diff --git a/.vscode/c_cpp_properties.json b/.vscode/c_cpp_properties.json
new file mode 100644
index 0000000..636377d
--- /dev/null
+++ b/.vscode/c_cpp_properties.json
@@ -0,0 +1,27 @@
+{
+  "version": 4,
+  "configurations": [
+    {
+      "name": "Linux",
+      "includePath": ["${workspaceFolder}/include"],
+      "defines": [],
+      "compilerPath": "/usr/bin/gcc",
+      "cStandard": "c89",
+      "intelliSenseMode": "linux-gcc-x64"
+    },
+    {
+      "name": "Mac",
+      "includePath": ["${workspaceFolder}/include"],
+      "compilerPath": "/usr/bin/clang",
+      "cStandard": "c89",
+      "intelliSenseMode": "macos-clang-x64"
+    },
+    {
+      "name": "Win",
+      "includePath": ["${workspaceFolder}\\include"],
+      "compilerPath": "C:\\Program Files\\LLVM\\bin\\clang.exe",
+      "cStandard": "c89",
+      "intelliSenseMode": "windows-clang-x64"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/.vscode/launch.json b/.vscode/launch.json
new file mode 100644
index 0000000..62a8c31
--- /dev/null
+++ b/.vscode/launch.json
@@ -0,0 +1,25 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "Executar no Windows",
+      "type": "cppvsdbg",
+      "request": "launch",
+      "program": "${workspaceFolder}/build/main.exe",
+      "cwd": "${workspaceFolder}",
+      "console": "externalTerminal",
+      "preLaunchTask": "build"
+    },
+    {
+      "name": "Executar no Linux/macOS",
+      "type": "cppdbg",
+      "request": "launch",
+      "program": "${workspaceFolder}/build/main",
+      "cwd": "${workspaceFolder}",
+      "MIMode": "gdb",
+      "stopAtEntry": false,
+      "console": "externalTerminal",
+      "preLaunchTask": "build"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/.vscode/tasks.json b/.vscode/tasks.json
new file mode 100644
index 0000000..3717796
--- /dev/null
+++ b/.vscode/tasks.json
@@ -0,0 +1,49 @@
+{
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "label": "Build with Watcom",
+      "type": "shell",
+      "command": "wcl386",
+      "args": [
+        "-I=include",
+        "src/main.c",
+        "-fe=bin/main_watcom.exe"
+      ],
+      "group": "build",
+      "problemMatcher": []
+    },
+    {
+      "label": "Build with VS2019",
+      "type": "shell",
+      "command": "cl",
+      "args": [
+        "/Iinclude",
+        "src\\main.c",
+        "/Fe:bin\\main_vs2019.exe"
+      ],
+      "options": {
+        "env": {
+          "PATH": "C:\\Program Files (x86)\\Microsoft Visual Studio\\2019\\Community\\VC\\Tools\\MSVC\\14.29.30133\\bin\\Hostx64\\x64;${env:PATH}"
+        }
+      },
+      "group": "build"
+    },
+    {
+      "label": "Build with VS2022",
+      "type": "shell",
+      "command": "cl",
+      "args": [
+        "/Iinclude",
+        "src\\main.c",
+        "/Fe:bin\\main_vs2022.exe"
+      ],
+      "options": {
+        "env": {
+          "PATH": "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.39.33519\\bin\\Hostx64\\x64;${env:PATH}"
+        }
+      },
+      "group": "build"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/bin/linux_64/Release/chrome-sandbox b/bin/linux_64/Release/chrome-sandbox
new file mode 100644
index 0000000..1bf2b32
Binary files /dev/null and b/bin/linux_64/Release/chrome-sandbox differ
diff --git a/bin/linux_64/Release/libcef.so b/bin/linux_64/Release/libcef.so
new file mode 100644
index 0000000..80668c7
Binary files /dev/null and b/bin/linux_64/Release/libcef.so differ
diff --git a/bin/linux_64/Release/natives_blob.bin b/bin/linux_64/Release/natives_blob.bin
new file mode 100644
index 0000000..b15de8f
--- /dev/null
+++ b/bin/linux_64/Release/natives_blob.bin
@@ -0,0 +1,19292 @@
+mirrors�t
+(function(a,b){
+"use strict";
+var c;
+var d=a.Array;
+var e=a.isNaN;
+var f=a.JSON.stringify;
+var g;
+var h;
+var i;
+var j=a.Math.min;
+var k=b.ImportNow("promise_status_symbol");
+var l=b.ImportNow("promise_value_symbol");
+var m;
+var n;
+var o;
+b.Import(function(p){
+c=p.ErrorToString;
+g=p.MakeError;
+h=p.MapEntries;
+i=p.MapIteratorNext;
+m=p.SetIteratorNext;
+n=p.SetValues;
+o=p.SymbolToString;
+});
+var q={
+UNDEFINED_TYPE:'undefined',
+NULL_TYPE:'null',
+BOOLEAN_TYPE:'boolean',
+NUMBER_TYPE:'number',
+STRING_TYPE:'string',
+SYMBOL_TYPE:'symbol',
+OBJECT_TYPE:'object',
+FUNCTION_TYPE:'function',
+REGEXP_TYPE:'regexp',
+ERROR_TYPE:'error',
+PROPERTY_TYPE:'property',
+INTERNAL_PROPERTY_TYPE:'internalProperty',
+FRAME_TYPE:'frame',
+SCRIPT_TYPE:'script',
+CONTEXT_TYPE:'context',
+SCOPE_TYPE:'scope',
+PROMISE_TYPE:'promise',
+MAP_TYPE:'map',
+SET_TYPE:'set',
+ITERATOR_TYPE:'iterator',
+GENERATOR_TYPE:'generator',
+}
+var r=0;
+var s=-1;
+var t=[];
+var u=true;
+function MirrorCacheIsEmpty(){
+return r==0&&t.length==0;
+}
+function ToggleMirrorCache(v){
+u=v;
+ClearMirrorCache();
+}
+function ClearMirrorCache(v){
+r=0;
+t=[];
+}
+function ObjectIsPromise(v){
+return(%_IsJSReceiver(v))&&
+!(%DebugGetProperty(v,k)===(void 0));
+}
+function MakeMirror(v,w){
+var x;
+if(!w&&u){
+for(var y in t){
+x=t[y];
+if(x.value()===v){
+return x;
+}
+if(x.isNumber()&&e(x.value())&&
+typeof v=='number'&&e(v)){
+return x;
+}
+}
+}
+if((v===(void 0))){
+x=new UndefinedMirror();
+}else if((v===null)){
+x=new NullMirror();
+}else if((typeof(v)==='boolean')){
+x=new BooleanMirror(v);
+}else if((typeof(v)==='number')){
+x=new NumberMirror(v);
+}else if((typeof(v)==='string')){
+x=new StringMirror(v);
+}else if((typeof(v)==='symbol')){
+x=new SymbolMirror(v);
+}else if((%_IsArray(v))){
+x=new ArrayMirror(v);
+}else if((%IsDate(v))){
+x=new DateMirror(v);
+}else if((%IsFunction(v))){
+x=new FunctionMirror(v);
+}else if((%_IsRegExp(v))){
+x=new RegExpMirror(v);
+}else if((%_ClassOf(v)==='Error')){
+x=new ErrorMirror(v);
+}else if((%_ClassOf(v)==='Script')){
+x=new ScriptMirror(v);
+}else if((%_ClassOf(v)==='Map')||(%_ClassOf(v)==='WeakMap')){
+x=new MapMirror(v);
+}else if((%_ClassOf(v)==='Set')||(%_ClassOf(v)==='WeakSet')){
+x=new SetMirror(v);
+}else if((%_ClassOf(v)==='Map Iterator')||(%_ClassOf(v)==='Set Iterator')){
+x=new IteratorMirror(v);
+}else if(ObjectIsPromise(v)){
+x=new PromiseMirror(v);
+}else if((%_ClassOf(v)==='Generator')){
+x=new GeneratorMirror(v);
+}else{
+x=new ObjectMirror(v,q.OBJECT_TYPE,w);
+}
+if(u)t[x.handle()]=x;
+return x;
+}
+function LookupMirror(z){
+if(!u){
+throw g(2,"Mirror cache is disabled");
+}
+return t[z];
+}
+function GetUndefinedMirror(){
+return MakeMirror((void 0));
+}
+function inherits(A,B){
+var C=function(){};
+C.prototype=B.prototype;
+A.super_=B.prototype;
+A.prototype=new C();
+A.prototype.constructor=A;
+}
+var D=80;
+var E={};
+E.Data=0;
+E.DataConstant=2;
+E.AccessorConstant=3;
+var F={};
+F.None=0;
+F.ReadOnly=1;
+F.DontEnum=2;
+F.DontDelete=4;
+var G={Global:0,
+Local:1,
+With:2,
+Closure:3,
+Catch:4,
+Block:5,
+Script:6};
+function Mirror(H){
+this.type_=H;
+}
+Mirror.prototype.type=function(){
+return this.type_;
+};
+Mirror.prototype.isValue=function(){
+return this instanceof ValueMirror;
+};
+Mirror.prototype.isUndefined=function(){
+return this instanceof UndefinedMirror;
+};
+Mirror.prototype.isNull=function(){
+return this instanceof NullMirror;
+};
+Mirror.prototype.isBoolean=function(){
+return this instanceof BooleanMirror;
+};
+Mirror.prototype.isNumber=function(){
+return this instanceof NumberMirror;
+};
+Mirror.prototype.isString=function(){
+return this instanceof StringMirror;
+};
+Mirror.prototype.isSymbol=function(){
+return this instanceof SymbolMirror;
+};
+Mirror.prototype.isObject=function(){
+return this instanceof ObjectMirror;
+};
+Mirror.prototype.isFunction=function(){
+return this instanceof FunctionMirror;
+};
+Mirror.prototype.isUnresolvedFunction=function(){
+return this instanceof UnresolvedFunctionMirror;
+};
+Mirror.prototype.isArray=function(){
+return this instanceof ArrayMirror;
+};
+Mirror.prototype.isDate=function(){
+return this instanceof DateMirror;
+};
+Mirror.prototype.isRegExp=function(){
+return this instanceof RegExpMirror;
+};
+Mirror.prototype.isError=function(){
+return this instanceof ErrorMirror;
+};
+Mirror.prototype.isPromise=function(){
+return this instanceof PromiseMirror;
+};
+Mirror.prototype.isGenerator=function(){
+return this instanceof GeneratorMirror;
+};
+Mirror.prototype.isProperty=function(){
+return this instanceof PropertyMirror;
+};
+Mirror.prototype.isInternalProperty=function(){
+return this instanceof InternalPropertyMirror;
+};
+Mirror.prototype.isFrame=function(){
+return this instanceof FrameMirror;
+};
+Mirror.prototype.isScript=function(){
+return this instanceof ScriptMirror;
+};
+Mirror.prototype.isContext=function(){
+return this instanceof ContextMirror;
+};
+Mirror.prototype.isScope=function(){
+return this instanceof ScopeMirror;
+};
+Mirror.prototype.isMap=function(){
+return this instanceof MapMirror;
+};
+Mirror.prototype.isSet=function(){
+return this instanceof SetMirror;
+};
+Mirror.prototype.isIterator=function(){
+return this instanceof IteratorMirror;
+};
+Mirror.prototype.allocateHandle_=function(){
+if(u)this.handle_=r++;
+};
+Mirror.prototype.allocateTransientHandle_=function(){
+this.handle_=s--;
+};
+Mirror.prototype.toText=function(){
+return"#<"+this.constructor.name+">";
+};
+function ValueMirror(H,v,I){
+%_Call(Mirror,this,H);
+this.value_=v;
+if(!I){
+this.allocateHandle_();
+}else{
+this.allocateTransientHandle_();
+}
+}
+inherits(ValueMirror,Mirror);
+Mirror.prototype.handle=function(){
+return this.handle_;
+};
+ValueMirror.prototype.isPrimitive=function(){
+var H=this.type();
+return H==='undefined'||
+H==='null'||
+H==='boolean'||
+H==='number'||
+H==='string'||
+H==='symbol';
+};
+ValueMirror.prototype.value=function(){
+return this.value_;
+};
+function UndefinedMirror(){
+%_Call(ValueMirror,this,q.UNDEFINED_TYPE,(void 0));
+}
+inherits(UndefinedMirror,ValueMirror);
+UndefinedMirror.prototype.toText=function(){
+return'undefined';
+};
+function NullMirror(){
+%_Call(ValueMirror,this,q.NULL_TYPE,null);
+}
+inherits(NullMirror,ValueMirror);
+NullMirror.prototype.toText=function(){
+return'null';
+};
+function BooleanMirror(v){
+%_Call(ValueMirror,this,q.BOOLEAN_TYPE,v);
+}
+inherits(BooleanMirror,ValueMirror);
+BooleanMirror.prototype.toText=function(){
+return this.value_?'true':'false';
+};
+function NumberMirror(v){
+%_Call(ValueMirror,this,q.NUMBER_TYPE,v);
+}
+inherits(NumberMirror,ValueMirror);
+NumberMirror.prototype.toText=function(){
+return %_NumberToString(this.value_);
+};
+function StringMirror(v){
+%_Call(ValueMirror,this,q.STRING_TYPE,v);
+}
+inherits(StringMirror,ValueMirror);
+StringMirror.prototype.length=function(){
+return this.value_.length;
+};
+StringMirror.prototype.getTruncatedValue=function(J){
+if(J!=-1&&this.length()>J){
+return this.value_.substring(0,J)+
+'... (length: '+this.length()+')';
+}
+return this.value_;
+};
+StringMirror.prototype.toText=function(){
+return this.getTruncatedValue(D);
+};
+function SymbolMirror(v){
+%_Call(ValueMirror,this,q.SYMBOL_TYPE,v);
+}
+inherits(SymbolMirror,ValueMirror);
+SymbolMirror.prototype.description=function(){
+return %SymbolDescription(%_ValueOf(this.value_));
+}
+SymbolMirror.prototype.toText=function(){
+return %_Call(o,this.value_);
+}
+function ObjectMirror(v,H,I){
+H=H||q.OBJECT_TYPE;
+%_Call(ValueMirror,this,H,v,I);
+}
+inherits(ObjectMirror,ValueMirror);
+ObjectMirror.prototype.className=function(){
+return %_ClassOf(this.value_);
+};
+ObjectMirror.prototype.constructorFunction=function(){
+return MakeMirror(%DebugGetProperty(this.value_,'constructor'));
+};
+ObjectMirror.prototype.prototypeObject=function(){
+return MakeMirror(%DebugGetProperty(this.value_,'prototype'));
+};
+ObjectMirror.prototype.protoObject=function(){
+return MakeMirror(%DebugGetPrototype(this.value_));
+};
+ObjectMirror.prototype.hasNamedInterceptor=function(){
+var K=%GetInterceptorInfo(this.value_);
+return(K&2)!=0;
+};
+ObjectMirror.prototype.hasIndexedInterceptor=function(){
+var K=%GetInterceptorInfo(this.value_);
+return(K&1)!=0;
+};
+ObjectMirror.prototype.propertyNames=function(){
+return %GetOwnPropertyKeys(this.value_,0);
+};
+ObjectMirror.prototype.properties=function(){
+var L=this.propertyNames();
+var M=new d(L.length);
+for(var N=0;N<L.length;N++){
+M[N]=this.property(L[N]);
+}
+return M;
+};
+ObjectMirror.prototype.internalProperties=function(){
+return ObjectMirror.GetInternalProperties(this.value_);
+}
+ObjectMirror.prototype.property=function(O){
+var P=%DebugGetPropertyDetails(this.value_,(%_ToName(O)));
+if(P){
+return new PropertyMirror(this,O,P);
+}
+return GetUndefinedMirror();
+};
+ObjectMirror.prototype.lookupProperty=function(v){
+var M=this.properties();
+for(var N=0;N<M.length;N++){
+var Q=M[N];
+if(Q.propertyType()!=E.AccessorConstant){
+if(Q.value_===v.value_){
+return Q;
+}
+}
+}
+return GetUndefinedMirror();
+};
+ObjectMirror.prototype.referencedBy=function(R){
+var S=%DebugReferencedBy(this.value_,
+Mirror.prototype,R||0);
+for(var N=0;N<S.length;N++){
+S[N]=MakeMirror(S[N]);
+}
+return S;
+};
+ObjectMirror.prototype.toText=function(){
+var O;
+var A=this.constructorFunction();
+if(!A.isFunction()){
+O=this.className();
+}else{
+O=A.name();
+if(!O){
+O=this.className();
+}
+}
+return'#<'+O+'>';
+};
+ObjectMirror.GetInternalProperties=function(v){
+var M=%DebugGetInternalProperties(v);
+var S=[];
+for(var N=0;N<M.length;N+=2){
+S.push(new InternalPropertyMirror(M[N],M[N+1]));
+}
+return S;
+}
+function FunctionMirror(v){
+%_Call(ObjectMirror,this,v,q.FUNCTION_TYPE);
+this.resolved_=true;
+}
+inherits(FunctionMirror,ObjectMirror);
+FunctionMirror.prototype.resolved=function(){
+return this.resolved_;
+};
+FunctionMirror.prototype.name=function(){
+return %FunctionGetName(this.value_);
+};
+FunctionMirror.prototype.debugName=function(){
+return %FunctionGetDebugName(this.value_);
+}
+FunctionMirror.prototype.inferredName=function(){
+return %FunctionGetInferredName(this.value_);
+};
+FunctionMirror.prototype.source=function(){
+if(this.resolved()){
+return %FunctionToString(this.value_);
+}
+};
+FunctionMirror.prototype.script=function(){
+if(this.resolved()){
+if(this.script_){
+return this.script_;
+}
+var T=%FunctionGetScript(this.value_);
+if(T){
+return this.script_=MakeMirror(T);
+}
+}
+};
+FunctionMirror.prototype.sourcePosition_=function(){
+if(this.resolved()){
+return %FunctionGetScriptSourcePosition(this.value_);
+}
+};
+FunctionMirror.prototype.sourceLocation=function(){
+if(this.resolved()){
+var T=this.script();
+if(T){
+return T.locationFromPosition(this.sourcePosition_(),true);
+}
+}
+};
+FunctionMirror.prototype.constructedBy=function(U){
+if(this.resolved()){
+var S=%DebugConstructedBy(this.value_,U||0);
+for(var N=0;N<S.length;N++){
+S[N]=MakeMirror(S[N]);
+}
+return S;
+}else{
+return[];
+}
+};
+FunctionMirror.prototype.scopeCount=function(){
+if(this.resolved()){
+if((this.scopeCount_===(void 0))){
+this.scopeCount_=%GetFunctionScopeCount(this.value());
+}
+return this.scopeCount_;
+}else{
+return 0;
+}
+};
+FunctionMirror.prototype.scope=function(V){
+if(this.resolved()){
+return new ScopeMirror((void 0),this,V);
+}
+};
+FunctionMirror.prototype.toText=function(){
+return this.source();
+};
+FunctionMirror.prototype.context=function(){
+if(this.resolved()){
+if(!this._context)
+this._context=new ContextMirror(%FunctionGetContextData(this.value_));
+return this._context;
+}
+};
+function UnresolvedFunctionMirror(v){
+%_Call(ValueMirror,this,q.FUNCTION_TYPE,v);
+this.propertyCount_=0;
+this.elementCount_=0;
+this.resolved_=false;
+}
+inherits(UnresolvedFunctionMirror,FunctionMirror);
+UnresolvedFunctionMirror.prototype.className=function(){
+return'Function';
+};
+UnresolvedFunctionMirror.prototype.constructorFunction=function(){
+return GetUndefinedMirror();
+};
+UnresolvedFunctionMirror.prototype.prototypeObject=function(){
+return GetUndefinedMirror();
+};
+UnresolvedFunctionMirror.prototype.protoObject=function(){
+return GetUndefinedMirror();
+};
+UnresolvedFunctionMirror.prototype.name=function(){
+return this.value_;
+};
+UnresolvedFunctionMirror.prototype.inferredName=function(){
+return(void 0);
+};
+UnresolvedFunctionMirror.prototype.propertyNames=function(W,X){
+return[];
+};
+function ArrayMirror(v){
+%_Call(ObjectMirror,this,v);
+}
+inherits(ArrayMirror,ObjectMirror);
+ArrayMirror.prototype.length=function(){
+return this.value_.length;
+};
+ArrayMirror.prototype.indexedPropertiesFromRange=function(opt_from_index,
+opt_to_index){
+var Y=opt_from_index||0;
+var Z=opt_to_index||this.length()-1;
+if(Y>Z)return new d();
+var aa=new d(Z-Y+1);
+for(var N=Y;N<=Z;N++){
+var P=%DebugGetPropertyDetails(this.value_,(%_ToString(N)));
+var v;
+if(P){
+v=new PropertyMirror(this,N,P);
+}else{
+v=GetUndefinedMirror();
+}
+aa[N-Y]=v;
+}
+return aa;
+};
+function DateMirror(v){
+%_Call(ObjectMirror,this,v);
+}
+inherits(DateMirror,ObjectMirror);
+DateMirror.prototype.toText=function(){
+var ab=f(this.value_);
+return ab.substring(1,ab.length-1);
+};
+function RegExpMirror(v){
+%_Call(ObjectMirror,this,v,q.REGEXP_TYPE);
+}
+inherits(RegExpMirror,ObjectMirror);
+RegExpMirror.prototype.source=function(){
+return this.value_.source;
+};
+RegExpMirror.prototype.global=function(){
+return this.value_.global;
+};
+RegExpMirror.prototype.ignoreCase=function(){
+return this.value_.ignoreCase;
+};
+RegExpMirror.prototype.multiline=function(){
+return this.value_.multiline;
+};
+RegExpMirror.prototype.sticky=function(){
+return this.value_.sticky;
+};
+RegExpMirror.prototype.unicode=function(){
+return this.value_.unicode;
+};
+RegExpMirror.prototype.toText=function(){
+return"/"+this.source()+"/";
+};
+function ErrorMirror(v){
+%_Call(ObjectMirror,this,v,q.ERROR_TYPE);
+}
+inherits(ErrorMirror,ObjectMirror);
+ErrorMirror.prototype.message=function(){
+return this.value_.message;
+};
+ErrorMirror.prototype.toText=function(){
+var ac;
+try{
+ac=%_Call(c,this.value_);
+}catch(e){
+ac='#<Error>';
+}
+return ac;
+};
+function PromiseMirror(v){
+%_Call(ObjectMirror,this,v,q.PROMISE_TYPE);
+}
+inherits(PromiseMirror,ObjectMirror);
+function PromiseGetStatus_(v){
+var ad=%DebugGetProperty(v,k);
+if(ad==0)return"pending";
+if(ad==1)return"resolved";
+return"rejected";
+}
+function PromiseGetValue_(v){
+return %DebugGetProperty(v,l);
+}
+PromiseMirror.prototype.status=function(){
+return PromiseGetStatus_(this.value_);
+};
+PromiseMirror.prototype.promiseValue=function(){
+return MakeMirror(PromiseGetValue_(this.value_));
+};
+function MapMirror(v){
+%_Call(ObjectMirror,this,v,q.MAP_TYPE);
+}
+inherits(MapMirror,ObjectMirror);
+MapMirror.prototype.entries=function(ae){
+var S=[];
+if((%_ClassOf(this.value_)==='WeakMap')){
+var af=%GetWeakMapEntries(this.value_,ae||0);
+for(var N=0;N<af.length;N+=2){
+S.push({
+key:af[N],
+value:af[N+1]
+});
+}
+return S;
+}
+var ag=%_Call(h,this.value_);
+var ah;
+while((!ae||S.length<ae)&&
+!(ah=ag.next()).done){
+S.push({
+key:ah.value[0],
+value:ah.value[1]
+});
+}
+return S;
+};
+function SetMirror(v){
+%_Call(ObjectMirror,this,v,q.SET_TYPE);
+}
+inherits(SetMirror,ObjectMirror);
+function IteratorGetValues_(ag,ai,ae){
+var S=[];
+var ah;
+while((!ae||S.length<ae)&&
+!(ah=%_Call(ai,ag)).done){
+S.push(ah.value);
+}
+return S;
+}
+SetMirror.prototype.values=function(ae){
+if((%_ClassOf(this.value_)==='WeakSet')){
+return %GetWeakSetValues(this.value_,ae||0);
+}
+var ag=%_Call(n,this.value_);
+return IteratorGetValues_(ag,m,ae);
+};
+function IteratorMirror(v){
+%_Call(ObjectMirror,this,v,q.ITERATOR_TYPE);
+}
+inherits(IteratorMirror,ObjectMirror);
+IteratorMirror.prototype.preview=function(ae){
+if((%_ClassOf(this.value_)==='Map Iterator')){
+return IteratorGetValues_(%MapIteratorClone(this.value_),
+i,
+ae);
+}else if((%_ClassOf(this.value_)==='Set Iterator')){
+return IteratorGetValues_(%SetIteratorClone(this.value_),
+m,
+ae);
+}
+};
+function GeneratorMirror(v){
+%_Call(ObjectMirror,this,v,q.GENERATOR_TYPE);
+}
+inherits(GeneratorMirror,ObjectMirror);
+function GeneratorGetStatus_(v){
+var aj=%GeneratorGetContinuation(v);
+if(aj<0)return"running";
+if(aj==0)return"closed";
+return"suspended";
+}
+GeneratorMirror.prototype.status=function(){
+return GeneratorGetStatus_(this.value_);
+};
+GeneratorMirror.prototype.sourcePosition_=function(){
+return %GeneratorGetSourcePosition(this.value_);
+};
+GeneratorMirror.prototype.sourceLocation=function(){
+var ak=this.sourcePosition_();
+if(!(ak===(void 0))){
+var T=this.func().script();
+if(T){
+return T.locationFromPosition(ak,true);
+}
+}
+};
+GeneratorMirror.prototype.func=function(){
+if(!this.func_){
+this.func_=MakeMirror(%GeneratorGetFunction(this.value_));
+}
+return this.func_;
+};
+GeneratorMirror.prototype.receiver=function(){
+if(!this.receiver_){
+this.receiver_=MakeMirror(%GeneratorGetReceiver(this.value_));
+}
+return this.receiver_;
+};
+function PropertyMirror(x,O,P){
+%_Call(Mirror,this,q.PROPERTY_TYPE);
+this.mirror_=x;
+this.name_=O;
+this.value_=P[0];
+this.details_=P[1];
+this.is_interceptor_=P[2];
+if(P.length>3){
+this.exception_=P[3];
+this.getter_=P[4];
+this.setter_=P[5];
+}
+}
+inherits(PropertyMirror,Mirror);
+PropertyMirror.prototype.isReadOnly=function(){
+return(this.attributes()&F.ReadOnly)!=0;
+};
+PropertyMirror.prototype.isEnum=function(){
+return(this.attributes()&F.DontEnum)==0;
+};
+PropertyMirror.prototype.canDelete=function(){
+return(this.attributes()&F.DontDelete)==0;
+};
+PropertyMirror.prototype.name=function(){
+return this.name_;
+};
+PropertyMirror.prototype.isIndexed=function(){
+for(var N=0;N<this.name_.length;N++){
+if(this.name_[N]<'0'||'9'<this.name_[N]){
+return false;
+}
+}
+return true;
+};
+PropertyMirror.prototype.value=function(){
+return MakeMirror(this.value_,false);
+};
+PropertyMirror.prototype.isException=function(){
+return this.exception_?true:false;
+};
+PropertyMirror.prototype.attributes=function(){
+return %DebugPropertyAttributesFromDetails(this.details_);
+};
+PropertyMirror.prototype.propertyType=function(){
+return %DebugPropertyTypeFromDetails(this.details_);
+};
+PropertyMirror.prototype.insertionIndex=function(){
+return %DebugPropertyIndexFromDetails(this.details_);
+};
+PropertyMirror.prototype.hasGetter=function(){
+return this.getter_?true:false;
+};
+PropertyMirror.prototype.hasSetter=function(){
+return this.setter_?true:false;
+};
+PropertyMirror.prototype.getter=function(){
+if(this.hasGetter()){
+return MakeMirror(this.getter_);
+}else{
+return GetUndefinedMirror();
+}
+};
+PropertyMirror.prototype.setter=function(){
+if(this.hasSetter()){
+return MakeMirror(this.setter_);
+}else{
+return GetUndefinedMirror();
+}
+};
+PropertyMirror.prototype.isNative=function(){
+return this.is_interceptor_||
+((this.propertyType()==E.AccessorConstant)&&
+!this.hasGetter()&&!this.hasSetter());
+};
+function InternalPropertyMirror(O,v){
+%_Call(Mirror,this,q.INTERNAL_PROPERTY_TYPE);
+this.name_=O;
+this.value_=v;
+}
+inherits(InternalPropertyMirror,Mirror);
+InternalPropertyMirror.prototype.name=function(){
+return this.name_;
+};
+InternalPropertyMirror.prototype.value=function(){
+return MakeMirror(this.value_,false);
+};
+var al=0;
+var am=1;
+var an=2;
+var ao=3;
+var ap=4;
+var aq=5;
+var ar=6;
+var as=7;
+var at=8;
+var au=9;
+var av=0;
+var aw=1;
+var ax=2;
+var ay=1<<0;
+var az=1<<1;
+var aA=7<<2;
+function FrameDetails(aB,V){
+this.break_id_=aB;
+this.details_=%GetFrameDetails(aB,V);
+}
+FrameDetails.prototype.frameId=function(){
+%CheckExecutionState(this.break_id_);
+return this.details_[al];
+};
+FrameDetails.prototype.receiver=function(){
+%CheckExecutionState(this.break_id_);
+return this.details_[am];
+};
+FrameDetails.prototype.func=function(){
+%CheckExecutionState(this.break_id_);
+return this.details_[an];
+};
+FrameDetails.prototype.isConstructCall=function(){
+%CheckExecutionState(this.break_id_);
+return this.details_[ar];
+};
+FrameDetails.prototype.isAtReturn=function(){
+%CheckExecutionState(this.break_id_);
+return this.details_[as];
+};
+FrameDetails.prototype.isDebuggerFrame=function(){
+%CheckExecutionState(this.break_id_);
+var aC=ay;
+return(this.details_[at]&aC)==aC;
+};
+FrameDetails.prototype.isOptimizedFrame=function(){
+%CheckExecutionState(this.break_id_);
+var aC=az;
+return(this.details_[at]&aC)==aC;
+};
+FrameDetails.prototype.isInlinedFrame=function(){
+return this.inlinedFrameIndex()>0;
+};
+FrameDetails.prototype.inlinedFrameIndex=function(){
+%CheckExecutionState(this.break_id_);
+var aC=aA;
+return(this.details_[at]&aC)>>2;
+};
+FrameDetails.prototype.argumentCount=function(){
+%CheckExecutionState(this.break_id_);
+return this.details_[ao];
+};
+FrameDetails.prototype.argumentName=function(V){
+%CheckExecutionState(this.break_id_);
+if(V>=0&&V<this.argumentCount()){
+return this.details_[au+
+V*ax+
+av];
+}
+};
+FrameDetails.prototype.argumentValue=function(V){
+%CheckExecutionState(this.break_id_);
+if(V>=0&&V<this.argumentCount()){
+return this.details_[au+
+V*ax+
+aw];
+}
+};
+FrameDetails.prototype.localCount=function(){
+%CheckExecutionState(this.break_id_);
+return this.details_[ap];
+};
+FrameDetails.prototype.sourcePosition=function(){
+%CheckExecutionState(this.break_id_);
+return this.details_[aq];
+};
+FrameDetails.prototype.localName=function(V){
+%CheckExecutionState(this.break_id_);
+if(V>=0&&V<this.localCount()){
+var aD=au+
+this.argumentCount()*ax;
+return this.details_[aD+
+V*ax+
+av];
+}
+};
+FrameDetails.prototype.localValue=function(V){
+%CheckExecutionState(this.break_id_);
+if(V>=0&&V<this.localCount()){
+var aD=au+
+this.argumentCount()*ax;
+return this.details_[aD+
+V*ax+
+aw];
+}
+};
+FrameDetails.prototype.returnValue=function(){
+%CheckExecutionState(this.break_id_);
+var aE=
+au+
+(this.argumentCount()+this.localCount())*ax;
+if(this.details_[as]){
+return this.details_[aE];
+}
+};
+FrameDetails.prototype.scopeCount=function(){
+if((this.scopeCount_===(void 0))){
+this.scopeCount_=%GetScopeCount(this.break_id_,this.frameId());
+}
+return this.scopeCount_;
+};
+function FrameMirror(aB,V){
+%_Call(Mirror,this,q.FRAME_TYPE);
+this.break_id_=aB;
+this.index_=V;
+this.details_=new FrameDetails(aB,V);
+}
+inherits(FrameMirror,Mirror);
+FrameMirror.prototype.details=function(){
+return this.details_;
+};
+FrameMirror.prototype.index=function(){
+return this.index_;
+};
+FrameMirror.prototype.func=function(){
+if(this.func_){
+return this.func_;
+}
+var aC=this.details_.func();
+if((%IsFunction(aC))){
+return this.func_=MakeMirror(aC);
+}else{
+return new UnresolvedFunctionMirror(aC);
+}
+};
+FrameMirror.prototype.receiver=function(){
+return MakeMirror(this.details_.receiver());
+};
+FrameMirror.prototype.isConstructCall=function(){
+return this.details_.isConstructCall();
+};
+FrameMirror.prototype.isAtReturn=function(){
+return this.details_.isAtReturn();
+};
+FrameMirror.prototype.isDebuggerFrame=function(){
+return this.details_.isDebuggerFrame();
+};
+FrameMirror.prototype.isOptimizedFrame=function(){
+return this.details_.isOptimizedFrame();
+};
+FrameMirror.prototype.isInlinedFrame=function(){
+return this.details_.isInlinedFrame();
+};
+FrameMirror.prototype.inlinedFrameIndex=function(){
+return this.details_.inlinedFrameIndex();
+};
+FrameMirror.prototype.argumentCount=function(){
+return this.details_.argumentCount();
+};
+FrameMirror.prototype.argumentName=function(V){
+return this.details_.argumentName(V);
+};
+FrameMirror.prototype.argumentValue=function(V){
+return MakeMirror(this.details_.argumentValue(V));
+};
+FrameMirror.prototype.localCount=function(){
+return this.details_.localCount();
+};
+FrameMirror.prototype.localName=function(V){
+return this.details_.localName(V);
+};
+FrameMirror.prototype.localValue=function(V){
+return MakeMirror(this.details_.localValue(V));
+};
+FrameMirror.prototype.returnValue=function(){
+return MakeMirror(this.details_.returnValue());
+};
+FrameMirror.prototype.sourcePosition=function(){
+return this.details_.sourcePosition();
+};
+FrameMirror.prototype.sourceLocation=function(){
+var aF=this.func();
+if(aF.resolved()){
+var T=aF.script();
+if(T){
+return T.locationFromPosition(this.sourcePosition(),true);
+}
+}
+};
+FrameMirror.prototype.sourceLine=function(){
+var aG=this.sourceLocation();
+if(aG){
+return aG.line;
+}
+};
+FrameMirror.prototype.sourceColumn=function(){
+var aG=this.sourceLocation();
+if(aG){
+return aG.column;
+}
+};
+FrameMirror.prototype.sourceLineText=function(){
+var aG=this.sourceLocation();
+if(aG){
+return aG.sourceText();
+}
+};
+FrameMirror.prototype.scopeCount=function(){
+return this.details_.scopeCount();
+};
+FrameMirror.prototype.scope=function(V){
+return new ScopeMirror(this,(void 0),V);
+};
+FrameMirror.prototype.allScopes=function(aH){
+var aI=%GetAllScopesDetails(this.break_id_,
+this.details_.frameId(),
+this.details_.inlinedFrameIndex(),
+!!aH);
+var S=[];
+for(var N=0;N<aI.length;++N){
+S.push(new ScopeMirror(this,(void 0),N,aI[N]));
+}
+return S;
+};
+FrameMirror.prototype.evaluate=function(source,disable_break,
+opt_context_object){
+return MakeMirror(%DebugEvaluate(this.break_id_,
+this.details_.frameId(),
+this.details_.inlinedFrameIndex(),
+source,
+(!!(disable_break)),
+opt_context_object));
+};
+FrameMirror.prototype.invocationText=function(){
+var S='';
+var aF=this.func();
+var aJ=this.receiver();
+if(this.isConstructCall()){
+S+='new ';
+S+=aF.name()?aF.name():'[anonymous]';
+}else if(this.isDebuggerFrame()){
+S+='[debugger]';
+}else{
+var aK=
+!aJ.className||(aJ.className()!='global');
+if(aK){
+S+=aJ.toText();
+}
+var Q=GetUndefinedMirror();
+if(aJ.isObject()){
+for(var aL=aJ;
+!aL.isNull()&&Q.isUndefined();
+aL=aL.protoObject()){
+Q=aL.lookupProperty(aF);
+}
+}
+if(!Q.isUndefined()){
+if(!Q.isIndexed()){
+if(aK){
+S+='.';
+}
+S+=Q.name();
+}else{
+S+='[';
+S+=Q.name();
+S+=']';
+}
+if(aF.name()&&aF.name()!=Q.name()){
+S+='(aka '+aF.name()+')';
+}
+}else{
+if(aK){
+S+='.';
+}
+S+=aF.name()?aF.name():'[anonymous]';
+}
+}
+if(!this.isDebuggerFrame()){
+S+='(';
+for(var N=0;N<this.argumentCount();N++){
+if(N!=0)S+=', ';
+if(this.argumentName(N)){
+S+=this.argumentName(N);
+S+='=';
+}
+S+=this.argumentValue(N).toText();
+}
+S+=')';
+}
+if(this.isAtReturn()){
+S+=' returning ';
+S+=this.returnValue().toText();
+}
+return S;
+};
+FrameMirror.prototype.sourceAndPositionText=function(){
+var S='';
+var aF=this.func();
+if(aF.resolved()){
+var T=aF.script();
+if(T){
+if(T.name()){
+S+=T.name();
+}else{
+S+='[unnamed]';
+}
+if(!this.isDebuggerFrame()){
+var aG=this.sourceLocation();
+S+=' line ';
+S+=!(aG===(void 0))?(aG.line+1):'?';
+S+=' column ';
+S+=!(aG===(void 0))?(aG.column+1):'?';
+if(!(this.sourcePosition()===(void 0))){
+S+=' (position '+(this.sourcePosition()+1)+')';
+}
+}
+}else{
+S+='[no source]';
+}
+}else{
+S+='[unresolved]';
+}
+return S;
+};
+FrameMirror.prototype.localsText=function(){
+var S='';
+var aM=this.localCount();
+if(aM>0){
+for(var N=0;N<aM;++N){
+S+='      var ';
+S+=this.localName(N);
+S+=' = ';
+S+=this.localValue(N).toText();
+if(N<aM-1)S+='\n';
+}
+}
+return S;
+};
+FrameMirror.prototype.restart=function(){
+var S=%LiveEditRestartFrame(this.break_id_,this.index_);
+if((S===(void 0))){
+S="Failed to find requested frame";
+}
+return S;
+};
+FrameMirror.prototype.toText=function(aN){
+var S='';
+S+='#'+(this.index()<=9?'0':'')+this.index();
+S+=' ';
+S+=this.invocationText();
+S+=' ';
+S+=this.sourceAndPositionText();
+if(aN){
+S+='\n';
+S+=this.localsText();
+}
+return S;
+};
+var aO=0;
+var aP=1;
+var aQ=2;
+var aR=3;
+var aS=4;
+var aT=5;
+function ScopeDetails(aU,aV,V,aW){
+if(aU){
+this.break_id_=aU.break_id_;
+this.details_=aW||
+%GetScopeDetails(aU.break_id_,
+aU.details_.frameId(),
+aU.details_.inlinedFrameIndex(),
+V);
+this.frame_id_=aU.details_.frameId();
+this.inlined_frame_id_=aU.details_.inlinedFrameIndex();
+}else{
+this.details_=aW||%GetFunctionScopeDetails(aV.value(),V);
+this.fun_value_=aV.value();
+this.break_id_=(void 0);
+}
+this.index_=V;
+}
+ScopeDetails.prototype.type=function(){
+if(!(this.break_id_===(void 0))){
+%CheckExecutionState(this.break_id_);
+}
+return this.details_[aO];
+};
+ScopeDetails.prototype.object=function(){
+if(!(this.break_id_===(void 0))){
+%CheckExecutionState(this.break_id_);
+}
+return this.details_[aP];
+};
+ScopeDetails.prototype.name=function(){
+if(!(this.break_id_===(void 0))){
+%CheckExecutionState(this.break_id_);
+}
+return this.details_[aQ];
+};
+ScopeDetails.prototype.startPosition=function(){
+if(!(this.break_id_===(void 0))){
+%CheckExecutionState(this.break_id_);
+}
+return this.details_[aR];
+}
+ScopeDetails.prototype.endPosition=function(){
+if(!(this.break_id_===(void 0))){
+%CheckExecutionState(this.break_id_);
+}
+return this.details_[aS];
+}
+ScopeDetails.prototype.func=function(){
+if(!(this.break_id_===(void 0))){
+%CheckExecutionState(this.break_id_);
+}
+return this.details_[aT];
+}
+ScopeDetails.prototype.setVariableValueImpl=function(O,aX){
+var aY;
+if(!(this.break_id_===(void 0))){
+%CheckExecutionState(this.break_id_);
+aY=%SetScopeVariableValue(this.break_id_,this.frame_id_,
+this.inlined_frame_id_,this.index_,O,aX);
+}else{
+aY=%SetScopeVariableValue(this.fun_value_,null,null,this.index_,
+O,aX);
+}
+if(!aY)throw g(2,"Failed to set variable value");
+};
+function ScopeMirror(aU,aV,V,aW){
+%_Call(Mirror,this,q.SCOPE_TYPE);
+if(aU){
+this.frame_index_=aU.index_;
+}else{
+this.frame_index_=(void 0);
+}
+this.scope_index_=V;
+this.details_=new ScopeDetails(aU,aV,V,aW);
+}
+inherits(ScopeMirror,Mirror);
+ScopeMirror.prototype.details=function(){
+return this.details_;
+};
+ScopeMirror.prototype.frameIndex=function(){
+return this.frame_index_;
+};
+ScopeMirror.prototype.scopeIndex=function(){
+return this.scope_index_;
+};
+ScopeMirror.prototype.scopeType=function(){
+return this.details_.type();
+};
+ScopeMirror.prototype.scopeObject=function(){
+var I=this.scopeType()==G.Local||
+this.scopeType()==G.Closure||
+this.scopeType()==G.Script;
+return MakeMirror(this.details_.object(),I);
+};
+ScopeMirror.prototype.setVariableValue=function(O,aX){
+this.details_.setVariableValueImpl(O,aX);
+};
+function ScriptMirror(T){
+%_Call(Mirror,this,q.SCRIPT_TYPE);
+this.script_=T;
+this.context_=new ContextMirror(T.context_data);
+this.allocateHandle_();
+}
+inherits(ScriptMirror,Mirror);
+ScriptMirror.prototype.value=function(){
+return this.script_;
+};
+ScriptMirror.prototype.name=function(){
+return this.script_.name||this.script_.nameOrSourceURL();
+};
+ScriptMirror.prototype.id=function(){
+return this.script_.id;
+};
+ScriptMirror.prototype.source=function(){
+return this.script_.source;
+};
+ScriptMirror.prototype.setSource=function(aZ){
+%DebugSetScriptSource(this.script_,aZ);
+};
+ScriptMirror.prototype.lineOffset=function(){
+return this.script_.line_offset;
+};
+ScriptMirror.prototype.columnOffset=function(){
+return this.script_.column_offset;
+};
+ScriptMirror.prototype.data=function(){
+return this.script_.data;
+};
+ScriptMirror.prototype.scriptType=function(){
+return this.script_.type;
+};
+ScriptMirror.prototype.compilationType=function(){
+return this.script_.compilation_type;
+};
+ScriptMirror.prototype.lineCount=function(){
+return this.script_.lineCount();
+};
+ScriptMirror.prototype.locationFromPosition=function(
+position,include_resource_offset){
+return this.script_.locationFromPosition(position,include_resource_offset);
+};
+ScriptMirror.prototype.sourceSlice=function(ba,bb){
+return this.script_.sourceSlice(ba,bb);
+};
+ScriptMirror.prototype.context=function(){
+return this.context_;
+};
+ScriptMirror.prototype.evalFromScript=function(){
+return MakeMirror(this.script_.eval_from_script);
+};
+ScriptMirror.prototype.evalFromFunctionName=function(){
+return MakeMirror(this.script_.eval_from_function_name);
+};
+ScriptMirror.prototype.evalFromLocation=function(){
+var bc=this.evalFromScript();
+if(!bc.isUndefined()){
+var bd=this.script_.eval_from_script_position;
+return bc.locationFromPosition(bd,true);
+}
+};
+ScriptMirror.prototype.toText=function(){
+var S='';
+S+=this.name();
+S+=' (lines: ';
+if(this.lineOffset()>0){
+S+=this.lineOffset();
+S+='-';
+S+=this.lineOffset()+this.lineCount()-1;
+}else{
+S+=this.lineCount();
+}
+S+=')';
+return S;
+};
+function ContextMirror(be){
+%_Call(Mirror,this,q.CONTEXT_TYPE);
+this.data_=be;
+this.allocateHandle_();
+}
+inherits(ContextMirror,Mirror);
+ContextMirror.prototype.data=function(){
+return this.data_;
+};
+function MakeMirrorSerializer(P,bf){
+return new JSONProtocolSerializer(P,bf);
+}
+function JSONProtocolSerializer(P,bf){
+this.details_=P;
+this.options_=bf;
+this.mirrors_=[];
+}
+JSONProtocolSerializer.prototype.serializeReference=function(x){
+return this.serialize_(x,true,true);
+};
+JSONProtocolSerializer.prototype.serializeValue=function(x){
+var bg=this.serialize_(x,false,true);
+return bg;
+};
+JSONProtocolSerializer.prototype.serializeReferencedObjects=function(){
+var bh=[];
+var bi=this.mirrors_.length;
+for(var N=0;N<bi;N++){
+bh.push(this.serialize_(this.mirrors_[N],false,false));
+}
+return bh;
+};
+JSONProtocolSerializer.prototype.includeSource_=function(){
+return this.options_&&this.options_.includeSource;
+};
+JSONProtocolSerializer.prototype.inlineRefs_=function(){
+return this.options_&&this.options_.inlineRefs;
+};
+JSONProtocolSerializer.prototype.maxStringLength_=function(){
+if((this.options_===(void 0))||
+(this.options_.maxStringLength===(void 0))){
+return D;
+}
+return this.options_.maxStringLength;
+};
+JSONProtocolSerializer.prototype.add_=function(x){
+for(var N=0;N<this.mirrors_.length;N++){
+if(this.mirrors_[N]===x){
+return;
+}
+}
+this.mirrors_.push(x);
+};
+JSONProtocolSerializer.prototype.serializeReferenceWithDisplayData_=
+function(x){
+var bj={};
+bj.ref=x.handle();
+bj.type=x.type();
+switch(x.type()){
+case q.UNDEFINED_TYPE:
+case q.NULL_TYPE:
+case q.BOOLEAN_TYPE:
+case q.NUMBER_TYPE:
+bj.value=x.value();
+break;
+case q.STRING_TYPE:
+bj.value=x.getTruncatedValue(this.maxStringLength_());
+break;
+case q.SYMBOL_TYPE:
+bj.description=x.description();
+break;
+case q.FUNCTION_TYPE:
+bj.name=x.name();
+bj.inferredName=x.inferredName();
+if(x.script()){
+bj.scriptId=x.script().id();
+}
+break;
+case q.ERROR_TYPE:
+case q.REGEXP_TYPE:
+bj.value=x.toText();
+break;
+case q.OBJECT_TYPE:
+bj.className=x.className();
+break;
+}
+return bj;
+};
+JSONProtocolSerializer.prototype.serialize_=function(x,reference,
+P){
+if(reference&&
+(x.isValue()||x.isScript()||x.isContext())){
+if(this.inlineRefs_()&&x.isValue()){
+return this.serializeReferenceWithDisplayData_(x);
+}else{
+this.add_(x);
+return{'ref':x.handle()};
+}
+}
+var bh={};
+if(x.isValue()||x.isScript()||x.isContext()){
+bh.handle=x.handle();
+}
+bh.type=x.type();
+switch(x.type()){
+case q.UNDEFINED_TYPE:
+case q.NULL_TYPE:
+break;
+case q.BOOLEAN_TYPE:
+bh.value=x.value();
+break;
+case q.NUMBER_TYPE:
+bh.value=NumberToJSON_(x.value());
+break;
+case q.STRING_TYPE:
+if(this.maxStringLength_()!=-1&&
+x.length()>this.maxStringLength_()){
+var bk=x.getTruncatedValue(this.maxStringLength_());
+bh.value=bk;
+bh.fromIndex=0;
+bh.toIndex=this.maxStringLength_();
+}else{
+bh.value=x.value();
+}
+bh.length=x.length();
+break;
+case q.SYMBOL_TYPE:
+bh.description=x.description();
+break;
+case q.OBJECT_TYPE:
+case q.FUNCTION_TYPE:
+case q.ERROR_TYPE:
+case q.REGEXP_TYPE:
+case q.PROMISE_TYPE:
+case q.GENERATOR_TYPE:
+this.serializeObject_(x,bh,P);
+break;
+case q.PROPERTY_TYPE:
+case q.INTERNAL_PROPERTY_TYPE:
+throw g(2,
+'PropertyMirror cannot be serialized independently');
+break;
+case q.FRAME_TYPE:
+this.serializeFrame_(x,bh);
+break;
+case q.SCOPE_TYPE:
+this.serializeScope_(x,bh);
+break;
+case q.SCRIPT_TYPE:
+if(x.name()){
+bh.name=x.name();
+}
+bh.id=x.id();
+bh.lineOffset=x.lineOffset();
+bh.columnOffset=x.columnOffset();
+bh.lineCount=x.lineCount();
+if(x.data()){
+bh.data=x.data();
+}
+if(this.includeSource_()){
+bh.source=x.source();
+}else{
+var bl=x.source().substring(0,80);
+bh.sourceStart=bl;
+}
+bh.sourceLength=x.source().length;
+bh.scriptType=x.scriptType();
+bh.compilationType=x.compilationType();
+if(x.compilationType()==1&&
+x.evalFromScript()){
+bh.evalFromScript=
+this.serializeReference(x.evalFromScript());
+var bm=x.evalFromLocation();
+if(bm){
+bh.evalFromLocation={line:bm.line,
+column:bm.column};
+}
+if(x.evalFromFunctionName()){
+bh.evalFromFunctionName=x.evalFromFunctionName();
+}
+}
+if(x.context()){
+bh.context=this.serializeReference(x.context());
+}
+break;
+case q.CONTEXT_TYPE:
+bh.data=x.data();
+break;
+}
+bh.text=x.toText();
+return bh;
+};
+JSONProtocolSerializer.prototype.serializeObject_=function(x,bh,
+P){
+bh.className=x.className();
+bh.constructorFunction=
+this.serializeReference(x.constructorFunction());
+bh.protoObject=this.serializeReference(x.protoObject());
+bh.prototypeObject=this.serializeReference(x.prototypeObject());
+if(x.hasNamedInterceptor()){
+bh.namedInterceptor=true;
+}
+if(x.hasIndexedInterceptor()){
+bh.indexedInterceptor=true;
+}
+if(x.isFunction()){
+bh.name=x.name();
+if(!(x.inferredName()===(void 0))){
+bh.inferredName=x.inferredName();
+}
+bh.resolved=x.resolved();
+if(x.resolved()){
+bh.source=x.source();
+}
+if(x.script()){
+bh.script=this.serializeReference(x.script());
+bh.scriptId=x.script().id();
+serializeLocationFields(x.sourceLocation(),bh);
+}
+bh.scopes=[];
+for(var N=0;N<x.scopeCount();N++){
+var bn=x.scope(N);
+bh.scopes.push({
+type:bn.scopeType(),
+index:N
+});
+}
+}
+if(x.isGenerator()){
+bh.status=x.status();
+bh.func=this.serializeReference(x.func())
+bh.receiver=this.serializeReference(x.receiver())
+serializeLocationFields(x.sourceLocation(),bh);
+}
+if(x.isDate()){
+bh.value=x.value();
+}
+if(x.isPromise()){
+bh.status=x.status();
+bh.promiseValue=this.serializeReference(x.promiseValue());
+}
+var M=x.propertyNames();
+for(var N=0;N<M.length;N++){
+var bo=x.property(M[N]);
+M[N]=this.serializeProperty_(bo);
+if(P){
+this.add_(bo.value());
+}
+}
+bh.properties=M;
+var bp=x.internalProperties();
+if(bp.length>0){
+var bq=[];
+for(var N=0;N<bp.length;N++){
+bq.push(this.serializeInternalProperty_(bp[N]));
+}
+bh.internalProperties=bq;
+}
+};
+function serializeLocationFields(aG,bh){
+if(!aG){
+return;
+}
+bh.position=aG.position;
+var br=aG.line;
+if(!(br===(void 0))){
+bh.line=br;
+}
+var bs=aG.column;
+if(!(bs===(void 0))){
+bh.column=bs;
+}
+}
+JSONProtocolSerializer.prototype.serializeProperty_=function(bo){
+var S={};
+S.name=bo.name();
+var bt=bo.value();
+if(this.inlineRefs_()&&bt.isValue()){
+S.value=this.serializeReferenceWithDisplayData_(bt);
+}else{
+if(bo.attributes()!=F.None){
+S.attributes=bo.attributes();
+}
+S.propertyType=bo.propertyType();
+S.ref=bt.handle();
+}
+return S;
+};
+JSONProtocolSerializer.prototype.serializeInternalProperty_=
+function(bo){
+var S={};
+S.name=bo.name();
+var bt=bo.value();
+if(this.inlineRefs_()&&bt.isValue()){
+S.value=this.serializeReferenceWithDisplayData_(bt);
+}else{
+S.ref=bt.handle();
+}
+return S;
+};
+JSONProtocolSerializer.prototype.serializeFrame_=function(x,bh){
+bh.index=x.index();
+bh.receiver=this.serializeReference(x.receiver());
+var aF=x.func();
+bh.func=this.serializeReference(aF);
+var T=aF.script();
+if(T){
+bh.script=this.serializeReference(T);
+}
+bh.constructCall=x.isConstructCall();
+bh.atReturn=x.isAtReturn();
+if(x.isAtReturn()){
+bh.returnValue=this.serializeReference(x.returnValue());
+}
+bh.debuggerFrame=x.isDebuggerFrame();
+var K=new d(x.argumentCount());
+for(var N=0;N<x.argumentCount();N++){
+var bu={};
+var bv=x.argumentName(N);
+if(bv){
+bu.name=bv;
+}
+bu.value=this.serializeReference(x.argumentValue(N));
+K[N]=bu;
+}
+bh.arguments=K;
+var K=new d(x.localCount());
+for(var N=0;N<x.localCount();N++){
+var bw={};
+bw.name=x.localName(N);
+bw.value=this.serializeReference(x.localValue(N));
+K[N]=bw;
+}
+bh.locals=K;
+serializeLocationFields(x.sourceLocation(),bh);
+var bx=x.sourceLineText();
+if(!(bx===(void 0))){
+bh.sourceLineText=bx;
+}
+bh.scopes=[];
+for(var N=0;N<x.scopeCount();N++){
+var bn=x.scope(N);
+bh.scopes.push({
+type:bn.scopeType(),
+index:N
+});
+}
+};
+JSONProtocolSerializer.prototype.serializeScope_=function(x,bh){
+bh.index=x.scopeIndex();
+bh.frameIndex=x.frameIndex();
+bh.type=x.scopeType();
+bh.object=this.inlineRefs_()?
+this.serializeValue(x.scopeObject()):
+this.serializeReference(x.scopeObject());
+};
+function NumberToJSON_(v){
+if(e(v)){
+return'NaN';
+}
+if(!(%_IsSmi(%IS_VAR(v))||((v==v)&&(v!=1/0)&&(v!=-1/0)))){
+if(v>0){
+return'Infinity';
+}else{
+return'-Infinity';
+}
+}
+return v;
+}
+b.InstallFunctions(a,2,[
+"MakeMirror",MakeMirror,
+"MakeMirrorSerializer",MakeMirrorSerializer,
+"LookupMirror",LookupMirror,
+"ToggleMirrorCache",ToggleMirrorCache,
+"MirrorCacheIsEmpty",MirrorCacheIsEmpty,
+]);
+b.InstallConstants(a,[
+"ScopeType",G,
+"PropertyType",E,
+"PropertyAttribute",F,
+"Mirror",Mirror,
+"ValueMirror",ValueMirror,
+"UndefinedMirror",UndefinedMirror,
+"NullMirror",NullMirror,
+"BooleanMirror",BooleanMirror,
+"NumberMirror",NumberMirror,
+"StringMirror",StringMirror,
+"SymbolMirror",SymbolMirror,
+"ObjectMirror",ObjectMirror,
+"FunctionMirror",FunctionMirror,
+"UnresolvedFunctionMirror",UnresolvedFunctionMirror,
+"ArrayMirror",ArrayMirror,
+"DateMirror",DateMirror,
+"RegExpMirror",RegExpMirror,
+"ErrorMirror",ErrorMirror,
+"PromiseMirror",PromiseMirror,
+"MapMirror",MapMirror,
+"SetMirror",SetMirror,
+"IteratorMirror",IteratorMirror,
+"GeneratorMirror",GeneratorMirror,
+"PropertyMirror",PropertyMirror,
+"InternalPropertyMirror",InternalPropertyMirror,
+"FrameMirror",FrameMirror,
+"ScriptMirror",ScriptMirror,
+"ScopeMirror",ScopeMirror,
+"FrameDetails",FrameDetails,
+]);
+b.InstallFunctions(b,2,[
+"ClearMirrorCache",ClearMirrorCache
+]);
+b.Export(function(by){
+by.MirrorType=q;
+});
+})
+
+debugRd
+(function(a,b){
+"use strict";
+var c=a.FrameMirror;
+var d=a.Array;
+var e=a.RegExp;
+var f=a.isNaN;
+var g=a.JSON.parse;
+var h=a.JSON.stringify;
+var i=a.LookupMirror;
+var j;
+var k;
+var l=a.MakeMirror;
+var m=a.MakeMirrorSerializer;
+var n=a.Math.min;
+var o=a.Mirror;
+var p;
+var q=a.parseInt;
+var r=a.ValueMirror;
+b.Import(function(s){
+j=s.MakeError;
+k=s.MakeTypeError;
+p=s.MirrorType;
+});
+var t=10;
+var u={};
+var v=/^(?:\s*(?:\/\*.*?\*\/)*)*/;
+u.DebugEvent={Break:1,
+Exception:2,
+NewFunction:3,
+BeforeCompile:4,
+AfterCompile:5,
+CompileError:6,
+AsyncTaskEvent:7};
+u.ExceptionBreak={Caught:0,
+Uncaught:1};
+u.StepAction={StepOut:0,
+StepNext:1,
+StepIn:2,
+StepFrame:3};
+u.ScriptType={Native:0,
+Extension:1,
+Normal:2};
+u.ScriptCompilationType={Host:0,
+Eval:1,
+JSON:2};
+u.ScriptBreakPointType={ScriptId:0,
+ScriptName:1,
+ScriptRegExp:2};
+u.BreakPositionAlignment={
+Statement:0,
+BreakPosition:1
+};
+function ScriptTypeFlag(w){
+return(1<<w);
+}
+var x=0;
+var y=1;
+var z=[];
+var A=[];
+var B={
+breakPointsActive:{
+value:true,
+getValue:function(){return this.value;},
+setValue:function(C){
+this.value=!!C;
+%SetBreakPointsActive(this.value);
+}
+},
+breakOnCaughtException:{
+getValue:function(){return u.isBreakOnException();},
+setValue:function(C){
+if(C){
+u.setBreakOnException();
+}else{
+u.clearBreakOnException();
+}
+}
+},
+breakOnUncaughtException:{
+getValue:function(){return u.isBreakOnUncaughtException();},
+setValue:function(C){
+if(C){
+u.setBreakOnUncaughtException();
+}else{
+u.clearBreakOnUncaughtException();
+}
+}
+},
+};
+function MakeBreakPoint(D,E){
+var F=new BreakPoint(D,E);
+z.push(F);
+return F;
+}
+function BreakPoint(D,E){
+this.source_position_=D;
+if(E){
+this.script_break_point_=E;
+}else{
+this.number_=y++;
+}
+this.active_=true;
+this.condition_=null;
+}
+BreakPoint.prototype.number=function(){
+return this.number_;
+};
+BreakPoint.prototype.func=function(){
+return this.func_;
+};
+BreakPoint.prototype.source_position=function(){
+return this.source_position_;
+};
+BreakPoint.prototype.active=function(){
+if(this.script_break_point()){
+return this.script_break_point().active();
+}
+return this.active_;
+};
+BreakPoint.prototype.condition=function(){
+if(this.script_break_point()&&this.script_break_point().condition()){
+return this.script_break_point().condition();
+}
+return this.condition_;
+};
+BreakPoint.prototype.script_break_point=function(){
+return this.script_break_point_;
+};
+BreakPoint.prototype.enable=function(){
+this.active_=true;
+};
+BreakPoint.prototype.disable=function(){
+this.active_=false;
+};
+BreakPoint.prototype.setCondition=function(G){
+this.condition_=G;
+};
+BreakPoint.prototype.isTriggered=function(H){
+if(!this.active())return false;
+if(this.condition()){
+try{
+var I=H.frame(0).evaluate(this.condition());
+if(!(I instanceof r)||!I.value_){
+return false;
+}
+}catch(e){
+return false;
+}
+}
+return true;
+};
+function IsBreakPointTriggered(J,F){
+return F.isTriggered(MakeExecutionState(J));
+}
+function ScriptBreakPoint(w,script_id_or_name,opt_line,opt_column,
+opt_groupId,opt_position_alignment){
+this.type_=w;
+if(w==u.ScriptBreakPointType.ScriptId){
+this.script_id_=script_id_or_name;
+}else if(w==u.ScriptBreakPointType.ScriptName){
+this.script_name_=script_id_or_name;
+}else if(w==u.ScriptBreakPointType.ScriptRegExp){
+this.script_regexp_object_=new e(script_id_or_name);
+}else{
+throw j(2,"Unexpected breakpoint type "+w);
+}
+this.line_=opt_line||0;
+this.column_=opt_column;
+this.groupId_=opt_groupId;
+this.position_alignment_=(opt_position_alignment===(void 0))
+?u.BreakPositionAlignment.Statement:opt_position_alignment;
+this.active_=true;
+this.condition_=null;
+this.break_points_=[];
+}
+ScriptBreakPoint.prototype.cloneForOtherScript=function(K){
+var L=new ScriptBreakPoint(u.ScriptBreakPointType.ScriptId,
+K.id,this.line_,this.column_,this.groupId_,
+this.position_alignment_);
+L.number_=y++;
+A.push(L);
+L.active_=this.active_;
+L.condition_=this.condition_;
+return L;
+};
+ScriptBreakPoint.prototype.number=function(){
+return this.number_;
+};
+ScriptBreakPoint.prototype.groupId=function(){
+return this.groupId_;
+};
+ScriptBreakPoint.prototype.type=function(){
+return this.type_;
+};
+ScriptBreakPoint.prototype.script_id=function(){
+return this.script_id_;
+};
+ScriptBreakPoint.prototype.script_name=function(){
+return this.script_name_;
+};
+ScriptBreakPoint.prototype.script_regexp_object=function(){
+return this.script_regexp_object_;
+};
+ScriptBreakPoint.prototype.line=function(){
+return this.line_;
+};
+ScriptBreakPoint.prototype.column=function(){
+return this.column_;
+};
+ScriptBreakPoint.prototype.actual_locations=function(){
+var M=[];
+for(var N=0;N<this.break_points_.length;N++){
+M.push(this.break_points_[N].actual_location);
+}
+return M;
+};
+ScriptBreakPoint.prototype.update_positions=function(O,P){
+this.line_=O;
+this.column_=P;
+};
+ScriptBreakPoint.prototype.active=function(){
+return this.active_;
+};
+ScriptBreakPoint.prototype.condition=function(){
+return this.condition_;
+};
+ScriptBreakPoint.prototype.enable=function(){
+this.active_=true;
+};
+ScriptBreakPoint.prototype.disable=function(){
+this.active_=false;
+};
+ScriptBreakPoint.prototype.setCondition=function(G){
+this.condition_=G;
+};
+ScriptBreakPoint.prototype.matchesScript=function(Q){
+if(this.type_==u.ScriptBreakPointType.ScriptId){
+return this.script_id_==Q.id;
+}else{
+if(!(Q.line_offset<=this.line_&&
+this.line_<Q.line_offset+Q.lineCount())){
+return false;
+}
+if(this.type_==u.ScriptBreakPointType.ScriptName){
+return this.script_name_==Q.nameOrSourceURL();
+}else if(this.type_==u.ScriptBreakPointType.ScriptRegExp){
+return this.script_regexp_object_.test(Q.nameOrSourceURL());
+}else{
+throw j(2,"Unexpected breakpoint type "+this.type_);
+}
+}
+};
+ScriptBreakPoint.prototype.set=function(Q){
+var P=this.column();
+var O=this.line();
+if((P===(void 0))){
+var R=Q.sourceLine(this.line());
+if(!Q.sourceColumnStart_){
+Q.sourceColumnStart_=new d(Q.lineCount());
+}
+if((Q.sourceColumnStart_[O]===(void 0))){
+Q.sourceColumnStart_[O]=
+R.match(v)[0].length;
+}
+P=Q.sourceColumnStart_[O];
+}
+var S=u.findScriptSourcePosition(Q,this.line(),P);
+if((S===null))return;
+var F=MakeBreakPoint(S,this);
+var T=%SetScriptBreakPoint(Q,S,
+this.position_alignment_,
+F);
+if((T===(void 0))){
+T=S;
+}
+var U=Q.locationFromPosition(T,true);
+F.actual_location={line:U.line,
+column:U.column,
+script_id:Q.id};
+this.break_points_.push(F);
+return F;
+};
+ScriptBreakPoint.prototype.clear=function(){
+var V=[];
+for(var N=0;N<z.length;N++){
+if(z[N].script_break_point()&&
+z[N].script_break_point()===this){
+%ClearBreakPoint(z[N]);
+}else{
+V.push(z[N]);
+}
+}
+z=V;
+this.break_points_=[];
+};
+function UpdateScriptBreakPoints(Q){
+for(var N=0;N<A.length;N++){
+var F=A[N];
+if((F.type()==u.ScriptBreakPointType.ScriptName||
+F.type()==u.ScriptBreakPointType.ScriptRegExp)&&
+F.matchesScript(Q)){
+F.set(Q);
+}
+}
+}
+function GetScriptBreakPoints(Q){
+var W=[];
+for(var N=0;N<A.length;N++){
+if(A[N].matchesScript(Q)){
+W.push(A[N]);
+}
+}
+return W;
+}
+u.setListener=function(X,Y){
+if(!(%IsFunction(X))&&!(X===(void 0))&&!(X===null)){
+throw k(34);
+}
+%SetDebugEventListener(X,Y);
+};
+u.breakLocations=function(Z,aa){
+if(!(%IsFunction(Z)))throw k(34);
+var ab=(aa===(void 0))
+?u.BreakPositionAlignment.Statement:aa;
+return %GetBreakLocations(Z,ab);
+};
+u.findScript=function(ac){
+if((%IsFunction(ac))){
+return %FunctionGetScript(ac);
+}else if((%_IsRegExp(ac))){
+var ad=u.scripts();
+var ae=null;
+var af=0;
+for(var N in ad){
+var Q=ad[N];
+if(ac.test(Q.name)){
+ae=Q;
+af++;
+}
+}
+if(af==1){
+return ae;
+}else{
+return(void 0);
+}
+}else{
+return %GetScript(ac);
+}
+};
+u.scriptSource=function(ac){
+return this.findScript(ac).source;
+};
+u.source=function(Z){
+if(!(%IsFunction(Z)))throw k(34);
+return %FunctionGetSourceCode(Z);
+};
+u.sourcePosition=function(Z){
+if(!(%IsFunction(Z)))throw k(34);
+return %FunctionGetScriptSourcePosition(Z);
+};
+u.findFunctionSourceLocation=function(ag,ah,ai){
+var Q=%FunctionGetScript(ag);
+var aj=%FunctionGetScriptSourcePosition(ag);
+return Q.locationFromLine(ah,ai,aj);
+};
+u.findScriptSourcePosition=function(Q,ah,ai){
+var ak=Q.locationFromLine(ah,ai);
+return ak?ak.position:null;
+};
+u.findBreakPoint=function(al,am){
+var F;
+for(var N=0;N<z.length;N++){
+if(z[N].number()==al){
+F=z[N];
+if(am){
+z.splice(N,1);
+}
+break;
+}
+}
+if(F){
+return F;
+}else{
+return this.findScriptBreakPoint(al,am);
+}
+};
+u.findBreakPointActualLocations=function(al){
+for(var N=0;N<A.length;N++){
+if(A[N].number()==al){
+return A[N].actual_locations();
+}
+}
+for(var N=0;N<z.length;N++){
+if(z[N].number()==al){
+return[z[N].actual_location];
+}
+}
+return[];
+};
+u.setBreakPoint=function(ag,ah,ai,an){
+if(!(%IsFunction(ag)))throw k(34);
+if(%FunctionIsAPIFunction(ag)){
+throw j(2,'Cannot set break point in native code.');
+}
+var ao=
+this.findFunctionSourceLocation(ag,ah,ai).position;
+var D=ao-this.sourcePosition(ag);
+var Q=%FunctionGetScript(ag);
+if(Q.type==u.ScriptType.Native){
+throw j(2,'Cannot set break point in native code.');
+}
+if(Q&&Q.id){
+D+=%FunctionGetScriptSourcePosition(ag);
+var ak=Q.locationFromPosition(D,false);
+return this.setScriptBreakPointById(Q.id,
+ak.line,ak.column,
+an);
+}else{
+var F=MakeBreakPoint(D);
+var T=
+%SetFunctionBreakPoint(ag,D,F);
+T+=this.sourcePosition(ag);
+var U=Q.locationFromPosition(T,true);
+F.actual_location={line:U.line,
+column:U.column,
+script_id:Q.id};
+F.setCondition(an);
+return F.number();
+}
+};
+u.setBreakPointByScriptIdAndPosition=function(script_id,S,
+G,enabled,
+opt_position_alignment)
+{
+var F=MakeBreakPoint(S);
+F.setCondition(G);
+if(!enabled){
+F.disable();
+}
+var ad=this.scripts();
+var ap=(opt_position_alignment===(void 0))
+?u.BreakPositionAlignment.Statement:opt_position_alignment;
+for(var N=0;N<ad.length;N++){
+if(script_id==ad[N].id){
+F.actual_position=%SetScriptBreakPoint(ad[N],S,
+ap,F);
+break;
+}
+}
+return F;
+};
+u.enableBreakPoint=function(al){
+var F=this.findBreakPoint(al,false);
+if(F){
+F.enable();
+}
+};
+u.disableBreakPoint=function(al){
+var F=this.findBreakPoint(al,false);
+if(F){
+F.disable();
+}
+};
+u.changeBreakPointCondition=function(al,G){
+var F=this.findBreakPoint(al,false);
+F.setCondition(G);
+};
+u.clearBreakPoint=function(al){
+var F=this.findBreakPoint(al,true);
+if(F){
+return %ClearBreakPoint(F);
+}else{
+F=this.findScriptBreakPoint(al,true);
+if(!F)throw j(2,'Invalid breakpoint');
+}
+};
+u.clearAllBreakPoints=function(){
+for(var N=0;N<z.length;N++){
+var F=z[N];
+%ClearBreakPoint(F);
+}
+z=[];
+};
+u.disableAllBreakPoints=function(){
+for(var N=1;N<y;N++){
+u.disableBreakPoint(N);
+}
+%ChangeBreakOnException(u.ExceptionBreak.Caught,false);
+%ChangeBreakOnException(u.ExceptionBreak.Uncaught,false);
+};
+u.findScriptBreakPoint=function(al,am){
+var aq;
+for(var N=0;N<A.length;N++){
+if(A[N].number()==al){
+aq=A[N];
+if(am){
+aq.clear();
+A.splice(N,1);
+}
+break;
+}
+}
+return aq;
+};
+u.setScriptBreakPoint=function(w,script_id_or_name,
+ah,ai,an,
+opt_groupId,opt_position_alignment){
+var aq=
+new ScriptBreakPoint(w,script_id_or_name,ah,ai,
+opt_groupId,opt_position_alignment);
+aq.number_=y++;
+aq.setCondition(an);
+A.push(aq);
+var ad=this.scripts();
+for(var N=0;N<ad.length;N++){
+if(aq.matchesScript(ad[N])){
+aq.set(ad[N]);
+}
+}
+return aq.number();
+};
+u.setScriptBreakPointById=function(script_id,
+ah,ai,
+an,opt_groupId,
+opt_position_alignment){
+return this.setScriptBreakPoint(u.ScriptBreakPointType.ScriptId,
+script_id,ah,ai,
+an,opt_groupId,
+opt_position_alignment);
+};
+u.setScriptBreakPointByName=function(script_name,
+ah,ai,
+an,opt_groupId){
+return this.setScriptBreakPoint(u.ScriptBreakPointType.ScriptName,
+script_name,ah,ai,
+an,opt_groupId);
+};
+u.setScriptBreakPointByRegExp=function(script_regexp,
+ah,ai,
+an,opt_groupId){
+return this.setScriptBreakPoint(u.ScriptBreakPointType.ScriptRegExp,
+script_regexp,ah,ai,
+an,opt_groupId);
+};
+u.enableScriptBreakPoint=function(al){
+var aq=this.findScriptBreakPoint(al,false);
+aq.enable();
+};
+u.disableScriptBreakPoint=function(al){
+var aq=this.findScriptBreakPoint(al,false);
+aq.disable();
+};
+u.changeScriptBreakPointCondition=function(
+al,G){
+var aq=this.findScriptBreakPoint(al,false);
+aq.setCondition(G);
+};
+u.scriptBreakPoints=function(){
+return A;
+};
+u.clearStepping=function(){
+%ClearStepping();
+};
+u.setBreakOnException=function(){
+return %ChangeBreakOnException(u.ExceptionBreak.Caught,true);
+};
+u.clearBreakOnException=function(){
+return %ChangeBreakOnException(u.ExceptionBreak.Caught,false);
+};
+u.isBreakOnException=function(){
+return!!%IsBreakOnException(u.ExceptionBreak.Caught);
+};
+u.setBreakOnUncaughtException=function(){
+return %ChangeBreakOnException(u.ExceptionBreak.Uncaught,true);
+};
+u.clearBreakOnUncaughtException=function(){
+return %ChangeBreakOnException(u.ExceptionBreak.Uncaught,false);
+};
+u.isBreakOnUncaughtException=function(){
+return!!%IsBreakOnException(u.ExceptionBreak.Uncaught);
+};
+u.showBreakPoints=function(Z,ar,as){
+if(!(%IsFunction(Z)))throw j(34);
+var at=ar?this.scriptSource(Z):this.source(Z);
+var au=ar?this.sourcePosition(Z):0;
+var M=this.breakLocations(Z,as);
+if(!M)return at;
+M.sort(function(av,aw){return av-aw;});
+var W="";
+var ax=0;
+var ay;
+for(var N=0;N<M.length;N++){
+ay=M[N]-au;
+W+=at.slice(ax,ay);
+W+="[B"+N+"]";
+ax=ay;
+}
+ay=at.length;
+W+=at.substring(ax,ay);
+return W;
+};
+u.scripts=function(){
+return %DebugGetLoadedScripts();
+};
+u.debuggerFlags=function(){
+return B;
+};
+u.MakeMirror=l;
+function MakeExecutionState(J){
+return new ExecutionState(J);
+}
+function ExecutionState(J){
+this.break_id=J;
+this.selected_frame=0;
+}
+ExecutionState.prototype.prepareStep=function(az){
+if(az===u.StepAction.StepIn||
+az===u.StepAction.StepOut||
+az===u.StepAction.StepNext||
+az===u.StepAction.StepFrame){
+return %PrepareStep(this.break_id,az);
+}
+throw k(34);
+};
+ExecutionState.prototype.evaluateGlobal=function(at,disable_break,
+opt_additional_context){
+return l(%DebugEvaluateGlobal(this.break_id,at,
+(!!(disable_break)),
+opt_additional_context));
+};
+ExecutionState.prototype.frameCount=function(){
+return %GetFrameCount(this.break_id);
+};
+ExecutionState.prototype.threadCount=function(){
+return %GetThreadCount(this.break_id);
+};
+ExecutionState.prototype.frame=function(aA){
+if(aA==null)aA=this.selected_frame;
+if(aA<0||aA>=this.frameCount()){
+throw k(33);
+}
+return new c(this.break_id,aA);
+};
+ExecutionState.prototype.setSelectedFrame=function(aB){
+var N=(%_ToNumber(aB));
+if(N<0||N>=this.frameCount()){
+throw k(33);
+}
+this.selected_frame=N;
+};
+ExecutionState.prototype.selectedFrame=function(){
+return this.selected_frame;
+};
+ExecutionState.prototype.debugCommandProcessor=function(aC){
+return new DebugCommandProcessor(this,aC);
+};
+function MakeBreakEvent(J,aD){
+return new BreakEvent(J,aD);
+}
+function BreakEvent(J,aD){
+this.frame_=new c(J,0);
+this.break_points_hit_=aD;
+}
+BreakEvent.prototype.eventType=function(){
+return u.DebugEvent.Break;
+};
+BreakEvent.prototype.func=function(){
+return this.frame_.func();
+};
+BreakEvent.prototype.sourceLine=function(){
+return this.frame_.sourceLine();
+};
+BreakEvent.prototype.sourceColumn=function(){
+return this.frame_.sourceColumn();
+};
+BreakEvent.prototype.sourceLineText=function(){
+return this.frame_.sourceLineText();
+};
+BreakEvent.prototype.breakPointsHit=function(){
+return this.break_points_hit_;
+};
+BreakEvent.prototype.toJSONProtocol=function(){
+var aE={seq:x++,
+type:"event",
+event:"break",
+body:{invocationText:this.frame_.invocationText()}
+};
+var Q=this.func().script();
+if(Q){
+aE.body.sourceLine=this.sourceLine(),
+aE.body.sourceColumn=this.sourceColumn(),
+aE.body.sourceLineText=this.sourceLineText(),
+aE.body.script=MakeScriptObject_(Q,false);
+}
+if(this.breakPointsHit()){
+aE.body.breakpoints=[];
+for(var N=0;N<this.breakPointsHit().length;N++){
+var aF=this.breakPointsHit()[N];
+var aq=aF.script_break_point();
+var aG;
+if(aq){
+aG=aq.number();
+}else{
+aG=aF.number();
+}
+aE.body.breakpoints.push(aG);
+}
+}
+return h(ObjectToProtocolObject_(aE));
+};
+function MakeExceptionEvent(J,aH,aI,aJ){
+return new ExceptionEvent(J,aH,aI,aJ);
+}
+function ExceptionEvent(J,aH,aI,aJ){
+this.exec_state_=new ExecutionState(J);
+this.exception_=aH;
+this.uncaught_=aI;
+this.promise_=aJ;
+}
+ExceptionEvent.prototype.eventType=function(){
+return u.DebugEvent.Exception;
+};
+ExceptionEvent.prototype.exception=function(){
+return this.exception_;
+};
+ExceptionEvent.prototype.uncaught=function(){
+return this.uncaught_;
+};
+ExceptionEvent.prototype.promise=function(){
+return this.promise_;
+};
+ExceptionEvent.prototype.func=function(){
+return this.exec_state_.frame(0).func();
+};
+ExceptionEvent.prototype.sourceLine=function(){
+return this.exec_state_.frame(0).sourceLine();
+};
+ExceptionEvent.prototype.sourceColumn=function(){
+return this.exec_state_.frame(0).sourceColumn();
+};
+ExceptionEvent.prototype.sourceLineText=function(){
+return this.exec_state_.frame(0).sourceLineText();
+};
+ExceptionEvent.prototype.toJSONProtocol=function(){
+var aE=new ProtocolMessage();
+aE.event="exception";
+aE.body={uncaught:this.uncaught_,
+exception:l(this.exception_)
+};
+if(this.exec_state_.frameCount()>0){
+aE.body.sourceLine=this.sourceLine();
+aE.body.sourceColumn=this.sourceColumn();
+aE.body.sourceLineText=this.sourceLineText();
+var Q=this.func().script();
+if(Q){
+aE.body.script=MakeScriptObject_(Q,false);
+}
+}else{
+aE.body.sourceLine=-1;
+}
+return aE.toJSONProtocol();
+};
+function MakeCompileEvent(Q,w){
+return new CompileEvent(Q,w);
+}
+function CompileEvent(Q,w){
+this.script_=l(Q);
+this.type_=w;
+}
+CompileEvent.prototype.eventType=function(){
+return this.type_;
+};
+CompileEvent.prototype.script=function(){
+return this.script_;
+};
+CompileEvent.prototype.toJSONProtocol=function(){
+var aE=new ProtocolMessage();
+aE.running=true;
+switch(this.type_){
+case u.DebugEvent.BeforeCompile:
+aE.event="beforeCompile";
+break;
+case u.DebugEvent.AfterCompile:
+aE.event="afterCompile";
+break;
+case u.DebugEvent.CompileError:
+aE.event="compileError";
+break;
+}
+aE.body={};
+aE.body.script=this.script_;
+return aE.toJSONProtocol();
+};
+function MakeScriptObject_(Q,aK){
+var aE={id:Q.id(),
+name:Q.name(),
+lineOffset:Q.lineOffset(),
+columnOffset:Q.columnOffset(),
+lineCount:Q.lineCount(),
+};
+if(!(Q.data()===(void 0))){
+aE.data=Q.data();
+}
+if(aK){
+aE.source=Q.source();
+}
+return aE;
+}
+function MakeAsyncTaskEvent(aL){
+return new AsyncTaskEvent(aL);
+}
+function AsyncTaskEvent(aL){
+this.type_=aL.type;
+this.name_=aL.name;
+this.id_=aL.id;
+}
+AsyncTaskEvent.prototype.type=function(){
+return this.type_;
+}
+AsyncTaskEvent.prototype.name=function(){
+return this.name_;
+}
+AsyncTaskEvent.prototype.id=function(){
+return this.id_;
+}
+function DebugCommandProcessor(H,aC){
+this.exec_state_=H;
+this.running_=aC||false;
+}
+DebugCommandProcessor.prototype.processDebugRequest=function(aM){
+return this.processDebugJSONRequest(aM);
+};
+function ProtocolMessage(aM){
+this.seq=x++;
+if(aM){
+this.type='response';
+this.request_seq=aM.seq;
+this.command=aM.command;
+}else{
+this.type='event';
+}
+this.success=true;
+this.running=(void 0);
+}
+ProtocolMessage.prototype.setOption=function(aN,C){
+if(!this.options_){
+this.options_={};
+}
+this.options_[aN]=C;
+};
+ProtocolMessage.prototype.failed=function(aO,aP){
+this.success=false;
+this.message=aO;
+if((typeof(aP)==='object')){
+this.error_details=aP;
+}
+};
+ProtocolMessage.prototype.toJSONProtocol=function(){
+var aQ={};
+aQ.seq=this.seq;
+if(this.request_seq){
+aQ.request_seq=this.request_seq;
+}
+aQ.type=this.type;
+if(this.event){
+aQ.event=this.event;
+}
+if(this.command){
+aQ.command=this.command;
+}
+if(this.success){
+aQ.success=this.success;
+}else{
+aQ.success=false;
+}
+if(this.body){
+var aR;
+var aS=m(true,this.options_);
+if(this.body instanceof o){
+aR=aS.serializeValue(this.body);
+}else if(this.body instanceof d){
+aR=[];
+for(var N=0;N<this.body.length;N++){
+if(this.body[N]instanceof o){
+aR.push(aS.serializeValue(this.body[N]));
+}else{
+aR.push(ObjectToProtocolObject_(this.body[N],aS));
+}
+}
+}else{
+aR=ObjectToProtocolObject_(this.body,aS);
+}
+aQ.body=aR;
+aQ.refs=aS.serializeReferencedObjects();
+}
+if(this.message){
+aQ.message=this.message;
+}
+if(this.error_details){
+aQ.error_details=this.error_details;
+}
+aQ.running=this.running;
+return h(aQ);
+};
+DebugCommandProcessor.prototype.createResponse=function(aM){
+return new ProtocolMessage(aM);
+};
+DebugCommandProcessor.prototype.processDebugJSONRequest=function(
+json_request){
+var aM;
+var aT;
+try{
+try{
+aM=g(json_request);
+aT=this.createResponse(aM);
+if(!aM.type){
+throw j(2,'Type not specified');
+}
+if(aM.type!='request'){
+throw j(2,
+"Illegal type '"+aM.type+"' in request");
+}
+if(!aM.command){
+throw j(2,'Command not specified');
+}
+if(aM.arguments){
+var aU=aM.arguments;
+if(aU.inlineRefs||aU.compactFormat){
+aT.setOption('inlineRefs',true);
+}
+if(!(aU.maxStringLength===(void 0))){
+aT.setOption('maxStringLength',aU.maxStringLength);
+}
+}
+var aV=aM.command.toLowerCase();
+var aW=DebugCommandProcessor.prototype.dispatch_[aV];
+if((%IsFunction(aW))){
+%_Call(aW,this,aM,aT);
+}else{
+throw j(2,
+'Unknown command "'+aM.command+'" in request');
+}
+}catch(e){
+if(!aT){
+aT=this.createResponse();
+}
+aT.success=false;
+aT.message=(%_ToString(e));
+}
+try{
+if(!(aT.running===(void 0))){
+this.running_=aT.running;
+}
+aT.running=this.running_;
+return aT.toJSONProtocol();
+}catch(e){
+return'{"seq":'+aT.seq+','+
+'"request_seq":'+aM.seq+','+
+'"type":"response",'+
+'"success":false,'+
+'"message":"Internal error: '+(%_ToString(e))+'"}';
+}
+}catch(e){
+return'{"seq":0,"type":"response","success":false,"message":"Internal error"}';
+}
+};
+DebugCommandProcessor.prototype.continueRequest_=function(aM,aT){
+if(aM.arguments){
+var az=u.StepAction.StepIn;
+var aX=aM.arguments.stepaction;
+if(aX){
+if(aX=='in'){
+az=u.StepAction.StepIn;
+}else if(aX=='next'){
+az=u.StepAction.StepNext;
+}else if(aX=='out'){
+az=u.StepAction.StepOut;
+}else{
+throw j(2,
+'Invalid stepaction argument "'+aX+'".');
+}
+}
+this.exec_state_.prepareStep(az);
+}
+aT.running=true;
+};
+DebugCommandProcessor.prototype.breakRequest_=function(aM,aT){
+};
+DebugCommandProcessor.prototype.setBreakPointRequest_=
+function(aM,aT){
+if(!aM.arguments){
+aT.failed('Missing arguments');
+return;
+}
+var w=aM.arguments.type;
+var aY=aM.arguments.target;
+var O=aM.arguments.line;
+var P=aM.arguments.column;
+var aZ=(aM.arguments.enabled===(void 0))?
+true:aM.arguments.enabled;
+var G=aM.arguments.condition;
+var ba=aM.arguments.groupId;
+if(!w||(aY===(void 0))){
+aT.failed('Missing argument "type" or "target"');
+return;
+}
+var al;
+if(w=='function'){
+if(!(typeof(aY)==='string')){
+aT.failed('Argument "target" is not a string value');
+return;
+}
+var Z;
+try{
+Z=this.exec_state_.evaluateGlobal(aY).value();
+}catch(e){
+aT.failed('Error: "'+(%_ToString(e))+
+'" evaluating "'+aY+'"');
+return;
+}
+if(!(%IsFunction(Z))){
+aT.failed('"'+aY+'" does not evaluate to a function');
+return;
+}
+al=u.setBreakPoint(Z,O,P,G);
+}else if(w=='handle'){
+var bb=q(aY,10);
+var I=i(bb);
+if(!I){
+return aT.failed('Object #'+bb+'# not found');
+}
+if(!I.isFunction()){
+return aT.failed('Object #'+bb+'# is not a function');
+}
+al=u.setBreakPoint(I.value(),
+O,P,G);
+}else if(w=='script'){
+al=
+u.setScriptBreakPointByName(aY,O,P,G,
+ba);
+}else if(w=='scriptId'){
+al=
+u.setScriptBreakPointById(aY,O,P,G,ba);
+}else if(w=='scriptRegExp'){
+al=
+u.setScriptBreakPointByRegExp(aY,O,P,G,
+ba);
+}else{
+aT.failed('Illegal type "'+w+'"');
+return;
+}
+var F=u.findBreakPoint(al);
+if(!aZ){
+u.disableBreakPoint(al);
+}
+aT.body={type:w,
+breakpoint:al};
+if(F instanceof ScriptBreakPoint){
+if(F.type()==u.ScriptBreakPointType.ScriptId){
+aT.body.type='scriptId';
+aT.body.script_id=F.script_id();
+}else if(F.type()==u.ScriptBreakPointType.ScriptName){
+aT.body.type='scriptName';
+aT.body.script_name=F.script_name();
+}else if(F.type()==u.ScriptBreakPointType.ScriptRegExp){
+aT.body.type='scriptRegExp';
+aT.body.script_regexp=F.script_regexp_object().source;
+}else{
+throw j(2,
+"Unexpected breakpoint type: "+F.type());
+}
+aT.body.line=F.line();
+aT.body.column=F.column();
+aT.body.actual_locations=F.actual_locations();
+}else{
+aT.body.type='function';
+aT.body.actual_locations=[F.actual_location];
+}
+};
+DebugCommandProcessor.prototype.changeBreakPointRequest_=function(
+aM,aT){
+if(!aM.arguments){
+aT.failed('Missing arguments');
+return;
+}
+var F=(%_ToNumber(aM.arguments.breakpoint));
+var aZ=aM.arguments.enabled;
+var G=aM.arguments.condition;
+if(!F){
+aT.failed('Missing argument "breakpoint"');
+return;
+}
+if(!(aZ===(void 0))){
+if(aZ){
+u.enableBreakPoint(F);
+}else{
+u.disableBreakPoint(F);
+}
+}
+if(!(G===(void 0))){
+u.changeBreakPointCondition(F,G);
+}
+};
+DebugCommandProcessor.prototype.clearBreakPointGroupRequest_=function(
+aM,aT){
+if(!aM.arguments){
+aT.failed('Missing arguments');
+return;
+}
+var bc=aM.arguments.groupId;
+if(!bc){
+aT.failed('Missing argument "groupId"');
+return;
+}
+var bd=[];
+var be=[];
+for(var N=0;N<A.length;N++){
+var bf=A[N];
+if(bf.groupId()==bc){
+bd.push(bf.number());
+bf.clear();
+}else{
+be.push(bf);
+}
+}
+A=be;
+aT.body={breakpoints:bd};
+};
+DebugCommandProcessor.prototype.clearBreakPointRequest_=function(
+aM,aT){
+if(!aM.arguments){
+aT.failed('Missing arguments');
+return;
+}
+var F=(%_ToNumber(aM.arguments.breakpoint));
+if(!F){
+aT.failed('Missing argument "breakpoint"');
+return;
+}
+u.clearBreakPoint(F);
+aT.body={breakpoint:F};
+};
+DebugCommandProcessor.prototype.listBreakpointsRequest_=function(
+aM,aT){
+var bg=[];
+for(var N=0;N<A.length;N++){
+var F=A[N];
+var bh={
+number:F.number(),
+line:F.line(),
+column:F.column(),
+groupId:F.groupId(),
+active:F.active(),
+condition:F.condition(),
+actual_locations:F.actual_locations()
+};
+if(F.type()==u.ScriptBreakPointType.ScriptId){
+bh.type='scriptId';
+bh.script_id=F.script_id();
+}else if(F.type()==u.ScriptBreakPointType.ScriptName){
+bh.type='scriptName';
+bh.script_name=F.script_name();
+}else if(F.type()==u.ScriptBreakPointType.ScriptRegExp){
+bh.type='scriptRegExp';
+bh.script_regexp=F.script_regexp_object().source;
+}else{
+throw j(2,
+"Unexpected breakpoint type: "+F.type());
+}
+bg.push(bh);
+}
+aT.body={
+breakpoints:bg,
+breakOnExceptions:u.isBreakOnException(),
+breakOnUncaughtExceptions:u.isBreakOnUncaughtException()
+};
+};
+DebugCommandProcessor.prototype.disconnectRequest_=
+function(aM,aT){
+u.disableAllBreakPoints();
+this.continueRequest_(aM,aT);
+};
+DebugCommandProcessor.prototype.setExceptionBreakRequest_=
+function(aM,aT){
+if(!aM.arguments){
+aT.failed('Missing arguments');
+return;
+}
+var w=aM.arguments.type;
+if(!w){
+aT.failed('Missing argument "type"');
+return;
+}
+var aZ;
+if(w=='all'){
+aZ=!u.isBreakOnException();
+}else if(w=='uncaught'){
+aZ=!u.isBreakOnUncaughtException();
+}
+if(!(aM.arguments.enabled===(void 0))){
+aZ=aM.arguments.enabled;
+if((aZ!=true)&&(aZ!=false)){
+aT.failed('Illegal value for "enabled":"'+aZ+'"');
+}
+}
+if(w=='all'){
+%ChangeBreakOnException(u.ExceptionBreak.Caught,aZ);
+}else if(w=='uncaught'){
+%ChangeBreakOnException(u.ExceptionBreak.Uncaught,aZ);
+}else{
+aT.failed('Unknown "type":"'+w+'"');
+}
+aT.body={'type':w,'enabled':aZ};
+};
+DebugCommandProcessor.prototype.backtraceRequest_=function(
+aM,aT){
+var bi=this.exec_state_.frameCount();
+if(bi==0){
+aT.body={
+totalFrames:bi
+};
+return;
+}
+var bj=0;
+var bk=t;
+if(aM.arguments){
+if(aM.arguments.fromFrame){
+bj=aM.arguments.fromFrame;
+}
+if(aM.arguments.toFrame){
+bk=aM.arguments.toFrame;
+}
+if(aM.arguments.bottom){
+var bl=bi-bj;
+bj=bi-bk;
+bk=bl;
+}
+if(bj<0||bk<0){
+return aT.failed('Invalid frame number');
+}
+}
+bk=n(bi,bk);
+if(bk<=bj){
+var bm='Invalid frame range';
+return aT.failed(bm);
+}
+var bn=[];
+for(var N=bj;N<bk;N++){
+bn.push(this.exec_state_.frame(N));
+}
+aT.body={
+fromFrame:bj,
+toFrame:bk,
+totalFrames:bi,
+frames:bn
+};
+};
+DebugCommandProcessor.prototype.frameRequest_=function(aM,aT){
+if(this.exec_state_.frameCount()==0){
+return aT.failed('No frames');
+}
+if(aM.arguments){
+var aB=aM.arguments.number;
+if(aB<0||this.exec_state_.frameCount()<=aB){
+return aT.failed('Invalid frame number');
+}
+this.exec_state_.setSelectedFrame(aM.arguments.number);
+}
+aT.body=this.exec_state_.frame();
+};
+DebugCommandProcessor.prototype.resolveFrameFromScopeDescription_=
+function(bo){
+if(bo&&!(bo.frameNumber===(void 0))){
+var bp=bo.frameNumber;
+if(bp<0||this.exec_state_.frameCount()<=bp){
+throw k(33);
+}
+return this.exec_state_.frame(bp);
+}else{
+return this.exec_state_.frame();
+}
+};
+DebugCommandProcessor.prototype.resolveScopeHolder_=
+function(bo){
+if(bo&&"functionHandle"in bo){
+if(!(typeof(bo.functionHandle)==='number')){
+throw j(2,'Function handle must be a number');
+}
+var bq=i(bo.functionHandle);
+if(!bq){
+throw j(2,'Failed to find function object by handle');
+}
+if(!bq.isFunction()){
+throw j(2,
+'Value of non-function type is found by handle');
+}
+return bq;
+}else{
+if(this.exec_state_.frameCount()==0){
+throw j(2,'No scopes');
+}
+var br=this.resolveFrameFromScopeDescription_(bo);
+return br;
+}
+}
+DebugCommandProcessor.prototype.scopesRequest_=function(aM,aT){
+var bs=this.resolveScopeHolder_(aM.arguments);
+var bt=bs.scopeCount();
+var bu=[];
+for(var N=0;N<bt;N++){
+bu.push(bs.scope(N));
+}
+aT.body={
+fromScope:0,
+toScope:bt,
+totalScopes:bt,
+scopes:bu
+};
+};
+DebugCommandProcessor.prototype.scopeRequest_=function(aM,aT){
+var bs=this.resolveScopeHolder_(aM.arguments);
+var bv=0;
+if(aM.arguments&&!(aM.arguments.number===(void 0))){
+bv=(%_ToNumber(aM.arguments.number));
+if(bv<0||bs.scopeCount()<=bv){
+return aT.failed('Invalid scope number');
+}
+}
+aT.body=bs.scope(bv);
+};
+DebugCommandProcessor.resolveValue_=function(bw){
+if("handle"in bw){
+var bx=i(bw.handle);
+if(!bx){
+throw j(2,"Failed to resolve value by handle, ' #"+
+bw.handle+"# not found");
+}
+return bx.value();
+}else if("stringDescription"in bw){
+if(bw.type==p.BOOLEAN_TYPE){
+return(!!(bw.stringDescription));
+}else if(bw.type==p.NUMBER_TYPE){
+return(%_ToNumber(bw.stringDescription));
+}if(bw.type==p.STRING_TYPE){
+return(%_ToString(bw.stringDescription));
+}else{
+throw j(2,"Unknown type");
+}
+}else if("value"in bw){
+return bw.value;
+}else if(bw.type==p.UNDEFINED_TYPE){
+return(void 0);
+}else if(bw.type==p.NULL_TYPE){
+return null;
+}else{
+throw j(2,"Failed to parse value description");
+}
+};
+DebugCommandProcessor.prototype.setVariableValueRequest_=
+function(aM,aT){
+if(!aM.arguments){
+aT.failed('Missing arguments');
+return;
+}
+if((aM.arguments.name===(void 0))){
+aT.failed('Missing variable name');
+}
+var by=aM.arguments.name;
+var bo=aM.arguments.scope;
+var bs=this.resolveScopeHolder_(bo);
+if((bo.number===(void 0))){
+aT.failed('Missing scope number');
+}
+var bv=(%_ToNumber(bo.number));
+var bz=bs.scope(bv);
+var bA=
+DebugCommandProcessor.resolveValue_(aM.arguments.newValue);
+bz.setVariableValue(by,bA);
+var bB=l(bA);
+aT.body={
+newValue:bB
+};
+};
+DebugCommandProcessor.prototype.evaluateRequest_=function(aM,aT){
+if(!aM.arguments){
+return aT.failed('Missing arguments');
+}
+var bC=aM.arguments.expression;
+var br=aM.arguments.frame;
+var a=aM.arguments.global;
+var bD=aM.arguments.disable_break;
+var bE=aM.arguments.additional_context;
+try{
+bC=(%_ToString(bC));
+}catch(e){
+return aT.failed('Failed to convert expression argument to string');
+}
+if(!(br===(void 0))&&a){
+return aT.failed('Arguments "frame" and "global" are exclusive');
+}
+var bF;
+if(bE){
+bF={};
+for(var N=0;N<bE.length;N++){
+var bG=bE[N];
+if(!(typeof(bG.name)==='string')){
+return aT.failed("Context element #"+N+
+" doesn't contain name:string property");
+}
+var bH=DebugCommandProcessor.resolveValue_(bG);
+bF[bG.name]=bH;
+}
+}
+if(a){
+aT.body=this.exec_state_.evaluateGlobal(
+bC,(!!(bD)),bF);
+return;
+}
+if((bD===(void 0))){
+bD=true;
+}
+if(this.exec_state_.frameCount()==0){
+return aT.failed('No frames');
+}
+if(!(br===(void 0))){
+var bI=(%_ToNumber(br));
+if(bI<0||bI>=this.exec_state_.frameCount()){
+return aT.failed('Invalid frame "'+br+'"');
+}
+aT.body=this.exec_state_.frame(bI).evaluate(
+bC,(!!(bD)),bF);
+return;
+}else{
+aT.body=this.exec_state_.frame().evaluate(
+bC,(!!(bD)),bF);
+return;
+}
+};
+DebugCommandProcessor.prototype.lookupRequest_=function(aM,aT){
+if(!aM.arguments){
+return aT.failed('Missing arguments');
+}
+var bJ=aM.arguments.handles;
+if((bJ===(void 0))){
+return aT.failed('Argument "handles" missing');
+}
+if(!(aM.arguments.includeSource===(void 0))){
+var bK=(!!(aM.arguments.includeSource));
+aT.setOption('includeSource',bK);
+}
+var bL={};
+for(var N=0;N<bJ.length;N++){
+var bb=bJ[N];
+var I=i(bb);
+if(!I){
+return aT.failed('Object #'+bb+'# not found');
+}
+bL[bb]=I;
+}
+aT.body=bL;
+};
+DebugCommandProcessor.prototype.referencesRequest_=
+function(aM,aT){
+if(!aM.arguments){
+return aT.failed('Missing arguments');
+}
+var w=aM.arguments.type;
+var bb=aM.arguments.handle;
+if((w===(void 0))){
+return aT.failed('Argument "type" missing');
+}
+if((bb===(void 0))){
+return aT.failed('Argument "handle" missing');
+}
+if(w!='referencedBy'&&w!='constructedBy'){
+return aT.failed('Invalid type "'+w+'"');
+}
+var I=i(bb);
+if(I){
+if(w=='referencedBy'){
+aT.body=I.referencedBy();
+}else{
+aT.body=I.constructedBy();
+}
+}else{
+return aT.failed('Object #'+bb+'# not found');
+}
+};
+DebugCommandProcessor.prototype.sourceRequest_=function(aM,aT){
+if(this.exec_state_.frameCount()==0){
+return aT.failed('No source');
+}
+var bM;
+var bN;
+var br=this.exec_state_.frame();
+if(aM.arguments){
+bM=aM.arguments.fromLine;
+bN=aM.arguments.toLine;
+if(!(aM.arguments.frame===(void 0))){
+var bI=(%_ToNumber(aM.arguments.frame));
+if(bI<0||bI>=this.exec_state_.frameCount()){
+return aT.failed('Invalid frame "'+br+'"');
+}
+br=this.exec_state_.frame(bI);
+}
+}
+var Q=br.func().script();
+if(!Q){
+return aT.failed('No source');
+}
+var bO=Q.sourceSlice(bM,bN);
+if(!bO){
+return aT.failed('Invalid line interval');
+}
+aT.body={};
+aT.body.source=bO.sourceText();
+aT.body.fromLine=bO.from_line;
+aT.body.toLine=bO.to_line;
+aT.body.fromPosition=bO.from_position;
+aT.body.toPosition=bO.to_position;
+aT.body.totalLines=Q.lineCount();
+};
+DebugCommandProcessor.prototype.scriptsRequest_=function(aM,aT){
+var bP=ScriptTypeFlag(u.ScriptType.Normal);
+var bK=false;
+var bQ=null;
+if(aM.arguments){
+if(!(aM.arguments.types===(void 0))){
+bP=(%_ToNumber(aM.arguments.types));
+if(f(bP)||bP<0){
+return aT.failed('Invalid types "'+
+aM.arguments.types+'"');
+}
+}
+if(!(aM.arguments.includeSource===(void 0))){
+bK=(!!(aM.arguments.includeSource));
+aT.setOption('includeSource',bK);
+}
+if((%_IsArray(aM.arguments.ids))){
+bQ={};
+var bR=aM.arguments.ids;
+for(var N=0;N<bR.length;N++){
+bQ[bR[N]]=true;
+}
+}
+var bS=null;
+var bT=null;
+if(!(aM.arguments.filter===(void 0))){
+var bU=(%_ToNumber(aM.arguments.filter));
+if(!f(bU)){
+bT=bU;
+}
+bS=aM.arguments.filter;
+}
+}
+var ad=%DebugGetLoadedScripts();
+aT.body=[];
+for(var N=0;N<ad.length;N++){
+if(bQ&&!bQ[ad[N].id]){
+continue;
+}
+if(bS||bT){
+var Q=ad[N];
+var bV=false;
+if(bT&&!bV){
+if(Q.id&&Q.id===bT){
+bV=true;
+}
+}
+if(bS&&!bV){
+if(Q.name&&Q.name.indexOf(bS)>=0){
+bV=true;
+}
+}
+if(!bV)continue;
+}
+if(bP&ScriptTypeFlag(ad[N].type)){
+aT.body.push(l(ad[N]));
+}
+}
+};
+DebugCommandProcessor.prototype.threadsRequest_=function(aM,aT){
+var bW=this.exec_state_.threadCount();
+var bX=[];
+for(var N=0;N<bW;N++){
+var bY=%GetThreadDetails(this.exec_state_.break_id,N);
+var bZ={current:bY[0],
+id:bY[1]
+};
+bX.push(bZ);
+}
+aT.body={
+totalThreads:bW,
+threads:bX
+};
+};
+DebugCommandProcessor.prototype.suspendRequest_=function(aM,aT){
+aT.running=false;
+};
+DebugCommandProcessor.prototype.versionRequest_=function(aM,aT){
+aT.body={
+V8Version:%GetV8Version()
+};
+};
+DebugCommandProcessor.prototype.changeLiveRequest_=function(
+aM,aT){
+if(!aM.arguments){
+return aT.failed('Missing arguments');
+}
+var ca=aM.arguments.script_id;
+var cb=!!aM.arguments.preview_only;
+var ad=%DebugGetLoadedScripts();
+var cc=null;
+for(var N=0;N<ad.length;N++){
+if(ad[N].id==ca){
+cc=ad[N];
+}
+}
+if(!cc){
+aT.failed('Script not found');
+return;
+}
+var cd=new d();
+if(!(typeof(aM.arguments.new_source)==='string')){
+throw"new_source argument expected";
+}
+var ce=aM.arguments.new_source;
+var cf;
+try{
+cf=u.LiveEdit.SetScriptSource(cc,
+ce,cb,cd);
+}catch(e){
+if(e instanceof u.LiveEdit.Failure&&"details"in e){
+aT.failed(e.message,e.details);
+return;
+}
+throw e;
+}
+aT.body={change_log:cd,result:cf};
+if(!cb&&!this.running_&&cf.stack_modified){
+aT.body.stepin_recommended=true;
+}
+};
+DebugCommandProcessor.prototype.restartFrameRequest_=function(
+aM,aT){
+if(!aM.arguments){
+return aT.failed('Missing arguments');
+}
+var br=aM.arguments.frame;
+if(this.exec_state_.frameCount()==0){
+return aT.failed('No frames');
+}
+var cg;
+if(!(br===(void 0))){
+var bI=(%_ToNumber(br));
+if(bI<0||bI>=this.exec_state_.frameCount()){
+return aT.failed('Invalid frame "'+br+'"');
+}
+cg=this.exec_state_.frame(bI);
+}else{
+cg=this.exec_state_.frame();
+}
+var cf=cg.restart();
+aT.body={result:cf};
+};
+DebugCommandProcessor.prototype.debuggerFlagsRequest_=function(aM,
+aT){
+if(!aM.arguments){
+aT.failed('Missing arguments');
+return;
+}
+var ch=aM.arguments.flags;
+aT.body={flags:[]};
+if(!(ch===(void 0))){
+for(var N=0;N<ch.length;N++){
+var aN=ch[N].name;
+var ci=B[aN];
+if(!ci){
+continue;
+}
+if('value'in ch[N]){
+ci.setValue(ch[N].value);
+}
+aT.body.flags.push({name:aN,value:ci.getValue()});
+}
+}else{
+for(var aN in B){
+var C=B[aN].getValue();
+aT.body.flags.push({name:aN,value:C});
+}
+}
+};
+DebugCommandProcessor.prototype.v8FlagsRequest_=function(aM,aT){
+var ch=aM.arguments.flags;
+if(!ch)ch='';
+%SetFlags(ch);
+};
+DebugCommandProcessor.prototype.gcRequest_=function(aM,aT){
+var w=aM.arguments.type;
+if(!w)w='all';
+var cj=%GetHeapUsage();
+%CollectGarbage(w);
+var ck=%GetHeapUsage();
+aT.body={"before":cj,"after":ck};
+};
+DebugCommandProcessor.prototype.dispatch_=(function(){
+var cl=DebugCommandProcessor.prototype;
+return{
+"continue":cl.continueRequest_,
+"break":cl.breakRequest_,
+"setbreakpoint":cl.setBreakPointRequest_,
+"changebreakpoint":cl.changeBreakPointRequest_,
+"clearbreakpoint":cl.clearBreakPointRequest_,
+"clearbreakpointgroup":cl.clearBreakPointGroupRequest_,
+"disconnect":cl.disconnectRequest_,
+"setexceptionbreak":cl.setExceptionBreakRequest_,
+"listbreakpoints":cl.listBreakpointsRequest_,
+"backtrace":cl.backtraceRequest_,
+"frame":cl.frameRequest_,
+"scopes":cl.scopesRequest_,
+"scope":cl.scopeRequest_,
+"setvariablevalue":cl.setVariableValueRequest_,
+"evaluate":cl.evaluateRequest_,
+"lookup":cl.lookupRequest_,
+"references":cl.referencesRequest_,
+"source":cl.sourceRequest_,
+"scripts":cl.scriptsRequest_,
+"threads":cl.threadsRequest_,
+"suspend":cl.suspendRequest_,
+"version":cl.versionRequest_,
+"changelive":cl.changeLiveRequest_,
+"restartframe":cl.restartFrameRequest_,
+"flags":cl.debuggerFlagsRequest_,
+"v8flag":cl.v8FlagsRequest_,
+"gc":cl.gcRequest_,
+};
+})();
+DebugCommandProcessor.prototype.isRunning=function(){
+return this.running_;
+};
+DebugCommandProcessor.prototype.systemBreak=function(cm,aU){
+return %SystemBreak();
+};
+function ObjectToProtocolObject_(cn,co){
+var cp={};
+for(var aV in cn){
+if(typeof aV=='string'){
+var cq=ValueToProtocolValue_(cn[aV],
+co);
+if(!(cq===(void 0))){
+cp[aV]=cq;
+}
+}
+}
+return cp;
+}
+function ArrayToProtocolArray_(bg,co){
+var aQ=[];
+for(var N=0;N<bg.length;N++){
+aQ.push(ValueToProtocolValue_(bg[N],co));
+}
+return aQ;
+}
+function ValueToProtocolValue_(C,co){
+var aQ;
+switch(typeof C){
+case'object':
+if(C instanceof o){
+aQ=co.serializeValue(C);
+}else if((%_IsArray(C))){
+aQ=ArrayToProtocolArray_(C,co);
+}else{
+aQ=ObjectToProtocolObject_(C,co);
+}
+break;
+case'boolean':
+case'string':
+case'number':
+aQ=C;
+break;
+default:
+aQ=null;
+}
+return aQ;
+}
+b.InstallConstants(a,[
+"Debug",u,
+"DebugCommandProcessor",DebugCommandProcessor,
+"BreakEvent",BreakEvent,
+"CompileEvent",CompileEvent,
+"BreakPoint",BreakPoint,
+]);
+b.InstallFunctions(b,2,[
+"MakeExecutionState",MakeExecutionState,
+"MakeExceptionEvent",MakeExceptionEvent,
+"MakeBreakEvent",MakeBreakEvent,
+"MakeCompileEvent",MakeCompileEvent,
+"MakeAsyncTaskEvent",MakeAsyncTaskEvent,
+"IsBreakPointTriggered",IsBreakPointTriggered,
+"UpdateScriptBreakPoints",UpdateScriptBreakPoints,
+]);
+b.Export(function(cr){
+cr.GetScriptBreakPoints=GetScriptBreakPoints;
+});
+})
+
+ liveedit%�
+(function(a,b){
+"use strict";
+var c=a.Debug.findScriptSourcePosition;
+var d;
+var e=a.Array;
+var f=a.Math.floor;
+var g=a.SyntaxError;
+b.Import(function(h){
+d=h.GetScriptBreakPoints;
+});
+var i;
+function ApplyPatchMultiChunk(script,diff_array,new_source,preview_only,
+change_log){
+var j=script.source;
+var k=GatherCompileInfo(j,script);
+var l=BuildCodeInfoTree(k);
+var m=new PosTranslator(diff_array);
+MarkChangedFunctions(l,m.GetChunks());
+FindLiveSharedInfos(l,script);
+var n;
+try{
+n=GatherCompileInfo(new_source,script);
+}catch(e){
+var o=
+new Failure("Failed to compile new version of script: "+e);
+if(e instanceof g){
+var p={
+type:"liveedit_compile_error",
+syntaxErrorMessage:e.message
+};
+CopyErrorPositionToDetails(e,p);
+o.details=p;
+}
+throw o;
+}
+var q=BuildCodeInfoTree(n);
+FindCorrespondingFunctions(l,q);
+var r=new e();
+var s=new e();
+var t=new e();
+var u=new e();
+function HarvestTodo(v){
+function CollectDamaged(w){
+s.push(w);
+for(var x=0;x<w.children.length;x++){
+CollectDamaged(w.children[x]);
+}
+}
+function CollectNew(y){
+for(var x=0;x<y.length;x++){
+t.push(y[x]);
+CollectNew(y[x].children);
+}
+}
+if(v.status==i.DAMAGED){
+CollectDamaged(v);
+return;
+}
+if(v.status==i.UNCHANGED){
+u.push(v);
+}else if(v.status==i.SOURCE_CHANGED){
+u.push(v);
+}else if(v.status==i.CHANGED){
+r.push(v);
+CollectNew(v.unmatched_new_nodes);
+}
+for(var x=0;x<v.children.length;x++){
+HarvestTodo(v.children[x]);
+}
+}
+var z={
+change_tree:DescribeChangeTree(l),
+textual_diff:{
+old_len:j.length,
+new_len:new_source.length,
+chunks:diff_array
+},
+updated:false
+};
+if(preview_only){
+return z;
+}
+HarvestTodo(l);
+var A=new e();
+var B=new e();
+for(var x=0;x<r.length;x++){
+var C=r[x].live_shared_function_infos;
+var D=
+r[x].corresponding_node.info.shared_function_info;
+if(C){
+for(var E=0;E<C.length;E++){
+A.push(C[E]);
+B.push(D);
+}
+}
+}
+var F=
+CheckStackActivations(A,
+B,
+change_log);
+z.stack_modified=F!=0;
+var G=TemporaryRemoveBreakPoints(script,change_log);
+var H;
+if(s.length==0){
+%LiveEditReplaceScript(script,new_source,null);
+H=(void 0);
+}else{
+var I=CreateNameForOldScript(script);
+H=%LiveEditReplaceScript(script,new_source,
+I);
+var J=new e();
+change_log.push({linked_to_old_script:J});
+for(var x=0;x<s.length;x++){
+LinkToOldScript(s[x],H,
+J);
+}
+z.created_script_name=I;
+}
+for(var x=0;x<t.length;x++){
+%LiveEditFunctionSetScript(
+t[x].info.shared_function_info,script);
+}
+for(var x=0;x<r.length;x++){
+PatchFunctionCode(r[x],change_log);
+}
+var K=new e();
+change_log.push({position_patched:K});
+for(var x=0;x<u.length;x++){
+PatchPositions(u[x],diff_array,
+K);
+if(u[x].live_shared_function_infos){
+u[x].live_shared_function_infos.
+forEach(function(L){
+%LiveEditFunctionSourceUpdated(L.raw_array);
+});
+}
+}
+G(m,H);
+z.updated=true;
+return z;
+}
+function GatherCompileInfo(M,N){
+var O=%LiveEditGatherCompileInfo(N,M);
+var P=new e();
+var Q=new e();
+for(var x=0;x<O.length;x++){
+var L=new FunctionCompileInfo(O[x]);
+%LiveEditFunctionSetScript(L.shared_function_info,(void 0));
+P.push(L);
+Q.push(x);
+}
+for(var x=0;x<P.length;x++){
+var R=x;
+for(var E=x+1;E<P.length;E++){
+if(P[R].start_position>P[E].start_position){
+R=E;
+}
+}
+if(R!=x){
+var S=P[R];
+var T=Q[R];
+P[R]=P[x];
+Q[R]=Q[x];
+P[x]=S;
+Q[x]=T;
+}
+}
+var U=0;
+function ResetIndexes(V,W){
+var X=-1;
+while(U<P.length&&
+P[U].outer_index==W){
+var Y=U;
+P[Y].outer_index=V;
+if(X!=-1){
+P[X].next_sibling_index=Y;
+}
+X=Y;
+U++;
+ResetIndexes(Y,Q[Y]);
+}
+if(X!=-1){
+P[X].next_sibling_index=-1;
+}
+}
+ResetIndexes(-1,-1);
+Assert(U==P.length);
+return P;
+}
+function PatchFunctionCode(v,Z){
+var D=v.corresponding_node.info;
+if(v.live_shared_function_infos){
+v.live_shared_function_infos.forEach(function(aa){
+%LiveEditReplaceFunctionCode(D.raw_array,
+aa.raw_array);
+for(var x=0;x<v.children.length;x++){
+if(v.children[x].corresponding_node){
+var ab=
+v.children[x].corresponding_node.info.
+shared_function_info;
+if(v.children[x].live_shared_function_infos){
+v.children[x].live_shared_function_infos.
+forEach(function(ac){
+%LiveEditReplaceRefToNestedFunction(
+aa.info,
+ab,
+ac.info);
+});
+}
+}
+}
+});
+Z.push({function_patched:D.function_name});
+}else{
+Z.push({function_patched:D.function_name,
+function_info_not_found:true});
+}
+}
+function LinkToOldScript(ad,H,ae){
+if(ad.live_shared_function_infos){
+ad.live_shared_function_infos.
+forEach(function(L){
+%LiveEditFunctionSetScript(L.info,H);
+});
+ae.push({name:ad.info.function_name});
+}else{
+ae.push(
+{name:ad.info.function_name,not_found:true});
+}
+}
+function TemporaryRemoveBreakPoints(af,Z){
+var ag=d(af);
+var ah=[];
+Z.push({break_points_update:ah});
+var ai=[];
+for(var x=0;x<ag.length;x++){
+var aj=ag[x];
+aj.clear();
+var ak=c(af,
+aj.line(),aj.column());
+var al={
+position:ak,
+line:aj.line(),
+column:aj.column()
+};
+ai.push(al);
+}
+return function(m,am){
+for(var x=0;x<ag.length;x++){
+var aj=ag[x];
+if(am){
+var an=aj.cloneForOtherScript(am);
+an.set(am);
+ah.push({
+type:"copied_to_old",
+id:aj.number(),
+new_id:an.number(),
+positions:ai[x]
+});
+}
+var ao=m.Translate(
+ai[x].position,
+PosTranslator.ShiftWithTopInsideChunkHandler);
+var ap=
+af.locationFromPosition(ao,false);
+aj.update_positions(ap.line,ap.column);
+var aq={
+position:ao,
+line:ap.line,
+column:ap.column
+};
+aj.set(af);
+ah.push({type:"position_changed",
+id:aj.number(),
+old_positions:ai[x],
+new_positions:aq
+});
+}
+};
+}
+function Assert(ar,as){
+if(!ar){
+if(as){
+throw"Assert "+as;
+}else{
+throw"Assert";
+}
+}
+}
+function DiffChunk(at,au,av,aw){
+this.pos1=at;
+this.pos2=au;
+this.len1=av;
+this.len2=aw;
+}
+function PosTranslator(ax){
+var ay=new e();
+var az=0;
+for(var x=0;x<ax.length;x+=3){
+var aA=ax[x];
+var aB=aA+az;
+var aC=ax[x+1];
+var aD=ax[x+2];
+ay.push(new DiffChunk(aA,aB,aC-aA,
+aD-aB));
+az=aD-aC;
+}
+this.chunks=ay;
+}
+PosTranslator.prototype.GetChunks=function(){
+return this.chunks;
+};
+PosTranslator.prototype.Translate=function(aE,aF){
+var aG=this.chunks;
+if(aG.length==0||aE<aG[0].pos1){
+return aE;
+}
+var aH=0;
+var aI=aG.length-1;
+while(aH<aI){
+var aJ=f((aH+aI)/2);
+if(aE<aG[aJ+1].pos1){
+aI=aJ;
+}else{
+aH=aJ+1;
+}
+}
+var aK=aG[aH];
+if(aE>=aK.pos1+aK.len1){
+return aE+aK.pos2+aK.len2-aK.pos1-aK.len1;
+}
+if(!aF){
+aF=PosTranslator.DefaultInsideChunkHandler;
+}
+return aF(aE,aK);
+};
+PosTranslator.DefaultInsideChunkHandler=function(aE,aL){
+Assert(false,"Cannot translate position in changed area");
+};
+PosTranslator.ShiftWithTopInsideChunkHandler=
+function(aE,aL){
+return aE-aL.pos1+aL.pos2;
+};
+var i={
+UNCHANGED:"unchanged",
+SOURCE_CHANGED:"source changed",
+CHANGED:"changed",
+DAMAGED:"damaged"
+};
+function CodeInfoTreeNode(aM,aN,aO){
+this.info=aM;
+this.children=aN;
+this.array_index=aO;
+this.parent=(void 0);
+this.status=i.UNCHANGED;
+this.status_explanation=(void 0);
+this.new_start_pos=(void 0);
+this.new_end_pos=(void 0);
+this.corresponding_node=(void 0);
+this.unmatched_new_nodes=(void 0);
+this.textual_corresponding_node=(void 0);
+this.textually_unmatched_new_nodes=(void 0);
+this.live_shared_function_infos=(void 0);
+}
+function BuildCodeInfoTree(aP){
+var aQ=0;
+function BuildNode(){
+var aR=aQ;
+aQ++;
+var aS=new e();
+while(aQ<aP.length&&
+aP[aQ].outer_index==aR){
+aS.push(BuildNode());
+}
+var w=new CodeInfoTreeNode(aP[aR],aS,
+aR);
+for(var x=0;x<aS.length;x++){
+aS[x].parent=w;
+}
+return w;
+}
+var aT=BuildNode();
+Assert(aQ==aP.length);
+return aT;
+}
+function MarkChangedFunctions(aU,ay){
+var aV=new function(){
+var aW=0;
+var aX=0;
+this.current=function(){return ay[aW];};
+this.next=function(){
+var aK=ay[aW];
+aX=aK.pos2+aK.len2-(aK.pos1+aK.len1);
+aW++;
+};
+this.done=function(){return aW>=ay.length;};
+this.TranslatePos=function(aE){return aE+aX;};
+};
+function ProcessInternals(aY){
+aY.new_start_pos=aV.TranslatePos(
+aY.info.start_position);
+var aZ=0;
+var ba=false;
+var bb=false;
+while(!aV.done()&&
+aV.current().pos1<aY.info.end_position){
+if(aZ<aY.children.length){
+var bc=aY.children[aZ];
+if(bc.info.end_position<=aV.current().pos1){
+ProcessUnchangedChild(bc);
+aZ++;
+continue;
+}else if(bc.info.start_position>=
+aV.current().pos1+aV.current().len1){
+ba=true;
+aV.next();
+continue;
+}else if(bc.info.start_position<=aV.current().pos1&&
+bc.info.end_position>=aV.current().pos1+
+aV.current().len1){
+ProcessInternals(bc);
+bb=bb||
+(bc.status!=i.UNCHANGED);
+ba=ba||
+(bc.status==i.DAMAGED);
+aZ++;
+continue;
+}else{
+ba=true;
+bc.status=i.DAMAGED;
+bc.status_explanation=
+"Text diff overlaps with function boundary";
+aZ++;
+continue;
+}
+}else{
+if(aV.current().pos1+aV.current().len1<=
+aY.info.end_position){
+aY.status=i.CHANGED;
+aV.next();
+continue;
+}else{
+aY.status=i.DAMAGED;
+aY.status_explanation=
+"Text diff overlaps with function boundary";
+return;
+}
+}
+Assert("Unreachable",false);
+}
+while(aZ<aY.children.length){
+var bc=aY.children[aZ];
+ProcessUnchangedChild(bc);
+aZ++;
+}
+if(ba){
+aY.status=i.CHANGED;
+}else if(bb){
+aY.status=i.SOURCE_CHANGED;
+}
+aY.new_end_pos=
+aV.TranslatePos(aY.info.end_position);
+}
+function ProcessUnchangedChild(w){
+w.new_start_pos=aV.TranslatePos(w.info.start_position);
+w.new_end_pos=aV.TranslatePos(w.info.end_position);
+}
+ProcessInternals(aU);
+}
+function FindCorrespondingFunctions(bd,be){
+function ProcessNode(v,bf){
+var bg=
+IsFunctionContextLocalsChanged(v.info,bf.info);
+if(bg){
+v.status=i.CHANGED;
+}
+var bh=v.children;
+var bi=bf.children;
+var bj=[];
+var bk=[];
+var bl=0;
+var bm=0;
+while(bl<bh.length){
+if(bh[bl].status==i.DAMAGED){
+bl++;
+}else if(bm<bi.length){
+if(bi[bm].info.start_position<
+bh[bl].new_start_pos){
+bj.push(bi[bm]);
+bk.push(bi[bm]);
+bm++;
+}else if(bi[bm].info.start_position==
+bh[bl].new_start_pos){
+if(bi[bm].info.end_position==
+bh[bl].new_end_pos){
+bh[bl].corresponding_node=
+bi[bm];
+bh[bl].textual_corresponding_node=
+bi[bm];
+if(bg){
+bh[bl].status=i.DAMAGED;
+bh[bl].status_explanation=
+"Enclosing function is now incompatible. "+
+bg;
+bh[bl].corresponding_node=(void 0);
+}else if(bh[bl].status!=
+i.UNCHANGED){
+ProcessNode(bh[bl],
+bi[bm]);
+if(bh[bl].status==i.DAMAGED){
+bj.push(
+bh[bl].corresponding_node);
+bh[bl].corresponding_node=(void 0);
+v.status=i.CHANGED;
+}
+}
+}else{
+bh[bl].status=i.DAMAGED;
+bh[bl].status_explanation=
+"No corresponding function in new script found";
+v.status=i.CHANGED;
+bj.push(bi[bm]);
+bk.push(bi[bm]);
+}
+bm++;
+bl++;
+}else{
+bh[bl].status=i.DAMAGED;
+bh[bl].status_explanation=
+"No corresponding function in new script found";
+v.status=i.CHANGED;
+bl++;
+}
+}else{
+bh[bl].status=i.DAMAGED;
+bh[bl].status_explanation=
+"No corresponding function in new script found";
+v.status=i.CHANGED;
+bl++;
+}
+}
+while(bm<bi.length){
+bj.push(bi[bm]);
+bk.push(bi[bm]);
+bm++;
+}
+if(v.status==i.CHANGED){
+if(v.info.param_num!=bf.info.param_num){
+v.status=i.DAMAGED;
+v.status_explanation="Changed parameter number: "+
+v.info.param_num+" and "+bf.info.param_num;
+}
+}
+v.unmatched_new_nodes=bj;
+v.textually_unmatched_new_nodes=
+bk;
+}
+ProcessNode(bd,be);
+bd.corresponding_node=be;
+bd.textual_corresponding_node=be;
+Assert(bd.status!=i.DAMAGED,
+"Script became damaged");
+}
+function FindLiveSharedInfos(bd,N){
+var bn=%LiveEditFindSharedFunctionInfosForScript(N);
+var bo=new e();
+for(var x=0;x<bn.length;x++){
+bo.push(new SharedInfoWrapper(bn[x]));
+}
+function FindFunctionInfos(P){
+var bp=[];
+for(var x=0;x<bo.length;x++){
+var bq=bo[x];
+if(bq.start_position==P.start_position&&
+bq.end_position==P.end_position){
+bp.push(bq);
+}
+}
+if(bp.length>0){
+return bp;
+}
+}
+function TraverseTree(w){
+w.live_shared_function_infos=FindFunctionInfos(w.info);
+for(var x=0;x<w.children.length;x++){
+TraverseTree(w.children[x]);
+}
+}
+TraverseTree(bd);
+}
+function FunctionCompileInfo(br){
+this.function_name=br[0];
+this.start_position=br[1];
+this.end_position=br[2];
+this.param_num=br[3];
+this.code=br[4];
+this.code_scope_info=br[5];
+this.scope_info=br[6];
+this.outer_index=br[7];
+this.shared_function_info=br[8];
+this.next_sibling_index=null;
+this.raw_array=br;
+}
+function SharedInfoWrapper(br){
+this.function_name=br[0];
+this.start_position=br[1];
+this.end_position=br[2];
+this.info=br[3];
+this.raw_array=br;
+}
+function PatchPositions(ad,ax,ae){
+if(ad.live_shared_function_infos){
+ad.live_shared_function_infos.forEach(function(L){
+%LiveEditPatchFunctionPositions(L.raw_array,
+ax);
+});
+ae.push({name:ad.info.function_name});
+}else{
+ae.push(
+{name:ad.info.function_name,info_not_found:true});
+}
+}
+function CreateNameForOldScript(N){
+return N.name+" (old)";
+}
+function IsFunctionContextLocalsChanged(bs,bt){
+var bu=bs.scope_info;
+var bv=bt.scope_info;
+var bw;
+var bx;
+if(bu){
+bw=bu.toString();
+}else{
+bw="";
+}
+if(bv){
+bx=bv.toString();
+}else{
+bx="";
+}
+if(bw!=bx){
+return"Variable map changed: ["+bw+
+"] => ["+bx+"]";
+}
+return;
+}
+var by;
+function CheckStackActivations(old_shared_wrapper_list,
+new_shared_list,
+Z){
+var bz=new e();
+for(var x=0;x<old_shared_wrapper_list.length;x++){
+bz[x]=old_shared_wrapper_list[x].info;
+}
+var bA=%LiveEditCheckAndDropActivations(
+bz,new_shared_list,true);
+if(bA[old_shared_wrapper_list.length]){
+throw new Failure(bA[old_shared_wrapper_list.length]);
+}
+var bB=new e();
+var bC=new e();
+for(var x=0;x<bz.length;x++){
+var bD=old_shared_wrapper_list[x];
+if(bA[x]==by.REPLACED_ON_ACTIVE_STACK){
+bC.push({name:bD.function_name});
+}else if(bA[x]!=by.AVAILABLE_FOR_PATCH){
+var bE={
+name:bD.function_name,
+start_pos:bD.start_position,
+end_pos:bD.end_position,
+replace_problem:
+by.SymbolName(bA[x])
+};
+bB.push(bE);
+}
+}
+if(bC.length>0){
+Z.push({dropped_from_stack:bC});
+}
+if(bB.length>0){
+Z.push({functions_on_stack:bB});
+throw new Failure("Blocked by functions on stack");
+}
+return bC.length;
+}
+var by={
+AVAILABLE_FOR_PATCH:1,
+BLOCKED_ON_ACTIVE_STACK:2,
+BLOCKED_ON_OTHER_STACK:3,
+BLOCKED_UNDER_NATIVE_CODE:4,
+REPLACED_ON_ACTIVE_STACK:5,
+BLOCKED_UNDER_GENERATOR:6,
+BLOCKED_ACTIVE_GENERATOR:7,
+BLOCKED_NO_NEW_TARGET_ON_RESTART:8
+};
+by.SymbolName=function(bF){
+var bG=by;
+for(var bH in bG){
+if(bG[bH]==bF){
+return bH;
+}
+}
+};
+function Failure(as){
+this.message=as;
+}
+Failure.prototype.toString=function(){
+return"LiveEdit Failure: "+this.message;
+};
+function CopyErrorPositionToDetails(bI,p){
+function createPositionStruct(N,bJ){
+if(bJ==-1)return;
+var bK=N.locationFromPosition(bJ,true);
+if(bK==null)return;
+return{
+line:bK.line+1,
+column:bK.column+1,
+position:bJ
+};
+}
+if(!("scriptObject"in bI)||!("startPosition"in bI)){
+return;
+}
+var N=bI.scriptObject;
+var bL={
+start:createPositionStruct(N,bI.startPosition),
+end:createPositionStruct(N,bI.endPosition)
+};
+p.position=bL;
+}
+function GetPcFromSourcePos(bM,bN){
+return %GetFunctionCodePositionFromSource(bM,bN);
+}
+function SetScriptSource(N,bO,bP,Z){
+var j=N.source;
+var bQ=CompareStrings(j,bO);
+return ApplyPatchMultiChunk(N,bQ,bO,bP,
+Z);
+}
+function CompareStrings(bR,bS){
+return %LiveEditCompareStrings(bR,bS);
+}
+function ApplySingleChunkPatch(N,change_pos,change_len,new_str,
+Z){
+var j=N.source;
+var bO=j.substring(0,change_pos)+
+new_str+j.substring(change_pos+change_len);
+return ApplyPatchMultiChunk(N,
+[change_pos,change_pos+change_len,change_pos+new_str.length],
+bO,false,Z);
+}
+function DescribeChangeTree(bd){
+function ProcessOldNode(w){
+var bT=[];
+for(var x=0;x<w.children.length;x++){
+var bc=w.children[x];
+if(bc.status!=i.UNCHANGED){
+bT.push(ProcessOldNode(bc));
+}
+}
+var bU=[];
+if(w.textually_unmatched_new_nodes){
+for(var x=0;x<w.textually_unmatched_new_nodes.length;x++){
+var bc=w.textually_unmatched_new_nodes[x];
+bU.push(ProcessNewNode(bc));
+}
+}
+var bV={
+name:w.info.function_name,
+positions:DescribePositions(w),
+status:w.status,
+children:bT,
+new_children:bU
+};
+if(w.status_explanation){
+bV.status_explanation=w.status_explanation;
+}
+if(w.textual_corresponding_node){
+bV.new_positions=DescribePositions(w.textual_corresponding_node);
+}
+return bV;
+}
+function ProcessNewNode(w){
+var bT=[];
+if(false){
+for(var x=0;x<w.children.length;x++){
+bT.push(ProcessNewNode(w.children[x]));
+}
+}
+var bV={
+name:w.info.function_name,
+positions:DescribePositions(w),
+children:bT,
+};
+return bV;
+}
+function DescribePositions(w){
+return{
+start_position:w.info.start_position,
+end_position:w.info.end_position
+};
+}
+return ProcessOldNode(bd);
+}
+var bW={};
+bW.SetScriptSource=SetScriptSource;
+bW.ApplyPatchMultiChunk=ApplyPatchMultiChunk;
+bW.Failure=Failure;
+bW.GetPcFromSourcePos=GetPcFromSourcePos;
+bW.TestApi={
+PosTranslator:PosTranslator,
+CompareStrings:CompareStrings,
+ApplySingleChunkPatch:ApplySingleChunkPatch
+};
+a.Debug.LiveEdit=bW;
+})
+
+l prologueR
+(function(a,b,c){
+"use strict";
+%CheckIsBootstrapping();
+var d=(void 0);
+var e=(void 0);
+var f=%ExportFromRuntime({});
+var g=(void 0);
+function SetupTypedArray(h){
+h.next=g;
+g=h;
+}
+function Export(h){
+h(f);
+}
+function Import(h){
+h.next=d;
+d=h;
+}
+function ImportNow(i){
+return f[i];
+}
+function ImportFromExperimental(h){
+h.next=e;
+e=h;
+}
+function SetFunctionName(h,i,j){
+if((typeof(i)==='symbol')){
+i="["+%SymbolDescription(i)+"]";
+}
+if((j===(void 0))){
+%FunctionSetName(h,i);
+}else{
+%FunctionSetName(h,j+" "+i);
+}
+}
+function InstallConstants(k,l){
+%CheckIsBootstrapping();
+%OptimizeObjectForAddingMultipleProperties(k,l.length>>1);
+var m=2|4|1;
+for(var n=0;n<l.length;n+=2){
+var i=l[n];
+var o=l[n+1];
+%AddNamedProperty(k,i,o,m);
+}
+%ToFastProperties(k);
+}
+function InstallFunctions(k,m,p){
+%CheckIsBootstrapping();
+%OptimizeObjectForAddingMultipleProperties(k,p.length>>1);
+for(var n=0;n<p.length;n+=2){
+var q=p[n];
+var h=p[n+1];
+SetFunctionName(h,q);
+%FunctionRemovePrototype(h);
+%AddNamedProperty(k,q,h,m);
+%SetNativeFlag(h);
+}
+%ToFastProperties(k);
+}
+function InstallGetter(k,i,r,m,j){
+%CheckIsBootstrapping();
+if((m===(void 0)))m=2;
+SetFunctionName(r,i,(j===(void 0))?"get":j);
+%FunctionRemovePrototype(r);
+%DefineGetterPropertyUnchecked(k,i,r,m);
+%SetNativeFlag(r);
+}
+function InstallGetterSetter(k,i,r,s,m){
+%CheckIsBootstrapping();
+if((m===(void 0)))m=2;
+SetFunctionName(r,i,"get");
+SetFunctionName(s,i,"set");
+%FunctionRemovePrototype(r);
+%FunctionRemovePrototype(s);
+%DefineAccessorPropertyUnchecked(k,i,r,s,2);
+%SetNativeFlag(r);
+%SetNativeFlag(s);
+}
+function OverrideFunction(k,i,h,t){
+%CheckIsBootstrapping();
+%ObjectDefineProperty(k,i,{value:h,
+writeable:true,
+configurable:true,
+enumerable:false});
+SetFunctionName(h,i);
+if(!t)%FunctionRemovePrototype(h);
+%SetNativeFlag(h);
+}
+function SetUpLockedPrototype(
+constructor,fields,methods){
+%CheckIsBootstrapping();
+var u=constructor.prototype;
+var v=(methods.length>>1)+(fields?fields.length:0);
+if(v>=4){
+%OptimizeObjectForAddingMultipleProperties(u,v);
+}
+if(fields){
+for(var n=0;n<fields.length;n++){
+%AddNamedProperty(u,fields[n],
+(void 0),2|4);
+}
+}
+for(var n=0;n<methods.length;n+=2){
+var q=methods[n];
+var h=methods[n+1];
+%AddNamedProperty(u,q,h,2|4|1);
+%SetNativeFlag(h);
+}
+%InternalSetPrototype(u,null);
+%ToFastProperties(u);
+}
+function PostNatives(b){
+%CheckIsBootstrapping();
+for(;!(d===(void 0));d=d.next){
+d(f);
+}
+var w=[
+"ArrayToString",
+"ErrorToString",
+"GetIterator",
+"GetMethod",
+"IsNaN",
+"MakeError",
+"MakeRangeError",
+"MakeTypeError",
+"MapEntries",
+"MapIterator",
+"MapIteratorNext",
+"MaxSimple",
+"MinSimple",
+"NumberIsInteger",
+"ObjectDefineProperty",
+"ObserveArrayMethods",
+"ObserveObjectMethods",
+"PromiseChain",
+"PromiseDeferred",
+"PromiseResolved",
+"RegExpSubclassExecJS",
+"RegExpSubclassMatch",
+"RegExpSubclassReplace",
+"RegExpSubclassSearch",
+"RegExpSubclassSplit",
+"RegExpSubclassTest",
+"SetIterator",
+"SetIteratorNext",
+"SetValues",
+"SymbolToString",
+"ToPositiveInteger",
+"is_concat_spreadable_symbol",
+"iterator_symbol",
+"promise_status_symbol",
+"promise_value_symbol",
+"object_freeze",
+"object_is_frozen",
+"object_is_sealed",
+"reflect_apply",
+"reflect_construct",
+"regexp_flags_symbol",
+"to_string_tag_symbol",
+"object_to_string",
+"species_symbol",
+"match_symbol",
+"replace_symbol",
+"search_symbol",
+"split_symbol",
+];
+var x={};
+%OptimizeObjectForAddingMultipleProperties(
+x,w.length);
+for(var q of w){
+x[q]=f[q];
+}
+%ToFastProperties(x);
+f=x;
+b.PostNatives=(void 0);
+b.ImportFromExperimental=(void 0);
+}
+function PostExperimentals(b){
+%CheckIsBootstrapping();
+%ExportExperimentalFromRuntime(f);
+for(;!(d===(void 0));d=d.next){
+d(f);
+}
+for(;!(e===(void 0));
+e=e.next){
+e(f);
+}
+b.CreateDoubleResultArray();
+b.CreateDoubleResultArray=(void 0);
+b.Export=(void 0);
+b.PostDebug=(void 0);
+b.PostExperimentals=(void 0);
+g=(void 0);
+}
+function PostDebug(b){
+for(;!(d===(void 0));d=d.next){
+d(f);
+}
+b.CreateDoubleResultArray();
+b.CreateDoubleResultArray=(void 0);
+f=(void 0);
+b.Export=(void 0);
+b.Import=(void 0);
+b.ImportNow=(void 0);
+b.PostDebug=(void 0);
+b.PostExperimentals=(void 0);
+g=(void 0);
+}
+function InitializeBuiltinTypedArrays(b,y,z){
+var A=g;
+for(;!(A===(void 0));A=A.next){
+A(y,z);
+}
+}
+%OptimizeObjectForAddingMultipleProperties(b,14);
+b.Import=Import;
+b.ImportNow=ImportNow;
+b.Export=Export;
+b.ImportFromExperimental=ImportFromExperimental;
+b.SetFunctionName=SetFunctionName;
+b.InstallConstants=InstallConstants;
+b.InstallFunctions=InstallFunctions;
+b.InstallGetter=InstallGetter;
+b.InstallGetterSetter=InstallGetterSetter;
+b.OverrideFunction=OverrideFunction;
+b.SetUpLockedPrototype=SetUpLockedPrototype;
+b.PostNatives=PostNatives;
+b.PostExperimentals=PostExperimentals;
+b.PostDebug=PostDebug;
+%ToFastProperties(b);
+%OptimizeObjectForAddingMultipleProperties(c,5);
+c.logStackTrace=function logStackTrace(){
+%DebugTrace();
+};
+c.log=function log(){
+let message='';
+for(const arg of arguments){
+message+=arg;
+}
+%GlobalPrint(message);
+};
+c.createPrivateSymbol=function createPrivateSymbol(i){
+return %CreatePrivateSymbol(i);
+};
+c.simpleBind=function simpleBind(B,C){
+return function(...args){
+return %reflect_apply(B,C,args);
+};
+};
+c.uncurryThis=function uncurryThis(B){
+return function(C,...args){
+return %reflect_apply(B,C,args);
+};
+};
+%ToFastProperties(c);
+})
+
+runtime-
+(function(a,b){
+%CheckIsBootstrapping();
+var c;
+var d=a.Array;
+var e=a.Boolean;
+var f=a.String;
+var g;
+var h;
+var i;
+b.Import(function(j){
+g=j.MakeRangeError;
+h=j.MakeTypeError;
+i=j.species_symbol;
+});
+b.ImportFromExperimental(function(j){
+c=j.FLAG_harmony_species;
+});
+function AddIndexedProperty(k,l,m){
+if(l===((l)>>>0)&&l!==4294967295){
+%AddElement(k,l,m);
+}else{
+%AddNamedProperty(k,(%_ToString(l)),m,0);
+}
+}
+%SetForceInlineFlag(AddIndexedProperty);
+function ToPositiveInteger(n,o){
+var p=(%_IsSmi(%IS_VAR(n))?n:%NumberToIntegerMapMinusZero(n));
+if(p<0)throw g(o);
+return p;
+}
+function MaxSimple(q,r){
+return q>r?q:r;
+}
+function MinSimple(q,r){
+return q>r?r:q;
+}
+%SetForceInlineFlag(MaxSimple);
+%SetForceInlineFlag(MinSimple);
+function SpeciesConstructor(s,t,u){
+if(c){
+var v=s.constructor;
+if((v===(void 0))){
+return t;
+}
+if(!(%_IsJSReceiver(v))){
+throw h(29);
+}
+var w=v[i];
+if((w==null)){
+return t;
+}
+if(%IsConstructor(w)){
+return w;
+}
+throw h(242);
+}else{
+return u?t:s.constructor;
+}
+}
+%FunctionSetPrototype(d,new d(0));
+b.Export(function(x){
+x.AddIndexedProperty=AddIndexedProperty;
+x.MaxSimple=MaxSimple;
+x.MinSimple=MinSimple;
+x.ToPositiveInteger=ToPositiveInteger;
+x.SpeciesConstructor=SpeciesConstructor;
+});
+})
+
+$v8natives�

+(function(a,b){
+%CheckIsBootstrapping();
+var c=a.Array;
+var d=a.Number;
+var e=a.Object;
+var f=b.InternalArray;
+var g=b.ImportNow("iterator_symbol");
+var h;
+var i;
+var j;
+var k;
+var l=%GetRootNaN();
+var m=b.ImportNow("object_to_string");
+var n;
+var o;
+var p;
+var q=b.ImportNow("to_string_tag_symbol");
+b.Import(function(r){
+h=r.MakeRangeError;
+i=r.MakeSyntaxError;
+j=r.MakeTypeError;
+k=r.MathAbs;
+n=r.ObserveBeginPerformSplice;
+o=r.ObserveEndPerformSplice;
+p=r.ObserveEnqueueSpliceRecord;
+});
+function GlobalIsNaN(s){
+s=(%_ToNumber(s));
+return(!%_IsSmi(%IS_VAR(s))&&!(s==s));
+}
+function GlobalIsFinite(s){
+s=(%_ToNumber(s));
+return(%_IsSmi(%IS_VAR(s))||((s==s)&&(s!=1/0)&&(s!=-1/0)));
+}
+function GlobalParseInt(t,u){
+if((u===(void 0))||u===10||u===0){
+if(%_IsSmi(t))return t;
+if((typeof(t)==='number')&&
+((0.01<t&&t<1e9)||
+(-1e9<t&&t<-0.01))){
+return t|0;
+}
+t=(%_ToString(t));
+u=u|0;
+}else{
+t=(%_ToString(t));
+u=((u)|0);
+if(!(u==0||(2<=u&&u<=36))){
+return l;
+}
+}
+if(%_HasCachedArrayIndex(t)&&
+(u==0||u==10)){
+return %_GetCachedArrayIndex(t);
+}
+return %StringParseInt(t,u);
+}
+function GlobalParseFloat(t){
+t=(%_ToString(t));
+if(%_HasCachedArrayIndex(t))return %_GetCachedArrayIndex(t);
+return %StringParseFloat(t);
+}
+var v=2|4|1;
+b.InstallConstants(a,[
+"Infinity",(1/0),
+"NaN",l,
+"undefined",(void 0),
+]);
+b.InstallFunctions(a,2,[
+"isNaN",GlobalIsNaN,
+"isFinite",GlobalIsFinite,
+"parseInt",GlobalParseInt,
+"parseFloat",GlobalParseFloat,
+]);
+function ObjectToLocaleString(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(18,"Object.prototype.toLocaleString");
+return this.toString();
+}
+function ObjectValueOf(){
+return(%_ToObject(this));
+}
+function ObjectIsPrototypeOf(w){
+if(!(%_IsJSReceiver(w)))return false;
+var x=(%_ToObject(this));
+return %HasInPrototypeChain(w,x);
+}
+function ObjectPropertyIsEnumerable(w){
+var y=(%_ToName(w));
+return %PropertyIsEnumerable((%_ToObject(this)),y);
+}
+function ObjectDefineGetter(z,A){
+var B=this;
+if((B===null)||(B===(void 0))){
+B=%GlobalProxy(ObjectDefineGetter);
+}
+if(!(typeof(A)==='function')){
+throw j(76);
+}
+var C=new PropertyDescriptor();
+C.setGet(A);
+C.setEnumerable(true);
+C.setConfigurable(true);
+DefineOwnProperty((%_ToObject(B)),(%_ToName(z)),C,false);
+}
+function ObjectLookupGetter(z){
+var B=this;
+if((B===null)||(B===(void 0))){
+B=%GlobalProxy(ObjectLookupGetter);
+}
+return %LookupAccessor((%_ToObject(B)),(%_ToName(z)),0);
+}
+function ObjectDefineSetter(z,A){
+var B=this;
+if((B===null)||(B===(void 0))){
+B=%GlobalProxy(ObjectDefineSetter);
+}
+if(!(typeof(A)==='function')){
+throw j(79);
+}
+var C=new PropertyDescriptor();
+C.setSet(A);
+C.setEnumerable(true);
+C.setConfigurable(true);
+DefineOwnProperty((%_ToObject(B)),(%_ToName(z)),C,false);
+}
+function ObjectLookupSetter(z){
+var B=this;
+if((B===null)||(B===(void 0))){
+B=%GlobalProxy(ObjectLookupSetter);
+}
+return %LookupAccessor((%_ToObject(B)),(%_ToName(z)),1);
+}
+function IsAccessorDescriptor(C){
+if((C===(void 0)))return false;
+return C.hasGetter()||C.hasSetter();
+}
+function IsDataDescriptor(C){
+if((C===(void 0)))return false;
+return C.hasValue()||C.hasWritable();
+}
+function IsGenericDescriptor(C){
+if((C===(void 0)))return false;
+return!(IsAccessorDescriptor(C)||IsDataDescriptor(C));
+}
+function IsInconsistentDescriptor(C){
+return IsAccessorDescriptor(C)&&IsDataDescriptor(C);
+}
+function FromGenericPropertyDescriptor(C){
+if((C===(void 0)))return C;
+var D=new e();
+if(C.hasValue()){
+%AddNamedProperty(D,"value",C.getValue(),0);
+}
+if(C.hasWritable()){
+%AddNamedProperty(D,"writable",C.isWritable(),0);
+}
+if(C.hasGetter()){
+%AddNamedProperty(D,"get",C.getGet(),0);
+}
+if(C.hasSetter()){
+%AddNamedProperty(D,"set",C.getSet(),0);
+}
+if(C.hasEnumerable()){
+%AddNamedProperty(D,"enumerable",C.isEnumerable(),0);
+}
+if(C.hasConfigurable()){
+%AddNamedProperty(D,"configurable",C.isConfigurable(),0);
+}
+return D;
+}
+function ToPropertyDescriptor(D){
+if(!(%_IsJSReceiver(D)))throw j(95,D);
+var C=new PropertyDescriptor();
+if("enumerable"in D){
+C.setEnumerable((!!(D.enumerable)));
+}
+if("configurable"in D){
+C.setConfigurable((!!(D.configurable)));
+}
+if("value"in D){
+C.setValue(D.value);
+}
+if("writable"in D){
+C.setWritable((!!(D.writable)));
+}
+if("get"in D){
+var E=D.get;
+if(!(E===(void 0))&&!(typeof(E)==='function')){
+throw j(77,E);
+}
+C.setGet(E);
+}
+if("set"in D){
+var F=D.set;
+if(!(F===(void 0))&&!(typeof(F)==='function')){
+throw j(80,F);
+}
+C.setSet(F);
+}
+if(IsInconsistentDescriptor(C)){
+throw j(153,D);
+}
+return C;
+}
+function ToCompletePropertyDescriptor(D){
+var C=ToPropertyDescriptor(D);
+if(IsGenericDescriptor(C)||IsDataDescriptor(C)){
+if(!C.hasValue())C.setValue((void 0));
+if(!C.hasWritable())C.setWritable(false);
+}else{
+if(!C.hasGetter())C.setGet((void 0));
+if(!C.hasSetter())C.setSet((void 0));
+}
+if(!C.hasEnumerable())C.setEnumerable(false);
+if(!C.hasConfigurable())C.setConfigurable(false);
+return C;
+}
+function PropertyDescriptor(){
+this.value_=(void 0);
+this.hasValue_=false;
+this.writable_=false;
+this.hasWritable_=false;
+this.enumerable_=false;
+this.hasEnumerable_=false;
+this.configurable_=false;
+this.hasConfigurable_=false;
+this.get_=(void 0);
+this.hasGetter_=false;
+this.set_=(void 0);
+this.hasSetter_=false;
+}
+b.SetUpLockedPrototype(PropertyDescriptor,[
+"value_",
+"hasValue_",
+"writable_",
+"hasWritable_",
+"enumerable_",
+"hasEnumerable_",
+"configurable_",
+"hasConfigurable_",
+"get_",
+"hasGetter_",
+"set_",
+"hasSetter_"
+],[
+"toString",function PropertyDescriptor_ToString(){
+return"[object PropertyDescriptor]";
+},
+"setValue",function PropertyDescriptor_SetValue(G){
+this.value_=G;
+this.hasValue_=true;
+},
+"getValue",function PropertyDescriptor_GetValue(){
+return this.value_;
+},
+"hasValue",function PropertyDescriptor_HasValue(){
+return this.hasValue_;
+},
+"setEnumerable",function PropertyDescriptor_SetEnumerable(H){
+this.enumerable_=H;
+this.hasEnumerable_=true;
+},
+"isEnumerable",function PropertyDescriptor_IsEnumerable(){
+return this.enumerable_;
+},
+"hasEnumerable",function PropertyDescriptor_HasEnumerable(){
+return this.hasEnumerable_;
+},
+"setWritable",function PropertyDescriptor_SetWritable(I){
+this.writable_=I;
+this.hasWritable_=true;
+},
+"isWritable",function PropertyDescriptor_IsWritable(){
+return this.writable_;
+},
+"hasWritable",function PropertyDescriptor_HasWritable(){
+return this.hasWritable_;
+},
+"setConfigurable",
+function PropertyDescriptor_SetConfigurable(J){
+this.configurable_=J;
+this.hasConfigurable_=true;
+},
+"hasConfigurable",function PropertyDescriptor_HasConfigurable(){
+return this.hasConfigurable_;
+},
+"isConfigurable",function PropertyDescriptor_IsConfigurable(){
+return this.configurable_;
+},
+"setGet",function PropertyDescriptor_SetGetter(E){
+this.get_=E;
+this.hasGetter_=true;
+},
+"getGet",function PropertyDescriptor_GetGetter(){
+return this.get_;
+},
+"hasGetter",function PropertyDescriptor_HasGetter(){
+return this.hasGetter_;
+},
+"setSet",function PropertyDescriptor_SetSetter(F){
+this.set_=F;
+this.hasSetter_=true;
+},
+"getSet",function PropertyDescriptor_GetSetter(){
+return this.set_;
+},
+"hasSetter",function PropertyDescriptor_HasSetter(){
+return this.hasSetter_;
+}
+]);
+function ConvertDescriptorArrayToDescriptor(K){
+if((K===(void 0))){
+return(void 0);
+}
+var C=new PropertyDescriptor();
+if(K[0]){
+C.setGet(K[2]);
+C.setSet(K[3]);
+}else{
+C.setValue(K[1]);
+C.setWritable(K[4]);
+}
+C.setEnumerable(K[5]);
+C.setConfigurable(K[6]);
+return C;
+}
+function GetTrap(L,z,M){
+var N=L[z];
+if((N===(void 0))){
+if((M===(void 0))){
+throw j(43);
+}
+N=M;
+}else if(!(typeof(N)==='function')){
+throw j(43);
+}
+return N;
+}
+function CallTrap1(L,z,M,O){
+return %_Call(GetTrap(L,z,M),L,O);
+}
+function CallTrap2(L,z,M,O,P){
+return %_Call(GetTrap(L,z,M),L,O,P);
+}
+function GetOwnPropertyJS(D,Q){
+var R=(%_ToName(Q));
+if((%_IsJSProxy(D))){
+if((typeof(Q)==='symbol'))return(void 0);
+var L=%JSProxyGetHandler(D);
+var S=CallTrap1(
+L,"getOwnPropertyDescriptor",(void 0),R);
+if((S===(void 0)))return S;
+var C=ToCompletePropertyDescriptor(S);
+if(!C.isConfigurable()){
+throw j(43);
+}
+return C;
+}
+var T=%GetOwnProperty_Legacy((%_ToObject(D)),R);
+return ConvertDescriptorArrayToDescriptor(T);
+}
+function GetMethod(D,R){
+var U=D[R];
+if((U==null))return(void 0);
+if((typeof(U)==='function'))return U;
+throw j(15,typeof U);
+}
+function DefineProxyProperty(D,R,v,V){
+if((typeof(R)==='symbol'))return false;
+var L=%JSProxyGetHandler(D);
+var W=CallTrap2(L,"defineProperty",(void 0),R,v);
+if(!W){
+if(V){
+throw j(43);
+}else{
+return false;
+}
+}
+return true;
+}
+function DefineObjectProperty(D,R,C,V){
+var X=%GetOwnProperty_Legacy(D,(%_ToName(R)));
+var Y=ConvertDescriptorArrayToDescriptor(X);
+var Z=%object_is_extensible(D);
+if((Y===(void 0))&&!Z){
+if(V){
+throw j(36,R);
+}else{
+return false;
+}
+}
+if(!(Y===(void 0))){
+if((IsGenericDescriptor(C)||
+IsDataDescriptor(C)==IsDataDescriptor(Y))&&
+(!C.hasEnumerable()||
+%SameValue(C.isEnumerable(),Y.isEnumerable()))&&
+(!C.hasConfigurable()||
+%SameValue(C.isConfigurable(),Y.isConfigurable()))&&
+(!C.hasWritable()||
+%SameValue(C.isWritable(),Y.isWritable()))&&
+(!C.hasValue()||
+%SameValue(C.getValue(),Y.getValue()))&&
+(!C.hasGetter()||
+%SameValue(C.getGet(),Y.getGet()))&&
+(!C.hasSetter()||
+%SameValue(C.getSet(),Y.getSet()))){
+return true;
+}
+if(!Y.isConfigurable()){
+if(C.isConfigurable()||
+(C.hasEnumerable()&&
+C.isEnumerable()!=Y.isEnumerable())){
+if(V){
+throw j(129,R);
+}else{
+return false;
+}
+}
+if(!IsGenericDescriptor(C)){
+if(IsDataDescriptor(Y)!=IsDataDescriptor(C)){
+if(V){
+throw j(129,R);
+}else{
+return false;
+}
+}
+if(IsDataDescriptor(Y)&&IsDataDescriptor(C)){
+var aa=Y.isWritable();
+if(aa!=C.isWritable()){
+if(!aa){
+if(V){
+throw j(129,R);
+}else{
+return false;
+}
+}
+}
+if(!aa&&C.hasValue()&&
+!%SameValue(C.getValue(),Y.getValue())){
+if(V){
+throw j(129,R);
+}else{
+return false;
+}
+}
+}
+if(IsAccessorDescriptor(C)&&IsAccessorDescriptor(Y)){
+if(C.hasSetter()&&
+!%SameValue(C.getSet(),Y.getSet())){
+if(V){
+throw j(129,R);
+}else{
+return false;
+}
+}
+if(C.hasGetter()&&!%SameValue(C.getGet(),Y.getGet())){
+if(V){
+throw j(129,R);
+}else{
+return false;
+}
+}
+}
+}
+}
+}
+var ab=0;
+if(C.hasEnumerable()){
+ab|=C.isEnumerable()?0:2;
+}else if(!(Y===(void 0))){
+ab|=Y.isEnumerable()?0:2;
+}else{
+ab|=2;
+}
+if(C.hasConfigurable()){
+ab|=C.isConfigurable()?0:4;
+}else if(!(Y===(void 0))){
+ab|=Y.isConfigurable()?0:4;
+}else
+ab|=4;
+if(IsDataDescriptor(C)||
+(IsGenericDescriptor(C)&&
+((Y===(void 0))||IsDataDescriptor(Y)))){
+if(C.hasWritable()){
+ab|=C.isWritable()?0:1;
+}else if(!(Y===(void 0))){
+ab|=Y.isWritable()?0:1;
+}else{
+ab|=1;
+}
+var G=(void 0);
+if(C.hasValue()){
+G=C.getValue();
+}else if(!(Y===(void 0))&&IsDataDescriptor(Y)){
+G=Y.getValue();
+}
+%DefineDataPropertyUnchecked(D,R,G,ab);
+}else{
+var ac=null;
+if(C.hasGetter()){
+ac=C.getGet();
+}else if(IsAccessorDescriptor(Y)&&Y.hasGetter()){
+ac=Y.getGet();
+}
+var ad=null;
+if(C.hasSetter()){
+ad=C.getSet();
+}else if(IsAccessorDescriptor(Y)&&Y.hasSetter()){
+ad=Y.getSet();
+}
+%DefineAccessorPropertyUnchecked(D,R,ac,ad,ab);
+}
+return true;
+}
+function DefineArrayProperty(D,R,C,V){
+if(!(typeof(R)==='symbol')){
+var ae=((R)>>>0);
+var af=false;
+if((%_ToString(ae))==R&&ae!=4294967295){
+var ag=D.length;
+if(ae>=ag&&%IsObserved(D)){
+af=true;
+n(D);
+}
+var ah=GetOwnPropertyJS(D,"length");
+if((ae>=ag&&!ah.isWritable())||
+!DefineObjectProperty(D,R,C,true)){
+if(af)
+o(D);
+if(V){
+throw j(36,R);
+}else{
+return false;
+}
+}
+if(ae>=ag){
+D.length=ae+1;
+}
+if(af){
+o(D);
+p(D,ag,[],ae+1-ag);
+}
+return true;
+}
+}
+return DefineObjectProperty(D,R,C,V);
+}
+function DefineOwnProperty(D,R,C,V){
+if((%_IsJSProxy(D))){
+if((typeof(R)==='symbol'))return false;
+var v=FromGenericPropertyDescriptor(C);
+return DefineProxyProperty(D,R,v,V);
+}else if((%_IsArray(D))){
+return DefineArrayProperty(D,R,C,V);
+}else{
+return DefineObjectProperty(D,R,C,V);
+}
+}
+function ObjectGetPrototypeOf(D){
+return %_GetPrototype((%_ToObject(D)));
+}
+function ObjectSetPrototypeOf(D,ai){
+if((%IS_VAR(D)===null)||(D===(void 0)))throw j(18,"Object.setPrototypeOf");
+if(ai!==null&&!(%_IsJSReceiver(ai))){
+throw j(97,ai);
+}
+if((%_IsJSReceiver(D))){
+%SetPrototype(D,ai);
+}
+return D;
+}
+function ObjectDefineProperty(D,R,v){
+if(%IsObserved(D)){
+if(!(%_IsJSReceiver(D))){
+throw j(17,"Object.defineProperty");
+}
+var z=(%_ToName(R));
+var C=ToPropertyDescriptor(v);
+DefineOwnProperty(D,z,C,true);
+return D;
+}
+return %ObjectDefineProperty(D,R,v);
+}
+function ObjectDefineProperties(D,aj){
+if(%IsObserved(D)){
+if(!(%_IsJSReceiver(D))){
+throw j(17,"Object.defineProperties");
+}
+var T=(%_ToObject(aj));
+var ak=%GetOwnPropertyKeys(T,2);
+var al=new f();
+for(var am=0;am<ak.length;am++){
+al.push(ToPropertyDescriptor(T[ak[am]]));
+}
+for(var am=0;am<ak.length;am++){
+DefineOwnProperty(D,ak[am],al[am],true);
+}
+return D;
+}
+return %ObjectDefineProperties(D,aj);
+}
+function ObjectGetProto(){
+return %_GetPrototype((%_ToObject(this)));
+}
+function ObjectSetProto(ai){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(18,"Object.prototype.__proto__");
+if(((%_IsJSReceiver(ai))||(ai===null))&&(%_IsJSReceiver(this))){
+%SetPrototype(this,ai);
+}
+}
+function ObjectConstructor(O){
+if(e!=new.target&&!(new.target===(void 0))){
+return this;
+}
+if((O===null)||(O===(void 0)))return{};
+return(%_ToObject(O));
+}
+%SetNativeFlag(e);
+%SetCode(e,ObjectConstructor);
+%AddNamedProperty(e.prototype,"constructor",e,
+2);
+b.InstallFunctions(e.prototype,2,[
+"toString",m,
+"toLocaleString",ObjectToLocaleString,
+"valueOf",ObjectValueOf,
+"isPrototypeOf",ObjectIsPrototypeOf,
+"propertyIsEnumerable",ObjectPropertyIsEnumerable,
+"__defineGetter__",ObjectDefineGetter,
+"__lookupGetter__",ObjectLookupGetter,
+"__defineSetter__",ObjectDefineSetter,
+"__lookupSetter__",ObjectLookupSetter
+]);
+b.InstallGetterSetter(e.prototype,"__proto__",ObjectGetProto,
+ObjectSetProto);
+b.InstallFunctions(e,2,[
+"defineProperty",ObjectDefineProperty,
+"defineProperties",ObjectDefineProperties,
+"getPrototypeOf",ObjectGetPrototypeOf,
+"setPrototypeOf",ObjectSetPrototypeOf,
+]);
+function NumberToStringJS(u){
+var s=this;
+if(!(typeof(this)==='number')){
+if(!(%_ClassOf(this)==='Number')){
+throw j(69,'Number.prototype.toString');
+}
+s=%_ValueOf(this);
+}
+if((u===(void 0))||u===10){
+return %_NumberToString(s);
+}
+u=(%_ToInteger(u));
+if(u<2||u>36)throw h(188);
+return %NumberToRadixString(s,u);
+}
+function NumberToLocaleString(){
+return %_Call(NumberToStringJS,this);
+}
+function NumberValueOf(){
+if(!(typeof(this)==='number')&&!(%_ClassOf(this)==='Number')){
+throw j(69,'Number.prototype.valueOf');
+}
+return %_ValueOf(this);
+}
+function NumberToFixedJS(an){
+var O=this;
+if(!(typeof(this)==='number')){
+if(!(%_ClassOf(this)==='Number')){
+throw j(44,
+"Number.prototype.toFixed",this);
+}
+O=%_ValueOf(this);
+}
+var ao=(%_ToInteger(an));
+if(ao<0||ao>20){
+throw h(184,"toFixed() digits");
+}
+if((!%_IsSmi(%IS_VAR(O))&&!(O==O)))return"NaN";
+if(O==(1/0))return"Infinity";
+if(O==-(1/0))return"-Infinity";
+return %NumberToFixed(O,ao);
+}
+function NumberToExponentialJS(an){
+var O=this;
+if(!(typeof(this)==='number')){
+if(!(%_ClassOf(this)==='Number')){
+throw j(44,
+"Number.prototype.toExponential",this);
+}
+O=%_ValueOf(this);
+}
+var ao=(an===(void 0))?(void 0):(%_ToInteger(an));
+if((!%_IsSmi(%IS_VAR(O))&&!(O==O)))return"NaN";
+if(O==(1/0))return"Infinity";
+if(O==-(1/0))return"-Infinity";
+if((ao===(void 0))){
+ao=-1;
+}else if(ao<0||ao>20){
+throw h(184,"toExponential()");
+}
+return %NumberToExponential(O,ao);
+}
+function NumberToPrecisionJS(ap){
+var O=this;
+if(!(typeof(this)==='number')){
+if(!(%_ClassOf(this)==='Number')){
+throw j(44,
+"Number.prototype.toPrecision",this);
+}
+O=%_ValueOf(this);
+}
+if((ap===(void 0)))return(%_ToString(O));
+var R=(%_ToInteger(ap));
+if((!%_IsSmi(%IS_VAR(O))&&!(O==O)))return"NaN";
+if(O==(1/0))return"Infinity";
+if(O==-(1/0))return"-Infinity";
+if(R<1||R>21){
+throw h(187);
+}
+return %NumberToPrecision(O,R);
+}
+function NumberIsFinite(s){
+return(typeof(s)==='number')&&(%_IsSmi(%IS_VAR(s))||((s==s)&&(s!=1/0)&&(s!=-1/0)));
+}
+function NumberIsInteger(s){
+return NumberIsFinite(s)&&(%_ToInteger(s))==s;
+}
+function NumberIsNaN(s){
+return(typeof(s)==='number')&&(!%_IsSmi(%IS_VAR(s))&&!(s==s));
+}
+function NumberIsSafeInteger(s){
+if(NumberIsFinite(s)){
+var aq=(%_ToInteger(s));
+if(aq==s){
+return k(aq)<=9007199254740991;
+}
+}
+return false;
+}
+%FunctionSetPrototype(d,new d(0));
+%OptimizeObjectForAddingMultipleProperties(d.prototype,8);
+%AddNamedProperty(d.prototype,"constructor",d,
+2);
+b.InstallConstants(d,[
+"MAX_VALUE",1.7976931348623157e+308,
+"MIN_VALUE",5e-324,
+"NaN",l,
+"NEGATIVE_INFINITY",-(1/0),
+"POSITIVE_INFINITY",(1/0),
+"MAX_SAFE_INTEGER",%_MathPow(2,53)-1,
+"MIN_SAFE_INTEGER",-%_MathPow(2,53)+1,
+"EPSILON",%_MathPow(2,-52)
+]);
+b.InstallFunctions(d.prototype,2,[
+"toString",NumberToStringJS,
+"toLocaleString",NumberToLocaleString,
+"valueOf",NumberValueOf,
+"toFixed",NumberToFixedJS,
+"toExponential",NumberToExponentialJS,
+"toPrecision",NumberToPrecisionJS
+]);
+b.InstallFunctions(d,2,[
+"isFinite",NumberIsFinite,
+"isInteger",NumberIsInteger,
+"isNaN",NumberIsNaN,
+"isSafeInteger",NumberIsSafeInteger,
+"parseInt",GlobalParseInt,
+"parseFloat",GlobalParseFloat
+]);
+%SetForceInlineFlag(NumberIsNaN);
+function GetIterator(D,ar){
+if((ar===(void 0))){
+ar=D[g];
+}
+if(!(typeof(ar)==='function')){
+throw j(70,D);
+}
+var as=%_Call(ar,D);
+if(!(%_IsJSReceiver(as))){
+throw j(64,as);
+}
+return as;
+}
+b.Export(function(at){
+at.GetIterator=GetIterator;
+at.GetMethod=GetMethod;
+at.IsFinite=GlobalIsFinite;
+at.IsNaN=GlobalIsNaN;
+at.NumberIsNaN=NumberIsNaN;
+at.NumberIsInteger=NumberIsInteger;
+at.ObjectDefineProperties=ObjectDefineProperties;
+at.ObjectDefineProperty=ObjectDefineProperty;
+at.ObjectHasOwnProperty=e.prototype.hasOwnProperty;
+});
+%InstallToContext([
+"object_value_of",ObjectValueOf,
+]);
+})
+
+symbol�
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Symbol;
+var d=b.ImportNow("has_instance_symbol");
+var e=
+b.ImportNow("is_concat_spreadable_symbol");
+var f=b.ImportNow("iterator_symbol");
+var g;
+var h=b.ImportNow("to_primitive_symbol");
+var i=b.ImportNow("to_string_tag_symbol");
+var j=b.ImportNow("unscopables_symbol");
+b.Import(function(k){
+g=k.MakeTypeError;
+});
+function SymbolToPrimitive(l){
+if(!((typeof(this)==='symbol')||(%_ClassOf(this)==='Symbol'))){
+throw g(44,
+"Symbol.prototype [ @@toPrimitive ]",this);
+}
+return %_ValueOf(this);
+}
+function SymbolToString(){
+if(!((typeof(this)==='symbol')||(%_ClassOf(this)==='Symbol'))){
+throw g(44,
+"Symbol.prototype.toString",this);
+}
+return %SymbolDescriptiveString(%_ValueOf(this));
+}
+function SymbolValueOf(){
+if(!((typeof(this)==='symbol')||(%_ClassOf(this)==='Symbol'))){
+throw g(44,
+"Symbol.prototype.valueOf",this);
+}
+return %_ValueOf(this);
+}
+function SymbolFor(m){
+m=(%_ToString(m));
+var n=%SymbolRegistry();
+if((n.for[m]===(void 0))){
+var o=%CreateSymbol(m);
+n.for[m]=o;
+n.keyFor[o]=m;
+}
+return n.for[m];
+}
+function SymbolKeyFor(o){
+if(!(typeof(o)==='symbol'))throw g(147,o);
+return %SymbolRegistry().keyFor[o];
+}
+b.InstallConstants(c,[
+"hasInstance",d,
+"isConcatSpreadable",e,
+"iterator",f,
+"toPrimitive",h,
+"toStringTag",i,
+"unscopables",j,
+]);
+b.InstallFunctions(c,2,[
+"for",SymbolFor,
+"keyFor",SymbolKeyFor
+]);
+%AddNamedProperty(
+c.prototype,i,"Symbol",2|1);
+b.InstallFunctions(c.prototype,2|1,[
+h,SymbolToPrimitive
+]);
+b.InstallFunctions(c.prototype,2,[
+"toString",SymbolToString,
+"valueOf",SymbolValueOf
+]);
+b.Export(function(p){
+p.SymbolToString=SymbolToString;
+})
+})
+
+arrayf�

+(function(a,b,c){
+"use strict";
+%CheckIsBootstrapping();
+var d;
+var e;
+var f;
+var g;
+var h=a.Array;
+var i=b.InternalArray;
+var j=b.InternalPackedArray;
+var k;
+var l;
+var m;
+var n;
+var o;
+var p=b.ImportNow("object_to_string");
+var q;
+var r;
+var s;
+var t=b.ImportNow("iterator_symbol");
+var u=b.ImportNow("unscopables_symbol");
+b.Import(function(v){
+d=v.AddIndexedProperty;
+f=v.GetIterator;
+g=v.GetMethod;
+k=v.MakeTypeError;
+l=v.MaxSimple;
+m=v.MinSimple;
+n=v.ObjectDefineProperty;
+o=v.ObjectHasOwnProperty;
+q=v.ObserveBeginPerformSplice;
+r=v.ObserveEndPerformSplice;
+s=v.ObserveEnqueueSpliceRecord;
+});
+b.ImportFromExperimental(function(v){
+e=v.FLAG_harmony_species;
+});
+function ArraySpeciesCreate(w,x){
+var y;
+if(e){
+y=%ArraySpeciesConstructor(w);
+}else{
+y=h;
+}
+return new y(x);
+}
+function DefineIndexedProperty(w,z,A){
+if(e){
+var B=n(w,z,{
+value:A,writable:true,configurable:true,enumerable:true
+});
+if(!B)throw k(141,z);
+}else{
+d(w,z,A);
+}
+}
+function KeySortCompare(C,D){
+return C-D;
+}
+function GetSortedArrayKeys(w,E){
+if((typeof(E)==='number')){
+var F=new i();
+var G=E;
+for(var z=0;z<G;++z){
+var H=w[z];
+if(!(H===(void 0))||z in w){
+F.push(z);
+}
+}
+return F;
+}
+return InnerArraySort(E,E.length,KeySortCompare);
+}
+function SparseJoinWithSeparatorJS(w,F,x,I,J){
+var K=F.length;
+var L=new i(K*2);
+for(var z=0;z<K;z++){
+var M=F[z];
+var H=w[M];
+L[z*2]=M;
+L[z*2+1]=(typeof(H)==='string')?H:I(H);
+}
+return %SparseJoinWithSeparator(L,x,J);
+}
+function SparseJoin(w,F,I){
+var K=F.length;
+var L=new i(K);
+for(var z=0;z<K;z++){
+var H=w[F[z]];
+L[z]=(typeof(H)==='string')?H:I(H);
+}
+return %StringBuilderConcat(L,K,'');
+}
+function UseSparseVariant(w,x,N,O){
+if(!N||x<1000||%IsObserved(w)||
+%HasComplexElements(w)){
+return false;
+}
+if(!%_IsSmi(x)){
+return true;
+}
+var P=x>>2;
+var Q=%EstimateNumberOfElements(w);
+return(Q<P)&&
+(O>Q*4);
+}
+function Stack(){
+this.length=0;
+this.values=new i();
+}
+Stack.prototype.length=null;
+Stack.prototype.values=null;
+function StackPush(R,A){
+R.values[R.length++]=A;
+}
+function StackPop(R){
+R.values[--R.length]=null
+}
+function StackHas(R,S){
+var x=R.length;
+var T=R.values;
+for(var z=0;z<x;z++){
+if(T[z]===S)return true;
+}
+return false;
+}
+var U=new Stack();
+function DoJoin(w,x,N,J,I){
+if(UseSparseVariant(w,x,N,x)){
+%NormalizeElements(w);
+var F=GetSortedArrayKeys(w,%GetArrayKeys(w,x));
+if(J===''){
+if(F.length===0)return'';
+return SparseJoin(w,F,I);
+}else{
+return SparseJoinWithSeparatorJS(w,F,x,I,J);
+}
+}
+if(x===1){
+var H=w[0];
+return(typeof(H)==='string')?H:I(H);
+}
+var L=new i(x);
+if(J===''){
+for(var z=0;z<x;z++){
+var H=w[z];
+L[z]=(typeof(H)==='string')?H:I(H);
+}
+return %StringBuilderConcat(L,x,'');
+}
+var H=w[0];
+if((typeof(H)==='number')){
+L[0]=%_NumberToString(H);
+for(var z=1;z<x;z++){
+H=w[z];
+if((typeof(H)==='number')){
+L[z]=%_NumberToString(H);
+}else{
+L[z]=(typeof(H)==='string')?H:I(H);
+}
+}
+}else{
+L[0]=(typeof(H)==='string')?H:I(H);
+for(var z=1;z<x;z++){
+H=w[z];
+L[z]=(typeof(H)==='string')?H:I(H);
+}
+}
+return %StringBuilderJoin(L,x,J);
+}
+function Join(w,x,J,I){
+if(x===0)return'';
+var N=(%_IsArray(w));
+if(N){
+if(StackHas(U,w))return'';
+StackPush(U,w);
+}
+try{
+return DoJoin(w,x,N,J,I);
+}finally{
+if(N)StackPop(U);
+}
+}
+function ConvertToString(V){
+if((V==null))return'';
+return(%_ToString(V));
+}
+function ConvertToLocaleString(H){
+if((H==null))return'';
+return(%_ToString(H.toLocaleString()));
+}
+function SparseSlice(w,W,X,Y,Z){
+var E=%GetArrayKeys(w,W+X);
+if((typeof(E)==='number')){
+var G=E;
+for(var z=W;z<G;++z){
+var aa=w[z];
+if(!(aa===(void 0))||z in w){
+DefineIndexedProperty(Z,z-W,aa);
+}
+}
+}else{
+var x=E.length;
+for(var ab=0;ab<x;++ab){
+var M=E[ab];
+if(M>=W){
+var aa=w[M];
+if(!(aa===(void 0))||M in w){
+DefineIndexedProperty(Z,M-W,aa);
+}
+}
+}
+}
+}
+function SparseMove(w,W,X,Y,ac){
+if(ac===X)return;
+var ad=new i(
+m(Y-X+ac,0xffffffff));
+var ae;
+var E=%GetArrayKeys(w,Y);
+if((typeof(E)==='number')){
+var G=E;
+for(var z=0;z<W&&z<G;++z){
+var aa=w[z];
+if(!(aa===(void 0))||z in w){
+ad[z]=aa;
+}
+}
+for(var z=W+X;z<G;++z){
+var aa=w[z];
+if(!(aa===(void 0))||z in w){
+ad[z-X+ac]=aa;
+}
+}
+}else{
+var x=E.length;
+for(var ab=0;ab<x;++ab){
+var M=E[ab];
+if(M<W){
+var aa=w[M];
+if(!(aa===(void 0))||M in w){
+ad[M]=aa;
+}
+}else if(M>=W+X){
+var aa=w[M];
+if(!(aa===(void 0))||M in w){
+var af=M-X+ac;
+ad[af]=aa;
+if(af>0xfffffffe){
+ae=ae||new i();
+ae.push(af);
+}
+}
+}
+}
+}
+%MoveArrayContents(ad,w);
+if(!(ae===(void 0))){
+var x=ae.length;
+for(var z=0;z<x;++z){
+var M=ae[z];
+w[M]=ad[M];
+}
+}
+}
+function SimpleSlice(w,W,X,Y,Z){
+var N=(%_IsArray(w));
+for(var z=0;z<X;z++){
+var ag=W+z;
+if(((N&&%_HasFastPackedElements(%IS_VAR(w))&&(ag<w.length))||(ag in w))){
+var aa=w[ag];
+DefineIndexedProperty(Z,z,aa);
+}
+}
+}
+function SimpleMove(w,W,X,Y,ac){
+var N=(%_IsArray(w));
+if(ac!==X){
+if(ac>X){
+for(var z=Y-X;z>W;z--){
+var ah=z+X-1;
+var ai=z+ac-1;
+if(((N&&%_HasFastPackedElements(%IS_VAR(w))&&(ah<w.length))||(ah in w))){
+w[ai]=w[ah];
+}else{
+delete w[ai];
+}
+}
+}else{
+for(var z=W;z<Y-X;z++){
+var ah=z+X;
+var ai=z+ac;
+if(((N&&%_HasFastPackedElements(%IS_VAR(w))&&(ah<w.length))||(ah in w))){
+w[ai]=w[ah];
+}else{
+delete w[ai];
+}
+}
+for(var z=Y;z>Y-X+ac;z--){
+delete w[z-1];
+}
+}
+}
+}
+function ArrayToString(){
+var w;
+var aj;
+if((%_IsArray(this))){
+aj=this.join;
+if(aj===ArrayJoin){
+return Join(this,this.length,',',ConvertToString);
+}
+w=this;
+}else{
+w=(%_ToObject(this));
+aj=w.join;
+}
+if(!(typeof(aj)==='function')){
+return %_Call(p,w);
+}
+return %_Call(aj,w);
+}
+function InnerArrayToLocaleString(w,x){
+var Y=(%_ToLength(x));
+if(Y===0)return"";
+return Join(w,Y,',',ConvertToLocaleString);
+}
+function ArrayToLocaleString(){
+var w=(%_ToObject(this));
+var ak=w.length;
+return InnerArrayToLocaleString(w,ak);
+}
+function InnerArrayJoin(J,w,x){
+if((J===(void 0))){
+J=',';
+}else{
+J=(%_ToString(J));
+}
+if(x===1){
+var H=w[0];
+if((H==null))return'';
+return(%_ToString(H));
+}
+return Join(w,x,J,ConvertToString);
+}
+function ArrayJoin(J){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"Array.prototype.join");
+var w=(%_ToObject(this));
+var x=(%_ToLength(w.length));
+return InnerArrayJoin(J,w,x);
+}
+function ObservedArrayPop(al){
+al--;
+var A=this[al];
+try{
+q(this);
+delete this[al];
+this.length=al;
+}finally{
+r(this);
+s(this,al,[A],0);
+}
+return A;
+}
+function ArrayPop(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"Array.prototype.pop");
+var w=(%_ToObject(this));
+var al=(%_ToLength(w.length));
+if(al==0){
+w.length=al;
+return;
+}
+if(%IsObserved(w))
+return ObservedArrayPop.call(w,al);
+al--;
+var A=w[al];
+%DeleteProperty_Strict(w,al);
+w.length=al;
+return A;
+}
+function ObservedArrayPush(){
+var al=(%_ToLength(this.length));
+var am=arguments.length;
+try{
+q(this);
+for(var z=0;z<am;z++){
+this[z+al]=arguments[z];
+}
+var an=al+am;
+this.length=an;
+}finally{
+r(this);
+s(this,al,[],am);
+}
+return an;
+}
+function ArrayPush(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"Array.prototype.push");
+if(%IsObserved(this))
+return ObservedArrayPush.apply(this,arguments);
+var w=(%_ToObject(this));
+var al=(%_ToLength(w.length));
+var am=arguments.length;
+if(am>(1<<30)||(al-(1<<30))+am>9007199254740991-(1<<30)){
+throw k(233,am,al);
+}
+for(var z=0;z<am;z++){
+w[z+al]=arguments[z];
+}
+var an=al+am;
+w.length=an;
+return an;
+}
+function SparseReverse(w,Y){
+var F=GetSortedArrayKeys(w,%GetArrayKeys(w,Y));
+var ao=F.length-1;
+var ap=0;
+while(ap<=ao){
+var z=F[ap];
+var aq=F[ao];
+var ar=Y-aq-1;
+var as,at;
+if(ar<=z){
+at=aq;
+while(F[--ao]==aq){}
+as=ar;
+}
+if(ar>=z){
+as=z;
+while(F[++ap]==z){}
+at=Y-z-1;
+}
+var au=w[as];
+if(!(au===(void 0))||as in w){
+var av=w[at];
+if(!(av===(void 0))||at in w){
+w[as]=av;
+w[at]=au;
+}else{
+w[at]=au;
+delete w[as];
+}
+}else{
+var av=w[at];
+if(!(av===(void 0))||at in w){
+w[as]=av;
+delete w[at];
+}
+}
+}
+}
+function PackedArrayReverse(w,Y){
+var aq=Y-1;
+for(var z=0;z<aq;z++,aq--){
+var au=w[z];
+var av=w[aq];
+w[z]=av;
+w[aq]=au;
+}
+return w;
+}
+function GenericArrayReverse(w,Y){
+var aq=Y-1;
+for(var z=0;z<aq;z++,aq--){
+if(z in w){
+var au=w[z];
+if(aq in w){
+var av=w[aq];
+w[z]=av;
+w[aq]=au;
+}else{
+w[aq]=au;
+delete w[z];
+}
+}else{
+if(aq in w){
+var av=w[aq];
+w[z]=av;
+delete w[aq];
+}
+}
+}
+return w;
+}
+function ArrayReverse(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"Array.prototype.reverse");
+var w=(%_ToObject(this));
+var Y=(%_ToLength(w.length));
+var aw=(%_IsArray(w));
+if(UseSparseVariant(w,Y,aw,Y)){
+%NormalizeElements(w);
+SparseReverse(w,Y);
+return w;
+}else if(aw&&%_HasFastPackedElements(w)){
+return PackedArrayReverse(w,Y);
+}else{
+return GenericArrayReverse(w,Y);
+}
+}
+function ObservedArrayShift(Y){
+var ax=this[0];
+try{
+q(this);
+SimpleMove(this,0,1,Y,0);
+this.length=Y-1;
+}finally{
+r(this);
+s(this,0,[ax],0);
+}
+return ax;
+}
+function ArrayShift(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"Array.prototype.shift");
+var w=(%_ToObject(this));
+var Y=(%_ToLength(w.length));
+if(Y===0){
+w.length=0;
+return;
+}
+if(%object_is_sealed(w))throw k(13);
+if(%IsObserved(w))
+return ObservedArrayShift.call(w,Y);
+var ax=w[0];
+if(UseSparseVariant(w,Y,(%_IsArray(w)),Y)){
+SparseMove(w,0,1,Y,0);
+}else{
+SimpleMove(w,0,1,Y,0);
+}
+w.length=Y-1;
+return ax;
+}
+function ObservedArrayUnshift(){
+var Y=(%_ToLength(this.length));
+var ay=arguments.length;
+try{
+q(this);
+SimpleMove(this,0,0,Y,ay);
+for(var z=0;z<ay;z++){
+this[z]=arguments[z];
+}
+var an=Y+ay;
+this.length=an;
+}finally{
+r(this);
+s(this,0,[],ay);
+}
+return an;
+}
+function ArrayUnshift(az){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"Array.prototype.unshift");
+if(%IsObserved(this))
+return ObservedArrayUnshift.apply(this,arguments);
+var w=(%_ToObject(this));
+var Y=(%_ToLength(w.length));
+var ay=arguments.length;
+if(Y>0&&UseSparseVariant(w,Y,(%_IsArray(w)),Y)&&
+!%object_is_sealed(w)){
+SparseMove(w,0,0,Y,ay);
+}else{
+SimpleMove(w,0,0,Y,ay);
+}
+for(var z=0;z<ay;z++){
+w[z]=arguments[z];
+}
+var an=Y+ay;
+w.length=an;
+return an;
+}
+function ArraySlice(aA,aB){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"Array.prototype.slice");
+var w=(%_ToObject(this));
+var Y=(%_ToLength(w.length));
+var W=(%_ToInteger(aA));
+var aC=Y;
+if(!(aB===(void 0)))aC=(%_ToInteger(aB));
+if(W<0){
+W+=Y;
+if(W<0)W=0;
+}else{
+if(W>Y)W=Y;
+}
+if(aC<0){
+aC+=Y;
+if(aC<0)aC=0;
+}else{
+if(aC>Y)aC=Y;
+}
+var B=ArraySpeciesCreate(w,l(aC-W,0));
+if(aC<W)return B;
+if(UseSparseVariant(w,Y,(%_IsArray(w)),aC-W)){
+%NormalizeElements(w);
+%NormalizeElements(B);
+SparseSlice(w,W,aC-W,Y,B);
+}else{
+SimpleSlice(w,W,aC-W,Y,B);
+}
+B.length=aC-W;
+return B;
+}
+function ComputeSpliceStartIndex(W,Y){
+if(W<0){
+W+=Y;
+return W<0?0:W;
+}
+return W>Y?Y:W;
+}
+function ComputeSpliceDeleteCount(aD,ay,Y,W){
+var X=0;
+if(ay==1)
+return Y-W;
+X=(%_ToInteger(aD));
+if(X<0)
+return 0;
+if(X>Y-W)
+return Y-W;
+return X;
+}
+function ObservedArraySplice(aA,aD){
+var ay=arguments.length;
+var Y=(%_ToLength(this.length));
+var W=ComputeSpliceStartIndex((%_ToInteger(aA)),Y);
+var X=ComputeSpliceDeleteCount(aD,ay,Y,
+W);
+var Z=[];
+Z.length=X;
+var aE=ay>2?ay-2:0;
+try{
+q(this);
+SimpleSlice(this,W,X,Y,Z);
+SimpleMove(this,W,X,Y,aE);
+var z=W;
+var aF=2;
+var aG=arguments.length;
+while(aF<aG){
+this[z++]=arguments[aF++];
+}
+this.length=Y-X+aE;
+}finally{
+r(this);
+if(Z.length||aE){
+s(this,
+W,
+Z.slice(),
+aE);
+}
+}
+return Z;
+}
+function ArraySplice(aA,aD){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"Array.prototype.splice");
+if(%IsObserved(this))
+return ObservedArraySplice.apply(this,arguments);
+var ay=arguments.length;
+var w=(%_ToObject(this));
+var Y=(%_ToLength(w.length));
+var W=ComputeSpliceStartIndex((%_ToInteger(aA)),Y);
+var X=ComputeSpliceDeleteCount(aD,ay,Y,
+W);
+var Z=ArraySpeciesCreate(w,X);
+Z.length=X;
+var aE=ay>2?ay-2:0;
+if(X!=aE&&%object_is_sealed(w)){
+throw k(13);
+}else if(X>0&&%object_is_frozen(w)){
+throw k(12);
+}
+var aH=X;
+if(aE!=X){
+aH+=Y-W-X;
+}
+if(UseSparseVariant(w,Y,(%_IsArray(w)),aH)){
+%NormalizeElements(w);
+%NormalizeElements(Z);
+SparseSlice(w,W,X,Y,Z);
+SparseMove(w,W,X,Y,aE);
+}else{
+SimpleSlice(w,W,X,Y,Z);
+SimpleMove(w,W,X,Y,aE);
+}
+var z=W;
+var aF=2;
+var aG=arguments.length;
+while(aF<aG){
+w[z++]=arguments[aF++];
+}
+w.length=Y-X+aE;
+return Z;
+}
+function InnerArraySort(w,x,aI){
+if(!(typeof(aI)==='function')){
+aI=function(V,aJ){
+if(V===aJ)return 0;
+if(%_IsSmi(V)&&%_IsSmi(aJ)){
+return %SmiLexicographicCompare(V,aJ);
+}
+V=(%_ToString(V));
+aJ=(%_ToString(aJ));
+if(V==aJ)return 0;
+else return V<aJ?-1:1;
+};
+}
+var aK=function InsertionSort(C,v,aL){
+for(var z=v+1;z<aL;z++){
+var aM=C[z];
+for(var aq=z-1;aq>=v;aq--){
+var aN=C[aq];
+var aO=aI(aN,aM);
+if(aO>0){
+C[aq+1]=aN;
+}else{
+break;
+}
+}
+C[aq+1]=aM;
+}
+};
+var aP=function(C,v,aL){
+var aQ=new i();
+var aR=200+((aL-v)&15);
+var aq=0;
+v+=1;
+aL-=1;
+for(var z=v;z<aL;z+=aR){
+aQ[aq]=[z,C[z]];
+aq++;
+}
+aQ.sort(function(C,D){
+return aI(C[1],D[1]);
+});
+var aS=aQ[aQ.length>>1][0];
+return aS;
+}
+var aT=function QuickSort(C,v,aL){
+var aS=0;
+while(true){
+if(aL-v<=10){
+aK(C,v,aL);
+return;
+}
+if(aL-v>1000){
+aS=aP(C,v,aL);
+}else{
+aS=v+((aL-v)>>1);
+}
+var aU=C[v];
+var aV=C[aL-1];
+var aW=C[aS];
+var aX=aI(aU,aV);
+if(aX>0){
+var aN=aU;
+aU=aV;
+aV=aN;
+}
+var aY=aI(aU,aW);
+if(aY>=0){
+var aN=aU;
+aU=aW;
+aW=aV;
+aV=aN;
+}else{
+var aZ=aI(aV,aW);
+if(aZ>0){
+var aN=aV;
+aV=aW;
+aW=aN;
+}
+}
+C[v]=aU;
+C[aL-1]=aW;
+var ba=aV;
+var bb=v+1;
+var bc=aL-1;
+C[aS]=C[bb];
+C[bb]=ba;
+partition:for(var z=bb+1;z<bc;z++){
+var aM=C[z];
+var aO=aI(aM,ba);
+if(aO<0){
+C[z]=C[bb];
+C[bb]=aM;
+bb++;
+}else if(aO>0){
+do{
+bc--;
+if(bc==z)break partition;
+var bd=C[bc];
+aO=aI(bd,ba);
+}while(aO>0);
+C[z]=C[bc];
+C[bc]=aM;
+if(aO<0){
+aM=C[z];
+C[z]=C[bb];
+C[bb]=aM;
+bb++;
+}
+}
+}
+if(aL-bc<bb-v){
+aT(C,bc,aL);
+aL=bb;
+}else{
+aT(C,v,bb);
+v=bc;
+}
+}
+};
+var be=function CopyFromPrototype(bf,x){
+var bg=0;
+for(var bh=%_GetPrototype(bf);bh;bh=%_GetPrototype(bh)){
+var E=(%_IsJSProxy(bh))?x:%GetArrayKeys(bh,x);
+if((typeof(E)==='number')){
+var bi=E;
+for(var z=0;z<bi;z++){
+if(!(%_Call(o,bf,z))&&(%_Call(o,bh,z))){
+bf[z]=bh[z];
+if(z>=bg){bg=z+1;}
+}
+}
+}else{
+for(var z=0;z<E.length;z++){
+var ag=E[z];
+if(!(%_Call(o,bf,ag))&&(%_Call(o,bh,ag))){
+bf[ag]=bh[ag];
+if(ag>=bg){bg=ag+1;}
+}
+}
+}
+}
+return bg;
+};
+var bj=function(bf,v,aL){
+for(var bh=%_GetPrototype(bf);bh;bh=%_GetPrototype(bh)){
+var E=(%_IsJSProxy(bh))?aL:%GetArrayKeys(bh,aL);
+if((typeof(E)==='number')){
+var bi=E;
+for(var z=v;z<bi;z++){
+if((%_Call(o,bh,z))){
+bf[z]=(void 0);
+}
+}
+}else{
+for(var z=0;z<E.length;z++){
+var ag=E[z];
+if(v<=ag&&(%_Call(o,bh,ag))){
+bf[ag]=(void 0);
+}
+}
+}
+}
+};
+var bk=function SafeRemoveArrayHoles(bf){
+var bl=0;
+var bm=x-1;
+var bn=0;
+while(bl<bm){
+while(bl<bm&&
+!(bf[bl]===(void 0))){
+bl++;
+}
+if(!(%_Call(o,bf,bl))){
+bn++;
+}
+while(bl<bm&&
+(bf[bm]===(void 0))){
+if(!(%_Call(o,bf,bm))){
+bn++;
+}
+bm--;
+}
+if(bl<bm){
+bf[bl]=bf[bm];
+bf[bm]=(void 0);
+}
+}
+if(!(bf[bl]===(void 0)))bl++;
+var z;
+for(z=bl;z<x-bn;z++){
+bf[z]=(void 0);
+}
+for(z=x-bn;z<x;z++){
+if(z in %_GetPrototype(bf)){
+bf[z]=(void 0);
+}else{
+delete bf[z];
+}
+}
+return bl;
+};
+if(x<2)return w;
+var N=(%_IsArray(w));
+var bo;
+if(!N){
+bo=be(w,x);
+}
+var bp=%RemoveArrayHoles(w,x);
+if(bp==-1){
+bp=bk(w);
+}
+aT(w,0,bp);
+if(!N&&(bp+1<bo)){
+bj(w,bp,bo);
+}
+return w;
+}
+function ArraySort(aI){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"Array.prototype.sort");
+var w=(%_ToObject(this));
+var x=(%_ToLength(w.length));
+return InnerArraySort(w,x,aI);
+}
+function InnerArrayFilter(bq,br,w,x,B){
+var bs=0;
+var N=(%_IsArray(w));
+for(var z=0;z<x;z++){
+if(((N&&%_HasFastPackedElements(%IS_VAR(w))&&(z<w.length))||(z in w))){
+var aM=w[z];
+if(%_Call(bq,br,aM,z,w)){
+DefineIndexedProperty(B,bs,aM);
+bs++;
+}
+}
+}
+return B;
+}
+function ArrayFilter(bq,br){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"Array.prototype.filter");
+var w=(%_ToObject(this));
+var x=(%_ToLength(w.length));
+if(!(typeof(bq)==='function'))throw k(15,bq);
+var B=ArraySpeciesCreate(w,0);
+return InnerArrayFilter(bq,br,w,x,B);
+}
+function InnerArrayForEach(bq,br,w,x){
+if(!(typeof(bq)==='function'))throw k(15,bq);
+var N=(%_IsArray(w));
+if((br===(void 0))){
+for(var z=0;z<x;z++){
+if(((N&&%_HasFastPackedElements(%IS_VAR(w))&&(z<w.length))||(z in w))){
+var aM=w[z];
+bq(aM,z,w);
+}
+}
+}else{
+for(var z=0;z<x;z++){
+if(((N&&%_HasFastPackedElements(%IS_VAR(w))&&(z<w.length))||(z in w))){
+var aM=w[z];
+%_Call(bq,br,aM,z,w);
+}
+}
+}
+}
+function ArrayForEach(bq,br){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"Array.prototype.forEach");
+var w=(%_ToObject(this));
+var x=(%_ToLength(w.length));
+InnerArrayForEach(bq,br,w,x);
+}
+function InnerArraySome(bq,br,w,x){
+if(!(typeof(bq)==='function'))throw k(15,bq);
+var N=(%_IsArray(w));
+for(var z=0;z<x;z++){
+if(((N&&%_HasFastPackedElements(%IS_VAR(w))&&(z<w.length))||(z in w))){
+var aM=w[z];
+if(%_Call(bq,br,aM,z,w))return true;
+}
+}
+return false;
+}
+function ArraySome(bq,br){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"Array.prototype.some");
+var w=(%_ToObject(this));
+var x=(%_ToLength(w.length));
+return InnerArraySome(bq,br,w,x);
+}
+function InnerArrayEvery(bq,br,w,x){
+if(!(typeof(bq)==='function'))throw k(15,bq);
+var N=(%_IsArray(w));
+for(var z=0;z<x;z++){
+if(((N&&%_HasFastPackedElements(%IS_VAR(w))&&(z<w.length))||(z in w))){
+var aM=w[z];
+if(!%_Call(bq,br,aM,z,w))return false;
+}
+}
+return true;
+}
+function ArrayEvery(bq,br){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"Array.prototype.every");
+var w=(%_ToObject(this));
+var x=(%_ToLength(w.length));
+return InnerArrayEvery(bq,br,w,x);
+}
+function ArrayMap(bq,br){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"Array.prototype.map");
+var w=(%_ToObject(this));
+var x=(%_ToLength(w.length));
+if(!(typeof(bq)==='function'))throw k(15,bq);
+var B=ArraySpeciesCreate(w,x);
+var N=(%_IsArray(w));
+for(var z=0;z<x;z++){
+if(((N&&%_HasFastPackedElements(%IS_VAR(w))&&(z<w.length))||(z in w))){
+var aM=w[z];
+DefineIndexedProperty(B,z,%_Call(bq,br,aM,z,w));
+}
+}
+return B;
+}
+function InnerArrayIndexOf(w,aM,ag,x){
+if(x==0)return-1;
+if((ag===(void 0))){
+ag=0;
+}else{
+ag=(%_ToInteger(ag))+0;
+if(ag<0){
+ag=x+ag;
+if(ag<0)ag=0;
+}
+}
+var bt=ag;
+var bg=x;
+if(UseSparseVariant(w,x,(%_IsArray(w)),bg-bt)){
+%NormalizeElements(w);
+var E=%GetArrayKeys(w,x);
+if((typeof(E)==='number')){
+bg=E;
+}else{
+if(E.length==0)return-1;
+var bu=GetSortedArrayKeys(w,E);
+var al=bu.length;
+var z=0;
+while(z<al&&bu[z]<ag)z++;
+while(z<al){
+var M=bu[z];
+if(w[M]===aM)return M;
+z++;
+}
+return-1;
+}
+}
+if(!(aM===(void 0))){
+for(var z=bt;z<bg;z++){
+if(w[z]===aM)return z;
+}
+return-1;
+}
+for(var z=bt;z<bg;z++){
+if((w[z]===(void 0))&&z in w){
+return z;
+}
+}
+return-1;
+}
+function ArrayIndexOf(aM,ag){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"Array.prototype.indexOf");
+var x=(%_ToLength(this.length));
+return InnerArrayIndexOf(this,aM,ag,x);
+}
+function InnerArrayLastIndexOf(w,aM,ag,x,bv){
+if(x==0)return-1;
+if(bv<2){
+ag=x-1;
+}else{
+ag=(%_ToInteger(ag))+0;
+if(ag<0)ag+=x;
+if(ag<0)return-1;
+else if(ag>=x)ag=x-1;
+}
+var bt=0;
+var bg=ag;
+if(UseSparseVariant(w,x,(%_IsArray(w)),ag)){
+%NormalizeElements(w);
+var E=%GetArrayKeys(w,ag+1);
+if((typeof(E)==='number')){
+bg=E;
+}else{
+if(E.length==0)return-1;
+var bu=GetSortedArrayKeys(w,E);
+var z=bu.length-1;
+while(z>=0){
+var M=bu[z];
+if(w[M]===aM)return M;
+z--;
+}
+return-1;
+}
+}
+if(!(aM===(void 0))){
+for(var z=bg;z>=bt;z--){
+if(w[z]===aM)return z;
+}
+return-1;
+}
+for(var z=bg;z>=bt;z--){
+if((w[z]===(void 0))&&z in w){
+return z;
+}
+}
+return-1;
+}
+function ArrayLastIndexOf(aM,ag){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"Array.prototype.lastIndexOf");
+var x=(%_ToLength(this.length));
+return InnerArrayLastIndexOf(this,aM,ag,x,
+arguments.length);
+}
+function InnerArrayReduce(bw,aa,w,x,bv){
+if(!(typeof(bw)==='function')){
+throw k(15,bw);
+}
+var N=(%_IsArray(w));
+var z=0;
+find_initial:if(bv<2){
+for(;z<x;z++){
+if(((N&&%_HasFastPackedElements(%IS_VAR(w))&&(z<w.length))||(z in w))){
+aa=w[z++];
+break find_initial;
+}
+}
+throw k(131);
+}
+for(;z<x;z++){
+if(((N&&%_HasFastPackedElements(%IS_VAR(w))&&(z<w.length))||(z in w))){
+var aM=w[z];
+aa=bw(aa,aM,z,w);
+}
+}
+return aa;
+}
+function ArrayReduce(bw,aa){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"Array.prototype.reduce");
+var w=(%_ToObject(this));
+var x=(%_ToLength(w.length));
+return InnerArrayReduce(bw,aa,w,x,
+arguments.length);
+}
+function InnerArrayReduceRight(bw,aa,w,x,
+bv){
+if(!(typeof(bw)==='function')){
+throw k(15,bw);
+}
+var N=(%_IsArray(w));
+var z=x-1;
+find_initial:if(bv<2){
+for(;z>=0;z--){
+if(((N&&%_HasFastPackedElements(%IS_VAR(w))&&(z<w.length))||(z in w))){
+aa=w[z--];
+break find_initial;
+}
+}
+throw k(131);
+}
+for(;z>=0;z--){
+if(((N&&%_HasFastPackedElements(%IS_VAR(w))&&(z<w.length))||(z in w))){
+var aM=w[z];
+aa=bw(aa,aM,z,w);
+}
+}
+return aa;
+}
+function ArrayReduceRight(bw,aa){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"Array.prototype.reduceRight");
+var w=(%_ToObject(this));
+var x=(%_ToLength(w.length));
+return InnerArrayReduceRight(bw,aa,w,x,
+arguments.length);
+}
+function InnerArrayCopyWithin(bx,aA,aB,w,x){
+bx=(%_ToInteger(bx));
+var aL;
+if(bx<0){
+aL=l(x+bx,0);
+}else{
+aL=m(bx,x);
+}
+aA=(%_ToInteger(aA));
+var v;
+if(aA<0){
+v=l(x+aA,0);
+}else{
+v=m(aA,x);
+}
+aB=(aB===(void 0))?x:(%_ToInteger(aB));
+var by;
+if(aB<0){
+by=l(x+aB,0);
+}else{
+by=m(aB,x);
+}
+var bz=m(by-v,x-aL);
+var bA=1;
+if(v<aL&&aL<(v+bz)){
+bA=-1;
+v=v+bz-1;
+aL=aL+bz-1;
+}
+while(bz>0){
+if(v in w){
+w[aL]=w[v];
+}else{
+delete w[aL];
+}
+v=v+bA;
+aL=aL+bA;
+bz--;
+}
+return w;
+}
+function ArrayCopyWithin(bx,aA,aB){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"Array.prototype.copyWithin");
+var w=(%_ToObject(this));
+var x=(%_ToLength(w.length));
+return InnerArrayCopyWithin(bx,aA,aB,w,x);
+}
+function InnerArrayFind(bB,bC,w,x){
+if(!(typeof(bB)==='function')){
+throw k(15,bB);
+}
+for(var z=0;z<x;z++){
+var aM=w[z];
+if(%_Call(bB,bC,aM,z,w)){
+return aM;
+}
+}
+return;
+}
+function ArrayFind(bB,bC){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"Array.prototype.find");
+var w=(%_ToObject(this));
+var x=(%_ToInteger(w.length));
+return InnerArrayFind(bB,bC,w,x);
+}
+function InnerArrayFindIndex(bB,bC,w,x){
+if(!(typeof(bB)==='function')){
+throw k(15,bB);
+}
+for(var z=0;z<x;z++){
+var aM=w[z];
+if(%_Call(bB,bC,aM,z,w)){
+return z;
+}
+}
+return-1;
+}
+function ArrayFindIndex(bB,bC){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"Array.prototype.findIndex");
+var w=(%_ToObject(this));
+var x=(%_ToInteger(w.length));
+return InnerArrayFindIndex(bB,bC,w,x);
+}
+function InnerArrayFill(A,aA,aB,w,x){
+var z=(aA===(void 0))?0:(%_ToInteger(aA));
+var aB=(aB===(void 0))?x:(%_ToInteger(aB));
+if(z<0){
+z+=x;
+if(z<0)z=0;
+}else{
+if(z>x)z=x;
+}
+if(aB<0){
+aB+=x;
+if(aB<0)aB=0;
+}else{
+if(aB>x)aB=x;
+}
+if((aB-z)>0&&%object_is_frozen(w)){
+throw k(12);
+}
+for(;z<aB;z++)
+w[z]=A;
+return w;
+}
+function ArrayFill(A,aA,aB){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"Array.prototype.fill");
+var w=(%_ToObject(this));
+var x=(%_ToLength(w.length));
+return InnerArrayFill(A,aA,aB,w,x);
+}
+function InnerArrayIncludes(bD,bE,w,x){
+if(x===0){
+return false;
+}
+var al=(%_ToInteger(bE));
+var ab;
+if(al>=0){
+ab=al;
+}else{
+ab=x+al;
+if(ab<0){
+ab=0;
+}
+}
+while(ab<x){
+var bF=w[ab];
+if(%SameValueZero(bD,bF)){
+return true;
+}
+++ab;
+}
+return false;
+}
+function ArrayIncludes(bD,bE){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"Array.prototype.includes");
+var w=(%_ToObject(this));
+var x=(%_ToLength(w.length));
+return InnerArrayIncludes(bD,bE,w,x);
+}
+function AddArrayElement(y,w,z,A){
+if(y===h){
+d(w,z,A);
+}else{
+n(w,z,{
+value:A,writable:true,configurable:true,enumerable:true
+});
+}
+}
+function ArrayFrom(bG,bH,br){
+var bI=(%_ToObject(bG));
+var bJ=!(bH===(void 0));
+if(bJ){
+if(!(typeof(bH)==='function')){
+throw k(15,bH);
+}
+}
+var bK=g(bI,t);
+var ab;
+var B;
+var bL;
+var bM;
+if(!(bK===(void 0))){
+B=%IsConstructor(this)?new this():[];
+ab=0;
+for(bM of
+{[t](){return f(bI,bK)}}){
+if(bJ){
+bL=%_Call(bH,br,bM,ab);
+}else{
+bL=bM;
+}
+AddArrayElement(this,B,ab,bL);
+ab++;
+}
+B.length=ab;
+return B;
+}else{
+var Y=(%_ToLength(bI.length));
+B=%IsConstructor(this)?new this(Y):new h(Y);
+for(ab=0;ab<Y;++ab){
+bM=bI[ab];
+if(bJ){
+bL=%_Call(bH,br,bM,ab);
+}else{
+bL=bM;
+}
+AddArrayElement(this,B,ab,bL);
+}
+B.length=ab;
+return B;
+}
+}
+function ArrayOf(...args){
+var x=args.length;
+var y=this;
+var w=%IsConstructor(y)?new y(x):[];
+for(var z=0;z<x;z++){
+AddArrayElement(y,w,z,args[z]);
+}
+w.length=x;
+return w;
+}
+%AddNamedProperty(h.prototype,"constructor",h,
+2);
+var bN={
+__proto__:null,
+copyWithin:true,
+entries:true,
+fill:true,
+find:true,
+findIndex:true,
+keys:true,
+};
+%AddNamedProperty(h.prototype,u,bN,
+2|1);
+%FunctionSetLength(ArrayFrom,1);
+b.InstallFunctions(h,2,[
+"from",ArrayFrom,
+"of",ArrayOf
+]);
+var bO=%SpecialArrayFunctions();
+var bP=function(bQ,bR,Y){
+var bq=bR;
+if(bO.hasOwnProperty(bQ)){
+bq=bO[bQ];
+}
+if(!(Y===(void 0))){
+%FunctionSetLength(bq,Y);
+}
+return bq;
+};
+b.InstallFunctions(h.prototype,2,[
+"toString",bP("toString",ArrayToString),
+"toLocaleString",bP("toLocaleString",ArrayToLocaleString),
+"join",bP("join",ArrayJoin),
+"pop",bP("pop",ArrayPop),
+"push",bP("push",ArrayPush,1),
+"reverse",bP("reverse",ArrayReverse),
+"shift",bP("shift",ArrayShift),
+"unshift",bP("unshift",ArrayUnshift,1),
+"slice",bP("slice",ArraySlice,2),
+"splice",bP("splice",ArraySplice,2),
+"sort",bP("sort",ArraySort),
+"filter",bP("filter",ArrayFilter,1),
+"forEach",bP("forEach",ArrayForEach,1),
+"some",bP("some",ArraySome,1),
+"every",bP("every",ArrayEvery,1),
+"map",bP("map",ArrayMap,1),
+"indexOf",bP("indexOf",ArrayIndexOf,1),
+"lastIndexOf",bP("lastIndexOf",ArrayLastIndexOf,1),
+"reduce",bP("reduce",ArrayReduce,1),
+"reduceRight",bP("reduceRight",ArrayReduceRight,1),
+"copyWithin",bP("copyWithin",ArrayCopyWithin,2),
+"find",bP("find",ArrayFind,1),
+"findIndex",bP("findIndex",ArrayFindIndex,1),
+"fill",bP("fill",ArrayFill,1),
+"includes",bP("includes",ArrayIncludes,1),
+]);
+%FinishArrayPrototypeSetup(h.prototype);
+b.SetUpLockedPrototype(i,h(),[
+"indexOf",bP("indexOf",ArrayIndexOf),
+"join",bP("join",ArrayJoin),
+"pop",bP("pop",ArrayPop),
+"push",bP("push",ArrayPush),
+"shift",bP("shift",ArrayShift),
+"sort",bP("sort",ArraySort),
+"splice",bP("splice",ArraySplice)
+]);
+b.SetUpLockedPrototype(j,h(),[
+"join",bP("join",ArrayJoin),
+"pop",bP("pop",ArrayPop),
+"push",bP("push",ArrayPush),
+"shift",bP("shift",ArrayShift)
+]);
+b.SetUpLockedPrototype(c.InternalPackedArray,h(),[
+"push",bP("push",ArrayPush),
+"pop",bP("pop",ArrayPop),
+"shift",bP("shift",ArrayShift),
+"unshift",bP("unshift",ArrayUnshift),
+"splice",bP("splice",ArraySplice),
+"slice",bP("slice",ArraySlice)
+]);
+b.Export(function(aL){
+aL.ArrayFrom=ArrayFrom;
+aL.ArrayIndexOf=ArrayIndexOf;
+aL.ArrayJoin=ArrayJoin;
+aL.ArrayPush=ArrayPush;
+aL.ArrayToString=ArrayToString;
+aL.InnerArrayCopyWithin=InnerArrayCopyWithin;
+aL.InnerArrayEvery=InnerArrayEvery;
+aL.InnerArrayFill=InnerArrayFill;
+aL.InnerArrayFilter=InnerArrayFilter;
+aL.InnerArrayFind=InnerArrayFind;
+aL.InnerArrayFindIndex=InnerArrayFindIndex;
+aL.InnerArrayForEach=InnerArrayForEach;
+aL.InnerArrayIncludes=InnerArrayIncludes;
+aL.InnerArrayIndexOf=InnerArrayIndexOf;
+aL.InnerArrayJoin=InnerArrayJoin;
+aL.InnerArrayLastIndexOf=InnerArrayLastIndexOf;
+aL.InnerArrayReduce=InnerArrayReduce;
+aL.InnerArrayReduceRight=InnerArrayReduceRight;
+aL.InnerArraySome=InnerArraySome;
+aL.InnerArraySort=InnerArraySort;
+aL.InnerArrayToLocaleString=InnerArrayToLocaleString;
+aL.PackedArrayReverse=PackedArrayReverse;
+aL.Stack=Stack;
+aL.StackHas=StackHas;
+aL.StackPush=StackPush;
+aL.StackPop=StackPop;
+});
+%InstallToContext([
+"array_pop",ArrayPop,
+"array_push",ArrayPush,
+"array_shift",ArrayShift,
+"array_splice",ArraySplice,
+"array_slice",ArraySlice,
+"array_unshift",ArrayUnshift,
+]);
+});
+
+string]�
+(function(a,b){
+%CheckIsBootstrapping();
+var c;
+var d;
+var e=a.RegExp;
+var f=a.String;
+var g=b.InternalArray;
+var h=b.InternalPackedArray;
+var i;
+var j;
+var k;
+var l;
+var m;
+var n;
+var o=b.ImportNow("match_symbol");
+var p=b.ImportNow("replace_symbol");
+var q=b.ImportNow("search_symbol");
+var r=b.ImportNow("split_symbol");
+b.Import(function(s){
+c=s.ArrayIndexOf;
+d=s.ArrayJoin;
+i=s.IsRegExp;
+j=s.MakeRangeError;
+k=s.MakeTypeError;
+l=s.MaxSimple;
+m=s.MinSimple;
+n=s.RegExpInitialize;
+});
+function StringToString(){
+if(!(typeof(this)==='string')&&!(%_ClassOf(this)==='String')){
+throw k(69,'String.prototype.toString');
+}
+return %_ValueOf(this);
+}
+function StringValueOf(){
+if(!(typeof(this)==='string')&&!(%_ClassOf(this)==='String')){
+throw k(69,'String.prototype.valueOf');
+}
+return %_ValueOf(this);
+}
+function StringCharAtJS(t){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.charAt");
+var u=%_StringCharAt(this,t);
+if(%_IsSmi(u)){
+u=%_StringCharAt((%_ToString(this)),(%_ToInteger(t)));
+}
+return u;
+}
+function StringCharCodeAtJS(t){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.charCodeAt");
+var u=%_StringCharCodeAt(this,t);
+if(!%_IsSmi(u)){
+u=%_StringCharCodeAt((%_ToString(this)),(%_ToInteger(t)));
+}
+return u;
+}
+function StringConcat(v){
+"use strict";
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.concat");
+var w=(%_ToString(this));
+var x=arguments.length;
+for(var y=0;y<x;++y){
+w=w+(%_ToString(arguments[y]));
+}
+return w;
+}
+function StringIndexOf(z,A){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.indexOf");
+var B=(%_ToString(this));
+z=(%_ToString(z));
+var C=(%_ToInteger(A));
+if(C<0)C=0;
+if(C>B.length)C=B.length;
+return %StringIndexOf(B,z,C);
+}
+%FunctionSetLength(StringIndexOf,1);
+function StringLastIndexOf(D,t){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.lastIndexOf");
+var E=(%_ToString(this));
+var F=E.length;
+var D=(%_ToString(D));
+var G=D.length;
+var C=F-G;
+var A=(%_ToNumber(t));
+if(!(!%_IsSmi(%IS_VAR(A))&&!(A==A))){
+A=(%_ToInteger(A));
+if(A<0){
+A=0;
+}
+if(A+G<F){
+C=A;
+}
+}
+if(C<0){
+return-1;
+}
+return %StringLastIndexOf(E,D,C);
+}
+%FunctionSetLength(StringLastIndexOf,1);
+function StringLocaleCompareJS(v){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.localeCompare");
+return %StringLocaleCompare((%_ToString(this)),(%_ToString(v)));
+}
+function StringMatchJS(z){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.match");
+if(!(z==null)){
+var H=z[o];
+if(!(H===(void 0))){
+return %_Call(H,z,this);
+}
+}
+var B=(%_ToString(this));
+var I=%_NewObject(e,e);
+n(I,z);
+return I[o](B);
+}
+function StringNormalize(J){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.normalize");
+var w=(%_ToString(this));
+var K=(J===(void 0))?'NFC':(%_ToString(J));
+var L=['NFC','NFD','NFKC','NFKD'];
+var M=%_Call(c,L,K);
+if(M===-1){
+throw j(183,
+%_Call(d,L,', '));
+}
+return w;
+}
+%FunctionSetLength(StringNormalize,0);
+var N=[2,"","",-1,-1];
+function StringReplace(O,P){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.replace");
+if(!(O==null)){
+var Q=O[p];
+if(!(Q===(void 0))){
+return %_Call(Q,O,this,P);
+}
+}
+var B=(%_ToString(this));
+O=(%_ToString(O));
+if(O.length==1&&
+B.length>0xFF&&
+(typeof(P)==='string')&&
+%StringIndexOf(P,'$',0)<0){
+return %StringReplaceOneCharWithString(B,O,P);
+}
+var R=%StringIndexOf(B,O,0);
+if(R<0)return B;
+var S=R+O.length;
+var u=%_SubString(B,0,R);
+if((typeof(P)==='function')){
+u+=P(O,R,B);
+}else{
+N[3]=R;
+N[4]=S;
+u=ExpandReplacement((%_ToString(P)),
+B,
+N,
+u);
+}
+return u+%_SubString(B,S,B.length);
+}
+function ExpandReplacement(T,B,U,u){
+var V=T.length;
+var W=%StringIndexOf(T,'$',0);
+if(W<0){
+if(V>0)u+=T;
+return u;
+}
+if(W>0)u+=%_SubString(T,0,W);
+while(true){
+var X='$';
+var A=W+1;
+if(A<V){
+var Y=%_StringCharCodeAt(T,A);
+if(Y==36){
+++A;
+u+='$';
+}else if(Y==38){
+++A;
+u+=
+%_SubString(B,U[3],U[4]);
+}else if(Y==96){
+++A;
+u+=%_SubString(B,0,U[3]);
+}else if(Y==39){
+++A;
+u+=%_SubString(B,U[4],B.length);
+}else if(Y>=48&&Y<=57){
+var Z=(Y-48)<<1;
+var aa=1;
+var ab=((U)[0]);
+if(A+1<T.length){
+var W=%_StringCharCodeAt(T,A+1);
+if(W>=48&&W<=57){
+var ac=Z*10+((W-48)<<1);
+if(ac<ab){
+Z=ac;
+aa=2;
+}
+}
+}
+if(Z!=0&&Z<ab){
+var R=U[(3+(Z))];
+if(R>=0){
+u+=
+%_SubString(B,R,U[(3+(Z+1))]);
+}
+A+=aa;
+}else{
+u+='$';
+}
+}else{
+u+='$';
+}
+}else{
+u+='$';
+}
+W=%StringIndexOf(T,'$',A);
+if(W<0){
+if(A<V){
+u+=%_SubString(T,A,V);
+}
+return u;
+}
+if(W>A){
+u+=%_SubString(T,A,W);
+}
+}
+return u;
+}
+function StringSearch(z){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.search");
+if(!(z==null)){
+var ad=z[q];
+if(!(ad===(void 0))){
+return %_Call(ad,z,this);
+}
+}
+var B=(%_ToString(this));
+var I=%_NewObject(e,e);
+n(I,z);
+return %_Call(I[q],I,B);
+}
+function StringSlice(R,S){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.slice");
+var w=(%_ToString(this));
+var ae=w.length;
+var af=(%_ToInteger(R));
+var ag=ae;
+if(!(S===(void 0))){
+ag=(%_ToInteger(S));
+}
+if(af<0){
+af+=ae;
+if(af<0){
+af=0;
+}
+}else{
+if(af>ae){
+return'';
+}
+}
+if(ag<0){
+ag+=ae;
+if(ag<0){
+return'';
+}
+}else{
+if(ag>ae){
+ag=ae;
+}
+}
+if(ag<=af){
+return'';
+}
+return %_SubString(w,af,ag);
+}
+function StringSplitJS(ah,ai){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.split");
+if(!(ah==null)){
+var aj=ah[r];
+if(!(aj===(void 0))){
+return %_Call(aj,ah,this,ai);
+}
+}
+var B=(%_ToString(this));
+ai=((ai===(void 0)))?4294967295:((ai)>>>0);
+var V=B.length;
+var ak=(%_ToString(ah));
+if(ai===0)return[];
+if((ah===(void 0)))return[B];
+var al=ak.length;
+if(al===0)return %StringToArray(B,ai);
+return %StringSplit(B,ak,ai);
+}
+function StringSubstring(R,S){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.subString");
+var w=(%_ToString(this));
+var ae=w.length;
+var af=(%_ToInteger(R));
+if(af<0){
+af=0;
+}else if(af>ae){
+af=ae;
+}
+var ag=ae;
+if(!(S===(void 0))){
+ag=(%_ToInteger(S));
+if(ag>ae){
+ag=ae;
+}else{
+if(ag<0)ag=0;
+if(af>ag){
+var am=ag;
+ag=af;
+af=am;
+}
+}
+}
+return %_SubString(w,af,ag);
+}
+function StringSubstr(R,an){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.substr");
+var w=(%_ToString(this));
+var x;
+if((an===(void 0))){
+x=w.length;
+}else{
+x=(%_ToInteger(an));
+if(x<=0)return'';
+}
+if((R===(void 0))){
+R=0;
+}else{
+R=(%_ToInteger(R));
+if(R>=w.length)return'';
+if(R<0){
+R+=w.length;
+if(R<0)R=0;
+}
+}
+var S=R+x;
+if(S>w.length)S=w.length;
+return %_SubString(w,R,S);
+}
+function StringToLowerCaseJS(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.toLowerCase");
+return %StringToLowerCase((%_ToString(this)));
+}
+function StringToLocaleLowerCase(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.toLocaleLowerCase");
+return %StringToLowerCase((%_ToString(this)));
+}
+function StringToUpperCaseJS(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.toUpperCase");
+return %StringToUpperCase((%_ToString(this)));
+}
+function StringToLocaleUpperCase(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.toLocaleUpperCase");
+return %StringToUpperCase((%_ToString(this)));
+}
+function StringTrimJS(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.trim");
+return %StringTrim((%_ToString(this)),true,true);
+}
+function StringTrimLeft(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.trimLeft");
+return %StringTrim((%_ToString(this)),true,false);
+}
+function StringTrimRight(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.trimRight");
+return %StringTrim((%_ToString(this)),false,true);
+}
+function StringFromCharCode(ao){
+"use strict";
+var w="";
+var an=arguments.length;
+for(var y=0;y<an;++y){
+w+=%_StringCharFromCode(arguments[y]&0xffff);
+}
+return w;
+}
+function HtmlEscape(ap){
+return %_Call(StringReplace,(%_ToString(ap)),/"/g,"&quot;");
+}
+function StringAnchor(aq){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.anchor");
+return"<a name=\""+HtmlEscape(aq)+"\">"+(%_ToString(this))+
+"</a>";
+}
+function StringBig(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.big");
+return"<big>"+(%_ToString(this))+"</big>";
+}
+function StringBlink(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.blink");
+return"<blink>"+(%_ToString(this))+"</blink>";
+}
+function StringBold(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.bold");
+return"<b>"+(%_ToString(this))+"</b>";
+}
+function StringFixed(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.fixed");
+return"<tt>"+(%_ToString(this))+"</tt>";
+}
+function StringFontcolor(ar){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.fontcolor");
+return"<font color=\""+HtmlEscape(ar)+"\">"+(%_ToString(this))+
+"</font>";
+}
+function StringFontsize(as){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.fontsize");
+return"<font size=\""+HtmlEscape(as)+"\">"+(%_ToString(this))+
+"</font>";
+}
+function StringItalics(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.italics");
+return"<i>"+(%_ToString(this))+"</i>";
+}
+function StringLink(w){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.link");
+return"<a href=\""+HtmlEscape(w)+"\">"+(%_ToString(this))+"</a>";
+}
+function StringSmall(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.small");
+return"<small>"+(%_ToString(this))+"</small>";
+}
+function StringStrike(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.strike");
+return"<strike>"+(%_ToString(this))+"</strike>";
+}
+function StringSub(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.sub");
+return"<sub>"+(%_ToString(this))+"</sub>";
+}
+function StringSup(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.sup");
+return"<sup>"+(%_ToString(this))+"</sup>";
+}
+function StringRepeat(at){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.repeat");
+var w=(%_ToString(this));
+var an=(%_ToInteger(at));
+if(an<0||an===(1/0))throw j(167);
+if(w.length===0)return"";
+if(an>%_MaxSmi())throw j(167);
+var au="";
+while(true){
+if(an&1)au+=w;
+an>>=1;
+if(an===0)return au;
+w+=w;
+}
+}
+function StringStartsWith(av,A){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.startsWith");
+var w=(%_ToString(this));
+if(i(av)){
+throw k(40,"String.prototype.startsWith");
+}
+var aw=(%_ToString(av));
+var t=(%_ToInteger(A));
+var ae=w.length;
+var R=m(l(t,0),ae);
+var ax=aw.length;
+if(ax+R>ae){
+return false;
+}
+return %_SubString(w,R,R+ax)===aw;
+}
+%FunctionSetLength(StringStartsWith,1);
+function StringEndsWith(av,A){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.endsWith");
+var w=(%_ToString(this));
+if(i(av)){
+throw k(40,"String.prototype.endsWith");
+}
+var aw=(%_ToString(av));
+var ae=w.length;
+var t=!(A===(void 0))?(%_ToInteger(A)):ae
+var S=m(l(t,0),ae);
+var ax=aw.length;
+var R=S-ax;
+if(R<0){
+return false;
+}
+return %_SubString(w,R,R+ax)===aw;
+}
+%FunctionSetLength(StringEndsWith,1);
+function StringIncludes(av,A){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.includes");
+var T=(%_ToString(this));
+if(i(av)){
+throw k(40,"String.prototype.includes");
+}
+av=(%_ToString(av));
+var t=(%_ToInteger(A));
+var ay=T.length;
+if(t<0)t=0;
+if(t>ay)t=ay;
+var az=av.length;
+if(az+t>ay){
+return false;
+}
+return %StringIndexOf(T,av,t)!==-1;
+}
+%FunctionSetLength(StringIncludes,1);
+function StringCodePointAt(t){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.codePointAt");
+var T=(%_ToString(this));
+var as=T.length;
+t=(%_ToInteger(t));
+if(t<0||t>=as){
+return(void 0);
+}
+var aA=%_StringCharCodeAt(T,t);
+if(aA<0xD800||aA>0xDBFF||t+1==as){
+return aA;
+}
+var aB=%_StringCharCodeAt(T,t+1);
+if(aB<0xDC00||aB>0xDFFF){
+return aA;
+}
+return(aA-0xD800)*0x400+aB+0x2400;
+}
+function StringFromCodePoint(ao){
+"use strict";
+var aC;
+var V=arguments.length;
+var C;
+var u="";
+for(C=0;C<V;C++){
+aC=arguments[C];
+if(!%_IsSmi(aC)){
+aC=(%_ToNumber(aC));
+}
+if(aC<0||aC>0x10FFFF||aC!==(%_ToInteger(aC))){
+throw j(166,aC);
+}
+if(aC<=0xFFFF){
+u+=%_StringCharFromCode(aC);
+}else{
+aC-=0x10000;
+u+=%_StringCharFromCode((aC>>>10)&0x3FF|0xD800);
+u+=%_StringCharFromCode(aC&0x3FF|0xDC00);
+}
+}
+return u;
+}
+function StringRaw(aD){
+"use strict";
+var aE=arguments.length;
+var aF=(%_ToObject(aD));
+var aG=(%_ToObject(aF.raw));
+var aH=(%_ToLength(aG.length));
+if(aH<=0)return"";
+var u=(%_ToString(aG[0]));
+for(var y=1;y<aH;++y){
+if(y<aE){
+u+=(%_ToString(arguments[y]));
+}
+u+=(%_ToString(aG[y]));
+}
+return u;
+}
+%FunctionSetPrototype(f,new f());
+%AddNamedProperty(
+f.prototype,"constructor",f,2);
+b.InstallFunctions(f,2,[
+"fromCharCode",StringFromCharCode,
+"fromCodePoint",StringFromCodePoint,
+"raw",StringRaw
+]);
+b.InstallFunctions(f.prototype,2,[
+"valueOf",StringValueOf,
+"toString",StringToString,
+"charAt",StringCharAtJS,
+"charCodeAt",StringCharCodeAtJS,
+"codePointAt",StringCodePointAt,
+"concat",StringConcat,
+"endsWith",StringEndsWith,
+"includes",StringIncludes,
+"indexOf",StringIndexOf,
+"lastIndexOf",StringLastIndexOf,
+"localeCompare",StringLocaleCompareJS,
+"match",StringMatchJS,
+"normalize",StringNormalize,
+"repeat",StringRepeat,
+"replace",StringReplace,
+"search",StringSearch,
+"slice",StringSlice,
+"split",StringSplitJS,
+"substring",StringSubstring,
+"substr",StringSubstr,
+"startsWith",StringStartsWith,
+"toLowerCase",StringToLowerCaseJS,
+"toLocaleLowerCase",StringToLocaleLowerCase,
+"toUpperCase",StringToUpperCaseJS,
+"toLocaleUpperCase",StringToLocaleUpperCase,
+"trim",StringTrimJS,
+"trimLeft",StringTrimLeft,
+"trimRight",StringTrimRight,
+"link",StringLink,
+"anchor",StringAnchor,
+"fontcolor",StringFontcolor,
+"fontsize",StringFontsize,
+"big",StringBig,
+"blink",StringBlink,
+"bold",StringBold,
+"fixed",StringFixed,
+"italics",StringItalics,
+"small",StringSmall,
+"strike",StringStrike,
+"sub",StringSub,
+"sup",StringSup
+]);
+b.Export(function(aI){
+aI.ExpandReplacement=ExpandReplacement;
+aI.StringCharAt=StringCharAtJS;
+aI.StringIndexOf=StringIndexOf;
+aI.StringLastIndexOf=StringLastIndexOf;
+aI.StringMatch=StringMatchJS;
+aI.StringReplace=StringReplace;
+aI.StringSlice=StringSlice;
+aI.StringSplit=StringSplitJS;
+aI.StringSubstr=StringSubstr;
+aI.StringSubstring=StringSubstring;
+});
+})
+
+uri�T
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Object;
+var d=b.InternalArray;
+var e;
+b.Import(function(f){
+e=f.MakeURIError;
+});
+function HexValueOf(g){
+if(g>=48&&g<=57)return g-48;
+if(g>=65&&g<=70)return g-55;
+if(g>=97&&g<=102)return g-87;
+return-1;
+}
+function isAlphaNumeric(h){
+if(97<=h&&h<=122)return true;
+if(65<=h&&h<=90)return true;
+if(48<=h&&h<=57)return true;
+return false;
+}
+var i=0;
+function URIAddEncodedOctetToBuffer(j,k,l){
+k[l++]=37;
+k[l++]=i[j>>4];
+k[l++]=i[j&0x0F];
+return l;
+}
+function URIEncodeOctets(m,k,l){
+if(i===0){
+i=[48,49,50,51,52,53,54,55,56,57,
+65,66,67,68,69,70];
+}
+l=URIAddEncodedOctetToBuffer(m[0],k,l);
+if(m[1])l=URIAddEncodedOctetToBuffer(m[1],k,l);
+if(m[2])l=URIAddEncodedOctetToBuffer(m[2],k,l);
+if(m[3])l=URIAddEncodedOctetToBuffer(m[3],k,l);
+return l;
+}
+function URIEncodeSingle(h,k,l){
+var n=(h>>12)&0xF;
+var o=(h>>6)&63;
+var p=h&63;
+var m=new d(3);
+if(h<=0x007F){
+m[0]=h;
+}else if(h<=0x07FF){
+m[0]=o+192;
+m[1]=p+128;
+}else{
+m[0]=n+224;
+m[1]=o+128;
+m[2]=p+128;
+}
+return URIEncodeOctets(m,k,l);
+}
+function URIEncodePair(q,r,k,l){
+var s=((q>>6)&0xF)+1;
+var t=(q>>2)&0xF;
+var n=q&3;
+var o=(r>>6)&0xF;
+var p=r&63;
+var m=new d(4);
+m[0]=(s>>2)+240;
+m[1]=(((s&3)<<4)|t)+128;
+m[2]=((n<<4)|o)+128;
+m[3]=p+128;
+return URIEncodeOctets(m,k,l);
+}
+function URIHexCharsToCharCode(u,v){
+var w=HexValueOf(u);
+var x=HexValueOf(v);
+if(w==-1||x==-1)throw e();
+return(w<<4)|x;
+}
+function URIDecodeOctets(m,k,l){
+var y;
+var z=m[0];
+if(z<0x80){
+y=z;
+}else if(z<0xc2){
+throw e();
+}else{
+var A=m[1];
+if(z<0xe0){
+var B=z&0x1f;
+if((A<0x80)||(A>0xbf))throw e();
+var C=A&0x3f;
+y=(B<<6)+C;
+if(y<0x80||y>0x7ff)throw e();
+}else{
+var D=m[2];
+if(z<0xf0){
+var B=z&0x0f;
+if((A<0x80)||(A>0xbf))throw e();
+var C=A&0x3f;
+if((D<0x80)||(D>0xbf))throw e();
+var E=D&0x3f;
+y=(B<<12)+(C<<6)+E;
+if((y<0x800)||(y>0xffff))throw e();
+}else{
+var F=m[3];
+if(z<0xf8){
+var B=(z&0x07);
+if((A<0x80)||(A>0xbf))throw e();
+var C=(A&0x3f);
+if((D<0x80)||(D>0xbf)){
+throw e();
+}
+var E=(D&0x3f);
+if((F<0x80)||(F>0xbf))throw e();
+var G=(F&0x3f);
+y=(B<<18)+(C<<12)+(E<<6)+G;
+if((y<0x10000)||(y>0x10ffff))throw e();
+}else{
+throw e();
+}
+}
+}
+}
+if(0xD800<=y&&y<=0xDFFF)throw e();
+if(y<0x10000){
+%_TwoByteSeqStringSetChar(l++,y,k);
+}else{
+%_TwoByteSeqStringSetChar(l++,(y>>10)+0xd7c0,k);
+%_TwoByteSeqStringSetChar(l++,(y&0x3ff)+0xdc00,k);
+}
+return l;
+}
+function Encode(H,I){
+H=(%_ToString(H));
+var J=H.length;
+var K=new d(J);
+var l=0;
+for(var L=0;L<J;L++){
+var q=%_StringCharCodeAt(H,L);
+if(I(q)){
+K[l++]=q;
+}else{
+if(q>=0xDC00&&q<=0xDFFF)throw e();
+if(q<0xD800||q>0xDBFF){
+l=URIEncodeSingle(q,K,l);
+}else{
+L++;
+if(L==J)throw e();
+var r=%_StringCharCodeAt(H,L);
+if(r<0xDC00||r>0xDFFF)throw e();
+l=URIEncodePair(q,r,K,l);
+}
+}
+}
+var k=%NewString(K.length,true);
+for(var M=0;M<K.length;M++){
+%_OneByteSeqStringSetChar(M,K[M],k);
+}
+return k;
+}
+function Decode(H,N){
+H=(%_ToString(H));
+var J=H.length;
+var O=%NewString(J,true);
+var l=0;
+var L=0;
+for(;L<J;L++){
+var g=%_StringCharCodeAt(H,L);
+if(g==37){
+if(L+2>=J)throw e();
+var h=URIHexCharsToCharCode(%_StringCharCodeAt(H,L+1),
+%_StringCharCodeAt(H,L+2));
+if(h>>7)break;
+if(N(h)){
+%_OneByteSeqStringSetChar(l++,37,O);
+%_OneByteSeqStringSetChar(l++,%_StringCharCodeAt(H,L+1),
+O);
+%_OneByteSeqStringSetChar(l++,%_StringCharCodeAt(H,L+2),
+O);
+}else{
+%_OneByteSeqStringSetChar(l++,h,O);
+}
+L+=2;
+}else{
+if(g>0x7f)break;
+%_OneByteSeqStringSetChar(l++,g,O);
+}
+}
+O=%TruncateString(O,l);
+if(L==J)return O;
+var P=%NewString(J-L,false);
+l=0;
+for(;L<J;L++){
+var g=%_StringCharCodeAt(H,L);
+if(g==37){
+if(L+2>=J)throw e();
+var h=URIHexCharsToCharCode(%_StringCharCodeAt(H,++L),
+%_StringCharCodeAt(H,++L));
+if(h>>7){
+var Q=0;
+while(((h<<++Q)&0x80)!=0){}
+if(Q==1||Q>4)throw e();
+var m=new d(Q);
+m[0]=h;
+if(L+3*(Q-1)>=J)throw e();
+for(var M=1;M<Q;M++){
+if(H[++L]!='%')throw e();
+m[M]=URIHexCharsToCharCode(%_StringCharCodeAt(H,++L),
+%_StringCharCodeAt(H,++L));
+}
+l=URIDecodeOctets(m,P,l);
+}else if(N(h)){
+%_TwoByteSeqStringSetChar(l++,37,P);
+%_TwoByteSeqStringSetChar(l++,%_StringCharCodeAt(H,L-1),
+P);
+%_TwoByteSeqStringSetChar(l++,%_StringCharCodeAt(H,L),
+P);
+}else{
+%_TwoByteSeqStringSetChar(l++,h,P);
+}
+}else{
+%_TwoByteSeqStringSetChar(l++,g,P);
+}
+}
+P=%TruncateString(P,l);
+return O+P;
+}
+function URIEscapeJS(R){
+return %URIEscape(R);
+}
+function URIUnescapeJS(R){
+return %URIUnescape(R);
+}
+function URIDecode(H){
+var S=function(h){
+if(35<=h&&h<=36)return true;
+if(h==38)return true;
+if(43<=h&&h<=44)return true;
+if(h==47)return true;
+if(58<=h&&h<=59)return true;
+if(h==61)return true;
+if(63<=h&&h<=64)return true;
+return false;
+};
+return Decode(H,S);
+}
+function URIDecodeComponent(T){
+var S=function(h){return false;};
+return Decode(T,S);
+}
+function URIEncode(H){
+var U=function(h){
+if(isAlphaNumeric(h))return true;
+if(h==33)return true;
+if(35<=h&&h<=36)return true;
+if(38<=h&&h<=47)return true;
+if(58<=h&&h<=59)return true;
+if(h==61)return true;
+if(63<=h&&h<=64)return true;
+if(h==95)return true;
+if(h==126)return true;
+return false;
+};
+return Encode(H,U);
+}
+function URIEncodeComponent(T){
+var U=function(h){
+if(isAlphaNumeric(h))return true;
+if(h==33)return true;
+if(39<=h&&h<=42)return true;
+if(45<=h&&h<=46)return true;
+if(h==95)return true;
+if(h==126)return true;
+return false;
+};
+return Encode(T,U);
+}
+b.InstallFunctions(a,2,[
+"escape",URIEscapeJS,
+"unescape",URIUnescapeJS,
+"decodeURI",URIDecode,
+"decodeURIComponent",URIDecodeComponent,
+"encodeURI",URIEncode,
+"encodeURIComponent",URIEncodeComponent
+]);
+})
+
+mathQ,
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Float64Array;
+var d=a.Math;
+var e=a.Object;
+var f=b.InternalArray;
+var g=%GetRootNaN();
+var h=0;
+var i=(void 0);
+var j=b.ImportNow("to_string_tag_symbol");
+function MathAbs(k){
+k=+k;
+return(k>0)?k:0-k;
+}
+function MathAtan2JS(l,k){
+l=+l;
+k=+k;
+return %MathAtan2(l,k);
+}
+function MathExp(k){
+return %MathExpRT((%_ToNumber(k)));
+}
+function MathLog(k){
+return %_MathLogRT((%_ToNumber(k)));
+}
+function MathPowJS(k,l){
+return %_MathPow((%_ToNumber(k)),(%_ToNumber(l)));
+}
+function MathRandom(){
+if(h<=2){
+i=%GenerateRandomNumbers(i);
+h=i.length;
+}
+return i[--h];
+}
+function MathRandomRaw(){
+if(h<=2){
+i=%GenerateRandomNumbers(i);
+h=i.length;
+}
+return %_DoubleLo(i[--h])&0x3FFFFFFF;
+}
+function MathSign(k){
+k=+k;
+if(k>0)return 1;
+if(k<0)return-1;
+return k;
+}
+function MathAsinh(k){
+k=(%_ToNumber(k));
+if(k===0||!(%_IsSmi(%IS_VAR(k))||((k==k)&&(k!=1/0)&&(k!=-1/0))))return k;
+if(k>0)return MathLog(k+%math_sqrt(k*k+1));
+return-MathLog(-k+%math_sqrt(k*k+1));
+}
+function MathAcosh(k){
+k=(%_ToNumber(k));
+if(k<1)return g;
+if(!(%_IsSmi(%IS_VAR(k))||((k==k)&&(k!=1/0)&&(k!=-1/0))))return k;
+return MathLog(k+%math_sqrt(k+1)*%math_sqrt(k-1));
+}
+function MathAtanh(k){
+k=(%_ToNumber(k));
+if(k===0)return k;
+if(!(%_IsSmi(%IS_VAR(k))||((k==k)&&(k!=1/0)&&(k!=-1/0))))return g;
+return 0.5*MathLog((1+k)/(1-k));
+}
+function MathHypot(k,l){
+var m=arguments.length;
+var n=0;
+for(var o=0;o<m;o++){
+var p=MathAbs(arguments[o]);
+if(p>n)n=p;
+arguments[o]=p;
+}
+if(n===(1/0))return(1/0);
+if(n===0)n=1;
+var q=0;
+var r=0;
+for(var o=0;o<m;o++){
+var p=arguments[o]/n;
+var s=p*p-r;
+var t=q+s;
+r=(t-q)-s;
+q=t;
+}
+return %math_sqrt(q)*n;
+}
+function MathCbrt(k){
+k=(%_ToNumber(k));
+if(k==0||!(%_IsSmi(%IS_VAR(k))||((k==k)&&(k!=1/0)&&(k!=-1/0))))return k;
+return k>=0?CubeRoot(k):-CubeRoot(-k);
+}
+function CubeRoot(k){
+var u=%math_floor(%_DoubleHi(k)/3)+0x2A9F7893;
+var v=%_ConstructDouble(u|0,0);
+v=(1.0/3.0)*(k/(v*v)+2*v);
+;
+v=(1.0/3.0)*(k/(v*v)+2*v);
+;
+v=(1.0/3.0)*(k/(v*v)+2*v);
+;
+return(1.0/3.0)*(k/(v*v)+2*v);
+;
+}
+%InstallToContext([
+"math_pow",MathPowJS,
+]);
+%AddNamedProperty(d,j,"Math",1|2);
+b.InstallConstants(d,[
+"E",2.7182818284590452354,
+"LN10",2.302585092994046,
+"LN2",0.6931471805599453,
+"LOG2E",1.4426950408889634,
+"LOG10E",0.4342944819032518,
+"PI",3.1415926535897932,
+"SQRT1_2",0.7071067811865476,
+"SQRT2",1.4142135623730951
+]);
+b.InstallFunctions(d,2,[
+"random",MathRandom,
+"abs",MathAbs,
+"exp",MathExp,
+"log",MathLog,
+"atan2",MathAtan2JS,
+"pow",MathPowJS,
+"sign",MathSign,
+"asinh",MathAsinh,
+"acosh",MathAcosh,
+"atanh",MathAtanh,
+"hypot",MathHypot,
+"cbrt",MathCbrt
+]);
+%SetForceInlineFlag(MathAbs);
+%SetForceInlineFlag(MathAtan2JS);
+%SetForceInlineFlag(MathRandom);
+%SetForceInlineFlag(MathSign);
+b.Export(function(w){
+w.MathAbs=MathAbs;
+w.MathExp=MathExp;
+w.IntRandom=MathRandomRaw;
+});
+})
+
+fdlibm��
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Float64Array;
+var d=a.Math;
+var e;
+var f;
+var g=%GetRootNaN();
+var h;
+b.Import(function(i){
+e=i.MathAbs;
+f=i.MathExp;
+});
+b.CreateDoubleResultArray=function(a){
+h=new c(2);
+};
+function KernelTan(j,k,l){
+var m;
+var n;
+var o=%_DoubleHi(j);
+var p=o&0x7fffffff;
+if(p<0x3e300000){
+if(((p|%_DoubleLo(j))|(l+1))==0){
+return 1/e(j);
+}else{
+if(l==1){
+return j;
+}else{
+var n=j+k;
+var m=%_ConstructDouble(%_DoubleHi(n),0);
+var q=k-(m-j);
+var r=-1/n;
+var s=%_ConstructDouble(%_DoubleHi(r),0);
+var t=1+s*m;
+return s+r*(t+s*q);
+}
+}
+}
+if(p>=0x3fe59428){
+if(j<0){
+j=-j;
+k=-k;
+}
+m=7.85398163397448278999e-01-j;
+n=3.06161699786838301793e-17-k;
+j=m+n;
+k=0;
+}
+m=j*j;
+n=m*m;
+var u=1.33333333333201242699e-01+n*(2.18694882948595424599e-02+n*(3.59207910759131235356e-03+
+n*(5.88041240820264096874e-04+n*(7.81794442939557092300e-05+n*-1.85586374855275456654e-05))));
+var q=m*(5.39682539762260521377e-02+n*(8.86323982359930005737e-03+n*(1.45620945432529025516e-03+
+n*(2.46463134818469906812e-04+n*(7.14072491382608190305e-05+n*2.59073051863633712884e-05)))));
+var t=m*j;
+u=k+m*(t*(u+q)+k);
+u=u+3.33333333333334091986e-01*t;
+n=j+u;
+if(p>=0x3fe59428){
+return(1-((o>>30)&2))*
+(l-2.0*(j-(n*n/(n+l)-u)));
+}
+if(l==1){
+return n;
+}else{
+m=%_ConstructDouble(%_DoubleHi(n),0);
+q=u-(m-j);
+var r=-1/n;
+var s=%_ConstructDouble(%_DoubleHi(r),0);
+t=1+s*m;
+return s+r*(t+s*q);
+}
+}
+function MathSinSlow(j){
+var v,w,x;
+var o=%_DoubleHi(j);
+var p=o&0x7fffffff;
+if(p<0x4002d97c){
+if(o>0){
+var m=j-1.57079632673412561417;
+if(p!=0x3ff921fb){
+w=m-6.07710050650619224932e-11;
+x=(m-w)-6.07710050650619224932e-11;
+}else{
+m-=6.07710050630396597660e-11;
+w=m-2.02226624879595063154e-21;
+x=(m-w)-2.02226624879595063154e-21;
+}
+v=1;
+}else{
+var m=j+1.57079632673412561417;
+if(p!=0x3ff921fb){
+w=m+6.07710050650619224932e-11;
+x=(m-w)+6.07710050650619224932e-11;
+}else{
+m+=6.07710050630396597660e-11;
+w=m+2.02226624879595063154e-21;
+x=(m-w)+2.02226624879595063154e-21;
+}
+v=-1;
+}
+}else if(p<=0x413921fb){
+var s=e(j);
+v=(s*6.36619772367581382433e-01+0.5)|0;
+var u=s-v*1.57079632673412561417;
+var n=v*6.07710050650619224932e-11;
+w=u-n;
+if(p-(%_DoubleHi(w)&0x7ff00000)>0x1000000){
+s=u;
+n=v*6.07710050630396597660e-11;
+u=s-n;
+n=v*2.02226624879595063154e-21-((s-u)-n);
+w=u-n;
+if(p-(%_DoubleHi(w)&0x7ff00000)>0x3100000){
+s=u;
+n=v*2.02226624871116645580e-21;
+u=s-n;
+n=v*8.47842766036889956997e-32-((s-u)-n);
+w=u-n;
+}
+}
+x=(u-w)-n;
+if(o<0){
+v=-v;
+w=-w;
+x=-x;
+}
+}else{
+v=%RemPiO2(j,h);
+w=h[0];
+x=h[1];
+}
+;
+var y=1-(v&2);
+if(v&1){
+var p=%_DoubleHi(w)&0x7fffffff;
+var m=w*w;
+var u=m*(4.16666666666666019037e-02+m*(-1.38888888888741095749e-03+m*(2.48015872894767294178e-05+m*(-2.75573143513906633035e-07+m*(2.08757232129817482790e-09+m*-1.13596475577881948265e-11)))));
+if(p<0x3fd33333){
+return(1-(0.5*m-(m*u-w*x)))*y;
+}else{
+var z;
+if(p>0x3fe90000){
+z=0.28125;
+}else{
+z=%_ConstructDouble(%_DoubleHi(0.25*w),0);
+}
+var A=0.5*m-z;
+return(1-z-(A-(m*u-w*x)))*y;
+}
+;
+}else{
+var m=w*w;
+var q=m*w;
+var u=8.33333333332248946124e-03+m*(-1.98412698298579493134e-04+m*(2.75573137070700676789e-06+m*(-2.50507602534068634195e-08+m*1.58969099521155010221e-10)));
+return(w-((m*(0.5*x-q*u)-x)-q*-1.66666666666666324348e-01))*y;
+;
+}
+}
+function MathCosSlow(j){
+var v,w,x;
+var o=%_DoubleHi(j);
+var p=o&0x7fffffff;
+if(p<0x4002d97c){
+if(o>0){
+var m=j-1.57079632673412561417;
+if(p!=0x3ff921fb){
+w=m-6.07710050650619224932e-11;
+x=(m-w)-6.07710050650619224932e-11;
+}else{
+m-=6.07710050630396597660e-11;
+w=m-2.02226624879595063154e-21;
+x=(m-w)-2.02226624879595063154e-21;
+}
+v=1;
+}else{
+var m=j+1.57079632673412561417;
+if(p!=0x3ff921fb){
+w=m+6.07710050650619224932e-11;
+x=(m-w)+6.07710050650619224932e-11;
+}else{
+m+=6.07710050630396597660e-11;
+w=m+2.02226624879595063154e-21;
+x=(m-w)+2.02226624879595063154e-21;
+}
+v=-1;
+}
+}else if(p<=0x413921fb){
+var s=e(j);
+v=(s*6.36619772367581382433e-01+0.5)|0;
+var u=s-v*1.57079632673412561417;
+var n=v*6.07710050650619224932e-11;
+w=u-n;
+if(p-(%_DoubleHi(w)&0x7ff00000)>0x1000000){
+s=u;
+n=v*6.07710050630396597660e-11;
+u=s-n;
+n=v*2.02226624879595063154e-21-((s-u)-n);
+w=u-n;
+if(p-(%_DoubleHi(w)&0x7ff00000)>0x3100000){
+s=u;
+n=v*2.02226624871116645580e-21;
+u=s-n;
+n=v*8.47842766036889956997e-32-((s-u)-n);
+w=u-n;
+}
+}
+x=(u-w)-n;
+if(o<0){
+v=-v;
+w=-w;
+x=-x;
+}
+}else{
+v=%RemPiO2(j,h);
+w=h[0];
+x=h[1];
+}
+;
+if(v&1){
+var y=(v&2)-1;
+var m=w*w;
+var q=m*w;
+var u=8.33333333332248946124e-03+m*(-1.98412698298579493134e-04+m*(2.75573137070700676789e-06+m*(-2.50507602534068634195e-08+m*1.58969099521155010221e-10)));
+return(w-((m*(0.5*x-q*u)-x)-q*-1.66666666666666324348e-01))*y;
+;
+}else{
+var y=1-(v&2);
+var p=%_DoubleHi(w)&0x7fffffff;
+var m=w*w;
+var u=m*(4.16666666666666019037e-02+m*(-1.38888888888741095749e-03+m*(2.48015872894767294178e-05+m*(-2.75573143513906633035e-07+m*(2.08757232129817482790e-09+m*-1.13596475577881948265e-11)))));
+if(p<0x3fd33333){
+return(1-(0.5*m-(m*u-w*x)))*y;
+}else{
+var z;
+if(p>0x3fe90000){
+z=0.28125;
+}else{
+z=%_ConstructDouble(%_DoubleHi(0.25*w),0);
+}
+var A=0.5*m-z;
+return(1-z-(A-(m*u-w*x)))*y;
+}
+;
+}
+}
+function MathSin(j){
+j=+j;
+if((%_DoubleHi(j)&0x7fffffff)<=0x3fe921fb){
+var m=j*j;
+var q=m*j;
+var u=8.33333333332248946124e-03+m*(-1.98412698298579493134e-04+m*(2.75573137070700676789e-06+m*(-2.50507602534068634195e-08+m*1.58969099521155010221e-10)));
+return(j-((m*(0.5*0-q*u)-0)-q*-1.66666666666666324348e-01));
+;
+}
+return+MathSinSlow(j);
+}
+function MathCos(j){
+j=+j;
+if((%_DoubleHi(j)&0x7fffffff)<=0x3fe921fb){
+var p=%_DoubleHi(j)&0x7fffffff;
+var m=j*j;
+var u=m*(4.16666666666666019037e-02+m*(-1.38888888888741095749e-03+m*(2.48015872894767294178e-05+m*(-2.75573143513906633035e-07+m*(2.08757232129817482790e-09+m*-1.13596475577881948265e-11)))));
+if(p<0x3fd33333){
+return(1-(0.5*m-(m*u-j*0)));
+}else{
+var z;
+if(p>0x3fe90000){
+z=0.28125;
+}else{
+z=%_ConstructDouble(%_DoubleHi(0.25*j),0);
+}
+var A=0.5*m-z;
+return(1-z-(A-(m*u-j*0)));
+}
+;
+}
+return+MathCosSlow(j);
+}
+function MathTan(j){
+j=j*1;
+if((%_DoubleHi(j)&0x7fffffff)<=0x3fe921fb){
+return KernelTan(j,0,1);
+}
+var v,w,x;
+var o=%_DoubleHi(j);
+var p=o&0x7fffffff;
+if(p<0x4002d97c){
+if(o>0){
+var m=j-1.57079632673412561417;
+if(p!=0x3ff921fb){
+w=m-6.07710050650619224932e-11;
+x=(m-w)-6.07710050650619224932e-11;
+}else{
+m-=6.07710050630396597660e-11;
+w=m-2.02226624879595063154e-21;
+x=(m-w)-2.02226624879595063154e-21;
+}
+v=1;
+}else{
+var m=j+1.57079632673412561417;
+if(p!=0x3ff921fb){
+w=m+6.07710050650619224932e-11;
+x=(m-w)+6.07710050650619224932e-11;
+}else{
+m+=6.07710050630396597660e-11;
+w=m+2.02226624879595063154e-21;
+x=(m-w)+2.02226624879595063154e-21;
+}
+v=-1;
+}
+}else if(p<=0x413921fb){
+var s=e(j);
+v=(s*6.36619772367581382433e-01+0.5)|0;
+var u=s-v*1.57079632673412561417;
+var n=v*6.07710050650619224932e-11;
+w=u-n;
+if(p-(%_DoubleHi(w)&0x7ff00000)>0x1000000){
+s=u;
+n=v*6.07710050630396597660e-11;
+u=s-n;
+n=v*2.02226624879595063154e-21-((s-u)-n);
+w=u-n;
+if(p-(%_DoubleHi(w)&0x7ff00000)>0x3100000){
+s=u;
+n=v*2.02226624871116645580e-21;
+u=s-n;
+n=v*8.47842766036889956997e-32-((s-u)-n);
+w=u-n;
+}
+}
+x=(u-w)-n;
+if(o<0){
+v=-v;
+w=-w;
+x=-x;
+}
+}else{
+v=%RemPiO2(j,h);
+w=h[0];
+x=h[1];
+}
+;
+return KernelTan(w,x,(v&1)?-1:1);
+}
+function MathLog1p(j){
+j=j*1;
+var o=%_DoubleHi(j);
+var B=o&0x7fffffff;
+var C=1;
+var D=j;
+var E=1;
+var F=0;
+var G=j;
+if(o<0x3fda827a){
+if(B>=0x3ff00000){
+if(j===-1){
+return-(1/0);
+}else{
+return g;
+}
+}else if(B<0x3c900000){
+return j;
+}else if(B<0x3e200000){
+return j-j*j*0.5;
+}
+if((o>0)||(o<=-0x402D413D)){
+C=0;
+}
+}
+if(o>=0x7ff00000)return j;
+if(C!==0){
+if(o<0x43400000){
+G=1+j;
+E=%_DoubleHi(G);
+C=(E>>20)-1023;
+F=(C>0)?1-(G-j):j-(G-1);
+F=F/G;
+}else{
+E=%_DoubleHi(G);
+C=(E>>20)-1023;
+}
+E=E&0xfffff;
+if(E<0x6a09e){
+G=%_ConstructDouble(E|0x3ff00000,%_DoubleLo(G));
+}else{
+++C;
+G=%_ConstructDouble(E|0x3fe00000,%_DoubleLo(G));
+E=(0x00100000-E)>>2;
+}
+D=G-1;
+}
+var H=0.5*D*D;
+if(E===0){
+if(D===0){
+if(C===0){
+return 0.0;
+}else{
+return C*6.93147180369123816490e-01+(F+C*1.90821492927058770002e-10);
+}
+}
+var I=H*(1-6.666666666666666666e-01*D);
+if(C===0){
+return D-I;
+}else{
+return C*6.93147180369123816490e-01-((I-(C*1.90821492927058770002e-10+F))-D);
+}
+}
+var t=D/(2+D);
+var m=t*t;
+var I=m*(6.666666666666735130e-01+m*(3.999999999940941908e-01+m*(2.857142874366239149e-01+m*(2.222219843214978396e-01+
+m*(1.818357216161805012e-01+m*(1.531383769920937332e-01+m*1.479819860511658591e-01))))));
+if(C===0){
+return D-(H-t*(H+I));
+}else{
+return C*6.93147180369123816490e-01-((H-(t*(H+I)+(C*1.90821492927058770002e-10+F)))-D);
+}
+}
+function MathExpm1(j){
+j=j*1;
+var k;
+var J;
+var K;
+var C;
+var s;
+var F;
+var o=%_DoubleHi(j);
+var L=o&0x80000000;
+var k=(L===0)?j:-j;
+o&=0x7fffffff;
+if(o>=0x4043687a){
+if(o>=0x40862e42){
+if(o>=0x7ff00000){
+return(j===-(1/0))?-1:j;
+}
+if(j>7.09782712893383973096e+02)return(1/0);
+}
+if(L!=0)return-1;
+}
+if(o>0x3fd62e42){
+if(o<0x3ff0a2b2){
+if(L===0){
+J=j-6.93147180369123816490e-01;
+K=1.90821492927058770002e-10;
+C=1;
+}else{
+J=j+6.93147180369123816490e-01;
+K=-1.90821492927058770002e-10;
+C=-1;
+}
+}else{
+C=(1.44269504088896338700*j+((L===0)?0.5:-0.5))|0;
+s=C;
+J=j-s*6.93147180369123816490e-01;
+K=s*1.90821492927058770002e-10;
+}
+j=J-K;
+F=(J-j)-K;
+}else if(o<0x3c900000){
+return j;
+}else{
+C=0;
+}
+var M=0.5*j;
+var N=j*M;
+var O=1+N*(-3.33333333333331316428e-02+N*(1.58730158725481460165e-03+N*
+(-7.93650757867487942473e-05+N*(4.00821782732936239552e-06+N*-2.01099218183624371326e-07))));
+s=3-O*M;
+var P=N*((O-s)/(6-j*s));
+if(C===0){
+return j-(j*P-N);
+}else{
+P=(j*(P-F)-F);
+P-=N;
+if(C===-1)return 0.5*(j-P)-0.5;
+if(C===1){
+if(j<-0.25)return-2*(P-(j+0.5));
+return 1+2*(j-P);
+}
+if(C<=-2||C>56){
+k=1-(P-j);
+k=%_ConstructDouble(%_DoubleHi(k)+(C<<20),%_DoubleLo(k));
+return k-1;
+}
+if(C<20){
+s=%_ConstructDouble(0x3ff00000-(0x200000>>C),0);
+k=s-(P-j);
+k=%_ConstructDouble(%_DoubleHi(k)+(C<<20),%_DoubleLo(k));
+}else{
+s=%_ConstructDouble((0x3ff-C)<<20,0);
+k=j-(P+s);
+k+=1;
+k=%_ConstructDouble(%_DoubleHi(k)+(C<<20),%_DoubleLo(k));
+}
+}
+return k;
+}
+function MathSinh(j){
+j=j*1;
+var Q=(j<0)?-0.5:0.5;
+var B=e(j);
+if(B<22){
+if(B<3.725290298461914e-9)return j;
+var s=MathExpm1(B);
+if(B<1)return Q*(2*s-s*s/(s+1));
+return Q*(s+s/(s+1));
+}
+if(B<709.7822265625)return Q*f(B);
+if(B<=710.4758600739439){
+var n=f(0.5*B);
+var s=Q*n;
+return s*n;
+}
+return j*(1/0);
+}
+function MathCosh(j){
+j=j*1;
+var p=%_DoubleHi(j)&0x7fffffff;
+if(p<0x3fd62e43){
+var s=MathExpm1(e(j));
+var n=1+s;
+if(p<0x3c800000)return n;
+return 1+(s*s)/(n+n);
+}
+if(p<0x40360000){
+var s=f(e(j));
+return 0.5*s+0.5/s;
+}
+if(p<0x40862e42)return 0.5*f(e(j));
+if(e(j)<=710.4758600739439){
+var n=f(0.5*e(j));
+var s=0.5*n;
+return s*n;
+}
+if((!%_IsSmi(%IS_VAR(j))&&!(j==j)))return j;
+return(1/0);
+}
+function MathTanh(j){
+j=j*1;
+if(!(%_IsSmi(%IS_VAR(j))||((j==j)&&(j!=1/0)&&(j!=-1/0)))){
+if(j>0)return 1;
+if(j<0)return-1;
+return j;
+}
+var B=e(j);
+var m;
+if(B<22){
+if(B<2.77555756156289135105e-17){
+return j;
+}
+if(B>=1){
+var s=MathExpm1(2*B);
+m=1-2/(s+2);
+}else{
+var s=MathExpm1(-2*B);
+m=-s/(s+2);
+}
+}else{
+m=1;
+}
+return(j>=0)?m:-m;
+}
+function MathLog10(j){
+j=j*1;
+var o=%_DoubleHi(j);
+var R=%_DoubleLo(j);
+var C=0;
+if(o<0x00100000){
+if(((o&0x7fffffff)|R)===0)return-(1/0);
+if(o<0)return g;
+C-=54;
+j*=18014398509481984;
+o=%_DoubleHi(j);
+R=%_DoubleLo(j);
+}
+if(o>=0x7ff00000)return j;
+C+=(o>>20)-1023;
+var S=(C&0x80000000)>>>31;
+o=(o&0x000fffff)|((0x3ff-S)<<20);
+var k=C+S;
+j=%_ConstructDouble(o,R);
+var m=k*3.69423907715893078616e-13+4.34294481903251816668e-01*%_MathLogRT(j);
+return m+k*3.01029995663611771306e-01;
+}
+function MathLog2(j){
+j=j*1;
+var B=e(j);
+var o=%_DoubleHi(j);
+var R=%_DoubleLo(j);
+var p=o&0x7fffffff;
+if((p|R)==0)return-(1/0);
+if(o<0)return g;
+if(p>=0x7ff00000)return j;
+var v=0;
+if(p<0x00100000){
+B*=9007199254740992;
+v-=53;
+p=%_DoubleHi(B);
+}
+v+=(p>>20)-0x3ff;
+var T=p&0x000fffff;
+p=T|0x3ff00000;
+var U=1;
+var V=0;
+var W=0;
+if(T>0x3988e){
+if(T<0xbb67a){
+U=1.5;
+V=5.84962487220764160156e-01;
+W=1.35003920212974897128e-08;
+}else{
+v+=1;
+p-=0x00100000;
+}
+}
+B=%_ConstructDouble(p,%_DoubleLo(B));
+var G=B-U;
+var q=1/(B+U);
+var X=G*q;
+var Y=%_ConstructDouble(%_DoubleHi(X),0);
+var Z=%_ConstructDouble(%_DoubleHi(B+U),0)
+var aa=B-(Z-U);
+var ab=q*((G-Y*Z)-Y*aa);
+var ac=X*X;
+var u=ac*ac*(5.99999999999994648725e-01+ac*(4.28571428578550184252e-01+ac*(3.33333329818377432918e-01+ac*(
+2.72728123808534006489e-01+ac*(2.30660745775561754067e-01+ac*2.06975017800338417784e-01)))));
+u+=ab*(Y+X);
+ac=Y*Y;
+Z=%_ConstructDouble(%_DoubleHi(3.0+ac+u),0);
+aa=u-((Z-3.0)-ac);
+G=Y*Z;
+q=ab*Z+aa*X;
+var ad=%_ConstructDouble(%_DoubleHi(G+q),0);
+var ae=q-(ad-G);
+var af=9.61796700954437255859e-01*ad;
+var ag=-7.02846165095275826516e-09*ad+ae*9.61796693925975554329e-01+W;
+var s=v;
+var ah=%_ConstructDouble(%_DoubleHi(((af+ag)+V)+s),0);
+var ai=ag-(((ah-s)-V)-af);
+return ah+ai;
+}
+b.InstallFunctions(d,2,[
+"cos",MathCos,
+"sin",MathSin,
+"tan",MathTan,
+"sinh",MathSinh,
+"cosh",MathCosh,
+"tanh",MathTanh,
+"log10",MathLog10,
+"log2",MathLog2,
+"log1p",MathLog1p,
+"expm1",MathExpm1
+]);
+%SetForceInlineFlag(MathSin);
+%SetForceInlineFlag(MathCos);
+})
+
+regexp

+(function(a,b){
+'use strict';
+%CheckIsBootstrapping();
+var c;
+var d;
+var e=a.Array;
+var f=a.Object;
+var g=a.RegExp;
+var h;
+var i=b.InternalArray;
+var j=b.InternalPackedArray;
+var k;
+var l;
+var m;
+var n=b.ImportNow("match_symbol");
+var o=b.ImportNow("replace_symbol");
+var p=b.ImportNow("search_symbol");
+var q=b.ImportNow("split_symbol");
+var r;
+b.Import(function(s){
+c=s.AddIndexedProperty;
+d=s.ExpandReplacement;
+k=s.MakeTypeError;
+l=s.MaxSimple;
+m=s.MinSimple;
+r=s.SpeciesConstructor;
+});
+var t=new j(
+2,
+"",
+(void 0),
+0,
+0
+);
+function IsRegExp(u){
+if(!(%_IsJSReceiver(u)))return false;
+var v=u[n];
+if(!(v===(void 0)))return(!!(v));
+return(%_IsRegExp(u));
+}
+function RegExpInitialize(w,x,y){
+x=(x===(void 0))?'':(%_ToString(x));
+y=(y===(void 0))?'':(%_ToString(y));
+%RegExpInitializeAndCompile(w,x,y);
+return w;
+}
+function PatternFlags(x){
+return((%_RegExpFlags(x)&1)?'g':'')+
+((%_RegExpFlags(x)&2)?'i':'')+
+((%_RegExpFlags(x)&4)?'m':'')+
+((%_RegExpFlags(x)&16)?'u':'')+
+((%_RegExpFlags(x)&8)?'y':'');
+}
+function RegExpConstructor(x,y){
+var z=new.target;
+var A=IsRegExp(x);
+if((z===(void 0))){
+z=g;
+if(A&&(y===(void 0))&&
+x.constructor===z){
+return x;
+}
+}
+if((%_IsRegExp(x))){
+if((y===(void 0)))y=PatternFlags(x);
+x=(%_RegExpSource(x));
+}else if(A){
+var B=x;
+x=x.source;
+if((y===(void 0)))y=B.flags;
+}
+var w=%_NewObject(g,z);
+return RegExpInitialize(w,x,y);
+}
+function RegExpCompileJS(x,y){
+if(!(%_IsRegExp(this))){
+throw k(44,
+"RegExp.prototype.compile",this);
+}
+if((%_IsRegExp(x))){
+if(!(y===(void 0)))throw k(132);
+y=PatternFlags(x);
+x=(%_RegExpSource(x));
+}
+RegExpInitialize(this,x,y);
+}
+function DoRegExpExec(C,D,E){
+return %_RegExpExec(C,D,E,t);
+}
+function RegExpExecNoTests(C,D,F){
+var G=%_RegExpExec(C,D,F,t);
+if(G!==null){
+if((%_RegExpFlags(C)&8))C.lastIndex=G[4];
+var H=((G)[0])>>1;
+var F=G[3];
+var I=G[4];
+var J=%_SubString(D,F,I);
+var K=%_RegExpConstructResult(H,F,D);
+K[0]=J;
+if(H==1)return K;
+var L=3+2;
+for(var M=1;M<H;M++){
+F=G[L++];
+if(F!=-1){
+I=G[L];
+K[M]=%_SubString(D,F,I);
+}
+L++;
+}
+return K;
+;
+}
+C.lastIndex=0;
+return null;
+}
+function RegExpSubclassExecJS(D){
+if(!(%_IsRegExp(this))){
+throw k(44,
+'RegExp.prototype.exec',this);
+}
+D=(%_ToString(D));
+var N=this.lastIndex;
+var M=(%_ToLength(N));
+var a=(!!((%_RegExpFlags(this)&1)));
+var O=(!!((%_RegExpFlags(this)&8)));
+var P=a||O;
+if(P){
+if(M>D.length){
+this.lastIndex=0;
+return null;
+}
+}else{
+M=0;
+}
+var Q=%_RegExpExec(this,D,M,t);
+if((Q===null)){
+this.lastIndex=0;
+return null;
+}
+if(P){
+this.lastIndex=t[4];
+}
+var H=((Q)[0])>>1;
+var F=Q[3];
+var I=Q[4];
+var J=%_SubString(D,F,I);
+var K=%_RegExpConstructResult(H,F,D);
+K[0]=J;
+if(H==1)return K;
+var L=3+2;
+for(var M=1;M<H;M++){
+F=Q[L++];
+if(F!=-1){
+I=Q[L];
+K[M]=%_SubString(D,F,I);
+}
+L++;
+}
+return K;
+;
+}
+%FunctionRemovePrototype(RegExpSubclassExecJS);
+function RegExpExecJS(D){
+if(!(%_IsRegExp(this))){
+throw k(44,
+'RegExp.prototype.exec',this);
+}
+D=(%_ToString(D));
+var N=this.lastIndex;
+var M=(%_ToLength(N));
+var P=(%_RegExpFlags(this)&1)||(%_RegExpFlags(this)&8);
+if(P){
+if(M<0||M>D.length){
+this.lastIndex=0;
+return null;
+}
+}else{
+M=0;
+}
+var Q=%_RegExpExec(this,D,M,t);
+if((Q===null)){
+this.lastIndex=0;
+return null;
+}
+if(P){
+this.lastIndex=t[4];
+}
+var H=((Q)[0])>>1;
+var F=Q[3];
+var I=Q[4];
+var J=%_SubString(D,F,I);
+var K=%_RegExpConstructResult(H,F,D);
+K[0]=J;
+if(H==1)return K;
+var L=3+2;
+for(var M=1;M<H;M++){
+F=Q[L++];
+if(F!=-1){
+I=Q[L];
+K[M]=%_SubString(D,F,I);
+}
+L++;
+}
+return K;
+;
+}
+function RegExpSubclassExec(C,D,R){
+if((R===(void 0))){
+R=C.exec;
+}
+if((typeof(R)==='function')){
+var K=%_Call(R,C,D);
+if(!(%_IsJSReceiver(K))&&!(K===null)){
+throw k(49);
+}
+return K;
+}
+return %_Call(RegExpExecJS,C,D);
+}
+%SetForceInlineFlag(RegExpSubclassExec);
+var S;
+var T;
+function RegExpTest(D){
+if(!(%_IsRegExp(this))){
+throw k(44,
+'RegExp.prototype.test',this);
+}
+D=(%_ToString(D));
+var N=this.lastIndex;
+var M=(%_ToLength(N));
+if((%_RegExpFlags(this)&1)||(%_RegExpFlags(this)&8)){
+if(M<0||M>D.length){
+this.lastIndex=0;
+return false;
+}
+var Q=%_RegExpExec(this,D,M,t);
+if((Q===null)){
+this.lastIndex=0;
+return false;
+}
+this.lastIndex=t[4];
+return true;
+}else{
+var C=this;
+var U=(%_RegExpSource(C));
+if(C.length>=3&&
+%_StringCharCodeAt(C,0)==46&&
+%_StringCharCodeAt(C,1)==42&&
+%_StringCharCodeAt(C,2)!=63){
+C=TrimRegExp(C);
+}
+var Q=%_RegExpExec(C,D,0,t);
+if((Q===null)){
+this.lastIndex=0;
+return false;
+}
+return true;
+}
+}
+function RegExpSubclassTest(D){
+if(!(%_IsJSReceiver(this))){
+throw k(44,
+'RegExp.prototype.test',this);
+}
+D=(%_ToString(D));
+var V=RegExpSubclassExec(this,D);
+return!(V===null);
+}
+%FunctionRemovePrototype(RegExpSubclassTest);
+function TrimRegExp(C){
+if(S!==C){
+S=C;
+T=
+new g(
+%_SubString((%_RegExpSource(C)),2,(%_RegExpSource(C)).length),
+((%_RegExpFlags(C)&2)?(%_RegExpFlags(C)&4)?"im":"i"
+:(%_RegExpFlags(C)&4)?"m":""));
+}
+return T;
+}
+function RegExpToString(){
+if(!(%_IsJSReceiver(this))){
+throw k(
+44,'RegExp.prototype.toString',this);
+}
+if(this===h){
+%IncrementUseCounter(12);
+}
+return'/'+(%_ToString(this.source))+'/'+(%_ToString(this.flags));
+}
+function AtSurrogatePair(W,E){
+if(E+1>=W.length)return false;
+var J=%_StringCharCodeAt(W,E);
+if(J<0xD800||J>0xDBFF)return false;
+var X=%_StringCharCodeAt(W,E+1);
+return X>=0xDC00||X<=0xDFFF;
+}
+function RegExpSplit(D,Y){
+if(!(%_IsRegExp(this))){
+throw k(44,
+"RegExp.prototype.@@split",this);
+}
+var Z=this;
+var W=(%_ToString(D));
+Y=((Y===(void 0)))?4294967295:((Y)>>>0);
+var aa=W.length;
+if(Y===0)return[];
+if(aa===0){
+if(DoRegExpExec(Z,W,0,0)!==null)return[];
+return[W];
+}
+var ab=0;
+var ac=0;
+var ad=0;
+var K=new i();
+outer_loop:
+while(true){
+if(ac===aa){
+K[K.length]=%_SubString(W,ab,aa);
+break;
+}
+var G=DoRegExpExec(Z,W,ac);
+if(G===null||aa===(ad=G[3])){
+K[K.length]=%_SubString(W,ab,aa);
+break;
+}
+var ae=G[4];
+if(ac===ae&&ae===ab){
+if((%_RegExpFlags(this)&16)&&AtSurrogatePair(W,ac)){
+ac+=2;
+}else{
+ac++;
+}
+continue;
+}
+K[K.length]=%_SubString(W,ab,ad);
+if(K.length===Y)break;
+var af=((G)[0])+3;
+for(var M=3+2;M<af;){
+var F=G[M++];
+var I=G[M++];
+if(I!=-1){
+K[K.length]=%_SubString(W,F,I);
+}else{
+K[K.length]=(void 0);
+}
+if(K.length===Y)break outer_loop;
+}
+ac=ab=ae;
+}
+var ag=[];
+%MoveArrayContents(K,ag);
+return ag;
+}
+function RegExpSubclassSplit(D,Y){
+if(!(%_IsJSReceiver(this))){
+throw k(44,
+"RegExp.prototype.@@split",this);
+}
+D=(%_ToString(D));
+var ah=r(this,g);
+var y=(%_ToString(this.flags));
+var R;
+if((%_IsRegExp(this))&&ah===g){
+R=this.exec;
+if(R===RegExpSubclassExecJS){
+return %_Call(RegExpSplit,this,D,Y);
+}
+}
+var ai=%StringIndexOf(y,'u',0)>=0;
+var O=%StringIndexOf(y,'y',0)>=0;
+var aj=O?y:y+"y";
+var ak=new ah(this,aj);
+var al=new e();
+var am=0;
+var an=((Y===(void 0)))?4294967295:((Y)>>>0);
+var ao=D.length;
+var ap=0;
+if(an===0)return al;
+var K;
+if(ao===0){
+K=RegExpSubclassExec(ak,D);
+if((K===null))c(al,0,D);
+return al;
+}
+var aq=ap;
+while(aq<ao){
+ak.lastIndex=aq;
+K=RegExpSubclassExec(ak,D,R);
+R=(void 0);
+if((K===null)){
+aq+=AdvanceStringIndex(D,aq,ai);
+}else{
+var I=m((%_ToLength(ak.lastIndex)),ao);
+if(I===aq){
+aq+=AdvanceStringIndex(D,aq,ai);
+}else{
+c(
+al,am,
+%_SubString(D,ap,aq));
+am++;
+if(am===an)return al;
+ap=I;
+var ar=l((%_ToLength(K.length)),0);
+for(var M=1;M<ar;M++){
+c(al,am,K[M]);
+am++;
+if(am===an)return al;
+}
+aq=ap;
+}
+}
+}
+c(al,am,
+%_SubString(D,ap,ao));
+return al;
+}
+%FunctionRemovePrototype(RegExpSubclassSplit);
+function RegExpMatch(D){
+if(!(%_IsRegExp(this))){
+throw k(44,
+"RegExp.prototype.@@match",this);
+}
+var W=(%_ToString(D));
+if(!(%_RegExpFlags(this)&1))return RegExpExecNoTests(this,W,0);
+this.lastIndex=0;
+var K=%StringMatch(W,this,t);
+return K;
+}
+function RegExpSubclassMatch(D){
+if(!(%_IsJSReceiver(this))){
+throw k(44,
+"RegExp.prototype.@@match",this);
+}
+D=(%_ToString(D));
+var a=this.global;
+if(!a)return RegExpSubclassExec(this,D);
+var ai=this.unicode;
+this.lastIndex=0;
+var al=new i();
+var as=0;
+var K;
+while(true){
+K=RegExpSubclassExec(this,D);
+if((K===null)){
+if(as===0)return null;
+break;
+}
+var at=(%_ToString(K[0]));
+al[as]=at;
+if(at==="")SetAdvancedStringIndex(this,D,ai);
+as++;
+}
+var au=[];
+%MoveArrayContents(al,au);
+return au;
+}
+%FunctionRemovePrototype(RegExpSubclassMatch);
+var av=new i(4);
+function StringReplaceGlobalRegExpWithFunction(W,C,aw){
+var au=av;
+if(au){
+av=null;
+}else{
+au=new i(16);
+}
+var ax=%RegExpExecMultiple(C,
+W,
+t,
+au);
+C.lastIndex=0;
+if((ax===null)){
+av=au;
+return W;
+}
+var ay=ax.length;
+if(((t)[0])==2){
+var az=0;
+for(var M=0;M<ay;M++){
+var aA=ax[M];
+if(%_IsSmi(aA)){
+if(aA>0){
+az=(aA>>11)+(aA&0x7ff);
+}else{
+az=ax[++M]-aA;
+}
+}else{
+var aB=aw(aA,az,W);
+ax[M]=(%_ToString(aB));
+az+=aA.length;
+}
+}
+}else{
+for(var M=0;M<ay;M++){
+var aA=ax[M];
+if(!%_IsSmi(aA)){
+var aB=%reflect_apply(aw,(void 0),aA);
+ax[M]=(%_ToString(aB));
+}
+}
+}
+var K=%StringBuilderConcat(ax,ay,W);
+au.length=0;
+av=au;
+return K;
+}
+function CaptureString(D,aC,E){
+var aD=E<<1;
+var F=aC[(3+(aD))];
+if(F<0)return;
+var I=aC[(3+(aD+1))];
+return %_SubString(D,F,I);
+}
+function StringReplaceNonGlobalRegExpWithFunction(W,C,aw){
+var G=DoRegExpExec(C,W,0);
+if((G===null)){
+C.lastIndex=0;
+return W;
+}
+var E=G[3];
+var K=%_SubString(W,0,E);
+var aE=G[4];
+var aF=((G)[0])>>1;
+var aG;
+if(aF==1){
+var aH=%_SubString(W,E,aE);
+aG=aw(aH,E,W);
+}else{
+var aI=new i(aF+2);
+for(var L=0;L<aF;L++){
+aI[L]=CaptureString(W,G,L);
+}
+aI[L]=E;
+aI[L+1]=W;
+aG=%reflect_apply(aw,(void 0),aI);
+}
+K+=aG;
+return K+%_SubString(W,aE,W.length);
+}
+function RegExpReplace(D,aw){
+if(!(%_IsRegExp(this))){
+throw k(44,
+"RegExp.prototype.@@replace",this);
+}
+var W=(%_ToString(D));
+var aJ=this;
+if(!(typeof(aw)==='function')){
+aw=(%_ToString(aw));
+if(!(%_RegExpFlags(aJ)&1)){
+var V=DoRegExpExec(aJ,W,0);
+if(V==null){
+aJ.lastIndex=0
+return W;
+}
+if(aw.length==0){
+return %_SubString(W,0,V[3])+
+%_SubString(W,V[4],W.length)
+}
+return d(aw,W,t,
+%_SubString(W,0,V[3]))+
+%_SubString(W,V[4],W.length);
+}
+aJ.lastIndex=0;
+return %StringReplaceGlobalRegExpWithString(
+W,aJ,aw,t);
+}
+if((%_RegExpFlags(aJ)&1)){
+return StringReplaceGlobalRegExpWithFunction(W,aJ,aw);
+}
+return StringReplaceNonGlobalRegExpWithFunction(W,aJ,aw);
+}
+function GetSubstitution(aK,D,aL,aM,aG){
+var aN=aK.length;
+var aO=D.length;
+var aP=aM.length;
+var aQ=aL+aN;
+var K="";
+var aR,aS,aT,aU,aV,aW,aX;
+var aU=%StringIndexOf(aG,'$',0);
+if(aU<0){
+K+=aG;
+return K;
+}
+if(aU>0)K+=%_SubString(aG,0,aU);
+while(true){
+aS='$';
+aR=aU+1;
+if(aR<aG.length){
+aT=%_StringCharCodeAt(aG,aR);
+if(aT==36){
+++aR;
+K+='$';
+}else if(aT==38){
+++aR;
+K+=aK;
+}else if(aT==96){
+++aR;
+K+=%_SubString(D,0,aL);
+}else if(aT==39){
+++aR;
+K+=%_SubString(D,aQ,aO);
+}else if(aT>=48&&aT<=57){
+aV=(aT-48);
+aW=1;
+if(aR+1<aG.length){
+aU=%_StringCharCodeAt(aG,aR+1);
+if(aU>=48&&aU<=57){
+aX=aV*10+((aU-48));
+if(aX<aP){
+aV=aX;
+aW=2;
+}
+}
+}
+if(aV!=0&&aV<aP){
+var aY=aM[aV];
+if(!(aY===(void 0)))K+=aY;
+aR+=aW;
+}else{
+K+='$';
+}
+}else{
+K+='$';
+}
+}else{
+K+='$';
+}
+aU=%StringIndexOf(aG,'$',aR);
+if(aU<0){
+if(aR<aG.length){
+K+=%_SubString(aG,aR,aG.length);
+}
+return K;
+}
+if(aU>aR){
+K+=%_SubString(aG,aR,aU);
+}
+}
+return K;
+}
+function AdvanceStringIndex(D,E,ai){
+var aZ=1;
+if(ai){
+var J=%_StringCharCodeAt(D,E);
+if(J>=0xD800&&J<=0xDBFF&&D.length>E+1){
+var X=%_StringCharCodeAt(D,E+1);
+if(X>=0xDC00&&X<=0xDFFF){
+aZ=2;
+}
+}
+}
+return aZ;
+}
+function SetAdvancedStringIndex(C,D,ai){
+var N=C.lastIndex;
+C.lastIndex=N+
+AdvanceStringIndex(D,N,ai);
+}
+function RegExpSubclassReplace(D,aw){
+if(!(%_IsJSReceiver(this))){
+throw k(44,
+"RegExp.prototype.@@replace",this);
+}
+D=(%_ToString(D));
+var aa=D.length;
+var ba=(typeof(aw)==='function');
+if(!ba)aw=(%_ToString(aw));
+var a=(!!(this.global));
+if(a){
+var ai=(!!(this.unicode));
+this.lastIndex=0;
+}
+var R;
+if((%_IsRegExp(this))){
+R=this.exec;
+if(R===RegExpSubclassExecJS){
+return %_Call(RegExpReplace,this,D,aw);
+}
+}
+var bb=new i();
+var K,aG;
+while(true){
+K=RegExpSubclassExec(this,D,R);
+R=(void 0);
+if((K===null)){
+break;
+}else{
+bb.push(K);
+if(!a)break;
+var at=(%_ToString(K[0]));
+if(at==="")SetAdvancedStringIndex(this,D,ai);
+}
+}
+var bc="";
+var bd=0;
+for(var M=0;M<bb.length;M++){
+K=bb[M];
+var aP=l((%_ToLength(K.length)),0);
+var aK=(%_ToString(K[0]));
+var be=aK.length;
+var aL=l(m((%_ToInteger(K.index)),aa),0);
+var aM=new i();
+for(var as=0;as<aP;as++){
+var aY=K[as];
+if(!(aY===(void 0)))aY=(%_ToString(aY));
+aM[as]=aY;
+}
+if(ba){
+var aI=new i(aP+2);
+for(var L=0;L<aP;L++){
+aI[L]=aM[L];
+}
+aI[L]=aL;
+aI[L+1]=D;
+aG=%reflect_apply(aw,(void 0),aI,0,
+aI.length);
+}else{
+aG=GetSubstitution(aK,D,aL,aM,
+aw);
+}
+if(aL>=bd){
+bc+=
+%_SubString(D,bd,aL)+aG;
+bd=aL+be;
+}
+}
+if(bd>=aa)return bc;
+return bc+%_SubString(D,bd,aa);
+}
+%FunctionRemovePrototype(RegExpSubclassReplace);
+function RegExpSearch(D){
+if(!(%_IsRegExp(this))){
+throw k(44,
+"RegExp.prototype.@@search",this);
+}
+var V=DoRegExpExec(this,(%_ToString(D)),0);
+if(V)return V[3];
+return-1;
+}
+function RegExpSubclassSearch(D){
+if(!(%_IsJSReceiver(this))){
+throw k(44,
+"RegExp.prototype.@@search",this);
+}
+D=(%_ToString(D));
+var bf=this.lastIndex;
+this.lastIndex=0;
+var K=RegExpSubclassExec(this,D);
+this.lastIndex=bf;
+if((K===null))return-1;
+return K.index;
+}
+%FunctionRemovePrototype(RegExpSubclassSearch);
+function RegExpGetLastMatch(){
+var bg=((t)[1]);
+return %_SubString(bg,
+t[3],
+t[4]);
+}
+function RegExpGetLastParen(){
+var aa=((t)[0]);
+if(aa<=2)return'';
+var bg=((t)[1]);
+var F=t[(3+(aa-2))];
+var I=t[(3+(aa-1))];
+if(F!=-1&&I!=-1){
+return %_SubString(bg,F,I);
+}
+return"";
+}
+function RegExpGetLeftContext(){
+var bh;
+var W;
+bh=t[3];
+W=((t)[1]);
+return %_SubString(W,0,bh);
+}
+function RegExpGetRightContext(){
+var bh;
+var W;
+bh=t[4];
+W=((t)[1]);
+return %_SubString(W,bh,W.length);
+}
+function RegExpMakeCaptureGetter(as){
+return function foo(){
+var E=as*2;
+if(E>=((t)[0]))return'';
+var bi=t[(3+(E))];
+var bj=t[(3+(E+1))];
+if(bi==-1||bj==-1)return'';
+return %_SubString(((t)[1]),bi,bj);
+};
+}
+function RegExpGetFlags(){
+if(!(%_IsJSReceiver(this))){
+throw k(
+133,"RegExp.prototype.flags",(%_ToString(this)));
+}
+var K='';
+if(this.global)K+='g';
+if(this.ignoreCase)K+='i';
+if(this.multiline)K+='m';
+if(this.unicode)K+='u';
+if(this.sticky)K+='y';
+return K;
+}
+function RegExpGetGlobal(){
+if(!(%_IsRegExp(this))){
+if(this===h){
+%IncrementUseCounter(31);
+return(void 0);
+}
+throw k(134,"RegExp.prototype.global");
+}
+return(!!((%_RegExpFlags(this)&1)));
+}
+%SetForceInlineFlag(RegExpGetGlobal);
+function RegExpGetIgnoreCase(){
+if(!(%_IsRegExp(this))){
+if(this===h){
+%IncrementUseCounter(31);
+return(void 0);
+}
+throw k(134,"RegExp.prototype.ignoreCase");
+}
+return(!!((%_RegExpFlags(this)&2)));
+}
+function RegExpGetMultiline(){
+if(!(%_IsRegExp(this))){
+if(this===h){
+%IncrementUseCounter(31);
+return(void 0);
+}
+throw k(134,"RegExp.prototype.multiline");
+}
+return(!!((%_RegExpFlags(this)&4)));
+}
+function RegExpGetSource(){
+if(!(%_IsRegExp(this))){
+if(this===h){
+%IncrementUseCounter(30);
+return"(?:)";
+}
+throw k(134,"RegExp.prototype.source");
+}
+return(%_RegExpSource(this));
+}
+function RegExpGetSticky(){
+if(!(%_IsRegExp(this))){
+if(this===h){
+%IncrementUseCounter(11);
+return(void 0);
+}
+throw k(134,"RegExp.prototype.sticky");
+}
+return(!!((%_RegExpFlags(this)&8)));
+}
+%SetForceInlineFlag(RegExpGetSticky);
+%FunctionSetInstanceClassName(g,'RegExp');
+h=new f();
+%FunctionSetPrototype(g,h);
+%AddNamedProperty(
+g.prototype,'constructor',g,2);
+%SetCode(g,RegExpConstructor);
+b.InstallFunctions(g.prototype,2,[
+"exec",RegExpExecJS,
+"test",RegExpTest,
+"toString",RegExpToString,
+"compile",RegExpCompileJS,
+n,RegExpMatch,
+o,RegExpReplace,
+p,RegExpSearch,
+q,RegExpSplit,
+]);
+b.InstallGetter(g.prototype,'flags',RegExpGetFlags);
+b.InstallGetter(g.prototype,'global',RegExpGetGlobal);
+b.InstallGetter(g.prototype,'ignoreCase',RegExpGetIgnoreCase);
+b.InstallGetter(g.prototype,'multiline',RegExpGetMultiline);
+b.InstallGetter(g.prototype,'source',RegExpGetSource);
+b.InstallGetter(g.prototype,'sticky',RegExpGetSticky);
+var bk=function(){
+var bl=((t)[2]);
+return(bl===(void 0))?"":bl;
+};
+var bm=function(D){
+((t)[2])=(%_ToString(D));
+};
+%OptimizeObjectForAddingMultipleProperties(g,22);
+b.InstallGetterSetter(g,'input',bk,bm,
+4);
+b.InstallGetterSetter(g,'$_',bk,bm,
+2|4);
+var bn=function(bo){};
+b.InstallGetterSetter(g,'lastMatch',RegExpGetLastMatch,
+bn,4);
+b.InstallGetterSetter(g,'$&',RegExpGetLastMatch,bn,
+2|4);
+b.InstallGetterSetter(g,'lastParen',RegExpGetLastParen,
+bn,4);
+b.InstallGetterSetter(g,'$+',RegExpGetLastParen,bn,
+2|4);
+b.InstallGetterSetter(g,'leftContext',RegExpGetLeftContext,
+bn,4);
+b.InstallGetterSetter(g,'$`',RegExpGetLeftContext,bn,
+2|4);
+b.InstallGetterSetter(g,'rightContext',RegExpGetRightContext,
+bn,4);
+b.InstallGetterSetter(g,"$'",RegExpGetRightContext,bn,
+2|4);
+for(var M=1;M<10;++M){
+b.InstallGetterSetter(g,'$'+M,RegExpMakeCaptureGetter(M),
+bn,4);
+}
+%ToFastProperties(g);
+var bp=new j(2,"",(void 0),0,0);
+function InternalRegExpMatch(C,W){
+var G=%_RegExpExec(C,W,0,bp);
+if(!(G===null)){
+var H=((G)[0])>>1;
+var F=G[3];
+var I=G[4];
+var J=%_SubString(W,F,I);
+var K=%_RegExpConstructResult(H,F,W);
+K[0]=J;
+if(H==1)return K;
+var L=3+2;
+for(var M=1;M<H;M++){
+F=G[L++];
+if(F!=-1){
+I=G[L];
+K[M]=%_SubString(W,F,I);
+}
+L++;
+}
+return K;
+;
+}
+return null;
+}
+function InternalRegExpReplace(C,W,aG){
+return %StringReplaceGlobalRegExpWithString(
+W,C,aG,bp);
+}
+b.Export(function(bq){
+bq.InternalRegExpMatch=InternalRegExpMatch;
+bq.InternalRegExpReplace=InternalRegExpReplace;
+bq.IsRegExp=IsRegExp;
+bq.RegExpExec=DoRegExpExec;
+bq.RegExpInitialize=RegExpInitialize;
+bq.RegExpLastMatchInfo=t;
+bq.RegExpSubclassExecJS=RegExpSubclassExecJS;
+bq.RegExpSubclassMatch=RegExpSubclassMatch;
+bq.RegExpSubclassReplace=RegExpSubclassReplace;
+bq.RegExpSubclassSearch=RegExpSubclassSearch;
+bq.RegExpSubclassSplit=RegExpSubclassSplit;
+bq.RegExpSubclassTest=RegExpSubclassTest;
+bq.RegExpTest=RegExpTest;
+});
+})
+
+,arraybuffer�
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.ArrayBuffer;
+var d;
+var e;
+var f;
+var g;
+b.Import(function(h){
+d=h.MakeTypeError;
+e=h.MaxSimple;
+f=h.MinSimple;
+g=h.SpeciesConstructor;
+});
+function ArrayBufferGetByteLen(){
+if(!(%_ClassOf(this)==='ArrayBuffer')){
+throw d(44,
+'ArrayBuffer.prototype.byteLength',this);
+}
+return %_ArrayBufferGetByteLength(this);
+}
+function ArrayBufferSlice(i,j){
+if(!(%_ClassOf(this)==='ArrayBuffer')){
+throw d(44,
+'ArrayBuffer.prototype.slice',this);
+}
+var k=(%_ToInteger(i));
+if(!(j===(void 0))){
+j=(%_ToInteger(j));
+}
+var l;
+var m=%_ArrayBufferGetByteLength(this);
+if(k<0){
+l=e(m+k,0);
+}else{
+l=f(k,m);
+}
+var n=(j===(void 0))?m:j;
+var o;
+if(n<0){
+o=e(m+n,0);
+}else{
+o=f(n,m);
+}
+if(o<l){
+o=l;
+}
+var p=o-l;
+var q=g(this,c,true);
+var r=new q(p);
+if(!(%_ClassOf(r)==='ArrayBuffer')){
+throw d(44,
+'ArrayBuffer.prototype.slice',r);
+}
+if(r===this){
+throw d(11);
+}
+if(%_ArrayBufferGetByteLength(r)<p){
+throw d(10);
+}
+%ArrayBufferSliceImpl(this,r,l,p);
+return r;
+}
+b.InstallGetter(c.prototype,"byteLength",
+ArrayBufferGetByteLen);
+b.InstallFunctions(c.prototype,2,[
+"slice",ArrayBufferSlice
+]);
+})
+
+(typedarrayf�
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c;
+var d=b.ImportNow("ArrayToString");
+var e;
+var f;
+var g;
+var h=a.Array;
+var i=a.ArrayBuffer;
+var j=i.prototype;
+var k=a.DataView;
+var l=a.Object;
+var m=b.InternalArray;
+var n;
+var o;
+var p;
+var q;
+var r;
+var s;
+var t;
+var u;
+var v;
+var w;
+var x;
+var y;
+var z;
+var A;
+var B;
+var C;
+var m=b.InternalArray;
+var D;
+var E;
+var F;
+var G;
+var H;
+var I;
+var J;
+var K;
+var L=b.ImportNow("iterator_symbol");
+var M=b.ImportNow("to_string_tag_symbol");
+var N=a.Uint8Array;
+
+var O=a.Int8Array;
+
+var P=a.Uint16Array;
+
+var Q=a.Int16Array;
+
+var R=a.Uint32Array;
+
+var S=a.Int32Array;
+
+var T=a.Float32Array;
+
+var U=a.Float64Array;
+
+var V=a.Uint8ClampedArray;
+
+
+b.Import(function(W){
+c=W.AddIndexedProperty;
+e=W.ArrayValues;
+f=W.GetIterator;
+g=W.GetMethod;
+n=W.InnerArrayCopyWithin;
+o=W.InnerArrayEvery;
+p=W.InnerArrayFill;
+q=W.InnerArrayFilter;
+r=W.InnerArrayFind;
+s=W.InnerArrayFindIndex;
+t=W.InnerArrayForEach;
+u=W.InnerArrayIncludes;
+v=W.InnerArrayIndexOf;
+w=W.InnerArrayJoin;
+x=W.InnerArrayLastIndexOf;
+y=W.InnerArrayReduce;
+z=W.InnerArrayReduceRight;
+A=W.InnerArraySome;
+B=W.InnerArraySort;
+C=W.InnerArrayToLocaleString;
+D=W.IsNaN;
+E=W.MakeRangeError;
+F=W.MakeTypeError;
+G=W.MaxSimple;
+H=W.MinSimple;
+I=W.PackedArrayReverse;
+J=W.SpeciesConstructor;
+K=W.ToPositiveInteger;
+});
+function TypedArrayDefaultConstructor(X){
+switch(%_ClassOf(X)){
+case"Uint8Array":
+return N;
+
+case"Int8Array":
+return O;
+
+case"Uint16Array":
+return P;
+
+case"Int16Array":
+return Q;
+
+case"Uint32Array":
+return R;
+
+case"Int32Array":
+return S;
+
+case"Float32Array":
+return T;
+
+case"Float64Array":
+return U;
+
+case"Uint8ClampedArray":
+return V;
+
+
+}
+throw F(44,
+"TypedArrayDefaultConstructor",this);
+}
+function TypedArrayCreate(Y,Z,aa,ab){
+if((aa===(void 0))){
+var ac=new Y(Z);
+}else{
+var ac=new Y(Z,aa,ab);
+}
+if(!(%_IsTypedArray(ac)))throw F(72);
+if((typeof(Z)==='number')&&%_TypedArrayGetLength(ac)<Z){
+throw F(253);
+}
+return ac;
+}
+function TypedArraySpeciesCreate(ad,Z,aa,ab,ae){
+var af=TypedArrayDefaultConstructor(ad);
+var Y=J(ad,af,
+ae);
+return TypedArrayCreate(Y,Z,aa,ab);
+}
+function Uint8ArrayConstructByArrayBuffer(ag,ah,ai,aj){
+if(!(ai===(void 0))){
+ai=K(ai,179);
+}
+if(!(aj===(void 0))){
+aj=K(aj,179);
+}
+var ak=%_ArrayBufferGetByteLength(ah);
+var al;
+if((ai===(void 0))){
+al=0;
+}else{
+al=ai;
+if(al % 1!==0){
+throw E(178,
+"start offset","Uint8Array",1);
+}
+if(al>ak){
+throw E(180);
+}
+}
+var am;
+var an;
+if((aj===(void 0))){
+if(ak % 1!==0){
+throw E(178,
+"byte length","Uint8Array",1);
+}
+am=ak-al;
+an=am/1;
+}else{
+var an=aj;
+am=an*1;
+}
+if((al+am>ak)
+||(an>%_MaxSmi())){
+throw E(179);
+}
+%_TypedArrayInitialize(ag,1,ah,al,am,true);
+}
+function Uint8ArrayConstructByLength(ag,aj){
+var ao=(aj===(void 0))?
+0:K(aj,179);
+if(ao>%_MaxSmi()){
+throw E(179);
+}
+var ap=ao*1;
+if(ap>%_TypedArrayMaxSizeInHeap()){
+var ah=new i(ap);
+%_TypedArrayInitialize(ag,1,ah,0,ap,true);
+}else{
+%_TypedArrayInitialize(ag,1,null,0,ap,true);
+}
+}
+function Uint8ArrayConstructByArrayLike(ag,aq,aj){
+var ao=K(aj,179);
+if(ao>%_MaxSmi()){
+throw E(179);
+}
+var ar=false;
+var ap=ao*1;
+if(ap<=%_TypedArrayMaxSizeInHeap()){
+%_TypedArrayInitialize(ag,1,null,0,ap,false);
+}else{
+ar=
+%TypedArrayInitializeFromArrayLike(ag,1,aq,ao);
+}
+if(!ar){
+for(var as=0;as<ao;as++){
+ag[as]=aq[as];
+}
+}
+}
+function Uint8ArrayConstructByIterable(ag,at,au){
+var av=new m();
+var aw=%_Call(au,at);
+var ax={
+__proto__:null
+};
+ax[L]=function(){return aw;}
+for(var ay of ax){
+av.push(ay);
+}
+Uint8ArrayConstructByArrayLike(ag,av,av.length);
+}
+function Uint8ArrayConstructByTypedArray(ag,X){
+var az=%TypedArrayGetBuffer(X);
+var aj=%_TypedArrayGetLength(X);
+var ap=%_ArrayBufferViewGetByteLength(X);
+var am=aj*1;
+Uint8ArrayConstructByArrayLike(ag,X,aj);
+var aA=J(az,i);
+var aB=aA.prototype;
+if((%_IsJSReceiver(aB))&&aB!==j){
+%InternalSetPrototype(%TypedArrayGetBuffer(ag),aB);
+}
+}
+function Uint8ArrayConstructor(aa,ab,aC){
+if(!(new.target===(void 0))){
+if((%_ClassOf(aa)==='ArrayBuffer')||(%_ClassOf(aa)==='SharedArrayBuffer')){
+Uint8ArrayConstructByArrayBuffer(this,aa,ab,aC);
+}else if((typeof(aa)==='number')||(typeof(aa)==='string')||
+(typeof(aa)==='boolean')||(aa===(void 0))){
+Uint8ArrayConstructByLength(this,aa);
+}else if((%_IsTypedArray(aa))){
+Uint8ArrayConstructByTypedArray(this,aa);
+}else{
+var au=aa[L];
+if((au===(void 0))||au===e){
+Uint8ArrayConstructByArrayLike(this,aa,aa.length);
+}else{
+Uint8ArrayConstructByIterable(this,aa,au);
+}
+}
+}else{
+throw F(28,"Uint8Array")
+}
+}
+function Uint8ArraySubArray(aD,aE){
+var aF=(%_ToInteger(aD));
+if(!(aE===(void 0))){
+var aG=(%_ToInteger(aE));
+var aH=%_TypedArrayGetLength(this);
+}else{
+var aH=%_TypedArrayGetLength(this);
+var aG=aH;
+}
+if(aF<0){
+aF=G(0,aH+aF);
+}else{
+aF=H(aF,aH);
+}
+if(aG<0){
+aG=G(0,aH+aG);
+}else{
+aG=H(aG,aH);
+}
+if(aG<aF){
+aG=aF;
+}
+var an=aG-aF;
+var aI=
+%_ArrayBufferViewGetByteOffset(this)+aF*1;
+return new N(%TypedArrayGetBuffer(this),aI,an);
+}
+
+function Int8ArrayConstructByArrayBuffer(ag,ah,ai,aj){
+if(!(ai===(void 0))){
+ai=K(ai,179);
+}
+if(!(aj===(void 0))){
+aj=K(aj,179);
+}
+var ak=%_ArrayBufferGetByteLength(ah);
+var al;
+if((ai===(void 0))){
+al=0;
+}else{
+al=ai;
+if(al % 1!==0){
+throw E(178,
+"start offset","Int8Array",1);
+}
+if(al>ak){
+throw E(180);
+}
+}
+var am;
+var an;
+if((aj===(void 0))){
+if(ak % 1!==0){
+throw E(178,
+"byte length","Int8Array",1);
+}
+am=ak-al;
+an=am/1;
+}else{
+var an=aj;
+am=an*1;
+}
+if((al+am>ak)
+||(an>%_MaxSmi())){
+throw E(179);
+}
+%_TypedArrayInitialize(ag,2,ah,al,am,true);
+}
+function Int8ArrayConstructByLength(ag,aj){
+var ao=(aj===(void 0))?
+0:K(aj,179);
+if(ao>%_MaxSmi()){
+throw E(179);
+}
+var ap=ao*1;
+if(ap>%_TypedArrayMaxSizeInHeap()){
+var ah=new i(ap);
+%_TypedArrayInitialize(ag,2,ah,0,ap,true);
+}else{
+%_TypedArrayInitialize(ag,2,null,0,ap,true);
+}
+}
+function Int8ArrayConstructByArrayLike(ag,aq,aj){
+var ao=K(aj,179);
+if(ao>%_MaxSmi()){
+throw E(179);
+}
+var ar=false;
+var ap=ao*1;
+if(ap<=%_TypedArrayMaxSizeInHeap()){
+%_TypedArrayInitialize(ag,2,null,0,ap,false);
+}else{
+ar=
+%TypedArrayInitializeFromArrayLike(ag,2,aq,ao);
+}
+if(!ar){
+for(var as=0;as<ao;as++){
+ag[as]=aq[as];
+}
+}
+}
+function Int8ArrayConstructByIterable(ag,at,au){
+var av=new m();
+var aw=%_Call(au,at);
+var ax={
+__proto__:null
+};
+ax[L]=function(){return aw;}
+for(var ay of ax){
+av.push(ay);
+}
+Int8ArrayConstructByArrayLike(ag,av,av.length);
+}
+function Int8ArrayConstructByTypedArray(ag,X){
+var az=%TypedArrayGetBuffer(X);
+var aj=%_TypedArrayGetLength(X);
+var ap=%_ArrayBufferViewGetByteLength(X);
+var am=aj*1;
+Int8ArrayConstructByArrayLike(ag,X,aj);
+var aA=J(az,i);
+var aB=aA.prototype;
+if((%_IsJSReceiver(aB))&&aB!==j){
+%InternalSetPrototype(%TypedArrayGetBuffer(ag),aB);
+}
+}
+function Int8ArrayConstructor(aa,ab,aC){
+if(!(new.target===(void 0))){
+if((%_ClassOf(aa)==='ArrayBuffer')||(%_ClassOf(aa)==='SharedArrayBuffer')){
+Int8ArrayConstructByArrayBuffer(this,aa,ab,aC);
+}else if((typeof(aa)==='number')||(typeof(aa)==='string')||
+(typeof(aa)==='boolean')||(aa===(void 0))){
+Int8ArrayConstructByLength(this,aa);
+}else if((%_IsTypedArray(aa))){
+Int8ArrayConstructByTypedArray(this,aa);
+}else{
+var au=aa[L];
+if((au===(void 0))||au===e){
+Int8ArrayConstructByArrayLike(this,aa,aa.length);
+}else{
+Int8ArrayConstructByIterable(this,aa,au);
+}
+}
+}else{
+throw F(28,"Int8Array")
+}
+}
+function Int8ArraySubArray(aD,aE){
+var aF=(%_ToInteger(aD));
+if(!(aE===(void 0))){
+var aG=(%_ToInteger(aE));
+var aH=%_TypedArrayGetLength(this);
+}else{
+var aH=%_TypedArrayGetLength(this);
+var aG=aH;
+}
+if(aF<0){
+aF=G(0,aH+aF);
+}else{
+aF=H(aF,aH);
+}
+if(aG<0){
+aG=G(0,aH+aG);
+}else{
+aG=H(aG,aH);
+}
+if(aG<aF){
+aG=aF;
+}
+var an=aG-aF;
+var aI=
+%_ArrayBufferViewGetByteOffset(this)+aF*1;
+return new O(%TypedArrayGetBuffer(this),aI,an);
+}
+
+function Uint16ArrayConstructByArrayBuffer(ag,ah,ai,aj){
+if(!(ai===(void 0))){
+ai=K(ai,179);
+}
+if(!(aj===(void 0))){
+aj=K(aj,179);
+}
+var ak=%_ArrayBufferGetByteLength(ah);
+var al;
+if((ai===(void 0))){
+al=0;
+}else{
+al=ai;
+if(al % 2!==0){
+throw E(178,
+"start offset","Uint16Array",2);
+}
+if(al>ak){
+throw E(180);
+}
+}
+var am;
+var an;
+if((aj===(void 0))){
+if(ak % 2!==0){
+throw E(178,
+"byte length","Uint16Array",2);
+}
+am=ak-al;
+an=am/2;
+}else{
+var an=aj;
+am=an*2;
+}
+if((al+am>ak)
+||(an>%_MaxSmi())){
+throw E(179);
+}
+%_TypedArrayInitialize(ag,3,ah,al,am,true);
+}
+function Uint16ArrayConstructByLength(ag,aj){
+var ao=(aj===(void 0))?
+0:K(aj,179);
+if(ao>%_MaxSmi()){
+throw E(179);
+}
+var ap=ao*2;
+if(ap>%_TypedArrayMaxSizeInHeap()){
+var ah=new i(ap);
+%_TypedArrayInitialize(ag,3,ah,0,ap,true);
+}else{
+%_TypedArrayInitialize(ag,3,null,0,ap,true);
+}
+}
+function Uint16ArrayConstructByArrayLike(ag,aq,aj){
+var ao=K(aj,179);
+if(ao>%_MaxSmi()){
+throw E(179);
+}
+var ar=false;
+var ap=ao*2;
+if(ap<=%_TypedArrayMaxSizeInHeap()){
+%_TypedArrayInitialize(ag,3,null,0,ap,false);
+}else{
+ar=
+%TypedArrayInitializeFromArrayLike(ag,3,aq,ao);
+}
+if(!ar){
+for(var as=0;as<ao;as++){
+ag[as]=aq[as];
+}
+}
+}
+function Uint16ArrayConstructByIterable(ag,at,au){
+var av=new m();
+var aw=%_Call(au,at);
+var ax={
+__proto__:null
+};
+ax[L]=function(){return aw;}
+for(var ay of ax){
+av.push(ay);
+}
+Uint16ArrayConstructByArrayLike(ag,av,av.length);
+}
+function Uint16ArrayConstructByTypedArray(ag,X){
+var az=%TypedArrayGetBuffer(X);
+var aj=%_TypedArrayGetLength(X);
+var ap=%_ArrayBufferViewGetByteLength(X);
+var am=aj*2;
+Uint16ArrayConstructByArrayLike(ag,X,aj);
+var aA=J(az,i);
+var aB=aA.prototype;
+if((%_IsJSReceiver(aB))&&aB!==j){
+%InternalSetPrototype(%TypedArrayGetBuffer(ag),aB);
+}
+}
+function Uint16ArrayConstructor(aa,ab,aC){
+if(!(new.target===(void 0))){
+if((%_ClassOf(aa)==='ArrayBuffer')||(%_ClassOf(aa)==='SharedArrayBuffer')){
+Uint16ArrayConstructByArrayBuffer(this,aa,ab,aC);
+}else if((typeof(aa)==='number')||(typeof(aa)==='string')||
+(typeof(aa)==='boolean')||(aa===(void 0))){
+Uint16ArrayConstructByLength(this,aa);
+}else if((%_IsTypedArray(aa))){
+Uint16ArrayConstructByTypedArray(this,aa);
+}else{
+var au=aa[L];
+if((au===(void 0))||au===e){
+Uint16ArrayConstructByArrayLike(this,aa,aa.length);
+}else{
+Uint16ArrayConstructByIterable(this,aa,au);
+}
+}
+}else{
+throw F(28,"Uint16Array")
+}
+}
+function Uint16ArraySubArray(aD,aE){
+var aF=(%_ToInteger(aD));
+if(!(aE===(void 0))){
+var aG=(%_ToInteger(aE));
+var aH=%_TypedArrayGetLength(this);
+}else{
+var aH=%_TypedArrayGetLength(this);
+var aG=aH;
+}
+if(aF<0){
+aF=G(0,aH+aF);
+}else{
+aF=H(aF,aH);
+}
+if(aG<0){
+aG=G(0,aH+aG);
+}else{
+aG=H(aG,aH);
+}
+if(aG<aF){
+aG=aF;
+}
+var an=aG-aF;
+var aI=
+%_ArrayBufferViewGetByteOffset(this)+aF*2;
+return new P(%TypedArrayGetBuffer(this),aI,an);
+}
+
+function Int16ArrayConstructByArrayBuffer(ag,ah,ai,aj){
+if(!(ai===(void 0))){
+ai=K(ai,179);
+}
+if(!(aj===(void 0))){
+aj=K(aj,179);
+}
+var ak=%_ArrayBufferGetByteLength(ah);
+var al;
+if((ai===(void 0))){
+al=0;
+}else{
+al=ai;
+if(al % 2!==0){
+throw E(178,
+"start offset","Int16Array",2);
+}
+if(al>ak){
+throw E(180);
+}
+}
+var am;
+var an;
+if((aj===(void 0))){
+if(ak % 2!==0){
+throw E(178,
+"byte length","Int16Array",2);
+}
+am=ak-al;
+an=am/2;
+}else{
+var an=aj;
+am=an*2;
+}
+if((al+am>ak)
+||(an>%_MaxSmi())){
+throw E(179);
+}
+%_TypedArrayInitialize(ag,4,ah,al,am,true);
+}
+function Int16ArrayConstructByLength(ag,aj){
+var ao=(aj===(void 0))?
+0:K(aj,179);
+if(ao>%_MaxSmi()){
+throw E(179);
+}
+var ap=ao*2;
+if(ap>%_TypedArrayMaxSizeInHeap()){
+var ah=new i(ap);
+%_TypedArrayInitialize(ag,4,ah,0,ap,true);
+}else{
+%_TypedArrayInitialize(ag,4,null,0,ap,true);
+}
+}
+function Int16ArrayConstructByArrayLike(ag,aq,aj){
+var ao=K(aj,179);
+if(ao>%_MaxSmi()){
+throw E(179);
+}
+var ar=false;
+var ap=ao*2;
+if(ap<=%_TypedArrayMaxSizeInHeap()){
+%_TypedArrayInitialize(ag,4,null,0,ap,false);
+}else{
+ar=
+%TypedArrayInitializeFromArrayLike(ag,4,aq,ao);
+}
+if(!ar){
+for(var as=0;as<ao;as++){
+ag[as]=aq[as];
+}
+}
+}
+function Int16ArrayConstructByIterable(ag,at,au){
+var av=new m();
+var aw=%_Call(au,at);
+var ax={
+__proto__:null
+};
+ax[L]=function(){return aw;}
+for(var ay of ax){
+av.push(ay);
+}
+Int16ArrayConstructByArrayLike(ag,av,av.length);
+}
+function Int16ArrayConstructByTypedArray(ag,X){
+var az=%TypedArrayGetBuffer(X);
+var aj=%_TypedArrayGetLength(X);
+var ap=%_ArrayBufferViewGetByteLength(X);
+var am=aj*2;
+Int16ArrayConstructByArrayLike(ag,X,aj);
+var aA=J(az,i);
+var aB=aA.prototype;
+if((%_IsJSReceiver(aB))&&aB!==j){
+%InternalSetPrototype(%TypedArrayGetBuffer(ag),aB);
+}
+}
+function Int16ArrayConstructor(aa,ab,aC){
+if(!(new.target===(void 0))){
+if((%_ClassOf(aa)==='ArrayBuffer')||(%_ClassOf(aa)==='SharedArrayBuffer')){
+Int16ArrayConstructByArrayBuffer(this,aa,ab,aC);
+}else if((typeof(aa)==='number')||(typeof(aa)==='string')||
+(typeof(aa)==='boolean')||(aa===(void 0))){
+Int16ArrayConstructByLength(this,aa);
+}else if((%_IsTypedArray(aa))){
+Int16ArrayConstructByTypedArray(this,aa);
+}else{
+var au=aa[L];
+if((au===(void 0))||au===e){
+Int16ArrayConstructByArrayLike(this,aa,aa.length);
+}else{
+Int16ArrayConstructByIterable(this,aa,au);
+}
+}
+}else{
+throw F(28,"Int16Array")
+}
+}
+function Int16ArraySubArray(aD,aE){
+var aF=(%_ToInteger(aD));
+if(!(aE===(void 0))){
+var aG=(%_ToInteger(aE));
+var aH=%_TypedArrayGetLength(this);
+}else{
+var aH=%_TypedArrayGetLength(this);
+var aG=aH;
+}
+if(aF<0){
+aF=G(0,aH+aF);
+}else{
+aF=H(aF,aH);
+}
+if(aG<0){
+aG=G(0,aH+aG);
+}else{
+aG=H(aG,aH);
+}
+if(aG<aF){
+aG=aF;
+}
+var an=aG-aF;
+var aI=
+%_ArrayBufferViewGetByteOffset(this)+aF*2;
+return new Q(%TypedArrayGetBuffer(this),aI,an);
+}
+
+function Uint32ArrayConstructByArrayBuffer(ag,ah,ai,aj){
+if(!(ai===(void 0))){
+ai=K(ai,179);
+}
+if(!(aj===(void 0))){
+aj=K(aj,179);
+}
+var ak=%_ArrayBufferGetByteLength(ah);
+var al;
+if((ai===(void 0))){
+al=0;
+}else{
+al=ai;
+if(al % 4!==0){
+throw E(178,
+"start offset","Uint32Array",4);
+}
+if(al>ak){
+throw E(180);
+}
+}
+var am;
+var an;
+if((aj===(void 0))){
+if(ak % 4!==0){
+throw E(178,
+"byte length","Uint32Array",4);
+}
+am=ak-al;
+an=am/4;
+}else{
+var an=aj;
+am=an*4;
+}
+if((al+am>ak)
+||(an>%_MaxSmi())){
+throw E(179);
+}
+%_TypedArrayInitialize(ag,5,ah,al,am,true);
+}
+function Uint32ArrayConstructByLength(ag,aj){
+var ao=(aj===(void 0))?
+0:K(aj,179);
+if(ao>%_MaxSmi()){
+throw E(179);
+}
+var ap=ao*4;
+if(ap>%_TypedArrayMaxSizeInHeap()){
+var ah=new i(ap);
+%_TypedArrayInitialize(ag,5,ah,0,ap,true);
+}else{
+%_TypedArrayInitialize(ag,5,null,0,ap,true);
+}
+}
+function Uint32ArrayConstructByArrayLike(ag,aq,aj){
+var ao=K(aj,179);
+if(ao>%_MaxSmi()){
+throw E(179);
+}
+var ar=false;
+var ap=ao*4;
+if(ap<=%_TypedArrayMaxSizeInHeap()){
+%_TypedArrayInitialize(ag,5,null,0,ap,false);
+}else{
+ar=
+%TypedArrayInitializeFromArrayLike(ag,5,aq,ao);
+}
+if(!ar){
+for(var as=0;as<ao;as++){
+ag[as]=aq[as];
+}
+}
+}
+function Uint32ArrayConstructByIterable(ag,at,au){
+var av=new m();
+var aw=%_Call(au,at);
+var ax={
+__proto__:null
+};
+ax[L]=function(){return aw;}
+for(var ay of ax){
+av.push(ay);
+}
+Uint32ArrayConstructByArrayLike(ag,av,av.length);
+}
+function Uint32ArrayConstructByTypedArray(ag,X){
+var az=%TypedArrayGetBuffer(X);
+var aj=%_TypedArrayGetLength(X);
+var ap=%_ArrayBufferViewGetByteLength(X);
+var am=aj*4;
+Uint32ArrayConstructByArrayLike(ag,X,aj);
+var aA=J(az,i);
+var aB=aA.prototype;
+if((%_IsJSReceiver(aB))&&aB!==j){
+%InternalSetPrototype(%TypedArrayGetBuffer(ag),aB);
+}
+}
+function Uint32ArrayConstructor(aa,ab,aC){
+if(!(new.target===(void 0))){
+if((%_ClassOf(aa)==='ArrayBuffer')||(%_ClassOf(aa)==='SharedArrayBuffer')){
+Uint32ArrayConstructByArrayBuffer(this,aa,ab,aC);
+}else if((typeof(aa)==='number')||(typeof(aa)==='string')||
+(typeof(aa)==='boolean')||(aa===(void 0))){
+Uint32ArrayConstructByLength(this,aa);
+}else if((%_IsTypedArray(aa))){
+Uint32ArrayConstructByTypedArray(this,aa);
+}else{
+var au=aa[L];
+if((au===(void 0))||au===e){
+Uint32ArrayConstructByArrayLike(this,aa,aa.length);
+}else{
+Uint32ArrayConstructByIterable(this,aa,au);
+}
+}
+}else{
+throw F(28,"Uint32Array")
+}
+}
+function Uint32ArraySubArray(aD,aE){
+var aF=(%_ToInteger(aD));
+if(!(aE===(void 0))){
+var aG=(%_ToInteger(aE));
+var aH=%_TypedArrayGetLength(this);
+}else{
+var aH=%_TypedArrayGetLength(this);
+var aG=aH;
+}
+if(aF<0){
+aF=G(0,aH+aF);
+}else{
+aF=H(aF,aH);
+}
+if(aG<0){
+aG=G(0,aH+aG);
+}else{
+aG=H(aG,aH);
+}
+if(aG<aF){
+aG=aF;
+}
+var an=aG-aF;
+var aI=
+%_ArrayBufferViewGetByteOffset(this)+aF*4;
+return new R(%TypedArrayGetBuffer(this),aI,an);
+}
+
+function Int32ArrayConstructByArrayBuffer(ag,ah,ai,aj){
+if(!(ai===(void 0))){
+ai=K(ai,179);
+}
+if(!(aj===(void 0))){
+aj=K(aj,179);
+}
+var ak=%_ArrayBufferGetByteLength(ah);
+var al;
+if((ai===(void 0))){
+al=0;
+}else{
+al=ai;
+if(al % 4!==0){
+throw E(178,
+"start offset","Int32Array",4);
+}
+if(al>ak){
+throw E(180);
+}
+}
+var am;
+var an;
+if((aj===(void 0))){
+if(ak % 4!==0){
+throw E(178,
+"byte length","Int32Array",4);
+}
+am=ak-al;
+an=am/4;
+}else{
+var an=aj;
+am=an*4;
+}
+if((al+am>ak)
+||(an>%_MaxSmi())){
+throw E(179);
+}
+%_TypedArrayInitialize(ag,6,ah,al,am,true);
+}
+function Int32ArrayConstructByLength(ag,aj){
+var ao=(aj===(void 0))?
+0:K(aj,179);
+if(ao>%_MaxSmi()){
+throw E(179);
+}
+var ap=ao*4;
+if(ap>%_TypedArrayMaxSizeInHeap()){
+var ah=new i(ap);
+%_TypedArrayInitialize(ag,6,ah,0,ap,true);
+}else{
+%_TypedArrayInitialize(ag,6,null,0,ap,true);
+}
+}
+function Int32ArrayConstructByArrayLike(ag,aq,aj){
+var ao=K(aj,179);
+if(ao>%_MaxSmi()){
+throw E(179);
+}
+var ar=false;
+var ap=ao*4;
+if(ap<=%_TypedArrayMaxSizeInHeap()){
+%_TypedArrayInitialize(ag,6,null,0,ap,false);
+}else{
+ar=
+%TypedArrayInitializeFromArrayLike(ag,6,aq,ao);
+}
+if(!ar){
+for(var as=0;as<ao;as++){
+ag[as]=aq[as];
+}
+}
+}
+function Int32ArrayConstructByIterable(ag,at,au){
+var av=new m();
+var aw=%_Call(au,at);
+var ax={
+__proto__:null
+};
+ax[L]=function(){return aw;}
+for(var ay of ax){
+av.push(ay);
+}
+Int32ArrayConstructByArrayLike(ag,av,av.length);
+}
+function Int32ArrayConstructByTypedArray(ag,X){
+var az=%TypedArrayGetBuffer(X);
+var aj=%_TypedArrayGetLength(X);
+var ap=%_ArrayBufferViewGetByteLength(X);
+var am=aj*4;
+Int32ArrayConstructByArrayLike(ag,X,aj);
+var aA=J(az,i);
+var aB=aA.prototype;
+if((%_IsJSReceiver(aB))&&aB!==j){
+%InternalSetPrototype(%TypedArrayGetBuffer(ag),aB);
+}
+}
+function Int32ArrayConstructor(aa,ab,aC){
+if(!(new.target===(void 0))){
+if((%_ClassOf(aa)==='ArrayBuffer')||(%_ClassOf(aa)==='SharedArrayBuffer')){
+Int32ArrayConstructByArrayBuffer(this,aa,ab,aC);
+}else if((typeof(aa)==='number')||(typeof(aa)==='string')||
+(typeof(aa)==='boolean')||(aa===(void 0))){
+Int32ArrayConstructByLength(this,aa);
+}else if((%_IsTypedArray(aa))){
+Int32ArrayConstructByTypedArray(this,aa);
+}else{
+var au=aa[L];
+if((au===(void 0))||au===e){
+Int32ArrayConstructByArrayLike(this,aa,aa.length);
+}else{
+Int32ArrayConstructByIterable(this,aa,au);
+}
+}
+}else{
+throw F(28,"Int32Array")
+}
+}
+function Int32ArraySubArray(aD,aE){
+var aF=(%_ToInteger(aD));
+if(!(aE===(void 0))){
+var aG=(%_ToInteger(aE));
+var aH=%_TypedArrayGetLength(this);
+}else{
+var aH=%_TypedArrayGetLength(this);
+var aG=aH;
+}
+if(aF<0){
+aF=G(0,aH+aF);
+}else{
+aF=H(aF,aH);
+}
+if(aG<0){
+aG=G(0,aH+aG);
+}else{
+aG=H(aG,aH);
+}
+if(aG<aF){
+aG=aF;
+}
+var an=aG-aF;
+var aI=
+%_ArrayBufferViewGetByteOffset(this)+aF*4;
+return new S(%TypedArrayGetBuffer(this),aI,an);
+}
+
+function Float32ArrayConstructByArrayBuffer(ag,ah,ai,aj){
+if(!(ai===(void 0))){
+ai=K(ai,179);
+}
+if(!(aj===(void 0))){
+aj=K(aj,179);
+}
+var ak=%_ArrayBufferGetByteLength(ah);
+var al;
+if((ai===(void 0))){
+al=0;
+}else{
+al=ai;
+if(al % 4!==0){
+throw E(178,
+"start offset","Float32Array",4);
+}
+if(al>ak){
+throw E(180);
+}
+}
+var am;
+var an;
+if((aj===(void 0))){
+if(ak % 4!==0){
+throw E(178,
+"byte length","Float32Array",4);
+}
+am=ak-al;
+an=am/4;
+}else{
+var an=aj;
+am=an*4;
+}
+if((al+am>ak)
+||(an>%_MaxSmi())){
+throw E(179);
+}
+%_TypedArrayInitialize(ag,7,ah,al,am,true);
+}
+function Float32ArrayConstructByLength(ag,aj){
+var ao=(aj===(void 0))?
+0:K(aj,179);
+if(ao>%_MaxSmi()){
+throw E(179);
+}
+var ap=ao*4;
+if(ap>%_TypedArrayMaxSizeInHeap()){
+var ah=new i(ap);
+%_TypedArrayInitialize(ag,7,ah,0,ap,true);
+}else{
+%_TypedArrayInitialize(ag,7,null,0,ap,true);
+}
+}
+function Float32ArrayConstructByArrayLike(ag,aq,aj){
+var ao=K(aj,179);
+if(ao>%_MaxSmi()){
+throw E(179);
+}
+var ar=false;
+var ap=ao*4;
+if(ap<=%_TypedArrayMaxSizeInHeap()){
+%_TypedArrayInitialize(ag,7,null,0,ap,false);
+}else{
+ar=
+%TypedArrayInitializeFromArrayLike(ag,7,aq,ao);
+}
+if(!ar){
+for(var as=0;as<ao;as++){
+ag[as]=aq[as];
+}
+}
+}
+function Float32ArrayConstructByIterable(ag,at,au){
+var av=new m();
+var aw=%_Call(au,at);
+var ax={
+__proto__:null
+};
+ax[L]=function(){return aw;}
+for(var ay of ax){
+av.push(ay);
+}
+Float32ArrayConstructByArrayLike(ag,av,av.length);
+}
+function Float32ArrayConstructByTypedArray(ag,X){
+var az=%TypedArrayGetBuffer(X);
+var aj=%_TypedArrayGetLength(X);
+var ap=%_ArrayBufferViewGetByteLength(X);
+var am=aj*4;
+Float32ArrayConstructByArrayLike(ag,X,aj);
+var aA=J(az,i);
+var aB=aA.prototype;
+if((%_IsJSReceiver(aB))&&aB!==j){
+%InternalSetPrototype(%TypedArrayGetBuffer(ag),aB);
+}
+}
+function Float32ArrayConstructor(aa,ab,aC){
+if(!(new.target===(void 0))){
+if((%_ClassOf(aa)==='ArrayBuffer')||(%_ClassOf(aa)==='SharedArrayBuffer')){
+Float32ArrayConstructByArrayBuffer(this,aa,ab,aC);
+}else if((typeof(aa)==='number')||(typeof(aa)==='string')||
+(typeof(aa)==='boolean')||(aa===(void 0))){
+Float32ArrayConstructByLength(this,aa);
+}else if((%_IsTypedArray(aa))){
+Float32ArrayConstructByTypedArray(this,aa);
+}else{
+var au=aa[L];
+if((au===(void 0))||au===e){
+Float32ArrayConstructByArrayLike(this,aa,aa.length);
+}else{
+Float32ArrayConstructByIterable(this,aa,au);
+}
+}
+}else{
+throw F(28,"Float32Array")
+}
+}
+function Float32ArraySubArray(aD,aE){
+var aF=(%_ToInteger(aD));
+if(!(aE===(void 0))){
+var aG=(%_ToInteger(aE));
+var aH=%_TypedArrayGetLength(this);
+}else{
+var aH=%_TypedArrayGetLength(this);
+var aG=aH;
+}
+if(aF<0){
+aF=G(0,aH+aF);
+}else{
+aF=H(aF,aH);
+}
+if(aG<0){
+aG=G(0,aH+aG);
+}else{
+aG=H(aG,aH);
+}
+if(aG<aF){
+aG=aF;
+}
+var an=aG-aF;
+var aI=
+%_ArrayBufferViewGetByteOffset(this)+aF*4;
+return new T(%TypedArrayGetBuffer(this),aI,an);
+}
+
+function Float64ArrayConstructByArrayBuffer(ag,ah,ai,aj){
+if(!(ai===(void 0))){
+ai=K(ai,179);
+}
+if(!(aj===(void 0))){
+aj=K(aj,179);
+}
+var ak=%_ArrayBufferGetByteLength(ah);
+var al;
+if((ai===(void 0))){
+al=0;
+}else{
+al=ai;
+if(al % 8!==0){
+throw E(178,
+"start offset","Float64Array",8);
+}
+if(al>ak){
+throw E(180);
+}
+}
+var am;
+var an;
+if((aj===(void 0))){
+if(ak % 8!==0){
+throw E(178,
+"byte length","Float64Array",8);
+}
+am=ak-al;
+an=am/8;
+}else{
+var an=aj;
+am=an*8;
+}
+if((al+am>ak)
+||(an>%_MaxSmi())){
+throw E(179);
+}
+%_TypedArrayInitialize(ag,8,ah,al,am,true);
+}
+function Float64ArrayConstructByLength(ag,aj){
+var ao=(aj===(void 0))?
+0:K(aj,179);
+if(ao>%_MaxSmi()){
+throw E(179);
+}
+var ap=ao*8;
+if(ap>%_TypedArrayMaxSizeInHeap()){
+var ah=new i(ap);
+%_TypedArrayInitialize(ag,8,ah,0,ap,true);
+}else{
+%_TypedArrayInitialize(ag,8,null,0,ap,true);
+}
+}
+function Float64ArrayConstructByArrayLike(ag,aq,aj){
+var ao=K(aj,179);
+if(ao>%_MaxSmi()){
+throw E(179);
+}
+var ar=false;
+var ap=ao*8;
+if(ap<=%_TypedArrayMaxSizeInHeap()){
+%_TypedArrayInitialize(ag,8,null,0,ap,false);
+}else{
+ar=
+%TypedArrayInitializeFromArrayLike(ag,8,aq,ao);
+}
+if(!ar){
+for(var as=0;as<ao;as++){
+ag[as]=aq[as];
+}
+}
+}
+function Float64ArrayConstructByIterable(ag,at,au){
+var av=new m();
+var aw=%_Call(au,at);
+var ax={
+__proto__:null
+};
+ax[L]=function(){return aw;}
+for(var ay of ax){
+av.push(ay);
+}
+Float64ArrayConstructByArrayLike(ag,av,av.length);
+}
+function Float64ArrayConstructByTypedArray(ag,X){
+var az=%TypedArrayGetBuffer(X);
+var aj=%_TypedArrayGetLength(X);
+var ap=%_ArrayBufferViewGetByteLength(X);
+var am=aj*8;
+Float64ArrayConstructByArrayLike(ag,X,aj);
+var aA=J(az,i);
+var aB=aA.prototype;
+if((%_IsJSReceiver(aB))&&aB!==j){
+%InternalSetPrototype(%TypedArrayGetBuffer(ag),aB);
+}
+}
+function Float64ArrayConstructor(aa,ab,aC){
+if(!(new.target===(void 0))){
+if((%_ClassOf(aa)==='ArrayBuffer')||(%_ClassOf(aa)==='SharedArrayBuffer')){
+Float64ArrayConstructByArrayBuffer(this,aa,ab,aC);
+}else if((typeof(aa)==='number')||(typeof(aa)==='string')||
+(typeof(aa)==='boolean')||(aa===(void 0))){
+Float64ArrayConstructByLength(this,aa);
+}else if((%_IsTypedArray(aa))){
+Float64ArrayConstructByTypedArray(this,aa);
+}else{
+var au=aa[L];
+if((au===(void 0))||au===e){
+Float64ArrayConstructByArrayLike(this,aa,aa.length);
+}else{
+Float64ArrayConstructByIterable(this,aa,au);
+}
+}
+}else{
+throw F(28,"Float64Array")
+}
+}
+function Float64ArraySubArray(aD,aE){
+var aF=(%_ToInteger(aD));
+if(!(aE===(void 0))){
+var aG=(%_ToInteger(aE));
+var aH=%_TypedArrayGetLength(this);
+}else{
+var aH=%_TypedArrayGetLength(this);
+var aG=aH;
+}
+if(aF<0){
+aF=G(0,aH+aF);
+}else{
+aF=H(aF,aH);
+}
+if(aG<0){
+aG=G(0,aH+aG);
+}else{
+aG=H(aG,aH);
+}
+if(aG<aF){
+aG=aF;
+}
+var an=aG-aF;
+var aI=
+%_ArrayBufferViewGetByteOffset(this)+aF*8;
+return new U(%TypedArrayGetBuffer(this),aI,an);
+}
+
+function Uint8ClampedArrayConstructByArrayBuffer(ag,ah,ai,aj){
+if(!(ai===(void 0))){
+ai=K(ai,179);
+}
+if(!(aj===(void 0))){
+aj=K(aj,179);
+}
+var ak=%_ArrayBufferGetByteLength(ah);
+var al;
+if((ai===(void 0))){
+al=0;
+}else{
+al=ai;
+if(al % 1!==0){
+throw E(178,
+"start offset","Uint8ClampedArray",1);
+}
+if(al>ak){
+throw E(180);
+}
+}
+var am;
+var an;
+if((aj===(void 0))){
+if(ak % 1!==0){
+throw E(178,
+"byte length","Uint8ClampedArray",1);
+}
+am=ak-al;
+an=am/1;
+}else{
+var an=aj;
+am=an*1;
+}
+if((al+am>ak)
+||(an>%_MaxSmi())){
+throw E(179);
+}
+%_TypedArrayInitialize(ag,9,ah,al,am,true);
+}
+function Uint8ClampedArrayConstructByLength(ag,aj){
+var ao=(aj===(void 0))?
+0:K(aj,179);
+if(ao>%_MaxSmi()){
+throw E(179);
+}
+var ap=ao*1;
+if(ap>%_TypedArrayMaxSizeInHeap()){
+var ah=new i(ap);
+%_TypedArrayInitialize(ag,9,ah,0,ap,true);
+}else{
+%_TypedArrayInitialize(ag,9,null,0,ap,true);
+}
+}
+function Uint8ClampedArrayConstructByArrayLike(ag,aq,aj){
+var ao=K(aj,179);
+if(ao>%_MaxSmi()){
+throw E(179);
+}
+var ar=false;
+var ap=ao*1;
+if(ap<=%_TypedArrayMaxSizeInHeap()){
+%_TypedArrayInitialize(ag,9,null,0,ap,false);
+}else{
+ar=
+%TypedArrayInitializeFromArrayLike(ag,9,aq,ao);
+}
+if(!ar){
+for(var as=0;as<ao;as++){
+ag[as]=aq[as];
+}
+}
+}
+function Uint8ClampedArrayConstructByIterable(ag,at,au){
+var av=new m();
+var aw=%_Call(au,at);
+var ax={
+__proto__:null
+};
+ax[L]=function(){return aw;}
+for(var ay of ax){
+av.push(ay);
+}
+Uint8ClampedArrayConstructByArrayLike(ag,av,av.length);
+}
+function Uint8ClampedArrayConstructByTypedArray(ag,X){
+var az=%TypedArrayGetBuffer(X);
+var aj=%_TypedArrayGetLength(X);
+var ap=%_ArrayBufferViewGetByteLength(X);
+var am=aj*1;
+Uint8ClampedArrayConstructByArrayLike(ag,X,aj);
+var aA=J(az,i);
+var aB=aA.prototype;
+if((%_IsJSReceiver(aB))&&aB!==j){
+%InternalSetPrototype(%TypedArrayGetBuffer(ag),aB);
+}
+}
+function Uint8ClampedArrayConstructor(aa,ab,aC){
+if(!(new.target===(void 0))){
+if((%_ClassOf(aa)==='ArrayBuffer')||(%_ClassOf(aa)==='SharedArrayBuffer')){
+Uint8ClampedArrayConstructByArrayBuffer(this,aa,ab,aC);
+}else if((typeof(aa)==='number')||(typeof(aa)==='string')||
+(typeof(aa)==='boolean')||(aa===(void 0))){
+Uint8ClampedArrayConstructByLength(this,aa);
+}else if((%_IsTypedArray(aa))){
+Uint8ClampedArrayConstructByTypedArray(this,aa);
+}else{
+var au=aa[L];
+if((au===(void 0))||au===e){
+Uint8ClampedArrayConstructByArrayLike(this,aa,aa.length);
+}else{
+Uint8ClampedArrayConstructByIterable(this,aa,au);
+}
+}
+}else{
+throw F(28,"Uint8ClampedArray")
+}
+}
+function Uint8ClampedArraySubArray(aD,aE){
+var aF=(%_ToInteger(aD));
+if(!(aE===(void 0))){
+var aG=(%_ToInteger(aE));
+var aH=%_TypedArrayGetLength(this);
+}else{
+var aH=%_TypedArrayGetLength(this);
+var aG=aH;
+}
+if(aF<0){
+aF=G(0,aH+aF);
+}else{
+aF=H(aF,aH);
+}
+if(aG<0){
+aG=G(0,aH+aG);
+}else{
+aG=H(aG,aH);
+}
+if(aG<aF){
+aG=aF;
+}
+var an=aG-aF;
+var aI=
+%_ArrayBufferViewGetByteOffset(this)+aF*1;
+return new V(%TypedArrayGetBuffer(this),aI,an);
+}
+
+
+function TypedArraySubArray(aD,aE){
+switch(%_ClassOf(this)){
+case"Uint8Array":
+return %_Call(Uint8ArraySubArray,this,aD,aE);
+
+case"Int8Array":
+return %_Call(Int8ArraySubArray,this,aD,aE);
+
+case"Uint16Array":
+return %_Call(Uint16ArraySubArray,this,aD,aE);
+
+case"Int16Array":
+return %_Call(Int16ArraySubArray,this,aD,aE);
+
+case"Uint32Array":
+return %_Call(Uint32ArraySubArray,this,aD,aE);
+
+case"Int32Array":
+return %_Call(Int32ArraySubArray,this,aD,aE);
+
+case"Float32Array":
+return %_Call(Float32ArraySubArray,this,aD,aE);
+
+case"Float64Array":
+return %_Call(Float64ArraySubArray,this,aD,aE);
+
+case"Uint8ClampedArray":
+return %_Call(Uint8ClampedArraySubArray,this,aD,aE);
+
+
+}
+throw F(44,
+"get TypedArray.prototype.subarray",this);
+}
+%SetForceInlineFlag(TypedArraySubArray);
+function TypedArrayGetBuffer(){
+if(!(%_IsTypedArray(this))){
+throw F(44,
+"get TypedArray.prototype.buffer",this);
+}
+return %TypedArrayGetBuffer(this);
+}
+%SetForceInlineFlag(TypedArrayGetBuffer);
+function TypedArrayGetByteLength(){
+if(!(%_IsTypedArray(this))){
+throw F(44,
+"get TypedArray.prototype.byteLength",this);
+}
+return %_ArrayBufferViewGetByteLength(this);
+}
+%SetForceInlineFlag(TypedArrayGetByteLength);
+function TypedArrayGetByteOffset(){
+if(!(%_IsTypedArray(this))){
+throw F(44,
+"get TypedArray.prototype.byteOffset",this);
+}
+return %_ArrayBufferViewGetByteOffset(this);
+}
+%SetForceInlineFlag(TypedArrayGetByteOffset);
+function TypedArrayGetLength(){
+if(!(%_IsTypedArray(this))){
+throw F(44,
+"get TypedArray.prototype.length",this);
+}
+return %_TypedArrayGetLength(this);
+}
+%SetForceInlineFlag(TypedArrayGetLength);
+function TypedArraySetFromArrayLike(aJ,aK,aL,al){
+if(al>0){
+for(var as=0;as<aL;as++){
+aJ[al+as]=aK[as];
+}
+}
+else{
+for(var as=0;as<aL;as++){
+aJ[as]=aK[as];
+}
+}
+}
+function TypedArraySetFromOverlappingTypedArray(aJ,aK,al){
+var aM=aK.BYTES_PER_ELEMENT;
+var aN=aJ.BYTES_PER_ELEMENT;
+var aL=aK.length;
+function CopyLeftPart(){
+var aO=aJ.byteOffset+(al+1)*aN;
+var aP=aK.byteOffset;
+for(var aQ=0;
+aQ<aL&&aO<=aP;
+aQ++){
+aJ[al+aQ]=aK[aQ];
+aO+=aN;
+aP+=aM;
+}
+return aQ;
+}
+var aQ=CopyLeftPart();
+function CopyRightPart(){
+var aO=
+aJ.byteOffset+(al+aL-1)*aN;
+var aP=
+aK.byteOffset+aL*aM;
+for(var aR=aL-1;
+aR>=aQ&&aO>=aP;
+aR--){
+aJ[al+aR]=aK[aR];
+aO-=aN;
+aP-=aM;
+}
+return aR;
+}
+var aR=CopyRightPart();
+var aS=new h(aR+1-aQ);
+for(var as=aQ;as<=aR;as++){
+aS[as-aQ]=aK[as];
+}
+for(as=aQ;as<=aR;as++){
+aJ[al+as]=aS[as-aQ];
+}
+}
+function TypedArraySet(ag,al){
+var aT=(al===(void 0))?0:(%_ToInteger(al));
+if(aT<0)throw F(189);
+if(aT>%_MaxSmi()){
+throw E(190);
+}
+switch(%TypedArraySetFastCases(this,ag,aT)){
+case 0:
+return;
+case 1:
+TypedArraySetFromOverlappingTypedArray(this,ag,aT);
+return;
+case 2:
+TypedArraySetFromArrayLike(this,ag,ag.length,aT);
+return;
+case 3:
+var ao=ag.length;
+if((ao===(void 0))){
+if((typeof(ag)==='number')){
+throw F(47);
+}
+return;
+}
+ao=(%_ToLength(ao));
+if(aT+ao>this.length){
+throw E(190);
+}
+TypedArraySetFromArrayLike(this,ag,ao,aT);
+return;
+}
+}
+%FunctionSetLength(TypedArraySet,1);
+function TypedArrayGetToStringTag(){
+if(!(%_IsTypedArray(this)))return;
+var aU=%_ClassOf(this);
+if((aU===(void 0)))return;
+return aU;
+}
+function TypedArrayCopyWithin(aJ,aV,aE){
+if(!(%_IsTypedArray(this)))throw F(72);
+var aj=%_TypedArrayGetLength(this);
+return n(aJ,aV,aE,this,aj);
+}
+%FunctionSetLength(TypedArrayCopyWithin,2);
+function TypedArrayEvery(aW,aX){
+if(!(%_IsTypedArray(this)))throw F(72);
+var aj=%_TypedArrayGetLength(this);
+return o(aW,aX,this,aj);
+}
+%FunctionSetLength(TypedArrayEvery,1);
+function TypedArrayForEach(aW,aX){
+if(!(%_IsTypedArray(this)))throw F(72);
+var aj=%_TypedArrayGetLength(this);
+t(aW,aX,this,aj);
+}
+%FunctionSetLength(TypedArrayForEach,1);
+function TypedArrayFill(ay,aV,aE){
+if(!(%_IsTypedArray(this)))throw F(72);
+var aj=%_TypedArrayGetLength(this);
+return p(ay,aV,aE,this,aj);
+}
+%FunctionSetLength(TypedArrayFill,1);
+function TypedArrayFilter(aW,aY){
+if(!(%_IsTypedArray(this)))throw F(72);
+var aj=%_TypedArrayGetLength(this);
+if(!(typeof(aW)==='function'))throw F(15,aW);
+var aZ=new m();
+q(aW,aY,this,aj,aZ);
+var ba=aZ.length;
+var bb=TypedArraySpeciesCreate(this,ba);
+for(var as=0;as<ba;as++){
+bb[as]=aZ[as];
+}
+return bb;
+}
+%FunctionSetLength(TypedArrayFilter,1);
+function TypedArrayFind(bc,aY){
+if(!(%_IsTypedArray(this)))throw F(72);
+var aj=%_TypedArrayGetLength(this);
+return r(bc,aY,this,aj);
+}
+%FunctionSetLength(TypedArrayFind,1);
+function TypedArrayFindIndex(bc,aY){
+if(!(%_IsTypedArray(this)))throw F(72);
+var aj=%_TypedArrayGetLength(this);
+return s(bc,aY,this,aj);
+}
+%FunctionSetLength(TypedArrayFindIndex,1);
+function TypedArrayReverse(){
+if(!(%_IsTypedArray(this)))throw F(72);
+var aj=%_TypedArrayGetLength(this);
+return I(this,aj);
+}
+function TypedArrayComparefn(bd,be){
+if(bd===0&&bd===be){
+bd=1/bd;
+be=1/be;
+}
+if(bd<be){
+return-1;
+}else if(bd>be){
+return 1;
+}else if(D(bd)&&D(be)){
+return D(be)?0:1;
+}else if(D(bd)){
+return 1;
+}
+return 0;
+}
+function TypedArraySort(bf){
+if(!(%_IsTypedArray(this)))throw F(72);
+var aj=%_TypedArrayGetLength(this);
+if((bf===(void 0))){
+bf=TypedArrayComparefn;
+}
+return B(this,aj,bf);
+}
+function TypedArrayIndexOf(bg,bh){
+if(!(%_IsTypedArray(this)))throw F(72);
+var aj=%_TypedArrayGetLength(this);
+return v(this,bg,bh,aj);
+}
+%FunctionSetLength(TypedArrayIndexOf,1);
+function TypedArrayLastIndexOf(bg,bh){
+if(!(%_IsTypedArray(this)))throw F(72);
+var aj=%_TypedArrayGetLength(this);
+return x(this,bg,bh,aj,
+arguments.length);
+}
+%FunctionSetLength(TypedArrayLastIndexOf,1);
+function TypedArrayMap(aW,aY){
+if(!(%_IsTypedArray(this)))throw F(72);
+var aj=%_TypedArrayGetLength(this);
+var aZ=TypedArraySpeciesCreate(this,aj);
+if(!(typeof(aW)==='function'))throw F(15,aW);
+for(var as=0;as<aj;as++){
+var bg=this[as];
+aZ[as]=%_Call(aW,aY,bg,as,this);
+}
+return aZ;
+}
+%FunctionSetLength(TypedArrayMap,1);
+function TypedArraySome(aW,aX){
+if(!(%_IsTypedArray(this)))throw F(72);
+var aj=%_TypedArrayGetLength(this);
+return A(aW,aX,this,aj);
+}
+%FunctionSetLength(TypedArraySome,1);
+function TypedArrayToLocaleString(){
+if(!(%_IsTypedArray(this)))throw F(72);
+var aj=%_TypedArrayGetLength(this);
+return C(this,aj);
+}
+function TypedArrayJoin(bi){
+if(!(%_IsTypedArray(this)))throw F(72);
+var aj=%_TypedArrayGetLength(this);
+return w(bi,this,aj);
+}
+function TypedArrayReduce(bj,bk){
+if(!(%_IsTypedArray(this)))throw F(72);
+var aj=%_TypedArrayGetLength(this);
+return y(bj,bk,this,aj,
+arguments.length);
+}
+%FunctionSetLength(TypedArrayReduce,1);
+function TypedArrayReduceRight(bj,bk){
+if(!(%_IsTypedArray(this)))throw F(72);
+var aj=%_TypedArrayGetLength(this);
+return z(bj,bk,this,aj,
+arguments.length);
+}
+%FunctionSetLength(TypedArrayReduceRight,1);
+function TypedArraySlice(aV,aE){
+if(!(%_IsTypedArray(this)))throw F(72);
+var bl=%_TypedArrayGetLength(this);
+var bm=(%_ToInteger(aV));
+var bn;
+if(bm<0){
+bn=G(bl+bm,0);
+}else{
+bn=H(bm,bl);
+}
+var bo;
+if((aE===(void 0))){
+bo=bl;
+}else{
+bo=(%_ToInteger(aE));
+}
+var bp;
+if(bo<0){
+bp=G(bl+bo,0);
+}else{
+bp=H(bo,bl);
+}
+var bq=G(bp-bn,0);
+var br=TypedArraySpeciesCreate(this,bq);
+var bs=0;
+while(bn<bp){
+var bt=this[bn];
+br[bs]=bt;
+bn++;
+bs++;
+}
+return br;
+}
+function TypedArrayIncludes(bu,bv){
+if(!(%_IsTypedArray(this)))throw F(72);
+var aj=%_TypedArrayGetLength(this);
+return u(bu,bv,this,aj);
+}
+%FunctionSetLength(TypedArrayIncludes,1);
+function TypedArrayOf(){
+var aj=arguments.length;
+var br=TypedArrayCreate(this,aj);
+for(var as=0;as<aj;as++){
+br[as]=arguments[as];
+}
+return br;
+}
+function IterableToArrayLike(bw){
+var at=g(bw,L);
+if(!(at===(void 0))){
+var bx=new m();
+var as=0;
+for(var ay of
+{[L](){return f(bw,at)}}){
+bx[as]=ay;
+as++;
+}
+var br=[];
+%MoveArrayContents(bx,br);
+return br;
+}
+return(%_ToObject(bw));
+}
+function TypedArrayFrom(aK,by,aY){
+if(!%IsConstructor(this))throw F(66,this);
+var bz;
+if(!(by===(void 0))){
+if(!(typeof(by)==='function'))throw F(15,this);
+bz=true;
+}else{
+bz=false;
+}
+var aq=IterableToArrayLike(aK);
+var aj=(%_ToLength(aq.length));
+var bA=TypedArrayCreate(this,aj);
+var ay,bB;
+for(var as=0;as<aj;as++){
+ay=aq[as];
+if(bz){
+bB=%_Call(by,aY,ay,as);
+}else{
+bB=ay;
+}
+bA[as]=bB;
+}
+return bA;
+}
+%FunctionSetLength(TypedArrayFrom,1);
+function TypedArray(){
+if((new.target===(void 0))){
+throw F(27,"TypedArray");
+}
+if(new.target===TypedArray){
+throw F(25,"TypedArray");
+}
+}
+%FunctionSetPrototype(TypedArray,new l());
+%AddNamedProperty(TypedArray.prototype,
+"constructor",TypedArray,2);
+b.InstallFunctions(TypedArray,2,[
+"from",TypedArrayFrom,
+"of",TypedArrayOf
+]);
+b.InstallGetter(TypedArray.prototype,"buffer",TypedArrayGetBuffer);
+b.InstallGetter(TypedArray.prototype,"byteOffset",TypedArrayGetByteOffset,
+2|4);
+b.InstallGetter(TypedArray.prototype,"byteLength",
+TypedArrayGetByteLength,2|4);
+b.InstallGetter(TypedArray.prototype,"length",TypedArrayGetLength,
+2|4);
+b.InstallGetter(TypedArray.prototype,M,
+TypedArrayGetToStringTag);
+b.InstallFunctions(TypedArray.prototype,2,[
+"subarray",TypedArraySubArray,
+"set",TypedArraySet,
+"copyWithin",TypedArrayCopyWithin,
+"every",TypedArrayEvery,
+"fill",TypedArrayFill,
+"filter",TypedArrayFilter,
+"find",TypedArrayFind,
+"findIndex",TypedArrayFindIndex,
+"includes",TypedArrayIncludes,
+"indexOf",TypedArrayIndexOf,
+"join",TypedArrayJoin,
+"lastIndexOf",TypedArrayLastIndexOf,
+"forEach",TypedArrayForEach,
+"map",TypedArrayMap,
+"reduce",TypedArrayReduce,
+"reduceRight",TypedArrayReduceRight,
+"reverse",TypedArrayReverse,
+"slice",TypedArraySlice,
+"some",TypedArraySome,
+"sort",TypedArraySort,
+"toLocaleString",TypedArrayToLocaleString
+]);
+%AddNamedProperty(TypedArray.prototype,"toString",d,
+2);
+%SetCode(N,Uint8ArrayConstructor);
+%FunctionSetPrototype(N,new l());
+%InternalSetPrototype(N,TypedArray);
+%InternalSetPrototype(N.prototype,TypedArray.prototype);
+%AddNamedProperty(N,"BYTES_PER_ELEMENT",1,
+1|2|4);
+%AddNamedProperty(N.prototype,
+"constructor",a.Uint8Array,2);
+%AddNamedProperty(N.prototype,
+"BYTES_PER_ELEMENT",1,
+1|2|4);
+
+%SetCode(O,Int8ArrayConstructor);
+%FunctionSetPrototype(O,new l());
+%InternalSetPrototype(O,TypedArray);
+%InternalSetPrototype(O.prototype,TypedArray.prototype);
+%AddNamedProperty(O,"BYTES_PER_ELEMENT",1,
+1|2|4);
+%AddNamedProperty(O.prototype,
+"constructor",a.Int8Array,2);
+%AddNamedProperty(O.prototype,
+"BYTES_PER_ELEMENT",1,
+1|2|4);
+
+%SetCode(P,Uint16ArrayConstructor);
+%FunctionSetPrototype(P,new l());
+%InternalSetPrototype(P,TypedArray);
+%InternalSetPrototype(P.prototype,TypedArray.prototype);
+%AddNamedProperty(P,"BYTES_PER_ELEMENT",2,
+1|2|4);
+%AddNamedProperty(P.prototype,
+"constructor",a.Uint16Array,2);
+%AddNamedProperty(P.prototype,
+"BYTES_PER_ELEMENT",2,
+1|2|4);
+
+%SetCode(Q,Int16ArrayConstructor);
+%FunctionSetPrototype(Q,new l());
+%InternalSetPrototype(Q,TypedArray);
+%InternalSetPrototype(Q.prototype,TypedArray.prototype);
+%AddNamedProperty(Q,"BYTES_PER_ELEMENT",2,
+1|2|4);
+%AddNamedProperty(Q.prototype,
+"constructor",a.Int16Array,2);
+%AddNamedProperty(Q.prototype,
+"BYTES_PER_ELEMENT",2,
+1|2|4);
+
+%SetCode(R,Uint32ArrayConstructor);
+%FunctionSetPrototype(R,new l());
+%InternalSetPrototype(R,TypedArray);
+%InternalSetPrototype(R.prototype,TypedArray.prototype);
+%AddNamedProperty(R,"BYTES_PER_ELEMENT",4,
+1|2|4);
+%AddNamedProperty(R.prototype,
+"constructor",a.Uint32Array,2);
+%AddNamedProperty(R.prototype,
+"BYTES_PER_ELEMENT",4,
+1|2|4);
+
+%SetCode(S,Int32ArrayConstructor);
+%FunctionSetPrototype(S,new l());
+%InternalSetPrototype(S,TypedArray);
+%InternalSetPrototype(S.prototype,TypedArray.prototype);
+%AddNamedProperty(S,"BYTES_PER_ELEMENT",4,
+1|2|4);
+%AddNamedProperty(S.prototype,
+"constructor",a.Int32Array,2);
+%AddNamedProperty(S.prototype,
+"BYTES_PER_ELEMENT",4,
+1|2|4);
+
+%SetCode(T,Float32ArrayConstructor);
+%FunctionSetPrototype(T,new l());
+%InternalSetPrototype(T,TypedArray);
+%InternalSetPrototype(T.prototype,TypedArray.prototype);
+%AddNamedProperty(T,"BYTES_PER_ELEMENT",4,
+1|2|4);
+%AddNamedProperty(T.prototype,
+"constructor",a.Float32Array,2);
+%AddNamedProperty(T.prototype,
+"BYTES_PER_ELEMENT",4,
+1|2|4);
+
+%SetCode(U,Float64ArrayConstructor);
+%FunctionSetPrototype(U,new l());
+%InternalSetPrototype(U,TypedArray);
+%InternalSetPrototype(U.prototype,TypedArray.prototype);
+%AddNamedProperty(U,"BYTES_PER_ELEMENT",8,
+1|2|4);
+%AddNamedProperty(U.prototype,
+"constructor",a.Float64Array,2);
+%AddNamedProperty(U.prototype,
+"BYTES_PER_ELEMENT",8,
+1|2|4);
+
+%SetCode(V,Uint8ClampedArrayConstructor);
+%FunctionSetPrototype(V,new l());
+%InternalSetPrototype(V,TypedArray);
+%InternalSetPrototype(V.prototype,TypedArray.prototype);
+%AddNamedProperty(V,"BYTES_PER_ELEMENT",1,
+1|2|4);
+%AddNamedProperty(V.prototype,
+"constructor",a.Uint8ClampedArray,2);
+%AddNamedProperty(V.prototype,
+"BYTES_PER_ELEMENT",1,
+1|2|4);
+
+
+function DataViewGetBufferJS(){
+if(!(%_ClassOf(this)==='DataView')){
+throw F(44,'DataView.buffer',this);
+}
+return %DataViewGetBuffer(this);
+}
+function DataViewGetByteOffset(){
+if(!(%_ClassOf(this)==='DataView')){
+throw F(44,
+'DataView.byteOffset',this);
+}
+return %_ArrayBufferViewGetByteOffset(this);
+}
+function DataViewGetByteLength(){
+if(!(%_ClassOf(this)==='DataView')){
+throw F(44,
+'DataView.byteLength',this);
+}
+return %_ArrayBufferViewGetByteLength(this);
+}
+function DataViewGetInt8JS(al,bC){
+if(!(%_ClassOf(this)==='DataView')){
+throw F(44,
+'DataView.getInt8',this);
+}
+if(arguments.length<1)throw F(47);
+al=K(al,169);
+return %DataViewGetInt8(this,al,!!bC);
+}
+%FunctionSetLength(DataViewGetInt8JS,1);
+function DataViewSetInt8JS(al,ay,bC){
+if(!(%_ClassOf(this)==='DataView')){
+throw F(44,
+'DataView.setInt8',this);
+}
+if(arguments.length<2)throw F(47);
+al=K(al,169);
+%DataViewSetInt8(this,al,(%_ToNumber(ay)),!!bC);
+}
+%FunctionSetLength(DataViewSetInt8JS,2);
+
+function DataViewGetUint8JS(al,bC){
+if(!(%_ClassOf(this)==='DataView')){
+throw F(44,
+'DataView.getUint8',this);
+}
+if(arguments.length<1)throw F(47);
+al=K(al,169);
+return %DataViewGetUint8(this,al,!!bC);
+}
+%FunctionSetLength(DataViewGetUint8JS,1);
+function DataViewSetUint8JS(al,ay,bC){
+if(!(%_ClassOf(this)==='DataView')){
+throw F(44,
+'DataView.setUint8',this);
+}
+if(arguments.length<2)throw F(47);
+al=K(al,169);
+%DataViewSetUint8(this,al,(%_ToNumber(ay)),!!bC);
+}
+%FunctionSetLength(DataViewSetUint8JS,2);
+
+function DataViewGetInt16JS(al,bC){
+if(!(%_ClassOf(this)==='DataView')){
+throw F(44,
+'DataView.getInt16',this);
+}
+if(arguments.length<1)throw F(47);
+al=K(al,169);
+return %DataViewGetInt16(this,al,!!bC);
+}
+%FunctionSetLength(DataViewGetInt16JS,1);
+function DataViewSetInt16JS(al,ay,bC){
+if(!(%_ClassOf(this)==='DataView')){
+throw F(44,
+'DataView.setInt16',this);
+}
+if(arguments.length<2)throw F(47);
+al=K(al,169);
+%DataViewSetInt16(this,al,(%_ToNumber(ay)),!!bC);
+}
+%FunctionSetLength(DataViewSetInt16JS,2);
+
+function DataViewGetUint16JS(al,bC){
+if(!(%_ClassOf(this)==='DataView')){
+throw F(44,
+'DataView.getUint16',this);
+}
+if(arguments.length<1)throw F(47);
+al=K(al,169);
+return %DataViewGetUint16(this,al,!!bC);
+}
+%FunctionSetLength(DataViewGetUint16JS,1);
+function DataViewSetUint16JS(al,ay,bC){
+if(!(%_ClassOf(this)==='DataView')){
+throw F(44,
+'DataView.setUint16',this);
+}
+if(arguments.length<2)throw F(47);
+al=K(al,169);
+%DataViewSetUint16(this,al,(%_ToNumber(ay)),!!bC);
+}
+%FunctionSetLength(DataViewSetUint16JS,2);
+
+function DataViewGetInt32JS(al,bC){
+if(!(%_ClassOf(this)==='DataView')){
+throw F(44,
+'DataView.getInt32',this);
+}
+if(arguments.length<1)throw F(47);
+al=K(al,169);
+return %DataViewGetInt32(this,al,!!bC);
+}
+%FunctionSetLength(DataViewGetInt32JS,1);
+function DataViewSetInt32JS(al,ay,bC){
+if(!(%_ClassOf(this)==='DataView')){
+throw F(44,
+'DataView.setInt32',this);
+}
+if(arguments.length<2)throw F(47);
+al=K(al,169);
+%DataViewSetInt32(this,al,(%_ToNumber(ay)),!!bC);
+}
+%FunctionSetLength(DataViewSetInt32JS,2);
+
+function DataViewGetUint32JS(al,bC){
+if(!(%_ClassOf(this)==='DataView')){
+throw F(44,
+'DataView.getUint32',this);
+}
+if(arguments.length<1)throw F(47);
+al=K(al,169);
+return %DataViewGetUint32(this,al,!!bC);
+}
+%FunctionSetLength(DataViewGetUint32JS,1);
+function DataViewSetUint32JS(al,ay,bC){
+if(!(%_ClassOf(this)==='DataView')){
+throw F(44,
+'DataView.setUint32',this);
+}
+if(arguments.length<2)throw F(47);
+al=K(al,169);
+%DataViewSetUint32(this,al,(%_ToNumber(ay)),!!bC);
+}
+%FunctionSetLength(DataViewSetUint32JS,2);
+
+function DataViewGetFloat32JS(al,bC){
+if(!(%_ClassOf(this)==='DataView')){
+throw F(44,
+'DataView.getFloat32',this);
+}
+if(arguments.length<1)throw F(47);
+al=K(al,169);
+return %DataViewGetFloat32(this,al,!!bC);
+}
+%FunctionSetLength(DataViewGetFloat32JS,1);
+function DataViewSetFloat32JS(al,ay,bC){
+if(!(%_ClassOf(this)==='DataView')){
+throw F(44,
+'DataView.setFloat32',this);
+}
+if(arguments.length<2)throw F(47);
+al=K(al,169);
+%DataViewSetFloat32(this,al,(%_ToNumber(ay)),!!bC);
+}
+%FunctionSetLength(DataViewSetFloat32JS,2);
+
+function DataViewGetFloat64JS(al,bC){
+if(!(%_ClassOf(this)==='DataView')){
+throw F(44,
+'DataView.getFloat64',this);
+}
+if(arguments.length<1)throw F(47);
+al=K(al,169);
+return %DataViewGetFloat64(this,al,!!bC);
+}
+%FunctionSetLength(DataViewGetFloat64JS,1);
+function DataViewSetFloat64JS(al,ay,bC){
+if(!(%_ClassOf(this)==='DataView')){
+throw F(44,
+'DataView.setFloat64',this);
+}
+if(arguments.length<2)throw F(47);
+al=K(al,169);
+%DataViewSetFloat64(this,al,(%_ToNumber(ay)),!!bC);
+}
+%FunctionSetLength(DataViewSetFloat64JS,2);
+
+
+%FunctionSetPrototype(k,new l);
+%AddNamedProperty(k.prototype,"constructor",k,
+2);
+%AddNamedProperty(k.prototype,M,"DataView",
+1|2);
+b.InstallGetter(k.prototype,"buffer",DataViewGetBufferJS);
+b.InstallGetter(k.prototype,"byteOffset",
+DataViewGetByteOffset);
+b.InstallGetter(k.prototype,"byteLength",
+DataViewGetByteLength);
+b.InstallFunctions(k.prototype,2,[
+"getInt8",DataViewGetInt8JS,
+"setInt8",DataViewSetInt8JS,
+"getUint8",DataViewGetUint8JS,
+"setUint8",DataViewSetUint8JS,
+"getInt16",DataViewGetInt16JS,
+"setInt16",DataViewSetInt16JS,
+"getUint16",DataViewGetUint16JS,
+"setUint16",DataViewSetUint16JS,
+"getInt32",DataViewGetInt32JS,
+"setInt32",DataViewSetInt32JS,
+"getUint32",DataViewGetUint32JS,
+"setUint32",DataViewSetUint32JS,
+"getFloat32",DataViewGetFloat32JS,
+"setFloat32",DataViewSetFloat32JS,
+"getFloat64",DataViewGetFloat64JS,
+"setFloat64",DataViewSetFloat64JS
+]);
+})
+
+Hiterator-prototype�
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Object;
+var d=b.ImportNow("IteratorPrototype");
+var e=b.ImportNow("iterator_symbol");
+function IteratorPrototypeIterator(){
+return this;
+}
+b.SetFunctionName(IteratorPrototypeIterator,e);
+%AddNamedProperty(d,e,
+IteratorPrototypeIterator,2);
+})
+
+$generator

+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=b.ImportNow("GeneratorFunctionPrototype");
+var d=b.ImportNow("GeneratorFunction");
+var e=a.Function;
+var f;
+var g=b.ImportNow("to_string_tag_symbol");
+b.Import(function(h){
+f=h.MakeTypeError;
+});
+function GeneratorObjectNext(i){
+if(!(%_ClassOf(this)==='Generator')){
+throw f(44,
+'[Generator].prototype.next',this);
+}
+var j=%GeneratorGetContinuation(this);
+if(j>0){
+if(%_DebugIsActive()!=0)%DebugPrepareStepInIfStepping(this);
+return %_GeneratorNext(this,i);
+}else if(j==0){
+return %_CreateIterResultObject((void 0),true);
+}else{
+throw f(42);
+}
+}
+function GeneratorObjectReturn(i){
+if(!(%_ClassOf(this)==='Generator')){
+throw f(44,
+'[Generator].prototype.return',this);
+}
+var j=%GeneratorGetContinuation(this);
+if(j>0){
+if(%_DebugIsActive()!=0)%DebugPrepareStepInIfStepping(this);
+return %_GeneratorReturn(this,i);
+}else if(j==0){
+return %_CreateIterResultObject(i,true);
+}else{
+throw f(42);
+}
+}
+function GeneratorObjectThrow(k){
+if(!(%_ClassOf(this)==='Generator')){
+throw f(44,
+'[Generator].prototype.throw',this);
+}
+var j=%GeneratorGetContinuation(this);
+if(j>0){
+if(%_DebugIsActive()!=0)%DebugPrepareStepInIfStepping(this);
+return %_GeneratorThrow(this,k);
+}else if(j==0){
+throw k;
+}else{
+throw f(42);
+}
+}
+%NeverOptimizeFunction(GeneratorObjectNext);
+%NeverOptimizeFunction(GeneratorObjectReturn);
+%NeverOptimizeFunction(GeneratorObjectThrow);
+var l=c.prototype;
+b.InstallFunctions(l,
+2,
+["next",GeneratorObjectNext,
+"return",GeneratorObjectReturn,
+"throw",GeneratorObjectThrow]);
+%AddNamedProperty(l,"constructor",
+c,2|1);
+%AddNamedProperty(l,
+g,"Generator",2|1);
+%InternalSetPrototype(c,e.prototype);
+%AddNamedProperty(c,
+g,"GeneratorFunction",2|1);
+%AddNamedProperty(c,"constructor",
+d,2|1);
+%InternalSetPrototype(d,e);
+})
+
+8object-observeѭ
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c;
+var d=a.Array;
+var e=a.Object;
+var f=b.InternalArray;
+var g;
+b.Import(function(h){
+c=h.GetHash;
+g=h.MakeTypeError;
+});
+var i;
+var j={};
+function GetObservationStateJS(){
+if((i===(void 0))){
+i=%GetObservationState();
+}
+if((i.callbackInfoMap===(void 0))){
+i.callbackInfoMap=%ObservationWeakMapCreate();
+i.objectInfoMap=%ObservationWeakMapCreate();
+i.notifierObjectInfoMap=%ObservationWeakMapCreate();
+i.pendingObservers=null;
+i.nextCallbackPriority=0;
+i.lastMicrotaskId=0;
+}
+return i;
+}
+function GetPendingObservers(){
+return GetObservationStateJS().pendingObservers;
+}
+function SetPendingObservers(k){
+GetObservationStateJS().pendingObservers=k;
+}
+function GetNextCallbackPriority(){
+return GetObservationStateJS().nextCallbackPriority++;
+}
+function nullProtoObject(){
+return{__proto__:null};
+}
+function TypeMapCreate(){
+return nullProtoObject();
+}
+function TypeMapAddType(l,m,n){
+l[m]=n?1:(l[m]||0)+1;
+}
+function TypeMapRemoveType(l,m){
+l[m]--;
+}
+function TypeMapCreateFromList(o,p){
+var l=TypeMapCreate();
+for(var q=0;q<p;q++){
+TypeMapAddType(l,o[q],true);
+}
+return l;
+}
+function TypeMapHasType(l,m){
+return!!l[m];
+}
+function TypeMapIsDisjointFrom(r,s){
+if(!r||!s)
+return true;
+for(var m in r){
+if(TypeMapHasType(r,m)&&TypeMapHasType(s,m))
+return false;
+}
+return true;
+}
+var t=(function(){
+var u=[
+'add',
+'update',
+'delete',
+'setPrototype',
+'reconfigure',
+'preventExtensions'
+];
+return TypeMapCreateFromList(u,u.length);
+})();
+function ObserverCreate(v,w){
+if((w===(void 0)))
+return v;
+var x=nullProtoObject();
+x.callback=v;
+x.accept=w;
+return x;
+}
+function ObserverGetCallback(x){
+return(typeof(x)==='function')?x:x.callback;
+}
+function ObserverGetAcceptTypes(x){
+return(typeof(x)==='function')?t:x.accept;
+}
+function ObserverIsActive(x,y){
+return TypeMapIsDisjointFrom(ObjectInfoGetPerformingTypes(y),
+ObserverGetAcceptTypes(x));
+}
+function ObjectInfoGetOrCreate(z){
+var y=ObjectInfoGet(z);
+if((y===(void 0))){
+if(!(%_IsJSProxy(z))){
+%SetIsObserved(z);
+}
+y={
+object:z,
+changeObservers:null,
+notifier:null,
+performing:null,
+performingCount:0,
+};
+%WeakCollectionSet(GetObservationStateJS().objectInfoMap,
+z,y,c(z));
+}
+return y;
+}
+function ObjectInfoGet(z){
+return %WeakCollectionGet(GetObservationStateJS().objectInfoMap,z,
+c(z));
+}
+function ObjectInfoGetFromNotifier(A){
+return %WeakCollectionGet(GetObservationStateJS().notifierObjectInfoMap,
+A,c(A));
+}
+function ObjectInfoGetNotifier(y){
+if((y.notifier===null)){
+var A={__proto__:j};
+y.notifier=A;
+%WeakCollectionSet(GetObservationStateJS().notifierObjectInfoMap,
+A,y,c(A));
+}
+return y.notifier;
+}
+function ChangeObserversIsOptimized(B){
+return(typeof(B)==='function')||
+(typeof(B.callback)==='function');
+}
+function ObjectInfoNormalizeChangeObservers(y){
+if(ChangeObserversIsOptimized(y.changeObservers)){
+var x=y.changeObservers;
+var v=ObserverGetCallback(x);
+var C=CallbackInfoGet(v);
+var D=CallbackInfoGetPriority(C);
+y.changeObservers=nullProtoObject();
+y.changeObservers[D]=x;
+}
+}
+function ObjectInfoAddObserver(y,v,w){
+var C=CallbackInfoGetOrCreate(v);
+var x=ObserverCreate(v,w);
+if(!y.changeObservers){
+y.changeObservers=x;
+return;
+}
+ObjectInfoNormalizeChangeObservers(y);
+var D=CallbackInfoGetPriority(C);
+y.changeObservers[D]=x;
+}
+function ObjectInfoRemoveObserver(y,v){
+if(!y.changeObservers)
+return;
+if(ChangeObserversIsOptimized(y.changeObservers)){
+if(v===ObserverGetCallback(y.changeObservers))
+y.changeObservers=null;
+return;
+}
+var C=CallbackInfoGet(v);
+var D=CallbackInfoGetPriority(C);
+y.changeObservers[D]=null;
+}
+function ObjectInfoHasActiveObservers(y){
+if((y===(void 0))||!y.changeObservers)
+return false;
+if(ChangeObserversIsOptimized(y.changeObservers))
+return ObserverIsActive(y.changeObservers,y);
+for(var D in y.changeObservers){
+var x=y.changeObservers[D];
+if(!(x===null)&&ObserverIsActive(x,y))
+return true;
+}
+return false;
+}
+function ObjectInfoAddPerformingType(y,m){
+y.performing=y.performing||TypeMapCreate();
+TypeMapAddType(y.performing,m);
+y.performingCount++;
+}
+function ObjectInfoRemovePerformingType(y,m){
+y.performingCount--;
+TypeMapRemoveType(y.performing,m);
+}
+function ObjectInfoGetPerformingTypes(y){
+return y.performingCount>0?y.performing:null;
+}
+function ConvertAcceptListToTypeMap(E){
+if((E===(void 0)))
+return E;
+if(!(%_IsJSReceiver(E)))throw g(84);
+var F=(%_ToInteger(E.length));
+if(F<0)F=0;
+return TypeMapCreateFromList(E,F);
+}
+function CallbackInfoGet(v){
+return %WeakCollectionGet(GetObservationStateJS().callbackInfoMap,v,
+c(v));
+}
+function CallbackInfoSet(v,C){
+%WeakCollectionSet(GetObservationStateJS().callbackInfoMap,
+v,C,c(v));
+}
+function CallbackInfoGetOrCreate(v){
+var C=CallbackInfoGet(v);
+if(!(C===(void 0)))
+return C;
+var D=GetNextCallbackPriority();
+CallbackInfoSet(v,D);
+return D;
+}
+function CallbackInfoGetPriority(C){
+if((typeof(C)==='number'))
+return C;
+else
+return C.priority;
+}
+function CallbackInfoNormalize(v){
+var C=CallbackInfoGet(v);
+if((typeof(C)==='number')){
+var D=C;
+C=new f;
+C.priority=D;
+CallbackInfoSet(v,C);
+}
+return C;
+}
+function ObjectObserve(z,v,w){
+if(!(%_IsJSReceiver(z)))
+throw g(86,"observe","observe");
+if(%IsJSGlobalProxy(z))
+throw g(82,"observe");
+if(%IsAccessCheckNeeded(z))
+throw g(83,"observe");
+if(!(typeof(v)==='function'))
+throw g(85,"observe");
+if(%object_is_frozen(v))
+throw g(81);
+var G=%GetObjectContextObjectObserve(z);
+return G(z,v,w);
+}
+function NativeObjectObserve(z,v,w){
+var y=ObjectInfoGetOrCreate(z);
+var o=ConvertAcceptListToTypeMap(w);
+ObjectInfoAddObserver(y,v,o);
+return z;
+}
+function ObjectUnobserve(z,v){
+if(!(%_IsJSReceiver(z)))
+throw g(86,"unobserve","unobserve");
+if(%IsJSGlobalProxy(z))
+throw g(82,"unobserve");
+if(!(typeof(v)==='function'))
+throw g(85,"unobserve");
+var y=ObjectInfoGet(z);
+if((y===(void 0)))
+return z;
+ObjectInfoRemoveObserver(y,v);
+return z;
+}
+function ArrayObserve(z,v){
+return ObjectObserve(z,v,['add',
+'update',
+'delete',
+'splice']);
+}
+function ArrayUnobserve(z,v){
+return ObjectUnobserve(z,v);
+}
+function ObserverEnqueueIfActive(x,y,H){
+if(!ObserverIsActive(x,y)||
+!TypeMapHasType(ObserverGetAcceptTypes(x),H.type)){
+return;
+}
+var v=ObserverGetCallback(x);
+if(!%ObserverObjectAndRecordHaveSameOrigin(v,H.object,
+H)){
+return;
+}
+var C=CallbackInfoNormalize(v);
+if((GetPendingObservers()===null)){
+SetPendingObservers(nullProtoObject());
+if((%_DebugIsActive()!=0)){
+var I=++GetObservationStateJS().lastMicrotaskId;
+var J="Object.observe";
+%EnqueueMicrotask(function(){
+%DebugAsyncTaskEvent({type:"willHandle",id:I,name:J});
+ObserveMicrotaskRunner();
+%DebugAsyncTaskEvent({type:"didHandle",id:I,name:J});
+});
+%DebugAsyncTaskEvent({type:"enqueue",id:I,name:J});
+}else{
+%EnqueueMicrotask(ObserveMicrotaskRunner);
+}
+}
+GetPendingObservers()[C.priority]=v;
+C.push(H);
+}
+function ObjectInfoEnqueueExternalChangeRecord(y,H,m){
+if(!ObjectInfoHasActiveObservers(y))
+return;
+var K=!(m===(void 0));
+var L=K?
+{object:y.object,type:m}:
+{object:y.object};
+for(var M in H){
+if(M==='object'||(K&&M==='type'))continue;
+%DefineDataPropertyUnchecked(
+L,M,H[M],1+4);
+}
+%object_freeze(L);
+ObjectInfoEnqueueInternalChangeRecord(y,L);
+}
+function ObjectInfoEnqueueInternalChangeRecord(y,H){
+if((typeof(H.name)==='symbol'))return;
+if(ChangeObserversIsOptimized(y.changeObservers)){
+var x=y.changeObservers;
+ObserverEnqueueIfActive(x,y,H);
+return;
+}
+for(var D in y.changeObservers){
+var x=y.changeObservers[D];
+if((x===null))
+continue;
+ObserverEnqueueIfActive(x,y,H);
+}
+}
+function BeginPerformSplice(N){
+var y=ObjectInfoGet(N);
+if(!(y===(void 0)))
+ObjectInfoAddPerformingType(y,'splice');
+}
+function EndPerformSplice(N){
+var y=ObjectInfoGet(N);
+if(!(y===(void 0)))
+ObjectInfoRemovePerformingType(y,'splice');
+}
+function EnqueueSpliceRecord(N,O,P,Q){
+var y=ObjectInfoGet(N);
+if(!ObjectInfoHasActiveObservers(y))
+return;
+var H={
+type:'splice',
+object:N,
+index:O,
+removed:P,
+addedCount:Q
+};
+%object_freeze(H);
+%object_freeze(H.removed);
+ObjectInfoEnqueueInternalChangeRecord(y,H);
+}
+function NotifyChange(m,z,J,R){
+var y=ObjectInfoGet(z);
+if(!ObjectInfoHasActiveObservers(y))
+return;
+var H;
+if(arguments.length==2){
+H={type:m,object:z};
+}else if(arguments.length==3){
+H={type:m,object:z,name:J};
+}else{
+H={
+type:m,
+object:z,
+name:J,
+oldValue:R
+};
+}
+%object_freeze(H);
+ObjectInfoEnqueueInternalChangeRecord(y,H);
+}
+function ObjectNotifierNotify(H){
+if(!(%_IsJSReceiver(this)))
+throw g(17,"notify");
+var y=ObjectInfoGetFromNotifier(this);
+if((y===(void 0)))
+throw g(87);
+if(!(typeof(H.type)==='string'))
+throw g(90);
+ObjectInfoEnqueueExternalChangeRecord(y,H);
+}
+function ObjectNotifierPerformChange(S,T){
+if(!(%_IsJSReceiver(this)))
+throw g(17,"performChange");
+var y=ObjectInfoGetFromNotifier(this);
+if((y===(void 0)))
+throw g(87);
+if(!(typeof(S)==='string'))
+throw g(89);
+if(!(typeof(T)==='function'))
+throw g(88);
+var U=%GetObjectContextNotifierPerformChange(y);
+U(y,S,T);
+}
+function NativeObjectNotifierPerformChange(y,S,T){
+ObjectInfoAddPerformingType(y,S);
+var H;
+try{
+H=T();
+}finally{
+ObjectInfoRemovePerformingType(y,S);
+}
+if((%_IsJSReceiver(H)))
+ObjectInfoEnqueueExternalChangeRecord(y,H,S);
+}
+function ObjectGetNotifier(z){
+if(!(%_IsJSReceiver(z)))
+throw g(86,"getNotifier","getNotifier");
+if(%IsJSGlobalProxy(z))
+throw g(82,"getNotifier");
+if(%IsAccessCheckNeeded(z))
+throw g(83,"getNotifier");
+if(%object_is_frozen(z))return null;
+if(!%ObjectWasCreatedInCurrentOrigin(z))return null;
+var V=%GetObjectContextObjectGetNotifier(z);
+return V(z);
+}
+function NativeObjectGetNotifier(z){
+var y=ObjectInfoGetOrCreate(z);
+return ObjectInfoGetNotifier(y);
+}
+function CallbackDeliverPending(v){
+var C=CallbackInfoGet(v);
+if((C===(void 0))||(typeof(C)==='number'))
+return false;
+var D=C.priority;
+CallbackInfoSet(v,D);
+var k=GetPendingObservers();
+if(!(k===null))
+delete k[D];
+var W=[];
+%MoveArrayContents(C,W);
+%DeliverObservationChangeRecords(v,W);
+return true;
+}
+function ObjectDeliverChangeRecords(v){
+if(!(typeof(v)==='function'))
+throw g(85,"deliverChangeRecords");
+while(CallbackDeliverPending(v)){}
+}
+function ObserveMicrotaskRunner(){
+var k=GetPendingObservers();
+if(!(k===null)){
+SetPendingObservers(null);
+for(var q in k){
+CallbackDeliverPending(k[q]);
+}
+}
+}
+b.InstallFunctions(j,2,[
+"notify",ObjectNotifierNotify,
+"performChange",ObjectNotifierPerformChange
+]);
+var X=[
+"deliverChangeRecords",ObjectDeliverChangeRecords,
+"getNotifier",ObjectGetNotifier,
+"observe",ObjectObserve,
+"unobserve",ObjectUnobserve
+];
+var Y=[
+"observe",ArrayObserve,
+"unobserve",ArrayUnobserve
+];
+var Z=function(aa,q){
+if(q % 2===1)%FunctionRemovePrototype(aa);
+};
+X.forEach(Z);
+Y.forEach(Z);
+%InstallToContext([
+"native_object_get_notifier",NativeObjectGetNotifier,
+"native_object_notifier_perform_change",NativeObjectNotifierPerformChange,
+"native_object_observe",NativeObjectObserve,
+"observers_begin_perform_splice",BeginPerformSplice,
+"observers_end_perform_splice",EndPerformSplice,
+"observers_enqueue_splice",EnqueueSpliceRecord,
+"observers_notify_change",NotifyChange,
+]);
+b.Export(function(ab){
+ab.ObserveArrayMethods=Y;
+ab.ObserveBeginPerformSplice=BeginPerformSplice;
+ab.ObserveEndPerformSplice=EndPerformSplice;
+ab.ObserveEnqueueSpliceRecord=EnqueueSpliceRecord;
+ab.ObserveObjectMethods=X;
+});
+})
+
+(collectionE}
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Map;
+var d=a.Object;
+var e=a.Set;
+var f=b.ImportNow("hash_code_symbol");
+var g;
+var h;
+var i;
+var j;
+var k;
+var l=b.ImportNow("to_string_tag_symbol");
+b.Import(function(m){
+g=m.IntRandom;
+h=m.MakeTypeError;
+i=m.MapIterator;
+j=m.NumberIsNaN;
+k=m.SetIterator;
+});
+function HashToEntry(n,o,p){
+var q=(o&((p)-1));
+return((%_FixedArrayGet(n,(3+(q))|0)));
+}
+%SetForceInlineFlag(HashToEntry);
+function SetFindEntry(n,p,r,o){
+var s=HashToEntry(n,o,p);
+if(s===-1)return s;
+var t=((%_FixedArrayGet(n,((3+(p)+((s)<<1)))|0)));
+if(r===t)return s;
+var u=j(r);
+while(true){
+if(u&&j(t)){
+return s;
+}
+s=((%_FixedArrayGet(n,((3+(p)+((s)<<1))+1)|0)));
+if(s===-1)return s;
+t=((%_FixedArrayGet(n,((3+(p)+((s)<<1)))|0)));
+if(r===t)return s;
+}
+return-1;
+}
+%SetForceInlineFlag(SetFindEntry);
+function MapFindEntry(n,p,r,o){
+var s=HashToEntry(n,o,p);
+if(s===-1)return s;
+var t=((%_FixedArrayGet(n,((3+(p)+((s)*3)))|0)));
+if(r===t)return s;
+var u=j(r);
+while(true){
+if(u&&j(t)){
+return s;
+}
+s=((%_FixedArrayGet(n,((3+(p)+((s)*3))+2)|0)));
+if(s===-1)return s;
+t=((%_FixedArrayGet(n,((3+(p)+((s)*3)))|0)));
+if(r===t)return s;
+}
+return-1;
+}
+%SetForceInlineFlag(MapFindEntry);
+function ComputeIntegerHash(r,v){
+var o=r;
+o=o^v;
+o=~o+(o<<15);
+o=o^(o>>>12);
+o=o+(o<<2);
+o=o^(o>>>4);
+o=(o*2057)|0;
+o=o^(o>>>16);
+return o&0x3fffffff;
+}
+%SetForceInlineFlag(ComputeIntegerHash);
+function GetExistingHash(r){
+if(%_IsSmi(r)){
+return ComputeIntegerHash(r,0);
+}
+if((typeof(r)==='string')){
+var w=%_StringGetRawHashField(r);
+if((w&1)===0){
+return w>>>2;
+}
+}else if((%_IsJSReceiver(r))&&!(%_IsJSProxy(r))&&!(%_ClassOf(r)==='global')){
+var o=(r[f]);
+return o;
+}
+return %GenericHash(r);
+}
+%SetForceInlineFlag(GetExistingHash);
+function GetHash(r){
+var o=GetExistingHash(r);
+if((o===(void 0))){
+o=g()|0;
+if(o===0)o=1;
+(r[f]=o);
+}
+return o;
+}
+%SetForceInlineFlag(GetHash);
+function SetConstructor(x){
+if((new.target===(void 0))){
+throw h(28,"Set");
+}
+%_SetInitialize(this);
+if(!(x==null)){
+var y=this.add;
+if(!(typeof(y)==='function')){
+throw h(96,y,'add',this);
+}
+for(var z of x){
+%_Call(y,this,z);
+}
+}
+}
+function SetAdd(r){
+if(!(%_ClassOf(this)==='Set')){
+throw h(44,'Set.prototype.add',this);
+}
+if(r===0){
+r=0;
+}
+var n=%_JSCollectionGetTable(this);
+var p=((%_FixedArrayGet(n,(0)|0)));
+var o=GetHash(r);
+if(SetFindEntry(n,p,r,o)!==-1)return this;
+var A=((%_FixedArrayGet(n,(1)|0)));
+var B=((%_FixedArrayGet(n,(2)|0)));
+var C=p<<1;
+if((A+B)>=C){
+%SetGrow(this);
+n=%_JSCollectionGetTable(this);
+p=((%_FixedArrayGet(n,(0)|0)));
+A=((%_FixedArrayGet(n,(1)|0)));
+B=((%_FixedArrayGet(n,(2)|0)));
+}
+var s=A+B;
+var D=(3+(p)+((s)<<1));
+var q=(o&((p)-1));
+var E=((%_FixedArrayGet(n,(3+(q))|0)));
+((%_FixedArraySet(n,(3+(q))|0,s)));
+(((%_FixedArraySet(n,(1)|0,(A+1)|0))));
+(%_FixedArraySet(n,(D)|0,r));
+((%_FixedArraySet(n,(D+1)|0,(E)|0)));
+return this;
+}
+function SetHas(r){
+if(!(%_ClassOf(this)==='Set')){
+throw h(44,'Set.prototype.has',this);
+}
+var n=%_JSCollectionGetTable(this);
+var p=((%_FixedArrayGet(n,(0)|0)));
+var o=GetExistingHash(r);
+if((o===(void 0)))return false;
+return SetFindEntry(n,p,r,o)!==-1;
+}
+function SetDelete(r){
+if(!(%_ClassOf(this)==='Set')){
+throw h(44,
+'Set.prototype.delete',this);
+}
+var n=%_JSCollectionGetTable(this);
+var p=((%_FixedArrayGet(n,(0)|0)));
+var o=GetExistingHash(r);
+if((o===(void 0)))return false;
+var s=SetFindEntry(n,p,r,o);
+if(s===-1)return false;
+var A=((%_FixedArrayGet(n,(1)|0)))-1;
+var B=((%_FixedArrayGet(n,(2)|0)))+1;
+var D=(3+(p)+((s)<<1));
+(%_FixedArraySet(n,(D)|0,%_TheHole()));
+(((%_FixedArraySet(n,(1)|0,(A)|0))));
+(((%_FixedArraySet(n,(2)|0,(B)|0))));
+if(A<(p>>>1))%SetShrink(this);
+return true;
+}
+function SetGetSize(){
+if(!(%_ClassOf(this)==='Set')){
+throw h(44,
+'Set.prototype.size',this);
+}
+var n=%_JSCollectionGetTable(this);
+return((%_FixedArrayGet(n,(1)|0)));
+}
+function SetClearJS(){
+if(!(%_ClassOf(this)==='Set')){
+throw h(44,
+'Set.prototype.clear',this);
+}
+%_SetClear(this);
+}
+function SetForEach(F,G){
+if(!(%_ClassOf(this)==='Set')){
+throw h(44,
+'Set.prototype.forEach',this);
+}
+if(!(typeof(F)==='function'))throw h(15,F);
+var H=new k(this,2);
+var r;
+var I=[(void 0)];
+while(%SetIteratorNext(H,I)){
+r=I[0];
+%_Call(F,G,r,r,this);
+}
+}
+%SetCode(e,SetConstructor);
+%FunctionSetLength(e,0);
+%FunctionSetPrototype(e,new d());
+%AddNamedProperty(e.prototype,"constructor",e,2);
+%AddNamedProperty(e.prototype,l,"Set",
+2|1);
+%FunctionSetLength(SetForEach,1);
+b.InstallGetter(e.prototype,"size",SetGetSize);
+b.InstallFunctions(e.prototype,2,[
+"add",SetAdd,
+"has",SetHas,
+"delete",SetDelete,
+"clear",SetClearJS,
+"forEach",SetForEach
+]);
+function MapConstructor(x){
+if((new.target===(void 0))){
+throw h(28,"Map");
+}
+%_MapInitialize(this);
+if(!(x==null)){
+var y=this.set;
+if(!(typeof(y)==='function')){
+throw h(96,y,'set',this);
+}
+for(var J of x){
+if(!(%_IsJSReceiver(J))){
+throw h(52,J);
+}
+%_Call(y,this,J[0],J[1]);
+}
+}
+}
+function MapGet(r){
+if(!(%_ClassOf(this)==='Map')){
+throw h(44,
+'Map.prototype.get',this);
+}
+var n=%_JSCollectionGetTable(this);
+var p=((%_FixedArrayGet(n,(0)|0)));
+var o=GetExistingHash(r);
+if((o===(void 0)))return(void 0);
+var s=MapFindEntry(n,p,r,o);
+if(s===-1)return(void 0);
+return((%_FixedArrayGet(n,((3+(p)+((s)*3))+1)|0)));
+}
+function MapSet(r,z){
+if(!(%_ClassOf(this)==='Map')){
+throw h(44,
+'Map.prototype.set',this);
+}
+if(r===0){
+r=0;
+}
+var n=%_JSCollectionGetTable(this);
+var p=((%_FixedArrayGet(n,(0)|0)));
+var o=GetHash(r);
+var s=MapFindEntry(n,p,r,o);
+if(s!==-1){
+var K=(3+(p)+((s)*3));
+(%_FixedArraySet(n,(K+1)|0,z));
+return this;
+}
+var A=((%_FixedArrayGet(n,(1)|0)));
+var B=((%_FixedArrayGet(n,(2)|0)));
+var C=p<<1;
+if((A+B)>=C){
+%MapGrow(this);
+n=%_JSCollectionGetTable(this);
+p=((%_FixedArrayGet(n,(0)|0)));
+A=((%_FixedArrayGet(n,(1)|0)));
+B=((%_FixedArrayGet(n,(2)|0)));
+}
+s=A+B;
+var D=(3+(p)+((s)*3));
+var q=(o&((p)-1));
+var E=((%_FixedArrayGet(n,(3+(q))|0)));
+((%_FixedArraySet(n,(3+(q))|0,s)));
+(((%_FixedArraySet(n,(1)|0,(A+1)|0))));
+(%_FixedArraySet(n,(D)|0,r));
+(%_FixedArraySet(n,(D+1)|0,z));
+(%_FixedArraySet(n,(D+2)|0,E));
+return this;
+}
+function MapHas(r){
+if(!(%_ClassOf(this)==='Map')){
+throw h(44,
+'Map.prototype.has',this);
+}
+var n=%_JSCollectionGetTable(this);
+var p=((%_FixedArrayGet(n,(0)|0)));
+var o=GetHash(r);
+return MapFindEntry(n,p,r,o)!==-1;
+}
+function MapDelete(r){
+if(!(%_ClassOf(this)==='Map')){
+throw h(44,
+'Map.prototype.delete',this);
+}
+var n=%_JSCollectionGetTable(this);
+var p=((%_FixedArrayGet(n,(0)|0)));
+var o=GetHash(r);
+var s=MapFindEntry(n,p,r,o);
+if(s===-1)return false;
+var A=((%_FixedArrayGet(n,(1)|0)))-1;
+var B=((%_FixedArrayGet(n,(2)|0)))+1;
+var D=(3+(p)+((s)*3));
+(%_FixedArraySet(n,(D)|0,%_TheHole()));
+(%_FixedArraySet(n,(D+1)|0,%_TheHole()));
+(((%_FixedArraySet(n,(1)|0,(A)|0))));
+(((%_FixedArraySet(n,(2)|0,(B)|0))));
+if(A<(p>>>1))%MapShrink(this);
+return true;
+}
+function MapGetSize(){
+if(!(%_ClassOf(this)==='Map')){
+throw h(44,
+'Map.prototype.size',this);
+}
+var n=%_JSCollectionGetTable(this);
+return((%_FixedArrayGet(n,(1)|0)));
+}
+function MapClearJS(){
+if(!(%_ClassOf(this)==='Map')){
+throw h(44,
+'Map.prototype.clear',this);
+}
+%_MapClear(this);
+}
+function MapForEach(F,G){
+if(!(%_ClassOf(this)==='Map')){
+throw h(44,
+'Map.prototype.forEach',this);
+}
+if(!(typeof(F)==='function'))throw h(15,F);
+var H=new i(this,3);
+var I=[(void 0),(void 0)];
+while(%MapIteratorNext(H,I)){
+%_Call(F,G,I[1],I[0],this);
+}
+}
+%SetCode(c,MapConstructor);
+%FunctionSetLength(c,0);
+%FunctionSetPrototype(c,new d());
+%AddNamedProperty(c.prototype,"constructor",c,2);
+%AddNamedProperty(
+c.prototype,l,"Map",2|1);
+%FunctionSetLength(MapForEach,1);
+b.InstallGetter(c.prototype,"size",MapGetSize);
+b.InstallFunctions(c.prototype,2,[
+"get",MapGet,
+"set",MapSet,
+"has",MapHas,
+"delete",MapDelete,
+"clear",MapClearJS,
+"forEach",MapForEach
+]);
+%InstallToContext([
+"map_get",MapGet,
+"map_set",MapSet,
+"map_has",MapHas,
+"map_delete",MapDelete,
+"set_add",SetAdd,
+"set_has",SetHas,
+"set_delete",SetDelete,
+]);
+b.Export(function(L){
+L.GetExistingHash=GetExistingHash;
+L.GetHash=GetHash;
+});
+})
+
+<weak-collection�-
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c;
+var d;
+var e=a.Object;
+var f=a.WeakMap;
+var g=a.WeakSet;
+var h;
+var i=b.ImportNow("to_string_tag_symbol");
+b.Import(function(j){
+c=j.GetExistingHash;
+d=j.GetHash;
+h=j.MakeTypeError;
+});
+function WeakMapConstructor(k){
+if((new.target===(void 0))){
+throw h(28,"WeakMap");
+}
+%WeakCollectionInitialize(this);
+if(!(k==null)){
+var l=this.set;
+if(!(typeof(l)==='function')){
+throw h(96,l,'set',this);
+}
+for(var m of k){
+if(!(%_IsJSReceiver(m))){
+throw h(52,m);
+}
+%_Call(l,this,m[0],m[1]);
+}
+}
+}
+function WeakMapGet(n){
+if(!(%_ClassOf(this)==='WeakMap')){
+throw h(44,
+'WeakMap.prototype.get',this);
+}
+if(!(%_IsJSReceiver(n)))return(void 0);
+var o=c(n);
+if((o===(void 0)))return(void 0);
+return %WeakCollectionGet(this,n,o);
+}
+function WeakMapSet(n,p){
+if(!(%_ClassOf(this)==='WeakMap')){
+throw h(44,
+'WeakMap.prototype.set',this);
+}
+if(!(%_IsJSReceiver(n)))throw h(174);
+return %WeakCollectionSet(this,n,p,d(n));
+}
+function WeakMapHas(n){
+if(!(%_ClassOf(this)==='WeakMap')){
+throw h(44,
+'WeakMap.prototype.has',this);
+}
+if(!(%_IsJSReceiver(n)))return false;
+var o=c(n);
+if((o===(void 0)))return false;
+return %WeakCollectionHas(this,n,o);
+}
+function WeakMapDelete(n){
+if(!(%_ClassOf(this)==='WeakMap')){
+throw h(44,
+'WeakMap.prototype.delete',this);
+}
+if(!(%_IsJSReceiver(n)))return false;
+var o=c(n);
+if((o===(void 0)))return false;
+return %WeakCollectionDelete(this,n,o);
+}
+%SetCode(f,WeakMapConstructor);
+%FunctionSetLength(f,0);
+%FunctionSetPrototype(f,new e());
+%AddNamedProperty(f.prototype,"constructor",f,
+2);
+%AddNamedProperty(f.prototype,i,"WeakMap",
+2|1);
+b.InstallFunctions(f.prototype,2,[
+"get",WeakMapGet,
+"set",WeakMapSet,
+"has",WeakMapHas,
+"delete",WeakMapDelete
+]);
+function WeakSetConstructor(k){
+if((new.target===(void 0))){
+throw h(28,"WeakSet");
+}
+%WeakCollectionInitialize(this);
+if(!(k==null)){
+var l=this.add;
+if(!(typeof(l)==='function')){
+throw h(96,l,'add',this);
+}
+for(var p of k){
+%_Call(l,this,p);
+}
+}
+}
+function WeakSetAdd(p){
+if(!(%_ClassOf(this)==='WeakSet')){
+throw h(44,
+'WeakSet.prototype.add',this);
+}
+if(!(%_IsJSReceiver(p)))throw h(175);
+return %WeakCollectionSet(this,p,true,d(p));
+}
+function WeakSetHas(p){
+if(!(%_ClassOf(this)==='WeakSet')){
+throw h(44,
+'WeakSet.prototype.has',this);
+}
+if(!(%_IsJSReceiver(p)))return false;
+var o=c(p);
+if((o===(void 0)))return false;
+return %WeakCollectionHas(this,p,o);
+}
+function WeakSetDelete(p){
+if(!(%_ClassOf(this)==='WeakSet')){
+throw h(44,
+'WeakSet.prototype.delete',this);
+}
+if(!(%_IsJSReceiver(p)))return false;
+var o=c(p);
+if((o===(void 0)))return false;
+return %WeakCollectionDelete(this,p,o);
+}
+%SetCode(g,WeakSetConstructor);
+%FunctionSetLength(g,0);
+%FunctionSetPrototype(g,new e());
+%AddNamedProperty(g.prototype,"constructor",g,
+2);
+%AddNamedProperty(g.prototype,i,"WeakSet",
+2|1);
+b.InstallFunctions(g.prototype,2,[
+"add",WeakSetAdd,
+"has",WeakSetHas,
+"delete",WeakSetDelete
+]);
+})
+
+Lcollection-iterator(
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Map;
+var d=a.Set;
+var e=b.ImportNow("iterator_symbol");
+var f;
+var g=b.ImportNow("MapIterator");
+var h=b.ImportNow("to_string_tag_symbol");
+var i=b.ImportNow("SetIterator");
+b.Import(function(j){
+f=j.MakeTypeError;
+});
+function SetIteratorConstructor(k,l){
+%SetIteratorInitialize(this,k,l);
+}
+function SetIteratorNextJS(){
+if(!(%_ClassOf(this)==='Set Iterator')){
+throw f(44,
+'Set Iterator.prototype.next',this);
+}
+var m=[(void 0),(void 0)];
+var n=%_CreateIterResultObject(m,false);
+switch(%SetIteratorNext(this,m)){
+case 0:
+n.value=(void 0);
+n.done=true;
+break;
+case 2:
+n.value=m[0];
+break;
+case 3:
+m[1]=m[0];
+break;
+}
+return n;
+}
+function SetEntries(){
+if(!(%_ClassOf(this)==='Set')){
+throw f(44,
+'Set.prototype.entries',this);
+}
+return new i(this,3);
+}
+function SetValues(){
+if(!(%_ClassOf(this)==='Set')){
+throw f(44,
+'Set.prototype.values',this);
+}
+return new i(this,2);
+}
+%SetCode(i,SetIteratorConstructor);
+%FunctionSetInstanceClassName(i,'Set Iterator');
+b.InstallFunctions(i.prototype,2,[
+'next',SetIteratorNextJS
+]);
+%AddNamedProperty(i.prototype,h,
+"Set Iterator",1|2);
+b.InstallFunctions(d.prototype,2,[
+'entries',SetEntries,
+'keys',SetValues,
+'values',SetValues
+]);
+%AddNamedProperty(d.prototype,e,SetValues,2);
+function MapIteratorConstructor(o,l){
+%MapIteratorInitialize(this,o,l);
+}
+function MapIteratorNextJS(){
+if(!(%_ClassOf(this)==='Map Iterator')){
+throw f(44,
+'Map Iterator.prototype.next',this);
+}
+var m=[(void 0),(void 0)];
+var n=%_CreateIterResultObject(m,false);
+switch(%MapIteratorNext(this,m)){
+case 0:
+n.value=(void 0);
+n.done=true;
+break;
+case 1:
+n.value=m[0];
+break;
+case 2:
+n.value=m[1];
+break;
+}
+return n;
+}
+function MapEntries(){
+if(!(%_ClassOf(this)==='Map')){
+throw f(44,
+'Map.prototype.entries',this);
+}
+return new g(this,3);
+}
+function MapKeys(){
+if(!(%_ClassOf(this)==='Map')){
+throw f(44,
+'Map.prototype.keys',this);
+}
+return new g(this,1);
+}
+function MapValues(){
+if(!(%_ClassOf(this)==='Map')){
+throw f(44,
+'Map.prototype.values',this);
+}
+return new g(this,2);
+}
+%SetCode(g,MapIteratorConstructor);
+%FunctionSetInstanceClassName(g,'Map Iterator');
+b.InstallFunctions(g.prototype,2,[
+'next',MapIteratorNextJS
+]);
+%AddNamedProperty(g.prototype,h,
+"Map Iterator",1|2);
+b.InstallFunctions(c.prototype,2,[
+'entries',MapEntries,
+'keys',MapKeys,
+'values',MapValues
+]);
+%AddNamedProperty(c.prototype,e,MapEntries,2);
+b.Export(function(p){
+p.MapEntries=MapEntries;
+p.MapIteratorNext=MapIteratorNextJS;
+p.SetIteratorNext=SetIteratorNextJS;
+p.SetValues=SetValues;
+});
+})
+
+promiser
+(function(a,b,c){
+"use strict";
+%CheckIsBootstrapping();
+var d=b.InternalArray;
+var e;
+var f=
+b.ImportNow("promise_combined_deferred_symbol");
+var g=
+b.ImportNow("promise_has_handler_symbol");
+var h=b.ImportNow("promise_on_reject_symbol");
+var i=
+b.ImportNow("promise_on_resolve_symbol");
+var j=b.ImportNow("promise_raw_symbol");
+var k=b.ImportNow("promise_status_symbol");
+var l=b.ImportNow("promise_value_symbol");
+var m;
+var n=b.ImportNow("to_string_tag_symbol");
+b.Import(function(o){
+e=o.MakeTypeError;
+m=o.SpeciesConstructor;
+});
+var p=0;
+function CreateResolvingFunctions(q){
+var r=false;
+var s=value=>{
+if(r===true)return;
+r=true;
+PromiseResolve(q,value);
+};
+var t=reason=>{
+if(r===true)return;
+r=true;
+PromiseReject(q,reason);
+};
+return{
+__proto__:null,
+resolve:s,
+reject:t
+};
+}
+var u=function Promise(v){
+if(v===j){
+return %_NewObject(u,new.target);
+}
+if((new.target===(void 0)))throw e(65,this);
+if(!(typeof(v)==='function'))
+throw e(137,v);
+var q=PromiseInit(%_NewObject(u,new.target));
+var w=CreateResolvingFunctions(q);
+try{
+%DebugPushPromise(q,Promise);
+v(w.resolve,w.reject);
+}catch(e){
+%_Call(w.reject,(void 0),e);
+}finally{
+%DebugPopPromise();
+}
+return q;
+}
+function PromiseSet(q,x,y,z,A){
+(q[k]=x);
+(q[l]=y);
+(q[i]=z);
+(q[h]=A);
+return q;
+}
+function PromiseCreateAndSet(x,y){
+var q=new u(j);
+if((%_DebugIsActive()!=0))PromiseSet(q,0,(void 0));
+return PromiseSet(q,x,y);
+}
+function PromiseInit(q){
+return PromiseSet(
+q,0,(void 0),new d,new d)
+}
+function PromiseDone(q,x,y,B){
+if((q[k])===0){
+var C=(q[B]);
+if(C.length)PromiseEnqueue(y,C,x);
+PromiseSet(q,x,y);
+}
+}
+function PromiseHandle(y,D,E){
+try{
+%DebugPushPromise(E.promise,PromiseHandle);
+var F=D(y);
+E.resolve(F);
+}catch(exception){
+try{E.reject(exception);}catch(e){}
+}finally{
+%DebugPopPromise();
+}
+}
+function PromiseEnqueue(y,C,x){
+var G,H,I=(%_DebugIsActive()!=0);
+%EnqueueMicrotask(function(){
+if(I){
+%DebugAsyncTaskEvent({type:"willHandle",id:G,name:H});
+}
+for(var J=0;J<C.length;J+=2){
+PromiseHandle(y,C[J],C[J+1])
+}
+if(I){
+%DebugAsyncTaskEvent({type:"didHandle",id:G,name:H});
+}
+});
+if(I){
+G=++p;
+H=x>0?"Promise.resolve":"Promise.reject";
+%DebugAsyncTaskEvent({type:"enqueue",id:G,name:H});
+}
+}
+function PromiseIdResolveHandler(K){return K}
+function PromiseIdRejectHandler(L){throw L}
+function PromiseNopResolver(){}
+function IsPromise(K){
+return(%_IsJSReceiver(K))&&(!(K[k]===(void 0)));
+}
+function PromiseCreate(){
+return new u(PromiseNopResolver)
+}
+function PromiseResolve(q,K){
+if(K===q){
+return PromiseReject(q,e(92,K));
+}
+if((%_IsJSReceiver(K))){
+try{
+var M=K.then;
+}catch(e){
+return PromiseReject(q,e);
+}
+if((typeof(M)==='function')){
+var G,H,I=(%_DebugIsActive()!=0);
+%EnqueueMicrotask(function(){
+if(I){
+%DebugAsyncTaskEvent({type:"willHandle",id:G,name:H});
+}
+var w=CreateResolvingFunctions(q);
+try{
+%_Call(M,K,w.resolve,w.reject);
+}catch(e){
+%_Call(w.reject,(void 0),e);
+}
+if(I){
+%DebugAsyncTaskEvent({type:"didHandle",id:G,name:H});
+}
+});
+if(I){
+G=++p;
+H="PromseResolveThenableJob";
+%DebugAsyncTaskEvent({type:"enqueue",id:G,name:H});
+}
+return;
+}
+}
+PromiseDone(q,+1,K,i);
+}
+function PromiseReject(q,L){
+if((q[k])==0){
+var N=(%_DebugIsActive()!=0);
+if(N||
+!(!(q[g]===(void 0)))){
+%PromiseRejectEvent(q,L,N);
+}
+}
+PromiseDone(q,-1,L,h)
+}
+function NewPromiseCapability(O){
+if(O===u){
+var q=PromiseInit(new u(j));
+var w=CreateResolvingFunctions(q);
+return{
+promise:q,
+resolve:w.resolve,
+reject:w.reject
+};
+}
+var F={promise:(void 0),resolve:(void 0),reject:(void 0)};
+F.promise=new O((s,t)=>{
+if(!(F.resolve===(void 0))||!(F.reject===(void 0)))
+throw e(93);
+F.resolve=s;
+F.reject=t;
+});
+if(!(typeof(F.resolve)==='function')||!(typeof(F.reject)==='function'))
+throw e(94);
+return F;
+}
+function PromiseDeferred(){
+%IncrementUseCounter(19);
+return NewPromiseCapability(this);
+}
+function PromiseResolved(K){
+%IncrementUseCounter(18);
+return %_Call(PromiseCast,this,K);
+}
+function PromiseRejected(L){
+if(!(%_IsJSReceiver(this))){
+throw e(17,PromiseRejected);
+}
+if(this===u){
+var q=PromiseCreateAndSet(-1,L);
+%PromiseRejectEvent(q,L,false);
+return q;
+}else{
+var P=NewPromiseCapability(this);
+%_Call(P.reject,(void 0),L);
+return P.promise;
+}
+}
+function PromiseThen(z,A){
+var x=(this[k]);
+if((x===(void 0))){
+throw e(65,this);
+}
+var Q=m(this,u);
+z=(typeof(z)==='function')?z:PromiseIdResolveHandler;
+A=(typeof(A)==='function')?A:PromiseIdRejectHandler;
+var E=NewPromiseCapability(Q);
+switch(x){
+case 0:
+(this[i]).push(z,E);
+(this[h]).push(A,E);
+break;
+case+1:
+PromiseEnqueue((this[l]),
+[z,E],
++1);
+break;
+case-1:
+if(!(!(this[g]===(void 0)))){
+%PromiseRevokeReject(this);
+}
+PromiseEnqueue((this[l]),
+[A,E],
+-1);
+break;
+}
+(this[g]=true);
+return E.promise;
+}
+function PromiseChain(z,A){
+%IncrementUseCounter(17);
+return %_Call(PromiseThen,this,z,A);
+}
+function PromiseCatch(A){
+return this.then((void 0),A);
+}
+function PromiseCast(K){
+if(!(%_IsJSReceiver(this))){
+throw e(17,PromiseCast);
+}
+if(IsPromise(K)&&K.constructor===this)return K;
+var P=NewPromiseCapability(this);
+var R=%_Call(P.resolve,(void 0),K);
+return P.promise;
+}
+function PromiseAll(S){
+if(!(%_IsJSReceiver(this))){
+throw e(17,"Promise.all");
+}
+var E=NewPromiseCapability(this);
+var T=new d();
+var U;
+function CreateResolveElementFunction(V,W,P){
+var X=false;
+return(K)=>{
+if(X===true)return;
+X=true;
+W[V]=K;
+if(--U===0){
+var Y=[];
+%MoveArrayContents(W,Y);
+%_Call(P.resolve,(void 0),Y);
+}
+};
+}
+try{
+var J=0;
+U=1;
+for(var y of S){
+var Z=this.resolve(y);
+++U;
+Z.then(
+CreateResolveElementFunction(J,T,E),
+E.reject);
+(E.reject[f]=E);
+++J;
+}
+if(--U===0){
+var Y=[];
+%MoveArrayContents(T,Y);
+%_Call(E.resolve,(void 0),Y);
+}
+}catch(e){
+%_Call(E.reject,(void 0),e);
+}
+return E.promise;
+}
+function PromiseRace(S){
+if(!(%_IsJSReceiver(this))){
+throw e(17,PromiseRace);
+}
+var E=NewPromiseCapability(this);
+try{
+for(var y of S){
+this.resolve(y).then(E.resolve,E.reject);
+(E.reject[f]=E);
+}
+}catch(e){
+E.reject(e)
+}
+return E.promise;
+}
+function PromiseHasUserDefinedRejectHandlerRecursive(q){
+var aa=(q[h]);
+if((aa===(void 0)))return false;
+for(var J=0;J<aa.length;J+=2){
+var D=aa[J];
+if(D!==PromiseIdRejectHandler){
+var E=(D[f]);
+if((E===(void 0)))return true;
+if(PromiseHasUserDefinedRejectHandlerRecursive(E.promise)){
+return true;
+}
+}else if(PromiseHasUserDefinedRejectHandlerRecursive(
+aa[J+1].promise)){
+return true;
+}
+}
+return false;
+}
+function PromiseHasUserDefinedRejectHandler(){
+return PromiseHasUserDefinedRejectHandlerRecursive(this);
+};
+%AddNamedProperty(a,'Promise',u,2);
+%AddNamedProperty(u.prototype,n,"Promise",
+2|1);
+b.InstallFunctions(u,2,[
+"reject",PromiseRejected,
+"all",PromiseAll,
+"race",PromiseRace,
+"resolve",PromiseCast
+]);
+b.InstallFunctions(u.prototype,2,[
+"then",PromiseThen,
+"catch",PromiseCatch
+]);
+%InstallToContext([
+"promise_catch",PromiseCatch,
+"promise_chain",PromiseChain,
+"promise_create",PromiseCreate,
+"promise_has_user_defined_reject_handler",PromiseHasUserDefinedRejectHandler,
+"promise_reject",PromiseReject,
+"promise_resolve",PromiseResolve,
+"promise_then",PromiseThen,
+]);
+b.InstallFunctions(c,0,[
+"createPromise",PromiseCreate,
+"resolvePromise",PromiseResolve,
+"rejectPromise",PromiseReject
+]);
+[PromiseChain,PromiseDeferred,PromiseResolved].forEach(
+fn=>%FunctionRemovePrototype(fn));
+b.Export(function(ab){
+ab.PromiseChain=PromiseChain;
+ab.PromiseDeferred=PromiseDeferred;
+ab.PromiseResolved=PromiseResolved;
+});
+})
+
+ messagesU�
+(function(a,b){
+%CheckIsBootstrapping();
+var c;
+var d;
+var e;
+var f;
+var g=
+b.ImportNow("call_site_receiver_symbol");
+var h=
+b.ImportNow("call_site_function_symbol");
+var i=
+b.ImportNow("call_site_position_symbol");
+var j=
+b.ImportNow("call_site_strict_symbol");
+var k;
+var l=
+b.ImportNow("formatted_stack_trace_symbol");
+var m=a.Object;
+var n;
+var o;
+var p;
+var q=b.InternalArray;
+var r=b.ImportNow("internal_error_symbol");
+var s;
+var t;
+var u=b.ImportNow("object_to_string");
+var v=b.ImportNow("Script");
+var w=b.ImportNow("stack_trace_symbol");
+var x;
+var y;
+var z;
+var A;
+var B=b.ImportNow("to_string_tag_symbol");
+var C;
+var D;
+var E;
+b.Import(function(F){
+c=F.ArrayJoin;
+d=F.Bool16x8ToString;
+e=F.Bool32x4ToString;
+f=F.Bool8x16ToString;
+k=F.Float32x4ToString;
+n=F.Int16x8ToString;
+o=F.Int32x4ToString;
+p=F.Int8x16ToString;
+s=F.ObjectDefineProperty;
+t=F.ObjectHasOwnProperty;
+x=F.StringCharAt;
+y=F.StringIndexOf;
+z=F.StringSubstring;
+A=F.SymbolToString;
+C=F.Uint16x8ToString;
+D=F.Uint32x4ToString;
+E=F.Uint8x16ToString;
+});
+var G;
+var H;
+var I;
+var J;
+var K;
+var L;
+var M;
+function NoSideEffectsObjectToString(){
+if((this===(void 0)))return"[object Undefined]";
+if((this===null))return"[object Null]";
+var N=(%_ToObject(this));
+var O=%_ClassOf(N);
+var P=%GetDataProperty(N,B);
+if(!(typeof(P)==='string')){
+P=O;
+}
+return`[object ${P}]`;
+}
+function IsErrorObject(Q){
+return(%_Call(t,Q,w));
+}
+function NoSideEffectsErrorToString(){
+var R=%GetDataProperty(this,"name");
+var S=%GetDataProperty(this,"message");
+R=(R===(void 0))?"Error":NoSideEffectsToString(R);
+S=(S===(void 0))?"":NoSideEffectsToString(S);
+if(R=="")return S;
+if(S=="")return R;
+return`${R}: ${S}`;
+}
+function NoSideEffectsToString(Q){
+if((typeof(Q)==='string'))return Q;
+if((typeof(Q)==='number'))return %_NumberToString(Q);
+if((typeof(Q)==='boolean'))return Q?'true':'false';
+if((Q===(void 0)))return'undefined';
+if((Q===null))return'null';
+if((%IsFunction(Q))){
+var T=%FunctionToString(Q);
+if(T.length>128){
+T=%_SubString(T,0,111)+"...<omitted>..."+
+%_SubString(T,T.length-2,T.length);
+}
+return T;
+}
+if((typeof(Q)==='symbol'))return %_Call(A,Q);
+if((%IsSimdValue(Q))){
+switch(typeof(Q)){
+case'float32x4':return %_Call(k,Q);
+case'int32x4':return %_Call(o,Q);
+case'int16x8':return %_Call(n,Q);
+case'int8x16':return %_Call(p,Q);
+case'uint32x4':return %_Call(D,Q);
+case'uint16x8':return %_Call(C,Q);
+case'uint8x16':return %_Call(E,Q);
+case'bool32x4':return %_Call(e,Q);
+case'bool16x8':return %_Call(d,Q);
+case'bool8x16':return %_Call(f,Q);
+}
+}
+if((%_IsJSReceiver(Q))){
+if(IsErrorObject(Q)||
+%GetDataProperty(Q,"toString")===ErrorToString){
+return %_Call(NoSideEffectsErrorToString,Q);
+}
+if(%GetDataProperty(Q,"toString")===u){
+var U=%GetDataProperty(Q,"constructor");
+if((%IsFunction(U))){
+var V=%FunctionGetName(U);
+if(V!="")return`#<${V}>`;
+}
+}
+}
+return %_Call(NoSideEffectsObjectToString,Q);
+}
+function MakeGenericError(U,W,X,Y,Z){
+var aa=new U(FormatMessage(W,X,Y,Z));
+aa[r]=true;
+return aa;
+}
+%FunctionSetInstanceClassName(v,'Script');
+%AddNamedProperty(v.prototype,'constructor',v,
+2|4|1);
+%SetCode(v,function(ab){
+throw MakeError(6);
+});
+function FormatMessage(W,X,Y,Z){
+var X=NoSideEffectsToString(X);
+var Y=NoSideEffectsToString(Y);
+var Z=NoSideEffectsToString(Z);
+try{
+return %FormatMessageString(W,X,Y,Z);
+}catch(e){
+return"<error>";
+}
+}
+function GetLineNumber(S){
+var ac=%MessageGetStartPosition(S);
+if(ac==-1)return 0;
+var ad=%MessageGetScript(S);
+var ae=ad.locationFromPosition(ac,true);
+if(ae==null)return 0;
+return ae.line+1;
+}
+function GetColumnNumber(S){
+var ad=%MessageGetScript(S);
+var ac=%MessageGetStartPosition(S);
+var ae=ad.locationFromPosition(ac,true);
+if(ae==null)return-1;
+return ae.column;
+}
+function GetSourceLine(S){
+var ad=%MessageGetScript(S);
+var ac=%MessageGetStartPosition(S);
+var ae=ad.locationFromPosition(ac,true);
+if(ae==null)return"";
+return ae.sourceText();
+}
+function ScriptLineFromPosition(af){
+var ag=0;
+var ah=this.lineCount()-1;
+var ai=this.line_ends;
+if(af>ai[ah]){
+return-1;
+}
+if(af<=ai[0]){
+return 0;
+}
+while(ah>=1){
+var aj=(ag+ah)>>1;
+if(af>ai[aj]){
+ag=aj+1;
+}else if(af<=ai[aj-1]){
+ah=aj-1;
+}else{
+return aj;
+}
+}
+return-1;
+}
+function ScriptLocationFromPosition(af,
+include_resource_offset){
+var ak=this.lineFromPosition(af);
+if(ak==-1)return null;
+var ai=this.line_ends;
+var al=ak==0?0:ai[ak-1]+1;
+var am=ai[ak];
+if(am>0&&%_Call(x,this.source,am-1)=='\r'){
+am--;
+}
+var an=af-al;
+if(include_resource_offset){
+ak+=this.line_offset;
+if(ak==this.line_offset){
+an+=this.column_offset;
+}
+}
+return new SourceLocation(this,af,ak,an,al,am);
+}
+function ScriptLocationFromLine(ao,ap,aq){
+var ak=0;
+if(!(ao===(void 0))){
+ak=ao-this.line_offset;
+}
+var an=ap||0;
+if(ak==0){
+an-=this.column_offset;
+}
+var ar=aq||0;
+if(ak<0||an<0||ar<0)return null;
+if(ak==0){
+return this.locationFromPosition(ar+an,false);
+}else{
+var as=this.lineFromPosition(ar);
+if(as==-1||as+ak>=this.lineCount()){
+return null;
+}
+return this.locationFromPosition(
+this.line_ends[as+ak-1]+1+an);
+}
+}
+function ScriptSourceSlice(at,au){
+var av=(at===(void 0))?this.line_offset
+:at;
+var aw=(au===(void 0))?this.line_offset+this.lineCount()
+:au;
+av-=this.line_offset;
+aw-=this.line_offset;
+if(av<0)av=0;
+if(aw>this.lineCount())aw=this.lineCount();
+if(av>=this.lineCount()||
+aw<0||
+av>aw){
+return null;
+}
+var ai=this.line_ends;
+var ax=av==0?0:ai[av-1]+1;
+var ay=aw==0?0:ai[aw-1]+1;
+return new SourceSlice(this,
+av+this.line_offset,
+aw+this.line_offset,
+ax,ay);
+}
+function ScriptSourceLine(ao){
+var ak=0;
+if(!(ao===(void 0))){
+ak=ao-this.line_offset;
+}
+if(ak<0||this.lineCount()<=ak){
+return null;
+}
+var ai=this.line_ends;
+var al=ak==0?0:ai[ak-1]+1;
+var am=ai[ak];
+return %_Call(z,this.source,al,am);
+}
+function ScriptLineCount(){
+return this.line_ends.length;
+}
+function ScriptLineEnd(az){
+return this.line_ends[az];
+}
+function ScriptNameOrSourceURL(){
+if(this.source_url)return this.source_url;
+return this.name;
+}
+b.SetUpLockedPrototype(v,[
+"source",
+"name",
+"source_url",
+"source_mapping_url",
+"line_ends",
+"line_offset",
+"column_offset"
+],[
+"lineFromPosition",ScriptLineFromPosition,
+"locationFromPosition",ScriptLocationFromPosition,
+"locationFromLine",ScriptLocationFromLine,
+"sourceSlice",ScriptSourceSlice,
+"sourceLine",ScriptSourceLine,
+"lineCount",ScriptLineCount,
+"nameOrSourceURL",ScriptNameOrSourceURL,
+"lineEnd",ScriptLineEnd
+]
+);
+function SourceLocation(ad,af,ak,an,al,am){
+this.script=ad;
+this.position=af;
+this.line=ak;
+this.column=an;
+this.start=al;
+this.end=am;
+}
+function SourceLocationSourceText(){
+return %_Call(z,this.script.source,this.start,this.end);
+}
+b.SetUpLockedPrototype(SourceLocation,
+["script","position","line","column","start","end"],
+["sourceText",SourceLocationSourceText]
+);
+function SourceSlice(ad,av,aw,ax,ay){
+this.script=ad;
+this.from_line=av;
+this.to_line=aw;
+this.from_position=ax;
+this.to_position=ay;
+}
+function SourceSliceSourceText(){
+return %_Call(z,
+this.script.source,
+this.from_position,
+this.to_position);
+}
+b.SetUpLockedPrototype(SourceSlice,
+["script","from_line","to_line","from_position","to_position"],
+["sourceText",SourceSliceSourceText]
+);
+function GetStackTraceLine(aA,aB,aC,aD){
+return new CallSite(aA,aB,aC,false).toString();
+}
+function CallSite(aE,aB,aC,aF){
+if(!(%IsFunction(aB))){
+throw MakeTypeError(19,typeof aB);
+}
+if((new.target===(void 0))){
+return new CallSite(aE,aB,aC,aF);
+}
+(this[g]=aE);
+(this[h]=aB);
+(this[i]=((aC)|0));
+(this[j]=(!!(aF)));
+}
+function CheckCallSite(Q,R){
+if(!(%_IsJSReceiver(Q))||!(%_Call(t,Q,h))){
+throw MakeTypeError(20,R);
+}
+}
+function CallSiteGetThis(){
+CheckCallSite(this,"getThis");
+return(this[j])
+?(void 0):(this[g]);
+}
+function CallSiteGetFunction(){
+CheckCallSite(this,"getFunction");
+return(this[j])
+?(void 0):(this[h]);
+}
+function CallSiteGetPosition(){
+CheckCallSite(this,"getPosition");
+return(this[i]);
+}
+function CallSiteGetTypeName(){
+CheckCallSite(this,"getTypeName");
+return GetTypeName((this[g]),false);
+}
+function CallSiteIsToplevel(){
+CheckCallSite(this,"isTopLevel");
+return %CallSiteIsToplevelRT(this);
+}
+function CallSiteIsEval(){
+CheckCallSite(this,"isEval");
+return %CallSiteIsEvalRT(this);
+}
+function CallSiteGetEvalOrigin(){
+CheckCallSite(this,"getEvalOrigin");
+var ad=%FunctionGetScript((this[h]));
+return FormatEvalOrigin(ad);
+}
+function CallSiteGetScriptNameOrSourceURL(){
+CheckCallSite(this,"getScriptNameOrSourceURL");
+return %CallSiteGetScriptNameOrSourceUrlRT(this);
+}
+function CallSiteGetFunctionName(){
+CheckCallSite(this,"getFunctionName");
+return %CallSiteGetFunctionNameRT(this);
+}
+function CallSiteGetMethodName(){
+CheckCallSite(this,"getMethodName");
+return %CallSiteGetMethodNameRT(this);
+}
+function CallSiteGetFileName(){
+CheckCallSite(this,"getFileName");
+return %CallSiteGetFileNameRT(this);
+}
+function CallSiteGetLineNumber(){
+CheckCallSite(this,"getLineNumber");
+return %CallSiteGetLineNumberRT(this);
+}
+function CallSiteGetColumnNumber(){
+CheckCallSite(this,"getColumnNumber");
+return %CallSiteGetColumnNumberRT(this);
+}
+function CallSiteIsNative(){
+CheckCallSite(this,"isNative");
+return %CallSiteIsNativeRT(this);
+}
+function CallSiteIsConstructor(){
+CheckCallSite(this,"isConstructor");
+return %CallSiteIsConstructorRT(this);
+}
+function CallSiteToString(){
+var aG;
+var aH="";
+if(this.isNative()){
+aH="native";
+}else{
+aG=this.getScriptNameOrSourceURL();
+if(!aG&&this.isEval()){
+aH=this.getEvalOrigin();
+aH+=", ";
+}
+if(aG){
+aH+=aG;
+}else{
+aH+="<anonymous>";
+}
+var aI=this.getLineNumber();
+if(aI!=null){
+aH+=":"+aI;
+var aJ=this.getColumnNumber();
+if(aJ){
+aH+=":"+aJ;
+}
+}
+}
+var ak="";
+var aK=this.getFunctionName();
+var aL=true;
+var aM=this.isConstructor();
+var aN=!(this.isToplevel()||aM);
+if(aN){
+var aO=GetTypeName((this[g]),true);
+var aP=this.getMethodName();
+if(aK){
+if(aO&&%_Call(y,aK,aO)!=0){
+ak+=aO+".";
+}
+ak+=aK;
+if(aP&&
+(%_Call(y,aK,"."+aP)!=
+aK.length-aP.length-1)){
+ak+=" [as "+aP+"]";
+}
+}else{
+ak+=aO+"."+(aP||"<anonymous>");
+}
+}else if(aM){
+ak+="new "+(aK||"<anonymous>");
+}else if(aK){
+ak+=aK;
+}else{
+ak+=aH;
+aL=false;
+}
+if(aL){
+ak+=" ("+aH+")";
+}
+return ak;
+}
+b.SetUpLockedPrototype(CallSite,["receiver","fun","pos"],[
+"getThis",CallSiteGetThis,
+"getTypeName",CallSiteGetTypeName,
+"isToplevel",CallSiteIsToplevel,
+"isEval",CallSiteIsEval,
+"getEvalOrigin",CallSiteGetEvalOrigin,
+"getScriptNameOrSourceURL",CallSiteGetScriptNameOrSourceURL,
+"getFunction",CallSiteGetFunction,
+"getFunctionName",CallSiteGetFunctionName,
+"getMethodName",CallSiteGetMethodName,
+"getFileName",CallSiteGetFileName,
+"getLineNumber",CallSiteGetLineNumber,
+"getColumnNumber",CallSiteGetColumnNumber,
+"isNative",CallSiteIsNative,
+"getPosition",CallSiteGetPosition,
+"isConstructor",CallSiteIsConstructor,
+"toString",CallSiteToString
+]);
+function FormatEvalOrigin(ad){
+var aQ=ad.nameOrSourceURL();
+if(aQ){
+return aQ;
+}
+var aR="eval at ";
+if(ad.eval_from_function_name){
+aR+=ad.eval_from_function_name;
+}else{
+aR+="<anonymous>";
+}
+var aS=ad.eval_from_script;
+if(aS){
+if(aS.compilation_type==1){
+aR+=" ("+FormatEvalOrigin(aS)+")";
+}else{
+if(aS.name){
+aR+=" ("+aS.name;
+var ae=aS.locationFromPosition(
+ad.eval_from_script_position,true);
+if(ae){
+aR+=":"+(ae.line+1);
+aR+=":"+(ae.column+1);
+}
+aR+=")";
+}else{
+aR+=" (unknown source)";
+}
+}
+}
+return aR;
+}
+function FormatErrorString(aa){
+try{
+return %_Call(ErrorToString,aa);
+}catch(e){
+try{
+return"<error: "+e+">";
+}catch(ee){
+return"<error>";
+}
+}
+}
+function GetStackFrames(aT){
+var aU=new q();
+var aV=aT[0];
+for(var aj=1;aj<aT.length;aj+=4){
+var aA=aT[aj];
+var aB=aT[aj+1];
+var aW=aT[aj+2];
+var aX=aT[aj+3];
+var aC=%_IsSmi(aW)?aW:%FunctionGetPositionForOffset(aW,aX);
+aV--;
+aU.push(new CallSite(aA,aB,aC,(aV<0)));
+}
+return aU;
+}
+var aY=false;
+function FormatStackTrace(Q,aT){
+var aU=GetStackFrames(aT);
+if((%IsFunction(G.prepareStackTrace))&&
+!aY){
+var aZ=[];
+%MoveArrayContents(aU,aZ);
+aY=true;
+var ba=(void 0);
+try{
+ba=G.prepareStackTrace(Q,aZ);
+}catch(e){
+throw e;
+}finally{
+aY=false;
+}
+return ba;
+}
+var bb=new q();
+bb.push(FormatErrorString(Q));
+for(var aj=0;aj<aU.length;aj++){
+var bc=aU[aj];
+var ak;
+try{
+ak=bc.toString();
+}catch(e){
+try{
+ak="<error: "+e+">";
+}catch(ee){
+ak="<error>";
+}
+}
+bb.push("    at "+ak);
+}
+return %_Call(c,bb,"\n");
+}
+function GetTypeName(aE,bd){
+if((aE==null))return null;
+if((%_IsJSProxy(aE)))return"Proxy";
+var U=%GetDataProperty((%_ToObject(aE)),"constructor");
+if(!(%IsFunction(U))){
+return bd?null:%_Call(NoSideEffectsToString,aE);
+}
+return %FunctionGetName(U);
+}
+var be=function(){
+var bf=(void 0);
+var bg=this;
+while(bg){
+var bf=
+(bg[l]);
+if((bf===(void 0))){
+var ba=(bg[w]);
+if((ba===(void 0))){
+bg=%_GetPrototype(bg);
+continue;
+}
+bf=FormatStackTrace(bg,ba);
+(bg[w]=(void 0));
+(bg[l]=bf);
+}
+return bf;
+}
+return(void 0);
+};
+var bh=function(bi){
+if(IsErrorObject(this)){
+(this[w]=(void 0));
+(this[l]=bi);
+}
+};
+var bj=function(){};
+function SetUpError(bk){
+%FunctionSetInstanceClassName(bk,'Error');
+var R=bk.name;
+var bl=new m();
+if(R!=='Error'){
+%InternalSetPrototype(bk,G);
+%InternalSetPrototype(bl,G.prototype);
+}
+%FunctionSetPrototype(bk,bl);
+%AddNamedProperty(bk.prototype,'name',R,2);
+%AddNamedProperty(bk.prototype,'message','',2);
+%AddNamedProperty(
+bk.prototype,'constructor',bk,2);
+%SetCode(bk,function(bm){
+if((new.target===(void 0)))return new bk(bm);
+try{bj(this,bk);}catch(e){}
+if(!(bm===(void 0))){
+%AddNamedProperty(this,'message',(%_ToString(bm)),2);
+}
+});
+%SetNativeFlag(bk);
+return bk;
+};
+G=SetUpError(a.Error);
+M=SetUpError(a.EvalError);
+I=SetUpError(a.RangeError);
+L=SetUpError(a.ReferenceError);
+K=SetUpError(a.SyntaxError);
+H=SetUpError(a.TypeError);
+J=SetUpError(a.URIError);
+b.InstallFunctions(G.prototype,2,
+['toString',ErrorToString]);
+function ErrorToString(){
+if(!(%_IsJSReceiver(this))){
+throw MakeTypeError(17,"Error.prototype.toString");
+}
+var R=this.name;
+R=(R===(void 0))?"Error":(%_ToString(R));
+var S=this.message;
+S=(S===(void 0))?"":(%_ToString(S));
+if(R=="")return S;
+if(S=="")return R;
+return`${R}: ${S}`
+}
+function MakeError(W,X,Y,Z){
+return MakeGenericError(G,W,X,Y,Z);
+}
+function MakeRangeError(W,X,Y,Z){
+return MakeGenericError(I,W,X,Y,Z);
+}
+function MakeSyntaxError(W,X,Y,Z){
+return MakeGenericError(K,W,X,Y,Z);
+}
+function MakeTypeError(W,X,Y,Z){
+return MakeGenericError(H,W,X,Y,Z);
+}
+function MakeURIError(){
+return MakeGenericError(J,277);
+}
+var bn=MakeRangeError(186);
+b.InstallGetterSetter(bn,'stack',
+be,bh)
+bj=function captureStackTrace(Q,bo){
+s(Q,'stack',{get:be,
+set:bh,
+configurable:true});
+%CollectStackTrace(Q,bo?bo:bj);
+};
+G.captureStackTrace=bj;
+%InstallToContext([
+"get_stack_trace_line_fun",GetStackTraceLine,
+"make_error_function",MakeGenericError,
+"make_range_error",MakeRangeError,
+"make_type_error",MakeTypeError,
+"message_get_column_number",GetColumnNumber,
+"message_get_line_number",GetLineNumber,
+"message_get_source_line",GetSourceLine,
+"no_side_effects_to_string_fun",NoSideEffectsToString,
+"stack_overflow_boilerplate",bn,
+]);
+b.Export(function(bp){
+bp.ErrorToString=ErrorToString;
+bp.MakeError=MakeError;
+bp.MakeRangeError=MakeRangeError;
+bp.MakeSyntaxError=MakeSyntaxError;
+bp.MakeTypeError=MakeTypeError;
+bp.MakeURIError=MakeURIError;
+});
+});
+
+json�H
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Date;
+var d=a.JSON;
+var e=a.Set;
+var f=b.InternalArray;
+var g;
+var h;
+var i;
+var j;
+var k;
+var l;
+var m;
+var n;
+var o=b.ImportNow("to_string_tag_symbol");
+b.Import(function(p){
+g=p.MakeTypeError;
+h=p.MaxSimple;
+i=p.MinSimple;
+j=p.ObjectHasOwnProperty;
+k=p.Stack;
+l=p.StackHas;
+m=p.StackPop;
+n=p.StackPush;
+});
+function CreateDataProperty(q,r,s){
+var t={value:s,enumerable:true,writable:true,configurable:true};
+return %reflect_define_property(q,r,t);
+}
+function InternalizeJSONProperty(u,v,w){
+var x=u[v];
+if((%_IsJSReceiver(x))){
+if(%is_arraylike(x)){
+var y=(%_ToLength(x.length));
+for(var z=0;z<y;z++){
+var A=
+InternalizeJSONProperty(x,%_NumberToString(z),w);
+if((A===(void 0))){
+%reflect_delete_property(x,z);
+}else{
+CreateDataProperty(x,z,A);
+}
+}
+}else{
+var B=%object_keys(x);
+for(var z=0;z<B.length;z++){
+var r=B[z];
+var A=InternalizeJSONProperty(x,r,w);
+if((A===(void 0))){
+%reflect_delete_property(x,r);
+}else{
+CreateDataProperty(x,r,A);
+}
+}
+}
+}
+return %_Call(w,u,v,x);
+}
+function JSONParse(C,w){
+var D=%ParseJson(C);
+if((typeof(w)==='function')){
+return InternalizeJSONProperty({'':D},'',w);
+}else{
+return D;
+}
+}
+function SerializeArray(E,F,G,H,I){
+if(l(G,E))throw g(24);
+n(G,E);
+var J=H;
+H+=I;
+var K=new f();
+var L=(%_ToLength(E.length));
+for(var z=0;z<L;z++){
+var M=JSONSerialize(%_NumberToString(z),E,F,G,
+H,I);
+if((M===(void 0))){
+M="null";
+}
+K.push(M);
+}
+var N;
+if(I==""){
+N="["+K.join(",")+"]";
+}else if(K.length>0){
+var O=",\n"+H;
+N="[\n"+H+K.join(O)+"\n"+
+J+"]";
+}else{
+N="[]";
+}
+m(G);
+return N;
+}
+function SerializeObject(E,F,G,H,I){
+if(l(G,E))throw g(24);
+n(G,E);
+var J=H;
+H+=I;
+var K=new f();
+if((%_IsArray(F))){
+var y=F.length;
+for(var z=0;z<y;z++){
+var r=F[z];
+var M=JSONSerialize(r,E,F,G,H,I);
+if(!(M===(void 0))){
+var P=%QuoteJSONString(r)+":";
+if(I!="")P+=" ";
+P+=M;
+K.push(P);
+}
+}
+}else{
+var B=%object_keys(E);
+for(var z=0;z<B.length;z++){
+var r=B[z];
+var M=JSONSerialize(r,E,F,G,H,I);
+if(!(M===(void 0))){
+var P=%QuoteJSONString(r)+":";
+if(I!="")P+=" ";
+P+=M;
+K.push(P);
+}
+}
+}
+var N;
+if(I==""){
+N="{"+K.join(",")+"}";
+}else if(K.length>0){
+var O=",\n"+H;
+N="{\n"+H+K.join(O)+"\n"+
+J+"}";
+}else{
+N="{}";
+}
+m(G);
+return N;
+}
+function JSONSerialize(Q,u,F,G,H,I){
+var E=u[Q];
+if((%_IsJSReceiver(E))){
+var R=E.toJSON;
+if((typeof(R)==='function')){
+E=%_Call(R,E,Q);
+}
+}
+if((typeof(F)==='function')){
+E=%_Call(F,u,Q,E);
+}
+if((typeof(E)==='string')){
+return %QuoteJSONString(E);
+}else if((typeof(E)==='number')){
+return((%_IsSmi(%IS_VAR(E))||E-E==0)?%_NumberToString(E):"null");
+}else if((typeof(E)==='boolean')){
+return E?"true":"false";
+}else if((E===null)){
+return"null";
+}else if((%_IsJSReceiver(E))&&!(typeof(E)==='function')){
+if(%is_arraylike(E)){
+return SerializeArray(E,F,G,H,I);
+}else if((%_ClassOf(E)==='Number')){
+E=(%_ToNumber(E));
+return((%_IsSmi(%IS_VAR(E))||E-E==0)?%_NumberToString(E):"null");
+}else if((%_ClassOf(E)==='String')){
+return %QuoteJSONString((%_ToString(E)));
+}else if((%_ClassOf(E)==='Boolean')){
+return %_ValueOf(E)?"true":"false";
+}else{
+return SerializeObject(E,F,G,H,I);
+}
+}
+return(void 0);
+}
+function JSONStringify(E,F,S){
+if(arguments.length===1&&!(%_IsJSProxy(E))){
+return %BasicJSONStringify(E);
+}
+if(!(typeof(F)==='function')&&%is_arraylike(F)){
+var T=new f();
+var U=new e();
+var y=(%_ToLength(F.length));
+for(var z=0;z<y;z++){
+var s=F[z];
+var V;
+if((typeof(s)==='string')){
+V=s;
+}else if((typeof(s)==='number')){
+V=%_NumberToString(s);
+}else if((%_ClassOf(s)==='String')||(%_ClassOf(s)==='Number')){
+V=(%_ToString(s));
+}else{
+continue;
+}
+if(!U.has(V)){
+T.push(V);
+U.add(V);
+}
+}
+F=T;
+}
+if((typeof(S)==='object')){
+if((%_ClassOf(S)==='Number')){
+S=(%_ToNumber(S));
+}else if((%_ClassOf(S)==='String')){
+S=(%_ToString(S));
+}
+}
+var I;
+if((typeof(S)==='number')){
+S=h(0,i((%_ToInteger(S)),10));
+I=%_SubString("          ",0,S);
+}else if((typeof(S)==='string')){
+if(S.length>10){
+I=%_SubString(S,0,10);
+}else{
+I=S;
+}
+}else{
+I="";
+}
+if(!(typeof(F)==='function')&&!T&&!I&&!(%_IsJSProxy(E))){
+return %BasicJSONStringify(E);
+}
+return JSONSerialize('',{'':E},F,new k(),"",I);
+}
+%AddNamedProperty(d,o,"JSON",1|2);
+b.InstallFunctions(d,2,[
+"parse",JSONParse,
+"stringify",JSONStringify
+]);
+function DateToJSON(Q){
+var q=(%_ToObject(this));
+var W=(%_ToPrimitive_Number(q));
+if((typeof(W)==='number')&&!(%_IsSmi(%IS_VAR(W))||((W==W)&&(W!=1/0)&&(W!=-1/0)))){
+return null;
+}
+return q.toISOString();
+}
+b.InstallFunctions(c.prototype,2,[
+"toJSON",DateToJSON
+]);
+function JsonSerializeAdapter(Q,X){
+var u={};
+u[Q]=X;
+return JSONSerialize(Q,u,(void 0),new k(),"","");
+}
+%InstallToContext(["json_serialize_adapter",JsonSerializeAdapter]);
+})
+
+8array-iterator�#
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=
+b.ImportNow("array_iteration_kind_symbol");
+var d=
+b.ImportNow("array_iterator_next_symbol");
+var e=
+b.ImportNow("array_iterator_object_symbol");
+var f=a.Array;
+var g=b.ImportNow("IteratorPrototype");
+var h=b.ImportNow("iterator_symbol");
+var i;
+var j=b.ImportNow("to_string_tag_symbol");
+var k=a.Uint8Array.__proto__;
+b.Import(function(l){
+i=l.MakeTypeError;
+})
+function ArrayIterator(){}
+function CreateArrayIterator(m,n){
+var o=(%_ToObject(m));
+var p=new ArrayIterator;
+(p[e]=o);
+(p[d]=0);
+(p[c]=n);
+return p;
+}
+function ArrayIteratorIterator(){
+return this;
+}
+function ArrayIteratorNext(){
+var p=this;
+var q=(void 0);
+var r=true;
+if(!(%_IsJSReceiver(p))||
+!(!(p[d]===(void 0)))){
+throw i(44,
+'Array Iterator.prototype.next',this);
+}
+var m=(p[e]);
+if(!(m===(void 0))){
+var s=(p[d]);
+var t=(p[c]);
+var u=((m.length)>>>0);
+if(s>=u){
+(p[e]=(void 0));
+}else{
+(p[d]=s+1);
+if(t==2){
+q=m[s];
+}else if(t==3){
+q=[s,m[s]];
+}else{
+q=s;
+}
+r=false;
+}
+}
+return %_CreateIterResultObject(q,r);
+}
+function ArrayEntries(){
+return CreateArrayIterator(this,3);
+}
+function ArrayValues(){
+return CreateArrayIterator(this,2);
+}
+function ArrayKeys(){
+return CreateArrayIterator(this,1);
+}
+function TypedArrayEntries(){
+if(!(%_IsTypedArray(this)))throw i(72);
+return %_Call(ArrayEntries,this);
+}
+function TypedArrayValues(){
+if(!(%_IsTypedArray(this)))throw i(72);
+return %_Call(ArrayValues,this);
+}
+function TypedArrayKeys(){
+if(!(%_IsTypedArray(this)))throw i(72);
+return %_Call(ArrayKeys,this);
+}
+%FunctionSetPrototype(ArrayIterator,{__proto__:g});
+%FunctionSetInstanceClassName(ArrayIterator,'Array Iterator');
+b.InstallFunctions(ArrayIterator.prototype,2,[
+'next',ArrayIteratorNext
+]);
+b.SetFunctionName(ArrayIteratorIterator,h);
+%AddNamedProperty(ArrayIterator.prototype,j,
+"Array Iterator",1|2);
+b.InstallFunctions(f.prototype,2,[
+'entries',ArrayEntries,
+'keys',ArrayKeys
+]);
+b.SetFunctionName(ArrayValues,'values');
+%AddNamedProperty(f.prototype,h,ArrayValues,
+2);
+b.InstallFunctions(k.prototype,2,[
+'entries',TypedArrayEntries,
+'keys',TypedArrayKeys,
+'values',TypedArrayValues
+]);
+%AddNamedProperty(k.prototype,
+h,TypedArrayValues,2);
+b.Export(function(v){
+v.ArrayValues=ArrayValues;
+});
+%InstallToContext(["array_values_iterator",ArrayValues]);
+})
+
+<string-iterator�
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.String;
+var d=b.ImportNow("IteratorPrototype");
+var e=b.ImportNow("iterator_symbol");
+var f;
+var g=
+b.ImportNow("string_iterator_iterated_string_symbol");
+var h=
+b.ImportNow("string_iterator_next_index_symbol");
+var i=b.ImportNow("to_string_tag_symbol");
+b.Import(function(j){
+f=j.MakeTypeError;
+});
+function StringIterator(){}
+function CreateStringIterator(k){
+if((%IS_VAR(k)===null)||(k===(void 0)))throw f(18,'String.prototype[Symbol.iterator]');
+var l=(%_ToString(k));
+var m=new StringIterator;
+(m[g]=l);
+(m[h]=0);
+return m;
+}
+function StringIteratorNext(){
+var m=this;
+var n=(void 0);
+var o=true;
+if(!(%_IsJSReceiver(m))||
+!(!(m[h]===(void 0)))){
+throw f(44,
+'String Iterator.prototype.next');
+}
+var l=(m[g]);
+if(!(l===(void 0))){
+var p=(m[h]);
+var q=((l.length)>>>0);
+if(p>=q){
+(m[g]=(void 0));
+}else{
+var r=%_StringCharCodeAt(l,p);
+n=%_StringCharFromCode(r);
+o=false;
+p++;
+if(r>=0xD800&&r<=0xDBFF&&p<q){
+var s=%_StringCharCodeAt(l,p);
+if(s>=0xDC00&&s<=0xDFFF){
+n+=%_StringCharFromCode(s);
+p++;
+}
+}
+(m[h]=p);
+}
+}
+return %_CreateIterResultObject(n,o);
+}
+function StringPrototypeIterator(){
+return CreateStringIterator(this);
+}
+%FunctionSetPrototype(StringIterator,{__proto__:d});
+%FunctionSetInstanceClassName(StringIterator,'String Iterator');
+b.InstallFunctions(StringIterator.prototype,2,[
+'next',StringIteratorNext
+]);
+%AddNamedProperty(StringIterator.prototype,i,
+"String Iterator",1|2);
+b.SetFunctionName(StringPrototypeIterator,e);
+%AddNamedProperty(c.prototype,e,
+StringPrototypeIterator,2);
+})
+
+$templates
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Map;
+var d=b.InternalArray;
+var e=new c;
+var f=c.prototype.get;
+var g=c.prototype.set;
+function SameCallSiteElements(h,i){
+var j=h.length;
+var i=i.raw;
+if(j!==i.length)return false;
+for(var k=0;k<j;++k){
+if(h[k]!==i[k])return false;
+}
+return true;
+}
+function GetCachedCallSite(l,m){
+var n=%_Call(f,e,m);
+if((n===(void 0)))return;
+var j=n.length;
+for(var k=0;k<j;++k){
+if(SameCallSiteElements(l,n[k]))return n[k];
+}
+}
+function SetCachedCallSite(l,m){
+var n=%_Call(f,e,m);
+var o;
+if((n===(void 0))){
+o=new d(1);
+o[0]=l;
+%_Call(g,e,m,o);
+}else{
+n.push(l);
+}
+return l;
+}
+function GetTemplateCallSite(l,h,m){
+var p=GetCachedCallSite(h,m);
+if(!(p===(void 0)))return p;
+%AddNamedProperty(l,"raw",%object_freeze(h),
+1|2|4);
+return SetCachedCallSite(%object_freeze(l),m);
+}
+%InstallToContext(["get_template_call_site",GetTemplateCallSite]);
+})
+
+spread�
+(function(a,b){
+'use strict';
+var c=b.InternalArray;
+var d;
+b.Import(function(e){
+d=e.MakeTypeError;
+});
+function SpreadArguments(){
+var f=arguments.length;
+var g=new c();
+for(var h=0;h<f;++h){
+var i=arguments[h];
+var j=i.length;
+for(var k=0;k<j;++k){
+g.push(i[k]);
+}
+}
+return g;
+}
+function SpreadIterable(l){
+if((l==null)){
+throw d(70,l);
+}
+var g=new c();
+for(var m of l){
+g.push(m);
+}
+return g;
+}
+%InstallToContext([
+"spread_arguments",SpreadArguments,
+"spread_iterable",SpreadIterable,
+]);
+})
+
+proxy�
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Proxy;
+function ProxyCreateRevocable(d,e){
+var f=new c(d,e);
+return{proxy:f,revoke:()=>%JSProxyRevoke(f)};
+}
+b.InstallFunctions(c,2,[
+"revocable",ProxyCreateRevocable
+]);
+})
+
+i18n��

+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c;
+var d;
+var e;
+var f=a.Boolean;
+var g=a.Date;
+var h=a.Number;
+var i=a.RegExp;
+var j=a.String;
+var k=b.InstallFunctions;
+var l=b.InstallGetter;
+var m=b.InternalPackedArray;
+var n;
+var o
+var p;
+var q;
+var r;
+var s;
+var t;
+var u=b.ImportNow("ObjectDefineProperties");
+var v=b.ImportNow("ObjectDefineProperty");
+var w=b.ImportNow("ObjectHasOwnProperty");
+var x=b.OverrideFunction;
+var y=b.ImportNow("intl_pattern_symbol");
+var z=b.ImportNow("intl_resolved_symbol");
+var A=b.SetFunctionName;
+var B;
+var C;
+var D;
+var E;
+var F;
+b.Import(function(G){
+c=G.ArrayIndexOf;
+d=G.ArrayJoin;
+e=G.ArrayPush;
+p=G.IsFinite;
+q=G.IsNaN;
+r=G.MakeError;
+s=G.MakeRangeError;
+t=G.MakeTypeError;
+n=G.InternalRegExpMatch;
+o=G.InternalRegExpReplace;
+B=G.StringIndexOf;
+C=G.StringLastIndexOf;
+D=G.StringSplit;
+E=G.StringSubstr;
+F=G.StringSubstring;
+});
+function InstallFunction(H,I,J){
+k(H,2,[I,J]);
+}
+function InstallConstructor(H,I,J){
+%CheckIsBootstrapping();
+A(J,I);
+%AddNamedProperty(H,I,J,2);
+%SetNativeFlag(J);
+%ToFastProperties(H);
+}
+function AddBoundMethod(K,L,M,N){
+%CheckIsBootstrapping();
+var O=%CreatePrivateSymbol(L);
+var P=function(){
+if(!%IsInitializedIntlObject(this)){
+throw t(54,L);
+}
+if((this[O]===(void 0))){
+var Q;
+if((N===(void 0))||N===2){
+Q=(x,y)=>M(this,x,y);
+}else if(N===1){
+Q=x=>M(this,x);
+}else{
+Q=(...args)=>{
+if(args.length>0){
+return M(this,args[0]);
+}else{
+return M(this);
+}
+}
+}
+%FunctionSetName(Q,'__bound'+L+'__');
+%FunctionRemovePrototype(Q);
+%SetNativeFlag(Q);
+this[O]=Q;
+}
+return this[O];
+};
+l(K.prototype,L,P,2);
+}
+var R={};
+%AddNamedProperty(a,"Intl",R,2);
+var S={
+'collator':(void 0),
+'numberformat':(void 0),
+'dateformat':(void 0),
+'breakiterator':(void 0)
+};
+var T=(void 0);
+var U=(void 0);
+function GetUnicodeExtensionRE(){
+if(((void 0)===(void 0))){
+U=new i('-u(-[a-z0-9]{2,8})+','g');
+}
+return U;
+}
+var V=(void 0);
+function GetAnyExtensionRE(){
+if((V===(void 0))){
+V=new i('-[a-z0-9]{1}-.*','g');
+}
+return V;
+}
+var W=(void 0);
+function GetQuotedStringRE(){
+if((W===(void 0))){
+W=new i("'[^']+'",'g');
+}
+return W;
+}
+var X=(void 0);
+function GetServiceRE(){
+if((X===(void 0))){
+X=
+new i('^(collator|numberformat|dateformat|breakiterator)$');
+}
+return X;
+}
+var Y=(void 0);
+function GetLanguageTagRE(){
+if((Y===(void 0))){
+BuildLanguageTagREs();
+}
+return Y;
+}
+var Z=(void 0);
+function GetLanguageVariantRE(){
+if((Z===(void 0))){
+BuildLanguageTagREs();
+}
+return Z;
+}
+var aa=(void 0);
+function GetLanguageSingletonRE(){
+if((aa===(void 0))){
+BuildLanguageTagREs();
+}
+return aa;
+}
+var ab=(void 0);
+function GetTimezoneNameCheckRE(){
+if((ab===(void 0))){
+ab=new i(
+'^([A-Za-z]+)/([A-Za-z_-]+)((?:\/[A-Za-z_-]+)+)*$');
+}
+return ab;
+}
+var ac=(void 0);
+function GetTimezoneNameLocationPartRE(){
+if((ac===(void 0))){
+ac=
+new i('^([A-Za-z]+)((?:[_-][A-Za-z]+)+)*$');
+}
+return ac;
+}
+function supportedLocalesOf(ad,ae,af){
+if((n(GetServiceRE(),ad)===null)){
+throw r(7,ad);
+}
+if((af===(void 0))){
+af={};
+}else{
+af=(%_ToObject(af));
+}
+var ag=af.localeMatcher;
+if(!(ag===(void 0))){
+ag=j(ag);
+if(ag!=='lookup'&&ag!=='best fit'){
+throw s(182,ag);
+}
+}else{
+ag='best fit';
+}
+var ah=initializeLocaleList(ae);
+if((S[ad]===(void 0))){
+S[ad]=getAvailableLocalesOf(ad);
+}
+if(ag==='best fit'){
+return initializeLocaleList(bestFitSupportedLocalesOf(
+ah,S[ad]));
+}
+return initializeLocaleList(lookupSupportedLocalesOf(
+ah,S[ad]));
+}
+function lookupSupportedLocalesOf(ah,ai){
+var aj=[];
+for(var ak=0;ak<ah.length;++ak){
+var al=o(
+GetUnicodeExtensionRE(),ah[ak],'');
+do{
+if(!(ai[al]===(void 0))){
+%_Call(e,aj,ah[ak]);
+break;
+}
+var am=%_Call(C,al,'-');
+if(am===-1){
+break;
+}
+al=%_Call(F,al,0,am);
+}while(true);
+}
+return aj;
+}
+function bestFitSupportedLocalesOf(ah,ai){
+return lookupSupportedLocalesOf(ah,ai);
+}
+function getGetOption(af,an){
+if((af===(void 0)))throw r(4,an);
+var ao=function getOption(ap,aq,ar,as){
+if(!(af[ap]===(void 0))){
+var at=af[ap];
+switch(aq){
+case'boolean':
+at=f(at);
+break;
+case'string':
+at=j(at);
+break;
+case'number':
+at=h(at);
+break;
+default:
+throw r(8);
+}
+if(!(ar===(void 0))&&%_Call(c,ar,at)===-1){
+throw s(192,at,an,ap);
+}
+return at;
+}
+return as;
+}
+return ao;
+}
+function resolveLocale(ad,ah,af){
+ah=initializeLocaleList(ah);
+var ao=getGetOption(af,ad);
+var ag=ao('localeMatcher','string',
+['lookup','best fit'],'best fit');
+var au;
+if(ag==='lookup'){
+au=lookupMatcher(ad,ah);
+}else{
+au=bestFitMatcher(ad,ah);
+}
+return au;
+}
+function lookupMatcher(ad,ah){
+if((n(GetServiceRE(),ad)===null)){
+throw r(7,ad);
+}
+if((S[ad]===(void 0))){
+S[ad]=getAvailableLocalesOf(ad);
+}
+for(var ak=0;ak<ah.length;++ak){
+var al=o(
+GetAnyExtensionRE(),ah[ak],'');
+do{
+if(!(S[ad][al]===(void 0))){
+var av=n(
+GetUnicodeExtensionRE(),ah[ak]);
+var aw=(av===null)?'':av[0];
+return{'locale':al,'extension':aw,'position':ak};
+}
+var am=%_Call(C,al,'-');
+if(am===-1){
+break;
+}
+al=%_Call(F,al,0,am);
+}while(true);
+}
+if((T===(void 0))){
+T=%GetDefaultICULocale();
+}
+return{'locale':T,'extension':'','position':-1};
+}
+function bestFitMatcher(ad,ah){
+return lookupMatcher(ad,ah);
+}
+function parseExtension(aw){
+var ax=%_Call(D,aw,'-');
+if(ax.length<=2||
+(ax[0]!==''&&ax[1]!=='u')){
+return{};
+}
+var ay={};
+var az=(void 0);
+for(var ak=2;ak<ax.length;++ak){
+var N=ax[ak].length;
+var aA=ax[ak];
+if(N===2){
+ay[aA]=(void 0);
+az=aA;
+}else if(N>=3&&N<=8&&!(az===(void 0))){
+ay[az]=aA;
+az=(void 0);
+}else{
+return{};
+}
+}
+return ay;
+}
+function setOptions(aB,ay,aC,ao,aD){
+var aw='';
+var aE=function updateExtension(aF,at){
+return'-'+aF+'-'+j(at);
+}
+var aG=function updateProperty(ap,aq,at){
+if(aq==='boolean'&&(typeof at==='string')){
+at=(at==='true')?true:false;
+}
+if(!(ap===(void 0))){
+defineWEProperty(aD,ap,at);
+}
+}
+for(var aF in aC){
+if((%_Call(w,aC,aF))){
+var at=(void 0);
+var aH=aC[aF];
+if(!(aH.property===(void 0))){
+at=ao(aH.property,aH.type,aH.values);
+}
+if(!(at===(void 0))){
+aG(aH.property,aH.type,at);
+aw+=aE(aF,at);
+continue;
+}
+if((%_Call(w,ay,aF))){
+at=ay[aF];
+if(!(at===(void 0))){
+aG(aH.property,aH.type,at);
+aw+=aE(aF,at);
+}else if(aH.type==='boolean'){
+aG(aH.property,aH.type,true);
+aw+=aE(aF,true);
+}
+}
+}
+}
+return aw===''?'':'-u'+aw;
+}
+function freezeArray(aI){
+var aJ=aI.length;
+for(var ak=0;ak<aJ;ak++){
+if(ak in aI){
+v(aI,ak,{value:aI[ak],
+configurable:false,
+writable:false,
+enumerable:true});
+}
+}
+v(aI,'length',{value:aJ,writable:false});
+return aI;
+}
+function getOptimalLanguageTag(aK,au){
+if(aK===au){
+return aK;
+}
+var ae=%GetLanguageTagVariants([aK,au]);
+if(ae[0].maximized!==ae[1].maximized){
+return au;
+}
+var aL=new i('^'+ae[1].base,'g');
+return o(aL,au,ae[0].base);
+}
+function getAvailableLocalesOf(ad){
+var aM=%AvailableLocalesOf(ad);
+for(var ak in aM){
+if((%_Call(w,aM,ak))){
+var aN=n(
+/^([a-z]{2,3})-([A-Z][a-z]{3})-([A-Z]{2})$/,ak);
+if(!(aN===null)){
+aM[aN[1]+'-'+aN[3]]=null;
+}
+}
+}
+return aM;
+}
+function defineWEProperty(H,ap,at){
+v(H,ap,
+{value:at,writable:true,enumerable:true});
+}
+function addWEPropertyIfDefined(H,ap,at){
+if(!(at===(void 0))){
+defineWEProperty(H,ap,at);
+}
+}
+function defineWECProperty(H,ap,at){
+v(H,ap,{value:at,
+writable:true,
+enumerable:true,
+configurable:true});
+}
+function addWECPropertyIfDefined(H,ap,at){
+if(!(at===(void 0))){
+defineWECProperty(H,ap,at);
+}
+}
+function toTitleCaseWord(aO){
+return %StringToUpperCase(%_Call(E,aO,0,1))+
+%StringToLowerCase(%_Call(E,aO,1));
+}
+function toTitleCaseTimezoneLocation(aP){
+var aQ=n(GetTimezoneNameLocationPartRE(),aP)
+if((aQ===null))throw s(161,aP);
+var aR=toTitleCaseWord(aQ[1]);
+if(!(aQ[2]===(void 0))&&2<aQ.length){
+var aS=%_Call(F,aQ[2],0,1);
+var aN=%_Call(D,aQ[2],aS);
+for(var ak=1;ak<aN.length;ak++){
+var aT=aN[ak]
+var aU=%StringToLowerCase(aT);
+aR=aR+aS+
+((aU!=='es'&&
+aU!=='of'&&aU!=='au')?
+toTitleCaseWord(aT):aU);
+}
+}
+return aR;
+}
+function canonicalizeLanguageTag(aV){
+if(typeof aV!=='string'&&typeof aV!=='object'||
+(aV===null)){
+throw t(53);
+}
+var aW=j(aV);
+if(isValidLanguageTag(aW)===false){
+throw s(173,aW);
+}
+var aX=%CanonicalizeLanguageTag(aW);
+if(aX==='invalid-tag'){
+throw s(173,aW);
+}
+return aX;
+}
+function initializeLocaleList(ae){
+var aY=[];
+if((ae===(void 0))){
+aY=[];
+}else{
+if(typeof ae==='string'){
+%_Call(e,aY,canonicalizeLanguageTag(ae));
+return freezeArray(aY);
+}
+var aZ=(%_ToObject(ae));
+var ba=((aZ.length)>>>0);
+for(var bb=0;bb<ba;bb++){
+if(bb in aZ){
+var at=aZ[bb];
+var aX=canonicalizeLanguageTag(at);
+if(%_Call(c,aY,aX)===-1){
+%_Call(e,aY,aX);
+}
+}
+}
+}
+return freezeArray(aY);
+}
+function isValidLanguageTag(al){
+if((n(GetLanguageTagRE(),al)===null)){
+return false;
+}
+if(%_Call(B,al,'x-')===0){
+return true;
+}
+al=%_Call(D,al,'-x-')[0];
+var bc=[];
+var bd=[];
+var aN=%_Call(D,al,'-');
+for(var ak=1;ak<aN.length;ak++){
+var at=aN[ak];
+if(!(n(GetLanguageVariantRE(),at)===null)&&
+bd.length===0){
+if(%_Call(c,bc,at)===-1){
+%_Call(e,bc,at);
+}else{
+return false;
+}
+}
+if(!(n(GetLanguageSingletonRE(),at)===null)){
+if(%_Call(c,bd,at)===-1){
+%_Call(e,bd,at);
+}else{
+return false;
+}
+}
+}
+return true;
+}
+function BuildLanguageTagREs(){
+var be='[a-zA-Z]';
+var bf='[0-9]';
+var bg='('+be+'|'+bf+')';
+var bh='(art-lojban|cel-gaulish|no-bok|no-nyn|zh-guoyu|zh-hakka|'+
+'zh-min|zh-min-nan|zh-xiang)';
+var bi='(en-GB-oed|i-ami|i-bnn|i-default|i-enochian|i-hak|'+
+'i-klingon|i-lux|i-mingo|i-navajo|i-pwn|i-tao|i-tay|'+
+'i-tsu|sgn-BE-FR|sgn-BE-NL|sgn-CH-DE)';
+var bj='('+bi+'|'+bh+')';
+var bk='(x(-'+bg+'{1,8})+)';
+var bl='('+bf+'|[A-WY-Za-wy-z])';
+aa=new i('^'+bl+'$','i');
+var aw='('+bl+'(-'+bg+'{2,8})+)';
+var bm='('+bg+'{5,8}|('+bf+bg+'{3}))';
+Z=new i('^'+bm+'$','i');
+var bn='('+be+'{2}|'+bf+'{3})';
+var bo='('+be+'{4})';
+var bp='('+be+'{3}(-'+be+'{3}){0,2})';
+var bq='('+be+'{2,3}(-'+bp+')?|'+be+'{4}|'+
+be+'{5,8})';
+var br=bq+'(-'+bo+')?(-'+bn+')?(-'+
+bm+')*(-'+aw+')*(-'+bk+')?';
+var bs=
+'^('+br+'|'+bk+'|'+bj+')$';
+Y=new i(bs,'i');
+}
+var bt={
+get(){
+%IncrementUseCounter(16);
+return this[z];
+},
+set(at){
+this[z]=at;
+}
+};
+function initializeCollator(bu,ae,af){
+if(%IsInitializedIntlObject(bu)){
+throw t(135,"Collator");
+}
+if((af===(void 0))){
+af={};
+}
+var ao=getGetOption(af,'collator');
+var bv={};
+defineWEProperty(bv,'usage',ao(
+'usage','string',['sort','search'],'sort'));
+var bw=ao('sensitivity','string',
+['base','accent','case','variant']);
+if((bw===(void 0))&&bv.usage==='sort'){
+bw='variant';
+}
+defineWEProperty(bv,'sensitivity',bw);
+defineWEProperty(bv,'ignorePunctuation',ao(
+'ignorePunctuation','boolean',(void 0),false));
+var al=resolveLocale('collator',ae,af);
+var ay=parseExtension(al.extension);
+var bx={
+'kn':{'property':'numeric','type':'boolean'},
+'kf':{'property':'caseFirst','type':'string',
+'values':['false','lower','upper']}
+};
+setOptions(
+af,ay,bx,ao,bv);
+var by='default';
+var aw='';
+if((%_Call(w,ay,'co'))&&bv.usage==='sort'){
+var bz=[
+'big5han','dict','direct','ducet','gb2312','phonebk','phonetic',
+'pinyin','reformed','searchjl','stroke','trad','unihan','zhuyin'
+];
+if(%_Call(c,bz,ay.co)!==-1){
+aw='-u-co-'+ay.co;
+by=ay.co;
+}
+}else if(bv.usage==='search'){
+aw='-u-co-search';
+}
+defineWEProperty(bv,'collation',by);
+var bA=al.locale+aw;
+var au=u({},{
+caseFirst:{writable:true},
+collation:{value:bv.collation,writable:true},
+ignorePunctuation:{writable:true},
+locale:{writable:true},
+numeric:{writable:true},
+requestedLocale:{value:bA,writable:true},
+sensitivity:{writable:true},
+strength:{writable:true},
+usage:{value:bv.usage,writable:true}
+});
+var bB=%CreateCollator(bA,
+bv,
+au);
+%MarkAsInitializedIntlObjectOfType(bu,'collator',bB);
+bu[z]=au;
+v(bu,'resolved',bt);
+return bu;
+}
+InstallConstructor(R,'Collator',function(){
+var ae=arguments[0];
+var af=arguments[1];
+if(!this||this===R){
+return new R.Collator(ae,af);
+}
+return initializeCollator((%_ToObject(this)),ae,af);
+}
+);
+InstallFunction(R.Collator.prototype,'resolvedOptions',function(){
+if(!(new.target===(void 0))){
+throw t(91);
+}
+if(!%IsInitializedIntlObjectOfType(this,'collator')){
+throw t(136,"Collator");
+}
+var bC=this;
+var al=getOptimalLanguageTag(bC[z].requestedLocale,
+bC[z].locale);
+return{
+locale:al,
+usage:bC[z].usage,
+sensitivity:bC[z].sensitivity,
+ignorePunctuation:bC[z].ignorePunctuation,
+numeric:bC[z].numeric,
+caseFirst:bC[z].caseFirst,
+collation:bC[z].collation
+};
+}
+);
+InstallFunction(R.Collator,'supportedLocalesOf',function(ae){
+if(!(new.target===(void 0))){
+throw t(91);
+}
+return supportedLocalesOf('collator',ae,arguments[1]);
+}
+);
+function compare(bu,bD,bE){
+return %InternalCompare(%GetImplFromInitializedIntlObject(bu),
+j(bD),j(bE));
+};
+AddBoundMethod(R.Collator,'compare',compare,2);
+function isWellFormedCurrencyCode(bF){
+return typeof bF=="string"&&bF.length==3&&
+(n(/[^A-Za-z]/,bF)===null);
+}
+function getNumberOption(af,ap,bG,bH,bI){
+var at=af[ap];
+if(!(at===(void 0))){
+at=h(at);
+if(q(at)||at<bG||at>bH){
+throw s(185,ap);
+}
+return %math_floor(at);
+}
+return bI;
+}
+var bJ={
+get(){
+%IncrementUseCounter(15);
+return this[y];
+},
+set(at){
+this[y]=at;
+}
+};
+function initializeNumberFormat(bK,ae,af){
+if(%IsInitializedIntlObject(bK)){
+throw t(135,"NumberFormat");
+}
+if((af===(void 0))){
+af={};
+}
+var ao=getGetOption(af,'numberformat');
+var al=resolveLocale('numberformat',ae,af);
+var bv={};
+defineWEProperty(bv,'style',ao(
+'style','string',['decimal','percent','currency'],'decimal'));
+var bF=ao('currency','string');
+if(!(bF===(void 0))&&!isWellFormedCurrencyCode(bF)){
+throw s(168,bF);
+}
+if(bv.style==='currency'&&(bF===(void 0))){
+throw t(30);
+}
+var bL=ao(
+'currencyDisplay','string',['code','symbol','name'],'symbol');
+if(bv.style==='currency'){
+defineWEProperty(bv,'currency',%StringToUpperCase(bF));
+defineWEProperty(bv,'currencyDisplay',bL);
+}
+var bM=getNumberOption(af,'minimumIntegerDigits',1,21,1);
+defineWEProperty(bv,'minimumIntegerDigits',bM);
+var bN=af['minimumFractionDigits'];
+var bO=af['maximumFractionDigits'];
+if(!(bN===(void 0))||bv.style!=='currency'){
+bN=getNumberOption(af,'minimumFractionDigits',0,20,0);
+defineWEProperty(bv,'minimumFractionDigits',bN);
+}
+if(!(bO===(void 0))||bv.style!=='currency'){
+var bP=bv.style==='percent'?0:3;
+bN=(bN===(void 0))?0:bN;
+var bQ=(bN>bP)?bN:bP;
+bO=getNumberOption(af,'maximumFractionDigits',bN,20,bQ);
+defineWEProperty(bv,'maximumFractionDigits',bO);
+}
+var bR=af['minimumSignificantDigits'];
+var bS=af['maximumSignificantDigits'];
+if(!(bR===(void 0))||!(bS===(void 0))){
+bR=getNumberOption(af,'minimumSignificantDigits',1,21,0);
+defineWEProperty(bv,'minimumSignificantDigits',bR);
+bS=getNumberOption(af,'maximumSignificantDigits',bR,21,21);
+defineWEProperty(bv,'maximumSignificantDigits',bS);
+}
+defineWEProperty(bv,'useGrouping',ao(
+'useGrouping','boolean',(void 0),true));
+var ay=parseExtension(al.extension);
+var bT={
+'nu':{'property':(void 0),'type':'string'}
+};
+var aw=setOptions(af,ay,bT,
+ao,bv);
+var bA=al.locale+aw;
+var au=u({},{
+currency:{writable:true},
+currencyDisplay:{writable:true},
+locale:{writable:true},
+maximumFractionDigits:{writable:true},
+minimumFractionDigits:{writable:true},
+minimumIntegerDigits:{writable:true},
+numberingSystem:{writable:true},
+pattern:bJ,
+requestedLocale:{value:bA,writable:true},
+style:{value:bv.style,writable:true},
+useGrouping:{writable:true}
+});
+if((%_Call(w,bv,'minimumSignificantDigits'))){
+defineWEProperty(au,'minimumSignificantDigits',(void 0));
+}
+if((%_Call(w,bv,'maximumSignificantDigits'))){
+defineWEProperty(au,'maximumSignificantDigits',(void 0));
+}
+var bU=%CreateNumberFormat(bA,
+bv,
+au);
+if(bv.style==='currency'){
+v(au,'currencyDisplay',{value:bL,
+writable:true});
+}
+%MarkAsInitializedIntlObjectOfType(bK,'numberformat',bU);
+bK[z]=au;
+v(bK,'resolved',bt);
+return bK;
+}
+InstallConstructor(R,'NumberFormat',function(){
+var ae=arguments[0];
+var af=arguments[1];
+if(!this||this===R){
+return new R.NumberFormat(ae,af);
+}
+return initializeNumberFormat((%_ToObject(this)),ae,af);
+}
+);
+InstallFunction(R.NumberFormat.prototype,'resolvedOptions',function(){
+if(!(new.target===(void 0))){
+throw t(91);
+}
+if(!%IsInitializedIntlObjectOfType(this,'numberformat')){
+throw t(136,"NumberFormat");
+}
+var bV=this;
+var al=getOptimalLanguageTag(bV[z].requestedLocale,
+bV[z].locale);
+var aR={
+locale:al,
+numberingSystem:bV[z].numberingSystem,
+style:bV[z].style,
+useGrouping:bV[z].useGrouping,
+minimumIntegerDigits:bV[z].minimumIntegerDigits,
+minimumFractionDigits:bV[z].minimumFractionDigits,
+maximumFractionDigits:bV[z].maximumFractionDigits,
+};
+if(aR.style==='currency'){
+defineWECProperty(aR,'currency',bV[z].currency);
+defineWECProperty(aR,'currencyDisplay',
+bV[z].currencyDisplay);
+}
+if((%_Call(w,bV[z],'minimumSignificantDigits'))){
+defineWECProperty(aR,'minimumSignificantDigits',
+bV[z].minimumSignificantDigits);
+}
+if((%_Call(w,bV[z],'maximumSignificantDigits'))){
+defineWECProperty(aR,'maximumSignificantDigits',
+bV[z].maximumSignificantDigits);
+}
+return aR;
+}
+);
+InstallFunction(R.NumberFormat,'supportedLocalesOf',function(ae){
+if(!(new.target===(void 0))){
+throw t(91);
+}
+return supportedLocalesOf('numberformat',ae,arguments[1]);
+}
+);
+function formatNumber(bU,at){
+var bW=(%_ToNumber(at))+0;
+return %InternalNumberFormat(%GetImplFromInitializedIntlObject(bU),
+bW);
+}
+function parseNumber(bU,at){
+return %InternalNumberParse(%GetImplFromInitializedIntlObject(bU),
+j(at));
+}
+AddBoundMethod(R.NumberFormat,'format',formatNumber,1);
+AddBoundMethod(R.NumberFormat,'v8Parse',parseNumber,1);
+function toLDMLString(af){
+var ao=getGetOption(af,'dateformat');
+var bX='';
+var bY=ao('weekday','string',['narrow','short','long']);
+bX+=appendToLDMLString(
+bY,{narrow:'EEEEE',short:'EEE',long:'EEEE'});
+bY=ao('era','string',['narrow','short','long']);
+bX+=appendToLDMLString(
+bY,{narrow:'GGGGG',short:'GGG',long:'GGGG'});
+bY=ao('year','string',['2-digit','numeric']);
+bX+=appendToLDMLString(bY,{'2-digit':'yy','numeric':'y'});
+bY=ao('month','string',
+['2-digit','numeric','narrow','short','long']);
+bX+=appendToLDMLString(bY,{'2-digit':'MM','numeric':'M',
+'narrow':'MMMMM','short':'MMM','long':'MMMM'});
+bY=ao('day','string',['2-digit','numeric']);
+bX+=appendToLDMLString(
+bY,{'2-digit':'dd','numeric':'d'});
+var bZ=ao('hour12','boolean');
+bY=ao('hour','string',['2-digit','numeric']);
+if((bZ===(void 0))){
+bX+=appendToLDMLString(bY,{'2-digit':'jj','numeric':'j'});
+}else if(bZ===true){
+bX+=appendToLDMLString(bY,{'2-digit':'hh','numeric':'h'});
+}else{
+bX+=appendToLDMLString(bY,{'2-digit':'HH','numeric':'H'});
+}
+bY=ao('minute','string',['2-digit','numeric']);
+bX+=appendToLDMLString(bY,{'2-digit':'mm','numeric':'m'});
+bY=ao('second','string',['2-digit','numeric']);
+bX+=appendToLDMLString(bY,{'2-digit':'ss','numeric':'s'});
+bY=ao('timeZoneName','string',['short','long']);
+bX+=appendToLDMLString(bY,{short:'z',long:'zzzz'});
+return bX;
+}
+function appendToLDMLString(bY,ca){
+if(!(bY===(void 0))){
+return ca[bY];
+}else{
+return'';
+}
+}
+function fromLDMLString(bX){
+bX=o(GetQuotedStringRE(),bX,'');
+var af={};
+var aQ=n(/E{3,5}/,bX);
+af=appendToDateTimeObject(
+af,'weekday',aQ,{EEEEE:'narrow',EEE:'short',EEEE:'long'});
+aQ=n(/G{3,5}/,bX);
+af=appendToDateTimeObject(
+af,'era',aQ,{GGGGG:'narrow',GGG:'short',GGGG:'long'});
+aQ=n(/y{1,2}/,bX);
+af=appendToDateTimeObject(
+af,'year',aQ,{y:'numeric',yy:'2-digit'});
+aQ=n(/M{1,5}/,bX);
+af=appendToDateTimeObject(af,'month',aQ,{MM:'2-digit',
+M:'numeric',MMMMM:'narrow',MMM:'short',MMMM:'long'});
+aQ=n(/L{1,5}/,bX);
+af=appendToDateTimeObject(af,'month',aQ,{LL:'2-digit',
+L:'numeric',LLLLL:'narrow',LLL:'short',LLLL:'long'});
+aQ=n(/d{1,2}/,bX);
+af=appendToDateTimeObject(
+af,'day',aQ,{d:'numeric',dd:'2-digit'});
+aQ=n(/h{1,2}/,bX);
+if(aQ!==null){
+af['hour12']=true;
+}
+af=appendToDateTimeObject(
+af,'hour',aQ,{h:'numeric',hh:'2-digit'});
+aQ=n(/H{1,2}/,bX);
+if(aQ!==null){
+af['hour12']=false;
+}
+af=appendToDateTimeObject(
+af,'hour',aQ,{H:'numeric',HH:'2-digit'});
+aQ=n(/m{1,2}/,bX);
+af=appendToDateTimeObject(
+af,'minute',aQ,{m:'numeric',mm:'2-digit'});
+aQ=n(/s{1,2}/,bX);
+af=appendToDateTimeObject(
+af,'second',aQ,{s:'numeric',ss:'2-digit'});
+aQ=n(/z|zzzz/,bX);
+af=appendToDateTimeObject(
+af,'timeZoneName',aQ,{z:'short',zzzz:'long'});
+return af;
+}
+function appendToDateTimeObject(af,bY,aQ,ca){
+if((aQ===null)){
+if(!(%_Call(w,af,bY))){
+defineWEProperty(af,bY,(void 0));
+}
+return af;
+}
+var ap=aQ[0];
+defineWEProperty(af,bY,ca[ap]);
+return af;
+}
+function toDateTimeOptions(af,cb,cc){
+if((af===(void 0))){
+af={};
+}else{
+af=(%_ToObject(af));
+}
+var cd=true;
+if((cb==='date'||cb==='any')&&
+(!(af.weekday===(void 0))||!(af.year===(void 0))||
+!(af.month===(void 0))||!(af.day===(void 0)))){
+cd=false;
+}
+if((cb==='time'||cb==='any')&&
+(!(af.hour===(void 0))||!(af.minute===(void 0))||
+!(af.second===(void 0)))){
+cd=false;
+}
+if(cd&&(cc==='date'||cc==='all')){
+v(af,'year',{value:'numeric',
+writable:true,
+enumerable:true,
+configurable:true});
+v(af,'month',{value:'numeric',
+writable:true,
+enumerable:true,
+configurable:true});
+v(af,'day',{value:'numeric',
+writable:true,
+enumerable:true,
+configurable:true});
+}
+if(cd&&(cc==='time'||cc==='all')){
+v(af,'hour',{value:'numeric',
+writable:true,
+enumerable:true,
+configurable:true});
+v(af,'minute',{value:'numeric',
+writable:true,
+enumerable:true,
+configurable:true});
+v(af,'second',{value:'numeric',
+writable:true,
+enumerable:true,
+configurable:true});
+}
+return af;
+}
+function initializeDateTimeFormat(ce,ae,af){
+if(%IsInitializedIntlObject(ce)){
+throw t(135,"DateTimeFormat");
+}
+if((af===(void 0))){
+af={};
+}
+var al=resolveLocale('dateformat',ae,af);
+af=toDateTimeOptions(af,'any','date');
+var ao=getGetOption(af,'dateformat');
+var ag=ao('formatMatcher','string',
+['basic','best fit'],'best fit');
+var bX=toLDMLString(af);
+var cf=canonicalizeTimeZoneID(af.timeZone);
+var bv={};
+var ay=parseExtension(al.extension);
+var cg={
+'ca':{'property':(void 0),'type':'string'},
+'nu':{'property':(void 0),'type':'string'}
+};
+var aw=setOptions(af,ay,cg,
+ao,bv);
+var bA=al.locale+aw;
+var au=u({},{
+calendar:{writable:true},
+day:{writable:true},
+era:{writable:true},
+hour12:{writable:true},
+hour:{writable:true},
+locale:{writable:true},
+minute:{writable:true},
+month:{writable:true},
+numberingSystem:{writable:true},
+[y]:{writable:true},
+pattern:bJ,
+requestedLocale:{value:bA,writable:true},
+second:{writable:true},
+timeZone:{writable:true},
+timeZoneName:{writable:true},
+tz:{value:cf,writable:true},
+weekday:{writable:true},
+year:{writable:true}
+});
+var bU=%CreateDateTimeFormat(
+bA,{skeleton:bX,timeZone:cf},au);
+if(au.timeZone==="Etc/Unknown"){
+throw s(191,cf);
+}
+%MarkAsInitializedIntlObjectOfType(ce,'dateformat',bU);
+ce[z]=au;
+v(ce,'resolved',bt);
+return ce;
+}
+InstallConstructor(R,'DateTimeFormat',function(){
+var ae=arguments[0];
+var af=arguments[1];
+if(!this||this===R){
+return new R.DateTimeFormat(ae,af);
+}
+return initializeDateTimeFormat((%_ToObject(this)),ae,af);
+}
+);
+InstallFunction(R.DateTimeFormat.prototype,'resolvedOptions',function(){
+if(!(new.target===(void 0))){
+throw t(91);
+}
+if(!%IsInitializedIntlObjectOfType(this,'dateformat')){
+throw t(136,"DateTimeFormat");
+}
+var ch={
+'gregorian':'gregory',
+'japanese':'japanese',
+'buddhist':'buddhist',
+'roc':'roc',
+'persian':'persian',
+'islamic-civil':'islamicc',
+'islamic':'islamic',
+'hebrew':'hebrew',
+'chinese':'chinese',
+'indian':'indian',
+'coptic':'coptic',
+'ethiopic':'ethiopic',
+'ethiopic-amete-alem':'ethioaa'
+};
+var bV=this;
+var ci=fromLDMLString(bV[z][y]);
+var cj=ch[bV[z].calendar];
+if((cj===(void 0))){
+cj=bV[z].calendar;
+}
+var al=getOptimalLanguageTag(bV[z].requestedLocale,
+bV[z].locale);
+var aR={
+locale:al,
+numberingSystem:bV[z].numberingSystem,
+calendar:cj,
+timeZone:bV[z].timeZone
+};
+addWECPropertyIfDefined(aR,'timeZoneName',ci.timeZoneName);
+addWECPropertyIfDefined(aR,'era',ci.era);
+addWECPropertyIfDefined(aR,'year',ci.year);
+addWECPropertyIfDefined(aR,'month',ci.month);
+addWECPropertyIfDefined(aR,'day',ci.day);
+addWECPropertyIfDefined(aR,'weekday',ci.weekday);
+addWECPropertyIfDefined(aR,'hour12',ci.hour12);
+addWECPropertyIfDefined(aR,'hour',ci.hour);
+addWECPropertyIfDefined(aR,'minute',ci.minute);
+addWECPropertyIfDefined(aR,'second',ci.second);
+return aR;
+}
+);
+InstallFunction(R.DateTimeFormat,'supportedLocalesOf',function(ae){
+if(!(new.target===(void 0))){
+throw t(91);
+}
+return supportedLocalesOf('dateformat',ae,arguments[1]);
+}
+);
+function formatDate(bU,ck){
+var cl;
+if((ck===(void 0))){
+cl=%DateCurrentTime();
+}else{
+cl=(%_ToNumber(ck));
+}
+if(!p(cl))throw s(159);
+return %InternalDateFormat(%GetImplFromInitializedIntlObject(bU),
+new g(cl));
+}
+function parseDate(bU,at){
+return %InternalDateParse(%GetImplFromInitializedIntlObject(bU),
+j(at));
+}
+AddBoundMethod(R.DateTimeFormat,'format',formatDate,0);
+AddBoundMethod(R.DateTimeFormat,'v8Parse',parseDate,1);
+function canonicalizeTimeZoneID(cm){
+if((cm===(void 0))){
+return cm;
+}
+var cn=%StringToUpperCase(cm);
+if(cn==='UTC'||cn==='GMT'||
+cn==='ETC/UTC'||cn==='ETC/GMT'){
+return'UTC';
+}
+var aQ=n(GetTimezoneNameCheckRE(),cm);
+if((aQ===null))throw s(160,cm);
+var aR=toTitleCaseTimezoneLocation(aQ[1])+'/'+
+toTitleCaseTimezoneLocation(aQ[2]);
+if(!(aQ[3]===(void 0))&&3<aQ.length){
+var co=%_Call(D,aQ[3],'/');
+for(var ak=1;ak<co.length;ak++){
+aR=aR+'/'+toTitleCaseTimezoneLocation(co[ak]);
+}
+}
+return aR;
+}
+function initializeBreakIterator(cp,ae,af){
+if(%IsInitializedIntlObject(cp)){
+throw t(135,"v8BreakIterator");
+}
+if((af===(void 0))){
+af={};
+}
+var ao=getGetOption(af,'breakiterator');
+var bv={};
+defineWEProperty(bv,'type',ao(
+'type','string',['character','word','sentence','line'],'word'));
+var al=resolveLocale('breakiterator',ae,af);
+var au=u({},{
+requestedLocale:{value:al.locale,writable:true},
+type:{value:bv.type,writable:true},
+locale:{writable:true}
+});
+var cq=%CreateBreakIterator(al.locale,
+bv,
+au);
+%MarkAsInitializedIntlObjectOfType(cp,'breakiterator',
+cq);
+cp[z]=au;
+v(cp,'resolved',bt);
+return cp;
+}
+InstallConstructor(R,'v8BreakIterator',function(){
+var ae=arguments[0];
+var af=arguments[1];
+if(!this||this===R){
+return new R.v8BreakIterator(ae,af);
+}
+return initializeBreakIterator((%_ToObject(this)),ae,af);
+}
+);
+InstallFunction(R.v8BreakIterator.prototype,'resolvedOptions',
+function(){
+if(!(new.target===(void 0))){
+throw t(91);
+}
+if(!%IsInitializedIntlObjectOfType(this,'breakiterator')){
+throw t(136,"v8BreakIterator");
+}
+var cr=this;
+var al=
+getOptimalLanguageTag(cr[z].requestedLocale,
+cr[z].locale);
+return{
+locale:al,
+type:cr[z].type
+};
+}
+);
+InstallFunction(R.v8BreakIterator,'supportedLocalesOf',
+function(ae){
+if(!(new.target===(void 0))){
+throw t(91);
+}
+return supportedLocalesOf('breakiterator',ae,arguments[1]);
+}
+);
+function adoptText(cp,cs){
+%BreakIteratorAdoptText(%GetImplFromInitializedIntlObject(cp),
+j(cs));
+}
+function first(cp){
+return %BreakIteratorFirst(%GetImplFromInitializedIntlObject(cp));
+}
+function next(cp){
+return %BreakIteratorNext(%GetImplFromInitializedIntlObject(cp));
+}
+function current(cp){
+return %BreakIteratorCurrent(%GetImplFromInitializedIntlObject(cp));
+}
+function breakType(cp){
+return %BreakIteratorBreakType(%GetImplFromInitializedIntlObject(cp));
+}
+AddBoundMethod(R.v8BreakIterator,'adoptText',adoptText,1);
+AddBoundMethod(R.v8BreakIterator,'first',first,0);
+AddBoundMethod(R.v8BreakIterator,'next',next,0);
+AddBoundMethod(R.v8BreakIterator,'current',current,0);
+AddBoundMethod(R.v8BreakIterator,'breakType',breakType,0);
+var ct={
+'collator':R.Collator,
+'numberformat':R.NumberFormat,
+'dateformatall':R.DateTimeFormat,
+'dateformatdate':R.DateTimeFormat,
+'dateformattime':R.DateTimeFormat
+};
+var cu={
+'collator':(void 0),
+'numberformat':(void 0),
+'dateformatall':(void 0),
+'dateformatdate':(void 0),
+'dateformattime':(void 0),
+};
+function cachedOrNewService(ad,ae,af,cc){
+var cv=((cc===(void 0)))?af:cc;
+if((ae===(void 0))&&(af===(void 0))){
+if((cu[ad]===(void 0))){
+cu[ad]=new ct[ad](ae,cv);
+}
+return cu[ad];
+}
+return new ct[ad](ae,cv);
+}
+x(j.prototype,'localeCompare',function(cw){
+if(!(new.target===(void 0))){
+throw t(91);
+}
+if((this==null)){
+throw t(55);
+}
+var ae=arguments[1];
+var af=arguments[2];
+var bu=cachedOrNewService('collator',ae,af);
+return compare(bu,this,cw);
+}
+);
+x(j.prototype,'normalize',function(){
+if(!(new.target===(void 0))){
+throw t(91);
+}
+if((%IS_VAR(this)===null)||(this===(void 0)))throw t(18,"String.prototype.normalize");
+var cx=(%_ToString(this));
+var cy=arguments[0];
+var cz=(cy===(void 0))?'NFC':(%_ToString(cy));
+var cA=['NFC','NFD','NFKC','NFKD'];
+var cB=%_Call(c,cA,cz);
+if(cB===-1){
+throw s(183,
+%_Call(d,cA,', '));
+}
+return %StringNormalize(cx,cB);
+}
+);
+x(h.prototype,'toLocaleString',function(){
+if(!(new.target===(void 0))){
+throw t(91);
+}
+if(!(this instanceof h)&&typeof(this)!=='number'){
+throw t(56,"Number");
+}
+var ae=arguments[0];
+var af=arguments[1];
+var bK=cachedOrNewService('numberformat',ae,af);
+return formatNumber(bK,this);
+}
+);
+function toLocaleDateTime(cC,ae,af,cb,cc,ad){
+if(!(cC instanceof g)){
+throw t(56,"Date");
+}
+if(q(cC))return'Invalid Date';
+var bv=toDateTimeOptions(af,cb,cc);
+var ce=
+cachedOrNewService(ad,ae,af,bv);
+return formatDate(ce,cC);
+}
+x(g.prototype,'toLocaleString',function(){
+if(!(new.target===(void 0))){
+throw t(91);
+}
+var ae=arguments[0];
+var af=arguments[1];
+return toLocaleDateTime(
+this,ae,af,'any','all','dateformatall');
+}
+);
+x(g.prototype,'toLocaleDateString',function(){
+if(!(new.target===(void 0))){
+throw t(91);
+}
+var ae=arguments[0];
+var af=arguments[1];
+return toLocaleDateTime(
+this,ae,af,'date','date','dateformatdate');
+}
+);
+x(g.prototype,'toLocaleTimeString',function(){
+if(!(new.target===(void 0))){
+throw t(91);
+}
+var ae=arguments[0];
+var af=arguments[1];
+return toLocaleDateTime(
+this,ae,af,'time','time','dateformattime');
+}
+);
+})
+
+($generator

+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=b.ImportNow("GeneratorFunctionPrototype");
+var d=b.ImportNow("GeneratorFunction");
+var e=a.Function;
+var f;
+var g=b.ImportNow("to_string_tag_symbol");
+b.Import(function(h){
+f=h.MakeTypeError;
+});
+function GeneratorObjectNext(i){
+if(!(%_ClassOf(this)==='Generator')){
+throw f(44,
+'[Generator].prototype.next',this);
+}
+var j=%GeneratorGetContinuation(this);
+if(j>0){
+if(%_DebugIsActive()!=0)%DebugPrepareStepInIfStepping(this);
+return %_GeneratorNext(this,i);
+}else if(j==0){
+return %_CreateIterResultObject((void 0),true);
+}else{
+throw f(42);
+}
+}
+function GeneratorObjectReturn(i){
+if(!(%_ClassOf(this)==='Generator')){
+throw f(44,
+'[Generator].prototype.return',this);
+}
+var j=%GeneratorGetContinuation(this);
+if(j>0){
+if(%_DebugIsActive()!=0)%DebugPrepareStepInIfStepping(this);
+return %_GeneratorReturn(this,i);
+}else if(j==0){
+return %_CreateIterResultObject(i,true);
+}else{
+throw f(42);
+}
+}
+function GeneratorObjectThrow(k){
+if(!(%_ClassOf(this)==='Generator')){
+throw f(44,
+'[Generator].prototype.throw',this);
+}
+var j=%GeneratorGetContinuation(this);
+if(j>0){
+if(%_DebugIsActive()!=0)%DebugPrepareStepInIfStepping(this);
+return %_GeneratorThrow(this,k);
+}else if(j==0){
+throw k;
+}else{
+throw f(42);
+}
+}
+%NeverOptimizeFunction(GeneratorObjectNext);
+%NeverOptimizeFunction(GeneratorObjectReturn);
+%NeverOptimizeFunction(GeneratorObjectThrow);
+var l=c.prototype;
+b.InstallFunctions(l,
+2,
+["next",GeneratorObjectNext,
+"return",GeneratorObjectReturn,
+"throw",GeneratorObjectThrow]);
+%AddNamedProperty(l,"constructor",
+c,2|1);
+%AddNamedProperty(l,
+g,"Generator",2|1);
+%InternalSetPrototype(c,e.prototype);
+%AddNamedProperty(c,
+g,"GeneratorFunction",2|1);
+%AddNamedProperty(c,"constructor",
+d,2|1);
+%InternalSetPrototype(d,e);
+})
+
+<harmony-atomicsu8
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Object;
+var d;
+var e;
+var f;
+var g=b.ImportNow("to_string_tag_symbol");
+b.Import(function(h){
+e=h.MakeTypeError;
+d=h.MakeRangeError;
+f=h.MaxSimple;
+});
+function CheckSharedIntegerTypedArray(i){
+if(!%IsSharedIntegerTypedArray(i)){
+throw e(74,i);
+}
+}
+function CheckSharedInteger32TypedArray(i){
+CheckSharedIntegerTypedArray(i);
+if(!%IsSharedInteger32TypedArray(i)){
+throw e(75,i);
+}
+}
+function ValidateIndex(j,k){
+var l=(%_ToNumber(j));
+var m=(%_ToInteger(l));
+if(l!==m){
+throw d(165);
+}
+if(m<0||m>=k){
+throw d(165);
+}
+return m;
+}
+function AtomicsCompareExchangeJS(n,j,o,p){
+CheckSharedIntegerTypedArray(n);
+j=ValidateIndex(j,%_TypedArrayGetLength(n));
+o=(%_ToNumber(o));
+p=(%_ToNumber(p));
+return %_AtomicsCompareExchange(n,j,o,p);
+}
+function AtomicsLoadJS(n,j){
+CheckSharedIntegerTypedArray(n);
+j=ValidateIndex(j,%_TypedArrayGetLength(n));
+return %_AtomicsLoad(n,j);
+}
+function AtomicsStoreJS(n,j,q){
+CheckSharedIntegerTypedArray(n);
+j=ValidateIndex(j,%_TypedArrayGetLength(n));
+q=(%_ToNumber(q));
+return %_AtomicsStore(n,j,q);
+}
+function AtomicsAddJS(i,j,q){
+CheckSharedIntegerTypedArray(i);
+j=ValidateIndex(j,%_TypedArrayGetLength(i));
+q=(%_ToNumber(q));
+return %_AtomicsAdd(i,j,q);
+}
+function AtomicsSubJS(i,j,q){
+CheckSharedIntegerTypedArray(i);
+j=ValidateIndex(j,%_TypedArrayGetLength(i));
+q=(%_ToNumber(q));
+return %_AtomicsSub(i,j,q);
+}
+function AtomicsAndJS(i,j,q){
+CheckSharedIntegerTypedArray(i);
+j=ValidateIndex(j,%_TypedArrayGetLength(i));
+q=(%_ToNumber(q));
+return %_AtomicsAnd(i,j,q);
+}
+function AtomicsOrJS(i,j,q){
+CheckSharedIntegerTypedArray(i);
+j=ValidateIndex(j,%_TypedArrayGetLength(i));
+q=(%_ToNumber(q));
+return %_AtomicsOr(i,j,q);
+}
+function AtomicsXorJS(i,j,q){
+CheckSharedIntegerTypedArray(i);
+j=ValidateIndex(j,%_TypedArrayGetLength(i));
+q=(%_ToNumber(q));
+return %_AtomicsXor(i,j,q);
+}
+function AtomicsExchangeJS(i,j,q){
+CheckSharedIntegerTypedArray(i);
+j=ValidateIndex(j,%_TypedArrayGetLength(i));
+q=(%_ToNumber(q));
+return %_AtomicsExchange(i,j,q);
+}
+function AtomicsIsLockFreeJS(r){
+return %_AtomicsIsLockFree(r);
+}
+function AtomicsFutexWaitJS(i,j,q,s){
+CheckSharedInteger32TypedArray(i);
+j=ValidateIndex(j,%_TypedArrayGetLength(i));
+if((s===(void 0))){
+s=(1/0);
+}else{
+s=(%_ToNumber(s));
+if((!%_IsSmi(%IS_VAR(s))&&!(s==s))){
+s=(1/0);
+}else{
+s=f(0,s);
+}
+}
+return %AtomicsFutexWait(i,j,q,s);
+}
+function AtomicsFutexWakeJS(i,j,t){
+CheckSharedInteger32TypedArray(i);
+j=ValidateIndex(j,%_TypedArrayGetLength(i));
+t=f(0,(%_ToInteger(t)));
+return %AtomicsFutexWake(i,j,t);
+}
+function AtomicsFutexWakeOrRequeueJS(i,u,t,q,v){
+CheckSharedInteger32TypedArray(i);
+u=ValidateIndex(u,%_TypedArrayGetLength(i));
+t=f(0,(%_ToInteger(t)));
+q=((q)|0);
+v=ValidateIndex(v,%_TypedArrayGetLength(i));
+if(u<0||u>=%_TypedArrayGetLength(i)||
+v<0||v>=%_TypedArrayGetLength(i)){
+return(void 0);
+}
+return %AtomicsFutexWakeOrRequeue(i,u,t,q,v);
+}
+function AtomicsConstructor(){}
+var w=new AtomicsConstructor();
+%InternalSetPrototype(w,c.prototype);
+%AddNamedProperty(a,"Atomics",w,2);
+%FunctionSetInstanceClassName(AtomicsConstructor,'Atomics');
+%AddNamedProperty(w,g,"Atomics",1|2);
+b.InstallConstants(w,[
+"OK",0,
+"NOTEQUAL",-1,
+"TIMEDOUT",-2,
+]);
+b.InstallFunctions(w,2,[
+"compareExchange",AtomicsCompareExchangeJS,
+"load",AtomicsLoadJS,
+"store",AtomicsStoreJS,
+"add",AtomicsAddJS,
+"sub",AtomicsSubJS,
+"and",AtomicsAndJS,
+"or",AtomicsOrJS,
+"xor",AtomicsXorJS,
+"exchange",AtomicsExchangeJS,
+"isLockFree",AtomicsIsLockFreeJS,
+"futexWait",AtomicsFutexWaitJS,
+"futexWake",AtomicsFutexWakeJS,
+"futexWakeOrRequeue",AtomicsFutexWakeOrRequeueJS,
+]);
+})
+
+Lharmony-regexp-execa
+(function(a,b){
+%CheckIsBootstrapping();
+var c=a.RegExp;
+var d=b.ImportNow("RegExpSubclassExecJS");
+var e=b.ImportNow("RegExpSubclassMatch");
+var f=b.ImportNow("RegExpSubclassReplace");
+var g=b.ImportNow("RegExpSubclassSearch");
+var h=b.ImportNow("RegExpSubclassSplit");
+var i=b.ImportNow("RegExpSubclassTest");
+var j=b.ImportNow("match_symbol");
+var k=b.ImportNow("replace_symbol");
+var l=b.ImportNow("search_symbol");
+var m=b.ImportNow("split_symbol");
+b.OverrideFunction(c.prototype,"exec",
+d,true);
+b.OverrideFunction(c.prototype,j,
+e,true);
+b.OverrideFunction(c.prototype,k,
+f,true);
+b.OverrideFunction(c.prototype,l,
+g,true);
+b.OverrideFunction(c.prototype,m,
+h,true);
+b.OverrideFunction(c.prototype,"test",
+i,true);
+})
+
+Xharmony-object-observeU
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=b.ImportNow("ObserveArrayMethods");
+var d=b.ImportNow("ObserveObjectMethods");;
+b.InstallFunctions(a.Object,2,d);
+b.InstallFunctions(a.Array,2,c);
+})
+
+dharmony-sharedarraybufferE
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.SharedArrayBuffer;
+var d;
+b.Import(function(e){
+d=e.MakeTypeError;
+})
+function SharedArrayBufferGetByteLen(){
+if(!(%_ClassOf(this)==='SharedArrayBuffer')){
+throw d(44,
+'SharedArrayBuffer.prototype.byteLength',this);
+}
+return %_ArrayBufferGetByteLength(this);
+}
+b.InstallGetter(c.prototype,"byteLength",
+SharedArrayBufferGetByteLen);
+})
+
+0harmony-simd��
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.SIMD;
+var d;
+var e=b.ImportNow("to_string_tag_symbol");
+b.Import(function(f){
+d=f.MakeTypeError;
+});
+var g=c.Float32x4;
+
+
+var h=c.Int32x4;
+
+var i=c.Int16x8;
+
+var j=c.Int8x16;
+
+
+var k=c.Uint32x4;
+
+var l=c.Uint16x8;
+
+var m=c.Uint8x16;
+
+
+var n=c.Bool32x4;
+
+var o=c.Bool16x8;
+
+var p=c.Bool8x16;
+
+
+
+function Float32x4CheckJS(q){
+return %Float32x4Check(q);
+}
+function Float32x4ToString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='float32x4'){
+throw d(44,
+"Float32x4.prototype.toString",this);
+}
+var s="SIMD.Float32x4(";
+s+=%Float32x4ExtractLane(r,0);
+for(var t=1;t<4;t++){
+s+=", "+%Float32x4ExtractLane(r,t);
+}
+return s+")";
+}
+function Float32x4ToLocaleString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='float32x4'){
+throw d(44,
+"Float32x4.prototype.toLocaleString",this);
+}
+var s="SIMD.Float32x4(";
+s+=%Float32x4ExtractLane(r,0).toLocaleString();
+for(var t=1;t<4;t++){
+s+=", "+%Float32x4ExtractLane(r,t).toLocaleString();
+}
+return s+")";
+}
+function Float32x4ValueOf(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='float32x4'){
+throw d(44,
+"Float32x4.prototype.valueOf",this);
+}
+return r;
+}
+function Float32x4ExtractLaneJS(u,v){
+return %Float32x4ExtractLane(u,v);
+}
+
+
+function Int32x4CheckJS(q){
+return %Int32x4Check(q);
+}
+function Int32x4ToString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='int32x4'){
+throw d(44,
+"Int32x4.prototype.toString",this);
+}
+var s="SIMD.Int32x4(";
+s+=%Int32x4ExtractLane(r,0);
+for(var t=1;t<4;t++){
+s+=", "+%Int32x4ExtractLane(r,t);
+}
+return s+")";
+}
+function Int32x4ToLocaleString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='int32x4'){
+throw d(44,
+"Int32x4.prototype.toLocaleString",this);
+}
+var s="SIMD.Int32x4(";
+s+=%Int32x4ExtractLane(r,0).toLocaleString();
+for(var t=1;t<4;t++){
+s+=", "+%Int32x4ExtractLane(r,t).toLocaleString();
+}
+return s+")";
+}
+function Int32x4ValueOf(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='int32x4'){
+throw d(44,
+"Int32x4.prototype.valueOf",this);
+}
+return r;
+}
+function Int32x4ExtractLaneJS(u,v){
+return %Int32x4ExtractLane(u,v);
+}
+
+function Int16x8CheckJS(q){
+return %Int16x8Check(q);
+}
+function Int16x8ToString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='int16x8'){
+throw d(44,
+"Int16x8.prototype.toString",this);
+}
+var s="SIMD.Int16x8(";
+s+=%Int16x8ExtractLane(r,0);
+for(var t=1;t<8;t++){
+s+=", "+%Int16x8ExtractLane(r,t);
+}
+return s+")";
+}
+function Int16x8ToLocaleString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='int16x8'){
+throw d(44,
+"Int16x8.prototype.toLocaleString",this);
+}
+var s="SIMD.Int16x8(";
+s+=%Int16x8ExtractLane(r,0).toLocaleString();
+for(var t=1;t<8;t++){
+s+=", "+%Int16x8ExtractLane(r,t).toLocaleString();
+}
+return s+")";
+}
+function Int16x8ValueOf(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='int16x8'){
+throw d(44,
+"Int16x8.prototype.valueOf",this);
+}
+return r;
+}
+function Int16x8ExtractLaneJS(u,v){
+return %Int16x8ExtractLane(u,v);
+}
+
+function Int8x16CheckJS(q){
+return %Int8x16Check(q);
+}
+function Int8x16ToString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='int8x16'){
+throw d(44,
+"Int8x16.prototype.toString",this);
+}
+var s="SIMD.Int8x16(";
+s+=%Int8x16ExtractLane(r,0);
+for(var t=1;t<16;t++){
+s+=", "+%Int8x16ExtractLane(r,t);
+}
+return s+")";
+}
+function Int8x16ToLocaleString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='int8x16'){
+throw d(44,
+"Int8x16.prototype.toLocaleString",this);
+}
+var s="SIMD.Int8x16(";
+s+=%Int8x16ExtractLane(r,0).toLocaleString();
+for(var t=1;t<16;t++){
+s+=", "+%Int8x16ExtractLane(r,t).toLocaleString();
+}
+return s+")";
+}
+function Int8x16ValueOf(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='int8x16'){
+throw d(44,
+"Int8x16.prototype.valueOf",this);
+}
+return r;
+}
+function Int8x16ExtractLaneJS(u,v){
+return %Int8x16ExtractLane(u,v);
+}
+
+
+function Uint32x4CheckJS(q){
+return %Uint32x4Check(q);
+}
+function Uint32x4ToString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='uint32x4'){
+throw d(44,
+"Uint32x4.prototype.toString",this);
+}
+var s="SIMD.Uint32x4(";
+s+=%Uint32x4ExtractLane(r,0);
+for(var t=1;t<4;t++){
+s+=", "+%Uint32x4ExtractLane(r,t);
+}
+return s+")";
+}
+function Uint32x4ToLocaleString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='uint32x4'){
+throw d(44,
+"Uint32x4.prototype.toLocaleString",this);
+}
+var s="SIMD.Uint32x4(";
+s+=%Uint32x4ExtractLane(r,0).toLocaleString();
+for(var t=1;t<4;t++){
+s+=", "+%Uint32x4ExtractLane(r,t).toLocaleString();
+}
+return s+")";
+}
+function Uint32x4ValueOf(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='uint32x4'){
+throw d(44,
+"Uint32x4.prototype.valueOf",this);
+}
+return r;
+}
+function Uint32x4ExtractLaneJS(u,v){
+return %Uint32x4ExtractLane(u,v);
+}
+
+function Uint16x8CheckJS(q){
+return %Uint16x8Check(q);
+}
+function Uint16x8ToString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='uint16x8'){
+throw d(44,
+"Uint16x8.prototype.toString",this);
+}
+var s="SIMD.Uint16x8(";
+s+=%Uint16x8ExtractLane(r,0);
+for(var t=1;t<8;t++){
+s+=", "+%Uint16x8ExtractLane(r,t);
+}
+return s+")";
+}
+function Uint16x8ToLocaleString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='uint16x8'){
+throw d(44,
+"Uint16x8.prototype.toLocaleString",this);
+}
+var s="SIMD.Uint16x8(";
+s+=%Uint16x8ExtractLane(r,0).toLocaleString();
+for(var t=1;t<8;t++){
+s+=", "+%Uint16x8ExtractLane(r,t).toLocaleString();
+}
+return s+")";
+}
+function Uint16x8ValueOf(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='uint16x8'){
+throw d(44,
+"Uint16x8.prototype.valueOf",this);
+}
+return r;
+}
+function Uint16x8ExtractLaneJS(u,v){
+return %Uint16x8ExtractLane(u,v);
+}
+
+function Uint8x16CheckJS(q){
+return %Uint8x16Check(q);
+}
+function Uint8x16ToString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='uint8x16'){
+throw d(44,
+"Uint8x16.prototype.toString",this);
+}
+var s="SIMD.Uint8x16(";
+s+=%Uint8x16ExtractLane(r,0);
+for(var t=1;t<16;t++){
+s+=", "+%Uint8x16ExtractLane(r,t);
+}
+return s+")";
+}
+function Uint8x16ToLocaleString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='uint8x16'){
+throw d(44,
+"Uint8x16.prototype.toLocaleString",this);
+}
+var s="SIMD.Uint8x16(";
+s+=%Uint8x16ExtractLane(r,0).toLocaleString();
+for(var t=1;t<16;t++){
+s+=", "+%Uint8x16ExtractLane(r,t).toLocaleString();
+}
+return s+")";
+}
+function Uint8x16ValueOf(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='uint8x16'){
+throw d(44,
+"Uint8x16.prototype.valueOf",this);
+}
+return r;
+}
+function Uint8x16ExtractLaneJS(u,v){
+return %Uint8x16ExtractLane(u,v);
+}
+
+
+function Bool32x4CheckJS(q){
+return %Bool32x4Check(q);
+}
+function Bool32x4ToString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='bool32x4'){
+throw d(44,
+"Bool32x4.prototype.toString",this);
+}
+var s="SIMD.Bool32x4(";
+s+=%Bool32x4ExtractLane(r,0);
+for(var t=1;t<4;t++){
+s+=", "+%Bool32x4ExtractLane(r,t);
+}
+return s+")";
+}
+function Bool32x4ToLocaleString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='bool32x4'){
+throw d(44,
+"Bool32x4.prototype.toLocaleString",this);
+}
+var s="SIMD.Bool32x4(";
+s+=%Bool32x4ExtractLane(r,0).toLocaleString();
+for(var t=1;t<4;t++){
+s+=", "+%Bool32x4ExtractLane(r,t).toLocaleString();
+}
+return s+")";
+}
+function Bool32x4ValueOf(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='bool32x4'){
+throw d(44,
+"Bool32x4.prototype.valueOf",this);
+}
+return r;
+}
+function Bool32x4ExtractLaneJS(u,v){
+return %Bool32x4ExtractLane(u,v);
+}
+
+function Bool16x8CheckJS(q){
+return %Bool16x8Check(q);
+}
+function Bool16x8ToString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='bool16x8'){
+throw d(44,
+"Bool16x8.prototype.toString",this);
+}
+var s="SIMD.Bool16x8(";
+s+=%Bool16x8ExtractLane(r,0);
+for(var t=1;t<8;t++){
+s+=", "+%Bool16x8ExtractLane(r,t);
+}
+return s+")";
+}
+function Bool16x8ToLocaleString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='bool16x8'){
+throw d(44,
+"Bool16x8.prototype.toLocaleString",this);
+}
+var s="SIMD.Bool16x8(";
+s+=%Bool16x8ExtractLane(r,0).toLocaleString();
+for(var t=1;t<8;t++){
+s+=", "+%Bool16x8ExtractLane(r,t).toLocaleString();
+}
+return s+")";
+}
+function Bool16x8ValueOf(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='bool16x8'){
+throw d(44,
+"Bool16x8.prototype.valueOf",this);
+}
+return r;
+}
+function Bool16x8ExtractLaneJS(u,v){
+return %Bool16x8ExtractLane(u,v);
+}
+
+function Bool8x16CheckJS(q){
+return %Bool8x16Check(q);
+}
+function Bool8x16ToString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='bool8x16'){
+throw d(44,
+"Bool8x16.prototype.toString",this);
+}
+var s="SIMD.Bool8x16(";
+s+=%Bool8x16ExtractLane(r,0);
+for(var t=1;t<16;t++){
+s+=", "+%Bool8x16ExtractLane(r,t);
+}
+return s+")";
+}
+function Bool8x16ToLocaleString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='bool8x16'){
+throw d(44,
+"Bool8x16.prototype.toLocaleString",this);
+}
+var s="SIMD.Bool8x16(";
+s+=%Bool8x16ExtractLane(r,0).toLocaleString();
+for(var t=1;t<16;t++){
+s+=", "+%Bool8x16ExtractLane(r,t).toLocaleString();
+}
+return s+")";
+}
+function Bool8x16ValueOf(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='bool8x16'){
+throw d(44,
+"Bool8x16.prototype.valueOf",this);
+}
+return r;
+}
+function Bool8x16ExtractLaneJS(u,v){
+return %Bool8x16ExtractLane(u,v);
+}
+
+
+
+function Int32x4ShiftLeftByScalarJS(u,w){
+return %Int32x4ShiftLeftByScalar(u,w);
+}
+function Int32x4ShiftRightByScalarJS(u,w){
+return %Int32x4ShiftRightByScalar(u,w);
+}
+
+function Int16x8ShiftLeftByScalarJS(u,w){
+return %Int16x8ShiftLeftByScalar(u,w);
+}
+function Int16x8ShiftRightByScalarJS(u,w){
+return %Int16x8ShiftRightByScalar(u,w);
+}
+
+function Int8x16ShiftLeftByScalarJS(u,w){
+return %Int8x16ShiftLeftByScalar(u,w);
+}
+function Int8x16ShiftRightByScalarJS(u,w){
+return %Int8x16ShiftRightByScalar(u,w);
+}
+
+
+function Uint32x4ShiftLeftByScalarJS(u,w){
+return %Uint32x4ShiftLeftByScalar(u,w);
+}
+function Uint32x4ShiftRightByScalarJS(u,w){
+return %Uint32x4ShiftRightByScalar(u,w);
+}
+
+function Uint16x8ShiftLeftByScalarJS(u,w){
+return %Uint16x8ShiftLeftByScalar(u,w);
+}
+function Uint16x8ShiftRightByScalarJS(u,w){
+return %Uint16x8ShiftRightByScalar(u,w);
+}
+
+function Uint8x16ShiftLeftByScalarJS(u,w){
+return %Uint8x16ShiftLeftByScalar(u,w);
+}
+function Uint8x16ShiftRightByScalarJS(u,w){
+return %Uint8x16ShiftRightByScalar(u,w);
+}
+
+
+function Int16x8AddSaturateJS(q,x){
+return %Int16x8AddSaturate(q,x);
+}
+function Int16x8SubSaturateJS(q,x){
+return %Int16x8SubSaturate(q,x);
+}
+
+function Int8x16AddSaturateJS(q,x){
+return %Int8x16AddSaturate(q,x);
+}
+function Int8x16SubSaturateJS(q,x){
+return %Int8x16SubSaturate(q,x);
+}
+
+function Uint8x16AddSaturateJS(q,x){
+return %Uint8x16AddSaturate(q,x);
+}
+function Uint8x16SubSaturateJS(q,x){
+return %Uint8x16SubSaturate(q,x);
+}
+
+function Uint16x8AddSaturateJS(q,x){
+return %Uint16x8AddSaturate(q,x);
+}
+function Uint16x8SubSaturateJS(q,x){
+return %Uint16x8SubSaturate(q,x);
+}
+
+
+function Float32x4NegJS(q){
+return %Float32x4Neg(q);
+}
+
+
+function Int32x4NegJS(q){
+return %Int32x4Neg(q);
+}
+
+function Int16x8NegJS(q){
+return %Int16x8Neg(q);
+}
+
+function Int8x16NegJS(q){
+return %Int8x16Neg(q);
+}
+
+
+function Bool32x4ReplaceLaneJS(u,v,r){
+return %Bool32x4ReplaceLane(u,v,r);
+}
+function Bool32x4AnyTrueJS(y){
+return %Bool32x4AnyTrue(y);
+}
+function Bool32x4AllTrueJS(y){
+return %Bool32x4AllTrue(y);
+}
+
+function Bool16x8ReplaceLaneJS(u,v,r){
+return %Bool16x8ReplaceLane(u,v,r);
+}
+function Bool16x8AnyTrueJS(y){
+return %Bool16x8AnyTrue(y);
+}
+function Bool16x8AllTrueJS(y){
+return %Bool16x8AllTrue(y);
+}
+
+function Bool8x16ReplaceLaneJS(u,v,r){
+return %Bool8x16ReplaceLane(u,v,r);
+}
+function Bool8x16AnyTrueJS(y){
+return %Bool8x16AnyTrue(y);
+}
+function Bool8x16AllTrueJS(y){
+return %Bool8x16AllTrue(y);
+}
+
+
+function Float32x4ReplaceLaneJS(u,v,r){
+return %Float32x4ReplaceLane(u,v,(%_ToNumber(r)));
+}
+function Float32x4SelectJS(z,q,x){
+return %Float32x4Select(z,q,x);
+}
+function Float32x4AddJS(q,x){
+return %Float32x4Add(q,x);
+}
+function Float32x4SubJS(q,x){
+return %Float32x4Sub(q,x);
+}
+function Float32x4MulJS(q,x){
+return %Float32x4Mul(q,x);
+}
+function Float32x4MinJS(q,x){
+return %Float32x4Min(q,x);
+}
+function Float32x4MaxJS(q,x){
+return %Float32x4Max(q,x);
+}
+function Float32x4EqualJS(q,x){
+return %Float32x4Equal(q,x);
+}
+function Float32x4NotEqualJS(q,x){
+return %Float32x4NotEqual(q,x);
+}
+function Float32x4LessThanJS(q,x){
+return %Float32x4LessThan(q,x);
+}
+function Float32x4LessThanOrEqualJS(q,x){
+return %Float32x4LessThanOrEqual(q,x);
+}
+function Float32x4GreaterThanJS(q,x){
+return %Float32x4GreaterThan(q,x);
+}
+function Float32x4GreaterThanOrEqualJS(q,x){
+return %Float32x4GreaterThanOrEqual(q,x);
+}
+function Float32x4LoadJS(A,B){
+return %Float32x4Load(A,B);
+}
+function Float32x4StoreJS(A,B,q){
+return %Float32x4Store(A,B,q);
+}
+
+
+function Int32x4ReplaceLaneJS(u,v,r){
+return %Int32x4ReplaceLane(u,v,(%_ToNumber(r)));
+}
+function Int32x4SelectJS(z,q,x){
+return %Int32x4Select(z,q,x);
+}
+function Int32x4AddJS(q,x){
+return %Int32x4Add(q,x);
+}
+function Int32x4SubJS(q,x){
+return %Int32x4Sub(q,x);
+}
+function Int32x4MulJS(q,x){
+return %Int32x4Mul(q,x);
+}
+function Int32x4MinJS(q,x){
+return %Int32x4Min(q,x);
+}
+function Int32x4MaxJS(q,x){
+return %Int32x4Max(q,x);
+}
+function Int32x4EqualJS(q,x){
+return %Int32x4Equal(q,x);
+}
+function Int32x4NotEqualJS(q,x){
+return %Int32x4NotEqual(q,x);
+}
+function Int32x4LessThanJS(q,x){
+return %Int32x4LessThan(q,x);
+}
+function Int32x4LessThanOrEqualJS(q,x){
+return %Int32x4LessThanOrEqual(q,x);
+}
+function Int32x4GreaterThanJS(q,x){
+return %Int32x4GreaterThan(q,x);
+}
+function Int32x4GreaterThanOrEqualJS(q,x){
+return %Int32x4GreaterThanOrEqual(q,x);
+}
+function Int32x4LoadJS(A,B){
+return %Int32x4Load(A,B);
+}
+function Int32x4StoreJS(A,B,q){
+return %Int32x4Store(A,B,q);
+}
+
+function Int16x8ReplaceLaneJS(u,v,r){
+return %Int16x8ReplaceLane(u,v,(%_ToNumber(r)));
+}
+function Int16x8SelectJS(z,q,x){
+return %Int16x8Select(z,q,x);
+}
+function Int16x8AddJS(q,x){
+return %Int16x8Add(q,x);
+}
+function Int16x8SubJS(q,x){
+return %Int16x8Sub(q,x);
+}
+function Int16x8MulJS(q,x){
+return %Int16x8Mul(q,x);
+}
+function Int16x8MinJS(q,x){
+return %Int16x8Min(q,x);
+}
+function Int16x8MaxJS(q,x){
+return %Int16x8Max(q,x);
+}
+function Int16x8EqualJS(q,x){
+return %Int16x8Equal(q,x);
+}
+function Int16x8NotEqualJS(q,x){
+return %Int16x8NotEqual(q,x);
+}
+function Int16x8LessThanJS(q,x){
+return %Int16x8LessThan(q,x);
+}
+function Int16x8LessThanOrEqualJS(q,x){
+return %Int16x8LessThanOrEqual(q,x);
+}
+function Int16x8GreaterThanJS(q,x){
+return %Int16x8GreaterThan(q,x);
+}
+function Int16x8GreaterThanOrEqualJS(q,x){
+return %Int16x8GreaterThanOrEqual(q,x);
+}
+function Int16x8LoadJS(A,B){
+return %Int16x8Load(A,B);
+}
+function Int16x8StoreJS(A,B,q){
+return %Int16x8Store(A,B,q);
+}
+
+function Int8x16ReplaceLaneJS(u,v,r){
+return %Int8x16ReplaceLane(u,v,(%_ToNumber(r)));
+}
+function Int8x16SelectJS(z,q,x){
+return %Int8x16Select(z,q,x);
+}
+function Int8x16AddJS(q,x){
+return %Int8x16Add(q,x);
+}
+function Int8x16SubJS(q,x){
+return %Int8x16Sub(q,x);
+}
+function Int8x16MulJS(q,x){
+return %Int8x16Mul(q,x);
+}
+function Int8x16MinJS(q,x){
+return %Int8x16Min(q,x);
+}
+function Int8x16MaxJS(q,x){
+return %Int8x16Max(q,x);
+}
+function Int8x16EqualJS(q,x){
+return %Int8x16Equal(q,x);
+}
+function Int8x16NotEqualJS(q,x){
+return %Int8x16NotEqual(q,x);
+}
+function Int8x16LessThanJS(q,x){
+return %Int8x16LessThan(q,x);
+}
+function Int8x16LessThanOrEqualJS(q,x){
+return %Int8x16LessThanOrEqual(q,x);
+}
+function Int8x16GreaterThanJS(q,x){
+return %Int8x16GreaterThan(q,x);
+}
+function Int8x16GreaterThanOrEqualJS(q,x){
+return %Int8x16GreaterThanOrEqual(q,x);
+}
+function Int8x16LoadJS(A,B){
+return %Int8x16Load(A,B);
+}
+function Int8x16StoreJS(A,B,q){
+return %Int8x16Store(A,B,q);
+}
+
+
+function Uint32x4ReplaceLaneJS(u,v,r){
+return %Uint32x4ReplaceLane(u,v,(%_ToNumber(r)));
+}
+function Uint32x4SelectJS(z,q,x){
+return %Uint32x4Select(z,q,x);
+}
+function Uint32x4AddJS(q,x){
+return %Uint32x4Add(q,x);
+}
+function Uint32x4SubJS(q,x){
+return %Uint32x4Sub(q,x);
+}
+function Uint32x4MulJS(q,x){
+return %Uint32x4Mul(q,x);
+}
+function Uint32x4MinJS(q,x){
+return %Uint32x4Min(q,x);
+}
+function Uint32x4MaxJS(q,x){
+return %Uint32x4Max(q,x);
+}
+function Uint32x4EqualJS(q,x){
+return %Uint32x4Equal(q,x);
+}
+function Uint32x4NotEqualJS(q,x){
+return %Uint32x4NotEqual(q,x);
+}
+function Uint32x4LessThanJS(q,x){
+return %Uint32x4LessThan(q,x);
+}
+function Uint32x4LessThanOrEqualJS(q,x){
+return %Uint32x4LessThanOrEqual(q,x);
+}
+function Uint32x4GreaterThanJS(q,x){
+return %Uint32x4GreaterThan(q,x);
+}
+function Uint32x4GreaterThanOrEqualJS(q,x){
+return %Uint32x4GreaterThanOrEqual(q,x);
+}
+function Uint32x4LoadJS(A,B){
+return %Uint32x4Load(A,B);
+}
+function Uint32x4StoreJS(A,B,q){
+return %Uint32x4Store(A,B,q);
+}
+
+function Uint16x8ReplaceLaneJS(u,v,r){
+return %Uint16x8ReplaceLane(u,v,(%_ToNumber(r)));
+}
+function Uint16x8SelectJS(z,q,x){
+return %Uint16x8Select(z,q,x);
+}
+function Uint16x8AddJS(q,x){
+return %Uint16x8Add(q,x);
+}
+function Uint16x8SubJS(q,x){
+return %Uint16x8Sub(q,x);
+}
+function Uint16x8MulJS(q,x){
+return %Uint16x8Mul(q,x);
+}
+function Uint16x8MinJS(q,x){
+return %Uint16x8Min(q,x);
+}
+function Uint16x8MaxJS(q,x){
+return %Uint16x8Max(q,x);
+}
+function Uint16x8EqualJS(q,x){
+return %Uint16x8Equal(q,x);
+}
+function Uint16x8NotEqualJS(q,x){
+return %Uint16x8NotEqual(q,x);
+}
+function Uint16x8LessThanJS(q,x){
+return %Uint16x8LessThan(q,x);
+}
+function Uint16x8LessThanOrEqualJS(q,x){
+return %Uint16x8LessThanOrEqual(q,x);
+}
+function Uint16x8GreaterThanJS(q,x){
+return %Uint16x8GreaterThan(q,x);
+}
+function Uint16x8GreaterThanOrEqualJS(q,x){
+return %Uint16x8GreaterThanOrEqual(q,x);
+}
+function Uint16x8LoadJS(A,B){
+return %Uint16x8Load(A,B);
+}
+function Uint16x8StoreJS(A,B,q){
+return %Uint16x8Store(A,B,q);
+}
+
+function Uint8x16ReplaceLaneJS(u,v,r){
+return %Uint8x16ReplaceLane(u,v,(%_ToNumber(r)));
+}
+function Uint8x16SelectJS(z,q,x){
+return %Uint8x16Select(z,q,x);
+}
+function Uint8x16AddJS(q,x){
+return %Uint8x16Add(q,x);
+}
+function Uint8x16SubJS(q,x){
+return %Uint8x16Sub(q,x);
+}
+function Uint8x16MulJS(q,x){
+return %Uint8x16Mul(q,x);
+}
+function Uint8x16MinJS(q,x){
+return %Uint8x16Min(q,x);
+}
+function Uint8x16MaxJS(q,x){
+return %Uint8x16Max(q,x);
+}
+function Uint8x16EqualJS(q,x){
+return %Uint8x16Equal(q,x);
+}
+function Uint8x16NotEqualJS(q,x){
+return %Uint8x16NotEqual(q,x);
+}
+function Uint8x16LessThanJS(q,x){
+return %Uint8x16LessThan(q,x);
+}
+function Uint8x16LessThanOrEqualJS(q,x){
+return %Uint8x16LessThanOrEqual(q,x);
+}
+function Uint8x16GreaterThanJS(q,x){
+return %Uint8x16GreaterThan(q,x);
+}
+function Uint8x16GreaterThanOrEqualJS(q,x){
+return %Uint8x16GreaterThanOrEqual(q,x);
+}
+function Uint8x16LoadJS(A,B){
+return %Uint8x16Load(A,B);
+}
+function Uint8x16StoreJS(A,B,q){
+return %Uint8x16Store(A,B,q);
+}
+
+
+
+function Int32x4AndJS(q,x){
+return %Int32x4And(q,x);
+}
+function Int32x4OrJS(q,x){
+return %Int32x4Or(q,x);
+}
+function Int32x4XorJS(q,x){
+return %Int32x4Xor(q,x);
+}
+function Int32x4NotJS(q){
+return %Int32x4Not(q);
+}
+
+function Int16x8AndJS(q,x){
+return %Int16x8And(q,x);
+}
+function Int16x8OrJS(q,x){
+return %Int16x8Or(q,x);
+}
+function Int16x8XorJS(q,x){
+return %Int16x8Xor(q,x);
+}
+function Int16x8NotJS(q){
+return %Int16x8Not(q);
+}
+
+function Int8x16AndJS(q,x){
+return %Int8x16And(q,x);
+}
+function Int8x16OrJS(q,x){
+return %Int8x16Or(q,x);
+}
+function Int8x16XorJS(q,x){
+return %Int8x16Xor(q,x);
+}
+function Int8x16NotJS(q){
+return %Int8x16Not(q);
+}
+
+
+function Uint32x4AndJS(q,x){
+return %Uint32x4And(q,x);
+}
+function Uint32x4OrJS(q,x){
+return %Uint32x4Or(q,x);
+}
+function Uint32x4XorJS(q,x){
+return %Uint32x4Xor(q,x);
+}
+function Uint32x4NotJS(q){
+return %Uint32x4Not(q);
+}
+
+function Uint16x8AndJS(q,x){
+return %Uint16x8And(q,x);
+}
+function Uint16x8OrJS(q,x){
+return %Uint16x8Or(q,x);
+}
+function Uint16x8XorJS(q,x){
+return %Uint16x8Xor(q,x);
+}
+function Uint16x8NotJS(q){
+return %Uint16x8Not(q);
+}
+
+function Uint8x16AndJS(q,x){
+return %Uint8x16And(q,x);
+}
+function Uint8x16OrJS(q,x){
+return %Uint8x16Or(q,x);
+}
+function Uint8x16XorJS(q,x){
+return %Uint8x16Xor(q,x);
+}
+function Uint8x16NotJS(q){
+return %Uint8x16Not(q);
+}
+
+
+function Bool32x4AndJS(q,x){
+return %Bool32x4And(q,x);
+}
+function Bool32x4OrJS(q,x){
+return %Bool32x4Or(q,x);
+}
+function Bool32x4XorJS(q,x){
+return %Bool32x4Xor(q,x);
+}
+function Bool32x4NotJS(q){
+return %Bool32x4Not(q);
+}
+
+function Bool16x8AndJS(q,x){
+return %Bool16x8And(q,x);
+}
+function Bool16x8OrJS(q,x){
+return %Bool16x8Or(q,x);
+}
+function Bool16x8XorJS(q,x){
+return %Bool16x8Xor(q,x);
+}
+function Bool16x8NotJS(q){
+return %Bool16x8Not(q);
+}
+
+function Bool8x16AndJS(q,x){
+return %Bool8x16And(q,x);
+}
+function Bool8x16OrJS(q,x){
+return %Bool8x16Or(q,x);
+}
+function Bool8x16XorJS(q,x){
+return %Bool8x16Xor(q,x);
+}
+function Bool8x16NotJS(q){
+return %Bool8x16Not(q);
+}
+
+
+
+function Float32x4FromInt32x4JS(q){
+return %Float32x4FromInt32x4(q);
+}
+
+function Float32x4FromUint32x4JS(q){
+return %Float32x4FromUint32x4(q);
+}
+
+function Int32x4FromFloat32x4JS(q){
+return %Int32x4FromFloat32x4(q);
+}
+
+function Int32x4FromUint32x4JS(q){
+return %Int32x4FromUint32x4(q);
+}
+
+function Uint32x4FromFloat32x4JS(q){
+return %Uint32x4FromFloat32x4(q);
+}
+
+function Uint32x4FromInt32x4JS(q){
+return %Uint32x4FromInt32x4(q);
+}
+
+function Int16x8FromUint16x8JS(q){
+return %Int16x8FromUint16x8(q);
+}
+
+function Uint16x8FromInt16x8JS(q){
+return %Uint16x8FromInt16x8(q);
+}
+
+function Int8x16FromUint8x16JS(q){
+return %Int8x16FromUint8x16(q);
+}
+
+function Uint8x16FromInt8x16JS(q){
+return %Uint8x16FromInt8x16(q);
+}
+
+
+function Float32x4FromInt32x4BitsJS(q){
+return %Float32x4FromInt32x4Bits(q);
+}
+
+function Float32x4FromUint32x4BitsJS(q){
+return %Float32x4FromUint32x4Bits(q);
+}
+
+function Float32x4FromInt16x8BitsJS(q){
+return %Float32x4FromInt16x8Bits(q);
+}
+
+function Float32x4FromUint16x8BitsJS(q){
+return %Float32x4FromUint16x8Bits(q);
+}
+
+function Float32x4FromInt8x16BitsJS(q){
+return %Float32x4FromInt8x16Bits(q);
+}
+
+function Float32x4FromUint8x16BitsJS(q){
+return %Float32x4FromUint8x16Bits(q);
+}
+
+function Int32x4FromFloat32x4BitsJS(q){
+return %Int32x4FromFloat32x4Bits(q);
+}
+
+function Int32x4FromUint32x4BitsJS(q){
+return %Int32x4FromUint32x4Bits(q);
+}
+
+function Int32x4FromInt16x8BitsJS(q){
+return %Int32x4FromInt16x8Bits(q);
+}
+
+function Int32x4FromUint16x8BitsJS(q){
+return %Int32x4FromUint16x8Bits(q);
+}
+
+function Int32x4FromInt8x16BitsJS(q){
+return %Int32x4FromInt8x16Bits(q);
+}
+
+function Int32x4FromUint8x16BitsJS(q){
+return %Int32x4FromUint8x16Bits(q);
+}
+
+function Uint32x4FromFloat32x4BitsJS(q){
+return %Uint32x4FromFloat32x4Bits(q);
+}
+
+function Uint32x4FromInt32x4BitsJS(q){
+return %Uint32x4FromInt32x4Bits(q);
+}
+
+function Uint32x4FromInt16x8BitsJS(q){
+return %Uint32x4FromInt16x8Bits(q);
+}
+
+function Uint32x4FromUint16x8BitsJS(q){
+return %Uint32x4FromUint16x8Bits(q);
+}
+
+function Uint32x4FromInt8x16BitsJS(q){
+return %Uint32x4FromInt8x16Bits(q);
+}
+
+function Uint32x4FromUint8x16BitsJS(q){
+return %Uint32x4FromUint8x16Bits(q);
+}
+
+function Int16x8FromFloat32x4BitsJS(q){
+return %Int16x8FromFloat32x4Bits(q);
+}
+
+function Int16x8FromInt32x4BitsJS(q){
+return %Int16x8FromInt32x4Bits(q);
+}
+
+function Int16x8FromUint32x4BitsJS(q){
+return %Int16x8FromUint32x4Bits(q);
+}
+
+function Int16x8FromUint16x8BitsJS(q){
+return %Int16x8FromUint16x8Bits(q);
+}
+
+function Int16x8FromInt8x16BitsJS(q){
+return %Int16x8FromInt8x16Bits(q);
+}
+
+function Int16x8FromUint8x16BitsJS(q){
+return %Int16x8FromUint8x16Bits(q);
+}
+
+function Uint16x8FromFloat32x4BitsJS(q){
+return %Uint16x8FromFloat32x4Bits(q);
+}
+
+function Uint16x8FromInt32x4BitsJS(q){
+return %Uint16x8FromInt32x4Bits(q);
+}
+
+function Uint16x8FromUint32x4BitsJS(q){
+return %Uint16x8FromUint32x4Bits(q);
+}
+
+function Uint16x8FromInt16x8BitsJS(q){
+return %Uint16x8FromInt16x8Bits(q);
+}
+
+function Uint16x8FromInt8x16BitsJS(q){
+return %Uint16x8FromInt8x16Bits(q);
+}
+
+function Uint16x8FromUint8x16BitsJS(q){
+return %Uint16x8FromUint8x16Bits(q);
+}
+
+function Int8x16FromFloat32x4BitsJS(q){
+return %Int8x16FromFloat32x4Bits(q);
+}
+
+function Int8x16FromInt32x4BitsJS(q){
+return %Int8x16FromInt32x4Bits(q);
+}
+
+function Int8x16FromUint32x4BitsJS(q){
+return %Int8x16FromUint32x4Bits(q);
+}
+
+function Int8x16FromInt16x8BitsJS(q){
+return %Int8x16FromInt16x8Bits(q);
+}
+
+function Int8x16FromUint16x8BitsJS(q){
+return %Int8x16FromUint16x8Bits(q);
+}
+
+function Int8x16FromUint8x16BitsJS(q){
+return %Int8x16FromUint8x16Bits(q);
+}
+
+function Uint8x16FromFloat32x4BitsJS(q){
+return %Uint8x16FromFloat32x4Bits(q);
+}
+
+function Uint8x16FromInt32x4BitsJS(q){
+return %Uint8x16FromInt32x4Bits(q);
+}
+
+function Uint8x16FromUint32x4BitsJS(q){
+return %Uint8x16FromUint32x4Bits(q);
+}
+
+function Uint8x16FromInt16x8BitsJS(q){
+return %Uint8x16FromInt16x8Bits(q);
+}
+
+function Uint8x16FromUint16x8BitsJS(q){
+return %Uint8x16FromUint16x8Bits(q);
+}
+
+function Uint8x16FromInt8x16BitsJS(q){
+return %Uint8x16FromInt8x16Bits(q);
+}
+
+
+function Float32x4Load1JS(A,B){
+return %Float32x4Load1(A,B);
+}
+function Float32x4Store1JS(A,B,q){
+return %Float32x4Store1(A,B,q);
+}
+
+function Float32x4Load2JS(A,B){
+return %Float32x4Load2(A,B);
+}
+function Float32x4Store2JS(A,B,q){
+return %Float32x4Store2(A,B,q);
+}
+
+function Float32x4Load3JS(A,B){
+return %Float32x4Load3(A,B);
+}
+function Float32x4Store3JS(A,B,q){
+return %Float32x4Store3(A,B,q);
+}
+
+function Int32x4Load1JS(A,B){
+return %Int32x4Load1(A,B);
+}
+function Int32x4Store1JS(A,B,q){
+return %Int32x4Store1(A,B,q);
+}
+
+function Int32x4Load2JS(A,B){
+return %Int32x4Load2(A,B);
+}
+function Int32x4Store2JS(A,B,q){
+return %Int32x4Store2(A,B,q);
+}
+
+function Int32x4Load3JS(A,B){
+return %Int32x4Load3(A,B);
+}
+function Int32x4Store3JS(A,B,q){
+return %Int32x4Store3(A,B,q);
+}
+
+function Uint32x4Load1JS(A,B){
+return %Uint32x4Load1(A,B);
+}
+function Uint32x4Store1JS(A,B,q){
+return %Uint32x4Store1(A,B,q);
+}
+
+function Uint32x4Load2JS(A,B){
+return %Uint32x4Load2(A,B);
+}
+function Uint32x4Store2JS(A,B,q){
+return %Uint32x4Store2(A,B,q);
+}
+
+function Uint32x4Load3JS(A,B){
+return %Uint32x4Load3(A,B);
+}
+function Uint32x4Store3JS(A,B,q){
+return %Uint32x4Store3(A,B,q);
+}
+
+
+function Float32x4Splat(y){
+return %CreateFloat32x4(y,y,y,y);
+}
+function Float32x4SwizzleJS(q,C,D,E,F){
+return %Float32x4Swizzle(q,C,D,E,F);
+}
+function Float32x4ShuffleJS(q,x,C,D,E,F){
+return %Float32x4Shuffle(q,x,C,D,E,F);
+}
+
+function Int32x4Splat(y){
+return %CreateInt32x4(y,y,y,y);
+}
+function Int32x4SwizzleJS(q,C,D,E,F){
+return %Int32x4Swizzle(q,C,D,E,F);
+}
+function Int32x4ShuffleJS(q,x,C,D,E,F){
+return %Int32x4Shuffle(q,x,C,D,E,F);
+}
+
+function Uint32x4Splat(y){
+return %CreateUint32x4(y,y,y,y);
+}
+function Uint32x4SwizzleJS(q,C,D,E,F){
+return %Uint32x4Swizzle(q,C,D,E,F);
+}
+function Uint32x4ShuffleJS(q,x,C,D,E,F){
+return %Uint32x4Shuffle(q,x,C,D,E,F);
+}
+
+function Bool32x4Splat(y){
+return %CreateBool32x4(y,y,y,y);
+}
+function Bool32x4SwizzleJS(q,C,D,E,F){
+return %Bool32x4Swizzle(q,C,D,E,F);
+}
+function Bool32x4ShuffleJS(q,x,C,D,E,F){
+return %Bool32x4Shuffle(q,x,C,D,E,F);
+}
+
+
+function Int16x8Splat(y){
+return %CreateInt16x8(y,y,y,y,y,y,y,y);
+}
+function Int16x8SwizzleJS(q,C,D,E,F,G,H,I,J){
+return %Int16x8Swizzle(q,C,D,E,F,G,H,I,J);
+}
+function Int16x8ShuffleJS(q,x,C,D,E,F,G,H,I,J){
+return %Int16x8Shuffle(q,x,C,D,E,F,G,H,I,J);
+}
+
+function Uint16x8Splat(y){
+return %CreateUint16x8(y,y,y,y,y,y,y,y);
+}
+function Uint16x8SwizzleJS(q,C,D,E,F,G,H,I,J){
+return %Uint16x8Swizzle(q,C,D,E,F,G,H,I,J);
+}
+function Uint16x8ShuffleJS(q,x,C,D,E,F,G,H,I,J){
+return %Uint16x8Shuffle(q,x,C,D,E,F,G,H,I,J);
+}
+
+function Bool16x8Splat(y){
+return %CreateBool16x8(y,y,y,y,y,y,y,y);
+}
+function Bool16x8SwizzleJS(q,C,D,E,F,G,H,I,J){
+return %Bool16x8Swizzle(q,C,D,E,F,G,H,I,J);
+}
+function Bool16x8ShuffleJS(q,x,C,D,E,F,G,H,I,J){
+return %Bool16x8Shuffle(q,x,C,D,E,F,G,H,I,J);
+}
+
+
+function Int8x16Splat(y){
+return %CreateInt8x16(y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y);
+}
+function Int8x16SwizzleJS(q,C,D,E,F,G,H,I,J,c8,c9,c10,c11,
+c12,c13,c14,c15){
+return %Int8x16Swizzle(q,C,D,E,F,G,H,I,J,c8,c9,c10,c11,
+c12,c13,c14,c15);
+}
+function Int8x16ShuffleJS(q,x,C,D,E,F,G,H,I,J,c8,c9,c10,
+c11,c12,c13,c14,c15){
+return %Int8x16Shuffle(q,x,C,D,E,F,G,H,I,J,c8,c9,c10,
+c11,c12,c13,c14,c15);
+}
+
+function Uint8x16Splat(y){
+return %CreateUint8x16(y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y);
+}
+function Uint8x16SwizzleJS(q,C,D,E,F,G,H,I,J,c8,c9,c10,c11,
+c12,c13,c14,c15){
+return %Uint8x16Swizzle(q,C,D,E,F,G,H,I,J,c8,c9,c10,c11,
+c12,c13,c14,c15);
+}
+function Uint8x16ShuffleJS(q,x,C,D,E,F,G,H,I,J,c8,c9,c10,
+c11,c12,c13,c14,c15){
+return %Uint8x16Shuffle(q,x,C,D,E,F,G,H,I,J,c8,c9,c10,
+c11,c12,c13,c14,c15);
+}
+
+function Bool8x16Splat(y){
+return %CreateBool8x16(y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y);
+}
+function Bool8x16SwizzleJS(q,C,D,E,F,G,H,I,J,c8,c9,c10,c11,
+c12,c13,c14,c15){
+return %Bool8x16Swizzle(q,C,D,E,F,G,H,I,J,c8,c9,c10,c11,
+c12,c13,c14,c15);
+}
+function Bool8x16ShuffleJS(q,x,C,D,E,F,G,H,I,J,c8,c9,c10,
+c11,c12,c13,c14,c15){
+return %Bool8x16Shuffle(q,x,C,D,E,F,G,H,I,J,c8,c9,c10,
+c11,c12,c13,c14,c15);
+}
+
+
+function Float32x4Constructor(C,D,E,F){
+if(!(new.target===(void 0))){
+throw d(66,"Float32x4");
+}
+return %CreateFloat32x4((%_ToNumber(C)),(%_ToNumber(D)),
+(%_ToNumber(E)),(%_ToNumber(F)));
+}
+function Int32x4Constructor(C,D,E,F){
+if(!(new.target===(void 0))){
+throw d(66,"Int32x4");
+}
+return %CreateInt32x4((%_ToNumber(C)),(%_ToNumber(D)),
+(%_ToNumber(E)),(%_ToNumber(F)));
+}
+function Uint32x4Constructor(C,D,E,F){
+if(!(new.target===(void 0))){
+throw d(66,"Uint32x4");
+}
+return %CreateUint32x4((%_ToNumber(C)),(%_ToNumber(D)),
+(%_ToNumber(E)),(%_ToNumber(F)));
+}
+function Bool32x4Constructor(C,D,E,F){
+if(!(new.target===(void 0))){
+throw d(66,"Bool32x4");
+}
+return %CreateBool32x4(C,D,E,F);
+}
+function Int16x8Constructor(C,D,E,F,G,H,I,J){
+if(!(new.target===(void 0))){
+throw d(66,"Int16x8");
+}
+return %CreateInt16x8((%_ToNumber(C)),(%_ToNumber(D)),
+(%_ToNumber(E)),(%_ToNumber(F)),
+(%_ToNumber(G)),(%_ToNumber(H)),
+(%_ToNumber(I)),(%_ToNumber(J)));
+}
+function Uint16x8Constructor(C,D,E,F,G,H,I,J){
+if(!(new.target===(void 0))){
+throw d(66,"Uint16x8");
+}
+return %CreateUint16x8((%_ToNumber(C)),(%_ToNumber(D)),
+(%_ToNumber(E)),(%_ToNumber(F)),
+(%_ToNumber(G)),(%_ToNumber(H)),
+(%_ToNumber(I)),(%_ToNumber(J)));
+}
+function Bool16x8Constructor(C,D,E,F,G,H,I,J){
+if(!(new.target===(void 0))){
+throw d(66,"Bool16x8");
+}
+return %CreateBool16x8(C,D,E,F,G,H,I,J);
+}
+function Int8x16Constructor(C,D,E,F,G,H,I,J,c8,c9,c10,c11,
+c12,c13,c14,c15){
+if(!(new.target===(void 0))){
+throw d(66,"Int8x16");
+}
+return %CreateInt8x16((%_ToNumber(C)),(%_ToNumber(D)),
+(%_ToNumber(E)),(%_ToNumber(F)),
+(%_ToNumber(G)),(%_ToNumber(H)),
+(%_ToNumber(I)),(%_ToNumber(J)),
+(%_ToNumber(c8)),(%_ToNumber(c9)),
+(%_ToNumber(c10)),(%_ToNumber(c11)),
+(%_ToNumber(c12)),(%_ToNumber(c13)),
+(%_ToNumber(c14)),(%_ToNumber(c15)));
+}
+function Uint8x16Constructor(C,D,E,F,G,H,I,J,c8,c9,c10,c11,
+c12,c13,c14,c15){
+if(!(new.target===(void 0))){
+throw d(66,"Uint8x16");
+}
+return %CreateUint8x16((%_ToNumber(C)),(%_ToNumber(D)),
+(%_ToNumber(E)),(%_ToNumber(F)),
+(%_ToNumber(G)),(%_ToNumber(H)),
+(%_ToNumber(I)),(%_ToNumber(J)),
+(%_ToNumber(c8)),(%_ToNumber(c9)),
+(%_ToNumber(c10)),(%_ToNumber(c11)),
+(%_ToNumber(c12)),(%_ToNumber(c13)),
+(%_ToNumber(c14)),(%_ToNumber(c15)));
+}
+function Bool8x16Constructor(C,D,E,F,G,H,I,J,c8,c9,c10,c11,
+c12,c13,c14,c15){
+if(!(new.target===(void 0))){
+throw d(66,"Bool8x16");
+}
+return %CreateBool8x16(C,D,E,F,G,H,I,J,c8,c9,c10,c11,c12,
+c13,c14,c15);
+}
+function Float32x4AbsJS(q){
+return %Float32x4Abs(q);
+}
+function Float32x4SqrtJS(q){
+return %Float32x4Sqrt(q);
+}
+function Float32x4RecipApproxJS(q){
+return %Float32x4RecipApprox(q);
+}
+function Float32x4RecipSqrtApproxJS(q){
+return %Float32x4RecipSqrtApprox(q);
+}
+function Float32x4DivJS(q,x){
+return %Float32x4Div(q,x);
+}
+function Float32x4MinNumJS(q,x){
+return %Float32x4MinNum(q,x);
+}
+function Float32x4MaxNumJS(q,x){
+return %Float32x4MaxNum(q,x);
+}
+%AddNamedProperty(c,e,'SIMD',1|2);
+%SetCode(g,Float32x4Constructor);
+%FunctionSetPrototype(g,{});
+%AddNamedProperty(g.prototype,'constructor',g,
+2);
+%AddNamedProperty(g.prototype,e,'Float32x4',
+2|1);
+b.InstallFunctions(g.prototype,2,[
+'toLocaleString',Float32x4ToLocaleString,
+'toString',Float32x4ToString,
+'valueOf',Float32x4ValueOf,
+]);
+
+
+%SetCode(h,Int32x4Constructor);
+%FunctionSetPrototype(h,{});
+%AddNamedProperty(h.prototype,'constructor',h,
+2);
+%AddNamedProperty(h.prototype,e,'Int32x4',
+2|1);
+b.InstallFunctions(h.prototype,2,[
+'toLocaleString',Int32x4ToLocaleString,
+'toString',Int32x4ToString,
+'valueOf',Int32x4ValueOf,
+]);
+
+%SetCode(i,Int16x8Constructor);
+%FunctionSetPrototype(i,{});
+%AddNamedProperty(i.prototype,'constructor',i,
+2);
+%AddNamedProperty(i.prototype,e,'Int16x8',
+2|1);
+b.InstallFunctions(i.prototype,2,[
+'toLocaleString',Int16x8ToLocaleString,
+'toString',Int16x8ToString,
+'valueOf',Int16x8ValueOf,
+]);
+
+%SetCode(j,Int8x16Constructor);
+%FunctionSetPrototype(j,{});
+%AddNamedProperty(j.prototype,'constructor',j,
+2);
+%AddNamedProperty(j.prototype,e,'Int8x16',
+2|1);
+b.InstallFunctions(j.prototype,2,[
+'toLocaleString',Int8x16ToLocaleString,
+'toString',Int8x16ToString,
+'valueOf',Int8x16ValueOf,
+]);
+
+
+%SetCode(k,Uint32x4Constructor);
+%FunctionSetPrototype(k,{});
+%AddNamedProperty(k.prototype,'constructor',k,
+2);
+%AddNamedProperty(k.prototype,e,'Uint32x4',
+2|1);
+b.InstallFunctions(k.prototype,2,[
+'toLocaleString',Uint32x4ToLocaleString,
+'toString',Uint32x4ToString,
+'valueOf',Uint32x4ValueOf,
+]);
+
+%SetCode(l,Uint16x8Constructor);
+%FunctionSetPrototype(l,{});
+%AddNamedProperty(l.prototype,'constructor',l,
+2);
+%AddNamedProperty(l.prototype,e,'Uint16x8',
+2|1);
+b.InstallFunctions(l.prototype,2,[
+'toLocaleString',Uint16x8ToLocaleString,
+'toString',Uint16x8ToString,
+'valueOf',Uint16x8ValueOf,
+]);
+
+%SetCode(m,Uint8x16Constructor);
+%FunctionSetPrototype(m,{});
+%AddNamedProperty(m.prototype,'constructor',m,
+2);
+%AddNamedProperty(m.prototype,e,'Uint8x16',
+2|1);
+b.InstallFunctions(m.prototype,2,[
+'toLocaleString',Uint8x16ToLocaleString,
+'toString',Uint8x16ToString,
+'valueOf',Uint8x16ValueOf,
+]);
+
+
+%SetCode(n,Bool32x4Constructor);
+%FunctionSetPrototype(n,{});
+%AddNamedProperty(n.prototype,'constructor',n,
+2);
+%AddNamedProperty(n.prototype,e,'Bool32x4',
+2|1);
+b.InstallFunctions(n.prototype,2,[
+'toLocaleString',Bool32x4ToLocaleString,
+'toString',Bool32x4ToString,
+'valueOf',Bool32x4ValueOf,
+]);
+
+%SetCode(o,Bool16x8Constructor);
+%FunctionSetPrototype(o,{});
+%AddNamedProperty(o.prototype,'constructor',o,
+2);
+%AddNamedProperty(o.prototype,e,'Bool16x8',
+2|1);
+b.InstallFunctions(o.prototype,2,[
+'toLocaleString',Bool16x8ToLocaleString,
+'toString',Bool16x8ToString,
+'valueOf',Bool16x8ValueOf,
+]);
+
+%SetCode(p,Bool8x16Constructor);
+%FunctionSetPrototype(p,{});
+%AddNamedProperty(p.prototype,'constructor',p,
+2);
+%AddNamedProperty(p.prototype,e,'Bool8x16',
+2|1);
+b.InstallFunctions(p.prototype,2,[
+'toLocaleString',Bool8x16ToLocaleString,
+'toString',Bool8x16ToString,
+'valueOf',Bool8x16ValueOf,
+]);
+
+
+
+b.InstallFunctions(g,2,[
+'splat',Float32x4Splat,
+'check',Float32x4CheckJS,
+'extractLane',Float32x4ExtractLaneJS,
+'replaceLane',Float32x4ReplaceLaneJS,
+'neg',Float32x4NegJS,
+'abs',Float32x4AbsJS,
+'sqrt',Float32x4SqrtJS,
+'reciprocalApproximation',Float32x4RecipApproxJS,
+'reciprocalSqrtApproximation',Float32x4RecipSqrtApproxJS,
+'add',Float32x4AddJS,
+'sub',Float32x4SubJS,
+'mul',Float32x4MulJS,
+'div',Float32x4DivJS,
+'min',Float32x4MinJS,
+'max',Float32x4MaxJS,
+'minNum',Float32x4MinNumJS,
+'maxNum',Float32x4MaxNumJS,
+'lessThan',Float32x4LessThanJS,
+'lessThanOrEqual',Float32x4LessThanOrEqualJS,
+'greaterThan',Float32x4GreaterThanJS,
+'greaterThanOrEqual',Float32x4GreaterThanOrEqualJS,
+'equal',Float32x4EqualJS,
+'notEqual',Float32x4NotEqualJS,
+'select',Float32x4SelectJS,
+'swizzle',Float32x4SwizzleJS,
+'shuffle',Float32x4ShuffleJS,
+'fromInt32x4',Float32x4FromInt32x4JS,
+'fromUint32x4',Float32x4FromUint32x4JS,
+'fromInt32x4Bits',Float32x4FromInt32x4BitsJS,
+'fromUint32x4Bits',Float32x4FromUint32x4BitsJS,
+'fromInt16x8Bits',Float32x4FromInt16x8BitsJS,
+'fromUint16x8Bits',Float32x4FromUint16x8BitsJS,
+'fromInt8x16Bits',Float32x4FromInt8x16BitsJS,
+'fromUint8x16Bits',Float32x4FromUint8x16BitsJS,
+'load',Float32x4LoadJS,
+'load1',Float32x4Load1JS,
+'load2',Float32x4Load2JS,
+'load3',Float32x4Load3JS,
+'store',Float32x4StoreJS,
+'store1',Float32x4Store1JS,
+'store2',Float32x4Store2JS,
+'store3',Float32x4Store3JS,
+]);
+b.InstallFunctions(h,2,[
+'splat',Int32x4Splat,
+'check',Int32x4CheckJS,
+'extractLane',Int32x4ExtractLaneJS,
+'replaceLane',Int32x4ReplaceLaneJS,
+'neg',Int32x4NegJS,
+'add',Int32x4AddJS,
+'sub',Int32x4SubJS,
+'mul',Int32x4MulJS,
+'min',Int32x4MinJS,
+'max',Int32x4MaxJS,
+'and',Int32x4AndJS,
+'or',Int32x4OrJS,
+'xor',Int32x4XorJS,
+'not',Int32x4NotJS,
+'shiftLeftByScalar',Int32x4ShiftLeftByScalarJS,
+'shiftRightByScalar',Int32x4ShiftRightByScalarJS,
+'lessThan',Int32x4LessThanJS,
+'lessThanOrEqual',Int32x4LessThanOrEqualJS,
+'greaterThan',Int32x4GreaterThanJS,
+'greaterThanOrEqual',Int32x4GreaterThanOrEqualJS,
+'equal',Int32x4EqualJS,
+'notEqual',Int32x4NotEqualJS,
+'select',Int32x4SelectJS,
+'swizzle',Int32x4SwizzleJS,
+'shuffle',Int32x4ShuffleJS,
+'fromFloat32x4',Int32x4FromFloat32x4JS,
+'fromUint32x4',Int32x4FromUint32x4JS,
+'fromFloat32x4Bits',Int32x4FromFloat32x4BitsJS,
+'fromUint32x4Bits',Int32x4FromUint32x4BitsJS,
+'fromInt16x8Bits',Int32x4FromInt16x8BitsJS,
+'fromUint16x8Bits',Int32x4FromUint16x8BitsJS,
+'fromInt8x16Bits',Int32x4FromInt8x16BitsJS,
+'fromUint8x16Bits',Int32x4FromUint8x16BitsJS,
+'load',Int32x4LoadJS,
+'load1',Int32x4Load1JS,
+'load2',Int32x4Load2JS,
+'load3',Int32x4Load3JS,
+'store',Int32x4StoreJS,
+'store1',Int32x4Store1JS,
+'store2',Int32x4Store2JS,
+'store3',Int32x4Store3JS,
+]);
+b.InstallFunctions(k,2,[
+'splat',Uint32x4Splat,
+'check',Uint32x4CheckJS,
+'extractLane',Uint32x4ExtractLaneJS,
+'replaceLane',Uint32x4ReplaceLaneJS,
+'add',Uint32x4AddJS,
+'sub',Uint32x4SubJS,
+'mul',Uint32x4MulJS,
+'min',Uint32x4MinJS,
+'max',Uint32x4MaxJS,
+'and',Uint32x4AndJS,
+'or',Uint32x4OrJS,
+'xor',Uint32x4XorJS,
+'not',Uint32x4NotJS,
+'shiftLeftByScalar',Uint32x4ShiftLeftByScalarJS,
+'shiftRightByScalar',Uint32x4ShiftRightByScalarJS,
+'lessThan',Uint32x4LessThanJS,
+'lessThanOrEqual',Uint32x4LessThanOrEqualJS,
+'greaterThan',Uint32x4GreaterThanJS,
+'greaterThanOrEqual',Uint32x4GreaterThanOrEqualJS,
+'equal',Uint32x4EqualJS,
+'notEqual',Uint32x4NotEqualJS,
+'select',Uint32x4SelectJS,
+'swizzle',Uint32x4SwizzleJS,
+'shuffle',Uint32x4ShuffleJS,
+'fromFloat32x4',Uint32x4FromFloat32x4JS,
+'fromInt32x4',Uint32x4FromInt32x4JS,
+'fromFloat32x4Bits',Uint32x4FromFloat32x4BitsJS,
+'fromInt32x4Bits',Uint32x4FromInt32x4BitsJS,
+'fromInt16x8Bits',Uint32x4FromInt16x8BitsJS,
+'fromUint16x8Bits',Uint32x4FromUint16x8BitsJS,
+'fromInt8x16Bits',Uint32x4FromInt8x16BitsJS,
+'fromUint8x16Bits',Uint32x4FromUint8x16BitsJS,
+'load',Uint32x4LoadJS,
+'load1',Uint32x4Load1JS,
+'load2',Uint32x4Load2JS,
+'load3',Uint32x4Load3JS,
+'store',Uint32x4StoreJS,
+'store1',Uint32x4Store1JS,
+'store2',Uint32x4Store2JS,
+'store3',Uint32x4Store3JS,
+]);
+b.InstallFunctions(n,2,[
+'splat',Bool32x4Splat,
+'check',Bool32x4CheckJS,
+'extractLane',Bool32x4ExtractLaneJS,
+'replaceLane',Bool32x4ReplaceLaneJS,
+'and',Bool32x4AndJS,
+'or',Bool32x4OrJS,
+'xor',Bool32x4XorJS,
+'not',Bool32x4NotJS,
+'anyTrue',Bool32x4AnyTrueJS,
+'allTrue',Bool32x4AllTrueJS,
+'swizzle',Bool32x4SwizzleJS,
+'shuffle',Bool32x4ShuffleJS,
+]);
+b.InstallFunctions(i,2,[
+'splat',Int16x8Splat,
+'check',Int16x8CheckJS,
+'extractLane',Int16x8ExtractLaneJS,
+'replaceLane',Int16x8ReplaceLaneJS,
+'neg',Int16x8NegJS,
+'add',Int16x8AddJS,
+'sub',Int16x8SubJS,
+'addSaturate',Int16x8AddSaturateJS,
+'subSaturate',Int16x8SubSaturateJS,
+'mul',Int16x8MulJS,
+'min',Int16x8MinJS,
+'max',Int16x8MaxJS,
+'and',Int16x8AndJS,
+'or',Int16x8OrJS,
+'xor',Int16x8XorJS,
+'not',Int16x8NotJS,
+'shiftLeftByScalar',Int16x8ShiftLeftByScalarJS,
+'shiftRightByScalar',Int16x8ShiftRightByScalarJS,
+'lessThan',Int16x8LessThanJS,
+'lessThanOrEqual',Int16x8LessThanOrEqualJS,
+'greaterThan',Int16x8GreaterThanJS,
+'greaterThanOrEqual',Int16x8GreaterThanOrEqualJS,
+'equal',Int16x8EqualJS,
+'notEqual',Int16x8NotEqualJS,
+'select',Int16x8SelectJS,
+'swizzle',Int16x8SwizzleJS,
+'shuffle',Int16x8ShuffleJS,
+'fromUint16x8',Int16x8FromUint16x8JS,
+'fromFloat32x4Bits',Int16x8FromFloat32x4BitsJS,
+'fromInt32x4Bits',Int16x8FromInt32x4BitsJS,
+'fromUint32x4Bits',Int16x8FromUint32x4BitsJS,
+'fromUint16x8Bits',Int16x8FromUint16x8BitsJS,
+'fromInt8x16Bits',Int16x8FromInt8x16BitsJS,
+'fromUint8x16Bits',Int16x8FromUint8x16BitsJS,
+'load',Int16x8LoadJS,
+'store',Int16x8StoreJS,
+]);
+b.InstallFunctions(l,2,[
+'splat',Uint16x8Splat,
+'check',Uint16x8CheckJS,
+'extractLane',Uint16x8ExtractLaneJS,
+'replaceLane',Uint16x8ReplaceLaneJS,
+'add',Uint16x8AddJS,
+'sub',Uint16x8SubJS,
+'addSaturate',Uint16x8AddSaturateJS,
+'subSaturate',Uint16x8SubSaturateJS,
+'mul',Uint16x8MulJS,
+'min',Uint16x8MinJS,
+'max',Uint16x8MaxJS,
+'and',Uint16x8AndJS,
+'or',Uint16x8OrJS,
+'xor',Uint16x8XorJS,
+'not',Uint16x8NotJS,
+'shiftLeftByScalar',Uint16x8ShiftLeftByScalarJS,
+'shiftRightByScalar',Uint16x8ShiftRightByScalarJS,
+'lessThan',Uint16x8LessThanJS,
+'lessThanOrEqual',Uint16x8LessThanOrEqualJS,
+'greaterThan',Uint16x8GreaterThanJS,
+'greaterThanOrEqual',Uint16x8GreaterThanOrEqualJS,
+'equal',Uint16x8EqualJS,
+'notEqual',Uint16x8NotEqualJS,
+'select',Uint16x8SelectJS,
+'swizzle',Uint16x8SwizzleJS,
+'shuffle',Uint16x8ShuffleJS,
+'fromInt16x8',Uint16x8FromInt16x8JS,
+'fromFloat32x4Bits',Uint16x8FromFloat32x4BitsJS,
+'fromInt32x4Bits',Uint16x8FromInt32x4BitsJS,
+'fromUint32x4Bits',Uint16x8FromUint32x4BitsJS,
+'fromInt16x8Bits',Uint16x8FromInt16x8BitsJS,
+'fromInt8x16Bits',Uint16x8FromInt8x16BitsJS,
+'fromUint8x16Bits',Uint16x8FromUint8x16BitsJS,
+'load',Uint16x8LoadJS,
+'store',Uint16x8StoreJS,
+]);
+b.InstallFunctions(o,2,[
+'splat',Bool16x8Splat,
+'check',Bool16x8CheckJS,
+'extractLane',Bool16x8ExtractLaneJS,
+'replaceLane',Bool16x8ReplaceLaneJS,
+'and',Bool16x8AndJS,
+'or',Bool16x8OrJS,
+'xor',Bool16x8XorJS,
+'not',Bool16x8NotJS,
+'anyTrue',Bool16x8AnyTrueJS,
+'allTrue',Bool16x8AllTrueJS,
+'swizzle',Bool16x8SwizzleJS,
+'shuffle',Bool16x8ShuffleJS,
+]);
+b.InstallFunctions(j,2,[
+'splat',Int8x16Splat,
+'check',Int8x16CheckJS,
+'extractLane',Int8x16ExtractLaneJS,
+'replaceLane',Int8x16ReplaceLaneJS,
+'neg',Int8x16NegJS,
+'add',Int8x16AddJS,
+'sub',Int8x16SubJS,
+'addSaturate',Int8x16AddSaturateJS,
+'subSaturate',Int8x16SubSaturateJS,
+'mul',Int8x16MulJS,
+'min',Int8x16MinJS,
+'max',Int8x16MaxJS,
+'and',Int8x16AndJS,
+'or',Int8x16OrJS,
+'xor',Int8x16XorJS,
+'not',Int8x16NotJS,
+'shiftLeftByScalar',Int8x16ShiftLeftByScalarJS,
+'shiftRightByScalar',Int8x16ShiftRightByScalarJS,
+'lessThan',Int8x16LessThanJS,
+'lessThanOrEqual',Int8x16LessThanOrEqualJS,
+'greaterThan',Int8x16GreaterThanJS,
+'greaterThanOrEqual',Int8x16GreaterThanOrEqualJS,
+'equal',Int8x16EqualJS,
+'notEqual',Int8x16NotEqualJS,
+'select',Int8x16SelectJS,
+'swizzle',Int8x16SwizzleJS,
+'shuffle',Int8x16ShuffleJS,
+'fromUint8x16',Int8x16FromUint8x16JS,
+'fromFloat32x4Bits',Int8x16FromFloat32x4BitsJS,
+'fromInt32x4Bits',Int8x16FromInt32x4BitsJS,
+'fromUint32x4Bits',Int8x16FromUint32x4BitsJS,
+'fromInt16x8Bits',Int8x16FromInt16x8BitsJS,
+'fromUint16x8Bits',Int8x16FromUint16x8BitsJS,
+'fromUint8x16Bits',Int8x16FromUint8x16BitsJS,
+'load',Int8x16LoadJS,
+'store',Int8x16StoreJS,
+]);
+b.InstallFunctions(m,2,[
+'splat',Uint8x16Splat,
+'check',Uint8x16CheckJS,
+'extractLane',Uint8x16ExtractLaneJS,
+'replaceLane',Uint8x16ReplaceLaneJS,
+'add',Uint8x16AddJS,
+'sub',Uint8x16SubJS,
+'addSaturate',Uint8x16AddSaturateJS,
+'subSaturate',Uint8x16SubSaturateJS,
+'mul',Uint8x16MulJS,
+'min',Uint8x16MinJS,
+'max',Uint8x16MaxJS,
+'and',Uint8x16AndJS,
+'or',Uint8x16OrJS,
+'xor',Uint8x16XorJS,
+'not',Uint8x16NotJS,
+'shiftLeftByScalar',Uint8x16ShiftLeftByScalarJS,
+'shiftRightByScalar',Uint8x16ShiftRightByScalarJS,
+'lessThan',Uint8x16LessThanJS,
+'lessThanOrEqual',Uint8x16LessThanOrEqualJS,
+'greaterThan',Uint8x16GreaterThanJS,
+'greaterThanOrEqual',Uint8x16GreaterThanOrEqualJS,
+'equal',Uint8x16EqualJS,
+'notEqual',Uint8x16NotEqualJS,
+'select',Uint8x16SelectJS,
+'swizzle',Uint8x16SwizzleJS,
+'shuffle',Uint8x16ShuffleJS,
+'fromInt8x16',Uint8x16FromInt8x16JS,
+'fromFloat32x4Bits',Uint8x16FromFloat32x4BitsJS,
+'fromInt32x4Bits',Uint8x16FromInt32x4BitsJS,
+'fromUint32x4Bits',Uint8x16FromUint32x4BitsJS,
+'fromInt16x8Bits',Uint8x16FromInt16x8BitsJS,
+'fromUint16x8Bits',Uint8x16FromUint16x8BitsJS,
+'fromInt8x16Bits',Uint8x16FromInt8x16BitsJS,
+'load',Uint8x16LoadJS,
+'store',Uint8x16StoreJS,
+]);
+b.InstallFunctions(p,2,[
+'splat',Bool8x16Splat,
+'check',Bool8x16CheckJS,
+'extractLane',Bool8x16ExtractLaneJS,
+'replaceLane',Bool8x16ReplaceLaneJS,
+'and',Bool8x16AndJS,
+'or',Bool8x16OrJS,
+'xor',Bool8x16XorJS,
+'not',Bool8x16NotJS,
+'anyTrue',Bool8x16AnyTrueJS,
+'allTrue',Bool8x16AllTrueJS,
+'swizzle',Bool8x16SwizzleJS,
+'shuffle',Bool8x16ShuffleJS,
+]);
+b.Export(function(K){
+K.Float32x4ToString=Float32x4ToString;
+K.Int32x4ToString=Int32x4ToString;
+K.Uint32x4ToString=Uint32x4ToString;
+K.Bool32x4ToString=Bool32x4ToString;
+K.Int16x8ToString=Int16x8ToString;
+K.Uint16x8ToString=Uint16x8ToString;
+K.Bool16x8ToString=Bool16x8ToString;
+K.Int8x16ToString=Int8x16ToString;
+K.Uint8x16ToString=Uint8x16ToString;
+K.Bool8x16ToString=Bool8x16ToString;
+});
+})
+
+<harmony-speciesE
+(function(a,b,c){
+"use strict";
+%CheckIsBootstrapping();
+var d=a.Array;
+var e=a.Uint8Array.__proto__;
+var f=a.Map;
+var g=a.Set;
+var h=a.ArrayBuffer;
+var i=a.Promise;
+var j=a.RegExp;
+var k=b.ImportNow("species_symbol");
+function ArraySpecies(){
+return this;
+}
+function TypedArraySpecies(){
+return this;
+}
+function MapSpecies(){
+return this;
+}
+function SetSpecies(){
+return this;
+}
+function ArrayBufferSpecies(){
+return this;
+}
+function PromiseSpecies(){
+return this;
+}
+function RegExpSpecies(){
+return this;
+}
+b.InstallGetter(d,k,ArraySpecies,2);
+b.InstallGetter(e,k,TypedArraySpecies,2);
+b.InstallGetter(f,k,MapSpecies,2);
+b.InstallGetter(g,k,SetSpecies,2);
+b.InstallGetter(h,k,ArrayBufferSpecies,
+2);
+b.InstallGetter(i,k,PromiseSpecies,2);
+b.InstallGetter(j,k,RegExpSpecies,2);
+});
+
+\harmony-unicode-regexps�
+(function(a,b){
+'use strict';
+%CheckIsBootstrapping();
+var c=a.RegExp;
+var d=c.prototype;
+var e;
+b.Import(function(f){
+e=f.MakeTypeError;
+});
+function RegExpGetUnicode(){
+if(!(%_IsRegExp(this))){
+if(this===d){
+%IncrementUseCounter(13);
+return(void 0);
+}
+throw e(134,"RegExp.prototype.unicode");
+}
+return(!!((%_RegExpFlags(this)&16)));
+}
+%SetForceInlineFlag(RegExpGetUnicode);
+b.InstallGetter(c.prototype,'unicode',RegExpGetUnicode);
+})
+
+Xharmony-string-padding�
+(function(a,b){
+%CheckIsBootstrapping();
+var c=a.String;
+var d;
+b.Import(function(e){
+d=e.MakeTypeError;
+});
+function StringPad(f,g,h){
+g=(%_ToLength(g));
+var i=f.length;
+if(g<=i)return"";
+if((h===(void 0))){
+h=" ";
+}else{
+h=(%_ToString(h));
+if(h===""){
+h=" ";
+}
+}
+var j=g-i;
+var k=(j/h.length)|0;
+var l=(j-h.length*k)|0;
+var m="";
+while(true){
+if(k&1)m+=h;
+k>>=1;
+if(k===0)break;
+h+=h;
+}
+if(l){
+m+=%_SubString(h,0,l);
+}
+return m;
+}
+function StringPadStart(g,h){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw d(18,"String.prototype.padStart")
+var f=(%_ToString(this));
+return StringPad(f,g,h)+f;
+}
+%FunctionSetLength(StringPadStart,1);
+function StringPadEnd(g,h){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw d(18,"String.prototype.padEnd")
+var f=(%_ToString(this));
+return f+StringPad(f,g,h);
+}
+%FunctionSetLength(StringPadEnd,1);
+b.InstallFunctions(c.prototype,2,[
+"padStart",StringPadStart,
+"padEnd",StringPadEnd
+]);
+});
+
+4promise-extra�
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Promise;
+var d=b.ImportNow("PromiseChain");
+var e=b.ImportNow("PromiseDeferred");
+var f=b.ImportNow("PromiseResolved");
+b.InstallFunctions(c.prototype,2,[
+"chain",d,
+]);
+b.InstallFunctions(c,2,[
+"defer",e,
+"accept",f,
+]);
+})
+
+XReadableStreamTempStubm
+(function(global, binding, v8) {
+  'use strict';
+  const TypeError = global.TypeError;
+  const defineProperty = global.Object.defineProperty;
+  class ReadableStream {
+    constructor() {
+      throw new TypeError('Illegal constructor');
+    }
+    getReader() {
+      throw new TypeError('Illegal invocation');
+    }
+    cancel() {
+      throw new TypeError('Illegal invocation');
+    }
+  }
+  defineProperty(global, 'ReadableStream', {
+    value: ReadableStream,
+    enumerable: false,
+    configurable: true,
+    writable: true
+  });
+});
+dByteLengthQueuingStrategy�
+(function(global, binding, v8) {
+  'use strict';
+  const defineProperty = global.Object.defineProperty;
+  class ByteLengthQueuingStrategy {
+    constructor(options) {
+      defineProperty(this, 'highWaterMark', {
+        value: options.highWaterMark,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    }
+    size(chunk) { return chunk.byteLength; }
+  }
+  defineProperty(global, 'ByteLengthQueuingStrategy', {
+    value: ByteLengthQueuingStrategy,
+    enumerable: false,
+    configurable: true,
+    writable: true
+  });
+});
+PCountQueuingStrategy�
+(function(global, binding, v8) {
+  'use strict';
+  const defineProperty = global.Object.defineProperty;
+  class CountQueuingStrategy {
+    constructor(options) {
+      defineProperty(this, 'highWaterMark', {
+        value: options.highWaterMark,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    }
+    size(chunk) { return 1; }
+  }
+  defineProperty(global, 'CountQueuingStrategy', {
+    value: CountQueuingStrategy,
+    enumerable: false,
+    configurable: true,
+    writable: true
+  });
+  class BuiltInCountQueuingStrategy {
+    constructor(highWaterMark) {
+      defineProperty(this, 'highWaterMark', {value: highWaterMark});
+    }
+    size(chunk) { return 1; }
+  }
+  binding.createBuiltInCountQueuingStrategy = highWaterMark =>
+      new BuiltInCountQueuingStrategy(highWaterMark);
+});
+8ReadableStream�s

+(function(global, binding, v8) {
+  'use strict';
+  const readableStreamController = v8.createPrivateSymbol('[[controller]]');
+  const readableStreamQueue = v8.createPrivateSymbol('[[queue]]');
+  const readableStreamQueueSize =
+      v8.createPrivateSymbol('[[queue]] total size');
+  const readableStreamReader = v8.createPrivateSymbol('[[reader]]');
+  const readableStreamState = v8.createPrivateSymbol('[[state]]');
+  const readableStreamStoredError = v8.createPrivateSymbol('[[storedError]]');
+  const readableStreamStrategySize = v8.createPrivateSymbol('[[strategySize]]');
+  const readableStreamStrategyHWM = v8.createPrivateSymbol('[[strategyHWM]]');
+  const readableStreamUnderlyingSource =
+      v8.createPrivateSymbol('[[underlyingSource]]');
+  const readableStreamControllerControlledReadableStream =
+      v8.createPrivateSymbol('[[controlledReadableStream]]');
+  const readableStreamReaderClosedPromise =
+      v8.createPrivateSymbol('[[closedPromise]]');
+  const readableStreamReaderOwnerReadableStream =
+      v8.createPrivateSymbol('[[ownerReadableStream]]');
+  const readableStreamReaderReadRequests =
+      v8.createPrivateSymbol('[[readRequests]]');
+  const createWithExternalControllerSentinel =
+      v8.createPrivateSymbol('flag for UA-created ReadableStream to pass');
+  const STATE_READABLE = 0;
+  const STATE_CLOSED = 1;
+  const STATE_ERRORED = 2;
+  const readableStreamBits = v8.createPrivateSymbol(
+      'bit field for [[started]], [[closeRequested]], [[pulling]], [[pullAgain]], [[disturbed]]');
+  const STARTED = 0b1;
+  const CLOSE_REQUESTED = 0b10;
+  const PULLING = 0b100;
+  const PULL_AGAIN = 0b1000;
+  const DISTURBED = 0b10000;
+  const undefined = global.undefined;
+  const Infinity = global.Infinity;
+  const defineProperty = global.Object.defineProperty;
+  const hasOwnProperty = v8.uncurryThis(global.Object.hasOwnProperty);
+  const callFunction = v8.uncurryThis(global.Function.prototype.call);
+  const TypeError = global.TypeError;
+  const RangeError = global.RangeError;
+  const Number = global.Number;
+  const Number_isNaN = Number.isNaN;
+  const Number_isFinite = Number.isFinite;
+  const Promise = global.Promise;
+  const thenPromise = v8.uncurryThis(Promise.prototype.then);
+  const Promise_resolve = v8.simpleBind(Promise.resolve, Promise);
+  const Promise_reject = v8.simpleBind(Promise.reject, Promise);
+  const errIllegalInvocation = 'Illegal invocation';
+  const errIllegalConstructor = 'Illegal constructor';
+  const errCancelLockedStream =
+      'Cannot cancel a readable stream that is locked to a reader';
+  const errEnqueueInCloseRequestedStream =
+      'Cannot enqueue a chunk into a readable stream that is closed or has been requested to be closed';
+  const errCancelReleasedReader =
+      'This readable stream reader has been released and cannot be used to cancel its previous owner stream';
+  const errReadReleasedReader =
+      'This readable stream reader has been released and cannot be used to read from its previous owner stream';
+  const errCloseCloseRequestedStream =
+      'Cannot close a readable stream that has already been requested to be closed';
+  const errCloseErroredStream = 'Cannot close an errored readable stream';
+  const errErrorClosedStream = 'Cannot error a close readable stream';
+  const errErrorErroredStream =
+      'Cannot error a readable stream that is already errored';
+  const errReaderConstructorBadArgument =
+      'ReadableStreamReader constructor argument is not a readable stream';
+  const errReaderConstructorStreamAlreadyLocked =
+      'ReadableStreamReader constructor can only accept readable streams that are not yet locked to a reader';
+  const errReleaseReaderWithPendingRead =
+      'Cannot release a readable stream reader when it still has outstanding read() calls that have not yet settled';
+  const errReleasedReaderClosedPromise =
+      'This readable stream reader has been released and cannot be used to monitor the stream\'s state';
+  const errInvalidSize =
+      'The return value of a queuing strategy\'s size function must be a finite, non-NaN, non-negative number';
+  const errSizeNotAFunction =
+      'A queuing strategy\'s size property must be a function';
+  const errInvalidHWM =
+      'A queueing strategy\'s highWaterMark property must be a nonnegative, non-NaN number';
+  const errTmplMustBeFunctionOrUndefined = name =>
+      `${name} must be a function or undefined`;
+  class ReadableStream {
+    constructor() {
+      const underlyingSource = arguments[0] === undefined ? {} : arguments[0];
+      const strategy = arguments[1] === undefined ? {} : arguments[1];
+      const size = strategy.size;
+      let highWaterMark = strategy.highWaterMark;
+      if (highWaterMark === undefined) {
+        highWaterMark = 1;
+      }
+      const normalizedStrategy =
+          ValidateAndNormalizeQueuingStrategy(size, highWaterMark);
+      this[readableStreamUnderlyingSource] = underlyingSource;
+      this[readableStreamQueue] = new v8.InternalPackedArray();
+      this[readableStreamQueueSize] = 0;
+      this[readableStreamState] = STATE_READABLE;
+      this[readableStreamBits] = 0b0;
+      this[readableStreamReader] = undefined;
+      this[readableStreamStoredError] = undefined;
+      this[readableStreamStrategySize] = normalizedStrategy.size;
+      this[readableStreamStrategyHWM] = normalizedStrategy.highWaterMark;
+      const isControlledExternally =
+          arguments[2] === createWithExternalControllerSentinel;
+      const controller =
+          isControlledExternally ? null : new ReadableStreamController(this);
+      this[readableStreamController] = controller;
+      const argToStart = isControlledExternally ? this : controller;
+      const startResult = CallOrNoop(
+          underlyingSource, 'start', argToStart, 'underlyingSource.start');
+      thenPromise(Promise_resolve(startResult),
+          () => {
+            this[readableStreamBits] |= STARTED;
+            RequestReadableStreamPull(this);
+          },
+          r => {
+            if (this[readableStreamState] === STATE_READABLE) {
+              return ErrorReadableStream(this, r);
+            }
+          });
+    }
+    get locked() {
+      if (IsReadableStream(this) === false) {
+        throw new TypeError(errIllegalInvocation);
+      }
+      return IsReadableStreamLocked(this);
+    }
+    cancel(reason) {
+      if (IsReadableStream(this) === false) {
+        return Promise_reject(new TypeError(errIllegalInvocation));
+      }
+      if (IsReadableStreamLocked(this) === true) {
+        return Promise_reject(new TypeError(errCancelLockedStream));
+      }
+      return CancelReadableStream(this, reason);
+    }
+    getReader() {
+      if (IsReadableStream(this) === false) {
+        throw new TypeError(errIllegalInvocation);
+      }
+      return AcquireReadableStreamReader(this);
+    }
+    tee() {
+      if (IsReadableStream(this) === false) {
+        throw new TypeError(errIllegalInvocation);
+      }
+      return TeeReadableStream(this);
+    }
+  }
+  class ReadableStreamController {
+    constructor(stream) {
+      if (IsReadableStream(stream) === false) {
+        throw new TypeError(errIllegalConstructor);
+      }
+      if (stream[readableStreamController] !== undefined) {
+        throw new TypeError(errIllegalConstructor);
+      }
+      this[readableStreamControllerControlledReadableStream] = stream;
+    }
+    get desiredSize() {
+      if (IsReadableStreamController(this) === false) {
+        throw new TypeError(errIllegalInvocation);
+      }
+      return GetReadableStreamDesiredSize(
+          this[readableStreamControllerControlledReadableStream]);
+    }
+    close() {
+      if (IsReadableStreamController(this) === false) {
+        throw new TypeError(errIllegalInvocation);
+      }
+      const stream = this[readableStreamControllerControlledReadableStream];
+      if (stream[readableStreamBits] & CLOSE_REQUESTED) {
+        throw new TypeError(errCloseCloseRequestedStream);
+      }
+      if (stream[readableStreamState] === STATE_ERRORED) {
+        throw new TypeError(errCloseErroredStream);
+      }
+      return CloseReadableStream(stream);
+    }
+    enqueue(chunk) {
+      if (IsReadableStreamController(this) === false) {
+        throw new TypeError(errIllegalInvocation);
+      }
+      const stream = this[readableStreamControllerControlledReadableStream];
+      if (stream[readableStreamState] === STATE_ERRORED) {
+        throw stream[readableStreamStoredError];
+      }
+      if (stream[readableStreamBits] & CLOSE_REQUESTED) {
+        throw new TypeError(errEnqueueInCloseRequestedStream);
+      }
+      return EnqueueInReadableStream(stream, chunk);
+    }
+    error(e) {
+      if (IsReadableStreamController(this) === false) {
+        throw new TypeError(errIllegalInvocation);
+      }
+      const stream = this[readableStreamControllerControlledReadableStream];
+      const state = stream[readableStreamState];
+      if (state !== STATE_READABLE) {
+        if (state === STATE_ERRORED) {
+          throw new TypeError(errErrorErroredStream);
+        }
+        if (state === STATE_CLOSED) {
+          throw new TypeError(errErrorClosedStream);
+        }
+      }
+      return ErrorReadableStream(stream, e);
+    }
+  }
+  class ReadableStreamReader {
+    constructor(stream) {
+      if (IsReadableStream(stream) === false) {
+        throw new TypeError(errReaderConstructorBadArgument);
+      }
+      if (IsReadableStreamLocked(stream) === true) {
+        throw new TypeError(errReaderConstructorStreamAlreadyLocked);
+      }
+      this[readableStreamReaderOwnerReadableStream] = stream;
+      stream[readableStreamReader] = this;
+      this[readableStreamReaderReadRequests] = new v8.InternalPackedArray();
+      switch (stream[readableStreamState]) {
+        case STATE_READABLE:
+          this[readableStreamReaderClosedPromise] = v8.createPromise();
+          break;
+        case STATE_CLOSED:
+          this[readableStreamReaderClosedPromise] = Promise_resolve(undefined);
+          break;
+        case STATE_ERRORED:
+          this[readableStreamReaderClosedPromise] =
+              Promise_reject(stream[readableStreamStoredError]);
+          break;
+      }
+    }
+    get closed() {
+      if (IsReadableStreamReader(this) === false) {
+        return Promise_reject(new TypeError(errIllegalInvocation));
+      }
+      return this[readableStreamReaderClosedPromise];
+    }
+    cancel(reason) {
+      if (IsReadableStreamReader(this) === false) {
+        return Promise_reject(new TypeError(errIllegalInvocation));
+      }
+      const stream = this[readableStreamReaderOwnerReadableStream];
+      if (stream === undefined) {
+        return Promise_reject(new TypeError(errCancelReleasedReader));
+      }
+      return CancelReadableStream(stream, reason);
+    }
+    read() {
+      if (IsReadableStreamReader(this) === false) {
+        return Promise_reject(new TypeError(errIllegalInvocation));
+      }
+      if (this[readableStreamReaderOwnerReadableStream] === undefined) {
+        return Promise_reject(new TypeError(errReadReleasedReader));
+      }
+      return ReadFromReadableStreamReader(this);
+    }
+    releaseLock() {
+      if (IsReadableStreamReader(this) === false) {
+        throw new TypeError(errIllegalInvocation);
+      }
+      const stream = this[readableStreamReaderOwnerReadableStream];
+      if (stream === undefined) {
+        return undefined;
+      }
+      if (this[readableStreamReaderReadRequests].length > 0) {
+        throw new TypeError(errReleaseReaderWithPendingRead);
+      }
+      if (stream[readableStreamState] === STATE_READABLE) {
+        v8.rejectPromise(this[readableStreamReaderClosedPromise],
+            new TypeError(errReleasedReaderClosedPromise));
+      } else {
+        this[readableStreamReaderClosedPromise] =
+            Promise_reject(new TypeError(errReleasedReaderClosedPromise));
+      }
+      this[readableStreamReaderOwnerReadableStream][readableStreamReader] =
+          undefined;
+      this[readableStreamReaderOwnerReadableStream] = undefined;
+    }
+  }
+  function AcquireReadableStreamReader(stream) {
+    return new ReadableStreamReader(stream);
+  }
+  function CancelReadableStream(stream, reason) {
+    stream[readableStreamBits] |= DISTURBED;
+    const state = stream[readableStreamState];
+    if (state === STATE_CLOSED) {
+      return Promise_resolve(undefined);
+    }
+    if (state === STATE_ERRORED) {
+      return Promise_reject(stream[readableStreamStoredError]);
+    }
+    stream[readableStreamQueue] = new v8.InternalPackedArray();
+    FinishClosingReadableStream(stream);
+    const underlyingSource = stream[readableStreamUnderlyingSource];
+    const sourceCancelPromise = PromiseCallOrNoop(
+        underlyingSource, 'cancel', reason, 'underlyingSource.cancel');
+    return thenPromise(sourceCancelPromise, () => undefined);
+  }
+  function CloseReadableStream(stream) {
+    if (stream[readableStreamState] === STATE_CLOSED) {
+      return undefined;
+    }
+    stream[readableStreamBits] |= CLOSE_REQUESTED;
+    if (stream[readableStreamQueue].length === 0) {
+      return FinishClosingReadableStream(stream);
+    }
+  }
+  function EnqueueInReadableStream(stream, chunk) {
+    if (stream[readableStreamState] === STATE_CLOSED) {
+      return undefined;
+    }
+    if (IsReadableStreamLocked(stream) === true &&
+        stream[readableStreamReader][readableStreamReaderReadRequests].length >
+            0) {
+      const readRequest =
+          stream[readableStreamReader][readableStreamReaderReadRequests]
+              .shift();
+      v8.resolvePromise(readRequest, CreateIterResultObject(chunk, false));
+    } else {
+      let chunkSize = 1;
+      const strategySize = stream[readableStreamStrategySize];
+      if (strategySize !== undefined) {
+        try {
+          chunkSize = strategySize(chunk);
+        } catch (chunkSizeE) {
+          if (stream[readableStreamState] === STATE_READABLE) {
+            ErrorReadableStream(stream, chunkSizeE);
+          }
+          throw chunkSizeE;
+        }
+      }
+      try {
+        EnqueueValueWithSize(stream, chunk, chunkSize);
+      } catch (enqueueE) {
+        if (stream[readableStreamState] === STATE_READABLE) {
+          ErrorReadableStream(stream, enqueueE);
+        }
+        throw enqueueE;
+      }
+    }
+    RequestReadableStreamPull(stream);
+  }
+  function ErrorReadableStream(stream, e) {
+    stream[readableStreamQueue] = new v8.InternalPackedArray();
+    stream[readableStreamStoredError] = e;
+    stream[readableStreamState] = STATE_ERRORED;
+    const reader = stream[readableStreamReader];
+    if (reader === undefined) {
+      return undefined;
+    }
+    const readRequests = reader[readableStreamReaderReadRequests];
+    for (let i = 0; i < readRequests.length; ++i) {
+      v8.rejectPromise(readRequests[i], e);
+    }
+    reader[readableStreamReaderReadRequests] = new v8.InternalPackedArray();
+    v8.rejectPromise(reader[readableStreamReaderClosedPromise], e);
+  }
+  function FinishClosingReadableStream(stream) {
+    stream[readableStreamState] = STATE_CLOSED;
+    const reader = stream[readableStreamReader];
+    if (reader === undefined) {
+      return undefined;
+    }
+    const readRequests = reader[readableStreamReaderReadRequests];
+    for (let i = 0; i < readRequests.length; ++i) {
+      v8.resolvePromise(
+          readRequests[i], CreateIterResultObject(undefined, true));
+    }
+    reader[readableStreamReaderReadRequests] = new v8.InternalPackedArray();
+    v8.resolvePromise(reader[readableStreamReaderClosedPromise], undefined);
+  }
+  function GetReadableStreamDesiredSize(stream) {
+    const queueSize = GetTotalQueueSize(stream);
+    return stream[readableStreamStrategyHWM] - queueSize;
+  }
+  function IsReadableStream(x) {
+    return hasOwnProperty(x, readableStreamUnderlyingSource);
+  }
+  function IsReadableStreamDisturbed(stream) {
+    return stream[readableStreamBits] & DISTURBED;
+  }
+  function IsReadableStreamLocked(stream) {
+    return stream[readableStreamReader] !== undefined;
+  }
+  function IsReadableStreamController(x) {
+    return hasOwnProperty(x, readableStreamControllerControlledReadableStream);
+  }
+  function IsReadableStreamReader(x) {
+    return hasOwnProperty(x, readableStreamReaderOwnerReadableStream);
+  }
+  function ReadFromReadableStreamReader(reader) {
+    const stream = reader[readableStreamReaderOwnerReadableStream];
+    stream[readableStreamBits] |= DISTURBED;
+    if (stream[readableStreamState] === STATE_CLOSED) {
+      return Promise_resolve(CreateIterResultObject(undefined, true));
+    }
+    if (stream[readableStreamState] === STATE_ERRORED) {
+      return Promise_reject(stream[readableStreamStoredError]);
+    }
+    const queue = stream[readableStreamQueue];
+    if (queue.length > 0) {
+      const chunk = DequeueValue(stream);
+      if (stream[readableStreamBits] & CLOSE_REQUESTED && queue.length === 0) {
+        FinishClosingReadableStream(stream);
+      } else {
+        RequestReadableStreamPull(stream);
+      }
+      return Promise_resolve(CreateIterResultObject(chunk, false));
+    } else {
+      const readRequest = v8.createPromise();
+      reader[readableStreamReaderReadRequests].push(readRequest);
+      RequestReadableStreamPull(stream);
+      return readRequest;
+    }
+  }
+  function RequestReadableStreamPull(stream) {
+    const shouldPull = ShouldReadableStreamPull(stream);
+    if (shouldPull === false) {
+      return undefined;
+    }
+    if (stream[readableStreamBits] & PULLING) {
+      stream[readableStreamBits] |= PULL_AGAIN;
+      return undefined;
+    }
+    stream[readableStreamBits] |= PULLING;
+    const underlyingSource = stream[readableStreamUnderlyingSource];
+    const controller = stream[readableStreamController];
+    const pullPromise = PromiseCallOrNoop(
+        underlyingSource, 'pull', controller, 'underlyingSource.pull');
+    thenPromise(pullPromise,
+        () => {
+          stream[readableStreamBits] &= ~PULLING;
+          if (stream[readableStreamBits] & PULL_AGAIN) {
+            stream[readableStreamBits] &= ~PULL_AGAIN;
+            return RequestReadableStreamPull(stream);
+          }
+        },
+        e => {
+          if (stream[readableStreamState] === STATE_READABLE) {
+            return ErrorReadableStream(stream, e);
+          }
+        });
+  }
+  function ShouldReadableStreamPull(stream) {
+    const state = stream[readableStreamState];
+    if (state === STATE_CLOSED || state === STATE_ERRORED) {
+      return false;
+    }
+    if (stream[readableStreamBits] & CLOSE_REQUESTED) {
+      return false;
+    }
+    if (!(stream[readableStreamBits] & STARTED)) {
+      return false;
+    }
+    if (IsReadableStreamLocked(stream) === true) {
+      const reader = stream[readableStreamReader];
+      const readRequests = reader[readableStreamReaderReadRequests];
+      if (readRequests.length > 0) {
+        return true;
+      }
+    }
+    const desiredSize = GetReadableStreamDesiredSize(stream);
+    if (desiredSize > 0) {
+      return true;
+    }
+    return false;
+  }
+  function TeeReadableStream(stream) {
+    const reader = AcquireReadableStreamReader(stream);
+    let closedOrErrored = false;
+    let canceled1 = false;
+    let canceled2 = false;
+    let reason1;
+    let reason2;
+    let promise = v8.createPromise();
+    const branch1 = new ReadableStream({pull, cancel: cancel1});
+    const branch2 = new ReadableStream({pull, cancel: cancel2});
+    thenPromise(
+        reader[readableStreamReaderClosedPromise], undefined, function(r) {
+          if (closedOrErrored === true) {
+            return;
+          }
+          ErrorReadableStream(branch1, r);
+          ErrorReadableStream(branch2, r);
+          closedOrErrored = true;
+        });
+    return [branch1, branch2];
+    function pull() {
+      return thenPromise(
+          ReadFromReadableStreamReader(reader), function(result) {
+            const value = result.value;
+            const done = result.done;
+            if (done === true && closedOrErrored === false) {
+              CloseReadableStream(branch1);
+              CloseReadableStream(branch2);
+              closedOrErrored = true;
+            }
+            if (closedOrErrored === true) {
+              return;
+            }
+            if (canceled1 === false) {
+              EnqueueInReadableStream(branch1, value);
+            }
+            if (canceled2 === false) {
+              EnqueueInReadableStream(branch2, value);
+            }
+          });
+    }
+    function cancel1(reason) {
+      canceled1 = true;
+      reason1 = reason;
+      if (canceled2 === true) {
+        const compositeReason = [reason1, reason2];
+        const cancelResult = CancelReadableStream(stream, compositeReason);
+        v8.resolvePromise(promise, cancelResult);
+      }
+      return promise;
+    }
+    function cancel2(reason) {
+      canceled2 = true;
+      reason2 = reason;
+      if (canceled1 === true) {
+        const compositeReason = [reason1, reason2];
+        const cancelResult = CancelReadableStream(stream, compositeReason);
+        v8.resolvePromise(promise, cancelResult);
+      }
+      return promise;
+    }
+  }
+  function DequeueValue(stream) {
+    const result = stream[readableStreamQueue].shift();
+    stream[readableStreamQueueSize] -= result.size;
+    return result.value;
+  }
+  function EnqueueValueWithSize(stream, value, size) {
+    size = Number(size);
+    if (Number_isNaN(size) || size === +Infinity || size < 0) {
+      throw new RangeError(errInvalidSize);
+    }
+    stream[readableStreamQueueSize] += size;
+    stream[readableStreamQueue].push({value, size});
+  }
+  function GetTotalQueueSize(stream) { return stream[readableStreamQueueSize]; }
+  function ValidateAndNormalizeQueuingStrategy(size, highWaterMark) {
+    if (size !== undefined && typeof size !== 'function') {
+      throw new TypeError(errSizeNotAFunction);
+    }
+    highWaterMark = Number(highWaterMark);
+    if (Number_isNaN(highWaterMark)) {
+      throw new TypeError(errInvalidHWM);
+    }
+    if (highWaterMark < 0) {
+      throw new RangeError(errInvalidHWM);
+    }
+    return {size, highWaterMark};
+  }
+  function CallOrNoop(O, P, arg, nameForError) {
+    const method = O[P];
+    if (method === undefined) {
+      return undefined;
+    }
+    if (typeof method !== 'function') {
+      throw new TypeError(errTmplMustBeFunctionOrUndefined(nameForError));
+    }
+    return callFunction(method, O, arg);
+  }
+  function PromiseCallOrNoop(O, P, arg, nameForError) {
+    let method;
+    try {
+      method = O[P];
+    } catch (methodE) {
+      return Promise_reject(methodE);
+    }
+    if (method === undefined) {
+      return Promise_resolve(undefined);
+    }
+    if (typeof method !== 'function') {
+      return Promise_reject(errTmplMustBeFunctionOrUndefined(nameForError));
+    }
+    try {
+      return Promise_resolve(callFunction(method, O, arg));
+    } catch (e) {
+      return Promise_reject(e);
+    }
+  }
+  function CreateIterResultObject(value, done) { return {value, done}; }
+  defineProperty(global, 'ReadableStream', {
+    value: ReadableStream,
+    enumerable: false,
+    configurable: true,
+    writable: true
+  });
+  binding.AcquireReadableStreamReader = AcquireReadableStreamReader;
+  binding.IsReadableStream = IsReadableStream;
+  binding.IsReadableStreamDisturbed = IsReadableStreamDisturbed;
+  binding.IsReadableStreamLocked = IsReadableStreamLocked;
+  binding.IsReadableStreamReader = IsReadableStreamReader;
+  binding.ReadFromReadableStreamReader = ReadFromReadableStreamReader;
+  binding.CloseReadableStream = CloseReadableStream;
+  binding.GetReadableStreamDesiredSize = GetReadableStreamDesiredSize;
+  binding.EnqueueInReadableStream = EnqueueInReadableStream;
+  binding.ErrorReadableStream = ErrorReadableStream;
+  binding.createReadableStreamWithExternalController =
+      (underlyingSource, strategy) => {
+        return new ReadableStream(
+            underlyingSource, strategy, createWithExternalControllerSentinel);
+      };
+});
diff --git a/bin/linux_64/Release/snapshot_blob.bin b/bin/linux_64/Release/snapshot_blob.bin
new file mode 100644
index 0000000..17e76b8
Binary files /dev/null and b/bin/linux_64/Release/snapshot_blob.bin differ
diff --git a/bin/linux_64/cef.pak b/bin/linux_64/cef.pak
new file mode 100644
index 0000000..ef6847c
Binary files /dev/null and b/bin/linux_64/cef.pak differ
diff --git a/bin/linux_64/cef_100_percent.pak b/bin/linux_64/cef_100_percent.pak
new file mode 100644
index 0000000..d936be2
Binary files /dev/null and b/bin/linux_64/cef_100_percent.pak differ
diff --git a/bin/linux_64/cef_200_percent.pak b/bin/linux_64/cef_200_percent.pak
new file mode 100644
index 0000000..3ffd1d8
Binary files /dev/null and b/bin/linux_64/cef_200_percent.pak differ
diff --git a/bin/linux_64/cef_extensions.pak b/bin/linux_64/cef_extensions.pak
new file mode 100644
index 0000000..cdda324
Binary files /dev/null and b/bin/linux_64/cef_extensions.pak differ
diff --git a/bin/linux_64/chrome-sandbox b/bin/linux_64/chrome-sandbox
new file mode 100644
index 0000000..1bf2b32
Binary files /dev/null and b/bin/linux_64/chrome-sandbox differ
diff --git a/bin/linux_64/devtools_resources.pak b/bin/linux_64/devtools_resources.pak
new file mode 100644
index 0000000..ffc399a
Binary files /dev/null and b/bin/linux_64/devtools_resources.pak differ
diff --git a/bin/linux_64/icudtl.dat b/bin/linux_64/icudtl.dat
new file mode 100644
index 0000000..1dbf249
Binary files /dev/null and b/bin/linux_64/icudtl.dat differ
diff --git a/bin/linux_64/locales/am.pak b/bin/linux_64/locales/am.pak
new file mode 100644
index 0000000..77913ff
Binary files /dev/null and b/bin/linux_64/locales/am.pak differ
diff --git a/bin/linux_64/locales/ar.pak b/bin/linux_64/locales/ar.pak
new file mode 100644
index 0000000..49c3226
Binary files /dev/null and b/bin/linux_64/locales/ar.pak differ
diff --git a/bin/linux_64/locales/bg.pak b/bin/linux_64/locales/bg.pak
new file mode 100644
index 0000000..0cb5f6f
Binary files /dev/null and b/bin/linux_64/locales/bg.pak differ
diff --git a/bin/linux_64/locales/bn.pak b/bin/linux_64/locales/bn.pak
new file mode 100644
index 0000000..626eafc
Binary files /dev/null and b/bin/linux_64/locales/bn.pak differ
diff --git a/bin/linux_64/locales/ca.pak b/bin/linux_64/locales/ca.pak
new file mode 100644
index 0000000..2f1d0a4
Binary files /dev/null and b/bin/linux_64/locales/ca.pak differ
diff --git a/bin/linux_64/locales/cs.pak b/bin/linux_64/locales/cs.pak
new file mode 100644
index 0000000..0d78595
Binary files /dev/null and b/bin/linux_64/locales/cs.pak differ
diff --git a/bin/linux_64/locales/da.pak b/bin/linux_64/locales/da.pak
new file mode 100644
index 0000000..d655ad1
Binary files /dev/null and b/bin/linux_64/locales/da.pak differ
diff --git a/bin/linux_64/locales/de.pak b/bin/linux_64/locales/de.pak
new file mode 100644
index 0000000..efb8e39
Binary files /dev/null and b/bin/linux_64/locales/de.pak differ
diff --git a/bin/linux_64/locales/el.pak b/bin/linux_64/locales/el.pak
new file mode 100644
index 0000000..9bbf30f
Binary files /dev/null and b/bin/linux_64/locales/el.pak differ
diff --git a/bin/linux_64/locales/en-GB.pak b/bin/linux_64/locales/en-GB.pak
new file mode 100644
index 0000000..8782f73
Binary files /dev/null and b/bin/linux_64/locales/en-GB.pak differ
diff --git a/bin/linux_64/locales/en-US.pak b/bin/linux_64/locales/en-US.pak
new file mode 100644
index 0000000..8d3c859
Binary files /dev/null and b/bin/linux_64/locales/en-US.pak differ
diff --git a/bin/linux_64/locales/es-419.pak b/bin/linux_64/locales/es-419.pak
new file mode 100644
index 0000000..1141341
Binary files /dev/null and b/bin/linux_64/locales/es-419.pak differ
diff --git a/bin/linux_64/locales/es.pak b/bin/linux_64/locales/es.pak
new file mode 100644
index 0000000..cd5bc78
Binary files /dev/null and b/bin/linux_64/locales/es.pak differ
diff --git a/bin/linux_64/locales/et.pak b/bin/linux_64/locales/et.pak
new file mode 100644
index 0000000..a8a2b52
Binary files /dev/null and b/bin/linux_64/locales/et.pak differ
diff --git a/bin/linux_64/locales/fa.pak b/bin/linux_64/locales/fa.pak
new file mode 100644
index 0000000..ae3a9fe
Binary files /dev/null and b/bin/linux_64/locales/fa.pak differ
diff --git a/bin/linux_64/locales/fi.pak b/bin/linux_64/locales/fi.pak
new file mode 100644
index 0000000..f347995
Binary files /dev/null and b/bin/linux_64/locales/fi.pak differ
diff --git a/bin/linux_64/locales/fil.pak b/bin/linux_64/locales/fil.pak
new file mode 100644
index 0000000..e8333d6
Binary files /dev/null and b/bin/linux_64/locales/fil.pak differ
diff --git a/bin/linux_64/locales/fr.pak b/bin/linux_64/locales/fr.pak
new file mode 100644
index 0000000..9866bfa
Binary files /dev/null and b/bin/linux_64/locales/fr.pak differ
diff --git a/bin/linux_64/locales/gu.pak b/bin/linux_64/locales/gu.pak
new file mode 100644
index 0000000..f414390
Binary files /dev/null and b/bin/linux_64/locales/gu.pak differ
diff --git a/bin/linux_64/locales/he.pak b/bin/linux_64/locales/he.pak
new file mode 100644
index 0000000..72ddb0c
Binary files /dev/null and b/bin/linux_64/locales/he.pak differ
diff --git a/bin/linux_64/locales/hi.pak b/bin/linux_64/locales/hi.pak
new file mode 100644
index 0000000..d97377e
Binary files /dev/null and b/bin/linux_64/locales/hi.pak differ
diff --git a/bin/linux_64/locales/hr.pak b/bin/linux_64/locales/hr.pak
new file mode 100644
index 0000000..caf395a
Binary files /dev/null and b/bin/linux_64/locales/hr.pak differ
diff --git a/bin/linux_64/locales/hu.pak b/bin/linux_64/locales/hu.pak
new file mode 100644
index 0000000..c8934ba
Binary files /dev/null and b/bin/linux_64/locales/hu.pak differ
diff --git a/bin/linux_64/locales/id.pak b/bin/linux_64/locales/id.pak
new file mode 100644
index 0000000..3812233
Binary files /dev/null and b/bin/linux_64/locales/id.pak differ
diff --git a/bin/linux_64/locales/it.pak b/bin/linux_64/locales/it.pak
new file mode 100644
index 0000000..1c4f43e
Binary files /dev/null and b/bin/linux_64/locales/it.pak differ
diff --git a/bin/linux_64/locales/ja.pak b/bin/linux_64/locales/ja.pak
new file mode 100644
index 0000000..309d4fd
Binary files /dev/null and b/bin/linux_64/locales/ja.pak differ
diff --git a/bin/linux_64/locales/kn.pak b/bin/linux_64/locales/kn.pak
new file mode 100644
index 0000000..1b51987
Binary files /dev/null and b/bin/linux_64/locales/kn.pak differ
diff --git a/bin/linux_64/locales/ko.pak b/bin/linux_64/locales/ko.pak
new file mode 100644
index 0000000..896f983
Binary files /dev/null and b/bin/linux_64/locales/ko.pak differ
diff --git a/bin/linux_64/locales/lt.pak b/bin/linux_64/locales/lt.pak
new file mode 100644
index 0000000..cd58e2c
Binary files /dev/null and b/bin/linux_64/locales/lt.pak differ
diff --git a/bin/linux_64/locales/lv.pak b/bin/linux_64/locales/lv.pak
new file mode 100644
index 0000000..f2a5096
Binary files /dev/null and b/bin/linux_64/locales/lv.pak differ
diff --git a/bin/linux_64/locales/ml.pak b/bin/linux_64/locales/ml.pak
new file mode 100644
index 0000000..b7f7f9b
Binary files /dev/null and b/bin/linux_64/locales/ml.pak differ
diff --git a/bin/linux_64/locales/mr.pak b/bin/linux_64/locales/mr.pak
new file mode 100644
index 0000000..e4f03b2
Binary files /dev/null and b/bin/linux_64/locales/mr.pak differ
diff --git a/bin/linux_64/locales/ms.pak b/bin/linux_64/locales/ms.pak
new file mode 100644
index 0000000..552402a
Binary files /dev/null and b/bin/linux_64/locales/ms.pak differ
diff --git a/bin/linux_64/locales/nb.pak b/bin/linux_64/locales/nb.pak
new file mode 100644
index 0000000..01d26bb
Binary files /dev/null and b/bin/linux_64/locales/nb.pak differ
diff --git a/bin/linux_64/locales/nl.pak b/bin/linux_64/locales/nl.pak
new file mode 100644
index 0000000..a049fd9
Binary files /dev/null and b/bin/linux_64/locales/nl.pak differ
diff --git a/bin/linux_64/locales/pl.pak b/bin/linux_64/locales/pl.pak
new file mode 100644
index 0000000..bd99140
Binary files /dev/null and b/bin/linux_64/locales/pl.pak differ
diff --git a/bin/linux_64/locales/pt-BR.pak b/bin/linux_64/locales/pt-BR.pak
new file mode 100644
index 0000000..27e695d
Binary files /dev/null and b/bin/linux_64/locales/pt-BR.pak differ
diff --git a/bin/linux_64/locales/pt-PT.pak b/bin/linux_64/locales/pt-PT.pak
new file mode 100644
index 0000000..9ffa8e6
Binary files /dev/null and b/bin/linux_64/locales/pt-PT.pak differ
diff --git a/bin/linux_64/locales/ro.pak b/bin/linux_64/locales/ro.pak
new file mode 100644
index 0000000..8a3ea51
Binary files /dev/null and b/bin/linux_64/locales/ro.pak differ
diff --git a/bin/linux_64/locales/ru.pak b/bin/linux_64/locales/ru.pak
new file mode 100644
index 0000000..247c969
Binary files /dev/null and b/bin/linux_64/locales/ru.pak differ
diff --git a/bin/linux_64/locales/sk.pak b/bin/linux_64/locales/sk.pak
new file mode 100644
index 0000000..e8126b7
Binary files /dev/null and b/bin/linux_64/locales/sk.pak differ
diff --git a/bin/linux_64/locales/sl.pak b/bin/linux_64/locales/sl.pak
new file mode 100644
index 0000000..74c98e6
Binary files /dev/null and b/bin/linux_64/locales/sl.pak differ
diff --git a/bin/linux_64/locales/sr.pak b/bin/linux_64/locales/sr.pak
new file mode 100644
index 0000000..86481ac
Binary files /dev/null and b/bin/linux_64/locales/sr.pak differ
diff --git a/bin/linux_64/locales/sv.pak b/bin/linux_64/locales/sv.pak
new file mode 100644
index 0000000..0d64c41
Binary files /dev/null and b/bin/linux_64/locales/sv.pak differ
diff --git a/bin/linux_64/locales/sw.pak b/bin/linux_64/locales/sw.pak
new file mode 100644
index 0000000..19214cc
Binary files /dev/null and b/bin/linux_64/locales/sw.pak differ
diff --git a/bin/linux_64/locales/ta.pak b/bin/linux_64/locales/ta.pak
new file mode 100644
index 0000000..001544d
Binary files /dev/null and b/bin/linux_64/locales/ta.pak differ
diff --git a/bin/linux_64/locales/te.pak b/bin/linux_64/locales/te.pak
new file mode 100644
index 0000000..72bf84f
Binary files /dev/null and b/bin/linux_64/locales/te.pak differ
diff --git a/bin/linux_64/locales/th.pak b/bin/linux_64/locales/th.pak
new file mode 100644
index 0000000..918caaa
Binary files /dev/null and b/bin/linux_64/locales/th.pak differ
diff --git a/bin/linux_64/locales/tr.pak b/bin/linux_64/locales/tr.pak
new file mode 100644
index 0000000..d73b33c
Binary files /dev/null and b/bin/linux_64/locales/tr.pak differ
diff --git a/bin/linux_64/locales/uk.pak b/bin/linux_64/locales/uk.pak
new file mode 100644
index 0000000..d12bbc8
Binary files /dev/null and b/bin/linux_64/locales/uk.pak differ
diff --git a/bin/linux_64/locales/vi.pak b/bin/linux_64/locales/vi.pak
new file mode 100644
index 0000000..47ece58
Binary files /dev/null and b/bin/linux_64/locales/vi.pak differ
diff --git a/bin/linux_64/locales/zh-CN.pak b/bin/linux_64/locales/zh-CN.pak
new file mode 100644
index 0000000..2f60869
Binary files /dev/null and b/bin/linux_64/locales/zh-CN.pak differ
diff --git a/bin/linux_64/locales/zh-TW.pak b/bin/linux_64/locales/zh-TW.pak
new file mode 100644
index 0000000..a1475d4
Binary files /dev/null and b/bin/linux_64/locales/zh-TW.pak differ
diff --git a/bin/linux_64/natives_blob.bin b/bin/linux_64/natives_blob.bin
new file mode 100644
index 0000000..b15de8f
--- /dev/null
+++ b/bin/linux_64/natives_blob.bin
@@ -0,0 +1,19292 @@
+mirrors�t
+(function(a,b){
+"use strict";
+var c;
+var d=a.Array;
+var e=a.isNaN;
+var f=a.JSON.stringify;
+var g;
+var h;
+var i;
+var j=a.Math.min;
+var k=b.ImportNow("promise_status_symbol");
+var l=b.ImportNow("promise_value_symbol");
+var m;
+var n;
+var o;
+b.Import(function(p){
+c=p.ErrorToString;
+g=p.MakeError;
+h=p.MapEntries;
+i=p.MapIteratorNext;
+m=p.SetIteratorNext;
+n=p.SetValues;
+o=p.SymbolToString;
+});
+var q={
+UNDEFINED_TYPE:'undefined',
+NULL_TYPE:'null',
+BOOLEAN_TYPE:'boolean',
+NUMBER_TYPE:'number',
+STRING_TYPE:'string',
+SYMBOL_TYPE:'symbol',
+OBJECT_TYPE:'object',
+FUNCTION_TYPE:'function',
+REGEXP_TYPE:'regexp',
+ERROR_TYPE:'error',
+PROPERTY_TYPE:'property',
+INTERNAL_PROPERTY_TYPE:'internalProperty',
+FRAME_TYPE:'frame',
+SCRIPT_TYPE:'script',
+CONTEXT_TYPE:'context',
+SCOPE_TYPE:'scope',
+PROMISE_TYPE:'promise',
+MAP_TYPE:'map',
+SET_TYPE:'set',
+ITERATOR_TYPE:'iterator',
+GENERATOR_TYPE:'generator',
+}
+var r=0;
+var s=-1;
+var t=[];
+var u=true;
+function MirrorCacheIsEmpty(){
+return r==0&&t.length==0;
+}
+function ToggleMirrorCache(v){
+u=v;
+ClearMirrorCache();
+}
+function ClearMirrorCache(v){
+r=0;
+t=[];
+}
+function ObjectIsPromise(v){
+return(%_IsJSReceiver(v))&&
+!(%DebugGetProperty(v,k)===(void 0));
+}
+function MakeMirror(v,w){
+var x;
+if(!w&&u){
+for(var y in t){
+x=t[y];
+if(x.value()===v){
+return x;
+}
+if(x.isNumber()&&e(x.value())&&
+typeof v=='number'&&e(v)){
+return x;
+}
+}
+}
+if((v===(void 0))){
+x=new UndefinedMirror();
+}else if((v===null)){
+x=new NullMirror();
+}else if((typeof(v)==='boolean')){
+x=new BooleanMirror(v);
+}else if((typeof(v)==='number')){
+x=new NumberMirror(v);
+}else if((typeof(v)==='string')){
+x=new StringMirror(v);
+}else if((typeof(v)==='symbol')){
+x=new SymbolMirror(v);
+}else if((%_IsArray(v))){
+x=new ArrayMirror(v);
+}else if((%IsDate(v))){
+x=new DateMirror(v);
+}else if((%IsFunction(v))){
+x=new FunctionMirror(v);
+}else if((%_IsRegExp(v))){
+x=new RegExpMirror(v);
+}else if((%_ClassOf(v)==='Error')){
+x=new ErrorMirror(v);
+}else if((%_ClassOf(v)==='Script')){
+x=new ScriptMirror(v);
+}else if((%_ClassOf(v)==='Map')||(%_ClassOf(v)==='WeakMap')){
+x=new MapMirror(v);
+}else if((%_ClassOf(v)==='Set')||(%_ClassOf(v)==='WeakSet')){
+x=new SetMirror(v);
+}else if((%_ClassOf(v)==='Map Iterator')||(%_ClassOf(v)==='Set Iterator')){
+x=new IteratorMirror(v);
+}else if(ObjectIsPromise(v)){
+x=new PromiseMirror(v);
+}else if((%_ClassOf(v)==='Generator')){
+x=new GeneratorMirror(v);
+}else{
+x=new ObjectMirror(v,q.OBJECT_TYPE,w);
+}
+if(u)t[x.handle()]=x;
+return x;
+}
+function LookupMirror(z){
+if(!u){
+throw g(2,"Mirror cache is disabled");
+}
+return t[z];
+}
+function GetUndefinedMirror(){
+return MakeMirror((void 0));
+}
+function inherits(A,B){
+var C=function(){};
+C.prototype=B.prototype;
+A.super_=B.prototype;
+A.prototype=new C();
+A.prototype.constructor=A;
+}
+var D=80;
+var E={};
+E.Data=0;
+E.DataConstant=2;
+E.AccessorConstant=3;
+var F={};
+F.None=0;
+F.ReadOnly=1;
+F.DontEnum=2;
+F.DontDelete=4;
+var G={Global:0,
+Local:1,
+With:2,
+Closure:3,
+Catch:4,
+Block:5,
+Script:6};
+function Mirror(H){
+this.type_=H;
+}
+Mirror.prototype.type=function(){
+return this.type_;
+};
+Mirror.prototype.isValue=function(){
+return this instanceof ValueMirror;
+};
+Mirror.prototype.isUndefined=function(){
+return this instanceof UndefinedMirror;
+};
+Mirror.prototype.isNull=function(){
+return this instanceof NullMirror;
+};
+Mirror.prototype.isBoolean=function(){
+return this instanceof BooleanMirror;
+};
+Mirror.prototype.isNumber=function(){
+return this instanceof NumberMirror;
+};
+Mirror.prototype.isString=function(){
+return this instanceof StringMirror;
+};
+Mirror.prototype.isSymbol=function(){
+return this instanceof SymbolMirror;
+};
+Mirror.prototype.isObject=function(){
+return this instanceof ObjectMirror;
+};
+Mirror.prototype.isFunction=function(){
+return this instanceof FunctionMirror;
+};
+Mirror.prototype.isUnresolvedFunction=function(){
+return this instanceof UnresolvedFunctionMirror;
+};
+Mirror.prototype.isArray=function(){
+return this instanceof ArrayMirror;
+};
+Mirror.prototype.isDate=function(){
+return this instanceof DateMirror;
+};
+Mirror.prototype.isRegExp=function(){
+return this instanceof RegExpMirror;
+};
+Mirror.prototype.isError=function(){
+return this instanceof ErrorMirror;
+};
+Mirror.prototype.isPromise=function(){
+return this instanceof PromiseMirror;
+};
+Mirror.prototype.isGenerator=function(){
+return this instanceof GeneratorMirror;
+};
+Mirror.prototype.isProperty=function(){
+return this instanceof PropertyMirror;
+};
+Mirror.prototype.isInternalProperty=function(){
+return this instanceof InternalPropertyMirror;
+};
+Mirror.prototype.isFrame=function(){
+return this instanceof FrameMirror;
+};
+Mirror.prototype.isScript=function(){
+return this instanceof ScriptMirror;
+};
+Mirror.prototype.isContext=function(){
+return this instanceof ContextMirror;
+};
+Mirror.prototype.isScope=function(){
+return this instanceof ScopeMirror;
+};
+Mirror.prototype.isMap=function(){
+return this instanceof MapMirror;
+};
+Mirror.prototype.isSet=function(){
+return this instanceof SetMirror;
+};
+Mirror.prototype.isIterator=function(){
+return this instanceof IteratorMirror;
+};
+Mirror.prototype.allocateHandle_=function(){
+if(u)this.handle_=r++;
+};
+Mirror.prototype.allocateTransientHandle_=function(){
+this.handle_=s--;
+};
+Mirror.prototype.toText=function(){
+return"#<"+this.constructor.name+">";
+};
+function ValueMirror(H,v,I){
+%_Call(Mirror,this,H);
+this.value_=v;
+if(!I){
+this.allocateHandle_();
+}else{
+this.allocateTransientHandle_();
+}
+}
+inherits(ValueMirror,Mirror);
+Mirror.prototype.handle=function(){
+return this.handle_;
+};
+ValueMirror.prototype.isPrimitive=function(){
+var H=this.type();
+return H==='undefined'||
+H==='null'||
+H==='boolean'||
+H==='number'||
+H==='string'||
+H==='symbol';
+};
+ValueMirror.prototype.value=function(){
+return this.value_;
+};
+function UndefinedMirror(){
+%_Call(ValueMirror,this,q.UNDEFINED_TYPE,(void 0));
+}
+inherits(UndefinedMirror,ValueMirror);
+UndefinedMirror.prototype.toText=function(){
+return'undefined';
+};
+function NullMirror(){
+%_Call(ValueMirror,this,q.NULL_TYPE,null);
+}
+inherits(NullMirror,ValueMirror);
+NullMirror.prototype.toText=function(){
+return'null';
+};
+function BooleanMirror(v){
+%_Call(ValueMirror,this,q.BOOLEAN_TYPE,v);
+}
+inherits(BooleanMirror,ValueMirror);
+BooleanMirror.prototype.toText=function(){
+return this.value_?'true':'false';
+};
+function NumberMirror(v){
+%_Call(ValueMirror,this,q.NUMBER_TYPE,v);
+}
+inherits(NumberMirror,ValueMirror);
+NumberMirror.prototype.toText=function(){
+return %_NumberToString(this.value_);
+};
+function StringMirror(v){
+%_Call(ValueMirror,this,q.STRING_TYPE,v);
+}
+inherits(StringMirror,ValueMirror);
+StringMirror.prototype.length=function(){
+return this.value_.length;
+};
+StringMirror.prototype.getTruncatedValue=function(J){
+if(J!=-1&&this.length()>J){
+return this.value_.substring(0,J)+
+'... (length: '+this.length()+')';
+}
+return this.value_;
+};
+StringMirror.prototype.toText=function(){
+return this.getTruncatedValue(D);
+};
+function SymbolMirror(v){
+%_Call(ValueMirror,this,q.SYMBOL_TYPE,v);
+}
+inherits(SymbolMirror,ValueMirror);
+SymbolMirror.prototype.description=function(){
+return %SymbolDescription(%_ValueOf(this.value_));
+}
+SymbolMirror.prototype.toText=function(){
+return %_Call(o,this.value_);
+}
+function ObjectMirror(v,H,I){
+H=H||q.OBJECT_TYPE;
+%_Call(ValueMirror,this,H,v,I);
+}
+inherits(ObjectMirror,ValueMirror);
+ObjectMirror.prototype.className=function(){
+return %_ClassOf(this.value_);
+};
+ObjectMirror.prototype.constructorFunction=function(){
+return MakeMirror(%DebugGetProperty(this.value_,'constructor'));
+};
+ObjectMirror.prototype.prototypeObject=function(){
+return MakeMirror(%DebugGetProperty(this.value_,'prototype'));
+};
+ObjectMirror.prototype.protoObject=function(){
+return MakeMirror(%DebugGetPrototype(this.value_));
+};
+ObjectMirror.prototype.hasNamedInterceptor=function(){
+var K=%GetInterceptorInfo(this.value_);
+return(K&2)!=0;
+};
+ObjectMirror.prototype.hasIndexedInterceptor=function(){
+var K=%GetInterceptorInfo(this.value_);
+return(K&1)!=0;
+};
+ObjectMirror.prototype.propertyNames=function(){
+return %GetOwnPropertyKeys(this.value_,0);
+};
+ObjectMirror.prototype.properties=function(){
+var L=this.propertyNames();
+var M=new d(L.length);
+for(var N=0;N<L.length;N++){
+M[N]=this.property(L[N]);
+}
+return M;
+};
+ObjectMirror.prototype.internalProperties=function(){
+return ObjectMirror.GetInternalProperties(this.value_);
+}
+ObjectMirror.prototype.property=function(O){
+var P=%DebugGetPropertyDetails(this.value_,(%_ToName(O)));
+if(P){
+return new PropertyMirror(this,O,P);
+}
+return GetUndefinedMirror();
+};
+ObjectMirror.prototype.lookupProperty=function(v){
+var M=this.properties();
+for(var N=0;N<M.length;N++){
+var Q=M[N];
+if(Q.propertyType()!=E.AccessorConstant){
+if(Q.value_===v.value_){
+return Q;
+}
+}
+}
+return GetUndefinedMirror();
+};
+ObjectMirror.prototype.referencedBy=function(R){
+var S=%DebugReferencedBy(this.value_,
+Mirror.prototype,R||0);
+for(var N=0;N<S.length;N++){
+S[N]=MakeMirror(S[N]);
+}
+return S;
+};
+ObjectMirror.prototype.toText=function(){
+var O;
+var A=this.constructorFunction();
+if(!A.isFunction()){
+O=this.className();
+}else{
+O=A.name();
+if(!O){
+O=this.className();
+}
+}
+return'#<'+O+'>';
+};
+ObjectMirror.GetInternalProperties=function(v){
+var M=%DebugGetInternalProperties(v);
+var S=[];
+for(var N=0;N<M.length;N+=2){
+S.push(new InternalPropertyMirror(M[N],M[N+1]));
+}
+return S;
+}
+function FunctionMirror(v){
+%_Call(ObjectMirror,this,v,q.FUNCTION_TYPE);
+this.resolved_=true;
+}
+inherits(FunctionMirror,ObjectMirror);
+FunctionMirror.prototype.resolved=function(){
+return this.resolved_;
+};
+FunctionMirror.prototype.name=function(){
+return %FunctionGetName(this.value_);
+};
+FunctionMirror.prototype.debugName=function(){
+return %FunctionGetDebugName(this.value_);
+}
+FunctionMirror.prototype.inferredName=function(){
+return %FunctionGetInferredName(this.value_);
+};
+FunctionMirror.prototype.source=function(){
+if(this.resolved()){
+return %FunctionToString(this.value_);
+}
+};
+FunctionMirror.prototype.script=function(){
+if(this.resolved()){
+if(this.script_){
+return this.script_;
+}
+var T=%FunctionGetScript(this.value_);
+if(T){
+return this.script_=MakeMirror(T);
+}
+}
+};
+FunctionMirror.prototype.sourcePosition_=function(){
+if(this.resolved()){
+return %FunctionGetScriptSourcePosition(this.value_);
+}
+};
+FunctionMirror.prototype.sourceLocation=function(){
+if(this.resolved()){
+var T=this.script();
+if(T){
+return T.locationFromPosition(this.sourcePosition_(),true);
+}
+}
+};
+FunctionMirror.prototype.constructedBy=function(U){
+if(this.resolved()){
+var S=%DebugConstructedBy(this.value_,U||0);
+for(var N=0;N<S.length;N++){
+S[N]=MakeMirror(S[N]);
+}
+return S;
+}else{
+return[];
+}
+};
+FunctionMirror.prototype.scopeCount=function(){
+if(this.resolved()){
+if((this.scopeCount_===(void 0))){
+this.scopeCount_=%GetFunctionScopeCount(this.value());
+}
+return this.scopeCount_;
+}else{
+return 0;
+}
+};
+FunctionMirror.prototype.scope=function(V){
+if(this.resolved()){
+return new ScopeMirror((void 0),this,V);
+}
+};
+FunctionMirror.prototype.toText=function(){
+return this.source();
+};
+FunctionMirror.prototype.context=function(){
+if(this.resolved()){
+if(!this._context)
+this._context=new ContextMirror(%FunctionGetContextData(this.value_));
+return this._context;
+}
+};
+function UnresolvedFunctionMirror(v){
+%_Call(ValueMirror,this,q.FUNCTION_TYPE,v);
+this.propertyCount_=0;
+this.elementCount_=0;
+this.resolved_=false;
+}
+inherits(UnresolvedFunctionMirror,FunctionMirror);
+UnresolvedFunctionMirror.prototype.className=function(){
+return'Function';
+};
+UnresolvedFunctionMirror.prototype.constructorFunction=function(){
+return GetUndefinedMirror();
+};
+UnresolvedFunctionMirror.prototype.prototypeObject=function(){
+return GetUndefinedMirror();
+};
+UnresolvedFunctionMirror.prototype.protoObject=function(){
+return GetUndefinedMirror();
+};
+UnresolvedFunctionMirror.prototype.name=function(){
+return this.value_;
+};
+UnresolvedFunctionMirror.prototype.inferredName=function(){
+return(void 0);
+};
+UnresolvedFunctionMirror.prototype.propertyNames=function(W,X){
+return[];
+};
+function ArrayMirror(v){
+%_Call(ObjectMirror,this,v);
+}
+inherits(ArrayMirror,ObjectMirror);
+ArrayMirror.prototype.length=function(){
+return this.value_.length;
+};
+ArrayMirror.prototype.indexedPropertiesFromRange=function(opt_from_index,
+opt_to_index){
+var Y=opt_from_index||0;
+var Z=opt_to_index||this.length()-1;
+if(Y>Z)return new d();
+var aa=new d(Z-Y+1);
+for(var N=Y;N<=Z;N++){
+var P=%DebugGetPropertyDetails(this.value_,(%_ToString(N)));
+var v;
+if(P){
+v=new PropertyMirror(this,N,P);
+}else{
+v=GetUndefinedMirror();
+}
+aa[N-Y]=v;
+}
+return aa;
+};
+function DateMirror(v){
+%_Call(ObjectMirror,this,v);
+}
+inherits(DateMirror,ObjectMirror);
+DateMirror.prototype.toText=function(){
+var ab=f(this.value_);
+return ab.substring(1,ab.length-1);
+};
+function RegExpMirror(v){
+%_Call(ObjectMirror,this,v,q.REGEXP_TYPE);
+}
+inherits(RegExpMirror,ObjectMirror);
+RegExpMirror.prototype.source=function(){
+return this.value_.source;
+};
+RegExpMirror.prototype.global=function(){
+return this.value_.global;
+};
+RegExpMirror.prototype.ignoreCase=function(){
+return this.value_.ignoreCase;
+};
+RegExpMirror.prototype.multiline=function(){
+return this.value_.multiline;
+};
+RegExpMirror.prototype.sticky=function(){
+return this.value_.sticky;
+};
+RegExpMirror.prototype.unicode=function(){
+return this.value_.unicode;
+};
+RegExpMirror.prototype.toText=function(){
+return"/"+this.source()+"/";
+};
+function ErrorMirror(v){
+%_Call(ObjectMirror,this,v,q.ERROR_TYPE);
+}
+inherits(ErrorMirror,ObjectMirror);
+ErrorMirror.prototype.message=function(){
+return this.value_.message;
+};
+ErrorMirror.prototype.toText=function(){
+var ac;
+try{
+ac=%_Call(c,this.value_);
+}catch(e){
+ac='#<Error>';
+}
+return ac;
+};
+function PromiseMirror(v){
+%_Call(ObjectMirror,this,v,q.PROMISE_TYPE);
+}
+inherits(PromiseMirror,ObjectMirror);
+function PromiseGetStatus_(v){
+var ad=%DebugGetProperty(v,k);
+if(ad==0)return"pending";
+if(ad==1)return"resolved";
+return"rejected";
+}
+function PromiseGetValue_(v){
+return %DebugGetProperty(v,l);
+}
+PromiseMirror.prototype.status=function(){
+return PromiseGetStatus_(this.value_);
+};
+PromiseMirror.prototype.promiseValue=function(){
+return MakeMirror(PromiseGetValue_(this.value_));
+};
+function MapMirror(v){
+%_Call(ObjectMirror,this,v,q.MAP_TYPE);
+}
+inherits(MapMirror,ObjectMirror);
+MapMirror.prototype.entries=function(ae){
+var S=[];
+if((%_ClassOf(this.value_)==='WeakMap')){
+var af=%GetWeakMapEntries(this.value_,ae||0);
+for(var N=0;N<af.length;N+=2){
+S.push({
+key:af[N],
+value:af[N+1]
+});
+}
+return S;
+}
+var ag=%_Call(h,this.value_);
+var ah;
+while((!ae||S.length<ae)&&
+!(ah=ag.next()).done){
+S.push({
+key:ah.value[0],
+value:ah.value[1]
+});
+}
+return S;
+};
+function SetMirror(v){
+%_Call(ObjectMirror,this,v,q.SET_TYPE);
+}
+inherits(SetMirror,ObjectMirror);
+function IteratorGetValues_(ag,ai,ae){
+var S=[];
+var ah;
+while((!ae||S.length<ae)&&
+!(ah=%_Call(ai,ag)).done){
+S.push(ah.value);
+}
+return S;
+}
+SetMirror.prototype.values=function(ae){
+if((%_ClassOf(this.value_)==='WeakSet')){
+return %GetWeakSetValues(this.value_,ae||0);
+}
+var ag=%_Call(n,this.value_);
+return IteratorGetValues_(ag,m,ae);
+};
+function IteratorMirror(v){
+%_Call(ObjectMirror,this,v,q.ITERATOR_TYPE);
+}
+inherits(IteratorMirror,ObjectMirror);
+IteratorMirror.prototype.preview=function(ae){
+if((%_ClassOf(this.value_)==='Map Iterator')){
+return IteratorGetValues_(%MapIteratorClone(this.value_),
+i,
+ae);
+}else if((%_ClassOf(this.value_)==='Set Iterator')){
+return IteratorGetValues_(%SetIteratorClone(this.value_),
+m,
+ae);
+}
+};
+function GeneratorMirror(v){
+%_Call(ObjectMirror,this,v,q.GENERATOR_TYPE);
+}
+inherits(GeneratorMirror,ObjectMirror);
+function GeneratorGetStatus_(v){
+var aj=%GeneratorGetContinuation(v);
+if(aj<0)return"running";
+if(aj==0)return"closed";
+return"suspended";
+}
+GeneratorMirror.prototype.status=function(){
+return GeneratorGetStatus_(this.value_);
+};
+GeneratorMirror.prototype.sourcePosition_=function(){
+return %GeneratorGetSourcePosition(this.value_);
+};
+GeneratorMirror.prototype.sourceLocation=function(){
+var ak=this.sourcePosition_();
+if(!(ak===(void 0))){
+var T=this.func().script();
+if(T){
+return T.locationFromPosition(ak,true);
+}
+}
+};
+GeneratorMirror.prototype.func=function(){
+if(!this.func_){
+this.func_=MakeMirror(%GeneratorGetFunction(this.value_));
+}
+return this.func_;
+};
+GeneratorMirror.prototype.receiver=function(){
+if(!this.receiver_){
+this.receiver_=MakeMirror(%GeneratorGetReceiver(this.value_));
+}
+return this.receiver_;
+};
+function PropertyMirror(x,O,P){
+%_Call(Mirror,this,q.PROPERTY_TYPE);
+this.mirror_=x;
+this.name_=O;
+this.value_=P[0];
+this.details_=P[1];
+this.is_interceptor_=P[2];
+if(P.length>3){
+this.exception_=P[3];
+this.getter_=P[4];
+this.setter_=P[5];
+}
+}
+inherits(PropertyMirror,Mirror);
+PropertyMirror.prototype.isReadOnly=function(){
+return(this.attributes()&F.ReadOnly)!=0;
+};
+PropertyMirror.prototype.isEnum=function(){
+return(this.attributes()&F.DontEnum)==0;
+};
+PropertyMirror.prototype.canDelete=function(){
+return(this.attributes()&F.DontDelete)==0;
+};
+PropertyMirror.prototype.name=function(){
+return this.name_;
+};
+PropertyMirror.prototype.isIndexed=function(){
+for(var N=0;N<this.name_.length;N++){
+if(this.name_[N]<'0'||'9'<this.name_[N]){
+return false;
+}
+}
+return true;
+};
+PropertyMirror.prototype.value=function(){
+return MakeMirror(this.value_,false);
+};
+PropertyMirror.prototype.isException=function(){
+return this.exception_?true:false;
+};
+PropertyMirror.prototype.attributes=function(){
+return %DebugPropertyAttributesFromDetails(this.details_);
+};
+PropertyMirror.prototype.propertyType=function(){
+return %DebugPropertyTypeFromDetails(this.details_);
+};
+PropertyMirror.prototype.insertionIndex=function(){
+return %DebugPropertyIndexFromDetails(this.details_);
+};
+PropertyMirror.prototype.hasGetter=function(){
+return this.getter_?true:false;
+};
+PropertyMirror.prototype.hasSetter=function(){
+return this.setter_?true:false;
+};
+PropertyMirror.prototype.getter=function(){
+if(this.hasGetter()){
+return MakeMirror(this.getter_);
+}else{
+return GetUndefinedMirror();
+}
+};
+PropertyMirror.prototype.setter=function(){
+if(this.hasSetter()){
+return MakeMirror(this.setter_);
+}else{
+return GetUndefinedMirror();
+}
+};
+PropertyMirror.prototype.isNative=function(){
+return this.is_interceptor_||
+((this.propertyType()==E.AccessorConstant)&&
+!this.hasGetter()&&!this.hasSetter());
+};
+function InternalPropertyMirror(O,v){
+%_Call(Mirror,this,q.INTERNAL_PROPERTY_TYPE);
+this.name_=O;
+this.value_=v;
+}
+inherits(InternalPropertyMirror,Mirror);
+InternalPropertyMirror.prototype.name=function(){
+return this.name_;
+};
+InternalPropertyMirror.prototype.value=function(){
+return MakeMirror(this.value_,false);
+};
+var al=0;
+var am=1;
+var an=2;
+var ao=3;
+var ap=4;
+var aq=5;
+var ar=6;
+var as=7;
+var at=8;
+var au=9;
+var av=0;
+var aw=1;
+var ax=2;
+var ay=1<<0;
+var az=1<<1;
+var aA=7<<2;
+function FrameDetails(aB,V){
+this.break_id_=aB;
+this.details_=%GetFrameDetails(aB,V);
+}
+FrameDetails.prototype.frameId=function(){
+%CheckExecutionState(this.break_id_);
+return this.details_[al];
+};
+FrameDetails.prototype.receiver=function(){
+%CheckExecutionState(this.break_id_);
+return this.details_[am];
+};
+FrameDetails.prototype.func=function(){
+%CheckExecutionState(this.break_id_);
+return this.details_[an];
+};
+FrameDetails.prototype.isConstructCall=function(){
+%CheckExecutionState(this.break_id_);
+return this.details_[ar];
+};
+FrameDetails.prototype.isAtReturn=function(){
+%CheckExecutionState(this.break_id_);
+return this.details_[as];
+};
+FrameDetails.prototype.isDebuggerFrame=function(){
+%CheckExecutionState(this.break_id_);
+var aC=ay;
+return(this.details_[at]&aC)==aC;
+};
+FrameDetails.prototype.isOptimizedFrame=function(){
+%CheckExecutionState(this.break_id_);
+var aC=az;
+return(this.details_[at]&aC)==aC;
+};
+FrameDetails.prototype.isInlinedFrame=function(){
+return this.inlinedFrameIndex()>0;
+};
+FrameDetails.prototype.inlinedFrameIndex=function(){
+%CheckExecutionState(this.break_id_);
+var aC=aA;
+return(this.details_[at]&aC)>>2;
+};
+FrameDetails.prototype.argumentCount=function(){
+%CheckExecutionState(this.break_id_);
+return this.details_[ao];
+};
+FrameDetails.prototype.argumentName=function(V){
+%CheckExecutionState(this.break_id_);
+if(V>=0&&V<this.argumentCount()){
+return this.details_[au+
+V*ax+
+av];
+}
+};
+FrameDetails.prototype.argumentValue=function(V){
+%CheckExecutionState(this.break_id_);
+if(V>=0&&V<this.argumentCount()){
+return this.details_[au+
+V*ax+
+aw];
+}
+};
+FrameDetails.prototype.localCount=function(){
+%CheckExecutionState(this.break_id_);
+return this.details_[ap];
+};
+FrameDetails.prototype.sourcePosition=function(){
+%CheckExecutionState(this.break_id_);
+return this.details_[aq];
+};
+FrameDetails.prototype.localName=function(V){
+%CheckExecutionState(this.break_id_);
+if(V>=0&&V<this.localCount()){
+var aD=au+
+this.argumentCount()*ax;
+return this.details_[aD+
+V*ax+
+av];
+}
+};
+FrameDetails.prototype.localValue=function(V){
+%CheckExecutionState(this.break_id_);
+if(V>=0&&V<this.localCount()){
+var aD=au+
+this.argumentCount()*ax;
+return this.details_[aD+
+V*ax+
+aw];
+}
+};
+FrameDetails.prototype.returnValue=function(){
+%CheckExecutionState(this.break_id_);
+var aE=
+au+
+(this.argumentCount()+this.localCount())*ax;
+if(this.details_[as]){
+return this.details_[aE];
+}
+};
+FrameDetails.prototype.scopeCount=function(){
+if((this.scopeCount_===(void 0))){
+this.scopeCount_=%GetScopeCount(this.break_id_,this.frameId());
+}
+return this.scopeCount_;
+};
+function FrameMirror(aB,V){
+%_Call(Mirror,this,q.FRAME_TYPE);
+this.break_id_=aB;
+this.index_=V;
+this.details_=new FrameDetails(aB,V);
+}
+inherits(FrameMirror,Mirror);
+FrameMirror.prototype.details=function(){
+return this.details_;
+};
+FrameMirror.prototype.index=function(){
+return this.index_;
+};
+FrameMirror.prototype.func=function(){
+if(this.func_){
+return this.func_;
+}
+var aC=this.details_.func();
+if((%IsFunction(aC))){
+return this.func_=MakeMirror(aC);
+}else{
+return new UnresolvedFunctionMirror(aC);
+}
+};
+FrameMirror.prototype.receiver=function(){
+return MakeMirror(this.details_.receiver());
+};
+FrameMirror.prototype.isConstructCall=function(){
+return this.details_.isConstructCall();
+};
+FrameMirror.prototype.isAtReturn=function(){
+return this.details_.isAtReturn();
+};
+FrameMirror.prototype.isDebuggerFrame=function(){
+return this.details_.isDebuggerFrame();
+};
+FrameMirror.prototype.isOptimizedFrame=function(){
+return this.details_.isOptimizedFrame();
+};
+FrameMirror.prototype.isInlinedFrame=function(){
+return this.details_.isInlinedFrame();
+};
+FrameMirror.prototype.inlinedFrameIndex=function(){
+return this.details_.inlinedFrameIndex();
+};
+FrameMirror.prototype.argumentCount=function(){
+return this.details_.argumentCount();
+};
+FrameMirror.prototype.argumentName=function(V){
+return this.details_.argumentName(V);
+};
+FrameMirror.prototype.argumentValue=function(V){
+return MakeMirror(this.details_.argumentValue(V));
+};
+FrameMirror.prototype.localCount=function(){
+return this.details_.localCount();
+};
+FrameMirror.prototype.localName=function(V){
+return this.details_.localName(V);
+};
+FrameMirror.prototype.localValue=function(V){
+return MakeMirror(this.details_.localValue(V));
+};
+FrameMirror.prototype.returnValue=function(){
+return MakeMirror(this.details_.returnValue());
+};
+FrameMirror.prototype.sourcePosition=function(){
+return this.details_.sourcePosition();
+};
+FrameMirror.prototype.sourceLocation=function(){
+var aF=this.func();
+if(aF.resolved()){
+var T=aF.script();
+if(T){
+return T.locationFromPosition(this.sourcePosition(),true);
+}
+}
+};
+FrameMirror.prototype.sourceLine=function(){
+var aG=this.sourceLocation();
+if(aG){
+return aG.line;
+}
+};
+FrameMirror.prototype.sourceColumn=function(){
+var aG=this.sourceLocation();
+if(aG){
+return aG.column;
+}
+};
+FrameMirror.prototype.sourceLineText=function(){
+var aG=this.sourceLocation();
+if(aG){
+return aG.sourceText();
+}
+};
+FrameMirror.prototype.scopeCount=function(){
+return this.details_.scopeCount();
+};
+FrameMirror.prototype.scope=function(V){
+return new ScopeMirror(this,(void 0),V);
+};
+FrameMirror.prototype.allScopes=function(aH){
+var aI=%GetAllScopesDetails(this.break_id_,
+this.details_.frameId(),
+this.details_.inlinedFrameIndex(),
+!!aH);
+var S=[];
+for(var N=0;N<aI.length;++N){
+S.push(new ScopeMirror(this,(void 0),N,aI[N]));
+}
+return S;
+};
+FrameMirror.prototype.evaluate=function(source,disable_break,
+opt_context_object){
+return MakeMirror(%DebugEvaluate(this.break_id_,
+this.details_.frameId(),
+this.details_.inlinedFrameIndex(),
+source,
+(!!(disable_break)),
+opt_context_object));
+};
+FrameMirror.prototype.invocationText=function(){
+var S='';
+var aF=this.func();
+var aJ=this.receiver();
+if(this.isConstructCall()){
+S+='new ';
+S+=aF.name()?aF.name():'[anonymous]';
+}else if(this.isDebuggerFrame()){
+S+='[debugger]';
+}else{
+var aK=
+!aJ.className||(aJ.className()!='global');
+if(aK){
+S+=aJ.toText();
+}
+var Q=GetUndefinedMirror();
+if(aJ.isObject()){
+for(var aL=aJ;
+!aL.isNull()&&Q.isUndefined();
+aL=aL.protoObject()){
+Q=aL.lookupProperty(aF);
+}
+}
+if(!Q.isUndefined()){
+if(!Q.isIndexed()){
+if(aK){
+S+='.';
+}
+S+=Q.name();
+}else{
+S+='[';
+S+=Q.name();
+S+=']';
+}
+if(aF.name()&&aF.name()!=Q.name()){
+S+='(aka '+aF.name()+')';
+}
+}else{
+if(aK){
+S+='.';
+}
+S+=aF.name()?aF.name():'[anonymous]';
+}
+}
+if(!this.isDebuggerFrame()){
+S+='(';
+for(var N=0;N<this.argumentCount();N++){
+if(N!=0)S+=', ';
+if(this.argumentName(N)){
+S+=this.argumentName(N);
+S+='=';
+}
+S+=this.argumentValue(N).toText();
+}
+S+=')';
+}
+if(this.isAtReturn()){
+S+=' returning ';
+S+=this.returnValue().toText();
+}
+return S;
+};
+FrameMirror.prototype.sourceAndPositionText=function(){
+var S='';
+var aF=this.func();
+if(aF.resolved()){
+var T=aF.script();
+if(T){
+if(T.name()){
+S+=T.name();
+}else{
+S+='[unnamed]';
+}
+if(!this.isDebuggerFrame()){
+var aG=this.sourceLocation();
+S+=' line ';
+S+=!(aG===(void 0))?(aG.line+1):'?';
+S+=' column ';
+S+=!(aG===(void 0))?(aG.column+1):'?';
+if(!(this.sourcePosition()===(void 0))){
+S+=' (position '+(this.sourcePosition()+1)+')';
+}
+}
+}else{
+S+='[no source]';
+}
+}else{
+S+='[unresolved]';
+}
+return S;
+};
+FrameMirror.prototype.localsText=function(){
+var S='';
+var aM=this.localCount();
+if(aM>0){
+for(var N=0;N<aM;++N){
+S+='      var ';
+S+=this.localName(N);
+S+=' = ';
+S+=this.localValue(N).toText();
+if(N<aM-1)S+='\n';
+}
+}
+return S;
+};
+FrameMirror.prototype.restart=function(){
+var S=%LiveEditRestartFrame(this.break_id_,this.index_);
+if((S===(void 0))){
+S="Failed to find requested frame";
+}
+return S;
+};
+FrameMirror.prototype.toText=function(aN){
+var S='';
+S+='#'+(this.index()<=9?'0':'')+this.index();
+S+=' ';
+S+=this.invocationText();
+S+=' ';
+S+=this.sourceAndPositionText();
+if(aN){
+S+='\n';
+S+=this.localsText();
+}
+return S;
+};
+var aO=0;
+var aP=1;
+var aQ=2;
+var aR=3;
+var aS=4;
+var aT=5;
+function ScopeDetails(aU,aV,V,aW){
+if(aU){
+this.break_id_=aU.break_id_;
+this.details_=aW||
+%GetScopeDetails(aU.break_id_,
+aU.details_.frameId(),
+aU.details_.inlinedFrameIndex(),
+V);
+this.frame_id_=aU.details_.frameId();
+this.inlined_frame_id_=aU.details_.inlinedFrameIndex();
+}else{
+this.details_=aW||%GetFunctionScopeDetails(aV.value(),V);
+this.fun_value_=aV.value();
+this.break_id_=(void 0);
+}
+this.index_=V;
+}
+ScopeDetails.prototype.type=function(){
+if(!(this.break_id_===(void 0))){
+%CheckExecutionState(this.break_id_);
+}
+return this.details_[aO];
+};
+ScopeDetails.prototype.object=function(){
+if(!(this.break_id_===(void 0))){
+%CheckExecutionState(this.break_id_);
+}
+return this.details_[aP];
+};
+ScopeDetails.prototype.name=function(){
+if(!(this.break_id_===(void 0))){
+%CheckExecutionState(this.break_id_);
+}
+return this.details_[aQ];
+};
+ScopeDetails.prototype.startPosition=function(){
+if(!(this.break_id_===(void 0))){
+%CheckExecutionState(this.break_id_);
+}
+return this.details_[aR];
+}
+ScopeDetails.prototype.endPosition=function(){
+if(!(this.break_id_===(void 0))){
+%CheckExecutionState(this.break_id_);
+}
+return this.details_[aS];
+}
+ScopeDetails.prototype.func=function(){
+if(!(this.break_id_===(void 0))){
+%CheckExecutionState(this.break_id_);
+}
+return this.details_[aT];
+}
+ScopeDetails.prototype.setVariableValueImpl=function(O,aX){
+var aY;
+if(!(this.break_id_===(void 0))){
+%CheckExecutionState(this.break_id_);
+aY=%SetScopeVariableValue(this.break_id_,this.frame_id_,
+this.inlined_frame_id_,this.index_,O,aX);
+}else{
+aY=%SetScopeVariableValue(this.fun_value_,null,null,this.index_,
+O,aX);
+}
+if(!aY)throw g(2,"Failed to set variable value");
+};
+function ScopeMirror(aU,aV,V,aW){
+%_Call(Mirror,this,q.SCOPE_TYPE);
+if(aU){
+this.frame_index_=aU.index_;
+}else{
+this.frame_index_=(void 0);
+}
+this.scope_index_=V;
+this.details_=new ScopeDetails(aU,aV,V,aW);
+}
+inherits(ScopeMirror,Mirror);
+ScopeMirror.prototype.details=function(){
+return this.details_;
+};
+ScopeMirror.prototype.frameIndex=function(){
+return this.frame_index_;
+};
+ScopeMirror.prototype.scopeIndex=function(){
+return this.scope_index_;
+};
+ScopeMirror.prototype.scopeType=function(){
+return this.details_.type();
+};
+ScopeMirror.prototype.scopeObject=function(){
+var I=this.scopeType()==G.Local||
+this.scopeType()==G.Closure||
+this.scopeType()==G.Script;
+return MakeMirror(this.details_.object(),I);
+};
+ScopeMirror.prototype.setVariableValue=function(O,aX){
+this.details_.setVariableValueImpl(O,aX);
+};
+function ScriptMirror(T){
+%_Call(Mirror,this,q.SCRIPT_TYPE);
+this.script_=T;
+this.context_=new ContextMirror(T.context_data);
+this.allocateHandle_();
+}
+inherits(ScriptMirror,Mirror);
+ScriptMirror.prototype.value=function(){
+return this.script_;
+};
+ScriptMirror.prototype.name=function(){
+return this.script_.name||this.script_.nameOrSourceURL();
+};
+ScriptMirror.prototype.id=function(){
+return this.script_.id;
+};
+ScriptMirror.prototype.source=function(){
+return this.script_.source;
+};
+ScriptMirror.prototype.setSource=function(aZ){
+%DebugSetScriptSource(this.script_,aZ);
+};
+ScriptMirror.prototype.lineOffset=function(){
+return this.script_.line_offset;
+};
+ScriptMirror.prototype.columnOffset=function(){
+return this.script_.column_offset;
+};
+ScriptMirror.prototype.data=function(){
+return this.script_.data;
+};
+ScriptMirror.prototype.scriptType=function(){
+return this.script_.type;
+};
+ScriptMirror.prototype.compilationType=function(){
+return this.script_.compilation_type;
+};
+ScriptMirror.prototype.lineCount=function(){
+return this.script_.lineCount();
+};
+ScriptMirror.prototype.locationFromPosition=function(
+position,include_resource_offset){
+return this.script_.locationFromPosition(position,include_resource_offset);
+};
+ScriptMirror.prototype.sourceSlice=function(ba,bb){
+return this.script_.sourceSlice(ba,bb);
+};
+ScriptMirror.prototype.context=function(){
+return this.context_;
+};
+ScriptMirror.prototype.evalFromScript=function(){
+return MakeMirror(this.script_.eval_from_script);
+};
+ScriptMirror.prototype.evalFromFunctionName=function(){
+return MakeMirror(this.script_.eval_from_function_name);
+};
+ScriptMirror.prototype.evalFromLocation=function(){
+var bc=this.evalFromScript();
+if(!bc.isUndefined()){
+var bd=this.script_.eval_from_script_position;
+return bc.locationFromPosition(bd,true);
+}
+};
+ScriptMirror.prototype.toText=function(){
+var S='';
+S+=this.name();
+S+=' (lines: ';
+if(this.lineOffset()>0){
+S+=this.lineOffset();
+S+='-';
+S+=this.lineOffset()+this.lineCount()-1;
+}else{
+S+=this.lineCount();
+}
+S+=')';
+return S;
+};
+function ContextMirror(be){
+%_Call(Mirror,this,q.CONTEXT_TYPE);
+this.data_=be;
+this.allocateHandle_();
+}
+inherits(ContextMirror,Mirror);
+ContextMirror.prototype.data=function(){
+return this.data_;
+};
+function MakeMirrorSerializer(P,bf){
+return new JSONProtocolSerializer(P,bf);
+}
+function JSONProtocolSerializer(P,bf){
+this.details_=P;
+this.options_=bf;
+this.mirrors_=[];
+}
+JSONProtocolSerializer.prototype.serializeReference=function(x){
+return this.serialize_(x,true,true);
+};
+JSONProtocolSerializer.prototype.serializeValue=function(x){
+var bg=this.serialize_(x,false,true);
+return bg;
+};
+JSONProtocolSerializer.prototype.serializeReferencedObjects=function(){
+var bh=[];
+var bi=this.mirrors_.length;
+for(var N=0;N<bi;N++){
+bh.push(this.serialize_(this.mirrors_[N],false,false));
+}
+return bh;
+};
+JSONProtocolSerializer.prototype.includeSource_=function(){
+return this.options_&&this.options_.includeSource;
+};
+JSONProtocolSerializer.prototype.inlineRefs_=function(){
+return this.options_&&this.options_.inlineRefs;
+};
+JSONProtocolSerializer.prototype.maxStringLength_=function(){
+if((this.options_===(void 0))||
+(this.options_.maxStringLength===(void 0))){
+return D;
+}
+return this.options_.maxStringLength;
+};
+JSONProtocolSerializer.prototype.add_=function(x){
+for(var N=0;N<this.mirrors_.length;N++){
+if(this.mirrors_[N]===x){
+return;
+}
+}
+this.mirrors_.push(x);
+};
+JSONProtocolSerializer.prototype.serializeReferenceWithDisplayData_=
+function(x){
+var bj={};
+bj.ref=x.handle();
+bj.type=x.type();
+switch(x.type()){
+case q.UNDEFINED_TYPE:
+case q.NULL_TYPE:
+case q.BOOLEAN_TYPE:
+case q.NUMBER_TYPE:
+bj.value=x.value();
+break;
+case q.STRING_TYPE:
+bj.value=x.getTruncatedValue(this.maxStringLength_());
+break;
+case q.SYMBOL_TYPE:
+bj.description=x.description();
+break;
+case q.FUNCTION_TYPE:
+bj.name=x.name();
+bj.inferredName=x.inferredName();
+if(x.script()){
+bj.scriptId=x.script().id();
+}
+break;
+case q.ERROR_TYPE:
+case q.REGEXP_TYPE:
+bj.value=x.toText();
+break;
+case q.OBJECT_TYPE:
+bj.className=x.className();
+break;
+}
+return bj;
+};
+JSONProtocolSerializer.prototype.serialize_=function(x,reference,
+P){
+if(reference&&
+(x.isValue()||x.isScript()||x.isContext())){
+if(this.inlineRefs_()&&x.isValue()){
+return this.serializeReferenceWithDisplayData_(x);
+}else{
+this.add_(x);
+return{'ref':x.handle()};
+}
+}
+var bh={};
+if(x.isValue()||x.isScript()||x.isContext()){
+bh.handle=x.handle();
+}
+bh.type=x.type();
+switch(x.type()){
+case q.UNDEFINED_TYPE:
+case q.NULL_TYPE:
+break;
+case q.BOOLEAN_TYPE:
+bh.value=x.value();
+break;
+case q.NUMBER_TYPE:
+bh.value=NumberToJSON_(x.value());
+break;
+case q.STRING_TYPE:
+if(this.maxStringLength_()!=-1&&
+x.length()>this.maxStringLength_()){
+var bk=x.getTruncatedValue(this.maxStringLength_());
+bh.value=bk;
+bh.fromIndex=0;
+bh.toIndex=this.maxStringLength_();
+}else{
+bh.value=x.value();
+}
+bh.length=x.length();
+break;
+case q.SYMBOL_TYPE:
+bh.description=x.description();
+break;
+case q.OBJECT_TYPE:
+case q.FUNCTION_TYPE:
+case q.ERROR_TYPE:
+case q.REGEXP_TYPE:
+case q.PROMISE_TYPE:
+case q.GENERATOR_TYPE:
+this.serializeObject_(x,bh,P);
+break;
+case q.PROPERTY_TYPE:
+case q.INTERNAL_PROPERTY_TYPE:
+throw g(2,
+'PropertyMirror cannot be serialized independently');
+break;
+case q.FRAME_TYPE:
+this.serializeFrame_(x,bh);
+break;
+case q.SCOPE_TYPE:
+this.serializeScope_(x,bh);
+break;
+case q.SCRIPT_TYPE:
+if(x.name()){
+bh.name=x.name();
+}
+bh.id=x.id();
+bh.lineOffset=x.lineOffset();
+bh.columnOffset=x.columnOffset();
+bh.lineCount=x.lineCount();
+if(x.data()){
+bh.data=x.data();
+}
+if(this.includeSource_()){
+bh.source=x.source();
+}else{
+var bl=x.source().substring(0,80);
+bh.sourceStart=bl;
+}
+bh.sourceLength=x.source().length;
+bh.scriptType=x.scriptType();
+bh.compilationType=x.compilationType();
+if(x.compilationType()==1&&
+x.evalFromScript()){
+bh.evalFromScript=
+this.serializeReference(x.evalFromScript());
+var bm=x.evalFromLocation();
+if(bm){
+bh.evalFromLocation={line:bm.line,
+column:bm.column};
+}
+if(x.evalFromFunctionName()){
+bh.evalFromFunctionName=x.evalFromFunctionName();
+}
+}
+if(x.context()){
+bh.context=this.serializeReference(x.context());
+}
+break;
+case q.CONTEXT_TYPE:
+bh.data=x.data();
+break;
+}
+bh.text=x.toText();
+return bh;
+};
+JSONProtocolSerializer.prototype.serializeObject_=function(x,bh,
+P){
+bh.className=x.className();
+bh.constructorFunction=
+this.serializeReference(x.constructorFunction());
+bh.protoObject=this.serializeReference(x.protoObject());
+bh.prototypeObject=this.serializeReference(x.prototypeObject());
+if(x.hasNamedInterceptor()){
+bh.namedInterceptor=true;
+}
+if(x.hasIndexedInterceptor()){
+bh.indexedInterceptor=true;
+}
+if(x.isFunction()){
+bh.name=x.name();
+if(!(x.inferredName()===(void 0))){
+bh.inferredName=x.inferredName();
+}
+bh.resolved=x.resolved();
+if(x.resolved()){
+bh.source=x.source();
+}
+if(x.script()){
+bh.script=this.serializeReference(x.script());
+bh.scriptId=x.script().id();
+serializeLocationFields(x.sourceLocation(),bh);
+}
+bh.scopes=[];
+for(var N=0;N<x.scopeCount();N++){
+var bn=x.scope(N);
+bh.scopes.push({
+type:bn.scopeType(),
+index:N
+});
+}
+}
+if(x.isGenerator()){
+bh.status=x.status();
+bh.func=this.serializeReference(x.func())
+bh.receiver=this.serializeReference(x.receiver())
+serializeLocationFields(x.sourceLocation(),bh);
+}
+if(x.isDate()){
+bh.value=x.value();
+}
+if(x.isPromise()){
+bh.status=x.status();
+bh.promiseValue=this.serializeReference(x.promiseValue());
+}
+var M=x.propertyNames();
+for(var N=0;N<M.length;N++){
+var bo=x.property(M[N]);
+M[N]=this.serializeProperty_(bo);
+if(P){
+this.add_(bo.value());
+}
+}
+bh.properties=M;
+var bp=x.internalProperties();
+if(bp.length>0){
+var bq=[];
+for(var N=0;N<bp.length;N++){
+bq.push(this.serializeInternalProperty_(bp[N]));
+}
+bh.internalProperties=bq;
+}
+};
+function serializeLocationFields(aG,bh){
+if(!aG){
+return;
+}
+bh.position=aG.position;
+var br=aG.line;
+if(!(br===(void 0))){
+bh.line=br;
+}
+var bs=aG.column;
+if(!(bs===(void 0))){
+bh.column=bs;
+}
+}
+JSONProtocolSerializer.prototype.serializeProperty_=function(bo){
+var S={};
+S.name=bo.name();
+var bt=bo.value();
+if(this.inlineRefs_()&&bt.isValue()){
+S.value=this.serializeReferenceWithDisplayData_(bt);
+}else{
+if(bo.attributes()!=F.None){
+S.attributes=bo.attributes();
+}
+S.propertyType=bo.propertyType();
+S.ref=bt.handle();
+}
+return S;
+};
+JSONProtocolSerializer.prototype.serializeInternalProperty_=
+function(bo){
+var S={};
+S.name=bo.name();
+var bt=bo.value();
+if(this.inlineRefs_()&&bt.isValue()){
+S.value=this.serializeReferenceWithDisplayData_(bt);
+}else{
+S.ref=bt.handle();
+}
+return S;
+};
+JSONProtocolSerializer.prototype.serializeFrame_=function(x,bh){
+bh.index=x.index();
+bh.receiver=this.serializeReference(x.receiver());
+var aF=x.func();
+bh.func=this.serializeReference(aF);
+var T=aF.script();
+if(T){
+bh.script=this.serializeReference(T);
+}
+bh.constructCall=x.isConstructCall();
+bh.atReturn=x.isAtReturn();
+if(x.isAtReturn()){
+bh.returnValue=this.serializeReference(x.returnValue());
+}
+bh.debuggerFrame=x.isDebuggerFrame();
+var K=new d(x.argumentCount());
+for(var N=0;N<x.argumentCount();N++){
+var bu={};
+var bv=x.argumentName(N);
+if(bv){
+bu.name=bv;
+}
+bu.value=this.serializeReference(x.argumentValue(N));
+K[N]=bu;
+}
+bh.arguments=K;
+var K=new d(x.localCount());
+for(var N=0;N<x.localCount();N++){
+var bw={};
+bw.name=x.localName(N);
+bw.value=this.serializeReference(x.localValue(N));
+K[N]=bw;
+}
+bh.locals=K;
+serializeLocationFields(x.sourceLocation(),bh);
+var bx=x.sourceLineText();
+if(!(bx===(void 0))){
+bh.sourceLineText=bx;
+}
+bh.scopes=[];
+for(var N=0;N<x.scopeCount();N++){
+var bn=x.scope(N);
+bh.scopes.push({
+type:bn.scopeType(),
+index:N
+});
+}
+};
+JSONProtocolSerializer.prototype.serializeScope_=function(x,bh){
+bh.index=x.scopeIndex();
+bh.frameIndex=x.frameIndex();
+bh.type=x.scopeType();
+bh.object=this.inlineRefs_()?
+this.serializeValue(x.scopeObject()):
+this.serializeReference(x.scopeObject());
+};
+function NumberToJSON_(v){
+if(e(v)){
+return'NaN';
+}
+if(!(%_IsSmi(%IS_VAR(v))||((v==v)&&(v!=1/0)&&(v!=-1/0)))){
+if(v>0){
+return'Infinity';
+}else{
+return'-Infinity';
+}
+}
+return v;
+}
+b.InstallFunctions(a,2,[
+"MakeMirror",MakeMirror,
+"MakeMirrorSerializer",MakeMirrorSerializer,
+"LookupMirror",LookupMirror,
+"ToggleMirrorCache",ToggleMirrorCache,
+"MirrorCacheIsEmpty",MirrorCacheIsEmpty,
+]);
+b.InstallConstants(a,[
+"ScopeType",G,
+"PropertyType",E,
+"PropertyAttribute",F,
+"Mirror",Mirror,
+"ValueMirror",ValueMirror,
+"UndefinedMirror",UndefinedMirror,
+"NullMirror",NullMirror,
+"BooleanMirror",BooleanMirror,
+"NumberMirror",NumberMirror,
+"StringMirror",StringMirror,
+"SymbolMirror",SymbolMirror,
+"ObjectMirror",ObjectMirror,
+"FunctionMirror",FunctionMirror,
+"UnresolvedFunctionMirror",UnresolvedFunctionMirror,
+"ArrayMirror",ArrayMirror,
+"DateMirror",DateMirror,
+"RegExpMirror",RegExpMirror,
+"ErrorMirror",ErrorMirror,
+"PromiseMirror",PromiseMirror,
+"MapMirror",MapMirror,
+"SetMirror",SetMirror,
+"IteratorMirror",IteratorMirror,
+"GeneratorMirror",GeneratorMirror,
+"PropertyMirror",PropertyMirror,
+"InternalPropertyMirror",InternalPropertyMirror,
+"FrameMirror",FrameMirror,
+"ScriptMirror",ScriptMirror,
+"ScopeMirror",ScopeMirror,
+"FrameDetails",FrameDetails,
+]);
+b.InstallFunctions(b,2,[
+"ClearMirrorCache",ClearMirrorCache
+]);
+b.Export(function(by){
+by.MirrorType=q;
+});
+})
+
+debugRd
+(function(a,b){
+"use strict";
+var c=a.FrameMirror;
+var d=a.Array;
+var e=a.RegExp;
+var f=a.isNaN;
+var g=a.JSON.parse;
+var h=a.JSON.stringify;
+var i=a.LookupMirror;
+var j;
+var k;
+var l=a.MakeMirror;
+var m=a.MakeMirrorSerializer;
+var n=a.Math.min;
+var o=a.Mirror;
+var p;
+var q=a.parseInt;
+var r=a.ValueMirror;
+b.Import(function(s){
+j=s.MakeError;
+k=s.MakeTypeError;
+p=s.MirrorType;
+});
+var t=10;
+var u={};
+var v=/^(?:\s*(?:\/\*.*?\*\/)*)*/;
+u.DebugEvent={Break:1,
+Exception:2,
+NewFunction:3,
+BeforeCompile:4,
+AfterCompile:5,
+CompileError:6,
+AsyncTaskEvent:7};
+u.ExceptionBreak={Caught:0,
+Uncaught:1};
+u.StepAction={StepOut:0,
+StepNext:1,
+StepIn:2,
+StepFrame:3};
+u.ScriptType={Native:0,
+Extension:1,
+Normal:2};
+u.ScriptCompilationType={Host:0,
+Eval:1,
+JSON:2};
+u.ScriptBreakPointType={ScriptId:0,
+ScriptName:1,
+ScriptRegExp:2};
+u.BreakPositionAlignment={
+Statement:0,
+BreakPosition:1
+};
+function ScriptTypeFlag(w){
+return(1<<w);
+}
+var x=0;
+var y=1;
+var z=[];
+var A=[];
+var B={
+breakPointsActive:{
+value:true,
+getValue:function(){return this.value;},
+setValue:function(C){
+this.value=!!C;
+%SetBreakPointsActive(this.value);
+}
+},
+breakOnCaughtException:{
+getValue:function(){return u.isBreakOnException();},
+setValue:function(C){
+if(C){
+u.setBreakOnException();
+}else{
+u.clearBreakOnException();
+}
+}
+},
+breakOnUncaughtException:{
+getValue:function(){return u.isBreakOnUncaughtException();},
+setValue:function(C){
+if(C){
+u.setBreakOnUncaughtException();
+}else{
+u.clearBreakOnUncaughtException();
+}
+}
+},
+};
+function MakeBreakPoint(D,E){
+var F=new BreakPoint(D,E);
+z.push(F);
+return F;
+}
+function BreakPoint(D,E){
+this.source_position_=D;
+if(E){
+this.script_break_point_=E;
+}else{
+this.number_=y++;
+}
+this.active_=true;
+this.condition_=null;
+}
+BreakPoint.prototype.number=function(){
+return this.number_;
+};
+BreakPoint.prototype.func=function(){
+return this.func_;
+};
+BreakPoint.prototype.source_position=function(){
+return this.source_position_;
+};
+BreakPoint.prototype.active=function(){
+if(this.script_break_point()){
+return this.script_break_point().active();
+}
+return this.active_;
+};
+BreakPoint.prototype.condition=function(){
+if(this.script_break_point()&&this.script_break_point().condition()){
+return this.script_break_point().condition();
+}
+return this.condition_;
+};
+BreakPoint.prototype.script_break_point=function(){
+return this.script_break_point_;
+};
+BreakPoint.prototype.enable=function(){
+this.active_=true;
+};
+BreakPoint.prototype.disable=function(){
+this.active_=false;
+};
+BreakPoint.prototype.setCondition=function(G){
+this.condition_=G;
+};
+BreakPoint.prototype.isTriggered=function(H){
+if(!this.active())return false;
+if(this.condition()){
+try{
+var I=H.frame(0).evaluate(this.condition());
+if(!(I instanceof r)||!I.value_){
+return false;
+}
+}catch(e){
+return false;
+}
+}
+return true;
+};
+function IsBreakPointTriggered(J,F){
+return F.isTriggered(MakeExecutionState(J));
+}
+function ScriptBreakPoint(w,script_id_or_name,opt_line,opt_column,
+opt_groupId,opt_position_alignment){
+this.type_=w;
+if(w==u.ScriptBreakPointType.ScriptId){
+this.script_id_=script_id_or_name;
+}else if(w==u.ScriptBreakPointType.ScriptName){
+this.script_name_=script_id_or_name;
+}else if(w==u.ScriptBreakPointType.ScriptRegExp){
+this.script_regexp_object_=new e(script_id_or_name);
+}else{
+throw j(2,"Unexpected breakpoint type "+w);
+}
+this.line_=opt_line||0;
+this.column_=opt_column;
+this.groupId_=opt_groupId;
+this.position_alignment_=(opt_position_alignment===(void 0))
+?u.BreakPositionAlignment.Statement:opt_position_alignment;
+this.active_=true;
+this.condition_=null;
+this.break_points_=[];
+}
+ScriptBreakPoint.prototype.cloneForOtherScript=function(K){
+var L=new ScriptBreakPoint(u.ScriptBreakPointType.ScriptId,
+K.id,this.line_,this.column_,this.groupId_,
+this.position_alignment_);
+L.number_=y++;
+A.push(L);
+L.active_=this.active_;
+L.condition_=this.condition_;
+return L;
+};
+ScriptBreakPoint.prototype.number=function(){
+return this.number_;
+};
+ScriptBreakPoint.prototype.groupId=function(){
+return this.groupId_;
+};
+ScriptBreakPoint.prototype.type=function(){
+return this.type_;
+};
+ScriptBreakPoint.prototype.script_id=function(){
+return this.script_id_;
+};
+ScriptBreakPoint.prototype.script_name=function(){
+return this.script_name_;
+};
+ScriptBreakPoint.prototype.script_regexp_object=function(){
+return this.script_regexp_object_;
+};
+ScriptBreakPoint.prototype.line=function(){
+return this.line_;
+};
+ScriptBreakPoint.prototype.column=function(){
+return this.column_;
+};
+ScriptBreakPoint.prototype.actual_locations=function(){
+var M=[];
+for(var N=0;N<this.break_points_.length;N++){
+M.push(this.break_points_[N].actual_location);
+}
+return M;
+};
+ScriptBreakPoint.prototype.update_positions=function(O,P){
+this.line_=O;
+this.column_=P;
+};
+ScriptBreakPoint.prototype.active=function(){
+return this.active_;
+};
+ScriptBreakPoint.prototype.condition=function(){
+return this.condition_;
+};
+ScriptBreakPoint.prototype.enable=function(){
+this.active_=true;
+};
+ScriptBreakPoint.prototype.disable=function(){
+this.active_=false;
+};
+ScriptBreakPoint.prototype.setCondition=function(G){
+this.condition_=G;
+};
+ScriptBreakPoint.prototype.matchesScript=function(Q){
+if(this.type_==u.ScriptBreakPointType.ScriptId){
+return this.script_id_==Q.id;
+}else{
+if(!(Q.line_offset<=this.line_&&
+this.line_<Q.line_offset+Q.lineCount())){
+return false;
+}
+if(this.type_==u.ScriptBreakPointType.ScriptName){
+return this.script_name_==Q.nameOrSourceURL();
+}else if(this.type_==u.ScriptBreakPointType.ScriptRegExp){
+return this.script_regexp_object_.test(Q.nameOrSourceURL());
+}else{
+throw j(2,"Unexpected breakpoint type "+this.type_);
+}
+}
+};
+ScriptBreakPoint.prototype.set=function(Q){
+var P=this.column();
+var O=this.line();
+if((P===(void 0))){
+var R=Q.sourceLine(this.line());
+if(!Q.sourceColumnStart_){
+Q.sourceColumnStart_=new d(Q.lineCount());
+}
+if((Q.sourceColumnStart_[O]===(void 0))){
+Q.sourceColumnStart_[O]=
+R.match(v)[0].length;
+}
+P=Q.sourceColumnStart_[O];
+}
+var S=u.findScriptSourcePosition(Q,this.line(),P);
+if((S===null))return;
+var F=MakeBreakPoint(S,this);
+var T=%SetScriptBreakPoint(Q,S,
+this.position_alignment_,
+F);
+if((T===(void 0))){
+T=S;
+}
+var U=Q.locationFromPosition(T,true);
+F.actual_location={line:U.line,
+column:U.column,
+script_id:Q.id};
+this.break_points_.push(F);
+return F;
+};
+ScriptBreakPoint.prototype.clear=function(){
+var V=[];
+for(var N=0;N<z.length;N++){
+if(z[N].script_break_point()&&
+z[N].script_break_point()===this){
+%ClearBreakPoint(z[N]);
+}else{
+V.push(z[N]);
+}
+}
+z=V;
+this.break_points_=[];
+};
+function UpdateScriptBreakPoints(Q){
+for(var N=0;N<A.length;N++){
+var F=A[N];
+if((F.type()==u.ScriptBreakPointType.ScriptName||
+F.type()==u.ScriptBreakPointType.ScriptRegExp)&&
+F.matchesScript(Q)){
+F.set(Q);
+}
+}
+}
+function GetScriptBreakPoints(Q){
+var W=[];
+for(var N=0;N<A.length;N++){
+if(A[N].matchesScript(Q)){
+W.push(A[N]);
+}
+}
+return W;
+}
+u.setListener=function(X,Y){
+if(!(%IsFunction(X))&&!(X===(void 0))&&!(X===null)){
+throw k(34);
+}
+%SetDebugEventListener(X,Y);
+};
+u.breakLocations=function(Z,aa){
+if(!(%IsFunction(Z)))throw k(34);
+var ab=(aa===(void 0))
+?u.BreakPositionAlignment.Statement:aa;
+return %GetBreakLocations(Z,ab);
+};
+u.findScript=function(ac){
+if((%IsFunction(ac))){
+return %FunctionGetScript(ac);
+}else if((%_IsRegExp(ac))){
+var ad=u.scripts();
+var ae=null;
+var af=0;
+for(var N in ad){
+var Q=ad[N];
+if(ac.test(Q.name)){
+ae=Q;
+af++;
+}
+}
+if(af==1){
+return ae;
+}else{
+return(void 0);
+}
+}else{
+return %GetScript(ac);
+}
+};
+u.scriptSource=function(ac){
+return this.findScript(ac).source;
+};
+u.source=function(Z){
+if(!(%IsFunction(Z)))throw k(34);
+return %FunctionGetSourceCode(Z);
+};
+u.sourcePosition=function(Z){
+if(!(%IsFunction(Z)))throw k(34);
+return %FunctionGetScriptSourcePosition(Z);
+};
+u.findFunctionSourceLocation=function(ag,ah,ai){
+var Q=%FunctionGetScript(ag);
+var aj=%FunctionGetScriptSourcePosition(ag);
+return Q.locationFromLine(ah,ai,aj);
+};
+u.findScriptSourcePosition=function(Q,ah,ai){
+var ak=Q.locationFromLine(ah,ai);
+return ak?ak.position:null;
+};
+u.findBreakPoint=function(al,am){
+var F;
+for(var N=0;N<z.length;N++){
+if(z[N].number()==al){
+F=z[N];
+if(am){
+z.splice(N,1);
+}
+break;
+}
+}
+if(F){
+return F;
+}else{
+return this.findScriptBreakPoint(al,am);
+}
+};
+u.findBreakPointActualLocations=function(al){
+for(var N=0;N<A.length;N++){
+if(A[N].number()==al){
+return A[N].actual_locations();
+}
+}
+for(var N=0;N<z.length;N++){
+if(z[N].number()==al){
+return[z[N].actual_location];
+}
+}
+return[];
+};
+u.setBreakPoint=function(ag,ah,ai,an){
+if(!(%IsFunction(ag)))throw k(34);
+if(%FunctionIsAPIFunction(ag)){
+throw j(2,'Cannot set break point in native code.');
+}
+var ao=
+this.findFunctionSourceLocation(ag,ah,ai).position;
+var D=ao-this.sourcePosition(ag);
+var Q=%FunctionGetScript(ag);
+if(Q.type==u.ScriptType.Native){
+throw j(2,'Cannot set break point in native code.');
+}
+if(Q&&Q.id){
+D+=%FunctionGetScriptSourcePosition(ag);
+var ak=Q.locationFromPosition(D,false);
+return this.setScriptBreakPointById(Q.id,
+ak.line,ak.column,
+an);
+}else{
+var F=MakeBreakPoint(D);
+var T=
+%SetFunctionBreakPoint(ag,D,F);
+T+=this.sourcePosition(ag);
+var U=Q.locationFromPosition(T,true);
+F.actual_location={line:U.line,
+column:U.column,
+script_id:Q.id};
+F.setCondition(an);
+return F.number();
+}
+};
+u.setBreakPointByScriptIdAndPosition=function(script_id,S,
+G,enabled,
+opt_position_alignment)
+{
+var F=MakeBreakPoint(S);
+F.setCondition(G);
+if(!enabled){
+F.disable();
+}
+var ad=this.scripts();
+var ap=(opt_position_alignment===(void 0))
+?u.BreakPositionAlignment.Statement:opt_position_alignment;
+for(var N=0;N<ad.length;N++){
+if(script_id==ad[N].id){
+F.actual_position=%SetScriptBreakPoint(ad[N],S,
+ap,F);
+break;
+}
+}
+return F;
+};
+u.enableBreakPoint=function(al){
+var F=this.findBreakPoint(al,false);
+if(F){
+F.enable();
+}
+};
+u.disableBreakPoint=function(al){
+var F=this.findBreakPoint(al,false);
+if(F){
+F.disable();
+}
+};
+u.changeBreakPointCondition=function(al,G){
+var F=this.findBreakPoint(al,false);
+F.setCondition(G);
+};
+u.clearBreakPoint=function(al){
+var F=this.findBreakPoint(al,true);
+if(F){
+return %ClearBreakPoint(F);
+}else{
+F=this.findScriptBreakPoint(al,true);
+if(!F)throw j(2,'Invalid breakpoint');
+}
+};
+u.clearAllBreakPoints=function(){
+for(var N=0;N<z.length;N++){
+var F=z[N];
+%ClearBreakPoint(F);
+}
+z=[];
+};
+u.disableAllBreakPoints=function(){
+for(var N=1;N<y;N++){
+u.disableBreakPoint(N);
+}
+%ChangeBreakOnException(u.ExceptionBreak.Caught,false);
+%ChangeBreakOnException(u.ExceptionBreak.Uncaught,false);
+};
+u.findScriptBreakPoint=function(al,am){
+var aq;
+for(var N=0;N<A.length;N++){
+if(A[N].number()==al){
+aq=A[N];
+if(am){
+aq.clear();
+A.splice(N,1);
+}
+break;
+}
+}
+return aq;
+};
+u.setScriptBreakPoint=function(w,script_id_or_name,
+ah,ai,an,
+opt_groupId,opt_position_alignment){
+var aq=
+new ScriptBreakPoint(w,script_id_or_name,ah,ai,
+opt_groupId,opt_position_alignment);
+aq.number_=y++;
+aq.setCondition(an);
+A.push(aq);
+var ad=this.scripts();
+for(var N=0;N<ad.length;N++){
+if(aq.matchesScript(ad[N])){
+aq.set(ad[N]);
+}
+}
+return aq.number();
+};
+u.setScriptBreakPointById=function(script_id,
+ah,ai,
+an,opt_groupId,
+opt_position_alignment){
+return this.setScriptBreakPoint(u.ScriptBreakPointType.ScriptId,
+script_id,ah,ai,
+an,opt_groupId,
+opt_position_alignment);
+};
+u.setScriptBreakPointByName=function(script_name,
+ah,ai,
+an,opt_groupId){
+return this.setScriptBreakPoint(u.ScriptBreakPointType.ScriptName,
+script_name,ah,ai,
+an,opt_groupId);
+};
+u.setScriptBreakPointByRegExp=function(script_regexp,
+ah,ai,
+an,opt_groupId){
+return this.setScriptBreakPoint(u.ScriptBreakPointType.ScriptRegExp,
+script_regexp,ah,ai,
+an,opt_groupId);
+};
+u.enableScriptBreakPoint=function(al){
+var aq=this.findScriptBreakPoint(al,false);
+aq.enable();
+};
+u.disableScriptBreakPoint=function(al){
+var aq=this.findScriptBreakPoint(al,false);
+aq.disable();
+};
+u.changeScriptBreakPointCondition=function(
+al,G){
+var aq=this.findScriptBreakPoint(al,false);
+aq.setCondition(G);
+};
+u.scriptBreakPoints=function(){
+return A;
+};
+u.clearStepping=function(){
+%ClearStepping();
+};
+u.setBreakOnException=function(){
+return %ChangeBreakOnException(u.ExceptionBreak.Caught,true);
+};
+u.clearBreakOnException=function(){
+return %ChangeBreakOnException(u.ExceptionBreak.Caught,false);
+};
+u.isBreakOnException=function(){
+return!!%IsBreakOnException(u.ExceptionBreak.Caught);
+};
+u.setBreakOnUncaughtException=function(){
+return %ChangeBreakOnException(u.ExceptionBreak.Uncaught,true);
+};
+u.clearBreakOnUncaughtException=function(){
+return %ChangeBreakOnException(u.ExceptionBreak.Uncaught,false);
+};
+u.isBreakOnUncaughtException=function(){
+return!!%IsBreakOnException(u.ExceptionBreak.Uncaught);
+};
+u.showBreakPoints=function(Z,ar,as){
+if(!(%IsFunction(Z)))throw j(34);
+var at=ar?this.scriptSource(Z):this.source(Z);
+var au=ar?this.sourcePosition(Z):0;
+var M=this.breakLocations(Z,as);
+if(!M)return at;
+M.sort(function(av,aw){return av-aw;});
+var W="";
+var ax=0;
+var ay;
+for(var N=0;N<M.length;N++){
+ay=M[N]-au;
+W+=at.slice(ax,ay);
+W+="[B"+N+"]";
+ax=ay;
+}
+ay=at.length;
+W+=at.substring(ax,ay);
+return W;
+};
+u.scripts=function(){
+return %DebugGetLoadedScripts();
+};
+u.debuggerFlags=function(){
+return B;
+};
+u.MakeMirror=l;
+function MakeExecutionState(J){
+return new ExecutionState(J);
+}
+function ExecutionState(J){
+this.break_id=J;
+this.selected_frame=0;
+}
+ExecutionState.prototype.prepareStep=function(az){
+if(az===u.StepAction.StepIn||
+az===u.StepAction.StepOut||
+az===u.StepAction.StepNext||
+az===u.StepAction.StepFrame){
+return %PrepareStep(this.break_id,az);
+}
+throw k(34);
+};
+ExecutionState.prototype.evaluateGlobal=function(at,disable_break,
+opt_additional_context){
+return l(%DebugEvaluateGlobal(this.break_id,at,
+(!!(disable_break)),
+opt_additional_context));
+};
+ExecutionState.prototype.frameCount=function(){
+return %GetFrameCount(this.break_id);
+};
+ExecutionState.prototype.threadCount=function(){
+return %GetThreadCount(this.break_id);
+};
+ExecutionState.prototype.frame=function(aA){
+if(aA==null)aA=this.selected_frame;
+if(aA<0||aA>=this.frameCount()){
+throw k(33);
+}
+return new c(this.break_id,aA);
+};
+ExecutionState.prototype.setSelectedFrame=function(aB){
+var N=(%_ToNumber(aB));
+if(N<0||N>=this.frameCount()){
+throw k(33);
+}
+this.selected_frame=N;
+};
+ExecutionState.prototype.selectedFrame=function(){
+return this.selected_frame;
+};
+ExecutionState.prototype.debugCommandProcessor=function(aC){
+return new DebugCommandProcessor(this,aC);
+};
+function MakeBreakEvent(J,aD){
+return new BreakEvent(J,aD);
+}
+function BreakEvent(J,aD){
+this.frame_=new c(J,0);
+this.break_points_hit_=aD;
+}
+BreakEvent.prototype.eventType=function(){
+return u.DebugEvent.Break;
+};
+BreakEvent.prototype.func=function(){
+return this.frame_.func();
+};
+BreakEvent.prototype.sourceLine=function(){
+return this.frame_.sourceLine();
+};
+BreakEvent.prototype.sourceColumn=function(){
+return this.frame_.sourceColumn();
+};
+BreakEvent.prototype.sourceLineText=function(){
+return this.frame_.sourceLineText();
+};
+BreakEvent.prototype.breakPointsHit=function(){
+return this.break_points_hit_;
+};
+BreakEvent.prototype.toJSONProtocol=function(){
+var aE={seq:x++,
+type:"event",
+event:"break",
+body:{invocationText:this.frame_.invocationText()}
+};
+var Q=this.func().script();
+if(Q){
+aE.body.sourceLine=this.sourceLine(),
+aE.body.sourceColumn=this.sourceColumn(),
+aE.body.sourceLineText=this.sourceLineText(),
+aE.body.script=MakeScriptObject_(Q,false);
+}
+if(this.breakPointsHit()){
+aE.body.breakpoints=[];
+for(var N=0;N<this.breakPointsHit().length;N++){
+var aF=this.breakPointsHit()[N];
+var aq=aF.script_break_point();
+var aG;
+if(aq){
+aG=aq.number();
+}else{
+aG=aF.number();
+}
+aE.body.breakpoints.push(aG);
+}
+}
+return h(ObjectToProtocolObject_(aE));
+};
+function MakeExceptionEvent(J,aH,aI,aJ){
+return new ExceptionEvent(J,aH,aI,aJ);
+}
+function ExceptionEvent(J,aH,aI,aJ){
+this.exec_state_=new ExecutionState(J);
+this.exception_=aH;
+this.uncaught_=aI;
+this.promise_=aJ;
+}
+ExceptionEvent.prototype.eventType=function(){
+return u.DebugEvent.Exception;
+};
+ExceptionEvent.prototype.exception=function(){
+return this.exception_;
+};
+ExceptionEvent.prototype.uncaught=function(){
+return this.uncaught_;
+};
+ExceptionEvent.prototype.promise=function(){
+return this.promise_;
+};
+ExceptionEvent.prototype.func=function(){
+return this.exec_state_.frame(0).func();
+};
+ExceptionEvent.prototype.sourceLine=function(){
+return this.exec_state_.frame(0).sourceLine();
+};
+ExceptionEvent.prototype.sourceColumn=function(){
+return this.exec_state_.frame(0).sourceColumn();
+};
+ExceptionEvent.prototype.sourceLineText=function(){
+return this.exec_state_.frame(0).sourceLineText();
+};
+ExceptionEvent.prototype.toJSONProtocol=function(){
+var aE=new ProtocolMessage();
+aE.event="exception";
+aE.body={uncaught:this.uncaught_,
+exception:l(this.exception_)
+};
+if(this.exec_state_.frameCount()>0){
+aE.body.sourceLine=this.sourceLine();
+aE.body.sourceColumn=this.sourceColumn();
+aE.body.sourceLineText=this.sourceLineText();
+var Q=this.func().script();
+if(Q){
+aE.body.script=MakeScriptObject_(Q,false);
+}
+}else{
+aE.body.sourceLine=-1;
+}
+return aE.toJSONProtocol();
+};
+function MakeCompileEvent(Q,w){
+return new CompileEvent(Q,w);
+}
+function CompileEvent(Q,w){
+this.script_=l(Q);
+this.type_=w;
+}
+CompileEvent.prototype.eventType=function(){
+return this.type_;
+};
+CompileEvent.prototype.script=function(){
+return this.script_;
+};
+CompileEvent.prototype.toJSONProtocol=function(){
+var aE=new ProtocolMessage();
+aE.running=true;
+switch(this.type_){
+case u.DebugEvent.BeforeCompile:
+aE.event="beforeCompile";
+break;
+case u.DebugEvent.AfterCompile:
+aE.event="afterCompile";
+break;
+case u.DebugEvent.CompileError:
+aE.event="compileError";
+break;
+}
+aE.body={};
+aE.body.script=this.script_;
+return aE.toJSONProtocol();
+};
+function MakeScriptObject_(Q,aK){
+var aE={id:Q.id(),
+name:Q.name(),
+lineOffset:Q.lineOffset(),
+columnOffset:Q.columnOffset(),
+lineCount:Q.lineCount(),
+};
+if(!(Q.data()===(void 0))){
+aE.data=Q.data();
+}
+if(aK){
+aE.source=Q.source();
+}
+return aE;
+}
+function MakeAsyncTaskEvent(aL){
+return new AsyncTaskEvent(aL);
+}
+function AsyncTaskEvent(aL){
+this.type_=aL.type;
+this.name_=aL.name;
+this.id_=aL.id;
+}
+AsyncTaskEvent.prototype.type=function(){
+return this.type_;
+}
+AsyncTaskEvent.prototype.name=function(){
+return this.name_;
+}
+AsyncTaskEvent.prototype.id=function(){
+return this.id_;
+}
+function DebugCommandProcessor(H,aC){
+this.exec_state_=H;
+this.running_=aC||false;
+}
+DebugCommandProcessor.prototype.processDebugRequest=function(aM){
+return this.processDebugJSONRequest(aM);
+};
+function ProtocolMessage(aM){
+this.seq=x++;
+if(aM){
+this.type='response';
+this.request_seq=aM.seq;
+this.command=aM.command;
+}else{
+this.type='event';
+}
+this.success=true;
+this.running=(void 0);
+}
+ProtocolMessage.prototype.setOption=function(aN,C){
+if(!this.options_){
+this.options_={};
+}
+this.options_[aN]=C;
+};
+ProtocolMessage.prototype.failed=function(aO,aP){
+this.success=false;
+this.message=aO;
+if((typeof(aP)==='object')){
+this.error_details=aP;
+}
+};
+ProtocolMessage.prototype.toJSONProtocol=function(){
+var aQ={};
+aQ.seq=this.seq;
+if(this.request_seq){
+aQ.request_seq=this.request_seq;
+}
+aQ.type=this.type;
+if(this.event){
+aQ.event=this.event;
+}
+if(this.command){
+aQ.command=this.command;
+}
+if(this.success){
+aQ.success=this.success;
+}else{
+aQ.success=false;
+}
+if(this.body){
+var aR;
+var aS=m(true,this.options_);
+if(this.body instanceof o){
+aR=aS.serializeValue(this.body);
+}else if(this.body instanceof d){
+aR=[];
+for(var N=0;N<this.body.length;N++){
+if(this.body[N]instanceof o){
+aR.push(aS.serializeValue(this.body[N]));
+}else{
+aR.push(ObjectToProtocolObject_(this.body[N],aS));
+}
+}
+}else{
+aR=ObjectToProtocolObject_(this.body,aS);
+}
+aQ.body=aR;
+aQ.refs=aS.serializeReferencedObjects();
+}
+if(this.message){
+aQ.message=this.message;
+}
+if(this.error_details){
+aQ.error_details=this.error_details;
+}
+aQ.running=this.running;
+return h(aQ);
+};
+DebugCommandProcessor.prototype.createResponse=function(aM){
+return new ProtocolMessage(aM);
+};
+DebugCommandProcessor.prototype.processDebugJSONRequest=function(
+json_request){
+var aM;
+var aT;
+try{
+try{
+aM=g(json_request);
+aT=this.createResponse(aM);
+if(!aM.type){
+throw j(2,'Type not specified');
+}
+if(aM.type!='request'){
+throw j(2,
+"Illegal type '"+aM.type+"' in request");
+}
+if(!aM.command){
+throw j(2,'Command not specified');
+}
+if(aM.arguments){
+var aU=aM.arguments;
+if(aU.inlineRefs||aU.compactFormat){
+aT.setOption('inlineRefs',true);
+}
+if(!(aU.maxStringLength===(void 0))){
+aT.setOption('maxStringLength',aU.maxStringLength);
+}
+}
+var aV=aM.command.toLowerCase();
+var aW=DebugCommandProcessor.prototype.dispatch_[aV];
+if((%IsFunction(aW))){
+%_Call(aW,this,aM,aT);
+}else{
+throw j(2,
+'Unknown command "'+aM.command+'" in request');
+}
+}catch(e){
+if(!aT){
+aT=this.createResponse();
+}
+aT.success=false;
+aT.message=(%_ToString(e));
+}
+try{
+if(!(aT.running===(void 0))){
+this.running_=aT.running;
+}
+aT.running=this.running_;
+return aT.toJSONProtocol();
+}catch(e){
+return'{"seq":'+aT.seq+','+
+'"request_seq":'+aM.seq+','+
+'"type":"response",'+
+'"success":false,'+
+'"message":"Internal error: '+(%_ToString(e))+'"}';
+}
+}catch(e){
+return'{"seq":0,"type":"response","success":false,"message":"Internal error"}';
+}
+};
+DebugCommandProcessor.prototype.continueRequest_=function(aM,aT){
+if(aM.arguments){
+var az=u.StepAction.StepIn;
+var aX=aM.arguments.stepaction;
+if(aX){
+if(aX=='in'){
+az=u.StepAction.StepIn;
+}else if(aX=='next'){
+az=u.StepAction.StepNext;
+}else if(aX=='out'){
+az=u.StepAction.StepOut;
+}else{
+throw j(2,
+'Invalid stepaction argument "'+aX+'".');
+}
+}
+this.exec_state_.prepareStep(az);
+}
+aT.running=true;
+};
+DebugCommandProcessor.prototype.breakRequest_=function(aM,aT){
+};
+DebugCommandProcessor.prototype.setBreakPointRequest_=
+function(aM,aT){
+if(!aM.arguments){
+aT.failed('Missing arguments');
+return;
+}
+var w=aM.arguments.type;
+var aY=aM.arguments.target;
+var O=aM.arguments.line;
+var P=aM.arguments.column;
+var aZ=(aM.arguments.enabled===(void 0))?
+true:aM.arguments.enabled;
+var G=aM.arguments.condition;
+var ba=aM.arguments.groupId;
+if(!w||(aY===(void 0))){
+aT.failed('Missing argument "type" or "target"');
+return;
+}
+var al;
+if(w=='function'){
+if(!(typeof(aY)==='string')){
+aT.failed('Argument "target" is not a string value');
+return;
+}
+var Z;
+try{
+Z=this.exec_state_.evaluateGlobal(aY).value();
+}catch(e){
+aT.failed('Error: "'+(%_ToString(e))+
+'" evaluating "'+aY+'"');
+return;
+}
+if(!(%IsFunction(Z))){
+aT.failed('"'+aY+'" does not evaluate to a function');
+return;
+}
+al=u.setBreakPoint(Z,O,P,G);
+}else if(w=='handle'){
+var bb=q(aY,10);
+var I=i(bb);
+if(!I){
+return aT.failed('Object #'+bb+'# not found');
+}
+if(!I.isFunction()){
+return aT.failed('Object #'+bb+'# is not a function');
+}
+al=u.setBreakPoint(I.value(),
+O,P,G);
+}else if(w=='script'){
+al=
+u.setScriptBreakPointByName(aY,O,P,G,
+ba);
+}else if(w=='scriptId'){
+al=
+u.setScriptBreakPointById(aY,O,P,G,ba);
+}else if(w=='scriptRegExp'){
+al=
+u.setScriptBreakPointByRegExp(aY,O,P,G,
+ba);
+}else{
+aT.failed('Illegal type "'+w+'"');
+return;
+}
+var F=u.findBreakPoint(al);
+if(!aZ){
+u.disableBreakPoint(al);
+}
+aT.body={type:w,
+breakpoint:al};
+if(F instanceof ScriptBreakPoint){
+if(F.type()==u.ScriptBreakPointType.ScriptId){
+aT.body.type='scriptId';
+aT.body.script_id=F.script_id();
+}else if(F.type()==u.ScriptBreakPointType.ScriptName){
+aT.body.type='scriptName';
+aT.body.script_name=F.script_name();
+}else if(F.type()==u.ScriptBreakPointType.ScriptRegExp){
+aT.body.type='scriptRegExp';
+aT.body.script_regexp=F.script_regexp_object().source;
+}else{
+throw j(2,
+"Unexpected breakpoint type: "+F.type());
+}
+aT.body.line=F.line();
+aT.body.column=F.column();
+aT.body.actual_locations=F.actual_locations();
+}else{
+aT.body.type='function';
+aT.body.actual_locations=[F.actual_location];
+}
+};
+DebugCommandProcessor.prototype.changeBreakPointRequest_=function(
+aM,aT){
+if(!aM.arguments){
+aT.failed('Missing arguments');
+return;
+}
+var F=(%_ToNumber(aM.arguments.breakpoint));
+var aZ=aM.arguments.enabled;
+var G=aM.arguments.condition;
+if(!F){
+aT.failed('Missing argument "breakpoint"');
+return;
+}
+if(!(aZ===(void 0))){
+if(aZ){
+u.enableBreakPoint(F);
+}else{
+u.disableBreakPoint(F);
+}
+}
+if(!(G===(void 0))){
+u.changeBreakPointCondition(F,G);
+}
+};
+DebugCommandProcessor.prototype.clearBreakPointGroupRequest_=function(
+aM,aT){
+if(!aM.arguments){
+aT.failed('Missing arguments');
+return;
+}
+var bc=aM.arguments.groupId;
+if(!bc){
+aT.failed('Missing argument "groupId"');
+return;
+}
+var bd=[];
+var be=[];
+for(var N=0;N<A.length;N++){
+var bf=A[N];
+if(bf.groupId()==bc){
+bd.push(bf.number());
+bf.clear();
+}else{
+be.push(bf);
+}
+}
+A=be;
+aT.body={breakpoints:bd};
+};
+DebugCommandProcessor.prototype.clearBreakPointRequest_=function(
+aM,aT){
+if(!aM.arguments){
+aT.failed('Missing arguments');
+return;
+}
+var F=(%_ToNumber(aM.arguments.breakpoint));
+if(!F){
+aT.failed('Missing argument "breakpoint"');
+return;
+}
+u.clearBreakPoint(F);
+aT.body={breakpoint:F};
+};
+DebugCommandProcessor.prototype.listBreakpointsRequest_=function(
+aM,aT){
+var bg=[];
+for(var N=0;N<A.length;N++){
+var F=A[N];
+var bh={
+number:F.number(),
+line:F.line(),
+column:F.column(),
+groupId:F.groupId(),
+active:F.active(),
+condition:F.condition(),
+actual_locations:F.actual_locations()
+};
+if(F.type()==u.ScriptBreakPointType.ScriptId){
+bh.type='scriptId';
+bh.script_id=F.script_id();
+}else if(F.type()==u.ScriptBreakPointType.ScriptName){
+bh.type='scriptName';
+bh.script_name=F.script_name();
+}else if(F.type()==u.ScriptBreakPointType.ScriptRegExp){
+bh.type='scriptRegExp';
+bh.script_regexp=F.script_regexp_object().source;
+}else{
+throw j(2,
+"Unexpected breakpoint type: "+F.type());
+}
+bg.push(bh);
+}
+aT.body={
+breakpoints:bg,
+breakOnExceptions:u.isBreakOnException(),
+breakOnUncaughtExceptions:u.isBreakOnUncaughtException()
+};
+};
+DebugCommandProcessor.prototype.disconnectRequest_=
+function(aM,aT){
+u.disableAllBreakPoints();
+this.continueRequest_(aM,aT);
+};
+DebugCommandProcessor.prototype.setExceptionBreakRequest_=
+function(aM,aT){
+if(!aM.arguments){
+aT.failed('Missing arguments');
+return;
+}
+var w=aM.arguments.type;
+if(!w){
+aT.failed('Missing argument "type"');
+return;
+}
+var aZ;
+if(w=='all'){
+aZ=!u.isBreakOnException();
+}else if(w=='uncaught'){
+aZ=!u.isBreakOnUncaughtException();
+}
+if(!(aM.arguments.enabled===(void 0))){
+aZ=aM.arguments.enabled;
+if((aZ!=true)&&(aZ!=false)){
+aT.failed('Illegal value for "enabled":"'+aZ+'"');
+}
+}
+if(w=='all'){
+%ChangeBreakOnException(u.ExceptionBreak.Caught,aZ);
+}else if(w=='uncaught'){
+%ChangeBreakOnException(u.ExceptionBreak.Uncaught,aZ);
+}else{
+aT.failed('Unknown "type":"'+w+'"');
+}
+aT.body={'type':w,'enabled':aZ};
+};
+DebugCommandProcessor.prototype.backtraceRequest_=function(
+aM,aT){
+var bi=this.exec_state_.frameCount();
+if(bi==0){
+aT.body={
+totalFrames:bi
+};
+return;
+}
+var bj=0;
+var bk=t;
+if(aM.arguments){
+if(aM.arguments.fromFrame){
+bj=aM.arguments.fromFrame;
+}
+if(aM.arguments.toFrame){
+bk=aM.arguments.toFrame;
+}
+if(aM.arguments.bottom){
+var bl=bi-bj;
+bj=bi-bk;
+bk=bl;
+}
+if(bj<0||bk<0){
+return aT.failed('Invalid frame number');
+}
+}
+bk=n(bi,bk);
+if(bk<=bj){
+var bm='Invalid frame range';
+return aT.failed(bm);
+}
+var bn=[];
+for(var N=bj;N<bk;N++){
+bn.push(this.exec_state_.frame(N));
+}
+aT.body={
+fromFrame:bj,
+toFrame:bk,
+totalFrames:bi,
+frames:bn
+};
+};
+DebugCommandProcessor.prototype.frameRequest_=function(aM,aT){
+if(this.exec_state_.frameCount()==0){
+return aT.failed('No frames');
+}
+if(aM.arguments){
+var aB=aM.arguments.number;
+if(aB<0||this.exec_state_.frameCount()<=aB){
+return aT.failed('Invalid frame number');
+}
+this.exec_state_.setSelectedFrame(aM.arguments.number);
+}
+aT.body=this.exec_state_.frame();
+};
+DebugCommandProcessor.prototype.resolveFrameFromScopeDescription_=
+function(bo){
+if(bo&&!(bo.frameNumber===(void 0))){
+var bp=bo.frameNumber;
+if(bp<0||this.exec_state_.frameCount()<=bp){
+throw k(33);
+}
+return this.exec_state_.frame(bp);
+}else{
+return this.exec_state_.frame();
+}
+};
+DebugCommandProcessor.prototype.resolveScopeHolder_=
+function(bo){
+if(bo&&"functionHandle"in bo){
+if(!(typeof(bo.functionHandle)==='number')){
+throw j(2,'Function handle must be a number');
+}
+var bq=i(bo.functionHandle);
+if(!bq){
+throw j(2,'Failed to find function object by handle');
+}
+if(!bq.isFunction()){
+throw j(2,
+'Value of non-function type is found by handle');
+}
+return bq;
+}else{
+if(this.exec_state_.frameCount()==0){
+throw j(2,'No scopes');
+}
+var br=this.resolveFrameFromScopeDescription_(bo);
+return br;
+}
+}
+DebugCommandProcessor.prototype.scopesRequest_=function(aM,aT){
+var bs=this.resolveScopeHolder_(aM.arguments);
+var bt=bs.scopeCount();
+var bu=[];
+for(var N=0;N<bt;N++){
+bu.push(bs.scope(N));
+}
+aT.body={
+fromScope:0,
+toScope:bt,
+totalScopes:bt,
+scopes:bu
+};
+};
+DebugCommandProcessor.prototype.scopeRequest_=function(aM,aT){
+var bs=this.resolveScopeHolder_(aM.arguments);
+var bv=0;
+if(aM.arguments&&!(aM.arguments.number===(void 0))){
+bv=(%_ToNumber(aM.arguments.number));
+if(bv<0||bs.scopeCount()<=bv){
+return aT.failed('Invalid scope number');
+}
+}
+aT.body=bs.scope(bv);
+};
+DebugCommandProcessor.resolveValue_=function(bw){
+if("handle"in bw){
+var bx=i(bw.handle);
+if(!bx){
+throw j(2,"Failed to resolve value by handle, ' #"+
+bw.handle+"# not found");
+}
+return bx.value();
+}else if("stringDescription"in bw){
+if(bw.type==p.BOOLEAN_TYPE){
+return(!!(bw.stringDescription));
+}else if(bw.type==p.NUMBER_TYPE){
+return(%_ToNumber(bw.stringDescription));
+}if(bw.type==p.STRING_TYPE){
+return(%_ToString(bw.stringDescription));
+}else{
+throw j(2,"Unknown type");
+}
+}else if("value"in bw){
+return bw.value;
+}else if(bw.type==p.UNDEFINED_TYPE){
+return(void 0);
+}else if(bw.type==p.NULL_TYPE){
+return null;
+}else{
+throw j(2,"Failed to parse value description");
+}
+};
+DebugCommandProcessor.prototype.setVariableValueRequest_=
+function(aM,aT){
+if(!aM.arguments){
+aT.failed('Missing arguments');
+return;
+}
+if((aM.arguments.name===(void 0))){
+aT.failed('Missing variable name');
+}
+var by=aM.arguments.name;
+var bo=aM.arguments.scope;
+var bs=this.resolveScopeHolder_(bo);
+if((bo.number===(void 0))){
+aT.failed('Missing scope number');
+}
+var bv=(%_ToNumber(bo.number));
+var bz=bs.scope(bv);
+var bA=
+DebugCommandProcessor.resolveValue_(aM.arguments.newValue);
+bz.setVariableValue(by,bA);
+var bB=l(bA);
+aT.body={
+newValue:bB
+};
+};
+DebugCommandProcessor.prototype.evaluateRequest_=function(aM,aT){
+if(!aM.arguments){
+return aT.failed('Missing arguments');
+}
+var bC=aM.arguments.expression;
+var br=aM.arguments.frame;
+var a=aM.arguments.global;
+var bD=aM.arguments.disable_break;
+var bE=aM.arguments.additional_context;
+try{
+bC=(%_ToString(bC));
+}catch(e){
+return aT.failed('Failed to convert expression argument to string');
+}
+if(!(br===(void 0))&&a){
+return aT.failed('Arguments "frame" and "global" are exclusive');
+}
+var bF;
+if(bE){
+bF={};
+for(var N=0;N<bE.length;N++){
+var bG=bE[N];
+if(!(typeof(bG.name)==='string')){
+return aT.failed("Context element #"+N+
+" doesn't contain name:string property");
+}
+var bH=DebugCommandProcessor.resolveValue_(bG);
+bF[bG.name]=bH;
+}
+}
+if(a){
+aT.body=this.exec_state_.evaluateGlobal(
+bC,(!!(bD)),bF);
+return;
+}
+if((bD===(void 0))){
+bD=true;
+}
+if(this.exec_state_.frameCount()==0){
+return aT.failed('No frames');
+}
+if(!(br===(void 0))){
+var bI=(%_ToNumber(br));
+if(bI<0||bI>=this.exec_state_.frameCount()){
+return aT.failed('Invalid frame "'+br+'"');
+}
+aT.body=this.exec_state_.frame(bI).evaluate(
+bC,(!!(bD)),bF);
+return;
+}else{
+aT.body=this.exec_state_.frame().evaluate(
+bC,(!!(bD)),bF);
+return;
+}
+};
+DebugCommandProcessor.prototype.lookupRequest_=function(aM,aT){
+if(!aM.arguments){
+return aT.failed('Missing arguments');
+}
+var bJ=aM.arguments.handles;
+if((bJ===(void 0))){
+return aT.failed('Argument "handles" missing');
+}
+if(!(aM.arguments.includeSource===(void 0))){
+var bK=(!!(aM.arguments.includeSource));
+aT.setOption('includeSource',bK);
+}
+var bL={};
+for(var N=0;N<bJ.length;N++){
+var bb=bJ[N];
+var I=i(bb);
+if(!I){
+return aT.failed('Object #'+bb+'# not found');
+}
+bL[bb]=I;
+}
+aT.body=bL;
+};
+DebugCommandProcessor.prototype.referencesRequest_=
+function(aM,aT){
+if(!aM.arguments){
+return aT.failed('Missing arguments');
+}
+var w=aM.arguments.type;
+var bb=aM.arguments.handle;
+if((w===(void 0))){
+return aT.failed('Argument "type" missing');
+}
+if((bb===(void 0))){
+return aT.failed('Argument "handle" missing');
+}
+if(w!='referencedBy'&&w!='constructedBy'){
+return aT.failed('Invalid type "'+w+'"');
+}
+var I=i(bb);
+if(I){
+if(w=='referencedBy'){
+aT.body=I.referencedBy();
+}else{
+aT.body=I.constructedBy();
+}
+}else{
+return aT.failed('Object #'+bb+'# not found');
+}
+};
+DebugCommandProcessor.prototype.sourceRequest_=function(aM,aT){
+if(this.exec_state_.frameCount()==0){
+return aT.failed('No source');
+}
+var bM;
+var bN;
+var br=this.exec_state_.frame();
+if(aM.arguments){
+bM=aM.arguments.fromLine;
+bN=aM.arguments.toLine;
+if(!(aM.arguments.frame===(void 0))){
+var bI=(%_ToNumber(aM.arguments.frame));
+if(bI<0||bI>=this.exec_state_.frameCount()){
+return aT.failed('Invalid frame "'+br+'"');
+}
+br=this.exec_state_.frame(bI);
+}
+}
+var Q=br.func().script();
+if(!Q){
+return aT.failed('No source');
+}
+var bO=Q.sourceSlice(bM,bN);
+if(!bO){
+return aT.failed('Invalid line interval');
+}
+aT.body={};
+aT.body.source=bO.sourceText();
+aT.body.fromLine=bO.from_line;
+aT.body.toLine=bO.to_line;
+aT.body.fromPosition=bO.from_position;
+aT.body.toPosition=bO.to_position;
+aT.body.totalLines=Q.lineCount();
+};
+DebugCommandProcessor.prototype.scriptsRequest_=function(aM,aT){
+var bP=ScriptTypeFlag(u.ScriptType.Normal);
+var bK=false;
+var bQ=null;
+if(aM.arguments){
+if(!(aM.arguments.types===(void 0))){
+bP=(%_ToNumber(aM.arguments.types));
+if(f(bP)||bP<0){
+return aT.failed('Invalid types "'+
+aM.arguments.types+'"');
+}
+}
+if(!(aM.arguments.includeSource===(void 0))){
+bK=(!!(aM.arguments.includeSource));
+aT.setOption('includeSource',bK);
+}
+if((%_IsArray(aM.arguments.ids))){
+bQ={};
+var bR=aM.arguments.ids;
+for(var N=0;N<bR.length;N++){
+bQ[bR[N]]=true;
+}
+}
+var bS=null;
+var bT=null;
+if(!(aM.arguments.filter===(void 0))){
+var bU=(%_ToNumber(aM.arguments.filter));
+if(!f(bU)){
+bT=bU;
+}
+bS=aM.arguments.filter;
+}
+}
+var ad=%DebugGetLoadedScripts();
+aT.body=[];
+for(var N=0;N<ad.length;N++){
+if(bQ&&!bQ[ad[N].id]){
+continue;
+}
+if(bS||bT){
+var Q=ad[N];
+var bV=false;
+if(bT&&!bV){
+if(Q.id&&Q.id===bT){
+bV=true;
+}
+}
+if(bS&&!bV){
+if(Q.name&&Q.name.indexOf(bS)>=0){
+bV=true;
+}
+}
+if(!bV)continue;
+}
+if(bP&ScriptTypeFlag(ad[N].type)){
+aT.body.push(l(ad[N]));
+}
+}
+};
+DebugCommandProcessor.prototype.threadsRequest_=function(aM,aT){
+var bW=this.exec_state_.threadCount();
+var bX=[];
+for(var N=0;N<bW;N++){
+var bY=%GetThreadDetails(this.exec_state_.break_id,N);
+var bZ={current:bY[0],
+id:bY[1]
+};
+bX.push(bZ);
+}
+aT.body={
+totalThreads:bW,
+threads:bX
+};
+};
+DebugCommandProcessor.prototype.suspendRequest_=function(aM,aT){
+aT.running=false;
+};
+DebugCommandProcessor.prototype.versionRequest_=function(aM,aT){
+aT.body={
+V8Version:%GetV8Version()
+};
+};
+DebugCommandProcessor.prototype.changeLiveRequest_=function(
+aM,aT){
+if(!aM.arguments){
+return aT.failed('Missing arguments');
+}
+var ca=aM.arguments.script_id;
+var cb=!!aM.arguments.preview_only;
+var ad=%DebugGetLoadedScripts();
+var cc=null;
+for(var N=0;N<ad.length;N++){
+if(ad[N].id==ca){
+cc=ad[N];
+}
+}
+if(!cc){
+aT.failed('Script not found');
+return;
+}
+var cd=new d();
+if(!(typeof(aM.arguments.new_source)==='string')){
+throw"new_source argument expected";
+}
+var ce=aM.arguments.new_source;
+var cf;
+try{
+cf=u.LiveEdit.SetScriptSource(cc,
+ce,cb,cd);
+}catch(e){
+if(e instanceof u.LiveEdit.Failure&&"details"in e){
+aT.failed(e.message,e.details);
+return;
+}
+throw e;
+}
+aT.body={change_log:cd,result:cf};
+if(!cb&&!this.running_&&cf.stack_modified){
+aT.body.stepin_recommended=true;
+}
+};
+DebugCommandProcessor.prototype.restartFrameRequest_=function(
+aM,aT){
+if(!aM.arguments){
+return aT.failed('Missing arguments');
+}
+var br=aM.arguments.frame;
+if(this.exec_state_.frameCount()==0){
+return aT.failed('No frames');
+}
+var cg;
+if(!(br===(void 0))){
+var bI=(%_ToNumber(br));
+if(bI<0||bI>=this.exec_state_.frameCount()){
+return aT.failed('Invalid frame "'+br+'"');
+}
+cg=this.exec_state_.frame(bI);
+}else{
+cg=this.exec_state_.frame();
+}
+var cf=cg.restart();
+aT.body={result:cf};
+};
+DebugCommandProcessor.prototype.debuggerFlagsRequest_=function(aM,
+aT){
+if(!aM.arguments){
+aT.failed('Missing arguments');
+return;
+}
+var ch=aM.arguments.flags;
+aT.body={flags:[]};
+if(!(ch===(void 0))){
+for(var N=0;N<ch.length;N++){
+var aN=ch[N].name;
+var ci=B[aN];
+if(!ci){
+continue;
+}
+if('value'in ch[N]){
+ci.setValue(ch[N].value);
+}
+aT.body.flags.push({name:aN,value:ci.getValue()});
+}
+}else{
+for(var aN in B){
+var C=B[aN].getValue();
+aT.body.flags.push({name:aN,value:C});
+}
+}
+};
+DebugCommandProcessor.prototype.v8FlagsRequest_=function(aM,aT){
+var ch=aM.arguments.flags;
+if(!ch)ch='';
+%SetFlags(ch);
+};
+DebugCommandProcessor.prototype.gcRequest_=function(aM,aT){
+var w=aM.arguments.type;
+if(!w)w='all';
+var cj=%GetHeapUsage();
+%CollectGarbage(w);
+var ck=%GetHeapUsage();
+aT.body={"before":cj,"after":ck};
+};
+DebugCommandProcessor.prototype.dispatch_=(function(){
+var cl=DebugCommandProcessor.prototype;
+return{
+"continue":cl.continueRequest_,
+"break":cl.breakRequest_,
+"setbreakpoint":cl.setBreakPointRequest_,
+"changebreakpoint":cl.changeBreakPointRequest_,
+"clearbreakpoint":cl.clearBreakPointRequest_,
+"clearbreakpointgroup":cl.clearBreakPointGroupRequest_,
+"disconnect":cl.disconnectRequest_,
+"setexceptionbreak":cl.setExceptionBreakRequest_,
+"listbreakpoints":cl.listBreakpointsRequest_,
+"backtrace":cl.backtraceRequest_,
+"frame":cl.frameRequest_,
+"scopes":cl.scopesRequest_,
+"scope":cl.scopeRequest_,
+"setvariablevalue":cl.setVariableValueRequest_,
+"evaluate":cl.evaluateRequest_,
+"lookup":cl.lookupRequest_,
+"references":cl.referencesRequest_,
+"source":cl.sourceRequest_,
+"scripts":cl.scriptsRequest_,
+"threads":cl.threadsRequest_,
+"suspend":cl.suspendRequest_,
+"version":cl.versionRequest_,
+"changelive":cl.changeLiveRequest_,
+"restartframe":cl.restartFrameRequest_,
+"flags":cl.debuggerFlagsRequest_,
+"v8flag":cl.v8FlagsRequest_,
+"gc":cl.gcRequest_,
+};
+})();
+DebugCommandProcessor.prototype.isRunning=function(){
+return this.running_;
+};
+DebugCommandProcessor.prototype.systemBreak=function(cm,aU){
+return %SystemBreak();
+};
+function ObjectToProtocolObject_(cn,co){
+var cp={};
+for(var aV in cn){
+if(typeof aV=='string'){
+var cq=ValueToProtocolValue_(cn[aV],
+co);
+if(!(cq===(void 0))){
+cp[aV]=cq;
+}
+}
+}
+return cp;
+}
+function ArrayToProtocolArray_(bg,co){
+var aQ=[];
+for(var N=0;N<bg.length;N++){
+aQ.push(ValueToProtocolValue_(bg[N],co));
+}
+return aQ;
+}
+function ValueToProtocolValue_(C,co){
+var aQ;
+switch(typeof C){
+case'object':
+if(C instanceof o){
+aQ=co.serializeValue(C);
+}else if((%_IsArray(C))){
+aQ=ArrayToProtocolArray_(C,co);
+}else{
+aQ=ObjectToProtocolObject_(C,co);
+}
+break;
+case'boolean':
+case'string':
+case'number':
+aQ=C;
+break;
+default:
+aQ=null;
+}
+return aQ;
+}
+b.InstallConstants(a,[
+"Debug",u,
+"DebugCommandProcessor",DebugCommandProcessor,
+"BreakEvent",BreakEvent,
+"CompileEvent",CompileEvent,
+"BreakPoint",BreakPoint,
+]);
+b.InstallFunctions(b,2,[
+"MakeExecutionState",MakeExecutionState,
+"MakeExceptionEvent",MakeExceptionEvent,
+"MakeBreakEvent",MakeBreakEvent,
+"MakeCompileEvent",MakeCompileEvent,
+"MakeAsyncTaskEvent",MakeAsyncTaskEvent,
+"IsBreakPointTriggered",IsBreakPointTriggered,
+"UpdateScriptBreakPoints",UpdateScriptBreakPoints,
+]);
+b.Export(function(cr){
+cr.GetScriptBreakPoints=GetScriptBreakPoints;
+});
+})
+
+ liveedit%�
+(function(a,b){
+"use strict";
+var c=a.Debug.findScriptSourcePosition;
+var d;
+var e=a.Array;
+var f=a.Math.floor;
+var g=a.SyntaxError;
+b.Import(function(h){
+d=h.GetScriptBreakPoints;
+});
+var i;
+function ApplyPatchMultiChunk(script,diff_array,new_source,preview_only,
+change_log){
+var j=script.source;
+var k=GatherCompileInfo(j,script);
+var l=BuildCodeInfoTree(k);
+var m=new PosTranslator(diff_array);
+MarkChangedFunctions(l,m.GetChunks());
+FindLiveSharedInfos(l,script);
+var n;
+try{
+n=GatherCompileInfo(new_source,script);
+}catch(e){
+var o=
+new Failure("Failed to compile new version of script: "+e);
+if(e instanceof g){
+var p={
+type:"liveedit_compile_error",
+syntaxErrorMessage:e.message
+};
+CopyErrorPositionToDetails(e,p);
+o.details=p;
+}
+throw o;
+}
+var q=BuildCodeInfoTree(n);
+FindCorrespondingFunctions(l,q);
+var r=new e();
+var s=new e();
+var t=new e();
+var u=new e();
+function HarvestTodo(v){
+function CollectDamaged(w){
+s.push(w);
+for(var x=0;x<w.children.length;x++){
+CollectDamaged(w.children[x]);
+}
+}
+function CollectNew(y){
+for(var x=0;x<y.length;x++){
+t.push(y[x]);
+CollectNew(y[x].children);
+}
+}
+if(v.status==i.DAMAGED){
+CollectDamaged(v);
+return;
+}
+if(v.status==i.UNCHANGED){
+u.push(v);
+}else if(v.status==i.SOURCE_CHANGED){
+u.push(v);
+}else if(v.status==i.CHANGED){
+r.push(v);
+CollectNew(v.unmatched_new_nodes);
+}
+for(var x=0;x<v.children.length;x++){
+HarvestTodo(v.children[x]);
+}
+}
+var z={
+change_tree:DescribeChangeTree(l),
+textual_diff:{
+old_len:j.length,
+new_len:new_source.length,
+chunks:diff_array
+},
+updated:false
+};
+if(preview_only){
+return z;
+}
+HarvestTodo(l);
+var A=new e();
+var B=new e();
+for(var x=0;x<r.length;x++){
+var C=r[x].live_shared_function_infos;
+var D=
+r[x].corresponding_node.info.shared_function_info;
+if(C){
+for(var E=0;E<C.length;E++){
+A.push(C[E]);
+B.push(D);
+}
+}
+}
+var F=
+CheckStackActivations(A,
+B,
+change_log);
+z.stack_modified=F!=0;
+var G=TemporaryRemoveBreakPoints(script,change_log);
+var H;
+if(s.length==0){
+%LiveEditReplaceScript(script,new_source,null);
+H=(void 0);
+}else{
+var I=CreateNameForOldScript(script);
+H=%LiveEditReplaceScript(script,new_source,
+I);
+var J=new e();
+change_log.push({linked_to_old_script:J});
+for(var x=0;x<s.length;x++){
+LinkToOldScript(s[x],H,
+J);
+}
+z.created_script_name=I;
+}
+for(var x=0;x<t.length;x++){
+%LiveEditFunctionSetScript(
+t[x].info.shared_function_info,script);
+}
+for(var x=0;x<r.length;x++){
+PatchFunctionCode(r[x],change_log);
+}
+var K=new e();
+change_log.push({position_patched:K});
+for(var x=0;x<u.length;x++){
+PatchPositions(u[x],diff_array,
+K);
+if(u[x].live_shared_function_infos){
+u[x].live_shared_function_infos.
+forEach(function(L){
+%LiveEditFunctionSourceUpdated(L.raw_array);
+});
+}
+}
+G(m,H);
+z.updated=true;
+return z;
+}
+function GatherCompileInfo(M,N){
+var O=%LiveEditGatherCompileInfo(N,M);
+var P=new e();
+var Q=new e();
+for(var x=0;x<O.length;x++){
+var L=new FunctionCompileInfo(O[x]);
+%LiveEditFunctionSetScript(L.shared_function_info,(void 0));
+P.push(L);
+Q.push(x);
+}
+for(var x=0;x<P.length;x++){
+var R=x;
+for(var E=x+1;E<P.length;E++){
+if(P[R].start_position>P[E].start_position){
+R=E;
+}
+}
+if(R!=x){
+var S=P[R];
+var T=Q[R];
+P[R]=P[x];
+Q[R]=Q[x];
+P[x]=S;
+Q[x]=T;
+}
+}
+var U=0;
+function ResetIndexes(V,W){
+var X=-1;
+while(U<P.length&&
+P[U].outer_index==W){
+var Y=U;
+P[Y].outer_index=V;
+if(X!=-1){
+P[X].next_sibling_index=Y;
+}
+X=Y;
+U++;
+ResetIndexes(Y,Q[Y]);
+}
+if(X!=-1){
+P[X].next_sibling_index=-1;
+}
+}
+ResetIndexes(-1,-1);
+Assert(U==P.length);
+return P;
+}
+function PatchFunctionCode(v,Z){
+var D=v.corresponding_node.info;
+if(v.live_shared_function_infos){
+v.live_shared_function_infos.forEach(function(aa){
+%LiveEditReplaceFunctionCode(D.raw_array,
+aa.raw_array);
+for(var x=0;x<v.children.length;x++){
+if(v.children[x].corresponding_node){
+var ab=
+v.children[x].corresponding_node.info.
+shared_function_info;
+if(v.children[x].live_shared_function_infos){
+v.children[x].live_shared_function_infos.
+forEach(function(ac){
+%LiveEditReplaceRefToNestedFunction(
+aa.info,
+ab,
+ac.info);
+});
+}
+}
+}
+});
+Z.push({function_patched:D.function_name});
+}else{
+Z.push({function_patched:D.function_name,
+function_info_not_found:true});
+}
+}
+function LinkToOldScript(ad,H,ae){
+if(ad.live_shared_function_infos){
+ad.live_shared_function_infos.
+forEach(function(L){
+%LiveEditFunctionSetScript(L.info,H);
+});
+ae.push({name:ad.info.function_name});
+}else{
+ae.push(
+{name:ad.info.function_name,not_found:true});
+}
+}
+function TemporaryRemoveBreakPoints(af,Z){
+var ag=d(af);
+var ah=[];
+Z.push({break_points_update:ah});
+var ai=[];
+for(var x=0;x<ag.length;x++){
+var aj=ag[x];
+aj.clear();
+var ak=c(af,
+aj.line(),aj.column());
+var al={
+position:ak,
+line:aj.line(),
+column:aj.column()
+};
+ai.push(al);
+}
+return function(m,am){
+for(var x=0;x<ag.length;x++){
+var aj=ag[x];
+if(am){
+var an=aj.cloneForOtherScript(am);
+an.set(am);
+ah.push({
+type:"copied_to_old",
+id:aj.number(),
+new_id:an.number(),
+positions:ai[x]
+});
+}
+var ao=m.Translate(
+ai[x].position,
+PosTranslator.ShiftWithTopInsideChunkHandler);
+var ap=
+af.locationFromPosition(ao,false);
+aj.update_positions(ap.line,ap.column);
+var aq={
+position:ao,
+line:ap.line,
+column:ap.column
+};
+aj.set(af);
+ah.push({type:"position_changed",
+id:aj.number(),
+old_positions:ai[x],
+new_positions:aq
+});
+}
+};
+}
+function Assert(ar,as){
+if(!ar){
+if(as){
+throw"Assert "+as;
+}else{
+throw"Assert";
+}
+}
+}
+function DiffChunk(at,au,av,aw){
+this.pos1=at;
+this.pos2=au;
+this.len1=av;
+this.len2=aw;
+}
+function PosTranslator(ax){
+var ay=new e();
+var az=0;
+for(var x=0;x<ax.length;x+=3){
+var aA=ax[x];
+var aB=aA+az;
+var aC=ax[x+1];
+var aD=ax[x+2];
+ay.push(new DiffChunk(aA,aB,aC-aA,
+aD-aB));
+az=aD-aC;
+}
+this.chunks=ay;
+}
+PosTranslator.prototype.GetChunks=function(){
+return this.chunks;
+};
+PosTranslator.prototype.Translate=function(aE,aF){
+var aG=this.chunks;
+if(aG.length==0||aE<aG[0].pos1){
+return aE;
+}
+var aH=0;
+var aI=aG.length-1;
+while(aH<aI){
+var aJ=f((aH+aI)/2);
+if(aE<aG[aJ+1].pos1){
+aI=aJ;
+}else{
+aH=aJ+1;
+}
+}
+var aK=aG[aH];
+if(aE>=aK.pos1+aK.len1){
+return aE+aK.pos2+aK.len2-aK.pos1-aK.len1;
+}
+if(!aF){
+aF=PosTranslator.DefaultInsideChunkHandler;
+}
+return aF(aE,aK);
+};
+PosTranslator.DefaultInsideChunkHandler=function(aE,aL){
+Assert(false,"Cannot translate position in changed area");
+};
+PosTranslator.ShiftWithTopInsideChunkHandler=
+function(aE,aL){
+return aE-aL.pos1+aL.pos2;
+};
+var i={
+UNCHANGED:"unchanged",
+SOURCE_CHANGED:"source changed",
+CHANGED:"changed",
+DAMAGED:"damaged"
+};
+function CodeInfoTreeNode(aM,aN,aO){
+this.info=aM;
+this.children=aN;
+this.array_index=aO;
+this.parent=(void 0);
+this.status=i.UNCHANGED;
+this.status_explanation=(void 0);
+this.new_start_pos=(void 0);
+this.new_end_pos=(void 0);
+this.corresponding_node=(void 0);
+this.unmatched_new_nodes=(void 0);
+this.textual_corresponding_node=(void 0);
+this.textually_unmatched_new_nodes=(void 0);
+this.live_shared_function_infos=(void 0);
+}
+function BuildCodeInfoTree(aP){
+var aQ=0;
+function BuildNode(){
+var aR=aQ;
+aQ++;
+var aS=new e();
+while(aQ<aP.length&&
+aP[aQ].outer_index==aR){
+aS.push(BuildNode());
+}
+var w=new CodeInfoTreeNode(aP[aR],aS,
+aR);
+for(var x=0;x<aS.length;x++){
+aS[x].parent=w;
+}
+return w;
+}
+var aT=BuildNode();
+Assert(aQ==aP.length);
+return aT;
+}
+function MarkChangedFunctions(aU,ay){
+var aV=new function(){
+var aW=0;
+var aX=0;
+this.current=function(){return ay[aW];};
+this.next=function(){
+var aK=ay[aW];
+aX=aK.pos2+aK.len2-(aK.pos1+aK.len1);
+aW++;
+};
+this.done=function(){return aW>=ay.length;};
+this.TranslatePos=function(aE){return aE+aX;};
+};
+function ProcessInternals(aY){
+aY.new_start_pos=aV.TranslatePos(
+aY.info.start_position);
+var aZ=0;
+var ba=false;
+var bb=false;
+while(!aV.done()&&
+aV.current().pos1<aY.info.end_position){
+if(aZ<aY.children.length){
+var bc=aY.children[aZ];
+if(bc.info.end_position<=aV.current().pos1){
+ProcessUnchangedChild(bc);
+aZ++;
+continue;
+}else if(bc.info.start_position>=
+aV.current().pos1+aV.current().len1){
+ba=true;
+aV.next();
+continue;
+}else if(bc.info.start_position<=aV.current().pos1&&
+bc.info.end_position>=aV.current().pos1+
+aV.current().len1){
+ProcessInternals(bc);
+bb=bb||
+(bc.status!=i.UNCHANGED);
+ba=ba||
+(bc.status==i.DAMAGED);
+aZ++;
+continue;
+}else{
+ba=true;
+bc.status=i.DAMAGED;
+bc.status_explanation=
+"Text diff overlaps with function boundary";
+aZ++;
+continue;
+}
+}else{
+if(aV.current().pos1+aV.current().len1<=
+aY.info.end_position){
+aY.status=i.CHANGED;
+aV.next();
+continue;
+}else{
+aY.status=i.DAMAGED;
+aY.status_explanation=
+"Text diff overlaps with function boundary";
+return;
+}
+}
+Assert("Unreachable",false);
+}
+while(aZ<aY.children.length){
+var bc=aY.children[aZ];
+ProcessUnchangedChild(bc);
+aZ++;
+}
+if(ba){
+aY.status=i.CHANGED;
+}else if(bb){
+aY.status=i.SOURCE_CHANGED;
+}
+aY.new_end_pos=
+aV.TranslatePos(aY.info.end_position);
+}
+function ProcessUnchangedChild(w){
+w.new_start_pos=aV.TranslatePos(w.info.start_position);
+w.new_end_pos=aV.TranslatePos(w.info.end_position);
+}
+ProcessInternals(aU);
+}
+function FindCorrespondingFunctions(bd,be){
+function ProcessNode(v,bf){
+var bg=
+IsFunctionContextLocalsChanged(v.info,bf.info);
+if(bg){
+v.status=i.CHANGED;
+}
+var bh=v.children;
+var bi=bf.children;
+var bj=[];
+var bk=[];
+var bl=0;
+var bm=0;
+while(bl<bh.length){
+if(bh[bl].status==i.DAMAGED){
+bl++;
+}else if(bm<bi.length){
+if(bi[bm].info.start_position<
+bh[bl].new_start_pos){
+bj.push(bi[bm]);
+bk.push(bi[bm]);
+bm++;
+}else if(bi[bm].info.start_position==
+bh[bl].new_start_pos){
+if(bi[bm].info.end_position==
+bh[bl].new_end_pos){
+bh[bl].corresponding_node=
+bi[bm];
+bh[bl].textual_corresponding_node=
+bi[bm];
+if(bg){
+bh[bl].status=i.DAMAGED;
+bh[bl].status_explanation=
+"Enclosing function is now incompatible. "+
+bg;
+bh[bl].corresponding_node=(void 0);
+}else if(bh[bl].status!=
+i.UNCHANGED){
+ProcessNode(bh[bl],
+bi[bm]);
+if(bh[bl].status==i.DAMAGED){
+bj.push(
+bh[bl].corresponding_node);
+bh[bl].corresponding_node=(void 0);
+v.status=i.CHANGED;
+}
+}
+}else{
+bh[bl].status=i.DAMAGED;
+bh[bl].status_explanation=
+"No corresponding function in new script found";
+v.status=i.CHANGED;
+bj.push(bi[bm]);
+bk.push(bi[bm]);
+}
+bm++;
+bl++;
+}else{
+bh[bl].status=i.DAMAGED;
+bh[bl].status_explanation=
+"No corresponding function in new script found";
+v.status=i.CHANGED;
+bl++;
+}
+}else{
+bh[bl].status=i.DAMAGED;
+bh[bl].status_explanation=
+"No corresponding function in new script found";
+v.status=i.CHANGED;
+bl++;
+}
+}
+while(bm<bi.length){
+bj.push(bi[bm]);
+bk.push(bi[bm]);
+bm++;
+}
+if(v.status==i.CHANGED){
+if(v.info.param_num!=bf.info.param_num){
+v.status=i.DAMAGED;
+v.status_explanation="Changed parameter number: "+
+v.info.param_num+" and "+bf.info.param_num;
+}
+}
+v.unmatched_new_nodes=bj;
+v.textually_unmatched_new_nodes=
+bk;
+}
+ProcessNode(bd,be);
+bd.corresponding_node=be;
+bd.textual_corresponding_node=be;
+Assert(bd.status!=i.DAMAGED,
+"Script became damaged");
+}
+function FindLiveSharedInfos(bd,N){
+var bn=%LiveEditFindSharedFunctionInfosForScript(N);
+var bo=new e();
+for(var x=0;x<bn.length;x++){
+bo.push(new SharedInfoWrapper(bn[x]));
+}
+function FindFunctionInfos(P){
+var bp=[];
+for(var x=0;x<bo.length;x++){
+var bq=bo[x];
+if(bq.start_position==P.start_position&&
+bq.end_position==P.end_position){
+bp.push(bq);
+}
+}
+if(bp.length>0){
+return bp;
+}
+}
+function TraverseTree(w){
+w.live_shared_function_infos=FindFunctionInfos(w.info);
+for(var x=0;x<w.children.length;x++){
+TraverseTree(w.children[x]);
+}
+}
+TraverseTree(bd);
+}
+function FunctionCompileInfo(br){
+this.function_name=br[0];
+this.start_position=br[1];
+this.end_position=br[2];
+this.param_num=br[3];
+this.code=br[4];
+this.code_scope_info=br[5];
+this.scope_info=br[6];
+this.outer_index=br[7];
+this.shared_function_info=br[8];
+this.next_sibling_index=null;
+this.raw_array=br;
+}
+function SharedInfoWrapper(br){
+this.function_name=br[0];
+this.start_position=br[1];
+this.end_position=br[2];
+this.info=br[3];
+this.raw_array=br;
+}
+function PatchPositions(ad,ax,ae){
+if(ad.live_shared_function_infos){
+ad.live_shared_function_infos.forEach(function(L){
+%LiveEditPatchFunctionPositions(L.raw_array,
+ax);
+});
+ae.push({name:ad.info.function_name});
+}else{
+ae.push(
+{name:ad.info.function_name,info_not_found:true});
+}
+}
+function CreateNameForOldScript(N){
+return N.name+" (old)";
+}
+function IsFunctionContextLocalsChanged(bs,bt){
+var bu=bs.scope_info;
+var bv=bt.scope_info;
+var bw;
+var bx;
+if(bu){
+bw=bu.toString();
+}else{
+bw="";
+}
+if(bv){
+bx=bv.toString();
+}else{
+bx="";
+}
+if(bw!=bx){
+return"Variable map changed: ["+bw+
+"] => ["+bx+"]";
+}
+return;
+}
+var by;
+function CheckStackActivations(old_shared_wrapper_list,
+new_shared_list,
+Z){
+var bz=new e();
+for(var x=0;x<old_shared_wrapper_list.length;x++){
+bz[x]=old_shared_wrapper_list[x].info;
+}
+var bA=%LiveEditCheckAndDropActivations(
+bz,new_shared_list,true);
+if(bA[old_shared_wrapper_list.length]){
+throw new Failure(bA[old_shared_wrapper_list.length]);
+}
+var bB=new e();
+var bC=new e();
+for(var x=0;x<bz.length;x++){
+var bD=old_shared_wrapper_list[x];
+if(bA[x]==by.REPLACED_ON_ACTIVE_STACK){
+bC.push({name:bD.function_name});
+}else if(bA[x]!=by.AVAILABLE_FOR_PATCH){
+var bE={
+name:bD.function_name,
+start_pos:bD.start_position,
+end_pos:bD.end_position,
+replace_problem:
+by.SymbolName(bA[x])
+};
+bB.push(bE);
+}
+}
+if(bC.length>0){
+Z.push({dropped_from_stack:bC});
+}
+if(bB.length>0){
+Z.push({functions_on_stack:bB});
+throw new Failure("Blocked by functions on stack");
+}
+return bC.length;
+}
+var by={
+AVAILABLE_FOR_PATCH:1,
+BLOCKED_ON_ACTIVE_STACK:2,
+BLOCKED_ON_OTHER_STACK:3,
+BLOCKED_UNDER_NATIVE_CODE:4,
+REPLACED_ON_ACTIVE_STACK:5,
+BLOCKED_UNDER_GENERATOR:6,
+BLOCKED_ACTIVE_GENERATOR:7,
+BLOCKED_NO_NEW_TARGET_ON_RESTART:8
+};
+by.SymbolName=function(bF){
+var bG=by;
+for(var bH in bG){
+if(bG[bH]==bF){
+return bH;
+}
+}
+};
+function Failure(as){
+this.message=as;
+}
+Failure.prototype.toString=function(){
+return"LiveEdit Failure: "+this.message;
+};
+function CopyErrorPositionToDetails(bI,p){
+function createPositionStruct(N,bJ){
+if(bJ==-1)return;
+var bK=N.locationFromPosition(bJ,true);
+if(bK==null)return;
+return{
+line:bK.line+1,
+column:bK.column+1,
+position:bJ
+};
+}
+if(!("scriptObject"in bI)||!("startPosition"in bI)){
+return;
+}
+var N=bI.scriptObject;
+var bL={
+start:createPositionStruct(N,bI.startPosition),
+end:createPositionStruct(N,bI.endPosition)
+};
+p.position=bL;
+}
+function GetPcFromSourcePos(bM,bN){
+return %GetFunctionCodePositionFromSource(bM,bN);
+}
+function SetScriptSource(N,bO,bP,Z){
+var j=N.source;
+var bQ=CompareStrings(j,bO);
+return ApplyPatchMultiChunk(N,bQ,bO,bP,
+Z);
+}
+function CompareStrings(bR,bS){
+return %LiveEditCompareStrings(bR,bS);
+}
+function ApplySingleChunkPatch(N,change_pos,change_len,new_str,
+Z){
+var j=N.source;
+var bO=j.substring(0,change_pos)+
+new_str+j.substring(change_pos+change_len);
+return ApplyPatchMultiChunk(N,
+[change_pos,change_pos+change_len,change_pos+new_str.length],
+bO,false,Z);
+}
+function DescribeChangeTree(bd){
+function ProcessOldNode(w){
+var bT=[];
+for(var x=0;x<w.children.length;x++){
+var bc=w.children[x];
+if(bc.status!=i.UNCHANGED){
+bT.push(ProcessOldNode(bc));
+}
+}
+var bU=[];
+if(w.textually_unmatched_new_nodes){
+for(var x=0;x<w.textually_unmatched_new_nodes.length;x++){
+var bc=w.textually_unmatched_new_nodes[x];
+bU.push(ProcessNewNode(bc));
+}
+}
+var bV={
+name:w.info.function_name,
+positions:DescribePositions(w),
+status:w.status,
+children:bT,
+new_children:bU
+};
+if(w.status_explanation){
+bV.status_explanation=w.status_explanation;
+}
+if(w.textual_corresponding_node){
+bV.new_positions=DescribePositions(w.textual_corresponding_node);
+}
+return bV;
+}
+function ProcessNewNode(w){
+var bT=[];
+if(false){
+for(var x=0;x<w.children.length;x++){
+bT.push(ProcessNewNode(w.children[x]));
+}
+}
+var bV={
+name:w.info.function_name,
+positions:DescribePositions(w),
+children:bT,
+};
+return bV;
+}
+function DescribePositions(w){
+return{
+start_position:w.info.start_position,
+end_position:w.info.end_position
+};
+}
+return ProcessOldNode(bd);
+}
+var bW={};
+bW.SetScriptSource=SetScriptSource;
+bW.ApplyPatchMultiChunk=ApplyPatchMultiChunk;
+bW.Failure=Failure;
+bW.GetPcFromSourcePos=GetPcFromSourcePos;
+bW.TestApi={
+PosTranslator:PosTranslator,
+CompareStrings:CompareStrings,
+ApplySingleChunkPatch:ApplySingleChunkPatch
+};
+a.Debug.LiveEdit=bW;
+})
+
+l prologueR
+(function(a,b,c){
+"use strict";
+%CheckIsBootstrapping();
+var d=(void 0);
+var e=(void 0);
+var f=%ExportFromRuntime({});
+var g=(void 0);
+function SetupTypedArray(h){
+h.next=g;
+g=h;
+}
+function Export(h){
+h(f);
+}
+function Import(h){
+h.next=d;
+d=h;
+}
+function ImportNow(i){
+return f[i];
+}
+function ImportFromExperimental(h){
+h.next=e;
+e=h;
+}
+function SetFunctionName(h,i,j){
+if((typeof(i)==='symbol')){
+i="["+%SymbolDescription(i)+"]";
+}
+if((j===(void 0))){
+%FunctionSetName(h,i);
+}else{
+%FunctionSetName(h,j+" "+i);
+}
+}
+function InstallConstants(k,l){
+%CheckIsBootstrapping();
+%OptimizeObjectForAddingMultipleProperties(k,l.length>>1);
+var m=2|4|1;
+for(var n=0;n<l.length;n+=2){
+var i=l[n];
+var o=l[n+1];
+%AddNamedProperty(k,i,o,m);
+}
+%ToFastProperties(k);
+}
+function InstallFunctions(k,m,p){
+%CheckIsBootstrapping();
+%OptimizeObjectForAddingMultipleProperties(k,p.length>>1);
+for(var n=0;n<p.length;n+=2){
+var q=p[n];
+var h=p[n+1];
+SetFunctionName(h,q);
+%FunctionRemovePrototype(h);
+%AddNamedProperty(k,q,h,m);
+%SetNativeFlag(h);
+}
+%ToFastProperties(k);
+}
+function InstallGetter(k,i,r,m,j){
+%CheckIsBootstrapping();
+if((m===(void 0)))m=2;
+SetFunctionName(r,i,(j===(void 0))?"get":j);
+%FunctionRemovePrototype(r);
+%DefineGetterPropertyUnchecked(k,i,r,m);
+%SetNativeFlag(r);
+}
+function InstallGetterSetter(k,i,r,s,m){
+%CheckIsBootstrapping();
+if((m===(void 0)))m=2;
+SetFunctionName(r,i,"get");
+SetFunctionName(s,i,"set");
+%FunctionRemovePrototype(r);
+%FunctionRemovePrototype(s);
+%DefineAccessorPropertyUnchecked(k,i,r,s,2);
+%SetNativeFlag(r);
+%SetNativeFlag(s);
+}
+function OverrideFunction(k,i,h,t){
+%CheckIsBootstrapping();
+%ObjectDefineProperty(k,i,{value:h,
+writeable:true,
+configurable:true,
+enumerable:false});
+SetFunctionName(h,i);
+if(!t)%FunctionRemovePrototype(h);
+%SetNativeFlag(h);
+}
+function SetUpLockedPrototype(
+constructor,fields,methods){
+%CheckIsBootstrapping();
+var u=constructor.prototype;
+var v=(methods.length>>1)+(fields?fields.length:0);
+if(v>=4){
+%OptimizeObjectForAddingMultipleProperties(u,v);
+}
+if(fields){
+for(var n=0;n<fields.length;n++){
+%AddNamedProperty(u,fields[n],
+(void 0),2|4);
+}
+}
+for(var n=0;n<methods.length;n+=2){
+var q=methods[n];
+var h=methods[n+1];
+%AddNamedProperty(u,q,h,2|4|1);
+%SetNativeFlag(h);
+}
+%InternalSetPrototype(u,null);
+%ToFastProperties(u);
+}
+function PostNatives(b){
+%CheckIsBootstrapping();
+for(;!(d===(void 0));d=d.next){
+d(f);
+}
+var w=[
+"ArrayToString",
+"ErrorToString",
+"GetIterator",
+"GetMethod",
+"IsNaN",
+"MakeError",
+"MakeRangeError",
+"MakeTypeError",
+"MapEntries",
+"MapIterator",
+"MapIteratorNext",
+"MaxSimple",
+"MinSimple",
+"NumberIsInteger",
+"ObjectDefineProperty",
+"ObserveArrayMethods",
+"ObserveObjectMethods",
+"PromiseChain",
+"PromiseDeferred",
+"PromiseResolved",
+"RegExpSubclassExecJS",
+"RegExpSubclassMatch",
+"RegExpSubclassReplace",
+"RegExpSubclassSearch",
+"RegExpSubclassSplit",
+"RegExpSubclassTest",
+"SetIterator",
+"SetIteratorNext",
+"SetValues",
+"SymbolToString",
+"ToPositiveInteger",
+"is_concat_spreadable_symbol",
+"iterator_symbol",
+"promise_status_symbol",
+"promise_value_symbol",
+"object_freeze",
+"object_is_frozen",
+"object_is_sealed",
+"reflect_apply",
+"reflect_construct",
+"regexp_flags_symbol",
+"to_string_tag_symbol",
+"object_to_string",
+"species_symbol",
+"match_symbol",
+"replace_symbol",
+"search_symbol",
+"split_symbol",
+];
+var x={};
+%OptimizeObjectForAddingMultipleProperties(
+x,w.length);
+for(var q of w){
+x[q]=f[q];
+}
+%ToFastProperties(x);
+f=x;
+b.PostNatives=(void 0);
+b.ImportFromExperimental=(void 0);
+}
+function PostExperimentals(b){
+%CheckIsBootstrapping();
+%ExportExperimentalFromRuntime(f);
+for(;!(d===(void 0));d=d.next){
+d(f);
+}
+for(;!(e===(void 0));
+e=e.next){
+e(f);
+}
+b.CreateDoubleResultArray();
+b.CreateDoubleResultArray=(void 0);
+b.Export=(void 0);
+b.PostDebug=(void 0);
+b.PostExperimentals=(void 0);
+g=(void 0);
+}
+function PostDebug(b){
+for(;!(d===(void 0));d=d.next){
+d(f);
+}
+b.CreateDoubleResultArray();
+b.CreateDoubleResultArray=(void 0);
+f=(void 0);
+b.Export=(void 0);
+b.Import=(void 0);
+b.ImportNow=(void 0);
+b.PostDebug=(void 0);
+b.PostExperimentals=(void 0);
+g=(void 0);
+}
+function InitializeBuiltinTypedArrays(b,y,z){
+var A=g;
+for(;!(A===(void 0));A=A.next){
+A(y,z);
+}
+}
+%OptimizeObjectForAddingMultipleProperties(b,14);
+b.Import=Import;
+b.ImportNow=ImportNow;
+b.Export=Export;
+b.ImportFromExperimental=ImportFromExperimental;
+b.SetFunctionName=SetFunctionName;
+b.InstallConstants=InstallConstants;
+b.InstallFunctions=InstallFunctions;
+b.InstallGetter=InstallGetter;
+b.InstallGetterSetter=InstallGetterSetter;
+b.OverrideFunction=OverrideFunction;
+b.SetUpLockedPrototype=SetUpLockedPrototype;
+b.PostNatives=PostNatives;
+b.PostExperimentals=PostExperimentals;
+b.PostDebug=PostDebug;
+%ToFastProperties(b);
+%OptimizeObjectForAddingMultipleProperties(c,5);
+c.logStackTrace=function logStackTrace(){
+%DebugTrace();
+};
+c.log=function log(){
+let message='';
+for(const arg of arguments){
+message+=arg;
+}
+%GlobalPrint(message);
+};
+c.createPrivateSymbol=function createPrivateSymbol(i){
+return %CreatePrivateSymbol(i);
+};
+c.simpleBind=function simpleBind(B,C){
+return function(...args){
+return %reflect_apply(B,C,args);
+};
+};
+c.uncurryThis=function uncurryThis(B){
+return function(C,...args){
+return %reflect_apply(B,C,args);
+};
+};
+%ToFastProperties(c);
+})
+
+runtime-
+(function(a,b){
+%CheckIsBootstrapping();
+var c;
+var d=a.Array;
+var e=a.Boolean;
+var f=a.String;
+var g;
+var h;
+var i;
+b.Import(function(j){
+g=j.MakeRangeError;
+h=j.MakeTypeError;
+i=j.species_symbol;
+});
+b.ImportFromExperimental(function(j){
+c=j.FLAG_harmony_species;
+});
+function AddIndexedProperty(k,l,m){
+if(l===((l)>>>0)&&l!==4294967295){
+%AddElement(k,l,m);
+}else{
+%AddNamedProperty(k,(%_ToString(l)),m,0);
+}
+}
+%SetForceInlineFlag(AddIndexedProperty);
+function ToPositiveInteger(n,o){
+var p=(%_IsSmi(%IS_VAR(n))?n:%NumberToIntegerMapMinusZero(n));
+if(p<0)throw g(o);
+return p;
+}
+function MaxSimple(q,r){
+return q>r?q:r;
+}
+function MinSimple(q,r){
+return q>r?r:q;
+}
+%SetForceInlineFlag(MaxSimple);
+%SetForceInlineFlag(MinSimple);
+function SpeciesConstructor(s,t,u){
+if(c){
+var v=s.constructor;
+if((v===(void 0))){
+return t;
+}
+if(!(%_IsJSReceiver(v))){
+throw h(29);
+}
+var w=v[i];
+if((w==null)){
+return t;
+}
+if(%IsConstructor(w)){
+return w;
+}
+throw h(242);
+}else{
+return u?t:s.constructor;
+}
+}
+%FunctionSetPrototype(d,new d(0));
+b.Export(function(x){
+x.AddIndexedProperty=AddIndexedProperty;
+x.MaxSimple=MaxSimple;
+x.MinSimple=MinSimple;
+x.ToPositiveInteger=ToPositiveInteger;
+x.SpeciesConstructor=SpeciesConstructor;
+});
+})
+
+$v8natives�

+(function(a,b){
+%CheckIsBootstrapping();
+var c=a.Array;
+var d=a.Number;
+var e=a.Object;
+var f=b.InternalArray;
+var g=b.ImportNow("iterator_symbol");
+var h;
+var i;
+var j;
+var k;
+var l=%GetRootNaN();
+var m=b.ImportNow("object_to_string");
+var n;
+var o;
+var p;
+var q=b.ImportNow("to_string_tag_symbol");
+b.Import(function(r){
+h=r.MakeRangeError;
+i=r.MakeSyntaxError;
+j=r.MakeTypeError;
+k=r.MathAbs;
+n=r.ObserveBeginPerformSplice;
+o=r.ObserveEndPerformSplice;
+p=r.ObserveEnqueueSpliceRecord;
+});
+function GlobalIsNaN(s){
+s=(%_ToNumber(s));
+return(!%_IsSmi(%IS_VAR(s))&&!(s==s));
+}
+function GlobalIsFinite(s){
+s=(%_ToNumber(s));
+return(%_IsSmi(%IS_VAR(s))||((s==s)&&(s!=1/0)&&(s!=-1/0)));
+}
+function GlobalParseInt(t,u){
+if((u===(void 0))||u===10||u===0){
+if(%_IsSmi(t))return t;
+if((typeof(t)==='number')&&
+((0.01<t&&t<1e9)||
+(-1e9<t&&t<-0.01))){
+return t|0;
+}
+t=(%_ToString(t));
+u=u|0;
+}else{
+t=(%_ToString(t));
+u=((u)|0);
+if(!(u==0||(2<=u&&u<=36))){
+return l;
+}
+}
+if(%_HasCachedArrayIndex(t)&&
+(u==0||u==10)){
+return %_GetCachedArrayIndex(t);
+}
+return %StringParseInt(t,u);
+}
+function GlobalParseFloat(t){
+t=(%_ToString(t));
+if(%_HasCachedArrayIndex(t))return %_GetCachedArrayIndex(t);
+return %StringParseFloat(t);
+}
+var v=2|4|1;
+b.InstallConstants(a,[
+"Infinity",(1/0),
+"NaN",l,
+"undefined",(void 0),
+]);
+b.InstallFunctions(a,2,[
+"isNaN",GlobalIsNaN,
+"isFinite",GlobalIsFinite,
+"parseInt",GlobalParseInt,
+"parseFloat",GlobalParseFloat,
+]);
+function ObjectToLocaleString(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(18,"Object.prototype.toLocaleString");
+return this.toString();
+}
+function ObjectValueOf(){
+return(%_ToObject(this));
+}
+function ObjectIsPrototypeOf(w){
+if(!(%_IsJSReceiver(w)))return false;
+var x=(%_ToObject(this));
+return %HasInPrototypeChain(w,x);
+}
+function ObjectPropertyIsEnumerable(w){
+var y=(%_ToName(w));
+return %PropertyIsEnumerable((%_ToObject(this)),y);
+}
+function ObjectDefineGetter(z,A){
+var B=this;
+if((B===null)||(B===(void 0))){
+B=%GlobalProxy(ObjectDefineGetter);
+}
+if(!(typeof(A)==='function')){
+throw j(76);
+}
+var C=new PropertyDescriptor();
+C.setGet(A);
+C.setEnumerable(true);
+C.setConfigurable(true);
+DefineOwnProperty((%_ToObject(B)),(%_ToName(z)),C,false);
+}
+function ObjectLookupGetter(z){
+var B=this;
+if((B===null)||(B===(void 0))){
+B=%GlobalProxy(ObjectLookupGetter);
+}
+return %LookupAccessor((%_ToObject(B)),(%_ToName(z)),0);
+}
+function ObjectDefineSetter(z,A){
+var B=this;
+if((B===null)||(B===(void 0))){
+B=%GlobalProxy(ObjectDefineSetter);
+}
+if(!(typeof(A)==='function')){
+throw j(79);
+}
+var C=new PropertyDescriptor();
+C.setSet(A);
+C.setEnumerable(true);
+C.setConfigurable(true);
+DefineOwnProperty((%_ToObject(B)),(%_ToName(z)),C,false);
+}
+function ObjectLookupSetter(z){
+var B=this;
+if((B===null)||(B===(void 0))){
+B=%GlobalProxy(ObjectLookupSetter);
+}
+return %LookupAccessor((%_ToObject(B)),(%_ToName(z)),1);
+}
+function IsAccessorDescriptor(C){
+if((C===(void 0)))return false;
+return C.hasGetter()||C.hasSetter();
+}
+function IsDataDescriptor(C){
+if((C===(void 0)))return false;
+return C.hasValue()||C.hasWritable();
+}
+function IsGenericDescriptor(C){
+if((C===(void 0)))return false;
+return!(IsAccessorDescriptor(C)||IsDataDescriptor(C));
+}
+function IsInconsistentDescriptor(C){
+return IsAccessorDescriptor(C)&&IsDataDescriptor(C);
+}
+function FromGenericPropertyDescriptor(C){
+if((C===(void 0)))return C;
+var D=new e();
+if(C.hasValue()){
+%AddNamedProperty(D,"value",C.getValue(),0);
+}
+if(C.hasWritable()){
+%AddNamedProperty(D,"writable",C.isWritable(),0);
+}
+if(C.hasGetter()){
+%AddNamedProperty(D,"get",C.getGet(),0);
+}
+if(C.hasSetter()){
+%AddNamedProperty(D,"set",C.getSet(),0);
+}
+if(C.hasEnumerable()){
+%AddNamedProperty(D,"enumerable",C.isEnumerable(),0);
+}
+if(C.hasConfigurable()){
+%AddNamedProperty(D,"configurable",C.isConfigurable(),0);
+}
+return D;
+}
+function ToPropertyDescriptor(D){
+if(!(%_IsJSReceiver(D)))throw j(95,D);
+var C=new PropertyDescriptor();
+if("enumerable"in D){
+C.setEnumerable((!!(D.enumerable)));
+}
+if("configurable"in D){
+C.setConfigurable((!!(D.configurable)));
+}
+if("value"in D){
+C.setValue(D.value);
+}
+if("writable"in D){
+C.setWritable((!!(D.writable)));
+}
+if("get"in D){
+var E=D.get;
+if(!(E===(void 0))&&!(typeof(E)==='function')){
+throw j(77,E);
+}
+C.setGet(E);
+}
+if("set"in D){
+var F=D.set;
+if(!(F===(void 0))&&!(typeof(F)==='function')){
+throw j(80,F);
+}
+C.setSet(F);
+}
+if(IsInconsistentDescriptor(C)){
+throw j(153,D);
+}
+return C;
+}
+function ToCompletePropertyDescriptor(D){
+var C=ToPropertyDescriptor(D);
+if(IsGenericDescriptor(C)||IsDataDescriptor(C)){
+if(!C.hasValue())C.setValue((void 0));
+if(!C.hasWritable())C.setWritable(false);
+}else{
+if(!C.hasGetter())C.setGet((void 0));
+if(!C.hasSetter())C.setSet((void 0));
+}
+if(!C.hasEnumerable())C.setEnumerable(false);
+if(!C.hasConfigurable())C.setConfigurable(false);
+return C;
+}
+function PropertyDescriptor(){
+this.value_=(void 0);
+this.hasValue_=false;
+this.writable_=false;
+this.hasWritable_=false;
+this.enumerable_=false;
+this.hasEnumerable_=false;
+this.configurable_=false;
+this.hasConfigurable_=false;
+this.get_=(void 0);
+this.hasGetter_=false;
+this.set_=(void 0);
+this.hasSetter_=false;
+}
+b.SetUpLockedPrototype(PropertyDescriptor,[
+"value_",
+"hasValue_",
+"writable_",
+"hasWritable_",
+"enumerable_",
+"hasEnumerable_",
+"configurable_",
+"hasConfigurable_",
+"get_",
+"hasGetter_",
+"set_",
+"hasSetter_"
+],[
+"toString",function PropertyDescriptor_ToString(){
+return"[object PropertyDescriptor]";
+},
+"setValue",function PropertyDescriptor_SetValue(G){
+this.value_=G;
+this.hasValue_=true;
+},
+"getValue",function PropertyDescriptor_GetValue(){
+return this.value_;
+},
+"hasValue",function PropertyDescriptor_HasValue(){
+return this.hasValue_;
+},
+"setEnumerable",function PropertyDescriptor_SetEnumerable(H){
+this.enumerable_=H;
+this.hasEnumerable_=true;
+},
+"isEnumerable",function PropertyDescriptor_IsEnumerable(){
+return this.enumerable_;
+},
+"hasEnumerable",function PropertyDescriptor_HasEnumerable(){
+return this.hasEnumerable_;
+},
+"setWritable",function PropertyDescriptor_SetWritable(I){
+this.writable_=I;
+this.hasWritable_=true;
+},
+"isWritable",function PropertyDescriptor_IsWritable(){
+return this.writable_;
+},
+"hasWritable",function PropertyDescriptor_HasWritable(){
+return this.hasWritable_;
+},
+"setConfigurable",
+function PropertyDescriptor_SetConfigurable(J){
+this.configurable_=J;
+this.hasConfigurable_=true;
+},
+"hasConfigurable",function PropertyDescriptor_HasConfigurable(){
+return this.hasConfigurable_;
+},
+"isConfigurable",function PropertyDescriptor_IsConfigurable(){
+return this.configurable_;
+},
+"setGet",function PropertyDescriptor_SetGetter(E){
+this.get_=E;
+this.hasGetter_=true;
+},
+"getGet",function PropertyDescriptor_GetGetter(){
+return this.get_;
+},
+"hasGetter",function PropertyDescriptor_HasGetter(){
+return this.hasGetter_;
+},
+"setSet",function PropertyDescriptor_SetSetter(F){
+this.set_=F;
+this.hasSetter_=true;
+},
+"getSet",function PropertyDescriptor_GetSetter(){
+return this.set_;
+},
+"hasSetter",function PropertyDescriptor_HasSetter(){
+return this.hasSetter_;
+}
+]);
+function ConvertDescriptorArrayToDescriptor(K){
+if((K===(void 0))){
+return(void 0);
+}
+var C=new PropertyDescriptor();
+if(K[0]){
+C.setGet(K[2]);
+C.setSet(K[3]);
+}else{
+C.setValue(K[1]);
+C.setWritable(K[4]);
+}
+C.setEnumerable(K[5]);
+C.setConfigurable(K[6]);
+return C;
+}
+function GetTrap(L,z,M){
+var N=L[z];
+if((N===(void 0))){
+if((M===(void 0))){
+throw j(43);
+}
+N=M;
+}else if(!(typeof(N)==='function')){
+throw j(43);
+}
+return N;
+}
+function CallTrap1(L,z,M,O){
+return %_Call(GetTrap(L,z,M),L,O);
+}
+function CallTrap2(L,z,M,O,P){
+return %_Call(GetTrap(L,z,M),L,O,P);
+}
+function GetOwnPropertyJS(D,Q){
+var R=(%_ToName(Q));
+if((%_IsJSProxy(D))){
+if((typeof(Q)==='symbol'))return(void 0);
+var L=%JSProxyGetHandler(D);
+var S=CallTrap1(
+L,"getOwnPropertyDescriptor",(void 0),R);
+if((S===(void 0)))return S;
+var C=ToCompletePropertyDescriptor(S);
+if(!C.isConfigurable()){
+throw j(43);
+}
+return C;
+}
+var T=%GetOwnProperty_Legacy((%_ToObject(D)),R);
+return ConvertDescriptorArrayToDescriptor(T);
+}
+function GetMethod(D,R){
+var U=D[R];
+if((U==null))return(void 0);
+if((typeof(U)==='function'))return U;
+throw j(15,typeof U);
+}
+function DefineProxyProperty(D,R,v,V){
+if((typeof(R)==='symbol'))return false;
+var L=%JSProxyGetHandler(D);
+var W=CallTrap2(L,"defineProperty",(void 0),R,v);
+if(!W){
+if(V){
+throw j(43);
+}else{
+return false;
+}
+}
+return true;
+}
+function DefineObjectProperty(D,R,C,V){
+var X=%GetOwnProperty_Legacy(D,(%_ToName(R)));
+var Y=ConvertDescriptorArrayToDescriptor(X);
+var Z=%object_is_extensible(D);
+if((Y===(void 0))&&!Z){
+if(V){
+throw j(36,R);
+}else{
+return false;
+}
+}
+if(!(Y===(void 0))){
+if((IsGenericDescriptor(C)||
+IsDataDescriptor(C)==IsDataDescriptor(Y))&&
+(!C.hasEnumerable()||
+%SameValue(C.isEnumerable(),Y.isEnumerable()))&&
+(!C.hasConfigurable()||
+%SameValue(C.isConfigurable(),Y.isConfigurable()))&&
+(!C.hasWritable()||
+%SameValue(C.isWritable(),Y.isWritable()))&&
+(!C.hasValue()||
+%SameValue(C.getValue(),Y.getValue()))&&
+(!C.hasGetter()||
+%SameValue(C.getGet(),Y.getGet()))&&
+(!C.hasSetter()||
+%SameValue(C.getSet(),Y.getSet()))){
+return true;
+}
+if(!Y.isConfigurable()){
+if(C.isConfigurable()||
+(C.hasEnumerable()&&
+C.isEnumerable()!=Y.isEnumerable())){
+if(V){
+throw j(129,R);
+}else{
+return false;
+}
+}
+if(!IsGenericDescriptor(C)){
+if(IsDataDescriptor(Y)!=IsDataDescriptor(C)){
+if(V){
+throw j(129,R);
+}else{
+return false;
+}
+}
+if(IsDataDescriptor(Y)&&IsDataDescriptor(C)){
+var aa=Y.isWritable();
+if(aa!=C.isWritable()){
+if(!aa){
+if(V){
+throw j(129,R);
+}else{
+return false;
+}
+}
+}
+if(!aa&&C.hasValue()&&
+!%SameValue(C.getValue(),Y.getValue())){
+if(V){
+throw j(129,R);
+}else{
+return false;
+}
+}
+}
+if(IsAccessorDescriptor(C)&&IsAccessorDescriptor(Y)){
+if(C.hasSetter()&&
+!%SameValue(C.getSet(),Y.getSet())){
+if(V){
+throw j(129,R);
+}else{
+return false;
+}
+}
+if(C.hasGetter()&&!%SameValue(C.getGet(),Y.getGet())){
+if(V){
+throw j(129,R);
+}else{
+return false;
+}
+}
+}
+}
+}
+}
+var ab=0;
+if(C.hasEnumerable()){
+ab|=C.isEnumerable()?0:2;
+}else if(!(Y===(void 0))){
+ab|=Y.isEnumerable()?0:2;
+}else{
+ab|=2;
+}
+if(C.hasConfigurable()){
+ab|=C.isConfigurable()?0:4;
+}else if(!(Y===(void 0))){
+ab|=Y.isConfigurable()?0:4;
+}else
+ab|=4;
+if(IsDataDescriptor(C)||
+(IsGenericDescriptor(C)&&
+((Y===(void 0))||IsDataDescriptor(Y)))){
+if(C.hasWritable()){
+ab|=C.isWritable()?0:1;
+}else if(!(Y===(void 0))){
+ab|=Y.isWritable()?0:1;
+}else{
+ab|=1;
+}
+var G=(void 0);
+if(C.hasValue()){
+G=C.getValue();
+}else if(!(Y===(void 0))&&IsDataDescriptor(Y)){
+G=Y.getValue();
+}
+%DefineDataPropertyUnchecked(D,R,G,ab);
+}else{
+var ac=null;
+if(C.hasGetter()){
+ac=C.getGet();
+}else if(IsAccessorDescriptor(Y)&&Y.hasGetter()){
+ac=Y.getGet();
+}
+var ad=null;
+if(C.hasSetter()){
+ad=C.getSet();
+}else if(IsAccessorDescriptor(Y)&&Y.hasSetter()){
+ad=Y.getSet();
+}
+%DefineAccessorPropertyUnchecked(D,R,ac,ad,ab);
+}
+return true;
+}
+function DefineArrayProperty(D,R,C,V){
+if(!(typeof(R)==='symbol')){
+var ae=((R)>>>0);
+var af=false;
+if((%_ToString(ae))==R&&ae!=4294967295){
+var ag=D.length;
+if(ae>=ag&&%IsObserved(D)){
+af=true;
+n(D);
+}
+var ah=GetOwnPropertyJS(D,"length");
+if((ae>=ag&&!ah.isWritable())||
+!DefineObjectProperty(D,R,C,true)){
+if(af)
+o(D);
+if(V){
+throw j(36,R);
+}else{
+return false;
+}
+}
+if(ae>=ag){
+D.length=ae+1;
+}
+if(af){
+o(D);
+p(D,ag,[],ae+1-ag);
+}
+return true;
+}
+}
+return DefineObjectProperty(D,R,C,V);
+}
+function DefineOwnProperty(D,R,C,V){
+if((%_IsJSProxy(D))){
+if((typeof(R)==='symbol'))return false;
+var v=FromGenericPropertyDescriptor(C);
+return DefineProxyProperty(D,R,v,V);
+}else if((%_IsArray(D))){
+return DefineArrayProperty(D,R,C,V);
+}else{
+return DefineObjectProperty(D,R,C,V);
+}
+}
+function ObjectGetPrototypeOf(D){
+return %_GetPrototype((%_ToObject(D)));
+}
+function ObjectSetPrototypeOf(D,ai){
+if((%IS_VAR(D)===null)||(D===(void 0)))throw j(18,"Object.setPrototypeOf");
+if(ai!==null&&!(%_IsJSReceiver(ai))){
+throw j(97,ai);
+}
+if((%_IsJSReceiver(D))){
+%SetPrototype(D,ai);
+}
+return D;
+}
+function ObjectDefineProperty(D,R,v){
+if(%IsObserved(D)){
+if(!(%_IsJSReceiver(D))){
+throw j(17,"Object.defineProperty");
+}
+var z=(%_ToName(R));
+var C=ToPropertyDescriptor(v);
+DefineOwnProperty(D,z,C,true);
+return D;
+}
+return %ObjectDefineProperty(D,R,v);
+}
+function ObjectDefineProperties(D,aj){
+if(%IsObserved(D)){
+if(!(%_IsJSReceiver(D))){
+throw j(17,"Object.defineProperties");
+}
+var T=(%_ToObject(aj));
+var ak=%GetOwnPropertyKeys(T,2);
+var al=new f();
+for(var am=0;am<ak.length;am++){
+al.push(ToPropertyDescriptor(T[ak[am]]));
+}
+for(var am=0;am<ak.length;am++){
+DefineOwnProperty(D,ak[am],al[am],true);
+}
+return D;
+}
+return %ObjectDefineProperties(D,aj);
+}
+function ObjectGetProto(){
+return %_GetPrototype((%_ToObject(this)));
+}
+function ObjectSetProto(ai){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(18,"Object.prototype.__proto__");
+if(((%_IsJSReceiver(ai))||(ai===null))&&(%_IsJSReceiver(this))){
+%SetPrototype(this,ai);
+}
+}
+function ObjectConstructor(O){
+if(e!=new.target&&!(new.target===(void 0))){
+return this;
+}
+if((O===null)||(O===(void 0)))return{};
+return(%_ToObject(O));
+}
+%SetNativeFlag(e);
+%SetCode(e,ObjectConstructor);
+%AddNamedProperty(e.prototype,"constructor",e,
+2);
+b.InstallFunctions(e.prototype,2,[
+"toString",m,
+"toLocaleString",ObjectToLocaleString,
+"valueOf",ObjectValueOf,
+"isPrototypeOf",ObjectIsPrototypeOf,
+"propertyIsEnumerable",ObjectPropertyIsEnumerable,
+"__defineGetter__",ObjectDefineGetter,
+"__lookupGetter__",ObjectLookupGetter,
+"__defineSetter__",ObjectDefineSetter,
+"__lookupSetter__",ObjectLookupSetter
+]);
+b.InstallGetterSetter(e.prototype,"__proto__",ObjectGetProto,
+ObjectSetProto);
+b.InstallFunctions(e,2,[
+"defineProperty",ObjectDefineProperty,
+"defineProperties",ObjectDefineProperties,
+"getPrototypeOf",ObjectGetPrototypeOf,
+"setPrototypeOf",ObjectSetPrototypeOf,
+]);
+function NumberToStringJS(u){
+var s=this;
+if(!(typeof(this)==='number')){
+if(!(%_ClassOf(this)==='Number')){
+throw j(69,'Number.prototype.toString');
+}
+s=%_ValueOf(this);
+}
+if((u===(void 0))||u===10){
+return %_NumberToString(s);
+}
+u=(%_ToInteger(u));
+if(u<2||u>36)throw h(188);
+return %NumberToRadixString(s,u);
+}
+function NumberToLocaleString(){
+return %_Call(NumberToStringJS,this);
+}
+function NumberValueOf(){
+if(!(typeof(this)==='number')&&!(%_ClassOf(this)==='Number')){
+throw j(69,'Number.prototype.valueOf');
+}
+return %_ValueOf(this);
+}
+function NumberToFixedJS(an){
+var O=this;
+if(!(typeof(this)==='number')){
+if(!(%_ClassOf(this)==='Number')){
+throw j(44,
+"Number.prototype.toFixed",this);
+}
+O=%_ValueOf(this);
+}
+var ao=(%_ToInteger(an));
+if(ao<0||ao>20){
+throw h(184,"toFixed() digits");
+}
+if((!%_IsSmi(%IS_VAR(O))&&!(O==O)))return"NaN";
+if(O==(1/0))return"Infinity";
+if(O==-(1/0))return"-Infinity";
+return %NumberToFixed(O,ao);
+}
+function NumberToExponentialJS(an){
+var O=this;
+if(!(typeof(this)==='number')){
+if(!(%_ClassOf(this)==='Number')){
+throw j(44,
+"Number.prototype.toExponential",this);
+}
+O=%_ValueOf(this);
+}
+var ao=(an===(void 0))?(void 0):(%_ToInteger(an));
+if((!%_IsSmi(%IS_VAR(O))&&!(O==O)))return"NaN";
+if(O==(1/0))return"Infinity";
+if(O==-(1/0))return"-Infinity";
+if((ao===(void 0))){
+ao=-1;
+}else if(ao<0||ao>20){
+throw h(184,"toExponential()");
+}
+return %NumberToExponential(O,ao);
+}
+function NumberToPrecisionJS(ap){
+var O=this;
+if(!(typeof(this)==='number')){
+if(!(%_ClassOf(this)==='Number')){
+throw j(44,
+"Number.prototype.toPrecision",this);
+}
+O=%_ValueOf(this);
+}
+if((ap===(void 0)))return(%_ToString(O));
+var R=(%_ToInteger(ap));
+if((!%_IsSmi(%IS_VAR(O))&&!(O==O)))return"NaN";
+if(O==(1/0))return"Infinity";
+if(O==-(1/0))return"-Infinity";
+if(R<1||R>21){
+throw h(187);
+}
+return %NumberToPrecision(O,R);
+}
+function NumberIsFinite(s){
+return(typeof(s)==='number')&&(%_IsSmi(%IS_VAR(s))||((s==s)&&(s!=1/0)&&(s!=-1/0)));
+}
+function NumberIsInteger(s){
+return NumberIsFinite(s)&&(%_ToInteger(s))==s;
+}
+function NumberIsNaN(s){
+return(typeof(s)==='number')&&(!%_IsSmi(%IS_VAR(s))&&!(s==s));
+}
+function NumberIsSafeInteger(s){
+if(NumberIsFinite(s)){
+var aq=(%_ToInteger(s));
+if(aq==s){
+return k(aq)<=9007199254740991;
+}
+}
+return false;
+}
+%FunctionSetPrototype(d,new d(0));
+%OptimizeObjectForAddingMultipleProperties(d.prototype,8);
+%AddNamedProperty(d.prototype,"constructor",d,
+2);
+b.InstallConstants(d,[
+"MAX_VALUE",1.7976931348623157e+308,
+"MIN_VALUE",5e-324,
+"NaN",l,
+"NEGATIVE_INFINITY",-(1/0),
+"POSITIVE_INFINITY",(1/0),
+"MAX_SAFE_INTEGER",%_MathPow(2,53)-1,
+"MIN_SAFE_INTEGER",-%_MathPow(2,53)+1,
+"EPSILON",%_MathPow(2,-52)
+]);
+b.InstallFunctions(d.prototype,2,[
+"toString",NumberToStringJS,
+"toLocaleString",NumberToLocaleString,
+"valueOf",NumberValueOf,
+"toFixed",NumberToFixedJS,
+"toExponential",NumberToExponentialJS,
+"toPrecision",NumberToPrecisionJS
+]);
+b.InstallFunctions(d,2,[
+"isFinite",NumberIsFinite,
+"isInteger",NumberIsInteger,
+"isNaN",NumberIsNaN,
+"isSafeInteger",NumberIsSafeInteger,
+"parseInt",GlobalParseInt,
+"parseFloat",GlobalParseFloat
+]);
+%SetForceInlineFlag(NumberIsNaN);
+function GetIterator(D,ar){
+if((ar===(void 0))){
+ar=D[g];
+}
+if(!(typeof(ar)==='function')){
+throw j(70,D);
+}
+var as=%_Call(ar,D);
+if(!(%_IsJSReceiver(as))){
+throw j(64,as);
+}
+return as;
+}
+b.Export(function(at){
+at.GetIterator=GetIterator;
+at.GetMethod=GetMethod;
+at.IsFinite=GlobalIsFinite;
+at.IsNaN=GlobalIsNaN;
+at.NumberIsNaN=NumberIsNaN;
+at.NumberIsInteger=NumberIsInteger;
+at.ObjectDefineProperties=ObjectDefineProperties;
+at.ObjectDefineProperty=ObjectDefineProperty;
+at.ObjectHasOwnProperty=e.prototype.hasOwnProperty;
+});
+%InstallToContext([
+"object_value_of",ObjectValueOf,
+]);
+})
+
+symbol�
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Symbol;
+var d=b.ImportNow("has_instance_symbol");
+var e=
+b.ImportNow("is_concat_spreadable_symbol");
+var f=b.ImportNow("iterator_symbol");
+var g;
+var h=b.ImportNow("to_primitive_symbol");
+var i=b.ImportNow("to_string_tag_symbol");
+var j=b.ImportNow("unscopables_symbol");
+b.Import(function(k){
+g=k.MakeTypeError;
+});
+function SymbolToPrimitive(l){
+if(!((typeof(this)==='symbol')||(%_ClassOf(this)==='Symbol'))){
+throw g(44,
+"Symbol.prototype [ @@toPrimitive ]",this);
+}
+return %_ValueOf(this);
+}
+function SymbolToString(){
+if(!((typeof(this)==='symbol')||(%_ClassOf(this)==='Symbol'))){
+throw g(44,
+"Symbol.prototype.toString",this);
+}
+return %SymbolDescriptiveString(%_ValueOf(this));
+}
+function SymbolValueOf(){
+if(!((typeof(this)==='symbol')||(%_ClassOf(this)==='Symbol'))){
+throw g(44,
+"Symbol.prototype.valueOf",this);
+}
+return %_ValueOf(this);
+}
+function SymbolFor(m){
+m=(%_ToString(m));
+var n=%SymbolRegistry();
+if((n.for[m]===(void 0))){
+var o=%CreateSymbol(m);
+n.for[m]=o;
+n.keyFor[o]=m;
+}
+return n.for[m];
+}
+function SymbolKeyFor(o){
+if(!(typeof(o)==='symbol'))throw g(147,o);
+return %SymbolRegistry().keyFor[o];
+}
+b.InstallConstants(c,[
+"hasInstance",d,
+"isConcatSpreadable",e,
+"iterator",f,
+"toPrimitive",h,
+"toStringTag",i,
+"unscopables",j,
+]);
+b.InstallFunctions(c,2,[
+"for",SymbolFor,
+"keyFor",SymbolKeyFor
+]);
+%AddNamedProperty(
+c.prototype,i,"Symbol",2|1);
+b.InstallFunctions(c.prototype,2|1,[
+h,SymbolToPrimitive
+]);
+b.InstallFunctions(c.prototype,2,[
+"toString",SymbolToString,
+"valueOf",SymbolValueOf
+]);
+b.Export(function(p){
+p.SymbolToString=SymbolToString;
+})
+})
+
+arrayf�

+(function(a,b,c){
+"use strict";
+%CheckIsBootstrapping();
+var d;
+var e;
+var f;
+var g;
+var h=a.Array;
+var i=b.InternalArray;
+var j=b.InternalPackedArray;
+var k;
+var l;
+var m;
+var n;
+var o;
+var p=b.ImportNow("object_to_string");
+var q;
+var r;
+var s;
+var t=b.ImportNow("iterator_symbol");
+var u=b.ImportNow("unscopables_symbol");
+b.Import(function(v){
+d=v.AddIndexedProperty;
+f=v.GetIterator;
+g=v.GetMethod;
+k=v.MakeTypeError;
+l=v.MaxSimple;
+m=v.MinSimple;
+n=v.ObjectDefineProperty;
+o=v.ObjectHasOwnProperty;
+q=v.ObserveBeginPerformSplice;
+r=v.ObserveEndPerformSplice;
+s=v.ObserveEnqueueSpliceRecord;
+});
+b.ImportFromExperimental(function(v){
+e=v.FLAG_harmony_species;
+});
+function ArraySpeciesCreate(w,x){
+var y;
+if(e){
+y=%ArraySpeciesConstructor(w);
+}else{
+y=h;
+}
+return new y(x);
+}
+function DefineIndexedProperty(w,z,A){
+if(e){
+var B=n(w,z,{
+value:A,writable:true,configurable:true,enumerable:true
+});
+if(!B)throw k(141,z);
+}else{
+d(w,z,A);
+}
+}
+function KeySortCompare(C,D){
+return C-D;
+}
+function GetSortedArrayKeys(w,E){
+if((typeof(E)==='number')){
+var F=new i();
+var G=E;
+for(var z=0;z<G;++z){
+var H=w[z];
+if(!(H===(void 0))||z in w){
+F.push(z);
+}
+}
+return F;
+}
+return InnerArraySort(E,E.length,KeySortCompare);
+}
+function SparseJoinWithSeparatorJS(w,F,x,I,J){
+var K=F.length;
+var L=new i(K*2);
+for(var z=0;z<K;z++){
+var M=F[z];
+var H=w[M];
+L[z*2]=M;
+L[z*2+1]=(typeof(H)==='string')?H:I(H);
+}
+return %SparseJoinWithSeparator(L,x,J);
+}
+function SparseJoin(w,F,I){
+var K=F.length;
+var L=new i(K);
+for(var z=0;z<K;z++){
+var H=w[F[z]];
+L[z]=(typeof(H)==='string')?H:I(H);
+}
+return %StringBuilderConcat(L,K,'');
+}
+function UseSparseVariant(w,x,N,O){
+if(!N||x<1000||%IsObserved(w)||
+%HasComplexElements(w)){
+return false;
+}
+if(!%_IsSmi(x)){
+return true;
+}
+var P=x>>2;
+var Q=%EstimateNumberOfElements(w);
+return(Q<P)&&
+(O>Q*4);
+}
+function Stack(){
+this.length=0;
+this.values=new i();
+}
+Stack.prototype.length=null;
+Stack.prototype.values=null;
+function StackPush(R,A){
+R.values[R.length++]=A;
+}
+function StackPop(R){
+R.values[--R.length]=null
+}
+function StackHas(R,S){
+var x=R.length;
+var T=R.values;
+for(var z=0;z<x;z++){
+if(T[z]===S)return true;
+}
+return false;
+}
+var U=new Stack();
+function DoJoin(w,x,N,J,I){
+if(UseSparseVariant(w,x,N,x)){
+%NormalizeElements(w);
+var F=GetSortedArrayKeys(w,%GetArrayKeys(w,x));
+if(J===''){
+if(F.length===0)return'';
+return SparseJoin(w,F,I);
+}else{
+return SparseJoinWithSeparatorJS(w,F,x,I,J);
+}
+}
+if(x===1){
+var H=w[0];
+return(typeof(H)==='string')?H:I(H);
+}
+var L=new i(x);
+if(J===''){
+for(var z=0;z<x;z++){
+var H=w[z];
+L[z]=(typeof(H)==='string')?H:I(H);
+}
+return %StringBuilderConcat(L,x,'');
+}
+var H=w[0];
+if((typeof(H)==='number')){
+L[0]=%_NumberToString(H);
+for(var z=1;z<x;z++){
+H=w[z];
+if((typeof(H)==='number')){
+L[z]=%_NumberToString(H);
+}else{
+L[z]=(typeof(H)==='string')?H:I(H);
+}
+}
+}else{
+L[0]=(typeof(H)==='string')?H:I(H);
+for(var z=1;z<x;z++){
+H=w[z];
+L[z]=(typeof(H)==='string')?H:I(H);
+}
+}
+return %StringBuilderJoin(L,x,J);
+}
+function Join(w,x,J,I){
+if(x===0)return'';
+var N=(%_IsArray(w));
+if(N){
+if(StackHas(U,w))return'';
+StackPush(U,w);
+}
+try{
+return DoJoin(w,x,N,J,I);
+}finally{
+if(N)StackPop(U);
+}
+}
+function ConvertToString(V){
+if((V==null))return'';
+return(%_ToString(V));
+}
+function ConvertToLocaleString(H){
+if((H==null))return'';
+return(%_ToString(H.toLocaleString()));
+}
+function SparseSlice(w,W,X,Y,Z){
+var E=%GetArrayKeys(w,W+X);
+if((typeof(E)==='number')){
+var G=E;
+for(var z=W;z<G;++z){
+var aa=w[z];
+if(!(aa===(void 0))||z in w){
+DefineIndexedProperty(Z,z-W,aa);
+}
+}
+}else{
+var x=E.length;
+for(var ab=0;ab<x;++ab){
+var M=E[ab];
+if(M>=W){
+var aa=w[M];
+if(!(aa===(void 0))||M in w){
+DefineIndexedProperty(Z,M-W,aa);
+}
+}
+}
+}
+}
+function SparseMove(w,W,X,Y,ac){
+if(ac===X)return;
+var ad=new i(
+m(Y-X+ac,0xffffffff));
+var ae;
+var E=%GetArrayKeys(w,Y);
+if((typeof(E)==='number')){
+var G=E;
+for(var z=0;z<W&&z<G;++z){
+var aa=w[z];
+if(!(aa===(void 0))||z in w){
+ad[z]=aa;
+}
+}
+for(var z=W+X;z<G;++z){
+var aa=w[z];
+if(!(aa===(void 0))||z in w){
+ad[z-X+ac]=aa;
+}
+}
+}else{
+var x=E.length;
+for(var ab=0;ab<x;++ab){
+var M=E[ab];
+if(M<W){
+var aa=w[M];
+if(!(aa===(void 0))||M in w){
+ad[M]=aa;
+}
+}else if(M>=W+X){
+var aa=w[M];
+if(!(aa===(void 0))||M in w){
+var af=M-X+ac;
+ad[af]=aa;
+if(af>0xfffffffe){
+ae=ae||new i();
+ae.push(af);
+}
+}
+}
+}
+}
+%MoveArrayContents(ad,w);
+if(!(ae===(void 0))){
+var x=ae.length;
+for(var z=0;z<x;++z){
+var M=ae[z];
+w[M]=ad[M];
+}
+}
+}
+function SimpleSlice(w,W,X,Y,Z){
+var N=(%_IsArray(w));
+for(var z=0;z<X;z++){
+var ag=W+z;
+if(((N&&%_HasFastPackedElements(%IS_VAR(w))&&(ag<w.length))||(ag in w))){
+var aa=w[ag];
+DefineIndexedProperty(Z,z,aa);
+}
+}
+}
+function SimpleMove(w,W,X,Y,ac){
+var N=(%_IsArray(w));
+if(ac!==X){
+if(ac>X){
+for(var z=Y-X;z>W;z--){
+var ah=z+X-1;
+var ai=z+ac-1;
+if(((N&&%_HasFastPackedElements(%IS_VAR(w))&&(ah<w.length))||(ah in w))){
+w[ai]=w[ah];
+}else{
+delete w[ai];
+}
+}
+}else{
+for(var z=W;z<Y-X;z++){
+var ah=z+X;
+var ai=z+ac;
+if(((N&&%_HasFastPackedElements(%IS_VAR(w))&&(ah<w.length))||(ah in w))){
+w[ai]=w[ah];
+}else{
+delete w[ai];
+}
+}
+for(var z=Y;z>Y-X+ac;z--){
+delete w[z-1];
+}
+}
+}
+}
+function ArrayToString(){
+var w;
+var aj;
+if((%_IsArray(this))){
+aj=this.join;
+if(aj===ArrayJoin){
+return Join(this,this.length,',',ConvertToString);
+}
+w=this;
+}else{
+w=(%_ToObject(this));
+aj=w.join;
+}
+if(!(typeof(aj)==='function')){
+return %_Call(p,w);
+}
+return %_Call(aj,w);
+}
+function InnerArrayToLocaleString(w,x){
+var Y=(%_ToLength(x));
+if(Y===0)return"";
+return Join(w,Y,',',ConvertToLocaleString);
+}
+function ArrayToLocaleString(){
+var w=(%_ToObject(this));
+var ak=w.length;
+return InnerArrayToLocaleString(w,ak);
+}
+function InnerArrayJoin(J,w,x){
+if((J===(void 0))){
+J=',';
+}else{
+J=(%_ToString(J));
+}
+if(x===1){
+var H=w[0];
+if((H==null))return'';
+return(%_ToString(H));
+}
+return Join(w,x,J,ConvertToString);
+}
+function ArrayJoin(J){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"Array.prototype.join");
+var w=(%_ToObject(this));
+var x=(%_ToLength(w.length));
+return InnerArrayJoin(J,w,x);
+}
+function ObservedArrayPop(al){
+al--;
+var A=this[al];
+try{
+q(this);
+delete this[al];
+this.length=al;
+}finally{
+r(this);
+s(this,al,[A],0);
+}
+return A;
+}
+function ArrayPop(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"Array.prototype.pop");
+var w=(%_ToObject(this));
+var al=(%_ToLength(w.length));
+if(al==0){
+w.length=al;
+return;
+}
+if(%IsObserved(w))
+return ObservedArrayPop.call(w,al);
+al--;
+var A=w[al];
+%DeleteProperty_Strict(w,al);
+w.length=al;
+return A;
+}
+function ObservedArrayPush(){
+var al=(%_ToLength(this.length));
+var am=arguments.length;
+try{
+q(this);
+for(var z=0;z<am;z++){
+this[z+al]=arguments[z];
+}
+var an=al+am;
+this.length=an;
+}finally{
+r(this);
+s(this,al,[],am);
+}
+return an;
+}
+function ArrayPush(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"Array.prototype.push");
+if(%IsObserved(this))
+return ObservedArrayPush.apply(this,arguments);
+var w=(%_ToObject(this));
+var al=(%_ToLength(w.length));
+var am=arguments.length;
+if(am>(1<<30)||(al-(1<<30))+am>9007199254740991-(1<<30)){
+throw k(233,am,al);
+}
+for(var z=0;z<am;z++){
+w[z+al]=arguments[z];
+}
+var an=al+am;
+w.length=an;
+return an;
+}
+function SparseReverse(w,Y){
+var F=GetSortedArrayKeys(w,%GetArrayKeys(w,Y));
+var ao=F.length-1;
+var ap=0;
+while(ap<=ao){
+var z=F[ap];
+var aq=F[ao];
+var ar=Y-aq-1;
+var as,at;
+if(ar<=z){
+at=aq;
+while(F[--ao]==aq){}
+as=ar;
+}
+if(ar>=z){
+as=z;
+while(F[++ap]==z){}
+at=Y-z-1;
+}
+var au=w[as];
+if(!(au===(void 0))||as in w){
+var av=w[at];
+if(!(av===(void 0))||at in w){
+w[as]=av;
+w[at]=au;
+}else{
+w[at]=au;
+delete w[as];
+}
+}else{
+var av=w[at];
+if(!(av===(void 0))||at in w){
+w[as]=av;
+delete w[at];
+}
+}
+}
+}
+function PackedArrayReverse(w,Y){
+var aq=Y-1;
+for(var z=0;z<aq;z++,aq--){
+var au=w[z];
+var av=w[aq];
+w[z]=av;
+w[aq]=au;
+}
+return w;
+}
+function GenericArrayReverse(w,Y){
+var aq=Y-1;
+for(var z=0;z<aq;z++,aq--){
+if(z in w){
+var au=w[z];
+if(aq in w){
+var av=w[aq];
+w[z]=av;
+w[aq]=au;
+}else{
+w[aq]=au;
+delete w[z];
+}
+}else{
+if(aq in w){
+var av=w[aq];
+w[z]=av;
+delete w[aq];
+}
+}
+}
+return w;
+}
+function ArrayReverse(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"Array.prototype.reverse");
+var w=(%_ToObject(this));
+var Y=(%_ToLength(w.length));
+var aw=(%_IsArray(w));
+if(UseSparseVariant(w,Y,aw,Y)){
+%NormalizeElements(w);
+SparseReverse(w,Y);
+return w;
+}else if(aw&&%_HasFastPackedElements(w)){
+return PackedArrayReverse(w,Y);
+}else{
+return GenericArrayReverse(w,Y);
+}
+}
+function ObservedArrayShift(Y){
+var ax=this[0];
+try{
+q(this);
+SimpleMove(this,0,1,Y,0);
+this.length=Y-1;
+}finally{
+r(this);
+s(this,0,[ax],0);
+}
+return ax;
+}
+function ArrayShift(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"Array.prototype.shift");
+var w=(%_ToObject(this));
+var Y=(%_ToLength(w.length));
+if(Y===0){
+w.length=0;
+return;
+}
+if(%object_is_sealed(w))throw k(13);
+if(%IsObserved(w))
+return ObservedArrayShift.call(w,Y);
+var ax=w[0];
+if(UseSparseVariant(w,Y,(%_IsArray(w)),Y)){
+SparseMove(w,0,1,Y,0);
+}else{
+SimpleMove(w,0,1,Y,0);
+}
+w.length=Y-1;
+return ax;
+}
+function ObservedArrayUnshift(){
+var Y=(%_ToLength(this.length));
+var ay=arguments.length;
+try{
+q(this);
+SimpleMove(this,0,0,Y,ay);
+for(var z=0;z<ay;z++){
+this[z]=arguments[z];
+}
+var an=Y+ay;
+this.length=an;
+}finally{
+r(this);
+s(this,0,[],ay);
+}
+return an;
+}
+function ArrayUnshift(az){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"Array.prototype.unshift");
+if(%IsObserved(this))
+return ObservedArrayUnshift.apply(this,arguments);
+var w=(%_ToObject(this));
+var Y=(%_ToLength(w.length));
+var ay=arguments.length;
+if(Y>0&&UseSparseVariant(w,Y,(%_IsArray(w)),Y)&&
+!%object_is_sealed(w)){
+SparseMove(w,0,0,Y,ay);
+}else{
+SimpleMove(w,0,0,Y,ay);
+}
+for(var z=0;z<ay;z++){
+w[z]=arguments[z];
+}
+var an=Y+ay;
+w.length=an;
+return an;
+}
+function ArraySlice(aA,aB){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"Array.prototype.slice");
+var w=(%_ToObject(this));
+var Y=(%_ToLength(w.length));
+var W=(%_ToInteger(aA));
+var aC=Y;
+if(!(aB===(void 0)))aC=(%_ToInteger(aB));
+if(W<0){
+W+=Y;
+if(W<0)W=0;
+}else{
+if(W>Y)W=Y;
+}
+if(aC<0){
+aC+=Y;
+if(aC<0)aC=0;
+}else{
+if(aC>Y)aC=Y;
+}
+var B=ArraySpeciesCreate(w,l(aC-W,0));
+if(aC<W)return B;
+if(UseSparseVariant(w,Y,(%_IsArray(w)),aC-W)){
+%NormalizeElements(w);
+%NormalizeElements(B);
+SparseSlice(w,W,aC-W,Y,B);
+}else{
+SimpleSlice(w,W,aC-W,Y,B);
+}
+B.length=aC-W;
+return B;
+}
+function ComputeSpliceStartIndex(W,Y){
+if(W<0){
+W+=Y;
+return W<0?0:W;
+}
+return W>Y?Y:W;
+}
+function ComputeSpliceDeleteCount(aD,ay,Y,W){
+var X=0;
+if(ay==1)
+return Y-W;
+X=(%_ToInteger(aD));
+if(X<0)
+return 0;
+if(X>Y-W)
+return Y-W;
+return X;
+}
+function ObservedArraySplice(aA,aD){
+var ay=arguments.length;
+var Y=(%_ToLength(this.length));
+var W=ComputeSpliceStartIndex((%_ToInteger(aA)),Y);
+var X=ComputeSpliceDeleteCount(aD,ay,Y,
+W);
+var Z=[];
+Z.length=X;
+var aE=ay>2?ay-2:0;
+try{
+q(this);
+SimpleSlice(this,W,X,Y,Z);
+SimpleMove(this,W,X,Y,aE);
+var z=W;
+var aF=2;
+var aG=arguments.length;
+while(aF<aG){
+this[z++]=arguments[aF++];
+}
+this.length=Y-X+aE;
+}finally{
+r(this);
+if(Z.length||aE){
+s(this,
+W,
+Z.slice(),
+aE);
+}
+}
+return Z;
+}
+function ArraySplice(aA,aD){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"Array.prototype.splice");
+if(%IsObserved(this))
+return ObservedArraySplice.apply(this,arguments);
+var ay=arguments.length;
+var w=(%_ToObject(this));
+var Y=(%_ToLength(w.length));
+var W=ComputeSpliceStartIndex((%_ToInteger(aA)),Y);
+var X=ComputeSpliceDeleteCount(aD,ay,Y,
+W);
+var Z=ArraySpeciesCreate(w,X);
+Z.length=X;
+var aE=ay>2?ay-2:0;
+if(X!=aE&&%object_is_sealed(w)){
+throw k(13);
+}else if(X>0&&%object_is_frozen(w)){
+throw k(12);
+}
+var aH=X;
+if(aE!=X){
+aH+=Y-W-X;
+}
+if(UseSparseVariant(w,Y,(%_IsArray(w)),aH)){
+%NormalizeElements(w);
+%NormalizeElements(Z);
+SparseSlice(w,W,X,Y,Z);
+SparseMove(w,W,X,Y,aE);
+}else{
+SimpleSlice(w,W,X,Y,Z);
+SimpleMove(w,W,X,Y,aE);
+}
+var z=W;
+var aF=2;
+var aG=arguments.length;
+while(aF<aG){
+w[z++]=arguments[aF++];
+}
+w.length=Y-X+aE;
+return Z;
+}
+function InnerArraySort(w,x,aI){
+if(!(typeof(aI)==='function')){
+aI=function(V,aJ){
+if(V===aJ)return 0;
+if(%_IsSmi(V)&&%_IsSmi(aJ)){
+return %SmiLexicographicCompare(V,aJ);
+}
+V=(%_ToString(V));
+aJ=(%_ToString(aJ));
+if(V==aJ)return 0;
+else return V<aJ?-1:1;
+};
+}
+var aK=function InsertionSort(C,v,aL){
+for(var z=v+1;z<aL;z++){
+var aM=C[z];
+for(var aq=z-1;aq>=v;aq--){
+var aN=C[aq];
+var aO=aI(aN,aM);
+if(aO>0){
+C[aq+1]=aN;
+}else{
+break;
+}
+}
+C[aq+1]=aM;
+}
+};
+var aP=function(C,v,aL){
+var aQ=new i();
+var aR=200+((aL-v)&15);
+var aq=0;
+v+=1;
+aL-=1;
+for(var z=v;z<aL;z+=aR){
+aQ[aq]=[z,C[z]];
+aq++;
+}
+aQ.sort(function(C,D){
+return aI(C[1],D[1]);
+});
+var aS=aQ[aQ.length>>1][0];
+return aS;
+}
+var aT=function QuickSort(C,v,aL){
+var aS=0;
+while(true){
+if(aL-v<=10){
+aK(C,v,aL);
+return;
+}
+if(aL-v>1000){
+aS=aP(C,v,aL);
+}else{
+aS=v+((aL-v)>>1);
+}
+var aU=C[v];
+var aV=C[aL-1];
+var aW=C[aS];
+var aX=aI(aU,aV);
+if(aX>0){
+var aN=aU;
+aU=aV;
+aV=aN;
+}
+var aY=aI(aU,aW);
+if(aY>=0){
+var aN=aU;
+aU=aW;
+aW=aV;
+aV=aN;
+}else{
+var aZ=aI(aV,aW);
+if(aZ>0){
+var aN=aV;
+aV=aW;
+aW=aN;
+}
+}
+C[v]=aU;
+C[aL-1]=aW;
+var ba=aV;
+var bb=v+1;
+var bc=aL-1;
+C[aS]=C[bb];
+C[bb]=ba;
+partition:for(var z=bb+1;z<bc;z++){
+var aM=C[z];
+var aO=aI(aM,ba);
+if(aO<0){
+C[z]=C[bb];
+C[bb]=aM;
+bb++;
+}else if(aO>0){
+do{
+bc--;
+if(bc==z)break partition;
+var bd=C[bc];
+aO=aI(bd,ba);
+}while(aO>0);
+C[z]=C[bc];
+C[bc]=aM;
+if(aO<0){
+aM=C[z];
+C[z]=C[bb];
+C[bb]=aM;
+bb++;
+}
+}
+}
+if(aL-bc<bb-v){
+aT(C,bc,aL);
+aL=bb;
+}else{
+aT(C,v,bb);
+v=bc;
+}
+}
+};
+var be=function CopyFromPrototype(bf,x){
+var bg=0;
+for(var bh=%_GetPrototype(bf);bh;bh=%_GetPrototype(bh)){
+var E=(%_IsJSProxy(bh))?x:%GetArrayKeys(bh,x);
+if((typeof(E)==='number')){
+var bi=E;
+for(var z=0;z<bi;z++){
+if(!(%_Call(o,bf,z))&&(%_Call(o,bh,z))){
+bf[z]=bh[z];
+if(z>=bg){bg=z+1;}
+}
+}
+}else{
+for(var z=0;z<E.length;z++){
+var ag=E[z];
+if(!(%_Call(o,bf,ag))&&(%_Call(o,bh,ag))){
+bf[ag]=bh[ag];
+if(ag>=bg){bg=ag+1;}
+}
+}
+}
+}
+return bg;
+};
+var bj=function(bf,v,aL){
+for(var bh=%_GetPrototype(bf);bh;bh=%_GetPrototype(bh)){
+var E=(%_IsJSProxy(bh))?aL:%GetArrayKeys(bh,aL);
+if((typeof(E)==='number')){
+var bi=E;
+for(var z=v;z<bi;z++){
+if((%_Call(o,bh,z))){
+bf[z]=(void 0);
+}
+}
+}else{
+for(var z=0;z<E.length;z++){
+var ag=E[z];
+if(v<=ag&&(%_Call(o,bh,ag))){
+bf[ag]=(void 0);
+}
+}
+}
+}
+};
+var bk=function SafeRemoveArrayHoles(bf){
+var bl=0;
+var bm=x-1;
+var bn=0;
+while(bl<bm){
+while(bl<bm&&
+!(bf[bl]===(void 0))){
+bl++;
+}
+if(!(%_Call(o,bf,bl))){
+bn++;
+}
+while(bl<bm&&
+(bf[bm]===(void 0))){
+if(!(%_Call(o,bf,bm))){
+bn++;
+}
+bm--;
+}
+if(bl<bm){
+bf[bl]=bf[bm];
+bf[bm]=(void 0);
+}
+}
+if(!(bf[bl]===(void 0)))bl++;
+var z;
+for(z=bl;z<x-bn;z++){
+bf[z]=(void 0);
+}
+for(z=x-bn;z<x;z++){
+if(z in %_GetPrototype(bf)){
+bf[z]=(void 0);
+}else{
+delete bf[z];
+}
+}
+return bl;
+};
+if(x<2)return w;
+var N=(%_IsArray(w));
+var bo;
+if(!N){
+bo=be(w,x);
+}
+var bp=%RemoveArrayHoles(w,x);
+if(bp==-1){
+bp=bk(w);
+}
+aT(w,0,bp);
+if(!N&&(bp+1<bo)){
+bj(w,bp,bo);
+}
+return w;
+}
+function ArraySort(aI){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"Array.prototype.sort");
+var w=(%_ToObject(this));
+var x=(%_ToLength(w.length));
+return InnerArraySort(w,x,aI);
+}
+function InnerArrayFilter(bq,br,w,x,B){
+var bs=0;
+var N=(%_IsArray(w));
+for(var z=0;z<x;z++){
+if(((N&&%_HasFastPackedElements(%IS_VAR(w))&&(z<w.length))||(z in w))){
+var aM=w[z];
+if(%_Call(bq,br,aM,z,w)){
+DefineIndexedProperty(B,bs,aM);
+bs++;
+}
+}
+}
+return B;
+}
+function ArrayFilter(bq,br){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"Array.prototype.filter");
+var w=(%_ToObject(this));
+var x=(%_ToLength(w.length));
+if(!(typeof(bq)==='function'))throw k(15,bq);
+var B=ArraySpeciesCreate(w,0);
+return InnerArrayFilter(bq,br,w,x,B);
+}
+function InnerArrayForEach(bq,br,w,x){
+if(!(typeof(bq)==='function'))throw k(15,bq);
+var N=(%_IsArray(w));
+if((br===(void 0))){
+for(var z=0;z<x;z++){
+if(((N&&%_HasFastPackedElements(%IS_VAR(w))&&(z<w.length))||(z in w))){
+var aM=w[z];
+bq(aM,z,w);
+}
+}
+}else{
+for(var z=0;z<x;z++){
+if(((N&&%_HasFastPackedElements(%IS_VAR(w))&&(z<w.length))||(z in w))){
+var aM=w[z];
+%_Call(bq,br,aM,z,w);
+}
+}
+}
+}
+function ArrayForEach(bq,br){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"Array.prototype.forEach");
+var w=(%_ToObject(this));
+var x=(%_ToLength(w.length));
+InnerArrayForEach(bq,br,w,x);
+}
+function InnerArraySome(bq,br,w,x){
+if(!(typeof(bq)==='function'))throw k(15,bq);
+var N=(%_IsArray(w));
+for(var z=0;z<x;z++){
+if(((N&&%_HasFastPackedElements(%IS_VAR(w))&&(z<w.length))||(z in w))){
+var aM=w[z];
+if(%_Call(bq,br,aM,z,w))return true;
+}
+}
+return false;
+}
+function ArraySome(bq,br){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"Array.prototype.some");
+var w=(%_ToObject(this));
+var x=(%_ToLength(w.length));
+return InnerArraySome(bq,br,w,x);
+}
+function InnerArrayEvery(bq,br,w,x){
+if(!(typeof(bq)==='function'))throw k(15,bq);
+var N=(%_IsArray(w));
+for(var z=0;z<x;z++){
+if(((N&&%_HasFastPackedElements(%IS_VAR(w))&&(z<w.length))||(z in w))){
+var aM=w[z];
+if(!%_Call(bq,br,aM,z,w))return false;
+}
+}
+return true;
+}
+function ArrayEvery(bq,br){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"Array.prototype.every");
+var w=(%_ToObject(this));
+var x=(%_ToLength(w.length));
+return InnerArrayEvery(bq,br,w,x);
+}
+function ArrayMap(bq,br){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"Array.prototype.map");
+var w=(%_ToObject(this));
+var x=(%_ToLength(w.length));
+if(!(typeof(bq)==='function'))throw k(15,bq);
+var B=ArraySpeciesCreate(w,x);
+var N=(%_IsArray(w));
+for(var z=0;z<x;z++){
+if(((N&&%_HasFastPackedElements(%IS_VAR(w))&&(z<w.length))||(z in w))){
+var aM=w[z];
+DefineIndexedProperty(B,z,%_Call(bq,br,aM,z,w));
+}
+}
+return B;
+}
+function InnerArrayIndexOf(w,aM,ag,x){
+if(x==0)return-1;
+if((ag===(void 0))){
+ag=0;
+}else{
+ag=(%_ToInteger(ag))+0;
+if(ag<0){
+ag=x+ag;
+if(ag<0)ag=0;
+}
+}
+var bt=ag;
+var bg=x;
+if(UseSparseVariant(w,x,(%_IsArray(w)),bg-bt)){
+%NormalizeElements(w);
+var E=%GetArrayKeys(w,x);
+if((typeof(E)==='number')){
+bg=E;
+}else{
+if(E.length==0)return-1;
+var bu=GetSortedArrayKeys(w,E);
+var al=bu.length;
+var z=0;
+while(z<al&&bu[z]<ag)z++;
+while(z<al){
+var M=bu[z];
+if(w[M]===aM)return M;
+z++;
+}
+return-1;
+}
+}
+if(!(aM===(void 0))){
+for(var z=bt;z<bg;z++){
+if(w[z]===aM)return z;
+}
+return-1;
+}
+for(var z=bt;z<bg;z++){
+if((w[z]===(void 0))&&z in w){
+return z;
+}
+}
+return-1;
+}
+function ArrayIndexOf(aM,ag){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"Array.prototype.indexOf");
+var x=(%_ToLength(this.length));
+return InnerArrayIndexOf(this,aM,ag,x);
+}
+function InnerArrayLastIndexOf(w,aM,ag,x,bv){
+if(x==0)return-1;
+if(bv<2){
+ag=x-1;
+}else{
+ag=(%_ToInteger(ag))+0;
+if(ag<0)ag+=x;
+if(ag<0)return-1;
+else if(ag>=x)ag=x-1;
+}
+var bt=0;
+var bg=ag;
+if(UseSparseVariant(w,x,(%_IsArray(w)),ag)){
+%NormalizeElements(w);
+var E=%GetArrayKeys(w,ag+1);
+if((typeof(E)==='number')){
+bg=E;
+}else{
+if(E.length==0)return-1;
+var bu=GetSortedArrayKeys(w,E);
+var z=bu.length-1;
+while(z>=0){
+var M=bu[z];
+if(w[M]===aM)return M;
+z--;
+}
+return-1;
+}
+}
+if(!(aM===(void 0))){
+for(var z=bg;z>=bt;z--){
+if(w[z]===aM)return z;
+}
+return-1;
+}
+for(var z=bg;z>=bt;z--){
+if((w[z]===(void 0))&&z in w){
+return z;
+}
+}
+return-1;
+}
+function ArrayLastIndexOf(aM,ag){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"Array.prototype.lastIndexOf");
+var x=(%_ToLength(this.length));
+return InnerArrayLastIndexOf(this,aM,ag,x,
+arguments.length);
+}
+function InnerArrayReduce(bw,aa,w,x,bv){
+if(!(typeof(bw)==='function')){
+throw k(15,bw);
+}
+var N=(%_IsArray(w));
+var z=0;
+find_initial:if(bv<2){
+for(;z<x;z++){
+if(((N&&%_HasFastPackedElements(%IS_VAR(w))&&(z<w.length))||(z in w))){
+aa=w[z++];
+break find_initial;
+}
+}
+throw k(131);
+}
+for(;z<x;z++){
+if(((N&&%_HasFastPackedElements(%IS_VAR(w))&&(z<w.length))||(z in w))){
+var aM=w[z];
+aa=bw(aa,aM,z,w);
+}
+}
+return aa;
+}
+function ArrayReduce(bw,aa){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"Array.prototype.reduce");
+var w=(%_ToObject(this));
+var x=(%_ToLength(w.length));
+return InnerArrayReduce(bw,aa,w,x,
+arguments.length);
+}
+function InnerArrayReduceRight(bw,aa,w,x,
+bv){
+if(!(typeof(bw)==='function')){
+throw k(15,bw);
+}
+var N=(%_IsArray(w));
+var z=x-1;
+find_initial:if(bv<2){
+for(;z>=0;z--){
+if(((N&&%_HasFastPackedElements(%IS_VAR(w))&&(z<w.length))||(z in w))){
+aa=w[z--];
+break find_initial;
+}
+}
+throw k(131);
+}
+for(;z>=0;z--){
+if(((N&&%_HasFastPackedElements(%IS_VAR(w))&&(z<w.length))||(z in w))){
+var aM=w[z];
+aa=bw(aa,aM,z,w);
+}
+}
+return aa;
+}
+function ArrayReduceRight(bw,aa){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"Array.prototype.reduceRight");
+var w=(%_ToObject(this));
+var x=(%_ToLength(w.length));
+return InnerArrayReduceRight(bw,aa,w,x,
+arguments.length);
+}
+function InnerArrayCopyWithin(bx,aA,aB,w,x){
+bx=(%_ToInteger(bx));
+var aL;
+if(bx<0){
+aL=l(x+bx,0);
+}else{
+aL=m(bx,x);
+}
+aA=(%_ToInteger(aA));
+var v;
+if(aA<0){
+v=l(x+aA,0);
+}else{
+v=m(aA,x);
+}
+aB=(aB===(void 0))?x:(%_ToInteger(aB));
+var by;
+if(aB<0){
+by=l(x+aB,0);
+}else{
+by=m(aB,x);
+}
+var bz=m(by-v,x-aL);
+var bA=1;
+if(v<aL&&aL<(v+bz)){
+bA=-1;
+v=v+bz-1;
+aL=aL+bz-1;
+}
+while(bz>0){
+if(v in w){
+w[aL]=w[v];
+}else{
+delete w[aL];
+}
+v=v+bA;
+aL=aL+bA;
+bz--;
+}
+return w;
+}
+function ArrayCopyWithin(bx,aA,aB){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"Array.prototype.copyWithin");
+var w=(%_ToObject(this));
+var x=(%_ToLength(w.length));
+return InnerArrayCopyWithin(bx,aA,aB,w,x);
+}
+function InnerArrayFind(bB,bC,w,x){
+if(!(typeof(bB)==='function')){
+throw k(15,bB);
+}
+for(var z=0;z<x;z++){
+var aM=w[z];
+if(%_Call(bB,bC,aM,z,w)){
+return aM;
+}
+}
+return;
+}
+function ArrayFind(bB,bC){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"Array.prototype.find");
+var w=(%_ToObject(this));
+var x=(%_ToInteger(w.length));
+return InnerArrayFind(bB,bC,w,x);
+}
+function InnerArrayFindIndex(bB,bC,w,x){
+if(!(typeof(bB)==='function')){
+throw k(15,bB);
+}
+for(var z=0;z<x;z++){
+var aM=w[z];
+if(%_Call(bB,bC,aM,z,w)){
+return z;
+}
+}
+return-1;
+}
+function ArrayFindIndex(bB,bC){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"Array.prototype.findIndex");
+var w=(%_ToObject(this));
+var x=(%_ToInteger(w.length));
+return InnerArrayFindIndex(bB,bC,w,x);
+}
+function InnerArrayFill(A,aA,aB,w,x){
+var z=(aA===(void 0))?0:(%_ToInteger(aA));
+var aB=(aB===(void 0))?x:(%_ToInteger(aB));
+if(z<0){
+z+=x;
+if(z<0)z=0;
+}else{
+if(z>x)z=x;
+}
+if(aB<0){
+aB+=x;
+if(aB<0)aB=0;
+}else{
+if(aB>x)aB=x;
+}
+if((aB-z)>0&&%object_is_frozen(w)){
+throw k(12);
+}
+for(;z<aB;z++)
+w[z]=A;
+return w;
+}
+function ArrayFill(A,aA,aB){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"Array.prototype.fill");
+var w=(%_ToObject(this));
+var x=(%_ToLength(w.length));
+return InnerArrayFill(A,aA,aB,w,x);
+}
+function InnerArrayIncludes(bD,bE,w,x){
+if(x===0){
+return false;
+}
+var al=(%_ToInteger(bE));
+var ab;
+if(al>=0){
+ab=al;
+}else{
+ab=x+al;
+if(ab<0){
+ab=0;
+}
+}
+while(ab<x){
+var bF=w[ab];
+if(%SameValueZero(bD,bF)){
+return true;
+}
+++ab;
+}
+return false;
+}
+function ArrayIncludes(bD,bE){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"Array.prototype.includes");
+var w=(%_ToObject(this));
+var x=(%_ToLength(w.length));
+return InnerArrayIncludes(bD,bE,w,x);
+}
+function AddArrayElement(y,w,z,A){
+if(y===h){
+d(w,z,A);
+}else{
+n(w,z,{
+value:A,writable:true,configurable:true,enumerable:true
+});
+}
+}
+function ArrayFrom(bG,bH,br){
+var bI=(%_ToObject(bG));
+var bJ=!(bH===(void 0));
+if(bJ){
+if(!(typeof(bH)==='function')){
+throw k(15,bH);
+}
+}
+var bK=g(bI,t);
+var ab;
+var B;
+var bL;
+var bM;
+if(!(bK===(void 0))){
+B=%IsConstructor(this)?new this():[];
+ab=0;
+for(bM of
+{[t](){return f(bI,bK)}}){
+if(bJ){
+bL=%_Call(bH,br,bM,ab);
+}else{
+bL=bM;
+}
+AddArrayElement(this,B,ab,bL);
+ab++;
+}
+B.length=ab;
+return B;
+}else{
+var Y=(%_ToLength(bI.length));
+B=%IsConstructor(this)?new this(Y):new h(Y);
+for(ab=0;ab<Y;++ab){
+bM=bI[ab];
+if(bJ){
+bL=%_Call(bH,br,bM,ab);
+}else{
+bL=bM;
+}
+AddArrayElement(this,B,ab,bL);
+}
+B.length=ab;
+return B;
+}
+}
+function ArrayOf(...args){
+var x=args.length;
+var y=this;
+var w=%IsConstructor(y)?new y(x):[];
+for(var z=0;z<x;z++){
+AddArrayElement(y,w,z,args[z]);
+}
+w.length=x;
+return w;
+}
+%AddNamedProperty(h.prototype,"constructor",h,
+2);
+var bN={
+__proto__:null,
+copyWithin:true,
+entries:true,
+fill:true,
+find:true,
+findIndex:true,
+keys:true,
+};
+%AddNamedProperty(h.prototype,u,bN,
+2|1);
+%FunctionSetLength(ArrayFrom,1);
+b.InstallFunctions(h,2,[
+"from",ArrayFrom,
+"of",ArrayOf
+]);
+var bO=%SpecialArrayFunctions();
+var bP=function(bQ,bR,Y){
+var bq=bR;
+if(bO.hasOwnProperty(bQ)){
+bq=bO[bQ];
+}
+if(!(Y===(void 0))){
+%FunctionSetLength(bq,Y);
+}
+return bq;
+};
+b.InstallFunctions(h.prototype,2,[
+"toString",bP("toString",ArrayToString),
+"toLocaleString",bP("toLocaleString",ArrayToLocaleString),
+"join",bP("join",ArrayJoin),
+"pop",bP("pop",ArrayPop),
+"push",bP("push",ArrayPush,1),
+"reverse",bP("reverse",ArrayReverse),
+"shift",bP("shift",ArrayShift),
+"unshift",bP("unshift",ArrayUnshift,1),
+"slice",bP("slice",ArraySlice,2),
+"splice",bP("splice",ArraySplice,2),
+"sort",bP("sort",ArraySort),
+"filter",bP("filter",ArrayFilter,1),
+"forEach",bP("forEach",ArrayForEach,1),
+"some",bP("some",ArraySome,1),
+"every",bP("every",ArrayEvery,1),
+"map",bP("map",ArrayMap,1),
+"indexOf",bP("indexOf",ArrayIndexOf,1),
+"lastIndexOf",bP("lastIndexOf",ArrayLastIndexOf,1),
+"reduce",bP("reduce",ArrayReduce,1),
+"reduceRight",bP("reduceRight",ArrayReduceRight,1),
+"copyWithin",bP("copyWithin",ArrayCopyWithin,2),
+"find",bP("find",ArrayFind,1),
+"findIndex",bP("findIndex",ArrayFindIndex,1),
+"fill",bP("fill",ArrayFill,1),
+"includes",bP("includes",ArrayIncludes,1),
+]);
+%FinishArrayPrototypeSetup(h.prototype);
+b.SetUpLockedPrototype(i,h(),[
+"indexOf",bP("indexOf",ArrayIndexOf),
+"join",bP("join",ArrayJoin),
+"pop",bP("pop",ArrayPop),
+"push",bP("push",ArrayPush),
+"shift",bP("shift",ArrayShift),
+"sort",bP("sort",ArraySort),
+"splice",bP("splice",ArraySplice)
+]);
+b.SetUpLockedPrototype(j,h(),[
+"join",bP("join",ArrayJoin),
+"pop",bP("pop",ArrayPop),
+"push",bP("push",ArrayPush),
+"shift",bP("shift",ArrayShift)
+]);
+b.SetUpLockedPrototype(c.InternalPackedArray,h(),[
+"push",bP("push",ArrayPush),
+"pop",bP("pop",ArrayPop),
+"shift",bP("shift",ArrayShift),
+"unshift",bP("unshift",ArrayUnshift),
+"splice",bP("splice",ArraySplice),
+"slice",bP("slice",ArraySlice)
+]);
+b.Export(function(aL){
+aL.ArrayFrom=ArrayFrom;
+aL.ArrayIndexOf=ArrayIndexOf;
+aL.ArrayJoin=ArrayJoin;
+aL.ArrayPush=ArrayPush;
+aL.ArrayToString=ArrayToString;
+aL.InnerArrayCopyWithin=InnerArrayCopyWithin;
+aL.InnerArrayEvery=InnerArrayEvery;
+aL.InnerArrayFill=InnerArrayFill;
+aL.InnerArrayFilter=InnerArrayFilter;
+aL.InnerArrayFind=InnerArrayFind;
+aL.InnerArrayFindIndex=InnerArrayFindIndex;
+aL.InnerArrayForEach=InnerArrayForEach;
+aL.InnerArrayIncludes=InnerArrayIncludes;
+aL.InnerArrayIndexOf=InnerArrayIndexOf;
+aL.InnerArrayJoin=InnerArrayJoin;
+aL.InnerArrayLastIndexOf=InnerArrayLastIndexOf;
+aL.InnerArrayReduce=InnerArrayReduce;
+aL.InnerArrayReduceRight=InnerArrayReduceRight;
+aL.InnerArraySome=InnerArraySome;
+aL.InnerArraySort=InnerArraySort;
+aL.InnerArrayToLocaleString=InnerArrayToLocaleString;
+aL.PackedArrayReverse=PackedArrayReverse;
+aL.Stack=Stack;
+aL.StackHas=StackHas;
+aL.StackPush=StackPush;
+aL.StackPop=StackPop;
+});
+%InstallToContext([
+"array_pop",ArrayPop,
+"array_push",ArrayPush,
+"array_shift",ArrayShift,
+"array_splice",ArraySplice,
+"array_slice",ArraySlice,
+"array_unshift",ArrayUnshift,
+]);
+});
+
+string]�
+(function(a,b){
+%CheckIsBootstrapping();
+var c;
+var d;
+var e=a.RegExp;
+var f=a.String;
+var g=b.InternalArray;
+var h=b.InternalPackedArray;
+var i;
+var j;
+var k;
+var l;
+var m;
+var n;
+var o=b.ImportNow("match_symbol");
+var p=b.ImportNow("replace_symbol");
+var q=b.ImportNow("search_symbol");
+var r=b.ImportNow("split_symbol");
+b.Import(function(s){
+c=s.ArrayIndexOf;
+d=s.ArrayJoin;
+i=s.IsRegExp;
+j=s.MakeRangeError;
+k=s.MakeTypeError;
+l=s.MaxSimple;
+m=s.MinSimple;
+n=s.RegExpInitialize;
+});
+function StringToString(){
+if(!(typeof(this)==='string')&&!(%_ClassOf(this)==='String')){
+throw k(69,'String.prototype.toString');
+}
+return %_ValueOf(this);
+}
+function StringValueOf(){
+if(!(typeof(this)==='string')&&!(%_ClassOf(this)==='String')){
+throw k(69,'String.prototype.valueOf');
+}
+return %_ValueOf(this);
+}
+function StringCharAtJS(t){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.charAt");
+var u=%_StringCharAt(this,t);
+if(%_IsSmi(u)){
+u=%_StringCharAt((%_ToString(this)),(%_ToInteger(t)));
+}
+return u;
+}
+function StringCharCodeAtJS(t){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.charCodeAt");
+var u=%_StringCharCodeAt(this,t);
+if(!%_IsSmi(u)){
+u=%_StringCharCodeAt((%_ToString(this)),(%_ToInteger(t)));
+}
+return u;
+}
+function StringConcat(v){
+"use strict";
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.concat");
+var w=(%_ToString(this));
+var x=arguments.length;
+for(var y=0;y<x;++y){
+w=w+(%_ToString(arguments[y]));
+}
+return w;
+}
+function StringIndexOf(z,A){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.indexOf");
+var B=(%_ToString(this));
+z=(%_ToString(z));
+var C=(%_ToInteger(A));
+if(C<0)C=0;
+if(C>B.length)C=B.length;
+return %StringIndexOf(B,z,C);
+}
+%FunctionSetLength(StringIndexOf,1);
+function StringLastIndexOf(D,t){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.lastIndexOf");
+var E=(%_ToString(this));
+var F=E.length;
+var D=(%_ToString(D));
+var G=D.length;
+var C=F-G;
+var A=(%_ToNumber(t));
+if(!(!%_IsSmi(%IS_VAR(A))&&!(A==A))){
+A=(%_ToInteger(A));
+if(A<0){
+A=0;
+}
+if(A+G<F){
+C=A;
+}
+}
+if(C<0){
+return-1;
+}
+return %StringLastIndexOf(E,D,C);
+}
+%FunctionSetLength(StringLastIndexOf,1);
+function StringLocaleCompareJS(v){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.localeCompare");
+return %StringLocaleCompare((%_ToString(this)),(%_ToString(v)));
+}
+function StringMatchJS(z){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.match");
+if(!(z==null)){
+var H=z[o];
+if(!(H===(void 0))){
+return %_Call(H,z,this);
+}
+}
+var B=(%_ToString(this));
+var I=%_NewObject(e,e);
+n(I,z);
+return I[o](B);
+}
+function StringNormalize(J){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.normalize");
+var w=(%_ToString(this));
+var K=(J===(void 0))?'NFC':(%_ToString(J));
+var L=['NFC','NFD','NFKC','NFKD'];
+var M=%_Call(c,L,K);
+if(M===-1){
+throw j(183,
+%_Call(d,L,', '));
+}
+return w;
+}
+%FunctionSetLength(StringNormalize,0);
+var N=[2,"","",-1,-1];
+function StringReplace(O,P){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.replace");
+if(!(O==null)){
+var Q=O[p];
+if(!(Q===(void 0))){
+return %_Call(Q,O,this,P);
+}
+}
+var B=(%_ToString(this));
+O=(%_ToString(O));
+if(O.length==1&&
+B.length>0xFF&&
+(typeof(P)==='string')&&
+%StringIndexOf(P,'$',0)<0){
+return %StringReplaceOneCharWithString(B,O,P);
+}
+var R=%StringIndexOf(B,O,0);
+if(R<0)return B;
+var S=R+O.length;
+var u=%_SubString(B,0,R);
+if((typeof(P)==='function')){
+u+=P(O,R,B);
+}else{
+N[3]=R;
+N[4]=S;
+u=ExpandReplacement((%_ToString(P)),
+B,
+N,
+u);
+}
+return u+%_SubString(B,S,B.length);
+}
+function ExpandReplacement(T,B,U,u){
+var V=T.length;
+var W=%StringIndexOf(T,'$',0);
+if(W<0){
+if(V>0)u+=T;
+return u;
+}
+if(W>0)u+=%_SubString(T,0,W);
+while(true){
+var X='$';
+var A=W+1;
+if(A<V){
+var Y=%_StringCharCodeAt(T,A);
+if(Y==36){
+++A;
+u+='$';
+}else if(Y==38){
+++A;
+u+=
+%_SubString(B,U[3],U[4]);
+}else if(Y==96){
+++A;
+u+=%_SubString(B,0,U[3]);
+}else if(Y==39){
+++A;
+u+=%_SubString(B,U[4],B.length);
+}else if(Y>=48&&Y<=57){
+var Z=(Y-48)<<1;
+var aa=1;
+var ab=((U)[0]);
+if(A+1<T.length){
+var W=%_StringCharCodeAt(T,A+1);
+if(W>=48&&W<=57){
+var ac=Z*10+((W-48)<<1);
+if(ac<ab){
+Z=ac;
+aa=2;
+}
+}
+}
+if(Z!=0&&Z<ab){
+var R=U[(3+(Z))];
+if(R>=0){
+u+=
+%_SubString(B,R,U[(3+(Z+1))]);
+}
+A+=aa;
+}else{
+u+='$';
+}
+}else{
+u+='$';
+}
+}else{
+u+='$';
+}
+W=%StringIndexOf(T,'$',A);
+if(W<0){
+if(A<V){
+u+=%_SubString(T,A,V);
+}
+return u;
+}
+if(W>A){
+u+=%_SubString(T,A,W);
+}
+}
+return u;
+}
+function StringSearch(z){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.search");
+if(!(z==null)){
+var ad=z[q];
+if(!(ad===(void 0))){
+return %_Call(ad,z,this);
+}
+}
+var B=(%_ToString(this));
+var I=%_NewObject(e,e);
+n(I,z);
+return %_Call(I[q],I,B);
+}
+function StringSlice(R,S){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.slice");
+var w=(%_ToString(this));
+var ae=w.length;
+var af=(%_ToInteger(R));
+var ag=ae;
+if(!(S===(void 0))){
+ag=(%_ToInteger(S));
+}
+if(af<0){
+af+=ae;
+if(af<0){
+af=0;
+}
+}else{
+if(af>ae){
+return'';
+}
+}
+if(ag<0){
+ag+=ae;
+if(ag<0){
+return'';
+}
+}else{
+if(ag>ae){
+ag=ae;
+}
+}
+if(ag<=af){
+return'';
+}
+return %_SubString(w,af,ag);
+}
+function StringSplitJS(ah,ai){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.split");
+if(!(ah==null)){
+var aj=ah[r];
+if(!(aj===(void 0))){
+return %_Call(aj,ah,this,ai);
+}
+}
+var B=(%_ToString(this));
+ai=((ai===(void 0)))?4294967295:((ai)>>>0);
+var V=B.length;
+var ak=(%_ToString(ah));
+if(ai===0)return[];
+if((ah===(void 0)))return[B];
+var al=ak.length;
+if(al===0)return %StringToArray(B,ai);
+return %StringSplit(B,ak,ai);
+}
+function StringSubstring(R,S){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.subString");
+var w=(%_ToString(this));
+var ae=w.length;
+var af=(%_ToInteger(R));
+if(af<0){
+af=0;
+}else if(af>ae){
+af=ae;
+}
+var ag=ae;
+if(!(S===(void 0))){
+ag=(%_ToInteger(S));
+if(ag>ae){
+ag=ae;
+}else{
+if(ag<0)ag=0;
+if(af>ag){
+var am=ag;
+ag=af;
+af=am;
+}
+}
+}
+return %_SubString(w,af,ag);
+}
+function StringSubstr(R,an){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.substr");
+var w=(%_ToString(this));
+var x;
+if((an===(void 0))){
+x=w.length;
+}else{
+x=(%_ToInteger(an));
+if(x<=0)return'';
+}
+if((R===(void 0))){
+R=0;
+}else{
+R=(%_ToInteger(R));
+if(R>=w.length)return'';
+if(R<0){
+R+=w.length;
+if(R<0)R=0;
+}
+}
+var S=R+x;
+if(S>w.length)S=w.length;
+return %_SubString(w,R,S);
+}
+function StringToLowerCaseJS(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.toLowerCase");
+return %StringToLowerCase((%_ToString(this)));
+}
+function StringToLocaleLowerCase(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.toLocaleLowerCase");
+return %StringToLowerCase((%_ToString(this)));
+}
+function StringToUpperCaseJS(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.toUpperCase");
+return %StringToUpperCase((%_ToString(this)));
+}
+function StringToLocaleUpperCase(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.toLocaleUpperCase");
+return %StringToUpperCase((%_ToString(this)));
+}
+function StringTrimJS(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.trim");
+return %StringTrim((%_ToString(this)),true,true);
+}
+function StringTrimLeft(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.trimLeft");
+return %StringTrim((%_ToString(this)),true,false);
+}
+function StringTrimRight(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.trimRight");
+return %StringTrim((%_ToString(this)),false,true);
+}
+function StringFromCharCode(ao){
+"use strict";
+var w="";
+var an=arguments.length;
+for(var y=0;y<an;++y){
+w+=%_StringCharFromCode(arguments[y]&0xffff);
+}
+return w;
+}
+function HtmlEscape(ap){
+return %_Call(StringReplace,(%_ToString(ap)),/"/g,"&quot;");
+}
+function StringAnchor(aq){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.anchor");
+return"<a name=\""+HtmlEscape(aq)+"\">"+(%_ToString(this))+
+"</a>";
+}
+function StringBig(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.big");
+return"<big>"+(%_ToString(this))+"</big>";
+}
+function StringBlink(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.blink");
+return"<blink>"+(%_ToString(this))+"</blink>";
+}
+function StringBold(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.bold");
+return"<b>"+(%_ToString(this))+"</b>";
+}
+function StringFixed(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.fixed");
+return"<tt>"+(%_ToString(this))+"</tt>";
+}
+function StringFontcolor(ar){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.fontcolor");
+return"<font color=\""+HtmlEscape(ar)+"\">"+(%_ToString(this))+
+"</font>";
+}
+function StringFontsize(as){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.fontsize");
+return"<font size=\""+HtmlEscape(as)+"\">"+(%_ToString(this))+
+"</font>";
+}
+function StringItalics(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.italics");
+return"<i>"+(%_ToString(this))+"</i>";
+}
+function StringLink(w){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.link");
+return"<a href=\""+HtmlEscape(w)+"\">"+(%_ToString(this))+"</a>";
+}
+function StringSmall(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.small");
+return"<small>"+(%_ToString(this))+"</small>";
+}
+function StringStrike(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.strike");
+return"<strike>"+(%_ToString(this))+"</strike>";
+}
+function StringSub(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.sub");
+return"<sub>"+(%_ToString(this))+"</sub>";
+}
+function StringSup(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.sup");
+return"<sup>"+(%_ToString(this))+"</sup>";
+}
+function StringRepeat(at){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.repeat");
+var w=(%_ToString(this));
+var an=(%_ToInteger(at));
+if(an<0||an===(1/0))throw j(167);
+if(w.length===0)return"";
+if(an>%_MaxSmi())throw j(167);
+var au="";
+while(true){
+if(an&1)au+=w;
+an>>=1;
+if(an===0)return au;
+w+=w;
+}
+}
+function StringStartsWith(av,A){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.startsWith");
+var w=(%_ToString(this));
+if(i(av)){
+throw k(40,"String.prototype.startsWith");
+}
+var aw=(%_ToString(av));
+var t=(%_ToInteger(A));
+var ae=w.length;
+var R=m(l(t,0),ae);
+var ax=aw.length;
+if(ax+R>ae){
+return false;
+}
+return %_SubString(w,R,R+ax)===aw;
+}
+%FunctionSetLength(StringStartsWith,1);
+function StringEndsWith(av,A){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.endsWith");
+var w=(%_ToString(this));
+if(i(av)){
+throw k(40,"String.prototype.endsWith");
+}
+var aw=(%_ToString(av));
+var ae=w.length;
+var t=!(A===(void 0))?(%_ToInteger(A)):ae
+var S=m(l(t,0),ae);
+var ax=aw.length;
+var R=S-ax;
+if(R<0){
+return false;
+}
+return %_SubString(w,R,R+ax)===aw;
+}
+%FunctionSetLength(StringEndsWith,1);
+function StringIncludes(av,A){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.includes");
+var T=(%_ToString(this));
+if(i(av)){
+throw k(40,"String.prototype.includes");
+}
+av=(%_ToString(av));
+var t=(%_ToInteger(A));
+var ay=T.length;
+if(t<0)t=0;
+if(t>ay)t=ay;
+var az=av.length;
+if(az+t>ay){
+return false;
+}
+return %StringIndexOf(T,av,t)!==-1;
+}
+%FunctionSetLength(StringIncludes,1);
+function StringCodePointAt(t){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(18,"String.prototype.codePointAt");
+var T=(%_ToString(this));
+var as=T.length;
+t=(%_ToInteger(t));
+if(t<0||t>=as){
+return(void 0);
+}
+var aA=%_StringCharCodeAt(T,t);
+if(aA<0xD800||aA>0xDBFF||t+1==as){
+return aA;
+}
+var aB=%_StringCharCodeAt(T,t+1);
+if(aB<0xDC00||aB>0xDFFF){
+return aA;
+}
+return(aA-0xD800)*0x400+aB+0x2400;
+}
+function StringFromCodePoint(ao){
+"use strict";
+var aC;
+var V=arguments.length;
+var C;
+var u="";
+for(C=0;C<V;C++){
+aC=arguments[C];
+if(!%_IsSmi(aC)){
+aC=(%_ToNumber(aC));
+}
+if(aC<0||aC>0x10FFFF||aC!==(%_ToInteger(aC))){
+throw j(166,aC);
+}
+if(aC<=0xFFFF){
+u+=%_StringCharFromCode(aC);
+}else{
+aC-=0x10000;
+u+=%_StringCharFromCode((aC>>>10)&0x3FF|0xD800);
+u+=%_StringCharFromCode(aC&0x3FF|0xDC00);
+}
+}
+return u;
+}
+function StringRaw(aD){
+"use strict";
+var aE=arguments.length;
+var aF=(%_ToObject(aD));
+var aG=(%_ToObject(aF.raw));
+var aH=(%_ToLength(aG.length));
+if(aH<=0)return"";
+var u=(%_ToString(aG[0]));
+for(var y=1;y<aH;++y){
+if(y<aE){
+u+=(%_ToString(arguments[y]));
+}
+u+=(%_ToString(aG[y]));
+}
+return u;
+}
+%FunctionSetPrototype(f,new f());
+%AddNamedProperty(
+f.prototype,"constructor",f,2);
+b.InstallFunctions(f,2,[
+"fromCharCode",StringFromCharCode,
+"fromCodePoint",StringFromCodePoint,
+"raw",StringRaw
+]);
+b.InstallFunctions(f.prototype,2,[
+"valueOf",StringValueOf,
+"toString",StringToString,
+"charAt",StringCharAtJS,
+"charCodeAt",StringCharCodeAtJS,
+"codePointAt",StringCodePointAt,
+"concat",StringConcat,
+"endsWith",StringEndsWith,
+"includes",StringIncludes,
+"indexOf",StringIndexOf,
+"lastIndexOf",StringLastIndexOf,
+"localeCompare",StringLocaleCompareJS,
+"match",StringMatchJS,
+"normalize",StringNormalize,
+"repeat",StringRepeat,
+"replace",StringReplace,
+"search",StringSearch,
+"slice",StringSlice,
+"split",StringSplitJS,
+"substring",StringSubstring,
+"substr",StringSubstr,
+"startsWith",StringStartsWith,
+"toLowerCase",StringToLowerCaseJS,
+"toLocaleLowerCase",StringToLocaleLowerCase,
+"toUpperCase",StringToUpperCaseJS,
+"toLocaleUpperCase",StringToLocaleUpperCase,
+"trim",StringTrimJS,
+"trimLeft",StringTrimLeft,
+"trimRight",StringTrimRight,
+"link",StringLink,
+"anchor",StringAnchor,
+"fontcolor",StringFontcolor,
+"fontsize",StringFontsize,
+"big",StringBig,
+"blink",StringBlink,
+"bold",StringBold,
+"fixed",StringFixed,
+"italics",StringItalics,
+"small",StringSmall,
+"strike",StringStrike,
+"sub",StringSub,
+"sup",StringSup
+]);
+b.Export(function(aI){
+aI.ExpandReplacement=ExpandReplacement;
+aI.StringCharAt=StringCharAtJS;
+aI.StringIndexOf=StringIndexOf;
+aI.StringLastIndexOf=StringLastIndexOf;
+aI.StringMatch=StringMatchJS;
+aI.StringReplace=StringReplace;
+aI.StringSlice=StringSlice;
+aI.StringSplit=StringSplitJS;
+aI.StringSubstr=StringSubstr;
+aI.StringSubstring=StringSubstring;
+});
+})
+
+uri�T
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Object;
+var d=b.InternalArray;
+var e;
+b.Import(function(f){
+e=f.MakeURIError;
+});
+function HexValueOf(g){
+if(g>=48&&g<=57)return g-48;
+if(g>=65&&g<=70)return g-55;
+if(g>=97&&g<=102)return g-87;
+return-1;
+}
+function isAlphaNumeric(h){
+if(97<=h&&h<=122)return true;
+if(65<=h&&h<=90)return true;
+if(48<=h&&h<=57)return true;
+return false;
+}
+var i=0;
+function URIAddEncodedOctetToBuffer(j,k,l){
+k[l++]=37;
+k[l++]=i[j>>4];
+k[l++]=i[j&0x0F];
+return l;
+}
+function URIEncodeOctets(m,k,l){
+if(i===0){
+i=[48,49,50,51,52,53,54,55,56,57,
+65,66,67,68,69,70];
+}
+l=URIAddEncodedOctetToBuffer(m[0],k,l);
+if(m[1])l=URIAddEncodedOctetToBuffer(m[1],k,l);
+if(m[2])l=URIAddEncodedOctetToBuffer(m[2],k,l);
+if(m[3])l=URIAddEncodedOctetToBuffer(m[3],k,l);
+return l;
+}
+function URIEncodeSingle(h,k,l){
+var n=(h>>12)&0xF;
+var o=(h>>6)&63;
+var p=h&63;
+var m=new d(3);
+if(h<=0x007F){
+m[0]=h;
+}else if(h<=0x07FF){
+m[0]=o+192;
+m[1]=p+128;
+}else{
+m[0]=n+224;
+m[1]=o+128;
+m[2]=p+128;
+}
+return URIEncodeOctets(m,k,l);
+}
+function URIEncodePair(q,r,k,l){
+var s=((q>>6)&0xF)+1;
+var t=(q>>2)&0xF;
+var n=q&3;
+var o=(r>>6)&0xF;
+var p=r&63;
+var m=new d(4);
+m[0]=(s>>2)+240;
+m[1]=(((s&3)<<4)|t)+128;
+m[2]=((n<<4)|o)+128;
+m[3]=p+128;
+return URIEncodeOctets(m,k,l);
+}
+function URIHexCharsToCharCode(u,v){
+var w=HexValueOf(u);
+var x=HexValueOf(v);
+if(w==-1||x==-1)throw e();
+return(w<<4)|x;
+}
+function URIDecodeOctets(m,k,l){
+var y;
+var z=m[0];
+if(z<0x80){
+y=z;
+}else if(z<0xc2){
+throw e();
+}else{
+var A=m[1];
+if(z<0xe0){
+var B=z&0x1f;
+if((A<0x80)||(A>0xbf))throw e();
+var C=A&0x3f;
+y=(B<<6)+C;
+if(y<0x80||y>0x7ff)throw e();
+}else{
+var D=m[2];
+if(z<0xf0){
+var B=z&0x0f;
+if((A<0x80)||(A>0xbf))throw e();
+var C=A&0x3f;
+if((D<0x80)||(D>0xbf))throw e();
+var E=D&0x3f;
+y=(B<<12)+(C<<6)+E;
+if((y<0x800)||(y>0xffff))throw e();
+}else{
+var F=m[3];
+if(z<0xf8){
+var B=(z&0x07);
+if((A<0x80)||(A>0xbf))throw e();
+var C=(A&0x3f);
+if((D<0x80)||(D>0xbf)){
+throw e();
+}
+var E=(D&0x3f);
+if((F<0x80)||(F>0xbf))throw e();
+var G=(F&0x3f);
+y=(B<<18)+(C<<12)+(E<<6)+G;
+if((y<0x10000)||(y>0x10ffff))throw e();
+}else{
+throw e();
+}
+}
+}
+}
+if(0xD800<=y&&y<=0xDFFF)throw e();
+if(y<0x10000){
+%_TwoByteSeqStringSetChar(l++,y,k);
+}else{
+%_TwoByteSeqStringSetChar(l++,(y>>10)+0xd7c0,k);
+%_TwoByteSeqStringSetChar(l++,(y&0x3ff)+0xdc00,k);
+}
+return l;
+}
+function Encode(H,I){
+H=(%_ToString(H));
+var J=H.length;
+var K=new d(J);
+var l=0;
+for(var L=0;L<J;L++){
+var q=%_StringCharCodeAt(H,L);
+if(I(q)){
+K[l++]=q;
+}else{
+if(q>=0xDC00&&q<=0xDFFF)throw e();
+if(q<0xD800||q>0xDBFF){
+l=URIEncodeSingle(q,K,l);
+}else{
+L++;
+if(L==J)throw e();
+var r=%_StringCharCodeAt(H,L);
+if(r<0xDC00||r>0xDFFF)throw e();
+l=URIEncodePair(q,r,K,l);
+}
+}
+}
+var k=%NewString(K.length,true);
+for(var M=0;M<K.length;M++){
+%_OneByteSeqStringSetChar(M,K[M],k);
+}
+return k;
+}
+function Decode(H,N){
+H=(%_ToString(H));
+var J=H.length;
+var O=%NewString(J,true);
+var l=0;
+var L=0;
+for(;L<J;L++){
+var g=%_StringCharCodeAt(H,L);
+if(g==37){
+if(L+2>=J)throw e();
+var h=URIHexCharsToCharCode(%_StringCharCodeAt(H,L+1),
+%_StringCharCodeAt(H,L+2));
+if(h>>7)break;
+if(N(h)){
+%_OneByteSeqStringSetChar(l++,37,O);
+%_OneByteSeqStringSetChar(l++,%_StringCharCodeAt(H,L+1),
+O);
+%_OneByteSeqStringSetChar(l++,%_StringCharCodeAt(H,L+2),
+O);
+}else{
+%_OneByteSeqStringSetChar(l++,h,O);
+}
+L+=2;
+}else{
+if(g>0x7f)break;
+%_OneByteSeqStringSetChar(l++,g,O);
+}
+}
+O=%TruncateString(O,l);
+if(L==J)return O;
+var P=%NewString(J-L,false);
+l=0;
+for(;L<J;L++){
+var g=%_StringCharCodeAt(H,L);
+if(g==37){
+if(L+2>=J)throw e();
+var h=URIHexCharsToCharCode(%_StringCharCodeAt(H,++L),
+%_StringCharCodeAt(H,++L));
+if(h>>7){
+var Q=0;
+while(((h<<++Q)&0x80)!=0){}
+if(Q==1||Q>4)throw e();
+var m=new d(Q);
+m[0]=h;
+if(L+3*(Q-1)>=J)throw e();
+for(var M=1;M<Q;M++){
+if(H[++L]!='%')throw e();
+m[M]=URIHexCharsToCharCode(%_StringCharCodeAt(H,++L),
+%_StringCharCodeAt(H,++L));
+}
+l=URIDecodeOctets(m,P,l);
+}else if(N(h)){
+%_TwoByteSeqStringSetChar(l++,37,P);
+%_TwoByteSeqStringSetChar(l++,%_StringCharCodeAt(H,L-1),
+P);
+%_TwoByteSeqStringSetChar(l++,%_StringCharCodeAt(H,L),
+P);
+}else{
+%_TwoByteSeqStringSetChar(l++,h,P);
+}
+}else{
+%_TwoByteSeqStringSetChar(l++,g,P);
+}
+}
+P=%TruncateString(P,l);
+return O+P;
+}
+function URIEscapeJS(R){
+return %URIEscape(R);
+}
+function URIUnescapeJS(R){
+return %URIUnescape(R);
+}
+function URIDecode(H){
+var S=function(h){
+if(35<=h&&h<=36)return true;
+if(h==38)return true;
+if(43<=h&&h<=44)return true;
+if(h==47)return true;
+if(58<=h&&h<=59)return true;
+if(h==61)return true;
+if(63<=h&&h<=64)return true;
+return false;
+};
+return Decode(H,S);
+}
+function URIDecodeComponent(T){
+var S=function(h){return false;};
+return Decode(T,S);
+}
+function URIEncode(H){
+var U=function(h){
+if(isAlphaNumeric(h))return true;
+if(h==33)return true;
+if(35<=h&&h<=36)return true;
+if(38<=h&&h<=47)return true;
+if(58<=h&&h<=59)return true;
+if(h==61)return true;
+if(63<=h&&h<=64)return true;
+if(h==95)return true;
+if(h==126)return true;
+return false;
+};
+return Encode(H,U);
+}
+function URIEncodeComponent(T){
+var U=function(h){
+if(isAlphaNumeric(h))return true;
+if(h==33)return true;
+if(39<=h&&h<=42)return true;
+if(45<=h&&h<=46)return true;
+if(h==95)return true;
+if(h==126)return true;
+return false;
+};
+return Encode(T,U);
+}
+b.InstallFunctions(a,2,[
+"escape",URIEscapeJS,
+"unescape",URIUnescapeJS,
+"decodeURI",URIDecode,
+"decodeURIComponent",URIDecodeComponent,
+"encodeURI",URIEncode,
+"encodeURIComponent",URIEncodeComponent
+]);
+})
+
+mathQ,
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Float64Array;
+var d=a.Math;
+var e=a.Object;
+var f=b.InternalArray;
+var g=%GetRootNaN();
+var h=0;
+var i=(void 0);
+var j=b.ImportNow("to_string_tag_symbol");
+function MathAbs(k){
+k=+k;
+return(k>0)?k:0-k;
+}
+function MathAtan2JS(l,k){
+l=+l;
+k=+k;
+return %MathAtan2(l,k);
+}
+function MathExp(k){
+return %MathExpRT((%_ToNumber(k)));
+}
+function MathLog(k){
+return %_MathLogRT((%_ToNumber(k)));
+}
+function MathPowJS(k,l){
+return %_MathPow((%_ToNumber(k)),(%_ToNumber(l)));
+}
+function MathRandom(){
+if(h<=2){
+i=%GenerateRandomNumbers(i);
+h=i.length;
+}
+return i[--h];
+}
+function MathRandomRaw(){
+if(h<=2){
+i=%GenerateRandomNumbers(i);
+h=i.length;
+}
+return %_DoubleLo(i[--h])&0x3FFFFFFF;
+}
+function MathSign(k){
+k=+k;
+if(k>0)return 1;
+if(k<0)return-1;
+return k;
+}
+function MathAsinh(k){
+k=(%_ToNumber(k));
+if(k===0||!(%_IsSmi(%IS_VAR(k))||((k==k)&&(k!=1/0)&&(k!=-1/0))))return k;
+if(k>0)return MathLog(k+%math_sqrt(k*k+1));
+return-MathLog(-k+%math_sqrt(k*k+1));
+}
+function MathAcosh(k){
+k=(%_ToNumber(k));
+if(k<1)return g;
+if(!(%_IsSmi(%IS_VAR(k))||((k==k)&&(k!=1/0)&&(k!=-1/0))))return k;
+return MathLog(k+%math_sqrt(k+1)*%math_sqrt(k-1));
+}
+function MathAtanh(k){
+k=(%_ToNumber(k));
+if(k===0)return k;
+if(!(%_IsSmi(%IS_VAR(k))||((k==k)&&(k!=1/0)&&(k!=-1/0))))return g;
+return 0.5*MathLog((1+k)/(1-k));
+}
+function MathHypot(k,l){
+var m=arguments.length;
+var n=0;
+for(var o=0;o<m;o++){
+var p=MathAbs(arguments[o]);
+if(p>n)n=p;
+arguments[o]=p;
+}
+if(n===(1/0))return(1/0);
+if(n===0)n=1;
+var q=0;
+var r=0;
+for(var o=0;o<m;o++){
+var p=arguments[o]/n;
+var s=p*p-r;
+var t=q+s;
+r=(t-q)-s;
+q=t;
+}
+return %math_sqrt(q)*n;
+}
+function MathCbrt(k){
+k=(%_ToNumber(k));
+if(k==0||!(%_IsSmi(%IS_VAR(k))||((k==k)&&(k!=1/0)&&(k!=-1/0))))return k;
+return k>=0?CubeRoot(k):-CubeRoot(-k);
+}
+function CubeRoot(k){
+var u=%math_floor(%_DoubleHi(k)/3)+0x2A9F7893;
+var v=%_ConstructDouble(u|0,0);
+v=(1.0/3.0)*(k/(v*v)+2*v);
+;
+v=(1.0/3.0)*(k/(v*v)+2*v);
+;
+v=(1.0/3.0)*(k/(v*v)+2*v);
+;
+return(1.0/3.0)*(k/(v*v)+2*v);
+;
+}
+%InstallToContext([
+"math_pow",MathPowJS,
+]);
+%AddNamedProperty(d,j,"Math",1|2);
+b.InstallConstants(d,[
+"E",2.7182818284590452354,
+"LN10",2.302585092994046,
+"LN2",0.6931471805599453,
+"LOG2E",1.4426950408889634,
+"LOG10E",0.4342944819032518,
+"PI",3.1415926535897932,
+"SQRT1_2",0.7071067811865476,
+"SQRT2",1.4142135623730951
+]);
+b.InstallFunctions(d,2,[
+"random",MathRandom,
+"abs",MathAbs,
+"exp",MathExp,
+"log",MathLog,
+"atan2",MathAtan2JS,
+"pow",MathPowJS,
+"sign",MathSign,
+"asinh",MathAsinh,
+"acosh",MathAcosh,
+"atanh",MathAtanh,
+"hypot",MathHypot,
+"cbrt",MathCbrt
+]);
+%SetForceInlineFlag(MathAbs);
+%SetForceInlineFlag(MathAtan2JS);
+%SetForceInlineFlag(MathRandom);
+%SetForceInlineFlag(MathSign);
+b.Export(function(w){
+w.MathAbs=MathAbs;
+w.MathExp=MathExp;
+w.IntRandom=MathRandomRaw;
+});
+})
+
+fdlibm��
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Float64Array;
+var d=a.Math;
+var e;
+var f;
+var g=%GetRootNaN();
+var h;
+b.Import(function(i){
+e=i.MathAbs;
+f=i.MathExp;
+});
+b.CreateDoubleResultArray=function(a){
+h=new c(2);
+};
+function KernelTan(j,k,l){
+var m;
+var n;
+var o=%_DoubleHi(j);
+var p=o&0x7fffffff;
+if(p<0x3e300000){
+if(((p|%_DoubleLo(j))|(l+1))==0){
+return 1/e(j);
+}else{
+if(l==1){
+return j;
+}else{
+var n=j+k;
+var m=%_ConstructDouble(%_DoubleHi(n),0);
+var q=k-(m-j);
+var r=-1/n;
+var s=%_ConstructDouble(%_DoubleHi(r),0);
+var t=1+s*m;
+return s+r*(t+s*q);
+}
+}
+}
+if(p>=0x3fe59428){
+if(j<0){
+j=-j;
+k=-k;
+}
+m=7.85398163397448278999e-01-j;
+n=3.06161699786838301793e-17-k;
+j=m+n;
+k=0;
+}
+m=j*j;
+n=m*m;
+var u=1.33333333333201242699e-01+n*(2.18694882948595424599e-02+n*(3.59207910759131235356e-03+
+n*(5.88041240820264096874e-04+n*(7.81794442939557092300e-05+n*-1.85586374855275456654e-05))));
+var q=m*(5.39682539762260521377e-02+n*(8.86323982359930005737e-03+n*(1.45620945432529025516e-03+
+n*(2.46463134818469906812e-04+n*(7.14072491382608190305e-05+n*2.59073051863633712884e-05)))));
+var t=m*j;
+u=k+m*(t*(u+q)+k);
+u=u+3.33333333333334091986e-01*t;
+n=j+u;
+if(p>=0x3fe59428){
+return(1-((o>>30)&2))*
+(l-2.0*(j-(n*n/(n+l)-u)));
+}
+if(l==1){
+return n;
+}else{
+m=%_ConstructDouble(%_DoubleHi(n),0);
+q=u-(m-j);
+var r=-1/n;
+var s=%_ConstructDouble(%_DoubleHi(r),0);
+t=1+s*m;
+return s+r*(t+s*q);
+}
+}
+function MathSinSlow(j){
+var v,w,x;
+var o=%_DoubleHi(j);
+var p=o&0x7fffffff;
+if(p<0x4002d97c){
+if(o>0){
+var m=j-1.57079632673412561417;
+if(p!=0x3ff921fb){
+w=m-6.07710050650619224932e-11;
+x=(m-w)-6.07710050650619224932e-11;
+}else{
+m-=6.07710050630396597660e-11;
+w=m-2.02226624879595063154e-21;
+x=(m-w)-2.02226624879595063154e-21;
+}
+v=1;
+}else{
+var m=j+1.57079632673412561417;
+if(p!=0x3ff921fb){
+w=m+6.07710050650619224932e-11;
+x=(m-w)+6.07710050650619224932e-11;
+}else{
+m+=6.07710050630396597660e-11;
+w=m+2.02226624879595063154e-21;
+x=(m-w)+2.02226624879595063154e-21;
+}
+v=-1;
+}
+}else if(p<=0x413921fb){
+var s=e(j);
+v=(s*6.36619772367581382433e-01+0.5)|0;
+var u=s-v*1.57079632673412561417;
+var n=v*6.07710050650619224932e-11;
+w=u-n;
+if(p-(%_DoubleHi(w)&0x7ff00000)>0x1000000){
+s=u;
+n=v*6.07710050630396597660e-11;
+u=s-n;
+n=v*2.02226624879595063154e-21-((s-u)-n);
+w=u-n;
+if(p-(%_DoubleHi(w)&0x7ff00000)>0x3100000){
+s=u;
+n=v*2.02226624871116645580e-21;
+u=s-n;
+n=v*8.47842766036889956997e-32-((s-u)-n);
+w=u-n;
+}
+}
+x=(u-w)-n;
+if(o<0){
+v=-v;
+w=-w;
+x=-x;
+}
+}else{
+v=%RemPiO2(j,h);
+w=h[0];
+x=h[1];
+}
+;
+var y=1-(v&2);
+if(v&1){
+var p=%_DoubleHi(w)&0x7fffffff;
+var m=w*w;
+var u=m*(4.16666666666666019037e-02+m*(-1.38888888888741095749e-03+m*(2.48015872894767294178e-05+m*(-2.75573143513906633035e-07+m*(2.08757232129817482790e-09+m*-1.13596475577881948265e-11)))));
+if(p<0x3fd33333){
+return(1-(0.5*m-(m*u-w*x)))*y;
+}else{
+var z;
+if(p>0x3fe90000){
+z=0.28125;
+}else{
+z=%_ConstructDouble(%_DoubleHi(0.25*w),0);
+}
+var A=0.5*m-z;
+return(1-z-(A-(m*u-w*x)))*y;
+}
+;
+}else{
+var m=w*w;
+var q=m*w;
+var u=8.33333333332248946124e-03+m*(-1.98412698298579493134e-04+m*(2.75573137070700676789e-06+m*(-2.50507602534068634195e-08+m*1.58969099521155010221e-10)));
+return(w-((m*(0.5*x-q*u)-x)-q*-1.66666666666666324348e-01))*y;
+;
+}
+}
+function MathCosSlow(j){
+var v,w,x;
+var o=%_DoubleHi(j);
+var p=o&0x7fffffff;
+if(p<0x4002d97c){
+if(o>0){
+var m=j-1.57079632673412561417;
+if(p!=0x3ff921fb){
+w=m-6.07710050650619224932e-11;
+x=(m-w)-6.07710050650619224932e-11;
+}else{
+m-=6.07710050630396597660e-11;
+w=m-2.02226624879595063154e-21;
+x=(m-w)-2.02226624879595063154e-21;
+}
+v=1;
+}else{
+var m=j+1.57079632673412561417;
+if(p!=0x3ff921fb){
+w=m+6.07710050650619224932e-11;
+x=(m-w)+6.07710050650619224932e-11;
+}else{
+m+=6.07710050630396597660e-11;
+w=m+2.02226624879595063154e-21;
+x=(m-w)+2.02226624879595063154e-21;
+}
+v=-1;
+}
+}else if(p<=0x413921fb){
+var s=e(j);
+v=(s*6.36619772367581382433e-01+0.5)|0;
+var u=s-v*1.57079632673412561417;
+var n=v*6.07710050650619224932e-11;
+w=u-n;
+if(p-(%_DoubleHi(w)&0x7ff00000)>0x1000000){
+s=u;
+n=v*6.07710050630396597660e-11;
+u=s-n;
+n=v*2.02226624879595063154e-21-((s-u)-n);
+w=u-n;
+if(p-(%_DoubleHi(w)&0x7ff00000)>0x3100000){
+s=u;
+n=v*2.02226624871116645580e-21;
+u=s-n;
+n=v*8.47842766036889956997e-32-((s-u)-n);
+w=u-n;
+}
+}
+x=(u-w)-n;
+if(o<0){
+v=-v;
+w=-w;
+x=-x;
+}
+}else{
+v=%RemPiO2(j,h);
+w=h[0];
+x=h[1];
+}
+;
+if(v&1){
+var y=(v&2)-1;
+var m=w*w;
+var q=m*w;
+var u=8.33333333332248946124e-03+m*(-1.98412698298579493134e-04+m*(2.75573137070700676789e-06+m*(-2.50507602534068634195e-08+m*1.58969099521155010221e-10)));
+return(w-((m*(0.5*x-q*u)-x)-q*-1.66666666666666324348e-01))*y;
+;
+}else{
+var y=1-(v&2);
+var p=%_DoubleHi(w)&0x7fffffff;
+var m=w*w;
+var u=m*(4.16666666666666019037e-02+m*(-1.38888888888741095749e-03+m*(2.48015872894767294178e-05+m*(-2.75573143513906633035e-07+m*(2.08757232129817482790e-09+m*-1.13596475577881948265e-11)))));
+if(p<0x3fd33333){
+return(1-(0.5*m-(m*u-w*x)))*y;
+}else{
+var z;
+if(p>0x3fe90000){
+z=0.28125;
+}else{
+z=%_ConstructDouble(%_DoubleHi(0.25*w),0);
+}
+var A=0.5*m-z;
+return(1-z-(A-(m*u-w*x)))*y;
+}
+;
+}
+}
+function MathSin(j){
+j=+j;
+if((%_DoubleHi(j)&0x7fffffff)<=0x3fe921fb){
+var m=j*j;
+var q=m*j;
+var u=8.33333333332248946124e-03+m*(-1.98412698298579493134e-04+m*(2.75573137070700676789e-06+m*(-2.50507602534068634195e-08+m*1.58969099521155010221e-10)));
+return(j-((m*(0.5*0-q*u)-0)-q*-1.66666666666666324348e-01));
+;
+}
+return+MathSinSlow(j);
+}
+function MathCos(j){
+j=+j;
+if((%_DoubleHi(j)&0x7fffffff)<=0x3fe921fb){
+var p=%_DoubleHi(j)&0x7fffffff;
+var m=j*j;
+var u=m*(4.16666666666666019037e-02+m*(-1.38888888888741095749e-03+m*(2.48015872894767294178e-05+m*(-2.75573143513906633035e-07+m*(2.08757232129817482790e-09+m*-1.13596475577881948265e-11)))));
+if(p<0x3fd33333){
+return(1-(0.5*m-(m*u-j*0)));
+}else{
+var z;
+if(p>0x3fe90000){
+z=0.28125;
+}else{
+z=%_ConstructDouble(%_DoubleHi(0.25*j),0);
+}
+var A=0.5*m-z;
+return(1-z-(A-(m*u-j*0)));
+}
+;
+}
+return+MathCosSlow(j);
+}
+function MathTan(j){
+j=j*1;
+if((%_DoubleHi(j)&0x7fffffff)<=0x3fe921fb){
+return KernelTan(j,0,1);
+}
+var v,w,x;
+var o=%_DoubleHi(j);
+var p=o&0x7fffffff;
+if(p<0x4002d97c){
+if(o>0){
+var m=j-1.57079632673412561417;
+if(p!=0x3ff921fb){
+w=m-6.07710050650619224932e-11;
+x=(m-w)-6.07710050650619224932e-11;
+}else{
+m-=6.07710050630396597660e-11;
+w=m-2.02226624879595063154e-21;
+x=(m-w)-2.02226624879595063154e-21;
+}
+v=1;
+}else{
+var m=j+1.57079632673412561417;
+if(p!=0x3ff921fb){
+w=m+6.07710050650619224932e-11;
+x=(m-w)+6.07710050650619224932e-11;
+}else{
+m+=6.07710050630396597660e-11;
+w=m+2.02226624879595063154e-21;
+x=(m-w)+2.02226624879595063154e-21;
+}
+v=-1;
+}
+}else if(p<=0x413921fb){
+var s=e(j);
+v=(s*6.36619772367581382433e-01+0.5)|0;
+var u=s-v*1.57079632673412561417;
+var n=v*6.07710050650619224932e-11;
+w=u-n;
+if(p-(%_DoubleHi(w)&0x7ff00000)>0x1000000){
+s=u;
+n=v*6.07710050630396597660e-11;
+u=s-n;
+n=v*2.02226624879595063154e-21-((s-u)-n);
+w=u-n;
+if(p-(%_DoubleHi(w)&0x7ff00000)>0x3100000){
+s=u;
+n=v*2.02226624871116645580e-21;
+u=s-n;
+n=v*8.47842766036889956997e-32-((s-u)-n);
+w=u-n;
+}
+}
+x=(u-w)-n;
+if(o<0){
+v=-v;
+w=-w;
+x=-x;
+}
+}else{
+v=%RemPiO2(j,h);
+w=h[0];
+x=h[1];
+}
+;
+return KernelTan(w,x,(v&1)?-1:1);
+}
+function MathLog1p(j){
+j=j*1;
+var o=%_DoubleHi(j);
+var B=o&0x7fffffff;
+var C=1;
+var D=j;
+var E=1;
+var F=0;
+var G=j;
+if(o<0x3fda827a){
+if(B>=0x3ff00000){
+if(j===-1){
+return-(1/0);
+}else{
+return g;
+}
+}else if(B<0x3c900000){
+return j;
+}else if(B<0x3e200000){
+return j-j*j*0.5;
+}
+if((o>0)||(o<=-0x402D413D)){
+C=0;
+}
+}
+if(o>=0x7ff00000)return j;
+if(C!==0){
+if(o<0x43400000){
+G=1+j;
+E=%_DoubleHi(G);
+C=(E>>20)-1023;
+F=(C>0)?1-(G-j):j-(G-1);
+F=F/G;
+}else{
+E=%_DoubleHi(G);
+C=(E>>20)-1023;
+}
+E=E&0xfffff;
+if(E<0x6a09e){
+G=%_ConstructDouble(E|0x3ff00000,%_DoubleLo(G));
+}else{
+++C;
+G=%_ConstructDouble(E|0x3fe00000,%_DoubleLo(G));
+E=(0x00100000-E)>>2;
+}
+D=G-1;
+}
+var H=0.5*D*D;
+if(E===0){
+if(D===0){
+if(C===0){
+return 0.0;
+}else{
+return C*6.93147180369123816490e-01+(F+C*1.90821492927058770002e-10);
+}
+}
+var I=H*(1-6.666666666666666666e-01*D);
+if(C===0){
+return D-I;
+}else{
+return C*6.93147180369123816490e-01-((I-(C*1.90821492927058770002e-10+F))-D);
+}
+}
+var t=D/(2+D);
+var m=t*t;
+var I=m*(6.666666666666735130e-01+m*(3.999999999940941908e-01+m*(2.857142874366239149e-01+m*(2.222219843214978396e-01+
+m*(1.818357216161805012e-01+m*(1.531383769920937332e-01+m*1.479819860511658591e-01))))));
+if(C===0){
+return D-(H-t*(H+I));
+}else{
+return C*6.93147180369123816490e-01-((H-(t*(H+I)+(C*1.90821492927058770002e-10+F)))-D);
+}
+}
+function MathExpm1(j){
+j=j*1;
+var k;
+var J;
+var K;
+var C;
+var s;
+var F;
+var o=%_DoubleHi(j);
+var L=o&0x80000000;
+var k=(L===0)?j:-j;
+o&=0x7fffffff;
+if(o>=0x4043687a){
+if(o>=0x40862e42){
+if(o>=0x7ff00000){
+return(j===-(1/0))?-1:j;
+}
+if(j>7.09782712893383973096e+02)return(1/0);
+}
+if(L!=0)return-1;
+}
+if(o>0x3fd62e42){
+if(o<0x3ff0a2b2){
+if(L===0){
+J=j-6.93147180369123816490e-01;
+K=1.90821492927058770002e-10;
+C=1;
+}else{
+J=j+6.93147180369123816490e-01;
+K=-1.90821492927058770002e-10;
+C=-1;
+}
+}else{
+C=(1.44269504088896338700*j+((L===0)?0.5:-0.5))|0;
+s=C;
+J=j-s*6.93147180369123816490e-01;
+K=s*1.90821492927058770002e-10;
+}
+j=J-K;
+F=(J-j)-K;
+}else if(o<0x3c900000){
+return j;
+}else{
+C=0;
+}
+var M=0.5*j;
+var N=j*M;
+var O=1+N*(-3.33333333333331316428e-02+N*(1.58730158725481460165e-03+N*
+(-7.93650757867487942473e-05+N*(4.00821782732936239552e-06+N*-2.01099218183624371326e-07))));
+s=3-O*M;
+var P=N*((O-s)/(6-j*s));
+if(C===0){
+return j-(j*P-N);
+}else{
+P=(j*(P-F)-F);
+P-=N;
+if(C===-1)return 0.5*(j-P)-0.5;
+if(C===1){
+if(j<-0.25)return-2*(P-(j+0.5));
+return 1+2*(j-P);
+}
+if(C<=-2||C>56){
+k=1-(P-j);
+k=%_ConstructDouble(%_DoubleHi(k)+(C<<20),%_DoubleLo(k));
+return k-1;
+}
+if(C<20){
+s=%_ConstructDouble(0x3ff00000-(0x200000>>C),0);
+k=s-(P-j);
+k=%_ConstructDouble(%_DoubleHi(k)+(C<<20),%_DoubleLo(k));
+}else{
+s=%_ConstructDouble((0x3ff-C)<<20,0);
+k=j-(P+s);
+k+=1;
+k=%_ConstructDouble(%_DoubleHi(k)+(C<<20),%_DoubleLo(k));
+}
+}
+return k;
+}
+function MathSinh(j){
+j=j*1;
+var Q=(j<0)?-0.5:0.5;
+var B=e(j);
+if(B<22){
+if(B<3.725290298461914e-9)return j;
+var s=MathExpm1(B);
+if(B<1)return Q*(2*s-s*s/(s+1));
+return Q*(s+s/(s+1));
+}
+if(B<709.7822265625)return Q*f(B);
+if(B<=710.4758600739439){
+var n=f(0.5*B);
+var s=Q*n;
+return s*n;
+}
+return j*(1/0);
+}
+function MathCosh(j){
+j=j*1;
+var p=%_DoubleHi(j)&0x7fffffff;
+if(p<0x3fd62e43){
+var s=MathExpm1(e(j));
+var n=1+s;
+if(p<0x3c800000)return n;
+return 1+(s*s)/(n+n);
+}
+if(p<0x40360000){
+var s=f(e(j));
+return 0.5*s+0.5/s;
+}
+if(p<0x40862e42)return 0.5*f(e(j));
+if(e(j)<=710.4758600739439){
+var n=f(0.5*e(j));
+var s=0.5*n;
+return s*n;
+}
+if((!%_IsSmi(%IS_VAR(j))&&!(j==j)))return j;
+return(1/0);
+}
+function MathTanh(j){
+j=j*1;
+if(!(%_IsSmi(%IS_VAR(j))||((j==j)&&(j!=1/0)&&(j!=-1/0)))){
+if(j>0)return 1;
+if(j<0)return-1;
+return j;
+}
+var B=e(j);
+var m;
+if(B<22){
+if(B<2.77555756156289135105e-17){
+return j;
+}
+if(B>=1){
+var s=MathExpm1(2*B);
+m=1-2/(s+2);
+}else{
+var s=MathExpm1(-2*B);
+m=-s/(s+2);
+}
+}else{
+m=1;
+}
+return(j>=0)?m:-m;
+}
+function MathLog10(j){
+j=j*1;
+var o=%_DoubleHi(j);
+var R=%_DoubleLo(j);
+var C=0;
+if(o<0x00100000){
+if(((o&0x7fffffff)|R)===0)return-(1/0);
+if(o<0)return g;
+C-=54;
+j*=18014398509481984;
+o=%_DoubleHi(j);
+R=%_DoubleLo(j);
+}
+if(o>=0x7ff00000)return j;
+C+=(o>>20)-1023;
+var S=(C&0x80000000)>>>31;
+o=(o&0x000fffff)|((0x3ff-S)<<20);
+var k=C+S;
+j=%_ConstructDouble(o,R);
+var m=k*3.69423907715893078616e-13+4.34294481903251816668e-01*%_MathLogRT(j);
+return m+k*3.01029995663611771306e-01;
+}
+function MathLog2(j){
+j=j*1;
+var B=e(j);
+var o=%_DoubleHi(j);
+var R=%_DoubleLo(j);
+var p=o&0x7fffffff;
+if((p|R)==0)return-(1/0);
+if(o<0)return g;
+if(p>=0x7ff00000)return j;
+var v=0;
+if(p<0x00100000){
+B*=9007199254740992;
+v-=53;
+p=%_DoubleHi(B);
+}
+v+=(p>>20)-0x3ff;
+var T=p&0x000fffff;
+p=T|0x3ff00000;
+var U=1;
+var V=0;
+var W=0;
+if(T>0x3988e){
+if(T<0xbb67a){
+U=1.5;
+V=5.84962487220764160156e-01;
+W=1.35003920212974897128e-08;
+}else{
+v+=1;
+p-=0x00100000;
+}
+}
+B=%_ConstructDouble(p,%_DoubleLo(B));
+var G=B-U;
+var q=1/(B+U);
+var X=G*q;
+var Y=%_ConstructDouble(%_DoubleHi(X),0);
+var Z=%_ConstructDouble(%_DoubleHi(B+U),0)
+var aa=B-(Z-U);
+var ab=q*((G-Y*Z)-Y*aa);
+var ac=X*X;
+var u=ac*ac*(5.99999999999994648725e-01+ac*(4.28571428578550184252e-01+ac*(3.33333329818377432918e-01+ac*(
+2.72728123808534006489e-01+ac*(2.30660745775561754067e-01+ac*2.06975017800338417784e-01)))));
+u+=ab*(Y+X);
+ac=Y*Y;
+Z=%_ConstructDouble(%_DoubleHi(3.0+ac+u),0);
+aa=u-((Z-3.0)-ac);
+G=Y*Z;
+q=ab*Z+aa*X;
+var ad=%_ConstructDouble(%_DoubleHi(G+q),0);
+var ae=q-(ad-G);
+var af=9.61796700954437255859e-01*ad;
+var ag=-7.02846165095275826516e-09*ad+ae*9.61796693925975554329e-01+W;
+var s=v;
+var ah=%_ConstructDouble(%_DoubleHi(((af+ag)+V)+s),0);
+var ai=ag-(((ah-s)-V)-af);
+return ah+ai;
+}
+b.InstallFunctions(d,2,[
+"cos",MathCos,
+"sin",MathSin,
+"tan",MathTan,
+"sinh",MathSinh,
+"cosh",MathCosh,
+"tanh",MathTanh,
+"log10",MathLog10,
+"log2",MathLog2,
+"log1p",MathLog1p,
+"expm1",MathExpm1
+]);
+%SetForceInlineFlag(MathSin);
+%SetForceInlineFlag(MathCos);
+})
+
+regexp

+(function(a,b){
+'use strict';
+%CheckIsBootstrapping();
+var c;
+var d;
+var e=a.Array;
+var f=a.Object;
+var g=a.RegExp;
+var h;
+var i=b.InternalArray;
+var j=b.InternalPackedArray;
+var k;
+var l;
+var m;
+var n=b.ImportNow("match_symbol");
+var o=b.ImportNow("replace_symbol");
+var p=b.ImportNow("search_symbol");
+var q=b.ImportNow("split_symbol");
+var r;
+b.Import(function(s){
+c=s.AddIndexedProperty;
+d=s.ExpandReplacement;
+k=s.MakeTypeError;
+l=s.MaxSimple;
+m=s.MinSimple;
+r=s.SpeciesConstructor;
+});
+var t=new j(
+2,
+"",
+(void 0),
+0,
+0
+);
+function IsRegExp(u){
+if(!(%_IsJSReceiver(u)))return false;
+var v=u[n];
+if(!(v===(void 0)))return(!!(v));
+return(%_IsRegExp(u));
+}
+function RegExpInitialize(w,x,y){
+x=(x===(void 0))?'':(%_ToString(x));
+y=(y===(void 0))?'':(%_ToString(y));
+%RegExpInitializeAndCompile(w,x,y);
+return w;
+}
+function PatternFlags(x){
+return((%_RegExpFlags(x)&1)?'g':'')+
+((%_RegExpFlags(x)&2)?'i':'')+
+((%_RegExpFlags(x)&4)?'m':'')+
+((%_RegExpFlags(x)&16)?'u':'')+
+((%_RegExpFlags(x)&8)?'y':'');
+}
+function RegExpConstructor(x,y){
+var z=new.target;
+var A=IsRegExp(x);
+if((z===(void 0))){
+z=g;
+if(A&&(y===(void 0))&&
+x.constructor===z){
+return x;
+}
+}
+if((%_IsRegExp(x))){
+if((y===(void 0)))y=PatternFlags(x);
+x=(%_RegExpSource(x));
+}else if(A){
+var B=x;
+x=x.source;
+if((y===(void 0)))y=B.flags;
+}
+var w=%_NewObject(g,z);
+return RegExpInitialize(w,x,y);
+}
+function RegExpCompileJS(x,y){
+if(!(%_IsRegExp(this))){
+throw k(44,
+"RegExp.prototype.compile",this);
+}
+if((%_IsRegExp(x))){
+if(!(y===(void 0)))throw k(132);
+y=PatternFlags(x);
+x=(%_RegExpSource(x));
+}
+RegExpInitialize(this,x,y);
+}
+function DoRegExpExec(C,D,E){
+return %_RegExpExec(C,D,E,t);
+}
+function RegExpExecNoTests(C,D,F){
+var G=%_RegExpExec(C,D,F,t);
+if(G!==null){
+if((%_RegExpFlags(C)&8))C.lastIndex=G[4];
+var H=((G)[0])>>1;
+var F=G[3];
+var I=G[4];
+var J=%_SubString(D,F,I);
+var K=%_RegExpConstructResult(H,F,D);
+K[0]=J;
+if(H==1)return K;
+var L=3+2;
+for(var M=1;M<H;M++){
+F=G[L++];
+if(F!=-1){
+I=G[L];
+K[M]=%_SubString(D,F,I);
+}
+L++;
+}
+return K;
+;
+}
+C.lastIndex=0;
+return null;
+}
+function RegExpSubclassExecJS(D){
+if(!(%_IsRegExp(this))){
+throw k(44,
+'RegExp.prototype.exec',this);
+}
+D=(%_ToString(D));
+var N=this.lastIndex;
+var M=(%_ToLength(N));
+var a=(!!((%_RegExpFlags(this)&1)));
+var O=(!!((%_RegExpFlags(this)&8)));
+var P=a||O;
+if(P){
+if(M>D.length){
+this.lastIndex=0;
+return null;
+}
+}else{
+M=0;
+}
+var Q=%_RegExpExec(this,D,M,t);
+if((Q===null)){
+this.lastIndex=0;
+return null;
+}
+if(P){
+this.lastIndex=t[4];
+}
+var H=((Q)[0])>>1;
+var F=Q[3];
+var I=Q[4];
+var J=%_SubString(D,F,I);
+var K=%_RegExpConstructResult(H,F,D);
+K[0]=J;
+if(H==1)return K;
+var L=3+2;
+for(var M=1;M<H;M++){
+F=Q[L++];
+if(F!=-1){
+I=Q[L];
+K[M]=%_SubString(D,F,I);
+}
+L++;
+}
+return K;
+;
+}
+%FunctionRemovePrototype(RegExpSubclassExecJS);
+function RegExpExecJS(D){
+if(!(%_IsRegExp(this))){
+throw k(44,
+'RegExp.prototype.exec',this);
+}
+D=(%_ToString(D));
+var N=this.lastIndex;
+var M=(%_ToLength(N));
+var P=(%_RegExpFlags(this)&1)||(%_RegExpFlags(this)&8);
+if(P){
+if(M<0||M>D.length){
+this.lastIndex=0;
+return null;
+}
+}else{
+M=0;
+}
+var Q=%_RegExpExec(this,D,M,t);
+if((Q===null)){
+this.lastIndex=0;
+return null;
+}
+if(P){
+this.lastIndex=t[4];
+}
+var H=((Q)[0])>>1;
+var F=Q[3];
+var I=Q[4];
+var J=%_SubString(D,F,I);
+var K=%_RegExpConstructResult(H,F,D);
+K[0]=J;
+if(H==1)return K;
+var L=3+2;
+for(var M=1;M<H;M++){
+F=Q[L++];
+if(F!=-1){
+I=Q[L];
+K[M]=%_SubString(D,F,I);
+}
+L++;
+}
+return K;
+;
+}
+function RegExpSubclassExec(C,D,R){
+if((R===(void 0))){
+R=C.exec;
+}
+if((typeof(R)==='function')){
+var K=%_Call(R,C,D);
+if(!(%_IsJSReceiver(K))&&!(K===null)){
+throw k(49);
+}
+return K;
+}
+return %_Call(RegExpExecJS,C,D);
+}
+%SetForceInlineFlag(RegExpSubclassExec);
+var S;
+var T;
+function RegExpTest(D){
+if(!(%_IsRegExp(this))){
+throw k(44,
+'RegExp.prototype.test',this);
+}
+D=(%_ToString(D));
+var N=this.lastIndex;
+var M=(%_ToLength(N));
+if((%_RegExpFlags(this)&1)||(%_RegExpFlags(this)&8)){
+if(M<0||M>D.length){
+this.lastIndex=0;
+return false;
+}
+var Q=%_RegExpExec(this,D,M,t);
+if((Q===null)){
+this.lastIndex=0;
+return false;
+}
+this.lastIndex=t[4];
+return true;
+}else{
+var C=this;
+var U=(%_RegExpSource(C));
+if(C.length>=3&&
+%_StringCharCodeAt(C,0)==46&&
+%_StringCharCodeAt(C,1)==42&&
+%_StringCharCodeAt(C,2)!=63){
+C=TrimRegExp(C);
+}
+var Q=%_RegExpExec(C,D,0,t);
+if((Q===null)){
+this.lastIndex=0;
+return false;
+}
+return true;
+}
+}
+function RegExpSubclassTest(D){
+if(!(%_IsJSReceiver(this))){
+throw k(44,
+'RegExp.prototype.test',this);
+}
+D=(%_ToString(D));
+var V=RegExpSubclassExec(this,D);
+return!(V===null);
+}
+%FunctionRemovePrototype(RegExpSubclassTest);
+function TrimRegExp(C){
+if(S!==C){
+S=C;
+T=
+new g(
+%_SubString((%_RegExpSource(C)),2,(%_RegExpSource(C)).length),
+((%_RegExpFlags(C)&2)?(%_RegExpFlags(C)&4)?"im":"i"
+:(%_RegExpFlags(C)&4)?"m":""));
+}
+return T;
+}
+function RegExpToString(){
+if(!(%_IsJSReceiver(this))){
+throw k(
+44,'RegExp.prototype.toString',this);
+}
+if(this===h){
+%IncrementUseCounter(12);
+}
+return'/'+(%_ToString(this.source))+'/'+(%_ToString(this.flags));
+}
+function AtSurrogatePair(W,E){
+if(E+1>=W.length)return false;
+var J=%_StringCharCodeAt(W,E);
+if(J<0xD800||J>0xDBFF)return false;
+var X=%_StringCharCodeAt(W,E+1);
+return X>=0xDC00||X<=0xDFFF;
+}
+function RegExpSplit(D,Y){
+if(!(%_IsRegExp(this))){
+throw k(44,
+"RegExp.prototype.@@split",this);
+}
+var Z=this;
+var W=(%_ToString(D));
+Y=((Y===(void 0)))?4294967295:((Y)>>>0);
+var aa=W.length;
+if(Y===0)return[];
+if(aa===0){
+if(DoRegExpExec(Z,W,0,0)!==null)return[];
+return[W];
+}
+var ab=0;
+var ac=0;
+var ad=0;
+var K=new i();
+outer_loop:
+while(true){
+if(ac===aa){
+K[K.length]=%_SubString(W,ab,aa);
+break;
+}
+var G=DoRegExpExec(Z,W,ac);
+if(G===null||aa===(ad=G[3])){
+K[K.length]=%_SubString(W,ab,aa);
+break;
+}
+var ae=G[4];
+if(ac===ae&&ae===ab){
+if((%_RegExpFlags(this)&16)&&AtSurrogatePair(W,ac)){
+ac+=2;
+}else{
+ac++;
+}
+continue;
+}
+K[K.length]=%_SubString(W,ab,ad);
+if(K.length===Y)break;
+var af=((G)[0])+3;
+for(var M=3+2;M<af;){
+var F=G[M++];
+var I=G[M++];
+if(I!=-1){
+K[K.length]=%_SubString(W,F,I);
+}else{
+K[K.length]=(void 0);
+}
+if(K.length===Y)break outer_loop;
+}
+ac=ab=ae;
+}
+var ag=[];
+%MoveArrayContents(K,ag);
+return ag;
+}
+function RegExpSubclassSplit(D,Y){
+if(!(%_IsJSReceiver(this))){
+throw k(44,
+"RegExp.prototype.@@split",this);
+}
+D=(%_ToString(D));
+var ah=r(this,g);
+var y=(%_ToString(this.flags));
+var R;
+if((%_IsRegExp(this))&&ah===g){
+R=this.exec;
+if(R===RegExpSubclassExecJS){
+return %_Call(RegExpSplit,this,D,Y);
+}
+}
+var ai=%StringIndexOf(y,'u',0)>=0;
+var O=%StringIndexOf(y,'y',0)>=0;
+var aj=O?y:y+"y";
+var ak=new ah(this,aj);
+var al=new e();
+var am=0;
+var an=((Y===(void 0)))?4294967295:((Y)>>>0);
+var ao=D.length;
+var ap=0;
+if(an===0)return al;
+var K;
+if(ao===0){
+K=RegExpSubclassExec(ak,D);
+if((K===null))c(al,0,D);
+return al;
+}
+var aq=ap;
+while(aq<ao){
+ak.lastIndex=aq;
+K=RegExpSubclassExec(ak,D,R);
+R=(void 0);
+if((K===null)){
+aq+=AdvanceStringIndex(D,aq,ai);
+}else{
+var I=m((%_ToLength(ak.lastIndex)),ao);
+if(I===aq){
+aq+=AdvanceStringIndex(D,aq,ai);
+}else{
+c(
+al,am,
+%_SubString(D,ap,aq));
+am++;
+if(am===an)return al;
+ap=I;
+var ar=l((%_ToLength(K.length)),0);
+for(var M=1;M<ar;M++){
+c(al,am,K[M]);
+am++;
+if(am===an)return al;
+}
+aq=ap;
+}
+}
+}
+c(al,am,
+%_SubString(D,ap,ao));
+return al;
+}
+%FunctionRemovePrototype(RegExpSubclassSplit);
+function RegExpMatch(D){
+if(!(%_IsRegExp(this))){
+throw k(44,
+"RegExp.prototype.@@match",this);
+}
+var W=(%_ToString(D));
+if(!(%_RegExpFlags(this)&1))return RegExpExecNoTests(this,W,0);
+this.lastIndex=0;
+var K=%StringMatch(W,this,t);
+return K;
+}
+function RegExpSubclassMatch(D){
+if(!(%_IsJSReceiver(this))){
+throw k(44,
+"RegExp.prototype.@@match",this);
+}
+D=(%_ToString(D));
+var a=this.global;
+if(!a)return RegExpSubclassExec(this,D);
+var ai=this.unicode;
+this.lastIndex=0;
+var al=new i();
+var as=0;
+var K;
+while(true){
+K=RegExpSubclassExec(this,D);
+if((K===null)){
+if(as===0)return null;
+break;
+}
+var at=(%_ToString(K[0]));
+al[as]=at;
+if(at==="")SetAdvancedStringIndex(this,D,ai);
+as++;
+}
+var au=[];
+%MoveArrayContents(al,au);
+return au;
+}
+%FunctionRemovePrototype(RegExpSubclassMatch);
+var av=new i(4);
+function StringReplaceGlobalRegExpWithFunction(W,C,aw){
+var au=av;
+if(au){
+av=null;
+}else{
+au=new i(16);
+}
+var ax=%RegExpExecMultiple(C,
+W,
+t,
+au);
+C.lastIndex=0;
+if((ax===null)){
+av=au;
+return W;
+}
+var ay=ax.length;
+if(((t)[0])==2){
+var az=0;
+for(var M=0;M<ay;M++){
+var aA=ax[M];
+if(%_IsSmi(aA)){
+if(aA>0){
+az=(aA>>11)+(aA&0x7ff);
+}else{
+az=ax[++M]-aA;
+}
+}else{
+var aB=aw(aA,az,W);
+ax[M]=(%_ToString(aB));
+az+=aA.length;
+}
+}
+}else{
+for(var M=0;M<ay;M++){
+var aA=ax[M];
+if(!%_IsSmi(aA)){
+var aB=%reflect_apply(aw,(void 0),aA);
+ax[M]=(%_ToString(aB));
+}
+}
+}
+var K=%StringBuilderConcat(ax,ay,W);
+au.length=0;
+av=au;
+return K;
+}
+function CaptureString(D,aC,E){
+var aD=E<<1;
+var F=aC[(3+(aD))];
+if(F<0)return;
+var I=aC[(3+(aD+1))];
+return %_SubString(D,F,I);
+}
+function StringReplaceNonGlobalRegExpWithFunction(W,C,aw){
+var G=DoRegExpExec(C,W,0);
+if((G===null)){
+C.lastIndex=0;
+return W;
+}
+var E=G[3];
+var K=%_SubString(W,0,E);
+var aE=G[4];
+var aF=((G)[0])>>1;
+var aG;
+if(aF==1){
+var aH=%_SubString(W,E,aE);
+aG=aw(aH,E,W);
+}else{
+var aI=new i(aF+2);
+for(var L=0;L<aF;L++){
+aI[L]=CaptureString(W,G,L);
+}
+aI[L]=E;
+aI[L+1]=W;
+aG=%reflect_apply(aw,(void 0),aI);
+}
+K+=aG;
+return K+%_SubString(W,aE,W.length);
+}
+function RegExpReplace(D,aw){
+if(!(%_IsRegExp(this))){
+throw k(44,
+"RegExp.prototype.@@replace",this);
+}
+var W=(%_ToString(D));
+var aJ=this;
+if(!(typeof(aw)==='function')){
+aw=(%_ToString(aw));
+if(!(%_RegExpFlags(aJ)&1)){
+var V=DoRegExpExec(aJ,W,0);
+if(V==null){
+aJ.lastIndex=0
+return W;
+}
+if(aw.length==0){
+return %_SubString(W,0,V[3])+
+%_SubString(W,V[4],W.length)
+}
+return d(aw,W,t,
+%_SubString(W,0,V[3]))+
+%_SubString(W,V[4],W.length);
+}
+aJ.lastIndex=0;
+return %StringReplaceGlobalRegExpWithString(
+W,aJ,aw,t);
+}
+if((%_RegExpFlags(aJ)&1)){
+return StringReplaceGlobalRegExpWithFunction(W,aJ,aw);
+}
+return StringReplaceNonGlobalRegExpWithFunction(W,aJ,aw);
+}
+function GetSubstitution(aK,D,aL,aM,aG){
+var aN=aK.length;
+var aO=D.length;
+var aP=aM.length;
+var aQ=aL+aN;
+var K="";
+var aR,aS,aT,aU,aV,aW,aX;
+var aU=%StringIndexOf(aG,'$',0);
+if(aU<0){
+K+=aG;
+return K;
+}
+if(aU>0)K+=%_SubString(aG,0,aU);
+while(true){
+aS='$';
+aR=aU+1;
+if(aR<aG.length){
+aT=%_StringCharCodeAt(aG,aR);
+if(aT==36){
+++aR;
+K+='$';
+}else if(aT==38){
+++aR;
+K+=aK;
+}else if(aT==96){
+++aR;
+K+=%_SubString(D,0,aL);
+}else if(aT==39){
+++aR;
+K+=%_SubString(D,aQ,aO);
+}else if(aT>=48&&aT<=57){
+aV=(aT-48);
+aW=1;
+if(aR+1<aG.length){
+aU=%_StringCharCodeAt(aG,aR+1);
+if(aU>=48&&aU<=57){
+aX=aV*10+((aU-48));
+if(aX<aP){
+aV=aX;
+aW=2;
+}
+}
+}
+if(aV!=0&&aV<aP){
+var aY=aM[aV];
+if(!(aY===(void 0)))K+=aY;
+aR+=aW;
+}else{
+K+='$';
+}
+}else{
+K+='$';
+}
+}else{
+K+='$';
+}
+aU=%StringIndexOf(aG,'$',aR);
+if(aU<0){
+if(aR<aG.length){
+K+=%_SubString(aG,aR,aG.length);
+}
+return K;
+}
+if(aU>aR){
+K+=%_SubString(aG,aR,aU);
+}
+}
+return K;
+}
+function AdvanceStringIndex(D,E,ai){
+var aZ=1;
+if(ai){
+var J=%_StringCharCodeAt(D,E);
+if(J>=0xD800&&J<=0xDBFF&&D.length>E+1){
+var X=%_StringCharCodeAt(D,E+1);
+if(X>=0xDC00&&X<=0xDFFF){
+aZ=2;
+}
+}
+}
+return aZ;
+}
+function SetAdvancedStringIndex(C,D,ai){
+var N=C.lastIndex;
+C.lastIndex=N+
+AdvanceStringIndex(D,N,ai);
+}
+function RegExpSubclassReplace(D,aw){
+if(!(%_IsJSReceiver(this))){
+throw k(44,
+"RegExp.prototype.@@replace",this);
+}
+D=(%_ToString(D));
+var aa=D.length;
+var ba=(typeof(aw)==='function');
+if(!ba)aw=(%_ToString(aw));
+var a=(!!(this.global));
+if(a){
+var ai=(!!(this.unicode));
+this.lastIndex=0;
+}
+var R;
+if((%_IsRegExp(this))){
+R=this.exec;
+if(R===RegExpSubclassExecJS){
+return %_Call(RegExpReplace,this,D,aw);
+}
+}
+var bb=new i();
+var K,aG;
+while(true){
+K=RegExpSubclassExec(this,D,R);
+R=(void 0);
+if((K===null)){
+break;
+}else{
+bb.push(K);
+if(!a)break;
+var at=(%_ToString(K[0]));
+if(at==="")SetAdvancedStringIndex(this,D,ai);
+}
+}
+var bc="";
+var bd=0;
+for(var M=0;M<bb.length;M++){
+K=bb[M];
+var aP=l((%_ToLength(K.length)),0);
+var aK=(%_ToString(K[0]));
+var be=aK.length;
+var aL=l(m((%_ToInteger(K.index)),aa),0);
+var aM=new i();
+for(var as=0;as<aP;as++){
+var aY=K[as];
+if(!(aY===(void 0)))aY=(%_ToString(aY));
+aM[as]=aY;
+}
+if(ba){
+var aI=new i(aP+2);
+for(var L=0;L<aP;L++){
+aI[L]=aM[L];
+}
+aI[L]=aL;
+aI[L+1]=D;
+aG=%reflect_apply(aw,(void 0),aI,0,
+aI.length);
+}else{
+aG=GetSubstitution(aK,D,aL,aM,
+aw);
+}
+if(aL>=bd){
+bc+=
+%_SubString(D,bd,aL)+aG;
+bd=aL+be;
+}
+}
+if(bd>=aa)return bc;
+return bc+%_SubString(D,bd,aa);
+}
+%FunctionRemovePrototype(RegExpSubclassReplace);
+function RegExpSearch(D){
+if(!(%_IsRegExp(this))){
+throw k(44,
+"RegExp.prototype.@@search",this);
+}
+var V=DoRegExpExec(this,(%_ToString(D)),0);
+if(V)return V[3];
+return-1;
+}
+function RegExpSubclassSearch(D){
+if(!(%_IsJSReceiver(this))){
+throw k(44,
+"RegExp.prototype.@@search",this);
+}
+D=(%_ToString(D));
+var bf=this.lastIndex;
+this.lastIndex=0;
+var K=RegExpSubclassExec(this,D);
+this.lastIndex=bf;
+if((K===null))return-1;
+return K.index;
+}
+%FunctionRemovePrototype(RegExpSubclassSearch);
+function RegExpGetLastMatch(){
+var bg=((t)[1]);
+return %_SubString(bg,
+t[3],
+t[4]);
+}
+function RegExpGetLastParen(){
+var aa=((t)[0]);
+if(aa<=2)return'';
+var bg=((t)[1]);
+var F=t[(3+(aa-2))];
+var I=t[(3+(aa-1))];
+if(F!=-1&&I!=-1){
+return %_SubString(bg,F,I);
+}
+return"";
+}
+function RegExpGetLeftContext(){
+var bh;
+var W;
+bh=t[3];
+W=((t)[1]);
+return %_SubString(W,0,bh);
+}
+function RegExpGetRightContext(){
+var bh;
+var W;
+bh=t[4];
+W=((t)[1]);
+return %_SubString(W,bh,W.length);
+}
+function RegExpMakeCaptureGetter(as){
+return function foo(){
+var E=as*2;
+if(E>=((t)[0]))return'';
+var bi=t[(3+(E))];
+var bj=t[(3+(E+1))];
+if(bi==-1||bj==-1)return'';
+return %_SubString(((t)[1]),bi,bj);
+};
+}
+function RegExpGetFlags(){
+if(!(%_IsJSReceiver(this))){
+throw k(
+133,"RegExp.prototype.flags",(%_ToString(this)));
+}
+var K='';
+if(this.global)K+='g';
+if(this.ignoreCase)K+='i';
+if(this.multiline)K+='m';
+if(this.unicode)K+='u';
+if(this.sticky)K+='y';
+return K;
+}
+function RegExpGetGlobal(){
+if(!(%_IsRegExp(this))){
+if(this===h){
+%IncrementUseCounter(31);
+return(void 0);
+}
+throw k(134,"RegExp.prototype.global");
+}
+return(!!((%_RegExpFlags(this)&1)));
+}
+%SetForceInlineFlag(RegExpGetGlobal);
+function RegExpGetIgnoreCase(){
+if(!(%_IsRegExp(this))){
+if(this===h){
+%IncrementUseCounter(31);
+return(void 0);
+}
+throw k(134,"RegExp.prototype.ignoreCase");
+}
+return(!!((%_RegExpFlags(this)&2)));
+}
+function RegExpGetMultiline(){
+if(!(%_IsRegExp(this))){
+if(this===h){
+%IncrementUseCounter(31);
+return(void 0);
+}
+throw k(134,"RegExp.prototype.multiline");
+}
+return(!!((%_RegExpFlags(this)&4)));
+}
+function RegExpGetSource(){
+if(!(%_IsRegExp(this))){
+if(this===h){
+%IncrementUseCounter(30);
+return"(?:)";
+}
+throw k(134,"RegExp.prototype.source");
+}
+return(%_RegExpSource(this));
+}
+function RegExpGetSticky(){
+if(!(%_IsRegExp(this))){
+if(this===h){
+%IncrementUseCounter(11);
+return(void 0);
+}
+throw k(134,"RegExp.prototype.sticky");
+}
+return(!!((%_RegExpFlags(this)&8)));
+}
+%SetForceInlineFlag(RegExpGetSticky);
+%FunctionSetInstanceClassName(g,'RegExp');
+h=new f();
+%FunctionSetPrototype(g,h);
+%AddNamedProperty(
+g.prototype,'constructor',g,2);
+%SetCode(g,RegExpConstructor);
+b.InstallFunctions(g.prototype,2,[
+"exec",RegExpExecJS,
+"test",RegExpTest,
+"toString",RegExpToString,
+"compile",RegExpCompileJS,
+n,RegExpMatch,
+o,RegExpReplace,
+p,RegExpSearch,
+q,RegExpSplit,
+]);
+b.InstallGetter(g.prototype,'flags',RegExpGetFlags);
+b.InstallGetter(g.prototype,'global',RegExpGetGlobal);
+b.InstallGetter(g.prototype,'ignoreCase',RegExpGetIgnoreCase);
+b.InstallGetter(g.prototype,'multiline',RegExpGetMultiline);
+b.InstallGetter(g.prototype,'source',RegExpGetSource);
+b.InstallGetter(g.prototype,'sticky',RegExpGetSticky);
+var bk=function(){
+var bl=((t)[2]);
+return(bl===(void 0))?"":bl;
+};
+var bm=function(D){
+((t)[2])=(%_ToString(D));
+};
+%OptimizeObjectForAddingMultipleProperties(g,22);
+b.InstallGetterSetter(g,'input',bk,bm,
+4);
+b.InstallGetterSetter(g,'$_',bk,bm,
+2|4);
+var bn=function(bo){};
+b.InstallGetterSetter(g,'lastMatch',RegExpGetLastMatch,
+bn,4);
+b.InstallGetterSetter(g,'$&',RegExpGetLastMatch,bn,
+2|4);
+b.InstallGetterSetter(g,'lastParen',RegExpGetLastParen,
+bn,4);
+b.InstallGetterSetter(g,'$+',RegExpGetLastParen,bn,
+2|4);
+b.InstallGetterSetter(g,'leftContext',RegExpGetLeftContext,
+bn,4);
+b.InstallGetterSetter(g,'$`',RegExpGetLeftContext,bn,
+2|4);
+b.InstallGetterSetter(g,'rightContext',RegExpGetRightContext,
+bn,4);
+b.InstallGetterSetter(g,"$'",RegExpGetRightContext,bn,
+2|4);
+for(var M=1;M<10;++M){
+b.InstallGetterSetter(g,'$'+M,RegExpMakeCaptureGetter(M),
+bn,4);
+}
+%ToFastProperties(g);
+var bp=new j(2,"",(void 0),0,0);
+function InternalRegExpMatch(C,W){
+var G=%_RegExpExec(C,W,0,bp);
+if(!(G===null)){
+var H=((G)[0])>>1;
+var F=G[3];
+var I=G[4];
+var J=%_SubString(W,F,I);
+var K=%_RegExpConstructResult(H,F,W);
+K[0]=J;
+if(H==1)return K;
+var L=3+2;
+for(var M=1;M<H;M++){
+F=G[L++];
+if(F!=-1){
+I=G[L];
+K[M]=%_SubString(W,F,I);
+}
+L++;
+}
+return K;
+;
+}
+return null;
+}
+function InternalRegExpReplace(C,W,aG){
+return %StringReplaceGlobalRegExpWithString(
+W,C,aG,bp);
+}
+b.Export(function(bq){
+bq.InternalRegExpMatch=InternalRegExpMatch;
+bq.InternalRegExpReplace=InternalRegExpReplace;
+bq.IsRegExp=IsRegExp;
+bq.RegExpExec=DoRegExpExec;
+bq.RegExpInitialize=RegExpInitialize;
+bq.RegExpLastMatchInfo=t;
+bq.RegExpSubclassExecJS=RegExpSubclassExecJS;
+bq.RegExpSubclassMatch=RegExpSubclassMatch;
+bq.RegExpSubclassReplace=RegExpSubclassReplace;
+bq.RegExpSubclassSearch=RegExpSubclassSearch;
+bq.RegExpSubclassSplit=RegExpSubclassSplit;
+bq.RegExpSubclassTest=RegExpSubclassTest;
+bq.RegExpTest=RegExpTest;
+});
+})
+
+,arraybuffer�
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.ArrayBuffer;
+var d;
+var e;
+var f;
+var g;
+b.Import(function(h){
+d=h.MakeTypeError;
+e=h.MaxSimple;
+f=h.MinSimple;
+g=h.SpeciesConstructor;
+});
+function ArrayBufferGetByteLen(){
+if(!(%_ClassOf(this)==='ArrayBuffer')){
+throw d(44,
+'ArrayBuffer.prototype.byteLength',this);
+}
+return %_ArrayBufferGetByteLength(this);
+}
+function ArrayBufferSlice(i,j){
+if(!(%_ClassOf(this)==='ArrayBuffer')){
+throw d(44,
+'ArrayBuffer.prototype.slice',this);
+}
+var k=(%_ToInteger(i));
+if(!(j===(void 0))){
+j=(%_ToInteger(j));
+}
+var l;
+var m=%_ArrayBufferGetByteLength(this);
+if(k<0){
+l=e(m+k,0);
+}else{
+l=f(k,m);
+}
+var n=(j===(void 0))?m:j;
+var o;
+if(n<0){
+o=e(m+n,0);
+}else{
+o=f(n,m);
+}
+if(o<l){
+o=l;
+}
+var p=o-l;
+var q=g(this,c,true);
+var r=new q(p);
+if(!(%_ClassOf(r)==='ArrayBuffer')){
+throw d(44,
+'ArrayBuffer.prototype.slice',r);
+}
+if(r===this){
+throw d(11);
+}
+if(%_ArrayBufferGetByteLength(r)<p){
+throw d(10);
+}
+%ArrayBufferSliceImpl(this,r,l,p);
+return r;
+}
+b.InstallGetter(c.prototype,"byteLength",
+ArrayBufferGetByteLen);
+b.InstallFunctions(c.prototype,2,[
+"slice",ArrayBufferSlice
+]);
+})
+
+(typedarrayf�
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c;
+var d=b.ImportNow("ArrayToString");
+var e;
+var f;
+var g;
+var h=a.Array;
+var i=a.ArrayBuffer;
+var j=i.prototype;
+var k=a.DataView;
+var l=a.Object;
+var m=b.InternalArray;
+var n;
+var o;
+var p;
+var q;
+var r;
+var s;
+var t;
+var u;
+var v;
+var w;
+var x;
+var y;
+var z;
+var A;
+var B;
+var C;
+var m=b.InternalArray;
+var D;
+var E;
+var F;
+var G;
+var H;
+var I;
+var J;
+var K;
+var L=b.ImportNow("iterator_symbol");
+var M=b.ImportNow("to_string_tag_symbol");
+var N=a.Uint8Array;
+
+var O=a.Int8Array;
+
+var P=a.Uint16Array;
+
+var Q=a.Int16Array;
+
+var R=a.Uint32Array;
+
+var S=a.Int32Array;
+
+var T=a.Float32Array;
+
+var U=a.Float64Array;
+
+var V=a.Uint8ClampedArray;
+
+
+b.Import(function(W){
+c=W.AddIndexedProperty;
+e=W.ArrayValues;
+f=W.GetIterator;
+g=W.GetMethod;
+n=W.InnerArrayCopyWithin;
+o=W.InnerArrayEvery;
+p=W.InnerArrayFill;
+q=W.InnerArrayFilter;
+r=W.InnerArrayFind;
+s=W.InnerArrayFindIndex;
+t=W.InnerArrayForEach;
+u=W.InnerArrayIncludes;
+v=W.InnerArrayIndexOf;
+w=W.InnerArrayJoin;
+x=W.InnerArrayLastIndexOf;
+y=W.InnerArrayReduce;
+z=W.InnerArrayReduceRight;
+A=W.InnerArraySome;
+B=W.InnerArraySort;
+C=W.InnerArrayToLocaleString;
+D=W.IsNaN;
+E=W.MakeRangeError;
+F=W.MakeTypeError;
+G=W.MaxSimple;
+H=W.MinSimple;
+I=W.PackedArrayReverse;
+J=W.SpeciesConstructor;
+K=W.ToPositiveInteger;
+});
+function TypedArrayDefaultConstructor(X){
+switch(%_ClassOf(X)){
+case"Uint8Array":
+return N;
+
+case"Int8Array":
+return O;
+
+case"Uint16Array":
+return P;
+
+case"Int16Array":
+return Q;
+
+case"Uint32Array":
+return R;
+
+case"Int32Array":
+return S;
+
+case"Float32Array":
+return T;
+
+case"Float64Array":
+return U;
+
+case"Uint8ClampedArray":
+return V;
+
+
+}
+throw F(44,
+"TypedArrayDefaultConstructor",this);
+}
+function TypedArrayCreate(Y,Z,aa,ab){
+if((aa===(void 0))){
+var ac=new Y(Z);
+}else{
+var ac=new Y(Z,aa,ab);
+}
+if(!(%_IsTypedArray(ac)))throw F(72);
+if((typeof(Z)==='number')&&%_TypedArrayGetLength(ac)<Z){
+throw F(253);
+}
+return ac;
+}
+function TypedArraySpeciesCreate(ad,Z,aa,ab,ae){
+var af=TypedArrayDefaultConstructor(ad);
+var Y=J(ad,af,
+ae);
+return TypedArrayCreate(Y,Z,aa,ab);
+}
+function Uint8ArrayConstructByArrayBuffer(ag,ah,ai,aj){
+if(!(ai===(void 0))){
+ai=K(ai,179);
+}
+if(!(aj===(void 0))){
+aj=K(aj,179);
+}
+var ak=%_ArrayBufferGetByteLength(ah);
+var al;
+if((ai===(void 0))){
+al=0;
+}else{
+al=ai;
+if(al % 1!==0){
+throw E(178,
+"start offset","Uint8Array",1);
+}
+if(al>ak){
+throw E(180);
+}
+}
+var am;
+var an;
+if((aj===(void 0))){
+if(ak % 1!==0){
+throw E(178,
+"byte length","Uint8Array",1);
+}
+am=ak-al;
+an=am/1;
+}else{
+var an=aj;
+am=an*1;
+}
+if((al+am>ak)
+||(an>%_MaxSmi())){
+throw E(179);
+}
+%_TypedArrayInitialize(ag,1,ah,al,am,true);
+}
+function Uint8ArrayConstructByLength(ag,aj){
+var ao=(aj===(void 0))?
+0:K(aj,179);
+if(ao>%_MaxSmi()){
+throw E(179);
+}
+var ap=ao*1;
+if(ap>%_TypedArrayMaxSizeInHeap()){
+var ah=new i(ap);
+%_TypedArrayInitialize(ag,1,ah,0,ap,true);
+}else{
+%_TypedArrayInitialize(ag,1,null,0,ap,true);
+}
+}
+function Uint8ArrayConstructByArrayLike(ag,aq,aj){
+var ao=K(aj,179);
+if(ao>%_MaxSmi()){
+throw E(179);
+}
+var ar=false;
+var ap=ao*1;
+if(ap<=%_TypedArrayMaxSizeInHeap()){
+%_TypedArrayInitialize(ag,1,null,0,ap,false);
+}else{
+ar=
+%TypedArrayInitializeFromArrayLike(ag,1,aq,ao);
+}
+if(!ar){
+for(var as=0;as<ao;as++){
+ag[as]=aq[as];
+}
+}
+}
+function Uint8ArrayConstructByIterable(ag,at,au){
+var av=new m();
+var aw=%_Call(au,at);
+var ax={
+__proto__:null
+};
+ax[L]=function(){return aw;}
+for(var ay of ax){
+av.push(ay);
+}
+Uint8ArrayConstructByArrayLike(ag,av,av.length);
+}
+function Uint8ArrayConstructByTypedArray(ag,X){
+var az=%TypedArrayGetBuffer(X);
+var aj=%_TypedArrayGetLength(X);
+var ap=%_ArrayBufferViewGetByteLength(X);
+var am=aj*1;
+Uint8ArrayConstructByArrayLike(ag,X,aj);
+var aA=J(az,i);
+var aB=aA.prototype;
+if((%_IsJSReceiver(aB))&&aB!==j){
+%InternalSetPrototype(%TypedArrayGetBuffer(ag),aB);
+}
+}
+function Uint8ArrayConstructor(aa,ab,aC){
+if(!(new.target===(void 0))){
+if((%_ClassOf(aa)==='ArrayBuffer')||(%_ClassOf(aa)==='SharedArrayBuffer')){
+Uint8ArrayConstructByArrayBuffer(this,aa,ab,aC);
+}else if((typeof(aa)==='number')||(typeof(aa)==='string')||
+(typeof(aa)==='boolean')||(aa===(void 0))){
+Uint8ArrayConstructByLength(this,aa);
+}else if((%_IsTypedArray(aa))){
+Uint8ArrayConstructByTypedArray(this,aa);
+}else{
+var au=aa[L];
+if((au===(void 0))||au===e){
+Uint8ArrayConstructByArrayLike(this,aa,aa.length);
+}else{
+Uint8ArrayConstructByIterable(this,aa,au);
+}
+}
+}else{
+throw F(28,"Uint8Array")
+}
+}
+function Uint8ArraySubArray(aD,aE){
+var aF=(%_ToInteger(aD));
+if(!(aE===(void 0))){
+var aG=(%_ToInteger(aE));
+var aH=%_TypedArrayGetLength(this);
+}else{
+var aH=%_TypedArrayGetLength(this);
+var aG=aH;
+}
+if(aF<0){
+aF=G(0,aH+aF);
+}else{
+aF=H(aF,aH);
+}
+if(aG<0){
+aG=G(0,aH+aG);
+}else{
+aG=H(aG,aH);
+}
+if(aG<aF){
+aG=aF;
+}
+var an=aG-aF;
+var aI=
+%_ArrayBufferViewGetByteOffset(this)+aF*1;
+return new N(%TypedArrayGetBuffer(this),aI,an);
+}
+
+function Int8ArrayConstructByArrayBuffer(ag,ah,ai,aj){
+if(!(ai===(void 0))){
+ai=K(ai,179);
+}
+if(!(aj===(void 0))){
+aj=K(aj,179);
+}
+var ak=%_ArrayBufferGetByteLength(ah);
+var al;
+if((ai===(void 0))){
+al=0;
+}else{
+al=ai;
+if(al % 1!==0){
+throw E(178,
+"start offset","Int8Array",1);
+}
+if(al>ak){
+throw E(180);
+}
+}
+var am;
+var an;
+if((aj===(void 0))){
+if(ak % 1!==0){
+throw E(178,
+"byte length","Int8Array",1);
+}
+am=ak-al;
+an=am/1;
+}else{
+var an=aj;
+am=an*1;
+}
+if((al+am>ak)
+||(an>%_MaxSmi())){
+throw E(179);
+}
+%_TypedArrayInitialize(ag,2,ah,al,am,true);
+}
+function Int8ArrayConstructByLength(ag,aj){
+var ao=(aj===(void 0))?
+0:K(aj,179);
+if(ao>%_MaxSmi()){
+throw E(179);
+}
+var ap=ao*1;
+if(ap>%_TypedArrayMaxSizeInHeap()){
+var ah=new i(ap);
+%_TypedArrayInitialize(ag,2,ah,0,ap,true);
+}else{
+%_TypedArrayInitialize(ag,2,null,0,ap,true);
+}
+}
+function Int8ArrayConstructByArrayLike(ag,aq,aj){
+var ao=K(aj,179);
+if(ao>%_MaxSmi()){
+throw E(179);
+}
+var ar=false;
+var ap=ao*1;
+if(ap<=%_TypedArrayMaxSizeInHeap()){
+%_TypedArrayInitialize(ag,2,null,0,ap,false);
+}else{
+ar=
+%TypedArrayInitializeFromArrayLike(ag,2,aq,ao);
+}
+if(!ar){
+for(var as=0;as<ao;as++){
+ag[as]=aq[as];
+}
+}
+}
+function Int8ArrayConstructByIterable(ag,at,au){
+var av=new m();
+var aw=%_Call(au,at);
+var ax={
+__proto__:null
+};
+ax[L]=function(){return aw;}
+for(var ay of ax){
+av.push(ay);
+}
+Int8ArrayConstructByArrayLike(ag,av,av.length);
+}
+function Int8ArrayConstructByTypedArray(ag,X){
+var az=%TypedArrayGetBuffer(X);
+var aj=%_TypedArrayGetLength(X);
+var ap=%_ArrayBufferViewGetByteLength(X);
+var am=aj*1;
+Int8ArrayConstructByArrayLike(ag,X,aj);
+var aA=J(az,i);
+var aB=aA.prototype;
+if((%_IsJSReceiver(aB))&&aB!==j){
+%InternalSetPrototype(%TypedArrayGetBuffer(ag),aB);
+}
+}
+function Int8ArrayConstructor(aa,ab,aC){
+if(!(new.target===(void 0))){
+if((%_ClassOf(aa)==='ArrayBuffer')||(%_ClassOf(aa)==='SharedArrayBuffer')){
+Int8ArrayConstructByArrayBuffer(this,aa,ab,aC);
+}else if((typeof(aa)==='number')||(typeof(aa)==='string')||
+(typeof(aa)==='boolean')||(aa===(void 0))){
+Int8ArrayConstructByLength(this,aa);
+}else if((%_IsTypedArray(aa))){
+Int8ArrayConstructByTypedArray(this,aa);
+}else{
+var au=aa[L];
+if((au===(void 0))||au===e){
+Int8ArrayConstructByArrayLike(this,aa,aa.length);
+}else{
+Int8ArrayConstructByIterable(this,aa,au);
+}
+}
+}else{
+throw F(28,"Int8Array")
+}
+}
+function Int8ArraySubArray(aD,aE){
+var aF=(%_ToInteger(aD));
+if(!(aE===(void 0))){
+var aG=(%_ToInteger(aE));
+var aH=%_TypedArrayGetLength(this);
+}else{
+var aH=%_TypedArrayGetLength(this);
+var aG=aH;
+}
+if(aF<0){
+aF=G(0,aH+aF);
+}else{
+aF=H(aF,aH);
+}
+if(aG<0){
+aG=G(0,aH+aG);
+}else{
+aG=H(aG,aH);
+}
+if(aG<aF){
+aG=aF;
+}
+var an=aG-aF;
+var aI=
+%_ArrayBufferViewGetByteOffset(this)+aF*1;
+return new O(%TypedArrayGetBuffer(this),aI,an);
+}
+
+function Uint16ArrayConstructByArrayBuffer(ag,ah,ai,aj){
+if(!(ai===(void 0))){
+ai=K(ai,179);
+}
+if(!(aj===(void 0))){
+aj=K(aj,179);
+}
+var ak=%_ArrayBufferGetByteLength(ah);
+var al;
+if((ai===(void 0))){
+al=0;
+}else{
+al=ai;
+if(al % 2!==0){
+throw E(178,
+"start offset","Uint16Array",2);
+}
+if(al>ak){
+throw E(180);
+}
+}
+var am;
+var an;
+if((aj===(void 0))){
+if(ak % 2!==0){
+throw E(178,
+"byte length","Uint16Array",2);
+}
+am=ak-al;
+an=am/2;
+}else{
+var an=aj;
+am=an*2;
+}
+if((al+am>ak)
+||(an>%_MaxSmi())){
+throw E(179);
+}
+%_TypedArrayInitialize(ag,3,ah,al,am,true);
+}
+function Uint16ArrayConstructByLength(ag,aj){
+var ao=(aj===(void 0))?
+0:K(aj,179);
+if(ao>%_MaxSmi()){
+throw E(179);
+}
+var ap=ao*2;
+if(ap>%_TypedArrayMaxSizeInHeap()){
+var ah=new i(ap);
+%_TypedArrayInitialize(ag,3,ah,0,ap,true);
+}else{
+%_TypedArrayInitialize(ag,3,null,0,ap,true);
+}
+}
+function Uint16ArrayConstructByArrayLike(ag,aq,aj){
+var ao=K(aj,179);
+if(ao>%_MaxSmi()){
+throw E(179);
+}
+var ar=false;
+var ap=ao*2;
+if(ap<=%_TypedArrayMaxSizeInHeap()){
+%_TypedArrayInitialize(ag,3,null,0,ap,false);
+}else{
+ar=
+%TypedArrayInitializeFromArrayLike(ag,3,aq,ao);
+}
+if(!ar){
+for(var as=0;as<ao;as++){
+ag[as]=aq[as];
+}
+}
+}
+function Uint16ArrayConstructByIterable(ag,at,au){
+var av=new m();
+var aw=%_Call(au,at);
+var ax={
+__proto__:null
+};
+ax[L]=function(){return aw;}
+for(var ay of ax){
+av.push(ay);
+}
+Uint16ArrayConstructByArrayLike(ag,av,av.length);
+}
+function Uint16ArrayConstructByTypedArray(ag,X){
+var az=%TypedArrayGetBuffer(X);
+var aj=%_TypedArrayGetLength(X);
+var ap=%_ArrayBufferViewGetByteLength(X);
+var am=aj*2;
+Uint16ArrayConstructByArrayLike(ag,X,aj);
+var aA=J(az,i);
+var aB=aA.prototype;
+if((%_IsJSReceiver(aB))&&aB!==j){
+%InternalSetPrototype(%TypedArrayGetBuffer(ag),aB);
+}
+}
+function Uint16ArrayConstructor(aa,ab,aC){
+if(!(new.target===(void 0))){
+if((%_ClassOf(aa)==='ArrayBuffer')||(%_ClassOf(aa)==='SharedArrayBuffer')){
+Uint16ArrayConstructByArrayBuffer(this,aa,ab,aC);
+}else if((typeof(aa)==='number')||(typeof(aa)==='string')||
+(typeof(aa)==='boolean')||(aa===(void 0))){
+Uint16ArrayConstructByLength(this,aa);
+}else if((%_IsTypedArray(aa))){
+Uint16ArrayConstructByTypedArray(this,aa);
+}else{
+var au=aa[L];
+if((au===(void 0))||au===e){
+Uint16ArrayConstructByArrayLike(this,aa,aa.length);
+}else{
+Uint16ArrayConstructByIterable(this,aa,au);
+}
+}
+}else{
+throw F(28,"Uint16Array")
+}
+}
+function Uint16ArraySubArray(aD,aE){
+var aF=(%_ToInteger(aD));
+if(!(aE===(void 0))){
+var aG=(%_ToInteger(aE));
+var aH=%_TypedArrayGetLength(this);
+}else{
+var aH=%_TypedArrayGetLength(this);
+var aG=aH;
+}
+if(aF<0){
+aF=G(0,aH+aF);
+}else{
+aF=H(aF,aH);
+}
+if(aG<0){
+aG=G(0,aH+aG);
+}else{
+aG=H(aG,aH);
+}
+if(aG<aF){
+aG=aF;
+}
+var an=aG-aF;
+var aI=
+%_ArrayBufferViewGetByteOffset(this)+aF*2;
+return new P(%TypedArrayGetBuffer(this),aI,an);
+}
+
+function Int16ArrayConstructByArrayBuffer(ag,ah,ai,aj){
+if(!(ai===(void 0))){
+ai=K(ai,179);
+}
+if(!(aj===(void 0))){
+aj=K(aj,179);
+}
+var ak=%_ArrayBufferGetByteLength(ah);
+var al;
+if((ai===(void 0))){
+al=0;
+}else{
+al=ai;
+if(al % 2!==0){
+throw E(178,
+"start offset","Int16Array",2);
+}
+if(al>ak){
+throw E(180);
+}
+}
+var am;
+var an;
+if((aj===(void 0))){
+if(ak % 2!==0){
+throw E(178,
+"byte length","Int16Array",2);
+}
+am=ak-al;
+an=am/2;
+}else{
+var an=aj;
+am=an*2;
+}
+if((al+am>ak)
+||(an>%_MaxSmi())){
+throw E(179);
+}
+%_TypedArrayInitialize(ag,4,ah,al,am,true);
+}
+function Int16ArrayConstructByLength(ag,aj){
+var ao=(aj===(void 0))?
+0:K(aj,179);
+if(ao>%_MaxSmi()){
+throw E(179);
+}
+var ap=ao*2;
+if(ap>%_TypedArrayMaxSizeInHeap()){
+var ah=new i(ap);
+%_TypedArrayInitialize(ag,4,ah,0,ap,true);
+}else{
+%_TypedArrayInitialize(ag,4,null,0,ap,true);
+}
+}
+function Int16ArrayConstructByArrayLike(ag,aq,aj){
+var ao=K(aj,179);
+if(ao>%_MaxSmi()){
+throw E(179);
+}
+var ar=false;
+var ap=ao*2;
+if(ap<=%_TypedArrayMaxSizeInHeap()){
+%_TypedArrayInitialize(ag,4,null,0,ap,false);
+}else{
+ar=
+%TypedArrayInitializeFromArrayLike(ag,4,aq,ao);
+}
+if(!ar){
+for(var as=0;as<ao;as++){
+ag[as]=aq[as];
+}
+}
+}
+function Int16ArrayConstructByIterable(ag,at,au){
+var av=new m();
+var aw=%_Call(au,at);
+var ax={
+__proto__:null
+};
+ax[L]=function(){return aw;}
+for(var ay of ax){
+av.push(ay);
+}
+Int16ArrayConstructByArrayLike(ag,av,av.length);
+}
+function Int16ArrayConstructByTypedArray(ag,X){
+var az=%TypedArrayGetBuffer(X);
+var aj=%_TypedArrayGetLength(X);
+var ap=%_ArrayBufferViewGetByteLength(X);
+var am=aj*2;
+Int16ArrayConstructByArrayLike(ag,X,aj);
+var aA=J(az,i);
+var aB=aA.prototype;
+if((%_IsJSReceiver(aB))&&aB!==j){
+%InternalSetPrototype(%TypedArrayGetBuffer(ag),aB);
+}
+}
+function Int16ArrayConstructor(aa,ab,aC){
+if(!(new.target===(void 0))){
+if((%_ClassOf(aa)==='ArrayBuffer')||(%_ClassOf(aa)==='SharedArrayBuffer')){
+Int16ArrayConstructByArrayBuffer(this,aa,ab,aC);
+}else if((typeof(aa)==='number')||(typeof(aa)==='string')||
+(typeof(aa)==='boolean')||(aa===(void 0))){
+Int16ArrayConstructByLength(this,aa);
+}else if((%_IsTypedArray(aa))){
+Int16ArrayConstructByTypedArray(this,aa);
+}else{
+var au=aa[L];
+if((au===(void 0))||au===e){
+Int16ArrayConstructByArrayLike(this,aa,aa.length);
+}else{
+Int16ArrayConstructByIterable(this,aa,au);
+}
+}
+}else{
+throw F(28,"Int16Array")
+}
+}
+function Int16ArraySubArray(aD,aE){
+var aF=(%_ToInteger(aD));
+if(!(aE===(void 0))){
+var aG=(%_ToInteger(aE));
+var aH=%_TypedArrayGetLength(this);
+}else{
+var aH=%_TypedArrayGetLength(this);
+var aG=aH;
+}
+if(aF<0){
+aF=G(0,aH+aF);
+}else{
+aF=H(aF,aH);
+}
+if(aG<0){
+aG=G(0,aH+aG);
+}else{
+aG=H(aG,aH);
+}
+if(aG<aF){
+aG=aF;
+}
+var an=aG-aF;
+var aI=
+%_ArrayBufferViewGetByteOffset(this)+aF*2;
+return new Q(%TypedArrayGetBuffer(this),aI,an);
+}
+
+function Uint32ArrayConstructByArrayBuffer(ag,ah,ai,aj){
+if(!(ai===(void 0))){
+ai=K(ai,179);
+}
+if(!(aj===(void 0))){
+aj=K(aj,179);
+}
+var ak=%_ArrayBufferGetByteLength(ah);
+var al;
+if((ai===(void 0))){
+al=0;
+}else{
+al=ai;
+if(al % 4!==0){
+throw E(178,
+"start offset","Uint32Array",4);
+}
+if(al>ak){
+throw E(180);
+}
+}
+var am;
+var an;
+if((aj===(void 0))){
+if(ak % 4!==0){
+throw E(178,
+"byte length","Uint32Array",4);
+}
+am=ak-al;
+an=am/4;
+}else{
+var an=aj;
+am=an*4;
+}
+if((al+am>ak)
+||(an>%_MaxSmi())){
+throw E(179);
+}
+%_TypedArrayInitialize(ag,5,ah,al,am,true);
+}
+function Uint32ArrayConstructByLength(ag,aj){
+var ao=(aj===(void 0))?
+0:K(aj,179);
+if(ao>%_MaxSmi()){
+throw E(179);
+}
+var ap=ao*4;
+if(ap>%_TypedArrayMaxSizeInHeap()){
+var ah=new i(ap);
+%_TypedArrayInitialize(ag,5,ah,0,ap,true);
+}else{
+%_TypedArrayInitialize(ag,5,null,0,ap,true);
+}
+}
+function Uint32ArrayConstructByArrayLike(ag,aq,aj){
+var ao=K(aj,179);
+if(ao>%_MaxSmi()){
+throw E(179);
+}
+var ar=false;
+var ap=ao*4;
+if(ap<=%_TypedArrayMaxSizeInHeap()){
+%_TypedArrayInitialize(ag,5,null,0,ap,false);
+}else{
+ar=
+%TypedArrayInitializeFromArrayLike(ag,5,aq,ao);
+}
+if(!ar){
+for(var as=0;as<ao;as++){
+ag[as]=aq[as];
+}
+}
+}
+function Uint32ArrayConstructByIterable(ag,at,au){
+var av=new m();
+var aw=%_Call(au,at);
+var ax={
+__proto__:null
+};
+ax[L]=function(){return aw;}
+for(var ay of ax){
+av.push(ay);
+}
+Uint32ArrayConstructByArrayLike(ag,av,av.length);
+}
+function Uint32ArrayConstructByTypedArray(ag,X){
+var az=%TypedArrayGetBuffer(X);
+var aj=%_TypedArrayGetLength(X);
+var ap=%_ArrayBufferViewGetByteLength(X);
+var am=aj*4;
+Uint32ArrayConstructByArrayLike(ag,X,aj);
+var aA=J(az,i);
+var aB=aA.prototype;
+if((%_IsJSReceiver(aB))&&aB!==j){
+%InternalSetPrototype(%TypedArrayGetBuffer(ag),aB);
+}
+}
+function Uint32ArrayConstructor(aa,ab,aC){
+if(!(new.target===(void 0))){
+if((%_ClassOf(aa)==='ArrayBuffer')||(%_ClassOf(aa)==='SharedArrayBuffer')){
+Uint32ArrayConstructByArrayBuffer(this,aa,ab,aC);
+}else if((typeof(aa)==='number')||(typeof(aa)==='string')||
+(typeof(aa)==='boolean')||(aa===(void 0))){
+Uint32ArrayConstructByLength(this,aa);
+}else if((%_IsTypedArray(aa))){
+Uint32ArrayConstructByTypedArray(this,aa);
+}else{
+var au=aa[L];
+if((au===(void 0))||au===e){
+Uint32ArrayConstructByArrayLike(this,aa,aa.length);
+}else{
+Uint32ArrayConstructByIterable(this,aa,au);
+}
+}
+}else{
+throw F(28,"Uint32Array")
+}
+}
+function Uint32ArraySubArray(aD,aE){
+var aF=(%_ToInteger(aD));
+if(!(aE===(void 0))){
+var aG=(%_ToInteger(aE));
+var aH=%_TypedArrayGetLength(this);
+}else{
+var aH=%_TypedArrayGetLength(this);
+var aG=aH;
+}
+if(aF<0){
+aF=G(0,aH+aF);
+}else{
+aF=H(aF,aH);
+}
+if(aG<0){
+aG=G(0,aH+aG);
+}else{
+aG=H(aG,aH);
+}
+if(aG<aF){
+aG=aF;
+}
+var an=aG-aF;
+var aI=
+%_ArrayBufferViewGetByteOffset(this)+aF*4;
+return new R(%TypedArrayGetBuffer(this),aI,an);
+}
+
+function Int32ArrayConstructByArrayBuffer(ag,ah,ai,aj){
+if(!(ai===(void 0))){
+ai=K(ai,179);
+}
+if(!(aj===(void 0))){
+aj=K(aj,179);
+}
+var ak=%_ArrayBufferGetByteLength(ah);
+var al;
+if((ai===(void 0))){
+al=0;
+}else{
+al=ai;
+if(al % 4!==0){
+throw E(178,
+"start offset","Int32Array",4);
+}
+if(al>ak){
+throw E(180);
+}
+}
+var am;
+var an;
+if((aj===(void 0))){
+if(ak % 4!==0){
+throw E(178,
+"byte length","Int32Array",4);
+}
+am=ak-al;
+an=am/4;
+}else{
+var an=aj;
+am=an*4;
+}
+if((al+am>ak)
+||(an>%_MaxSmi())){
+throw E(179);
+}
+%_TypedArrayInitialize(ag,6,ah,al,am,true);
+}
+function Int32ArrayConstructByLength(ag,aj){
+var ao=(aj===(void 0))?
+0:K(aj,179);
+if(ao>%_MaxSmi()){
+throw E(179);
+}
+var ap=ao*4;
+if(ap>%_TypedArrayMaxSizeInHeap()){
+var ah=new i(ap);
+%_TypedArrayInitialize(ag,6,ah,0,ap,true);
+}else{
+%_TypedArrayInitialize(ag,6,null,0,ap,true);
+}
+}
+function Int32ArrayConstructByArrayLike(ag,aq,aj){
+var ao=K(aj,179);
+if(ao>%_MaxSmi()){
+throw E(179);
+}
+var ar=false;
+var ap=ao*4;
+if(ap<=%_TypedArrayMaxSizeInHeap()){
+%_TypedArrayInitialize(ag,6,null,0,ap,false);
+}else{
+ar=
+%TypedArrayInitializeFromArrayLike(ag,6,aq,ao);
+}
+if(!ar){
+for(var as=0;as<ao;as++){
+ag[as]=aq[as];
+}
+}
+}
+function Int32ArrayConstructByIterable(ag,at,au){
+var av=new m();
+var aw=%_Call(au,at);
+var ax={
+__proto__:null
+};
+ax[L]=function(){return aw;}
+for(var ay of ax){
+av.push(ay);
+}
+Int32ArrayConstructByArrayLike(ag,av,av.length);
+}
+function Int32ArrayConstructByTypedArray(ag,X){
+var az=%TypedArrayGetBuffer(X);
+var aj=%_TypedArrayGetLength(X);
+var ap=%_ArrayBufferViewGetByteLength(X);
+var am=aj*4;
+Int32ArrayConstructByArrayLike(ag,X,aj);
+var aA=J(az,i);
+var aB=aA.prototype;
+if((%_IsJSReceiver(aB))&&aB!==j){
+%InternalSetPrototype(%TypedArrayGetBuffer(ag),aB);
+}
+}
+function Int32ArrayConstructor(aa,ab,aC){
+if(!(new.target===(void 0))){
+if((%_ClassOf(aa)==='ArrayBuffer')||(%_ClassOf(aa)==='SharedArrayBuffer')){
+Int32ArrayConstructByArrayBuffer(this,aa,ab,aC);
+}else if((typeof(aa)==='number')||(typeof(aa)==='string')||
+(typeof(aa)==='boolean')||(aa===(void 0))){
+Int32ArrayConstructByLength(this,aa);
+}else if((%_IsTypedArray(aa))){
+Int32ArrayConstructByTypedArray(this,aa);
+}else{
+var au=aa[L];
+if((au===(void 0))||au===e){
+Int32ArrayConstructByArrayLike(this,aa,aa.length);
+}else{
+Int32ArrayConstructByIterable(this,aa,au);
+}
+}
+}else{
+throw F(28,"Int32Array")
+}
+}
+function Int32ArraySubArray(aD,aE){
+var aF=(%_ToInteger(aD));
+if(!(aE===(void 0))){
+var aG=(%_ToInteger(aE));
+var aH=%_TypedArrayGetLength(this);
+}else{
+var aH=%_TypedArrayGetLength(this);
+var aG=aH;
+}
+if(aF<0){
+aF=G(0,aH+aF);
+}else{
+aF=H(aF,aH);
+}
+if(aG<0){
+aG=G(0,aH+aG);
+}else{
+aG=H(aG,aH);
+}
+if(aG<aF){
+aG=aF;
+}
+var an=aG-aF;
+var aI=
+%_ArrayBufferViewGetByteOffset(this)+aF*4;
+return new S(%TypedArrayGetBuffer(this),aI,an);
+}
+
+function Float32ArrayConstructByArrayBuffer(ag,ah,ai,aj){
+if(!(ai===(void 0))){
+ai=K(ai,179);
+}
+if(!(aj===(void 0))){
+aj=K(aj,179);
+}
+var ak=%_ArrayBufferGetByteLength(ah);
+var al;
+if((ai===(void 0))){
+al=0;
+}else{
+al=ai;
+if(al % 4!==0){
+throw E(178,
+"start offset","Float32Array",4);
+}
+if(al>ak){
+throw E(180);
+}
+}
+var am;
+var an;
+if((aj===(void 0))){
+if(ak % 4!==0){
+throw E(178,
+"byte length","Float32Array",4);
+}
+am=ak-al;
+an=am/4;
+}else{
+var an=aj;
+am=an*4;
+}
+if((al+am>ak)
+||(an>%_MaxSmi())){
+throw E(179);
+}
+%_TypedArrayInitialize(ag,7,ah,al,am,true);
+}
+function Float32ArrayConstructByLength(ag,aj){
+var ao=(aj===(void 0))?
+0:K(aj,179);
+if(ao>%_MaxSmi()){
+throw E(179);
+}
+var ap=ao*4;
+if(ap>%_TypedArrayMaxSizeInHeap()){
+var ah=new i(ap);
+%_TypedArrayInitialize(ag,7,ah,0,ap,true);
+}else{
+%_TypedArrayInitialize(ag,7,null,0,ap,true);
+}
+}
+function Float32ArrayConstructByArrayLike(ag,aq,aj){
+var ao=K(aj,179);
+if(ao>%_MaxSmi()){
+throw E(179);
+}
+var ar=false;
+var ap=ao*4;
+if(ap<=%_TypedArrayMaxSizeInHeap()){
+%_TypedArrayInitialize(ag,7,null,0,ap,false);
+}else{
+ar=
+%TypedArrayInitializeFromArrayLike(ag,7,aq,ao);
+}
+if(!ar){
+for(var as=0;as<ao;as++){
+ag[as]=aq[as];
+}
+}
+}
+function Float32ArrayConstructByIterable(ag,at,au){
+var av=new m();
+var aw=%_Call(au,at);
+var ax={
+__proto__:null
+};
+ax[L]=function(){return aw;}
+for(var ay of ax){
+av.push(ay);
+}
+Float32ArrayConstructByArrayLike(ag,av,av.length);
+}
+function Float32ArrayConstructByTypedArray(ag,X){
+var az=%TypedArrayGetBuffer(X);
+var aj=%_TypedArrayGetLength(X);
+var ap=%_ArrayBufferViewGetByteLength(X);
+var am=aj*4;
+Float32ArrayConstructByArrayLike(ag,X,aj);
+var aA=J(az,i);
+var aB=aA.prototype;
+if((%_IsJSReceiver(aB))&&aB!==j){
+%InternalSetPrototype(%TypedArrayGetBuffer(ag),aB);
+}
+}
+function Float32ArrayConstructor(aa,ab,aC){
+if(!(new.target===(void 0))){
+if((%_ClassOf(aa)==='ArrayBuffer')||(%_ClassOf(aa)==='SharedArrayBuffer')){
+Float32ArrayConstructByArrayBuffer(this,aa,ab,aC);
+}else if((typeof(aa)==='number')||(typeof(aa)==='string')||
+(typeof(aa)==='boolean')||(aa===(void 0))){
+Float32ArrayConstructByLength(this,aa);
+}else if((%_IsTypedArray(aa))){
+Float32ArrayConstructByTypedArray(this,aa);
+}else{
+var au=aa[L];
+if((au===(void 0))||au===e){
+Float32ArrayConstructByArrayLike(this,aa,aa.length);
+}else{
+Float32ArrayConstructByIterable(this,aa,au);
+}
+}
+}else{
+throw F(28,"Float32Array")
+}
+}
+function Float32ArraySubArray(aD,aE){
+var aF=(%_ToInteger(aD));
+if(!(aE===(void 0))){
+var aG=(%_ToInteger(aE));
+var aH=%_TypedArrayGetLength(this);
+}else{
+var aH=%_TypedArrayGetLength(this);
+var aG=aH;
+}
+if(aF<0){
+aF=G(0,aH+aF);
+}else{
+aF=H(aF,aH);
+}
+if(aG<0){
+aG=G(0,aH+aG);
+}else{
+aG=H(aG,aH);
+}
+if(aG<aF){
+aG=aF;
+}
+var an=aG-aF;
+var aI=
+%_ArrayBufferViewGetByteOffset(this)+aF*4;
+return new T(%TypedArrayGetBuffer(this),aI,an);
+}
+
+function Float64ArrayConstructByArrayBuffer(ag,ah,ai,aj){
+if(!(ai===(void 0))){
+ai=K(ai,179);
+}
+if(!(aj===(void 0))){
+aj=K(aj,179);
+}
+var ak=%_ArrayBufferGetByteLength(ah);
+var al;
+if((ai===(void 0))){
+al=0;
+}else{
+al=ai;
+if(al % 8!==0){
+throw E(178,
+"start offset","Float64Array",8);
+}
+if(al>ak){
+throw E(180);
+}
+}
+var am;
+var an;
+if((aj===(void 0))){
+if(ak % 8!==0){
+throw E(178,
+"byte length","Float64Array",8);
+}
+am=ak-al;
+an=am/8;
+}else{
+var an=aj;
+am=an*8;
+}
+if((al+am>ak)
+||(an>%_MaxSmi())){
+throw E(179);
+}
+%_TypedArrayInitialize(ag,8,ah,al,am,true);
+}
+function Float64ArrayConstructByLength(ag,aj){
+var ao=(aj===(void 0))?
+0:K(aj,179);
+if(ao>%_MaxSmi()){
+throw E(179);
+}
+var ap=ao*8;
+if(ap>%_TypedArrayMaxSizeInHeap()){
+var ah=new i(ap);
+%_TypedArrayInitialize(ag,8,ah,0,ap,true);
+}else{
+%_TypedArrayInitialize(ag,8,null,0,ap,true);
+}
+}
+function Float64ArrayConstructByArrayLike(ag,aq,aj){
+var ao=K(aj,179);
+if(ao>%_MaxSmi()){
+throw E(179);
+}
+var ar=false;
+var ap=ao*8;
+if(ap<=%_TypedArrayMaxSizeInHeap()){
+%_TypedArrayInitialize(ag,8,null,0,ap,false);
+}else{
+ar=
+%TypedArrayInitializeFromArrayLike(ag,8,aq,ao);
+}
+if(!ar){
+for(var as=0;as<ao;as++){
+ag[as]=aq[as];
+}
+}
+}
+function Float64ArrayConstructByIterable(ag,at,au){
+var av=new m();
+var aw=%_Call(au,at);
+var ax={
+__proto__:null
+};
+ax[L]=function(){return aw;}
+for(var ay of ax){
+av.push(ay);
+}
+Float64ArrayConstructByArrayLike(ag,av,av.length);
+}
+function Float64ArrayConstructByTypedArray(ag,X){
+var az=%TypedArrayGetBuffer(X);
+var aj=%_TypedArrayGetLength(X);
+var ap=%_ArrayBufferViewGetByteLength(X);
+var am=aj*8;
+Float64ArrayConstructByArrayLike(ag,X,aj);
+var aA=J(az,i);
+var aB=aA.prototype;
+if((%_IsJSReceiver(aB))&&aB!==j){
+%InternalSetPrototype(%TypedArrayGetBuffer(ag),aB);
+}
+}
+function Float64ArrayConstructor(aa,ab,aC){
+if(!(new.target===(void 0))){
+if((%_ClassOf(aa)==='ArrayBuffer')||(%_ClassOf(aa)==='SharedArrayBuffer')){
+Float64ArrayConstructByArrayBuffer(this,aa,ab,aC);
+}else if((typeof(aa)==='number')||(typeof(aa)==='string')||
+(typeof(aa)==='boolean')||(aa===(void 0))){
+Float64ArrayConstructByLength(this,aa);
+}else if((%_IsTypedArray(aa))){
+Float64ArrayConstructByTypedArray(this,aa);
+}else{
+var au=aa[L];
+if((au===(void 0))||au===e){
+Float64ArrayConstructByArrayLike(this,aa,aa.length);
+}else{
+Float64ArrayConstructByIterable(this,aa,au);
+}
+}
+}else{
+throw F(28,"Float64Array")
+}
+}
+function Float64ArraySubArray(aD,aE){
+var aF=(%_ToInteger(aD));
+if(!(aE===(void 0))){
+var aG=(%_ToInteger(aE));
+var aH=%_TypedArrayGetLength(this);
+}else{
+var aH=%_TypedArrayGetLength(this);
+var aG=aH;
+}
+if(aF<0){
+aF=G(0,aH+aF);
+}else{
+aF=H(aF,aH);
+}
+if(aG<0){
+aG=G(0,aH+aG);
+}else{
+aG=H(aG,aH);
+}
+if(aG<aF){
+aG=aF;
+}
+var an=aG-aF;
+var aI=
+%_ArrayBufferViewGetByteOffset(this)+aF*8;
+return new U(%TypedArrayGetBuffer(this),aI,an);
+}
+
+function Uint8ClampedArrayConstructByArrayBuffer(ag,ah,ai,aj){
+if(!(ai===(void 0))){
+ai=K(ai,179);
+}
+if(!(aj===(void 0))){
+aj=K(aj,179);
+}
+var ak=%_ArrayBufferGetByteLength(ah);
+var al;
+if((ai===(void 0))){
+al=0;
+}else{
+al=ai;
+if(al % 1!==0){
+throw E(178,
+"start offset","Uint8ClampedArray",1);
+}
+if(al>ak){
+throw E(180);
+}
+}
+var am;
+var an;
+if((aj===(void 0))){
+if(ak % 1!==0){
+throw E(178,
+"byte length","Uint8ClampedArray",1);
+}
+am=ak-al;
+an=am/1;
+}else{
+var an=aj;
+am=an*1;
+}
+if((al+am>ak)
+||(an>%_MaxSmi())){
+throw E(179);
+}
+%_TypedArrayInitialize(ag,9,ah,al,am,true);
+}
+function Uint8ClampedArrayConstructByLength(ag,aj){
+var ao=(aj===(void 0))?
+0:K(aj,179);
+if(ao>%_MaxSmi()){
+throw E(179);
+}
+var ap=ao*1;
+if(ap>%_TypedArrayMaxSizeInHeap()){
+var ah=new i(ap);
+%_TypedArrayInitialize(ag,9,ah,0,ap,true);
+}else{
+%_TypedArrayInitialize(ag,9,null,0,ap,true);
+}
+}
+function Uint8ClampedArrayConstructByArrayLike(ag,aq,aj){
+var ao=K(aj,179);
+if(ao>%_MaxSmi()){
+throw E(179);
+}
+var ar=false;
+var ap=ao*1;
+if(ap<=%_TypedArrayMaxSizeInHeap()){
+%_TypedArrayInitialize(ag,9,null,0,ap,false);
+}else{
+ar=
+%TypedArrayInitializeFromArrayLike(ag,9,aq,ao);
+}
+if(!ar){
+for(var as=0;as<ao;as++){
+ag[as]=aq[as];
+}
+}
+}
+function Uint8ClampedArrayConstructByIterable(ag,at,au){
+var av=new m();
+var aw=%_Call(au,at);
+var ax={
+__proto__:null
+};
+ax[L]=function(){return aw;}
+for(var ay of ax){
+av.push(ay);
+}
+Uint8ClampedArrayConstructByArrayLike(ag,av,av.length);
+}
+function Uint8ClampedArrayConstructByTypedArray(ag,X){
+var az=%TypedArrayGetBuffer(X);
+var aj=%_TypedArrayGetLength(X);
+var ap=%_ArrayBufferViewGetByteLength(X);
+var am=aj*1;
+Uint8ClampedArrayConstructByArrayLike(ag,X,aj);
+var aA=J(az,i);
+var aB=aA.prototype;
+if((%_IsJSReceiver(aB))&&aB!==j){
+%InternalSetPrototype(%TypedArrayGetBuffer(ag),aB);
+}
+}
+function Uint8ClampedArrayConstructor(aa,ab,aC){
+if(!(new.target===(void 0))){
+if((%_ClassOf(aa)==='ArrayBuffer')||(%_ClassOf(aa)==='SharedArrayBuffer')){
+Uint8ClampedArrayConstructByArrayBuffer(this,aa,ab,aC);
+}else if((typeof(aa)==='number')||(typeof(aa)==='string')||
+(typeof(aa)==='boolean')||(aa===(void 0))){
+Uint8ClampedArrayConstructByLength(this,aa);
+}else if((%_IsTypedArray(aa))){
+Uint8ClampedArrayConstructByTypedArray(this,aa);
+}else{
+var au=aa[L];
+if((au===(void 0))||au===e){
+Uint8ClampedArrayConstructByArrayLike(this,aa,aa.length);
+}else{
+Uint8ClampedArrayConstructByIterable(this,aa,au);
+}
+}
+}else{
+throw F(28,"Uint8ClampedArray")
+}
+}
+function Uint8ClampedArraySubArray(aD,aE){
+var aF=(%_ToInteger(aD));
+if(!(aE===(void 0))){
+var aG=(%_ToInteger(aE));
+var aH=%_TypedArrayGetLength(this);
+}else{
+var aH=%_TypedArrayGetLength(this);
+var aG=aH;
+}
+if(aF<0){
+aF=G(0,aH+aF);
+}else{
+aF=H(aF,aH);
+}
+if(aG<0){
+aG=G(0,aH+aG);
+}else{
+aG=H(aG,aH);
+}
+if(aG<aF){
+aG=aF;
+}
+var an=aG-aF;
+var aI=
+%_ArrayBufferViewGetByteOffset(this)+aF*1;
+return new V(%TypedArrayGetBuffer(this),aI,an);
+}
+
+
+function TypedArraySubArray(aD,aE){
+switch(%_ClassOf(this)){
+case"Uint8Array":
+return %_Call(Uint8ArraySubArray,this,aD,aE);
+
+case"Int8Array":
+return %_Call(Int8ArraySubArray,this,aD,aE);
+
+case"Uint16Array":
+return %_Call(Uint16ArraySubArray,this,aD,aE);
+
+case"Int16Array":
+return %_Call(Int16ArraySubArray,this,aD,aE);
+
+case"Uint32Array":
+return %_Call(Uint32ArraySubArray,this,aD,aE);
+
+case"Int32Array":
+return %_Call(Int32ArraySubArray,this,aD,aE);
+
+case"Float32Array":
+return %_Call(Float32ArraySubArray,this,aD,aE);
+
+case"Float64Array":
+return %_Call(Float64ArraySubArray,this,aD,aE);
+
+case"Uint8ClampedArray":
+return %_Call(Uint8ClampedArraySubArray,this,aD,aE);
+
+
+}
+throw F(44,
+"get TypedArray.prototype.subarray",this);
+}
+%SetForceInlineFlag(TypedArraySubArray);
+function TypedArrayGetBuffer(){
+if(!(%_IsTypedArray(this))){
+throw F(44,
+"get TypedArray.prototype.buffer",this);
+}
+return %TypedArrayGetBuffer(this);
+}
+%SetForceInlineFlag(TypedArrayGetBuffer);
+function TypedArrayGetByteLength(){
+if(!(%_IsTypedArray(this))){
+throw F(44,
+"get TypedArray.prototype.byteLength",this);
+}
+return %_ArrayBufferViewGetByteLength(this);
+}
+%SetForceInlineFlag(TypedArrayGetByteLength);
+function TypedArrayGetByteOffset(){
+if(!(%_IsTypedArray(this))){
+throw F(44,
+"get TypedArray.prototype.byteOffset",this);
+}
+return %_ArrayBufferViewGetByteOffset(this);
+}
+%SetForceInlineFlag(TypedArrayGetByteOffset);
+function TypedArrayGetLength(){
+if(!(%_IsTypedArray(this))){
+throw F(44,
+"get TypedArray.prototype.length",this);
+}
+return %_TypedArrayGetLength(this);
+}
+%SetForceInlineFlag(TypedArrayGetLength);
+function TypedArraySetFromArrayLike(aJ,aK,aL,al){
+if(al>0){
+for(var as=0;as<aL;as++){
+aJ[al+as]=aK[as];
+}
+}
+else{
+for(var as=0;as<aL;as++){
+aJ[as]=aK[as];
+}
+}
+}
+function TypedArraySetFromOverlappingTypedArray(aJ,aK,al){
+var aM=aK.BYTES_PER_ELEMENT;
+var aN=aJ.BYTES_PER_ELEMENT;
+var aL=aK.length;
+function CopyLeftPart(){
+var aO=aJ.byteOffset+(al+1)*aN;
+var aP=aK.byteOffset;
+for(var aQ=0;
+aQ<aL&&aO<=aP;
+aQ++){
+aJ[al+aQ]=aK[aQ];
+aO+=aN;
+aP+=aM;
+}
+return aQ;
+}
+var aQ=CopyLeftPart();
+function CopyRightPart(){
+var aO=
+aJ.byteOffset+(al+aL-1)*aN;
+var aP=
+aK.byteOffset+aL*aM;
+for(var aR=aL-1;
+aR>=aQ&&aO>=aP;
+aR--){
+aJ[al+aR]=aK[aR];
+aO-=aN;
+aP-=aM;
+}
+return aR;
+}
+var aR=CopyRightPart();
+var aS=new h(aR+1-aQ);
+for(var as=aQ;as<=aR;as++){
+aS[as-aQ]=aK[as];
+}
+for(as=aQ;as<=aR;as++){
+aJ[al+as]=aS[as-aQ];
+}
+}
+function TypedArraySet(ag,al){
+var aT=(al===(void 0))?0:(%_ToInteger(al));
+if(aT<0)throw F(189);
+if(aT>%_MaxSmi()){
+throw E(190);
+}
+switch(%TypedArraySetFastCases(this,ag,aT)){
+case 0:
+return;
+case 1:
+TypedArraySetFromOverlappingTypedArray(this,ag,aT);
+return;
+case 2:
+TypedArraySetFromArrayLike(this,ag,ag.length,aT);
+return;
+case 3:
+var ao=ag.length;
+if((ao===(void 0))){
+if((typeof(ag)==='number')){
+throw F(47);
+}
+return;
+}
+ao=(%_ToLength(ao));
+if(aT+ao>this.length){
+throw E(190);
+}
+TypedArraySetFromArrayLike(this,ag,ao,aT);
+return;
+}
+}
+%FunctionSetLength(TypedArraySet,1);
+function TypedArrayGetToStringTag(){
+if(!(%_IsTypedArray(this)))return;
+var aU=%_ClassOf(this);
+if((aU===(void 0)))return;
+return aU;
+}
+function TypedArrayCopyWithin(aJ,aV,aE){
+if(!(%_IsTypedArray(this)))throw F(72);
+var aj=%_TypedArrayGetLength(this);
+return n(aJ,aV,aE,this,aj);
+}
+%FunctionSetLength(TypedArrayCopyWithin,2);
+function TypedArrayEvery(aW,aX){
+if(!(%_IsTypedArray(this)))throw F(72);
+var aj=%_TypedArrayGetLength(this);
+return o(aW,aX,this,aj);
+}
+%FunctionSetLength(TypedArrayEvery,1);
+function TypedArrayForEach(aW,aX){
+if(!(%_IsTypedArray(this)))throw F(72);
+var aj=%_TypedArrayGetLength(this);
+t(aW,aX,this,aj);
+}
+%FunctionSetLength(TypedArrayForEach,1);
+function TypedArrayFill(ay,aV,aE){
+if(!(%_IsTypedArray(this)))throw F(72);
+var aj=%_TypedArrayGetLength(this);
+return p(ay,aV,aE,this,aj);
+}
+%FunctionSetLength(TypedArrayFill,1);
+function TypedArrayFilter(aW,aY){
+if(!(%_IsTypedArray(this)))throw F(72);
+var aj=%_TypedArrayGetLength(this);
+if(!(typeof(aW)==='function'))throw F(15,aW);
+var aZ=new m();
+q(aW,aY,this,aj,aZ);
+var ba=aZ.length;
+var bb=TypedArraySpeciesCreate(this,ba);
+for(var as=0;as<ba;as++){
+bb[as]=aZ[as];
+}
+return bb;
+}
+%FunctionSetLength(TypedArrayFilter,1);
+function TypedArrayFind(bc,aY){
+if(!(%_IsTypedArray(this)))throw F(72);
+var aj=%_TypedArrayGetLength(this);
+return r(bc,aY,this,aj);
+}
+%FunctionSetLength(TypedArrayFind,1);
+function TypedArrayFindIndex(bc,aY){
+if(!(%_IsTypedArray(this)))throw F(72);
+var aj=%_TypedArrayGetLength(this);
+return s(bc,aY,this,aj);
+}
+%FunctionSetLength(TypedArrayFindIndex,1);
+function TypedArrayReverse(){
+if(!(%_IsTypedArray(this)))throw F(72);
+var aj=%_TypedArrayGetLength(this);
+return I(this,aj);
+}
+function TypedArrayComparefn(bd,be){
+if(bd===0&&bd===be){
+bd=1/bd;
+be=1/be;
+}
+if(bd<be){
+return-1;
+}else if(bd>be){
+return 1;
+}else if(D(bd)&&D(be)){
+return D(be)?0:1;
+}else if(D(bd)){
+return 1;
+}
+return 0;
+}
+function TypedArraySort(bf){
+if(!(%_IsTypedArray(this)))throw F(72);
+var aj=%_TypedArrayGetLength(this);
+if((bf===(void 0))){
+bf=TypedArrayComparefn;
+}
+return B(this,aj,bf);
+}
+function TypedArrayIndexOf(bg,bh){
+if(!(%_IsTypedArray(this)))throw F(72);
+var aj=%_TypedArrayGetLength(this);
+return v(this,bg,bh,aj);
+}
+%FunctionSetLength(TypedArrayIndexOf,1);
+function TypedArrayLastIndexOf(bg,bh){
+if(!(%_IsTypedArray(this)))throw F(72);
+var aj=%_TypedArrayGetLength(this);
+return x(this,bg,bh,aj,
+arguments.length);
+}
+%FunctionSetLength(TypedArrayLastIndexOf,1);
+function TypedArrayMap(aW,aY){
+if(!(%_IsTypedArray(this)))throw F(72);
+var aj=%_TypedArrayGetLength(this);
+var aZ=TypedArraySpeciesCreate(this,aj);
+if(!(typeof(aW)==='function'))throw F(15,aW);
+for(var as=0;as<aj;as++){
+var bg=this[as];
+aZ[as]=%_Call(aW,aY,bg,as,this);
+}
+return aZ;
+}
+%FunctionSetLength(TypedArrayMap,1);
+function TypedArraySome(aW,aX){
+if(!(%_IsTypedArray(this)))throw F(72);
+var aj=%_TypedArrayGetLength(this);
+return A(aW,aX,this,aj);
+}
+%FunctionSetLength(TypedArraySome,1);
+function TypedArrayToLocaleString(){
+if(!(%_IsTypedArray(this)))throw F(72);
+var aj=%_TypedArrayGetLength(this);
+return C(this,aj);
+}
+function TypedArrayJoin(bi){
+if(!(%_IsTypedArray(this)))throw F(72);
+var aj=%_TypedArrayGetLength(this);
+return w(bi,this,aj);
+}
+function TypedArrayReduce(bj,bk){
+if(!(%_IsTypedArray(this)))throw F(72);
+var aj=%_TypedArrayGetLength(this);
+return y(bj,bk,this,aj,
+arguments.length);
+}
+%FunctionSetLength(TypedArrayReduce,1);
+function TypedArrayReduceRight(bj,bk){
+if(!(%_IsTypedArray(this)))throw F(72);
+var aj=%_TypedArrayGetLength(this);
+return z(bj,bk,this,aj,
+arguments.length);
+}
+%FunctionSetLength(TypedArrayReduceRight,1);
+function TypedArraySlice(aV,aE){
+if(!(%_IsTypedArray(this)))throw F(72);
+var bl=%_TypedArrayGetLength(this);
+var bm=(%_ToInteger(aV));
+var bn;
+if(bm<0){
+bn=G(bl+bm,0);
+}else{
+bn=H(bm,bl);
+}
+var bo;
+if((aE===(void 0))){
+bo=bl;
+}else{
+bo=(%_ToInteger(aE));
+}
+var bp;
+if(bo<0){
+bp=G(bl+bo,0);
+}else{
+bp=H(bo,bl);
+}
+var bq=G(bp-bn,0);
+var br=TypedArraySpeciesCreate(this,bq);
+var bs=0;
+while(bn<bp){
+var bt=this[bn];
+br[bs]=bt;
+bn++;
+bs++;
+}
+return br;
+}
+function TypedArrayIncludes(bu,bv){
+if(!(%_IsTypedArray(this)))throw F(72);
+var aj=%_TypedArrayGetLength(this);
+return u(bu,bv,this,aj);
+}
+%FunctionSetLength(TypedArrayIncludes,1);
+function TypedArrayOf(){
+var aj=arguments.length;
+var br=TypedArrayCreate(this,aj);
+for(var as=0;as<aj;as++){
+br[as]=arguments[as];
+}
+return br;
+}
+function IterableToArrayLike(bw){
+var at=g(bw,L);
+if(!(at===(void 0))){
+var bx=new m();
+var as=0;
+for(var ay of
+{[L](){return f(bw,at)}}){
+bx[as]=ay;
+as++;
+}
+var br=[];
+%MoveArrayContents(bx,br);
+return br;
+}
+return(%_ToObject(bw));
+}
+function TypedArrayFrom(aK,by,aY){
+if(!%IsConstructor(this))throw F(66,this);
+var bz;
+if(!(by===(void 0))){
+if(!(typeof(by)==='function'))throw F(15,this);
+bz=true;
+}else{
+bz=false;
+}
+var aq=IterableToArrayLike(aK);
+var aj=(%_ToLength(aq.length));
+var bA=TypedArrayCreate(this,aj);
+var ay,bB;
+for(var as=0;as<aj;as++){
+ay=aq[as];
+if(bz){
+bB=%_Call(by,aY,ay,as);
+}else{
+bB=ay;
+}
+bA[as]=bB;
+}
+return bA;
+}
+%FunctionSetLength(TypedArrayFrom,1);
+function TypedArray(){
+if((new.target===(void 0))){
+throw F(27,"TypedArray");
+}
+if(new.target===TypedArray){
+throw F(25,"TypedArray");
+}
+}
+%FunctionSetPrototype(TypedArray,new l());
+%AddNamedProperty(TypedArray.prototype,
+"constructor",TypedArray,2);
+b.InstallFunctions(TypedArray,2,[
+"from",TypedArrayFrom,
+"of",TypedArrayOf
+]);
+b.InstallGetter(TypedArray.prototype,"buffer",TypedArrayGetBuffer);
+b.InstallGetter(TypedArray.prototype,"byteOffset",TypedArrayGetByteOffset,
+2|4);
+b.InstallGetter(TypedArray.prototype,"byteLength",
+TypedArrayGetByteLength,2|4);
+b.InstallGetter(TypedArray.prototype,"length",TypedArrayGetLength,
+2|4);
+b.InstallGetter(TypedArray.prototype,M,
+TypedArrayGetToStringTag);
+b.InstallFunctions(TypedArray.prototype,2,[
+"subarray",TypedArraySubArray,
+"set",TypedArraySet,
+"copyWithin",TypedArrayCopyWithin,
+"every",TypedArrayEvery,
+"fill",TypedArrayFill,
+"filter",TypedArrayFilter,
+"find",TypedArrayFind,
+"findIndex",TypedArrayFindIndex,
+"includes",TypedArrayIncludes,
+"indexOf",TypedArrayIndexOf,
+"join",TypedArrayJoin,
+"lastIndexOf",TypedArrayLastIndexOf,
+"forEach",TypedArrayForEach,
+"map",TypedArrayMap,
+"reduce",TypedArrayReduce,
+"reduceRight",TypedArrayReduceRight,
+"reverse",TypedArrayReverse,
+"slice",TypedArraySlice,
+"some",TypedArraySome,
+"sort",TypedArraySort,
+"toLocaleString",TypedArrayToLocaleString
+]);
+%AddNamedProperty(TypedArray.prototype,"toString",d,
+2);
+%SetCode(N,Uint8ArrayConstructor);
+%FunctionSetPrototype(N,new l());
+%InternalSetPrototype(N,TypedArray);
+%InternalSetPrototype(N.prototype,TypedArray.prototype);
+%AddNamedProperty(N,"BYTES_PER_ELEMENT",1,
+1|2|4);
+%AddNamedProperty(N.prototype,
+"constructor",a.Uint8Array,2);
+%AddNamedProperty(N.prototype,
+"BYTES_PER_ELEMENT",1,
+1|2|4);
+
+%SetCode(O,Int8ArrayConstructor);
+%FunctionSetPrototype(O,new l());
+%InternalSetPrototype(O,TypedArray);
+%InternalSetPrototype(O.prototype,TypedArray.prototype);
+%AddNamedProperty(O,"BYTES_PER_ELEMENT",1,
+1|2|4);
+%AddNamedProperty(O.prototype,
+"constructor",a.Int8Array,2);
+%AddNamedProperty(O.prototype,
+"BYTES_PER_ELEMENT",1,
+1|2|4);
+
+%SetCode(P,Uint16ArrayConstructor);
+%FunctionSetPrototype(P,new l());
+%InternalSetPrototype(P,TypedArray);
+%InternalSetPrototype(P.prototype,TypedArray.prototype);
+%AddNamedProperty(P,"BYTES_PER_ELEMENT",2,
+1|2|4);
+%AddNamedProperty(P.prototype,
+"constructor",a.Uint16Array,2);
+%AddNamedProperty(P.prototype,
+"BYTES_PER_ELEMENT",2,
+1|2|4);
+
+%SetCode(Q,Int16ArrayConstructor);
+%FunctionSetPrototype(Q,new l());
+%InternalSetPrototype(Q,TypedArray);
+%InternalSetPrototype(Q.prototype,TypedArray.prototype);
+%AddNamedProperty(Q,"BYTES_PER_ELEMENT",2,
+1|2|4);
+%AddNamedProperty(Q.prototype,
+"constructor",a.Int16Array,2);
+%AddNamedProperty(Q.prototype,
+"BYTES_PER_ELEMENT",2,
+1|2|4);
+
+%SetCode(R,Uint32ArrayConstructor);
+%FunctionSetPrototype(R,new l());
+%InternalSetPrototype(R,TypedArray);
+%InternalSetPrototype(R.prototype,TypedArray.prototype);
+%AddNamedProperty(R,"BYTES_PER_ELEMENT",4,
+1|2|4);
+%AddNamedProperty(R.prototype,
+"constructor",a.Uint32Array,2);
+%AddNamedProperty(R.prototype,
+"BYTES_PER_ELEMENT",4,
+1|2|4);
+
+%SetCode(S,Int32ArrayConstructor);
+%FunctionSetPrototype(S,new l());
+%InternalSetPrototype(S,TypedArray);
+%InternalSetPrototype(S.prototype,TypedArray.prototype);
+%AddNamedProperty(S,"BYTES_PER_ELEMENT",4,
+1|2|4);
+%AddNamedProperty(S.prototype,
+"constructor",a.Int32Array,2);
+%AddNamedProperty(S.prototype,
+"BYTES_PER_ELEMENT",4,
+1|2|4);
+
+%SetCode(T,Float32ArrayConstructor);
+%FunctionSetPrototype(T,new l());
+%InternalSetPrototype(T,TypedArray);
+%InternalSetPrototype(T.prototype,TypedArray.prototype);
+%AddNamedProperty(T,"BYTES_PER_ELEMENT",4,
+1|2|4);
+%AddNamedProperty(T.prototype,
+"constructor",a.Float32Array,2);
+%AddNamedProperty(T.prototype,
+"BYTES_PER_ELEMENT",4,
+1|2|4);
+
+%SetCode(U,Float64ArrayConstructor);
+%FunctionSetPrototype(U,new l());
+%InternalSetPrototype(U,TypedArray);
+%InternalSetPrototype(U.prototype,TypedArray.prototype);
+%AddNamedProperty(U,"BYTES_PER_ELEMENT",8,
+1|2|4);
+%AddNamedProperty(U.prototype,
+"constructor",a.Float64Array,2);
+%AddNamedProperty(U.prototype,
+"BYTES_PER_ELEMENT",8,
+1|2|4);
+
+%SetCode(V,Uint8ClampedArrayConstructor);
+%FunctionSetPrototype(V,new l());
+%InternalSetPrototype(V,TypedArray);
+%InternalSetPrototype(V.prototype,TypedArray.prototype);
+%AddNamedProperty(V,"BYTES_PER_ELEMENT",1,
+1|2|4);
+%AddNamedProperty(V.prototype,
+"constructor",a.Uint8ClampedArray,2);
+%AddNamedProperty(V.prototype,
+"BYTES_PER_ELEMENT",1,
+1|2|4);
+
+
+function DataViewGetBufferJS(){
+if(!(%_ClassOf(this)==='DataView')){
+throw F(44,'DataView.buffer',this);
+}
+return %DataViewGetBuffer(this);
+}
+function DataViewGetByteOffset(){
+if(!(%_ClassOf(this)==='DataView')){
+throw F(44,
+'DataView.byteOffset',this);
+}
+return %_ArrayBufferViewGetByteOffset(this);
+}
+function DataViewGetByteLength(){
+if(!(%_ClassOf(this)==='DataView')){
+throw F(44,
+'DataView.byteLength',this);
+}
+return %_ArrayBufferViewGetByteLength(this);
+}
+function DataViewGetInt8JS(al,bC){
+if(!(%_ClassOf(this)==='DataView')){
+throw F(44,
+'DataView.getInt8',this);
+}
+if(arguments.length<1)throw F(47);
+al=K(al,169);
+return %DataViewGetInt8(this,al,!!bC);
+}
+%FunctionSetLength(DataViewGetInt8JS,1);
+function DataViewSetInt8JS(al,ay,bC){
+if(!(%_ClassOf(this)==='DataView')){
+throw F(44,
+'DataView.setInt8',this);
+}
+if(arguments.length<2)throw F(47);
+al=K(al,169);
+%DataViewSetInt8(this,al,(%_ToNumber(ay)),!!bC);
+}
+%FunctionSetLength(DataViewSetInt8JS,2);
+
+function DataViewGetUint8JS(al,bC){
+if(!(%_ClassOf(this)==='DataView')){
+throw F(44,
+'DataView.getUint8',this);
+}
+if(arguments.length<1)throw F(47);
+al=K(al,169);
+return %DataViewGetUint8(this,al,!!bC);
+}
+%FunctionSetLength(DataViewGetUint8JS,1);
+function DataViewSetUint8JS(al,ay,bC){
+if(!(%_ClassOf(this)==='DataView')){
+throw F(44,
+'DataView.setUint8',this);
+}
+if(arguments.length<2)throw F(47);
+al=K(al,169);
+%DataViewSetUint8(this,al,(%_ToNumber(ay)),!!bC);
+}
+%FunctionSetLength(DataViewSetUint8JS,2);
+
+function DataViewGetInt16JS(al,bC){
+if(!(%_ClassOf(this)==='DataView')){
+throw F(44,
+'DataView.getInt16',this);
+}
+if(arguments.length<1)throw F(47);
+al=K(al,169);
+return %DataViewGetInt16(this,al,!!bC);
+}
+%FunctionSetLength(DataViewGetInt16JS,1);
+function DataViewSetInt16JS(al,ay,bC){
+if(!(%_ClassOf(this)==='DataView')){
+throw F(44,
+'DataView.setInt16',this);
+}
+if(arguments.length<2)throw F(47);
+al=K(al,169);
+%DataViewSetInt16(this,al,(%_ToNumber(ay)),!!bC);
+}
+%FunctionSetLength(DataViewSetInt16JS,2);
+
+function DataViewGetUint16JS(al,bC){
+if(!(%_ClassOf(this)==='DataView')){
+throw F(44,
+'DataView.getUint16',this);
+}
+if(arguments.length<1)throw F(47);
+al=K(al,169);
+return %DataViewGetUint16(this,al,!!bC);
+}
+%FunctionSetLength(DataViewGetUint16JS,1);
+function DataViewSetUint16JS(al,ay,bC){
+if(!(%_ClassOf(this)==='DataView')){
+throw F(44,
+'DataView.setUint16',this);
+}
+if(arguments.length<2)throw F(47);
+al=K(al,169);
+%DataViewSetUint16(this,al,(%_ToNumber(ay)),!!bC);
+}
+%FunctionSetLength(DataViewSetUint16JS,2);
+
+function DataViewGetInt32JS(al,bC){
+if(!(%_ClassOf(this)==='DataView')){
+throw F(44,
+'DataView.getInt32',this);
+}
+if(arguments.length<1)throw F(47);
+al=K(al,169);
+return %DataViewGetInt32(this,al,!!bC);
+}
+%FunctionSetLength(DataViewGetInt32JS,1);
+function DataViewSetInt32JS(al,ay,bC){
+if(!(%_ClassOf(this)==='DataView')){
+throw F(44,
+'DataView.setInt32',this);
+}
+if(arguments.length<2)throw F(47);
+al=K(al,169);
+%DataViewSetInt32(this,al,(%_ToNumber(ay)),!!bC);
+}
+%FunctionSetLength(DataViewSetInt32JS,2);
+
+function DataViewGetUint32JS(al,bC){
+if(!(%_ClassOf(this)==='DataView')){
+throw F(44,
+'DataView.getUint32',this);
+}
+if(arguments.length<1)throw F(47);
+al=K(al,169);
+return %DataViewGetUint32(this,al,!!bC);
+}
+%FunctionSetLength(DataViewGetUint32JS,1);
+function DataViewSetUint32JS(al,ay,bC){
+if(!(%_ClassOf(this)==='DataView')){
+throw F(44,
+'DataView.setUint32',this);
+}
+if(arguments.length<2)throw F(47);
+al=K(al,169);
+%DataViewSetUint32(this,al,(%_ToNumber(ay)),!!bC);
+}
+%FunctionSetLength(DataViewSetUint32JS,2);
+
+function DataViewGetFloat32JS(al,bC){
+if(!(%_ClassOf(this)==='DataView')){
+throw F(44,
+'DataView.getFloat32',this);
+}
+if(arguments.length<1)throw F(47);
+al=K(al,169);
+return %DataViewGetFloat32(this,al,!!bC);
+}
+%FunctionSetLength(DataViewGetFloat32JS,1);
+function DataViewSetFloat32JS(al,ay,bC){
+if(!(%_ClassOf(this)==='DataView')){
+throw F(44,
+'DataView.setFloat32',this);
+}
+if(arguments.length<2)throw F(47);
+al=K(al,169);
+%DataViewSetFloat32(this,al,(%_ToNumber(ay)),!!bC);
+}
+%FunctionSetLength(DataViewSetFloat32JS,2);
+
+function DataViewGetFloat64JS(al,bC){
+if(!(%_ClassOf(this)==='DataView')){
+throw F(44,
+'DataView.getFloat64',this);
+}
+if(arguments.length<1)throw F(47);
+al=K(al,169);
+return %DataViewGetFloat64(this,al,!!bC);
+}
+%FunctionSetLength(DataViewGetFloat64JS,1);
+function DataViewSetFloat64JS(al,ay,bC){
+if(!(%_ClassOf(this)==='DataView')){
+throw F(44,
+'DataView.setFloat64',this);
+}
+if(arguments.length<2)throw F(47);
+al=K(al,169);
+%DataViewSetFloat64(this,al,(%_ToNumber(ay)),!!bC);
+}
+%FunctionSetLength(DataViewSetFloat64JS,2);
+
+
+%FunctionSetPrototype(k,new l);
+%AddNamedProperty(k.prototype,"constructor",k,
+2);
+%AddNamedProperty(k.prototype,M,"DataView",
+1|2);
+b.InstallGetter(k.prototype,"buffer",DataViewGetBufferJS);
+b.InstallGetter(k.prototype,"byteOffset",
+DataViewGetByteOffset);
+b.InstallGetter(k.prototype,"byteLength",
+DataViewGetByteLength);
+b.InstallFunctions(k.prototype,2,[
+"getInt8",DataViewGetInt8JS,
+"setInt8",DataViewSetInt8JS,
+"getUint8",DataViewGetUint8JS,
+"setUint8",DataViewSetUint8JS,
+"getInt16",DataViewGetInt16JS,
+"setInt16",DataViewSetInt16JS,
+"getUint16",DataViewGetUint16JS,
+"setUint16",DataViewSetUint16JS,
+"getInt32",DataViewGetInt32JS,
+"setInt32",DataViewSetInt32JS,
+"getUint32",DataViewGetUint32JS,
+"setUint32",DataViewSetUint32JS,
+"getFloat32",DataViewGetFloat32JS,
+"setFloat32",DataViewSetFloat32JS,
+"getFloat64",DataViewGetFloat64JS,
+"setFloat64",DataViewSetFloat64JS
+]);
+})
+
+Hiterator-prototype�
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Object;
+var d=b.ImportNow("IteratorPrototype");
+var e=b.ImportNow("iterator_symbol");
+function IteratorPrototypeIterator(){
+return this;
+}
+b.SetFunctionName(IteratorPrototypeIterator,e);
+%AddNamedProperty(d,e,
+IteratorPrototypeIterator,2);
+})
+
+$generator

+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=b.ImportNow("GeneratorFunctionPrototype");
+var d=b.ImportNow("GeneratorFunction");
+var e=a.Function;
+var f;
+var g=b.ImportNow("to_string_tag_symbol");
+b.Import(function(h){
+f=h.MakeTypeError;
+});
+function GeneratorObjectNext(i){
+if(!(%_ClassOf(this)==='Generator')){
+throw f(44,
+'[Generator].prototype.next',this);
+}
+var j=%GeneratorGetContinuation(this);
+if(j>0){
+if(%_DebugIsActive()!=0)%DebugPrepareStepInIfStepping(this);
+return %_GeneratorNext(this,i);
+}else if(j==0){
+return %_CreateIterResultObject((void 0),true);
+}else{
+throw f(42);
+}
+}
+function GeneratorObjectReturn(i){
+if(!(%_ClassOf(this)==='Generator')){
+throw f(44,
+'[Generator].prototype.return',this);
+}
+var j=%GeneratorGetContinuation(this);
+if(j>0){
+if(%_DebugIsActive()!=0)%DebugPrepareStepInIfStepping(this);
+return %_GeneratorReturn(this,i);
+}else if(j==0){
+return %_CreateIterResultObject(i,true);
+}else{
+throw f(42);
+}
+}
+function GeneratorObjectThrow(k){
+if(!(%_ClassOf(this)==='Generator')){
+throw f(44,
+'[Generator].prototype.throw',this);
+}
+var j=%GeneratorGetContinuation(this);
+if(j>0){
+if(%_DebugIsActive()!=0)%DebugPrepareStepInIfStepping(this);
+return %_GeneratorThrow(this,k);
+}else if(j==0){
+throw k;
+}else{
+throw f(42);
+}
+}
+%NeverOptimizeFunction(GeneratorObjectNext);
+%NeverOptimizeFunction(GeneratorObjectReturn);
+%NeverOptimizeFunction(GeneratorObjectThrow);
+var l=c.prototype;
+b.InstallFunctions(l,
+2,
+["next",GeneratorObjectNext,
+"return",GeneratorObjectReturn,
+"throw",GeneratorObjectThrow]);
+%AddNamedProperty(l,"constructor",
+c,2|1);
+%AddNamedProperty(l,
+g,"Generator",2|1);
+%InternalSetPrototype(c,e.prototype);
+%AddNamedProperty(c,
+g,"GeneratorFunction",2|1);
+%AddNamedProperty(c,"constructor",
+d,2|1);
+%InternalSetPrototype(d,e);
+})
+
+8object-observeѭ
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c;
+var d=a.Array;
+var e=a.Object;
+var f=b.InternalArray;
+var g;
+b.Import(function(h){
+c=h.GetHash;
+g=h.MakeTypeError;
+});
+var i;
+var j={};
+function GetObservationStateJS(){
+if((i===(void 0))){
+i=%GetObservationState();
+}
+if((i.callbackInfoMap===(void 0))){
+i.callbackInfoMap=%ObservationWeakMapCreate();
+i.objectInfoMap=%ObservationWeakMapCreate();
+i.notifierObjectInfoMap=%ObservationWeakMapCreate();
+i.pendingObservers=null;
+i.nextCallbackPriority=0;
+i.lastMicrotaskId=0;
+}
+return i;
+}
+function GetPendingObservers(){
+return GetObservationStateJS().pendingObservers;
+}
+function SetPendingObservers(k){
+GetObservationStateJS().pendingObservers=k;
+}
+function GetNextCallbackPriority(){
+return GetObservationStateJS().nextCallbackPriority++;
+}
+function nullProtoObject(){
+return{__proto__:null};
+}
+function TypeMapCreate(){
+return nullProtoObject();
+}
+function TypeMapAddType(l,m,n){
+l[m]=n?1:(l[m]||0)+1;
+}
+function TypeMapRemoveType(l,m){
+l[m]--;
+}
+function TypeMapCreateFromList(o,p){
+var l=TypeMapCreate();
+for(var q=0;q<p;q++){
+TypeMapAddType(l,o[q],true);
+}
+return l;
+}
+function TypeMapHasType(l,m){
+return!!l[m];
+}
+function TypeMapIsDisjointFrom(r,s){
+if(!r||!s)
+return true;
+for(var m in r){
+if(TypeMapHasType(r,m)&&TypeMapHasType(s,m))
+return false;
+}
+return true;
+}
+var t=(function(){
+var u=[
+'add',
+'update',
+'delete',
+'setPrototype',
+'reconfigure',
+'preventExtensions'
+];
+return TypeMapCreateFromList(u,u.length);
+})();
+function ObserverCreate(v,w){
+if((w===(void 0)))
+return v;
+var x=nullProtoObject();
+x.callback=v;
+x.accept=w;
+return x;
+}
+function ObserverGetCallback(x){
+return(typeof(x)==='function')?x:x.callback;
+}
+function ObserverGetAcceptTypes(x){
+return(typeof(x)==='function')?t:x.accept;
+}
+function ObserverIsActive(x,y){
+return TypeMapIsDisjointFrom(ObjectInfoGetPerformingTypes(y),
+ObserverGetAcceptTypes(x));
+}
+function ObjectInfoGetOrCreate(z){
+var y=ObjectInfoGet(z);
+if((y===(void 0))){
+if(!(%_IsJSProxy(z))){
+%SetIsObserved(z);
+}
+y={
+object:z,
+changeObservers:null,
+notifier:null,
+performing:null,
+performingCount:0,
+};
+%WeakCollectionSet(GetObservationStateJS().objectInfoMap,
+z,y,c(z));
+}
+return y;
+}
+function ObjectInfoGet(z){
+return %WeakCollectionGet(GetObservationStateJS().objectInfoMap,z,
+c(z));
+}
+function ObjectInfoGetFromNotifier(A){
+return %WeakCollectionGet(GetObservationStateJS().notifierObjectInfoMap,
+A,c(A));
+}
+function ObjectInfoGetNotifier(y){
+if((y.notifier===null)){
+var A={__proto__:j};
+y.notifier=A;
+%WeakCollectionSet(GetObservationStateJS().notifierObjectInfoMap,
+A,y,c(A));
+}
+return y.notifier;
+}
+function ChangeObserversIsOptimized(B){
+return(typeof(B)==='function')||
+(typeof(B.callback)==='function');
+}
+function ObjectInfoNormalizeChangeObservers(y){
+if(ChangeObserversIsOptimized(y.changeObservers)){
+var x=y.changeObservers;
+var v=ObserverGetCallback(x);
+var C=CallbackInfoGet(v);
+var D=CallbackInfoGetPriority(C);
+y.changeObservers=nullProtoObject();
+y.changeObservers[D]=x;
+}
+}
+function ObjectInfoAddObserver(y,v,w){
+var C=CallbackInfoGetOrCreate(v);
+var x=ObserverCreate(v,w);
+if(!y.changeObservers){
+y.changeObservers=x;
+return;
+}
+ObjectInfoNormalizeChangeObservers(y);
+var D=CallbackInfoGetPriority(C);
+y.changeObservers[D]=x;
+}
+function ObjectInfoRemoveObserver(y,v){
+if(!y.changeObservers)
+return;
+if(ChangeObserversIsOptimized(y.changeObservers)){
+if(v===ObserverGetCallback(y.changeObservers))
+y.changeObservers=null;
+return;
+}
+var C=CallbackInfoGet(v);
+var D=CallbackInfoGetPriority(C);
+y.changeObservers[D]=null;
+}
+function ObjectInfoHasActiveObservers(y){
+if((y===(void 0))||!y.changeObservers)
+return false;
+if(ChangeObserversIsOptimized(y.changeObservers))
+return ObserverIsActive(y.changeObservers,y);
+for(var D in y.changeObservers){
+var x=y.changeObservers[D];
+if(!(x===null)&&ObserverIsActive(x,y))
+return true;
+}
+return false;
+}
+function ObjectInfoAddPerformingType(y,m){
+y.performing=y.performing||TypeMapCreate();
+TypeMapAddType(y.performing,m);
+y.performingCount++;
+}
+function ObjectInfoRemovePerformingType(y,m){
+y.performingCount--;
+TypeMapRemoveType(y.performing,m);
+}
+function ObjectInfoGetPerformingTypes(y){
+return y.performingCount>0?y.performing:null;
+}
+function ConvertAcceptListToTypeMap(E){
+if((E===(void 0)))
+return E;
+if(!(%_IsJSReceiver(E)))throw g(84);
+var F=(%_ToInteger(E.length));
+if(F<0)F=0;
+return TypeMapCreateFromList(E,F);
+}
+function CallbackInfoGet(v){
+return %WeakCollectionGet(GetObservationStateJS().callbackInfoMap,v,
+c(v));
+}
+function CallbackInfoSet(v,C){
+%WeakCollectionSet(GetObservationStateJS().callbackInfoMap,
+v,C,c(v));
+}
+function CallbackInfoGetOrCreate(v){
+var C=CallbackInfoGet(v);
+if(!(C===(void 0)))
+return C;
+var D=GetNextCallbackPriority();
+CallbackInfoSet(v,D);
+return D;
+}
+function CallbackInfoGetPriority(C){
+if((typeof(C)==='number'))
+return C;
+else
+return C.priority;
+}
+function CallbackInfoNormalize(v){
+var C=CallbackInfoGet(v);
+if((typeof(C)==='number')){
+var D=C;
+C=new f;
+C.priority=D;
+CallbackInfoSet(v,C);
+}
+return C;
+}
+function ObjectObserve(z,v,w){
+if(!(%_IsJSReceiver(z)))
+throw g(86,"observe","observe");
+if(%IsJSGlobalProxy(z))
+throw g(82,"observe");
+if(%IsAccessCheckNeeded(z))
+throw g(83,"observe");
+if(!(typeof(v)==='function'))
+throw g(85,"observe");
+if(%object_is_frozen(v))
+throw g(81);
+var G=%GetObjectContextObjectObserve(z);
+return G(z,v,w);
+}
+function NativeObjectObserve(z,v,w){
+var y=ObjectInfoGetOrCreate(z);
+var o=ConvertAcceptListToTypeMap(w);
+ObjectInfoAddObserver(y,v,o);
+return z;
+}
+function ObjectUnobserve(z,v){
+if(!(%_IsJSReceiver(z)))
+throw g(86,"unobserve","unobserve");
+if(%IsJSGlobalProxy(z))
+throw g(82,"unobserve");
+if(!(typeof(v)==='function'))
+throw g(85,"unobserve");
+var y=ObjectInfoGet(z);
+if((y===(void 0)))
+return z;
+ObjectInfoRemoveObserver(y,v);
+return z;
+}
+function ArrayObserve(z,v){
+return ObjectObserve(z,v,['add',
+'update',
+'delete',
+'splice']);
+}
+function ArrayUnobserve(z,v){
+return ObjectUnobserve(z,v);
+}
+function ObserverEnqueueIfActive(x,y,H){
+if(!ObserverIsActive(x,y)||
+!TypeMapHasType(ObserverGetAcceptTypes(x),H.type)){
+return;
+}
+var v=ObserverGetCallback(x);
+if(!%ObserverObjectAndRecordHaveSameOrigin(v,H.object,
+H)){
+return;
+}
+var C=CallbackInfoNormalize(v);
+if((GetPendingObservers()===null)){
+SetPendingObservers(nullProtoObject());
+if((%_DebugIsActive()!=0)){
+var I=++GetObservationStateJS().lastMicrotaskId;
+var J="Object.observe";
+%EnqueueMicrotask(function(){
+%DebugAsyncTaskEvent({type:"willHandle",id:I,name:J});
+ObserveMicrotaskRunner();
+%DebugAsyncTaskEvent({type:"didHandle",id:I,name:J});
+});
+%DebugAsyncTaskEvent({type:"enqueue",id:I,name:J});
+}else{
+%EnqueueMicrotask(ObserveMicrotaskRunner);
+}
+}
+GetPendingObservers()[C.priority]=v;
+C.push(H);
+}
+function ObjectInfoEnqueueExternalChangeRecord(y,H,m){
+if(!ObjectInfoHasActiveObservers(y))
+return;
+var K=!(m===(void 0));
+var L=K?
+{object:y.object,type:m}:
+{object:y.object};
+for(var M in H){
+if(M==='object'||(K&&M==='type'))continue;
+%DefineDataPropertyUnchecked(
+L,M,H[M],1+4);
+}
+%object_freeze(L);
+ObjectInfoEnqueueInternalChangeRecord(y,L);
+}
+function ObjectInfoEnqueueInternalChangeRecord(y,H){
+if((typeof(H.name)==='symbol'))return;
+if(ChangeObserversIsOptimized(y.changeObservers)){
+var x=y.changeObservers;
+ObserverEnqueueIfActive(x,y,H);
+return;
+}
+for(var D in y.changeObservers){
+var x=y.changeObservers[D];
+if((x===null))
+continue;
+ObserverEnqueueIfActive(x,y,H);
+}
+}
+function BeginPerformSplice(N){
+var y=ObjectInfoGet(N);
+if(!(y===(void 0)))
+ObjectInfoAddPerformingType(y,'splice');
+}
+function EndPerformSplice(N){
+var y=ObjectInfoGet(N);
+if(!(y===(void 0)))
+ObjectInfoRemovePerformingType(y,'splice');
+}
+function EnqueueSpliceRecord(N,O,P,Q){
+var y=ObjectInfoGet(N);
+if(!ObjectInfoHasActiveObservers(y))
+return;
+var H={
+type:'splice',
+object:N,
+index:O,
+removed:P,
+addedCount:Q
+};
+%object_freeze(H);
+%object_freeze(H.removed);
+ObjectInfoEnqueueInternalChangeRecord(y,H);
+}
+function NotifyChange(m,z,J,R){
+var y=ObjectInfoGet(z);
+if(!ObjectInfoHasActiveObservers(y))
+return;
+var H;
+if(arguments.length==2){
+H={type:m,object:z};
+}else if(arguments.length==3){
+H={type:m,object:z,name:J};
+}else{
+H={
+type:m,
+object:z,
+name:J,
+oldValue:R
+};
+}
+%object_freeze(H);
+ObjectInfoEnqueueInternalChangeRecord(y,H);
+}
+function ObjectNotifierNotify(H){
+if(!(%_IsJSReceiver(this)))
+throw g(17,"notify");
+var y=ObjectInfoGetFromNotifier(this);
+if((y===(void 0)))
+throw g(87);
+if(!(typeof(H.type)==='string'))
+throw g(90);
+ObjectInfoEnqueueExternalChangeRecord(y,H);
+}
+function ObjectNotifierPerformChange(S,T){
+if(!(%_IsJSReceiver(this)))
+throw g(17,"performChange");
+var y=ObjectInfoGetFromNotifier(this);
+if((y===(void 0)))
+throw g(87);
+if(!(typeof(S)==='string'))
+throw g(89);
+if(!(typeof(T)==='function'))
+throw g(88);
+var U=%GetObjectContextNotifierPerformChange(y);
+U(y,S,T);
+}
+function NativeObjectNotifierPerformChange(y,S,T){
+ObjectInfoAddPerformingType(y,S);
+var H;
+try{
+H=T();
+}finally{
+ObjectInfoRemovePerformingType(y,S);
+}
+if((%_IsJSReceiver(H)))
+ObjectInfoEnqueueExternalChangeRecord(y,H,S);
+}
+function ObjectGetNotifier(z){
+if(!(%_IsJSReceiver(z)))
+throw g(86,"getNotifier","getNotifier");
+if(%IsJSGlobalProxy(z))
+throw g(82,"getNotifier");
+if(%IsAccessCheckNeeded(z))
+throw g(83,"getNotifier");
+if(%object_is_frozen(z))return null;
+if(!%ObjectWasCreatedInCurrentOrigin(z))return null;
+var V=%GetObjectContextObjectGetNotifier(z);
+return V(z);
+}
+function NativeObjectGetNotifier(z){
+var y=ObjectInfoGetOrCreate(z);
+return ObjectInfoGetNotifier(y);
+}
+function CallbackDeliverPending(v){
+var C=CallbackInfoGet(v);
+if((C===(void 0))||(typeof(C)==='number'))
+return false;
+var D=C.priority;
+CallbackInfoSet(v,D);
+var k=GetPendingObservers();
+if(!(k===null))
+delete k[D];
+var W=[];
+%MoveArrayContents(C,W);
+%DeliverObservationChangeRecords(v,W);
+return true;
+}
+function ObjectDeliverChangeRecords(v){
+if(!(typeof(v)==='function'))
+throw g(85,"deliverChangeRecords");
+while(CallbackDeliverPending(v)){}
+}
+function ObserveMicrotaskRunner(){
+var k=GetPendingObservers();
+if(!(k===null)){
+SetPendingObservers(null);
+for(var q in k){
+CallbackDeliverPending(k[q]);
+}
+}
+}
+b.InstallFunctions(j,2,[
+"notify",ObjectNotifierNotify,
+"performChange",ObjectNotifierPerformChange
+]);
+var X=[
+"deliverChangeRecords",ObjectDeliverChangeRecords,
+"getNotifier",ObjectGetNotifier,
+"observe",ObjectObserve,
+"unobserve",ObjectUnobserve
+];
+var Y=[
+"observe",ArrayObserve,
+"unobserve",ArrayUnobserve
+];
+var Z=function(aa,q){
+if(q % 2===1)%FunctionRemovePrototype(aa);
+};
+X.forEach(Z);
+Y.forEach(Z);
+%InstallToContext([
+"native_object_get_notifier",NativeObjectGetNotifier,
+"native_object_notifier_perform_change",NativeObjectNotifierPerformChange,
+"native_object_observe",NativeObjectObserve,
+"observers_begin_perform_splice",BeginPerformSplice,
+"observers_end_perform_splice",EndPerformSplice,
+"observers_enqueue_splice",EnqueueSpliceRecord,
+"observers_notify_change",NotifyChange,
+]);
+b.Export(function(ab){
+ab.ObserveArrayMethods=Y;
+ab.ObserveBeginPerformSplice=BeginPerformSplice;
+ab.ObserveEndPerformSplice=EndPerformSplice;
+ab.ObserveEnqueueSpliceRecord=EnqueueSpliceRecord;
+ab.ObserveObjectMethods=X;
+});
+})
+
+(collectionE}
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Map;
+var d=a.Object;
+var e=a.Set;
+var f=b.ImportNow("hash_code_symbol");
+var g;
+var h;
+var i;
+var j;
+var k;
+var l=b.ImportNow("to_string_tag_symbol");
+b.Import(function(m){
+g=m.IntRandom;
+h=m.MakeTypeError;
+i=m.MapIterator;
+j=m.NumberIsNaN;
+k=m.SetIterator;
+});
+function HashToEntry(n,o,p){
+var q=(o&((p)-1));
+return((%_FixedArrayGet(n,(3+(q))|0)));
+}
+%SetForceInlineFlag(HashToEntry);
+function SetFindEntry(n,p,r,o){
+var s=HashToEntry(n,o,p);
+if(s===-1)return s;
+var t=((%_FixedArrayGet(n,((3+(p)+((s)<<1)))|0)));
+if(r===t)return s;
+var u=j(r);
+while(true){
+if(u&&j(t)){
+return s;
+}
+s=((%_FixedArrayGet(n,((3+(p)+((s)<<1))+1)|0)));
+if(s===-1)return s;
+t=((%_FixedArrayGet(n,((3+(p)+((s)<<1)))|0)));
+if(r===t)return s;
+}
+return-1;
+}
+%SetForceInlineFlag(SetFindEntry);
+function MapFindEntry(n,p,r,o){
+var s=HashToEntry(n,o,p);
+if(s===-1)return s;
+var t=((%_FixedArrayGet(n,((3+(p)+((s)*3)))|0)));
+if(r===t)return s;
+var u=j(r);
+while(true){
+if(u&&j(t)){
+return s;
+}
+s=((%_FixedArrayGet(n,((3+(p)+((s)*3))+2)|0)));
+if(s===-1)return s;
+t=((%_FixedArrayGet(n,((3+(p)+((s)*3)))|0)));
+if(r===t)return s;
+}
+return-1;
+}
+%SetForceInlineFlag(MapFindEntry);
+function ComputeIntegerHash(r,v){
+var o=r;
+o=o^v;
+o=~o+(o<<15);
+o=o^(o>>>12);
+o=o+(o<<2);
+o=o^(o>>>4);
+o=(o*2057)|0;
+o=o^(o>>>16);
+return o&0x3fffffff;
+}
+%SetForceInlineFlag(ComputeIntegerHash);
+function GetExistingHash(r){
+if(%_IsSmi(r)){
+return ComputeIntegerHash(r,0);
+}
+if((typeof(r)==='string')){
+var w=%_StringGetRawHashField(r);
+if((w&1)===0){
+return w>>>2;
+}
+}else if((%_IsJSReceiver(r))&&!(%_IsJSProxy(r))&&!(%_ClassOf(r)==='global')){
+var o=(r[f]);
+return o;
+}
+return %GenericHash(r);
+}
+%SetForceInlineFlag(GetExistingHash);
+function GetHash(r){
+var o=GetExistingHash(r);
+if((o===(void 0))){
+o=g()|0;
+if(o===0)o=1;
+(r[f]=o);
+}
+return o;
+}
+%SetForceInlineFlag(GetHash);
+function SetConstructor(x){
+if((new.target===(void 0))){
+throw h(28,"Set");
+}
+%_SetInitialize(this);
+if(!(x==null)){
+var y=this.add;
+if(!(typeof(y)==='function')){
+throw h(96,y,'add',this);
+}
+for(var z of x){
+%_Call(y,this,z);
+}
+}
+}
+function SetAdd(r){
+if(!(%_ClassOf(this)==='Set')){
+throw h(44,'Set.prototype.add',this);
+}
+if(r===0){
+r=0;
+}
+var n=%_JSCollectionGetTable(this);
+var p=((%_FixedArrayGet(n,(0)|0)));
+var o=GetHash(r);
+if(SetFindEntry(n,p,r,o)!==-1)return this;
+var A=((%_FixedArrayGet(n,(1)|0)));
+var B=((%_FixedArrayGet(n,(2)|0)));
+var C=p<<1;
+if((A+B)>=C){
+%SetGrow(this);
+n=%_JSCollectionGetTable(this);
+p=((%_FixedArrayGet(n,(0)|0)));
+A=((%_FixedArrayGet(n,(1)|0)));
+B=((%_FixedArrayGet(n,(2)|0)));
+}
+var s=A+B;
+var D=(3+(p)+((s)<<1));
+var q=(o&((p)-1));
+var E=((%_FixedArrayGet(n,(3+(q))|0)));
+((%_FixedArraySet(n,(3+(q))|0,s)));
+(((%_FixedArraySet(n,(1)|0,(A+1)|0))));
+(%_FixedArraySet(n,(D)|0,r));
+((%_FixedArraySet(n,(D+1)|0,(E)|0)));
+return this;
+}
+function SetHas(r){
+if(!(%_ClassOf(this)==='Set')){
+throw h(44,'Set.prototype.has',this);
+}
+var n=%_JSCollectionGetTable(this);
+var p=((%_FixedArrayGet(n,(0)|0)));
+var o=GetExistingHash(r);
+if((o===(void 0)))return false;
+return SetFindEntry(n,p,r,o)!==-1;
+}
+function SetDelete(r){
+if(!(%_ClassOf(this)==='Set')){
+throw h(44,
+'Set.prototype.delete',this);
+}
+var n=%_JSCollectionGetTable(this);
+var p=((%_FixedArrayGet(n,(0)|0)));
+var o=GetExistingHash(r);
+if((o===(void 0)))return false;
+var s=SetFindEntry(n,p,r,o);
+if(s===-1)return false;
+var A=((%_FixedArrayGet(n,(1)|0)))-1;
+var B=((%_FixedArrayGet(n,(2)|0)))+1;
+var D=(3+(p)+((s)<<1));
+(%_FixedArraySet(n,(D)|0,%_TheHole()));
+(((%_FixedArraySet(n,(1)|0,(A)|0))));
+(((%_FixedArraySet(n,(2)|0,(B)|0))));
+if(A<(p>>>1))%SetShrink(this);
+return true;
+}
+function SetGetSize(){
+if(!(%_ClassOf(this)==='Set')){
+throw h(44,
+'Set.prototype.size',this);
+}
+var n=%_JSCollectionGetTable(this);
+return((%_FixedArrayGet(n,(1)|0)));
+}
+function SetClearJS(){
+if(!(%_ClassOf(this)==='Set')){
+throw h(44,
+'Set.prototype.clear',this);
+}
+%_SetClear(this);
+}
+function SetForEach(F,G){
+if(!(%_ClassOf(this)==='Set')){
+throw h(44,
+'Set.prototype.forEach',this);
+}
+if(!(typeof(F)==='function'))throw h(15,F);
+var H=new k(this,2);
+var r;
+var I=[(void 0)];
+while(%SetIteratorNext(H,I)){
+r=I[0];
+%_Call(F,G,r,r,this);
+}
+}
+%SetCode(e,SetConstructor);
+%FunctionSetLength(e,0);
+%FunctionSetPrototype(e,new d());
+%AddNamedProperty(e.prototype,"constructor",e,2);
+%AddNamedProperty(e.prototype,l,"Set",
+2|1);
+%FunctionSetLength(SetForEach,1);
+b.InstallGetter(e.prototype,"size",SetGetSize);
+b.InstallFunctions(e.prototype,2,[
+"add",SetAdd,
+"has",SetHas,
+"delete",SetDelete,
+"clear",SetClearJS,
+"forEach",SetForEach
+]);
+function MapConstructor(x){
+if((new.target===(void 0))){
+throw h(28,"Map");
+}
+%_MapInitialize(this);
+if(!(x==null)){
+var y=this.set;
+if(!(typeof(y)==='function')){
+throw h(96,y,'set',this);
+}
+for(var J of x){
+if(!(%_IsJSReceiver(J))){
+throw h(52,J);
+}
+%_Call(y,this,J[0],J[1]);
+}
+}
+}
+function MapGet(r){
+if(!(%_ClassOf(this)==='Map')){
+throw h(44,
+'Map.prototype.get',this);
+}
+var n=%_JSCollectionGetTable(this);
+var p=((%_FixedArrayGet(n,(0)|0)));
+var o=GetExistingHash(r);
+if((o===(void 0)))return(void 0);
+var s=MapFindEntry(n,p,r,o);
+if(s===-1)return(void 0);
+return((%_FixedArrayGet(n,((3+(p)+((s)*3))+1)|0)));
+}
+function MapSet(r,z){
+if(!(%_ClassOf(this)==='Map')){
+throw h(44,
+'Map.prototype.set',this);
+}
+if(r===0){
+r=0;
+}
+var n=%_JSCollectionGetTable(this);
+var p=((%_FixedArrayGet(n,(0)|0)));
+var o=GetHash(r);
+var s=MapFindEntry(n,p,r,o);
+if(s!==-1){
+var K=(3+(p)+((s)*3));
+(%_FixedArraySet(n,(K+1)|0,z));
+return this;
+}
+var A=((%_FixedArrayGet(n,(1)|0)));
+var B=((%_FixedArrayGet(n,(2)|0)));
+var C=p<<1;
+if((A+B)>=C){
+%MapGrow(this);
+n=%_JSCollectionGetTable(this);
+p=((%_FixedArrayGet(n,(0)|0)));
+A=((%_FixedArrayGet(n,(1)|0)));
+B=((%_FixedArrayGet(n,(2)|0)));
+}
+s=A+B;
+var D=(3+(p)+((s)*3));
+var q=(o&((p)-1));
+var E=((%_FixedArrayGet(n,(3+(q))|0)));
+((%_FixedArraySet(n,(3+(q))|0,s)));
+(((%_FixedArraySet(n,(1)|0,(A+1)|0))));
+(%_FixedArraySet(n,(D)|0,r));
+(%_FixedArraySet(n,(D+1)|0,z));
+(%_FixedArraySet(n,(D+2)|0,E));
+return this;
+}
+function MapHas(r){
+if(!(%_ClassOf(this)==='Map')){
+throw h(44,
+'Map.prototype.has',this);
+}
+var n=%_JSCollectionGetTable(this);
+var p=((%_FixedArrayGet(n,(0)|0)));
+var o=GetHash(r);
+return MapFindEntry(n,p,r,o)!==-1;
+}
+function MapDelete(r){
+if(!(%_ClassOf(this)==='Map')){
+throw h(44,
+'Map.prototype.delete',this);
+}
+var n=%_JSCollectionGetTable(this);
+var p=((%_FixedArrayGet(n,(0)|0)));
+var o=GetHash(r);
+var s=MapFindEntry(n,p,r,o);
+if(s===-1)return false;
+var A=((%_FixedArrayGet(n,(1)|0)))-1;
+var B=((%_FixedArrayGet(n,(2)|0)))+1;
+var D=(3+(p)+((s)*3));
+(%_FixedArraySet(n,(D)|0,%_TheHole()));
+(%_FixedArraySet(n,(D+1)|0,%_TheHole()));
+(((%_FixedArraySet(n,(1)|0,(A)|0))));
+(((%_FixedArraySet(n,(2)|0,(B)|0))));
+if(A<(p>>>1))%MapShrink(this);
+return true;
+}
+function MapGetSize(){
+if(!(%_ClassOf(this)==='Map')){
+throw h(44,
+'Map.prototype.size',this);
+}
+var n=%_JSCollectionGetTable(this);
+return((%_FixedArrayGet(n,(1)|0)));
+}
+function MapClearJS(){
+if(!(%_ClassOf(this)==='Map')){
+throw h(44,
+'Map.prototype.clear',this);
+}
+%_MapClear(this);
+}
+function MapForEach(F,G){
+if(!(%_ClassOf(this)==='Map')){
+throw h(44,
+'Map.prototype.forEach',this);
+}
+if(!(typeof(F)==='function'))throw h(15,F);
+var H=new i(this,3);
+var I=[(void 0),(void 0)];
+while(%MapIteratorNext(H,I)){
+%_Call(F,G,I[1],I[0],this);
+}
+}
+%SetCode(c,MapConstructor);
+%FunctionSetLength(c,0);
+%FunctionSetPrototype(c,new d());
+%AddNamedProperty(c.prototype,"constructor",c,2);
+%AddNamedProperty(
+c.prototype,l,"Map",2|1);
+%FunctionSetLength(MapForEach,1);
+b.InstallGetter(c.prototype,"size",MapGetSize);
+b.InstallFunctions(c.prototype,2,[
+"get",MapGet,
+"set",MapSet,
+"has",MapHas,
+"delete",MapDelete,
+"clear",MapClearJS,
+"forEach",MapForEach
+]);
+%InstallToContext([
+"map_get",MapGet,
+"map_set",MapSet,
+"map_has",MapHas,
+"map_delete",MapDelete,
+"set_add",SetAdd,
+"set_has",SetHas,
+"set_delete",SetDelete,
+]);
+b.Export(function(L){
+L.GetExistingHash=GetExistingHash;
+L.GetHash=GetHash;
+});
+})
+
+<weak-collection�-
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c;
+var d;
+var e=a.Object;
+var f=a.WeakMap;
+var g=a.WeakSet;
+var h;
+var i=b.ImportNow("to_string_tag_symbol");
+b.Import(function(j){
+c=j.GetExistingHash;
+d=j.GetHash;
+h=j.MakeTypeError;
+});
+function WeakMapConstructor(k){
+if((new.target===(void 0))){
+throw h(28,"WeakMap");
+}
+%WeakCollectionInitialize(this);
+if(!(k==null)){
+var l=this.set;
+if(!(typeof(l)==='function')){
+throw h(96,l,'set',this);
+}
+for(var m of k){
+if(!(%_IsJSReceiver(m))){
+throw h(52,m);
+}
+%_Call(l,this,m[0],m[1]);
+}
+}
+}
+function WeakMapGet(n){
+if(!(%_ClassOf(this)==='WeakMap')){
+throw h(44,
+'WeakMap.prototype.get',this);
+}
+if(!(%_IsJSReceiver(n)))return(void 0);
+var o=c(n);
+if((o===(void 0)))return(void 0);
+return %WeakCollectionGet(this,n,o);
+}
+function WeakMapSet(n,p){
+if(!(%_ClassOf(this)==='WeakMap')){
+throw h(44,
+'WeakMap.prototype.set',this);
+}
+if(!(%_IsJSReceiver(n)))throw h(174);
+return %WeakCollectionSet(this,n,p,d(n));
+}
+function WeakMapHas(n){
+if(!(%_ClassOf(this)==='WeakMap')){
+throw h(44,
+'WeakMap.prototype.has',this);
+}
+if(!(%_IsJSReceiver(n)))return false;
+var o=c(n);
+if((o===(void 0)))return false;
+return %WeakCollectionHas(this,n,o);
+}
+function WeakMapDelete(n){
+if(!(%_ClassOf(this)==='WeakMap')){
+throw h(44,
+'WeakMap.prototype.delete',this);
+}
+if(!(%_IsJSReceiver(n)))return false;
+var o=c(n);
+if((o===(void 0)))return false;
+return %WeakCollectionDelete(this,n,o);
+}
+%SetCode(f,WeakMapConstructor);
+%FunctionSetLength(f,0);
+%FunctionSetPrototype(f,new e());
+%AddNamedProperty(f.prototype,"constructor",f,
+2);
+%AddNamedProperty(f.prototype,i,"WeakMap",
+2|1);
+b.InstallFunctions(f.prototype,2,[
+"get",WeakMapGet,
+"set",WeakMapSet,
+"has",WeakMapHas,
+"delete",WeakMapDelete
+]);
+function WeakSetConstructor(k){
+if((new.target===(void 0))){
+throw h(28,"WeakSet");
+}
+%WeakCollectionInitialize(this);
+if(!(k==null)){
+var l=this.add;
+if(!(typeof(l)==='function')){
+throw h(96,l,'add',this);
+}
+for(var p of k){
+%_Call(l,this,p);
+}
+}
+}
+function WeakSetAdd(p){
+if(!(%_ClassOf(this)==='WeakSet')){
+throw h(44,
+'WeakSet.prototype.add',this);
+}
+if(!(%_IsJSReceiver(p)))throw h(175);
+return %WeakCollectionSet(this,p,true,d(p));
+}
+function WeakSetHas(p){
+if(!(%_ClassOf(this)==='WeakSet')){
+throw h(44,
+'WeakSet.prototype.has',this);
+}
+if(!(%_IsJSReceiver(p)))return false;
+var o=c(p);
+if((o===(void 0)))return false;
+return %WeakCollectionHas(this,p,o);
+}
+function WeakSetDelete(p){
+if(!(%_ClassOf(this)==='WeakSet')){
+throw h(44,
+'WeakSet.prototype.delete',this);
+}
+if(!(%_IsJSReceiver(p)))return false;
+var o=c(p);
+if((o===(void 0)))return false;
+return %WeakCollectionDelete(this,p,o);
+}
+%SetCode(g,WeakSetConstructor);
+%FunctionSetLength(g,0);
+%FunctionSetPrototype(g,new e());
+%AddNamedProperty(g.prototype,"constructor",g,
+2);
+%AddNamedProperty(g.prototype,i,"WeakSet",
+2|1);
+b.InstallFunctions(g.prototype,2,[
+"add",WeakSetAdd,
+"has",WeakSetHas,
+"delete",WeakSetDelete
+]);
+})
+
+Lcollection-iterator(
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Map;
+var d=a.Set;
+var e=b.ImportNow("iterator_symbol");
+var f;
+var g=b.ImportNow("MapIterator");
+var h=b.ImportNow("to_string_tag_symbol");
+var i=b.ImportNow("SetIterator");
+b.Import(function(j){
+f=j.MakeTypeError;
+});
+function SetIteratorConstructor(k,l){
+%SetIteratorInitialize(this,k,l);
+}
+function SetIteratorNextJS(){
+if(!(%_ClassOf(this)==='Set Iterator')){
+throw f(44,
+'Set Iterator.prototype.next',this);
+}
+var m=[(void 0),(void 0)];
+var n=%_CreateIterResultObject(m,false);
+switch(%SetIteratorNext(this,m)){
+case 0:
+n.value=(void 0);
+n.done=true;
+break;
+case 2:
+n.value=m[0];
+break;
+case 3:
+m[1]=m[0];
+break;
+}
+return n;
+}
+function SetEntries(){
+if(!(%_ClassOf(this)==='Set')){
+throw f(44,
+'Set.prototype.entries',this);
+}
+return new i(this,3);
+}
+function SetValues(){
+if(!(%_ClassOf(this)==='Set')){
+throw f(44,
+'Set.prototype.values',this);
+}
+return new i(this,2);
+}
+%SetCode(i,SetIteratorConstructor);
+%FunctionSetInstanceClassName(i,'Set Iterator');
+b.InstallFunctions(i.prototype,2,[
+'next',SetIteratorNextJS
+]);
+%AddNamedProperty(i.prototype,h,
+"Set Iterator",1|2);
+b.InstallFunctions(d.prototype,2,[
+'entries',SetEntries,
+'keys',SetValues,
+'values',SetValues
+]);
+%AddNamedProperty(d.prototype,e,SetValues,2);
+function MapIteratorConstructor(o,l){
+%MapIteratorInitialize(this,o,l);
+}
+function MapIteratorNextJS(){
+if(!(%_ClassOf(this)==='Map Iterator')){
+throw f(44,
+'Map Iterator.prototype.next',this);
+}
+var m=[(void 0),(void 0)];
+var n=%_CreateIterResultObject(m,false);
+switch(%MapIteratorNext(this,m)){
+case 0:
+n.value=(void 0);
+n.done=true;
+break;
+case 1:
+n.value=m[0];
+break;
+case 2:
+n.value=m[1];
+break;
+}
+return n;
+}
+function MapEntries(){
+if(!(%_ClassOf(this)==='Map')){
+throw f(44,
+'Map.prototype.entries',this);
+}
+return new g(this,3);
+}
+function MapKeys(){
+if(!(%_ClassOf(this)==='Map')){
+throw f(44,
+'Map.prototype.keys',this);
+}
+return new g(this,1);
+}
+function MapValues(){
+if(!(%_ClassOf(this)==='Map')){
+throw f(44,
+'Map.prototype.values',this);
+}
+return new g(this,2);
+}
+%SetCode(g,MapIteratorConstructor);
+%FunctionSetInstanceClassName(g,'Map Iterator');
+b.InstallFunctions(g.prototype,2,[
+'next',MapIteratorNextJS
+]);
+%AddNamedProperty(g.prototype,h,
+"Map Iterator",1|2);
+b.InstallFunctions(c.prototype,2,[
+'entries',MapEntries,
+'keys',MapKeys,
+'values',MapValues
+]);
+%AddNamedProperty(c.prototype,e,MapEntries,2);
+b.Export(function(p){
+p.MapEntries=MapEntries;
+p.MapIteratorNext=MapIteratorNextJS;
+p.SetIteratorNext=SetIteratorNextJS;
+p.SetValues=SetValues;
+});
+})
+
+promiser
+(function(a,b,c){
+"use strict";
+%CheckIsBootstrapping();
+var d=b.InternalArray;
+var e;
+var f=
+b.ImportNow("promise_combined_deferred_symbol");
+var g=
+b.ImportNow("promise_has_handler_symbol");
+var h=b.ImportNow("promise_on_reject_symbol");
+var i=
+b.ImportNow("promise_on_resolve_symbol");
+var j=b.ImportNow("promise_raw_symbol");
+var k=b.ImportNow("promise_status_symbol");
+var l=b.ImportNow("promise_value_symbol");
+var m;
+var n=b.ImportNow("to_string_tag_symbol");
+b.Import(function(o){
+e=o.MakeTypeError;
+m=o.SpeciesConstructor;
+});
+var p=0;
+function CreateResolvingFunctions(q){
+var r=false;
+var s=value=>{
+if(r===true)return;
+r=true;
+PromiseResolve(q,value);
+};
+var t=reason=>{
+if(r===true)return;
+r=true;
+PromiseReject(q,reason);
+};
+return{
+__proto__:null,
+resolve:s,
+reject:t
+};
+}
+var u=function Promise(v){
+if(v===j){
+return %_NewObject(u,new.target);
+}
+if((new.target===(void 0)))throw e(65,this);
+if(!(typeof(v)==='function'))
+throw e(137,v);
+var q=PromiseInit(%_NewObject(u,new.target));
+var w=CreateResolvingFunctions(q);
+try{
+%DebugPushPromise(q,Promise);
+v(w.resolve,w.reject);
+}catch(e){
+%_Call(w.reject,(void 0),e);
+}finally{
+%DebugPopPromise();
+}
+return q;
+}
+function PromiseSet(q,x,y,z,A){
+(q[k]=x);
+(q[l]=y);
+(q[i]=z);
+(q[h]=A);
+return q;
+}
+function PromiseCreateAndSet(x,y){
+var q=new u(j);
+if((%_DebugIsActive()!=0))PromiseSet(q,0,(void 0));
+return PromiseSet(q,x,y);
+}
+function PromiseInit(q){
+return PromiseSet(
+q,0,(void 0),new d,new d)
+}
+function PromiseDone(q,x,y,B){
+if((q[k])===0){
+var C=(q[B]);
+if(C.length)PromiseEnqueue(y,C,x);
+PromiseSet(q,x,y);
+}
+}
+function PromiseHandle(y,D,E){
+try{
+%DebugPushPromise(E.promise,PromiseHandle);
+var F=D(y);
+E.resolve(F);
+}catch(exception){
+try{E.reject(exception);}catch(e){}
+}finally{
+%DebugPopPromise();
+}
+}
+function PromiseEnqueue(y,C,x){
+var G,H,I=(%_DebugIsActive()!=0);
+%EnqueueMicrotask(function(){
+if(I){
+%DebugAsyncTaskEvent({type:"willHandle",id:G,name:H});
+}
+for(var J=0;J<C.length;J+=2){
+PromiseHandle(y,C[J],C[J+1])
+}
+if(I){
+%DebugAsyncTaskEvent({type:"didHandle",id:G,name:H});
+}
+});
+if(I){
+G=++p;
+H=x>0?"Promise.resolve":"Promise.reject";
+%DebugAsyncTaskEvent({type:"enqueue",id:G,name:H});
+}
+}
+function PromiseIdResolveHandler(K){return K}
+function PromiseIdRejectHandler(L){throw L}
+function PromiseNopResolver(){}
+function IsPromise(K){
+return(%_IsJSReceiver(K))&&(!(K[k]===(void 0)));
+}
+function PromiseCreate(){
+return new u(PromiseNopResolver)
+}
+function PromiseResolve(q,K){
+if(K===q){
+return PromiseReject(q,e(92,K));
+}
+if((%_IsJSReceiver(K))){
+try{
+var M=K.then;
+}catch(e){
+return PromiseReject(q,e);
+}
+if((typeof(M)==='function')){
+var G,H,I=(%_DebugIsActive()!=0);
+%EnqueueMicrotask(function(){
+if(I){
+%DebugAsyncTaskEvent({type:"willHandle",id:G,name:H});
+}
+var w=CreateResolvingFunctions(q);
+try{
+%_Call(M,K,w.resolve,w.reject);
+}catch(e){
+%_Call(w.reject,(void 0),e);
+}
+if(I){
+%DebugAsyncTaskEvent({type:"didHandle",id:G,name:H});
+}
+});
+if(I){
+G=++p;
+H="PromseResolveThenableJob";
+%DebugAsyncTaskEvent({type:"enqueue",id:G,name:H});
+}
+return;
+}
+}
+PromiseDone(q,+1,K,i);
+}
+function PromiseReject(q,L){
+if((q[k])==0){
+var N=(%_DebugIsActive()!=0);
+if(N||
+!(!(q[g]===(void 0)))){
+%PromiseRejectEvent(q,L,N);
+}
+}
+PromiseDone(q,-1,L,h)
+}
+function NewPromiseCapability(O){
+if(O===u){
+var q=PromiseInit(new u(j));
+var w=CreateResolvingFunctions(q);
+return{
+promise:q,
+resolve:w.resolve,
+reject:w.reject
+};
+}
+var F={promise:(void 0),resolve:(void 0),reject:(void 0)};
+F.promise=new O((s,t)=>{
+if(!(F.resolve===(void 0))||!(F.reject===(void 0)))
+throw e(93);
+F.resolve=s;
+F.reject=t;
+});
+if(!(typeof(F.resolve)==='function')||!(typeof(F.reject)==='function'))
+throw e(94);
+return F;
+}
+function PromiseDeferred(){
+%IncrementUseCounter(19);
+return NewPromiseCapability(this);
+}
+function PromiseResolved(K){
+%IncrementUseCounter(18);
+return %_Call(PromiseCast,this,K);
+}
+function PromiseRejected(L){
+if(!(%_IsJSReceiver(this))){
+throw e(17,PromiseRejected);
+}
+if(this===u){
+var q=PromiseCreateAndSet(-1,L);
+%PromiseRejectEvent(q,L,false);
+return q;
+}else{
+var P=NewPromiseCapability(this);
+%_Call(P.reject,(void 0),L);
+return P.promise;
+}
+}
+function PromiseThen(z,A){
+var x=(this[k]);
+if((x===(void 0))){
+throw e(65,this);
+}
+var Q=m(this,u);
+z=(typeof(z)==='function')?z:PromiseIdResolveHandler;
+A=(typeof(A)==='function')?A:PromiseIdRejectHandler;
+var E=NewPromiseCapability(Q);
+switch(x){
+case 0:
+(this[i]).push(z,E);
+(this[h]).push(A,E);
+break;
+case+1:
+PromiseEnqueue((this[l]),
+[z,E],
++1);
+break;
+case-1:
+if(!(!(this[g]===(void 0)))){
+%PromiseRevokeReject(this);
+}
+PromiseEnqueue((this[l]),
+[A,E],
+-1);
+break;
+}
+(this[g]=true);
+return E.promise;
+}
+function PromiseChain(z,A){
+%IncrementUseCounter(17);
+return %_Call(PromiseThen,this,z,A);
+}
+function PromiseCatch(A){
+return this.then((void 0),A);
+}
+function PromiseCast(K){
+if(!(%_IsJSReceiver(this))){
+throw e(17,PromiseCast);
+}
+if(IsPromise(K)&&K.constructor===this)return K;
+var P=NewPromiseCapability(this);
+var R=%_Call(P.resolve,(void 0),K);
+return P.promise;
+}
+function PromiseAll(S){
+if(!(%_IsJSReceiver(this))){
+throw e(17,"Promise.all");
+}
+var E=NewPromiseCapability(this);
+var T=new d();
+var U;
+function CreateResolveElementFunction(V,W,P){
+var X=false;
+return(K)=>{
+if(X===true)return;
+X=true;
+W[V]=K;
+if(--U===0){
+var Y=[];
+%MoveArrayContents(W,Y);
+%_Call(P.resolve,(void 0),Y);
+}
+};
+}
+try{
+var J=0;
+U=1;
+for(var y of S){
+var Z=this.resolve(y);
+++U;
+Z.then(
+CreateResolveElementFunction(J,T,E),
+E.reject);
+(E.reject[f]=E);
+++J;
+}
+if(--U===0){
+var Y=[];
+%MoveArrayContents(T,Y);
+%_Call(E.resolve,(void 0),Y);
+}
+}catch(e){
+%_Call(E.reject,(void 0),e);
+}
+return E.promise;
+}
+function PromiseRace(S){
+if(!(%_IsJSReceiver(this))){
+throw e(17,PromiseRace);
+}
+var E=NewPromiseCapability(this);
+try{
+for(var y of S){
+this.resolve(y).then(E.resolve,E.reject);
+(E.reject[f]=E);
+}
+}catch(e){
+E.reject(e)
+}
+return E.promise;
+}
+function PromiseHasUserDefinedRejectHandlerRecursive(q){
+var aa=(q[h]);
+if((aa===(void 0)))return false;
+for(var J=0;J<aa.length;J+=2){
+var D=aa[J];
+if(D!==PromiseIdRejectHandler){
+var E=(D[f]);
+if((E===(void 0)))return true;
+if(PromiseHasUserDefinedRejectHandlerRecursive(E.promise)){
+return true;
+}
+}else if(PromiseHasUserDefinedRejectHandlerRecursive(
+aa[J+1].promise)){
+return true;
+}
+}
+return false;
+}
+function PromiseHasUserDefinedRejectHandler(){
+return PromiseHasUserDefinedRejectHandlerRecursive(this);
+};
+%AddNamedProperty(a,'Promise',u,2);
+%AddNamedProperty(u.prototype,n,"Promise",
+2|1);
+b.InstallFunctions(u,2,[
+"reject",PromiseRejected,
+"all",PromiseAll,
+"race",PromiseRace,
+"resolve",PromiseCast
+]);
+b.InstallFunctions(u.prototype,2,[
+"then",PromiseThen,
+"catch",PromiseCatch
+]);
+%InstallToContext([
+"promise_catch",PromiseCatch,
+"promise_chain",PromiseChain,
+"promise_create",PromiseCreate,
+"promise_has_user_defined_reject_handler",PromiseHasUserDefinedRejectHandler,
+"promise_reject",PromiseReject,
+"promise_resolve",PromiseResolve,
+"promise_then",PromiseThen,
+]);
+b.InstallFunctions(c,0,[
+"createPromise",PromiseCreate,
+"resolvePromise",PromiseResolve,
+"rejectPromise",PromiseReject
+]);
+[PromiseChain,PromiseDeferred,PromiseResolved].forEach(
+fn=>%FunctionRemovePrototype(fn));
+b.Export(function(ab){
+ab.PromiseChain=PromiseChain;
+ab.PromiseDeferred=PromiseDeferred;
+ab.PromiseResolved=PromiseResolved;
+});
+})
+
+ messagesU�
+(function(a,b){
+%CheckIsBootstrapping();
+var c;
+var d;
+var e;
+var f;
+var g=
+b.ImportNow("call_site_receiver_symbol");
+var h=
+b.ImportNow("call_site_function_symbol");
+var i=
+b.ImportNow("call_site_position_symbol");
+var j=
+b.ImportNow("call_site_strict_symbol");
+var k;
+var l=
+b.ImportNow("formatted_stack_trace_symbol");
+var m=a.Object;
+var n;
+var o;
+var p;
+var q=b.InternalArray;
+var r=b.ImportNow("internal_error_symbol");
+var s;
+var t;
+var u=b.ImportNow("object_to_string");
+var v=b.ImportNow("Script");
+var w=b.ImportNow("stack_trace_symbol");
+var x;
+var y;
+var z;
+var A;
+var B=b.ImportNow("to_string_tag_symbol");
+var C;
+var D;
+var E;
+b.Import(function(F){
+c=F.ArrayJoin;
+d=F.Bool16x8ToString;
+e=F.Bool32x4ToString;
+f=F.Bool8x16ToString;
+k=F.Float32x4ToString;
+n=F.Int16x8ToString;
+o=F.Int32x4ToString;
+p=F.Int8x16ToString;
+s=F.ObjectDefineProperty;
+t=F.ObjectHasOwnProperty;
+x=F.StringCharAt;
+y=F.StringIndexOf;
+z=F.StringSubstring;
+A=F.SymbolToString;
+C=F.Uint16x8ToString;
+D=F.Uint32x4ToString;
+E=F.Uint8x16ToString;
+});
+var G;
+var H;
+var I;
+var J;
+var K;
+var L;
+var M;
+function NoSideEffectsObjectToString(){
+if((this===(void 0)))return"[object Undefined]";
+if((this===null))return"[object Null]";
+var N=(%_ToObject(this));
+var O=%_ClassOf(N);
+var P=%GetDataProperty(N,B);
+if(!(typeof(P)==='string')){
+P=O;
+}
+return`[object ${P}]`;
+}
+function IsErrorObject(Q){
+return(%_Call(t,Q,w));
+}
+function NoSideEffectsErrorToString(){
+var R=%GetDataProperty(this,"name");
+var S=%GetDataProperty(this,"message");
+R=(R===(void 0))?"Error":NoSideEffectsToString(R);
+S=(S===(void 0))?"":NoSideEffectsToString(S);
+if(R=="")return S;
+if(S=="")return R;
+return`${R}: ${S}`;
+}
+function NoSideEffectsToString(Q){
+if((typeof(Q)==='string'))return Q;
+if((typeof(Q)==='number'))return %_NumberToString(Q);
+if((typeof(Q)==='boolean'))return Q?'true':'false';
+if((Q===(void 0)))return'undefined';
+if((Q===null))return'null';
+if((%IsFunction(Q))){
+var T=%FunctionToString(Q);
+if(T.length>128){
+T=%_SubString(T,0,111)+"...<omitted>..."+
+%_SubString(T,T.length-2,T.length);
+}
+return T;
+}
+if((typeof(Q)==='symbol'))return %_Call(A,Q);
+if((%IsSimdValue(Q))){
+switch(typeof(Q)){
+case'float32x4':return %_Call(k,Q);
+case'int32x4':return %_Call(o,Q);
+case'int16x8':return %_Call(n,Q);
+case'int8x16':return %_Call(p,Q);
+case'uint32x4':return %_Call(D,Q);
+case'uint16x8':return %_Call(C,Q);
+case'uint8x16':return %_Call(E,Q);
+case'bool32x4':return %_Call(e,Q);
+case'bool16x8':return %_Call(d,Q);
+case'bool8x16':return %_Call(f,Q);
+}
+}
+if((%_IsJSReceiver(Q))){
+if(IsErrorObject(Q)||
+%GetDataProperty(Q,"toString")===ErrorToString){
+return %_Call(NoSideEffectsErrorToString,Q);
+}
+if(%GetDataProperty(Q,"toString")===u){
+var U=%GetDataProperty(Q,"constructor");
+if((%IsFunction(U))){
+var V=%FunctionGetName(U);
+if(V!="")return`#<${V}>`;
+}
+}
+}
+return %_Call(NoSideEffectsObjectToString,Q);
+}
+function MakeGenericError(U,W,X,Y,Z){
+var aa=new U(FormatMessage(W,X,Y,Z));
+aa[r]=true;
+return aa;
+}
+%FunctionSetInstanceClassName(v,'Script');
+%AddNamedProperty(v.prototype,'constructor',v,
+2|4|1);
+%SetCode(v,function(ab){
+throw MakeError(6);
+});
+function FormatMessage(W,X,Y,Z){
+var X=NoSideEffectsToString(X);
+var Y=NoSideEffectsToString(Y);
+var Z=NoSideEffectsToString(Z);
+try{
+return %FormatMessageString(W,X,Y,Z);
+}catch(e){
+return"<error>";
+}
+}
+function GetLineNumber(S){
+var ac=%MessageGetStartPosition(S);
+if(ac==-1)return 0;
+var ad=%MessageGetScript(S);
+var ae=ad.locationFromPosition(ac,true);
+if(ae==null)return 0;
+return ae.line+1;
+}
+function GetColumnNumber(S){
+var ad=%MessageGetScript(S);
+var ac=%MessageGetStartPosition(S);
+var ae=ad.locationFromPosition(ac,true);
+if(ae==null)return-1;
+return ae.column;
+}
+function GetSourceLine(S){
+var ad=%MessageGetScript(S);
+var ac=%MessageGetStartPosition(S);
+var ae=ad.locationFromPosition(ac,true);
+if(ae==null)return"";
+return ae.sourceText();
+}
+function ScriptLineFromPosition(af){
+var ag=0;
+var ah=this.lineCount()-1;
+var ai=this.line_ends;
+if(af>ai[ah]){
+return-1;
+}
+if(af<=ai[0]){
+return 0;
+}
+while(ah>=1){
+var aj=(ag+ah)>>1;
+if(af>ai[aj]){
+ag=aj+1;
+}else if(af<=ai[aj-1]){
+ah=aj-1;
+}else{
+return aj;
+}
+}
+return-1;
+}
+function ScriptLocationFromPosition(af,
+include_resource_offset){
+var ak=this.lineFromPosition(af);
+if(ak==-1)return null;
+var ai=this.line_ends;
+var al=ak==0?0:ai[ak-1]+1;
+var am=ai[ak];
+if(am>0&&%_Call(x,this.source,am-1)=='\r'){
+am--;
+}
+var an=af-al;
+if(include_resource_offset){
+ak+=this.line_offset;
+if(ak==this.line_offset){
+an+=this.column_offset;
+}
+}
+return new SourceLocation(this,af,ak,an,al,am);
+}
+function ScriptLocationFromLine(ao,ap,aq){
+var ak=0;
+if(!(ao===(void 0))){
+ak=ao-this.line_offset;
+}
+var an=ap||0;
+if(ak==0){
+an-=this.column_offset;
+}
+var ar=aq||0;
+if(ak<0||an<0||ar<0)return null;
+if(ak==0){
+return this.locationFromPosition(ar+an,false);
+}else{
+var as=this.lineFromPosition(ar);
+if(as==-1||as+ak>=this.lineCount()){
+return null;
+}
+return this.locationFromPosition(
+this.line_ends[as+ak-1]+1+an);
+}
+}
+function ScriptSourceSlice(at,au){
+var av=(at===(void 0))?this.line_offset
+:at;
+var aw=(au===(void 0))?this.line_offset+this.lineCount()
+:au;
+av-=this.line_offset;
+aw-=this.line_offset;
+if(av<0)av=0;
+if(aw>this.lineCount())aw=this.lineCount();
+if(av>=this.lineCount()||
+aw<0||
+av>aw){
+return null;
+}
+var ai=this.line_ends;
+var ax=av==0?0:ai[av-1]+1;
+var ay=aw==0?0:ai[aw-1]+1;
+return new SourceSlice(this,
+av+this.line_offset,
+aw+this.line_offset,
+ax,ay);
+}
+function ScriptSourceLine(ao){
+var ak=0;
+if(!(ao===(void 0))){
+ak=ao-this.line_offset;
+}
+if(ak<0||this.lineCount()<=ak){
+return null;
+}
+var ai=this.line_ends;
+var al=ak==0?0:ai[ak-1]+1;
+var am=ai[ak];
+return %_Call(z,this.source,al,am);
+}
+function ScriptLineCount(){
+return this.line_ends.length;
+}
+function ScriptLineEnd(az){
+return this.line_ends[az];
+}
+function ScriptNameOrSourceURL(){
+if(this.source_url)return this.source_url;
+return this.name;
+}
+b.SetUpLockedPrototype(v,[
+"source",
+"name",
+"source_url",
+"source_mapping_url",
+"line_ends",
+"line_offset",
+"column_offset"
+],[
+"lineFromPosition",ScriptLineFromPosition,
+"locationFromPosition",ScriptLocationFromPosition,
+"locationFromLine",ScriptLocationFromLine,
+"sourceSlice",ScriptSourceSlice,
+"sourceLine",ScriptSourceLine,
+"lineCount",ScriptLineCount,
+"nameOrSourceURL",ScriptNameOrSourceURL,
+"lineEnd",ScriptLineEnd
+]
+);
+function SourceLocation(ad,af,ak,an,al,am){
+this.script=ad;
+this.position=af;
+this.line=ak;
+this.column=an;
+this.start=al;
+this.end=am;
+}
+function SourceLocationSourceText(){
+return %_Call(z,this.script.source,this.start,this.end);
+}
+b.SetUpLockedPrototype(SourceLocation,
+["script","position","line","column","start","end"],
+["sourceText",SourceLocationSourceText]
+);
+function SourceSlice(ad,av,aw,ax,ay){
+this.script=ad;
+this.from_line=av;
+this.to_line=aw;
+this.from_position=ax;
+this.to_position=ay;
+}
+function SourceSliceSourceText(){
+return %_Call(z,
+this.script.source,
+this.from_position,
+this.to_position);
+}
+b.SetUpLockedPrototype(SourceSlice,
+["script","from_line","to_line","from_position","to_position"],
+["sourceText",SourceSliceSourceText]
+);
+function GetStackTraceLine(aA,aB,aC,aD){
+return new CallSite(aA,aB,aC,false).toString();
+}
+function CallSite(aE,aB,aC,aF){
+if(!(%IsFunction(aB))){
+throw MakeTypeError(19,typeof aB);
+}
+if((new.target===(void 0))){
+return new CallSite(aE,aB,aC,aF);
+}
+(this[g]=aE);
+(this[h]=aB);
+(this[i]=((aC)|0));
+(this[j]=(!!(aF)));
+}
+function CheckCallSite(Q,R){
+if(!(%_IsJSReceiver(Q))||!(%_Call(t,Q,h))){
+throw MakeTypeError(20,R);
+}
+}
+function CallSiteGetThis(){
+CheckCallSite(this,"getThis");
+return(this[j])
+?(void 0):(this[g]);
+}
+function CallSiteGetFunction(){
+CheckCallSite(this,"getFunction");
+return(this[j])
+?(void 0):(this[h]);
+}
+function CallSiteGetPosition(){
+CheckCallSite(this,"getPosition");
+return(this[i]);
+}
+function CallSiteGetTypeName(){
+CheckCallSite(this,"getTypeName");
+return GetTypeName((this[g]),false);
+}
+function CallSiteIsToplevel(){
+CheckCallSite(this,"isTopLevel");
+return %CallSiteIsToplevelRT(this);
+}
+function CallSiteIsEval(){
+CheckCallSite(this,"isEval");
+return %CallSiteIsEvalRT(this);
+}
+function CallSiteGetEvalOrigin(){
+CheckCallSite(this,"getEvalOrigin");
+var ad=%FunctionGetScript((this[h]));
+return FormatEvalOrigin(ad);
+}
+function CallSiteGetScriptNameOrSourceURL(){
+CheckCallSite(this,"getScriptNameOrSourceURL");
+return %CallSiteGetScriptNameOrSourceUrlRT(this);
+}
+function CallSiteGetFunctionName(){
+CheckCallSite(this,"getFunctionName");
+return %CallSiteGetFunctionNameRT(this);
+}
+function CallSiteGetMethodName(){
+CheckCallSite(this,"getMethodName");
+return %CallSiteGetMethodNameRT(this);
+}
+function CallSiteGetFileName(){
+CheckCallSite(this,"getFileName");
+return %CallSiteGetFileNameRT(this);
+}
+function CallSiteGetLineNumber(){
+CheckCallSite(this,"getLineNumber");
+return %CallSiteGetLineNumberRT(this);
+}
+function CallSiteGetColumnNumber(){
+CheckCallSite(this,"getColumnNumber");
+return %CallSiteGetColumnNumberRT(this);
+}
+function CallSiteIsNative(){
+CheckCallSite(this,"isNative");
+return %CallSiteIsNativeRT(this);
+}
+function CallSiteIsConstructor(){
+CheckCallSite(this,"isConstructor");
+return %CallSiteIsConstructorRT(this);
+}
+function CallSiteToString(){
+var aG;
+var aH="";
+if(this.isNative()){
+aH="native";
+}else{
+aG=this.getScriptNameOrSourceURL();
+if(!aG&&this.isEval()){
+aH=this.getEvalOrigin();
+aH+=", ";
+}
+if(aG){
+aH+=aG;
+}else{
+aH+="<anonymous>";
+}
+var aI=this.getLineNumber();
+if(aI!=null){
+aH+=":"+aI;
+var aJ=this.getColumnNumber();
+if(aJ){
+aH+=":"+aJ;
+}
+}
+}
+var ak="";
+var aK=this.getFunctionName();
+var aL=true;
+var aM=this.isConstructor();
+var aN=!(this.isToplevel()||aM);
+if(aN){
+var aO=GetTypeName((this[g]),true);
+var aP=this.getMethodName();
+if(aK){
+if(aO&&%_Call(y,aK,aO)!=0){
+ak+=aO+".";
+}
+ak+=aK;
+if(aP&&
+(%_Call(y,aK,"."+aP)!=
+aK.length-aP.length-1)){
+ak+=" [as "+aP+"]";
+}
+}else{
+ak+=aO+"."+(aP||"<anonymous>");
+}
+}else if(aM){
+ak+="new "+(aK||"<anonymous>");
+}else if(aK){
+ak+=aK;
+}else{
+ak+=aH;
+aL=false;
+}
+if(aL){
+ak+=" ("+aH+")";
+}
+return ak;
+}
+b.SetUpLockedPrototype(CallSite,["receiver","fun","pos"],[
+"getThis",CallSiteGetThis,
+"getTypeName",CallSiteGetTypeName,
+"isToplevel",CallSiteIsToplevel,
+"isEval",CallSiteIsEval,
+"getEvalOrigin",CallSiteGetEvalOrigin,
+"getScriptNameOrSourceURL",CallSiteGetScriptNameOrSourceURL,
+"getFunction",CallSiteGetFunction,
+"getFunctionName",CallSiteGetFunctionName,
+"getMethodName",CallSiteGetMethodName,
+"getFileName",CallSiteGetFileName,
+"getLineNumber",CallSiteGetLineNumber,
+"getColumnNumber",CallSiteGetColumnNumber,
+"isNative",CallSiteIsNative,
+"getPosition",CallSiteGetPosition,
+"isConstructor",CallSiteIsConstructor,
+"toString",CallSiteToString
+]);
+function FormatEvalOrigin(ad){
+var aQ=ad.nameOrSourceURL();
+if(aQ){
+return aQ;
+}
+var aR="eval at ";
+if(ad.eval_from_function_name){
+aR+=ad.eval_from_function_name;
+}else{
+aR+="<anonymous>";
+}
+var aS=ad.eval_from_script;
+if(aS){
+if(aS.compilation_type==1){
+aR+=" ("+FormatEvalOrigin(aS)+")";
+}else{
+if(aS.name){
+aR+=" ("+aS.name;
+var ae=aS.locationFromPosition(
+ad.eval_from_script_position,true);
+if(ae){
+aR+=":"+(ae.line+1);
+aR+=":"+(ae.column+1);
+}
+aR+=")";
+}else{
+aR+=" (unknown source)";
+}
+}
+}
+return aR;
+}
+function FormatErrorString(aa){
+try{
+return %_Call(ErrorToString,aa);
+}catch(e){
+try{
+return"<error: "+e+">";
+}catch(ee){
+return"<error>";
+}
+}
+}
+function GetStackFrames(aT){
+var aU=new q();
+var aV=aT[0];
+for(var aj=1;aj<aT.length;aj+=4){
+var aA=aT[aj];
+var aB=aT[aj+1];
+var aW=aT[aj+2];
+var aX=aT[aj+3];
+var aC=%_IsSmi(aW)?aW:%FunctionGetPositionForOffset(aW,aX);
+aV--;
+aU.push(new CallSite(aA,aB,aC,(aV<0)));
+}
+return aU;
+}
+var aY=false;
+function FormatStackTrace(Q,aT){
+var aU=GetStackFrames(aT);
+if((%IsFunction(G.prepareStackTrace))&&
+!aY){
+var aZ=[];
+%MoveArrayContents(aU,aZ);
+aY=true;
+var ba=(void 0);
+try{
+ba=G.prepareStackTrace(Q,aZ);
+}catch(e){
+throw e;
+}finally{
+aY=false;
+}
+return ba;
+}
+var bb=new q();
+bb.push(FormatErrorString(Q));
+for(var aj=0;aj<aU.length;aj++){
+var bc=aU[aj];
+var ak;
+try{
+ak=bc.toString();
+}catch(e){
+try{
+ak="<error: "+e+">";
+}catch(ee){
+ak="<error>";
+}
+}
+bb.push("    at "+ak);
+}
+return %_Call(c,bb,"\n");
+}
+function GetTypeName(aE,bd){
+if((aE==null))return null;
+if((%_IsJSProxy(aE)))return"Proxy";
+var U=%GetDataProperty((%_ToObject(aE)),"constructor");
+if(!(%IsFunction(U))){
+return bd?null:%_Call(NoSideEffectsToString,aE);
+}
+return %FunctionGetName(U);
+}
+var be=function(){
+var bf=(void 0);
+var bg=this;
+while(bg){
+var bf=
+(bg[l]);
+if((bf===(void 0))){
+var ba=(bg[w]);
+if((ba===(void 0))){
+bg=%_GetPrototype(bg);
+continue;
+}
+bf=FormatStackTrace(bg,ba);
+(bg[w]=(void 0));
+(bg[l]=bf);
+}
+return bf;
+}
+return(void 0);
+};
+var bh=function(bi){
+if(IsErrorObject(this)){
+(this[w]=(void 0));
+(this[l]=bi);
+}
+};
+var bj=function(){};
+function SetUpError(bk){
+%FunctionSetInstanceClassName(bk,'Error');
+var R=bk.name;
+var bl=new m();
+if(R!=='Error'){
+%InternalSetPrototype(bk,G);
+%InternalSetPrototype(bl,G.prototype);
+}
+%FunctionSetPrototype(bk,bl);
+%AddNamedProperty(bk.prototype,'name',R,2);
+%AddNamedProperty(bk.prototype,'message','',2);
+%AddNamedProperty(
+bk.prototype,'constructor',bk,2);
+%SetCode(bk,function(bm){
+if((new.target===(void 0)))return new bk(bm);
+try{bj(this,bk);}catch(e){}
+if(!(bm===(void 0))){
+%AddNamedProperty(this,'message',(%_ToString(bm)),2);
+}
+});
+%SetNativeFlag(bk);
+return bk;
+};
+G=SetUpError(a.Error);
+M=SetUpError(a.EvalError);
+I=SetUpError(a.RangeError);
+L=SetUpError(a.ReferenceError);
+K=SetUpError(a.SyntaxError);
+H=SetUpError(a.TypeError);
+J=SetUpError(a.URIError);
+b.InstallFunctions(G.prototype,2,
+['toString',ErrorToString]);
+function ErrorToString(){
+if(!(%_IsJSReceiver(this))){
+throw MakeTypeError(17,"Error.prototype.toString");
+}
+var R=this.name;
+R=(R===(void 0))?"Error":(%_ToString(R));
+var S=this.message;
+S=(S===(void 0))?"":(%_ToString(S));
+if(R=="")return S;
+if(S=="")return R;
+return`${R}: ${S}`
+}
+function MakeError(W,X,Y,Z){
+return MakeGenericError(G,W,X,Y,Z);
+}
+function MakeRangeError(W,X,Y,Z){
+return MakeGenericError(I,W,X,Y,Z);
+}
+function MakeSyntaxError(W,X,Y,Z){
+return MakeGenericError(K,W,X,Y,Z);
+}
+function MakeTypeError(W,X,Y,Z){
+return MakeGenericError(H,W,X,Y,Z);
+}
+function MakeURIError(){
+return MakeGenericError(J,277);
+}
+var bn=MakeRangeError(186);
+b.InstallGetterSetter(bn,'stack',
+be,bh)
+bj=function captureStackTrace(Q,bo){
+s(Q,'stack',{get:be,
+set:bh,
+configurable:true});
+%CollectStackTrace(Q,bo?bo:bj);
+};
+G.captureStackTrace=bj;
+%InstallToContext([
+"get_stack_trace_line_fun",GetStackTraceLine,
+"make_error_function",MakeGenericError,
+"make_range_error",MakeRangeError,
+"make_type_error",MakeTypeError,
+"message_get_column_number",GetColumnNumber,
+"message_get_line_number",GetLineNumber,
+"message_get_source_line",GetSourceLine,
+"no_side_effects_to_string_fun",NoSideEffectsToString,
+"stack_overflow_boilerplate",bn,
+]);
+b.Export(function(bp){
+bp.ErrorToString=ErrorToString;
+bp.MakeError=MakeError;
+bp.MakeRangeError=MakeRangeError;
+bp.MakeSyntaxError=MakeSyntaxError;
+bp.MakeTypeError=MakeTypeError;
+bp.MakeURIError=MakeURIError;
+});
+});
+
+json�H
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Date;
+var d=a.JSON;
+var e=a.Set;
+var f=b.InternalArray;
+var g;
+var h;
+var i;
+var j;
+var k;
+var l;
+var m;
+var n;
+var o=b.ImportNow("to_string_tag_symbol");
+b.Import(function(p){
+g=p.MakeTypeError;
+h=p.MaxSimple;
+i=p.MinSimple;
+j=p.ObjectHasOwnProperty;
+k=p.Stack;
+l=p.StackHas;
+m=p.StackPop;
+n=p.StackPush;
+});
+function CreateDataProperty(q,r,s){
+var t={value:s,enumerable:true,writable:true,configurable:true};
+return %reflect_define_property(q,r,t);
+}
+function InternalizeJSONProperty(u,v,w){
+var x=u[v];
+if((%_IsJSReceiver(x))){
+if(%is_arraylike(x)){
+var y=(%_ToLength(x.length));
+for(var z=0;z<y;z++){
+var A=
+InternalizeJSONProperty(x,%_NumberToString(z),w);
+if((A===(void 0))){
+%reflect_delete_property(x,z);
+}else{
+CreateDataProperty(x,z,A);
+}
+}
+}else{
+var B=%object_keys(x);
+for(var z=0;z<B.length;z++){
+var r=B[z];
+var A=InternalizeJSONProperty(x,r,w);
+if((A===(void 0))){
+%reflect_delete_property(x,r);
+}else{
+CreateDataProperty(x,r,A);
+}
+}
+}
+}
+return %_Call(w,u,v,x);
+}
+function JSONParse(C,w){
+var D=%ParseJson(C);
+if((typeof(w)==='function')){
+return InternalizeJSONProperty({'':D},'',w);
+}else{
+return D;
+}
+}
+function SerializeArray(E,F,G,H,I){
+if(l(G,E))throw g(24);
+n(G,E);
+var J=H;
+H+=I;
+var K=new f();
+var L=(%_ToLength(E.length));
+for(var z=0;z<L;z++){
+var M=JSONSerialize(%_NumberToString(z),E,F,G,
+H,I);
+if((M===(void 0))){
+M="null";
+}
+K.push(M);
+}
+var N;
+if(I==""){
+N="["+K.join(",")+"]";
+}else if(K.length>0){
+var O=",\n"+H;
+N="[\n"+H+K.join(O)+"\n"+
+J+"]";
+}else{
+N="[]";
+}
+m(G);
+return N;
+}
+function SerializeObject(E,F,G,H,I){
+if(l(G,E))throw g(24);
+n(G,E);
+var J=H;
+H+=I;
+var K=new f();
+if((%_IsArray(F))){
+var y=F.length;
+for(var z=0;z<y;z++){
+var r=F[z];
+var M=JSONSerialize(r,E,F,G,H,I);
+if(!(M===(void 0))){
+var P=%QuoteJSONString(r)+":";
+if(I!="")P+=" ";
+P+=M;
+K.push(P);
+}
+}
+}else{
+var B=%object_keys(E);
+for(var z=0;z<B.length;z++){
+var r=B[z];
+var M=JSONSerialize(r,E,F,G,H,I);
+if(!(M===(void 0))){
+var P=%QuoteJSONString(r)+":";
+if(I!="")P+=" ";
+P+=M;
+K.push(P);
+}
+}
+}
+var N;
+if(I==""){
+N="{"+K.join(",")+"}";
+}else if(K.length>0){
+var O=",\n"+H;
+N="{\n"+H+K.join(O)+"\n"+
+J+"}";
+}else{
+N="{}";
+}
+m(G);
+return N;
+}
+function JSONSerialize(Q,u,F,G,H,I){
+var E=u[Q];
+if((%_IsJSReceiver(E))){
+var R=E.toJSON;
+if((typeof(R)==='function')){
+E=%_Call(R,E,Q);
+}
+}
+if((typeof(F)==='function')){
+E=%_Call(F,u,Q,E);
+}
+if((typeof(E)==='string')){
+return %QuoteJSONString(E);
+}else if((typeof(E)==='number')){
+return((%_IsSmi(%IS_VAR(E))||E-E==0)?%_NumberToString(E):"null");
+}else if((typeof(E)==='boolean')){
+return E?"true":"false";
+}else if((E===null)){
+return"null";
+}else if((%_IsJSReceiver(E))&&!(typeof(E)==='function')){
+if(%is_arraylike(E)){
+return SerializeArray(E,F,G,H,I);
+}else if((%_ClassOf(E)==='Number')){
+E=(%_ToNumber(E));
+return((%_IsSmi(%IS_VAR(E))||E-E==0)?%_NumberToString(E):"null");
+}else if((%_ClassOf(E)==='String')){
+return %QuoteJSONString((%_ToString(E)));
+}else if((%_ClassOf(E)==='Boolean')){
+return %_ValueOf(E)?"true":"false";
+}else{
+return SerializeObject(E,F,G,H,I);
+}
+}
+return(void 0);
+}
+function JSONStringify(E,F,S){
+if(arguments.length===1&&!(%_IsJSProxy(E))){
+return %BasicJSONStringify(E);
+}
+if(!(typeof(F)==='function')&&%is_arraylike(F)){
+var T=new f();
+var U=new e();
+var y=(%_ToLength(F.length));
+for(var z=0;z<y;z++){
+var s=F[z];
+var V;
+if((typeof(s)==='string')){
+V=s;
+}else if((typeof(s)==='number')){
+V=%_NumberToString(s);
+}else if((%_ClassOf(s)==='String')||(%_ClassOf(s)==='Number')){
+V=(%_ToString(s));
+}else{
+continue;
+}
+if(!U.has(V)){
+T.push(V);
+U.add(V);
+}
+}
+F=T;
+}
+if((typeof(S)==='object')){
+if((%_ClassOf(S)==='Number')){
+S=(%_ToNumber(S));
+}else if((%_ClassOf(S)==='String')){
+S=(%_ToString(S));
+}
+}
+var I;
+if((typeof(S)==='number')){
+S=h(0,i((%_ToInteger(S)),10));
+I=%_SubString("          ",0,S);
+}else if((typeof(S)==='string')){
+if(S.length>10){
+I=%_SubString(S,0,10);
+}else{
+I=S;
+}
+}else{
+I="";
+}
+if(!(typeof(F)==='function')&&!T&&!I&&!(%_IsJSProxy(E))){
+return %BasicJSONStringify(E);
+}
+return JSONSerialize('',{'':E},F,new k(),"",I);
+}
+%AddNamedProperty(d,o,"JSON",1|2);
+b.InstallFunctions(d,2,[
+"parse",JSONParse,
+"stringify",JSONStringify
+]);
+function DateToJSON(Q){
+var q=(%_ToObject(this));
+var W=(%_ToPrimitive_Number(q));
+if((typeof(W)==='number')&&!(%_IsSmi(%IS_VAR(W))||((W==W)&&(W!=1/0)&&(W!=-1/0)))){
+return null;
+}
+return q.toISOString();
+}
+b.InstallFunctions(c.prototype,2,[
+"toJSON",DateToJSON
+]);
+function JsonSerializeAdapter(Q,X){
+var u={};
+u[Q]=X;
+return JSONSerialize(Q,u,(void 0),new k(),"","");
+}
+%InstallToContext(["json_serialize_adapter",JsonSerializeAdapter]);
+})
+
+8array-iterator�#
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=
+b.ImportNow("array_iteration_kind_symbol");
+var d=
+b.ImportNow("array_iterator_next_symbol");
+var e=
+b.ImportNow("array_iterator_object_symbol");
+var f=a.Array;
+var g=b.ImportNow("IteratorPrototype");
+var h=b.ImportNow("iterator_symbol");
+var i;
+var j=b.ImportNow("to_string_tag_symbol");
+var k=a.Uint8Array.__proto__;
+b.Import(function(l){
+i=l.MakeTypeError;
+})
+function ArrayIterator(){}
+function CreateArrayIterator(m,n){
+var o=(%_ToObject(m));
+var p=new ArrayIterator;
+(p[e]=o);
+(p[d]=0);
+(p[c]=n);
+return p;
+}
+function ArrayIteratorIterator(){
+return this;
+}
+function ArrayIteratorNext(){
+var p=this;
+var q=(void 0);
+var r=true;
+if(!(%_IsJSReceiver(p))||
+!(!(p[d]===(void 0)))){
+throw i(44,
+'Array Iterator.prototype.next',this);
+}
+var m=(p[e]);
+if(!(m===(void 0))){
+var s=(p[d]);
+var t=(p[c]);
+var u=((m.length)>>>0);
+if(s>=u){
+(p[e]=(void 0));
+}else{
+(p[d]=s+1);
+if(t==2){
+q=m[s];
+}else if(t==3){
+q=[s,m[s]];
+}else{
+q=s;
+}
+r=false;
+}
+}
+return %_CreateIterResultObject(q,r);
+}
+function ArrayEntries(){
+return CreateArrayIterator(this,3);
+}
+function ArrayValues(){
+return CreateArrayIterator(this,2);
+}
+function ArrayKeys(){
+return CreateArrayIterator(this,1);
+}
+function TypedArrayEntries(){
+if(!(%_IsTypedArray(this)))throw i(72);
+return %_Call(ArrayEntries,this);
+}
+function TypedArrayValues(){
+if(!(%_IsTypedArray(this)))throw i(72);
+return %_Call(ArrayValues,this);
+}
+function TypedArrayKeys(){
+if(!(%_IsTypedArray(this)))throw i(72);
+return %_Call(ArrayKeys,this);
+}
+%FunctionSetPrototype(ArrayIterator,{__proto__:g});
+%FunctionSetInstanceClassName(ArrayIterator,'Array Iterator');
+b.InstallFunctions(ArrayIterator.prototype,2,[
+'next',ArrayIteratorNext
+]);
+b.SetFunctionName(ArrayIteratorIterator,h);
+%AddNamedProperty(ArrayIterator.prototype,j,
+"Array Iterator",1|2);
+b.InstallFunctions(f.prototype,2,[
+'entries',ArrayEntries,
+'keys',ArrayKeys
+]);
+b.SetFunctionName(ArrayValues,'values');
+%AddNamedProperty(f.prototype,h,ArrayValues,
+2);
+b.InstallFunctions(k.prototype,2,[
+'entries',TypedArrayEntries,
+'keys',TypedArrayKeys,
+'values',TypedArrayValues
+]);
+%AddNamedProperty(k.prototype,
+h,TypedArrayValues,2);
+b.Export(function(v){
+v.ArrayValues=ArrayValues;
+});
+%InstallToContext(["array_values_iterator",ArrayValues]);
+})
+
+<string-iterator�
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.String;
+var d=b.ImportNow("IteratorPrototype");
+var e=b.ImportNow("iterator_symbol");
+var f;
+var g=
+b.ImportNow("string_iterator_iterated_string_symbol");
+var h=
+b.ImportNow("string_iterator_next_index_symbol");
+var i=b.ImportNow("to_string_tag_symbol");
+b.Import(function(j){
+f=j.MakeTypeError;
+});
+function StringIterator(){}
+function CreateStringIterator(k){
+if((%IS_VAR(k)===null)||(k===(void 0)))throw f(18,'String.prototype[Symbol.iterator]');
+var l=(%_ToString(k));
+var m=new StringIterator;
+(m[g]=l);
+(m[h]=0);
+return m;
+}
+function StringIteratorNext(){
+var m=this;
+var n=(void 0);
+var o=true;
+if(!(%_IsJSReceiver(m))||
+!(!(m[h]===(void 0)))){
+throw f(44,
+'String Iterator.prototype.next');
+}
+var l=(m[g]);
+if(!(l===(void 0))){
+var p=(m[h]);
+var q=((l.length)>>>0);
+if(p>=q){
+(m[g]=(void 0));
+}else{
+var r=%_StringCharCodeAt(l,p);
+n=%_StringCharFromCode(r);
+o=false;
+p++;
+if(r>=0xD800&&r<=0xDBFF&&p<q){
+var s=%_StringCharCodeAt(l,p);
+if(s>=0xDC00&&s<=0xDFFF){
+n+=%_StringCharFromCode(s);
+p++;
+}
+}
+(m[h]=p);
+}
+}
+return %_CreateIterResultObject(n,o);
+}
+function StringPrototypeIterator(){
+return CreateStringIterator(this);
+}
+%FunctionSetPrototype(StringIterator,{__proto__:d});
+%FunctionSetInstanceClassName(StringIterator,'String Iterator');
+b.InstallFunctions(StringIterator.prototype,2,[
+'next',StringIteratorNext
+]);
+%AddNamedProperty(StringIterator.prototype,i,
+"String Iterator",1|2);
+b.SetFunctionName(StringPrototypeIterator,e);
+%AddNamedProperty(c.prototype,e,
+StringPrototypeIterator,2);
+})
+
+$templates
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Map;
+var d=b.InternalArray;
+var e=new c;
+var f=c.prototype.get;
+var g=c.prototype.set;
+function SameCallSiteElements(h,i){
+var j=h.length;
+var i=i.raw;
+if(j!==i.length)return false;
+for(var k=0;k<j;++k){
+if(h[k]!==i[k])return false;
+}
+return true;
+}
+function GetCachedCallSite(l,m){
+var n=%_Call(f,e,m);
+if((n===(void 0)))return;
+var j=n.length;
+for(var k=0;k<j;++k){
+if(SameCallSiteElements(l,n[k]))return n[k];
+}
+}
+function SetCachedCallSite(l,m){
+var n=%_Call(f,e,m);
+var o;
+if((n===(void 0))){
+o=new d(1);
+o[0]=l;
+%_Call(g,e,m,o);
+}else{
+n.push(l);
+}
+return l;
+}
+function GetTemplateCallSite(l,h,m){
+var p=GetCachedCallSite(h,m);
+if(!(p===(void 0)))return p;
+%AddNamedProperty(l,"raw",%object_freeze(h),
+1|2|4);
+return SetCachedCallSite(%object_freeze(l),m);
+}
+%InstallToContext(["get_template_call_site",GetTemplateCallSite]);
+})
+
+spread�
+(function(a,b){
+'use strict';
+var c=b.InternalArray;
+var d;
+b.Import(function(e){
+d=e.MakeTypeError;
+});
+function SpreadArguments(){
+var f=arguments.length;
+var g=new c();
+for(var h=0;h<f;++h){
+var i=arguments[h];
+var j=i.length;
+for(var k=0;k<j;++k){
+g.push(i[k]);
+}
+}
+return g;
+}
+function SpreadIterable(l){
+if((l==null)){
+throw d(70,l);
+}
+var g=new c();
+for(var m of l){
+g.push(m);
+}
+return g;
+}
+%InstallToContext([
+"spread_arguments",SpreadArguments,
+"spread_iterable",SpreadIterable,
+]);
+})
+
+proxy�
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Proxy;
+function ProxyCreateRevocable(d,e){
+var f=new c(d,e);
+return{proxy:f,revoke:()=>%JSProxyRevoke(f)};
+}
+b.InstallFunctions(c,2,[
+"revocable",ProxyCreateRevocable
+]);
+})
+
+i18n��

+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c;
+var d;
+var e;
+var f=a.Boolean;
+var g=a.Date;
+var h=a.Number;
+var i=a.RegExp;
+var j=a.String;
+var k=b.InstallFunctions;
+var l=b.InstallGetter;
+var m=b.InternalPackedArray;
+var n;
+var o
+var p;
+var q;
+var r;
+var s;
+var t;
+var u=b.ImportNow("ObjectDefineProperties");
+var v=b.ImportNow("ObjectDefineProperty");
+var w=b.ImportNow("ObjectHasOwnProperty");
+var x=b.OverrideFunction;
+var y=b.ImportNow("intl_pattern_symbol");
+var z=b.ImportNow("intl_resolved_symbol");
+var A=b.SetFunctionName;
+var B;
+var C;
+var D;
+var E;
+var F;
+b.Import(function(G){
+c=G.ArrayIndexOf;
+d=G.ArrayJoin;
+e=G.ArrayPush;
+p=G.IsFinite;
+q=G.IsNaN;
+r=G.MakeError;
+s=G.MakeRangeError;
+t=G.MakeTypeError;
+n=G.InternalRegExpMatch;
+o=G.InternalRegExpReplace;
+B=G.StringIndexOf;
+C=G.StringLastIndexOf;
+D=G.StringSplit;
+E=G.StringSubstr;
+F=G.StringSubstring;
+});
+function InstallFunction(H,I,J){
+k(H,2,[I,J]);
+}
+function InstallConstructor(H,I,J){
+%CheckIsBootstrapping();
+A(J,I);
+%AddNamedProperty(H,I,J,2);
+%SetNativeFlag(J);
+%ToFastProperties(H);
+}
+function AddBoundMethod(K,L,M,N){
+%CheckIsBootstrapping();
+var O=%CreatePrivateSymbol(L);
+var P=function(){
+if(!%IsInitializedIntlObject(this)){
+throw t(54,L);
+}
+if((this[O]===(void 0))){
+var Q;
+if((N===(void 0))||N===2){
+Q=(x,y)=>M(this,x,y);
+}else if(N===1){
+Q=x=>M(this,x);
+}else{
+Q=(...args)=>{
+if(args.length>0){
+return M(this,args[0]);
+}else{
+return M(this);
+}
+}
+}
+%FunctionSetName(Q,'__bound'+L+'__');
+%FunctionRemovePrototype(Q);
+%SetNativeFlag(Q);
+this[O]=Q;
+}
+return this[O];
+};
+l(K.prototype,L,P,2);
+}
+var R={};
+%AddNamedProperty(a,"Intl",R,2);
+var S={
+'collator':(void 0),
+'numberformat':(void 0),
+'dateformat':(void 0),
+'breakiterator':(void 0)
+};
+var T=(void 0);
+var U=(void 0);
+function GetUnicodeExtensionRE(){
+if(((void 0)===(void 0))){
+U=new i('-u(-[a-z0-9]{2,8})+','g');
+}
+return U;
+}
+var V=(void 0);
+function GetAnyExtensionRE(){
+if((V===(void 0))){
+V=new i('-[a-z0-9]{1}-.*','g');
+}
+return V;
+}
+var W=(void 0);
+function GetQuotedStringRE(){
+if((W===(void 0))){
+W=new i("'[^']+'",'g');
+}
+return W;
+}
+var X=(void 0);
+function GetServiceRE(){
+if((X===(void 0))){
+X=
+new i('^(collator|numberformat|dateformat|breakiterator)$');
+}
+return X;
+}
+var Y=(void 0);
+function GetLanguageTagRE(){
+if((Y===(void 0))){
+BuildLanguageTagREs();
+}
+return Y;
+}
+var Z=(void 0);
+function GetLanguageVariantRE(){
+if((Z===(void 0))){
+BuildLanguageTagREs();
+}
+return Z;
+}
+var aa=(void 0);
+function GetLanguageSingletonRE(){
+if((aa===(void 0))){
+BuildLanguageTagREs();
+}
+return aa;
+}
+var ab=(void 0);
+function GetTimezoneNameCheckRE(){
+if((ab===(void 0))){
+ab=new i(
+'^([A-Za-z]+)/([A-Za-z_-]+)((?:\/[A-Za-z_-]+)+)*$');
+}
+return ab;
+}
+var ac=(void 0);
+function GetTimezoneNameLocationPartRE(){
+if((ac===(void 0))){
+ac=
+new i('^([A-Za-z]+)((?:[_-][A-Za-z]+)+)*$');
+}
+return ac;
+}
+function supportedLocalesOf(ad,ae,af){
+if((n(GetServiceRE(),ad)===null)){
+throw r(7,ad);
+}
+if((af===(void 0))){
+af={};
+}else{
+af=(%_ToObject(af));
+}
+var ag=af.localeMatcher;
+if(!(ag===(void 0))){
+ag=j(ag);
+if(ag!=='lookup'&&ag!=='best fit'){
+throw s(182,ag);
+}
+}else{
+ag='best fit';
+}
+var ah=initializeLocaleList(ae);
+if((S[ad]===(void 0))){
+S[ad]=getAvailableLocalesOf(ad);
+}
+if(ag==='best fit'){
+return initializeLocaleList(bestFitSupportedLocalesOf(
+ah,S[ad]));
+}
+return initializeLocaleList(lookupSupportedLocalesOf(
+ah,S[ad]));
+}
+function lookupSupportedLocalesOf(ah,ai){
+var aj=[];
+for(var ak=0;ak<ah.length;++ak){
+var al=o(
+GetUnicodeExtensionRE(),ah[ak],'');
+do{
+if(!(ai[al]===(void 0))){
+%_Call(e,aj,ah[ak]);
+break;
+}
+var am=%_Call(C,al,'-');
+if(am===-1){
+break;
+}
+al=%_Call(F,al,0,am);
+}while(true);
+}
+return aj;
+}
+function bestFitSupportedLocalesOf(ah,ai){
+return lookupSupportedLocalesOf(ah,ai);
+}
+function getGetOption(af,an){
+if((af===(void 0)))throw r(4,an);
+var ao=function getOption(ap,aq,ar,as){
+if(!(af[ap]===(void 0))){
+var at=af[ap];
+switch(aq){
+case'boolean':
+at=f(at);
+break;
+case'string':
+at=j(at);
+break;
+case'number':
+at=h(at);
+break;
+default:
+throw r(8);
+}
+if(!(ar===(void 0))&&%_Call(c,ar,at)===-1){
+throw s(192,at,an,ap);
+}
+return at;
+}
+return as;
+}
+return ao;
+}
+function resolveLocale(ad,ah,af){
+ah=initializeLocaleList(ah);
+var ao=getGetOption(af,ad);
+var ag=ao('localeMatcher','string',
+['lookup','best fit'],'best fit');
+var au;
+if(ag==='lookup'){
+au=lookupMatcher(ad,ah);
+}else{
+au=bestFitMatcher(ad,ah);
+}
+return au;
+}
+function lookupMatcher(ad,ah){
+if((n(GetServiceRE(),ad)===null)){
+throw r(7,ad);
+}
+if((S[ad]===(void 0))){
+S[ad]=getAvailableLocalesOf(ad);
+}
+for(var ak=0;ak<ah.length;++ak){
+var al=o(
+GetAnyExtensionRE(),ah[ak],'');
+do{
+if(!(S[ad][al]===(void 0))){
+var av=n(
+GetUnicodeExtensionRE(),ah[ak]);
+var aw=(av===null)?'':av[0];
+return{'locale':al,'extension':aw,'position':ak};
+}
+var am=%_Call(C,al,'-');
+if(am===-1){
+break;
+}
+al=%_Call(F,al,0,am);
+}while(true);
+}
+if((T===(void 0))){
+T=%GetDefaultICULocale();
+}
+return{'locale':T,'extension':'','position':-1};
+}
+function bestFitMatcher(ad,ah){
+return lookupMatcher(ad,ah);
+}
+function parseExtension(aw){
+var ax=%_Call(D,aw,'-');
+if(ax.length<=2||
+(ax[0]!==''&&ax[1]!=='u')){
+return{};
+}
+var ay={};
+var az=(void 0);
+for(var ak=2;ak<ax.length;++ak){
+var N=ax[ak].length;
+var aA=ax[ak];
+if(N===2){
+ay[aA]=(void 0);
+az=aA;
+}else if(N>=3&&N<=8&&!(az===(void 0))){
+ay[az]=aA;
+az=(void 0);
+}else{
+return{};
+}
+}
+return ay;
+}
+function setOptions(aB,ay,aC,ao,aD){
+var aw='';
+var aE=function updateExtension(aF,at){
+return'-'+aF+'-'+j(at);
+}
+var aG=function updateProperty(ap,aq,at){
+if(aq==='boolean'&&(typeof at==='string')){
+at=(at==='true')?true:false;
+}
+if(!(ap===(void 0))){
+defineWEProperty(aD,ap,at);
+}
+}
+for(var aF in aC){
+if((%_Call(w,aC,aF))){
+var at=(void 0);
+var aH=aC[aF];
+if(!(aH.property===(void 0))){
+at=ao(aH.property,aH.type,aH.values);
+}
+if(!(at===(void 0))){
+aG(aH.property,aH.type,at);
+aw+=aE(aF,at);
+continue;
+}
+if((%_Call(w,ay,aF))){
+at=ay[aF];
+if(!(at===(void 0))){
+aG(aH.property,aH.type,at);
+aw+=aE(aF,at);
+}else if(aH.type==='boolean'){
+aG(aH.property,aH.type,true);
+aw+=aE(aF,true);
+}
+}
+}
+}
+return aw===''?'':'-u'+aw;
+}
+function freezeArray(aI){
+var aJ=aI.length;
+for(var ak=0;ak<aJ;ak++){
+if(ak in aI){
+v(aI,ak,{value:aI[ak],
+configurable:false,
+writable:false,
+enumerable:true});
+}
+}
+v(aI,'length',{value:aJ,writable:false});
+return aI;
+}
+function getOptimalLanguageTag(aK,au){
+if(aK===au){
+return aK;
+}
+var ae=%GetLanguageTagVariants([aK,au]);
+if(ae[0].maximized!==ae[1].maximized){
+return au;
+}
+var aL=new i('^'+ae[1].base,'g');
+return o(aL,au,ae[0].base);
+}
+function getAvailableLocalesOf(ad){
+var aM=%AvailableLocalesOf(ad);
+for(var ak in aM){
+if((%_Call(w,aM,ak))){
+var aN=n(
+/^([a-z]{2,3})-([A-Z][a-z]{3})-([A-Z]{2})$/,ak);
+if(!(aN===null)){
+aM[aN[1]+'-'+aN[3]]=null;
+}
+}
+}
+return aM;
+}
+function defineWEProperty(H,ap,at){
+v(H,ap,
+{value:at,writable:true,enumerable:true});
+}
+function addWEPropertyIfDefined(H,ap,at){
+if(!(at===(void 0))){
+defineWEProperty(H,ap,at);
+}
+}
+function defineWECProperty(H,ap,at){
+v(H,ap,{value:at,
+writable:true,
+enumerable:true,
+configurable:true});
+}
+function addWECPropertyIfDefined(H,ap,at){
+if(!(at===(void 0))){
+defineWECProperty(H,ap,at);
+}
+}
+function toTitleCaseWord(aO){
+return %StringToUpperCase(%_Call(E,aO,0,1))+
+%StringToLowerCase(%_Call(E,aO,1));
+}
+function toTitleCaseTimezoneLocation(aP){
+var aQ=n(GetTimezoneNameLocationPartRE(),aP)
+if((aQ===null))throw s(161,aP);
+var aR=toTitleCaseWord(aQ[1]);
+if(!(aQ[2]===(void 0))&&2<aQ.length){
+var aS=%_Call(F,aQ[2],0,1);
+var aN=%_Call(D,aQ[2],aS);
+for(var ak=1;ak<aN.length;ak++){
+var aT=aN[ak]
+var aU=%StringToLowerCase(aT);
+aR=aR+aS+
+((aU!=='es'&&
+aU!=='of'&&aU!=='au')?
+toTitleCaseWord(aT):aU);
+}
+}
+return aR;
+}
+function canonicalizeLanguageTag(aV){
+if(typeof aV!=='string'&&typeof aV!=='object'||
+(aV===null)){
+throw t(53);
+}
+var aW=j(aV);
+if(isValidLanguageTag(aW)===false){
+throw s(173,aW);
+}
+var aX=%CanonicalizeLanguageTag(aW);
+if(aX==='invalid-tag'){
+throw s(173,aW);
+}
+return aX;
+}
+function initializeLocaleList(ae){
+var aY=[];
+if((ae===(void 0))){
+aY=[];
+}else{
+if(typeof ae==='string'){
+%_Call(e,aY,canonicalizeLanguageTag(ae));
+return freezeArray(aY);
+}
+var aZ=(%_ToObject(ae));
+var ba=((aZ.length)>>>0);
+for(var bb=0;bb<ba;bb++){
+if(bb in aZ){
+var at=aZ[bb];
+var aX=canonicalizeLanguageTag(at);
+if(%_Call(c,aY,aX)===-1){
+%_Call(e,aY,aX);
+}
+}
+}
+}
+return freezeArray(aY);
+}
+function isValidLanguageTag(al){
+if((n(GetLanguageTagRE(),al)===null)){
+return false;
+}
+if(%_Call(B,al,'x-')===0){
+return true;
+}
+al=%_Call(D,al,'-x-')[0];
+var bc=[];
+var bd=[];
+var aN=%_Call(D,al,'-');
+for(var ak=1;ak<aN.length;ak++){
+var at=aN[ak];
+if(!(n(GetLanguageVariantRE(),at)===null)&&
+bd.length===0){
+if(%_Call(c,bc,at)===-1){
+%_Call(e,bc,at);
+}else{
+return false;
+}
+}
+if(!(n(GetLanguageSingletonRE(),at)===null)){
+if(%_Call(c,bd,at)===-1){
+%_Call(e,bd,at);
+}else{
+return false;
+}
+}
+}
+return true;
+}
+function BuildLanguageTagREs(){
+var be='[a-zA-Z]';
+var bf='[0-9]';
+var bg='('+be+'|'+bf+')';
+var bh='(art-lojban|cel-gaulish|no-bok|no-nyn|zh-guoyu|zh-hakka|'+
+'zh-min|zh-min-nan|zh-xiang)';
+var bi='(en-GB-oed|i-ami|i-bnn|i-default|i-enochian|i-hak|'+
+'i-klingon|i-lux|i-mingo|i-navajo|i-pwn|i-tao|i-tay|'+
+'i-tsu|sgn-BE-FR|sgn-BE-NL|sgn-CH-DE)';
+var bj='('+bi+'|'+bh+')';
+var bk='(x(-'+bg+'{1,8})+)';
+var bl='('+bf+'|[A-WY-Za-wy-z])';
+aa=new i('^'+bl+'$','i');
+var aw='('+bl+'(-'+bg+'{2,8})+)';
+var bm='('+bg+'{5,8}|('+bf+bg+'{3}))';
+Z=new i('^'+bm+'$','i');
+var bn='('+be+'{2}|'+bf+'{3})';
+var bo='('+be+'{4})';
+var bp='('+be+'{3}(-'+be+'{3}){0,2})';
+var bq='('+be+'{2,3}(-'+bp+')?|'+be+'{4}|'+
+be+'{5,8})';
+var br=bq+'(-'+bo+')?(-'+bn+')?(-'+
+bm+')*(-'+aw+')*(-'+bk+')?';
+var bs=
+'^('+br+'|'+bk+'|'+bj+')$';
+Y=new i(bs,'i');
+}
+var bt={
+get(){
+%IncrementUseCounter(16);
+return this[z];
+},
+set(at){
+this[z]=at;
+}
+};
+function initializeCollator(bu,ae,af){
+if(%IsInitializedIntlObject(bu)){
+throw t(135,"Collator");
+}
+if((af===(void 0))){
+af={};
+}
+var ao=getGetOption(af,'collator');
+var bv={};
+defineWEProperty(bv,'usage',ao(
+'usage','string',['sort','search'],'sort'));
+var bw=ao('sensitivity','string',
+['base','accent','case','variant']);
+if((bw===(void 0))&&bv.usage==='sort'){
+bw='variant';
+}
+defineWEProperty(bv,'sensitivity',bw);
+defineWEProperty(bv,'ignorePunctuation',ao(
+'ignorePunctuation','boolean',(void 0),false));
+var al=resolveLocale('collator',ae,af);
+var ay=parseExtension(al.extension);
+var bx={
+'kn':{'property':'numeric','type':'boolean'},
+'kf':{'property':'caseFirst','type':'string',
+'values':['false','lower','upper']}
+};
+setOptions(
+af,ay,bx,ao,bv);
+var by='default';
+var aw='';
+if((%_Call(w,ay,'co'))&&bv.usage==='sort'){
+var bz=[
+'big5han','dict','direct','ducet','gb2312','phonebk','phonetic',
+'pinyin','reformed','searchjl','stroke','trad','unihan','zhuyin'
+];
+if(%_Call(c,bz,ay.co)!==-1){
+aw='-u-co-'+ay.co;
+by=ay.co;
+}
+}else if(bv.usage==='search'){
+aw='-u-co-search';
+}
+defineWEProperty(bv,'collation',by);
+var bA=al.locale+aw;
+var au=u({},{
+caseFirst:{writable:true},
+collation:{value:bv.collation,writable:true},
+ignorePunctuation:{writable:true},
+locale:{writable:true},
+numeric:{writable:true},
+requestedLocale:{value:bA,writable:true},
+sensitivity:{writable:true},
+strength:{writable:true},
+usage:{value:bv.usage,writable:true}
+});
+var bB=%CreateCollator(bA,
+bv,
+au);
+%MarkAsInitializedIntlObjectOfType(bu,'collator',bB);
+bu[z]=au;
+v(bu,'resolved',bt);
+return bu;
+}
+InstallConstructor(R,'Collator',function(){
+var ae=arguments[0];
+var af=arguments[1];
+if(!this||this===R){
+return new R.Collator(ae,af);
+}
+return initializeCollator((%_ToObject(this)),ae,af);
+}
+);
+InstallFunction(R.Collator.prototype,'resolvedOptions',function(){
+if(!(new.target===(void 0))){
+throw t(91);
+}
+if(!%IsInitializedIntlObjectOfType(this,'collator')){
+throw t(136,"Collator");
+}
+var bC=this;
+var al=getOptimalLanguageTag(bC[z].requestedLocale,
+bC[z].locale);
+return{
+locale:al,
+usage:bC[z].usage,
+sensitivity:bC[z].sensitivity,
+ignorePunctuation:bC[z].ignorePunctuation,
+numeric:bC[z].numeric,
+caseFirst:bC[z].caseFirst,
+collation:bC[z].collation
+};
+}
+);
+InstallFunction(R.Collator,'supportedLocalesOf',function(ae){
+if(!(new.target===(void 0))){
+throw t(91);
+}
+return supportedLocalesOf('collator',ae,arguments[1]);
+}
+);
+function compare(bu,bD,bE){
+return %InternalCompare(%GetImplFromInitializedIntlObject(bu),
+j(bD),j(bE));
+};
+AddBoundMethod(R.Collator,'compare',compare,2);
+function isWellFormedCurrencyCode(bF){
+return typeof bF=="string"&&bF.length==3&&
+(n(/[^A-Za-z]/,bF)===null);
+}
+function getNumberOption(af,ap,bG,bH,bI){
+var at=af[ap];
+if(!(at===(void 0))){
+at=h(at);
+if(q(at)||at<bG||at>bH){
+throw s(185,ap);
+}
+return %math_floor(at);
+}
+return bI;
+}
+var bJ={
+get(){
+%IncrementUseCounter(15);
+return this[y];
+},
+set(at){
+this[y]=at;
+}
+};
+function initializeNumberFormat(bK,ae,af){
+if(%IsInitializedIntlObject(bK)){
+throw t(135,"NumberFormat");
+}
+if((af===(void 0))){
+af={};
+}
+var ao=getGetOption(af,'numberformat');
+var al=resolveLocale('numberformat',ae,af);
+var bv={};
+defineWEProperty(bv,'style',ao(
+'style','string',['decimal','percent','currency'],'decimal'));
+var bF=ao('currency','string');
+if(!(bF===(void 0))&&!isWellFormedCurrencyCode(bF)){
+throw s(168,bF);
+}
+if(bv.style==='currency'&&(bF===(void 0))){
+throw t(30);
+}
+var bL=ao(
+'currencyDisplay','string',['code','symbol','name'],'symbol');
+if(bv.style==='currency'){
+defineWEProperty(bv,'currency',%StringToUpperCase(bF));
+defineWEProperty(bv,'currencyDisplay',bL);
+}
+var bM=getNumberOption(af,'minimumIntegerDigits',1,21,1);
+defineWEProperty(bv,'minimumIntegerDigits',bM);
+var bN=af['minimumFractionDigits'];
+var bO=af['maximumFractionDigits'];
+if(!(bN===(void 0))||bv.style!=='currency'){
+bN=getNumberOption(af,'minimumFractionDigits',0,20,0);
+defineWEProperty(bv,'minimumFractionDigits',bN);
+}
+if(!(bO===(void 0))||bv.style!=='currency'){
+var bP=bv.style==='percent'?0:3;
+bN=(bN===(void 0))?0:bN;
+var bQ=(bN>bP)?bN:bP;
+bO=getNumberOption(af,'maximumFractionDigits',bN,20,bQ);
+defineWEProperty(bv,'maximumFractionDigits',bO);
+}
+var bR=af['minimumSignificantDigits'];
+var bS=af['maximumSignificantDigits'];
+if(!(bR===(void 0))||!(bS===(void 0))){
+bR=getNumberOption(af,'minimumSignificantDigits',1,21,0);
+defineWEProperty(bv,'minimumSignificantDigits',bR);
+bS=getNumberOption(af,'maximumSignificantDigits',bR,21,21);
+defineWEProperty(bv,'maximumSignificantDigits',bS);
+}
+defineWEProperty(bv,'useGrouping',ao(
+'useGrouping','boolean',(void 0),true));
+var ay=parseExtension(al.extension);
+var bT={
+'nu':{'property':(void 0),'type':'string'}
+};
+var aw=setOptions(af,ay,bT,
+ao,bv);
+var bA=al.locale+aw;
+var au=u({},{
+currency:{writable:true},
+currencyDisplay:{writable:true},
+locale:{writable:true},
+maximumFractionDigits:{writable:true},
+minimumFractionDigits:{writable:true},
+minimumIntegerDigits:{writable:true},
+numberingSystem:{writable:true},
+pattern:bJ,
+requestedLocale:{value:bA,writable:true},
+style:{value:bv.style,writable:true},
+useGrouping:{writable:true}
+});
+if((%_Call(w,bv,'minimumSignificantDigits'))){
+defineWEProperty(au,'minimumSignificantDigits',(void 0));
+}
+if((%_Call(w,bv,'maximumSignificantDigits'))){
+defineWEProperty(au,'maximumSignificantDigits',(void 0));
+}
+var bU=%CreateNumberFormat(bA,
+bv,
+au);
+if(bv.style==='currency'){
+v(au,'currencyDisplay',{value:bL,
+writable:true});
+}
+%MarkAsInitializedIntlObjectOfType(bK,'numberformat',bU);
+bK[z]=au;
+v(bK,'resolved',bt);
+return bK;
+}
+InstallConstructor(R,'NumberFormat',function(){
+var ae=arguments[0];
+var af=arguments[1];
+if(!this||this===R){
+return new R.NumberFormat(ae,af);
+}
+return initializeNumberFormat((%_ToObject(this)),ae,af);
+}
+);
+InstallFunction(R.NumberFormat.prototype,'resolvedOptions',function(){
+if(!(new.target===(void 0))){
+throw t(91);
+}
+if(!%IsInitializedIntlObjectOfType(this,'numberformat')){
+throw t(136,"NumberFormat");
+}
+var bV=this;
+var al=getOptimalLanguageTag(bV[z].requestedLocale,
+bV[z].locale);
+var aR={
+locale:al,
+numberingSystem:bV[z].numberingSystem,
+style:bV[z].style,
+useGrouping:bV[z].useGrouping,
+minimumIntegerDigits:bV[z].minimumIntegerDigits,
+minimumFractionDigits:bV[z].minimumFractionDigits,
+maximumFractionDigits:bV[z].maximumFractionDigits,
+};
+if(aR.style==='currency'){
+defineWECProperty(aR,'currency',bV[z].currency);
+defineWECProperty(aR,'currencyDisplay',
+bV[z].currencyDisplay);
+}
+if((%_Call(w,bV[z],'minimumSignificantDigits'))){
+defineWECProperty(aR,'minimumSignificantDigits',
+bV[z].minimumSignificantDigits);
+}
+if((%_Call(w,bV[z],'maximumSignificantDigits'))){
+defineWECProperty(aR,'maximumSignificantDigits',
+bV[z].maximumSignificantDigits);
+}
+return aR;
+}
+);
+InstallFunction(R.NumberFormat,'supportedLocalesOf',function(ae){
+if(!(new.target===(void 0))){
+throw t(91);
+}
+return supportedLocalesOf('numberformat',ae,arguments[1]);
+}
+);
+function formatNumber(bU,at){
+var bW=(%_ToNumber(at))+0;
+return %InternalNumberFormat(%GetImplFromInitializedIntlObject(bU),
+bW);
+}
+function parseNumber(bU,at){
+return %InternalNumberParse(%GetImplFromInitializedIntlObject(bU),
+j(at));
+}
+AddBoundMethod(R.NumberFormat,'format',formatNumber,1);
+AddBoundMethod(R.NumberFormat,'v8Parse',parseNumber,1);
+function toLDMLString(af){
+var ao=getGetOption(af,'dateformat');
+var bX='';
+var bY=ao('weekday','string',['narrow','short','long']);
+bX+=appendToLDMLString(
+bY,{narrow:'EEEEE',short:'EEE',long:'EEEE'});
+bY=ao('era','string',['narrow','short','long']);
+bX+=appendToLDMLString(
+bY,{narrow:'GGGGG',short:'GGG',long:'GGGG'});
+bY=ao('year','string',['2-digit','numeric']);
+bX+=appendToLDMLString(bY,{'2-digit':'yy','numeric':'y'});
+bY=ao('month','string',
+['2-digit','numeric','narrow','short','long']);
+bX+=appendToLDMLString(bY,{'2-digit':'MM','numeric':'M',
+'narrow':'MMMMM','short':'MMM','long':'MMMM'});
+bY=ao('day','string',['2-digit','numeric']);
+bX+=appendToLDMLString(
+bY,{'2-digit':'dd','numeric':'d'});
+var bZ=ao('hour12','boolean');
+bY=ao('hour','string',['2-digit','numeric']);
+if((bZ===(void 0))){
+bX+=appendToLDMLString(bY,{'2-digit':'jj','numeric':'j'});
+}else if(bZ===true){
+bX+=appendToLDMLString(bY,{'2-digit':'hh','numeric':'h'});
+}else{
+bX+=appendToLDMLString(bY,{'2-digit':'HH','numeric':'H'});
+}
+bY=ao('minute','string',['2-digit','numeric']);
+bX+=appendToLDMLString(bY,{'2-digit':'mm','numeric':'m'});
+bY=ao('second','string',['2-digit','numeric']);
+bX+=appendToLDMLString(bY,{'2-digit':'ss','numeric':'s'});
+bY=ao('timeZoneName','string',['short','long']);
+bX+=appendToLDMLString(bY,{short:'z',long:'zzzz'});
+return bX;
+}
+function appendToLDMLString(bY,ca){
+if(!(bY===(void 0))){
+return ca[bY];
+}else{
+return'';
+}
+}
+function fromLDMLString(bX){
+bX=o(GetQuotedStringRE(),bX,'');
+var af={};
+var aQ=n(/E{3,5}/,bX);
+af=appendToDateTimeObject(
+af,'weekday',aQ,{EEEEE:'narrow',EEE:'short',EEEE:'long'});
+aQ=n(/G{3,5}/,bX);
+af=appendToDateTimeObject(
+af,'era',aQ,{GGGGG:'narrow',GGG:'short',GGGG:'long'});
+aQ=n(/y{1,2}/,bX);
+af=appendToDateTimeObject(
+af,'year',aQ,{y:'numeric',yy:'2-digit'});
+aQ=n(/M{1,5}/,bX);
+af=appendToDateTimeObject(af,'month',aQ,{MM:'2-digit',
+M:'numeric',MMMMM:'narrow',MMM:'short',MMMM:'long'});
+aQ=n(/L{1,5}/,bX);
+af=appendToDateTimeObject(af,'month',aQ,{LL:'2-digit',
+L:'numeric',LLLLL:'narrow',LLL:'short',LLLL:'long'});
+aQ=n(/d{1,2}/,bX);
+af=appendToDateTimeObject(
+af,'day',aQ,{d:'numeric',dd:'2-digit'});
+aQ=n(/h{1,2}/,bX);
+if(aQ!==null){
+af['hour12']=true;
+}
+af=appendToDateTimeObject(
+af,'hour',aQ,{h:'numeric',hh:'2-digit'});
+aQ=n(/H{1,2}/,bX);
+if(aQ!==null){
+af['hour12']=false;
+}
+af=appendToDateTimeObject(
+af,'hour',aQ,{H:'numeric',HH:'2-digit'});
+aQ=n(/m{1,2}/,bX);
+af=appendToDateTimeObject(
+af,'minute',aQ,{m:'numeric',mm:'2-digit'});
+aQ=n(/s{1,2}/,bX);
+af=appendToDateTimeObject(
+af,'second',aQ,{s:'numeric',ss:'2-digit'});
+aQ=n(/z|zzzz/,bX);
+af=appendToDateTimeObject(
+af,'timeZoneName',aQ,{z:'short',zzzz:'long'});
+return af;
+}
+function appendToDateTimeObject(af,bY,aQ,ca){
+if((aQ===null)){
+if(!(%_Call(w,af,bY))){
+defineWEProperty(af,bY,(void 0));
+}
+return af;
+}
+var ap=aQ[0];
+defineWEProperty(af,bY,ca[ap]);
+return af;
+}
+function toDateTimeOptions(af,cb,cc){
+if((af===(void 0))){
+af={};
+}else{
+af=(%_ToObject(af));
+}
+var cd=true;
+if((cb==='date'||cb==='any')&&
+(!(af.weekday===(void 0))||!(af.year===(void 0))||
+!(af.month===(void 0))||!(af.day===(void 0)))){
+cd=false;
+}
+if((cb==='time'||cb==='any')&&
+(!(af.hour===(void 0))||!(af.minute===(void 0))||
+!(af.second===(void 0)))){
+cd=false;
+}
+if(cd&&(cc==='date'||cc==='all')){
+v(af,'year',{value:'numeric',
+writable:true,
+enumerable:true,
+configurable:true});
+v(af,'month',{value:'numeric',
+writable:true,
+enumerable:true,
+configurable:true});
+v(af,'day',{value:'numeric',
+writable:true,
+enumerable:true,
+configurable:true});
+}
+if(cd&&(cc==='time'||cc==='all')){
+v(af,'hour',{value:'numeric',
+writable:true,
+enumerable:true,
+configurable:true});
+v(af,'minute',{value:'numeric',
+writable:true,
+enumerable:true,
+configurable:true});
+v(af,'second',{value:'numeric',
+writable:true,
+enumerable:true,
+configurable:true});
+}
+return af;
+}
+function initializeDateTimeFormat(ce,ae,af){
+if(%IsInitializedIntlObject(ce)){
+throw t(135,"DateTimeFormat");
+}
+if((af===(void 0))){
+af={};
+}
+var al=resolveLocale('dateformat',ae,af);
+af=toDateTimeOptions(af,'any','date');
+var ao=getGetOption(af,'dateformat');
+var ag=ao('formatMatcher','string',
+['basic','best fit'],'best fit');
+var bX=toLDMLString(af);
+var cf=canonicalizeTimeZoneID(af.timeZone);
+var bv={};
+var ay=parseExtension(al.extension);
+var cg={
+'ca':{'property':(void 0),'type':'string'},
+'nu':{'property':(void 0),'type':'string'}
+};
+var aw=setOptions(af,ay,cg,
+ao,bv);
+var bA=al.locale+aw;
+var au=u({},{
+calendar:{writable:true},
+day:{writable:true},
+era:{writable:true},
+hour12:{writable:true},
+hour:{writable:true},
+locale:{writable:true},
+minute:{writable:true},
+month:{writable:true},
+numberingSystem:{writable:true},
+[y]:{writable:true},
+pattern:bJ,
+requestedLocale:{value:bA,writable:true},
+second:{writable:true},
+timeZone:{writable:true},
+timeZoneName:{writable:true},
+tz:{value:cf,writable:true},
+weekday:{writable:true},
+year:{writable:true}
+});
+var bU=%CreateDateTimeFormat(
+bA,{skeleton:bX,timeZone:cf},au);
+if(au.timeZone==="Etc/Unknown"){
+throw s(191,cf);
+}
+%MarkAsInitializedIntlObjectOfType(ce,'dateformat',bU);
+ce[z]=au;
+v(ce,'resolved',bt);
+return ce;
+}
+InstallConstructor(R,'DateTimeFormat',function(){
+var ae=arguments[0];
+var af=arguments[1];
+if(!this||this===R){
+return new R.DateTimeFormat(ae,af);
+}
+return initializeDateTimeFormat((%_ToObject(this)),ae,af);
+}
+);
+InstallFunction(R.DateTimeFormat.prototype,'resolvedOptions',function(){
+if(!(new.target===(void 0))){
+throw t(91);
+}
+if(!%IsInitializedIntlObjectOfType(this,'dateformat')){
+throw t(136,"DateTimeFormat");
+}
+var ch={
+'gregorian':'gregory',
+'japanese':'japanese',
+'buddhist':'buddhist',
+'roc':'roc',
+'persian':'persian',
+'islamic-civil':'islamicc',
+'islamic':'islamic',
+'hebrew':'hebrew',
+'chinese':'chinese',
+'indian':'indian',
+'coptic':'coptic',
+'ethiopic':'ethiopic',
+'ethiopic-amete-alem':'ethioaa'
+};
+var bV=this;
+var ci=fromLDMLString(bV[z][y]);
+var cj=ch[bV[z].calendar];
+if((cj===(void 0))){
+cj=bV[z].calendar;
+}
+var al=getOptimalLanguageTag(bV[z].requestedLocale,
+bV[z].locale);
+var aR={
+locale:al,
+numberingSystem:bV[z].numberingSystem,
+calendar:cj,
+timeZone:bV[z].timeZone
+};
+addWECPropertyIfDefined(aR,'timeZoneName',ci.timeZoneName);
+addWECPropertyIfDefined(aR,'era',ci.era);
+addWECPropertyIfDefined(aR,'year',ci.year);
+addWECPropertyIfDefined(aR,'month',ci.month);
+addWECPropertyIfDefined(aR,'day',ci.day);
+addWECPropertyIfDefined(aR,'weekday',ci.weekday);
+addWECPropertyIfDefined(aR,'hour12',ci.hour12);
+addWECPropertyIfDefined(aR,'hour',ci.hour);
+addWECPropertyIfDefined(aR,'minute',ci.minute);
+addWECPropertyIfDefined(aR,'second',ci.second);
+return aR;
+}
+);
+InstallFunction(R.DateTimeFormat,'supportedLocalesOf',function(ae){
+if(!(new.target===(void 0))){
+throw t(91);
+}
+return supportedLocalesOf('dateformat',ae,arguments[1]);
+}
+);
+function formatDate(bU,ck){
+var cl;
+if((ck===(void 0))){
+cl=%DateCurrentTime();
+}else{
+cl=(%_ToNumber(ck));
+}
+if(!p(cl))throw s(159);
+return %InternalDateFormat(%GetImplFromInitializedIntlObject(bU),
+new g(cl));
+}
+function parseDate(bU,at){
+return %InternalDateParse(%GetImplFromInitializedIntlObject(bU),
+j(at));
+}
+AddBoundMethod(R.DateTimeFormat,'format',formatDate,0);
+AddBoundMethod(R.DateTimeFormat,'v8Parse',parseDate,1);
+function canonicalizeTimeZoneID(cm){
+if((cm===(void 0))){
+return cm;
+}
+var cn=%StringToUpperCase(cm);
+if(cn==='UTC'||cn==='GMT'||
+cn==='ETC/UTC'||cn==='ETC/GMT'){
+return'UTC';
+}
+var aQ=n(GetTimezoneNameCheckRE(),cm);
+if((aQ===null))throw s(160,cm);
+var aR=toTitleCaseTimezoneLocation(aQ[1])+'/'+
+toTitleCaseTimezoneLocation(aQ[2]);
+if(!(aQ[3]===(void 0))&&3<aQ.length){
+var co=%_Call(D,aQ[3],'/');
+for(var ak=1;ak<co.length;ak++){
+aR=aR+'/'+toTitleCaseTimezoneLocation(co[ak]);
+}
+}
+return aR;
+}
+function initializeBreakIterator(cp,ae,af){
+if(%IsInitializedIntlObject(cp)){
+throw t(135,"v8BreakIterator");
+}
+if((af===(void 0))){
+af={};
+}
+var ao=getGetOption(af,'breakiterator');
+var bv={};
+defineWEProperty(bv,'type',ao(
+'type','string',['character','word','sentence','line'],'word'));
+var al=resolveLocale('breakiterator',ae,af);
+var au=u({},{
+requestedLocale:{value:al.locale,writable:true},
+type:{value:bv.type,writable:true},
+locale:{writable:true}
+});
+var cq=%CreateBreakIterator(al.locale,
+bv,
+au);
+%MarkAsInitializedIntlObjectOfType(cp,'breakiterator',
+cq);
+cp[z]=au;
+v(cp,'resolved',bt);
+return cp;
+}
+InstallConstructor(R,'v8BreakIterator',function(){
+var ae=arguments[0];
+var af=arguments[1];
+if(!this||this===R){
+return new R.v8BreakIterator(ae,af);
+}
+return initializeBreakIterator((%_ToObject(this)),ae,af);
+}
+);
+InstallFunction(R.v8BreakIterator.prototype,'resolvedOptions',
+function(){
+if(!(new.target===(void 0))){
+throw t(91);
+}
+if(!%IsInitializedIntlObjectOfType(this,'breakiterator')){
+throw t(136,"v8BreakIterator");
+}
+var cr=this;
+var al=
+getOptimalLanguageTag(cr[z].requestedLocale,
+cr[z].locale);
+return{
+locale:al,
+type:cr[z].type
+};
+}
+);
+InstallFunction(R.v8BreakIterator,'supportedLocalesOf',
+function(ae){
+if(!(new.target===(void 0))){
+throw t(91);
+}
+return supportedLocalesOf('breakiterator',ae,arguments[1]);
+}
+);
+function adoptText(cp,cs){
+%BreakIteratorAdoptText(%GetImplFromInitializedIntlObject(cp),
+j(cs));
+}
+function first(cp){
+return %BreakIteratorFirst(%GetImplFromInitializedIntlObject(cp));
+}
+function next(cp){
+return %BreakIteratorNext(%GetImplFromInitializedIntlObject(cp));
+}
+function current(cp){
+return %BreakIteratorCurrent(%GetImplFromInitializedIntlObject(cp));
+}
+function breakType(cp){
+return %BreakIteratorBreakType(%GetImplFromInitializedIntlObject(cp));
+}
+AddBoundMethod(R.v8BreakIterator,'adoptText',adoptText,1);
+AddBoundMethod(R.v8BreakIterator,'first',first,0);
+AddBoundMethod(R.v8BreakIterator,'next',next,0);
+AddBoundMethod(R.v8BreakIterator,'current',current,0);
+AddBoundMethod(R.v8BreakIterator,'breakType',breakType,0);
+var ct={
+'collator':R.Collator,
+'numberformat':R.NumberFormat,
+'dateformatall':R.DateTimeFormat,
+'dateformatdate':R.DateTimeFormat,
+'dateformattime':R.DateTimeFormat
+};
+var cu={
+'collator':(void 0),
+'numberformat':(void 0),
+'dateformatall':(void 0),
+'dateformatdate':(void 0),
+'dateformattime':(void 0),
+};
+function cachedOrNewService(ad,ae,af,cc){
+var cv=((cc===(void 0)))?af:cc;
+if((ae===(void 0))&&(af===(void 0))){
+if((cu[ad]===(void 0))){
+cu[ad]=new ct[ad](ae,cv);
+}
+return cu[ad];
+}
+return new ct[ad](ae,cv);
+}
+x(j.prototype,'localeCompare',function(cw){
+if(!(new.target===(void 0))){
+throw t(91);
+}
+if((this==null)){
+throw t(55);
+}
+var ae=arguments[1];
+var af=arguments[2];
+var bu=cachedOrNewService('collator',ae,af);
+return compare(bu,this,cw);
+}
+);
+x(j.prototype,'normalize',function(){
+if(!(new.target===(void 0))){
+throw t(91);
+}
+if((%IS_VAR(this)===null)||(this===(void 0)))throw t(18,"String.prototype.normalize");
+var cx=(%_ToString(this));
+var cy=arguments[0];
+var cz=(cy===(void 0))?'NFC':(%_ToString(cy));
+var cA=['NFC','NFD','NFKC','NFKD'];
+var cB=%_Call(c,cA,cz);
+if(cB===-1){
+throw s(183,
+%_Call(d,cA,', '));
+}
+return %StringNormalize(cx,cB);
+}
+);
+x(h.prototype,'toLocaleString',function(){
+if(!(new.target===(void 0))){
+throw t(91);
+}
+if(!(this instanceof h)&&typeof(this)!=='number'){
+throw t(56,"Number");
+}
+var ae=arguments[0];
+var af=arguments[1];
+var bK=cachedOrNewService('numberformat',ae,af);
+return formatNumber(bK,this);
+}
+);
+function toLocaleDateTime(cC,ae,af,cb,cc,ad){
+if(!(cC instanceof g)){
+throw t(56,"Date");
+}
+if(q(cC))return'Invalid Date';
+var bv=toDateTimeOptions(af,cb,cc);
+var ce=
+cachedOrNewService(ad,ae,af,bv);
+return formatDate(ce,cC);
+}
+x(g.prototype,'toLocaleString',function(){
+if(!(new.target===(void 0))){
+throw t(91);
+}
+var ae=arguments[0];
+var af=arguments[1];
+return toLocaleDateTime(
+this,ae,af,'any','all','dateformatall');
+}
+);
+x(g.prototype,'toLocaleDateString',function(){
+if(!(new.target===(void 0))){
+throw t(91);
+}
+var ae=arguments[0];
+var af=arguments[1];
+return toLocaleDateTime(
+this,ae,af,'date','date','dateformatdate');
+}
+);
+x(g.prototype,'toLocaleTimeString',function(){
+if(!(new.target===(void 0))){
+throw t(91);
+}
+var ae=arguments[0];
+var af=arguments[1];
+return toLocaleDateTime(
+this,ae,af,'time','time','dateformattime');
+}
+);
+})
+
+($generator

+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=b.ImportNow("GeneratorFunctionPrototype");
+var d=b.ImportNow("GeneratorFunction");
+var e=a.Function;
+var f;
+var g=b.ImportNow("to_string_tag_symbol");
+b.Import(function(h){
+f=h.MakeTypeError;
+});
+function GeneratorObjectNext(i){
+if(!(%_ClassOf(this)==='Generator')){
+throw f(44,
+'[Generator].prototype.next',this);
+}
+var j=%GeneratorGetContinuation(this);
+if(j>0){
+if(%_DebugIsActive()!=0)%DebugPrepareStepInIfStepping(this);
+return %_GeneratorNext(this,i);
+}else if(j==0){
+return %_CreateIterResultObject((void 0),true);
+}else{
+throw f(42);
+}
+}
+function GeneratorObjectReturn(i){
+if(!(%_ClassOf(this)==='Generator')){
+throw f(44,
+'[Generator].prototype.return',this);
+}
+var j=%GeneratorGetContinuation(this);
+if(j>0){
+if(%_DebugIsActive()!=0)%DebugPrepareStepInIfStepping(this);
+return %_GeneratorReturn(this,i);
+}else if(j==0){
+return %_CreateIterResultObject(i,true);
+}else{
+throw f(42);
+}
+}
+function GeneratorObjectThrow(k){
+if(!(%_ClassOf(this)==='Generator')){
+throw f(44,
+'[Generator].prototype.throw',this);
+}
+var j=%GeneratorGetContinuation(this);
+if(j>0){
+if(%_DebugIsActive()!=0)%DebugPrepareStepInIfStepping(this);
+return %_GeneratorThrow(this,k);
+}else if(j==0){
+throw k;
+}else{
+throw f(42);
+}
+}
+%NeverOptimizeFunction(GeneratorObjectNext);
+%NeverOptimizeFunction(GeneratorObjectReturn);
+%NeverOptimizeFunction(GeneratorObjectThrow);
+var l=c.prototype;
+b.InstallFunctions(l,
+2,
+["next",GeneratorObjectNext,
+"return",GeneratorObjectReturn,
+"throw",GeneratorObjectThrow]);
+%AddNamedProperty(l,"constructor",
+c,2|1);
+%AddNamedProperty(l,
+g,"Generator",2|1);
+%InternalSetPrototype(c,e.prototype);
+%AddNamedProperty(c,
+g,"GeneratorFunction",2|1);
+%AddNamedProperty(c,"constructor",
+d,2|1);
+%InternalSetPrototype(d,e);
+})
+
+<harmony-atomicsu8
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Object;
+var d;
+var e;
+var f;
+var g=b.ImportNow("to_string_tag_symbol");
+b.Import(function(h){
+e=h.MakeTypeError;
+d=h.MakeRangeError;
+f=h.MaxSimple;
+});
+function CheckSharedIntegerTypedArray(i){
+if(!%IsSharedIntegerTypedArray(i)){
+throw e(74,i);
+}
+}
+function CheckSharedInteger32TypedArray(i){
+CheckSharedIntegerTypedArray(i);
+if(!%IsSharedInteger32TypedArray(i)){
+throw e(75,i);
+}
+}
+function ValidateIndex(j,k){
+var l=(%_ToNumber(j));
+var m=(%_ToInteger(l));
+if(l!==m){
+throw d(165);
+}
+if(m<0||m>=k){
+throw d(165);
+}
+return m;
+}
+function AtomicsCompareExchangeJS(n,j,o,p){
+CheckSharedIntegerTypedArray(n);
+j=ValidateIndex(j,%_TypedArrayGetLength(n));
+o=(%_ToNumber(o));
+p=(%_ToNumber(p));
+return %_AtomicsCompareExchange(n,j,o,p);
+}
+function AtomicsLoadJS(n,j){
+CheckSharedIntegerTypedArray(n);
+j=ValidateIndex(j,%_TypedArrayGetLength(n));
+return %_AtomicsLoad(n,j);
+}
+function AtomicsStoreJS(n,j,q){
+CheckSharedIntegerTypedArray(n);
+j=ValidateIndex(j,%_TypedArrayGetLength(n));
+q=(%_ToNumber(q));
+return %_AtomicsStore(n,j,q);
+}
+function AtomicsAddJS(i,j,q){
+CheckSharedIntegerTypedArray(i);
+j=ValidateIndex(j,%_TypedArrayGetLength(i));
+q=(%_ToNumber(q));
+return %_AtomicsAdd(i,j,q);
+}
+function AtomicsSubJS(i,j,q){
+CheckSharedIntegerTypedArray(i);
+j=ValidateIndex(j,%_TypedArrayGetLength(i));
+q=(%_ToNumber(q));
+return %_AtomicsSub(i,j,q);
+}
+function AtomicsAndJS(i,j,q){
+CheckSharedIntegerTypedArray(i);
+j=ValidateIndex(j,%_TypedArrayGetLength(i));
+q=(%_ToNumber(q));
+return %_AtomicsAnd(i,j,q);
+}
+function AtomicsOrJS(i,j,q){
+CheckSharedIntegerTypedArray(i);
+j=ValidateIndex(j,%_TypedArrayGetLength(i));
+q=(%_ToNumber(q));
+return %_AtomicsOr(i,j,q);
+}
+function AtomicsXorJS(i,j,q){
+CheckSharedIntegerTypedArray(i);
+j=ValidateIndex(j,%_TypedArrayGetLength(i));
+q=(%_ToNumber(q));
+return %_AtomicsXor(i,j,q);
+}
+function AtomicsExchangeJS(i,j,q){
+CheckSharedIntegerTypedArray(i);
+j=ValidateIndex(j,%_TypedArrayGetLength(i));
+q=(%_ToNumber(q));
+return %_AtomicsExchange(i,j,q);
+}
+function AtomicsIsLockFreeJS(r){
+return %_AtomicsIsLockFree(r);
+}
+function AtomicsFutexWaitJS(i,j,q,s){
+CheckSharedInteger32TypedArray(i);
+j=ValidateIndex(j,%_TypedArrayGetLength(i));
+if((s===(void 0))){
+s=(1/0);
+}else{
+s=(%_ToNumber(s));
+if((!%_IsSmi(%IS_VAR(s))&&!(s==s))){
+s=(1/0);
+}else{
+s=f(0,s);
+}
+}
+return %AtomicsFutexWait(i,j,q,s);
+}
+function AtomicsFutexWakeJS(i,j,t){
+CheckSharedInteger32TypedArray(i);
+j=ValidateIndex(j,%_TypedArrayGetLength(i));
+t=f(0,(%_ToInteger(t)));
+return %AtomicsFutexWake(i,j,t);
+}
+function AtomicsFutexWakeOrRequeueJS(i,u,t,q,v){
+CheckSharedInteger32TypedArray(i);
+u=ValidateIndex(u,%_TypedArrayGetLength(i));
+t=f(0,(%_ToInteger(t)));
+q=((q)|0);
+v=ValidateIndex(v,%_TypedArrayGetLength(i));
+if(u<0||u>=%_TypedArrayGetLength(i)||
+v<0||v>=%_TypedArrayGetLength(i)){
+return(void 0);
+}
+return %AtomicsFutexWakeOrRequeue(i,u,t,q,v);
+}
+function AtomicsConstructor(){}
+var w=new AtomicsConstructor();
+%InternalSetPrototype(w,c.prototype);
+%AddNamedProperty(a,"Atomics",w,2);
+%FunctionSetInstanceClassName(AtomicsConstructor,'Atomics');
+%AddNamedProperty(w,g,"Atomics",1|2);
+b.InstallConstants(w,[
+"OK",0,
+"NOTEQUAL",-1,
+"TIMEDOUT",-2,
+]);
+b.InstallFunctions(w,2,[
+"compareExchange",AtomicsCompareExchangeJS,
+"load",AtomicsLoadJS,
+"store",AtomicsStoreJS,
+"add",AtomicsAddJS,
+"sub",AtomicsSubJS,
+"and",AtomicsAndJS,
+"or",AtomicsOrJS,
+"xor",AtomicsXorJS,
+"exchange",AtomicsExchangeJS,
+"isLockFree",AtomicsIsLockFreeJS,
+"futexWait",AtomicsFutexWaitJS,
+"futexWake",AtomicsFutexWakeJS,
+"futexWakeOrRequeue",AtomicsFutexWakeOrRequeueJS,
+]);
+})
+
+Lharmony-regexp-execa
+(function(a,b){
+%CheckIsBootstrapping();
+var c=a.RegExp;
+var d=b.ImportNow("RegExpSubclassExecJS");
+var e=b.ImportNow("RegExpSubclassMatch");
+var f=b.ImportNow("RegExpSubclassReplace");
+var g=b.ImportNow("RegExpSubclassSearch");
+var h=b.ImportNow("RegExpSubclassSplit");
+var i=b.ImportNow("RegExpSubclassTest");
+var j=b.ImportNow("match_symbol");
+var k=b.ImportNow("replace_symbol");
+var l=b.ImportNow("search_symbol");
+var m=b.ImportNow("split_symbol");
+b.OverrideFunction(c.prototype,"exec",
+d,true);
+b.OverrideFunction(c.prototype,j,
+e,true);
+b.OverrideFunction(c.prototype,k,
+f,true);
+b.OverrideFunction(c.prototype,l,
+g,true);
+b.OverrideFunction(c.prototype,m,
+h,true);
+b.OverrideFunction(c.prototype,"test",
+i,true);
+})
+
+Xharmony-object-observeU
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=b.ImportNow("ObserveArrayMethods");
+var d=b.ImportNow("ObserveObjectMethods");;
+b.InstallFunctions(a.Object,2,d);
+b.InstallFunctions(a.Array,2,c);
+})
+
+dharmony-sharedarraybufferE
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.SharedArrayBuffer;
+var d;
+b.Import(function(e){
+d=e.MakeTypeError;
+})
+function SharedArrayBufferGetByteLen(){
+if(!(%_ClassOf(this)==='SharedArrayBuffer')){
+throw d(44,
+'SharedArrayBuffer.prototype.byteLength',this);
+}
+return %_ArrayBufferGetByteLength(this);
+}
+b.InstallGetter(c.prototype,"byteLength",
+SharedArrayBufferGetByteLen);
+})
+
+0harmony-simd��
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.SIMD;
+var d;
+var e=b.ImportNow("to_string_tag_symbol");
+b.Import(function(f){
+d=f.MakeTypeError;
+});
+var g=c.Float32x4;
+
+
+var h=c.Int32x4;
+
+var i=c.Int16x8;
+
+var j=c.Int8x16;
+
+
+var k=c.Uint32x4;
+
+var l=c.Uint16x8;
+
+var m=c.Uint8x16;
+
+
+var n=c.Bool32x4;
+
+var o=c.Bool16x8;
+
+var p=c.Bool8x16;
+
+
+
+function Float32x4CheckJS(q){
+return %Float32x4Check(q);
+}
+function Float32x4ToString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='float32x4'){
+throw d(44,
+"Float32x4.prototype.toString",this);
+}
+var s="SIMD.Float32x4(";
+s+=%Float32x4ExtractLane(r,0);
+for(var t=1;t<4;t++){
+s+=", "+%Float32x4ExtractLane(r,t);
+}
+return s+")";
+}
+function Float32x4ToLocaleString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='float32x4'){
+throw d(44,
+"Float32x4.prototype.toLocaleString",this);
+}
+var s="SIMD.Float32x4(";
+s+=%Float32x4ExtractLane(r,0).toLocaleString();
+for(var t=1;t<4;t++){
+s+=", "+%Float32x4ExtractLane(r,t).toLocaleString();
+}
+return s+")";
+}
+function Float32x4ValueOf(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='float32x4'){
+throw d(44,
+"Float32x4.prototype.valueOf",this);
+}
+return r;
+}
+function Float32x4ExtractLaneJS(u,v){
+return %Float32x4ExtractLane(u,v);
+}
+
+
+function Int32x4CheckJS(q){
+return %Int32x4Check(q);
+}
+function Int32x4ToString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='int32x4'){
+throw d(44,
+"Int32x4.prototype.toString",this);
+}
+var s="SIMD.Int32x4(";
+s+=%Int32x4ExtractLane(r,0);
+for(var t=1;t<4;t++){
+s+=", "+%Int32x4ExtractLane(r,t);
+}
+return s+")";
+}
+function Int32x4ToLocaleString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='int32x4'){
+throw d(44,
+"Int32x4.prototype.toLocaleString",this);
+}
+var s="SIMD.Int32x4(";
+s+=%Int32x4ExtractLane(r,0).toLocaleString();
+for(var t=1;t<4;t++){
+s+=", "+%Int32x4ExtractLane(r,t).toLocaleString();
+}
+return s+")";
+}
+function Int32x4ValueOf(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='int32x4'){
+throw d(44,
+"Int32x4.prototype.valueOf",this);
+}
+return r;
+}
+function Int32x4ExtractLaneJS(u,v){
+return %Int32x4ExtractLane(u,v);
+}
+
+function Int16x8CheckJS(q){
+return %Int16x8Check(q);
+}
+function Int16x8ToString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='int16x8'){
+throw d(44,
+"Int16x8.prototype.toString",this);
+}
+var s="SIMD.Int16x8(";
+s+=%Int16x8ExtractLane(r,0);
+for(var t=1;t<8;t++){
+s+=", "+%Int16x8ExtractLane(r,t);
+}
+return s+")";
+}
+function Int16x8ToLocaleString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='int16x8'){
+throw d(44,
+"Int16x8.prototype.toLocaleString",this);
+}
+var s="SIMD.Int16x8(";
+s+=%Int16x8ExtractLane(r,0).toLocaleString();
+for(var t=1;t<8;t++){
+s+=", "+%Int16x8ExtractLane(r,t).toLocaleString();
+}
+return s+")";
+}
+function Int16x8ValueOf(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='int16x8'){
+throw d(44,
+"Int16x8.prototype.valueOf",this);
+}
+return r;
+}
+function Int16x8ExtractLaneJS(u,v){
+return %Int16x8ExtractLane(u,v);
+}
+
+function Int8x16CheckJS(q){
+return %Int8x16Check(q);
+}
+function Int8x16ToString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='int8x16'){
+throw d(44,
+"Int8x16.prototype.toString",this);
+}
+var s="SIMD.Int8x16(";
+s+=%Int8x16ExtractLane(r,0);
+for(var t=1;t<16;t++){
+s+=", "+%Int8x16ExtractLane(r,t);
+}
+return s+")";
+}
+function Int8x16ToLocaleString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='int8x16'){
+throw d(44,
+"Int8x16.prototype.toLocaleString",this);
+}
+var s="SIMD.Int8x16(";
+s+=%Int8x16ExtractLane(r,0).toLocaleString();
+for(var t=1;t<16;t++){
+s+=", "+%Int8x16ExtractLane(r,t).toLocaleString();
+}
+return s+")";
+}
+function Int8x16ValueOf(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='int8x16'){
+throw d(44,
+"Int8x16.prototype.valueOf",this);
+}
+return r;
+}
+function Int8x16ExtractLaneJS(u,v){
+return %Int8x16ExtractLane(u,v);
+}
+
+
+function Uint32x4CheckJS(q){
+return %Uint32x4Check(q);
+}
+function Uint32x4ToString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='uint32x4'){
+throw d(44,
+"Uint32x4.prototype.toString",this);
+}
+var s="SIMD.Uint32x4(";
+s+=%Uint32x4ExtractLane(r,0);
+for(var t=1;t<4;t++){
+s+=", "+%Uint32x4ExtractLane(r,t);
+}
+return s+")";
+}
+function Uint32x4ToLocaleString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='uint32x4'){
+throw d(44,
+"Uint32x4.prototype.toLocaleString",this);
+}
+var s="SIMD.Uint32x4(";
+s+=%Uint32x4ExtractLane(r,0).toLocaleString();
+for(var t=1;t<4;t++){
+s+=", "+%Uint32x4ExtractLane(r,t).toLocaleString();
+}
+return s+")";
+}
+function Uint32x4ValueOf(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='uint32x4'){
+throw d(44,
+"Uint32x4.prototype.valueOf",this);
+}
+return r;
+}
+function Uint32x4ExtractLaneJS(u,v){
+return %Uint32x4ExtractLane(u,v);
+}
+
+function Uint16x8CheckJS(q){
+return %Uint16x8Check(q);
+}
+function Uint16x8ToString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='uint16x8'){
+throw d(44,
+"Uint16x8.prototype.toString",this);
+}
+var s="SIMD.Uint16x8(";
+s+=%Uint16x8ExtractLane(r,0);
+for(var t=1;t<8;t++){
+s+=", "+%Uint16x8ExtractLane(r,t);
+}
+return s+")";
+}
+function Uint16x8ToLocaleString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='uint16x8'){
+throw d(44,
+"Uint16x8.prototype.toLocaleString",this);
+}
+var s="SIMD.Uint16x8(";
+s+=%Uint16x8ExtractLane(r,0).toLocaleString();
+for(var t=1;t<8;t++){
+s+=", "+%Uint16x8ExtractLane(r,t).toLocaleString();
+}
+return s+")";
+}
+function Uint16x8ValueOf(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='uint16x8'){
+throw d(44,
+"Uint16x8.prototype.valueOf",this);
+}
+return r;
+}
+function Uint16x8ExtractLaneJS(u,v){
+return %Uint16x8ExtractLane(u,v);
+}
+
+function Uint8x16CheckJS(q){
+return %Uint8x16Check(q);
+}
+function Uint8x16ToString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='uint8x16'){
+throw d(44,
+"Uint8x16.prototype.toString",this);
+}
+var s="SIMD.Uint8x16(";
+s+=%Uint8x16ExtractLane(r,0);
+for(var t=1;t<16;t++){
+s+=", "+%Uint8x16ExtractLane(r,t);
+}
+return s+")";
+}
+function Uint8x16ToLocaleString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='uint8x16'){
+throw d(44,
+"Uint8x16.prototype.toLocaleString",this);
+}
+var s="SIMD.Uint8x16(";
+s+=%Uint8x16ExtractLane(r,0).toLocaleString();
+for(var t=1;t<16;t++){
+s+=", "+%Uint8x16ExtractLane(r,t).toLocaleString();
+}
+return s+")";
+}
+function Uint8x16ValueOf(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='uint8x16'){
+throw d(44,
+"Uint8x16.prototype.valueOf",this);
+}
+return r;
+}
+function Uint8x16ExtractLaneJS(u,v){
+return %Uint8x16ExtractLane(u,v);
+}
+
+
+function Bool32x4CheckJS(q){
+return %Bool32x4Check(q);
+}
+function Bool32x4ToString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='bool32x4'){
+throw d(44,
+"Bool32x4.prototype.toString",this);
+}
+var s="SIMD.Bool32x4(";
+s+=%Bool32x4ExtractLane(r,0);
+for(var t=1;t<4;t++){
+s+=", "+%Bool32x4ExtractLane(r,t);
+}
+return s+")";
+}
+function Bool32x4ToLocaleString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='bool32x4'){
+throw d(44,
+"Bool32x4.prototype.toLocaleString",this);
+}
+var s="SIMD.Bool32x4(";
+s+=%Bool32x4ExtractLane(r,0).toLocaleString();
+for(var t=1;t<4;t++){
+s+=", "+%Bool32x4ExtractLane(r,t).toLocaleString();
+}
+return s+")";
+}
+function Bool32x4ValueOf(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='bool32x4'){
+throw d(44,
+"Bool32x4.prototype.valueOf",this);
+}
+return r;
+}
+function Bool32x4ExtractLaneJS(u,v){
+return %Bool32x4ExtractLane(u,v);
+}
+
+function Bool16x8CheckJS(q){
+return %Bool16x8Check(q);
+}
+function Bool16x8ToString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='bool16x8'){
+throw d(44,
+"Bool16x8.prototype.toString",this);
+}
+var s="SIMD.Bool16x8(";
+s+=%Bool16x8ExtractLane(r,0);
+for(var t=1;t<8;t++){
+s+=", "+%Bool16x8ExtractLane(r,t);
+}
+return s+")";
+}
+function Bool16x8ToLocaleString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='bool16x8'){
+throw d(44,
+"Bool16x8.prototype.toLocaleString",this);
+}
+var s="SIMD.Bool16x8(";
+s+=%Bool16x8ExtractLane(r,0).toLocaleString();
+for(var t=1;t<8;t++){
+s+=", "+%Bool16x8ExtractLane(r,t).toLocaleString();
+}
+return s+")";
+}
+function Bool16x8ValueOf(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='bool16x8'){
+throw d(44,
+"Bool16x8.prototype.valueOf",this);
+}
+return r;
+}
+function Bool16x8ExtractLaneJS(u,v){
+return %Bool16x8ExtractLane(u,v);
+}
+
+function Bool8x16CheckJS(q){
+return %Bool8x16Check(q);
+}
+function Bool8x16ToString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='bool8x16'){
+throw d(44,
+"Bool8x16.prototype.toString",this);
+}
+var s="SIMD.Bool8x16(";
+s+=%Bool8x16ExtractLane(r,0);
+for(var t=1;t<16;t++){
+s+=", "+%Bool8x16ExtractLane(r,t);
+}
+return s+")";
+}
+function Bool8x16ToLocaleString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='bool8x16'){
+throw d(44,
+"Bool8x16.prototype.toLocaleString",this);
+}
+var s="SIMD.Bool8x16(";
+s+=%Bool8x16ExtractLane(r,0).toLocaleString();
+for(var t=1;t<16;t++){
+s+=", "+%Bool8x16ExtractLane(r,t).toLocaleString();
+}
+return s+")";
+}
+function Bool8x16ValueOf(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='bool8x16'){
+throw d(44,
+"Bool8x16.prototype.valueOf",this);
+}
+return r;
+}
+function Bool8x16ExtractLaneJS(u,v){
+return %Bool8x16ExtractLane(u,v);
+}
+
+
+
+function Int32x4ShiftLeftByScalarJS(u,w){
+return %Int32x4ShiftLeftByScalar(u,w);
+}
+function Int32x4ShiftRightByScalarJS(u,w){
+return %Int32x4ShiftRightByScalar(u,w);
+}
+
+function Int16x8ShiftLeftByScalarJS(u,w){
+return %Int16x8ShiftLeftByScalar(u,w);
+}
+function Int16x8ShiftRightByScalarJS(u,w){
+return %Int16x8ShiftRightByScalar(u,w);
+}
+
+function Int8x16ShiftLeftByScalarJS(u,w){
+return %Int8x16ShiftLeftByScalar(u,w);
+}
+function Int8x16ShiftRightByScalarJS(u,w){
+return %Int8x16ShiftRightByScalar(u,w);
+}
+
+
+function Uint32x4ShiftLeftByScalarJS(u,w){
+return %Uint32x4ShiftLeftByScalar(u,w);
+}
+function Uint32x4ShiftRightByScalarJS(u,w){
+return %Uint32x4ShiftRightByScalar(u,w);
+}
+
+function Uint16x8ShiftLeftByScalarJS(u,w){
+return %Uint16x8ShiftLeftByScalar(u,w);
+}
+function Uint16x8ShiftRightByScalarJS(u,w){
+return %Uint16x8ShiftRightByScalar(u,w);
+}
+
+function Uint8x16ShiftLeftByScalarJS(u,w){
+return %Uint8x16ShiftLeftByScalar(u,w);
+}
+function Uint8x16ShiftRightByScalarJS(u,w){
+return %Uint8x16ShiftRightByScalar(u,w);
+}
+
+
+function Int16x8AddSaturateJS(q,x){
+return %Int16x8AddSaturate(q,x);
+}
+function Int16x8SubSaturateJS(q,x){
+return %Int16x8SubSaturate(q,x);
+}
+
+function Int8x16AddSaturateJS(q,x){
+return %Int8x16AddSaturate(q,x);
+}
+function Int8x16SubSaturateJS(q,x){
+return %Int8x16SubSaturate(q,x);
+}
+
+function Uint8x16AddSaturateJS(q,x){
+return %Uint8x16AddSaturate(q,x);
+}
+function Uint8x16SubSaturateJS(q,x){
+return %Uint8x16SubSaturate(q,x);
+}
+
+function Uint16x8AddSaturateJS(q,x){
+return %Uint16x8AddSaturate(q,x);
+}
+function Uint16x8SubSaturateJS(q,x){
+return %Uint16x8SubSaturate(q,x);
+}
+
+
+function Float32x4NegJS(q){
+return %Float32x4Neg(q);
+}
+
+
+function Int32x4NegJS(q){
+return %Int32x4Neg(q);
+}
+
+function Int16x8NegJS(q){
+return %Int16x8Neg(q);
+}
+
+function Int8x16NegJS(q){
+return %Int8x16Neg(q);
+}
+
+
+function Bool32x4ReplaceLaneJS(u,v,r){
+return %Bool32x4ReplaceLane(u,v,r);
+}
+function Bool32x4AnyTrueJS(y){
+return %Bool32x4AnyTrue(y);
+}
+function Bool32x4AllTrueJS(y){
+return %Bool32x4AllTrue(y);
+}
+
+function Bool16x8ReplaceLaneJS(u,v,r){
+return %Bool16x8ReplaceLane(u,v,r);
+}
+function Bool16x8AnyTrueJS(y){
+return %Bool16x8AnyTrue(y);
+}
+function Bool16x8AllTrueJS(y){
+return %Bool16x8AllTrue(y);
+}
+
+function Bool8x16ReplaceLaneJS(u,v,r){
+return %Bool8x16ReplaceLane(u,v,r);
+}
+function Bool8x16AnyTrueJS(y){
+return %Bool8x16AnyTrue(y);
+}
+function Bool8x16AllTrueJS(y){
+return %Bool8x16AllTrue(y);
+}
+
+
+function Float32x4ReplaceLaneJS(u,v,r){
+return %Float32x4ReplaceLane(u,v,(%_ToNumber(r)));
+}
+function Float32x4SelectJS(z,q,x){
+return %Float32x4Select(z,q,x);
+}
+function Float32x4AddJS(q,x){
+return %Float32x4Add(q,x);
+}
+function Float32x4SubJS(q,x){
+return %Float32x4Sub(q,x);
+}
+function Float32x4MulJS(q,x){
+return %Float32x4Mul(q,x);
+}
+function Float32x4MinJS(q,x){
+return %Float32x4Min(q,x);
+}
+function Float32x4MaxJS(q,x){
+return %Float32x4Max(q,x);
+}
+function Float32x4EqualJS(q,x){
+return %Float32x4Equal(q,x);
+}
+function Float32x4NotEqualJS(q,x){
+return %Float32x4NotEqual(q,x);
+}
+function Float32x4LessThanJS(q,x){
+return %Float32x4LessThan(q,x);
+}
+function Float32x4LessThanOrEqualJS(q,x){
+return %Float32x4LessThanOrEqual(q,x);
+}
+function Float32x4GreaterThanJS(q,x){
+return %Float32x4GreaterThan(q,x);
+}
+function Float32x4GreaterThanOrEqualJS(q,x){
+return %Float32x4GreaterThanOrEqual(q,x);
+}
+function Float32x4LoadJS(A,B){
+return %Float32x4Load(A,B);
+}
+function Float32x4StoreJS(A,B,q){
+return %Float32x4Store(A,B,q);
+}
+
+
+function Int32x4ReplaceLaneJS(u,v,r){
+return %Int32x4ReplaceLane(u,v,(%_ToNumber(r)));
+}
+function Int32x4SelectJS(z,q,x){
+return %Int32x4Select(z,q,x);
+}
+function Int32x4AddJS(q,x){
+return %Int32x4Add(q,x);
+}
+function Int32x4SubJS(q,x){
+return %Int32x4Sub(q,x);
+}
+function Int32x4MulJS(q,x){
+return %Int32x4Mul(q,x);
+}
+function Int32x4MinJS(q,x){
+return %Int32x4Min(q,x);
+}
+function Int32x4MaxJS(q,x){
+return %Int32x4Max(q,x);
+}
+function Int32x4EqualJS(q,x){
+return %Int32x4Equal(q,x);
+}
+function Int32x4NotEqualJS(q,x){
+return %Int32x4NotEqual(q,x);
+}
+function Int32x4LessThanJS(q,x){
+return %Int32x4LessThan(q,x);
+}
+function Int32x4LessThanOrEqualJS(q,x){
+return %Int32x4LessThanOrEqual(q,x);
+}
+function Int32x4GreaterThanJS(q,x){
+return %Int32x4GreaterThan(q,x);
+}
+function Int32x4GreaterThanOrEqualJS(q,x){
+return %Int32x4GreaterThanOrEqual(q,x);
+}
+function Int32x4LoadJS(A,B){
+return %Int32x4Load(A,B);
+}
+function Int32x4StoreJS(A,B,q){
+return %Int32x4Store(A,B,q);
+}
+
+function Int16x8ReplaceLaneJS(u,v,r){
+return %Int16x8ReplaceLane(u,v,(%_ToNumber(r)));
+}
+function Int16x8SelectJS(z,q,x){
+return %Int16x8Select(z,q,x);
+}
+function Int16x8AddJS(q,x){
+return %Int16x8Add(q,x);
+}
+function Int16x8SubJS(q,x){
+return %Int16x8Sub(q,x);
+}
+function Int16x8MulJS(q,x){
+return %Int16x8Mul(q,x);
+}
+function Int16x8MinJS(q,x){
+return %Int16x8Min(q,x);
+}
+function Int16x8MaxJS(q,x){
+return %Int16x8Max(q,x);
+}
+function Int16x8EqualJS(q,x){
+return %Int16x8Equal(q,x);
+}
+function Int16x8NotEqualJS(q,x){
+return %Int16x8NotEqual(q,x);
+}
+function Int16x8LessThanJS(q,x){
+return %Int16x8LessThan(q,x);
+}
+function Int16x8LessThanOrEqualJS(q,x){
+return %Int16x8LessThanOrEqual(q,x);
+}
+function Int16x8GreaterThanJS(q,x){
+return %Int16x8GreaterThan(q,x);
+}
+function Int16x8GreaterThanOrEqualJS(q,x){
+return %Int16x8GreaterThanOrEqual(q,x);
+}
+function Int16x8LoadJS(A,B){
+return %Int16x8Load(A,B);
+}
+function Int16x8StoreJS(A,B,q){
+return %Int16x8Store(A,B,q);
+}
+
+function Int8x16ReplaceLaneJS(u,v,r){
+return %Int8x16ReplaceLane(u,v,(%_ToNumber(r)));
+}
+function Int8x16SelectJS(z,q,x){
+return %Int8x16Select(z,q,x);
+}
+function Int8x16AddJS(q,x){
+return %Int8x16Add(q,x);
+}
+function Int8x16SubJS(q,x){
+return %Int8x16Sub(q,x);
+}
+function Int8x16MulJS(q,x){
+return %Int8x16Mul(q,x);
+}
+function Int8x16MinJS(q,x){
+return %Int8x16Min(q,x);
+}
+function Int8x16MaxJS(q,x){
+return %Int8x16Max(q,x);
+}
+function Int8x16EqualJS(q,x){
+return %Int8x16Equal(q,x);
+}
+function Int8x16NotEqualJS(q,x){
+return %Int8x16NotEqual(q,x);
+}
+function Int8x16LessThanJS(q,x){
+return %Int8x16LessThan(q,x);
+}
+function Int8x16LessThanOrEqualJS(q,x){
+return %Int8x16LessThanOrEqual(q,x);
+}
+function Int8x16GreaterThanJS(q,x){
+return %Int8x16GreaterThan(q,x);
+}
+function Int8x16GreaterThanOrEqualJS(q,x){
+return %Int8x16GreaterThanOrEqual(q,x);
+}
+function Int8x16LoadJS(A,B){
+return %Int8x16Load(A,B);
+}
+function Int8x16StoreJS(A,B,q){
+return %Int8x16Store(A,B,q);
+}
+
+
+function Uint32x4ReplaceLaneJS(u,v,r){
+return %Uint32x4ReplaceLane(u,v,(%_ToNumber(r)));
+}
+function Uint32x4SelectJS(z,q,x){
+return %Uint32x4Select(z,q,x);
+}
+function Uint32x4AddJS(q,x){
+return %Uint32x4Add(q,x);
+}
+function Uint32x4SubJS(q,x){
+return %Uint32x4Sub(q,x);
+}
+function Uint32x4MulJS(q,x){
+return %Uint32x4Mul(q,x);
+}
+function Uint32x4MinJS(q,x){
+return %Uint32x4Min(q,x);
+}
+function Uint32x4MaxJS(q,x){
+return %Uint32x4Max(q,x);
+}
+function Uint32x4EqualJS(q,x){
+return %Uint32x4Equal(q,x);
+}
+function Uint32x4NotEqualJS(q,x){
+return %Uint32x4NotEqual(q,x);
+}
+function Uint32x4LessThanJS(q,x){
+return %Uint32x4LessThan(q,x);
+}
+function Uint32x4LessThanOrEqualJS(q,x){
+return %Uint32x4LessThanOrEqual(q,x);
+}
+function Uint32x4GreaterThanJS(q,x){
+return %Uint32x4GreaterThan(q,x);
+}
+function Uint32x4GreaterThanOrEqualJS(q,x){
+return %Uint32x4GreaterThanOrEqual(q,x);
+}
+function Uint32x4LoadJS(A,B){
+return %Uint32x4Load(A,B);
+}
+function Uint32x4StoreJS(A,B,q){
+return %Uint32x4Store(A,B,q);
+}
+
+function Uint16x8ReplaceLaneJS(u,v,r){
+return %Uint16x8ReplaceLane(u,v,(%_ToNumber(r)));
+}
+function Uint16x8SelectJS(z,q,x){
+return %Uint16x8Select(z,q,x);
+}
+function Uint16x8AddJS(q,x){
+return %Uint16x8Add(q,x);
+}
+function Uint16x8SubJS(q,x){
+return %Uint16x8Sub(q,x);
+}
+function Uint16x8MulJS(q,x){
+return %Uint16x8Mul(q,x);
+}
+function Uint16x8MinJS(q,x){
+return %Uint16x8Min(q,x);
+}
+function Uint16x8MaxJS(q,x){
+return %Uint16x8Max(q,x);
+}
+function Uint16x8EqualJS(q,x){
+return %Uint16x8Equal(q,x);
+}
+function Uint16x8NotEqualJS(q,x){
+return %Uint16x8NotEqual(q,x);
+}
+function Uint16x8LessThanJS(q,x){
+return %Uint16x8LessThan(q,x);
+}
+function Uint16x8LessThanOrEqualJS(q,x){
+return %Uint16x8LessThanOrEqual(q,x);
+}
+function Uint16x8GreaterThanJS(q,x){
+return %Uint16x8GreaterThan(q,x);
+}
+function Uint16x8GreaterThanOrEqualJS(q,x){
+return %Uint16x8GreaterThanOrEqual(q,x);
+}
+function Uint16x8LoadJS(A,B){
+return %Uint16x8Load(A,B);
+}
+function Uint16x8StoreJS(A,B,q){
+return %Uint16x8Store(A,B,q);
+}
+
+function Uint8x16ReplaceLaneJS(u,v,r){
+return %Uint8x16ReplaceLane(u,v,(%_ToNumber(r)));
+}
+function Uint8x16SelectJS(z,q,x){
+return %Uint8x16Select(z,q,x);
+}
+function Uint8x16AddJS(q,x){
+return %Uint8x16Add(q,x);
+}
+function Uint8x16SubJS(q,x){
+return %Uint8x16Sub(q,x);
+}
+function Uint8x16MulJS(q,x){
+return %Uint8x16Mul(q,x);
+}
+function Uint8x16MinJS(q,x){
+return %Uint8x16Min(q,x);
+}
+function Uint8x16MaxJS(q,x){
+return %Uint8x16Max(q,x);
+}
+function Uint8x16EqualJS(q,x){
+return %Uint8x16Equal(q,x);
+}
+function Uint8x16NotEqualJS(q,x){
+return %Uint8x16NotEqual(q,x);
+}
+function Uint8x16LessThanJS(q,x){
+return %Uint8x16LessThan(q,x);
+}
+function Uint8x16LessThanOrEqualJS(q,x){
+return %Uint8x16LessThanOrEqual(q,x);
+}
+function Uint8x16GreaterThanJS(q,x){
+return %Uint8x16GreaterThan(q,x);
+}
+function Uint8x16GreaterThanOrEqualJS(q,x){
+return %Uint8x16GreaterThanOrEqual(q,x);
+}
+function Uint8x16LoadJS(A,B){
+return %Uint8x16Load(A,B);
+}
+function Uint8x16StoreJS(A,B,q){
+return %Uint8x16Store(A,B,q);
+}
+
+
+
+function Int32x4AndJS(q,x){
+return %Int32x4And(q,x);
+}
+function Int32x4OrJS(q,x){
+return %Int32x4Or(q,x);
+}
+function Int32x4XorJS(q,x){
+return %Int32x4Xor(q,x);
+}
+function Int32x4NotJS(q){
+return %Int32x4Not(q);
+}
+
+function Int16x8AndJS(q,x){
+return %Int16x8And(q,x);
+}
+function Int16x8OrJS(q,x){
+return %Int16x8Or(q,x);
+}
+function Int16x8XorJS(q,x){
+return %Int16x8Xor(q,x);
+}
+function Int16x8NotJS(q){
+return %Int16x8Not(q);
+}
+
+function Int8x16AndJS(q,x){
+return %Int8x16And(q,x);
+}
+function Int8x16OrJS(q,x){
+return %Int8x16Or(q,x);
+}
+function Int8x16XorJS(q,x){
+return %Int8x16Xor(q,x);
+}
+function Int8x16NotJS(q){
+return %Int8x16Not(q);
+}
+
+
+function Uint32x4AndJS(q,x){
+return %Uint32x4And(q,x);
+}
+function Uint32x4OrJS(q,x){
+return %Uint32x4Or(q,x);
+}
+function Uint32x4XorJS(q,x){
+return %Uint32x4Xor(q,x);
+}
+function Uint32x4NotJS(q){
+return %Uint32x4Not(q);
+}
+
+function Uint16x8AndJS(q,x){
+return %Uint16x8And(q,x);
+}
+function Uint16x8OrJS(q,x){
+return %Uint16x8Or(q,x);
+}
+function Uint16x8XorJS(q,x){
+return %Uint16x8Xor(q,x);
+}
+function Uint16x8NotJS(q){
+return %Uint16x8Not(q);
+}
+
+function Uint8x16AndJS(q,x){
+return %Uint8x16And(q,x);
+}
+function Uint8x16OrJS(q,x){
+return %Uint8x16Or(q,x);
+}
+function Uint8x16XorJS(q,x){
+return %Uint8x16Xor(q,x);
+}
+function Uint8x16NotJS(q){
+return %Uint8x16Not(q);
+}
+
+
+function Bool32x4AndJS(q,x){
+return %Bool32x4And(q,x);
+}
+function Bool32x4OrJS(q,x){
+return %Bool32x4Or(q,x);
+}
+function Bool32x4XorJS(q,x){
+return %Bool32x4Xor(q,x);
+}
+function Bool32x4NotJS(q){
+return %Bool32x4Not(q);
+}
+
+function Bool16x8AndJS(q,x){
+return %Bool16x8And(q,x);
+}
+function Bool16x8OrJS(q,x){
+return %Bool16x8Or(q,x);
+}
+function Bool16x8XorJS(q,x){
+return %Bool16x8Xor(q,x);
+}
+function Bool16x8NotJS(q){
+return %Bool16x8Not(q);
+}
+
+function Bool8x16AndJS(q,x){
+return %Bool8x16And(q,x);
+}
+function Bool8x16OrJS(q,x){
+return %Bool8x16Or(q,x);
+}
+function Bool8x16XorJS(q,x){
+return %Bool8x16Xor(q,x);
+}
+function Bool8x16NotJS(q){
+return %Bool8x16Not(q);
+}
+
+
+
+function Float32x4FromInt32x4JS(q){
+return %Float32x4FromInt32x4(q);
+}
+
+function Float32x4FromUint32x4JS(q){
+return %Float32x4FromUint32x4(q);
+}
+
+function Int32x4FromFloat32x4JS(q){
+return %Int32x4FromFloat32x4(q);
+}
+
+function Int32x4FromUint32x4JS(q){
+return %Int32x4FromUint32x4(q);
+}
+
+function Uint32x4FromFloat32x4JS(q){
+return %Uint32x4FromFloat32x4(q);
+}
+
+function Uint32x4FromInt32x4JS(q){
+return %Uint32x4FromInt32x4(q);
+}
+
+function Int16x8FromUint16x8JS(q){
+return %Int16x8FromUint16x8(q);
+}
+
+function Uint16x8FromInt16x8JS(q){
+return %Uint16x8FromInt16x8(q);
+}
+
+function Int8x16FromUint8x16JS(q){
+return %Int8x16FromUint8x16(q);
+}
+
+function Uint8x16FromInt8x16JS(q){
+return %Uint8x16FromInt8x16(q);
+}
+
+
+function Float32x4FromInt32x4BitsJS(q){
+return %Float32x4FromInt32x4Bits(q);
+}
+
+function Float32x4FromUint32x4BitsJS(q){
+return %Float32x4FromUint32x4Bits(q);
+}
+
+function Float32x4FromInt16x8BitsJS(q){
+return %Float32x4FromInt16x8Bits(q);
+}
+
+function Float32x4FromUint16x8BitsJS(q){
+return %Float32x4FromUint16x8Bits(q);
+}
+
+function Float32x4FromInt8x16BitsJS(q){
+return %Float32x4FromInt8x16Bits(q);
+}
+
+function Float32x4FromUint8x16BitsJS(q){
+return %Float32x4FromUint8x16Bits(q);
+}
+
+function Int32x4FromFloat32x4BitsJS(q){
+return %Int32x4FromFloat32x4Bits(q);
+}
+
+function Int32x4FromUint32x4BitsJS(q){
+return %Int32x4FromUint32x4Bits(q);
+}
+
+function Int32x4FromInt16x8BitsJS(q){
+return %Int32x4FromInt16x8Bits(q);
+}
+
+function Int32x4FromUint16x8BitsJS(q){
+return %Int32x4FromUint16x8Bits(q);
+}
+
+function Int32x4FromInt8x16BitsJS(q){
+return %Int32x4FromInt8x16Bits(q);
+}
+
+function Int32x4FromUint8x16BitsJS(q){
+return %Int32x4FromUint8x16Bits(q);
+}
+
+function Uint32x4FromFloat32x4BitsJS(q){
+return %Uint32x4FromFloat32x4Bits(q);
+}
+
+function Uint32x4FromInt32x4BitsJS(q){
+return %Uint32x4FromInt32x4Bits(q);
+}
+
+function Uint32x4FromInt16x8BitsJS(q){
+return %Uint32x4FromInt16x8Bits(q);
+}
+
+function Uint32x4FromUint16x8BitsJS(q){
+return %Uint32x4FromUint16x8Bits(q);
+}
+
+function Uint32x4FromInt8x16BitsJS(q){
+return %Uint32x4FromInt8x16Bits(q);
+}
+
+function Uint32x4FromUint8x16BitsJS(q){
+return %Uint32x4FromUint8x16Bits(q);
+}
+
+function Int16x8FromFloat32x4BitsJS(q){
+return %Int16x8FromFloat32x4Bits(q);
+}
+
+function Int16x8FromInt32x4BitsJS(q){
+return %Int16x8FromInt32x4Bits(q);
+}
+
+function Int16x8FromUint32x4BitsJS(q){
+return %Int16x8FromUint32x4Bits(q);
+}
+
+function Int16x8FromUint16x8BitsJS(q){
+return %Int16x8FromUint16x8Bits(q);
+}
+
+function Int16x8FromInt8x16BitsJS(q){
+return %Int16x8FromInt8x16Bits(q);
+}
+
+function Int16x8FromUint8x16BitsJS(q){
+return %Int16x8FromUint8x16Bits(q);
+}
+
+function Uint16x8FromFloat32x4BitsJS(q){
+return %Uint16x8FromFloat32x4Bits(q);
+}
+
+function Uint16x8FromInt32x4BitsJS(q){
+return %Uint16x8FromInt32x4Bits(q);
+}
+
+function Uint16x8FromUint32x4BitsJS(q){
+return %Uint16x8FromUint32x4Bits(q);
+}
+
+function Uint16x8FromInt16x8BitsJS(q){
+return %Uint16x8FromInt16x8Bits(q);
+}
+
+function Uint16x8FromInt8x16BitsJS(q){
+return %Uint16x8FromInt8x16Bits(q);
+}
+
+function Uint16x8FromUint8x16BitsJS(q){
+return %Uint16x8FromUint8x16Bits(q);
+}
+
+function Int8x16FromFloat32x4BitsJS(q){
+return %Int8x16FromFloat32x4Bits(q);
+}
+
+function Int8x16FromInt32x4BitsJS(q){
+return %Int8x16FromInt32x4Bits(q);
+}
+
+function Int8x16FromUint32x4BitsJS(q){
+return %Int8x16FromUint32x4Bits(q);
+}
+
+function Int8x16FromInt16x8BitsJS(q){
+return %Int8x16FromInt16x8Bits(q);
+}
+
+function Int8x16FromUint16x8BitsJS(q){
+return %Int8x16FromUint16x8Bits(q);
+}
+
+function Int8x16FromUint8x16BitsJS(q){
+return %Int8x16FromUint8x16Bits(q);
+}
+
+function Uint8x16FromFloat32x4BitsJS(q){
+return %Uint8x16FromFloat32x4Bits(q);
+}
+
+function Uint8x16FromInt32x4BitsJS(q){
+return %Uint8x16FromInt32x4Bits(q);
+}
+
+function Uint8x16FromUint32x4BitsJS(q){
+return %Uint8x16FromUint32x4Bits(q);
+}
+
+function Uint8x16FromInt16x8BitsJS(q){
+return %Uint8x16FromInt16x8Bits(q);
+}
+
+function Uint8x16FromUint16x8BitsJS(q){
+return %Uint8x16FromUint16x8Bits(q);
+}
+
+function Uint8x16FromInt8x16BitsJS(q){
+return %Uint8x16FromInt8x16Bits(q);
+}
+
+
+function Float32x4Load1JS(A,B){
+return %Float32x4Load1(A,B);
+}
+function Float32x4Store1JS(A,B,q){
+return %Float32x4Store1(A,B,q);
+}
+
+function Float32x4Load2JS(A,B){
+return %Float32x4Load2(A,B);
+}
+function Float32x4Store2JS(A,B,q){
+return %Float32x4Store2(A,B,q);
+}
+
+function Float32x4Load3JS(A,B){
+return %Float32x4Load3(A,B);
+}
+function Float32x4Store3JS(A,B,q){
+return %Float32x4Store3(A,B,q);
+}
+
+function Int32x4Load1JS(A,B){
+return %Int32x4Load1(A,B);
+}
+function Int32x4Store1JS(A,B,q){
+return %Int32x4Store1(A,B,q);
+}
+
+function Int32x4Load2JS(A,B){
+return %Int32x4Load2(A,B);
+}
+function Int32x4Store2JS(A,B,q){
+return %Int32x4Store2(A,B,q);
+}
+
+function Int32x4Load3JS(A,B){
+return %Int32x4Load3(A,B);
+}
+function Int32x4Store3JS(A,B,q){
+return %Int32x4Store3(A,B,q);
+}
+
+function Uint32x4Load1JS(A,B){
+return %Uint32x4Load1(A,B);
+}
+function Uint32x4Store1JS(A,B,q){
+return %Uint32x4Store1(A,B,q);
+}
+
+function Uint32x4Load2JS(A,B){
+return %Uint32x4Load2(A,B);
+}
+function Uint32x4Store2JS(A,B,q){
+return %Uint32x4Store2(A,B,q);
+}
+
+function Uint32x4Load3JS(A,B){
+return %Uint32x4Load3(A,B);
+}
+function Uint32x4Store3JS(A,B,q){
+return %Uint32x4Store3(A,B,q);
+}
+
+
+function Float32x4Splat(y){
+return %CreateFloat32x4(y,y,y,y);
+}
+function Float32x4SwizzleJS(q,C,D,E,F){
+return %Float32x4Swizzle(q,C,D,E,F);
+}
+function Float32x4ShuffleJS(q,x,C,D,E,F){
+return %Float32x4Shuffle(q,x,C,D,E,F);
+}
+
+function Int32x4Splat(y){
+return %CreateInt32x4(y,y,y,y);
+}
+function Int32x4SwizzleJS(q,C,D,E,F){
+return %Int32x4Swizzle(q,C,D,E,F);
+}
+function Int32x4ShuffleJS(q,x,C,D,E,F){
+return %Int32x4Shuffle(q,x,C,D,E,F);
+}
+
+function Uint32x4Splat(y){
+return %CreateUint32x4(y,y,y,y);
+}
+function Uint32x4SwizzleJS(q,C,D,E,F){
+return %Uint32x4Swizzle(q,C,D,E,F);
+}
+function Uint32x4ShuffleJS(q,x,C,D,E,F){
+return %Uint32x4Shuffle(q,x,C,D,E,F);
+}
+
+function Bool32x4Splat(y){
+return %CreateBool32x4(y,y,y,y);
+}
+function Bool32x4SwizzleJS(q,C,D,E,F){
+return %Bool32x4Swizzle(q,C,D,E,F);
+}
+function Bool32x4ShuffleJS(q,x,C,D,E,F){
+return %Bool32x4Shuffle(q,x,C,D,E,F);
+}
+
+
+function Int16x8Splat(y){
+return %CreateInt16x8(y,y,y,y,y,y,y,y);
+}
+function Int16x8SwizzleJS(q,C,D,E,F,G,H,I,J){
+return %Int16x8Swizzle(q,C,D,E,F,G,H,I,J);
+}
+function Int16x8ShuffleJS(q,x,C,D,E,F,G,H,I,J){
+return %Int16x8Shuffle(q,x,C,D,E,F,G,H,I,J);
+}
+
+function Uint16x8Splat(y){
+return %CreateUint16x8(y,y,y,y,y,y,y,y);
+}
+function Uint16x8SwizzleJS(q,C,D,E,F,G,H,I,J){
+return %Uint16x8Swizzle(q,C,D,E,F,G,H,I,J);
+}
+function Uint16x8ShuffleJS(q,x,C,D,E,F,G,H,I,J){
+return %Uint16x8Shuffle(q,x,C,D,E,F,G,H,I,J);
+}
+
+function Bool16x8Splat(y){
+return %CreateBool16x8(y,y,y,y,y,y,y,y);
+}
+function Bool16x8SwizzleJS(q,C,D,E,F,G,H,I,J){
+return %Bool16x8Swizzle(q,C,D,E,F,G,H,I,J);
+}
+function Bool16x8ShuffleJS(q,x,C,D,E,F,G,H,I,J){
+return %Bool16x8Shuffle(q,x,C,D,E,F,G,H,I,J);
+}
+
+
+function Int8x16Splat(y){
+return %CreateInt8x16(y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y);
+}
+function Int8x16SwizzleJS(q,C,D,E,F,G,H,I,J,c8,c9,c10,c11,
+c12,c13,c14,c15){
+return %Int8x16Swizzle(q,C,D,E,F,G,H,I,J,c8,c9,c10,c11,
+c12,c13,c14,c15);
+}
+function Int8x16ShuffleJS(q,x,C,D,E,F,G,H,I,J,c8,c9,c10,
+c11,c12,c13,c14,c15){
+return %Int8x16Shuffle(q,x,C,D,E,F,G,H,I,J,c8,c9,c10,
+c11,c12,c13,c14,c15);
+}
+
+function Uint8x16Splat(y){
+return %CreateUint8x16(y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y);
+}
+function Uint8x16SwizzleJS(q,C,D,E,F,G,H,I,J,c8,c9,c10,c11,
+c12,c13,c14,c15){
+return %Uint8x16Swizzle(q,C,D,E,F,G,H,I,J,c8,c9,c10,c11,
+c12,c13,c14,c15);
+}
+function Uint8x16ShuffleJS(q,x,C,D,E,F,G,H,I,J,c8,c9,c10,
+c11,c12,c13,c14,c15){
+return %Uint8x16Shuffle(q,x,C,D,E,F,G,H,I,J,c8,c9,c10,
+c11,c12,c13,c14,c15);
+}
+
+function Bool8x16Splat(y){
+return %CreateBool8x16(y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y);
+}
+function Bool8x16SwizzleJS(q,C,D,E,F,G,H,I,J,c8,c9,c10,c11,
+c12,c13,c14,c15){
+return %Bool8x16Swizzle(q,C,D,E,F,G,H,I,J,c8,c9,c10,c11,
+c12,c13,c14,c15);
+}
+function Bool8x16ShuffleJS(q,x,C,D,E,F,G,H,I,J,c8,c9,c10,
+c11,c12,c13,c14,c15){
+return %Bool8x16Shuffle(q,x,C,D,E,F,G,H,I,J,c8,c9,c10,
+c11,c12,c13,c14,c15);
+}
+
+
+function Float32x4Constructor(C,D,E,F){
+if(!(new.target===(void 0))){
+throw d(66,"Float32x4");
+}
+return %CreateFloat32x4((%_ToNumber(C)),(%_ToNumber(D)),
+(%_ToNumber(E)),(%_ToNumber(F)));
+}
+function Int32x4Constructor(C,D,E,F){
+if(!(new.target===(void 0))){
+throw d(66,"Int32x4");
+}
+return %CreateInt32x4((%_ToNumber(C)),(%_ToNumber(D)),
+(%_ToNumber(E)),(%_ToNumber(F)));
+}
+function Uint32x4Constructor(C,D,E,F){
+if(!(new.target===(void 0))){
+throw d(66,"Uint32x4");
+}
+return %CreateUint32x4((%_ToNumber(C)),(%_ToNumber(D)),
+(%_ToNumber(E)),(%_ToNumber(F)));
+}
+function Bool32x4Constructor(C,D,E,F){
+if(!(new.target===(void 0))){
+throw d(66,"Bool32x4");
+}
+return %CreateBool32x4(C,D,E,F);
+}
+function Int16x8Constructor(C,D,E,F,G,H,I,J){
+if(!(new.target===(void 0))){
+throw d(66,"Int16x8");
+}
+return %CreateInt16x8((%_ToNumber(C)),(%_ToNumber(D)),
+(%_ToNumber(E)),(%_ToNumber(F)),
+(%_ToNumber(G)),(%_ToNumber(H)),
+(%_ToNumber(I)),(%_ToNumber(J)));
+}
+function Uint16x8Constructor(C,D,E,F,G,H,I,J){
+if(!(new.target===(void 0))){
+throw d(66,"Uint16x8");
+}
+return %CreateUint16x8((%_ToNumber(C)),(%_ToNumber(D)),
+(%_ToNumber(E)),(%_ToNumber(F)),
+(%_ToNumber(G)),(%_ToNumber(H)),
+(%_ToNumber(I)),(%_ToNumber(J)));
+}
+function Bool16x8Constructor(C,D,E,F,G,H,I,J){
+if(!(new.target===(void 0))){
+throw d(66,"Bool16x8");
+}
+return %CreateBool16x8(C,D,E,F,G,H,I,J);
+}
+function Int8x16Constructor(C,D,E,F,G,H,I,J,c8,c9,c10,c11,
+c12,c13,c14,c15){
+if(!(new.target===(void 0))){
+throw d(66,"Int8x16");
+}
+return %CreateInt8x16((%_ToNumber(C)),(%_ToNumber(D)),
+(%_ToNumber(E)),(%_ToNumber(F)),
+(%_ToNumber(G)),(%_ToNumber(H)),
+(%_ToNumber(I)),(%_ToNumber(J)),
+(%_ToNumber(c8)),(%_ToNumber(c9)),
+(%_ToNumber(c10)),(%_ToNumber(c11)),
+(%_ToNumber(c12)),(%_ToNumber(c13)),
+(%_ToNumber(c14)),(%_ToNumber(c15)));
+}
+function Uint8x16Constructor(C,D,E,F,G,H,I,J,c8,c9,c10,c11,
+c12,c13,c14,c15){
+if(!(new.target===(void 0))){
+throw d(66,"Uint8x16");
+}
+return %CreateUint8x16((%_ToNumber(C)),(%_ToNumber(D)),
+(%_ToNumber(E)),(%_ToNumber(F)),
+(%_ToNumber(G)),(%_ToNumber(H)),
+(%_ToNumber(I)),(%_ToNumber(J)),
+(%_ToNumber(c8)),(%_ToNumber(c9)),
+(%_ToNumber(c10)),(%_ToNumber(c11)),
+(%_ToNumber(c12)),(%_ToNumber(c13)),
+(%_ToNumber(c14)),(%_ToNumber(c15)));
+}
+function Bool8x16Constructor(C,D,E,F,G,H,I,J,c8,c9,c10,c11,
+c12,c13,c14,c15){
+if(!(new.target===(void 0))){
+throw d(66,"Bool8x16");
+}
+return %CreateBool8x16(C,D,E,F,G,H,I,J,c8,c9,c10,c11,c12,
+c13,c14,c15);
+}
+function Float32x4AbsJS(q){
+return %Float32x4Abs(q);
+}
+function Float32x4SqrtJS(q){
+return %Float32x4Sqrt(q);
+}
+function Float32x4RecipApproxJS(q){
+return %Float32x4RecipApprox(q);
+}
+function Float32x4RecipSqrtApproxJS(q){
+return %Float32x4RecipSqrtApprox(q);
+}
+function Float32x4DivJS(q,x){
+return %Float32x4Div(q,x);
+}
+function Float32x4MinNumJS(q,x){
+return %Float32x4MinNum(q,x);
+}
+function Float32x4MaxNumJS(q,x){
+return %Float32x4MaxNum(q,x);
+}
+%AddNamedProperty(c,e,'SIMD',1|2);
+%SetCode(g,Float32x4Constructor);
+%FunctionSetPrototype(g,{});
+%AddNamedProperty(g.prototype,'constructor',g,
+2);
+%AddNamedProperty(g.prototype,e,'Float32x4',
+2|1);
+b.InstallFunctions(g.prototype,2,[
+'toLocaleString',Float32x4ToLocaleString,
+'toString',Float32x4ToString,
+'valueOf',Float32x4ValueOf,
+]);
+
+
+%SetCode(h,Int32x4Constructor);
+%FunctionSetPrototype(h,{});
+%AddNamedProperty(h.prototype,'constructor',h,
+2);
+%AddNamedProperty(h.prototype,e,'Int32x4',
+2|1);
+b.InstallFunctions(h.prototype,2,[
+'toLocaleString',Int32x4ToLocaleString,
+'toString',Int32x4ToString,
+'valueOf',Int32x4ValueOf,
+]);
+
+%SetCode(i,Int16x8Constructor);
+%FunctionSetPrototype(i,{});
+%AddNamedProperty(i.prototype,'constructor',i,
+2);
+%AddNamedProperty(i.prototype,e,'Int16x8',
+2|1);
+b.InstallFunctions(i.prototype,2,[
+'toLocaleString',Int16x8ToLocaleString,
+'toString',Int16x8ToString,
+'valueOf',Int16x8ValueOf,
+]);
+
+%SetCode(j,Int8x16Constructor);
+%FunctionSetPrototype(j,{});
+%AddNamedProperty(j.prototype,'constructor',j,
+2);
+%AddNamedProperty(j.prototype,e,'Int8x16',
+2|1);
+b.InstallFunctions(j.prototype,2,[
+'toLocaleString',Int8x16ToLocaleString,
+'toString',Int8x16ToString,
+'valueOf',Int8x16ValueOf,
+]);
+
+
+%SetCode(k,Uint32x4Constructor);
+%FunctionSetPrototype(k,{});
+%AddNamedProperty(k.prototype,'constructor',k,
+2);
+%AddNamedProperty(k.prototype,e,'Uint32x4',
+2|1);
+b.InstallFunctions(k.prototype,2,[
+'toLocaleString',Uint32x4ToLocaleString,
+'toString',Uint32x4ToString,
+'valueOf',Uint32x4ValueOf,
+]);
+
+%SetCode(l,Uint16x8Constructor);
+%FunctionSetPrototype(l,{});
+%AddNamedProperty(l.prototype,'constructor',l,
+2);
+%AddNamedProperty(l.prototype,e,'Uint16x8',
+2|1);
+b.InstallFunctions(l.prototype,2,[
+'toLocaleString',Uint16x8ToLocaleString,
+'toString',Uint16x8ToString,
+'valueOf',Uint16x8ValueOf,
+]);
+
+%SetCode(m,Uint8x16Constructor);
+%FunctionSetPrototype(m,{});
+%AddNamedProperty(m.prototype,'constructor',m,
+2);
+%AddNamedProperty(m.prototype,e,'Uint8x16',
+2|1);
+b.InstallFunctions(m.prototype,2,[
+'toLocaleString',Uint8x16ToLocaleString,
+'toString',Uint8x16ToString,
+'valueOf',Uint8x16ValueOf,
+]);
+
+
+%SetCode(n,Bool32x4Constructor);
+%FunctionSetPrototype(n,{});
+%AddNamedProperty(n.prototype,'constructor',n,
+2);
+%AddNamedProperty(n.prototype,e,'Bool32x4',
+2|1);
+b.InstallFunctions(n.prototype,2,[
+'toLocaleString',Bool32x4ToLocaleString,
+'toString',Bool32x4ToString,
+'valueOf',Bool32x4ValueOf,
+]);
+
+%SetCode(o,Bool16x8Constructor);
+%FunctionSetPrototype(o,{});
+%AddNamedProperty(o.prototype,'constructor',o,
+2);
+%AddNamedProperty(o.prototype,e,'Bool16x8',
+2|1);
+b.InstallFunctions(o.prototype,2,[
+'toLocaleString',Bool16x8ToLocaleString,
+'toString',Bool16x8ToString,
+'valueOf',Bool16x8ValueOf,
+]);
+
+%SetCode(p,Bool8x16Constructor);
+%FunctionSetPrototype(p,{});
+%AddNamedProperty(p.prototype,'constructor',p,
+2);
+%AddNamedProperty(p.prototype,e,'Bool8x16',
+2|1);
+b.InstallFunctions(p.prototype,2,[
+'toLocaleString',Bool8x16ToLocaleString,
+'toString',Bool8x16ToString,
+'valueOf',Bool8x16ValueOf,
+]);
+
+
+
+b.InstallFunctions(g,2,[
+'splat',Float32x4Splat,
+'check',Float32x4CheckJS,
+'extractLane',Float32x4ExtractLaneJS,
+'replaceLane',Float32x4ReplaceLaneJS,
+'neg',Float32x4NegJS,
+'abs',Float32x4AbsJS,
+'sqrt',Float32x4SqrtJS,
+'reciprocalApproximation',Float32x4RecipApproxJS,
+'reciprocalSqrtApproximation',Float32x4RecipSqrtApproxJS,
+'add',Float32x4AddJS,
+'sub',Float32x4SubJS,
+'mul',Float32x4MulJS,
+'div',Float32x4DivJS,
+'min',Float32x4MinJS,
+'max',Float32x4MaxJS,
+'minNum',Float32x4MinNumJS,
+'maxNum',Float32x4MaxNumJS,
+'lessThan',Float32x4LessThanJS,
+'lessThanOrEqual',Float32x4LessThanOrEqualJS,
+'greaterThan',Float32x4GreaterThanJS,
+'greaterThanOrEqual',Float32x4GreaterThanOrEqualJS,
+'equal',Float32x4EqualJS,
+'notEqual',Float32x4NotEqualJS,
+'select',Float32x4SelectJS,
+'swizzle',Float32x4SwizzleJS,
+'shuffle',Float32x4ShuffleJS,
+'fromInt32x4',Float32x4FromInt32x4JS,
+'fromUint32x4',Float32x4FromUint32x4JS,
+'fromInt32x4Bits',Float32x4FromInt32x4BitsJS,
+'fromUint32x4Bits',Float32x4FromUint32x4BitsJS,
+'fromInt16x8Bits',Float32x4FromInt16x8BitsJS,
+'fromUint16x8Bits',Float32x4FromUint16x8BitsJS,
+'fromInt8x16Bits',Float32x4FromInt8x16BitsJS,
+'fromUint8x16Bits',Float32x4FromUint8x16BitsJS,
+'load',Float32x4LoadJS,
+'load1',Float32x4Load1JS,
+'load2',Float32x4Load2JS,
+'load3',Float32x4Load3JS,
+'store',Float32x4StoreJS,
+'store1',Float32x4Store1JS,
+'store2',Float32x4Store2JS,
+'store3',Float32x4Store3JS,
+]);
+b.InstallFunctions(h,2,[
+'splat',Int32x4Splat,
+'check',Int32x4CheckJS,
+'extractLane',Int32x4ExtractLaneJS,
+'replaceLane',Int32x4ReplaceLaneJS,
+'neg',Int32x4NegJS,
+'add',Int32x4AddJS,
+'sub',Int32x4SubJS,
+'mul',Int32x4MulJS,
+'min',Int32x4MinJS,
+'max',Int32x4MaxJS,
+'and',Int32x4AndJS,
+'or',Int32x4OrJS,
+'xor',Int32x4XorJS,
+'not',Int32x4NotJS,
+'shiftLeftByScalar',Int32x4ShiftLeftByScalarJS,
+'shiftRightByScalar',Int32x4ShiftRightByScalarJS,
+'lessThan',Int32x4LessThanJS,
+'lessThanOrEqual',Int32x4LessThanOrEqualJS,
+'greaterThan',Int32x4GreaterThanJS,
+'greaterThanOrEqual',Int32x4GreaterThanOrEqualJS,
+'equal',Int32x4EqualJS,
+'notEqual',Int32x4NotEqualJS,
+'select',Int32x4SelectJS,
+'swizzle',Int32x4SwizzleJS,
+'shuffle',Int32x4ShuffleJS,
+'fromFloat32x4',Int32x4FromFloat32x4JS,
+'fromUint32x4',Int32x4FromUint32x4JS,
+'fromFloat32x4Bits',Int32x4FromFloat32x4BitsJS,
+'fromUint32x4Bits',Int32x4FromUint32x4BitsJS,
+'fromInt16x8Bits',Int32x4FromInt16x8BitsJS,
+'fromUint16x8Bits',Int32x4FromUint16x8BitsJS,
+'fromInt8x16Bits',Int32x4FromInt8x16BitsJS,
+'fromUint8x16Bits',Int32x4FromUint8x16BitsJS,
+'load',Int32x4LoadJS,
+'load1',Int32x4Load1JS,
+'load2',Int32x4Load2JS,
+'load3',Int32x4Load3JS,
+'store',Int32x4StoreJS,
+'store1',Int32x4Store1JS,
+'store2',Int32x4Store2JS,
+'store3',Int32x4Store3JS,
+]);
+b.InstallFunctions(k,2,[
+'splat',Uint32x4Splat,
+'check',Uint32x4CheckJS,
+'extractLane',Uint32x4ExtractLaneJS,
+'replaceLane',Uint32x4ReplaceLaneJS,
+'add',Uint32x4AddJS,
+'sub',Uint32x4SubJS,
+'mul',Uint32x4MulJS,
+'min',Uint32x4MinJS,
+'max',Uint32x4MaxJS,
+'and',Uint32x4AndJS,
+'or',Uint32x4OrJS,
+'xor',Uint32x4XorJS,
+'not',Uint32x4NotJS,
+'shiftLeftByScalar',Uint32x4ShiftLeftByScalarJS,
+'shiftRightByScalar',Uint32x4ShiftRightByScalarJS,
+'lessThan',Uint32x4LessThanJS,
+'lessThanOrEqual',Uint32x4LessThanOrEqualJS,
+'greaterThan',Uint32x4GreaterThanJS,
+'greaterThanOrEqual',Uint32x4GreaterThanOrEqualJS,
+'equal',Uint32x4EqualJS,
+'notEqual',Uint32x4NotEqualJS,
+'select',Uint32x4SelectJS,
+'swizzle',Uint32x4SwizzleJS,
+'shuffle',Uint32x4ShuffleJS,
+'fromFloat32x4',Uint32x4FromFloat32x4JS,
+'fromInt32x4',Uint32x4FromInt32x4JS,
+'fromFloat32x4Bits',Uint32x4FromFloat32x4BitsJS,
+'fromInt32x4Bits',Uint32x4FromInt32x4BitsJS,
+'fromInt16x8Bits',Uint32x4FromInt16x8BitsJS,
+'fromUint16x8Bits',Uint32x4FromUint16x8BitsJS,
+'fromInt8x16Bits',Uint32x4FromInt8x16BitsJS,
+'fromUint8x16Bits',Uint32x4FromUint8x16BitsJS,
+'load',Uint32x4LoadJS,
+'load1',Uint32x4Load1JS,
+'load2',Uint32x4Load2JS,
+'load3',Uint32x4Load3JS,
+'store',Uint32x4StoreJS,
+'store1',Uint32x4Store1JS,
+'store2',Uint32x4Store2JS,
+'store3',Uint32x4Store3JS,
+]);
+b.InstallFunctions(n,2,[
+'splat',Bool32x4Splat,
+'check',Bool32x4CheckJS,
+'extractLane',Bool32x4ExtractLaneJS,
+'replaceLane',Bool32x4ReplaceLaneJS,
+'and',Bool32x4AndJS,
+'or',Bool32x4OrJS,
+'xor',Bool32x4XorJS,
+'not',Bool32x4NotJS,
+'anyTrue',Bool32x4AnyTrueJS,
+'allTrue',Bool32x4AllTrueJS,
+'swizzle',Bool32x4SwizzleJS,
+'shuffle',Bool32x4ShuffleJS,
+]);
+b.InstallFunctions(i,2,[
+'splat',Int16x8Splat,
+'check',Int16x8CheckJS,
+'extractLane',Int16x8ExtractLaneJS,
+'replaceLane',Int16x8ReplaceLaneJS,
+'neg',Int16x8NegJS,
+'add',Int16x8AddJS,
+'sub',Int16x8SubJS,
+'addSaturate',Int16x8AddSaturateJS,
+'subSaturate',Int16x8SubSaturateJS,
+'mul',Int16x8MulJS,
+'min',Int16x8MinJS,
+'max',Int16x8MaxJS,
+'and',Int16x8AndJS,
+'or',Int16x8OrJS,
+'xor',Int16x8XorJS,
+'not',Int16x8NotJS,
+'shiftLeftByScalar',Int16x8ShiftLeftByScalarJS,
+'shiftRightByScalar',Int16x8ShiftRightByScalarJS,
+'lessThan',Int16x8LessThanJS,
+'lessThanOrEqual',Int16x8LessThanOrEqualJS,
+'greaterThan',Int16x8GreaterThanJS,
+'greaterThanOrEqual',Int16x8GreaterThanOrEqualJS,
+'equal',Int16x8EqualJS,
+'notEqual',Int16x8NotEqualJS,
+'select',Int16x8SelectJS,
+'swizzle',Int16x8SwizzleJS,
+'shuffle',Int16x8ShuffleJS,
+'fromUint16x8',Int16x8FromUint16x8JS,
+'fromFloat32x4Bits',Int16x8FromFloat32x4BitsJS,
+'fromInt32x4Bits',Int16x8FromInt32x4BitsJS,
+'fromUint32x4Bits',Int16x8FromUint32x4BitsJS,
+'fromUint16x8Bits',Int16x8FromUint16x8BitsJS,
+'fromInt8x16Bits',Int16x8FromInt8x16BitsJS,
+'fromUint8x16Bits',Int16x8FromUint8x16BitsJS,
+'load',Int16x8LoadJS,
+'store',Int16x8StoreJS,
+]);
+b.InstallFunctions(l,2,[
+'splat',Uint16x8Splat,
+'check',Uint16x8CheckJS,
+'extractLane',Uint16x8ExtractLaneJS,
+'replaceLane',Uint16x8ReplaceLaneJS,
+'add',Uint16x8AddJS,
+'sub',Uint16x8SubJS,
+'addSaturate',Uint16x8AddSaturateJS,
+'subSaturate',Uint16x8SubSaturateJS,
+'mul',Uint16x8MulJS,
+'min',Uint16x8MinJS,
+'max',Uint16x8MaxJS,
+'and',Uint16x8AndJS,
+'or',Uint16x8OrJS,
+'xor',Uint16x8XorJS,
+'not',Uint16x8NotJS,
+'shiftLeftByScalar',Uint16x8ShiftLeftByScalarJS,
+'shiftRightByScalar',Uint16x8ShiftRightByScalarJS,
+'lessThan',Uint16x8LessThanJS,
+'lessThanOrEqual',Uint16x8LessThanOrEqualJS,
+'greaterThan',Uint16x8GreaterThanJS,
+'greaterThanOrEqual',Uint16x8GreaterThanOrEqualJS,
+'equal',Uint16x8EqualJS,
+'notEqual',Uint16x8NotEqualJS,
+'select',Uint16x8SelectJS,
+'swizzle',Uint16x8SwizzleJS,
+'shuffle',Uint16x8ShuffleJS,
+'fromInt16x8',Uint16x8FromInt16x8JS,
+'fromFloat32x4Bits',Uint16x8FromFloat32x4BitsJS,
+'fromInt32x4Bits',Uint16x8FromInt32x4BitsJS,
+'fromUint32x4Bits',Uint16x8FromUint32x4BitsJS,
+'fromInt16x8Bits',Uint16x8FromInt16x8BitsJS,
+'fromInt8x16Bits',Uint16x8FromInt8x16BitsJS,
+'fromUint8x16Bits',Uint16x8FromUint8x16BitsJS,
+'load',Uint16x8LoadJS,
+'store',Uint16x8StoreJS,
+]);
+b.InstallFunctions(o,2,[
+'splat',Bool16x8Splat,
+'check',Bool16x8CheckJS,
+'extractLane',Bool16x8ExtractLaneJS,
+'replaceLane',Bool16x8ReplaceLaneJS,
+'and',Bool16x8AndJS,
+'or',Bool16x8OrJS,
+'xor',Bool16x8XorJS,
+'not',Bool16x8NotJS,
+'anyTrue',Bool16x8AnyTrueJS,
+'allTrue',Bool16x8AllTrueJS,
+'swizzle',Bool16x8SwizzleJS,
+'shuffle',Bool16x8ShuffleJS,
+]);
+b.InstallFunctions(j,2,[
+'splat',Int8x16Splat,
+'check',Int8x16CheckJS,
+'extractLane',Int8x16ExtractLaneJS,
+'replaceLane',Int8x16ReplaceLaneJS,
+'neg',Int8x16NegJS,
+'add',Int8x16AddJS,
+'sub',Int8x16SubJS,
+'addSaturate',Int8x16AddSaturateJS,
+'subSaturate',Int8x16SubSaturateJS,
+'mul',Int8x16MulJS,
+'min',Int8x16MinJS,
+'max',Int8x16MaxJS,
+'and',Int8x16AndJS,
+'or',Int8x16OrJS,
+'xor',Int8x16XorJS,
+'not',Int8x16NotJS,
+'shiftLeftByScalar',Int8x16ShiftLeftByScalarJS,
+'shiftRightByScalar',Int8x16ShiftRightByScalarJS,
+'lessThan',Int8x16LessThanJS,
+'lessThanOrEqual',Int8x16LessThanOrEqualJS,
+'greaterThan',Int8x16GreaterThanJS,
+'greaterThanOrEqual',Int8x16GreaterThanOrEqualJS,
+'equal',Int8x16EqualJS,
+'notEqual',Int8x16NotEqualJS,
+'select',Int8x16SelectJS,
+'swizzle',Int8x16SwizzleJS,
+'shuffle',Int8x16ShuffleJS,
+'fromUint8x16',Int8x16FromUint8x16JS,
+'fromFloat32x4Bits',Int8x16FromFloat32x4BitsJS,
+'fromInt32x4Bits',Int8x16FromInt32x4BitsJS,
+'fromUint32x4Bits',Int8x16FromUint32x4BitsJS,
+'fromInt16x8Bits',Int8x16FromInt16x8BitsJS,
+'fromUint16x8Bits',Int8x16FromUint16x8BitsJS,
+'fromUint8x16Bits',Int8x16FromUint8x16BitsJS,
+'load',Int8x16LoadJS,
+'store',Int8x16StoreJS,
+]);
+b.InstallFunctions(m,2,[
+'splat',Uint8x16Splat,
+'check',Uint8x16CheckJS,
+'extractLane',Uint8x16ExtractLaneJS,
+'replaceLane',Uint8x16ReplaceLaneJS,
+'add',Uint8x16AddJS,
+'sub',Uint8x16SubJS,
+'addSaturate',Uint8x16AddSaturateJS,
+'subSaturate',Uint8x16SubSaturateJS,
+'mul',Uint8x16MulJS,
+'min',Uint8x16MinJS,
+'max',Uint8x16MaxJS,
+'and',Uint8x16AndJS,
+'or',Uint8x16OrJS,
+'xor',Uint8x16XorJS,
+'not',Uint8x16NotJS,
+'shiftLeftByScalar',Uint8x16ShiftLeftByScalarJS,
+'shiftRightByScalar',Uint8x16ShiftRightByScalarJS,
+'lessThan',Uint8x16LessThanJS,
+'lessThanOrEqual',Uint8x16LessThanOrEqualJS,
+'greaterThan',Uint8x16GreaterThanJS,
+'greaterThanOrEqual',Uint8x16GreaterThanOrEqualJS,
+'equal',Uint8x16EqualJS,
+'notEqual',Uint8x16NotEqualJS,
+'select',Uint8x16SelectJS,
+'swizzle',Uint8x16SwizzleJS,
+'shuffle',Uint8x16ShuffleJS,
+'fromInt8x16',Uint8x16FromInt8x16JS,
+'fromFloat32x4Bits',Uint8x16FromFloat32x4BitsJS,
+'fromInt32x4Bits',Uint8x16FromInt32x4BitsJS,
+'fromUint32x4Bits',Uint8x16FromUint32x4BitsJS,
+'fromInt16x8Bits',Uint8x16FromInt16x8BitsJS,
+'fromUint16x8Bits',Uint8x16FromUint16x8BitsJS,
+'fromInt8x16Bits',Uint8x16FromInt8x16BitsJS,
+'load',Uint8x16LoadJS,
+'store',Uint8x16StoreJS,
+]);
+b.InstallFunctions(p,2,[
+'splat',Bool8x16Splat,
+'check',Bool8x16CheckJS,
+'extractLane',Bool8x16ExtractLaneJS,
+'replaceLane',Bool8x16ReplaceLaneJS,
+'and',Bool8x16AndJS,
+'or',Bool8x16OrJS,
+'xor',Bool8x16XorJS,
+'not',Bool8x16NotJS,
+'anyTrue',Bool8x16AnyTrueJS,
+'allTrue',Bool8x16AllTrueJS,
+'swizzle',Bool8x16SwizzleJS,
+'shuffle',Bool8x16ShuffleJS,
+]);
+b.Export(function(K){
+K.Float32x4ToString=Float32x4ToString;
+K.Int32x4ToString=Int32x4ToString;
+K.Uint32x4ToString=Uint32x4ToString;
+K.Bool32x4ToString=Bool32x4ToString;
+K.Int16x8ToString=Int16x8ToString;
+K.Uint16x8ToString=Uint16x8ToString;
+K.Bool16x8ToString=Bool16x8ToString;
+K.Int8x16ToString=Int8x16ToString;
+K.Uint8x16ToString=Uint8x16ToString;
+K.Bool8x16ToString=Bool8x16ToString;
+});
+})
+
+<harmony-speciesE
+(function(a,b,c){
+"use strict";
+%CheckIsBootstrapping();
+var d=a.Array;
+var e=a.Uint8Array.__proto__;
+var f=a.Map;
+var g=a.Set;
+var h=a.ArrayBuffer;
+var i=a.Promise;
+var j=a.RegExp;
+var k=b.ImportNow("species_symbol");
+function ArraySpecies(){
+return this;
+}
+function TypedArraySpecies(){
+return this;
+}
+function MapSpecies(){
+return this;
+}
+function SetSpecies(){
+return this;
+}
+function ArrayBufferSpecies(){
+return this;
+}
+function PromiseSpecies(){
+return this;
+}
+function RegExpSpecies(){
+return this;
+}
+b.InstallGetter(d,k,ArraySpecies,2);
+b.InstallGetter(e,k,TypedArraySpecies,2);
+b.InstallGetter(f,k,MapSpecies,2);
+b.InstallGetter(g,k,SetSpecies,2);
+b.InstallGetter(h,k,ArrayBufferSpecies,
+2);
+b.InstallGetter(i,k,PromiseSpecies,2);
+b.InstallGetter(j,k,RegExpSpecies,2);
+});
+
+\harmony-unicode-regexps�
+(function(a,b){
+'use strict';
+%CheckIsBootstrapping();
+var c=a.RegExp;
+var d=c.prototype;
+var e;
+b.Import(function(f){
+e=f.MakeTypeError;
+});
+function RegExpGetUnicode(){
+if(!(%_IsRegExp(this))){
+if(this===d){
+%IncrementUseCounter(13);
+return(void 0);
+}
+throw e(134,"RegExp.prototype.unicode");
+}
+return(!!((%_RegExpFlags(this)&16)));
+}
+%SetForceInlineFlag(RegExpGetUnicode);
+b.InstallGetter(c.prototype,'unicode',RegExpGetUnicode);
+})
+
+Xharmony-string-padding�
+(function(a,b){
+%CheckIsBootstrapping();
+var c=a.String;
+var d;
+b.Import(function(e){
+d=e.MakeTypeError;
+});
+function StringPad(f,g,h){
+g=(%_ToLength(g));
+var i=f.length;
+if(g<=i)return"";
+if((h===(void 0))){
+h=" ";
+}else{
+h=(%_ToString(h));
+if(h===""){
+h=" ";
+}
+}
+var j=g-i;
+var k=(j/h.length)|0;
+var l=(j-h.length*k)|0;
+var m="";
+while(true){
+if(k&1)m+=h;
+k>>=1;
+if(k===0)break;
+h+=h;
+}
+if(l){
+m+=%_SubString(h,0,l);
+}
+return m;
+}
+function StringPadStart(g,h){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw d(18,"String.prototype.padStart")
+var f=(%_ToString(this));
+return StringPad(f,g,h)+f;
+}
+%FunctionSetLength(StringPadStart,1);
+function StringPadEnd(g,h){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw d(18,"String.prototype.padEnd")
+var f=(%_ToString(this));
+return f+StringPad(f,g,h);
+}
+%FunctionSetLength(StringPadEnd,1);
+b.InstallFunctions(c.prototype,2,[
+"padStart",StringPadStart,
+"padEnd",StringPadEnd
+]);
+});
+
+4promise-extra�
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Promise;
+var d=b.ImportNow("PromiseChain");
+var e=b.ImportNow("PromiseDeferred");
+var f=b.ImportNow("PromiseResolved");
+b.InstallFunctions(c.prototype,2,[
+"chain",d,
+]);
+b.InstallFunctions(c,2,[
+"defer",e,
+"accept",f,
+]);
+})
+
+XReadableStreamTempStubm
+(function(global, binding, v8) {
+  'use strict';
+  const TypeError = global.TypeError;
+  const defineProperty = global.Object.defineProperty;
+  class ReadableStream {
+    constructor() {
+      throw new TypeError('Illegal constructor');
+    }
+    getReader() {
+      throw new TypeError('Illegal invocation');
+    }
+    cancel() {
+      throw new TypeError('Illegal invocation');
+    }
+  }
+  defineProperty(global, 'ReadableStream', {
+    value: ReadableStream,
+    enumerable: false,
+    configurable: true,
+    writable: true
+  });
+});
+dByteLengthQueuingStrategy�
+(function(global, binding, v8) {
+  'use strict';
+  const defineProperty = global.Object.defineProperty;
+  class ByteLengthQueuingStrategy {
+    constructor(options) {
+      defineProperty(this, 'highWaterMark', {
+        value: options.highWaterMark,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    }
+    size(chunk) { return chunk.byteLength; }
+  }
+  defineProperty(global, 'ByteLengthQueuingStrategy', {
+    value: ByteLengthQueuingStrategy,
+    enumerable: false,
+    configurable: true,
+    writable: true
+  });
+});
+PCountQueuingStrategy�
+(function(global, binding, v8) {
+  'use strict';
+  const defineProperty = global.Object.defineProperty;
+  class CountQueuingStrategy {
+    constructor(options) {
+      defineProperty(this, 'highWaterMark', {
+        value: options.highWaterMark,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    }
+    size(chunk) { return 1; }
+  }
+  defineProperty(global, 'CountQueuingStrategy', {
+    value: CountQueuingStrategy,
+    enumerable: false,
+    configurable: true,
+    writable: true
+  });
+  class BuiltInCountQueuingStrategy {
+    constructor(highWaterMark) {
+      defineProperty(this, 'highWaterMark', {value: highWaterMark});
+    }
+    size(chunk) { return 1; }
+  }
+  binding.createBuiltInCountQueuingStrategy = highWaterMark =>
+      new BuiltInCountQueuingStrategy(highWaterMark);
+});
+8ReadableStream�s

+(function(global, binding, v8) {
+  'use strict';
+  const readableStreamController = v8.createPrivateSymbol('[[controller]]');
+  const readableStreamQueue = v8.createPrivateSymbol('[[queue]]');
+  const readableStreamQueueSize =
+      v8.createPrivateSymbol('[[queue]] total size');
+  const readableStreamReader = v8.createPrivateSymbol('[[reader]]');
+  const readableStreamState = v8.createPrivateSymbol('[[state]]');
+  const readableStreamStoredError = v8.createPrivateSymbol('[[storedError]]');
+  const readableStreamStrategySize = v8.createPrivateSymbol('[[strategySize]]');
+  const readableStreamStrategyHWM = v8.createPrivateSymbol('[[strategyHWM]]');
+  const readableStreamUnderlyingSource =
+      v8.createPrivateSymbol('[[underlyingSource]]');
+  const readableStreamControllerControlledReadableStream =
+      v8.createPrivateSymbol('[[controlledReadableStream]]');
+  const readableStreamReaderClosedPromise =
+      v8.createPrivateSymbol('[[closedPromise]]');
+  const readableStreamReaderOwnerReadableStream =
+      v8.createPrivateSymbol('[[ownerReadableStream]]');
+  const readableStreamReaderReadRequests =
+      v8.createPrivateSymbol('[[readRequests]]');
+  const createWithExternalControllerSentinel =
+      v8.createPrivateSymbol('flag for UA-created ReadableStream to pass');
+  const STATE_READABLE = 0;
+  const STATE_CLOSED = 1;
+  const STATE_ERRORED = 2;
+  const readableStreamBits = v8.createPrivateSymbol(
+      'bit field for [[started]], [[closeRequested]], [[pulling]], [[pullAgain]], [[disturbed]]');
+  const STARTED = 0b1;
+  const CLOSE_REQUESTED = 0b10;
+  const PULLING = 0b100;
+  const PULL_AGAIN = 0b1000;
+  const DISTURBED = 0b10000;
+  const undefined = global.undefined;
+  const Infinity = global.Infinity;
+  const defineProperty = global.Object.defineProperty;
+  const hasOwnProperty = v8.uncurryThis(global.Object.hasOwnProperty);
+  const callFunction = v8.uncurryThis(global.Function.prototype.call);
+  const TypeError = global.TypeError;
+  const RangeError = global.RangeError;
+  const Number = global.Number;
+  const Number_isNaN = Number.isNaN;
+  const Number_isFinite = Number.isFinite;
+  const Promise = global.Promise;
+  const thenPromise = v8.uncurryThis(Promise.prototype.then);
+  const Promise_resolve = v8.simpleBind(Promise.resolve, Promise);
+  const Promise_reject = v8.simpleBind(Promise.reject, Promise);
+  const errIllegalInvocation = 'Illegal invocation';
+  const errIllegalConstructor = 'Illegal constructor';
+  const errCancelLockedStream =
+      'Cannot cancel a readable stream that is locked to a reader';
+  const errEnqueueInCloseRequestedStream =
+      'Cannot enqueue a chunk into a readable stream that is closed or has been requested to be closed';
+  const errCancelReleasedReader =
+      'This readable stream reader has been released and cannot be used to cancel its previous owner stream';
+  const errReadReleasedReader =
+      'This readable stream reader has been released and cannot be used to read from its previous owner stream';
+  const errCloseCloseRequestedStream =
+      'Cannot close a readable stream that has already been requested to be closed';
+  const errCloseErroredStream = 'Cannot close an errored readable stream';
+  const errErrorClosedStream = 'Cannot error a close readable stream';
+  const errErrorErroredStream =
+      'Cannot error a readable stream that is already errored';
+  const errReaderConstructorBadArgument =
+      'ReadableStreamReader constructor argument is not a readable stream';
+  const errReaderConstructorStreamAlreadyLocked =
+      'ReadableStreamReader constructor can only accept readable streams that are not yet locked to a reader';
+  const errReleaseReaderWithPendingRead =
+      'Cannot release a readable stream reader when it still has outstanding read() calls that have not yet settled';
+  const errReleasedReaderClosedPromise =
+      'This readable stream reader has been released and cannot be used to monitor the stream\'s state';
+  const errInvalidSize =
+      'The return value of a queuing strategy\'s size function must be a finite, non-NaN, non-negative number';
+  const errSizeNotAFunction =
+      'A queuing strategy\'s size property must be a function';
+  const errInvalidHWM =
+      'A queueing strategy\'s highWaterMark property must be a nonnegative, non-NaN number';
+  const errTmplMustBeFunctionOrUndefined = name =>
+      `${name} must be a function or undefined`;
+  class ReadableStream {
+    constructor() {
+      const underlyingSource = arguments[0] === undefined ? {} : arguments[0];
+      const strategy = arguments[1] === undefined ? {} : arguments[1];
+      const size = strategy.size;
+      let highWaterMark = strategy.highWaterMark;
+      if (highWaterMark === undefined) {
+        highWaterMark = 1;
+      }
+      const normalizedStrategy =
+          ValidateAndNormalizeQueuingStrategy(size, highWaterMark);
+      this[readableStreamUnderlyingSource] = underlyingSource;
+      this[readableStreamQueue] = new v8.InternalPackedArray();
+      this[readableStreamQueueSize] = 0;
+      this[readableStreamState] = STATE_READABLE;
+      this[readableStreamBits] = 0b0;
+      this[readableStreamReader] = undefined;
+      this[readableStreamStoredError] = undefined;
+      this[readableStreamStrategySize] = normalizedStrategy.size;
+      this[readableStreamStrategyHWM] = normalizedStrategy.highWaterMark;
+      const isControlledExternally =
+          arguments[2] === createWithExternalControllerSentinel;
+      const controller =
+          isControlledExternally ? null : new ReadableStreamController(this);
+      this[readableStreamController] = controller;
+      const argToStart = isControlledExternally ? this : controller;
+      const startResult = CallOrNoop(
+          underlyingSource, 'start', argToStart, 'underlyingSource.start');
+      thenPromise(Promise_resolve(startResult),
+          () => {
+            this[readableStreamBits] |= STARTED;
+            RequestReadableStreamPull(this);
+          },
+          r => {
+            if (this[readableStreamState] === STATE_READABLE) {
+              return ErrorReadableStream(this, r);
+            }
+          });
+    }
+    get locked() {
+      if (IsReadableStream(this) === false) {
+        throw new TypeError(errIllegalInvocation);
+      }
+      return IsReadableStreamLocked(this);
+    }
+    cancel(reason) {
+      if (IsReadableStream(this) === false) {
+        return Promise_reject(new TypeError(errIllegalInvocation));
+      }
+      if (IsReadableStreamLocked(this) === true) {
+        return Promise_reject(new TypeError(errCancelLockedStream));
+      }
+      return CancelReadableStream(this, reason);
+    }
+    getReader() {
+      if (IsReadableStream(this) === false) {
+        throw new TypeError(errIllegalInvocation);
+      }
+      return AcquireReadableStreamReader(this);
+    }
+    tee() {
+      if (IsReadableStream(this) === false) {
+        throw new TypeError(errIllegalInvocation);
+      }
+      return TeeReadableStream(this);
+    }
+  }
+  class ReadableStreamController {
+    constructor(stream) {
+      if (IsReadableStream(stream) === false) {
+        throw new TypeError(errIllegalConstructor);
+      }
+      if (stream[readableStreamController] !== undefined) {
+        throw new TypeError(errIllegalConstructor);
+      }
+      this[readableStreamControllerControlledReadableStream] = stream;
+    }
+    get desiredSize() {
+      if (IsReadableStreamController(this) === false) {
+        throw new TypeError(errIllegalInvocation);
+      }
+      return GetReadableStreamDesiredSize(
+          this[readableStreamControllerControlledReadableStream]);
+    }
+    close() {
+      if (IsReadableStreamController(this) === false) {
+        throw new TypeError(errIllegalInvocation);
+      }
+      const stream = this[readableStreamControllerControlledReadableStream];
+      if (stream[readableStreamBits] & CLOSE_REQUESTED) {
+        throw new TypeError(errCloseCloseRequestedStream);
+      }
+      if (stream[readableStreamState] === STATE_ERRORED) {
+        throw new TypeError(errCloseErroredStream);
+      }
+      return CloseReadableStream(stream);
+    }
+    enqueue(chunk) {
+      if (IsReadableStreamController(this) === false) {
+        throw new TypeError(errIllegalInvocation);
+      }
+      const stream = this[readableStreamControllerControlledReadableStream];
+      if (stream[readableStreamState] === STATE_ERRORED) {
+        throw stream[readableStreamStoredError];
+      }
+      if (stream[readableStreamBits] & CLOSE_REQUESTED) {
+        throw new TypeError(errEnqueueInCloseRequestedStream);
+      }
+      return EnqueueInReadableStream(stream, chunk);
+    }
+    error(e) {
+      if (IsReadableStreamController(this) === false) {
+        throw new TypeError(errIllegalInvocation);
+      }
+      const stream = this[readableStreamControllerControlledReadableStream];
+      const state = stream[readableStreamState];
+      if (state !== STATE_READABLE) {
+        if (state === STATE_ERRORED) {
+          throw new TypeError(errErrorErroredStream);
+        }
+        if (state === STATE_CLOSED) {
+          throw new TypeError(errErrorClosedStream);
+        }
+      }
+      return ErrorReadableStream(stream, e);
+    }
+  }
+  class ReadableStreamReader {
+    constructor(stream) {
+      if (IsReadableStream(stream) === false) {
+        throw new TypeError(errReaderConstructorBadArgument);
+      }
+      if (IsReadableStreamLocked(stream) === true) {
+        throw new TypeError(errReaderConstructorStreamAlreadyLocked);
+      }
+      this[readableStreamReaderOwnerReadableStream] = stream;
+      stream[readableStreamReader] = this;
+      this[readableStreamReaderReadRequests] = new v8.InternalPackedArray();
+      switch (stream[readableStreamState]) {
+        case STATE_READABLE:
+          this[readableStreamReaderClosedPromise] = v8.createPromise();
+          break;
+        case STATE_CLOSED:
+          this[readableStreamReaderClosedPromise] = Promise_resolve(undefined);
+          break;
+        case STATE_ERRORED:
+          this[readableStreamReaderClosedPromise] =
+              Promise_reject(stream[readableStreamStoredError]);
+          break;
+      }
+    }
+    get closed() {
+      if (IsReadableStreamReader(this) === false) {
+        return Promise_reject(new TypeError(errIllegalInvocation));
+      }
+      return this[readableStreamReaderClosedPromise];
+    }
+    cancel(reason) {
+      if (IsReadableStreamReader(this) === false) {
+        return Promise_reject(new TypeError(errIllegalInvocation));
+      }
+      const stream = this[readableStreamReaderOwnerReadableStream];
+      if (stream === undefined) {
+        return Promise_reject(new TypeError(errCancelReleasedReader));
+      }
+      return CancelReadableStream(stream, reason);
+    }
+    read() {
+      if (IsReadableStreamReader(this) === false) {
+        return Promise_reject(new TypeError(errIllegalInvocation));
+      }
+      if (this[readableStreamReaderOwnerReadableStream] === undefined) {
+        return Promise_reject(new TypeError(errReadReleasedReader));
+      }
+      return ReadFromReadableStreamReader(this);
+    }
+    releaseLock() {
+      if (IsReadableStreamReader(this) === false) {
+        throw new TypeError(errIllegalInvocation);
+      }
+      const stream = this[readableStreamReaderOwnerReadableStream];
+      if (stream === undefined) {
+        return undefined;
+      }
+      if (this[readableStreamReaderReadRequests].length > 0) {
+        throw new TypeError(errReleaseReaderWithPendingRead);
+      }
+      if (stream[readableStreamState] === STATE_READABLE) {
+        v8.rejectPromise(this[readableStreamReaderClosedPromise],
+            new TypeError(errReleasedReaderClosedPromise));
+      } else {
+        this[readableStreamReaderClosedPromise] =
+            Promise_reject(new TypeError(errReleasedReaderClosedPromise));
+      }
+      this[readableStreamReaderOwnerReadableStream][readableStreamReader] =
+          undefined;
+      this[readableStreamReaderOwnerReadableStream] = undefined;
+    }
+  }
+  function AcquireReadableStreamReader(stream) {
+    return new ReadableStreamReader(stream);
+  }
+  function CancelReadableStream(stream, reason) {
+    stream[readableStreamBits] |= DISTURBED;
+    const state = stream[readableStreamState];
+    if (state === STATE_CLOSED) {
+      return Promise_resolve(undefined);
+    }
+    if (state === STATE_ERRORED) {
+      return Promise_reject(stream[readableStreamStoredError]);
+    }
+    stream[readableStreamQueue] = new v8.InternalPackedArray();
+    FinishClosingReadableStream(stream);
+    const underlyingSource = stream[readableStreamUnderlyingSource];
+    const sourceCancelPromise = PromiseCallOrNoop(
+        underlyingSource, 'cancel', reason, 'underlyingSource.cancel');
+    return thenPromise(sourceCancelPromise, () => undefined);
+  }
+  function CloseReadableStream(stream) {
+    if (stream[readableStreamState] === STATE_CLOSED) {
+      return undefined;
+    }
+    stream[readableStreamBits] |= CLOSE_REQUESTED;
+    if (stream[readableStreamQueue].length === 0) {
+      return FinishClosingReadableStream(stream);
+    }
+  }
+  function EnqueueInReadableStream(stream, chunk) {
+    if (stream[readableStreamState] === STATE_CLOSED) {
+      return undefined;
+    }
+    if (IsReadableStreamLocked(stream) === true &&
+        stream[readableStreamReader][readableStreamReaderReadRequests].length >
+            0) {
+      const readRequest =
+          stream[readableStreamReader][readableStreamReaderReadRequests]
+              .shift();
+      v8.resolvePromise(readRequest, CreateIterResultObject(chunk, false));
+    } else {
+      let chunkSize = 1;
+      const strategySize = stream[readableStreamStrategySize];
+      if (strategySize !== undefined) {
+        try {
+          chunkSize = strategySize(chunk);
+        } catch (chunkSizeE) {
+          if (stream[readableStreamState] === STATE_READABLE) {
+            ErrorReadableStream(stream, chunkSizeE);
+          }
+          throw chunkSizeE;
+        }
+      }
+      try {
+        EnqueueValueWithSize(stream, chunk, chunkSize);
+      } catch (enqueueE) {
+        if (stream[readableStreamState] === STATE_READABLE) {
+          ErrorReadableStream(stream, enqueueE);
+        }
+        throw enqueueE;
+      }
+    }
+    RequestReadableStreamPull(stream);
+  }
+  function ErrorReadableStream(stream, e) {
+    stream[readableStreamQueue] = new v8.InternalPackedArray();
+    stream[readableStreamStoredError] = e;
+    stream[readableStreamState] = STATE_ERRORED;
+    const reader = stream[readableStreamReader];
+    if (reader === undefined) {
+      return undefined;
+    }
+    const readRequests = reader[readableStreamReaderReadRequests];
+    for (let i = 0; i < readRequests.length; ++i) {
+      v8.rejectPromise(readRequests[i], e);
+    }
+    reader[readableStreamReaderReadRequests] = new v8.InternalPackedArray();
+    v8.rejectPromise(reader[readableStreamReaderClosedPromise], e);
+  }
+  function FinishClosingReadableStream(stream) {
+    stream[readableStreamState] = STATE_CLOSED;
+    const reader = stream[readableStreamReader];
+    if (reader === undefined) {
+      return undefined;
+    }
+    const readRequests = reader[readableStreamReaderReadRequests];
+    for (let i = 0; i < readRequests.length; ++i) {
+      v8.resolvePromise(
+          readRequests[i], CreateIterResultObject(undefined, true));
+    }
+    reader[readableStreamReaderReadRequests] = new v8.InternalPackedArray();
+    v8.resolvePromise(reader[readableStreamReaderClosedPromise], undefined);
+  }
+  function GetReadableStreamDesiredSize(stream) {
+    const queueSize = GetTotalQueueSize(stream);
+    return stream[readableStreamStrategyHWM] - queueSize;
+  }
+  function IsReadableStream(x) {
+    return hasOwnProperty(x, readableStreamUnderlyingSource);
+  }
+  function IsReadableStreamDisturbed(stream) {
+    return stream[readableStreamBits] & DISTURBED;
+  }
+  function IsReadableStreamLocked(stream) {
+    return stream[readableStreamReader] !== undefined;
+  }
+  function IsReadableStreamController(x) {
+    return hasOwnProperty(x, readableStreamControllerControlledReadableStream);
+  }
+  function IsReadableStreamReader(x) {
+    return hasOwnProperty(x, readableStreamReaderOwnerReadableStream);
+  }
+  function ReadFromReadableStreamReader(reader) {
+    const stream = reader[readableStreamReaderOwnerReadableStream];
+    stream[readableStreamBits] |= DISTURBED;
+    if (stream[readableStreamState] === STATE_CLOSED) {
+      return Promise_resolve(CreateIterResultObject(undefined, true));
+    }
+    if (stream[readableStreamState] === STATE_ERRORED) {
+      return Promise_reject(stream[readableStreamStoredError]);
+    }
+    const queue = stream[readableStreamQueue];
+    if (queue.length > 0) {
+      const chunk = DequeueValue(stream);
+      if (stream[readableStreamBits] & CLOSE_REQUESTED && queue.length === 0) {
+        FinishClosingReadableStream(stream);
+      } else {
+        RequestReadableStreamPull(stream);
+      }
+      return Promise_resolve(CreateIterResultObject(chunk, false));
+    } else {
+      const readRequest = v8.createPromise();
+      reader[readableStreamReaderReadRequests].push(readRequest);
+      RequestReadableStreamPull(stream);
+      return readRequest;
+    }
+  }
+  function RequestReadableStreamPull(stream) {
+    const shouldPull = ShouldReadableStreamPull(stream);
+    if (shouldPull === false) {
+      return undefined;
+    }
+    if (stream[readableStreamBits] & PULLING) {
+      stream[readableStreamBits] |= PULL_AGAIN;
+      return undefined;
+    }
+    stream[readableStreamBits] |= PULLING;
+    const underlyingSource = stream[readableStreamUnderlyingSource];
+    const controller = stream[readableStreamController];
+    const pullPromise = PromiseCallOrNoop(
+        underlyingSource, 'pull', controller, 'underlyingSource.pull');
+    thenPromise(pullPromise,
+        () => {
+          stream[readableStreamBits] &= ~PULLING;
+          if (stream[readableStreamBits] & PULL_AGAIN) {
+            stream[readableStreamBits] &= ~PULL_AGAIN;
+            return RequestReadableStreamPull(stream);
+          }
+        },
+        e => {
+          if (stream[readableStreamState] === STATE_READABLE) {
+            return ErrorReadableStream(stream, e);
+          }
+        });
+  }
+  function ShouldReadableStreamPull(stream) {
+    const state = stream[readableStreamState];
+    if (state === STATE_CLOSED || state === STATE_ERRORED) {
+      return false;
+    }
+    if (stream[readableStreamBits] & CLOSE_REQUESTED) {
+      return false;
+    }
+    if (!(stream[readableStreamBits] & STARTED)) {
+      return false;
+    }
+    if (IsReadableStreamLocked(stream) === true) {
+      const reader = stream[readableStreamReader];
+      const readRequests = reader[readableStreamReaderReadRequests];
+      if (readRequests.length > 0) {
+        return true;
+      }
+    }
+    const desiredSize = GetReadableStreamDesiredSize(stream);
+    if (desiredSize > 0) {
+      return true;
+    }
+    return false;
+  }
+  function TeeReadableStream(stream) {
+    const reader = AcquireReadableStreamReader(stream);
+    let closedOrErrored = false;
+    let canceled1 = false;
+    let canceled2 = false;
+    let reason1;
+    let reason2;
+    let promise = v8.createPromise();
+    const branch1 = new ReadableStream({pull, cancel: cancel1});
+    const branch2 = new ReadableStream({pull, cancel: cancel2});
+    thenPromise(
+        reader[readableStreamReaderClosedPromise], undefined, function(r) {
+          if (closedOrErrored === true) {
+            return;
+          }
+          ErrorReadableStream(branch1, r);
+          ErrorReadableStream(branch2, r);
+          closedOrErrored = true;
+        });
+    return [branch1, branch2];
+    function pull() {
+      return thenPromise(
+          ReadFromReadableStreamReader(reader), function(result) {
+            const value = result.value;
+            const done = result.done;
+            if (done === true && closedOrErrored === false) {
+              CloseReadableStream(branch1);
+              CloseReadableStream(branch2);
+              closedOrErrored = true;
+            }
+            if (closedOrErrored === true) {
+              return;
+            }
+            if (canceled1 === false) {
+              EnqueueInReadableStream(branch1, value);
+            }
+            if (canceled2 === false) {
+              EnqueueInReadableStream(branch2, value);
+            }
+          });
+    }
+    function cancel1(reason) {
+      canceled1 = true;
+      reason1 = reason;
+      if (canceled2 === true) {
+        const compositeReason = [reason1, reason2];
+        const cancelResult = CancelReadableStream(stream, compositeReason);
+        v8.resolvePromise(promise, cancelResult);
+      }
+      return promise;
+    }
+    function cancel2(reason) {
+      canceled2 = true;
+      reason2 = reason;
+      if (canceled1 === true) {
+        const compositeReason = [reason1, reason2];
+        const cancelResult = CancelReadableStream(stream, compositeReason);
+        v8.resolvePromise(promise, cancelResult);
+      }
+      return promise;
+    }
+  }
+  function DequeueValue(stream) {
+    const result = stream[readableStreamQueue].shift();
+    stream[readableStreamQueueSize] -= result.size;
+    return result.value;
+  }
+  function EnqueueValueWithSize(stream, value, size) {
+    size = Number(size);
+    if (Number_isNaN(size) || size === +Infinity || size < 0) {
+      throw new RangeError(errInvalidSize);
+    }
+    stream[readableStreamQueueSize] += size;
+    stream[readableStreamQueue].push({value, size});
+  }
+  function GetTotalQueueSize(stream) { return stream[readableStreamQueueSize]; }
+  function ValidateAndNormalizeQueuingStrategy(size, highWaterMark) {
+    if (size !== undefined && typeof size !== 'function') {
+      throw new TypeError(errSizeNotAFunction);
+    }
+    highWaterMark = Number(highWaterMark);
+    if (Number_isNaN(highWaterMark)) {
+      throw new TypeError(errInvalidHWM);
+    }
+    if (highWaterMark < 0) {
+      throw new RangeError(errInvalidHWM);
+    }
+    return {size, highWaterMark};
+  }
+  function CallOrNoop(O, P, arg, nameForError) {
+    const method = O[P];
+    if (method === undefined) {
+      return undefined;
+    }
+    if (typeof method !== 'function') {
+      throw new TypeError(errTmplMustBeFunctionOrUndefined(nameForError));
+    }
+    return callFunction(method, O, arg);
+  }
+  function PromiseCallOrNoop(O, P, arg, nameForError) {
+    let method;
+    try {
+      method = O[P];
+    } catch (methodE) {
+      return Promise_reject(methodE);
+    }
+    if (method === undefined) {
+      return Promise_resolve(undefined);
+    }
+    if (typeof method !== 'function') {
+      return Promise_reject(errTmplMustBeFunctionOrUndefined(nameForError));
+    }
+    try {
+      return Promise_resolve(callFunction(method, O, arg));
+    } catch (e) {
+      return Promise_reject(e);
+    }
+  }
+  function CreateIterResultObject(value, done) { return {value, done}; }
+  defineProperty(global, 'ReadableStream', {
+    value: ReadableStream,
+    enumerable: false,
+    configurable: true,
+    writable: true
+  });
+  binding.AcquireReadableStreamReader = AcquireReadableStreamReader;
+  binding.IsReadableStream = IsReadableStream;
+  binding.IsReadableStreamDisturbed = IsReadableStreamDisturbed;
+  binding.IsReadableStreamLocked = IsReadableStreamLocked;
+  binding.IsReadableStreamReader = IsReadableStreamReader;
+  binding.ReadFromReadableStreamReader = ReadFromReadableStreamReader;
+  binding.CloseReadableStream = CloseReadableStream;
+  binding.GetReadableStreamDesiredSize = GetReadableStreamDesiredSize;
+  binding.EnqueueInReadableStream = EnqueueInReadableStream;
+  binding.ErrorReadableStream = ErrorReadableStream;
+  binding.createReadableStreamWithExternalController =
+      (underlyingSource, strategy) => {
+        return new ReadableStream(
+            underlyingSource, strategy, createWithExternalControllerSentinel);
+      };
+});
diff --git a/bin/linux_64/snapshot_blob.bin b/bin/linux_64/snapshot_blob.bin
new file mode 100644
index 0000000..17e76b8
Binary files /dev/null and b/bin/linux_64/snapshot_blob.bin differ
diff --git a/bin/lpc_launcher/display_manager_nt.obj b/bin/lpc_launcher/display_manager_nt.obj
new file mode 100644
index 0000000..ded8684
Binary files /dev/null and b/bin/lpc_launcher/display_manager_nt.obj differ
diff --git a/bin/lpc_launcher/main.obj b/bin/lpc_launcher/main.obj
new file mode 100644
index 0000000..3df0cb5
Binary files /dev/null and b/bin/lpc_launcher/main.obj differ
diff --git a/bin/lpc_launcher/pres.res b/bin/lpc_launcher/pres.res
new file mode 100644
index 0000000..7e0d872
Binary files /dev/null and b/bin/lpc_launcher/pres.res differ
diff --git a/bin/nt_64/cef.pak b/bin/nt_64/cef.pak
new file mode 100644
index 0000000..8774393
Binary files /dev/null and b/bin/nt_64/cef.pak differ
diff --git a/bin/nt_64/cef_100_percent.pak b/bin/nt_64/cef_100_percent.pak
new file mode 100644
index 0000000..a42afe6
Binary files /dev/null and b/bin/nt_64/cef_100_percent.pak differ
diff --git a/bin/nt_64/cef_200_percent.pak b/bin/nt_64/cef_200_percent.pak
new file mode 100644
index 0000000..ced35f6
Binary files /dev/null and b/bin/nt_64/cef_200_percent.pak differ
diff --git a/bin/nt_64/cef_extensions.pak b/bin/nt_64/cef_extensions.pak
new file mode 100644
index 0000000..e085962
Binary files /dev/null and b/bin/nt_64/cef_extensions.pak differ
diff --git a/bin/nt_64/d3dcompiler_43.dll b/bin/nt_64/d3dcompiler_43.dll
new file mode 100644
index 0000000..ab96161
Binary files /dev/null and b/bin/nt_64/d3dcompiler_43.dll differ
diff --git a/bin/nt_64/d3dcompiler_47.dll b/bin/nt_64/d3dcompiler_47.dll
new file mode 100644
index 0000000..efd0813
Binary files /dev/null and b/bin/nt_64/d3dcompiler_47.dll differ
diff --git a/bin/nt_64/debug.log b/bin/nt_64/debug.log
new file mode 100644
index 0000000..613b9f2
--- /dev/null
+++ b/bin/nt_64/debug.log
@@ -0,0 +1,11 @@
+[0619/134641:ERROR:ipc_channel_win.cc(217)] pipe error: 109
+[0624/082509:ERROR:proxy_service_factory.cc(136)] Cannot use V8 Proxy resolver in single process mode.
+[0624/082509:WARNING:histograms.cc(40)] Started multiple compositor clients (Browser, Renderer) in one process. Some metrics will be disabled.
+[0624/082518:WARNING:raw_channel_win.cc(532)] WriteFile: O pipe est� sendo fechado. (0xE8)
+[0624/082518:ERROR:ipc_channel_win.cc(217)] pipe error: 109
+[0624/084854:ERROR:proxy_service_factory.cc(136)] Cannot use V8 Proxy resolver in single process mode.
+[0624/084854:WARNING:histograms.cc(40)] Started multiple compositor clients (Browser, Renderer) in one process. Some metrics will be disabled.
+[0624/084858:WARNING:raw_channel_win.cc(532)] WriteFile: O pipe est� sendo fechado. (0xE8)
+[0624/133149:ERROR:proxy_service_factory.cc(136)] Cannot use V8 Proxy resolver in single process mode.
+[0624/133149:WARNING:histograms.cc(40)] Started multiple compositor clients (Browser, Renderer) in one process. Some metrics will be disabled.
+[0624/133151:WARNING:raw_channel_win.cc(532)] WriteFile: O pipe est� sendo fechado. (0xE8)
diff --git a/bin/nt_64/debug/VS2013/libcef_dll_wrapper.lib b/bin/nt_64/debug/VS2013/libcef_dll_wrapper.lib
new file mode 100644
index 0000000..fceda1d
Binary files /dev/null and b/bin/nt_64/debug/VS2013/libcef_dll_wrapper.lib differ
diff --git a/bin/nt_64/debug/VS2015/libcef_dll_wrapper.lib b/bin/nt_64/debug/VS2015/libcef_dll_wrapper.lib
new file mode 100644
index 0000000..32c9827
Binary files /dev/null and b/bin/nt_64/debug/VS2015/libcef_dll_wrapper.lib differ
diff --git a/bin/nt_64/debug/libcef.lib b/bin/nt_64/debug/libcef.lib
new file mode 100644
index 0000000..d320eb8
Binary files /dev/null and b/bin/nt_64/debug/libcef.lib differ
diff --git a/bin/nt_64/devtools_resources.pak b/bin/nt_64/devtools_resources.pak
new file mode 100644
index 0000000..46aecd8
Binary files /dev/null and b/bin/nt_64/devtools_resources.pak differ
diff --git a/bin/nt_64/icudtl.dat b/bin/nt_64/icudtl.dat
new file mode 100644
index 0000000..065463a
Binary files /dev/null and b/bin/nt_64/icudtl.dat differ
diff --git a/bin/nt_64/libEGL.dll b/bin/nt_64/libEGL.dll
new file mode 100644
index 0000000..4f8147b
Binary files /dev/null and b/bin/nt_64/libEGL.dll differ
diff --git a/bin/nt_64/libGLESv2.dll b/bin/nt_64/libGLESv2.dll
new file mode 100644
index 0000000..e4e2bb7
Binary files /dev/null and b/bin/nt_64/libGLESv2.dll differ
diff --git a/bin/nt_64/libcef.dll b/bin/nt_64/libcef.dll
new file mode 100644
index 0000000..8142881
Binary files /dev/null and b/bin/nt_64/libcef.dll differ
diff --git a/bin/nt_64/locales/am.pak b/bin/nt_64/locales/am.pak
new file mode 100644
index 0000000..c1f4bab
Binary files /dev/null and b/bin/nt_64/locales/am.pak differ
diff --git a/bin/nt_64/locales/ar.pak b/bin/nt_64/locales/ar.pak
new file mode 100644
index 0000000..5225c7f
Binary files /dev/null and b/bin/nt_64/locales/ar.pak differ
diff --git a/bin/nt_64/locales/bg.pak b/bin/nt_64/locales/bg.pak
new file mode 100644
index 0000000..50670c9
Binary files /dev/null and b/bin/nt_64/locales/bg.pak differ
diff --git a/bin/nt_64/locales/bn.pak b/bin/nt_64/locales/bn.pak
new file mode 100644
index 0000000..0967278
Binary files /dev/null and b/bin/nt_64/locales/bn.pak differ
diff --git a/bin/nt_64/locales/ca.pak b/bin/nt_64/locales/ca.pak
new file mode 100644
index 0000000..9e06aad
Binary files /dev/null and b/bin/nt_64/locales/ca.pak differ
diff --git a/bin/nt_64/locales/cs.pak b/bin/nt_64/locales/cs.pak
new file mode 100644
index 0000000..518e33e
Binary files /dev/null and b/bin/nt_64/locales/cs.pak differ
diff --git a/bin/nt_64/locales/da.pak b/bin/nt_64/locales/da.pak
new file mode 100644
index 0000000..b2e8b7b
Binary files /dev/null and b/bin/nt_64/locales/da.pak differ
diff --git a/bin/nt_64/locales/de.pak b/bin/nt_64/locales/de.pak
new file mode 100644
index 0000000..231b7c9
Binary files /dev/null and b/bin/nt_64/locales/de.pak differ
diff --git a/bin/nt_64/locales/el.pak b/bin/nt_64/locales/el.pak
new file mode 100644
index 0000000..4b13cb7
Binary files /dev/null and b/bin/nt_64/locales/el.pak differ
diff --git a/bin/nt_64/locales/en-GB.pak b/bin/nt_64/locales/en-GB.pak
new file mode 100644
index 0000000..927af5f
Binary files /dev/null and b/bin/nt_64/locales/en-GB.pak differ
diff --git a/bin/nt_64/locales/en-US.pak b/bin/nt_64/locales/en-US.pak
new file mode 100644
index 0000000..e0e9edd
Binary files /dev/null and b/bin/nt_64/locales/en-US.pak differ
diff --git a/bin/nt_64/locales/es-419.pak b/bin/nt_64/locales/es-419.pak
new file mode 100644
index 0000000..50406d9
Binary files /dev/null and b/bin/nt_64/locales/es-419.pak differ
diff --git a/bin/nt_64/locales/es.pak b/bin/nt_64/locales/es.pak
new file mode 100644
index 0000000..3680708
Binary files /dev/null and b/bin/nt_64/locales/es.pak differ
diff --git a/bin/nt_64/locales/et.pak b/bin/nt_64/locales/et.pak
new file mode 100644
index 0000000..ef9c51f
Binary files /dev/null and b/bin/nt_64/locales/et.pak differ
diff --git a/bin/nt_64/locales/fa.pak b/bin/nt_64/locales/fa.pak
new file mode 100644
index 0000000..5e5144f
Binary files /dev/null and b/bin/nt_64/locales/fa.pak differ
diff --git a/bin/nt_64/locales/fi.pak b/bin/nt_64/locales/fi.pak
new file mode 100644
index 0000000..2bc0675
Binary files /dev/null and b/bin/nt_64/locales/fi.pak differ
diff --git a/bin/nt_64/locales/fil.pak b/bin/nt_64/locales/fil.pak
new file mode 100644
index 0000000..c96dd03
Binary files /dev/null and b/bin/nt_64/locales/fil.pak differ
diff --git a/bin/nt_64/locales/fr.pak b/bin/nt_64/locales/fr.pak
new file mode 100644
index 0000000..63b1025
Binary files /dev/null and b/bin/nt_64/locales/fr.pak differ
diff --git a/bin/nt_64/locales/gu.pak b/bin/nt_64/locales/gu.pak
new file mode 100644
index 0000000..47f12f5
Binary files /dev/null and b/bin/nt_64/locales/gu.pak differ
diff --git a/bin/nt_64/locales/he.pak b/bin/nt_64/locales/he.pak
new file mode 100644
index 0000000..4533306
Binary files /dev/null and b/bin/nt_64/locales/he.pak differ
diff --git a/bin/nt_64/locales/hi.pak b/bin/nt_64/locales/hi.pak
new file mode 100644
index 0000000..07f5e17
Binary files /dev/null and b/bin/nt_64/locales/hi.pak differ
diff --git a/bin/nt_64/locales/hr.pak b/bin/nt_64/locales/hr.pak
new file mode 100644
index 0000000..61d43f1
Binary files /dev/null and b/bin/nt_64/locales/hr.pak differ
diff --git a/bin/nt_64/locales/hu.pak b/bin/nt_64/locales/hu.pak
new file mode 100644
index 0000000..2f3840d
Binary files /dev/null and b/bin/nt_64/locales/hu.pak differ
diff --git a/bin/nt_64/locales/id.pak b/bin/nt_64/locales/id.pak
new file mode 100644
index 0000000..0a8fb87
Binary files /dev/null and b/bin/nt_64/locales/id.pak differ
diff --git a/bin/nt_64/locales/it.pak b/bin/nt_64/locales/it.pak
new file mode 100644
index 0000000..3c9a472
Binary files /dev/null and b/bin/nt_64/locales/it.pak differ
diff --git a/bin/nt_64/locales/ja.pak b/bin/nt_64/locales/ja.pak
new file mode 100644
index 0000000..b192604
Binary files /dev/null and b/bin/nt_64/locales/ja.pak differ
diff --git a/bin/nt_64/locales/kn.pak b/bin/nt_64/locales/kn.pak
new file mode 100644
index 0000000..9118da2
Binary files /dev/null and b/bin/nt_64/locales/kn.pak differ
diff --git a/bin/nt_64/locales/ko.pak b/bin/nt_64/locales/ko.pak
new file mode 100644
index 0000000..f405e4c
Binary files /dev/null and b/bin/nt_64/locales/ko.pak differ
diff --git a/bin/nt_64/locales/lt.pak b/bin/nt_64/locales/lt.pak
new file mode 100644
index 0000000..292b71b
Binary files /dev/null and b/bin/nt_64/locales/lt.pak differ
diff --git a/bin/nt_64/locales/lv.pak b/bin/nt_64/locales/lv.pak
new file mode 100644
index 0000000..dae91ac
Binary files /dev/null and b/bin/nt_64/locales/lv.pak differ
diff --git a/bin/nt_64/locales/ml.pak b/bin/nt_64/locales/ml.pak
new file mode 100644
index 0000000..01195db
Binary files /dev/null and b/bin/nt_64/locales/ml.pak differ
diff --git a/bin/nt_64/locales/mr.pak b/bin/nt_64/locales/mr.pak
new file mode 100644
index 0000000..48bbe3a
Binary files /dev/null and b/bin/nt_64/locales/mr.pak differ
diff --git a/bin/nt_64/locales/ms.pak b/bin/nt_64/locales/ms.pak
new file mode 100644
index 0000000..ae122e7
Binary files /dev/null and b/bin/nt_64/locales/ms.pak differ
diff --git a/bin/nt_64/locales/nb.pak b/bin/nt_64/locales/nb.pak
new file mode 100644
index 0000000..99ee492
Binary files /dev/null and b/bin/nt_64/locales/nb.pak differ
diff --git a/bin/nt_64/locales/nl.pak b/bin/nt_64/locales/nl.pak
new file mode 100644
index 0000000..feeb59a
Binary files /dev/null and b/bin/nt_64/locales/nl.pak differ
diff --git a/bin/nt_64/locales/pl.pak b/bin/nt_64/locales/pl.pak
new file mode 100644
index 0000000..9491c43
Binary files /dev/null and b/bin/nt_64/locales/pl.pak differ
diff --git a/bin/nt_64/locales/pt-BR.pak b/bin/nt_64/locales/pt-BR.pak
new file mode 100644
index 0000000..839ce5f
Binary files /dev/null and b/bin/nt_64/locales/pt-BR.pak differ
diff --git a/bin/nt_64/locales/pt-PT.pak b/bin/nt_64/locales/pt-PT.pak
new file mode 100644
index 0000000..ead3c0a
Binary files /dev/null and b/bin/nt_64/locales/pt-PT.pak differ
diff --git a/bin/nt_64/locales/ro.pak b/bin/nt_64/locales/ro.pak
new file mode 100644
index 0000000..2001198
Binary files /dev/null and b/bin/nt_64/locales/ro.pak differ
diff --git a/bin/nt_64/locales/ru.pak b/bin/nt_64/locales/ru.pak
new file mode 100644
index 0000000..ea47578
Binary files /dev/null and b/bin/nt_64/locales/ru.pak differ
diff --git a/bin/nt_64/locales/sk.pak b/bin/nt_64/locales/sk.pak
new file mode 100644
index 0000000..24cf537
Binary files /dev/null and b/bin/nt_64/locales/sk.pak differ
diff --git a/bin/nt_64/locales/sl.pak b/bin/nt_64/locales/sl.pak
new file mode 100644
index 0000000..7a2755b
Binary files /dev/null and b/bin/nt_64/locales/sl.pak differ
diff --git a/bin/nt_64/locales/sr.pak b/bin/nt_64/locales/sr.pak
new file mode 100644
index 0000000..d3edea2
Binary files /dev/null and b/bin/nt_64/locales/sr.pak differ
diff --git a/bin/nt_64/locales/sv.pak b/bin/nt_64/locales/sv.pak
new file mode 100644
index 0000000..d967fd2
Binary files /dev/null and b/bin/nt_64/locales/sv.pak differ
diff --git a/bin/nt_64/locales/sw.pak b/bin/nt_64/locales/sw.pak
new file mode 100644
index 0000000..96b9ada
Binary files /dev/null and b/bin/nt_64/locales/sw.pak differ
diff --git a/bin/nt_64/locales/ta.pak b/bin/nt_64/locales/ta.pak
new file mode 100644
index 0000000..48bd8d1
Binary files /dev/null and b/bin/nt_64/locales/ta.pak differ
diff --git a/bin/nt_64/locales/te.pak b/bin/nt_64/locales/te.pak
new file mode 100644
index 0000000..28ed3ef
Binary files /dev/null and b/bin/nt_64/locales/te.pak differ
diff --git a/bin/nt_64/locales/th.pak b/bin/nt_64/locales/th.pak
new file mode 100644
index 0000000..876b1e0
Binary files /dev/null and b/bin/nt_64/locales/th.pak differ
diff --git a/bin/nt_64/locales/tr.pak b/bin/nt_64/locales/tr.pak
new file mode 100644
index 0000000..0d965da
Binary files /dev/null and b/bin/nt_64/locales/tr.pak differ
diff --git a/bin/nt_64/locales/uk.pak b/bin/nt_64/locales/uk.pak
new file mode 100644
index 0000000..ef83ec6
Binary files /dev/null and b/bin/nt_64/locales/uk.pak differ
diff --git a/bin/nt_64/locales/vi.pak b/bin/nt_64/locales/vi.pak
new file mode 100644
index 0000000..af258bf
Binary files /dev/null and b/bin/nt_64/locales/vi.pak differ
diff --git a/bin/nt_64/locales/zh-CN.pak b/bin/nt_64/locales/zh-CN.pak
new file mode 100644
index 0000000..6f4896f
Binary files /dev/null and b/bin/nt_64/locales/zh-CN.pak differ
diff --git a/bin/nt_64/locales/zh-TW.pak b/bin/nt_64/locales/zh-TW.pak
new file mode 100644
index 0000000..85ce42d
Binary files /dev/null and b/bin/nt_64/locales/zh-TW.pak differ
diff --git a/bin/nt_64/lpc_launcher.exe b/bin/nt_64/lpc_launcher.exe
new file mode 100644
index 0000000..f952eb5
Binary files /dev/null and b/bin/nt_64/lpc_launcher.exe differ
diff --git a/bin/nt_64/natives_blob.bin b/bin/nt_64/natives_blob.bin
new file mode 100644
index 0000000..ccaa95d
--- /dev/null
+++ b/bin/nt_64/natives_blob.bin
@@ -0,0 +1,19123 @@
+mirrors�t
+(function(a,b){
+"use strict";
+var c;
+var d=a.Array;
+var e=a.isNaN;
+var f=a.JSON.stringify;
+var g;
+var h;
+var i;
+var j=a.Math.min;
+var k=b.ImportNow("promise_status_symbol");
+var l=b.ImportNow("promise_value_symbol");
+var m;
+var n;
+var o;
+b.Import(function(p){
+c=p.ErrorToString;
+g=p.MakeError;
+h=p.MapEntries;
+i=p.MapIteratorNext;
+m=p.SetIteratorNext;
+n=p.SetValues;
+o=p.SymbolToString;
+});
+var q={
+UNDEFINED_TYPE:'undefined',
+NULL_TYPE:'null',
+BOOLEAN_TYPE:'boolean',
+NUMBER_TYPE:'number',
+STRING_TYPE:'string',
+SYMBOL_TYPE:'symbol',
+OBJECT_TYPE:'object',
+FUNCTION_TYPE:'function',
+REGEXP_TYPE:'regexp',
+ERROR_TYPE:'error',
+PROPERTY_TYPE:'property',
+INTERNAL_PROPERTY_TYPE:'internalProperty',
+FRAME_TYPE:'frame',
+SCRIPT_TYPE:'script',
+CONTEXT_TYPE:'context',
+SCOPE_TYPE:'scope',
+PROMISE_TYPE:'promise',
+MAP_TYPE:'map',
+SET_TYPE:'set',
+ITERATOR_TYPE:'iterator',
+GENERATOR_TYPE:'generator',
+}
+var r=0;
+var s=-1;
+var t=[];
+var u=true;
+function MirrorCacheIsEmpty(){
+return r==0&&t.length==0;
+}
+function ToggleMirrorCache(v){
+u=v;
+ClearMirrorCache();
+}
+function ClearMirrorCache(v){
+r=0;
+t=[];
+}
+function ObjectIsPromise(v){
+return(%_IsJSReceiver(v))&&
+!(%DebugGetProperty(v,k)===(void 0));
+}
+function MakeMirror(v,w){
+var x;
+if(!w&&u){
+for(var y in t){
+x=t[y];
+if(x.value()===v){
+return x;
+}
+if(x.isNumber()&&e(x.value())&&
+typeof v=='number'&&e(v)){
+return x;
+}
+}
+}
+if((v===(void 0))){
+x=new UndefinedMirror();
+}else if((v===null)){
+x=new NullMirror();
+}else if((typeof(v)==='boolean')){
+x=new BooleanMirror(v);
+}else if((typeof(v)==='number')){
+x=new NumberMirror(v);
+}else if((typeof(v)==='string')){
+x=new StringMirror(v);
+}else if((typeof(v)==='symbol')){
+x=new SymbolMirror(v);
+}else if((%_IsArray(v))){
+x=new ArrayMirror(v);
+}else if((%_IsDate(v))){
+x=new DateMirror(v);
+}else if((%_IsFunction(v))){
+x=new FunctionMirror(v);
+}else if((%_IsRegExp(v))){
+x=new RegExpMirror(v);
+}else if((%_ClassOf(v)==='Error')){
+x=new ErrorMirror(v);
+}else if((%_ClassOf(v)==='Script')){
+x=new ScriptMirror(v);
+}else if((%_ClassOf(v)==='Map')||(%_ClassOf(v)==='WeakMap')){
+x=new MapMirror(v);
+}else if((%_ClassOf(v)==='Set')||(%_ClassOf(v)==='WeakSet')){
+x=new SetMirror(v);
+}else if((%_ClassOf(v)==='Map Iterator')||(%_ClassOf(v)==='Set Iterator')){
+x=new IteratorMirror(v);
+}else if(ObjectIsPromise(v)){
+x=new PromiseMirror(v);
+}else if((%_ClassOf(v)==='Generator')){
+x=new GeneratorMirror(v);
+}else{
+x=new ObjectMirror(v,q.OBJECT_TYPE,w);
+}
+if(u)t[x.handle()]=x;
+return x;
+}
+function LookupMirror(z){
+if(!u){
+throw g(2,"Mirror cache is disabled");
+}
+return t[z];
+}
+function GetUndefinedMirror(){
+return MakeMirror((void 0));
+}
+function inherits(A,B){
+var C=function(){};
+C.prototype=B.prototype;
+A.super_=B.prototype;
+A.prototype=new C();
+A.prototype.constructor=A;
+}
+var D=80;
+var E={};
+E.Data=0;
+E.DataConstant=2;
+E.AccessorConstant=3;
+var F={};
+F.None=0;
+F.ReadOnly=1;
+F.DontEnum=2;
+F.DontDelete=4;
+var G={Global:0,
+Local:1,
+With:2,
+Closure:3,
+Catch:4,
+Block:5,
+Script:6};
+function Mirror(H){
+this.type_=H;
+}
+Mirror.prototype.type=function(){
+return this.type_;
+};
+Mirror.prototype.isValue=function(){
+return this instanceof ValueMirror;
+};
+Mirror.prototype.isUndefined=function(){
+return this instanceof UndefinedMirror;
+};
+Mirror.prototype.isNull=function(){
+return this instanceof NullMirror;
+};
+Mirror.prototype.isBoolean=function(){
+return this instanceof BooleanMirror;
+};
+Mirror.prototype.isNumber=function(){
+return this instanceof NumberMirror;
+};
+Mirror.prototype.isString=function(){
+return this instanceof StringMirror;
+};
+Mirror.prototype.isSymbol=function(){
+return this instanceof SymbolMirror;
+};
+Mirror.prototype.isObject=function(){
+return this instanceof ObjectMirror;
+};
+Mirror.prototype.isFunction=function(){
+return this instanceof FunctionMirror;
+};
+Mirror.prototype.isUnresolvedFunction=function(){
+return this instanceof UnresolvedFunctionMirror;
+};
+Mirror.prototype.isArray=function(){
+return this instanceof ArrayMirror;
+};
+Mirror.prototype.isDate=function(){
+return this instanceof DateMirror;
+};
+Mirror.prototype.isRegExp=function(){
+return this instanceof RegExpMirror;
+};
+Mirror.prototype.isError=function(){
+return this instanceof ErrorMirror;
+};
+Mirror.prototype.isPromise=function(){
+return this instanceof PromiseMirror;
+};
+Mirror.prototype.isGenerator=function(){
+return this instanceof GeneratorMirror;
+};
+Mirror.prototype.isProperty=function(){
+return this instanceof PropertyMirror;
+};
+Mirror.prototype.isInternalProperty=function(){
+return this instanceof InternalPropertyMirror;
+};
+Mirror.prototype.isFrame=function(){
+return this instanceof FrameMirror;
+};
+Mirror.prototype.isScript=function(){
+return this instanceof ScriptMirror;
+};
+Mirror.prototype.isContext=function(){
+return this instanceof ContextMirror;
+};
+Mirror.prototype.isScope=function(){
+return this instanceof ScopeMirror;
+};
+Mirror.prototype.isMap=function(){
+return this instanceof MapMirror;
+};
+Mirror.prototype.isSet=function(){
+return this instanceof SetMirror;
+};
+Mirror.prototype.isIterator=function(){
+return this instanceof IteratorMirror;
+};
+Mirror.prototype.allocateHandle_=function(){
+if(u)this.handle_=r++;
+};
+Mirror.prototype.allocateTransientHandle_=function(){
+this.handle_=s--;
+};
+Mirror.prototype.toText=function(){
+return"#<"+this.constructor.name+">";
+};
+function ValueMirror(H,v,I){
+%_Call(Mirror,this,H);
+this.value_=v;
+if(!I){
+this.allocateHandle_();
+}else{
+this.allocateTransientHandle_();
+}
+}
+inherits(ValueMirror,Mirror);
+Mirror.prototype.handle=function(){
+return this.handle_;
+};
+ValueMirror.prototype.isPrimitive=function(){
+var H=this.type();
+return H==='undefined'||
+H==='null'||
+H==='boolean'||
+H==='number'||
+H==='string'||
+H==='symbol';
+};
+ValueMirror.prototype.value=function(){
+return this.value_;
+};
+function UndefinedMirror(){
+%_Call(ValueMirror,this,q.UNDEFINED_TYPE,(void 0));
+}
+inherits(UndefinedMirror,ValueMirror);
+UndefinedMirror.prototype.toText=function(){
+return'undefined';
+};
+function NullMirror(){
+%_Call(ValueMirror,this,q.NULL_TYPE,null);
+}
+inherits(NullMirror,ValueMirror);
+NullMirror.prototype.toText=function(){
+return'null';
+};
+function BooleanMirror(v){
+%_Call(ValueMirror,this,q.BOOLEAN_TYPE,v);
+}
+inherits(BooleanMirror,ValueMirror);
+BooleanMirror.prototype.toText=function(){
+return this.value_?'true':'false';
+};
+function NumberMirror(v){
+%_Call(ValueMirror,this,q.NUMBER_TYPE,v);
+}
+inherits(NumberMirror,ValueMirror);
+NumberMirror.prototype.toText=function(){
+return %_NumberToString(this.value_);
+};
+function StringMirror(v){
+%_Call(ValueMirror,this,q.STRING_TYPE,v);
+}
+inherits(StringMirror,ValueMirror);
+StringMirror.prototype.length=function(){
+return this.value_.length;
+};
+StringMirror.prototype.getTruncatedValue=function(J){
+if(J!=-1&&this.length()>J){
+return this.value_.substring(0,J)+
+'... (length: '+this.length()+')';
+}
+return this.value_;
+};
+StringMirror.prototype.toText=function(){
+return this.getTruncatedValue(D);
+};
+function SymbolMirror(v){
+%_Call(ValueMirror,this,q.SYMBOL_TYPE,v);
+}
+inherits(SymbolMirror,ValueMirror);
+SymbolMirror.prototype.description=function(){
+return %SymbolDescription(%_ValueOf(this.value_));
+}
+SymbolMirror.prototype.toText=function(){
+return %_Call(o,this.value_);
+}
+function ObjectMirror(v,H,I){
+H=H||q.OBJECT_TYPE;
+%_Call(ValueMirror,this,H,v,I);
+}
+inherits(ObjectMirror,ValueMirror);
+ObjectMirror.prototype.className=function(){
+return %_ClassOf(this.value_);
+};
+ObjectMirror.prototype.constructorFunction=function(){
+return MakeMirror(%DebugGetProperty(this.value_,'constructor'));
+};
+ObjectMirror.prototype.prototypeObject=function(){
+return MakeMirror(%DebugGetProperty(this.value_,'prototype'));
+};
+ObjectMirror.prototype.protoObject=function(){
+return MakeMirror(%DebugGetPrototype(this.value_));
+};
+ObjectMirror.prototype.hasNamedInterceptor=function(){
+var K=%GetInterceptorInfo(this.value_);
+return(K&2)!=0;
+};
+ObjectMirror.prototype.hasIndexedInterceptor=function(){
+var K=%GetInterceptorInfo(this.value_);
+return(K&1)!=0;
+};
+ObjectMirror.prototype.propertyNames=function(){
+return %GetOwnPropertyKeys(this.value_,0);
+};
+ObjectMirror.prototype.properties=function(){
+var L=this.propertyNames();
+var M=new d(L.length);
+for(var N=0;N<L.length;N++){
+M[N]=this.property(L[N]);
+}
+return M;
+};
+ObjectMirror.prototype.internalProperties=function(){
+return ObjectMirror.GetInternalProperties(this.value_);
+}
+ObjectMirror.prototype.property=function(O){
+var P=%DebugGetPropertyDetails(this.value_,(%_ToName(O)));
+if(P){
+return new PropertyMirror(this,O,P);
+}
+return GetUndefinedMirror();
+};
+ObjectMirror.prototype.lookupProperty=function(v){
+var M=this.properties();
+for(var N=0;N<M.length;N++){
+var Q=M[N];
+if(Q.propertyType()!=E.AccessorConstant){
+if(%_ObjectEquals(Q.value_,v.value_)){
+return Q;
+}
+}
+}
+return GetUndefinedMirror();
+};
+ObjectMirror.prototype.referencedBy=function(R){
+var S=%DebugReferencedBy(this.value_,
+Mirror.prototype,R||0);
+for(var N=0;N<S.length;N++){
+S[N]=MakeMirror(S[N]);
+}
+return S;
+};
+ObjectMirror.prototype.toText=function(){
+var O;
+var A=this.constructorFunction();
+if(!A.isFunction()){
+O=this.className();
+}else{
+O=A.name();
+if(!O){
+O=this.className();
+}
+}
+return'#<'+O+'>';
+};
+ObjectMirror.GetInternalProperties=function(v){
+var M=%DebugGetInternalProperties(v);
+var S=[];
+for(var N=0;N<M.length;N+=2){
+S.push(new InternalPropertyMirror(M[N],M[N+1]));
+}
+return S;
+}
+function FunctionMirror(v){
+%_Call(ObjectMirror,this,v,q.FUNCTION_TYPE);
+this.resolved_=true;
+}
+inherits(FunctionMirror,ObjectMirror);
+FunctionMirror.prototype.resolved=function(){
+return this.resolved_;
+};
+FunctionMirror.prototype.name=function(){
+return %FunctionGetName(this.value_);
+};
+FunctionMirror.prototype.debugName=function(){
+return %FunctionGetDebugName(this.value_);
+}
+FunctionMirror.prototype.inferredName=function(){
+return %FunctionGetInferredName(this.value_);
+};
+FunctionMirror.prototype.source=function(){
+if(this.resolved()){
+return %FunctionToString(this.value_);
+}
+};
+FunctionMirror.prototype.script=function(){
+if(this.resolved()){
+if(this.script_){
+return this.script_;
+}
+var T=%FunctionGetScript(this.value_);
+if(T){
+return this.script_=MakeMirror(T);
+}
+}
+};
+FunctionMirror.prototype.sourcePosition_=function(){
+if(this.resolved()){
+return %FunctionGetScriptSourcePosition(this.value_);
+}
+};
+FunctionMirror.prototype.sourceLocation=function(){
+if(this.resolved()){
+var T=this.script();
+if(T){
+return T.locationFromPosition(this.sourcePosition_(),true);
+}
+}
+};
+FunctionMirror.prototype.constructedBy=function(U){
+if(this.resolved()){
+var S=%DebugConstructedBy(this.value_,U||0);
+for(var N=0;N<S.length;N++){
+S[N]=MakeMirror(S[N]);
+}
+return S;
+}else{
+return[];
+}
+};
+FunctionMirror.prototype.scopeCount=function(){
+if(this.resolved()){
+if((this.scopeCount_===(void 0))){
+this.scopeCount_=%GetFunctionScopeCount(this.value());
+}
+return this.scopeCount_;
+}else{
+return 0;
+}
+};
+FunctionMirror.prototype.scope=function(V){
+if(this.resolved()){
+return new ScopeMirror((void 0),this,V);
+}
+};
+FunctionMirror.prototype.toText=function(){
+return this.source();
+};
+function UnresolvedFunctionMirror(v){
+%_Call(ValueMirror,this,q.FUNCTION_TYPE,v);
+this.propertyCount_=0;
+this.elementCount_=0;
+this.resolved_=false;
+}
+inherits(UnresolvedFunctionMirror,FunctionMirror);
+UnresolvedFunctionMirror.prototype.className=function(){
+return'Function';
+};
+UnresolvedFunctionMirror.prototype.constructorFunction=function(){
+return GetUndefinedMirror();
+};
+UnresolvedFunctionMirror.prototype.prototypeObject=function(){
+return GetUndefinedMirror();
+};
+UnresolvedFunctionMirror.prototype.protoObject=function(){
+return GetUndefinedMirror();
+};
+UnresolvedFunctionMirror.prototype.name=function(){
+return this.value_;
+};
+UnresolvedFunctionMirror.prototype.inferredName=function(){
+return(void 0);
+};
+UnresolvedFunctionMirror.prototype.propertyNames=function(W,X){
+return[];
+};
+function ArrayMirror(v){
+%_Call(ObjectMirror,this,v);
+}
+inherits(ArrayMirror,ObjectMirror);
+ArrayMirror.prototype.length=function(){
+return this.value_.length;
+};
+ArrayMirror.prototype.indexedPropertiesFromRange=function(opt_from_index,
+opt_to_index){
+var Y=opt_from_index||0;
+var Z=opt_to_index||this.length()-1;
+if(Y>Z)return new d();
+var aa=new d(Z-Y+1);
+for(var N=Y;N<=Z;N++){
+var P=%DebugGetPropertyDetails(this.value_,(%_ToString(N)));
+var v;
+if(P){
+v=new PropertyMirror(this,N,P);
+}else{
+v=GetUndefinedMirror();
+}
+aa[N-Y]=v;
+}
+return aa;
+};
+function DateMirror(v){
+%_Call(ObjectMirror,this,v);
+}
+inherits(DateMirror,ObjectMirror);
+DateMirror.prototype.toText=function(){
+var ab=f(this.value_);
+return ab.substring(1,ab.length-1);
+};
+function RegExpMirror(v){
+%_Call(ObjectMirror,this,v,q.REGEXP_TYPE);
+}
+inherits(RegExpMirror,ObjectMirror);
+RegExpMirror.prototype.source=function(){
+return this.value_.source;
+};
+RegExpMirror.prototype.global=function(){
+return this.value_.global;
+};
+RegExpMirror.prototype.ignoreCase=function(){
+return this.value_.ignoreCase;
+};
+RegExpMirror.prototype.multiline=function(){
+return this.value_.multiline;
+};
+RegExpMirror.prototype.sticky=function(){
+return this.value_.sticky;
+};
+RegExpMirror.prototype.unicode=function(){
+return this.value_.unicode;
+};
+RegExpMirror.prototype.toText=function(){
+return"/"+this.source()+"/";
+};
+function ErrorMirror(v){
+%_Call(ObjectMirror,this,v,q.ERROR_TYPE);
+}
+inherits(ErrorMirror,ObjectMirror);
+ErrorMirror.prototype.message=function(){
+return this.value_.message;
+};
+ErrorMirror.prototype.toText=function(){
+var ac;
+try{
+ac=%_Call(c,this.value_);
+}catch(e){
+ac='#<Error>';
+}
+return ac;
+};
+function PromiseMirror(v){
+%_Call(ObjectMirror,this,v,q.PROMISE_TYPE);
+}
+inherits(PromiseMirror,ObjectMirror);
+function PromiseGetStatus_(v){
+var ad=%DebugGetProperty(v,k);
+if(ad==0)return"pending";
+if(ad==1)return"resolved";
+return"rejected";
+}
+function PromiseGetValue_(v){
+return %DebugGetProperty(v,l);
+}
+PromiseMirror.prototype.status=function(){
+return PromiseGetStatus_(this.value_);
+};
+PromiseMirror.prototype.promiseValue=function(){
+return MakeMirror(PromiseGetValue_(this.value_));
+};
+function MapMirror(v){
+%_Call(ObjectMirror,this,v,q.MAP_TYPE);
+}
+inherits(MapMirror,ObjectMirror);
+MapMirror.prototype.entries=function(ae){
+var S=[];
+if((%_ClassOf(this.value_)==='WeakMap')){
+var af=%GetWeakMapEntries(this.value_,ae||0);
+for(var N=0;N<af.length;N+=2){
+S.push({
+key:af[N],
+value:af[N+1]
+});
+}
+return S;
+}
+var ag=%_Call(h,this.value_);
+var ah;
+while((!ae||S.length<ae)&&
+!(ah=ag.next()).done){
+S.push({
+key:ah.value[0],
+value:ah.value[1]
+});
+}
+return S;
+};
+function SetMirror(v){
+%_Call(ObjectMirror,this,v,q.SET_TYPE);
+}
+inherits(SetMirror,ObjectMirror);
+function IteratorGetValues_(ag,ai,ae){
+var S=[];
+var ah;
+while((!ae||S.length<ae)&&
+!(ah=%_Call(ai,ag)).done){
+S.push(ah.value);
+}
+return S;
+}
+SetMirror.prototype.values=function(ae){
+if((%_ClassOf(this.value_)==='WeakSet')){
+return %GetWeakSetValues(this.value_,ae||0);
+}
+var ag=%_Call(n,this.value_);
+return IteratorGetValues_(ag,m,ae);
+};
+function IteratorMirror(v){
+%_Call(ObjectMirror,this,v,q.ITERATOR_TYPE);
+}
+inherits(IteratorMirror,ObjectMirror);
+IteratorMirror.prototype.preview=function(ae){
+if((%_ClassOf(this.value_)==='Map Iterator')){
+return IteratorGetValues_(%MapIteratorClone(this.value_),
+i,
+ae);
+}else if((%_ClassOf(this.value_)==='Set Iterator')){
+return IteratorGetValues_(%SetIteratorClone(this.value_),
+m,
+ae);
+}
+};
+function GeneratorMirror(v){
+%_Call(ObjectMirror,this,v,q.GENERATOR_TYPE);
+}
+inherits(GeneratorMirror,ObjectMirror);
+function GeneratorGetStatus_(v){
+var aj=%GeneratorGetContinuation(v);
+if(aj<0)return"running";
+if(aj==0)return"closed";
+return"suspended";
+}
+GeneratorMirror.prototype.status=function(){
+return GeneratorGetStatus_(this.value_);
+};
+GeneratorMirror.prototype.sourcePosition_=function(){
+return %GeneratorGetSourcePosition(this.value_);
+};
+GeneratorMirror.prototype.sourceLocation=function(){
+var ak=this.sourcePosition_();
+if(!(ak===(void 0))){
+var T=this.func().script();
+if(T){
+return T.locationFromPosition(ak,true);
+}
+}
+};
+GeneratorMirror.prototype.func=function(){
+if(!this.func_){
+this.func_=MakeMirror(%GeneratorGetFunction(this.value_));
+}
+return this.func_;
+};
+GeneratorMirror.prototype.context=function(){
+if(!this.context_){
+this.context_=new ContextMirror(%GeneratorGetContext(this.value_));
+}
+return this.context_;
+};
+GeneratorMirror.prototype.receiver=function(){
+if(!this.receiver_){
+this.receiver_=MakeMirror(%GeneratorGetReceiver(this.value_));
+}
+return this.receiver_;
+};
+function PropertyMirror(x,O,P){
+%_Call(Mirror,this,q.PROPERTY_TYPE);
+this.mirror_=x;
+this.name_=O;
+this.value_=P[0];
+this.details_=P[1];
+this.is_interceptor_=P[2];
+if(P.length>3){
+this.exception_=P[3];
+this.getter_=P[4];
+this.setter_=P[5];
+}
+}
+inherits(PropertyMirror,Mirror);
+PropertyMirror.prototype.isReadOnly=function(){
+return(this.attributes()&F.ReadOnly)!=0;
+};
+PropertyMirror.prototype.isEnum=function(){
+return(this.attributes()&F.DontEnum)==0;
+};
+PropertyMirror.prototype.canDelete=function(){
+return(this.attributes()&F.DontDelete)==0;
+};
+PropertyMirror.prototype.name=function(){
+return this.name_;
+};
+PropertyMirror.prototype.isIndexed=function(){
+for(var N=0;N<this.name_.length;N++){
+if(this.name_[N]<'0'||'9'<this.name_[N]){
+return false;
+}
+}
+return true;
+};
+PropertyMirror.prototype.value=function(){
+return MakeMirror(this.value_,false);
+};
+PropertyMirror.prototype.isException=function(){
+return this.exception_?true:false;
+};
+PropertyMirror.prototype.attributes=function(){
+return %DebugPropertyAttributesFromDetails(this.details_);
+};
+PropertyMirror.prototype.propertyType=function(){
+return %DebugPropertyTypeFromDetails(this.details_);
+};
+PropertyMirror.prototype.insertionIndex=function(){
+return %DebugPropertyIndexFromDetails(this.details_);
+};
+PropertyMirror.prototype.hasGetter=function(){
+return this.getter_?true:false;
+};
+PropertyMirror.prototype.hasSetter=function(){
+return this.setter_?true:false;
+};
+PropertyMirror.prototype.getter=function(){
+if(this.hasGetter()){
+return MakeMirror(this.getter_);
+}else{
+return GetUndefinedMirror();
+}
+};
+PropertyMirror.prototype.setter=function(){
+if(this.hasSetter()){
+return MakeMirror(this.setter_);
+}else{
+return GetUndefinedMirror();
+}
+};
+PropertyMirror.prototype.isNative=function(){
+return this.is_interceptor_||
+((this.propertyType()==E.AccessorConstant)&&
+!this.hasGetter()&&!this.hasSetter());
+};
+function InternalPropertyMirror(O,v){
+%_Call(Mirror,this,q.INTERNAL_PROPERTY_TYPE);
+this.name_=O;
+this.value_=v;
+}
+inherits(InternalPropertyMirror,Mirror);
+InternalPropertyMirror.prototype.name=function(){
+return this.name_;
+};
+InternalPropertyMirror.prototype.value=function(){
+return MakeMirror(this.value_,false);
+};
+var al=0;
+var am=1;
+var an=2;
+var ao=3;
+var ap=4;
+var aq=5;
+var ar=6;
+var as=7;
+var at=8;
+var au=9;
+var av=0;
+var aw=1;
+var ax=2;
+var ay=1<<0;
+var az=1<<1;
+var aA=7<<2;
+function FrameDetails(aB,V){
+this.break_id_=aB;
+this.details_=%GetFrameDetails(aB,V);
+}
+FrameDetails.prototype.frameId=function(){
+%CheckExecutionState(this.break_id_);
+return this.details_[al];
+};
+FrameDetails.prototype.receiver=function(){
+%CheckExecutionState(this.break_id_);
+return this.details_[am];
+};
+FrameDetails.prototype.func=function(){
+%CheckExecutionState(this.break_id_);
+return this.details_[an];
+};
+FrameDetails.prototype.isConstructCall=function(){
+%CheckExecutionState(this.break_id_);
+return this.details_[ar];
+};
+FrameDetails.prototype.isAtReturn=function(){
+%CheckExecutionState(this.break_id_);
+return this.details_[as];
+};
+FrameDetails.prototype.isDebuggerFrame=function(){
+%CheckExecutionState(this.break_id_);
+var aC=ay;
+return(this.details_[at]&aC)==aC;
+};
+FrameDetails.prototype.isOptimizedFrame=function(){
+%CheckExecutionState(this.break_id_);
+var aC=az;
+return(this.details_[at]&aC)==aC;
+};
+FrameDetails.prototype.isInlinedFrame=function(){
+return this.inlinedFrameIndex()>0;
+};
+FrameDetails.prototype.inlinedFrameIndex=function(){
+%CheckExecutionState(this.break_id_);
+var aC=aA;
+return(this.details_[at]&aC)>>2;
+};
+FrameDetails.prototype.argumentCount=function(){
+%CheckExecutionState(this.break_id_);
+return this.details_[ao];
+};
+FrameDetails.prototype.argumentName=function(V){
+%CheckExecutionState(this.break_id_);
+if(V>=0&&V<this.argumentCount()){
+return this.details_[au+
+V*ax+
+av];
+}
+};
+FrameDetails.prototype.argumentValue=function(V){
+%CheckExecutionState(this.break_id_);
+if(V>=0&&V<this.argumentCount()){
+return this.details_[au+
+V*ax+
+aw];
+}
+};
+FrameDetails.prototype.localCount=function(){
+%CheckExecutionState(this.break_id_);
+return this.details_[ap];
+};
+FrameDetails.prototype.sourcePosition=function(){
+%CheckExecutionState(this.break_id_);
+return this.details_[aq];
+};
+FrameDetails.prototype.localName=function(V){
+%CheckExecutionState(this.break_id_);
+if(V>=0&&V<this.localCount()){
+var aD=au+
+this.argumentCount()*ax;
+return this.details_[aD+
+V*ax+
+av];
+}
+};
+FrameDetails.prototype.localValue=function(V){
+%CheckExecutionState(this.break_id_);
+if(V>=0&&V<this.localCount()){
+var aD=au+
+this.argumentCount()*ax;
+return this.details_[aD+
+V*ax+
+aw];
+}
+};
+FrameDetails.prototype.returnValue=function(){
+%CheckExecutionState(this.break_id_);
+var aE=
+au+
+(this.argumentCount()+this.localCount())*ax;
+if(this.details_[as]){
+return this.details_[aE];
+}
+};
+FrameDetails.prototype.scopeCount=function(){
+if((this.scopeCount_===(void 0))){
+this.scopeCount_=%GetScopeCount(this.break_id_,this.frameId());
+}
+return this.scopeCount_;
+};
+FrameDetails.prototype.stepInPositionsImpl=function(){
+return %GetStepInPositions(this.break_id_,this.frameId());
+};
+function FrameMirror(aB,V){
+%_Call(Mirror,this,q.FRAME_TYPE);
+this.break_id_=aB;
+this.index_=V;
+this.details_=new FrameDetails(aB,V);
+}
+inherits(FrameMirror,Mirror);
+FrameMirror.prototype.details=function(){
+return this.details_;
+};
+FrameMirror.prototype.index=function(){
+return this.index_;
+};
+FrameMirror.prototype.func=function(){
+if(this.func_){
+return this.func_;
+}
+var aC=this.details_.func();
+if((%_IsFunction(aC))){
+return this.func_=MakeMirror(aC);
+}else{
+return new UnresolvedFunctionMirror(aC);
+}
+};
+FrameMirror.prototype.receiver=function(){
+return MakeMirror(this.details_.receiver());
+};
+FrameMirror.prototype.isConstructCall=function(){
+return this.details_.isConstructCall();
+};
+FrameMirror.prototype.isAtReturn=function(){
+return this.details_.isAtReturn();
+};
+FrameMirror.prototype.isDebuggerFrame=function(){
+return this.details_.isDebuggerFrame();
+};
+FrameMirror.prototype.isOptimizedFrame=function(){
+return this.details_.isOptimizedFrame();
+};
+FrameMirror.prototype.isInlinedFrame=function(){
+return this.details_.isInlinedFrame();
+};
+FrameMirror.prototype.inlinedFrameIndex=function(){
+return this.details_.inlinedFrameIndex();
+};
+FrameMirror.prototype.argumentCount=function(){
+return this.details_.argumentCount();
+};
+FrameMirror.prototype.argumentName=function(V){
+return this.details_.argumentName(V);
+};
+FrameMirror.prototype.argumentValue=function(V){
+return MakeMirror(this.details_.argumentValue(V));
+};
+FrameMirror.prototype.localCount=function(){
+return this.details_.localCount();
+};
+FrameMirror.prototype.localName=function(V){
+return this.details_.localName(V);
+};
+FrameMirror.prototype.localValue=function(V){
+return MakeMirror(this.details_.localValue(V));
+};
+FrameMirror.prototype.returnValue=function(){
+return MakeMirror(this.details_.returnValue());
+};
+FrameMirror.prototype.sourcePosition=function(){
+return this.details_.sourcePosition();
+};
+FrameMirror.prototype.sourceLocation=function(){
+var aF=this.func();
+if(aF.resolved()){
+var T=aF.script();
+if(T){
+return T.locationFromPosition(this.sourcePosition(),true);
+}
+}
+};
+FrameMirror.prototype.sourceLine=function(){
+var aG=this.sourceLocation();
+if(aG){
+return aG.line;
+}
+};
+FrameMirror.prototype.sourceColumn=function(){
+var aG=this.sourceLocation();
+if(aG){
+return aG.column;
+}
+};
+FrameMirror.prototype.sourceLineText=function(){
+var aG=this.sourceLocation();
+if(aG){
+return aG.sourceText();
+}
+};
+FrameMirror.prototype.scopeCount=function(){
+return this.details_.scopeCount();
+};
+FrameMirror.prototype.scope=function(V){
+return new ScopeMirror(this,(void 0),V);
+};
+FrameMirror.prototype.allScopes=function(aH){
+var aI=%GetAllScopesDetails(this.break_id_,
+this.details_.frameId(),
+this.details_.inlinedFrameIndex(),
+!!aH);
+var S=[];
+for(var N=0;N<aI.length;++N){
+S.push(new ScopeMirror(this,(void 0),N,aI[N]));
+}
+return S;
+};
+FrameMirror.prototype.stepInPositions=function(){
+var T=this.func().script();
+var aJ=this.func().sourcePosition_();
+var aK=this.details_.stepInPositionsImpl();
+var S=[];
+if(aK){
+for(var N=0;N<aK.length;N++){
+var aL={};
+var aM=T.locationFromPosition(aJ+aK[N],
+true);
+serializeLocationFields(aM,aL);
+var aN={
+position:aL
+};
+S.push(aN);
+}
+}
+return S;
+};
+FrameMirror.prototype.evaluate=function(source,disable_break,
+opt_context_object){
+return MakeMirror(%DebugEvaluate(this.break_id_,
+this.details_.frameId(),
+this.details_.inlinedFrameIndex(),
+source,
+(!!(disable_break)),
+opt_context_object));
+};
+FrameMirror.prototype.invocationText=function(){
+var S='';
+var aF=this.func();
+var aO=this.receiver();
+if(this.isConstructCall()){
+S+='new ';
+S+=aF.name()?aF.name():'[anonymous]';
+}else if(this.isDebuggerFrame()){
+S+='[debugger]';
+}else{
+var aP=
+!aO.className||(aO.className()!='global');
+if(aP){
+S+=aO.toText();
+}
+var Q=GetUndefinedMirror();
+if(aO.isObject()){
+for(var aQ=aO;
+!aQ.isNull()&&Q.isUndefined();
+aQ=aQ.protoObject()){
+Q=aQ.lookupProperty(aF);
+}
+}
+if(!Q.isUndefined()){
+if(!Q.isIndexed()){
+if(aP){
+S+='.';
+}
+S+=Q.name();
+}else{
+S+='[';
+S+=Q.name();
+S+=']';
+}
+if(aF.name()&&aF.name()!=Q.name()){
+S+='(aka '+aF.name()+')';
+}
+}else{
+if(aP){
+S+='.';
+}
+S+=aF.name()?aF.name():'[anonymous]';
+}
+}
+if(!this.isDebuggerFrame()){
+S+='(';
+for(var N=0;N<this.argumentCount();N++){
+if(N!=0)S+=', ';
+if(this.argumentName(N)){
+S+=this.argumentName(N);
+S+='=';
+}
+S+=this.argumentValue(N).toText();
+}
+S+=')';
+}
+if(this.isAtReturn()){
+S+=' returning ';
+S+=this.returnValue().toText();
+}
+return S;
+};
+FrameMirror.prototype.sourceAndPositionText=function(){
+var S='';
+var aF=this.func();
+if(aF.resolved()){
+var T=aF.script();
+if(T){
+if(T.name()){
+S+=T.name();
+}else{
+S+='[unnamed]';
+}
+if(!this.isDebuggerFrame()){
+var aG=this.sourceLocation();
+S+=' line ';
+S+=!(aG===(void 0))?(aG.line+1):'?';
+S+=' column ';
+S+=!(aG===(void 0))?(aG.column+1):'?';
+if(!(this.sourcePosition()===(void 0))){
+S+=' (position '+(this.sourcePosition()+1)+')';
+}
+}
+}else{
+S+='[no source]';
+}
+}else{
+S+='[unresolved]';
+}
+return S;
+};
+FrameMirror.prototype.localsText=function(){
+var S='';
+var aR=this.localCount();
+if(aR>0){
+for(var N=0;N<aR;++N){
+S+='      var ';
+S+=this.localName(N);
+S+=' = ';
+S+=this.localValue(N).toText();
+if(N<aR-1)S+='\n';
+}
+}
+return S;
+};
+FrameMirror.prototype.restart=function(){
+var S=%LiveEditRestartFrame(this.break_id_,this.index_);
+if((S===(void 0))){
+S="Failed to find requested frame";
+}
+return S;
+};
+FrameMirror.prototype.toText=function(aS){
+var S='';
+S+='#'+(this.index()<=9?'0':'')+this.index();
+S+=' ';
+S+=this.invocationText();
+S+=' ';
+S+=this.sourceAndPositionText();
+if(aS){
+S+='\n';
+S+=this.localsText();
+}
+return S;
+};
+var aT=0;
+var aU=1;
+var aV=2;
+function ScopeDetails(aW,aX,V,aY){
+if(aW){
+this.break_id_=aW.break_id_;
+this.details_=aY||
+%GetScopeDetails(aW.break_id_,
+aW.details_.frameId(),
+aW.details_.inlinedFrameIndex(),
+V);
+this.frame_id_=aW.details_.frameId();
+this.inlined_frame_id_=aW.details_.inlinedFrameIndex();
+}else{
+this.details_=aY||%GetFunctionScopeDetails(aX.value(),V);
+this.fun_value_=aX.value();
+this.break_id_=(void 0);
+}
+this.index_=V;
+}
+ScopeDetails.prototype.type=function(){
+if(!(this.break_id_===(void 0))){
+%CheckExecutionState(this.break_id_);
+}
+return this.details_[aT];
+};
+ScopeDetails.prototype.object=function(){
+if(!(this.break_id_===(void 0))){
+%CheckExecutionState(this.break_id_);
+}
+return this.details_[aU];
+};
+ScopeDetails.prototype.name=function(){
+if(!(this.break_id_===(void 0))){
+%CheckExecutionState(this.break_id_);
+}
+return this.details_[aV];
+};
+ScopeDetails.prototype.setVariableValueImpl=function(O,aZ){
+var ba;
+if(!(this.break_id_===(void 0))){
+%CheckExecutionState(this.break_id_);
+ba=%SetScopeVariableValue(this.break_id_,this.frame_id_,
+this.inlined_frame_id_,this.index_,O,aZ);
+}else{
+ba=%SetScopeVariableValue(this.fun_value_,null,null,this.index_,
+O,aZ);
+}
+if(!ba)throw g(2,"Failed to set variable value");
+};
+function ScopeMirror(aW,aX,V,aY){
+%_Call(Mirror,this,q.SCOPE_TYPE);
+if(aW){
+this.frame_index_=aW.index_;
+}else{
+this.frame_index_=(void 0);
+}
+this.scope_index_=V;
+this.details_=new ScopeDetails(aW,aX,V,aY);
+}
+inherits(ScopeMirror,Mirror);
+ScopeMirror.prototype.details=function(){
+return this.details_;
+};
+ScopeMirror.prototype.frameIndex=function(){
+return this.frame_index_;
+};
+ScopeMirror.prototype.scopeIndex=function(){
+return this.scope_index_;
+};
+ScopeMirror.prototype.scopeType=function(){
+return this.details_.type();
+};
+ScopeMirror.prototype.scopeObject=function(){
+var I=this.scopeType()==G.Local||
+this.scopeType()==G.Closure||
+this.scopeType()==G.Script;
+return MakeMirror(this.details_.object(),I);
+};
+ScopeMirror.prototype.setVariableValue=function(O,aZ){
+this.details_.setVariableValueImpl(O,aZ);
+};
+function ScriptMirror(T){
+%_Call(Mirror,this,q.SCRIPT_TYPE);
+this.script_=T;
+this.context_=new ContextMirror(T.context_data);
+this.allocateHandle_();
+}
+inherits(ScriptMirror,Mirror);
+ScriptMirror.prototype.value=function(){
+return this.script_;
+};
+ScriptMirror.prototype.name=function(){
+return this.script_.name||this.script_.nameOrSourceURL();
+};
+ScriptMirror.prototype.id=function(){
+return this.script_.id;
+};
+ScriptMirror.prototype.source=function(){
+return this.script_.source;
+};
+ScriptMirror.prototype.setSource=function(bb){
+%DebugSetScriptSource(this.script_,bb);
+};
+ScriptMirror.prototype.lineOffset=function(){
+return this.script_.line_offset;
+};
+ScriptMirror.prototype.columnOffset=function(){
+return this.script_.column_offset;
+};
+ScriptMirror.prototype.data=function(){
+return this.script_.data;
+};
+ScriptMirror.prototype.scriptType=function(){
+return this.script_.type;
+};
+ScriptMirror.prototype.compilationType=function(){
+return this.script_.compilation_type;
+};
+ScriptMirror.prototype.lineCount=function(){
+return this.script_.lineCount();
+};
+ScriptMirror.prototype.locationFromPosition=function(
+position,include_resource_offset){
+return this.script_.locationFromPosition(position,include_resource_offset);
+};
+ScriptMirror.prototype.sourceSlice=function(bc,bd){
+return this.script_.sourceSlice(bc,bd);
+};
+ScriptMirror.prototype.context=function(){
+return this.context_;
+};
+ScriptMirror.prototype.evalFromScript=function(){
+return MakeMirror(this.script_.eval_from_script);
+};
+ScriptMirror.prototype.evalFromFunctionName=function(){
+return MakeMirror(this.script_.eval_from_function_name);
+};
+ScriptMirror.prototype.evalFromLocation=function(){
+var be=this.evalFromScript();
+if(!be.isUndefined()){
+var bf=this.script_.eval_from_script_position;
+return be.locationFromPosition(bf,true);
+}
+};
+ScriptMirror.prototype.toText=function(){
+var S='';
+S+=this.name();
+S+=' (lines: ';
+if(this.lineOffset()>0){
+S+=this.lineOffset();
+S+='-';
+S+=this.lineOffset()+this.lineCount()-1;
+}else{
+S+=this.lineCount();
+}
+S+=')';
+return S;
+};
+function ContextMirror(bg){
+%_Call(Mirror,this,q.CONTEXT_TYPE);
+this.data_=bg;
+this.allocateHandle_();
+}
+inherits(ContextMirror,Mirror);
+ContextMirror.prototype.data=function(){
+return this.data_;
+};
+function MakeMirrorSerializer(P,bh){
+return new JSONProtocolSerializer(P,bh);
+}
+function JSONProtocolSerializer(P,bh){
+this.details_=P;
+this.options_=bh;
+this.mirrors_=[];
+}
+JSONProtocolSerializer.prototype.serializeReference=function(x){
+return this.serialize_(x,true,true);
+};
+JSONProtocolSerializer.prototype.serializeValue=function(x){
+var bi=this.serialize_(x,false,true);
+return bi;
+};
+JSONProtocolSerializer.prototype.serializeReferencedObjects=function(){
+var bj=[];
+var bk=this.mirrors_.length;
+for(var N=0;N<bk;N++){
+bj.push(this.serialize_(this.mirrors_[N],false,false));
+}
+return bj;
+};
+JSONProtocolSerializer.prototype.includeSource_=function(){
+return this.options_&&this.options_.includeSource;
+};
+JSONProtocolSerializer.prototype.inlineRefs_=function(){
+return this.options_&&this.options_.inlineRefs;
+};
+JSONProtocolSerializer.prototype.maxStringLength_=function(){
+if((this.options_===(void 0))||
+(this.options_.maxStringLength===(void 0))){
+return D;
+}
+return this.options_.maxStringLength;
+};
+JSONProtocolSerializer.prototype.add_=function(x){
+for(var N=0;N<this.mirrors_.length;N++){
+if(this.mirrors_[N]===x){
+return;
+}
+}
+this.mirrors_.push(x);
+};
+JSONProtocolSerializer.prototype.serializeReferenceWithDisplayData_=
+function(x){
+var bl={};
+bl.ref=x.handle();
+bl.type=x.type();
+switch(x.type()){
+case q.UNDEFINED_TYPE:
+case q.NULL_TYPE:
+case q.BOOLEAN_TYPE:
+case q.NUMBER_TYPE:
+bl.value=x.value();
+break;
+case q.STRING_TYPE:
+bl.value=x.getTruncatedValue(this.maxStringLength_());
+break;
+case q.SYMBOL_TYPE:
+bl.description=x.description();
+break;
+case q.FUNCTION_TYPE:
+bl.name=x.name();
+bl.inferredName=x.inferredName();
+if(x.script()){
+bl.scriptId=x.script().id();
+}
+break;
+case q.ERROR_TYPE:
+case q.REGEXP_TYPE:
+bl.value=x.toText();
+break;
+case q.OBJECT_TYPE:
+bl.className=x.className();
+break;
+}
+return bl;
+};
+JSONProtocolSerializer.prototype.serialize_=function(x,reference,
+P){
+if(reference&&
+(x.isValue()||x.isScript()||x.isContext())){
+if(this.inlineRefs_()&&x.isValue()){
+return this.serializeReferenceWithDisplayData_(x);
+}else{
+this.add_(x);
+return{'ref':x.handle()};
+}
+}
+var bj={};
+if(x.isValue()||x.isScript()||x.isContext()){
+bj.handle=x.handle();
+}
+bj.type=x.type();
+switch(x.type()){
+case q.UNDEFINED_TYPE:
+case q.NULL_TYPE:
+break;
+case q.BOOLEAN_TYPE:
+bj.value=x.value();
+break;
+case q.NUMBER_TYPE:
+bj.value=NumberToJSON_(x.value());
+break;
+case q.STRING_TYPE:
+if(this.maxStringLength_()!=-1&&
+x.length()>this.maxStringLength_()){
+var bm=x.getTruncatedValue(this.maxStringLength_());
+bj.value=bm;
+bj.fromIndex=0;
+bj.toIndex=this.maxStringLength_();
+}else{
+bj.value=x.value();
+}
+bj.length=x.length();
+break;
+case q.SYMBOL_TYPE:
+bj.description=x.description();
+break;
+case q.OBJECT_TYPE:
+case q.FUNCTION_TYPE:
+case q.ERROR_TYPE:
+case q.REGEXP_TYPE:
+case q.PROMISE_TYPE:
+case q.GENERATOR_TYPE:
+this.serializeObject_(x,bj,P);
+break;
+case q.PROPERTY_TYPE:
+case q.INTERNAL_PROPERTY_TYPE:
+throw g(2,
+'PropertyMirror cannot be serialized independently');
+break;
+case q.FRAME_TYPE:
+this.serializeFrame_(x,bj);
+break;
+case q.SCOPE_TYPE:
+this.serializeScope_(x,bj);
+break;
+case q.SCRIPT_TYPE:
+if(x.name()){
+bj.name=x.name();
+}
+bj.id=x.id();
+bj.lineOffset=x.lineOffset();
+bj.columnOffset=x.columnOffset();
+bj.lineCount=x.lineCount();
+if(x.data()){
+bj.data=x.data();
+}
+if(this.includeSource_()){
+bj.source=x.source();
+}else{
+var bn=x.source().substring(0,80);
+bj.sourceStart=bn;
+}
+bj.sourceLength=x.source().length;
+bj.scriptType=x.scriptType();
+bj.compilationType=x.compilationType();
+if(x.compilationType()==1&&
+x.evalFromScript()){
+bj.evalFromScript=
+this.serializeReference(x.evalFromScript());
+var bo=x.evalFromLocation();
+if(bo){
+bj.evalFromLocation={line:bo.line,
+column:bo.column};
+}
+if(x.evalFromFunctionName()){
+bj.evalFromFunctionName=x.evalFromFunctionName();
+}
+}
+if(x.context()){
+bj.context=this.serializeReference(x.context());
+}
+break;
+case q.CONTEXT_TYPE:
+bj.data=x.data();
+break;
+}
+bj.text=x.toText();
+return bj;
+};
+JSONProtocolSerializer.prototype.serializeObject_=function(x,bj,
+P){
+bj.className=x.className();
+bj.constructorFunction=
+this.serializeReference(x.constructorFunction());
+bj.protoObject=this.serializeReference(x.protoObject());
+bj.prototypeObject=this.serializeReference(x.prototypeObject());
+if(x.hasNamedInterceptor()){
+bj.namedInterceptor=true;
+}
+if(x.hasIndexedInterceptor()){
+bj.indexedInterceptor=true;
+}
+if(x.isFunction()){
+bj.name=x.name();
+if(!(x.inferredName()===(void 0))){
+bj.inferredName=x.inferredName();
+}
+bj.resolved=x.resolved();
+if(x.resolved()){
+bj.source=x.source();
+}
+if(x.script()){
+bj.script=this.serializeReference(x.script());
+bj.scriptId=x.script().id();
+serializeLocationFields(x.sourceLocation(),bj);
+}
+bj.scopes=[];
+for(var N=0;N<x.scopeCount();N++){
+var bp=x.scope(N);
+bj.scopes.push({
+type:bp.scopeType(),
+index:N
+});
+}
+}
+if(x.isGenerator()){
+bj.status=x.status();
+bj.func=this.serializeReference(x.func())
+bj.receiver=this.serializeReference(x.receiver())
+serializeLocationFields(x.sourceLocation(),bj);
+}
+if(x.isDate()){
+bj.value=x.value();
+}
+if(x.isPromise()){
+bj.status=x.status();
+bj.promiseValue=this.serializeReference(x.promiseValue());
+}
+var M=x.propertyNames();
+for(var N=0;N<M.length;N++){
+var bq=x.property(M[N]);
+M[N]=this.serializeProperty_(bq);
+if(P){
+this.add_(bq.value());
+}
+}
+bj.properties=M;
+var br=x.internalProperties();
+if(br.length>0){
+var bs=[];
+for(var N=0;N<br.length;N++){
+bs.push(this.serializeInternalProperty_(br[N]));
+}
+bj.internalProperties=bs;
+}
+};
+function serializeLocationFields(aG,bj){
+if(!aG){
+return;
+}
+bj.position=aG.position;
+var bt=aG.line;
+if(!(bt===(void 0))){
+bj.line=bt;
+}
+var bu=aG.column;
+if(!(bu===(void 0))){
+bj.column=bu;
+}
+}
+JSONProtocolSerializer.prototype.serializeProperty_=function(bq){
+var S={};
+S.name=bq.name();
+var bv=bq.value();
+if(this.inlineRefs_()&&bv.isValue()){
+S.value=this.serializeReferenceWithDisplayData_(bv);
+}else{
+if(bq.attributes()!=F.None){
+S.attributes=bq.attributes();
+}
+S.propertyType=bq.propertyType();
+S.ref=bv.handle();
+}
+return S;
+};
+JSONProtocolSerializer.prototype.serializeInternalProperty_=
+function(bq){
+var S={};
+S.name=bq.name();
+var bv=bq.value();
+if(this.inlineRefs_()&&bv.isValue()){
+S.value=this.serializeReferenceWithDisplayData_(bv);
+}else{
+S.ref=bv.handle();
+}
+return S;
+};
+JSONProtocolSerializer.prototype.serializeFrame_=function(x,bj){
+bj.index=x.index();
+bj.receiver=this.serializeReference(x.receiver());
+var aF=x.func();
+bj.func=this.serializeReference(aF);
+var T=aF.script();
+if(T){
+bj.script=this.serializeReference(T);
+}
+bj.constructCall=x.isConstructCall();
+bj.atReturn=x.isAtReturn();
+if(x.isAtReturn()){
+bj.returnValue=this.serializeReference(x.returnValue());
+}
+bj.debuggerFrame=x.isDebuggerFrame();
+var K=new d(x.argumentCount());
+for(var N=0;N<x.argumentCount();N++){
+var bw={};
+var bx=x.argumentName(N);
+if(bx){
+bw.name=bx;
+}
+bw.value=this.serializeReference(x.argumentValue(N));
+K[N]=bw;
+}
+bj.arguments=K;
+var K=new d(x.localCount());
+for(var N=0;N<x.localCount();N++){
+var by={};
+by.name=x.localName(N);
+by.value=this.serializeReference(x.localValue(N));
+K[N]=by;
+}
+bj.locals=K;
+serializeLocationFields(x.sourceLocation(),bj);
+var bz=x.sourceLineText();
+if(!(bz===(void 0))){
+bj.sourceLineText=bz;
+}
+bj.scopes=[];
+for(var N=0;N<x.scopeCount();N++){
+var bp=x.scope(N);
+bj.scopes.push({
+type:bp.scopeType(),
+index:N
+});
+}
+};
+JSONProtocolSerializer.prototype.serializeScope_=function(x,bj){
+bj.index=x.scopeIndex();
+bj.frameIndex=x.frameIndex();
+bj.type=x.scopeType();
+bj.object=this.inlineRefs_()?
+this.serializeValue(x.scopeObject()):
+this.serializeReference(x.scopeObject());
+};
+function NumberToJSON_(v){
+if(e(v)){
+return'NaN';
+}
+if(!(%_IsSmi(%IS_VAR(v))||((v==v)&&(v!=1/0)&&(v!=-1/0)))){
+if(v>0){
+return'Infinity';
+}else{
+return'-Infinity';
+}
+}
+return v;
+}
+b.InstallFunctions(a,2,[
+"MakeMirror",MakeMirror,
+"MakeMirrorSerializer",MakeMirrorSerializer,
+"LookupMirror",LookupMirror,
+"ToggleMirrorCache",ToggleMirrorCache,
+"MirrorCacheIsEmpty",MirrorCacheIsEmpty,
+]);
+b.InstallConstants(a,[
+"ScopeType",G,
+"PropertyType",E,
+"PropertyAttribute",F,
+"Mirror",Mirror,
+"ValueMirror",ValueMirror,
+"UndefinedMirror",UndefinedMirror,
+"NullMirror",NullMirror,
+"BooleanMirror",BooleanMirror,
+"NumberMirror",NumberMirror,
+"StringMirror",StringMirror,
+"SymbolMirror",SymbolMirror,
+"ObjectMirror",ObjectMirror,
+"FunctionMirror",FunctionMirror,
+"UnresolvedFunctionMirror",UnresolvedFunctionMirror,
+"ArrayMirror",ArrayMirror,
+"DateMirror",DateMirror,
+"RegExpMirror",RegExpMirror,
+"ErrorMirror",ErrorMirror,
+"PromiseMirror",PromiseMirror,
+"MapMirror",MapMirror,
+"SetMirror",SetMirror,
+"IteratorMirror",IteratorMirror,
+"GeneratorMirror",GeneratorMirror,
+"PropertyMirror",PropertyMirror,
+"InternalPropertyMirror",InternalPropertyMirror,
+"FrameMirror",FrameMirror,
+"ScriptMirror",ScriptMirror,
+"ScopeMirror",ScopeMirror,
+"FrameDetails",FrameDetails,
+]);
+b.InstallFunctions(b,2,[
+"ClearMirrorCache",ClearMirrorCache
+]);
+b.Export(function(bA){
+bA.MirrorType=q;
+});
+})
+
+debugN�
+(function(a,b){
+"use strict";
+var c=a.FrameMirror;
+var d=a.Array;
+var e=a.RegExp;
+var f=a.isNaN;
+var g=a.JSON.parse;
+var h=a.JSON.stringify;
+var i=a.LookupMirror;
+var j;
+var k;
+var l=a.MakeMirror;
+var m=a.MakeMirrorSerializer;
+var n=a.Math.min;
+var o=a.Mirror;
+var p;
+var q=a.parseInt;
+var r=a.ValueMirror;
+b.Import(function(s){
+j=s.MakeError;
+k=s.MakeTypeError;
+p=s.MirrorType;
+});
+var t=10;
+var u={};
+var v=/^(?:\s*(?:\/\*.*?\*\/)*)*/;
+u.DebugEvent={Break:1,
+Exception:2,
+NewFunction:3,
+BeforeCompile:4,
+AfterCompile:5,
+CompileError:6,
+PromiseEvent:7,
+AsyncTaskEvent:8};
+u.ExceptionBreak={Caught:0,
+Uncaught:1};
+u.StepAction={StepOut:0,
+StepNext:1,
+StepIn:2,
+StepFrame:3};
+u.ScriptType={Native:0,
+Extension:1,
+Normal:2};
+u.ScriptCompilationType={Host:0,
+Eval:1,
+JSON:2};
+u.ScriptBreakPointType={ScriptId:0,
+ScriptName:1,
+ScriptRegExp:2};
+u.BreakPositionAlignment={
+Statement:0,
+BreakPosition:1
+};
+function ScriptTypeFlag(w){
+return(1<<w);
+}
+var x=0;
+var y=1;
+var z=[];
+var A=[];
+var B={
+breakPointsActive:{
+value:true,
+getValue:function(){return this.value;},
+setValue:function(C){
+this.value=!!C;
+%SetBreakPointsActive(this.value);
+}
+},
+breakOnCaughtException:{
+getValue:function(){return u.isBreakOnException();},
+setValue:function(C){
+if(C){
+u.setBreakOnException();
+}else{
+u.clearBreakOnException();
+}
+}
+},
+breakOnUncaughtException:{
+getValue:function(){return u.isBreakOnUncaughtException();},
+setValue:function(C){
+if(C){
+u.setBreakOnUncaughtException();
+}else{
+u.clearBreakOnUncaughtException();
+}
+}
+},
+};
+function MakeBreakPoint(D,E){
+var F=new BreakPoint(D,E);
+z.push(F);
+return F;
+}
+function BreakPoint(D,E){
+this.source_position_=D;
+if(E){
+this.script_break_point_=E;
+}else{
+this.number_=y++;
+}
+this.hit_count_=0;
+this.active_=true;
+this.condition_=null;
+this.ignoreCount_=0;
+}
+BreakPoint.prototype.number=function(){
+return this.number_;
+};
+BreakPoint.prototype.func=function(){
+return this.func_;
+};
+BreakPoint.prototype.source_position=function(){
+return this.source_position_;
+};
+BreakPoint.prototype.hit_count=function(){
+return this.hit_count_;
+};
+BreakPoint.prototype.active=function(){
+if(this.script_break_point()){
+return this.script_break_point().active();
+}
+return this.active_;
+};
+BreakPoint.prototype.condition=function(){
+if(this.script_break_point()&&this.script_break_point().condition()){
+return this.script_break_point().condition();
+}
+return this.condition_;
+};
+BreakPoint.prototype.ignoreCount=function(){
+return this.ignoreCount_;
+};
+BreakPoint.prototype.script_break_point=function(){
+return this.script_break_point_;
+};
+BreakPoint.prototype.enable=function(){
+this.active_=true;
+};
+BreakPoint.prototype.disable=function(){
+this.active_=false;
+};
+BreakPoint.prototype.setCondition=function(G){
+this.condition_=G;
+};
+BreakPoint.prototype.setIgnoreCount=function(H){
+this.ignoreCount_=H;
+};
+BreakPoint.prototype.isTriggered=function(I){
+if(!this.active())return false;
+if(this.condition()){
+try{
+var J=I.frame(0).evaluate(this.condition());
+if(!(J instanceof r)||!J.value_){
+return false;
+}
+}catch(e){
+return false;
+}
+}
+this.hit_count_++;
+if(this.script_break_point_){
+this.script_break_point_.hit_count_++;
+}
+if(this.ignoreCount_>0){
+this.ignoreCount_--;
+return false;
+}
+return true;
+};
+function IsBreakPointTriggered(K,F){
+return F.isTriggered(MakeExecutionState(K));
+}
+function ScriptBreakPoint(w,script_id_or_name,opt_line,opt_column,
+opt_groupId,opt_position_alignment){
+this.type_=w;
+if(w==u.ScriptBreakPointType.ScriptId){
+this.script_id_=script_id_or_name;
+}else if(w==u.ScriptBreakPointType.ScriptName){
+this.script_name_=script_id_or_name;
+}else if(w==u.ScriptBreakPointType.ScriptRegExp){
+this.script_regexp_object_=new e(script_id_or_name);
+}else{
+throw j(2,"Unexpected breakpoint type "+w);
+}
+this.line_=opt_line||0;
+this.column_=opt_column;
+this.groupId_=opt_groupId;
+this.position_alignment_=(opt_position_alignment===(void 0))
+?u.BreakPositionAlignment.Statement:opt_position_alignment;
+this.hit_count_=0;
+this.active_=true;
+this.condition_=null;
+this.ignoreCount_=0;
+this.break_points_=[];
+}
+ScriptBreakPoint.prototype.cloneForOtherScript=function(L){
+var M=new ScriptBreakPoint(u.ScriptBreakPointType.ScriptId,
+L.id,this.line_,this.column_,this.groupId_,
+this.position_alignment_);
+M.number_=y++;
+A.push(M);
+M.hit_count_=this.hit_count_;
+M.active_=this.active_;
+M.condition_=this.condition_;
+M.ignoreCount_=this.ignoreCount_;
+return M;
+};
+ScriptBreakPoint.prototype.number=function(){
+return this.number_;
+};
+ScriptBreakPoint.prototype.groupId=function(){
+return this.groupId_;
+};
+ScriptBreakPoint.prototype.type=function(){
+return this.type_;
+};
+ScriptBreakPoint.prototype.script_id=function(){
+return this.script_id_;
+};
+ScriptBreakPoint.prototype.script_name=function(){
+return this.script_name_;
+};
+ScriptBreakPoint.prototype.script_regexp_object=function(){
+return this.script_regexp_object_;
+};
+ScriptBreakPoint.prototype.line=function(){
+return this.line_;
+};
+ScriptBreakPoint.prototype.column=function(){
+return this.column_;
+};
+ScriptBreakPoint.prototype.actual_locations=function(){
+var N=[];
+for(var O=0;O<this.break_points_.length;O++){
+N.push(this.break_points_[O].actual_location);
+}
+return N;
+};
+ScriptBreakPoint.prototype.update_positions=function(P,Q){
+this.line_=P;
+this.column_=Q;
+};
+ScriptBreakPoint.prototype.hit_count=function(){
+return this.hit_count_;
+};
+ScriptBreakPoint.prototype.active=function(){
+return this.active_;
+};
+ScriptBreakPoint.prototype.condition=function(){
+return this.condition_;
+};
+ScriptBreakPoint.prototype.ignoreCount=function(){
+return this.ignoreCount_;
+};
+ScriptBreakPoint.prototype.enable=function(){
+this.active_=true;
+};
+ScriptBreakPoint.prototype.disable=function(){
+this.active_=false;
+};
+ScriptBreakPoint.prototype.setCondition=function(G){
+this.condition_=G;
+};
+ScriptBreakPoint.prototype.setIgnoreCount=function(H){
+this.ignoreCount_=H;
+for(var O=0;O<this.break_points_.length;O++){
+this.break_points_[O].setIgnoreCount(H);
+}
+};
+ScriptBreakPoint.prototype.matchesScript=function(R){
+if(this.type_==u.ScriptBreakPointType.ScriptId){
+return this.script_id_==R.id;
+}else{
+if(!(R.line_offset<=this.line_&&
+this.line_<R.line_offset+R.lineCount())){
+return false;
+}
+if(this.type_==u.ScriptBreakPointType.ScriptName){
+return this.script_name_==R.nameOrSourceURL();
+}else if(this.type_==u.ScriptBreakPointType.ScriptRegExp){
+return this.script_regexp_object_.test(R.nameOrSourceURL());
+}else{
+throw j(2,"Unexpected breakpoint type "+this.type_);
+}
+}
+};
+ScriptBreakPoint.prototype.set=function(R){
+var Q=this.column();
+var P=this.line();
+if((Q===(void 0))){
+var S=R.sourceLine(this.line());
+if(!R.sourceColumnStart_){
+R.sourceColumnStart_=new d(R.lineCount());
+}
+if((R.sourceColumnStart_[P]===(void 0))){
+R.sourceColumnStart_[P]=
+S.match(v)[0].length;
+}
+Q=R.sourceColumnStart_[P];
+}
+var T=u.findScriptSourcePosition(R,this.line(),Q);
+if((T===null))return;
+var F=MakeBreakPoint(T,this);
+F.setIgnoreCount(this.ignoreCount());
+var U=%SetScriptBreakPoint(R,T,
+this.position_alignment_,
+F);
+if((U===(void 0))){
+U=T;
+}
+var V=R.locationFromPosition(U,true);
+F.actual_location={line:V.line,
+column:V.column,
+script_id:R.id};
+this.break_points_.push(F);
+return F;
+};
+ScriptBreakPoint.prototype.clear=function(){
+var W=[];
+for(var O=0;O<z.length;O++){
+if(z[O].script_break_point()&&
+z[O].script_break_point()===this){
+%ClearBreakPoint(z[O]);
+}else{
+W.push(z[O]);
+}
+}
+z=W;
+this.break_points_=[];
+};
+function UpdateScriptBreakPoints(R){
+for(var O=0;O<A.length;O++){
+var F=A[O];
+if((F.type()==u.ScriptBreakPointType.ScriptName||
+F.type()==u.ScriptBreakPointType.ScriptRegExp)&&
+F.matchesScript(R)){
+F.set(R);
+}
+}
+}
+function GetScriptBreakPoints(R){
+var X=[];
+for(var O=0;O<A.length;O++){
+if(A[O].matchesScript(R)){
+X.push(A[O]);
+}
+}
+return X;
+}
+u.setListener=function(Y,Z){
+if(!(%_IsFunction(Y))&&!(Y===(void 0))&&!(Y===null)){
+throw k(32);
+}
+%SetDebugEventListener(Y,Z);
+};
+u.breakLocations=function(aa,ab){
+if(!(%_IsFunction(aa)))throw k(32);
+var ac=(ab===(void 0))
+?u.BreakPositionAlignment.Statement:ab;
+return %GetBreakLocations(aa,ac);
+};
+u.findScript=function(ad){
+if((%_IsFunction(ad))){
+return %FunctionGetScript(ad);
+}else if((%_IsRegExp(ad))){
+var ae=u.scripts();
+var af=null;
+var ag=0;
+for(var O in ae){
+var R=ae[O];
+if(ad.test(R.name)){
+af=R;
+ag++;
+}
+}
+if(ag==1){
+return af;
+}else{
+return(void 0);
+}
+}else{
+return %GetScript(ad);
+}
+};
+u.scriptSource=function(ad){
+return this.findScript(ad).source;
+};
+u.source=function(aa){
+if(!(%_IsFunction(aa)))throw k(32);
+return %FunctionGetSourceCode(aa);
+};
+u.sourcePosition=function(aa){
+if(!(%_IsFunction(aa)))throw k(32);
+return %FunctionGetScriptSourcePosition(aa);
+};
+u.findFunctionSourceLocation=function(ah,ai,aj){
+var R=%FunctionGetScript(ah);
+var ak=%FunctionGetScriptSourcePosition(ah);
+return R.locationFromLine(ai,aj,ak);
+};
+u.findScriptSourcePosition=function(R,ai,aj){
+var al=R.locationFromLine(ai,aj);
+return al?al.position:null;
+};
+u.findBreakPoint=function(am,an){
+var F;
+for(var O=0;O<z.length;O++){
+if(z[O].number()==am){
+F=z[O];
+if(an){
+z.splice(O,1);
+}
+break;
+}
+}
+if(F){
+return F;
+}else{
+return this.findScriptBreakPoint(am,an);
+}
+};
+u.findBreakPointActualLocations=function(am){
+for(var O=0;O<A.length;O++){
+if(A[O].number()==am){
+return A[O].actual_locations();
+}
+}
+for(var O=0;O<z.length;O++){
+if(z[O].number()==am){
+return[z[O].actual_location];
+}
+}
+return[];
+};
+u.setBreakPoint=function(ah,ai,aj,ao){
+if(!(%_IsFunction(ah)))throw k(32);
+if(%FunctionIsAPIFunction(ah)){
+throw j(2,'Cannot set break point in native code.');
+}
+var ap=
+this.findFunctionSourceLocation(ah,ai,aj).position;
+var D=ap-this.sourcePosition(ah);
+var R=%FunctionGetScript(ah);
+if(R.type==u.ScriptType.Native){
+throw j(2,'Cannot set break point in native code.');
+}
+if(R&&R.id){
+D+=%FunctionGetScriptSourcePosition(ah);
+var al=R.locationFromPosition(D,false);
+return this.setScriptBreakPointById(R.id,
+al.line,al.column,
+ao);
+}else{
+var F=MakeBreakPoint(D);
+var U=
+%SetFunctionBreakPoint(ah,D,F);
+U+=this.sourcePosition(ah);
+var V=R.locationFromPosition(U,true);
+F.actual_location={line:V.line,
+column:V.column,
+script_id:R.id};
+F.setCondition(ao);
+return F.number();
+}
+};
+u.setBreakPointByScriptIdAndPosition=function(script_id,T,
+G,enabled,
+opt_position_alignment)
+{
+var F=MakeBreakPoint(T);
+F.setCondition(G);
+if(!enabled){
+F.disable();
+}
+var ae=this.scripts();
+var aq=(opt_position_alignment===(void 0))
+?u.BreakPositionAlignment.Statement:opt_position_alignment;
+for(var O=0;O<ae.length;O++){
+if(script_id==ae[O].id){
+F.actual_position=%SetScriptBreakPoint(ae[O],T,
+aq,F);
+break;
+}
+}
+return F;
+};
+u.enableBreakPoint=function(am){
+var F=this.findBreakPoint(am,false);
+if(F){
+F.enable();
+}
+};
+u.disableBreakPoint=function(am){
+var F=this.findBreakPoint(am,false);
+if(F){
+F.disable();
+}
+};
+u.changeBreakPointCondition=function(am,G){
+var F=this.findBreakPoint(am,false);
+F.setCondition(G);
+};
+u.changeBreakPointIgnoreCount=function(am,H){
+if(H<0)throw j(2,'Invalid argument');
+var F=this.findBreakPoint(am,false);
+F.setIgnoreCount(H);
+};
+u.clearBreakPoint=function(am){
+var F=this.findBreakPoint(am,true);
+if(F){
+return %ClearBreakPoint(F);
+}else{
+F=this.findScriptBreakPoint(am,true);
+if(!F)throw j(2,'Invalid breakpoint');
+}
+};
+u.clearAllBreakPoints=function(){
+for(var O=0;O<z.length;O++){
+var F=z[O];
+%ClearBreakPoint(F);
+}
+z=[];
+};
+u.disableAllBreakPoints=function(){
+for(var O=1;O<y;O++){
+u.disableBreakPoint(O);
+}
+%ChangeBreakOnException(u.ExceptionBreak.Caught,false);
+%ChangeBreakOnException(u.ExceptionBreak.Uncaught,false);
+};
+u.findScriptBreakPoint=function(am,an){
+var ar;
+for(var O=0;O<A.length;O++){
+if(A[O].number()==am){
+ar=A[O];
+if(an){
+ar.clear();
+A.splice(O,1);
+}
+break;
+}
+}
+return ar;
+};
+u.setScriptBreakPoint=function(w,script_id_or_name,
+ai,aj,ao,
+opt_groupId,opt_position_alignment){
+var ar=
+new ScriptBreakPoint(w,script_id_or_name,ai,aj,
+opt_groupId,opt_position_alignment);
+ar.number_=y++;
+ar.setCondition(ao);
+A.push(ar);
+var ae=this.scripts();
+for(var O=0;O<ae.length;O++){
+if(ar.matchesScript(ae[O])){
+ar.set(ae[O]);
+}
+}
+return ar.number();
+};
+u.setScriptBreakPointById=function(script_id,
+ai,aj,
+ao,opt_groupId,
+opt_position_alignment){
+return this.setScriptBreakPoint(u.ScriptBreakPointType.ScriptId,
+script_id,ai,aj,
+ao,opt_groupId,
+opt_position_alignment);
+};
+u.setScriptBreakPointByName=function(script_name,
+ai,aj,
+ao,opt_groupId){
+return this.setScriptBreakPoint(u.ScriptBreakPointType.ScriptName,
+script_name,ai,aj,
+ao,opt_groupId);
+};
+u.setScriptBreakPointByRegExp=function(script_regexp,
+ai,aj,
+ao,opt_groupId){
+return this.setScriptBreakPoint(u.ScriptBreakPointType.ScriptRegExp,
+script_regexp,ai,aj,
+ao,opt_groupId);
+};
+u.enableScriptBreakPoint=function(am){
+var ar=this.findScriptBreakPoint(am,false);
+ar.enable();
+};
+u.disableScriptBreakPoint=function(am){
+var ar=this.findScriptBreakPoint(am,false);
+ar.disable();
+};
+u.changeScriptBreakPointCondition=function(
+am,G){
+var ar=this.findScriptBreakPoint(am,false);
+ar.setCondition(G);
+};
+u.changeScriptBreakPointIgnoreCount=function(
+am,H){
+if(H<0)throw j(2,'Invalid argument');
+var ar=this.findScriptBreakPoint(am,false);
+ar.setIgnoreCount(H);
+};
+u.scriptBreakPoints=function(){
+return A;
+};
+u.clearStepping=function(){
+%ClearStepping();
+};
+u.setBreakOnException=function(){
+return %ChangeBreakOnException(u.ExceptionBreak.Caught,true);
+};
+u.clearBreakOnException=function(){
+return %ChangeBreakOnException(u.ExceptionBreak.Caught,false);
+};
+u.isBreakOnException=function(){
+return!!%IsBreakOnException(u.ExceptionBreak.Caught);
+};
+u.setBreakOnUncaughtException=function(){
+return %ChangeBreakOnException(u.ExceptionBreak.Uncaught,true);
+};
+u.clearBreakOnUncaughtException=function(){
+return %ChangeBreakOnException(u.ExceptionBreak.Uncaught,false);
+};
+u.isBreakOnUncaughtException=function(){
+return!!%IsBreakOnException(u.ExceptionBreak.Uncaught);
+};
+u.showBreakPoints=function(aa,as,at){
+if(!(%_IsFunction(aa)))throw j(32);
+var au=as?this.scriptSource(aa):this.source(aa);
+var av=as?this.sourcePosition(aa):0;
+var N=this.breakLocations(aa,at);
+if(!N)return au;
+N.sort(function(aw,ax){return aw-ax;});
+var X="";
+var ay=0;
+var az;
+for(var O=0;O<N.length;O++){
+az=N[O]-av;
+X+=au.slice(ay,az);
+X+="[B"+O+"]";
+ay=az;
+}
+az=au.length;
+X+=au.substring(ay,az);
+return X;
+};
+u.scripts=function(){
+return %DebugGetLoadedScripts();
+};
+u.debuggerFlags=function(){
+return B;
+};
+u.MakeMirror=l;
+function MakeExecutionState(K){
+return new ExecutionState(K);
+}
+function ExecutionState(K){
+this.break_id=K;
+this.selected_frame=0;
+}
+ExecutionState.prototype.prepareStep=function(aA){
+if(aA===u.StepAction.StepIn||
+aA===u.StepAction.StepOut||
+aA===u.StepAction.StepNext||
+aA===u.StepAction.StepFrame){
+return %PrepareStep(this.break_id,aA);
+}
+throw k(32);
+};
+ExecutionState.prototype.evaluateGlobal=function(au,disable_break,
+opt_additional_context){
+return l(%DebugEvaluateGlobal(this.break_id,au,
+(!!(disable_break)),
+opt_additional_context));
+};
+ExecutionState.prototype.frameCount=function(){
+return %GetFrameCount(this.break_id);
+};
+ExecutionState.prototype.threadCount=function(){
+return %GetThreadCount(this.break_id);
+};
+ExecutionState.prototype.frame=function(aB){
+if(aB==null)aB=this.selected_frame;
+if(aB<0||aB>=this.frameCount()){
+throw k(31);
+}
+return new c(this.break_id,aB);
+};
+ExecutionState.prototype.setSelectedFrame=function(aC){
+var O=(%_ToNumber(aC));
+if(O<0||O>=this.frameCount()){
+throw k(31);
+}
+this.selected_frame=O;
+};
+ExecutionState.prototype.selectedFrame=function(){
+return this.selected_frame;
+};
+ExecutionState.prototype.debugCommandProcessor=function(aD){
+return new DebugCommandProcessor(this,aD);
+};
+function MakeBreakEvent(K,aE){
+return new BreakEvent(K,aE);
+}
+function BreakEvent(K,aE){
+this.frame_=new c(K,0);
+this.break_points_hit_=aE;
+}
+BreakEvent.prototype.eventType=function(){
+return u.DebugEvent.Break;
+};
+BreakEvent.prototype.func=function(){
+return this.frame_.func();
+};
+BreakEvent.prototype.sourceLine=function(){
+return this.frame_.sourceLine();
+};
+BreakEvent.prototype.sourceColumn=function(){
+return this.frame_.sourceColumn();
+};
+BreakEvent.prototype.sourceLineText=function(){
+return this.frame_.sourceLineText();
+};
+BreakEvent.prototype.breakPointsHit=function(){
+return this.break_points_hit_;
+};
+BreakEvent.prototype.toJSONProtocol=function(){
+var aF={seq:x++,
+type:"event",
+event:"break",
+body:{invocationText:this.frame_.invocationText()}
+};
+var R=this.func().script();
+if(R){
+aF.body.sourceLine=this.sourceLine(),
+aF.body.sourceColumn=this.sourceColumn(),
+aF.body.sourceLineText=this.sourceLineText(),
+aF.body.script=MakeScriptObject_(R,false);
+}
+if(this.breakPointsHit()){
+aF.body.breakpoints=[];
+for(var O=0;O<this.breakPointsHit().length;O++){
+var aG=this.breakPointsHit()[O];
+var ar=aG.script_break_point();
+var aH;
+if(ar){
+aH=ar.number();
+}else{
+aH=aG.number();
+}
+aF.body.breakpoints.push(aH);
+}
+}
+return h(ObjectToProtocolObject_(aF));
+};
+function MakeExceptionEvent(K,aI,aJ,aK){
+return new ExceptionEvent(K,aI,aJ,aK);
+}
+function ExceptionEvent(K,aI,aJ,aK){
+this.exec_state_=new ExecutionState(K);
+this.exception_=aI;
+this.uncaught_=aJ;
+this.promise_=aK;
+}
+ExceptionEvent.prototype.eventType=function(){
+return u.DebugEvent.Exception;
+};
+ExceptionEvent.prototype.exception=function(){
+return this.exception_;
+};
+ExceptionEvent.prototype.uncaught=function(){
+return this.uncaught_;
+};
+ExceptionEvent.prototype.promise=function(){
+return this.promise_;
+};
+ExceptionEvent.prototype.func=function(){
+return this.exec_state_.frame(0).func();
+};
+ExceptionEvent.prototype.sourceLine=function(){
+return this.exec_state_.frame(0).sourceLine();
+};
+ExceptionEvent.prototype.sourceColumn=function(){
+return this.exec_state_.frame(0).sourceColumn();
+};
+ExceptionEvent.prototype.sourceLineText=function(){
+return this.exec_state_.frame(0).sourceLineText();
+};
+ExceptionEvent.prototype.toJSONProtocol=function(){
+var aF=new ProtocolMessage();
+aF.event="exception";
+aF.body={uncaught:this.uncaught_,
+exception:l(this.exception_)
+};
+if(this.exec_state_.frameCount()>0){
+aF.body.sourceLine=this.sourceLine();
+aF.body.sourceColumn=this.sourceColumn();
+aF.body.sourceLineText=this.sourceLineText();
+var R=this.func().script();
+if(R){
+aF.body.script=MakeScriptObject_(R,false);
+}
+}else{
+aF.body.sourceLine=-1;
+}
+return aF.toJSONProtocol();
+};
+function MakeCompileEvent(R,w){
+return new CompileEvent(R,w);
+}
+function CompileEvent(R,w){
+this.script_=l(R);
+this.type_=w;
+}
+CompileEvent.prototype.eventType=function(){
+return this.type_;
+};
+CompileEvent.prototype.script=function(){
+return this.script_;
+};
+CompileEvent.prototype.toJSONProtocol=function(){
+var aF=new ProtocolMessage();
+aF.running=true;
+switch(this.type_){
+case u.DebugEvent.BeforeCompile:
+aF.event="beforeCompile";
+break;
+case u.DebugEvent.AfterCompile:
+aF.event="afterCompile";
+break;
+case u.DebugEvent.CompileError:
+aF.event="compileError";
+break;
+}
+aF.body={};
+aF.body.script=this.script_;
+return aF.toJSONProtocol();
+};
+function MakeScriptObject_(R,aL){
+var aF={id:R.id(),
+name:R.name(),
+lineOffset:R.lineOffset(),
+columnOffset:R.columnOffset(),
+lineCount:R.lineCount(),
+};
+if(!(R.data()===(void 0))){
+aF.data=R.data();
+}
+if(aL){
+aF.source=R.source();
+}
+return aF;
+}
+function MakePromiseEvent(aM){
+return new PromiseEvent(aM);
+}
+function PromiseEvent(aM){
+this.promise_=aM.promise;
+this.parentPromise_=aM.parentPromise;
+this.status_=aM.status;
+this.value_=aM.value;
+}
+PromiseEvent.prototype.promise=function(){
+return l(this.promise_);
+}
+PromiseEvent.prototype.parentPromise=function(){
+return l(this.parentPromise_);
+}
+PromiseEvent.prototype.status=function(){
+return this.status_;
+}
+PromiseEvent.prototype.value=function(){
+return l(this.value_);
+}
+function MakeAsyncTaskEvent(aM){
+return new AsyncTaskEvent(aM);
+}
+function AsyncTaskEvent(aM){
+this.type_=aM.type;
+this.name_=aM.name;
+this.id_=aM.id;
+}
+AsyncTaskEvent.prototype.type=function(){
+return this.type_;
+}
+AsyncTaskEvent.prototype.name=function(){
+return this.name_;
+}
+AsyncTaskEvent.prototype.id=function(){
+return this.id_;
+}
+function DebugCommandProcessor(I,aD){
+this.exec_state_=I;
+this.running_=aD||false;
+}
+DebugCommandProcessor.prototype.processDebugRequest=function(aN){
+return this.processDebugJSONRequest(aN);
+};
+function ProtocolMessage(aN){
+this.seq=x++;
+if(aN){
+this.type='response';
+this.request_seq=aN.seq;
+this.command=aN.command;
+}else{
+this.type='event';
+}
+this.success=true;
+this.running=(void 0);
+}
+ProtocolMessage.prototype.setOption=function(aO,C){
+if(!this.options_){
+this.options_={};
+}
+this.options_[aO]=C;
+};
+ProtocolMessage.prototype.failed=function(aP,aQ){
+this.success=false;
+this.message=aP;
+if((typeof(aQ)==='object')){
+this.error_details=aQ;
+}
+};
+ProtocolMessage.prototype.toJSONProtocol=function(){
+var aR={};
+aR.seq=this.seq;
+if(this.request_seq){
+aR.request_seq=this.request_seq;
+}
+aR.type=this.type;
+if(this.event){
+aR.event=this.event;
+}
+if(this.command){
+aR.command=this.command;
+}
+if(this.success){
+aR.success=this.success;
+}else{
+aR.success=false;
+}
+if(this.body){
+var aS;
+var aT=m(true,this.options_);
+if(this.body instanceof o){
+aS=aT.serializeValue(this.body);
+}else if(this.body instanceof d){
+aS=[];
+for(var O=0;O<this.body.length;O++){
+if(this.body[O]instanceof o){
+aS.push(aT.serializeValue(this.body[O]));
+}else{
+aS.push(ObjectToProtocolObject_(this.body[O],aT));
+}
+}
+}else{
+aS=ObjectToProtocolObject_(this.body,aT);
+}
+aR.body=aS;
+aR.refs=aT.serializeReferencedObjects();
+}
+if(this.message){
+aR.message=this.message;
+}
+if(this.error_details){
+aR.error_details=this.error_details;
+}
+aR.running=this.running;
+return h(aR);
+};
+DebugCommandProcessor.prototype.createResponse=function(aN){
+return new ProtocolMessage(aN);
+};
+DebugCommandProcessor.prototype.processDebugJSONRequest=function(
+json_request){
+var aN;
+var aU;
+try{
+try{
+aN=g(json_request);
+aU=this.createResponse(aN);
+if(!aN.type){
+throw j(2,'Type not specified');
+}
+if(aN.type!='request'){
+throw j(2,
+"Illegal type '"+aN.type+"' in request");
+}
+if(!aN.command){
+throw j(2,'Command not specified');
+}
+if(aN.arguments){
+var aV=aN.arguments;
+if(aV.inlineRefs||aV.compactFormat){
+aU.setOption('inlineRefs',true);
+}
+if(!(aV.maxStringLength===(void 0))){
+aU.setOption('maxStringLength',aV.maxStringLength);
+}
+}
+var aW=aN.command.toLowerCase();
+var aX=DebugCommandProcessor.prototype.dispatch_[aW];
+if((%_IsFunction(aX))){
+%_Call(aX,this,aN,aU);
+}else{
+throw j(2,
+'Unknown command "'+aN.command+'" in request');
+}
+}catch(e){
+if(!aU){
+aU=this.createResponse();
+}
+aU.success=false;
+aU.message=(%_ToString(e));
+}
+try{
+if(!(aU.running===(void 0))){
+this.running_=aU.running;
+}
+aU.running=this.running_;
+return aU.toJSONProtocol();
+}catch(e){
+return'{"seq":'+aU.seq+','+
+'"request_seq":'+aN.seq+','+
+'"type":"response",'+
+'"success":false,'+
+'"message":"Internal error: '+(%_ToString(e))+'"}';
+}
+}catch(e){
+return'{"seq":0,"type":"response","success":false,"message":"Internal error"}';
+}
+};
+DebugCommandProcessor.prototype.continueRequest_=function(aN,aU){
+if(aN.arguments){
+var aA=u.StepAction.StepIn;
+var aY=aN.arguments.stepaction;
+if(aY){
+if(aY=='in'){
+aA=u.StepAction.StepIn;
+}else if(aY=='next'){
+aA=u.StepAction.StepNext;
+}else if(aY=='out'){
+aA=u.StepAction.StepOut;
+}else{
+throw j(2,
+'Invalid stepaction argument "'+aY+'".');
+}
+}
+this.exec_state_.prepareStep(aA);
+}
+aU.running=true;
+};
+DebugCommandProcessor.prototype.breakRequest_=function(aN,aU){
+};
+DebugCommandProcessor.prototype.setBreakPointRequest_=
+function(aN,aU){
+if(!aN.arguments){
+aU.failed('Missing arguments');
+return;
+}
+var w=aN.arguments.type;
+var aZ=aN.arguments.target;
+var P=aN.arguments.line;
+var Q=aN.arguments.column;
+var ba=(aN.arguments.enabled===(void 0))?
+true:aN.arguments.enabled;
+var G=aN.arguments.condition;
+var H=aN.arguments.ignoreCount;
+var bb=aN.arguments.groupId;
+if(!w||(aZ===(void 0))){
+aU.failed('Missing argument "type" or "target"');
+return;
+}
+var am;
+if(w=='function'){
+if(!(typeof(aZ)==='string')){
+aU.failed('Argument "target" is not a string value');
+return;
+}
+var aa;
+try{
+aa=this.exec_state_.evaluateGlobal(aZ).value();
+}catch(e){
+aU.failed('Error: "'+(%_ToString(e))+
+'" evaluating "'+aZ+'"');
+return;
+}
+if(!(%_IsFunction(aa))){
+aU.failed('"'+aZ+'" does not evaluate to a function');
+return;
+}
+am=u.setBreakPoint(aa,P,Q,G);
+}else if(w=='handle'){
+var bc=q(aZ,10);
+var J=i(bc);
+if(!J){
+return aU.failed('Object #'+bc+'# not found');
+}
+if(!J.isFunction()){
+return aU.failed('Object #'+bc+'# is not a function');
+}
+am=u.setBreakPoint(J.value(),
+P,Q,G);
+}else if(w=='script'){
+am=
+u.setScriptBreakPointByName(aZ,P,Q,G,
+bb);
+}else if(w=='scriptId'){
+am=
+u.setScriptBreakPointById(aZ,P,Q,G,bb);
+}else if(w=='scriptRegExp'){
+am=
+u.setScriptBreakPointByRegExp(aZ,P,Q,G,
+bb);
+}else{
+aU.failed('Illegal type "'+w+'"');
+return;
+}
+var F=u.findBreakPoint(am);
+if(H){
+u.changeBreakPointIgnoreCount(am,H);
+}
+if(!ba){
+u.disableBreakPoint(am);
+}
+aU.body={type:w,
+breakpoint:am};
+if(F instanceof ScriptBreakPoint){
+if(F.type()==u.ScriptBreakPointType.ScriptId){
+aU.body.type='scriptId';
+aU.body.script_id=F.script_id();
+}else if(F.type()==u.ScriptBreakPointType.ScriptName){
+aU.body.type='scriptName';
+aU.body.script_name=F.script_name();
+}else if(F.type()==u.ScriptBreakPointType.ScriptRegExp){
+aU.body.type='scriptRegExp';
+aU.body.script_regexp=F.script_regexp_object().source;
+}else{
+throw j(2,
+"Unexpected breakpoint type: "+F.type());
+}
+aU.body.line=F.line();
+aU.body.column=F.column();
+aU.body.actual_locations=F.actual_locations();
+}else{
+aU.body.type='function';
+aU.body.actual_locations=[F.actual_location];
+}
+};
+DebugCommandProcessor.prototype.changeBreakPointRequest_=function(
+aN,aU){
+if(!aN.arguments){
+aU.failed('Missing arguments');
+return;
+}
+var F=(%_ToNumber(aN.arguments.breakpoint));
+var ba=aN.arguments.enabled;
+var G=aN.arguments.condition;
+var H=aN.arguments.ignoreCount;
+if(!F){
+aU.failed('Missing argument "breakpoint"');
+return;
+}
+if(!(ba===(void 0))){
+if(ba){
+u.enableBreakPoint(F);
+}else{
+u.disableBreakPoint(F);
+}
+}
+if(!(G===(void 0))){
+u.changeBreakPointCondition(F,G);
+}
+if(!(H===(void 0))){
+u.changeBreakPointIgnoreCount(F,H);
+}
+};
+DebugCommandProcessor.prototype.clearBreakPointGroupRequest_=function(
+aN,aU){
+if(!aN.arguments){
+aU.failed('Missing arguments');
+return;
+}
+var bd=aN.arguments.groupId;
+if(!bd){
+aU.failed('Missing argument "groupId"');
+return;
+}
+var be=[];
+var bf=[];
+for(var O=0;O<A.length;O++){
+var bg=A[O];
+if(bg.groupId()==bd){
+be.push(bg.number());
+bg.clear();
+}else{
+bf.push(bg);
+}
+}
+A=bf;
+aU.body={breakpoints:be};
+};
+DebugCommandProcessor.prototype.clearBreakPointRequest_=function(
+aN,aU){
+if(!aN.arguments){
+aU.failed('Missing arguments');
+return;
+}
+var F=(%_ToNumber(aN.arguments.breakpoint));
+if(!F){
+aU.failed('Missing argument "breakpoint"');
+return;
+}
+u.clearBreakPoint(F);
+aU.body={breakpoint:F};
+};
+DebugCommandProcessor.prototype.listBreakpointsRequest_=function(
+aN,aU){
+var bh=[];
+for(var O=0;O<A.length;O++){
+var F=A[O];
+var bi={
+number:F.number(),
+line:F.line(),
+column:F.column(),
+groupId:F.groupId(),
+hit_count:F.hit_count(),
+active:F.active(),
+condition:F.condition(),
+ignoreCount:F.ignoreCount(),
+actual_locations:F.actual_locations()
+};
+if(F.type()==u.ScriptBreakPointType.ScriptId){
+bi.type='scriptId';
+bi.script_id=F.script_id();
+}else if(F.type()==u.ScriptBreakPointType.ScriptName){
+bi.type='scriptName';
+bi.script_name=F.script_name();
+}else if(F.type()==u.ScriptBreakPointType.ScriptRegExp){
+bi.type='scriptRegExp';
+bi.script_regexp=F.script_regexp_object().source;
+}else{
+throw j(2,
+"Unexpected breakpoint type: "+F.type());
+}
+bh.push(bi);
+}
+aU.body={
+breakpoints:bh,
+breakOnExceptions:u.isBreakOnException(),
+breakOnUncaughtExceptions:u.isBreakOnUncaughtException()
+};
+};
+DebugCommandProcessor.prototype.disconnectRequest_=
+function(aN,aU){
+u.disableAllBreakPoints();
+this.continueRequest_(aN,aU);
+};
+DebugCommandProcessor.prototype.setExceptionBreakRequest_=
+function(aN,aU){
+if(!aN.arguments){
+aU.failed('Missing arguments');
+return;
+}
+var w=aN.arguments.type;
+if(!w){
+aU.failed('Missing argument "type"');
+return;
+}
+var ba;
+if(w=='all'){
+ba=!u.isBreakOnException();
+}else if(w=='uncaught'){
+ba=!u.isBreakOnUncaughtException();
+}
+if(!(aN.arguments.enabled===(void 0))){
+ba=aN.arguments.enabled;
+if((ba!=true)&&(ba!=false)){
+aU.failed('Illegal value for "enabled":"'+ba+'"');
+}
+}
+if(w=='all'){
+%ChangeBreakOnException(u.ExceptionBreak.Caught,ba);
+}else if(w=='uncaught'){
+%ChangeBreakOnException(u.ExceptionBreak.Uncaught,ba);
+}else{
+aU.failed('Unknown "type":"'+w+'"');
+}
+aU.body={'type':w,'enabled':ba};
+};
+DebugCommandProcessor.prototype.backtraceRequest_=function(
+aN,aU){
+var bj=this.exec_state_.frameCount();
+if(bj==0){
+aU.body={
+totalFrames:bj
+};
+return;
+}
+var bk=0;
+var bl=t;
+if(aN.arguments){
+if(aN.arguments.fromFrame){
+bk=aN.arguments.fromFrame;
+}
+if(aN.arguments.toFrame){
+bl=aN.arguments.toFrame;
+}
+if(aN.arguments.bottom){
+var bm=bj-bk;
+bk=bj-bl;
+bl=bm;
+}
+if(bk<0||bl<0){
+return aU.failed('Invalid frame number');
+}
+}
+bl=n(bj,bl);
+if(bl<=bk){
+var bn='Invalid frame range';
+return aU.failed(bn);
+}
+var bo=[];
+for(var O=bk;O<bl;O++){
+bo.push(this.exec_state_.frame(O));
+}
+aU.body={
+fromFrame:bk,
+toFrame:bl,
+totalFrames:bj,
+frames:bo
+};
+};
+DebugCommandProcessor.prototype.frameRequest_=function(aN,aU){
+if(this.exec_state_.frameCount()==0){
+return aU.failed('No frames');
+}
+if(aN.arguments){
+var aC=aN.arguments.number;
+if(aC<0||this.exec_state_.frameCount()<=aC){
+return aU.failed('Invalid frame number');
+}
+this.exec_state_.setSelectedFrame(aN.arguments.number);
+}
+aU.body=this.exec_state_.frame();
+};
+DebugCommandProcessor.prototype.resolveFrameFromScopeDescription_=
+function(bp){
+if(bp&&!(bp.frameNumber===(void 0))){
+var bq=bp.frameNumber;
+if(bq<0||this.exec_state_.frameCount()<=bq){
+throw k(31);
+}
+return this.exec_state_.frame(bq);
+}else{
+return this.exec_state_.frame();
+}
+};
+DebugCommandProcessor.prototype.resolveScopeHolder_=
+function(bp){
+if(bp&&"functionHandle"in bp){
+if(!(typeof(bp.functionHandle)==='number')){
+throw j(2,'Function handle must be a number');
+}
+var br=i(bp.functionHandle);
+if(!br){
+throw j(2,'Failed to find function object by handle');
+}
+if(!br.isFunction()){
+throw j(2,
+'Value of non-function type is found by handle');
+}
+return br;
+}else{
+if(this.exec_state_.frameCount()==0){
+throw j(2,'No scopes');
+}
+var bs=this.resolveFrameFromScopeDescription_(bp);
+return bs;
+}
+}
+DebugCommandProcessor.prototype.scopesRequest_=function(aN,aU){
+var bt=this.resolveScopeHolder_(aN.arguments);
+var bu=bt.scopeCount();
+var bv=[];
+for(var O=0;O<bu;O++){
+bv.push(bt.scope(O));
+}
+aU.body={
+fromScope:0,
+toScope:bu,
+totalScopes:bu,
+scopes:bv
+};
+};
+DebugCommandProcessor.prototype.scopeRequest_=function(aN,aU){
+var bt=this.resolveScopeHolder_(aN.arguments);
+var bw=0;
+if(aN.arguments&&!(aN.arguments.number===(void 0))){
+bw=(%_ToNumber(aN.arguments.number));
+if(bw<0||bt.scopeCount()<=bw){
+return aU.failed('Invalid scope number');
+}
+}
+aU.body=bt.scope(bw);
+};
+DebugCommandProcessor.resolveValue_=function(bx){
+if("handle"in bx){
+var by=i(bx.handle);
+if(!by){
+throw j(2,"Failed to resolve value by handle, ' #"+
+bx.handle+"# not found");
+}
+return by.value();
+}else if("stringDescription"in bx){
+if(bx.type==p.BOOLEAN_TYPE){
+return(!!(bx.stringDescription));
+}else if(bx.type==p.NUMBER_TYPE){
+return(%_ToNumber(bx.stringDescription));
+}if(bx.type==p.STRING_TYPE){
+return(%_ToString(bx.stringDescription));
+}else{
+throw j(2,"Unknown type");
+}
+}else if("value"in bx){
+return bx.value;
+}else if(bx.type==p.UNDEFINED_TYPE){
+return(void 0);
+}else if(bx.type==p.NULL_TYPE){
+return null;
+}else{
+throw j(2,"Failed to parse value description");
+}
+};
+DebugCommandProcessor.prototype.setVariableValueRequest_=
+function(aN,aU){
+if(!aN.arguments){
+aU.failed('Missing arguments');
+return;
+}
+if((aN.arguments.name===(void 0))){
+aU.failed('Missing variable name');
+}
+var bz=aN.arguments.name;
+var bp=aN.arguments.scope;
+var bt=this.resolveScopeHolder_(bp);
+if((bp.number===(void 0))){
+aU.failed('Missing scope number');
+}
+var bw=(%_ToNumber(bp.number));
+var bA=bt.scope(bw);
+var bB=
+DebugCommandProcessor.resolveValue_(aN.arguments.newValue);
+bA.setVariableValue(bz,bB);
+var bC=l(bB);
+aU.body={
+newValue:bC
+};
+};
+DebugCommandProcessor.prototype.evaluateRequest_=function(aN,aU){
+if(!aN.arguments){
+return aU.failed('Missing arguments');
+}
+var bD=aN.arguments.expression;
+var bs=aN.arguments.frame;
+var a=aN.arguments.global;
+var bE=aN.arguments.disable_break;
+var bF=aN.arguments.additional_context;
+try{
+bD=(%_ToString(bD));
+}catch(e){
+return aU.failed('Failed to convert expression argument to string');
+}
+if(!(bs===(void 0))&&a){
+return aU.failed('Arguments "frame" and "global" are exclusive');
+}
+var bG;
+if(bF){
+bG={};
+for(var O=0;O<bF.length;O++){
+var bH=bF[O];
+if(!(typeof(bH.name)==='string')){
+return aU.failed("Context element #"+O+
+" doesn't contain name:string property");
+}
+var bI=DebugCommandProcessor.resolveValue_(bH);
+bG[bH.name]=bI;
+}
+}
+if(a){
+aU.body=this.exec_state_.evaluateGlobal(
+bD,(!!(bE)),bG);
+return;
+}
+if((bE===(void 0))){
+bE=true;
+}
+if(this.exec_state_.frameCount()==0){
+return aU.failed('No frames');
+}
+if(!(bs===(void 0))){
+var bJ=(%_ToNumber(bs));
+if(bJ<0||bJ>=this.exec_state_.frameCount()){
+return aU.failed('Invalid frame "'+bs+'"');
+}
+aU.body=this.exec_state_.frame(bJ).evaluate(
+bD,(!!(bE)),bG);
+return;
+}else{
+aU.body=this.exec_state_.frame().evaluate(
+bD,(!!(bE)),bG);
+return;
+}
+};
+DebugCommandProcessor.prototype.lookupRequest_=function(aN,aU){
+if(!aN.arguments){
+return aU.failed('Missing arguments');
+}
+var bK=aN.arguments.handles;
+if((bK===(void 0))){
+return aU.failed('Argument "handles" missing');
+}
+if(!(aN.arguments.includeSource===(void 0))){
+var bL=(!!(aN.arguments.includeSource));
+aU.setOption('includeSource',bL);
+}
+var bM={};
+for(var O=0;O<bK.length;O++){
+var bc=bK[O];
+var J=i(bc);
+if(!J){
+return aU.failed('Object #'+bc+'# not found');
+}
+bM[bc]=J;
+}
+aU.body=bM;
+};
+DebugCommandProcessor.prototype.referencesRequest_=
+function(aN,aU){
+if(!aN.arguments){
+return aU.failed('Missing arguments');
+}
+var w=aN.arguments.type;
+var bc=aN.arguments.handle;
+if((w===(void 0))){
+return aU.failed('Argument "type" missing');
+}
+if((bc===(void 0))){
+return aU.failed('Argument "handle" missing');
+}
+if(w!='referencedBy'&&w!='constructedBy'){
+return aU.failed('Invalid type "'+w+'"');
+}
+var J=i(bc);
+if(J){
+if(w=='referencedBy'){
+aU.body=J.referencedBy();
+}else{
+aU.body=J.constructedBy();
+}
+}else{
+return aU.failed('Object #'+bc+'# not found');
+}
+};
+DebugCommandProcessor.prototype.sourceRequest_=function(aN,aU){
+if(this.exec_state_.frameCount()==0){
+return aU.failed('No source');
+}
+var bN;
+var bO;
+var bs=this.exec_state_.frame();
+if(aN.arguments){
+bN=aN.arguments.fromLine;
+bO=aN.arguments.toLine;
+if(!(aN.arguments.frame===(void 0))){
+var bJ=(%_ToNumber(aN.arguments.frame));
+if(bJ<0||bJ>=this.exec_state_.frameCount()){
+return aU.failed('Invalid frame "'+bs+'"');
+}
+bs=this.exec_state_.frame(bJ);
+}
+}
+var R=bs.func().script();
+if(!R){
+return aU.failed('No source');
+}
+var bP=R.sourceSlice(bN,bO);
+if(!bP){
+return aU.failed('Invalid line interval');
+}
+aU.body={};
+aU.body.source=bP.sourceText();
+aU.body.fromLine=bP.from_line;
+aU.body.toLine=bP.to_line;
+aU.body.fromPosition=bP.from_position;
+aU.body.toPosition=bP.to_position;
+aU.body.totalLines=R.lineCount();
+};
+DebugCommandProcessor.prototype.scriptsRequest_=function(aN,aU){
+var bQ=ScriptTypeFlag(u.ScriptType.Normal);
+var bL=false;
+var bR=null;
+if(aN.arguments){
+if(!(aN.arguments.types===(void 0))){
+bQ=(%_ToNumber(aN.arguments.types));
+if(f(bQ)||bQ<0){
+return aU.failed('Invalid types "'+
+aN.arguments.types+'"');
+}
+}
+if(!(aN.arguments.includeSource===(void 0))){
+bL=(!!(aN.arguments.includeSource));
+aU.setOption('includeSource',bL);
+}
+if((%_IsArray(aN.arguments.ids))){
+bR={};
+var bS=aN.arguments.ids;
+for(var O=0;O<bS.length;O++){
+bR[bS[O]]=true;
+}
+}
+var bT=null;
+var bU=null;
+if(!(aN.arguments.filter===(void 0))){
+var bV=(%_ToNumber(aN.arguments.filter));
+if(!f(bV)){
+bU=bV;
+}
+bT=aN.arguments.filter;
+}
+}
+var ae=%DebugGetLoadedScripts();
+aU.body=[];
+for(var O=0;O<ae.length;O++){
+if(bR&&!bR[ae[O].id]){
+continue;
+}
+if(bT||bU){
+var R=ae[O];
+var bW=false;
+if(bU&&!bW){
+if(R.id&&R.id===bU){
+bW=true;
+}
+}
+if(bT&&!bW){
+if(R.name&&R.name.indexOf(bT)>=0){
+bW=true;
+}
+}
+if(!bW)continue;
+}
+if(bQ&ScriptTypeFlag(ae[O].type)){
+aU.body.push(l(ae[O]));
+}
+}
+};
+DebugCommandProcessor.prototype.threadsRequest_=function(aN,aU){
+var bX=this.exec_state_.threadCount();
+var bY=[];
+for(var O=0;O<bX;O++){
+var bZ=%GetThreadDetails(this.exec_state_.break_id,O);
+var ca={current:bZ[0],
+id:bZ[1]
+};
+bY.push(ca);
+}
+aU.body={
+totalThreads:bX,
+threads:bY
+};
+};
+DebugCommandProcessor.prototype.suspendRequest_=function(aN,aU){
+aU.running=false;
+};
+DebugCommandProcessor.prototype.versionRequest_=function(aN,aU){
+aU.body={
+V8Version:%GetV8Version()
+};
+};
+DebugCommandProcessor.prototype.changeLiveRequest_=function(
+aN,aU){
+if(!aN.arguments){
+return aU.failed('Missing arguments');
+}
+var cb=aN.arguments.script_id;
+var cc=!!aN.arguments.preview_only;
+var ae=%DebugGetLoadedScripts();
+var cd=null;
+for(var O=0;O<ae.length;O++){
+if(ae[O].id==cb){
+cd=ae[O];
+}
+}
+if(!cd){
+aU.failed('Script not found');
+return;
+}
+var ce=new d();
+if(!(typeof(aN.arguments.new_source)==='string')){
+throw"new_source argument expected";
+}
+var cf=aN.arguments.new_source;
+var cg;
+try{
+cg=u.LiveEdit.SetScriptSource(cd,
+cf,cc,ce);
+}catch(e){
+if(e instanceof u.LiveEdit.Failure&&"details"in e){
+aU.failed(e.message,e.details);
+return;
+}
+throw e;
+}
+aU.body={change_log:ce,result:cg};
+if(!cc&&!this.running_&&cg.stack_modified){
+aU.body.stepin_recommended=true;
+}
+};
+DebugCommandProcessor.prototype.restartFrameRequest_=function(
+aN,aU){
+if(!aN.arguments){
+return aU.failed('Missing arguments');
+}
+var bs=aN.arguments.frame;
+if(this.exec_state_.frameCount()==0){
+return aU.failed('No frames');
+}
+var ch;
+if(!(bs===(void 0))){
+var bJ=(%_ToNumber(bs));
+if(bJ<0||bJ>=this.exec_state_.frameCount()){
+return aU.failed('Invalid frame "'+bs+'"');
+}
+ch=this.exec_state_.frame(bJ);
+}else{
+ch=this.exec_state_.frame();
+}
+var cg=u.LiveEdit.RestartFrame(ch);
+aU.body={result:cg};
+};
+DebugCommandProcessor.prototype.debuggerFlagsRequest_=function(aN,
+aU){
+if(!aN.arguments){
+aU.failed('Missing arguments');
+return;
+}
+var ci=aN.arguments.flags;
+aU.body={flags:[]};
+if(!(ci===(void 0))){
+for(var O=0;O<ci.length;O++){
+var aO=ci[O].name;
+var cj=B[aO];
+if(!cj){
+continue;
+}
+if('value'in ci[O]){
+cj.setValue(ci[O].value);
+}
+aU.body.flags.push({name:aO,value:cj.getValue()});
+}
+}else{
+for(var aO in B){
+var C=B[aO].getValue();
+aU.body.flags.push({name:aO,value:C});
+}
+}
+};
+DebugCommandProcessor.prototype.v8FlagsRequest_=function(aN,aU){
+var ci=aN.arguments.flags;
+if(!ci)ci='';
+%SetFlags(ci);
+};
+DebugCommandProcessor.prototype.gcRequest_=function(aN,aU){
+var w=aN.arguments.type;
+if(!w)w='all';
+var ck=%GetHeapUsage();
+%CollectGarbage(w);
+var cl=%GetHeapUsage();
+aU.body={"before":ck,"after":cl};
+};
+DebugCommandProcessor.prototype.dispatch_=(function(){
+var cm=DebugCommandProcessor.prototype;
+return{
+"continue":cm.continueRequest_,
+"break":cm.breakRequest_,
+"setbreakpoint":cm.setBreakPointRequest_,
+"changebreakpoint":cm.changeBreakPointRequest_,
+"clearbreakpoint":cm.clearBreakPointRequest_,
+"clearbreakpointgroup":cm.clearBreakPointGroupRequest_,
+"disconnect":cm.disconnectRequest_,
+"setexceptionbreak":cm.setExceptionBreakRequest_,
+"listbreakpoints":cm.listBreakpointsRequest_,
+"backtrace":cm.backtraceRequest_,
+"frame":cm.frameRequest_,
+"scopes":cm.scopesRequest_,
+"scope":cm.scopeRequest_,
+"setvariablevalue":cm.setVariableValueRequest_,
+"evaluate":cm.evaluateRequest_,
+"lookup":cm.lookupRequest_,
+"references":cm.referencesRequest_,
+"source":cm.sourceRequest_,
+"scripts":cm.scriptsRequest_,
+"threads":cm.threadsRequest_,
+"suspend":cm.suspendRequest_,
+"version":cm.versionRequest_,
+"changelive":cm.changeLiveRequest_,
+"restartframe":cm.restartFrameRequest_,
+"flags":cm.debuggerFlagsRequest_,
+"v8flag":cm.v8FlagsRequest_,
+"gc":cm.gcRequest_,
+};
+})();
+DebugCommandProcessor.prototype.isRunning=function(){
+return this.running_;
+};
+DebugCommandProcessor.prototype.systemBreak=function(cn,aV){
+return %SystemBreak();
+};
+function ObjectToProtocolObject_(co,cp){
+var cq={};
+for(var aW in co){
+if(typeof aW=='string'){
+var cr=ValueToProtocolValue_(co[aW],
+cp);
+if(!(cr===(void 0))){
+cq[aW]=cr;
+}
+}
+}
+return cq;
+}
+function ArrayToProtocolArray_(bh,cp){
+var aR=[];
+for(var O=0;O<bh.length;O++){
+aR.push(ValueToProtocolValue_(bh[O],cp));
+}
+return aR;
+}
+function ValueToProtocolValue_(C,cp){
+var aR;
+switch(typeof C){
+case'object':
+if(C instanceof o){
+aR=cp.serializeValue(C);
+}else if((%_IsArray(C))){
+aR=ArrayToProtocolArray_(C,cp);
+}else{
+aR=ObjectToProtocolObject_(C,cp);
+}
+break;
+case'boolean':
+case'string':
+case'number':
+aR=C;
+break;
+default:
+aR=null;
+}
+return aR;
+}
+b.InstallConstants(a,[
+"Debug",u,
+"DebugCommandProcessor",DebugCommandProcessor,
+"BreakEvent",BreakEvent,
+"CompileEvent",CompileEvent,
+"BreakPoint",BreakPoint,
+]);
+b.InstallFunctions(b,2,[
+"MakeExecutionState",MakeExecutionState,
+"MakeExceptionEvent",MakeExceptionEvent,
+"MakeBreakEvent",MakeBreakEvent,
+"MakeCompileEvent",MakeCompileEvent,
+"MakePromiseEvent",MakePromiseEvent,
+"MakeAsyncTaskEvent",MakeAsyncTaskEvent,
+"IsBreakPointTriggered",IsBreakPointTriggered,
+"UpdateScriptBreakPoints",UpdateScriptBreakPoints,
+]);
+b.Export(function(cs){
+cs.GetScriptBreakPoints=GetScriptBreakPoints;
+});
+})
+
+ liveedit%�
+(function(a,b){
+"use strict";
+var c=a.Debug.findScriptSourcePosition;
+var d;
+var e=a.Array;
+var f=a.Math.floor;
+var g=a.SyntaxError;
+b.Import(function(h){
+d=h.GetScriptBreakPoints;
+});
+var i;
+function ApplyPatchMultiChunk(script,diff_array,new_source,preview_only,
+change_log){
+var j=script.source;
+var k=GatherCompileInfo(j,script);
+var l=BuildCodeInfoTree(k);
+var m=new PosTranslator(diff_array);
+MarkChangedFunctions(l,m.GetChunks());
+FindLiveSharedInfos(l,script);
+var n;
+try{
+n=GatherCompileInfo(new_source,script);
+}catch(e){
+var o=
+new Failure("Failed to compile new version of script: "+e);
+if(e instanceof g){
+var p={
+type:"liveedit_compile_error",
+syntaxErrorMessage:e.message
+};
+CopyErrorPositionToDetails(e,p);
+o.details=p;
+}
+throw o;
+}
+var q=BuildCodeInfoTree(n);
+FindCorrespondingFunctions(l,q);
+var r=new e();
+var s=new e();
+var t=new e();
+var u=new e();
+function HarvestTodo(v){
+function CollectDamaged(w){
+s.push(w);
+for(var x=0;x<w.children.length;x++){
+CollectDamaged(w.children[x]);
+}
+}
+function CollectNew(y){
+for(var x=0;x<y.length;x++){
+t.push(y[x]);
+CollectNew(y[x].children);
+}
+}
+if(v.status==i.DAMAGED){
+CollectDamaged(v);
+return;
+}
+if(v.status==i.UNCHANGED){
+u.push(v);
+}else if(v.status==i.SOURCE_CHANGED){
+u.push(v);
+}else if(v.status==i.CHANGED){
+r.push(v);
+CollectNew(v.unmatched_new_nodes);
+}
+for(var x=0;x<v.children.length;x++){
+HarvestTodo(v.children[x]);
+}
+}
+var z={
+change_tree:DescribeChangeTree(l),
+textual_diff:{
+old_len:j.length,
+new_len:new_source.length,
+chunks:diff_array
+},
+updated:false
+};
+if(preview_only){
+return z;
+}
+HarvestTodo(l);
+var A=new e();
+var B=new e();
+for(var x=0;x<r.length;x++){
+var C=r[x].live_shared_function_infos;
+var D=
+r[x].corresponding_node.info.shared_function_info;
+if(C){
+for(var E=0;E<C.length;E++){
+A.push(C[E]);
+B.push(D);
+}
+}
+}
+var F=
+CheckStackActivations(A,
+B,
+change_log);
+z.stack_modified=F!=0;
+var G=TemporaryRemoveBreakPoints(script,change_log);
+var H;
+if(s.length==0){
+%LiveEditReplaceScript(script,new_source,null);
+H=(void 0);
+}else{
+var I=CreateNameForOldScript(script);
+H=%LiveEditReplaceScript(script,new_source,
+I);
+var J=new e();
+change_log.push({linked_to_old_script:J});
+for(var x=0;x<s.length;x++){
+LinkToOldScript(s[x],H,
+J);
+}
+z.created_script_name=I;
+}
+for(var x=0;x<t.length;x++){
+%LiveEditFunctionSetScript(
+t[x].info.shared_function_info,script);
+}
+for(var x=0;x<r.length;x++){
+PatchFunctionCode(r[x],change_log);
+}
+var K=new e();
+change_log.push({position_patched:K});
+for(var x=0;x<u.length;x++){
+PatchPositions(u[x],diff_array,
+K);
+if(u[x].live_shared_function_infos){
+u[x].live_shared_function_infos.
+forEach(function(L){
+%LiveEditFunctionSourceUpdated(L.raw_array);
+});
+}
+}
+G(m,H);
+z.updated=true;
+return z;
+}
+function GatherCompileInfo(M,N){
+var O=%LiveEditGatherCompileInfo(N,M);
+var P=new e();
+var Q=new e();
+for(var x=0;x<O.length;x++){
+var L=new FunctionCompileInfo(O[x]);
+%LiveEditFunctionSetScript(L.shared_function_info,(void 0));
+P.push(L);
+Q.push(x);
+}
+for(var x=0;x<P.length;x++){
+var R=x;
+for(var E=x+1;E<P.length;E++){
+if(P[R].start_position>P[E].start_position){
+R=E;
+}
+}
+if(R!=x){
+var S=P[R];
+var T=Q[R];
+P[R]=P[x];
+Q[R]=Q[x];
+P[x]=S;
+Q[x]=T;
+}
+}
+var U=0;
+function ResetIndexes(V,W){
+var X=-1;
+while(U<P.length&&
+P[U].outer_index==W){
+var Y=U;
+P[Y].outer_index=V;
+if(X!=-1){
+P[X].next_sibling_index=Y;
+}
+X=Y;
+U++;
+ResetIndexes(Y,Q[Y]);
+}
+if(X!=-1){
+P[X].next_sibling_index=-1;
+}
+}
+ResetIndexes(-1,-1);
+Assert(U==P.length);
+return P;
+}
+function PatchFunctionCode(v,Z){
+var D=v.corresponding_node.info;
+if(v.live_shared_function_infos){
+v.live_shared_function_infos.forEach(function(aa){
+%LiveEditReplaceFunctionCode(D.raw_array,
+aa.raw_array);
+for(var x=0;x<v.children.length;x++){
+if(v.children[x].corresponding_node){
+var ab=
+v.children[x].corresponding_node.info.
+shared_function_info;
+if(v.children[x].live_shared_function_infos){
+v.children[x].live_shared_function_infos.
+forEach(function(ac){
+%LiveEditReplaceRefToNestedFunction(
+aa.info,
+ab,
+ac.info);
+});
+}
+}
+}
+});
+Z.push({function_patched:D.function_name});
+}else{
+Z.push({function_patched:D.function_name,
+function_info_not_found:true});
+}
+}
+function LinkToOldScript(ad,H,ae){
+if(ad.live_shared_function_infos){
+ad.live_shared_function_infos.
+forEach(function(L){
+%LiveEditFunctionSetScript(L.info,H);
+});
+ae.push({name:ad.info.function_name});
+}else{
+ae.push(
+{name:ad.info.function_name,not_found:true});
+}
+}
+function TemporaryRemoveBreakPoints(af,Z){
+var ag=d(af);
+var ah=[];
+Z.push({break_points_update:ah});
+var ai=[];
+for(var x=0;x<ag.length;x++){
+var aj=ag[x];
+aj.clear();
+var ak=c(af,
+aj.line(),aj.column());
+var al={
+position:ak,
+line:aj.line(),
+column:aj.column()
+};
+ai.push(al);
+}
+return function(m,am){
+for(var x=0;x<ag.length;x++){
+var aj=ag[x];
+if(am){
+var an=aj.cloneForOtherScript(am);
+an.set(am);
+ah.push({
+type:"copied_to_old",
+id:aj.number(),
+new_id:an.number(),
+positions:ai[x]
+});
+}
+var ao=m.Translate(
+ai[x].position,
+PosTranslator.ShiftWithTopInsideChunkHandler);
+var ap=
+af.locationFromPosition(ao,false);
+aj.update_positions(ap.line,ap.column);
+var aq={
+position:ao,
+line:ap.line,
+column:ap.column
+};
+aj.set(af);
+ah.push({type:"position_changed",
+id:aj.number(),
+old_positions:ai[x],
+new_positions:aq
+});
+}
+};
+}
+function Assert(ar,as){
+if(!ar){
+if(as){
+throw"Assert "+as;
+}else{
+throw"Assert";
+}
+}
+}
+function DiffChunk(at,au,av,aw){
+this.pos1=at;
+this.pos2=au;
+this.len1=av;
+this.len2=aw;
+}
+function PosTranslator(ax){
+var ay=new e();
+var az=0;
+for(var x=0;x<ax.length;x+=3){
+var aA=ax[x];
+var aB=aA+az;
+var aC=ax[x+1];
+var aD=ax[x+2];
+ay.push(new DiffChunk(aA,aB,aC-aA,
+aD-aB));
+az=aD-aC;
+}
+this.chunks=ay;
+}
+PosTranslator.prototype.GetChunks=function(){
+return this.chunks;
+};
+PosTranslator.prototype.Translate=function(aE,aF){
+var aG=this.chunks;
+if(aG.length==0||aE<aG[0].pos1){
+return aE;
+}
+var aH=0;
+var aI=aG.length-1;
+while(aH<aI){
+var aJ=f((aH+aI)/2);
+if(aE<aG[aJ+1].pos1){
+aI=aJ;
+}else{
+aH=aJ+1;
+}
+}
+var aK=aG[aH];
+if(aE>=aK.pos1+aK.len1){
+return aE+aK.pos2+aK.len2-aK.pos1-aK.len1;
+}
+if(!aF){
+aF=PosTranslator.DefaultInsideChunkHandler;
+}
+return aF(aE,aK);
+};
+PosTranslator.DefaultInsideChunkHandler=function(aE,aL){
+Assert(false,"Cannot translate position in changed area");
+};
+PosTranslator.ShiftWithTopInsideChunkHandler=
+function(aE,aL){
+return aE-aL.pos1+aL.pos2;
+};
+var i={
+UNCHANGED:"unchanged",
+SOURCE_CHANGED:"source changed",
+CHANGED:"changed",
+DAMAGED:"damaged"
+};
+function CodeInfoTreeNode(aM,aN,aO){
+this.info=aM;
+this.children=aN;
+this.array_index=aO;
+this.parent=(void 0);
+this.status=i.UNCHANGED;
+this.status_explanation=(void 0);
+this.new_start_pos=(void 0);
+this.new_end_pos=(void 0);
+this.corresponding_node=(void 0);
+this.unmatched_new_nodes=(void 0);
+this.textual_corresponding_node=(void 0);
+this.textually_unmatched_new_nodes=(void 0);
+this.live_shared_function_infos=(void 0);
+}
+function BuildCodeInfoTree(aP){
+var aQ=0;
+function BuildNode(){
+var aR=aQ;
+aQ++;
+var aS=new e();
+while(aQ<aP.length&&
+aP[aQ].outer_index==aR){
+aS.push(BuildNode());
+}
+var w=new CodeInfoTreeNode(aP[aR],aS,
+aR);
+for(var x=0;x<aS.length;x++){
+aS[x].parent=w;
+}
+return w;
+}
+var aT=BuildNode();
+Assert(aQ==aP.length);
+return aT;
+}
+function MarkChangedFunctions(aU,ay){
+var aV=new function(){
+var aW=0;
+var aX=0;
+this.current=function(){return ay[aW];};
+this.next=function(){
+var aK=ay[aW];
+aX=aK.pos2+aK.len2-(aK.pos1+aK.len1);
+aW++;
+};
+this.done=function(){return aW>=ay.length;};
+this.TranslatePos=function(aE){return aE+aX;};
+};
+function ProcessInternals(aY){
+aY.new_start_pos=aV.TranslatePos(
+aY.info.start_position);
+var aZ=0;
+var ba=false;
+var bb=false;
+while(!aV.done()&&
+aV.current().pos1<aY.info.end_position){
+if(aZ<aY.children.length){
+var bc=aY.children[aZ];
+if(bc.info.end_position<=aV.current().pos1){
+ProcessUnchangedChild(bc);
+aZ++;
+continue;
+}else if(bc.info.start_position>=
+aV.current().pos1+aV.current().len1){
+ba=true;
+aV.next();
+continue;
+}else if(bc.info.start_position<=aV.current().pos1&&
+bc.info.end_position>=aV.current().pos1+
+aV.current().len1){
+ProcessInternals(bc);
+bb=bb||
+(bc.status!=i.UNCHANGED);
+ba=ba||
+(bc.status==i.DAMAGED);
+aZ++;
+continue;
+}else{
+ba=true;
+bc.status=i.DAMAGED;
+bc.status_explanation=
+"Text diff overlaps with function boundary";
+aZ++;
+continue;
+}
+}else{
+if(aV.current().pos1+aV.current().len1<=
+aY.info.end_position){
+aY.status=i.CHANGED;
+aV.next();
+continue;
+}else{
+aY.status=i.DAMAGED;
+aY.status_explanation=
+"Text diff overlaps with function boundary";
+return;
+}
+}
+Assert("Unreachable",false);
+}
+while(aZ<aY.children.length){
+var bc=aY.children[aZ];
+ProcessUnchangedChild(bc);
+aZ++;
+}
+if(ba){
+aY.status=i.CHANGED;
+}else if(bb){
+aY.status=i.SOURCE_CHANGED;
+}
+aY.new_end_pos=
+aV.TranslatePos(aY.info.end_position);
+}
+function ProcessUnchangedChild(w){
+w.new_start_pos=aV.TranslatePos(w.info.start_position);
+w.new_end_pos=aV.TranslatePos(w.info.end_position);
+}
+ProcessInternals(aU);
+}
+function FindCorrespondingFunctions(bd,be){
+function ProcessNode(v,bf){
+var bg=
+IsFunctionContextLocalsChanged(v.info,bf.info);
+if(bg){
+v.status=i.CHANGED;
+}
+var bh=v.children;
+var bi=bf.children;
+var bj=[];
+var bk=[];
+var bl=0;
+var bm=0;
+while(bl<bh.length){
+if(bh[bl].status==i.DAMAGED){
+bl++;
+}else if(bm<bi.length){
+if(bi[bm].info.start_position<
+bh[bl].new_start_pos){
+bj.push(bi[bm]);
+bk.push(bi[bm]);
+bm++;
+}else if(bi[bm].info.start_position==
+bh[bl].new_start_pos){
+if(bi[bm].info.end_position==
+bh[bl].new_end_pos){
+bh[bl].corresponding_node=
+bi[bm];
+bh[bl].textual_corresponding_node=
+bi[bm];
+if(bg){
+bh[bl].status=i.DAMAGED;
+bh[bl].status_explanation=
+"Enclosing function is now incompatible. "+
+bg;
+bh[bl].corresponding_node=(void 0);
+}else if(bh[bl].status!=
+i.UNCHANGED){
+ProcessNode(bh[bl],
+bi[bm]);
+if(bh[bl].status==i.DAMAGED){
+bj.push(
+bh[bl].corresponding_node);
+bh[bl].corresponding_node=(void 0);
+v.status=i.CHANGED;
+}
+}
+}else{
+bh[bl].status=i.DAMAGED;
+bh[bl].status_explanation=
+"No corresponding function in new script found";
+v.status=i.CHANGED;
+bj.push(bi[bm]);
+bk.push(bi[bm]);
+}
+bm++;
+bl++;
+}else{
+bh[bl].status=i.DAMAGED;
+bh[bl].status_explanation=
+"No corresponding function in new script found";
+v.status=i.CHANGED;
+bl++;
+}
+}else{
+bh[bl].status=i.DAMAGED;
+bh[bl].status_explanation=
+"No corresponding function in new script found";
+v.status=i.CHANGED;
+bl++;
+}
+}
+while(bm<bi.length){
+bj.push(bi[bm]);
+bk.push(bi[bm]);
+bm++;
+}
+if(v.status==i.CHANGED){
+if(v.info.param_num!=bf.info.param_num){
+v.status=i.DAMAGED;
+v.status_explanation="Changed parameter number: "+
+v.info.param_num+" and "+bf.info.param_num;
+}
+}
+v.unmatched_new_nodes=bj;
+v.textually_unmatched_new_nodes=
+bk;
+}
+ProcessNode(bd,be);
+bd.corresponding_node=be;
+bd.textual_corresponding_node=be;
+Assert(bd.status!=i.DAMAGED,
+"Script became damaged");
+}
+function FindLiveSharedInfos(bd,N){
+var bn=%LiveEditFindSharedFunctionInfosForScript(N);
+var bo=new e();
+for(var x=0;x<bn.length;x++){
+bo.push(new SharedInfoWrapper(bn[x]));
+}
+function FindFunctionInfos(P){
+var bp=[];
+for(var x=0;x<bo.length;x++){
+var bq=bo[x];
+if(bq.start_position==P.start_position&&
+bq.end_position==P.end_position){
+bp.push(bq);
+}
+}
+if(bp.length>0){
+return bp;
+}
+}
+function TraverseTree(w){
+w.live_shared_function_infos=FindFunctionInfos(w.info);
+for(var x=0;x<w.children.length;x++){
+TraverseTree(w.children[x]);
+}
+}
+TraverseTree(bd);
+}
+function FunctionCompileInfo(br){
+this.function_name=br[0];
+this.start_position=br[1];
+this.end_position=br[2];
+this.param_num=br[3];
+this.code=br[4];
+this.code_scope_info=br[5];
+this.scope_info=br[6];
+this.outer_index=br[7];
+this.shared_function_info=br[8];
+this.next_sibling_index=null;
+this.raw_array=br;
+}
+function SharedInfoWrapper(br){
+this.function_name=br[0];
+this.start_position=br[1];
+this.end_position=br[2];
+this.info=br[3];
+this.raw_array=br;
+}
+function PatchPositions(ad,ax,ae){
+if(ad.live_shared_function_infos){
+ad.live_shared_function_infos.forEach(function(L){
+%LiveEditPatchFunctionPositions(L.raw_array,
+ax);
+});
+ae.push({name:ad.info.function_name});
+}else{
+ae.push(
+{name:ad.info.function_name,info_not_found:true});
+}
+}
+function CreateNameForOldScript(N){
+return N.name+" (old)";
+}
+function IsFunctionContextLocalsChanged(bs,bt){
+var bu=bs.scope_info;
+var bv=bt.scope_info;
+var bw;
+var bx;
+if(bu){
+bw=bu.toString();
+}else{
+bw="";
+}
+if(bv){
+bx=bv.toString();
+}else{
+bx="";
+}
+if(bw!=bx){
+return"Variable map changed: ["+bw+
+"] => ["+bx+"]";
+}
+return;
+}
+var by;
+function CheckStackActivations(old_shared_wrapper_list,
+new_shared_list,
+Z){
+var bz=new e();
+for(var x=0;x<old_shared_wrapper_list.length;x++){
+bz[x]=old_shared_wrapper_list[x].info;
+}
+var bA=%LiveEditCheckAndDropActivations(
+bz,new_shared_list,true);
+if(bA[old_shared_wrapper_list.length]){
+throw new Failure(bA[old_shared_wrapper_list.length]);
+}
+var bB=new e();
+var bC=new e();
+for(var x=0;x<bz.length;x++){
+var bD=old_shared_wrapper_list[x];
+if(bA[x]==by.REPLACED_ON_ACTIVE_STACK){
+bC.push({name:bD.function_name});
+}else if(bA[x]!=by.AVAILABLE_FOR_PATCH){
+var bE={
+name:bD.function_name,
+start_pos:bD.start_position,
+end_pos:bD.end_position,
+replace_problem:
+by.SymbolName(bA[x])
+};
+bB.push(bE);
+}
+}
+if(bC.length>0){
+Z.push({dropped_from_stack:bC});
+}
+if(bB.length>0){
+Z.push({functions_on_stack:bB});
+throw new Failure("Blocked by functions on stack");
+}
+return bC.length;
+}
+var by={
+AVAILABLE_FOR_PATCH:1,
+BLOCKED_ON_ACTIVE_STACK:2,
+BLOCKED_ON_OTHER_STACK:3,
+BLOCKED_UNDER_NATIVE_CODE:4,
+REPLACED_ON_ACTIVE_STACK:5,
+BLOCKED_UNDER_GENERATOR:6,
+BLOCKED_ACTIVE_GENERATOR:7,
+BLOCKED_NO_NEW_TARGET_ON_RESTART:8
+};
+by.SymbolName=function(bF){
+var bG=by;
+for(var bH in bG){
+if(bG[bH]==bF){
+return bH;
+}
+}
+};
+function Failure(as){
+this.message=as;
+}
+Failure.prototype.toString=function(){
+return"LiveEdit Failure: "+this.message;
+};
+function CopyErrorPositionToDetails(bI,p){
+function createPositionStruct(N,bJ){
+if(bJ==-1)return;
+var bK=N.locationFromPosition(bJ,true);
+if(bK==null)return;
+return{
+line:bK.line+1,
+column:bK.column+1,
+position:bJ
+};
+}
+if(!("scriptObject"in bI)||!("startPosition"in bI)){
+return;
+}
+var N=bI.scriptObject;
+var bL={
+start:createPositionStruct(N,bI.startPosition),
+end:createPositionStruct(N,bI.endPosition)
+};
+p.position=bL;
+}
+function GetPcFromSourcePos(bM,bN){
+return %GetFunctionCodePositionFromSource(bM,bN);
+}
+function SetScriptSource(N,bO,bP,Z){
+var j=N.source;
+var bQ=CompareStrings(j,bO);
+return ApplyPatchMultiChunk(N,bQ,bO,bP,
+Z);
+}
+function CompareStrings(bR,bS){
+return %LiveEditCompareStrings(bR,bS);
+}
+function ApplySingleChunkPatch(N,change_pos,change_len,new_str,
+Z){
+var j=N.source;
+var bO=j.substring(0,change_pos)+
+new_str+j.substring(change_pos+change_len);
+return ApplyPatchMultiChunk(N,
+[change_pos,change_pos+change_len,change_pos+new_str.length],
+bO,false,Z);
+}
+function DescribeChangeTree(bd){
+function ProcessOldNode(w){
+var bT=[];
+for(var x=0;x<w.children.length;x++){
+var bc=w.children[x];
+if(bc.status!=i.UNCHANGED){
+bT.push(ProcessOldNode(bc));
+}
+}
+var bU=[];
+if(w.textually_unmatched_new_nodes){
+for(var x=0;x<w.textually_unmatched_new_nodes.length;x++){
+var bc=w.textually_unmatched_new_nodes[x];
+bU.push(ProcessNewNode(bc));
+}
+}
+var bV={
+name:w.info.function_name,
+positions:DescribePositions(w),
+status:w.status,
+children:bT,
+new_children:bU
+};
+if(w.status_explanation){
+bV.status_explanation=w.status_explanation;
+}
+if(w.textual_corresponding_node){
+bV.new_positions=DescribePositions(w.textual_corresponding_node);
+}
+return bV;
+}
+function ProcessNewNode(w){
+var bT=[];
+if(false){
+for(var x=0;x<w.children.length;x++){
+bT.push(ProcessNewNode(w.children[x]));
+}
+}
+var bV={
+name:w.info.function_name,
+positions:DescribePositions(w),
+children:bT,
+};
+return bV;
+}
+function DescribePositions(w){
+return{
+start_position:w.info.start_position,
+end_position:w.info.end_position
+};
+}
+return ProcessOldNode(bd);
+}
+var bW={};
+bW.SetScriptSource=SetScriptSource;
+bW.ApplyPatchMultiChunk=ApplyPatchMultiChunk;
+bW.Failure=Failure;
+bW.GetPcFromSourcePos=GetPcFromSourcePos;
+bW.TestApi={
+PosTranslator:PosTranslator,
+CompareStrings:CompareStrings,
+ApplySingleChunkPatch:ApplySingleChunkPatch
+};
+a.Debug.LiveEdit=bW;
+})
+
+h prologueK
+(function(a,b,c){
+"use strict";
+%CheckIsBootstrapping();
+var d=(void 0);
+var e=(void 0);
+var f=%ExportFromRuntime({});
+var g=(void 0);
+function SetupTypedArray(h){
+h.next=g;
+g=h;
+}
+function Export(h){
+h(f);
+}
+function Import(h){
+h.next=d;
+d=h;
+}
+function ImportNow(i){
+return f[i];
+}
+function ImportFromExperimental(h){
+h.next=e;
+e=h;
+}
+function SetFunctionName(h,i,j){
+if((typeof(i)==='symbol')){
+i="["+%SymbolDescription(i)+"]";
+}
+if((j===(void 0))){
+%FunctionSetName(h,i);
+}else{
+%FunctionSetName(h,j+" "+i);
+}
+}
+function InstallConstants(k,l){
+%CheckIsBootstrapping();
+%OptimizeObjectForAddingMultipleProperties(k,l.length>>1);
+var m=2|4|1;
+for(var n=0;n<l.length;n+=2){
+var i=l[n];
+var o=l[n+1];
+%AddNamedProperty(k,i,o,m);
+}
+%ToFastProperties(k);
+}
+function InstallFunctions(k,m,p){
+%CheckIsBootstrapping();
+%OptimizeObjectForAddingMultipleProperties(k,p.length>>1);
+for(var n=0;n<p.length;n+=2){
+var q=p[n];
+var h=p[n+1];
+SetFunctionName(h,q);
+%FunctionRemovePrototype(h);
+%AddNamedProperty(k,q,h,m);
+%SetNativeFlag(h);
+}
+%ToFastProperties(k);
+}
+function InstallGetter(k,i,r,m,j){
+%CheckIsBootstrapping();
+if((m===(void 0)))m=2;
+SetFunctionName(r,i,(j===(void 0))?"get":j);
+%FunctionRemovePrototype(r);
+%DefineGetterPropertyUnchecked(k,i,r,m);
+%SetNativeFlag(r);
+}
+function InstallGetterSetter(k,i,r,s,m){
+%CheckIsBootstrapping();
+if((m===(void 0)))m=2;
+SetFunctionName(r,i,"get");
+SetFunctionName(s,i,"set");
+%FunctionRemovePrototype(r);
+%FunctionRemovePrototype(s);
+%DefineAccessorPropertyUnchecked(k,i,r,s,2);
+%SetNativeFlag(r);
+%SetNativeFlag(s);
+}
+function SetUpLockedPrototype(
+constructor,fields,methods){
+%CheckIsBootstrapping();
+var t=constructor.prototype;
+var u=(methods.length>>1)+(fields?fields.length:0);
+if(u>=4){
+%OptimizeObjectForAddingMultipleProperties(t,u);
+}
+if(fields){
+for(var n=0;n<fields.length;n++){
+%AddNamedProperty(t,fields[n],
+(void 0),2|4);
+}
+}
+for(var n=0;n<methods.length;n+=2){
+var q=methods[n];
+var h=methods[n+1];
+%AddNamedProperty(t,q,h,2|4|1);
+%SetNativeFlag(h);
+}
+%InternalSetPrototype(t,null);
+%ToFastProperties(t);
+}
+function PostNatives(b){
+%CheckIsBootstrapping();
+for(;!(d===(void 0));d=d.next){
+d(f);
+}
+var v=[
+"ArrayToString",
+"ErrorToString",
+"GetIterator",
+"GetMethod",
+"IsNaN",
+"MakeError",
+"MakeTypeError",
+"MapEntries",
+"MapIterator",
+"MapIteratorNext",
+"MathMax",
+"MathMin",
+"MaxSimple",
+"MinSimple",
+"ObjectDefineProperty",
+"ObserveArrayMethods",
+"ObserveObjectMethods",
+"PromiseChain",
+"PromiseDeferred",
+"PromiseResolved",
+"SameValueZero",
+"SetIterator",
+"SetIteratorNext",
+"SetValues",
+"SymbolToString",
+"ToPositiveInteger",
+"is_concat_spreadable_symbol",
+"iterator_symbol",
+"promise_status_symbol",
+"promise_value_symbol",
+"object_freeze",
+"object_is_frozen",
+"object_is_sealed",
+"reflect_apply",
+"reflect_construct",
+"regexp_flags_symbol",
+"to_string_tag_symbol",
+"object_to_string",
+"species_symbol",
+];
+var w={};
+%OptimizeObjectForAddingMultipleProperties(
+w,v.length);
+for(var q of v){
+w[q]=f[q];
+}
+%ToFastProperties(w);
+f=w;
+b.PostNatives=(void 0);
+b.ImportFromExperimental=(void 0);
+}
+function PostExperimentals(b){
+%CheckIsBootstrapping();
+%ExportExperimentalFromRuntime(f);
+for(;!(d===(void 0));d=d.next){
+d(f);
+}
+for(;!(e===(void 0));
+e=e.next){
+e(f);
+}
+b.CreateDoubleResultArray();
+b.CreateDoubleResultArray=(void 0);
+b.Export=(void 0);
+b.PostDebug=(void 0);
+b.PostExperimentals=(void 0);
+g=(void 0);
+}
+function PostDebug(b){
+for(;!(d===(void 0));d=d.next){
+d(f);
+}
+b.CreateDoubleResultArray();
+b.CreateDoubleResultArray=(void 0);
+f=(void 0);
+b.Export=(void 0);
+b.Import=(void 0);
+b.ImportNow=(void 0);
+b.PostDebug=(void 0);
+b.PostExperimentals=(void 0);
+g=(void 0);
+}
+function InitializeBuiltinTypedArrays(b,x,y){
+var z=g;
+for(;!(z===(void 0));z=z.next){
+z(x,y);
+}
+}
+%OptimizeObjectForAddingMultipleProperties(b,14);
+b.Import=Import;
+b.ImportNow=ImportNow;
+b.Export=Export;
+b.ImportFromExperimental=ImportFromExperimental;
+b.SetFunctionName=SetFunctionName;
+b.InstallConstants=InstallConstants;
+b.InstallFunctions=InstallFunctions;
+b.InstallGetter=InstallGetter;
+b.InstallGetterSetter=InstallGetterSetter;
+b.SetUpLockedPrototype=SetUpLockedPrototype;
+b.PostNatives=PostNatives;
+b.PostExperimentals=PostExperimentals;
+b.PostDebug=PostDebug;
+%ToFastProperties(b);
+%OptimizeObjectForAddingMultipleProperties(c,5);
+c.logStackTrace=function logStackTrace(){
+%DebugTrace();
+};
+c.log=function log(){
+let message='';
+for(const arg of arguments){
+message+=arg;
+}
+%GlobalPrint(message);
+};
+c.createPrivateSymbol=function createPrivateSymbol(i){
+return %CreatePrivateSymbol(i);
+};
+c.simpleBind=function simpleBind(A,B){
+return function(){
+return %Apply(A,B,arguments,0,arguments.length);
+};
+};
+c.uncurryThis=function uncurryThis(A){
+return function(B){
+return %Apply(A,B,arguments,1,arguments.length-1);
+};
+};
+%ToFastProperties(c);
+})
+
+runtime9"
+(function(a,b){
+%CheckIsBootstrapping();
+var c;
+var d=a.Array;
+var e=a.Boolean;
+var f=a.String;
+var g;
+var h;
+var i;
+b.Import(function(j){
+g=j.MakeRangeError;
+h=j.MakeTypeError;
+i=j.species_symbol;
+});
+b.ImportFromExperimental(function(j){
+c=j.FLAG_harmony_species;
+});
+function CONCAT_ITERABLE_TO_ARRAY(k){
+return %concat_iterable_to_array(this,k);
+};
+function SameValue(l,m){
+if(typeof l!=typeof m)return false;
+if((typeof(l)==='number')){
+if((!%_IsSmi(%IS_VAR(l))&&!(l==l))&&(!%_IsSmi(%IS_VAR(m))&&!(m==m)))return true;
+if(l===0&&m===0&&%_IsMinusZero(l)!=%_IsMinusZero(m)){
+return false;
+}
+}
+if((%_IsSimdValue(l)))return %SimdSameValue(l,m);
+return l===m;
+}
+function SameValueZero(l,m){
+if(typeof l!=typeof m)return false;
+if((typeof(l)==='number')){
+if((!%_IsSmi(%IS_VAR(l))&&!(l==l))&&(!%_IsSmi(%IS_VAR(m))&&!(m==m)))return true;
+}
+if((%_IsSimdValue(l)))return %SimdSameValueZero(l,m);
+return l===m;
+}
+function ConcatIterableToArray(n,k){
+var o=n.length;
+for(var p of k){
+AddIndexedProperty(n,o++,p);
+}
+return n;
+}
+function AddIndexedProperty(q,o,r){
+if(o===((o)>>>0)&&o!==4294967295){
+%AddElement(q,o,r);
+}else{
+%AddNamedProperty(q,(%_ToString(o)),r,0);
+}
+}
+%SetForceInlineFlag(AddIndexedProperty);
+function ToPositiveInteger(l,s){
+var t=(%_IsSmi(%IS_VAR(l))?l:%NumberToIntegerMapMinusZero(l));
+if(t<0)throw g(s);
+return t;
+}
+function MaxSimple(u,v){
+return u>v?u:v;
+}
+function MinSimple(u,v){
+return u>v?v:u;
+}
+%SetForceInlineFlag(MaxSimple);
+%SetForceInlineFlag(MinSimple);
+function SpeciesConstructor(w,x,y){
+if(c){
+var z=w.constructor;
+if((z===(void 0))){
+return x;
+}
+if(!(%_IsJSReceiver(z))){
+throw h(27);
+}
+var A=z[i];
+if((A==null)){
+return x;
+}
+if(%IsConstructor(A)){
+return A;
+}
+throw h(235);
+}else{
+return y?x:w.constructor;
+}
+}
+%FunctionSetPrototype(d,new d(0));
+b.Export(function(B){
+B.AddIndexedProperty=AddIndexedProperty;
+B.MaxSimple=MaxSimple;
+B.MinSimple=MinSimple;
+B.SameValue=SameValue;
+B.SameValueZero=SameValueZero;
+B.ToPositiveInteger=ToPositiveInteger;
+B.SpeciesConstructor=SpeciesConstructor;
+});
+%InstallToContext([
+"concat_iterable_to_array_builtin",CONCAT_ITERABLE_TO_ARRAY,
+]);
+%InstallToContext([
+"concat_iterable_to_array",ConcatIterableToArray,
+]);
+})
+
+$v8natives�#

+(function(a,b){
+%CheckIsBootstrapping();
+var c=a.Array;
+var d=a.Boolean;
+var e=a.Number;
+var f=a.Object;
+var g=b.InternalArray;
+var h=b.ImportNow("iterator_symbol");
+var i;
+var j;
+var k;
+var l;
+var m=%GetRootNaN();
+var n=b.ImportNow("object_to_string");
+var o;
+var p;
+var q;
+var r=b.ImportNow("SameValue");
+var s=b.ImportNow("to_string_tag_symbol");
+b.Import(function(t){
+i=t.MakeRangeError;
+j=t.MakeSyntaxError;
+k=t.MakeTypeError;
+l=t.MathAbs;
+o=t.ObserveBeginPerformSplice;
+p=t.ObserveEndPerformSplice;
+q=t.ObserveEnqueueSpliceRecord;
+});
+function GlobalIsNaN(u){
+u=(%_ToNumber(u));
+return(!%_IsSmi(%IS_VAR(u))&&!(u==u));
+}
+function GlobalIsFinite(u){
+u=(%_ToNumber(u));
+return(%_IsSmi(%IS_VAR(u))||((u==u)&&(u!=1/0)&&(u!=-1/0)));
+}
+function GlobalParseInt(v,w){
+if((w===(void 0))||w===10||w===0){
+if(%_IsSmi(v))return v;
+if((typeof(v)==='number')&&
+((0.01<v&&v<1e9)||
+(-1e9<v&&v<-0.01))){
+return v|0;
+}
+v=(%_ToString(v));
+w=w|0;
+}else{
+v=(%_ToString(v));
+w=((w)|0);
+if(!(w==0||(2<=w&&w<=36))){
+return m;
+}
+}
+if(%_HasCachedArrayIndex(v)&&
+(w==0||w==10)){
+return %_GetCachedArrayIndex(v);
+}
+return %StringParseInt(v,w);
+}
+function GlobalParseFloat(v){
+v=(%_ToString(v));
+if(%_HasCachedArrayIndex(v))return %_GetCachedArrayIndex(v);
+return %StringParseFloat(v);
+}
+var x=2|4|1;
+b.InstallConstants(a,[
+"Infinity",(1/0),
+"NaN",m,
+"undefined",(void 0),
+]);
+b.InstallFunctions(a,2,[
+"isNaN",GlobalIsNaN,
+"isFinite",GlobalIsFinite,
+"parseInt",GlobalParseInt,
+"parseFloat",GlobalParseFloat,
+]);
+function ObjectToLocaleString(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(17,"Object.prototype.toLocaleString");
+return this.toString();
+}
+function ObjectValueOf(){
+return(%_ToObject(this));
+}
+function ObjectHasOwnProperty(y){
+var z=(%_ToName(y));
+var A=(%_ToObject(this));
+return %HasOwnProperty(A,z);
+}
+function ObjectIsPrototypeOf(B){
+if(!(%_IsJSReceiver(B)))return false;
+var C=(%_ToObject(this));
+return %HasInPrototypeChain(B,C);
+}
+function ObjectPropertyIsEnumerable(B){
+var D=(%_ToName(B));
+return %PropertyIsEnumerable((%_ToObject(this)),D);
+}
+function ObjectDefineGetter(z,E){
+var F=this;
+if((F===null)||(F===(void 0))){
+F=%GlobalProxy(ObjectDefineGetter);
+}
+if(!(typeof(E)==='function')){
+throw k(72);
+}
+var G=new PropertyDescriptor();
+G.setGet(E);
+G.setEnumerable(true);
+G.setConfigurable(true);
+DefineOwnProperty((%_ToObject(F)),(%_ToName(z)),G,false);
+}
+function ObjectLookupGetter(z){
+var F=this;
+if((F===null)||(F===(void 0))){
+F=%GlobalProxy(ObjectLookupGetter);
+}
+return %LookupAccessor((%_ToObject(F)),(%_ToName(z)),0);
+}
+function ObjectDefineSetter(z,E){
+var F=this;
+if((F===null)||(F===(void 0))){
+F=%GlobalProxy(ObjectDefineSetter);
+}
+if(!(typeof(E)==='function')){
+throw k(75);
+}
+var G=new PropertyDescriptor();
+G.setSet(E);
+G.setEnumerable(true);
+G.setConfigurable(true);
+DefineOwnProperty((%_ToObject(F)),(%_ToName(z)),G,false);
+}
+function ObjectLookupSetter(z){
+var F=this;
+if((F===null)||(F===(void 0))){
+F=%GlobalProxy(ObjectLookupSetter);
+}
+return %LookupAccessor((%_ToObject(F)),(%_ToName(z)),1);
+}
+function IsAccessorDescriptor(G){
+if((G===(void 0)))return false;
+return G.hasGetter()||G.hasSetter();
+}
+function IsDataDescriptor(G){
+if((G===(void 0)))return false;
+return G.hasValue()||G.hasWritable();
+}
+function IsGenericDescriptor(G){
+if((G===(void 0)))return false;
+return!(IsAccessorDescriptor(G)||IsDataDescriptor(G));
+}
+function IsInconsistentDescriptor(G){
+return IsAccessorDescriptor(G)&&IsDataDescriptor(G);
+}
+function FromGenericPropertyDescriptor(G){
+if((G===(void 0)))return G;
+var H=new f();
+if(G.hasValue()){
+%AddNamedProperty(H,"value",G.getValue(),0);
+}
+if(G.hasWritable()){
+%AddNamedProperty(H,"writable",G.isWritable(),0);
+}
+if(G.hasGetter()){
+%AddNamedProperty(H,"get",G.getGet(),0);
+}
+if(G.hasSetter()){
+%AddNamedProperty(H,"set",G.getSet(),0);
+}
+if(G.hasEnumerable()){
+%AddNamedProperty(H,"enumerable",G.isEnumerable(),0);
+}
+if(G.hasConfigurable()){
+%AddNamedProperty(H,"configurable",G.isConfigurable(),0);
+}
+return H;
+}
+function ToPropertyDescriptor(H){
+if(!(%_IsJSReceiver(H)))throw k(90,H);
+var G=new PropertyDescriptor();
+if("enumerable"in H){
+G.setEnumerable((!!(H.enumerable)));
+}
+if("configurable"in H){
+G.setConfigurable((!!(H.configurable)));
+}
+if("value"in H){
+G.setValue(H.value);
+}
+if("writable"in H){
+G.setWritable((!!(H.writable)));
+}
+if("get"in H){
+var I=H.get;
+if(!(I===(void 0))&&!(typeof(I)==='function')){
+throw k(73,I);
+}
+G.setGet(I);
+}
+if("set"in H){
+var J=H.set;
+if(!(J===(void 0))&&!(typeof(J)==='function')){
+throw k(76,J);
+}
+G.setSet(J);
+}
+if(IsInconsistentDescriptor(G)){
+throw k(153,H);
+}
+return G;
+}
+function ToCompletePropertyDescriptor(H){
+var G=ToPropertyDescriptor(H);
+if(IsGenericDescriptor(G)||IsDataDescriptor(G)){
+if(!G.hasValue())G.setValue((void 0));
+if(!G.hasWritable())G.setWritable(false);
+}else{
+if(!G.hasGetter())G.setGet((void 0));
+if(!G.hasSetter())G.setSet((void 0));
+}
+if(!G.hasEnumerable())G.setEnumerable(false);
+if(!G.hasConfigurable())G.setConfigurable(false);
+return G;
+}
+function PropertyDescriptor(){
+this.value_=(void 0);
+this.hasValue_=false;
+this.writable_=false;
+this.hasWritable_=false;
+this.enumerable_=false;
+this.hasEnumerable_=false;
+this.configurable_=false;
+this.hasConfigurable_=false;
+this.get_=(void 0);
+this.hasGetter_=false;
+this.set_=(void 0);
+this.hasSetter_=false;
+}
+b.SetUpLockedPrototype(PropertyDescriptor,[
+"value_",
+"hasValue_",
+"writable_",
+"hasWritable_",
+"enumerable_",
+"hasEnumerable_",
+"configurable_",
+"hasConfigurable_",
+"get_",
+"hasGetter_",
+"set_",
+"hasSetter_"
+],[
+"toString",function PropertyDescriptor_ToString(){
+return"[object PropertyDescriptor]";
+},
+"setValue",function PropertyDescriptor_SetValue(y){
+this.value_=y;
+this.hasValue_=true;
+},
+"getValue",function PropertyDescriptor_GetValue(){
+return this.value_;
+},
+"hasValue",function PropertyDescriptor_HasValue(){
+return this.hasValue_;
+},
+"setEnumerable",function PropertyDescriptor_SetEnumerable(K){
+this.enumerable_=K;
+this.hasEnumerable_=true;
+},
+"isEnumerable",function PropertyDescriptor_IsEnumerable(){
+return this.enumerable_;
+},
+"hasEnumerable",function PropertyDescriptor_HasEnumerable(){
+return this.hasEnumerable_;
+},
+"setWritable",function PropertyDescriptor_SetWritable(L){
+this.writable_=L;
+this.hasWritable_=true;
+},
+"isWritable",function PropertyDescriptor_IsWritable(){
+return this.writable_;
+},
+"hasWritable",function PropertyDescriptor_HasWritable(){
+return this.hasWritable_;
+},
+"setConfigurable",
+function PropertyDescriptor_SetConfigurable(M){
+this.configurable_=M;
+this.hasConfigurable_=true;
+},
+"hasConfigurable",function PropertyDescriptor_HasConfigurable(){
+return this.hasConfigurable_;
+},
+"isConfigurable",function PropertyDescriptor_IsConfigurable(){
+return this.configurable_;
+},
+"setGet",function PropertyDescriptor_SetGetter(I){
+this.get_=I;
+this.hasGetter_=true;
+},
+"getGet",function PropertyDescriptor_GetGetter(){
+return this.get_;
+},
+"hasGetter",function PropertyDescriptor_HasGetter(){
+return this.hasGetter_;
+},
+"setSet",function PropertyDescriptor_SetSetter(J){
+this.set_=J;
+this.hasSetter_=true;
+},
+"getSet",function PropertyDescriptor_GetSetter(){
+return this.set_;
+},
+"hasSetter",function PropertyDescriptor_HasSetter(){
+return this.hasSetter_;
+}
+]);
+function ConvertDescriptorArrayToDescriptor(N){
+if((N===(void 0))){
+return(void 0);
+}
+var G=new PropertyDescriptor();
+if(N[0]){
+G.setGet(N[2]);
+G.setSet(N[3]);
+}else{
+G.setValue(N[1]);
+G.setWritable(N[4]);
+}
+G.setEnumerable(N[5]);
+G.setConfigurable(N[6]);
+return G;
+}
+function GetTrap(O,z,P){
+var Q=O[z];
+if((Q===(void 0))){
+if((P===(void 0))){
+throw k(41);
+}
+Q=P;
+}else if(!(typeof(Q)==='function')){
+throw k(41);
+}
+return Q;
+}
+function CallTrap1(O,z,P,R){
+return %_Call(GetTrap(O,z,P),O,R);
+}
+function CallTrap2(O,z,P,R,S){
+return %_Call(GetTrap(O,z,P),O,R,S);
+}
+function GetOwnPropertyJS(H,T){
+var U=(%_ToName(T));
+if((%_IsJSProxy(H))){
+if((typeof(T)==='symbol'))return(void 0);
+var O=%JSProxyGetHandler(H);
+var V=CallTrap1(
+O,"getOwnPropertyDescriptor",(void 0),U);
+if((V===(void 0)))return V;
+var G=ToCompletePropertyDescriptor(V);
+if(!G.isConfigurable()){
+throw k(41);
+}
+return G;
+}
+var W=%GetOwnProperty_Legacy((%_ToObject(H)),U);
+return ConvertDescriptorArrayToDescriptor(W);
+}
+function GetMethod(H,U){
+var X=H[U];
+if((X==null))return(void 0);
+if((typeof(X)==='function'))return X;
+throw k(15,typeof X);
+}
+function DefineProxyProperty(H,U,x,Y){
+if((typeof(U)==='symbol'))return false;
+var O=%JSProxyGetHandler(H);
+var Z=CallTrap2(O,"defineProperty",(void 0),U,x);
+if(!Z){
+if(Y){
+throw k(41);
+}else{
+return false;
+}
+}
+return true;
+}
+function DefineObjectProperty(H,U,G,Y){
+var aa=%GetOwnProperty_Legacy(H,(%_ToName(U)));
+var ab=ConvertDescriptorArrayToDescriptor(aa);
+var ac=%object_is_extensible(H);
+if((ab===(void 0))&&!ac){
+if(Y){
+throw k(34,U);
+}else{
+return false;
+}
+}
+if(!(ab===(void 0))){
+if((IsGenericDescriptor(G)||
+IsDataDescriptor(G)==IsDataDescriptor(ab))&&
+(!G.hasEnumerable()||
+r(G.isEnumerable(),ab.isEnumerable()))&&
+(!G.hasConfigurable()||
+r(G.isConfigurable(),ab.isConfigurable()))&&
+(!G.hasWritable()||
+r(G.isWritable(),ab.isWritable()))&&
+(!G.hasValue()||
+r(G.getValue(),ab.getValue()))&&
+(!G.hasGetter()||
+r(G.getGet(),ab.getGet()))&&
+(!G.hasSetter()||
+r(G.getSet(),ab.getSet()))){
+return true;
+}
+if(!ab.isConfigurable()){
+if(G.isConfigurable()||
+(G.hasEnumerable()&&
+G.isEnumerable()!=ab.isEnumerable())){
+if(Y){
+throw k(126,U);
+}else{
+return false;
+}
+}
+if(!IsGenericDescriptor(G)){
+if(IsDataDescriptor(ab)!=IsDataDescriptor(G)){
+if(Y){
+throw k(126,U);
+}else{
+return false;
+}
+}
+if(IsDataDescriptor(ab)&&IsDataDescriptor(G)){
+var ad=ab.isWritable();
+if(ad!=G.isWritable()){
+if(!ad||(%IsStrong(H))){
+if(Y){
+throw ad
+?k(146,H,U)
+:k(126,U);
+}else{
+return false;
+}
+}
+}
+if(!ad&&G.hasValue()&&
+!r(G.getValue(),ab.getValue())){
+if(Y){
+throw k(126,U);
+}else{
+return false;
+}
+}
+}
+if(IsAccessorDescriptor(G)&&IsAccessorDescriptor(ab)){
+if(G.hasSetter()&&
+!r(G.getSet(),ab.getSet())){
+if(Y){
+throw k(126,U);
+}else{
+return false;
+}
+}
+if(G.hasGetter()&&!r(G.getGet(),ab.getGet())){
+if(Y){
+throw k(126,U);
+}else{
+return false;
+}
+}
+}
+}
+}
+}
+var ae=0;
+if(G.hasEnumerable()){
+ae|=G.isEnumerable()?0:2;
+}else if(!(ab===(void 0))){
+ae|=ab.isEnumerable()?0:2;
+}else{
+ae|=2;
+}
+if(G.hasConfigurable()){
+ae|=G.isConfigurable()?0:4;
+}else if(!(ab===(void 0))){
+ae|=ab.isConfigurable()?0:4;
+}else
+ae|=4;
+if(IsDataDescriptor(G)||
+(IsGenericDescriptor(G)&&
+((ab===(void 0))||IsDataDescriptor(ab)))){
+if(G.hasWritable()){
+ae|=G.isWritable()?0:1;
+}else if(!(ab===(void 0))){
+ae|=ab.isWritable()?0:1;
+}else{
+ae|=1;
+}
+var y=(void 0);
+if(G.hasValue()){
+y=G.getValue();
+}else if(!(ab===(void 0))&&IsDataDescriptor(ab)){
+y=ab.getValue();
+}
+%DefineDataPropertyUnchecked(H,U,y,ae);
+}else{
+var af=null;
+if(G.hasGetter()){
+af=G.getGet();
+}else if(IsAccessorDescriptor(ab)&&ab.hasGetter()){
+af=ab.getGet();
+}
+var ag=null;
+if(G.hasSetter()){
+ag=G.getSet();
+}else if(IsAccessorDescriptor(ab)&&ab.hasSetter()){
+ag=ab.getSet();
+}
+%DefineAccessorPropertyUnchecked(H,U,af,ag,ae);
+}
+return true;
+}
+function DefineArrayProperty(H,U,G,Y){
+if(!(typeof(U)==='symbol')){
+var ah=((U)>>>0);
+var ai=false;
+if((%_ToString(ah))==U&&ah!=4294967295){
+var aj=H.length;
+if(ah>=aj&&%IsObserved(H)){
+ai=true;
+o(H);
+}
+var ak=GetOwnPropertyJS(H,"length");
+if((ah>=aj&&!ak.isWritable())||
+!DefineObjectProperty(H,U,G,true)){
+if(ai)
+p(H);
+if(Y){
+throw k(34,U);
+}else{
+return false;
+}
+}
+if(ah>=aj){
+H.length=ah+1;
+}
+if(ai){
+p(H);
+q(H,aj,[],ah+1-aj);
+}
+return true;
+}
+}
+return DefineObjectProperty(H,U,G,Y);
+}
+function DefineOwnProperty(H,U,G,Y){
+if((%_IsJSProxy(H))){
+if((typeof(U)==='symbol'))return false;
+var x=FromGenericPropertyDescriptor(G);
+return DefineProxyProperty(H,U,x,Y);
+}else if((%_IsArray(H))){
+return DefineArrayProperty(H,U,G,Y);
+}else{
+return DefineObjectProperty(H,U,G,Y);
+}
+}
+function ObjectGetPrototypeOf(H){
+return %_GetPrototype((%_ToObject(H)));
+}
+function ObjectSetPrototypeOf(H,al){
+if((%IS_VAR(H)===null)||(H===(void 0)))throw k(17,"Object.setPrototypeOf");
+if(al!==null&&!(%_IsJSReceiver(al))){
+throw k(92,al);
+}
+if((%_IsJSReceiver(H))){
+%SetPrototype(H,al);
+}
+return H;
+}
+function ObjectGetOwnPropertyDescriptor(H,U){
+return %GetOwnProperty(H,U);
+}
+function ObjectGetOwnPropertyNames(H){
+H=(%_ToObject(H));
+return %GetOwnPropertyKeys(H,16);
+}
+function ObjectDefineProperty(H,U,x){
+if(%IsObserved(H)){
+if(!(%_IsJSReceiver(H))){
+throw k(16,"Object.defineProperty");
+}
+var z=(%_ToName(U));
+var G=ToPropertyDescriptor(x);
+DefineOwnProperty(H,z,G,true);
+return H;
+}
+return %ObjectDefineProperty(H,U,x);
+}
+function GetOwnEnumerablePropertyNames(A){
+return %GetOwnPropertyKeys(A,2);
+}
+function ObjectDefineProperties(H,am){
+if(%IsObserved(H)){
+if(!(%_IsJSReceiver(H))){
+throw k(16,"Object.defineProperties");
+}
+var W=(%_ToObject(am));
+var an=GetOwnEnumerablePropertyNames(W);
+var ao=new g();
+for(var ap=0;ap<an.length;ap++){
+ao.push(ToPropertyDescriptor(W[an[ap]]));
+}
+for(var ap=0;ap<an.length;ap++){
+DefineOwnProperty(H,an[ap],ao[ap],true);
+}
+return H;
+}
+return %ObjectDefineProperties(H,am);
+}
+function ObjectGetProto(){
+return %_GetPrototype((%_ToObject(this)));
+}
+function ObjectSetProto(al){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(17,"Object.prototype.__proto__");
+if(((%_IsJSReceiver(al))||(al===null))&&(%_IsJSReceiver(this))){
+%SetPrototype(this,al);
+}
+}
+function ObjectConstructor(R){
+if(f!=new.target&&!(new.target===(void 0))){
+return this;
+}
+if((R===null)||(R===(void 0)))return{};
+return(%_ToObject(R));
+}
+%SetNativeFlag(f);
+%SetCode(f,ObjectConstructor);
+%AddNamedProperty(f.prototype,"constructor",f,
+2);
+b.InstallFunctions(f.prototype,2,[
+"toString",n,
+"toLocaleString",ObjectToLocaleString,
+"valueOf",ObjectValueOf,
+"hasOwnProperty",ObjectHasOwnProperty,
+"isPrototypeOf",ObjectIsPrototypeOf,
+"propertyIsEnumerable",ObjectPropertyIsEnumerable,
+"__defineGetter__",ObjectDefineGetter,
+"__lookupGetter__",ObjectLookupGetter,
+"__defineSetter__",ObjectDefineSetter,
+"__lookupSetter__",ObjectLookupSetter
+]);
+b.InstallGetterSetter(f.prototype,"__proto__",ObjectGetProto,
+ObjectSetProto);
+b.InstallFunctions(f,2,[
+"defineProperty",ObjectDefineProperty,
+"defineProperties",ObjectDefineProperties,
+"getPrototypeOf",ObjectGetPrototypeOf,
+"setPrototypeOf",ObjectSetPrototypeOf,
+"getOwnPropertyDescriptor",ObjectGetOwnPropertyDescriptor,
+"getOwnPropertyNames",ObjectGetOwnPropertyNames,
+"is",r,
+]);
+function BooleanConstructor(R){
+"use strict";
+if(!(new.target===(void 0))){
+%_SetValueOf(this,(!!(R)));
+}else{
+return(!!(R));
+}
+}
+function BooleanToString(){
+var aq=this;
+if(!(typeof(aq)==='boolean')){
+if(!(%_ClassOf(aq)==='Boolean')){
+throw k(65,'Boolean.prototype.toString');
+}
+aq=%_ValueOf(aq);
+}
+return aq?'true':'false';
+}
+function BooleanValueOf(){
+if(!(typeof(this)==='boolean')&&!(%_ClassOf(this)==='Boolean')){
+throw k(65,'Boolean.prototype.valueOf');
+}
+return %_ValueOf(this);
+}
+%SetCode(d,BooleanConstructor);
+%FunctionSetPrototype(d,new d(false));
+%AddNamedProperty(d.prototype,"constructor",d,
+2);
+b.InstallFunctions(d.prototype,2,[
+"toString",BooleanToString,
+"valueOf",BooleanValueOf
+]);
+function NumberToStringJS(w){
+var u=this;
+if(!(typeof(this)==='number')){
+if(!(%_ClassOf(this)==='Number')){
+throw k(65,'Number.prototype.toString');
+}
+u=%_ValueOf(this);
+}
+if((w===(void 0))||w===10){
+return %_NumberToString(u);
+}
+w=(%_ToInteger(w));
+if(w<2||w>36)throw i(189);
+return %NumberToRadixString(u,w);
+}
+function NumberToLocaleString(){
+return %_Call(NumberToStringJS,this);
+}
+function NumberValueOf(){
+if(!(typeof(this)==='number')&&!(%_ClassOf(this)==='Number')){
+throw k(65,'Number.prototype.valueOf');
+}
+return %_ValueOf(this);
+}
+function NumberToFixedJS(ar){
+var R=this;
+if(!(typeof(this)==='number')){
+if(!(%_ClassOf(this)==='Number')){
+throw k(42,
+"Number.prototype.toFixed",this);
+}
+R=%_ValueOf(this);
+}
+var as=(%_ToInteger(ar));
+if(as<0||as>20){
+throw i(185,"toFixed() digits");
+}
+if((!%_IsSmi(%IS_VAR(R))&&!(R==R)))return"NaN";
+if(R==(1/0))return"Infinity";
+if(R==-(1/0))return"-Infinity";
+return %NumberToFixed(R,as);
+}
+function NumberToExponentialJS(ar){
+var R=this;
+if(!(typeof(this)==='number')){
+if(!(%_ClassOf(this)==='Number')){
+throw k(42,
+"Number.prototype.toExponential",this);
+}
+R=%_ValueOf(this);
+}
+var as=(ar===(void 0))?(void 0):(%_ToInteger(ar));
+if((!%_IsSmi(%IS_VAR(R))&&!(R==R)))return"NaN";
+if(R==(1/0))return"Infinity";
+if(R==-(1/0))return"-Infinity";
+if((as===(void 0))){
+as=-1;
+}else if(as<0||as>20){
+throw i(185,"toExponential()");
+}
+return %NumberToExponential(R,as);
+}
+function NumberToPrecisionJS(at){
+var R=this;
+if(!(typeof(this)==='number')){
+if(!(%_ClassOf(this)==='Number')){
+throw k(42,
+"Number.prototype.toPrecision",this);
+}
+R=%_ValueOf(this);
+}
+if((at===(void 0)))return(%_ToString(R));
+var U=(%_ToInteger(at));
+if((!%_IsSmi(%IS_VAR(R))&&!(R==R)))return"NaN";
+if(R==(1/0))return"Infinity";
+if(R==-(1/0))return"-Infinity";
+if(U<1||U>21){
+throw i(188);
+}
+return %NumberToPrecision(R,U);
+}
+function NumberIsFinite(u){
+return(typeof(u)==='number')&&(%_IsSmi(%IS_VAR(u))||((u==u)&&(u!=1/0)&&(u!=-1/0)));
+}
+function NumberIsInteger(u){
+return NumberIsFinite(u)&&(%_ToInteger(u))==u;
+}
+function NumberIsNaN(u){
+return(typeof(u)==='number')&&(!%_IsSmi(%IS_VAR(u))&&!(u==u));
+}
+function NumberIsSafeInteger(u){
+if(NumberIsFinite(u)){
+var au=(%_ToInteger(u));
+if(au==u){
+return l(au)<=9007199254740991;
+}
+}
+return false;
+}
+%FunctionSetPrototype(e,new e(0));
+%OptimizeObjectForAddingMultipleProperties(e.prototype,8);
+%AddNamedProperty(e.prototype,"constructor",e,
+2);
+b.InstallConstants(e,[
+"MAX_VALUE",1.7976931348623157e+308,
+"MIN_VALUE",5e-324,
+"NaN",m,
+"NEGATIVE_INFINITY",-(1/0),
+"POSITIVE_INFINITY",(1/0),
+"MAX_SAFE_INTEGER",%_MathPow(2,53)-1,
+"MIN_SAFE_INTEGER",-%_MathPow(2,53)+1,
+"EPSILON",%_MathPow(2,-52)
+]);
+b.InstallFunctions(e.prototype,2,[
+"toString",NumberToStringJS,
+"toLocaleString",NumberToLocaleString,
+"valueOf",NumberValueOf,
+"toFixed",NumberToFixedJS,
+"toExponential",NumberToExponentialJS,
+"toPrecision",NumberToPrecisionJS
+]);
+b.InstallFunctions(e,2,[
+"isFinite",NumberIsFinite,
+"isInteger",NumberIsInteger,
+"isNaN",NumberIsNaN,
+"isSafeInteger",NumberIsSafeInteger,
+"parseInt",GlobalParseInt,
+"parseFloat",GlobalParseFloat
+]);
+%SetForceInlineFlag(NumberIsNaN);
+function GetIterator(H,av){
+if((av===(void 0))){
+av=H[h];
+}
+if(!(typeof(av)==='function')){
+throw k(66,H);
+}
+var aw=%_Call(av,H);
+if(!(%_IsJSReceiver(aw))){
+throw k(60,aw);
+}
+return aw;
+}
+b.Export(function(ax){
+ax.GetIterator=GetIterator;
+ax.GetMethod=GetMethod;
+ax.IsFinite=GlobalIsFinite;
+ax.IsNaN=GlobalIsNaN;
+ax.NumberIsNaN=NumberIsNaN;
+ax.ObjectDefineProperties=ObjectDefineProperties;
+ax.ObjectDefineProperty=ObjectDefineProperty;
+ax.ObjectHasOwnProperty=ObjectHasOwnProperty;
+});
+%InstallToContext([
+"object_value_of",ObjectValueOf,
+]);
+})
+
+symbol9
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Object;
+var d=a.Symbol;
+var e=b.ImportNow("has_instance_symbol");
+var f=
+b.ImportNow("is_concat_spreadable_symbol");
+var g=b.ImportNow("iterator_symbol");
+var h;
+var i=b.ImportNow("to_primitive_symbol");
+var j=b.ImportNow("to_string_tag_symbol");
+var k=b.ImportNow("unscopables_symbol");
+b.Import(function(l){
+h=l.MakeTypeError;
+});
+function SymbolToPrimitive(m){
+if(!((typeof(this)==='symbol')||(%_ClassOf(this)==='Symbol'))){
+throw h(42,
+"Symbol.prototype [ @@toPrimitive ]",this);
+}
+return %_ValueOf(this);
+}
+function SymbolToString(){
+if(!((typeof(this)==='symbol')||(%_ClassOf(this)==='Symbol'))){
+throw h(42,
+"Symbol.prototype.toString",this);
+}
+return %SymbolDescriptiveString(%_ValueOf(this));
+}
+function SymbolValueOf(){
+if(!((typeof(this)==='symbol')||(%_ClassOf(this)==='Symbol'))){
+throw h(42,
+"Symbol.prototype.valueOf",this);
+}
+return %_ValueOf(this);
+}
+function SymbolFor(n){
+n=(%_ToString(n));
+var o=%SymbolRegistry();
+if((o.for[n]===(void 0))){
+var p=%CreateSymbol(n);
+o.for[n]=p;
+o.keyFor[p]=n;
+}
+return o.for[n];
+}
+function SymbolKeyFor(p){
+if(!(typeof(p)==='symbol'))throw h(148,p);
+return %SymbolRegistry().keyFor[p];
+}
+function ObjectGetOwnPropertySymbols(q){
+q=(%_ToObject(q));
+return %GetOwnPropertyKeys(q,8);
+}
+%FunctionSetPrototype(d,new c());
+b.InstallConstants(d,[
+"iterator",g,
+"toPrimitive",i,
+"unscopables",k,
+]);
+b.InstallFunctions(d,2,[
+"for",SymbolFor,
+"keyFor",SymbolKeyFor
+]);
+%AddNamedProperty(
+d.prototype,"constructor",d,2);
+%AddNamedProperty(
+d.prototype,j,"Symbol",2|1);
+b.InstallFunctions(d.prototype,2|1,[
+i,SymbolToPrimitive
+]);
+b.InstallFunctions(d.prototype,2,[
+"toString",SymbolToString,
+"valueOf",SymbolValueOf
+]);
+b.InstallFunctions(c,2,[
+"getOwnPropertySymbols",ObjectGetOwnPropertySymbols
+]);
+b.Export(function(r){
+r.SymbolToString=SymbolToString;
+})
+})
+
+array��

+(function(a,b,c){
+"use strict";
+%CheckIsBootstrapping();
+var d;
+var e;
+var f;
+var g;
+var h;
+var i=a.Array;
+var j=b.InternalArray;
+var k=b.InternalPackedArray;
+var l;
+var m;
+var n;
+var o;
+var p;
+var q=b.ImportNow("object_to_string");
+var r;
+var s;
+var t;
+var u;
+var v=b.ImportNow("iterator_symbol");
+var w=b.ImportNow("unscopables_symbol");
+b.Import(function(x){
+d=x.AddIndexedProperty;
+g=x.GetIterator;
+h=x.GetMethod;
+l=x.MakeTypeError;
+m=x.MaxSimple;
+n=x.MinSimple;
+o=x.ObjectDefineProperty;
+p=x.ObjectHasOwnProperty;
+r=x.ObserveBeginPerformSplice;
+s=x.ObserveEndPerformSplice;
+t=x.ObserveEnqueueSpliceRecord;
+u=x.SameValueZero;
+});
+b.ImportFromExperimental(function(x){
+e=x.FLAG_harmony_tolength;
+f=x.FLAG_harmony_species;
+});
+function ArraySpeciesCreate(y,z){
+var A;
+if(f){
+A=%ArraySpeciesConstructor(y);
+}else{
+A=i;
+}
+return new A(z);
+}
+function DefineIndexedProperty(y,B,C){
+if(f){
+var D=o(y,B,{
+value:C,writable:true,configurable:true,enumerable:true
+});
+if(!D)throw l(137,B);
+}else{
+d(y,B,C);
+}
+}
+var E=new j();
+function GetSortedArrayKeys(y,F){
+var G=new j();
+if((typeof(F)==='number')){
+var H=F;
+for(var B=0;B<H;++B){
+var I=y[B];
+if(!(I===(void 0))||B in y){
+G.push(B);
+}
+}
+}else{
+var z=F.length;
+for(var J=0;J<z;++J){
+var K=F[J];
+if(!(K===(void 0))){
+var I=y[K];
+if(!(I===(void 0))||K in y){
+G.push(K);
+}
+}
+}
+G.sort(function(L,M){return L-M;});
+}
+return G;
+}
+function SparseJoinWithSeparatorJS(y,N,O,P){
+var G=GetSortedArrayKeys(y,%GetArrayKeys(y,N));
+var Q=0;
+var R=new j(G.length*2);
+var S=-1;
+for(var B=0;B<G.length;B++){
+var K=G[B];
+if(K!=S){
+var I=y[K];
+if(!(typeof(I)==='string'))I=O(I);
+R[B*2]=K;
+R[B*2+1]=I;
+S=K;
+}
+}
+return %SparseJoinWithSeparator(R,N,P);
+}
+function SparseJoin(y,N,O){
+var G=GetSortedArrayKeys(y,%GetArrayKeys(y,N));
+var T=-1;
+var U=G.length;
+var R=new j(U);
+var V=0;
+for(var B=0;B<U;B++){
+var K=G[B];
+if(K!=T){
+var I=y[K];
+if(!(typeof(I)==='string'))I=O(I);
+R[V++]=I;
+T=K;
+}
+}
+return %StringBuilderConcat(R,V,'');
+}
+function UseSparseVariant(y,z,W,X){
+if(!W||z<1000||%IsObserved(y)||
+%HasComplexElements(y)){
+return false;
+}
+if(!%_IsSmi(z)){
+return true;
+}
+var Y=z>>2;
+var Z=%EstimateNumberOfElements(y);
+return(Z<Y)&&
+(X>Z*4);
+}
+function Join(y,z,P,O){
+if(z==0)return'';
+var W=(%_IsArray(y));
+if(W){
+if(!%PushIfAbsent(E,y))return'';
+}
+try{
+if(UseSparseVariant(y,z,W,z)){
+%NormalizeElements(y);
+if(P.length==0){
+return SparseJoin(y,z,O);
+}else{
+return SparseJoinWithSeparatorJS(y,z,O,P);
+}
+}
+if(z==1){
+var I=y[0];
+if((typeof(I)==='string'))return I;
+return O(I);
+}
+var R=new j(z);
+if(P.length==0){
+var V=0;
+for(var B=0;B<z;B++){
+var I=y[B];
+if(!(typeof(I)==='string'))I=O(I);
+R[V++]=I;
+}
+R.length=V;
+var D=%_FastOneByteArrayJoin(R,'');
+if(!(D===(void 0)))return D;
+return %StringBuilderConcat(R,V,'');
+}
+if(!(typeof(y[0])==='number')){
+for(var B=0;B<z;B++){
+var I=y[B];
+if(!(typeof(I)==='string'))I=O(I);
+R[B]=I;
+}
+}else{
+for(var B=0;B<z;B++){
+var I=y[B];
+if((typeof(I)==='number')){
+I=%_NumberToString(I);
+}else if(!(typeof(I)==='string')){
+I=O(I);
+}
+R[B]=I;
+}
+}
+var D=%_FastOneByteArrayJoin(R,P);
+if(!(D===(void 0)))return D;
+return %StringBuilderJoin(R,z,P);
+}finally{
+if(W)E.length=E.length-1;
+}
+}
+function ConvertToString(aa){
+if((aa==null)){
+return'';
+}else{
+return(%_ToString(aa));
+}
+}
+function ConvertToLocaleString(I){
+if((I==null)){
+return'';
+}else{
+return(%_ToString(I.toLocaleString()));
+}
+}
+function SparseSlice(y,ab,ac,N,ad){
+var F=%GetArrayKeys(y,ab+ac);
+if((typeof(F)==='number')){
+var H=F;
+for(var B=ab;B<H;++B){
+var ae=y[B];
+if(!(ae===(void 0))||B in y){
+DefineIndexedProperty(ad,B-ab,ae);
+}
+}
+}else{
+var z=F.length;
+for(var J=0;J<z;++J){
+var K=F[J];
+if(!(K===(void 0))){
+if(K>=ab){
+var ae=y[K];
+if(!(ae===(void 0))||K in y){
+DefineIndexedProperty(ad,K-ab,ae);
+}
+}
+}
+}
+}
+}
+function SparseMove(y,ab,ac,N,af){
+if(af===ac)return;
+var ag=new j(
+n(N-ac+af,0xffffffff));
+var ah;
+var F=%GetArrayKeys(y,N);
+if((typeof(F)==='number')){
+var H=F;
+for(var B=0;B<ab&&B<H;++B){
+var ae=y[B];
+if(!(ae===(void 0))||B in y){
+ag[B]=ae;
+}
+}
+for(var B=ab+ac;B<H;++B){
+var ae=y[B];
+if(!(ae===(void 0))||B in y){
+ag[B-ac+af]=ae;
+}
+}
+}else{
+var z=F.length;
+for(var J=0;J<z;++J){
+var K=F[J];
+if(!(K===(void 0))){
+if(K<ab){
+var ae=y[K];
+if(!(ae===(void 0))||K in y){
+ag[K]=ae;
+}
+}else if(K>=ab+ac){
+var ae=y[K];
+if(!(ae===(void 0))||K in y){
+var ai=K-ac+af;
+ag[ai]=ae;
+if(ai>0xfffffffe){
+ah=ah||new j();
+ah.push(ai);
+}
+}
+}
+}
+}
+}
+%MoveArrayContents(ag,y);
+if(!(ah===(void 0))){
+var z=ah.length;
+for(var B=0;B<z;++B){
+var K=ah[B];
+y[K]=ag[K];
+}
+}
+}
+function SimpleSlice(y,ab,ac,N,ad){
+var W=(%_IsArray(y));
+for(var B=0;B<ac;B++){
+var aj=ab+B;
+if(((W&&%_HasFastPackedElements(%IS_VAR(y)))?(aj<y.length):(aj in y))){
+var ae=y[aj];
+DefineIndexedProperty(ad,B,ae);
+}
+}
+}
+function SimpleMove(y,ab,ac,N,af){
+var W=(%_IsArray(y));
+if(af!==ac){
+if(af>ac){
+for(var B=N-ac;B>ab;B--){
+var ak=B+ac-1;
+var al=B+af-1;
+if(((W&&%_HasFastPackedElements(%IS_VAR(y)))?(ak<y.length):(ak in y))){
+y[al]=y[ak];
+}else{
+delete y[al];
+}
+}
+}else{
+for(var B=ab;B<N-ac;B++){
+var ak=B+ac;
+var al=B+af;
+if(((W&&%_HasFastPackedElements(%IS_VAR(y)))?(ak<y.length):(ak in y))){
+y[al]=y[ak];
+}else{
+delete y[al];
+}
+}
+for(var B=N;B>N-ac+af;B--){
+delete y[B-1];
+}
+}
+}
+}
+function ArrayToString(){
+var y;
+var am;
+if((%_IsArray(this))){
+am=this.join;
+if(am===ArrayJoin){
+return Join(this,this.length,',',ConvertToString);
+}
+y=this;
+}else{
+y=(%_ToObject(this));
+am=y.join;
+}
+if(!(typeof(am)==='function')){
+return %_Call(q,y);
+}
+return %_Call(am,y);
+}
+function InnerArrayToLocaleString(y,z){
+var N=(e?(%_ToLength(z)):((z)>>>0));
+if(N===0)return"";
+return Join(y,N,',',ConvertToLocaleString);
+}
+function ArrayToLocaleString(){
+var y=(%_ToObject(this));
+var an=y.length;
+return InnerArrayToLocaleString(y,an);
+}
+function InnerArrayJoin(P,y,z){
+if((P===(void 0))){
+P=',';
+}else{
+P=(%_ToString(P));
+}
+var D=%_FastOneByteArrayJoin(y,P);
+if(!(D===(void 0)))return D;
+if(z===1){
+var I=y[0];
+if((I==null))return'';
+return(%_ToString(I));
+}
+return Join(y,z,P,ConvertToString);
+}
+function ArrayJoin(P){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.join");
+var y=(%_ToObject(this));
+var z=(e?(%_ToLength(y.length)):((y.length)>>>0));
+return InnerArrayJoin(P,y,z);
+}
+function ObservedArrayPop(ao){
+ao--;
+var C=this[ao];
+try{
+r(this);
+delete this[ao];
+this.length=ao;
+}finally{
+s(this);
+t(this,ao,[C],0);
+}
+return C;
+}
+function ArrayPop(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.pop");
+var y=(%_ToObject(this));
+var ao=(e?(%_ToLength(y.length)):((y.length)>>>0));
+if(ao==0){
+y.length=ao;
+return;
+}
+if(%IsObserved(y))
+return ObservedArrayPop.call(y,ao);
+ao--;
+var C=y[ao];
+%DeleteProperty_Strict(y,ao);
+y.length=ao;
+return C;
+}
+function ObservedArrayPush(){
+var ao=(e?(%_ToLength(this.length)):((this.length)>>>0));
+var ap=%_ArgumentsLength();
+try{
+r(this);
+for(var B=0;B<ap;B++){
+this[B+ao]=%_Arguments(B);
+}
+var aq=ao+ap;
+this.length=aq;
+}finally{
+s(this);
+t(this,ao,[],ap);
+}
+return aq;
+}
+function ArrayPush(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.push");
+if(%IsObserved(this))
+return ObservedArrayPush.apply(this,arguments);
+var y=(%_ToObject(this));
+var ao=(e?(%_ToLength(y.length)):((y.length)>>>0));
+var ap=%_ArgumentsLength();
+if(ap>(1<<30)||(ao-(1<<30))+ap>9007199254740991-(1<<30)){
+throw l(228,ap,ao);
+}
+for(var B=0;B<ap;B++){
+y[B+ao]=%_Arguments(B);
+}
+var aq=ao+ap;
+y.length=aq;
+return aq;
+}
+function SparseReverse(y,N){
+var G=GetSortedArrayKeys(y,%GetArrayKeys(y,N));
+var ar=G.length-1;
+var as=0;
+while(as<=ar){
+var B=G[as];
+var at=G[ar];
+var au=N-at-1;
+var av,aw;
+if(au<=B){
+aw=at;
+while(G[--ar]==at){}
+av=au;
+}
+if(au>=B){
+av=B;
+while(G[++as]==B){}
+aw=N-B-1;
+}
+var ax=y[av];
+if(!(ax===(void 0))||av in y){
+var ay=y[aw];
+if(!(ay===(void 0))||aw in y){
+y[av]=ay;
+y[aw]=ax;
+}else{
+y[aw]=ax;
+delete y[av];
+}
+}else{
+var ay=y[aw];
+if(!(ay===(void 0))||aw in y){
+y[av]=ay;
+delete y[aw];
+}
+}
+}
+}
+function PackedArrayReverse(y,N){
+var at=N-1;
+for(var B=0;B<at;B++,at--){
+var ax=y[B];
+var ay=y[at];
+y[B]=ay;
+y[at]=ax;
+}
+return y;
+}
+function GenericArrayReverse(y,N){
+var at=N-1;
+for(var B=0;B<at;B++,at--){
+if(B in y){
+var ax=y[B];
+if(at in y){
+var ay=y[at];
+y[B]=ay;
+y[at]=ax;
+}else{
+y[at]=ax;
+delete y[B];
+}
+}else{
+if(at in y){
+var ay=y[at];
+y[B]=ay;
+delete y[at];
+}
+}
+}
+return y;
+}
+function ArrayReverse(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.reverse");
+var y=(%_ToObject(this));
+var N=(e?(%_ToLength(y.length)):((y.length)>>>0));
+var az=(%_IsArray(y));
+if(UseSparseVariant(y,N,az,N)){
+%NormalizeElements(y);
+SparseReverse(y,N);
+return y;
+}else if(az&&%_HasFastPackedElements(y)){
+return PackedArrayReverse(y,N);
+}else{
+return GenericArrayReverse(y,N);
+}
+}
+function ObservedArrayShift(N){
+var aA=this[0];
+try{
+r(this);
+SimpleMove(this,0,1,N,0);
+this.length=N-1;
+}finally{
+s(this);
+t(this,0,[aA],0);
+}
+return aA;
+}
+function ArrayShift(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.shift");
+var y=(%_ToObject(this));
+var N=(e?(%_ToLength(y.length)):((y.length)>>>0));
+if(N===0){
+y.length=0;
+return;
+}
+if(%object_is_sealed(y))throw l(13);
+if(%IsObserved(y))
+return ObservedArrayShift.call(y,N);
+var aA=y[0];
+if(UseSparseVariant(y,N,(%_IsArray(y)),N)){
+SparseMove(y,0,1,N,0);
+}else{
+SimpleMove(y,0,1,N,0);
+}
+y.length=N-1;
+return aA;
+}
+function ObservedArrayUnshift(){
+var N=(e?(%_ToLength(this.length)):((this.length)>>>0));
+var aB=%_ArgumentsLength();
+try{
+r(this);
+SimpleMove(this,0,0,N,aB);
+for(var B=0;B<aB;B++){
+this[B]=%_Arguments(B);
+}
+var aq=N+aB;
+this.length=aq;
+}finally{
+s(this);
+t(this,0,[],aB);
+}
+return aq;
+}
+function ArrayUnshift(aC){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.unshift");
+if(%IsObserved(this))
+return ObservedArrayUnshift.apply(this,arguments);
+var y=(%_ToObject(this));
+var N=(e?(%_ToLength(y.length)):((y.length)>>>0));
+var aB=%_ArgumentsLength();
+if(N>0&&UseSparseVariant(y,N,(%_IsArray(y)),N)&&
+!%object_is_sealed(y)){
+SparseMove(y,0,0,N,aB);
+}else{
+SimpleMove(y,0,0,N,aB);
+}
+for(var B=0;B<aB;B++){
+y[B]=%_Arguments(B);
+}
+var aq=N+aB;
+y.length=aq;
+return aq;
+}
+function ArraySlice(aD,aE){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.slice");
+var y=(%_ToObject(this));
+var N=(e?(%_ToLength(y.length)):((y.length)>>>0));
+var ab=(%_ToInteger(aD));
+var aF=N;
+if(!(aE===(void 0)))aF=(%_ToInteger(aE));
+if(ab<0){
+ab+=N;
+if(ab<0)ab=0;
+}else{
+if(ab>N)ab=N;
+}
+if(aF<0){
+aF+=N;
+if(aF<0)aF=0;
+}else{
+if(aF>N)aF=N;
+}
+var D=ArraySpeciesCreate(y,m(aF-ab,0));
+if(aF<ab)return D;
+if(UseSparseVariant(y,N,(%_IsArray(y)),aF-ab)){
+%NormalizeElements(y);
+%NormalizeElements(D);
+SparseSlice(y,ab,aF-ab,N,D);
+}else{
+SimpleSlice(y,ab,aF-ab,N,D);
+}
+D.length=aF-ab;
+return D;
+}
+function ComputeSpliceStartIndex(ab,N){
+if(ab<0){
+ab+=N;
+return ab<0?0:ab;
+}
+return ab>N?N:ab;
+}
+function ComputeSpliceDeleteCount(aG,aB,N,ab){
+var ac=0;
+if(aB==1)
+return N-ab;
+ac=(%_ToInteger(aG));
+if(ac<0)
+return 0;
+if(ac>N-ab)
+return N-ab;
+return ac;
+}
+function ObservedArraySplice(aD,aG){
+var aB=%_ArgumentsLength();
+var N=(e?(%_ToLength(this.length)):((this.length)>>>0));
+var ab=ComputeSpliceStartIndex((%_ToInteger(aD)),N);
+var ac=ComputeSpliceDeleteCount(aG,aB,N,
+ab);
+var ad=[];
+ad.length=ac;
+var aH=aB>2?aB-2:0;
+try{
+r(this);
+SimpleSlice(this,ab,ac,N,ad);
+SimpleMove(this,ab,ac,N,aH);
+var B=ab;
+var aI=2;
+var aJ=%_ArgumentsLength();
+while(aI<aJ){
+this[B++]=%_Arguments(aI++);
+}
+this.length=N-ac+aH;
+}finally{
+s(this);
+if(ad.length||aH){
+t(this,
+ab,
+ad.slice(),
+aH);
+}
+}
+return ad;
+}
+function ArraySplice(aD,aG){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.splice");
+if(%IsObserved(this))
+return ObservedArraySplice.apply(this,arguments);
+var aB=%_ArgumentsLength();
+var y=(%_ToObject(this));
+var N=(e?(%_ToLength(y.length)):((y.length)>>>0));
+var ab=ComputeSpliceStartIndex((%_ToInteger(aD)),N);
+var ac=ComputeSpliceDeleteCount(aG,aB,N,
+ab);
+var ad=ArraySpeciesCreate(y,ac);
+ad.length=ac;
+var aH=aB>2?aB-2:0;
+if(ac!=aH&&%object_is_sealed(y)){
+throw l(13);
+}else if(ac>0&&%object_is_frozen(y)){
+throw l(12);
+}
+var aK=ac;
+if(aH!=ac){
+aK+=N-ab-ac;
+}
+if(UseSparseVariant(y,N,(%_IsArray(y)),aK)){
+%NormalizeElements(y);
+%NormalizeElements(ad);
+SparseSlice(y,ab,ac,N,ad);
+SparseMove(y,ab,ac,N,aH);
+}else{
+SimpleSlice(y,ab,ac,N,ad);
+SimpleMove(y,ab,ac,N,aH);
+}
+var B=ab;
+var aI=2;
+var aJ=%_ArgumentsLength();
+while(aI<aJ){
+y[B++]=%_Arguments(aI++);
+}
+y.length=N-ac+aH;
+return ad;
+}
+function InnerArraySort(y,z,aL){
+if(!(typeof(aL)==='function')){
+aL=function(aa,aM){
+if(aa===aM)return 0;
+if(%_IsSmi(aa)&&%_IsSmi(aM)){
+return %SmiLexicographicCompare(aa,aM);
+}
+aa=(%_ToString(aa));
+aM=(%_ToString(aM));
+if(aa==aM)return 0;
+else return aa<aM?-1:1;
+};
+}
+var aN=function InsertionSort(L,x,aO){
+for(var B=x+1;B<aO;B++){
+var aP=L[B];
+for(var at=B-1;at>=x;at--){
+var aQ=L[at];
+var aR=aL(aQ,aP);
+if(aR>0){
+L[at+1]=aQ;
+}else{
+break;
+}
+}
+L[at+1]=aP;
+}
+};
+var aS=function(L,x,aO){
+var aT=new j();
+var aU=200+((aO-x)&15);
+var at=0;
+x+=1;
+aO-=1;
+for(var B=x;B<aO;B+=aU){
+aT[at]=[B,L[B]];
+at++;
+}
+aT.sort(function(L,M){
+return aL(L[1],M[1]);
+});
+var aV=aT[aT.length>>1][0];
+return aV;
+}
+var aW=function QuickSort(L,x,aO){
+var aV=0;
+while(true){
+if(aO-x<=10){
+aN(L,x,aO);
+return;
+}
+if(aO-x>1000){
+aV=aS(L,x,aO);
+}else{
+aV=x+((aO-x)>>1);
+}
+var aX=L[x];
+var aY=L[aO-1];
+var aZ=L[aV];
+var ba=aL(aX,aY);
+if(ba>0){
+var aQ=aX;
+aX=aY;
+aY=aQ;
+}
+var bb=aL(aX,aZ);
+if(bb>=0){
+var aQ=aX;
+aX=aZ;
+aZ=aY;
+aY=aQ;
+}else{
+var bc=aL(aY,aZ);
+if(bc>0){
+var aQ=aY;
+aY=aZ;
+aZ=aQ;
+}
+}
+L[x]=aX;
+L[aO-1]=aZ;
+var bd=aY;
+var be=x+1;
+var bf=aO-1;
+L[aV]=L[be];
+L[be]=bd;
+partition:for(var B=be+1;B<bf;B++){
+var aP=L[B];
+var aR=aL(aP,bd);
+if(aR<0){
+L[B]=L[be];
+L[be]=aP;
+be++;
+}else if(aR>0){
+do{
+bf--;
+if(bf==B)break partition;
+var bg=L[bf];
+aR=aL(bg,bd);
+}while(aR>0);
+L[B]=L[bf];
+L[bf]=aP;
+if(aR<0){
+aP=L[B];
+L[B]=L[be];
+L[be]=aP;
+be++;
+}
+}
+}
+if(aO-bf<be-x){
+aW(L,bf,aO);
+aO=be;
+}else{
+aW(L,x,be);
+x=bf;
+}
+}
+};
+var bh=function CopyFromPrototype(bi,z){
+var bj=0;
+for(var bk=%_GetPrototype(bi);bk;bk=%_GetPrototype(bk)){
+var F=%GetArrayKeys(bk,z);
+if((typeof(F)==='number')){
+var bl=F;
+for(var B=0;B<bl;B++){
+if(!(%_Call(p,bi,B))&&(%_Call(p,bk,B))){
+bi[B]=bk[B];
+if(B>=bj){bj=B+1;}
+}
+}
+}else{
+for(var B=0;B<F.length;B++){
+var aj=F[B];
+if(!(aj===(void 0))&&!(%_Call(p,bi,aj))
+&&(%_Call(p,bk,aj))){
+bi[aj]=bk[aj];
+if(aj>=bj){bj=aj+1;}
+}
+}
+}
+}
+return bj;
+};
+var bm=function(bi,x,aO){
+for(var bk=%_GetPrototype(bi);bk;bk=%_GetPrototype(bk)){
+var F=%GetArrayKeys(bk,aO);
+if((typeof(F)==='number')){
+var bl=F;
+for(var B=x;B<bl;B++){
+if((%_Call(p,bk,B))){
+bi[B]=(void 0);
+}
+}
+}else{
+for(var B=0;B<F.length;B++){
+var aj=F[B];
+if(!(aj===(void 0))&&x<=aj&&
+(%_Call(p,bk,aj))){
+bi[aj]=(void 0);
+}
+}
+}
+}
+};
+var bn=function SafeRemoveArrayHoles(bi){
+var bo=0;
+var bp=z-1;
+var bq=0;
+while(bo<bp){
+while(bo<bp&&
+!(bi[bo]===(void 0))){
+bo++;
+}
+if(!(%_Call(p,bi,bo))){
+bq++;
+}
+while(bo<bp&&
+(bi[bp]===(void 0))){
+if(!(%_Call(p,bi,bp))){
+bq++;
+}
+bp--;
+}
+if(bo<bp){
+bi[bo]=bi[bp];
+bi[bp]=(void 0);
+}
+}
+if(!(bi[bo]===(void 0)))bo++;
+var B;
+for(B=bo;B<z-bq;B++){
+bi[B]=(void 0);
+}
+for(B=z-bq;B<z;B++){
+if(B in %_GetPrototype(bi)){
+bi[B]=(void 0);
+}else{
+delete bi[B];
+}
+}
+return bo;
+};
+if(z<2)return y;
+var W=(%_IsArray(y));
+var br;
+if(!W){
+br=bh(y,z);
+}
+var bs=%RemoveArrayHoles(y,z);
+if(bs==-1){
+bs=bn(y);
+}
+aW(y,0,bs);
+if(!W&&(bs+1<br)){
+bm(y,bs,br);
+}
+return y;
+}
+function ArraySort(aL){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.sort");
+var y=(%_ToObject(this));
+var z=(e?(%_ToLength(y.length)):((y.length)>>>0));
+return InnerArraySort(y,z,aL);
+}
+function InnerArrayFilter(bt,bu,y,z,D){
+var bv=0;
+var W=(%_IsArray(y));
+for(var B=0;B<z;B++){
+if(((W&&%_HasFastPackedElements(%IS_VAR(y)))?(B<y.length):(B in y))){
+var aP=y[B];
+if(%_Call(bt,bu,aP,B,y)){
+DefineIndexedProperty(D,bv,aP);
+bv++;
+}
+}
+}
+return D;
+}
+function ArrayFilter(bt,bu){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.filter");
+var y=(%_ToObject(this));
+var z=(e?(%_ToLength(y.length)):((y.length)>>>0));
+if(!(typeof(bt)==='function'))throw l(15,bt);
+var D=ArraySpeciesCreate(y,0);
+return InnerArrayFilter(bt,bu,y,z,D);
+}
+function InnerArrayForEach(bt,bu,y,z){
+if(!(typeof(bt)==='function'))throw l(15,bt);
+var W=(%_IsArray(y));
+for(var B=0;B<z;B++){
+if(((W&&%_HasFastPackedElements(%IS_VAR(y)))?(B<y.length):(B in y))){
+var aP=y[B];
+%_Call(bt,bu,aP,B,y);
+}
+}
+}
+function ArrayForEach(bt,bu){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.forEach");
+var y=(%_ToObject(this));
+var z=(e?(%_ToLength(y.length)):((y.length)>>>0));
+InnerArrayForEach(bt,bu,y,z);
+}
+function InnerArraySome(bt,bu,y,z){
+if(!(typeof(bt)==='function'))throw l(15,bt);
+var W=(%_IsArray(y));
+for(var B=0;B<z;B++){
+if(((W&&%_HasFastPackedElements(%IS_VAR(y)))?(B<y.length):(B in y))){
+var aP=y[B];
+if(%_Call(bt,bu,aP,B,y))return true;
+}
+}
+return false;
+}
+function ArraySome(bt,bu){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.some");
+var y=(%_ToObject(this));
+var z=(e?(%_ToLength(y.length)):((y.length)>>>0));
+return InnerArraySome(bt,bu,y,z);
+}
+function InnerArrayEvery(bt,bu,y,z){
+if(!(typeof(bt)==='function'))throw l(15,bt);
+var W=(%_IsArray(y));
+for(var B=0;B<z;B++){
+if(((W&&%_HasFastPackedElements(%IS_VAR(y)))?(B<y.length):(B in y))){
+var aP=y[B];
+if(!%_Call(bt,bu,aP,B,y))return false;
+}
+}
+return true;
+}
+function ArrayEvery(bt,bu){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.every");
+var y=(%_ToObject(this));
+var z=(e?(%_ToLength(y.length)):((y.length)>>>0));
+return InnerArrayEvery(bt,bu,y,z);
+}
+function ArrayMap(bt,bu){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.map");
+var y=(%_ToObject(this));
+var z=(e?(%_ToLength(y.length)):((y.length)>>>0));
+if(!(typeof(bt)==='function'))throw l(15,bt);
+var D=ArraySpeciesCreate(y,z);
+var W=(%_IsArray(y));
+for(var B=0;B<z;B++){
+if(((W&&%_HasFastPackedElements(%IS_VAR(y)))?(B<y.length):(B in y))){
+var aP=y[B];
+DefineIndexedProperty(D,B,%_Call(bt,bu,aP,B,y));
+}
+}
+return D;
+}
+function InnerArrayIndexOf(y,aP,aj,z){
+if(z==0)return-1;
+if((aj===(void 0))){
+aj=0;
+}else{
+aj=(%_ToInteger(aj));
+if(aj<0){
+aj=z+aj;
+if(aj<0)aj=0;
+}
+}
+var bw=aj;
+var bj=z;
+if(UseSparseVariant(y,z,(%_IsArray(y)),bj-bw)){
+%NormalizeElements(y);
+var F=%GetArrayKeys(y,z);
+if((typeof(F)==='number')){
+bj=F;
+}else{
+if(F.length==0)return-1;
+var bx=GetSortedArrayKeys(y,F);
+var ao=bx.length;
+var B=0;
+while(B<ao&&bx[B]<aj)B++;
+while(B<ao){
+var K=bx[B];
+if(!(K===(void 0))&&y[K]===aP)return K;
+B++;
+}
+return-1;
+}
+}
+if(!(aP===(void 0))){
+for(var B=bw;B<bj;B++){
+if(y[B]===aP)return B;
+}
+return-1;
+}
+for(var B=bw;B<bj;B++){
+if((y[B]===(void 0))&&B in y){
+return B;
+}
+}
+return-1;
+}
+function ArrayIndexOf(aP,aj){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.indexOf");
+var z=(e?(%_ToLength(this.length)):((this.length)>>>0));
+return InnerArrayIndexOf(this,aP,aj,z);
+}
+function InnerArrayLastIndexOf(y,aP,aj,z,by){
+if(z==0)return-1;
+if(by<2){
+aj=z-1;
+}else{
+aj=(%_ToInteger(aj));
+if(aj<0)aj+=z;
+if(aj<0)return-1;
+else if(aj>=z)aj=z-1;
+}
+var bw=0;
+var bj=aj;
+if(UseSparseVariant(y,z,(%_IsArray(y)),aj)){
+%NormalizeElements(y);
+var F=%GetArrayKeys(y,aj+1);
+if((typeof(F)==='number')){
+bj=F;
+}else{
+if(F.length==0)return-1;
+var bx=GetSortedArrayKeys(y,F);
+var B=bx.length-1;
+while(B>=0){
+var K=bx[B];
+if(!(K===(void 0))&&y[K]===aP)return K;
+B--;
+}
+return-1;
+}
+}
+if(!(aP===(void 0))){
+for(var B=bj;B>=bw;B--){
+if(y[B]===aP)return B;
+}
+return-1;
+}
+for(var B=bj;B>=bw;B--){
+if((y[B]===(void 0))&&B in y){
+return B;
+}
+}
+return-1;
+}
+function ArrayLastIndexOf(aP,aj){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.lastIndexOf");
+var z=(e?(%_ToLength(this.length)):((this.length)>>>0));
+return InnerArrayLastIndexOf(this,aP,aj,z,
+%_ArgumentsLength());
+}
+function InnerArrayReduce(bz,ae,y,z,by){
+if(!(typeof(bz)==='function')){
+throw l(15,bz);
+}
+var W=(%_IsArray(y));
+var B=0;
+find_initial:if(by<2){
+for(;B<z;B++){
+if(((W&&%_HasFastPackedElements(%IS_VAR(y)))?(B<y.length):(B in y))){
+ae=y[B++];
+break find_initial;
+}
+}
+throw l(128);
+}
+for(;B<z;B++){
+if(((W&&%_HasFastPackedElements(%IS_VAR(y)))?(B<y.length):(B in y))){
+var aP=y[B];
+ae=bz(ae,aP,B,y);
+}
+}
+return ae;
+}
+function ArrayReduce(bz,ae){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.reduce");
+var y=(%_ToObject(this));
+var z=(e?(%_ToLength(y.length)):((y.length)>>>0));
+return InnerArrayReduce(bz,ae,y,z,
+%_ArgumentsLength());
+}
+function InnerArrayReduceRight(bz,ae,y,z,
+by){
+if(!(typeof(bz)==='function')){
+throw l(15,bz);
+}
+var W=(%_IsArray(y));
+var B=z-1;
+find_initial:if(by<2){
+for(;B>=0;B--){
+if(((W&&%_HasFastPackedElements(%IS_VAR(y)))?(B<y.length):(B in y))){
+ae=y[B--];
+break find_initial;
+}
+}
+throw l(128);
+}
+for(;B>=0;B--){
+if(((W&&%_HasFastPackedElements(%IS_VAR(y)))?(B<y.length):(B in y))){
+var aP=y[B];
+ae=bz(ae,aP,B,y);
+}
+}
+return ae;
+}
+function ArrayReduceRight(bz,ae){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.reduceRight");
+var y=(%_ToObject(this));
+var z=(e?(%_ToLength(y.length)):((y.length)>>>0));
+return InnerArrayReduceRight(bz,ae,y,z,
+%_ArgumentsLength());
+}
+function InnerArrayCopyWithin(bA,aD,aE,y,z){
+bA=(%_ToInteger(bA));
+var aO;
+if(bA<0){
+aO=m(z+bA,0);
+}else{
+aO=n(bA,z);
+}
+aD=(%_ToInteger(aD));
+var x;
+if(aD<0){
+x=m(z+aD,0);
+}else{
+x=n(aD,z);
+}
+aE=(aE===(void 0))?z:(%_ToInteger(aE));
+var bB;
+if(aE<0){
+bB=m(z+aE,0);
+}else{
+bB=n(aE,z);
+}
+var bC=n(bB-x,z-aO);
+var bD=1;
+if(x<aO&&aO<(x+bC)){
+bD=-1;
+x=x+bC-1;
+aO=aO+bC-1;
+}
+while(bC>0){
+if(x in y){
+y[aO]=y[x];
+}else{
+delete y[aO];
+}
+x=x+bD;
+aO=aO+bD;
+bC--;
+}
+return y;
+}
+function ArrayCopyWithin(bA,aD,aE){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.copyWithin");
+var y=(%_ToObject(this));
+var z=(%_ToLength(y.length));
+return InnerArrayCopyWithin(bA,aD,aE,y,z);
+}
+function InnerArrayFind(bE,bF,y,z){
+if(!(typeof(bE)==='function')){
+throw l(15,bE);
+}
+for(var B=0;B<z;B++){
+var aP=y[B];
+if(%_Call(bE,bF,aP,B,y)){
+return aP;
+}
+}
+return;
+}
+function ArrayFind(bE,bF){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.find");
+var y=(%_ToObject(this));
+var z=(%_ToInteger(y.length));
+return InnerArrayFind(bE,bF,y,z);
+}
+function InnerArrayFindIndex(bE,bF,y,z){
+if(!(typeof(bE)==='function')){
+throw l(15,bE);
+}
+for(var B=0;B<z;B++){
+var aP=y[B];
+if(%_Call(bE,bF,aP,B,y)){
+return B;
+}
+}
+return-1;
+}
+function ArrayFindIndex(bE,bF){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.findIndex");
+var y=(%_ToObject(this));
+var z=(%_ToInteger(y.length));
+return InnerArrayFindIndex(bE,bF,y,z);
+}
+function InnerArrayFill(C,aD,aE,y,z){
+var B=(aD===(void 0))?0:(%_ToInteger(aD));
+var aE=(aE===(void 0))?z:(%_ToInteger(aE));
+if(B<0){
+B+=z;
+if(B<0)B=0;
+}else{
+if(B>z)B=z;
+}
+if(aE<0){
+aE+=z;
+if(aE<0)aE=0;
+}else{
+if(aE>z)aE=z;
+}
+if((aE-B)>0&&%object_is_frozen(y)){
+throw l(12);
+}
+for(;B<aE;B++)
+y[B]=C;
+return y;
+}
+function ArrayFill(C,aD,aE){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.fill");
+var y=(%_ToObject(this));
+var z=(e?(%_ToLength(y.length)):((y.length)>>>0));
+return InnerArrayFill(C,aD,aE,y,z);
+}
+function InnerArrayIncludes(bG,bH,y,z){
+if(z===0){
+return false;
+}
+var ao=(%_ToInteger(bH));
+var J;
+if(ao>=0){
+J=ao;
+}else{
+J=z+ao;
+if(J<0){
+J=0;
+}
+}
+while(J<z){
+var bI=y[J];
+if(u(bG,bI)){
+return true;
+}
+++J;
+}
+return false;
+}
+function ArrayIncludes(bG,bH){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.includes");
+var y=(%_ToObject(this));
+var z=(%_ToLength(y.length));
+return InnerArrayIncludes(bG,bH,y,z);
+}
+function AddArrayElement(A,y,B,C){
+if(A===i){
+d(y,B,C);
+}else{
+o(y,B,{
+value:C,writable:true,configurable:true,enumerable:true
+});
+}
+}
+function ArrayFrom(bJ,bK,bu){
+var bL=(%_ToObject(bJ));
+var bM=!(bK===(void 0));
+if(bM){
+if(!(typeof(bK)==='function')){
+throw l(15,bK);
+}
+}
+var bN=h(bL,v);
+var J;
+var D;
+var bO;
+var bP;
+if(!(bN===(void 0))){
+D=%IsConstructor(this)?new this():[];
+var bQ=g(bL,bN);
+J=0;
+while(true){
+var bR=bQ.next();
+if(!(%_IsJSReceiver(bR))){
+throw l(48,bR);
+}
+if(bR.done){
+D.length=J;
+return D;
+}
+bP=bR.value;
+if(bM){
+bO=%_Call(bK,bu,bP,J);
+}else{
+bO=bP;
+}
+AddArrayElement(this,D,J,bO);
+J++;
+}
+}else{
+var N=(%_ToLength(bL.length));
+D=%IsConstructor(this)?new this(N):new i(N);
+for(J=0;J<N;++J){
+bP=bL[J];
+if(bM){
+bO=%_Call(bK,bu,bP,J);
+}else{
+bO=bP;
+}
+AddArrayElement(this,D,J,bO);
+}
+D.length=J;
+return D;
+}
+}
+function ArrayOf(){
+var z=%_ArgumentsLength();
+var A=this;
+var y=%IsConstructor(A)?new A(z):[];
+for(var B=0;B<z;B++){
+AddArrayElement(A,y,B,%_Arguments(B));
+}
+y.length=z;
+return y;
+}
+%AddNamedProperty(i.prototype,"constructor",i,
+2);
+var bS={
+__proto__:null,
+copyWithin:true,
+entries:true,
+fill:true,
+find:true,
+findIndex:true,
+keys:true,
+};
+%AddNamedProperty(i.prototype,w,bS,
+2|1);
+%FunctionSetLength(ArrayFrom,1);
+b.InstallFunctions(i,2,[
+"from",ArrayFrom,
+"of",ArrayOf
+]);
+var bT=%SpecialArrayFunctions();
+var bU=function(bV,bW,N){
+var bt=bW;
+if(bT.hasOwnProperty(bV)){
+bt=bT[bV];
+}
+if(!(N===(void 0))){
+%FunctionSetLength(bt,N);
+}
+return bt;
+};
+b.InstallFunctions(i.prototype,2,[
+"toString",bU("toString",ArrayToString),
+"toLocaleString",bU("toLocaleString",ArrayToLocaleString),
+"join",bU("join",ArrayJoin),
+"pop",bU("pop",ArrayPop),
+"push",bU("push",ArrayPush,1),
+"reverse",bU("reverse",ArrayReverse),
+"shift",bU("shift",ArrayShift),
+"unshift",bU("unshift",ArrayUnshift,1),
+"slice",bU("slice",ArraySlice,2),
+"splice",bU("splice",ArraySplice,2),
+"sort",bU("sort",ArraySort),
+"filter",bU("filter",ArrayFilter,1),
+"forEach",bU("forEach",ArrayForEach,1),
+"some",bU("some",ArraySome,1),
+"every",bU("every",ArrayEvery,1),
+"map",bU("map",ArrayMap,1),
+"indexOf",bU("indexOf",ArrayIndexOf,1),
+"lastIndexOf",bU("lastIndexOf",ArrayLastIndexOf,1),
+"reduce",bU("reduce",ArrayReduce,1),
+"reduceRight",bU("reduceRight",ArrayReduceRight,1),
+"copyWithin",bU("copyWithin",ArrayCopyWithin,2),
+"find",bU("find",ArrayFind,1),
+"findIndex",bU("findIndex",ArrayFindIndex,1),
+"fill",bU("fill",ArrayFill,1),
+"includes",bU("includes",ArrayIncludes,1),
+]);
+%FinishArrayPrototypeSetup(i.prototype);
+b.SetUpLockedPrototype(j,i(),[
+"indexOf",bU("indexOf",ArrayIndexOf),
+"join",bU("join",ArrayJoin),
+"pop",bU("pop",ArrayPop),
+"push",bU("push",ArrayPush),
+"shift",bU("shift",ArrayShift),
+"sort",bU("sort",ArraySort),
+"splice",bU("splice",ArraySplice)
+]);
+b.SetUpLockedPrototype(k,i(),[
+"join",bU("join",ArrayJoin),
+"pop",bU("pop",ArrayPop),
+"push",bU("push",ArrayPush),
+"shift",bU("shift",ArrayShift)
+]);
+b.SetUpLockedPrototype(c.InternalPackedArray,i(),[
+"push",bU("push",ArrayPush),
+"pop",bU("pop",ArrayPop),
+"shift",bU("shift",ArrayShift),
+"unshift",bU("unshift",ArrayUnshift),
+"splice",bU("splice",ArraySplice),
+"slice",bU("slice",ArraySlice)
+]);
+b.Export(function(aO){
+aO.ArrayFrom=ArrayFrom;
+aO.ArrayIndexOf=ArrayIndexOf;
+aO.ArrayJoin=ArrayJoin;
+aO.ArrayPush=ArrayPush;
+aO.ArrayToString=ArrayToString;
+aO.InnerArrayCopyWithin=InnerArrayCopyWithin;
+aO.InnerArrayEvery=InnerArrayEvery;
+aO.InnerArrayFill=InnerArrayFill;
+aO.InnerArrayFilter=InnerArrayFilter;
+aO.InnerArrayFind=InnerArrayFind;
+aO.InnerArrayFindIndex=InnerArrayFindIndex;
+aO.InnerArrayForEach=InnerArrayForEach;
+aO.InnerArrayIncludes=InnerArrayIncludes;
+aO.InnerArrayIndexOf=InnerArrayIndexOf;
+aO.InnerArrayJoin=InnerArrayJoin;
+aO.InnerArrayLastIndexOf=InnerArrayLastIndexOf;
+aO.InnerArrayReduce=InnerArrayReduce;
+aO.InnerArrayReduceRight=InnerArrayReduceRight;
+aO.InnerArraySome=InnerArraySome;
+aO.InnerArraySort=InnerArraySort;
+aO.InnerArrayToLocaleString=InnerArrayToLocaleString;
+aO.PackedArrayReverse=PackedArrayReverse;
+});
+%InstallToContext([
+"array_pop",ArrayPop,
+"array_push",ArrayPush,
+"array_shift",ArrayShift,
+"array_splice",ArraySplice,
+"array_slice",ArraySlice,
+"array_unshift",ArrayUnshift,
+]);
+});
+
+string:

+(function(a,b){
+%CheckIsBootstrapping();
+var c;
+var d;
+var e=a.RegExp;
+var f=a.String;
+var g=b.InternalArray;
+var h=b.InternalPackedArray;
+var i;
+var j;
+var k;
+var l;
+var m=b.ImportNow("match_symbol");
+var n;
+var o;
+var p;
+var q=b.ImportNow("search_symbol");
+var r=b.ImportNow("split_symbol");
+b.Import(function(s){
+c=s.ArrayIndexOf;
+d=s.ArrayJoin;
+i=s.MakeRangeError;
+j=s.MakeTypeError;
+k=s.MathMax;
+l=s.MathMin;
+n=s.RegExpExec;
+o=s.RegExpExecNoTests;
+p=s.RegExpLastMatchInfo;
+});
+function StringToString(){
+if(!(typeof(this)==='string')&&!(%_ClassOf(this)==='String')){
+throw j(65,'String.prototype.toString');
+}
+return %_ValueOf(this);
+}
+function StringValueOf(){
+if(!(typeof(this)==='string')&&!(%_ClassOf(this)==='String')){
+throw j(65,'String.prototype.valueOf');
+}
+return %_ValueOf(this);
+}
+function StringCharAtJS(t){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.charAt");
+var u=%_StringCharAt(this,t);
+if(%_IsSmi(u)){
+u=%_StringCharAt((%_ToString(this)),(%_ToInteger(t)));
+}
+return u;
+}
+function StringCharCodeAtJS(t){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.charCodeAt");
+var u=%_StringCharCodeAt(this,t);
+if(!%_IsSmi(u)){
+u=%_StringCharCodeAt((%_ToString(this)),(%_ToInteger(t)));
+}
+return u;
+}
+function StringConcat(v){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.concat");
+var w=%_ArgumentsLength();
+var x=(%_ToString(this));
+if(w===1){
+return x+(%_ToString(v));
+}
+var y=new g(w+1);
+y[0]=x;
+for(var z=0;z<w;z++){
+var A=%_Arguments(z);
+y[z+1]=(%_ToString(A));
+}
+return %StringBuilderConcat(y,w+1,"");
+}
+function StringIndexOfJS(B){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.indexOf");
+var C=(%_ToString(this));
+B=(%_ToString(B));
+var D=0;
+if(%_ArgumentsLength()>1){
+D=%_Arguments(1);
+D=(%_ToInteger(D));
+if(D<0)D=0;
+if(D>C.length)D=C.length;
+}
+return %StringIndexOf(C,B,D);
+}
+function StringLastIndexOfJS(E){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.lastIndexOf");
+var F=(%_ToString(this));
+var G=F.length;
+var E=(%_ToString(E));
+var H=E.length;
+var D=G-H;
+if(%_ArgumentsLength()>1){
+var I=(%_ToNumber(%_Arguments(1)));
+if(!(!%_IsSmi(%IS_VAR(I))&&!(I==I))){
+I=(%_ToInteger(I));
+if(I<0){
+I=0;
+}
+if(I+H<G){
+D=I;
+}
+}
+}
+if(D<0){
+return-1;
+}
+return %StringLastIndexOf(F,E,D);
+}
+function StringLocaleCompareJS(v){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.localeCompare");
+return %StringLocaleCompare((%_ToString(this)),(%_ToString(v)));
+}
+function StringMatchJS(B){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.match");
+if(!(B==null)){
+var J=B[m];
+if(!(J===(void 0))){
+return %_Call(J,B,this);
+}
+}
+var C=(%_ToString(this));
+var K=new e(B);
+return o(K,C,0);
+}
+function StringNormalizeJS(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.normalize");
+var L=(%_ToString(this));
+var M=%_Arguments(0);
+var N=(M===(void 0))?'NFC':(%_ToString(M));
+var O=['NFC','NFD','NFKC','NFKD'];
+var P=%_Call(c,O,N);
+if(P===-1){
+throw i(184,
+%_Call(d,O,', '));
+}
+return L;
+}
+var Q=[2,"","",-1,-1];
+function StringReplace(R,S){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.replace");
+var C=(%_ToString(this));
+if((%_IsRegExp(R))){
+if(!(typeof(S)==='function')){
+S=(%_ToString(S));
+if(!(%_RegExpFlags(R)&1)){
+var T=n(R,C,0);
+if(T==null){
+R.lastIndex=0
+return C;
+}
+if(S.length==0){
+return %_SubString(C,0,T[3])+
+%_SubString(C,T[4],C.length)
+}
+return ExpandReplacement(S,C,p,
+%_SubString(C,0,T[3]))+
+%_SubString(C,T[4],C.length);
+}
+R.lastIndex=0;
+return %StringReplaceGlobalRegExpWithString(
+C,R,S,p);
+}
+if((%_RegExpFlags(R)&1)){
+return StringReplaceGlobalRegExpWithFunction(C,R,S);
+}
+return StringReplaceNonGlobalRegExpWithFunction(C,R,S);
+}
+R=(%_ToString(R));
+if(R.length==1&&
+C.length>0xFF&&
+(typeof(S)==='string')&&
+%StringIndexOf(S,'$',0)<0){
+return %StringReplaceOneCharWithString(C,R,S);
+}
+var U=%StringIndexOf(C,R,0);
+if(U<0)return C;
+var V=U+R.length;
+var u=%_SubString(C,0,U);
+if((typeof(S)==='function')){
+u+=S(R,U,C);
+}else{
+Q[3]=U;
+Q[4]=V;
+u=ExpandReplacement((%_ToString(S)),
+C,
+Q,
+u);
+}
+return u+%_SubString(C,V,C.length);
+}
+function ExpandReplacement(W,C,X,u){
+var Y=W.length;
+var Z=%StringIndexOf(W,'$',0);
+if(Z<0){
+if(Y>0)u+=W;
+return u;
+}
+if(Z>0)u+=%_SubString(W,0,Z);
+while(true){
+var aa='$';
+var I=Z+1;
+if(I<Y){
+var ab=%_StringCharCodeAt(W,I);
+if(ab==36){
+++I;
+u+='$';
+}else if(ab==38){
+++I;
+u+=
+%_SubString(C,X[3],X[4]);
+}else if(ab==96){
+++I;
+u+=%_SubString(C,0,X[3]);
+}else if(ab==39){
+++I;
+u+=%_SubString(C,X[4],C.length);
+}else if(ab>=48&&ab<=57){
+var ac=(ab-48)<<1;
+var ad=1;
+var ae=((X)[0]);
+if(I+1<W.length){
+var Z=%_StringCharCodeAt(W,I+1);
+if(Z>=48&&Z<=57){
+var af=ac*10+((Z-48)<<1);
+if(af<ae){
+ac=af;
+ad=2;
+}
+}
+}
+if(ac!=0&&ac<ae){
+var U=X[(3+(ac))];
+if(U>=0){
+u+=
+%_SubString(C,U,X[(3+(ac+1))]);
+}
+I+=ad;
+}else{
+u+='$';
+}
+}else{
+u+='$';
+}
+}else{
+u+='$';
+}
+Z=%StringIndexOf(W,'$',I);
+if(Z<0){
+if(I<Y){
+u+=%_SubString(W,I,Y);
+}
+return u;
+}
+if(Z>I){
+u+=%_SubString(W,I,Z);
+}
+}
+return u;
+}
+function CaptureString(W,ag,D){
+var ah=D<<1;
+var U=ag[(3+(ah))];
+if(U<0)return;
+var V=ag[(3+(ah+1))];
+return %_SubString(W,U,V);
+}
+var ai=new g(4);
+function StringReplaceGlobalRegExpWithFunction(C,K,S){
+var aj=ai;
+if(aj){
+ai=null;
+}else{
+aj=new g(16);
+}
+var ak=%RegExpExecMultiple(K,
+C,
+p,
+aj);
+K.lastIndex=0;
+if((ak===null)){
+ai=aj;
+return C;
+}
+var w=ak.length;
+if(((p)[0])==2){
+var al=0;
+for(var z=0;z<w;z++){
+var am=ak[z];
+if(%_IsSmi(am)){
+if(am>0){
+al=(am>>11)+(am&0x7ff);
+}else{
+al=ak[++z]-am;
+}
+}else{
+var an=S(am,al,C);
+ak[z]=(%_ToString(an));
+al+=am.length;
+}
+}
+}else{
+for(var z=0;z<w;z++){
+var am=ak[z];
+if(!%_IsSmi(am)){
+var an=%Apply(S,(void 0),am,0,am.length);
+ak[z]=(%_ToString(an));
+}
+}
+}
+var u=%StringBuilderConcat(ak,w,C);
+aj.length=0;
+ai=aj;
+return u;
+}
+function StringReplaceNonGlobalRegExpWithFunction(C,K,S){
+var X=n(K,C,0);
+if((X===null)){
+K.lastIndex=0;
+return C;
+}
+var D=X[3];
+var u=%_SubString(C,0,D);
+var ao=X[4];
+var ap=((X)[0])>>1;
+var aq;
+if(ap==1){
+var L=%_SubString(C,D,ao);
+aq=S(L,D,C);
+}else{
+var ar=new g(ap+2);
+for(var as=0;as<ap;as++){
+ar[as]=CaptureString(C,X,as);
+}
+ar[as]=D;
+ar[as+1]=C;
+aq=%Apply(S,(void 0),ar,0,as+2);
+}
+u+=aq;
+return u+%_SubString(C,ao,C.length);
+}
+function StringSearch(B){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.search");
+if(!(B==null)){
+var at=B[q];
+if(!(at===(void 0))){
+return %_Call(at,B,this);
+}
+}
+var C=(%_ToString(this));
+var K=new e(B);
+return %_Call(K[q],K,C);
+}
+function StringSlice(U,V){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.slice");
+var L=(%_ToString(this));
+var au=L.length;
+var av=(%_ToInteger(U));
+var aw=au;
+if(!(V===(void 0))){
+aw=(%_ToInteger(V));
+}
+if(av<0){
+av+=au;
+if(av<0){
+av=0;
+}
+}else{
+if(av>au){
+return'';
+}
+}
+if(aw<0){
+aw+=au;
+if(aw<0){
+return'';
+}
+}else{
+if(aw>au){
+aw=au;
+}
+}
+if(aw<=av){
+return'';
+}
+return %_SubString(L,av,aw);
+}
+function StringSplitJS(ax,ay){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.split");
+if(!(ax==null)){
+var az=ax[r];
+if(!(az===(void 0))){
+return %_Call(az,ax,this,ay);
+}
+}
+var C=(%_ToString(this));
+ay=((ay===(void 0)))?4294967295:((ay)>>>0);
+var Y=C.length;
+var aA=(%_ToString(ax));
+if(ay===0)return[];
+if((ax===(void 0)))return[C];
+var aB=aA.length;
+if(aB===0)return %StringToArray(C,ay);
+return %StringSplit(C,aA,ay);
+}
+function StringSubstring(U,V){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.subString");
+var L=(%_ToString(this));
+var au=L.length;
+var av=(%_ToInteger(U));
+if(av<0){
+av=0;
+}else if(av>au){
+av=au;
+}
+var aw=au;
+if(!(V===(void 0))){
+aw=(%_ToInteger(V));
+if(aw>au){
+aw=au;
+}else{
+if(aw<0)aw=0;
+if(av>aw){
+var aC=aw;
+aw=av;
+av=aC;
+}
+}
+}
+return %_SubString(L,av,aw);
+}
+function StringSubstr(U,aD){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.substr");
+var L=(%_ToString(this));
+var w;
+if((aD===(void 0))){
+w=L.length;
+}else{
+w=(%_ToInteger(aD));
+if(w<=0)return'';
+}
+if((U===(void 0))){
+U=0;
+}else{
+U=(%_ToInteger(U));
+if(U>=L.length)return'';
+if(U<0){
+U+=L.length;
+if(U<0)U=0;
+}
+}
+var V=U+w;
+if(V>L.length)V=L.length;
+return %_SubString(L,U,V);
+}
+function StringToLowerCaseJS(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.toLowerCase");
+return %StringToLowerCase((%_ToString(this)));
+}
+function StringToLocaleLowerCase(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.toLocaleLowerCase");
+return %StringToLowerCase((%_ToString(this)));
+}
+function StringToUpperCaseJS(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.toUpperCase");
+return %StringToUpperCase((%_ToString(this)));
+}
+function StringToLocaleUpperCase(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.toLocaleUpperCase");
+return %StringToUpperCase((%_ToString(this)));
+}
+function StringTrimJS(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.trim");
+return %StringTrim((%_ToString(this)),true,true);
+}
+function StringTrimLeft(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.trimLeft");
+return %StringTrim((%_ToString(this)),true,false);
+}
+function StringTrimRight(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.trimRight");
+return %StringTrim((%_ToString(this)),false,true);
+}
+function StringFromCharCode(aE){
+var aD=%_ArgumentsLength();
+if(aD==1)return %_StringCharFromCode(aE&0xffff);
+var aF=%NewString(aD,true);
+var z;
+for(z=0;z<aD;z++){
+aE=%_Arguments(z)&0xffff;
+if(aE>0xff)break;
+%_OneByteSeqStringSetChar(z,aE,aF);
+}
+if(z==aD)return aF;
+aF=%TruncateString(aF,z);
+var aG=%NewString(aD-z,false);
+%_TwoByteSeqStringSetChar(0,aE,aG);
+z++;
+for(var as=1;z<aD;z++,as++){
+aE=%_Arguments(z)&0xffff;
+%_TwoByteSeqStringSetChar(as,aE,aG);
+}
+return aF+aG;
+}
+function HtmlEscape(aH){
+return %_Call(StringReplace,(%_ToString(aH)),/"/g,"&quot;");
+}
+function StringAnchor(aI){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.anchor");
+return"<a name=\""+HtmlEscape(aI)+"\">"+(%_ToString(this))+
+"</a>";
+}
+function StringBig(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.big");
+return"<big>"+(%_ToString(this))+"</big>";
+}
+function StringBlink(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.blink");
+return"<blink>"+(%_ToString(this))+"</blink>";
+}
+function StringBold(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.bold");
+return"<b>"+(%_ToString(this))+"</b>";
+}
+function StringFixed(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.fixed");
+return"<tt>"+(%_ToString(this))+"</tt>";
+}
+function StringFontcolor(aJ){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.fontcolor");
+return"<font color=\""+HtmlEscape(aJ)+"\">"+(%_ToString(this))+
+"</font>";
+}
+function StringFontsize(aK){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.fontsize");
+return"<font size=\""+HtmlEscape(aK)+"\">"+(%_ToString(this))+
+"</font>";
+}
+function StringItalics(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.italics");
+return"<i>"+(%_ToString(this))+"</i>";
+}
+function StringLink(L){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.link");
+return"<a href=\""+HtmlEscape(L)+"\">"+(%_ToString(this))+"</a>";
+}
+function StringSmall(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.small");
+return"<small>"+(%_ToString(this))+"</small>";
+}
+function StringStrike(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.strike");
+return"<strike>"+(%_ToString(this))+"</strike>";
+}
+function StringSub(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.sub");
+return"<sub>"+(%_ToString(this))+"</sub>";
+}
+function StringSup(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.sup");
+return"<sup>"+(%_ToString(this))+"</sup>";
+}
+function StringRepeat(aL){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.repeat");
+var L=(%_ToString(this));
+var aD=(%_ToInteger(aL));
+if(aD<0||aD===(1/0))throw i(168);
+if(L.length===0)return"";
+if(aD>%_MaxSmi())throw i(168);
+var aM="";
+while(true){
+if(aD&1)aM+=L;
+aD>>=1;
+if(aD===0)return aM;
+L+=L;
+}
+}
+function StringStartsWith(aN){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.startsWith");
+var L=(%_ToString(this));
+if((%_IsRegExp(aN))){
+throw j(38,"String.prototype.startsWith");
+}
+var aO=(%_ToString(aN));
+var t=0;
+if(%_ArgumentsLength()>1){
+var aP=%_Arguments(1);
+if(!(aP===(void 0))){
+t=(%_ToInteger(aP));
+}
+}
+var au=L.length;
+var U=l(k(t,0),au);
+var aQ=aO.length;
+if(aQ+U>au){
+return false;
+}
+return %_SubString(L,U,U+aQ)===aO;
+}
+function StringEndsWith(aN){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.endsWith");
+var L=(%_ToString(this));
+if((%_IsRegExp(aN))){
+throw j(38,"String.prototype.endsWith");
+}
+var aO=(%_ToString(aN));
+var au=L.length;
+var t=au;
+if(%_ArgumentsLength()>1){
+var aP=%_Arguments(1);
+if(!(aP===(void 0))){
+t=(%_ToInteger(aP));
+}
+}
+var V=l(k(t,0),au);
+var aQ=aO.length;
+var U=V-aQ;
+if(U<0){
+return false;
+}
+return %_SubString(L,U,U+aQ)===aO;
+}
+function StringIncludes(aN){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.includes");
+var W=(%_ToString(this));
+if((%_IsRegExp(aN))){
+throw j(38,"String.prototype.includes");
+}
+aN=(%_ToString(aN));
+var t=0;
+if(%_ArgumentsLength()>1){
+t=%_Arguments(1);
+t=(%_ToInteger(t));
+}
+var aR=W.length;
+if(t<0)t=0;
+if(t>aR)t=aR;
+var aS=aN.length;
+if(aS+t>aR){
+return false;
+}
+return %StringIndexOf(W,aN,t)!==-1;
+}
+function StringCodePointAt(t){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.codePointAt");
+var W=(%_ToString(this));
+var aK=W.length;
+t=(%_ToInteger(t));
+if(t<0||t>=aK){
+return(void 0);
+}
+var aT=%_StringCharCodeAt(W,t);
+if(aT<0xD800||aT>0xDBFF||t+1==aK){
+return aT;
+}
+var aU=%_StringCharCodeAt(W,t+1);
+if(aU<0xDC00||aU>0xDFFF){
+return aT;
+}
+return(aT-0xD800)*0x400+aU+0x2400;
+}
+function StringFromCodePoint(aV){
+var aE;
+var Y=%_ArgumentsLength();
+var D;
+var u="";
+for(D=0;D<Y;D++){
+aE=%_Arguments(D);
+if(!%_IsSmi(aE)){
+aE=(%_ToNumber(aE));
+}
+if(aE<0||aE>0x10FFFF||aE!==(%_ToInteger(aE))){
+throw i(167,aE);
+}
+if(aE<=0xFFFF){
+u+=%_StringCharFromCode(aE);
+}else{
+aE-=0x10000;
+u+=%_StringCharFromCode((aE>>>10)&0x3FF|0xD800);
+u+=%_StringCharFromCode(aE&0x3FF|0xDC00);
+}
+}
+return u;
+}
+function StringRaw(aW){
+var aX=%_ArgumentsLength();
+var aY=(%_ToObject(aW));
+var aZ=(%_ToObject(aY.raw));
+var ba=(%_ToLength(aZ.length));
+if(ba<=0)return"";
+var u=(%_ToString(aZ[0]));
+for(var z=1;z<ba;++z){
+if(z<aX){
+u+=(%_ToString(%_Arguments(z)));
+}
+u+=(%_ToString(aZ[z]));
+}
+return u;
+}
+%FunctionSetPrototype(f,new f());
+%AddNamedProperty(
+f.prototype,"constructor",f,2);
+b.InstallFunctions(f,2,[
+"fromCharCode",StringFromCharCode,
+"fromCodePoint",StringFromCodePoint,
+"raw",StringRaw
+]);
+b.InstallFunctions(f.prototype,2,[
+"valueOf",StringValueOf,
+"toString",StringToString,
+"charAt",StringCharAtJS,
+"charCodeAt",StringCharCodeAtJS,
+"codePointAt",StringCodePointAt,
+"concat",StringConcat,
+"endsWith",StringEndsWith,
+"includes",StringIncludes,
+"indexOf",StringIndexOfJS,
+"lastIndexOf",StringLastIndexOfJS,
+"localeCompare",StringLocaleCompareJS,
+"match",StringMatchJS,
+"normalize",StringNormalizeJS,
+"repeat",StringRepeat,
+"replace",StringReplace,
+"search",StringSearch,
+"slice",StringSlice,
+"split",StringSplitJS,
+"substring",StringSubstring,
+"substr",StringSubstr,
+"startsWith",StringStartsWith,
+"toLowerCase",StringToLowerCaseJS,
+"toLocaleLowerCase",StringToLocaleLowerCase,
+"toUpperCase",StringToUpperCaseJS,
+"toLocaleUpperCase",StringToLocaleUpperCase,
+"trim",StringTrimJS,
+"trimLeft",StringTrimLeft,
+"trimRight",StringTrimRight,
+"link",StringLink,
+"anchor",StringAnchor,
+"fontcolor",StringFontcolor,
+"fontsize",StringFontsize,
+"big",StringBig,
+"blink",StringBlink,
+"bold",StringBold,
+"fixed",StringFixed,
+"italics",StringItalics,
+"small",StringSmall,
+"strike",StringStrike,
+"sub",StringSub,
+"sup",StringSup
+]);
+b.Export(function(bb){
+bb.StringCharAt=StringCharAtJS;
+bb.StringIndexOf=StringIndexOfJS;
+bb.StringLastIndexOf=StringLastIndexOfJS;
+bb.StringMatch=StringMatchJS;
+bb.StringReplace=StringReplace;
+bb.StringSlice=StringSlice;
+bb.StringSplit=StringSplitJS;
+bb.StringSubstr=StringSubstr;
+bb.StringSubstring=StringSubstring;
+});
+})
+
+uri1U
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Object;
+var d=a.Array;
+var e=b.InternalArray;
+var f;
+b.Import(function(g){
+f=g.MakeURIError;
+});
+function HexValueOf(h){
+if(h>=48&&h<=57)return h-48;
+if(h>=65&&h<=70)return h-55;
+if(h>=97&&h<=102)return h-87;
+return-1;
+}
+function isAlphaNumeric(i){
+if(97<=i&&i<=122)return true;
+if(65<=i&&i<=90)return true;
+if(48<=i&&i<=57)return true;
+return false;
+}
+var j=0;
+function URIAddEncodedOctetToBuffer(k,l,m){
+l[m++]=37;
+l[m++]=j[k>>4];
+l[m++]=j[k&0x0F];
+return m;
+}
+function URIEncodeOctets(n,l,m){
+if(j===0){
+j=[48,49,50,51,52,53,54,55,56,57,
+65,66,67,68,69,70];
+}
+m=URIAddEncodedOctetToBuffer(n[0],l,m);
+if(n[1])m=URIAddEncodedOctetToBuffer(n[1],l,m);
+if(n[2])m=URIAddEncodedOctetToBuffer(n[2],l,m);
+if(n[3])m=URIAddEncodedOctetToBuffer(n[3],l,m);
+return m;
+}
+function URIEncodeSingle(i,l,m){
+var o=(i>>12)&0xF;
+var p=(i>>6)&63;
+var q=i&63;
+var n=new d(3);
+if(i<=0x007F){
+n[0]=i;
+}else if(i<=0x07FF){
+n[0]=p+192;
+n[1]=q+128;
+}else{
+n[0]=o+224;
+n[1]=p+128;
+n[2]=q+128;
+}
+return URIEncodeOctets(n,l,m);
+}
+function URIEncodePair(r,s,l,m){
+var t=((r>>6)&0xF)+1;
+var u=(r>>2)&0xF;
+var o=r&3;
+var p=(s>>6)&0xF;
+var q=s&63;
+var n=new d(4);
+n[0]=(t>>2)+240;
+n[1]=(((t&3)<<4)|u)+128;
+n[2]=((o<<4)|p)+128;
+n[3]=q+128;
+return URIEncodeOctets(n,l,m);
+}
+function URIHexCharsToCharCode(v,w){
+var x=HexValueOf(v);
+var y=HexValueOf(w);
+if(x==-1||y==-1)throw f();
+return(x<<4)|y;
+}
+function URIDecodeOctets(n,l,m){
+var z;
+var A=n[0];
+if(A<0x80){
+z=A;
+}else if(A<0xc2){
+throw f();
+}else{
+var B=n[1];
+if(A<0xe0){
+var C=A&0x1f;
+if((B<0x80)||(B>0xbf))throw f();
+var D=B&0x3f;
+z=(C<<6)+D;
+if(z<0x80||z>0x7ff)throw f();
+}else{
+var E=n[2];
+if(A<0xf0){
+var C=A&0x0f;
+if((B<0x80)||(B>0xbf))throw f();
+var D=B&0x3f;
+if((E<0x80)||(E>0xbf))throw f();
+var F=E&0x3f;
+z=(C<<12)+(D<<6)+F;
+if((z<0x800)||(z>0xffff))throw f();
+}else{
+var G=n[3];
+if(A<0xf8){
+var C=(A&0x07);
+if((B<0x80)||(B>0xbf))throw f();
+var D=(B&0x3f);
+if((E<0x80)||(E>0xbf)){
+throw f();
+}
+var F=(E&0x3f);
+if((G<0x80)||(G>0xbf))throw f();
+var H=(G&0x3f);
+z=(C<<18)+(D<<12)+(F<<6)+H;
+if((z<0x10000)||(z>0x10ffff))throw f();
+}else{
+throw f();
+}
+}
+}
+}
+if(0xD800<=z&&z<=0xDFFF)throw f();
+if(z<0x10000){
+%_TwoByteSeqStringSetChar(m++,z,l);
+}else{
+%_TwoByteSeqStringSetChar(m++,(z>>10)+0xd7c0,l);
+%_TwoByteSeqStringSetChar(m++,(z&0x3ff)+0xdc00,l);
+}
+return m;
+}
+function Encode(I,J){
+I=(%_ToString(I));
+var K=I.length;
+var L=new e(K);
+var m=0;
+for(var M=0;M<K;M++){
+var r=%_StringCharCodeAt(I,M);
+if(J(r)){
+L[m++]=r;
+}else{
+if(r>=0xDC00&&r<=0xDFFF)throw f();
+if(r<0xD800||r>0xDBFF){
+m=URIEncodeSingle(r,L,m);
+}else{
+M++;
+if(M==K)throw f();
+var s=%_StringCharCodeAt(I,M);
+if(s<0xDC00||s>0xDFFF)throw f();
+m=URIEncodePair(r,s,L,m);
+}
+}
+}
+var l=%NewString(L.length,true);
+for(var N=0;N<L.length;N++){
+%_OneByteSeqStringSetChar(N,L[N],l);
+}
+return l;
+}
+function Decode(I,O){
+I=(%_ToString(I));
+var K=I.length;
+var P=%NewString(K,true);
+var m=0;
+var M=0;
+for(;M<K;M++){
+var h=%_StringCharCodeAt(I,M);
+if(h==37){
+if(M+2>=K)throw f();
+var i=URIHexCharsToCharCode(%_StringCharCodeAt(I,M+1),
+%_StringCharCodeAt(I,M+2));
+if(i>>7)break;
+if(O(i)){
+%_OneByteSeqStringSetChar(m++,37,P);
+%_OneByteSeqStringSetChar(m++,%_StringCharCodeAt(I,M+1),
+P);
+%_OneByteSeqStringSetChar(m++,%_StringCharCodeAt(I,M+2),
+P);
+}else{
+%_OneByteSeqStringSetChar(m++,i,P);
+}
+M+=2;
+}else{
+if(h>0x7f)break;
+%_OneByteSeqStringSetChar(m++,h,P);
+}
+}
+P=%TruncateString(P,m);
+if(M==K)return P;
+var Q=%NewString(K-M,false);
+m=0;
+for(;M<K;M++){
+var h=%_StringCharCodeAt(I,M);
+if(h==37){
+if(M+2>=K)throw f();
+var i=URIHexCharsToCharCode(%_StringCharCodeAt(I,++M),
+%_StringCharCodeAt(I,++M));
+if(i>>7){
+var R=0;
+while(((i<<++R)&0x80)!=0){}
+if(R==1||R>4)throw f();
+var n=new d(R);
+n[0]=i;
+if(M+3*(R-1)>=K)throw f();
+for(var N=1;N<R;N++){
+if(I[++M]!='%')throw f();
+n[N]=URIHexCharsToCharCode(%_StringCharCodeAt(I,++M),
+%_StringCharCodeAt(I,++M));
+}
+m=URIDecodeOctets(n,Q,m);
+}else if(O(i)){
+%_TwoByteSeqStringSetChar(m++,37,Q);
+%_TwoByteSeqStringSetChar(m++,%_StringCharCodeAt(I,M-1),
+Q);
+%_TwoByteSeqStringSetChar(m++,%_StringCharCodeAt(I,M),
+Q);
+}else{
+%_TwoByteSeqStringSetChar(m++,i,Q);
+}
+}else{
+%_TwoByteSeqStringSetChar(m++,h,Q);
+}
+}
+Q=%TruncateString(Q,m);
+return P+Q;
+}
+function URIEscapeJS(S){
+return %URIEscape(S);
+}
+function URIUnescapeJS(S){
+return %URIUnescape(S);
+}
+function URIDecode(I){
+var T=function(i){
+if(35<=i&&i<=36)return true;
+if(i==38)return true;
+if(43<=i&&i<=44)return true;
+if(i==47)return true;
+if(58<=i&&i<=59)return true;
+if(i==61)return true;
+if(63<=i&&i<=64)return true;
+return false;
+};
+return Decode(I,T);
+}
+function URIDecodeComponent(U){
+var T=function(i){return false;};
+return Decode(U,T);
+}
+function URIEncode(I){
+var V=function(i){
+if(isAlphaNumeric(i))return true;
+if(i==33)return true;
+if(35<=i&&i<=36)return true;
+if(38<=i&&i<=47)return true;
+if(58<=i&&i<=59)return true;
+if(i==61)return true;
+if(63<=i&&i<=64)return true;
+if(i==95)return true;
+if(i==126)return true;
+return false;
+};
+return Encode(I,V);
+}
+function URIEncodeComponent(U){
+var V=function(i){
+if(isAlphaNumeric(i))return true;
+if(i==33)return true;
+if(39<=i&&i<=42)return true;
+if(45<=i&&i<=46)return true;
+if(i==95)return true;
+if(i==126)return true;
+return false;
+};
+return Encode(U,V);
+}
+b.InstallFunctions(a,2,[
+"escape",URIEscapeJS,
+"unescape",URIUnescapeJS,
+"decodeURI",URIDecode,
+"decodeURIComponent",URIDecodeComponent,
+"encodeURI",URIEncode,
+"encodeURIComponent",URIEncodeComponent
+]);
+})
+
+math�J
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Float64Array;
+var d=a.Math;
+var e=a.Object;
+var f=b.InternalArray;
+var g=%GetRootNaN();
+var h=64;
+var i=(void 0);
+var j=b.ImportNow("to_string_tag_symbol");
+function MathAbs(k){
+k=+k;
+return(k>0)?k:0-k;
+}
+function MathAcosJS(k){
+return %_MathAcos(+k);
+}
+function MathAsinJS(k){
+return %_MathAsin(+k);
+}
+function MathAtanJS(k){
+return %_MathAtan(+k);
+}
+function MathAtan2JS(l,k){
+l=+l;
+k=+k;
+return %_MathAtan2(l,k);
+}
+function MathCeil(k){
+return-%_MathFloor(-k);
+}
+function MathExp(k){
+return %MathExpRT((%_ToNumber(k)));
+}
+function MathFloorJS(k){
+return %_MathFloor(+k);
+}
+function MathLog(k){
+return %_MathLogRT((%_ToNumber(k)));
+}
+function MathMax(m,n){
+var o=%_ArgumentsLength();
+if(o==2){
+m=(%_ToNumber(m));
+n=(%_ToNumber(n));
+if(n>m)return n;
+if(m>n)return m;
+if(m==n){
+return(m===0&&%_IsMinusZero(m))?n:m;
+}
+return g;
+}
+var p=-(1/0);
+for(var q=0;q<o;q++){
+var r=%_Arguments(q);
+r=(%_ToNumber(r));
+if((!%_IsSmi(%IS_VAR(r))&&!(r==r))||r>p||(p===0&&r===0&&%_IsMinusZero(p))){
+p=r;
+}
+}
+return p;
+}
+function MathMin(m,n){
+var o=%_ArgumentsLength();
+if(o==2){
+m=(%_ToNumber(m));
+n=(%_ToNumber(n));
+if(n>m)return m;
+if(m>n)return n;
+if(m==n){
+return(m===0&&%_IsMinusZero(m))?m:n;
+}
+return g;
+}
+var p=(1/0);
+for(var q=0;q<o;q++){
+var r=%_Arguments(q);
+r=(%_ToNumber(r));
+if((!%_IsSmi(%IS_VAR(r))&&!(r==r))||r<p||(p===0&&r===0&&%_IsMinusZero(r))){
+p=r;
+}
+}
+return p;
+}
+function MathPowJS(k,l){
+return %_MathPow((%_ToNumber(k)),(%_ToNumber(l)));
+}
+function MathRandom(){
+if(h>=64){
+i=%GenerateRandomNumbers(i);
+h=2;
+}
+return i[h++];
+}
+function MathRandomRaw(){
+if(h>=64){
+i=%GenerateRandomNumbers(i);
+h=2;
+}
+return %_DoubleLo(i[h++])&0x3FFFFFFF;
+}
+function MathRound(k){
+return %RoundNumber((%_ToNumber(k)));
+}
+function MathSqrtJS(k){
+return %_MathSqrt(+k);
+}
+function MathImul(k,l){
+return %NumberImul((%_ToNumber(k)),(%_ToNumber(l)));
+}
+function MathSign(k){
+k=+k;
+if(k>0)return 1;
+if(k<0)return-1;
+return k;
+}
+function MathTrunc(k){
+k=+k;
+if(k>0)return %_MathFloor(k);
+if(k<0)return-%_MathFloor(-k);
+return k;
+}
+function MathAsinh(k){
+k=(%_ToNumber(k));
+if(k===0||!(%_IsSmi(%IS_VAR(k))||((k==k)&&(k!=1/0)&&(k!=-1/0))))return k;
+if(k>0)return MathLog(k+%_MathSqrt(k*k+1));
+return-MathLog(-k+%_MathSqrt(k*k+1));
+}
+function MathAcosh(k){
+k=(%_ToNumber(k));
+if(k<1)return g;
+if(!(%_IsSmi(%IS_VAR(k))||((k==k)&&(k!=1/0)&&(k!=-1/0))))return k;
+return MathLog(k+%_MathSqrt(k+1)*%_MathSqrt(k-1));
+}
+function MathAtanh(k){
+k=(%_ToNumber(k));
+if(k===0)return k;
+if(!(%_IsSmi(%IS_VAR(k))||((k==k)&&(k!=1/0)&&(k!=-1/0))))return g;
+return 0.5*MathLog((1+k)/(1-k));
+}
+function MathHypot(k,l){
+var o=%_ArgumentsLength();
+var s=new f(o);
+var t=0;
+for(var q=0;q<o;q++){
+var r=%_Arguments(q);
+r=(%_ToNumber(r));
+if(r===(1/0)||r===-(1/0))return(1/0);
+r=MathAbs(r);
+if(r>t)t=r;
+s[q]=r;
+}
+if(t===0)t=1;
+var u=0;
+var v=0;
+for(var q=0;q<o;q++){
+var r=s[q]/t;
+var w=r*r-v;
+var x=u+w;
+v=(x-u)-w;
+u=x;
+}
+return %_MathSqrt(u)*t;
+}
+function MathFroundJS(k){
+return %MathFround((%_ToNumber(k)));
+}
+function MathClz32JS(k){
+return %_MathClz32(k>>>0);
+}
+function MathCbrt(k){
+k=(%_ToNumber(k));
+if(k==0||!(%_IsSmi(%IS_VAR(k))||((k==k)&&(k!=1/0)&&(k!=-1/0))))return k;
+return k>=0?CubeRoot(k):-CubeRoot(-k);
+}
+function CubeRoot(k){
+var y=MathFloorJS(%_DoubleHi(k)/3)+0x2A9F7893;
+var z=%_ConstructDouble(y|0,0);
+z=(1.0/3.0)*(k/(z*z)+2*z);
+;
+z=(1.0/3.0)*(k/(z*z)+2*z);
+;
+z=(1.0/3.0)*(k/(z*z)+2*z);
+;
+return(1.0/3.0)*(k/(z*z)+2*z);
+;
+}
+%AddNamedProperty(d,j,"Math",1|2);
+b.InstallConstants(d,[
+"E",2.7182818284590452354,
+"LN10",2.302585092994046,
+"LN2",0.6931471805599453,
+"LOG2E",1.4426950408889634,
+"LOG10E",0.4342944819032518,
+"PI",3.1415926535897932,
+"SQRT1_2",0.7071067811865476,
+"SQRT2",1.4142135623730951
+]);
+b.InstallFunctions(d,2,[
+"random",MathRandom,
+"abs",MathAbs,
+"acos",MathAcosJS,
+"asin",MathAsinJS,
+"atan",MathAtanJS,
+"ceil",MathCeil,
+"exp",MathExp,
+"floor",MathFloorJS,
+"log",MathLog,
+"round",MathRound,
+"sqrt",MathSqrtJS,
+"atan2",MathAtan2JS,
+"pow",MathPowJS,
+"max",MathMax,
+"min",MathMin,
+"imul",MathImul,
+"sign",MathSign,
+"trunc",MathTrunc,
+"asinh",MathAsinh,
+"acosh",MathAcosh,
+"atanh",MathAtanh,
+"hypot",MathHypot,
+"fround",MathFroundJS,
+"clz32",MathClz32JS,
+"cbrt",MathCbrt
+]);
+%SetForceInlineFlag(MathAbs);
+%SetForceInlineFlag(MathAcosJS);
+%SetForceInlineFlag(MathAsinJS);
+%SetForceInlineFlag(MathAtanJS);
+%SetForceInlineFlag(MathAtan2JS);
+%SetForceInlineFlag(MathCeil);
+%SetForceInlineFlag(MathClz32JS);
+%SetForceInlineFlag(MathFloorJS);
+%SetForceInlineFlag(MathRandom);
+%SetForceInlineFlag(MathSign);
+%SetForceInlineFlag(MathSqrtJS);
+%SetForceInlineFlag(MathTrunc);
+b.Export(function(A){
+A.MathAbs=MathAbs;
+A.MathExp=MathExp;
+A.MathFloor=MathFloorJS;
+A.IntRandom=MathRandomRaw;
+A.MathMax=MathMax;
+A.MathMin=MathMin;
+});
+})
+
+fdlibm��
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Float64Array;
+var d=a.Math;
+var e;
+var f;
+var g=%GetRootNaN();
+var h;
+b.Import(function(i){
+e=i.MathAbs;
+f=i.MathExp;
+});
+b.CreateDoubleResultArray=function(a){
+h=new c(2);
+};
+function KernelTan(j,k,l){
+var m;
+var n;
+var o=%_DoubleHi(j);
+var p=o&0x7fffffff;
+if(p<0x3e300000){
+if(((p|%_DoubleLo(j))|(l+1))==0){
+return 1/e(j);
+}else{
+if(l==1){
+return j;
+}else{
+var n=j+k;
+var m=%_ConstructDouble(%_DoubleHi(n),0);
+var q=k-(m-j);
+var r=-1/n;
+var s=%_ConstructDouble(%_DoubleHi(r),0);
+var t=1+s*m;
+return s+r*(t+s*q);
+}
+}
+}
+if(p>=0x3fe59428){
+if(j<0){
+j=-j;
+k=-k;
+}
+m=7.85398163397448278999e-01-j;
+n=3.06161699786838301793e-17-k;
+j=m+n;
+k=0;
+}
+m=j*j;
+n=m*m;
+var u=1.33333333333201242699e-01+n*(2.18694882948595424599e-02+n*(3.59207910759131235356e-03+
+n*(5.88041240820264096874e-04+n*(7.81794442939557092300e-05+n*-1.85586374855275456654e-05))));
+var q=m*(5.39682539762260521377e-02+n*(8.86323982359930005737e-03+n*(1.45620945432529025516e-03+
+n*(2.46463134818469906812e-04+n*(7.14072491382608190305e-05+n*2.59073051863633712884e-05)))));
+var t=m*j;
+u=k+m*(t*(u+q)+k);
+u=u+3.33333333333334091986e-01*t;
+n=j+u;
+if(p>=0x3fe59428){
+return(1-((o>>30)&2))*
+(l-2.0*(j-(n*n/(n+l)-u)));
+}
+if(l==1){
+return n;
+}else{
+m=%_ConstructDouble(%_DoubleHi(n),0);
+q=u-(m-j);
+var r=-1/n;
+var s=%_ConstructDouble(%_DoubleHi(r),0);
+t=1+s*m;
+return s+r*(t+s*q);
+}
+}
+function MathSinSlow(j){
+var v,w,x;
+var o=%_DoubleHi(j);
+var p=o&0x7fffffff;
+if(p<0x4002d97c){
+if(o>0){
+var m=j-1.57079632673412561417;
+if(p!=0x3ff921fb){
+w=m-6.07710050650619224932e-11;
+x=(m-w)-6.07710050650619224932e-11;
+}else{
+m-=6.07710050630396597660e-11;
+w=m-2.02226624879595063154e-21;
+x=(m-w)-2.02226624879595063154e-21;
+}
+v=1;
+}else{
+var m=j+1.57079632673412561417;
+if(p!=0x3ff921fb){
+w=m+6.07710050650619224932e-11;
+x=(m-w)+6.07710050650619224932e-11;
+}else{
+m+=6.07710050630396597660e-11;
+w=m+2.02226624879595063154e-21;
+x=(m-w)+2.02226624879595063154e-21;
+}
+v=-1;
+}
+}else if(p<=0x413921fb){
+var s=e(j);
+v=(s*6.36619772367581382433e-01+0.5)|0;
+var u=s-v*1.57079632673412561417;
+var n=v*6.07710050650619224932e-11;
+w=u-n;
+if(p-(%_DoubleHi(w)&0x7ff00000)>0x1000000){
+s=u;
+n=v*6.07710050630396597660e-11;
+u=s-n;
+n=v*2.02226624879595063154e-21-((s-u)-n);
+w=u-n;
+if(p-(%_DoubleHi(w)&0x7ff00000)>0x3100000){
+s=u;
+n=v*2.02226624871116645580e-21;
+u=s-n;
+n=v*8.47842766036889956997e-32-((s-u)-n);
+w=u-n;
+}
+}
+x=(u-w)-n;
+if(o<0){
+v=-v;
+w=-w;
+x=-x;
+}
+}else{
+v=%RemPiO2(j,h);
+w=h[0];
+x=h[1];
+}
+;
+var y=1-(v&2);
+if(v&1){
+var p=%_DoubleHi(w)&0x7fffffff;
+var m=w*w;
+var u=m*(4.16666666666666019037e-02+m*(-1.38888888888741095749e-03+m*(2.48015872894767294178e-05+m*(-2.75573143513906633035e-07+m*(2.08757232129817482790e-09+m*-1.13596475577881948265e-11)))));
+if(p<0x3fd33333){
+return(1-(0.5*m-(m*u-w*x)))*y;
+}else{
+var z;
+if(p>0x3fe90000){
+z=0.28125;
+}else{
+z=%_ConstructDouble(%_DoubleHi(0.25*w),0);
+}
+var A=0.5*m-z;
+return(1-z-(A-(m*u-w*x)))*y;
+}
+;
+}else{
+var m=w*w;
+var q=m*w;
+var u=8.33333333332248946124e-03+m*(-1.98412698298579493134e-04+m*(2.75573137070700676789e-06+m*(-2.50507602534068634195e-08+m*1.58969099521155010221e-10)));
+return(w-((m*(0.5*x-q*u)-x)-q*-1.66666666666666324348e-01))*y;
+;
+}
+}
+function MathCosSlow(j){
+var v,w,x;
+var o=%_DoubleHi(j);
+var p=o&0x7fffffff;
+if(p<0x4002d97c){
+if(o>0){
+var m=j-1.57079632673412561417;
+if(p!=0x3ff921fb){
+w=m-6.07710050650619224932e-11;
+x=(m-w)-6.07710050650619224932e-11;
+}else{
+m-=6.07710050630396597660e-11;
+w=m-2.02226624879595063154e-21;
+x=(m-w)-2.02226624879595063154e-21;
+}
+v=1;
+}else{
+var m=j+1.57079632673412561417;
+if(p!=0x3ff921fb){
+w=m+6.07710050650619224932e-11;
+x=(m-w)+6.07710050650619224932e-11;
+}else{
+m+=6.07710050630396597660e-11;
+w=m+2.02226624879595063154e-21;
+x=(m-w)+2.02226624879595063154e-21;
+}
+v=-1;
+}
+}else if(p<=0x413921fb){
+var s=e(j);
+v=(s*6.36619772367581382433e-01+0.5)|0;
+var u=s-v*1.57079632673412561417;
+var n=v*6.07710050650619224932e-11;
+w=u-n;
+if(p-(%_DoubleHi(w)&0x7ff00000)>0x1000000){
+s=u;
+n=v*6.07710050630396597660e-11;
+u=s-n;
+n=v*2.02226624879595063154e-21-((s-u)-n);
+w=u-n;
+if(p-(%_DoubleHi(w)&0x7ff00000)>0x3100000){
+s=u;
+n=v*2.02226624871116645580e-21;
+u=s-n;
+n=v*8.47842766036889956997e-32-((s-u)-n);
+w=u-n;
+}
+}
+x=(u-w)-n;
+if(o<0){
+v=-v;
+w=-w;
+x=-x;
+}
+}else{
+v=%RemPiO2(j,h);
+w=h[0];
+x=h[1];
+}
+;
+if(v&1){
+var y=(v&2)-1;
+var m=w*w;
+var q=m*w;
+var u=8.33333333332248946124e-03+m*(-1.98412698298579493134e-04+m*(2.75573137070700676789e-06+m*(-2.50507602534068634195e-08+m*1.58969099521155010221e-10)));
+return(w-((m*(0.5*x-q*u)-x)-q*-1.66666666666666324348e-01))*y;
+;
+}else{
+var y=1-(v&2);
+var p=%_DoubleHi(w)&0x7fffffff;
+var m=w*w;
+var u=m*(4.16666666666666019037e-02+m*(-1.38888888888741095749e-03+m*(2.48015872894767294178e-05+m*(-2.75573143513906633035e-07+m*(2.08757232129817482790e-09+m*-1.13596475577881948265e-11)))));
+if(p<0x3fd33333){
+return(1-(0.5*m-(m*u-w*x)))*y;
+}else{
+var z;
+if(p>0x3fe90000){
+z=0.28125;
+}else{
+z=%_ConstructDouble(%_DoubleHi(0.25*w),0);
+}
+var A=0.5*m-z;
+return(1-z-(A-(m*u-w*x)))*y;
+}
+;
+}
+}
+function MathSin(j){
+j=+j;
+if((%_DoubleHi(j)&0x7fffffff)<=0x3fe921fb){
+var m=j*j;
+var q=m*j;
+var u=8.33333333332248946124e-03+m*(-1.98412698298579493134e-04+m*(2.75573137070700676789e-06+m*(-2.50507602534068634195e-08+m*1.58969099521155010221e-10)));
+return(j-((m*(0.5*0-q*u)-0)-q*-1.66666666666666324348e-01));
+;
+}
+return+MathSinSlow(j);
+}
+function MathCos(j){
+j=+j;
+if((%_DoubleHi(j)&0x7fffffff)<=0x3fe921fb){
+var p=%_DoubleHi(j)&0x7fffffff;
+var m=j*j;
+var u=m*(4.16666666666666019037e-02+m*(-1.38888888888741095749e-03+m*(2.48015872894767294178e-05+m*(-2.75573143513906633035e-07+m*(2.08757232129817482790e-09+m*-1.13596475577881948265e-11)))));
+if(p<0x3fd33333){
+return(1-(0.5*m-(m*u-j*0)));
+}else{
+var z;
+if(p>0x3fe90000){
+z=0.28125;
+}else{
+z=%_ConstructDouble(%_DoubleHi(0.25*j),0);
+}
+var A=0.5*m-z;
+return(1-z-(A-(m*u-j*0)));
+}
+;
+}
+return+MathCosSlow(j);
+}
+function MathTan(j){
+j=j*1;
+if((%_DoubleHi(j)&0x7fffffff)<=0x3fe921fb){
+return KernelTan(j,0,1);
+}
+var v,w,x;
+var o=%_DoubleHi(j);
+var p=o&0x7fffffff;
+if(p<0x4002d97c){
+if(o>0){
+var m=j-1.57079632673412561417;
+if(p!=0x3ff921fb){
+w=m-6.07710050650619224932e-11;
+x=(m-w)-6.07710050650619224932e-11;
+}else{
+m-=6.07710050630396597660e-11;
+w=m-2.02226624879595063154e-21;
+x=(m-w)-2.02226624879595063154e-21;
+}
+v=1;
+}else{
+var m=j+1.57079632673412561417;
+if(p!=0x3ff921fb){
+w=m+6.07710050650619224932e-11;
+x=(m-w)+6.07710050650619224932e-11;
+}else{
+m+=6.07710050630396597660e-11;
+w=m+2.02226624879595063154e-21;
+x=(m-w)+2.02226624879595063154e-21;
+}
+v=-1;
+}
+}else if(p<=0x413921fb){
+var s=e(j);
+v=(s*6.36619772367581382433e-01+0.5)|0;
+var u=s-v*1.57079632673412561417;
+var n=v*6.07710050650619224932e-11;
+w=u-n;
+if(p-(%_DoubleHi(w)&0x7ff00000)>0x1000000){
+s=u;
+n=v*6.07710050630396597660e-11;
+u=s-n;
+n=v*2.02226624879595063154e-21-((s-u)-n);
+w=u-n;
+if(p-(%_DoubleHi(w)&0x7ff00000)>0x3100000){
+s=u;
+n=v*2.02226624871116645580e-21;
+u=s-n;
+n=v*8.47842766036889956997e-32-((s-u)-n);
+w=u-n;
+}
+}
+x=(u-w)-n;
+if(o<0){
+v=-v;
+w=-w;
+x=-x;
+}
+}else{
+v=%RemPiO2(j,h);
+w=h[0];
+x=h[1];
+}
+;
+return KernelTan(w,x,(v&1)?-1:1);
+}
+function MathLog1p(j){
+j=j*1;
+var o=%_DoubleHi(j);
+var B=o&0x7fffffff;
+var C=1;
+var D=j;
+var E=1;
+var F=0;
+var G=j;
+if(o<0x3fda827a){
+if(B>=0x3ff00000){
+if(j===-1){
+return-(1/0);
+}else{
+return g;
+}
+}else if(B<0x3c900000){
+return j;
+}else if(B<0x3e200000){
+return j-j*j*0.5;
+}
+if((o>0)||(o<=-0x402D413D)){
+C=0;
+}
+}
+if(o>=0x7ff00000)return j;
+if(C!==0){
+if(o<0x43400000){
+G=1+j;
+E=%_DoubleHi(G);
+C=(E>>20)-1023;
+F=(C>0)?1-(G-j):j-(G-1);
+F=F/G;
+}else{
+E=%_DoubleHi(G);
+C=(E>>20)-1023;
+}
+E=E&0xfffff;
+if(E<0x6a09e){
+G=%_ConstructDouble(E|0x3ff00000,%_DoubleLo(G));
+}else{
+++C;
+G=%_ConstructDouble(E|0x3fe00000,%_DoubleLo(G));
+E=(0x00100000-E)>>2;
+}
+D=G-1;
+}
+var H=0.5*D*D;
+if(E===0){
+if(D===0){
+if(C===0){
+return 0.0;
+}else{
+return C*6.93147180369123816490e-01+(F+C*1.90821492927058770002e-10);
+}
+}
+var I=H*(1-6.666666666666666666e-01*D);
+if(C===0){
+return D-I;
+}else{
+return C*6.93147180369123816490e-01-((I-(C*1.90821492927058770002e-10+F))-D);
+}
+}
+var t=D/(2+D);
+var m=t*t;
+var I=m*(6.666666666666735130e-01+m*(3.999999999940941908e-01+m*(2.857142874366239149e-01+m*(2.222219843214978396e-01+
+m*(1.818357216161805012e-01+m*(1.531383769920937332e-01+m*1.479819860511658591e-01))))));
+if(C===0){
+return D-(H-t*(H+I));
+}else{
+return C*6.93147180369123816490e-01-((H-(t*(H+I)+(C*1.90821492927058770002e-10+F)))-D);
+}
+}
+function MathExpm1(j){
+j=j*1;
+var k;
+var J;
+var K;
+var C;
+var s;
+var F;
+var o=%_DoubleHi(j);
+var L=o&0x80000000;
+var k=(L===0)?j:-j;
+o&=0x7fffffff;
+if(o>=0x4043687a){
+if(o>=0x40862e42){
+if(o>=0x7ff00000){
+return(j===-(1/0))?-1:j;
+}
+if(j>7.09782712893383973096e+02)return(1/0);
+}
+if(L!=0)return-1;
+}
+if(o>0x3fd62e42){
+if(o<0x3ff0a2b2){
+if(L===0){
+J=j-6.93147180369123816490e-01;
+K=1.90821492927058770002e-10;
+C=1;
+}else{
+J=j+6.93147180369123816490e-01;
+K=-1.90821492927058770002e-10;
+C=-1;
+}
+}else{
+C=(1.44269504088896338700*j+((L===0)?0.5:-0.5))|0;
+s=C;
+J=j-s*6.93147180369123816490e-01;
+K=s*1.90821492927058770002e-10;
+}
+j=J-K;
+F=(J-j)-K;
+}else if(o<0x3c900000){
+return j;
+}else{
+C=0;
+}
+var M=0.5*j;
+var N=j*M;
+var O=1+N*(-3.33333333333331316428e-02+N*(1.58730158725481460165e-03+N*
+(-7.93650757867487942473e-05+N*(4.00821782732936239552e-06+N*-2.01099218183624371326e-07))));
+s=3-O*M;
+var P=N*((O-s)/(6-j*s));
+if(C===0){
+return j-(j*P-N);
+}else{
+P=(j*(P-F)-F);
+P-=N;
+if(C===-1)return 0.5*(j-P)-0.5;
+if(C===1){
+if(j<-0.25)return-2*(P-(j+0.5));
+return 1+2*(j-P);
+}
+if(C<=-2||C>56){
+k=1-(P-j);
+k=%_ConstructDouble(%_DoubleHi(k)+(C<<20),%_DoubleLo(k));
+return k-1;
+}
+if(C<20){
+s=%_ConstructDouble(0x3ff00000-(0x200000>>C),0);
+k=s-(P-j);
+k=%_ConstructDouble(%_DoubleHi(k)+(C<<20),%_DoubleLo(k));
+}else{
+s=%_ConstructDouble((0x3ff-C)<<20,0);
+k=j-(P+s);
+k+=1;
+k=%_ConstructDouble(%_DoubleHi(k)+(C<<20),%_DoubleLo(k));
+}
+}
+return k;
+}
+function MathSinh(j){
+j=j*1;
+var Q=(j<0)?-0.5:0.5;
+var B=e(j);
+if(B<22){
+if(B<3.725290298461914e-9)return j;
+var s=MathExpm1(B);
+if(B<1)return Q*(2*s-s*s/(s+1));
+return Q*(s+s/(s+1));
+}
+if(B<709.7822265625)return Q*f(B);
+if(B<=710.4758600739439){
+var n=f(0.5*B);
+var s=Q*n;
+return s*n;
+}
+return j*(1/0);
+}
+function MathCosh(j){
+j=j*1;
+var p=%_DoubleHi(j)&0x7fffffff;
+if(p<0x3fd62e43){
+var s=MathExpm1(e(j));
+var n=1+s;
+if(p<0x3c800000)return n;
+return 1+(s*s)/(n+n);
+}
+if(p<0x40360000){
+var s=f(e(j));
+return 0.5*s+0.5/s;
+}
+if(p<0x40862e42)return 0.5*f(e(j));
+if(e(j)<=710.4758600739439){
+var n=f(0.5*e(j));
+var s=0.5*n;
+return s*n;
+}
+if((!%_IsSmi(%IS_VAR(j))&&!(j==j)))return j;
+return(1/0);
+}
+function MathTanh(j){
+j=j*1;
+if(!(%_IsSmi(%IS_VAR(j))||((j==j)&&(j!=1/0)&&(j!=-1/0)))){
+if(j>0)return 1;
+if(j<0)return-1;
+return j;
+}
+var B=e(j);
+var m;
+if(B<22){
+if(B<2.77555756156289135105e-17){
+return j;
+}
+if(B>=1){
+var s=MathExpm1(2*B);
+m=1-2/(s+2);
+}else{
+var s=MathExpm1(-2*B);
+m=-s/(s+2);
+}
+}else{
+m=1;
+}
+return(j>=0)?m:-m;
+}
+function MathLog10(j){
+j=j*1;
+var o=%_DoubleHi(j);
+var R=%_DoubleLo(j);
+var C=0;
+if(o<0x00100000){
+if(((o&0x7fffffff)|R)===0)return-(1/0);
+if(o<0)return g;
+C-=54;
+j*=18014398509481984;
+o=%_DoubleHi(j);
+R=%_DoubleLo(j);
+}
+if(o>=0x7ff00000)return j;
+C+=(o>>20)-1023;
+var S=(C&0x80000000)>>>31;
+o=(o&0x000fffff)|((0x3ff-S)<<20);
+var k=C+S;
+j=%_ConstructDouble(o,R);
+var m=k*3.69423907715893078616e-13+4.34294481903251816668e-01*%_MathLogRT(j);
+return m+k*3.01029995663611771306e-01;
+}
+function MathLog2(j){
+j=j*1;
+var B=e(j);
+var o=%_DoubleHi(j);
+var R=%_DoubleLo(j);
+var p=o&0x7fffffff;
+if((p|R)==0)return-(1/0);
+if(o<0)return g;
+if(p>=0x7ff00000)return j;
+var v=0;
+if(p<0x00100000){
+B*=9007199254740992;
+v-=53;
+p=%_DoubleHi(B);
+}
+v+=(p>>20)-0x3ff;
+var T=p&0x000fffff;
+p=T|0x3ff00000;
+var U=1;
+var V=0;
+var W=0;
+if(T>0x3988e){
+if(T<0xbb67a){
+U=1.5;
+V=5.84962487220764160156e-01;
+W=1.35003920212974897128e-08;
+}else{
+v+=1;
+p-=0x00100000;
+}
+}
+B=%_ConstructDouble(p,%_DoubleLo(B));
+var G=B-U;
+var q=1/(B+U);
+var X=G*q;
+var Y=%_ConstructDouble(%_DoubleHi(X),0);
+var Z=%_ConstructDouble(%_DoubleHi(B+U),0)
+var aa=B-(Z-U);
+var ab=q*((G-Y*Z)-Y*aa);
+var ac=X*X;
+var u=ac*ac*(5.99999999999994648725e-01+ac*(4.28571428578550184252e-01+ac*(3.33333329818377432918e-01+ac*(
+2.72728123808534006489e-01+ac*(2.30660745775561754067e-01+ac*2.06975017800338417784e-01)))));
+u+=ab*(Y+X);
+ac=Y*Y;
+Z=%_ConstructDouble(%_DoubleHi(3.0+ac+u),0);
+aa=u-((Z-3.0)-ac);
+G=Y*Z;
+q=ab*Z+aa*X;
+var ad=%_ConstructDouble(%_DoubleHi(G+q),0);
+var ae=q-(ad-G);
+var af=9.61796700954437255859e-01*ad;
+var ag=-7.02846165095275826516e-09*ad+ae*9.61796693925975554329e-01+W;
+var s=v;
+var ah=%_ConstructDouble(%_DoubleHi(((af+ag)+V)+s),0);
+var ai=ag-(((ah-s)-V)-af);
+return ah+ai;
+}
+b.InstallFunctions(d,2,[
+"cos",MathCos,
+"sin",MathSin,
+"tan",MathTan,
+"sinh",MathSinh,
+"cosh",MathCosh,
+"tanh",MathTanh,
+"log10",MathLog10,
+"log2",MathLog2,
+"log1p",MathLog1p,
+"expm1",MathExpm1
+]);
+%SetForceInlineFlag(MathSin);
+%SetForceInlineFlag(MathCos);
+})
+
+regexp�
+(function(a,b){
+%CheckIsBootstrapping();
+var c;
+var d=a.Object;
+var e=a.RegExp;
+var f;
+var g=b.InternalArray;
+var h=b.InternalPackedArray;
+var i;
+var j=b.ImportNow("match_symbol");
+var k=b.ImportNow("search_symbol");
+var l=b.ImportNow("split_symbol");
+b.ImportFromExperimental(function(m){
+c=m.FLAG_harmony_tolength;
+});
+b.Import(function(m){
+i=m.MakeTypeError;
+});
+var n=new h(
+2,
+"",
+(void 0),
+0,
+0
+);
+function IsRegExp(o){
+if(!(%_IsJSReceiver(o)))return false;
+var p=o[j];
+if(!(p===(void 0)))return(!!(p));
+return(%_IsRegExp(o));
+}
+function RegExpInitialize(q,r,s){
+r=(r===(void 0))?'':(%_ToString(r));
+s=(s===(void 0))?'':(%_ToString(s));
+%RegExpInitializeAndCompile(q,r,s);
+return q;
+}
+function PatternFlags(r){
+return((%_RegExpFlags(r)&1)?'g':'')+
+((%_RegExpFlags(r)&2)?'i':'')+
+((%_RegExpFlags(r)&4)?'m':'')+
+((%_RegExpFlags(r)&16)?'u':'')+
+((%_RegExpFlags(r)&8)?'y':'');
+}
+function RegExpConstructor(r,s){
+var t=new.target;
+var u=IsRegExp(r);
+if((t===(void 0))){
+t=e;
+if(u&&(s===(void 0))&&
+r.constructor===t){
+return r;
+}
+}
+if((%_IsRegExp(r))){
+if((s===(void 0)))s=PatternFlags(r);
+r=(%_RegExpSource(r));
+}else if(u){
+var v=r;
+r=r.source;
+if((s===(void 0)))s=v.flags;
+}
+var q=%NewObject(e,t);
+return RegExpInitialize(q,r,s);
+}
+function RegExpCompileJS(r,s){
+if(!(%_IsRegExp(this))){
+throw i(42,
+"RegExp.prototype.compile",this);
+}
+if((%_IsRegExp(r))){
+if(!(s===(void 0)))throw i(129);
+s=PatternFlags(r);
+r=(%_RegExpSource(r));
+}
+RegExpInitialize(this,r,s);
+}
+function DoRegExpExec(w,x,y){
+return %_RegExpExec(w,x,y,n);
+}
+function RegExpExecNoTests(w,x,z){
+var A=%_RegExpExec(w,x,z,n);
+if(A!==null){
+if((%_RegExpFlags(w)&8))w.lastIndex=A[4];
+var B=((A)[0])>>1;
+var z=A[3];
+var C=A[4];
+var D=%_SubString(x,z,C);
+var E=%_RegExpConstructResult(B,z,x);
+E[0]=D;
+if(B==1)return E;
+var F=3+2;
+for(var G=1;G<B;G++){
+z=A[F++];
+if(z!=-1){
+C=A[F];
+E[G]=%_SubString(x,z,C);
+}
+F++;
+}
+return E;
+;
+}
+w.lastIndex=0;
+return null;
+}
+function RegExpExecJS(x){
+if(!(%_IsRegExp(this))){
+throw i(42,
+'RegExp.prototype.exec',this);
+}
+x=(%_ToString(x));
+var H=this.lastIndex;
+var G=(c?(%_ToLength(H)):(%_ToInteger(H)));
+var I=(%_RegExpFlags(this)&1)||(%_RegExpFlags(this)&8);
+if(I){
+if(G<0||G>x.length){
+this.lastIndex=0;
+return null;
+}
+}else{
+G=0;
+}
+var J=%_RegExpExec(this,x,G,n);
+if((J===null)){
+this.lastIndex=0;
+return null;
+}
+if(I){
+this.lastIndex=n[4];
+}
+var B=((J)[0])>>1;
+var z=J[3];
+var C=J[4];
+var D=%_SubString(x,z,C);
+var E=%_RegExpConstructResult(B,z,x);
+E[0]=D;
+if(B==1)return E;
+var F=3+2;
+for(var G=1;G<B;G++){
+z=J[F++];
+if(z!=-1){
+C=J[F];
+E[G]=%_SubString(x,z,C);
+}
+F++;
+}
+return E;
+;
+}
+var K;
+var L;
+function RegExpTest(x){
+if(!(%_IsRegExp(this))){
+throw i(42,
+'RegExp.prototype.test',this);
+}
+x=(%_ToString(x));
+var H=this.lastIndex;
+var G=(c?(%_ToLength(H)):(%_ToInteger(H)));
+if((%_RegExpFlags(this)&1)||(%_RegExpFlags(this)&8)){
+if(G<0||G>x.length){
+this.lastIndex=0;
+return false;
+}
+var J=%_RegExpExec(this,x,G,n);
+if((J===null)){
+this.lastIndex=0;
+return false;
+}
+this.lastIndex=n[4];
+return true;
+}else{
+var w=this;
+var M=(%_RegExpSource(w));
+if(w.length>=3&&
+%_StringCharCodeAt(w,0)==46&&
+%_StringCharCodeAt(w,1)==42&&
+%_StringCharCodeAt(w,2)!=63){
+w=TrimRegExp(w);
+}
+var J=%_RegExpExec(w,x,0,n);
+if((J===null)){
+this.lastIndex=0;
+return false;
+}
+return true;
+}
+}
+function TrimRegExp(w){
+if(!%_ObjectEquals(K,w)){
+K=w;
+L=
+new e(
+%_SubString((%_RegExpSource(w)),2,(%_RegExpSource(w)).length),
+((%_RegExpFlags(w)&2)?(%_RegExpFlags(w)&4)?"im":"i"
+:(%_RegExpFlags(w)&4)?"m":""));
+}
+return L;
+}
+function RegExpToString(){
+if(!(%_IsRegExp(this))){
+if(this===f){
+%IncrementUseCounter(12);
+return'/(?:)/';
+}
+throw i(42,
+'RegExp.prototype.toString',this);
+}
+var E='/'+(%_RegExpSource(this))+'/';
+if((%_RegExpFlags(this)&1))E+='g';
+if((%_RegExpFlags(this)&2))E+='i';
+if((%_RegExpFlags(this)&4))E+='m';
+if((%_RegExpFlags(this)&16))E+='u';
+if((%_RegExpFlags(this)&8))E+='y';
+return E;
+}
+function RegExpSplit(x,N){
+if(!(%_IsRegExp(this))){
+throw i(42,
+"RegExp.prototype.@@split",this);
+}
+var O=this;
+var P=(%_ToString(x));
+N=((N===(void 0)))?4294967295:((N)>>>0);
+var Q=P.length;
+if(N===0)return[];
+if(Q===0){
+if(DoRegExpExec(O,P,0,0)!==null)return[];
+return[P];
+}
+var R=0;
+var S=0;
+var T=0;
+var E=new g();
+outer_loop:
+while(true){
+if(S===Q){
+E[E.length]=%_SubString(P,R,Q);
+break;
+}
+var A=DoRegExpExec(O,P,S);
+if(A===null||Q===(T=A[3])){
+E[E.length]=%_SubString(P,R,Q);
+break;
+}
+var U=A[4];
+if(S===U&&U===R){
+S++;
+continue;
+}
+E[E.length]=%_SubString(P,R,T);
+if(E.length===N)break;
+var V=((A)[0])+3;
+for(var G=3+2;G<V;){
+var z=A[G++];
+var C=A[G++];
+if(C!=-1){
+E[E.length]=%_SubString(P,z,C);
+}else{
+E[E.length]=(void 0);
+}
+if(E.length===N)break outer_loop;
+}
+S=R=U;
+}
+var W=[];
+%MoveArrayContents(E,W);
+return W;
+}
+function RegExpMatch(x){
+if(!(%_IsRegExp(this))){
+throw i(42,
+"RegExp.prototype.@@match",this);
+}
+var P=(%_ToString(x));
+if(!(%_RegExpFlags(this)&1))return RegExpExecNoTests(this,P,0);
+this.lastIndex=0;
+var E=%StringMatch(P,this,n);
+return E;
+}
+function RegExpSearch(x){
+if(!(%_IsRegExp(this))){
+throw i(42,
+"RegExp.prototype.@@search",this);
+}
+var X=DoRegExpExec(this,(%_ToString(x)),0);
+if(X)return X[3];
+return-1;
+}
+function RegExpGetLastMatch(){
+var Y=((n)[1]);
+return %_SubString(Y,
+n[3],
+n[4]);
+}
+function RegExpGetLastParen(){
+var Q=((n)[0]);
+if(Q<=2)return'';
+var Y=((n)[1]);
+var z=n[(3+(Q-2))];
+var C=n[(3+(Q-1))];
+if(z!=-1&&C!=-1){
+return %_SubString(Y,z,C);
+}
+return"";
+}
+function RegExpGetLeftContext(){
+var Z;
+var P;
+Z=n[3];
+P=((n)[1]);
+return %_SubString(P,0,Z);
+}
+function RegExpGetRightContext(){
+var Z;
+var P;
+Z=n[4];
+P=((n)[1]);
+return %_SubString(P,Z,P.length);
+}
+function RegExpMakeCaptureGetter(aa){
+return function foo(){
+var y=aa*2;
+if(y>=((n)[0]))return'';
+var ab=n[(3+(y))];
+var ac=n[(3+(y+1))];
+if(ab==-1||ac==-1)return'';
+return %_SubString(((n)[1]),ab,ac);
+};
+}
+function RegExpGetGlobal(){
+if(!(%_IsRegExp(this))){
+if(this===f){
+return(void 0);
+}
+throw i(131,"RegExp.prototype.global");
+}
+return!!(%_RegExpFlags(this)&1);
+}
+%FunctionSetName(RegExpGetGlobal,"RegExp.prototype.global");
+%SetNativeFlag(RegExpGetGlobal);
+function RegExpGetIgnoreCase(){
+if(!(%_IsRegExp(this))){
+if(this===f){
+return(void 0);
+}
+throw i(131,"RegExp.prototype.ignoreCase");
+}
+return!!(%_RegExpFlags(this)&2);
+}
+%FunctionSetName(RegExpGetIgnoreCase,"RegExp.prototype.ignoreCase");
+%SetNativeFlag(RegExpGetIgnoreCase);
+function RegExpGetMultiline(){
+if(!(%_IsRegExp(this))){
+if(this===f){
+return(void 0);
+}
+throw i(131,"RegExp.prototype.multiline");
+}
+return!!(%_RegExpFlags(this)&4);
+}
+%FunctionSetName(RegExpGetMultiline,"RegExp.prototype.multiline");
+%SetNativeFlag(RegExpGetMultiline);
+function RegExpGetSource(){
+if(!(%_IsRegExp(this))){
+if(this===f){
+return(void 0);
+}
+throw i(131,"RegExp.prototype.source");
+}
+return(%_RegExpSource(this));
+}
+%FunctionSetName(RegExpGetSource,"RegExp.prototype.source");
+%SetNativeFlag(RegExpGetSource);
+%FunctionSetInstanceClassName(e,'RegExp');
+f=new d();
+%FunctionSetPrototype(e,f);
+%AddNamedProperty(
+e.prototype,'constructor',e,2);
+%SetCode(e,RegExpConstructor);
+b.InstallFunctions(e.prototype,2,[
+"exec",RegExpExecJS,
+"test",RegExpTest,
+"toString",RegExpToString,
+"compile",RegExpCompileJS,
+j,RegExpMatch,
+k,RegExpSearch,
+l,RegExpSplit,
+]);
+b.InstallGetter(e.prototype,'global',RegExpGetGlobal);
+b.InstallGetter(e.prototype,'ignoreCase',RegExpGetIgnoreCase);
+b.InstallGetter(e.prototype,'multiline',RegExpGetMultiline);
+b.InstallGetter(e.prototype,'source',RegExpGetSource);
+%FunctionSetLength(e.prototype.compile,1);
+var ad=function(){
+var ae=((n)[2]);
+return(ae===(void 0))?"":ae;
+};
+var af=function(x){
+((n)[2])=(%_ToString(x));
+};
+%OptimizeObjectForAddingMultipleProperties(e,22);
+b.InstallGetterSetter(e,'input',ad,af,
+4);
+b.InstallGetterSetter(e,'$_',ad,af,
+2|4);
+var ag=function(ah){};
+b.InstallGetterSetter(e,'lastMatch',RegExpGetLastMatch,
+ag,4);
+b.InstallGetterSetter(e,'$&',RegExpGetLastMatch,ag,
+2|4);
+b.InstallGetterSetter(e,'lastParen',RegExpGetLastParen,
+ag,4);
+b.InstallGetterSetter(e,'$+',RegExpGetLastParen,ag,
+2|4);
+b.InstallGetterSetter(e,'leftContext',RegExpGetLeftContext,
+ag,4);
+b.InstallGetterSetter(e,'$`',RegExpGetLeftContext,ag,
+2|4);
+b.InstallGetterSetter(e,'rightContext',RegExpGetRightContext,
+ag,4);
+b.InstallGetterSetter(e,"$'",RegExpGetRightContext,ag,
+2|4);
+for(var G=1;G<10;++G){
+b.InstallGetterSetter(e,'$'+G,RegExpMakeCaptureGetter(G),
+ag,4);
+}
+%ToFastProperties(e);
+b.Export(function(ai){
+ai.RegExpExec=DoRegExpExec;
+ai.RegExpExecNoTests=RegExpExecNoTests;
+ai.RegExpLastMatchInfo=n;
+ai.RegExpTest=RegExpTest;
+});
+})
+
+,arraybuffer�
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.ArrayBuffer;
+var d;
+var e;
+var f;
+var g;
+b.Import(function(h){
+d=h.MakeTypeError;
+e=h.MaxSimple;
+f=h.MinSimple;
+g=h.SpeciesConstructor;
+});
+function ArrayBufferGetByteLen(){
+if(!(%_ClassOf(this)==='ArrayBuffer')){
+throw d(42,
+'ArrayBuffer.prototype.byteLength',this);
+}
+return %_ArrayBufferGetByteLength(this);
+}
+function ArrayBufferSlice(i,j){
+if(!(%_ClassOf(this)==='ArrayBuffer')){
+throw d(42,
+'ArrayBuffer.prototype.slice',this);
+}
+var k=(%_ToInteger(i));
+if(!(j===(void 0))){
+j=(%_ToInteger(j));
+}
+var l;
+var m=%_ArrayBufferGetByteLength(this);
+if(k<0){
+l=e(m+k,0);
+}else{
+l=f(k,m);
+}
+var n=(j===(void 0))?m:j;
+var o;
+if(n<0){
+o=e(m+n,0);
+}else{
+o=f(n,m);
+}
+if(o<l){
+o=l;
+}
+var p=o-l;
+var q=g(this,c,true);
+var r=new q(p);
+if(!(%_ClassOf(r)==='ArrayBuffer')){
+throw d(42,
+'ArrayBuffer.prototype.slice',r);
+}
+if(r===this){
+throw d(11);
+}
+if(%_ArrayBufferGetByteLength(r)<p){
+throw d(10);
+}
+%ArrayBufferSliceImpl(this,r,l,p);
+return r;
+}
+b.InstallGetter(c.prototype,"byteLength",
+ArrayBufferGetByteLen);
+b.InstallFunctions(c.prototype,2,[
+"slice",ArrayBufferSlice
+]);
+})
+
+(typedarrayz�
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c;
+var d;
+var e;
+var f=a.Array;
+var g=a.ArrayBuffer;
+var h=a.DataView;
+var i=a.Object;
+var j=b.InternalArray;
+var k;
+var l;
+var m;
+var n;
+var o;
+var p;
+var q;
+var r;
+var s;
+var t;
+var u;
+var v;
+var w;
+var x;
+var y;
+var z;
+var j=b.InternalArray;
+var A;
+var B;
+var C;
+var D;
+var E;
+var F;
+var G;
+var H;
+var I=b.ImportNow("iterator_symbol");
+var J=b.ImportNow("to_string_tag_symbol");
+var K=a.Uint8Array;
+
+var L=a.Int8Array;
+
+var M=a.Uint16Array;
+
+var N=a.Int16Array;
+
+var O=a.Uint32Array;
+
+var P=a.Int32Array;
+
+var Q=a.Float32Array;
+
+var R=a.Float64Array;
+
+var S=a.Uint8ClampedArray;
+
+
+b.Import(function(T){
+c=T.ArrayFrom;
+d=T.ArrayToString;
+e=T.ArrayValues;
+k=T.InnerArrayCopyWithin;
+l=T.InnerArrayEvery;
+m=T.InnerArrayFill;
+n=T.InnerArrayFilter;
+o=T.InnerArrayFind;
+p=T.InnerArrayFindIndex;
+q=T.InnerArrayForEach;
+r=T.InnerArrayIncludes;
+s=T.InnerArrayIndexOf;
+t=T.InnerArrayJoin;
+u=T.InnerArrayLastIndexOf;
+v=T.InnerArrayReduce;
+w=T.InnerArrayReduceRight;
+x=T.InnerArraySome;
+y=T.InnerArraySort;
+z=T.InnerArrayToLocaleString;
+A=T.IsNaN;
+B=T.MakeRangeError;
+C=T.MakeTypeError;
+D=T.MaxSimple;
+E=T.MinSimple;
+F=T.PackedArrayReverse;
+G=T.SpeciesConstructor;
+H=T.ToPositiveInteger;
+});
+function TypedArrayDefaultConstructor(U){
+switch(%_ClassOf(U)){
+case"Uint8Array":
+return K;
+
+case"Int8Array":
+return L;
+
+case"Uint16Array":
+return M;
+
+case"Int16Array":
+return N;
+
+case"Uint32Array":
+return O;
+
+case"Int32Array":
+return P;
+
+case"Float32Array":
+return Q;
+
+case"Float64Array":
+return R;
+
+case"Uint8ClampedArray":
+return S;
+
+
+}
+throw C(42,
+"TypedArrayDefaultConstructor",this);
+}
+function TypedArrayCreate(V,W,X,Y){
+if((X===(void 0))){
+var Z=new V(W);
+}else{
+var Z=new V(W,X,Y);
+}
+if(!%_IsTypedArray(Z))throw C(68);
+if((typeof(W)==='number')&&%_TypedArrayGetLength(Z)<W){
+throw C(265);
+}
+return Z;
+}
+function TypedArraySpeciesCreate(aa,W,X,Y,ab){
+var ac=TypedArrayDefaultConstructor(aa);
+var V=G(aa,ac,
+ab);
+return TypedArrayCreate(V,W,X,Y);
+}
+function Uint8ArrayConstructByArrayBuffer(ad,ae,af,ag){
+if(!(af===(void 0))){
+af=H(af,180);
+}
+if(!(ag===(void 0))){
+ag=H(ag,180);
+}
+var ah=%_ArrayBufferGetByteLength(ae);
+var ai;
+if((af===(void 0))){
+ai=0;
+}else{
+ai=af;
+if(ai % 1!==0){
+throw B(179,
+"start offset","Uint8Array",1);
+}
+if(ai>ah){
+throw B(181);
+}
+}
+var aj;
+var ak;
+if((ag===(void 0))){
+if(ah % 1!==0){
+throw B(179,
+"byte length","Uint8Array",1);
+}
+aj=ah-ai;
+ak=aj/1;
+}else{
+var ak=ag;
+aj=ak*1;
+}
+if((ai+aj>ah)
+||(ak>%_MaxSmi())){
+throw B(180);
+}
+%_TypedArrayInitialize(ad,1,ae,ai,aj,true);
+}
+function Uint8ArrayConstructByLength(ad,ag){
+var al=(ag===(void 0))?
+0:H(ag,180);
+if(al>%_MaxSmi()){
+throw B(180);
+}
+var am=al*1;
+if(am>%_TypedArrayMaxSizeInHeap()){
+var ae=new g(am);
+%_TypedArrayInitialize(ad,1,ae,0,am,true);
+}else{
+%_TypedArrayInitialize(ad,1,null,0,am,true);
+}
+}
+function Uint8ArrayConstructByArrayLike(ad,an){
+var ag=an.length;
+var al=H(ag,180);
+if(al>%_MaxSmi()){
+throw B(180);
+}
+var ao=false;
+var am=al*1;
+if(am<=%_TypedArrayMaxSizeInHeap()){
+%_TypedArrayInitialize(ad,1,null,0,am,false);
+}else{
+ao=
+%TypedArrayInitializeFromArrayLike(ad,1,an,al);
+}
+if(!ao){
+for(var ap=0;ap<al;ap++){
+ad[ap]=an[ap];
+}
+}
+}
+function Uint8ArrayConstructByIterable(ad,aq,ar){
+var as=new j();
+var at=%_Call(ar,aq);
+var au={
+__proto__:null
+};
+au[I]=function(){return at;}
+for(var av of au){
+as.push(av);
+}
+Uint8ArrayConstructByArrayLike(ad,as);
+}
+function Uint8ArrayConstructor(X,Y,aw){
+if(!(new.target===(void 0))){
+if((%_ClassOf(X)==='ArrayBuffer')||(%_ClassOf(X)==='SharedArrayBuffer')){
+Uint8ArrayConstructByArrayBuffer(this,X,Y,aw);
+}else if((typeof(X)==='number')||(typeof(X)==='string')||
+(typeof(X)==='boolean')||(X===(void 0))){
+Uint8ArrayConstructByLength(this,X);
+}else{
+var ar=X[I];
+if((ar===(void 0))||ar===e){
+Uint8ArrayConstructByArrayLike(this,X);
+}else{
+Uint8ArrayConstructByIterable(this,X,ar);
+}
+}
+}else{
+throw C(26,"Uint8Array")
+}
+}
+function Uint8Array_GetLength(){
+if(!(%_ClassOf(this)==='Uint8Array')){
+throw C(42,"Uint8Array.length",this);
+}
+return %_TypedArrayGetLength(this);
+}
+function Uint8ArraySubArray(ax,ay){
+var az=(%_ToInteger(ax));
+if(!(ay===(void 0))){
+var aA=(%_ToInteger(ay));
+var aB=%_TypedArrayGetLength(this);
+}else{
+var aB=%_TypedArrayGetLength(this);
+var aA=aB;
+}
+if(az<0){
+az=D(0,aB+az);
+}else{
+az=E(az,aB);
+}
+if(aA<0){
+aA=D(0,aB+aA);
+}else{
+aA=E(aA,aB);
+}
+if(aA<az){
+aA=az;
+}
+var ak=aA-az;
+var aC=
+%_ArrayBufferViewGetByteOffset(this)+az*1;
+return TypedArraySpeciesCreate(this,%TypedArrayGetBuffer(this),
+aC,ak,true);
+}
+
+function Int8ArrayConstructByArrayBuffer(ad,ae,af,ag){
+if(!(af===(void 0))){
+af=H(af,180);
+}
+if(!(ag===(void 0))){
+ag=H(ag,180);
+}
+var ah=%_ArrayBufferGetByteLength(ae);
+var ai;
+if((af===(void 0))){
+ai=0;
+}else{
+ai=af;
+if(ai % 1!==0){
+throw B(179,
+"start offset","Int8Array",1);
+}
+if(ai>ah){
+throw B(181);
+}
+}
+var aj;
+var ak;
+if((ag===(void 0))){
+if(ah % 1!==0){
+throw B(179,
+"byte length","Int8Array",1);
+}
+aj=ah-ai;
+ak=aj/1;
+}else{
+var ak=ag;
+aj=ak*1;
+}
+if((ai+aj>ah)
+||(ak>%_MaxSmi())){
+throw B(180);
+}
+%_TypedArrayInitialize(ad,2,ae,ai,aj,true);
+}
+function Int8ArrayConstructByLength(ad,ag){
+var al=(ag===(void 0))?
+0:H(ag,180);
+if(al>%_MaxSmi()){
+throw B(180);
+}
+var am=al*1;
+if(am>%_TypedArrayMaxSizeInHeap()){
+var ae=new g(am);
+%_TypedArrayInitialize(ad,2,ae,0,am,true);
+}else{
+%_TypedArrayInitialize(ad,2,null,0,am,true);
+}
+}
+function Int8ArrayConstructByArrayLike(ad,an){
+var ag=an.length;
+var al=H(ag,180);
+if(al>%_MaxSmi()){
+throw B(180);
+}
+var ao=false;
+var am=al*1;
+if(am<=%_TypedArrayMaxSizeInHeap()){
+%_TypedArrayInitialize(ad,2,null,0,am,false);
+}else{
+ao=
+%TypedArrayInitializeFromArrayLike(ad,2,an,al);
+}
+if(!ao){
+for(var ap=0;ap<al;ap++){
+ad[ap]=an[ap];
+}
+}
+}
+function Int8ArrayConstructByIterable(ad,aq,ar){
+var as=new j();
+var at=%_Call(ar,aq);
+var au={
+__proto__:null
+};
+au[I]=function(){return at;}
+for(var av of au){
+as.push(av);
+}
+Int8ArrayConstructByArrayLike(ad,as);
+}
+function Int8ArrayConstructor(X,Y,aw){
+if(!(new.target===(void 0))){
+if((%_ClassOf(X)==='ArrayBuffer')||(%_ClassOf(X)==='SharedArrayBuffer')){
+Int8ArrayConstructByArrayBuffer(this,X,Y,aw);
+}else if((typeof(X)==='number')||(typeof(X)==='string')||
+(typeof(X)==='boolean')||(X===(void 0))){
+Int8ArrayConstructByLength(this,X);
+}else{
+var ar=X[I];
+if((ar===(void 0))||ar===e){
+Int8ArrayConstructByArrayLike(this,X);
+}else{
+Int8ArrayConstructByIterable(this,X,ar);
+}
+}
+}else{
+throw C(26,"Int8Array")
+}
+}
+function Int8Array_GetLength(){
+if(!(%_ClassOf(this)==='Int8Array')){
+throw C(42,"Int8Array.length",this);
+}
+return %_TypedArrayGetLength(this);
+}
+function Int8ArraySubArray(ax,ay){
+var az=(%_ToInteger(ax));
+if(!(ay===(void 0))){
+var aA=(%_ToInteger(ay));
+var aB=%_TypedArrayGetLength(this);
+}else{
+var aB=%_TypedArrayGetLength(this);
+var aA=aB;
+}
+if(az<0){
+az=D(0,aB+az);
+}else{
+az=E(az,aB);
+}
+if(aA<0){
+aA=D(0,aB+aA);
+}else{
+aA=E(aA,aB);
+}
+if(aA<az){
+aA=az;
+}
+var ak=aA-az;
+var aC=
+%_ArrayBufferViewGetByteOffset(this)+az*1;
+return TypedArraySpeciesCreate(this,%TypedArrayGetBuffer(this),
+aC,ak,true);
+}
+
+function Uint16ArrayConstructByArrayBuffer(ad,ae,af,ag){
+if(!(af===(void 0))){
+af=H(af,180);
+}
+if(!(ag===(void 0))){
+ag=H(ag,180);
+}
+var ah=%_ArrayBufferGetByteLength(ae);
+var ai;
+if((af===(void 0))){
+ai=0;
+}else{
+ai=af;
+if(ai % 2!==0){
+throw B(179,
+"start offset","Uint16Array",2);
+}
+if(ai>ah){
+throw B(181);
+}
+}
+var aj;
+var ak;
+if((ag===(void 0))){
+if(ah % 2!==0){
+throw B(179,
+"byte length","Uint16Array",2);
+}
+aj=ah-ai;
+ak=aj/2;
+}else{
+var ak=ag;
+aj=ak*2;
+}
+if((ai+aj>ah)
+||(ak>%_MaxSmi())){
+throw B(180);
+}
+%_TypedArrayInitialize(ad,3,ae,ai,aj,true);
+}
+function Uint16ArrayConstructByLength(ad,ag){
+var al=(ag===(void 0))?
+0:H(ag,180);
+if(al>%_MaxSmi()){
+throw B(180);
+}
+var am=al*2;
+if(am>%_TypedArrayMaxSizeInHeap()){
+var ae=new g(am);
+%_TypedArrayInitialize(ad,3,ae,0,am,true);
+}else{
+%_TypedArrayInitialize(ad,3,null,0,am,true);
+}
+}
+function Uint16ArrayConstructByArrayLike(ad,an){
+var ag=an.length;
+var al=H(ag,180);
+if(al>%_MaxSmi()){
+throw B(180);
+}
+var ao=false;
+var am=al*2;
+if(am<=%_TypedArrayMaxSizeInHeap()){
+%_TypedArrayInitialize(ad,3,null,0,am,false);
+}else{
+ao=
+%TypedArrayInitializeFromArrayLike(ad,3,an,al);
+}
+if(!ao){
+for(var ap=0;ap<al;ap++){
+ad[ap]=an[ap];
+}
+}
+}
+function Uint16ArrayConstructByIterable(ad,aq,ar){
+var as=new j();
+var at=%_Call(ar,aq);
+var au={
+__proto__:null
+};
+au[I]=function(){return at;}
+for(var av of au){
+as.push(av);
+}
+Uint16ArrayConstructByArrayLike(ad,as);
+}
+function Uint16ArrayConstructor(X,Y,aw){
+if(!(new.target===(void 0))){
+if((%_ClassOf(X)==='ArrayBuffer')||(%_ClassOf(X)==='SharedArrayBuffer')){
+Uint16ArrayConstructByArrayBuffer(this,X,Y,aw);
+}else if((typeof(X)==='number')||(typeof(X)==='string')||
+(typeof(X)==='boolean')||(X===(void 0))){
+Uint16ArrayConstructByLength(this,X);
+}else{
+var ar=X[I];
+if((ar===(void 0))||ar===e){
+Uint16ArrayConstructByArrayLike(this,X);
+}else{
+Uint16ArrayConstructByIterable(this,X,ar);
+}
+}
+}else{
+throw C(26,"Uint16Array")
+}
+}
+function Uint16Array_GetLength(){
+if(!(%_ClassOf(this)==='Uint16Array')){
+throw C(42,"Uint16Array.length",this);
+}
+return %_TypedArrayGetLength(this);
+}
+function Uint16ArraySubArray(ax,ay){
+var az=(%_ToInteger(ax));
+if(!(ay===(void 0))){
+var aA=(%_ToInteger(ay));
+var aB=%_TypedArrayGetLength(this);
+}else{
+var aB=%_TypedArrayGetLength(this);
+var aA=aB;
+}
+if(az<0){
+az=D(0,aB+az);
+}else{
+az=E(az,aB);
+}
+if(aA<0){
+aA=D(0,aB+aA);
+}else{
+aA=E(aA,aB);
+}
+if(aA<az){
+aA=az;
+}
+var ak=aA-az;
+var aC=
+%_ArrayBufferViewGetByteOffset(this)+az*2;
+return TypedArraySpeciesCreate(this,%TypedArrayGetBuffer(this),
+aC,ak,true);
+}
+
+function Int16ArrayConstructByArrayBuffer(ad,ae,af,ag){
+if(!(af===(void 0))){
+af=H(af,180);
+}
+if(!(ag===(void 0))){
+ag=H(ag,180);
+}
+var ah=%_ArrayBufferGetByteLength(ae);
+var ai;
+if((af===(void 0))){
+ai=0;
+}else{
+ai=af;
+if(ai % 2!==0){
+throw B(179,
+"start offset","Int16Array",2);
+}
+if(ai>ah){
+throw B(181);
+}
+}
+var aj;
+var ak;
+if((ag===(void 0))){
+if(ah % 2!==0){
+throw B(179,
+"byte length","Int16Array",2);
+}
+aj=ah-ai;
+ak=aj/2;
+}else{
+var ak=ag;
+aj=ak*2;
+}
+if((ai+aj>ah)
+||(ak>%_MaxSmi())){
+throw B(180);
+}
+%_TypedArrayInitialize(ad,4,ae,ai,aj,true);
+}
+function Int16ArrayConstructByLength(ad,ag){
+var al=(ag===(void 0))?
+0:H(ag,180);
+if(al>%_MaxSmi()){
+throw B(180);
+}
+var am=al*2;
+if(am>%_TypedArrayMaxSizeInHeap()){
+var ae=new g(am);
+%_TypedArrayInitialize(ad,4,ae,0,am,true);
+}else{
+%_TypedArrayInitialize(ad,4,null,0,am,true);
+}
+}
+function Int16ArrayConstructByArrayLike(ad,an){
+var ag=an.length;
+var al=H(ag,180);
+if(al>%_MaxSmi()){
+throw B(180);
+}
+var ao=false;
+var am=al*2;
+if(am<=%_TypedArrayMaxSizeInHeap()){
+%_TypedArrayInitialize(ad,4,null,0,am,false);
+}else{
+ao=
+%TypedArrayInitializeFromArrayLike(ad,4,an,al);
+}
+if(!ao){
+for(var ap=0;ap<al;ap++){
+ad[ap]=an[ap];
+}
+}
+}
+function Int16ArrayConstructByIterable(ad,aq,ar){
+var as=new j();
+var at=%_Call(ar,aq);
+var au={
+__proto__:null
+};
+au[I]=function(){return at;}
+for(var av of au){
+as.push(av);
+}
+Int16ArrayConstructByArrayLike(ad,as);
+}
+function Int16ArrayConstructor(X,Y,aw){
+if(!(new.target===(void 0))){
+if((%_ClassOf(X)==='ArrayBuffer')||(%_ClassOf(X)==='SharedArrayBuffer')){
+Int16ArrayConstructByArrayBuffer(this,X,Y,aw);
+}else if((typeof(X)==='number')||(typeof(X)==='string')||
+(typeof(X)==='boolean')||(X===(void 0))){
+Int16ArrayConstructByLength(this,X);
+}else{
+var ar=X[I];
+if((ar===(void 0))||ar===e){
+Int16ArrayConstructByArrayLike(this,X);
+}else{
+Int16ArrayConstructByIterable(this,X,ar);
+}
+}
+}else{
+throw C(26,"Int16Array")
+}
+}
+function Int16Array_GetLength(){
+if(!(%_ClassOf(this)==='Int16Array')){
+throw C(42,"Int16Array.length",this);
+}
+return %_TypedArrayGetLength(this);
+}
+function Int16ArraySubArray(ax,ay){
+var az=(%_ToInteger(ax));
+if(!(ay===(void 0))){
+var aA=(%_ToInteger(ay));
+var aB=%_TypedArrayGetLength(this);
+}else{
+var aB=%_TypedArrayGetLength(this);
+var aA=aB;
+}
+if(az<0){
+az=D(0,aB+az);
+}else{
+az=E(az,aB);
+}
+if(aA<0){
+aA=D(0,aB+aA);
+}else{
+aA=E(aA,aB);
+}
+if(aA<az){
+aA=az;
+}
+var ak=aA-az;
+var aC=
+%_ArrayBufferViewGetByteOffset(this)+az*2;
+return TypedArraySpeciesCreate(this,%TypedArrayGetBuffer(this),
+aC,ak,true);
+}
+
+function Uint32ArrayConstructByArrayBuffer(ad,ae,af,ag){
+if(!(af===(void 0))){
+af=H(af,180);
+}
+if(!(ag===(void 0))){
+ag=H(ag,180);
+}
+var ah=%_ArrayBufferGetByteLength(ae);
+var ai;
+if((af===(void 0))){
+ai=0;
+}else{
+ai=af;
+if(ai % 4!==0){
+throw B(179,
+"start offset","Uint32Array",4);
+}
+if(ai>ah){
+throw B(181);
+}
+}
+var aj;
+var ak;
+if((ag===(void 0))){
+if(ah % 4!==0){
+throw B(179,
+"byte length","Uint32Array",4);
+}
+aj=ah-ai;
+ak=aj/4;
+}else{
+var ak=ag;
+aj=ak*4;
+}
+if((ai+aj>ah)
+||(ak>%_MaxSmi())){
+throw B(180);
+}
+%_TypedArrayInitialize(ad,5,ae,ai,aj,true);
+}
+function Uint32ArrayConstructByLength(ad,ag){
+var al=(ag===(void 0))?
+0:H(ag,180);
+if(al>%_MaxSmi()){
+throw B(180);
+}
+var am=al*4;
+if(am>%_TypedArrayMaxSizeInHeap()){
+var ae=new g(am);
+%_TypedArrayInitialize(ad,5,ae,0,am,true);
+}else{
+%_TypedArrayInitialize(ad,5,null,0,am,true);
+}
+}
+function Uint32ArrayConstructByArrayLike(ad,an){
+var ag=an.length;
+var al=H(ag,180);
+if(al>%_MaxSmi()){
+throw B(180);
+}
+var ao=false;
+var am=al*4;
+if(am<=%_TypedArrayMaxSizeInHeap()){
+%_TypedArrayInitialize(ad,5,null,0,am,false);
+}else{
+ao=
+%TypedArrayInitializeFromArrayLike(ad,5,an,al);
+}
+if(!ao){
+for(var ap=0;ap<al;ap++){
+ad[ap]=an[ap];
+}
+}
+}
+function Uint32ArrayConstructByIterable(ad,aq,ar){
+var as=new j();
+var at=%_Call(ar,aq);
+var au={
+__proto__:null
+};
+au[I]=function(){return at;}
+for(var av of au){
+as.push(av);
+}
+Uint32ArrayConstructByArrayLike(ad,as);
+}
+function Uint32ArrayConstructor(X,Y,aw){
+if(!(new.target===(void 0))){
+if((%_ClassOf(X)==='ArrayBuffer')||(%_ClassOf(X)==='SharedArrayBuffer')){
+Uint32ArrayConstructByArrayBuffer(this,X,Y,aw);
+}else if((typeof(X)==='number')||(typeof(X)==='string')||
+(typeof(X)==='boolean')||(X===(void 0))){
+Uint32ArrayConstructByLength(this,X);
+}else{
+var ar=X[I];
+if((ar===(void 0))||ar===e){
+Uint32ArrayConstructByArrayLike(this,X);
+}else{
+Uint32ArrayConstructByIterable(this,X,ar);
+}
+}
+}else{
+throw C(26,"Uint32Array")
+}
+}
+function Uint32Array_GetLength(){
+if(!(%_ClassOf(this)==='Uint32Array')){
+throw C(42,"Uint32Array.length",this);
+}
+return %_TypedArrayGetLength(this);
+}
+function Uint32ArraySubArray(ax,ay){
+var az=(%_ToInteger(ax));
+if(!(ay===(void 0))){
+var aA=(%_ToInteger(ay));
+var aB=%_TypedArrayGetLength(this);
+}else{
+var aB=%_TypedArrayGetLength(this);
+var aA=aB;
+}
+if(az<0){
+az=D(0,aB+az);
+}else{
+az=E(az,aB);
+}
+if(aA<0){
+aA=D(0,aB+aA);
+}else{
+aA=E(aA,aB);
+}
+if(aA<az){
+aA=az;
+}
+var ak=aA-az;
+var aC=
+%_ArrayBufferViewGetByteOffset(this)+az*4;
+return TypedArraySpeciesCreate(this,%TypedArrayGetBuffer(this),
+aC,ak,true);
+}
+
+function Int32ArrayConstructByArrayBuffer(ad,ae,af,ag){
+if(!(af===(void 0))){
+af=H(af,180);
+}
+if(!(ag===(void 0))){
+ag=H(ag,180);
+}
+var ah=%_ArrayBufferGetByteLength(ae);
+var ai;
+if((af===(void 0))){
+ai=0;
+}else{
+ai=af;
+if(ai % 4!==0){
+throw B(179,
+"start offset","Int32Array",4);
+}
+if(ai>ah){
+throw B(181);
+}
+}
+var aj;
+var ak;
+if((ag===(void 0))){
+if(ah % 4!==0){
+throw B(179,
+"byte length","Int32Array",4);
+}
+aj=ah-ai;
+ak=aj/4;
+}else{
+var ak=ag;
+aj=ak*4;
+}
+if((ai+aj>ah)
+||(ak>%_MaxSmi())){
+throw B(180);
+}
+%_TypedArrayInitialize(ad,6,ae,ai,aj,true);
+}
+function Int32ArrayConstructByLength(ad,ag){
+var al=(ag===(void 0))?
+0:H(ag,180);
+if(al>%_MaxSmi()){
+throw B(180);
+}
+var am=al*4;
+if(am>%_TypedArrayMaxSizeInHeap()){
+var ae=new g(am);
+%_TypedArrayInitialize(ad,6,ae,0,am,true);
+}else{
+%_TypedArrayInitialize(ad,6,null,0,am,true);
+}
+}
+function Int32ArrayConstructByArrayLike(ad,an){
+var ag=an.length;
+var al=H(ag,180);
+if(al>%_MaxSmi()){
+throw B(180);
+}
+var ao=false;
+var am=al*4;
+if(am<=%_TypedArrayMaxSizeInHeap()){
+%_TypedArrayInitialize(ad,6,null,0,am,false);
+}else{
+ao=
+%TypedArrayInitializeFromArrayLike(ad,6,an,al);
+}
+if(!ao){
+for(var ap=0;ap<al;ap++){
+ad[ap]=an[ap];
+}
+}
+}
+function Int32ArrayConstructByIterable(ad,aq,ar){
+var as=new j();
+var at=%_Call(ar,aq);
+var au={
+__proto__:null
+};
+au[I]=function(){return at;}
+for(var av of au){
+as.push(av);
+}
+Int32ArrayConstructByArrayLike(ad,as);
+}
+function Int32ArrayConstructor(X,Y,aw){
+if(!(new.target===(void 0))){
+if((%_ClassOf(X)==='ArrayBuffer')||(%_ClassOf(X)==='SharedArrayBuffer')){
+Int32ArrayConstructByArrayBuffer(this,X,Y,aw);
+}else if((typeof(X)==='number')||(typeof(X)==='string')||
+(typeof(X)==='boolean')||(X===(void 0))){
+Int32ArrayConstructByLength(this,X);
+}else{
+var ar=X[I];
+if((ar===(void 0))||ar===e){
+Int32ArrayConstructByArrayLike(this,X);
+}else{
+Int32ArrayConstructByIterable(this,X,ar);
+}
+}
+}else{
+throw C(26,"Int32Array")
+}
+}
+function Int32Array_GetLength(){
+if(!(%_ClassOf(this)==='Int32Array')){
+throw C(42,"Int32Array.length",this);
+}
+return %_TypedArrayGetLength(this);
+}
+function Int32ArraySubArray(ax,ay){
+var az=(%_ToInteger(ax));
+if(!(ay===(void 0))){
+var aA=(%_ToInteger(ay));
+var aB=%_TypedArrayGetLength(this);
+}else{
+var aB=%_TypedArrayGetLength(this);
+var aA=aB;
+}
+if(az<0){
+az=D(0,aB+az);
+}else{
+az=E(az,aB);
+}
+if(aA<0){
+aA=D(0,aB+aA);
+}else{
+aA=E(aA,aB);
+}
+if(aA<az){
+aA=az;
+}
+var ak=aA-az;
+var aC=
+%_ArrayBufferViewGetByteOffset(this)+az*4;
+return TypedArraySpeciesCreate(this,%TypedArrayGetBuffer(this),
+aC,ak,true);
+}
+
+function Float32ArrayConstructByArrayBuffer(ad,ae,af,ag){
+if(!(af===(void 0))){
+af=H(af,180);
+}
+if(!(ag===(void 0))){
+ag=H(ag,180);
+}
+var ah=%_ArrayBufferGetByteLength(ae);
+var ai;
+if((af===(void 0))){
+ai=0;
+}else{
+ai=af;
+if(ai % 4!==0){
+throw B(179,
+"start offset","Float32Array",4);
+}
+if(ai>ah){
+throw B(181);
+}
+}
+var aj;
+var ak;
+if((ag===(void 0))){
+if(ah % 4!==0){
+throw B(179,
+"byte length","Float32Array",4);
+}
+aj=ah-ai;
+ak=aj/4;
+}else{
+var ak=ag;
+aj=ak*4;
+}
+if((ai+aj>ah)
+||(ak>%_MaxSmi())){
+throw B(180);
+}
+%_TypedArrayInitialize(ad,7,ae,ai,aj,true);
+}
+function Float32ArrayConstructByLength(ad,ag){
+var al=(ag===(void 0))?
+0:H(ag,180);
+if(al>%_MaxSmi()){
+throw B(180);
+}
+var am=al*4;
+if(am>%_TypedArrayMaxSizeInHeap()){
+var ae=new g(am);
+%_TypedArrayInitialize(ad,7,ae,0,am,true);
+}else{
+%_TypedArrayInitialize(ad,7,null,0,am,true);
+}
+}
+function Float32ArrayConstructByArrayLike(ad,an){
+var ag=an.length;
+var al=H(ag,180);
+if(al>%_MaxSmi()){
+throw B(180);
+}
+var ao=false;
+var am=al*4;
+if(am<=%_TypedArrayMaxSizeInHeap()){
+%_TypedArrayInitialize(ad,7,null,0,am,false);
+}else{
+ao=
+%TypedArrayInitializeFromArrayLike(ad,7,an,al);
+}
+if(!ao){
+for(var ap=0;ap<al;ap++){
+ad[ap]=an[ap];
+}
+}
+}
+function Float32ArrayConstructByIterable(ad,aq,ar){
+var as=new j();
+var at=%_Call(ar,aq);
+var au={
+__proto__:null
+};
+au[I]=function(){return at;}
+for(var av of au){
+as.push(av);
+}
+Float32ArrayConstructByArrayLike(ad,as);
+}
+function Float32ArrayConstructor(X,Y,aw){
+if(!(new.target===(void 0))){
+if((%_ClassOf(X)==='ArrayBuffer')||(%_ClassOf(X)==='SharedArrayBuffer')){
+Float32ArrayConstructByArrayBuffer(this,X,Y,aw);
+}else if((typeof(X)==='number')||(typeof(X)==='string')||
+(typeof(X)==='boolean')||(X===(void 0))){
+Float32ArrayConstructByLength(this,X);
+}else{
+var ar=X[I];
+if((ar===(void 0))||ar===e){
+Float32ArrayConstructByArrayLike(this,X);
+}else{
+Float32ArrayConstructByIterable(this,X,ar);
+}
+}
+}else{
+throw C(26,"Float32Array")
+}
+}
+function Float32Array_GetLength(){
+if(!(%_ClassOf(this)==='Float32Array')){
+throw C(42,"Float32Array.length",this);
+}
+return %_TypedArrayGetLength(this);
+}
+function Float32ArraySubArray(ax,ay){
+var az=(%_ToInteger(ax));
+if(!(ay===(void 0))){
+var aA=(%_ToInteger(ay));
+var aB=%_TypedArrayGetLength(this);
+}else{
+var aB=%_TypedArrayGetLength(this);
+var aA=aB;
+}
+if(az<0){
+az=D(0,aB+az);
+}else{
+az=E(az,aB);
+}
+if(aA<0){
+aA=D(0,aB+aA);
+}else{
+aA=E(aA,aB);
+}
+if(aA<az){
+aA=az;
+}
+var ak=aA-az;
+var aC=
+%_ArrayBufferViewGetByteOffset(this)+az*4;
+return TypedArraySpeciesCreate(this,%TypedArrayGetBuffer(this),
+aC,ak,true);
+}
+
+function Float64ArrayConstructByArrayBuffer(ad,ae,af,ag){
+if(!(af===(void 0))){
+af=H(af,180);
+}
+if(!(ag===(void 0))){
+ag=H(ag,180);
+}
+var ah=%_ArrayBufferGetByteLength(ae);
+var ai;
+if((af===(void 0))){
+ai=0;
+}else{
+ai=af;
+if(ai % 8!==0){
+throw B(179,
+"start offset","Float64Array",8);
+}
+if(ai>ah){
+throw B(181);
+}
+}
+var aj;
+var ak;
+if((ag===(void 0))){
+if(ah % 8!==0){
+throw B(179,
+"byte length","Float64Array",8);
+}
+aj=ah-ai;
+ak=aj/8;
+}else{
+var ak=ag;
+aj=ak*8;
+}
+if((ai+aj>ah)
+||(ak>%_MaxSmi())){
+throw B(180);
+}
+%_TypedArrayInitialize(ad,8,ae,ai,aj,true);
+}
+function Float64ArrayConstructByLength(ad,ag){
+var al=(ag===(void 0))?
+0:H(ag,180);
+if(al>%_MaxSmi()){
+throw B(180);
+}
+var am=al*8;
+if(am>%_TypedArrayMaxSizeInHeap()){
+var ae=new g(am);
+%_TypedArrayInitialize(ad,8,ae,0,am,true);
+}else{
+%_TypedArrayInitialize(ad,8,null,0,am,true);
+}
+}
+function Float64ArrayConstructByArrayLike(ad,an){
+var ag=an.length;
+var al=H(ag,180);
+if(al>%_MaxSmi()){
+throw B(180);
+}
+var ao=false;
+var am=al*8;
+if(am<=%_TypedArrayMaxSizeInHeap()){
+%_TypedArrayInitialize(ad,8,null,0,am,false);
+}else{
+ao=
+%TypedArrayInitializeFromArrayLike(ad,8,an,al);
+}
+if(!ao){
+for(var ap=0;ap<al;ap++){
+ad[ap]=an[ap];
+}
+}
+}
+function Float64ArrayConstructByIterable(ad,aq,ar){
+var as=new j();
+var at=%_Call(ar,aq);
+var au={
+__proto__:null
+};
+au[I]=function(){return at;}
+for(var av of au){
+as.push(av);
+}
+Float64ArrayConstructByArrayLike(ad,as);
+}
+function Float64ArrayConstructor(X,Y,aw){
+if(!(new.target===(void 0))){
+if((%_ClassOf(X)==='ArrayBuffer')||(%_ClassOf(X)==='SharedArrayBuffer')){
+Float64ArrayConstructByArrayBuffer(this,X,Y,aw);
+}else if((typeof(X)==='number')||(typeof(X)==='string')||
+(typeof(X)==='boolean')||(X===(void 0))){
+Float64ArrayConstructByLength(this,X);
+}else{
+var ar=X[I];
+if((ar===(void 0))||ar===e){
+Float64ArrayConstructByArrayLike(this,X);
+}else{
+Float64ArrayConstructByIterable(this,X,ar);
+}
+}
+}else{
+throw C(26,"Float64Array")
+}
+}
+function Float64Array_GetLength(){
+if(!(%_ClassOf(this)==='Float64Array')){
+throw C(42,"Float64Array.length",this);
+}
+return %_TypedArrayGetLength(this);
+}
+function Float64ArraySubArray(ax,ay){
+var az=(%_ToInteger(ax));
+if(!(ay===(void 0))){
+var aA=(%_ToInteger(ay));
+var aB=%_TypedArrayGetLength(this);
+}else{
+var aB=%_TypedArrayGetLength(this);
+var aA=aB;
+}
+if(az<0){
+az=D(0,aB+az);
+}else{
+az=E(az,aB);
+}
+if(aA<0){
+aA=D(0,aB+aA);
+}else{
+aA=E(aA,aB);
+}
+if(aA<az){
+aA=az;
+}
+var ak=aA-az;
+var aC=
+%_ArrayBufferViewGetByteOffset(this)+az*8;
+return TypedArraySpeciesCreate(this,%TypedArrayGetBuffer(this),
+aC,ak,true);
+}
+
+function Uint8ClampedArrayConstructByArrayBuffer(ad,ae,af,ag){
+if(!(af===(void 0))){
+af=H(af,180);
+}
+if(!(ag===(void 0))){
+ag=H(ag,180);
+}
+var ah=%_ArrayBufferGetByteLength(ae);
+var ai;
+if((af===(void 0))){
+ai=0;
+}else{
+ai=af;
+if(ai % 1!==0){
+throw B(179,
+"start offset","Uint8ClampedArray",1);
+}
+if(ai>ah){
+throw B(181);
+}
+}
+var aj;
+var ak;
+if((ag===(void 0))){
+if(ah % 1!==0){
+throw B(179,
+"byte length","Uint8ClampedArray",1);
+}
+aj=ah-ai;
+ak=aj/1;
+}else{
+var ak=ag;
+aj=ak*1;
+}
+if((ai+aj>ah)
+||(ak>%_MaxSmi())){
+throw B(180);
+}
+%_TypedArrayInitialize(ad,9,ae,ai,aj,true);
+}
+function Uint8ClampedArrayConstructByLength(ad,ag){
+var al=(ag===(void 0))?
+0:H(ag,180);
+if(al>%_MaxSmi()){
+throw B(180);
+}
+var am=al*1;
+if(am>%_TypedArrayMaxSizeInHeap()){
+var ae=new g(am);
+%_TypedArrayInitialize(ad,9,ae,0,am,true);
+}else{
+%_TypedArrayInitialize(ad,9,null,0,am,true);
+}
+}
+function Uint8ClampedArrayConstructByArrayLike(ad,an){
+var ag=an.length;
+var al=H(ag,180);
+if(al>%_MaxSmi()){
+throw B(180);
+}
+var ao=false;
+var am=al*1;
+if(am<=%_TypedArrayMaxSizeInHeap()){
+%_TypedArrayInitialize(ad,9,null,0,am,false);
+}else{
+ao=
+%TypedArrayInitializeFromArrayLike(ad,9,an,al);
+}
+if(!ao){
+for(var ap=0;ap<al;ap++){
+ad[ap]=an[ap];
+}
+}
+}
+function Uint8ClampedArrayConstructByIterable(ad,aq,ar){
+var as=new j();
+var at=%_Call(ar,aq);
+var au={
+__proto__:null
+};
+au[I]=function(){return at;}
+for(var av of au){
+as.push(av);
+}
+Uint8ClampedArrayConstructByArrayLike(ad,as);
+}
+function Uint8ClampedArrayConstructor(X,Y,aw){
+if(!(new.target===(void 0))){
+if((%_ClassOf(X)==='ArrayBuffer')||(%_ClassOf(X)==='SharedArrayBuffer')){
+Uint8ClampedArrayConstructByArrayBuffer(this,X,Y,aw);
+}else if((typeof(X)==='number')||(typeof(X)==='string')||
+(typeof(X)==='boolean')||(X===(void 0))){
+Uint8ClampedArrayConstructByLength(this,X);
+}else{
+var ar=X[I];
+if((ar===(void 0))||ar===e){
+Uint8ClampedArrayConstructByArrayLike(this,X);
+}else{
+Uint8ClampedArrayConstructByIterable(this,X,ar);
+}
+}
+}else{
+throw C(26,"Uint8ClampedArray")
+}
+}
+function Uint8ClampedArray_GetLength(){
+if(!(%_ClassOf(this)==='Uint8ClampedArray')){
+throw C(42,"Uint8ClampedArray.length",this);
+}
+return %_TypedArrayGetLength(this);
+}
+function Uint8ClampedArraySubArray(ax,ay){
+var az=(%_ToInteger(ax));
+if(!(ay===(void 0))){
+var aA=(%_ToInteger(ay));
+var aB=%_TypedArrayGetLength(this);
+}else{
+var aB=%_TypedArrayGetLength(this);
+var aA=aB;
+}
+if(az<0){
+az=D(0,aB+az);
+}else{
+az=E(az,aB);
+}
+if(aA<0){
+aA=D(0,aB+aA);
+}else{
+aA=E(aA,aB);
+}
+if(aA<az){
+aA=az;
+}
+var ak=aA-az;
+var aC=
+%_ArrayBufferViewGetByteOffset(this)+az*1;
+return TypedArraySpeciesCreate(this,%TypedArrayGetBuffer(this),
+aC,ak,true);
+}
+
+
+function TypedArraySubArray(ax,ay){
+switch(%_ClassOf(this)){
+case"Uint8Array":
+return %_Call(Uint8ArraySubArray,this,ax,ay);
+
+case"Int8Array":
+return %_Call(Int8ArraySubArray,this,ax,ay);
+
+case"Uint16Array":
+return %_Call(Uint16ArraySubArray,this,ax,ay);
+
+case"Int16Array":
+return %_Call(Int16ArraySubArray,this,ax,ay);
+
+case"Uint32Array":
+return %_Call(Uint32ArraySubArray,this,ax,ay);
+
+case"Int32Array":
+return %_Call(Int32ArraySubArray,this,ax,ay);
+
+case"Float32Array":
+return %_Call(Float32ArraySubArray,this,ax,ay);
+
+case"Float64Array":
+return %_Call(Float64ArraySubArray,this,ax,ay);
+
+case"Uint8ClampedArray":
+return %_Call(Uint8ClampedArraySubArray,this,ax,ay);
+
+
+}
+throw C(42,
+"get TypedArray.prototype.subarray",this);
+}
+%SetForceInlineFlag(TypedArraySubArray);
+function TypedArrayGetBuffer(){
+if(!%_IsTypedArray(this)){
+throw C(42,
+"get TypedArray.prototype.buffer",this);
+}
+return %TypedArrayGetBuffer(this);
+}
+%SetForceInlineFlag(TypedArrayGetBuffer);
+function TypedArrayGetByteLength(){
+if(!%_IsTypedArray(this)){
+throw C(42,
+"get TypedArray.prototype.byteLength",this);
+}
+return %_ArrayBufferViewGetByteLength(this);
+}
+%SetForceInlineFlag(TypedArrayGetByteLength);
+function TypedArrayGetByteOffset(){
+if(!%_IsTypedArray(this)){
+throw C(42,
+"get TypedArray.prototype.byteOffset",this);
+}
+return %_ArrayBufferViewGetByteOffset(this);
+}
+%SetForceInlineFlag(TypedArrayGetByteOffset);
+function TypedArrayGetLength(){
+if(!%_IsTypedArray(this)){
+throw C(42,
+"get TypedArray.prototype.length",this);
+}
+return %_TypedArrayGetLength(this);
+}
+%SetForceInlineFlag(TypedArrayGetLength);
+function TypedArraySetFromArrayLike(aD,aE,aF,ai){
+if(ai>0){
+for(var ap=0;ap<aF;ap++){
+aD[ai+ap]=aE[ap];
+}
+}
+else{
+for(var ap=0;ap<aF;ap++){
+aD[ap]=aE[ap];
+}
+}
+}
+function TypedArraySetFromOverlappingTypedArray(aD,aE,ai){
+var aG=aE.BYTES_PER_ELEMENT;
+var aH=aD.BYTES_PER_ELEMENT;
+var aF=aE.length;
+function CopyLeftPart(){
+var aI=aD.byteOffset+(ai+1)*aH;
+var aJ=aE.byteOffset;
+for(var aK=0;
+aK<aF&&aI<=aJ;
+aK++){
+aD[ai+aK]=aE[aK];
+aI+=aH;
+aJ+=aG;
+}
+return aK;
+}
+var aK=CopyLeftPart();
+function CopyRightPart(){
+var aI=
+aD.byteOffset+(ai+aF-1)*aH;
+var aJ=
+aE.byteOffset+aF*aG;
+for(var aL=aF-1;
+aL>=aK&&aI>=aJ;
+aL--){
+aD[ai+aL]=aE[aL];
+aI-=aH;
+aJ-=aG;
+}
+return aL;
+}
+var aL=CopyRightPart();
+var aM=new f(aL+1-aK);
+for(var ap=aK;ap<=aL;ap++){
+aM[ap-aK]=aE[ap];
+}
+for(ap=aK;ap<=aL;ap++){
+aD[ai+ap]=aM[ap-aK];
+}
+}
+function TypedArraySet(ad,ai){
+var aN=(ai===(void 0))?0:(%_ToInteger(ai));
+if(aN<0)throw C(190);
+if(aN>%_MaxSmi()){
+throw B(191);
+}
+switch(%TypedArraySetFastCases(this,ad,aN)){
+case 0:
+return;
+case 1:
+TypedArraySetFromOverlappingTypedArray(this,ad,aN);
+return;
+case 2:
+TypedArraySetFromArrayLike(this,ad,ad.length,aN);
+return;
+case 3:
+var al=ad.length;
+if((al===(void 0))){
+if((typeof(ad)==='number')){
+throw C(45);
+}
+return;
+}
+al=(%_ToLength(al));
+if(aN+al>this.length){
+throw B(191);
+}
+TypedArraySetFromArrayLike(this,ad,al,aN);
+return;
+}
+}
+function TypedArrayGetToStringTag(){
+if(!%_IsTypedArray(this))return;
+var aO=%_ClassOf(this);
+if((aO===(void 0)))return;
+return aO;
+}
+function TypedArrayCopyWithin(aD,aP,ay){
+if(!%_IsTypedArray(this))throw C(68);
+var ag=%_TypedArrayGetLength(this);
+return k(aD,aP,ay,this,ag);
+}
+%FunctionSetLength(TypedArrayCopyWithin,2);
+function TypedArrayEvery(aQ,aR){
+if(!%_IsTypedArray(this))throw C(68);
+var ag=%_TypedArrayGetLength(this);
+return l(aQ,aR,this,ag);
+}
+%FunctionSetLength(TypedArrayEvery,1);
+function TypedArrayForEach(aQ,aR){
+if(!%_IsTypedArray(this))throw C(68);
+var ag=%_TypedArrayGetLength(this);
+q(aQ,aR,this,ag);
+}
+%FunctionSetLength(TypedArrayForEach,1);
+function TypedArrayFill(av,aP,ay){
+if(!%_IsTypedArray(this))throw C(68);
+var ag=%_TypedArrayGetLength(this);
+return m(av,aP,ay,this,ag);
+}
+%FunctionSetLength(TypedArrayFill,1);
+function TypedArrayFilter(aQ,aS){
+if(!%_IsTypedArray(this))throw C(68);
+var ag=%_TypedArrayGetLength(this);
+if(!(typeof(aQ)==='function'))throw C(15,aQ);
+var aT=new j();
+n(aQ,aS,this,ag,aT);
+var aU=aT.length;
+var aV=TypedArraySpeciesCreate(this,aU);
+for(var ap=0;ap<aU;ap++){
+aV[ap]=aT[ap];
+}
+return aV;
+}
+%FunctionSetLength(TypedArrayFilter,1);
+function TypedArrayFind(aW,aS){
+if(!%_IsTypedArray(this))throw C(68);
+var ag=%_TypedArrayGetLength(this);
+return o(aW,aS,this,ag);
+}
+%FunctionSetLength(TypedArrayFind,1);
+function TypedArrayFindIndex(aW,aS){
+if(!%_IsTypedArray(this))throw C(68);
+var ag=%_TypedArrayGetLength(this);
+return p(aW,aS,this,ag);
+}
+%FunctionSetLength(TypedArrayFindIndex,1);
+function TypedArrayReverse(){
+if(!%_IsTypedArray(this))throw C(68);
+var ag=%_TypedArrayGetLength(this);
+return F(this,ag);
+}
+function TypedArrayComparefn(aX,aY){
+if(A(aX)&&A(aY)){
+return A(aY)?0:1;
+}
+if(A(aX)){
+return 1;
+}
+if(aX===0&&aX===aY){
+if(%_IsMinusZero(aX)){
+if(!%_IsMinusZero(aY)){
+return-1;
+}
+}else if(%_IsMinusZero(aY)){
+return 1;
+}
+}
+return aX-aY;
+}
+function TypedArraySort(aZ){
+if(!%_IsTypedArray(this))throw C(68);
+var ag=%_TypedArrayGetLength(this);
+if((aZ===(void 0))){
+aZ=TypedArrayComparefn;
+}
+return y(this,ag,aZ);
+}
+function TypedArrayIndexOf(ba,bb){
+if(!%_IsTypedArray(this))throw C(68);
+var ag=%_TypedArrayGetLength(this);
+return s(this,ba,bb,ag);
+}
+%FunctionSetLength(TypedArrayIndexOf,1);
+function TypedArrayLastIndexOf(ba,bb){
+if(!%_IsTypedArray(this))throw C(68);
+var ag=%_TypedArrayGetLength(this);
+return u(this,ba,bb,ag,
+%_ArgumentsLength());
+}
+%FunctionSetLength(TypedArrayLastIndexOf,1);
+function TypedArrayMap(aQ,aS){
+if(!%_IsTypedArray(this))throw C(68);
+var ag=%_TypedArrayGetLength(this);
+var aT=TypedArraySpeciesCreate(this,ag);
+if(!(typeof(aQ)==='function'))throw C(15,aQ);
+for(var ap=0;ap<ag;ap++){
+var ba=this[ap];
+aT[ap]=%_Call(aQ,aS,ba,ap,this);
+}
+return aT;
+}
+%FunctionSetLength(TypedArrayMap,1);
+function TypedArraySome(aQ,aR){
+if(!%_IsTypedArray(this))throw C(68);
+var ag=%_TypedArrayGetLength(this);
+return x(aQ,aR,this,ag);
+}
+%FunctionSetLength(TypedArraySome,1);
+function TypedArrayToLocaleString(){
+if(!%_IsTypedArray(this))throw C(68);
+var ag=%_TypedArrayGetLength(this);
+return z(this,ag);
+}
+function TypedArrayToString(){
+return %_Call(d,this);
+}
+function TypedArrayJoin(bc){
+if(!%_IsTypedArray(this))throw C(68);
+var ag=%_TypedArrayGetLength(this);
+return t(bc,this,ag);
+}
+function TypedArrayReduce(bd,be){
+if(!%_IsTypedArray(this))throw C(68);
+var ag=%_TypedArrayGetLength(this);
+return v(bd,be,this,ag,
+%_ArgumentsLength());
+}
+%FunctionSetLength(TypedArrayReduce,1);
+function TypedArrayReduceRight(bd,be){
+if(!%_IsTypedArray(this))throw C(68);
+var ag=%_TypedArrayGetLength(this);
+return w(bd,be,this,ag,
+%_ArgumentsLength());
+}
+%FunctionSetLength(TypedArrayReduceRight,1);
+function TypedArraySlice(aP,ay){
+if(!%_IsTypedArray(this))throw C(68);
+var bf=%_TypedArrayGetLength(this);
+var bg=(%_ToInteger(aP));
+var bh;
+if(bg<0){
+bh=D(bf+bg,0);
+}else{
+bh=E(bg,bf);
+}
+var bi;
+if((ay===(void 0))){
+bi=bf;
+}else{
+bi=(%_ToInteger(ay));
+}
+var bj;
+if(bi<0){
+bj=D(bf+bi,0);
+}else{
+bj=E(bi,bf);
+}
+var bk=D(bj-bh,0);
+var bl=TypedArraySpeciesCreate(this,bk);
+var bm=0;
+while(bh<bj){
+var bn=this[bh];
+bl[bm]=bn;
+bh++;
+bm++;
+}
+return bl;
+}
+function TypedArrayIncludes(bo,bp){
+if(!%_IsTypedArray(this))throw C(68);
+var ag=%_TypedArrayGetLength(this);
+return r(bo,bp,this,ag);
+}
+%FunctionSetLength(TypedArrayIncludes,1);
+function TypedArrayOf(){
+var ag=%_ArgumentsLength();
+var bl=TypedArrayCreate(this,ag);
+for(var ap=0;ap<ag;ap++){
+bl[ap]=%_Arguments(ap);
+}
+return bl;
+}
+function TypedArrayFrom(aE,bq,aS){
+var bl=%_Call(c,f,aE,bq,aS);
+return TypedArrayCreate(this,bl);
+}
+%FunctionSetLength(TypedArrayFrom,1);
+function TypedArray(){
+if((new.target===(void 0))){
+throw C(25,"TypedArray");
+}
+if(new.target===TypedArray){
+throw C(23,"TypedArray");
+}
+}
+%FunctionSetPrototype(TypedArray,new i());
+%AddNamedProperty(TypedArray.prototype,
+"constructor",TypedArray,2);
+b.InstallFunctions(TypedArray,2|4|1,[
+"from",TypedArrayFrom,
+"of",TypedArrayOf
+]);
+b.InstallGetter(TypedArray.prototype,"buffer",TypedArrayGetBuffer);
+b.InstallGetter(TypedArray.prototype,"byteOffset",TypedArrayGetByteOffset,
+2|4);
+b.InstallGetter(TypedArray.prototype,"byteLength",
+TypedArrayGetByteLength,2|4);
+b.InstallGetter(TypedArray.prototype,"length",TypedArrayGetLength,
+2|4);
+b.InstallGetter(TypedArray.prototype,J,
+TypedArrayGetToStringTag);
+b.InstallFunctions(TypedArray.prototype,2,[
+"subarray",TypedArraySubArray,
+"set",TypedArraySet,
+"copyWithin",TypedArrayCopyWithin,
+"every",TypedArrayEvery,
+"fill",TypedArrayFill,
+"filter",TypedArrayFilter,
+"find",TypedArrayFind,
+"findIndex",TypedArrayFindIndex,
+"includes",TypedArrayIncludes,
+"indexOf",TypedArrayIndexOf,
+"join",TypedArrayJoin,
+"lastIndexOf",TypedArrayLastIndexOf,
+"forEach",TypedArrayForEach,
+"map",TypedArrayMap,
+"reduce",TypedArrayReduce,
+"reduceRight",TypedArrayReduceRight,
+"reverse",TypedArrayReverse,
+"slice",TypedArraySlice,
+"some",TypedArraySome,
+"sort",TypedArraySort,
+"toString",TypedArrayToString,
+"toLocaleString",TypedArrayToLocaleString
+]);
+%SetCode(K,Uint8ArrayConstructor);
+%FunctionSetPrototype(K,new i());
+%InternalSetPrototype(K,TypedArray);
+%InternalSetPrototype(K.prototype,TypedArray.prototype);
+%AddNamedProperty(K,"BYTES_PER_ELEMENT",1,
+1|2|4);
+%AddNamedProperty(K.prototype,
+"constructor",a.Uint8Array,2);
+%AddNamedProperty(K.prototype,
+"BYTES_PER_ELEMENT",1,
+1|2|4);
+b.InstallGetter(K.prototype,"length",Uint8Array_GetLength,
+2|4);
+
+%SetCode(L,Int8ArrayConstructor);
+%FunctionSetPrototype(L,new i());
+%InternalSetPrototype(L,TypedArray);
+%InternalSetPrototype(L.prototype,TypedArray.prototype);
+%AddNamedProperty(L,"BYTES_PER_ELEMENT",1,
+1|2|4);
+%AddNamedProperty(L.prototype,
+"constructor",a.Int8Array,2);
+%AddNamedProperty(L.prototype,
+"BYTES_PER_ELEMENT",1,
+1|2|4);
+b.InstallGetter(L.prototype,"length",Int8Array_GetLength,
+2|4);
+
+%SetCode(M,Uint16ArrayConstructor);
+%FunctionSetPrototype(M,new i());
+%InternalSetPrototype(M,TypedArray);
+%InternalSetPrototype(M.prototype,TypedArray.prototype);
+%AddNamedProperty(M,"BYTES_PER_ELEMENT",2,
+1|2|4);
+%AddNamedProperty(M.prototype,
+"constructor",a.Uint16Array,2);
+%AddNamedProperty(M.prototype,
+"BYTES_PER_ELEMENT",2,
+1|2|4);
+b.InstallGetter(M.prototype,"length",Uint16Array_GetLength,
+2|4);
+
+%SetCode(N,Int16ArrayConstructor);
+%FunctionSetPrototype(N,new i());
+%InternalSetPrototype(N,TypedArray);
+%InternalSetPrototype(N.prototype,TypedArray.prototype);
+%AddNamedProperty(N,"BYTES_PER_ELEMENT",2,
+1|2|4);
+%AddNamedProperty(N.prototype,
+"constructor",a.Int16Array,2);
+%AddNamedProperty(N.prototype,
+"BYTES_PER_ELEMENT",2,
+1|2|4);
+b.InstallGetter(N.prototype,"length",Int16Array_GetLength,
+2|4);
+
+%SetCode(O,Uint32ArrayConstructor);
+%FunctionSetPrototype(O,new i());
+%InternalSetPrototype(O,TypedArray);
+%InternalSetPrototype(O.prototype,TypedArray.prototype);
+%AddNamedProperty(O,"BYTES_PER_ELEMENT",4,
+1|2|4);
+%AddNamedProperty(O.prototype,
+"constructor",a.Uint32Array,2);
+%AddNamedProperty(O.prototype,
+"BYTES_PER_ELEMENT",4,
+1|2|4);
+b.InstallGetter(O.prototype,"length",Uint32Array_GetLength,
+2|4);
+
+%SetCode(P,Int32ArrayConstructor);
+%FunctionSetPrototype(P,new i());
+%InternalSetPrototype(P,TypedArray);
+%InternalSetPrototype(P.prototype,TypedArray.prototype);
+%AddNamedProperty(P,"BYTES_PER_ELEMENT",4,
+1|2|4);
+%AddNamedProperty(P.prototype,
+"constructor",a.Int32Array,2);
+%AddNamedProperty(P.prototype,
+"BYTES_PER_ELEMENT",4,
+1|2|4);
+b.InstallGetter(P.prototype,"length",Int32Array_GetLength,
+2|4);
+
+%SetCode(Q,Float32ArrayConstructor);
+%FunctionSetPrototype(Q,new i());
+%InternalSetPrototype(Q,TypedArray);
+%InternalSetPrototype(Q.prototype,TypedArray.prototype);
+%AddNamedProperty(Q,"BYTES_PER_ELEMENT",4,
+1|2|4);
+%AddNamedProperty(Q.prototype,
+"constructor",a.Float32Array,2);
+%AddNamedProperty(Q.prototype,
+"BYTES_PER_ELEMENT",4,
+1|2|4);
+b.InstallGetter(Q.prototype,"length",Float32Array_GetLength,
+2|4);
+
+%SetCode(R,Float64ArrayConstructor);
+%FunctionSetPrototype(R,new i());
+%InternalSetPrototype(R,TypedArray);
+%InternalSetPrototype(R.prototype,TypedArray.prototype);
+%AddNamedProperty(R,"BYTES_PER_ELEMENT",8,
+1|2|4);
+%AddNamedProperty(R.prototype,
+"constructor",a.Float64Array,2);
+%AddNamedProperty(R.prototype,
+"BYTES_PER_ELEMENT",8,
+1|2|4);
+b.InstallGetter(R.prototype,"length",Float64Array_GetLength,
+2|4);
+
+%SetCode(S,Uint8ClampedArrayConstructor);
+%FunctionSetPrototype(S,new i());
+%InternalSetPrototype(S,TypedArray);
+%InternalSetPrototype(S.prototype,TypedArray.prototype);
+%AddNamedProperty(S,"BYTES_PER_ELEMENT",1,
+1|2|4);
+%AddNamedProperty(S.prototype,
+"constructor",a.Uint8ClampedArray,2);
+%AddNamedProperty(S.prototype,
+"BYTES_PER_ELEMENT",1,
+1|2|4);
+b.InstallGetter(S.prototype,"length",Uint8ClampedArray_GetLength,
+2|4);
+
+
+function DataViewConstructor(ae,af,am){
+if((new.target===(void 0))){
+throw C(26,"DataView");
+}
+if(!(%_ClassOf(ae)==='ArrayBuffer'))throw C(29);
+if(!(af===(void 0))){
+af=H(af,172);
+}
+if(!(am===(void 0))){
+am=(%_ToInteger(am));
+}
+var ah=%_ArrayBufferGetByteLength(ae);
+var ai=(af===(void 0))?0:af;
+if(ai>ah)throw B(172);
+var ag=(am===(void 0))
+?ah-ai
+:am;
+if(ag<0||ai+ag>ah){
+throw new B(171);
+}
+var aT=%NewObject(h,new.target);
+%_DataViewInitialize(aT,ae,ai,ag);
+return aT;
+}
+function DataViewGetBufferJS(){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,'DataView.buffer',this);
+}
+return %DataViewGetBuffer(this);
+}
+function DataViewGetByteOffset(){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.byteOffset',this);
+}
+return %_ArrayBufferViewGetByteOffset(this);
+}
+function DataViewGetByteLength(){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.byteLength',this);
+}
+return %_ArrayBufferViewGetByteLength(this);
+}
+function DataViewGetInt8JS(ai,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.getInt8',this);
+}
+if(%_ArgumentsLength()<1)throw C(45);
+ai=H(ai,170);
+return %DataViewGetInt8(this,ai,!!br);
+}
+function DataViewSetInt8JS(ai,av,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.setInt8',this);
+}
+if(%_ArgumentsLength()<2)throw C(45);
+ai=H(ai,170);
+%DataViewSetInt8(this,ai,(%_ToNumber(av)),!!br);
+}
+
+function DataViewGetUint8JS(ai,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.getUint8',this);
+}
+if(%_ArgumentsLength()<1)throw C(45);
+ai=H(ai,170);
+return %DataViewGetUint8(this,ai,!!br);
+}
+function DataViewSetUint8JS(ai,av,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.setUint8',this);
+}
+if(%_ArgumentsLength()<2)throw C(45);
+ai=H(ai,170);
+%DataViewSetUint8(this,ai,(%_ToNumber(av)),!!br);
+}
+
+function DataViewGetInt16JS(ai,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.getInt16',this);
+}
+if(%_ArgumentsLength()<1)throw C(45);
+ai=H(ai,170);
+return %DataViewGetInt16(this,ai,!!br);
+}
+function DataViewSetInt16JS(ai,av,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.setInt16',this);
+}
+if(%_ArgumentsLength()<2)throw C(45);
+ai=H(ai,170);
+%DataViewSetInt16(this,ai,(%_ToNumber(av)),!!br);
+}
+
+function DataViewGetUint16JS(ai,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.getUint16',this);
+}
+if(%_ArgumentsLength()<1)throw C(45);
+ai=H(ai,170);
+return %DataViewGetUint16(this,ai,!!br);
+}
+function DataViewSetUint16JS(ai,av,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.setUint16',this);
+}
+if(%_ArgumentsLength()<2)throw C(45);
+ai=H(ai,170);
+%DataViewSetUint16(this,ai,(%_ToNumber(av)),!!br);
+}
+
+function DataViewGetInt32JS(ai,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.getInt32',this);
+}
+if(%_ArgumentsLength()<1)throw C(45);
+ai=H(ai,170);
+return %DataViewGetInt32(this,ai,!!br);
+}
+function DataViewSetInt32JS(ai,av,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.setInt32',this);
+}
+if(%_ArgumentsLength()<2)throw C(45);
+ai=H(ai,170);
+%DataViewSetInt32(this,ai,(%_ToNumber(av)),!!br);
+}
+
+function DataViewGetUint32JS(ai,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.getUint32',this);
+}
+if(%_ArgumentsLength()<1)throw C(45);
+ai=H(ai,170);
+return %DataViewGetUint32(this,ai,!!br);
+}
+function DataViewSetUint32JS(ai,av,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.setUint32',this);
+}
+if(%_ArgumentsLength()<2)throw C(45);
+ai=H(ai,170);
+%DataViewSetUint32(this,ai,(%_ToNumber(av)),!!br);
+}
+
+function DataViewGetFloat32JS(ai,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.getFloat32',this);
+}
+if(%_ArgumentsLength()<1)throw C(45);
+ai=H(ai,170);
+return %DataViewGetFloat32(this,ai,!!br);
+}
+function DataViewSetFloat32JS(ai,av,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.setFloat32',this);
+}
+if(%_ArgumentsLength()<2)throw C(45);
+ai=H(ai,170);
+%DataViewSetFloat32(this,ai,(%_ToNumber(av)),!!br);
+}
+
+function DataViewGetFloat64JS(ai,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.getFloat64',this);
+}
+if(%_ArgumentsLength()<1)throw C(45);
+ai=H(ai,170);
+return %DataViewGetFloat64(this,ai,!!br);
+}
+function DataViewSetFloat64JS(ai,av,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.setFloat64',this);
+}
+if(%_ArgumentsLength()<2)throw C(45);
+ai=H(ai,170);
+%DataViewSetFloat64(this,ai,(%_ToNumber(av)),!!br);
+}
+
+
+%SetCode(h,DataViewConstructor);
+%FunctionSetPrototype(h,new i);
+%AddNamedProperty(h.prototype,"constructor",h,
+2);
+%AddNamedProperty(h.prototype,J,"DataView",
+1|2);
+b.InstallGetter(h.prototype,"buffer",DataViewGetBufferJS);
+b.InstallGetter(h.prototype,"byteOffset",
+DataViewGetByteOffset);
+b.InstallGetter(h.prototype,"byteLength",
+DataViewGetByteLength);
+b.InstallFunctions(h.prototype,2,[
+"getInt8",DataViewGetInt8JS,
+"setInt8",DataViewSetInt8JS,
+"getUint8",DataViewGetUint8JS,
+"setUint8",DataViewSetUint8JS,
+"getInt16",DataViewGetInt16JS,
+"setInt16",DataViewSetInt16JS,
+"getUint16",DataViewGetUint16JS,
+"setUint16",DataViewSetUint16JS,
+"getInt32",DataViewGetInt32JS,
+"setInt32",DataViewSetInt32JS,
+"getUint32",DataViewGetUint32JS,
+"setUint32",DataViewSetUint32JS,
+"getFloat32",DataViewGetFloat32JS,
+"setFloat32",DataViewSetFloat32JS,
+"getFloat64",DataViewGetFloat64JS,
+"setFloat64",DataViewSetFloat64JS
+]);
+})
+
+Hiterator-prototype�
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Object;
+var d=b.ImportNow("IteratorPrototype");
+var e=b.ImportNow("iterator_symbol");
+function IteratorPrototypeIterator(){
+return this;
+}
+b.SetFunctionName(IteratorPrototypeIterator,e);
+%AddNamedProperty(d,e,
+IteratorPrototypeIterator,2);
+})
+
+$generator�
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=b.ImportNow("GeneratorFunctionPrototype");
+var d=b.ImportNow("GeneratorFunction");
+var e=a.Function;
+var f;
+var g=b.ImportNow("to_string_tag_symbol");
+b.Import(function(h){
+f=h.MakeTypeError;
+});
+function GeneratorObjectNext(i){
+if(!(%_ClassOf(this)==='Generator')){
+throw f(42,
+'[Generator].prototype.next',this);
+}
+var j=%GeneratorGetContinuation(this);
+if(j>0){
+if(%_DebugIsActive()!=0)%DebugPrepareStepInIfStepping(this);
+try{
+return %_GeneratorNext(this,i);
+}catch(e){
+%GeneratorClose(this);
+throw e;
+}
+}else if(j==0){
+return{value:void 0,done:true};
+}else{
+throw f(40);
+}
+}
+function GeneratorObjectThrow(k){
+if(!(%_ClassOf(this)==='Generator')){
+throw f(42,
+'[Generator].prototype.throw',this);
+}
+var j=%GeneratorGetContinuation(this);
+if(j>0){
+try{
+return %_GeneratorThrow(this,k);
+}catch(e){
+%GeneratorClose(this);
+throw e;
+}
+}else if(j==0){
+throw k;
+}else{
+throw f(40);
+}
+}
+%NeverOptimizeFunction(GeneratorObjectNext);
+%NeverOptimizeFunction(GeneratorObjectThrow);
+var l=c.prototype;
+b.InstallFunctions(l,
+2,
+["next",GeneratorObjectNext,
+"throw",GeneratorObjectThrow]);
+%AddNamedProperty(l,"constructor",
+c,2|1);
+%AddNamedProperty(l,
+g,"Generator",2|1);
+%InternalSetPrototype(c,e.prototype);
+%AddNamedProperty(c,
+g,"GeneratorFunction",2|1);
+%AddNamedProperty(c,"constructor",
+d,2|1);
+%InternalSetPrototype(d,e);
+})
+
+8object-observeѭ
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c;
+var d=a.Array;
+var e=a.Object;
+var f=b.InternalArray;
+var g;
+b.Import(function(h){
+c=h.GetHash;
+g=h.MakeTypeError;
+});
+var i;
+var j={};
+function GetObservationStateJS(){
+if((i===(void 0))){
+i=%GetObservationState();
+}
+if((i.callbackInfoMap===(void 0))){
+i.callbackInfoMap=%ObservationWeakMapCreate();
+i.objectInfoMap=%ObservationWeakMapCreate();
+i.notifierObjectInfoMap=%ObservationWeakMapCreate();
+i.pendingObservers=null;
+i.nextCallbackPriority=0;
+i.lastMicrotaskId=0;
+}
+return i;
+}
+function GetPendingObservers(){
+return GetObservationStateJS().pendingObservers;
+}
+function SetPendingObservers(k){
+GetObservationStateJS().pendingObservers=k;
+}
+function GetNextCallbackPriority(){
+return GetObservationStateJS().nextCallbackPriority++;
+}
+function nullProtoObject(){
+return{__proto__:null};
+}
+function TypeMapCreate(){
+return nullProtoObject();
+}
+function TypeMapAddType(l,m,n){
+l[m]=n?1:(l[m]||0)+1;
+}
+function TypeMapRemoveType(l,m){
+l[m]--;
+}
+function TypeMapCreateFromList(o,p){
+var l=TypeMapCreate();
+for(var q=0;q<p;q++){
+TypeMapAddType(l,o[q],true);
+}
+return l;
+}
+function TypeMapHasType(l,m){
+return!!l[m];
+}
+function TypeMapIsDisjointFrom(r,s){
+if(!r||!s)
+return true;
+for(var m in r){
+if(TypeMapHasType(r,m)&&TypeMapHasType(s,m))
+return false;
+}
+return true;
+}
+var t=(function(){
+var u=[
+'add',
+'update',
+'delete',
+'setPrototype',
+'reconfigure',
+'preventExtensions'
+];
+return TypeMapCreateFromList(u,u.length);
+})();
+function ObserverCreate(v,w){
+if((w===(void 0)))
+return v;
+var x=nullProtoObject();
+x.callback=v;
+x.accept=w;
+return x;
+}
+function ObserverGetCallback(x){
+return(typeof(x)==='function')?x:x.callback;
+}
+function ObserverGetAcceptTypes(x){
+return(typeof(x)==='function')?t:x.accept;
+}
+function ObserverIsActive(x,y){
+return TypeMapIsDisjointFrom(ObjectInfoGetPerformingTypes(y),
+ObserverGetAcceptTypes(x));
+}
+function ObjectInfoGetOrCreate(z){
+var y=ObjectInfoGet(z);
+if((y===(void 0))){
+if(!(%_IsJSProxy(z))){
+%SetIsObserved(z);
+}
+y={
+object:z,
+changeObservers:null,
+notifier:null,
+performing:null,
+performingCount:0,
+};
+%WeakCollectionSet(GetObservationStateJS().objectInfoMap,
+z,y,c(z));
+}
+return y;
+}
+function ObjectInfoGet(z){
+return %WeakCollectionGet(GetObservationStateJS().objectInfoMap,z,
+c(z));
+}
+function ObjectInfoGetFromNotifier(A){
+return %WeakCollectionGet(GetObservationStateJS().notifierObjectInfoMap,
+A,c(A));
+}
+function ObjectInfoGetNotifier(y){
+if((y.notifier===null)){
+var A={__proto__:j};
+y.notifier=A;
+%WeakCollectionSet(GetObservationStateJS().notifierObjectInfoMap,
+A,y,c(A));
+}
+return y.notifier;
+}
+function ChangeObserversIsOptimized(B){
+return(typeof(B)==='function')||
+(typeof(B.callback)==='function');
+}
+function ObjectInfoNormalizeChangeObservers(y){
+if(ChangeObserversIsOptimized(y.changeObservers)){
+var x=y.changeObservers;
+var v=ObserverGetCallback(x);
+var C=CallbackInfoGet(v);
+var D=CallbackInfoGetPriority(C);
+y.changeObservers=nullProtoObject();
+y.changeObservers[D]=x;
+}
+}
+function ObjectInfoAddObserver(y,v,w){
+var C=CallbackInfoGetOrCreate(v);
+var x=ObserverCreate(v,w);
+if(!y.changeObservers){
+y.changeObservers=x;
+return;
+}
+ObjectInfoNormalizeChangeObservers(y);
+var D=CallbackInfoGetPriority(C);
+y.changeObservers[D]=x;
+}
+function ObjectInfoRemoveObserver(y,v){
+if(!y.changeObservers)
+return;
+if(ChangeObserversIsOptimized(y.changeObservers)){
+if(v===ObserverGetCallback(y.changeObservers))
+y.changeObservers=null;
+return;
+}
+var C=CallbackInfoGet(v);
+var D=CallbackInfoGetPriority(C);
+y.changeObservers[D]=null;
+}
+function ObjectInfoHasActiveObservers(y){
+if((y===(void 0))||!y.changeObservers)
+return false;
+if(ChangeObserversIsOptimized(y.changeObservers))
+return ObserverIsActive(y.changeObservers,y);
+for(var D in y.changeObservers){
+var x=y.changeObservers[D];
+if(!(x===null)&&ObserverIsActive(x,y))
+return true;
+}
+return false;
+}
+function ObjectInfoAddPerformingType(y,m){
+y.performing=y.performing||TypeMapCreate();
+TypeMapAddType(y.performing,m);
+y.performingCount++;
+}
+function ObjectInfoRemovePerformingType(y,m){
+y.performingCount--;
+TypeMapRemoveType(y.performing,m);
+}
+function ObjectInfoGetPerformingTypes(y){
+return y.performingCount>0?y.performing:null;
+}
+function ConvertAcceptListToTypeMap(E){
+if((E===(void 0)))
+return E;
+if(!(%_IsJSReceiver(E)))throw g(80);
+var F=(%_ToInteger(E.length));
+if(F<0)F=0;
+return TypeMapCreateFromList(E,F);
+}
+function CallbackInfoGet(v){
+return %WeakCollectionGet(GetObservationStateJS().callbackInfoMap,v,
+c(v));
+}
+function CallbackInfoSet(v,C){
+%WeakCollectionSet(GetObservationStateJS().callbackInfoMap,
+v,C,c(v));
+}
+function CallbackInfoGetOrCreate(v){
+var C=CallbackInfoGet(v);
+if(!(C===(void 0)))
+return C;
+var D=GetNextCallbackPriority();
+CallbackInfoSet(v,D);
+return D;
+}
+function CallbackInfoGetPriority(C){
+if((typeof(C)==='number'))
+return C;
+else
+return C.priority;
+}
+function CallbackInfoNormalize(v){
+var C=CallbackInfoGet(v);
+if((typeof(C)==='number')){
+var D=C;
+C=new f;
+C.priority=D;
+CallbackInfoSet(v,C);
+}
+return C;
+}
+function ObjectObserve(z,v,w){
+if(!(%_IsJSReceiver(z)))
+throw g(82,"observe","observe");
+if(%IsJSGlobalProxy(z))
+throw g(78,"observe");
+if(%IsAccessCheckNeeded(z))
+throw g(79,"observe");
+if(!(typeof(v)==='function'))
+throw g(81,"observe");
+if(%object_is_frozen(v))
+throw g(77);
+var G=%GetObjectContextObjectObserve(z);
+return G(z,v,w);
+}
+function NativeObjectObserve(z,v,w){
+var y=ObjectInfoGetOrCreate(z);
+var o=ConvertAcceptListToTypeMap(w);
+ObjectInfoAddObserver(y,v,o);
+return z;
+}
+function ObjectUnobserve(z,v){
+if(!(%_IsJSReceiver(z)))
+throw g(82,"unobserve","unobserve");
+if(%IsJSGlobalProxy(z))
+throw g(78,"unobserve");
+if(!(typeof(v)==='function'))
+throw g(81,"unobserve");
+var y=ObjectInfoGet(z);
+if((y===(void 0)))
+return z;
+ObjectInfoRemoveObserver(y,v);
+return z;
+}
+function ArrayObserve(z,v){
+return ObjectObserve(z,v,['add',
+'update',
+'delete',
+'splice']);
+}
+function ArrayUnobserve(z,v){
+return ObjectUnobserve(z,v);
+}
+function ObserverEnqueueIfActive(x,y,H){
+if(!ObserverIsActive(x,y)||
+!TypeMapHasType(ObserverGetAcceptTypes(x),H.type)){
+return;
+}
+var v=ObserverGetCallback(x);
+if(!%ObserverObjectAndRecordHaveSameOrigin(v,H.object,
+H)){
+return;
+}
+var C=CallbackInfoNormalize(v);
+if((GetPendingObservers()===null)){
+SetPendingObservers(nullProtoObject());
+if((%_DebugIsActive()!=0)){
+var I=++GetObservationStateJS().lastMicrotaskId;
+var J="Object.observe";
+%EnqueueMicrotask(function(){
+%DebugAsyncTaskEvent({type:"willHandle",id:I,name:J});
+ObserveMicrotaskRunner();
+%DebugAsyncTaskEvent({type:"didHandle",id:I,name:J});
+});
+%DebugAsyncTaskEvent({type:"enqueue",id:I,name:J});
+}else{
+%EnqueueMicrotask(ObserveMicrotaskRunner);
+}
+}
+GetPendingObservers()[C.priority]=v;
+C.push(H);
+}
+function ObjectInfoEnqueueExternalChangeRecord(y,H,m){
+if(!ObjectInfoHasActiveObservers(y))
+return;
+var K=!(m===(void 0));
+var L=K?
+{object:y.object,type:m}:
+{object:y.object};
+for(var M in H){
+if(M==='object'||(K&&M==='type'))continue;
+%DefineDataPropertyUnchecked(
+L,M,H[M],1+4);
+}
+%object_freeze(L);
+ObjectInfoEnqueueInternalChangeRecord(y,L);
+}
+function ObjectInfoEnqueueInternalChangeRecord(y,H){
+if((typeof(H.name)==='symbol'))return;
+if(ChangeObserversIsOptimized(y.changeObservers)){
+var x=y.changeObservers;
+ObserverEnqueueIfActive(x,y,H);
+return;
+}
+for(var D in y.changeObservers){
+var x=y.changeObservers[D];
+if((x===null))
+continue;
+ObserverEnqueueIfActive(x,y,H);
+}
+}
+function BeginPerformSplice(N){
+var y=ObjectInfoGet(N);
+if(!(y===(void 0)))
+ObjectInfoAddPerformingType(y,'splice');
+}
+function EndPerformSplice(N){
+var y=ObjectInfoGet(N);
+if(!(y===(void 0)))
+ObjectInfoRemovePerformingType(y,'splice');
+}
+function EnqueueSpliceRecord(N,O,P,Q){
+var y=ObjectInfoGet(N);
+if(!ObjectInfoHasActiveObservers(y))
+return;
+var H={
+type:'splice',
+object:N,
+index:O,
+removed:P,
+addedCount:Q
+};
+%object_freeze(H);
+%object_freeze(H.removed);
+ObjectInfoEnqueueInternalChangeRecord(y,H);
+}
+function NotifyChange(m,z,J,R){
+var y=ObjectInfoGet(z);
+if(!ObjectInfoHasActiveObservers(y))
+return;
+var H;
+if(arguments.length==2){
+H={type:m,object:z};
+}else if(arguments.length==3){
+H={type:m,object:z,name:J};
+}else{
+H={
+type:m,
+object:z,
+name:J,
+oldValue:R
+};
+}
+%object_freeze(H);
+ObjectInfoEnqueueInternalChangeRecord(y,H);
+}
+function ObjectNotifierNotify(H){
+if(!(%_IsJSReceiver(this)))
+throw g(16,"notify");
+var y=ObjectInfoGetFromNotifier(this);
+if((y===(void 0)))
+throw g(83);
+if(!(typeof(H.type)==='string'))
+throw g(86);
+ObjectInfoEnqueueExternalChangeRecord(y,H);
+}
+function ObjectNotifierPerformChange(S,T){
+if(!(%_IsJSReceiver(this)))
+throw g(16,"performChange");
+var y=ObjectInfoGetFromNotifier(this);
+if((y===(void 0)))
+throw g(83);
+if(!(typeof(S)==='string'))
+throw g(85);
+if(!(typeof(T)==='function'))
+throw g(84);
+var U=%GetObjectContextNotifierPerformChange(y);
+U(y,S,T);
+}
+function NativeObjectNotifierPerformChange(y,S,T){
+ObjectInfoAddPerformingType(y,S);
+var H;
+try{
+H=T();
+}finally{
+ObjectInfoRemovePerformingType(y,S);
+}
+if((%_IsJSReceiver(H)))
+ObjectInfoEnqueueExternalChangeRecord(y,H,S);
+}
+function ObjectGetNotifier(z){
+if(!(%_IsJSReceiver(z)))
+throw g(82,"getNotifier","getNotifier");
+if(%IsJSGlobalProxy(z))
+throw g(78,"getNotifier");
+if(%IsAccessCheckNeeded(z))
+throw g(79,"getNotifier");
+if(%object_is_frozen(z))return null;
+if(!%ObjectWasCreatedInCurrentOrigin(z))return null;
+var V=%GetObjectContextObjectGetNotifier(z);
+return V(z);
+}
+function NativeObjectGetNotifier(z){
+var y=ObjectInfoGetOrCreate(z);
+return ObjectInfoGetNotifier(y);
+}
+function CallbackDeliverPending(v){
+var C=CallbackInfoGet(v);
+if((C===(void 0))||(typeof(C)==='number'))
+return false;
+var D=C.priority;
+CallbackInfoSet(v,D);
+var k=GetPendingObservers();
+if(!(k===null))
+delete k[D];
+var W=[];
+%MoveArrayContents(C,W);
+%DeliverObservationChangeRecords(v,W);
+return true;
+}
+function ObjectDeliverChangeRecords(v){
+if(!(typeof(v)==='function'))
+throw g(81,"deliverChangeRecords");
+while(CallbackDeliverPending(v)){}
+}
+function ObserveMicrotaskRunner(){
+var k=GetPendingObservers();
+if(!(k===null)){
+SetPendingObservers(null);
+for(var q in k){
+CallbackDeliverPending(k[q]);
+}
+}
+}
+b.InstallFunctions(j,2,[
+"notify",ObjectNotifierNotify,
+"performChange",ObjectNotifierPerformChange
+]);
+var X=[
+"deliverChangeRecords",ObjectDeliverChangeRecords,
+"getNotifier",ObjectGetNotifier,
+"observe",ObjectObserve,
+"unobserve",ObjectUnobserve
+];
+var Y=[
+"observe",ArrayObserve,
+"unobserve",ArrayUnobserve
+];
+var Z=function(aa,q){
+if(q % 2===1)%FunctionRemovePrototype(aa);
+};
+X.forEach(Z);
+Y.forEach(Z);
+%InstallToContext([
+"native_object_get_notifier",NativeObjectGetNotifier,
+"native_object_notifier_perform_change",NativeObjectNotifierPerformChange,
+"native_object_observe",NativeObjectObserve,
+"observers_begin_perform_splice",BeginPerformSplice,
+"observers_end_perform_splice",EndPerformSplice,
+"observers_enqueue_splice",EnqueueSpliceRecord,
+"observers_notify_change",NotifyChange,
+]);
+b.Export(function(ab){
+ab.ObserveArrayMethods=Y;
+ab.ObserveBeginPerformSplice=BeginPerformSplice;
+ab.ObserveEndPerformSplice=EndPerformSplice;
+ab.ObserveEnqueueSpliceRecord=EnqueueSpliceRecord;
+ab.ObserveObjectMethods=X;
+});
+})
+
+(collectionE}
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Map;
+var d=a.Object;
+var e=a.Set;
+var f=b.ImportNow("hash_code_symbol");
+var g;
+var h;
+var i;
+var j;
+var k;
+var l=b.ImportNow("to_string_tag_symbol");
+b.Import(function(m){
+g=m.IntRandom;
+h=m.MakeTypeError;
+i=m.MapIterator;
+j=m.NumberIsNaN;
+k=m.SetIterator;
+});
+function HashToEntry(n,o,p){
+var q=(o&((p)-1));
+return((%_FixedArrayGet(n,(3+(q))|0)));
+}
+%SetForceInlineFlag(HashToEntry);
+function SetFindEntry(n,p,r,o){
+var s=HashToEntry(n,o,p);
+if(s===-1)return s;
+var t=((%_FixedArrayGet(n,((3+(p)+((s)<<1)))|0)));
+if(r===t)return s;
+var u=j(r);
+while(true){
+if(u&&j(t)){
+return s;
+}
+s=((%_FixedArrayGet(n,((3+(p)+((s)<<1))+1)|0)));
+if(s===-1)return s;
+t=((%_FixedArrayGet(n,((3+(p)+((s)<<1)))|0)));
+if(r===t)return s;
+}
+return-1;
+}
+%SetForceInlineFlag(SetFindEntry);
+function MapFindEntry(n,p,r,o){
+var s=HashToEntry(n,o,p);
+if(s===-1)return s;
+var t=((%_FixedArrayGet(n,((3+(p)+((s)*3)))|0)));
+if(r===t)return s;
+var u=j(r);
+while(true){
+if(u&&j(t)){
+return s;
+}
+s=((%_FixedArrayGet(n,((3+(p)+((s)*3))+2)|0)));
+if(s===-1)return s;
+t=((%_FixedArrayGet(n,((3+(p)+((s)*3)))|0)));
+if(r===t)return s;
+}
+return-1;
+}
+%SetForceInlineFlag(MapFindEntry);
+function ComputeIntegerHash(r,v){
+var o=r;
+o=o^v;
+o=~o+(o<<15);
+o=o^(o>>>12);
+o=o+(o<<2);
+o=o^(o>>>4);
+o=(o*2057)|0;
+o=o^(o>>>16);
+return o&0x3fffffff;
+}
+%SetForceInlineFlag(ComputeIntegerHash);
+function GetExistingHash(r){
+if(%_IsSmi(r)){
+return ComputeIntegerHash(r,0);
+}
+if((typeof(r)==='string')){
+var w=%_StringGetRawHashField(r);
+if((w&1)===0){
+return w>>>2;
+}
+}else if((%_IsJSReceiver(r))&&!(%_IsJSProxy(r))&&!(%_ClassOf(r)==='global')){
+var o=(r[f]);
+return o;
+}
+return %GenericHash(r);
+}
+%SetForceInlineFlag(GetExistingHash);
+function GetHash(r){
+var o=GetExistingHash(r);
+if((o===(void 0))){
+o=g()|0;
+if(o===0)o=1;
+(r[f]=o);
+}
+return o;
+}
+%SetForceInlineFlag(GetHash);
+function SetConstructor(x){
+if((new.target===(void 0))){
+throw h(26,"Set");
+}
+%_SetInitialize(this);
+if(!(x==null)){
+var y=this.add;
+if(!(typeof(y)==='function')){
+throw h(91,y,'add',this);
+}
+for(var z of x){
+%_Call(y,this,z);
+}
+}
+}
+function SetAdd(r){
+if(!(%_ClassOf(this)==='Set')){
+throw h(42,'Set.prototype.add',this);
+}
+if(r===0){
+r=0;
+}
+var n=%_JSCollectionGetTable(this);
+var p=((%_FixedArrayGet(n,(0)|0)));
+var o=GetHash(r);
+if(SetFindEntry(n,p,r,o)!==-1)return this;
+var A=((%_FixedArrayGet(n,(1)|0)));
+var B=((%_FixedArrayGet(n,(2)|0)));
+var C=p<<1;
+if((A+B)>=C){
+%SetGrow(this);
+n=%_JSCollectionGetTable(this);
+p=((%_FixedArrayGet(n,(0)|0)));
+A=((%_FixedArrayGet(n,(1)|0)));
+B=((%_FixedArrayGet(n,(2)|0)));
+}
+var s=A+B;
+var D=(3+(p)+((s)<<1));
+var q=(o&((p)-1));
+var E=((%_FixedArrayGet(n,(3+(q))|0)));
+((%_FixedArraySet(n,(3+(q))|0,s)));
+(((%_FixedArraySet(n,(1)|0,(A+1)|0))));
+(%_FixedArraySet(n,(D)|0,r));
+((%_FixedArraySet(n,(D+1)|0,(E)|0)));
+return this;
+}
+function SetHas(r){
+if(!(%_ClassOf(this)==='Set')){
+throw h(42,'Set.prototype.has',this);
+}
+var n=%_JSCollectionGetTable(this);
+var p=((%_FixedArrayGet(n,(0)|0)));
+var o=GetExistingHash(r);
+if((o===(void 0)))return false;
+return SetFindEntry(n,p,r,o)!==-1;
+}
+function SetDelete(r){
+if(!(%_ClassOf(this)==='Set')){
+throw h(42,
+'Set.prototype.delete',this);
+}
+var n=%_JSCollectionGetTable(this);
+var p=((%_FixedArrayGet(n,(0)|0)));
+var o=GetExistingHash(r);
+if((o===(void 0)))return false;
+var s=SetFindEntry(n,p,r,o);
+if(s===-1)return false;
+var A=((%_FixedArrayGet(n,(1)|0)))-1;
+var B=((%_FixedArrayGet(n,(2)|0)))+1;
+var D=(3+(p)+((s)<<1));
+(%_FixedArraySet(n,(D)|0,%_TheHole()));
+(((%_FixedArraySet(n,(1)|0,(A)|0))));
+(((%_FixedArraySet(n,(2)|0,(B)|0))));
+if(A<(p>>>1))%SetShrink(this);
+return true;
+}
+function SetGetSize(){
+if(!(%_ClassOf(this)==='Set')){
+throw h(42,
+'Set.prototype.size',this);
+}
+var n=%_JSCollectionGetTable(this);
+return((%_FixedArrayGet(n,(1)|0)));
+}
+function SetClearJS(){
+if(!(%_ClassOf(this)==='Set')){
+throw h(42,
+'Set.prototype.clear',this);
+}
+%_SetClear(this);
+}
+function SetForEach(F,G){
+if(!(%_ClassOf(this)==='Set')){
+throw h(42,
+'Set.prototype.forEach',this);
+}
+if(!(typeof(F)==='function'))throw h(15,F);
+var H=new k(this,2);
+var r;
+var I=[(void 0)];
+while(%SetIteratorNext(H,I)){
+r=I[0];
+%_Call(F,G,r,r,this);
+}
+}
+%SetCode(e,SetConstructor);
+%FunctionSetLength(e,0);
+%FunctionSetPrototype(e,new d());
+%AddNamedProperty(e.prototype,"constructor",e,2);
+%AddNamedProperty(e.prototype,l,"Set",
+2|1);
+%FunctionSetLength(SetForEach,1);
+b.InstallGetter(e.prototype,"size",SetGetSize);
+b.InstallFunctions(e.prototype,2,[
+"add",SetAdd,
+"has",SetHas,
+"delete",SetDelete,
+"clear",SetClearJS,
+"forEach",SetForEach
+]);
+function MapConstructor(x){
+if((new.target===(void 0))){
+throw h(26,"Map");
+}
+%_MapInitialize(this);
+if(!(x==null)){
+var y=this.set;
+if(!(typeof(y)==='function')){
+throw h(91,y,'set',this);
+}
+for(var J of x){
+if(!(%_IsJSReceiver(J))){
+throw h(49,J);
+}
+%_Call(y,this,J[0],J[1]);
+}
+}
+}
+function MapGet(r){
+if(!(%_ClassOf(this)==='Map')){
+throw h(42,
+'Map.prototype.get',this);
+}
+var n=%_JSCollectionGetTable(this);
+var p=((%_FixedArrayGet(n,(0)|0)));
+var o=GetExistingHash(r);
+if((o===(void 0)))return(void 0);
+var s=MapFindEntry(n,p,r,o);
+if(s===-1)return(void 0);
+return((%_FixedArrayGet(n,((3+(p)+((s)*3))+1)|0)));
+}
+function MapSet(r,z){
+if(!(%_ClassOf(this)==='Map')){
+throw h(42,
+'Map.prototype.set',this);
+}
+if(r===0){
+r=0;
+}
+var n=%_JSCollectionGetTable(this);
+var p=((%_FixedArrayGet(n,(0)|0)));
+var o=GetHash(r);
+var s=MapFindEntry(n,p,r,o);
+if(s!==-1){
+var K=(3+(p)+((s)*3));
+(%_FixedArraySet(n,(K+1)|0,z));
+return this;
+}
+var A=((%_FixedArrayGet(n,(1)|0)));
+var B=((%_FixedArrayGet(n,(2)|0)));
+var C=p<<1;
+if((A+B)>=C){
+%MapGrow(this);
+n=%_JSCollectionGetTable(this);
+p=((%_FixedArrayGet(n,(0)|0)));
+A=((%_FixedArrayGet(n,(1)|0)));
+B=((%_FixedArrayGet(n,(2)|0)));
+}
+s=A+B;
+var D=(3+(p)+((s)*3));
+var q=(o&((p)-1));
+var E=((%_FixedArrayGet(n,(3+(q))|0)));
+((%_FixedArraySet(n,(3+(q))|0,s)));
+(((%_FixedArraySet(n,(1)|0,(A+1)|0))));
+(%_FixedArraySet(n,(D)|0,r));
+(%_FixedArraySet(n,(D+1)|0,z));
+(%_FixedArraySet(n,(D+2)|0,E));
+return this;
+}
+function MapHas(r){
+if(!(%_ClassOf(this)==='Map')){
+throw h(42,
+'Map.prototype.has',this);
+}
+var n=%_JSCollectionGetTable(this);
+var p=((%_FixedArrayGet(n,(0)|0)));
+var o=GetHash(r);
+return MapFindEntry(n,p,r,o)!==-1;
+}
+function MapDelete(r){
+if(!(%_ClassOf(this)==='Map')){
+throw h(42,
+'Map.prototype.delete',this);
+}
+var n=%_JSCollectionGetTable(this);
+var p=((%_FixedArrayGet(n,(0)|0)));
+var o=GetHash(r);
+var s=MapFindEntry(n,p,r,o);
+if(s===-1)return false;
+var A=((%_FixedArrayGet(n,(1)|0)))-1;
+var B=((%_FixedArrayGet(n,(2)|0)))+1;
+var D=(3+(p)+((s)*3));
+(%_FixedArraySet(n,(D)|0,%_TheHole()));
+(%_FixedArraySet(n,(D+1)|0,%_TheHole()));
+(((%_FixedArraySet(n,(1)|0,(A)|0))));
+(((%_FixedArraySet(n,(2)|0,(B)|0))));
+if(A<(p>>>1))%MapShrink(this);
+return true;
+}
+function MapGetSize(){
+if(!(%_ClassOf(this)==='Map')){
+throw h(42,
+'Map.prototype.size',this);
+}
+var n=%_JSCollectionGetTable(this);
+return((%_FixedArrayGet(n,(1)|0)));
+}
+function MapClearJS(){
+if(!(%_ClassOf(this)==='Map')){
+throw h(42,
+'Map.prototype.clear',this);
+}
+%_MapClear(this);
+}
+function MapForEach(F,G){
+if(!(%_ClassOf(this)==='Map')){
+throw h(42,
+'Map.prototype.forEach',this);
+}
+if(!(typeof(F)==='function'))throw h(15,F);
+var H=new i(this,3);
+var I=[(void 0),(void 0)];
+while(%MapIteratorNext(H,I)){
+%_Call(F,G,I[1],I[0],this);
+}
+}
+%SetCode(c,MapConstructor);
+%FunctionSetLength(c,0);
+%FunctionSetPrototype(c,new d());
+%AddNamedProperty(c.prototype,"constructor",c,2);
+%AddNamedProperty(
+c.prototype,l,"Map",2|1);
+%FunctionSetLength(MapForEach,1);
+b.InstallGetter(c.prototype,"size",MapGetSize);
+b.InstallFunctions(c.prototype,2,[
+"get",MapGet,
+"set",MapSet,
+"has",MapHas,
+"delete",MapDelete,
+"clear",MapClearJS,
+"forEach",MapForEach
+]);
+%InstallToContext([
+"map_get",MapGet,
+"map_set",MapSet,
+"map_has",MapHas,
+"map_delete",MapDelete,
+"set_add",SetAdd,
+"set_has",SetHas,
+"set_delete",SetDelete,
+]);
+b.Export(function(L){
+L.GetExistingHash=GetExistingHash;
+L.GetHash=GetHash;
+});
+})
+
+<weak-collection�-
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c;
+var d;
+var e=a.Object;
+var f=a.WeakMap;
+var g=a.WeakSet;
+var h;
+var i=b.ImportNow("to_string_tag_symbol");
+b.Import(function(j){
+c=j.GetExistingHash;
+d=j.GetHash;
+h=j.MakeTypeError;
+});
+function WeakMapConstructor(k){
+if((new.target===(void 0))){
+throw h(26,"WeakMap");
+}
+%WeakCollectionInitialize(this);
+if(!(k==null)){
+var l=this.set;
+if(!(typeof(l)==='function')){
+throw h(91,l,'set',this);
+}
+for(var m of k){
+if(!(%_IsJSReceiver(m))){
+throw h(49,m);
+}
+%_Call(l,this,m[0],m[1]);
+}
+}
+}
+function WeakMapGet(n){
+if(!(%_ClassOf(this)==='WeakMap')){
+throw h(42,
+'WeakMap.prototype.get',this);
+}
+if(!(%_IsJSReceiver(n)))return(void 0);
+var o=c(n);
+if((o===(void 0)))return(void 0);
+return %WeakCollectionGet(this,n,o);
+}
+function WeakMapSet(n,p){
+if(!(%_ClassOf(this)==='WeakMap')){
+throw h(42,
+'WeakMap.prototype.set',this);
+}
+if(!(%_IsJSReceiver(n)))throw h(175);
+return %WeakCollectionSet(this,n,p,d(n));
+}
+function WeakMapHas(n){
+if(!(%_ClassOf(this)==='WeakMap')){
+throw h(42,
+'WeakMap.prototype.has',this);
+}
+if(!(%_IsJSReceiver(n)))return false;
+var o=c(n);
+if((o===(void 0)))return false;
+return %WeakCollectionHas(this,n,o);
+}
+function WeakMapDelete(n){
+if(!(%_ClassOf(this)==='WeakMap')){
+throw h(42,
+'WeakMap.prototype.delete',this);
+}
+if(!(%_IsJSReceiver(n)))return false;
+var o=c(n);
+if((o===(void 0)))return false;
+return %WeakCollectionDelete(this,n,o);
+}
+%SetCode(f,WeakMapConstructor);
+%FunctionSetLength(f,0);
+%FunctionSetPrototype(f,new e());
+%AddNamedProperty(f.prototype,"constructor",f,
+2);
+%AddNamedProperty(f.prototype,i,"WeakMap",
+2|1);
+b.InstallFunctions(f.prototype,2,[
+"get",WeakMapGet,
+"set",WeakMapSet,
+"has",WeakMapHas,
+"delete",WeakMapDelete
+]);
+function WeakSetConstructor(k){
+if((new.target===(void 0))){
+throw h(26,"WeakSet");
+}
+%WeakCollectionInitialize(this);
+if(!(k==null)){
+var l=this.add;
+if(!(typeof(l)==='function')){
+throw h(91,l,'add',this);
+}
+for(var p of k){
+%_Call(l,this,p);
+}
+}
+}
+function WeakSetAdd(p){
+if(!(%_ClassOf(this)==='WeakSet')){
+throw h(42,
+'WeakSet.prototype.add',this);
+}
+if(!(%_IsJSReceiver(p)))throw h(176);
+return %WeakCollectionSet(this,p,true,d(p));
+}
+function WeakSetHas(p){
+if(!(%_ClassOf(this)==='WeakSet')){
+throw h(42,
+'WeakSet.prototype.has',this);
+}
+if(!(%_IsJSReceiver(p)))return false;
+var o=c(p);
+if((o===(void 0)))return false;
+return %WeakCollectionHas(this,p,o);
+}
+function WeakSetDelete(p){
+if(!(%_ClassOf(this)==='WeakSet')){
+throw h(42,
+'WeakSet.prototype.delete',this);
+}
+if(!(%_IsJSReceiver(p)))return false;
+var o=c(p);
+if((o===(void 0)))return false;
+return %WeakCollectionDelete(this,p,o);
+}
+%SetCode(g,WeakSetConstructor);
+%FunctionSetLength(g,0);
+%FunctionSetPrototype(g,new e());
+%AddNamedProperty(g.prototype,"constructor",g,
+2);
+%AddNamedProperty(g.prototype,i,"WeakSet",
+2|1);
+b.InstallFunctions(g.prototype,2,[
+"add",WeakSetAdd,
+"has",WeakSetHas,
+"delete",WeakSetDelete
+]);
+})
+
+Lcollection-iterator(
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Map;
+var d=a.Set;
+var e=b.ImportNow("iterator_symbol");
+var f;
+var g=b.ImportNow("MapIterator");
+var h=b.ImportNow("to_string_tag_symbol");
+var i=b.ImportNow("SetIterator");
+b.Import(function(j){
+f=j.MakeTypeError;
+});
+function SetIteratorConstructor(k,l){
+%SetIteratorInitialize(this,k,l);
+}
+function SetIteratorNextJS(){
+if(!(%_ClassOf(this)==='Set Iterator')){
+throw f(42,
+'Set Iterator.prototype.next',this);
+}
+var m=[(void 0),(void 0)];
+var n=%_CreateIterResultObject(m,false);
+switch(%SetIteratorNext(this,m)){
+case 0:
+n.value=(void 0);
+n.done=true;
+break;
+case 2:
+n.value=m[0];
+break;
+case 3:
+m[1]=m[0];
+break;
+}
+return n;
+}
+function SetEntries(){
+if(!(%_ClassOf(this)==='Set')){
+throw f(42,
+'Set.prototype.entries',this);
+}
+return new i(this,3);
+}
+function SetValues(){
+if(!(%_ClassOf(this)==='Set')){
+throw f(42,
+'Set.prototype.values',this);
+}
+return new i(this,2);
+}
+%SetCode(i,SetIteratorConstructor);
+%FunctionSetInstanceClassName(i,'Set Iterator');
+b.InstallFunctions(i.prototype,2,[
+'next',SetIteratorNextJS
+]);
+%AddNamedProperty(i.prototype,h,
+"Set Iterator",1|2);
+b.InstallFunctions(d.prototype,2,[
+'entries',SetEntries,
+'keys',SetValues,
+'values',SetValues
+]);
+%AddNamedProperty(d.prototype,e,SetValues,2);
+function MapIteratorConstructor(o,l){
+%MapIteratorInitialize(this,o,l);
+}
+function MapIteratorNextJS(){
+if(!(%_ClassOf(this)==='Map Iterator')){
+throw f(42,
+'Map Iterator.prototype.next',this);
+}
+var m=[(void 0),(void 0)];
+var n=%_CreateIterResultObject(m,false);
+switch(%MapIteratorNext(this,m)){
+case 0:
+n.value=(void 0);
+n.done=true;
+break;
+case 1:
+n.value=m[0];
+break;
+case 2:
+n.value=m[1];
+break;
+}
+return n;
+}
+function MapEntries(){
+if(!(%_ClassOf(this)==='Map')){
+throw f(42,
+'Map.prototype.entries',this);
+}
+return new g(this,3);
+}
+function MapKeys(){
+if(!(%_ClassOf(this)==='Map')){
+throw f(42,
+'Map.prototype.keys',this);
+}
+return new g(this,1);
+}
+function MapValues(){
+if(!(%_ClassOf(this)==='Map')){
+throw f(42,
+'Map.prototype.values',this);
+}
+return new g(this,2);
+}
+%SetCode(g,MapIteratorConstructor);
+%FunctionSetInstanceClassName(g,'Map Iterator');
+b.InstallFunctions(g.prototype,2,[
+'next',MapIteratorNextJS
+]);
+%AddNamedProperty(g.prototype,h,
+"Map Iterator",1|2);
+b.InstallFunctions(c.prototype,2,[
+'entries',MapEntries,
+'keys',MapKeys,
+'values',MapValues
+]);
+%AddNamedProperty(c.prototype,e,MapEntries,2);
+b.Export(function(p){
+p.MapEntries=MapEntries;
+p.MapIteratorNext=MapIteratorNextJS;
+p.SetIteratorNext=SetIteratorNextJS;
+p.SetValues=SetValues;
+});
+})
+
+promiseQs
+(function(a,b,c){
+"use strict";
+%CheckIsBootstrapping();
+var d=b.InternalArray;
+var e;
+var f=
+b.ImportNow("promise_combined_deferred_symbol");
+var g=
+b.ImportNow("promise_has_handler_symbol");
+var h=b.ImportNow("promise_on_reject_symbol");
+var i=
+b.ImportNow("promise_on_resolve_symbol");
+var j=b.ImportNow("promise_raw_symbol");
+var k=b.ImportNow("promise_status_symbol");
+var l=b.ImportNow("promise_value_symbol");
+var m;
+var n=b.ImportNow("to_string_tag_symbol");
+b.Import(function(o){
+e=o.MakeTypeError;
+m=o.SpeciesConstructor;
+});
+var p=0;
+function CreateResolvingFunctions(q){
+var r=false;
+var s=value=>{
+if(r===true)return;
+r=true;
+PromiseResolve(q,value);
+};
+var t=reason=>{
+if(r===true)return;
+r=true;
+PromiseReject(q,reason);
+};
+return{
+__proto__:null,
+resolve:s,
+reject:t
+};
+}
+var u=function Promise(v){
+if(v===j){
+return %NewObject(u,new.target);
+}
+if((new.target===(void 0)))throw e(61,this);
+if(!(typeof(v)==='function'))
+throw e(134,v);
+var q=PromiseInit(%NewObject(u,new.target));
+var w=CreateResolvingFunctions(q);
+try{
+%DebugPushPromise(q,Promise);
+v(w.resolve,w.reject);
+}catch(e){
+%_Call(w.reject,(void 0),e);
+}finally{
+%DebugPopPromise();
+}
+return q;
+}
+function PromiseSet(q,x,y,z,A){
+(q[k]=x);
+(q[l]=y);
+(q[i]=z);
+(q[h]=A);
+if((%_DebugIsActive()!=0)){
+%DebugPromiseEvent({promise:q,status:x,value:y});
+}
+return q;
+}
+function PromiseCreateAndSet(x,y){
+var q=new u(j);
+if((%_DebugIsActive()!=0))PromiseSet(q,0,(void 0));
+return PromiseSet(q,x,y);
+}
+function PromiseInit(q){
+return PromiseSet(
+q,0,(void 0),new d,new d)
+}
+function PromiseDone(q,x,y,B){
+if((q[k])===0){
+var C=(q[B]);
+if(C.length)PromiseEnqueue(y,C,x);
+PromiseSet(q,x,y);
+}
+}
+function PromiseHandle(y,D,E){
+try{
+%DebugPushPromise(E.promise,PromiseHandle);
+var F=D(y);
+E.resolve(F);
+}catch(exception){
+try{E.reject(exception);}catch(e){}
+}finally{
+%DebugPopPromise();
+}
+}
+function PromiseEnqueue(y,C,x){
+var G,H,I=(%_DebugIsActive()!=0);
+%EnqueueMicrotask(function(){
+if(I){
+%DebugAsyncTaskEvent({type:"willHandle",id:G,name:H});
+}
+for(var J=0;J<C.length;J+=2){
+PromiseHandle(y,C[J],C[J+1])
+}
+if(I){
+%DebugAsyncTaskEvent({type:"didHandle",id:G,name:H});
+}
+});
+if(I){
+G=++p;
+H=x>0?"Promise.resolve":"Promise.reject";
+%DebugAsyncTaskEvent({type:"enqueue",id:G,name:H});
+}
+}
+function PromiseIdResolveHandler(K){return K}
+function PromiseIdRejectHandler(L){throw L}
+function PromiseNopResolver(){}
+function IsPromise(K){
+return(%_IsJSReceiver(K))&&(!(K[k]===(void 0)));
+}
+function PromiseCreate(){
+return new u(PromiseNopResolver)
+}
+function PromiseResolve(q,K){
+if(K===q){
+return PromiseReject(q,e(88,K));
+}
+if((%_IsJSReceiver(K))){
+try{
+var M=K.then;
+}catch(e){
+return PromiseReject(q,e);
+}
+if((typeof(M)==='function')){
+var G,H,I=(%_DebugIsActive()!=0);
+%EnqueueMicrotask(function(){
+if(I){
+%DebugAsyncTaskEvent({type:"willHandle",id:G,name:H});
+}
+var w=CreateResolvingFunctions(q);
+try{
+%_Call(M,K,w.resolve,w.reject);
+}catch(e){
+%_Call(w.reject,(void 0),e);
+}
+if(I){
+%DebugAsyncTaskEvent({type:"didHandle",id:G,name:H});
+}
+});
+if(I){
+G=++p;
+H="PromseResolveThenableJob";
+%DebugAsyncTaskEvent({type:"enqueue",id:G,name:H});
+}
+return;
+}
+}
+PromiseDone(q,+1,K,i);
+}
+function PromiseReject(q,L){
+if((q[k])==0){
+var N=(%_DebugIsActive()!=0);
+if(N||
+!(!(q[g]===(void 0)))){
+%PromiseRejectEvent(q,L,N);
+}
+}
+PromiseDone(q,-1,L,h)
+}
+function NewPromiseCapability(O){
+if(O===u){
+var q=PromiseInit(new u(j));
+var w=CreateResolvingFunctions(q);
+return{
+promise:q,
+resolve:w.resolve,
+reject:w.reject
+};
+}
+var F={promise:(void 0),resolve:(void 0),reject:(void 0)};
+F.promise=new O((s,t)=>{
+if(!(F.resolve===(void 0))||!(F.reject===(void 0)))
+throw e(89);
+F.resolve=s;
+F.reject=t;
+});
+return F;
+}
+function PromiseDeferred(){
+%IncrementUseCounter(19);
+return NewPromiseCapability(this);
+}
+function PromiseResolved(K){
+%IncrementUseCounter(18);
+return %_Call(PromiseCast,this,K);
+}
+function PromiseRejected(L){
+if(!(%_IsJSReceiver(this))){
+throw e(16,PromiseRejected);
+}
+if(this===u){
+var q=PromiseCreateAndSet(-1,L);
+%PromiseRejectEvent(q,L,false);
+return q;
+}else{
+var P=NewPromiseCapability(this);
+%_Call(P.reject,(void 0),L);
+return P.promise;
+}
+}
+function PromiseThen(z,A){
+var x=(this[k]);
+if((x===(void 0))){
+throw e(61,this);
+}
+var Q=m(this,u);
+z=(typeof(z)==='function')?z:PromiseIdResolveHandler;
+A=(typeof(A)==='function')?A:PromiseIdRejectHandler;
+var E=NewPromiseCapability(Q);
+switch(x){
+case 0:
+(this[i]).push(z,E);
+(this[h]).push(A,E);
+break;
+case+1:
+PromiseEnqueue((this[l]),
+[z,E],
++1);
+break;
+case-1:
+if(!(!(this[g]===(void 0)))){
+%PromiseRevokeReject(this);
+}
+PromiseEnqueue((this[l]),
+[A,E],
+-1);
+break;
+}
+(this[g]=true);
+if((%_DebugIsActive()!=0)){
+%DebugPromiseEvent({promise:E.promise,parentPromise:this});
+}
+return E.promise;
+}
+function PromiseChain(z,A){
+%IncrementUseCounter(17);
+return %_Call(PromiseThen,this,z,A);
+}
+function PromiseCatch(A){
+return this.then((void 0),A);
+}
+function PromiseCast(K){
+if(!(%_IsJSReceiver(this))){
+throw e(16,PromiseCast);
+}
+if(IsPromise(K)&&K.constructor===this)return K;
+var P=NewPromiseCapability(this);
+var R=%_Call(P.resolve,(void 0),K);
+return P.promise;
+}
+function PromiseAll(S){
+if(!(%_IsJSReceiver(this))){
+throw e(16,"Promise.all");
+}
+var E=NewPromiseCapability(this);
+var T=new d();
+var U;
+function CreateResolveElementFunction(V,W,P){
+var X=false;
+return(K)=>{
+if(X===true)return;
+X=true;
+W[V]=K;
+if(--U===0){
+var Y=[];
+%MoveArrayContents(W,Y);
+%_Call(P.resolve,(void 0),Y);
+}
+};
+}
+try{
+var J=0;
+U=1;
+for(var y of S){
+var Z=this.resolve(y);
+++U;
+Z.then(
+CreateResolveElementFunction(J,T,E),
+E.reject);
+(E.reject[f]=E);
+++J;
+}
+if(--U===0){
+var Y=[];
+%MoveArrayContents(T,Y);
+%_Call(E.resolve,(void 0),Y);
+}
+}catch(e){
+%_Call(E.reject,(void 0),e);
+}
+return E.promise;
+}
+function PromiseRace(S){
+if(!(%_IsJSReceiver(this))){
+throw e(16,PromiseRace);
+}
+var E=NewPromiseCapability(this);
+try{
+for(var y of S){
+this.resolve(y).then(E.resolve,E.reject);
+(E.reject[f]=E);
+}
+}catch(e){
+E.reject(e)
+}
+return E.promise;
+}
+function PromiseHasUserDefinedRejectHandlerRecursive(q){
+var aa=(q[h]);
+if((aa===(void 0)))return false;
+for(var J=0;J<aa.length;J+=2){
+var D=aa[J];
+if(D!==PromiseIdRejectHandler){
+var E=(D[f]);
+if((E===(void 0)))return true;
+if(PromiseHasUserDefinedRejectHandlerRecursive(E.promise)){
+return true;
+}
+}else if(PromiseHasUserDefinedRejectHandlerRecursive(
+aa[J+1].promise)){
+return true;
+}
+}
+return false;
+}
+function PromiseHasUserDefinedRejectHandler(){
+return PromiseHasUserDefinedRejectHandlerRecursive(this);
+};
+%AddNamedProperty(a,'Promise',u,2);
+%AddNamedProperty(u.prototype,n,"Promise",
+2|1);
+b.InstallFunctions(u,2,[
+"reject",PromiseRejected,
+"all",PromiseAll,
+"race",PromiseRace,
+"resolve",PromiseCast
+]);
+b.InstallFunctions(u.prototype,2,[
+"then",PromiseThen,
+"catch",PromiseCatch
+]);
+%InstallToContext([
+"promise_catch",PromiseCatch,
+"promise_chain",PromiseChain,
+"promise_create",PromiseCreate,
+"promise_has_user_defined_reject_handler",PromiseHasUserDefinedRejectHandler,
+"promise_reject",PromiseReject,
+"promise_resolve",PromiseResolve,
+"promise_then",PromiseThen,
+]);
+b.InstallFunctions(c,0,[
+"createPromise",PromiseCreate,
+"resolvePromise",PromiseResolve,
+"rejectPromise",PromiseReject
+]);
+[PromiseChain,PromiseDeferred,PromiseResolved].forEach(
+fn=>%FunctionRemovePrototype(fn));
+b.Export(function(ab){
+ab.PromiseChain=PromiseChain;
+ab.PromiseDeferred=PromiseDeferred;
+ab.PromiseResolved=PromiseResolved;
+});
+})
+
+ messages��
+(function(a,b){
+%CheckIsBootstrapping();
+var c;
+var d;
+var e;
+var f;
+var g=
+b.ImportNow("call_site_receiver_symbol");
+var h=
+b.ImportNow("call_site_function_symbol");
+var i=
+b.ImportNow("call_site_position_symbol");
+var j=
+b.ImportNow("call_site_strict_symbol");
+var k;
+var l;
+var m=
+b.ImportNow("formatted_stack_trace_symbol");
+var n=a.Object;
+var o;
+var p;
+var q;
+var r=b.InternalArray;
+var s=b.ImportNow("internal_error_symbol");
+var t;
+var u=b.ImportNow("object_to_string");
+var v=b.ImportNow("Script");
+var w=b.ImportNow("stack_trace_symbol");
+var x;
+var y;
+var z;
+var A;
+var B=b.ImportNow("to_string_tag_symbol");
+var C;
+var D;
+var E;
+b.Import(function(F){
+c=F.ArrayJoin;
+d=F.Bool16x8ToString;
+e=F.Bool32x4ToString;
+f=F.Bool8x16ToString;
+l=F.Float32x4ToString;
+o=F.Int16x8ToString;
+p=F.Int32x4ToString;
+q=F.Int8x16ToString;
+t=F.ObjectDefineProperty;
+x=F.StringCharAt;
+y=F.StringIndexOf;
+z=F.StringSubstring;
+A=F.SymbolToString;
+C=F.Uint16x8ToString;
+D=F.Uint32x4ToString;
+E=F.Uint8x16ToString;
+});
+b.ImportFromExperimental(function(F){
+k=F.FLAG_harmony_tostring;
+});
+var G;
+var H;
+var I;
+var J;
+var K;
+var L;
+var M;
+function NoSideEffectsObjectToString(){
+if((this===(void 0)))return"[object Undefined]";
+if((this===null))return"[object Null]";
+var N=(%_ToObject(this));
+var O=%_ClassOf(N);
+var P;
+if(k){
+P=%GetDataProperty(N,B);
+if(!(typeof(P)==='string')){
+P=O;
+}
+}else{
+P=O;
+}
+return`[object ${P}]`;
+}
+function IsErrorObject(Q){
+return(%HasOwnProperty(Q,w));
+}
+function NoSideEffectsErrorToString(){
+var R=%GetDataProperty(this,"name");
+var S=%GetDataProperty(this,"message");
+R=(R===(void 0))?"Error":NoSideEffectsToString(R);
+S=(S===(void 0))?"":NoSideEffectsToString(S);
+if(R=="")return S;
+if(S=="")return R;
+return`${R}: ${S}`;
+}
+function NoSideEffectsToString(Q){
+if((typeof(Q)==='string'))return Q;
+if((typeof(Q)==='number'))return %_NumberToString(Q);
+if((typeof(Q)==='boolean'))return Q?'true':'false';
+if((Q===(void 0)))return'undefined';
+if((Q===null))return'null';
+if((%_IsFunction(Q))){
+var T=%FunctionToString(Q);
+if(T.length>128){
+T=%_SubString(T,0,111)+"...<omitted>..."+
+%_SubString(T,T.length-2,T.length);
+}
+return T;
+}
+if((typeof(Q)==='symbol'))return %_Call(A,Q);
+if((%_IsSimdValue(Q))){
+switch(typeof(Q)){
+case'float32x4':return %_Call(l,Q);
+case'int32x4':return %_Call(p,Q);
+case'int16x8':return %_Call(o,Q);
+case'int8x16':return %_Call(q,Q);
+case'uint32x4':return %_Call(D,Q);
+case'uint16x8':return %_Call(C,Q);
+case'uint8x16':return %_Call(E,Q);
+case'bool32x4':return %_Call(e,Q);
+case'bool16x8':return %_Call(d,Q);
+case'bool8x16':return %_Call(f,Q);
+}
+}
+if((%_IsJSReceiver(Q))){
+if(IsErrorObject(Q)||
+%GetDataProperty(Q,"toString")===ErrorToString){
+return %_Call(NoSideEffectsErrorToString,Q);
+}
+if(%GetDataProperty(Q,"toString")===u){
+var U=%GetDataProperty(Q,"constructor");
+if((%_IsFunction(U))){
+var V=%FunctionGetName(U);
+if(V!="")return`#<${V}>`;
+}
+}
+}
+return %_Call(NoSideEffectsObjectToString,Q);
+}
+function MakeGenericError(U,W,X,Y,Z){
+var aa=new U(FormatMessage(W,X,Y,Z));
+aa[s]=true;
+return aa;
+}
+%FunctionSetInstanceClassName(v,'Script');
+%AddNamedProperty(v.prototype,'constructor',v,
+2|4|1);
+%SetCode(v,function(ab){
+throw MakeError(6);
+});
+function FormatMessage(W,X,Y,Z){
+var X=NoSideEffectsToString(X);
+var Y=NoSideEffectsToString(Y);
+var Z=NoSideEffectsToString(Z);
+try{
+return %FormatMessageString(W,X,Y,Z);
+}catch(e){
+return"<error>";
+}
+}
+function GetLineNumber(S){
+var ac=%MessageGetStartPosition(S);
+if(ac==-1)return 0;
+var ad=%MessageGetScript(S);
+var ae=ad.locationFromPosition(ac,true);
+if(ae==null)return 0;
+return ae.line+1;
+}
+function GetColumnNumber(S){
+var ad=%MessageGetScript(S);
+var ac=%MessageGetStartPosition(S);
+var ae=ad.locationFromPosition(ac,true);
+if(ae==null)return-1;
+return ae.column;
+}
+function GetSourceLine(S){
+var ad=%MessageGetScript(S);
+var ac=%MessageGetStartPosition(S);
+var ae=ad.locationFromPosition(ac,true);
+if(ae==null)return"";
+return ae.sourceText();
+}
+function ScriptLineFromPosition(af){
+var ag=0;
+var ah=this.lineCount()-1;
+var ai=this.line_ends;
+if(af>ai[ah]){
+return-1;
+}
+if(af<=ai[0]){
+return 0;
+}
+while(ah>=1){
+var aj=(ag+ah)>>1;
+if(af>ai[aj]){
+ag=aj+1;
+}else if(af<=ai[aj-1]){
+ah=aj-1;
+}else{
+return aj;
+}
+}
+return-1;
+}
+function ScriptLocationFromPosition(af,
+include_resource_offset){
+var ak=this.lineFromPosition(af);
+if(ak==-1)return null;
+var ai=this.line_ends;
+var al=ak==0?0:ai[ak-1]+1;
+var am=ai[ak];
+if(am>0&&%_Call(x,this.source,am-1)=='\r'){
+am--;
+}
+var an=af-al;
+if(include_resource_offset){
+ak+=this.line_offset;
+if(ak==this.line_offset){
+an+=this.column_offset;
+}
+}
+return new SourceLocation(this,af,ak,an,al,am);
+}
+function ScriptLocationFromLine(ao,ap,aq){
+var ak=0;
+if(!(ao===(void 0))){
+ak=ao-this.line_offset;
+}
+var an=ap||0;
+if(ak==0){
+an-=this.column_offset;
+}
+var ar=aq||0;
+if(ak<0||an<0||ar<0)return null;
+if(ak==0){
+return this.locationFromPosition(ar+an,false);
+}else{
+var as=this.lineFromPosition(ar);
+if(as==-1||as+ak>=this.lineCount()){
+return null;
+}
+return this.locationFromPosition(
+this.line_ends[as+ak-1]+1+an);
+}
+}
+function ScriptSourceSlice(at,au){
+var av=(at===(void 0))?this.line_offset
+:at;
+var aw=(au===(void 0))?this.line_offset+this.lineCount()
+:au;
+av-=this.line_offset;
+aw-=this.line_offset;
+if(av<0)av=0;
+if(aw>this.lineCount())aw=this.lineCount();
+if(av>=this.lineCount()||
+aw<0||
+av>aw){
+return null;
+}
+var ai=this.line_ends;
+var ax=av==0?0:ai[av-1]+1;
+var ay=aw==0?0:ai[aw-1]+1;
+return new SourceSlice(this,
+av+this.line_offset,
+aw+this.line_offset,
+ax,ay);
+}
+function ScriptSourceLine(ao){
+var ak=0;
+if(!(ao===(void 0))){
+ak=ao-this.line_offset;
+}
+if(ak<0||this.lineCount()<=ak){
+return null;
+}
+var ai=this.line_ends;
+var al=ak==0?0:ai[ak-1]+1;
+var am=ai[ak];
+return %_Call(z,this.source,al,am);
+}
+function ScriptLineCount(){
+return this.line_ends.length;
+}
+function ScriptLineEnd(az){
+return this.line_ends[az];
+}
+function ScriptNameOrSourceURL(){
+if(this.source_url)return this.source_url;
+return this.name;
+}
+b.SetUpLockedPrototype(v,[
+"source",
+"name",
+"source_url",
+"source_mapping_url",
+"line_ends",
+"line_offset",
+"column_offset"
+],[
+"lineFromPosition",ScriptLineFromPosition,
+"locationFromPosition",ScriptLocationFromPosition,
+"locationFromLine",ScriptLocationFromLine,
+"sourceSlice",ScriptSourceSlice,
+"sourceLine",ScriptSourceLine,
+"lineCount",ScriptLineCount,
+"nameOrSourceURL",ScriptNameOrSourceURL,
+"lineEnd",ScriptLineEnd
+]
+);
+function SourceLocation(ad,af,ak,an,al,am){
+this.script=ad;
+this.position=af;
+this.line=ak;
+this.column=an;
+this.start=al;
+this.end=am;
+}
+function SourceLocationSourceText(){
+return %_Call(z,this.script.source,this.start,this.end);
+}
+b.SetUpLockedPrototype(SourceLocation,
+["script","position","line","column","start","end"],
+["sourceText",SourceLocationSourceText]
+);
+function SourceSlice(ad,av,aw,ax,ay){
+this.script=ad;
+this.from_line=av;
+this.to_line=aw;
+this.from_position=ax;
+this.to_position=ay;
+}
+function SourceSliceSourceText(){
+return %_Call(z,
+this.script.source,
+this.from_position,
+this.to_position);
+}
+b.SetUpLockedPrototype(SourceSlice,
+["script","from_line","to_line","from_position","to_position"],
+["sourceText",SourceSliceSourceText]
+);
+function GetStackTraceLine(aA,aB,aC,aD){
+return new CallSite(aA,aB,aC,false).toString();
+}
+function CallSite(aE,aB,aC,aF){
+if(!(%_IsFunction(aB))){
+throw MakeTypeError(18,typeof aB);
+}
+if((new.target===(void 0))){
+return new CallSite(aE,aB,aC,aF);
+}
+(this[g]=aE);
+(this[h]=aB);
+(this[i]=((aC)|0));
+(this[j]=(!!(aF)));
+}
+function CallSiteGetThis(){
+return(this[j])
+?(void 0):(this[g]);
+}
+function CallSiteGetFunction(){
+return(this[j])
+?(void 0):(this[h]);
+}
+function CallSiteGetPosition(){
+return(this[i]);
+}
+function CallSiteGetTypeName(){
+return GetTypeName((this[g]),false);
+}
+function CallSiteIsToplevel(){
+return %CallSiteIsToplevelRT(this);
+}
+function CallSiteIsEval(){
+return %CallSiteIsEvalRT(this);
+}
+function CallSiteGetEvalOrigin(){
+var ad=%FunctionGetScript((this[h]));
+return FormatEvalOrigin(ad);
+}
+function CallSiteGetScriptNameOrSourceURL(){
+return %CallSiteGetScriptNameOrSourceUrlRT(this);
+}
+function CallSiteGetFunctionName(){
+return %CallSiteGetFunctionNameRT(this);
+}
+function CallSiteGetMethodName(){
+return %CallSiteGetMethodNameRT(this);
+}
+function CallSiteGetFileName(){
+return %CallSiteGetFileNameRT(this);
+}
+function CallSiteGetLineNumber(){
+return %CallSiteGetLineNumberRT(this);
+}
+function CallSiteGetColumnNumber(){
+return %CallSiteGetColumnNumberRT(this);
+}
+function CallSiteIsNative(){
+return %CallSiteIsNativeRT(this);
+}
+function CallSiteIsConstructor(){
+return %CallSiteIsConstructorRT(this);
+}
+function CallSiteToString(){
+var aG;
+var aH="";
+if(this.isNative()){
+aH="native";
+}else{
+aG=this.getScriptNameOrSourceURL();
+if(!aG&&this.isEval()){
+aH=this.getEvalOrigin();
+aH+=", ";
+}
+if(aG){
+aH+=aG;
+}else{
+aH+="<anonymous>";
+}
+var aI=this.getLineNumber();
+if(aI!=null){
+aH+=":"+aI;
+var aJ=this.getColumnNumber();
+if(aJ){
+aH+=":"+aJ;
+}
+}
+}
+var ak="";
+var aK=this.getFunctionName();
+var aL=true;
+var aM=this.isConstructor();
+var aN=!(this.isToplevel()||aM);
+if(aN){
+var aO=GetTypeName((this[g]),true);
+var aP=this.getMethodName();
+if(aK){
+if(aO&&%_Call(y,aK,aO)!=0){
+ak+=aO+".";
+}
+ak+=aK;
+if(aP&&
+(%_Call(y,aK,"."+aP)!=
+aK.length-aP.length-1)){
+ak+=" [as "+aP+"]";
+}
+}else{
+ak+=aO+"."+(aP||"<anonymous>");
+}
+}else if(aM){
+ak+="new "+(aK||"<anonymous>");
+}else if(aK){
+ak+=aK;
+}else{
+ak+=aH;
+aL=false;
+}
+if(aL){
+ak+=" ("+aH+")";
+}
+return ak;
+}
+b.SetUpLockedPrototype(CallSite,["receiver","fun","pos"],[
+"getThis",CallSiteGetThis,
+"getTypeName",CallSiteGetTypeName,
+"isToplevel",CallSiteIsToplevel,
+"isEval",CallSiteIsEval,
+"getEvalOrigin",CallSiteGetEvalOrigin,
+"getScriptNameOrSourceURL",CallSiteGetScriptNameOrSourceURL,
+"getFunction",CallSiteGetFunction,
+"getFunctionName",CallSiteGetFunctionName,
+"getMethodName",CallSiteGetMethodName,
+"getFileName",CallSiteGetFileName,
+"getLineNumber",CallSiteGetLineNumber,
+"getColumnNumber",CallSiteGetColumnNumber,
+"isNative",CallSiteIsNative,
+"getPosition",CallSiteGetPosition,
+"isConstructor",CallSiteIsConstructor,
+"toString",CallSiteToString
+]);
+function FormatEvalOrigin(ad){
+var aQ=ad.nameOrSourceURL();
+if(aQ){
+return aQ;
+}
+var aR="eval at ";
+if(ad.eval_from_function_name){
+aR+=ad.eval_from_function_name;
+}else{
+aR+="<anonymous>";
+}
+var aS=ad.eval_from_script;
+if(aS){
+if(aS.compilation_type==1){
+aR+=" ("+FormatEvalOrigin(aS)+")";
+}else{
+if(aS.name){
+aR+=" ("+aS.name;
+var ae=aS.locationFromPosition(
+ad.eval_from_script_position,true);
+if(ae){
+aR+=":"+(ae.line+1);
+aR+=":"+(ae.column+1);
+}
+aR+=")";
+}else{
+aR+=" (unknown source)";
+}
+}
+}
+return aR;
+}
+function FormatErrorString(aa){
+try{
+return %_Call(ErrorToString,aa);
+}catch(e){
+try{
+return"<error: "+e+">";
+}catch(ee){
+return"<error>";
+}
+}
+}
+function GetStackFrames(aT){
+var aU=new r();
+var aV=aT[0];
+for(var aj=1;aj<aT.length;aj+=4){
+var aA=aT[aj];
+var aB=aT[aj+1];
+var aW=aT[aj+2];
+var aX=aT[aj+3];
+var aC=%_IsSmi(aW)?aW:%FunctionGetPositionForOffset(aW,aX);
+aV--;
+aU.push(new CallSite(aA,aB,aC,(aV<0)));
+}
+return aU;
+}
+var aY=false;
+function FormatStackTrace(Q,aT){
+var aU=GetStackFrames(aT);
+if((%_IsFunction(G.prepareStackTrace))&&
+!aY){
+var aZ=[];
+%MoveArrayContents(aU,aZ);
+aY=true;
+var ba=(void 0);
+try{
+ba=G.prepareStackTrace(Q,aZ);
+}catch(e){
+throw e;
+}finally{
+aY=false;
+}
+return ba;
+}
+var bb=new r();
+bb.push(FormatErrorString(Q));
+for(var aj=0;aj<aU.length;aj++){
+var bc=aU[aj];
+var ak;
+try{
+ak=bc.toString();
+}catch(e){
+try{
+ak="<error: "+e+">";
+}catch(ee){
+ak="<error>";
+}
+}
+bb.push("    at "+ak);
+}
+return %_Call(c,bb,"\n");
+}
+function GetTypeName(aE,bd){
+if((aE==null))return null;
+if((%_IsJSProxy(aE)))return"Proxy";
+var U=%GetDataProperty((%_ToObject(aE)),"constructor");
+if(!(%_IsFunction(U))){
+return bd?null:%_Call(NoSideEffectsToString,aE);
+}
+return %FunctionGetName(U);
+}
+var be=function(){
+var bf=(void 0);
+var bg=this;
+while(bg){
+var bf=
+(bg[m]);
+if((bf===(void 0))){
+var ba=(bg[w]);
+if((ba===(void 0))){
+bg=%_GetPrototype(bg);
+continue;
+}
+bf=FormatStackTrace(bg,ba);
+(bg[w]=(void 0));
+(bg[m]=bf);
+}
+return bf;
+}
+return(void 0);
+};
+var bh=function(bi){
+if(IsErrorObject(this)){
+(this[w]=(void 0));
+(this[m]=bi);
+}
+};
+var bj=function(){};
+function SetUpError(bk){
+%FunctionSetInstanceClassName(bk,'Error');
+var R=bk.name;
+var bl=new n();
+if(R!=='Error'){
+%InternalSetPrototype(bk,G);
+%InternalSetPrototype(bl,G.prototype);
+}
+%FunctionSetPrototype(bk,bl);
+%AddNamedProperty(bk.prototype,'name',R,2);
+%AddNamedProperty(bk.prototype,'message','',2);
+%AddNamedProperty(
+bk.prototype,'constructor',bk,2);
+%SetCode(bk,function(bm){
+if((new.target===(void 0)))return new bk(bm);
+try{bj(this,bk);}catch(e){}
+if(!(bm===(void 0))){
+%AddNamedProperty(this,'message',(%_ToString(bm)),2);
+}
+});
+%SetNativeFlag(bk);
+return bk;
+};
+G=SetUpError(a.Error);
+M=SetUpError(a.EvalError);
+I=SetUpError(a.RangeError);
+L=SetUpError(a.ReferenceError);
+K=SetUpError(a.SyntaxError);
+H=SetUpError(a.TypeError);
+J=SetUpError(a.URIError);
+b.InstallFunctions(G.prototype,2,
+['toString',ErrorToString]);
+function ErrorToString(){
+if(!(%_IsJSReceiver(this))){
+throw MakeTypeError(16,"Error.prototype.toString");
+}
+var R=this.name;
+R=(R===(void 0))?"Error":(%_ToString(R));
+var S=this.message;
+S=(S===(void 0))?"":(%_ToString(S));
+if(R=="")return S;
+if(S=="")return R;
+return`${R}: ${S}`
+}
+function MakeError(W,X,Y,Z){
+return MakeGenericError(G,W,X,Y,Z);
+}
+function MakeRangeError(W,X,Y,Z){
+return MakeGenericError(I,W,X,Y,Z);
+}
+function MakeSyntaxError(W,X,Y,Z){
+return MakeGenericError(K,W,X,Y,Z);
+}
+function MakeTypeError(W,X,Y,Z){
+return MakeGenericError(H,W,X,Y,Z);
+}
+function MakeURIError(){
+return MakeGenericError(J,283);
+}
+var bn=MakeRangeError(187);
+b.InstallGetterSetter(bn,'stack',
+be,bh)
+bj=function captureStackTrace(Q,bo){
+t(Q,'stack',{get:be,
+set:bh,
+configurable:true});
+%CollectStackTrace(Q,bo?bo:bj);
+};
+G.captureStackTrace=bj;
+%InstallToContext([
+"get_stack_trace_line_fun",GetStackTraceLine,
+"make_error_function",MakeGenericError,
+"make_range_error",MakeRangeError,
+"make_type_error",MakeTypeError,
+"message_get_column_number",GetColumnNumber,
+"message_get_line_number",GetLineNumber,
+"message_get_source_line",GetSourceLine,
+"no_side_effects_to_string_fun",NoSideEffectsToString,
+"stack_overflow_boilerplate",bn,
+]);
+b.Export(function(bp){
+bp.ErrorToString=ErrorToString;
+bp.MakeError=MakeError;
+bp.MakeRangeError=MakeRangeError;
+bp.MakeSyntaxError=MakeSyntaxError;
+bp.MakeTypeError=MakeTypeError;
+bp.MakeURIError=MakeURIError;
+});
+});
+
+jsonE
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Date;
+var d=a.JSON;
+var e=a.Set;
+var f=b.InternalArray;
+var g;
+var h;
+var i;
+var j;
+var k=b.ImportNow("to_string_tag_symbol");
+b.Import(function(l){
+g=l.MakeTypeError;
+h=l.MaxSimple;
+i=l.MinSimple;
+j=l.ObjectHasOwnProperty;
+});
+function CreateDataProperty(m,n,o){
+var p={value:o,enumerable:true,writable:true,configurable:true};
+return %reflect_define_property(m,n,p);
+}
+function InternalizeJSONProperty(q,r,s){
+var t=q[r];
+if((%_IsJSReceiver(t))){
+if(%is_arraylike(t)){
+var u=(%_ToLength(t.length));
+for(var v=0;v<u;v++){
+var w=
+InternalizeJSONProperty(t,%_NumberToString(v),s);
+if((w===(void 0))){
+%reflect_delete_property(t,v);
+}else{
+CreateDataProperty(t,v,w);
+}
+}
+}else{
+for(var n of %object_keys(t)){
+var w=InternalizeJSONProperty(t,n,s);
+if((w===(void 0))){
+%reflect_delete_property(t,n);
+}else{
+CreateDataProperty(t,n,w);
+}
+}
+}
+}
+return %_Call(s,q,r,t);
+}
+function JSONParse(x,s){
+var y=%ParseJson(x);
+if((typeof(s)==='function')){
+return InternalizeJSONProperty({'':y},'',s);
+}else{
+return y;
+}
+}
+function SerializeArray(z,A,B,C,D){
+if(!%PushIfAbsent(B,z))throw g(22);
+var E=C;
+C+=D;
+var F=new f();
+var G=(%_ToLength(z.length));
+for(var v=0;v<G;v++){
+var H=JSONSerialize(%_NumberToString(v),z,A,B,
+C,D);
+if((H===(void 0))){
+H="null";
+}
+F.push(H);
+}
+var I;
+if(D==""){
+I="["+F.join(",")+"]";
+}else if(F.length>0){
+var J=",\n"+C;
+I="[\n"+C+F.join(J)+"\n"+
+E+"]";
+}else{
+I="[]";
+}
+B.pop();
+return I;
+}
+function SerializeObject(z,A,B,C,D){
+if(!%PushIfAbsent(B,z))throw g(22);
+var E=C;
+C+=D;
+var F=new f();
+if((%_IsArray(A))){
+var u=A.length;
+for(var v=0;v<u;v++){
+var n=A[v];
+var H=JSONSerialize(n,z,A,B,C,D);
+if(!(H===(void 0))){
+var K=%QuoteJSONString(n)+":";
+if(D!="")K+=" ";
+K+=H;
+F.push(K);
+}
+}
+}else{
+for(var n of %object_keys(z)){
+var H=JSONSerialize(n,z,A,B,C,D);
+if(!(H===(void 0))){
+var K=%QuoteJSONString(n)+":";
+if(D!="")K+=" ";
+K+=H;
+F.push(K);
+}
+}
+}
+var I;
+if(D==""){
+I="{"+F.join(",")+"}";
+}else if(F.length>0){
+var J=",\n"+C;
+I="{\n"+C+F.join(J)+"\n"+
+E+"}";
+}else{
+I="{}";
+}
+B.pop();
+return I;
+}
+function JSONSerialize(L,q,A,B,C,D){
+var z=q[L];
+if((%_IsJSReceiver(z))){
+var M=z.toJSON;
+if((typeof(M)==='function')){
+z=%_Call(M,z,L);
+}
+}
+if((typeof(A)==='function')){
+z=%_Call(A,q,L,z);
+}
+if((typeof(z)==='string')){
+return %QuoteJSONString(z);
+}else if((typeof(z)==='number')){
+return((%_IsSmi(%IS_VAR(z))||z-z==0)?%_NumberToString(z):"null");
+}else if((typeof(z)==='boolean')){
+return z?"true":"false";
+}else if((z===null)){
+return"null";
+}else if((%_IsJSReceiver(z))&&!(typeof(z)==='function')){
+if(%is_arraylike(z)){
+return SerializeArray(z,A,B,C,D);
+}else if((%_ClassOf(z)==='Number')){
+z=(%_ToNumber(z));
+return((%_IsSmi(%IS_VAR(z))||z-z==0)?%_NumberToString(z):"null");
+}else if((%_ClassOf(z)==='String')){
+return %QuoteJSONString((%_ToString(z)));
+}else if((%_ClassOf(z)==='Boolean')){
+return %_ValueOf(z)?"true":"false";
+}else{
+return SerializeObject(z,A,B,C,D);
+}
+}
+return(void 0);
+}
+function JSONStringify(z,A,N){
+if(%_ArgumentsLength()==1&&!(%_IsJSProxy(z))){
+return %BasicJSONStringify(z);
+}
+if(!(typeof(A)==='function')&&%is_arraylike(A)){
+var O=new f();
+var P=new e();
+var u=(%_ToLength(A.length));
+for(var v=0;v<u;v++){
+var o=A[v];
+var Q;
+if((typeof(o)==='string')){
+Q=o;
+}else if((typeof(o)==='number')){
+Q=%_NumberToString(o);
+}else if((%_ClassOf(o)==='String')||(%_ClassOf(o)==='Number')){
+Q=(%_ToString(o));
+}else{
+continue;
+}
+if(!P.has(Q)){
+O.push(Q);
+P.add(Q);
+}
+}
+A=O;
+}
+if((typeof(N)==='object')){
+if((%_ClassOf(N)==='Number')){
+N=(%_ToNumber(N));
+}else if((%_ClassOf(N)==='String')){
+N=(%_ToString(N));
+}
+}
+var D;
+if((typeof(N)==='number')){
+N=h(0,i((%_ToInteger(N)),10));
+D=%_SubString("          ",0,N);
+}else if((typeof(N)==='string')){
+if(N.length>10){
+D=%_SubString(N,0,10);
+}else{
+D=N;
+}
+}else{
+D="";
+}
+return JSONSerialize('',{'':z},A,new f(),"",D);
+}
+%AddNamedProperty(d,k,"JSON",1|2);
+b.InstallFunctions(d,2,[
+"parse",JSONParse,
+"stringify",JSONStringify
+]);
+function DateToJSON(L){
+var m=(%_ToObject(this));
+var R=(%_ToPrimitive_Number(m));
+if((typeof(R)==='number')&&!(%_IsSmi(%IS_VAR(R))||((R==R)&&(R!=1/0)&&(R!=-1/0)))){
+return null;
+}
+return m.toISOString();
+}
+b.InstallFunctions(c.prototype,2,[
+"toJSON",DateToJSON
+]);
+function JsonSerializeAdapter(L,S){
+var q={};
+q[L]=S;
+return JSONSerialize(L,q,(void 0),new f(),"","");
+}
+%InstallToContext(["json_serialize_adapter",JsonSerializeAdapter]);
+})
+
+8array-iterator� 
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=
+b.ImportNow("array_iteration_kind_symbol");
+var d=
+b.ImportNow("array_iterator_next_symbol");
+var e=
+b.ImportNow("array_iterator_object_symbol");
+var f=a.Array;
+var g=b.ImportNow("IteratorPrototype");
+var h=b.ImportNow("iterator_symbol");
+var i;
+var j=b.ImportNow("to_string_tag_symbol");
+var k=a.Uint8Array.__proto__;
+b.Import(function(l){
+i=l.MakeTypeError;
+})
+function ArrayIterator(){}
+function CreateArrayIterator(m,n){
+var o=(%_ToObject(m));
+var p=new ArrayIterator;
+(p[e]=o);
+(p[d]=0);
+(p[c]=n);
+return p;
+}
+function ArrayIteratorIterator(){
+return this;
+}
+function ArrayIteratorNext(){
+var p=this;
+var q=(void 0);
+var r=true;
+if(!(%_IsJSReceiver(p))||
+!(!(p[d]===(void 0)))){
+throw i(42,
+'Array Iterator.prototype.next',this);
+}
+var m=(p[e]);
+if(!(m===(void 0))){
+var s=(p[d]);
+var t=(p[c]);
+var u=((m.length)>>>0);
+if(s>=u){
+(p[e]=(void 0));
+}else{
+(p[d]=s+1);
+if(t==2){
+q=m[s];
+}else if(t==3){
+q=[s,m[s]];
+}else{
+q=s;
+}
+r=false;
+}
+}
+return %_CreateIterResultObject(q,r);
+}
+function ArrayEntries(){
+return CreateArrayIterator(this,3);
+}
+function ArrayValues(){
+return CreateArrayIterator(this,2);
+}
+function ArrayKeys(){
+return CreateArrayIterator(this,1);
+}
+%FunctionSetPrototype(ArrayIterator,{__proto__:g});
+%FunctionSetInstanceClassName(ArrayIterator,'Array Iterator');
+b.InstallFunctions(ArrayIterator.prototype,2,[
+'next',ArrayIteratorNext
+]);
+b.SetFunctionName(ArrayIteratorIterator,h);
+%AddNamedProperty(ArrayIterator.prototype,h,
+ArrayIteratorIterator,2);
+%AddNamedProperty(ArrayIterator.prototype,j,
+"Array Iterator",1|2);
+b.InstallFunctions(f.prototype,2,[
+'entries',ArrayEntries,
+'keys',ArrayKeys
+]);
+b.SetFunctionName(ArrayValues,'values');
+%AddNamedProperty(f.prototype,h,ArrayValues,
+2);
+%AddNamedProperty(k.prototype,
+'entries',ArrayEntries,2);
+%AddNamedProperty(k.prototype,'values',ArrayValues,2);
+%AddNamedProperty(k.prototype,'keys',ArrayKeys,2);
+%AddNamedProperty(k.prototype,
+h,ArrayValues,2);
+b.Export(function(v){
+v.ArrayValues=ArrayValues;
+});
+%InstallToContext(["array_values_iterator",ArrayValues]);
+})
+
+<string-iterator5
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.String;
+var d=b.ImportNow("IteratorPrototype");
+var e=b.ImportNow("iterator_symbol");
+var f;
+var g=
+b.ImportNow("string_iterator_iterated_string_symbol");
+var h=
+b.ImportNow("string_iterator_next_index_symbol");
+var i=b.ImportNow("to_string_tag_symbol");
+b.Import(function(j){
+f=j.MakeTypeError;
+});
+function StringIterator(){}
+function CreateStringIterator(k){
+var l=(%_ToString(k));
+var m=new StringIterator;
+(m[g]=l);
+(m[h]=0);
+return m;
+}
+function StringIteratorNext(){
+var m=this;
+var n=(void 0);
+var o=true;
+if(!(%_IsJSReceiver(m))||
+!(!(m[h]===(void 0)))){
+throw f(42,
+'String Iterator.prototype.next');
+}
+var l=(m[g]);
+if(!(l===(void 0))){
+var p=(m[h]);
+var q=((l.length)>>>0);
+if(p>=q){
+(m[g]=(void 0));
+}else{
+var r=%_StringCharCodeAt(l,p);
+n=%_StringCharFromCode(r);
+o=false;
+p++;
+if(r>=0xD800&&r<=0xDBFF&&p<q){
+var s=%_StringCharCodeAt(l,p);
+if(s>=0xDC00&&s<=0xDFFF){
+n+=%_StringCharFromCode(s);
+p++;
+}
+}
+(m[h]=p);
+}
+}
+return %_CreateIterResultObject(n,o);
+}
+function StringPrototypeIterator(){
+return CreateStringIterator(this);
+}
+%FunctionSetPrototype(StringIterator,{__proto__:d});
+%FunctionSetInstanceClassName(StringIterator,'String Iterator');
+b.InstallFunctions(StringIterator.prototype,2,[
+'next',StringIteratorNext
+]);
+%AddNamedProperty(StringIterator.prototype,i,
+"String Iterator",1|2);
+b.SetFunctionName(StringPrototypeIterator,e);
+%AddNamedProperty(c.prototype,e,
+StringPrototypeIterator,2);
+})
+
+$templates
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Map;
+var d=b.InternalArray;
+var e=new c;
+var f=c.prototype.get;
+var g=c.prototype.set;
+function SameCallSiteElements(h,i){
+var j=h.length;
+var i=i.raw;
+if(j!==i.length)return false;
+for(var k=0;k<j;++k){
+if(h[k]!==i[k])return false;
+}
+return true;
+}
+function GetCachedCallSite(l,m){
+var n=%_Call(f,e,m);
+if((n===(void 0)))return;
+var j=n.length;
+for(var k=0;k<j;++k){
+if(SameCallSiteElements(l,n[k]))return n[k];
+}
+}
+function SetCachedCallSite(l,m){
+var n=%_Call(f,e,m);
+var o;
+if((n===(void 0))){
+o=new d(1);
+o[0]=l;
+%_Call(g,e,m,o);
+}else{
+n.push(l);
+}
+return l;
+}
+function GetTemplateCallSite(l,h,m){
+var p=GetCachedCallSite(h,m);
+if(!(p===(void 0)))return p;
+%AddNamedProperty(l,"raw",%object_freeze(h),
+1|2|4);
+return SetCachedCallSite(%object_freeze(l),m);
+}
+%InstallToContext(["get_template_call_site",GetTemplateCallSite]);
+})
+
+spread�
+(function(a,b){
+'use strict';
+var c=b.InternalArray;
+var d;
+b.Import(function(e){
+d=e.MakeTypeError;
+});
+function SpreadArguments(){
+var f=%_ArgumentsLength();
+var g=new c();
+for(var h=0;h<f;++h){
+var i=%_Arguments(h);
+var j=i.length;
+for(var k=0;k<j;++k){
+g.push(i[k]);
+}
+}
+return g;
+}
+function SpreadIterable(l){
+if((l==null)){
+throw d(66,l);
+}
+var g=new c();
+for(var m of l){
+g.push(m);
+}
+return g;
+}
+%InstallToContext([
+"spread_arguments",SpreadArguments,
+"spread_iterable",SpreadIterable,
+]);
+})
+
+i18nF�

+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c;
+var d;
+var e;
+var f;
+var g;
+var h=a.Boolean;
+var i=a.Date;
+var j=a.Number;
+var k=a.RegExp;
+var l=a.String;
+var m;
+var n;
+var o;
+var p;
+var q=b.ImportNow("ObjectDefineProperties");
+var r=b.ImportNow("ObjectDefineProperty");
+var s=b.ImportNow("intl_pattern_symbol");
+var t;
+var u=b.ImportNow("intl_resolved_symbol");
+var v;
+var w;
+var x;
+var y;
+var z;
+var A;
+var B;
+b.Import(function(C){
+c=C.ArrayIndexOf;
+d=C.ArrayJoin;
+e=C.ArrayPush;
+f=C.IsFinite;
+g=C.IsNaN;
+m=C.MakeError;
+n=C.MakeRangeError;
+o=C.MakeTypeError;
+p=C.MathFloor;
+t=C.RegExpTest;
+v=C.StringIndexOf;
+w=C.StringLastIndexOf;
+x=C.StringMatch;
+y=C.StringReplace;
+z=C.StringSplit;
+A=C.StringSubstr;
+B=C.StringSubstring;
+});
+var D={};
+%AddNamedProperty(a,"Intl",D,2);
+var E={
+'collator':(void 0),
+'numberformat':(void 0),
+'dateformat':(void 0),
+'breakiterator':(void 0)
+};
+var F=(void 0);
+var G=(void 0);
+function GetUnicodeExtensionRE(){
+if(((void 0)===(void 0))){
+G=new k('-u(-[a-z0-9]{2,8})+','g');
+}
+return G;
+}
+var H=(void 0);
+function GetAnyExtensionRE(){
+if((H===(void 0))){
+H=new k('-[a-z0-9]{1}-.*','g');
+}
+return H;
+}
+var I=(void 0);
+function GetQuotedStringRE(){
+if((I===(void 0))){
+I=new k("'[^']+'",'g');
+}
+return I;
+}
+var J=(void 0);
+function GetServiceRE(){
+if((J===(void 0))){
+J=
+new k('^(collator|numberformat|dateformat|breakiterator)$');
+}
+return J;
+}
+var K=(void 0);
+function GetLanguageTagRE(){
+if((K===(void 0))){
+BuildLanguageTagREs();
+}
+return K;
+}
+var L=(void 0);
+function GetLanguageVariantRE(){
+if((L===(void 0))){
+BuildLanguageTagREs();
+}
+return L;
+}
+var M=(void 0);
+function GetLanguageSingletonRE(){
+if((M===(void 0))){
+BuildLanguageTagREs();
+}
+return M;
+}
+var N=(void 0);
+function GetTimezoneNameCheckRE(){
+if((N===(void 0))){
+N=new k(
+'^([A-Za-z]+)/([A-Za-z_-]+)((?:\/[A-Za-z_-]+)+)*$');
+}
+return N;
+}
+var O=(void 0);
+function GetTimezoneNameLocationPartRE(){
+if((O===(void 0))){
+O=
+new k('^([A-Za-z]+)((?:[_-][A-Za-z]+)+)*$');
+}
+return O;
+}
+function addBoundMethod(P,Q,R,S){
+%CheckIsBootstrapping();
+function getter(){
+if(!%IsInitializedIntlObject(this)){
+throw o(51,Q);
+}
+var T='__bound'+Q+'__';
+if((this[T]===(void 0))){
+var U=this;
+var V;
+if((S===(void 0))||S===2){
+V=function(W,X){
+if(!(new.target===(void 0))){
+throw o(87);
+}
+return R(U,W,X);
+}
+}else if(S===1){
+V=function(W){
+if(!(new.target===(void 0))){
+throw o(87);
+}
+return R(U,W);
+}
+}else{
+V=function(){
+if(!(new.target===(void 0))){
+throw o(87);
+}
+if(%_ArgumentsLength()>0){
+return R(U,%_Arguments(0));
+}else{
+return R(U);
+}
+}
+}
+%FunctionSetName(V,T);
+%FunctionRemovePrototype(V);
+%SetNativeFlag(V);
+this[T]=V;
+}
+return this[T];
+}
+%FunctionSetName(getter,Q);
+%FunctionRemovePrototype(getter);
+%SetNativeFlag(getter);
+r(P.prototype,Q,{
+get:getter,
+enumerable:false,
+configurable:true
+});
+}
+function supportedLocalesOf(Y,Z,aa){
+if((%_Call(x,Y,GetServiceRE())===null)){
+throw m(7,Y);
+}
+if((aa===(void 0))){
+aa={};
+}else{
+aa=(%_ToObject(aa));
+}
+var ab=aa.localeMatcher;
+if(!(ab===(void 0))){
+ab=l(ab);
+if(ab!=='lookup'&&ab!=='best fit'){
+throw n(183,ab);
+}
+}else{
+ab='best fit';
+}
+var ac=initializeLocaleList(Z);
+if((E[Y]===(void 0))){
+E[Y]=getAvailableLocalesOf(Y);
+}
+if(ab==='best fit'){
+return initializeLocaleList(bestFitSupportedLocalesOf(
+ac,E[Y]));
+}
+return initializeLocaleList(lookupSupportedLocalesOf(
+ac,E[Y]));
+}
+function lookupSupportedLocalesOf(ac,ad){
+var ae=[];
+for(var af=0;af<ac.length;++af){
+var ag=%_Call(y,
+ac[af],
+GetUnicodeExtensionRE(),
+'');
+do{
+if(!(ad[ag]===(void 0))){
+%_Call(e,ae,ac[af]);
+break;
+}
+var ah=%_Call(w,ag,'-');
+if(ah===-1){
+break;
+}
+ag=%_Call(B,ag,0,ah);
+}while(true);
+}
+return ae;
+}
+function bestFitSupportedLocalesOf(ac,ad){
+return lookupSupportedLocalesOf(ac,ad);
+}
+function getGetOption(aa,ai){
+if((aa===(void 0)))throw m(4,ai);
+var aj=function getOption(ak,al,am,an){
+if(!(aa[ak]===(void 0))){
+var ao=aa[ak];
+switch(al){
+case'boolean':
+ao=h(ao);
+break;
+case'string':
+ao=l(ao);
+break;
+case'number':
+ao=j(ao);
+break;
+default:
+throw m(8);
+}
+if(!(am===(void 0))&&%_Call(c,am,ao)===-1){
+throw n(193,ao,ai,ak);
+}
+return ao;
+}
+return an;
+}
+return aj;
+}
+function resolveLocale(Y,ac,aa){
+ac=initializeLocaleList(ac);
+var aj=getGetOption(aa,Y);
+var ab=aj('localeMatcher','string',
+['lookup','best fit'],'best fit');
+var ap;
+if(ab==='lookup'){
+ap=lookupMatcher(Y,ac);
+}else{
+ap=bestFitMatcher(Y,ac);
+}
+return ap;
+}
+function lookupMatcher(Y,ac){
+if((%_Call(x,Y,GetServiceRE())===null)){
+throw m(7,Y);
+}
+if((E[Y]===(void 0))){
+E[Y]=getAvailableLocalesOf(Y);
+}
+for(var af=0;af<ac.length;++af){
+var ag=%_Call(y,ac[af],
+GetAnyExtensionRE(),'');
+do{
+if(!(E[Y][ag]===(void 0))){
+var aq=
+%_Call(x,ac[af],GetUnicodeExtensionRE());
+var ar=(aq===null)?'':aq[0];
+return{'locale':ag,'extension':ar,'position':af};
+}
+var ah=%_Call(w,ag,'-');
+if(ah===-1){
+break;
+}
+ag=%_Call(B,ag,0,ah);
+}while(true);
+}
+if((F===(void 0))){
+F=%GetDefaultICULocale();
+}
+return{'locale':F,'extension':'','position':-1};
+}
+function bestFitMatcher(Y,ac){
+return lookupMatcher(Y,ac);
+}
+function parseExtension(ar){
+var as=%_Call(z,ar,'-');
+if(as.length<=2||
+(as[0]!==''&&as[1]!=='u')){
+return{};
+}
+var at={};
+var au=(void 0);
+for(var af=2;af<as.length;++af){
+var S=as[af].length;
+var av=as[af];
+if(S===2){
+at[av]=(void 0);
+au=av;
+}else if(S>=3&&S<=8&&!(au===(void 0))){
+at[au]=av;
+au=(void 0);
+}else{
+return{};
+}
+}
+return at;
+}
+function setOptions(aw,at,ax,aj,ay){
+var ar='';
+var az=function updateExtension(aA,ao){
+return'-'+aA+'-'+l(ao);
+}
+var aB=function updateProperty(ak,al,ao){
+if(al==='boolean'&&(typeof ao==='string')){
+ao=(ao==='true')?true:false;
+}
+if(!(ak===(void 0))){
+defineWEProperty(ay,ak,ao);
+}
+}
+for(var aA in ax){
+if(%HasOwnProperty(ax,aA)){
+var ao=(void 0);
+var aC=ax[aA];
+if(!(aC.property===(void 0))){
+ao=aj(aC.property,aC.type,aC.values);
+}
+if(!(ao===(void 0))){
+aB(aC.property,aC.type,ao);
+ar+=az(aA,ao);
+continue;
+}
+if(%HasOwnProperty(at,aA)){
+ao=at[aA];
+if(!(ao===(void 0))){
+aB(aC.property,aC.type,ao);
+ar+=az(aA,ao);
+}else if(aC.type==='boolean'){
+aB(aC.property,aC.type,true);
+ar+=az(aA,true);
+}
+}
+}
+}
+return ar===''?'':'-u'+ar;
+}
+function freezeArray(aD){
+var aE=aD.length;
+for(var af=0;af<aE;af++){
+if(af in aD){
+r(aD,af,{value:aD[af],
+configurable:false,
+writable:false,
+enumerable:true});
+}
+}
+r(aD,'length',{value:aE,writable:false});
+return aD;
+}
+function getOptimalLanguageTag(aF,ap){
+if(aF===ap){
+return aF;
+}
+var Z=%GetLanguageTagVariants([aF,ap]);
+if(Z[0].maximized!==Z[1].maximized){
+return ap;
+}
+var aG=new k('^'+Z[1].base);
+return %_Call(y,ap,aG,Z[0].base);
+}
+function getAvailableLocalesOf(Y){
+var aH=%AvailableLocalesOf(Y);
+for(var af in aH){
+if(%HasOwnProperty(aH,af)){
+var aI=
+%_Call(x,af,/^([a-z]{2,3})-([A-Z][a-z]{3})-([A-Z]{2})$/);
+if(aI!==null){
+aH[aI[1]+'-'+aI[3]]=null;
+}
+}
+}
+return aH;
+}
+function defineWEProperty(aJ,ak,ao){
+r(aJ,ak,
+{value:ao,writable:true,enumerable:true});
+}
+function addWEPropertyIfDefined(aJ,ak,ao){
+if(!(ao===(void 0))){
+defineWEProperty(aJ,ak,ao);
+}
+}
+function defineWECProperty(aJ,ak,ao){
+r(aJ,ak,{value:ao,
+writable:true,
+enumerable:true,
+configurable:true});
+}
+function addWECPropertyIfDefined(aJ,ak,ao){
+if(!(ao===(void 0))){
+defineWECProperty(aJ,ak,ao);
+}
+}
+function toTitleCaseWord(aK){
+return %StringToUpperCase(%_Call(A,aK,0,1))+
+%StringToLowerCase(%_Call(A,aK,1));
+}
+function toTitleCaseTimezoneLocation(aL){
+var aM=%_Call(x,aL,GetTimezoneNameLocationPartRE());
+if((aM===null))throw n(163,aL);
+var aN=toTitleCaseWord(aM[1]);
+if(!(aM[2]===(void 0))&&2<aM.length){
+var aO=%_Call(B,aM[2],0,1);
+var aI=%_Call(z,aM[2],aO);
+for(var af=1;af<aI.length;af++){
+var aP=aI[af]
+var aQ=%StringToLowerCase(aP);
+aN=aN+aO+
+((aQ!=='es'&&
+aQ!=='of'&&aQ!=='au')?
+toTitleCaseWord(aP):aQ);
+}
+}
+return aN;
+}
+function canonicalizeLanguageTag(aR){
+if(typeof aR!=='string'&&typeof aR!=='object'||
+(aR===null)){
+throw o(50);
+}
+var aS=l(aR);
+if(isValidLanguageTag(aS)===false){
+throw n(174,aS);
+}
+var aT=%CanonicalizeLanguageTag(aS);
+if(aT==='invalid-tag'){
+throw n(174,aS);
+}
+return aT;
+}
+function initializeLocaleList(Z){
+var aU=[];
+if((Z===(void 0))){
+aU=[];
+}else{
+if(typeof Z==='string'){
+%_Call(e,aU,canonicalizeLanguageTag(Z));
+return freezeArray(aU);
+}
+var aV=(%_ToObject(Z));
+var aW=((aV.length)>>>0);
+for(var aX=0;aX<aW;aX++){
+if(aX in aV){
+var ao=aV[aX];
+var aT=canonicalizeLanguageTag(ao);
+if(%_Call(c,aU,aT)===-1){
+%_Call(e,aU,aT);
+}
+}
+}
+}
+return freezeArray(aU);
+}
+function isValidLanguageTag(ag){
+if(!%_Call(t,GetLanguageTagRE(),ag)){
+return false;
+}
+if(%_Call(v,ag,'x-')===0){
+return true;
+}
+ag=%_Call(z,ag,/-x-/)[0];
+var aY=[];
+var aZ=[];
+var aI=%_Call(z,ag,/-/);
+for(var af=1;af<aI.length;af++){
+var ao=aI[af];
+if(%_Call(t,GetLanguageVariantRE(),ao)&&
+aZ.length===0){
+if(%_Call(c,aY,ao)===-1){
+%_Call(e,aY,ao);
+}else{
+return false;
+}
+}
+if(%_Call(t,GetLanguageSingletonRE(),ao)){
+if(%_Call(c,aZ,ao)===-1){
+%_Call(e,aZ,ao);
+}else{
+return false;
+}
+}
+}
+return true;
+}
+function BuildLanguageTagREs(){
+var ba='[a-zA-Z]';
+var bb='[0-9]';
+var bc='('+ba+'|'+bb+')';
+var bd='(art-lojban|cel-gaulish|no-bok|no-nyn|zh-guoyu|zh-hakka|'+
+'zh-min|zh-min-nan|zh-xiang)';
+var be='(en-GB-oed|i-ami|i-bnn|i-default|i-enochian|i-hak|'+
+'i-klingon|i-lux|i-mingo|i-navajo|i-pwn|i-tao|i-tay|'+
+'i-tsu|sgn-BE-FR|sgn-BE-NL|sgn-CH-DE)';
+var bf='('+be+'|'+bd+')';
+var bg='(x(-'+bc+'{1,8})+)';
+var bh='('+bb+'|[A-WY-Za-wy-z])';
+M=new k('^'+bh+'$','i');
+var ar='('+bh+'(-'+bc+'{2,8})+)';
+var bi='('+bc+'{5,8}|('+bb+bc+'{3}))';
+L=new k('^'+bi+'$','i');
+var bj='('+ba+'{2}|'+bb+'{3})';
+var bk='('+ba+'{4})';
+var bl='('+ba+'{3}(-'+ba+'{3}){0,2})';
+var bm='('+ba+'{2,3}(-'+bl+')?|'+ba+'{4}|'+
+ba+'{5,8})';
+var bn=bm+'(-'+bk+')?(-'+bj+')?(-'+
+bi+')*(-'+ar+')*(-'+bg+')?';
+var bo=
+'^('+bn+'|'+bg+'|'+bf+')$';
+K=new k(bo,'i');
+}
+var bp={
+get(){
+%IncrementUseCounter(16);
+return this[u];
+},
+set(ao){
+this[u]=ao;
+}
+};
+function initializeCollator(bq,Z,aa){
+if(%IsInitializedIntlObject(bq)){
+throw o(132,"Collator");
+}
+if((aa===(void 0))){
+aa={};
+}
+var aj=getGetOption(aa,'collator');
+var br={};
+defineWEProperty(br,'usage',aj(
+'usage','string',['sort','search'],'sort'));
+var bs=aj('sensitivity','string',
+['base','accent','case','variant']);
+if((bs===(void 0))&&br.usage==='sort'){
+bs='variant';
+}
+defineWEProperty(br,'sensitivity',bs);
+defineWEProperty(br,'ignorePunctuation',aj(
+'ignorePunctuation','boolean',(void 0),false));
+var ag=resolveLocale('collator',Z,aa);
+var at=parseExtension(ag.extension);
+var bt={
+'kn':{'property':'numeric','type':'boolean'},
+'kf':{'property':'caseFirst','type':'string',
+'values':['false','lower','upper']}
+};
+setOptions(
+aa,at,bt,aj,br);
+var bu='default';
+var ar='';
+if(%HasOwnProperty(at,'co')&&br.usage==='sort'){
+var bv=[
+'big5han','dict','direct','ducet','gb2312','phonebk','phonetic',
+'pinyin','reformed','searchjl','stroke','trad','unihan','zhuyin'
+];
+if(%_Call(c,bv,at.co)!==-1){
+ar='-u-co-'+at.co;
+bu=at.co;
+}
+}else if(br.usage==='search'){
+ar='-u-co-search';
+}
+defineWEProperty(br,'collation',bu);
+var bw=ag.locale+ar;
+var ap=q({},{
+caseFirst:{writable:true},
+collation:{value:br.collation,writable:true},
+ignorePunctuation:{writable:true},
+locale:{writable:true},
+numeric:{writable:true},
+requestedLocale:{value:bw,writable:true},
+sensitivity:{writable:true},
+strength:{writable:true},
+usage:{value:br.usage,writable:true}
+});
+var bx=%CreateCollator(bw,
+br,
+ap);
+%MarkAsInitializedIntlObjectOfType(bq,'collator',bx);
+bq[u]=ap;
+r(bq,'resolved',bp);
+return bq;
+}
+%AddNamedProperty(D,'Collator',function(){
+var Z=%_Arguments(0);
+var aa=%_Arguments(1);
+if(!this||this===D){
+return new D.Collator(Z,aa);
+}
+return initializeCollator((%_ToObject(this)),Z,aa);
+},
+2
+);
+%AddNamedProperty(D.Collator.prototype,'resolvedOptions',function(){
+if(!(new.target===(void 0))){
+throw o(87);
+}
+if(!%IsInitializedIntlObjectOfType(this,'collator')){
+throw o(133,"Collator");
+}
+var by=this;
+var ag=getOptimalLanguageTag(by[u].requestedLocale,
+by[u].locale);
+return{
+locale:ag,
+usage:by[u].usage,
+sensitivity:by[u].sensitivity,
+ignorePunctuation:by[u].ignorePunctuation,
+numeric:by[u].numeric,
+caseFirst:by[u].caseFirst,
+collation:by[u].collation
+};
+},
+2
+);
+%FunctionSetName(D.Collator.prototype.resolvedOptions,'resolvedOptions');
+%FunctionRemovePrototype(D.Collator.prototype.resolvedOptions);
+%SetNativeFlag(D.Collator.prototype.resolvedOptions);
+%AddNamedProperty(D.Collator,'supportedLocalesOf',function(Z){
+if(!(new.target===(void 0))){
+throw o(87);
+}
+return supportedLocalesOf('collator',Z,%_Arguments(1));
+},
+2
+);
+%FunctionSetName(D.Collator.supportedLocalesOf,'supportedLocalesOf');
+%FunctionRemovePrototype(D.Collator.supportedLocalesOf);
+%SetNativeFlag(D.Collator.supportedLocalesOf);
+function compare(bq,W,X){
+return %InternalCompare(%GetImplFromInitializedIntlObject(bq),
+l(W),l(X));
+};
+addBoundMethod(D.Collator,'compare',compare,2);
+function isWellFormedCurrencyCode(bz){
+return typeof bz=="string"&&
+bz.length==3&&
+%_Call(x,bz,/[^A-Za-z]/)==null;
+}
+function getNumberOption(aa,ak,bA,bB,bC){
+var ao=aa[ak];
+if(!(ao===(void 0))){
+ao=j(ao);
+if(g(ao)||ao<bA||ao>bB){
+throw n(186,ak);
+}
+return p(ao);
+}
+return bC;
+}
+var bD={
+get(){
+%IncrementUseCounter(15);
+return this[s];
+},
+set(ao){
+this[s]=ao;
+}
+};
+function initializeNumberFormat(bE,Z,aa){
+if(%IsInitializedIntlObject(bE)){
+throw o(132,"NumberFormat");
+}
+if((aa===(void 0))){
+aa={};
+}
+var aj=getGetOption(aa,'numberformat');
+var ag=resolveLocale('numberformat',Z,aa);
+var br={};
+defineWEProperty(br,'style',aj(
+'style','string',['decimal','percent','currency'],'decimal'));
+var bz=aj('currency','string');
+if(!(bz===(void 0))&&!isWellFormedCurrencyCode(bz)){
+throw n(169,bz);
+}
+if(br.style==='currency'&&(bz===(void 0))){
+throw o(28);
+}
+var bF=aj(
+'currencyDisplay','string',['code','symbol','name'],'symbol');
+if(br.style==='currency'){
+defineWEProperty(br,'currency',%StringToUpperCase(bz));
+defineWEProperty(br,'currencyDisplay',bF);
+}
+var bG=getNumberOption(aa,'minimumIntegerDigits',1,21,1);
+defineWEProperty(br,'minimumIntegerDigits',bG);
+var bH=aa['minimumFractionDigits'];
+var bI=aa['maximumFractionDigits'];
+if(!(bH===(void 0))||br.style!=='currency'){
+bH=getNumberOption(aa,'minimumFractionDigits',0,20,0);
+defineWEProperty(br,'minimumFractionDigits',bH);
+}
+if(!(bI===(void 0))||br.style!=='currency'){
+var bJ=br.style==='percent'?0:3;
+bH=(bH===(void 0))?0:bH;
+var bK=(bH>bJ)?bH:bJ;
+bI=getNumberOption(aa,'maximumFractionDigits',bH,20,bK);
+defineWEProperty(br,'maximumFractionDigits',bI);
+}
+var bL=aa['minimumSignificantDigits'];
+var bM=aa['maximumSignificantDigits'];
+if(!(bL===(void 0))||!(bM===(void 0))){
+bL=getNumberOption(aa,'minimumSignificantDigits',1,21,0);
+defineWEProperty(br,'minimumSignificantDigits',bL);
+bM=getNumberOption(aa,'maximumSignificantDigits',bL,21,21);
+defineWEProperty(br,'maximumSignificantDigits',bM);
+}
+defineWEProperty(br,'useGrouping',aj(
+'useGrouping','boolean',(void 0),true));
+var at=parseExtension(ag.extension);
+var bN={
+'nu':{'property':(void 0),'type':'string'}
+};
+var ar=setOptions(aa,at,bN,
+aj,br);
+var bw=ag.locale+ar;
+var ap=q({},{
+currency:{writable:true},
+currencyDisplay:{writable:true},
+locale:{writable:true},
+maximumFractionDigits:{writable:true},
+minimumFractionDigits:{writable:true},
+minimumIntegerDigits:{writable:true},
+numberingSystem:{writable:true},
+pattern:bD,
+requestedLocale:{value:bw,writable:true},
+style:{value:br.style,writable:true},
+useGrouping:{writable:true}
+});
+if(%HasOwnProperty(br,'minimumSignificantDigits')){
+defineWEProperty(ap,'minimumSignificantDigits',(void 0));
+}
+if(%HasOwnProperty(br,'maximumSignificantDigits')){
+defineWEProperty(ap,'maximumSignificantDigits',(void 0));
+}
+var bO=%CreateNumberFormat(bw,
+br,
+ap);
+if(br.style==='currency'){
+r(ap,'currencyDisplay',{value:bF,
+writable:true});
+}
+%MarkAsInitializedIntlObjectOfType(bE,'numberformat',bO);
+bE[u]=ap;
+r(bE,'resolved',bp);
+return bE;
+}
+%AddNamedProperty(D,'NumberFormat',function(){
+var Z=%_Arguments(0);
+var aa=%_Arguments(1);
+if(!this||this===D){
+return new D.NumberFormat(Z,aa);
+}
+return initializeNumberFormat((%_ToObject(this)),Z,aa);
+},
+2
+);
+%AddNamedProperty(D.NumberFormat.prototype,'resolvedOptions',function(){
+if(!(new.target===(void 0))){
+throw o(87);
+}
+if(!%IsInitializedIntlObjectOfType(this,'numberformat')){
+throw o(133,"NumberFormat");
+}
+var bP=this;
+var ag=getOptimalLanguageTag(bP[u].requestedLocale,
+bP[u].locale);
+var aN={
+locale:ag,
+numberingSystem:bP[u].numberingSystem,
+style:bP[u].style,
+useGrouping:bP[u].useGrouping,
+minimumIntegerDigits:bP[u].minimumIntegerDigits,
+minimumFractionDigits:bP[u].minimumFractionDigits,
+maximumFractionDigits:bP[u].maximumFractionDigits,
+};
+if(aN.style==='currency'){
+defineWECProperty(aN,'currency',bP[u].currency);
+defineWECProperty(aN,'currencyDisplay',
+bP[u].currencyDisplay);
+}
+if(%HasOwnProperty(bP[u],'minimumSignificantDigits')){
+defineWECProperty(aN,'minimumSignificantDigits',
+bP[u].minimumSignificantDigits);
+}
+if(%HasOwnProperty(bP[u],'maximumSignificantDigits')){
+defineWECProperty(aN,'maximumSignificantDigits',
+bP[u].maximumSignificantDigits);
+}
+return aN;
+},
+2
+);
+%FunctionSetName(D.NumberFormat.prototype.resolvedOptions,
+'resolvedOptions');
+%FunctionRemovePrototype(D.NumberFormat.prototype.resolvedOptions);
+%SetNativeFlag(D.NumberFormat.prototype.resolvedOptions);
+%AddNamedProperty(D.NumberFormat,'supportedLocalesOf',function(Z){
+if(!(new.target===(void 0))){
+throw o(87);
+}
+return supportedLocalesOf('numberformat',Z,%_Arguments(1));
+},
+2
+);
+%FunctionSetName(D.NumberFormat.supportedLocalesOf,'supportedLocalesOf');
+%FunctionRemovePrototype(D.NumberFormat.supportedLocalesOf);
+%SetNativeFlag(D.NumberFormat.supportedLocalesOf);
+function formatNumber(bO,ao){
+var bQ=(%_ToNumber(ao))+0;
+return %InternalNumberFormat(%GetImplFromInitializedIntlObject(bO),
+bQ);
+}
+function parseNumber(bO,ao){
+return %InternalNumberParse(%GetImplFromInitializedIntlObject(bO),
+l(ao));
+}
+addBoundMethod(D.NumberFormat,'format',formatNumber,1);
+addBoundMethod(D.NumberFormat,'v8Parse',parseNumber,1);
+function toLDMLString(aa){
+var aj=getGetOption(aa,'dateformat');
+var bR='';
+var bS=aj('weekday','string',['narrow','short','long']);
+bR+=appendToLDMLString(
+bS,{narrow:'EEEEE',short:'EEE',long:'EEEE'});
+bS=aj('era','string',['narrow','short','long']);
+bR+=appendToLDMLString(
+bS,{narrow:'GGGGG',short:'GGG',long:'GGGG'});
+bS=aj('year','string',['2-digit','numeric']);
+bR+=appendToLDMLString(bS,{'2-digit':'yy','numeric':'y'});
+bS=aj('month','string',
+['2-digit','numeric','narrow','short','long']);
+bR+=appendToLDMLString(bS,{'2-digit':'MM','numeric':'M',
+'narrow':'MMMMM','short':'MMM','long':'MMMM'});
+bS=aj('day','string',['2-digit','numeric']);
+bR+=appendToLDMLString(
+bS,{'2-digit':'dd','numeric':'d'});
+var bT=aj('hour12','boolean');
+bS=aj('hour','string',['2-digit','numeric']);
+if((bT===(void 0))){
+bR+=appendToLDMLString(bS,{'2-digit':'jj','numeric':'j'});
+}else if(bT===true){
+bR+=appendToLDMLString(bS,{'2-digit':'hh','numeric':'h'});
+}else{
+bR+=appendToLDMLString(bS,{'2-digit':'HH','numeric':'H'});
+}
+bS=aj('minute','string',['2-digit','numeric']);
+bR+=appendToLDMLString(bS,{'2-digit':'mm','numeric':'m'});
+bS=aj('second','string',['2-digit','numeric']);
+bR+=appendToLDMLString(bS,{'2-digit':'ss','numeric':'s'});
+bS=aj('timeZoneName','string',['short','long']);
+bR+=appendToLDMLString(bS,{short:'z',long:'zzzz'});
+return bR;
+}
+function appendToLDMLString(bS,bU){
+if(!(bS===(void 0))){
+return bU[bS];
+}else{
+return'';
+}
+}
+function fromLDMLString(bR){
+bR=%_Call(y,bR,GetQuotedStringRE(),'');
+var aa={};
+var aM=%_Call(x,bR,/E{3,5}/g);
+aa=appendToDateTimeObject(
+aa,'weekday',aM,{EEEEE:'narrow',EEE:'short',EEEE:'long'});
+aM=%_Call(x,bR,/G{3,5}/g);
+aa=appendToDateTimeObject(
+aa,'era',aM,{GGGGG:'narrow',GGG:'short',GGGG:'long'});
+aM=%_Call(x,bR,/y{1,2}/g);
+aa=appendToDateTimeObject(
+aa,'year',aM,{y:'numeric',yy:'2-digit'});
+aM=%_Call(x,bR,/M{1,5}/g);
+aa=appendToDateTimeObject(aa,'month',aM,{MM:'2-digit',
+M:'numeric',MMMMM:'narrow',MMM:'short',MMMM:'long'});
+aM=%_Call(x,bR,/L{1,5}/g);
+aa=appendToDateTimeObject(aa,'month',aM,{LL:'2-digit',
+L:'numeric',LLLLL:'narrow',LLL:'short',LLLL:'long'});
+aM=%_Call(x,bR,/d{1,2}/g);
+aa=appendToDateTimeObject(
+aa,'day',aM,{d:'numeric',dd:'2-digit'});
+aM=%_Call(x,bR,/h{1,2}/g);
+if(aM!==null){
+aa['hour12']=true;
+}
+aa=appendToDateTimeObject(
+aa,'hour',aM,{h:'numeric',hh:'2-digit'});
+aM=%_Call(x,bR,/H{1,2}/g);
+if(aM!==null){
+aa['hour12']=false;
+}
+aa=appendToDateTimeObject(
+aa,'hour',aM,{H:'numeric',HH:'2-digit'});
+aM=%_Call(x,bR,/m{1,2}/g);
+aa=appendToDateTimeObject(
+aa,'minute',aM,{m:'numeric',mm:'2-digit'});
+aM=%_Call(x,bR,/s{1,2}/g);
+aa=appendToDateTimeObject(
+aa,'second',aM,{s:'numeric',ss:'2-digit'});
+aM=%_Call(x,bR,/z|zzzz/g);
+aa=appendToDateTimeObject(
+aa,'timeZoneName',aM,{z:'short',zzzz:'long'});
+return aa;
+}
+function appendToDateTimeObject(aa,bS,aM,bU){
+if((aM===null)){
+if(!%HasOwnProperty(aa,bS)){
+defineWEProperty(aa,bS,(void 0));
+}
+return aa;
+}
+var ak=aM[0];
+defineWEProperty(aa,bS,bU[ak]);
+return aa;
+}
+function toDateTimeOptions(aa,bV,bW){
+if((aa===(void 0))){
+aa={};
+}else{
+aa=(%_ToObject(aa));
+}
+var bX=true;
+if((bV==='date'||bV==='any')&&
+(!(aa.weekday===(void 0))||!(aa.year===(void 0))||
+!(aa.month===(void 0))||!(aa.day===(void 0)))){
+bX=false;
+}
+if((bV==='time'||bV==='any')&&
+(!(aa.hour===(void 0))||!(aa.minute===(void 0))||
+!(aa.second===(void 0)))){
+bX=false;
+}
+if(bX&&(bW==='date'||bW==='all')){
+r(aa,'year',{value:'numeric',
+writable:true,
+enumerable:true,
+configurable:true});
+r(aa,'month',{value:'numeric',
+writable:true,
+enumerable:true,
+configurable:true});
+r(aa,'day',{value:'numeric',
+writable:true,
+enumerable:true,
+configurable:true});
+}
+if(bX&&(bW==='time'||bW==='all')){
+r(aa,'hour',{value:'numeric',
+writable:true,
+enumerable:true,
+configurable:true});
+r(aa,'minute',{value:'numeric',
+writable:true,
+enumerable:true,
+configurable:true});
+r(aa,'second',{value:'numeric',
+writable:true,
+enumerable:true,
+configurable:true});
+}
+return aa;
+}
+function initializeDateTimeFormat(bY,Z,aa){
+if(%IsInitializedIntlObject(bY)){
+throw o(132,"DateTimeFormat");
+}
+if((aa===(void 0))){
+aa={};
+}
+var ag=resolveLocale('dateformat',Z,aa);
+aa=toDateTimeOptions(aa,'any','date');
+var aj=getGetOption(aa,'dateformat');
+var ab=aj('formatMatcher','string',
+['basic','best fit'],'best fit');
+var bR=toLDMLString(aa);
+var bZ=canonicalizeTimeZoneID(aa.timeZone);
+var br={};
+var at=parseExtension(ag.extension);
+var ca={
+'ca':{'property':(void 0),'type':'string'},
+'nu':{'property':(void 0),'type':'string'}
+};
+var ar=setOptions(aa,at,ca,
+aj,br);
+var bw=ag.locale+ar;
+var ap=q({},{
+calendar:{writable:true},
+day:{writable:true},
+era:{writable:true},
+hour12:{writable:true},
+hour:{writable:true},
+locale:{writable:true},
+minute:{writable:true},
+month:{writable:true},
+numberingSystem:{writable:true},
+[s]:{writable:true},
+pattern:bD,
+requestedLocale:{value:bw,writable:true},
+second:{writable:true},
+timeZone:{writable:true},
+timeZoneName:{writable:true},
+tz:{value:bZ,writable:true},
+weekday:{writable:true},
+year:{writable:true}
+});
+var bO=%CreateDateTimeFormat(
+bw,{skeleton:bR,timeZone:bZ},ap);
+if(ap.timeZone==="Etc/Unknown"){
+throw n(192,bZ);
+}
+%MarkAsInitializedIntlObjectOfType(bY,'dateformat',bO);
+bY[u]=ap;
+r(bY,'resolved',bp);
+return bY;
+}
+%AddNamedProperty(D,'DateTimeFormat',function(){
+var Z=%_Arguments(0);
+var aa=%_Arguments(1);
+if(!this||this===D){
+return new D.DateTimeFormat(Z,aa);
+}
+return initializeDateTimeFormat((%_ToObject(this)),Z,aa);
+},
+2
+);
+%AddNamedProperty(D.DateTimeFormat.prototype,'resolvedOptions',function(){
+if(!(new.target===(void 0))){
+throw o(87);
+}
+if(!%IsInitializedIntlObjectOfType(this,'dateformat')){
+throw o(133,"DateTimeFormat");
+}
+var cb={
+'gregorian':'gregory',
+'japanese':'japanese',
+'buddhist':'buddhist',
+'roc':'roc',
+'persian':'persian',
+'islamic-civil':'islamicc',
+'islamic':'islamic',
+'hebrew':'hebrew',
+'chinese':'chinese',
+'indian':'indian',
+'coptic':'coptic',
+'ethiopic':'ethiopic',
+'ethiopic-amete-alem':'ethioaa'
+};
+var bP=this;
+var cc=fromLDMLString(bP[u][s]);
+var cd=cb[bP[u].calendar];
+if((cd===(void 0))){
+cd=bP[u].calendar;
+}
+var ag=getOptimalLanguageTag(bP[u].requestedLocale,
+bP[u].locale);
+var aN={
+locale:ag,
+numberingSystem:bP[u].numberingSystem,
+calendar:cd,
+timeZone:bP[u].timeZone
+};
+addWECPropertyIfDefined(aN,'timeZoneName',cc.timeZoneName);
+addWECPropertyIfDefined(aN,'era',cc.era);
+addWECPropertyIfDefined(aN,'year',cc.year);
+addWECPropertyIfDefined(aN,'month',cc.month);
+addWECPropertyIfDefined(aN,'day',cc.day);
+addWECPropertyIfDefined(aN,'weekday',cc.weekday);
+addWECPropertyIfDefined(aN,'hour12',cc.hour12);
+addWECPropertyIfDefined(aN,'hour',cc.hour);
+addWECPropertyIfDefined(aN,'minute',cc.minute);
+addWECPropertyIfDefined(aN,'second',cc.second);
+return aN;
+},
+2
+);
+%FunctionSetName(D.DateTimeFormat.prototype.resolvedOptions,
+'resolvedOptions');
+%FunctionRemovePrototype(D.DateTimeFormat.prototype.resolvedOptions);
+%SetNativeFlag(D.DateTimeFormat.prototype.resolvedOptions);
+%AddNamedProperty(D.DateTimeFormat,'supportedLocalesOf',function(Z){
+if(!(new.target===(void 0))){
+throw o(87);
+}
+return supportedLocalesOf('dateformat',Z,%_Arguments(1));
+},
+2
+);
+%FunctionSetName(D.DateTimeFormat.supportedLocalesOf,'supportedLocalesOf');
+%FunctionRemovePrototype(D.DateTimeFormat.supportedLocalesOf);
+%SetNativeFlag(D.DateTimeFormat.supportedLocalesOf);
+function formatDate(bO,ce){
+var cf;
+if((ce===(void 0))){
+cf=%DateCurrentTime();
+}else{
+cf=(%_ToNumber(ce));
+}
+if(!f(cf))throw n(161);
+return %InternalDateFormat(%GetImplFromInitializedIntlObject(bO),
+new i(cf));
+}
+function parseDate(bO,ao){
+return %InternalDateParse(%GetImplFromInitializedIntlObject(bO),
+l(ao));
+}
+addBoundMethod(D.DateTimeFormat,'format',formatDate,0);
+addBoundMethod(D.DateTimeFormat,'v8Parse',parseDate,1);
+function canonicalizeTimeZoneID(cg){
+if((cg===(void 0))){
+return cg;
+}
+var ch=%StringToUpperCase(cg);
+if(ch==='UTC'||ch==='GMT'||
+ch==='ETC/UTC'||ch==='ETC/GMT'){
+return'UTC';
+}
+var aM=%_Call(x,cg,GetTimezoneNameCheckRE());
+if((aM===null))throw n(162,cg);
+var aN=toTitleCaseTimezoneLocation(aM[1])+'/'+
+toTitleCaseTimezoneLocation(aM[2]);
+if(!(aM[3]===(void 0))&&3<aM.length){
+var ci=%_Call(z,aM[3],'/');
+for(var af=1;af<ci.length;af++){
+aN=aN+'/'+toTitleCaseTimezoneLocation(ci[af]);
+}
+}
+return aN;
+}
+function initializeBreakIterator(cj,Z,aa){
+if(%IsInitializedIntlObject(cj)){
+throw o(132,"v8BreakIterator");
+}
+if((aa===(void 0))){
+aa={};
+}
+var aj=getGetOption(aa,'breakiterator');
+var br={};
+defineWEProperty(br,'type',aj(
+'type','string',['character','word','sentence','line'],'word'));
+var ag=resolveLocale('breakiterator',Z,aa);
+var ap=q({},{
+requestedLocale:{value:ag.locale,writable:true},
+type:{value:br.type,writable:true},
+locale:{writable:true}
+});
+var ck=%CreateBreakIterator(ag.locale,
+br,
+ap);
+%MarkAsInitializedIntlObjectOfType(cj,'breakiterator',
+ck);
+cj[u]=ap;
+r(cj,'resolved',bp);
+return cj;
+}
+%AddNamedProperty(D,'v8BreakIterator',function(){
+var Z=%_Arguments(0);
+var aa=%_Arguments(1);
+if(!this||this===D){
+return new D.v8BreakIterator(Z,aa);
+}
+return initializeBreakIterator((%_ToObject(this)),Z,aa);
+},
+2
+);
+%AddNamedProperty(D.v8BreakIterator.prototype,'resolvedOptions',
+function(){
+if(!(new.target===(void 0))){
+throw o(87);
+}
+if(!%IsInitializedIntlObjectOfType(this,'breakiterator')){
+throw o(133,"v8BreakIterator");
+}
+var cl=this;
+var ag=
+getOptimalLanguageTag(cl[u].requestedLocale,
+cl[u].locale);
+return{
+locale:ag,
+type:cl[u].type
+};
+},
+2
+);
+%FunctionSetName(D.v8BreakIterator.prototype.resolvedOptions,
+'resolvedOptions');
+%FunctionRemovePrototype(D.v8BreakIterator.prototype.resolvedOptions);
+%SetNativeFlag(D.v8BreakIterator.prototype.resolvedOptions);
+%AddNamedProperty(D.v8BreakIterator,'supportedLocalesOf',
+function(Z){
+if(!(new.target===(void 0))){
+throw o(87);
+}
+return supportedLocalesOf('breakiterator',Z,%_Arguments(1));
+},
+2
+);
+%FunctionSetName(D.v8BreakIterator.supportedLocalesOf,'supportedLocalesOf');
+%FunctionRemovePrototype(D.v8BreakIterator.supportedLocalesOf);
+%SetNativeFlag(D.v8BreakIterator.supportedLocalesOf);
+function adoptText(cj,cm){
+%BreakIteratorAdoptText(%GetImplFromInitializedIntlObject(cj),
+l(cm));
+}
+function first(cj){
+return %BreakIteratorFirst(%GetImplFromInitializedIntlObject(cj));
+}
+function next(cj){
+return %BreakIteratorNext(%GetImplFromInitializedIntlObject(cj));
+}
+function current(cj){
+return %BreakIteratorCurrent(%GetImplFromInitializedIntlObject(cj));
+}
+function breakType(cj){
+return %BreakIteratorBreakType(%GetImplFromInitializedIntlObject(cj));
+}
+addBoundMethod(D.v8BreakIterator,'adoptText',adoptText,1);
+addBoundMethod(D.v8BreakIterator,'first',first,0);
+addBoundMethod(D.v8BreakIterator,'next',next,0);
+addBoundMethod(D.v8BreakIterator,'current',current,0);
+addBoundMethod(D.v8BreakIterator,'breakType',breakType,0);
+var cn={
+'collator':D.Collator,
+'numberformat':D.NumberFormat,
+'dateformatall':D.DateTimeFormat,
+'dateformatdate':D.DateTimeFormat,
+'dateformattime':D.DateTimeFormat
+};
+var co={
+'collator':(void 0),
+'numberformat':(void 0),
+'dateformatall':(void 0),
+'dateformatdate':(void 0),
+'dateformattime':(void 0),
+};
+function cachedOrNewService(Y,Z,aa,bW){
+var cp=((bW===(void 0)))?aa:bW;
+if((Z===(void 0))&&(aa===(void 0))){
+if((co[Y]===(void 0))){
+co[Y]=new cn[Y](Z,cp);
+}
+return co[Y];
+}
+return new cn[Y](Z,cp);
+}
+function OverrideFunction(aJ,cq,cr){
+%CheckIsBootstrapping();
+r(aJ,cq,{value:cr,
+writeable:true,
+configurable:true,
+enumerable:false});
+%FunctionSetName(cr,cq);
+%FunctionRemovePrototype(cr);
+%SetNativeFlag(cr);
+}
+OverrideFunction(l.prototype,'localeCompare',function(U){
+if(!(new.target===(void 0))){
+throw o(87);
+}
+if((this==null)){
+throw o(52);
+}
+var Z=%_Arguments(1);
+var aa=%_Arguments(2);
+var bq=cachedOrNewService('collator',Z,aa);
+return compare(bq,this,U);
+}
+);
+OverrideFunction(l.prototype,'normalize',function(){
+if(!(new.target===(void 0))){
+throw o(87);
+}
+if((%IS_VAR(this)===null)||(this===(void 0)))throw o(17,"String.prototype.normalize");
+var cs=(%_ToString(this));
+var ct=%_Arguments(0);
+var cu=(ct===(void 0))?'NFC':(%_ToString(ct));
+var cv=['NFC','NFD','NFKC','NFKD'];
+var cw=%_Call(c,cv,cu);
+if(cw===-1){
+throw n(184,
+%_Call(d,cv,', '));
+}
+return %StringNormalize(cs,cw);
+}
+);
+OverrideFunction(j.prototype,'toLocaleString',function(){
+if(!(new.target===(void 0))){
+throw o(87);
+}
+if(!(this instanceof j)&&typeof(this)!=='number'){
+throw o(53,"Number");
+}
+var Z=%_Arguments(0);
+var aa=%_Arguments(1);
+var bE=cachedOrNewService('numberformat',Z,aa);
+return formatNumber(bE,this);
+}
+);
+function toLocaleDateTime(cx,Z,aa,bV,bW,Y){
+if(!(cx instanceof i)){
+throw o(53,"Date");
+}
+if(g(cx))return'Invalid Date';
+var br=toDateTimeOptions(aa,bV,bW);
+var bY=
+cachedOrNewService(Y,Z,aa,br);
+return formatDate(bY,cx);
+}
+OverrideFunction(i.prototype,'toLocaleString',function(){
+if(!(new.target===(void 0))){
+throw o(87);
+}
+var Z=%_Arguments(0);
+var aa=%_Arguments(1);
+return toLocaleDateTime(
+this,Z,aa,'any','all','dateformatall');
+}
+);
+OverrideFunction(i.prototype,'toLocaleDateString',function(){
+if(!(new.target===(void 0))){
+throw o(87);
+}
+var Z=%_Arguments(0);
+var aa=%_Arguments(1);
+return toLocaleDateTime(
+this,Z,aa,'date','date','dateformatdate');
+}
+);
+OverrideFunction(i.prototype,'toLocaleTimeString',function(){
+if(!(new.target===(void 0))){
+throw o(87);
+}
+var Z=%_Arguments(0);
+var aa=%_Arguments(1);
+return toLocaleDateTime(
+this,Z,aa,'time','time','dateformattime');
+}
+);
+})
+
+,proxy		
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Proxy;
+var d;
+b.Import(function(e){
+d=e.MakeTypeError;
+});
+function ProxyCreateRevocable(f,g){
+var h=new c(f,g);
+return{proxy:h,revoke:()=>%JSProxyRevoke(h)};
+}
+function ProxyEnumerate(i,g,f){
+var j=%_Call(i,g,f);
+if(!(%_IsJSReceiver(j))){
+throw d(99);
+}
+var k=[];
+for(var l=j.next();!l.done;l=j.next()){
+var m=l.value;
+if(!(typeof(m)==='string')){
+throw d(100);
+}
+k.push(m);
+}
+return k;
+}
+b.InstallFunctions(c,2,[
+"revocable",ProxyCreateRevocable
+]);
+%InstallToContext([
+"proxy_enumerate",ProxyEnumerate,
+]);
+})
+
+$generator�
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=b.ImportNow("GeneratorFunctionPrototype");
+var d=b.ImportNow("GeneratorFunction");
+var e=a.Function;
+var f;
+var g=b.ImportNow("to_string_tag_symbol");
+b.Import(function(h){
+f=h.MakeTypeError;
+});
+function GeneratorObjectNext(i){
+if(!(%_ClassOf(this)==='Generator')){
+throw f(42,
+'[Generator].prototype.next',this);
+}
+var j=%GeneratorGetContinuation(this);
+if(j>0){
+if(%_DebugIsActive()!=0)%DebugPrepareStepInIfStepping(this);
+try{
+return %_GeneratorNext(this,i);
+}catch(e){
+%GeneratorClose(this);
+throw e;
+}
+}else if(j==0){
+return{value:void 0,done:true};
+}else{
+throw f(40);
+}
+}
+function GeneratorObjectThrow(k){
+if(!(%_ClassOf(this)==='Generator')){
+throw f(42,
+'[Generator].prototype.throw',this);
+}
+var j=%GeneratorGetContinuation(this);
+if(j>0){
+try{
+return %_GeneratorThrow(this,k);
+}catch(e){
+%GeneratorClose(this);
+throw e;
+}
+}else if(j==0){
+throw k;
+}else{
+throw f(40);
+}
+}
+%NeverOptimizeFunction(GeneratorObjectNext);
+%NeverOptimizeFunction(GeneratorObjectThrow);
+var l=c.prototype;
+b.InstallFunctions(l,
+2,
+["next",GeneratorObjectNext,
+"throw",GeneratorObjectThrow]);
+%AddNamedProperty(l,"constructor",
+c,2|1);
+%AddNamedProperty(l,
+g,"Generator",2|1);
+%InternalSetPrototype(c,e.prototype);
+%AddNamedProperty(c,
+g,"GeneratorFunction",2|1);
+%AddNamedProperty(c,"constructor",
+d,2|1);
+%InternalSetPrototype(d,e);
+})
+
+<harmony-atomicsM:
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Object;
+var d;
+var e;
+var f=b.ImportNow("to_string_tag_symbol");
+b.Import(function(g){
+d=g.MakeTypeError;
+e=g.MaxSimple;
+});
+function CheckSharedIntegerTypedArray(h){
+if(!%IsSharedIntegerTypedArray(h)){
+throw d(70,h);
+}
+}
+function CheckSharedInteger32TypedArray(h){
+CheckSharedIntegerTypedArray(h);
+if(!%IsSharedInteger32TypedArray(h)){
+throw d(71,h);
+}
+}
+function AtomicsCompareExchangeJS(i,j,k,l){
+CheckSharedIntegerTypedArray(i);
+j=(%_ToInteger(j));
+if(j<0||j>=%_TypedArrayGetLength(i)){
+return(void 0);
+}
+k=(%_ToNumber(k));
+l=(%_ToNumber(l));
+return %_AtomicsCompareExchange(i,j,k,l);
+}
+function AtomicsLoadJS(i,j){
+CheckSharedIntegerTypedArray(i);
+j=(%_ToInteger(j));
+if(j<0||j>=%_TypedArrayGetLength(i)){
+return(void 0);
+}
+return %_AtomicsLoad(i,j);
+}
+function AtomicsStoreJS(i,j,m){
+CheckSharedIntegerTypedArray(i);
+j=(%_ToInteger(j));
+if(j<0||j>=%_TypedArrayGetLength(i)){
+return(void 0);
+}
+m=(%_ToNumber(m));
+return %_AtomicsStore(i,j,m);
+}
+function AtomicsAddJS(h,j,m){
+CheckSharedIntegerTypedArray(h);
+j=(%_ToInteger(j));
+if(j<0||j>=%_TypedArrayGetLength(h)){
+return(void 0);
+}
+m=(%_ToNumber(m));
+return %_AtomicsAdd(h,j,m);
+}
+function AtomicsSubJS(h,j,m){
+CheckSharedIntegerTypedArray(h);
+j=(%_ToInteger(j));
+if(j<0||j>=%_TypedArrayGetLength(h)){
+return(void 0);
+}
+m=(%_ToNumber(m));
+return %_AtomicsSub(h,j,m);
+}
+function AtomicsAndJS(h,j,m){
+CheckSharedIntegerTypedArray(h);
+j=(%_ToInteger(j));
+if(j<0||j>=%_TypedArrayGetLength(h)){
+return(void 0);
+}
+m=(%_ToNumber(m));
+return %_AtomicsAnd(h,j,m);
+}
+function AtomicsOrJS(h,j,m){
+CheckSharedIntegerTypedArray(h);
+j=(%_ToInteger(j));
+if(j<0||j>=%_TypedArrayGetLength(h)){
+return(void 0);
+}
+m=(%_ToNumber(m));
+return %_AtomicsOr(h,j,m);
+}
+function AtomicsXorJS(h,j,m){
+CheckSharedIntegerTypedArray(h);
+j=(%_ToInteger(j));
+if(j<0||j>=%_TypedArrayGetLength(h)){
+return(void 0);
+}
+m=(%_ToNumber(m));
+return %_AtomicsXor(h,j,m);
+}
+function AtomicsExchangeJS(h,j,m){
+CheckSharedIntegerTypedArray(h);
+j=(%_ToInteger(j));
+if(j<0||j>=%_TypedArrayGetLength(h)){
+return(void 0);
+}
+m=(%_ToNumber(m));
+return %_AtomicsExchange(h,j,m);
+}
+function AtomicsIsLockFreeJS(n){
+return %_AtomicsIsLockFree(n);
+}
+function AtomicsFutexWaitJS(h,j,m,o){
+CheckSharedInteger32TypedArray(h);
+j=(%_ToInteger(j));
+if(j<0||j>=%_TypedArrayGetLength(h)){
+return(void 0);
+}
+if((o===(void 0))){
+o=(1/0);
+}else{
+o=(%_ToNumber(o));
+if((!%_IsSmi(%IS_VAR(o))&&!(o==o))){
+o=(1/0);
+}else{
+o=e(0,o);
+}
+}
+return %AtomicsFutexWait(h,j,m,o);
+}
+function AtomicsFutexWakeJS(h,j,p){
+CheckSharedInteger32TypedArray(h);
+j=(%_ToInteger(j));
+if(j<0||j>=%_TypedArrayGetLength(h)){
+return(void 0);
+}
+p=e(0,(%_ToInteger(p)));
+return %AtomicsFutexWake(h,j,p);
+}
+function AtomicsFutexWakeOrRequeueJS(h,q,p,m,r){
+CheckSharedInteger32TypedArray(h);
+q=(%_ToInteger(q));
+p=e(0,(%_ToInteger(p)));
+m=((m)|0);
+r=(%_ToInteger(r));
+if(q<0||q>=%_TypedArrayGetLength(h)||
+r<0||r>=%_TypedArrayGetLength(h)){
+return(void 0);
+}
+return %AtomicsFutexWakeOrRequeue(h,q,p,m,r);
+}
+function AtomicsConstructor(){}
+var s=new AtomicsConstructor();
+%InternalSetPrototype(s,c.prototype);
+%AddNamedProperty(a,"Atomics",s,2);
+%FunctionSetInstanceClassName(AtomicsConstructor,'Atomics');
+%AddNamedProperty(s,f,"Atomics",1|2);
+b.InstallConstants(s,[
+"OK",0,
+"NOTEQUAL",-1,
+"TIMEDOUT",-2,
+]);
+b.InstallFunctions(s,2,[
+"compareExchange",AtomicsCompareExchangeJS,
+"load",AtomicsLoadJS,
+"store",AtomicsStoreJS,
+"add",AtomicsAddJS,
+"sub",AtomicsSubJS,
+"and",AtomicsAndJS,
+"or",AtomicsOrJS,
+"xor",AtomicsXorJS,
+"exchange",AtomicsExchangeJS,
+"isLockFree",AtomicsIsLockFreeJS,
+"futexWait",AtomicsFutexWaitJS,
+"futexWake",AtomicsFutexWakeJS,
+"futexWakeOrRequeue",AtomicsFutexWakeOrRequeueJS,
+]);
+})
+
+8harmony-regexp%
+(function(a,b){
+'use strict';
+%CheckIsBootstrapping();
+var c=a.RegExp;
+var d=c.prototype;
+var e;
+var f=b.ImportNow("regexp_flags_symbol");
+b.Import(function(g){
+e=g.MakeTypeError;
+});
+function RegExpGetFlags(){
+if(!(%_IsJSReceiver(this))){
+throw e(
+130,"RegExp.prototype.flags",(%_ToString(this)));
+}
+var h='';
+if(this.global)h+='g';
+if(this.ignoreCase)h+='i';
+if(this.multiline)h+='m';
+if(this.unicode)h+='u';
+if(this.sticky)h+='y';
+return h;
+}
+function RegExpGetSticky(){
+if(!(%_IsRegExp(this))){
+if(this===d){
+%IncrementUseCounter(11);
+return(void 0);
+}
+throw e(131,"RegExp.prototype.sticky");
+}
+return!!(%_RegExpFlags(this)&8);
+}
+%FunctionSetName(RegExpGetSticky,"RegExp.prototype.sticky");
+%SetNativeFlag(RegExpGetSticky);
+b.InstallGetter(c.prototype,'flags',RegExpGetFlags);
+b.InstallGetter(c.prototype,'sticky',RegExpGetSticky);
+})
+
+<harmony-reflect�
+(function(a,b){
+'use strict';
+%CheckIsBootstrapping();
+var c=a.Reflect;
+var d;
+var e=b.ImportNow("reflect_apply");
+var f=b.ImportNow("reflect_construct");
+b.Import(function(g){
+d=g.MakeTypeError;
+});
+function ReflectEnumerate(h){
+if(!(%_IsJSReceiver(h)))
+throw d(16,"Reflect.enumerate")
+return(function*(){for(var i in h)yield i})();
+}
+b.InstallFunctions(c,2,[
+"apply",e,
+"construct",f,
+"enumerate",ReflectEnumerate
+]);
+})
+
+Xharmony-object-observeU
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=b.ImportNow("ObserveArrayMethods");
+var d=b.ImportNow("ObserveObjectMethods");;
+b.InstallFunctions(a.Object,2,d);
+b.InstallFunctions(a.Array,2,c);
+})
+
+dharmony-sharedarraybufferE
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.SharedArrayBuffer;
+var d;
+b.Import(function(e){
+d=e.MakeTypeError;
+})
+function SharedArrayBufferGetByteLen(){
+if(!(%_ClassOf(this)==='SharedArrayBuffer')){
+throw d(42,
+'SharedArrayBuffer.prototype.byteLength',this);
+}
+return %_ArrayBufferGetByteLength(this);
+}
+b.InstallGetter(c.prototype,"byteLength",
+SharedArrayBufferGetByteLen);
+})
+
+0harmony-simd��
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.SIMD;
+var d;
+var e=b.ImportNow("to_string_tag_symbol");
+b.Import(function(f){
+d=f.MakeTypeError;
+});
+var g=c.Float32x4;
+
+
+var h=c.Int32x4;
+
+var i=c.Int16x8;
+
+var j=c.Int8x16;
+
+
+var k=c.Uint32x4;
+
+var l=c.Uint16x8;
+
+var m=c.Uint8x16;
+
+
+var n=c.Bool32x4;
+
+var o=c.Bool16x8;
+
+var p=c.Bool8x16;
+
+
+
+function Float32x4CheckJS(q){
+return %Float32x4Check(q);
+}
+function Float32x4ToString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='float32x4'){
+throw d(42,
+"Float32x4.prototype.toString",this);
+}
+var s="SIMD.Float32x4(";
+s+=%Float32x4ExtractLane(r,0);
+for(var t=1;t<4;t++){
+s+=", "+%Float32x4ExtractLane(r,t);
+}
+return s+")";
+}
+function Float32x4ToLocaleString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='float32x4'){
+throw d(42,
+"Float32x4.prototype.toLocaleString",this);
+}
+var s="SIMD.Float32x4(";
+s+=%Float32x4ExtractLane(r,0).toLocaleString();
+for(var t=1;t<4;t++){
+s+=", "+%Float32x4ExtractLane(r,t).toLocaleString();
+}
+return s+")";
+}
+function Float32x4ValueOf(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='float32x4'){
+throw d(42,
+"Float32x4.prototype.valueOf",this);
+}
+return r;
+}
+function Float32x4ExtractLaneJS(u,v){
+return %Float32x4ExtractLane(u,v);
+}
+
+
+function Int32x4CheckJS(q){
+return %Int32x4Check(q);
+}
+function Int32x4ToString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='int32x4'){
+throw d(42,
+"Int32x4.prototype.toString",this);
+}
+var s="SIMD.Int32x4(";
+s+=%Int32x4ExtractLane(r,0);
+for(var t=1;t<4;t++){
+s+=", "+%Int32x4ExtractLane(r,t);
+}
+return s+")";
+}
+function Int32x4ToLocaleString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='int32x4'){
+throw d(42,
+"Int32x4.prototype.toLocaleString",this);
+}
+var s="SIMD.Int32x4(";
+s+=%Int32x4ExtractLane(r,0).toLocaleString();
+for(var t=1;t<4;t++){
+s+=", "+%Int32x4ExtractLane(r,t).toLocaleString();
+}
+return s+")";
+}
+function Int32x4ValueOf(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='int32x4'){
+throw d(42,
+"Int32x4.prototype.valueOf",this);
+}
+return r;
+}
+function Int32x4ExtractLaneJS(u,v){
+return %Int32x4ExtractLane(u,v);
+}
+
+function Int16x8CheckJS(q){
+return %Int16x8Check(q);
+}
+function Int16x8ToString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='int16x8'){
+throw d(42,
+"Int16x8.prototype.toString",this);
+}
+var s="SIMD.Int16x8(";
+s+=%Int16x8ExtractLane(r,0);
+for(var t=1;t<8;t++){
+s+=", "+%Int16x8ExtractLane(r,t);
+}
+return s+")";
+}
+function Int16x8ToLocaleString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='int16x8'){
+throw d(42,
+"Int16x8.prototype.toLocaleString",this);
+}
+var s="SIMD.Int16x8(";
+s+=%Int16x8ExtractLane(r,0).toLocaleString();
+for(var t=1;t<8;t++){
+s+=", "+%Int16x8ExtractLane(r,t).toLocaleString();
+}
+return s+")";
+}
+function Int16x8ValueOf(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='int16x8'){
+throw d(42,
+"Int16x8.prototype.valueOf",this);
+}
+return r;
+}
+function Int16x8ExtractLaneJS(u,v){
+return %Int16x8ExtractLane(u,v);
+}
+
+function Int8x16CheckJS(q){
+return %Int8x16Check(q);
+}
+function Int8x16ToString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='int8x16'){
+throw d(42,
+"Int8x16.prototype.toString",this);
+}
+var s="SIMD.Int8x16(";
+s+=%Int8x16ExtractLane(r,0);
+for(var t=1;t<16;t++){
+s+=", "+%Int8x16ExtractLane(r,t);
+}
+return s+")";
+}
+function Int8x16ToLocaleString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='int8x16'){
+throw d(42,
+"Int8x16.prototype.toLocaleString",this);
+}
+var s="SIMD.Int8x16(";
+s+=%Int8x16ExtractLane(r,0).toLocaleString();
+for(var t=1;t<16;t++){
+s+=", "+%Int8x16ExtractLane(r,t).toLocaleString();
+}
+return s+")";
+}
+function Int8x16ValueOf(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='int8x16'){
+throw d(42,
+"Int8x16.prototype.valueOf",this);
+}
+return r;
+}
+function Int8x16ExtractLaneJS(u,v){
+return %Int8x16ExtractLane(u,v);
+}
+
+
+function Uint32x4CheckJS(q){
+return %Uint32x4Check(q);
+}
+function Uint32x4ToString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='uint32x4'){
+throw d(42,
+"Uint32x4.prototype.toString",this);
+}
+var s="SIMD.Uint32x4(";
+s+=%Uint32x4ExtractLane(r,0);
+for(var t=1;t<4;t++){
+s+=", "+%Uint32x4ExtractLane(r,t);
+}
+return s+")";
+}
+function Uint32x4ToLocaleString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='uint32x4'){
+throw d(42,
+"Uint32x4.prototype.toLocaleString",this);
+}
+var s="SIMD.Uint32x4(";
+s+=%Uint32x4ExtractLane(r,0).toLocaleString();
+for(var t=1;t<4;t++){
+s+=", "+%Uint32x4ExtractLane(r,t).toLocaleString();
+}
+return s+")";
+}
+function Uint32x4ValueOf(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='uint32x4'){
+throw d(42,
+"Uint32x4.prototype.valueOf",this);
+}
+return r;
+}
+function Uint32x4ExtractLaneJS(u,v){
+return %Uint32x4ExtractLane(u,v);
+}
+
+function Uint16x8CheckJS(q){
+return %Uint16x8Check(q);
+}
+function Uint16x8ToString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='uint16x8'){
+throw d(42,
+"Uint16x8.prototype.toString",this);
+}
+var s="SIMD.Uint16x8(";
+s+=%Uint16x8ExtractLane(r,0);
+for(var t=1;t<8;t++){
+s+=", "+%Uint16x8ExtractLane(r,t);
+}
+return s+")";
+}
+function Uint16x8ToLocaleString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='uint16x8'){
+throw d(42,
+"Uint16x8.prototype.toLocaleString",this);
+}
+var s="SIMD.Uint16x8(";
+s+=%Uint16x8ExtractLane(r,0).toLocaleString();
+for(var t=1;t<8;t++){
+s+=", "+%Uint16x8ExtractLane(r,t).toLocaleString();
+}
+return s+")";
+}
+function Uint16x8ValueOf(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='uint16x8'){
+throw d(42,
+"Uint16x8.prototype.valueOf",this);
+}
+return r;
+}
+function Uint16x8ExtractLaneJS(u,v){
+return %Uint16x8ExtractLane(u,v);
+}
+
+function Uint8x16CheckJS(q){
+return %Uint8x16Check(q);
+}
+function Uint8x16ToString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='uint8x16'){
+throw d(42,
+"Uint8x16.prototype.toString",this);
+}
+var s="SIMD.Uint8x16(";
+s+=%Uint8x16ExtractLane(r,0);
+for(var t=1;t<16;t++){
+s+=", "+%Uint8x16ExtractLane(r,t);
+}
+return s+")";
+}
+function Uint8x16ToLocaleString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='uint8x16'){
+throw d(42,
+"Uint8x16.prototype.toLocaleString",this);
+}
+var s="SIMD.Uint8x16(";
+s+=%Uint8x16ExtractLane(r,0).toLocaleString();
+for(var t=1;t<16;t++){
+s+=", "+%Uint8x16ExtractLane(r,t).toLocaleString();
+}
+return s+")";
+}
+function Uint8x16ValueOf(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='uint8x16'){
+throw d(42,
+"Uint8x16.prototype.valueOf",this);
+}
+return r;
+}
+function Uint8x16ExtractLaneJS(u,v){
+return %Uint8x16ExtractLane(u,v);
+}
+
+
+function Bool32x4CheckJS(q){
+return %Bool32x4Check(q);
+}
+function Bool32x4ToString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='bool32x4'){
+throw d(42,
+"Bool32x4.prototype.toString",this);
+}
+var s="SIMD.Bool32x4(";
+s+=%Bool32x4ExtractLane(r,0);
+for(var t=1;t<4;t++){
+s+=", "+%Bool32x4ExtractLane(r,t);
+}
+return s+")";
+}
+function Bool32x4ToLocaleString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='bool32x4'){
+throw d(42,
+"Bool32x4.prototype.toLocaleString",this);
+}
+var s="SIMD.Bool32x4(";
+s+=%Bool32x4ExtractLane(r,0).toLocaleString();
+for(var t=1;t<4;t++){
+s+=", "+%Bool32x4ExtractLane(r,t).toLocaleString();
+}
+return s+")";
+}
+function Bool32x4ValueOf(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='bool32x4'){
+throw d(42,
+"Bool32x4.prototype.valueOf",this);
+}
+return r;
+}
+function Bool32x4ExtractLaneJS(u,v){
+return %Bool32x4ExtractLane(u,v);
+}
+
+function Bool16x8CheckJS(q){
+return %Bool16x8Check(q);
+}
+function Bool16x8ToString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='bool16x8'){
+throw d(42,
+"Bool16x8.prototype.toString",this);
+}
+var s="SIMD.Bool16x8(";
+s+=%Bool16x8ExtractLane(r,0);
+for(var t=1;t<8;t++){
+s+=", "+%Bool16x8ExtractLane(r,t);
+}
+return s+")";
+}
+function Bool16x8ToLocaleString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='bool16x8'){
+throw d(42,
+"Bool16x8.prototype.toLocaleString",this);
+}
+var s="SIMD.Bool16x8(";
+s+=%Bool16x8ExtractLane(r,0).toLocaleString();
+for(var t=1;t<8;t++){
+s+=", "+%Bool16x8ExtractLane(r,t).toLocaleString();
+}
+return s+")";
+}
+function Bool16x8ValueOf(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='bool16x8'){
+throw d(42,
+"Bool16x8.prototype.valueOf",this);
+}
+return r;
+}
+function Bool16x8ExtractLaneJS(u,v){
+return %Bool16x8ExtractLane(u,v);
+}
+
+function Bool8x16CheckJS(q){
+return %Bool8x16Check(q);
+}
+function Bool8x16ToString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='bool8x16'){
+throw d(42,
+"Bool8x16.prototype.toString",this);
+}
+var s="SIMD.Bool8x16(";
+s+=%Bool8x16ExtractLane(r,0);
+for(var t=1;t<16;t++){
+s+=", "+%Bool8x16ExtractLane(r,t);
+}
+return s+")";
+}
+function Bool8x16ToLocaleString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='bool8x16'){
+throw d(42,
+"Bool8x16.prototype.toLocaleString",this);
+}
+var s="SIMD.Bool8x16(";
+s+=%Bool8x16ExtractLane(r,0).toLocaleString();
+for(var t=1;t<16;t++){
+s+=", "+%Bool8x16ExtractLane(r,t).toLocaleString();
+}
+return s+")";
+}
+function Bool8x16ValueOf(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='bool8x16'){
+throw d(42,
+"Bool8x16.prototype.valueOf",this);
+}
+return r;
+}
+function Bool8x16ExtractLaneJS(u,v){
+return %Bool8x16ExtractLane(u,v);
+}
+
+
+
+function Int32x4ShiftLeftByScalarJS(u,w){
+return %Int32x4ShiftLeftByScalar(u,w);
+}
+function Int32x4ShiftRightByScalarJS(u,w){
+return %Int32x4ShiftRightByScalar(u,w);
+}
+
+function Int16x8ShiftLeftByScalarJS(u,w){
+return %Int16x8ShiftLeftByScalar(u,w);
+}
+function Int16x8ShiftRightByScalarJS(u,w){
+return %Int16x8ShiftRightByScalar(u,w);
+}
+
+function Int8x16ShiftLeftByScalarJS(u,w){
+return %Int8x16ShiftLeftByScalar(u,w);
+}
+function Int8x16ShiftRightByScalarJS(u,w){
+return %Int8x16ShiftRightByScalar(u,w);
+}
+
+
+function Uint32x4ShiftLeftByScalarJS(u,w){
+return %Uint32x4ShiftLeftByScalar(u,w);
+}
+function Uint32x4ShiftRightByScalarJS(u,w){
+return %Uint32x4ShiftRightByScalar(u,w);
+}
+
+function Uint16x8ShiftLeftByScalarJS(u,w){
+return %Uint16x8ShiftLeftByScalar(u,w);
+}
+function Uint16x8ShiftRightByScalarJS(u,w){
+return %Uint16x8ShiftRightByScalar(u,w);
+}
+
+function Uint8x16ShiftLeftByScalarJS(u,w){
+return %Uint8x16ShiftLeftByScalar(u,w);
+}
+function Uint8x16ShiftRightByScalarJS(u,w){
+return %Uint8x16ShiftRightByScalar(u,w);
+}
+
+
+function Int16x8AddSaturateJS(q,x){
+return %Int16x8AddSaturate(q,x);
+}
+function Int16x8SubSaturateJS(q,x){
+return %Int16x8SubSaturate(q,x);
+}
+
+function Int8x16AddSaturateJS(q,x){
+return %Int8x16AddSaturate(q,x);
+}
+function Int8x16SubSaturateJS(q,x){
+return %Int8x16SubSaturate(q,x);
+}
+
+function Uint8x16AddSaturateJS(q,x){
+return %Uint8x16AddSaturate(q,x);
+}
+function Uint8x16SubSaturateJS(q,x){
+return %Uint8x16SubSaturate(q,x);
+}
+
+function Uint16x8AddSaturateJS(q,x){
+return %Uint16x8AddSaturate(q,x);
+}
+function Uint16x8SubSaturateJS(q,x){
+return %Uint16x8SubSaturate(q,x);
+}
+
+
+function Float32x4NegJS(q){
+return %Float32x4Neg(q);
+}
+
+
+function Int32x4NegJS(q){
+return %Int32x4Neg(q);
+}
+
+function Int16x8NegJS(q){
+return %Int16x8Neg(q);
+}
+
+function Int8x16NegJS(q){
+return %Int8x16Neg(q);
+}
+
+
+function Bool32x4ReplaceLaneJS(u,v,r){
+return %Bool32x4ReplaceLane(u,v,r);
+}
+function Bool32x4AnyTrueJS(y){
+return %Bool32x4AnyTrue(y);
+}
+function Bool32x4AllTrueJS(y){
+return %Bool32x4AllTrue(y);
+}
+
+function Bool16x8ReplaceLaneJS(u,v,r){
+return %Bool16x8ReplaceLane(u,v,r);
+}
+function Bool16x8AnyTrueJS(y){
+return %Bool16x8AnyTrue(y);
+}
+function Bool16x8AllTrueJS(y){
+return %Bool16x8AllTrue(y);
+}
+
+function Bool8x16ReplaceLaneJS(u,v,r){
+return %Bool8x16ReplaceLane(u,v,r);
+}
+function Bool8x16AnyTrueJS(y){
+return %Bool8x16AnyTrue(y);
+}
+function Bool8x16AllTrueJS(y){
+return %Bool8x16AllTrue(y);
+}
+
+
+function Float32x4ReplaceLaneJS(u,v,r){
+return %Float32x4ReplaceLane(u,v,(%_ToNumber(r)));
+}
+function Float32x4SelectJS(z,q,x){
+return %Float32x4Select(z,q,x);
+}
+function Float32x4AddJS(q,x){
+return %Float32x4Add(q,x);
+}
+function Float32x4SubJS(q,x){
+return %Float32x4Sub(q,x);
+}
+function Float32x4MulJS(q,x){
+return %Float32x4Mul(q,x);
+}
+function Float32x4MinJS(q,x){
+return %Float32x4Min(q,x);
+}
+function Float32x4MaxJS(q,x){
+return %Float32x4Max(q,x);
+}
+function Float32x4EqualJS(q,x){
+return %Float32x4Equal(q,x);
+}
+function Float32x4NotEqualJS(q,x){
+return %Float32x4NotEqual(q,x);
+}
+function Float32x4LessThanJS(q,x){
+return %Float32x4LessThan(q,x);
+}
+function Float32x4LessThanOrEqualJS(q,x){
+return %Float32x4LessThanOrEqual(q,x);
+}
+function Float32x4GreaterThanJS(q,x){
+return %Float32x4GreaterThan(q,x);
+}
+function Float32x4GreaterThanOrEqualJS(q,x){
+return %Float32x4GreaterThanOrEqual(q,x);
+}
+function Float32x4LoadJS(A,B){
+return %Float32x4Load(A,B);
+}
+function Float32x4StoreJS(A,B,q){
+return %Float32x4Store(A,B,q);
+}
+
+
+function Int32x4ReplaceLaneJS(u,v,r){
+return %Int32x4ReplaceLane(u,v,(%_ToNumber(r)));
+}
+function Int32x4SelectJS(z,q,x){
+return %Int32x4Select(z,q,x);
+}
+function Int32x4AddJS(q,x){
+return %Int32x4Add(q,x);
+}
+function Int32x4SubJS(q,x){
+return %Int32x4Sub(q,x);
+}
+function Int32x4MulJS(q,x){
+return %Int32x4Mul(q,x);
+}
+function Int32x4MinJS(q,x){
+return %Int32x4Min(q,x);
+}
+function Int32x4MaxJS(q,x){
+return %Int32x4Max(q,x);
+}
+function Int32x4EqualJS(q,x){
+return %Int32x4Equal(q,x);
+}
+function Int32x4NotEqualJS(q,x){
+return %Int32x4NotEqual(q,x);
+}
+function Int32x4LessThanJS(q,x){
+return %Int32x4LessThan(q,x);
+}
+function Int32x4LessThanOrEqualJS(q,x){
+return %Int32x4LessThanOrEqual(q,x);
+}
+function Int32x4GreaterThanJS(q,x){
+return %Int32x4GreaterThan(q,x);
+}
+function Int32x4GreaterThanOrEqualJS(q,x){
+return %Int32x4GreaterThanOrEqual(q,x);
+}
+function Int32x4LoadJS(A,B){
+return %Int32x4Load(A,B);
+}
+function Int32x4StoreJS(A,B,q){
+return %Int32x4Store(A,B,q);
+}
+
+function Int16x8ReplaceLaneJS(u,v,r){
+return %Int16x8ReplaceLane(u,v,(%_ToNumber(r)));
+}
+function Int16x8SelectJS(z,q,x){
+return %Int16x8Select(z,q,x);
+}
+function Int16x8AddJS(q,x){
+return %Int16x8Add(q,x);
+}
+function Int16x8SubJS(q,x){
+return %Int16x8Sub(q,x);
+}
+function Int16x8MulJS(q,x){
+return %Int16x8Mul(q,x);
+}
+function Int16x8MinJS(q,x){
+return %Int16x8Min(q,x);
+}
+function Int16x8MaxJS(q,x){
+return %Int16x8Max(q,x);
+}
+function Int16x8EqualJS(q,x){
+return %Int16x8Equal(q,x);
+}
+function Int16x8NotEqualJS(q,x){
+return %Int16x8NotEqual(q,x);
+}
+function Int16x8LessThanJS(q,x){
+return %Int16x8LessThan(q,x);
+}
+function Int16x8LessThanOrEqualJS(q,x){
+return %Int16x8LessThanOrEqual(q,x);
+}
+function Int16x8GreaterThanJS(q,x){
+return %Int16x8GreaterThan(q,x);
+}
+function Int16x8GreaterThanOrEqualJS(q,x){
+return %Int16x8GreaterThanOrEqual(q,x);
+}
+function Int16x8LoadJS(A,B){
+return %Int16x8Load(A,B);
+}
+function Int16x8StoreJS(A,B,q){
+return %Int16x8Store(A,B,q);
+}
+
+function Int8x16ReplaceLaneJS(u,v,r){
+return %Int8x16ReplaceLane(u,v,(%_ToNumber(r)));
+}
+function Int8x16SelectJS(z,q,x){
+return %Int8x16Select(z,q,x);
+}
+function Int8x16AddJS(q,x){
+return %Int8x16Add(q,x);
+}
+function Int8x16SubJS(q,x){
+return %Int8x16Sub(q,x);
+}
+function Int8x16MulJS(q,x){
+return %Int8x16Mul(q,x);
+}
+function Int8x16MinJS(q,x){
+return %Int8x16Min(q,x);
+}
+function Int8x16MaxJS(q,x){
+return %Int8x16Max(q,x);
+}
+function Int8x16EqualJS(q,x){
+return %Int8x16Equal(q,x);
+}
+function Int8x16NotEqualJS(q,x){
+return %Int8x16NotEqual(q,x);
+}
+function Int8x16LessThanJS(q,x){
+return %Int8x16LessThan(q,x);
+}
+function Int8x16LessThanOrEqualJS(q,x){
+return %Int8x16LessThanOrEqual(q,x);
+}
+function Int8x16GreaterThanJS(q,x){
+return %Int8x16GreaterThan(q,x);
+}
+function Int8x16GreaterThanOrEqualJS(q,x){
+return %Int8x16GreaterThanOrEqual(q,x);
+}
+function Int8x16LoadJS(A,B){
+return %Int8x16Load(A,B);
+}
+function Int8x16StoreJS(A,B,q){
+return %Int8x16Store(A,B,q);
+}
+
+
+function Uint32x4ReplaceLaneJS(u,v,r){
+return %Uint32x4ReplaceLane(u,v,(%_ToNumber(r)));
+}
+function Uint32x4SelectJS(z,q,x){
+return %Uint32x4Select(z,q,x);
+}
+function Uint32x4AddJS(q,x){
+return %Uint32x4Add(q,x);
+}
+function Uint32x4SubJS(q,x){
+return %Uint32x4Sub(q,x);
+}
+function Uint32x4MulJS(q,x){
+return %Uint32x4Mul(q,x);
+}
+function Uint32x4MinJS(q,x){
+return %Uint32x4Min(q,x);
+}
+function Uint32x4MaxJS(q,x){
+return %Uint32x4Max(q,x);
+}
+function Uint32x4EqualJS(q,x){
+return %Uint32x4Equal(q,x);
+}
+function Uint32x4NotEqualJS(q,x){
+return %Uint32x4NotEqual(q,x);
+}
+function Uint32x4LessThanJS(q,x){
+return %Uint32x4LessThan(q,x);
+}
+function Uint32x4LessThanOrEqualJS(q,x){
+return %Uint32x4LessThanOrEqual(q,x);
+}
+function Uint32x4GreaterThanJS(q,x){
+return %Uint32x4GreaterThan(q,x);
+}
+function Uint32x4GreaterThanOrEqualJS(q,x){
+return %Uint32x4GreaterThanOrEqual(q,x);
+}
+function Uint32x4LoadJS(A,B){
+return %Uint32x4Load(A,B);
+}
+function Uint32x4StoreJS(A,B,q){
+return %Uint32x4Store(A,B,q);
+}
+
+function Uint16x8ReplaceLaneJS(u,v,r){
+return %Uint16x8ReplaceLane(u,v,(%_ToNumber(r)));
+}
+function Uint16x8SelectJS(z,q,x){
+return %Uint16x8Select(z,q,x);
+}
+function Uint16x8AddJS(q,x){
+return %Uint16x8Add(q,x);
+}
+function Uint16x8SubJS(q,x){
+return %Uint16x8Sub(q,x);
+}
+function Uint16x8MulJS(q,x){
+return %Uint16x8Mul(q,x);
+}
+function Uint16x8MinJS(q,x){
+return %Uint16x8Min(q,x);
+}
+function Uint16x8MaxJS(q,x){
+return %Uint16x8Max(q,x);
+}
+function Uint16x8EqualJS(q,x){
+return %Uint16x8Equal(q,x);
+}
+function Uint16x8NotEqualJS(q,x){
+return %Uint16x8NotEqual(q,x);
+}
+function Uint16x8LessThanJS(q,x){
+return %Uint16x8LessThan(q,x);
+}
+function Uint16x8LessThanOrEqualJS(q,x){
+return %Uint16x8LessThanOrEqual(q,x);
+}
+function Uint16x8GreaterThanJS(q,x){
+return %Uint16x8GreaterThan(q,x);
+}
+function Uint16x8GreaterThanOrEqualJS(q,x){
+return %Uint16x8GreaterThanOrEqual(q,x);
+}
+function Uint16x8LoadJS(A,B){
+return %Uint16x8Load(A,B);
+}
+function Uint16x8StoreJS(A,B,q){
+return %Uint16x8Store(A,B,q);
+}
+
+function Uint8x16ReplaceLaneJS(u,v,r){
+return %Uint8x16ReplaceLane(u,v,(%_ToNumber(r)));
+}
+function Uint8x16SelectJS(z,q,x){
+return %Uint8x16Select(z,q,x);
+}
+function Uint8x16AddJS(q,x){
+return %Uint8x16Add(q,x);
+}
+function Uint8x16SubJS(q,x){
+return %Uint8x16Sub(q,x);
+}
+function Uint8x16MulJS(q,x){
+return %Uint8x16Mul(q,x);
+}
+function Uint8x16MinJS(q,x){
+return %Uint8x16Min(q,x);
+}
+function Uint8x16MaxJS(q,x){
+return %Uint8x16Max(q,x);
+}
+function Uint8x16EqualJS(q,x){
+return %Uint8x16Equal(q,x);
+}
+function Uint8x16NotEqualJS(q,x){
+return %Uint8x16NotEqual(q,x);
+}
+function Uint8x16LessThanJS(q,x){
+return %Uint8x16LessThan(q,x);
+}
+function Uint8x16LessThanOrEqualJS(q,x){
+return %Uint8x16LessThanOrEqual(q,x);
+}
+function Uint8x16GreaterThanJS(q,x){
+return %Uint8x16GreaterThan(q,x);
+}
+function Uint8x16GreaterThanOrEqualJS(q,x){
+return %Uint8x16GreaterThanOrEqual(q,x);
+}
+function Uint8x16LoadJS(A,B){
+return %Uint8x16Load(A,B);
+}
+function Uint8x16StoreJS(A,B,q){
+return %Uint8x16Store(A,B,q);
+}
+
+
+
+function Int32x4AndJS(q,x){
+return %Int32x4And(q,x);
+}
+function Int32x4OrJS(q,x){
+return %Int32x4Or(q,x);
+}
+function Int32x4XorJS(q,x){
+return %Int32x4Xor(q,x);
+}
+function Int32x4NotJS(q){
+return %Int32x4Not(q);
+}
+
+function Int16x8AndJS(q,x){
+return %Int16x8And(q,x);
+}
+function Int16x8OrJS(q,x){
+return %Int16x8Or(q,x);
+}
+function Int16x8XorJS(q,x){
+return %Int16x8Xor(q,x);
+}
+function Int16x8NotJS(q){
+return %Int16x8Not(q);
+}
+
+function Int8x16AndJS(q,x){
+return %Int8x16And(q,x);
+}
+function Int8x16OrJS(q,x){
+return %Int8x16Or(q,x);
+}
+function Int8x16XorJS(q,x){
+return %Int8x16Xor(q,x);
+}
+function Int8x16NotJS(q){
+return %Int8x16Not(q);
+}
+
+
+function Uint32x4AndJS(q,x){
+return %Uint32x4And(q,x);
+}
+function Uint32x4OrJS(q,x){
+return %Uint32x4Or(q,x);
+}
+function Uint32x4XorJS(q,x){
+return %Uint32x4Xor(q,x);
+}
+function Uint32x4NotJS(q){
+return %Uint32x4Not(q);
+}
+
+function Uint16x8AndJS(q,x){
+return %Uint16x8And(q,x);
+}
+function Uint16x8OrJS(q,x){
+return %Uint16x8Or(q,x);
+}
+function Uint16x8XorJS(q,x){
+return %Uint16x8Xor(q,x);
+}
+function Uint16x8NotJS(q){
+return %Uint16x8Not(q);
+}
+
+function Uint8x16AndJS(q,x){
+return %Uint8x16And(q,x);
+}
+function Uint8x16OrJS(q,x){
+return %Uint8x16Or(q,x);
+}
+function Uint8x16XorJS(q,x){
+return %Uint8x16Xor(q,x);
+}
+function Uint8x16NotJS(q){
+return %Uint8x16Not(q);
+}
+
+
+function Bool32x4AndJS(q,x){
+return %Bool32x4And(q,x);
+}
+function Bool32x4OrJS(q,x){
+return %Bool32x4Or(q,x);
+}
+function Bool32x4XorJS(q,x){
+return %Bool32x4Xor(q,x);
+}
+function Bool32x4NotJS(q){
+return %Bool32x4Not(q);
+}
+
+function Bool16x8AndJS(q,x){
+return %Bool16x8And(q,x);
+}
+function Bool16x8OrJS(q,x){
+return %Bool16x8Or(q,x);
+}
+function Bool16x8XorJS(q,x){
+return %Bool16x8Xor(q,x);
+}
+function Bool16x8NotJS(q){
+return %Bool16x8Not(q);
+}
+
+function Bool8x16AndJS(q,x){
+return %Bool8x16And(q,x);
+}
+function Bool8x16OrJS(q,x){
+return %Bool8x16Or(q,x);
+}
+function Bool8x16XorJS(q,x){
+return %Bool8x16Xor(q,x);
+}
+function Bool8x16NotJS(q){
+return %Bool8x16Not(q);
+}
+
+
+
+function Float32x4FromInt32x4JS(q){
+return %Float32x4FromInt32x4(q);
+}
+
+function Float32x4FromUint32x4JS(q){
+return %Float32x4FromUint32x4(q);
+}
+
+function Int32x4FromFloat32x4JS(q){
+return %Int32x4FromFloat32x4(q);
+}
+
+function Int32x4FromUint32x4JS(q){
+return %Int32x4FromUint32x4(q);
+}
+
+function Uint32x4FromFloat32x4JS(q){
+return %Uint32x4FromFloat32x4(q);
+}
+
+function Uint32x4FromInt32x4JS(q){
+return %Uint32x4FromInt32x4(q);
+}
+
+function Int16x8FromUint16x8JS(q){
+return %Int16x8FromUint16x8(q);
+}
+
+function Uint16x8FromInt16x8JS(q){
+return %Uint16x8FromInt16x8(q);
+}
+
+function Int8x16FromUint8x16JS(q){
+return %Int8x16FromUint8x16(q);
+}
+
+function Uint8x16FromInt8x16JS(q){
+return %Uint8x16FromInt8x16(q);
+}
+
+
+function Float32x4FromInt32x4BitsJS(q){
+return %Float32x4FromInt32x4Bits(q);
+}
+
+function Float32x4FromUint32x4BitsJS(q){
+return %Float32x4FromUint32x4Bits(q);
+}
+
+function Float32x4FromInt16x8BitsJS(q){
+return %Float32x4FromInt16x8Bits(q);
+}
+
+function Float32x4FromUint16x8BitsJS(q){
+return %Float32x4FromUint16x8Bits(q);
+}
+
+function Float32x4FromInt8x16BitsJS(q){
+return %Float32x4FromInt8x16Bits(q);
+}
+
+function Float32x4FromUint8x16BitsJS(q){
+return %Float32x4FromUint8x16Bits(q);
+}
+
+function Int32x4FromFloat32x4BitsJS(q){
+return %Int32x4FromFloat32x4Bits(q);
+}
+
+function Int32x4FromUint32x4BitsJS(q){
+return %Int32x4FromUint32x4Bits(q);
+}
+
+function Int32x4FromInt16x8BitsJS(q){
+return %Int32x4FromInt16x8Bits(q);
+}
+
+function Int32x4FromUint16x8BitsJS(q){
+return %Int32x4FromUint16x8Bits(q);
+}
+
+function Int32x4FromInt8x16BitsJS(q){
+return %Int32x4FromInt8x16Bits(q);
+}
+
+function Int32x4FromUint8x16BitsJS(q){
+return %Int32x4FromUint8x16Bits(q);
+}
+
+function Uint32x4FromFloat32x4BitsJS(q){
+return %Uint32x4FromFloat32x4Bits(q);
+}
+
+function Uint32x4FromInt32x4BitsJS(q){
+return %Uint32x4FromInt32x4Bits(q);
+}
+
+function Uint32x4FromInt16x8BitsJS(q){
+return %Uint32x4FromInt16x8Bits(q);
+}
+
+function Uint32x4FromUint16x8BitsJS(q){
+return %Uint32x4FromUint16x8Bits(q);
+}
+
+function Uint32x4FromInt8x16BitsJS(q){
+return %Uint32x4FromInt8x16Bits(q);
+}
+
+function Uint32x4FromUint8x16BitsJS(q){
+return %Uint32x4FromUint8x16Bits(q);
+}
+
+function Int16x8FromFloat32x4BitsJS(q){
+return %Int16x8FromFloat32x4Bits(q);
+}
+
+function Int16x8FromInt32x4BitsJS(q){
+return %Int16x8FromInt32x4Bits(q);
+}
+
+function Int16x8FromUint32x4BitsJS(q){
+return %Int16x8FromUint32x4Bits(q);
+}
+
+function Int16x8FromUint16x8BitsJS(q){
+return %Int16x8FromUint16x8Bits(q);
+}
+
+function Int16x8FromInt8x16BitsJS(q){
+return %Int16x8FromInt8x16Bits(q);
+}
+
+function Int16x8FromUint8x16BitsJS(q){
+return %Int16x8FromUint8x16Bits(q);
+}
+
+function Uint16x8FromFloat32x4BitsJS(q){
+return %Uint16x8FromFloat32x4Bits(q);
+}
+
+function Uint16x8FromInt32x4BitsJS(q){
+return %Uint16x8FromInt32x4Bits(q);
+}
+
+function Uint16x8FromUint32x4BitsJS(q){
+return %Uint16x8FromUint32x4Bits(q);
+}
+
+function Uint16x8FromInt16x8BitsJS(q){
+return %Uint16x8FromInt16x8Bits(q);
+}
+
+function Uint16x8FromInt8x16BitsJS(q){
+return %Uint16x8FromInt8x16Bits(q);
+}
+
+function Uint16x8FromUint8x16BitsJS(q){
+return %Uint16x8FromUint8x16Bits(q);
+}
+
+function Int8x16FromFloat32x4BitsJS(q){
+return %Int8x16FromFloat32x4Bits(q);
+}
+
+function Int8x16FromInt32x4BitsJS(q){
+return %Int8x16FromInt32x4Bits(q);
+}
+
+function Int8x16FromUint32x4BitsJS(q){
+return %Int8x16FromUint32x4Bits(q);
+}
+
+function Int8x16FromInt16x8BitsJS(q){
+return %Int8x16FromInt16x8Bits(q);
+}
+
+function Int8x16FromUint16x8BitsJS(q){
+return %Int8x16FromUint16x8Bits(q);
+}
+
+function Int8x16FromUint8x16BitsJS(q){
+return %Int8x16FromUint8x16Bits(q);
+}
+
+function Uint8x16FromFloat32x4BitsJS(q){
+return %Uint8x16FromFloat32x4Bits(q);
+}
+
+function Uint8x16FromInt32x4BitsJS(q){
+return %Uint8x16FromInt32x4Bits(q);
+}
+
+function Uint8x16FromUint32x4BitsJS(q){
+return %Uint8x16FromUint32x4Bits(q);
+}
+
+function Uint8x16FromInt16x8BitsJS(q){
+return %Uint8x16FromInt16x8Bits(q);
+}
+
+function Uint8x16FromUint16x8BitsJS(q){
+return %Uint8x16FromUint16x8Bits(q);
+}
+
+function Uint8x16FromInt8x16BitsJS(q){
+return %Uint8x16FromInt8x16Bits(q);
+}
+
+
+function Float32x4Load1JS(A,B){
+return %Float32x4Load1(A,B);
+}
+function Float32x4Store1JS(A,B,q){
+return %Float32x4Store1(A,B,q);
+}
+
+function Float32x4Load2JS(A,B){
+return %Float32x4Load2(A,B);
+}
+function Float32x4Store2JS(A,B,q){
+return %Float32x4Store2(A,B,q);
+}
+
+function Float32x4Load3JS(A,B){
+return %Float32x4Load3(A,B);
+}
+function Float32x4Store3JS(A,B,q){
+return %Float32x4Store3(A,B,q);
+}
+
+function Int32x4Load1JS(A,B){
+return %Int32x4Load1(A,B);
+}
+function Int32x4Store1JS(A,B,q){
+return %Int32x4Store1(A,B,q);
+}
+
+function Int32x4Load2JS(A,B){
+return %Int32x4Load2(A,B);
+}
+function Int32x4Store2JS(A,B,q){
+return %Int32x4Store2(A,B,q);
+}
+
+function Int32x4Load3JS(A,B){
+return %Int32x4Load3(A,B);
+}
+function Int32x4Store3JS(A,B,q){
+return %Int32x4Store3(A,B,q);
+}
+
+function Uint32x4Load1JS(A,B){
+return %Uint32x4Load1(A,B);
+}
+function Uint32x4Store1JS(A,B,q){
+return %Uint32x4Store1(A,B,q);
+}
+
+function Uint32x4Load2JS(A,B){
+return %Uint32x4Load2(A,B);
+}
+function Uint32x4Store2JS(A,B,q){
+return %Uint32x4Store2(A,B,q);
+}
+
+function Uint32x4Load3JS(A,B){
+return %Uint32x4Load3(A,B);
+}
+function Uint32x4Store3JS(A,B,q){
+return %Uint32x4Store3(A,B,q);
+}
+
+
+function Float32x4Splat(y){
+return %CreateFloat32x4(y,y,y,y);
+}
+function Float32x4SwizzleJS(q,C,D,E,F){
+return %Float32x4Swizzle(q,C,D,E,F);
+}
+function Float32x4ShuffleJS(q,x,C,D,E,F){
+return %Float32x4Shuffle(q,x,C,D,E,F);
+}
+
+function Int32x4Splat(y){
+return %CreateInt32x4(y,y,y,y);
+}
+function Int32x4SwizzleJS(q,C,D,E,F){
+return %Int32x4Swizzle(q,C,D,E,F);
+}
+function Int32x4ShuffleJS(q,x,C,D,E,F){
+return %Int32x4Shuffle(q,x,C,D,E,F);
+}
+
+function Uint32x4Splat(y){
+return %CreateUint32x4(y,y,y,y);
+}
+function Uint32x4SwizzleJS(q,C,D,E,F){
+return %Uint32x4Swizzle(q,C,D,E,F);
+}
+function Uint32x4ShuffleJS(q,x,C,D,E,F){
+return %Uint32x4Shuffle(q,x,C,D,E,F);
+}
+
+function Bool32x4Splat(y){
+return %CreateBool32x4(y,y,y,y);
+}
+function Bool32x4SwizzleJS(q,C,D,E,F){
+return %Bool32x4Swizzle(q,C,D,E,F);
+}
+function Bool32x4ShuffleJS(q,x,C,D,E,F){
+return %Bool32x4Shuffle(q,x,C,D,E,F);
+}
+
+
+function Int16x8Splat(y){
+return %CreateInt16x8(y,y,y,y,y,y,y,y);
+}
+function Int16x8SwizzleJS(q,C,D,E,F,G,H,I,J){
+return %Int16x8Swizzle(q,C,D,E,F,G,H,I,J);
+}
+function Int16x8ShuffleJS(q,x,C,D,E,F,G,H,I,J){
+return %Int16x8Shuffle(q,x,C,D,E,F,G,H,I,J);
+}
+
+function Uint16x8Splat(y){
+return %CreateUint16x8(y,y,y,y,y,y,y,y);
+}
+function Uint16x8SwizzleJS(q,C,D,E,F,G,H,I,J){
+return %Uint16x8Swizzle(q,C,D,E,F,G,H,I,J);
+}
+function Uint16x8ShuffleJS(q,x,C,D,E,F,G,H,I,J){
+return %Uint16x8Shuffle(q,x,C,D,E,F,G,H,I,J);
+}
+
+function Bool16x8Splat(y){
+return %CreateBool16x8(y,y,y,y,y,y,y,y);
+}
+function Bool16x8SwizzleJS(q,C,D,E,F,G,H,I,J){
+return %Bool16x8Swizzle(q,C,D,E,F,G,H,I,J);
+}
+function Bool16x8ShuffleJS(q,x,C,D,E,F,G,H,I,J){
+return %Bool16x8Shuffle(q,x,C,D,E,F,G,H,I,J);
+}
+
+
+function Int8x16Splat(y){
+return %CreateInt8x16(y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y);
+}
+function Int8x16SwizzleJS(q,C,D,E,F,G,H,I,J,c8,c9,c10,c11,
+c12,c13,c14,c15){
+return %Int8x16Swizzle(q,C,D,E,F,G,H,I,J,c8,c9,c10,c11,
+c12,c13,c14,c15);
+}
+function Int8x16ShuffleJS(q,x,C,D,E,F,G,H,I,J,c8,c9,c10,
+c11,c12,c13,c14,c15){
+return %Int8x16Shuffle(q,x,C,D,E,F,G,H,I,J,c8,c9,c10,
+c11,c12,c13,c14,c15);
+}
+
+function Uint8x16Splat(y){
+return %CreateUint8x16(y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y);
+}
+function Uint8x16SwizzleJS(q,C,D,E,F,G,H,I,J,c8,c9,c10,c11,
+c12,c13,c14,c15){
+return %Uint8x16Swizzle(q,C,D,E,F,G,H,I,J,c8,c9,c10,c11,
+c12,c13,c14,c15);
+}
+function Uint8x16ShuffleJS(q,x,C,D,E,F,G,H,I,J,c8,c9,c10,
+c11,c12,c13,c14,c15){
+return %Uint8x16Shuffle(q,x,C,D,E,F,G,H,I,J,c8,c9,c10,
+c11,c12,c13,c14,c15);
+}
+
+function Bool8x16Splat(y){
+return %CreateBool8x16(y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y);
+}
+function Bool8x16SwizzleJS(q,C,D,E,F,G,H,I,J,c8,c9,c10,c11,
+c12,c13,c14,c15){
+return %Bool8x16Swizzle(q,C,D,E,F,G,H,I,J,c8,c9,c10,c11,
+c12,c13,c14,c15);
+}
+function Bool8x16ShuffleJS(q,x,C,D,E,F,G,H,I,J,c8,c9,c10,
+c11,c12,c13,c14,c15){
+return %Bool8x16Shuffle(q,x,C,D,E,F,G,H,I,J,c8,c9,c10,
+c11,c12,c13,c14,c15);
+}
+
+
+function Float32x4Constructor(C,D,E,F){
+if(!(new.target===(void 0))){
+throw d(62,"Float32x4");
+}
+return %CreateFloat32x4((%_ToNumber(C)),(%_ToNumber(D)),
+(%_ToNumber(E)),(%_ToNumber(F)));
+}
+function Int32x4Constructor(C,D,E,F){
+if(!(new.target===(void 0))){
+throw d(62,"Int32x4");
+}
+return %CreateInt32x4((%_ToNumber(C)),(%_ToNumber(D)),
+(%_ToNumber(E)),(%_ToNumber(F)));
+}
+function Uint32x4Constructor(C,D,E,F){
+if(!(new.target===(void 0))){
+throw d(62,"Uint32x4");
+}
+return %CreateUint32x4((%_ToNumber(C)),(%_ToNumber(D)),
+(%_ToNumber(E)),(%_ToNumber(F)));
+}
+function Bool32x4Constructor(C,D,E,F){
+if(!(new.target===(void 0))){
+throw d(62,"Bool32x4");
+}
+return %CreateBool32x4(C,D,E,F);
+}
+function Int16x8Constructor(C,D,E,F,G,H,I,J){
+if(!(new.target===(void 0))){
+throw d(62,"Int16x8");
+}
+return %CreateInt16x8((%_ToNumber(C)),(%_ToNumber(D)),
+(%_ToNumber(E)),(%_ToNumber(F)),
+(%_ToNumber(G)),(%_ToNumber(H)),
+(%_ToNumber(I)),(%_ToNumber(J)));
+}
+function Uint16x8Constructor(C,D,E,F,G,H,I,J){
+if(!(new.target===(void 0))){
+throw d(62,"Uint16x8");
+}
+return %CreateUint16x8((%_ToNumber(C)),(%_ToNumber(D)),
+(%_ToNumber(E)),(%_ToNumber(F)),
+(%_ToNumber(G)),(%_ToNumber(H)),
+(%_ToNumber(I)),(%_ToNumber(J)));
+}
+function Bool16x8Constructor(C,D,E,F,G,H,I,J){
+if(!(new.target===(void 0))){
+throw d(62,"Bool16x8");
+}
+return %CreateBool16x8(C,D,E,F,G,H,I,J);
+}
+function Int8x16Constructor(C,D,E,F,G,H,I,J,c8,c9,c10,c11,
+c12,c13,c14,c15){
+if(!(new.target===(void 0))){
+throw d(62,"Int8x16");
+}
+return %CreateInt8x16((%_ToNumber(C)),(%_ToNumber(D)),
+(%_ToNumber(E)),(%_ToNumber(F)),
+(%_ToNumber(G)),(%_ToNumber(H)),
+(%_ToNumber(I)),(%_ToNumber(J)),
+(%_ToNumber(c8)),(%_ToNumber(c9)),
+(%_ToNumber(c10)),(%_ToNumber(c11)),
+(%_ToNumber(c12)),(%_ToNumber(c13)),
+(%_ToNumber(c14)),(%_ToNumber(c15)));
+}
+function Uint8x16Constructor(C,D,E,F,G,H,I,J,c8,c9,c10,c11,
+c12,c13,c14,c15){
+if(!(new.target===(void 0))){
+throw d(62,"Uint8x16");
+}
+return %CreateUint8x16((%_ToNumber(C)),(%_ToNumber(D)),
+(%_ToNumber(E)),(%_ToNumber(F)),
+(%_ToNumber(G)),(%_ToNumber(H)),
+(%_ToNumber(I)),(%_ToNumber(J)),
+(%_ToNumber(c8)),(%_ToNumber(c9)),
+(%_ToNumber(c10)),(%_ToNumber(c11)),
+(%_ToNumber(c12)),(%_ToNumber(c13)),
+(%_ToNumber(c14)),(%_ToNumber(c15)));
+}
+function Bool8x16Constructor(C,D,E,F,G,H,I,J,c8,c9,c10,c11,
+c12,c13,c14,c15){
+if(!(new.target===(void 0))){
+throw d(62,"Bool8x16");
+}
+return %CreateBool8x16(C,D,E,F,G,H,I,J,c8,c9,c10,c11,c12,
+c13,c14,c15);
+}
+function Float32x4AbsJS(q){
+return %Float32x4Abs(q);
+}
+function Float32x4SqrtJS(q){
+return %Float32x4Sqrt(q);
+}
+function Float32x4RecipApproxJS(q){
+return %Float32x4RecipApprox(q);
+}
+function Float32x4RecipSqrtApproxJS(q){
+return %Float32x4RecipSqrtApprox(q);
+}
+function Float32x4DivJS(q,x){
+return %Float32x4Div(q,x);
+}
+function Float32x4MinNumJS(q,x){
+return %Float32x4MinNum(q,x);
+}
+function Float32x4MaxNumJS(q,x){
+return %Float32x4MaxNum(q,x);
+}
+%AddNamedProperty(c,e,'SIMD',1|2);
+%SetCode(g,Float32x4Constructor);
+%FunctionSetPrototype(g,{});
+%AddNamedProperty(g.prototype,'constructor',g,
+2);
+%AddNamedProperty(g.prototype,e,'Float32x4',
+2|1);
+b.InstallFunctions(g.prototype,2,[
+'toLocaleString',Float32x4ToLocaleString,
+'toString',Float32x4ToString,
+'valueOf',Float32x4ValueOf,
+]);
+
+
+%SetCode(h,Int32x4Constructor);
+%FunctionSetPrototype(h,{});
+%AddNamedProperty(h.prototype,'constructor',h,
+2);
+%AddNamedProperty(h.prototype,e,'Int32x4',
+2|1);
+b.InstallFunctions(h.prototype,2,[
+'toLocaleString',Int32x4ToLocaleString,
+'toString',Int32x4ToString,
+'valueOf',Int32x4ValueOf,
+]);
+
+%SetCode(i,Int16x8Constructor);
+%FunctionSetPrototype(i,{});
+%AddNamedProperty(i.prototype,'constructor',i,
+2);
+%AddNamedProperty(i.prototype,e,'Int16x8',
+2|1);
+b.InstallFunctions(i.prototype,2,[
+'toLocaleString',Int16x8ToLocaleString,
+'toString',Int16x8ToString,
+'valueOf',Int16x8ValueOf,
+]);
+
+%SetCode(j,Int8x16Constructor);
+%FunctionSetPrototype(j,{});
+%AddNamedProperty(j.prototype,'constructor',j,
+2);
+%AddNamedProperty(j.prototype,e,'Int8x16',
+2|1);
+b.InstallFunctions(j.prototype,2,[
+'toLocaleString',Int8x16ToLocaleString,
+'toString',Int8x16ToString,
+'valueOf',Int8x16ValueOf,
+]);
+
+
+%SetCode(k,Uint32x4Constructor);
+%FunctionSetPrototype(k,{});
+%AddNamedProperty(k.prototype,'constructor',k,
+2);
+%AddNamedProperty(k.prototype,e,'Uint32x4',
+2|1);
+b.InstallFunctions(k.prototype,2,[
+'toLocaleString',Uint32x4ToLocaleString,
+'toString',Uint32x4ToString,
+'valueOf',Uint32x4ValueOf,
+]);
+
+%SetCode(l,Uint16x8Constructor);
+%FunctionSetPrototype(l,{});
+%AddNamedProperty(l.prototype,'constructor',l,
+2);
+%AddNamedProperty(l.prototype,e,'Uint16x8',
+2|1);
+b.InstallFunctions(l.prototype,2,[
+'toLocaleString',Uint16x8ToLocaleString,
+'toString',Uint16x8ToString,
+'valueOf',Uint16x8ValueOf,
+]);
+
+%SetCode(m,Uint8x16Constructor);
+%FunctionSetPrototype(m,{});
+%AddNamedProperty(m.prototype,'constructor',m,
+2);
+%AddNamedProperty(m.prototype,e,'Uint8x16',
+2|1);
+b.InstallFunctions(m.prototype,2,[
+'toLocaleString',Uint8x16ToLocaleString,
+'toString',Uint8x16ToString,
+'valueOf',Uint8x16ValueOf,
+]);
+
+
+%SetCode(n,Bool32x4Constructor);
+%FunctionSetPrototype(n,{});
+%AddNamedProperty(n.prototype,'constructor',n,
+2);
+%AddNamedProperty(n.prototype,e,'Bool32x4',
+2|1);
+b.InstallFunctions(n.prototype,2,[
+'toLocaleString',Bool32x4ToLocaleString,
+'toString',Bool32x4ToString,
+'valueOf',Bool32x4ValueOf,
+]);
+
+%SetCode(o,Bool16x8Constructor);
+%FunctionSetPrototype(o,{});
+%AddNamedProperty(o.prototype,'constructor',o,
+2);
+%AddNamedProperty(o.prototype,e,'Bool16x8',
+2|1);
+b.InstallFunctions(o.prototype,2,[
+'toLocaleString',Bool16x8ToLocaleString,
+'toString',Bool16x8ToString,
+'valueOf',Bool16x8ValueOf,
+]);
+
+%SetCode(p,Bool8x16Constructor);
+%FunctionSetPrototype(p,{});
+%AddNamedProperty(p.prototype,'constructor',p,
+2);
+%AddNamedProperty(p.prototype,e,'Bool8x16',
+2|1);
+b.InstallFunctions(p.prototype,2,[
+'toLocaleString',Bool8x16ToLocaleString,
+'toString',Bool8x16ToString,
+'valueOf',Bool8x16ValueOf,
+]);
+
+
+
+b.InstallFunctions(g,2,[
+'splat',Float32x4Splat,
+'check',Float32x4CheckJS,
+'extractLane',Float32x4ExtractLaneJS,
+'replaceLane',Float32x4ReplaceLaneJS,
+'neg',Float32x4NegJS,
+'abs',Float32x4AbsJS,
+'sqrt',Float32x4SqrtJS,
+'reciprocalApproximation',Float32x4RecipApproxJS,
+'reciprocalSqrtApproximation',Float32x4RecipSqrtApproxJS,
+'add',Float32x4AddJS,
+'sub',Float32x4SubJS,
+'mul',Float32x4MulJS,
+'div',Float32x4DivJS,
+'min',Float32x4MinJS,
+'max',Float32x4MaxJS,
+'minNum',Float32x4MinNumJS,
+'maxNum',Float32x4MaxNumJS,
+'lessThan',Float32x4LessThanJS,
+'lessThanOrEqual',Float32x4LessThanOrEqualJS,
+'greaterThan',Float32x4GreaterThanJS,
+'greaterThanOrEqual',Float32x4GreaterThanOrEqualJS,
+'equal',Float32x4EqualJS,
+'notEqual',Float32x4NotEqualJS,
+'select',Float32x4SelectJS,
+'swizzle',Float32x4SwizzleJS,
+'shuffle',Float32x4ShuffleJS,
+'fromInt32x4',Float32x4FromInt32x4JS,
+'fromUint32x4',Float32x4FromUint32x4JS,
+'fromInt32x4Bits',Float32x4FromInt32x4BitsJS,
+'fromUint32x4Bits',Float32x4FromUint32x4BitsJS,
+'fromInt16x8Bits',Float32x4FromInt16x8BitsJS,
+'fromUint16x8Bits',Float32x4FromUint16x8BitsJS,
+'fromInt8x16Bits',Float32x4FromInt8x16BitsJS,
+'fromUint8x16Bits',Float32x4FromUint8x16BitsJS,
+'load',Float32x4LoadJS,
+'load1',Float32x4Load1JS,
+'load2',Float32x4Load2JS,
+'load3',Float32x4Load3JS,
+'store',Float32x4StoreJS,
+'store1',Float32x4Store1JS,
+'store2',Float32x4Store2JS,
+'store3',Float32x4Store3JS,
+]);
+b.InstallFunctions(h,2,[
+'splat',Int32x4Splat,
+'check',Int32x4CheckJS,
+'extractLane',Int32x4ExtractLaneJS,
+'replaceLane',Int32x4ReplaceLaneJS,
+'neg',Int32x4NegJS,
+'add',Int32x4AddJS,
+'sub',Int32x4SubJS,
+'mul',Int32x4MulJS,
+'min',Int32x4MinJS,
+'max',Int32x4MaxJS,
+'and',Int32x4AndJS,
+'or',Int32x4OrJS,
+'xor',Int32x4XorJS,
+'not',Int32x4NotJS,
+'shiftLeftByScalar',Int32x4ShiftLeftByScalarJS,
+'shiftRightByScalar',Int32x4ShiftRightByScalarJS,
+'lessThan',Int32x4LessThanJS,
+'lessThanOrEqual',Int32x4LessThanOrEqualJS,
+'greaterThan',Int32x4GreaterThanJS,
+'greaterThanOrEqual',Int32x4GreaterThanOrEqualJS,
+'equal',Int32x4EqualJS,
+'notEqual',Int32x4NotEqualJS,
+'select',Int32x4SelectJS,
+'swizzle',Int32x4SwizzleJS,
+'shuffle',Int32x4ShuffleJS,
+'fromFloat32x4',Int32x4FromFloat32x4JS,
+'fromUint32x4',Int32x4FromUint32x4JS,
+'fromFloat32x4Bits',Int32x4FromFloat32x4BitsJS,
+'fromUint32x4Bits',Int32x4FromUint32x4BitsJS,
+'fromInt16x8Bits',Int32x4FromInt16x8BitsJS,
+'fromUint16x8Bits',Int32x4FromUint16x8BitsJS,
+'fromInt8x16Bits',Int32x4FromInt8x16BitsJS,
+'fromUint8x16Bits',Int32x4FromUint8x16BitsJS,
+'load',Int32x4LoadJS,
+'load1',Int32x4Load1JS,
+'load2',Int32x4Load2JS,
+'load3',Int32x4Load3JS,
+'store',Int32x4StoreJS,
+'store1',Int32x4Store1JS,
+'store2',Int32x4Store2JS,
+'store3',Int32x4Store3JS,
+]);
+b.InstallFunctions(k,2,[
+'splat',Uint32x4Splat,
+'check',Uint32x4CheckJS,
+'extractLane',Uint32x4ExtractLaneJS,
+'replaceLane',Uint32x4ReplaceLaneJS,
+'add',Uint32x4AddJS,
+'sub',Uint32x4SubJS,
+'mul',Uint32x4MulJS,
+'min',Uint32x4MinJS,
+'max',Uint32x4MaxJS,
+'and',Uint32x4AndJS,
+'or',Uint32x4OrJS,
+'xor',Uint32x4XorJS,
+'not',Uint32x4NotJS,
+'shiftLeftByScalar',Uint32x4ShiftLeftByScalarJS,
+'shiftRightByScalar',Uint32x4ShiftRightByScalarJS,
+'lessThan',Uint32x4LessThanJS,
+'lessThanOrEqual',Uint32x4LessThanOrEqualJS,
+'greaterThan',Uint32x4GreaterThanJS,
+'greaterThanOrEqual',Uint32x4GreaterThanOrEqualJS,
+'equal',Uint32x4EqualJS,
+'notEqual',Uint32x4NotEqualJS,
+'select',Uint32x4SelectJS,
+'swizzle',Uint32x4SwizzleJS,
+'shuffle',Uint32x4ShuffleJS,
+'fromFloat32x4',Uint32x4FromFloat32x4JS,
+'fromInt32x4',Uint32x4FromInt32x4JS,
+'fromFloat32x4Bits',Uint32x4FromFloat32x4BitsJS,
+'fromInt32x4Bits',Uint32x4FromInt32x4BitsJS,
+'fromInt16x8Bits',Uint32x4FromInt16x8BitsJS,
+'fromUint16x8Bits',Uint32x4FromUint16x8BitsJS,
+'fromInt8x16Bits',Uint32x4FromInt8x16BitsJS,
+'fromUint8x16Bits',Uint32x4FromUint8x16BitsJS,
+'load',Uint32x4LoadJS,
+'load1',Uint32x4Load1JS,
+'load2',Uint32x4Load2JS,
+'load3',Uint32x4Load3JS,
+'store',Uint32x4StoreJS,
+'store1',Uint32x4Store1JS,
+'store2',Uint32x4Store2JS,
+'store3',Uint32x4Store3JS,
+]);
+b.InstallFunctions(n,2,[
+'splat',Bool32x4Splat,
+'check',Bool32x4CheckJS,
+'extractLane',Bool32x4ExtractLaneJS,
+'replaceLane',Bool32x4ReplaceLaneJS,
+'and',Bool32x4AndJS,
+'or',Bool32x4OrJS,
+'xor',Bool32x4XorJS,
+'not',Bool32x4NotJS,
+'anyTrue',Bool32x4AnyTrueJS,
+'allTrue',Bool32x4AllTrueJS,
+'swizzle',Bool32x4SwizzleJS,
+'shuffle',Bool32x4ShuffleJS,
+]);
+b.InstallFunctions(i,2,[
+'splat',Int16x8Splat,
+'check',Int16x8CheckJS,
+'extractLane',Int16x8ExtractLaneJS,
+'replaceLane',Int16x8ReplaceLaneJS,
+'neg',Int16x8NegJS,
+'add',Int16x8AddJS,
+'sub',Int16x8SubJS,
+'addSaturate',Int16x8AddSaturateJS,
+'subSaturate',Int16x8SubSaturateJS,
+'mul',Int16x8MulJS,
+'min',Int16x8MinJS,
+'max',Int16x8MaxJS,
+'and',Int16x8AndJS,
+'or',Int16x8OrJS,
+'xor',Int16x8XorJS,
+'not',Int16x8NotJS,
+'shiftLeftByScalar',Int16x8ShiftLeftByScalarJS,
+'shiftRightByScalar',Int16x8ShiftRightByScalarJS,
+'lessThan',Int16x8LessThanJS,
+'lessThanOrEqual',Int16x8LessThanOrEqualJS,
+'greaterThan',Int16x8GreaterThanJS,
+'greaterThanOrEqual',Int16x8GreaterThanOrEqualJS,
+'equal',Int16x8EqualJS,
+'notEqual',Int16x8NotEqualJS,
+'select',Int16x8SelectJS,
+'swizzle',Int16x8SwizzleJS,
+'shuffle',Int16x8ShuffleJS,
+'fromUint16x8',Int16x8FromUint16x8JS,
+'fromFloat32x4Bits',Int16x8FromFloat32x4BitsJS,
+'fromInt32x4Bits',Int16x8FromInt32x4BitsJS,
+'fromUint32x4Bits',Int16x8FromUint32x4BitsJS,
+'fromUint16x8Bits',Int16x8FromUint16x8BitsJS,
+'fromInt8x16Bits',Int16x8FromInt8x16BitsJS,
+'fromUint8x16Bits',Int16x8FromUint8x16BitsJS,
+'load',Int16x8LoadJS,
+'store',Int16x8StoreJS,
+]);
+b.InstallFunctions(l,2,[
+'splat',Uint16x8Splat,
+'check',Uint16x8CheckJS,
+'extractLane',Uint16x8ExtractLaneJS,
+'replaceLane',Uint16x8ReplaceLaneJS,
+'add',Uint16x8AddJS,
+'sub',Uint16x8SubJS,
+'addSaturate',Uint16x8AddSaturateJS,
+'subSaturate',Uint16x8SubSaturateJS,
+'mul',Uint16x8MulJS,
+'min',Uint16x8MinJS,
+'max',Uint16x8MaxJS,
+'and',Uint16x8AndJS,
+'or',Uint16x8OrJS,
+'xor',Uint16x8XorJS,
+'not',Uint16x8NotJS,
+'shiftLeftByScalar',Uint16x8ShiftLeftByScalarJS,
+'shiftRightByScalar',Uint16x8ShiftRightByScalarJS,
+'lessThan',Uint16x8LessThanJS,
+'lessThanOrEqual',Uint16x8LessThanOrEqualJS,
+'greaterThan',Uint16x8GreaterThanJS,
+'greaterThanOrEqual',Uint16x8GreaterThanOrEqualJS,
+'equal',Uint16x8EqualJS,
+'notEqual',Uint16x8NotEqualJS,
+'select',Uint16x8SelectJS,
+'swizzle',Uint16x8SwizzleJS,
+'shuffle',Uint16x8ShuffleJS,
+'fromInt16x8',Uint16x8FromInt16x8JS,
+'fromFloat32x4Bits',Uint16x8FromFloat32x4BitsJS,
+'fromInt32x4Bits',Uint16x8FromInt32x4BitsJS,
+'fromUint32x4Bits',Uint16x8FromUint32x4BitsJS,
+'fromInt16x8Bits',Uint16x8FromInt16x8BitsJS,
+'fromInt8x16Bits',Uint16x8FromInt8x16BitsJS,
+'fromUint8x16Bits',Uint16x8FromUint8x16BitsJS,
+'load',Uint16x8LoadJS,
+'store',Uint16x8StoreJS,
+]);
+b.InstallFunctions(o,2,[
+'splat',Bool16x8Splat,
+'check',Bool16x8CheckJS,
+'extractLane',Bool16x8ExtractLaneJS,
+'replaceLane',Bool16x8ReplaceLaneJS,
+'and',Bool16x8AndJS,
+'or',Bool16x8OrJS,
+'xor',Bool16x8XorJS,
+'not',Bool16x8NotJS,
+'anyTrue',Bool16x8AnyTrueJS,
+'allTrue',Bool16x8AllTrueJS,
+'swizzle',Bool16x8SwizzleJS,
+'shuffle',Bool16x8ShuffleJS,
+]);
+b.InstallFunctions(j,2,[
+'splat',Int8x16Splat,
+'check',Int8x16CheckJS,
+'extractLane',Int8x16ExtractLaneJS,
+'replaceLane',Int8x16ReplaceLaneJS,
+'neg',Int8x16NegJS,
+'add',Int8x16AddJS,
+'sub',Int8x16SubJS,
+'addSaturate',Int8x16AddSaturateJS,
+'subSaturate',Int8x16SubSaturateJS,
+'mul',Int8x16MulJS,
+'min',Int8x16MinJS,
+'max',Int8x16MaxJS,
+'and',Int8x16AndJS,
+'or',Int8x16OrJS,
+'xor',Int8x16XorJS,
+'not',Int8x16NotJS,
+'shiftLeftByScalar',Int8x16ShiftLeftByScalarJS,
+'shiftRightByScalar',Int8x16ShiftRightByScalarJS,
+'lessThan',Int8x16LessThanJS,
+'lessThanOrEqual',Int8x16LessThanOrEqualJS,
+'greaterThan',Int8x16GreaterThanJS,
+'greaterThanOrEqual',Int8x16GreaterThanOrEqualJS,
+'equal',Int8x16EqualJS,
+'notEqual',Int8x16NotEqualJS,
+'select',Int8x16SelectJS,
+'swizzle',Int8x16SwizzleJS,
+'shuffle',Int8x16ShuffleJS,
+'fromUint8x16',Int8x16FromUint8x16JS,
+'fromFloat32x4Bits',Int8x16FromFloat32x4BitsJS,
+'fromInt32x4Bits',Int8x16FromInt32x4BitsJS,
+'fromUint32x4Bits',Int8x16FromUint32x4BitsJS,
+'fromInt16x8Bits',Int8x16FromInt16x8BitsJS,
+'fromUint16x8Bits',Int8x16FromUint16x8BitsJS,
+'fromUint8x16Bits',Int8x16FromUint8x16BitsJS,
+'load',Int8x16LoadJS,
+'store',Int8x16StoreJS,
+]);
+b.InstallFunctions(m,2,[
+'splat',Uint8x16Splat,
+'check',Uint8x16CheckJS,
+'extractLane',Uint8x16ExtractLaneJS,
+'replaceLane',Uint8x16ReplaceLaneJS,
+'add',Uint8x16AddJS,
+'sub',Uint8x16SubJS,
+'addSaturate',Uint8x16AddSaturateJS,
+'subSaturate',Uint8x16SubSaturateJS,
+'mul',Uint8x16MulJS,
+'min',Uint8x16MinJS,
+'max',Uint8x16MaxJS,
+'and',Uint8x16AndJS,
+'or',Uint8x16OrJS,
+'xor',Uint8x16XorJS,
+'not',Uint8x16NotJS,
+'shiftLeftByScalar',Uint8x16ShiftLeftByScalarJS,
+'shiftRightByScalar',Uint8x16ShiftRightByScalarJS,
+'lessThan',Uint8x16LessThanJS,
+'lessThanOrEqual',Uint8x16LessThanOrEqualJS,
+'greaterThan',Uint8x16GreaterThanJS,
+'greaterThanOrEqual',Uint8x16GreaterThanOrEqualJS,
+'equal',Uint8x16EqualJS,
+'notEqual',Uint8x16NotEqualJS,
+'select',Uint8x16SelectJS,
+'swizzle',Uint8x16SwizzleJS,
+'shuffle',Uint8x16ShuffleJS,
+'fromInt8x16',Uint8x16FromInt8x16JS,
+'fromFloat32x4Bits',Uint8x16FromFloat32x4BitsJS,
+'fromInt32x4Bits',Uint8x16FromInt32x4BitsJS,
+'fromUint32x4Bits',Uint8x16FromUint32x4BitsJS,
+'fromInt16x8Bits',Uint8x16FromInt16x8BitsJS,
+'fromUint16x8Bits',Uint8x16FromUint16x8BitsJS,
+'fromInt8x16Bits',Uint8x16FromInt8x16BitsJS,
+'load',Uint8x16LoadJS,
+'store',Uint8x16StoreJS,
+]);
+b.InstallFunctions(p,2,[
+'splat',Bool8x16Splat,
+'check',Bool8x16CheckJS,
+'extractLane',Bool8x16ExtractLaneJS,
+'replaceLane',Bool8x16ReplaceLaneJS,
+'and',Bool8x16AndJS,
+'or',Bool8x16OrJS,
+'xor',Bool8x16XorJS,
+'not',Bool8x16NotJS,
+'anyTrue',Bool8x16AnyTrueJS,
+'allTrue',Bool8x16AllTrueJS,
+'swizzle',Bool8x16SwizzleJS,
+'shuffle',Bool8x16ShuffleJS,
+]);
+b.Export(function(K){
+K.Float32x4ToString=Float32x4ToString;
+K.Int32x4ToString=Int32x4ToString;
+K.Uint32x4ToString=Uint32x4ToString;
+K.Bool32x4ToString=Bool32x4ToString;
+K.Int16x8ToString=Int16x8ToString;
+K.Uint16x8ToString=Uint16x8ToString;
+K.Bool16x8ToString=Bool16x8ToString;
+K.Int8x16ToString=Int8x16ToString;
+K.Uint8x16ToString=Uint8x16ToString;
+K.Bool8x16ToString=Bool8x16ToString;
+});
+})
+
+<harmony-speciesE
+(function(a,b,c){
+"use strict";
+%CheckIsBootstrapping();
+var d=a.Array;
+var e=a.Uint8Array.__proto__;
+var f=a.Map;
+var g=a.Set;
+var h=a.ArrayBuffer;
+var i=a.Promise;
+var j=a.RegExp;
+var k=b.ImportNow("species_symbol");
+function ArraySpecies(){
+return this;
+}
+function TypedArraySpecies(){
+return this;
+}
+function MapSpecies(){
+return this;
+}
+function SetSpecies(){
+return this;
+}
+function ArrayBufferSpecies(){
+return this;
+}
+function PromiseSpecies(){
+return this;
+}
+function RegExpSpecies(){
+return this;
+}
+b.InstallGetter(d,k,ArraySpecies,2);
+b.InstallGetter(e,k,TypedArraySpecies,2);
+b.InstallGetter(f,k,MapSpecies,2);
+b.InstallGetter(g,k,SetSpecies,2);
+b.InstallGetter(h,k,ArrayBufferSpecies,
+2);
+b.InstallGetter(i,k,PromiseSpecies,2);
+b.InstallGetter(j,k,RegExpSpecies,2);
+});
+
+\harmony-unicode-regexps�
+(function(a,b){
+'use strict';
+%CheckIsBootstrapping();
+var c=a.RegExp;
+var d=c.prototype;
+var e;
+b.Import(function(f){
+e=f.MakeTypeError;
+});
+function RegExpGetUnicode(){
+if(!(%_IsRegExp(this))){
+if(this===d){
+%IncrementUseCounter(13);
+return(void 0);
+}
+throw e(131,"RegExp.prototype.unicode");
+}
+return!!(%_RegExpFlags(this)&16);
+}
+%FunctionSetName(RegExpGetUnicode,"RegExp.prototype.unicode");
+%SetNativeFlag(RegExpGetUnicode);
+b.InstallGetter(c.prototype,'unicode',RegExpGetUnicode);
+})
+
+4promise-extra�
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Promise;
+var d=b.ImportNow("PromiseChain");
+var e=b.ImportNow("PromiseDeferred");
+var f=b.ImportNow("PromiseResolved");
+b.InstallFunctions(c.prototype,2,[
+"chain",d,
+]);
+b.InstallFunctions(c,2,[
+"defer",e,
+"accept",f,
+]);
+})
+
+XReadableStreamTempStubm
+(function(global, binding, v8) {
+  'use strict';
+  const TypeError = global.TypeError;
+  const defineProperty = global.Object.defineProperty;
+  class ReadableStream {
+    constructor() {
+      throw new TypeError('Illegal constructor');
+    }
+    getReader() {
+      throw new TypeError('Illegal invocation');
+    }
+    cancel() {
+      throw new TypeError('Illegal invocation');
+    }
+  }
+  defineProperty(global, 'ReadableStream', {
+    value: ReadableStream,
+    enumerable: false,
+    configurable: true,
+    writable: true
+  });
+});
+dByteLengthQueuingStrategy�
+(function(global, binding, v8) {
+  'use strict';
+  const defineProperty = global.Object.defineProperty;
+  class ByteLengthQueuingStrategy {
+    constructor(options) {
+      defineProperty(this, 'highWaterMark', {
+        value: options.highWaterMark,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    }
+    size(chunk) { return chunk.byteLength; }
+  }
+  defineProperty(global, 'ByteLengthQueuingStrategy', {
+    value: ByteLengthQueuingStrategy,
+    enumerable: false,
+    configurable: true,
+    writable: true
+  });
+});
+PCountQueuingStrategyY
+(function(global, binding, v8) {
+  'use strict';
+  const defineProperty = global.Object.defineProperty;
+  class CountQueuingStrategy {
+    constructor(options) {
+      defineProperty(this, 'highWaterMark', {
+        value: options.highWaterMark,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    }
+    size(chunk) { return 1; }
+  }
+  defineProperty(global, 'CountQueuingStrategy', {
+    value: CountQueuingStrategy,
+    enumerable: false,
+    configurable: true,
+    writable: true
+  });
+});
+8ReadableStreamVg

+(function(global, binding, v8) {
+  'use strict';
+  const readableStreamController = v8.createPrivateSymbol('[[controller]]');
+  const readableStreamQueue = v8.createPrivateSymbol('[[queue]]');
+  const readableStreamQueueSize =
+      v8.createPrivateSymbol('[[queue]] total size');
+  const readableStreamReader = v8.createPrivateSymbol('[[reader]]');
+  const readableStreamState = v8.createPrivateSymbol('[[state]]');
+  const readableStreamStoredError = v8.createPrivateSymbol('[[storedError]]');
+  const readableStreamStrategySize = v8.createPrivateSymbol('[[strategySize]]');
+  const readableStreamStrategyHWM = v8.createPrivateSymbol('[[strategyHWM]]');
+  const readableStreamUnderlyingSource =
+      v8.createPrivateSymbol('[[underlyingSource]]');
+  const readableStreamControllerControlledReadableStream =
+      v8.createPrivateSymbol('[[controlledReadableStream]]');
+  const readableStreamReaderClosedPromise =
+      v8.createPrivateSymbol('[[closedPromise]]');
+  const readableStreamReaderOwnerReadableStream =
+      v8.createPrivateSymbol('[[ownerReadableStream]]');
+  const readableStreamReaderReadRequests =
+      v8.createPrivateSymbol('[[readRequests]]');
+  const STATE_READABLE = 0;
+  const STATE_CLOSED = 1;
+  const STATE_ERRORED = 2;
+  const readableStreamBits = v8.createPrivateSymbol(
+      'bit field for [[started]], [[closeRequested]], [[pulling]], [[pullAgain]], [[disturbed]]');
+  const STARTED = 0b1;
+  const CLOSE_REQUESTED = 0b10;
+  const PULLING = 0b100;
+  const PULL_AGAIN = 0b1000;
+  const DISTURBED = 0b10000;
+  const undefined = global.undefined;
+  const Infinity = global.Infinity;
+  const defineProperty = global.Object.defineProperty;
+  const hasOwnProperty = v8.uncurryThis(global.Object.hasOwnProperty);
+  const callFunction = v8.uncurryThis(global.Function.prototype.call);
+  const TypeError = global.TypeError;
+  const RangeError = global.RangeError;
+  const Number = global.Number;
+  const Number_isNaN = Number.isNaN;
+  const Number_isFinite = Number.isFinite;
+  const Promise = global.Promise;
+  const thenPromise = v8.uncurryThis(Promise.prototype.then);
+  const Promise_resolve = v8.simpleBind(Promise.resolve, Promise);
+  const Promise_reject = v8.simpleBind(Promise.reject, Promise);
+  const errIllegalInvocation = 'Illegal invocation';
+  const errIllegalConstructor = 'Illegal constructor';
+  const errCancelLockedStream =
+      'Cannot cancel a readable stream that is locked to a reader';
+  const errEnqueueInCloseRequestedStream =
+      'Cannot enqueue a chunk into a readable stream that is closed or has been requested to be closed';
+  const errCancelReleasedReader =
+      'This readable stream reader has been released and cannot be used to cancel its previous owner stream';
+  const errReadReleasedReader =
+      'This readable stream reader has been released and cannot be used to read from its previous owner stream';
+  const errCloseCloseRequestedStream =
+      'Cannot close a readable stream that has already been requested to be closed';
+  const errCloseErroredStream = 'Cannot close an errored readable stream';
+  const errErrorClosedStream = 'Cannot error a close readable stream';
+  const errErrorErroredStream =
+      'Cannot error a readable stream that is already errored';
+  const errReaderConstructorBadArgument =
+      'ReadableStreamReader constructor argument is not a readable stream';
+  const errReaderConstructorStreamAlreadyLocked =
+      'ReadableStreamReader constructor can only accept readable streams that are not yet locked to a reader';
+  const errReleaseReaderWithPendingRead =
+      'Cannot release a readable stream reader when it still has outstanding read() calls that have not yet settled';
+  const errReleasedReaderClosedPromise =
+      'This readable stream reader has been released and cannot be used to monitor the stream\'s state';
+  const errInvalidSize =
+      'The return value of a queuing strategy\'s size function must be a finite, non-NaN, non-negative number';
+  const errSizeNotAFunction =
+      'A queuing strategy\'s size property must be a function';
+  const errInvalidHWM =
+      'A queueing strategy\'s highWaterMark property must be a nonnegative, non-NaN number';
+  const errTmplMustBeFunctionOrUndefined = name =>
+      `${name} must be a function or undefined`;
+  class ReadableStream {
+    constructor() {
+      const underlyingSource = arguments[0] === undefined ? {} : arguments[0];
+      const strategy = arguments[1] === undefined ? {} : arguments[1];
+      const size = strategy.size;
+      let highWaterMark = strategy.highWaterMark;
+      if (highWaterMark === undefined) {
+        highWaterMark = 1;
+      }
+      const normalizedStrategy =
+          ValidateAndNormalizeQueuingStrategy(size, highWaterMark);
+      this[readableStreamUnderlyingSource] = underlyingSource;
+      this[readableStreamQueue] = new v8.InternalPackedArray();
+      this[readableStreamQueueSize] = 0;
+      this[readableStreamState] = STATE_READABLE;
+      this[readableStreamBits] = 0b0;
+      this[readableStreamReader] = undefined;
+      this[readableStreamStoredError] = undefined;
+      this[readableStreamStrategySize] = normalizedStrategy.size;
+      this[readableStreamStrategyHWM] = normalizedStrategy.highWaterMark;
+      const controller = new ReadableStreamController(this);
+      this[readableStreamController] = controller;
+      const startResult = CallOrNoop(
+          underlyingSource, 'start', controller, 'underlyingSource.start');
+      thenPromise(Promise_resolve(startResult),
+          () => {
+            this[readableStreamBits] |= STARTED;
+            RequestReadableStreamPull(this);
+          },
+          r => {
+            if (this[readableStreamState] === STATE_READABLE) {
+              return ErrorReadableStream(this, r);
+            }
+          });
+    }
+    get locked() {
+      if (IsReadableStream(this) === false) {
+        throw new TypeError(errIllegalInvocation);
+      }
+      return IsReadableStreamLocked(this);
+    }
+    cancel(reason) {
+      if (IsReadableStream(this) === false) {
+        return Promise_reject(new TypeError(errIllegalInvocation));
+      }
+      if (IsReadableStreamLocked(this) === true) {
+        return Promise_reject(new TypeError(errCancelLockedStream));
+      }
+      return CancelReadableStream(this, reason);
+    }
+    getReader() {
+      if (IsReadableStream(this) === false) {
+        throw new TypeError(errIllegalInvocation);
+      }
+      return AcquireReadableStreamReader(this);
+    }
+    tee() {
+      if (IsReadableStream(this) === false) {
+        throw new TypeError(errIllegalInvocation);
+      }
+      return TeeReadableStream(this);
+    }
+  }
+  class ReadableStreamController {
+    constructor(stream) {
+      if (IsReadableStream(stream) === false) {
+        throw new TypeError(errIllegalConstructor);
+      }
+      if (stream[readableStreamController] !== undefined) {
+        throw new TypeError(errIllegalConstructor);
+      }
+      this[readableStreamControllerControlledReadableStream] = stream;
+    }
+    get desiredSize() {
+      if (IsReadableStreamController(this) === false) {
+        throw new TypeError(errIllegalInvocation);
+      }
+      return GetReadableStreamDesiredSize(
+          this[readableStreamControllerControlledReadableStream]);
+    }
+    close() {
+      if (IsReadableStreamController(this) === false) {
+        throw new TypeError(errIllegalInvocation);
+      }
+      const stream = this[readableStreamControllerControlledReadableStream];
+      if (stream[readableStreamBits] & CLOSE_REQUESTED) {
+        throw new TypeError(errCloseCloseRequestedStream);
+      }
+      if (stream[readableStreamState] === STATE_ERRORED) {
+        throw new TypeError(errCloseErroredStream);
+      }
+      return CloseReadableStream(stream);
+    }
+    enqueue(chunk) {
+      if (IsReadableStreamController(this) === false) {
+        throw new TypeError(errIllegalInvocation);
+      }
+      const stream = this[readableStreamControllerControlledReadableStream];
+      if (stream[readableStreamState] === STATE_ERRORED) {
+        throw stream[readableStreamStoredError];
+      }
+      if (stream[readableStreamBits] & CLOSE_REQUESTED) {
+        throw new TypeError(errEnqueueInCloseRequestedStream);
+      }
+      return EnqueueInReadableStream(stream, chunk);
+    }
+    error(e) {
+      if (IsReadableStreamController(this) === false) {
+        throw new TypeError(errIllegalInvocation);
+      }
+      const stream = this[readableStreamControllerControlledReadableStream];
+      const state = stream[readableStreamState];
+      if (state !== STATE_READABLE) {
+        if (state === STATE_ERRORED) {
+          throw new TypeError(errErrorErroredStream);
+        }
+        if (state === STATE_CLOSED) {
+          throw new TypeError(errErrorClosedStream);
+        }
+      }
+      return ErrorReadableStream(stream, e);
+    }
+  }
+  class ReadableStreamReader {
+    constructor(stream) {
+      if (IsReadableStream(stream) === false) {
+        throw new TypeError(errReaderConstructorBadArgument);
+      }
+      if (IsReadableStreamLocked(stream) === true) {
+        throw new TypeError(errReaderConstructorStreamAlreadyLocked);
+      }
+      this[readableStreamReaderOwnerReadableStream] = stream;
+      stream[readableStreamReader] = this;
+      this[readableStreamReaderReadRequests] = new v8.InternalPackedArray();
+      switch (stream[readableStreamState]) {
+        case STATE_READABLE:
+          this[readableStreamReaderClosedPromise] = v8.createPromise();
+          break;
+        case STATE_CLOSED:
+          this[readableStreamReaderClosedPromise] = Promise_resolve(undefined);
+          break;
+        case STATE_ERRORED:
+          this[readableStreamReaderClosedPromise] =
+              Promise_reject(stream[readableStreamStoredError]);
+          break;
+      }
+    }
+    get closed() {
+      if (IsReadableStreamReader(this) === false) {
+        return Promise_reject(new TypeError(errIllegalInvocation));
+      }
+      return this[readableStreamReaderClosedPromise];
+    }
+    cancel(reason) {
+      if (IsReadableStreamReader(this) === false) {
+        return Promise_reject(new TypeError(errIllegalInvocation));
+      }
+      const stream = this[readableStreamReaderOwnerReadableStream];
+      if (stream === undefined) {
+        return Promise_reject(new TypeError(errCancelReleasedReader));
+      }
+      return CancelReadableStream(stream, reason);
+    }
+    read() {
+      if (IsReadableStreamReader(this) === false) {
+        return Promise_reject(new TypeError(errIllegalInvocation));
+      }
+      if (this[readableStreamReaderOwnerReadableStream] === undefined) {
+        return Promise_reject(new TypeError(errReadReleasedReader));
+      }
+      return ReadFromReadableStreamReader(this);
+    }
+    releaseLock() {
+      if (IsReadableStreamReader(this) === false) {
+        throw new TypeError(errIllegalInvocation);
+      }
+      const stream = this[readableStreamReaderOwnerReadableStream];
+      if (stream === undefined) {
+        return undefined;
+      }
+      if (this[readableStreamReaderReadRequests].length > 0) {
+        throw new TypeError(errReleaseReaderWithPendingRead);
+      }
+      if (stream[readableStreamState] === STATE_READABLE) {
+        v8.rejectPromise(this[readableStreamReaderClosedPromise],
+            new TypeError(errReleasedReaderClosedPromise));
+      } else {
+        this[readableStreamReaderClosedPromise] = Promise_reject(new TypeError(
+            errReleasedReaderClosedPromise));
+      }
+      this[readableStreamReaderOwnerReadableStream][readableStreamReader] =
+          undefined;
+      this[readableStreamReaderOwnerReadableStream] = undefined;
+    }
+  }
+  function AcquireReadableStreamReader(stream) {
+    return new ReadableStreamReader(stream);
+  }
+  function CancelReadableStream(stream, reason) {
+    stream[readableStreamBits] |= DISTURBED;
+    const state = stream[readableStreamState];
+    if (state === STATE_CLOSED) {
+      return Promise_resolve(undefined);
+    }
+    if (state === STATE_ERRORED) {
+      return Promise_reject(stream[readableStreamStoredError]);
+    }
+    stream[readableStreamQueue] = new v8.InternalPackedArray();
+    FinishClosingReadableStream(stream);
+    const underlyingSource = stream[readableStreamUnderlyingSource];
+    const sourceCancelPromise = PromiseCallOrNoop(
+        underlyingSource, 'cancel', reason, 'underlyingSource.cancel');
+    return thenPromise(sourceCancelPromise, () => undefined);
+  }
+  function CloseReadableStream(stream) {
+    if (stream[readableStreamState] === STATE_CLOSED) {
+      return undefined;
+    }
+    stream[readableStreamBits] |= CLOSE_REQUESTED;
+    if (stream[readableStreamQueue].length === 0) {
+      return FinishClosingReadableStream(stream);
+    }
+  }
+  function EnqueueInReadableStream(stream, chunk) {
+    if (stream[readableStreamState] === STATE_CLOSED) {
+      return undefined;
+    }
+    if (IsReadableStreamLocked(stream) === true &&
+        stream[readableStreamReader][readableStreamReaderReadRequests].length >
+            0) {
+      const readRequest =
+          stream[readableStreamReader][readableStreamReaderReadRequests]
+              .shift();
+      v8.resolvePromise(readRequest, CreateIterResultObject(chunk, false));
+    } else {
+      let chunkSize = 1;
+      const strategySize = stream[readableStreamStrategySize];
+      if (strategySize !== undefined) {
+        try {
+          chunkSize = strategySize(chunk);
+        } catch (chunkSizeE) {
+          if (stream[readableStreamState] === STATE_READABLE) {
+            ErrorReadableStream(stream, chunkSizeE);
+          }
+          throw chunkSizeE;
+        }
+      }
+      try {
+        EnqueueValueWithSize(stream, chunk, chunkSize);
+      } catch (enqueueE) {
+        if (stream[readableStreamState] === STATE_READABLE) {
+          ErrorReadableStream(stream, enqueueE);
+        }
+        throw enqueueE;
+      }
+    }
+    RequestReadableStreamPull(stream);
+  }
+  function ErrorReadableStream(stream, e) {
+    stream[readableStreamQueue] = new v8.InternalPackedArray();
+    stream[readableStreamStoredError] = e;
+    stream[readableStreamState] = STATE_ERRORED;
+    const reader = stream[readableStreamReader];
+    if (reader === undefined) {
+      return undefined;
+    }
+    const readRequests = reader[readableStreamReaderReadRequests];
+    for (let i = 0; i < readRequests.length; ++i) {
+      v8.rejectPromise(readRequests[i], e);
+    }
+    reader[readableStreamReaderReadRequests] = new v8.InternalPackedArray();
+    v8.rejectPromise(reader[readableStreamReaderClosedPromise], e);
+  }
+  function FinishClosingReadableStream(stream) {
+    stream[readableStreamState] = STATE_CLOSED;
+    const reader = stream[readableStreamReader];
+    if (reader === undefined) {
+      return undefined;
+    }
+    const readRequests = reader[readableStreamReaderReadRequests];
+    for (let i = 0; i < readRequests.length; ++i) {
+      v8.resolvePromise(
+          readRequests[i], CreateIterResultObject(undefined, true));
+    }
+    reader[readableStreamReaderReadRequests] = new v8.InternalPackedArray();
+    v8.resolvePromise(reader[readableStreamReaderClosedPromise], undefined);
+  }
+  function GetReadableStreamDesiredSize(stream) {
+    const queueSize = GetTotalQueueSize(stream);
+    return stream[readableStreamStrategyHWM] - queueSize;
+  }
+  function IsReadableStream(x) {
+    return hasOwnProperty(x, readableStreamUnderlyingSource);
+  }
+  function IsReadableStreamDisturbed(stream) {
+    return stream[readableStreamBits] & DISTURBED;
+  }
+  function IsReadableStreamLocked(stream) {
+    return stream[readableStreamReader] !== undefined;
+  }
+  function IsReadableStreamController(x) {
+    return hasOwnProperty(x, readableStreamControllerControlledReadableStream);
+  }
+  function IsReadableStreamReader(x) {
+    return hasOwnProperty(x, readableStreamReaderOwnerReadableStream);
+  }
+  function ReadFromReadableStreamReader(reader) {
+    const stream = reader[readableStreamReaderOwnerReadableStream];
+    stream[readableStreamBits] |= DISTURBED;
+    if (stream[readableStreamState] === STATE_CLOSED) {
+      return Promise_resolve(CreateIterResultObject(undefined, true));
+    }
+    if (stream[readableStreamState] === STATE_ERRORED) {
+      return Promise_reject(stream[readableStreamStoredError]);
+    }
+    const queue = stream[readableStreamQueue];
+    if (queue.length > 0) {
+      const chunk = DequeueValue(stream);
+      if (stream[readableStreamBits] & CLOSE_REQUESTED && queue.length === 0) {
+        FinishClosingReadableStream(stream);
+      } else {
+        RequestReadableStreamPull(stream);
+      }
+      return Promise_resolve(CreateIterResultObject(chunk, false));
+    } else {
+      const readRequest = v8.createPromise();
+      reader[readableStreamReaderReadRequests].push(readRequest);
+      RequestReadableStreamPull(stream);
+      return readRequest;
+    }
+  }
+  function RequestReadableStreamPull(stream) {
+    const shouldPull = ShouldReadableStreamPull(stream);
+    if (shouldPull === false) {
+      return undefined;
+    }
+    if (stream[readableStreamBits] & PULLING) {
+      stream[readableStreamBits] |= PULL_AGAIN;
+      return undefined;
+    }
+    stream[readableStreamBits] |= PULLING;
+    const underlyingSource = stream[readableStreamUnderlyingSource];
+    const controller = stream[readableStreamController];
+    const pullPromise = PromiseCallOrNoop(
+        underlyingSource, 'pull', controller, 'underlyingSource.pull');
+    thenPromise(pullPromise,
+        () => {
+          stream[readableStreamBits] &= ~PULLING;
+          if (stream[readableStreamBits] & PULL_AGAIN) {
+            stream[readableStreamBits] &= ~PULL_AGAIN;
+            return RequestReadableStreamPull(stream);
+          }
+        },
+        e => {
+          if (stream[readableStreamState] === STATE_READABLE) {
+            return ErrorReadableStream(stream, e);
+          }
+        });
+  }
+  function ShouldReadableStreamPull(stream) {
+    const state = stream[readableStreamState];
+    if (state === STATE_CLOSED || state === STATE_ERRORED) {
+      return false;
+    }
+    if (stream[readableStreamBits] & CLOSE_REQUESTED) {
+      return false;
+    }
+    if (!(stream[readableStreamBits] & STARTED)) {
+      return false;
+    }
+    if (IsReadableStreamLocked(stream) === true) {
+      const reader = stream[readableStreamReader];
+      const readRequests = reader[readableStreamReaderReadRequests];
+      if (readRequests.length > 0) {
+        return true;
+      }
+    }
+    const desiredSize = GetReadableStreamDesiredSize(stream);
+    if (desiredSize > 0) {
+      return true;
+    }
+    return false;
+  }
+  function TeeReadableStream(stream) {
+    const reader = AcquireReadableStreamReader(stream);
+    let closedOrErrored = false;
+    let canceled1 = false;
+    let canceled2 = false;
+    let reason1;
+    let reason2;
+    let promise = v8.createPromise();
+    const branch1 = new ReadableStream({pull, cancel: cancel1});
+    const branch2 = new ReadableStream({pull, cancel: cancel2});
+    thenPromise(
+        reader[readableStreamReaderClosedPromise], undefined, function(r) {
+          if (closedOrErrored === true) {
+            return;
+          }
+          ErrorReadableStream(branch1, r);
+          ErrorReadableStream(branch2, r);
+          closedOrErrored = true;
+        });
+    return [branch1, branch2];
+    function pull() {
+      return thenPromise(
+          ReadFromReadableStreamReader(reader), function(result) {
+            const value = result.value;
+            const done = result.done;
+            if (done === true && closedOrErrored === false) {
+              CloseReadableStream(branch1);
+              CloseReadableStream(branch2);
+              closedOrErrored = true;
+            }
+            if (closedOrErrored === true) {
+              return;
+            }
+            if (canceled1 === false) {
+              EnqueueInReadableStream(branch1, value);
+            }
+            if (canceled2 === false) {
+              EnqueueInReadableStream(branch2, value);
+            }
+          });
+    }
+    function cancel1(reason) {
+      canceled1 = true;
+      reason1 = reason;
+      if (canceled2 === true) {
+        const compositeReason = [reason1, reason2];
+        const cancelResult = CancelReadableStream(stream, compositeReason);
+        v8.resolvePromise(promise, cancelResult);
+      }
+      return promise;
+    }
+    function cancel2(reason) {
+      canceled2 = true;
+      reason2 = reason;
+      if (canceled1 === true) {
+        const compositeReason = [reason1, reason2];
+        const cancelResult = CancelReadableStream(stream, compositeReason);
+        v8.resolvePromise(promise, cancelResult);
+      }
+      return promise;
+    }
+  }
+  function DequeueValue(stream) {
+    const result = stream[readableStreamQueue].shift();
+    stream[readableStreamQueueSize] -= result.size;
+    return result.value;
+  }
+  function EnqueueValueWithSize(stream, value, size) {
+    size = Number(size);
+    if (Number_isNaN(size) || size === +Infinity || size < 0) {
+      throw new RangeError(errInvalidSize);
+    }
+    stream[readableStreamQueueSize] += size;
+    stream[readableStreamQueue].push({value, size});
+  }
+  function GetTotalQueueSize(stream) { return stream[readableStreamQueueSize]; }
+  function ValidateAndNormalizeQueuingStrategy(size, highWaterMark) {
+    if (size !== undefined && typeof size !== 'function') {
+      throw new TypeError(errSizeNotAFunction);
+    }
+    highWaterMark = Number(highWaterMark);
+    if (Number_isNaN(highWaterMark)) {
+      throw new TypeError(errInvalidHWM);
+    }
+    if (highWaterMark < 0) {
+      throw new RangeError(errInvalidHWM);
+    }
+    return {size, highWaterMark};
+  }
+  function CallOrNoop(O, P, arg, nameForError) {
+    const method = O[P];
+    if (method === undefined) {
+      return undefined;
+    }
+    if (typeof method !== 'function') {
+      throw new TypeError(errTmplMustBeFunctionOrUndefined(nameForError));
+    }
+    return callFunction(method, O, arg);
+  }
+  function PromiseCallOrNoop(O, P, arg, nameForError) {
+    let method;
+    try {
+      method = O[P];
+    } catch (methodE) {
+      return Promise_reject(methodE);
+    }
+    if (method === undefined) {
+      return Promise_resolve(undefined);
+    }
+    if (typeof method !== 'function') {
+      return Promise_reject(errTmplMustBeFunctionOrUndefined(nameForError));
+    }
+    try {
+      return Promise_resolve(callFunction(method, O, arg));
+    } catch (e) {
+      return Promise_reject(e);
+    }
+  }
+  function CreateIterResultObject(value, done) { return {value, done}; }
+  defineProperty(global, 'ReadableStream', {
+    value: ReadableStream,
+    enumerable: false,
+    configurable: true,
+    writable: true
+  });
+  binding.AcquireReadableStreamReader = AcquireReadableStreamReader;
+  binding.IsReadableStream = IsReadableStream;
+  binding.IsReadableStreamDisturbed = IsReadableStreamDisturbed;
+  binding.IsReadableStreamLocked = IsReadableStreamLocked;
+  binding.IsReadableStreamReader = IsReadableStreamReader;
+  binding.ReadFromReadableStreamReader = ReadFromReadableStreamReader;
+});
diff --git a/bin/nt_64/release/VS2013/libcef_dll_wrapper.lib b/bin/nt_64/release/VS2013/libcef_dll_wrapper.lib
new file mode 100644
index 0000000..2a443f1
Binary files /dev/null and b/bin/nt_64/release/VS2013/libcef_dll_wrapper.lib differ
diff --git a/bin/nt_64/release/VS2015/libcef_dll_wrapper.lib b/bin/nt_64/release/VS2015/libcef_dll_wrapper.lib
new file mode 100644
index 0000000..c401364
Binary files /dev/null and b/bin/nt_64/release/VS2015/libcef_dll_wrapper.lib differ
diff --git a/bin/nt_64/release/libcef.lib b/bin/nt_64/release/libcef.lib
new file mode 100644
index 0000000..3635886
Binary files /dev/null and b/bin/nt_64/release/libcef.lib differ
diff --git a/bin/nt_64/snapshot_blob.bin b/bin/nt_64/snapshot_blob.bin
new file mode 100644
index 0000000..124c2f8
Binary files /dev/null and b/bin/nt_64/snapshot_blob.bin differ
diff --git a/bin/nt_64/widevinecdmadapter.dll b/bin/nt_64/widevinecdmadapter.dll
new file mode 100644
index 0000000..a8e18bd
Binary files /dev/null and b/bin/nt_64/widevinecdmadapter.dll differ
diff --git a/bin/nt_86/cef.pak b/bin/nt_86/cef.pak
new file mode 100644
index 0000000..8774393
Binary files /dev/null and b/bin/nt_86/cef.pak differ
diff --git a/bin/nt_86/cef_100_percent.pak b/bin/nt_86/cef_100_percent.pak
new file mode 100644
index 0000000..a42afe6
Binary files /dev/null and b/bin/nt_86/cef_100_percent.pak differ
diff --git a/bin/nt_86/cef_200_percent.pak b/bin/nt_86/cef_200_percent.pak
new file mode 100644
index 0000000..ced35f6
Binary files /dev/null and b/bin/nt_86/cef_200_percent.pak differ
diff --git a/bin/nt_86/cef_extensions.pak b/bin/nt_86/cef_extensions.pak
new file mode 100644
index 0000000..e085962
Binary files /dev/null and b/bin/nt_86/cef_extensions.pak differ
diff --git a/bin/nt_86/d3dcompiler_43.dll b/bin/nt_86/d3dcompiler_43.dll
new file mode 100644
index 0000000..ab96161
Binary files /dev/null and b/bin/nt_86/d3dcompiler_43.dll differ
diff --git a/bin/nt_86/d3dcompiler_47.dll b/bin/nt_86/d3dcompiler_47.dll
new file mode 100644
index 0000000..71220ae
Binary files /dev/null and b/bin/nt_86/d3dcompiler_47.dll differ
diff --git a/bin/nt_86/debug.log b/bin/nt_86/debug.log
new file mode 100644
index 0000000..c29dc7b
--- /dev/null
+++ b/bin/nt_86/debug.log
@@ -0,0 +1,63 @@
+[0622/145246:ERROR:proxy_service_factory.cc(136)] Cannot use V8 Proxy resolver in single process mode.
+[0622/145246:WARNING:histograms.cc(40)] Started multiple compositor clients (Browser, Renderer) in one process. Some metrics will be disabled.
+[0622/145412:WARNING:raw_channel_win.cc(532)] WriteFile: O pipe est� sendo fechado. (0xE8)
+[0622/145651:ERROR:proxy_service_factory.cc(136)] Cannot use V8 Proxy resolver in single process mode.
+[0622/145713:ERROR:proxy_service_factory.cc(136)] Cannot use V8 Proxy resolver in single process mode.
+[0622/145713:WARNING:histograms.cc(40)] Started multiple compositor clients (Browser, Renderer) in one process. Some metrics will be disabled.
+[0622/145718:WARNING:raw_channel_win.cc(532)] WriteFile: O pipe est� sendo fechado. (0xE8)
+[0622/145718:ERROR:ipc_channel_win.cc(217)] pipe error: 109
+[0622/150359:ERROR:proxy_service_factory.cc(136)] Cannot use V8 Proxy resolver in single process mode.
+[0622/150359:WARNING:histograms.cc(40)] Started multiple compositor clients (Browser, Renderer) in one process. Some metrics will be disabled.
+[0622/150403:WARNING:raw_channel_win.cc(532)] WriteFile: O pipe est� sendo fechado. (0xE8)
+[0622/151221:ERROR:proxy_service_factory.cc(136)] Cannot use V8 Proxy resolver in single process mode.
+[0622/151221:WARNING:histograms.cc(40)] Started multiple compositor clients (Browser, Renderer) in one process. Some metrics will be disabled.
+[0622/151303:WARNING:raw_channel_win.cc(532)] WriteFile: O pipe est� sendo fechado. (0xE8)
+[0623/093625:ERROR:proxy_service_factory.cc(136)] Cannot use V8 Proxy resolver in single process mode.
+[0623/093627:WARNING:histograms.cc(40)] Started multiple compositor clients (Browser, Renderer) in one process. Some metrics will be disabled.
+[0623/093713:ERROR:ipc_channel_win.cc(217)] pipe error: 109
+[0623/093714:ERROR:proxy_service_factory.cc(136)] Cannot use V8 Proxy resolver in single process mode.
+[0623/093714:WARNING:histograms.cc(40)] Started multiple compositor clients (Browser, Renderer) in one process. Some metrics will be disabled.
+[0623/093717:WARNING:raw_channel_win.cc(532)] WriteFile: O pipe est� sendo fechado. (0xE8)
+[0623/093725:ERROR:proxy_service_factory.cc(136)] Cannot use V8 Proxy resolver in single process mode.
+[0623/093725:WARNING:histograms.cc(40)] Started multiple compositor clients (Browser, Renderer) in one process. Some metrics will be disabled.
+[0623/093727:WARNING:raw_channel_win.cc(532)] WriteFile: O pipe est� sendo fechado. (0xE8)
+[0623/101452:ERROR:proxy_service_factory.cc(136)] Cannot use V8 Proxy resolver in single process mode.
+[0623/101452:WARNING:histograms.cc(40)] Started multiple compositor clients (Browser, Renderer) in one process. Some metrics will be disabled.
+[0623/101456:WARNING:raw_channel_win.cc(532)] WriteFile: O pipe est� sendo fechado. (0xE8)
+[0623/103045:ERROR:proxy_service_factory.cc(136)] Cannot use V8 Proxy resolver in single process mode.
+[0623/103045:WARNING:histograms.cc(40)] Started multiple compositor clients (Browser, Renderer) in one process. Some metrics will be disabled.
+[0623/103137:WARNING:raw_channel_win.cc(532)] WriteFile: O pipe est� sendo fechado. (0xE8)
+[0623/111745:ERROR:proxy_service_factory.cc(136)] Cannot use V8 Proxy resolver in single process mode.
+[0623/111745:WARNING:histograms.cc(40)] Started multiple compositor clients (Browser, Renderer) in one process. Some metrics will be disabled.
+[0623/111809:WARNING:raw_channel_win.cc(532)] WriteFile: O pipe est� sendo fechado. (0xE8)
+[0623/113547:ERROR:proxy_service_factory.cc(136)] Cannot use V8 Proxy resolver in single process mode.
+[0623/113547:WARNING:histograms.cc(40)] Started multiple compositor clients (Browser, Renderer) in one process. Some metrics will be disabled.
+[0623/113551:WARNING:raw_channel_win.cc(532)] WriteFile: O pipe est� sendo fechado. (0xE8)
+[0623/113736:ERROR:proxy_service_factory.cc(136)] Cannot use V8 Proxy resolver in single process mode.
+[0623/113736:WARNING:histograms.cc(40)] Started multiple compositor clients (Browser, Renderer) in one process. Some metrics will be disabled.
+[0623/113848:WARNING:raw_channel_win.cc(532)] WriteFile: O pipe est� sendo fechado. (0xE8)
+[0623/113901:ERROR:proxy_service_factory.cc(136)] Cannot use V8 Proxy resolver in single process mode.
+[0623/113901:WARNING:histograms.cc(40)] Started multiple compositor clients (Browser, Renderer) in one process. Some metrics will be disabled.
+[0623/113936:WARNING:raw_channel_win.cc(532)] WriteFile: O pipe est� sendo fechado. (0xE8)
+[0623/113937:ERROR:proxy_service_factory.cc(136)] Cannot use V8 Proxy resolver in single process mode.
+[0623/113937:WARNING:histograms.cc(40)] Started multiple compositor clients (Browser, Renderer) in one process. Some metrics will be disabled.
+[0623/113945:WARNING:raw_channel_win.cc(532)] WriteFile: O pipe est� sendo fechado. (0xE8)
+[0623/124814:ERROR:proxy_service_factory.cc(136)] Cannot use V8 Proxy resolver in single process mode.
+[0623/124814:WARNING:histograms.cc(40)] Started multiple compositor clients (Browser, Renderer) in one process. Some metrics will be disabled.
+[0623/124827:WARNING:raw_channel_win.cc(532)] WriteFile: O pipe est� sendo fechado. (0xE8)
+[0624/080510:ERROR:proxy_service_factory.cc(136)] Cannot use V8 Proxy resolver in single process mode.
+[0624/080512:WARNING:histograms.cc(40)] Started multiple compositor clients (Browser, Renderer) in one process. Some metrics will be disabled.
+[0624/080544:ERROR:ipc_channel_win.cc(217)] pipe error: 109
+[0624/080956:ERROR:proxy_service_factory.cc(136)] Cannot use V8 Proxy resolver in single process mode.
+[0624/080956:WARNING:histograms.cc(40)] Started multiple compositor clients (Browser, Renderer) in one process. Some metrics will be disabled.
+[0624/081000:WARNING:raw_channel_win.cc(532)] WriteFile: O pipe est� sendo fechado. (0xE8)
+[0624/081000:ERROR:ipc_channel_win.cc(217)] pipe error: 109
+[0624/133100:ERROR:proxy_service_factory.cc(136)] Cannot use V8 Proxy resolver in single process mode.
+[0624/133100:WARNING:histograms.cc(40)] Started multiple compositor clients (Browser, Renderer) in one process. Some metrics will be disabled.
+[0624/133131:WARNING:raw_channel_win.cc(532)] WriteFile: O pipe est� sendo fechado. (0xE8)
+[0624/133144:ERROR:proxy_service_factory.cc(136)] Cannot use V8 Proxy resolver in single process mode.
+[0624/133144:WARNING:histograms.cc(40)] Started multiple compositor clients (Browser, Renderer) in one process. Some metrics will be disabled.
+[0624/133146:WARNING:raw_channel_win.cc(532)] WriteFile: O pipe est� sendo fechado. (0xE8)
+[0624/172549:ERROR:proxy_service_factory.cc(136)] Cannot use V8 Proxy resolver in single process mode.
+[0624/172549:WARNING:histograms.cc(40)] Started multiple compositor clients (Browser, Renderer) in one process. Some metrics will be disabled.
+[0624/172555:ERROR:ipc_channel_win.cc(217)] pipe error: 109
diff --git a/bin/nt_86/debug/VS2013/libcef_dll_wrapper.lib b/bin/nt_86/debug/VS2013/libcef_dll_wrapper.lib
new file mode 100644
index 0000000..b112ef7
Binary files /dev/null and b/bin/nt_86/debug/VS2013/libcef_dll_wrapper.lib differ
diff --git a/bin/nt_86/debug/VS2015/libcef_dll_wrapper.lib b/bin/nt_86/debug/VS2015/libcef_dll_wrapper.lib
new file mode 100644
index 0000000..2d43113
Binary files /dev/null and b/bin/nt_86/debug/VS2015/libcef_dll_wrapper.lib differ
diff --git a/bin/nt_86/debug/libcef.lib b/bin/nt_86/debug/libcef.lib
new file mode 100644
index 0000000..92d5064
Binary files /dev/null and b/bin/nt_86/debug/libcef.lib differ
diff --git a/bin/nt_86/devtools_resources.pak b/bin/nt_86/devtools_resources.pak
new file mode 100644
index 0000000..46aecd8
Binary files /dev/null and b/bin/nt_86/devtools_resources.pak differ
diff --git a/bin/nt_86/icudtl.dat b/bin/nt_86/icudtl.dat
new file mode 100644
index 0000000..065463a
Binary files /dev/null and b/bin/nt_86/icudtl.dat differ
diff --git a/bin/nt_86/libEGL.dll b/bin/nt_86/libEGL.dll
new file mode 100644
index 0000000..0b0ecff
Binary files /dev/null and b/bin/nt_86/libEGL.dll differ
diff --git a/bin/nt_86/libGLESv2.dll b/bin/nt_86/libGLESv2.dll
new file mode 100644
index 0000000..d65b675
Binary files /dev/null and b/bin/nt_86/libGLESv2.dll differ
diff --git a/bin/nt_86/libcef.dll b/bin/nt_86/libcef.dll
new file mode 100644
index 0000000..40d5ffa
Binary files /dev/null and b/bin/nt_86/libcef.dll differ
diff --git a/bin/nt_86/locales/am.pak b/bin/nt_86/locales/am.pak
new file mode 100644
index 0000000..c1f4bab
Binary files /dev/null and b/bin/nt_86/locales/am.pak differ
diff --git a/bin/nt_86/locales/ar.pak b/bin/nt_86/locales/ar.pak
new file mode 100644
index 0000000..5225c7f
Binary files /dev/null and b/bin/nt_86/locales/ar.pak differ
diff --git a/bin/nt_86/locales/bg.pak b/bin/nt_86/locales/bg.pak
new file mode 100644
index 0000000..50670c9
Binary files /dev/null and b/bin/nt_86/locales/bg.pak differ
diff --git a/bin/nt_86/locales/bn.pak b/bin/nt_86/locales/bn.pak
new file mode 100644
index 0000000..0967278
Binary files /dev/null and b/bin/nt_86/locales/bn.pak differ
diff --git a/bin/nt_86/locales/ca.pak b/bin/nt_86/locales/ca.pak
new file mode 100644
index 0000000..9e06aad
Binary files /dev/null and b/bin/nt_86/locales/ca.pak differ
diff --git a/bin/nt_86/locales/cs.pak b/bin/nt_86/locales/cs.pak
new file mode 100644
index 0000000..518e33e
Binary files /dev/null and b/bin/nt_86/locales/cs.pak differ
diff --git a/bin/nt_86/locales/da.pak b/bin/nt_86/locales/da.pak
new file mode 100644
index 0000000..b2e8b7b
Binary files /dev/null and b/bin/nt_86/locales/da.pak differ
diff --git a/bin/nt_86/locales/de.pak b/bin/nt_86/locales/de.pak
new file mode 100644
index 0000000..231b7c9
Binary files /dev/null and b/bin/nt_86/locales/de.pak differ
diff --git a/bin/nt_86/locales/el.pak b/bin/nt_86/locales/el.pak
new file mode 100644
index 0000000..4b13cb7
Binary files /dev/null and b/bin/nt_86/locales/el.pak differ
diff --git a/bin/nt_86/locales/en-GB.pak b/bin/nt_86/locales/en-GB.pak
new file mode 100644
index 0000000..927af5f
Binary files /dev/null and b/bin/nt_86/locales/en-GB.pak differ
diff --git a/bin/nt_86/locales/en-US.pak b/bin/nt_86/locales/en-US.pak
new file mode 100644
index 0000000..e0e9edd
Binary files /dev/null and b/bin/nt_86/locales/en-US.pak differ
diff --git a/bin/nt_86/locales/es-419.pak b/bin/nt_86/locales/es-419.pak
new file mode 100644
index 0000000..50406d9
Binary files /dev/null and b/bin/nt_86/locales/es-419.pak differ
diff --git a/bin/nt_86/locales/es.pak b/bin/nt_86/locales/es.pak
new file mode 100644
index 0000000..3680708
Binary files /dev/null and b/bin/nt_86/locales/es.pak differ
diff --git a/bin/nt_86/locales/et.pak b/bin/nt_86/locales/et.pak
new file mode 100644
index 0000000..ef9c51f
Binary files /dev/null and b/bin/nt_86/locales/et.pak differ
diff --git a/bin/nt_86/locales/fa.pak b/bin/nt_86/locales/fa.pak
new file mode 100644
index 0000000..5e5144f
Binary files /dev/null and b/bin/nt_86/locales/fa.pak differ
diff --git a/bin/nt_86/locales/fi.pak b/bin/nt_86/locales/fi.pak
new file mode 100644
index 0000000..2bc0675
Binary files /dev/null and b/bin/nt_86/locales/fi.pak differ
diff --git a/bin/nt_86/locales/fil.pak b/bin/nt_86/locales/fil.pak
new file mode 100644
index 0000000..c96dd03
Binary files /dev/null and b/bin/nt_86/locales/fil.pak differ
diff --git a/bin/nt_86/locales/fr.pak b/bin/nt_86/locales/fr.pak
new file mode 100644
index 0000000..63b1025
Binary files /dev/null and b/bin/nt_86/locales/fr.pak differ
diff --git a/bin/nt_86/locales/gu.pak b/bin/nt_86/locales/gu.pak
new file mode 100644
index 0000000..47f12f5
Binary files /dev/null and b/bin/nt_86/locales/gu.pak differ
diff --git a/bin/nt_86/locales/he.pak b/bin/nt_86/locales/he.pak
new file mode 100644
index 0000000..4533306
Binary files /dev/null and b/bin/nt_86/locales/he.pak differ
diff --git a/bin/nt_86/locales/hi.pak b/bin/nt_86/locales/hi.pak
new file mode 100644
index 0000000..07f5e17
Binary files /dev/null and b/bin/nt_86/locales/hi.pak differ
diff --git a/bin/nt_86/locales/hr.pak b/bin/nt_86/locales/hr.pak
new file mode 100644
index 0000000..61d43f1
Binary files /dev/null and b/bin/nt_86/locales/hr.pak differ
diff --git a/bin/nt_86/locales/hu.pak b/bin/nt_86/locales/hu.pak
new file mode 100644
index 0000000..2f3840d
Binary files /dev/null and b/bin/nt_86/locales/hu.pak differ
diff --git a/bin/nt_86/locales/id.pak b/bin/nt_86/locales/id.pak
new file mode 100644
index 0000000..0a8fb87
Binary files /dev/null and b/bin/nt_86/locales/id.pak differ
diff --git a/bin/nt_86/locales/it.pak b/bin/nt_86/locales/it.pak
new file mode 100644
index 0000000..3c9a472
Binary files /dev/null and b/bin/nt_86/locales/it.pak differ
diff --git a/bin/nt_86/locales/ja.pak b/bin/nt_86/locales/ja.pak
new file mode 100644
index 0000000..b192604
Binary files /dev/null and b/bin/nt_86/locales/ja.pak differ
diff --git a/bin/nt_86/locales/kn.pak b/bin/nt_86/locales/kn.pak
new file mode 100644
index 0000000..9118da2
Binary files /dev/null and b/bin/nt_86/locales/kn.pak differ
diff --git a/bin/nt_86/locales/ko.pak b/bin/nt_86/locales/ko.pak
new file mode 100644
index 0000000..f405e4c
Binary files /dev/null and b/bin/nt_86/locales/ko.pak differ
diff --git a/bin/nt_86/locales/lt.pak b/bin/nt_86/locales/lt.pak
new file mode 100644
index 0000000..292b71b
Binary files /dev/null and b/bin/nt_86/locales/lt.pak differ
diff --git a/bin/nt_86/locales/lv.pak b/bin/nt_86/locales/lv.pak
new file mode 100644
index 0000000..dae91ac
Binary files /dev/null and b/bin/nt_86/locales/lv.pak differ
diff --git a/bin/nt_86/locales/ml.pak b/bin/nt_86/locales/ml.pak
new file mode 100644
index 0000000..01195db
Binary files /dev/null and b/bin/nt_86/locales/ml.pak differ
diff --git a/bin/nt_86/locales/mr.pak b/bin/nt_86/locales/mr.pak
new file mode 100644
index 0000000..48bbe3a
Binary files /dev/null and b/bin/nt_86/locales/mr.pak differ
diff --git a/bin/nt_86/locales/ms.pak b/bin/nt_86/locales/ms.pak
new file mode 100644
index 0000000..ae122e7
Binary files /dev/null and b/bin/nt_86/locales/ms.pak differ
diff --git a/bin/nt_86/locales/nb.pak b/bin/nt_86/locales/nb.pak
new file mode 100644
index 0000000..99ee492
Binary files /dev/null and b/bin/nt_86/locales/nb.pak differ
diff --git a/bin/nt_86/locales/nl.pak b/bin/nt_86/locales/nl.pak
new file mode 100644
index 0000000..feeb59a
Binary files /dev/null and b/bin/nt_86/locales/nl.pak differ
diff --git a/bin/nt_86/locales/pl.pak b/bin/nt_86/locales/pl.pak
new file mode 100644
index 0000000..9491c43
Binary files /dev/null and b/bin/nt_86/locales/pl.pak differ
diff --git a/bin/nt_86/locales/pt-BR.pak b/bin/nt_86/locales/pt-BR.pak
new file mode 100644
index 0000000..839ce5f
Binary files /dev/null and b/bin/nt_86/locales/pt-BR.pak differ
diff --git a/bin/nt_86/locales/pt-PT.pak b/bin/nt_86/locales/pt-PT.pak
new file mode 100644
index 0000000..ead3c0a
Binary files /dev/null and b/bin/nt_86/locales/pt-PT.pak differ
diff --git a/bin/nt_86/locales/ro.pak b/bin/nt_86/locales/ro.pak
new file mode 100644
index 0000000..2001198
Binary files /dev/null and b/bin/nt_86/locales/ro.pak differ
diff --git a/bin/nt_86/locales/ru.pak b/bin/nt_86/locales/ru.pak
new file mode 100644
index 0000000..ea47578
Binary files /dev/null and b/bin/nt_86/locales/ru.pak differ
diff --git a/bin/nt_86/locales/sk.pak b/bin/nt_86/locales/sk.pak
new file mode 100644
index 0000000..24cf537
Binary files /dev/null and b/bin/nt_86/locales/sk.pak differ
diff --git a/bin/nt_86/locales/sl.pak b/bin/nt_86/locales/sl.pak
new file mode 100644
index 0000000..7a2755b
Binary files /dev/null and b/bin/nt_86/locales/sl.pak differ
diff --git a/bin/nt_86/locales/sr.pak b/bin/nt_86/locales/sr.pak
new file mode 100644
index 0000000..d3edea2
Binary files /dev/null and b/bin/nt_86/locales/sr.pak differ
diff --git a/bin/nt_86/locales/sv.pak b/bin/nt_86/locales/sv.pak
new file mode 100644
index 0000000..d967fd2
Binary files /dev/null and b/bin/nt_86/locales/sv.pak differ
diff --git a/bin/nt_86/locales/sw.pak b/bin/nt_86/locales/sw.pak
new file mode 100644
index 0000000..96b9ada
Binary files /dev/null and b/bin/nt_86/locales/sw.pak differ
diff --git a/bin/nt_86/locales/ta.pak b/bin/nt_86/locales/ta.pak
new file mode 100644
index 0000000..48bd8d1
Binary files /dev/null and b/bin/nt_86/locales/ta.pak differ
diff --git a/bin/nt_86/locales/te.pak b/bin/nt_86/locales/te.pak
new file mode 100644
index 0000000..28ed3ef
Binary files /dev/null and b/bin/nt_86/locales/te.pak differ
diff --git a/bin/nt_86/locales/th.pak b/bin/nt_86/locales/th.pak
new file mode 100644
index 0000000..876b1e0
Binary files /dev/null and b/bin/nt_86/locales/th.pak differ
diff --git a/bin/nt_86/locales/tr.pak b/bin/nt_86/locales/tr.pak
new file mode 100644
index 0000000..0d965da
Binary files /dev/null and b/bin/nt_86/locales/tr.pak differ
diff --git a/bin/nt_86/locales/uk.pak b/bin/nt_86/locales/uk.pak
new file mode 100644
index 0000000..ef83ec6
Binary files /dev/null and b/bin/nt_86/locales/uk.pak differ
diff --git a/bin/nt_86/locales/vi.pak b/bin/nt_86/locales/vi.pak
new file mode 100644
index 0000000..af258bf
Binary files /dev/null and b/bin/nt_86/locales/vi.pak differ
diff --git a/bin/nt_86/locales/zh-CN.pak b/bin/nt_86/locales/zh-CN.pak
new file mode 100644
index 0000000..6f4896f
Binary files /dev/null and b/bin/nt_86/locales/zh-CN.pak differ
diff --git a/bin/nt_86/locales/zh-TW.pak b/bin/nt_86/locales/zh-TW.pak
new file mode 100644
index 0000000..85ce42d
Binary files /dev/null and b/bin/nt_86/locales/zh-TW.pak differ
diff --git a/bin/nt_86/lpc_launcher.exe b/bin/nt_86/lpc_launcher.exe
new file mode 100644
index 0000000..8437e3a
Binary files /dev/null and b/bin/nt_86/lpc_launcher.exe differ
diff --git a/bin/nt_86/natives_blob.bin b/bin/nt_86/natives_blob.bin
new file mode 100644
index 0000000..ccaa95d
--- /dev/null
+++ b/bin/nt_86/natives_blob.bin
@@ -0,0 +1,19123 @@
+mirrors�t
+(function(a,b){
+"use strict";
+var c;
+var d=a.Array;
+var e=a.isNaN;
+var f=a.JSON.stringify;
+var g;
+var h;
+var i;
+var j=a.Math.min;
+var k=b.ImportNow("promise_status_symbol");
+var l=b.ImportNow("promise_value_symbol");
+var m;
+var n;
+var o;
+b.Import(function(p){
+c=p.ErrorToString;
+g=p.MakeError;
+h=p.MapEntries;
+i=p.MapIteratorNext;
+m=p.SetIteratorNext;
+n=p.SetValues;
+o=p.SymbolToString;
+});
+var q={
+UNDEFINED_TYPE:'undefined',
+NULL_TYPE:'null',
+BOOLEAN_TYPE:'boolean',
+NUMBER_TYPE:'number',
+STRING_TYPE:'string',
+SYMBOL_TYPE:'symbol',
+OBJECT_TYPE:'object',
+FUNCTION_TYPE:'function',
+REGEXP_TYPE:'regexp',
+ERROR_TYPE:'error',
+PROPERTY_TYPE:'property',
+INTERNAL_PROPERTY_TYPE:'internalProperty',
+FRAME_TYPE:'frame',
+SCRIPT_TYPE:'script',
+CONTEXT_TYPE:'context',
+SCOPE_TYPE:'scope',
+PROMISE_TYPE:'promise',
+MAP_TYPE:'map',
+SET_TYPE:'set',
+ITERATOR_TYPE:'iterator',
+GENERATOR_TYPE:'generator',
+}
+var r=0;
+var s=-1;
+var t=[];
+var u=true;
+function MirrorCacheIsEmpty(){
+return r==0&&t.length==0;
+}
+function ToggleMirrorCache(v){
+u=v;
+ClearMirrorCache();
+}
+function ClearMirrorCache(v){
+r=0;
+t=[];
+}
+function ObjectIsPromise(v){
+return(%_IsJSReceiver(v))&&
+!(%DebugGetProperty(v,k)===(void 0));
+}
+function MakeMirror(v,w){
+var x;
+if(!w&&u){
+for(var y in t){
+x=t[y];
+if(x.value()===v){
+return x;
+}
+if(x.isNumber()&&e(x.value())&&
+typeof v=='number'&&e(v)){
+return x;
+}
+}
+}
+if((v===(void 0))){
+x=new UndefinedMirror();
+}else if((v===null)){
+x=new NullMirror();
+}else if((typeof(v)==='boolean')){
+x=new BooleanMirror(v);
+}else if((typeof(v)==='number')){
+x=new NumberMirror(v);
+}else if((typeof(v)==='string')){
+x=new StringMirror(v);
+}else if((typeof(v)==='symbol')){
+x=new SymbolMirror(v);
+}else if((%_IsArray(v))){
+x=new ArrayMirror(v);
+}else if((%_IsDate(v))){
+x=new DateMirror(v);
+}else if((%_IsFunction(v))){
+x=new FunctionMirror(v);
+}else if((%_IsRegExp(v))){
+x=new RegExpMirror(v);
+}else if((%_ClassOf(v)==='Error')){
+x=new ErrorMirror(v);
+}else if((%_ClassOf(v)==='Script')){
+x=new ScriptMirror(v);
+}else if((%_ClassOf(v)==='Map')||(%_ClassOf(v)==='WeakMap')){
+x=new MapMirror(v);
+}else if((%_ClassOf(v)==='Set')||(%_ClassOf(v)==='WeakSet')){
+x=new SetMirror(v);
+}else if((%_ClassOf(v)==='Map Iterator')||(%_ClassOf(v)==='Set Iterator')){
+x=new IteratorMirror(v);
+}else if(ObjectIsPromise(v)){
+x=new PromiseMirror(v);
+}else if((%_ClassOf(v)==='Generator')){
+x=new GeneratorMirror(v);
+}else{
+x=new ObjectMirror(v,q.OBJECT_TYPE,w);
+}
+if(u)t[x.handle()]=x;
+return x;
+}
+function LookupMirror(z){
+if(!u){
+throw g(2,"Mirror cache is disabled");
+}
+return t[z];
+}
+function GetUndefinedMirror(){
+return MakeMirror((void 0));
+}
+function inherits(A,B){
+var C=function(){};
+C.prototype=B.prototype;
+A.super_=B.prototype;
+A.prototype=new C();
+A.prototype.constructor=A;
+}
+var D=80;
+var E={};
+E.Data=0;
+E.DataConstant=2;
+E.AccessorConstant=3;
+var F={};
+F.None=0;
+F.ReadOnly=1;
+F.DontEnum=2;
+F.DontDelete=4;
+var G={Global:0,
+Local:1,
+With:2,
+Closure:3,
+Catch:4,
+Block:5,
+Script:6};
+function Mirror(H){
+this.type_=H;
+}
+Mirror.prototype.type=function(){
+return this.type_;
+};
+Mirror.prototype.isValue=function(){
+return this instanceof ValueMirror;
+};
+Mirror.prototype.isUndefined=function(){
+return this instanceof UndefinedMirror;
+};
+Mirror.prototype.isNull=function(){
+return this instanceof NullMirror;
+};
+Mirror.prototype.isBoolean=function(){
+return this instanceof BooleanMirror;
+};
+Mirror.prototype.isNumber=function(){
+return this instanceof NumberMirror;
+};
+Mirror.prototype.isString=function(){
+return this instanceof StringMirror;
+};
+Mirror.prototype.isSymbol=function(){
+return this instanceof SymbolMirror;
+};
+Mirror.prototype.isObject=function(){
+return this instanceof ObjectMirror;
+};
+Mirror.prototype.isFunction=function(){
+return this instanceof FunctionMirror;
+};
+Mirror.prototype.isUnresolvedFunction=function(){
+return this instanceof UnresolvedFunctionMirror;
+};
+Mirror.prototype.isArray=function(){
+return this instanceof ArrayMirror;
+};
+Mirror.prototype.isDate=function(){
+return this instanceof DateMirror;
+};
+Mirror.prototype.isRegExp=function(){
+return this instanceof RegExpMirror;
+};
+Mirror.prototype.isError=function(){
+return this instanceof ErrorMirror;
+};
+Mirror.prototype.isPromise=function(){
+return this instanceof PromiseMirror;
+};
+Mirror.prototype.isGenerator=function(){
+return this instanceof GeneratorMirror;
+};
+Mirror.prototype.isProperty=function(){
+return this instanceof PropertyMirror;
+};
+Mirror.prototype.isInternalProperty=function(){
+return this instanceof InternalPropertyMirror;
+};
+Mirror.prototype.isFrame=function(){
+return this instanceof FrameMirror;
+};
+Mirror.prototype.isScript=function(){
+return this instanceof ScriptMirror;
+};
+Mirror.prototype.isContext=function(){
+return this instanceof ContextMirror;
+};
+Mirror.prototype.isScope=function(){
+return this instanceof ScopeMirror;
+};
+Mirror.prototype.isMap=function(){
+return this instanceof MapMirror;
+};
+Mirror.prototype.isSet=function(){
+return this instanceof SetMirror;
+};
+Mirror.prototype.isIterator=function(){
+return this instanceof IteratorMirror;
+};
+Mirror.prototype.allocateHandle_=function(){
+if(u)this.handle_=r++;
+};
+Mirror.prototype.allocateTransientHandle_=function(){
+this.handle_=s--;
+};
+Mirror.prototype.toText=function(){
+return"#<"+this.constructor.name+">";
+};
+function ValueMirror(H,v,I){
+%_Call(Mirror,this,H);
+this.value_=v;
+if(!I){
+this.allocateHandle_();
+}else{
+this.allocateTransientHandle_();
+}
+}
+inherits(ValueMirror,Mirror);
+Mirror.prototype.handle=function(){
+return this.handle_;
+};
+ValueMirror.prototype.isPrimitive=function(){
+var H=this.type();
+return H==='undefined'||
+H==='null'||
+H==='boolean'||
+H==='number'||
+H==='string'||
+H==='symbol';
+};
+ValueMirror.prototype.value=function(){
+return this.value_;
+};
+function UndefinedMirror(){
+%_Call(ValueMirror,this,q.UNDEFINED_TYPE,(void 0));
+}
+inherits(UndefinedMirror,ValueMirror);
+UndefinedMirror.prototype.toText=function(){
+return'undefined';
+};
+function NullMirror(){
+%_Call(ValueMirror,this,q.NULL_TYPE,null);
+}
+inherits(NullMirror,ValueMirror);
+NullMirror.prototype.toText=function(){
+return'null';
+};
+function BooleanMirror(v){
+%_Call(ValueMirror,this,q.BOOLEAN_TYPE,v);
+}
+inherits(BooleanMirror,ValueMirror);
+BooleanMirror.prototype.toText=function(){
+return this.value_?'true':'false';
+};
+function NumberMirror(v){
+%_Call(ValueMirror,this,q.NUMBER_TYPE,v);
+}
+inherits(NumberMirror,ValueMirror);
+NumberMirror.prototype.toText=function(){
+return %_NumberToString(this.value_);
+};
+function StringMirror(v){
+%_Call(ValueMirror,this,q.STRING_TYPE,v);
+}
+inherits(StringMirror,ValueMirror);
+StringMirror.prototype.length=function(){
+return this.value_.length;
+};
+StringMirror.prototype.getTruncatedValue=function(J){
+if(J!=-1&&this.length()>J){
+return this.value_.substring(0,J)+
+'... (length: '+this.length()+')';
+}
+return this.value_;
+};
+StringMirror.prototype.toText=function(){
+return this.getTruncatedValue(D);
+};
+function SymbolMirror(v){
+%_Call(ValueMirror,this,q.SYMBOL_TYPE,v);
+}
+inherits(SymbolMirror,ValueMirror);
+SymbolMirror.prototype.description=function(){
+return %SymbolDescription(%_ValueOf(this.value_));
+}
+SymbolMirror.prototype.toText=function(){
+return %_Call(o,this.value_);
+}
+function ObjectMirror(v,H,I){
+H=H||q.OBJECT_TYPE;
+%_Call(ValueMirror,this,H,v,I);
+}
+inherits(ObjectMirror,ValueMirror);
+ObjectMirror.prototype.className=function(){
+return %_ClassOf(this.value_);
+};
+ObjectMirror.prototype.constructorFunction=function(){
+return MakeMirror(%DebugGetProperty(this.value_,'constructor'));
+};
+ObjectMirror.prototype.prototypeObject=function(){
+return MakeMirror(%DebugGetProperty(this.value_,'prototype'));
+};
+ObjectMirror.prototype.protoObject=function(){
+return MakeMirror(%DebugGetPrototype(this.value_));
+};
+ObjectMirror.prototype.hasNamedInterceptor=function(){
+var K=%GetInterceptorInfo(this.value_);
+return(K&2)!=0;
+};
+ObjectMirror.prototype.hasIndexedInterceptor=function(){
+var K=%GetInterceptorInfo(this.value_);
+return(K&1)!=0;
+};
+ObjectMirror.prototype.propertyNames=function(){
+return %GetOwnPropertyKeys(this.value_,0);
+};
+ObjectMirror.prototype.properties=function(){
+var L=this.propertyNames();
+var M=new d(L.length);
+for(var N=0;N<L.length;N++){
+M[N]=this.property(L[N]);
+}
+return M;
+};
+ObjectMirror.prototype.internalProperties=function(){
+return ObjectMirror.GetInternalProperties(this.value_);
+}
+ObjectMirror.prototype.property=function(O){
+var P=%DebugGetPropertyDetails(this.value_,(%_ToName(O)));
+if(P){
+return new PropertyMirror(this,O,P);
+}
+return GetUndefinedMirror();
+};
+ObjectMirror.prototype.lookupProperty=function(v){
+var M=this.properties();
+for(var N=0;N<M.length;N++){
+var Q=M[N];
+if(Q.propertyType()!=E.AccessorConstant){
+if(%_ObjectEquals(Q.value_,v.value_)){
+return Q;
+}
+}
+}
+return GetUndefinedMirror();
+};
+ObjectMirror.prototype.referencedBy=function(R){
+var S=%DebugReferencedBy(this.value_,
+Mirror.prototype,R||0);
+for(var N=0;N<S.length;N++){
+S[N]=MakeMirror(S[N]);
+}
+return S;
+};
+ObjectMirror.prototype.toText=function(){
+var O;
+var A=this.constructorFunction();
+if(!A.isFunction()){
+O=this.className();
+}else{
+O=A.name();
+if(!O){
+O=this.className();
+}
+}
+return'#<'+O+'>';
+};
+ObjectMirror.GetInternalProperties=function(v){
+var M=%DebugGetInternalProperties(v);
+var S=[];
+for(var N=0;N<M.length;N+=2){
+S.push(new InternalPropertyMirror(M[N],M[N+1]));
+}
+return S;
+}
+function FunctionMirror(v){
+%_Call(ObjectMirror,this,v,q.FUNCTION_TYPE);
+this.resolved_=true;
+}
+inherits(FunctionMirror,ObjectMirror);
+FunctionMirror.prototype.resolved=function(){
+return this.resolved_;
+};
+FunctionMirror.prototype.name=function(){
+return %FunctionGetName(this.value_);
+};
+FunctionMirror.prototype.debugName=function(){
+return %FunctionGetDebugName(this.value_);
+}
+FunctionMirror.prototype.inferredName=function(){
+return %FunctionGetInferredName(this.value_);
+};
+FunctionMirror.prototype.source=function(){
+if(this.resolved()){
+return %FunctionToString(this.value_);
+}
+};
+FunctionMirror.prototype.script=function(){
+if(this.resolved()){
+if(this.script_){
+return this.script_;
+}
+var T=%FunctionGetScript(this.value_);
+if(T){
+return this.script_=MakeMirror(T);
+}
+}
+};
+FunctionMirror.prototype.sourcePosition_=function(){
+if(this.resolved()){
+return %FunctionGetScriptSourcePosition(this.value_);
+}
+};
+FunctionMirror.prototype.sourceLocation=function(){
+if(this.resolved()){
+var T=this.script();
+if(T){
+return T.locationFromPosition(this.sourcePosition_(),true);
+}
+}
+};
+FunctionMirror.prototype.constructedBy=function(U){
+if(this.resolved()){
+var S=%DebugConstructedBy(this.value_,U||0);
+for(var N=0;N<S.length;N++){
+S[N]=MakeMirror(S[N]);
+}
+return S;
+}else{
+return[];
+}
+};
+FunctionMirror.prototype.scopeCount=function(){
+if(this.resolved()){
+if((this.scopeCount_===(void 0))){
+this.scopeCount_=%GetFunctionScopeCount(this.value());
+}
+return this.scopeCount_;
+}else{
+return 0;
+}
+};
+FunctionMirror.prototype.scope=function(V){
+if(this.resolved()){
+return new ScopeMirror((void 0),this,V);
+}
+};
+FunctionMirror.prototype.toText=function(){
+return this.source();
+};
+function UnresolvedFunctionMirror(v){
+%_Call(ValueMirror,this,q.FUNCTION_TYPE,v);
+this.propertyCount_=0;
+this.elementCount_=0;
+this.resolved_=false;
+}
+inherits(UnresolvedFunctionMirror,FunctionMirror);
+UnresolvedFunctionMirror.prototype.className=function(){
+return'Function';
+};
+UnresolvedFunctionMirror.prototype.constructorFunction=function(){
+return GetUndefinedMirror();
+};
+UnresolvedFunctionMirror.prototype.prototypeObject=function(){
+return GetUndefinedMirror();
+};
+UnresolvedFunctionMirror.prototype.protoObject=function(){
+return GetUndefinedMirror();
+};
+UnresolvedFunctionMirror.prototype.name=function(){
+return this.value_;
+};
+UnresolvedFunctionMirror.prototype.inferredName=function(){
+return(void 0);
+};
+UnresolvedFunctionMirror.prototype.propertyNames=function(W,X){
+return[];
+};
+function ArrayMirror(v){
+%_Call(ObjectMirror,this,v);
+}
+inherits(ArrayMirror,ObjectMirror);
+ArrayMirror.prototype.length=function(){
+return this.value_.length;
+};
+ArrayMirror.prototype.indexedPropertiesFromRange=function(opt_from_index,
+opt_to_index){
+var Y=opt_from_index||0;
+var Z=opt_to_index||this.length()-1;
+if(Y>Z)return new d();
+var aa=new d(Z-Y+1);
+for(var N=Y;N<=Z;N++){
+var P=%DebugGetPropertyDetails(this.value_,(%_ToString(N)));
+var v;
+if(P){
+v=new PropertyMirror(this,N,P);
+}else{
+v=GetUndefinedMirror();
+}
+aa[N-Y]=v;
+}
+return aa;
+};
+function DateMirror(v){
+%_Call(ObjectMirror,this,v);
+}
+inherits(DateMirror,ObjectMirror);
+DateMirror.prototype.toText=function(){
+var ab=f(this.value_);
+return ab.substring(1,ab.length-1);
+};
+function RegExpMirror(v){
+%_Call(ObjectMirror,this,v,q.REGEXP_TYPE);
+}
+inherits(RegExpMirror,ObjectMirror);
+RegExpMirror.prototype.source=function(){
+return this.value_.source;
+};
+RegExpMirror.prototype.global=function(){
+return this.value_.global;
+};
+RegExpMirror.prototype.ignoreCase=function(){
+return this.value_.ignoreCase;
+};
+RegExpMirror.prototype.multiline=function(){
+return this.value_.multiline;
+};
+RegExpMirror.prototype.sticky=function(){
+return this.value_.sticky;
+};
+RegExpMirror.prototype.unicode=function(){
+return this.value_.unicode;
+};
+RegExpMirror.prototype.toText=function(){
+return"/"+this.source()+"/";
+};
+function ErrorMirror(v){
+%_Call(ObjectMirror,this,v,q.ERROR_TYPE);
+}
+inherits(ErrorMirror,ObjectMirror);
+ErrorMirror.prototype.message=function(){
+return this.value_.message;
+};
+ErrorMirror.prototype.toText=function(){
+var ac;
+try{
+ac=%_Call(c,this.value_);
+}catch(e){
+ac='#<Error>';
+}
+return ac;
+};
+function PromiseMirror(v){
+%_Call(ObjectMirror,this,v,q.PROMISE_TYPE);
+}
+inherits(PromiseMirror,ObjectMirror);
+function PromiseGetStatus_(v){
+var ad=%DebugGetProperty(v,k);
+if(ad==0)return"pending";
+if(ad==1)return"resolved";
+return"rejected";
+}
+function PromiseGetValue_(v){
+return %DebugGetProperty(v,l);
+}
+PromiseMirror.prototype.status=function(){
+return PromiseGetStatus_(this.value_);
+};
+PromiseMirror.prototype.promiseValue=function(){
+return MakeMirror(PromiseGetValue_(this.value_));
+};
+function MapMirror(v){
+%_Call(ObjectMirror,this,v,q.MAP_TYPE);
+}
+inherits(MapMirror,ObjectMirror);
+MapMirror.prototype.entries=function(ae){
+var S=[];
+if((%_ClassOf(this.value_)==='WeakMap')){
+var af=%GetWeakMapEntries(this.value_,ae||0);
+for(var N=0;N<af.length;N+=2){
+S.push({
+key:af[N],
+value:af[N+1]
+});
+}
+return S;
+}
+var ag=%_Call(h,this.value_);
+var ah;
+while((!ae||S.length<ae)&&
+!(ah=ag.next()).done){
+S.push({
+key:ah.value[0],
+value:ah.value[1]
+});
+}
+return S;
+};
+function SetMirror(v){
+%_Call(ObjectMirror,this,v,q.SET_TYPE);
+}
+inherits(SetMirror,ObjectMirror);
+function IteratorGetValues_(ag,ai,ae){
+var S=[];
+var ah;
+while((!ae||S.length<ae)&&
+!(ah=%_Call(ai,ag)).done){
+S.push(ah.value);
+}
+return S;
+}
+SetMirror.prototype.values=function(ae){
+if((%_ClassOf(this.value_)==='WeakSet')){
+return %GetWeakSetValues(this.value_,ae||0);
+}
+var ag=%_Call(n,this.value_);
+return IteratorGetValues_(ag,m,ae);
+};
+function IteratorMirror(v){
+%_Call(ObjectMirror,this,v,q.ITERATOR_TYPE);
+}
+inherits(IteratorMirror,ObjectMirror);
+IteratorMirror.prototype.preview=function(ae){
+if((%_ClassOf(this.value_)==='Map Iterator')){
+return IteratorGetValues_(%MapIteratorClone(this.value_),
+i,
+ae);
+}else if((%_ClassOf(this.value_)==='Set Iterator')){
+return IteratorGetValues_(%SetIteratorClone(this.value_),
+m,
+ae);
+}
+};
+function GeneratorMirror(v){
+%_Call(ObjectMirror,this,v,q.GENERATOR_TYPE);
+}
+inherits(GeneratorMirror,ObjectMirror);
+function GeneratorGetStatus_(v){
+var aj=%GeneratorGetContinuation(v);
+if(aj<0)return"running";
+if(aj==0)return"closed";
+return"suspended";
+}
+GeneratorMirror.prototype.status=function(){
+return GeneratorGetStatus_(this.value_);
+};
+GeneratorMirror.prototype.sourcePosition_=function(){
+return %GeneratorGetSourcePosition(this.value_);
+};
+GeneratorMirror.prototype.sourceLocation=function(){
+var ak=this.sourcePosition_();
+if(!(ak===(void 0))){
+var T=this.func().script();
+if(T){
+return T.locationFromPosition(ak,true);
+}
+}
+};
+GeneratorMirror.prototype.func=function(){
+if(!this.func_){
+this.func_=MakeMirror(%GeneratorGetFunction(this.value_));
+}
+return this.func_;
+};
+GeneratorMirror.prototype.context=function(){
+if(!this.context_){
+this.context_=new ContextMirror(%GeneratorGetContext(this.value_));
+}
+return this.context_;
+};
+GeneratorMirror.prototype.receiver=function(){
+if(!this.receiver_){
+this.receiver_=MakeMirror(%GeneratorGetReceiver(this.value_));
+}
+return this.receiver_;
+};
+function PropertyMirror(x,O,P){
+%_Call(Mirror,this,q.PROPERTY_TYPE);
+this.mirror_=x;
+this.name_=O;
+this.value_=P[0];
+this.details_=P[1];
+this.is_interceptor_=P[2];
+if(P.length>3){
+this.exception_=P[3];
+this.getter_=P[4];
+this.setter_=P[5];
+}
+}
+inherits(PropertyMirror,Mirror);
+PropertyMirror.prototype.isReadOnly=function(){
+return(this.attributes()&F.ReadOnly)!=0;
+};
+PropertyMirror.prototype.isEnum=function(){
+return(this.attributes()&F.DontEnum)==0;
+};
+PropertyMirror.prototype.canDelete=function(){
+return(this.attributes()&F.DontDelete)==0;
+};
+PropertyMirror.prototype.name=function(){
+return this.name_;
+};
+PropertyMirror.prototype.isIndexed=function(){
+for(var N=0;N<this.name_.length;N++){
+if(this.name_[N]<'0'||'9'<this.name_[N]){
+return false;
+}
+}
+return true;
+};
+PropertyMirror.prototype.value=function(){
+return MakeMirror(this.value_,false);
+};
+PropertyMirror.prototype.isException=function(){
+return this.exception_?true:false;
+};
+PropertyMirror.prototype.attributes=function(){
+return %DebugPropertyAttributesFromDetails(this.details_);
+};
+PropertyMirror.prototype.propertyType=function(){
+return %DebugPropertyTypeFromDetails(this.details_);
+};
+PropertyMirror.prototype.insertionIndex=function(){
+return %DebugPropertyIndexFromDetails(this.details_);
+};
+PropertyMirror.prototype.hasGetter=function(){
+return this.getter_?true:false;
+};
+PropertyMirror.prototype.hasSetter=function(){
+return this.setter_?true:false;
+};
+PropertyMirror.prototype.getter=function(){
+if(this.hasGetter()){
+return MakeMirror(this.getter_);
+}else{
+return GetUndefinedMirror();
+}
+};
+PropertyMirror.prototype.setter=function(){
+if(this.hasSetter()){
+return MakeMirror(this.setter_);
+}else{
+return GetUndefinedMirror();
+}
+};
+PropertyMirror.prototype.isNative=function(){
+return this.is_interceptor_||
+((this.propertyType()==E.AccessorConstant)&&
+!this.hasGetter()&&!this.hasSetter());
+};
+function InternalPropertyMirror(O,v){
+%_Call(Mirror,this,q.INTERNAL_PROPERTY_TYPE);
+this.name_=O;
+this.value_=v;
+}
+inherits(InternalPropertyMirror,Mirror);
+InternalPropertyMirror.prototype.name=function(){
+return this.name_;
+};
+InternalPropertyMirror.prototype.value=function(){
+return MakeMirror(this.value_,false);
+};
+var al=0;
+var am=1;
+var an=2;
+var ao=3;
+var ap=4;
+var aq=5;
+var ar=6;
+var as=7;
+var at=8;
+var au=9;
+var av=0;
+var aw=1;
+var ax=2;
+var ay=1<<0;
+var az=1<<1;
+var aA=7<<2;
+function FrameDetails(aB,V){
+this.break_id_=aB;
+this.details_=%GetFrameDetails(aB,V);
+}
+FrameDetails.prototype.frameId=function(){
+%CheckExecutionState(this.break_id_);
+return this.details_[al];
+};
+FrameDetails.prototype.receiver=function(){
+%CheckExecutionState(this.break_id_);
+return this.details_[am];
+};
+FrameDetails.prototype.func=function(){
+%CheckExecutionState(this.break_id_);
+return this.details_[an];
+};
+FrameDetails.prototype.isConstructCall=function(){
+%CheckExecutionState(this.break_id_);
+return this.details_[ar];
+};
+FrameDetails.prototype.isAtReturn=function(){
+%CheckExecutionState(this.break_id_);
+return this.details_[as];
+};
+FrameDetails.prototype.isDebuggerFrame=function(){
+%CheckExecutionState(this.break_id_);
+var aC=ay;
+return(this.details_[at]&aC)==aC;
+};
+FrameDetails.prototype.isOptimizedFrame=function(){
+%CheckExecutionState(this.break_id_);
+var aC=az;
+return(this.details_[at]&aC)==aC;
+};
+FrameDetails.prototype.isInlinedFrame=function(){
+return this.inlinedFrameIndex()>0;
+};
+FrameDetails.prototype.inlinedFrameIndex=function(){
+%CheckExecutionState(this.break_id_);
+var aC=aA;
+return(this.details_[at]&aC)>>2;
+};
+FrameDetails.prototype.argumentCount=function(){
+%CheckExecutionState(this.break_id_);
+return this.details_[ao];
+};
+FrameDetails.prototype.argumentName=function(V){
+%CheckExecutionState(this.break_id_);
+if(V>=0&&V<this.argumentCount()){
+return this.details_[au+
+V*ax+
+av];
+}
+};
+FrameDetails.prototype.argumentValue=function(V){
+%CheckExecutionState(this.break_id_);
+if(V>=0&&V<this.argumentCount()){
+return this.details_[au+
+V*ax+
+aw];
+}
+};
+FrameDetails.prototype.localCount=function(){
+%CheckExecutionState(this.break_id_);
+return this.details_[ap];
+};
+FrameDetails.prototype.sourcePosition=function(){
+%CheckExecutionState(this.break_id_);
+return this.details_[aq];
+};
+FrameDetails.prototype.localName=function(V){
+%CheckExecutionState(this.break_id_);
+if(V>=0&&V<this.localCount()){
+var aD=au+
+this.argumentCount()*ax;
+return this.details_[aD+
+V*ax+
+av];
+}
+};
+FrameDetails.prototype.localValue=function(V){
+%CheckExecutionState(this.break_id_);
+if(V>=0&&V<this.localCount()){
+var aD=au+
+this.argumentCount()*ax;
+return this.details_[aD+
+V*ax+
+aw];
+}
+};
+FrameDetails.prototype.returnValue=function(){
+%CheckExecutionState(this.break_id_);
+var aE=
+au+
+(this.argumentCount()+this.localCount())*ax;
+if(this.details_[as]){
+return this.details_[aE];
+}
+};
+FrameDetails.prototype.scopeCount=function(){
+if((this.scopeCount_===(void 0))){
+this.scopeCount_=%GetScopeCount(this.break_id_,this.frameId());
+}
+return this.scopeCount_;
+};
+FrameDetails.prototype.stepInPositionsImpl=function(){
+return %GetStepInPositions(this.break_id_,this.frameId());
+};
+function FrameMirror(aB,V){
+%_Call(Mirror,this,q.FRAME_TYPE);
+this.break_id_=aB;
+this.index_=V;
+this.details_=new FrameDetails(aB,V);
+}
+inherits(FrameMirror,Mirror);
+FrameMirror.prototype.details=function(){
+return this.details_;
+};
+FrameMirror.prototype.index=function(){
+return this.index_;
+};
+FrameMirror.prototype.func=function(){
+if(this.func_){
+return this.func_;
+}
+var aC=this.details_.func();
+if((%_IsFunction(aC))){
+return this.func_=MakeMirror(aC);
+}else{
+return new UnresolvedFunctionMirror(aC);
+}
+};
+FrameMirror.prototype.receiver=function(){
+return MakeMirror(this.details_.receiver());
+};
+FrameMirror.prototype.isConstructCall=function(){
+return this.details_.isConstructCall();
+};
+FrameMirror.prototype.isAtReturn=function(){
+return this.details_.isAtReturn();
+};
+FrameMirror.prototype.isDebuggerFrame=function(){
+return this.details_.isDebuggerFrame();
+};
+FrameMirror.prototype.isOptimizedFrame=function(){
+return this.details_.isOptimizedFrame();
+};
+FrameMirror.prototype.isInlinedFrame=function(){
+return this.details_.isInlinedFrame();
+};
+FrameMirror.prototype.inlinedFrameIndex=function(){
+return this.details_.inlinedFrameIndex();
+};
+FrameMirror.prototype.argumentCount=function(){
+return this.details_.argumentCount();
+};
+FrameMirror.prototype.argumentName=function(V){
+return this.details_.argumentName(V);
+};
+FrameMirror.prototype.argumentValue=function(V){
+return MakeMirror(this.details_.argumentValue(V));
+};
+FrameMirror.prototype.localCount=function(){
+return this.details_.localCount();
+};
+FrameMirror.prototype.localName=function(V){
+return this.details_.localName(V);
+};
+FrameMirror.prototype.localValue=function(V){
+return MakeMirror(this.details_.localValue(V));
+};
+FrameMirror.prototype.returnValue=function(){
+return MakeMirror(this.details_.returnValue());
+};
+FrameMirror.prototype.sourcePosition=function(){
+return this.details_.sourcePosition();
+};
+FrameMirror.prototype.sourceLocation=function(){
+var aF=this.func();
+if(aF.resolved()){
+var T=aF.script();
+if(T){
+return T.locationFromPosition(this.sourcePosition(),true);
+}
+}
+};
+FrameMirror.prototype.sourceLine=function(){
+var aG=this.sourceLocation();
+if(aG){
+return aG.line;
+}
+};
+FrameMirror.prototype.sourceColumn=function(){
+var aG=this.sourceLocation();
+if(aG){
+return aG.column;
+}
+};
+FrameMirror.prototype.sourceLineText=function(){
+var aG=this.sourceLocation();
+if(aG){
+return aG.sourceText();
+}
+};
+FrameMirror.prototype.scopeCount=function(){
+return this.details_.scopeCount();
+};
+FrameMirror.prototype.scope=function(V){
+return new ScopeMirror(this,(void 0),V);
+};
+FrameMirror.prototype.allScopes=function(aH){
+var aI=%GetAllScopesDetails(this.break_id_,
+this.details_.frameId(),
+this.details_.inlinedFrameIndex(),
+!!aH);
+var S=[];
+for(var N=0;N<aI.length;++N){
+S.push(new ScopeMirror(this,(void 0),N,aI[N]));
+}
+return S;
+};
+FrameMirror.prototype.stepInPositions=function(){
+var T=this.func().script();
+var aJ=this.func().sourcePosition_();
+var aK=this.details_.stepInPositionsImpl();
+var S=[];
+if(aK){
+for(var N=0;N<aK.length;N++){
+var aL={};
+var aM=T.locationFromPosition(aJ+aK[N],
+true);
+serializeLocationFields(aM,aL);
+var aN={
+position:aL
+};
+S.push(aN);
+}
+}
+return S;
+};
+FrameMirror.prototype.evaluate=function(source,disable_break,
+opt_context_object){
+return MakeMirror(%DebugEvaluate(this.break_id_,
+this.details_.frameId(),
+this.details_.inlinedFrameIndex(),
+source,
+(!!(disable_break)),
+opt_context_object));
+};
+FrameMirror.prototype.invocationText=function(){
+var S='';
+var aF=this.func();
+var aO=this.receiver();
+if(this.isConstructCall()){
+S+='new ';
+S+=aF.name()?aF.name():'[anonymous]';
+}else if(this.isDebuggerFrame()){
+S+='[debugger]';
+}else{
+var aP=
+!aO.className||(aO.className()!='global');
+if(aP){
+S+=aO.toText();
+}
+var Q=GetUndefinedMirror();
+if(aO.isObject()){
+for(var aQ=aO;
+!aQ.isNull()&&Q.isUndefined();
+aQ=aQ.protoObject()){
+Q=aQ.lookupProperty(aF);
+}
+}
+if(!Q.isUndefined()){
+if(!Q.isIndexed()){
+if(aP){
+S+='.';
+}
+S+=Q.name();
+}else{
+S+='[';
+S+=Q.name();
+S+=']';
+}
+if(aF.name()&&aF.name()!=Q.name()){
+S+='(aka '+aF.name()+')';
+}
+}else{
+if(aP){
+S+='.';
+}
+S+=aF.name()?aF.name():'[anonymous]';
+}
+}
+if(!this.isDebuggerFrame()){
+S+='(';
+for(var N=0;N<this.argumentCount();N++){
+if(N!=0)S+=', ';
+if(this.argumentName(N)){
+S+=this.argumentName(N);
+S+='=';
+}
+S+=this.argumentValue(N).toText();
+}
+S+=')';
+}
+if(this.isAtReturn()){
+S+=' returning ';
+S+=this.returnValue().toText();
+}
+return S;
+};
+FrameMirror.prototype.sourceAndPositionText=function(){
+var S='';
+var aF=this.func();
+if(aF.resolved()){
+var T=aF.script();
+if(T){
+if(T.name()){
+S+=T.name();
+}else{
+S+='[unnamed]';
+}
+if(!this.isDebuggerFrame()){
+var aG=this.sourceLocation();
+S+=' line ';
+S+=!(aG===(void 0))?(aG.line+1):'?';
+S+=' column ';
+S+=!(aG===(void 0))?(aG.column+1):'?';
+if(!(this.sourcePosition()===(void 0))){
+S+=' (position '+(this.sourcePosition()+1)+')';
+}
+}
+}else{
+S+='[no source]';
+}
+}else{
+S+='[unresolved]';
+}
+return S;
+};
+FrameMirror.prototype.localsText=function(){
+var S='';
+var aR=this.localCount();
+if(aR>0){
+for(var N=0;N<aR;++N){
+S+='      var ';
+S+=this.localName(N);
+S+=' = ';
+S+=this.localValue(N).toText();
+if(N<aR-1)S+='\n';
+}
+}
+return S;
+};
+FrameMirror.prototype.restart=function(){
+var S=%LiveEditRestartFrame(this.break_id_,this.index_);
+if((S===(void 0))){
+S="Failed to find requested frame";
+}
+return S;
+};
+FrameMirror.prototype.toText=function(aS){
+var S='';
+S+='#'+(this.index()<=9?'0':'')+this.index();
+S+=' ';
+S+=this.invocationText();
+S+=' ';
+S+=this.sourceAndPositionText();
+if(aS){
+S+='\n';
+S+=this.localsText();
+}
+return S;
+};
+var aT=0;
+var aU=1;
+var aV=2;
+function ScopeDetails(aW,aX,V,aY){
+if(aW){
+this.break_id_=aW.break_id_;
+this.details_=aY||
+%GetScopeDetails(aW.break_id_,
+aW.details_.frameId(),
+aW.details_.inlinedFrameIndex(),
+V);
+this.frame_id_=aW.details_.frameId();
+this.inlined_frame_id_=aW.details_.inlinedFrameIndex();
+}else{
+this.details_=aY||%GetFunctionScopeDetails(aX.value(),V);
+this.fun_value_=aX.value();
+this.break_id_=(void 0);
+}
+this.index_=V;
+}
+ScopeDetails.prototype.type=function(){
+if(!(this.break_id_===(void 0))){
+%CheckExecutionState(this.break_id_);
+}
+return this.details_[aT];
+};
+ScopeDetails.prototype.object=function(){
+if(!(this.break_id_===(void 0))){
+%CheckExecutionState(this.break_id_);
+}
+return this.details_[aU];
+};
+ScopeDetails.prototype.name=function(){
+if(!(this.break_id_===(void 0))){
+%CheckExecutionState(this.break_id_);
+}
+return this.details_[aV];
+};
+ScopeDetails.prototype.setVariableValueImpl=function(O,aZ){
+var ba;
+if(!(this.break_id_===(void 0))){
+%CheckExecutionState(this.break_id_);
+ba=%SetScopeVariableValue(this.break_id_,this.frame_id_,
+this.inlined_frame_id_,this.index_,O,aZ);
+}else{
+ba=%SetScopeVariableValue(this.fun_value_,null,null,this.index_,
+O,aZ);
+}
+if(!ba)throw g(2,"Failed to set variable value");
+};
+function ScopeMirror(aW,aX,V,aY){
+%_Call(Mirror,this,q.SCOPE_TYPE);
+if(aW){
+this.frame_index_=aW.index_;
+}else{
+this.frame_index_=(void 0);
+}
+this.scope_index_=V;
+this.details_=new ScopeDetails(aW,aX,V,aY);
+}
+inherits(ScopeMirror,Mirror);
+ScopeMirror.prototype.details=function(){
+return this.details_;
+};
+ScopeMirror.prototype.frameIndex=function(){
+return this.frame_index_;
+};
+ScopeMirror.prototype.scopeIndex=function(){
+return this.scope_index_;
+};
+ScopeMirror.prototype.scopeType=function(){
+return this.details_.type();
+};
+ScopeMirror.prototype.scopeObject=function(){
+var I=this.scopeType()==G.Local||
+this.scopeType()==G.Closure||
+this.scopeType()==G.Script;
+return MakeMirror(this.details_.object(),I);
+};
+ScopeMirror.prototype.setVariableValue=function(O,aZ){
+this.details_.setVariableValueImpl(O,aZ);
+};
+function ScriptMirror(T){
+%_Call(Mirror,this,q.SCRIPT_TYPE);
+this.script_=T;
+this.context_=new ContextMirror(T.context_data);
+this.allocateHandle_();
+}
+inherits(ScriptMirror,Mirror);
+ScriptMirror.prototype.value=function(){
+return this.script_;
+};
+ScriptMirror.prototype.name=function(){
+return this.script_.name||this.script_.nameOrSourceURL();
+};
+ScriptMirror.prototype.id=function(){
+return this.script_.id;
+};
+ScriptMirror.prototype.source=function(){
+return this.script_.source;
+};
+ScriptMirror.prototype.setSource=function(bb){
+%DebugSetScriptSource(this.script_,bb);
+};
+ScriptMirror.prototype.lineOffset=function(){
+return this.script_.line_offset;
+};
+ScriptMirror.prototype.columnOffset=function(){
+return this.script_.column_offset;
+};
+ScriptMirror.prototype.data=function(){
+return this.script_.data;
+};
+ScriptMirror.prototype.scriptType=function(){
+return this.script_.type;
+};
+ScriptMirror.prototype.compilationType=function(){
+return this.script_.compilation_type;
+};
+ScriptMirror.prototype.lineCount=function(){
+return this.script_.lineCount();
+};
+ScriptMirror.prototype.locationFromPosition=function(
+position,include_resource_offset){
+return this.script_.locationFromPosition(position,include_resource_offset);
+};
+ScriptMirror.prototype.sourceSlice=function(bc,bd){
+return this.script_.sourceSlice(bc,bd);
+};
+ScriptMirror.prototype.context=function(){
+return this.context_;
+};
+ScriptMirror.prototype.evalFromScript=function(){
+return MakeMirror(this.script_.eval_from_script);
+};
+ScriptMirror.prototype.evalFromFunctionName=function(){
+return MakeMirror(this.script_.eval_from_function_name);
+};
+ScriptMirror.prototype.evalFromLocation=function(){
+var be=this.evalFromScript();
+if(!be.isUndefined()){
+var bf=this.script_.eval_from_script_position;
+return be.locationFromPosition(bf,true);
+}
+};
+ScriptMirror.prototype.toText=function(){
+var S='';
+S+=this.name();
+S+=' (lines: ';
+if(this.lineOffset()>0){
+S+=this.lineOffset();
+S+='-';
+S+=this.lineOffset()+this.lineCount()-1;
+}else{
+S+=this.lineCount();
+}
+S+=')';
+return S;
+};
+function ContextMirror(bg){
+%_Call(Mirror,this,q.CONTEXT_TYPE);
+this.data_=bg;
+this.allocateHandle_();
+}
+inherits(ContextMirror,Mirror);
+ContextMirror.prototype.data=function(){
+return this.data_;
+};
+function MakeMirrorSerializer(P,bh){
+return new JSONProtocolSerializer(P,bh);
+}
+function JSONProtocolSerializer(P,bh){
+this.details_=P;
+this.options_=bh;
+this.mirrors_=[];
+}
+JSONProtocolSerializer.prototype.serializeReference=function(x){
+return this.serialize_(x,true,true);
+};
+JSONProtocolSerializer.prototype.serializeValue=function(x){
+var bi=this.serialize_(x,false,true);
+return bi;
+};
+JSONProtocolSerializer.prototype.serializeReferencedObjects=function(){
+var bj=[];
+var bk=this.mirrors_.length;
+for(var N=0;N<bk;N++){
+bj.push(this.serialize_(this.mirrors_[N],false,false));
+}
+return bj;
+};
+JSONProtocolSerializer.prototype.includeSource_=function(){
+return this.options_&&this.options_.includeSource;
+};
+JSONProtocolSerializer.prototype.inlineRefs_=function(){
+return this.options_&&this.options_.inlineRefs;
+};
+JSONProtocolSerializer.prototype.maxStringLength_=function(){
+if((this.options_===(void 0))||
+(this.options_.maxStringLength===(void 0))){
+return D;
+}
+return this.options_.maxStringLength;
+};
+JSONProtocolSerializer.prototype.add_=function(x){
+for(var N=0;N<this.mirrors_.length;N++){
+if(this.mirrors_[N]===x){
+return;
+}
+}
+this.mirrors_.push(x);
+};
+JSONProtocolSerializer.prototype.serializeReferenceWithDisplayData_=
+function(x){
+var bl={};
+bl.ref=x.handle();
+bl.type=x.type();
+switch(x.type()){
+case q.UNDEFINED_TYPE:
+case q.NULL_TYPE:
+case q.BOOLEAN_TYPE:
+case q.NUMBER_TYPE:
+bl.value=x.value();
+break;
+case q.STRING_TYPE:
+bl.value=x.getTruncatedValue(this.maxStringLength_());
+break;
+case q.SYMBOL_TYPE:
+bl.description=x.description();
+break;
+case q.FUNCTION_TYPE:
+bl.name=x.name();
+bl.inferredName=x.inferredName();
+if(x.script()){
+bl.scriptId=x.script().id();
+}
+break;
+case q.ERROR_TYPE:
+case q.REGEXP_TYPE:
+bl.value=x.toText();
+break;
+case q.OBJECT_TYPE:
+bl.className=x.className();
+break;
+}
+return bl;
+};
+JSONProtocolSerializer.prototype.serialize_=function(x,reference,
+P){
+if(reference&&
+(x.isValue()||x.isScript()||x.isContext())){
+if(this.inlineRefs_()&&x.isValue()){
+return this.serializeReferenceWithDisplayData_(x);
+}else{
+this.add_(x);
+return{'ref':x.handle()};
+}
+}
+var bj={};
+if(x.isValue()||x.isScript()||x.isContext()){
+bj.handle=x.handle();
+}
+bj.type=x.type();
+switch(x.type()){
+case q.UNDEFINED_TYPE:
+case q.NULL_TYPE:
+break;
+case q.BOOLEAN_TYPE:
+bj.value=x.value();
+break;
+case q.NUMBER_TYPE:
+bj.value=NumberToJSON_(x.value());
+break;
+case q.STRING_TYPE:
+if(this.maxStringLength_()!=-1&&
+x.length()>this.maxStringLength_()){
+var bm=x.getTruncatedValue(this.maxStringLength_());
+bj.value=bm;
+bj.fromIndex=0;
+bj.toIndex=this.maxStringLength_();
+}else{
+bj.value=x.value();
+}
+bj.length=x.length();
+break;
+case q.SYMBOL_TYPE:
+bj.description=x.description();
+break;
+case q.OBJECT_TYPE:
+case q.FUNCTION_TYPE:
+case q.ERROR_TYPE:
+case q.REGEXP_TYPE:
+case q.PROMISE_TYPE:
+case q.GENERATOR_TYPE:
+this.serializeObject_(x,bj,P);
+break;
+case q.PROPERTY_TYPE:
+case q.INTERNAL_PROPERTY_TYPE:
+throw g(2,
+'PropertyMirror cannot be serialized independently');
+break;
+case q.FRAME_TYPE:
+this.serializeFrame_(x,bj);
+break;
+case q.SCOPE_TYPE:
+this.serializeScope_(x,bj);
+break;
+case q.SCRIPT_TYPE:
+if(x.name()){
+bj.name=x.name();
+}
+bj.id=x.id();
+bj.lineOffset=x.lineOffset();
+bj.columnOffset=x.columnOffset();
+bj.lineCount=x.lineCount();
+if(x.data()){
+bj.data=x.data();
+}
+if(this.includeSource_()){
+bj.source=x.source();
+}else{
+var bn=x.source().substring(0,80);
+bj.sourceStart=bn;
+}
+bj.sourceLength=x.source().length;
+bj.scriptType=x.scriptType();
+bj.compilationType=x.compilationType();
+if(x.compilationType()==1&&
+x.evalFromScript()){
+bj.evalFromScript=
+this.serializeReference(x.evalFromScript());
+var bo=x.evalFromLocation();
+if(bo){
+bj.evalFromLocation={line:bo.line,
+column:bo.column};
+}
+if(x.evalFromFunctionName()){
+bj.evalFromFunctionName=x.evalFromFunctionName();
+}
+}
+if(x.context()){
+bj.context=this.serializeReference(x.context());
+}
+break;
+case q.CONTEXT_TYPE:
+bj.data=x.data();
+break;
+}
+bj.text=x.toText();
+return bj;
+};
+JSONProtocolSerializer.prototype.serializeObject_=function(x,bj,
+P){
+bj.className=x.className();
+bj.constructorFunction=
+this.serializeReference(x.constructorFunction());
+bj.protoObject=this.serializeReference(x.protoObject());
+bj.prototypeObject=this.serializeReference(x.prototypeObject());
+if(x.hasNamedInterceptor()){
+bj.namedInterceptor=true;
+}
+if(x.hasIndexedInterceptor()){
+bj.indexedInterceptor=true;
+}
+if(x.isFunction()){
+bj.name=x.name();
+if(!(x.inferredName()===(void 0))){
+bj.inferredName=x.inferredName();
+}
+bj.resolved=x.resolved();
+if(x.resolved()){
+bj.source=x.source();
+}
+if(x.script()){
+bj.script=this.serializeReference(x.script());
+bj.scriptId=x.script().id();
+serializeLocationFields(x.sourceLocation(),bj);
+}
+bj.scopes=[];
+for(var N=0;N<x.scopeCount();N++){
+var bp=x.scope(N);
+bj.scopes.push({
+type:bp.scopeType(),
+index:N
+});
+}
+}
+if(x.isGenerator()){
+bj.status=x.status();
+bj.func=this.serializeReference(x.func())
+bj.receiver=this.serializeReference(x.receiver())
+serializeLocationFields(x.sourceLocation(),bj);
+}
+if(x.isDate()){
+bj.value=x.value();
+}
+if(x.isPromise()){
+bj.status=x.status();
+bj.promiseValue=this.serializeReference(x.promiseValue());
+}
+var M=x.propertyNames();
+for(var N=0;N<M.length;N++){
+var bq=x.property(M[N]);
+M[N]=this.serializeProperty_(bq);
+if(P){
+this.add_(bq.value());
+}
+}
+bj.properties=M;
+var br=x.internalProperties();
+if(br.length>0){
+var bs=[];
+for(var N=0;N<br.length;N++){
+bs.push(this.serializeInternalProperty_(br[N]));
+}
+bj.internalProperties=bs;
+}
+};
+function serializeLocationFields(aG,bj){
+if(!aG){
+return;
+}
+bj.position=aG.position;
+var bt=aG.line;
+if(!(bt===(void 0))){
+bj.line=bt;
+}
+var bu=aG.column;
+if(!(bu===(void 0))){
+bj.column=bu;
+}
+}
+JSONProtocolSerializer.prototype.serializeProperty_=function(bq){
+var S={};
+S.name=bq.name();
+var bv=bq.value();
+if(this.inlineRefs_()&&bv.isValue()){
+S.value=this.serializeReferenceWithDisplayData_(bv);
+}else{
+if(bq.attributes()!=F.None){
+S.attributes=bq.attributes();
+}
+S.propertyType=bq.propertyType();
+S.ref=bv.handle();
+}
+return S;
+};
+JSONProtocolSerializer.prototype.serializeInternalProperty_=
+function(bq){
+var S={};
+S.name=bq.name();
+var bv=bq.value();
+if(this.inlineRefs_()&&bv.isValue()){
+S.value=this.serializeReferenceWithDisplayData_(bv);
+}else{
+S.ref=bv.handle();
+}
+return S;
+};
+JSONProtocolSerializer.prototype.serializeFrame_=function(x,bj){
+bj.index=x.index();
+bj.receiver=this.serializeReference(x.receiver());
+var aF=x.func();
+bj.func=this.serializeReference(aF);
+var T=aF.script();
+if(T){
+bj.script=this.serializeReference(T);
+}
+bj.constructCall=x.isConstructCall();
+bj.atReturn=x.isAtReturn();
+if(x.isAtReturn()){
+bj.returnValue=this.serializeReference(x.returnValue());
+}
+bj.debuggerFrame=x.isDebuggerFrame();
+var K=new d(x.argumentCount());
+for(var N=0;N<x.argumentCount();N++){
+var bw={};
+var bx=x.argumentName(N);
+if(bx){
+bw.name=bx;
+}
+bw.value=this.serializeReference(x.argumentValue(N));
+K[N]=bw;
+}
+bj.arguments=K;
+var K=new d(x.localCount());
+for(var N=0;N<x.localCount();N++){
+var by={};
+by.name=x.localName(N);
+by.value=this.serializeReference(x.localValue(N));
+K[N]=by;
+}
+bj.locals=K;
+serializeLocationFields(x.sourceLocation(),bj);
+var bz=x.sourceLineText();
+if(!(bz===(void 0))){
+bj.sourceLineText=bz;
+}
+bj.scopes=[];
+for(var N=0;N<x.scopeCount();N++){
+var bp=x.scope(N);
+bj.scopes.push({
+type:bp.scopeType(),
+index:N
+});
+}
+};
+JSONProtocolSerializer.prototype.serializeScope_=function(x,bj){
+bj.index=x.scopeIndex();
+bj.frameIndex=x.frameIndex();
+bj.type=x.scopeType();
+bj.object=this.inlineRefs_()?
+this.serializeValue(x.scopeObject()):
+this.serializeReference(x.scopeObject());
+};
+function NumberToJSON_(v){
+if(e(v)){
+return'NaN';
+}
+if(!(%_IsSmi(%IS_VAR(v))||((v==v)&&(v!=1/0)&&(v!=-1/0)))){
+if(v>0){
+return'Infinity';
+}else{
+return'-Infinity';
+}
+}
+return v;
+}
+b.InstallFunctions(a,2,[
+"MakeMirror",MakeMirror,
+"MakeMirrorSerializer",MakeMirrorSerializer,
+"LookupMirror",LookupMirror,
+"ToggleMirrorCache",ToggleMirrorCache,
+"MirrorCacheIsEmpty",MirrorCacheIsEmpty,
+]);
+b.InstallConstants(a,[
+"ScopeType",G,
+"PropertyType",E,
+"PropertyAttribute",F,
+"Mirror",Mirror,
+"ValueMirror",ValueMirror,
+"UndefinedMirror",UndefinedMirror,
+"NullMirror",NullMirror,
+"BooleanMirror",BooleanMirror,
+"NumberMirror",NumberMirror,
+"StringMirror",StringMirror,
+"SymbolMirror",SymbolMirror,
+"ObjectMirror",ObjectMirror,
+"FunctionMirror",FunctionMirror,
+"UnresolvedFunctionMirror",UnresolvedFunctionMirror,
+"ArrayMirror",ArrayMirror,
+"DateMirror",DateMirror,
+"RegExpMirror",RegExpMirror,
+"ErrorMirror",ErrorMirror,
+"PromiseMirror",PromiseMirror,
+"MapMirror",MapMirror,
+"SetMirror",SetMirror,
+"IteratorMirror",IteratorMirror,
+"GeneratorMirror",GeneratorMirror,
+"PropertyMirror",PropertyMirror,
+"InternalPropertyMirror",InternalPropertyMirror,
+"FrameMirror",FrameMirror,
+"ScriptMirror",ScriptMirror,
+"ScopeMirror",ScopeMirror,
+"FrameDetails",FrameDetails,
+]);
+b.InstallFunctions(b,2,[
+"ClearMirrorCache",ClearMirrorCache
+]);
+b.Export(function(bA){
+bA.MirrorType=q;
+});
+})
+
+debugN�
+(function(a,b){
+"use strict";
+var c=a.FrameMirror;
+var d=a.Array;
+var e=a.RegExp;
+var f=a.isNaN;
+var g=a.JSON.parse;
+var h=a.JSON.stringify;
+var i=a.LookupMirror;
+var j;
+var k;
+var l=a.MakeMirror;
+var m=a.MakeMirrorSerializer;
+var n=a.Math.min;
+var o=a.Mirror;
+var p;
+var q=a.parseInt;
+var r=a.ValueMirror;
+b.Import(function(s){
+j=s.MakeError;
+k=s.MakeTypeError;
+p=s.MirrorType;
+});
+var t=10;
+var u={};
+var v=/^(?:\s*(?:\/\*.*?\*\/)*)*/;
+u.DebugEvent={Break:1,
+Exception:2,
+NewFunction:3,
+BeforeCompile:4,
+AfterCompile:5,
+CompileError:6,
+PromiseEvent:7,
+AsyncTaskEvent:8};
+u.ExceptionBreak={Caught:0,
+Uncaught:1};
+u.StepAction={StepOut:0,
+StepNext:1,
+StepIn:2,
+StepFrame:3};
+u.ScriptType={Native:0,
+Extension:1,
+Normal:2};
+u.ScriptCompilationType={Host:0,
+Eval:1,
+JSON:2};
+u.ScriptBreakPointType={ScriptId:0,
+ScriptName:1,
+ScriptRegExp:2};
+u.BreakPositionAlignment={
+Statement:0,
+BreakPosition:1
+};
+function ScriptTypeFlag(w){
+return(1<<w);
+}
+var x=0;
+var y=1;
+var z=[];
+var A=[];
+var B={
+breakPointsActive:{
+value:true,
+getValue:function(){return this.value;},
+setValue:function(C){
+this.value=!!C;
+%SetBreakPointsActive(this.value);
+}
+},
+breakOnCaughtException:{
+getValue:function(){return u.isBreakOnException();},
+setValue:function(C){
+if(C){
+u.setBreakOnException();
+}else{
+u.clearBreakOnException();
+}
+}
+},
+breakOnUncaughtException:{
+getValue:function(){return u.isBreakOnUncaughtException();},
+setValue:function(C){
+if(C){
+u.setBreakOnUncaughtException();
+}else{
+u.clearBreakOnUncaughtException();
+}
+}
+},
+};
+function MakeBreakPoint(D,E){
+var F=new BreakPoint(D,E);
+z.push(F);
+return F;
+}
+function BreakPoint(D,E){
+this.source_position_=D;
+if(E){
+this.script_break_point_=E;
+}else{
+this.number_=y++;
+}
+this.hit_count_=0;
+this.active_=true;
+this.condition_=null;
+this.ignoreCount_=0;
+}
+BreakPoint.prototype.number=function(){
+return this.number_;
+};
+BreakPoint.prototype.func=function(){
+return this.func_;
+};
+BreakPoint.prototype.source_position=function(){
+return this.source_position_;
+};
+BreakPoint.prototype.hit_count=function(){
+return this.hit_count_;
+};
+BreakPoint.prototype.active=function(){
+if(this.script_break_point()){
+return this.script_break_point().active();
+}
+return this.active_;
+};
+BreakPoint.prototype.condition=function(){
+if(this.script_break_point()&&this.script_break_point().condition()){
+return this.script_break_point().condition();
+}
+return this.condition_;
+};
+BreakPoint.prototype.ignoreCount=function(){
+return this.ignoreCount_;
+};
+BreakPoint.prototype.script_break_point=function(){
+return this.script_break_point_;
+};
+BreakPoint.prototype.enable=function(){
+this.active_=true;
+};
+BreakPoint.prototype.disable=function(){
+this.active_=false;
+};
+BreakPoint.prototype.setCondition=function(G){
+this.condition_=G;
+};
+BreakPoint.prototype.setIgnoreCount=function(H){
+this.ignoreCount_=H;
+};
+BreakPoint.prototype.isTriggered=function(I){
+if(!this.active())return false;
+if(this.condition()){
+try{
+var J=I.frame(0).evaluate(this.condition());
+if(!(J instanceof r)||!J.value_){
+return false;
+}
+}catch(e){
+return false;
+}
+}
+this.hit_count_++;
+if(this.script_break_point_){
+this.script_break_point_.hit_count_++;
+}
+if(this.ignoreCount_>0){
+this.ignoreCount_--;
+return false;
+}
+return true;
+};
+function IsBreakPointTriggered(K,F){
+return F.isTriggered(MakeExecutionState(K));
+}
+function ScriptBreakPoint(w,script_id_or_name,opt_line,opt_column,
+opt_groupId,opt_position_alignment){
+this.type_=w;
+if(w==u.ScriptBreakPointType.ScriptId){
+this.script_id_=script_id_or_name;
+}else if(w==u.ScriptBreakPointType.ScriptName){
+this.script_name_=script_id_or_name;
+}else if(w==u.ScriptBreakPointType.ScriptRegExp){
+this.script_regexp_object_=new e(script_id_or_name);
+}else{
+throw j(2,"Unexpected breakpoint type "+w);
+}
+this.line_=opt_line||0;
+this.column_=opt_column;
+this.groupId_=opt_groupId;
+this.position_alignment_=(opt_position_alignment===(void 0))
+?u.BreakPositionAlignment.Statement:opt_position_alignment;
+this.hit_count_=0;
+this.active_=true;
+this.condition_=null;
+this.ignoreCount_=0;
+this.break_points_=[];
+}
+ScriptBreakPoint.prototype.cloneForOtherScript=function(L){
+var M=new ScriptBreakPoint(u.ScriptBreakPointType.ScriptId,
+L.id,this.line_,this.column_,this.groupId_,
+this.position_alignment_);
+M.number_=y++;
+A.push(M);
+M.hit_count_=this.hit_count_;
+M.active_=this.active_;
+M.condition_=this.condition_;
+M.ignoreCount_=this.ignoreCount_;
+return M;
+};
+ScriptBreakPoint.prototype.number=function(){
+return this.number_;
+};
+ScriptBreakPoint.prototype.groupId=function(){
+return this.groupId_;
+};
+ScriptBreakPoint.prototype.type=function(){
+return this.type_;
+};
+ScriptBreakPoint.prototype.script_id=function(){
+return this.script_id_;
+};
+ScriptBreakPoint.prototype.script_name=function(){
+return this.script_name_;
+};
+ScriptBreakPoint.prototype.script_regexp_object=function(){
+return this.script_regexp_object_;
+};
+ScriptBreakPoint.prototype.line=function(){
+return this.line_;
+};
+ScriptBreakPoint.prototype.column=function(){
+return this.column_;
+};
+ScriptBreakPoint.prototype.actual_locations=function(){
+var N=[];
+for(var O=0;O<this.break_points_.length;O++){
+N.push(this.break_points_[O].actual_location);
+}
+return N;
+};
+ScriptBreakPoint.prototype.update_positions=function(P,Q){
+this.line_=P;
+this.column_=Q;
+};
+ScriptBreakPoint.prototype.hit_count=function(){
+return this.hit_count_;
+};
+ScriptBreakPoint.prototype.active=function(){
+return this.active_;
+};
+ScriptBreakPoint.prototype.condition=function(){
+return this.condition_;
+};
+ScriptBreakPoint.prototype.ignoreCount=function(){
+return this.ignoreCount_;
+};
+ScriptBreakPoint.prototype.enable=function(){
+this.active_=true;
+};
+ScriptBreakPoint.prototype.disable=function(){
+this.active_=false;
+};
+ScriptBreakPoint.prototype.setCondition=function(G){
+this.condition_=G;
+};
+ScriptBreakPoint.prototype.setIgnoreCount=function(H){
+this.ignoreCount_=H;
+for(var O=0;O<this.break_points_.length;O++){
+this.break_points_[O].setIgnoreCount(H);
+}
+};
+ScriptBreakPoint.prototype.matchesScript=function(R){
+if(this.type_==u.ScriptBreakPointType.ScriptId){
+return this.script_id_==R.id;
+}else{
+if(!(R.line_offset<=this.line_&&
+this.line_<R.line_offset+R.lineCount())){
+return false;
+}
+if(this.type_==u.ScriptBreakPointType.ScriptName){
+return this.script_name_==R.nameOrSourceURL();
+}else if(this.type_==u.ScriptBreakPointType.ScriptRegExp){
+return this.script_regexp_object_.test(R.nameOrSourceURL());
+}else{
+throw j(2,"Unexpected breakpoint type "+this.type_);
+}
+}
+};
+ScriptBreakPoint.prototype.set=function(R){
+var Q=this.column();
+var P=this.line();
+if((Q===(void 0))){
+var S=R.sourceLine(this.line());
+if(!R.sourceColumnStart_){
+R.sourceColumnStart_=new d(R.lineCount());
+}
+if((R.sourceColumnStart_[P]===(void 0))){
+R.sourceColumnStart_[P]=
+S.match(v)[0].length;
+}
+Q=R.sourceColumnStart_[P];
+}
+var T=u.findScriptSourcePosition(R,this.line(),Q);
+if((T===null))return;
+var F=MakeBreakPoint(T,this);
+F.setIgnoreCount(this.ignoreCount());
+var U=%SetScriptBreakPoint(R,T,
+this.position_alignment_,
+F);
+if((U===(void 0))){
+U=T;
+}
+var V=R.locationFromPosition(U,true);
+F.actual_location={line:V.line,
+column:V.column,
+script_id:R.id};
+this.break_points_.push(F);
+return F;
+};
+ScriptBreakPoint.prototype.clear=function(){
+var W=[];
+for(var O=0;O<z.length;O++){
+if(z[O].script_break_point()&&
+z[O].script_break_point()===this){
+%ClearBreakPoint(z[O]);
+}else{
+W.push(z[O]);
+}
+}
+z=W;
+this.break_points_=[];
+};
+function UpdateScriptBreakPoints(R){
+for(var O=0;O<A.length;O++){
+var F=A[O];
+if((F.type()==u.ScriptBreakPointType.ScriptName||
+F.type()==u.ScriptBreakPointType.ScriptRegExp)&&
+F.matchesScript(R)){
+F.set(R);
+}
+}
+}
+function GetScriptBreakPoints(R){
+var X=[];
+for(var O=0;O<A.length;O++){
+if(A[O].matchesScript(R)){
+X.push(A[O]);
+}
+}
+return X;
+}
+u.setListener=function(Y,Z){
+if(!(%_IsFunction(Y))&&!(Y===(void 0))&&!(Y===null)){
+throw k(32);
+}
+%SetDebugEventListener(Y,Z);
+};
+u.breakLocations=function(aa,ab){
+if(!(%_IsFunction(aa)))throw k(32);
+var ac=(ab===(void 0))
+?u.BreakPositionAlignment.Statement:ab;
+return %GetBreakLocations(aa,ac);
+};
+u.findScript=function(ad){
+if((%_IsFunction(ad))){
+return %FunctionGetScript(ad);
+}else if((%_IsRegExp(ad))){
+var ae=u.scripts();
+var af=null;
+var ag=0;
+for(var O in ae){
+var R=ae[O];
+if(ad.test(R.name)){
+af=R;
+ag++;
+}
+}
+if(ag==1){
+return af;
+}else{
+return(void 0);
+}
+}else{
+return %GetScript(ad);
+}
+};
+u.scriptSource=function(ad){
+return this.findScript(ad).source;
+};
+u.source=function(aa){
+if(!(%_IsFunction(aa)))throw k(32);
+return %FunctionGetSourceCode(aa);
+};
+u.sourcePosition=function(aa){
+if(!(%_IsFunction(aa)))throw k(32);
+return %FunctionGetScriptSourcePosition(aa);
+};
+u.findFunctionSourceLocation=function(ah,ai,aj){
+var R=%FunctionGetScript(ah);
+var ak=%FunctionGetScriptSourcePosition(ah);
+return R.locationFromLine(ai,aj,ak);
+};
+u.findScriptSourcePosition=function(R,ai,aj){
+var al=R.locationFromLine(ai,aj);
+return al?al.position:null;
+};
+u.findBreakPoint=function(am,an){
+var F;
+for(var O=0;O<z.length;O++){
+if(z[O].number()==am){
+F=z[O];
+if(an){
+z.splice(O,1);
+}
+break;
+}
+}
+if(F){
+return F;
+}else{
+return this.findScriptBreakPoint(am,an);
+}
+};
+u.findBreakPointActualLocations=function(am){
+for(var O=0;O<A.length;O++){
+if(A[O].number()==am){
+return A[O].actual_locations();
+}
+}
+for(var O=0;O<z.length;O++){
+if(z[O].number()==am){
+return[z[O].actual_location];
+}
+}
+return[];
+};
+u.setBreakPoint=function(ah,ai,aj,ao){
+if(!(%_IsFunction(ah)))throw k(32);
+if(%FunctionIsAPIFunction(ah)){
+throw j(2,'Cannot set break point in native code.');
+}
+var ap=
+this.findFunctionSourceLocation(ah,ai,aj).position;
+var D=ap-this.sourcePosition(ah);
+var R=%FunctionGetScript(ah);
+if(R.type==u.ScriptType.Native){
+throw j(2,'Cannot set break point in native code.');
+}
+if(R&&R.id){
+D+=%FunctionGetScriptSourcePosition(ah);
+var al=R.locationFromPosition(D,false);
+return this.setScriptBreakPointById(R.id,
+al.line,al.column,
+ao);
+}else{
+var F=MakeBreakPoint(D);
+var U=
+%SetFunctionBreakPoint(ah,D,F);
+U+=this.sourcePosition(ah);
+var V=R.locationFromPosition(U,true);
+F.actual_location={line:V.line,
+column:V.column,
+script_id:R.id};
+F.setCondition(ao);
+return F.number();
+}
+};
+u.setBreakPointByScriptIdAndPosition=function(script_id,T,
+G,enabled,
+opt_position_alignment)
+{
+var F=MakeBreakPoint(T);
+F.setCondition(G);
+if(!enabled){
+F.disable();
+}
+var ae=this.scripts();
+var aq=(opt_position_alignment===(void 0))
+?u.BreakPositionAlignment.Statement:opt_position_alignment;
+for(var O=0;O<ae.length;O++){
+if(script_id==ae[O].id){
+F.actual_position=%SetScriptBreakPoint(ae[O],T,
+aq,F);
+break;
+}
+}
+return F;
+};
+u.enableBreakPoint=function(am){
+var F=this.findBreakPoint(am,false);
+if(F){
+F.enable();
+}
+};
+u.disableBreakPoint=function(am){
+var F=this.findBreakPoint(am,false);
+if(F){
+F.disable();
+}
+};
+u.changeBreakPointCondition=function(am,G){
+var F=this.findBreakPoint(am,false);
+F.setCondition(G);
+};
+u.changeBreakPointIgnoreCount=function(am,H){
+if(H<0)throw j(2,'Invalid argument');
+var F=this.findBreakPoint(am,false);
+F.setIgnoreCount(H);
+};
+u.clearBreakPoint=function(am){
+var F=this.findBreakPoint(am,true);
+if(F){
+return %ClearBreakPoint(F);
+}else{
+F=this.findScriptBreakPoint(am,true);
+if(!F)throw j(2,'Invalid breakpoint');
+}
+};
+u.clearAllBreakPoints=function(){
+for(var O=0;O<z.length;O++){
+var F=z[O];
+%ClearBreakPoint(F);
+}
+z=[];
+};
+u.disableAllBreakPoints=function(){
+for(var O=1;O<y;O++){
+u.disableBreakPoint(O);
+}
+%ChangeBreakOnException(u.ExceptionBreak.Caught,false);
+%ChangeBreakOnException(u.ExceptionBreak.Uncaught,false);
+};
+u.findScriptBreakPoint=function(am,an){
+var ar;
+for(var O=0;O<A.length;O++){
+if(A[O].number()==am){
+ar=A[O];
+if(an){
+ar.clear();
+A.splice(O,1);
+}
+break;
+}
+}
+return ar;
+};
+u.setScriptBreakPoint=function(w,script_id_or_name,
+ai,aj,ao,
+opt_groupId,opt_position_alignment){
+var ar=
+new ScriptBreakPoint(w,script_id_or_name,ai,aj,
+opt_groupId,opt_position_alignment);
+ar.number_=y++;
+ar.setCondition(ao);
+A.push(ar);
+var ae=this.scripts();
+for(var O=0;O<ae.length;O++){
+if(ar.matchesScript(ae[O])){
+ar.set(ae[O]);
+}
+}
+return ar.number();
+};
+u.setScriptBreakPointById=function(script_id,
+ai,aj,
+ao,opt_groupId,
+opt_position_alignment){
+return this.setScriptBreakPoint(u.ScriptBreakPointType.ScriptId,
+script_id,ai,aj,
+ao,opt_groupId,
+opt_position_alignment);
+};
+u.setScriptBreakPointByName=function(script_name,
+ai,aj,
+ao,opt_groupId){
+return this.setScriptBreakPoint(u.ScriptBreakPointType.ScriptName,
+script_name,ai,aj,
+ao,opt_groupId);
+};
+u.setScriptBreakPointByRegExp=function(script_regexp,
+ai,aj,
+ao,opt_groupId){
+return this.setScriptBreakPoint(u.ScriptBreakPointType.ScriptRegExp,
+script_regexp,ai,aj,
+ao,opt_groupId);
+};
+u.enableScriptBreakPoint=function(am){
+var ar=this.findScriptBreakPoint(am,false);
+ar.enable();
+};
+u.disableScriptBreakPoint=function(am){
+var ar=this.findScriptBreakPoint(am,false);
+ar.disable();
+};
+u.changeScriptBreakPointCondition=function(
+am,G){
+var ar=this.findScriptBreakPoint(am,false);
+ar.setCondition(G);
+};
+u.changeScriptBreakPointIgnoreCount=function(
+am,H){
+if(H<0)throw j(2,'Invalid argument');
+var ar=this.findScriptBreakPoint(am,false);
+ar.setIgnoreCount(H);
+};
+u.scriptBreakPoints=function(){
+return A;
+};
+u.clearStepping=function(){
+%ClearStepping();
+};
+u.setBreakOnException=function(){
+return %ChangeBreakOnException(u.ExceptionBreak.Caught,true);
+};
+u.clearBreakOnException=function(){
+return %ChangeBreakOnException(u.ExceptionBreak.Caught,false);
+};
+u.isBreakOnException=function(){
+return!!%IsBreakOnException(u.ExceptionBreak.Caught);
+};
+u.setBreakOnUncaughtException=function(){
+return %ChangeBreakOnException(u.ExceptionBreak.Uncaught,true);
+};
+u.clearBreakOnUncaughtException=function(){
+return %ChangeBreakOnException(u.ExceptionBreak.Uncaught,false);
+};
+u.isBreakOnUncaughtException=function(){
+return!!%IsBreakOnException(u.ExceptionBreak.Uncaught);
+};
+u.showBreakPoints=function(aa,as,at){
+if(!(%_IsFunction(aa)))throw j(32);
+var au=as?this.scriptSource(aa):this.source(aa);
+var av=as?this.sourcePosition(aa):0;
+var N=this.breakLocations(aa,at);
+if(!N)return au;
+N.sort(function(aw,ax){return aw-ax;});
+var X="";
+var ay=0;
+var az;
+for(var O=0;O<N.length;O++){
+az=N[O]-av;
+X+=au.slice(ay,az);
+X+="[B"+O+"]";
+ay=az;
+}
+az=au.length;
+X+=au.substring(ay,az);
+return X;
+};
+u.scripts=function(){
+return %DebugGetLoadedScripts();
+};
+u.debuggerFlags=function(){
+return B;
+};
+u.MakeMirror=l;
+function MakeExecutionState(K){
+return new ExecutionState(K);
+}
+function ExecutionState(K){
+this.break_id=K;
+this.selected_frame=0;
+}
+ExecutionState.prototype.prepareStep=function(aA){
+if(aA===u.StepAction.StepIn||
+aA===u.StepAction.StepOut||
+aA===u.StepAction.StepNext||
+aA===u.StepAction.StepFrame){
+return %PrepareStep(this.break_id,aA);
+}
+throw k(32);
+};
+ExecutionState.prototype.evaluateGlobal=function(au,disable_break,
+opt_additional_context){
+return l(%DebugEvaluateGlobal(this.break_id,au,
+(!!(disable_break)),
+opt_additional_context));
+};
+ExecutionState.prototype.frameCount=function(){
+return %GetFrameCount(this.break_id);
+};
+ExecutionState.prototype.threadCount=function(){
+return %GetThreadCount(this.break_id);
+};
+ExecutionState.prototype.frame=function(aB){
+if(aB==null)aB=this.selected_frame;
+if(aB<0||aB>=this.frameCount()){
+throw k(31);
+}
+return new c(this.break_id,aB);
+};
+ExecutionState.prototype.setSelectedFrame=function(aC){
+var O=(%_ToNumber(aC));
+if(O<0||O>=this.frameCount()){
+throw k(31);
+}
+this.selected_frame=O;
+};
+ExecutionState.prototype.selectedFrame=function(){
+return this.selected_frame;
+};
+ExecutionState.prototype.debugCommandProcessor=function(aD){
+return new DebugCommandProcessor(this,aD);
+};
+function MakeBreakEvent(K,aE){
+return new BreakEvent(K,aE);
+}
+function BreakEvent(K,aE){
+this.frame_=new c(K,0);
+this.break_points_hit_=aE;
+}
+BreakEvent.prototype.eventType=function(){
+return u.DebugEvent.Break;
+};
+BreakEvent.prototype.func=function(){
+return this.frame_.func();
+};
+BreakEvent.prototype.sourceLine=function(){
+return this.frame_.sourceLine();
+};
+BreakEvent.prototype.sourceColumn=function(){
+return this.frame_.sourceColumn();
+};
+BreakEvent.prototype.sourceLineText=function(){
+return this.frame_.sourceLineText();
+};
+BreakEvent.prototype.breakPointsHit=function(){
+return this.break_points_hit_;
+};
+BreakEvent.prototype.toJSONProtocol=function(){
+var aF={seq:x++,
+type:"event",
+event:"break",
+body:{invocationText:this.frame_.invocationText()}
+};
+var R=this.func().script();
+if(R){
+aF.body.sourceLine=this.sourceLine(),
+aF.body.sourceColumn=this.sourceColumn(),
+aF.body.sourceLineText=this.sourceLineText(),
+aF.body.script=MakeScriptObject_(R,false);
+}
+if(this.breakPointsHit()){
+aF.body.breakpoints=[];
+for(var O=0;O<this.breakPointsHit().length;O++){
+var aG=this.breakPointsHit()[O];
+var ar=aG.script_break_point();
+var aH;
+if(ar){
+aH=ar.number();
+}else{
+aH=aG.number();
+}
+aF.body.breakpoints.push(aH);
+}
+}
+return h(ObjectToProtocolObject_(aF));
+};
+function MakeExceptionEvent(K,aI,aJ,aK){
+return new ExceptionEvent(K,aI,aJ,aK);
+}
+function ExceptionEvent(K,aI,aJ,aK){
+this.exec_state_=new ExecutionState(K);
+this.exception_=aI;
+this.uncaught_=aJ;
+this.promise_=aK;
+}
+ExceptionEvent.prototype.eventType=function(){
+return u.DebugEvent.Exception;
+};
+ExceptionEvent.prototype.exception=function(){
+return this.exception_;
+};
+ExceptionEvent.prototype.uncaught=function(){
+return this.uncaught_;
+};
+ExceptionEvent.prototype.promise=function(){
+return this.promise_;
+};
+ExceptionEvent.prototype.func=function(){
+return this.exec_state_.frame(0).func();
+};
+ExceptionEvent.prototype.sourceLine=function(){
+return this.exec_state_.frame(0).sourceLine();
+};
+ExceptionEvent.prototype.sourceColumn=function(){
+return this.exec_state_.frame(0).sourceColumn();
+};
+ExceptionEvent.prototype.sourceLineText=function(){
+return this.exec_state_.frame(0).sourceLineText();
+};
+ExceptionEvent.prototype.toJSONProtocol=function(){
+var aF=new ProtocolMessage();
+aF.event="exception";
+aF.body={uncaught:this.uncaught_,
+exception:l(this.exception_)
+};
+if(this.exec_state_.frameCount()>0){
+aF.body.sourceLine=this.sourceLine();
+aF.body.sourceColumn=this.sourceColumn();
+aF.body.sourceLineText=this.sourceLineText();
+var R=this.func().script();
+if(R){
+aF.body.script=MakeScriptObject_(R,false);
+}
+}else{
+aF.body.sourceLine=-1;
+}
+return aF.toJSONProtocol();
+};
+function MakeCompileEvent(R,w){
+return new CompileEvent(R,w);
+}
+function CompileEvent(R,w){
+this.script_=l(R);
+this.type_=w;
+}
+CompileEvent.prototype.eventType=function(){
+return this.type_;
+};
+CompileEvent.prototype.script=function(){
+return this.script_;
+};
+CompileEvent.prototype.toJSONProtocol=function(){
+var aF=new ProtocolMessage();
+aF.running=true;
+switch(this.type_){
+case u.DebugEvent.BeforeCompile:
+aF.event="beforeCompile";
+break;
+case u.DebugEvent.AfterCompile:
+aF.event="afterCompile";
+break;
+case u.DebugEvent.CompileError:
+aF.event="compileError";
+break;
+}
+aF.body={};
+aF.body.script=this.script_;
+return aF.toJSONProtocol();
+};
+function MakeScriptObject_(R,aL){
+var aF={id:R.id(),
+name:R.name(),
+lineOffset:R.lineOffset(),
+columnOffset:R.columnOffset(),
+lineCount:R.lineCount(),
+};
+if(!(R.data()===(void 0))){
+aF.data=R.data();
+}
+if(aL){
+aF.source=R.source();
+}
+return aF;
+}
+function MakePromiseEvent(aM){
+return new PromiseEvent(aM);
+}
+function PromiseEvent(aM){
+this.promise_=aM.promise;
+this.parentPromise_=aM.parentPromise;
+this.status_=aM.status;
+this.value_=aM.value;
+}
+PromiseEvent.prototype.promise=function(){
+return l(this.promise_);
+}
+PromiseEvent.prototype.parentPromise=function(){
+return l(this.parentPromise_);
+}
+PromiseEvent.prototype.status=function(){
+return this.status_;
+}
+PromiseEvent.prototype.value=function(){
+return l(this.value_);
+}
+function MakeAsyncTaskEvent(aM){
+return new AsyncTaskEvent(aM);
+}
+function AsyncTaskEvent(aM){
+this.type_=aM.type;
+this.name_=aM.name;
+this.id_=aM.id;
+}
+AsyncTaskEvent.prototype.type=function(){
+return this.type_;
+}
+AsyncTaskEvent.prototype.name=function(){
+return this.name_;
+}
+AsyncTaskEvent.prototype.id=function(){
+return this.id_;
+}
+function DebugCommandProcessor(I,aD){
+this.exec_state_=I;
+this.running_=aD||false;
+}
+DebugCommandProcessor.prototype.processDebugRequest=function(aN){
+return this.processDebugJSONRequest(aN);
+};
+function ProtocolMessage(aN){
+this.seq=x++;
+if(aN){
+this.type='response';
+this.request_seq=aN.seq;
+this.command=aN.command;
+}else{
+this.type='event';
+}
+this.success=true;
+this.running=(void 0);
+}
+ProtocolMessage.prototype.setOption=function(aO,C){
+if(!this.options_){
+this.options_={};
+}
+this.options_[aO]=C;
+};
+ProtocolMessage.prototype.failed=function(aP,aQ){
+this.success=false;
+this.message=aP;
+if((typeof(aQ)==='object')){
+this.error_details=aQ;
+}
+};
+ProtocolMessage.prototype.toJSONProtocol=function(){
+var aR={};
+aR.seq=this.seq;
+if(this.request_seq){
+aR.request_seq=this.request_seq;
+}
+aR.type=this.type;
+if(this.event){
+aR.event=this.event;
+}
+if(this.command){
+aR.command=this.command;
+}
+if(this.success){
+aR.success=this.success;
+}else{
+aR.success=false;
+}
+if(this.body){
+var aS;
+var aT=m(true,this.options_);
+if(this.body instanceof o){
+aS=aT.serializeValue(this.body);
+}else if(this.body instanceof d){
+aS=[];
+for(var O=0;O<this.body.length;O++){
+if(this.body[O]instanceof o){
+aS.push(aT.serializeValue(this.body[O]));
+}else{
+aS.push(ObjectToProtocolObject_(this.body[O],aT));
+}
+}
+}else{
+aS=ObjectToProtocolObject_(this.body,aT);
+}
+aR.body=aS;
+aR.refs=aT.serializeReferencedObjects();
+}
+if(this.message){
+aR.message=this.message;
+}
+if(this.error_details){
+aR.error_details=this.error_details;
+}
+aR.running=this.running;
+return h(aR);
+};
+DebugCommandProcessor.prototype.createResponse=function(aN){
+return new ProtocolMessage(aN);
+};
+DebugCommandProcessor.prototype.processDebugJSONRequest=function(
+json_request){
+var aN;
+var aU;
+try{
+try{
+aN=g(json_request);
+aU=this.createResponse(aN);
+if(!aN.type){
+throw j(2,'Type not specified');
+}
+if(aN.type!='request'){
+throw j(2,
+"Illegal type '"+aN.type+"' in request");
+}
+if(!aN.command){
+throw j(2,'Command not specified');
+}
+if(aN.arguments){
+var aV=aN.arguments;
+if(aV.inlineRefs||aV.compactFormat){
+aU.setOption('inlineRefs',true);
+}
+if(!(aV.maxStringLength===(void 0))){
+aU.setOption('maxStringLength',aV.maxStringLength);
+}
+}
+var aW=aN.command.toLowerCase();
+var aX=DebugCommandProcessor.prototype.dispatch_[aW];
+if((%_IsFunction(aX))){
+%_Call(aX,this,aN,aU);
+}else{
+throw j(2,
+'Unknown command "'+aN.command+'" in request');
+}
+}catch(e){
+if(!aU){
+aU=this.createResponse();
+}
+aU.success=false;
+aU.message=(%_ToString(e));
+}
+try{
+if(!(aU.running===(void 0))){
+this.running_=aU.running;
+}
+aU.running=this.running_;
+return aU.toJSONProtocol();
+}catch(e){
+return'{"seq":'+aU.seq+','+
+'"request_seq":'+aN.seq+','+
+'"type":"response",'+
+'"success":false,'+
+'"message":"Internal error: '+(%_ToString(e))+'"}';
+}
+}catch(e){
+return'{"seq":0,"type":"response","success":false,"message":"Internal error"}';
+}
+};
+DebugCommandProcessor.prototype.continueRequest_=function(aN,aU){
+if(aN.arguments){
+var aA=u.StepAction.StepIn;
+var aY=aN.arguments.stepaction;
+if(aY){
+if(aY=='in'){
+aA=u.StepAction.StepIn;
+}else if(aY=='next'){
+aA=u.StepAction.StepNext;
+}else if(aY=='out'){
+aA=u.StepAction.StepOut;
+}else{
+throw j(2,
+'Invalid stepaction argument "'+aY+'".');
+}
+}
+this.exec_state_.prepareStep(aA);
+}
+aU.running=true;
+};
+DebugCommandProcessor.prototype.breakRequest_=function(aN,aU){
+};
+DebugCommandProcessor.prototype.setBreakPointRequest_=
+function(aN,aU){
+if(!aN.arguments){
+aU.failed('Missing arguments');
+return;
+}
+var w=aN.arguments.type;
+var aZ=aN.arguments.target;
+var P=aN.arguments.line;
+var Q=aN.arguments.column;
+var ba=(aN.arguments.enabled===(void 0))?
+true:aN.arguments.enabled;
+var G=aN.arguments.condition;
+var H=aN.arguments.ignoreCount;
+var bb=aN.arguments.groupId;
+if(!w||(aZ===(void 0))){
+aU.failed('Missing argument "type" or "target"');
+return;
+}
+var am;
+if(w=='function'){
+if(!(typeof(aZ)==='string')){
+aU.failed('Argument "target" is not a string value');
+return;
+}
+var aa;
+try{
+aa=this.exec_state_.evaluateGlobal(aZ).value();
+}catch(e){
+aU.failed('Error: "'+(%_ToString(e))+
+'" evaluating "'+aZ+'"');
+return;
+}
+if(!(%_IsFunction(aa))){
+aU.failed('"'+aZ+'" does not evaluate to a function');
+return;
+}
+am=u.setBreakPoint(aa,P,Q,G);
+}else if(w=='handle'){
+var bc=q(aZ,10);
+var J=i(bc);
+if(!J){
+return aU.failed('Object #'+bc+'# not found');
+}
+if(!J.isFunction()){
+return aU.failed('Object #'+bc+'# is not a function');
+}
+am=u.setBreakPoint(J.value(),
+P,Q,G);
+}else if(w=='script'){
+am=
+u.setScriptBreakPointByName(aZ,P,Q,G,
+bb);
+}else if(w=='scriptId'){
+am=
+u.setScriptBreakPointById(aZ,P,Q,G,bb);
+}else if(w=='scriptRegExp'){
+am=
+u.setScriptBreakPointByRegExp(aZ,P,Q,G,
+bb);
+}else{
+aU.failed('Illegal type "'+w+'"');
+return;
+}
+var F=u.findBreakPoint(am);
+if(H){
+u.changeBreakPointIgnoreCount(am,H);
+}
+if(!ba){
+u.disableBreakPoint(am);
+}
+aU.body={type:w,
+breakpoint:am};
+if(F instanceof ScriptBreakPoint){
+if(F.type()==u.ScriptBreakPointType.ScriptId){
+aU.body.type='scriptId';
+aU.body.script_id=F.script_id();
+}else if(F.type()==u.ScriptBreakPointType.ScriptName){
+aU.body.type='scriptName';
+aU.body.script_name=F.script_name();
+}else if(F.type()==u.ScriptBreakPointType.ScriptRegExp){
+aU.body.type='scriptRegExp';
+aU.body.script_regexp=F.script_regexp_object().source;
+}else{
+throw j(2,
+"Unexpected breakpoint type: "+F.type());
+}
+aU.body.line=F.line();
+aU.body.column=F.column();
+aU.body.actual_locations=F.actual_locations();
+}else{
+aU.body.type='function';
+aU.body.actual_locations=[F.actual_location];
+}
+};
+DebugCommandProcessor.prototype.changeBreakPointRequest_=function(
+aN,aU){
+if(!aN.arguments){
+aU.failed('Missing arguments');
+return;
+}
+var F=(%_ToNumber(aN.arguments.breakpoint));
+var ba=aN.arguments.enabled;
+var G=aN.arguments.condition;
+var H=aN.arguments.ignoreCount;
+if(!F){
+aU.failed('Missing argument "breakpoint"');
+return;
+}
+if(!(ba===(void 0))){
+if(ba){
+u.enableBreakPoint(F);
+}else{
+u.disableBreakPoint(F);
+}
+}
+if(!(G===(void 0))){
+u.changeBreakPointCondition(F,G);
+}
+if(!(H===(void 0))){
+u.changeBreakPointIgnoreCount(F,H);
+}
+};
+DebugCommandProcessor.prototype.clearBreakPointGroupRequest_=function(
+aN,aU){
+if(!aN.arguments){
+aU.failed('Missing arguments');
+return;
+}
+var bd=aN.arguments.groupId;
+if(!bd){
+aU.failed('Missing argument "groupId"');
+return;
+}
+var be=[];
+var bf=[];
+for(var O=0;O<A.length;O++){
+var bg=A[O];
+if(bg.groupId()==bd){
+be.push(bg.number());
+bg.clear();
+}else{
+bf.push(bg);
+}
+}
+A=bf;
+aU.body={breakpoints:be};
+};
+DebugCommandProcessor.prototype.clearBreakPointRequest_=function(
+aN,aU){
+if(!aN.arguments){
+aU.failed('Missing arguments');
+return;
+}
+var F=(%_ToNumber(aN.arguments.breakpoint));
+if(!F){
+aU.failed('Missing argument "breakpoint"');
+return;
+}
+u.clearBreakPoint(F);
+aU.body={breakpoint:F};
+};
+DebugCommandProcessor.prototype.listBreakpointsRequest_=function(
+aN,aU){
+var bh=[];
+for(var O=0;O<A.length;O++){
+var F=A[O];
+var bi={
+number:F.number(),
+line:F.line(),
+column:F.column(),
+groupId:F.groupId(),
+hit_count:F.hit_count(),
+active:F.active(),
+condition:F.condition(),
+ignoreCount:F.ignoreCount(),
+actual_locations:F.actual_locations()
+};
+if(F.type()==u.ScriptBreakPointType.ScriptId){
+bi.type='scriptId';
+bi.script_id=F.script_id();
+}else if(F.type()==u.ScriptBreakPointType.ScriptName){
+bi.type='scriptName';
+bi.script_name=F.script_name();
+}else if(F.type()==u.ScriptBreakPointType.ScriptRegExp){
+bi.type='scriptRegExp';
+bi.script_regexp=F.script_regexp_object().source;
+}else{
+throw j(2,
+"Unexpected breakpoint type: "+F.type());
+}
+bh.push(bi);
+}
+aU.body={
+breakpoints:bh,
+breakOnExceptions:u.isBreakOnException(),
+breakOnUncaughtExceptions:u.isBreakOnUncaughtException()
+};
+};
+DebugCommandProcessor.prototype.disconnectRequest_=
+function(aN,aU){
+u.disableAllBreakPoints();
+this.continueRequest_(aN,aU);
+};
+DebugCommandProcessor.prototype.setExceptionBreakRequest_=
+function(aN,aU){
+if(!aN.arguments){
+aU.failed('Missing arguments');
+return;
+}
+var w=aN.arguments.type;
+if(!w){
+aU.failed('Missing argument "type"');
+return;
+}
+var ba;
+if(w=='all'){
+ba=!u.isBreakOnException();
+}else if(w=='uncaught'){
+ba=!u.isBreakOnUncaughtException();
+}
+if(!(aN.arguments.enabled===(void 0))){
+ba=aN.arguments.enabled;
+if((ba!=true)&&(ba!=false)){
+aU.failed('Illegal value for "enabled":"'+ba+'"');
+}
+}
+if(w=='all'){
+%ChangeBreakOnException(u.ExceptionBreak.Caught,ba);
+}else if(w=='uncaught'){
+%ChangeBreakOnException(u.ExceptionBreak.Uncaught,ba);
+}else{
+aU.failed('Unknown "type":"'+w+'"');
+}
+aU.body={'type':w,'enabled':ba};
+};
+DebugCommandProcessor.prototype.backtraceRequest_=function(
+aN,aU){
+var bj=this.exec_state_.frameCount();
+if(bj==0){
+aU.body={
+totalFrames:bj
+};
+return;
+}
+var bk=0;
+var bl=t;
+if(aN.arguments){
+if(aN.arguments.fromFrame){
+bk=aN.arguments.fromFrame;
+}
+if(aN.arguments.toFrame){
+bl=aN.arguments.toFrame;
+}
+if(aN.arguments.bottom){
+var bm=bj-bk;
+bk=bj-bl;
+bl=bm;
+}
+if(bk<0||bl<0){
+return aU.failed('Invalid frame number');
+}
+}
+bl=n(bj,bl);
+if(bl<=bk){
+var bn='Invalid frame range';
+return aU.failed(bn);
+}
+var bo=[];
+for(var O=bk;O<bl;O++){
+bo.push(this.exec_state_.frame(O));
+}
+aU.body={
+fromFrame:bk,
+toFrame:bl,
+totalFrames:bj,
+frames:bo
+};
+};
+DebugCommandProcessor.prototype.frameRequest_=function(aN,aU){
+if(this.exec_state_.frameCount()==0){
+return aU.failed('No frames');
+}
+if(aN.arguments){
+var aC=aN.arguments.number;
+if(aC<0||this.exec_state_.frameCount()<=aC){
+return aU.failed('Invalid frame number');
+}
+this.exec_state_.setSelectedFrame(aN.arguments.number);
+}
+aU.body=this.exec_state_.frame();
+};
+DebugCommandProcessor.prototype.resolveFrameFromScopeDescription_=
+function(bp){
+if(bp&&!(bp.frameNumber===(void 0))){
+var bq=bp.frameNumber;
+if(bq<0||this.exec_state_.frameCount()<=bq){
+throw k(31);
+}
+return this.exec_state_.frame(bq);
+}else{
+return this.exec_state_.frame();
+}
+};
+DebugCommandProcessor.prototype.resolveScopeHolder_=
+function(bp){
+if(bp&&"functionHandle"in bp){
+if(!(typeof(bp.functionHandle)==='number')){
+throw j(2,'Function handle must be a number');
+}
+var br=i(bp.functionHandle);
+if(!br){
+throw j(2,'Failed to find function object by handle');
+}
+if(!br.isFunction()){
+throw j(2,
+'Value of non-function type is found by handle');
+}
+return br;
+}else{
+if(this.exec_state_.frameCount()==0){
+throw j(2,'No scopes');
+}
+var bs=this.resolveFrameFromScopeDescription_(bp);
+return bs;
+}
+}
+DebugCommandProcessor.prototype.scopesRequest_=function(aN,aU){
+var bt=this.resolveScopeHolder_(aN.arguments);
+var bu=bt.scopeCount();
+var bv=[];
+for(var O=0;O<bu;O++){
+bv.push(bt.scope(O));
+}
+aU.body={
+fromScope:0,
+toScope:bu,
+totalScopes:bu,
+scopes:bv
+};
+};
+DebugCommandProcessor.prototype.scopeRequest_=function(aN,aU){
+var bt=this.resolveScopeHolder_(aN.arguments);
+var bw=0;
+if(aN.arguments&&!(aN.arguments.number===(void 0))){
+bw=(%_ToNumber(aN.arguments.number));
+if(bw<0||bt.scopeCount()<=bw){
+return aU.failed('Invalid scope number');
+}
+}
+aU.body=bt.scope(bw);
+};
+DebugCommandProcessor.resolveValue_=function(bx){
+if("handle"in bx){
+var by=i(bx.handle);
+if(!by){
+throw j(2,"Failed to resolve value by handle, ' #"+
+bx.handle+"# not found");
+}
+return by.value();
+}else if("stringDescription"in bx){
+if(bx.type==p.BOOLEAN_TYPE){
+return(!!(bx.stringDescription));
+}else if(bx.type==p.NUMBER_TYPE){
+return(%_ToNumber(bx.stringDescription));
+}if(bx.type==p.STRING_TYPE){
+return(%_ToString(bx.stringDescription));
+}else{
+throw j(2,"Unknown type");
+}
+}else if("value"in bx){
+return bx.value;
+}else if(bx.type==p.UNDEFINED_TYPE){
+return(void 0);
+}else if(bx.type==p.NULL_TYPE){
+return null;
+}else{
+throw j(2,"Failed to parse value description");
+}
+};
+DebugCommandProcessor.prototype.setVariableValueRequest_=
+function(aN,aU){
+if(!aN.arguments){
+aU.failed('Missing arguments');
+return;
+}
+if((aN.arguments.name===(void 0))){
+aU.failed('Missing variable name');
+}
+var bz=aN.arguments.name;
+var bp=aN.arguments.scope;
+var bt=this.resolveScopeHolder_(bp);
+if((bp.number===(void 0))){
+aU.failed('Missing scope number');
+}
+var bw=(%_ToNumber(bp.number));
+var bA=bt.scope(bw);
+var bB=
+DebugCommandProcessor.resolveValue_(aN.arguments.newValue);
+bA.setVariableValue(bz,bB);
+var bC=l(bB);
+aU.body={
+newValue:bC
+};
+};
+DebugCommandProcessor.prototype.evaluateRequest_=function(aN,aU){
+if(!aN.arguments){
+return aU.failed('Missing arguments');
+}
+var bD=aN.arguments.expression;
+var bs=aN.arguments.frame;
+var a=aN.arguments.global;
+var bE=aN.arguments.disable_break;
+var bF=aN.arguments.additional_context;
+try{
+bD=(%_ToString(bD));
+}catch(e){
+return aU.failed('Failed to convert expression argument to string');
+}
+if(!(bs===(void 0))&&a){
+return aU.failed('Arguments "frame" and "global" are exclusive');
+}
+var bG;
+if(bF){
+bG={};
+for(var O=0;O<bF.length;O++){
+var bH=bF[O];
+if(!(typeof(bH.name)==='string')){
+return aU.failed("Context element #"+O+
+" doesn't contain name:string property");
+}
+var bI=DebugCommandProcessor.resolveValue_(bH);
+bG[bH.name]=bI;
+}
+}
+if(a){
+aU.body=this.exec_state_.evaluateGlobal(
+bD,(!!(bE)),bG);
+return;
+}
+if((bE===(void 0))){
+bE=true;
+}
+if(this.exec_state_.frameCount()==0){
+return aU.failed('No frames');
+}
+if(!(bs===(void 0))){
+var bJ=(%_ToNumber(bs));
+if(bJ<0||bJ>=this.exec_state_.frameCount()){
+return aU.failed('Invalid frame "'+bs+'"');
+}
+aU.body=this.exec_state_.frame(bJ).evaluate(
+bD,(!!(bE)),bG);
+return;
+}else{
+aU.body=this.exec_state_.frame().evaluate(
+bD,(!!(bE)),bG);
+return;
+}
+};
+DebugCommandProcessor.prototype.lookupRequest_=function(aN,aU){
+if(!aN.arguments){
+return aU.failed('Missing arguments');
+}
+var bK=aN.arguments.handles;
+if((bK===(void 0))){
+return aU.failed('Argument "handles" missing');
+}
+if(!(aN.arguments.includeSource===(void 0))){
+var bL=(!!(aN.arguments.includeSource));
+aU.setOption('includeSource',bL);
+}
+var bM={};
+for(var O=0;O<bK.length;O++){
+var bc=bK[O];
+var J=i(bc);
+if(!J){
+return aU.failed('Object #'+bc+'# not found');
+}
+bM[bc]=J;
+}
+aU.body=bM;
+};
+DebugCommandProcessor.prototype.referencesRequest_=
+function(aN,aU){
+if(!aN.arguments){
+return aU.failed('Missing arguments');
+}
+var w=aN.arguments.type;
+var bc=aN.arguments.handle;
+if((w===(void 0))){
+return aU.failed('Argument "type" missing');
+}
+if((bc===(void 0))){
+return aU.failed('Argument "handle" missing');
+}
+if(w!='referencedBy'&&w!='constructedBy'){
+return aU.failed('Invalid type "'+w+'"');
+}
+var J=i(bc);
+if(J){
+if(w=='referencedBy'){
+aU.body=J.referencedBy();
+}else{
+aU.body=J.constructedBy();
+}
+}else{
+return aU.failed('Object #'+bc+'# not found');
+}
+};
+DebugCommandProcessor.prototype.sourceRequest_=function(aN,aU){
+if(this.exec_state_.frameCount()==0){
+return aU.failed('No source');
+}
+var bN;
+var bO;
+var bs=this.exec_state_.frame();
+if(aN.arguments){
+bN=aN.arguments.fromLine;
+bO=aN.arguments.toLine;
+if(!(aN.arguments.frame===(void 0))){
+var bJ=(%_ToNumber(aN.arguments.frame));
+if(bJ<0||bJ>=this.exec_state_.frameCount()){
+return aU.failed('Invalid frame "'+bs+'"');
+}
+bs=this.exec_state_.frame(bJ);
+}
+}
+var R=bs.func().script();
+if(!R){
+return aU.failed('No source');
+}
+var bP=R.sourceSlice(bN,bO);
+if(!bP){
+return aU.failed('Invalid line interval');
+}
+aU.body={};
+aU.body.source=bP.sourceText();
+aU.body.fromLine=bP.from_line;
+aU.body.toLine=bP.to_line;
+aU.body.fromPosition=bP.from_position;
+aU.body.toPosition=bP.to_position;
+aU.body.totalLines=R.lineCount();
+};
+DebugCommandProcessor.prototype.scriptsRequest_=function(aN,aU){
+var bQ=ScriptTypeFlag(u.ScriptType.Normal);
+var bL=false;
+var bR=null;
+if(aN.arguments){
+if(!(aN.arguments.types===(void 0))){
+bQ=(%_ToNumber(aN.arguments.types));
+if(f(bQ)||bQ<0){
+return aU.failed('Invalid types "'+
+aN.arguments.types+'"');
+}
+}
+if(!(aN.arguments.includeSource===(void 0))){
+bL=(!!(aN.arguments.includeSource));
+aU.setOption('includeSource',bL);
+}
+if((%_IsArray(aN.arguments.ids))){
+bR={};
+var bS=aN.arguments.ids;
+for(var O=0;O<bS.length;O++){
+bR[bS[O]]=true;
+}
+}
+var bT=null;
+var bU=null;
+if(!(aN.arguments.filter===(void 0))){
+var bV=(%_ToNumber(aN.arguments.filter));
+if(!f(bV)){
+bU=bV;
+}
+bT=aN.arguments.filter;
+}
+}
+var ae=%DebugGetLoadedScripts();
+aU.body=[];
+for(var O=0;O<ae.length;O++){
+if(bR&&!bR[ae[O].id]){
+continue;
+}
+if(bT||bU){
+var R=ae[O];
+var bW=false;
+if(bU&&!bW){
+if(R.id&&R.id===bU){
+bW=true;
+}
+}
+if(bT&&!bW){
+if(R.name&&R.name.indexOf(bT)>=0){
+bW=true;
+}
+}
+if(!bW)continue;
+}
+if(bQ&ScriptTypeFlag(ae[O].type)){
+aU.body.push(l(ae[O]));
+}
+}
+};
+DebugCommandProcessor.prototype.threadsRequest_=function(aN,aU){
+var bX=this.exec_state_.threadCount();
+var bY=[];
+for(var O=0;O<bX;O++){
+var bZ=%GetThreadDetails(this.exec_state_.break_id,O);
+var ca={current:bZ[0],
+id:bZ[1]
+};
+bY.push(ca);
+}
+aU.body={
+totalThreads:bX,
+threads:bY
+};
+};
+DebugCommandProcessor.prototype.suspendRequest_=function(aN,aU){
+aU.running=false;
+};
+DebugCommandProcessor.prototype.versionRequest_=function(aN,aU){
+aU.body={
+V8Version:%GetV8Version()
+};
+};
+DebugCommandProcessor.prototype.changeLiveRequest_=function(
+aN,aU){
+if(!aN.arguments){
+return aU.failed('Missing arguments');
+}
+var cb=aN.arguments.script_id;
+var cc=!!aN.arguments.preview_only;
+var ae=%DebugGetLoadedScripts();
+var cd=null;
+for(var O=0;O<ae.length;O++){
+if(ae[O].id==cb){
+cd=ae[O];
+}
+}
+if(!cd){
+aU.failed('Script not found');
+return;
+}
+var ce=new d();
+if(!(typeof(aN.arguments.new_source)==='string')){
+throw"new_source argument expected";
+}
+var cf=aN.arguments.new_source;
+var cg;
+try{
+cg=u.LiveEdit.SetScriptSource(cd,
+cf,cc,ce);
+}catch(e){
+if(e instanceof u.LiveEdit.Failure&&"details"in e){
+aU.failed(e.message,e.details);
+return;
+}
+throw e;
+}
+aU.body={change_log:ce,result:cg};
+if(!cc&&!this.running_&&cg.stack_modified){
+aU.body.stepin_recommended=true;
+}
+};
+DebugCommandProcessor.prototype.restartFrameRequest_=function(
+aN,aU){
+if(!aN.arguments){
+return aU.failed('Missing arguments');
+}
+var bs=aN.arguments.frame;
+if(this.exec_state_.frameCount()==0){
+return aU.failed('No frames');
+}
+var ch;
+if(!(bs===(void 0))){
+var bJ=(%_ToNumber(bs));
+if(bJ<0||bJ>=this.exec_state_.frameCount()){
+return aU.failed('Invalid frame "'+bs+'"');
+}
+ch=this.exec_state_.frame(bJ);
+}else{
+ch=this.exec_state_.frame();
+}
+var cg=u.LiveEdit.RestartFrame(ch);
+aU.body={result:cg};
+};
+DebugCommandProcessor.prototype.debuggerFlagsRequest_=function(aN,
+aU){
+if(!aN.arguments){
+aU.failed('Missing arguments');
+return;
+}
+var ci=aN.arguments.flags;
+aU.body={flags:[]};
+if(!(ci===(void 0))){
+for(var O=0;O<ci.length;O++){
+var aO=ci[O].name;
+var cj=B[aO];
+if(!cj){
+continue;
+}
+if('value'in ci[O]){
+cj.setValue(ci[O].value);
+}
+aU.body.flags.push({name:aO,value:cj.getValue()});
+}
+}else{
+for(var aO in B){
+var C=B[aO].getValue();
+aU.body.flags.push({name:aO,value:C});
+}
+}
+};
+DebugCommandProcessor.prototype.v8FlagsRequest_=function(aN,aU){
+var ci=aN.arguments.flags;
+if(!ci)ci='';
+%SetFlags(ci);
+};
+DebugCommandProcessor.prototype.gcRequest_=function(aN,aU){
+var w=aN.arguments.type;
+if(!w)w='all';
+var ck=%GetHeapUsage();
+%CollectGarbage(w);
+var cl=%GetHeapUsage();
+aU.body={"before":ck,"after":cl};
+};
+DebugCommandProcessor.prototype.dispatch_=(function(){
+var cm=DebugCommandProcessor.prototype;
+return{
+"continue":cm.continueRequest_,
+"break":cm.breakRequest_,
+"setbreakpoint":cm.setBreakPointRequest_,
+"changebreakpoint":cm.changeBreakPointRequest_,
+"clearbreakpoint":cm.clearBreakPointRequest_,
+"clearbreakpointgroup":cm.clearBreakPointGroupRequest_,
+"disconnect":cm.disconnectRequest_,
+"setexceptionbreak":cm.setExceptionBreakRequest_,
+"listbreakpoints":cm.listBreakpointsRequest_,
+"backtrace":cm.backtraceRequest_,
+"frame":cm.frameRequest_,
+"scopes":cm.scopesRequest_,
+"scope":cm.scopeRequest_,
+"setvariablevalue":cm.setVariableValueRequest_,
+"evaluate":cm.evaluateRequest_,
+"lookup":cm.lookupRequest_,
+"references":cm.referencesRequest_,
+"source":cm.sourceRequest_,
+"scripts":cm.scriptsRequest_,
+"threads":cm.threadsRequest_,
+"suspend":cm.suspendRequest_,
+"version":cm.versionRequest_,
+"changelive":cm.changeLiveRequest_,
+"restartframe":cm.restartFrameRequest_,
+"flags":cm.debuggerFlagsRequest_,
+"v8flag":cm.v8FlagsRequest_,
+"gc":cm.gcRequest_,
+};
+})();
+DebugCommandProcessor.prototype.isRunning=function(){
+return this.running_;
+};
+DebugCommandProcessor.prototype.systemBreak=function(cn,aV){
+return %SystemBreak();
+};
+function ObjectToProtocolObject_(co,cp){
+var cq={};
+for(var aW in co){
+if(typeof aW=='string'){
+var cr=ValueToProtocolValue_(co[aW],
+cp);
+if(!(cr===(void 0))){
+cq[aW]=cr;
+}
+}
+}
+return cq;
+}
+function ArrayToProtocolArray_(bh,cp){
+var aR=[];
+for(var O=0;O<bh.length;O++){
+aR.push(ValueToProtocolValue_(bh[O],cp));
+}
+return aR;
+}
+function ValueToProtocolValue_(C,cp){
+var aR;
+switch(typeof C){
+case'object':
+if(C instanceof o){
+aR=cp.serializeValue(C);
+}else if((%_IsArray(C))){
+aR=ArrayToProtocolArray_(C,cp);
+}else{
+aR=ObjectToProtocolObject_(C,cp);
+}
+break;
+case'boolean':
+case'string':
+case'number':
+aR=C;
+break;
+default:
+aR=null;
+}
+return aR;
+}
+b.InstallConstants(a,[
+"Debug",u,
+"DebugCommandProcessor",DebugCommandProcessor,
+"BreakEvent",BreakEvent,
+"CompileEvent",CompileEvent,
+"BreakPoint",BreakPoint,
+]);
+b.InstallFunctions(b,2,[
+"MakeExecutionState",MakeExecutionState,
+"MakeExceptionEvent",MakeExceptionEvent,
+"MakeBreakEvent",MakeBreakEvent,
+"MakeCompileEvent",MakeCompileEvent,
+"MakePromiseEvent",MakePromiseEvent,
+"MakeAsyncTaskEvent",MakeAsyncTaskEvent,
+"IsBreakPointTriggered",IsBreakPointTriggered,
+"UpdateScriptBreakPoints",UpdateScriptBreakPoints,
+]);
+b.Export(function(cs){
+cs.GetScriptBreakPoints=GetScriptBreakPoints;
+});
+})
+
+ liveedit%�
+(function(a,b){
+"use strict";
+var c=a.Debug.findScriptSourcePosition;
+var d;
+var e=a.Array;
+var f=a.Math.floor;
+var g=a.SyntaxError;
+b.Import(function(h){
+d=h.GetScriptBreakPoints;
+});
+var i;
+function ApplyPatchMultiChunk(script,diff_array,new_source,preview_only,
+change_log){
+var j=script.source;
+var k=GatherCompileInfo(j,script);
+var l=BuildCodeInfoTree(k);
+var m=new PosTranslator(diff_array);
+MarkChangedFunctions(l,m.GetChunks());
+FindLiveSharedInfos(l,script);
+var n;
+try{
+n=GatherCompileInfo(new_source,script);
+}catch(e){
+var o=
+new Failure("Failed to compile new version of script: "+e);
+if(e instanceof g){
+var p={
+type:"liveedit_compile_error",
+syntaxErrorMessage:e.message
+};
+CopyErrorPositionToDetails(e,p);
+o.details=p;
+}
+throw o;
+}
+var q=BuildCodeInfoTree(n);
+FindCorrespondingFunctions(l,q);
+var r=new e();
+var s=new e();
+var t=new e();
+var u=new e();
+function HarvestTodo(v){
+function CollectDamaged(w){
+s.push(w);
+for(var x=0;x<w.children.length;x++){
+CollectDamaged(w.children[x]);
+}
+}
+function CollectNew(y){
+for(var x=0;x<y.length;x++){
+t.push(y[x]);
+CollectNew(y[x].children);
+}
+}
+if(v.status==i.DAMAGED){
+CollectDamaged(v);
+return;
+}
+if(v.status==i.UNCHANGED){
+u.push(v);
+}else if(v.status==i.SOURCE_CHANGED){
+u.push(v);
+}else if(v.status==i.CHANGED){
+r.push(v);
+CollectNew(v.unmatched_new_nodes);
+}
+for(var x=0;x<v.children.length;x++){
+HarvestTodo(v.children[x]);
+}
+}
+var z={
+change_tree:DescribeChangeTree(l),
+textual_diff:{
+old_len:j.length,
+new_len:new_source.length,
+chunks:diff_array
+},
+updated:false
+};
+if(preview_only){
+return z;
+}
+HarvestTodo(l);
+var A=new e();
+var B=new e();
+for(var x=0;x<r.length;x++){
+var C=r[x].live_shared_function_infos;
+var D=
+r[x].corresponding_node.info.shared_function_info;
+if(C){
+for(var E=0;E<C.length;E++){
+A.push(C[E]);
+B.push(D);
+}
+}
+}
+var F=
+CheckStackActivations(A,
+B,
+change_log);
+z.stack_modified=F!=0;
+var G=TemporaryRemoveBreakPoints(script,change_log);
+var H;
+if(s.length==0){
+%LiveEditReplaceScript(script,new_source,null);
+H=(void 0);
+}else{
+var I=CreateNameForOldScript(script);
+H=%LiveEditReplaceScript(script,new_source,
+I);
+var J=new e();
+change_log.push({linked_to_old_script:J});
+for(var x=0;x<s.length;x++){
+LinkToOldScript(s[x],H,
+J);
+}
+z.created_script_name=I;
+}
+for(var x=0;x<t.length;x++){
+%LiveEditFunctionSetScript(
+t[x].info.shared_function_info,script);
+}
+for(var x=0;x<r.length;x++){
+PatchFunctionCode(r[x],change_log);
+}
+var K=new e();
+change_log.push({position_patched:K});
+for(var x=0;x<u.length;x++){
+PatchPositions(u[x],diff_array,
+K);
+if(u[x].live_shared_function_infos){
+u[x].live_shared_function_infos.
+forEach(function(L){
+%LiveEditFunctionSourceUpdated(L.raw_array);
+});
+}
+}
+G(m,H);
+z.updated=true;
+return z;
+}
+function GatherCompileInfo(M,N){
+var O=%LiveEditGatherCompileInfo(N,M);
+var P=new e();
+var Q=new e();
+for(var x=0;x<O.length;x++){
+var L=new FunctionCompileInfo(O[x]);
+%LiveEditFunctionSetScript(L.shared_function_info,(void 0));
+P.push(L);
+Q.push(x);
+}
+for(var x=0;x<P.length;x++){
+var R=x;
+for(var E=x+1;E<P.length;E++){
+if(P[R].start_position>P[E].start_position){
+R=E;
+}
+}
+if(R!=x){
+var S=P[R];
+var T=Q[R];
+P[R]=P[x];
+Q[R]=Q[x];
+P[x]=S;
+Q[x]=T;
+}
+}
+var U=0;
+function ResetIndexes(V,W){
+var X=-1;
+while(U<P.length&&
+P[U].outer_index==W){
+var Y=U;
+P[Y].outer_index=V;
+if(X!=-1){
+P[X].next_sibling_index=Y;
+}
+X=Y;
+U++;
+ResetIndexes(Y,Q[Y]);
+}
+if(X!=-1){
+P[X].next_sibling_index=-1;
+}
+}
+ResetIndexes(-1,-1);
+Assert(U==P.length);
+return P;
+}
+function PatchFunctionCode(v,Z){
+var D=v.corresponding_node.info;
+if(v.live_shared_function_infos){
+v.live_shared_function_infos.forEach(function(aa){
+%LiveEditReplaceFunctionCode(D.raw_array,
+aa.raw_array);
+for(var x=0;x<v.children.length;x++){
+if(v.children[x].corresponding_node){
+var ab=
+v.children[x].corresponding_node.info.
+shared_function_info;
+if(v.children[x].live_shared_function_infos){
+v.children[x].live_shared_function_infos.
+forEach(function(ac){
+%LiveEditReplaceRefToNestedFunction(
+aa.info,
+ab,
+ac.info);
+});
+}
+}
+}
+});
+Z.push({function_patched:D.function_name});
+}else{
+Z.push({function_patched:D.function_name,
+function_info_not_found:true});
+}
+}
+function LinkToOldScript(ad,H,ae){
+if(ad.live_shared_function_infos){
+ad.live_shared_function_infos.
+forEach(function(L){
+%LiveEditFunctionSetScript(L.info,H);
+});
+ae.push({name:ad.info.function_name});
+}else{
+ae.push(
+{name:ad.info.function_name,not_found:true});
+}
+}
+function TemporaryRemoveBreakPoints(af,Z){
+var ag=d(af);
+var ah=[];
+Z.push({break_points_update:ah});
+var ai=[];
+for(var x=0;x<ag.length;x++){
+var aj=ag[x];
+aj.clear();
+var ak=c(af,
+aj.line(),aj.column());
+var al={
+position:ak,
+line:aj.line(),
+column:aj.column()
+};
+ai.push(al);
+}
+return function(m,am){
+for(var x=0;x<ag.length;x++){
+var aj=ag[x];
+if(am){
+var an=aj.cloneForOtherScript(am);
+an.set(am);
+ah.push({
+type:"copied_to_old",
+id:aj.number(),
+new_id:an.number(),
+positions:ai[x]
+});
+}
+var ao=m.Translate(
+ai[x].position,
+PosTranslator.ShiftWithTopInsideChunkHandler);
+var ap=
+af.locationFromPosition(ao,false);
+aj.update_positions(ap.line,ap.column);
+var aq={
+position:ao,
+line:ap.line,
+column:ap.column
+};
+aj.set(af);
+ah.push({type:"position_changed",
+id:aj.number(),
+old_positions:ai[x],
+new_positions:aq
+});
+}
+};
+}
+function Assert(ar,as){
+if(!ar){
+if(as){
+throw"Assert "+as;
+}else{
+throw"Assert";
+}
+}
+}
+function DiffChunk(at,au,av,aw){
+this.pos1=at;
+this.pos2=au;
+this.len1=av;
+this.len2=aw;
+}
+function PosTranslator(ax){
+var ay=new e();
+var az=0;
+for(var x=0;x<ax.length;x+=3){
+var aA=ax[x];
+var aB=aA+az;
+var aC=ax[x+1];
+var aD=ax[x+2];
+ay.push(new DiffChunk(aA,aB,aC-aA,
+aD-aB));
+az=aD-aC;
+}
+this.chunks=ay;
+}
+PosTranslator.prototype.GetChunks=function(){
+return this.chunks;
+};
+PosTranslator.prototype.Translate=function(aE,aF){
+var aG=this.chunks;
+if(aG.length==0||aE<aG[0].pos1){
+return aE;
+}
+var aH=0;
+var aI=aG.length-1;
+while(aH<aI){
+var aJ=f((aH+aI)/2);
+if(aE<aG[aJ+1].pos1){
+aI=aJ;
+}else{
+aH=aJ+1;
+}
+}
+var aK=aG[aH];
+if(aE>=aK.pos1+aK.len1){
+return aE+aK.pos2+aK.len2-aK.pos1-aK.len1;
+}
+if(!aF){
+aF=PosTranslator.DefaultInsideChunkHandler;
+}
+return aF(aE,aK);
+};
+PosTranslator.DefaultInsideChunkHandler=function(aE,aL){
+Assert(false,"Cannot translate position in changed area");
+};
+PosTranslator.ShiftWithTopInsideChunkHandler=
+function(aE,aL){
+return aE-aL.pos1+aL.pos2;
+};
+var i={
+UNCHANGED:"unchanged",
+SOURCE_CHANGED:"source changed",
+CHANGED:"changed",
+DAMAGED:"damaged"
+};
+function CodeInfoTreeNode(aM,aN,aO){
+this.info=aM;
+this.children=aN;
+this.array_index=aO;
+this.parent=(void 0);
+this.status=i.UNCHANGED;
+this.status_explanation=(void 0);
+this.new_start_pos=(void 0);
+this.new_end_pos=(void 0);
+this.corresponding_node=(void 0);
+this.unmatched_new_nodes=(void 0);
+this.textual_corresponding_node=(void 0);
+this.textually_unmatched_new_nodes=(void 0);
+this.live_shared_function_infos=(void 0);
+}
+function BuildCodeInfoTree(aP){
+var aQ=0;
+function BuildNode(){
+var aR=aQ;
+aQ++;
+var aS=new e();
+while(aQ<aP.length&&
+aP[aQ].outer_index==aR){
+aS.push(BuildNode());
+}
+var w=new CodeInfoTreeNode(aP[aR],aS,
+aR);
+for(var x=0;x<aS.length;x++){
+aS[x].parent=w;
+}
+return w;
+}
+var aT=BuildNode();
+Assert(aQ==aP.length);
+return aT;
+}
+function MarkChangedFunctions(aU,ay){
+var aV=new function(){
+var aW=0;
+var aX=0;
+this.current=function(){return ay[aW];};
+this.next=function(){
+var aK=ay[aW];
+aX=aK.pos2+aK.len2-(aK.pos1+aK.len1);
+aW++;
+};
+this.done=function(){return aW>=ay.length;};
+this.TranslatePos=function(aE){return aE+aX;};
+};
+function ProcessInternals(aY){
+aY.new_start_pos=aV.TranslatePos(
+aY.info.start_position);
+var aZ=0;
+var ba=false;
+var bb=false;
+while(!aV.done()&&
+aV.current().pos1<aY.info.end_position){
+if(aZ<aY.children.length){
+var bc=aY.children[aZ];
+if(bc.info.end_position<=aV.current().pos1){
+ProcessUnchangedChild(bc);
+aZ++;
+continue;
+}else if(bc.info.start_position>=
+aV.current().pos1+aV.current().len1){
+ba=true;
+aV.next();
+continue;
+}else if(bc.info.start_position<=aV.current().pos1&&
+bc.info.end_position>=aV.current().pos1+
+aV.current().len1){
+ProcessInternals(bc);
+bb=bb||
+(bc.status!=i.UNCHANGED);
+ba=ba||
+(bc.status==i.DAMAGED);
+aZ++;
+continue;
+}else{
+ba=true;
+bc.status=i.DAMAGED;
+bc.status_explanation=
+"Text diff overlaps with function boundary";
+aZ++;
+continue;
+}
+}else{
+if(aV.current().pos1+aV.current().len1<=
+aY.info.end_position){
+aY.status=i.CHANGED;
+aV.next();
+continue;
+}else{
+aY.status=i.DAMAGED;
+aY.status_explanation=
+"Text diff overlaps with function boundary";
+return;
+}
+}
+Assert("Unreachable",false);
+}
+while(aZ<aY.children.length){
+var bc=aY.children[aZ];
+ProcessUnchangedChild(bc);
+aZ++;
+}
+if(ba){
+aY.status=i.CHANGED;
+}else if(bb){
+aY.status=i.SOURCE_CHANGED;
+}
+aY.new_end_pos=
+aV.TranslatePos(aY.info.end_position);
+}
+function ProcessUnchangedChild(w){
+w.new_start_pos=aV.TranslatePos(w.info.start_position);
+w.new_end_pos=aV.TranslatePos(w.info.end_position);
+}
+ProcessInternals(aU);
+}
+function FindCorrespondingFunctions(bd,be){
+function ProcessNode(v,bf){
+var bg=
+IsFunctionContextLocalsChanged(v.info,bf.info);
+if(bg){
+v.status=i.CHANGED;
+}
+var bh=v.children;
+var bi=bf.children;
+var bj=[];
+var bk=[];
+var bl=0;
+var bm=0;
+while(bl<bh.length){
+if(bh[bl].status==i.DAMAGED){
+bl++;
+}else if(bm<bi.length){
+if(bi[bm].info.start_position<
+bh[bl].new_start_pos){
+bj.push(bi[bm]);
+bk.push(bi[bm]);
+bm++;
+}else if(bi[bm].info.start_position==
+bh[bl].new_start_pos){
+if(bi[bm].info.end_position==
+bh[bl].new_end_pos){
+bh[bl].corresponding_node=
+bi[bm];
+bh[bl].textual_corresponding_node=
+bi[bm];
+if(bg){
+bh[bl].status=i.DAMAGED;
+bh[bl].status_explanation=
+"Enclosing function is now incompatible. "+
+bg;
+bh[bl].corresponding_node=(void 0);
+}else if(bh[bl].status!=
+i.UNCHANGED){
+ProcessNode(bh[bl],
+bi[bm]);
+if(bh[bl].status==i.DAMAGED){
+bj.push(
+bh[bl].corresponding_node);
+bh[bl].corresponding_node=(void 0);
+v.status=i.CHANGED;
+}
+}
+}else{
+bh[bl].status=i.DAMAGED;
+bh[bl].status_explanation=
+"No corresponding function in new script found";
+v.status=i.CHANGED;
+bj.push(bi[bm]);
+bk.push(bi[bm]);
+}
+bm++;
+bl++;
+}else{
+bh[bl].status=i.DAMAGED;
+bh[bl].status_explanation=
+"No corresponding function in new script found";
+v.status=i.CHANGED;
+bl++;
+}
+}else{
+bh[bl].status=i.DAMAGED;
+bh[bl].status_explanation=
+"No corresponding function in new script found";
+v.status=i.CHANGED;
+bl++;
+}
+}
+while(bm<bi.length){
+bj.push(bi[bm]);
+bk.push(bi[bm]);
+bm++;
+}
+if(v.status==i.CHANGED){
+if(v.info.param_num!=bf.info.param_num){
+v.status=i.DAMAGED;
+v.status_explanation="Changed parameter number: "+
+v.info.param_num+" and "+bf.info.param_num;
+}
+}
+v.unmatched_new_nodes=bj;
+v.textually_unmatched_new_nodes=
+bk;
+}
+ProcessNode(bd,be);
+bd.corresponding_node=be;
+bd.textual_corresponding_node=be;
+Assert(bd.status!=i.DAMAGED,
+"Script became damaged");
+}
+function FindLiveSharedInfos(bd,N){
+var bn=%LiveEditFindSharedFunctionInfosForScript(N);
+var bo=new e();
+for(var x=0;x<bn.length;x++){
+bo.push(new SharedInfoWrapper(bn[x]));
+}
+function FindFunctionInfos(P){
+var bp=[];
+for(var x=0;x<bo.length;x++){
+var bq=bo[x];
+if(bq.start_position==P.start_position&&
+bq.end_position==P.end_position){
+bp.push(bq);
+}
+}
+if(bp.length>0){
+return bp;
+}
+}
+function TraverseTree(w){
+w.live_shared_function_infos=FindFunctionInfos(w.info);
+for(var x=0;x<w.children.length;x++){
+TraverseTree(w.children[x]);
+}
+}
+TraverseTree(bd);
+}
+function FunctionCompileInfo(br){
+this.function_name=br[0];
+this.start_position=br[1];
+this.end_position=br[2];
+this.param_num=br[3];
+this.code=br[4];
+this.code_scope_info=br[5];
+this.scope_info=br[6];
+this.outer_index=br[7];
+this.shared_function_info=br[8];
+this.next_sibling_index=null;
+this.raw_array=br;
+}
+function SharedInfoWrapper(br){
+this.function_name=br[0];
+this.start_position=br[1];
+this.end_position=br[2];
+this.info=br[3];
+this.raw_array=br;
+}
+function PatchPositions(ad,ax,ae){
+if(ad.live_shared_function_infos){
+ad.live_shared_function_infos.forEach(function(L){
+%LiveEditPatchFunctionPositions(L.raw_array,
+ax);
+});
+ae.push({name:ad.info.function_name});
+}else{
+ae.push(
+{name:ad.info.function_name,info_not_found:true});
+}
+}
+function CreateNameForOldScript(N){
+return N.name+" (old)";
+}
+function IsFunctionContextLocalsChanged(bs,bt){
+var bu=bs.scope_info;
+var bv=bt.scope_info;
+var bw;
+var bx;
+if(bu){
+bw=bu.toString();
+}else{
+bw="";
+}
+if(bv){
+bx=bv.toString();
+}else{
+bx="";
+}
+if(bw!=bx){
+return"Variable map changed: ["+bw+
+"] => ["+bx+"]";
+}
+return;
+}
+var by;
+function CheckStackActivations(old_shared_wrapper_list,
+new_shared_list,
+Z){
+var bz=new e();
+for(var x=0;x<old_shared_wrapper_list.length;x++){
+bz[x]=old_shared_wrapper_list[x].info;
+}
+var bA=%LiveEditCheckAndDropActivations(
+bz,new_shared_list,true);
+if(bA[old_shared_wrapper_list.length]){
+throw new Failure(bA[old_shared_wrapper_list.length]);
+}
+var bB=new e();
+var bC=new e();
+for(var x=0;x<bz.length;x++){
+var bD=old_shared_wrapper_list[x];
+if(bA[x]==by.REPLACED_ON_ACTIVE_STACK){
+bC.push({name:bD.function_name});
+}else if(bA[x]!=by.AVAILABLE_FOR_PATCH){
+var bE={
+name:bD.function_name,
+start_pos:bD.start_position,
+end_pos:bD.end_position,
+replace_problem:
+by.SymbolName(bA[x])
+};
+bB.push(bE);
+}
+}
+if(bC.length>0){
+Z.push({dropped_from_stack:bC});
+}
+if(bB.length>0){
+Z.push({functions_on_stack:bB});
+throw new Failure("Blocked by functions on stack");
+}
+return bC.length;
+}
+var by={
+AVAILABLE_FOR_PATCH:1,
+BLOCKED_ON_ACTIVE_STACK:2,
+BLOCKED_ON_OTHER_STACK:3,
+BLOCKED_UNDER_NATIVE_CODE:4,
+REPLACED_ON_ACTIVE_STACK:5,
+BLOCKED_UNDER_GENERATOR:6,
+BLOCKED_ACTIVE_GENERATOR:7,
+BLOCKED_NO_NEW_TARGET_ON_RESTART:8
+};
+by.SymbolName=function(bF){
+var bG=by;
+for(var bH in bG){
+if(bG[bH]==bF){
+return bH;
+}
+}
+};
+function Failure(as){
+this.message=as;
+}
+Failure.prototype.toString=function(){
+return"LiveEdit Failure: "+this.message;
+};
+function CopyErrorPositionToDetails(bI,p){
+function createPositionStruct(N,bJ){
+if(bJ==-1)return;
+var bK=N.locationFromPosition(bJ,true);
+if(bK==null)return;
+return{
+line:bK.line+1,
+column:bK.column+1,
+position:bJ
+};
+}
+if(!("scriptObject"in bI)||!("startPosition"in bI)){
+return;
+}
+var N=bI.scriptObject;
+var bL={
+start:createPositionStruct(N,bI.startPosition),
+end:createPositionStruct(N,bI.endPosition)
+};
+p.position=bL;
+}
+function GetPcFromSourcePos(bM,bN){
+return %GetFunctionCodePositionFromSource(bM,bN);
+}
+function SetScriptSource(N,bO,bP,Z){
+var j=N.source;
+var bQ=CompareStrings(j,bO);
+return ApplyPatchMultiChunk(N,bQ,bO,bP,
+Z);
+}
+function CompareStrings(bR,bS){
+return %LiveEditCompareStrings(bR,bS);
+}
+function ApplySingleChunkPatch(N,change_pos,change_len,new_str,
+Z){
+var j=N.source;
+var bO=j.substring(0,change_pos)+
+new_str+j.substring(change_pos+change_len);
+return ApplyPatchMultiChunk(N,
+[change_pos,change_pos+change_len,change_pos+new_str.length],
+bO,false,Z);
+}
+function DescribeChangeTree(bd){
+function ProcessOldNode(w){
+var bT=[];
+for(var x=0;x<w.children.length;x++){
+var bc=w.children[x];
+if(bc.status!=i.UNCHANGED){
+bT.push(ProcessOldNode(bc));
+}
+}
+var bU=[];
+if(w.textually_unmatched_new_nodes){
+for(var x=0;x<w.textually_unmatched_new_nodes.length;x++){
+var bc=w.textually_unmatched_new_nodes[x];
+bU.push(ProcessNewNode(bc));
+}
+}
+var bV={
+name:w.info.function_name,
+positions:DescribePositions(w),
+status:w.status,
+children:bT,
+new_children:bU
+};
+if(w.status_explanation){
+bV.status_explanation=w.status_explanation;
+}
+if(w.textual_corresponding_node){
+bV.new_positions=DescribePositions(w.textual_corresponding_node);
+}
+return bV;
+}
+function ProcessNewNode(w){
+var bT=[];
+if(false){
+for(var x=0;x<w.children.length;x++){
+bT.push(ProcessNewNode(w.children[x]));
+}
+}
+var bV={
+name:w.info.function_name,
+positions:DescribePositions(w),
+children:bT,
+};
+return bV;
+}
+function DescribePositions(w){
+return{
+start_position:w.info.start_position,
+end_position:w.info.end_position
+};
+}
+return ProcessOldNode(bd);
+}
+var bW={};
+bW.SetScriptSource=SetScriptSource;
+bW.ApplyPatchMultiChunk=ApplyPatchMultiChunk;
+bW.Failure=Failure;
+bW.GetPcFromSourcePos=GetPcFromSourcePos;
+bW.TestApi={
+PosTranslator:PosTranslator,
+CompareStrings:CompareStrings,
+ApplySingleChunkPatch:ApplySingleChunkPatch
+};
+a.Debug.LiveEdit=bW;
+})
+
+h prologueK
+(function(a,b,c){
+"use strict";
+%CheckIsBootstrapping();
+var d=(void 0);
+var e=(void 0);
+var f=%ExportFromRuntime({});
+var g=(void 0);
+function SetupTypedArray(h){
+h.next=g;
+g=h;
+}
+function Export(h){
+h(f);
+}
+function Import(h){
+h.next=d;
+d=h;
+}
+function ImportNow(i){
+return f[i];
+}
+function ImportFromExperimental(h){
+h.next=e;
+e=h;
+}
+function SetFunctionName(h,i,j){
+if((typeof(i)==='symbol')){
+i="["+%SymbolDescription(i)+"]";
+}
+if((j===(void 0))){
+%FunctionSetName(h,i);
+}else{
+%FunctionSetName(h,j+" "+i);
+}
+}
+function InstallConstants(k,l){
+%CheckIsBootstrapping();
+%OptimizeObjectForAddingMultipleProperties(k,l.length>>1);
+var m=2|4|1;
+for(var n=0;n<l.length;n+=2){
+var i=l[n];
+var o=l[n+1];
+%AddNamedProperty(k,i,o,m);
+}
+%ToFastProperties(k);
+}
+function InstallFunctions(k,m,p){
+%CheckIsBootstrapping();
+%OptimizeObjectForAddingMultipleProperties(k,p.length>>1);
+for(var n=0;n<p.length;n+=2){
+var q=p[n];
+var h=p[n+1];
+SetFunctionName(h,q);
+%FunctionRemovePrototype(h);
+%AddNamedProperty(k,q,h,m);
+%SetNativeFlag(h);
+}
+%ToFastProperties(k);
+}
+function InstallGetter(k,i,r,m,j){
+%CheckIsBootstrapping();
+if((m===(void 0)))m=2;
+SetFunctionName(r,i,(j===(void 0))?"get":j);
+%FunctionRemovePrototype(r);
+%DefineGetterPropertyUnchecked(k,i,r,m);
+%SetNativeFlag(r);
+}
+function InstallGetterSetter(k,i,r,s,m){
+%CheckIsBootstrapping();
+if((m===(void 0)))m=2;
+SetFunctionName(r,i,"get");
+SetFunctionName(s,i,"set");
+%FunctionRemovePrototype(r);
+%FunctionRemovePrototype(s);
+%DefineAccessorPropertyUnchecked(k,i,r,s,2);
+%SetNativeFlag(r);
+%SetNativeFlag(s);
+}
+function SetUpLockedPrototype(
+constructor,fields,methods){
+%CheckIsBootstrapping();
+var t=constructor.prototype;
+var u=(methods.length>>1)+(fields?fields.length:0);
+if(u>=4){
+%OptimizeObjectForAddingMultipleProperties(t,u);
+}
+if(fields){
+for(var n=0;n<fields.length;n++){
+%AddNamedProperty(t,fields[n],
+(void 0),2|4);
+}
+}
+for(var n=0;n<methods.length;n+=2){
+var q=methods[n];
+var h=methods[n+1];
+%AddNamedProperty(t,q,h,2|4|1);
+%SetNativeFlag(h);
+}
+%InternalSetPrototype(t,null);
+%ToFastProperties(t);
+}
+function PostNatives(b){
+%CheckIsBootstrapping();
+for(;!(d===(void 0));d=d.next){
+d(f);
+}
+var v=[
+"ArrayToString",
+"ErrorToString",
+"GetIterator",
+"GetMethod",
+"IsNaN",
+"MakeError",
+"MakeTypeError",
+"MapEntries",
+"MapIterator",
+"MapIteratorNext",
+"MathMax",
+"MathMin",
+"MaxSimple",
+"MinSimple",
+"ObjectDefineProperty",
+"ObserveArrayMethods",
+"ObserveObjectMethods",
+"PromiseChain",
+"PromiseDeferred",
+"PromiseResolved",
+"SameValueZero",
+"SetIterator",
+"SetIteratorNext",
+"SetValues",
+"SymbolToString",
+"ToPositiveInteger",
+"is_concat_spreadable_symbol",
+"iterator_symbol",
+"promise_status_symbol",
+"promise_value_symbol",
+"object_freeze",
+"object_is_frozen",
+"object_is_sealed",
+"reflect_apply",
+"reflect_construct",
+"regexp_flags_symbol",
+"to_string_tag_symbol",
+"object_to_string",
+"species_symbol",
+];
+var w={};
+%OptimizeObjectForAddingMultipleProperties(
+w,v.length);
+for(var q of v){
+w[q]=f[q];
+}
+%ToFastProperties(w);
+f=w;
+b.PostNatives=(void 0);
+b.ImportFromExperimental=(void 0);
+}
+function PostExperimentals(b){
+%CheckIsBootstrapping();
+%ExportExperimentalFromRuntime(f);
+for(;!(d===(void 0));d=d.next){
+d(f);
+}
+for(;!(e===(void 0));
+e=e.next){
+e(f);
+}
+b.CreateDoubleResultArray();
+b.CreateDoubleResultArray=(void 0);
+b.Export=(void 0);
+b.PostDebug=(void 0);
+b.PostExperimentals=(void 0);
+g=(void 0);
+}
+function PostDebug(b){
+for(;!(d===(void 0));d=d.next){
+d(f);
+}
+b.CreateDoubleResultArray();
+b.CreateDoubleResultArray=(void 0);
+f=(void 0);
+b.Export=(void 0);
+b.Import=(void 0);
+b.ImportNow=(void 0);
+b.PostDebug=(void 0);
+b.PostExperimentals=(void 0);
+g=(void 0);
+}
+function InitializeBuiltinTypedArrays(b,x,y){
+var z=g;
+for(;!(z===(void 0));z=z.next){
+z(x,y);
+}
+}
+%OptimizeObjectForAddingMultipleProperties(b,14);
+b.Import=Import;
+b.ImportNow=ImportNow;
+b.Export=Export;
+b.ImportFromExperimental=ImportFromExperimental;
+b.SetFunctionName=SetFunctionName;
+b.InstallConstants=InstallConstants;
+b.InstallFunctions=InstallFunctions;
+b.InstallGetter=InstallGetter;
+b.InstallGetterSetter=InstallGetterSetter;
+b.SetUpLockedPrototype=SetUpLockedPrototype;
+b.PostNatives=PostNatives;
+b.PostExperimentals=PostExperimentals;
+b.PostDebug=PostDebug;
+%ToFastProperties(b);
+%OptimizeObjectForAddingMultipleProperties(c,5);
+c.logStackTrace=function logStackTrace(){
+%DebugTrace();
+};
+c.log=function log(){
+let message='';
+for(const arg of arguments){
+message+=arg;
+}
+%GlobalPrint(message);
+};
+c.createPrivateSymbol=function createPrivateSymbol(i){
+return %CreatePrivateSymbol(i);
+};
+c.simpleBind=function simpleBind(A,B){
+return function(){
+return %Apply(A,B,arguments,0,arguments.length);
+};
+};
+c.uncurryThis=function uncurryThis(A){
+return function(B){
+return %Apply(A,B,arguments,1,arguments.length-1);
+};
+};
+%ToFastProperties(c);
+})
+
+runtime9"
+(function(a,b){
+%CheckIsBootstrapping();
+var c;
+var d=a.Array;
+var e=a.Boolean;
+var f=a.String;
+var g;
+var h;
+var i;
+b.Import(function(j){
+g=j.MakeRangeError;
+h=j.MakeTypeError;
+i=j.species_symbol;
+});
+b.ImportFromExperimental(function(j){
+c=j.FLAG_harmony_species;
+});
+function CONCAT_ITERABLE_TO_ARRAY(k){
+return %concat_iterable_to_array(this,k);
+};
+function SameValue(l,m){
+if(typeof l!=typeof m)return false;
+if((typeof(l)==='number')){
+if((!%_IsSmi(%IS_VAR(l))&&!(l==l))&&(!%_IsSmi(%IS_VAR(m))&&!(m==m)))return true;
+if(l===0&&m===0&&%_IsMinusZero(l)!=%_IsMinusZero(m)){
+return false;
+}
+}
+if((%_IsSimdValue(l)))return %SimdSameValue(l,m);
+return l===m;
+}
+function SameValueZero(l,m){
+if(typeof l!=typeof m)return false;
+if((typeof(l)==='number')){
+if((!%_IsSmi(%IS_VAR(l))&&!(l==l))&&(!%_IsSmi(%IS_VAR(m))&&!(m==m)))return true;
+}
+if((%_IsSimdValue(l)))return %SimdSameValueZero(l,m);
+return l===m;
+}
+function ConcatIterableToArray(n,k){
+var o=n.length;
+for(var p of k){
+AddIndexedProperty(n,o++,p);
+}
+return n;
+}
+function AddIndexedProperty(q,o,r){
+if(o===((o)>>>0)&&o!==4294967295){
+%AddElement(q,o,r);
+}else{
+%AddNamedProperty(q,(%_ToString(o)),r,0);
+}
+}
+%SetForceInlineFlag(AddIndexedProperty);
+function ToPositiveInteger(l,s){
+var t=(%_IsSmi(%IS_VAR(l))?l:%NumberToIntegerMapMinusZero(l));
+if(t<0)throw g(s);
+return t;
+}
+function MaxSimple(u,v){
+return u>v?u:v;
+}
+function MinSimple(u,v){
+return u>v?v:u;
+}
+%SetForceInlineFlag(MaxSimple);
+%SetForceInlineFlag(MinSimple);
+function SpeciesConstructor(w,x,y){
+if(c){
+var z=w.constructor;
+if((z===(void 0))){
+return x;
+}
+if(!(%_IsJSReceiver(z))){
+throw h(27);
+}
+var A=z[i];
+if((A==null)){
+return x;
+}
+if(%IsConstructor(A)){
+return A;
+}
+throw h(235);
+}else{
+return y?x:w.constructor;
+}
+}
+%FunctionSetPrototype(d,new d(0));
+b.Export(function(B){
+B.AddIndexedProperty=AddIndexedProperty;
+B.MaxSimple=MaxSimple;
+B.MinSimple=MinSimple;
+B.SameValue=SameValue;
+B.SameValueZero=SameValueZero;
+B.ToPositiveInteger=ToPositiveInteger;
+B.SpeciesConstructor=SpeciesConstructor;
+});
+%InstallToContext([
+"concat_iterable_to_array_builtin",CONCAT_ITERABLE_TO_ARRAY,
+]);
+%InstallToContext([
+"concat_iterable_to_array",ConcatIterableToArray,
+]);
+})
+
+$v8natives�#

+(function(a,b){
+%CheckIsBootstrapping();
+var c=a.Array;
+var d=a.Boolean;
+var e=a.Number;
+var f=a.Object;
+var g=b.InternalArray;
+var h=b.ImportNow("iterator_symbol");
+var i;
+var j;
+var k;
+var l;
+var m=%GetRootNaN();
+var n=b.ImportNow("object_to_string");
+var o;
+var p;
+var q;
+var r=b.ImportNow("SameValue");
+var s=b.ImportNow("to_string_tag_symbol");
+b.Import(function(t){
+i=t.MakeRangeError;
+j=t.MakeSyntaxError;
+k=t.MakeTypeError;
+l=t.MathAbs;
+o=t.ObserveBeginPerformSplice;
+p=t.ObserveEndPerformSplice;
+q=t.ObserveEnqueueSpliceRecord;
+});
+function GlobalIsNaN(u){
+u=(%_ToNumber(u));
+return(!%_IsSmi(%IS_VAR(u))&&!(u==u));
+}
+function GlobalIsFinite(u){
+u=(%_ToNumber(u));
+return(%_IsSmi(%IS_VAR(u))||((u==u)&&(u!=1/0)&&(u!=-1/0)));
+}
+function GlobalParseInt(v,w){
+if((w===(void 0))||w===10||w===0){
+if(%_IsSmi(v))return v;
+if((typeof(v)==='number')&&
+((0.01<v&&v<1e9)||
+(-1e9<v&&v<-0.01))){
+return v|0;
+}
+v=(%_ToString(v));
+w=w|0;
+}else{
+v=(%_ToString(v));
+w=((w)|0);
+if(!(w==0||(2<=w&&w<=36))){
+return m;
+}
+}
+if(%_HasCachedArrayIndex(v)&&
+(w==0||w==10)){
+return %_GetCachedArrayIndex(v);
+}
+return %StringParseInt(v,w);
+}
+function GlobalParseFloat(v){
+v=(%_ToString(v));
+if(%_HasCachedArrayIndex(v))return %_GetCachedArrayIndex(v);
+return %StringParseFloat(v);
+}
+var x=2|4|1;
+b.InstallConstants(a,[
+"Infinity",(1/0),
+"NaN",m,
+"undefined",(void 0),
+]);
+b.InstallFunctions(a,2,[
+"isNaN",GlobalIsNaN,
+"isFinite",GlobalIsFinite,
+"parseInt",GlobalParseInt,
+"parseFloat",GlobalParseFloat,
+]);
+function ObjectToLocaleString(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(17,"Object.prototype.toLocaleString");
+return this.toString();
+}
+function ObjectValueOf(){
+return(%_ToObject(this));
+}
+function ObjectHasOwnProperty(y){
+var z=(%_ToName(y));
+var A=(%_ToObject(this));
+return %HasOwnProperty(A,z);
+}
+function ObjectIsPrototypeOf(B){
+if(!(%_IsJSReceiver(B)))return false;
+var C=(%_ToObject(this));
+return %HasInPrototypeChain(B,C);
+}
+function ObjectPropertyIsEnumerable(B){
+var D=(%_ToName(B));
+return %PropertyIsEnumerable((%_ToObject(this)),D);
+}
+function ObjectDefineGetter(z,E){
+var F=this;
+if((F===null)||(F===(void 0))){
+F=%GlobalProxy(ObjectDefineGetter);
+}
+if(!(typeof(E)==='function')){
+throw k(72);
+}
+var G=new PropertyDescriptor();
+G.setGet(E);
+G.setEnumerable(true);
+G.setConfigurable(true);
+DefineOwnProperty((%_ToObject(F)),(%_ToName(z)),G,false);
+}
+function ObjectLookupGetter(z){
+var F=this;
+if((F===null)||(F===(void 0))){
+F=%GlobalProxy(ObjectLookupGetter);
+}
+return %LookupAccessor((%_ToObject(F)),(%_ToName(z)),0);
+}
+function ObjectDefineSetter(z,E){
+var F=this;
+if((F===null)||(F===(void 0))){
+F=%GlobalProxy(ObjectDefineSetter);
+}
+if(!(typeof(E)==='function')){
+throw k(75);
+}
+var G=new PropertyDescriptor();
+G.setSet(E);
+G.setEnumerable(true);
+G.setConfigurable(true);
+DefineOwnProperty((%_ToObject(F)),(%_ToName(z)),G,false);
+}
+function ObjectLookupSetter(z){
+var F=this;
+if((F===null)||(F===(void 0))){
+F=%GlobalProxy(ObjectLookupSetter);
+}
+return %LookupAccessor((%_ToObject(F)),(%_ToName(z)),1);
+}
+function IsAccessorDescriptor(G){
+if((G===(void 0)))return false;
+return G.hasGetter()||G.hasSetter();
+}
+function IsDataDescriptor(G){
+if((G===(void 0)))return false;
+return G.hasValue()||G.hasWritable();
+}
+function IsGenericDescriptor(G){
+if((G===(void 0)))return false;
+return!(IsAccessorDescriptor(G)||IsDataDescriptor(G));
+}
+function IsInconsistentDescriptor(G){
+return IsAccessorDescriptor(G)&&IsDataDescriptor(G);
+}
+function FromGenericPropertyDescriptor(G){
+if((G===(void 0)))return G;
+var H=new f();
+if(G.hasValue()){
+%AddNamedProperty(H,"value",G.getValue(),0);
+}
+if(G.hasWritable()){
+%AddNamedProperty(H,"writable",G.isWritable(),0);
+}
+if(G.hasGetter()){
+%AddNamedProperty(H,"get",G.getGet(),0);
+}
+if(G.hasSetter()){
+%AddNamedProperty(H,"set",G.getSet(),0);
+}
+if(G.hasEnumerable()){
+%AddNamedProperty(H,"enumerable",G.isEnumerable(),0);
+}
+if(G.hasConfigurable()){
+%AddNamedProperty(H,"configurable",G.isConfigurable(),0);
+}
+return H;
+}
+function ToPropertyDescriptor(H){
+if(!(%_IsJSReceiver(H)))throw k(90,H);
+var G=new PropertyDescriptor();
+if("enumerable"in H){
+G.setEnumerable((!!(H.enumerable)));
+}
+if("configurable"in H){
+G.setConfigurable((!!(H.configurable)));
+}
+if("value"in H){
+G.setValue(H.value);
+}
+if("writable"in H){
+G.setWritable((!!(H.writable)));
+}
+if("get"in H){
+var I=H.get;
+if(!(I===(void 0))&&!(typeof(I)==='function')){
+throw k(73,I);
+}
+G.setGet(I);
+}
+if("set"in H){
+var J=H.set;
+if(!(J===(void 0))&&!(typeof(J)==='function')){
+throw k(76,J);
+}
+G.setSet(J);
+}
+if(IsInconsistentDescriptor(G)){
+throw k(153,H);
+}
+return G;
+}
+function ToCompletePropertyDescriptor(H){
+var G=ToPropertyDescriptor(H);
+if(IsGenericDescriptor(G)||IsDataDescriptor(G)){
+if(!G.hasValue())G.setValue((void 0));
+if(!G.hasWritable())G.setWritable(false);
+}else{
+if(!G.hasGetter())G.setGet((void 0));
+if(!G.hasSetter())G.setSet((void 0));
+}
+if(!G.hasEnumerable())G.setEnumerable(false);
+if(!G.hasConfigurable())G.setConfigurable(false);
+return G;
+}
+function PropertyDescriptor(){
+this.value_=(void 0);
+this.hasValue_=false;
+this.writable_=false;
+this.hasWritable_=false;
+this.enumerable_=false;
+this.hasEnumerable_=false;
+this.configurable_=false;
+this.hasConfigurable_=false;
+this.get_=(void 0);
+this.hasGetter_=false;
+this.set_=(void 0);
+this.hasSetter_=false;
+}
+b.SetUpLockedPrototype(PropertyDescriptor,[
+"value_",
+"hasValue_",
+"writable_",
+"hasWritable_",
+"enumerable_",
+"hasEnumerable_",
+"configurable_",
+"hasConfigurable_",
+"get_",
+"hasGetter_",
+"set_",
+"hasSetter_"
+],[
+"toString",function PropertyDescriptor_ToString(){
+return"[object PropertyDescriptor]";
+},
+"setValue",function PropertyDescriptor_SetValue(y){
+this.value_=y;
+this.hasValue_=true;
+},
+"getValue",function PropertyDescriptor_GetValue(){
+return this.value_;
+},
+"hasValue",function PropertyDescriptor_HasValue(){
+return this.hasValue_;
+},
+"setEnumerable",function PropertyDescriptor_SetEnumerable(K){
+this.enumerable_=K;
+this.hasEnumerable_=true;
+},
+"isEnumerable",function PropertyDescriptor_IsEnumerable(){
+return this.enumerable_;
+},
+"hasEnumerable",function PropertyDescriptor_HasEnumerable(){
+return this.hasEnumerable_;
+},
+"setWritable",function PropertyDescriptor_SetWritable(L){
+this.writable_=L;
+this.hasWritable_=true;
+},
+"isWritable",function PropertyDescriptor_IsWritable(){
+return this.writable_;
+},
+"hasWritable",function PropertyDescriptor_HasWritable(){
+return this.hasWritable_;
+},
+"setConfigurable",
+function PropertyDescriptor_SetConfigurable(M){
+this.configurable_=M;
+this.hasConfigurable_=true;
+},
+"hasConfigurable",function PropertyDescriptor_HasConfigurable(){
+return this.hasConfigurable_;
+},
+"isConfigurable",function PropertyDescriptor_IsConfigurable(){
+return this.configurable_;
+},
+"setGet",function PropertyDescriptor_SetGetter(I){
+this.get_=I;
+this.hasGetter_=true;
+},
+"getGet",function PropertyDescriptor_GetGetter(){
+return this.get_;
+},
+"hasGetter",function PropertyDescriptor_HasGetter(){
+return this.hasGetter_;
+},
+"setSet",function PropertyDescriptor_SetSetter(J){
+this.set_=J;
+this.hasSetter_=true;
+},
+"getSet",function PropertyDescriptor_GetSetter(){
+return this.set_;
+},
+"hasSetter",function PropertyDescriptor_HasSetter(){
+return this.hasSetter_;
+}
+]);
+function ConvertDescriptorArrayToDescriptor(N){
+if((N===(void 0))){
+return(void 0);
+}
+var G=new PropertyDescriptor();
+if(N[0]){
+G.setGet(N[2]);
+G.setSet(N[3]);
+}else{
+G.setValue(N[1]);
+G.setWritable(N[4]);
+}
+G.setEnumerable(N[5]);
+G.setConfigurable(N[6]);
+return G;
+}
+function GetTrap(O,z,P){
+var Q=O[z];
+if((Q===(void 0))){
+if((P===(void 0))){
+throw k(41);
+}
+Q=P;
+}else if(!(typeof(Q)==='function')){
+throw k(41);
+}
+return Q;
+}
+function CallTrap1(O,z,P,R){
+return %_Call(GetTrap(O,z,P),O,R);
+}
+function CallTrap2(O,z,P,R,S){
+return %_Call(GetTrap(O,z,P),O,R,S);
+}
+function GetOwnPropertyJS(H,T){
+var U=(%_ToName(T));
+if((%_IsJSProxy(H))){
+if((typeof(T)==='symbol'))return(void 0);
+var O=%JSProxyGetHandler(H);
+var V=CallTrap1(
+O,"getOwnPropertyDescriptor",(void 0),U);
+if((V===(void 0)))return V;
+var G=ToCompletePropertyDescriptor(V);
+if(!G.isConfigurable()){
+throw k(41);
+}
+return G;
+}
+var W=%GetOwnProperty_Legacy((%_ToObject(H)),U);
+return ConvertDescriptorArrayToDescriptor(W);
+}
+function GetMethod(H,U){
+var X=H[U];
+if((X==null))return(void 0);
+if((typeof(X)==='function'))return X;
+throw k(15,typeof X);
+}
+function DefineProxyProperty(H,U,x,Y){
+if((typeof(U)==='symbol'))return false;
+var O=%JSProxyGetHandler(H);
+var Z=CallTrap2(O,"defineProperty",(void 0),U,x);
+if(!Z){
+if(Y){
+throw k(41);
+}else{
+return false;
+}
+}
+return true;
+}
+function DefineObjectProperty(H,U,G,Y){
+var aa=%GetOwnProperty_Legacy(H,(%_ToName(U)));
+var ab=ConvertDescriptorArrayToDescriptor(aa);
+var ac=%object_is_extensible(H);
+if((ab===(void 0))&&!ac){
+if(Y){
+throw k(34,U);
+}else{
+return false;
+}
+}
+if(!(ab===(void 0))){
+if((IsGenericDescriptor(G)||
+IsDataDescriptor(G)==IsDataDescriptor(ab))&&
+(!G.hasEnumerable()||
+r(G.isEnumerable(),ab.isEnumerable()))&&
+(!G.hasConfigurable()||
+r(G.isConfigurable(),ab.isConfigurable()))&&
+(!G.hasWritable()||
+r(G.isWritable(),ab.isWritable()))&&
+(!G.hasValue()||
+r(G.getValue(),ab.getValue()))&&
+(!G.hasGetter()||
+r(G.getGet(),ab.getGet()))&&
+(!G.hasSetter()||
+r(G.getSet(),ab.getSet()))){
+return true;
+}
+if(!ab.isConfigurable()){
+if(G.isConfigurable()||
+(G.hasEnumerable()&&
+G.isEnumerable()!=ab.isEnumerable())){
+if(Y){
+throw k(126,U);
+}else{
+return false;
+}
+}
+if(!IsGenericDescriptor(G)){
+if(IsDataDescriptor(ab)!=IsDataDescriptor(G)){
+if(Y){
+throw k(126,U);
+}else{
+return false;
+}
+}
+if(IsDataDescriptor(ab)&&IsDataDescriptor(G)){
+var ad=ab.isWritable();
+if(ad!=G.isWritable()){
+if(!ad||(%IsStrong(H))){
+if(Y){
+throw ad
+?k(146,H,U)
+:k(126,U);
+}else{
+return false;
+}
+}
+}
+if(!ad&&G.hasValue()&&
+!r(G.getValue(),ab.getValue())){
+if(Y){
+throw k(126,U);
+}else{
+return false;
+}
+}
+}
+if(IsAccessorDescriptor(G)&&IsAccessorDescriptor(ab)){
+if(G.hasSetter()&&
+!r(G.getSet(),ab.getSet())){
+if(Y){
+throw k(126,U);
+}else{
+return false;
+}
+}
+if(G.hasGetter()&&!r(G.getGet(),ab.getGet())){
+if(Y){
+throw k(126,U);
+}else{
+return false;
+}
+}
+}
+}
+}
+}
+var ae=0;
+if(G.hasEnumerable()){
+ae|=G.isEnumerable()?0:2;
+}else if(!(ab===(void 0))){
+ae|=ab.isEnumerable()?0:2;
+}else{
+ae|=2;
+}
+if(G.hasConfigurable()){
+ae|=G.isConfigurable()?0:4;
+}else if(!(ab===(void 0))){
+ae|=ab.isConfigurable()?0:4;
+}else
+ae|=4;
+if(IsDataDescriptor(G)||
+(IsGenericDescriptor(G)&&
+((ab===(void 0))||IsDataDescriptor(ab)))){
+if(G.hasWritable()){
+ae|=G.isWritable()?0:1;
+}else if(!(ab===(void 0))){
+ae|=ab.isWritable()?0:1;
+}else{
+ae|=1;
+}
+var y=(void 0);
+if(G.hasValue()){
+y=G.getValue();
+}else if(!(ab===(void 0))&&IsDataDescriptor(ab)){
+y=ab.getValue();
+}
+%DefineDataPropertyUnchecked(H,U,y,ae);
+}else{
+var af=null;
+if(G.hasGetter()){
+af=G.getGet();
+}else if(IsAccessorDescriptor(ab)&&ab.hasGetter()){
+af=ab.getGet();
+}
+var ag=null;
+if(G.hasSetter()){
+ag=G.getSet();
+}else if(IsAccessorDescriptor(ab)&&ab.hasSetter()){
+ag=ab.getSet();
+}
+%DefineAccessorPropertyUnchecked(H,U,af,ag,ae);
+}
+return true;
+}
+function DefineArrayProperty(H,U,G,Y){
+if(!(typeof(U)==='symbol')){
+var ah=((U)>>>0);
+var ai=false;
+if((%_ToString(ah))==U&&ah!=4294967295){
+var aj=H.length;
+if(ah>=aj&&%IsObserved(H)){
+ai=true;
+o(H);
+}
+var ak=GetOwnPropertyJS(H,"length");
+if((ah>=aj&&!ak.isWritable())||
+!DefineObjectProperty(H,U,G,true)){
+if(ai)
+p(H);
+if(Y){
+throw k(34,U);
+}else{
+return false;
+}
+}
+if(ah>=aj){
+H.length=ah+1;
+}
+if(ai){
+p(H);
+q(H,aj,[],ah+1-aj);
+}
+return true;
+}
+}
+return DefineObjectProperty(H,U,G,Y);
+}
+function DefineOwnProperty(H,U,G,Y){
+if((%_IsJSProxy(H))){
+if((typeof(U)==='symbol'))return false;
+var x=FromGenericPropertyDescriptor(G);
+return DefineProxyProperty(H,U,x,Y);
+}else if((%_IsArray(H))){
+return DefineArrayProperty(H,U,G,Y);
+}else{
+return DefineObjectProperty(H,U,G,Y);
+}
+}
+function ObjectGetPrototypeOf(H){
+return %_GetPrototype((%_ToObject(H)));
+}
+function ObjectSetPrototypeOf(H,al){
+if((%IS_VAR(H)===null)||(H===(void 0)))throw k(17,"Object.setPrototypeOf");
+if(al!==null&&!(%_IsJSReceiver(al))){
+throw k(92,al);
+}
+if((%_IsJSReceiver(H))){
+%SetPrototype(H,al);
+}
+return H;
+}
+function ObjectGetOwnPropertyDescriptor(H,U){
+return %GetOwnProperty(H,U);
+}
+function ObjectGetOwnPropertyNames(H){
+H=(%_ToObject(H));
+return %GetOwnPropertyKeys(H,16);
+}
+function ObjectDefineProperty(H,U,x){
+if(%IsObserved(H)){
+if(!(%_IsJSReceiver(H))){
+throw k(16,"Object.defineProperty");
+}
+var z=(%_ToName(U));
+var G=ToPropertyDescriptor(x);
+DefineOwnProperty(H,z,G,true);
+return H;
+}
+return %ObjectDefineProperty(H,U,x);
+}
+function GetOwnEnumerablePropertyNames(A){
+return %GetOwnPropertyKeys(A,2);
+}
+function ObjectDefineProperties(H,am){
+if(%IsObserved(H)){
+if(!(%_IsJSReceiver(H))){
+throw k(16,"Object.defineProperties");
+}
+var W=(%_ToObject(am));
+var an=GetOwnEnumerablePropertyNames(W);
+var ao=new g();
+for(var ap=0;ap<an.length;ap++){
+ao.push(ToPropertyDescriptor(W[an[ap]]));
+}
+for(var ap=0;ap<an.length;ap++){
+DefineOwnProperty(H,an[ap],ao[ap],true);
+}
+return H;
+}
+return %ObjectDefineProperties(H,am);
+}
+function ObjectGetProto(){
+return %_GetPrototype((%_ToObject(this)));
+}
+function ObjectSetProto(al){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(17,"Object.prototype.__proto__");
+if(((%_IsJSReceiver(al))||(al===null))&&(%_IsJSReceiver(this))){
+%SetPrototype(this,al);
+}
+}
+function ObjectConstructor(R){
+if(f!=new.target&&!(new.target===(void 0))){
+return this;
+}
+if((R===null)||(R===(void 0)))return{};
+return(%_ToObject(R));
+}
+%SetNativeFlag(f);
+%SetCode(f,ObjectConstructor);
+%AddNamedProperty(f.prototype,"constructor",f,
+2);
+b.InstallFunctions(f.prototype,2,[
+"toString",n,
+"toLocaleString",ObjectToLocaleString,
+"valueOf",ObjectValueOf,
+"hasOwnProperty",ObjectHasOwnProperty,
+"isPrototypeOf",ObjectIsPrototypeOf,
+"propertyIsEnumerable",ObjectPropertyIsEnumerable,
+"__defineGetter__",ObjectDefineGetter,
+"__lookupGetter__",ObjectLookupGetter,
+"__defineSetter__",ObjectDefineSetter,
+"__lookupSetter__",ObjectLookupSetter
+]);
+b.InstallGetterSetter(f.prototype,"__proto__",ObjectGetProto,
+ObjectSetProto);
+b.InstallFunctions(f,2,[
+"defineProperty",ObjectDefineProperty,
+"defineProperties",ObjectDefineProperties,
+"getPrototypeOf",ObjectGetPrototypeOf,
+"setPrototypeOf",ObjectSetPrototypeOf,
+"getOwnPropertyDescriptor",ObjectGetOwnPropertyDescriptor,
+"getOwnPropertyNames",ObjectGetOwnPropertyNames,
+"is",r,
+]);
+function BooleanConstructor(R){
+"use strict";
+if(!(new.target===(void 0))){
+%_SetValueOf(this,(!!(R)));
+}else{
+return(!!(R));
+}
+}
+function BooleanToString(){
+var aq=this;
+if(!(typeof(aq)==='boolean')){
+if(!(%_ClassOf(aq)==='Boolean')){
+throw k(65,'Boolean.prototype.toString');
+}
+aq=%_ValueOf(aq);
+}
+return aq?'true':'false';
+}
+function BooleanValueOf(){
+if(!(typeof(this)==='boolean')&&!(%_ClassOf(this)==='Boolean')){
+throw k(65,'Boolean.prototype.valueOf');
+}
+return %_ValueOf(this);
+}
+%SetCode(d,BooleanConstructor);
+%FunctionSetPrototype(d,new d(false));
+%AddNamedProperty(d.prototype,"constructor",d,
+2);
+b.InstallFunctions(d.prototype,2,[
+"toString",BooleanToString,
+"valueOf",BooleanValueOf
+]);
+function NumberToStringJS(w){
+var u=this;
+if(!(typeof(this)==='number')){
+if(!(%_ClassOf(this)==='Number')){
+throw k(65,'Number.prototype.toString');
+}
+u=%_ValueOf(this);
+}
+if((w===(void 0))||w===10){
+return %_NumberToString(u);
+}
+w=(%_ToInteger(w));
+if(w<2||w>36)throw i(189);
+return %NumberToRadixString(u,w);
+}
+function NumberToLocaleString(){
+return %_Call(NumberToStringJS,this);
+}
+function NumberValueOf(){
+if(!(typeof(this)==='number')&&!(%_ClassOf(this)==='Number')){
+throw k(65,'Number.prototype.valueOf');
+}
+return %_ValueOf(this);
+}
+function NumberToFixedJS(ar){
+var R=this;
+if(!(typeof(this)==='number')){
+if(!(%_ClassOf(this)==='Number')){
+throw k(42,
+"Number.prototype.toFixed",this);
+}
+R=%_ValueOf(this);
+}
+var as=(%_ToInteger(ar));
+if(as<0||as>20){
+throw i(185,"toFixed() digits");
+}
+if((!%_IsSmi(%IS_VAR(R))&&!(R==R)))return"NaN";
+if(R==(1/0))return"Infinity";
+if(R==-(1/0))return"-Infinity";
+return %NumberToFixed(R,as);
+}
+function NumberToExponentialJS(ar){
+var R=this;
+if(!(typeof(this)==='number')){
+if(!(%_ClassOf(this)==='Number')){
+throw k(42,
+"Number.prototype.toExponential",this);
+}
+R=%_ValueOf(this);
+}
+var as=(ar===(void 0))?(void 0):(%_ToInteger(ar));
+if((!%_IsSmi(%IS_VAR(R))&&!(R==R)))return"NaN";
+if(R==(1/0))return"Infinity";
+if(R==-(1/0))return"-Infinity";
+if((as===(void 0))){
+as=-1;
+}else if(as<0||as>20){
+throw i(185,"toExponential()");
+}
+return %NumberToExponential(R,as);
+}
+function NumberToPrecisionJS(at){
+var R=this;
+if(!(typeof(this)==='number')){
+if(!(%_ClassOf(this)==='Number')){
+throw k(42,
+"Number.prototype.toPrecision",this);
+}
+R=%_ValueOf(this);
+}
+if((at===(void 0)))return(%_ToString(R));
+var U=(%_ToInteger(at));
+if((!%_IsSmi(%IS_VAR(R))&&!(R==R)))return"NaN";
+if(R==(1/0))return"Infinity";
+if(R==-(1/0))return"-Infinity";
+if(U<1||U>21){
+throw i(188);
+}
+return %NumberToPrecision(R,U);
+}
+function NumberIsFinite(u){
+return(typeof(u)==='number')&&(%_IsSmi(%IS_VAR(u))||((u==u)&&(u!=1/0)&&(u!=-1/0)));
+}
+function NumberIsInteger(u){
+return NumberIsFinite(u)&&(%_ToInteger(u))==u;
+}
+function NumberIsNaN(u){
+return(typeof(u)==='number')&&(!%_IsSmi(%IS_VAR(u))&&!(u==u));
+}
+function NumberIsSafeInteger(u){
+if(NumberIsFinite(u)){
+var au=(%_ToInteger(u));
+if(au==u){
+return l(au)<=9007199254740991;
+}
+}
+return false;
+}
+%FunctionSetPrototype(e,new e(0));
+%OptimizeObjectForAddingMultipleProperties(e.prototype,8);
+%AddNamedProperty(e.prototype,"constructor",e,
+2);
+b.InstallConstants(e,[
+"MAX_VALUE",1.7976931348623157e+308,
+"MIN_VALUE",5e-324,
+"NaN",m,
+"NEGATIVE_INFINITY",-(1/0),
+"POSITIVE_INFINITY",(1/0),
+"MAX_SAFE_INTEGER",%_MathPow(2,53)-1,
+"MIN_SAFE_INTEGER",-%_MathPow(2,53)+1,
+"EPSILON",%_MathPow(2,-52)
+]);
+b.InstallFunctions(e.prototype,2,[
+"toString",NumberToStringJS,
+"toLocaleString",NumberToLocaleString,
+"valueOf",NumberValueOf,
+"toFixed",NumberToFixedJS,
+"toExponential",NumberToExponentialJS,
+"toPrecision",NumberToPrecisionJS
+]);
+b.InstallFunctions(e,2,[
+"isFinite",NumberIsFinite,
+"isInteger",NumberIsInteger,
+"isNaN",NumberIsNaN,
+"isSafeInteger",NumberIsSafeInteger,
+"parseInt",GlobalParseInt,
+"parseFloat",GlobalParseFloat
+]);
+%SetForceInlineFlag(NumberIsNaN);
+function GetIterator(H,av){
+if((av===(void 0))){
+av=H[h];
+}
+if(!(typeof(av)==='function')){
+throw k(66,H);
+}
+var aw=%_Call(av,H);
+if(!(%_IsJSReceiver(aw))){
+throw k(60,aw);
+}
+return aw;
+}
+b.Export(function(ax){
+ax.GetIterator=GetIterator;
+ax.GetMethod=GetMethod;
+ax.IsFinite=GlobalIsFinite;
+ax.IsNaN=GlobalIsNaN;
+ax.NumberIsNaN=NumberIsNaN;
+ax.ObjectDefineProperties=ObjectDefineProperties;
+ax.ObjectDefineProperty=ObjectDefineProperty;
+ax.ObjectHasOwnProperty=ObjectHasOwnProperty;
+});
+%InstallToContext([
+"object_value_of",ObjectValueOf,
+]);
+})
+
+symbol9
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Object;
+var d=a.Symbol;
+var e=b.ImportNow("has_instance_symbol");
+var f=
+b.ImportNow("is_concat_spreadable_symbol");
+var g=b.ImportNow("iterator_symbol");
+var h;
+var i=b.ImportNow("to_primitive_symbol");
+var j=b.ImportNow("to_string_tag_symbol");
+var k=b.ImportNow("unscopables_symbol");
+b.Import(function(l){
+h=l.MakeTypeError;
+});
+function SymbolToPrimitive(m){
+if(!((typeof(this)==='symbol')||(%_ClassOf(this)==='Symbol'))){
+throw h(42,
+"Symbol.prototype [ @@toPrimitive ]",this);
+}
+return %_ValueOf(this);
+}
+function SymbolToString(){
+if(!((typeof(this)==='symbol')||(%_ClassOf(this)==='Symbol'))){
+throw h(42,
+"Symbol.prototype.toString",this);
+}
+return %SymbolDescriptiveString(%_ValueOf(this));
+}
+function SymbolValueOf(){
+if(!((typeof(this)==='symbol')||(%_ClassOf(this)==='Symbol'))){
+throw h(42,
+"Symbol.prototype.valueOf",this);
+}
+return %_ValueOf(this);
+}
+function SymbolFor(n){
+n=(%_ToString(n));
+var o=%SymbolRegistry();
+if((o.for[n]===(void 0))){
+var p=%CreateSymbol(n);
+o.for[n]=p;
+o.keyFor[p]=n;
+}
+return o.for[n];
+}
+function SymbolKeyFor(p){
+if(!(typeof(p)==='symbol'))throw h(148,p);
+return %SymbolRegistry().keyFor[p];
+}
+function ObjectGetOwnPropertySymbols(q){
+q=(%_ToObject(q));
+return %GetOwnPropertyKeys(q,8);
+}
+%FunctionSetPrototype(d,new c());
+b.InstallConstants(d,[
+"iterator",g,
+"toPrimitive",i,
+"unscopables",k,
+]);
+b.InstallFunctions(d,2,[
+"for",SymbolFor,
+"keyFor",SymbolKeyFor
+]);
+%AddNamedProperty(
+d.prototype,"constructor",d,2);
+%AddNamedProperty(
+d.prototype,j,"Symbol",2|1);
+b.InstallFunctions(d.prototype,2|1,[
+i,SymbolToPrimitive
+]);
+b.InstallFunctions(d.prototype,2,[
+"toString",SymbolToString,
+"valueOf",SymbolValueOf
+]);
+b.InstallFunctions(c,2,[
+"getOwnPropertySymbols",ObjectGetOwnPropertySymbols
+]);
+b.Export(function(r){
+r.SymbolToString=SymbolToString;
+})
+})
+
+array��

+(function(a,b,c){
+"use strict";
+%CheckIsBootstrapping();
+var d;
+var e;
+var f;
+var g;
+var h;
+var i=a.Array;
+var j=b.InternalArray;
+var k=b.InternalPackedArray;
+var l;
+var m;
+var n;
+var o;
+var p;
+var q=b.ImportNow("object_to_string");
+var r;
+var s;
+var t;
+var u;
+var v=b.ImportNow("iterator_symbol");
+var w=b.ImportNow("unscopables_symbol");
+b.Import(function(x){
+d=x.AddIndexedProperty;
+g=x.GetIterator;
+h=x.GetMethod;
+l=x.MakeTypeError;
+m=x.MaxSimple;
+n=x.MinSimple;
+o=x.ObjectDefineProperty;
+p=x.ObjectHasOwnProperty;
+r=x.ObserveBeginPerformSplice;
+s=x.ObserveEndPerformSplice;
+t=x.ObserveEnqueueSpliceRecord;
+u=x.SameValueZero;
+});
+b.ImportFromExperimental(function(x){
+e=x.FLAG_harmony_tolength;
+f=x.FLAG_harmony_species;
+});
+function ArraySpeciesCreate(y,z){
+var A;
+if(f){
+A=%ArraySpeciesConstructor(y);
+}else{
+A=i;
+}
+return new A(z);
+}
+function DefineIndexedProperty(y,B,C){
+if(f){
+var D=o(y,B,{
+value:C,writable:true,configurable:true,enumerable:true
+});
+if(!D)throw l(137,B);
+}else{
+d(y,B,C);
+}
+}
+var E=new j();
+function GetSortedArrayKeys(y,F){
+var G=new j();
+if((typeof(F)==='number')){
+var H=F;
+for(var B=0;B<H;++B){
+var I=y[B];
+if(!(I===(void 0))||B in y){
+G.push(B);
+}
+}
+}else{
+var z=F.length;
+for(var J=0;J<z;++J){
+var K=F[J];
+if(!(K===(void 0))){
+var I=y[K];
+if(!(I===(void 0))||K in y){
+G.push(K);
+}
+}
+}
+G.sort(function(L,M){return L-M;});
+}
+return G;
+}
+function SparseJoinWithSeparatorJS(y,N,O,P){
+var G=GetSortedArrayKeys(y,%GetArrayKeys(y,N));
+var Q=0;
+var R=new j(G.length*2);
+var S=-1;
+for(var B=0;B<G.length;B++){
+var K=G[B];
+if(K!=S){
+var I=y[K];
+if(!(typeof(I)==='string'))I=O(I);
+R[B*2]=K;
+R[B*2+1]=I;
+S=K;
+}
+}
+return %SparseJoinWithSeparator(R,N,P);
+}
+function SparseJoin(y,N,O){
+var G=GetSortedArrayKeys(y,%GetArrayKeys(y,N));
+var T=-1;
+var U=G.length;
+var R=new j(U);
+var V=0;
+for(var B=0;B<U;B++){
+var K=G[B];
+if(K!=T){
+var I=y[K];
+if(!(typeof(I)==='string'))I=O(I);
+R[V++]=I;
+T=K;
+}
+}
+return %StringBuilderConcat(R,V,'');
+}
+function UseSparseVariant(y,z,W,X){
+if(!W||z<1000||%IsObserved(y)||
+%HasComplexElements(y)){
+return false;
+}
+if(!%_IsSmi(z)){
+return true;
+}
+var Y=z>>2;
+var Z=%EstimateNumberOfElements(y);
+return(Z<Y)&&
+(X>Z*4);
+}
+function Join(y,z,P,O){
+if(z==0)return'';
+var W=(%_IsArray(y));
+if(W){
+if(!%PushIfAbsent(E,y))return'';
+}
+try{
+if(UseSparseVariant(y,z,W,z)){
+%NormalizeElements(y);
+if(P.length==0){
+return SparseJoin(y,z,O);
+}else{
+return SparseJoinWithSeparatorJS(y,z,O,P);
+}
+}
+if(z==1){
+var I=y[0];
+if((typeof(I)==='string'))return I;
+return O(I);
+}
+var R=new j(z);
+if(P.length==0){
+var V=0;
+for(var B=0;B<z;B++){
+var I=y[B];
+if(!(typeof(I)==='string'))I=O(I);
+R[V++]=I;
+}
+R.length=V;
+var D=%_FastOneByteArrayJoin(R,'');
+if(!(D===(void 0)))return D;
+return %StringBuilderConcat(R,V,'');
+}
+if(!(typeof(y[0])==='number')){
+for(var B=0;B<z;B++){
+var I=y[B];
+if(!(typeof(I)==='string'))I=O(I);
+R[B]=I;
+}
+}else{
+for(var B=0;B<z;B++){
+var I=y[B];
+if((typeof(I)==='number')){
+I=%_NumberToString(I);
+}else if(!(typeof(I)==='string')){
+I=O(I);
+}
+R[B]=I;
+}
+}
+var D=%_FastOneByteArrayJoin(R,P);
+if(!(D===(void 0)))return D;
+return %StringBuilderJoin(R,z,P);
+}finally{
+if(W)E.length=E.length-1;
+}
+}
+function ConvertToString(aa){
+if((aa==null)){
+return'';
+}else{
+return(%_ToString(aa));
+}
+}
+function ConvertToLocaleString(I){
+if((I==null)){
+return'';
+}else{
+return(%_ToString(I.toLocaleString()));
+}
+}
+function SparseSlice(y,ab,ac,N,ad){
+var F=%GetArrayKeys(y,ab+ac);
+if((typeof(F)==='number')){
+var H=F;
+for(var B=ab;B<H;++B){
+var ae=y[B];
+if(!(ae===(void 0))||B in y){
+DefineIndexedProperty(ad,B-ab,ae);
+}
+}
+}else{
+var z=F.length;
+for(var J=0;J<z;++J){
+var K=F[J];
+if(!(K===(void 0))){
+if(K>=ab){
+var ae=y[K];
+if(!(ae===(void 0))||K in y){
+DefineIndexedProperty(ad,K-ab,ae);
+}
+}
+}
+}
+}
+}
+function SparseMove(y,ab,ac,N,af){
+if(af===ac)return;
+var ag=new j(
+n(N-ac+af,0xffffffff));
+var ah;
+var F=%GetArrayKeys(y,N);
+if((typeof(F)==='number')){
+var H=F;
+for(var B=0;B<ab&&B<H;++B){
+var ae=y[B];
+if(!(ae===(void 0))||B in y){
+ag[B]=ae;
+}
+}
+for(var B=ab+ac;B<H;++B){
+var ae=y[B];
+if(!(ae===(void 0))||B in y){
+ag[B-ac+af]=ae;
+}
+}
+}else{
+var z=F.length;
+for(var J=0;J<z;++J){
+var K=F[J];
+if(!(K===(void 0))){
+if(K<ab){
+var ae=y[K];
+if(!(ae===(void 0))||K in y){
+ag[K]=ae;
+}
+}else if(K>=ab+ac){
+var ae=y[K];
+if(!(ae===(void 0))||K in y){
+var ai=K-ac+af;
+ag[ai]=ae;
+if(ai>0xfffffffe){
+ah=ah||new j();
+ah.push(ai);
+}
+}
+}
+}
+}
+}
+%MoveArrayContents(ag,y);
+if(!(ah===(void 0))){
+var z=ah.length;
+for(var B=0;B<z;++B){
+var K=ah[B];
+y[K]=ag[K];
+}
+}
+}
+function SimpleSlice(y,ab,ac,N,ad){
+var W=(%_IsArray(y));
+for(var B=0;B<ac;B++){
+var aj=ab+B;
+if(((W&&%_HasFastPackedElements(%IS_VAR(y)))?(aj<y.length):(aj in y))){
+var ae=y[aj];
+DefineIndexedProperty(ad,B,ae);
+}
+}
+}
+function SimpleMove(y,ab,ac,N,af){
+var W=(%_IsArray(y));
+if(af!==ac){
+if(af>ac){
+for(var B=N-ac;B>ab;B--){
+var ak=B+ac-1;
+var al=B+af-1;
+if(((W&&%_HasFastPackedElements(%IS_VAR(y)))?(ak<y.length):(ak in y))){
+y[al]=y[ak];
+}else{
+delete y[al];
+}
+}
+}else{
+for(var B=ab;B<N-ac;B++){
+var ak=B+ac;
+var al=B+af;
+if(((W&&%_HasFastPackedElements(%IS_VAR(y)))?(ak<y.length):(ak in y))){
+y[al]=y[ak];
+}else{
+delete y[al];
+}
+}
+for(var B=N;B>N-ac+af;B--){
+delete y[B-1];
+}
+}
+}
+}
+function ArrayToString(){
+var y;
+var am;
+if((%_IsArray(this))){
+am=this.join;
+if(am===ArrayJoin){
+return Join(this,this.length,',',ConvertToString);
+}
+y=this;
+}else{
+y=(%_ToObject(this));
+am=y.join;
+}
+if(!(typeof(am)==='function')){
+return %_Call(q,y);
+}
+return %_Call(am,y);
+}
+function InnerArrayToLocaleString(y,z){
+var N=(e?(%_ToLength(z)):((z)>>>0));
+if(N===0)return"";
+return Join(y,N,',',ConvertToLocaleString);
+}
+function ArrayToLocaleString(){
+var y=(%_ToObject(this));
+var an=y.length;
+return InnerArrayToLocaleString(y,an);
+}
+function InnerArrayJoin(P,y,z){
+if((P===(void 0))){
+P=',';
+}else{
+P=(%_ToString(P));
+}
+var D=%_FastOneByteArrayJoin(y,P);
+if(!(D===(void 0)))return D;
+if(z===1){
+var I=y[0];
+if((I==null))return'';
+return(%_ToString(I));
+}
+return Join(y,z,P,ConvertToString);
+}
+function ArrayJoin(P){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.join");
+var y=(%_ToObject(this));
+var z=(e?(%_ToLength(y.length)):((y.length)>>>0));
+return InnerArrayJoin(P,y,z);
+}
+function ObservedArrayPop(ao){
+ao--;
+var C=this[ao];
+try{
+r(this);
+delete this[ao];
+this.length=ao;
+}finally{
+s(this);
+t(this,ao,[C],0);
+}
+return C;
+}
+function ArrayPop(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.pop");
+var y=(%_ToObject(this));
+var ao=(e?(%_ToLength(y.length)):((y.length)>>>0));
+if(ao==0){
+y.length=ao;
+return;
+}
+if(%IsObserved(y))
+return ObservedArrayPop.call(y,ao);
+ao--;
+var C=y[ao];
+%DeleteProperty_Strict(y,ao);
+y.length=ao;
+return C;
+}
+function ObservedArrayPush(){
+var ao=(e?(%_ToLength(this.length)):((this.length)>>>0));
+var ap=%_ArgumentsLength();
+try{
+r(this);
+for(var B=0;B<ap;B++){
+this[B+ao]=%_Arguments(B);
+}
+var aq=ao+ap;
+this.length=aq;
+}finally{
+s(this);
+t(this,ao,[],ap);
+}
+return aq;
+}
+function ArrayPush(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.push");
+if(%IsObserved(this))
+return ObservedArrayPush.apply(this,arguments);
+var y=(%_ToObject(this));
+var ao=(e?(%_ToLength(y.length)):((y.length)>>>0));
+var ap=%_ArgumentsLength();
+if(ap>(1<<30)||(ao-(1<<30))+ap>9007199254740991-(1<<30)){
+throw l(228,ap,ao);
+}
+for(var B=0;B<ap;B++){
+y[B+ao]=%_Arguments(B);
+}
+var aq=ao+ap;
+y.length=aq;
+return aq;
+}
+function SparseReverse(y,N){
+var G=GetSortedArrayKeys(y,%GetArrayKeys(y,N));
+var ar=G.length-1;
+var as=0;
+while(as<=ar){
+var B=G[as];
+var at=G[ar];
+var au=N-at-1;
+var av,aw;
+if(au<=B){
+aw=at;
+while(G[--ar]==at){}
+av=au;
+}
+if(au>=B){
+av=B;
+while(G[++as]==B){}
+aw=N-B-1;
+}
+var ax=y[av];
+if(!(ax===(void 0))||av in y){
+var ay=y[aw];
+if(!(ay===(void 0))||aw in y){
+y[av]=ay;
+y[aw]=ax;
+}else{
+y[aw]=ax;
+delete y[av];
+}
+}else{
+var ay=y[aw];
+if(!(ay===(void 0))||aw in y){
+y[av]=ay;
+delete y[aw];
+}
+}
+}
+}
+function PackedArrayReverse(y,N){
+var at=N-1;
+for(var B=0;B<at;B++,at--){
+var ax=y[B];
+var ay=y[at];
+y[B]=ay;
+y[at]=ax;
+}
+return y;
+}
+function GenericArrayReverse(y,N){
+var at=N-1;
+for(var B=0;B<at;B++,at--){
+if(B in y){
+var ax=y[B];
+if(at in y){
+var ay=y[at];
+y[B]=ay;
+y[at]=ax;
+}else{
+y[at]=ax;
+delete y[B];
+}
+}else{
+if(at in y){
+var ay=y[at];
+y[B]=ay;
+delete y[at];
+}
+}
+}
+return y;
+}
+function ArrayReverse(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.reverse");
+var y=(%_ToObject(this));
+var N=(e?(%_ToLength(y.length)):((y.length)>>>0));
+var az=(%_IsArray(y));
+if(UseSparseVariant(y,N,az,N)){
+%NormalizeElements(y);
+SparseReverse(y,N);
+return y;
+}else if(az&&%_HasFastPackedElements(y)){
+return PackedArrayReverse(y,N);
+}else{
+return GenericArrayReverse(y,N);
+}
+}
+function ObservedArrayShift(N){
+var aA=this[0];
+try{
+r(this);
+SimpleMove(this,0,1,N,0);
+this.length=N-1;
+}finally{
+s(this);
+t(this,0,[aA],0);
+}
+return aA;
+}
+function ArrayShift(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.shift");
+var y=(%_ToObject(this));
+var N=(e?(%_ToLength(y.length)):((y.length)>>>0));
+if(N===0){
+y.length=0;
+return;
+}
+if(%object_is_sealed(y))throw l(13);
+if(%IsObserved(y))
+return ObservedArrayShift.call(y,N);
+var aA=y[0];
+if(UseSparseVariant(y,N,(%_IsArray(y)),N)){
+SparseMove(y,0,1,N,0);
+}else{
+SimpleMove(y,0,1,N,0);
+}
+y.length=N-1;
+return aA;
+}
+function ObservedArrayUnshift(){
+var N=(e?(%_ToLength(this.length)):((this.length)>>>0));
+var aB=%_ArgumentsLength();
+try{
+r(this);
+SimpleMove(this,0,0,N,aB);
+for(var B=0;B<aB;B++){
+this[B]=%_Arguments(B);
+}
+var aq=N+aB;
+this.length=aq;
+}finally{
+s(this);
+t(this,0,[],aB);
+}
+return aq;
+}
+function ArrayUnshift(aC){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.unshift");
+if(%IsObserved(this))
+return ObservedArrayUnshift.apply(this,arguments);
+var y=(%_ToObject(this));
+var N=(e?(%_ToLength(y.length)):((y.length)>>>0));
+var aB=%_ArgumentsLength();
+if(N>0&&UseSparseVariant(y,N,(%_IsArray(y)),N)&&
+!%object_is_sealed(y)){
+SparseMove(y,0,0,N,aB);
+}else{
+SimpleMove(y,0,0,N,aB);
+}
+for(var B=0;B<aB;B++){
+y[B]=%_Arguments(B);
+}
+var aq=N+aB;
+y.length=aq;
+return aq;
+}
+function ArraySlice(aD,aE){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.slice");
+var y=(%_ToObject(this));
+var N=(e?(%_ToLength(y.length)):((y.length)>>>0));
+var ab=(%_ToInteger(aD));
+var aF=N;
+if(!(aE===(void 0)))aF=(%_ToInteger(aE));
+if(ab<0){
+ab+=N;
+if(ab<0)ab=0;
+}else{
+if(ab>N)ab=N;
+}
+if(aF<0){
+aF+=N;
+if(aF<0)aF=0;
+}else{
+if(aF>N)aF=N;
+}
+var D=ArraySpeciesCreate(y,m(aF-ab,0));
+if(aF<ab)return D;
+if(UseSparseVariant(y,N,(%_IsArray(y)),aF-ab)){
+%NormalizeElements(y);
+%NormalizeElements(D);
+SparseSlice(y,ab,aF-ab,N,D);
+}else{
+SimpleSlice(y,ab,aF-ab,N,D);
+}
+D.length=aF-ab;
+return D;
+}
+function ComputeSpliceStartIndex(ab,N){
+if(ab<0){
+ab+=N;
+return ab<0?0:ab;
+}
+return ab>N?N:ab;
+}
+function ComputeSpliceDeleteCount(aG,aB,N,ab){
+var ac=0;
+if(aB==1)
+return N-ab;
+ac=(%_ToInteger(aG));
+if(ac<0)
+return 0;
+if(ac>N-ab)
+return N-ab;
+return ac;
+}
+function ObservedArraySplice(aD,aG){
+var aB=%_ArgumentsLength();
+var N=(e?(%_ToLength(this.length)):((this.length)>>>0));
+var ab=ComputeSpliceStartIndex((%_ToInteger(aD)),N);
+var ac=ComputeSpliceDeleteCount(aG,aB,N,
+ab);
+var ad=[];
+ad.length=ac;
+var aH=aB>2?aB-2:0;
+try{
+r(this);
+SimpleSlice(this,ab,ac,N,ad);
+SimpleMove(this,ab,ac,N,aH);
+var B=ab;
+var aI=2;
+var aJ=%_ArgumentsLength();
+while(aI<aJ){
+this[B++]=%_Arguments(aI++);
+}
+this.length=N-ac+aH;
+}finally{
+s(this);
+if(ad.length||aH){
+t(this,
+ab,
+ad.slice(),
+aH);
+}
+}
+return ad;
+}
+function ArraySplice(aD,aG){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.splice");
+if(%IsObserved(this))
+return ObservedArraySplice.apply(this,arguments);
+var aB=%_ArgumentsLength();
+var y=(%_ToObject(this));
+var N=(e?(%_ToLength(y.length)):((y.length)>>>0));
+var ab=ComputeSpliceStartIndex((%_ToInteger(aD)),N);
+var ac=ComputeSpliceDeleteCount(aG,aB,N,
+ab);
+var ad=ArraySpeciesCreate(y,ac);
+ad.length=ac;
+var aH=aB>2?aB-2:0;
+if(ac!=aH&&%object_is_sealed(y)){
+throw l(13);
+}else if(ac>0&&%object_is_frozen(y)){
+throw l(12);
+}
+var aK=ac;
+if(aH!=ac){
+aK+=N-ab-ac;
+}
+if(UseSparseVariant(y,N,(%_IsArray(y)),aK)){
+%NormalizeElements(y);
+%NormalizeElements(ad);
+SparseSlice(y,ab,ac,N,ad);
+SparseMove(y,ab,ac,N,aH);
+}else{
+SimpleSlice(y,ab,ac,N,ad);
+SimpleMove(y,ab,ac,N,aH);
+}
+var B=ab;
+var aI=2;
+var aJ=%_ArgumentsLength();
+while(aI<aJ){
+y[B++]=%_Arguments(aI++);
+}
+y.length=N-ac+aH;
+return ad;
+}
+function InnerArraySort(y,z,aL){
+if(!(typeof(aL)==='function')){
+aL=function(aa,aM){
+if(aa===aM)return 0;
+if(%_IsSmi(aa)&&%_IsSmi(aM)){
+return %SmiLexicographicCompare(aa,aM);
+}
+aa=(%_ToString(aa));
+aM=(%_ToString(aM));
+if(aa==aM)return 0;
+else return aa<aM?-1:1;
+};
+}
+var aN=function InsertionSort(L,x,aO){
+for(var B=x+1;B<aO;B++){
+var aP=L[B];
+for(var at=B-1;at>=x;at--){
+var aQ=L[at];
+var aR=aL(aQ,aP);
+if(aR>0){
+L[at+1]=aQ;
+}else{
+break;
+}
+}
+L[at+1]=aP;
+}
+};
+var aS=function(L,x,aO){
+var aT=new j();
+var aU=200+((aO-x)&15);
+var at=0;
+x+=1;
+aO-=1;
+for(var B=x;B<aO;B+=aU){
+aT[at]=[B,L[B]];
+at++;
+}
+aT.sort(function(L,M){
+return aL(L[1],M[1]);
+});
+var aV=aT[aT.length>>1][0];
+return aV;
+}
+var aW=function QuickSort(L,x,aO){
+var aV=0;
+while(true){
+if(aO-x<=10){
+aN(L,x,aO);
+return;
+}
+if(aO-x>1000){
+aV=aS(L,x,aO);
+}else{
+aV=x+((aO-x)>>1);
+}
+var aX=L[x];
+var aY=L[aO-1];
+var aZ=L[aV];
+var ba=aL(aX,aY);
+if(ba>0){
+var aQ=aX;
+aX=aY;
+aY=aQ;
+}
+var bb=aL(aX,aZ);
+if(bb>=0){
+var aQ=aX;
+aX=aZ;
+aZ=aY;
+aY=aQ;
+}else{
+var bc=aL(aY,aZ);
+if(bc>0){
+var aQ=aY;
+aY=aZ;
+aZ=aQ;
+}
+}
+L[x]=aX;
+L[aO-1]=aZ;
+var bd=aY;
+var be=x+1;
+var bf=aO-1;
+L[aV]=L[be];
+L[be]=bd;
+partition:for(var B=be+1;B<bf;B++){
+var aP=L[B];
+var aR=aL(aP,bd);
+if(aR<0){
+L[B]=L[be];
+L[be]=aP;
+be++;
+}else if(aR>0){
+do{
+bf--;
+if(bf==B)break partition;
+var bg=L[bf];
+aR=aL(bg,bd);
+}while(aR>0);
+L[B]=L[bf];
+L[bf]=aP;
+if(aR<0){
+aP=L[B];
+L[B]=L[be];
+L[be]=aP;
+be++;
+}
+}
+}
+if(aO-bf<be-x){
+aW(L,bf,aO);
+aO=be;
+}else{
+aW(L,x,be);
+x=bf;
+}
+}
+};
+var bh=function CopyFromPrototype(bi,z){
+var bj=0;
+for(var bk=%_GetPrototype(bi);bk;bk=%_GetPrototype(bk)){
+var F=%GetArrayKeys(bk,z);
+if((typeof(F)==='number')){
+var bl=F;
+for(var B=0;B<bl;B++){
+if(!(%_Call(p,bi,B))&&(%_Call(p,bk,B))){
+bi[B]=bk[B];
+if(B>=bj){bj=B+1;}
+}
+}
+}else{
+for(var B=0;B<F.length;B++){
+var aj=F[B];
+if(!(aj===(void 0))&&!(%_Call(p,bi,aj))
+&&(%_Call(p,bk,aj))){
+bi[aj]=bk[aj];
+if(aj>=bj){bj=aj+1;}
+}
+}
+}
+}
+return bj;
+};
+var bm=function(bi,x,aO){
+for(var bk=%_GetPrototype(bi);bk;bk=%_GetPrototype(bk)){
+var F=%GetArrayKeys(bk,aO);
+if((typeof(F)==='number')){
+var bl=F;
+for(var B=x;B<bl;B++){
+if((%_Call(p,bk,B))){
+bi[B]=(void 0);
+}
+}
+}else{
+for(var B=0;B<F.length;B++){
+var aj=F[B];
+if(!(aj===(void 0))&&x<=aj&&
+(%_Call(p,bk,aj))){
+bi[aj]=(void 0);
+}
+}
+}
+}
+};
+var bn=function SafeRemoveArrayHoles(bi){
+var bo=0;
+var bp=z-1;
+var bq=0;
+while(bo<bp){
+while(bo<bp&&
+!(bi[bo]===(void 0))){
+bo++;
+}
+if(!(%_Call(p,bi,bo))){
+bq++;
+}
+while(bo<bp&&
+(bi[bp]===(void 0))){
+if(!(%_Call(p,bi,bp))){
+bq++;
+}
+bp--;
+}
+if(bo<bp){
+bi[bo]=bi[bp];
+bi[bp]=(void 0);
+}
+}
+if(!(bi[bo]===(void 0)))bo++;
+var B;
+for(B=bo;B<z-bq;B++){
+bi[B]=(void 0);
+}
+for(B=z-bq;B<z;B++){
+if(B in %_GetPrototype(bi)){
+bi[B]=(void 0);
+}else{
+delete bi[B];
+}
+}
+return bo;
+};
+if(z<2)return y;
+var W=(%_IsArray(y));
+var br;
+if(!W){
+br=bh(y,z);
+}
+var bs=%RemoveArrayHoles(y,z);
+if(bs==-1){
+bs=bn(y);
+}
+aW(y,0,bs);
+if(!W&&(bs+1<br)){
+bm(y,bs,br);
+}
+return y;
+}
+function ArraySort(aL){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.sort");
+var y=(%_ToObject(this));
+var z=(e?(%_ToLength(y.length)):((y.length)>>>0));
+return InnerArraySort(y,z,aL);
+}
+function InnerArrayFilter(bt,bu,y,z,D){
+var bv=0;
+var W=(%_IsArray(y));
+for(var B=0;B<z;B++){
+if(((W&&%_HasFastPackedElements(%IS_VAR(y)))?(B<y.length):(B in y))){
+var aP=y[B];
+if(%_Call(bt,bu,aP,B,y)){
+DefineIndexedProperty(D,bv,aP);
+bv++;
+}
+}
+}
+return D;
+}
+function ArrayFilter(bt,bu){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.filter");
+var y=(%_ToObject(this));
+var z=(e?(%_ToLength(y.length)):((y.length)>>>0));
+if(!(typeof(bt)==='function'))throw l(15,bt);
+var D=ArraySpeciesCreate(y,0);
+return InnerArrayFilter(bt,bu,y,z,D);
+}
+function InnerArrayForEach(bt,bu,y,z){
+if(!(typeof(bt)==='function'))throw l(15,bt);
+var W=(%_IsArray(y));
+for(var B=0;B<z;B++){
+if(((W&&%_HasFastPackedElements(%IS_VAR(y)))?(B<y.length):(B in y))){
+var aP=y[B];
+%_Call(bt,bu,aP,B,y);
+}
+}
+}
+function ArrayForEach(bt,bu){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.forEach");
+var y=(%_ToObject(this));
+var z=(e?(%_ToLength(y.length)):((y.length)>>>0));
+InnerArrayForEach(bt,bu,y,z);
+}
+function InnerArraySome(bt,bu,y,z){
+if(!(typeof(bt)==='function'))throw l(15,bt);
+var W=(%_IsArray(y));
+for(var B=0;B<z;B++){
+if(((W&&%_HasFastPackedElements(%IS_VAR(y)))?(B<y.length):(B in y))){
+var aP=y[B];
+if(%_Call(bt,bu,aP,B,y))return true;
+}
+}
+return false;
+}
+function ArraySome(bt,bu){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.some");
+var y=(%_ToObject(this));
+var z=(e?(%_ToLength(y.length)):((y.length)>>>0));
+return InnerArraySome(bt,bu,y,z);
+}
+function InnerArrayEvery(bt,bu,y,z){
+if(!(typeof(bt)==='function'))throw l(15,bt);
+var W=(%_IsArray(y));
+for(var B=0;B<z;B++){
+if(((W&&%_HasFastPackedElements(%IS_VAR(y)))?(B<y.length):(B in y))){
+var aP=y[B];
+if(!%_Call(bt,bu,aP,B,y))return false;
+}
+}
+return true;
+}
+function ArrayEvery(bt,bu){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.every");
+var y=(%_ToObject(this));
+var z=(e?(%_ToLength(y.length)):((y.length)>>>0));
+return InnerArrayEvery(bt,bu,y,z);
+}
+function ArrayMap(bt,bu){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.map");
+var y=(%_ToObject(this));
+var z=(e?(%_ToLength(y.length)):((y.length)>>>0));
+if(!(typeof(bt)==='function'))throw l(15,bt);
+var D=ArraySpeciesCreate(y,z);
+var W=(%_IsArray(y));
+for(var B=0;B<z;B++){
+if(((W&&%_HasFastPackedElements(%IS_VAR(y)))?(B<y.length):(B in y))){
+var aP=y[B];
+DefineIndexedProperty(D,B,%_Call(bt,bu,aP,B,y));
+}
+}
+return D;
+}
+function InnerArrayIndexOf(y,aP,aj,z){
+if(z==0)return-1;
+if((aj===(void 0))){
+aj=0;
+}else{
+aj=(%_ToInteger(aj));
+if(aj<0){
+aj=z+aj;
+if(aj<0)aj=0;
+}
+}
+var bw=aj;
+var bj=z;
+if(UseSparseVariant(y,z,(%_IsArray(y)),bj-bw)){
+%NormalizeElements(y);
+var F=%GetArrayKeys(y,z);
+if((typeof(F)==='number')){
+bj=F;
+}else{
+if(F.length==0)return-1;
+var bx=GetSortedArrayKeys(y,F);
+var ao=bx.length;
+var B=0;
+while(B<ao&&bx[B]<aj)B++;
+while(B<ao){
+var K=bx[B];
+if(!(K===(void 0))&&y[K]===aP)return K;
+B++;
+}
+return-1;
+}
+}
+if(!(aP===(void 0))){
+for(var B=bw;B<bj;B++){
+if(y[B]===aP)return B;
+}
+return-1;
+}
+for(var B=bw;B<bj;B++){
+if((y[B]===(void 0))&&B in y){
+return B;
+}
+}
+return-1;
+}
+function ArrayIndexOf(aP,aj){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.indexOf");
+var z=(e?(%_ToLength(this.length)):((this.length)>>>0));
+return InnerArrayIndexOf(this,aP,aj,z);
+}
+function InnerArrayLastIndexOf(y,aP,aj,z,by){
+if(z==0)return-1;
+if(by<2){
+aj=z-1;
+}else{
+aj=(%_ToInteger(aj));
+if(aj<0)aj+=z;
+if(aj<0)return-1;
+else if(aj>=z)aj=z-1;
+}
+var bw=0;
+var bj=aj;
+if(UseSparseVariant(y,z,(%_IsArray(y)),aj)){
+%NormalizeElements(y);
+var F=%GetArrayKeys(y,aj+1);
+if((typeof(F)==='number')){
+bj=F;
+}else{
+if(F.length==0)return-1;
+var bx=GetSortedArrayKeys(y,F);
+var B=bx.length-1;
+while(B>=0){
+var K=bx[B];
+if(!(K===(void 0))&&y[K]===aP)return K;
+B--;
+}
+return-1;
+}
+}
+if(!(aP===(void 0))){
+for(var B=bj;B>=bw;B--){
+if(y[B]===aP)return B;
+}
+return-1;
+}
+for(var B=bj;B>=bw;B--){
+if((y[B]===(void 0))&&B in y){
+return B;
+}
+}
+return-1;
+}
+function ArrayLastIndexOf(aP,aj){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.lastIndexOf");
+var z=(e?(%_ToLength(this.length)):((this.length)>>>0));
+return InnerArrayLastIndexOf(this,aP,aj,z,
+%_ArgumentsLength());
+}
+function InnerArrayReduce(bz,ae,y,z,by){
+if(!(typeof(bz)==='function')){
+throw l(15,bz);
+}
+var W=(%_IsArray(y));
+var B=0;
+find_initial:if(by<2){
+for(;B<z;B++){
+if(((W&&%_HasFastPackedElements(%IS_VAR(y)))?(B<y.length):(B in y))){
+ae=y[B++];
+break find_initial;
+}
+}
+throw l(128);
+}
+for(;B<z;B++){
+if(((W&&%_HasFastPackedElements(%IS_VAR(y)))?(B<y.length):(B in y))){
+var aP=y[B];
+ae=bz(ae,aP,B,y);
+}
+}
+return ae;
+}
+function ArrayReduce(bz,ae){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.reduce");
+var y=(%_ToObject(this));
+var z=(e?(%_ToLength(y.length)):((y.length)>>>0));
+return InnerArrayReduce(bz,ae,y,z,
+%_ArgumentsLength());
+}
+function InnerArrayReduceRight(bz,ae,y,z,
+by){
+if(!(typeof(bz)==='function')){
+throw l(15,bz);
+}
+var W=(%_IsArray(y));
+var B=z-1;
+find_initial:if(by<2){
+for(;B>=0;B--){
+if(((W&&%_HasFastPackedElements(%IS_VAR(y)))?(B<y.length):(B in y))){
+ae=y[B--];
+break find_initial;
+}
+}
+throw l(128);
+}
+for(;B>=0;B--){
+if(((W&&%_HasFastPackedElements(%IS_VAR(y)))?(B<y.length):(B in y))){
+var aP=y[B];
+ae=bz(ae,aP,B,y);
+}
+}
+return ae;
+}
+function ArrayReduceRight(bz,ae){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.reduceRight");
+var y=(%_ToObject(this));
+var z=(e?(%_ToLength(y.length)):((y.length)>>>0));
+return InnerArrayReduceRight(bz,ae,y,z,
+%_ArgumentsLength());
+}
+function InnerArrayCopyWithin(bA,aD,aE,y,z){
+bA=(%_ToInteger(bA));
+var aO;
+if(bA<0){
+aO=m(z+bA,0);
+}else{
+aO=n(bA,z);
+}
+aD=(%_ToInteger(aD));
+var x;
+if(aD<0){
+x=m(z+aD,0);
+}else{
+x=n(aD,z);
+}
+aE=(aE===(void 0))?z:(%_ToInteger(aE));
+var bB;
+if(aE<0){
+bB=m(z+aE,0);
+}else{
+bB=n(aE,z);
+}
+var bC=n(bB-x,z-aO);
+var bD=1;
+if(x<aO&&aO<(x+bC)){
+bD=-1;
+x=x+bC-1;
+aO=aO+bC-1;
+}
+while(bC>0){
+if(x in y){
+y[aO]=y[x];
+}else{
+delete y[aO];
+}
+x=x+bD;
+aO=aO+bD;
+bC--;
+}
+return y;
+}
+function ArrayCopyWithin(bA,aD,aE){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.copyWithin");
+var y=(%_ToObject(this));
+var z=(%_ToLength(y.length));
+return InnerArrayCopyWithin(bA,aD,aE,y,z);
+}
+function InnerArrayFind(bE,bF,y,z){
+if(!(typeof(bE)==='function')){
+throw l(15,bE);
+}
+for(var B=0;B<z;B++){
+var aP=y[B];
+if(%_Call(bE,bF,aP,B,y)){
+return aP;
+}
+}
+return;
+}
+function ArrayFind(bE,bF){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.find");
+var y=(%_ToObject(this));
+var z=(%_ToInteger(y.length));
+return InnerArrayFind(bE,bF,y,z);
+}
+function InnerArrayFindIndex(bE,bF,y,z){
+if(!(typeof(bE)==='function')){
+throw l(15,bE);
+}
+for(var B=0;B<z;B++){
+var aP=y[B];
+if(%_Call(bE,bF,aP,B,y)){
+return B;
+}
+}
+return-1;
+}
+function ArrayFindIndex(bE,bF){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.findIndex");
+var y=(%_ToObject(this));
+var z=(%_ToInteger(y.length));
+return InnerArrayFindIndex(bE,bF,y,z);
+}
+function InnerArrayFill(C,aD,aE,y,z){
+var B=(aD===(void 0))?0:(%_ToInteger(aD));
+var aE=(aE===(void 0))?z:(%_ToInteger(aE));
+if(B<0){
+B+=z;
+if(B<0)B=0;
+}else{
+if(B>z)B=z;
+}
+if(aE<0){
+aE+=z;
+if(aE<0)aE=0;
+}else{
+if(aE>z)aE=z;
+}
+if((aE-B)>0&&%object_is_frozen(y)){
+throw l(12);
+}
+for(;B<aE;B++)
+y[B]=C;
+return y;
+}
+function ArrayFill(C,aD,aE){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.fill");
+var y=(%_ToObject(this));
+var z=(e?(%_ToLength(y.length)):((y.length)>>>0));
+return InnerArrayFill(C,aD,aE,y,z);
+}
+function InnerArrayIncludes(bG,bH,y,z){
+if(z===0){
+return false;
+}
+var ao=(%_ToInteger(bH));
+var J;
+if(ao>=0){
+J=ao;
+}else{
+J=z+ao;
+if(J<0){
+J=0;
+}
+}
+while(J<z){
+var bI=y[J];
+if(u(bG,bI)){
+return true;
+}
+++J;
+}
+return false;
+}
+function ArrayIncludes(bG,bH){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.includes");
+var y=(%_ToObject(this));
+var z=(%_ToLength(y.length));
+return InnerArrayIncludes(bG,bH,y,z);
+}
+function AddArrayElement(A,y,B,C){
+if(A===i){
+d(y,B,C);
+}else{
+o(y,B,{
+value:C,writable:true,configurable:true,enumerable:true
+});
+}
+}
+function ArrayFrom(bJ,bK,bu){
+var bL=(%_ToObject(bJ));
+var bM=!(bK===(void 0));
+if(bM){
+if(!(typeof(bK)==='function')){
+throw l(15,bK);
+}
+}
+var bN=h(bL,v);
+var J;
+var D;
+var bO;
+var bP;
+if(!(bN===(void 0))){
+D=%IsConstructor(this)?new this():[];
+var bQ=g(bL,bN);
+J=0;
+while(true){
+var bR=bQ.next();
+if(!(%_IsJSReceiver(bR))){
+throw l(48,bR);
+}
+if(bR.done){
+D.length=J;
+return D;
+}
+bP=bR.value;
+if(bM){
+bO=%_Call(bK,bu,bP,J);
+}else{
+bO=bP;
+}
+AddArrayElement(this,D,J,bO);
+J++;
+}
+}else{
+var N=(%_ToLength(bL.length));
+D=%IsConstructor(this)?new this(N):new i(N);
+for(J=0;J<N;++J){
+bP=bL[J];
+if(bM){
+bO=%_Call(bK,bu,bP,J);
+}else{
+bO=bP;
+}
+AddArrayElement(this,D,J,bO);
+}
+D.length=J;
+return D;
+}
+}
+function ArrayOf(){
+var z=%_ArgumentsLength();
+var A=this;
+var y=%IsConstructor(A)?new A(z):[];
+for(var B=0;B<z;B++){
+AddArrayElement(A,y,B,%_Arguments(B));
+}
+y.length=z;
+return y;
+}
+%AddNamedProperty(i.prototype,"constructor",i,
+2);
+var bS={
+__proto__:null,
+copyWithin:true,
+entries:true,
+fill:true,
+find:true,
+findIndex:true,
+keys:true,
+};
+%AddNamedProperty(i.prototype,w,bS,
+2|1);
+%FunctionSetLength(ArrayFrom,1);
+b.InstallFunctions(i,2,[
+"from",ArrayFrom,
+"of",ArrayOf
+]);
+var bT=%SpecialArrayFunctions();
+var bU=function(bV,bW,N){
+var bt=bW;
+if(bT.hasOwnProperty(bV)){
+bt=bT[bV];
+}
+if(!(N===(void 0))){
+%FunctionSetLength(bt,N);
+}
+return bt;
+};
+b.InstallFunctions(i.prototype,2,[
+"toString",bU("toString",ArrayToString),
+"toLocaleString",bU("toLocaleString",ArrayToLocaleString),
+"join",bU("join",ArrayJoin),
+"pop",bU("pop",ArrayPop),
+"push",bU("push",ArrayPush,1),
+"reverse",bU("reverse",ArrayReverse),
+"shift",bU("shift",ArrayShift),
+"unshift",bU("unshift",ArrayUnshift,1),
+"slice",bU("slice",ArraySlice,2),
+"splice",bU("splice",ArraySplice,2),
+"sort",bU("sort",ArraySort),
+"filter",bU("filter",ArrayFilter,1),
+"forEach",bU("forEach",ArrayForEach,1),
+"some",bU("some",ArraySome,1),
+"every",bU("every",ArrayEvery,1),
+"map",bU("map",ArrayMap,1),
+"indexOf",bU("indexOf",ArrayIndexOf,1),
+"lastIndexOf",bU("lastIndexOf",ArrayLastIndexOf,1),
+"reduce",bU("reduce",ArrayReduce,1),
+"reduceRight",bU("reduceRight",ArrayReduceRight,1),
+"copyWithin",bU("copyWithin",ArrayCopyWithin,2),
+"find",bU("find",ArrayFind,1),
+"findIndex",bU("findIndex",ArrayFindIndex,1),
+"fill",bU("fill",ArrayFill,1),
+"includes",bU("includes",ArrayIncludes,1),
+]);
+%FinishArrayPrototypeSetup(i.prototype);
+b.SetUpLockedPrototype(j,i(),[
+"indexOf",bU("indexOf",ArrayIndexOf),
+"join",bU("join",ArrayJoin),
+"pop",bU("pop",ArrayPop),
+"push",bU("push",ArrayPush),
+"shift",bU("shift",ArrayShift),
+"sort",bU("sort",ArraySort),
+"splice",bU("splice",ArraySplice)
+]);
+b.SetUpLockedPrototype(k,i(),[
+"join",bU("join",ArrayJoin),
+"pop",bU("pop",ArrayPop),
+"push",bU("push",ArrayPush),
+"shift",bU("shift",ArrayShift)
+]);
+b.SetUpLockedPrototype(c.InternalPackedArray,i(),[
+"push",bU("push",ArrayPush),
+"pop",bU("pop",ArrayPop),
+"shift",bU("shift",ArrayShift),
+"unshift",bU("unshift",ArrayUnshift),
+"splice",bU("splice",ArraySplice),
+"slice",bU("slice",ArraySlice)
+]);
+b.Export(function(aO){
+aO.ArrayFrom=ArrayFrom;
+aO.ArrayIndexOf=ArrayIndexOf;
+aO.ArrayJoin=ArrayJoin;
+aO.ArrayPush=ArrayPush;
+aO.ArrayToString=ArrayToString;
+aO.InnerArrayCopyWithin=InnerArrayCopyWithin;
+aO.InnerArrayEvery=InnerArrayEvery;
+aO.InnerArrayFill=InnerArrayFill;
+aO.InnerArrayFilter=InnerArrayFilter;
+aO.InnerArrayFind=InnerArrayFind;
+aO.InnerArrayFindIndex=InnerArrayFindIndex;
+aO.InnerArrayForEach=InnerArrayForEach;
+aO.InnerArrayIncludes=InnerArrayIncludes;
+aO.InnerArrayIndexOf=InnerArrayIndexOf;
+aO.InnerArrayJoin=InnerArrayJoin;
+aO.InnerArrayLastIndexOf=InnerArrayLastIndexOf;
+aO.InnerArrayReduce=InnerArrayReduce;
+aO.InnerArrayReduceRight=InnerArrayReduceRight;
+aO.InnerArraySome=InnerArraySome;
+aO.InnerArraySort=InnerArraySort;
+aO.InnerArrayToLocaleString=InnerArrayToLocaleString;
+aO.PackedArrayReverse=PackedArrayReverse;
+});
+%InstallToContext([
+"array_pop",ArrayPop,
+"array_push",ArrayPush,
+"array_shift",ArrayShift,
+"array_splice",ArraySplice,
+"array_slice",ArraySlice,
+"array_unshift",ArrayUnshift,
+]);
+});
+
+string:

+(function(a,b){
+%CheckIsBootstrapping();
+var c;
+var d;
+var e=a.RegExp;
+var f=a.String;
+var g=b.InternalArray;
+var h=b.InternalPackedArray;
+var i;
+var j;
+var k;
+var l;
+var m=b.ImportNow("match_symbol");
+var n;
+var o;
+var p;
+var q=b.ImportNow("search_symbol");
+var r=b.ImportNow("split_symbol");
+b.Import(function(s){
+c=s.ArrayIndexOf;
+d=s.ArrayJoin;
+i=s.MakeRangeError;
+j=s.MakeTypeError;
+k=s.MathMax;
+l=s.MathMin;
+n=s.RegExpExec;
+o=s.RegExpExecNoTests;
+p=s.RegExpLastMatchInfo;
+});
+function StringToString(){
+if(!(typeof(this)==='string')&&!(%_ClassOf(this)==='String')){
+throw j(65,'String.prototype.toString');
+}
+return %_ValueOf(this);
+}
+function StringValueOf(){
+if(!(typeof(this)==='string')&&!(%_ClassOf(this)==='String')){
+throw j(65,'String.prototype.valueOf');
+}
+return %_ValueOf(this);
+}
+function StringCharAtJS(t){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.charAt");
+var u=%_StringCharAt(this,t);
+if(%_IsSmi(u)){
+u=%_StringCharAt((%_ToString(this)),(%_ToInteger(t)));
+}
+return u;
+}
+function StringCharCodeAtJS(t){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.charCodeAt");
+var u=%_StringCharCodeAt(this,t);
+if(!%_IsSmi(u)){
+u=%_StringCharCodeAt((%_ToString(this)),(%_ToInteger(t)));
+}
+return u;
+}
+function StringConcat(v){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.concat");
+var w=%_ArgumentsLength();
+var x=(%_ToString(this));
+if(w===1){
+return x+(%_ToString(v));
+}
+var y=new g(w+1);
+y[0]=x;
+for(var z=0;z<w;z++){
+var A=%_Arguments(z);
+y[z+1]=(%_ToString(A));
+}
+return %StringBuilderConcat(y,w+1,"");
+}
+function StringIndexOfJS(B){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.indexOf");
+var C=(%_ToString(this));
+B=(%_ToString(B));
+var D=0;
+if(%_ArgumentsLength()>1){
+D=%_Arguments(1);
+D=(%_ToInteger(D));
+if(D<0)D=0;
+if(D>C.length)D=C.length;
+}
+return %StringIndexOf(C,B,D);
+}
+function StringLastIndexOfJS(E){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.lastIndexOf");
+var F=(%_ToString(this));
+var G=F.length;
+var E=(%_ToString(E));
+var H=E.length;
+var D=G-H;
+if(%_ArgumentsLength()>1){
+var I=(%_ToNumber(%_Arguments(1)));
+if(!(!%_IsSmi(%IS_VAR(I))&&!(I==I))){
+I=(%_ToInteger(I));
+if(I<0){
+I=0;
+}
+if(I+H<G){
+D=I;
+}
+}
+}
+if(D<0){
+return-1;
+}
+return %StringLastIndexOf(F,E,D);
+}
+function StringLocaleCompareJS(v){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.localeCompare");
+return %StringLocaleCompare((%_ToString(this)),(%_ToString(v)));
+}
+function StringMatchJS(B){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.match");
+if(!(B==null)){
+var J=B[m];
+if(!(J===(void 0))){
+return %_Call(J,B,this);
+}
+}
+var C=(%_ToString(this));
+var K=new e(B);
+return o(K,C,0);
+}
+function StringNormalizeJS(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.normalize");
+var L=(%_ToString(this));
+var M=%_Arguments(0);
+var N=(M===(void 0))?'NFC':(%_ToString(M));
+var O=['NFC','NFD','NFKC','NFKD'];
+var P=%_Call(c,O,N);
+if(P===-1){
+throw i(184,
+%_Call(d,O,', '));
+}
+return L;
+}
+var Q=[2,"","",-1,-1];
+function StringReplace(R,S){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.replace");
+var C=(%_ToString(this));
+if((%_IsRegExp(R))){
+if(!(typeof(S)==='function')){
+S=(%_ToString(S));
+if(!(%_RegExpFlags(R)&1)){
+var T=n(R,C,0);
+if(T==null){
+R.lastIndex=0
+return C;
+}
+if(S.length==0){
+return %_SubString(C,0,T[3])+
+%_SubString(C,T[4],C.length)
+}
+return ExpandReplacement(S,C,p,
+%_SubString(C,0,T[3]))+
+%_SubString(C,T[4],C.length);
+}
+R.lastIndex=0;
+return %StringReplaceGlobalRegExpWithString(
+C,R,S,p);
+}
+if((%_RegExpFlags(R)&1)){
+return StringReplaceGlobalRegExpWithFunction(C,R,S);
+}
+return StringReplaceNonGlobalRegExpWithFunction(C,R,S);
+}
+R=(%_ToString(R));
+if(R.length==1&&
+C.length>0xFF&&
+(typeof(S)==='string')&&
+%StringIndexOf(S,'$',0)<0){
+return %StringReplaceOneCharWithString(C,R,S);
+}
+var U=%StringIndexOf(C,R,0);
+if(U<0)return C;
+var V=U+R.length;
+var u=%_SubString(C,0,U);
+if((typeof(S)==='function')){
+u+=S(R,U,C);
+}else{
+Q[3]=U;
+Q[4]=V;
+u=ExpandReplacement((%_ToString(S)),
+C,
+Q,
+u);
+}
+return u+%_SubString(C,V,C.length);
+}
+function ExpandReplacement(W,C,X,u){
+var Y=W.length;
+var Z=%StringIndexOf(W,'$',0);
+if(Z<0){
+if(Y>0)u+=W;
+return u;
+}
+if(Z>0)u+=%_SubString(W,0,Z);
+while(true){
+var aa='$';
+var I=Z+1;
+if(I<Y){
+var ab=%_StringCharCodeAt(W,I);
+if(ab==36){
+++I;
+u+='$';
+}else if(ab==38){
+++I;
+u+=
+%_SubString(C,X[3],X[4]);
+}else if(ab==96){
+++I;
+u+=%_SubString(C,0,X[3]);
+}else if(ab==39){
+++I;
+u+=%_SubString(C,X[4],C.length);
+}else if(ab>=48&&ab<=57){
+var ac=(ab-48)<<1;
+var ad=1;
+var ae=((X)[0]);
+if(I+1<W.length){
+var Z=%_StringCharCodeAt(W,I+1);
+if(Z>=48&&Z<=57){
+var af=ac*10+((Z-48)<<1);
+if(af<ae){
+ac=af;
+ad=2;
+}
+}
+}
+if(ac!=0&&ac<ae){
+var U=X[(3+(ac))];
+if(U>=0){
+u+=
+%_SubString(C,U,X[(3+(ac+1))]);
+}
+I+=ad;
+}else{
+u+='$';
+}
+}else{
+u+='$';
+}
+}else{
+u+='$';
+}
+Z=%StringIndexOf(W,'$',I);
+if(Z<0){
+if(I<Y){
+u+=%_SubString(W,I,Y);
+}
+return u;
+}
+if(Z>I){
+u+=%_SubString(W,I,Z);
+}
+}
+return u;
+}
+function CaptureString(W,ag,D){
+var ah=D<<1;
+var U=ag[(3+(ah))];
+if(U<0)return;
+var V=ag[(3+(ah+1))];
+return %_SubString(W,U,V);
+}
+var ai=new g(4);
+function StringReplaceGlobalRegExpWithFunction(C,K,S){
+var aj=ai;
+if(aj){
+ai=null;
+}else{
+aj=new g(16);
+}
+var ak=%RegExpExecMultiple(K,
+C,
+p,
+aj);
+K.lastIndex=0;
+if((ak===null)){
+ai=aj;
+return C;
+}
+var w=ak.length;
+if(((p)[0])==2){
+var al=0;
+for(var z=0;z<w;z++){
+var am=ak[z];
+if(%_IsSmi(am)){
+if(am>0){
+al=(am>>11)+(am&0x7ff);
+}else{
+al=ak[++z]-am;
+}
+}else{
+var an=S(am,al,C);
+ak[z]=(%_ToString(an));
+al+=am.length;
+}
+}
+}else{
+for(var z=0;z<w;z++){
+var am=ak[z];
+if(!%_IsSmi(am)){
+var an=%Apply(S,(void 0),am,0,am.length);
+ak[z]=(%_ToString(an));
+}
+}
+}
+var u=%StringBuilderConcat(ak,w,C);
+aj.length=0;
+ai=aj;
+return u;
+}
+function StringReplaceNonGlobalRegExpWithFunction(C,K,S){
+var X=n(K,C,0);
+if((X===null)){
+K.lastIndex=0;
+return C;
+}
+var D=X[3];
+var u=%_SubString(C,0,D);
+var ao=X[4];
+var ap=((X)[0])>>1;
+var aq;
+if(ap==1){
+var L=%_SubString(C,D,ao);
+aq=S(L,D,C);
+}else{
+var ar=new g(ap+2);
+for(var as=0;as<ap;as++){
+ar[as]=CaptureString(C,X,as);
+}
+ar[as]=D;
+ar[as+1]=C;
+aq=%Apply(S,(void 0),ar,0,as+2);
+}
+u+=aq;
+return u+%_SubString(C,ao,C.length);
+}
+function StringSearch(B){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.search");
+if(!(B==null)){
+var at=B[q];
+if(!(at===(void 0))){
+return %_Call(at,B,this);
+}
+}
+var C=(%_ToString(this));
+var K=new e(B);
+return %_Call(K[q],K,C);
+}
+function StringSlice(U,V){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.slice");
+var L=(%_ToString(this));
+var au=L.length;
+var av=(%_ToInteger(U));
+var aw=au;
+if(!(V===(void 0))){
+aw=(%_ToInteger(V));
+}
+if(av<0){
+av+=au;
+if(av<0){
+av=0;
+}
+}else{
+if(av>au){
+return'';
+}
+}
+if(aw<0){
+aw+=au;
+if(aw<0){
+return'';
+}
+}else{
+if(aw>au){
+aw=au;
+}
+}
+if(aw<=av){
+return'';
+}
+return %_SubString(L,av,aw);
+}
+function StringSplitJS(ax,ay){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.split");
+if(!(ax==null)){
+var az=ax[r];
+if(!(az===(void 0))){
+return %_Call(az,ax,this,ay);
+}
+}
+var C=(%_ToString(this));
+ay=((ay===(void 0)))?4294967295:((ay)>>>0);
+var Y=C.length;
+var aA=(%_ToString(ax));
+if(ay===0)return[];
+if((ax===(void 0)))return[C];
+var aB=aA.length;
+if(aB===0)return %StringToArray(C,ay);
+return %StringSplit(C,aA,ay);
+}
+function StringSubstring(U,V){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.subString");
+var L=(%_ToString(this));
+var au=L.length;
+var av=(%_ToInteger(U));
+if(av<0){
+av=0;
+}else if(av>au){
+av=au;
+}
+var aw=au;
+if(!(V===(void 0))){
+aw=(%_ToInteger(V));
+if(aw>au){
+aw=au;
+}else{
+if(aw<0)aw=0;
+if(av>aw){
+var aC=aw;
+aw=av;
+av=aC;
+}
+}
+}
+return %_SubString(L,av,aw);
+}
+function StringSubstr(U,aD){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.substr");
+var L=(%_ToString(this));
+var w;
+if((aD===(void 0))){
+w=L.length;
+}else{
+w=(%_ToInteger(aD));
+if(w<=0)return'';
+}
+if((U===(void 0))){
+U=0;
+}else{
+U=(%_ToInteger(U));
+if(U>=L.length)return'';
+if(U<0){
+U+=L.length;
+if(U<0)U=0;
+}
+}
+var V=U+w;
+if(V>L.length)V=L.length;
+return %_SubString(L,U,V);
+}
+function StringToLowerCaseJS(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.toLowerCase");
+return %StringToLowerCase((%_ToString(this)));
+}
+function StringToLocaleLowerCase(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.toLocaleLowerCase");
+return %StringToLowerCase((%_ToString(this)));
+}
+function StringToUpperCaseJS(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.toUpperCase");
+return %StringToUpperCase((%_ToString(this)));
+}
+function StringToLocaleUpperCase(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.toLocaleUpperCase");
+return %StringToUpperCase((%_ToString(this)));
+}
+function StringTrimJS(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.trim");
+return %StringTrim((%_ToString(this)),true,true);
+}
+function StringTrimLeft(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.trimLeft");
+return %StringTrim((%_ToString(this)),true,false);
+}
+function StringTrimRight(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.trimRight");
+return %StringTrim((%_ToString(this)),false,true);
+}
+function StringFromCharCode(aE){
+var aD=%_ArgumentsLength();
+if(aD==1)return %_StringCharFromCode(aE&0xffff);
+var aF=%NewString(aD,true);
+var z;
+for(z=0;z<aD;z++){
+aE=%_Arguments(z)&0xffff;
+if(aE>0xff)break;
+%_OneByteSeqStringSetChar(z,aE,aF);
+}
+if(z==aD)return aF;
+aF=%TruncateString(aF,z);
+var aG=%NewString(aD-z,false);
+%_TwoByteSeqStringSetChar(0,aE,aG);
+z++;
+for(var as=1;z<aD;z++,as++){
+aE=%_Arguments(z)&0xffff;
+%_TwoByteSeqStringSetChar(as,aE,aG);
+}
+return aF+aG;
+}
+function HtmlEscape(aH){
+return %_Call(StringReplace,(%_ToString(aH)),/"/g,"&quot;");
+}
+function StringAnchor(aI){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.anchor");
+return"<a name=\""+HtmlEscape(aI)+"\">"+(%_ToString(this))+
+"</a>";
+}
+function StringBig(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.big");
+return"<big>"+(%_ToString(this))+"</big>";
+}
+function StringBlink(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.blink");
+return"<blink>"+(%_ToString(this))+"</blink>";
+}
+function StringBold(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.bold");
+return"<b>"+(%_ToString(this))+"</b>";
+}
+function StringFixed(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.fixed");
+return"<tt>"+(%_ToString(this))+"</tt>";
+}
+function StringFontcolor(aJ){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.fontcolor");
+return"<font color=\""+HtmlEscape(aJ)+"\">"+(%_ToString(this))+
+"</font>";
+}
+function StringFontsize(aK){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.fontsize");
+return"<font size=\""+HtmlEscape(aK)+"\">"+(%_ToString(this))+
+"</font>";
+}
+function StringItalics(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.italics");
+return"<i>"+(%_ToString(this))+"</i>";
+}
+function StringLink(L){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.link");
+return"<a href=\""+HtmlEscape(L)+"\">"+(%_ToString(this))+"</a>";
+}
+function StringSmall(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.small");
+return"<small>"+(%_ToString(this))+"</small>";
+}
+function StringStrike(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.strike");
+return"<strike>"+(%_ToString(this))+"</strike>";
+}
+function StringSub(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.sub");
+return"<sub>"+(%_ToString(this))+"</sub>";
+}
+function StringSup(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.sup");
+return"<sup>"+(%_ToString(this))+"</sup>";
+}
+function StringRepeat(aL){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.repeat");
+var L=(%_ToString(this));
+var aD=(%_ToInteger(aL));
+if(aD<0||aD===(1/0))throw i(168);
+if(L.length===0)return"";
+if(aD>%_MaxSmi())throw i(168);
+var aM="";
+while(true){
+if(aD&1)aM+=L;
+aD>>=1;
+if(aD===0)return aM;
+L+=L;
+}
+}
+function StringStartsWith(aN){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.startsWith");
+var L=(%_ToString(this));
+if((%_IsRegExp(aN))){
+throw j(38,"String.prototype.startsWith");
+}
+var aO=(%_ToString(aN));
+var t=0;
+if(%_ArgumentsLength()>1){
+var aP=%_Arguments(1);
+if(!(aP===(void 0))){
+t=(%_ToInteger(aP));
+}
+}
+var au=L.length;
+var U=l(k(t,0),au);
+var aQ=aO.length;
+if(aQ+U>au){
+return false;
+}
+return %_SubString(L,U,U+aQ)===aO;
+}
+function StringEndsWith(aN){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.endsWith");
+var L=(%_ToString(this));
+if((%_IsRegExp(aN))){
+throw j(38,"String.prototype.endsWith");
+}
+var aO=(%_ToString(aN));
+var au=L.length;
+var t=au;
+if(%_ArgumentsLength()>1){
+var aP=%_Arguments(1);
+if(!(aP===(void 0))){
+t=(%_ToInteger(aP));
+}
+}
+var V=l(k(t,0),au);
+var aQ=aO.length;
+var U=V-aQ;
+if(U<0){
+return false;
+}
+return %_SubString(L,U,U+aQ)===aO;
+}
+function StringIncludes(aN){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.includes");
+var W=(%_ToString(this));
+if((%_IsRegExp(aN))){
+throw j(38,"String.prototype.includes");
+}
+aN=(%_ToString(aN));
+var t=0;
+if(%_ArgumentsLength()>1){
+t=%_Arguments(1);
+t=(%_ToInteger(t));
+}
+var aR=W.length;
+if(t<0)t=0;
+if(t>aR)t=aR;
+var aS=aN.length;
+if(aS+t>aR){
+return false;
+}
+return %StringIndexOf(W,aN,t)!==-1;
+}
+function StringCodePointAt(t){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.codePointAt");
+var W=(%_ToString(this));
+var aK=W.length;
+t=(%_ToInteger(t));
+if(t<0||t>=aK){
+return(void 0);
+}
+var aT=%_StringCharCodeAt(W,t);
+if(aT<0xD800||aT>0xDBFF||t+1==aK){
+return aT;
+}
+var aU=%_StringCharCodeAt(W,t+1);
+if(aU<0xDC00||aU>0xDFFF){
+return aT;
+}
+return(aT-0xD800)*0x400+aU+0x2400;
+}
+function StringFromCodePoint(aV){
+var aE;
+var Y=%_ArgumentsLength();
+var D;
+var u="";
+for(D=0;D<Y;D++){
+aE=%_Arguments(D);
+if(!%_IsSmi(aE)){
+aE=(%_ToNumber(aE));
+}
+if(aE<0||aE>0x10FFFF||aE!==(%_ToInteger(aE))){
+throw i(167,aE);
+}
+if(aE<=0xFFFF){
+u+=%_StringCharFromCode(aE);
+}else{
+aE-=0x10000;
+u+=%_StringCharFromCode((aE>>>10)&0x3FF|0xD800);
+u+=%_StringCharFromCode(aE&0x3FF|0xDC00);
+}
+}
+return u;
+}
+function StringRaw(aW){
+var aX=%_ArgumentsLength();
+var aY=(%_ToObject(aW));
+var aZ=(%_ToObject(aY.raw));
+var ba=(%_ToLength(aZ.length));
+if(ba<=0)return"";
+var u=(%_ToString(aZ[0]));
+for(var z=1;z<ba;++z){
+if(z<aX){
+u+=(%_ToString(%_Arguments(z)));
+}
+u+=(%_ToString(aZ[z]));
+}
+return u;
+}
+%FunctionSetPrototype(f,new f());
+%AddNamedProperty(
+f.prototype,"constructor",f,2);
+b.InstallFunctions(f,2,[
+"fromCharCode",StringFromCharCode,
+"fromCodePoint",StringFromCodePoint,
+"raw",StringRaw
+]);
+b.InstallFunctions(f.prototype,2,[
+"valueOf",StringValueOf,
+"toString",StringToString,
+"charAt",StringCharAtJS,
+"charCodeAt",StringCharCodeAtJS,
+"codePointAt",StringCodePointAt,
+"concat",StringConcat,
+"endsWith",StringEndsWith,
+"includes",StringIncludes,
+"indexOf",StringIndexOfJS,
+"lastIndexOf",StringLastIndexOfJS,
+"localeCompare",StringLocaleCompareJS,
+"match",StringMatchJS,
+"normalize",StringNormalizeJS,
+"repeat",StringRepeat,
+"replace",StringReplace,
+"search",StringSearch,
+"slice",StringSlice,
+"split",StringSplitJS,
+"substring",StringSubstring,
+"substr",StringSubstr,
+"startsWith",StringStartsWith,
+"toLowerCase",StringToLowerCaseJS,
+"toLocaleLowerCase",StringToLocaleLowerCase,
+"toUpperCase",StringToUpperCaseJS,
+"toLocaleUpperCase",StringToLocaleUpperCase,
+"trim",StringTrimJS,
+"trimLeft",StringTrimLeft,
+"trimRight",StringTrimRight,
+"link",StringLink,
+"anchor",StringAnchor,
+"fontcolor",StringFontcolor,
+"fontsize",StringFontsize,
+"big",StringBig,
+"blink",StringBlink,
+"bold",StringBold,
+"fixed",StringFixed,
+"italics",StringItalics,
+"small",StringSmall,
+"strike",StringStrike,
+"sub",StringSub,
+"sup",StringSup
+]);
+b.Export(function(bb){
+bb.StringCharAt=StringCharAtJS;
+bb.StringIndexOf=StringIndexOfJS;
+bb.StringLastIndexOf=StringLastIndexOfJS;
+bb.StringMatch=StringMatchJS;
+bb.StringReplace=StringReplace;
+bb.StringSlice=StringSlice;
+bb.StringSplit=StringSplitJS;
+bb.StringSubstr=StringSubstr;
+bb.StringSubstring=StringSubstring;
+});
+})
+
+uri1U
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Object;
+var d=a.Array;
+var e=b.InternalArray;
+var f;
+b.Import(function(g){
+f=g.MakeURIError;
+});
+function HexValueOf(h){
+if(h>=48&&h<=57)return h-48;
+if(h>=65&&h<=70)return h-55;
+if(h>=97&&h<=102)return h-87;
+return-1;
+}
+function isAlphaNumeric(i){
+if(97<=i&&i<=122)return true;
+if(65<=i&&i<=90)return true;
+if(48<=i&&i<=57)return true;
+return false;
+}
+var j=0;
+function URIAddEncodedOctetToBuffer(k,l,m){
+l[m++]=37;
+l[m++]=j[k>>4];
+l[m++]=j[k&0x0F];
+return m;
+}
+function URIEncodeOctets(n,l,m){
+if(j===0){
+j=[48,49,50,51,52,53,54,55,56,57,
+65,66,67,68,69,70];
+}
+m=URIAddEncodedOctetToBuffer(n[0],l,m);
+if(n[1])m=URIAddEncodedOctetToBuffer(n[1],l,m);
+if(n[2])m=URIAddEncodedOctetToBuffer(n[2],l,m);
+if(n[3])m=URIAddEncodedOctetToBuffer(n[3],l,m);
+return m;
+}
+function URIEncodeSingle(i,l,m){
+var o=(i>>12)&0xF;
+var p=(i>>6)&63;
+var q=i&63;
+var n=new d(3);
+if(i<=0x007F){
+n[0]=i;
+}else if(i<=0x07FF){
+n[0]=p+192;
+n[1]=q+128;
+}else{
+n[0]=o+224;
+n[1]=p+128;
+n[2]=q+128;
+}
+return URIEncodeOctets(n,l,m);
+}
+function URIEncodePair(r,s,l,m){
+var t=((r>>6)&0xF)+1;
+var u=(r>>2)&0xF;
+var o=r&3;
+var p=(s>>6)&0xF;
+var q=s&63;
+var n=new d(4);
+n[0]=(t>>2)+240;
+n[1]=(((t&3)<<4)|u)+128;
+n[2]=((o<<4)|p)+128;
+n[3]=q+128;
+return URIEncodeOctets(n,l,m);
+}
+function URIHexCharsToCharCode(v,w){
+var x=HexValueOf(v);
+var y=HexValueOf(w);
+if(x==-1||y==-1)throw f();
+return(x<<4)|y;
+}
+function URIDecodeOctets(n,l,m){
+var z;
+var A=n[0];
+if(A<0x80){
+z=A;
+}else if(A<0xc2){
+throw f();
+}else{
+var B=n[1];
+if(A<0xe0){
+var C=A&0x1f;
+if((B<0x80)||(B>0xbf))throw f();
+var D=B&0x3f;
+z=(C<<6)+D;
+if(z<0x80||z>0x7ff)throw f();
+}else{
+var E=n[2];
+if(A<0xf0){
+var C=A&0x0f;
+if((B<0x80)||(B>0xbf))throw f();
+var D=B&0x3f;
+if((E<0x80)||(E>0xbf))throw f();
+var F=E&0x3f;
+z=(C<<12)+(D<<6)+F;
+if((z<0x800)||(z>0xffff))throw f();
+}else{
+var G=n[3];
+if(A<0xf8){
+var C=(A&0x07);
+if((B<0x80)||(B>0xbf))throw f();
+var D=(B&0x3f);
+if((E<0x80)||(E>0xbf)){
+throw f();
+}
+var F=(E&0x3f);
+if((G<0x80)||(G>0xbf))throw f();
+var H=(G&0x3f);
+z=(C<<18)+(D<<12)+(F<<6)+H;
+if((z<0x10000)||(z>0x10ffff))throw f();
+}else{
+throw f();
+}
+}
+}
+}
+if(0xD800<=z&&z<=0xDFFF)throw f();
+if(z<0x10000){
+%_TwoByteSeqStringSetChar(m++,z,l);
+}else{
+%_TwoByteSeqStringSetChar(m++,(z>>10)+0xd7c0,l);
+%_TwoByteSeqStringSetChar(m++,(z&0x3ff)+0xdc00,l);
+}
+return m;
+}
+function Encode(I,J){
+I=(%_ToString(I));
+var K=I.length;
+var L=new e(K);
+var m=0;
+for(var M=0;M<K;M++){
+var r=%_StringCharCodeAt(I,M);
+if(J(r)){
+L[m++]=r;
+}else{
+if(r>=0xDC00&&r<=0xDFFF)throw f();
+if(r<0xD800||r>0xDBFF){
+m=URIEncodeSingle(r,L,m);
+}else{
+M++;
+if(M==K)throw f();
+var s=%_StringCharCodeAt(I,M);
+if(s<0xDC00||s>0xDFFF)throw f();
+m=URIEncodePair(r,s,L,m);
+}
+}
+}
+var l=%NewString(L.length,true);
+for(var N=0;N<L.length;N++){
+%_OneByteSeqStringSetChar(N,L[N],l);
+}
+return l;
+}
+function Decode(I,O){
+I=(%_ToString(I));
+var K=I.length;
+var P=%NewString(K,true);
+var m=0;
+var M=0;
+for(;M<K;M++){
+var h=%_StringCharCodeAt(I,M);
+if(h==37){
+if(M+2>=K)throw f();
+var i=URIHexCharsToCharCode(%_StringCharCodeAt(I,M+1),
+%_StringCharCodeAt(I,M+2));
+if(i>>7)break;
+if(O(i)){
+%_OneByteSeqStringSetChar(m++,37,P);
+%_OneByteSeqStringSetChar(m++,%_StringCharCodeAt(I,M+1),
+P);
+%_OneByteSeqStringSetChar(m++,%_StringCharCodeAt(I,M+2),
+P);
+}else{
+%_OneByteSeqStringSetChar(m++,i,P);
+}
+M+=2;
+}else{
+if(h>0x7f)break;
+%_OneByteSeqStringSetChar(m++,h,P);
+}
+}
+P=%TruncateString(P,m);
+if(M==K)return P;
+var Q=%NewString(K-M,false);
+m=0;
+for(;M<K;M++){
+var h=%_StringCharCodeAt(I,M);
+if(h==37){
+if(M+2>=K)throw f();
+var i=URIHexCharsToCharCode(%_StringCharCodeAt(I,++M),
+%_StringCharCodeAt(I,++M));
+if(i>>7){
+var R=0;
+while(((i<<++R)&0x80)!=0){}
+if(R==1||R>4)throw f();
+var n=new d(R);
+n[0]=i;
+if(M+3*(R-1)>=K)throw f();
+for(var N=1;N<R;N++){
+if(I[++M]!='%')throw f();
+n[N]=URIHexCharsToCharCode(%_StringCharCodeAt(I,++M),
+%_StringCharCodeAt(I,++M));
+}
+m=URIDecodeOctets(n,Q,m);
+}else if(O(i)){
+%_TwoByteSeqStringSetChar(m++,37,Q);
+%_TwoByteSeqStringSetChar(m++,%_StringCharCodeAt(I,M-1),
+Q);
+%_TwoByteSeqStringSetChar(m++,%_StringCharCodeAt(I,M),
+Q);
+}else{
+%_TwoByteSeqStringSetChar(m++,i,Q);
+}
+}else{
+%_TwoByteSeqStringSetChar(m++,h,Q);
+}
+}
+Q=%TruncateString(Q,m);
+return P+Q;
+}
+function URIEscapeJS(S){
+return %URIEscape(S);
+}
+function URIUnescapeJS(S){
+return %URIUnescape(S);
+}
+function URIDecode(I){
+var T=function(i){
+if(35<=i&&i<=36)return true;
+if(i==38)return true;
+if(43<=i&&i<=44)return true;
+if(i==47)return true;
+if(58<=i&&i<=59)return true;
+if(i==61)return true;
+if(63<=i&&i<=64)return true;
+return false;
+};
+return Decode(I,T);
+}
+function URIDecodeComponent(U){
+var T=function(i){return false;};
+return Decode(U,T);
+}
+function URIEncode(I){
+var V=function(i){
+if(isAlphaNumeric(i))return true;
+if(i==33)return true;
+if(35<=i&&i<=36)return true;
+if(38<=i&&i<=47)return true;
+if(58<=i&&i<=59)return true;
+if(i==61)return true;
+if(63<=i&&i<=64)return true;
+if(i==95)return true;
+if(i==126)return true;
+return false;
+};
+return Encode(I,V);
+}
+function URIEncodeComponent(U){
+var V=function(i){
+if(isAlphaNumeric(i))return true;
+if(i==33)return true;
+if(39<=i&&i<=42)return true;
+if(45<=i&&i<=46)return true;
+if(i==95)return true;
+if(i==126)return true;
+return false;
+};
+return Encode(U,V);
+}
+b.InstallFunctions(a,2,[
+"escape",URIEscapeJS,
+"unescape",URIUnescapeJS,
+"decodeURI",URIDecode,
+"decodeURIComponent",URIDecodeComponent,
+"encodeURI",URIEncode,
+"encodeURIComponent",URIEncodeComponent
+]);
+})
+
+math�J
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Float64Array;
+var d=a.Math;
+var e=a.Object;
+var f=b.InternalArray;
+var g=%GetRootNaN();
+var h=64;
+var i=(void 0);
+var j=b.ImportNow("to_string_tag_symbol");
+function MathAbs(k){
+k=+k;
+return(k>0)?k:0-k;
+}
+function MathAcosJS(k){
+return %_MathAcos(+k);
+}
+function MathAsinJS(k){
+return %_MathAsin(+k);
+}
+function MathAtanJS(k){
+return %_MathAtan(+k);
+}
+function MathAtan2JS(l,k){
+l=+l;
+k=+k;
+return %_MathAtan2(l,k);
+}
+function MathCeil(k){
+return-%_MathFloor(-k);
+}
+function MathExp(k){
+return %MathExpRT((%_ToNumber(k)));
+}
+function MathFloorJS(k){
+return %_MathFloor(+k);
+}
+function MathLog(k){
+return %_MathLogRT((%_ToNumber(k)));
+}
+function MathMax(m,n){
+var o=%_ArgumentsLength();
+if(o==2){
+m=(%_ToNumber(m));
+n=(%_ToNumber(n));
+if(n>m)return n;
+if(m>n)return m;
+if(m==n){
+return(m===0&&%_IsMinusZero(m))?n:m;
+}
+return g;
+}
+var p=-(1/0);
+for(var q=0;q<o;q++){
+var r=%_Arguments(q);
+r=(%_ToNumber(r));
+if((!%_IsSmi(%IS_VAR(r))&&!(r==r))||r>p||(p===0&&r===0&&%_IsMinusZero(p))){
+p=r;
+}
+}
+return p;
+}
+function MathMin(m,n){
+var o=%_ArgumentsLength();
+if(o==2){
+m=(%_ToNumber(m));
+n=(%_ToNumber(n));
+if(n>m)return m;
+if(m>n)return n;
+if(m==n){
+return(m===0&&%_IsMinusZero(m))?m:n;
+}
+return g;
+}
+var p=(1/0);
+for(var q=0;q<o;q++){
+var r=%_Arguments(q);
+r=(%_ToNumber(r));
+if((!%_IsSmi(%IS_VAR(r))&&!(r==r))||r<p||(p===0&&r===0&&%_IsMinusZero(r))){
+p=r;
+}
+}
+return p;
+}
+function MathPowJS(k,l){
+return %_MathPow((%_ToNumber(k)),(%_ToNumber(l)));
+}
+function MathRandom(){
+if(h>=64){
+i=%GenerateRandomNumbers(i);
+h=2;
+}
+return i[h++];
+}
+function MathRandomRaw(){
+if(h>=64){
+i=%GenerateRandomNumbers(i);
+h=2;
+}
+return %_DoubleLo(i[h++])&0x3FFFFFFF;
+}
+function MathRound(k){
+return %RoundNumber((%_ToNumber(k)));
+}
+function MathSqrtJS(k){
+return %_MathSqrt(+k);
+}
+function MathImul(k,l){
+return %NumberImul((%_ToNumber(k)),(%_ToNumber(l)));
+}
+function MathSign(k){
+k=+k;
+if(k>0)return 1;
+if(k<0)return-1;
+return k;
+}
+function MathTrunc(k){
+k=+k;
+if(k>0)return %_MathFloor(k);
+if(k<0)return-%_MathFloor(-k);
+return k;
+}
+function MathAsinh(k){
+k=(%_ToNumber(k));
+if(k===0||!(%_IsSmi(%IS_VAR(k))||((k==k)&&(k!=1/0)&&(k!=-1/0))))return k;
+if(k>0)return MathLog(k+%_MathSqrt(k*k+1));
+return-MathLog(-k+%_MathSqrt(k*k+1));
+}
+function MathAcosh(k){
+k=(%_ToNumber(k));
+if(k<1)return g;
+if(!(%_IsSmi(%IS_VAR(k))||((k==k)&&(k!=1/0)&&(k!=-1/0))))return k;
+return MathLog(k+%_MathSqrt(k+1)*%_MathSqrt(k-1));
+}
+function MathAtanh(k){
+k=(%_ToNumber(k));
+if(k===0)return k;
+if(!(%_IsSmi(%IS_VAR(k))||((k==k)&&(k!=1/0)&&(k!=-1/0))))return g;
+return 0.5*MathLog((1+k)/(1-k));
+}
+function MathHypot(k,l){
+var o=%_ArgumentsLength();
+var s=new f(o);
+var t=0;
+for(var q=0;q<o;q++){
+var r=%_Arguments(q);
+r=(%_ToNumber(r));
+if(r===(1/0)||r===-(1/0))return(1/0);
+r=MathAbs(r);
+if(r>t)t=r;
+s[q]=r;
+}
+if(t===0)t=1;
+var u=0;
+var v=0;
+for(var q=0;q<o;q++){
+var r=s[q]/t;
+var w=r*r-v;
+var x=u+w;
+v=(x-u)-w;
+u=x;
+}
+return %_MathSqrt(u)*t;
+}
+function MathFroundJS(k){
+return %MathFround((%_ToNumber(k)));
+}
+function MathClz32JS(k){
+return %_MathClz32(k>>>0);
+}
+function MathCbrt(k){
+k=(%_ToNumber(k));
+if(k==0||!(%_IsSmi(%IS_VAR(k))||((k==k)&&(k!=1/0)&&(k!=-1/0))))return k;
+return k>=0?CubeRoot(k):-CubeRoot(-k);
+}
+function CubeRoot(k){
+var y=MathFloorJS(%_DoubleHi(k)/3)+0x2A9F7893;
+var z=%_ConstructDouble(y|0,0);
+z=(1.0/3.0)*(k/(z*z)+2*z);
+;
+z=(1.0/3.0)*(k/(z*z)+2*z);
+;
+z=(1.0/3.0)*(k/(z*z)+2*z);
+;
+return(1.0/3.0)*(k/(z*z)+2*z);
+;
+}
+%AddNamedProperty(d,j,"Math",1|2);
+b.InstallConstants(d,[
+"E",2.7182818284590452354,
+"LN10",2.302585092994046,
+"LN2",0.6931471805599453,
+"LOG2E",1.4426950408889634,
+"LOG10E",0.4342944819032518,
+"PI",3.1415926535897932,
+"SQRT1_2",0.7071067811865476,
+"SQRT2",1.4142135623730951
+]);
+b.InstallFunctions(d,2,[
+"random",MathRandom,
+"abs",MathAbs,
+"acos",MathAcosJS,
+"asin",MathAsinJS,
+"atan",MathAtanJS,
+"ceil",MathCeil,
+"exp",MathExp,
+"floor",MathFloorJS,
+"log",MathLog,
+"round",MathRound,
+"sqrt",MathSqrtJS,
+"atan2",MathAtan2JS,
+"pow",MathPowJS,
+"max",MathMax,
+"min",MathMin,
+"imul",MathImul,
+"sign",MathSign,
+"trunc",MathTrunc,
+"asinh",MathAsinh,
+"acosh",MathAcosh,
+"atanh",MathAtanh,
+"hypot",MathHypot,
+"fround",MathFroundJS,
+"clz32",MathClz32JS,
+"cbrt",MathCbrt
+]);
+%SetForceInlineFlag(MathAbs);
+%SetForceInlineFlag(MathAcosJS);
+%SetForceInlineFlag(MathAsinJS);
+%SetForceInlineFlag(MathAtanJS);
+%SetForceInlineFlag(MathAtan2JS);
+%SetForceInlineFlag(MathCeil);
+%SetForceInlineFlag(MathClz32JS);
+%SetForceInlineFlag(MathFloorJS);
+%SetForceInlineFlag(MathRandom);
+%SetForceInlineFlag(MathSign);
+%SetForceInlineFlag(MathSqrtJS);
+%SetForceInlineFlag(MathTrunc);
+b.Export(function(A){
+A.MathAbs=MathAbs;
+A.MathExp=MathExp;
+A.MathFloor=MathFloorJS;
+A.IntRandom=MathRandomRaw;
+A.MathMax=MathMax;
+A.MathMin=MathMin;
+});
+})
+
+fdlibm��
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Float64Array;
+var d=a.Math;
+var e;
+var f;
+var g=%GetRootNaN();
+var h;
+b.Import(function(i){
+e=i.MathAbs;
+f=i.MathExp;
+});
+b.CreateDoubleResultArray=function(a){
+h=new c(2);
+};
+function KernelTan(j,k,l){
+var m;
+var n;
+var o=%_DoubleHi(j);
+var p=o&0x7fffffff;
+if(p<0x3e300000){
+if(((p|%_DoubleLo(j))|(l+1))==0){
+return 1/e(j);
+}else{
+if(l==1){
+return j;
+}else{
+var n=j+k;
+var m=%_ConstructDouble(%_DoubleHi(n),0);
+var q=k-(m-j);
+var r=-1/n;
+var s=%_ConstructDouble(%_DoubleHi(r),0);
+var t=1+s*m;
+return s+r*(t+s*q);
+}
+}
+}
+if(p>=0x3fe59428){
+if(j<0){
+j=-j;
+k=-k;
+}
+m=7.85398163397448278999e-01-j;
+n=3.06161699786838301793e-17-k;
+j=m+n;
+k=0;
+}
+m=j*j;
+n=m*m;
+var u=1.33333333333201242699e-01+n*(2.18694882948595424599e-02+n*(3.59207910759131235356e-03+
+n*(5.88041240820264096874e-04+n*(7.81794442939557092300e-05+n*-1.85586374855275456654e-05))));
+var q=m*(5.39682539762260521377e-02+n*(8.86323982359930005737e-03+n*(1.45620945432529025516e-03+
+n*(2.46463134818469906812e-04+n*(7.14072491382608190305e-05+n*2.59073051863633712884e-05)))));
+var t=m*j;
+u=k+m*(t*(u+q)+k);
+u=u+3.33333333333334091986e-01*t;
+n=j+u;
+if(p>=0x3fe59428){
+return(1-((o>>30)&2))*
+(l-2.0*(j-(n*n/(n+l)-u)));
+}
+if(l==1){
+return n;
+}else{
+m=%_ConstructDouble(%_DoubleHi(n),0);
+q=u-(m-j);
+var r=-1/n;
+var s=%_ConstructDouble(%_DoubleHi(r),0);
+t=1+s*m;
+return s+r*(t+s*q);
+}
+}
+function MathSinSlow(j){
+var v,w,x;
+var o=%_DoubleHi(j);
+var p=o&0x7fffffff;
+if(p<0x4002d97c){
+if(o>0){
+var m=j-1.57079632673412561417;
+if(p!=0x3ff921fb){
+w=m-6.07710050650619224932e-11;
+x=(m-w)-6.07710050650619224932e-11;
+}else{
+m-=6.07710050630396597660e-11;
+w=m-2.02226624879595063154e-21;
+x=(m-w)-2.02226624879595063154e-21;
+}
+v=1;
+}else{
+var m=j+1.57079632673412561417;
+if(p!=0x3ff921fb){
+w=m+6.07710050650619224932e-11;
+x=(m-w)+6.07710050650619224932e-11;
+}else{
+m+=6.07710050630396597660e-11;
+w=m+2.02226624879595063154e-21;
+x=(m-w)+2.02226624879595063154e-21;
+}
+v=-1;
+}
+}else if(p<=0x413921fb){
+var s=e(j);
+v=(s*6.36619772367581382433e-01+0.5)|0;
+var u=s-v*1.57079632673412561417;
+var n=v*6.07710050650619224932e-11;
+w=u-n;
+if(p-(%_DoubleHi(w)&0x7ff00000)>0x1000000){
+s=u;
+n=v*6.07710050630396597660e-11;
+u=s-n;
+n=v*2.02226624879595063154e-21-((s-u)-n);
+w=u-n;
+if(p-(%_DoubleHi(w)&0x7ff00000)>0x3100000){
+s=u;
+n=v*2.02226624871116645580e-21;
+u=s-n;
+n=v*8.47842766036889956997e-32-((s-u)-n);
+w=u-n;
+}
+}
+x=(u-w)-n;
+if(o<0){
+v=-v;
+w=-w;
+x=-x;
+}
+}else{
+v=%RemPiO2(j,h);
+w=h[0];
+x=h[1];
+}
+;
+var y=1-(v&2);
+if(v&1){
+var p=%_DoubleHi(w)&0x7fffffff;
+var m=w*w;
+var u=m*(4.16666666666666019037e-02+m*(-1.38888888888741095749e-03+m*(2.48015872894767294178e-05+m*(-2.75573143513906633035e-07+m*(2.08757232129817482790e-09+m*-1.13596475577881948265e-11)))));
+if(p<0x3fd33333){
+return(1-(0.5*m-(m*u-w*x)))*y;
+}else{
+var z;
+if(p>0x3fe90000){
+z=0.28125;
+}else{
+z=%_ConstructDouble(%_DoubleHi(0.25*w),0);
+}
+var A=0.5*m-z;
+return(1-z-(A-(m*u-w*x)))*y;
+}
+;
+}else{
+var m=w*w;
+var q=m*w;
+var u=8.33333333332248946124e-03+m*(-1.98412698298579493134e-04+m*(2.75573137070700676789e-06+m*(-2.50507602534068634195e-08+m*1.58969099521155010221e-10)));
+return(w-((m*(0.5*x-q*u)-x)-q*-1.66666666666666324348e-01))*y;
+;
+}
+}
+function MathCosSlow(j){
+var v,w,x;
+var o=%_DoubleHi(j);
+var p=o&0x7fffffff;
+if(p<0x4002d97c){
+if(o>0){
+var m=j-1.57079632673412561417;
+if(p!=0x3ff921fb){
+w=m-6.07710050650619224932e-11;
+x=(m-w)-6.07710050650619224932e-11;
+}else{
+m-=6.07710050630396597660e-11;
+w=m-2.02226624879595063154e-21;
+x=(m-w)-2.02226624879595063154e-21;
+}
+v=1;
+}else{
+var m=j+1.57079632673412561417;
+if(p!=0x3ff921fb){
+w=m+6.07710050650619224932e-11;
+x=(m-w)+6.07710050650619224932e-11;
+}else{
+m+=6.07710050630396597660e-11;
+w=m+2.02226624879595063154e-21;
+x=(m-w)+2.02226624879595063154e-21;
+}
+v=-1;
+}
+}else if(p<=0x413921fb){
+var s=e(j);
+v=(s*6.36619772367581382433e-01+0.5)|0;
+var u=s-v*1.57079632673412561417;
+var n=v*6.07710050650619224932e-11;
+w=u-n;
+if(p-(%_DoubleHi(w)&0x7ff00000)>0x1000000){
+s=u;
+n=v*6.07710050630396597660e-11;
+u=s-n;
+n=v*2.02226624879595063154e-21-((s-u)-n);
+w=u-n;
+if(p-(%_DoubleHi(w)&0x7ff00000)>0x3100000){
+s=u;
+n=v*2.02226624871116645580e-21;
+u=s-n;
+n=v*8.47842766036889956997e-32-((s-u)-n);
+w=u-n;
+}
+}
+x=(u-w)-n;
+if(o<0){
+v=-v;
+w=-w;
+x=-x;
+}
+}else{
+v=%RemPiO2(j,h);
+w=h[0];
+x=h[1];
+}
+;
+if(v&1){
+var y=(v&2)-1;
+var m=w*w;
+var q=m*w;
+var u=8.33333333332248946124e-03+m*(-1.98412698298579493134e-04+m*(2.75573137070700676789e-06+m*(-2.50507602534068634195e-08+m*1.58969099521155010221e-10)));
+return(w-((m*(0.5*x-q*u)-x)-q*-1.66666666666666324348e-01))*y;
+;
+}else{
+var y=1-(v&2);
+var p=%_DoubleHi(w)&0x7fffffff;
+var m=w*w;
+var u=m*(4.16666666666666019037e-02+m*(-1.38888888888741095749e-03+m*(2.48015872894767294178e-05+m*(-2.75573143513906633035e-07+m*(2.08757232129817482790e-09+m*-1.13596475577881948265e-11)))));
+if(p<0x3fd33333){
+return(1-(0.5*m-(m*u-w*x)))*y;
+}else{
+var z;
+if(p>0x3fe90000){
+z=0.28125;
+}else{
+z=%_ConstructDouble(%_DoubleHi(0.25*w),0);
+}
+var A=0.5*m-z;
+return(1-z-(A-(m*u-w*x)))*y;
+}
+;
+}
+}
+function MathSin(j){
+j=+j;
+if((%_DoubleHi(j)&0x7fffffff)<=0x3fe921fb){
+var m=j*j;
+var q=m*j;
+var u=8.33333333332248946124e-03+m*(-1.98412698298579493134e-04+m*(2.75573137070700676789e-06+m*(-2.50507602534068634195e-08+m*1.58969099521155010221e-10)));
+return(j-((m*(0.5*0-q*u)-0)-q*-1.66666666666666324348e-01));
+;
+}
+return+MathSinSlow(j);
+}
+function MathCos(j){
+j=+j;
+if((%_DoubleHi(j)&0x7fffffff)<=0x3fe921fb){
+var p=%_DoubleHi(j)&0x7fffffff;
+var m=j*j;
+var u=m*(4.16666666666666019037e-02+m*(-1.38888888888741095749e-03+m*(2.48015872894767294178e-05+m*(-2.75573143513906633035e-07+m*(2.08757232129817482790e-09+m*-1.13596475577881948265e-11)))));
+if(p<0x3fd33333){
+return(1-(0.5*m-(m*u-j*0)));
+}else{
+var z;
+if(p>0x3fe90000){
+z=0.28125;
+}else{
+z=%_ConstructDouble(%_DoubleHi(0.25*j),0);
+}
+var A=0.5*m-z;
+return(1-z-(A-(m*u-j*0)));
+}
+;
+}
+return+MathCosSlow(j);
+}
+function MathTan(j){
+j=j*1;
+if((%_DoubleHi(j)&0x7fffffff)<=0x3fe921fb){
+return KernelTan(j,0,1);
+}
+var v,w,x;
+var o=%_DoubleHi(j);
+var p=o&0x7fffffff;
+if(p<0x4002d97c){
+if(o>0){
+var m=j-1.57079632673412561417;
+if(p!=0x3ff921fb){
+w=m-6.07710050650619224932e-11;
+x=(m-w)-6.07710050650619224932e-11;
+}else{
+m-=6.07710050630396597660e-11;
+w=m-2.02226624879595063154e-21;
+x=(m-w)-2.02226624879595063154e-21;
+}
+v=1;
+}else{
+var m=j+1.57079632673412561417;
+if(p!=0x3ff921fb){
+w=m+6.07710050650619224932e-11;
+x=(m-w)+6.07710050650619224932e-11;
+}else{
+m+=6.07710050630396597660e-11;
+w=m+2.02226624879595063154e-21;
+x=(m-w)+2.02226624879595063154e-21;
+}
+v=-1;
+}
+}else if(p<=0x413921fb){
+var s=e(j);
+v=(s*6.36619772367581382433e-01+0.5)|0;
+var u=s-v*1.57079632673412561417;
+var n=v*6.07710050650619224932e-11;
+w=u-n;
+if(p-(%_DoubleHi(w)&0x7ff00000)>0x1000000){
+s=u;
+n=v*6.07710050630396597660e-11;
+u=s-n;
+n=v*2.02226624879595063154e-21-((s-u)-n);
+w=u-n;
+if(p-(%_DoubleHi(w)&0x7ff00000)>0x3100000){
+s=u;
+n=v*2.02226624871116645580e-21;
+u=s-n;
+n=v*8.47842766036889956997e-32-((s-u)-n);
+w=u-n;
+}
+}
+x=(u-w)-n;
+if(o<0){
+v=-v;
+w=-w;
+x=-x;
+}
+}else{
+v=%RemPiO2(j,h);
+w=h[0];
+x=h[1];
+}
+;
+return KernelTan(w,x,(v&1)?-1:1);
+}
+function MathLog1p(j){
+j=j*1;
+var o=%_DoubleHi(j);
+var B=o&0x7fffffff;
+var C=1;
+var D=j;
+var E=1;
+var F=0;
+var G=j;
+if(o<0x3fda827a){
+if(B>=0x3ff00000){
+if(j===-1){
+return-(1/0);
+}else{
+return g;
+}
+}else if(B<0x3c900000){
+return j;
+}else if(B<0x3e200000){
+return j-j*j*0.5;
+}
+if((o>0)||(o<=-0x402D413D)){
+C=0;
+}
+}
+if(o>=0x7ff00000)return j;
+if(C!==0){
+if(o<0x43400000){
+G=1+j;
+E=%_DoubleHi(G);
+C=(E>>20)-1023;
+F=(C>0)?1-(G-j):j-(G-1);
+F=F/G;
+}else{
+E=%_DoubleHi(G);
+C=(E>>20)-1023;
+}
+E=E&0xfffff;
+if(E<0x6a09e){
+G=%_ConstructDouble(E|0x3ff00000,%_DoubleLo(G));
+}else{
+++C;
+G=%_ConstructDouble(E|0x3fe00000,%_DoubleLo(G));
+E=(0x00100000-E)>>2;
+}
+D=G-1;
+}
+var H=0.5*D*D;
+if(E===0){
+if(D===0){
+if(C===0){
+return 0.0;
+}else{
+return C*6.93147180369123816490e-01+(F+C*1.90821492927058770002e-10);
+}
+}
+var I=H*(1-6.666666666666666666e-01*D);
+if(C===0){
+return D-I;
+}else{
+return C*6.93147180369123816490e-01-((I-(C*1.90821492927058770002e-10+F))-D);
+}
+}
+var t=D/(2+D);
+var m=t*t;
+var I=m*(6.666666666666735130e-01+m*(3.999999999940941908e-01+m*(2.857142874366239149e-01+m*(2.222219843214978396e-01+
+m*(1.818357216161805012e-01+m*(1.531383769920937332e-01+m*1.479819860511658591e-01))))));
+if(C===0){
+return D-(H-t*(H+I));
+}else{
+return C*6.93147180369123816490e-01-((H-(t*(H+I)+(C*1.90821492927058770002e-10+F)))-D);
+}
+}
+function MathExpm1(j){
+j=j*1;
+var k;
+var J;
+var K;
+var C;
+var s;
+var F;
+var o=%_DoubleHi(j);
+var L=o&0x80000000;
+var k=(L===0)?j:-j;
+o&=0x7fffffff;
+if(o>=0x4043687a){
+if(o>=0x40862e42){
+if(o>=0x7ff00000){
+return(j===-(1/0))?-1:j;
+}
+if(j>7.09782712893383973096e+02)return(1/0);
+}
+if(L!=0)return-1;
+}
+if(o>0x3fd62e42){
+if(o<0x3ff0a2b2){
+if(L===0){
+J=j-6.93147180369123816490e-01;
+K=1.90821492927058770002e-10;
+C=1;
+}else{
+J=j+6.93147180369123816490e-01;
+K=-1.90821492927058770002e-10;
+C=-1;
+}
+}else{
+C=(1.44269504088896338700*j+((L===0)?0.5:-0.5))|0;
+s=C;
+J=j-s*6.93147180369123816490e-01;
+K=s*1.90821492927058770002e-10;
+}
+j=J-K;
+F=(J-j)-K;
+}else if(o<0x3c900000){
+return j;
+}else{
+C=0;
+}
+var M=0.5*j;
+var N=j*M;
+var O=1+N*(-3.33333333333331316428e-02+N*(1.58730158725481460165e-03+N*
+(-7.93650757867487942473e-05+N*(4.00821782732936239552e-06+N*-2.01099218183624371326e-07))));
+s=3-O*M;
+var P=N*((O-s)/(6-j*s));
+if(C===0){
+return j-(j*P-N);
+}else{
+P=(j*(P-F)-F);
+P-=N;
+if(C===-1)return 0.5*(j-P)-0.5;
+if(C===1){
+if(j<-0.25)return-2*(P-(j+0.5));
+return 1+2*(j-P);
+}
+if(C<=-2||C>56){
+k=1-(P-j);
+k=%_ConstructDouble(%_DoubleHi(k)+(C<<20),%_DoubleLo(k));
+return k-1;
+}
+if(C<20){
+s=%_ConstructDouble(0x3ff00000-(0x200000>>C),0);
+k=s-(P-j);
+k=%_ConstructDouble(%_DoubleHi(k)+(C<<20),%_DoubleLo(k));
+}else{
+s=%_ConstructDouble((0x3ff-C)<<20,0);
+k=j-(P+s);
+k+=1;
+k=%_ConstructDouble(%_DoubleHi(k)+(C<<20),%_DoubleLo(k));
+}
+}
+return k;
+}
+function MathSinh(j){
+j=j*1;
+var Q=(j<0)?-0.5:0.5;
+var B=e(j);
+if(B<22){
+if(B<3.725290298461914e-9)return j;
+var s=MathExpm1(B);
+if(B<1)return Q*(2*s-s*s/(s+1));
+return Q*(s+s/(s+1));
+}
+if(B<709.7822265625)return Q*f(B);
+if(B<=710.4758600739439){
+var n=f(0.5*B);
+var s=Q*n;
+return s*n;
+}
+return j*(1/0);
+}
+function MathCosh(j){
+j=j*1;
+var p=%_DoubleHi(j)&0x7fffffff;
+if(p<0x3fd62e43){
+var s=MathExpm1(e(j));
+var n=1+s;
+if(p<0x3c800000)return n;
+return 1+(s*s)/(n+n);
+}
+if(p<0x40360000){
+var s=f(e(j));
+return 0.5*s+0.5/s;
+}
+if(p<0x40862e42)return 0.5*f(e(j));
+if(e(j)<=710.4758600739439){
+var n=f(0.5*e(j));
+var s=0.5*n;
+return s*n;
+}
+if((!%_IsSmi(%IS_VAR(j))&&!(j==j)))return j;
+return(1/0);
+}
+function MathTanh(j){
+j=j*1;
+if(!(%_IsSmi(%IS_VAR(j))||((j==j)&&(j!=1/0)&&(j!=-1/0)))){
+if(j>0)return 1;
+if(j<0)return-1;
+return j;
+}
+var B=e(j);
+var m;
+if(B<22){
+if(B<2.77555756156289135105e-17){
+return j;
+}
+if(B>=1){
+var s=MathExpm1(2*B);
+m=1-2/(s+2);
+}else{
+var s=MathExpm1(-2*B);
+m=-s/(s+2);
+}
+}else{
+m=1;
+}
+return(j>=0)?m:-m;
+}
+function MathLog10(j){
+j=j*1;
+var o=%_DoubleHi(j);
+var R=%_DoubleLo(j);
+var C=0;
+if(o<0x00100000){
+if(((o&0x7fffffff)|R)===0)return-(1/0);
+if(o<0)return g;
+C-=54;
+j*=18014398509481984;
+o=%_DoubleHi(j);
+R=%_DoubleLo(j);
+}
+if(o>=0x7ff00000)return j;
+C+=(o>>20)-1023;
+var S=(C&0x80000000)>>>31;
+o=(o&0x000fffff)|((0x3ff-S)<<20);
+var k=C+S;
+j=%_ConstructDouble(o,R);
+var m=k*3.69423907715893078616e-13+4.34294481903251816668e-01*%_MathLogRT(j);
+return m+k*3.01029995663611771306e-01;
+}
+function MathLog2(j){
+j=j*1;
+var B=e(j);
+var o=%_DoubleHi(j);
+var R=%_DoubleLo(j);
+var p=o&0x7fffffff;
+if((p|R)==0)return-(1/0);
+if(o<0)return g;
+if(p>=0x7ff00000)return j;
+var v=0;
+if(p<0x00100000){
+B*=9007199254740992;
+v-=53;
+p=%_DoubleHi(B);
+}
+v+=(p>>20)-0x3ff;
+var T=p&0x000fffff;
+p=T|0x3ff00000;
+var U=1;
+var V=0;
+var W=0;
+if(T>0x3988e){
+if(T<0xbb67a){
+U=1.5;
+V=5.84962487220764160156e-01;
+W=1.35003920212974897128e-08;
+}else{
+v+=1;
+p-=0x00100000;
+}
+}
+B=%_ConstructDouble(p,%_DoubleLo(B));
+var G=B-U;
+var q=1/(B+U);
+var X=G*q;
+var Y=%_ConstructDouble(%_DoubleHi(X),0);
+var Z=%_ConstructDouble(%_DoubleHi(B+U),0)
+var aa=B-(Z-U);
+var ab=q*((G-Y*Z)-Y*aa);
+var ac=X*X;
+var u=ac*ac*(5.99999999999994648725e-01+ac*(4.28571428578550184252e-01+ac*(3.33333329818377432918e-01+ac*(
+2.72728123808534006489e-01+ac*(2.30660745775561754067e-01+ac*2.06975017800338417784e-01)))));
+u+=ab*(Y+X);
+ac=Y*Y;
+Z=%_ConstructDouble(%_DoubleHi(3.0+ac+u),0);
+aa=u-((Z-3.0)-ac);
+G=Y*Z;
+q=ab*Z+aa*X;
+var ad=%_ConstructDouble(%_DoubleHi(G+q),0);
+var ae=q-(ad-G);
+var af=9.61796700954437255859e-01*ad;
+var ag=-7.02846165095275826516e-09*ad+ae*9.61796693925975554329e-01+W;
+var s=v;
+var ah=%_ConstructDouble(%_DoubleHi(((af+ag)+V)+s),0);
+var ai=ag-(((ah-s)-V)-af);
+return ah+ai;
+}
+b.InstallFunctions(d,2,[
+"cos",MathCos,
+"sin",MathSin,
+"tan",MathTan,
+"sinh",MathSinh,
+"cosh",MathCosh,
+"tanh",MathTanh,
+"log10",MathLog10,
+"log2",MathLog2,
+"log1p",MathLog1p,
+"expm1",MathExpm1
+]);
+%SetForceInlineFlag(MathSin);
+%SetForceInlineFlag(MathCos);
+})
+
+regexp�
+(function(a,b){
+%CheckIsBootstrapping();
+var c;
+var d=a.Object;
+var e=a.RegExp;
+var f;
+var g=b.InternalArray;
+var h=b.InternalPackedArray;
+var i;
+var j=b.ImportNow("match_symbol");
+var k=b.ImportNow("search_symbol");
+var l=b.ImportNow("split_symbol");
+b.ImportFromExperimental(function(m){
+c=m.FLAG_harmony_tolength;
+});
+b.Import(function(m){
+i=m.MakeTypeError;
+});
+var n=new h(
+2,
+"",
+(void 0),
+0,
+0
+);
+function IsRegExp(o){
+if(!(%_IsJSReceiver(o)))return false;
+var p=o[j];
+if(!(p===(void 0)))return(!!(p));
+return(%_IsRegExp(o));
+}
+function RegExpInitialize(q,r,s){
+r=(r===(void 0))?'':(%_ToString(r));
+s=(s===(void 0))?'':(%_ToString(s));
+%RegExpInitializeAndCompile(q,r,s);
+return q;
+}
+function PatternFlags(r){
+return((%_RegExpFlags(r)&1)?'g':'')+
+((%_RegExpFlags(r)&2)?'i':'')+
+((%_RegExpFlags(r)&4)?'m':'')+
+((%_RegExpFlags(r)&16)?'u':'')+
+((%_RegExpFlags(r)&8)?'y':'');
+}
+function RegExpConstructor(r,s){
+var t=new.target;
+var u=IsRegExp(r);
+if((t===(void 0))){
+t=e;
+if(u&&(s===(void 0))&&
+r.constructor===t){
+return r;
+}
+}
+if((%_IsRegExp(r))){
+if((s===(void 0)))s=PatternFlags(r);
+r=(%_RegExpSource(r));
+}else if(u){
+var v=r;
+r=r.source;
+if((s===(void 0)))s=v.flags;
+}
+var q=%NewObject(e,t);
+return RegExpInitialize(q,r,s);
+}
+function RegExpCompileJS(r,s){
+if(!(%_IsRegExp(this))){
+throw i(42,
+"RegExp.prototype.compile",this);
+}
+if((%_IsRegExp(r))){
+if(!(s===(void 0)))throw i(129);
+s=PatternFlags(r);
+r=(%_RegExpSource(r));
+}
+RegExpInitialize(this,r,s);
+}
+function DoRegExpExec(w,x,y){
+return %_RegExpExec(w,x,y,n);
+}
+function RegExpExecNoTests(w,x,z){
+var A=%_RegExpExec(w,x,z,n);
+if(A!==null){
+if((%_RegExpFlags(w)&8))w.lastIndex=A[4];
+var B=((A)[0])>>1;
+var z=A[3];
+var C=A[4];
+var D=%_SubString(x,z,C);
+var E=%_RegExpConstructResult(B,z,x);
+E[0]=D;
+if(B==1)return E;
+var F=3+2;
+for(var G=1;G<B;G++){
+z=A[F++];
+if(z!=-1){
+C=A[F];
+E[G]=%_SubString(x,z,C);
+}
+F++;
+}
+return E;
+;
+}
+w.lastIndex=0;
+return null;
+}
+function RegExpExecJS(x){
+if(!(%_IsRegExp(this))){
+throw i(42,
+'RegExp.prototype.exec',this);
+}
+x=(%_ToString(x));
+var H=this.lastIndex;
+var G=(c?(%_ToLength(H)):(%_ToInteger(H)));
+var I=(%_RegExpFlags(this)&1)||(%_RegExpFlags(this)&8);
+if(I){
+if(G<0||G>x.length){
+this.lastIndex=0;
+return null;
+}
+}else{
+G=0;
+}
+var J=%_RegExpExec(this,x,G,n);
+if((J===null)){
+this.lastIndex=0;
+return null;
+}
+if(I){
+this.lastIndex=n[4];
+}
+var B=((J)[0])>>1;
+var z=J[3];
+var C=J[4];
+var D=%_SubString(x,z,C);
+var E=%_RegExpConstructResult(B,z,x);
+E[0]=D;
+if(B==1)return E;
+var F=3+2;
+for(var G=1;G<B;G++){
+z=J[F++];
+if(z!=-1){
+C=J[F];
+E[G]=%_SubString(x,z,C);
+}
+F++;
+}
+return E;
+;
+}
+var K;
+var L;
+function RegExpTest(x){
+if(!(%_IsRegExp(this))){
+throw i(42,
+'RegExp.prototype.test',this);
+}
+x=(%_ToString(x));
+var H=this.lastIndex;
+var G=(c?(%_ToLength(H)):(%_ToInteger(H)));
+if((%_RegExpFlags(this)&1)||(%_RegExpFlags(this)&8)){
+if(G<0||G>x.length){
+this.lastIndex=0;
+return false;
+}
+var J=%_RegExpExec(this,x,G,n);
+if((J===null)){
+this.lastIndex=0;
+return false;
+}
+this.lastIndex=n[4];
+return true;
+}else{
+var w=this;
+var M=(%_RegExpSource(w));
+if(w.length>=3&&
+%_StringCharCodeAt(w,0)==46&&
+%_StringCharCodeAt(w,1)==42&&
+%_StringCharCodeAt(w,2)!=63){
+w=TrimRegExp(w);
+}
+var J=%_RegExpExec(w,x,0,n);
+if((J===null)){
+this.lastIndex=0;
+return false;
+}
+return true;
+}
+}
+function TrimRegExp(w){
+if(!%_ObjectEquals(K,w)){
+K=w;
+L=
+new e(
+%_SubString((%_RegExpSource(w)),2,(%_RegExpSource(w)).length),
+((%_RegExpFlags(w)&2)?(%_RegExpFlags(w)&4)?"im":"i"
+:(%_RegExpFlags(w)&4)?"m":""));
+}
+return L;
+}
+function RegExpToString(){
+if(!(%_IsRegExp(this))){
+if(this===f){
+%IncrementUseCounter(12);
+return'/(?:)/';
+}
+throw i(42,
+'RegExp.prototype.toString',this);
+}
+var E='/'+(%_RegExpSource(this))+'/';
+if((%_RegExpFlags(this)&1))E+='g';
+if((%_RegExpFlags(this)&2))E+='i';
+if((%_RegExpFlags(this)&4))E+='m';
+if((%_RegExpFlags(this)&16))E+='u';
+if((%_RegExpFlags(this)&8))E+='y';
+return E;
+}
+function RegExpSplit(x,N){
+if(!(%_IsRegExp(this))){
+throw i(42,
+"RegExp.prototype.@@split",this);
+}
+var O=this;
+var P=(%_ToString(x));
+N=((N===(void 0)))?4294967295:((N)>>>0);
+var Q=P.length;
+if(N===0)return[];
+if(Q===0){
+if(DoRegExpExec(O,P,0,0)!==null)return[];
+return[P];
+}
+var R=0;
+var S=0;
+var T=0;
+var E=new g();
+outer_loop:
+while(true){
+if(S===Q){
+E[E.length]=%_SubString(P,R,Q);
+break;
+}
+var A=DoRegExpExec(O,P,S);
+if(A===null||Q===(T=A[3])){
+E[E.length]=%_SubString(P,R,Q);
+break;
+}
+var U=A[4];
+if(S===U&&U===R){
+S++;
+continue;
+}
+E[E.length]=%_SubString(P,R,T);
+if(E.length===N)break;
+var V=((A)[0])+3;
+for(var G=3+2;G<V;){
+var z=A[G++];
+var C=A[G++];
+if(C!=-1){
+E[E.length]=%_SubString(P,z,C);
+}else{
+E[E.length]=(void 0);
+}
+if(E.length===N)break outer_loop;
+}
+S=R=U;
+}
+var W=[];
+%MoveArrayContents(E,W);
+return W;
+}
+function RegExpMatch(x){
+if(!(%_IsRegExp(this))){
+throw i(42,
+"RegExp.prototype.@@match",this);
+}
+var P=(%_ToString(x));
+if(!(%_RegExpFlags(this)&1))return RegExpExecNoTests(this,P,0);
+this.lastIndex=0;
+var E=%StringMatch(P,this,n);
+return E;
+}
+function RegExpSearch(x){
+if(!(%_IsRegExp(this))){
+throw i(42,
+"RegExp.prototype.@@search",this);
+}
+var X=DoRegExpExec(this,(%_ToString(x)),0);
+if(X)return X[3];
+return-1;
+}
+function RegExpGetLastMatch(){
+var Y=((n)[1]);
+return %_SubString(Y,
+n[3],
+n[4]);
+}
+function RegExpGetLastParen(){
+var Q=((n)[0]);
+if(Q<=2)return'';
+var Y=((n)[1]);
+var z=n[(3+(Q-2))];
+var C=n[(3+(Q-1))];
+if(z!=-1&&C!=-1){
+return %_SubString(Y,z,C);
+}
+return"";
+}
+function RegExpGetLeftContext(){
+var Z;
+var P;
+Z=n[3];
+P=((n)[1]);
+return %_SubString(P,0,Z);
+}
+function RegExpGetRightContext(){
+var Z;
+var P;
+Z=n[4];
+P=((n)[1]);
+return %_SubString(P,Z,P.length);
+}
+function RegExpMakeCaptureGetter(aa){
+return function foo(){
+var y=aa*2;
+if(y>=((n)[0]))return'';
+var ab=n[(3+(y))];
+var ac=n[(3+(y+1))];
+if(ab==-1||ac==-1)return'';
+return %_SubString(((n)[1]),ab,ac);
+};
+}
+function RegExpGetGlobal(){
+if(!(%_IsRegExp(this))){
+if(this===f){
+return(void 0);
+}
+throw i(131,"RegExp.prototype.global");
+}
+return!!(%_RegExpFlags(this)&1);
+}
+%FunctionSetName(RegExpGetGlobal,"RegExp.prototype.global");
+%SetNativeFlag(RegExpGetGlobal);
+function RegExpGetIgnoreCase(){
+if(!(%_IsRegExp(this))){
+if(this===f){
+return(void 0);
+}
+throw i(131,"RegExp.prototype.ignoreCase");
+}
+return!!(%_RegExpFlags(this)&2);
+}
+%FunctionSetName(RegExpGetIgnoreCase,"RegExp.prototype.ignoreCase");
+%SetNativeFlag(RegExpGetIgnoreCase);
+function RegExpGetMultiline(){
+if(!(%_IsRegExp(this))){
+if(this===f){
+return(void 0);
+}
+throw i(131,"RegExp.prototype.multiline");
+}
+return!!(%_RegExpFlags(this)&4);
+}
+%FunctionSetName(RegExpGetMultiline,"RegExp.prototype.multiline");
+%SetNativeFlag(RegExpGetMultiline);
+function RegExpGetSource(){
+if(!(%_IsRegExp(this))){
+if(this===f){
+return(void 0);
+}
+throw i(131,"RegExp.prototype.source");
+}
+return(%_RegExpSource(this));
+}
+%FunctionSetName(RegExpGetSource,"RegExp.prototype.source");
+%SetNativeFlag(RegExpGetSource);
+%FunctionSetInstanceClassName(e,'RegExp');
+f=new d();
+%FunctionSetPrototype(e,f);
+%AddNamedProperty(
+e.prototype,'constructor',e,2);
+%SetCode(e,RegExpConstructor);
+b.InstallFunctions(e.prototype,2,[
+"exec",RegExpExecJS,
+"test",RegExpTest,
+"toString",RegExpToString,
+"compile",RegExpCompileJS,
+j,RegExpMatch,
+k,RegExpSearch,
+l,RegExpSplit,
+]);
+b.InstallGetter(e.prototype,'global',RegExpGetGlobal);
+b.InstallGetter(e.prototype,'ignoreCase',RegExpGetIgnoreCase);
+b.InstallGetter(e.prototype,'multiline',RegExpGetMultiline);
+b.InstallGetter(e.prototype,'source',RegExpGetSource);
+%FunctionSetLength(e.prototype.compile,1);
+var ad=function(){
+var ae=((n)[2]);
+return(ae===(void 0))?"":ae;
+};
+var af=function(x){
+((n)[2])=(%_ToString(x));
+};
+%OptimizeObjectForAddingMultipleProperties(e,22);
+b.InstallGetterSetter(e,'input',ad,af,
+4);
+b.InstallGetterSetter(e,'$_',ad,af,
+2|4);
+var ag=function(ah){};
+b.InstallGetterSetter(e,'lastMatch',RegExpGetLastMatch,
+ag,4);
+b.InstallGetterSetter(e,'$&',RegExpGetLastMatch,ag,
+2|4);
+b.InstallGetterSetter(e,'lastParen',RegExpGetLastParen,
+ag,4);
+b.InstallGetterSetter(e,'$+',RegExpGetLastParen,ag,
+2|4);
+b.InstallGetterSetter(e,'leftContext',RegExpGetLeftContext,
+ag,4);
+b.InstallGetterSetter(e,'$`',RegExpGetLeftContext,ag,
+2|4);
+b.InstallGetterSetter(e,'rightContext',RegExpGetRightContext,
+ag,4);
+b.InstallGetterSetter(e,"$'",RegExpGetRightContext,ag,
+2|4);
+for(var G=1;G<10;++G){
+b.InstallGetterSetter(e,'$'+G,RegExpMakeCaptureGetter(G),
+ag,4);
+}
+%ToFastProperties(e);
+b.Export(function(ai){
+ai.RegExpExec=DoRegExpExec;
+ai.RegExpExecNoTests=RegExpExecNoTests;
+ai.RegExpLastMatchInfo=n;
+ai.RegExpTest=RegExpTest;
+});
+})
+
+,arraybuffer�
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.ArrayBuffer;
+var d;
+var e;
+var f;
+var g;
+b.Import(function(h){
+d=h.MakeTypeError;
+e=h.MaxSimple;
+f=h.MinSimple;
+g=h.SpeciesConstructor;
+});
+function ArrayBufferGetByteLen(){
+if(!(%_ClassOf(this)==='ArrayBuffer')){
+throw d(42,
+'ArrayBuffer.prototype.byteLength',this);
+}
+return %_ArrayBufferGetByteLength(this);
+}
+function ArrayBufferSlice(i,j){
+if(!(%_ClassOf(this)==='ArrayBuffer')){
+throw d(42,
+'ArrayBuffer.prototype.slice',this);
+}
+var k=(%_ToInteger(i));
+if(!(j===(void 0))){
+j=(%_ToInteger(j));
+}
+var l;
+var m=%_ArrayBufferGetByteLength(this);
+if(k<0){
+l=e(m+k,0);
+}else{
+l=f(k,m);
+}
+var n=(j===(void 0))?m:j;
+var o;
+if(n<0){
+o=e(m+n,0);
+}else{
+o=f(n,m);
+}
+if(o<l){
+o=l;
+}
+var p=o-l;
+var q=g(this,c,true);
+var r=new q(p);
+if(!(%_ClassOf(r)==='ArrayBuffer')){
+throw d(42,
+'ArrayBuffer.prototype.slice',r);
+}
+if(r===this){
+throw d(11);
+}
+if(%_ArrayBufferGetByteLength(r)<p){
+throw d(10);
+}
+%ArrayBufferSliceImpl(this,r,l,p);
+return r;
+}
+b.InstallGetter(c.prototype,"byteLength",
+ArrayBufferGetByteLen);
+b.InstallFunctions(c.prototype,2,[
+"slice",ArrayBufferSlice
+]);
+})
+
+(typedarrayz�
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c;
+var d;
+var e;
+var f=a.Array;
+var g=a.ArrayBuffer;
+var h=a.DataView;
+var i=a.Object;
+var j=b.InternalArray;
+var k;
+var l;
+var m;
+var n;
+var o;
+var p;
+var q;
+var r;
+var s;
+var t;
+var u;
+var v;
+var w;
+var x;
+var y;
+var z;
+var j=b.InternalArray;
+var A;
+var B;
+var C;
+var D;
+var E;
+var F;
+var G;
+var H;
+var I=b.ImportNow("iterator_symbol");
+var J=b.ImportNow("to_string_tag_symbol");
+var K=a.Uint8Array;
+
+var L=a.Int8Array;
+
+var M=a.Uint16Array;
+
+var N=a.Int16Array;
+
+var O=a.Uint32Array;
+
+var P=a.Int32Array;
+
+var Q=a.Float32Array;
+
+var R=a.Float64Array;
+
+var S=a.Uint8ClampedArray;
+
+
+b.Import(function(T){
+c=T.ArrayFrom;
+d=T.ArrayToString;
+e=T.ArrayValues;
+k=T.InnerArrayCopyWithin;
+l=T.InnerArrayEvery;
+m=T.InnerArrayFill;
+n=T.InnerArrayFilter;
+o=T.InnerArrayFind;
+p=T.InnerArrayFindIndex;
+q=T.InnerArrayForEach;
+r=T.InnerArrayIncludes;
+s=T.InnerArrayIndexOf;
+t=T.InnerArrayJoin;
+u=T.InnerArrayLastIndexOf;
+v=T.InnerArrayReduce;
+w=T.InnerArrayReduceRight;
+x=T.InnerArraySome;
+y=T.InnerArraySort;
+z=T.InnerArrayToLocaleString;
+A=T.IsNaN;
+B=T.MakeRangeError;
+C=T.MakeTypeError;
+D=T.MaxSimple;
+E=T.MinSimple;
+F=T.PackedArrayReverse;
+G=T.SpeciesConstructor;
+H=T.ToPositiveInteger;
+});
+function TypedArrayDefaultConstructor(U){
+switch(%_ClassOf(U)){
+case"Uint8Array":
+return K;
+
+case"Int8Array":
+return L;
+
+case"Uint16Array":
+return M;
+
+case"Int16Array":
+return N;
+
+case"Uint32Array":
+return O;
+
+case"Int32Array":
+return P;
+
+case"Float32Array":
+return Q;
+
+case"Float64Array":
+return R;
+
+case"Uint8ClampedArray":
+return S;
+
+
+}
+throw C(42,
+"TypedArrayDefaultConstructor",this);
+}
+function TypedArrayCreate(V,W,X,Y){
+if((X===(void 0))){
+var Z=new V(W);
+}else{
+var Z=new V(W,X,Y);
+}
+if(!%_IsTypedArray(Z))throw C(68);
+if((typeof(W)==='number')&&%_TypedArrayGetLength(Z)<W){
+throw C(265);
+}
+return Z;
+}
+function TypedArraySpeciesCreate(aa,W,X,Y,ab){
+var ac=TypedArrayDefaultConstructor(aa);
+var V=G(aa,ac,
+ab);
+return TypedArrayCreate(V,W,X,Y);
+}
+function Uint8ArrayConstructByArrayBuffer(ad,ae,af,ag){
+if(!(af===(void 0))){
+af=H(af,180);
+}
+if(!(ag===(void 0))){
+ag=H(ag,180);
+}
+var ah=%_ArrayBufferGetByteLength(ae);
+var ai;
+if((af===(void 0))){
+ai=0;
+}else{
+ai=af;
+if(ai % 1!==0){
+throw B(179,
+"start offset","Uint8Array",1);
+}
+if(ai>ah){
+throw B(181);
+}
+}
+var aj;
+var ak;
+if((ag===(void 0))){
+if(ah % 1!==0){
+throw B(179,
+"byte length","Uint8Array",1);
+}
+aj=ah-ai;
+ak=aj/1;
+}else{
+var ak=ag;
+aj=ak*1;
+}
+if((ai+aj>ah)
+||(ak>%_MaxSmi())){
+throw B(180);
+}
+%_TypedArrayInitialize(ad,1,ae,ai,aj,true);
+}
+function Uint8ArrayConstructByLength(ad,ag){
+var al=(ag===(void 0))?
+0:H(ag,180);
+if(al>%_MaxSmi()){
+throw B(180);
+}
+var am=al*1;
+if(am>%_TypedArrayMaxSizeInHeap()){
+var ae=new g(am);
+%_TypedArrayInitialize(ad,1,ae,0,am,true);
+}else{
+%_TypedArrayInitialize(ad,1,null,0,am,true);
+}
+}
+function Uint8ArrayConstructByArrayLike(ad,an){
+var ag=an.length;
+var al=H(ag,180);
+if(al>%_MaxSmi()){
+throw B(180);
+}
+var ao=false;
+var am=al*1;
+if(am<=%_TypedArrayMaxSizeInHeap()){
+%_TypedArrayInitialize(ad,1,null,0,am,false);
+}else{
+ao=
+%TypedArrayInitializeFromArrayLike(ad,1,an,al);
+}
+if(!ao){
+for(var ap=0;ap<al;ap++){
+ad[ap]=an[ap];
+}
+}
+}
+function Uint8ArrayConstructByIterable(ad,aq,ar){
+var as=new j();
+var at=%_Call(ar,aq);
+var au={
+__proto__:null
+};
+au[I]=function(){return at;}
+for(var av of au){
+as.push(av);
+}
+Uint8ArrayConstructByArrayLike(ad,as);
+}
+function Uint8ArrayConstructor(X,Y,aw){
+if(!(new.target===(void 0))){
+if((%_ClassOf(X)==='ArrayBuffer')||(%_ClassOf(X)==='SharedArrayBuffer')){
+Uint8ArrayConstructByArrayBuffer(this,X,Y,aw);
+}else if((typeof(X)==='number')||(typeof(X)==='string')||
+(typeof(X)==='boolean')||(X===(void 0))){
+Uint8ArrayConstructByLength(this,X);
+}else{
+var ar=X[I];
+if((ar===(void 0))||ar===e){
+Uint8ArrayConstructByArrayLike(this,X);
+}else{
+Uint8ArrayConstructByIterable(this,X,ar);
+}
+}
+}else{
+throw C(26,"Uint8Array")
+}
+}
+function Uint8Array_GetLength(){
+if(!(%_ClassOf(this)==='Uint8Array')){
+throw C(42,"Uint8Array.length",this);
+}
+return %_TypedArrayGetLength(this);
+}
+function Uint8ArraySubArray(ax,ay){
+var az=(%_ToInteger(ax));
+if(!(ay===(void 0))){
+var aA=(%_ToInteger(ay));
+var aB=%_TypedArrayGetLength(this);
+}else{
+var aB=%_TypedArrayGetLength(this);
+var aA=aB;
+}
+if(az<0){
+az=D(0,aB+az);
+}else{
+az=E(az,aB);
+}
+if(aA<0){
+aA=D(0,aB+aA);
+}else{
+aA=E(aA,aB);
+}
+if(aA<az){
+aA=az;
+}
+var ak=aA-az;
+var aC=
+%_ArrayBufferViewGetByteOffset(this)+az*1;
+return TypedArraySpeciesCreate(this,%TypedArrayGetBuffer(this),
+aC,ak,true);
+}
+
+function Int8ArrayConstructByArrayBuffer(ad,ae,af,ag){
+if(!(af===(void 0))){
+af=H(af,180);
+}
+if(!(ag===(void 0))){
+ag=H(ag,180);
+}
+var ah=%_ArrayBufferGetByteLength(ae);
+var ai;
+if((af===(void 0))){
+ai=0;
+}else{
+ai=af;
+if(ai % 1!==0){
+throw B(179,
+"start offset","Int8Array",1);
+}
+if(ai>ah){
+throw B(181);
+}
+}
+var aj;
+var ak;
+if((ag===(void 0))){
+if(ah % 1!==0){
+throw B(179,
+"byte length","Int8Array",1);
+}
+aj=ah-ai;
+ak=aj/1;
+}else{
+var ak=ag;
+aj=ak*1;
+}
+if((ai+aj>ah)
+||(ak>%_MaxSmi())){
+throw B(180);
+}
+%_TypedArrayInitialize(ad,2,ae,ai,aj,true);
+}
+function Int8ArrayConstructByLength(ad,ag){
+var al=(ag===(void 0))?
+0:H(ag,180);
+if(al>%_MaxSmi()){
+throw B(180);
+}
+var am=al*1;
+if(am>%_TypedArrayMaxSizeInHeap()){
+var ae=new g(am);
+%_TypedArrayInitialize(ad,2,ae,0,am,true);
+}else{
+%_TypedArrayInitialize(ad,2,null,0,am,true);
+}
+}
+function Int8ArrayConstructByArrayLike(ad,an){
+var ag=an.length;
+var al=H(ag,180);
+if(al>%_MaxSmi()){
+throw B(180);
+}
+var ao=false;
+var am=al*1;
+if(am<=%_TypedArrayMaxSizeInHeap()){
+%_TypedArrayInitialize(ad,2,null,0,am,false);
+}else{
+ao=
+%TypedArrayInitializeFromArrayLike(ad,2,an,al);
+}
+if(!ao){
+for(var ap=0;ap<al;ap++){
+ad[ap]=an[ap];
+}
+}
+}
+function Int8ArrayConstructByIterable(ad,aq,ar){
+var as=new j();
+var at=%_Call(ar,aq);
+var au={
+__proto__:null
+};
+au[I]=function(){return at;}
+for(var av of au){
+as.push(av);
+}
+Int8ArrayConstructByArrayLike(ad,as);
+}
+function Int8ArrayConstructor(X,Y,aw){
+if(!(new.target===(void 0))){
+if((%_ClassOf(X)==='ArrayBuffer')||(%_ClassOf(X)==='SharedArrayBuffer')){
+Int8ArrayConstructByArrayBuffer(this,X,Y,aw);
+}else if((typeof(X)==='number')||(typeof(X)==='string')||
+(typeof(X)==='boolean')||(X===(void 0))){
+Int8ArrayConstructByLength(this,X);
+}else{
+var ar=X[I];
+if((ar===(void 0))||ar===e){
+Int8ArrayConstructByArrayLike(this,X);
+}else{
+Int8ArrayConstructByIterable(this,X,ar);
+}
+}
+}else{
+throw C(26,"Int8Array")
+}
+}
+function Int8Array_GetLength(){
+if(!(%_ClassOf(this)==='Int8Array')){
+throw C(42,"Int8Array.length",this);
+}
+return %_TypedArrayGetLength(this);
+}
+function Int8ArraySubArray(ax,ay){
+var az=(%_ToInteger(ax));
+if(!(ay===(void 0))){
+var aA=(%_ToInteger(ay));
+var aB=%_TypedArrayGetLength(this);
+}else{
+var aB=%_TypedArrayGetLength(this);
+var aA=aB;
+}
+if(az<0){
+az=D(0,aB+az);
+}else{
+az=E(az,aB);
+}
+if(aA<0){
+aA=D(0,aB+aA);
+}else{
+aA=E(aA,aB);
+}
+if(aA<az){
+aA=az;
+}
+var ak=aA-az;
+var aC=
+%_ArrayBufferViewGetByteOffset(this)+az*1;
+return TypedArraySpeciesCreate(this,%TypedArrayGetBuffer(this),
+aC,ak,true);
+}
+
+function Uint16ArrayConstructByArrayBuffer(ad,ae,af,ag){
+if(!(af===(void 0))){
+af=H(af,180);
+}
+if(!(ag===(void 0))){
+ag=H(ag,180);
+}
+var ah=%_ArrayBufferGetByteLength(ae);
+var ai;
+if((af===(void 0))){
+ai=0;
+}else{
+ai=af;
+if(ai % 2!==0){
+throw B(179,
+"start offset","Uint16Array",2);
+}
+if(ai>ah){
+throw B(181);
+}
+}
+var aj;
+var ak;
+if((ag===(void 0))){
+if(ah % 2!==0){
+throw B(179,
+"byte length","Uint16Array",2);
+}
+aj=ah-ai;
+ak=aj/2;
+}else{
+var ak=ag;
+aj=ak*2;
+}
+if((ai+aj>ah)
+||(ak>%_MaxSmi())){
+throw B(180);
+}
+%_TypedArrayInitialize(ad,3,ae,ai,aj,true);
+}
+function Uint16ArrayConstructByLength(ad,ag){
+var al=(ag===(void 0))?
+0:H(ag,180);
+if(al>%_MaxSmi()){
+throw B(180);
+}
+var am=al*2;
+if(am>%_TypedArrayMaxSizeInHeap()){
+var ae=new g(am);
+%_TypedArrayInitialize(ad,3,ae,0,am,true);
+}else{
+%_TypedArrayInitialize(ad,3,null,0,am,true);
+}
+}
+function Uint16ArrayConstructByArrayLike(ad,an){
+var ag=an.length;
+var al=H(ag,180);
+if(al>%_MaxSmi()){
+throw B(180);
+}
+var ao=false;
+var am=al*2;
+if(am<=%_TypedArrayMaxSizeInHeap()){
+%_TypedArrayInitialize(ad,3,null,0,am,false);
+}else{
+ao=
+%TypedArrayInitializeFromArrayLike(ad,3,an,al);
+}
+if(!ao){
+for(var ap=0;ap<al;ap++){
+ad[ap]=an[ap];
+}
+}
+}
+function Uint16ArrayConstructByIterable(ad,aq,ar){
+var as=new j();
+var at=%_Call(ar,aq);
+var au={
+__proto__:null
+};
+au[I]=function(){return at;}
+for(var av of au){
+as.push(av);
+}
+Uint16ArrayConstructByArrayLike(ad,as);
+}
+function Uint16ArrayConstructor(X,Y,aw){
+if(!(new.target===(void 0))){
+if((%_ClassOf(X)==='ArrayBuffer')||(%_ClassOf(X)==='SharedArrayBuffer')){
+Uint16ArrayConstructByArrayBuffer(this,X,Y,aw);
+}else if((typeof(X)==='number')||(typeof(X)==='string')||
+(typeof(X)==='boolean')||(X===(void 0))){
+Uint16ArrayConstructByLength(this,X);
+}else{
+var ar=X[I];
+if((ar===(void 0))||ar===e){
+Uint16ArrayConstructByArrayLike(this,X);
+}else{
+Uint16ArrayConstructByIterable(this,X,ar);
+}
+}
+}else{
+throw C(26,"Uint16Array")
+}
+}
+function Uint16Array_GetLength(){
+if(!(%_ClassOf(this)==='Uint16Array')){
+throw C(42,"Uint16Array.length",this);
+}
+return %_TypedArrayGetLength(this);
+}
+function Uint16ArraySubArray(ax,ay){
+var az=(%_ToInteger(ax));
+if(!(ay===(void 0))){
+var aA=(%_ToInteger(ay));
+var aB=%_TypedArrayGetLength(this);
+}else{
+var aB=%_TypedArrayGetLength(this);
+var aA=aB;
+}
+if(az<0){
+az=D(0,aB+az);
+}else{
+az=E(az,aB);
+}
+if(aA<0){
+aA=D(0,aB+aA);
+}else{
+aA=E(aA,aB);
+}
+if(aA<az){
+aA=az;
+}
+var ak=aA-az;
+var aC=
+%_ArrayBufferViewGetByteOffset(this)+az*2;
+return TypedArraySpeciesCreate(this,%TypedArrayGetBuffer(this),
+aC,ak,true);
+}
+
+function Int16ArrayConstructByArrayBuffer(ad,ae,af,ag){
+if(!(af===(void 0))){
+af=H(af,180);
+}
+if(!(ag===(void 0))){
+ag=H(ag,180);
+}
+var ah=%_ArrayBufferGetByteLength(ae);
+var ai;
+if((af===(void 0))){
+ai=0;
+}else{
+ai=af;
+if(ai % 2!==0){
+throw B(179,
+"start offset","Int16Array",2);
+}
+if(ai>ah){
+throw B(181);
+}
+}
+var aj;
+var ak;
+if((ag===(void 0))){
+if(ah % 2!==0){
+throw B(179,
+"byte length","Int16Array",2);
+}
+aj=ah-ai;
+ak=aj/2;
+}else{
+var ak=ag;
+aj=ak*2;
+}
+if((ai+aj>ah)
+||(ak>%_MaxSmi())){
+throw B(180);
+}
+%_TypedArrayInitialize(ad,4,ae,ai,aj,true);
+}
+function Int16ArrayConstructByLength(ad,ag){
+var al=(ag===(void 0))?
+0:H(ag,180);
+if(al>%_MaxSmi()){
+throw B(180);
+}
+var am=al*2;
+if(am>%_TypedArrayMaxSizeInHeap()){
+var ae=new g(am);
+%_TypedArrayInitialize(ad,4,ae,0,am,true);
+}else{
+%_TypedArrayInitialize(ad,4,null,0,am,true);
+}
+}
+function Int16ArrayConstructByArrayLike(ad,an){
+var ag=an.length;
+var al=H(ag,180);
+if(al>%_MaxSmi()){
+throw B(180);
+}
+var ao=false;
+var am=al*2;
+if(am<=%_TypedArrayMaxSizeInHeap()){
+%_TypedArrayInitialize(ad,4,null,0,am,false);
+}else{
+ao=
+%TypedArrayInitializeFromArrayLike(ad,4,an,al);
+}
+if(!ao){
+for(var ap=0;ap<al;ap++){
+ad[ap]=an[ap];
+}
+}
+}
+function Int16ArrayConstructByIterable(ad,aq,ar){
+var as=new j();
+var at=%_Call(ar,aq);
+var au={
+__proto__:null
+};
+au[I]=function(){return at;}
+for(var av of au){
+as.push(av);
+}
+Int16ArrayConstructByArrayLike(ad,as);
+}
+function Int16ArrayConstructor(X,Y,aw){
+if(!(new.target===(void 0))){
+if((%_ClassOf(X)==='ArrayBuffer')||(%_ClassOf(X)==='SharedArrayBuffer')){
+Int16ArrayConstructByArrayBuffer(this,X,Y,aw);
+}else if((typeof(X)==='number')||(typeof(X)==='string')||
+(typeof(X)==='boolean')||(X===(void 0))){
+Int16ArrayConstructByLength(this,X);
+}else{
+var ar=X[I];
+if((ar===(void 0))||ar===e){
+Int16ArrayConstructByArrayLike(this,X);
+}else{
+Int16ArrayConstructByIterable(this,X,ar);
+}
+}
+}else{
+throw C(26,"Int16Array")
+}
+}
+function Int16Array_GetLength(){
+if(!(%_ClassOf(this)==='Int16Array')){
+throw C(42,"Int16Array.length",this);
+}
+return %_TypedArrayGetLength(this);
+}
+function Int16ArraySubArray(ax,ay){
+var az=(%_ToInteger(ax));
+if(!(ay===(void 0))){
+var aA=(%_ToInteger(ay));
+var aB=%_TypedArrayGetLength(this);
+}else{
+var aB=%_TypedArrayGetLength(this);
+var aA=aB;
+}
+if(az<0){
+az=D(0,aB+az);
+}else{
+az=E(az,aB);
+}
+if(aA<0){
+aA=D(0,aB+aA);
+}else{
+aA=E(aA,aB);
+}
+if(aA<az){
+aA=az;
+}
+var ak=aA-az;
+var aC=
+%_ArrayBufferViewGetByteOffset(this)+az*2;
+return TypedArraySpeciesCreate(this,%TypedArrayGetBuffer(this),
+aC,ak,true);
+}
+
+function Uint32ArrayConstructByArrayBuffer(ad,ae,af,ag){
+if(!(af===(void 0))){
+af=H(af,180);
+}
+if(!(ag===(void 0))){
+ag=H(ag,180);
+}
+var ah=%_ArrayBufferGetByteLength(ae);
+var ai;
+if((af===(void 0))){
+ai=0;
+}else{
+ai=af;
+if(ai % 4!==0){
+throw B(179,
+"start offset","Uint32Array",4);
+}
+if(ai>ah){
+throw B(181);
+}
+}
+var aj;
+var ak;
+if((ag===(void 0))){
+if(ah % 4!==0){
+throw B(179,
+"byte length","Uint32Array",4);
+}
+aj=ah-ai;
+ak=aj/4;
+}else{
+var ak=ag;
+aj=ak*4;
+}
+if((ai+aj>ah)
+||(ak>%_MaxSmi())){
+throw B(180);
+}
+%_TypedArrayInitialize(ad,5,ae,ai,aj,true);
+}
+function Uint32ArrayConstructByLength(ad,ag){
+var al=(ag===(void 0))?
+0:H(ag,180);
+if(al>%_MaxSmi()){
+throw B(180);
+}
+var am=al*4;
+if(am>%_TypedArrayMaxSizeInHeap()){
+var ae=new g(am);
+%_TypedArrayInitialize(ad,5,ae,0,am,true);
+}else{
+%_TypedArrayInitialize(ad,5,null,0,am,true);
+}
+}
+function Uint32ArrayConstructByArrayLike(ad,an){
+var ag=an.length;
+var al=H(ag,180);
+if(al>%_MaxSmi()){
+throw B(180);
+}
+var ao=false;
+var am=al*4;
+if(am<=%_TypedArrayMaxSizeInHeap()){
+%_TypedArrayInitialize(ad,5,null,0,am,false);
+}else{
+ao=
+%TypedArrayInitializeFromArrayLike(ad,5,an,al);
+}
+if(!ao){
+for(var ap=0;ap<al;ap++){
+ad[ap]=an[ap];
+}
+}
+}
+function Uint32ArrayConstructByIterable(ad,aq,ar){
+var as=new j();
+var at=%_Call(ar,aq);
+var au={
+__proto__:null
+};
+au[I]=function(){return at;}
+for(var av of au){
+as.push(av);
+}
+Uint32ArrayConstructByArrayLike(ad,as);
+}
+function Uint32ArrayConstructor(X,Y,aw){
+if(!(new.target===(void 0))){
+if((%_ClassOf(X)==='ArrayBuffer')||(%_ClassOf(X)==='SharedArrayBuffer')){
+Uint32ArrayConstructByArrayBuffer(this,X,Y,aw);
+}else if((typeof(X)==='number')||(typeof(X)==='string')||
+(typeof(X)==='boolean')||(X===(void 0))){
+Uint32ArrayConstructByLength(this,X);
+}else{
+var ar=X[I];
+if((ar===(void 0))||ar===e){
+Uint32ArrayConstructByArrayLike(this,X);
+}else{
+Uint32ArrayConstructByIterable(this,X,ar);
+}
+}
+}else{
+throw C(26,"Uint32Array")
+}
+}
+function Uint32Array_GetLength(){
+if(!(%_ClassOf(this)==='Uint32Array')){
+throw C(42,"Uint32Array.length",this);
+}
+return %_TypedArrayGetLength(this);
+}
+function Uint32ArraySubArray(ax,ay){
+var az=(%_ToInteger(ax));
+if(!(ay===(void 0))){
+var aA=(%_ToInteger(ay));
+var aB=%_TypedArrayGetLength(this);
+}else{
+var aB=%_TypedArrayGetLength(this);
+var aA=aB;
+}
+if(az<0){
+az=D(0,aB+az);
+}else{
+az=E(az,aB);
+}
+if(aA<0){
+aA=D(0,aB+aA);
+}else{
+aA=E(aA,aB);
+}
+if(aA<az){
+aA=az;
+}
+var ak=aA-az;
+var aC=
+%_ArrayBufferViewGetByteOffset(this)+az*4;
+return TypedArraySpeciesCreate(this,%TypedArrayGetBuffer(this),
+aC,ak,true);
+}
+
+function Int32ArrayConstructByArrayBuffer(ad,ae,af,ag){
+if(!(af===(void 0))){
+af=H(af,180);
+}
+if(!(ag===(void 0))){
+ag=H(ag,180);
+}
+var ah=%_ArrayBufferGetByteLength(ae);
+var ai;
+if((af===(void 0))){
+ai=0;
+}else{
+ai=af;
+if(ai % 4!==0){
+throw B(179,
+"start offset","Int32Array",4);
+}
+if(ai>ah){
+throw B(181);
+}
+}
+var aj;
+var ak;
+if((ag===(void 0))){
+if(ah % 4!==0){
+throw B(179,
+"byte length","Int32Array",4);
+}
+aj=ah-ai;
+ak=aj/4;
+}else{
+var ak=ag;
+aj=ak*4;
+}
+if((ai+aj>ah)
+||(ak>%_MaxSmi())){
+throw B(180);
+}
+%_TypedArrayInitialize(ad,6,ae,ai,aj,true);
+}
+function Int32ArrayConstructByLength(ad,ag){
+var al=(ag===(void 0))?
+0:H(ag,180);
+if(al>%_MaxSmi()){
+throw B(180);
+}
+var am=al*4;
+if(am>%_TypedArrayMaxSizeInHeap()){
+var ae=new g(am);
+%_TypedArrayInitialize(ad,6,ae,0,am,true);
+}else{
+%_TypedArrayInitialize(ad,6,null,0,am,true);
+}
+}
+function Int32ArrayConstructByArrayLike(ad,an){
+var ag=an.length;
+var al=H(ag,180);
+if(al>%_MaxSmi()){
+throw B(180);
+}
+var ao=false;
+var am=al*4;
+if(am<=%_TypedArrayMaxSizeInHeap()){
+%_TypedArrayInitialize(ad,6,null,0,am,false);
+}else{
+ao=
+%TypedArrayInitializeFromArrayLike(ad,6,an,al);
+}
+if(!ao){
+for(var ap=0;ap<al;ap++){
+ad[ap]=an[ap];
+}
+}
+}
+function Int32ArrayConstructByIterable(ad,aq,ar){
+var as=new j();
+var at=%_Call(ar,aq);
+var au={
+__proto__:null
+};
+au[I]=function(){return at;}
+for(var av of au){
+as.push(av);
+}
+Int32ArrayConstructByArrayLike(ad,as);
+}
+function Int32ArrayConstructor(X,Y,aw){
+if(!(new.target===(void 0))){
+if((%_ClassOf(X)==='ArrayBuffer')||(%_ClassOf(X)==='SharedArrayBuffer')){
+Int32ArrayConstructByArrayBuffer(this,X,Y,aw);
+}else if((typeof(X)==='number')||(typeof(X)==='string')||
+(typeof(X)==='boolean')||(X===(void 0))){
+Int32ArrayConstructByLength(this,X);
+}else{
+var ar=X[I];
+if((ar===(void 0))||ar===e){
+Int32ArrayConstructByArrayLike(this,X);
+}else{
+Int32ArrayConstructByIterable(this,X,ar);
+}
+}
+}else{
+throw C(26,"Int32Array")
+}
+}
+function Int32Array_GetLength(){
+if(!(%_ClassOf(this)==='Int32Array')){
+throw C(42,"Int32Array.length",this);
+}
+return %_TypedArrayGetLength(this);
+}
+function Int32ArraySubArray(ax,ay){
+var az=(%_ToInteger(ax));
+if(!(ay===(void 0))){
+var aA=(%_ToInteger(ay));
+var aB=%_TypedArrayGetLength(this);
+}else{
+var aB=%_TypedArrayGetLength(this);
+var aA=aB;
+}
+if(az<0){
+az=D(0,aB+az);
+}else{
+az=E(az,aB);
+}
+if(aA<0){
+aA=D(0,aB+aA);
+}else{
+aA=E(aA,aB);
+}
+if(aA<az){
+aA=az;
+}
+var ak=aA-az;
+var aC=
+%_ArrayBufferViewGetByteOffset(this)+az*4;
+return TypedArraySpeciesCreate(this,%TypedArrayGetBuffer(this),
+aC,ak,true);
+}
+
+function Float32ArrayConstructByArrayBuffer(ad,ae,af,ag){
+if(!(af===(void 0))){
+af=H(af,180);
+}
+if(!(ag===(void 0))){
+ag=H(ag,180);
+}
+var ah=%_ArrayBufferGetByteLength(ae);
+var ai;
+if((af===(void 0))){
+ai=0;
+}else{
+ai=af;
+if(ai % 4!==0){
+throw B(179,
+"start offset","Float32Array",4);
+}
+if(ai>ah){
+throw B(181);
+}
+}
+var aj;
+var ak;
+if((ag===(void 0))){
+if(ah % 4!==0){
+throw B(179,
+"byte length","Float32Array",4);
+}
+aj=ah-ai;
+ak=aj/4;
+}else{
+var ak=ag;
+aj=ak*4;
+}
+if((ai+aj>ah)
+||(ak>%_MaxSmi())){
+throw B(180);
+}
+%_TypedArrayInitialize(ad,7,ae,ai,aj,true);
+}
+function Float32ArrayConstructByLength(ad,ag){
+var al=(ag===(void 0))?
+0:H(ag,180);
+if(al>%_MaxSmi()){
+throw B(180);
+}
+var am=al*4;
+if(am>%_TypedArrayMaxSizeInHeap()){
+var ae=new g(am);
+%_TypedArrayInitialize(ad,7,ae,0,am,true);
+}else{
+%_TypedArrayInitialize(ad,7,null,0,am,true);
+}
+}
+function Float32ArrayConstructByArrayLike(ad,an){
+var ag=an.length;
+var al=H(ag,180);
+if(al>%_MaxSmi()){
+throw B(180);
+}
+var ao=false;
+var am=al*4;
+if(am<=%_TypedArrayMaxSizeInHeap()){
+%_TypedArrayInitialize(ad,7,null,0,am,false);
+}else{
+ao=
+%TypedArrayInitializeFromArrayLike(ad,7,an,al);
+}
+if(!ao){
+for(var ap=0;ap<al;ap++){
+ad[ap]=an[ap];
+}
+}
+}
+function Float32ArrayConstructByIterable(ad,aq,ar){
+var as=new j();
+var at=%_Call(ar,aq);
+var au={
+__proto__:null
+};
+au[I]=function(){return at;}
+for(var av of au){
+as.push(av);
+}
+Float32ArrayConstructByArrayLike(ad,as);
+}
+function Float32ArrayConstructor(X,Y,aw){
+if(!(new.target===(void 0))){
+if((%_ClassOf(X)==='ArrayBuffer')||(%_ClassOf(X)==='SharedArrayBuffer')){
+Float32ArrayConstructByArrayBuffer(this,X,Y,aw);
+}else if((typeof(X)==='number')||(typeof(X)==='string')||
+(typeof(X)==='boolean')||(X===(void 0))){
+Float32ArrayConstructByLength(this,X);
+}else{
+var ar=X[I];
+if((ar===(void 0))||ar===e){
+Float32ArrayConstructByArrayLike(this,X);
+}else{
+Float32ArrayConstructByIterable(this,X,ar);
+}
+}
+}else{
+throw C(26,"Float32Array")
+}
+}
+function Float32Array_GetLength(){
+if(!(%_ClassOf(this)==='Float32Array')){
+throw C(42,"Float32Array.length",this);
+}
+return %_TypedArrayGetLength(this);
+}
+function Float32ArraySubArray(ax,ay){
+var az=(%_ToInteger(ax));
+if(!(ay===(void 0))){
+var aA=(%_ToInteger(ay));
+var aB=%_TypedArrayGetLength(this);
+}else{
+var aB=%_TypedArrayGetLength(this);
+var aA=aB;
+}
+if(az<0){
+az=D(0,aB+az);
+}else{
+az=E(az,aB);
+}
+if(aA<0){
+aA=D(0,aB+aA);
+}else{
+aA=E(aA,aB);
+}
+if(aA<az){
+aA=az;
+}
+var ak=aA-az;
+var aC=
+%_ArrayBufferViewGetByteOffset(this)+az*4;
+return TypedArraySpeciesCreate(this,%TypedArrayGetBuffer(this),
+aC,ak,true);
+}
+
+function Float64ArrayConstructByArrayBuffer(ad,ae,af,ag){
+if(!(af===(void 0))){
+af=H(af,180);
+}
+if(!(ag===(void 0))){
+ag=H(ag,180);
+}
+var ah=%_ArrayBufferGetByteLength(ae);
+var ai;
+if((af===(void 0))){
+ai=0;
+}else{
+ai=af;
+if(ai % 8!==0){
+throw B(179,
+"start offset","Float64Array",8);
+}
+if(ai>ah){
+throw B(181);
+}
+}
+var aj;
+var ak;
+if((ag===(void 0))){
+if(ah % 8!==0){
+throw B(179,
+"byte length","Float64Array",8);
+}
+aj=ah-ai;
+ak=aj/8;
+}else{
+var ak=ag;
+aj=ak*8;
+}
+if((ai+aj>ah)
+||(ak>%_MaxSmi())){
+throw B(180);
+}
+%_TypedArrayInitialize(ad,8,ae,ai,aj,true);
+}
+function Float64ArrayConstructByLength(ad,ag){
+var al=(ag===(void 0))?
+0:H(ag,180);
+if(al>%_MaxSmi()){
+throw B(180);
+}
+var am=al*8;
+if(am>%_TypedArrayMaxSizeInHeap()){
+var ae=new g(am);
+%_TypedArrayInitialize(ad,8,ae,0,am,true);
+}else{
+%_TypedArrayInitialize(ad,8,null,0,am,true);
+}
+}
+function Float64ArrayConstructByArrayLike(ad,an){
+var ag=an.length;
+var al=H(ag,180);
+if(al>%_MaxSmi()){
+throw B(180);
+}
+var ao=false;
+var am=al*8;
+if(am<=%_TypedArrayMaxSizeInHeap()){
+%_TypedArrayInitialize(ad,8,null,0,am,false);
+}else{
+ao=
+%TypedArrayInitializeFromArrayLike(ad,8,an,al);
+}
+if(!ao){
+for(var ap=0;ap<al;ap++){
+ad[ap]=an[ap];
+}
+}
+}
+function Float64ArrayConstructByIterable(ad,aq,ar){
+var as=new j();
+var at=%_Call(ar,aq);
+var au={
+__proto__:null
+};
+au[I]=function(){return at;}
+for(var av of au){
+as.push(av);
+}
+Float64ArrayConstructByArrayLike(ad,as);
+}
+function Float64ArrayConstructor(X,Y,aw){
+if(!(new.target===(void 0))){
+if((%_ClassOf(X)==='ArrayBuffer')||(%_ClassOf(X)==='SharedArrayBuffer')){
+Float64ArrayConstructByArrayBuffer(this,X,Y,aw);
+}else if((typeof(X)==='number')||(typeof(X)==='string')||
+(typeof(X)==='boolean')||(X===(void 0))){
+Float64ArrayConstructByLength(this,X);
+}else{
+var ar=X[I];
+if((ar===(void 0))||ar===e){
+Float64ArrayConstructByArrayLike(this,X);
+}else{
+Float64ArrayConstructByIterable(this,X,ar);
+}
+}
+}else{
+throw C(26,"Float64Array")
+}
+}
+function Float64Array_GetLength(){
+if(!(%_ClassOf(this)==='Float64Array')){
+throw C(42,"Float64Array.length",this);
+}
+return %_TypedArrayGetLength(this);
+}
+function Float64ArraySubArray(ax,ay){
+var az=(%_ToInteger(ax));
+if(!(ay===(void 0))){
+var aA=(%_ToInteger(ay));
+var aB=%_TypedArrayGetLength(this);
+}else{
+var aB=%_TypedArrayGetLength(this);
+var aA=aB;
+}
+if(az<0){
+az=D(0,aB+az);
+}else{
+az=E(az,aB);
+}
+if(aA<0){
+aA=D(0,aB+aA);
+}else{
+aA=E(aA,aB);
+}
+if(aA<az){
+aA=az;
+}
+var ak=aA-az;
+var aC=
+%_ArrayBufferViewGetByteOffset(this)+az*8;
+return TypedArraySpeciesCreate(this,%TypedArrayGetBuffer(this),
+aC,ak,true);
+}
+
+function Uint8ClampedArrayConstructByArrayBuffer(ad,ae,af,ag){
+if(!(af===(void 0))){
+af=H(af,180);
+}
+if(!(ag===(void 0))){
+ag=H(ag,180);
+}
+var ah=%_ArrayBufferGetByteLength(ae);
+var ai;
+if((af===(void 0))){
+ai=0;
+}else{
+ai=af;
+if(ai % 1!==0){
+throw B(179,
+"start offset","Uint8ClampedArray",1);
+}
+if(ai>ah){
+throw B(181);
+}
+}
+var aj;
+var ak;
+if((ag===(void 0))){
+if(ah % 1!==0){
+throw B(179,
+"byte length","Uint8ClampedArray",1);
+}
+aj=ah-ai;
+ak=aj/1;
+}else{
+var ak=ag;
+aj=ak*1;
+}
+if((ai+aj>ah)
+||(ak>%_MaxSmi())){
+throw B(180);
+}
+%_TypedArrayInitialize(ad,9,ae,ai,aj,true);
+}
+function Uint8ClampedArrayConstructByLength(ad,ag){
+var al=(ag===(void 0))?
+0:H(ag,180);
+if(al>%_MaxSmi()){
+throw B(180);
+}
+var am=al*1;
+if(am>%_TypedArrayMaxSizeInHeap()){
+var ae=new g(am);
+%_TypedArrayInitialize(ad,9,ae,0,am,true);
+}else{
+%_TypedArrayInitialize(ad,9,null,0,am,true);
+}
+}
+function Uint8ClampedArrayConstructByArrayLike(ad,an){
+var ag=an.length;
+var al=H(ag,180);
+if(al>%_MaxSmi()){
+throw B(180);
+}
+var ao=false;
+var am=al*1;
+if(am<=%_TypedArrayMaxSizeInHeap()){
+%_TypedArrayInitialize(ad,9,null,0,am,false);
+}else{
+ao=
+%TypedArrayInitializeFromArrayLike(ad,9,an,al);
+}
+if(!ao){
+for(var ap=0;ap<al;ap++){
+ad[ap]=an[ap];
+}
+}
+}
+function Uint8ClampedArrayConstructByIterable(ad,aq,ar){
+var as=new j();
+var at=%_Call(ar,aq);
+var au={
+__proto__:null
+};
+au[I]=function(){return at;}
+for(var av of au){
+as.push(av);
+}
+Uint8ClampedArrayConstructByArrayLike(ad,as);
+}
+function Uint8ClampedArrayConstructor(X,Y,aw){
+if(!(new.target===(void 0))){
+if((%_ClassOf(X)==='ArrayBuffer')||(%_ClassOf(X)==='SharedArrayBuffer')){
+Uint8ClampedArrayConstructByArrayBuffer(this,X,Y,aw);
+}else if((typeof(X)==='number')||(typeof(X)==='string')||
+(typeof(X)==='boolean')||(X===(void 0))){
+Uint8ClampedArrayConstructByLength(this,X);
+}else{
+var ar=X[I];
+if((ar===(void 0))||ar===e){
+Uint8ClampedArrayConstructByArrayLike(this,X);
+}else{
+Uint8ClampedArrayConstructByIterable(this,X,ar);
+}
+}
+}else{
+throw C(26,"Uint8ClampedArray")
+}
+}
+function Uint8ClampedArray_GetLength(){
+if(!(%_ClassOf(this)==='Uint8ClampedArray')){
+throw C(42,"Uint8ClampedArray.length",this);
+}
+return %_TypedArrayGetLength(this);
+}
+function Uint8ClampedArraySubArray(ax,ay){
+var az=(%_ToInteger(ax));
+if(!(ay===(void 0))){
+var aA=(%_ToInteger(ay));
+var aB=%_TypedArrayGetLength(this);
+}else{
+var aB=%_TypedArrayGetLength(this);
+var aA=aB;
+}
+if(az<0){
+az=D(0,aB+az);
+}else{
+az=E(az,aB);
+}
+if(aA<0){
+aA=D(0,aB+aA);
+}else{
+aA=E(aA,aB);
+}
+if(aA<az){
+aA=az;
+}
+var ak=aA-az;
+var aC=
+%_ArrayBufferViewGetByteOffset(this)+az*1;
+return TypedArraySpeciesCreate(this,%TypedArrayGetBuffer(this),
+aC,ak,true);
+}
+
+
+function TypedArraySubArray(ax,ay){
+switch(%_ClassOf(this)){
+case"Uint8Array":
+return %_Call(Uint8ArraySubArray,this,ax,ay);
+
+case"Int8Array":
+return %_Call(Int8ArraySubArray,this,ax,ay);
+
+case"Uint16Array":
+return %_Call(Uint16ArraySubArray,this,ax,ay);
+
+case"Int16Array":
+return %_Call(Int16ArraySubArray,this,ax,ay);
+
+case"Uint32Array":
+return %_Call(Uint32ArraySubArray,this,ax,ay);
+
+case"Int32Array":
+return %_Call(Int32ArraySubArray,this,ax,ay);
+
+case"Float32Array":
+return %_Call(Float32ArraySubArray,this,ax,ay);
+
+case"Float64Array":
+return %_Call(Float64ArraySubArray,this,ax,ay);
+
+case"Uint8ClampedArray":
+return %_Call(Uint8ClampedArraySubArray,this,ax,ay);
+
+
+}
+throw C(42,
+"get TypedArray.prototype.subarray",this);
+}
+%SetForceInlineFlag(TypedArraySubArray);
+function TypedArrayGetBuffer(){
+if(!%_IsTypedArray(this)){
+throw C(42,
+"get TypedArray.prototype.buffer",this);
+}
+return %TypedArrayGetBuffer(this);
+}
+%SetForceInlineFlag(TypedArrayGetBuffer);
+function TypedArrayGetByteLength(){
+if(!%_IsTypedArray(this)){
+throw C(42,
+"get TypedArray.prototype.byteLength",this);
+}
+return %_ArrayBufferViewGetByteLength(this);
+}
+%SetForceInlineFlag(TypedArrayGetByteLength);
+function TypedArrayGetByteOffset(){
+if(!%_IsTypedArray(this)){
+throw C(42,
+"get TypedArray.prototype.byteOffset",this);
+}
+return %_ArrayBufferViewGetByteOffset(this);
+}
+%SetForceInlineFlag(TypedArrayGetByteOffset);
+function TypedArrayGetLength(){
+if(!%_IsTypedArray(this)){
+throw C(42,
+"get TypedArray.prototype.length",this);
+}
+return %_TypedArrayGetLength(this);
+}
+%SetForceInlineFlag(TypedArrayGetLength);
+function TypedArraySetFromArrayLike(aD,aE,aF,ai){
+if(ai>0){
+for(var ap=0;ap<aF;ap++){
+aD[ai+ap]=aE[ap];
+}
+}
+else{
+for(var ap=0;ap<aF;ap++){
+aD[ap]=aE[ap];
+}
+}
+}
+function TypedArraySetFromOverlappingTypedArray(aD,aE,ai){
+var aG=aE.BYTES_PER_ELEMENT;
+var aH=aD.BYTES_PER_ELEMENT;
+var aF=aE.length;
+function CopyLeftPart(){
+var aI=aD.byteOffset+(ai+1)*aH;
+var aJ=aE.byteOffset;
+for(var aK=0;
+aK<aF&&aI<=aJ;
+aK++){
+aD[ai+aK]=aE[aK];
+aI+=aH;
+aJ+=aG;
+}
+return aK;
+}
+var aK=CopyLeftPart();
+function CopyRightPart(){
+var aI=
+aD.byteOffset+(ai+aF-1)*aH;
+var aJ=
+aE.byteOffset+aF*aG;
+for(var aL=aF-1;
+aL>=aK&&aI>=aJ;
+aL--){
+aD[ai+aL]=aE[aL];
+aI-=aH;
+aJ-=aG;
+}
+return aL;
+}
+var aL=CopyRightPart();
+var aM=new f(aL+1-aK);
+for(var ap=aK;ap<=aL;ap++){
+aM[ap-aK]=aE[ap];
+}
+for(ap=aK;ap<=aL;ap++){
+aD[ai+ap]=aM[ap-aK];
+}
+}
+function TypedArraySet(ad,ai){
+var aN=(ai===(void 0))?0:(%_ToInteger(ai));
+if(aN<0)throw C(190);
+if(aN>%_MaxSmi()){
+throw B(191);
+}
+switch(%TypedArraySetFastCases(this,ad,aN)){
+case 0:
+return;
+case 1:
+TypedArraySetFromOverlappingTypedArray(this,ad,aN);
+return;
+case 2:
+TypedArraySetFromArrayLike(this,ad,ad.length,aN);
+return;
+case 3:
+var al=ad.length;
+if((al===(void 0))){
+if((typeof(ad)==='number')){
+throw C(45);
+}
+return;
+}
+al=(%_ToLength(al));
+if(aN+al>this.length){
+throw B(191);
+}
+TypedArraySetFromArrayLike(this,ad,al,aN);
+return;
+}
+}
+function TypedArrayGetToStringTag(){
+if(!%_IsTypedArray(this))return;
+var aO=%_ClassOf(this);
+if((aO===(void 0)))return;
+return aO;
+}
+function TypedArrayCopyWithin(aD,aP,ay){
+if(!%_IsTypedArray(this))throw C(68);
+var ag=%_TypedArrayGetLength(this);
+return k(aD,aP,ay,this,ag);
+}
+%FunctionSetLength(TypedArrayCopyWithin,2);
+function TypedArrayEvery(aQ,aR){
+if(!%_IsTypedArray(this))throw C(68);
+var ag=%_TypedArrayGetLength(this);
+return l(aQ,aR,this,ag);
+}
+%FunctionSetLength(TypedArrayEvery,1);
+function TypedArrayForEach(aQ,aR){
+if(!%_IsTypedArray(this))throw C(68);
+var ag=%_TypedArrayGetLength(this);
+q(aQ,aR,this,ag);
+}
+%FunctionSetLength(TypedArrayForEach,1);
+function TypedArrayFill(av,aP,ay){
+if(!%_IsTypedArray(this))throw C(68);
+var ag=%_TypedArrayGetLength(this);
+return m(av,aP,ay,this,ag);
+}
+%FunctionSetLength(TypedArrayFill,1);
+function TypedArrayFilter(aQ,aS){
+if(!%_IsTypedArray(this))throw C(68);
+var ag=%_TypedArrayGetLength(this);
+if(!(typeof(aQ)==='function'))throw C(15,aQ);
+var aT=new j();
+n(aQ,aS,this,ag,aT);
+var aU=aT.length;
+var aV=TypedArraySpeciesCreate(this,aU);
+for(var ap=0;ap<aU;ap++){
+aV[ap]=aT[ap];
+}
+return aV;
+}
+%FunctionSetLength(TypedArrayFilter,1);
+function TypedArrayFind(aW,aS){
+if(!%_IsTypedArray(this))throw C(68);
+var ag=%_TypedArrayGetLength(this);
+return o(aW,aS,this,ag);
+}
+%FunctionSetLength(TypedArrayFind,1);
+function TypedArrayFindIndex(aW,aS){
+if(!%_IsTypedArray(this))throw C(68);
+var ag=%_TypedArrayGetLength(this);
+return p(aW,aS,this,ag);
+}
+%FunctionSetLength(TypedArrayFindIndex,1);
+function TypedArrayReverse(){
+if(!%_IsTypedArray(this))throw C(68);
+var ag=%_TypedArrayGetLength(this);
+return F(this,ag);
+}
+function TypedArrayComparefn(aX,aY){
+if(A(aX)&&A(aY)){
+return A(aY)?0:1;
+}
+if(A(aX)){
+return 1;
+}
+if(aX===0&&aX===aY){
+if(%_IsMinusZero(aX)){
+if(!%_IsMinusZero(aY)){
+return-1;
+}
+}else if(%_IsMinusZero(aY)){
+return 1;
+}
+}
+return aX-aY;
+}
+function TypedArraySort(aZ){
+if(!%_IsTypedArray(this))throw C(68);
+var ag=%_TypedArrayGetLength(this);
+if((aZ===(void 0))){
+aZ=TypedArrayComparefn;
+}
+return y(this,ag,aZ);
+}
+function TypedArrayIndexOf(ba,bb){
+if(!%_IsTypedArray(this))throw C(68);
+var ag=%_TypedArrayGetLength(this);
+return s(this,ba,bb,ag);
+}
+%FunctionSetLength(TypedArrayIndexOf,1);
+function TypedArrayLastIndexOf(ba,bb){
+if(!%_IsTypedArray(this))throw C(68);
+var ag=%_TypedArrayGetLength(this);
+return u(this,ba,bb,ag,
+%_ArgumentsLength());
+}
+%FunctionSetLength(TypedArrayLastIndexOf,1);
+function TypedArrayMap(aQ,aS){
+if(!%_IsTypedArray(this))throw C(68);
+var ag=%_TypedArrayGetLength(this);
+var aT=TypedArraySpeciesCreate(this,ag);
+if(!(typeof(aQ)==='function'))throw C(15,aQ);
+for(var ap=0;ap<ag;ap++){
+var ba=this[ap];
+aT[ap]=%_Call(aQ,aS,ba,ap,this);
+}
+return aT;
+}
+%FunctionSetLength(TypedArrayMap,1);
+function TypedArraySome(aQ,aR){
+if(!%_IsTypedArray(this))throw C(68);
+var ag=%_TypedArrayGetLength(this);
+return x(aQ,aR,this,ag);
+}
+%FunctionSetLength(TypedArraySome,1);
+function TypedArrayToLocaleString(){
+if(!%_IsTypedArray(this))throw C(68);
+var ag=%_TypedArrayGetLength(this);
+return z(this,ag);
+}
+function TypedArrayToString(){
+return %_Call(d,this);
+}
+function TypedArrayJoin(bc){
+if(!%_IsTypedArray(this))throw C(68);
+var ag=%_TypedArrayGetLength(this);
+return t(bc,this,ag);
+}
+function TypedArrayReduce(bd,be){
+if(!%_IsTypedArray(this))throw C(68);
+var ag=%_TypedArrayGetLength(this);
+return v(bd,be,this,ag,
+%_ArgumentsLength());
+}
+%FunctionSetLength(TypedArrayReduce,1);
+function TypedArrayReduceRight(bd,be){
+if(!%_IsTypedArray(this))throw C(68);
+var ag=%_TypedArrayGetLength(this);
+return w(bd,be,this,ag,
+%_ArgumentsLength());
+}
+%FunctionSetLength(TypedArrayReduceRight,1);
+function TypedArraySlice(aP,ay){
+if(!%_IsTypedArray(this))throw C(68);
+var bf=%_TypedArrayGetLength(this);
+var bg=(%_ToInteger(aP));
+var bh;
+if(bg<0){
+bh=D(bf+bg,0);
+}else{
+bh=E(bg,bf);
+}
+var bi;
+if((ay===(void 0))){
+bi=bf;
+}else{
+bi=(%_ToInteger(ay));
+}
+var bj;
+if(bi<0){
+bj=D(bf+bi,0);
+}else{
+bj=E(bi,bf);
+}
+var bk=D(bj-bh,0);
+var bl=TypedArraySpeciesCreate(this,bk);
+var bm=0;
+while(bh<bj){
+var bn=this[bh];
+bl[bm]=bn;
+bh++;
+bm++;
+}
+return bl;
+}
+function TypedArrayIncludes(bo,bp){
+if(!%_IsTypedArray(this))throw C(68);
+var ag=%_TypedArrayGetLength(this);
+return r(bo,bp,this,ag);
+}
+%FunctionSetLength(TypedArrayIncludes,1);
+function TypedArrayOf(){
+var ag=%_ArgumentsLength();
+var bl=TypedArrayCreate(this,ag);
+for(var ap=0;ap<ag;ap++){
+bl[ap]=%_Arguments(ap);
+}
+return bl;
+}
+function TypedArrayFrom(aE,bq,aS){
+var bl=%_Call(c,f,aE,bq,aS);
+return TypedArrayCreate(this,bl);
+}
+%FunctionSetLength(TypedArrayFrom,1);
+function TypedArray(){
+if((new.target===(void 0))){
+throw C(25,"TypedArray");
+}
+if(new.target===TypedArray){
+throw C(23,"TypedArray");
+}
+}
+%FunctionSetPrototype(TypedArray,new i());
+%AddNamedProperty(TypedArray.prototype,
+"constructor",TypedArray,2);
+b.InstallFunctions(TypedArray,2|4|1,[
+"from",TypedArrayFrom,
+"of",TypedArrayOf
+]);
+b.InstallGetter(TypedArray.prototype,"buffer",TypedArrayGetBuffer);
+b.InstallGetter(TypedArray.prototype,"byteOffset",TypedArrayGetByteOffset,
+2|4);
+b.InstallGetter(TypedArray.prototype,"byteLength",
+TypedArrayGetByteLength,2|4);
+b.InstallGetter(TypedArray.prototype,"length",TypedArrayGetLength,
+2|4);
+b.InstallGetter(TypedArray.prototype,J,
+TypedArrayGetToStringTag);
+b.InstallFunctions(TypedArray.prototype,2,[
+"subarray",TypedArraySubArray,
+"set",TypedArraySet,
+"copyWithin",TypedArrayCopyWithin,
+"every",TypedArrayEvery,
+"fill",TypedArrayFill,
+"filter",TypedArrayFilter,
+"find",TypedArrayFind,
+"findIndex",TypedArrayFindIndex,
+"includes",TypedArrayIncludes,
+"indexOf",TypedArrayIndexOf,
+"join",TypedArrayJoin,
+"lastIndexOf",TypedArrayLastIndexOf,
+"forEach",TypedArrayForEach,
+"map",TypedArrayMap,
+"reduce",TypedArrayReduce,
+"reduceRight",TypedArrayReduceRight,
+"reverse",TypedArrayReverse,
+"slice",TypedArraySlice,
+"some",TypedArraySome,
+"sort",TypedArraySort,
+"toString",TypedArrayToString,
+"toLocaleString",TypedArrayToLocaleString
+]);
+%SetCode(K,Uint8ArrayConstructor);
+%FunctionSetPrototype(K,new i());
+%InternalSetPrototype(K,TypedArray);
+%InternalSetPrototype(K.prototype,TypedArray.prototype);
+%AddNamedProperty(K,"BYTES_PER_ELEMENT",1,
+1|2|4);
+%AddNamedProperty(K.prototype,
+"constructor",a.Uint8Array,2);
+%AddNamedProperty(K.prototype,
+"BYTES_PER_ELEMENT",1,
+1|2|4);
+b.InstallGetter(K.prototype,"length",Uint8Array_GetLength,
+2|4);
+
+%SetCode(L,Int8ArrayConstructor);
+%FunctionSetPrototype(L,new i());
+%InternalSetPrototype(L,TypedArray);
+%InternalSetPrototype(L.prototype,TypedArray.prototype);
+%AddNamedProperty(L,"BYTES_PER_ELEMENT",1,
+1|2|4);
+%AddNamedProperty(L.prototype,
+"constructor",a.Int8Array,2);
+%AddNamedProperty(L.prototype,
+"BYTES_PER_ELEMENT",1,
+1|2|4);
+b.InstallGetter(L.prototype,"length",Int8Array_GetLength,
+2|4);
+
+%SetCode(M,Uint16ArrayConstructor);
+%FunctionSetPrototype(M,new i());
+%InternalSetPrototype(M,TypedArray);
+%InternalSetPrototype(M.prototype,TypedArray.prototype);
+%AddNamedProperty(M,"BYTES_PER_ELEMENT",2,
+1|2|4);
+%AddNamedProperty(M.prototype,
+"constructor",a.Uint16Array,2);
+%AddNamedProperty(M.prototype,
+"BYTES_PER_ELEMENT",2,
+1|2|4);
+b.InstallGetter(M.prototype,"length",Uint16Array_GetLength,
+2|4);
+
+%SetCode(N,Int16ArrayConstructor);
+%FunctionSetPrototype(N,new i());
+%InternalSetPrototype(N,TypedArray);
+%InternalSetPrototype(N.prototype,TypedArray.prototype);
+%AddNamedProperty(N,"BYTES_PER_ELEMENT",2,
+1|2|4);
+%AddNamedProperty(N.prototype,
+"constructor",a.Int16Array,2);
+%AddNamedProperty(N.prototype,
+"BYTES_PER_ELEMENT",2,
+1|2|4);
+b.InstallGetter(N.prototype,"length",Int16Array_GetLength,
+2|4);
+
+%SetCode(O,Uint32ArrayConstructor);
+%FunctionSetPrototype(O,new i());
+%InternalSetPrototype(O,TypedArray);
+%InternalSetPrototype(O.prototype,TypedArray.prototype);
+%AddNamedProperty(O,"BYTES_PER_ELEMENT",4,
+1|2|4);
+%AddNamedProperty(O.prototype,
+"constructor",a.Uint32Array,2);
+%AddNamedProperty(O.prototype,
+"BYTES_PER_ELEMENT",4,
+1|2|4);
+b.InstallGetter(O.prototype,"length",Uint32Array_GetLength,
+2|4);
+
+%SetCode(P,Int32ArrayConstructor);
+%FunctionSetPrototype(P,new i());
+%InternalSetPrototype(P,TypedArray);
+%InternalSetPrototype(P.prototype,TypedArray.prototype);
+%AddNamedProperty(P,"BYTES_PER_ELEMENT",4,
+1|2|4);
+%AddNamedProperty(P.prototype,
+"constructor",a.Int32Array,2);
+%AddNamedProperty(P.prototype,
+"BYTES_PER_ELEMENT",4,
+1|2|4);
+b.InstallGetter(P.prototype,"length",Int32Array_GetLength,
+2|4);
+
+%SetCode(Q,Float32ArrayConstructor);
+%FunctionSetPrototype(Q,new i());
+%InternalSetPrototype(Q,TypedArray);
+%InternalSetPrototype(Q.prototype,TypedArray.prototype);
+%AddNamedProperty(Q,"BYTES_PER_ELEMENT",4,
+1|2|4);
+%AddNamedProperty(Q.prototype,
+"constructor",a.Float32Array,2);
+%AddNamedProperty(Q.prototype,
+"BYTES_PER_ELEMENT",4,
+1|2|4);
+b.InstallGetter(Q.prototype,"length",Float32Array_GetLength,
+2|4);
+
+%SetCode(R,Float64ArrayConstructor);
+%FunctionSetPrototype(R,new i());
+%InternalSetPrototype(R,TypedArray);
+%InternalSetPrototype(R.prototype,TypedArray.prototype);
+%AddNamedProperty(R,"BYTES_PER_ELEMENT",8,
+1|2|4);
+%AddNamedProperty(R.prototype,
+"constructor",a.Float64Array,2);
+%AddNamedProperty(R.prototype,
+"BYTES_PER_ELEMENT",8,
+1|2|4);
+b.InstallGetter(R.prototype,"length",Float64Array_GetLength,
+2|4);
+
+%SetCode(S,Uint8ClampedArrayConstructor);
+%FunctionSetPrototype(S,new i());
+%InternalSetPrototype(S,TypedArray);
+%InternalSetPrototype(S.prototype,TypedArray.prototype);
+%AddNamedProperty(S,"BYTES_PER_ELEMENT",1,
+1|2|4);
+%AddNamedProperty(S.prototype,
+"constructor",a.Uint8ClampedArray,2);
+%AddNamedProperty(S.prototype,
+"BYTES_PER_ELEMENT",1,
+1|2|4);
+b.InstallGetter(S.prototype,"length",Uint8ClampedArray_GetLength,
+2|4);
+
+
+function DataViewConstructor(ae,af,am){
+if((new.target===(void 0))){
+throw C(26,"DataView");
+}
+if(!(%_ClassOf(ae)==='ArrayBuffer'))throw C(29);
+if(!(af===(void 0))){
+af=H(af,172);
+}
+if(!(am===(void 0))){
+am=(%_ToInteger(am));
+}
+var ah=%_ArrayBufferGetByteLength(ae);
+var ai=(af===(void 0))?0:af;
+if(ai>ah)throw B(172);
+var ag=(am===(void 0))
+?ah-ai
+:am;
+if(ag<0||ai+ag>ah){
+throw new B(171);
+}
+var aT=%NewObject(h,new.target);
+%_DataViewInitialize(aT,ae,ai,ag);
+return aT;
+}
+function DataViewGetBufferJS(){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,'DataView.buffer',this);
+}
+return %DataViewGetBuffer(this);
+}
+function DataViewGetByteOffset(){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.byteOffset',this);
+}
+return %_ArrayBufferViewGetByteOffset(this);
+}
+function DataViewGetByteLength(){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.byteLength',this);
+}
+return %_ArrayBufferViewGetByteLength(this);
+}
+function DataViewGetInt8JS(ai,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.getInt8',this);
+}
+if(%_ArgumentsLength()<1)throw C(45);
+ai=H(ai,170);
+return %DataViewGetInt8(this,ai,!!br);
+}
+function DataViewSetInt8JS(ai,av,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.setInt8',this);
+}
+if(%_ArgumentsLength()<2)throw C(45);
+ai=H(ai,170);
+%DataViewSetInt8(this,ai,(%_ToNumber(av)),!!br);
+}
+
+function DataViewGetUint8JS(ai,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.getUint8',this);
+}
+if(%_ArgumentsLength()<1)throw C(45);
+ai=H(ai,170);
+return %DataViewGetUint8(this,ai,!!br);
+}
+function DataViewSetUint8JS(ai,av,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.setUint8',this);
+}
+if(%_ArgumentsLength()<2)throw C(45);
+ai=H(ai,170);
+%DataViewSetUint8(this,ai,(%_ToNumber(av)),!!br);
+}
+
+function DataViewGetInt16JS(ai,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.getInt16',this);
+}
+if(%_ArgumentsLength()<1)throw C(45);
+ai=H(ai,170);
+return %DataViewGetInt16(this,ai,!!br);
+}
+function DataViewSetInt16JS(ai,av,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.setInt16',this);
+}
+if(%_ArgumentsLength()<2)throw C(45);
+ai=H(ai,170);
+%DataViewSetInt16(this,ai,(%_ToNumber(av)),!!br);
+}
+
+function DataViewGetUint16JS(ai,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.getUint16',this);
+}
+if(%_ArgumentsLength()<1)throw C(45);
+ai=H(ai,170);
+return %DataViewGetUint16(this,ai,!!br);
+}
+function DataViewSetUint16JS(ai,av,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.setUint16',this);
+}
+if(%_ArgumentsLength()<2)throw C(45);
+ai=H(ai,170);
+%DataViewSetUint16(this,ai,(%_ToNumber(av)),!!br);
+}
+
+function DataViewGetInt32JS(ai,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.getInt32',this);
+}
+if(%_ArgumentsLength()<1)throw C(45);
+ai=H(ai,170);
+return %DataViewGetInt32(this,ai,!!br);
+}
+function DataViewSetInt32JS(ai,av,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.setInt32',this);
+}
+if(%_ArgumentsLength()<2)throw C(45);
+ai=H(ai,170);
+%DataViewSetInt32(this,ai,(%_ToNumber(av)),!!br);
+}
+
+function DataViewGetUint32JS(ai,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.getUint32',this);
+}
+if(%_ArgumentsLength()<1)throw C(45);
+ai=H(ai,170);
+return %DataViewGetUint32(this,ai,!!br);
+}
+function DataViewSetUint32JS(ai,av,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.setUint32',this);
+}
+if(%_ArgumentsLength()<2)throw C(45);
+ai=H(ai,170);
+%DataViewSetUint32(this,ai,(%_ToNumber(av)),!!br);
+}
+
+function DataViewGetFloat32JS(ai,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.getFloat32',this);
+}
+if(%_ArgumentsLength()<1)throw C(45);
+ai=H(ai,170);
+return %DataViewGetFloat32(this,ai,!!br);
+}
+function DataViewSetFloat32JS(ai,av,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.setFloat32',this);
+}
+if(%_ArgumentsLength()<2)throw C(45);
+ai=H(ai,170);
+%DataViewSetFloat32(this,ai,(%_ToNumber(av)),!!br);
+}
+
+function DataViewGetFloat64JS(ai,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.getFloat64',this);
+}
+if(%_ArgumentsLength()<1)throw C(45);
+ai=H(ai,170);
+return %DataViewGetFloat64(this,ai,!!br);
+}
+function DataViewSetFloat64JS(ai,av,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.setFloat64',this);
+}
+if(%_ArgumentsLength()<2)throw C(45);
+ai=H(ai,170);
+%DataViewSetFloat64(this,ai,(%_ToNumber(av)),!!br);
+}
+
+
+%SetCode(h,DataViewConstructor);
+%FunctionSetPrototype(h,new i);
+%AddNamedProperty(h.prototype,"constructor",h,
+2);
+%AddNamedProperty(h.prototype,J,"DataView",
+1|2);
+b.InstallGetter(h.prototype,"buffer",DataViewGetBufferJS);
+b.InstallGetter(h.prototype,"byteOffset",
+DataViewGetByteOffset);
+b.InstallGetter(h.prototype,"byteLength",
+DataViewGetByteLength);
+b.InstallFunctions(h.prototype,2,[
+"getInt8",DataViewGetInt8JS,
+"setInt8",DataViewSetInt8JS,
+"getUint8",DataViewGetUint8JS,
+"setUint8",DataViewSetUint8JS,
+"getInt16",DataViewGetInt16JS,
+"setInt16",DataViewSetInt16JS,
+"getUint16",DataViewGetUint16JS,
+"setUint16",DataViewSetUint16JS,
+"getInt32",DataViewGetInt32JS,
+"setInt32",DataViewSetInt32JS,
+"getUint32",DataViewGetUint32JS,
+"setUint32",DataViewSetUint32JS,
+"getFloat32",DataViewGetFloat32JS,
+"setFloat32",DataViewSetFloat32JS,
+"getFloat64",DataViewGetFloat64JS,
+"setFloat64",DataViewSetFloat64JS
+]);
+})
+
+Hiterator-prototype�
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Object;
+var d=b.ImportNow("IteratorPrototype");
+var e=b.ImportNow("iterator_symbol");
+function IteratorPrototypeIterator(){
+return this;
+}
+b.SetFunctionName(IteratorPrototypeIterator,e);
+%AddNamedProperty(d,e,
+IteratorPrototypeIterator,2);
+})
+
+$generator�
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=b.ImportNow("GeneratorFunctionPrototype");
+var d=b.ImportNow("GeneratorFunction");
+var e=a.Function;
+var f;
+var g=b.ImportNow("to_string_tag_symbol");
+b.Import(function(h){
+f=h.MakeTypeError;
+});
+function GeneratorObjectNext(i){
+if(!(%_ClassOf(this)==='Generator')){
+throw f(42,
+'[Generator].prototype.next',this);
+}
+var j=%GeneratorGetContinuation(this);
+if(j>0){
+if(%_DebugIsActive()!=0)%DebugPrepareStepInIfStepping(this);
+try{
+return %_GeneratorNext(this,i);
+}catch(e){
+%GeneratorClose(this);
+throw e;
+}
+}else if(j==0){
+return{value:void 0,done:true};
+}else{
+throw f(40);
+}
+}
+function GeneratorObjectThrow(k){
+if(!(%_ClassOf(this)==='Generator')){
+throw f(42,
+'[Generator].prototype.throw',this);
+}
+var j=%GeneratorGetContinuation(this);
+if(j>0){
+try{
+return %_GeneratorThrow(this,k);
+}catch(e){
+%GeneratorClose(this);
+throw e;
+}
+}else if(j==0){
+throw k;
+}else{
+throw f(40);
+}
+}
+%NeverOptimizeFunction(GeneratorObjectNext);
+%NeverOptimizeFunction(GeneratorObjectThrow);
+var l=c.prototype;
+b.InstallFunctions(l,
+2,
+["next",GeneratorObjectNext,
+"throw",GeneratorObjectThrow]);
+%AddNamedProperty(l,"constructor",
+c,2|1);
+%AddNamedProperty(l,
+g,"Generator",2|1);
+%InternalSetPrototype(c,e.prototype);
+%AddNamedProperty(c,
+g,"GeneratorFunction",2|1);
+%AddNamedProperty(c,"constructor",
+d,2|1);
+%InternalSetPrototype(d,e);
+})
+
+8object-observeѭ
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c;
+var d=a.Array;
+var e=a.Object;
+var f=b.InternalArray;
+var g;
+b.Import(function(h){
+c=h.GetHash;
+g=h.MakeTypeError;
+});
+var i;
+var j={};
+function GetObservationStateJS(){
+if((i===(void 0))){
+i=%GetObservationState();
+}
+if((i.callbackInfoMap===(void 0))){
+i.callbackInfoMap=%ObservationWeakMapCreate();
+i.objectInfoMap=%ObservationWeakMapCreate();
+i.notifierObjectInfoMap=%ObservationWeakMapCreate();
+i.pendingObservers=null;
+i.nextCallbackPriority=0;
+i.lastMicrotaskId=0;
+}
+return i;
+}
+function GetPendingObservers(){
+return GetObservationStateJS().pendingObservers;
+}
+function SetPendingObservers(k){
+GetObservationStateJS().pendingObservers=k;
+}
+function GetNextCallbackPriority(){
+return GetObservationStateJS().nextCallbackPriority++;
+}
+function nullProtoObject(){
+return{__proto__:null};
+}
+function TypeMapCreate(){
+return nullProtoObject();
+}
+function TypeMapAddType(l,m,n){
+l[m]=n?1:(l[m]||0)+1;
+}
+function TypeMapRemoveType(l,m){
+l[m]--;
+}
+function TypeMapCreateFromList(o,p){
+var l=TypeMapCreate();
+for(var q=0;q<p;q++){
+TypeMapAddType(l,o[q],true);
+}
+return l;
+}
+function TypeMapHasType(l,m){
+return!!l[m];
+}
+function TypeMapIsDisjointFrom(r,s){
+if(!r||!s)
+return true;
+for(var m in r){
+if(TypeMapHasType(r,m)&&TypeMapHasType(s,m))
+return false;
+}
+return true;
+}
+var t=(function(){
+var u=[
+'add',
+'update',
+'delete',
+'setPrototype',
+'reconfigure',
+'preventExtensions'
+];
+return TypeMapCreateFromList(u,u.length);
+})();
+function ObserverCreate(v,w){
+if((w===(void 0)))
+return v;
+var x=nullProtoObject();
+x.callback=v;
+x.accept=w;
+return x;
+}
+function ObserverGetCallback(x){
+return(typeof(x)==='function')?x:x.callback;
+}
+function ObserverGetAcceptTypes(x){
+return(typeof(x)==='function')?t:x.accept;
+}
+function ObserverIsActive(x,y){
+return TypeMapIsDisjointFrom(ObjectInfoGetPerformingTypes(y),
+ObserverGetAcceptTypes(x));
+}
+function ObjectInfoGetOrCreate(z){
+var y=ObjectInfoGet(z);
+if((y===(void 0))){
+if(!(%_IsJSProxy(z))){
+%SetIsObserved(z);
+}
+y={
+object:z,
+changeObservers:null,
+notifier:null,
+performing:null,
+performingCount:0,
+};
+%WeakCollectionSet(GetObservationStateJS().objectInfoMap,
+z,y,c(z));
+}
+return y;
+}
+function ObjectInfoGet(z){
+return %WeakCollectionGet(GetObservationStateJS().objectInfoMap,z,
+c(z));
+}
+function ObjectInfoGetFromNotifier(A){
+return %WeakCollectionGet(GetObservationStateJS().notifierObjectInfoMap,
+A,c(A));
+}
+function ObjectInfoGetNotifier(y){
+if((y.notifier===null)){
+var A={__proto__:j};
+y.notifier=A;
+%WeakCollectionSet(GetObservationStateJS().notifierObjectInfoMap,
+A,y,c(A));
+}
+return y.notifier;
+}
+function ChangeObserversIsOptimized(B){
+return(typeof(B)==='function')||
+(typeof(B.callback)==='function');
+}
+function ObjectInfoNormalizeChangeObservers(y){
+if(ChangeObserversIsOptimized(y.changeObservers)){
+var x=y.changeObservers;
+var v=ObserverGetCallback(x);
+var C=CallbackInfoGet(v);
+var D=CallbackInfoGetPriority(C);
+y.changeObservers=nullProtoObject();
+y.changeObservers[D]=x;
+}
+}
+function ObjectInfoAddObserver(y,v,w){
+var C=CallbackInfoGetOrCreate(v);
+var x=ObserverCreate(v,w);
+if(!y.changeObservers){
+y.changeObservers=x;
+return;
+}
+ObjectInfoNormalizeChangeObservers(y);
+var D=CallbackInfoGetPriority(C);
+y.changeObservers[D]=x;
+}
+function ObjectInfoRemoveObserver(y,v){
+if(!y.changeObservers)
+return;
+if(ChangeObserversIsOptimized(y.changeObservers)){
+if(v===ObserverGetCallback(y.changeObservers))
+y.changeObservers=null;
+return;
+}
+var C=CallbackInfoGet(v);
+var D=CallbackInfoGetPriority(C);
+y.changeObservers[D]=null;
+}
+function ObjectInfoHasActiveObservers(y){
+if((y===(void 0))||!y.changeObservers)
+return false;
+if(ChangeObserversIsOptimized(y.changeObservers))
+return ObserverIsActive(y.changeObservers,y);
+for(var D in y.changeObservers){
+var x=y.changeObservers[D];
+if(!(x===null)&&ObserverIsActive(x,y))
+return true;
+}
+return false;
+}
+function ObjectInfoAddPerformingType(y,m){
+y.performing=y.performing||TypeMapCreate();
+TypeMapAddType(y.performing,m);
+y.performingCount++;
+}
+function ObjectInfoRemovePerformingType(y,m){
+y.performingCount--;
+TypeMapRemoveType(y.performing,m);
+}
+function ObjectInfoGetPerformingTypes(y){
+return y.performingCount>0?y.performing:null;
+}
+function ConvertAcceptListToTypeMap(E){
+if((E===(void 0)))
+return E;
+if(!(%_IsJSReceiver(E)))throw g(80);
+var F=(%_ToInteger(E.length));
+if(F<0)F=0;
+return TypeMapCreateFromList(E,F);
+}
+function CallbackInfoGet(v){
+return %WeakCollectionGet(GetObservationStateJS().callbackInfoMap,v,
+c(v));
+}
+function CallbackInfoSet(v,C){
+%WeakCollectionSet(GetObservationStateJS().callbackInfoMap,
+v,C,c(v));
+}
+function CallbackInfoGetOrCreate(v){
+var C=CallbackInfoGet(v);
+if(!(C===(void 0)))
+return C;
+var D=GetNextCallbackPriority();
+CallbackInfoSet(v,D);
+return D;
+}
+function CallbackInfoGetPriority(C){
+if((typeof(C)==='number'))
+return C;
+else
+return C.priority;
+}
+function CallbackInfoNormalize(v){
+var C=CallbackInfoGet(v);
+if((typeof(C)==='number')){
+var D=C;
+C=new f;
+C.priority=D;
+CallbackInfoSet(v,C);
+}
+return C;
+}
+function ObjectObserve(z,v,w){
+if(!(%_IsJSReceiver(z)))
+throw g(82,"observe","observe");
+if(%IsJSGlobalProxy(z))
+throw g(78,"observe");
+if(%IsAccessCheckNeeded(z))
+throw g(79,"observe");
+if(!(typeof(v)==='function'))
+throw g(81,"observe");
+if(%object_is_frozen(v))
+throw g(77);
+var G=%GetObjectContextObjectObserve(z);
+return G(z,v,w);
+}
+function NativeObjectObserve(z,v,w){
+var y=ObjectInfoGetOrCreate(z);
+var o=ConvertAcceptListToTypeMap(w);
+ObjectInfoAddObserver(y,v,o);
+return z;
+}
+function ObjectUnobserve(z,v){
+if(!(%_IsJSReceiver(z)))
+throw g(82,"unobserve","unobserve");
+if(%IsJSGlobalProxy(z))
+throw g(78,"unobserve");
+if(!(typeof(v)==='function'))
+throw g(81,"unobserve");
+var y=ObjectInfoGet(z);
+if((y===(void 0)))
+return z;
+ObjectInfoRemoveObserver(y,v);
+return z;
+}
+function ArrayObserve(z,v){
+return ObjectObserve(z,v,['add',
+'update',
+'delete',
+'splice']);
+}
+function ArrayUnobserve(z,v){
+return ObjectUnobserve(z,v);
+}
+function ObserverEnqueueIfActive(x,y,H){
+if(!ObserverIsActive(x,y)||
+!TypeMapHasType(ObserverGetAcceptTypes(x),H.type)){
+return;
+}
+var v=ObserverGetCallback(x);
+if(!%ObserverObjectAndRecordHaveSameOrigin(v,H.object,
+H)){
+return;
+}
+var C=CallbackInfoNormalize(v);
+if((GetPendingObservers()===null)){
+SetPendingObservers(nullProtoObject());
+if((%_DebugIsActive()!=0)){
+var I=++GetObservationStateJS().lastMicrotaskId;
+var J="Object.observe";
+%EnqueueMicrotask(function(){
+%DebugAsyncTaskEvent({type:"willHandle",id:I,name:J});
+ObserveMicrotaskRunner();
+%DebugAsyncTaskEvent({type:"didHandle",id:I,name:J});
+});
+%DebugAsyncTaskEvent({type:"enqueue",id:I,name:J});
+}else{
+%EnqueueMicrotask(ObserveMicrotaskRunner);
+}
+}
+GetPendingObservers()[C.priority]=v;
+C.push(H);
+}
+function ObjectInfoEnqueueExternalChangeRecord(y,H,m){
+if(!ObjectInfoHasActiveObservers(y))
+return;
+var K=!(m===(void 0));
+var L=K?
+{object:y.object,type:m}:
+{object:y.object};
+for(var M in H){
+if(M==='object'||(K&&M==='type'))continue;
+%DefineDataPropertyUnchecked(
+L,M,H[M],1+4);
+}
+%object_freeze(L);
+ObjectInfoEnqueueInternalChangeRecord(y,L);
+}
+function ObjectInfoEnqueueInternalChangeRecord(y,H){
+if((typeof(H.name)==='symbol'))return;
+if(ChangeObserversIsOptimized(y.changeObservers)){
+var x=y.changeObservers;
+ObserverEnqueueIfActive(x,y,H);
+return;
+}
+for(var D in y.changeObservers){
+var x=y.changeObservers[D];
+if((x===null))
+continue;
+ObserverEnqueueIfActive(x,y,H);
+}
+}
+function BeginPerformSplice(N){
+var y=ObjectInfoGet(N);
+if(!(y===(void 0)))
+ObjectInfoAddPerformingType(y,'splice');
+}
+function EndPerformSplice(N){
+var y=ObjectInfoGet(N);
+if(!(y===(void 0)))
+ObjectInfoRemovePerformingType(y,'splice');
+}
+function EnqueueSpliceRecord(N,O,P,Q){
+var y=ObjectInfoGet(N);
+if(!ObjectInfoHasActiveObservers(y))
+return;
+var H={
+type:'splice',
+object:N,
+index:O,
+removed:P,
+addedCount:Q
+};
+%object_freeze(H);
+%object_freeze(H.removed);
+ObjectInfoEnqueueInternalChangeRecord(y,H);
+}
+function NotifyChange(m,z,J,R){
+var y=ObjectInfoGet(z);
+if(!ObjectInfoHasActiveObservers(y))
+return;
+var H;
+if(arguments.length==2){
+H={type:m,object:z};
+}else if(arguments.length==3){
+H={type:m,object:z,name:J};
+}else{
+H={
+type:m,
+object:z,
+name:J,
+oldValue:R
+};
+}
+%object_freeze(H);
+ObjectInfoEnqueueInternalChangeRecord(y,H);
+}
+function ObjectNotifierNotify(H){
+if(!(%_IsJSReceiver(this)))
+throw g(16,"notify");
+var y=ObjectInfoGetFromNotifier(this);
+if((y===(void 0)))
+throw g(83);
+if(!(typeof(H.type)==='string'))
+throw g(86);
+ObjectInfoEnqueueExternalChangeRecord(y,H);
+}
+function ObjectNotifierPerformChange(S,T){
+if(!(%_IsJSReceiver(this)))
+throw g(16,"performChange");
+var y=ObjectInfoGetFromNotifier(this);
+if((y===(void 0)))
+throw g(83);
+if(!(typeof(S)==='string'))
+throw g(85);
+if(!(typeof(T)==='function'))
+throw g(84);
+var U=%GetObjectContextNotifierPerformChange(y);
+U(y,S,T);
+}
+function NativeObjectNotifierPerformChange(y,S,T){
+ObjectInfoAddPerformingType(y,S);
+var H;
+try{
+H=T();
+}finally{
+ObjectInfoRemovePerformingType(y,S);
+}
+if((%_IsJSReceiver(H)))
+ObjectInfoEnqueueExternalChangeRecord(y,H,S);
+}
+function ObjectGetNotifier(z){
+if(!(%_IsJSReceiver(z)))
+throw g(82,"getNotifier","getNotifier");
+if(%IsJSGlobalProxy(z))
+throw g(78,"getNotifier");
+if(%IsAccessCheckNeeded(z))
+throw g(79,"getNotifier");
+if(%object_is_frozen(z))return null;
+if(!%ObjectWasCreatedInCurrentOrigin(z))return null;
+var V=%GetObjectContextObjectGetNotifier(z);
+return V(z);
+}
+function NativeObjectGetNotifier(z){
+var y=ObjectInfoGetOrCreate(z);
+return ObjectInfoGetNotifier(y);
+}
+function CallbackDeliverPending(v){
+var C=CallbackInfoGet(v);
+if((C===(void 0))||(typeof(C)==='number'))
+return false;
+var D=C.priority;
+CallbackInfoSet(v,D);
+var k=GetPendingObservers();
+if(!(k===null))
+delete k[D];
+var W=[];
+%MoveArrayContents(C,W);
+%DeliverObservationChangeRecords(v,W);
+return true;
+}
+function ObjectDeliverChangeRecords(v){
+if(!(typeof(v)==='function'))
+throw g(81,"deliverChangeRecords");
+while(CallbackDeliverPending(v)){}
+}
+function ObserveMicrotaskRunner(){
+var k=GetPendingObservers();
+if(!(k===null)){
+SetPendingObservers(null);
+for(var q in k){
+CallbackDeliverPending(k[q]);
+}
+}
+}
+b.InstallFunctions(j,2,[
+"notify",ObjectNotifierNotify,
+"performChange",ObjectNotifierPerformChange
+]);
+var X=[
+"deliverChangeRecords",ObjectDeliverChangeRecords,
+"getNotifier",ObjectGetNotifier,
+"observe",ObjectObserve,
+"unobserve",ObjectUnobserve
+];
+var Y=[
+"observe",ArrayObserve,
+"unobserve",ArrayUnobserve
+];
+var Z=function(aa,q){
+if(q % 2===1)%FunctionRemovePrototype(aa);
+};
+X.forEach(Z);
+Y.forEach(Z);
+%InstallToContext([
+"native_object_get_notifier",NativeObjectGetNotifier,
+"native_object_notifier_perform_change",NativeObjectNotifierPerformChange,
+"native_object_observe",NativeObjectObserve,
+"observers_begin_perform_splice",BeginPerformSplice,
+"observers_end_perform_splice",EndPerformSplice,
+"observers_enqueue_splice",EnqueueSpliceRecord,
+"observers_notify_change",NotifyChange,
+]);
+b.Export(function(ab){
+ab.ObserveArrayMethods=Y;
+ab.ObserveBeginPerformSplice=BeginPerformSplice;
+ab.ObserveEndPerformSplice=EndPerformSplice;
+ab.ObserveEnqueueSpliceRecord=EnqueueSpliceRecord;
+ab.ObserveObjectMethods=X;
+});
+})
+
+(collectionE}
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Map;
+var d=a.Object;
+var e=a.Set;
+var f=b.ImportNow("hash_code_symbol");
+var g;
+var h;
+var i;
+var j;
+var k;
+var l=b.ImportNow("to_string_tag_symbol");
+b.Import(function(m){
+g=m.IntRandom;
+h=m.MakeTypeError;
+i=m.MapIterator;
+j=m.NumberIsNaN;
+k=m.SetIterator;
+});
+function HashToEntry(n,o,p){
+var q=(o&((p)-1));
+return((%_FixedArrayGet(n,(3+(q))|0)));
+}
+%SetForceInlineFlag(HashToEntry);
+function SetFindEntry(n,p,r,o){
+var s=HashToEntry(n,o,p);
+if(s===-1)return s;
+var t=((%_FixedArrayGet(n,((3+(p)+((s)<<1)))|0)));
+if(r===t)return s;
+var u=j(r);
+while(true){
+if(u&&j(t)){
+return s;
+}
+s=((%_FixedArrayGet(n,((3+(p)+((s)<<1))+1)|0)));
+if(s===-1)return s;
+t=((%_FixedArrayGet(n,((3+(p)+((s)<<1)))|0)));
+if(r===t)return s;
+}
+return-1;
+}
+%SetForceInlineFlag(SetFindEntry);
+function MapFindEntry(n,p,r,o){
+var s=HashToEntry(n,o,p);
+if(s===-1)return s;
+var t=((%_FixedArrayGet(n,((3+(p)+((s)*3)))|0)));
+if(r===t)return s;
+var u=j(r);
+while(true){
+if(u&&j(t)){
+return s;
+}
+s=((%_FixedArrayGet(n,((3+(p)+((s)*3))+2)|0)));
+if(s===-1)return s;
+t=((%_FixedArrayGet(n,((3+(p)+((s)*3)))|0)));
+if(r===t)return s;
+}
+return-1;
+}
+%SetForceInlineFlag(MapFindEntry);
+function ComputeIntegerHash(r,v){
+var o=r;
+o=o^v;
+o=~o+(o<<15);
+o=o^(o>>>12);
+o=o+(o<<2);
+o=o^(o>>>4);
+o=(o*2057)|0;
+o=o^(o>>>16);
+return o&0x3fffffff;
+}
+%SetForceInlineFlag(ComputeIntegerHash);
+function GetExistingHash(r){
+if(%_IsSmi(r)){
+return ComputeIntegerHash(r,0);
+}
+if((typeof(r)==='string')){
+var w=%_StringGetRawHashField(r);
+if((w&1)===0){
+return w>>>2;
+}
+}else if((%_IsJSReceiver(r))&&!(%_IsJSProxy(r))&&!(%_ClassOf(r)==='global')){
+var o=(r[f]);
+return o;
+}
+return %GenericHash(r);
+}
+%SetForceInlineFlag(GetExistingHash);
+function GetHash(r){
+var o=GetExistingHash(r);
+if((o===(void 0))){
+o=g()|0;
+if(o===0)o=1;
+(r[f]=o);
+}
+return o;
+}
+%SetForceInlineFlag(GetHash);
+function SetConstructor(x){
+if((new.target===(void 0))){
+throw h(26,"Set");
+}
+%_SetInitialize(this);
+if(!(x==null)){
+var y=this.add;
+if(!(typeof(y)==='function')){
+throw h(91,y,'add',this);
+}
+for(var z of x){
+%_Call(y,this,z);
+}
+}
+}
+function SetAdd(r){
+if(!(%_ClassOf(this)==='Set')){
+throw h(42,'Set.prototype.add',this);
+}
+if(r===0){
+r=0;
+}
+var n=%_JSCollectionGetTable(this);
+var p=((%_FixedArrayGet(n,(0)|0)));
+var o=GetHash(r);
+if(SetFindEntry(n,p,r,o)!==-1)return this;
+var A=((%_FixedArrayGet(n,(1)|0)));
+var B=((%_FixedArrayGet(n,(2)|0)));
+var C=p<<1;
+if((A+B)>=C){
+%SetGrow(this);
+n=%_JSCollectionGetTable(this);
+p=((%_FixedArrayGet(n,(0)|0)));
+A=((%_FixedArrayGet(n,(1)|0)));
+B=((%_FixedArrayGet(n,(2)|0)));
+}
+var s=A+B;
+var D=(3+(p)+((s)<<1));
+var q=(o&((p)-1));
+var E=((%_FixedArrayGet(n,(3+(q))|0)));
+((%_FixedArraySet(n,(3+(q))|0,s)));
+(((%_FixedArraySet(n,(1)|0,(A+1)|0))));
+(%_FixedArraySet(n,(D)|0,r));
+((%_FixedArraySet(n,(D+1)|0,(E)|0)));
+return this;
+}
+function SetHas(r){
+if(!(%_ClassOf(this)==='Set')){
+throw h(42,'Set.prototype.has',this);
+}
+var n=%_JSCollectionGetTable(this);
+var p=((%_FixedArrayGet(n,(0)|0)));
+var o=GetExistingHash(r);
+if((o===(void 0)))return false;
+return SetFindEntry(n,p,r,o)!==-1;
+}
+function SetDelete(r){
+if(!(%_ClassOf(this)==='Set')){
+throw h(42,
+'Set.prototype.delete',this);
+}
+var n=%_JSCollectionGetTable(this);
+var p=((%_FixedArrayGet(n,(0)|0)));
+var o=GetExistingHash(r);
+if((o===(void 0)))return false;
+var s=SetFindEntry(n,p,r,o);
+if(s===-1)return false;
+var A=((%_FixedArrayGet(n,(1)|0)))-1;
+var B=((%_FixedArrayGet(n,(2)|0)))+1;
+var D=(3+(p)+((s)<<1));
+(%_FixedArraySet(n,(D)|0,%_TheHole()));
+(((%_FixedArraySet(n,(1)|0,(A)|0))));
+(((%_FixedArraySet(n,(2)|0,(B)|0))));
+if(A<(p>>>1))%SetShrink(this);
+return true;
+}
+function SetGetSize(){
+if(!(%_ClassOf(this)==='Set')){
+throw h(42,
+'Set.prototype.size',this);
+}
+var n=%_JSCollectionGetTable(this);
+return((%_FixedArrayGet(n,(1)|0)));
+}
+function SetClearJS(){
+if(!(%_ClassOf(this)==='Set')){
+throw h(42,
+'Set.prototype.clear',this);
+}
+%_SetClear(this);
+}
+function SetForEach(F,G){
+if(!(%_ClassOf(this)==='Set')){
+throw h(42,
+'Set.prototype.forEach',this);
+}
+if(!(typeof(F)==='function'))throw h(15,F);
+var H=new k(this,2);
+var r;
+var I=[(void 0)];
+while(%SetIteratorNext(H,I)){
+r=I[0];
+%_Call(F,G,r,r,this);
+}
+}
+%SetCode(e,SetConstructor);
+%FunctionSetLength(e,0);
+%FunctionSetPrototype(e,new d());
+%AddNamedProperty(e.prototype,"constructor",e,2);
+%AddNamedProperty(e.prototype,l,"Set",
+2|1);
+%FunctionSetLength(SetForEach,1);
+b.InstallGetter(e.prototype,"size",SetGetSize);
+b.InstallFunctions(e.prototype,2,[
+"add",SetAdd,
+"has",SetHas,
+"delete",SetDelete,
+"clear",SetClearJS,
+"forEach",SetForEach
+]);
+function MapConstructor(x){
+if((new.target===(void 0))){
+throw h(26,"Map");
+}
+%_MapInitialize(this);
+if(!(x==null)){
+var y=this.set;
+if(!(typeof(y)==='function')){
+throw h(91,y,'set',this);
+}
+for(var J of x){
+if(!(%_IsJSReceiver(J))){
+throw h(49,J);
+}
+%_Call(y,this,J[0],J[1]);
+}
+}
+}
+function MapGet(r){
+if(!(%_ClassOf(this)==='Map')){
+throw h(42,
+'Map.prototype.get',this);
+}
+var n=%_JSCollectionGetTable(this);
+var p=((%_FixedArrayGet(n,(0)|0)));
+var o=GetExistingHash(r);
+if((o===(void 0)))return(void 0);
+var s=MapFindEntry(n,p,r,o);
+if(s===-1)return(void 0);
+return((%_FixedArrayGet(n,((3+(p)+((s)*3))+1)|0)));
+}
+function MapSet(r,z){
+if(!(%_ClassOf(this)==='Map')){
+throw h(42,
+'Map.prototype.set',this);
+}
+if(r===0){
+r=0;
+}
+var n=%_JSCollectionGetTable(this);
+var p=((%_FixedArrayGet(n,(0)|0)));
+var o=GetHash(r);
+var s=MapFindEntry(n,p,r,o);
+if(s!==-1){
+var K=(3+(p)+((s)*3));
+(%_FixedArraySet(n,(K+1)|0,z));
+return this;
+}
+var A=((%_FixedArrayGet(n,(1)|0)));
+var B=((%_FixedArrayGet(n,(2)|0)));
+var C=p<<1;
+if((A+B)>=C){
+%MapGrow(this);
+n=%_JSCollectionGetTable(this);
+p=((%_FixedArrayGet(n,(0)|0)));
+A=((%_FixedArrayGet(n,(1)|0)));
+B=((%_FixedArrayGet(n,(2)|0)));
+}
+s=A+B;
+var D=(3+(p)+((s)*3));
+var q=(o&((p)-1));
+var E=((%_FixedArrayGet(n,(3+(q))|0)));
+((%_FixedArraySet(n,(3+(q))|0,s)));
+(((%_FixedArraySet(n,(1)|0,(A+1)|0))));
+(%_FixedArraySet(n,(D)|0,r));
+(%_FixedArraySet(n,(D+1)|0,z));
+(%_FixedArraySet(n,(D+2)|0,E));
+return this;
+}
+function MapHas(r){
+if(!(%_ClassOf(this)==='Map')){
+throw h(42,
+'Map.prototype.has',this);
+}
+var n=%_JSCollectionGetTable(this);
+var p=((%_FixedArrayGet(n,(0)|0)));
+var o=GetHash(r);
+return MapFindEntry(n,p,r,o)!==-1;
+}
+function MapDelete(r){
+if(!(%_ClassOf(this)==='Map')){
+throw h(42,
+'Map.prototype.delete',this);
+}
+var n=%_JSCollectionGetTable(this);
+var p=((%_FixedArrayGet(n,(0)|0)));
+var o=GetHash(r);
+var s=MapFindEntry(n,p,r,o);
+if(s===-1)return false;
+var A=((%_FixedArrayGet(n,(1)|0)))-1;
+var B=((%_FixedArrayGet(n,(2)|0)))+1;
+var D=(3+(p)+((s)*3));
+(%_FixedArraySet(n,(D)|0,%_TheHole()));
+(%_FixedArraySet(n,(D+1)|0,%_TheHole()));
+(((%_FixedArraySet(n,(1)|0,(A)|0))));
+(((%_FixedArraySet(n,(2)|0,(B)|0))));
+if(A<(p>>>1))%MapShrink(this);
+return true;
+}
+function MapGetSize(){
+if(!(%_ClassOf(this)==='Map')){
+throw h(42,
+'Map.prototype.size',this);
+}
+var n=%_JSCollectionGetTable(this);
+return((%_FixedArrayGet(n,(1)|0)));
+}
+function MapClearJS(){
+if(!(%_ClassOf(this)==='Map')){
+throw h(42,
+'Map.prototype.clear',this);
+}
+%_MapClear(this);
+}
+function MapForEach(F,G){
+if(!(%_ClassOf(this)==='Map')){
+throw h(42,
+'Map.prototype.forEach',this);
+}
+if(!(typeof(F)==='function'))throw h(15,F);
+var H=new i(this,3);
+var I=[(void 0),(void 0)];
+while(%MapIteratorNext(H,I)){
+%_Call(F,G,I[1],I[0],this);
+}
+}
+%SetCode(c,MapConstructor);
+%FunctionSetLength(c,0);
+%FunctionSetPrototype(c,new d());
+%AddNamedProperty(c.prototype,"constructor",c,2);
+%AddNamedProperty(
+c.prototype,l,"Map",2|1);
+%FunctionSetLength(MapForEach,1);
+b.InstallGetter(c.prototype,"size",MapGetSize);
+b.InstallFunctions(c.prototype,2,[
+"get",MapGet,
+"set",MapSet,
+"has",MapHas,
+"delete",MapDelete,
+"clear",MapClearJS,
+"forEach",MapForEach
+]);
+%InstallToContext([
+"map_get",MapGet,
+"map_set",MapSet,
+"map_has",MapHas,
+"map_delete",MapDelete,
+"set_add",SetAdd,
+"set_has",SetHas,
+"set_delete",SetDelete,
+]);
+b.Export(function(L){
+L.GetExistingHash=GetExistingHash;
+L.GetHash=GetHash;
+});
+})
+
+<weak-collection�-
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c;
+var d;
+var e=a.Object;
+var f=a.WeakMap;
+var g=a.WeakSet;
+var h;
+var i=b.ImportNow("to_string_tag_symbol");
+b.Import(function(j){
+c=j.GetExistingHash;
+d=j.GetHash;
+h=j.MakeTypeError;
+});
+function WeakMapConstructor(k){
+if((new.target===(void 0))){
+throw h(26,"WeakMap");
+}
+%WeakCollectionInitialize(this);
+if(!(k==null)){
+var l=this.set;
+if(!(typeof(l)==='function')){
+throw h(91,l,'set',this);
+}
+for(var m of k){
+if(!(%_IsJSReceiver(m))){
+throw h(49,m);
+}
+%_Call(l,this,m[0],m[1]);
+}
+}
+}
+function WeakMapGet(n){
+if(!(%_ClassOf(this)==='WeakMap')){
+throw h(42,
+'WeakMap.prototype.get',this);
+}
+if(!(%_IsJSReceiver(n)))return(void 0);
+var o=c(n);
+if((o===(void 0)))return(void 0);
+return %WeakCollectionGet(this,n,o);
+}
+function WeakMapSet(n,p){
+if(!(%_ClassOf(this)==='WeakMap')){
+throw h(42,
+'WeakMap.prototype.set',this);
+}
+if(!(%_IsJSReceiver(n)))throw h(175);
+return %WeakCollectionSet(this,n,p,d(n));
+}
+function WeakMapHas(n){
+if(!(%_ClassOf(this)==='WeakMap')){
+throw h(42,
+'WeakMap.prototype.has',this);
+}
+if(!(%_IsJSReceiver(n)))return false;
+var o=c(n);
+if((o===(void 0)))return false;
+return %WeakCollectionHas(this,n,o);
+}
+function WeakMapDelete(n){
+if(!(%_ClassOf(this)==='WeakMap')){
+throw h(42,
+'WeakMap.prototype.delete',this);
+}
+if(!(%_IsJSReceiver(n)))return false;
+var o=c(n);
+if((o===(void 0)))return false;
+return %WeakCollectionDelete(this,n,o);
+}
+%SetCode(f,WeakMapConstructor);
+%FunctionSetLength(f,0);
+%FunctionSetPrototype(f,new e());
+%AddNamedProperty(f.prototype,"constructor",f,
+2);
+%AddNamedProperty(f.prototype,i,"WeakMap",
+2|1);
+b.InstallFunctions(f.prototype,2,[
+"get",WeakMapGet,
+"set",WeakMapSet,
+"has",WeakMapHas,
+"delete",WeakMapDelete
+]);
+function WeakSetConstructor(k){
+if((new.target===(void 0))){
+throw h(26,"WeakSet");
+}
+%WeakCollectionInitialize(this);
+if(!(k==null)){
+var l=this.add;
+if(!(typeof(l)==='function')){
+throw h(91,l,'add',this);
+}
+for(var p of k){
+%_Call(l,this,p);
+}
+}
+}
+function WeakSetAdd(p){
+if(!(%_ClassOf(this)==='WeakSet')){
+throw h(42,
+'WeakSet.prototype.add',this);
+}
+if(!(%_IsJSReceiver(p)))throw h(176);
+return %WeakCollectionSet(this,p,true,d(p));
+}
+function WeakSetHas(p){
+if(!(%_ClassOf(this)==='WeakSet')){
+throw h(42,
+'WeakSet.prototype.has',this);
+}
+if(!(%_IsJSReceiver(p)))return false;
+var o=c(p);
+if((o===(void 0)))return false;
+return %WeakCollectionHas(this,p,o);
+}
+function WeakSetDelete(p){
+if(!(%_ClassOf(this)==='WeakSet')){
+throw h(42,
+'WeakSet.prototype.delete',this);
+}
+if(!(%_IsJSReceiver(p)))return false;
+var o=c(p);
+if((o===(void 0)))return false;
+return %WeakCollectionDelete(this,p,o);
+}
+%SetCode(g,WeakSetConstructor);
+%FunctionSetLength(g,0);
+%FunctionSetPrototype(g,new e());
+%AddNamedProperty(g.prototype,"constructor",g,
+2);
+%AddNamedProperty(g.prototype,i,"WeakSet",
+2|1);
+b.InstallFunctions(g.prototype,2,[
+"add",WeakSetAdd,
+"has",WeakSetHas,
+"delete",WeakSetDelete
+]);
+})
+
+Lcollection-iterator(
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Map;
+var d=a.Set;
+var e=b.ImportNow("iterator_symbol");
+var f;
+var g=b.ImportNow("MapIterator");
+var h=b.ImportNow("to_string_tag_symbol");
+var i=b.ImportNow("SetIterator");
+b.Import(function(j){
+f=j.MakeTypeError;
+});
+function SetIteratorConstructor(k,l){
+%SetIteratorInitialize(this,k,l);
+}
+function SetIteratorNextJS(){
+if(!(%_ClassOf(this)==='Set Iterator')){
+throw f(42,
+'Set Iterator.prototype.next',this);
+}
+var m=[(void 0),(void 0)];
+var n=%_CreateIterResultObject(m,false);
+switch(%SetIteratorNext(this,m)){
+case 0:
+n.value=(void 0);
+n.done=true;
+break;
+case 2:
+n.value=m[0];
+break;
+case 3:
+m[1]=m[0];
+break;
+}
+return n;
+}
+function SetEntries(){
+if(!(%_ClassOf(this)==='Set')){
+throw f(42,
+'Set.prototype.entries',this);
+}
+return new i(this,3);
+}
+function SetValues(){
+if(!(%_ClassOf(this)==='Set')){
+throw f(42,
+'Set.prototype.values',this);
+}
+return new i(this,2);
+}
+%SetCode(i,SetIteratorConstructor);
+%FunctionSetInstanceClassName(i,'Set Iterator');
+b.InstallFunctions(i.prototype,2,[
+'next',SetIteratorNextJS
+]);
+%AddNamedProperty(i.prototype,h,
+"Set Iterator",1|2);
+b.InstallFunctions(d.prototype,2,[
+'entries',SetEntries,
+'keys',SetValues,
+'values',SetValues
+]);
+%AddNamedProperty(d.prototype,e,SetValues,2);
+function MapIteratorConstructor(o,l){
+%MapIteratorInitialize(this,o,l);
+}
+function MapIteratorNextJS(){
+if(!(%_ClassOf(this)==='Map Iterator')){
+throw f(42,
+'Map Iterator.prototype.next',this);
+}
+var m=[(void 0),(void 0)];
+var n=%_CreateIterResultObject(m,false);
+switch(%MapIteratorNext(this,m)){
+case 0:
+n.value=(void 0);
+n.done=true;
+break;
+case 1:
+n.value=m[0];
+break;
+case 2:
+n.value=m[1];
+break;
+}
+return n;
+}
+function MapEntries(){
+if(!(%_ClassOf(this)==='Map')){
+throw f(42,
+'Map.prototype.entries',this);
+}
+return new g(this,3);
+}
+function MapKeys(){
+if(!(%_ClassOf(this)==='Map')){
+throw f(42,
+'Map.prototype.keys',this);
+}
+return new g(this,1);
+}
+function MapValues(){
+if(!(%_ClassOf(this)==='Map')){
+throw f(42,
+'Map.prototype.values',this);
+}
+return new g(this,2);
+}
+%SetCode(g,MapIteratorConstructor);
+%FunctionSetInstanceClassName(g,'Map Iterator');
+b.InstallFunctions(g.prototype,2,[
+'next',MapIteratorNextJS
+]);
+%AddNamedProperty(g.prototype,h,
+"Map Iterator",1|2);
+b.InstallFunctions(c.prototype,2,[
+'entries',MapEntries,
+'keys',MapKeys,
+'values',MapValues
+]);
+%AddNamedProperty(c.prototype,e,MapEntries,2);
+b.Export(function(p){
+p.MapEntries=MapEntries;
+p.MapIteratorNext=MapIteratorNextJS;
+p.SetIteratorNext=SetIteratorNextJS;
+p.SetValues=SetValues;
+});
+})
+
+promiseQs
+(function(a,b,c){
+"use strict";
+%CheckIsBootstrapping();
+var d=b.InternalArray;
+var e;
+var f=
+b.ImportNow("promise_combined_deferred_symbol");
+var g=
+b.ImportNow("promise_has_handler_symbol");
+var h=b.ImportNow("promise_on_reject_symbol");
+var i=
+b.ImportNow("promise_on_resolve_symbol");
+var j=b.ImportNow("promise_raw_symbol");
+var k=b.ImportNow("promise_status_symbol");
+var l=b.ImportNow("promise_value_symbol");
+var m;
+var n=b.ImportNow("to_string_tag_symbol");
+b.Import(function(o){
+e=o.MakeTypeError;
+m=o.SpeciesConstructor;
+});
+var p=0;
+function CreateResolvingFunctions(q){
+var r=false;
+var s=value=>{
+if(r===true)return;
+r=true;
+PromiseResolve(q,value);
+};
+var t=reason=>{
+if(r===true)return;
+r=true;
+PromiseReject(q,reason);
+};
+return{
+__proto__:null,
+resolve:s,
+reject:t
+};
+}
+var u=function Promise(v){
+if(v===j){
+return %NewObject(u,new.target);
+}
+if((new.target===(void 0)))throw e(61,this);
+if(!(typeof(v)==='function'))
+throw e(134,v);
+var q=PromiseInit(%NewObject(u,new.target));
+var w=CreateResolvingFunctions(q);
+try{
+%DebugPushPromise(q,Promise);
+v(w.resolve,w.reject);
+}catch(e){
+%_Call(w.reject,(void 0),e);
+}finally{
+%DebugPopPromise();
+}
+return q;
+}
+function PromiseSet(q,x,y,z,A){
+(q[k]=x);
+(q[l]=y);
+(q[i]=z);
+(q[h]=A);
+if((%_DebugIsActive()!=0)){
+%DebugPromiseEvent({promise:q,status:x,value:y});
+}
+return q;
+}
+function PromiseCreateAndSet(x,y){
+var q=new u(j);
+if((%_DebugIsActive()!=0))PromiseSet(q,0,(void 0));
+return PromiseSet(q,x,y);
+}
+function PromiseInit(q){
+return PromiseSet(
+q,0,(void 0),new d,new d)
+}
+function PromiseDone(q,x,y,B){
+if((q[k])===0){
+var C=(q[B]);
+if(C.length)PromiseEnqueue(y,C,x);
+PromiseSet(q,x,y);
+}
+}
+function PromiseHandle(y,D,E){
+try{
+%DebugPushPromise(E.promise,PromiseHandle);
+var F=D(y);
+E.resolve(F);
+}catch(exception){
+try{E.reject(exception);}catch(e){}
+}finally{
+%DebugPopPromise();
+}
+}
+function PromiseEnqueue(y,C,x){
+var G,H,I=(%_DebugIsActive()!=0);
+%EnqueueMicrotask(function(){
+if(I){
+%DebugAsyncTaskEvent({type:"willHandle",id:G,name:H});
+}
+for(var J=0;J<C.length;J+=2){
+PromiseHandle(y,C[J],C[J+1])
+}
+if(I){
+%DebugAsyncTaskEvent({type:"didHandle",id:G,name:H});
+}
+});
+if(I){
+G=++p;
+H=x>0?"Promise.resolve":"Promise.reject";
+%DebugAsyncTaskEvent({type:"enqueue",id:G,name:H});
+}
+}
+function PromiseIdResolveHandler(K){return K}
+function PromiseIdRejectHandler(L){throw L}
+function PromiseNopResolver(){}
+function IsPromise(K){
+return(%_IsJSReceiver(K))&&(!(K[k]===(void 0)));
+}
+function PromiseCreate(){
+return new u(PromiseNopResolver)
+}
+function PromiseResolve(q,K){
+if(K===q){
+return PromiseReject(q,e(88,K));
+}
+if((%_IsJSReceiver(K))){
+try{
+var M=K.then;
+}catch(e){
+return PromiseReject(q,e);
+}
+if((typeof(M)==='function')){
+var G,H,I=(%_DebugIsActive()!=0);
+%EnqueueMicrotask(function(){
+if(I){
+%DebugAsyncTaskEvent({type:"willHandle",id:G,name:H});
+}
+var w=CreateResolvingFunctions(q);
+try{
+%_Call(M,K,w.resolve,w.reject);
+}catch(e){
+%_Call(w.reject,(void 0),e);
+}
+if(I){
+%DebugAsyncTaskEvent({type:"didHandle",id:G,name:H});
+}
+});
+if(I){
+G=++p;
+H="PromseResolveThenableJob";
+%DebugAsyncTaskEvent({type:"enqueue",id:G,name:H});
+}
+return;
+}
+}
+PromiseDone(q,+1,K,i);
+}
+function PromiseReject(q,L){
+if((q[k])==0){
+var N=(%_DebugIsActive()!=0);
+if(N||
+!(!(q[g]===(void 0)))){
+%PromiseRejectEvent(q,L,N);
+}
+}
+PromiseDone(q,-1,L,h)
+}
+function NewPromiseCapability(O){
+if(O===u){
+var q=PromiseInit(new u(j));
+var w=CreateResolvingFunctions(q);
+return{
+promise:q,
+resolve:w.resolve,
+reject:w.reject
+};
+}
+var F={promise:(void 0),resolve:(void 0),reject:(void 0)};
+F.promise=new O((s,t)=>{
+if(!(F.resolve===(void 0))||!(F.reject===(void 0)))
+throw e(89);
+F.resolve=s;
+F.reject=t;
+});
+return F;
+}
+function PromiseDeferred(){
+%IncrementUseCounter(19);
+return NewPromiseCapability(this);
+}
+function PromiseResolved(K){
+%IncrementUseCounter(18);
+return %_Call(PromiseCast,this,K);
+}
+function PromiseRejected(L){
+if(!(%_IsJSReceiver(this))){
+throw e(16,PromiseRejected);
+}
+if(this===u){
+var q=PromiseCreateAndSet(-1,L);
+%PromiseRejectEvent(q,L,false);
+return q;
+}else{
+var P=NewPromiseCapability(this);
+%_Call(P.reject,(void 0),L);
+return P.promise;
+}
+}
+function PromiseThen(z,A){
+var x=(this[k]);
+if((x===(void 0))){
+throw e(61,this);
+}
+var Q=m(this,u);
+z=(typeof(z)==='function')?z:PromiseIdResolveHandler;
+A=(typeof(A)==='function')?A:PromiseIdRejectHandler;
+var E=NewPromiseCapability(Q);
+switch(x){
+case 0:
+(this[i]).push(z,E);
+(this[h]).push(A,E);
+break;
+case+1:
+PromiseEnqueue((this[l]),
+[z,E],
++1);
+break;
+case-1:
+if(!(!(this[g]===(void 0)))){
+%PromiseRevokeReject(this);
+}
+PromiseEnqueue((this[l]),
+[A,E],
+-1);
+break;
+}
+(this[g]=true);
+if((%_DebugIsActive()!=0)){
+%DebugPromiseEvent({promise:E.promise,parentPromise:this});
+}
+return E.promise;
+}
+function PromiseChain(z,A){
+%IncrementUseCounter(17);
+return %_Call(PromiseThen,this,z,A);
+}
+function PromiseCatch(A){
+return this.then((void 0),A);
+}
+function PromiseCast(K){
+if(!(%_IsJSReceiver(this))){
+throw e(16,PromiseCast);
+}
+if(IsPromise(K)&&K.constructor===this)return K;
+var P=NewPromiseCapability(this);
+var R=%_Call(P.resolve,(void 0),K);
+return P.promise;
+}
+function PromiseAll(S){
+if(!(%_IsJSReceiver(this))){
+throw e(16,"Promise.all");
+}
+var E=NewPromiseCapability(this);
+var T=new d();
+var U;
+function CreateResolveElementFunction(V,W,P){
+var X=false;
+return(K)=>{
+if(X===true)return;
+X=true;
+W[V]=K;
+if(--U===0){
+var Y=[];
+%MoveArrayContents(W,Y);
+%_Call(P.resolve,(void 0),Y);
+}
+};
+}
+try{
+var J=0;
+U=1;
+for(var y of S){
+var Z=this.resolve(y);
+++U;
+Z.then(
+CreateResolveElementFunction(J,T,E),
+E.reject);
+(E.reject[f]=E);
+++J;
+}
+if(--U===0){
+var Y=[];
+%MoveArrayContents(T,Y);
+%_Call(E.resolve,(void 0),Y);
+}
+}catch(e){
+%_Call(E.reject,(void 0),e);
+}
+return E.promise;
+}
+function PromiseRace(S){
+if(!(%_IsJSReceiver(this))){
+throw e(16,PromiseRace);
+}
+var E=NewPromiseCapability(this);
+try{
+for(var y of S){
+this.resolve(y).then(E.resolve,E.reject);
+(E.reject[f]=E);
+}
+}catch(e){
+E.reject(e)
+}
+return E.promise;
+}
+function PromiseHasUserDefinedRejectHandlerRecursive(q){
+var aa=(q[h]);
+if((aa===(void 0)))return false;
+for(var J=0;J<aa.length;J+=2){
+var D=aa[J];
+if(D!==PromiseIdRejectHandler){
+var E=(D[f]);
+if((E===(void 0)))return true;
+if(PromiseHasUserDefinedRejectHandlerRecursive(E.promise)){
+return true;
+}
+}else if(PromiseHasUserDefinedRejectHandlerRecursive(
+aa[J+1].promise)){
+return true;
+}
+}
+return false;
+}
+function PromiseHasUserDefinedRejectHandler(){
+return PromiseHasUserDefinedRejectHandlerRecursive(this);
+};
+%AddNamedProperty(a,'Promise',u,2);
+%AddNamedProperty(u.prototype,n,"Promise",
+2|1);
+b.InstallFunctions(u,2,[
+"reject",PromiseRejected,
+"all",PromiseAll,
+"race",PromiseRace,
+"resolve",PromiseCast
+]);
+b.InstallFunctions(u.prototype,2,[
+"then",PromiseThen,
+"catch",PromiseCatch
+]);
+%InstallToContext([
+"promise_catch",PromiseCatch,
+"promise_chain",PromiseChain,
+"promise_create",PromiseCreate,
+"promise_has_user_defined_reject_handler",PromiseHasUserDefinedRejectHandler,
+"promise_reject",PromiseReject,
+"promise_resolve",PromiseResolve,
+"promise_then",PromiseThen,
+]);
+b.InstallFunctions(c,0,[
+"createPromise",PromiseCreate,
+"resolvePromise",PromiseResolve,
+"rejectPromise",PromiseReject
+]);
+[PromiseChain,PromiseDeferred,PromiseResolved].forEach(
+fn=>%FunctionRemovePrototype(fn));
+b.Export(function(ab){
+ab.PromiseChain=PromiseChain;
+ab.PromiseDeferred=PromiseDeferred;
+ab.PromiseResolved=PromiseResolved;
+});
+})
+
+ messages��
+(function(a,b){
+%CheckIsBootstrapping();
+var c;
+var d;
+var e;
+var f;
+var g=
+b.ImportNow("call_site_receiver_symbol");
+var h=
+b.ImportNow("call_site_function_symbol");
+var i=
+b.ImportNow("call_site_position_symbol");
+var j=
+b.ImportNow("call_site_strict_symbol");
+var k;
+var l;
+var m=
+b.ImportNow("formatted_stack_trace_symbol");
+var n=a.Object;
+var o;
+var p;
+var q;
+var r=b.InternalArray;
+var s=b.ImportNow("internal_error_symbol");
+var t;
+var u=b.ImportNow("object_to_string");
+var v=b.ImportNow("Script");
+var w=b.ImportNow("stack_trace_symbol");
+var x;
+var y;
+var z;
+var A;
+var B=b.ImportNow("to_string_tag_symbol");
+var C;
+var D;
+var E;
+b.Import(function(F){
+c=F.ArrayJoin;
+d=F.Bool16x8ToString;
+e=F.Bool32x4ToString;
+f=F.Bool8x16ToString;
+l=F.Float32x4ToString;
+o=F.Int16x8ToString;
+p=F.Int32x4ToString;
+q=F.Int8x16ToString;
+t=F.ObjectDefineProperty;
+x=F.StringCharAt;
+y=F.StringIndexOf;
+z=F.StringSubstring;
+A=F.SymbolToString;
+C=F.Uint16x8ToString;
+D=F.Uint32x4ToString;
+E=F.Uint8x16ToString;
+});
+b.ImportFromExperimental(function(F){
+k=F.FLAG_harmony_tostring;
+});
+var G;
+var H;
+var I;
+var J;
+var K;
+var L;
+var M;
+function NoSideEffectsObjectToString(){
+if((this===(void 0)))return"[object Undefined]";
+if((this===null))return"[object Null]";
+var N=(%_ToObject(this));
+var O=%_ClassOf(N);
+var P;
+if(k){
+P=%GetDataProperty(N,B);
+if(!(typeof(P)==='string')){
+P=O;
+}
+}else{
+P=O;
+}
+return`[object ${P}]`;
+}
+function IsErrorObject(Q){
+return(%HasOwnProperty(Q,w));
+}
+function NoSideEffectsErrorToString(){
+var R=%GetDataProperty(this,"name");
+var S=%GetDataProperty(this,"message");
+R=(R===(void 0))?"Error":NoSideEffectsToString(R);
+S=(S===(void 0))?"":NoSideEffectsToString(S);
+if(R=="")return S;
+if(S=="")return R;
+return`${R}: ${S}`;
+}
+function NoSideEffectsToString(Q){
+if((typeof(Q)==='string'))return Q;
+if((typeof(Q)==='number'))return %_NumberToString(Q);
+if((typeof(Q)==='boolean'))return Q?'true':'false';
+if((Q===(void 0)))return'undefined';
+if((Q===null))return'null';
+if((%_IsFunction(Q))){
+var T=%FunctionToString(Q);
+if(T.length>128){
+T=%_SubString(T,0,111)+"...<omitted>..."+
+%_SubString(T,T.length-2,T.length);
+}
+return T;
+}
+if((typeof(Q)==='symbol'))return %_Call(A,Q);
+if((%_IsSimdValue(Q))){
+switch(typeof(Q)){
+case'float32x4':return %_Call(l,Q);
+case'int32x4':return %_Call(p,Q);
+case'int16x8':return %_Call(o,Q);
+case'int8x16':return %_Call(q,Q);
+case'uint32x4':return %_Call(D,Q);
+case'uint16x8':return %_Call(C,Q);
+case'uint8x16':return %_Call(E,Q);
+case'bool32x4':return %_Call(e,Q);
+case'bool16x8':return %_Call(d,Q);
+case'bool8x16':return %_Call(f,Q);
+}
+}
+if((%_IsJSReceiver(Q))){
+if(IsErrorObject(Q)||
+%GetDataProperty(Q,"toString")===ErrorToString){
+return %_Call(NoSideEffectsErrorToString,Q);
+}
+if(%GetDataProperty(Q,"toString")===u){
+var U=%GetDataProperty(Q,"constructor");
+if((%_IsFunction(U))){
+var V=%FunctionGetName(U);
+if(V!="")return`#<${V}>`;
+}
+}
+}
+return %_Call(NoSideEffectsObjectToString,Q);
+}
+function MakeGenericError(U,W,X,Y,Z){
+var aa=new U(FormatMessage(W,X,Y,Z));
+aa[s]=true;
+return aa;
+}
+%FunctionSetInstanceClassName(v,'Script');
+%AddNamedProperty(v.prototype,'constructor',v,
+2|4|1);
+%SetCode(v,function(ab){
+throw MakeError(6);
+});
+function FormatMessage(W,X,Y,Z){
+var X=NoSideEffectsToString(X);
+var Y=NoSideEffectsToString(Y);
+var Z=NoSideEffectsToString(Z);
+try{
+return %FormatMessageString(W,X,Y,Z);
+}catch(e){
+return"<error>";
+}
+}
+function GetLineNumber(S){
+var ac=%MessageGetStartPosition(S);
+if(ac==-1)return 0;
+var ad=%MessageGetScript(S);
+var ae=ad.locationFromPosition(ac,true);
+if(ae==null)return 0;
+return ae.line+1;
+}
+function GetColumnNumber(S){
+var ad=%MessageGetScript(S);
+var ac=%MessageGetStartPosition(S);
+var ae=ad.locationFromPosition(ac,true);
+if(ae==null)return-1;
+return ae.column;
+}
+function GetSourceLine(S){
+var ad=%MessageGetScript(S);
+var ac=%MessageGetStartPosition(S);
+var ae=ad.locationFromPosition(ac,true);
+if(ae==null)return"";
+return ae.sourceText();
+}
+function ScriptLineFromPosition(af){
+var ag=0;
+var ah=this.lineCount()-1;
+var ai=this.line_ends;
+if(af>ai[ah]){
+return-1;
+}
+if(af<=ai[0]){
+return 0;
+}
+while(ah>=1){
+var aj=(ag+ah)>>1;
+if(af>ai[aj]){
+ag=aj+1;
+}else if(af<=ai[aj-1]){
+ah=aj-1;
+}else{
+return aj;
+}
+}
+return-1;
+}
+function ScriptLocationFromPosition(af,
+include_resource_offset){
+var ak=this.lineFromPosition(af);
+if(ak==-1)return null;
+var ai=this.line_ends;
+var al=ak==0?0:ai[ak-1]+1;
+var am=ai[ak];
+if(am>0&&%_Call(x,this.source,am-1)=='\r'){
+am--;
+}
+var an=af-al;
+if(include_resource_offset){
+ak+=this.line_offset;
+if(ak==this.line_offset){
+an+=this.column_offset;
+}
+}
+return new SourceLocation(this,af,ak,an,al,am);
+}
+function ScriptLocationFromLine(ao,ap,aq){
+var ak=0;
+if(!(ao===(void 0))){
+ak=ao-this.line_offset;
+}
+var an=ap||0;
+if(ak==0){
+an-=this.column_offset;
+}
+var ar=aq||0;
+if(ak<0||an<0||ar<0)return null;
+if(ak==0){
+return this.locationFromPosition(ar+an,false);
+}else{
+var as=this.lineFromPosition(ar);
+if(as==-1||as+ak>=this.lineCount()){
+return null;
+}
+return this.locationFromPosition(
+this.line_ends[as+ak-1]+1+an);
+}
+}
+function ScriptSourceSlice(at,au){
+var av=(at===(void 0))?this.line_offset
+:at;
+var aw=(au===(void 0))?this.line_offset+this.lineCount()
+:au;
+av-=this.line_offset;
+aw-=this.line_offset;
+if(av<0)av=0;
+if(aw>this.lineCount())aw=this.lineCount();
+if(av>=this.lineCount()||
+aw<0||
+av>aw){
+return null;
+}
+var ai=this.line_ends;
+var ax=av==0?0:ai[av-1]+1;
+var ay=aw==0?0:ai[aw-1]+1;
+return new SourceSlice(this,
+av+this.line_offset,
+aw+this.line_offset,
+ax,ay);
+}
+function ScriptSourceLine(ao){
+var ak=0;
+if(!(ao===(void 0))){
+ak=ao-this.line_offset;
+}
+if(ak<0||this.lineCount()<=ak){
+return null;
+}
+var ai=this.line_ends;
+var al=ak==0?0:ai[ak-1]+1;
+var am=ai[ak];
+return %_Call(z,this.source,al,am);
+}
+function ScriptLineCount(){
+return this.line_ends.length;
+}
+function ScriptLineEnd(az){
+return this.line_ends[az];
+}
+function ScriptNameOrSourceURL(){
+if(this.source_url)return this.source_url;
+return this.name;
+}
+b.SetUpLockedPrototype(v,[
+"source",
+"name",
+"source_url",
+"source_mapping_url",
+"line_ends",
+"line_offset",
+"column_offset"
+],[
+"lineFromPosition",ScriptLineFromPosition,
+"locationFromPosition",ScriptLocationFromPosition,
+"locationFromLine",ScriptLocationFromLine,
+"sourceSlice",ScriptSourceSlice,
+"sourceLine",ScriptSourceLine,
+"lineCount",ScriptLineCount,
+"nameOrSourceURL",ScriptNameOrSourceURL,
+"lineEnd",ScriptLineEnd
+]
+);
+function SourceLocation(ad,af,ak,an,al,am){
+this.script=ad;
+this.position=af;
+this.line=ak;
+this.column=an;
+this.start=al;
+this.end=am;
+}
+function SourceLocationSourceText(){
+return %_Call(z,this.script.source,this.start,this.end);
+}
+b.SetUpLockedPrototype(SourceLocation,
+["script","position","line","column","start","end"],
+["sourceText",SourceLocationSourceText]
+);
+function SourceSlice(ad,av,aw,ax,ay){
+this.script=ad;
+this.from_line=av;
+this.to_line=aw;
+this.from_position=ax;
+this.to_position=ay;
+}
+function SourceSliceSourceText(){
+return %_Call(z,
+this.script.source,
+this.from_position,
+this.to_position);
+}
+b.SetUpLockedPrototype(SourceSlice,
+["script","from_line","to_line","from_position","to_position"],
+["sourceText",SourceSliceSourceText]
+);
+function GetStackTraceLine(aA,aB,aC,aD){
+return new CallSite(aA,aB,aC,false).toString();
+}
+function CallSite(aE,aB,aC,aF){
+if(!(%_IsFunction(aB))){
+throw MakeTypeError(18,typeof aB);
+}
+if((new.target===(void 0))){
+return new CallSite(aE,aB,aC,aF);
+}
+(this[g]=aE);
+(this[h]=aB);
+(this[i]=((aC)|0));
+(this[j]=(!!(aF)));
+}
+function CallSiteGetThis(){
+return(this[j])
+?(void 0):(this[g]);
+}
+function CallSiteGetFunction(){
+return(this[j])
+?(void 0):(this[h]);
+}
+function CallSiteGetPosition(){
+return(this[i]);
+}
+function CallSiteGetTypeName(){
+return GetTypeName((this[g]),false);
+}
+function CallSiteIsToplevel(){
+return %CallSiteIsToplevelRT(this);
+}
+function CallSiteIsEval(){
+return %CallSiteIsEvalRT(this);
+}
+function CallSiteGetEvalOrigin(){
+var ad=%FunctionGetScript((this[h]));
+return FormatEvalOrigin(ad);
+}
+function CallSiteGetScriptNameOrSourceURL(){
+return %CallSiteGetScriptNameOrSourceUrlRT(this);
+}
+function CallSiteGetFunctionName(){
+return %CallSiteGetFunctionNameRT(this);
+}
+function CallSiteGetMethodName(){
+return %CallSiteGetMethodNameRT(this);
+}
+function CallSiteGetFileName(){
+return %CallSiteGetFileNameRT(this);
+}
+function CallSiteGetLineNumber(){
+return %CallSiteGetLineNumberRT(this);
+}
+function CallSiteGetColumnNumber(){
+return %CallSiteGetColumnNumberRT(this);
+}
+function CallSiteIsNative(){
+return %CallSiteIsNativeRT(this);
+}
+function CallSiteIsConstructor(){
+return %CallSiteIsConstructorRT(this);
+}
+function CallSiteToString(){
+var aG;
+var aH="";
+if(this.isNative()){
+aH="native";
+}else{
+aG=this.getScriptNameOrSourceURL();
+if(!aG&&this.isEval()){
+aH=this.getEvalOrigin();
+aH+=", ";
+}
+if(aG){
+aH+=aG;
+}else{
+aH+="<anonymous>";
+}
+var aI=this.getLineNumber();
+if(aI!=null){
+aH+=":"+aI;
+var aJ=this.getColumnNumber();
+if(aJ){
+aH+=":"+aJ;
+}
+}
+}
+var ak="";
+var aK=this.getFunctionName();
+var aL=true;
+var aM=this.isConstructor();
+var aN=!(this.isToplevel()||aM);
+if(aN){
+var aO=GetTypeName((this[g]),true);
+var aP=this.getMethodName();
+if(aK){
+if(aO&&%_Call(y,aK,aO)!=0){
+ak+=aO+".";
+}
+ak+=aK;
+if(aP&&
+(%_Call(y,aK,"."+aP)!=
+aK.length-aP.length-1)){
+ak+=" [as "+aP+"]";
+}
+}else{
+ak+=aO+"."+(aP||"<anonymous>");
+}
+}else if(aM){
+ak+="new "+(aK||"<anonymous>");
+}else if(aK){
+ak+=aK;
+}else{
+ak+=aH;
+aL=false;
+}
+if(aL){
+ak+=" ("+aH+")";
+}
+return ak;
+}
+b.SetUpLockedPrototype(CallSite,["receiver","fun","pos"],[
+"getThis",CallSiteGetThis,
+"getTypeName",CallSiteGetTypeName,
+"isToplevel",CallSiteIsToplevel,
+"isEval",CallSiteIsEval,
+"getEvalOrigin",CallSiteGetEvalOrigin,
+"getScriptNameOrSourceURL",CallSiteGetScriptNameOrSourceURL,
+"getFunction",CallSiteGetFunction,
+"getFunctionName",CallSiteGetFunctionName,
+"getMethodName",CallSiteGetMethodName,
+"getFileName",CallSiteGetFileName,
+"getLineNumber",CallSiteGetLineNumber,
+"getColumnNumber",CallSiteGetColumnNumber,
+"isNative",CallSiteIsNative,
+"getPosition",CallSiteGetPosition,
+"isConstructor",CallSiteIsConstructor,
+"toString",CallSiteToString
+]);
+function FormatEvalOrigin(ad){
+var aQ=ad.nameOrSourceURL();
+if(aQ){
+return aQ;
+}
+var aR="eval at ";
+if(ad.eval_from_function_name){
+aR+=ad.eval_from_function_name;
+}else{
+aR+="<anonymous>";
+}
+var aS=ad.eval_from_script;
+if(aS){
+if(aS.compilation_type==1){
+aR+=" ("+FormatEvalOrigin(aS)+")";
+}else{
+if(aS.name){
+aR+=" ("+aS.name;
+var ae=aS.locationFromPosition(
+ad.eval_from_script_position,true);
+if(ae){
+aR+=":"+(ae.line+1);
+aR+=":"+(ae.column+1);
+}
+aR+=")";
+}else{
+aR+=" (unknown source)";
+}
+}
+}
+return aR;
+}
+function FormatErrorString(aa){
+try{
+return %_Call(ErrorToString,aa);
+}catch(e){
+try{
+return"<error: "+e+">";
+}catch(ee){
+return"<error>";
+}
+}
+}
+function GetStackFrames(aT){
+var aU=new r();
+var aV=aT[0];
+for(var aj=1;aj<aT.length;aj+=4){
+var aA=aT[aj];
+var aB=aT[aj+1];
+var aW=aT[aj+2];
+var aX=aT[aj+3];
+var aC=%_IsSmi(aW)?aW:%FunctionGetPositionForOffset(aW,aX);
+aV--;
+aU.push(new CallSite(aA,aB,aC,(aV<0)));
+}
+return aU;
+}
+var aY=false;
+function FormatStackTrace(Q,aT){
+var aU=GetStackFrames(aT);
+if((%_IsFunction(G.prepareStackTrace))&&
+!aY){
+var aZ=[];
+%MoveArrayContents(aU,aZ);
+aY=true;
+var ba=(void 0);
+try{
+ba=G.prepareStackTrace(Q,aZ);
+}catch(e){
+throw e;
+}finally{
+aY=false;
+}
+return ba;
+}
+var bb=new r();
+bb.push(FormatErrorString(Q));
+for(var aj=0;aj<aU.length;aj++){
+var bc=aU[aj];
+var ak;
+try{
+ak=bc.toString();
+}catch(e){
+try{
+ak="<error: "+e+">";
+}catch(ee){
+ak="<error>";
+}
+}
+bb.push("    at "+ak);
+}
+return %_Call(c,bb,"\n");
+}
+function GetTypeName(aE,bd){
+if((aE==null))return null;
+if((%_IsJSProxy(aE)))return"Proxy";
+var U=%GetDataProperty((%_ToObject(aE)),"constructor");
+if(!(%_IsFunction(U))){
+return bd?null:%_Call(NoSideEffectsToString,aE);
+}
+return %FunctionGetName(U);
+}
+var be=function(){
+var bf=(void 0);
+var bg=this;
+while(bg){
+var bf=
+(bg[m]);
+if((bf===(void 0))){
+var ba=(bg[w]);
+if((ba===(void 0))){
+bg=%_GetPrototype(bg);
+continue;
+}
+bf=FormatStackTrace(bg,ba);
+(bg[w]=(void 0));
+(bg[m]=bf);
+}
+return bf;
+}
+return(void 0);
+};
+var bh=function(bi){
+if(IsErrorObject(this)){
+(this[w]=(void 0));
+(this[m]=bi);
+}
+};
+var bj=function(){};
+function SetUpError(bk){
+%FunctionSetInstanceClassName(bk,'Error');
+var R=bk.name;
+var bl=new n();
+if(R!=='Error'){
+%InternalSetPrototype(bk,G);
+%InternalSetPrototype(bl,G.prototype);
+}
+%FunctionSetPrototype(bk,bl);
+%AddNamedProperty(bk.prototype,'name',R,2);
+%AddNamedProperty(bk.prototype,'message','',2);
+%AddNamedProperty(
+bk.prototype,'constructor',bk,2);
+%SetCode(bk,function(bm){
+if((new.target===(void 0)))return new bk(bm);
+try{bj(this,bk);}catch(e){}
+if(!(bm===(void 0))){
+%AddNamedProperty(this,'message',(%_ToString(bm)),2);
+}
+});
+%SetNativeFlag(bk);
+return bk;
+};
+G=SetUpError(a.Error);
+M=SetUpError(a.EvalError);
+I=SetUpError(a.RangeError);
+L=SetUpError(a.ReferenceError);
+K=SetUpError(a.SyntaxError);
+H=SetUpError(a.TypeError);
+J=SetUpError(a.URIError);
+b.InstallFunctions(G.prototype,2,
+['toString',ErrorToString]);
+function ErrorToString(){
+if(!(%_IsJSReceiver(this))){
+throw MakeTypeError(16,"Error.prototype.toString");
+}
+var R=this.name;
+R=(R===(void 0))?"Error":(%_ToString(R));
+var S=this.message;
+S=(S===(void 0))?"":(%_ToString(S));
+if(R=="")return S;
+if(S=="")return R;
+return`${R}: ${S}`
+}
+function MakeError(W,X,Y,Z){
+return MakeGenericError(G,W,X,Y,Z);
+}
+function MakeRangeError(W,X,Y,Z){
+return MakeGenericError(I,W,X,Y,Z);
+}
+function MakeSyntaxError(W,X,Y,Z){
+return MakeGenericError(K,W,X,Y,Z);
+}
+function MakeTypeError(W,X,Y,Z){
+return MakeGenericError(H,W,X,Y,Z);
+}
+function MakeURIError(){
+return MakeGenericError(J,283);
+}
+var bn=MakeRangeError(187);
+b.InstallGetterSetter(bn,'stack',
+be,bh)
+bj=function captureStackTrace(Q,bo){
+t(Q,'stack',{get:be,
+set:bh,
+configurable:true});
+%CollectStackTrace(Q,bo?bo:bj);
+};
+G.captureStackTrace=bj;
+%InstallToContext([
+"get_stack_trace_line_fun",GetStackTraceLine,
+"make_error_function",MakeGenericError,
+"make_range_error",MakeRangeError,
+"make_type_error",MakeTypeError,
+"message_get_column_number",GetColumnNumber,
+"message_get_line_number",GetLineNumber,
+"message_get_source_line",GetSourceLine,
+"no_side_effects_to_string_fun",NoSideEffectsToString,
+"stack_overflow_boilerplate",bn,
+]);
+b.Export(function(bp){
+bp.ErrorToString=ErrorToString;
+bp.MakeError=MakeError;
+bp.MakeRangeError=MakeRangeError;
+bp.MakeSyntaxError=MakeSyntaxError;
+bp.MakeTypeError=MakeTypeError;
+bp.MakeURIError=MakeURIError;
+});
+});
+
+jsonE
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Date;
+var d=a.JSON;
+var e=a.Set;
+var f=b.InternalArray;
+var g;
+var h;
+var i;
+var j;
+var k=b.ImportNow("to_string_tag_symbol");
+b.Import(function(l){
+g=l.MakeTypeError;
+h=l.MaxSimple;
+i=l.MinSimple;
+j=l.ObjectHasOwnProperty;
+});
+function CreateDataProperty(m,n,o){
+var p={value:o,enumerable:true,writable:true,configurable:true};
+return %reflect_define_property(m,n,p);
+}
+function InternalizeJSONProperty(q,r,s){
+var t=q[r];
+if((%_IsJSReceiver(t))){
+if(%is_arraylike(t)){
+var u=(%_ToLength(t.length));
+for(var v=0;v<u;v++){
+var w=
+InternalizeJSONProperty(t,%_NumberToString(v),s);
+if((w===(void 0))){
+%reflect_delete_property(t,v);
+}else{
+CreateDataProperty(t,v,w);
+}
+}
+}else{
+for(var n of %object_keys(t)){
+var w=InternalizeJSONProperty(t,n,s);
+if((w===(void 0))){
+%reflect_delete_property(t,n);
+}else{
+CreateDataProperty(t,n,w);
+}
+}
+}
+}
+return %_Call(s,q,r,t);
+}
+function JSONParse(x,s){
+var y=%ParseJson(x);
+if((typeof(s)==='function')){
+return InternalizeJSONProperty({'':y},'',s);
+}else{
+return y;
+}
+}
+function SerializeArray(z,A,B,C,D){
+if(!%PushIfAbsent(B,z))throw g(22);
+var E=C;
+C+=D;
+var F=new f();
+var G=(%_ToLength(z.length));
+for(var v=0;v<G;v++){
+var H=JSONSerialize(%_NumberToString(v),z,A,B,
+C,D);
+if((H===(void 0))){
+H="null";
+}
+F.push(H);
+}
+var I;
+if(D==""){
+I="["+F.join(",")+"]";
+}else if(F.length>0){
+var J=",\n"+C;
+I="[\n"+C+F.join(J)+"\n"+
+E+"]";
+}else{
+I="[]";
+}
+B.pop();
+return I;
+}
+function SerializeObject(z,A,B,C,D){
+if(!%PushIfAbsent(B,z))throw g(22);
+var E=C;
+C+=D;
+var F=new f();
+if((%_IsArray(A))){
+var u=A.length;
+for(var v=0;v<u;v++){
+var n=A[v];
+var H=JSONSerialize(n,z,A,B,C,D);
+if(!(H===(void 0))){
+var K=%QuoteJSONString(n)+":";
+if(D!="")K+=" ";
+K+=H;
+F.push(K);
+}
+}
+}else{
+for(var n of %object_keys(z)){
+var H=JSONSerialize(n,z,A,B,C,D);
+if(!(H===(void 0))){
+var K=%QuoteJSONString(n)+":";
+if(D!="")K+=" ";
+K+=H;
+F.push(K);
+}
+}
+}
+var I;
+if(D==""){
+I="{"+F.join(",")+"}";
+}else if(F.length>0){
+var J=",\n"+C;
+I="{\n"+C+F.join(J)+"\n"+
+E+"}";
+}else{
+I="{}";
+}
+B.pop();
+return I;
+}
+function JSONSerialize(L,q,A,B,C,D){
+var z=q[L];
+if((%_IsJSReceiver(z))){
+var M=z.toJSON;
+if((typeof(M)==='function')){
+z=%_Call(M,z,L);
+}
+}
+if((typeof(A)==='function')){
+z=%_Call(A,q,L,z);
+}
+if((typeof(z)==='string')){
+return %QuoteJSONString(z);
+}else if((typeof(z)==='number')){
+return((%_IsSmi(%IS_VAR(z))||z-z==0)?%_NumberToString(z):"null");
+}else if((typeof(z)==='boolean')){
+return z?"true":"false";
+}else if((z===null)){
+return"null";
+}else if((%_IsJSReceiver(z))&&!(typeof(z)==='function')){
+if(%is_arraylike(z)){
+return SerializeArray(z,A,B,C,D);
+}else if((%_ClassOf(z)==='Number')){
+z=(%_ToNumber(z));
+return((%_IsSmi(%IS_VAR(z))||z-z==0)?%_NumberToString(z):"null");
+}else if((%_ClassOf(z)==='String')){
+return %QuoteJSONString((%_ToString(z)));
+}else if((%_ClassOf(z)==='Boolean')){
+return %_ValueOf(z)?"true":"false";
+}else{
+return SerializeObject(z,A,B,C,D);
+}
+}
+return(void 0);
+}
+function JSONStringify(z,A,N){
+if(%_ArgumentsLength()==1&&!(%_IsJSProxy(z))){
+return %BasicJSONStringify(z);
+}
+if(!(typeof(A)==='function')&&%is_arraylike(A)){
+var O=new f();
+var P=new e();
+var u=(%_ToLength(A.length));
+for(var v=0;v<u;v++){
+var o=A[v];
+var Q;
+if((typeof(o)==='string')){
+Q=o;
+}else if((typeof(o)==='number')){
+Q=%_NumberToString(o);
+}else if((%_ClassOf(o)==='String')||(%_ClassOf(o)==='Number')){
+Q=(%_ToString(o));
+}else{
+continue;
+}
+if(!P.has(Q)){
+O.push(Q);
+P.add(Q);
+}
+}
+A=O;
+}
+if((typeof(N)==='object')){
+if((%_ClassOf(N)==='Number')){
+N=(%_ToNumber(N));
+}else if((%_ClassOf(N)==='String')){
+N=(%_ToString(N));
+}
+}
+var D;
+if((typeof(N)==='number')){
+N=h(0,i((%_ToInteger(N)),10));
+D=%_SubString("          ",0,N);
+}else if((typeof(N)==='string')){
+if(N.length>10){
+D=%_SubString(N,0,10);
+}else{
+D=N;
+}
+}else{
+D="";
+}
+return JSONSerialize('',{'':z},A,new f(),"",D);
+}
+%AddNamedProperty(d,k,"JSON",1|2);
+b.InstallFunctions(d,2,[
+"parse",JSONParse,
+"stringify",JSONStringify
+]);
+function DateToJSON(L){
+var m=(%_ToObject(this));
+var R=(%_ToPrimitive_Number(m));
+if((typeof(R)==='number')&&!(%_IsSmi(%IS_VAR(R))||((R==R)&&(R!=1/0)&&(R!=-1/0)))){
+return null;
+}
+return m.toISOString();
+}
+b.InstallFunctions(c.prototype,2,[
+"toJSON",DateToJSON
+]);
+function JsonSerializeAdapter(L,S){
+var q={};
+q[L]=S;
+return JSONSerialize(L,q,(void 0),new f(),"","");
+}
+%InstallToContext(["json_serialize_adapter",JsonSerializeAdapter]);
+})
+
+8array-iterator� 
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=
+b.ImportNow("array_iteration_kind_symbol");
+var d=
+b.ImportNow("array_iterator_next_symbol");
+var e=
+b.ImportNow("array_iterator_object_symbol");
+var f=a.Array;
+var g=b.ImportNow("IteratorPrototype");
+var h=b.ImportNow("iterator_symbol");
+var i;
+var j=b.ImportNow("to_string_tag_symbol");
+var k=a.Uint8Array.__proto__;
+b.Import(function(l){
+i=l.MakeTypeError;
+})
+function ArrayIterator(){}
+function CreateArrayIterator(m,n){
+var o=(%_ToObject(m));
+var p=new ArrayIterator;
+(p[e]=o);
+(p[d]=0);
+(p[c]=n);
+return p;
+}
+function ArrayIteratorIterator(){
+return this;
+}
+function ArrayIteratorNext(){
+var p=this;
+var q=(void 0);
+var r=true;
+if(!(%_IsJSReceiver(p))||
+!(!(p[d]===(void 0)))){
+throw i(42,
+'Array Iterator.prototype.next',this);
+}
+var m=(p[e]);
+if(!(m===(void 0))){
+var s=(p[d]);
+var t=(p[c]);
+var u=((m.length)>>>0);
+if(s>=u){
+(p[e]=(void 0));
+}else{
+(p[d]=s+1);
+if(t==2){
+q=m[s];
+}else if(t==3){
+q=[s,m[s]];
+}else{
+q=s;
+}
+r=false;
+}
+}
+return %_CreateIterResultObject(q,r);
+}
+function ArrayEntries(){
+return CreateArrayIterator(this,3);
+}
+function ArrayValues(){
+return CreateArrayIterator(this,2);
+}
+function ArrayKeys(){
+return CreateArrayIterator(this,1);
+}
+%FunctionSetPrototype(ArrayIterator,{__proto__:g});
+%FunctionSetInstanceClassName(ArrayIterator,'Array Iterator');
+b.InstallFunctions(ArrayIterator.prototype,2,[
+'next',ArrayIteratorNext
+]);
+b.SetFunctionName(ArrayIteratorIterator,h);
+%AddNamedProperty(ArrayIterator.prototype,h,
+ArrayIteratorIterator,2);
+%AddNamedProperty(ArrayIterator.prototype,j,
+"Array Iterator",1|2);
+b.InstallFunctions(f.prototype,2,[
+'entries',ArrayEntries,
+'keys',ArrayKeys
+]);
+b.SetFunctionName(ArrayValues,'values');
+%AddNamedProperty(f.prototype,h,ArrayValues,
+2);
+%AddNamedProperty(k.prototype,
+'entries',ArrayEntries,2);
+%AddNamedProperty(k.prototype,'values',ArrayValues,2);
+%AddNamedProperty(k.prototype,'keys',ArrayKeys,2);
+%AddNamedProperty(k.prototype,
+h,ArrayValues,2);
+b.Export(function(v){
+v.ArrayValues=ArrayValues;
+});
+%InstallToContext(["array_values_iterator",ArrayValues]);
+})
+
+<string-iterator5
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.String;
+var d=b.ImportNow("IteratorPrototype");
+var e=b.ImportNow("iterator_symbol");
+var f;
+var g=
+b.ImportNow("string_iterator_iterated_string_symbol");
+var h=
+b.ImportNow("string_iterator_next_index_symbol");
+var i=b.ImportNow("to_string_tag_symbol");
+b.Import(function(j){
+f=j.MakeTypeError;
+});
+function StringIterator(){}
+function CreateStringIterator(k){
+var l=(%_ToString(k));
+var m=new StringIterator;
+(m[g]=l);
+(m[h]=0);
+return m;
+}
+function StringIteratorNext(){
+var m=this;
+var n=(void 0);
+var o=true;
+if(!(%_IsJSReceiver(m))||
+!(!(m[h]===(void 0)))){
+throw f(42,
+'String Iterator.prototype.next');
+}
+var l=(m[g]);
+if(!(l===(void 0))){
+var p=(m[h]);
+var q=((l.length)>>>0);
+if(p>=q){
+(m[g]=(void 0));
+}else{
+var r=%_StringCharCodeAt(l,p);
+n=%_StringCharFromCode(r);
+o=false;
+p++;
+if(r>=0xD800&&r<=0xDBFF&&p<q){
+var s=%_StringCharCodeAt(l,p);
+if(s>=0xDC00&&s<=0xDFFF){
+n+=%_StringCharFromCode(s);
+p++;
+}
+}
+(m[h]=p);
+}
+}
+return %_CreateIterResultObject(n,o);
+}
+function StringPrototypeIterator(){
+return CreateStringIterator(this);
+}
+%FunctionSetPrototype(StringIterator,{__proto__:d});
+%FunctionSetInstanceClassName(StringIterator,'String Iterator');
+b.InstallFunctions(StringIterator.prototype,2,[
+'next',StringIteratorNext
+]);
+%AddNamedProperty(StringIterator.prototype,i,
+"String Iterator",1|2);
+b.SetFunctionName(StringPrototypeIterator,e);
+%AddNamedProperty(c.prototype,e,
+StringPrototypeIterator,2);
+})
+
+$templates
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Map;
+var d=b.InternalArray;
+var e=new c;
+var f=c.prototype.get;
+var g=c.prototype.set;
+function SameCallSiteElements(h,i){
+var j=h.length;
+var i=i.raw;
+if(j!==i.length)return false;
+for(var k=0;k<j;++k){
+if(h[k]!==i[k])return false;
+}
+return true;
+}
+function GetCachedCallSite(l,m){
+var n=%_Call(f,e,m);
+if((n===(void 0)))return;
+var j=n.length;
+for(var k=0;k<j;++k){
+if(SameCallSiteElements(l,n[k]))return n[k];
+}
+}
+function SetCachedCallSite(l,m){
+var n=%_Call(f,e,m);
+var o;
+if((n===(void 0))){
+o=new d(1);
+o[0]=l;
+%_Call(g,e,m,o);
+}else{
+n.push(l);
+}
+return l;
+}
+function GetTemplateCallSite(l,h,m){
+var p=GetCachedCallSite(h,m);
+if(!(p===(void 0)))return p;
+%AddNamedProperty(l,"raw",%object_freeze(h),
+1|2|4);
+return SetCachedCallSite(%object_freeze(l),m);
+}
+%InstallToContext(["get_template_call_site",GetTemplateCallSite]);
+})
+
+spread�
+(function(a,b){
+'use strict';
+var c=b.InternalArray;
+var d;
+b.Import(function(e){
+d=e.MakeTypeError;
+});
+function SpreadArguments(){
+var f=%_ArgumentsLength();
+var g=new c();
+for(var h=0;h<f;++h){
+var i=%_Arguments(h);
+var j=i.length;
+for(var k=0;k<j;++k){
+g.push(i[k]);
+}
+}
+return g;
+}
+function SpreadIterable(l){
+if((l==null)){
+throw d(66,l);
+}
+var g=new c();
+for(var m of l){
+g.push(m);
+}
+return g;
+}
+%InstallToContext([
+"spread_arguments",SpreadArguments,
+"spread_iterable",SpreadIterable,
+]);
+})
+
+i18nF�

+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c;
+var d;
+var e;
+var f;
+var g;
+var h=a.Boolean;
+var i=a.Date;
+var j=a.Number;
+var k=a.RegExp;
+var l=a.String;
+var m;
+var n;
+var o;
+var p;
+var q=b.ImportNow("ObjectDefineProperties");
+var r=b.ImportNow("ObjectDefineProperty");
+var s=b.ImportNow("intl_pattern_symbol");
+var t;
+var u=b.ImportNow("intl_resolved_symbol");
+var v;
+var w;
+var x;
+var y;
+var z;
+var A;
+var B;
+b.Import(function(C){
+c=C.ArrayIndexOf;
+d=C.ArrayJoin;
+e=C.ArrayPush;
+f=C.IsFinite;
+g=C.IsNaN;
+m=C.MakeError;
+n=C.MakeRangeError;
+o=C.MakeTypeError;
+p=C.MathFloor;
+t=C.RegExpTest;
+v=C.StringIndexOf;
+w=C.StringLastIndexOf;
+x=C.StringMatch;
+y=C.StringReplace;
+z=C.StringSplit;
+A=C.StringSubstr;
+B=C.StringSubstring;
+});
+var D={};
+%AddNamedProperty(a,"Intl",D,2);
+var E={
+'collator':(void 0),
+'numberformat':(void 0),
+'dateformat':(void 0),
+'breakiterator':(void 0)
+};
+var F=(void 0);
+var G=(void 0);
+function GetUnicodeExtensionRE(){
+if(((void 0)===(void 0))){
+G=new k('-u(-[a-z0-9]{2,8})+','g');
+}
+return G;
+}
+var H=(void 0);
+function GetAnyExtensionRE(){
+if((H===(void 0))){
+H=new k('-[a-z0-9]{1}-.*','g');
+}
+return H;
+}
+var I=(void 0);
+function GetQuotedStringRE(){
+if((I===(void 0))){
+I=new k("'[^']+'",'g');
+}
+return I;
+}
+var J=(void 0);
+function GetServiceRE(){
+if((J===(void 0))){
+J=
+new k('^(collator|numberformat|dateformat|breakiterator)$');
+}
+return J;
+}
+var K=(void 0);
+function GetLanguageTagRE(){
+if((K===(void 0))){
+BuildLanguageTagREs();
+}
+return K;
+}
+var L=(void 0);
+function GetLanguageVariantRE(){
+if((L===(void 0))){
+BuildLanguageTagREs();
+}
+return L;
+}
+var M=(void 0);
+function GetLanguageSingletonRE(){
+if((M===(void 0))){
+BuildLanguageTagREs();
+}
+return M;
+}
+var N=(void 0);
+function GetTimezoneNameCheckRE(){
+if((N===(void 0))){
+N=new k(
+'^([A-Za-z]+)/([A-Za-z_-]+)((?:\/[A-Za-z_-]+)+)*$');
+}
+return N;
+}
+var O=(void 0);
+function GetTimezoneNameLocationPartRE(){
+if((O===(void 0))){
+O=
+new k('^([A-Za-z]+)((?:[_-][A-Za-z]+)+)*$');
+}
+return O;
+}
+function addBoundMethod(P,Q,R,S){
+%CheckIsBootstrapping();
+function getter(){
+if(!%IsInitializedIntlObject(this)){
+throw o(51,Q);
+}
+var T='__bound'+Q+'__';
+if((this[T]===(void 0))){
+var U=this;
+var V;
+if((S===(void 0))||S===2){
+V=function(W,X){
+if(!(new.target===(void 0))){
+throw o(87);
+}
+return R(U,W,X);
+}
+}else if(S===1){
+V=function(W){
+if(!(new.target===(void 0))){
+throw o(87);
+}
+return R(U,W);
+}
+}else{
+V=function(){
+if(!(new.target===(void 0))){
+throw o(87);
+}
+if(%_ArgumentsLength()>0){
+return R(U,%_Arguments(0));
+}else{
+return R(U);
+}
+}
+}
+%FunctionSetName(V,T);
+%FunctionRemovePrototype(V);
+%SetNativeFlag(V);
+this[T]=V;
+}
+return this[T];
+}
+%FunctionSetName(getter,Q);
+%FunctionRemovePrototype(getter);
+%SetNativeFlag(getter);
+r(P.prototype,Q,{
+get:getter,
+enumerable:false,
+configurable:true
+});
+}
+function supportedLocalesOf(Y,Z,aa){
+if((%_Call(x,Y,GetServiceRE())===null)){
+throw m(7,Y);
+}
+if((aa===(void 0))){
+aa={};
+}else{
+aa=(%_ToObject(aa));
+}
+var ab=aa.localeMatcher;
+if(!(ab===(void 0))){
+ab=l(ab);
+if(ab!=='lookup'&&ab!=='best fit'){
+throw n(183,ab);
+}
+}else{
+ab='best fit';
+}
+var ac=initializeLocaleList(Z);
+if((E[Y]===(void 0))){
+E[Y]=getAvailableLocalesOf(Y);
+}
+if(ab==='best fit'){
+return initializeLocaleList(bestFitSupportedLocalesOf(
+ac,E[Y]));
+}
+return initializeLocaleList(lookupSupportedLocalesOf(
+ac,E[Y]));
+}
+function lookupSupportedLocalesOf(ac,ad){
+var ae=[];
+for(var af=0;af<ac.length;++af){
+var ag=%_Call(y,
+ac[af],
+GetUnicodeExtensionRE(),
+'');
+do{
+if(!(ad[ag]===(void 0))){
+%_Call(e,ae,ac[af]);
+break;
+}
+var ah=%_Call(w,ag,'-');
+if(ah===-1){
+break;
+}
+ag=%_Call(B,ag,0,ah);
+}while(true);
+}
+return ae;
+}
+function bestFitSupportedLocalesOf(ac,ad){
+return lookupSupportedLocalesOf(ac,ad);
+}
+function getGetOption(aa,ai){
+if((aa===(void 0)))throw m(4,ai);
+var aj=function getOption(ak,al,am,an){
+if(!(aa[ak]===(void 0))){
+var ao=aa[ak];
+switch(al){
+case'boolean':
+ao=h(ao);
+break;
+case'string':
+ao=l(ao);
+break;
+case'number':
+ao=j(ao);
+break;
+default:
+throw m(8);
+}
+if(!(am===(void 0))&&%_Call(c,am,ao)===-1){
+throw n(193,ao,ai,ak);
+}
+return ao;
+}
+return an;
+}
+return aj;
+}
+function resolveLocale(Y,ac,aa){
+ac=initializeLocaleList(ac);
+var aj=getGetOption(aa,Y);
+var ab=aj('localeMatcher','string',
+['lookup','best fit'],'best fit');
+var ap;
+if(ab==='lookup'){
+ap=lookupMatcher(Y,ac);
+}else{
+ap=bestFitMatcher(Y,ac);
+}
+return ap;
+}
+function lookupMatcher(Y,ac){
+if((%_Call(x,Y,GetServiceRE())===null)){
+throw m(7,Y);
+}
+if((E[Y]===(void 0))){
+E[Y]=getAvailableLocalesOf(Y);
+}
+for(var af=0;af<ac.length;++af){
+var ag=%_Call(y,ac[af],
+GetAnyExtensionRE(),'');
+do{
+if(!(E[Y][ag]===(void 0))){
+var aq=
+%_Call(x,ac[af],GetUnicodeExtensionRE());
+var ar=(aq===null)?'':aq[0];
+return{'locale':ag,'extension':ar,'position':af};
+}
+var ah=%_Call(w,ag,'-');
+if(ah===-1){
+break;
+}
+ag=%_Call(B,ag,0,ah);
+}while(true);
+}
+if((F===(void 0))){
+F=%GetDefaultICULocale();
+}
+return{'locale':F,'extension':'','position':-1};
+}
+function bestFitMatcher(Y,ac){
+return lookupMatcher(Y,ac);
+}
+function parseExtension(ar){
+var as=%_Call(z,ar,'-');
+if(as.length<=2||
+(as[0]!==''&&as[1]!=='u')){
+return{};
+}
+var at={};
+var au=(void 0);
+for(var af=2;af<as.length;++af){
+var S=as[af].length;
+var av=as[af];
+if(S===2){
+at[av]=(void 0);
+au=av;
+}else if(S>=3&&S<=8&&!(au===(void 0))){
+at[au]=av;
+au=(void 0);
+}else{
+return{};
+}
+}
+return at;
+}
+function setOptions(aw,at,ax,aj,ay){
+var ar='';
+var az=function updateExtension(aA,ao){
+return'-'+aA+'-'+l(ao);
+}
+var aB=function updateProperty(ak,al,ao){
+if(al==='boolean'&&(typeof ao==='string')){
+ao=(ao==='true')?true:false;
+}
+if(!(ak===(void 0))){
+defineWEProperty(ay,ak,ao);
+}
+}
+for(var aA in ax){
+if(%HasOwnProperty(ax,aA)){
+var ao=(void 0);
+var aC=ax[aA];
+if(!(aC.property===(void 0))){
+ao=aj(aC.property,aC.type,aC.values);
+}
+if(!(ao===(void 0))){
+aB(aC.property,aC.type,ao);
+ar+=az(aA,ao);
+continue;
+}
+if(%HasOwnProperty(at,aA)){
+ao=at[aA];
+if(!(ao===(void 0))){
+aB(aC.property,aC.type,ao);
+ar+=az(aA,ao);
+}else if(aC.type==='boolean'){
+aB(aC.property,aC.type,true);
+ar+=az(aA,true);
+}
+}
+}
+}
+return ar===''?'':'-u'+ar;
+}
+function freezeArray(aD){
+var aE=aD.length;
+for(var af=0;af<aE;af++){
+if(af in aD){
+r(aD,af,{value:aD[af],
+configurable:false,
+writable:false,
+enumerable:true});
+}
+}
+r(aD,'length',{value:aE,writable:false});
+return aD;
+}
+function getOptimalLanguageTag(aF,ap){
+if(aF===ap){
+return aF;
+}
+var Z=%GetLanguageTagVariants([aF,ap]);
+if(Z[0].maximized!==Z[1].maximized){
+return ap;
+}
+var aG=new k('^'+Z[1].base);
+return %_Call(y,ap,aG,Z[0].base);
+}
+function getAvailableLocalesOf(Y){
+var aH=%AvailableLocalesOf(Y);
+for(var af in aH){
+if(%HasOwnProperty(aH,af)){
+var aI=
+%_Call(x,af,/^([a-z]{2,3})-([A-Z][a-z]{3})-([A-Z]{2})$/);
+if(aI!==null){
+aH[aI[1]+'-'+aI[3]]=null;
+}
+}
+}
+return aH;
+}
+function defineWEProperty(aJ,ak,ao){
+r(aJ,ak,
+{value:ao,writable:true,enumerable:true});
+}
+function addWEPropertyIfDefined(aJ,ak,ao){
+if(!(ao===(void 0))){
+defineWEProperty(aJ,ak,ao);
+}
+}
+function defineWECProperty(aJ,ak,ao){
+r(aJ,ak,{value:ao,
+writable:true,
+enumerable:true,
+configurable:true});
+}
+function addWECPropertyIfDefined(aJ,ak,ao){
+if(!(ao===(void 0))){
+defineWECProperty(aJ,ak,ao);
+}
+}
+function toTitleCaseWord(aK){
+return %StringToUpperCase(%_Call(A,aK,0,1))+
+%StringToLowerCase(%_Call(A,aK,1));
+}
+function toTitleCaseTimezoneLocation(aL){
+var aM=%_Call(x,aL,GetTimezoneNameLocationPartRE());
+if((aM===null))throw n(163,aL);
+var aN=toTitleCaseWord(aM[1]);
+if(!(aM[2]===(void 0))&&2<aM.length){
+var aO=%_Call(B,aM[2],0,1);
+var aI=%_Call(z,aM[2],aO);
+for(var af=1;af<aI.length;af++){
+var aP=aI[af]
+var aQ=%StringToLowerCase(aP);
+aN=aN+aO+
+((aQ!=='es'&&
+aQ!=='of'&&aQ!=='au')?
+toTitleCaseWord(aP):aQ);
+}
+}
+return aN;
+}
+function canonicalizeLanguageTag(aR){
+if(typeof aR!=='string'&&typeof aR!=='object'||
+(aR===null)){
+throw o(50);
+}
+var aS=l(aR);
+if(isValidLanguageTag(aS)===false){
+throw n(174,aS);
+}
+var aT=%CanonicalizeLanguageTag(aS);
+if(aT==='invalid-tag'){
+throw n(174,aS);
+}
+return aT;
+}
+function initializeLocaleList(Z){
+var aU=[];
+if((Z===(void 0))){
+aU=[];
+}else{
+if(typeof Z==='string'){
+%_Call(e,aU,canonicalizeLanguageTag(Z));
+return freezeArray(aU);
+}
+var aV=(%_ToObject(Z));
+var aW=((aV.length)>>>0);
+for(var aX=0;aX<aW;aX++){
+if(aX in aV){
+var ao=aV[aX];
+var aT=canonicalizeLanguageTag(ao);
+if(%_Call(c,aU,aT)===-1){
+%_Call(e,aU,aT);
+}
+}
+}
+}
+return freezeArray(aU);
+}
+function isValidLanguageTag(ag){
+if(!%_Call(t,GetLanguageTagRE(),ag)){
+return false;
+}
+if(%_Call(v,ag,'x-')===0){
+return true;
+}
+ag=%_Call(z,ag,/-x-/)[0];
+var aY=[];
+var aZ=[];
+var aI=%_Call(z,ag,/-/);
+for(var af=1;af<aI.length;af++){
+var ao=aI[af];
+if(%_Call(t,GetLanguageVariantRE(),ao)&&
+aZ.length===0){
+if(%_Call(c,aY,ao)===-1){
+%_Call(e,aY,ao);
+}else{
+return false;
+}
+}
+if(%_Call(t,GetLanguageSingletonRE(),ao)){
+if(%_Call(c,aZ,ao)===-1){
+%_Call(e,aZ,ao);
+}else{
+return false;
+}
+}
+}
+return true;
+}
+function BuildLanguageTagREs(){
+var ba='[a-zA-Z]';
+var bb='[0-9]';
+var bc='('+ba+'|'+bb+')';
+var bd='(art-lojban|cel-gaulish|no-bok|no-nyn|zh-guoyu|zh-hakka|'+
+'zh-min|zh-min-nan|zh-xiang)';
+var be='(en-GB-oed|i-ami|i-bnn|i-default|i-enochian|i-hak|'+
+'i-klingon|i-lux|i-mingo|i-navajo|i-pwn|i-tao|i-tay|'+
+'i-tsu|sgn-BE-FR|sgn-BE-NL|sgn-CH-DE)';
+var bf='('+be+'|'+bd+')';
+var bg='(x(-'+bc+'{1,8})+)';
+var bh='('+bb+'|[A-WY-Za-wy-z])';
+M=new k('^'+bh+'$','i');
+var ar='('+bh+'(-'+bc+'{2,8})+)';
+var bi='('+bc+'{5,8}|('+bb+bc+'{3}))';
+L=new k('^'+bi+'$','i');
+var bj='('+ba+'{2}|'+bb+'{3})';
+var bk='('+ba+'{4})';
+var bl='('+ba+'{3}(-'+ba+'{3}){0,2})';
+var bm='('+ba+'{2,3}(-'+bl+')?|'+ba+'{4}|'+
+ba+'{5,8})';
+var bn=bm+'(-'+bk+')?(-'+bj+')?(-'+
+bi+')*(-'+ar+')*(-'+bg+')?';
+var bo=
+'^('+bn+'|'+bg+'|'+bf+')$';
+K=new k(bo,'i');
+}
+var bp={
+get(){
+%IncrementUseCounter(16);
+return this[u];
+},
+set(ao){
+this[u]=ao;
+}
+};
+function initializeCollator(bq,Z,aa){
+if(%IsInitializedIntlObject(bq)){
+throw o(132,"Collator");
+}
+if((aa===(void 0))){
+aa={};
+}
+var aj=getGetOption(aa,'collator');
+var br={};
+defineWEProperty(br,'usage',aj(
+'usage','string',['sort','search'],'sort'));
+var bs=aj('sensitivity','string',
+['base','accent','case','variant']);
+if((bs===(void 0))&&br.usage==='sort'){
+bs='variant';
+}
+defineWEProperty(br,'sensitivity',bs);
+defineWEProperty(br,'ignorePunctuation',aj(
+'ignorePunctuation','boolean',(void 0),false));
+var ag=resolveLocale('collator',Z,aa);
+var at=parseExtension(ag.extension);
+var bt={
+'kn':{'property':'numeric','type':'boolean'},
+'kf':{'property':'caseFirst','type':'string',
+'values':['false','lower','upper']}
+};
+setOptions(
+aa,at,bt,aj,br);
+var bu='default';
+var ar='';
+if(%HasOwnProperty(at,'co')&&br.usage==='sort'){
+var bv=[
+'big5han','dict','direct','ducet','gb2312','phonebk','phonetic',
+'pinyin','reformed','searchjl','stroke','trad','unihan','zhuyin'
+];
+if(%_Call(c,bv,at.co)!==-1){
+ar='-u-co-'+at.co;
+bu=at.co;
+}
+}else if(br.usage==='search'){
+ar='-u-co-search';
+}
+defineWEProperty(br,'collation',bu);
+var bw=ag.locale+ar;
+var ap=q({},{
+caseFirst:{writable:true},
+collation:{value:br.collation,writable:true},
+ignorePunctuation:{writable:true},
+locale:{writable:true},
+numeric:{writable:true},
+requestedLocale:{value:bw,writable:true},
+sensitivity:{writable:true},
+strength:{writable:true},
+usage:{value:br.usage,writable:true}
+});
+var bx=%CreateCollator(bw,
+br,
+ap);
+%MarkAsInitializedIntlObjectOfType(bq,'collator',bx);
+bq[u]=ap;
+r(bq,'resolved',bp);
+return bq;
+}
+%AddNamedProperty(D,'Collator',function(){
+var Z=%_Arguments(0);
+var aa=%_Arguments(1);
+if(!this||this===D){
+return new D.Collator(Z,aa);
+}
+return initializeCollator((%_ToObject(this)),Z,aa);
+},
+2
+);
+%AddNamedProperty(D.Collator.prototype,'resolvedOptions',function(){
+if(!(new.target===(void 0))){
+throw o(87);
+}
+if(!%IsInitializedIntlObjectOfType(this,'collator')){
+throw o(133,"Collator");
+}
+var by=this;
+var ag=getOptimalLanguageTag(by[u].requestedLocale,
+by[u].locale);
+return{
+locale:ag,
+usage:by[u].usage,
+sensitivity:by[u].sensitivity,
+ignorePunctuation:by[u].ignorePunctuation,
+numeric:by[u].numeric,
+caseFirst:by[u].caseFirst,
+collation:by[u].collation
+};
+},
+2
+);
+%FunctionSetName(D.Collator.prototype.resolvedOptions,'resolvedOptions');
+%FunctionRemovePrototype(D.Collator.prototype.resolvedOptions);
+%SetNativeFlag(D.Collator.prototype.resolvedOptions);
+%AddNamedProperty(D.Collator,'supportedLocalesOf',function(Z){
+if(!(new.target===(void 0))){
+throw o(87);
+}
+return supportedLocalesOf('collator',Z,%_Arguments(1));
+},
+2
+);
+%FunctionSetName(D.Collator.supportedLocalesOf,'supportedLocalesOf');
+%FunctionRemovePrototype(D.Collator.supportedLocalesOf);
+%SetNativeFlag(D.Collator.supportedLocalesOf);
+function compare(bq,W,X){
+return %InternalCompare(%GetImplFromInitializedIntlObject(bq),
+l(W),l(X));
+};
+addBoundMethod(D.Collator,'compare',compare,2);
+function isWellFormedCurrencyCode(bz){
+return typeof bz=="string"&&
+bz.length==3&&
+%_Call(x,bz,/[^A-Za-z]/)==null;
+}
+function getNumberOption(aa,ak,bA,bB,bC){
+var ao=aa[ak];
+if(!(ao===(void 0))){
+ao=j(ao);
+if(g(ao)||ao<bA||ao>bB){
+throw n(186,ak);
+}
+return p(ao);
+}
+return bC;
+}
+var bD={
+get(){
+%IncrementUseCounter(15);
+return this[s];
+},
+set(ao){
+this[s]=ao;
+}
+};
+function initializeNumberFormat(bE,Z,aa){
+if(%IsInitializedIntlObject(bE)){
+throw o(132,"NumberFormat");
+}
+if((aa===(void 0))){
+aa={};
+}
+var aj=getGetOption(aa,'numberformat');
+var ag=resolveLocale('numberformat',Z,aa);
+var br={};
+defineWEProperty(br,'style',aj(
+'style','string',['decimal','percent','currency'],'decimal'));
+var bz=aj('currency','string');
+if(!(bz===(void 0))&&!isWellFormedCurrencyCode(bz)){
+throw n(169,bz);
+}
+if(br.style==='currency'&&(bz===(void 0))){
+throw o(28);
+}
+var bF=aj(
+'currencyDisplay','string',['code','symbol','name'],'symbol');
+if(br.style==='currency'){
+defineWEProperty(br,'currency',%StringToUpperCase(bz));
+defineWEProperty(br,'currencyDisplay',bF);
+}
+var bG=getNumberOption(aa,'minimumIntegerDigits',1,21,1);
+defineWEProperty(br,'minimumIntegerDigits',bG);
+var bH=aa['minimumFractionDigits'];
+var bI=aa['maximumFractionDigits'];
+if(!(bH===(void 0))||br.style!=='currency'){
+bH=getNumberOption(aa,'minimumFractionDigits',0,20,0);
+defineWEProperty(br,'minimumFractionDigits',bH);
+}
+if(!(bI===(void 0))||br.style!=='currency'){
+var bJ=br.style==='percent'?0:3;
+bH=(bH===(void 0))?0:bH;
+var bK=(bH>bJ)?bH:bJ;
+bI=getNumberOption(aa,'maximumFractionDigits',bH,20,bK);
+defineWEProperty(br,'maximumFractionDigits',bI);
+}
+var bL=aa['minimumSignificantDigits'];
+var bM=aa['maximumSignificantDigits'];
+if(!(bL===(void 0))||!(bM===(void 0))){
+bL=getNumberOption(aa,'minimumSignificantDigits',1,21,0);
+defineWEProperty(br,'minimumSignificantDigits',bL);
+bM=getNumberOption(aa,'maximumSignificantDigits',bL,21,21);
+defineWEProperty(br,'maximumSignificantDigits',bM);
+}
+defineWEProperty(br,'useGrouping',aj(
+'useGrouping','boolean',(void 0),true));
+var at=parseExtension(ag.extension);
+var bN={
+'nu':{'property':(void 0),'type':'string'}
+};
+var ar=setOptions(aa,at,bN,
+aj,br);
+var bw=ag.locale+ar;
+var ap=q({},{
+currency:{writable:true},
+currencyDisplay:{writable:true},
+locale:{writable:true},
+maximumFractionDigits:{writable:true},
+minimumFractionDigits:{writable:true},
+minimumIntegerDigits:{writable:true},
+numberingSystem:{writable:true},
+pattern:bD,
+requestedLocale:{value:bw,writable:true},
+style:{value:br.style,writable:true},
+useGrouping:{writable:true}
+});
+if(%HasOwnProperty(br,'minimumSignificantDigits')){
+defineWEProperty(ap,'minimumSignificantDigits',(void 0));
+}
+if(%HasOwnProperty(br,'maximumSignificantDigits')){
+defineWEProperty(ap,'maximumSignificantDigits',(void 0));
+}
+var bO=%CreateNumberFormat(bw,
+br,
+ap);
+if(br.style==='currency'){
+r(ap,'currencyDisplay',{value:bF,
+writable:true});
+}
+%MarkAsInitializedIntlObjectOfType(bE,'numberformat',bO);
+bE[u]=ap;
+r(bE,'resolved',bp);
+return bE;
+}
+%AddNamedProperty(D,'NumberFormat',function(){
+var Z=%_Arguments(0);
+var aa=%_Arguments(1);
+if(!this||this===D){
+return new D.NumberFormat(Z,aa);
+}
+return initializeNumberFormat((%_ToObject(this)),Z,aa);
+},
+2
+);
+%AddNamedProperty(D.NumberFormat.prototype,'resolvedOptions',function(){
+if(!(new.target===(void 0))){
+throw o(87);
+}
+if(!%IsInitializedIntlObjectOfType(this,'numberformat')){
+throw o(133,"NumberFormat");
+}
+var bP=this;
+var ag=getOptimalLanguageTag(bP[u].requestedLocale,
+bP[u].locale);
+var aN={
+locale:ag,
+numberingSystem:bP[u].numberingSystem,
+style:bP[u].style,
+useGrouping:bP[u].useGrouping,
+minimumIntegerDigits:bP[u].minimumIntegerDigits,
+minimumFractionDigits:bP[u].minimumFractionDigits,
+maximumFractionDigits:bP[u].maximumFractionDigits,
+};
+if(aN.style==='currency'){
+defineWECProperty(aN,'currency',bP[u].currency);
+defineWECProperty(aN,'currencyDisplay',
+bP[u].currencyDisplay);
+}
+if(%HasOwnProperty(bP[u],'minimumSignificantDigits')){
+defineWECProperty(aN,'minimumSignificantDigits',
+bP[u].minimumSignificantDigits);
+}
+if(%HasOwnProperty(bP[u],'maximumSignificantDigits')){
+defineWECProperty(aN,'maximumSignificantDigits',
+bP[u].maximumSignificantDigits);
+}
+return aN;
+},
+2
+);
+%FunctionSetName(D.NumberFormat.prototype.resolvedOptions,
+'resolvedOptions');
+%FunctionRemovePrototype(D.NumberFormat.prototype.resolvedOptions);
+%SetNativeFlag(D.NumberFormat.prototype.resolvedOptions);
+%AddNamedProperty(D.NumberFormat,'supportedLocalesOf',function(Z){
+if(!(new.target===(void 0))){
+throw o(87);
+}
+return supportedLocalesOf('numberformat',Z,%_Arguments(1));
+},
+2
+);
+%FunctionSetName(D.NumberFormat.supportedLocalesOf,'supportedLocalesOf');
+%FunctionRemovePrototype(D.NumberFormat.supportedLocalesOf);
+%SetNativeFlag(D.NumberFormat.supportedLocalesOf);
+function formatNumber(bO,ao){
+var bQ=(%_ToNumber(ao))+0;
+return %InternalNumberFormat(%GetImplFromInitializedIntlObject(bO),
+bQ);
+}
+function parseNumber(bO,ao){
+return %InternalNumberParse(%GetImplFromInitializedIntlObject(bO),
+l(ao));
+}
+addBoundMethod(D.NumberFormat,'format',formatNumber,1);
+addBoundMethod(D.NumberFormat,'v8Parse',parseNumber,1);
+function toLDMLString(aa){
+var aj=getGetOption(aa,'dateformat');
+var bR='';
+var bS=aj('weekday','string',['narrow','short','long']);
+bR+=appendToLDMLString(
+bS,{narrow:'EEEEE',short:'EEE',long:'EEEE'});
+bS=aj('era','string',['narrow','short','long']);
+bR+=appendToLDMLString(
+bS,{narrow:'GGGGG',short:'GGG',long:'GGGG'});
+bS=aj('year','string',['2-digit','numeric']);
+bR+=appendToLDMLString(bS,{'2-digit':'yy','numeric':'y'});
+bS=aj('month','string',
+['2-digit','numeric','narrow','short','long']);
+bR+=appendToLDMLString(bS,{'2-digit':'MM','numeric':'M',
+'narrow':'MMMMM','short':'MMM','long':'MMMM'});
+bS=aj('day','string',['2-digit','numeric']);
+bR+=appendToLDMLString(
+bS,{'2-digit':'dd','numeric':'d'});
+var bT=aj('hour12','boolean');
+bS=aj('hour','string',['2-digit','numeric']);
+if((bT===(void 0))){
+bR+=appendToLDMLString(bS,{'2-digit':'jj','numeric':'j'});
+}else if(bT===true){
+bR+=appendToLDMLString(bS,{'2-digit':'hh','numeric':'h'});
+}else{
+bR+=appendToLDMLString(bS,{'2-digit':'HH','numeric':'H'});
+}
+bS=aj('minute','string',['2-digit','numeric']);
+bR+=appendToLDMLString(bS,{'2-digit':'mm','numeric':'m'});
+bS=aj('second','string',['2-digit','numeric']);
+bR+=appendToLDMLString(bS,{'2-digit':'ss','numeric':'s'});
+bS=aj('timeZoneName','string',['short','long']);
+bR+=appendToLDMLString(bS,{short:'z',long:'zzzz'});
+return bR;
+}
+function appendToLDMLString(bS,bU){
+if(!(bS===(void 0))){
+return bU[bS];
+}else{
+return'';
+}
+}
+function fromLDMLString(bR){
+bR=%_Call(y,bR,GetQuotedStringRE(),'');
+var aa={};
+var aM=%_Call(x,bR,/E{3,5}/g);
+aa=appendToDateTimeObject(
+aa,'weekday',aM,{EEEEE:'narrow',EEE:'short',EEEE:'long'});
+aM=%_Call(x,bR,/G{3,5}/g);
+aa=appendToDateTimeObject(
+aa,'era',aM,{GGGGG:'narrow',GGG:'short',GGGG:'long'});
+aM=%_Call(x,bR,/y{1,2}/g);
+aa=appendToDateTimeObject(
+aa,'year',aM,{y:'numeric',yy:'2-digit'});
+aM=%_Call(x,bR,/M{1,5}/g);
+aa=appendToDateTimeObject(aa,'month',aM,{MM:'2-digit',
+M:'numeric',MMMMM:'narrow',MMM:'short',MMMM:'long'});
+aM=%_Call(x,bR,/L{1,5}/g);
+aa=appendToDateTimeObject(aa,'month',aM,{LL:'2-digit',
+L:'numeric',LLLLL:'narrow',LLL:'short',LLLL:'long'});
+aM=%_Call(x,bR,/d{1,2}/g);
+aa=appendToDateTimeObject(
+aa,'day',aM,{d:'numeric',dd:'2-digit'});
+aM=%_Call(x,bR,/h{1,2}/g);
+if(aM!==null){
+aa['hour12']=true;
+}
+aa=appendToDateTimeObject(
+aa,'hour',aM,{h:'numeric',hh:'2-digit'});
+aM=%_Call(x,bR,/H{1,2}/g);
+if(aM!==null){
+aa['hour12']=false;
+}
+aa=appendToDateTimeObject(
+aa,'hour',aM,{H:'numeric',HH:'2-digit'});
+aM=%_Call(x,bR,/m{1,2}/g);
+aa=appendToDateTimeObject(
+aa,'minute',aM,{m:'numeric',mm:'2-digit'});
+aM=%_Call(x,bR,/s{1,2}/g);
+aa=appendToDateTimeObject(
+aa,'second',aM,{s:'numeric',ss:'2-digit'});
+aM=%_Call(x,bR,/z|zzzz/g);
+aa=appendToDateTimeObject(
+aa,'timeZoneName',aM,{z:'short',zzzz:'long'});
+return aa;
+}
+function appendToDateTimeObject(aa,bS,aM,bU){
+if((aM===null)){
+if(!%HasOwnProperty(aa,bS)){
+defineWEProperty(aa,bS,(void 0));
+}
+return aa;
+}
+var ak=aM[0];
+defineWEProperty(aa,bS,bU[ak]);
+return aa;
+}
+function toDateTimeOptions(aa,bV,bW){
+if((aa===(void 0))){
+aa={};
+}else{
+aa=(%_ToObject(aa));
+}
+var bX=true;
+if((bV==='date'||bV==='any')&&
+(!(aa.weekday===(void 0))||!(aa.year===(void 0))||
+!(aa.month===(void 0))||!(aa.day===(void 0)))){
+bX=false;
+}
+if((bV==='time'||bV==='any')&&
+(!(aa.hour===(void 0))||!(aa.minute===(void 0))||
+!(aa.second===(void 0)))){
+bX=false;
+}
+if(bX&&(bW==='date'||bW==='all')){
+r(aa,'year',{value:'numeric',
+writable:true,
+enumerable:true,
+configurable:true});
+r(aa,'month',{value:'numeric',
+writable:true,
+enumerable:true,
+configurable:true});
+r(aa,'day',{value:'numeric',
+writable:true,
+enumerable:true,
+configurable:true});
+}
+if(bX&&(bW==='time'||bW==='all')){
+r(aa,'hour',{value:'numeric',
+writable:true,
+enumerable:true,
+configurable:true});
+r(aa,'minute',{value:'numeric',
+writable:true,
+enumerable:true,
+configurable:true});
+r(aa,'second',{value:'numeric',
+writable:true,
+enumerable:true,
+configurable:true});
+}
+return aa;
+}
+function initializeDateTimeFormat(bY,Z,aa){
+if(%IsInitializedIntlObject(bY)){
+throw o(132,"DateTimeFormat");
+}
+if((aa===(void 0))){
+aa={};
+}
+var ag=resolveLocale('dateformat',Z,aa);
+aa=toDateTimeOptions(aa,'any','date');
+var aj=getGetOption(aa,'dateformat');
+var ab=aj('formatMatcher','string',
+['basic','best fit'],'best fit');
+var bR=toLDMLString(aa);
+var bZ=canonicalizeTimeZoneID(aa.timeZone);
+var br={};
+var at=parseExtension(ag.extension);
+var ca={
+'ca':{'property':(void 0),'type':'string'},
+'nu':{'property':(void 0),'type':'string'}
+};
+var ar=setOptions(aa,at,ca,
+aj,br);
+var bw=ag.locale+ar;
+var ap=q({},{
+calendar:{writable:true},
+day:{writable:true},
+era:{writable:true},
+hour12:{writable:true},
+hour:{writable:true},
+locale:{writable:true},
+minute:{writable:true},
+month:{writable:true},
+numberingSystem:{writable:true},
+[s]:{writable:true},
+pattern:bD,
+requestedLocale:{value:bw,writable:true},
+second:{writable:true},
+timeZone:{writable:true},
+timeZoneName:{writable:true},
+tz:{value:bZ,writable:true},
+weekday:{writable:true},
+year:{writable:true}
+});
+var bO=%CreateDateTimeFormat(
+bw,{skeleton:bR,timeZone:bZ},ap);
+if(ap.timeZone==="Etc/Unknown"){
+throw n(192,bZ);
+}
+%MarkAsInitializedIntlObjectOfType(bY,'dateformat',bO);
+bY[u]=ap;
+r(bY,'resolved',bp);
+return bY;
+}
+%AddNamedProperty(D,'DateTimeFormat',function(){
+var Z=%_Arguments(0);
+var aa=%_Arguments(1);
+if(!this||this===D){
+return new D.DateTimeFormat(Z,aa);
+}
+return initializeDateTimeFormat((%_ToObject(this)),Z,aa);
+},
+2
+);
+%AddNamedProperty(D.DateTimeFormat.prototype,'resolvedOptions',function(){
+if(!(new.target===(void 0))){
+throw o(87);
+}
+if(!%IsInitializedIntlObjectOfType(this,'dateformat')){
+throw o(133,"DateTimeFormat");
+}
+var cb={
+'gregorian':'gregory',
+'japanese':'japanese',
+'buddhist':'buddhist',
+'roc':'roc',
+'persian':'persian',
+'islamic-civil':'islamicc',
+'islamic':'islamic',
+'hebrew':'hebrew',
+'chinese':'chinese',
+'indian':'indian',
+'coptic':'coptic',
+'ethiopic':'ethiopic',
+'ethiopic-amete-alem':'ethioaa'
+};
+var bP=this;
+var cc=fromLDMLString(bP[u][s]);
+var cd=cb[bP[u].calendar];
+if((cd===(void 0))){
+cd=bP[u].calendar;
+}
+var ag=getOptimalLanguageTag(bP[u].requestedLocale,
+bP[u].locale);
+var aN={
+locale:ag,
+numberingSystem:bP[u].numberingSystem,
+calendar:cd,
+timeZone:bP[u].timeZone
+};
+addWECPropertyIfDefined(aN,'timeZoneName',cc.timeZoneName);
+addWECPropertyIfDefined(aN,'era',cc.era);
+addWECPropertyIfDefined(aN,'year',cc.year);
+addWECPropertyIfDefined(aN,'month',cc.month);
+addWECPropertyIfDefined(aN,'day',cc.day);
+addWECPropertyIfDefined(aN,'weekday',cc.weekday);
+addWECPropertyIfDefined(aN,'hour12',cc.hour12);
+addWECPropertyIfDefined(aN,'hour',cc.hour);
+addWECPropertyIfDefined(aN,'minute',cc.minute);
+addWECPropertyIfDefined(aN,'second',cc.second);
+return aN;
+},
+2
+);
+%FunctionSetName(D.DateTimeFormat.prototype.resolvedOptions,
+'resolvedOptions');
+%FunctionRemovePrototype(D.DateTimeFormat.prototype.resolvedOptions);
+%SetNativeFlag(D.DateTimeFormat.prototype.resolvedOptions);
+%AddNamedProperty(D.DateTimeFormat,'supportedLocalesOf',function(Z){
+if(!(new.target===(void 0))){
+throw o(87);
+}
+return supportedLocalesOf('dateformat',Z,%_Arguments(1));
+},
+2
+);
+%FunctionSetName(D.DateTimeFormat.supportedLocalesOf,'supportedLocalesOf');
+%FunctionRemovePrototype(D.DateTimeFormat.supportedLocalesOf);
+%SetNativeFlag(D.DateTimeFormat.supportedLocalesOf);
+function formatDate(bO,ce){
+var cf;
+if((ce===(void 0))){
+cf=%DateCurrentTime();
+}else{
+cf=(%_ToNumber(ce));
+}
+if(!f(cf))throw n(161);
+return %InternalDateFormat(%GetImplFromInitializedIntlObject(bO),
+new i(cf));
+}
+function parseDate(bO,ao){
+return %InternalDateParse(%GetImplFromInitializedIntlObject(bO),
+l(ao));
+}
+addBoundMethod(D.DateTimeFormat,'format',formatDate,0);
+addBoundMethod(D.DateTimeFormat,'v8Parse',parseDate,1);
+function canonicalizeTimeZoneID(cg){
+if((cg===(void 0))){
+return cg;
+}
+var ch=%StringToUpperCase(cg);
+if(ch==='UTC'||ch==='GMT'||
+ch==='ETC/UTC'||ch==='ETC/GMT'){
+return'UTC';
+}
+var aM=%_Call(x,cg,GetTimezoneNameCheckRE());
+if((aM===null))throw n(162,cg);
+var aN=toTitleCaseTimezoneLocation(aM[1])+'/'+
+toTitleCaseTimezoneLocation(aM[2]);
+if(!(aM[3]===(void 0))&&3<aM.length){
+var ci=%_Call(z,aM[3],'/');
+for(var af=1;af<ci.length;af++){
+aN=aN+'/'+toTitleCaseTimezoneLocation(ci[af]);
+}
+}
+return aN;
+}
+function initializeBreakIterator(cj,Z,aa){
+if(%IsInitializedIntlObject(cj)){
+throw o(132,"v8BreakIterator");
+}
+if((aa===(void 0))){
+aa={};
+}
+var aj=getGetOption(aa,'breakiterator');
+var br={};
+defineWEProperty(br,'type',aj(
+'type','string',['character','word','sentence','line'],'word'));
+var ag=resolveLocale('breakiterator',Z,aa);
+var ap=q({},{
+requestedLocale:{value:ag.locale,writable:true},
+type:{value:br.type,writable:true},
+locale:{writable:true}
+});
+var ck=%CreateBreakIterator(ag.locale,
+br,
+ap);
+%MarkAsInitializedIntlObjectOfType(cj,'breakiterator',
+ck);
+cj[u]=ap;
+r(cj,'resolved',bp);
+return cj;
+}
+%AddNamedProperty(D,'v8BreakIterator',function(){
+var Z=%_Arguments(0);
+var aa=%_Arguments(1);
+if(!this||this===D){
+return new D.v8BreakIterator(Z,aa);
+}
+return initializeBreakIterator((%_ToObject(this)),Z,aa);
+},
+2
+);
+%AddNamedProperty(D.v8BreakIterator.prototype,'resolvedOptions',
+function(){
+if(!(new.target===(void 0))){
+throw o(87);
+}
+if(!%IsInitializedIntlObjectOfType(this,'breakiterator')){
+throw o(133,"v8BreakIterator");
+}
+var cl=this;
+var ag=
+getOptimalLanguageTag(cl[u].requestedLocale,
+cl[u].locale);
+return{
+locale:ag,
+type:cl[u].type
+};
+},
+2
+);
+%FunctionSetName(D.v8BreakIterator.prototype.resolvedOptions,
+'resolvedOptions');
+%FunctionRemovePrototype(D.v8BreakIterator.prototype.resolvedOptions);
+%SetNativeFlag(D.v8BreakIterator.prototype.resolvedOptions);
+%AddNamedProperty(D.v8BreakIterator,'supportedLocalesOf',
+function(Z){
+if(!(new.target===(void 0))){
+throw o(87);
+}
+return supportedLocalesOf('breakiterator',Z,%_Arguments(1));
+},
+2
+);
+%FunctionSetName(D.v8BreakIterator.supportedLocalesOf,'supportedLocalesOf');
+%FunctionRemovePrototype(D.v8BreakIterator.supportedLocalesOf);
+%SetNativeFlag(D.v8BreakIterator.supportedLocalesOf);
+function adoptText(cj,cm){
+%BreakIteratorAdoptText(%GetImplFromInitializedIntlObject(cj),
+l(cm));
+}
+function first(cj){
+return %BreakIteratorFirst(%GetImplFromInitializedIntlObject(cj));
+}
+function next(cj){
+return %BreakIteratorNext(%GetImplFromInitializedIntlObject(cj));
+}
+function current(cj){
+return %BreakIteratorCurrent(%GetImplFromInitializedIntlObject(cj));
+}
+function breakType(cj){
+return %BreakIteratorBreakType(%GetImplFromInitializedIntlObject(cj));
+}
+addBoundMethod(D.v8BreakIterator,'adoptText',adoptText,1);
+addBoundMethod(D.v8BreakIterator,'first',first,0);
+addBoundMethod(D.v8BreakIterator,'next',next,0);
+addBoundMethod(D.v8BreakIterator,'current',current,0);
+addBoundMethod(D.v8BreakIterator,'breakType',breakType,0);
+var cn={
+'collator':D.Collator,
+'numberformat':D.NumberFormat,
+'dateformatall':D.DateTimeFormat,
+'dateformatdate':D.DateTimeFormat,
+'dateformattime':D.DateTimeFormat
+};
+var co={
+'collator':(void 0),
+'numberformat':(void 0),
+'dateformatall':(void 0),
+'dateformatdate':(void 0),
+'dateformattime':(void 0),
+};
+function cachedOrNewService(Y,Z,aa,bW){
+var cp=((bW===(void 0)))?aa:bW;
+if((Z===(void 0))&&(aa===(void 0))){
+if((co[Y]===(void 0))){
+co[Y]=new cn[Y](Z,cp);
+}
+return co[Y];
+}
+return new cn[Y](Z,cp);
+}
+function OverrideFunction(aJ,cq,cr){
+%CheckIsBootstrapping();
+r(aJ,cq,{value:cr,
+writeable:true,
+configurable:true,
+enumerable:false});
+%FunctionSetName(cr,cq);
+%FunctionRemovePrototype(cr);
+%SetNativeFlag(cr);
+}
+OverrideFunction(l.prototype,'localeCompare',function(U){
+if(!(new.target===(void 0))){
+throw o(87);
+}
+if((this==null)){
+throw o(52);
+}
+var Z=%_Arguments(1);
+var aa=%_Arguments(2);
+var bq=cachedOrNewService('collator',Z,aa);
+return compare(bq,this,U);
+}
+);
+OverrideFunction(l.prototype,'normalize',function(){
+if(!(new.target===(void 0))){
+throw o(87);
+}
+if((%IS_VAR(this)===null)||(this===(void 0)))throw o(17,"String.prototype.normalize");
+var cs=(%_ToString(this));
+var ct=%_Arguments(0);
+var cu=(ct===(void 0))?'NFC':(%_ToString(ct));
+var cv=['NFC','NFD','NFKC','NFKD'];
+var cw=%_Call(c,cv,cu);
+if(cw===-1){
+throw n(184,
+%_Call(d,cv,', '));
+}
+return %StringNormalize(cs,cw);
+}
+);
+OverrideFunction(j.prototype,'toLocaleString',function(){
+if(!(new.target===(void 0))){
+throw o(87);
+}
+if(!(this instanceof j)&&typeof(this)!=='number'){
+throw o(53,"Number");
+}
+var Z=%_Arguments(0);
+var aa=%_Arguments(1);
+var bE=cachedOrNewService('numberformat',Z,aa);
+return formatNumber(bE,this);
+}
+);
+function toLocaleDateTime(cx,Z,aa,bV,bW,Y){
+if(!(cx instanceof i)){
+throw o(53,"Date");
+}
+if(g(cx))return'Invalid Date';
+var br=toDateTimeOptions(aa,bV,bW);
+var bY=
+cachedOrNewService(Y,Z,aa,br);
+return formatDate(bY,cx);
+}
+OverrideFunction(i.prototype,'toLocaleString',function(){
+if(!(new.target===(void 0))){
+throw o(87);
+}
+var Z=%_Arguments(0);
+var aa=%_Arguments(1);
+return toLocaleDateTime(
+this,Z,aa,'any','all','dateformatall');
+}
+);
+OverrideFunction(i.prototype,'toLocaleDateString',function(){
+if(!(new.target===(void 0))){
+throw o(87);
+}
+var Z=%_Arguments(0);
+var aa=%_Arguments(1);
+return toLocaleDateTime(
+this,Z,aa,'date','date','dateformatdate');
+}
+);
+OverrideFunction(i.prototype,'toLocaleTimeString',function(){
+if(!(new.target===(void 0))){
+throw o(87);
+}
+var Z=%_Arguments(0);
+var aa=%_Arguments(1);
+return toLocaleDateTime(
+this,Z,aa,'time','time','dateformattime');
+}
+);
+})
+
+,proxy		
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Proxy;
+var d;
+b.Import(function(e){
+d=e.MakeTypeError;
+});
+function ProxyCreateRevocable(f,g){
+var h=new c(f,g);
+return{proxy:h,revoke:()=>%JSProxyRevoke(h)};
+}
+function ProxyEnumerate(i,g,f){
+var j=%_Call(i,g,f);
+if(!(%_IsJSReceiver(j))){
+throw d(99);
+}
+var k=[];
+for(var l=j.next();!l.done;l=j.next()){
+var m=l.value;
+if(!(typeof(m)==='string')){
+throw d(100);
+}
+k.push(m);
+}
+return k;
+}
+b.InstallFunctions(c,2,[
+"revocable",ProxyCreateRevocable
+]);
+%InstallToContext([
+"proxy_enumerate",ProxyEnumerate,
+]);
+})
+
+$generator�
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=b.ImportNow("GeneratorFunctionPrototype");
+var d=b.ImportNow("GeneratorFunction");
+var e=a.Function;
+var f;
+var g=b.ImportNow("to_string_tag_symbol");
+b.Import(function(h){
+f=h.MakeTypeError;
+});
+function GeneratorObjectNext(i){
+if(!(%_ClassOf(this)==='Generator')){
+throw f(42,
+'[Generator].prototype.next',this);
+}
+var j=%GeneratorGetContinuation(this);
+if(j>0){
+if(%_DebugIsActive()!=0)%DebugPrepareStepInIfStepping(this);
+try{
+return %_GeneratorNext(this,i);
+}catch(e){
+%GeneratorClose(this);
+throw e;
+}
+}else if(j==0){
+return{value:void 0,done:true};
+}else{
+throw f(40);
+}
+}
+function GeneratorObjectThrow(k){
+if(!(%_ClassOf(this)==='Generator')){
+throw f(42,
+'[Generator].prototype.throw',this);
+}
+var j=%GeneratorGetContinuation(this);
+if(j>0){
+try{
+return %_GeneratorThrow(this,k);
+}catch(e){
+%GeneratorClose(this);
+throw e;
+}
+}else if(j==0){
+throw k;
+}else{
+throw f(40);
+}
+}
+%NeverOptimizeFunction(GeneratorObjectNext);
+%NeverOptimizeFunction(GeneratorObjectThrow);
+var l=c.prototype;
+b.InstallFunctions(l,
+2,
+["next",GeneratorObjectNext,
+"throw",GeneratorObjectThrow]);
+%AddNamedProperty(l,"constructor",
+c,2|1);
+%AddNamedProperty(l,
+g,"Generator",2|1);
+%InternalSetPrototype(c,e.prototype);
+%AddNamedProperty(c,
+g,"GeneratorFunction",2|1);
+%AddNamedProperty(c,"constructor",
+d,2|1);
+%InternalSetPrototype(d,e);
+})
+
+<harmony-atomicsM:
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Object;
+var d;
+var e;
+var f=b.ImportNow("to_string_tag_symbol");
+b.Import(function(g){
+d=g.MakeTypeError;
+e=g.MaxSimple;
+});
+function CheckSharedIntegerTypedArray(h){
+if(!%IsSharedIntegerTypedArray(h)){
+throw d(70,h);
+}
+}
+function CheckSharedInteger32TypedArray(h){
+CheckSharedIntegerTypedArray(h);
+if(!%IsSharedInteger32TypedArray(h)){
+throw d(71,h);
+}
+}
+function AtomicsCompareExchangeJS(i,j,k,l){
+CheckSharedIntegerTypedArray(i);
+j=(%_ToInteger(j));
+if(j<0||j>=%_TypedArrayGetLength(i)){
+return(void 0);
+}
+k=(%_ToNumber(k));
+l=(%_ToNumber(l));
+return %_AtomicsCompareExchange(i,j,k,l);
+}
+function AtomicsLoadJS(i,j){
+CheckSharedIntegerTypedArray(i);
+j=(%_ToInteger(j));
+if(j<0||j>=%_TypedArrayGetLength(i)){
+return(void 0);
+}
+return %_AtomicsLoad(i,j);
+}
+function AtomicsStoreJS(i,j,m){
+CheckSharedIntegerTypedArray(i);
+j=(%_ToInteger(j));
+if(j<0||j>=%_TypedArrayGetLength(i)){
+return(void 0);
+}
+m=(%_ToNumber(m));
+return %_AtomicsStore(i,j,m);
+}
+function AtomicsAddJS(h,j,m){
+CheckSharedIntegerTypedArray(h);
+j=(%_ToInteger(j));
+if(j<0||j>=%_TypedArrayGetLength(h)){
+return(void 0);
+}
+m=(%_ToNumber(m));
+return %_AtomicsAdd(h,j,m);
+}
+function AtomicsSubJS(h,j,m){
+CheckSharedIntegerTypedArray(h);
+j=(%_ToInteger(j));
+if(j<0||j>=%_TypedArrayGetLength(h)){
+return(void 0);
+}
+m=(%_ToNumber(m));
+return %_AtomicsSub(h,j,m);
+}
+function AtomicsAndJS(h,j,m){
+CheckSharedIntegerTypedArray(h);
+j=(%_ToInteger(j));
+if(j<0||j>=%_TypedArrayGetLength(h)){
+return(void 0);
+}
+m=(%_ToNumber(m));
+return %_AtomicsAnd(h,j,m);
+}
+function AtomicsOrJS(h,j,m){
+CheckSharedIntegerTypedArray(h);
+j=(%_ToInteger(j));
+if(j<0||j>=%_TypedArrayGetLength(h)){
+return(void 0);
+}
+m=(%_ToNumber(m));
+return %_AtomicsOr(h,j,m);
+}
+function AtomicsXorJS(h,j,m){
+CheckSharedIntegerTypedArray(h);
+j=(%_ToInteger(j));
+if(j<0||j>=%_TypedArrayGetLength(h)){
+return(void 0);
+}
+m=(%_ToNumber(m));
+return %_AtomicsXor(h,j,m);
+}
+function AtomicsExchangeJS(h,j,m){
+CheckSharedIntegerTypedArray(h);
+j=(%_ToInteger(j));
+if(j<0||j>=%_TypedArrayGetLength(h)){
+return(void 0);
+}
+m=(%_ToNumber(m));
+return %_AtomicsExchange(h,j,m);
+}
+function AtomicsIsLockFreeJS(n){
+return %_AtomicsIsLockFree(n);
+}
+function AtomicsFutexWaitJS(h,j,m,o){
+CheckSharedInteger32TypedArray(h);
+j=(%_ToInteger(j));
+if(j<0||j>=%_TypedArrayGetLength(h)){
+return(void 0);
+}
+if((o===(void 0))){
+o=(1/0);
+}else{
+o=(%_ToNumber(o));
+if((!%_IsSmi(%IS_VAR(o))&&!(o==o))){
+o=(1/0);
+}else{
+o=e(0,o);
+}
+}
+return %AtomicsFutexWait(h,j,m,o);
+}
+function AtomicsFutexWakeJS(h,j,p){
+CheckSharedInteger32TypedArray(h);
+j=(%_ToInteger(j));
+if(j<0||j>=%_TypedArrayGetLength(h)){
+return(void 0);
+}
+p=e(0,(%_ToInteger(p)));
+return %AtomicsFutexWake(h,j,p);
+}
+function AtomicsFutexWakeOrRequeueJS(h,q,p,m,r){
+CheckSharedInteger32TypedArray(h);
+q=(%_ToInteger(q));
+p=e(0,(%_ToInteger(p)));
+m=((m)|0);
+r=(%_ToInteger(r));
+if(q<0||q>=%_TypedArrayGetLength(h)||
+r<0||r>=%_TypedArrayGetLength(h)){
+return(void 0);
+}
+return %AtomicsFutexWakeOrRequeue(h,q,p,m,r);
+}
+function AtomicsConstructor(){}
+var s=new AtomicsConstructor();
+%InternalSetPrototype(s,c.prototype);
+%AddNamedProperty(a,"Atomics",s,2);
+%FunctionSetInstanceClassName(AtomicsConstructor,'Atomics');
+%AddNamedProperty(s,f,"Atomics",1|2);
+b.InstallConstants(s,[
+"OK",0,
+"NOTEQUAL",-1,
+"TIMEDOUT",-2,
+]);
+b.InstallFunctions(s,2,[
+"compareExchange",AtomicsCompareExchangeJS,
+"load",AtomicsLoadJS,
+"store",AtomicsStoreJS,
+"add",AtomicsAddJS,
+"sub",AtomicsSubJS,
+"and",AtomicsAndJS,
+"or",AtomicsOrJS,
+"xor",AtomicsXorJS,
+"exchange",AtomicsExchangeJS,
+"isLockFree",AtomicsIsLockFreeJS,
+"futexWait",AtomicsFutexWaitJS,
+"futexWake",AtomicsFutexWakeJS,
+"futexWakeOrRequeue",AtomicsFutexWakeOrRequeueJS,
+]);
+})
+
+8harmony-regexp%
+(function(a,b){
+'use strict';
+%CheckIsBootstrapping();
+var c=a.RegExp;
+var d=c.prototype;
+var e;
+var f=b.ImportNow("regexp_flags_symbol");
+b.Import(function(g){
+e=g.MakeTypeError;
+});
+function RegExpGetFlags(){
+if(!(%_IsJSReceiver(this))){
+throw e(
+130,"RegExp.prototype.flags",(%_ToString(this)));
+}
+var h='';
+if(this.global)h+='g';
+if(this.ignoreCase)h+='i';
+if(this.multiline)h+='m';
+if(this.unicode)h+='u';
+if(this.sticky)h+='y';
+return h;
+}
+function RegExpGetSticky(){
+if(!(%_IsRegExp(this))){
+if(this===d){
+%IncrementUseCounter(11);
+return(void 0);
+}
+throw e(131,"RegExp.prototype.sticky");
+}
+return!!(%_RegExpFlags(this)&8);
+}
+%FunctionSetName(RegExpGetSticky,"RegExp.prototype.sticky");
+%SetNativeFlag(RegExpGetSticky);
+b.InstallGetter(c.prototype,'flags',RegExpGetFlags);
+b.InstallGetter(c.prototype,'sticky',RegExpGetSticky);
+})
+
+<harmony-reflect�
+(function(a,b){
+'use strict';
+%CheckIsBootstrapping();
+var c=a.Reflect;
+var d;
+var e=b.ImportNow("reflect_apply");
+var f=b.ImportNow("reflect_construct");
+b.Import(function(g){
+d=g.MakeTypeError;
+});
+function ReflectEnumerate(h){
+if(!(%_IsJSReceiver(h)))
+throw d(16,"Reflect.enumerate")
+return(function*(){for(var i in h)yield i})();
+}
+b.InstallFunctions(c,2,[
+"apply",e,
+"construct",f,
+"enumerate",ReflectEnumerate
+]);
+})
+
+Xharmony-object-observeU
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=b.ImportNow("ObserveArrayMethods");
+var d=b.ImportNow("ObserveObjectMethods");;
+b.InstallFunctions(a.Object,2,d);
+b.InstallFunctions(a.Array,2,c);
+})
+
+dharmony-sharedarraybufferE
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.SharedArrayBuffer;
+var d;
+b.Import(function(e){
+d=e.MakeTypeError;
+})
+function SharedArrayBufferGetByteLen(){
+if(!(%_ClassOf(this)==='SharedArrayBuffer')){
+throw d(42,
+'SharedArrayBuffer.prototype.byteLength',this);
+}
+return %_ArrayBufferGetByteLength(this);
+}
+b.InstallGetter(c.prototype,"byteLength",
+SharedArrayBufferGetByteLen);
+})
+
+0harmony-simd��
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.SIMD;
+var d;
+var e=b.ImportNow("to_string_tag_symbol");
+b.Import(function(f){
+d=f.MakeTypeError;
+});
+var g=c.Float32x4;
+
+
+var h=c.Int32x4;
+
+var i=c.Int16x8;
+
+var j=c.Int8x16;
+
+
+var k=c.Uint32x4;
+
+var l=c.Uint16x8;
+
+var m=c.Uint8x16;
+
+
+var n=c.Bool32x4;
+
+var o=c.Bool16x8;
+
+var p=c.Bool8x16;
+
+
+
+function Float32x4CheckJS(q){
+return %Float32x4Check(q);
+}
+function Float32x4ToString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='float32x4'){
+throw d(42,
+"Float32x4.prototype.toString",this);
+}
+var s="SIMD.Float32x4(";
+s+=%Float32x4ExtractLane(r,0);
+for(var t=1;t<4;t++){
+s+=", "+%Float32x4ExtractLane(r,t);
+}
+return s+")";
+}
+function Float32x4ToLocaleString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='float32x4'){
+throw d(42,
+"Float32x4.prototype.toLocaleString",this);
+}
+var s="SIMD.Float32x4(";
+s+=%Float32x4ExtractLane(r,0).toLocaleString();
+for(var t=1;t<4;t++){
+s+=", "+%Float32x4ExtractLane(r,t).toLocaleString();
+}
+return s+")";
+}
+function Float32x4ValueOf(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='float32x4'){
+throw d(42,
+"Float32x4.prototype.valueOf",this);
+}
+return r;
+}
+function Float32x4ExtractLaneJS(u,v){
+return %Float32x4ExtractLane(u,v);
+}
+
+
+function Int32x4CheckJS(q){
+return %Int32x4Check(q);
+}
+function Int32x4ToString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='int32x4'){
+throw d(42,
+"Int32x4.prototype.toString",this);
+}
+var s="SIMD.Int32x4(";
+s+=%Int32x4ExtractLane(r,0);
+for(var t=1;t<4;t++){
+s+=", "+%Int32x4ExtractLane(r,t);
+}
+return s+")";
+}
+function Int32x4ToLocaleString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='int32x4'){
+throw d(42,
+"Int32x4.prototype.toLocaleString",this);
+}
+var s="SIMD.Int32x4(";
+s+=%Int32x4ExtractLane(r,0).toLocaleString();
+for(var t=1;t<4;t++){
+s+=", "+%Int32x4ExtractLane(r,t).toLocaleString();
+}
+return s+")";
+}
+function Int32x4ValueOf(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='int32x4'){
+throw d(42,
+"Int32x4.prototype.valueOf",this);
+}
+return r;
+}
+function Int32x4ExtractLaneJS(u,v){
+return %Int32x4ExtractLane(u,v);
+}
+
+function Int16x8CheckJS(q){
+return %Int16x8Check(q);
+}
+function Int16x8ToString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='int16x8'){
+throw d(42,
+"Int16x8.prototype.toString",this);
+}
+var s="SIMD.Int16x8(";
+s+=%Int16x8ExtractLane(r,0);
+for(var t=1;t<8;t++){
+s+=", "+%Int16x8ExtractLane(r,t);
+}
+return s+")";
+}
+function Int16x8ToLocaleString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='int16x8'){
+throw d(42,
+"Int16x8.prototype.toLocaleString",this);
+}
+var s="SIMD.Int16x8(";
+s+=%Int16x8ExtractLane(r,0).toLocaleString();
+for(var t=1;t<8;t++){
+s+=", "+%Int16x8ExtractLane(r,t).toLocaleString();
+}
+return s+")";
+}
+function Int16x8ValueOf(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='int16x8'){
+throw d(42,
+"Int16x8.prototype.valueOf",this);
+}
+return r;
+}
+function Int16x8ExtractLaneJS(u,v){
+return %Int16x8ExtractLane(u,v);
+}
+
+function Int8x16CheckJS(q){
+return %Int8x16Check(q);
+}
+function Int8x16ToString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='int8x16'){
+throw d(42,
+"Int8x16.prototype.toString",this);
+}
+var s="SIMD.Int8x16(";
+s+=%Int8x16ExtractLane(r,0);
+for(var t=1;t<16;t++){
+s+=", "+%Int8x16ExtractLane(r,t);
+}
+return s+")";
+}
+function Int8x16ToLocaleString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='int8x16'){
+throw d(42,
+"Int8x16.prototype.toLocaleString",this);
+}
+var s="SIMD.Int8x16(";
+s+=%Int8x16ExtractLane(r,0).toLocaleString();
+for(var t=1;t<16;t++){
+s+=", "+%Int8x16ExtractLane(r,t).toLocaleString();
+}
+return s+")";
+}
+function Int8x16ValueOf(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='int8x16'){
+throw d(42,
+"Int8x16.prototype.valueOf",this);
+}
+return r;
+}
+function Int8x16ExtractLaneJS(u,v){
+return %Int8x16ExtractLane(u,v);
+}
+
+
+function Uint32x4CheckJS(q){
+return %Uint32x4Check(q);
+}
+function Uint32x4ToString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='uint32x4'){
+throw d(42,
+"Uint32x4.prototype.toString",this);
+}
+var s="SIMD.Uint32x4(";
+s+=%Uint32x4ExtractLane(r,0);
+for(var t=1;t<4;t++){
+s+=", "+%Uint32x4ExtractLane(r,t);
+}
+return s+")";
+}
+function Uint32x4ToLocaleString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='uint32x4'){
+throw d(42,
+"Uint32x4.prototype.toLocaleString",this);
+}
+var s="SIMD.Uint32x4(";
+s+=%Uint32x4ExtractLane(r,0).toLocaleString();
+for(var t=1;t<4;t++){
+s+=", "+%Uint32x4ExtractLane(r,t).toLocaleString();
+}
+return s+")";
+}
+function Uint32x4ValueOf(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='uint32x4'){
+throw d(42,
+"Uint32x4.prototype.valueOf",this);
+}
+return r;
+}
+function Uint32x4ExtractLaneJS(u,v){
+return %Uint32x4ExtractLane(u,v);
+}
+
+function Uint16x8CheckJS(q){
+return %Uint16x8Check(q);
+}
+function Uint16x8ToString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='uint16x8'){
+throw d(42,
+"Uint16x8.prototype.toString",this);
+}
+var s="SIMD.Uint16x8(";
+s+=%Uint16x8ExtractLane(r,0);
+for(var t=1;t<8;t++){
+s+=", "+%Uint16x8ExtractLane(r,t);
+}
+return s+")";
+}
+function Uint16x8ToLocaleString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='uint16x8'){
+throw d(42,
+"Uint16x8.prototype.toLocaleString",this);
+}
+var s="SIMD.Uint16x8(";
+s+=%Uint16x8ExtractLane(r,0).toLocaleString();
+for(var t=1;t<8;t++){
+s+=", "+%Uint16x8ExtractLane(r,t).toLocaleString();
+}
+return s+")";
+}
+function Uint16x8ValueOf(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='uint16x8'){
+throw d(42,
+"Uint16x8.prototype.valueOf",this);
+}
+return r;
+}
+function Uint16x8ExtractLaneJS(u,v){
+return %Uint16x8ExtractLane(u,v);
+}
+
+function Uint8x16CheckJS(q){
+return %Uint8x16Check(q);
+}
+function Uint8x16ToString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='uint8x16'){
+throw d(42,
+"Uint8x16.prototype.toString",this);
+}
+var s="SIMD.Uint8x16(";
+s+=%Uint8x16ExtractLane(r,0);
+for(var t=1;t<16;t++){
+s+=", "+%Uint8x16ExtractLane(r,t);
+}
+return s+")";
+}
+function Uint8x16ToLocaleString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='uint8x16'){
+throw d(42,
+"Uint8x16.prototype.toLocaleString",this);
+}
+var s="SIMD.Uint8x16(";
+s+=%Uint8x16ExtractLane(r,0).toLocaleString();
+for(var t=1;t<16;t++){
+s+=", "+%Uint8x16ExtractLane(r,t).toLocaleString();
+}
+return s+")";
+}
+function Uint8x16ValueOf(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='uint8x16'){
+throw d(42,
+"Uint8x16.prototype.valueOf",this);
+}
+return r;
+}
+function Uint8x16ExtractLaneJS(u,v){
+return %Uint8x16ExtractLane(u,v);
+}
+
+
+function Bool32x4CheckJS(q){
+return %Bool32x4Check(q);
+}
+function Bool32x4ToString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='bool32x4'){
+throw d(42,
+"Bool32x4.prototype.toString",this);
+}
+var s="SIMD.Bool32x4(";
+s+=%Bool32x4ExtractLane(r,0);
+for(var t=1;t<4;t++){
+s+=", "+%Bool32x4ExtractLane(r,t);
+}
+return s+")";
+}
+function Bool32x4ToLocaleString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='bool32x4'){
+throw d(42,
+"Bool32x4.prototype.toLocaleString",this);
+}
+var s="SIMD.Bool32x4(";
+s+=%Bool32x4ExtractLane(r,0).toLocaleString();
+for(var t=1;t<4;t++){
+s+=", "+%Bool32x4ExtractLane(r,t).toLocaleString();
+}
+return s+")";
+}
+function Bool32x4ValueOf(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='bool32x4'){
+throw d(42,
+"Bool32x4.prototype.valueOf",this);
+}
+return r;
+}
+function Bool32x4ExtractLaneJS(u,v){
+return %Bool32x4ExtractLane(u,v);
+}
+
+function Bool16x8CheckJS(q){
+return %Bool16x8Check(q);
+}
+function Bool16x8ToString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='bool16x8'){
+throw d(42,
+"Bool16x8.prototype.toString",this);
+}
+var s="SIMD.Bool16x8(";
+s+=%Bool16x8ExtractLane(r,0);
+for(var t=1;t<8;t++){
+s+=", "+%Bool16x8ExtractLane(r,t);
+}
+return s+")";
+}
+function Bool16x8ToLocaleString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='bool16x8'){
+throw d(42,
+"Bool16x8.prototype.toLocaleString",this);
+}
+var s="SIMD.Bool16x8(";
+s+=%Bool16x8ExtractLane(r,0).toLocaleString();
+for(var t=1;t<8;t++){
+s+=", "+%Bool16x8ExtractLane(r,t).toLocaleString();
+}
+return s+")";
+}
+function Bool16x8ValueOf(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='bool16x8'){
+throw d(42,
+"Bool16x8.prototype.valueOf",this);
+}
+return r;
+}
+function Bool16x8ExtractLaneJS(u,v){
+return %Bool16x8ExtractLane(u,v);
+}
+
+function Bool8x16CheckJS(q){
+return %Bool8x16Check(q);
+}
+function Bool8x16ToString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='bool8x16'){
+throw d(42,
+"Bool8x16.prototype.toString",this);
+}
+var s="SIMD.Bool8x16(";
+s+=%Bool8x16ExtractLane(r,0);
+for(var t=1;t<16;t++){
+s+=", "+%Bool8x16ExtractLane(r,t);
+}
+return s+")";
+}
+function Bool8x16ToLocaleString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='bool8x16'){
+throw d(42,
+"Bool8x16.prototype.toLocaleString",this);
+}
+var s="SIMD.Bool8x16(";
+s+=%Bool8x16ExtractLane(r,0).toLocaleString();
+for(var t=1;t<16;t++){
+s+=", "+%Bool8x16ExtractLane(r,t).toLocaleString();
+}
+return s+")";
+}
+function Bool8x16ValueOf(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='bool8x16'){
+throw d(42,
+"Bool8x16.prototype.valueOf",this);
+}
+return r;
+}
+function Bool8x16ExtractLaneJS(u,v){
+return %Bool8x16ExtractLane(u,v);
+}
+
+
+
+function Int32x4ShiftLeftByScalarJS(u,w){
+return %Int32x4ShiftLeftByScalar(u,w);
+}
+function Int32x4ShiftRightByScalarJS(u,w){
+return %Int32x4ShiftRightByScalar(u,w);
+}
+
+function Int16x8ShiftLeftByScalarJS(u,w){
+return %Int16x8ShiftLeftByScalar(u,w);
+}
+function Int16x8ShiftRightByScalarJS(u,w){
+return %Int16x8ShiftRightByScalar(u,w);
+}
+
+function Int8x16ShiftLeftByScalarJS(u,w){
+return %Int8x16ShiftLeftByScalar(u,w);
+}
+function Int8x16ShiftRightByScalarJS(u,w){
+return %Int8x16ShiftRightByScalar(u,w);
+}
+
+
+function Uint32x4ShiftLeftByScalarJS(u,w){
+return %Uint32x4ShiftLeftByScalar(u,w);
+}
+function Uint32x4ShiftRightByScalarJS(u,w){
+return %Uint32x4ShiftRightByScalar(u,w);
+}
+
+function Uint16x8ShiftLeftByScalarJS(u,w){
+return %Uint16x8ShiftLeftByScalar(u,w);
+}
+function Uint16x8ShiftRightByScalarJS(u,w){
+return %Uint16x8ShiftRightByScalar(u,w);
+}
+
+function Uint8x16ShiftLeftByScalarJS(u,w){
+return %Uint8x16ShiftLeftByScalar(u,w);
+}
+function Uint8x16ShiftRightByScalarJS(u,w){
+return %Uint8x16ShiftRightByScalar(u,w);
+}
+
+
+function Int16x8AddSaturateJS(q,x){
+return %Int16x8AddSaturate(q,x);
+}
+function Int16x8SubSaturateJS(q,x){
+return %Int16x8SubSaturate(q,x);
+}
+
+function Int8x16AddSaturateJS(q,x){
+return %Int8x16AddSaturate(q,x);
+}
+function Int8x16SubSaturateJS(q,x){
+return %Int8x16SubSaturate(q,x);
+}
+
+function Uint8x16AddSaturateJS(q,x){
+return %Uint8x16AddSaturate(q,x);
+}
+function Uint8x16SubSaturateJS(q,x){
+return %Uint8x16SubSaturate(q,x);
+}
+
+function Uint16x8AddSaturateJS(q,x){
+return %Uint16x8AddSaturate(q,x);
+}
+function Uint16x8SubSaturateJS(q,x){
+return %Uint16x8SubSaturate(q,x);
+}
+
+
+function Float32x4NegJS(q){
+return %Float32x4Neg(q);
+}
+
+
+function Int32x4NegJS(q){
+return %Int32x4Neg(q);
+}
+
+function Int16x8NegJS(q){
+return %Int16x8Neg(q);
+}
+
+function Int8x16NegJS(q){
+return %Int8x16Neg(q);
+}
+
+
+function Bool32x4ReplaceLaneJS(u,v,r){
+return %Bool32x4ReplaceLane(u,v,r);
+}
+function Bool32x4AnyTrueJS(y){
+return %Bool32x4AnyTrue(y);
+}
+function Bool32x4AllTrueJS(y){
+return %Bool32x4AllTrue(y);
+}
+
+function Bool16x8ReplaceLaneJS(u,v,r){
+return %Bool16x8ReplaceLane(u,v,r);
+}
+function Bool16x8AnyTrueJS(y){
+return %Bool16x8AnyTrue(y);
+}
+function Bool16x8AllTrueJS(y){
+return %Bool16x8AllTrue(y);
+}
+
+function Bool8x16ReplaceLaneJS(u,v,r){
+return %Bool8x16ReplaceLane(u,v,r);
+}
+function Bool8x16AnyTrueJS(y){
+return %Bool8x16AnyTrue(y);
+}
+function Bool8x16AllTrueJS(y){
+return %Bool8x16AllTrue(y);
+}
+
+
+function Float32x4ReplaceLaneJS(u,v,r){
+return %Float32x4ReplaceLane(u,v,(%_ToNumber(r)));
+}
+function Float32x4SelectJS(z,q,x){
+return %Float32x4Select(z,q,x);
+}
+function Float32x4AddJS(q,x){
+return %Float32x4Add(q,x);
+}
+function Float32x4SubJS(q,x){
+return %Float32x4Sub(q,x);
+}
+function Float32x4MulJS(q,x){
+return %Float32x4Mul(q,x);
+}
+function Float32x4MinJS(q,x){
+return %Float32x4Min(q,x);
+}
+function Float32x4MaxJS(q,x){
+return %Float32x4Max(q,x);
+}
+function Float32x4EqualJS(q,x){
+return %Float32x4Equal(q,x);
+}
+function Float32x4NotEqualJS(q,x){
+return %Float32x4NotEqual(q,x);
+}
+function Float32x4LessThanJS(q,x){
+return %Float32x4LessThan(q,x);
+}
+function Float32x4LessThanOrEqualJS(q,x){
+return %Float32x4LessThanOrEqual(q,x);
+}
+function Float32x4GreaterThanJS(q,x){
+return %Float32x4GreaterThan(q,x);
+}
+function Float32x4GreaterThanOrEqualJS(q,x){
+return %Float32x4GreaterThanOrEqual(q,x);
+}
+function Float32x4LoadJS(A,B){
+return %Float32x4Load(A,B);
+}
+function Float32x4StoreJS(A,B,q){
+return %Float32x4Store(A,B,q);
+}
+
+
+function Int32x4ReplaceLaneJS(u,v,r){
+return %Int32x4ReplaceLane(u,v,(%_ToNumber(r)));
+}
+function Int32x4SelectJS(z,q,x){
+return %Int32x4Select(z,q,x);
+}
+function Int32x4AddJS(q,x){
+return %Int32x4Add(q,x);
+}
+function Int32x4SubJS(q,x){
+return %Int32x4Sub(q,x);
+}
+function Int32x4MulJS(q,x){
+return %Int32x4Mul(q,x);
+}
+function Int32x4MinJS(q,x){
+return %Int32x4Min(q,x);
+}
+function Int32x4MaxJS(q,x){
+return %Int32x4Max(q,x);
+}
+function Int32x4EqualJS(q,x){
+return %Int32x4Equal(q,x);
+}
+function Int32x4NotEqualJS(q,x){
+return %Int32x4NotEqual(q,x);
+}
+function Int32x4LessThanJS(q,x){
+return %Int32x4LessThan(q,x);
+}
+function Int32x4LessThanOrEqualJS(q,x){
+return %Int32x4LessThanOrEqual(q,x);
+}
+function Int32x4GreaterThanJS(q,x){
+return %Int32x4GreaterThan(q,x);
+}
+function Int32x4GreaterThanOrEqualJS(q,x){
+return %Int32x4GreaterThanOrEqual(q,x);
+}
+function Int32x4LoadJS(A,B){
+return %Int32x4Load(A,B);
+}
+function Int32x4StoreJS(A,B,q){
+return %Int32x4Store(A,B,q);
+}
+
+function Int16x8ReplaceLaneJS(u,v,r){
+return %Int16x8ReplaceLane(u,v,(%_ToNumber(r)));
+}
+function Int16x8SelectJS(z,q,x){
+return %Int16x8Select(z,q,x);
+}
+function Int16x8AddJS(q,x){
+return %Int16x8Add(q,x);
+}
+function Int16x8SubJS(q,x){
+return %Int16x8Sub(q,x);
+}
+function Int16x8MulJS(q,x){
+return %Int16x8Mul(q,x);
+}
+function Int16x8MinJS(q,x){
+return %Int16x8Min(q,x);
+}
+function Int16x8MaxJS(q,x){
+return %Int16x8Max(q,x);
+}
+function Int16x8EqualJS(q,x){
+return %Int16x8Equal(q,x);
+}
+function Int16x8NotEqualJS(q,x){
+return %Int16x8NotEqual(q,x);
+}
+function Int16x8LessThanJS(q,x){
+return %Int16x8LessThan(q,x);
+}
+function Int16x8LessThanOrEqualJS(q,x){
+return %Int16x8LessThanOrEqual(q,x);
+}
+function Int16x8GreaterThanJS(q,x){
+return %Int16x8GreaterThan(q,x);
+}
+function Int16x8GreaterThanOrEqualJS(q,x){
+return %Int16x8GreaterThanOrEqual(q,x);
+}
+function Int16x8LoadJS(A,B){
+return %Int16x8Load(A,B);
+}
+function Int16x8StoreJS(A,B,q){
+return %Int16x8Store(A,B,q);
+}
+
+function Int8x16ReplaceLaneJS(u,v,r){
+return %Int8x16ReplaceLane(u,v,(%_ToNumber(r)));
+}
+function Int8x16SelectJS(z,q,x){
+return %Int8x16Select(z,q,x);
+}
+function Int8x16AddJS(q,x){
+return %Int8x16Add(q,x);
+}
+function Int8x16SubJS(q,x){
+return %Int8x16Sub(q,x);
+}
+function Int8x16MulJS(q,x){
+return %Int8x16Mul(q,x);
+}
+function Int8x16MinJS(q,x){
+return %Int8x16Min(q,x);
+}
+function Int8x16MaxJS(q,x){
+return %Int8x16Max(q,x);
+}
+function Int8x16EqualJS(q,x){
+return %Int8x16Equal(q,x);
+}
+function Int8x16NotEqualJS(q,x){
+return %Int8x16NotEqual(q,x);
+}
+function Int8x16LessThanJS(q,x){
+return %Int8x16LessThan(q,x);
+}
+function Int8x16LessThanOrEqualJS(q,x){
+return %Int8x16LessThanOrEqual(q,x);
+}
+function Int8x16GreaterThanJS(q,x){
+return %Int8x16GreaterThan(q,x);
+}
+function Int8x16GreaterThanOrEqualJS(q,x){
+return %Int8x16GreaterThanOrEqual(q,x);
+}
+function Int8x16LoadJS(A,B){
+return %Int8x16Load(A,B);
+}
+function Int8x16StoreJS(A,B,q){
+return %Int8x16Store(A,B,q);
+}
+
+
+function Uint32x4ReplaceLaneJS(u,v,r){
+return %Uint32x4ReplaceLane(u,v,(%_ToNumber(r)));
+}
+function Uint32x4SelectJS(z,q,x){
+return %Uint32x4Select(z,q,x);
+}
+function Uint32x4AddJS(q,x){
+return %Uint32x4Add(q,x);
+}
+function Uint32x4SubJS(q,x){
+return %Uint32x4Sub(q,x);
+}
+function Uint32x4MulJS(q,x){
+return %Uint32x4Mul(q,x);
+}
+function Uint32x4MinJS(q,x){
+return %Uint32x4Min(q,x);
+}
+function Uint32x4MaxJS(q,x){
+return %Uint32x4Max(q,x);
+}
+function Uint32x4EqualJS(q,x){
+return %Uint32x4Equal(q,x);
+}
+function Uint32x4NotEqualJS(q,x){
+return %Uint32x4NotEqual(q,x);
+}
+function Uint32x4LessThanJS(q,x){
+return %Uint32x4LessThan(q,x);
+}
+function Uint32x4LessThanOrEqualJS(q,x){
+return %Uint32x4LessThanOrEqual(q,x);
+}
+function Uint32x4GreaterThanJS(q,x){
+return %Uint32x4GreaterThan(q,x);
+}
+function Uint32x4GreaterThanOrEqualJS(q,x){
+return %Uint32x4GreaterThanOrEqual(q,x);
+}
+function Uint32x4LoadJS(A,B){
+return %Uint32x4Load(A,B);
+}
+function Uint32x4StoreJS(A,B,q){
+return %Uint32x4Store(A,B,q);
+}
+
+function Uint16x8ReplaceLaneJS(u,v,r){
+return %Uint16x8ReplaceLane(u,v,(%_ToNumber(r)));
+}
+function Uint16x8SelectJS(z,q,x){
+return %Uint16x8Select(z,q,x);
+}
+function Uint16x8AddJS(q,x){
+return %Uint16x8Add(q,x);
+}
+function Uint16x8SubJS(q,x){
+return %Uint16x8Sub(q,x);
+}
+function Uint16x8MulJS(q,x){
+return %Uint16x8Mul(q,x);
+}
+function Uint16x8MinJS(q,x){
+return %Uint16x8Min(q,x);
+}
+function Uint16x8MaxJS(q,x){
+return %Uint16x8Max(q,x);
+}
+function Uint16x8EqualJS(q,x){
+return %Uint16x8Equal(q,x);
+}
+function Uint16x8NotEqualJS(q,x){
+return %Uint16x8NotEqual(q,x);
+}
+function Uint16x8LessThanJS(q,x){
+return %Uint16x8LessThan(q,x);
+}
+function Uint16x8LessThanOrEqualJS(q,x){
+return %Uint16x8LessThanOrEqual(q,x);
+}
+function Uint16x8GreaterThanJS(q,x){
+return %Uint16x8GreaterThan(q,x);
+}
+function Uint16x8GreaterThanOrEqualJS(q,x){
+return %Uint16x8GreaterThanOrEqual(q,x);
+}
+function Uint16x8LoadJS(A,B){
+return %Uint16x8Load(A,B);
+}
+function Uint16x8StoreJS(A,B,q){
+return %Uint16x8Store(A,B,q);
+}
+
+function Uint8x16ReplaceLaneJS(u,v,r){
+return %Uint8x16ReplaceLane(u,v,(%_ToNumber(r)));
+}
+function Uint8x16SelectJS(z,q,x){
+return %Uint8x16Select(z,q,x);
+}
+function Uint8x16AddJS(q,x){
+return %Uint8x16Add(q,x);
+}
+function Uint8x16SubJS(q,x){
+return %Uint8x16Sub(q,x);
+}
+function Uint8x16MulJS(q,x){
+return %Uint8x16Mul(q,x);
+}
+function Uint8x16MinJS(q,x){
+return %Uint8x16Min(q,x);
+}
+function Uint8x16MaxJS(q,x){
+return %Uint8x16Max(q,x);
+}
+function Uint8x16EqualJS(q,x){
+return %Uint8x16Equal(q,x);
+}
+function Uint8x16NotEqualJS(q,x){
+return %Uint8x16NotEqual(q,x);
+}
+function Uint8x16LessThanJS(q,x){
+return %Uint8x16LessThan(q,x);
+}
+function Uint8x16LessThanOrEqualJS(q,x){
+return %Uint8x16LessThanOrEqual(q,x);
+}
+function Uint8x16GreaterThanJS(q,x){
+return %Uint8x16GreaterThan(q,x);
+}
+function Uint8x16GreaterThanOrEqualJS(q,x){
+return %Uint8x16GreaterThanOrEqual(q,x);
+}
+function Uint8x16LoadJS(A,B){
+return %Uint8x16Load(A,B);
+}
+function Uint8x16StoreJS(A,B,q){
+return %Uint8x16Store(A,B,q);
+}
+
+
+
+function Int32x4AndJS(q,x){
+return %Int32x4And(q,x);
+}
+function Int32x4OrJS(q,x){
+return %Int32x4Or(q,x);
+}
+function Int32x4XorJS(q,x){
+return %Int32x4Xor(q,x);
+}
+function Int32x4NotJS(q){
+return %Int32x4Not(q);
+}
+
+function Int16x8AndJS(q,x){
+return %Int16x8And(q,x);
+}
+function Int16x8OrJS(q,x){
+return %Int16x8Or(q,x);
+}
+function Int16x8XorJS(q,x){
+return %Int16x8Xor(q,x);
+}
+function Int16x8NotJS(q){
+return %Int16x8Not(q);
+}
+
+function Int8x16AndJS(q,x){
+return %Int8x16And(q,x);
+}
+function Int8x16OrJS(q,x){
+return %Int8x16Or(q,x);
+}
+function Int8x16XorJS(q,x){
+return %Int8x16Xor(q,x);
+}
+function Int8x16NotJS(q){
+return %Int8x16Not(q);
+}
+
+
+function Uint32x4AndJS(q,x){
+return %Uint32x4And(q,x);
+}
+function Uint32x4OrJS(q,x){
+return %Uint32x4Or(q,x);
+}
+function Uint32x4XorJS(q,x){
+return %Uint32x4Xor(q,x);
+}
+function Uint32x4NotJS(q){
+return %Uint32x4Not(q);
+}
+
+function Uint16x8AndJS(q,x){
+return %Uint16x8And(q,x);
+}
+function Uint16x8OrJS(q,x){
+return %Uint16x8Or(q,x);
+}
+function Uint16x8XorJS(q,x){
+return %Uint16x8Xor(q,x);
+}
+function Uint16x8NotJS(q){
+return %Uint16x8Not(q);
+}
+
+function Uint8x16AndJS(q,x){
+return %Uint8x16And(q,x);
+}
+function Uint8x16OrJS(q,x){
+return %Uint8x16Or(q,x);
+}
+function Uint8x16XorJS(q,x){
+return %Uint8x16Xor(q,x);
+}
+function Uint8x16NotJS(q){
+return %Uint8x16Not(q);
+}
+
+
+function Bool32x4AndJS(q,x){
+return %Bool32x4And(q,x);
+}
+function Bool32x4OrJS(q,x){
+return %Bool32x4Or(q,x);
+}
+function Bool32x4XorJS(q,x){
+return %Bool32x4Xor(q,x);
+}
+function Bool32x4NotJS(q){
+return %Bool32x4Not(q);
+}
+
+function Bool16x8AndJS(q,x){
+return %Bool16x8And(q,x);
+}
+function Bool16x8OrJS(q,x){
+return %Bool16x8Or(q,x);
+}
+function Bool16x8XorJS(q,x){
+return %Bool16x8Xor(q,x);
+}
+function Bool16x8NotJS(q){
+return %Bool16x8Not(q);
+}
+
+function Bool8x16AndJS(q,x){
+return %Bool8x16And(q,x);
+}
+function Bool8x16OrJS(q,x){
+return %Bool8x16Or(q,x);
+}
+function Bool8x16XorJS(q,x){
+return %Bool8x16Xor(q,x);
+}
+function Bool8x16NotJS(q){
+return %Bool8x16Not(q);
+}
+
+
+
+function Float32x4FromInt32x4JS(q){
+return %Float32x4FromInt32x4(q);
+}
+
+function Float32x4FromUint32x4JS(q){
+return %Float32x4FromUint32x4(q);
+}
+
+function Int32x4FromFloat32x4JS(q){
+return %Int32x4FromFloat32x4(q);
+}
+
+function Int32x4FromUint32x4JS(q){
+return %Int32x4FromUint32x4(q);
+}
+
+function Uint32x4FromFloat32x4JS(q){
+return %Uint32x4FromFloat32x4(q);
+}
+
+function Uint32x4FromInt32x4JS(q){
+return %Uint32x4FromInt32x4(q);
+}
+
+function Int16x8FromUint16x8JS(q){
+return %Int16x8FromUint16x8(q);
+}
+
+function Uint16x8FromInt16x8JS(q){
+return %Uint16x8FromInt16x8(q);
+}
+
+function Int8x16FromUint8x16JS(q){
+return %Int8x16FromUint8x16(q);
+}
+
+function Uint8x16FromInt8x16JS(q){
+return %Uint8x16FromInt8x16(q);
+}
+
+
+function Float32x4FromInt32x4BitsJS(q){
+return %Float32x4FromInt32x4Bits(q);
+}
+
+function Float32x4FromUint32x4BitsJS(q){
+return %Float32x4FromUint32x4Bits(q);
+}
+
+function Float32x4FromInt16x8BitsJS(q){
+return %Float32x4FromInt16x8Bits(q);
+}
+
+function Float32x4FromUint16x8BitsJS(q){
+return %Float32x4FromUint16x8Bits(q);
+}
+
+function Float32x4FromInt8x16BitsJS(q){
+return %Float32x4FromInt8x16Bits(q);
+}
+
+function Float32x4FromUint8x16BitsJS(q){
+return %Float32x4FromUint8x16Bits(q);
+}
+
+function Int32x4FromFloat32x4BitsJS(q){
+return %Int32x4FromFloat32x4Bits(q);
+}
+
+function Int32x4FromUint32x4BitsJS(q){
+return %Int32x4FromUint32x4Bits(q);
+}
+
+function Int32x4FromInt16x8BitsJS(q){
+return %Int32x4FromInt16x8Bits(q);
+}
+
+function Int32x4FromUint16x8BitsJS(q){
+return %Int32x4FromUint16x8Bits(q);
+}
+
+function Int32x4FromInt8x16BitsJS(q){
+return %Int32x4FromInt8x16Bits(q);
+}
+
+function Int32x4FromUint8x16BitsJS(q){
+return %Int32x4FromUint8x16Bits(q);
+}
+
+function Uint32x4FromFloat32x4BitsJS(q){
+return %Uint32x4FromFloat32x4Bits(q);
+}
+
+function Uint32x4FromInt32x4BitsJS(q){
+return %Uint32x4FromInt32x4Bits(q);
+}
+
+function Uint32x4FromInt16x8BitsJS(q){
+return %Uint32x4FromInt16x8Bits(q);
+}
+
+function Uint32x4FromUint16x8BitsJS(q){
+return %Uint32x4FromUint16x8Bits(q);
+}
+
+function Uint32x4FromInt8x16BitsJS(q){
+return %Uint32x4FromInt8x16Bits(q);
+}
+
+function Uint32x4FromUint8x16BitsJS(q){
+return %Uint32x4FromUint8x16Bits(q);
+}
+
+function Int16x8FromFloat32x4BitsJS(q){
+return %Int16x8FromFloat32x4Bits(q);
+}
+
+function Int16x8FromInt32x4BitsJS(q){
+return %Int16x8FromInt32x4Bits(q);
+}
+
+function Int16x8FromUint32x4BitsJS(q){
+return %Int16x8FromUint32x4Bits(q);
+}
+
+function Int16x8FromUint16x8BitsJS(q){
+return %Int16x8FromUint16x8Bits(q);
+}
+
+function Int16x8FromInt8x16BitsJS(q){
+return %Int16x8FromInt8x16Bits(q);
+}
+
+function Int16x8FromUint8x16BitsJS(q){
+return %Int16x8FromUint8x16Bits(q);
+}
+
+function Uint16x8FromFloat32x4BitsJS(q){
+return %Uint16x8FromFloat32x4Bits(q);
+}
+
+function Uint16x8FromInt32x4BitsJS(q){
+return %Uint16x8FromInt32x4Bits(q);
+}
+
+function Uint16x8FromUint32x4BitsJS(q){
+return %Uint16x8FromUint32x4Bits(q);
+}
+
+function Uint16x8FromInt16x8BitsJS(q){
+return %Uint16x8FromInt16x8Bits(q);
+}
+
+function Uint16x8FromInt8x16BitsJS(q){
+return %Uint16x8FromInt8x16Bits(q);
+}
+
+function Uint16x8FromUint8x16BitsJS(q){
+return %Uint16x8FromUint8x16Bits(q);
+}
+
+function Int8x16FromFloat32x4BitsJS(q){
+return %Int8x16FromFloat32x4Bits(q);
+}
+
+function Int8x16FromInt32x4BitsJS(q){
+return %Int8x16FromInt32x4Bits(q);
+}
+
+function Int8x16FromUint32x4BitsJS(q){
+return %Int8x16FromUint32x4Bits(q);
+}
+
+function Int8x16FromInt16x8BitsJS(q){
+return %Int8x16FromInt16x8Bits(q);
+}
+
+function Int8x16FromUint16x8BitsJS(q){
+return %Int8x16FromUint16x8Bits(q);
+}
+
+function Int8x16FromUint8x16BitsJS(q){
+return %Int8x16FromUint8x16Bits(q);
+}
+
+function Uint8x16FromFloat32x4BitsJS(q){
+return %Uint8x16FromFloat32x4Bits(q);
+}
+
+function Uint8x16FromInt32x4BitsJS(q){
+return %Uint8x16FromInt32x4Bits(q);
+}
+
+function Uint8x16FromUint32x4BitsJS(q){
+return %Uint8x16FromUint32x4Bits(q);
+}
+
+function Uint8x16FromInt16x8BitsJS(q){
+return %Uint8x16FromInt16x8Bits(q);
+}
+
+function Uint8x16FromUint16x8BitsJS(q){
+return %Uint8x16FromUint16x8Bits(q);
+}
+
+function Uint8x16FromInt8x16BitsJS(q){
+return %Uint8x16FromInt8x16Bits(q);
+}
+
+
+function Float32x4Load1JS(A,B){
+return %Float32x4Load1(A,B);
+}
+function Float32x4Store1JS(A,B,q){
+return %Float32x4Store1(A,B,q);
+}
+
+function Float32x4Load2JS(A,B){
+return %Float32x4Load2(A,B);
+}
+function Float32x4Store2JS(A,B,q){
+return %Float32x4Store2(A,B,q);
+}
+
+function Float32x4Load3JS(A,B){
+return %Float32x4Load3(A,B);
+}
+function Float32x4Store3JS(A,B,q){
+return %Float32x4Store3(A,B,q);
+}
+
+function Int32x4Load1JS(A,B){
+return %Int32x4Load1(A,B);
+}
+function Int32x4Store1JS(A,B,q){
+return %Int32x4Store1(A,B,q);
+}
+
+function Int32x4Load2JS(A,B){
+return %Int32x4Load2(A,B);
+}
+function Int32x4Store2JS(A,B,q){
+return %Int32x4Store2(A,B,q);
+}
+
+function Int32x4Load3JS(A,B){
+return %Int32x4Load3(A,B);
+}
+function Int32x4Store3JS(A,B,q){
+return %Int32x4Store3(A,B,q);
+}
+
+function Uint32x4Load1JS(A,B){
+return %Uint32x4Load1(A,B);
+}
+function Uint32x4Store1JS(A,B,q){
+return %Uint32x4Store1(A,B,q);
+}
+
+function Uint32x4Load2JS(A,B){
+return %Uint32x4Load2(A,B);
+}
+function Uint32x4Store2JS(A,B,q){
+return %Uint32x4Store2(A,B,q);
+}
+
+function Uint32x4Load3JS(A,B){
+return %Uint32x4Load3(A,B);
+}
+function Uint32x4Store3JS(A,B,q){
+return %Uint32x4Store3(A,B,q);
+}
+
+
+function Float32x4Splat(y){
+return %CreateFloat32x4(y,y,y,y);
+}
+function Float32x4SwizzleJS(q,C,D,E,F){
+return %Float32x4Swizzle(q,C,D,E,F);
+}
+function Float32x4ShuffleJS(q,x,C,D,E,F){
+return %Float32x4Shuffle(q,x,C,D,E,F);
+}
+
+function Int32x4Splat(y){
+return %CreateInt32x4(y,y,y,y);
+}
+function Int32x4SwizzleJS(q,C,D,E,F){
+return %Int32x4Swizzle(q,C,D,E,F);
+}
+function Int32x4ShuffleJS(q,x,C,D,E,F){
+return %Int32x4Shuffle(q,x,C,D,E,F);
+}
+
+function Uint32x4Splat(y){
+return %CreateUint32x4(y,y,y,y);
+}
+function Uint32x4SwizzleJS(q,C,D,E,F){
+return %Uint32x4Swizzle(q,C,D,E,F);
+}
+function Uint32x4ShuffleJS(q,x,C,D,E,F){
+return %Uint32x4Shuffle(q,x,C,D,E,F);
+}
+
+function Bool32x4Splat(y){
+return %CreateBool32x4(y,y,y,y);
+}
+function Bool32x4SwizzleJS(q,C,D,E,F){
+return %Bool32x4Swizzle(q,C,D,E,F);
+}
+function Bool32x4ShuffleJS(q,x,C,D,E,F){
+return %Bool32x4Shuffle(q,x,C,D,E,F);
+}
+
+
+function Int16x8Splat(y){
+return %CreateInt16x8(y,y,y,y,y,y,y,y);
+}
+function Int16x8SwizzleJS(q,C,D,E,F,G,H,I,J){
+return %Int16x8Swizzle(q,C,D,E,F,G,H,I,J);
+}
+function Int16x8ShuffleJS(q,x,C,D,E,F,G,H,I,J){
+return %Int16x8Shuffle(q,x,C,D,E,F,G,H,I,J);
+}
+
+function Uint16x8Splat(y){
+return %CreateUint16x8(y,y,y,y,y,y,y,y);
+}
+function Uint16x8SwizzleJS(q,C,D,E,F,G,H,I,J){
+return %Uint16x8Swizzle(q,C,D,E,F,G,H,I,J);
+}
+function Uint16x8ShuffleJS(q,x,C,D,E,F,G,H,I,J){
+return %Uint16x8Shuffle(q,x,C,D,E,F,G,H,I,J);
+}
+
+function Bool16x8Splat(y){
+return %CreateBool16x8(y,y,y,y,y,y,y,y);
+}
+function Bool16x8SwizzleJS(q,C,D,E,F,G,H,I,J){
+return %Bool16x8Swizzle(q,C,D,E,F,G,H,I,J);
+}
+function Bool16x8ShuffleJS(q,x,C,D,E,F,G,H,I,J){
+return %Bool16x8Shuffle(q,x,C,D,E,F,G,H,I,J);
+}
+
+
+function Int8x16Splat(y){
+return %CreateInt8x16(y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y);
+}
+function Int8x16SwizzleJS(q,C,D,E,F,G,H,I,J,c8,c9,c10,c11,
+c12,c13,c14,c15){
+return %Int8x16Swizzle(q,C,D,E,F,G,H,I,J,c8,c9,c10,c11,
+c12,c13,c14,c15);
+}
+function Int8x16ShuffleJS(q,x,C,D,E,F,G,H,I,J,c8,c9,c10,
+c11,c12,c13,c14,c15){
+return %Int8x16Shuffle(q,x,C,D,E,F,G,H,I,J,c8,c9,c10,
+c11,c12,c13,c14,c15);
+}
+
+function Uint8x16Splat(y){
+return %CreateUint8x16(y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y);
+}
+function Uint8x16SwizzleJS(q,C,D,E,F,G,H,I,J,c8,c9,c10,c11,
+c12,c13,c14,c15){
+return %Uint8x16Swizzle(q,C,D,E,F,G,H,I,J,c8,c9,c10,c11,
+c12,c13,c14,c15);
+}
+function Uint8x16ShuffleJS(q,x,C,D,E,F,G,H,I,J,c8,c9,c10,
+c11,c12,c13,c14,c15){
+return %Uint8x16Shuffle(q,x,C,D,E,F,G,H,I,J,c8,c9,c10,
+c11,c12,c13,c14,c15);
+}
+
+function Bool8x16Splat(y){
+return %CreateBool8x16(y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y);
+}
+function Bool8x16SwizzleJS(q,C,D,E,F,G,H,I,J,c8,c9,c10,c11,
+c12,c13,c14,c15){
+return %Bool8x16Swizzle(q,C,D,E,F,G,H,I,J,c8,c9,c10,c11,
+c12,c13,c14,c15);
+}
+function Bool8x16ShuffleJS(q,x,C,D,E,F,G,H,I,J,c8,c9,c10,
+c11,c12,c13,c14,c15){
+return %Bool8x16Shuffle(q,x,C,D,E,F,G,H,I,J,c8,c9,c10,
+c11,c12,c13,c14,c15);
+}
+
+
+function Float32x4Constructor(C,D,E,F){
+if(!(new.target===(void 0))){
+throw d(62,"Float32x4");
+}
+return %CreateFloat32x4((%_ToNumber(C)),(%_ToNumber(D)),
+(%_ToNumber(E)),(%_ToNumber(F)));
+}
+function Int32x4Constructor(C,D,E,F){
+if(!(new.target===(void 0))){
+throw d(62,"Int32x4");
+}
+return %CreateInt32x4((%_ToNumber(C)),(%_ToNumber(D)),
+(%_ToNumber(E)),(%_ToNumber(F)));
+}
+function Uint32x4Constructor(C,D,E,F){
+if(!(new.target===(void 0))){
+throw d(62,"Uint32x4");
+}
+return %CreateUint32x4((%_ToNumber(C)),(%_ToNumber(D)),
+(%_ToNumber(E)),(%_ToNumber(F)));
+}
+function Bool32x4Constructor(C,D,E,F){
+if(!(new.target===(void 0))){
+throw d(62,"Bool32x4");
+}
+return %CreateBool32x4(C,D,E,F);
+}
+function Int16x8Constructor(C,D,E,F,G,H,I,J){
+if(!(new.target===(void 0))){
+throw d(62,"Int16x8");
+}
+return %CreateInt16x8((%_ToNumber(C)),(%_ToNumber(D)),
+(%_ToNumber(E)),(%_ToNumber(F)),
+(%_ToNumber(G)),(%_ToNumber(H)),
+(%_ToNumber(I)),(%_ToNumber(J)));
+}
+function Uint16x8Constructor(C,D,E,F,G,H,I,J){
+if(!(new.target===(void 0))){
+throw d(62,"Uint16x8");
+}
+return %CreateUint16x8((%_ToNumber(C)),(%_ToNumber(D)),
+(%_ToNumber(E)),(%_ToNumber(F)),
+(%_ToNumber(G)),(%_ToNumber(H)),
+(%_ToNumber(I)),(%_ToNumber(J)));
+}
+function Bool16x8Constructor(C,D,E,F,G,H,I,J){
+if(!(new.target===(void 0))){
+throw d(62,"Bool16x8");
+}
+return %CreateBool16x8(C,D,E,F,G,H,I,J);
+}
+function Int8x16Constructor(C,D,E,F,G,H,I,J,c8,c9,c10,c11,
+c12,c13,c14,c15){
+if(!(new.target===(void 0))){
+throw d(62,"Int8x16");
+}
+return %CreateInt8x16((%_ToNumber(C)),(%_ToNumber(D)),
+(%_ToNumber(E)),(%_ToNumber(F)),
+(%_ToNumber(G)),(%_ToNumber(H)),
+(%_ToNumber(I)),(%_ToNumber(J)),
+(%_ToNumber(c8)),(%_ToNumber(c9)),
+(%_ToNumber(c10)),(%_ToNumber(c11)),
+(%_ToNumber(c12)),(%_ToNumber(c13)),
+(%_ToNumber(c14)),(%_ToNumber(c15)));
+}
+function Uint8x16Constructor(C,D,E,F,G,H,I,J,c8,c9,c10,c11,
+c12,c13,c14,c15){
+if(!(new.target===(void 0))){
+throw d(62,"Uint8x16");
+}
+return %CreateUint8x16((%_ToNumber(C)),(%_ToNumber(D)),
+(%_ToNumber(E)),(%_ToNumber(F)),
+(%_ToNumber(G)),(%_ToNumber(H)),
+(%_ToNumber(I)),(%_ToNumber(J)),
+(%_ToNumber(c8)),(%_ToNumber(c9)),
+(%_ToNumber(c10)),(%_ToNumber(c11)),
+(%_ToNumber(c12)),(%_ToNumber(c13)),
+(%_ToNumber(c14)),(%_ToNumber(c15)));
+}
+function Bool8x16Constructor(C,D,E,F,G,H,I,J,c8,c9,c10,c11,
+c12,c13,c14,c15){
+if(!(new.target===(void 0))){
+throw d(62,"Bool8x16");
+}
+return %CreateBool8x16(C,D,E,F,G,H,I,J,c8,c9,c10,c11,c12,
+c13,c14,c15);
+}
+function Float32x4AbsJS(q){
+return %Float32x4Abs(q);
+}
+function Float32x4SqrtJS(q){
+return %Float32x4Sqrt(q);
+}
+function Float32x4RecipApproxJS(q){
+return %Float32x4RecipApprox(q);
+}
+function Float32x4RecipSqrtApproxJS(q){
+return %Float32x4RecipSqrtApprox(q);
+}
+function Float32x4DivJS(q,x){
+return %Float32x4Div(q,x);
+}
+function Float32x4MinNumJS(q,x){
+return %Float32x4MinNum(q,x);
+}
+function Float32x4MaxNumJS(q,x){
+return %Float32x4MaxNum(q,x);
+}
+%AddNamedProperty(c,e,'SIMD',1|2);
+%SetCode(g,Float32x4Constructor);
+%FunctionSetPrototype(g,{});
+%AddNamedProperty(g.prototype,'constructor',g,
+2);
+%AddNamedProperty(g.prototype,e,'Float32x4',
+2|1);
+b.InstallFunctions(g.prototype,2,[
+'toLocaleString',Float32x4ToLocaleString,
+'toString',Float32x4ToString,
+'valueOf',Float32x4ValueOf,
+]);
+
+
+%SetCode(h,Int32x4Constructor);
+%FunctionSetPrototype(h,{});
+%AddNamedProperty(h.prototype,'constructor',h,
+2);
+%AddNamedProperty(h.prototype,e,'Int32x4',
+2|1);
+b.InstallFunctions(h.prototype,2,[
+'toLocaleString',Int32x4ToLocaleString,
+'toString',Int32x4ToString,
+'valueOf',Int32x4ValueOf,
+]);
+
+%SetCode(i,Int16x8Constructor);
+%FunctionSetPrototype(i,{});
+%AddNamedProperty(i.prototype,'constructor',i,
+2);
+%AddNamedProperty(i.prototype,e,'Int16x8',
+2|1);
+b.InstallFunctions(i.prototype,2,[
+'toLocaleString',Int16x8ToLocaleString,
+'toString',Int16x8ToString,
+'valueOf',Int16x8ValueOf,
+]);
+
+%SetCode(j,Int8x16Constructor);
+%FunctionSetPrototype(j,{});
+%AddNamedProperty(j.prototype,'constructor',j,
+2);
+%AddNamedProperty(j.prototype,e,'Int8x16',
+2|1);
+b.InstallFunctions(j.prototype,2,[
+'toLocaleString',Int8x16ToLocaleString,
+'toString',Int8x16ToString,
+'valueOf',Int8x16ValueOf,
+]);
+
+
+%SetCode(k,Uint32x4Constructor);
+%FunctionSetPrototype(k,{});
+%AddNamedProperty(k.prototype,'constructor',k,
+2);
+%AddNamedProperty(k.prototype,e,'Uint32x4',
+2|1);
+b.InstallFunctions(k.prototype,2,[
+'toLocaleString',Uint32x4ToLocaleString,
+'toString',Uint32x4ToString,
+'valueOf',Uint32x4ValueOf,
+]);
+
+%SetCode(l,Uint16x8Constructor);
+%FunctionSetPrototype(l,{});
+%AddNamedProperty(l.prototype,'constructor',l,
+2);
+%AddNamedProperty(l.prototype,e,'Uint16x8',
+2|1);
+b.InstallFunctions(l.prototype,2,[
+'toLocaleString',Uint16x8ToLocaleString,
+'toString',Uint16x8ToString,
+'valueOf',Uint16x8ValueOf,
+]);
+
+%SetCode(m,Uint8x16Constructor);
+%FunctionSetPrototype(m,{});
+%AddNamedProperty(m.prototype,'constructor',m,
+2);
+%AddNamedProperty(m.prototype,e,'Uint8x16',
+2|1);
+b.InstallFunctions(m.prototype,2,[
+'toLocaleString',Uint8x16ToLocaleString,
+'toString',Uint8x16ToString,
+'valueOf',Uint8x16ValueOf,
+]);
+
+
+%SetCode(n,Bool32x4Constructor);
+%FunctionSetPrototype(n,{});
+%AddNamedProperty(n.prototype,'constructor',n,
+2);
+%AddNamedProperty(n.prototype,e,'Bool32x4',
+2|1);
+b.InstallFunctions(n.prototype,2,[
+'toLocaleString',Bool32x4ToLocaleString,
+'toString',Bool32x4ToString,
+'valueOf',Bool32x4ValueOf,
+]);
+
+%SetCode(o,Bool16x8Constructor);
+%FunctionSetPrototype(o,{});
+%AddNamedProperty(o.prototype,'constructor',o,
+2);
+%AddNamedProperty(o.prototype,e,'Bool16x8',
+2|1);
+b.InstallFunctions(o.prototype,2,[
+'toLocaleString',Bool16x8ToLocaleString,
+'toString',Bool16x8ToString,
+'valueOf',Bool16x8ValueOf,
+]);
+
+%SetCode(p,Bool8x16Constructor);
+%FunctionSetPrototype(p,{});
+%AddNamedProperty(p.prototype,'constructor',p,
+2);
+%AddNamedProperty(p.prototype,e,'Bool8x16',
+2|1);
+b.InstallFunctions(p.prototype,2,[
+'toLocaleString',Bool8x16ToLocaleString,
+'toString',Bool8x16ToString,
+'valueOf',Bool8x16ValueOf,
+]);
+
+
+
+b.InstallFunctions(g,2,[
+'splat',Float32x4Splat,
+'check',Float32x4CheckJS,
+'extractLane',Float32x4ExtractLaneJS,
+'replaceLane',Float32x4ReplaceLaneJS,
+'neg',Float32x4NegJS,
+'abs',Float32x4AbsJS,
+'sqrt',Float32x4SqrtJS,
+'reciprocalApproximation',Float32x4RecipApproxJS,
+'reciprocalSqrtApproximation',Float32x4RecipSqrtApproxJS,
+'add',Float32x4AddJS,
+'sub',Float32x4SubJS,
+'mul',Float32x4MulJS,
+'div',Float32x4DivJS,
+'min',Float32x4MinJS,
+'max',Float32x4MaxJS,
+'minNum',Float32x4MinNumJS,
+'maxNum',Float32x4MaxNumJS,
+'lessThan',Float32x4LessThanJS,
+'lessThanOrEqual',Float32x4LessThanOrEqualJS,
+'greaterThan',Float32x4GreaterThanJS,
+'greaterThanOrEqual',Float32x4GreaterThanOrEqualJS,
+'equal',Float32x4EqualJS,
+'notEqual',Float32x4NotEqualJS,
+'select',Float32x4SelectJS,
+'swizzle',Float32x4SwizzleJS,
+'shuffle',Float32x4ShuffleJS,
+'fromInt32x4',Float32x4FromInt32x4JS,
+'fromUint32x4',Float32x4FromUint32x4JS,
+'fromInt32x4Bits',Float32x4FromInt32x4BitsJS,
+'fromUint32x4Bits',Float32x4FromUint32x4BitsJS,
+'fromInt16x8Bits',Float32x4FromInt16x8BitsJS,
+'fromUint16x8Bits',Float32x4FromUint16x8BitsJS,
+'fromInt8x16Bits',Float32x4FromInt8x16BitsJS,
+'fromUint8x16Bits',Float32x4FromUint8x16BitsJS,
+'load',Float32x4LoadJS,
+'load1',Float32x4Load1JS,
+'load2',Float32x4Load2JS,
+'load3',Float32x4Load3JS,
+'store',Float32x4StoreJS,
+'store1',Float32x4Store1JS,
+'store2',Float32x4Store2JS,
+'store3',Float32x4Store3JS,
+]);
+b.InstallFunctions(h,2,[
+'splat',Int32x4Splat,
+'check',Int32x4CheckJS,
+'extractLane',Int32x4ExtractLaneJS,
+'replaceLane',Int32x4ReplaceLaneJS,
+'neg',Int32x4NegJS,
+'add',Int32x4AddJS,
+'sub',Int32x4SubJS,
+'mul',Int32x4MulJS,
+'min',Int32x4MinJS,
+'max',Int32x4MaxJS,
+'and',Int32x4AndJS,
+'or',Int32x4OrJS,
+'xor',Int32x4XorJS,
+'not',Int32x4NotJS,
+'shiftLeftByScalar',Int32x4ShiftLeftByScalarJS,
+'shiftRightByScalar',Int32x4ShiftRightByScalarJS,
+'lessThan',Int32x4LessThanJS,
+'lessThanOrEqual',Int32x4LessThanOrEqualJS,
+'greaterThan',Int32x4GreaterThanJS,
+'greaterThanOrEqual',Int32x4GreaterThanOrEqualJS,
+'equal',Int32x4EqualJS,
+'notEqual',Int32x4NotEqualJS,
+'select',Int32x4SelectJS,
+'swizzle',Int32x4SwizzleJS,
+'shuffle',Int32x4ShuffleJS,
+'fromFloat32x4',Int32x4FromFloat32x4JS,
+'fromUint32x4',Int32x4FromUint32x4JS,
+'fromFloat32x4Bits',Int32x4FromFloat32x4BitsJS,
+'fromUint32x4Bits',Int32x4FromUint32x4BitsJS,
+'fromInt16x8Bits',Int32x4FromInt16x8BitsJS,
+'fromUint16x8Bits',Int32x4FromUint16x8BitsJS,
+'fromInt8x16Bits',Int32x4FromInt8x16BitsJS,
+'fromUint8x16Bits',Int32x4FromUint8x16BitsJS,
+'load',Int32x4LoadJS,
+'load1',Int32x4Load1JS,
+'load2',Int32x4Load2JS,
+'load3',Int32x4Load3JS,
+'store',Int32x4StoreJS,
+'store1',Int32x4Store1JS,
+'store2',Int32x4Store2JS,
+'store3',Int32x4Store3JS,
+]);
+b.InstallFunctions(k,2,[
+'splat',Uint32x4Splat,
+'check',Uint32x4CheckJS,
+'extractLane',Uint32x4ExtractLaneJS,
+'replaceLane',Uint32x4ReplaceLaneJS,
+'add',Uint32x4AddJS,
+'sub',Uint32x4SubJS,
+'mul',Uint32x4MulJS,
+'min',Uint32x4MinJS,
+'max',Uint32x4MaxJS,
+'and',Uint32x4AndJS,
+'or',Uint32x4OrJS,
+'xor',Uint32x4XorJS,
+'not',Uint32x4NotJS,
+'shiftLeftByScalar',Uint32x4ShiftLeftByScalarJS,
+'shiftRightByScalar',Uint32x4ShiftRightByScalarJS,
+'lessThan',Uint32x4LessThanJS,
+'lessThanOrEqual',Uint32x4LessThanOrEqualJS,
+'greaterThan',Uint32x4GreaterThanJS,
+'greaterThanOrEqual',Uint32x4GreaterThanOrEqualJS,
+'equal',Uint32x4EqualJS,
+'notEqual',Uint32x4NotEqualJS,
+'select',Uint32x4SelectJS,
+'swizzle',Uint32x4SwizzleJS,
+'shuffle',Uint32x4ShuffleJS,
+'fromFloat32x4',Uint32x4FromFloat32x4JS,
+'fromInt32x4',Uint32x4FromInt32x4JS,
+'fromFloat32x4Bits',Uint32x4FromFloat32x4BitsJS,
+'fromInt32x4Bits',Uint32x4FromInt32x4BitsJS,
+'fromInt16x8Bits',Uint32x4FromInt16x8BitsJS,
+'fromUint16x8Bits',Uint32x4FromUint16x8BitsJS,
+'fromInt8x16Bits',Uint32x4FromInt8x16BitsJS,
+'fromUint8x16Bits',Uint32x4FromUint8x16BitsJS,
+'load',Uint32x4LoadJS,
+'load1',Uint32x4Load1JS,
+'load2',Uint32x4Load2JS,
+'load3',Uint32x4Load3JS,
+'store',Uint32x4StoreJS,
+'store1',Uint32x4Store1JS,
+'store2',Uint32x4Store2JS,
+'store3',Uint32x4Store3JS,
+]);
+b.InstallFunctions(n,2,[
+'splat',Bool32x4Splat,
+'check',Bool32x4CheckJS,
+'extractLane',Bool32x4ExtractLaneJS,
+'replaceLane',Bool32x4ReplaceLaneJS,
+'and',Bool32x4AndJS,
+'or',Bool32x4OrJS,
+'xor',Bool32x4XorJS,
+'not',Bool32x4NotJS,
+'anyTrue',Bool32x4AnyTrueJS,
+'allTrue',Bool32x4AllTrueJS,
+'swizzle',Bool32x4SwizzleJS,
+'shuffle',Bool32x4ShuffleJS,
+]);
+b.InstallFunctions(i,2,[
+'splat',Int16x8Splat,
+'check',Int16x8CheckJS,
+'extractLane',Int16x8ExtractLaneJS,
+'replaceLane',Int16x8ReplaceLaneJS,
+'neg',Int16x8NegJS,
+'add',Int16x8AddJS,
+'sub',Int16x8SubJS,
+'addSaturate',Int16x8AddSaturateJS,
+'subSaturate',Int16x8SubSaturateJS,
+'mul',Int16x8MulJS,
+'min',Int16x8MinJS,
+'max',Int16x8MaxJS,
+'and',Int16x8AndJS,
+'or',Int16x8OrJS,
+'xor',Int16x8XorJS,
+'not',Int16x8NotJS,
+'shiftLeftByScalar',Int16x8ShiftLeftByScalarJS,
+'shiftRightByScalar',Int16x8ShiftRightByScalarJS,
+'lessThan',Int16x8LessThanJS,
+'lessThanOrEqual',Int16x8LessThanOrEqualJS,
+'greaterThan',Int16x8GreaterThanJS,
+'greaterThanOrEqual',Int16x8GreaterThanOrEqualJS,
+'equal',Int16x8EqualJS,
+'notEqual',Int16x8NotEqualJS,
+'select',Int16x8SelectJS,
+'swizzle',Int16x8SwizzleJS,
+'shuffle',Int16x8ShuffleJS,
+'fromUint16x8',Int16x8FromUint16x8JS,
+'fromFloat32x4Bits',Int16x8FromFloat32x4BitsJS,
+'fromInt32x4Bits',Int16x8FromInt32x4BitsJS,
+'fromUint32x4Bits',Int16x8FromUint32x4BitsJS,
+'fromUint16x8Bits',Int16x8FromUint16x8BitsJS,
+'fromInt8x16Bits',Int16x8FromInt8x16BitsJS,
+'fromUint8x16Bits',Int16x8FromUint8x16BitsJS,
+'load',Int16x8LoadJS,
+'store',Int16x8StoreJS,
+]);
+b.InstallFunctions(l,2,[
+'splat',Uint16x8Splat,
+'check',Uint16x8CheckJS,
+'extractLane',Uint16x8ExtractLaneJS,
+'replaceLane',Uint16x8ReplaceLaneJS,
+'add',Uint16x8AddJS,
+'sub',Uint16x8SubJS,
+'addSaturate',Uint16x8AddSaturateJS,
+'subSaturate',Uint16x8SubSaturateJS,
+'mul',Uint16x8MulJS,
+'min',Uint16x8MinJS,
+'max',Uint16x8MaxJS,
+'and',Uint16x8AndJS,
+'or',Uint16x8OrJS,
+'xor',Uint16x8XorJS,
+'not',Uint16x8NotJS,
+'shiftLeftByScalar',Uint16x8ShiftLeftByScalarJS,
+'shiftRightByScalar',Uint16x8ShiftRightByScalarJS,
+'lessThan',Uint16x8LessThanJS,
+'lessThanOrEqual',Uint16x8LessThanOrEqualJS,
+'greaterThan',Uint16x8GreaterThanJS,
+'greaterThanOrEqual',Uint16x8GreaterThanOrEqualJS,
+'equal',Uint16x8EqualJS,
+'notEqual',Uint16x8NotEqualJS,
+'select',Uint16x8SelectJS,
+'swizzle',Uint16x8SwizzleJS,
+'shuffle',Uint16x8ShuffleJS,
+'fromInt16x8',Uint16x8FromInt16x8JS,
+'fromFloat32x4Bits',Uint16x8FromFloat32x4BitsJS,
+'fromInt32x4Bits',Uint16x8FromInt32x4BitsJS,
+'fromUint32x4Bits',Uint16x8FromUint32x4BitsJS,
+'fromInt16x8Bits',Uint16x8FromInt16x8BitsJS,
+'fromInt8x16Bits',Uint16x8FromInt8x16BitsJS,
+'fromUint8x16Bits',Uint16x8FromUint8x16BitsJS,
+'load',Uint16x8LoadJS,
+'store',Uint16x8StoreJS,
+]);
+b.InstallFunctions(o,2,[
+'splat',Bool16x8Splat,
+'check',Bool16x8CheckJS,
+'extractLane',Bool16x8ExtractLaneJS,
+'replaceLane',Bool16x8ReplaceLaneJS,
+'and',Bool16x8AndJS,
+'or',Bool16x8OrJS,
+'xor',Bool16x8XorJS,
+'not',Bool16x8NotJS,
+'anyTrue',Bool16x8AnyTrueJS,
+'allTrue',Bool16x8AllTrueJS,
+'swizzle',Bool16x8SwizzleJS,
+'shuffle',Bool16x8ShuffleJS,
+]);
+b.InstallFunctions(j,2,[
+'splat',Int8x16Splat,
+'check',Int8x16CheckJS,
+'extractLane',Int8x16ExtractLaneJS,
+'replaceLane',Int8x16ReplaceLaneJS,
+'neg',Int8x16NegJS,
+'add',Int8x16AddJS,
+'sub',Int8x16SubJS,
+'addSaturate',Int8x16AddSaturateJS,
+'subSaturate',Int8x16SubSaturateJS,
+'mul',Int8x16MulJS,
+'min',Int8x16MinJS,
+'max',Int8x16MaxJS,
+'and',Int8x16AndJS,
+'or',Int8x16OrJS,
+'xor',Int8x16XorJS,
+'not',Int8x16NotJS,
+'shiftLeftByScalar',Int8x16ShiftLeftByScalarJS,
+'shiftRightByScalar',Int8x16ShiftRightByScalarJS,
+'lessThan',Int8x16LessThanJS,
+'lessThanOrEqual',Int8x16LessThanOrEqualJS,
+'greaterThan',Int8x16GreaterThanJS,
+'greaterThanOrEqual',Int8x16GreaterThanOrEqualJS,
+'equal',Int8x16EqualJS,
+'notEqual',Int8x16NotEqualJS,
+'select',Int8x16SelectJS,
+'swizzle',Int8x16SwizzleJS,
+'shuffle',Int8x16ShuffleJS,
+'fromUint8x16',Int8x16FromUint8x16JS,
+'fromFloat32x4Bits',Int8x16FromFloat32x4BitsJS,
+'fromInt32x4Bits',Int8x16FromInt32x4BitsJS,
+'fromUint32x4Bits',Int8x16FromUint32x4BitsJS,
+'fromInt16x8Bits',Int8x16FromInt16x8BitsJS,
+'fromUint16x8Bits',Int8x16FromUint16x8BitsJS,
+'fromUint8x16Bits',Int8x16FromUint8x16BitsJS,
+'load',Int8x16LoadJS,
+'store',Int8x16StoreJS,
+]);
+b.InstallFunctions(m,2,[
+'splat',Uint8x16Splat,
+'check',Uint8x16CheckJS,
+'extractLane',Uint8x16ExtractLaneJS,
+'replaceLane',Uint8x16ReplaceLaneJS,
+'add',Uint8x16AddJS,
+'sub',Uint8x16SubJS,
+'addSaturate',Uint8x16AddSaturateJS,
+'subSaturate',Uint8x16SubSaturateJS,
+'mul',Uint8x16MulJS,
+'min',Uint8x16MinJS,
+'max',Uint8x16MaxJS,
+'and',Uint8x16AndJS,
+'or',Uint8x16OrJS,
+'xor',Uint8x16XorJS,
+'not',Uint8x16NotJS,
+'shiftLeftByScalar',Uint8x16ShiftLeftByScalarJS,
+'shiftRightByScalar',Uint8x16ShiftRightByScalarJS,
+'lessThan',Uint8x16LessThanJS,
+'lessThanOrEqual',Uint8x16LessThanOrEqualJS,
+'greaterThan',Uint8x16GreaterThanJS,
+'greaterThanOrEqual',Uint8x16GreaterThanOrEqualJS,
+'equal',Uint8x16EqualJS,
+'notEqual',Uint8x16NotEqualJS,
+'select',Uint8x16SelectJS,
+'swizzle',Uint8x16SwizzleJS,
+'shuffle',Uint8x16ShuffleJS,
+'fromInt8x16',Uint8x16FromInt8x16JS,
+'fromFloat32x4Bits',Uint8x16FromFloat32x4BitsJS,
+'fromInt32x4Bits',Uint8x16FromInt32x4BitsJS,
+'fromUint32x4Bits',Uint8x16FromUint32x4BitsJS,
+'fromInt16x8Bits',Uint8x16FromInt16x8BitsJS,
+'fromUint16x8Bits',Uint8x16FromUint16x8BitsJS,
+'fromInt8x16Bits',Uint8x16FromInt8x16BitsJS,
+'load',Uint8x16LoadJS,
+'store',Uint8x16StoreJS,
+]);
+b.InstallFunctions(p,2,[
+'splat',Bool8x16Splat,
+'check',Bool8x16CheckJS,
+'extractLane',Bool8x16ExtractLaneJS,
+'replaceLane',Bool8x16ReplaceLaneJS,
+'and',Bool8x16AndJS,
+'or',Bool8x16OrJS,
+'xor',Bool8x16XorJS,
+'not',Bool8x16NotJS,
+'anyTrue',Bool8x16AnyTrueJS,
+'allTrue',Bool8x16AllTrueJS,
+'swizzle',Bool8x16SwizzleJS,
+'shuffle',Bool8x16ShuffleJS,
+]);
+b.Export(function(K){
+K.Float32x4ToString=Float32x4ToString;
+K.Int32x4ToString=Int32x4ToString;
+K.Uint32x4ToString=Uint32x4ToString;
+K.Bool32x4ToString=Bool32x4ToString;
+K.Int16x8ToString=Int16x8ToString;
+K.Uint16x8ToString=Uint16x8ToString;
+K.Bool16x8ToString=Bool16x8ToString;
+K.Int8x16ToString=Int8x16ToString;
+K.Uint8x16ToString=Uint8x16ToString;
+K.Bool8x16ToString=Bool8x16ToString;
+});
+})
+
+<harmony-speciesE
+(function(a,b,c){
+"use strict";
+%CheckIsBootstrapping();
+var d=a.Array;
+var e=a.Uint8Array.__proto__;
+var f=a.Map;
+var g=a.Set;
+var h=a.ArrayBuffer;
+var i=a.Promise;
+var j=a.RegExp;
+var k=b.ImportNow("species_symbol");
+function ArraySpecies(){
+return this;
+}
+function TypedArraySpecies(){
+return this;
+}
+function MapSpecies(){
+return this;
+}
+function SetSpecies(){
+return this;
+}
+function ArrayBufferSpecies(){
+return this;
+}
+function PromiseSpecies(){
+return this;
+}
+function RegExpSpecies(){
+return this;
+}
+b.InstallGetter(d,k,ArraySpecies,2);
+b.InstallGetter(e,k,TypedArraySpecies,2);
+b.InstallGetter(f,k,MapSpecies,2);
+b.InstallGetter(g,k,SetSpecies,2);
+b.InstallGetter(h,k,ArrayBufferSpecies,
+2);
+b.InstallGetter(i,k,PromiseSpecies,2);
+b.InstallGetter(j,k,RegExpSpecies,2);
+});
+
+\harmony-unicode-regexps�
+(function(a,b){
+'use strict';
+%CheckIsBootstrapping();
+var c=a.RegExp;
+var d=c.prototype;
+var e;
+b.Import(function(f){
+e=f.MakeTypeError;
+});
+function RegExpGetUnicode(){
+if(!(%_IsRegExp(this))){
+if(this===d){
+%IncrementUseCounter(13);
+return(void 0);
+}
+throw e(131,"RegExp.prototype.unicode");
+}
+return!!(%_RegExpFlags(this)&16);
+}
+%FunctionSetName(RegExpGetUnicode,"RegExp.prototype.unicode");
+%SetNativeFlag(RegExpGetUnicode);
+b.InstallGetter(c.prototype,'unicode',RegExpGetUnicode);
+})
+
+4promise-extra�
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Promise;
+var d=b.ImportNow("PromiseChain");
+var e=b.ImportNow("PromiseDeferred");
+var f=b.ImportNow("PromiseResolved");
+b.InstallFunctions(c.prototype,2,[
+"chain",d,
+]);
+b.InstallFunctions(c,2,[
+"defer",e,
+"accept",f,
+]);
+})
+
+XReadableStreamTempStubm
+(function(global, binding, v8) {
+  'use strict';
+  const TypeError = global.TypeError;
+  const defineProperty = global.Object.defineProperty;
+  class ReadableStream {
+    constructor() {
+      throw new TypeError('Illegal constructor');
+    }
+    getReader() {
+      throw new TypeError('Illegal invocation');
+    }
+    cancel() {
+      throw new TypeError('Illegal invocation');
+    }
+  }
+  defineProperty(global, 'ReadableStream', {
+    value: ReadableStream,
+    enumerable: false,
+    configurable: true,
+    writable: true
+  });
+});
+dByteLengthQueuingStrategy�
+(function(global, binding, v8) {
+  'use strict';
+  const defineProperty = global.Object.defineProperty;
+  class ByteLengthQueuingStrategy {
+    constructor(options) {
+      defineProperty(this, 'highWaterMark', {
+        value: options.highWaterMark,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    }
+    size(chunk) { return chunk.byteLength; }
+  }
+  defineProperty(global, 'ByteLengthQueuingStrategy', {
+    value: ByteLengthQueuingStrategy,
+    enumerable: false,
+    configurable: true,
+    writable: true
+  });
+});
+PCountQueuingStrategyY
+(function(global, binding, v8) {
+  'use strict';
+  const defineProperty = global.Object.defineProperty;
+  class CountQueuingStrategy {
+    constructor(options) {
+      defineProperty(this, 'highWaterMark', {
+        value: options.highWaterMark,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    }
+    size(chunk) { return 1; }
+  }
+  defineProperty(global, 'CountQueuingStrategy', {
+    value: CountQueuingStrategy,
+    enumerable: false,
+    configurable: true,
+    writable: true
+  });
+});
+8ReadableStreamVg

+(function(global, binding, v8) {
+  'use strict';
+  const readableStreamController = v8.createPrivateSymbol('[[controller]]');
+  const readableStreamQueue = v8.createPrivateSymbol('[[queue]]');
+  const readableStreamQueueSize =
+      v8.createPrivateSymbol('[[queue]] total size');
+  const readableStreamReader = v8.createPrivateSymbol('[[reader]]');
+  const readableStreamState = v8.createPrivateSymbol('[[state]]');
+  const readableStreamStoredError = v8.createPrivateSymbol('[[storedError]]');
+  const readableStreamStrategySize = v8.createPrivateSymbol('[[strategySize]]');
+  const readableStreamStrategyHWM = v8.createPrivateSymbol('[[strategyHWM]]');
+  const readableStreamUnderlyingSource =
+      v8.createPrivateSymbol('[[underlyingSource]]');
+  const readableStreamControllerControlledReadableStream =
+      v8.createPrivateSymbol('[[controlledReadableStream]]');
+  const readableStreamReaderClosedPromise =
+      v8.createPrivateSymbol('[[closedPromise]]');
+  const readableStreamReaderOwnerReadableStream =
+      v8.createPrivateSymbol('[[ownerReadableStream]]');
+  const readableStreamReaderReadRequests =
+      v8.createPrivateSymbol('[[readRequests]]');
+  const STATE_READABLE = 0;
+  const STATE_CLOSED = 1;
+  const STATE_ERRORED = 2;
+  const readableStreamBits = v8.createPrivateSymbol(
+      'bit field for [[started]], [[closeRequested]], [[pulling]], [[pullAgain]], [[disturbed]]');
+  const STARTED = 0b1;
+  const CLOSE_REQUESTED = 0b10;
+  const PULLING = 0b100;
+  const PULL_AGAIN = 0b1000;
+  const DISTURBED = 0b10000;
+  const undefined = global.undefined;
+  const Infinity = global.Infinity;
+  const defineProperty = global.Object.defineProperty;
+  const hasOwnProperty = v8.uncurryThis(global.Object.hasOwnProperty);
+  const callFunction = v8.uncurryThis(global.Function.prototype.call);
+  const TypeError = global.TypeError;
+  const RangeError = global.RangeError;
+  const Number = global.Number;
+  const Number_isNaN = Number.isNaN;
+  const Number_isFinite = Number.isFinite;
+  const Promise = global.Promise;
+  const thenPromise = v8.uncurryThis(Promise.prototype.then);
+  const Promise_resolve = v8.simpleBind(Promise.resolve, Promise);
+  const Promise_reject = v8.simpleBind(Promise.reject, Promise);
+  const errIllegalInvocation = 'Illegal invocation';
+  const errIllegalConstructor = 'Illegal constructor';
+  const errCancelLockedStream =
+      'Cannot cancel a readable stream that is locked to a reader';
+  const errEnqueueInCloseRequestedStream =
+      'Cannot enqueue a chunk into a readable stream that is closed or has been requested to be closed';
+  const errCancelReleasedReader =
+      'This readable stream reader has been released and cannot be used to cancel its previous owner stream';
+  const errReadReleasedReader =
+      'This readable stream reader has been released and cannot be used to read from its previous owner stream';
+  const errCloseCloseRequestedStream =
+      'Cannot close a readable stream that has already been requested to be closed';
+  const errCloseErroredStream = 'Cannot close an errored readable stream';
+  const errErrorClosedStream = 'Cannot error a close readable stream';
+  const errErrorErroredStream =
+      'Cannot error a readable stream that is already errored';
+  const errReaderConstructorBadArgument =
+      'ReadableStreamReader constructor argument is not a readable stream';
+  const errReaderConstructorStreamAlreadyLocked =
+      'ReadableStreamReader constructor can only accept readable streams that are not yet locked to a reader';
+  const errReleaseReaderWithPendingRead =
+      'Cannot release a readable stream reader when it still has outstanding read() calls that have not yet settled';
+  const errReleasedReaderClosedPromise =
+      'This readable stream reader has been released and cannot be used to monitor the stream\'s state';
+  const errInvalidSize =
+      'The return value of a queuing strategy\'s size function must be a finite, non-NaN, non-negative number';
+  const errSizeNotAFunction =
+      'A queuing strategy\'s size property must be a function';
+  const errInvalidHWM =
+      'A queueing strategy\'s highWaterMark property must be a nonnegative, non-NaN number';
+  const errTmplMustBeFunctionOrUndefined = name =>
+      `${name} must be a function or undefined`;
+  class ReadableStream {
+    constructor() {
+      const underlyingSource = arguments[0] === undefined ? {} : arguments[0];
+      const strategy = arguments[1] === undefined ? {} : arguments[1];
+      const size = strategy.size;
+      let highWaterMark = strategy.highWaterMark;
+      if (highWaterMark === undefined) {
+        highWaterMark = 1;
+      }
+      const normalizedStrategy =
+          ValidateAndNormalizeQueuingStrategy(size, highWaterMark);
+      this[readableStreamUnderlyingSource] = underlyingSource;
+      this[readableStreamQueue] = new v8.InternalPackedArray();
+      this[readableStreamQueueSize] = 0;
+      this[readableStreamState] = STATE_READABLE;
+      this[readableStreamBits] = 0b0;
+      this[readableStreamReader] = undefined;
+      this[readableStreamStoredError] = undefined;
+      this[readableStreamStrategySize] = normalizedStrategy.size;
+      this[readableStreamStrategyHWM] = normalizedStrategy.highWaterMark;
+      const controller = new ReadableStreamController(this);
+      this[readableStreamController] = controller;
+      const startResult = CallOrNoop(
+          underlyingSource, 'start', controller, 'underlyingSource.start');
+      thenPromise(Promise_resolve(startResult),
+          () => {
+            this[readableStreamBits] |= STARTED;
+            RequestReadableStreamPull(this);
+          },
+          r => {
+            if (this[readableStreamState] === STATE_READABLE) {
+              return ErrorReadableStream(this, r);
+            }
+          });
+    }
+    get locked() {
+      if (IsReadableStream(this) === false) {
+        throw new TypeError(errIllegalInvocation);
+      }
+      return IsReadableStreamLocked(this);
+    }
+    cancel(reason) {
+      if (IsReadableStream(this) === false) {
+        return Promise_reject(new TypeError(errIllegalInvocation));
+      }
+      if (IsReadableStreamLocked(this) === true) {
+        return Promise_reject(new TypeError(errCancelLockedStream));
+      }
+      return CancelReadableStream(this, reason);
+    }
+    getReader() {
+      if (IsReadableStream(this) === false) {
+        throw new TypeError(errIllegalInvocation);
+      }
+      return AcquireReadableStreamReader(this);
+    }
+    tee() {
+      if (IsReadableStream(this) === false) {
+        throw new TypeError(errIllegalInvocation);
+      }
+      return TeeReadableStream(this);
+    }
+  }
+  class ReadableStreamController {
+    constructor(stream) {
+      if (IsReadableStream(stream) === false) {
+        throw new TypeError(errIllegalConstructor);
+      }
+      if (stream[readableStreamController] !== undefined) {
+        throw new TypeError(errIllegalConstructor);
+      }
+      this[readableStreamControllerControlledReadableStream] = stream;
+    }
+    get desiredSize() {
+      if (IsReadableStreamController(this) === false) {
+        throw new TypeError(errIllegalInvocation);
+      }
+      return GetReadableStreamDesiredSize(
+          this[readableStreamControllerControlledReadableStream]);
+    }
+    close() {
+      if (IsReadableStreamController(this) === false) {
+        throw new TypeError(errIllegalInvocation);
+      }
+      const stream = this[readableStreamControllerControlledReadableStream];
+      if (stream[readableStreamBits] & CLOSE_REQUESTED) {
+        throw new TypeError(errCloseCloseRequestedStream);
+      }
+      if (stream[readableStreamState] === STATE_ERRORED) {
+        throw new TypeError(errCloseErroredStream);
+      }
+      return CloseReadableStream(stream);
+    }
+    enqueue(chunk) {
+      if (IsReadableStreamController(this) === false) {
+        throw new TypeError(errIllegalInvocation);
+      }
+      const stream = this[readableStreamControllerControlledReadableStream];
+      if (stream[readableStreamState] === STATE_ERRORED) {
+        throw stream[readableStreamStoredError];
+      }
+      if (stream[readableStreamBits] & CLOSE_REQUESTED) {
+        throw new TypeError(errEnqueueInCloseRequestedStream);
+      }
+      return EnqueueInReadableStream(stream, chunk);
+    }
+    error(e) {
+      if (IsReadableStreamController(this) === false) {
+        throw new TypeError(errIllegalInvocation);
+      }
+      const stream = this[readableStreamControllerControlledReadableStream];
+      const state = stream[readableStreamState];
+      if (state !== STATE_READABLE) {
+        if (state === STATE_ERRORED) {
+          throw new TypeError(errErrorErroredStream);
+        }
+        if (state === STATE_CLOSED) {
+          throw new TypeError(errErrorClosedStream);
+        }
+      }
+      return ErrorReadableStream(stream, e);
+    }
+  }
+  class ReadableStreamReader {
+    constructor(stream) {
+      if (IsReadableStream(stream) === false) {
+        throw new TypeError(errReaderConstructorBadArgument);
+      }
+      if (IsReadableStreamLocked(stream) === true) {
+        throw new TypeError(errReaderConstructorStreamAlreadyLocked);
+      }
+      this[readableStreamReaderOwnerReadableStream] = stream;
+      stream[readableStreamReader] = this;
+      this[readableStreamReaderReadRequests] = new v8.InternalPackedArray();
+      switch (stream[readableStreamState]) {
+        case STATE_READABLE:
+          this[readableStreamReaderClosedPromise] = v8.createPromise();
+          break;
+        case STATE_CLOSED:
+          this[readableStreamReaderClosedPromise] = Promise_resolve(undefined);
+          break;
+        case STATE_ERRORED:
+          this[readableStreamReaderClosedPromise] =
+              Promise_reject(stream[readableStreamStoredError]);
+          break;
+      }
+    }
+    get closed() {
+      if (IsReadableStreamReader(this) === false) {
+        return Promise_reject(new TypeError(errIllegalInvocation));
+      }
+      return this[readableStreamReaderClosedPromise];
+    }
+    cancel(reason) {
+      if (IsReadableStreamReader(this) === false) {
+        return Promise_reject(new TypeError(errIllegalInvocation));
+      }
+      const stream = this[readableStreamReaderOwnerReadableStream];
+      if (stream === undefined) {
+        return Promise_reject(new TypeError(errCancelReleasedReader));
+      }
+      return CancelReadableStream(stream, reason);
+    }
+    read() {
+      if (IsReadableStreamReader(this) === false) {
+        return Promise_reject(new TypeError(errIllegalInvocation));
+      }
+      if (this[readableStreamReaderOwnerReadableStream] === undefined) {
+        return Promise_reject(new TypeError(errReadReleasedReader));
+      }
+      return ReadFromReadableStreamReader(this);
+    }
+    releaseLock() {
+      if (IsReadableStreamReader(this) === false) {
+        throw new TypeError(errIllegalInvocation);
+      }
+      const stream = this[readableStreamReaderOwnerReadableStream];
+      if (stream === undefined) {
+        return undefined;
+      }
+      if (this[readableStreamReaderReadRequests].length > 0) {
+        throw new TypeError(errReleaseReaderWithPendingRead);
+      }
+      if (stream[readableStreamState] === STATE_READABLE) {
+        v8.rejectPromise(this[readableStreamReaderClosedPromise],
+            new TypeError(errReleasedReaderClosedPromise));
+      } else {
+        this[readableStreamReaderClosedPromise] = Promise_reject(new TypeError(
+            errReleasedReaderClosedPromise));
+      }
+      this[readableStreamReaderOwnerReadableStream][readableStreamReader] =
+          undefined;
+      this[readableStreamReaderOwnerReadableStream] = undefined;
+    }
+  }
+  function AcquireReadableStreamReader(stream) {
+    return new ReadableStreamReader(stream);
+  }
+  function CancelReadableStream(stream, reason) {
+    stream[readableStreamBits] |= DISTURBED;
+    const state = stream[readableStreamState];
+    if (state === STATE_CLOSED) {
+      return Promise_resolve(undefined);
+    }
+    if (state === STATE_ERRORED) {
+      return Promise_reject(stream[readableStreamStoredError]);
+    }
+    stream[readableStreamQueue] = new v8.InternalPackedArray();
+    FinishClosingReadableStream(stream);
+    const underlyingSource = stream[readableStreamUnderlyingSource];
+    const sourceCancelPromise = PromiseCallOrNoop(
+        underlyingSource, 'cancel', reason, 'underlyingSource.cancel');
+    return thenPromise(sourceCancelPromise, () => undefined);
+  }
+  function CloseReadableStream(stream) {
+    if (stream[readableStreamState] === STATE_CLOSED) {
+      return undefined;
+    }
+    stream[readableStreamBits] |= CLOSE_REQUESTED;
+    if (stream[readableStreamQueue].length === 0) {
+      return FinishClosingReadableStream(stream);
+    }
+  }
+  function EnqueueInReadableStream(stream, chunk) {
+    if (stream[readableStreamState] === STATE_CLOSED) {
+      return undefined;
+    }
+    if (IsReadableStreamLocked(stream) === true &&
+        stream[readableStreamReader][readableStreamReaderReadRequests].length >
+            0) {
+      const readRequest =
+          stream[readableStreamReader][readableStreamReaderReadRequests]
+              .shift();
+      v8.resolvePromise(readRequest, CreateIterResultObject(chunk, false));
+    } else {
+      let chunkSize = 1;
+      const strategySize = stream[readableStreamStrategySize];
+      if (strategySize !== undefined) {
+        try {
+          chunkSize = strategySize(chunk);
+        } catch (chunkSizeE) {
+          if (stream[readableStreamState] === STATE_READABLE) {
+            ErrorReadableStream(stream, chunkSizeE);
+          }
+          throw chunkSizeE;
+        }
+      }
+      try {
+        EnqueueValueWithSize(stream, chunk, chunkSize);
+      } catch (enqueueE) {
+        if (stream[readableStreamState] === STATE_READABLE) {
+          ErrorReadableStream(stream, enqueueE);
+        }
+        throw enqueueE;
+      }
+    }
+    RequestReadableStreamPull(stream);
+  }
+  function ErrorReadableStream(stream, e) {
+    stream[readableStreamQueue] = new v8.InternalPackedArray();
+    stream[readableStreamStoredError] = e;
+    stream[readableStreamState] = STATE_ERRORED;
+    const reader = stream[readableStreamReader];
+    if (reader === undefined) {
+      return undefined;
+    }
+    const readRequests = reader[readableStreamReaderReadRequests];
+    for (let i = 0; i < readRequests.length; ++i) {
+      v8.rejectPromise(readRequests[i], e);
+    }
+    reader[readableStreamReaderReadRequests] = new v8.InternalPackedArray();
+    v8.rejectPromise(reader[readableStreamReaderClosedPromise], e);
+  }
+  function FinishClosingReadableStream(stream) {
+    stream[readableStreamState] = STATE_CLOSED;
+    const reader = stream[readableStreamReader];
+    if (reader === undefined) {
+      return undefined;
+    }
+    const readRequests = reader[readableStreamReaderReadRequests];
+    for (let i = 0; i < readRequests.length; ++i) {
+      v8.resolvePromise(
+          readRequests[i], CreateIterResultObject(undefined, true));
+    }
+    reader[readableStreamReaderReadRequests] = new v8.InternalPackedArray();
+    v8.resolvePromise(reader[readableStreamReaderClosedPromise], undefined);
+  }
+  function GetReadableStreamDesiredSize(stream) {
+    const queueSize = GetTotalQueueSize(stream);
+    return stream[readableStreamStrategyHWM] - queueSize;
+  }
+  function IsReadableStream(x) {
+    return hasOwnProperty(x, readableStreamUnderlyingSource);
+  }
+  function IsReadableStreamDisturbed(stream) {
+    return stream[readableStreamBits] & DISTURBED;
+  }
+  function IsReadableStreamLocked(stream) {
+    return stream[readableStreamReader] !== undefined;
+  }
+  function IsReadableStreamController(x) {
+    return hasOwnProperty(x, readableStreamControllerControlledReadableStream);
+  }
+  function IsReadableStreamReader(x) {
+    return hasOwnProperty(x, readableStreamReaderOwnerReadableStream);
+  }
+  function ReadFromReadableStreamReader(reader) {
+    const stream = reader[readableStreamReaderOwnerReadableStream];
+    stream[readableStreamBits] |= DISTURBED;
+    if (stream[readableStreamState] === STATE_CLOSED) {
+      return Promise_resolve(CreateIterResultObject(undefined, true));
+    }
+    if (stream[readableStreamState] === STATE_ERRORED) {
+      return Promise_reject(stream[readableStreamStoredError]);
+    }
+    const queue = stream[readableStreamQueue];
+    if (queue.length > 0) {
+      const chunk = DequeueValue(stream);
+      if (stream[readableStreamBits] & CLOSE_REQUESTED && queue.length === 0) {
+        FinishClosingReadableStream(stream);
+      } else {
+        RequestReadableStreamPull(stream);
+      }
+      return Promise_resolve(CreateIterResultObject(chunk, false));
+    } else {
+      const readRequest = v8.createPromise();
+      reader[readableStreamReaderReadRequests].push(readRequest);
+      RequestReadableStreamPull(stream);
+      return readRequest;
+    }
+  }
+  function RequestReadableStreamPull(stream) {
+    const shouldPull = ShouldReadableStreamPull(stream);
+    if (shouldPull === false) {
+      return undefined;
+    }
+    if (stream[readableStreamBits] & PULLING) {
+      stream[readableStreamBits] |= PULL_AGAIN;
+      return undefined;
+    }
+    stream[readableStreamBits] |= PULLING;
+    const underlyingSource = stream[readableStreamUnderlyingSource];
+    const controller = stream[readableStreamController];
+    const pullPromise = PromiseCallOrNoop(
+        underlyingSource, 'pull', controller, 'underlyingSource.pull');
+    thenPromise(pullPromise,
+        () => {
+          stream[readableStreamBits] &= ~PULLING;
+          if (stream[readableStreamBits] & PULL_AGAIN) {
+            stream[readableStreamBits] &= ~PULL_AGAIN;
+            return RequestReadableStreamPull(stream);
+          }
+        },
+        e => {
+          if (stream[readableStreamState] === STATE_READABLE) {
+            return ErrorReadableStream(stream, e);
+          }
+        });
+  }
+  function ShouldReadableStreamPull(stream) {
+    const state = stream[readableStreamState];
+    if (state === STATE_CLOSED || state === STATE_ERRORED) {
+      return false;
+    }
+    if (stream[readableStreamBits] & CLOSE_REQUESTED) {
+      return false;
+    }
+    if (!(stream[readableStreamBits] & STARTED)) {
+      return false;
+    }
+    if (IsReadableStreamLocked(stream) === true) {
+      const reader = stream[readableStreamReader];
+      const readRequests = reader[readableStreamReaderReadRequests];
+      if (readRequests.length > 0) {
+        return true;
+      }
+    }
+    const desiredSize = GetReadableStreamDesiredSize(stream);
+    if (desiredSize > 0) {
+      return true;
+    }
+    return false;
+  }
+  function TeeReadableStream(stream) {
+    const reader = AcquireReadableStreamReader(stream);
+    let closedOrErrored = false;
+    let canceled1 = false;
+    let canceled2 = false;
+    let reason1;
+    let reason2;
+    let promise = v8.createPromise();
+    const branch1 = new ReadableStream({pull, cancel: cancel1});
+    const branch2 = new ReadableStream({pull, cancel: cancel2});
+    thenPromise(
+        reader[readableStreamReaderClosedPromise], undefined, function(r) {
+          if (closedOrErrored === true) {
+            return;
+          }
+          ErrorReadableStream(branch1, r);
+          ErrorReadableStream(branch2, r);
+          closedOrErrored = true;
+        });
+    return [branch1, branch2];
+    function pull() {
+      return thenPromise(
+          ReadFromReadableStreamReader(reader), function(result) {
+            const value = result.value;
+            const done = result.done;
+            if (done === true && closedOrErrored === false) {
+              CloseReadableStream(branch1);
+              CloseReadableStream(branch2);
+              closedOrErrored = true;
+            }
+            if (closedOrErrored === true) {
+              return;
+            }
+            if (canceled1 === false) {
+              EnqueueInReadableStream(branch1, value);
+            }
+            if (canceled2 === false) {
+              EnqueueInReadableStream(branch2, value);
+            }
+          });
+    }
+    function cancel1(reason) {
+      canceled1 = true;
+      reason1 = reason;
+      if (canceled2 === true) {
+        const compositeReason = [reason1, reason2];
+        const cancelResult = CancelReadableStream(stream, compositeReason);
+        v8.resolvePromise(promise, cancelResult);
+      }
+      return promise;
+    }
+    function cancel2(reason) {
+      canceled2 = true;
+      reason2 = reason;
+      if (canceled1 === true) {
+        const compositeReason = [reason1, reason2];
+        const cancelResult = CancelReadableStream(stream, compositeReason);
+        v8.resolvePromise(promise, cancelResult);
+      }
+      return promise;
+    }
+  }
+  function DequeueValue(stream) {
+    const result = stream[readableStreamQueue].shift();
+    stream[readableStreamQueueSize] -= result.size;
+    return result.value;
+  }
+  function EnqueueValueWithSize(stream, value, size) {
+    size = Number(size);
+    if (Number_isNaN(size) || size === +Infinity || size < 0) {
+      throw new RangeError(errInvalidSize);
+    }
+    stream[readableStreamQueueSize] += size;
+    stream[readableStreamQueue].push({value, size});
+  }
+  function GetTotalQueueSize(stream) { return stream[readableStreamQueueSize]; }
+  function ValidateAndNormalizeQueuingStrategy(size, highWaterMark) {
+    if (size !== undefined && typeof size !== 'function') {
+      throw new TypeError(errSizeNotAFunction);
+    }
+    highWaterMark = Number(highWaterMark);
+    if (Number_isNaN(highWaterMark)) {
+      throw new TypeError(errInvalidHWM);
+    }
+    if (highWaterMark < 0) {
+      throw new RangeError(errInvalidHWM);
+    }
+    return {size, highWaterMark};
+  }
+  function CallOrNoop(O, P, arg, nameForError) {
+    const method = O[P];
+    if (method === undefined) {
+      return undefined;
+    }
+    if (typeof method !== 'function') {
+      throw new TypeError(errTmplMustBeFunctionOrUndefined(nameForError));
+    }
+    return callFunction(method, O, arg);
+  }
+  function PromiseCallOrNoop(O, P, arg, nameForError) {
+    let method;
+    try {
+      method = O[P];
+    } catch (methodE) {
+      return Promise_reject(methodE);
+    }
+    if (method === undefined) {
+      return Promise_resolve(undefined);
+    }
+    if (typeof method !== 'function') {
+      return Promise_reject(errTmplMustBeFunctionOrUndefined(nameForError));
+    }
+    try {
+      return Promise_resolve(callFunction(method, O, arg));
+    } catch (e) {
+      return Promise_reject(e);
+    }
+  }
+  function CreateIterResultObject(value, done) { return {value, done}; }
+  defineProperty(global, 'ReadableStream', {
+    value: ReadableStream,
+    enumerable: false,
+    configurable: true,
+    writable: true
+  });
+  binding.AcquireReadableStreamReader = AcquireReadableStreamReader;
+  binding.IsReadableStream = IsReadableStream;
+  binding.IsReadableStreamDisturbed = IsReadableStreamDisturbed;
+  binding.IsReadableStreamLocked = IsReadableStreamLocked;
+  binding.IsReadableStreamReader = IsReadableStreamReader;
+  binding.ReadFromReadableStreamReader = ReadFromReadableStreamReader;
+});
diff --git a/bin/nt_86/release/VS2013/libcef_dll_wrapper.lib b/bin/nt_86/release/VS2013/libcef_dll_wrapper.lib
new file mode 100644
index 0000000..54a4874
Binary files /dev/null and b/bin/nt_86/release/VS2013/libcef_dll_wrapper.lib differ
diff --git a/bin/nt_86/release/VS2015/libcef_dll_wrapper.lib b/bin/nt_86/release/VS2015/libcef_dll_wrapper.lib
new file mode 100644
index 0000000..1ef901b
Binary files /dev/null and b/bin/nt_86/release/VS2015/libcef_dll_wrapper.lib differ
diff --git a/bin/nt_86/release/libcef.lib b/bin/nt_86/release/libcef.lib
new file mode 100644
index 0000000..18ffddd
Binary files /dev/null and b/bin/nt_86/release/libcef.lib differ
diff --git a/bin/nt_86/snapshot_blob.bin b/bin/nt_86/snapshot_blob.bin
new file mode 100644
index 0000000..bb47653
Binary files /dev/null and b/bin/nt_86/snapshot_blob.bin differ
diff --git a/bin/nt_86/ui/assets/img/Loading-animation-03.gif b/bin/nt_86/ui/assets/img/Loading-animation-03.gif
new file mode 100644
index 0000000..11ba8b0
Binary files /dev/null and b/bin/nt_86/ui/assets/img/Loading-animation-03.gif differ
diff --git a/bin/nt_86/widevinecdmadapter.dll b/bin/nt_86/widevinecdmadapter.dll
new file mode 100644
index 0000000..5683cf2
Binary files /dev/null and b/bin/nt_86/widevinecdmadapter.dll differ
diff --git a/build_launcher_gcc_linux.sh b/build_launcher_gcc_linux.sh
new file mode 100644
index 0000000..e69de29
diff --git a/build_launcher_visual_studio.bat b/build_launcher_visual_studio.bat
new file mode 100644
index 0000000..18bc31f
--- /dev/null
+++ b/build_launcher_visual_studio.bat
@@ -0,0 +1,86 @@
+@echo off
+
+rem vsv   visual studio "version" , year
+set vsv=2019
+
+rem cpuarch    cpu architeture, 86 / 64
+set cpuarch=64
+
+rem build type, debug or release
+set build_type=release
+
+echo.
+:: configure visual studio.
+echo.
+echo visual studio set
+call "C:\Program Files (x86)\Microsoft Visual Studio\%vsv%\Community\VC\Auxiliary\Build\vcvarsall.bat" x%cpuarch%
+
+:: Verify that the environment has been configured correctly
+if %ERRORLEVEL% neq 0 (
+    echo Error configuring Visual Studio environment.
+    pause
+    exit /b %ERRORLEVEL%
+)
+
+
+echo echo.
+
+echo.
+echo ==== BUILD -- main.c -- )
+echo.
+
+
+@cl /c /O2 /MT /I "src" /I "src/include" /I "src/include/libcef" "src/lpc_launcher/main.c" /Fo"bin/lpc_launcher/"
+
+echo.
+echo ==== BUILD -- display_manager_nt.c -- )
+echo.
+
+
+@cl /c /O2 /MT /I "src" /I "src/include" /I "src/include/libcef" "src/lpc_launcher/display_manager/display_manager_nt.c" /Fo"bin/lpc_launcher/"
+
+echo.
+echo  __________(RESOURCE)________________________________________
+echo /____________________________________________________________\
+     rc /r /fo"bin/lpc_launcher/pres.res" "src/lpc_launcher/resource/pres.rc"
+echo ______________________________________________________________
+echo \____________________________________________________________/
+echo.
+echo.
+
+echo.
+echo =========== LINKER ==============
+
+
+link bin/lpc_launcher/*.obj ^
+        "lib/nt_%cpuarch%/libcef.lib" ^
+        "bin/lpc_launcher/pres.res" ^
+        /SUBSYSTEM:CONSOLE ^
+        /DYNAMICBASE:NO /NXCOMPAT:NO ^
+        /OUT:lpc_launcher.exe ^
+        user32.lib gdi32.lib ole32.lib shell32.lib comdlg32.lib advapi32.lib winmm.lib oleaut32.lib
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+pause
diff --git a/build_launcher_watcom.bat b/build_launcher_watcom.bat
new file mode 100644
index 0000000..7ece072
--- /dev/null
+++ b/build_launcher_watcom.bat
@@ -0,0 +1,67 @@
+@echo off
+
+
+rem This script with watcom will still exist to maintain compatibility with older Windows systems
+
+echo echo.
+
+echo.
+echo BUILD -- simple_app.cc -- )
+echo.
+
+@wcc386 -ecc /6r -fp6 -ms -ot -zkl -ol -i="src/include" -i="src/include/libcef" -e999 "src/lpc_launcher/main.c" -fo="bin/lpc_launcher/" ^
+     2>&1 | findstr /V /C:"Open Watcom" /C:"Portions" /C:"See"
+
+
+echo.
+echo.
+@wcc386 -ecc /6r -fp6 -ms -ot -zkl -ol -i="src" -i="src/lpc_launcher" "src/lpc_launcher/display_manager/display_manager_nt.c" -fo="bin/lpc_launcher/" ^
+     2>&1 | findstr /V /C:"Open Watcom" /C:"Portions" /C:"See"
+
+
+echo.
+echo  __________(RESOURCE)________________________________________
+echo /____________________________________________________________\
+     @wrc src/lpc_launcher/resource/pres.rc -r -fo="bin/lpc_launcher/pres.res"   ^
+     2>&1 | findstr /V /C:"Open Watcom" /C:"Portions" /C:"See"
+echo ______________________________________________________________
+echo \____________________________________________________________/
+echo.
+echo.
+
+echo.
+echo =========== LINKER ==============
+
+@wlink option resource 'bin/lpc_launcher/pres.res' ^
+          name lpc_launcher.exe ^
+          file bin/lpc_launcher/*.obj Library ^
+                                        user32.lib, ^
+                                        lib/nt_86/libcef.lib
+
+echo.
+echo.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+pause
diff --git a/lib/linux_64/libcef.so b/lib/linux_64/libcef.so
new file mode 100644
index 0000000..80668c7
Binary files /dev/null and b/lib/linux_64/libcef.so differ
diff --git a/lib/nt_64/libcef.lib b/lib/nt_64/libcef.lib
new file mode 100644
index 0000000..3635886
Binary files /dev/null and b/lib/nt_64/libcef.lib differ
diff --git a/lib/nt_86/libcef.lib b/lib/nt_86/libcef.lib
new file mode 100644
index 0000000..18ffddd
Binary files /dev/null and b/lib/nt_86/libcef.lib differ
diff --git a/lib/nt_86/libcjson.lib b/lib/nt_86/libcjson.lib
new file mode 100644
index 0000000..31b0a6b
Binary files /dev/null and b/lib/nt_86/libcjson.lib differ
diff --git a/lib/nt_86/libcrypto.lib b/lib/nt_86/libcrypto.lib
new file mode 100644
index 0000000..cbe6570
Binary files /dev/null and b/lib/nt_86/libcrypto.lib differ
diff --git a/lib/nt_86/libcurl_a.lib b/lib/nt_86/libcurl_a.lib
new file mode 100644
index 0000000..5fda36d
Binary files /dev/null and b/lib/nt_86/libcurl_a.lib differ
diff --git a/lib/nt_86/libssl.lib b/lib/nt_86/libssl.lib
new file mode 100644
index 0000000..4efc28b
Binary files /dev/null and b/lib/nt_86/libssl.lib differ
diff --git a/lib/nt_86/pthreadWC2.lib b/lib/nt_86/pthreadWC2.lib
new file mode 100644
index 0000000..a1baa56
Binary files /dev/null and b/lib/nt_86/pthreadWC2.lib differ
diff --git a/lpc_launcher_vsc.code-workspace b/lpc_launcher_vsc.code-workspace
new file mode 100644
index 0000000..876a149
--- /dev/null
+++ b/lpc_launcher_vsc.code-workspace
@@ -0,0 +1,8 @@
+{
+	"folders": [
+		{
+			"path": "."
+		}
+	],
+	"settings": {}
+}
\ No newline at end of file
diff --git a/src/include/cJSON/cJSON.h b/src/include/cJSON/cJSON.h
new file mode 100644
index 0000000..88cf0bc
--- /dev/null
+++ b/src/include/cJSON/cJSON.h
@@ -0,0 +1,300 @@
+/*
+  Copyright (c) 2009-2017 Dave Gamble and cJSON contributors
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+  THE SOFTWARE.
+*/
+
+#ifndef cJSON__h
+#define cJSON__h
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#if !defined(__WINDOWS__) && (defined(WIN32) || defined(WIN64) || defined(_MSC_VER) || defined(_WIN32))
+#define __WINDOWS__
+#endif
+
+#ifdef __WINDOWS__
+
+/* When compiling for windows, we specify a specific calling convention to avoid issues where we are being called from a project with a different default calling convention.  For windows you have 3 define options:
+
+CJSON_HIDE_SYMBOLS - Define this in the case where you don't want to ever dllexport symbols
+CJSON_EXPORT_SYMBOLS - Define this on library build when you want to dllexport symbols (default)
+CJSON_IMPORT_SYMBOLS - Define this if you want to dllimport symbol
+
+For *nix builds that support visibility attribute, you can define similar behavior by
+
+setting default visibility to hidden by adding
+-fvisibility=hidden (for gcc)
+or
+-xldscope=hidden (for sun cc)
+to CFLAGS
+
+then using the CJSON_API_VISIBILITY flag to "export" the same symbols the way CJSON_EXPORT_SYMBOLS does
+
+*/
+
+#define CJSON_CDECL __cdecl
+#define CJSON_STDCALL __stdcall
+
+/* export symbols by default, this is necessary for copy pasting the C and header file */
+#if !defined(CJSON_HIDE_SYMBOLS) && !defined(CJSON_IMPORT_SYMBOLS) && !defined(CJSON_EXPORT_SYMBOLS)
+#define CJSON_EXPORT_SYMBOLS
+#endif
+
+#if defined(CJSON_HIDE_SYMBOLS)
+#define CJSON_PUBLIC(type)   type CJSON_STDCALL
+#elif defined(CJSON_EXPORT_SYMBOLS)
+#define CJSON_PUBLIC(type)   __declspec(dllexport) type CJSON_STDCALL
+#elif defined(CJSON_IMPORT_SYMBOLS)
+#define CJSON_PUBLIC(type)   __declspec(dllimport) type CJSON_STDCALL
+#endif
+#else /* !__WINDOWS__ */
+#define CJSON_CDECL
+#define CJSON_STDCALL
+
+#if (defined(__GNUC__) || defined(__SUNPRO_CC) || defined (__SUNPRO_C)) && defined(CJSON_API_VISIBILITY)
+#define CJSON_PUBLIC(type)   __attribute__((visibility("default"))) type
+#else
+#define CJSON_PUBLIC(type) type
+#endif
+#endif
+
+/* project version */
+#define CJSON_VERSION_MAJOR 1
+#define CJSON_VERSION_MINOR 7
+#define CJSON_VERSION_PATCH 18
+
+#include <stddef.h>
+
+/* cJSON Types: */
+#define cJSON_Invalid (0)
+#define cJSON_False  (1 << 0)
+#define cJSON_True   (1 << 1)
+#define cJSON_NULL   (1 << 2)
+#define cJSON_Number (1 << 3)
+#define cJSON_String (1 << 4)
+#define cJSON_Array  (1 << 5)
+#define cJSON_Object (1 << 6)
+#define cJSON_Raw    (1 << 7) /* raw json */
+
+#define cJSON_IsReference 256
+#define cJSON_StringIsConst 512
+
+/* The cJSON structure: */
+typedef struct cJSON
+{
+    /* next/prev allow you to walk array/object chains. Alternatively, use GetArraySize/GetArrayItem/GetObjectItem */
+    struct cJSON *next;
+    struct cJSON *prev;
+    /* An array or object item will have a child pointer pointing to a chain of the items in the array/object. */
+    struct cJSON *child;
+
+    /* The type of the item, as above. */
+    int type;
+
+    /* The item's string, if type==cJSON_String  and type == cJSON_Raw */
+    char *valuestring;
+    /* writing to valueint is DEPRECATED, use cJSON_SetNumberValue instead */
+    int valueint;
+    /* The item's number, if type==cJSON_Number */
+    double valuedouble;
+
+    /* The item's name string, if this item is the child of, or is in the list of subitems of an object. */
+    char *string;
+} cJSON;
+
+typedef struct cJSON_Hooks
+{
+      /* malloc/free are CDECL on Windows regardless of the default calling convention of the compiler, so ensure the hooks allow passing those functions directly. */
+      void *(CJSON_CDECL *malloc_fn)(size_t sz);
+      void (CJSON_CDECL *free_fn)(void *ptr);
+} cJSON_Hooks;
+
+typedef int cJSON_bool;
+
+/* Limits how deeply nested arrays/objects can be before cJSON rejects to parse them.
+ * This is to prevent stack overflows. */
+#ifndef CJSON_NESTING_LIMIT
+#define CJSON_NESTING_LIMIT 1000
+#endif
+
+/* returns the version of cJSON as a string */
+CJSON_PUBLIC(const char*) cJSON_Version(void);
+
+/* Supply malloc, realloc and free functions to cJSON */
+CJSON_PUBLIC(void) cJSON_InitHooks(cJSON_Hooks* hooks);
+
+/* Memory Management: the caller is always responsible to free the results from all variants of cJSON_Parse (with cJSON_Delete) and cJSON_Print (with stdlib free, cJSON_Hooks.free_fn, or cJSON_free as appropriate). The exception is cJSON_PrintPreallocated, where the caller has full responsibility of the buffer. */
+/* Supply a block of JSON, and this returns a cJSON object you can interrogate. */
+CJSON_PUBLIC(cJSON *) cJSON_Parse(const char *value);
+CJSON_PUBLIC(cJSON *) cJSON_ParseWithLength(const char *value, size_t buffer_length);
+/* ParseWithOpts allows you to require (and check) that the JSON is null terminated, and to retrieve the pointer to the final byte parsed. */
+/* If you supply a ptr in return_parse_end and parsing fails, then return_parse_end will contain a pointer to the error so will match cJSON_GetErrorPtr(). */
+CJSON_PUBLIC(cJSON *) cJSON_ParseWithOpts(const char *value, const char **return_parse_end, cJSON_bool require_null_terminated);
+CJSON_PUBLIC(cJSON *) cJSON_ParseWithLengthOpts(const char *value, size_t buffer_length, const char **return_parse_end, cJSON_bool require_null_terminated);
+
+/* Render a cJSON entity to text for transfer/storage. */
+CJSON_PUBLIC(char *) cJSON_Print(const cJSON *item);
+/* Render a cJSON entity to text for transfer/storage without any formatting. */
+CJSON_PUBLIC(char *) cJSON_PrintUnformatted(const cJSON *item);
+/* Render a cJSON entity to text using a buffered strategy. prebuffer is a guess at the final size. guessing well reduces reallocation. fmt=0 gives unformatted, =1 gives formatted */
+CJSON_PUBLIC(char *) cJSON_PrintBuffered(const cJSON *item, int prebuffer, cJSON_bool fmt);
+/* Render a cJSON entity to text using a buffer already allocated in memory with given length. Returns 1 on success and 0 on failure. */
+/* NOTE: cJSON is not always 100% accurate in estimating how much memory it will use, so to be safe allocate 5 bytes more than you actually need */
+CJSON_PUBLIC(cJSON_bool) cJSON_PrintPreallocated(cJSON *item, char *buffer, const int length, const cJSON_bool format);
+/* Delete a cJSON entity and all subentities. */
+CJSON_PUBLIC(void) cJSON_Delete(cJSON *item);
+
+/* Returns the number of items in an array (or object). */
+CJSON_PUBLIC(int) cJSON_GetArraySize(const cJSON *array);
+/* Retrieve item number "index" from array "array". Returns NULL if unsuccessful. */
+CJSON_PUBLIC(cJSON *) cJSON_GetArrayItem(const cJSON *array, int index);
+/* Get item "string" from object. Case insensitive. */
+CJSON_PUBLIC(cJSON *) cJSON_GetObjectItem(const cJSON * const object, const char * const string);
+CJSON_PUBLIC(cJSON *) cJSON_GetObjectItemCaseSensitive(const cJSON * const object, const char * const string);
+CJSON_PUBLIC(cJSON_bool) cJSON_HasObjectItem(const cJSON *object, const char *string);
+/* For analysing failed parses. This returns a pointer to the parse error. You'll probably need to look a few chars back to make sense of it. Defined when cJSON_Parse() returns 0. 0 when cJSON_Parse() succeeds. */
+CJSON_PUBLIC(const char *) cJSON_GetErrorPtr(void);
+
+/* Check item type and return its value */
+CJSON_PUBLIC(char *) cJSON_GetStringValue(const cJSON * const item);
+CJSON_PUBLIC(double) cJSON_GetNumberValue(const cJSON * const item);
+
+/* These functions check the type of an item */
+CJSON_PUBLIC(cJSON_bool) cJSON_IsInvalid(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsFalse(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsTrue(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsBool(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsNull(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsNumber(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsString(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsArray(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsObject(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsRaw(const cJSON * const item);
+
+/* These calls create a cJSON item of the appropriate type. */
+CJSON_PUBLIC(cJSON *) cJSON_CreateNull(void);
+CJSON_PUBLIC(cJSON *) cJSON_CreateTrue(void);
+CJSON_PUBLIC(cJSON *) cJSON_CreateFalse(void);
+CJSON_PUBLIC(cJSON *) cJSON_CreateBool(cJSON_bool boolean);
+CJSON_PUBLIC(cJSON *) cJSON_CreateNumber(double num);
+CJSON_PUBLIC(cJSON *) cJSON_CreateString(const char *string);
+/* raw json */
+CJSON_PUBLIC(cJSON *) cJSON_CreateRaw(const char *raw);
+CJSON_PUBLIC(cJSON *) cJSON_CreateArray(void);
+CJSON_PUBLIC(cJSON *) cJSON_CreateObject(void);
+
+/* Create a string where valuestring references a string so
+ * it will not be freed by cJSON_Delete */
+CJSON_PUBLIC(cJSON *) cJSON_CreateStringReference(const char *string);
+/* Create an object/array that only references it's elements so
+ * they will not be freed by cJSON_Delete */
+CJSON_PUBLIC(cJSON *) cJSON_CreateObjectReference(const cJSON *child);
+CJSON_PUBLIC(cJSON *) cJSON_CreateArrayReference(const cJSON *child);
+
+/* These utilities create an Array of count items.
+ * The parameter count cannot be greater than the number of elements in the number array, otherwise array access will be out of bounds.*/
+CJSON_PUBLIC(cJSON *) cJSON_CreateIntArray(const int *numbers, int count);
+CJSON_PUBLIC(cJSON *) cJSON_CreateFloatArray(const float *numbers, int count);
+CJSON_PUBLIC(cJSON *) cJSON_CreateDoubleArray(const double *numbers, int count);
+CJSON_PUBLIC(cJSON *) cJSON_CreateStringArray(const char *const *strings, int count);
+
+/* Append item to the specified array/object. */
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToArray(cJSON *array, cJSON *item);
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item);
+/* Use this when string is definitely const (i.e. a literal, or as good as), and will definitely survive the cJSON object.
+ * WARNING: When this function was used, make sure to always check that (item->type & cJSON_StringIsConst) is zero before
+ * writing to `item->string` */
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObjectCS(cJSON *object, const char *string, cJSON *item);
+/* Append reference to item to the specified array/object. Use this when you want to add an existing cJSON to a new cJSON, but don't want to corrupt your existing cJSON. */
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item);
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item);
+
+/* Remove/Detach items from Arrays/Objects. */
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemViaPointer(cJSON *parent, cJSON * const item);
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromArray(cJSON *array, int which);
+CJSON_PUBLIC(void) cJSON_DeleteItemFromArray(cJSON *array, int which);
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObject(cJSON *object, const char *string);
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObjectCaseSensitive(cJSON *object, const char *string);
+CJSON_PUBLIC(void) cJSON_DeleteItemFromObject(cJSON *object, const char *string);
+CJSON_PUBLIC(void) cJSON_DeleteItemFromObjectCaseSensitive(cJSON *object, const char *string);
+
+/* Update array items. */
+CJSON_PUBLIC(cJSON_bool) cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem); /* Shifts pre-existing items to the right. */
+CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemViaPointer(cJSON * const parent, cJSON * const item, cJSON * replacement);
+CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInArray(cJSON *array, int which, cJSON *newitem);
+CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObject(cJSON *object,const char *string,cJSON *newitem);
+CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObjectCaseSensitive(cJSON *object,const char *string,cJSON *newitem);
+
+/* Duplicate a cJSON item */
+CJSON_PUBLIC(cJSON *) cJSON_Duplicate(const cJSON *item, cJSON_bool recurse);
+/* Duplicate will create a new, identical cJSON item to the one you pass, in new memory that will
+ * need to be released. With recurse!=0, it will duplicate any children connected to the item.
+ * The item->next and ->prev pointers are always zero on return from Duplicate. */
+/* Recursively compare two cJSON items for equality. If either a or b is NULL or invalid, they will be considered unequal.
+ * case_sensitive determines if object keys are treated case sensitive (1) or case insensitive (0) */
+CJSON_PUBLIC(cJSON_bool) cJSON_Compare(const cJSON * const a, const cJSON * const b, const cJSON_bool case_sensitive);
+
+/* Minify a strings, remove blank characters(such as ' ', '\t', '\r', '\n') from strings.
+ * The input pointer json cannot point to a read-only address area, such as a string constant, 
+ * but should point to a readable and writable address area. */
+CJSON_PUBLIC(void) cJSON_Minify(char *json);
+
+/* Helper functions for creating and adding items to an object at the same time.
+ * They return the added item or NULL on failure. */
+CJSON_PUBLIC(cJSON*) cJSON_AddNullToObject(cJSON * const object, const char * const name);
+CJSON_PUBLIC(cJSON*) cJSON_AddTrueToObject(cJSON * const object, const char * const name);
+CJSON_PUBLIC(cJSON*) cJSON_AddFalseToObject(cJSON * const object, const char * const name);
+CJSON_PUBLIC(cJSON*) cJSON_AddBoolToObject(cJSON * const object, const char * const name, const cJSON_bool boolean);
+CJSON_PUBLIC(cJSON*) cJSON_AddNumberToObject(cJSON * const object, const char * const name, const double number);
+CJSON_PUBLIC(cJSON*) cJSON_AddStringToObject(cJSON * const object, const char * const name, const char * const string);
+CJSON_PUBLIC(cJSON*) cJSON_AddRawToObject(cJSON * const object, const char * const name, const char * const raw);
+CJSON_PUBLIC(cJSON*) cJSON_AddObjectToObject(cJSON * const object, const char * const name);
+CJSON_PUBLIC(cJSON*) cJSON_AddArrayToObject(cJSON * const object, const char * const name);
+
+/* When assigning an integer value, it needs to be propagated to valuedouble too. */
+#define cJSON_SetIntValue(object, number) ((object) ? (object)->valueint = (object)->valuedouble = (number) : (number))
+/* helper for the cJSON_SetNumberValue macro */
+CJSON_PUBLIC(double) cJSON_SetNumberHelper(cJSON *object, double number);
+#define cJSON_SetNumberValue(object, number) ((object != NULL) ? cJSON_SetNumberHelper(object, (double)number) : (number))
+/* Change the valuestring of a cJSON_String object, only takes effect when type of object is cJSON_String */
+CJSON_PUBLIC(char*) cJSON_SetValuestring(cJSON *object, const char *valuestring);
+
+/* If the object is not a boolean type this does nothing and returns cJSON_Invalid else it returns the new type*/
+#define cJSON_SetBoolValue(object, boolValue) ( \
+    (object != NULL && ((object)->type & (cJSON_False|cJSON_True))) ? \
+    (object)->type=((object)->type &(~(cJSON_False|cJSON_True)))|((boolValue)?cJSON_True:cJSON_False) : \
+    cJSON_Invalid\
+)
+
+/* Macro for iterating over an array or object */
+#define cJSON_ArrayForEach(element, array) for(element = (array != NULL) ? (array)->child : NULL; element != NULL; element = element->next)
+
+/* malloc/free objects using the malloc/free functions that have been set with cJSON_InitHooks */
+CJSON_PUBLIC(void *) cJSON_malloc(size_t size);
+CJSON_PUBLIC(void) cJSON_free(void *object);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/include/cJSON/cJSON_Utils.h b/src/include/cJSON/cJSON_Utils.h
new file mode 100644
index 0000000..a970c65
--- /dev/null
+++ b/src/include/cJSON/cJSON_Utils.h
@@ -0,0 +1,88 @@
+/*
+  Copyright (c) 2009-2017 Dave Gamble and cJSON contributors
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+  THE SOFTWARE.
+*/
+
+#ifndef cJSON_Utils__h
+#define cJSON_Utils__h
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#include "cJSON.h"
+
+/* Implement RFC6901 (https://tools.ietf.org/html/rfc6901) JSON Pointer spec. */
+CJSON_PUBLIC(cJSON *) cJSONUtils_GetPointer(cJSON * const object, const char *pointer);
+CJSON_PUBLIC(cJSON *) cJSONUtils_GetPointerCaseSensitive(cJSON * const object, const char *pointer);
+
+/* Implement RFC6902 (https://tools.ietf.org/html/rfc6902) JSON Patch spec. */
+/* NOTE: This modifies objects in 'from' and 'to' by sorting the elements by their key */
+CJSON_PUBLIC(cJSON *) cJSONUtils_GeneratePatches(cJSON * const from, cJSON * const to);
+CJSON_PUBLIC(cJSON *) cJSONUtils_GeneratePatchesCaseSensitive(cJSON * const from, cJSON * const to);
+/* Utility for generating patch array entries. */
+CJSON_PUBLIC(void) cJSONUtils_AddPatchToArray(cJSON * const array, const char * const operation, const char * const path, const cJSON * const value);
+/* Returns 0 for success. */
+CJSON_PUBLIC(int) cJSONUtils_ApplyPatches(cJSON * const object, const cJSON * const patches);
+CJSON_PUBLIC(int) cJSONUtils_ApplyPatchesCaseSensitive(cJSON * const object, const cJSON * const patches);
+
+/*
+// Note that ApplyPatches is NOT atomic on failure. To implement an atomic ApplyPatches, use:
+//int cJSONUtils_AtomicApplyPatches(cJSON **object, cJSON *patches)
+//{
+//    cJSON *modme = cJSON_Duplicate(*object, 1);
+//    int error = cJSONUtils_ApplyPatches(modme, patches);
+//    if (!error)
+//    {
+//        cJSON_Delete(*object);
+//        *object = modme;
+//    }
+//    else
+//    {
+//        cJSON_Delete(modme);
+//    }
+//
+//    return error;
+//}
+// Code not added to library since this strategy is a LOT slower.
+*/
+
+/* Implement RFC7386 (https://tools.ietf.org/html/rfc7396) JSON Merge Patch spec. */
+/* target will be modified by patch. return value is new ptr for target. */
+CJSON_PUBLIC(cJSON *) cJSONUtils_MergePatch(cJSON *target, const cJSON * const patch);
+CJSON_PUBLIC(cJSON *) cJSONUtils_MergePatchCaseSensitive(cJSON *target, const cJSON * const patch);
+/* generates a patch to move from -> to */
+/* NOTE: This modifies objects in 'from' and 'to' by sorting the elements by their key */
+CJSON_PUBLIC(cJSON *) cJSONUtils_GenerateMergePatch(cJSON * const from, cJSON * const to);
+CJSON_PUBLIC(cJSON *) cJSONUtils_GenerateMergePatchCaseSensitive(cJSON * const from, cJSON * const to);
+
+/* Given a root object and a target object, construct a pointer from one to the other. */
+CJSON_PUBLIC(char *) cJSONUtils_FindPointerFromObjectTo(const cJSON * const object, const cJSON * const target);
+
+/* Sorts the members of the object into alphabetical order. */
+CJSON_PUBLIC(void) cJSONUtils_SortObject(cJSON * const object);
+CJSON_PUBLIC(void) cJSONUtils_SortObjectCaseSensitive(cJSON * const object);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/include/curl/curl.h b/src/include/curl/curl.h
new file mode 100644
index 0000000..1030712
--- /dev/null
+++ b/src/include/curl/curl.h
@@ -0,0 +1,2552 @@
+#ifndef __CURL_CURL_H
+#define __CURL_CURL_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2017, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at https://curl.haxx.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ***************************************************************************/
+
+/*
+ * If you have libcurl problems, all docs and details are found here:
+ *   https://curl.haxx.se/libcurl/
+ *
+ * curl-library mailing list subscription and unsubscription web interface:
+ *   https://cool.haxx.se/mailman/listinfo/curl-library/
+ */
+
+#ifdef CURL_NO_OLDIES
+#define CURL_STRICTER
+#endif
+
+#include "curlver.h"         /* libcurl version defines   */
+#include "system.h"          /* determine things run-time */
+#include "curlbuild.h"       /* libcurl build definitions */
+#include "curlrules.h"       /* libcurl rules enforcement */
+
+/*
+ * Define WIN32 when build target is Win32 API
+ */
+
+#if (defined(_WIN32) || defined(__WIN32__)) && \
+     !defined(WIN32) && !defined(__SYMBIAN32__)
+#define WIN32
+#endif
+
+#include <stdio.h>
+#include <limits.h>
+
+#if defined(__FreeBSD__) && (__FreeBSD__ >= 2)
+/* Needed for __FreeBSD_version symbol definition */
+#include <osreldate.h>
+#endif
+
+/* The include stuff here below is mainly for time_t! */
+#include <sys/types.h>
+#include <time.h>
+
+#if defined(WIN32) && !defined(_WIN32_WCE) && !defined(__CYGWIN__)
+#if !(defined(_WINSOCKAPI_) || defined(_WINSOCK_H) || \
+      defined(__LWIP_OPT_H__) || defined(LWIP_HDR_OPT_H))
+/* The check above prevents the winsock2 inclusion if winsock.h already was
+   included, since they can't co-exist without problems */
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#endif
+#endif
+
+/* HP-UX systems version 9, 10 and 11 lack sys/select.h and so does oldish
+   libc5-based Linux systems. Only include it on systems that are known to
+   require it! */
+#if defined(_AIX) || defined(__NOVELL_LIBC__) || defined(__NetBSD__) || \
+    defined(__minix) || defined(__SYMBIAN32__) || defined(__INTEGRITY) || \
+    defined(ANDROID) || defined(__ANDROID__) || defined(__OpenBSD__) || \
+   (defined(__FreeBSD_version) && (__FreeBSD_version < 800000))
+#include <sys/select.h>
+#endif
+
+#if !defined(WIN32) && !defined(_WIN32_WCE)
+#include <sys/socket.h>
+#endif
+
+#if !defined(WIN32) && !defined(__WATCOMC__) && !defined(__VXWORKS__)
+#include <sys/time.h>
+#endif
+
+#ifdef __BEOS__
+#include <support/SupportDefs.h>
+#endif
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+#if defined(BUILDING_LIBCURL) || defined(CURL_STRICTER)
+typedef struct Curl_easy CURL;
+typedef struct Curl_share CURLSH;
+#else
+typedef void CURL;
+typedef void CURLSH;
+#endif
+
+/*
+ * libcurl external API function linkage decorations.
+ */
+
+#ifdef CURL_STATICLIB
+#  define CURL_EXTERN
+#elif defined(WIN32) || defined(_WIN32) || defined(__SYMBIAN32__)
+#  if defined(BUILDING_LIBCURL)
+#    define CURL_EXTERN  __declspec(dllexport)
+#  else
+#    define CURL_EXTERN  __declspec(dllimport)
+#  endif
+#elif defined(BUILDING_LIBCURL) && defined(CURL_HIDDEN_SYMBOLS)
+#  define CURL_EXTERN CURL_EXTERN_SYMBOL
+#else
+#  define CURL_EXTERN
+#endif
+
+#ifndef curl_socket_typedef
+/* socket typedef */
+#if defined(WIN32) && !defined(__LWIP_OPT_H__) && !defined(LWIP_HDR_OPT_H)
+typedef SOCKET curl_socket_t;
+#define CURL_SOCKET_BAD INVALID_SOCKET
+#else
+typedef int curl_socket_t;
+#define CURL_SOCKET_BAD -1
+#endif
+#define curl_socket_typedef
+#endif /* curl_socket_typedef */
+
+struct curl_httppost {
+  struct curl_httppost *next;       /* next entry in the list */
+  char *name;                       /* pointer to allocated name */
+  long namelength;                  /* length of name length */
+  char *contents;                   /* pointer to allocated data contents */
+  long contentslength;              /* length of contents field, see also
+                                       CURL_HTTPPOST_LARGE */
+  char *buffer;                     /* pointer to allocated buffer contents */
+  long bufferlength;                /* length of buffer field */
+  char *contenttype;                /* Content-Type */
+  struct curl_slist *contentheader; /* list of extra headers for this form */
+  struct curl_httppost *more;       /* if one field name has more than one
+                                       file, this link should link to following
+                                       files */
+  long flags;                       /* as defined below */
+
+/* specified content is a file name */
+#define CURL_HTTPPOST_FILENAME (1<<0)
+/* specified content is a file name */
+#define CURL_HTTPPOST_READFILE (1<<1)
+/* name is only stored pointer do not free in formfree */
+#define CURL_HTTPPOST_PTRNAME (1<<2)
+/* contents is only stored pointer do not free in formfree */
+#define CURL_HTTPPOST_PTRCONTENTS (1<<3)
+/* upload file from buffer */
+#define CURL_HTTPPOST_BUFFER (1<<4)
+/* upload file from pointer contents */
+#define CURL_HTTPPOST_PTRBUFFER (1<<5)
+/* upload file contents by using the regular read callback to get the data and
+   pass the given pointer as custom pointer */
+#define CURL_HTTPPOST_CALLBACK (1<<6)
+/* use size in 'contentlen', added in 7.46.0 */
+#define CURL_HTTPPOST_LARGE (1<<7)
+
+  char *showfilename;               /* The file name to show. If not set, the
+                                       actual file name will be used (if this
+                                       is a file part) */
+  void *userp;                      /* custom pointer used for
+                                       HTTPPOST_CALLBACK posts */
+  curl_off_t contentlen;            /* alternative length of contents
+                                       field. Used if CURL_HTTPPOST_LARGE is
+                                       set. Added in 7.46.0 */
+};
+
+/* This is the CURLOPT_PROGRESSFUNCTION callback proto. It is now considered
+   deprecated but was the only choice up until 7.31.0 */
+typedef int (*curl_progress_callback)(void *clientp,
+                                      double dltotal,
+                                      double dlnow,
+                                      double ultotal,
+                                      double ulnow);
+
+/* This is the CURLOPT_XFERINFOFUNCTION callback proto. It was introduced in
+   7.32.0, it avoids floating point and provides more detailed information. */
+typedef int (*curl_xferinfo_callback)(void *clientp,
+                                      curl_off_t dltotal,
+                                      curl_off_t dlnow,
+                                      curl_off_t ultotal,
+                                      curl_off_t ulnow);
+
+#ifndef CURL_MAX_READ_SIZE
+  /* The maximum receive buffer size configurable via CURLOPT_BUFFERSIZE. */
+#define CURL_MAX_READ_SIZE 524288
+#endif
+
+#ifndef CURL_MAX_WRITE_SIZE
+  /* Tests have proven that 20K is a very bad buffer size for uploads on
+     Windows, while 16K for some odd reason performed a lot better.
+     We do the ifndef check to allow this value to easier be changed at build
+     time for those who feel adventurous. The practical minimum is about
+     400 bytes since libcurl uses a buffer of this size as a scratch area
+     (unrelated to network send operations). */
+#define CURL_MAX_WRITE_SIZE 16384
+#endif
+
+#ifndef CURL_MAX_HTTP_HEADER
+/* The only reason to have a max limit for this is to avoid the risk of a bad
+   server feeding libcurl with a never-ending header that will cause reallocs
+   infinitely */
+#define CURL_MAX_HTTP_HEADER (100*1024)
+#endif
+
+/* This is a magic return code for the write callback that, when returned,
+   will signal libcurl to pause receiving on the current transfer. */
+#define CURL_WRITEFUNC_PAUSE 0x10000001
+
+typedef size_t (*curl_write_callback)(char *buffer,
+                                      size_t size,
+                                      size_t nitems,
+                                      void *outstream);
+
+
+
+/* enumeration of file types */
+typedef enum {
+  CURLFILETYPE_FILE = 0,
+  CURLFILETYPE_DIRECTORY,
+  CURLFILETYPE_SYMLINK,
+  CURLFILETYPE_DEVICE_BLOCK,
+  CURLFILETYPE_DEVICE_CHAR,
+  CURLFILETYPE_NAMEDPIPE,
+  CURLFILETYPE_SOCKET,
+  CURLFILETYPE_DOOR, /* is possible only on Sun Solaris now */
+
+  CURLFILETYPE_UNKNOWN /* should never occur */
+} curlfiletype;
+
+#define CURLFINFOFLAG_KNOWN_FILENAME    (1<<0)
+#define CURLFINFOFLAG_KNOWN_FILETYPE    (1<<1)
+#define CURLFINFOFLAG_KNOWN_TIME        (1<<2)
+#define CURLFINFOFLAG_KNOWN_PERM        (1<<3)
+#define CURLFINFOFLAG_KNOWN_UID         (1<<4)
+#define CURLFINFOFLAG_KNOWN_GID         (1<<5)
+#define CURLFINFOFLAG_KNOWN_SIZE        (1<<6)
+#define CURLFINFOFLAG_KNOWN_HLINKCOUNT  (1<<7)
+
+/* Content of this structure depends on information which is known and is
+   achievable (e.g. by FTP LIST parsing). Please see the url_easy_setopt(3) man
+   page for callbacks returning this structure -- some fields are mandatory,
+   some others are optional. The FLAG field has special meaning. */
+struct curl_fileinfo {
+  char *filename;
+  curlfiletype filetype;
+  time_t time;
+  unsigned int perm;
+  int uid;
+  int gid;
+  curl_off_t size;
+  long int hardlinks;
+
+  struct {
+    /* If some of these fields is not NULL, it is a pointer to b_data. */
+    char *time;
+    char *perm;
+    char *user;
+    char *group;
+    char *target; /* pointer to the target filename of a symlink */
+  } strings;
+
+  unsigned int flags;
+
+  /* used internally */
+  char *b_data;
+  size_t b_size;
+  size_t b_used;
+};
+
+/* return codes for CURLOPT_CHUNK_BGN_FUNCTION */
+#define CURL_CHUNK_BGN_FUNC_OK      0
+#define CURL_CHUNK_BGN_FUNC_FAIL    1 /* tell the lib to end the task */
+#define CURL_CHUNK_BGN_FUNC_SKIP    2 /* skip this chunk over */
+
+/* if splitting of data transfer is enabled, this callback is called before
+   download of an individual chunk started. Note that parameter "remains" works
+   only for FTP wildcard downloading (for now), otherwise is not used */
+typedef long (*curl_chunk_bgn_callback)(const void *transfer_info,
+                                        void *ptr,
+                                        int remains);
+
+/* return codes for CURLOPT_CHUNK_END_FUNCTION */
+#define CURL_CHUNK_END_FUNC_OK      0
+#define CURL_CHUNK_END_FUNC_FAIL    1 /* tell the lib to end the task */
+
+/* If splitting of data transfer is enabled this callback is called after
+   download of an individual chunk finished.
+   Note! After this callback was set then it have to be called FOR ALL chunks.
+   Even if downloading of this chunk was skipped in CHUNK_BGN_FUNC.
+   This is the reason why we don't need "transfer_info" parameter in this
+   callback and we are not interested in "remains" parameter too. */
+typedef long (*curl_chunk_end_callback)(void *ptr);
+
+/* return codes for FNMATCHFUNCTION */
+#define CURL_FNMATCHFUNC_MATCH    0 /* string corresponds to the pattern */
+#define CURL_FNMATCHFUNC_NOMATCH  1 /* pattern doesn't match the string */
+#define CURL_FNMATCHFUNC_FAIL     2 /* an error occurred */
+
+/* callback type for wildcard downloading pattern matching. If the
+   string matches the pattern, return CURL_FNMATCHFUNC_MATCH value, etc. */
+typedef int (*curl_fnmatch_callback)(void *ptr,
+                                     const char *pattern,
+                                     const char *string);
+
+/* These are the return codes for the seek callbacks */
+#define CURL_SEEKFUNC_OK       0
+#define CURL_SEEKFUNC_FAIL     1 /* fail the entire transfer */
+#define CURL_SEEKFUNC_CANTSEEK 2 /* tell libcurl seeking can't be done, so
+                                    libcurl might try other means instead */
+typedef int (*curl_seek_callback)(void *instream,
+                                  curl_off_t offset,
+                                  int origin); /* 'whence' */
+
+/* This is a return code for the read callback that, when returned, will
+   signal libcurl to immediately abort the current transfer. */
+#define CURL_READFUNC_ABORT 0x10000000
+/* This is a return code for the read callback that, when returned, will
+   signal libcurl to pause sending data on the current transfer. */
+#define CURL_READFUNC_PAUSE 0x10000001
+
+typedef size_t (*curl_read_callback)(char *buffer,
+                                      size_t size,
+                                      size_t nitems,
+                                      void *instream);
+
+typedef enum  {
+  CURLSOCKTYPE_IPCXN,  /* socket created for a specific IP connection */
+  CURLSOCKTYPE_ACCEPT, /* socket created by accept() call */
+  CURLSOCKTYPE_LAST    /* never use */
+} curlsocktype;
+
+/* The return code from the sockopt_callback can signal information back
+   to libcurl: */
+#define CURL_SOCKOPT_OK 0
+#define CURL_SOCKOPT_ERROR 1 /* causes libcurl to abort and return
+                                CURLE_ABORTED_BY_CALLBACK */
+#define CURL_SOCKOPT_ALREADY_CONNECTED 2
+
+typedef int (*curl_sockopt_callback)(void *clientp,
+                                     curl_socket_t curlfd,
+                                     curlsocktype purpose);
+
+struct curl_sockaddr {
+  int family;
+  int socktype;
+  int protocol;
+  unsigned int addrlen; /* addrlen was a socklen_t type before 7.18.0 but it
+                           turned really ugly and painful on the systems that
+                           lack this type */
+  struct sockaddr addr;
+};
+
+typedef curl_socket_t
+(*curl_opensocket_callback)(void *clientp,
+                            curlsocktype purpose,
+                            struct curl_sockaddr *address);
+
+typedef int
+(*curl_closesocket_callback)(void *clientp, curl_socket_t item);
+
+typedef enum {
+  CURLIOE_OK,            /* I/O operation successful */
+  CURLIOE_UNKNOWNCMD,    /* command was unknown to callback */
+  CURLIOE_FAILRESTART,   /* failed to restart the read */
+  CURLIOE_LAST           /* never use */
+} curlioerr;
+
+typedef enum  {
+  CURLIOCMD_NOP,         /* no operation */
+  CURLIOCMD_RESTARTREAD, /* restart the read stream from start */
+  CURLIOCMD_LAST         /* never use */
+} curliocmd;
+
+typedef curlioerr (*curl_ioctl_callback)(CURL *handle,
+                                         int cmd,
+                                         void *clientp);
+
+#ifndef CURL_DID_MEMORY_FUNC_TYPEDEFS
+/*
+ * The following typedef's are signatures of malloc, free, realloc, strdup and
+ * calloc respectively.  Function pointers of these types can be passed to the
+ * curl_global_init_mem() function to set user defined memory management
+ * callback routines.
+ */
+typedef void *(*curl_malloc_callback)(size_t size);
+typedef void (*curl_free_callback)(void *ptr);
+typedef void *(*curl_realloc_callback)(void *ptr, size_t size);
+typedef char *(*curl_strdup_callback)(const char *str);
+typedef void *(*curl_calloc_callback)(size_t nmemb, size_t size);
+
+#define CURL_DID_MEMORY_FUNC_TYPEDEFS
+#endif
+
+/* the kind of data that is passed to information_callback*/
+typedef enum {
+  CURLINFO_TEXT = 0,
+  CURLINFO_HEADER_IN,    /* 1 */
+  CURLINFO_HEADER_OUT,   /* 2 */
+  CURLINFO_DATA_IN,      /* 3 */
+  CURLINFO_DATA_OUT,     /* 4 */
+  CURLINFO_SSL_DATA_IN,  /* 5 */
+  CURLINFO_SSL_DATA_OUT, /* 6 */
+  CURLINFO_END
+} curl_infotype;
+
+typedef int (*curl_debug_callback)
+       (CURL *handle,      /* the handle/transfer this concerns */
+        curl_infotype type, /* what kind of data */
+        char *data,        /* points to the data */
+        size_t size,       /* size of the data pointed to */
+        void *userptr);    /* whatever the user please */
+
+/* All possible error codes from all sorts of curl functions. Future versions
+   may return other values, stay prepared.
+
+   Always add new return codes last. Never *EVER* remove any. The return
+   codes must remain the same!
+ */
+
+typedef enum {
+  CURLE_OK = 0,
+  CURLE_UNSUPPORTED_PROTOCOL,    /* 1 */
+  CURLE_FAILED_INIT,             /* 2 */
+  CURLE_URL_MALFORMAT,           /* 3 */
+  CURLE_NOT_BUILT_IN,            /* 4 - [was obsoleted in August 2007 for
+                                    7.17.0, reused in April 2011 for 7.21.5] */
+  CURLE_COULDNT_RESOLVE_PROXY,   /* 5 */
+  CURLE_COULDNT_RESOLVE_HOST,    /* 6 */
+  CURLE_COULDNT_CONNECT,         /* 7 */
+  CURLE_WEIRD_SERVER_REPLY,      /* 8 */
+  CURLE_REMOTE_ACCESS_DENIED,    /* 9 a service was denied by the server
+                                    due to lack of access - when login fails
+                                    this is not returned. */
+  CURLE_FTP_ACCEPT_FAILED,       /* 10 - [was obsoleted in April 2006 for
+                                    7.15.4, reused in Dec 2011 for 7.24.0]*/
+  CURLE_FTP_WEIRD_PASS_REPLY,    /* 11 */
+  CURLE_FTP_ACCEPT_TIMEOUT,      /* 12 - timeout occurred accepting server
+                                    [was obsoleted in August 2007 for 7.17.0,
+                                    reused in Dec 2011 for 7.24.0]*/
+  CURLE_FTP_WEIRD_PASV_REPLY,    /* 13 */
+  CURLE_FTP_WEIRD_227_FORMAT,    /* 14 */
+  CURLE_FTP_CANT_GET_HOST,       /* 15 */
+  CURLE_HTTP2,                   /* 16 - A problem in the http2 framing layer.
+                                    [was obsoleted in August 2007 for 7.17.0,
+                                    reused in July 2014 for 7.38.0] */
+  CURLE_FTP_COULDNT_SET_TYPE,    /* 17 */
+  CURLE_PARTIAL_FILE,            /* 18 */
+  CURLE_FTP_COULDNT_RETR_FILE,   /* 19 */
+  CURLE_OBSOLETE20,              /* 20 - NOT USED */
+  CURLE_QUOTE_ERROR,             /* 21 - quote command failure */
+  CURLE_HTTP_RETURNED_ERROR,     /* 22 */
+  CURLE_WRITE_ERROR,             /* 23 */
+  CURLE_OBSOLETE24,              /* 24 - NOT USED */
+  CURLE_UPLOAD_FAILED,           /* 25 - failed upload "command" */
+  CURLE_READ_ERROR,              /* 26 - couldn't open/read from file */
+  CURLE_OUT_OF_MEMORY,           /* 27 */
+  /* Note: CURLE_OUT_OF_MEMORY may sometimes indicate a conversion error
+           instead of a memory allocation error if CURL_DOES_CONVERSIONS
+           is defined
+  */
+  CURLE_OPERATION_TIMEDOUT,      /* 28 - the timeout time was reached */
+  CURLE_OBSOLETE29,              /* 29 - NOT USED */
+  CURLE_FTP_PORT_FAILED,         /* 30 - FTP PORT operation failed */
+  CURLE_FTP_COULDNT_USE_REST,    /* 31 - the REST command failed */
+  CURLE_OBSOLETE32,              /* 32 - NOT USED */
+  CURLE_RANGE_ERROR,             /* 33 - RANGE "command" didn't work */
+  CURLE_HTTP_POST_ERROR,         /* 34 */
+  CURLE_SSL_CONNECT_ERROR,       /* 35 - wrong when connecting with SSL */
+  CURLE_BAD_DOWNLOAD_RESUME,     /* 36 - couldn't resume download */
+  CURLE_FILE_COULDNT_READ_FILE,  /* 37 */
+  CURLE_LDAP_CANNOT_BIND,        /* 38 */
+  CURLE_LDAP_SEARCH_FAILED,      /* 39 */
+  CURLE_OBSOLETE40,              /* 40 - NOT USED */
+  CURLE_FUNCTION_NOT_FOUND,      /* 41 - NOT USED starting with 7.53.0 */
+  CURLE_ABORTED_BY_CALLBACK,     /* 42 */
+  CURLE_BAD_FUNCTION_ARGUMENT,   /* 43 */
+  CURLE_OBSOLETE44,              /* 44 - NOT USED */
+  CURLE_INTERFACE_FAILED,        /* 45 - CURLOPT_INTERFACE failed */
+  CURLE_OBSOLETE46,              /* 46 - NOT USED */
+  CURLE_TOO_MANY_REDIRECTS,      /* 47 - catch endless re-direct loops */
+  CURLE_UNKNOWN_OPTION,          /* 48 - User specified an unknown option */
+  CURLE_TELNET_OPTION_SYNTAX,    /* 49 - Malformed telnet option */
+  CURLE_OBSOLETE50,              /* 50 - NOT USED */
+  CURLE_PEER_FAILED_VERIFICATION, /* 51 - peer's certificate or fingerprint
+                                     wasn't verified fine */
+  CURLE_GOT_NOTHING,             /* 52 - when this is a specific error */
+  CURLE_SSL_ENGINE_NOTFOUND,     /* 53 - SSL crypto engine not found */
+  CURLE_SSL_ENGINE_SETFAILED,    /* 54 - can not set SSL crypto engine as
+                                    default */
+  CURLE_SEND_ERROR,              /* 55 - failed sending network data */
+  CURLE_RECV_ERROR,              /* 56 - failure in receiving network data */
+  CURLE_OBSOLETE57,              /* 57 - NOT IN USE */
+  CURLE_SSL_CERTPROBLEM,         /* 58 - problem with the local certificate */
+  CURLE_SSL_CIPHER,              /* 59 - couldn't use specified cipher */
+  CURLE_SSL_CACERT,              /* 60 - problem with the CA cert (path?) */
+  CURLE_BAD_CONTENT_ENCODING,    /* 61 - Unrecognized/bad encoding */
+  CURLE_LDAP_INVALID_URL,        /* 62 - Invalid LDAP URL */
+  CURLE_FILESIZE_EXCEEDED,       /* 63 - Maximum file size exceeded */
+  CURLE_USE_SSL_FAILED,          /* 64 - Requested FTP SSL level failed */
+  CURLE_SEND_FAIL_REWIND,        /* 65 - Sending the data requires a rewind
+                                    that failed */
+  CURLE_SSL_ENGINE_INITFAILED,   /* 66 - failed to initialise ENGINE */
+  CURLE_LOGIN_DENIED,            /* 67 - user, password or similar was not
+                                    accepted and we failed to login */
+  CURLE_TFTP_NOTFOUND,           /* 68 - file not found on server */
+  CURLE_TFTP_PERM,               /* 69 - permission problem on server */
+  CURLE_REMOTE_DISK_FULL,        /* 70 - out of disk space on server */
+  CURLE_TFTP_ILLEGAL,            /* 71 - Illegal TFTP operation */
+  CURLE_TFTP_UNKNOWNID,          /* 72 - Unknown transfer ID */
+  CURLE_REMOTE_FILE_EXISTS,      /* 73 - File already exists */
+  CURLE_TFTP_NOSUCHUSER,         /* 74 - No such user */
+  CURLE_CONV_FAILED,             /* 75 - conversion failed */
+  CURLE_CONV_REQD,               /* 76 - caller must register conversion
+                                    callbacks using curl_easy_setopt options
+                                    CURLOPT_CONV_FROM_NETWORK_FUNCTION,
+                                    CURLOPT_CONV_TO_NETWORK_FUNCTION, and
+                                    CURLOPT_CONV_FROM_UTF8_FUNCTION */
+  CURLE_SSL_CACERT_BADFILE,      /* 77 - could not load CACERT file, missing
+                                    or wrong format */
+  CURLE_REMOTE_FILE_NOT_FOUND,   /* 78 - remote file not found */
+  CURLE_SSH,                     /* 79 - error from the SSH layer, somewhat
+                                    generic so the error message will be of
+                                    interest when this has happened */
+
+  CURLE_SSL_SHUTDOWN_FAILED,     /* 80 - Failed to shut down the SSL
+                                    connection */
+  CURLE_AGAIN,                   /* 81 - socket is not ready for send/recv,
+                                    wait till it's ready and try again (Added
+                                    in 7.18.2) */
+  CURLE_SSL_CRL_BADFILE,         /* 82 - could not load CRL file, missing or
+                                    wrong format (Added in 7.19.0) */
+  CURLE_SSL_ISSUER_ERROR,        /* 83 - Issuer check failed.  (Added in
+                                    7.19.0) */
+  CURLE_FTP_PRET_FAILED,         /* 84 - a PRET command failed */
+  CURLE_RTSP_CSEQ_ERROR,         /* 85 - mismatch of RTSP CSeq numbers */
+  CURLE_RTSP_SESSION_ERROR,      /* 86 - mismatch of RTSP Session Ids */
+  CURLE_FTP_BAD_FILE_LIST,       /* 87 - unable to parse FTP file list */
+  CURLE_CHUNK_FAILED,            /* 88 - chunk callback reported error */
+  CURLE_NO_CONNECTION_AVAILABLE, /* 89 - No connection available, the
+                                    session will be queued */
+  CURLE_SSL_PINNEDPUBKEYNOTMATCH, /* 90 - specified pinned public key did not
+                                     match */
+  CURLE_SSL_INVALIDCERTSTATUS,   /* 91 - invalid certificate status */
+  CURLE_HTTP2_STREAM,            /* 92 - stream error in HTTP/2 framing layer
+                                    */
+  CURL_LAST /* never use! */
+} CURLcode;
+
+#ifndef CURL_NO_OLDIES /* define this to test if your app builds with all
+                          the obsolete stuff removed! */
+
+/* Previously obsolete error code re-used in 7.38.0 */
+#define CURLE_OBSOLETE16 CURLE_HTTP2
+
+/* Previously obsolete error codes re-used in 7.24.0 */
+#define CURLE_OBSOLETE10 CURLE_FTP_ACCEPT_FAILED
+#define CURLE_OBSOLETE12 CURLE_FTP_ACCEPT_TIMEOUT
+
+/*  compatibility with older names */
+#define CURLOPT_ENCODING CURLOPT_ACCEPT_ENCODING
+#define CURLE_FTP_WEIRD_SERVER_REPLY CURLE_WEIRD_SERVER_REPLY
+
+/* The following were added in 7.21.5, April 2011 */
+#define CURLE_UNKNOWN_TELNET_OPTION CURLE_UNKNOWN_OPTION
+
+/* The following were added in 7.17.1 */
+/* These are scheduled to disappear by 2009 */
+#define CURLE_SSL_PEER_CERTIFICATE CURLE_PEER_FAILED_VERIFICATION
+
+/* The following were added in 7.17.0 */
+/* These are scheduled to disappear by 2009 */
+#define CURLE_OBSOLETE CURLE_OBSOLETE50 /* no one should be using this! */
+#define CURLE_BAD_PASSWORD_ENTERED CURLE_OBSOLETE46
+#define CURLE_BAD_CALLING_ORDER CURLE_OBSOLETE44
+#define CURLE_FTP_USER_PASSWORD_INCORRECT CURLE_OBSOLETE10
+#define CURLE_FTP_CANT_RECONNECT CURLE_OBSOLETE16
+#define CURLE_FTP_COULDNT_GET_SIZE CURLE_OBSOLETE32
+#define CURLE_FTP_COULDNT_SET_ASCII CURLE_OBSOLETE29
+#define CURLE_FTP_WEIRD_USER_REPLY CURLE_OBSOLETE12
+#define CURLE_FTP_WRITE_ERROR CURLE_OBSOLETE20
+#define CURLE_LIBRARY_NOT_FOUND CURLE_OBSOLETE40
+#define CURLE_MALFORMAT_USER CURLE_OBSOLETE24
+#define CURLE_SHARE_IN_USE CURLE_OBSOLETE57
+#define CURLE_URL_MALFORMAT_USER CURLE_NOT_BUILT_IN
+
+#define CURLE_FTP_ACCESS_DENIED CURLE_REMOTE_ACCESS_DENIED
+#define CURLE_FTP_COULDNT_SET_BINARY CURLE_FTP_COULDNT_SET_TYPE
+#define CURLE_FTP_QUOTE_ERROR CURLE_QUOTE_ERROR
+#define CURLE_TFTP_DISKFULL CURLE_REMOTE_DISK_FULL
+#define CURLE_TFTP_EXISTS CURLE_REMOTE_FILE_EXISTS
+#define CURLE_HTTP_RANGE_ERROR CURLE_RANGE_ERROR
+#define CURLE_FTP_SSL_FAILED CURLE_USE_SSL_FAILED
+
+/* The following were added earlier */
+
+#define CURLE_OPERATION_TIMEOUTED CURLE_OPERATION_TIMEDOUT
+
+#define CURLE_HTTP_NOT_FOUND CURLE_HTTP_RETURNED_ERROR
+#define CURLE_HTTP_PORT_FAILED CURLE_INTERFACE_FAILED
+#define CURLE_FTP_COULDNT_STOR_FILE CURLE_UPLOAD_FAILED
+
+#define CURLE_FTP_PARTIAL_FILE CURLE_PARTIAL_FILE
+#define CURLE_FTP_BAD_DOWNLOAD_RESUME CURLE_BAD_DOWNLOAD_RESUME
+
+/* This was the error code 50 in 7.7.3 and a few earlier versions, this
+   is no longer used by libcurl but is instead #defined here only to not
+   make programs break */
+#define CURLE_ALREADY_COMPLETE 99999
+
+/* Provide defines for really old option names */
+#define CURLOPT_FILE CURLOPT_WRITEDATA /* name changed in 7.9.7 */
+#define CURLOPT_INFILE CURLOPT_READDATA /* name changed in 7.9.7 */
+#define CURLOPT_WRITEHEADER CURLOPT_HEADERDATA
+
+/* Since long deprecated options with no code in the lib that does anything
+   with them. */
+#define CURLOPT_WRITEINFO CURLOPT_OBSOLETE40
+#define CURLOPT_CLOSEPOLICY CURLOPT_OBSOLETE72
+
+#endif /*!CURL_NO_OLDIES*/
+
+/* This prototype applies to all conversion callbacks */
+typedef CURLcode (*curl_conv_callback)(char *buffer, size_t length);
+
+typedef CURLcode (*curl_ssl_ctx_callback)(CURL *curl,    /* easy handle */
+                                          void *ssl_ctx, /* actually an
+                                                            OpenSSL SSL_CTX */
+                                          void *userptr);
+
+typedef enum {
+  CURLPROXY_HTTP = 0,   /* added in 7.10, new in 7.19.4 default is to use
+                           CONNECT HTTP/1.1 */
+  CURLPROXY_HTTP_1_0 = 1,   /* added in 7.19.4, force to use CONNECT
+                               HTTP/1.0  */
+  CURLPROXY_HTTPS = 2, /* added in 7.52.0 */
+  CURLPROXY_SOCKS4 = 4, /* support added in 7.15.2, enum existed already
+                           in 7.10 */
+  CURLPROXY_SOCKS5 = 5, /* added in 7.10 */
+  CURLPROXY_SOCKS4A = 6, /* added in 7.18.0 */
+  CURLPROXY_SOCKS5_HOSTNAME = 7 /* Use the SOCKS5 protocol but pass along the
+                                   host name rather than the IP address. added
+                                   in 7.18.0 */
+} curl_proxytype;  /* this enum was added in 7.10 */
+
+/*
+ * Bitmasks for CURLOPT_HTTPAUTH and CURLOPT_PROXYAUTH options:
+ *
+ * CURLAUTH_NONE         - No HTTP authentication
+ * CURLAUTH_BASIC        - HTTP Basic authentication (default)
+ * CURLAUTH_DIGEST       - HTTP Digest authentication
+ * CURLAUTH_NEGOTIATE    - HTTP Negotiate (SPNEGO) authentication
+ * CURLAUTH_GSSNEGOTIATE - Alias for CURLAUTH_NEGOTIATE (deprecated)
+ * CURLAUTH_NTLM         - HTTP NTLM authentication
+ * CURLAUTH_DIGEST_IE    - HTTP Digest authentication with IE flavour
+ * CURLAUTH_NTLM_WB      - HTTP NTLM authentication delegated to winbind helper
+ * CURLAUTH_ONLY         - Use together with a single other type to force no
+ *                         authentication or just that single type
+ * CURLAUTH_ANY          - All fine types set
+ * CURLAUTH_ANYSAFE      - All fine types except Basic
+ */
+
+#define CURLAUTH_NONE         ((unsigned long)0)
+#define CURLAUTH_BASIC        (((unsigned long)1)<<0)
+#define CURLAUTH_DIGEST       (((unsigned long)1)<<1)
+#define CURLAUTH_NEGOTIATE    (((unsigned long)1)<<2)
+/* Deprecated since the advent of CURLAUTH_NEGOTIATE */
+#define CURLAUTH_GSSNEGOTIATE CURLAUTH_NEGOTIATE
+#define CURLAUTH_NTLM         (((unsigned long)1)<<3)
+#define CURLAUTH_DIGEST_IE    (((unsigned long)1)<<4)
+#define CURLAUTH_NTLM_WB      (((unsigned long)1)<<5)
+#define CURLAUTH_ONLY         (((unsigned long)1)<<31)
+#define CURLAUTH_ANY          (~CURLAUTH_DIGEST_IE)
+#define CURLAUTH_ANYSAFE      (~(CURLAUTH_BASIC|CURLAUTH_DIGEST_IE))
+
+#define CURLSSH_AUTH_ANY       ~0     /* all types supported by the server */
+#define CURLSSH_AUTH_NONE      0      /* none allowed, silly but complete */
+#define CURLSSH_AUTH_PUBLICKEY (1<<0) /* public/private key files */
+#define CURLSSH_AUTH_PASSWORD  (1<<1) /* password */
+#define CURLSSH_AUTH_HOST      (1<<2) /* host key files */
+#define CURLSSH_AUTH_KEYBOARD  (1<<3) /* keyboard interactive */
+#define CURLSSH_AUTH_AGENT     (1<<4) /* agent (ssh-agent, pageant...) */
+#define CURLSSH_AUTH_DEFAULT CURLSSH_AUTH_ANY
+
+#define CURLGSSAPI_DELEGATION_NONE        0      /* no delegation (default) */
+#define CURLGSSAPI_DELEGATION_POLICY_FLAG (1<<0) /* if permitted by policy */
+#define CURLGSSAPI_DELEGATION_FLAG        (1<<1) /* delegate always */
+
+#define CURL_ERROR_SIZE 256
+
+enum curl_khtype {
+  CURLKHTYPE_UNKNOWN,
+  CURLKHTYPE_RSA1,
+  CURLKHTYPE_RSA,
+  CURLKHTYPE_DSS
+};
+
+struct curl_khkey {
+  const char *key; /* points to a zero-terminated string encoded with base64
+                      if len is zero, otherwise to the "raw" data */
+  size_t len;
+  enum curl_khtype keytype;
+};
+
+/* this is the set of return values expected from the curl_sshkeycallback
+   callback */
+enum curl_khstat {
+  CURLKHSTAT_FINE_ADD_TO_FILE,
+  CURLKHSTAT_FINE,
+  CURLKHSTAT_REJECT, /* reject the connection, return an error */
+  CURLKHSTAT_DEFER,  /* do not accept it, but we can't answer right now so
+                        this causes a CURLE_DEFER error but otherwise the
+                        connection will be left intact etc */
+  CURLKHSTAT_LAST    /* not for use, only a marker for last-in-list */
+};
+
+/* this is the set of status codes pass in to the callback */
+enum curl_khmatch {
+  CURLKHMATCH_OK,       /* match */
+  CURLKHMATCH_MISMATCH, /* host found, key mismatch! */
+  CURLKHMATCH_MISSING,  /* no matching host/key found */
+  CURLKHMATCH_LAST      /* not for use, only a marker for last-in-list */
+};
+
+typedef int
+  (*curl_sshkeycallback) (CURL *easy,     /* easy handle */
+                          const struct curl_khkey *knownkey, /* known */
+                          const struct curl_khkey *foundkey, /* found */
+                          enum curl_khmatch, /* libcurl's view on the keys */
+                          void *clientp); /* custom pointer passed from app */
+
+/* parameter for the CURLOPT_USE_SSL option */
+typedef enum {
+  CURLUSESSL_NONE,    /* do not attempt to use SSL */
+  CURLUSESSL_TRY,     /* try using SSL, proceed anyway otherwise */
+  CURLUSESSL_CONTROL, /* SSL for the control connection or fail */
+  CURLUSESSL_ALL,     /* SSL for all communication or fail */
+  CURLUSESSL_LAST     /* not an option, never use */
+} curl_usessl;
+
+/* Definition of bits for the CURLOPT_SSL_OPTIONS argument: */
+
+/* - ALLOW_BEAST tells libcurl to allow the BEAST SSL vulnerability in the
+   name of improving interoperability with older servers. Some SSL libraries
+   have introduced work-arounds for this flaw but those work-arounds sometimes
+   make the SSL communication fail. To regain functionality with those broken
+   servers, a user can this way allow the vulnerability back. */
+#define CURLSSLOPT_ALLOW_BEAST (1<<0)
+
+/* - NO_REVOKE tells libcurl to disable certificate revocation checks for those
+   SSL backends where such behavior is present. */
+#define CURLSSLOPT_NO_REVOKE (1<<1)
+
+#ifndef CURL_NO_OLDIES /* define this to test if your app builds with all
+                          the obsolete stuff removed! */
+
+/* Backwards compatibility with older names */
+/* These are scheduled to disappear by 2009 */
+
+#define CURLFTPSSL_NONE CURLUSESSL_NONE
+#define CURLFTPSSL_TRY CURLUSESSL_TRY
+#define CURLFTPSSL_CONTROL CURLUSESSL_CONTROL
+#define CURLFTPSSL_ALL CURLUSESSL_ALL
+#define CURLFTPSSL_LAST CURLUSESSL_LAST
+#define curl_ftpssl curl_usessl
+#endif /*!CURL_NO_OLDIES*/
+
+/* parameter for the CURLOPT_FTP_SSL_CCC option */
+typedef enum {
+  CURLFTPSSL_CCC_NONE,    /* do not send CCC */
+  CURLFTPSSL_CCC_PASSIVE, /* Let the server initiate the shutdown */
+  CURLFTPSSL_CCC_ACTIVE,  /* Initiate the shutdown */
+  CURLFTPSSL_CCC_LAST     /* not an option, never use */
+} curl_ftpccc;
+
+/* parameter for the CURLOPT_FTPSSLAUTH option */
+typedef enum {
+  CURLFTPAUTH_DEFAULT, /* let libcurl decide */
+  CURLFTPAUTH_SSL,     /* use "AUTH SSL" */
+  CURLFTPAUTH_TLS,     /* use "AUTH TLS" */
+  CURLFTPAUTH_LAST /* not an option, never use */
+} curl_ftpauth;
+
+/* parameter for the CURLOPT_FTP_CREATE_MISSING_DIRS option */
+typedef enum {
+  CURLFTP_CREATE_DIR_NONE,  /* do NOT create missing dirs! */
+  CURLFTP_CREATE_DIR,       /* (FTP/SFTP) if CWD fails, try MKD and then CWD
+                               again if MKD succeeded, for SFTP this does
+                               similar magic */
+  CURLFTP_CREATE_DIR_RETRY, /* (FTP only) if CWD fails, try MKD and then CWD
+                               again even if MKD failed! */
+  CURLFTP_CREATE_DIR_LAST   /* not an option, never use */
+} curl_ftpcreatedir;
+
+/* parameter for the CURLOPT_FTP_FILEMETHOD option */
+typedef enum {
+  CURLFTPMETHOD_DEFAULT,   /* let libcurl pick */
+  CURLFTPMETHOD_MULTICWD,  /* single CWD operation for each path part */
+  CURLFTPMETHOD_NOCWD,     /* no CWD at all */
+  CURLFTPMETHOD_SINGLECWD, /* one CWD to full dir, then work on file */
+  CURLFTPMETHOD_LAST       /* not an option, never use */
+} curl_ftpmethod;
+
+/* bitmask defines for CURLOPT_HEADEROPT */
+#define CURLHEADER_UNIFIED  0
+#define CURLHEADER_SEPARATE (1<<0)
+
+/* CURLPROTO_ defines are for the CURLOPT_*PROTOCOLS options */
+#define CURLPROTO_HTTP   (1<<0)
+#define CURLPROTO_HTTPS  (1<<1)
+#define CURLPROTO_FTP    (1<<2)
+#define CURLPROTO_FTPS   (1<<3)
+#define CURLPROTO_SCP    (1<<4)
+#define CURLPROTO_SFTP   (1<<5)
+#define CURLPROTO_TELNET (1<<6)
+#define CURLPROTO_LDAP   (1<<7)
+#define CURLPROTO_LDAPS  (1<<8)
+#define CURLPROTO_DICT   (1<<9)
+#define CURLPROTO_FILE   (1<<10)
+#define CURLPROTO_TFTP   (1<<11)
+#define CURLPROTO_IMAP   (1<<12)
+#define CURLPROTO_IMAPS  (1<<13)
+#define CURLPROTO_POP3   (1<<14)
+#define CURLPROTO_POP3S  (1<<15)
+#define CURLPROTO_SMTP   (1<<16)
+#define CURLPROTO_SMTPS  (1<<17)
+#define CURLPROTO_RTSP   (1<<18)
+#define CURLPROTO_RTMP   (1<<19)
+#define CURLPROTO_RTMPT  (1<<20)
+#define CURLPROTO_RTMPE  (1<<21)
+#define CURLPROTO_RTMPTE (1<<22)
+#define CURLPROTO_RTMPS  (1<<23)
+#define CURLPROTO_RTMPTS (1<<24)
+#define CURLPROTO_GOPHER (1<<25)
+#define CURLPROTO_SMB    (1<<26)
+#define CURLPROTO_SMBS   (1<<27)
+#define CURLPROTO_ALL    (~0) /* enable everything */
+
+/* long may be 32 or 64 bits, but we should never depend on anything else
+   but 32 */
+#define CURLOPTTYPE_LONG          0
+#define CURLOPTTYPE_OBJECTPOINT   10000
+#define CURLOPTTYPE_STRINGPOINT   10000
+#define CURLOPTTYPE_FUNCTIONPOINT 20000
+#define CURLOPTTYPE_OFF_T         30000
+
+/* *STRINGPOINT is an alias for OBJECTPOINT to allow tools to extract the
+   string options from the header file */
+
+/* name is uppercase CURLOPT_<name>,
+   type is one of the defined CURLOPTTYPE_<type>
+   number is unique identifier */
+#ifdef CINIT
+#undef CINIT
+#endif
+
+#ifdef CURL_ISOCPP
+#define CINIT(na,t,nu) CURLOPT_ ## na = CURLOPTTYPE_ ## t + nu
+#else
+/* The macro "##" is ISO C, we assume pre-ISO C doesn't support it. */
+#define LONG          CURLOPTTYPE_LONG
+#define OBJECTPOINT   CURLOPTTYPE_OBJECTPOINT
+#define STRINGPOINT   CURLOPTTYPE_OBJECTPOINT
+#define FUNCTIONPOINT CURLOPTTYPE_FUNCTIONPOINT
+#define OFF_T         CURLOPTTYPE_OFF_T
+#define CINIT(name,type,number) CURLOPT_/**/name = type + number
+#endif
+
+/*
+ * This macro-mania below setups the CURLOPT_[what] enum, to be used with
+ * curl_easy_setopt(). The first argument in the CINIT() macro is the [what]
+ * word.
+ */
+
+typedef enum {
+  /* This is the FILE * or void * the regular output should be written to. */
+  CINIT(WRITEDATA, OBJECTPOINT, 1),
+
+  /* The full URL to get/put */
+  CINIT(URL, STRINGPOINT, 2),
+
+  /* Port number to connect to, if other than default. */
+  CINIT(PORT, LONG, 3),
+
+  /* Name of proxy to use. */
+  CINIT(PROXY, STRINGPOINT, 4),
+
+  /* "user:password;options" to use when fetching. */
+  CINIT(USERPWD, STRINGPOINT, 5),
+
+  /* "user:password" to use with proxy. */
+  CINIT(PROXYUSERPWD, STRINGPOINT, 6),
+
+  /* Range to get, specified as an ASCII string. */
+  CINIT(RANGE, STRINGPOINT, 7),
+
+  /* not used */
+
+  /* Specified file stream to upload from (use as input): */
+  CINIT(READDATA, OBJECTPOINT, 9),
+
+  /* Buffer to receive error messages in, must be at least CURL_ERROR_SIZE
+   * bytes big. If this is not used, error messages go to stderr instead: */
+  CINIT(ERRORBUFFER, OBJECTPOINT, 10),
+
+  /* Function that will be called to store the output (instead of fwrite). The
+   * parameters will use fwrite() syntax, make sure to follow them. */
+  CINIT(WRITEFUNCTION, FUNCTIONPOINT, 11),
+
+  /* Function that will be called to read the input (instead of fread). The
+   * parameters will use fread() syntax, make sure to follow them. */
+  CINIT(READFUNCTION, FUNCTIONPOINT, 12),
+
+  /* Time-out the read operation after this amount of seconds */
+  CINIT(TIMEOUT, LONG, 13),
+
+  /* If the CURLOPT_INFILE is used, this can be used to inform libcurl about
+   * how large the file being sent really is. That allows better error
+   * checking and better verifies that the upload was successful. -1 means
+   * unknown size.
+   *
+   * For large file support, there is also a _LARGE version of the key
+   * which takes an off_t type, allowing platforms with larger off_t
+   * sizes to handle larger files.  See below for INFILESIZE_LARGE.
+   */
+  CINIT(INFILESIZE, LONG, 14),
+
+  /* POST static input fields. */
+  CINIT(POSTFIELDS, OBJECTPOINT, 15),
+
+  /* Set the referrer page (needed by some CGIs) */
+  CINIT(REFERER, STRINGPOINT, 16),
+
+  /* Set the FTP PORT string (interface name, named or numerical IP address)
+     Use i.e '-' to use default address. */
+  CINIT(FTPPORT, STRINGPOINT, 17),
+
+  /* Set the User-Agent string (examined by some CGIs) */
+  CINIT(USERAGENT, STRINGPOINT, 18),
+
+  /* If the download receives less than "low speed limit" bytes/second
+   * during "low speed time" seconds, the operations is aborted.
+   * You could i.e if you have a pretty high speed connection, abort if
+   * it is less than 2000 bytes/sec during 20 seconds.
+   */
+
+  /* Set the "low speed limit" */
+  CINIT(LOW_SPEED_LIMIT, LONG, 19),
+
+  /* Set the "low speed time" */
+  CINIT(LOW_SPEED_TIME, LONG, 20),
+
+  /* Set the continuation offset.
+   *
+   * Note there is also a _LARGE version of this key which uses
+   * off_t types, allowing for large file offsets on platforms which
+   * use larger-than-32-bit off_t's.  Look below for RESUME_FROM_LARGE.
+   */
+  CINIT(RESUME_FROM, LONG, 21),
+
+  /* Set cookie in request: */
+  CINIT(COOKIE, STRINGPOINT, 22),
+
+  /* This points to a linked list of headers, struct curl_slist kind. This
+     list is also used for RTSP (in spite of its name) */
+  CINIT(HTTPHEADER, OBJECTPOINT, 23),
+
+  /* This points to a linked list of post entries, struct curl_httppost */
+  CINIT(HTTPPOST, OBJECTPOINT, 24),
+
+  /* name of the file keeping your private SSL-certificate */
+  CINIT(SSLCERT, STRINGPOINT, 25),
+
+  /* password for the SSL or SSH private key */
+  CINIT(KEYPASSWD, STRINGPOINT, 26),
+
+  /* send TYPE parameter? */
+  CINIT(CRLF, LONG, 27),
+
+  /* send linked-list of QUOTE commands */
+  CINIT(QUOTE, OBJECTPOINT, 28),
+
+  /* send FILE * or void * to store headers to, if you use a callback it
+     is simply passed to the callback unmodified */
+  CINIT(HEADERDATA, OBJECTPOINT, 29),
+
+  /* point to a file to read the initial cookies from, also enables
+     "cookie awareness" */
+  CINIT(COOKIEFILE, STRINGPOINT, 31),
+
+  /* What version to specifically try to use.
+     See CURL_SSLVERSION defines below. */
+  CINIT(SSLVERSION, LONG, 32),
+
+  /* What kind of HTTP time condition to use, see defines */
+  CINIT(TIMECONDITION, LONG, 33),
+
+  /* Time to use with the above condition. Specified in number of seconds
+     since 1 Jan 1970 */
+  CINIT(TIMEVALUE, LONG, 34),
+
+  /* 35 = OBSOLETE */
+
+  /* Custom request, for customizing the get command like
+     HTTP: DELETE, TRACE and others
+     FTP: to use a different list command
+     */
+  CINIT(CUSTOMREQUEST, STRINGPOINT, 36),
+
+  /* FILE handle to use instead of stderr */
+  CINIT(STDERR, OBJECTPOINT, 37),
+
+  /* 38 is not used */
+
+  /* send linked-list of post-transfer QUOTE commands */
+  CINIT(POSTQUOTE, OBJECTPOINT, 39),
+
+  CINIT(OBSOLETE40, OBJECTPOINT, 40), /* OBSOLETE, do not use! */
+
+  CINIT(VERBOSE, LONG, 41),      /* talk a lot */
+  CINIT(HEADER, LONG, 42),       /* throw the header out too */
+  CINIT(NOPROGRESS, LONG, 43),   /* shut off the progress meter */
+  CINIT(NOBODY, LONG, 44),       /* use HEAD to get http document */
+  CINIT(FAILONERROR, LONG, 45),  /* no output on http error codes >= 400 */
+  CINIT(UPLOAD, LONG, 46),       /* this is an upload */
+  CINIT(POST, LONG, 47),         /* HTTP POST method */
+  CINIT(DIRLISTONLY, LONG, 48),  /* bare names when listing directories */
+
+  CINIT(APPEND, LONG, 50),       /* Append instead of overwrite on upload! */
+
+  /* Specify whether to read the user+password from the .netrc or the URL.
+   * This must be one of the CURL_NETRC_* enums below. */
+  CINIT(NETRC, LONG, 51),
+
+  CINIT(FOLLOWLOCATION, LONG, 52),  /* use Location: Luke! */
+
+  CINIT(TRANSFERTEXT, LONG, 53), /* transfer data in text/ASCII format */
+  CINIT(PUT, LONG, 54),          /* HTTP PUT */
+
+  /* 55 = OBSOLETE */
+
+  /* DEPRECATED
+   * Function that will be called instead of the internal progress display
+   * function. This function should be defined as the curl_progress_callback
+   * prototype defines. */
+  CINIT(PROGRESSFUNCTION, FUNCTIONPOINT, 56),
+
+  /* Data passed to the CURLOPT_PROGRESSFUNCTION and CURLOPT_XFERINFOFUNCTION
+     callbacks */
+  CINIT(PROGRESSDATA, OBJECTPOINT, 57),
+#define CURLOPT_XFERINFODATA CURLOPT_PROGRESSDATA
+
+  /* We want the referrer field set automatically when following locations */
+  CINIT(AUTOREFERER, LONG, 58),
+
+  /* Port of the proxy, can be set in the proxy string as well with:
+     "[host]:[port]" */
+  CINIT(PROXYPORT, LONG, 59),
+
+  /* size of the POST input data, if strlen() is not good to use */
+  CINIT(POSTFIELDSIZE, LONG, 60),
+
+  /* tunnel non-http operations through a HTTP proxy */
+  CINIT(HTTPPROXYTUNNEL, LONG, 61),
+
+  /* Set the interface string to use as outgoing network interface */
+  CINIT(INTERFACE, STRINGPOINT, 62),
+
+  /* Set the krb4/5 security level, this also enables krb4/5 awareness.  This
+   * is a string, 'clear', 'safe', 'confidential' or 'private'.  If the string
+   * is set but doesn't match one of these, 'private' will be used.  */
+  CINIT(KRBLEVEL, STRINGPOINT, 63),
+
+  /* Set if we should verify the peer in ssl handshake, set 1 to verify. */
+  CINIT(SSL_VERIFYPEER, LONG, 64),
+
+  /* The CApath or CAfile used to validate the peer certificate
+     this option is used only if SSL_VERIFYPEER is true */
+  CINIT(CAINFO, STRINGPOINT, 65),
+
+  /* 66 = OBSOLETE */
+  /* 67 = OBSOLETE */
+
+  /* Maximum number of http redirects to follow */
+  CINIT(MAXREDIRS, LONG, 68),
+
+  /* Pass a long set to 1 to get the date of the requested document (if
+     possible)! Pass a zero to shut it off. */
+  CINIT(FILETIME, LONG, 69),
+
+  /* This points to a linked list of telnet options */
+  CINIT(TELNETOPTIONS, OBJECTPOINT, 70),
+
+  /* Max amount of cached alive connections */
+  CINIT(MAXCONNECTS, LONG, 71),
+
+  CINIT(OBSOLETE72, LONG, 72), /* OBSOLETE, do not use! */
+
+  /* 73 = OBSOLETE */
+
+  /* Set to explicitly use a new connection for the upcoming transfer.
+     Do not use this unless you're absolutely sure of this, as it makes the
+     operation slower and is less friendly for the network. */
+  CINIT(FRESH_CONNECT, LONG, 74),
+
+  /* Set to explicitly forbid the upcoming transfer's connection to be re-used
+     when done. Do not use this unless you're absolutely sure of this, as it
+     makes the operation slower and is less friendly for the network. */
+  CINIT(FORBID_REUSE, LONG, 75),
+
+  /* Set to a file name that contains random data for libcurl to use to
+     seed the random engine when doing SSL connects. */
+  CINIT(RANDOM_FILE, STRINGPOINT, 76),
+
+  /* Set to the Entropy Gathering Daemon socket pathname */
+  CINIT(EGDSOCKET, STRINGPOINT, 77),
+
+  /* Time-out connect operations after this amount of seconds, if connects are
+     OK within this time, then fine... This only aborts the connect phase. */
+  CINIT(CONNECTTIMEOUT, LONG, 78),
+
+  /* Function that will be called to store headers (instead of fwrite). The
+   * parameters will use fwrite() syntax, make sure to follow them. */
+  CINIT(HEADERFUNCTION, FUNCTIONPOINT, 79),
+
+  /* Set this to force the HTTP request to get back to GET. Only really usable
+     if POST, PUT or a custom request have been used first.
+   */
+  CINIT(HTTPGET, LONG, 80),
+
+  /* Set if we should verify the Common name from the peer certificate in ssl
+   * handshake, set 1 to check existence, 2 to ensure that it matches the
+   * provided hostname. */
+  CINIT(SSL_VERIFYHOST, LONG, 81),
+
+  /* Specify which file name to write all known cookies in after completed
+     operation. Set file name to "-" (dash) to make it go to stdout. */
+  CINIT(COOKIEJAR, STRINGPOINT, 82),
+
+  /* Specify which SSL ciphers to use */
+  CINIT(SSL_CIPHER_LIST, STRINGPOINT, 83),
+
+  /* Specify which HTTP version to use! This must be set to one of the
+     CURL_HTTP_VERSION* enums set below. */
+  CINIT(HTTP_VERSION, LONG, 84),
+
+  /* Specifically switch on or off the FTP engine's use of the EPSV command. By
+     default, that one will always be attempted before the more traditional
+     PASV command. */
+  CINIT(FTP_USE_EPSV, LONG, 85),
+
+  /* type of the file keeping your SSL-certificate ("DER", "PEM", "ENG") */
+  CINIT(SSLCERTTYPE, STRINGPOINT, 86),
+
+  /* name of the file keeping your private SSL-key */
+  CINIT(SSLKEY, STRINGPOINT, 87),
+
+  /* type of the file keeping your private SSL-key ("DER", "PEM", "ENG") */
+  CINIT(SSLKEYTYPE, STRINGPOINT, 88),
+
+  /* crypto engine for the SSL-sub system */
+  CINIT(SSLENGINE, STRINGPOINT, 89),
+
+  /* set the crypto engine for the SSL-sub system as default
+     the param has no meaning...
+   */
+  CINIT(SSLENGINE_DEFAULT, LONG, 90),
+
+  /* Non-zero value means to use the global dns cache */
+  CINIT(DNS_USE_GLOBAL_CACHE, LONG, 91), /* DEPRECATED, do not use! */
+
+  /* DNS cache timeout */
+  CINIT(DNS_CACHE_TIMEOUT, LONG, 92),
+
+  /* send linked-list of pre-transfer QUOTE commands */
+  CINIT(PREQUOTE, OBJECTPOINT, 93),
+
+  /* set the debug function */
+  CINIT(DEBUGFUNCTION, FUNCTIONPOINT, 94),
+
+  /* set the data for the debug function */
+  CINIT(DEBUGDATA, OBJECTPOINT, 95),
+
+  /* mark this as start of a cookie session */
+  CINIT(COOKIESESSION, LONG, 96),
+
+  /* The CApath directory used to validate the peer certificate
+     this option is used only if SSL_VERIFYPEER is true */
+  CINIT(CAPATH, STRINGPOINT, 97),
+
+  /* Instruct libcurl to use a smaller receive buffer */
+  CINIT(BUFFERSIZE, LONG, 98),
+
+  /* Instruct libcurl to not use any signal/alarm handlers, even when using
+     timeouts. This option is useful for multi-threaded applications.
+     See libcurl-the-guide for more background information. */
+  CINIT(NOSIGNAL, LONG, 99),
+
+  /* Provide a CURLShare for mutexing non-ts data */
+  CINIT(SHARE, OBJECTPOINT, 100),
+
+  /* indicates type of proxy. accepted values are CURLPROXY_HTTP (default),
+     CURLPROXY_HTTPS, CURLPROXY_SOCKS4, CURLPROXY_SOCKS4A and
+     CURLPROXY_SOCKS5. */
+  CINIT(PROXYTYPE, LONG, 101),
+
+  /* Set the Accept-Encoding string. Use this to tell a server you would like
+     the response to be compressed. Before 7.21.6, this was known as
+     CURLOPT_ENCODING */
+  CINIT(ACCEPT_ENCODING, STRINGPOINT, 102),
+
+  /* Set pointer to private data */
+  CINIT(PRIVATE, OBJECTPOINT, 103),
+
+  /* Set aliases for HTTP 200 in the HTTP Response header */
+  CINIT(HTTP200ALIASES, OBJECTPOINT, 104),
+
+  /* Continue to send authentication (user+password) when following locations,
+     even when hostname changed. This can potentially send off the name
+     and password to whatever host the server decides. */
+  CINIT(UNRESTRICTED_AUTH, LONG, 105),
+
+  /* Specifically switch on or off the FTP engine's use of the EPRT command (
+     it also disables the LPRT attempt). By default, those ones will always be
+     attempted before the good old traditional PORT command. */
+  CINIT(FTP_USE_EPRT, LONG, 106),
+
+  /* Set this to a bitmask value to enable the particular authentications
+     methods you like. Use this in combination with CURLOPT_USERPWD.
+     Note that setting multiple bits may cause extra network round-trips. */
+  CINIT(HTTPAUTH, LONG, 107),
+
+  /* Set the ssl context callback function, currently only for OpenSSL ssl_ctx
+     in second argument. The function must be matching the
+     curl_ssl_ctx_callback proto. */
+  CINIT(SSL_CTX_FUNCTION, FUNCTIONPOINT, 108),
+
+  /* Set the userdata for the ssl context callback function's third
+     argument */
+  CINIT(SSL_CTX_DATA, OBJECTPOINT, 109),
+
+  /* FTP Option that causes missing dirs to be created on the remote server.
+     In 7.19.4 we introduced the convenience enums for this option using the
+     CURLFTP_CREATE_DIR prefix.
+  */
+  CINIT(FTP_CREATE_MISSING_DIRS, LONG, 110),
+
+  /* Set this to a bitmask value to enable the particular authentications
+     methods you like. Use this in combination with CURLOPT_PROXYUSERPWD.
+     Note that setting multiple bits may cause extra network round-trips. */
+  CINIT(PROXYAUTH, LONG, 111),
+
+  /* FTP option that changes the timeout, in seconds, associated with
+     getting a response.  This is different from transfer timeout time and
+     essentially places a demand on the FTP server to acknowledge commands
+     in a timely manner. */
+  CINIT(FTP_RESPONSE_TIMEOUT, LONG, 112),
+#define CURLOPT_SERVER_RESPONSE_TIMEOUT CURLOPT_FTP_RESPONSE_TIMEOUT
+
+  /* Set this option to one of the CURL_IPRESOLVE_* defines (see below) to
+     tell libcurl to resolve names to those IP versions only. This only has
+     affect on systems with support for more than one, i.e IPv4 _and_ IPv6. */
+  CINIT(IPRESOLVE, LONG, 113),
+
+  /* Set this option to limit the size of a file that will be downloaded from
+     an HTTP or FTP server.
+
+     Note there is also _LARGE version which adds large file support for
+     platforms which have larger off_t sizes.  See MAXFILESIZE_LARGE below. */
+  CINIT(MAXFILESIZE, LONG, 114),
+
+  /* See the comment for INFILESIZE above, but in short, specifies
+   * the size of the file being uploaded.  -1 means unknown.
+   */
+  CINIT(INFILESIZE_LARGE, OFF_T, 115),
+
+  /* Sets the continuation offset.  There is also a LONG version of this;
+   * look above for RESUME_FROM.
+   */
+  CINIT(RESUME_FROM_LARGE, OFF_T, 116),
+
+  /* Sets the maximum size of data that will be downloaded from
+   * an HTTP or FTP server.  See MAXFILESIZE above for the LONG version.
+   */
+  CINIT(MAXFILESIZE_LARGE, OFF_T, 117),
+
+  /* Set this option to the file name of your .netrc file you want libcurl
+     to parse (using the CURLOPT_NETRC option). If not set, libcurl will do
+     a poor attempt to find the user's home directory and check for a .netrc
+     file in there. */
+  CINIT(NETRC_FILE, STRINGPOINT, 118),
+
+  /* Enable SSL/TLS for FTP, pick one of:
+     CURLUSESSL_TRY     - try using SSL, proceed anyway otherwise
+     CURLUSESSL_CONTROL - SSL for the control connection or fail
+     CURLUSESSL_ALL     - SSL for all communication or fail
+  */
+  CINIT(USE_SSL, LONG, 119),
+
+  /* The _LARGE version of the standard POSTFIELDSIZE option */
+  CINIT(POSTFIELDSIZE_LARGE, OFF_T, 120),
+
+  /* Enable/disable the TCP Nagle algorithm */
+  CINIT(TCP_NODELAY, LONG, 121),
+
+  /* 122 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */
+  /* 123 OBSOLETE. Gone in 7.16.0 */
+  /* 124 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */
+  /* 125 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */
+  /* 126 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */
+  /* 127 OBSOLETE. Gone in 7.16.0 */
+  /* 128 OBSOLETE. Gone in 7.16.0 */
+
+  /* When FTP over SSL/TLS is selected (with CURLOPT_USE_SSL), this option
+     can be used to change libcurl's default action which is to first try
+     "AUTH SSL" and then "AUTH TLS" in this order, and proceed when a OK
+     response has been received.
+
+     Available parameters are:
+     CURLFTPAUTH_DEFAULT - let libcurl decide
+     CURLFTPAUTH_SSL     - try "AUTH SSL" first, then TLS
+     CURLFTPAUTH_TLS     - try "AUTH TLS" first, then SSL
+  */
+  CINIT(FTPSSLAUTH, LONG, 129),
+
+  CINIT(IOCTLFUNCTION, FUNCTIONPOINT, 130),
+  CINIT(IOCTLDATA, OBJECTPOINT, 131),
+
+  /* 132 OBSOLETE. Gone in 7.16.0 */
+  /* 133 OBSOLETE. Gone in 7.16.0 */
+
+  /* zero terminated string for pass on to the FTP server when asked for
+     "account" info */
+  CINIT(FTP_ACCOUNT, STRINGPOINT, 134),
+
+  /* feed cookie into cookie engine */
+  CINIT(COOKIELIST, STRINGPOINT, 135),
+
+  /* ignore Content-Length */
+  CINIT(IGNORE_CONTENT_LENGTH, LONG, 136),
+
+  /* Set to non-zero to skip the IP address received in a 227 PASV FTP server
+     response. Typically used for FTP-SSL purposes but is not restricted to
+     that. libcurl will then instead use the same IP address it used for the
+     control connection. */
+  CINIT(FTP_SKIP_PASV_IP, LONG, 137),
+
+  /* Select "file method" to use when doing FTP, see the curl_ftpmethod
+     above. */
+  CINIT(FTP_FILEMETHOD, LONG, 138),
+
+  /* Local port number to bind the socket to */
+  CINIT(LOCALPORT, LONG, 139),
+
+  /* Number of ports to try, including the first one set with LOCALPORT.
+     Thus, setting it to 1 will make no additional attempts but the first.
+  */
+  CINIT(LOCALPORTRANGE, LONG, 140),
+
+  /* no transfer, set up connection and let application use the socket by
+     extracting it with CURLINFO_LASTSOCKET */
+  CINIT(CONNECT_ONLY, LONG, 141),
+
+  /* Function that will be called to convert from the
+     network encoding (instead of using the iconv calls in libcurl) */
+  CINIT(CONV_FROM_NETWORK_FUNCTION, FUNCTIONPOINT, 142),
+
+  /* Function that will be called to convert to the
+     network encoding (instead of using the iconv calls in libcurl) */
+  CINIT(CONV_TO_NETWORK_FUNCTION, FUNCTIONPOINT, 143),
+
+  /* Function that will be called to convert from UTF8
+     (instead of using the iconv calls in libcurl)
+     Note that this is used only for SSL certificate processing */
+  CINIT(CONV_FROM_UTF8_FUNCTION, FUNCTIONPOINT, 144),
+
+  /* if the connection proceeds too quickly then need to slow it down */
+  /* limit-rate: maximum number of bytes per second to send or receive */
+  CINIT(MAX_SEND_SPEED_LARGE, OFF_T, 145),
+  CINIT(MAX_RECV_SPEED_LARGE, OFF_T, 146),
+
+  /* Pointer to command string to send if USER/PASS fails. */
+  CINIT(FTP_ALTERNATIVE_TO_USER, STRINGPOINT, 147),
+
+  /* callback function for setting socket options */
+  CINIT(SOCKOPTFUNCTION, FUNCTIONPOINT, 148),
+  CINIT(SOCKOPTDATA, OBJECTPOINT, 149),
+
+  /* set to 0 to disable session ID re-use for this transfer, default is
+     enabled (== 1) */
+  CINIT(SSL_SESSIONID_CACHE, LONG, 150),
+
+  /* allowed SSH authentication methods */
+  CINIT(SSH_AUTH_TYPES, LONG, 151),
+
+  /* Used by scp/sftp to do public/private key authentication */
+  CINIT(SSH_PUBLIC_KEYFILE, STRINGPOINT, 152),
+  CINIT(SSH_PRIVATE_KEYFILE, STRINGPOINT, 153),
+
+  /* Send CCC (Clear Command Channel) after authentication */
+  CINIT(FTP_SSL_CCC, LONG, 154),
+
+  /* Same as TIMEOUT and CONNECTTIMEOUT, but with ms resolution */
+  CINIT(TIMEOUT_MS, LONG, 155),
+  CINIT(CONNECTTIMEOUT_MS, LONG, 156),
+
+  /* set to zero to disable the libcurl's decoding and thus pass the raw body
+     data to the application even when it is encoded/compressed */
+  CINIT(HTTP_TRANSFER_DECODING, LONG, 157),
+  CINIT(HTTP_CONTENT_DECODING, LONG, 158),
+
+  /* Permission used when creating new files and directories on the remote
+     server for protocols that support it, SFTP/SCP/FILE */
+  CINIT(NEW_FILE_PERMS, LONG, 159),
+  CINIT(NEW_DIRECTORY_PERMS, LONG, 160),
+
+  /* Set the behaviour of POST when redirecting. Values must be set to one
+     of CURL_REDIR* defines below. This used to be called CURLOPT_POST301 */
+  CINIT(POSTREDIR, LONG, 161),
+
+  /* used by scp/sftp to verify the host's public key */
+  CINIT(SSH_HOST_PUBLIC_KEY_MD5, STRINGPOINT, 162),
+
+  /* Callback function for opening socket (instead of socket(2)). Optionally,
+     callback is able change the address or refuse to connect returning
+     CURL_SOCKET_BAD.  The callback should have type
+     curl_opensocket_callback */
+  CINIT(OPENSOCKETFUNCTION, FUNCTIONPOINT, 163),
+  CINIT(OPENSOCKETDATA, OBJECTPOINT, 164),
+
+  /* POST volatile input fields. */
+  CINIT(COPYPOSTFIELDS, OBJECTPOINT, 165),
+
+  /* set transfer mode (;type=<a|i>) when doing FTP via an HTTP proxy */
+  CINIT(PROXY_TRANSFER_MODE, LONG, 166),
+
+  /* Callback function for seeking in the input stream */
+  CINIT(SEEKFUNCTION, FUNCTIONPOINT, 167),
+  CINIT(SEEKDATA, OBJECTPOINT, 168),
+
+  /* CRL file */
+  CINIT(CRLFILE, STRINGPOINT, 169),
+
+  /* Issuer certificate */
+  CINIT(ISSUERCERT, STRINGPOINT, 170),
+
+  /* (IPv6) Address scope */
+  CINIT(ADDRESS_SCOPE, LONG, 171),
+
+  /* Collect certificate chain info and allow it to get retrievable with
+     CURLINFO_CERTINFO after the transfer is complete. */
+  CINIT(CERTINFO, LONG, 172),
+
+  /* "name" and "pwd" to use when fetching. */
+  CINIT(USERNAME, STRINGPOINT, 173),
+  CINIT(PASSWORD, STRINGPOINT, 174),
+
+    /* "name" and "pwd" to use with Proxy when fetching. */
+  CINIT(PROXYUSERNAME, STRINGPOINT, 175),
+  CINIT(PROXYPASSWORD, STRINGPOINT, 176),
+
+  /* Comma separated list of hostnames defining no-proxy zones. These should
+     match both hostnames directly, and hostnames within a domain. For
+     example, local.com will match local.com and www.local.com, but NOT
+     notlocal.com or www.notlocal.com. For compatibility with other
+     implementations of this, .local.com will be considered to be the same as
+     local.com. A single * is the only valid wildcard, and effectively
+     disables the use of proxy. */
+  CINIT(NOPROXY, STRINGPOINT, 177),
+
+  /* block size for TFTP transfers */
+  CINIT(TFTP_BLKSIZE, LONG, 178),
+
+  /* Socks Service */
+  CINIT(SOCKS5_GSSAPI_SERVICE, STRINGPOINT, 179), /* DEPRECATED, do not use! */
+
+  /* Socks Service */
+  CINIT(SOCKS5_GSSAPI_NEC, LONG, 180),
+
+  /* set the bitmask for the protocols that are allowed to be used for the
+     transfer, which thus helps the app which takes URLs from users or other
+     external inputs and want to restrict what protocol(s) to deal
+     with. Defaults to CURLPROTO_ALL. */
+  CINIT(PROTOCOLS, LONG, 181),
+
+  /* set the bitmask for the protocols that libcurl is allowed to follow to,
+     as a subset of the CURLOPT_PROTOCOLS ones. That means the protocol needs
+     to be set in both bitmasks to be allowed to get redirected to. Defaults
+     to all protocols except FILE and SCP. */
+  CINIT(REDIR_PROTOCOLS, LONG, 182),
+
+  /* set the SSH knownhost file name to use */
+  CINIT(SSH_KNOWNHOSTS, STRINGPOINT, 183),
+
+  /* set the SSH host key callback, must point to a curl_sshkeycallback
+     function */
+  CINIT(SSH_KEYFUNCTION, FUNCTIONPOINT, 184),
+
+  /* set the SSH host key callback custom pointer */
+  CINIT(SSH_KEYDATA, OBJECTPOINT, 185),
+
+  /* set the SMTP mail originator */
+  CINIT(MAIL_FROM, STRINGPOINT, 186),
+
+  /* set the list of SMTP mail receiver(s) */
+  CINIT(MAIL_RCPT, OBJECTPOINT, 187),
+
+  /* FTP: send PRET before PASV */
+  CINIT(FTP_USE_PRET, LONG, 188),
+
+  /* RTSP request method (OPTIONS, SETUP, PLAY, etc...) */
+  CINIT(RTSP_REQUEST, LONG, 189),
+
+  /* The RTSP session identifier */
+  CINIT(RTSP_SESSION_ID, STRINGPOINT, 190),
+
+  /* The RTSP stream URI */
+  CINIT(RTSP_STREAM_URI, STRINGPOINT, 191),
+
+  /* The Transport: header to use in RTSP requests */
+  CINIT(RTSP_TRANSPORT, STRINGPOINT, 192),
+
+  /* Manually initialize the client RTSP CSeq for this handle */
+  CINIT(RTSP_CLIENT_CSEQ, LONG, 193),
+
+  /* Manually initialize the server RTSP CSeq for this handle */
+  CINIT(RTSP_SERVER_CSEQ, LONG, 194),
+
+  /* The stream to pass to INTERLEAVEFUNCTION. */
+  CINIT(INTERLEAVEDATA, OBJECTPOINT, 195),
+
+  /* Let the application define a custom write method for RTP data */
+  CINIT(INTERLEAVEFUNCTION, FUNCTIONPOINT, 196),
+
+  /* Turn on wildcard matching */
+  CINIT(WILDCARDMATCH, LONG, 197),
+
+  /* Directory matching callback called before downloading of an
+     individual file (chunk) started */
+  CINIT(CHUNK_BGN_FUNCTION, FUNCTIONPOINT, 198),
+
+  /* Directory matching callback called after the file (chunk)
+     was downloaded, or skipped */
+  CINIT(CHUNK_END_FUNCTION, FUNCTIONPOINT, 199),
+
+  /* Change match (fnmatch-like) callback for wildcard matching */
+  CINIT(FNMATCH_FUNCTION, FUNCTIONPOINT, 200),
+
+  /* Let the application define custom chunk data pointer */
+  CINIT(CHUNK_DATA, OBJECTPOINT, 201),
+
+  /* FNMATCH_FUNCTION user pointer */
+  CINIT(FNMATCH_DATA, OBJECTPOINT, 202),
+
+  /* send linked-list of name:port:address sets */
+  CINIT(RESOLVE, OBJECTPOINT, 203),
+
+  /* Set a username for authenticated TLS */
+  CINIT(TLSAUTH_USERNAME, STRINGPOINT, 204),
+
+  /* Set a password for authenticated TLS */
+  CINIT(TLSAUTH_PASSWORD, STRINGPOINT, 205),
+
+  /* Set authentication type for authenticated TLS */
+  CINIT(TLSAUTH_TYPE, STRINGPOINT, 206),
+
+  /* Set to 1 to enable the "TE:" header in HTTP requests to ask for
+     compressed transfer-encoded responses. Set to 0 to disable the use of TE:
+     in outgoing requests. The current default is 0, but it might change in a
+     future libcurl release.
+
+     libcurl will ask for the compressed methods it knows of, and if that
+     isn't any, it will not ask for transfer-encoding at all even if this
+     option is set to 1.
+
+  */
+  CINIT(TRANSFER_ENCODING, LONG, 207),
+
+  /* Callback function for closing socket (instead of close(2)). The callback
+     should have type curl_closesocket_callback */
+  CINIT(CLOSESOCKETFUNCTION, FUNCTIONPOINT, 208),
+  CINIT(CLOSESOCKETDATA, OBJECTPOINT, 209),
+
+  /* allow GSSAPI credential delegation */
+  CINIT(GSSAPI_DELEGATION, LONG, 210),
+
+  /* Set the name servers to use for DNS resolution */
+  CINIT(DNS_SERVERS, STRINGPOINT, 211),
+
+  /* Time-out accept operations (currently for FTP only) after this amount
+     of milliseconds. */
+  CINIT(ACCEPTTIMEOUT_MS, LONG, 212),
+
+  /* Set TCP keepalive */
+  CINIT(TCP_KEEPALIVE, LONG, 213),
+
+  /* non-universal keepalive knobs (Linux, AIX, HP-UX, more) */
+  CINIT(TCP_KEEPIDLE, LONG, 214),
+  CINIT(TCP_KEEPINTVL, LONG, 215),
+
+  /* Enable/disable specific SSL features with a bitmask, see CURLSSLOPT_* */
+  CINIT(SSL_OPTIONS, LONG, 216),
+
+  /* Set the SMTP auth originator */
+  CINIT(MAIL_AUTH, STRINGPOINT, 217),
+
+  /* Enable/disable SASL initial response */
+  CINIT(SASL_IR, LONG, 218),
+
+  /* Function that will be called instead of the internal progress display
+   * function. This function should be defined as the curl_xferinfo_callback
+   * prototype defines. (Deprecates CURLOPT_PROGRESSFUNCTION) */
+  CINIT(XFERINFOFUNCTION, FUNCTIONPOINT, 219),
+
+  /* The XOAUTH2 bearer token */
+  CINIT(XOAUTH2_BEARER, STRINGPOINT, 220),
+
+  /* Set the interface string to use as outgoing network
+   * interface for DNS requests.
+   * Only supported by the c-ares DNS backend */
+  CINIT(DNS_INTERFACE, STRINGPOINT, 221),
+
+  /* Set the local IPv4 address to use for outgoing DNS requests.
+   * Only supported by the c-ares DNS backend */
+  CINIT(DNS_LOCAL_IP4, STRINGPOINT, 222),
+
+  /* Set the local IPv4 address to use for outgoing DNS requests.
+   * Only supported by the c-ares DNS backend */
+  CINIT(DNS_LOCAL_IP6, STRINGPOINT, 223),
+
+  /* Set authentication options directly */
+  CINIT(LOGIN_OPTIONS, STRINGPOINT, 224),
+
+  /* Enable/disable TLS NPN extension (http2 over ssl might fail without) */
+  CINIT(SSL_ENABLE_NPN, LONG, 225),
+
+  /* Enable/disable TLS ALPN extension (http2 over ssl might fail without) */
+  CINIT(SSL_ENABLE_ALPN, LONG, 226),
+
+  /* Time to wait for a response to a HTTP request containing an
+   * Expect: 100-continue header before sending the data anyway. */
+  CINIT(EXPECT_100_TIMEOUT_MS, LONG, 227),
+
+  /* This points to a linked list of headers used for proxy requests only,
+     struct curl_slist kind */
+  CINIT(PROXYHEADER, OBJECTPOINT, 228),
+
+  /* Pass in a bitmask of "header options" */
+  CINIT(HEADEROPT, LONG, 229),
+
+  /* The public key in DER form used to validate the peer public key
+     this option is used only if SSL_VERIFYPEER is true */
+  CINIT(PINNEDPUBLICKEY, STRINGPOINT, 230),
+
+  /* Path to Unix domain socket */
+  CINIT(UNIX_SOCKET_PATH, STRINGPOINT, 231),
+
+  /* Set if we should verify the certificate status. */
+  CINIT(SSL_VERIFYSTATUS, LONG, 232),
+
+  /* Set if we should enable TLS false start. */
+  CINIT(SSL_FALSESTART, LONG, 233),
+
+  /* Do not squash dot-dot sequences */
+  CINIT(PATH_AS_IS, LONG, 234),
+
+  /* Proxy Service Name */
+  CINIT(PROXY_SERVICE_NAME, STRINGPOINT, 235),
+
+  /* Service Name */
+  CINIT(SERVICE_NAME, STRINGPOINT, 236),
+
+  /* Wait/don't wait for pipe/mutex to clarify */
+  CINIT(PIPEWAIT, LONG, 237),
+
+  /* Set the protocol used when curl is given a URL without a protocol */
+  CINIT(DEFAULT_PROTOCOL, STRINGPOINT, 238),
+
+  /* Set stream weight, 1 - 256 (default is 16) */
+  CINIT(STREAM_WEIGHT, LONG, 239),
+
+  /* Set stream dependency on another CURL handle */
+  CINIT(STREAM_DEPENDS, OBJECTPOINT, 240),
+
+  /* Set E-xclusive stream dependency on another CURL handle */
+  CINIT(STREAM_DEPENDS_E, OBJECTPOINT, 241),
+
+  /* Do not send any tftp option requests to the server */
+  CINIT(TFTP_NO_OPTIONS, LONG, 242),
+
+  /* Linked-list of host:port:connect-to-host:connect-to-port,
+     overrides the URL's host:port (only for the network layer) */
+  CINIT(CONNECT_TO, OBJECTPOINT, 243),
+
+  /* Set TCP Fast Open */
+  CINIT(TCP_FASTOPEN, LONG, 244),
+
+  /* Continue to send data if the server responds early with an
+   * HTTP status code >= 300 */
+  CINIT(KEEP_SENDING_ON_ERROR, LONG, 245),
+
+  /* The CApath or CAfile used to validate the proxy certificate
+     this option is used only if PROXY_SSL_VERIFYPEER is true */
+  CINIT(PROXY_CAINFO, STRINGPOINT, 246),
+
+  /* The CApath directory used to validate the proxy certificate
+     this option is used only if PROXY_SSL_VERIFYPEER is true */
+  CINIT(PROXY_CAPATH, STRINGPOINT, 247),
+
+  /* Set if we should verify the proxy in ssl handshake,
+     set 1 to verify. */
+  CINIT(PROXY_SSL_VERIFYPEER, LONG, 248),
+
+  /* Set if we should verify the Common name from the proxy certificate in ssl
+   * handshake, set 1 to check existence, 2 to ensure that it matches
+   * the provided hostname. */
+  CINIT(PROXY_SSL_VERIFYHOST, LONG, 249),
+
+  /* What version to specifically try to use for proxy.
+     See CURL_SSLVERSION defines below. */
+  CINIT(PROXY_SSLVERSION, LONG, 250),
+
+  /* Set a username for authenticated TLS for proxy */
+  CINIT(PROXY_TLSAUTH_USERNAME, STRINGPOINT, 251),
+
+  /* Set a password for authenticated TLS for proxy */
+  CINIT(PROXY_TLSAUTH_PASSWORD, STRINGPOINT, 252),
+
+  /* Set authentication type for authenticated TLS for proxy */
+  CINIT(PROXY_TLSAUTH_TYPE, STRINGPOINT, 253),
+
+  /* name of the file keeping your private SSL-certificate for proxy */
+  CINIT(PROXY_SSLCERT, STRINGPOINT, 254),
+
+  /* type of the file keeping your SSL-certificate ("DER", "PEM", "ENG") for
+     proxy */
+  CINIT(PROXY_SSLCERTTYPE, STRINGPOINT, 255),
+
+  /* name of the file keeping your private SSL-key for proxy */
+  CINIT(PROXY_SSLKEY, STRINGPOINT, 256),
+
+  /* type of the file keeping your private SSL-key ("DER", "PEM", "ENG") for
+     proxy */
+  CINIT(PROXY_SSLKEYTYPE, STRINGPOINT, 257),
+
+  /* password for the SSL private key for proxy */
+  CINIT(PROXY_KEYPASSWD, STRINGPOINT, 258),
+
+  /* Specify which SSL ciphers to use for proxy */
+  CINIT(PROXY_SSL_CIPHER_LIST, STRINGPOINT, 259),
+
+  /* CRL file for proxy */
+  CINIT(PROXY_CRLFILE, STRINGPOINT, 260),
+
+  /* Enable/disable specific SSL features with a bitmask for proxy, see
+     CURLSSLOPT_* */
+  CINIT(PROXY_SSL_OPTIONS, LONG, 261),
+
+  /* Name of pre proxy to use. */
+  CINIT(PRE_PROXY, STRINGPOINT, 262),
+
+  /* The public key in DER form used to validate the proxy public key
+     this option is used only if PROXY_SSL_VERIFYPEER is true */
+  CINIT(PROXY_PINNEDPUBLICKEY, STRINGPOINT, 263),
+
+  /* Path to an abstract Unix domain socket */
+  CINIT(ABSTRACT_UNIX_SOCKET, STRINGPOINT, 264),
+
+  /* Suppress proxy CONNECT response headers from user callbacks */
+  CINIT(SUPPRESS_CONNECT_HEADERS, LONG, 265),
+
+  CURLOPT_LASTENTRY /* the last unused */
+} CURLoption;
+
+#ifndef CURL_NO_OLDIES /* define this to test if your app builds with all
+                          the obsolete stuff removed! */
+
+/* Backwards compatibility with older names */
+/* These are scheduled to disappear by 2011 */
+
+/* This was added in version 7.19.1 */
+#define CURLOPT_POST301 CURLOPT_POSTREDIR
+
+/* These are scheduled to disappear by 2009 */
+
+/* The following were added in 7.17.0 */
+#define CURLOPT_SSLKEYPASSWD CURLOPT_KEYPASSWD
+#define CURLOPT_FTPAPPEND CURLOPT_APPEND
+#define CURLOPT_FTPLISTONLY CURLOPT_DIRLISTONLY
+#define CURLOPT_FTP_SSL CURLOPT_USE_SSL
+
+/* The following were added earlier */
+
+#define CURLOPT_SSLCERTPASSWD CURLOPT_KEYPASSWD
+#define CURLOPT_KRB4LEVEL CURLOPT_KRBLEVEL
+
+#else
+/* This is set if CURL_NO_OLDIES is defined at compile-time */
+#undef CURLOPT_DNS_USE_GLOBAL_CACHE /* soon obsolete */
+#endif
+
+
+  /* Below here follows defines for the CURLOPT_IPRESOLVE option. If a host
+     name resolves addresses using more than one IP protocol version, this
+     option might be handy to force libcurl to use a specific IP version. */
+#define CURL_IPRESOLVE_WHATEVER 0 /* default, resolves addresses to all IP
+                                     versions that your system allows */
+#define CURL_IPRESOLVE_V4       1 /* resolve to IPv4 addresses */
+#define CURL_IPRESOLVE_V6       2 /* resolve to IPv6 addresses */
+
+  /* three convenient "aliases" that follow the name scheme better */
+#define CURLOPT_RTSPHEADER CURLOPT_HTTPHEADER
+
+  /* These enums are for use with the CURLOPT_HTTP_VERSION option. */
+enum {
+  CURL_HTTP_VERSION_NONE, /* setting this means we don't care, and that we'd
+                             like the library to choose the best possible
+                             for us! */
+  CURL_HTTP_VERSION_1_0,  /* please use HTTP 1.0 in the request */
+  CURL_HTTP_VERSION_1_1,  /* please use HTTP 1.1 in the request */
+  CURL_HTTP_VERSION_2_0,  /* please use HTTP 2 in the request */
+  CURL_HTTP_VERSION_2TLS, /* use version 2 for HTTPS, version 1.1 for HTTP */
+  CURL_HTTP_VERSION_2_PRIOR_KNOWLEDGE,  /* please use HTTP 2 without HTTP/1.1
+                                           Upgrade */
+
+  CURL_HTTP_VERSION_LAST /* *ILLEGAL* http version */
+};
+
+/* Convenience definition simple because the name of the version is HTTP/2 and
+   not 2.0. The 2_0 version of the enum name was set while the version was
+   still planned to be 2.0 and we stick to it for compatibility. */
+#define CURL_HTTP_VERSION_2 CURL_HTTP_VERSION_2_0
+
+/*
+ * Public API enums for RTSP requests
+ */
+enum {
+    CURL_RTSPREQ_NONE, /* first in list */
+    CURL_RTSPREQ_OPTIONS,
+    CURL_RTSPREQ_DESCRIBE,
+    CURL_RTSPREQ_ANNOUNCE,
+    CURL_RTSPREQ_SETUP,
+    CURL_RTSPREQ_PLAY,
+    CURL_RTSPREQ_PAUSE,
+    CURL_RTSPREQ_TEARDOWN,
+    CURL_RTSPREQ_GET_PARAMETER,
+    CURL_RTSPREQ_SET_PARAMETER,
+    CURL_RTSPREQ_RECORD,
+    CURL_RTSPREQ_RECEIVE,
+    CURL_RTSPREQ_LAST /* last in list */
+};
+
+  /* These enums are for use with the CURLOPT_NETRC option. */
+enum CURL_NETRC_OPTION {
+  CURL_NETRC_IGNORED,     /* The .netrc will never be read.
+                           * This is the default. */
+  CURL_NETRC_OPTIONAL,    /* A user:password in the URL will be preferred
+                           * to one in the .netrc. */
+  CURL_NETRC_REQUIRED,    /* A user:password in the URL will be ignored.
+                           * Unless one is set programmatically, the .netrc
+                           * will be queried. */
+  CURL_NETRC_LAST
+};
+
+enum {
+  CURL_SSLVERSION_DEFAULT,
+  CURL_SSLVERSION_TLSv1, /* TLS 1.x */
+  CURL_SSLVERSION_SSLv2,
+  CURL_SSLVERSION_SSLv3,
+  CURL_SSLVERSION_TLSv1_0,
+  CURL_SSLVERSION_TLSv1_1,
+  CURL_SSLVERSION_TLSv1_2,
+  CURL_SSLVERSION_TLSv1_3,
+
+  CURL_SSLVERSION_LAST /* never use, keep last */
+};
+
+enum {
+  CURL_SSLVERSION_MAX_NONE =     0,
+  CURL_SSLVERSION_MAX_DEFAULT =  (CURL_SSLVERSION_TLSv1   << 16),
+  CURL_SSLVERSION_MAX_TLSv1_0 =  (CURL_SSLVERSION_TLSv1_0 << 16),
+  CURL_SSLVERSION_MAX_TLSv1_1 =  (CURL_SSLVERSION_TLSv1_1 << 16),
+  CURL_SSLVERSION_MAX_TLSv1_2 =  (CURL_SSLVERSION_TLSv1_2 << 16),
+  CURL_SSLVERSION_MAX_TLSv1_3 =  (CURL_SSLVERSION_TLSv1_3 << 16),
+
+  /* never use, keep last */
+  CURL_SSLVERSION_MAX_LAST =     (CURL_SSLVERSION_LAST    << 16)
+};
+
+enum CURL_TLSAUTH {
+  CURL_TLSAUTH_NONE,
+  CURL_TLSAUTH_SRP,
+  CURL_TLSAUTH_LAST /* never use, keep last */
+};
+
+/* symbols to use with CURLOPT_POSTREDIR.
+   CURL_REDIR_POST_301, CURL_REDIR_POST_302 and CURL_REDIR_POST_303
+   can be bitwise ORed so that CURL_REDIR_POST_301 | CURL_REDIR_POST_302
+   | CURL_REDIR_POST_303 == CURL_REDIR_POST_ALL */
+
+#define CURL_REDIR_GET_ALL  0
+#define CURL_REDIR_POST_301 1
+#define CURL_REDIR_POST_302 2
+#define CURL_REDIR_POST_303 4
+#define CURL_REDIR_POST_ALL \
+    (CURL_REDIR_POST_301|CURL_REDIR_POST_302|CURL_REDIR_POST_303)
+
+typedef enum {
+  CURL_TIMECOND_NONE,
+
+  CURL_TIMECOND_IFMODSINCE,
+  CURL_TIMECOND_IFUNMODSINCE,
+  CURL_TIMECOND_LASTMOD,
+
+  CURL_TIMECOND_LAST
+} curl_TimeCond;
+
+
+/* curl_strequal() and curl_strnequal() are subject for removal in a future
+   libcurl, see lib/README.curlx for details
+
+   !checksrc! disable SPACEBEFOREPAREN 2
+*/
+CURL_EXTERN int (curl_strequal)(const char *s1, const char *s2);
+CURL_EXTERN int (curl_strnequal)(const char *s1, const char *s2, size_t n);
+
+/* name is uppercase CURLFORM_<name> */
+#ifdef CFINIT
+#undef CFINIT
+#endif
+
+#ifdef CURL_ISOCPP
+#define CFINIT(name) CURLFORM_ ## name
+#else
+/* The macro "##" is ISO C, we assume pre-ISO C doesn't support it. */
+#define CFINIT(name) CURLFORM_/**/name
+#endif
+
+typedef enum {
+  CFINIT(NOTHING),        /********* the first one is unused ************/
+
+  /*  */
+  CFINIT(COPYNAME),
+  CFINIT(PTRNAME),
+  CFINIT(NAMELENGTH),
+  CFINIT(COPYCONTENTS),
+  CFINIT(PTRCONTENTS),
+  CFINIT(CONTENTSLENGTH),
+  CFINIT(FILECONTENT),
+  CFINIT(ARRAY),
+  CFINIT(OBSOLETE),
+  CFINIT(FILE),
+
+  CFINIT(BUFFER),
+  CFINIT(BUFFERPTR),
+  CFINIT(BUFFERLENGTH),
+
+  CFINIT(CONTENTTYPE),
+  CFINIT(CONTENTHEADER),
+  CFINIT(FILENAME),
+  CFINIT(END),
+  CFINIT(OBSOLETE2),
+
+  CFINIT(STREAM),
+  CFINIT(CONTENTLEN), /* added in 7.46.0, provide a curl_off_t length */
+
+  CURLFORM_LASTENTRY /* the last unused */
+} CURLformoption;
+
+#undef CFINIT /* done */
+
+/* structure to be used as parameter for CURLFORM_ARRAY */
+struct curl_forms {
+  CURLformoption option;
+  const char     *value;
+};
+
+/* use this for multipart formpost building */
+/* Returns code for curl_formadd()
+ *
+ * Returns:
+ * CURL_FORMADD_OK             on success
+ * CURL_FORMADD_MEMORY         if the FormInfo allocation fails
+ * CURL_FORMADD_OPTION_TWICE   if one option is given twice for one Form
+ * CURL_FORMADD_NULL           if a null pointer was given for a char
+ * CURL_FORMADD_MEMORY         if the allocation of a FormInfo struct failed
+ * CURL_FORMADD_UNKNOWN_OPTION if an unknown option was used
+ * CURL_FORMADD_INCOMPLETE     if the some FormInfo is not complete (or error)
+ * CURL_FORMADD_MEMORY         if a curl_httppost struct cannot be allocated
+ * CURL_FORMADD_MEMORY         if some allocation for string copying failed.
+ * CURL_FORMADD_ILLEGAL_ARRAY  if an illegal option is used in an array
+ *
+ ***************************************************************************/
+typedef enum {
+  CURL_FORMADD_OK, /* first, no error */
+
+  CURL_FORMADD_MEMORY,
+  CURL_FORMADD_OPTION_TWICE,
+  CURL_FORMADD_NULL,
+  CURL_FORMADD_UNKNOWN_OPTION,
+  CURL_FORMADD_INCOMPLETE,
+  CURL_FORMADD_ILLEGAL_ARRAY,
+  CURL_FORMADD_DISABLED, /* libcurl was built with this disabled */
+
+  CURL_FORMADD_LAST /* last */
+} CURLFORMcode;
+
+/*
+ * NAME curl_formadd()
+ *
+ * DESCRIPTION
+ *
+ * Pretty advanced function for building multi-part formposts. Each invoke
+ * adds one part that together construct a full post. Then use
+ * CURLOPT_HTTPPOST to send it off to libcurl.
+ */
+CURL_EXTERN CURLFORMcode curl_formadd(struct curl_httppost **httppost,
+                                      struct curl_httppost **last_post,
+                                      ...);
+
+/*
+ * callback function for curl_formget()
+ * The void *arg pointer will be the one passed as second argument to
+ *   curl_formget().
+ * The character buffer passed to it must not be freed.
+ * Should return the buffer length passed to it as the argument "len" on
+ *   success.
+ */
+typedef size_t (*curl_formget_callback)(void *arg, const char *buf,
+                                        size_t len);
+
+/*
+ * NAME curl_formget()
+ *
+ * DESCRIPTION
+ *
+ * Serialize a curl_httppost struct built with curl_formadd().
+ * Accepts a void pointer as second argument which will be passed to
+ * the curl_formget_callback function.
+ * Returns 0 on success.
+ */
+CURL_EXTERN int curl_formget(struct curl_httppost *form, void *arg,
+                             curl_formget_callback append);
+/*
+ * NAME curl_formfree()
+ *
+ * DESCRIPTION
+ *
+ * Free a multipart formpost previously built with curl_formadd().
+ */
+CURL_EXTERN void curl_formfree(struct curl_httppost *form);
+
+/*
+ * NAME curl_getenv()
+ *
+ * DESCRIPTION
+ *
+ * Returns a malloc()'ed string that MUST be curl_free()ed after usage is
+ * complete. DEPRECATED - see lib/README.curlx
+ */
+CURL_EXTERN char *curl_getenv(const char *variable);
+
+/*
+ * NAME curl_version()
+ *
+ * DESCRIPTION
+ *
+ * Returns a static ascii string of the libcurl version.
+ */
+CURL_EXTERN char *curl_version(void);
+
+/*
+ * NAME curl_easy_escape()
+ *
+ * DESCRIPTION
+ *
+ * Escapes URL strings (converts all letters consider illegal in URLs to their
+ * %XX versions). This function returns a new allocated string or NULL if an
+ * error occurred.
+ */
+CURL_EXTERN char *curl_easy_escape(CURL *handle,
+                                   const char *string,
+                                   int length);
+
+/* the previous version: */
+CURL_EXTERN char *curl_escape(const char *string,
+                              int length);
+
+
+/*
+ * NAME curl_easy_unescape()
+ *
+ * DESCRIPTION
+ *
+ * Unescapes URL encoding in strings (converts all %XX codes to their 8bit
+ * versions). This function returns a new allocated string or NULL if an error
+ * occurred.
+ * Conversion Note: On non-ASCII platforms the ASCII %XX codes are
+ * converted into the host encoding.
+ */
+CURL_EXTERN char *curl_easy_unescape(CURL *handle,
+                                     const char *string,
+                                     int length,
+                                     int *outlength);
+
+/* the previous version */
+CURL_EXTERN char *curl_unescape(const char *string,
+                                int length);
+
+/*
+ * NAME curl_free()
+ *
+ * DESCRIPTION
+ *
+ * Provided for de-allocation in the same translation unit that did the
+ * allocation. Added in libcurl 7.10
+ */
+CURL_EXTERN void curl_free(void *p);
+
+/*
+ * NAME curl_global_init()
+ *
+ * DESCRIPTION
+ *
+ * curl_global_init() should be invoked exactly once for each application that
+ * uses libcurl and before any call of other libcurl functions.
+ *
+ * This function is not thread-safe!
+ */
+CURL_EXTERN CURLcode curl_global_init(long flags);
+
+/*
+ * NAME curl_global_init_mem()
+ *
+ * DESCRIPTION
+ *
+ * curl_global_init() or curl_global_init_mem() should be invoked exactly once
+ * for each application that uses libcurl.  This function can be used to
+ * initialize libcurl and set user defined memory management callback
+ * functions.  Users can implement memory management routines to check for
+ * memory leaks, check for mis-use of the curl library etc.  User registered
+ * callback routines with be invoked by this library instead of the system
+ * memory management routines like malloc, free etc.
+ */
+CURL_EXTERN CURLcode curl_global_init_mem(long flags,
+                                          curl_malloc_callback m,
+                                          curl_free_callback f,
+                                          curl_realloc_callback r,
+                                          curl_strdup_callback s,
+                                          curl_calloc_callback c);
+
+/*
+ * NAME curl_global_cleanup()
+ *
+ * DESCRIPTION
+ *
+ * curl_global_cleanup() should be invoked exactly once for each application
+ * that uses libcurl
+ */
+CURL_EXTERN void curl_global_cleanup(void);
+
+/* linked-list structure for the CURLOPT_QUOTE option (and other) */
+struct curl_slist {
+  char *data;
+  struct curl_slist *next;
+};
+
+/*
+ * NAME curl_slist_append()
+ *
+ * DESCRIPTION
+ *
+ * Appends a string to a linked list. If no list exists, it will be created
+ * first. Returns the new list, after appending.
+ */
+CURL_EXTERN struct curl_slist *curl_slist_append(struct curl_slist *,
+                                                 const char *);
+
+/*
+ * NAME curl_slist_free_all()
+ *
+ * DESCRIPTION
+ *
+ * free a previously built curl_slist.
+ */
+CURL_EXTERN void curl_slist_free_all(struct curl_slist *);
+
+/*
+ * NAME curl_getdate()
+ *
+ * DESCRIPTION
+ *
+ * Returns the time, in seconds since 1 Jan 1970 of the time string given in
+ * the first argument. The time argument in the second parameter is unused
+ * and should be set to NULL.
+ */
+CURL_EXTERN time_t curl_getdate(const char *p, const time_t *unused);
+
+/* info about the certificate chain, only for OpenSSL builds. Asked
+   for with CURLOPT_CERTINFO / CURLINFO_CERTINFO */
+struct curl_certinfo {
+  int num_of_certs;             /* number of certificates with information */
+  struct curl_slist **certinfo; /* for each index in this array, there's a
+                                   linked list with textual information in the
+                                   format "name: value" */
+};
+
+/* enum for the different supported SSL backends */
+typedef enum {
+  CURLSSLBACKEND_NONE = 0,
+  CURLSSLBACKEND_OPENSSL = 1,
+  CURLSSLBACKEND_GNUTLS = 2,
+  CURLSSLBACKEND_NSS = 3,
+  CURLSSLBACKEND_OBSOLETE4 = 4,  /* Was QSOSSL. */
+  CURLSSLBACKEND_GSKIT = 5,
+  CURLSSLBACKEND_POLARSSL = 6,
+  CURLSSLBACKEND_CYASSL = 7,
+  CURLSSLBACKEND_SCHANNEL = 8,
+  CURLSSLBACKEND_DARWINSSL = 9,
+  CURLSSLBACKEND_AXTLS = 10,
+  CURLSSLBACKEND_MBEDTLS = 11
+} curl_sslbackend;
+
+/* aliases for library clones and renames */
+#define CURLSSLBACKEND_LIBRESSL 1
+#define CURLSSLBACKEND_BORINGSSL 1
+#define CURLSSLBACKEND_WOLFSSL 6
+
+/* Information about the SSL library used and the respective internal SSL
+   handle, which can be used to obtain further information regarding the
+   connection. Asked for with CURLINFO_TLS_SSL_PTR or CURLINFO_TLS_SESSION. */
+struct curl_tlssessioninfo {
+  curl_sslbackend backend;
+  void *internals;
+};
+
+#define CURLINFO_STRING   0x100000
+#define CURLINFO_LONG     0x200000
+#define CURLINFO_DOUBLE   0x300000
+#define CURLINFO_SLIST    0x400000
+#define CURLINFO_SOCKET   0x500000
+#define CURLINFO_MASK     0x0fffff
+#define CURLINFO_TYPEMASK 0xf00000
+
+typedef enum {
+  CURLINFO_NONE, /* first, never use this */
+  CURLINFO_EFFECTIVE_URL    = CURLINFO_STRING + 1,
+  CURLINFO_RESPONSE_CODE    = CURLINFO_LONG   + 2,
+  CURLINFO_TOTAL_TIME       = CURLINFO_DOUBLE + 3,
+  CURLINFO_NAMELOOKUP_TIME  = CURLINFO_DOUBLE + 4,
+  CURLINFO_CONNECT_TIME     = CURLINFO_DOUBLE + 5,
+  CURLINFO_PRETRANSFER_TIME = CURLINFO_DOUBLE + 6,
+  CURLINFO_SIZE_UPLOAD      = CURLINFO_DOUBLE + 7,
+  CURLINFO_SIZE_DOWNLOAD    = CURLINFO_DOUBLE + 8,
+  CURLINFO_SPEED_DOWNLOAD   = CURLINFO_DOUBLE + 9,
+  CURLINFO_SPEED_UPLOAD     = CURLINFO_DOUBLE + 10,
+  CURLINFO_HEADER_SIZE      = CURLINFO_LONG   + 11,
+  CURLINFO_REQUEST_SIZE     = CURLINFO_LONG   + 12,
+  CURLINFO_SSL_VERIFYRESULT = CURLINFO_LONG   + 13,
+  CURLINFO_FILETIME         = CURLINFO_LONG   + 14,
+  CURLINFO_CONTENT_LENGTH_DOWNLOAD   = CURLINFO_DOUBLE + 15,
+  CURLINFO_CONTENT_LENGTH_UPLOAD     = CURLINFO_DOUBLE + 16,
+  CURLINFO_STARTTRANSFER_TIME = CURLINFO_DOUBLE + 17,
+  CURLINFO_CONTENT_TYPE     = CURLINFO_STRING + 18,
+  CURLINFO_REDIRECT_TIME    = CURLINFO_DOUBLE + 19,
+  CURLINFO_REDIRECT_COUNT   = CURLINFO_LONG   + 20,
+  CURLINFO_PRIVATE          = CURLINFO_STRING + 21,
+  CURLINFO_HTTP_CONNECTCODE = CURLINFO_LONG   + 22,
+  CURLINFO_HTTPAUTH_AVAIL   = CURLINFO_LONG   + 23,
+  CURLINFO_PROXYAUTH_AVAIL  = CURLINFO_LONG   + 24,
+  CURLINFO_OS_ERRNO         = CURLINFO_LONG   + 25,
+  CURLINFO_NUM_CONNECTS     = CURLINFO_LONG   + 26,
+  CURLINFO_SSL_ENGINES      = CURLINFO_SLIST  + 27,
+  CURLINFO_COOKIELIST       = CURLINFO_SLIST  + 28,
+  CURLINFO_LASTSOCKET       = CURLINFO_LONG   + 29,
+  CURLINFO_FTP_ENTRY_PATH   = CURLINFO_STRING + 30,
+  CURLINFO_REDIRECT_URL     = CURLINFO_STRING + 31,
+  CURLINFO_PRIMARY_IP       = CURLINFO_STRING + 32,
+  CURLINFO_APPCONNECT_TIME  = CURLINFO_DOUBLE + 33,
+  CURLINFO_CERTINFO         = CURLINFO_SLIST  + 34,
+  CURLINFO_CONDITION_UNMET  = CURLINFO_LONG   + 35,
+  CURLINFO_RTSP_SESSION_ID  = CURLINFO_STRING + 36,
+  CURLINFO_RTSP_CLIENT_CSEQ = CURLINFO_LONG   + 37,
+  CURLINFO_RTSP_SERVER_CSEQ = CURLINFO_LONG   + 38,
+  CURLINFO_RTSP_CSEQ_RECV   = CURLINFO_LONG   + 39,
+  CURLINFO_PRIMARY_PORT     = CURLINFO_LONG   + 40,
+  CURLINFO_LOCAL_IP         = CURLINFO_STRING + 41,
+  CURLINFO_LOCAL_PORT       = CURLINFO_LONG   + 42,
+  CURLINFO_TLS_SESSION      = CURLINFO_SLIST  + 43,
+  CURLINFO_ACTIVESOCKET     = CURLINFO_SOCKET + 44,
+  CURLINFO_TLS_SSL_PTR      = CURLINFO_SLIST  + 45,
+  CURLINFO_HTTP_VERSION     = CURLINFO_LONG   + 46,
+  CURLINFO_PROXY_SSL_VERIFYRESULT = CURLINFO_LONG + 47,
+  CURLINFO_PROTOCOL         = CURLINFO_LONG   + 48,
+  CURLINFO_SCHEME           = CURLINFO_STRING + 49,
+  /* Fill in new entries below here! */
+
+  CURLINFO_LASTONE          = 49
+} CURLINFO;
+
+/* CURLINFO_RESPONSE_CODE is the new name for the option previously known as
+   CURLINFO_HTTP_CODE */
+#define CURLINFO_HTTP_CODE CURLINFO_RESPONSE_CODE
+
+typedef enum {
+  CURLCLOSEPOLICY_NONE, /* first, never use this */
+
+  CURLCLOSEPOLICY_OLDEST,
+  CURLCLOSEPOLICY_LEAST_RECENTLY_USED,
+  CURLCLOSEPOLICY_LEAST_TRAFFIC,
+  CURLCLOSEPOLICY_SLOWEST,
+  CURLCLOSEPOLICY_CALLBACK,
+
+  CURLCLOSEPOLICY_LAST /* last, never use this */
+} curl_closepolicy;
+
+#define CURL_GLOBAL_SSL (1<<0)
+#define CURL_GLOBAL_WIN32 (1<<1)
+#define CURL_GLOBAL_ALL (CURL_GLOBAL_SSL|CURL_GLOBAL_WIN32)
+#define CURL_GLOBAL_NOTHING 0
+#define CURL_GLOBAL_DEFAULT CURL_GLOBAL_ALL
+#define CURL_GLOBAL_ACK_EINTR (1<<2)
+
+
+/*****************************************************************************
+ * Setup defines, protos etc for the sharing stuff.
+ */
+
+/* Different data locks for a single share */
+typedef enum {
+  CURL_LOCK_DATA_NONE = 0,
+  /*  CURL_LOCK_DATA_SHARE is used internally to say that
+   *  the locking is just made to change the internal state of the share
+   *  itself.
+   */
+  CURL_LOCK_DATA_SHARE,
+  CURL_LOCK_DATA_COOKIE,
+  CURL_LOCK_DATA_DNS,
+  CURL_LOCK_DATA_SSL_SESSION,
+  CURL_LOCK_DATA_CONNECT,
+  CURL_LOCK_DATA_LAST
+} curl_lock_data;
+
+/* Different lock access types */
+typedef enum {
+  CURL_LOCK_ACCESS_NONE = 0,   /* unspecified action */
+  CURL_LOCK_ACCESS_SHARED = 1, /* for read perhaps */
+  CURL_LOCK_ACCESS_SINGLE = 2, /* for write perhaps */
+  CURL_LOCK_ACCESS_LAST        /* never use */
+} curl_lock_access;
+
+typedef void (*curl_lock_function)(CURL *handle,
+                                   curl_lock_data data,
+                                   curl_lock_access locktype,
+                                   void *userptr);
+typedef void (*curl_unlock_function)(CURL *handle,
+                                     curl_lock_data data,
+                                     void *userptr);
+
+
+typedef enum {
+  CURLSHE_OK,  /* all is fine */
+  CURLSHE_BAD_OPTION, /* 1 */
+  CURLSHE_IN_USE,     /* 2 */
+  CURLSHE_INVALID,    /* 3 */
+  CURLSHE_NOMEM,      /* 4 out of memory */
+  CURLSHE_NOT_BUILT_IN, /* 5 feature not present in lib */
+  CURLSHE_LAST        /* never use */
+} CURLSHcode;
+
+typedef enum {
+  CURLSHOPT_NONE,  /* don't use */
+  CURLSHOPT_SHARE,   /* specify a data type to share */
+  CURLSHOPT_UNSHARE, /* specify which data type to stop sharing */
+  CURLSHOPT_LOCKFUNC,   /* pass in a 'curl_lock_function' pointer */
+  CURLSHOPT_UNLOCKFUNC, /* pass in a 'curl_unlock_function' pointer */
+  CURLSHOPT_USERDATA,   /* pass in a user data pointer used in the lock/unlock
+                           callback functions */
+  CURLSHOPT_LAST  /* never use */
+} CURLSHoption;
+
+CURL_EXTERN CURLSH *curl_share_init(void);
+CURL_EXTERN CURLSHcode curl_share_setopt(CURLSH *, CURLSHoption option, ...);
+CURL_EXTERN CURLSHcode curl_share_cleanup(CURLSH *);
+
+/****************************************************************************
+ * Structures for querying information about the curl library at runtime.
+ */
+
+typedef enum {
+  CURLVERSION_FIRST,
+  CURLVERSION_SECOND,
+  CURLVERSION_THIRD,
+  CURLVERSION_FOURTH,
+  CURLVERSION_LAST /* never actually use this */
+} CURLversion;
+
+/* The 'CURLVERSION_NOW' is the symbolic name meant to be used by
+   basically all programs ever that want to get version information. It is
+   meant to be a built-in version number for what kind of struct the caller
+   expects. If the struct ever changes, we redefine the NOW to another enum
+   from above. */
+#define CURLVERSION_NOW CURLVERSION_FOURTH
+
+typedef struct {
+  CURLversion age;          /* age of the returned struct */
+  const char *version;      /* LIBCURL_VERSION */
+  unsigned int version_num; /* LIBCURL_VERSION_NUM */
+  const char *host;         /* OS/host/cpu/machine when configured */
+  int features;             /* bitmask, see defines below */
+  const char *ssl_version;  /* human readable string */
+  long ssl_version_num;     /* not used anymore, always 0 */
+  const char *libz_version; /* human readable string */
+  /* protocols is terminated by an entry with a NULL protoname */
+  const char * const *protocols;
+
+  /* The fields below this were added in CURLVERSION_SECOND */
+  const char *ares;
+  int ares_num;
+
+  /* This field was added in CURLVERSION_THIRD */
+  const char *libidn;
+
+  /* These field were added in CURLVERSION_FOURTH */
+
+  /* Same as '_libiconv_version' if built with HAVE_ICONV */
+  int iconv_ver_num;
+
+  const char *libssh_version; /* human readable string */
+
+} curl_version_info_data;
+
+#define CURL_VERSION_IPV6         (1<<0)  /* IPv6-enabled */
+#define CURL_VERSION_KERBEROS4    (1<<1)  /* Kerberos V4 auth is supported
+                                             (deprecated) */
+#define CURL_VERSION_SSL          (1<<2)  /* SSL options are present */
+#define CURL_VERSION_LIBZ         (1<<3)  /* libz features are present */
+#define CURL_VERSION_NTLM         (1<<4)  /* NTLM auth is supported */
+#define CURL_VERSION_GSSNEGOTIATE (1<<5)  /* Negotiate auth is supported
+                                             (deprecated) */
+#define CURL_VERSION_DEBUG        (1<<6)  /* Built with debug capabilities */
+#define CURL_VERSION_ASYNCHDNS    (1<<7)  /* Asynchronous DNS resolves */
+#define CURL_VERSION_SPNEGO       (1<<8)  /* SPNEGO auth is supported */
+#define CURL_VERSION_LARGEFILE    (1<<9)  /* Supports files larger than 2GB */
+#define CURL_VERSION_IDN          (1<<10) /* Internationized Domain Names are
+                                             supported */
+#define CURL_VERSION_SSPI         (1<<11) /* Built against Windows SSPI */
+#define CURL_VERSION_CONV         (1<<12) /* Character conversions supported */
+#define CURL_VERSION_CURLDEBUG    (1<<13) /* Debug memory tracking supported */
+#define CURL_VERSION_TLSAUTH_SRP  (1<<14) /* TLS-SRP auth is supported */
+#define CURL_VERSION_NTLM_WB      (1<<15) /* NTLM delegation to winbind helper
+                                             is supported */
+#define CURL_VERSION_HTTP2        (1<<16) /* HTTP2 support built-in */
+#define CURL_VERSION_GSSAPI       (1<<17) /* Built against a GSS-API library */
+#define CURL_VERSION_KERBEROS5    (1<<18) /* Kerberos V5 auth is supported */
+#define CURL_VERSION_UNIX_SOCKETS (1<<19) /* Unix domain sockets support */
+#define CURL_VERSION_PSL          (1<<20) /* Mozilla's Public Suffix List, used
+                                             for cookie domain verification */
+#define CURL_VERSION_HTTPS_PROXY  (1<<21) /* HTTPS-proxy support built-in */
+
+ /*
+ * NAME curl_version_info()
+ *
+ * DESCRIPTION
+ *
+ * This function returns a pointer to a static copy of the version info
+ * struct. See above.
+ */
+CURL_EXTERN curl_version_info_data *curl_version_info(CURLversion);
+
+/*
+ * NAME curl_easy_strerror()
+ *
+ * DESCRIPTION
+ *
+ * The curl_easy_strerror function may be used to turn a CURLcode value
+ * into the equivalent human readable error string.  This is useful
+ * for printing meaningful error messages.
+ */
+CURL_EXTERN const char *curl_easy_strerror(CURLcode);
+
+/*
+ * NAME curl_share_strerror()
+ *
+ * DESCRIPTION
+ *
+ * The curl_share_strerror function may be used to turn a CURLSHcode value
+ * into the equivalent human readable error string.  This is useful
+ * for printing meaningful error messages.
+ */
+CURL_EXTERN const char *curl_share_strerror(CURLSHcode);
+
+/*
+ * NAME curl_easy_pause()
+ *
+ * DESCRIPTION
+ *
+ * The curl_easy_pause function pauses or unpauses transfers. Select the new
+ * state by setting the bitmask, use the convenience defines below.
+ *
+ */
+CURL_EXTERN CURLcode curl_easy_pause(CURL *handle, int bitmask);
+
+#define CURLPAUSE_RECV      (1<<0)
+#define CURLPAUSE_RECV_CONT (0)
+
+#define CURLPAUSE_SEND      (1<<2)
+#define CURLPAUSE_SEND_CONT (0)
+
+#define CURLPAUSE_ALL       (CURLPAUSE_RECV|CURLPAUSE_SEND)
+#define CURLPAUSE_CONT      (CURLPAUSE_RECV_CONT|CURLPAUSE_SEND_CONT)
+
+#ifdef  __cplusplus
+}
+#endif
+
+/* unfortunately, the easy.h and multi.h include files need options and info
+  stuff before they can be included! */
+#include "easy.h" /* nothing in curl is fun without the easy stuff */
+#include "multi.h"
+
+/* the typechecker doesn't work in C++ (yet) */
+#if defined(__GNUC__) && defined(__GNUC_MINOR__) && \
+    ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) && \
+    !defined(__cplusplus) && !defined(CURL_DISABLE_TYPECHECK)
+#include "typecheck-gcc.h"
+#else
+#if defined(__STDC__) && (__STDC__ >= 1)
+/* This preprocessor magic that replaces a call with the exact same call is
+   only done to make sure application authors pass exactly three arguments
+   to these functions. */
+#define curl_easy_setopt(handle,opt,param) curl_easy_setopt(handle,opt,param)
+#define curl_easy_getinfo(handle,info,arg) curl_easy_getinfo(handle,info,arg)
+#define curl_share_setopt(share,opt,param) curl_share_setopt(share,opt,param)
+#define curl_multi_setopt(handle,opt,param) curl_multi_setopt(handle,opt,param)
+#endif /* __STDC__ >= 1 */
+#endif /* gcc >= 4.3 && !__cplusplus */
+
+#endif /* __CURL_CURL_H */
diff --git a/src/include/curl/curlbuild.h b/src/include/curl/curlbuild.h
new file mode 100644
index 0000000..ae95095
--- /dev/null
+++ b/src/include/curl/curlbuild.h
@@ -0,0 +1,586 @@
+#ifndef __CURL_CURLBUILD_H
+#define __CURL_CURLBUILD_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2016, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at https://curl.haxx.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ***************************************************************************/
+
+/* ================================================================ */
+/*               NOTES FOR CONFIGURE CAPABLE SYSTEMS                */
+/* ================================================================ */
+
+/*
+ * NOTE 1:
+ * -------
+ *
+ * See file include/curl/curlbuild.h.in, run configure, and forget
+ * that this file exists it is only used for non-configure systems.
+ * But you can keep reading if you want ;-)
+ *
+ */
+
+/* ================================================================ */
+/*                 NOTES FOR NON-CONFIGURE SYSTEMS                  */
+/* ================================================================ */
+
+/*
+ * NOTE 1:
+ * -------
+ *
+ * Nothing in this file is intended to be modified or adjusted by the
+ * curl library user nor by the curl library builder.
+ *
+ * If you think that something actually needs to be changed, adjusted
+ * or fixed in this file, then, report it on the libcurl development
+ * mailing list: https://cool.haxx.se/mailman/listinfo/curl-library/
+ *
+ * Try to keep one section per platform, compiler and architecture,
+ * otherwise, if an existing section is reused for a different one and
+ * later on the original is adjusted, probably the piggybacking one can
+ * be adversely changed.
+ *
+ * In order to differentiate between platforms/compilers/architectures
+ * use only compiler built in predefined preprocessor symbols.
+ *
+ * This header file shall only export symbols which are 'curl' or 'CURL'
+ * prefixed, otherwise public name space would be polluted.
+ *
+ * NOTE 2:
+ * -------
+ *
+ * For any given platform/compiler curl_off_t must be typedef'ed to a
+ * 64-bit wide signed integral data type. The width of this data type
+ * must remain constant and independent of any possible large file
+ * support settings.
+ *
+ * As an exception to the above, curl_off_t shall be typedef'ed to a
+ * 32-bit wide signed integral data type if there is no 64-bit type.
+ *
+ * As a general rule, curl_off_t shall not be mapped to off_t. This
+ * rule shall only be violated if off_t is the only 64-bit data type
+ * available and the size of off_t is independent of large file support
+ * settings. Keep your build on the safe side avoiding an off_t gating.
+ * If you have a 64-bit off_t then take for sure that another 64-bit
+ * data type exists, dig deeper and you will find it.
+ *
+ * NOTE 3:
+ * -------
+ *
+ * Right now you might be staring at file include/curl/curlbuild.h.dist or
+ * at file include/curl/curlbuild.h, this is due to the following reason:
+ * file include/curl/curlbuild.h.dist is renamed to include/curl/curlbuild.h
+ * when the libcurl source code distribution archive file is created.
+ *
+ * File include/curl/curlbuild.h.dist is not included in the distribution
+ * archive. File include/curl/curlbuild.h is not present in the git tree.
+ *
+ * The distributed include/curl/curlbuild.h file is only intended to be used
+ * on systems which can not run the also distributed configure script.
+ *
+ * On systems capable of running the configure script, the configure process
+ * will overwrite the distributed include/curl/curlbuild.h file with one that
+ * is suitable and specific to the library being configured and built, which
+ * is generated from the include/curl/curlbuild.h.in template file.
+ *
+ * If you check out from git on a non-configure platform, you must run the
+ * appropriate buildconf* script to set up curlbuild.h and other local files.
+ *
+ */
+
+/* ================================================================ */
+/*  DEFINITION OF THESE SYMBOLS SHALL NOT TAKE PLACE ANYWHERE ELSE  */
+/* ================================================================ */
+
+#ifdef CURL_SIZEOF_LONG
+#  error "CURL_SIZEOF_LONG shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_SIZEOF_LONG_already_defined
+#endif
+
+#ifdef CURL_TYPEOF_CURL_SOCKLEN_T
+#  error "CURL_TYPEOF_CURL_SOCKLEN_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_TYPEOF_CURL_SOCKLEN_T_already_defined
+#endif
+
+#ifdef CURL_SIZEOF_CURL_SOCKLEN_T
+#  error "CURL_SIZEOF_CURL_SOCKLEN_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_SIZEOF_CURL_SOCKLEN_T_already_defined
+#endif
+
+#ifdef CURL_TYPEOF_CURL_OFF_T
+#  error "CURL_TYPEOF_CURL_OFF_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_TYPEOF_CURL_OFF_T_already_defined
+#endif
+
+#ifdef CURL_FORMAT_CURL_OFF_T
+#  error "CURL_FORMAT_CURL_OFF_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_FORMAT_CURL_OFF_T_already_defined
+#endif
+
+#ifdef CURL_FORMAT_CURL_OFF_TU
+#  error "CURL_FORMAT_CURL_OFF_TU shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_FORMAT_CURL_OFF_TU_already_defined
+#endif
+
+#ifdef CURL_FORMAT_OFF_T
+#  error "CURL_FORMAT_OFF_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_FORMAT_OFF_T_already_defined
+#endif
+
+#ifdef CURL_SIZEOF_CURL_OFF_T
+#  error "CURL_SIZEOF_CURL_OFF_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_SIZEOF_CURL_OFF_T_already_defined
+#endif
+
+#ifdef CURL_SUFFIX_CURL_OFF_T
+#  error "CURL_SUFFIX_CURL_OFF_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_T_already_defined
+#endif
+
+#ifdef CURL_SUFFIX_CURL_OFF_TU
+#  error "CURL_SUFFIX_CURL_OFF_TU shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_TU_already_defined
+#endif
+
+/* ================================================================ */
+/*    EXTERNAL INTERFACE SETTINGS FOR NON-CONFIGURE SYSTEMS ONLY    */
+/* ================================================================ */
+
+#if defined(__DJGPP__) || defined(__GO32__)
+#  if defined(__DJGPP__) && (__DJGPP__ > 1)
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     long long
+#    define CURL_FORMAT_CURL_OFF_T     "lld"
+#    define CURL_FORMAT_CURL_OFF_TU    "llu"
+#    define CURL_FORMAT_OFF_T          "%lld"
+#    define CURL_SIZEOF_CURL_OFF_T     8
+#    define CURL_SUFFIX_CURL_OFF_T     LL
+#    define CURL_SUFFIX_CURL_OFF_TU    ULL
+#  else
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     long
+#    define CURL_FORMAT_CURL_OFF_T     "ld"
+#    define CURL_FORMAT_CURL_OFF_TU    "lu"
+#    define CURL_FORMAT_OFF_T          "%ld"
+#    define CURL_SIZEOF_CURL_OFF_T     4
+#    define CURL_SUFFIX_CURL_OFF_T     L
+#    define CURL_SUFFIX_CURL_OFF_TU    UL
+#  endif
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
+
+#elif defined(__SALFORDC__)
+#  define CURL_SIZEOF_LONG           4
+#  define CURL_TYPEOF_CURL_OFF_T     long
+#  define CURL_FORMAT_CURL_OFF_T     "ld"
+#  define CURL_FORMAT_CURL_OFF_TU    "lu"
+#  define CURL_FORMAT_OFF_T          "%ld"
+#  define CURL_SIZEOF_CURL_OFF_T     4
+#  define CURL_SUFFIX_CURL_OFF_T     L
+#  define CURL_SUFFIX_CURL_OFF_TU    UL
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
+
+#elif defined(__BORLANDC__)
+#  if (__BORLANDC__ < 0x520)
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     long
+#    define CURL_FORMAT_CURL_OFF_T     "ld"
+#    define CURL_FORMAT_CURL_OFF_TU    "lu"
+#    define CURL_FORMAT_OFF_T          "%ld"
+#    define CURL_SIZEOF_CURL_OFF_T     4
+#    define CURL_SUFFIX_CURL_OFF_T     L
+#    define CURL_SUFFIX_CURL_OFF_TU    UL
+#  else
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     __int64
+#    define CURL_FORMAT_CURL_OFF_T     "I64d"
+#    define CURL_FORMAT_CURL_OFF_TU    "I64u"
+#    define CURL_FORMAT_OFF_T          "%I64d"
+#    define CURL_SIZEOF_CURL_OFF_T     8
+#    define CURL_SUFFIX_CURL_OFF_T     i64
+#    define CURL_SUFFIX_CURL_OFF_TU    ui64
+#  endif
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
+
+#elif defined(__TURBOC__)
+#  define CURL_SIZEOF_LONG           4
+#  define CURL_TYPEOF_CURL_OFF_T     long
+#  define CURL_FORMAT_CURL_OFF_T     "ld"
+#  define CURL_FORMAT_CURL_OFF_TU    "lu"
+#  define CURL_FORMAT_OFF_T          "%ld"
+#  define CURL_SIZEOF_CURL_OFF_T     4
+#  define CURL_SUFFIX_CURL_OFF_T     L
+#  define CURL_SUFFIX_CURL_OFF_TU    UL
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
+
+#elif defined(__WATCOMC__)
+#  if defined(__386__)
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     __int64
+#    define CURL_FORMAT_CURL_OFF_T     "I64d"
+#    define CURL_FORMAT_CURL_OFF_TU    "I64u"
+#    define CURL_FORMAT_OFF_T          "%I64d"
+#    define CURL_SIZEOF_CURL_OFF_T     8
+#    define CURL_SUFFIX_CURL_OFF_T     i64
+#    define CURL_SUFFIX_CURL_OFF_TU    ui64
+#  else
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     long
+#    define CURL_FORMAT_CURL_OFF_T     "ld"
+#    define CURL_FORMAT_CURL_OFF_TU    "lu"
+#    define CURL_FORMAT_OFF_T          "%ld"
+#    define CURL_SIZEOF_CURL_OFF_T     4
+#    define CURL_SUFFIX_CURL_OFF_T     L
+#    define CURL_SUFFIX_CURL_OFF_TU    UL
+#  endif
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
+
+#elif defined(__POCC__)
+#  if (__POCC__ < 280)
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     long
+#    define CURL_FORMAT_CURL_OFF_T     "ld"
+#    define CURL_FORMAT_CURL_OFF_TU    "lu"
+#    define CURL_FORMAT_OFF_T          "%ld"
+#    define CURL_SIZEOF_CURL_OFF_T     4
+#    define CURL_SUFFIX_CURL_OFF_T     L
+#    define CURL_SUFFIX_CURL_OFF_TU    UL
+#  elif defined(_MSC_VER)
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     __int64
+#    define CURL_FORMAT_CURL_OFF_T     "I64d"
+#    define CURL_FORMAT_CURL_OFF_TU    "I64u"
+#    define CURL_FORMAT_OFF_T          "%I64d"
+#    define CURL_SIZEOF_CURL_OFF_T     8
+#    define CURL_SUFFIX_CURL_OFF_T     i64
+#    define CURL_SUFFIX_CURL_OFF_TU    ui64
+#  else
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     long long
+#    define CURL_FORMAT_CURL_OFF_T     "lld"
+#    define CURL_FORMAT_CURL_OFF_TU    "llu"
+#    define CURL_FORMAT_OFF_T          "%lld"
+#    define CURL_SIZEOF_CURL_OFF_T     8
+#    define CURL_SUFFIX_CURL_OFF_T     LL
+#    define CURL_SUFFIX_CURL_OFF_TU    ULL
+#  endif
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
+
+#elif defined(__LCC__)
+#  define CURL_SIZEOF_LONG           4
+#  define CURL_TYPEOF_CURL_OFF_T     long
+#  define CURL_FORMAT_CURL_OFF_T     "ld"
+#  define CURL_FORMAT_CURL_OFF_TU    "lu"
+#  define CURL_FORMAT_OFF_T          "%ld"
+#  define CURL_SIZEOF_CURL_OFF_T     4
+#  define CURL_SUFFIX_CURL_OFF_T     L
+#  define CURL_SUFFIX_CURL_OFF_TU    UL
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
+
+#elif defined(__SYMBIAN32__)
+#  if defined(__EABI__)  /* Treat all ARM compilers equally */
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     long long
+#    define CURL_FORMAT_CURL_OFF_T     "lld"
+#    define CURL_FORMAT_CURL_OFF_TU    "llu"
+#    define CURL_FORMAT_OFF_T          "%lld"
+#    define CURL_SIZEOF_CURL_OFF_T     8
+#    define CURL_SUFFIX_CURL_OFF_T     LL
+#    define CURL_SUFFIX_CURL_OFF_TU    ULL
+#  elif defined(__CW32__)
+#    pragma longlong on
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     long long
+#    define CURL_FORMAT_CURL_OFF_T     "lld"
+#    define CURL_FORMAT_CURL_OFF_TU    "llu"
+#    define CURL_FORMAT_OFF_T          "%lld"
+#    define CURL_SIZEOF_CURL_OFF_T     8
+#    define CURL_SUFFIX_CURL_OFF_T     LL
+#    define CURL_SUFFIX_CURL_OFF_TU    ULL
+#  elif defined(__VC32__)
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     __int64
+#    define CURL_FORMAT_CURL_OFF_T     "lld"
+#    define CURL_FORMAT_CURL_OFF_TU    "llu"
+#    define CURL_FORMAT_OFF_T          "%lld"
+#    define CURL_SIZEOF_CURL_OFF_T     8
+#    define CURL_SUFFIX_CURL_OFF_T     LL
+#    define CURL_SUFFIX_CURL_OFF_TU    ULL
+#  endif
+#  define CURL_TYPEOF_CURL_SOCKLEN_T unsigned int
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
+
+#elif defined(__MWERKS__)
+#  define CURL_SIZEOF_LONG           4
+#  define CURL_TYPEOF_CURL_OFF_T     long long
+#  define CURL_FORMAT_CURL_OFF_T     "lld"
+#  define CURL_FORMAT_CURL_OFF_TU    "llu"
+#  define CURL_FORMAT_OFF_T          "%lld"
+#  define CURL_SIZEOF_CURL_OFF_T     8
+#  define CURL_SUFFIX_CURL_OFF_T     LL
+#  define CURL_SUFFIX_CURL_OFF_TU    ULL
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
+
+#elif defined(_WIN32_WCE)
+#  define CURL_SIZEOF_LONG           4
+#  define CURL_TYPEOF_CURL_OFF_T     __int64
+#  define CURL_FORMAT_CURL_OFF_T     "I64d"
+#  define CURL_FORMAT_CURL_OFF_TU    "I64u"
+#  define CURL_FORMAT_OFF_T          "%I64d"
+#  define CURL_SIZEOF_CURL_OFF_T     8
+#  define CURL_SUFFIX_CURL_OFF_T     i64
+#  define CURL_SUFFIX_CURL_OFF_TU    ui64
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
+
+#elif defined(__MINGW32__)
+#  define CURL_SIZEOF_LONG           4
+#  define CURL_TYPEOF_CURL_OFF_T     long long
+#  define CURL_FORMAT_CURL_OFF_T     "I64d"
+#  define CURL_FORMAT_CURL_OFF_TU    "I64u"
+#  define CURL_FORMAT_OFF_T          "%I64d"
+#  define CURL_SIZEOF_CURL_OFF_T     8
+#  define CURL_SUFFIX_CURL_OFF_T     LL
+#  define CURL_SUFFIX_CURL_OFF_TU    ULL
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
+
+#elif defined(__VMS)
+#  if defined(__VAX)
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     long
+#    define CURL_FORMAT_CURL_OFF_T     "ld"
+#    define CURL_FORMAT_CURL_OFF_TU    "lu"
+#    define CURL_FORMAT_OFF_T          "%ld"
+#    define CURL_SIZEOF_CURL_OFF_T     4
+#    define CURL_SUFFIX_CURL_OFF_T     L
+#    define CURL_SUFFIX_CURL_OFF_TU    UL
+#  else
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     long long
+#    define CURL_FORMAT_CURL_OFF_T     "lld"
+#    define CURL_FORMAT_CURL_OFF_TU    "llu"
+#    define CURL_FORMAT_OFF_T          "%lld"
+#    define CURL_SIZEOF_CURL_OFF_T     8
+#    define CURL_SUFFIX_CURL_OFF_T     LL
+#    define CURL_SUFFIX_CURL_OFF_TU    ULL
+#  endif
+#  define CURL_TYPEOF_CURL_SOCKLEN_T unsigned int
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
+
+#elif defined(__OS400__)
+#  if defined(__ILEC400__)
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     long long
+#    define CURL_FORMAT_CURL_OFF_T     "lld"
+#    define CURL_FORMAT_CURL_OFF_TU    "llu"
+#    define CURL_FORMAT_OFF_T          "%lld"
+#    define CURL_SIZEOF_CURL_OFF_T     8
+#    define CURL_SUFFIX_CURL_OFF_T     LL
+#    define CURL_SUFFIX_CURL_OFF_TU    ULL
+#    define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t
+#    define CURL_SIZEOF_CURL_SOCKLEN_T 4
+#    define CURL_PULL_SYS_TYPES_H      1
+#    define CURL_PULL_SYS_SOCKET_H     1
+#  endif
+
+#elif defined(__MVS__)
+#  if defined(__IBMC__) || defined(__IBMCPP__)
+#    if defined(_ILP32)
+#      define CURL_SIZEOF_LONG           4
+#    elif defined(_LP64)
+#      define CURL_SIZEOF_LONG           8
+#    endif
+#    if defined(_LONG_LONG)
+#      define CURL_TYPEOF_CURL_OFF_T     long long
+#      define CURL_FORMAT_CURL_OFF_T     "lld"
+#      define CURL_FORMAT_CURL_OFF_TU    "llu"
+#      define CURL_FORMAT_OFF_T          "%lld"
+#      define CURL_SIZEOF_CURL_OFF_T     8
+#      define CURL_SUFFIX_CURL_OFF_T     LL
+#      define CURL_SUFFIX_CURL_OFF_TU    ULL
+#    elif defined(_LP64)
+#      define CURL_TYPEOF_CURL_OFF_T     long
+#      define CURL_FORMAT_CURL_OFF_T     "ld"
+#      define CURL_FORMAT_CURL_OFF_TU    "lu"
+#      define CURL_FORMAT_OFF_T          "%ld"
+#      define CURL_SIZEOF_CURL_OFF_T     8
+#      define CURL_SUFFIX_CURL_OFF_T     L
+#      define CURL_SUFFIX_CURL_OFF_TU    UL
+#    else
+#      define CURL_TYPEOF_CURL_OFF_T     long
+#      define CURL_FORMAT_CURL_OFF_T     "ld"
+#      define CURL_FORMAT_CURL_OFF_TU    "lu"
+#      define CURL_FORMAT_OFF_T          "%ld"
+#      define CURL_SIZEOF_CURL_OFF_T     4
+#      define CURL_SUFFIX_CURL_OFF_T     L
+#      define CURL_SUFFIX_CURL_OFF_TU    UL
+#    endif
+#    define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t
+#    define CURL_SIZEOF_CURL_SOCKLEN_T 4
+#    define CURL_PULL_SYS_TYPES_H      1
+#    define CURL_PULL_SYS_SOCKET_H     1
+#  endif
+
+#elif defined(__370__)
+#  if defined(__IBMC__) || defined(__IBMCPP__)
+#    if defined(_ILP32)
+#      define CURL_SIZEOF_LONG           4
+#    elif defined(_LP64)
+#      define CURL_SIZEOF_LONG           8
+#    endif
+#    if defined(_LONG_LONG)
+#      define CURL_TYPEOF_CURL_OFF_T     long long
+#      define CURL_FORMAT_CURL_OFF_T     "lld"
+#      define CURL_FORMAT_CURL_OFF_TU    "llu"
+#      define CURL_FORMAT_OFF_T          "%lld"
+#      define CURL_SIZEOF_CURL_OFF_T     8
+#      define CURL_SUFFIX_CURL_OFF_T     LL
+#      define CURL_SUFFIX_CURL_OFF_TU    ULL
+#    elif defined(_LP64)
+#      define CURL_TYPEOF_CURL_OFF_T     long
+#      define CURL_FORMAT_CURL_OFF_T     "ld"
+#      define CURL_FORMAT_CURL_OFF_TU    "lu"
+#      define CURL_FORMAT_OFF_T          "%ld"
+#      define CURL_SIZEOF_CURL_OFF_T     8
+#      define CURL_SUFFIX_CURL_OFF_T     L
+#      define CURL_SUFFIX_CURL_OFF_TU    UL
+#    else
+#      define CURL_TYPEOF_CURL_OFF_T     long
+#      define CURL_FORMAT_CURL_OFF_T     "ld"
+#      define CURL_FORMAT_CURL_OFF_TU    "lu"
+#      define CURL_FORMAT_OFF_T          "%ld"
+#      define CURL_SIZEOF_CURL_OFF_T     4
+#      define CURL_SUFFIX_CURL_OFF_T     L
+#      define CURL_SUFFIX_CURL_OFF_TU    UL
+#    endif
+#    define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t
+#    define CURL_SIZEOF_CURL_SOCKLEN_T 4
+#    define CURL_PULL_SYS_TYPES_H      1
+#    define CURL_PULL_SYS_SOCKET_H     1
+#  endif
+
+#elif defined(TPF)
+#  define CURL_SIZEOF_LONG           8
+#  define CURL_TYPEOF_CURL_OFF_T     long
+#  define CURL_FORMAT_CURL_OFF_T     "ld"
+#  define CURL_FORMAT_CURL_OFF_TU    "lu"
+#  define CURL_FORMAT_OFF_T          "%ld"
+#  define CURL_SIZEOF_CURL_OFF_T     8
+#  define CURL_SUFFIX_CURL_OFF_T     L
+#  define CURL_SUFFIX_CURL_OFF_TU    UL
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
+
+/* ===================================== */
+/*    KEEP MSVC THE PENULTIMATE ENTRY    */
+/* ===================================== */
+
+#elif defined(_MSC_VER)
+#  if (_MSC_VER >= 900) && (_INTEGRAL_MAX_BITS >= 64)
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     __int64
+#    define CURL_FORMAT_CURL_OFF_T     "I64d"
+#    define CURL_FORMAT_CURL_OFF_TU    "I64u"
+#    define CURL_FORMAT_OFF_T          "%I64d"
+#    define CURL_SIZEOF_CURL_OFF_T     8
+#    define CURL_SUFFIX_CURL_OFF_T     i64
+#    define CURL_SUFFIX_CURL_OFF_TU    ui64
+#  else
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     long
+#    define CURL_FORMAT_CURL_OFF_T     "ld"
+#    define CURL_FORMAT_CURL_OFF_TU    "lu"
+#    define CURL_FORMAT_OFF_T          "%ld"
+#    define CURL_SIZEOF_CURL_OFF_T     4
+#    define CURL_SUFFIX_CURL_OFF_T     L
+#    define CURL_SUFFIX_CURL_OFF_TU    UL
+#  endif
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
+
+/* ===================================== */
+/*    KEEP GENERIC GCC THE LAST ENTRY    */
+/* ===================================== */
+
+#elif defined(__GNUC__)
+#  if !defined(__LP64__) && (defined(__ILP32__) || \
+      defined(__i386__) || defined(__ppc__) || defined(__arm__) || \
+      defined(__sparc__) || defined(__mips__) || defined(__sh__))
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     long long
+#    define CURL_FORMAT_CURL_OFF_T     "lld"
+#    define CURL_FORMAT_CURL_OFF_TU    "llu"
+#    define CURL_FORMAT_OFF_T          "%lld"
+#    define CURL_SIZEOF_CURL_OFF_T     8
+#    define CURL_SUFFIX_CURL_OFF_T     LL
+#    define CURL_SUFFIX_CURL_OFF_TU    ULL
+#  elif defined(__LP64__) || \
+        defined(__x86_64__) || defined(__ppc64__) || defined(__sparc64__)
+#    define CURL_SIZEOF_LONG           8
+#    define CURL_TYPEOF_CURL_OFF_T     long
+#    define CURL_FORMAT_CURL_OFF_T     "ld"
+#    define CURL_FORMAT_CURL_OFF_TU    "lu"
+#    define CURL_FORMAT_OFF_T          "%ld"
+#    define CURL_SIZEOF_CURL_OFF_T     8
+#    define CURL_SUFFIX_CURL_OFF_T     L
+#    define CURL_SUFFIX_CURL_OFF_TU    UL
+#  endif
+#  define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
+#  define CURL_PULL_SYS_TYPES_H      1
+#  define CURL_PULL_SYS_SOCKET_H     1
+
+#else
+#  error "Unknown non-configure build target!"
+   Error Compilation_aborted_Unknown_non_configure_build_target
+#endif
+
+/* CURL_PULL_SYS_TYPES_H is defined above when inclusion of header file  */
+/* sys/types.h is required here to properly make type definitions below. */
+#ifdef CURL_PULL_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+
+/* CURL_PULL_SYS_SOCKET_H is defined above when inclusion of header file  */
+/* sys/socket.h is required here to properly make type definitions below. */
+#ifdef CURL_PULL_SYS_SOCKET_H
+#  include <sys/socket.h>
+#endif
+
+/* Data type definition of curl_socklen_t. */
+
+#ifdef CURL_TYPEOF_CURL_SOCKLEN_T
+  typedef CURL_TYPEOF_CURL_SOCKLEN_T curl_socklen_t;
+#endif
+
+/* Data type definition of curl_off_t. */
+
+#ifdef CURL_TYPEOF_CURL_OFF_T
+  typedef CURL_TYPEOF_CURL_OFF_T curl_off_t;
+#endif
+
+#endif /* __CURL_CURLBUILD_H */
diff --git a/src/include/curl/curlrules.h b/src/include/curl/curlrules.h
new file mode 100644
index 0000000..0abd9f7
--- /dev/null
+++ b/src/include/curl/curlrules.h
@@ -0,0 +1,239 @@
+#ifndef __CURL_CURLRULES_H
+#define __CURL_CURLRULES_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2017, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at https://curl.haxx.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ***************************************************************************/
+
+/* ================================================================ */
+/*                    COMPILE TIME SANITY CHECKS                    */
+/* ================================================================ */
+
+/*
+ * NOTE 1:
+ * -------
+ *
+ * All checks done in this file are intentionally placed in a public
+ * header file which is pulled by curl/curl.h when an application is
+ * being built using an already built libcurl library. Additionally
+ * this file is also included and used when building the library.
+ *
+ * If compilation fails on this file it is certainly sure that the
+ * problem is elsewhere. It could be a problem in the curlbuild.h
+ * header file, or simply that you are using different compilation
+ * settings than those used to build the library.
+ *
+ * Nothing in this file is intended to be modified or adjusted by the
+ * curl library user nor by the curl library builder.
+ *
+ * Do not deactivate any check, these are done to make sure that the
+ * library is properly built and used.
+ *
+ * You can find further help on the libcurl development mailing list:
+ * https://cool.haxx.se/mailman/listinfo/curl-library/
+ *
+ * NOTE 2
+ * ------
+ *
+ * Some of the following compile time checks are based on the fact
+ * that the dimension of a constant array can not be a negative one.
+ * In this way if the compile time verification fails, the compilation
+ * will fail issuing an error. The error description wording is compiler
+ * dependent but it will be quite similar to one of the following:
+ *
+ *   "negative subscript or subscript is too large"
+ *   "array must have at least one element"
+ *   "-1 is an illegal array size"
+ *   "size of array is negative"
+ *
+ * If you are building an application which tries to use an already
+ * built libcurl library and you are getting this kind of errors on
+ * this file, it is a clear indication that there is a mismatch between
+ * how the library was built and how you are trying to use it for your
+ * application. Your already compiled or binary library provider is the
+ * only one who can give you the details you need to properly use it.
+ */
+
+/*
+ * Verify that some macros are actually defined.
+ */
+
+#ifndef CURL_SIZEOF_LONG
+#  error "CURL_SIZEOF_LONG definition is missing!"
+   Error Compilation_aborted_CURL_SIZEOF_LONG_is_missing
+#endif
+
+#ifndef CURL_TYPEOF_CURL_SOCKLEN_T
+#  error "CURL_TYPEOF_CURL_SOCKLEN_T definition is missing!"
+   Error Compilation_aborted_CURL_TYPEOF_CURL_SOCKLEN_T_is_missing
+#endif
+
+#ifndef CURL_SIZEOF_CURL_SOCKLEN_T
+#  error "CURL_SIZEOF_CURL_SOCKLEN_T definition is missing!"
+   Error Compilation_aborted_CURL_SIZEOF_CURL_SOCKLEN_T_is_missing
+#endif
+
+#ifndef CURL_TYPEOF_CURL_OFF_T
+#  error "CURL_TYPEOF_CURL_OFF_T definition is missing!"
+   Error Compilation_aborted_CURL_TYPEOF_CURL_OFF_T_is_missing
+#endif
+
+#ifndef CURL_FORMAT_CURL_OFF_T
+#  error "CURL_FORMAT_CURL_OFF_T definition is missing!"
+   Error Compilation_aborted_CURL_FORMAT_CURL_OFF_T_is_missing
+#endif
+
+#ifndef CURL_FORMAT_CURL_OFF_TU
+#  error "CURL_FORMAT_CURL_OFF_TU definition is missing!"
+   Error Compilation_aborted_CURL_FORMAT_CURL_OFF_TU_is_missing
+#endif
+
+#ifndef CURL_SIZEOF_CURL_OFF_T
+#  error "CURL_SIZEOF_CURL_OFF_T definition is missing!"
+   Error Compilation_aborted_CURL_SIZEOF_CURL_OFF_T_is_missing
+#endif
+
+#ifndef CURL_SUFFIX_CURL_OFF_T
+#  error "CURL_SUFFIX_CURL_OFF_T definition is missing!"
+   Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_T_is_missing
+#endif
+
+#ifndef CURL_SUFFIX_CURL_OFF_TU
+#  error "CURL_SUFFIX_CURL_OFF_TU definition is missing!"
+   Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_TU_is_missing
+#endif
+
+/*
+ * Macros private to this header file.
+ */
+
+#define CurlchkszEQ(t, s) sizeof(t) == s ? 1 : -1
+
+#define CurlchkszGE(t1, t2) sizeof(t1) >= sizeof(t2) ? 1 : -1
+
+/*
+ * Verify that the size previously defined and expected for long
+ * is the same as the one reported by sizeof() at compile time.
+ */
+
+typedef char
+  __curl_rule_01__
+    [CurlchkszEQ(long, CURL_SIZEOF_LONG)];
+
+/*
+ * Verify that the size previously defined and expected for
+ * curl_off_t is actually the the same as the one reported
+ * by sizeof() at compile time.
+ */
+
+typedef char
+  __curl_rule_02__
+    [CurlchkszEQ(curl_off_t, CURL_SIZEOF_CURL_OFF_T)];
+
+/*
+ * Verify at compile time that the size of curl_off_t as reported
+ * by sizeof() is greater or equal than the one reported for long
+ * for the current compilation.
+ */
+
+typedef char
+  __curl_rule_03__
+    [CurlchkszGE(curl_off_t, long)];
+
+/*
+ * Verify that the size previously defined and expected for
+ * curl_socklen_t is actually the the same as the one reported
+ * by sizeof() at compile time.
+ */
+
+typedef char
+  __curl_rule_04__
+    [CurlchkszEQ(curl_socklen_t, CURL_SIZEOF_CURL_SOCKLEN_T)];
+
+/*
+ * Verify at compile time that the size of curl_socklen_t as reported
+ * by sizeof() is greater or equal than the one reported for int for
+ * the current compilation.
+ */
+
+typedef char
+  __curl_rule_05__
+    [CurlchkszGE(curl_socklen_t, int)];
+
+/* ================================================================ */
+/*          EXTERNALLY AND INTERNALLY VISIBLE DEFINITIONS           */
+/* ================================================================ */
+
+/*
+ * CURL_ISOCPP and CURL_OFF_T_C definitions are done here in order to allow
+ * these to be visible and exported by the external libcurl interface API,
+ * while also making them visible to the library internals, simply including
+ * curl_setup.h, without actually needing to include curl.h internally.
+ * If some day this section would grow big enough, all this should be moved
+ * to its own header file.
+ */
+
+/*
+ * Figure out if we can use the ## preprocessor operator, which is supported
+ * by ISO/ANSI C and C++. Some compilers support it without setting __STDC__
+ * or  __cplusplus so we need to carefully check for them too.
+ */
+
+#if defined(__STDC__) || defined(_MSC_VER) || defined(__cplusplus) || \
+  defined(__HP_aCC) || defined(__BORLANDC__) || defined(__LCC__) || \
+  defined(__POCC__) || defined(__SALFORDC__) || defined(__HIGHC__) || \
+  defined(__ILEC400__)
+  /* This compiler is believed to have an ISO compatible preprocessor */
+#define CURL_ISOCPP
+#else
+  /* This compiler is believed NOT to have an ISO compatible preprocessor */
+#undef CURL_ISOCPP
+#endif
+
+/*
+ * Macros for minimum-width signed and unsigned curl_off_t integer constants.
+ */
+
+#if defined(__BORLANDC__) && (__BORLANDC__ == 0x0551)
+#  define __CURL_OFF_T_C_HLPR2(x) x
+#  define __CURL_OFF_T_C_HLPR1(x) __CURL_OFF_T_C_HLPR2(x)
+#  define CURL_OFF_T_C(Val)  __CURL_OFF_T_C_HLPR1(Val) ## \
+                             __CURL_OFF_T_C_HLPR1(CURL_SUFFIX_CURL_OFF_T)
+#  define CURL_OFF_TU_C(Val) __CURL_OFF_T_C_HLPR1(Val) ## \
+                             __CURL_OFF_T_C_HLPR1(CURL_SUFFIX_CURL_OFF_TU)
+#else
+#  ifdef CURL_ISOCPP
+#    define __CURL_OFF_T_C_HLPR2(Val,Suffix) Val ## Suffix
+#  else
+#    define __CURL_OFF_T_C_HLPR2(Val,Suffix) Val/**/Suffix
+#  endif
+#  define __CURL_OFF_T_C_HLPR1(Val,Suffix) __CURL_OFF_T_C_HLPR2(Val,Suffix)
+#  define CURL_OFF_T_C(Val)  __CURL_OFF_T_C_HLPR1(Val,CURL_SUFFIX_CURL_OFF_T)
+#  define CURL_OFF_TU_C(Val) __CURL_OFF_T_C_HLPR1(Val,CURL_SUFFIX_CURL_OFF_TU)
+#endif
+
+/*
+ * Get rid of macros private to this header file.
+ */
+
+#undef CurlchkszEQ
+#undef CurlchkszGE
+
+#endif /* __CURL_CURLRULES_H */
diff --git a/src/include/curl/curlver.h b/src/include/curl/curlver.h
new file mode 100644
index 0000000..95a2cbb
--- /dev/null
+++ b/src/include/curl/curlver.h
@@ -0,0 +1,77 @@
+#ifndef __CURL_CURLVER_H
+#define __CURL_CURLVER_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2017, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at https://curl.haxx.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ***************************************************************************/
+
+/* This header file contains nothing but libcurl version info, generated by
+   a script at release-time. This was made its own header file in 7.11.2 */
+
+/* This is the global package copyright */
+#define LIBCURL_COPYRIGHT "1996 - 2017 Daniel Stenberg, <daniel@haxx.se>."
+
+/* This is the version number of the libcurl package from which this header
+   file origins: */
+#define LIBCURL_VERSION "7.54.0"
+
+/* The numeric version number is also available "in parts" by using these
+   defines: */
+#define LIBCURL_VERSION_MAJOR 7
+#define LIBCURL_VERSION_MINOR 54
+#define LIBCURL_VERSION_PATCH 0
+
+/* This is the numeric version of the libcurl version number, meant for easier
+   parsing and comparions by programs. The LIBCURL_VERSION_NUM define will
+   always follow this syntax:
+
+         0xXXYYZZ
+
+   Where XX, YY and ZZ are the main version, release and patch numbers in
+   hexadecimal (using 8 bits each). All three numbers are always represented
+   using two digits.  1.2 would appear as "0x010200" while version 9.11.7
+   appears as "0x090b07".
+
+   This 6-digit (24 bits) hexadecimal number does not show pre-release number,
+   and it is always a greater number in a more recent release. It makes
+   comparisons with greater than and less than work.
+
+   Note: This define is the full hex number and _does not_ use the
+   CURL_VERSION_BITS() macro since curl's own configure script greps for it
+   and needs it to contain the full number.
+*/
+#define LIBCURL_VERSION_NUM 0x073600
+
+/*
+ * This is the date and time when the full source package was created. The
+ * timestamp is not stored in git, as the timestamp is properly set in the
+ * tarballs by the maketgz script.
+ *
+ * The format of the date should follow this template:
+ *
+ * "Mon Feb 12 11:35:33 UTC 2007"
+ */
+#define LIBCURL_TIMESTAMP "Wed Apr 19 05:43:55 UTC 2017"
+
+#define CURL_VERSION_BITS(x,y,z) ((x)<<16|(y)<<8|z)
+#define CURL_AT_LEAST_VERSION(x,y,z) \
+  (LIBCURL_VERSION_NUM >= CURL_VERSION_BITS(x, y, z))
+
+#endif /* __CURL_CURLVER_H */
diff --git a/src/include/curl/easy.h b/src/include/curl/easy.h
new file mode 100644
index 0000000..752c504
--- /dev/null
+++ b/src/include/curl/easy.h
@@ -0,0 +1,102 @@
+#ifndef __CURL_EASY_H
+#define __CURL_EASY_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2016, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at https://curl.haxx.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ***************************************************************************/
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+CURL_EXTERN CURL *curl_easy_init(void);
+CURL_EXTERN CURLcode curl_easy_setopt(CURL *curl, CURLoption option, ...);
+CURL_EXTERN CURLcode curl_easy_perform(CURL *curl);
+CURL_EXTERN void curl_easy_cleanup(CURL *curl);
+
+/*
+ * NAME curl_easy_getinfo()
+ *
+ * DESCRIPTION
+ *
+ * Request internal information from the curl session with this function.  The
+ * third argument MUST be a pointer to a long, a pointer to a char * or a
+ * pointer to a double (as the documentation describes elsewhere).  The data
+ * pointed to will be filled in accordingly and can be relied upon only if the
+ * function returns CURLE_OK.  This function is intended to get used *AFTER* a
+ * performed transfer, all results from this function are undefined until the
+ * transfer is completed.
+ */
+CURL_EXTERN CURLcode curl_easy_getinfo(CURL *curl, CURLINFO info, ...);
+
+
+/*
+ * NAME curl_easy_duphandle()
+ *
+ * DESCRIPTION
+ *
+ * Creates a new curl session handle with the same options set for the handle
+ * passed in. Duplicating a handle could only be a matter of cloning data and
+ * options, internal state info and things like persistent connections cannot
+ * be transferred. It is useful in multithreaded applications when you can run
+ * curl_easy_duphandle() for each new thread to avoid a series of identical
+ * curl_easy_setopt() invokes in every thread.
+ */
+CURL_EXTERN CURL *curl_easy_duphandle(CURL *curl);
+
+/*
+ * NAME curl_easy_reset()
+ *
+ * DESCRIPTION
+ *
+ * Re-initializes a CURL handle to the default values. This puts back the
+ * handle to the same state as it was in when it was just created.
+ *
+ * It does keep: live connections, the Session ID cache, the DNS cache and the
+ * cookies.
+ */
+CURL_EXTERN void curl_easy_reset(CURL *curl);
+
+/*
+ * NAME curl_easy_recv()
+ *
+ * DESCRIPTION
+ *
+ * Receives data from the connected socket. Use after successful
+ * curl_easy_perform() with CURLOPT_CONNECT_ONLY option.
+ */
+CURL_EXTERN CURLcode curl_easy_recv(CURL *curl, void *buffer, size_t buflen,
+                                    size_t *n);
+
+/*
+ * NAME curl_easy_send()
+ *
+ * DESCRIPTION
+ *
+ * Sends data over the connected socket. Use after successful
+ * curl_easy_perform() with CURLOPT_CONNECT_ONLY option.
+ */
+CURL_EXTERN CURLcode curl_easy_send(CURL *curl, const void *buffer,
+                                    size_t buflen, size_t *n);
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/include/curl/mprintf.h b/src/include/curl/mprintf.h
new file mode 100644
index 0000000..e20f546
--- /dev/null
+++ b/src/include/curl/mprintf.h
@@ -0,0 +1,50 @@
+#ifndef __CURL_MPRINTF_H
+#define __CURL_MPRINTF_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2016, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at https://curl.haxx.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ***************************************************************************/
+
+#include <stdarg.h>
+#include <stdio.h> /* needed for FILE */
+#include "curl.h"  /* for CURL_EXTERN */
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+CURL_EXTERN int curl_mprintf(const char *format, ...);
+CURL_EXTERN int curl_mfprintf(FILE *fd, const char *format, ...);
+CURL_EXTERN int curl_msprintf(char *buffer, const char *format, ...);
+CURL_EXTERN int curl_msnprintf(char *buffer, size_t maxlength,
+                               const char *format, ...);
+CURL_EXTERN int curl_mvprintf(const char *format, va_list args);
+CURL_EXTERN int curl_mvfprintf(FILE *fd, const char *format, va_list args);
+CURL_EXTERN int curl_mvsprintf(char *buffer, const char *format, va_list args);
+CURL_EXTERN int curl_mvsnprintf(char *buffer, size_t maxlength,
+                                const char *format, va_list args);
+CURL_EXTERN char *curl_maprintf(const char *format, ...);
+CURL_EXTERN char *curl_mvaprintf(const char *format, va_list args);
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif /* __CURL_MPRINTF_H */
diff --git a/src/include/curl/multi.h b/src/include/curl/multi.h
new file mode 100644
index 0000000..f93e511
--- /dev/null
+++ b/src/include/curl/multi.h
@@ -0,0 +1,439 @@
+#ifndef __CURL_MULTI_H
+#define __CURL_MULTI_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2016, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at https://curl.haxx.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ***************************************************************************/
+/*
+  This is an "external" header file. Don't give away any internals here!
+
+  GOALS
+
+  o Enable a "pull" interface. The application that uses libcurl decides where
+    and when to ask libcurl to get/send data.
+
+  o Enable multiple simultaneous transfers in the same thread without making it
+    complicated for the application.
+
+  o Enable the application to select() on its own file descriptors and curl's
+    file descriptors simultaneous easily.
+
+*/
+
+/*
+ * This header file should not really need to include "curl.h" since curl.h
+ * itself includes this file and we expect user applications to do #include
+ * <curl/curl.h> without the need for especially including multi.h.
+ *
+ * For some reason we added this include here at one point, and rather than to
+ * break existing (wrongly written) libcurl applications, we leave it as-is
+ * but with this warning attached.
+ */
+#include "curl.h"
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+#if defined(BUILDING_LIBCURL) || defined(CURL_STRICTER)
+typedef struct Curl_multi CURLM;
+#else
+typedef void CURLM;
+#endif
+
+typedef enum {
+  CURLM_CALL_MULTI_PERFORM = -1, /* please call curl_multi_perform() or
+                                    curl_multi_socket*() soon */
+  CURLM_OK,
+  CURLM_BAD_HANDLE,      /* the passed-in handle is not a valid CURLM handle */
+  CURLM_BAD_EASY_HANDLE, /* an easy handle was not good/valid */
+  CURLM_OUT_OF_MEMORY,   /* if you ever get this, you're in deep sh*t */
+  CURLM_INTERNAL_ERROR,  /* this is a libcurl bug */
+  CURLM_BAD_SOCKET,      /* the passed in socket argument did not match */
+  CURLM_UNKNOWN_OPTION,  /* curl_multi_setopt() with unsupported option */
+  CURLM_ADDED_ALREADY,   /* an easy handle already added to a multi handle was
+                            attempted to get added - again */
+  CURLM_LAST
+} CURLMcode;
+
+/* just to make code nicer when using curl_multi_socket() you can now check
+   for CURLM_CALL_MULTI_SOCKET too in the same style it works for
+   curl_multi_perform() and CURLM_CALL_MULTI_PERFORM */
+#define CURLM_CALL_MULTI_SOCKET CURLM_CALL_MULTI_PERFORM
+
+/* bitmask bits for CURLMOPT_PIPELINING */
+#define CURLPIPE_NOTHING   0L
+#define CURLPIPE_HTTP1     1L
+#define CURLPIPE_MULTIPLEX 2L
+
+typedef enum {
+  CURLMSG_NONE, /* first, not used */
+  CURLMSG_DONE, /* This easy handle has completed. 'result' contains
+                   the CURLcode of the transfer */
+  CURLMSG_LAST /* last, not used */
+} CURLMSG;
+
+struct CURLMsg {
+  CURLMSG msg;       /* what this message means */
+  CURL *easy_handle; /* the handle it concerns */
+  union {
+    void *whatever;    /* message-specific data */
+    CURLcode result;   /* return code for transfer */
+  } data;
+};
+typedef struct CURLMsg CURLMsg;
+
+/* Based on poll(2) structure and values.
+ * We don't use pollfd and POLL* constants explicitly
+ * to cover platforms without poll(). */
+#define CURL_WAIT_POLLIN    0x0001
+#define CURL_WAIT_POLLPRI   0x0002
+#define CURL_WAIT_POLLOUT   0x0004
+
+struct curl_waitfd {
+  curl_socket_t fd;
+  short events;
+  short revents; /* not supported yet */
+};
+
+/*
+ * Name:    curl_multi_init()
+ *
+ * Desc:    inititalize multi-style curl usage
+ *
+ * Returns: a new CURLM handle to use in all 'curl_multi' functions.
+ */
+CURL_EXTERN CURLM *curl_multi_init(void);
+
+/*
+ * Name:    curl_multi_add_handle()
+ *
+ * Desc:    add a standard curl handle to the multi stack
+ *
+ * Returns: CURLMcode type, general multi error code.
+ */
+CURL_EXTERN CURLMcode curl_multi_add_handle(CURLM *multi_handle,
+                                            CURL *curl_handle);
+
+ /*
+  * Name:    curl_multi_remove_handle()
+  *
+  * Desc:    removes a curl handle from the multi stack again
+  *
+  * Returns: CURLMcode type, general multi error code.
+  */
+CURL_EXTERN CURLMcode curl_multi_remove_handle(CURLM *multi_handle,
+                                               CURL *curl_handle);
+
+ /*
+  * Name:    curl_multi_fdset()
+  *
+  * Desc:    Ask curl for its fd_set sets. The app can use these to select() or
+  *          poll() on. We want curl_multi_perform() called as soon as one of
+  *          them are ready.
+  *
+  * Returns: CURLMcode type, general multi error code.
+  */
+CURL_EXTERN CURLMcode curl_multi_fdset(CURLM *multi_handle,
+                                       fd_set *read_fd_set,
+                                       fd_set *write_fd_set,
+                                       fd_set *exc_fd_set,
+                                       int *max_fd);
+
+/*
+ * Name:     curl_multi_wait()
+ *
+ * Desc:     Poll on all fds within a CURLM set as well as any
+ *           additional fds passed to the function.
+ *
+ * Returns:  CURLMcode type, general multi error code.
+ */
+CURL_EXTERN CURLMcode curl_multi_wait(CURLM *multi_handle,
+                                      struct curl_waitfd extra_fds[],
+                                      unsigned int extra_nfds,
+                                      int timeout_ms,
+                                      int *ret);
+
+ /*
+  * Name:    curl_multi_perform()
+  *
+  * Desc:    When the app thinks there's data available for curl it calls this
+  *          function to read/write whatever there is right now. This returns
+  *          as soon as the reads and writes are done. This function does not
+  *          require that there actually is data available for reading or that
+  *          data can be written, it can be called just in case. It returns
+  *          the number of handles that still transfer data in the second
+  *          argument's integer-pointer.
+  *
+  * Returns: CURLMcode type, general multi error code. *NOTE* that this only
+  *          returns errors etc regarding the whole multi stack. There might
+  *          still have occurred problems on invidual transfers even when this
+  *          returns OK.
+  */
+CURL_EXTERN CURLMcode curl_multi_perform(CURLM *multi_handle,
+                                         int *running_handles);
+
+ /*
+  * Name:    curl_multi_cleanup()
+  *
+  * Desc:    Cleans up and removes a whole multi stack. It does not free or
+  *          touch any individual easy handles in any way. We need to define
+  *          in what state those handles will be if this function is called
+  *          in the middle of a transfer.
+  *
+  * Returns: CURLMcode type, general multi error code.
+  */
+CURL_EXTERN CURLMcode curl_multi_cleanup(CURLM *multi_handle);
+
+/*
+ * Name:    curl_multi_info_read()
+ *
+ * Desc:    Ask the multi handle if there's any messages/informationals from
+ *          the individual transfers. Messages include informationals such as
+ *          error code from the transfer or just the fact that a transfer is
+ *          completed. More details on these should be written down as well.
+ *
+ *          Repeated calls to this function will return a new struct each
+ *          time, until a special "end of msgs" struct is returned as a signal
+ *          that there is no more to get at this point.
+ *
+ *          The data the returned pointer points to will not survive calling
+ *          curl_multi_cleanup().
+ *
+ *          The 'CURLMsg' struct is meant to be very simple and only contain
+ *          very basic information. If more involved information is wanted,
+ *          we will provide the particular "transfer handle" in that struct
+ *          and that should/could/would be used in subsequent
+ *          curl_easy_getinfo() calls (or similar). The point being that we
+ *          must never expose complex structs to applications, as then we'll
+ *          undoubtably get backwards compatibility problems in the future.
+ *
+ * Returns: A pointer to a filled-in struct, or NULL if it failed or ran out
+ *          of structs. It also writes the number of messages left in the
+ *          queue (after this read) in the integer the second argument points
+ *          to.
+ */
+CURL_EXTERN CURLMsg *curl_multi_info_read(CURLM *multi_handle,
+                                          int *msgs_in_queue);
+
+/*
+ * Name:    curl_multi_strerror()
+ *
+ * Desc:    The curl_multi_strerror function may be used to turn a CURLMcode
+ *          value into the equivalent human readable error string.  This is
+ *          useful for printing meaningful error messages.
+ *
+ * Returns: A pointer to a zero-terminated error message.
+ */
+CURL_EXTERN const char *curl_multi_strerror(CURLMcode);
+
+/*
+ * Name:    curl_multi_socket() and
+ *          curl_multi_socket_all()
+ *
+ * Desc:    An alternative version of curl_multi_perform() that allows the
+ *          application to pass in one of the file descriptors that have been
+ *          detected to have "action" on them and let libcurl perform.
+ *          See man page for details.
+ */
+#define CURL_POLL_NONE   0
+#define CURL_POLL_IN     1
+#define CURL_POLL_OUT    2
+#define CURL_POLL_INOUT  3
+#define CURL_POLL_REMOVE 4
+
+#define CURL_SOCKET_TIMEOUT CURL_SOCKET_BAD
+
+#define CURL_CSELECT_IN   0x01
+#define CURL_CSELECT_OUT  0x02
+#define CURL_CSELECT_ERR  0x04
+
+typedef int (*curl_socket_callback)(CURL *easy,      /* easy handle */
+                                    curl_socket_t s, /* socket */
+                                    int what,        /* see above */
+                                    void *userp,     /* private callback
+                                                        pointer */
+                                    void *socketp);  /* private socket
+                                                        pointer */
+/*
+ * Name:    curl_multi_timer_callback
+ *
+ * Desc:    Called by libcurl whenever the library detects a change in the
+ *          maximum number of milliseconds the app is allowed to wait before
+ *          curl_multi_socket() or curl_multi_perform() must be called
+ *          (to allow libcurl's timed events to take place).
+ *
+ * Returns: The callback should return zero.
+ */
+typedef int (*curl_multi_timer_callback)(CURLM *multi,    /* multi handle */
+                                         long timeout_ms, /* see above */
+                                         void *userp);    /* private callback
+                                                             pointer */
+
+CURL_EXTERN CURLMcode curl_multi_socket(CURLM *multi_handle, curl_socket_t s,
+                                        int *running_handles);
+
+CURL_EXTERN CURLMcode curl_multi_socket_action(CURLM *multi_handle,
+                                               curl_socket_t s,
+                                               int ev_bitmask,
+                                               int *running_handles);
+
+CURL_EXTERN CURLMcode curl_multi_socket_all(CURLM *multi_handle,
+                                            int *running_handles);
+
+#ifndef CURL_ALLOW_OLD_MULTI_SOCKET
+/* This macro below was added in 7.16.3 to push users who recompile to use
+   the new curl_multi_socket_action() instead of the old curl_multi_socket()
+*/
+#define curl_multi_socket(x,y,z) curl_multi_socket_action(x,y,0,z)
+#endif
+
+/*
+ * Name:    curl_multi_timeout()
+ *
+ * Desc:    Returns the maximum number of milliseconds the app is allowed to
+ *          wait before curl_multi_socket() or curl_multi_perform() must be
+ *          called (to allow libcurl's timed events to take place).
+ *
+ * Returns: CURLM error code.
+ */
+CURL_EXTERN CURLMcode curl_multi_timeout(CURLM *multi_handle,
+                                         long *milliseconds);
+
+#undef CINIT /* re-using the same name as in curl.h */
+
+#ifdef CURL_ISOCPP
+#define CINIT(name,type,num) CURLMOPT_ ## name = CURLOPTTYPE_ ## type + num
+#else
+/* The macro "##" is ISO C, we assume pre-ISO C doesn't support it. */
+#define LONG          CURLOPTTYPE_LONG
+#define OBJECTPOINT   CURLOPTTYPE_OBJECTPOINT
+#define FUNCTIONPOINT CURLOPTTYPE_FUNCTIONPOINT
+#define OFF_T         CURLOPTTYPE_OFF_T
+#define CINIT(name,type,number) CURLMOPT_/**/name = type + number
+#endif
+
+typedef enum {
+  /* This is the socket callback function pointer */
+  CINIT(SOCKETFUNCTION, FUNCTIONPOINT, 1),
+
+  /* This is the argument passed to the socket callback */
+  CINIT(SOCKETDATA, OBJECTPOINT, 2),
+
+    /* set to 1 to enable pipelining for this multi handle */
+  CINIT(PIPELINING, LONG, 3),
+
+   /* This is the timer callback function pointer */
+  CINIT(TIMERFUNCTION, FUNCTIONPOINT, 4),
+
+  /* This is the argument passed to the timer callback */
+  CINIT(TIMERDATA, OBJECTPOINT, 5),
+
+  /* maximum number of entries in the connection cache */
+  CINIT(MAXCONNECTS, LONG, 6),
+
+  /* maximum number of (pipelining) connections to one host */
+  CINIT(MAX_HOST_CONNECTIONS, LONG, 7),
+
+  /* maximum number of requests in a pipeline */
+  CINIT(MAX_PIPELINE_LENGTH, LONG, 8),
+
+  /* a connection with a content-length longer than this
+     will not be considered for pipelining */
+  CINIT(CONTENT_LENGTH_PENALTY_SIZE, OFF_T, 9),
+
+  /* a connection with a chunk length longer than this
+     will not be considered for pipelining */
+  CINIT(CHUNK_LENGTH_PENALTY_SIZE, OFF_T, 10),
+
+  /* a list of site names(+port) that are blacklisted from
+     pipelining */
+  CINIT(PIPELINING_SITE_BL, OBJECTPOINT, 11),
+
+  /* a list of server types that are blacklisted from
+     pipelining */
+  CINIT(PIPELINING_SERVER_BL, OBJECTPOINT, 12),
+
+  /* maximum number of open connections in total */
+  CINIT(MAX_TOTAL_CONNECTIONS, LONG, 13),
+
+   /* This is the server push callback function pointer */
+  CINIT(PUSHFUNCTION, FUNCTIONPOINT, 14),
+
+  /* This is the argument passed to the server push callback */
+  CINIT(PUSHDATA, OBJECTPOINT, 15),
+
+  CURLMOPT_LASTENTRY /* the last unused */
+} CURLMoption;
+
+
+/*
+ * Name:    curl_multi_setopt()
+ *
+ * Desc:    Sets options for the multi handle.
+ *
+ * Returns: CURLM error code.
+ */
+CURL_EXTERN CURLMcode curl_multi_setopt(CURLM *multi_handle,
+                                        CURLMoption option, ...);
+
+
+/*
+ * Name:    curl_multi_assign()
+ *
+ * Desc:    This function sets an association in the multi handle between the
+ *          given socket and a private pointer of the application. This is
+ *          (only) useful for curl_multi_socket uses.
+ *
+ * Returns: CURLM error code.
+ */
+CURL_EXTERN CURLMcode curl_multi_assign(CURLM *multi_handle,
+                                        curl_socket_t sockfd, void *sockp);
+
+
+/*
+ * Name: curl_push_callback
+ *
+ * Desc: This callback gets called when a new stream is being pushed by the
+ *       server. It approves or denies the new stream.
+ *
+ * Returns: CURL_PUSH_OK or CURL_PUSH_DENY.
+ */
+#define CURL_PUSH_OK   0
+#define CURL_PUSH_DENY 1
+
+struct curl_pushheaders;  /* forward declaration only */
+
+CURL_EXTERN char *curl_pushheader_bynum(struct curl_pushheaders *h,
+                                        size_t num);
+CURL_EXTERN char *curl_pushheader_byname(struct curl_pushheaders *h,
+                                         const char *name);
+
+typedef int (*curl_push_callback)(CURL *parent,
+                                  CURL *easy,
+                                  size_t num_headers,
+                                  struct curl_pushheaders *headers,
+                                  void *userp);
+
+#ifdef __cplusplus
+} /* end of extern "C" */
+#endif
+
+#endif
diff --git a/src/include/curl/stdcheaders.h b/src/include/curl/stdcheaders.h
new file mode 100644
index 0000000..027b6f4
--- /dev/null
+++ b/src/include/curl/stdcheaders.h
@@ -0,0 +1,33 @@
+#ifndef __STDC_HEADERS_H
+#define __STDC_HEADERS_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2016, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at https://curl.haxx.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ***************************************************************************/
+
+#include <sys/types.h>
+
+size_t fread(void *, size_t, size_t, FILE *);
+size_t fwrite(const void *, size_t, size_t, FILE *);
+
+int strcasecmp(const char *, const char *);
+int strncasecmp(const char *, const char *, size_t);
+
+#endif /* __STDC_HEADERS_H */
diff --git a/src/include/curl/system.h b/src/include/curl/system.h
new file mode 100644
index 0000000..ed3a55c
--- /dev/null
+++ b/src/include/curl/system.h
@@ -0,0 +1,484 @@
+#ifndef __CURL_SYSTEM_H
+#define __CURL_SYSTEM_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2017, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at https://curl.haxx.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ***************************************************************************/
+
+/*
+ * This header is supposed to eventually replace curlbuild.h. This little one
+ * is still learning.  During the experimental phase, this header files
+ * defines symbols using the prefixes CURLSYS_ or curlsys_. When we feel
+ * confident enough, we replace curlbuild.h with this file and rename all
+ * prefixes to CURL_ and curl_.
+ */
+
+/*
+ * Try to keep one section per platform, compiler and architecture, otherwise,
+ * if an existing section is reused for a different one and later on the
+ * original is adjusted, probably the piggybacking one can be adversely
+ * changed.
+ *
+ * In order to differentiate between platforms/compilers/architectures use
+ * only compiler built in predefined preprocessor symbols.
+ *
+ * curl_off_t
+ * ----------
+ *
+ * For any given platform/compiler curl_off_t must be typedef'ed to a 64-bit
+ * wide signed integral data type. The width of this data type must remain
+ * constant and independent of any possible large file support settings.
+ *
+ * As an exception to the above, curl_off_t shall be typedef'ed to a 32-bit
+ * wide signed integral data type if there is no 64-bit type.
+ *
+ * As a general rule, curl_off_t shall not be mapped to off_t. This rule shall
+ * only be violated if off_t is the only 64-bit data type available and the
+ * size of off_t is independent of large file support settings. Keep your
+ * build on the safe side avoiding an off_t gating.  If you have a 64-bit
+ * off_t then take for sure that another 64-bit data type exists, dig deeper
+ * and you will find it.
+ *
+ */
+
+#if defined(__DJGPP__) || defined(__GO32__)
+#  if defined(__DJGPP__) && (__DJGPP__ > 1)
+#    define CURLSYS_SIZEOF_LONG           4
+#    define CURLSYS_TYPEOF_CURL_OFF_T     long long
+#    define CURLSYS_FORMAT_CURL_OFF_T     "lld"
+#    define CURLSYS_FORMAT_CURL_OFF_TU    "llu"
+#    define CURLSYS_SIZEOF_CURL_OFF_T     8
+#    define CURLSYS_SUFFIX_CURL_OFF_T     LL
+#    define CURLSYS_SUFFIX_CURL_OFF_TU    ULL
+#  else
+#    define CURLSYS_SIZEOF_LONG           4
+#    define CURLSYS_TYPEOF_CURL_OFF_T     long
+#    define CURLSYS_FORMAT_CURL_OFF_T     "ld"
+#    define CURLSYS_FORMAT_CURL_OFF_TU    "lu"
+#    define CURLSYS_SIZEOF_CURL_OFF_T     4
+#    define CURLSYS_SUFFIX_CURL_OFF_T     L
+#    define CURLSYS_SUFFIX_CURL_OFF_TU    UL
+#  endif
+#  define CURLSYS_TYPEOF_CURL_SOCKLEN_T int
+#  define CURLSYS_SIZEOF_CURL_SOCKLEN_T 4
+
+#elif defined(__SALFORDC__)
+#  define CURLSYS_SIZEOF_LONG           4
+#  define CURLSYS_TYPEOF_CURL_OFF_T     long
+#  define CURLSYS_FORMAT_CURL_OFF_T     "ld"
+#  define CURLSYS_FORMAT_CURL_OFF_TU    "lu"
+#  define CURLSYS_SIZEOF_CURL_OFF_T     4
+#  define CURLSYS_SUFFIX_CURL_OFF_T     L
+#  define CURLSYS_SUFFIX_CURL_OFF_TU    UL
+#  define CURLSYS_TYPEOF_CURL_SOCKLEN_T int
+#  define CURLSYS_SIZEOF_CURL_SOCKLEN_T 4
+
+#elif defined(__BORLANDC__)
+#  if (__BORLANDC__ < 0x520)
+#    define CURLSYS_SIZEOF_LONG           4
+#    define CURLSYS_TYPEOF_CURL_OFF_T     long
+#    define CURLSYS_FORMAT_CURL_OFF_T     "ld"
+#    define CURLSYS_FORMAT_CURL_OFF_TU    "lu"
+#    define CURLSYS_SIZEOF_CURL_OFF_T     4
+#    define CURLSYS_SUFFIX_CURL_OFF_T     L
+#    define CURLSYS_SUFFIX_CURL_OFF_TU    UL
+#  else
+#    define CURLSYS_SIZEOF_LONG           4
+#    define CURLSYS_TYPEOF_CURL_OFF_T     __int64
+#    define CURLSYS_FORMAT_CURL_OFF_T     "I64d"
+#    define CURLSYS_FORMAT_CURL_OFF_TU    "I64u"
+#    define CURLSYS_SIZEOF_CURL_OFF_T     8
+#    define CURLSYS_SUFFIX_CURL_OFF_T     i64
+#    define CURLSYS_SUFFIX_CURL_OFF_TU    ui64
+#  endif
+#  define CURLSYS_TYPEOF_CURL_SOCKLEN_T int
+#  define CURLSYS_SIZEOF_CURL_SOCKLEN_T 4
+
+#elif defined(__TURBOC__)
+#  define CURLSYS_SIZEOF_LONG           4
+#  define CURLSYS_TYPEOF_CURL_OFF_T     long
+#  define CURLSYS_FORMAT_CURL_OFF_T     "ld"
+#  define CURLSYS_FORMAT_CURL_OFF_TU    "lu"
+#  define CURLSYS_SIZEOF_CURL_OFF_T     4
+#  define CURLSYS_SUFFIX_CURL_OFF_T     L
+#  define CURLSYS_SUFFIX_CURL_OFF_TU    UL
+#  define CURLSYS_TYPEOF_CURL_SOCKLEN_T int
+#  define CURLSYS_SIZEOF_CURL_SOCKLEN_T 4
+
+#elif defined(__WATCOMC__)
+#  if defined(__386__)
+#    define CURLSYS_SIZEOF_LONG           4
+#    define CURLSYS_TYPEOF_CURL_OFF_T     __int64
+#    define CURLSYS_FORMAT_CURL_OFF_T     "I64d"
+#    define CURLSYS_FORMAT_CURL_OFF_TU    "I64u"
+#    define CURLSYS_SIZEOF_CURL_OFF_T     8
+#    define CURLSYS_SUFFIX_CURL_OFF_T     i64
+#    define CURLSYS_SUFFIX_CURL_OFF_TU    ui64
+#  else
+#    define CURLSYS_SIZEOF_LONG           4
+#    define CURLSYS_TYPEOF_CURL_OFF_T     long
+#    define CURLSYS_FORMAT_CURL_OFF_T     "ld"
+#    define CURLSYS_FORMAT_CURL_OFF_TU    "lu"
+#    define CURLSYS_SIZEOF_CURL_OFF_T     4
+#    define CURLSYS_SUFFIX_CURL_OFF_T     L
+#    define CURLSYS_SUFFIX_CURL_OFF_TU    UL
+#  endif
+#  define CURLSYS_TYPEOF_CURL_SOCKLEN_T int
+#  define CURLSYS_SIZEOF_CURL_SOCKLEN_T 4
+
+#elif defined(__POCC__)
+#  if (__POCC__ < 280)
+#    define CURLSYS_SIZEOF_LONG           4
+#    define CURLSYS_TYPEOF_CURL_OFF_T     long
+#    define CURLSYS_FORMAT_CURL_OFF_T     "ld"
+#    define CURLSYS_FORMAT_CURL_OFF_TU    "lu"
+#    define CURLSYS_SIZEOF_CURL_OFF_T     4
+#    define CURLSYS_SUFFIX_CURL_OFF_T     L
+#    define CURLSYS_SUFFIX_CURL_OFF_TU    UL
+#  elif defined(_MSC_VER)
+#    define CURLSYS_SIZEOF_LONG           4
+#    define CURLSYS_TYPEOF_CURL_OFF_T     __int64
+#    define CURLSYS_FORMAT_CURL_OFF_T     "I64d"
+#    define CURLSYS_FORMAT_CURL_OFF_TU    "I64u"
+#    define CURLSYS_SIZEOF_CURL_OFF_T     8
+#    define CURLSYS_SUFFIX_CURL_OFF_T     i64
+#    define CURLSYS_SUFFIX_CURL_OFF_TU    ui64
+#  else
+#    define CURLSYS_SIZEOF_LONG           4
+#    define CURLSYS_TYPEOF_CURL_OFF_T     long long
+#    define CURLSYS_FORMAT_CURL_OFF_T     "lld"
+#    define CURLSYS_FORMAT_CURL_OFF_TU    "llu"
+#    define CURLSYS_SIZEOF_CURL_OFF_T     8
+#    define CURLSYS_SUFFIX_CURL_OFF_T     LL
+#    define CURLSYS_SUFFIX_CURL_OFF_TU    ULL
+#  endif
+#  define CURLSYS_TYPEOF_CURL_SOCKLEN_T int
+#  define CURLSYS_SIZEOF_CURL_SOCKLEN_T 4
+
+#elif defined(__LCC__)
+#  define CURLSYS_SIZEOF_LONG           4
+#  define CURLSYS_TYPEOF_CURL_OFF_T     long
+#  define CURLSYS_FORMAT_CURL_OFF_T     "ld"
+#  define CURLSYS_FORMAT_CURL_OFF_TU    "lu"
+#  define CURLSYS_SIZEOF_CURL_OFF_T     4
+#  define CURLSYS_SUFFIX_CURL_OFF_T     L
+#  define CURLSYS_SUFFIX_CURL_OFF_TU    UL
+#  define CURLSYS_TYPEOF_CURL_SOCKLEN_T int
+#  define CURLSYS_SIZEOF_CURL_SOCKLEN_T 4
+
+#elif defined(__SYMBIAN32__)
+#  if defined(__EABI__)  /* Treat all ARM compilers equally */
+#    define CURLSYS_SIZEOF_LONG           4
+#    define CURLSYS_TYPEOF_CURL_OFF_T     long long
+#    define CURLSYS_FORMAT_CURL_OFF_T     "lld"
+#    define CURLSYS_FORMAT_CURL_OFF_TU    "llu"
+#    define CURLSYS_SIZEOF_CURL_OFF_T     8
+#    define CURLSYS_SUFFIX_CURL_OFF_T     LL
+#    define CURLSYS_SUFFIX_CURL_OFF_TU    ULL
+#  elif defined(__CW32__)
+#    pragma longlong on
+#    define CURLSYS_SIZEOF_LONG           4
+#    define CURLSYS_TYPEOF_CURL_OFF_T     long long
+#    define CURLSYS_FORMAT_CURL_OFF_T     "lld"
+#    define CURLSYS_FORMAT_CURL_OFF_TU    "llu"
+#    define CURLSYS_SIZEOF_CURL_OFF_T     8
+#    define CURLSYS_SUFFIX_CURL_OFF_T     LL
+#    define CURLSYS_SUFFIX_CURL_OFF_TU    ULL
+#  elif defined(__VC32__)
+#    define CURLSYS_SIZEOF_LONG           4
+#    define CURLSYS_TYPEOF_CURL_OFF_T     __int64
+#    define CURLSYS_FORMAT_CURL_OFF_T     "lld"
+#    define CURLSYS_FORMAT_CURL_OFF_TU    "llu"
+#    define CURLSYS_SIZEOF_CURL_OFF_T     8
+#    define CURLSYS_SUFFIX_CURL_OFF_T     LL
+#    define CURLSYS_SUFFIX_CURL_OFF_TU    ULL
+#  endif
+#  define CURLSYS_TYPEOF_CURL_SOCKLEN_T unsigned int
+#  define CURLSYS_SIZEOF_CURL_SOCKLEN_T 4
+
+#elif defined(__MWERKS__)
+#  define CURLSYS_SIZEOF_LONG           4
+#  define CURLSYS_TYPEOF_CURL_OFF_T     long long
+#  define CURLSYS_FORMAT_CURL_OFF_T     "lld"
+#  define CURLSYS_FORMAT_CURL_OFF_TU    "llu"
+#  define CURLSYS_SIZEOF_CURL_OFF_T     8
+#  define CURLSYS_SUFFIX_CURL_OFF_T     LL
+#  define CURLSYS_SUFFIX_CURL_OFF_TU    ULL
+#  define CURLSYS_TYPEOF_CURL_SOCKLEN_T int
+#  define CURLSYS_SIZEOF_CURL_SOCKLEN_T 4
+
+#elif defined(_WIN32_WCE)
+#  define CURLSYS_SIZEOF_LONG           4
+#  define CURLSYS_TYPEOF_CURL_OFF_T     __int64
+#  define CURLSYS_FORMAT_CURL_OFF_T     "I64d"
+#  define CURLSYS_FORMAT_CURL_OFF_TU    "I64u"
+#  define CURLSYS_SIZEOF_CURL_OFF_T     8
+#  define CURLSYS_SUFFIX_CURL_OFF_T     i64
+#  define CURLSYS_SUFFIX_CURL_OFF_TU    ui64
+#  define CURLSYS_TYPEOF_CURL_SOCKLEN_T int
+#  define CURLSYS_SIZEOF_CURL_SOCKLEN_T 4
+
+#elif defined(__MINGW32__)
+#  define CURLSYS_SIZEOF_LONG           4
+#  define CURLSYS_TYPEOF_CURL_OFF_T     long long
+#  define CURLSYS_FORMAT_CURL_OFF_T     "I64d"
+#  define CURLSYS_FORMAT_CURL_OFF_TU    "I64u"
+#  define CURLSYS_SIZEOF_CURL_OFF_T     8
+#  define CURLSYS_SUFFIX_CURL_OFF_T     LL
+#  define CURLSYS_SUFFIX_CURL_OFF_TU    ULL
+#  define CURLSYS_TYPEOF_CURL_SOCKLEN_T socklen_t
+#  define CURLSYS_SIZEOF_CURL_SOCKLEN_T 4
+#  define CURLSYS_PULL_SYS_TYPES_H      1
+#  define CURLSYS_PULL_WS2TCPIP_H       1
+
+#elif defined(__VMS)
+#  if defined(__VAX)
+#    define CURLSYS_SIZEOF_LONG           4
+#    define CURLSYS_TYPEOF_CURL_OFF_T     long
+#    define CURLSYS_FORMAT_CURL_OFF_T     "ld"
+#    define CURLSYS_FORMAT_CURL_OFF_TU    "lu"
+#    define CURLSYS_SIZEOF_CURL_OFF_T     4
+#    define CURLSYS_SUFFIX_CURL_OFF_T     L
+#    define CURLSYS_SUFFIX_CURL_OFF_TU    UL
+#  else
+#    define CURLSYS_SIZEOF_LONG           4
+#    define CURLSYS_TYPEOF_CURL_OFF_T     long long
+#    define CURLSYS_FORMAT_CURL_OFF_T     "lld"
+#    define CURLSYS_FORMAT_CURL_OFF_TU    "llu"
+#    define CURLSYS_SIZEOF_CURL_OFF_T     8
+#    define CURLSYS_SUFFIX_CURL_OFF_T     LL
+#    define CURLSYS_SUFFIX_CURL_OFF_TU    ULL
+#  endif
+#  define CURLSYS_TYPEOF_CURL_SOCKLEN_T unsigned int
+#  define CURLSYS_SIZEOF_CURL_SOCKLEN_T 4
+
+#elif defined(__OS400__)
+#  if defined(__ILEC400__)
+#    define CURLSYS_SIZEOF_LONG           4
+#    define CURLSYS_TYPEOF_CURL_OFF_T     long long
+#    define CURLSYS_FORMAT_CURL_OFF_T     "lld"
+#    define CURLSYS_FORMAT_CURL_OFF_TU    "llu"
+#    define CURLSYS_SIZEOF_CURL_OFF_T     8
+#    define CURLSYS_SUFFIX_CURL_OFF_T     LL
+#    define CURLSYS_SUFFIX_CURL_OFF_TU    ULL
+#    define CURLSYS_TYPEOF_CURL_SOCKLEN_T socklen_t
+#    define CURLSYS_SIZEOF_CURL_SOCKLEN_T 4
+#    define CURLSYS_PULL_SYS_TYPES_H      1
+#    define CURLSYS_PULL_SYS_SOCKET_H     1
+#  endif
+
+#elif defined(__MVS__)
+#  if defined(__IBMC__) || defined(__IBMCPP__)
+#    if defined(_ILP32)
+#      define CURLSYS_SIZEOF_LONG           4
+#    elif defined(_LP64)
+#      define CURLSYS_SIZEOF_LONG           8
+#    endif
+#    if defined(_LONG_LONG)
+#      define CURLSYS_TYPEOF_CURL_OFF_T     long long
+#      define CURLSYS_FORMAT_CURL_OFF_T     "lld"
+#      define CURLSYS_FORMAT_CURL_OFF_TU    "llu"
+#      define CURLSYS_SIZEOF_CURL_OFF_T     8
+#      define CURLSYS_SUFFIX_CURL_OFF_T     LL
+#      define CURLSYS_SUFFIX_CURL_OFF_TU    ULL
+#    elif defined(_LP64)
+#      define CURLSYS_TYPEOF_CURL_OFF_T     long
+#      define CURLSYS_FORMAT_CURL_OFF_T     "ld"
+#      define CURLSYS_FORMAT_CURL_OFF_TU    "lu"
+#      define CURLSYS_SIZEOF_CURL_OFF_T     8
+#      define CURLSYS_SUFFIX_CURL_OFF_T     L
+#      define CURLSYS_SUFFIX_CURL_OFF_TU    UL
+#    else
+#      define CURLSYS_TYPEOF_CURL_OFF_T     long
+#      define CURLSYS_FORMAT_CURL_OFF_T     "ld"
+#      define CURLSYS_FORMAT_CURL_OFF_TU    "lu"
+#      define CURLSYS_SIZEOF_CURL_OFF_T     4
+#      define CURLSYS_SUFFIX_CURL_OFF_T     L
+#      define CURLSYS_SUFFIX_CURL_OFF_TU    UL
+#    endif
+#    define CURLSYS_TYPEOF_CURL_SOCKLEN_T socklen_t
+#    define CURLSYS_SIZEOF_CURL_SOCKLEN_T 4
+#    define CURLSYS_PULL_SYS_TYPES_H      1
+#    define CURLSYS_PULL_SYS_SOCKET_H     1
+#  endif
+
+#elif defined(__370__)
+#  if defined(__IBMC__) || defined(__IBMCPP__)
+#    if defined(_ILP32)
+#      define CURLSYS_SIZEOF_LONG           4
+#    elif defined(_LP64)
+#      define CURLSYS_SIZEOF_LONG           8
+#    endif
+#    if defined(_LONG_LONG)
+#      define CURLSYS_TYPEOF_CURL_OFF_T     long long
+#      define CURLSYS_FORMAT_CURL_OFF_T     "lld"
+#      define CURLSYS_FORMAT_CURL_OFF_TU    "llu"
+#      define CURLSYS_SIZEOF_CURL_OFF_T     8
+#      define CURLSYS_SUFFIX_CURL_OFF_T     LL
+#      define CURLSYS_SUFFIX_CURL_OFF_TU    ULL
+#    elif defined(_LP64)
+#      define CURLSYS_TYPEOF_CURL_OFF_T     long
+#      define CURLSYS_FORMAT_CURL_OFF_T     "ld"
+#      define CURLSYS_FORMAT_CURL_OFF_TU    "lu"
+#      define CURLSYS_SIZEOF_CURL_OFF_T     8
+#      define CURLSYS_SUFFIX_CURL_OFF_T     L
+#      define CURLSYS_SUFFIX_CURL_OFF_TU    UL
+#    else
+#      define CURLSYS_TYPEOF_CURL_OFF_T     long
+#      define CURLSYS_FORMAT_CURL_OFF_T     "ld"
+#      define CURLSYS_FORMAT_CURL_OFF_TU    "lu"
+#      define CURLSYS_SIZEOF_CURL_OFF_T     4
+#      define CURLSYS_SUFFIX_CURL_OFF_T     L
+#      define CURLSYS_SUFFIX_CURL_OFF_TU    UL
+#    endif
+#    define CURLSYS_TYPEOF_CURL_SOCKLEN_T socklen_t
+#    define CURLSYS_SIZEOF_CURL_SOCKLEN_T 4
+#    define CURLSYS_PULL_SYS_TYPES_H      1
+#    define CURLSYS_PULL_SYS_SOCKET_H     1
+#  endif
+
+#elif defined(TPF)
+#  define CURLSYS_SIZEOF_LONG           8
+#  define CURLSYS_TYPEOF_CURL_OFF_T     long
+#  define CURLSYS_FORMAT_CURL_OFF_T     "ld"
+#  define CURLSYS_FORMAT_CURL_OFF_TU    "lu"
+#  define CURLSYS_SIZEOF_CURL_OFF_T     8
+#  define CURLSYS_SUFFIX_CURL_OFF_T     L
+#  define CURLSYS_SUFFIX_CURL_OFF_TU    UL
+#  define CURLSYS_TYPEOF_CURL_SOCKLEN_T int
+#  define CURLSYS_SIZEOF_CURL_SOCKLEN_T 4
+
+#elif defined(__TINYC__) /* also known as tcc */
+
+#  define CURLSYS_SIZEOF_LONG           4
+#  define CURLSYS_TYPEOF_CURL_OFF_T     long long
+#  define CURLSYS_FORMAT_CURL_OFF_T     "lld"
+#  define CURLSYS_FORMAT_CURL_OFF_TU    "llu"
+#  define CURLSYS_SIZEOF_CURL_OFF_T     8
+#  define CURLSYS_SUFFIX_CURL_OFF_T     LL
+#  define CURLSYS_SUFFIX_CURL_OFF_TU    ULL
+#  define CURLSYS_TYPEOF_CURL_SOCKLEN_T socklen_t
+#  define CURLSYS_PULL_SYS_TYPES_H      1
+#  define CURLSYS_PULL_SYS_SOCKET_H     1
+
+/* ===================================== */
+/*    KEEP MSVC THE PENULTIMATE ENTRY    */
+/* ===================================== */
+
+#elif defined(_MSC_VER)
+#  if (_MSC_VER >= 900) && (_INTEGRAL_MAX_BITS >= 64)
+#    define CURLSYS_SIZEOF_LONG           4
+#    define CURLSYS_TYPEOF_CURL_OFF_T     __int64
+#    define CURLSYS_FORMAT_CURL_OFF_T     "I64d"
+#    define CURLSYS_FORMAT_CURL_OFF_TU    "I64u"
+#    define CURLSYS_SIZEOF_CURL_OFF_T     8
+#    define CURLSYS_SUFFIX_CURL_OFF_T     i64
+#    define CURLSYS_SUFFIX_CURL_OFF_TU    ui64
+#  else
+#    define CURLSYS_SIZEOF_LONG           4
+#    define CURLSYS_TYPEOF_CURL_OFF_T     long
+#    define CURLSYS_FORMAT_CURL_OFF_T     "ld"
+#    define CURLSYS_FORMAT_CURL_OFF_TU    "lu"
+#    define CURLSYS_SIZEOF_CURL_OFF_T     4
+#    define CURLSYS_SUFFIX_CURL_OFF_T     L
+#    define CURLSYS_SUFFIX_CURL_OFF_TU    UL
+#  endif
+#  define CURLSYS_TYPEOF_CURL_SOCKLEN_T int
+#  define CURLSYS_SIZEOF_CURL_SOCKLEN_T 4
+
+/* ===================================== */
+/*    KEEP GENERIC GCC THE LAST ENTRY    */
+/* ===================================== */
+
+#elif defined(__GNUC__)
+#  if !defined(__LP64__) && (defined(__ILP32__) || \
+      defined(__i386__) || defined(__ppc__) || defined(__arm__) || \
+      defined(__sparc__) || defined(__mips__) || defined(__sh__))
+#    define CURLSYS_SIZEOF_LONG           4
+#    define CURLSYS_TYPEOF_CURL_OFF_T     long long
+#    define CURLSYS_FORMAT_CURL_OFF_T     "lld"
+#    define CURLSYS_FORMAT_CURL_OFF_TU    "llu"
+#    define CURLSYS_SIZEOF_CURL_OFF_T     8
+#    define CURLSYS_SUFFIX_CURL_OFF_T     LL
+#    define CURLSYS_SUFFIX_CURL_OFF_TU    ULL
+#  elif defined(__LP64__) || \
+        defined(__x86_64__) || defined(__ppc64__) || defined(__sparc64__)
+#    define CURLSYS_SIZEOF_LONG           8
+#    define CURLSYS_TYPEOF_CURL_OFF_T     long
+#    define CURLSYS_FORMAT_CURL_OFF_T     "ld"
+#    define CURLSYS_FORMAT_CURL_OFF_TU    "lu"
+#    define CURLSYS_SIZEOF_CURL_OFF_T     8
+#    define CURLSYS_SUFFIX_CURL_OFF_T     L
+#    define CURLSYS_SUFFIX_CURL_OFF_TU    UL
+#  endif
+#  define CURLSYS_TYPEOF_CURL_SOCKLEN_T socklen_t
+#  define CURLSYS_SIZEOF_CURL_SOCKLEN_T 4
+#  define CURLSYS_PULL_SYS_TYPES_H      1
+#  define CURLSYS_PULL_SYS_SOCKET_H     1
+
+#else
+/* generic "safe guess" on old 32 bit style */
+# define CURLSYS_SIZEOF_LONG 4
+# define CURLSYS_SIZEOF_CURL_SOCKLEN_T 4
+# define CURLSYS_SIZEOF_CURL_OFF_T 4
+# define CURLSYS_TYPEOF_CURL_OFF_T     long
+# define CURLSYS_FORMAT_CURL_OFF_T     "ld"
+# define CURLSYS_FORMAT_CURL_OFF_TU    "lu"
+# define CURLSYS_SUFFIX_CURL_OFF_T     L
+# define CURLSYS_SUFFIX_CURL_OFF_TU    UL
+# define CURLSYS_TYPEOF_CURL_SOCKLEN_T int
+#endif
+
+/* CURLSYS_PULL_WS2TCPIP_H is defined above when inclusion of header file  */
+/* ws2tcpip.h is required here to properly make type definitions below. */
+#ifdef CURLSYS_PULL_WS2TCPIP_H
+#  ifndef WIN32_LEAN_AND_MEAN
+#    define WIN32_LEAN_AND_MEAN
+#  endif
+#  include <windows.h>
+#  include <winsock2.h>
+#  include <ws2tcpip.h>
+#endif
+
+/* CURLSYS_PULL_SYS_TYPES_H is defined above when inclusion of header file  */
+/* sys/types.h is required here to properly make type definitions below. */
+#ifdef CURLSYS_PULL_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+
+/* CURLSYS_PULL_SYS_SOCKET_H is defined above when inclusion of header file  */
+/* sys/socket.h is required here to properly make type definitions below. */
+#ifdef CURLSYS_PULL_SYS_SOCKET_H
+#  include <sys/socket.h>
+#endif
+
+/* Data type definition of curl_socklen_t. */
+#ifdef CURLSYS_TYPEOF_CURL_SOCKLEN_T
+  typedef CURLSYS_TYPEOF_CURL_SOCKLEN_T curlsys_socklen_t;
+#endif
+
+/* Data type definition of curl_off_t. */
+
+#ifdef CURLSYS_TYPEOF_CURL_OFF_T
+  typedef CURLSYS_TYPEOF_CURL_OFF_T curlsys_off_t;
+#endif
+
+#endif /* __CURL_SYSTEM_H */
+
diff --git a/src/include/curl/typecheck-gcc.h b/src/include/curl/typecheck-gcc.h
new file mode 100644
index 0000000..3d68315
--- /dev/null
+++ b/src/include/curl/typecheck-gcc.h
@@ -0,0 +1,624 @@
+#ifndef __CURL_TYPECHECK_GCC_H
+#define __CURL_TYPECHECK_GCC_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2016, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at https://curl.haxx.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ***************************************************************************/
+
+/* wraps curl_easy_setopt() with typechecking */
+
+/* To add a new kind of warning, add an
+ *   if(_curl_is_sometype_option(_curl_opt))
+ *     if(!_curl_is_sometype(value))
+ *       _curl_easy_setopt_err_sometype();
+ * block and define _curl_is_sometype_option, _curl_is_sometype and
+ * _curl_easy_setopt_err_sometype below
+ *
+ * NOTE: We use two nested 'if' statements here instead of the && operator, in
+ *       order to work around gcc bug #32061.  It affects only gcc 4.3.x/4.4.x
+ *       when compiling with -Wlogical-op.
+ *
+ * To add an option that uses the same type as an existing option, you'll just
+ * need to extend the appropriate _curl_*_option macro
+ */
+#define curl_easy_setopt(handle, option, value)                               \
+__extension__ ({                                                              \
+  __typeof__(option) _curl_opt = option;                                     \
+  if(__builtin_constant_p(_curl_opt)) {                                       \
+    if(_curl_is_long_option(_curl_opt))                                       \
+      if(!_curl_is_long(value))                                               \
+        _curl_easy_setopt_err_long();                                         \
+    if(_curl_is_off_t_option(_curl_opt))                                      \
+      if(!_curl_is_off_t(value))                                              \
+        _curl_easy_setopt_err_curl_off_t();                                   \
+    if(_curl_is_string_option(_curl_opt))                                     \
+      if(!_curl_is_string(value))                                             \
+        _curl_easy_setopt_err_string();                                       \
+    if(_curl_is_write_cb_option(_curl_opt))                                   \
+      if(!_curl_is_write_cb(value))                                           \
+        _curl_easy_setopt_err_write_callback();                               \
+    if((_curl_opt) == CURLOPT_READFUNCTION)                                   \
+      if(!_curl_is_read_cb(value))                                            \
+        _curl_easy_setopt_err_read_cb();                                      \
+    if((_curl_opt) == CURLOPT_IOCTLFUNCTION)                                  \
+      if(!_curl_is_ioctl_cb(value))                                           \
+        _curl_easy_setopt_err_ioctl_cb();                                     \
+    if((_curl_opt) == CURLOPT_SOCKOPTFUNCTION)                                \
+      if(!_curl_is_sockopt_cb(value))                                         \
+        _curl_easy_setopt_err_sockopt_cb();                                   \
+    if((_curl_opt) == CURLOPT_OPENSOCKETFUNCTION)                             \
+      if(!_curl_is_opensocket_cb(value))                                      \
+        _curl_easy_setopt_err_opensocket_cb();                                \
+    if((_curl_opt) == CURLOPT_PROGRESSFUNCTION)                               \
+      if(!_curl_is_progress_cb(value))                                        \
+        _curl_easy_setopt_err_progress_cb();                                  \
+    if((_curl_opt) == CURLOPT_DEBUGFUNCTION)                                  \
+      if(!_curl_is_debug_cb(value))                                           \
+        _curl_easy_setopt_err_debug_cb();                                     \
+    if((_curl_opt) == CURLOPT_SSL_CTX_FUNCTION)                               \
+      if(!_curl_is_ssl_ctx_cb(value))                                         \
+        _curl_easy_setopt_err_ssl_ctx_cb();                                   \
+    if(_curl_is_conv_cb_option(_curl_opt))                                    \
+      if(!_curl_is_conv_cb(value))                                            \
+        _curl_easy_setopt_err_conv_cb();                                      \
+    if((_curl_opt) == CURLOPT_SEEKFUNCTION)                                   \
+      if(!_curl_is_seek_cb(value))                                            \
+        _curl_easy_setopt_err_seek_cb();                                      \
+    if(_curl_is_cb_data_option(_curl_opt))                                    \
+      if(!_curl_is_cb_data(value))                                            \
+        _curl_easy_setopt_err_cb_data();                                      \
+    if((_curl_opt) == CURLOPT_ERRORBUFFER)                                    \
+      if(!_curl_is_error_buffer(value))                                       \
+        _curl_easy_setopt_err_error_buffer();                                 \
+    if((_curl_opt) == CURLOPT_STDERR)                                         \
+      if(!_curl_is_FILE(value))                                               \
+        _curl_easy_setopt_err_FILE();                                         \
+    if(_curl_is_postfields_option(_curl_opt))                                 \
+      if(!_curl_is_postfields(value))                                         \
+        _curl_easy_setopt_err_postfields();                                   \
+    if((_curl_opt) == CURLOPT_HTTPPOST)                                       \
+      if(!_curl_is_arr((value), struct curl_httppost))                        \
+        _curl_easy_setopt_err_curl_httpost();                                 \
+    if(_curl_is_slist_option(_curl_opt))                                      \
+      if(!_curl_is_arr((value), struct curl_slist))                           \
+        _curl_easy_setopt_err_curl_slist();                                   \
+    if((_curl_opt) == CURLOPT_SHARE)                                          \
+      if(!_curl_is_ptr((value), CURLSH))                                      \
+        _curl_easy_setopt_err_CURLSH();                                       \
+  }                                                                           \
+  curl_easy_setopt(handle, _curl_opt, value);                                 \
+})
+
+/* wraps curl_easy_getinfo() with typechecking */
+/* FIXME: don't allow const pointers */
+#define curl_easy_getinfo(handle, info, arg)                                  \
+__extension__ ({                                                              \
+  __typeof__(info) _curl_info = info;                                        \
+  if(__builtin_constant_p(_curl_info)) {                                      \
+    if(_curl_is_string_info(_curl_info))                                      \
+      if(!_curl_is_arr((arg), char *))                                        \
+        _curl_easy_getinfo_err_string();                                      \
+    if(_curl_is_long_info(_curl_info))                                        \
+      if(!_curl_is_arr((arg), long))                                          \
+        _curl_easy_getinfo_err_long();                                        \
+    if(_curl_is_double_info(_curl_info))                                      \
+      if(!_curl_is_arr((arg), double))                                        \
+        _curl_easy_getinfo_err_double();                                      \
+    if(_curl_is_slist_info(_curl_info))                                       \
+      if(!_curl_is_arr((arg), struct curl_slist *))                           \
+        _curl_easy_getinfo_err_curl_slist();                                  \
+  }                                                                           \
+  curl_easy_getinfo(handle, _curl_info, arg);                                 \
+})
+
+/* TODO: typechecking for curl_share_setopt() and curl_multi_setopt(),
+ * for now just make sure that the functions are called with three
+ * arguments
+ */
+#define curl_share_setopt(share,opt,param) curl_share_setopt(share,opt,param)
+#define curl_multi_setopt(handle,opt,param) curl_multi_setopt(handle,opt,param)
+
+
+/* the actual warnings, triggered by calling the _curl_easy_setopt_err*
+ * functions */
+
+/* To define a new warning, use _CURL_WARNING(identifier, "message") */
+#define _CURL_WARNING(id, message)                                            \
+  static void __attribute__((__warning__(message)))                           \
+  __attribute__((__unused__)) __attribute__((__noinline__))                   \
+  id(void) { __asm__(""); }
+
+_CURL_WARNING(_curl_easy_setopt_err_long,
+  "curl_easy_setopt expects a long argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_curl_off_t,
+  "curl_easy_setopt expects a curl_off_t argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_string,
+              "curl_easy_setopt expects a "
+              "string ('char *' or char[]) argument for this option"
+  )
+_CURL_WARNING(_curl_easy_setopt_err_write_callback,
+  "curl_easy_setopt expects a curl_write_callback argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_read_cb,
+  "curl_easy_setopt expects a curl_read_callback argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_ioctl_cb,
+  "curl_easy_setopt expects a curl_ioctl_callback argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_sockopt_cb,
+  "curl_easy_setopt expects a curl_sockopt_callback argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_opensocket_cb,
+              "curl_easy_setopt expects a "
+              "curl_opensocket_callback argument for this option"
+  )
+_CURL_WARNING(_curl_easy_setopt_err_progress_cb,
+  "curl_easy_setopt expects a curl_progress_callback argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_debug_cb,
+  "curl_easy_setopt expects a curl_debug_callback argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_ssl_ctx_cb,
+  "curl_easy_setopt expects a curl_ssl_ctx_callback argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_conv_cb,
+  "curl_easy_setopt expects a curl_conv_callback argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_seek_cb,
+  "curl_easy_setopt expects a curl_seek_callback argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_cb_data,
+              "curl_easy_setopt expects a "
+              "private data pointer as argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_error_buffer,
+              "curl_easy_setopt expects a "
+              "char buffer of CURL_ERROR_SIZE as argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_FILE,
+  "curl_easy_setopt expects a 'FILE *' argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_postfields,
+  "curl_easy_setopt expects a 'void *' or 'char *' argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_curl_httpost,
+              "curl_easy_setopt expects a 'struct curl_httppost *' "
+              "argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_curl_slist,
+  "curl_easy_setopt expects a 'struct curl_slist *' argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_CURLSH,
+  "curl_easy_setopt expects a CURLSH* argument for this option")
+
+_CURL_WARNING(_curl_easy_getinfo_err_string,
+  "curl_easy_getinfo expects a pointer to 'char *' for this info")
+_CURL_WARNING(_curl_easy_getinfo_err_long,
+  "curl_easy_getinfo expects a pointer to long for this info")
+_CURL_WARNING(_curl_easy_getinfo_err_double,
+  "curl_easy_getinfo expects a pointer to double for this info")
+_CURL_WARNING(_curl_easy_getinfo_err_curl_slist,
+  "curl_easy_getinfo expects a pointer to 'struct curl_slist *' for this info")
+
+/* groups of curl_easy_setops options that take the same type of argument */
+
+/* To add a new option to one of the groups, just add
+ *   (option) == CURLOPT_SOMETHING
+ * to the or-expression. If the option takes a long or curl_off_t, you don't
+ * have to do anything
+ */
+
+/* evaluates to true if option takes a long argument */
+#define _curl_is_long_option(option)                                          \
+  (0 < (option) && (option) < CURLOPTTYPE_OBJECTPOINT)
+
+#define _curl_is_off_t_option(option)                                         \
+  ((option) > CURLOPTTYPE_OFF_T)
+
+/* evaluates to true if option takes a char* argument */
+#define _curl_is_string_option(option)                                        \
+  ((option) == CURLOPT_ABSTRACT_UNIX_SOCKET ||                                \
+   (option) == CURLOPT_ACCEPT_ENCODING ||                                     \
+   (option) == CURLOPT_CAINFO ||                                              \
+   (option) == CURLOPT_CAPATH ||                                              \
+   (option) == CURLOPT_COOKIE ||                                              \
+   (option) == CURLOPT_COOKIEFILE ||                                          \
+   (option) == CURLOPT_COOKIEJAR ||                                           \
+   (option) == CURLOPT_COOKIELIST ||                                          \
+   (option) == CURLOPT_CRLFILE ||                                             \
+   (option) == CURLOPT_CUSTOMREQUEST ||                                       \
+   (option) == CURLOPT_DEFAULT_PROTOCOL ||                                    \
+   (option) == CURLOPT_DNS_INTERFACE ||                                       \
+   (option) == CURLOPT_DNS_LOCAL_IP4 ||                                       \
+   (option) == CURLOPT_DNS_LOCAL_IP6 ||                                       \
+   (option) == CURLOPT_DNS_SERVERS ||                                         \
+   (option) == CURLOPT_EGDSOCKET ||                                           \
+   (option) == CURLOPT_FTPPORT ||                                             \
+   (option) == CURLOPT_FTP_ACCOUNT ||                                         \
+   (option) == CURLOPT_FTP_ALTERNATIVE_TO_USER ||                             \
+   (option) == CURLOPT_INTERFACE ||                                           \
+   (option) == CURLOPT_ISSUERCERT ||                                          \
+   (option) == CURLOPT_KEYPASSWD ||                                           \
+   (option) == CURLOPT_KRBLEVEL ||                                            \
+   (option) == CURLOPT_LOGIN_OPTIONS ||                                       \
+   (option) == CURLOPT_MAIL_AUTH ||                                           \
+   (option) == CURLOPT_MAIL_FROM ||                                           \
+   (option) == CURLOPT_NETRC_FILE ||                                          \
+   (option) == CURLOPT_NOPROXY ||                                             \
+   (option) == CURLOPT_PASSWORD ||                                            \
+   (option) == CURLOPT_PINNEDPUBLICKEY ||                                     \
+   (option) == CURLOPT_PROXY ||                                               \
+   (option) == CURLOPT_PROXYPASSWORD ||                                       \
+   (option) == CURLOPT_PROXYUSERNAME ||                                       \
+   (option) == CURLOPT_PROXYUSERPWD ||                                        \
+   (option) == CURLOPT_PROXY_SERVICE_NAME ||                                  \
+   (option) == CURLOPT_RANDOM_FILE ||                                         \
+   (option) == CURLOPT_RANGE ||                                               \
+   (option) == CURLOPT_REFERER ||                                             \
+   (option) == CURLOPT_RTSP_SESSION_ID ||                                     \
+   (option) == CURLOPT_RTSP_STREAM_URI ||                                     \
+   (option) == CURLOPT_RTSP_TRANSPORT ||                                      \
+   (option) == CURLOPT_SERVICE_NAME ||                                        \
+   (option) == CURLOPT_SOCKS5_GSSAPI_SERVICE ||                               \
+   (option) == CURLOPT_SSH_HOST_PUBLIC_KEY_MD5 ||                             \
+   (option) == CURLOPT_SSH_KNOWNHOSTS ||                                      \
+   (option) == CURLOPT_SSH_PRIVATE_KEYFILE ||                                 \
+   (option) == CURLOPT_SSH_PUBLIC_KEYFILE ||                                  \
+   (option) == CURLOPT_SSLCERT ||                                             \
+   (option) == CURLOPT_SSLCERTTYPE ||                                         \
+   (option) == CURLOPT_SSLENGINE ||                                           \
+   (option) == CURLOPT_SSLKEY ||                                              \
+   (option) == CURLOPT_SSLKEYTYPE ||                                          \
+   (option) == CURLOPT_SSL_CIPHER_LIST ||                                     \
+   (option) == CURLOPT_TLSAUTH_PASSWORD ||                                    \
+   (option) == CURLOPT_TLSAUTH_TYPE ||                                        \
+   (option) == CURLOPT_TLSAUTH_USERNAME ||                                    \
+   (option) == CURLOPT_UNIX_SOCKET_PATH ||                                    \
+   (option) == CURLOPT_URL ||                                                 \
+   (option) == CURLOPT_USERAGENT ||                                           \
+   (option) == CURLOPT_USERNAME ||                                            \
+   (option) == CURLOPT_USERPWD ||                                             \
+   (option) == CURLOPT_XOAUTH2_BEARER ||                                      \
+   0)
+
+/* evaluates to true if option takes a curl_write_callback argument */
+#define _curl_is_write_cb_option(option)                                      \
+  ((option) == CURLOPT_HEADERFUNCTION ||                                      \
+   (option) == CURLOPT_WRITEFUNCTION)
+
+/* evaluates to true if option takes a curl_conv_callback argument */
+#define _curl_is_conv_cb_option(option)                                       \
+  ((option) == CURLOPT_CONV_TO_NETWORK_FUNCTION ||                            \
+   (option) == CURLOPT_CONV_FROM_NETWORK_FUNCTION ||                          \
+   (option) == CURLOPT_CONV_FROM_UTF8_FUNCTION)
+
+/* evaluates to true if option takes a data argument to pass to a callback */
+#define _curl_is_cb_data_option(option)                                       \
+  ((option) == CURLOPT_CHUNK_DATA ||                                          \
+   (option) == CURLOPT_CLOSESOCKETDATA ||                                     \
+   (option) == CURLOPT_DEBUGDATA ||                                           \
+   (option) == CURLOPT_FNMATCH_DATA ||                                        \
+   (option) == CURLOPT_HEADERDATA ||                                          \
+   (option) == CURLOPT_INTERLEAVEDATA ||                                      \
+   (option) == CURLOPT_IOCTLDATA ||                                           \
+   (option) == CURLOPT_OPENSOCKETDATA ||                                      \
+   (option) == CURLOPT_PRIVATE ||                                             \
+   (option) == CURLOPT_PROGRESSDATA ||                                        \
+   (option) == CURLOPT_READDATA ||                                            \
+   (option) == CURLOPT_SEEKDATA ||                                            \
+   (option) == CURLOPT_SOCKOPTDATA ||                                         \
+   (option) == CURLOPT_SSH_KEYDATA ||                                         \
+   (option) == CURLOPT_SSL_CTX_DATA ||                                        \
+   (option) == CURLOPT_WRITEDATA ||                                           \
+   0)
+
+/* evaluates to true if option takes a POST data argument (void* or char*) */
+#define _curl_is_postfields_option(option)                                    \
+  ((option) == CURLOPT_POSTFIELDS ||                                          \
+   (option) == CURLOPT_COPYPOSTFIELDS ||                                      \
+   0)
+
+/* evaluates to true if option takes a struct curl_slist * argument */
+#define _curl_is_slist_option(option)                                         \
+  ((option) == CURLOPT_HTTP200ALIASES ||                                      \
+   (option) == CURLOPT_HTTPHEADER ||                                          \
+   (option) == CURLOPT_MAIL_RCPT ||                                           \
+   (option) == CURLOPT_POSTQUOTE ||                                           \
+   (option) == CURLOPT_PREQUOTE ||                                            \
+   (option) == CURLOPT_PROXYHEADER ||                                         \
+   (option) == CURLOPT_QUOTE ||                                               \
+   (option) == CURLOPT_RESOLVE ||                                             \
+   (option) == CURLOPT_TELNETOPTIONS ||                                       \
+   0)
+
+/* groups of curl_easy_getinfo infos that take the same type of argument */
+
+/* evaluates to true if info expects a pointer to char * argument */
+#define _curl_is_string_info(info)                                            \
+  (CURLINFO_STRING < (info) && (info) < CURLINFO_LONG)
+
+/* evaluates to true if info expects a pointer to long argument */
+#define _curl_is_long_info(info)                                              \
+  (CURLINFO_LONG < (info) && (info) < CURLINFO_DOUBLE)
+
+/* evaluates to true if info expects a pointer to double argument */
+#define _curl_is_double_info(info)                                            \
+  (CURLINFO_DOUBLE < (info) && (info) < CURLINFO_SLIST)
+
+/* true if info expects a pointer to struct curl_slist * argument */
+#define _curl_is_slist_info(info)                                             \
+  (CURLINFO_SLIST < (info))
+
+
+/* typecheck helpers -- check whether given expression has requested type*/
+
+/* For pointers, you can use the _curl_is_ptr/_curl_is_arr macros,
+ * otherwise define a new macro. Search for __builtin_types_compatible_p
+ * in the GCC manual.
+ * NOTE: these macros MUST NOT EVALUATE their arguments! The argument is
+ * the actual expression passed to the curl_easy_setopt macro. This
+ * means that you can only apply the sizeof and __typeof__ operators, no
+ * == or whatsoever.
+ */
+
+/* XXX: should evaluate to true iff expr is a pointer */
+#define _curl_is_any_ptr(expr)                                                \
+  (sizeof(expr) == sizeof(void *))
+
+/* evaluates to true if expr is NULL */
+/* XXX: must not evaluate expr, so this check is not accurate */
+#define _curl_is_NULL(expr)                                                   \
+  (__builtin_types_compatible_p(__typeof__(expr), __typeof__(NULL)))
+
+/* evaluates to true if expr is type*, const type* or NULL */
+#define _curl_is_ptr(expr, type)                                              \
+  (_curl_is_NULL(expr) ||                                                     \
+   __builtin_types_compatible_p(__typeof__(expr), type *) ||                  \
+   __builtin_types_compatible_p(__typeof__(expr), const type *))
+
+/* evaluates to true if expr is one of type[], type*, NULL or const type* */
+#define _curl_is_arr(expr, type)                                              \
+  (_curl_is_ptr((expr), type) ||                                              \
+   __builtin_types_compatible_p(__typeof__(expr), type []))
+
+/* evaluates to true if expr is a string */
+#define _curl_is_string(expr)                                                 \
+  (_curl_is_arr((expr), char) ||                                              \
+   _curl_is_arr((expr), signed char) ||                                       \
+   _curl_is_arr((expr), unsigned char))
+
+/* evaluates to true if expr is a long (no matter the signedness)
+ * XXX: for now, int is also accepted (and therefore short and char, which
+ * are promoted to int when passed to a variadic function) */
+#define _curl_is_long(expr)                                                   \
+  (__builtin_types_compatible_p(__typeof__(expr), long) ||                    \
+   __builtin_types_compatible_p(__typeof__(expr), signed long) ||             \
+   __builtin_types_compatible_p(__typeof__(expr), unsigned long) ||           \
+   __builtin_types_compatible_p(__typeof__(expr), int) ||                     \
+   __builtin_types_compatible_p(__typeof__(expr), signed int) ||              \
+   __builtin_types_compatible_p(__typeof__(expr), unsigned int) ||            \
+   __builtin_types_compatible_p(__typeof__(expr), short) ||                   \
+   __builtin_types_compatible_p(__typeof__(expr), signed short) ||            \
+   __builtin_types_compatible_p(__typeof__(expr), unsigned short) ||          \
+   __builtin_types_compatible_p(__typeof__(expr), char) ||                    \
+   __builtin_types_compatible_p(__typeof__(expr), signed char) ||             \
+   __builtin_types_compatible_p(__typeof__(expr), unsigned char))
+
+/* evaluates to true if expr is of type curl_off_t */
+#define _curl_is_off_t(expr)                                                  \
+  (__builtin_types_compatible_p(__typeof__(expr), curl_off_t))
+
+/* evaluates to true if expr is abuffer suitable for CURLOPT_ERRORBUFFER */
+/* XXX: also check size of an char[] array? */
+#define _curl_is_error_buffer(expr)                                           \
+  (_curl_is_NULL(expr) ||                                                     \
+   __builtin_types_compatible_p(__typeof__(expr), char *) ||                  \
+   __builtin_types_compatible_p(__typeof__(expr), char[]))
+
+/* evaluates to true if expr is of type (const) void* or (const) FILE* */
+#if 0
+#define _curl_is_cb_data(expr)                                                \
+  (_curl_is_ptr((expr), void) ||                                              \
+   _curl_is_ptr((expr), FILE))
+#else /* be less strict */
+#define _curl_is_cb_data(expr)                                                \
+  _curl_is_any_ptr(expr)
+#endif
+
+/* evaluates to true if expr is of type FILE* */
+#define _curl_is_FILE(expr)                                                   \
+  (__builtin_types_compatible_p(__typeof__(expr), FILE *))
+
+/* evaluates to true if expr can be passed as POST data (void* or char*) */
+#define _curl_is_postfields(expr)                                             \
+  (_curl_is_ptr((expr), void) ||                                              \
+   _curl_is_arr((expr), char))
+
+/* FIXME: the whole callback checking is messy...
+ * The idea is to tolerate char vs. void and const vs. not const
+ * pointers in arguments at least
+ */
+/* helper: __builtin_types_compatible_p distinguishes between functions and
+ * function pointers, hide it */
+#define _curl_callback_compatible(func, type)                                 \
+  (__builtin_types_compatible_p(__typeof__(func), type) ||                    \
+   __builtin_types_compatible_p(__typeof__(func), type*))
+
+/* evaluates to true if expr is of type curl_read_callback or "similar" */
+#define _curl_is_read_cb(expr)                                          \
+  (_curl_is_NULL(expr) ||                                                     \
+   __builtin_types_compatible_p(__typeof__(expr), __typeof__(fread)) ||       \
+   __builtin_types_compatible_p(__typeof__(expr), curl_read_callback) ||      \
+   _curl_callback_compatible((expr), _curl_read_callback1) ||                 \
+   _curl_callback_compatible((expr), _curl_read_callback2) ||                 \
+   _curl_callback_compatible((expr), _curl_read_callback3) ||                 \
+   _curl_callback_compatible((expr), _curl_read_callback4) ||                 \
+   _curl_callback_compatible((expr), _curl_read_callback5) ||                 \
+   _curl_callback_compatible((expr), _curl_read_callback6))
+typedef size_t (_curl_read_callback1)(char *, size_t, size_t, void *);
+typedef size_t (_curl_read_callback2)(char *, size_t, size_t, const void *);
+typedef size_t (_curl_read_callback3)(char *, size_t, size_t, FILE *);
+typedef size_t (_curl_read_callback4)(void *, size_t, size_t, void *);
+typedef size_t (_curl_read_callback5)(void *, size_t, size_t, const void *);
+typedef size_t (_curl_read_callback6)(void *, size_t, size_t, FILE *);
+
+/* evaluates to true if expr is of type curl_write_callback or "similar" */
+#define _curl_is_write_cb(expr)                                               \
+  (_curl_is_read_cb(expr) ||                                            \
+   __builtin_types_compatible_p(__typeof__(expr), __typeof__(fwrite)) ||      \
+   __builtin_types_compatible_p(__typeof__(expr), curl_write_callback) ||     \
+   _curl_callback_compatible((expr), _curl_write_callback1) ||                \
+   _curl_callback_compatible((expr), _curl_write_callback2) ||                \
+   _curl_callback_compatible((expr), _curl_write_callback3) ||                \
+   _curl_callback_compatible((expr), _curl_write_callback4) ||                \
+   _curl_callback_compatible((expr), _curl_write_callback5) ||                \
+   _curl_callback_compatible((expr), _curl_write_callback6))
+typedef size_t (_curl_write_callback1)(const char *, size_t, size_t, void *);
+typedef size_t (_curl_write_callback2)(const char *, size_t, size_t,
+                                       const void *);
+typedef size_t (_curl_write_callback3)(const char *, size_t, size_t, FILE *);
+typedef size_t (_curl_write_callback4)(const void *, size_t, size_t, void *);
+typedef size_t (_curl_write_callback5)(const void *, size_t, size_t,
+                                       const void *);
+typedef size_t (_curl_write_callback6)(const void *, size_t, size_t, FILE *);
+
+/* evaluates to true if expr is of type curl_ioctl_callback or "similar" */
+#define _curl_is_ioctl_cb(expr)                                         \
+  (_curl_is_NULL(expr) ||                                                     \
+   __builtin_types_compatible_p(__typeof__(expr), curl_ioctl_callback) ||     \
+   _curl_callback_compatible((expr), _curl_ioctl_callback1) ||                \
+   _curl_callback_compatible((expr), _curl_ioctl_callback2) ||                \
+   _curl_callback_compatible((expr), _curl_ioctl_callback3) ||                \
+   _curl_callback_compatible((expr), _curl_ioctl_callback4))
+typedef curlioerr (_curl_ioctl_callback1)(CURL *, int, void *);
+typedef curlioerr (_curl_ioctl_callback2)(CURL *, int, const void *);
+typedef curlioerr (_curl_ioctl_callback3)(CURL *, curliocmd, void *);
+typedef curlioerr (_curl_ioctl_callback4)(CURL *, curliocmd, const void *);
+
+/* evaluates to true if expr is of type curl_sockopt_callback or "similar" */
+#define _curl_is_sockopt_cb(expr)                                       \
+  (_curl_is_NULL(expr) ||                                                     \
+   __builtin_types_compatible_p(__typeof__(expr), curl_sockopt_callback) ||   \
+   _curl_callback_compatible((expr), _curl_sockopt_callback1) ||              \
+   _curl_callback_compatible((expr), _curl_sockopt_callback2))
+typedef int (_curl_sockopt_callback1)(void *, curl_socket_t, curlsocktype);
+typedef int (_curl_sockopt_callback2)(const void *, curl_socket_t,
+                                      curlsocktype);
+
+/* evaluates to true if expr is of type curl_opensocket_callback or
+   "similar" */
+#define _curl_is_opensocket_cb(expr)                                    \
+  (_curl_is_NULL(expr) ||                                                     \
+   __builtin_types_compatible_p(__typeof__(expr), curl_opensocket_callback) ||\
+   _curl_callback_compatible((expr), _curl_opensocket_callback1) ||           \
+   _curl_callback_compatible((expr), _curl_opensocket_callback2) ||           \
+   _curl_callback_compatible((expr), _curl_opensocket_callback3) ||           \
+   _curl_callback_compatible((expr), _curl_opensocket_callback4))
+typedef curl_socket_t (_curl_opensocket_callback1)
+  (void *, curlsocktype, struct curl_sockaddr *);
+typedef curl_socket_t (_curl_opensocket_callback2)
+  (void *, curlsocktype, const struct curl_sockaddr *);
+typedef curl_socket_t (_curl_opensocket_callback3)
+  (const void *, curlsocktype, struct curl_sockaddr *);
+typedef curl_socket_t (_curl_opensocket_callback4)
+  (const void *, curlsocktype, const struct curl_sockaddr *);
+
+/* evaluates to true if expr is of type curl_progress_callback or "similar" */
+#define _curl_is_progress_cb(expr)                                      \
+  (_curl_is_NULL(expr) ||                                                     \
+   __builtin_types_compatible_p(__typeof__(expr), curl_progress_callback) ||  \
+   _curl_callback_compatible((expr), _curl_progress_callback1) ||             \
+   _curl_callback_compatible((expr), _curl_progress_callback2))
+typedef int (_curl_progress_callback1)(void *,
+    double, double, double, double);
+typedef int (_curl_progress_callback2)(const void *,
+    double, double, double, double);
+
+/* evaluates to true if expr is of type curl_debug_callback or "similar" */
+#define _curl_is_debug_cb(expr)                                         \
+  (_curl_is_NULL(expr) ||                                                     \
+   __builtin_types_compatible_p(__typeof__(expr), curl_debug_callback) ||     \
+   _curl_callback_compatible((expr), _curl_debug_callback1) ||                \
+   _curl_callback_compatible((expr), _curl_debug_callback2) ||                \
+   _curl_callback_compatible((expr), _curl_debug_callback3) ||                \
+   _curl_callback_compatible((expr), _curl_debug_callback4) ||                \
+   _curl_callback_compatible((expr), _curl_debug_callback5) ||                \
+   _curl_callback_compatible((expr), _curl_debug_callback6) ||                \
+   _curl_callback_compatible((expr), _curl_debug_callback7) ||                \
+   _curl_callback_compatible((expr), _curl_debug_callback8))
+typedef int (_curl_debug_callback1) (CURL *,
+    curl_infotype, char *, size_t, void *);
+typedef int (_curl_debug_callback2) (CURL *,
+    curl_infotype, char *, size_t, const void *);
+typedef int (_curl_debug_callback3) (CURL *,
+    curl_infotype, const char *, size_t, void *);
+typedef int (_curl_debug_callback4) (CURL *,
+    curl_infotype, const char *, size_t, const void *);
+typedef int (_curl_debug_callback5) (CURL *,
+    curl_infotype, unsigned char *, size_t, void *);
+typedef int (_curl_debug_callback6) (CURL *,
+    curl_infotype, unsigned char *, size_t, const void *);
+typedef int (_curl_debug_callback7) (CURL *,
+    curl_infotype, const unsigned char *, size_t, void *);
+typedef int (_curl_debug_callback8) (CURL *,
+    curl_infotype, const unsigned char *, size_t, const void *);
+
+/* evaluates to true if expr is of type curl_ssl_ctx_callback or "similar" */
+/* this is getting even messier... */
+#define _curl_is_ssl_ctx_cb(expr)                                       \
+  (_curl_is_NULL(expr) ||                                                     \
+   __builtin_types_compatible_p(__typeof__(expr), curl_ssl_ctx_callback) ||   \
+   _curl_callback_compatible((expr), _curl_ssl_ctx_callback1) ||              \
+   _curl_callback_compatible((expr), _curl_ssl_ctx_callback2) ||              \
+   _curl_callback_compatible((expr), _curl_ssl_ctx_callback3) ||              \
+   _curl_callback_compatible((expr), _curl_ssl_ctx_callback4) ||              \
+   _curl_callback_compatible((expr), _curl_ssl_ctx_callback5) ||              \
+   _curl_callback_compatible((expr), _curl_ssl_ctx_callback6) ||              \
+   _curl_callback_compatible((expr), _curl_ssl_ctx_callback7) ||              \
+   _curl_callback_compatible((expr), _curl_ssl_ctx_callback8))
+typedef CURLcode (_curl_ssl_ctx_callback1)(CURL *, void *, void *);
+typedef CURLcode (_curl_ssl_ctx_callback2)(CURL *, void *, const void *);
+typedef CURLcode (_curl_ssl_ctx_callback3)(CURL *, const void *, void *);
+typedef CURLcode (_curl_ssl_ctx_callback4)(CURL *, const void *, const void *);
+#ifdef HEADER_SSL_H
+/* hack: if we included OpenSSL's ssl.h, we know about SSL_CTX
+ * this will of course break if we're included before OpenSSL headers...
+ */
+typedef CURLcode (_curl_ssl_ctx_callback5)(CURL *, SSL_CTX, void *);
+typedef CURLcode (_curl_ssl_ctx_callback6)(CURL *, SSL_CTX, const void *);
+typedef CURLcode (_curl_ssl_ctx_callback7)(CURL *, const SSL_CTX, void *);
+typedef CURLcode (_curl_ssl_ctx_callback8)(CURL *, const SSL_CTX,
+                                           const void *);
+#else
+typedef _curl_ssl_ctx_callback1 _curl_ssl_ctx_callback5;
+typedef _curl_ssl_ctx_callback1 _curl_ssl_ctx_callback6;
+typedef _curl_ssl_ctx_callback1 _curl_ssl_ctx_callback7;
+typedef _curl_ssl_ctx_callback1 _curl_ssl_ctx_callback8;
+#endif
+
+/* evaluates to true if expr is of type curl_conv_callback or "similar" */
+#define _curl_is_conv_cb(expr)                                          \
+  (_curl_is_NULL(expr) ||                                                     \
+   __builtin_types_compatible_p(__typeof__(expr), curl_conv_callback) ||      \
+   _curl_callback_compatible((expr), _curl_conv_callback1) ||                 \
+   _curl_callback_compatible((expr), _curl_conv_callback2) ||                 \
+   _curl_callback_compatible((expr), _curl_conv_callback3) ||                 \
+   _curl_callback_compatible((expr), _curl_conv_callback4))
+typedef CURLcode (*_curl_conv_callback1)(char *, size_t length);
+typedef CURLcode (*_curl_conv_callback2)(const char *, size_t length);
+typedef CURLcode (*_curl_conv_callback3)(void *, size_t length);
+typedef CURLcode (*_curl_conv_callback4)(const void *, size_t length);
+
+/* evaluates to true if expr is of type curl_seek_callback or "similar" */
+#define _curl_is_seek_cb(expr)                                          \
+  (_curl_is_NULL(expr) ||                                                     \
+   __builtin_types_compatible_p(__typeof__(expr), curl_seek_callback) ||      \
+   _curl_callback_compatible((expr), _curl_seek_callback1) ||                 \
+   _curl_callback_compatible((expr), _curl_seek_callback2))
+typedef CURLcode (*_curl_seek_callback1)(void *, curl_off_t, int);
+typedef CURLcode (*_curl_seek_callback2)(const void *, curl_off_t, int);
+
+
+#endif /* __CURL_TYPECHECK_GCC_H */
diff --git a/src/include/libcef/base/cef_atomic_ref_count.h b/src/include/libcef/base/cef_atomic_ref_count.h
new file mode 100644
index 0000000..b6c2f6e
--- /dev/null
+++ b/src/include/libcef/base/cef_atomic_ref_count.h
@@ -0,0 +1,126 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2011
+// Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// This is a low level implementation of atomic semantics for reference
+// counting.  Please use cef_ref_counted.h directly instead.
+//
+// The Chromium implementation includes annotations to avoid some false
+// positives when using data race detection tools. Annotations are not
+// currently supported by the CEF implementation.
+
+#ifndef CEF_INCLUDE_BASE_CEF_ATOMIC_REF_COUNT_H_
+#define CEF_INCLUDE_BASE_CEF_ATOMIC_REF_COUNT_H_
+#pragma once
+
+#if defined(BASE_ATOMIC_REF_COUNT_H_)
+// Do nothing if the Chromium header has already been included.
+// This can happen in cases where Chromium code is used directly by the
+// client application. When using Chromium code directly always include
+// the Chromium header first to avoid type conflicts.
+#elif defined(USING_CHROMIUM_INCLUDES)
+// When building CEF include the Chromium header directly.
+#include "base/atomic_ref_count.h"
+#else  // !USING_CHROMIUM_INCLUDES
+// The following is substantially similar to the Chromium implementation.
+// If the Chromium implementation diverges the below implementation should be
+// updated to match.
+
+#include "libcef/base/cef_atomicops.h"
+
+// Annotations are not currently supported.
+#define ANNOTATE_HAPPENS_BEFORE(obj) /* empty */
+#define ANNOTATE_HAPPENS_AFTER(obj) /* empty */
+
+namespace base {
+
+typedef subtle::Atomic32 AtomicRefCount;
+
+// Increment a reference count by "increment", which must exceed 0.
+inline void AtomicRefCountIncN(volatile AtomicRefCount *ptr,
+                               AtomicRefCount increment) {
+  subtle::NoBarrier_AtomicIncrement(ptr, increment);
+}
+
+// Decrement a reference count by "decrement", which must exceed 0,
+// and return whether the result is non-zero.
+// Insert barriers to ensure that state written before the reference count
+// became zero will be visible to a thread that has just made the count zero.
+inline bool AtomicRefCountDecN(volatile AtomicRefCount *ptr,
+                               AtomicRefCount decrement) {
+  ANNOTATE_HAPPENS_BEFORE(ptr);
+  bool res = (subtle::Barrier_AtomicIncrement(ptr, -decrement) != 0);
+  if (!res) {
+    ANNOTATE_HAPPENS_AFTER(ptr);
+  }
+  return res;
+}
+
+// Increment a reference count by 1.
+inline void AtomicRefCountInc(volatile AtomicRefCount *ptr) {
+  base::AtomicRefCountIncN(ptr, 1);
+}
+
+// Decrement a reference count by 1 and return whether the result is non-zero.
+// Insert barriers to ensure that state written before the reference count
+// became zero will be visible to a thread that has just made the count zero.
+inline bool AtomicRefCountDec(volatile AtomicRefCount *ptr) {
+  return base::AtomicRefCountDecN(ptr, 1);
+}
+
+// Return whether the reference count is one.  If the reference count is used
+// in the conventional way, a refrerence count of 1 implies that the current
+// thread owns the reference and no other thread shares it.  This call performs
+// the test for a reference count of one, and performs the memory barrier
+// needed for the owning thread to act on the object, knowing that it has
+// exclusive access to the object.
+inline bool AtomicRefCountIsOne(volatile AtomicRefCount *ptr) {
+  bool res = (subtle::Acquire_Load(ptr) == 1);
+  if (res) {
+    ANNOTATE_HAPPENS_AFTER(ptr);
+  }
+  return res;
+}
+
+// Return whether the reference count is zero.  With conventional object
+// referencing counting, the object will be destroyed, so the reference count
+// should never be zero.  Hence this is generally used for a debug check.
+inline bool AtomicRefCountIsZero(volatile AtomicRefCount *ptr) {
+  bool res = (subtle::Acquire_Load(ptr) == 0);
+  if (res) {
+    ANNOTATE_HAPPENS_AFTER(ptr);
+  }
+  return res;
+}
+
+}  // namespace base
+
+#endif  // !USING_CHROMIUM_INCLUDES
+
+#endif  // CEF_INCLUDE_BASE_CEF_ATOMIC_REF_COUNT_H_
diff --git a/src/include/libcef/base/cef_atomicops.h b/src/include/libcef/base/cef_atomicops.h
new file mode 100644
index 0000000..2d0ec5e
--- /dev/null
+++ b/src/include/libcef/base/cef_atomicops.h
@@ -0,0 +1,198 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2012
+// Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// For atomic operations on reference counts, see cef_atomic_ref_count.h.
+
+// The routines exported by this module are subtle.  If you use them, even if
+// you get the code right, it will depend on careful reasoning about atomicity
+// and memory ordering; it will be less readable, and harder to maintain.  If
+// you plan to use these routines, you should have a good reason, such as solid
+// evidence that performance would otherwise suffer, or there being no
+// alternative.  You should assume only properties explicitly guaranteed by the
+// specifications in this file.  You are almost certainly _not_ writing code
+// just for the x86; if you assume x86 semantics, x86 hardware bugs and
+// implementations on other archtectures will cause your code to break.  If you
+// do not know what you are doing, avoid these routines, and use a Mutex.
+//
+// It is incorrect to make direct assignments to/from an atomic variable.
+// You should use one of the Load or Store routines.  The NoBarrier
+// versions are provided when no barriers are needed:
+//   NoBarrier_Store()
+//   NoBarrier_Load()
+// Although there are currently no compiler enforcement, you are encouraged
+// to use these.
+//
+
+#ifndef CEF_INCLUDE_BASE_CEF_ATOMICOPS_H_
+#define CEF_INCLUDE_BASE_CEF_ATOMICOPS_H_
+#pragma once
+
+#if defined(BASE_ATOMICOPS_H_)
+// Do nothing if the Chromium header has already been included.
+// This can happen in cases where Chromium code is used directly by the
+// client application. When using Chromium code directly always include
+// the Chromium header first to avoid type conflicts.
+#elif defined(USING_CHROMIUM_INCLUDES)
+// When building CEF include the Chromium header directly.
+#include "base/atomicops.h"
+#else  // !USING_CHROMIUM_INCLUDES
+// The following is substantially similar to the Chromium implementation.
+// If the Chromium implementation diverges the below implementation should be
+// updated to match.
+
+#include <stdint.h>
+
+#include "libcef/base/cef_build.h"
+
+#if defined(OS_WIN) && defined(ARCH_CPU_64_BITS)
+// windows.h #defines this (only on x64). This causes problems because the
+// public API also uses MemoryBarrier at the public name for this fence. So, on
+// X64, undef it, and call its documented
+// (http://msdn.microsoft.com/en-us/library/windows/desktop/ms684208.aspx)
+// implementation directly.
+#undef MemoryBarrier
+#endif
+
+namespace base {
+namespace subtle {
+
+typedef int32_t Atomic32;
+#ifdef ARCH_CPU_64_BITS
+// We need to be able to go between Atomic64 and AtomicWord implicitly.  This
+// means Atomic64 and AtomicWord should be the same type on 64-bit.
+#if defined(__ILP32__) || defined(OS_NACL)
+// NaCl's intptr_t is not actually 64-bits on 64-bit!
+// http://code.google.com/p/nativeclient/issues/detail?id=1162
+typedef int64_t Atomic64;
+#else
+typedef intptr_t Atomic64;
+#endif
+#endif
+
+// Use AtomicWord for a machine-sized pointer.  It will use the Atomic32 or
+// Atomic64 routines below, depending on your architecture.
+typedef intptr_t AtomicWord;
+
+// Atomically execute:
+//      result = *ptr;
+//      if (*ptr == old_value)
+//        *ptr = new_value;
+//      return result;
+//
+// I.e., replace "*ptr" with "new_value" if "*ptr" used to be "old_value".
+// Always return the old value of "*ptr"
+//
+// This routine implies no memory barriers.
+Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr,
+                                  Atomic32 old_value,
+                                  Atomic32 new_value);
+
+// Atomically store new_value into *ptr, returning the previous value held in
+// *ptr.  This routine implies no memory barriers.
+Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr, Atomic32 new_value);
+
+// Atomically increment *ptr by "increment".  Returns the new value of
+// *ptr with the increment applied.  This routine implies no memory barriers.
+Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr, Atomic32 increment);
+
+Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr,
+                                 Atomic32 increment);
+
+// These following lower-level operations are typically useful only to people
+// implementing higher-level synchronization operations like spinlocks,
+// mutexes, and condition-variables.  They combine CompareAndSwap(), a load, or
+// a store with appropriate memory-ordering instructions.  "Acquire" operations
+// ensure that no later memory access can be reordered ahead of the operation.
+// "Release" operations ensure that no previous memory access can be reordered
+// after the operation.  "Barrier" operations have both "Acquire" and "Release"
+// semantics.   A MemoryBarrier() has "Barrier" semantics, but does no memory
+// access.
+Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr,
+                                Atomic32 old_value,
+                                Atomic32 new_value);
+Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr,
+                                Atomic32 old_value,
+                                Atomic32 new_value);
+
+void MemoryBarrier();
+void NoBarrier_Store(volatile Atomic32* ptr, Atomic32 value);
+void Acquire_Store(volatile Atomic32* ptr, Atomic32 value);
+void Release_Store(volatile Atomic32* ptr, Atomic32 value);
+
+Atomic32 NoBarrier_Load(volatile const Atomic32* ptr);
+Atomic32 Acquire_Load(volatile const Atomic32* ptr);
+Atomic32 Release_Load(volatile const Atomic32* ptr);
+
+// 64-bit atomic operations (only available on 64-bit processors).
+#ifdef ARCH_CPU_64_BITS
+Atomic64 NoBarrier_CompareAndSwap(volatile Atomic64* ptr,
+                                  Atomic64 old_value,
+                                  Atomic64 new_value);
+Atomic64 NoBarrier_AtomicExchange(volatile Atomic64* ptr, Atomic64 new_value);
+Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64* ptr, Atomic64 increment);
+Atomic64 Barrier_AtomicIncrement(volatile Atomic64* ptr, Atomic64 increment);
+
+Atomic64 Acquire_CompareAndSwap(volatile Atomic64* ptr,
+                                Atomic64 old_value,
+                                Atomic64 new_value);
+Atomic64 Release_CompareAndSwap(volatile Atomic64* ptr,
+                                Atomic64 old_value,
+                                Atomic64 new_value);
+void NoBarrier_Store(volatile Atomic64* ptr, Atomic64 value);
+void Acquire_Store(volatile Atomic64* ptr, Atomic64 value);
+void Release_Store(volatile Atomic64* ptr, Atomic64 value);
+Atomic64 NoBarrier_Load(volatile const Atomic64* ptr);
+Atomic64 Acquire_Load(volatile const Atomic64* ptr);
+Atomic64 Release_Load(volatile const Atomic64* ptr);
+#endif  // ARCH_CPU_64_BITS
+
+}  // namespace subtle
+}  // namespace base
+
+// Include our platform specific implementation.
+#if defined(OS_WIN) && defined(COMPILER_MSVC) && defined(ARCH_CPU_X86_FAMILY)
+    #include "libcef/base/internal/cef_atomicops_x86_msvc.h"
+#elif defined(OS_MACOSX)
+    #include "libcef/base/internal/cef_atomicops_mac.h"
+#elif defined(COMPILER_GCC) && defined(ARCH_CPU_X86_FAMILY)
+    #include "libcef/base/internal/cef_atomicops_x86_gcc.h"
+#else
+    #error "Atomic operations are not supported on your platform"
+#endif
+
+// On some platforms we need additional declarations to make
+// AtomicWord compatible with our other Atomic* types.
+#if defined(OS_MACOSX) || defined(OS_OPENBSD)
+    #include "libcef/base/internal/cef_atomicops_atomicword_compat.h"
+#endif
+
+#endif  // !USING_CHROMIUM_INCLUDES
+
+#endif  // CEF_INCLUDE_BASE_CEF_ATOMICOPS_H_
diff --git a/src/include/libcef/base/cef_basictypes.h b/src/include/libcef/base/cef_basictypes.h
new file mode 100644
index 0000000..128cd3f
--- /dev/null
+++ b/src/include/libcef/base/cef_basictypes.h
@@ -0,0 +1,77 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2012
+// Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef CEF_INCLUDE_BASE_CEF_BASICTYPES_H_
+#define CEF_INCLUDE_BASE_CEF_BASICTYPES_H_
+#pragma once
+
+#include <limits.h>         // For UINT_MAX
+#include <stddef.h>         // For size_t
+
+#include "libcef/base/cef_build.h"
+
+// The NSPR system headers define 64-bit as |long| when possible, except on
+// Mac OS X.  In order to not have typedef mismatches, we do the same on LP64.
+//
+// On Mac OS X, |long long| is used for 64-bit types for compatibility with
+// <inttypes.h> format macros even in the LP64 model.
+#if defined(__LP64__) && !defined(OS_MACOSX) && !defined(OS_OPENBSD)
+typedef long                int64;  // NOLINT(runtime/int)
+typedef unsigned long       uint64;  // NOLINT(runtime/int)
+#else
+typedef long long           int64;  // NOLINT(runtime/int)
+typedef unsigned long long  uint64;  // NOLINT(runtime/int)
+#endif
+
+// TODO: Remove these type guards.  These are to avoid conflicts with
+// obsolete/protypes.h in the Gecko SDK.
+#ifndef _INT32
+#define _INT32
+typedef int                 int32;
+#endif
+
+// TODO: Remove these type guards.  These are to avoid conflicts with
+// obsolete/protypes.h in the Gecko SDK.
+#ifndef _UINT32
+#define _UINT32
+typedef unsigned int       uint32;
+#endif
+
+// UTF-16 character type.
+// This should be kept synchronized with base/strings/string16.h
+#ifndef char16
+#if defined(WCHAR_T_IS_UTF16)
+typedef wchar_t             char16;
+#elif defined(WCHAR_T_IS_UTF32)
+typedef unsigned short      char16;
+#endif
+#endif
+
+#endif  // CEF_INCLUDE_BASE_CEF_BASICTYPES_H_
diff --git a/src/include/libcef/base/cef_bind.h b/src/include/libcef/base/cef_bind.h
new file mode 100644
index 0000000..2017a95
--- /dev/null
+++ b/src/include/libcef/base/cef_bind.h
@@ -0,0 +1,548 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2011
+// Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef CEF_INCLUDE_BASE_CEF_BIND_H_
+#define CEF_INCLUDE_BASE_CEF_BIND_H_
+#pragma once
+
+#if defined(BASE_BIND_H_)
+// Do nothing if the Chromium header has already been included.
+// This can happen in cases where Chromium code is used directly by the
+// client application. When using Chromium code directly always include
+// the Chromium header first to avoid type conflicts.
+#elif defined(USING_CHROMIUM_INCLUDES)
+// When building CEF include the Chromium header directly.
+#include "base/bind.h"
+#else  // !USING_CHROMIUM_INCLUDES
+// The following is substantially similar to the Chromium implementation.
+// If the Chromium implementation diverges the below implementation should be
+// updated to match.
+
+#include "libcef/base/internal/cef_bind_internal.h"
+#include "libcef/base/internal/cef_callback_internal.h"
+
+// -----------------------------------------------------------------------------
+// Usage documentation
+// -----------------------------------------------------------------------------
+//
+// See base/cef_callback.h for documentation.
+//
+//
+// -----------------------------------------------------------------------------
+// Implementation notes
+// -----------------------------------------------------------------------------
+//
+// If you're reading the implementation, before proceeding further, you should
+// read the top comment of base/bind_internal.h for a definition of common
+// terms and concepts.
+//
+// RETURN TYPES
+//
+// Though Bind()'s result is meant to be stored in a Callback<> type, it
+// cannot actually return the exact type without requiring a large amount
+// of extra template specializations. The problem is that in order to
+// discern the correct specialization of Callback<>, Bind would need to
+// unwrap the function signature to determine the signature's arity, and
+// whether or not it is a method.
+//
+// Each unique combination of (arity, function_type, num_prebound) where
+// function_type is one of {function, method, const_method} would require
+// one specialization.  We eventually have to do a similar number of
+// specializations anyways in the implementation (see the Invoker<>,
+// classes).  However, it is avoidable in Bind if we return the result
+// via an indirection like we do below.
+//
+// TODO(ajwong): We might be able to avoid this now, but need to test.
+//
+// It is possible to move most of the COMPILE_ASSERT asserts into BindState<>,
+// but it feels a little nicer to have the asserts here so people do not
+// need to crack open bind_internal.h.  On the other hand, it makes Bind()
+// harder to read.
+
+namespace base {
+
+template <typename Functor>
+base::Callback<
+    typename cef_internal::BindState<
+        typename cef_internal::FunctorTraits<Functor>::RunnableType,
+        typename cef_internal::FunctorTraits<Functor>::RunType,
+        void()>
+            ::UnboundRunType>
+Bind(Functor functor) {
+  // Typedefs for how to store and run the functor.
+  typedef typename cef_internal::FunctorTraits<Functor>::RunnableType RunnableType;
+  typedef typename cef_internal::FunctorTraits<Functor>::RunType RunType;
+
+  typedef cef_internal::BindState<RunnableType, RunType, void()> BindState;
+
+
+  return Callback<typename BindState::UnboundRunType>(
+      new BindState(cef_internal::MakeRunnable(functor)));
+}
+
+template <typename Functor, typename P1>
+base::Callback<
+    typename cef_internal::BindState<
+        typename cef_internal::FunctorTraits<Functor>::RunnableType,
+        typename cef_internal::FunctorTraits<Functor>::RunType,
+        void(typename cef_internal::CallbackParamTraits<P1>::StorageType)>
+            ::UnboundRunType>
+Bind(Functor functor, const P1& p1) {
+  // Typedefs for how to store and run the functor.
+  typedef typename cef_internal::FunctorTraits<Functor>::RunnableType RunnableType;
+  typedef typename cef_internal::FunctorTraits<Functor>::RunType RunType;
+
+  // Use RunnableType::RunType instead of RunType above because our
+  // checks should below for bound references need to know what the actual
+  // functor is going to interpret the argument as.
+  typedef cef_internal::FunctionTraits<typename RunnableType::RunType>
+      BoundFunctorTraits;
+
+  // Do not allow binding a non-const reference parameter. Non-const reference
+  // parameters are disallowed by the Google style guide.  Also, binding a
+  // non-const reference parameter can make for subtle bugs because the
+  // invoked function will receive a reference to the stored copy of the
+  // argument and not the original.
+  COMPILE_ASSERT(
+      !(is_non_const_reference<typename BoundFunctorTraits::A1Type>::value ),
+      do_not_bind_functions_with_nonconst_ref);
+
+  // For methods, we need to be careful for parameter 1.  We do not require
+  // a scoped_refptr because BindState<> itself takes care of AddRef() for
+  // methods. We also disallow binding of an array as the method's target
+  // object.
+  COMPILE_ASSERT(
+      cef_internal::HasIsMethodTag<RunnableType>::value ||
+          !cef_internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
+      p1_is_refcounted_type_and_needs_scoped_refptr);
+  COMPILE_ASSERT(!cef_internal::HasIsMethodTag<RunnableType>::value ||
+                     !is_array<P1>::value,
+                 first_bound_argument_to_method_cannot_be_array);
+  typedef cef_internal::BindState<RunnableType, RunType,
+      void(typename cef_internal::CallbackParamTraits<P1>::StorageType)> BindState;
+
+
+  return Callback<typename BindState::UnboundRunType>(
+      new BindState(cef_internal::MakeRunnable(functor), p1));
+}
+
+template <typename Functor, typename P1, typename P2>
+base::Callback<
+    typename cef_internal::BindState<
+        typename cef_internal::FunctorTraits<Functor>::RunnableType,
+        typename cef_internal::FunctorTraits<Functor>::RunType,
+        void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
+            typename cef_internal::CallbackParamTraits<P2>::StorageType)>
+            ::UnboundRunType>
+Bind(Functor functor, const P1& p1, const P2& p2) {
+  // Typedefs for how to store and run the functor.
+  typedef typename cef_internal::FunctorTraits<Functor>::RunnableType RunnableType;
+  typedef typename cef_internal::FunctorTraits<Functor>::RunType RunType;
+
+  // Use RunnableType::RunType instead of RunType above because our
+  // checks should below for bound references need to know what the actual
+  // functor is going to interpret the argument as.
+  typedef cef_internal::FunctionTraits<typename RunnableType::RunType>
+      BoundFunctorTraits;
+
+  // Do not allow binding a non-const reference parameter. Non-const reference
+  // parameters are disallowed by the Google style guide.  Also, binding a
+  // non-const reference parameter can make for subtle bugs because the
+  // invoked function will receive a reference to the stored copy of the
+  // argument and not the original.
+  COMPILE_ASSERT(
+      !(is_non_const_reference<typename BoundFunctorTraits::A1Type>::value ||
+          is_non_const_reference<typename BoundFunctorTraits::A2Type>::value ),
+      do_not_bind_functions_with_nonconst_ref);
+
+  // For methods, we need to be careful for parameter 1.  We do not require
+  // a scoped_refptr because BindState<> itself takes care of AddRef() for
+  // methods. We also disallow binding of an array as the method's target
+  // object.
+  COMPILE_ASSERT(
+      cef_internal::HasIsMethodTag<RunnableType>::value ||
+          !cef_internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
+      p1_is_refcounted_type_and_needs_scoped_refptr);
+  COMPILE_ASSERT(!cef_internal::HasIsMethodTag<RunnableType>::value ||
+                     !is_array<P1>::value,
+                 first_bound_argument_to_method_cannot_be_array);
+  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
+                 p2_is_refcounted_type_and_needs_scoped_refptr);
+  typedef cef_internal::BindState<RunnableType, RunType,
+      void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
+      typename cef_internal::CallbackParamTraits<P2>::StorageType)> BindState;
+
+
+  return Callback<typename BindState::UnboundRunType>(
+      new BindState(cef_internal::MakeRunnable(functor), p1, p2));
+}
+
+template <typename Functor, typename P1, typename P2, typename P3>
+base::Callback<
+    typename cef_internal::BindState<
+        typename cef_internal::FunctorTraits<Functor>::RunnableType,
+        typename cef_internal::FunctorTraits<Functor>::RunType,
+        void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
+            typename cef_internal::CallbackParamTraits<P2>::StorageType,
+            typename cef_internal::CallbackParamTraits<P3>::StorageType)>
+            ::UnboundRunType>
+Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3) {
+  // Typedefs for how to store and run the functor.
+  typedef typename cef_internal::FunctorTraits<Functor>::RunnableType RunnableType;
+  typedef typename cef_internal::FunctorTraits<Functor>::RunType RunType;
+
+  // Use RunnableType::RunType instead of RunType above because our
+  // checks should below for bound references need to know what the actual
+  // functor is going to interpret the argument as.
+  typedef cef_internal::FunctionTraits<typename RunnableType::RunType>
+      BoundFunctorTraits;
+
+  // Do not allow binding a non-const reference parameter. Non-const reference
+  // parameters are disallowed by the Google style guide.  Also, binding a
+  // non-const reference parameter can make for subtle bugs because the
+  // invoked function will receive a reference to the stored copy of the
+  // argument and not the original.
+  COMPILE_ASSERT(
+      !(is_non_const_reference<typename BoundFunctorTraits::A1Type>::value ||
+          is_non_const_reference<typename BoundFunctorTraits::A2Type>::value ||
+          is_non_const_reference<typename BoundFunctorTraits::A3Type>::value ),
+      do_not_bind_functions_with_nonconst_ref);
+
+  // For methods, we need to be careful for parameter 1.  We do not require
+  // a scoped_refptr because BindState<> itself takes care of AddRef() for
+  // methods. We also disallow binding of an array as the method's target
+  // object.
+  COMPILE_ASSERT(
+      cef_internal::HasIsMethodTag<RunnableType>::value ||
+          !cef_internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
+      p1_is_refcounted_type_and_needs_scoped_refptr);
+  COMPILE_ASSERT(!cef_internal::HasIsMethodTag<RunnableType>::value ||
+                     !is_array<P1>::value,
+                 first_bound_argument_to_method_cannot_be_array);
+  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
+                 p2_is_refcounted_type_and_needs_scoped_refptr);
+  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P3>::value,
+                 p3_is_refcounted_type_and_needs_scoped_refptr);
+  typedef cef_internal::BindState<RunnableType, RunType,
+      void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
+      typename cef_internal::CallbackParamTraits<P2>::StorageType,
+      typename cef_internal::CallbackParamTraits<P3>::StorageType)> BindState;
+
+
+  return Callback<typename BindState::UnboundRunType>(
+      new BindState(cef_internal::MakeRunnable(functor), p1, p2, p3));
+}
+
+template <typename Functor, typename P1, typename P2, typename P3, typename P4>
+base::Callback<
+    typename cef_internal::BindState<
+        typename cef_internal::FunctorTraits<Functor>::RunnableType,
+        typename cef_internal::FunctorTraits<Functor>::RunType,
+        void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
+            typename cef_internal::CallbackParamTraits<P2>::StorageType,
+            typename cef_internal::CallbackParamTraits<P3>::StorageType,
+            typename cef_internal::CallbackParamTraits<P4>::StorageType)>
+            ::UnboundRunType>
+Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
+  // Typedefs for how to store and run the functor.
+  typedef typename cef_internal::FunctorTraits<Functor>::RunnableType RunnableType;
+  typedef typename cef_internal::FunctorTraits<Functor>::RunType RunType;
+
+  // Use RunnableType::RunType instead of RunType above because our
+  // checks should below for bound references need to know what the actual
+  // functor is going to interpret the argument as.
+  typedef cef_internal::FunctionTraits<typename RunnableType::RunType>
+      BoundFunctorTraits;
+
+  // Do not allow binding a non-const reference parameter. Non-const reference
+  // parameters are disallowed by the Google style guide.  Also, binding a
+  // non-const reference parameter can make for subtle bugs because the
+  // invoked function will receive a reference to the stored copy of the
+  // argument and not the original.
+  COMPILE_ASSERT(
+      !(is_non_const_reference<typename BoundFunctorTraits::A1Type>::value ||
+          is_non_const_reference<typename BoundFunctorTraits::A2Type>::value ||
+          is_non_const_reference<typename BoundFunctorTraits::A3Type>::value ||
+          is_non_const_reference<typename BoundFunctorTraits::A4Type>::value ),
+      do_not_bind_functions_with_nonconst_ref);
+
+  // For methods, we need to be careful for parameter 1.  We do not require
+  // a scoped_refptr because BindState<> itself takes care of AddRef() for
+  // methods. We also disallow binding of an array as the method's target
+  // object.
+  COMPILE_ASSERT(
+      cef_internal::HasIsMethodTag<RunnableType>::value ||
+          !cef_internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
+      p1_is_refcounted_type_and_needs_scoped_refptr);
+  COMPILE_ASSERT(!cef_internal::HasIsMethodTag<RunnableType>::value ||
+                     !is_array<P1>::value,
+                 first_bound_argument_to_method_cannot_be_array);
+  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
+                 p2_is_refcounted_type_and_needs_scoped_refptr);
+  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P3>::value,
+                 p3_is_refcounted_type_and_needs_scoped_refptr);
+  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P4>::value,
+                 p4_is_refcounted_type_and_needs_scoped_refptr);
+  typedef cef_internal::BindState<RunnableType, RunType,
+      void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
+      typename cef_internal::CallbackParamTraits<P2>::StorageType,
+      typename cef_internal::CallbackParamTraits<P3>::StorageType,
+      typename cef_internal::CallbackParamTraits<P4>::StorageType)> BindState;
+
+
+  return Callback<typename BindState::UnboundRunType>(
+      new BindState(cef_internal::MakeRunnable(functor), p1, p2, p3, p4));
+}
+
+template <typename Functor, typename P1, typename P2, typename P3, typename P4,
+    typename P5>
+base::Callback<
+    typename cef_internal::BindState<
+        typename cef_internal::FunctorTraits<Functor>::RunnableType,
+        typename cef_internal::FunctorTraits<Functor>::RunType,
+        void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
+            typename cef_internal::CallbackParamTraits<P2>::StorageType,
+            typename cef_internal::CallbackParamTraits<P3>::StorageType,
+            typename cef_internal::CallbackParamTraits<P4>::StorageType,
+            typename cef_internal::CallbackParamTraits<P5>::StorageType)>
+            ::UnboundRunType>
+Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4,
+    const P5& p5) {
+  // Typedefs for how to store and run the functor.
+  typedef typename cef_internal::FunctorTraits<Functor>::RunnableType RunnableType;
+  typedef typename cef_internal::FunctorTraits<Functor>::RunType RunType;
+
+  // Use RunnableType::RunType instead of RunType above because our
+  // checks should below for bound references need to know what the actual
+  // functor is going to interpret the argument as.
+  typedef cef_internal::FunctionTraits<typename RunnableType::RunType>
+      BoundFunctorTraits;
+
+  // Do not allow binding a non-const reference parameter. Non-const reference
+  // parameters are disallowed by the Google style guide.  Also, binding a
+  // non-const reference parameter can make for subtle bugs because the
+  // invoked function will receive a reference to the stored copy of the
+  // argument and not the original.
+  COMPILE_ASSERT(
+      !(is_non_const_reference<typename BoundFunctorTraits::A1Type>::value ||
+          is_non_const_reference<typename BoundFunctorTraits::A2Type>::value ||
+          is_non_const_reference<typename BoundFunctorTraits::A3Type>::value ||
+          is_non_const_reference<typename BoundFunctorTraits::A4Type>::value ||
+          is_non_const_reference<typename BoundFunctorTraits::A5Type>::value ),
+      do_not_bind_functions_with_nonconst_ref);
+
+  // For methods, we need to be careful for parameter 1.  We do not require
+  // a scoped_refptr because BindState<> itself takes care of AddRef() for
+  // methods. We also disallow binding of an array as the method's target
+  // object.
+  COMPILE_ASSERT(
+      cef_internal::HasIsMethodTag<RunnableType>::value ||
+          !cef_internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
+      p1_is_refcounted_type_and_needs_scoped_refptr);
+  COMPILE_ASSERT(!cef_internal::HasIsMethodTag<RunnableType>::value ||
+                     !is_array<P1>::value,
+                 first_bound_argument_to_method_cannot_be_array);
+  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
+                 p2_is_refcounted_type_and_needs_scoped_refptr);
+  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P3>::value,
+                 p3_is_refcounted_type_and_needs_scoped_refptr);
+  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P4>::value,
+                 p4_is_refcounted_type_and_needs_scoped_refptr);
+  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P5>::value,
+                 p5_is_refcounted_type_and_needs_scoped_refptr);
+  typedef cef_internal::BindState<RunnableType, RunType,
+      void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
+      typename cef_internal::CallbackParamTraits<P2>::StorageType,
+      typename cef_internal::CallbackParamTraits<P3>::StorageType,
+      typename cef_internal::CallbackParamTraits<P4>::StorageType,
+      typename cef_internal::CallbackParamTraits<P5>::StorageType)> BindState;
+
+
+  return Callback<typename BindState::UnboundRunType>(
+      new BindState(cef_internal::MakeRunnable(functor), p1, p2, p3, p4, p5));
+}
+
+template <typename Functor, typename P1, typename P2, typename P3, typename P4,
+    typename P5, typename P6>
+base::Callback<
+    typename cef_internal::BindState<
+        typename cef_internal::FunctorTraits<Functor>::RunnableType,
+        typename cef_internal::FunctorTraits<Functor>::RunType,
+        void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
+            typename cef_internal::CallbackParamTraits<P2>::StorageType,
+            typename cef_internal::CallbackParamTraits<P3>::StorageType,
+            typename cef_internal::CallbackParamTraits<P4>::StorageType,
+            typename cef_internal::CallbackParamTraits<P5>::StorageType,
+            typename cef_internal::CallbackParamTraits<P6>::StorageType)>
+            ::UnboundRunType>
+Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4,
+    const P5& p5, const P6& p6) {
+  // Typedefs for how to store and run the functor.
+  typedef typename cef_internal::FunctorTraits<Functor>::RunnableType RunnableType;
+  typedef typename cef_internal::FunctorTraits<Functor>::RunType RunType;
+
+  // Use RunnableType::RunType instead of RunType above because our
+  // checks should below for bound references need to know what the actual
+  // functor is going to interpret the argument as.
+  typedef cef_internal::FunctionTraits<typename RunnableType::RunType>
+      BoundFunctorTraits;
+
+  // Do not allow binding a non-const reference parameter. Non-const reference
+  // parameters are disallowed by the Google style guide.  Also, binding a
+  // non-const reference parameter can make for subtle bugs because the
+  // invoked function will receive a reference to the stored copy of the
+  // argument and not the original.
+  COMPILE_ASSERT(
+      !(is_non_const_reference<typename BoundFunctorTraits::A1Type>::value ||
+          is_non_const_reference<typename BoundFunctorTraits::A2Type>::value ||
+          is_non_const_reference<typename BoundFunctorTraits::A3Type>::value ||
+          is_non_const_reference<typename BoundFunctorTraits::A4Type>::value ||
+          is_non_const_reference<typename BoundFunctorTraits::A5Type>::value ||
+          is_non_const_reference<typename BoundFunctorTraits::A6Type>::value ),
+      do_not_bind_functions_with_nonconst_ref);
+
+  // For methods, we need to be careful for parameter 1.  We do not require
+  // a scoped_refptr because BindState<> itself takes care of AddRef() for
+  // methods. We also disallow binding of an array as the method's target
+  // object.
+  COMPILE_ASSERT(
+      cef_internal::HasIsMethodTag<RunnableType>::value ||
+          !cef_internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
+      p1_is_refcounted_type_and_needs_scoped_refptr);
+  COMPILE_ASSERT(!cef_internal::HasIsMethodTag<RunnableType>::value ||
+                     !is_array<P1>::value,
+                 first_bound_argument_to_method_cannot_be_array);
+  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
+                 p2_is_refcounted_type_and_needs_scoped_refptr);
+  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P3>::value,
+                 p3_is_refcounted_type_and_needs_scoped_refptr);
+  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P4>::value,
+                 p4_is_refcounted_type_and_needs_scoped_refptr);
+  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P5>::value,
+                 p5_is_refcounted_type_and_needs_scoped_refptr);
+  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P6>::value,
+                 p6_is_refcounted_type_and_needs_scoped_refptr);
+  typedef cef_internal::BindState<RunnableType, RunType,
+      void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
+      typename cef_internal::CallbackParamTraits<P2>::StorageType,
+      typename cef_internal::CallbackParamTraits<P3>::StorageType,
+      typename cef_internal::CallbackParamTraits<P4>::StorageType,
+      typename cef_internal::CallbackParamTraits<P5>::StorageType,
+      typename cef_internal::CallbackParamTraits<P6>::StorageType)> BindState;
+
+
+  return Callback<typename BindState::UnboundRunType>(
+      new BindState(cef_internal::MakeRunnable(functor), p1, p2, p3, p4, p5, p6));
+}
+
+template <typename Functor, typename P1, typename P2, typename P3, typename P4,
+    typename P5, typename P6, typename P7>
+base::Callback<
+    typename cef_internal::BindState<
+        typename cef_internal::FunctorTraits<Functor>::RunnableType,
+        typename cef_internal::FunctorTraits<Functor>::RunType,
+        void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
+            typename cef_internal::CallbackParamTraits<P2>::StorageType,
+            typename cef_internal::CallbackParamTraits<P3>::StorageType,
+            typename cef_internal::CallbackParamTraits<P4>::StorageType,
+            typename cef_internal::CallbackParamTraits<P5>::StorageType,
+            typename cef_internal::CallbackParamTraits<P6>::StorageType,
+            typename cef_internal::CallbackParamTraits<P7>::StorageType)>
+            ::UnboundRunType>
+Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4,
+    const P5& p5, const P6& p6, const P7& p7) {
+  // Typedefs for how to store and run the functor.
+  typedef typename cef_internal::FunctorTraits<Functor>::RunnableType RunnableType;
+  typedef typename cef_internal::FunctorTraits<Functor>::RunType RunType;
+
+  // Use RunnableType::RunType instead of RunType above because our
+  // checks should below for bound references need to know what the actual
+  // functor is going to interpret the argument as.
+  typedef cef_internal::FunctionTraits<typename RunnableType::RunType>
+      BoundFunctorTraits;
+
+  // Do not allow binding a non-const reference parameter. Non-const reference
+  // parameters are disallowed by the Google style guide.  Also, binding a
+  // non-const reference parameter can make for subtle bugs because the
+  // invoked function will receive a reference to the stored copy of the
+  // argument and not the original.
+  COMPILE_ASSERT(
+      !(is_non_const_reference<typename BoundFunctorTraits::A1Type>::value ||
+          is_non_const_reference<typename BoundFunctorTraits::A2Type>::value ||
+          is_non_const_reference<typename BoundFunctorTraits::A3Type>::value ||
+          is_non_const_reference<typename BoundFunctorTraits::A4Type>::value ||
+          is_non_const_reference<typename BoundFunctorTraits::A5Type>::value ||
+          is_non_const_reference<typename BoundFunctorTraits::A6Type>::value ||
+          is_non_const_reference<typename BoundFunctorTraits::A7Type>::value ),
+      do_not_bind_functions_with_nonconst_ref);
+
+  // For methods, we need to be careful for parameter 1.  We do not require
+  // a scoped_refptr because BindState<> itself takes care of AddRef() for
+  // methods. We also disallow binding of an array as the method's target
+  // object.
+  COMPILE_ASSERT(
+      cef_internal::HasIsMethodTag<RunnableType>::value ||
+          !cef_internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
+      p1_is_refcounted_type_and_needs_scoped_refptr);
+  COMPILE_ASSERT(!cef_internal::HasIsMethodTag<RunnableType>::value ||
+                     !is_array<P1>::value,
+                 first_bound_argument_to_method_cannot_be_array);
+  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
+                 p2_is_refcounted_type_and_needs_scoped_refptr);
+  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P3>::value,
+                 p3_is_refcounted_type_and_needs_scoped_refptr);
+  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P4>::value,
+                 p4_is_refcounted_type_and_needs_scoped_refptr);
+  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P5>::value,
+                 p5_is_refcounted_type_and_needs_scoped_refptr);
+  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P6>::value,
+                 p6_is_refcounted_type_and_needs_scoped_refptr);
+  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P7>::value,
+                 p7_is_refcounted_type_and_needs_scoped_refptr);
+  typedef cef_internal::BindState<RunnableType, RunType,
+      void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
+      typename cef_internal::CallbackParamTraits<P2>::StorageType,
+      typename cef_internal::CallbackParamTraits<P3>::StorageType,
+      typename cef_internal::CallbackParamTraits<P4>::StorageType,
+      typename cef_internal::CallbackParamTraits<P5>::StorageType,
+      typename cef_internal::CallbackParamTraits<P6>::StorageType,
+      typename cef_internal::CallbackParamTraits<P7>::StorageType)> BindState;
+
+
+  return Callback<typename BindState::UnboundRunType>(
+      new BindState(cef_internal::MakeRunnable(functor), p1, p2, p3, p4, p5, p6,
+          p7));
+}
+
+}  // namespace base
+
+#endif  // !USING_CHROMIUM_INCLUDES
+
+#endif  // CEF_INCLUDE_BASE_CEF_BIND_H_
diff --git a/src/include/libcef/base/cef_bind_helpers.h b/src/include/libcef/base/cef_bind_helpers.h
new file mode 100644
index 0000000..bc8c6ab
--- /dev/null
+++ b/src/include/libcef/base/cef_bind_helpers.h
@@ -0,0 +1,586 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2011
+// Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// This defines a set of argument wrappers and related factory methods that
+// can be used specify the refcounting and reference semantics of arguments
+// that are bound by the Bind() function in base/bind.h.
+//
+// It also defines a set of simple functions and utilities that people want
+// when using Callback<> and Bind().
+//
+//
+// ARGUMENT BINDING WRAPPERS
+//
+// The wrapper functions are base::Unretained(), base::Owned(), base::Passed(),
+// base::ConstRef(), and base::IgnoreResult().
+//
+// Unretained() allows Bind() to bind a non-refcounted class, and to disable
+// refcounting on arguments that are refcounted objects.
+//
+// Owned() transfers ownership of an object to the Callback resulting from
+// bind; the object will be deleted when the Callback is deleted.
+//
+// Passed() is for transferring movable-but-not-copyable types (eg. scoped_ptr)
+// through a Callback. Logically, this signifies a destructive transfer of
+// the state of the argument into the target function.  Invoking
+// Callback::Run() twice on a Callback that was created with a Passed()
+// argument will CHECK() because the first invocation would have already
+// transferred ownership to the target function.
+//
+// ConstRef() allows binding a constant reference to an argument rather
+// than a copy.
+//
+// IgnoreResult() is used to adapt a function or Callback with a return type to
+// one with a void return. This is most useful if you have a function with,
+// say, a pesky ignorable bool return that you want to use with PostTask or
+// something else that expect a Callback with a void return.
+//
+// EXAMPLE OF Unretained():
+//
+//   class Foo {
+//    public:
+//     void func() { cout << "Foo:f" << endl; }
+//   };
+//
+//   // In some function somewhere.
+//   Foo foo;
+//   Closure foo_callback =
+//       Bind(&Foo::func, Unretained(&foo));
+//   foo_callback.Run();  // Prints "Foo:f".
+//
+// Without the Unretained() wrapper on |&foo|, the above call would fail
+// to compile because Foo does not support the AddRef() and Release() methods.
+//
+//
+// EXAMPLE OF Owned():
+//
+//   void foo(int* arg) { cout << *arg << endl }
+//
+//   int* pn = new int(1);
+//   Closure foo_callback = Bind(&foo, Owned(pn));
+//
+//   foo_callback.Run();  // Prints "1"
+//   foo_callback.Run();  // Prints "1"
+//   *n = 2;
+//   foo_callback.Run();  // Prints "2"
+//
+//   foo_callback.Reset();  // |pn| is deleted.  Also will happen when
+//                          // |foo_callback| goes out of scope.
+//
+// Without Owned(), someone would have to know to delete |pn| when the last
+// reference to the Callback is deleted.
+//
+//
+// EXAMPLE OF ConstRef():
+//
+//   void foo(int arg) { cout << arg << endl }
+//
+//   int n = 1;
+//   Closure no_ref = Bind(&foo, n);
+//   Closure has_ref = Bind(&foo, ConstRef(n));
+//
+//   no_ref.Run();  // Prints "1"
+//   has_ref.Run();  // Prints "1"
+//
+//   n = 2;
+//   no_ref.Run();  // Prints "1"
+//   has_ref.Run();  // Prints "2"
+//
+// Note that because ConstRef() takes a reference on |n|, |n| must outlive all
+// its bound callbacks.
+//
+//
+// EXAMPLE OF IgnoreResult():
+//
+//   int DoSomething(int arg) { cout << arg << endl; }
+//
+//   // Assign to a Callback with a void return type.
+//   Callback<void(int)> cb = Bind(IgnoreResult(&DoSomething));
+//   cb->Run(1);  // Prints "1".
+//
+//   // Prints "1" on |ml|.
+//   ml->PostTask(FROM_HERE, Bind(IgnoreResult(&DoSomething), 1);
+//
+//
+// EXAMPLE OF Passed():
+//
+//   void TakesOwnership(scoped_ptr<Foo> arg) { }
+//   scoped_ptr<Foo> CreateFoo() { return scoped_ptr<Foo>(new Foo()); }
+//
+//   scoped_ptr<Foo> f(new Foo());
+//
+//   // |cb| is given ownership of Foo(). |f| is now NULL.
+//   // You can use f.Pass() in place of &f, but it's more verbose.
+//   Closure cb = Bind(&TakesOwnership, Passed(&f));
+//
+//   // Run was never called so |cb| still owns Foo() and deletes
+//   // it on Reset().
+//   cb.Reset();
+//
+//   // |cb| is given a new Foo created by CreateFoo().
+//   cb = Bind(&TakesOwnership, Passed(CreateFoo()));
+//
+//   // |arg| in TakesOwnership() is given ownership of Foo(). |cb|
+//   // no longer owns Foo() and, if reset, would not delete Foo().
+//   cb.Run();  // Foo() is now transferred to |arg| and deleted.
+//   cb.Run();  // This CHECK()s since Foo() already been used once.
+//
+// Passed() is particularly useful with PostTask() when you are transferring
+// ownership of an argument into a task, but don't necessarily know if the
+// task will always be executed. This can happen if the task is cancellable
+// or if it is posted to a MessageLoopProxy.
+//
+//
+// SIMPLE FUNCTIONS AND UTILITIES.
+//
+//   DoNothing() - Useful for creating a Closure that does nothing when called.
+//   DeletePointer<T>() - Useful for creating a Closure that will delete a
+//                        pointer when invoked. Only use this when necessary.
+//                        In most cases MessageLoop::DeleteSoon() is a better
+//                        fit.
+
+#ifndef CEF_INCLUDE_BASE_CEF_BIND_HELPERS_H_
+#define CEF_INCLUDE_BASE_CEF_BIND_HELPERS_H_
+#pragma once
+
+#if defined(BASE_BIND_HELPERS_H_)
+// Do nothing if the Chromium header has already been included.
+// This can happen in cases where Chromium code is used directly by the
+// client application. When using Chromium code directly always include
+// the Chromium header first to avoid type conflicts.
+#elif defined(USING_CHROMIUM_INCLUDES)
+// When building CEF include the Chromium header directly.
+#include "base/bind_helpers.h"
+#else  // !USING_CHROMIUM_INCLUDES
+// The following is substantially similar to the Chromium implementation.
+// If the Chromium implementation diverges the below implementation should be
+// updated to match.
+
+#include "libcef/base/cef_basictypes.h"
+#include "libcef/base/cef_callback.h"
+#include "libcef/base/cef_template_util.h"
+#include "libcef/base/cef_weak_ptr.h"
+
+namespace base {
+namespace cef_internal {
+
+// Use the Substitution Failure Is Not An Error (SFINAE) trick to inspect T
+// for the existence of AddRef() and Release() functions of the correct
+// signature.
+//
+// http://en.wikipedia.org/wiki/Substitution_failure_is_not_an_error
+// http://stackoverflow.com/questions/257288/is-it-possible-to-write-a-c-template-to-check-for-a-functions-existence
+// http://stackoverflow.com/questions/4358584/sfinae-approach-comparison
+// http://stackoverflow.com/questions/1966362/sfinae-to-check-for-inherited-member-functions
+//
+// The last link in particular show the method used below.
+//
+// For SFINAE to work with inherited methods, we need to pull some extra tricks
+// with multiple inheritance.  In the more standard formulation, the overloads
+// of Check would be:
+//
+//   template <typename C>
+//   Yes NotTheCheckWeWant(Helper<&C::TargetFunc>*);
+//
+//   template <typename C>
+//   No NotTheCheckWeWant(...);
+//
+//   static const bool value = sizeof(NotTheCheckWeWant<T>(0)) == sizeof(Yes);
+//
+// The problem here is that template resolution will not match
+// C::TargetFunc if TargetFunc does not exist directly in C.  That is, if
+// TargetFunc in inherited from an ancestor, &C::TargetFunc will not match,
+// |value| will be false.  This formulation only checks for whether or
+// not TargetFunc exist directly in the class being introspected.
+//
+// To get around this, we play a dirty trick with multiple inheritance.
+// First, We create a class BaseMixin that declares each function that we
+// want to probe for.  Then we create a class Base that inherits from both T
+// (the class we wish to probe) and BaseMixin.  Note that the function
+// signature in BaseMixin does not need to match the signature of the function
+// we are probing for; thus it's easiest to just use void(void).
+//
+// Now, if TargetFunc exists somewhere in T, then &Base::TargetFunc has an
+// ambiguous resolution between BaseMixin and T.  This lets us write the
+// following:
+//
+//   template <typename C>
+//   No GoodCheck(Helper<&C::TargetFunc>*);
+//
+//   template <typename C>
+//   Yes GoodCheck(...);
+//
+//   static const bool value = sizeof(GoodCheck<Base>(0)) == sizeof(Yes);
+//
+// Notice here that the variadic version of GoodCheck() returns Yes here
+// instead of No like the previous one. Also notice that we calculate |value|
+// by specializing GoodCheck() on Base instead of T.
+//
+// We've reversed the roles of the variadic, and Helper overloads.
+// GoodCheck(Helper<&C::TargetFunc>*), when C = Base, fails to be a valid
+// substitution if T::TargetFunc exists. Thus GoodCheck<Base>(0) will resolve
+// to the variadic version if T has TargetFunc.  If T::TargetFunc does not
+// exist, then &C::TargetFunc is not ambiguous, and the overload resolution
+// will prefer GoodCheck(Helper<&C::TargetFunc>*).
+//
+// This method of SFINAE will correctly probe for inherited names, but it cannot
+// typecheck those names.  It's still a good enough sanity check though.
+//
+// Works on gcc-4.2, gcc-4.4, and Visual Studio 2008.
+//
+// TODO(ajwong): Move to ref_counted.h or template_util.h when we've vetted
+// this works well.
+//
+// TODO(ajwong): Make this check for Release() as well.
+// See http://crbug.com/82038.
+template <typename T>
+class SupportsAddRefAndRelease {
+  typedef char Yes[1];
+  typedef char No[2];
+
+  struct BaseMixin {
+    void AddRef();
+  };
+
+// MSVC warns when you try to use Base if T has a private destructor, the
+// common pattern for refcounted types. It does this even though no attempt to
+// instantiate Base is made.  We disable the warning for this definition.
+#if defined(OS_WIN)
+#pragma warning(push)
+#pragma warning(disable:4624)
+#endif
+  struct Base : public T, public BaseMixin {
+  };
+#if defined(OS_WIN)
+#pragma warning(pop)
+#endif
+
+  template <void(BaseMixin::*)(void)> struct Helper {};
+
+  template <typename C>
+  static No& Check(Helper<&C::AddRef>*);
+
+  template <typename >
+  static Yes& Check(...);
+
+ public:
+  static const bool value = sizeof(Check<Base>(0)) == sizeof(Yes);
+};
+
+// Helpers to assert that arguments of a recounted type are bound with a
+// scoped_refptr.
+template <bool IsClasstype, typename T>
+struct UnsafeBindtoRefCountedArgHelper : false_type {
+};
+
+template <typename T>
+struct UnsafeBindtoRefCountedArgHelper<true, T>
+    : integral_constant<bool, SupportsAddRefAndRelease<T>::value> {
+};
+
+template <typename T>
+struct UnsafeBindtoRefCountedArg : false_type {
+};
+
+template <typename T>
+struct UnsafeBindtoRefCountedArg<T*>
+    : UnsafeBindtoRefCountedArgHelper<is_class<T>::value, T> {
+};
+
+template <typename T>
+class HasIsMethodTag {
+  typedef char Yes[1];
+  typedef char No[2];
+
+  template <typename U>
+  static Yes& Check(typename U::IsMethod*);
+
+  template <typename U>
+  static No& Check(...);
+
+ public:
+  static const bool value = sizeof(Check<T>(0)) == sizeof(Yes);
+};
+
+template <typename T>
+class UnretainedWrapper {
+ public:
+  explicit UnretainedWrapper(T* o) : ptr_(o) {}
+  T* get() const { return ptr_; }
+ private:
+  T* ptr_;
+};
+
+template <typename T>
+class ConstRefWrapper {
+ public:
+  explicit ConstRefWrapper(const T& o) : ptr_(&o) {}
+  const T& get() const { return *ptr_; }
+ private:
+  const T* ptr_;
+};
+
+template <typename T>
+struct IgnoreResultHelper {
+  explicit IgnoreResultHelper(T functor) : functor_(functor) {}
+
+  T functor_;
+};
+
+template <typename T>
+struct IgnoreResultHelper<Callback<T> > {
+  explicit IgnoreResultHelper(const Callback<T>& functor) : functor_(functor) {}
+
+  const Callback<T>& functor_;
+};
+
+// An alternate implementation is to avoid the destructive copy, and instead
+// specialize ParamTraits<> for OwnedWrapper<> to change the StorageType to
+// a class that is essentially a scoped_ptr<>.
+//
+// The current implementation has the benefit though of leaving ParamTraits<>
+// fully in callback_internal.h as well as avoiding type conversions during
+// storage.
+template <typename T>
+class OwnedWrapper {
+ public:
+  explicit OwnedWrapper(T* o) : ptr_(o) {}
+  ~OwnedWrapper() { delete ptr_; }
+  T* get() const { return ptr_; }
+  OwnedWrapper(const OwnedWrapper& other) {
+    ptr_ = other.ptr_;
+    other.ptr_ = NULL;
+  }
+
+ private:
+  mutable T* ptr_;
+};
+
+// PassedWrapper is a copyable adapter for a scoper that ignores const.
+//
+// It is needed to get around the fact that Bind() takes a const reference to
+// all its arguments.  Because Bind() takes a const reference to avoid
+// unnecessary copies, it is incompatible with movable-but-not-copyable
+// types; doing a destructive "move" of the type into Bind() would violate
+// the const correctness.
+//
+// This conundrum cannot be solved without either C++11 rvalue references or
+// a O(2^n) blowup of Bind() templates to handle each combination of regular
+// types and movable-but-not-copyable types.  Thus we introduce a wrapper type
+// that is copyable to transmit the correct type information down into
+// BindState<>. Ignoring const in this type makes sense because it is only
+// created when we are explicitly trying to do a destructive move.
+//
+// Two notes:
+//  1) PassedWrapper supports any type that has a "Pass()" function.
+//     This is intentional. The whitelisting of which specific types we
+//     support is maintained by CallbackParamTraits<>.
+//  2) is_valid_ is distinct from NULL because it is valid to bind a "NULL"
+//     scoper to a Callback and allow the Callback to execute once.
+template <typename T>
+class PassedWrapper {
+ public:
+  explicit PassedWrapper(T scoper) : is_valid_(true), scoper_(scoper.Pass()) {}
+  PassedWrapper(const PassedWrapper& other)
+      : is_valid_(other.is_valid_), scoper_(other.scoper_.Pass()) {
+  }
+  T Pass() const {
+    CHECK(is_valid_);
+    is_valid_ = false;
+    return scoper_.Pass();
+  }
+
+ private:
+  mutable bool is_valid_;
+  mutable T scoper_;
+};
+
+// Unwrap the stored parameters for the wrappers above.
+template <typename T>
+struct UnwrapTraits {
+  typedef const T& ForwardType;
+  static ForwardType Unwrap(const T& o) { return o; }
+};
+
+template <typename T>
+struct UnwrapTraits<UnretainedWrapper<T> > {
+  typedef T* ForwardType;
+  static ForwardType Unwrap(UnretainedWrapper<T> unretained) {
+    return unretained.get();
+  }
+};
+
+template <typename T>
+struct UnwrapTraits<ConstRefWrapper<T> > {
+  typedef const T& ForwardType;
+  static ForwardType Unwrap(ConstRefWrapper<T> const_ref) {
+    return const_ref.get();
+  }
+};
+
+template <typename T>
+struct UnwrapTraits<scoped_refptr<T> > {
+  typedef T* ForwardType;
+  static ForwardType Unwrap(const scoped_refptr<T>& o) { return o.get(); }
+};
+
+template <typename T>
+struct UnwrapTraits<WeakPtr<T> > {
+  typedef const WeakPtr<T>& ForwardType;
+  static ForwardType Unwrap(const WeakPtr<T>& o) { return o; }
+};
+
+template <typename T>
+struct UnwrapTraits<OwnedWrapper<T> > {
+  typedef T* ForwardType;
+  static ForwardType Unwrap(const OwnedWrapper<T>& o) {
+    return o.get();
+  }
+};
+
+template <typename T>
+struct UnwrapTraits<PassedWrapper<T> > {
+  typedef T ForwardType;
+  static T Unwrap(PassedWrapper<T>& o) {
+    return o.Pass();
+  }
+};
+
+// Utility for handling different refcounting semantics in the Bind()
+// function.
+template <bool is_method, typename T>
+struct MaybeRefcount;
+
+template <typename T>
+struct MaybeRefcount<false, T> {
+  static void AddRef(const T&) {}
+  static void Release(const T&) {}
+};
+
+template <typename T, size_t n>
+struct MaybeRefcount<false, T[n]> {
+  static void AddRef(const T*) {}
+  static void Release(const T*) {}
+};
+
+template <typename T>
+struct MaybeRefcount<true, T> {
+  static void AddRef(const T&) {}
+  static void Release(const T&) {}
+};
+
+template <typename T>
+struct MaybeRefcount<true, T*> {
+  static void AddRef(T* o) { o->AddRef(); }
+  static void Release(T* o) { o->Release(); }
+};
+
+// No need to additionally AddRef() and Release() since we are storing a
+// scoped_refptr<> inside the storage object already.
+template <typename T>
+struct MaybeRefcount<true, scoped_refptr<T> > {
+  static void AddRef(const scoped_refptr<T>& o) {}
+  static void Release(const scoped_refptr<T>& o) {}
+};
+
+template <typename T>
+struct MaybeRefcount<true, const T*> {
+  static void AddRef(const T* o) { o->AddRef(); }
+  static void Release(const T* o) { o->Release(); }
+};
+
+// IsWeakMethod is a helper that determine if we are binding a WeakPtr<> to a
+// method.  It is used internally by Bind() to select the correct
+// InvokeHelper that will no-op itself in the event the WeakPtr<> for
+// the target object is invalidated.
+//
+// P1 should be the type of the object that will be received of the method.
+template <bool IsMethod, typename P1>
+struct IsWeakMethod : public false_type {};
+
+template <typename T>
+struct IsWeakMethod<true, WeakPtr<T> > : public true_type {};
+
+template <typename T>
+struct IsWeakMethod<true, ConstRefWrapper<WeakPtr<T> > > : public true_type {};
+
+}  // namespace cef_internal
+
+template <typename T>
+static inline cef_internal::UnretainedWrapper<T> Unretained(T* o) {
+  return cef_internal::UnretainedWrapper<T>(o);
+}
+
+template <typename T>
+static inline cef_internal::ConstRefWrapper<T> ConstRef(const T& o) {
+  return cef_internal::ConstRefWrapper<T>(o);
+}
+
+template <typename T>
+static inline cef_internal::OwnedWrapper<T> Owned(T* o) {
+  return cef_internal::OwnedWrapper<T>(o);
+}
+
+// We offer 2 syntaxes for calling Passed().  The first takes a temporary and
+// is best suited for use with the return value of a function. The second
+// takes a pointer to the scoper and is just syntactic sugar to avoid having
+// to write Passed(scoper.Pass()).
+template <typename T>
+static inline cef_internal::PassedWrapper<T> Passed(T scoper) {
+  return cef_internal::PassedWrapper<T>(scoper.Pass());
+}
+template <typename T>
+static inline cef_internal::PassedWrapper<T> Passed(T* scoper) {
+  return cef_internal::PassedWrapper<T>(scoper->Pass());
+}
+
+template <typename T>
+static inline cef_internal::IgnoreResultHelper<T> IgnoreResult(T data) {
+  return cef_internal::IgnoreResultHelper<T>(data);
+}
+
+template <typename T>
+static inline cef_internal::IgnoreResultHelper<Callback<T> >
+IgnoreResult(const Callback<T>& data) {
+  return cef_internal::IgnoreResultHelper<Callback<T> >(data);
+}
+
+void DoNothing();
+
+template<typename T>
+void DeletePointer(T* obj) {
+  delete obj;
+}
+
+}  // namespace base
+
+#endif  // !USING_CHROMIUM_INCLUDES
+
+#endif  // CEF_INCLUDE_BASE_CEF_BIND_HELPERS_H_
diff --git a/src/include/libcef/base/cef_build.h b/src/include/libcef/base/cef_build.h
new file mode 100644
index 0000000..2680de0
--- /dev/null
+++ b/src/include/libcef/base/cef_build.h
@@ -0,0 +1,197 @@
+// Copyright (c) 2011 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+#ifndef CEF_INCLUDE_BASE_CEF_BUILD_H_
+#define CEF_INCLUDE_BASE_CEF_BUILD_H_
+#pragma once
+
+#if defined(BUILDING_CEF_SHARED)
+    // When building CEF include the Chromium header directly.
+    #include"base/compiler_specific.h"
+#else  // !BUILDING_CEF_SHARED
+    // The following is substantially similar to the Chromium implementation.
+    // If the Chromium implementation diverges the below implementation should be
+    // updated to match.
+
+    #if defined(_WIN32)
+        #ifndef OS_WIN
+            #define OS_WIN 1
+        #endif
+    #elif defined(__APPLE__)
+        #ifndef OS_MACOSX
+            #define OS_MACOSX 1
+        #endif
+    #elif defined(__linux__)
+        #ifndef OS_LINUX
+            #define OS_LINUX 1
+        #endif
+    #else
+        #error Please add support for your platform in cef_build.h
+    #endif
+
+    // For access to standard POSIXish features, use OS_POSIX instead of a
+    // more specific macro.
+    #if defined(OS_MACOSX) || defined(OS_LINUX)
+        #ifndef OS_POSIX
+            #define OS_POSIX 1
+        #endif
+    #endif
+
+    // Compiler detection.
+    #if defined(__GNUC__)
+        #ifndef COMPILER_GCC
+            #define COMPILER_GCC 1
+        #endif
+    #elif defined(_MSC_VER)
+        #ifndef COMPILER_MSVC
+            #define COMPILER_MSVC 1
+        #endif
+    #elif defined(__WATCOMC__)
+        #ifndef COMPILER_WATCOMC
+            #define COMPILER_WATCOMC 1
+        #endif
+    #else
+        #error Please add support for your compiler in cef_build.h
+    #endif
+
+    // Processor architecture detection.  For more info on what's defined, see:
+    //   http://msdn.microsoft.com/en-us/library/b0084kay.aspx
+    //   http://www.agner.org/optimize/calling_conventions.pdf
+    //   or with gcc, run: "echo | gcc -E -dM -"
+    #if defined(_M_X64) || defined(__x86_64__)
+        #define ARCH_CPU_X86_FAMILY 1
+        #define ARCH_CPU_X86_64 1
+        #define ARCH_CPU_64_BITS 1
+        #define ARCH_CPU_LITTLE_ENDIAN 1
+    #elif defined(_M_IX86) || defined(__i386__)
+        #define ARCH_CPU_X86_FAMILY 1
+        #define ARCH_CPU_X86 1
+        #define ARCH_CPU_32_BITS 1
+        #define ARCH_CPU_LITTLE_ENDIAN 1
+    #elif defined(__ARMEL__)
+        #define ARCH_CPU_ARM_FAMILY 1
+        #define ARCH_CPU_ARMEL 1
+        #define ARCH_CPU_32_BITS 1
+        #define ARCH_CPU_LITTLE_ENDIAN 1
+    #elif defined(__aarch64__)
+        #define ARCH_CPU_ARM_FAMILY 1
+        #define ARCH_CPU_ARM64 1
+        #define ARCH_CPU_64_BITS 1
+        #define ARCH_CPU_LITTLE_ENDIAN 1
+    #elif defined(__pnacl__)
+        #define ARCH_CPU_32_BITS 1
+        #define ARCH_CPU_LITTLE_ENDIAN 1
+    #elif defined(__MIPSEL__)
+        #define ARCH_CPU_MIPS_FAMILY 1
+        #define ARCH_CPU_MIPSEL 1
+        #define ARCH_CPU_32_BITS 1
+        #define ARCH_CPU_LITTLE_ENDIAN 1
+    #else
+        #error Please add support for your architecture in cef_build.h
+    #endif
+
+    // Type detection for wchar_t.
+    #if defined(OS_WIN)
+        #define WCHAR_T_IS_UTF16
+    #elif defined(OS_POSIX) && defined(COMPILER_GCC) && \
+        defined(__WCHAR_MAX__) && \
+        (__WCHAR_MAX__ == 0x7fffffff || __WCHAR_MAX__ == 0xffffffff)
+        #define WCHAR_T_IS_UTF32
+    #elif defined(OS_POSIX) && defined(COMPILER_GCC) && \
+        defined(__WCHAR_MAX__) && \
+        (__WCHAR_MAX__ == 0x7fff || __WCHAR_MAX__ == 0xffff)
+    // On Posix, we'll detect short wchar_t, but projects aren't guaranteed to
+    // compile in this mode (in particular, Chrome doesn't). This is intended for
+    // other projects using base who manage their own dependencies and make sure
+    // short wchar works for them.
+        #define WCHAR_T_IS_UTF16
+    #else
+        #error Please add support for your compiler in cef_build.h
+    #endif
+
+    // Annotate a function indicating the caller must examine the return value.
+    // Use like:
+    //   int foo() WARN_UNUSED_RESULT;
+    // To explicitly ignore a result, see |ignore_result()| in <base/macros.h>.
+    #ifndef WARN_UNUSED_RESULT
+        #if defined(COMPILER_GCC)
+            #define WARN_UNUSED_RESULT __attribute__((warn_unused_result))
+        #else
+            #define WARN_UNUSED_RESULT
+        #endif
+    #endif  // WARN_UNUSED_RESULT
+
+
+    // Annotate a typedef or function indicating it's ok if it's not used.
+    // Use like:
+    //   typedef Foo Bar ALLOW_UNUSED_TYPE;
+    #ifndef ALLOW_UNUSED_TYPE
+        #if defined(COMPILER_GCC)
+            #define ALLOW_UNUSED_TYPE __attribute__((unused))
+        #else
+            #define ALLOW_UNUSED_TYPE
+        #endif
+    #endif  // ALLOW_UNUSED_TYPE
+
+    // Annotate a variable indicating it's ok if the variable is not used.
+    // (Typically used to silence a compiler warning when the assignment
+    // is important for some other reason.)
+    // Use like:
+    //   int x = ...;
+    //   ALLOW_UNUSED_LOCAL(x);
+    #ifndef ALLOW_UNUSED_LOCAL
+        #define ALLOW_UNUSED_LOCAL(x) false ? (void)x : (void)0
+    #endif
+
+#endif  // !BUILDING_CEF_SHARED
+
+// Annotate a virtual method indicating it must be overriding a virtual method
+// in the parent class.
+// Use like:
+//   void foo() OVERRIDE;
+// NOTE: This define should only be used in classes exposed to the client since
+// C++11 support may not be enabled in client applications. CEF internal classes
+// should use the `override` keyword directly.
+#ifndef OVERRIDE
+    #if defined(__clang__)
+        #define OVERRIDE override
+    #elif defined(COMPILER_MSVC) && _MSC_VER >= 1600
+        // Visual Studio 2010 and later support override.
+        #define OVERRIDE override
+    #elif defined(COMPILER_GCC) && __cplusplus >= 201103 && \
+          (__GNUC__ * 10000 + __GNUC_MINOR__ * 100) >= 40700
+        // GCC 4.7 supports explicit virtual overrides when C++11 support is enabled.
+        #define OVERRIDE override
+    #else
+        #define OVERRIDE
+    #endif
+#endif  // OVERRIDE
+
+#endif  // CEF_INCLUDE_BASE_CEF_BUILD_H_
diff --git a/src/include/libcef/base/cef_callback.h b/src/include/libcef/base/cef_callback.h
new file mode 100644
index 0000000..b26b48a
--- /dev/null
+++ b/src/include/libcef/base/cef_callback.h
@@ -0,0 +1,807 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2012
+// Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef CEF_INCLUDE_BASE_CEF_CALLBACK_H_
+#define CEF_INCLUDE_BASE_CEF_CALLBACK_H_
+#pragma once
+
+#if defined(BASE_CALLBACK_H_)
+// Do nothing if the Chromium header has already been included.
+// This can happen in cases where Chromium code is used directly by the
+// client application. When using Chromium code directly always include
+// the Chromium header first to avoid type conflicts.
+#elif defined(USING_CHROMIUM_INCLUDES)
+// When building CEF include the Chromium header directly.
+#include "base/callback.h"
+#else  // !USING_CHROMIUM_INCLUDES
+// The following is substantially similar to the Chromium implementation.
+// If the Chromium implementation diverges the below implementation should be
+// updated to match.
+
+#include "libcef/base/internal/cef_callback_internal.h"
+#include "libcef/base/cef_callback_forward.h"
+#include "libcef/base/cef_template_util.h"
+
+// NOTE: Header files that do not require the full definition of Callback or
+// Closure should #include "base/cef_callback_forward.h" instead of this file.
+
+// -----------------------------------------------------------------------------
+// Introduction
+// -----------------------------------------------------------------------------
+//
+// The templated Callback class is a generalized function object. Together
+// with the Bind() function in bind.h, they provide a type-safe method for
+// performing partial application of functions.
+//
+// Partial application (or "currying") is the process of binding a subset of
+// a function's arguments to produce another function that takes fewer
+// arguments. This can be used to pass around a unit of delayed execution,
+// much like lexical closures are used in other languages. For example, it
+// is used in Chromium code to schedule tasks on different MessageLoops.
+//
+// A callback with no unbound input parameters (base::Callback<void(void)>)
+// is called a base::Closure. Note that this is NOT the same as what other
+// languages refer to as a closure -- it does not retain a reference to its
+// enclosing environment.
+//
+// MEMORY MANAGEMENT AND PASSING
+//
+// The Callback objects themselves should be passed by const-reference, and
+// stored by copy. They internally store their state via a refcounted class
+// and thus do not need to be deleted.
+//
+// The reason to pass via a const-reference is to avoid unnecessary
+// AddRef/Release pairs to the internal state.
+//
+//
+// -----------------------------------------------------------------------------
+// Quick reference for basic stuff
+// -----------------------------------------------------------------------------
+//
+// BINDING A BARE FUNCTION
+//
+//   int Return5() { return 5; }
+//   base::Callback<int(void)> func_cb = base::Bind(&Return5);
+//   LOG(INFO) << func_cb.Run();  // Prints 5.
+//
+// BINDING A CLASS METHOD
+//
+//   The first argument to bind is the member function to call, the second is
+//   the object on which to call it.
+//
+//   class Ref : public base::RefCountedThreadSafe<Ref> {
+//    public:
+//     int Foo() { return 3; }
+//     void PrintBye() { LOG(INFO) << "bye."; }
+//   };
+//   scoped_refptr<Ref> ref = new Ref();
+//   base::Callback<void(void)> ref_cb = base::Bind(&Ref::Foo, ref);
+//   LOG(INFO) << ref_cb.Run();  // Prints out 3.
+//
+//   By default the object must support RefCounted or you will get a compiler
+//   error. If you're passing between threads, be sure it's
+//   RefCountedThreadSafe! See "Advanced binding of member functions" below if
+//   you don't want to use reference counting.
+//
+// RUNNING A CALLBACK
+//
+//   Callbacks can be run with their "Run" method, which has the same
+//   signature as the template argument to the callback.
+//
+//   void DoSomething(const base::Callback<void(int, std::string)>& callback) {
+//     callback.Run(5, "hello");
+//   }
+//
+//   Callbacks can be run more than once (they don't get deleted or marked when
+//   run). However, this precludes using base::Passed (see below).
+//
+//   void DoSomething(const base::Callback<double(double)>& callback) {
+//     double myresult = callback.Run(3.14159);
+//     myresult += callback.Run(2.71828);
+//   }
+//
+// PASSING UNBOUND INPUT PARAMETERS
+//
+//   Unbound parameters are specified at the time a callback is Run(). They are
+//   specified in the Callback template type:
+//
+//   void MyFunc(int i, const std::string& str) {}
+//   base::Callback<void(int, const std::string&)> cb = base::Bind(&MyFunc);
+//   cb.Run(23, "hello, world");
+//
+// PASSING BOUND INPUT PARAMETERS
+//
+//   Bound parameters are specified when you create thee callback as arguments
+//   to Bind(). They will be passed to the function and the Run()ner of the
+//   callback doesn't see those values or even know that the function it's
+//   calling.
+//
+//   void MyFunc(int i, const std::string& str) {}
+//   base::Callback<void(void)> cb = base::Bind(&MyFunc, 23, "hello world");
+//   cb.Run();
+//
+//   A callback with no unbound input parameters (base::Callback<void(void)>)
+//   is called a base::Closure. So we could have also written:
+//
+//   base::Closure cb = base::Bind(&MyFunc, 23, "hello world");
+//
+//   When calling member functions, bound parameters just go after the object
+//   pointer.
+//
+//   base::Closure cb = base::Bind(&MyClass::MyFunc, this, 23, "hello world");
+//
+// PARTIAL BINDING OF PARAMETERS
+//
+//   You can specify some parameters when you create the callback, and specify
+//   the rest when you execute the callback.
+//
+//   void MyFunc(int i, const std::string& str) {}
+//   base::Callback<void(const std::string&)> cb = base::Bind(&MyFunc, 23);
+//   cb.Run("hello world");
+//
+//   When calling a function bound parameters are first, followed by unbound
+//   parameters.
+//
+//
+// -----------------------------------------------------------------------------
+// Quick reference for advanced binding
+// -----------------------------------------------------------------------------
+//
+// BINDING A CLASS METHOD WITH WEAK POINTERS
+//
+//   base::Bind(&MyClass::Foo, GetWeakPtr());
+//
+//   The callback will not be run if the object has already been destroyed.
+//   DANGER: weak pointers are not threadsafe, so don't use this
+//   when passing between threads!
+//
+// BINDING A CLASS METHOD WITH MANUAL LIFETIME MANAGEMENT
+//
+//   base::Bind(&MyClass::Foo, base::Unretained(this));
+//
+//   This disables all lifetime management on the object. You're responsible
+//   for making sure the object is alive at the time of the call. You break it,
+//   you own it!
+//
+// BINDING A CLASS METHOD AND HAVING THE CALLBACK OWN THE CLASS
+//
+//   MyClass* myclass = new MyClass;
+//   base::Bind(&MyClass::Foo, base::Owned(myclass));
+//
+//   The object will be deleted when the callback is destroyed, even if it's
+//   not run (like if you post a task during shutdown). Potentially useful for
+//   "fire and forget" cases.
+//
+// IGNORING RETURN VALUES
+//
+//   Sometimes you want to call a function that returns a value in a callback
+//   that doesn't expect a return value.
+//
+//   int DoSomething(int arg) { cout << arg << endl; }
+//   base::Callback<void<int>) cb =
+//       base::Bind(base::IgnoreResult(&DoSomething));
+//
+//
+// -----------------------------------------------------------------------------
+// Quick reference for binding parameters to Bind()
+// -----------------------------------------------------------------------------
+//
+// Bound parameters are specified as arguments to Bind() and are passed to the
+// function. A callback with no parameters or no unbound parameters is called a
+// Closure (base::Callback<void(void)> and base::Closure are the same thing).
+//
+// PASSING PARAMETERS OWNED BY THE CALLBACK
+//
+//   void Foo(int* arg) { cout << *arg << endl; }
+//   int* pn = new int(1);
+//   base::Closure foo_callback = base::Bind(&foo, base::Owned(pn));
+//
+//   The parameter will be deleted when the callback is destroyed, even if it's
+//   not run (like if you post a task during shutdown).
+//
+// PASSING PARAMETERS AS A scoped_ptr
+//
+//   void TakesOwnership(scoped_ptr<Foo> arg) {}
+//   scoped_ptr<Foo> f(new Foo);
+//   // f becomes null during the following call.
+//   base::Closure cb = base::Bind(&TakesOwnership, base::Passed(&f));
+//
+//   Ownership of the parameter will be with the callback until the it is run,
+//   when ownership is passed to the callback function. This means the callback
+//   can only be run once. If the callback is never run, it will delete the
+//   object when it's destroyed.
+//
+// PASSING PARAMETERS AS A scoped_refptr
+//
+//   void TakesOneRef(scoped_refptr<Foo> arg) {}
+//   scoped_refptr<Foo> f(new Foo)
+//   base::Closure cb = base::Bind(&TakesOneRef, f);
+//
+//   This should "just work." The closure will take a reference as long as it
+//   is alive, and another reference will be taken for the called function.
+//
+// PASSING PARAMETERS BY REFERENCE
+//
+//   Const references are *copied* unless ConstRef is used. Example:
+//
+//   void foo(const int& arg) { printf("%d %p\n", arg, &arg); }
+//   int n = 1;
+//   base::Closure has_copy = base::Bind(&foo, n);
+//   base::Closure has_ref = base::Bind(&foo, base::ConstRef(n));
+//   n = 2;
+//   foo(n);                        // Prints "2 0xaaaaaaaaaaaa"
+//   has_copy.Run();                // Prints "1 0xbbbbbbbbbbbb"
+//   has_ref.Run();                 // Prints "2 0xaaaaaaaaaaaa"
+//
+//   Normally parameters are copied in the closure. DANGER: ConstRef stores a
+//   const reference instead, referencing the original parameter. This means
+//   that you must ensure the object outlives the callback!
+//
+//
+// -----------------------------------------------------------------------------
+// Implementation notes
+// -----------------------------------------------------------------------------
+//
+// WHERE IS THIS DESIGN FROM:
+//
+// The design Callback and Bind is heavily influenced by C++'s
+// tr1::function/tr1::bind, and by the "Google Callback" system used inside
+// Google.
+//
+//
+// HOW THE IMPLEMENTATION WORKS:
+//
+// There are three main components to the system:
+//   1) The Callback classes.
+//   2) The Bind() functions.
+//   3) The arguments wrappers (e.g., Unretained() and ConstRef()).
+//
+// The Callback classes represent a generic function pointer. Internally,
+// it stores a refcounted piece of state that represents the target function
+// and all its bound parameters.  Each Callback specialization has a templated
+// constructor that takes an BindState<>*.  In the context of the constructor,
+// the static type of this BindState<> pointer uniquely identifies the
+// function it is representing, all its bound parameters, and a Run() method
+// that is capable of invoking the target.
+//
+// Callback's constructor takes the BindState<>* that has the full static type
+// and erases the target function type as well as the types of the bound
+// parameters.  It does this by storing a pointer to the specific Run()
+// function, and upcasting the state of BindState<>* to a
+// BindStateBase*. This is safe as long as this BindStateBase pointer
+// is only used with the stored Run() pointer.
+//
+// To BindState<> objects are created inside the Bind() functions.
+// These functions, along with a set of internal templates, are responsible for
+//
+//  - Unwrapping the function signature into return type, and parameters
+//  - Determining the number of parameters that are bound
+//  - Creating the BindState storing the bound parameters
+//  - Performing compile-time asserts to avoid error-prone behavior
+//  - Returning an Callback<> with an arity matching the number of unbound
+//    parameters and that knows the correct refcounting semantics for the
+//    target object if we are binding a method.
+//
+// The Bind functions do the above using type-inference, and template
+// specializations.
+//
+// By default Bind() will store copies of all bound parameters, and attempt
+// to refcount a target object if the function being bound is a class method.
+// These copies are created even if the function takes parameters as const
+// references. (Binding to non-const references is forbidden, see bind.h.)
+//
+// To change this behavior, we introduce a set of argument wrappers
+// (e.g., Unretained(), and ConstRef()).  These are simple container templates
+// that are passed by value, and wrap a pointer to argument.  See the
+// file-level comment in base/bind_helpers.h for more info.
+//
+// These types are passed to the Unwrap() functions, and the MaybeRefcount()
+// functions respectively to modify the behavior of Bind().  The Unwrap()
+// and MaybeRefcount() functions change behavior by doing partial
+// specialization based on whether or not a parameter is a wrapper type.
+//
+// ConstRef() is similar to tr1::cref.  Unretained() is specific to Chromium.
+//
+//
+// WHY NOT TR1 FUNCTION/BIND?
+//
+// Direct use of tr1::function and tr1::bind was considered, but ultimately
+// rejected because of the number of copy constructors invocations involved
+// in the binding of arguments during construction, and the forwarding of
+// arguments during invocation.  These copies will no longer be an issue in
+// C++0x because C++0x will support rvalue reference allowing for the compiler
+// to avoid these copies.  However, waiting for C++0x is not an option.
+//
+// Measured with valgrind on gcc version 4.4.3 (Ubuntu 4.4.3-4ubuntu5), the
+// tr1::bind call itself will invoke a non-trivial copy constructor three times
+// for each bound parameter.  Also, each when passing a tr1::function, each
+// bound argument will be copied again.
+//
+// In addition to the copies taken at binding and invocation, copying a
+// tr1::function causes a copy to be made of all the bound parameters and
+// state.
+//
+// Furthermore, in Chromium, it is desirable for the Callback to take a
+// reference on a target object when representing a class method call.  This
+// is not supported by tr1.
+//
+// Lastly, tr1::function and tr1::bind has a more general and flexible API.
+// This includes things like argument reordering by use of
+// tr1::bind::placeholder, support for non-const reference parameters, and some
+// limited amount of subtyping of the tr1::function object (e.g.,
+// tr1::function<int(int)> is convertible to tr1::function<void(int)>).
+//
+// These are not features that are required in Chromium. Some of them, such as
+// allowing for reference parameters, and subtyping of functions, may actually
+// become a source of errors. Removing support for these features actually
+// allows for a simpler implementation, and a terser Currying API.
+//
+//
+// WHY NOT GOOGLE CALLBACKS?
+//
+// The Google callback system also does not support refcounting.  Furthermore,
+// its implementation has a number of strange edge cases with respect to type
+// conversion of its arguments.  In particular, the argument's constness must
+// at times match exactly the function signature, or the type-inference might
+// break.  Given the above, writing a custom solution was easier.
+//
+//
+// MISSING FUNCTIONALITY
+//  - Invoking the return of Bind.  Bind(&foo).Run() does not work;
+//  - Binding arrays to functions that take a non-const pointer.
+//    Example:
+//      void Foo(const char* ptr);
+//      void Bar(char* ptr);
+//      Bind(&Foo, "test");
+//      Bind(&Bar, "test");  // This fails because ptr is not const.
+
+namespace base {
+
+// First, we forward declare the Callback class template. This informs the
+// compiler that the template only has 1 type parameter which is the function
+// signature that the Callback is representing.
+//
+// After this, create template specializations for 0-7 parameters. Note that
+// even though the template typelist grows, the specialization still
+// only has one type: the function signature.
+//
+// If you are thinking of forward declaring Callback in your own header file,
+// please include "base/callback_forward.h" instead.
+template <typename Sig>
+class Callback;
+
+namespace cef_internal {
+template <typename Runnable, typename RunType, typename BoundArgsType>
+struct BindState;
+}  // namespace cef_internal
+
+template <typename R>
+class Callback<R(void)> : public cef_internal::CallbackBase {
+ public:
+  typedef R(RunType)();
+
+  Callback() : CallbackBase(NULL) { }
+
+  // Note that this constructor CANNOT be explicit, and that Bind() CANNOT
+  // return the exact Callback<> type.  See base/bind.h for details.
+  template <typename Runnable, typename BindRunType, typename BoundArgsType>
+  Callback(cef_internal::BindState<Runnable, BindRunType,
+           BoundArgsType>* bind_state)
+      : CallbackBase(bind_state) {
+
+    // Force the assignment to a local variable of PolymorphicInvoke
+    // so the compiler will typecheck that the passed in Run() method has
+    // the correct type.
+    PolymorphicInvoke invoke_func =
+        &cef_internal::BindState<Runnable, BindRunType, BoundArgsType>
+            ::InvokerType::Run;
+    polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
+  }
+
+  bool Equals(const Callback& other) const {
+    return CallbackBase::Equals(other);
+  }
+
+  R Run() const {
+    PolymorphicInvoke f =
+        reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_);
+
+    return f(bind_state_.get());
+  }
+
+ private:
+  typedef R(*PolymorphicInvoke)(
+      cef_internal::BindStateBase*);
+
+};
+
+template <typename R, typename A1>
+class Callback<R(A1)> : public cef_internal::CallbackBase {
+ public:
+  typedef R(RunType)(A1);
+
+  Callback() : CallbackBase(NULL) { }
+
+  // Note that this constructor CANNOT be explicit, and that Bind() CANNOT
+  // return the exact Callback<> type.  See base/bind.h for details.
+  template <typename Runnable, typename BindRunType, typename BoundArgsType>
+  Callback(cef_internal::BindState<Runnable, BindRunType,
+           BoundArgsType>* bind_state)
+      : CallbackBase(bind_state) {
+
+    // Force the assignment to a local variable of PolymorphicInvoke
+    // so the compiler will typecheck that the passed in Run() method has
+    // the correct type.
+    PolymorphicInvoke invoke_func =
+        &cef_internal::BindState<Runnable, BindRunType, BoundArgsType>
+            ::InvokerType::Run;
+    polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
+  }
+
+  bool Equals(const Callback& other) const {
+    return CallbackBase::Equals(other);
+  }
+
+  R Run(typename cef_internal::CallbackParamTraits<A1>::ForwardType a1) const {
+    PolymorphicInvoke f =
+        reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_);
+
+    return f(bind_state_.get(), cef_internal::CallbackForward(a1));
+  }
+
+ private:
+  typedef R(*PolymorphicInvoke)(
+      cef_internal::BindStateBase*,
+          typename cef_internal::CallbackParamTraits<A1>::ForwardType);
+
+};
+
+template <typename R, typename A1, typename A2>
+class Callback<R(A1, A2)> : public cef_internal::CallbackBase {
+ public:
+  typedef R(RunType)(A1, A2);
+
+  Callback() : CallbackBase(NULL) { }
+
+  // Note that this constructor CANNOT be explicit, and that Bind() CANNOT
+  // return the exact Callback<> type.  See base/bind.h for details.
+  template <typename Runnable, typename BindRunType, typename BoundArgsType>
+  Callback(cef_internal::BindState<Runnable, BindRunType,
+           BoundArgsType>* bind_state)
+      : CallbackBase(bind_state) {
+
+    // Force the assignment to a local variable of PolymorphicInvoke
+    // so the compiler will typecheck that the passed in Run() method has
+    // the correct type.
+    PolymorphicInvoke invoke_func =
+        &cef_internal::BindState<Runnable, BindRunType, BoundArgsType>
+            ::InvokerType::Run;
+    polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
+  }
+
+  bool Equals(const Callback& other) const {
+    return CallbackBase::Equals(other);
+  }
+
+  R Run(typename cef_internal::CallbackParamTraits<A1>::ForwardType a1,
+        typename cef_internal::CallbackParamTraits<A2>::ForwardType a2) const {
+    PolymorphicInvoke f =
+        reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_);
+
+    return f(bind_state_.get(), cef_internal::CallbackForward(a1),
+             cef_internal::CallbackForward(a2));
+  }
+
+ private:
+  typedef R(*PolymorphicInvoke)(
+      cef_internal::BindStateBase*,
+          typename cef_internal::CallbackParamTraits<A1>::ForwardType,
+          typename cef_internal::CallbackParamTraits<A2>::ForwardType);
+
+};
+
+template <typename R, typename A1, typename A2, typename A3>
+class Callback<R(A1, A2, A3)> : public cef_internal::CallbackBase {
+ public:
+  typedef R(RunType)(A1, A2, A3);
+
+  Callback() : CallbackBase(NULL) { }
+
+  // Note that this constructor CANNOT be explicit, and that Bind() CANNOT
+  // return the exact Callback<> type.  See base/bind.h for details.
+  template <typename Runnable, typename BindRunType, typename BoundArgsType>
+  Callback(cef_internal::BindState<Runnable, BindRunType,
+           BoundArgsType>* bind_state)
+      : CallbackBase(bind_state) {
+
+    // Force the assignment to a local variable of PolymorphicInvoke
+    // so the compiler will typecheck that the passed in Run() method has
+    // the correct type.
+    PolymorphicInvoke invoke_func =
+        &cef_internal::BindState<Runnable, BindRunType, BoundArgsType>
+            ::InvokerType::Run;
+    polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
+  }
+
+  bool Equals(const Callback& other) const {
+    return CallbackBase::Equals(other);
+  }
+
+  R Run(typename cef_internal::CallbackParamTraits<A1>::ForwardType a1,
+        typename cef_internal::CallbackParamTraits<A2>::ForwardType a2,
+        typename cef_internal::CallbackParamTraits<A3>::ForwardType a3) const {
+    PolymorphicInvoke f =
+        reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_);
+
+    return f(bind_state_.get(), cef_internal::CallbackForward(a1),
+             cef_internal::CallbackForward(a2),
+             cef_internal::CallbackForward(a3));
+  }
+
+ private:
+  typedef R(*PolymorphicInvoke)(
+      cef_internal::BindStateBase*,
+          typename cef_internal::CallbackParamTraits<A1>::ForwardType,
+          typename cef_internal::CallbackParamTraits<A2>::ForwardType,
+          typename cef_internal::CallbackParamTraits<A3>::ForwardType);
+
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4>
+class Callback<R(A1, A2, A3, A4)> : public cef_internal::CallbackBase {
+ public:
+  typedef R(RunType)(A1, A2, A3, A4);
+
+  Callback() : CallbackBase(NULL) { }
+
+  // Note that this constructor CANNOT be explicit, and that Bind() CANNOT
+  // return the exact Callback<> type.  See base/bind.h for details.
+  template <typename Runnable, typename BindRunType, typename BoundArgsType>
+  Callback(cef_internal::BindState<Runnable, BindRunType,
+           BoundArgsType>* bind_state)
+      : CallbackBase(bind_state) {
+
+    // Force the assignment to a local variable of PolymorphicInvoke
+    // so the compiler will typecheck that the passed in Run() method has
+    // the correct type.
+    PolymorphicInvoke invoke_func =
+        &cef_internal::BindState<Runnable, BindRunType, BoundArgsType>
+            ::InvokerType::Run;
+    polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
+  }
+
+  bool Equals(const Callback& other) const {
+    return CallbackBase::Equals(other);
+  }
+
+  R Run(typename cef_internal::CallbackParamTraits<A1>::ForwardType a1,
+        typename cef_internal::CallbackParamTraits<A2>::ForwardType a2,
+        typename cef_internal::CallbackParamTraits<A3>::ForwardType a3,
+        typename cef_internal::CallbackParamTraits<A4>::ForwardType a4) const {
+    PolymorphicInvoke f =
+        reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_);
+
+    return f(bind_state_.get(), cef_internal::CallbackForward(a1),
+             cef_internal::CallbackForward(a2),
+             cef_internal::CallbackForward(a3),
+             cef_internal::CallbackForward(a4));
+  }
+
+ private:
+  typedef R(*PolymorphicInvoke)(
+      cef_internal::BindStateBase*,
+          typename cef_internal::CallbackParamTraits<A1>::ForwardType,
+          typename cef_internal::CallbackParamTraits<A2>::ForwardType,
+          typename cef_internal::CallbackParamTraits<A3>::ForwardType,
+          typename cef_internal::CallbackParamTraits<A4>::ForwardType);
+
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5>
+class Callback<R(A1, A2, A3, A4, A5)> : public cef_internal::CallbackBase {
+ public:
+  typedef R(RunType)(A1, A2, A3, A4, A5);
+
+  Callback() : CallbackBase(NULL) { }
+
+  // Note that this constructor CANNOT be explicit, and that Bind() CANNOT
+  // return the exact Callback<> type.  See base/bind.h for details.
+  template <typename Runnable, typename BindRunType, typename BoundArgsType>
+  Callback(cef_internal::BindState<Runnable, BindRunType,
+           BoundArgsType>* bind_state)
+      : CallbackBase(bind_state) {
+
+    // Force the assignment to a local variable of PolymorphicInvoke
+    // so the compiler will typecheck that the passed in Run() method has
+    // the correct type.
+    PolymorphicInvoke invoke_func =
+        &cef_internal::BindState<Runnable, BindRunType, BoundArgsType>
+            ::InvokerType::Run;
+    polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
+  }
+
+  bool Equals(const Callback& other) const {
+    return CallbackBase::Equals(other);
+  }
+
+  R Run(typename cef_internal::CallbackParamTraits<A1>::ForwardType a1,
+        typename cef_internal::CallbackParamTraits<A2>::ForwardType a2,
+        typename cef_internal::CallbackParamTraits<A3>::ForwardType a3,
+        typename cef_internal::CallbackParamTraits<A4>::ForwardType a4,
+        typename cef_internal::CallbackParamTraits<A5>::ForwardType a5) const {
+    PolymorphicInvoke f =
+        reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_);
+
+    return f(bind_state_.get(), cef_internal::CallbackForward(a1),
+             cef_internal::CallbackForward(a2),
+             cef_internal::CallbackForward(a3),
+             cef_internal::CallbackForward(a4),
+             cef_internal::CallbackForward(a5));
+  }
+
+ private:
+  typedef R(*PolymorphicInvoke)(
+      cef_internal::BindStateBase*,
+          typename cef_internal::CallbackParamTraits<A1>::ForwardType,
+          typename cef_internal::CallbackParamTraits<A2>::ForwardType,
+          typename cef_internal::CallbackParamTraits<A3>::ForwardType,
+          typename cef_internal::CallbackParamTraits<A4>::ForwardType,
+          typename cef_internal::CallbackParamTraits<A5>::ForwardType);
+
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6>
+class Callback<R(A1, A2, A3, A4, A5, A6)> : public cef_internal::CallbackBase {
+ public:
+  typedef R(RunType)(A1, A2, A3, A4, A5, A6);
+
+  Callback() : CallbackBase(NULL) { }
+
+  // Note that this constructor CANNOT be explicit, and that Bind() CANNOT
+  // return the exact Callback<> type.  See base/bind.h for details.
+  template <typename Runnable, typename BindRunType, typename BoundArgsType>
+  Callback(cef_internal::BindState<Runnable, BindRunType,
+           BoundArgsType>* bind_state)
+      : CallbackBase(bind_state) {
+
+    // Force the assignment to a local variable of PolymorphicInvoke
+    // so the compiler will typecheck that the passed in Run() method has
+    // the correct type.
+    PolymorphicInvoke invoke_func =
+        &cef_internal::BindState<Runnable, BindRunType, BoundArgsType>
+            ::InvokerType::Run;
+    polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
+  }
+
+  bool Equals(const Callback& other) const {
+    return CallbackBase::Equals(other);
+  }
+
+  R Run(typename cef_internal::CallbackParamTraits<A1>::ForwardType a1,
+        typename cef_internal::CallbackParamTraits<A2>::ForwardType a2,
+        typename cef_internal::CallbackParamTraits<A3>::ForwardType a3,
+        typename cef_internal::CallbackParamTraits<A4>::ForwardType a4,
+        typename cef_internal::CallbackParamTraits<A5>::ForwardType a5,
+        typename cef_internal::CallbackParamTraits<A6>::ForwardType a6) const {
+    PolymorphicInvoke f =
+        reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_);
+
+    return f(bind_state_.get(), cef_internal::CallbackForward(a1),
+             cef_internal::CallbackForward(a2),
+             cef_internal::CallbackForward(a3),
+             cef_internal::CallbackForward(a4),
+             cef_internal::CallbackForward(a5),
+             cef_internal::CallbackForward(a6));
+  }
+
+ private:
+  typedef R(*PolymorphicInvoke)(
+      cef_internal::BindStateBase*,
+          typename cef_internal::CallbackParamTraits<A1>::ForwardType,
+          typename cef_internal::CallbackParamTraits<A2>::ForwardType,
+          typename cef_internal::CallbackParamTraits<A3>::ForwardType,
+          typename cef_internal::CallbackParamTraits<A4>::ForwardType,
+          typename cef_internal::CallbackParamTraits<A5>::ForwardType,
+          typename cef_internal::CallbackParamTraits<A6>::ForwardType);
+
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6, typename A7>
+class Callback<R(A1, A2, A3, A4, A5, A6, A7)> : public cef_internal::CallbackBase {
+ public:
+  typedef R(RunType)(A1, A2, A3, A4, A5, A6, A7);
+
+  Callback() : CallbackBase(NULL) { }
+
+  // Note that this constructor CANNOT be explicit, and that Bind() CANNOT
+  // return the exact Callback<> type.  See base/bind.h for details.
+  template <typename Runnable, typename BindRunType, typename BoundArgsType>
+  Callback(cef_internal::BindState<Runnable, BindRunType,
+           BoundArgsType>* bind_state)
+      : CallbackBase(bind_state) {
+
+    // Force the assignment to a local variable of PolymorphicInvoke
+    // so the compiler will typecheck that the passed in Run() method has
+    // the correct type.
+    PolymorphicInvoke invoke_func =
+        &cef_internal::BindState<Runnable, BindRunType, BoundArgsType>
+            ::InvokerType::Run;
+    polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
+  }
+
+  bool Equals(const Callback& other) const {
+    return CallbackBase::Equals(other);
+  }
+
+  R Run(typename cef_internal::CallbackParamTraits<A1>::ForwardType a1,
+        typename cef_internal::CallbackParamTraits<A2>::ForwardType a2,
+        typename cef_internal::CallbackParamTraits<A3>::ForwardType a3,
+        typename cef_internal::CallbackParamTraits<A4>::ForwardType a4,
+        typename cef_internal::CallbackParamTraits<A5>::ForwardType a5,
+        typename cef_internal::CallbackParamTraits<A6>::ForwardType a6,
+        typename cef_internal::CallbackParamTraits<A7>::ForwardType a7) const {
+    PolymorphicInvoke f =
+        reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_);
+
+    return f(bind_state_.get(), cef_internal::CallbackForward(a1),
+             cef_internal::CallbackForward(a2),
+             cef_internal::CallbackForward(a3),
+             cef_internal::CallbackForward(a4),
+             cef_internal::CallbackForward(a5),
+             cef_internal::CallbackForward(a6),
+             cef_internal::CallbackForward(a7));
+  }
+
+ private:
+  typedef R(*PolymorphicInvoke)(
+      cef_internal::BindStateBase*,
+          typename cef_internal::CallbackParamTraits<A1>::ForwardType,
+          typename cef_internal::CallbackParamTraits<A2>::ForwardType,
+          typename cef_internal::CallbackParamTraits<A3>::ForwardType,
+          typename cef_internal::CallbackParamTraits<A4>::ForwardType,
+          typename cef_internal::CallbackParamTraits<A5>::ForwardType,
+          typename cef_internal::CallbackParamTraits<A6>::ForwardType,
+          typename cef_internal::CallbackParamTraits<A7>::ForwardType);
+
+};
+
+
+// Syntactic sugar to make Callbacks<void(void)> easier to declare since it
+// will be used in a lot of APIs with delayed execution.
+typedef Callback<void(void)> Closure;
+
+}  // namespace base
+
+#endif  // !USING_CHROMIUM_INCLUDES
+
+#endif  // CEF_INCLUDE_BASE_CEF_CALLBACK_H_
diff --git a/src/include/libcef/base/cef_callback_forward.h b/src/include/libcef/base/cef_callback_forward.h
new file mode 100644
index 0000000..d604d7c
--- /dev/null
+++ b/src/include/libcef/base/cef_callback_forward.h
@@ -0,0 +1,59 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2011
+// Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef INCLUDE_BASE_CEF_CALLBACK_FORWARD_H_
+#define INCLUDE_BASE_CEF_CALLBACK_FORWARD_H_
+#pragma once
+
+#if defined(BASE_CALLBACK_FORWARD_H_)
+// Do nothing if the Chromium header has already been included.
+// This can happen in cases where Chromium code is used directly by the
+// client application. When using Chromium code directly always include
+// the Chromium header first to avoid type conflicts.
+#elif defined(USING_CHROMIUM_INCLUDES)
+// When building CEF include the Chromium header directly.
+#include "base/callback_forward.h"
+#else  // !USING_CHROMIUM_INCLUDES
+// The following is substantially similar to the Chromium implementation.
+// If the Chromium implementation diverges the below implementation should be
+// updated to match.
+
+namespace base {
+
+template <typename Sig>
+class Callback;
+
+typedef Callback<void(void)> Closure;
+
+}  // namespace base
+
+#endif  // !!USING_CHROMIUM_INCLUDES
+
+#endif  // INCLUDE_BASE_CEF_CALLBACK_FORWARD_H_
diff --git a/src/include/libcef/base/cef_callback_helpers.h b/src/include/libcef/base/cef_callback_helpers.h
new file mode 100644
index 0000000..4b25957
--- /dev/null
+++ b/src/include/libcef/base/cef_callback_helpers.h
@@ -0,0 +1,93 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2012
+// Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// This defines helpful methods for dealing with Callbacks.  Because Callbacks
+// are implemented using templates, with a class per callback signature, adding
+// methods to Callback<> itself is unattractive (lots of extra code gets
+// generated).  Instead, consider adding methods here.
+//
+// ResetAndReturn(&cb) is like cb.Reset() but allows executing a callback (via a
+// copy) after the original callback is Reset().  This can be handy if Run()
+// reads/writes the variable holding the Callback.
+
+#ifndef CEF_INCLUDE_BASE_CEF_CALLBACK_HELPERS_H_
+#define CEF_INCLUDE_BASE_CEF_CALLBACK_HELPERS_H_
+#pragma once
+
+#if defined(BASE_CALLBACK_HELPERS_H_)
+// Do nothing if the Chromium header has already been included.
+// This can happen in cases where Chromium code is used directly by the
+// client application. When using Chromium code directly always include
+// the Chromium header first to avoid type conflicts.
+#elif defined(USING_CHROMIUM_INCLUDES)
+// When building CEF include the Chromium header directly.
+#include "base/callback_helpers.h"
+#else  // !USING_CHROMIUM_INCLUDES
+// The following is substantially similar to the Chromium implementation.
+// If the Chromium implementation diverges the below implementation should be
+// updated to match.
+
+#include "libcef/base/cef_basictypes.h"
+#include "libcef/base/cef_build.h"
+#include "libcef/base/cef_callback.h"
+#include "libcef/base/cef_macros.h"
+
+namespace base {
+
+template <typename Sig>
+base::Callback<Sig> ResetAndReturn(base::Callback<Sig>* cb) {
+  base::Callback<Sig> ret(*cb);
+  cb->Reset();
+  return ret;
+}
+
+// ScopedClosureRunner is akin to scoped_ptr for Closures. It ensures that the
+// Closure is executed and deleted no matter how the current scope exits.
+class ScopedClosureRunner {
+ public:
+  ScopedClosureRunner();
+  explicit ScopedClosureRunner(const Closure& closure);
+  ~ScopedClosureRunner();
+
+  void Reset();
+  void Reset(const Closure& closure);
+  Closure Release() WARN_UNUSED_RESULT;
+
+ private:
+  Closure closure_;
+
+  DISALLOW_COPY_AND_ASSIGN(ScopedClosureRunner);
+};
+
+}  // namespace base
+
+#endif  // !USING_CHROMIUM_INCLUDES
+
+#endif  // CEF_INCLUDE_BASE_CEF_CALLBACK_HELPERS_H_
diff --git a/src/include/libcef/base/cef_callback_list.h b/src/include/libcef/base/cef_callback_list.h
new file mode 100644
index 0000000..c5c279c
--- /dev/null
+++ b/src/include/libcef/base/cef_callback_list.h
@@ -0,0 +1,444 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2013
+// Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef CEF_INCLUDE_BASE_CEF_CALLBACK_LIST_H_
+#define CEF_INCLUDE_BASE_CEF_CALLBACK_LIST_H_
+#pragma once
+
+#if defined(BASE_CALLBACK_LIST_H_)
+// Do nothing if the Chromium header has already been included.
+// This can happen in cases where Chromium code is used directly by the
+// client application. When using Chromium code directly always include
+// the Chromium header first to avoid type conflicts.
+#elif defined(USING_CHROMIUM_INCLUDES)
+// When building CEF include the Chromium header directly.
+#include "base/callback_list.h"
+#else  // !USING_CHROMIUM_INCLUDES
+// The following is substantially similar to the Chromium implementation.
+// If the Chromium implementation diverges the below implementation should be
+// updated to match.
+
+#include <list>
+
+#include "libcef/base/cef_basictypes.h"
+#include "libcef/base/cef_callback.h"
+#include "libcef/base/internal/cef_callback_internal.h"
+#include "libcef/base/cef_build.h"
+#include "libcef/base/cef_logging.h"
+#include "libcef/base/cef_macros.h"
+#include "libcef/base/cef_scoped_ptr.h"
+
+// OVERVIEW:
+//
+// A container for a list of callbacks.  Unlike a normal STL vector or list,
+// this container can be modified during iteration without invalidating the
+// iterator. It safely handles the case of a callback removing itself
+// or another callback from the list while callbacks are being run.
+//
+// TYPICAL USAGE:
+//
+// class MyWidget {
+//  public:
+//   ...
+//
+//   typedef base::Callback<void(const Foo&)> OnFooCallback;
+//
+//   scoped_ptr<base::CallbackList<void(const Foo&)>::Subscription>
+//   RegisterCallback(const OnFooCallback& cb) {
+//     return callback_list_.Add(cb);
+//   }
+//
+//  private:
+//   void NotifyFoo(const Foo& foo) {
+//      callback_list_.Notify(foo);
+//   }
+//
+//   base::CallbackList<void(const Foo&)> callback_list_;
+//
+//   DISALLOW_COPY_AND_ASSIGN(MyWidget);
+// };
+//
+//
+// class MyWidgetListener {
+//  public:
+//   MyWidgetListener::MyWidgetListener() {
+//     foo_subscription_ = MyWidget::GetCurrent()->RegisterCallback(
+//             base::Bind(&MyWidgetListener::OnFoo, this)));
+//   }
+//
+//   MyWidgetListener::~MyWidgetListener() {
+//      // Subscription gets deleted automatically and will deregister
+//      // the callback in the process.
+//   }
+//
+//  private:
+//   void OnFoo(const Foo& foo) {
+//     // Do something.
+//   }
+//
+//   scoped_ptr<base::CallbackList<void(const Foo&)>::Subscription>
+//       foo_subscription_;
+//
+//   DISALLOW_COPY_AND_ASSIGN(MyWidgetListener);
+// };
+
+namespace base {
+
+namespace cef_internal {
+
+template <typename CallbackType>
+class CallbackListBase {
+ public:
+  class Subscription {
+   public:
+    Subscription(CallbackListBase<CallbackType>* list,
+                 typename std::list<CallbackType>::iterator iter)
+        : list_(list),
+          iter_(iter) {
+    }
+
+    ~Subscription() {
+      if (list_->active_iterator_count_) {
+        iter_->Reset();
+      } else {
+        list_->callbacks_.erase(iter_);
+        if (!list_->removal_callback_.is_null())
+          list_->removal_callback_.Run();
+      }
+    }
+
+   private:
+    CallbackListBase<CallbackType>* list_;
+    typename std::list<CallbackType>::iterator iter_;
+
+    DISALLOW_COPY_AND_ASSIGN(Subscription);
+  };
+
+  // Add a callback to the list. The callback will remain registered until the
+  // returned Subscription is destroyed, which must occur before the
+  // CallbackList is destroyed.
+  scoped_ptr<Subscription> Add(const CallbackType& cb) WARN_UNUSED_RESULT {
+    DCHECK(!cb.is_null());
+    return scoped_ptr<Subscription>(
+        new Subscription(this, callbacks_.insert(callbacks_.end(), cb)));
+  }
+
+  // Sets a callback which will be run when a subscription list is changed.
+  void set_removal_callback(const Closure& callback) {
+    removal_callback_ = callback;
+  }
+
+  // Returns true if there are no subscriptions. This is only valid to call when
+  // not looping through the list.
+  bool empty() {
+    DCHECK_EQ(0, active_iterator_count_);
+    return callbacks_.empty();
+  }
+
+ protected:
+  // An iterator class that can be used to access the list of callbacks.
+  class Iterator {
+   public:
+    explicit Iterator(CallbackListBase<CallbackType>* list)
+        : list_(list),
+          list_iter_(list_->callbacks_.begin()) {
+      ++list_->active_iterator_count_;
+    }
+
+    Iterator(const Iterator& iter)
+        : list_(iter.list_),
+          list_iter_(iter.list_iter_) {
+      ++list_->active_iterator_count_;
+    }
+
+    ~Iterator() {
+      if (list_ && --list_->active_iterator_count_ == 0) {
+        list_->Compact();
+      }
+    }
+
+    CallbackType* GetNext() {
+      while ((list_iter_ != list_->callbacks_.end()) && list_iter_->is_null())
+        ++list_iter_;
+
+      CallbackType* cb = NULL;
+      if (list_iter_ != list_->callbacks_.end()) {
+        cb = &(*list_iter_);
+        ++list_iter_;
+      }
+      return cb;
+    }
+
+   private:
+    CallbackListBase<CallbackType>* list_;
+    typename std::list<CallbackType>::iterator list_iter_;
+  };
+
+  CallbackListBase() : active_iterator_count_(0) {}
+
+  ~CallbackListBase() {
+    DCHECK_EQ(0, active_iterator_count_);
+    DCHECK_EQ(0U, callbacks_.size());
+  }
+
+  // Returns an instance of a CallbackListBase::Iterator which can be used
+  // to run callbacks.
+  Iterator GetIterator() {
+    return Iterator(this);
+  }
+
+  // Compact the list: remove any entries which were NULLed out during
+  // iteration.
+  void Compact() {
+    typename std::list<CallbackType>::iterator it = callbacks_.begin();
+    bool updated = false;
+    while (it != callbacks_.end()) {
+      if ((*it).is_null()) {
+        updated = true;
+        it = callbacks_.erase(it);
+      } else {
+        ++it;
+      }
+
+      if (updated && !removal_callback_.is_null())
+        removal_callback_.Run();
+    }
+  }
+
+ private:
+  std::list<CallbackType> callbacks_;
+  int active_iterator_count_;
+  Closure removal_callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(CallbackListBase);
+};
+
+}  // namespace cef_internal
+
+template <typename Sig> class CallbackList;
+
+template <>
+class CallbackList<void(void)>
+    : public cef_internal::CallbackListBase<Callback<void(void)> > {
+ public:
+  typedef Callback<void(void)> CallbackType;
+
+  CallbackList() {}
+
+  void Notify() {
+    cef_internal::CallbackListBase<CallbackType>::Iterator it =
+        this->GetIterator();
+    CallbackType* cb;
+    while ((cb = it.GetNext()) != NULL) {
+      cb->Run();
+    }
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(CallbackList);
+};
+
+template <typename A1>
+class CallbackList<void(A1)>
+    : public cef_internal::CallbackListBase<Callback<void(A1)> > {
+ public:
+  typedef Callback<void(A1)> CallbackType;
+
+  CallbackList() {}
+
+  void Notify(typename cef_internal::CallbackParamTraits<A1>::ForwardType a1) {
+    typename cef_internal::CallbackListBase<CallbackType>::Iterator it =
+        this->GetIterator();
+    CallbackType* cb;
+    while ((cb = it.GetNext()) != NULL) {
+      cb->Run(a1);
+    }
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(CallbackList);
+};
+
+template <typename A1, typename A2>
+class CallbackList<void(A1, A2)>
+    : public cef_internal::CallbackListBase<Callback<void(A1, A2)> > {
+ public:
+  typedef Callback<void(A1, A2)> CallbackType;
+
+  CallbackList() {}
+
+  void Notify(typename cef_internal::CallbackParamTraits<A1>::ForwardType a1,
+              typename cef_internal::CallbackParamTraits<A2>::ForwardType a2) {
+    typename cef_internal::CallbackListBase<CallbackType>::Iterator it =
+        this->GetIterator();
+    CallbackType* cb;
+    while ((cb = it.GetNext()) != NULL) {
+      cb->Run(a1, a2);
+    }
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(CallbackList);
+};
+
+template <typename A1, typename A2, typename A3>
+class CallbackList<void(A1, A2, A3)>
+    : public cef_internal::CallbackListBase<Callback<void(A1, A2, A3)> > {
+ public:
+  typedef Callback<void(A1, A2, A3)> CallbackType;
+
+  CallbackList() {}
+
+  void Notify(typename cef_internal::CallbackParamTraits<A1>::ForwardType a1,
+              typename cef_internal::CallbackParamTraits<A2>::ForwardType a2,
+              typename cef_internal::CallbackParamTraits<A3>::ForwardType a3) {
+    typename cef_internal::CallbackListBase<CallbackType>::Iterator it =
+        this->GetIterator();
+    CallbackType* cb;
+    while ((cb = it.GetNext()) != NULL) {
+      cb->Run(a1, a2, a3);
+    }
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(CallbackList);
+};
+
+template <typename A1, typename A2, typename A3, typename A4>
+class CallbackList<void(A1, A2, A3, A4)>
+    : public cef_internal::CallbackListBase<Callback<void(A1, A2, A3, A4)> > {
+ public:
+  typedef Callback<void(A1, A2, A3, A4)> CallbackType;
+
+  CallbackList() {}
+
+  void Notify(typename cef_internal::CallbackParamTraits<A1>::ForwardType a1,
+              typename cef_internal::CallbackParamTraits<A2>::ForwardType a2,
+              typename cef_internal::CallbackParamTraits<A3>::ForwardType a3,
+              typename cef_internal::CallbackParamTraits<A4>::ForwardType a4) {
+    typename cef_internal::CallbackListBase<CallbackType>::Iterator it =
+        this->GetIterator();
+    CallbackType* cb;
+    while ((cb = it.GetNext()) != NULL) {
+      cb->Run(a1, a2, a3, a4);
+    }
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(CallbackList);
+};
+
+template <typename A1, typename A2, typename A3, typename A4, typename A5>
+class CallbackList<void(A1, A2, A3, A4, A5)>
+    : public cef_internal::CallbackListBase<Callback<void(A1, A2, A3, A4, A5)> > {
+ public:
+  typedef Callback<void(A1, A2, A3, A4, A5)> CallbackType;
+
+  CallbackList() {}
+
+  void Notify(typename cef_internal::CallbackParamTraits<A1>::ForwardType a1,
+              typename cef_internal::CallbackParamTraits<A2>::ForwardType a2,
+              typename cef_internal::CallbackParamTraits<A3>::ForwardType a3,
+              typename cef_internal::CallbackParamTraits<A4>::ForwardType a4,
+              typename cef_internal::CallbackParamTraits<A5>::ForwardType a5) {
+    typename cef_internal::CallbackListBase<CallbackType>::Iterator it =
+        this->GetIterator();
+    CallbackType* cb;
+    while ((cb = it.GetNext()) != NULL) {
+      cb->Run(a1, a2, a3, a4, a5);
+    }
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(CallbackList);
+};
+
+template <typename A1, typename A2, typename A3, typename A4, typename A5,
+    typename A6>
+class CallbackList<void(A1, A2, A3, A4, A5, A6)>
+    : public cef_internal::CallbackListBase<Callback<void(A1, A2, A3, A4, A5,
+        A6)> > {
+ public:
+  typedef Callback<void(A1, A2, A3, A4, A5, A6)> CallbackType;
+
+  CallbackList() {}
+
+  void Notify(typename cef_internal::CallbackParamTraits<A1>::ForwardType a1,
+              typename cef_internal::CallbackParamTraits<A2>::ForwardType a2,
+              typename cef_internal::CallbackParamTraits<A3>::ForwardType a3,
+              typename cef_internal::CallbackParamTraits<A4>::ForwardType a4,
+              typename cef_internal::CallbackParamTraits<A5>::ForwardType a5,
+              typename cef_internal::CallbackParamTraits<A6>::ForwardType a6) {
+    typename cef_internal::CallbackListBase<CallbackType>::Iterator it =
+        this->GetIterator();
+    CallbackType* cb;
+    while ((cb = it.GetNext()) != NULL) {
+      cb->Run(a1, a2, a3, a4, a5, a6);
+    }
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(CallbackList);
+};
+
+template <typename A1, typename A2, typename A3, typename A4, typename A5,
+    typename A6, typename A7>
+class CallbackList<void(A1, A2, A3, A4, A5, A6, A7)>
+    : public cef_internal::CallbackListBase<Callback<void(A1, A2, A3, A4, A5, A6,
+        A7)> > {
+ public:
+  typedef Callback<void(A1, A2, A3, A4, A5, A6, A7)> CallbackType;
+
+  CallbackList() {}
+
+  void Notify(typename cef_internal::CallbackParamTraits<A1>::ForwardType a1,
+              typename cef_internal::CallbackParamTraits<A2>::ForwardType a2,
+              typename cef_internal::CallbackParamTraits<A3>::ForwardType a3,
+              typename cef_internal::CallbackParamTraits<A4>::ForwardType a4,
+              typename cef_internal::CallbackParamTraits<A5>::ForwardType a5,
+              typename cef_internal::CallbackParamTraits<A6>::ForwardType a6,
+              typename cef_internal::CallbackParamTraits<A7>::ForwardType a7) {
+    typename cef_internal::CallbackListBase<CallbackType>::Iterator it =
+        this->GetIterator();
+    CallbackType* cb;
+    while ((cb = it.GetNext()) != NULL) {
+      cb->Run(a1, a2, a3, a4, a5, a6, a7);
+    }
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(CallbackList);
+};
+
+}  // namespace base
+
+#endif  // !USING_CHROMIUM_INCLUDES
+
+#endif  // CEF_INCLUDE_BASE_CEF_CALLBACK_LIST_H_
diff --git a/src/include/libcef/base/cef_cancelable_callback.h b/src/include/libcef/base/cef_cancelable_callback.h
new file mode 100644
index 0000000..ca0b1fe
--- /dev/null
+++ b/src/include/libcef/base/cef_cancelable_callback.h
@@ -0,0 +1,314 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2011
+// Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// CancelableCallback is a wrapper around base::Callback that allows
+// cancellation of a callback. CancelableCallback takes a reference on the
+// wrapped callback until this object is destroyed or Reset()/Cancel() are
+// called.
+//
+// NOTE:
+//
+// Calling CancelableCallback::Cancel() brings the object back to its natural,
+// default-constructed state, i.e., CancelableCallback::callback() will return
+// a null callback.
+//
+// THREAD-SAFETY:
+//
+// CancelableCallback objects must be created on, posted to, cancelled on, and
+// destroyed on the same thread.
+//
+//
+// EXAMPLE USAGE:
+//
+// In the following example, the test is verifying that RunIntensiveTest()
+// Quit()s the message loop within 4 seconds. The cancelable callback is posted
+// to the message loop, the intensive test runs, the message loop is run,
+// then the callback is cancelled.
+//
+// void TimeoutCallback(const std::string& timeout_message) {
+//   FAIL() << timeout_message;
+//   MessageLoop::current()->QuitWhenIdle();
+// }
+//
+// CancelableClosure timeout(base::Bind(&TimeoutCallback, "Test timed out."));
+// MessageLoop::current()->PostDelayedTask(FROM_HERE, timeout.callback(),
+//                                         4000)  // 4 seconds to run.
+// RunIntensiveTest();
+// MessageLoop::current()->Run();
+// timeout.Cancel();  // Hopefully this is hit before the timeout callback runs.
+//
+
+#ifndef CEF_INCLUDE_BASE_CEF_CANCELABLE_CALLBACK_H_
+#define CEF_INCLUDE_BASE_CEF_CANCELABLE_CALLBACK_H_
+#pragma once
+
+#if defined(BASE_CANCELABLE_CALLBACK_H_)
+// Do nothing if the Chromium header has already been included.
+// This can happen in cases where Chromium code is used directly by the
+// client application. When using Chromium code directly always include
+// the Chromium header first to avoid type conflicts.
+#elif defined(USING_CHROMIUM_INCLUDES)
+// When building CEF include the Chromium header directly.
+#include "base/cancelable_callback.h"
+#else  // !USING_CHROMIUM_INCLUDES
+// The following is substantially similar to the Chromium implementation.
+// If the Chromium implementation diverges the below implementation should be
+// updated to match.
+
+#include "libcef/base/cef_bind.h"
+#include "libcef/base/cef_callback.h"
+#include "libcef/base/cef_build.h"
+#include "libcef/base/cef_logging.h"
+#include "libcef/base/cef_macros.h"
+#include "libcef/base/cef_weak_ptr.h"
+#include "libcef/base/internal/cef_callback_internal.h"
+
+namespace base {
+
+template <typename Sig>
+class CancelableCallback;
+
+template <>
+class CancelableCallback<void(void)> {
+ public:
+  CancelableCallback() : weak_factory_(this) {}
+
+  // |callback| must not be null.
+  explicit CancelableCallback(const base::Callback<void(void)>& callback)
+      : weak_factory_(this),
+        callback_(callback) {
+    DCHECK(!callback.is_null());
+    InitializeForwarder();
+  }
+
+  ~CancelableCallback() {}
+
+  // Cancels and drops the reference to the wrapped callback.
+  void Cancel() {
+    weak_factory_.InvalidateWeakPtrs();
+    forwarder_.Reset();
+    callback_.Reset();
+  }
+
+  // Returns true if the wrapped callback has been cancelled.
+  bool IsCancelled() const {
+    return callback_.is_null();
+  }
+
+  // Sets |callback| as the closure that may be cancelled. |callback| may not
+  // be null. Outstanding and any previously wrapped callbacks are cancelled.
+  void Reset(const base::Callback<void(void)>& callback) {
+    DCHECK(!callback.is_null());
+
+    // Outstanding tasks (e.g., posted to a message loop) must not be called.
+    Cancel();
+
+    // |forwarder_| is no longer valid after Cancel(), so re-bind.
+    InitializeForwarder();
+
+    callback_ = callback;
+  }
+
+  // Returns a callback that can be disabled by calling Cancel().
+  const base::Callback<void(void)>& callback() const {
+    return forwarder_;
+  }
+
+ private:
+  void Forward() {
+    callback_.Run();
+  }
+
+  // Helper method to bind |forwarder_| using a weak pointer from
+  // |weak_factory_|.
+  void InitializeForwarder() {
+    forwarder_ = base::Bind(&CancelableCallback<void(void)>::Forward,
+                            weak_factory_.GetWeakPtr());
+  }
+
+  // Used to ensure Forward() is not run when this object is destroyed.
+  base::WeakPtrFactory<CancelableCallback<void(void)> > weak_factory_;
+
+  // The wrapper closure.
+  base::Callback<void(void)> forwarder_;
+
+  // The stored closure that may be cancelled.
+  base::Callback<void(void)> callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(CancelableCallback);
+};
+
+template <typename A1>
+class CancelableCallback<void(A1)> {
+ public:
+  CancelableCallback() : weak_factory_(this) {}
+
+  // |callback| must not be null.
+  explicit CancelableCallback(const base::Callback<void(A1)>& callback)
+      : weak_factory_(this),
+        callback_(callback) {
+    DCHECK(!callback.is_null());
+    InitializeForwarder();
+  }
+
+  ~CancelableCallback() {}
+
+  // Cancels and drops the reference to the wrapped callback.
+  void Cancel() {
+    weak_factory_.InvalidateWeakPtrs();
+    forwarder_.Reset();
+    callback_.Reset();
+  }
+
+  // Returns true if the wrapped callback has been cancelled.
+  bool IsCancelled() const {
+    return callback_.is_null();
+  }
+
+  // Sets |callback| as the closure that may be cancelled. |callback| may not
+  // be null. Outstanding and any previously wrapped callbacks are cancelled.
+  void Reset(const base::Callback<void(A1)>& callback) {
+    DCHECK(!callback.is_null());
+
+    // Outstanding tasks (e.g., posted to a message loop) must not be called.
+    Cancel();
+
+    // |forwarder_| is no longer valid after Cancel(), so re-bind.
+    InitializeForwarder();
+
+    callback_ = callback;
+  }
+
+  // Returns a callback that can be disabled by calling Cancel().
+  const base::Callback<void(A1)>& callback() const {
+    return forwarder_;
+  }
+
+ private:
+  void Forward(A1 a1) const {
+    callback_.Run(a1);
+  }
+
+  // Helper method to bind |forwarder_| using a weak pointer from
+  // |weak_factory_|.
+  void InitializeForwarder() {
+    forwarder_ = base::Bind(&CancelableCallback<void(A1)>::Forward,
+                            weak_factory_.GetWeakPtr());
+  }
+
+  // Used to ensure Forward() is not run when this object is destroyed.
+  base::WeakPtrFactory<CancelableCallback<void(A1)> > weak_factory_;
+
+  // The wrapper closure.
+  base::Callback<void(A1)> forwarder_;
+
+  // The stored closure that may be cancelled.
+  base::Callback<void(A1)> callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(CancelableCallback);
+};
+
+template <typename A1, typename A2>
+class CancelableCallback<void(A1, A2)> {
+ public:
+  CancelableCallback() : weak_factory_(this) {}
+
+  // |callback| must not be null.
+  explicit CancelableCallback(const base::Callback<void(A1, A2)>& callback)
+      : weak_factory_(this),
+        callback_(callback) {
+    DCHECK(!callback.is_null());
+    InitializeForwarder();
+  }
+
+  ~CancelableCallback() {}
+
+  // Cancels and drops the reference to the wrapped callback.
+  void Cancel() {
+    weak_factory_.InvalidateWeakPtrs();
+    forwarder_.Reset();
+    callback_.Reset();
+  }
+
+  // Returns true if the wrapped callback has been cancelled.
+  bool IsCancelled() const {
+    return callback_.is_null();
+  }
+
+  // Sets |callback| as the closure that may be cancelled. |callback| may not
+  // be null. Outstanding and any previously wrapped callbacks are cancelled.
+  void Reset(const base::Callback<void(A1, A2)>& callback) {
+    DCHECK(!callback.is_null());
+
+    // Outstanding tasks (e.g., posted to a message loop) must not be called.
+    Cancel();
+
+    // |forwarder_| is no longer valid after Cancel(), so re-bind.
+    InitializeForwarder();
+
+    callback_ = callback;
+  }
+
+  // Returns a callback that can be disabled by calling Cancel().
+  const base::Callback<void(A1, A2)>& callback() const {
+    return forwarder_;
+  }
+
+ private:
+  void Forward(A1 a1, A2 a2) const {
+    callback_.Run(a1, a2);
+  }
+
+  // Helper method to bind |forwarder_| using a weak pointer from
+  // |weak_factory_|.
+  void InitializeForwarder() {
+    forwarder_ = base::Bind(&CancelableCallback<void(A1, A2)>::Forward,
+                            weak_factory_.GetWeakPtr());
+  }
+
+  // Used to ensure Forward() is not run when this object is destroyed.
+  base::WeakPtrFactory<CancelableCallback<void(A1, A2)> > weak_factory_;
+
+  // The wrapper closure.
+  base::Callback<void(A1, A2)> forwarder_;
+
+  // The stored closure that may be cancelled.
+  base::Callback<void(A1, A2)> callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(CancelableCallback);
+};
+
+typedef CancelableCallback<void(void)> CancelableClosure;
+
+}  // namespace base
+
+#endif  // !USING_CHROMIUM_INCLUDES
+
+#endif  // CEF_INCLUDE_BASE_CEF_CANCELABLE_CALLBACK_H_
diff --git a/src/include/libcef/base/cef_lock.h b/src/include/libcef/base/cef_lock.h
new file mode 100644
index 0000000..d7c3f23
--- /dev/null
+++ b/src/include/libcef/base/cef_lock.h
@@ -0,0 +1,167 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2011
+// Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef CEF_INCLUDE_BASE_CEF_LOCK_H_
+#define CEF_INCLUDE_BASE_CEF_LOCK_H_
+#pragma once
+
+#if defined(BASE_SYNCHRONIZATION_LOCK_H_)
+// Do nothing if the Chromium header has already been included.
+// This can happen in cases where Chromium code is used directly by the
+// client application. When using Chromium code directly always include
+// the Chromium header first to avoid type conflicts.
+#elif defined(USING_CHROMIUM_INCLUDES)
+// When building CEF include the Chromium header directly.
+#include "base/synchronization/lock.h"
+#else  // !USING_CHROMIUM_INCLUDES
+// The following is substantially similar to the Chromium implementation.
+// If the Chromium implementation diverges the below implementation should be
+// updated to match.
+
+#include "libcef/base/cef_macros.h"
+#include "libcef/base/cef_platform_thread.h"
+#include "libcef/base/internal/cef_lock_impl.h"
+
+namespace base {
+
+// A convenient wrapper for an OS specific critical section.  The only real
+// intelligence in this class is in debug mode for the support for the
+// AssertAcquired() method.
+class Lock {
+ public:
+#if defined(NDEBUG)             // Optimized wrapper implementation
+  Lock() : lock_() {}
+  ~Lock() {}
+  void Acquire() { lock_.Lock(); }
+  void Release() { lock_.Unlock(); }
+
+  // If the lock is not held, take it and return true. If the lock is already
+  // held by another thread, immediately return false. This must not be called
+  // by a thread already holding the lock (what happens is undefined and an
+  // assertion may fail).
+  bool Try() { return lock_.Try(); }
+
+  // Null implementation if not debug.
+  void AssertAcquired() const {}
+#else
+  Lock();
+  ~Lock();
+
+  // NOTE: Although windows critical sections support recursive locks, we do not
+  // allow this, and we will commonly fire a DCHECK() if a thread attempts to
+  // acquire the lock a second time (while already holding it).
+  void Acquire() {
+    lock_.Lock();
+    CheckUnheldAndMark();
+  }
+  void Release() {
+    CheckHeldAndUnmark();
+    lock_.Unlock();
+  }
+
+  bool Try() {
+    bool rv = lock_.Try();
+    if (rv) {
+      CheckUnheldAndMark();
+    }
+    return rv;
+  }
+
+  void AssertAcquired() const;
+#endif                          // NDEBUG
+
+ private:
+#if !defined(NDEBUG)
+  // Members and routines taking care of locks assertions.
+  // Note that this checks for recursive locks and allows them
+  // if the variable is set.  This is allowed by the underlying implementation
+  // on windows but not on Posix, so we're doing unneeded checks on Posix.
+  // It's worth it to share the code.
+  void CheckHeldAndUnmark();
+  void CheckUnheldAndMark();
+
+  // All private data is implicitly protected by lock_.
+  // Be VERY careful to only access members under that lock.
+  base::PlatformThreadRef owning_thread_ref_;
+#endif  // NDEBUG
+
+  // Platform specific underlying lock implementation.
+  cef_internal::LockImpl lock_;
+
+  DISALLOW_COPY_AND_ASSIGN(Lock);
+};
+
+// A helper class that acquires the given Lock while the AutoLock is in scope.
+class AutoLock {
+ public:
+  struct AlreadyAcquired {};
+
+  explicit AutoLock(Lock& lock) : lock_(lock) {
+    lock_.Acquire();
+  }
+
+  AutoLock(Lock& lock, const AlreadyAcquired&) : lock_(lock) {
+    lock_.AssertAcquired();
+  }
+
+  ~AutoLock() {
+    lock_.AssertAcquired();
+    lock_.Release();
+  }
+
+ private:
+  Lock& lock_;
+  DISALLOW_COPY_AND_ASSIGN(AutoLock);
+};
+
+// AutoUnlock is a helper that will Release() the |lock| argument in the
+// constructor, and re-Acquire() it in the destructor.
+class AutoUnlock {
+ public:
+  explicit AutoUnlock(Lock& lock) : lock_(lock) {
+    // We require our caller to have the lock.
+    lock_.AssertAcquired();
+    lock_.Release();
+  }
+
+  ~AutoUnlock() {
+    lock_.Acquire();
+  }
+
+ private:
+  Lock& lock_;
+  DISALLOW_COPY_AND_ASSIGN(AutoUnlock);
+};
+
+}  // namespace base
+
+#endif  // !USING_CHROMIUM_INCLUDES
+
+#endif  // CEF_INCLUDE_BASE_CEF_LOCK_H_
diff --git a/src/include/libcef/base/cef_logging.h b/src/include/libcef/base/cef_logging.h
new file mode 100644
index 0000000..504650d
--- /dev/null
+++ b/src/include/libcef/base/cef_logging.h
@@ -0,0 +1,752 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2012
+// Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file are only available to applications that link
+// against the libcef_dll_wrapper target.
+//
+// WARNING: Logging macros should not be used in the main/browser process before
+// calling CefInitialize or in sub-processes before calling CefExecuteProcess.
+//
+// Instructions
+// ------------
+//
+// Make a bunch of macros for logging.  The way to log things is to stream
+// things to LOG(<a particular severity level>).  E.g.,
+//
+//   LOG(INFO) << "Found " << num_cookies << " cookies";
+//
+// You can also do conditional logging:
+//
+//   LOG_IF(INFO, num_cookies > 10) << "Got lots of cookies";
+//
+// The CHECK(condition) macro is active in both debug and release builds and
+// effectively performs a LOG(FATAL) which terminates the process and
+// generates a crashdump unless a debugger is attached.
+//
+// There are also "debug mode" logging macros like the ones above:
+//
+//   DLOG(INFO) << "Found cookies";
+//
+//   DLOG_IF(INFO, num_cookies > 10) << "Got lots of cookies";
+//
+// All "debug mode" logging is compiled away to nothing for non-debug mode
+// compiles.  LOG_IF and development flags also work well together
+// because the code can be compiled away sometimes.
+//
+// We also have
+//
+//   LOG_ASSERT(assertion);
+//   DLOG_ASSERT(assertion);
+//
+// which is syntactic sugar for {,D}LOG_IF(FATAL, assert fails) << assertion;
+//
+// There are "verbose level" logging macros.  They look like
+//
+//   VLOG(1) << "I'm printed when you run the program with --v=1 or more";
+//   VLOG(2) << "I'm printed when you run the program with --v=2 or more";
+//
+// These always log at the INFO log level (when they log at all).
+// The verbose logging can also be turned on module-by-module.  For instance,
+//    --vmodule=profile=2,icon_loader=1,browser_*=3,*/chromeos/*=4 --v=0
+// will cause:
+//   a. VLOG(2) and lower messages to be printed from profile.{h,cc}
+//   b. VLOG(1) and lower messages to be printed from icon_loader.{h,cc}
+//   c. VLOG(3) and lower messages to be printed from files prefixed with
+//      "browser"
+//   d. VLOG(4) and lower messages to be printed from files under a
+//     "chromeos" directory.
+//   e. VLOG(0) and lower messages to be printed from elsewhere
+//
+// The wildcarding functionality shown by (c) supports both '*' (match
+// 0 or more characters) and '?' (match any single character)
+// wildcards.  Any pattern containing a forward or backward slash will
+// be tested against the whole pathname and not just the module.
+// E.g., "*/foo/bar/*=2" would change the logging level for all code
+// in source files under a "foo/bar" directory.
+//
+// There's also VLOG_IS_ON(n) "verbose level" condition macro. To be used as
+//
+//   if (VLOG_IS_ON(2)) {
+//     // do some logging preparation and logging
+//     // that can't be accomplished with just VLOG(2) << ...;
+//   }
+//
+// There is also a VLOG_IF "verbose level" condition macro for sample
+// cases, when some extra computation and preparation for logs is not
+// needed.
+//
+//   VLOG_IF(1, (size > 1024))
+//      << "I'm printed when size is more than 1024 and when you run the "
+//         "program with --v=1 or more";
+//
+// We also override the standard 'assert' to use 'DLOG_ASSERT'.
+//
+// Lastly, there is:
+//
+//   PLOG(ERROR) << "Couldn't do foo";
+//   DPLOG(ERROR) << "Couldn't do foo";
+//   PLOG_IF(ERROR, cond) << "Couldn't do foo";
+//   DPLOG_IF(ERROR, cond) << "Couldn't do foo";
+//   PCHECK(condition) << "Couldn't do foo";
+//   DPCHECK(condition) << "Couldn't do foo";
+//
+// which append the last system error to the message in string form (taken from
+// GetLastError() on Windows and errno on POSIX).
+//
+// The supported severity levels for macros that allow you to specify one
+// are (in increasing order of severity) INFO, WARNING, ERROR, and FATAL.
+//
+// Very important: logging a message at the FATAL severity level causes
+// the program to terminate (after the message is logged).
+//
+// There is the special severity of DFATAL, which logs FATAL in debug mode,
+// ERROR in normal mode.
+//
+
+#ifndef CEF_INCLUDE_BASE_CEF_LOGGING_H_
+#define CEF_INCLUDE_BASE_CEF_LOGGING_H_
+#pragma once
+
+#if defined(DCHECK)
+// Do nothing if the macros provided by this header already exist.
+// This can happen in cases where Chromium code is used directly by the
+// client application. When using Chromium code directly always include
+// the Chromium header first to avoid type conflicts.
+
+// Always define the DCHECK_IS_ON macro which is used from other CEF headers.
+#if defined(NDEBUG) && !defined(DCHECK_ALWAYS_ON)
+#define DCHECK_IS_ON() 0
+#else
+#define DCHECK_IS_ON() 1
+#endif
+
+#elif defined(USING_CHROMIUM_INCLUDES)
+// When building CEF include the Chromium header directly.
+#include "base/logging.h"
+#else  // !USING_CHROMIUM_INCLUDES
+// The following is substantially similar to the Chromium implementation.
+// If the Chromium implementation diverges the below implementation should be
+// updated to match.
+
+#include <cassert>
+#include <string>
+#include <cstring>
+#include <sstream>
+
+#include "libcef/base/cef_build.h"
+#include "libcef/base/cef_macros.h"
+#include "libcef/internal/cef_logging_internal.h"
+
+namespace cef {
+namespace logging {
+
+// Gets the current log level.
+inline int GetMinLogLevel() {
+  return cef_get_min_log_level();
+}
+
+// Gets the current vlog level for the given file (usually taken from
+// __FILE__). Note that |N| is the size *with* the null terminator.
+template <size_t N>
+int GetVlogLevel(const char (&file)[N]) {
+  return cef_get_vlog_level(file, N);
+}
+
+typedef int LogSeverity;
+const LogSeverity LOG_VERBOSE = -1;  // This is level 1 verbosity
+// Note: the log severities are used to index into the array of names,
+// see log_severity_names.
+const LogSeverity LOG_INFO = 0;
+const LogSeverity LOG_WARNING = 1;
+const LogSeverity LOG_ERROR = 2;
+const LogSeverity LOG_FATAL = 3;
+const LogSeverity LOG_NUM_SEVERITIES = 4;
+
+// LOG_DFATAL is LOG_FATAL in debug mode, ERROR in normal mode
+#ifdef NDEBUG
+const LogSeverity LOG_DFATAL = LOG_ERROR;
+#else
+const LogSeverity LOG_DFATAL = LOG_FATAL;
+#endif
+
+// A few definitions of macros that don't generate much code. These are used
+// by LOG() and LOG_IF, etc. Since these are used all over our code, it's
+// better to have compact code for these operations.
+#define COMPACT_GOOGLE_LOG_EX_INFO(ClassName, ...) \
+  cef::logging::ClassName(__FILE__, __LINE__, cef::logging::LOG_INFO , \
+                         ##__VA_ARGS__)
+#define COMPACT_GOOGLE_LOG_EX_WARNING(ClassName, ...) \
+  cef::logging::ClassName(__FILE__, __LINE__, cef::logging::LOG_WARNING , \
+                         ##__VA_ARGS__)
+#define COMPACT_GOOGLE_LOG_EX_ERROR(ClassName, ...) \
+  cef::logging::ClassName(__FILE__, __LINE__, cef::logging::LOG_ERROR , \
+                         ##__VA_ARGS__)
+#define COMPACT_GOOGLE_LOG_EX_FATAL(ClassName, ...) \
+  cef::logging::ClassName(__FILE__, __LINE__, cef::logging::LOG_FATAL , \
+                         ##__VA_ARGS__)
+#define COMPACT_GOOGLE_LOG_EX_DFATAL(ClassName, ...) \
+  cef::logging::ClassName(__FILE__, __LINE__, cef::logging::LOG_DFATAL , \
+                         ##__VA_ARGS__)
+
+#define COMPACT_GOOGLE_LOG_INFO \
+  COMPACT_GOOGLE_LOG_EX_INFO(LogMessage)
+#define COMPACT_GOOGLE_LOG_WARNING \
+  COMPACT_GOOGLE_LOG_EX_WARNING(LogMessage)
+#define COMPACT_GOOGLE_LOG_ERROR \
+  COMPACT_GOOGLE_LOG_EX_ERROR(LogMessage)
+#define COMPACT_GOOGLE_LOG_FATAL \
+  COMPACT_GOOGLE_LOG_EX_FATAL(LogMessage)
+#define COMPACT_GOOGLE_LOG_DFATAL \
+  COMPACT_GOOGLE_LOG_EX_DFATAL(LogMessage)
+
+#if defined(OS_WIN)
+// wingdi.h defines ERROR to be 0. When we call LOG(ERROR), it gets
+// substituted with 0, and it expands to COMPACT_GOOGLE_LOG_0. To allow us
+// to keep using this syntax, we define this macro to do the same thing
+// as COMPACT_GOOGLE_LOG_ERROR, and also define ERROR the same way that
+// the Windows SDK does for consistency.
+#define ERROR 0
+#define COMPACT_GOOGLE_LOG_EX_0(ClassName, ...) \
+  COMPACT_GOOGLE_LOG_EX_ERROR(ClassName , ##__VA_ARGS__)
+#define COMPACT_GOOGLE_LOG_0 COMPACT_GOOGLE_LOG_ERROR
+// Needed for LOG_IS_ON(ERROR).
+const LogSeverity LOG_0 = LOG_ERROR;
+#endif
+
+// As special cases, we can assume that LOG_IS_ON(FATAL) always holds. Also,
+// LOG_IS_ON(DFATAL) always holds in debug mode. In particular, CHECK()s will
+// always fire if they fail.
+#define LOG_IS_ON(severity) \
+  ((::cef::logging::LOG_ ## severity) >= ::cef::logging::GetMinLogLevel())
+
+// We can't do any caching tricks with VLOG_IS_ON() like the
+// google-glog version since it requires GCC extensions.  This means
+// that using the v-logging functions in conjunction with --vmodule
+// may be slow.
+#define VLOG_IS_ON(verboselevel) \
+  ((verboselevel) <= ::cef::logging::GetVlogLevel(__FILE__))
+
+// Helper macro which avoids evaluating the arguments to a stream if
+// the condition doesn't hold.
+#define LAZY_STREAM(stream, condition)                                  \
+  !(condition) ? (void) 0 : ::cef::logging::LogMessageVoidify() & (stream)
+
+// We use the preprocessor's merging operator, "##", so that, e.g.,
+// LOG(INFO) becomes the token COMPACT_GOOGLE_LOG_INFO.  There's some funny
+// subtle difference between ostream member streaming functions (e.g.,
+// ostream::operator<<(int) and ostream non-member streaming functions
+// (e.g., ::operator<<(ostream&, string&): it turns out that it's
+// impossible to stream something like a string directly to an unnamed
+// ostream. We employ a neat hack by calling the stream() member
+// function of LogMessage which seems to avoid the problem.
+#define LOG_STREAM(severity) COMPACT_GOOGLE_LOG_ ## severity.stream()
+
+#define LOG(severity) LAZY_STREAM(LOG_STREAM(severity), LOG_IS_ON(severity))
+#define LOG_IF(severity, condition) \
+  LAZY_STREAM(LOG_STREAM(severity), LOG_IS_ON(severity) && (condition))
+
+#define SYSLOG(severity) LOG(severity)
+#define SYSLOG_IF(severity, condition) LOG_IF(severity, condition)
+
+// The VLOG macros log with negative verbosities.
+#define VLOG_STREAM(verbose_level) \
+  cef::logging::LogMessage(__FILE__, __LINE__, -verbose_level).stream()
+
+#define VLOG(verbose_level) \
+  LAZY_STREAM(VLOG_STREAM(verbose_level), VLOG_IS_ON(verbose_level))
+
+#define VLOG_IF(verbose_level, condition) \
+  LAZY_STREAM(VLOG_STREAM(verbose_level), \
+      VLOG_IS_ON(verbose_level) && (condition))
+
+#if defined (OS_WIN)
+#define VPLOG_STREAM(verbose_level) \
+  cef::logging::Win32ErrorLogMessage(__FILE__, __LINE__, -verbose_level, \
+    ::cef::logging::GetLastSystemErrorCode()).stream()
+#elif defined(OS_POSIX)
+#define VPLOG_STREAM(verbose_level) \
+  cef::logging::ErrnoLogMessage(__FILE__, __LINE__, -verbose_level, \
+    ::cef::logging::GetLastSystemErrorCode()).stream()
+#endif
+
+#define VPLOG(verbose_level) \
+  LAZY_STREAM(VPLOG_STREAM(verbose_level), VLOG_IS_ON(verbose_level))
+
+#define VPLOG_IF(verbose_level, condition) \
+  LAZY_STREAM(VPLOG_STREAM(verbose_level), \
+    VLOG_IS_ON(verbose_level) && (condition))
+
+// TODO(akalin): Add more VLOG variants, e.g. VPLOG.
+
+#define LOG_ASSERT(condition)  \
+  LOG_IF(FATAL, !(condition)) << "Assert failed: " #condition ". "
+#define SYSLOG_ASSERT(condition) \
+  SYSLOG_IF(FATAL, !(condition)) << "Assert failed: " #condition ". "
+
+#if defined(OS_WIN)
+#define PLOG_STREAM(severity) \
+  COMPACT_GOOGLE_LOG_EX_ ## severity(Win32ErrorLogMessage, \
+      ::cef::logging::GetLastSystemErrorCode()).stream()
+#elif defined(OS_POSIX)
+#define PLOG_STREAM(severity) \
+  COMPACT_GOOGLE_LOG_EX_ ## severity(ErrnoLogMessage, \
+      ::cef::logging::GetLastSystemErrorCode()).stream()
+#endif
+
+#define PLOG(severity)                                          \
+  LAZY_STREAM(PLOG_STREAM(severity), LOG_IS_ON(severity))
+
+#define PLOG_IF(severity, condition) \
+  LAZY_STREAM(PLOG_STREAM(severity), LOG_IS_ON(severity) && (condition))
+
+// The actual stream used isn't important.
+#define EAT_STREAM_PARAMETERS                                           \
+  true ? (void) 0 : ::cef::logging::LogMessageVoidify() & LOG_STREAM(FATAL)
+
+// CHECK dies with a fatal error if condition is not true.  It is *not*
+// controlled by NDEBUG, so the check will be executed regardless of
+// compilation mode.
+//
+// We make sure CHECK et al. always evaluates their arguments, as
+// doing CHECK(FunctionWithSideEffect()) is a common idiom.
+
+#define CHECK(condition)                       \
+  LAZY_STREAM(LOG_STREAM(FATAL), !(condition)) \
+  << "Check failed: " #condition ". "
+
+#define PCHECK(condition) \
+  LAZY_STREAM(PLOG_STREAM(FATAL), !(condition)) \
+  << "Check failed: " #condition ". "
+
+// Helper macro for binary operators.
+// Don't use this macro directly in your code, use CHECK_EQ et al below.
+//
+// TODO(akalin): Rewrite this so that constructs like if (...)
+// CHECK_EQ(...) else { ... } work properly.
+#define CHECK_OP(name, op, val1, val2)                          \
+  if (std::string* _result =                                    \
+      cef::logging::Check##name##Impl((val1), (val2),                \
+                                 #val1 " " #op " " #val2))      \
+    cef::logging::LogMessage(__FILE__, __LINE__, _result).stream()
+
+// Build the error message string.  This is separate from the "Impl"
+// function template because it is not performance critical and so can
+// be out of line, while the "Impl" code should be inline.  Caller
+// takes ownership of the returned string.
+template<class t1, class t2>
+std::string* MakeCheckOpString(const t1& v1, const t2& v2, const char* names) {
+  std::ostringstream ss;
+  ss << names << " (" << v1 << " vs. " << v2 << ")";
+  std::string* msg = new std::string(ss.str());
+  return msg;
+}
+
+// MSVC doesn't like complex extern templates and DLLs.
+#if !defined(COMPILER_MSVC)
+// Commonly used instantiations of MakeCheckOpString<>. Explicitly instantiated
+// in logging.cc.
+extern template std::string* MakeCheckOpString<int, int>(
+    const int&, const int&, const char* names);
+extern template
+std::string* MakeCheckOpString<unsigned long, unsigned long>(
+    const unsigned long&, const unsigned long&, const char* names);
+extern template
+std::string* MakeCheckOpString<unsigned long, unsigned int>(
+    const unsigned long&, const unsigned int&, const char* names);
+extern template
+std::string* MakeCheckOpString<unsigned int, unsigned long>(
+    const unsigned int&, const unsigned long&, const char* names);
+extern template
+std::string* MakeCheckOpString<std::string, std::string>(
+    const std::string&, const std::string&, const char* name);
+#endif
+
+// Helper functions for CHECK_OP macro.
+// The (int, int) specialization works around the issue that the compiler
+// will not instantiate the template version of the function on values of
+// unnamed enum type - see comment below.
+#define DEFINE_CHECK_OP_IMPL(name, op) \
+  template <class t1, class t2> \
+  inline std::string* Check##name##Impl(const t1& v1, const t2& v2, \
+                                        const char* names) { \
+    if (v1 op v2) return NULL; \
+    else return MakeCheckOpString(v1, v2, names); \
+  } \
+  inline std::string* Check##name##Impl(int v1, int v2, const char* names) { \
+    if (v1 op v2) return NULL; \
+    else return MakeCheckOpString(v1, v2, names); \
+  }
+DEFINE_CHECK_OP_IMPL(EQ, ==)
+DEFINE_CHECK_OP_IMPL(NE, !=)
+DEFINE_CHECK_OP_IMPL(LE, <=)
+DEFINE_CHECK_OP_IMPL(LT, < )
+DEFINE_CHECK_OP_IMPL(GE, >=)
+DEFINE_CHECK_OP_IMPL(GT, > )
+#undef DEFINE_CHECK_OP_IMPL
+
+#define CHECK_EQ(val1, val2) CHECK_OP(EQ, ==, val1, val2)
+#define CHECK_NE(val1, val2) CHECK_OP(NE, !=, val1, val2)
+#define CHECK_LE(val1, val2) CHECK_OP(LE, <=, val1, val2)
+#define CHECK_LT(val1, val2) CHECK_OP(LT, < , val1, val2)
+#define CHECK_GE(val1, val2) CHECK_OP(GE, >=, val1, val2)
+#define CHECK_GT(val1, val2) CHECK_OP(GT, > , val1, val2)
+
+#if defined(NDEBUG)
+#define ENABLE_DLOG 0
+#else
+#define ENABLE_DLOG 1
+#endif
+
+#if defined(NDEBUG) && !defined(DCHECK_ALWAYS_ON)
+#define DCHECK_IS_ON() 0
+#else
+#define DCHECK_IS_ON() 1
+#endif
+
+// Definitions for DLOG et al.
+
+#if ENABLE_DLOG
+
+#define DLOG_IS_ON(severity) LOG_IS_ON(severity)
+#define DLOG_IF(severity, condition) LOG_IF(severity, condition)
+#define DLOG_ASSERT(condition) LOG_ASSERT(condition)
+#define DPLOG_IF(severity, condition) PLOG_IF(severity, condition)
+#define DVLOG_IF(verboselevel, condition) VLOG_IF(verboselevel, condition)
+#define DVPLOG_IF(verboselevel, condition) VPLOG_IF(verboselevel, condition)
+
+#else  // ENABLE_DLOG
+
+// If ENABLE_DLOG is off, we want to avoid emitting any references to
+// |condition| (which may reference a variable defined only if NDEBUG
+// is not defined).  Contrast this with DCHECK et al., which has
+// different behavior.
+
+#define DLOG_IS_ON(severity) false
+#define DLOG_IF(severity, condition) EAT_STREAM_PARAMETERS
+#define DLOG_ASSERT(condition) EAT_STREAM_PARAMETERS
+#define DPLOG_IF(severity, condition) EAT_STREAM_PARAMETERS
+#define DVLOG_IF(verboselevel, condition) EAT_STREAM_PARAMETERS
+#define DVPLOG_IF(verboselevel, condition) EAT_STREAM_PARAMETERS
+
+#endif  // ENABLE_DLOG
+
+// DEBUG_MODE is for uses like
+//   if (DEBUG_MODE) foo.CheckThatFoo();
+// instead of
+//   #ifndef NDEBUG
+//     foo.CheckThatFoo();
+//   #endif
+//
+// We tie its state to ENABLE_DLOG.
+enum { DEBUG_MODE = ENABLE_DLOG };
+
+#undef ENABLE_DLOG
+
+#define DLOG(severity)                                          \
+  LAZY_STREAM(LOG_STREAM(severity), DLOG_IS_ON(severity))
+
+#define DPLOG(severity)                                         \
+  LAZY_STREAM(PLOG_STREAM(severity), DLOG_IS_ON(severity))
+
+#define DVLOG(verboselevel) DVLOG_IF(verboselevel, VLOG_IS_ON(verboselevel))
+
+#define DVPLOG(verboselevel) DVPLOG_IF(verboselevel, VLOG_IS_ON(verboselevel))
+
+// Definitions for DCHECK et al.
+
+#if DCHECK_IS_ON()
+
+#define COMPACT_GOOGLE_LOG_EX_DCHECK(ClassName, ...) \
+  COMPACT_GOOGLE_LOG_EX_FATAL(ClassName , ##__VA_ARGS__)
+#define COMPACT_GOOGLE_LOG_DCHECK COMPACT_GOOGLE_LOG_FATAL
+const LogSeverity LOG_DCHECK = LOG_FATAL;
+
+#else  // DCHECK_IS_ON()
+
+// These are just dummy values.
+#define COMPACT_GOOGLE_LOG_EX_DCHECK(ClassName, ...) \
+  COMPACT_GOOGLE_LOG_EX_INFO(ClassName , ##__VA_ARGS__)
+#define COMPACT_GOOGLE_LOG_DCHECK COMPACT_GOOGLE_LOG_INFO
+const LogSeverity LOG_DCHECK = LOG_INFO;
+
+#endif  // DCHECK_IS_ON()
+
+// DCHECK et al. make sure to reference |condition| regardless of
+// whether DCHECKs are enabled; this is so that we don't get unused
+// variable warnings if the only use of a variable is in a DCHECK.
+// This behavior is different from DLOG_IF et al.
+
+#define DCHECK(condition)                                           \
+  LAZY_STREAM(LOG_STREAM(DCHECK), DCHECK_IS_ON() && !(condition))   \
+      << "Check failed: " #condition ". "
+
+#define DPCHECK(condition)                                          \
+  LAZY_STREAM(PLOG_STREAM(DCHECK), DCHECK_IS_ON() && !(condition))  \
+      << "Check failed: " #condition ". "
+
+// Helper macro for binary operators.
+// Don't use this macro directly in your code, use DCHECK_EQ et al below.
+#define DCHECK_OP(name, op, val1, val2)                                   \
+  if (DCHECK_IS_ON())                                                     \
+    if (std::string* _result = cef::logging::Check##name##Impl(           \
+            (val1), (val2), #val1 " " #op " " #val2))                     \
+  cef::logging::LogMessage(__FILE__, __LINE__,                            \
+      ::cef::logging::LOG_DCHECK, _result).stream()
+
+// Equality/Inequality checks - compare two values, and log a
+// LOG_DCHECK message including the two values when the result is not
+// as expected.  The values must have operator<<(ostream, ...)
+// defined.
+//
+// You may append to the error message like so:
+//   DCHECK_NE(1, 2) << ": The world must be ending!";
+//
+// We are very careful to ensure that each argument is evaluated exactly
+// once, and that anything which is legal to pass as a function argument is
+// legal here.  In particular, the arguments may be temporary expressions
+// which will end up being destroyed at the end of the apparent statement,
+// for example:
+//   DCHECK_EQ(string("abc")[1], 'b');
+//
+// WARNING: These may not compile correctly if one of the arguments is a pointer
+// and the other is NULL. To work around this, simply static_cast NULL to the
+// type of the desired pointer.
+
+#define DCHECK_EQ(val1, val2) DCHECK_OP(EQ, ==, val1, val2)
+#define DCHECK_NE(val1, val2) DCHECK_OP(NE, !=, val1, val2)
+#define DCHECK_LE(val1, val2) DCHECK_OP(LE, <=, val1, val2)
+#define DCHECK_LT(val1, val2) DCHECK_OP(LT, < , val1, val2)
+#define DCHECK_GE(val1, val2) DCHECK_OP(GE, >=, val1, val2)
+#define DCHECK_GT(val1, val2) DCHECK_OP(GT, > , val1, val2)
+
+#if defined(NDEBUG) && defined(OS_CHROMEOS)
+#define NOTREACHED() LOG(ERROR) << "NOTREACHED() hit in " << \
+    __FUNCTION__ << ". "
+#else
+#define NOTREACHED() DCHECK(false)
+#endif
+
+// Redefine the standard assert to use our nice log files
+#undef assert
+#define assert(x) DLOG_ASSERT(x)
+
+// This class more or less represents a particular log message.  You
+// create an instance of LogMessage and then stream stuff to it.
+// When you finish streaming to it, ~LogMessage is called and the
+// full message gets streamed to the appropriate destination.
+//
+// You shouldn't actually use LogMessage's constructor to log things,
+// though.  You should use the LOG() macro (and variants thereof)
+// above.
+class LogMessage {
+ public:
+  // Used for LOG(severity).
+  LogMessage(const char* file, int line, LogSeverity severity);
+
+  // Used for CHECK_EQ(), etc. Takes ownership of the given string.
+  // Implied severity = LOG_FATAL.
+  LogMessage(const char* file, int line, std::string* result);
+
+  // Used for DCHECK_EQ(), etc. Takes ownership of the given string.
+  LogMessage(const char* file, int line, LogSeverity severity,
+             std::string* result);
+
+  ~LogMessage();
+
+  std::ostream& stream() { return stream_; }
+
+ private:
+  LogSeverity severity_;
+  std::ostringstream stream_;
+
+  // The file and line information passed in to the constructor.
+  const char* file_;
+  const int line_;
+
+#if defined(OS_WIN)
+  // Stores the current value of GetLastError in the constructor and restores
+  // it in the destructor by calling SetLastError.
+  // This is useful since the LogMessage class uses a lot of Win32 calls
+  // that will lose the value of GLE and the code that called the log function
+  // will have lost the thread error value when the log call returns.
+  class SaveLastError {
+   public:
+    SaveLastError();
+    ~SaveLastError();
+
+    unsigned long get_error() const { return last_error_; }
+
+   protected:
+    unsigned long last_error_;
+  };
+
+  SaveLastError last_error_;
+#endif
+
+  DISALLOW_COPY_AND_ASSIGN(LogMessage);
+};
+
+// A non-macro interface to the log facility; (useful
+// when the logging level is not a compile-time constant).
+inline void LogAtLevel(int const log_level, std::string const &msg) {
+  LogMessage(__FILE__, __LINE__, log_level).stream() << msg;
+}
+
+// This class is used to explicitly ignore values in the conditional
+// logging macros.  This avoids compiler warnings like "value computed
+// is not used" and "statement has no effect".
+class LogMessageVoidify {
+ public:
+  LogMessageVoidify() { }
+  // This has to be an operator with a precedence lower than << but
+  // higher than ?:
+  void operator&(std::ostream&) { }
+};
+
+#if defined(OS_WIN)
+typedef unsigned long SystemErrorCode;
+#elif defined(OS_POSIX)
+typedef int SystemErrorCode;
+#endif
+
+// Alias for ::GetLastError() on Windows and errno on POSIX. Avoids having to
+// pull in windows.h just for GetLastError() and DWORD.
+SystemErrorCode GetLastSystemErrorCode();
+std::string SystemErrorCodeToString(SystemErrorCode error_code);
+
+#if defined(OS_WIN)
+// Appends a formatted system message of the GetLastError() type.
+class Win32ErrorLogMessage {
+ public:
+  Win32ErrorLogMessage(const char* file,
+                       int line,
+                       LogSeverity severity,
+                       SystemErrorCode err);
+
+  // Appends the error message before destructing the encapsulated class.
+  ~Win32ErrorLogMessage();
+
+  std::ostream& stream() { return log_message_.stream(); }
+
+ private:
+  SystemErrorCode err_;
+  LogMessage log_message_;
+
+  DISALLOW_COPY_AND_ASSIGN(Win32ErrorLogMessage);
+};
+#elif defined(OS_POSIX)
+// Appends a formatted system message of the errno type
+class ErrnoLogMessage {
+ public:
+  ErrnoLogMessage(const char* file,
+                  int line,
+                  LogSeverity severity,
+                  SystemErrorCode err);
+
+  // Appends the error message before destructing the encapsulated class.
+  ~ErrnoLogMessage();
+
+  std::ostream& stream() { return log_message_.stream(); }
+
+ private:
+  SystemErrorCode err_;
+  LogMessage log_message_;
+
+  DISALLOW_COPY_AND_ASSIGN(ErrnoLogMessage);
+};
+#endif  // OS_WIN
+
+}  // namespace logging
+}  // namespace cef
+
+// These functions are provided as a convenience for logging, which is where we
+// use streams (it is against Google style to use streams in other places). It
+// is designed to allow you to emit non-ASCII Unicode strings to the log file,
+// which is normally ASCII. It is relatively slow, so try not to use it for
+// common cases. Non-ASCII characters will be converted to UTF-8 by these
+// operators.
+std::ostream& operator<<(std::ostream& out, const wchar_t* wstr);
+inline std::ostream& operator<<(std::ostream& out, const std::wstring& wstr) {
+  return out << wstr.c_str();
+}
+
+// The NOTIMPLEMENTED() macro annotates codepaths which have
+// not been implemented yet.
+//
+// The implementation of this macro is controlled by NOTIMPLEMENTED_POLICY:
+//   0 -- Do nothing (stripped by compiler)
+//   1 -- Warn at compile time
+//   2 -- Fail at compile time
+//   3 -- Fail at runtime (DCHECK)
+//   4 -- [default] LOG(ERROR) at runtime
+//   5 -- LOG(ERROR) at runtime, only once per call-site
+
+#ifndef NOTIMPLEMENTED_POLICY
+#if defined(OS_ANDROID) && defined(OFFICIAL_BUILD)
+#define NOTIMPLEMENTED_POLICY 0
+#else
+// Select default policy: LOG(ERROR)
+#define NOTIMPLEMENTED_POLICY 4
+#endif
+#endif
+
+#if defined(COMPILER_GCC)
+// On Linux, with GCC, we can use __PRETTY_FUNCTION__ to get the demangled name
+// of the current function in the NOTIMPLEMENTED message.
+#define NOTIMPLEMENTED_MSG "Not implemented reached in " << __PRETTY_FUNCTION__
+#else
+#define NOTIMPLEMENTED_MSG "NOT IMPLEMENTED"
+#endif
+
+#if NOTIMPLEMENTED_POLICY == 0
+#define NOTIMPLEMENTED() EAT_STREAM_PARAMETERS
+#elif NOTIMPLEMENTED_POLICY == 1
+// TODO, figure out how to generate a warning
+#define NOTIMPLEMENTED() COMPILE_ASSERT(false, NOT_IMPLEMENTED)
+#elif NOTIMPLEMENTED_POLICY == 2
+#define NOTIMPLEMENTED() COMPILE_ASSERT(false, NOT_IMPLEMENTED)
+#elif NOTIMPLEMENTED_POLICY == 3
+#define NOTIMPLEMENTED() NOTREACHED()
+#elif NOTIMPLEMENTED_POLICY == 4
+#define NOTIMPLEMENTED() LOG(ERROR) << NOTIMPLEMENTED_MSG
+#elif NOTIMPLEMENTED_POLICY == 5
+#define NOTIMPLEMENTED() do {\
+  static bool logged_once = false;\
+  LOG_IF(ERROR, !logged_once) << NOTIMPLEMENTED_MSG;\
+  logged_once = true;\
+} while(0);\
+EAT_STREAM_PARAMETERS
+#endif
+
+#endif  // !USING_CHROMIUM_INCLUDES
+
+#endif  // CEF_INCLUDE_BASE_CEF_LOGGING_H_
diff --git a/src/include/libcef/base/cef_macros.h b/src/include/libcef/base/cef_macros.h
new file mode 100644
index 0000000..884bd98
--- /dev/null
+++ b/src/include/libcef/base/cef_macros.h
@@ -0,0 +1,226 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2012
+// Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef CEF_INCLUDE_BASE_CEF_MACROS_H_
+#define CEF_INCLUDE_BASE_CEF_MACROS_H_
+#pragma once
+
+#if defined(USING_CHROMIUM_INCLUDES)
+// When building CEF include the Chromium header directly.
+#include "base/macros.h"
+
+// Chromium uses movable types.
+#define MOVE_SCOPED_PTR(var) std::move(var)
+
+#else  // !USING_CHROMIUM_INCLUDES
+// The following is substantially similar to the Chromium implementation.
+// If the Chromium implementation diverges the below implementation should be
+// updated to match.
+
+#include <stddef.h>  // For size_t.
+#include "libcef/base/cef_build.h"  // For COMPILER_MSVC
+
+// CEF does not use movable types.
+#define MOVE_SCOPED_PTR(var) var.Pass()
+
+#if !defined(arraysize)
+
+// The arraysize(arr) macro returns the # of elements in an array arr.
+// The expression is a compile-time constant, and therefore can be
+// used in defining new arrays, for example.  If you use arraysize on
+// a pointer by mistake, you will get a compile-time error.
+//
+// One caveat is that arraysize() doesn't accept any array of an
+// anonymous type or a type defined inside a function.  In these rare
+// cases, you have to use the unsafe ARRAYSIZE_UNSAFE() macro below.  This is
+// due to a limitation in C++'s template system.  The limitation might
+// eventually be removed, but it hasn't happened yet.
+
+// This template function declaration is used in defining arraysize.
+// Note that the function doesn't need an implementation, as we only
+// use its type.
+template <typename T, size_t N>
+char (&ArraySizeHelper(T (&array)[N]))[N];
+
+// That gcc wants both of these prototypes seems mysterious. VC, for
+// its part, can't decide which to use (another mystery). Matching of
+// template overloads: the final frontier.
+#ifndef _MSC_VER
+template <typename T, size_t N>
+char (&ArraySizeHelper(const T (&array)[N]))[N];
+#endif
+
+#define arraysize(array) (sizeof(ArraySizeHelper(array)))
+
+#endif  // !arraysize
+
+#if !defined(DISALLOW_COPY_AND_ASSIGN)
+
+// A macro to disallow the copy constructor and operator= functions
+// This should be used in the private: declarations for a class
+#define DISALLOW_COPY_AND_ASSIGN(TypeName) \
+  TypeName(const TypeName&);               \
+  void operator=(const TypeName&)
+
+#endif  // !DISALLOW_COPY_AND_ASSIGN
+
+#if !defined(DISALLOW_IMPLICIT_CONSTRUCTORS)
+
+// A macro to disallow all the implicit constructors, namely the
+// default constructor, copy constructor and operator= functions.
+//
+// This should be used in the private: declarations for a class
+// that wants to prevent anyone from instantiating it. This is
+// especially useful for classes containing only static methods.
+#define DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \
+  TypeName();                                    \
+  DISALLOW_COPY_AND_ASSIGN(TypeName)
+
+#endif  // !DISALLOW_IMPLICIT_CONSTRUCTORS
+
+#if !defined(COMPILE_ASSERT)
+
+// The COMPILE_ASSERT macro can be used to verify that a compile time
+// expression is true. For example, you could use it to verify the
+// size of a static array:
+//
+//   COMPILE_ASSERT(ARRAYSIZE_UNSAFE(content_type_names) == CONTENT_NUM_TYPES,
+//                  content_type_names_incorrect_size);
+//
+// or to make sure a struct is smaller than a certain size:
+//
+//   COMPILE_ASSERT(sizeof(foo) < 128, foo_too_large);
+//
+// The second argument to the macro is the name of the variable. If
+// the expression is false, most compilers will issue a warning/error
+// containing the name of the variable.
+
+#if __cplusplus >= 201103L
+
+// Under C++11, just use static_assert.
+#define COMPILE_ASSERT(expr, msg) static_assert(expr, #msg)
+
+#else
+
+namespace cef {
+
+template <bool>
+struct CompileAssert {
+};
+
+}  // namespace cef
+
+#define COMPILE_ASSERT(expr, msg) \
+  typedef cef::CompileAssert<(bool(expr))> msg[bool(expr) ? 1 : -1] \
+      ALLOW_UNUSED_TYPE
+
+// Implementation details of COMPILE_ASSERT:
+//
+// - COMPILE_ASSERT works by defining an array type that has -1
+//   elements (and thus is invalid) when the expression is false.
+//
+// - The simpler definition
+//
+//     #define COMPILE_ASSERT(expr, msg) typedef char msg[(expr) ? 1 : -1]
+//
+//   does not work, as gcc supports variable-length arrays whose sizes
+//   are determined at run-time (this is gcc's extension and not part
+//   of the C++ standard).  As a result, gcc fails to reject the
+//   following code with the simple definition:
+//
+//     int foo;
+//     COMPILE_ASSERT(foo, msg); // not supposed to compile as foo is
+//                               // not a compile-time constant.
+//
+// - By using the type CompileAssert<(bool(expr))>, we ensures that
+//   expr is a compile-time constant.  (Template arguments must be
+//   determined at compile-time.)
+//
+// - The outer parentheses in CompileAssert<(bool(expr))> are necessary
+//   to work around a bug in gcc 3.4.4 and 4.0.1.  If we had written
+//
+//     CompileAssert<bool(expr)>
+//
+//   instead, these compilers will refuse to compile
+//
+//     COMPILE_ASSERT(5 > 0, some_message);
+//
+//   (They seem to think the ">" in "5 > 0" marks the end of the
+//   template argument list.)
+//
+// - The array size is (bool(expr) ? 1 : -1), instead of simply
+//
+//     ((expr) ? 1 : -1).
+//
+//   This is to avoid running into a bug in MS VC 7.1, which
+//   causes ((0.0) ? 1 : -1) to incorrectly evaluate to 1.
+
+#endif  // !(__cplusplus >= 201103L)
+
+#endif  // !defined(COMPILE_ASSERT)
+
+#endif  // !USING_CHROMIUM_INCLUDES
+
+#if !defined(ALLOW_THIS_IN_INITIALIZER_LIST)
+#if defined(COMPILER_MSVC)
+
+// MSVC_PUSH_DISABLE_WARNING pushes |n| onto a stack of warnings to be disabled.
+// The warning remains disabled until popped by MSVC_POP_WARNING.
+#define MSVC_PUSH_DISABLE_WARNING(n) __pragma(warning(push)) \
+                                     __pragma(warning(disable:n))
+
+// MSVC_PUSH_WARNING_LEVEL pushes |n| as the global warning level.  The level
+// remains in effect until popped by MSVC_POP_WARNING().  Use 0 to disable all
+// warnings.
+#define MSVC_PUSH_WARNING_LEVEL(n) __pragma(warning(push, n))
+
+// Pop effects of innermost MSVC_PUSH_* macro.
+#define MSVC_POP_WARNING() __pragma(warning(pop))
+
+// Allows |this| to be passed as an argument in constructor initializer lists.
+// This uses push/pop instead of the seemingly simpler suppress feature to avoid
+// having the warning be disabled for more than just |code|.
+//
+// Example usage:
+// Foo::Foo() : x(NULL), ALLOW_THIS_IN_INITIALIZER_LIST(y(this)), z(3) {}
+//
+// Compiler warning C4355: 'this': used in base member initializer list:
+// http://msdn.microsoft.com/en-us/library/3c594ae3(VS.80).aspx
+#define ALLOW_THIS_IN_INITIALIZER_LIST(code) MSVC_PUSH_DISABLE_WARNING(4355) \
+                                             code \
+                                             MSVC_POP_WARNING()
+#else  // !COMPILER_MSVC
+
+#define ALLOW_THIS_IN_INITIALIZER_LIST(code) code
+
+#endif  // !COMPILER_MSVC
+#endif  // !ALLOW_THIS_IN_INITIALIZER_LIST
+
+#endif  // CEF_INCLUDE_BASE_CEF_MACROS_H_
diff --git a/src/include/libcef/base/cef_move.h b/src/include/libcef/base/cef_move.h
new file mode 100644
index 0000000..3c3c491
--- /dev/null
+++ b/src/include/libcef/base/cef_move.h
@@ -0,0 +1,259 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2012
+// Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef CEF_INCLUDE_BASE_CEF_MOVE_H_
+#define CEF_INCLUDE_BASE_CEF_MOVE_H_
+
+#if defined(MOVE_ONLY_TYPE_FOR_CPP_03)
+// Do nothing if the macro in this header has already been defined.
+// This can happen in cases where Chromium code is used directly by the
+// client application. When using Chromium code directly always include
+// the Chromium header first to avoid type conflicts.
+#elif defined(USING_CHROMIUM_INCLUDES)
+// When building CEF include the Chromium header directly.
+#include "base/move.h"
+#else  // !USING_CHROMIUM_INCLUDES
+// The following is substantially similar to the Chromium implementation.
+// If the Chromium implementation diverges the below implementation should be
+// updated to match.
+
+// Macro with the boilerplate that makes a type move-only in C++03.
+//
+// USAGE
+//
+// This macro should be used instead of DISALLOW_COPY_AND_ASSIGN to create
+// a "move-only" type.  Unlike DISALLOW_COPY_AND_ASSIGN, this macro should be
+// the first line in a class declaration.
+//
+// A class using this macro must call .Pass() (or somehow be an r-value already)
+// before it can be:
+//
+//   * Passed as a function argument
+//   * Used as the right-hand side of an assignment
+//   * Returned from a function
+//
+// Each class will still need to define their own "move constructor" and "move
+// operator=" to make this useful.  Here's an example of the macro, the move
+// constructor, and the move operator= from the scoped_ptr class:
+//
+//  template <typename T>
+//  class scoped_ptr {
+//     MOVE_ONLY_TYPE_FOR_CPP_03(scoped_ptr, RValue)
+//   public:
+//    scoped_ptr(RValue& other) : ptr_(other.release()) { }
+//    scoped_ptr& operator=(RValue& other) {
+//      swap(other);
+//      return *this;
+//    }
+//  };
+//
+// Note that the constructor must NOT be marked explicit.
+//
+// For consistency, the second parameter to the macro should always be RValue
+// unless you have a strong reason to do otherwise.  It is only exposed as a
+// macro parameter so that the move constructor and move operator= don't look
+// like they're using a phantom type.
+//
+//
+// HOW THIS WORKS
+//
+// For a thorough explanation of this technique, see:
+//
+//   http://en.wikibooks.org/wiki/More_C%2B%2B_Idioms/Move_Constructor
+//
+// The summary is that we take advantage of 2 properties:
+//
+//   1) non-const references will not bind to r-values.
+//   2) C++ can apply one user-defined conversion when initializing a
+//      variable.
+//
+// The first lets us disable the copy constructor and assignment operator
+// by declaring private version of them with a non-const reference parameter.
+//
+// For l-values, direct initialization still fails like in
+// DISALLOW_COPY_AND_ASSIGN because the copy constructor and assignment
+// operators are private.
+//
+// For r-values, the situation is different. The copy constructor and
+// assignment operator are not viable due to (1), so we are trying to call
+// a non-existent constructor and non-existing operator= rather than a private
+// one.  Since we have not committed an error quite yet, we can provide an
+// alternate conversion sequence and a constructor.  We add
+//
+//   * a private struct named "RValue"
+//   * a user-defined conversion "operator RValue()"
+//   * a "move constructor" and "move operator=" that take the RValue& as
+//     their sole parameter.
+//
+// Only r-values will trigger this sequence and execute our "move constructor"
+// or "move operator=."  L-values will match the private copy constructor and
+// operator= first giving a "private in this context" error.  This combination
+// gives us a move-only type.
+//
+// For signaling a destructive transfer of data from an l-value, we provide a
+// method named Pass() which creates an r-value for the current instance
+// triggering the move constructor or move operator=.
+//
+// Other ways to get r-values is to use the result of an expression like a
+// function call.
+//
+// Here's an example with comments explaining what gets triggered where:
+//
+//    class Foo {
+//      MOVE_ONLY_TYPE_FOR_CPP_03(Foo, RValue);
+//
+//     public:
+//       ... API ...
+//       Foo(RValue other);           // Move constructor.
+//       Foo& operator=(RValue rhs);  // Move operator=
+//    };
+//
+//    Foo MakeFoo();  // Function that returns a Foo.
+//
+//    Foo f;
+//    Foo f_copy(f);  // ERROR: Foo(Foo&) is private in this context.
+//    Foo f_assign;
+//    f_assign = f;   // ERROR: operator=(Foo&) is private in this context.
+//
+//
+//    Foo f(MakeFoo());      // R-value so alternate conversion executed.
+//    Foo f_copy(f.Pass());  // R-value so alternate conversion executed.
+//    f = f_copy.Pass();     // R-value so alternate conversion executed.
+//
+//
+// IMPLEMENTATION SUBTLETIES WITH RValue
+//
+// The RValue struct is just a container for a pointer back to the original
+// object. It should only ever be created as a temporary, and no external
+// class should ever declare it or use it in a parameter.
+//
+// It is tempting to want to use the RValue type in function parameters, but
+// excluding the limited usage here for the move constructor and move
+// operator=, doing so would mean that the function could take both r-values
+// and l-values equially which is unexpected.  See COMPARED To Boost.Move for
+// more details.
+//
+// An alternate, and incorrect, implementation of the RValue class used by
+// Boost.Move makes RValue a fieldless child of the move-only type. RValue&
+// is then used in place of RValue in the various operators.  The RValue& is
+// "created" by doing *reinterpret_cast<RValue*>(this).  This has the appeal
+// of never creating a temporary RValue struct even with optimizations
+// disabled.  Also, by virtue of inheritance you can treat the RValue
+// reference as if it were the move-only type itself.  Unfortunately,
+// using the result of this reinterpret_cast<> is actually undefined behavior
+// due to C++98 5.2.10.7. In certain compilers (e.g., NaCl) the optimizer
+// will generate non-working code.
+//
+// In optimized builds, both implementations generate the same assembly so we
+// choose the one that adheres to the standard.
+//
+//
+// WHY HAVE typedef void MoveOnlyTypeForCPP03
+//
+// Callback<>/Bind() needs to understand movable-but-not-copyable semantics
+// to call .Pass() appropriately when it is expected to transfer the value.
+// The cryptic typedef MoveOnlyTypeForCPP03 is added to make this check
+// easy and automatic in helper templates for Callback<>/Bind().
+// See IsMoveOnlyType template and its usage in base/callback_internal.h
+// for more details.
+//
+//
+// COMPARED TO C++11
+//
+// In C++11, you would implement this functionality using an r-value reference
+// and our .Pass() method would be replaced with a call to std::move().
+//
+// This emulation also has a deficiency where it uses up the single
+// user-defined conversion allowed by C++ during initialization.  This can
+// cause problems in some API edge cases.  For instance, in scoped_ptr, it is
+// impossible to make a function "void Foo(scoped_ptr<Parent> p)" accept a
+// value of type scoped_ptr<Child> even if you add a constructor to
+// scoped_ptr<> that would make it look like it should work.  C++11 does not
+// have this deficiency.
+//
+//
+// COMPARED TO Boost.Move
+//
+// Our implementation similar to Boost.Move, but we keep the RValue struct
+// private to the move-only type, and we don't use the reinterpret_cast<> hack.
+//
+// In Boost.Move, RValue is the boost::rv<> template.  This type can be used
+// when writing APIs like:
+//
+//   void MyFunc(boost::rv<Foo>& f)
+//
+// that can take advantage of rv<> to avoid extra copies of a type.  However you
+// would still be able to call this version of MyFunc with an l-value:
+//
+//   Foo f;
+//   MyFunc(f);  // Uh oh, we probably just destroyed |f| w/o calling Pass().
+//
+// unless someone is very careful to also declare a parallel override like:
+//
+//   void MyFunc(const Foo& f)
+//
+// that would catch the l-values first.  This was declared unsafe in C++11 and
+// a C++11 compiler will explicitly fail MyFunc(f).  Unfortunately, we cannot
+// ensure this in C++03.
+//
+// Since we have no need for writing such APIs yet, our implementation keeps
+// RValue private and uses a .Pass() method to do the conversion instead of
+// trying to write a version of "std::move()." Writing an API like std::move()
+// would require the RValue struct to be public.
+//
+//
+// CAVEATS
+//
+// If you include a move-only type as a field inside a class that does not
+// explicitly declare a copy constructor, the containing class's implicit
+// copy constructor will change from Containing(const Containing&) to
+// Containing(Containing&).  This can cause some unexpected errors.
+//
+//   http://llvm.org/bugs/show_bug.cgi?id=11528
+//
+// The workaround is to explicitly declare your copy constructor.
+//
+#define MOVE_ONLY_TYPE_FOR_CPP_03(type, rvalue_type) \
+ private: \
+  struct rvalue_type { \
+    explicit rvalue_type(type* object) : object(object) {} \
+    type* object; \
+  }; \
+  type(type&); \
+  void operator=(type&); \
+ public: \
+  operator rvalue_type() { return rvalue_type(this); } \
+  type Pass() { return type(rvalue_type(this)); } \
+  typedef void MoveOnlyTypeForCPP03; \
+ private:
+ 
+#endif  // !USING_CHROMIUM_INCLUDES
+
+#endif  // CEF_INCLUDE_BASE_CEF_MOVE_H_
diff --git a/src/include/libcef/base/cef_platform_thread.h b/src/include/libcef/base/cef_platform_thread.h
new file mode 100644
index 0000000..424c014
--- /dev/null
+++ b/src/include/libcef/base/cef_platform_thread.h
@@ -0,0 +1,113 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2011
+// Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// WARNING: You should *NOT* be using this class directly.  PlatformThread is
+// the low-level platform-specific abstraction to the OS's threading interface.
+// You should instead be using a message-loop driven Thread, see thread.h.
+
+#ifndef CEF_INCLUDE_BASE_PLATFORM_THREAD_H_
+#define CEF_INCLUDE_BASE_PLATFORM_THREAD_H_
+
+#if defined(BASE_THREADING_PLATFORM_THREAD_H_)
+// Do nothing if the Chromium header has already been included.
+// This can happen in cases where Chromium code is used directly by the
+// client application. When using Chromium code directly always include
+// the Chromium header first to avoid type conflicts.
+#elif defined(USING_CHROMIUM_INCLUDES)
+// When building CEF include the Chromium header directly.
+#include "base/threading/platform_thread.h"
+#else  // !USING_CHROMIUM_INCLUDES
+// The following is substantially similar to the Chromium implementation.
+// If the Chromium implementation diverges the below implementation should be
+// updated to match.
+
+#include "libcef/base/cef_basictypes.h"
+#include "libcef/base/cef_build.h"
+#include "libcef/internal/cef_thread_internal.h"
+
+namespace base {
+
+// Used for logging. Always an integer value.
+typedef cef_platform_thread_id_t PlatformThreadId;
+
+// Used for thread checking and debugging.
+// Meant to be as fast as possible.
+// These are produced by PlatformThread::CurrentRef(), and used to later
+// check if we are on the same thread or not by using ==. These are safe
+// to copy between threads, but can't be copied to another process as they
+// have no meaning there. Also, the internal identifier can be re-used
+// after a thread dies, so a PlatformThreadRef cannot be reliably used
+// to distinguish a new thread from an old, dead thread.
+class PlatformThreadRef {
+ public:
+  typedef cef_platform_thread_handle_t RefType;
+
+  PlatformThreadRef()
+      : id_(0) {
+  }
+
+  explicit PlatformThreadRef(RefType id)
+      : id_(id) {
+  }
+
+  bool operator==(PlatformThreadRef other) const {
+    return id_ == other.id_;
+  }
+
+  bool is_null() const {
+    return id_ == 0;
+  }
+ private:
+  RefType id_;
+};
+
+// A namespace for low-level thread functions.
+// Chromium uses a class with static methods but CEF uses an actual namespace
+// to avoid linker problems with the sandbox libaries on Windows.
+namespace PlatformThread {
+
+// Gets the current thread id, which may be useful for logging purposes.
+inline PlatformThreadId CurrentId() {
+  return cef_get_current_platform_thread_id();
+}
+
+// Gets the current thread reference, which can be used to check if
+// we're on the right thread quickly.
+inline PlatformThreadRef CurrentRef() {
+  return PlatformThreadRef(cef_get_current_platform_thread_handle());
+}
+
+}  // namespace PlatformThread
+
+}  // namespace base
+
+#endif  // !USING_CHROMIUM_INCLUDES
+
+#endif  // CEF_INCLUDE_BASE_PLATFORM_THREAD_H_
diff --git a/src/include/libcef/base/cef_ref_counted.h b/src/include/libcef/base/cef_ref_counted.h
new file mode 100644
index 0000000..b7734d8
--- /dev/null
+++ b/src/include/libcef/base/cef_ref_counted.h
@@ -0,0 +1,386 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2012
+// Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+
+#ifndef CEF_INCLUDE_BASE_CEF_REF_COUNTED_H_
+#define CEF_INCLUDE_BASE_CEF_REF_COUNTED_H_
+#pragma once
+
+#if defined(BASE_MEMORY_REF_COUNTED_H_)
+// Do nothing if the Chromium header has already been included.
+// This can happen in cases where Chromium code is used directly by the
+// client application. When using Chromium code directly always include
+// the Chromium header first to avoid type conflicts.
+#elif defined(USING_CHROMIUM_INCLUDES)
+// When building CEF include the Chromium header directly.
+#include "base/memory/ref_counted.h"
+#else  // !USING_CHROMIUM_INCLUDES
+// The following is substantially similar to the Chromium implementation.
+// If the Chromium implementation diverges the below implementation should be
+// updated to match.
+
+#include <cassert>
+
+#include "libcef/base/cef_atomic_ref_count.h"
+#include "libcef/base/cef_build.h"
+#ifndef NDEBUG
+#include "libcef/base/cef_logging.h"
+#endif
+#include "libcef/base/cef_thread_collision_warner.h"
+
+namespace base {
+
+namespace cef_subtle {
+
+class RefCountedBase {
+ public:
+  bool HasOneRef() const { return ref_count_ == 1; }
+
+ protected:
+  RefCountedBase()
+      : ref_count_(0)
+  #ifndef NDEBUG
+      , in_dtor_(false)
+  #endif
+      {
+  }
+
+  ~RefCountedBase() {
+  #ifndef NDEBUG
+    DCHECK(in_dtor_) << "RefCounted object deleted without calling Release()";
+  #endif
+  }
+
+
+  void AddRef() const {
+    // TODO(maruel): Add back once it doesn't assert 500 times/sec.
+    // Current thread books the critical section "AddRelease"
+    // without release it.
+    // DFAKE_SCOPED_LOCK_THREAD_LOCKED(add_release_);
+  #ifndef NDEBUG
+    DCHECK(!in_dtor_);
+  #endif
+    ++ref_count_;
+  }
+
+  // Returns true if the object should self-delete.
+  bool Release() const {
+    // TODO(maruel): Add back once it doesn't assert 500 times/sec.
+    // Current thread books the critical section "AddRelease"
+    // without release it.
+    // DFAKE_SCOPED_LOCK_THREAD_LOCKED(add_release_);
+  #ifndef NDEBUG
+    DCHECK(!in_dtor_);
+  #endif
+    if (--ref_count_ == 0) {
+  #ifndef NDEBUG
+      in_dtor_ = true;
+  #endif
+      return true;
+    }
+    return false;
+  }
+
+ private:
+  mutable int ref_count_;
+#ifndef NDEBUG
+  mutable bool in_dtor_;
+#endif
+
+  DFAKE_MUTEX(add_release_);
+
+  DISALLOW_COPY_AND_ASSIGN(RefCountedBase);
+};
+
+class RefCountedThreadSafeBase {
+ public:
+  bool HasOneRef() const;
+
+ protected:
+  RefCountedThreadSafeBase();
+  ~RefCountedThreadSafeBase();
+
+  void AddRef() const;
+
+  // Returns true if the object should self-delete.
+  bool Release() const;
+
+ private:
+  mutable AtomicRefCount ref_count_;
+#ifndef NDEBUG
+  mutable bool in_dtor_;
+#endif
+
+  DISALLOW_COPY_AND_ASSIGN(RefCountedThreadSafeBase);
+};
+
+}  // namespace cef_subtle
+
+//
+// A base class for reference counted classes.  Otherwise, known as a cheap
+// knock-off of WebKit's RefCounted<T> class.  To use this guy just extend your
+// class from it like so:
+//
+//   class MyFoo : public base::RefCounted<MyFoo> {
+//    ...
+//    private:
+//     friend class base::RefCounted<MyFoo>;
+//     ~MyFoo();
+//   };
+//
+// You should always make your destructor private, to avoid any code deleting
+// the object accidently while there are references to it.
+template <class T>
+class RefCounted : public cef_subtle::RefCountedBase {
+ public:
+  RefCounted() {}
+
+  void AddRef() const {
+    cef_subtle::RefCountedBase::AddRef();
+  }
+
+  void Release() const {
+    if (cef_subtle::RefCountedBase::Release()) {
+      delete static_cast<const T*>(this);
+    }
+  }
+
+ protected:
+  ~RefCounted() {}
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(RefCounted<T>);
+};
+
+// Forward declaration.
+template <class T, typename Traits> class RefCountedThreadSafe;
+
+// Default traits for RefCountedThreadSafe<T>.  Deletes the object when its ref
+// count reaches 0.  Overload to delete it on a different thread etc.
+template<typename T>
+struct DefaultRefCountedThreadSafeTraits {
+  static void Destruct(const T* x) {
+    // Delete through RefCountedThreadSafe to make child classes only need to be
+    // friend with RefCountedThreadSafe instead of this struct, which is an
+    // implementation detail.
+    RefCountedThreadSafe<T,
+                         DefaultRefCountedThreadSafeTraits>::DeleteInternal(x);
+  }
+};
+
+//
+// A thread-safe variant of RefCounted<T>
+//
+//   class MyFoo : public base::RefCountedThreadSafe<MyFoo> {
+//    ...
+//   };
+//
+// If you're using the default trait, then you should add compile time
+// asserts that no one else is deleting your object.  i.e.
+//    private:
+//     friend class base::RefCountedThreadSafe<MyFoo>;
+//     ~MyFoo();
+template <class T, typename Traits = DefaultRefCountedThreadSafeTraits<T> >
+class RefCountedThreadSafe : public cef_subtle::RefCountedThreadSafeBase {
+ public:
+  RefCountedThreadSafe() {}
+
+  void AddRef() const {
+    cef_subtle::RefCountedThreadSafeBase::AddRef();
+  }
+
+  void Release() const {
+    if (cef_subtle::RefCountedThreadSafeBase::Release()) {
+      Traits::Destruct(static_cast<const T*>(this));
+    }
+  }
+
+ protected:
+  ~RefCountedThreadSafe() {}
+
+ private:
+  friend struct DefaultRefCountedThreadSafeTraits<T>;
+  static void DeleteInternal(const T* x) { delete x; }
+
+  DISALLOW_COPY_AND_ASSIGN(RefCountedThreadSafe);
+};
+
+//
+// A thread-safe wrapper for some piece of data so we can place other
+// things in scoped_refptrs<>.
+//
+template<typename T>
+class RefCountedData
+    : public base::RefCountedThreadSafe< base::RefCountedData<T> > {
+ public:
+  RefCountedData() : data() {}
+  RefCountedData(const T& in_value) : data(in_value) {}
+
+  T data;
+
+ private:
+  friend class base::RefCountedThreadSafe<base::RefCountedData<T> >;
+  ~RefCountedData() {}
+};
+
+}  // namespace base
+
+//
+// A smart pointer class for reference counted objects.  Use this class instead
+// of calling AddRef and Release manually on a reference counted object to
+// avoid common memory leaks caused by forgetting to Release an object
+// reference.  Sample usage:
+//
+//   class MyFoo : public RefCounted<MyFoo> {
+//    ...
+//   };
+//
+//   void some_function() {
+//     scoped_refptr<MyFoo> foo = new MyFoo();
+//     foo->Method(param);
+//     // |foo| is released when this function returns
+//   }
+//
+//   void some_other_function() {
+//     scoped_refptr<MyFoo> foo = new MyFoo();
+//     ...
+//     foo = NULL;  // explicitly releases |foo|
+//     ...
+//     if (foo)
+//       foo->Method(param);
+//   }
+//
+// The above examples show how scoped_refptr<T> acts like a pointer to T.
+// Given two scoped_refptr<T> classes, it is also possible to exchange
+// references between the two objects, like so:
+//
+//   {
+//     scoped_refptr<MyFoo> a = new MyFoo();
+//     scoped_refptr<MyFoo> b;
+//
+//     b.swap(a);
+//     // now, |b| references the MyFoo object, and |a| references NULL.
+//   }
+//
+// To make both |a| and |b| in the above example reference the same MyFoo
+// object, simply use the assignment operator:
+//
+//   {
+//     scoped_refptr<MyFoo> a = new MyFoo();
+//     scoped_refptr<MyFoo> b;
+//
+//     b = a;
+//     // now, |a| and |b| each own a reference to the same MyFoo object.
+//   }
+//
+template <class T>
+class scoped_refptr {
+ public:
+  typedef T element_type;
+
+  scoped_refptr() : ptr_(NULL) {
+  }
+
+  scoped_refptr(T* p) : ptr_(p) {
+    if (ptr_)
+      ptr_->AddRef();
+  }
+
+  scoped_refptr(const scoped_refptr<T>& r) : ptr_(r.ptr_) {
+    if (ptr_)
+      ptr_->AddRef();
+  }
+
+  template <typename U>
+  scoped_refptr(const scoped_refptr<U>& r) : ptr_(r.get()) {
+    if (ptr_)
+      ptr_->AddRef();
+  }
+
+  ~scoped_refptr() {
+    if (ptr_)
+      ptr_->Release();
+  }
+
+  T* get() const { return ptr_; }
+
+  // Allow scoped_refptr<C> to be used in boolean expression
+  // and comparison operations.
+  operator T*() const { return ptr_; }
+
+  T* operator->() const {
+    assert(ptr_ != NULL);
+    return ptr_;
+  }
+
+  scoped_refptr<T>& operator=(T* p) {
+    // AddRef first so that self assignment should work
+    if (p)
+      p->AddRef();
+    T* old_ptr = ptr_;
+    ptr_ = p;
+    if (old_ptr)
+      old_ptr->Release();
+    return *this;
+  }
+
+  scoped_refptr<T>& operator=(const scoped_refptr<T>& r) {
+    return *this = r.ptr_;
+  }
+
+  template <typename U>
+  scoped_refptr<T>& operator=(const scoped_refptr<U>& r) {
+    return *this = r.get();
+  }
+
+  void swap(T** pp) {
+    T* p = ptr_;
+    ptr_ = *pp;
+    *pp = p;
+  }
+
+  void swap(scoped_refptr<T>& r) {
+    swap(&r.ptr_);
+  }
+
+ protected:
+  T* ptr_;
+};
+
+// Handy utility for creating a scoped_refptr<T> out of a T* explicitly without
+// having to retype all the template arguments
+template <typename T>
+scoped_refptr<T> make_scoped_refptr(T* t) {
+  return scoped_refptr<T>(t);
+}
+
+#endif  // !USING_CHROMIUM_INCLUDES
+
+#endif  // CEF_INCLUDE_BASE_CEF_REF_COUNTED_H_
diff --git a/src/include/libcef/base/cef_scoped_ptr.h b/src/include/libcef/base/cef_scoped_ptr.h
new file mode 100644
index 0000000..18b3065
--- /dev/null
+++ b/src/include/libcef/base/cef_scoped_ptr.h
@@ -0,0 +1,624 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2012
+// Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Scopers help you manage ownership of a pointer, helping you easily manage a
+// pointer within a scope, and automatically destroying the pointer at the end
+// of a scope.  There are two main classes you will use, which correspond to the
+// operators new/delete and new[]/delete[].
+//
+// Example usage (scoped_ptr<T>):
+//   {
+//     scoped_ptr<Foo> foo(new Foo("wee"));
+//   }  // foo goes out of scope, releasing the pointer with it.
+//
+//   {
+//     scoped_ptr<Foo> foo;          // No pointer managed.
+//     foo.reset(new Foo("wee"));    // Now a pointer is managed.
+//     foo.reset(new Foo("wee2"));   // Foo("wee") was destroyed.
+//     foo.reset(new Foo("wee3"));   // Foo("wee2") was destroyed.
+//     foo->Method();                // Foo::Method() called.
+//     foo.get()->Method();          // Foo::Method() called.
+//     SomeFunc(foo.release());      // SomeFunc takes ownership, foo no longer
+//                                   // manages a pointer.
+//     foo.reset(new Foo("wee4"));   // foo manages a pointer again.
+//     foo.reset();                  // Foo("wee4") destroyed, foo no longer
+//                                   // manages a pointer.
+//   }  // foo wasn't managing a pointer, so nothing was destroyed.
+//
+// Example usage (scoped_ptr<T[]>):
+//   {
+//     scoped_ptr<Foo[]> foo(new Foo[100]);
+//     foo.get()->Method();  // Foo::Method on the 0th element.
+//     foo[10].Method();     // Foo::Method on the 10th element.
+//   }
+//
+// These scopers also implement part of the functionality of C++11 unique_ptr
+// in that they are "movable but not copyable."  You can use the scopers in
+// the parameter and return types of functions to signify ownership transfer
+// in to and out of a function.  When calling a function that has a scoper
+// as the argument type, it must be called with the result of an analogous
+// scoper's Pass() function or another function that generates a temporary;
+// passing by copy will NOT work.  Here is an example using scoped_ptr:
+//
+//   void TakesOwnership(scoped_ptr<Foo> arg) {
+//     // Do something with arg
+//   }
+//   scoped_ptr<Foo> CreateFoo() {
+//     // No need for calling Pass() because we are constructing a temporary
+//     // for the return value.
+//     return scoped_ptr<Foo>(new Foo("new"));
+//   }
+//   scoped_ptr<Foo> PassThru(scoped_ptr<Foo> arg) {
+//     return arg.Pass();
+//   }
+//
+//   {
+//     scoped_ptr<Foo> ptr(new Foo("yay"));  // ptr manages Foo("yay").
+//     TakesOwnership(ptr.Pass());           // ptr no longer owns Foo("yay").
+//     scoped_ptr<Foo> ptr2 = CreateFoo();   // ptr2 owns the return Foo.
+//     scoped_ptr<Foo> ptr3 =                // ptr3 now owns what was in ptr2.
+//         PassThru(ptr2.Pass());            // ptr2 is correspondingly NULL.
+//   }
+//
+// Notice that if you do not call Pass() when returning from PassThru(), or
+// when invoking TakesOwnership(), the code will not compile because scopers
+// are not copyable; they only implement move semantics which require calling
+// the Pass() function to signify a destructive transfer of state. CreateFoo()
+// is different though because we are constructing a temporary on the return
+// line and thus can avoid needing to call Pass().
+//
+// Pass() properly handles upcast in initialization, i.e. you can use a
+// scoped_ptr<Child> to initialize a scoped_ptr<Parent>:
+//
+//   scoped_ptr<Foo> foo(new Foo());
+//   scoped_ptr<FooParent> parent(foo.Pass());
+//
+// PassAs<>() should be used to upcast return value in return statement:
+//
+//   scoped_ptr<Foo> CreateFoo() {
+//     scoped_ptr<FooChild> result(new FooChild());
+//     return result.PassAs<Foo>();
+//   }
+//
+// Note that PassAs<>() is implemented only for scoped_ptr<T>, but not for
+// scoped_ptr<T[]>. This is because casting array pointers may not be safe.
+
+#ifndef CEF_INCLUDE_BASE_CEF_MEMORY_SCOPED_PTR_H_
+#define CEF_INCLUDE_BASE_CEF_MEMORY_SCOPED_PTR_H_
+#pragma once
+
+#if defined(BASE_MEMORY_SCOPED_PTR_H_)
+// Do nothing if the Chromium header has already been included.
+// This can happen in cases where Chromium code is used directly by the
+// client application. When using Chromium code directly always include
+// the Chromium header first to avoid type conflicts.
+#elif defined(USING_CHROMIUM_INCLUDES)
+// When building CEF include the Chromium header directly.
+#include "base/memory/scoped_ptr.h"
+#else  // !USING_CHROMIUM_INCLUDES
+// The following is substantially similar to the Chromium implementation.
+// If the Chromium implementation diverges the below implementation should be
+// updated to match.
+
+// This is an implementation designed to match the anticipated future TR2
+// implementation of the scoped_ptr class.
+
+#include <assert.h>
+#include <stddef.h>
+#include <stdlib.h>
+
+#include <algorithm>  // For std::swap().
+
+#include "libcef/base/cef_basictypes.h"
+#include "libcef/base/cef_build.h"
+#include "libcef/base/cef_macros.h"
+#include "libcef/base/cef_move.h"
+#include "libcef/base/cef_template_util.h"
+
+namespace base {
+
+namespace subtle {
+class RefCountedBase;
+class RefCountedThreadSafeBase;
+}  // namespace subtle
+
+// Function object which deletes its parameter, which must be a pointer.
+// If C is an array type, invokes 'delete[]' on the parameter; otherwise,
+// invokes 'delete'. The default deleter for scoped_ptr<T>.
+template <class T>
+struct DefaultDeleter {
+  DefaultDeleter() {}
+  template <typename U> DefaultDeleter(const DefaultDeleter<U>& other) {
+    // IMPLEMENTATION NOTE: C++11 20.7.1.1.2p2 only provides this constructor
+    // if U* is implicitly convertible to T* and U is not an array type.
+    //
+    // Correct implementation should use SFINAE to disable this
+    // constructor. However, since there are no other 1-argument constructors,
+    // using a COMPILE_ASSERT() based on is_convertible<> and requiring
+    // complete types is simpler and will cause compile failures for equivalent
+    // misuses.
+    //
+    // Note, the is_convertible<U*, T*> check also ensures that U is not an
+    // array. T is guaranteed to be a non-array, so any U* where U is an array
+    // cannot convert to T*.
+    enum { T_must_be_complete = sizeof(T) };
+    enum { U_must_be_complete = sizeof(U) };
+    COMPILE_ASSERT((base::is_convertible<U*, T*>::value),
+                   U_ptr_must_implicitly_convert_to_T_ptr);
+  }
+  inline void operator()(T* ptr) const {
+    enum { type_must_be_complete = sizeof(T) };
+    delete ptr;
+  }
+};
+
+// Specialization of DefaultDeleter for array types.
+template <class T>
+struct DefaultDeleter<T[]> {
+  inline void operator()(T* ptr) const {
+    enum { type_must_be_complete = sizeof(T) };
+    delete[] ptr;
+  }
+
+ private:
+  // Disable this operator for any U != T because it is undefined to execute
+  // an array delete when the static type of the array mismatches the dynamic
+  // type.
+  //
+  // References:
+  //   C++98 [expr.delete]p3
+  //   http://cplusplus.github.com/LWG/lwg-defects.html#938
+  template <typename U> void operator()(U* array) const;
+};
+
+template <class T, int n>
+struct DefaultDeleter<T[n]> {
+  // Never allow someone to declare something like scoped_ptr<int[10]>.
+  COMPILE_ASSERT(sizeof(T) == -1, do_not_use_array_with_size_as_type);
+};
+
+// Function object which invokes 'free' on its parameter, which must be
+// a pointer. Can be used to store malloc-allocated pointers in scoped_ptr:
+//
+// scoped_ptr<int, base::FreeDeleter> foo_ptr(
+//     static_cast<int*>(malloc(sizeof(int))));
+struct FreeDeleter {
+  inline void operator()(void* ptr) const {
+    free(ptr);
+  }
+};
+
+namespace cef_internal {
+
+template <typename T> struct IsNotRefCounted {
+  enum {
+    value = !base::is_convertible<T*, base::subtle::RefCountedBase*>::value &&
+        !base::is_convertible<T*, base::subtle::RefCountedThreadSafeBase*>::
+            value
+  };
+};
+
+// Minimal implementation of the core logic of scoped_ptr, suitable for
+// reuse in both scoped_ptr and its specializations.
+template <class T, class D>
+class scoped_ptr_impl {
+ public:
+  explicit scoped_ptr_impl(T* p) : data_(p) { }
+
+  // Initializer for deleters that have data parameters.
+  scoped_ptr_impl(T* p, const D& d) : data_(p, d) {}
+
+  // Templated constructor that destructively takes the value from another
+  // scoped_ptr_impl.
+  template <typename U, typename V>
+  scoped_ptr_impl(scoped_ptr_impl<U, V>* other)
+      : data_(other->release(), other->get_deleter()) {
+    // We do not support move-only deleters.  We could modify our move
+    // emulation to have base::subtle::move() and base::subtle::forward()
+    // functions that are imperfect emulations of their C++11 equivalents,
+    // but until there's a requirement, just assume deleters are copyable.
+  }
+
+  template <typename U, typename V>
+  void TakeState(scoped_ptr_impl<U, V>* other) {
+    // See comment in templated constructor above regarding lack of support
+    // for move-only deleters.
+    reset(other->release());
+    get_deleter() = other->get_deleter();
+  }
+
+  ~scoped_ptr_impl() {
+    if (data_.ptr != NULL) {
+      // Not using get_deleter() saves one function call in non-optimized
+      // builds.
+      static_cast<D&>(data_)(data_.ptr);
+    }
+  }
+
+  void reset(T* p) {
+    // This is a self-reset, which is no longer allowed: http://crbug.com/162971
+    if (p != NULL && p == data_.ptr)
+      abort();
+
+    // Note that running data_.ptr = p can lead to undefined behavior if
+    // get_deleter()(get()) deletes this. In order to prevent this, reset()
+    // should update the stored pointer before deleting its old value.
+    //
+    // However, changing reset() to use that behavior may cause current code to
+    // break in unexpected ways. If the destruction of the owned object
+    // dereferences the scoped_ptr when it is destroyed by a call to reset(),
+    // then it will incorrectly dispatch calls to |p| rather than the original
+    // value of |data_.ptr|.
+    //
+    // During the transition period, set the stored pointer to NULL while
+    // deleting the object. Eventually, this safety check will be removed to
+    // prevent the scenario initially described from occuring and
+    // http://crbug.com/176091 can be closed.
+    T* old = data_.ptr;
+    data_.ptr = NULL;
+    if (old != NULL)
+      static_cast<D&>(data_)(old);
+    data_.ptr = p;
+  }
+
+  T* get() const { return data_.ptr; }
+
+  D& get_deleter() { return data_; }
+  const D& get_deleter() const { return data_; }
+
+  void swap(scoped_ptr_impl& p2) {
+    // Standard swap idiom: 'using std::swap' ensures that std::swap is
+    // present in the overload set, but we call swap unqualified so that
+    // any more-specific overloads can be used, if available.
+    using std::swap;
+    swap(static_cast<D&>(data_), static_cast<D&>(p2.data_));
+    swap(data_.ptr, p2.data_.ptr);
+  }
+
+  T* release() {
+    T* old_ptr = data_.ptr;
+    data_.ptr = NULL;
+    return old_ptr;
+  }
+
+ private:
+  // Needed to allow type-converting constructor.
+  template <typename U, typename V> friend class scoped_ptr_impl;
+
+  // Use the empty base class optimization to allow us to have a D
+  // member, while avoiding any space overhead for it when D is an
+  // empty class.  See e.g. http://www.cantrip.org/emptyopt.html for a good
+  // discussion of this technique.
+  struct Data : public D {
+    explicit Data(T* ptr_in) : ptr(ptr_in) {}
+    Data(T* ptr_in, const D& other) : D(other), ptr(ptr_in) {}
+    T* ptr;
+  };
+
+  Data data_;
+
+  DISALLOW_COPY_AND_ASSIGN(scoped_ptr_impl);
+};
+
+}  // namespace cef_internal
+
+}  // namespace base
+
+// A scoped_ptr<T> is like a T*, except that the destructor of scoped_ptr<T>
+// automatically deletes the pointer it holds (if any).
+// That is, scoped_ptr<T> owns the T object that it points to.
+// Like a T*, a scoped_ptr<T> may hold either NULL or a pointer to a T object.
+// Also like T*, scoped_ptr<T> is thread-compatible, and once you
+// dereference it, you get the thread safety guarantees of T.
+//
+// The size of scoped_ptr is small. On most compilers, when using the
+// DefaultDeleter, sizeof(scoped_ptr<T>) == sizeof(T*). Custom deleters will
+// increase the size proportional to whatever state they need to have. See
+// comments inside scoped_ptr_impl<> for details.
+//
+// Current implementation targets having a strict subset of  C++11's
+// unique_ptr<> features. Known deficiencies include not supporting move-only
+// deleteres, function pointers as deleters, and deleters with reference
+// types.
+template <class T, class D = base::DefaultDeleter<T> >
+class scoped_ptr {
+  MOVE_ONLY_TYPE_FOR_CPP_03(scoped_ptr, RValue)
+
+  COMPILE_ASSERT(base::cef_internal::IsNotRefCounted<T>::value,
+                 T_is_refcounted_type_and_needs_scoped_refptr);
+
+ public:
+  // The element and deleter types.
+  typedef T element_type;
+  typedef D deleter_type;
+
+  // Constructor.  Defaults to initializing with NULL.
+  scoped_ptr() : impl_(NULL) { }
+
+  // Constructor.  Takes ownership of p.
+  explicit scoped_ptr(element_type* p) : impl_(p) { }
+
+  // Constructor.  Allows initialization of a stateful deleter.
+  scoped_ptr(element_type* p, const D& d) : impl_(p, d) { }
+
+  // Constructor.  Allows construction from a scoped_ptr rvalue for a
+  // convertible type and deleter.
+  //
+  // IMPLEMENTATION NOTE: C++11 unique_ptr<> keeps this constructor distinct
+  // from the normal move constructor. By C++11 20.7.1.2.1.21, this constructor
+  // has different post-conditions if D is a reference type. Since this
+  // implementation does not support deleters with reference type,
+  // we do not need a separate move constructor allowing us to avoid one
+  // use of SFINAE. You only need to care about this if you modify the
+  // implementation of scoped_ptr.
+  template <typename U, typename V>
+  scoped_ptr(scoped_ptr<U, V> other) : impl_(&other.impl_) {
+    COMPILE_ASSERT(!base::is_array<U>::value, U_cannot_be_an_array);
+  }
+
+  // Constructor.  Move constructor for C++03 move emulation of this type.
+  scoped_ptr(RValue rvalue) : impl_(&rvalue.object->impl_) { }
+
+  // operator=.  Allows assignment from a scoped_ptr rvalue for a convertible
+  // type and deleter.
+  //
+  // IMPLEMENTATION NOTE: C++11 unique_ptr<> keeps this operator= distinct from
+  // the normal move assignment operator. By C++11 20.7.1.2.3.4, this templated
+  // form has different requirements on for move-only Deleters. Since this
+  // implementation does not support move-only Deleters, we do not need a
+  // separate move assignment operator allowing us to avoid one use of SFINAE.
+  // You only need to care about this if you modify the implementation of
+  // scoped_ptr.
+  template <typename U, typename V>
+  scoped_ptr& operator=(scoped_ptr<U, V> rhs) {
+    COMPILE_ASSERT(!base::is_array<U>::value, U_cannot_be_an_array);
+    impl_.TakeState(&rhs.impl_);
+    return *this;
+  }
+
+  // Reset.  Deletes the currently owned object, if any.
+  // Then takes ownership of a new object, if given.
+  void reset(element_type* p = NULL) { impl_.reset(p); }
+
+  // Accessors to get the owned object.
+  // operator* and operator-> will assert() if there is no current object.
+  element_type& operator*() const {
+    assert(impl_.get() != NULL);
+    return *impl_.get();
+  }
+  element_type* operator->() const  {
+    assert(impl_.get() != NULL);
+    return impl_.get();
+  }
+  element_type* get() const { return impl_.get(); }
+
+  // Access to the deleter.
+  deleter_type& get_deleter() { return impl_.get_deleter(); }
+  const deleter_type& get_deleter() const { return impl_.get_deleter(); }
+
+  // Allow scoped_ptr<element_type> to be used in boolean expressions, but not
+  // implicitly convertible to a real bool (which is dangerous).
+  //
+  // Note that this trick is only safe when the == and != operators
+  // are declared explicitly, as otherwise "scoped_ptr1 ==
+  // scoped_ptr2" will compile but do the wrong thing (i.e., convert
+  // to Testable and then do the comparison).
+ private:
+  typedef base::cef_internal::scoped_ptr_impl<element_type, deleter_type>
+      scoped_ptr::*Testable;
+
+ public:
+  operator Testable() const { return impl_.get() ? &scoped_ptr::impl_ : NULL; }
+
+  // Comparison operators.
+  // These return whether two scoped_ptr refer to the same object, not just to
+  // two different but equal objects.
+  bool operator==(const element_type* p) const { return impl_.get() == p; }
+  bool operator!=(const element_type* p) const { return impl_.get() != p; }
+
+  // Swap two scoped pointers.
+  void swap(scoped_ptr& p2) {
+    impl_.swap(p2.impl_);
+  }
+
+  // Release a pointer.
+  // The return value is the current pointer held by this object.
+  // If this object holds a NULL pointer, the return value is NULL.
+  // After this operation, this object will hold a NULL pointer,
+  // and will not own the object any more.
+  element_type* release() WARN_UNUSED_RESULT {
+    return impl_.release();
+  }
+
+  // C++98 doesn't support functions templates with default parameters which
+  // makes it hard to write a PassAs() that understands converting the deleter
+  // while preserving simple calling semantics.
+  //
+  // Until there is a use case for PassAs() with custom deleters, just ignore
+  // the custom deleter.
+  template <typename PassAsType>
+  scoped_ptr<PassAsType> PassAs() {
+    return scoped_ptr<PassAsType>(Pass());
+  }
+
+ private:
+  // Needed to reach into |impl_| in the constructor.
+  template <typename U, typename V> friend class scoped_ptr;
+  base::cef_internal::scoped_ptr_impl<element_type, deleter_type> impl_;
+
+  // Forbidden for API compatibility with std::unique_ptr.
+  explicit scoped_ptr(int disallow_construction_from_null);
+
+  // Forbid comparison of scoped_ptr types.  If U != T, it totally
+  // doesn't make sense, and if U == T, it still doesn't make sense
+  // because you should never have the same object owned by two different
+  // scoped_ptrs.
+  template <class U> bool operator==(scoped_ptr<U> const& p2) const;
+  template <class U> bool operator!=(scoped_ptr<U> const& p2) const;
+};
+
+template <class T, class D>
+class scoped_ptr<T[], D> {
+  MOVE_ONLY_TYPE_FOR_CPP_03(scoped_ptr, RValue)
+
+ public:
+  // The element and deleter types.
+  typedef T element_type;
+  typedef D deleter_type;
+
+  // Constructor.  Defaults to initializing with NULL.
+  scoped_ptr() : impl_(NULL) { }
+
+  // Constructor. Stores the given array. Note that the argument's type
+  // must exactly match T*. In particular:
+  // - it cannot be a pointer to a type derived from T, because it is
+  //   inherently unsafe in the general case to access an array through a
+  //   pointer whose dynamic type does not match its static type (eg., if
+  //   T and the derived types had different sizes access would be
+  //   incorrectly calculated). Deletion is also always undefined
+  //   (C++98 [expr.delete]p3). If you're doing this, fix your code.
+  // - it cannot be NULL, because NULL is an integral expression, not a
+  //   pointer to T. Use the no-argument version instead of explicitly
+  //   passing NULL.
+  // - it cannot be const-qualified differently from T per unique_ptr spec
+  //   (http://cplusplus.github.com/LWG/lwg-active.html#2118). Users wanting
+  //   to work around this may use implicit_cast<const T*>().
+  //   However, because of the first bullet in this comment, users MUST
+  //   NOT use implicit_cast<Base*>() to upcast the static type of the array.
+  explicit scoped_ptr(element_type* array) : impl_(array) { }
+
+  // Constructor.  Move constructor for C++03 move emulation of this type.
+  scoped_ptr(RValue rvalue) : impl_(&rvalue.object->impl_) { }
+
+  // operator=.  Move operator= for C++03 move emulation of this type.
+  scoped_ptr& operator=(RValue rhs) {
+    impl_.TakeState(&rhs.object->impl_);
+    return *this;
+  }
+
+  // Reset.  Deletes the currently owned array, if any.
+  // Then takes ownership of a new object, if given.
+  void reset(element_type* array = NULL) { impl_.reset(array); }
+
+  // Accessors to get the owned array.
+  element_type& operator[](size_t i) const {
+    assert(impl_.get() != NULL);
+    return impl_.get()[i];
+  }
+  element_type* get() const { return impl_.get(); }
+
+  // Access to the deleter.
+  deleter_type& get_deleter() { return impl_.get_deleter(); }
+  const deleter_type& get_deleter() const { return impl_.get_deleter(); }
+
+  // Allow scoped_ptr<element_type> to be used in boolean expressions, but not
+  // implicitly convertible to a real bool (which is dangerous).
+ private:
+  typedef base::cef_internal::scoped_ptr_impl<element_type, deleter_type>
+      scoped_ptr::*Testable;
+
+ public:
+  operator Testable() const { return impl_.get() ? &scoped_ptr::impl_ : NULL; }
+
+  // Comparison operators.
+  // These return whether two scoped_ptr refer to the same object, not just to
+  // two different but equal objects.
+  bool operator==(element_type* array) const { return impl_.get() == array; }
+  bool operator!=(element_type* array) const { return impl_.get() != array; }
+
+  // Swap two scoped pointers.
+  void swap(scoped_ptr& p2) {
+    impl_.swap(p2.impl_);
+  }
+
+  // Release a pointer.
+  // The return value is the current pointer held by this object.
+  // If this object holds a NULL pointer, the return value is NULL.
+  // After this operation, this object will hold a NULL pointer,
+  // and will not own the object any more.
+  element_type* release() WARN_UNUSED_RESULT {
+    return impl_.release();
+  }
+
+ private:
+  // Force element_type to be a complete type.
+  enum { type_must_be_complete = sizeof(element_type) };
+
+  // Actually hold the data.
+  base::cef_internal::scoped_ptr_impl<element_type, deleter_type> impl_;
+
+  // Disable initialization from any type other than element_type*, by
+  // providing a constructor that matches such an initialization, but is
+  // private and has no definition. This is disabled because it is not safe to
+  // call delete[] on an array whose static type does not match its dynamic
+  // type.
+  template <typename U> explicit scoped_ptr(U* array);
+  explicit scoped_ptr(int disallow_construction_from_null);
+
+  // Disable reset() from any type other than element_type*, for the same
+  // reasons as the constructor above.
+  template <typename U> void reset(U* array);
+  void reset(int disallow_reset_from_null);
+
+  // Forbid comparison of scoped_ptr types.  If U != T, it totally
+  // doesn't make sense, and if U == T, it still doesn't make sense
+  // because you should never have the same object owned by two different
+  // scoped_ptrs.
+  template <class U> bool operator==(scoped_ptr<U> const& p2) const;
+  template <class U> bool operator!=(scoped_ptr<U> const& p2) const;
+};
+
+// Free functions
+template <class T, class D>
+void swap(scoped_ptr<T, D>& p1, scoped_ptr<T, D>& p2) {
+  p1.swap(p2);
+}
+
+template <class T, class D>
+bool operator==(T* p1, const scoped_ptr<T, D>& p2) {
+  return p1 == p2.get();
+}
+
+template <class T, class D>
+bool operator!=(T* p1, const scoped_ptr<T, D>& p2) {
+  return p1 != p2.get();
+}
+
+// A function to convert T* into scoped_ptr<T>
+// Doing e.g. make_scoped_ptr(new FooBarBaz<type>(arg)) is a shorter notation
+// for scoped_ptr<FooBarBaz<type> >(new FooBarBaz<type>(arg))
+template <typename T>
+scoped_ptr<T> make_scoped_ptr(T* ptr) {
+  return scoped_ptr<T>(ptr);
+}
+
+#endif  // !USING_CHROMIUM_INCLUDES
+
+#endif  // CEF_INCLUDE_BASE_CEF_MEMORY_SCOPED_PTR_H_
diff --git a/src/include/libcef/base/cef_string16.h b/src/include/libcef/base/cef_string16.h
new file mode 100644
index 0000000..7ba1aa1
--- /dev/null
+++ b/src/include/libcef/base/cef_string16.h
@@ -0,0 +1,227 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2013
+// Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef CEF_INCLUDE_BASE_CEF_STRING16_H_
+#define CEF_INCLUDE_BASE_CEF_STRING16_H_
+#pragma once
+
+#if defined(BASE_STRINGS_STRING16_H_)
+// Do nothing if the Chromium header has already been included.
+// This can happen in cases where Chromium code is used directly by the
+// client application. When using Chromium code directly always include
+// the Chromium header first to avoid type conflicts.
+#elif defined(USING_CHROMIUM_INCLUDES)
+// When building CEF include the Chromium header directly.
+#include "base/strings/string16.h"
+#else  // !USING_CHROMIUM_INCLUDES
+// The following is substantially similar to the Chromium implementation.
+// If the Chromium implementation diverges the below implementation should be
+// updated to match.
+// WHAT:
+// A version of std::basic_string that provides 2-byte characters even when
+// wchar_t is not implemented as a 2-byte type. You can access this class as
+// string16. We also define char16, which string16 is based upon.
+//
+// WHY:
+// On Windows, wchar_t is 2 bytes, and it can conveniently handle UTF-16/UCS-2
+// data. Plenty of existing code operates on strings encoded as UTF-16.
+//
+// On many other platforms, sizeof(wchar_t) is 4 bytes by default. We can make
+// it 2 bytes by using the GCC flag -fshort-wchar. But then std::wstring fails
+// at run time, because it calls some functions (like wcslen) that come from
+// the system's native C library -- which was built with a 4-byte wchar_t!
+// It's wasteful to use 4-byte wchar_t strings to carry UTF-16 data, and it's
+// entirely improper on those systems where the encoding of wchar_t is defined
+// as UTF-32.
+//
+// Here, we define string16, which is similar to std::wstring but replaces all
+// libc functions with custom, 2-byte-char compatible routines. It is capable
+// of carrying UTF-16-encoded data.
+
+#include <stdio.h>
+#include <string>
+
+#include "libcef/base/cef_basictypes.h"
+
+#if defined(WCHAR_T_IS_UTF16)
+
+namespace base {
+
+typedef wchar_t char16;
+typedef std::wstring string16;
+typedef std::char_traits<wchar_t> string16_char_traits;
+
+}  // namespace base
+
+#elif defined(WCHAR_T_IS_UTF32)
+
+#include <stdint.h>  // For uint16_t
+
+#include "libcef/base/cef_macros.h"
+
+namespace base {
+
+typedef uint16_t char16;
+
+// char16 versions of the functions required by string16_char_traits; these
+// are based on the wide character functions of similar names ("w" or "wcs"
+// instead of "c16").
+int c16memcmp(const char16* s1, const char16* s2, size_t n);
+size_t c16len(const char16* s);
+const char16* c16memchr(const char16* s, char16 c, size_t n);
+char16* c16memmove(char16* s1, const char16* s2, size_t n);
+char16* c16memcpy(char16* s1, const char16* s2, size_t n);
+char16* c16memset(char16* s, char16 c, size_t n);
+
+struct string16_char_traits {
+  typedef char16 char_type;
+  typedef int int_type;
+
+  // int_type needs to be able to hold each possible value of char_type, and in
+  // addition, the distinct value of eof().
+  COMPILE_ASSERT(sizeof(int_type) > sizeof(char_type), unexpected_type_width);
+
+  typedef std::streamoff off_type;
+  typedef mbstate_t state_type;
+  typedef std::fpos<state_type> pos_type;
+
+  static void assign(char_type& c1, const char_type& c2) {
+    c1 = c2;
+  }
+
+  static bool eq(const char_type& c1, const char_type& c2) {
+    return c1 == c2;
+  }
+  static bool lt(const char_type& c1, const char_type& c2) {
+    return c1 < c2;
+  }
+
+  static int compare(const char_type* s1, const char_type* s2, size_t n) {
+    return c16memcmp(s1, s2, n);
+  }
+
+  static size_t length(const char_type* s) {
+    return c16len(s);
+  }
+
+  static const char_type* find(const char_type* s, size_t n,
+                               const char_type& a) {
+    return c16memchr(s, a, n);
+  }
+
+  static char_type* move(char_type* s1, const char_type* s2, int_type n) {
+    return c16memmove(s1, s2, n);
+  }
+
+  static char_type* copy(char_type* s1, const char_type* s2, size_t n) {
+    return c16memcpy(s1, s2, n);
+  }
+
+  static char_type* assign(char_type* s, size_t n, char_type a) {
+    return c16memset(s, a, n);
+  }
+
+  static int_type not_eof(const int_type& c) {
+    return eq_int_type(c, eof()) ? 0 : c;
+  }
+
+  static char_type to_char_type(const int_type& c) {
+    return char_type(c);
+  }
+
+  static int_type to_int_type(const char_type& c) {
+    return int_type(c);
+  }
+
+  static bool eq_int_type(const int_type& c1, const int_type& c2) {
+    return c1 == c2;
+  }
+
+  static int_type eof() {
+    return static_cast<int_type>(EOF);
+  }
+};
+
+typedef std::basic_string<char16, base::string16_char_traits> string16;
+
+extern std::ostream& operator<<(std::ostream& out, const string16& str);
+
+// This is required by googletest to print a readable output on test failures.
+extern void PrintTo(const string16& str, std::ostream* out);
+
+}  // namespace base
+
+// The string class will be explicitly instantiated only once, in string16.cc.
+//
+// std::basic_string<> in GNU libstdc++ contains a static data member,
+// _S_empty_rep_storage, to represent empty strings.  When an operation such
+// as assignment or destruction is performed on a string, causing its existing
+// data member to be invalidated, it must not be freed if this static data
+// member is being used.  Otherwise, it counts as an attempt to free static
+// (and not allocated) data, which is a memory error.
+//
+// Generally, due to C++ template magic, _S_empty_rep_storage will be marked
+// as a coalesced symbol, meaning that the linker will combine multiple
+// instances into a single one when generating output.
+//
+// If a string class is used by multiple shared libraries, a problem occurs.
+// Each library will get its own copy of _S_empty_rep_storage.  When strings
+// are passed across a library boundary for alteration or destruction, memory
+// errors will result.  GNU libstdc++ contains a configuration option,
+// --enable-fully-dynamic-string (_GLIBCXX_FULLY_DYNAMIC_STRING), which
+// disables the static data member optimization, but it's a good optimization
+// and non-STL code is generally at the mercy of the system's STL
+// configuration.  Fully-dynamic strings are not the default for GNU libstdc++
+// libstdc++ itself or for the libstdc++ installations on the systems we care
+// about, such as Mac OS X and relevant flavors of Linux.
+//
+// See also http://gcc.gnu.org/bugzilla/show_bug.cgi?id=24196 .
+//
+// To avoid problems, string classes need to be explicitly instantiated only
+// once, in exactly one library.  All other string users see it via an "extern"
+// declaration.  This is precisely how GNU libstdc++ handles
+// std::basic_string<char> (string) and std::basic_string<wchar_t> (wstring).
+//
+// This also works around a Mac OS X linker bug in ld64-85.2.1 (Xcode 3.1.2),
+// in which the linker does not fully coalesce symbols when dead code
+// stripping is enabled.  This bug causes the memory errors described above
+// to occur even when a std::basic_string<> does not cross shared library
+// boundaries, such as in statically-linked executables.
+//
+// TODO(mark): File this bug with Apple and update this note with a bug number.
+
+extern template
+class std::basic_string<base::char16, base::string16_char_traits>;
+
+#endif  // WCHAR_T_IS_UTF32
+
+#endif  // !USING_CHROMIUM_INCLUDES
+
+#endif  // CEF_INCLUDE_BASE_CEF_STRING16_H_
diff --git a/src/include/libcef/base/cef_template_util.h b/src/include/libcef/base/cef_template_util.h
new file mode 100644
index 0000000..fa618bf
--- /dev/null
+++ b/src/include/libcef/base/cef_template_util.h
@@ -0,0 +1,192 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2011
+// Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef CEF_INCLUDE_BASE_CEF_TEMPLATE_UTIL_H_
+#define CEF_INCLUDE_BASE_CEF_TEMPLATE_UTIL_H_
+#pragma once
+
+#if defined(BASE_TEMPLATE_UTIL_H_)
+// Do nothing if the Chromium header has already been included.
+// This can happen in cases where Chromium code is used directly by the
+// client application. When using Chromium code directly always include
+// the Chromium header first to avoid type conflicts.
+#elif defined(USING_CHROMIUM_INCLUDES)
+// When building CEF include the Chromium header directly.
+#include "base/template_util.h"
+#else  // !USING_CHROMIUM_INCLUDES
+// The following is substantially similar to the Chromium implementation.
+// If the Chromium implementation diverges the below implementation should be
+// updated to match.
+
+#include <cstddef>  // For size_t.
+
+#include "libcef/base/cef_build.h"
+
+namespace base {
+
+// template definitions from tr1
+
+template<class T, T v>
+struct integral_constant {
+  static const T value = v;
+  typedef T value_type;
+  typedef integral_constant<T, v> type;
+};
+
+template <class T, T v> const T integral_constant<T, v>::value;
+
+typedef integral_constant<bool, true> true_type;
+typedef integral_constant<bool, false> false_type;
+
+template <class T> struct is_pointer : false_type {};
+template <class T> struct is_pointer<T*> : true_type {};
+
+// Member function pointer detection up to four params. Add more as needed
+// below. This is built-in to C++ 11, and we can remove this when we switch.
+template<typename T>
+struct is_member_function_pointer : false_type {};
+
+template <typename R, typename Z>
+struct is_member_function_pointer<R(Z::*)()> : true_type {};
+template <typename R, typename Z>
+struct is_member_function_pointer<R(Z::*)() const> : true_type {};
+
+template <typename R, typename Z, typename A>
+struct is_member_function_pointer<R(Z::*)(A)> : true_type {};
+template <typename R, typename Z, typename A>
+struct is_member_function_pointer<R(Z::*)(A) const> : true_type {};
+
+template <typename R, typename Z, typename A, typename B>
+struct is_member_function_pointer<R(Z::*)(A, B)> : true_type {};
+template <typename R, typename Z, typename A, typename B>
+struct is_member_function_pointer<R(Z::*)(A, B) const> : true_type {};
+
+template <typename R, typename Z, typename A, typename B, typename C>
+struct is_member_function_pointer<R(Z::*)(A, B, C)> : true_type {};
+template <typename R, typename Z, typename A, typename B, typename C>
+struct is_member_function_pointer<R(Z::*)(A, B, C) const> : true_type {};
+
+template <typename R, typename Z, typename A, typename B, typename C,
+          typename D>
+struct is_member_function_pointer<R(Z::*)(A, B, C, D)> : true_type {};
+template <typename R, typename Z, typename A, typename B, typename C,
+          typename D>
+struct is_member_function_pointer<R(Z::*)(A, B, C, D) const> : true_type {};
+
+
+template <class T, class U> struct is_same : public false_type {};
+template <class T> struct is_same<T,T> : true_type {};
+
+template<class> struct is_array : public false_type {};
+template<class T, size_t n> struct is_array<T[n]> : public true_type {};
+template<class T> struct is_array<T[]> : public true_type {};
+
+template <class T> struct is_non_const_reference : false_type {};
+template <class T> struct is_non_const_reference<T&> : true_type {};
+template <class T> struct is_non_const_reference<const T&> : false_type {};
+
+template <class T> struct is_const : false_type {};
+template <class T> struct is_const<const T> : true_type {};
+
+template <class T> struct is_void : false_type {};
+template <> struct is_void<void> : true_type {};
+
+namespace cef_internal {
+
+// Types YesType and NoType are guaranteed such that sizeof(YesType) <
+// sizeof(NoType).
+typedef char YesType;
+
+struct NoType {
+  YesType dummy[2];
+};
+
+// This class is an implementation detail for is_convertible, and you
+// don't need to know how it works to use is_convertible. For those
+// who care: we declare two different functions, one whose argument is
+// of type To and one with a variadic argument list. We give them
+// return types of different size, so we can use sizeof to trick the
+// compiler into telling us which function it would have chosen if we
+// had called it with an argument of type From.  See Alexandrescu's
+// _Modern C++ Design_ for more details on this sort of trick.
+
+struct ConvertHelper {
+  template <typename To>
+  static YesType Test(To);
+
+  template <typename To>
+  static NoType Test(...);
+
+  template <typename From>
+  static From& Create();
+};
+
+// Used to determine if a type is a struct/union/class. Inspired by Boost's
+// is_class type_trait implementation.
+struct IsClassHelper {
+  template <typename C>
+  static YesType Test(void(C::*)(void));
+
+  template <typename C>
+  static NoType Test(...);
+};
+
+}  // namespace cef_internal
+
+// Inherits from true_type if From is convertible to To, false_type otherwise.
+//
+// Note that if the type is convertible, this will be a true_type REGARDLESS
+// of whether or not the conversion would emit a warning.
+template <typename From, typename To>
+struct is_convertible
+    : integral_constant<bool,
+                        sizeof(cef_internal::ConvertHelper::Test<To>(
+                                   cef_internal::ConvertHelper::Create<From>())) ==
+                        sizeof(cef_internal::YesType)> {
+};
+
+template <typename T>
+struct is_class
+    : integral_constant<bool,
+                        sizeof(cef_internal::IsClassHelper::Test<T>(0)) ==
+                            sizeof(cef_internal::YesType)> {
+};
+
+template<bool B, class T = void>
+struct enable_if {};
+
+template<class T>
+struct enable_if<true, T> { typedef T type; };
+
+}  // namespace base
+
+#endif  // !USING_CHROMIUM_INCLUDES
+
+#endif  // CEF_INCLUDE_BASE_CEF_TEMPLATE_UTIL_H_
diff --git a/src/include/libcef/base/cef_thread_checker.h b/src/include/libcef/base/cef_thread_checker.h
new file mode 100644
index 0000000..1e9ec06
--- /dev/null
+++ b/src/include/libcef/base/cef_thread_checker.h
@@ -0,0 +1,126 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2012
+// Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef CEF_INCLUDE_BASE_THREAD_CHECKER_H_
+#define CEF_INCLUDE_BASE_THREAD_CHECKER_H_
+#pragma once
+
+#if defined(BASE_THREADING_THREAD_CHECKER_H_)
+// Do nothing if the Chromium header has already been included.
+// This can happen in cases where Chromium code is used directly by the
+// client application. When using Chromium code directly always include
+// the Chromium header first to avoid type conflicts.
+#elif defined(USING_CHROMIUM_INCLUDES)
+// When building CEF include the Chromium header directly.
+#include "base/threading/thread_checker.h"
+#else  // !USING_CHROMIUM_INCLUDES
+// The following is substantially similar to the Chromium implementation.
+// If the Chromium implementation diverges the below implementation should be
+// updated to match.
+
+#include "libcef/base/cef_logging.h"
+#include "libcef/base/internal/cef_thread_checker_impl.h"
+
+// Apart from debug builds, we also enable the thread checker in
+// builds with DCHECK_ALWAYS_ON so that trybots and waterfall bots
+// with this define will get the same level of thread checking as
+// debug bots.
+#if DCHECK_IS_ON()
+#define ENABLE_THREAD_CHECKER 1
+#else
+#define ENABLE_THREAD_CHECKER 0
+#endif
+
+
+namespace base {
+
+namespace cef_internal {
+
+// Do nothing implementation, for use in release mode.
+//
+// Note: You should almost always use the ThreadChecker class to get the
+// right version for your build configuration.
+class ThreadCheckerDoNothing {
+ public:
+  bool CalledOnValidThread() const {
+    return true;
+  }
+
+  void DetachFromThread() {}
+};
+
+}  // namespace cef_internal
+
+// ThreadChecker is a helper class used to help verify that some methods of a
+// class are called from the same thread. It provides identical functionality to
+// base::NonThreadSafe, but it is meant to be held as a member variable, rather
+// than inherited from base::NonThreadSafe.
+//
+// While inheriting from base::NonThreadSafe may give a clear indication about
+// the thread-safety of a class, it may also lead to violations of the style
+// guide with regard to multiple inheritance. The choice between having a
+// ThreadChecker member and inheriting from base::NonThreadSafe should be based
+// on whether:
+//  - Derived classes need to know the thread they belong to, as opposed to
+//    having that functionality fully encapsulated in the base class.
+//  - Derived classes should be able to reassign the base class to another
+//    thread, via DetachFromThread.
+//
+// If neither of these are true, then having a ThreadChecker member and calling
+// CalledOnValidThread is the preferable solution.
+//
+// Example:
+// class MyClass {
+//  public:
+//   void Foo() {
+//     DCHECK(thread_checker_.CalledOnValidThread());
+//     ... (do stuff) ...
+//   }
+//
+//  private:
+//   ThreadChecker thread_checker_;
+// }
+//
+// In Release mode, CalledOnValidThread will always return true.
+#if ENABLE_THREAD_CHECKER
+class ThreadChecker : public cef_internal::ThreadCheckerImpl {
+};
+#else
+class ThreadChecker : public cef_internal::ThreadCheckerDoNothing {
+};
+#endif  // ENABLE_THREAD_CHECKER
+
+#undef ENABLE_THREAD_CHECKER
+
+}  // namespace base
+
+#endif  // !USING_CHROMIUM_INCLUDES
+
+#endif  // CEF_INCLUDE_BASE_THREAD_CHECKER_H_
diff --git a/src/include/libcef/base/cef_thread_collision_warner.h b/src/include/libcef/base/cef_thread_collision_warner.h
new file mode 100644
index 0000000..5fb9982
--- /dev/null
+++ b/src/include/libcef/base/cef_thread_collision_warner.h
@@ -0,0 +1,287 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2012
+// Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef CEF_INCLUDE_BASE_CEF_THREAD_COLLISION_WARNER_H_
+#define CEF_INCLUDE_BASE_CEF_THREAD_COLLISION_WARNER_H_
+#pragma once
+
+#if defined(BASE_THREADING_THREAD_COLLISION_WARNER_H_)
+// Do nothing if the Chromium header has already been included.
+// This can happen in cases where Chromium code is used directly by the
+// client application. When using Chromium code directly always include
+// the Chromium header first to avoid type conflicts.
+#elif defined(USING_CHROMIUM_INCLUDES)
+// When building CEF include the Chromium header directly.
+#include "base/threading/thread_collision_warner.h"
+#else  // !USING_CHROMIUM_INCLUDES
+// The following is substantially similar to the Chromium implementation.
+// If the Chromium implementation diverges the below implementation should be
+// updated to match.
+
+#include <memory>
+
+#include "libcef/base/cef_atomicops.h"
+#include "libcef/base/cef_basictypes.h"
+#include "libcef/base/cef_build.h"
+#include "libcef/base/cef_macros.h"
+
+// A helper class alongside macros to be used to verify assumptions about thread
+// safety of a class.
+//
+// Example: Queue implementation non thread-safe but still usable if clients
+//          are synchronized somehow.
+//
+//          In this case the macro DFAKE_SCOPED_LOCK has to be
+//          used, it checks that if a thread is inside the push/pop then
+//          noone else is still inside the pop/push
+//
+// class NonThreadSafeQueue {
+//  public:
+//   ...
+//   void push(int) { DFAKE_SCOPED_LOCK(push_pop_); ... }
+//   int pop() { DFAKE_SCOPED_LOCK(push_pop_); ... }
+//   ...
+//  private:
+//   DFAKE_MUTEX(push_pop_);
+// };
+//
+//
+// Example: Queue implementation non thread-safe but still usable if clients
+//          are synchronized somehow, it calls a method to "protect" from
+//          a "protected" method
+//
+//          In this case the macro DFAKE_SCOPED_RECURSIVE_LOCK
+//          has to be used, it checks that if a thread is inside the push/pop
+//          then noone else is still inside the pop/push
+//
+// class NonThreadSafeQueue {
+//  public:
+//   void push(int) {
+//     DFAKE_SCOPED_LOCK(push_pop_);
+//     ...
+//   }
+//   int pop() {
+//     DFAKE_SCOPED_RECURSIVE_LOCK(push_pop_);
+//     bar();
+//     ...
+//   }
+//   void bar() { DFAKE_SCOPED_RECURSIVE_LOCK(push_pop_); ... }
+//   ...
+//  private:
+//   DFAKE_MUTEX(push_pop_);
+// };
+//
+//
+// Example: Queue implementation not usable even if clients are synchronized,
+//          so only one thread in the class life cycle can use the two members
+//          push/pop.
+//
+//          In this case the macro DFAKE_SCOPED_LOCK_THREAD_LOCKED pins the
+//          specified
+//          critical section the first time a thread enters push or pop, from
+//          that time on only that thread is allowed to execute push or pop.
+//
+// class NonThreadSafeQueue {
+//  public:
+//   ...
+//   void push(int) { DFAKE_SCOPED_LOCK_THREAD_LOCKED(push_pop_); ... }
+//   int pop() { DFAKE_SCOPED_LOCK_THREAD_LOCKED(push_pop_); ... }
+//   ...
+//  private:
+//   DFAKE_MUTEX(push_pop_);
+// };
+//
+//
+// Example: Class that has to be contructed/destroyed on same thread, it has
+//          a "shareable" method (with external synchronization) and a not
+//          shareable method (even with external synchronization).
+//
+//          In this case 3 Critical sections have to be defined
+//
+// class ExoticClass {
+//  public:
+//   ExoticClass() { DFAKE_SCOPED_LOCK_THREAD_LOCKED(ctor_dtor_); ... }
+//   ~ExoticClass() { DFAKE_SCOPED_LOCK_THREAD_LOCKED(ctor_dtor_); ... }
+//
+//   void Shareable() { DFAKE_SCOPED_LOCK(shareable_section_); ... }
+//   void NotShareable() { DFAKE_SCOPED_LOCK_THREAD_LOCKED(ctor_dtor_); ... }
+//   ...
+//  private:
+//   DFAKE_MUTEX(ctor_dtor_);
+//   DFAKE_MUTEX(shareable_section_);
+// };
+
+
+#if !defined(NDEBUG)
+
+// Defines a class member that acts like a mutex. It is used only as a
+// verification tool.
+#define DFAKE_MUTEX(obj) \
+     mutable base::ThreadCollisionWarner obj
+// Asserts the call is never called simultaneously in two threads. Used at
+// member function scope.
+#define DFAKE_SCOPED_LOCK(obj) \
+     base::ThreadCollisionWarner::ScopedCheck s_check_##obj(&obj)
+// Asserts the call is never called simultaneously in two threads. Used at
+// member function scope. Same as DFAKE_SCOPED_LOCK but allows recursive locks.
+#define DFAKE_SCOPED_RECURSIVE_LOCK(obj) \
+     base::ThreadCollisionWarner::ScopedRecursiveCheck sr_check_##obj(&obj)
+// Asserts the code is always executed in the same thread.
+#define DFAKE_SCOPED_LOCK_THREAD_LOCKED(obj) \
+     base::ThreadCollisionWarner::Check check_##obj(&obj)
+
+#else
+
+#define DFAKE_MUTEX(obj) typedef void InternalFakeMutexType##obj
+#define DFAKE_SCOPED_LOCK(obj) ((void)0)
+#define DFAKE_SCOPED_RECURSIVE_LOCK(obj) ((void)0)
+#define DFAKE_SCOPED_LOCK_THREAD_LOCKED(obj) ((void)0)
+
+#endif
+
+namespace base {
+
+// The class ThreadCollisionWarner uses an Asserter to notify the collision
+// AsserterBase is the interfaces and DCheckAsserter is the default asserter
+// used. During the unit tests is used another class that doesn't "DCHECK"
+// in case of collision (check thread_collision_warner_unittests.cc)
+struct AsserterBase {
+  virtual ~AsserterBase() {}
+  virtual void warn() = 0;
+};
+
+struct DCheckAsserter : public AsserterBase {
+  virtual ~DCheckAsserter() {}
+  virtual void warn() OVERRIDE;
+};
+
+class ThreadCollisionWarner {
+ public:
+  // The parameter asserter is there only for test purpose
+  explicit ThreadCollisionWarner(AsserterBase* asserter = new DCheckAsserter())
+      : valid_thread_id_(0),
+        counter_(0),
+        asserter_(asserter) {}
+
+  ~ThreadCollisionWarner() {
+    delete asserter_;
+  }
+
+  // This class is meant to be used through the macro
+  // DFAKE_SCOPED_LOCK_THREAD_LOCKED
+  // it doesn't leave the critical section, as opposed to ScopedCheck,
+  // because the critical section being pinned is allowed to be used only
+  // from one thread
+  class Check {
+   public:
+    explicit Check(ThreadCollisionWarner* warner)
+        : warner_(warner) {
+      warner_->EnterSelf();
+    }
+
+    ~Check() {}
+
+   private:
+    ThreadCollisionWarner* warner_;
+
+    DISALLOW_COPY_AND_ASSIGN(Check);
+  };
+
+  // This class is meant to be used through the macro
+  // DFAKE_SCOPED_LOCK
+  class ScopedCheck {
+   public:
+    explicit ScopedCheck(ThreadCollisionWarner* warner)
+        : warner_(warner) {
+      warner_->Enter();
+    }
+
+    ~ScopedCheck() {
+      warner_->Leave();
+    }
+
+   private:
+    ThreadCollisionWarner* warner_;
+
+    DISALLOW_COPY_AND_ASSIGN(ScopedCheck);
+  };
+
+  // This class is meant to be used through the macro
+  // DFAKE_SCOPED_RECURSIVE_LOCK
+  class ScopedRecursiveCheck {
+   public:
+    explicit ScopedRecursiveCheck(ThreadCollisionWarner* warner)
+        : warner_(warner) {
+      warner_->EnterSelf();
+    }
+
+    ~ScopedRecursiveCheck() {
+      warner_->Leave();
+    }
+
+   private:
+    ThreadCollisionWarner* warner_;
+
+    DISALLOW_COPY_AND_ASSIGN(ScopedRecursiveCheck);
+  };
+
+ private:
+  // This method stores the current thread identifier and does a DCHECK
+  // if a another thread has already done it, it is safe if same thread
+  // calls this multiple time (recursion allowed).
+  void EnterSelf();
+
+  // Same as EnterSelf but recursion is not allowed.
+  void Enter();
+
+  // Removes the thread_id stored in order to allow other threads to
+  // call EnterSelf or Enter.
+  void Leave();
+
+  // This stores the thread id that is inside the critical section, if the
+  // value is 0 then no thread is inside.
+  volatile subtle::Atomic32 valid_thread_id_;
+
+  // Counter to trace how many time a critical section was "pinned"
+  // (when allowed) in order to unpin it when counter_ reaches 0.
+  volatile subtle::Atomic32 counter_;
+
+  // Here only for class unit tests purpose, during the test I need to not
+  // DCHECK but notify the collision with something else.
+  AsserterBase* asserter_;
+
+  DISALLOW_COPY_AND_ASSIGN(ThreadCollisionWarner);
+};
+
+}  // namespace base
+
+#endif  // !USING_CHROMIUM_INCLUDES
+
+#endif  // CEF_INCLUDE_BASE_CEF_THREAD_COLLISION_WARNER_H_
diff --git a/src/include/libcef/base/cef_trace_event.h b/src/include/libcef/base/cef_trace_event.h
new file mode 100644
index 0000000..05004b2
--- /dev/null
+++ b/src/include/libcef/base/cef_trace_event.h
@@ -0,0 +1,427 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2012
+// Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+///
+// Trace events are for tracking application performance and resource usage.
+// Macros are provided to track:
+//    Begin and end of function calls
+//    Counters
+//
+// Events are issued against categories. Whereas LOG's categories are statically
+// defined, TRACE categories are created implicitly with a string. For example:
+//   TRACE_EVENT_INSTANT0("MY_SUBSYSTEM", "SomeImportantEvent")
+//
+// Events can be INSTANT, or can be pairs of BEGIN and END in the same scope:
+//   TRACE_EVENT_BEGIN0("MY_SUBSYSTEM", "SomethingCostly")
+//   doSomethingCostly()
+//   TRACE_EVENT_END0("MY_SUBSYSTEM", "SomethingCostly")
+// Note: Our tools can't always determine the correct BEGIN/END pairs unless
+// these are used in the same scope. Use ASYNC_BEGIN/ASYNC_END macros if you
+// need them to be in separate scopes.
+//
+// A common use case is to trace entire function scopes. This issues a trace
+// BEGIN and END automatically:
+//   void doSomethingCostly() {
+//     TRACE_EVENT0("MY_SUBSYSTEM", "doSomethingCostly");
+//     ...
+//   }
+//
+// Additional parameters can be associated with an event:
+//   void doSomethingCostly2(int howMuch) {
+//     TRACE_EVENT1("MY_SUBSYSTEM", "doSomethingCostly",
+//         "howMuch", howMuch);
+//     ...
+//   }
+//
+// The trace system will automatically add to this information the current
+// process id, thread id, and a timestamp in microseconds.
+//
+// To trace an asynchronous procedure such as an IPC send/receive, use
+// ASYNC_BEGIN and ASYNC_END:
+//   [single threaded sender code]
+//     static int send_count = 0;
+//     ++send_count;
+//     TRACE_EVENT_ASYNC_BEGIN0("ipc", "message", send_count);
+//     Send(new MyMessage(send_count));
+//   [receive code]
+//     void OnMyMessage(send_count) {
+//       TRACE_EVENT_ASYNC_END0("ipc", "message", send_count);
+//     }
+// The third parameter is a unique ID to match ASYNC_BEGIN/ASYNC_END pairs.
+// ASYNC_BEGIN and ASYNC_END can occur on any thread of any traced process.
+// Pointers can be used for the ID parameter, and they will be mangled
+// internally so that the same pointer on two different processes will not
+// match. For example:
+//   class MyTracedClass {
+//    public:
+//     MyTracedClass() {
+//       TRACE_EVENT_ASYNC_BEGIN0("category", "MyTracedClass", this);
+//     }
+//     ~MyTracedClass() {
+//       TRACE_EVENT_ASYNC_END0("category", "MyTracedClass", this);
+//     }
+//   }
+//
+// The trace event also supports counters, which is a way to track a quantity
+// as it varies over time. Counters are created with the following macro:
+//   TRACE_COUNTER1("MY_SUBSYSTEM", "myCounter", g_myCounterValue);
+//
+// Counters are process-specific. The macro itself can be issued from any
+// thread, however.
+//
+// Sometimes, you want to track two counters at once. You can do this with two
+// counter macros:
+//   TRACE_COUNTER1("MY_SUBSYSTEM", "myCounter0", g_myCounterValue[0]);
+//   TRACE_COUNTER1("MY_SUBSYSTEM", "myCounter1", g_myCounterValue[1]);
+// Or you can do it with a combined macro:
+//   TRACE_COUNTER2("MY_SUBSYSTEM", "myCounter",
+//       "bytesPinned", g_myCounterValue[0],
+//       "bytesAllocated", g_myCounterValue[1]);
+// This indicates to the tracing UI that these counters should be displayed
+// in a single graph, as a summed area chart.
+//
+// Since counters are in a global namespace, you may want to disembiguate with a
+// unique ID, by using the TRACE_COUNTER_ID* variations.
+//
+// By default, trace collection is compiled in, but turned off at runtime.
+// Collecting trace data is the responsibility of the embedding application. In
+// CEF's case, calling BeginTracing will turn on tracing on all active
+// processes.
+//
+//
+// Memory scoping note:
+// Tracing copies the pointers, not the string content, of the strings passed
+// in for category, name, and arg_names.  Thus, the following code will cause
+// problems:
+//     char* str = strdup("impprtantName");
+//     TRACE_EVENT_INSTANT0("SUBSYSTEM", str);  // BAD!
+//     free(str);                   // Trace system now has dangling pointer
+//
+// To avoid this issue with the |name| and |arg_name| parameters, use the
+// TRACE_EVENT_COPY_XXX overloads of the macros at additional runtime
+// overhead.
+// Notes: The category must always be in a long-lived char* (i.e. static const).
+//        The |arg_values|, when used, are always deep copied with the _COPY
+//        macros.
+//
+//
+// Thread Safety:
+// All macros are thread safe and can be used from any process.
+///
+
+#ifndef CEF_INCLUDE_BASE_CEF_TRACE_EVENT_H_
+#define CEF_INCLUDE_BASE_CEF_TRACE_EVENT_H_
+#pragma once
+
+#if defined(TRACE_EVENT0)
+// Do nothing if the macros provided by this header already exist.
+// This can happen in cases where Chromium code is used directly by the
+// client application. When using Chromium code directly always include
+// the Chromium header first to avoid type conflicts.
+#elif defined(USING_CHROMIUM_INCLUDES)
+// When building CEF include the Chromium header directly.
+#include "base/trace_event/trace_event.h"
+#else  // !USING_CHROMIUM_INCLUDES
+// The following is substantially similar to the Chromium implementation.
+// If the Chromium implementation diverges the below implementation should be
+// updated to match.
+
+#include "libcef/internal/cef_trace_event_internal.h"
+
+// Records a pair of begin and end events called "name" for the current
+// scope, with 0, 1 or 2 associated arguments. If the category is not
+// enabled, then this does nothing.
+// - category and name strings must have application lifetime (statics or
+//   literals). They may not include " chars.
+#define TRACE_EVENT0(category, name) \
+  cef_trace_event_begin(category, name, NULL, 0, NULL, 0, false); \
+  CEF_INTERNAL_TRACE_END_ON_SCOPE_CLOSE(category, name)
+#define TRACE_EVENT1(category, name, arg1_name, arg1_val) \
+  cef_trace_event_begin(category, name, arg1_name, arg1_val, NULL, 0, false); \
+  CEF_INTERNAL_TRACE_END_ON_SCOPE_CLOSE(category, name)
+#define TRACE_EVENT2(category, name, arg1_name, arg1_val, arg2_name, \
+      arg2_val) \
+  cef_trace_event_begin(category, name, arg1_name, arg1_val, \
+                                        arg2_name, arg2_val, false); \
+  CEF_INTERNAL_TRACE_END_ON_SCOPE_CLOSE(category, name)
+
+// Implementation detail: trace event macros create temporary variable names.
+// These macros give each temporary variable a unique name based on the line
+// number to prevent name collisions.
+#define CEF_INTERNAL_TRACE_EVENT_UID3(a,b) \
+  cef_trace_event_unique_##a##b
+#define CEF_INTERNAL_TRACE_EVENT_UID2(a,b) \
+  CEF_INTERNAL_TRACE_EVENT_UID3(a,b)
+#define CEF_INTERNAL_TRACE_EVENT_UID(name_prefix) \
+  CEF_INTERNAL_TRACE_EVENT_UID2(name_prefix, __LINE__)
+
+// Implementation detail: internal macro to end end event when the scope ends.
+#define CEF_INTERNAL_TRACE_END_ON_SCOPE_CLOSE(category, name) \
+   cef_trace_event::CefTraceEndOnScopeClose \
+       CEF_INTERNAL_TRACE_EVENT_UID(profileScope)(category, name)
+
+// Records a single event called "name" immediately, with 0, 1 or 2
+// associated arguments. If the category is not enabled, then this
+// does nothing.
+// - category and name strings must have application lifetime (statics or
+//   literals). They may not include " chars.
+#define TRACE_EVENT_INSTANT0(category, name) \
+  cef_trace_event_instant(category, name, NULL, 0, NULL, 0, false)
+#define TRACE_EVENT_INSTANT1(category, name, arg1_name, arg1_val) \
+  cef_trace_event_instant(category, name, arg1_name, arg1_val, NULL, 0, false)
+#define TRACE_EVENT_INSTANT2(category, name, arg1_name, arg1_val, \
+      arg2_name, arg2_val) \
+  cef_trace_event_instant(category, name, arg1_name, arg1_val, arg2_name, \
+      arg2_val, false)
+#define TRACE_EVENT_COPY_INSTANT0(category, name) \
+  cef_trace_event_instant(category, name, NULL, 0, NULL, 0, true)
+#define TRACE_EVENT_COPY_INSTANT1(category, name, arg1_name, arg1_val) \
+  cef_trace_event_instant(category, name, arg1_name, arg1_val, NULL, 0, true)
+#define TRACE_EVENT_COPY_INSTANT2(category, name, arg1_name, arg1_val, \
+      arg2_name, arg2_val) \
+  cef_trace_event_instant(category, name, arg1_name, arg1_val, arg2_name, \
+      arg2_val, true)
+
+// Records a single BEGIN event called "name" immediately, with 0, 1 or 2
+// associated arguments. If the category is not enabled, then this
+// does nothing.
+// - category and name strings must have application lifetime (statics or
+//   literals). They may not include " chars.
+#define TRACE_EVENT_BEGIN0(category, name) \
+  cef_trace_event_begin(category, name, NULL, 0, NULL, 0, false)
+#define TRACE_EVENT_BEGIN1(category, name, arg1_name, arg1_val) \
+  cef_trace_event_begin(category, name, arg1_name, arg1_val, NULL, 0, false)
+#define TRACE_EVENT_BEGIN2(category, name, arg1_name, arg1_val, \
+      arg2_name, arg2_val) \
+  cef_trace_event_begin(category, name, arg1_name, arg1_val, arg2_name, \
+      arg2_val, false)
+#define TRACE_EVENT_COPY_BEGIN0(category, name) \
+  cef_trace_event_begin(category, name, NULL, 0, NULL, 0, true)
+#define TRACE_EVENT_COPY_BEGIN1(category, name, arg1_name, arg1_val) \
+  cef_trace_event_begin(category, name, arg1_name, arg1_val, NULL, 0, true)
+#define TRACE_EVENT_COPY_BEGIN2(category, name, arg1_name, arg1_val, \
+      arg2_name, arg2_val) \
+  cef_trace_event_begin(category, name, arg1_name, arg1_val, arg2_name, \
+      arg2_val, true)
+
+// Records a single END event for "name" immediately. If the category
+// is not enabled, then this does nothing.
+// - category and name strings must have application lifetime (statics or
+//   literals). They may not include " chars.
+#define TRACE_EVENT_END0(category, name) \
+  cef_trace_event_end(category, name, NULL, 0, NULL, 0, false)
+#define TRACE_EVENT_END1(category, name, arg1_name, arg1_val) \
+  cef_trace_event_end(category, name, arg1_name, arg1_val, NULL, 0, false)
+#define TRACE_EVENT_END2(category, name, arg1_name, arg1_val, \
+      arg2_name, arg2_val) \
+  cef_trace_event_end(category, name, arg1_name, arg1_val, arg2_name, \
+      arg2_val, false)
+#define TRACE_EVENT_COPY_END0(category, name) \
+  cef_trace_event_end(category, name, NULL, 0, NULL, 0, true)
+#define TRACE_EVENT_COPY_END1(category, name, arg1_name, arg1_val) \
+  cef_trace_event_end(category, name, arg1_name, arg1_val, NULL, 0, true)
+#define TRACE_EVENT_COPY_END2(category, name, arg1_name, arg1_val, \
+      arg2_name, arg2_val) \
+  cef_trace_event_end(category, name, arg1_name, arg1_val, arg2_name, \
+      arg2_val, true)
+
+// Records the value of a counter called "name" immediately. Value
+// must be representable as a 32 bit integer.
+// - category and name strings must have application lifetime (statics or
+//   literals). They may not include " chars.
+#define TRACE_COUNTER1(category, name, value) \
+  cef_trace_counter(category, name, NULL, value, NULL, 0, false)
+#define TRACE_COPY_COUNTER1(category, name, value) \
+  cef_trace_counter(category, name, NULL, value, NULL, 0, true)
+
+// Records the values of a multi-parted counter called "name" immediately.
+// The UI will treat value1 and value2 as parts of a whole, displaying their
+// values as a stacked-bar chart.
+// - category and name strings must have application lifetime (statics or
+//   literals). They may not include " chars.
+#define TRACE_COUNTER2(category, name, value1_name, value1_val, \
+      value2_name, value2_val) \
+  cef_trace_counter(category, name, value1_name, value1_val, value2_name, \
+      value2_val, false)
+#define TRACE_COPY_COUNTER2(category, name, value1_name, value1_val, \
+      value2_name, value2_val) \
+  cef_trace_counter(category, name, value1_name, value1_val, value2_name, \
+      value2_val, true)
+
+// Records the value of a counter called "name" immediately. Value
+// must be representable as a 32 bit integer.
+// - category and name strings must have application lifetime (statics or
+//   literals). They may not include " chars.
+// - |id| is used to disambiguate counters with the same name. It must either
+//   be a pointer or an integer value up to 64 bits. If it's a pointer, the
+//   bits will be xored with a hash of the process ID so that the same pointer
+//   on two different processes will not collide.
+#define TRACE_COUNTER_ID1(category, name, id, value) \
+  cef_trace_counter_id(category, name, id, NULL, value, NULL, 0, false)
+#define TRACE_COPY_COUNTER_ID1(category, name, id, value) \
+  cef_trace_counter_id(category, name, id, NULL, value, NULL, 0, true)
+
+// Records the values of a multi-parted counter called "name" immediately.
+// The UI will treat value1 and value2 as parts of a whole, displaying their
+// values as a stacked-bar chart.
+// - category and name strings must have application lifetime (statics or
+//   literals). They may not include " chars.
+// - |id| is used to disambiguate counters with the same name. It must either
+//   be a pointer or an integer value up to 64 bits. If it's a pointer, the
+//   bits will be xored with a hash of the process ID so that the same pointer
+//   on two different processes will not collide.
+#define TRACE_COUNTER_ID2(category, name, id, value1_name, value1_val, \
+      value2_name, value2_val) \
+  cef_trace_counter_id(category, name, id, value1_name, value1_val, \
+      value2_name, value2_val, false)
+#define TRACE_COPY_COUNTER_ID2(category, name, id, value1_name, \
+      value1_val, value2_name, value2_val) \
+  cef_trace_counter_id(category, name, id, value1_name, value1_val, \
+      value2_name, value2_val, true)
+
+
+// Records a single ASYNC_BEGIN event called "name" immediately, with 0, 1 or 2
+// associated arguments. If the category is not enabled, then this
+// does nothing.
+// - category and name strings must have application lifetime (statics or
+//   literals). They may not include " chars.
+// - |id| is used to match the ASYNC_BEGIN event with the ASYNC_END event.
+//   ASYNC events are considered to match if their category, name and id values
+//   all match. |id| must either be a pointer or an integer value up to 64
+//   bits. If it's a pointer, the bits will be xored with a hash of the process
+//   ID sothat the same pointer on two different processes will not collide.
+// An asynchronous operation can consist of multiple phases. The first phase is
+// defined by the ASYNC_BEGIN calls. Additional phases can be defined using the
+// ASYNC_STEP_BEGIN macros. When the operation completes, call ASYNC_END.
+// An async operation can span threads and processes, but all events in that
+// operation must use the same |name| and |id|. Each event can have its own
+// args.
+#define TRACE_EVENT_ASYNC_BEGIN0(category, name, id) \
+  cef_trace_event_async_begin(category, name, id, NULL, 0, NULL, 0, false)
+#define TRACE_EVENT_ASYNC_BEGIN1(category, name, id, arg1_name, arg1_val) \
+  cef_trace_event_async_begin(category, name, id, arg1_name, arg1_val, NULL, \
+      0, false)
+#define TRACE_EVENT_ASYNC_BEGIN2(category, name, id, arg1_name, arg1_val, \
+      arg2_name, arg2_val) \
+  cef_trace_event_async_begin(category, name, id, arg1_name, arg1_val, \
+      arg2_name, arg2_val, false)
+#define TRACE_EVENT_COPY_ASYNC_BEGIN0(category, name, id) \
+  cef_trace_event_async_begin(category, name, id, NULL, 0, NULL, 0, true)
+#define TRACE_EVENT_COPY_ASYNC_BEGIN1(category, name, id, arg1_name, \
+      arg1_val) \
+  cef_trace_event_async_begin(category, name, id, arg1_name, arg1_val, NULL, \
+      0, true)
+#define TRACE_EVENT_COPY_ASYNC_BEGIN2(category, name, id, arg1_name, \
+      arg1_val, arg2_name, arg2_val) \
+  cef_trace_event_async_begin(category, name, id, arg1_name, arg1_val, \
+      arg2_name, arg2_val, true)
+
+// Records a single ASYNC_STEP_INTO event for |step| immediately. If the
+// category is not enabled, then this does nothing. The |name| and |id| must
+// match the ASYNC_BEGIN event above. The |step| param identifies this step
+// within the async event. This should be called at the beginning of the next
+// phase of an asynchronous operation. The ASYNC_BEGIN event must not have any
+// ASYNC_STEP_PAST events.
+#define TRACE_EVENT_ASYNC_STEP_INTO0(category, name, id, step) \
+  cef_trace_event_async_step_into(category, name, id, step, NULL, 0, false)
+#define TRACE_EVENT_ASYNC_STEP_INTO1(category, name, id, step, \
+      arg1_name, arg1_val) \
+  cef_trace_event_async_step_into(category, name, id, step, arg1_name, \
+      arg1_val, false)
+#define TRACE_EVENT_COPY_ASYNC_STEP_INTO0(category, name, id, step) \
+  cef_trace_event_async_step_into(category, name, id, step, NULL, 0, true)
+#define TRACE_EVENT_COPY_ASYNC_STEP_INTO1(category, name, id, step, \
+      arg1_name, arg1_val) \
+  cef_trace_event_async_step_into(category, name, id, step, arg1_name, \
+      arg1_val, true)
+
+// Records a single ASYNC_STEP_PAST event for |step| immediately. If the
+// category is not enabled, then this does nothing. The |name| and |id| must
+// match the ASYNC_BEGIN event above. The |step| param identifies this step
+// within the async event. This should be called at the beginning of the next
+// phase of an asynchronous operation. The ASYNC_BEGIN event must not have any
+// ASYNC_STEP_INTO events.
+#define TRACE_EVENT_ASYNC_STEP_PAST0(category, name, id, step) \
+  cef_trace_event_async_step_past(category, name, id, step, NULL, 0, false)
+#define TRACE_EVENT_ASYNC_STEP_PAST1(category, name, id, step, \
+      arg1_name, arg1_val) \
+  cef_trace_event_async_step_past(category, name, id, step, arg1_name, \
+      arg1_val, false)
+#define TRACE_EVENT_COPY_ASYNC_STEP_PAST0(category, name, id, step) \
+  cef_trace_event_async_step_past(category, name, id, step, NULL, 0, true)
+#define TRACE_EVENT_COPY_ASYNC_STEP_PAST1(category, name, id, step, \
+      arg1_name, arg1_val) \
+  cef_trace_event_async_step_past(category, name, id, step, arg1_name, \
+      arg1_val, true)
+
+// Records a single ASYNC_END event for "name" immediately. If the category
+// is not enabled, then this does nothing.
+#define TRACE_EVENT_ASYNC_END0(category, name, id) \
+  cef_trace_event_async_end(category, name, id, NULL, 0, NULL, 0, false)
+#define TRACE_EVENT_ASYNC_END1(category, name, id, arg1_name, arg1_val) \
+  cef_trace_event_async_end(category, name, id, arg1_name, arg1_val, NULL, 0, \
+      false)
+#define TRACE_EVENT_ASYNC_END2(category, name, id, arg1_name, arg1_val, \
+      arg2_name, arg2_val) \
+  cef_trace_event_async_end(category, name, id, arg1_name, arg1_val, \
+      arg2_name, arg2_val, false)
+#define TRACE_EVENT_COPY_ASYNC_END0(category, name, id) \
+  cef_trace_event_async_end(category, name, id, NULL, 0, NULL, 0, true)
+#define TRACE_EVENT_COPY_ASYNC_END1(category, name, id, arg1_name, \
+      arg1_val) \
+  cef_trace_event_async_end(category, name, id, arg1_name, arg1_val, NULL, 0, \
+      true)
+#define TRACE_EVENT_COPY_ASYNC_END2(category, name, id, arg1_name, \
+      arg1_val, arg2_name, arg2_val) \
+  cef_trace_event_async_end(category, name, id, arg1_name, arg1_val, \
+      arg2_name, arg2_val, true)
+
+namespace cef_trace_event {
+
+// Used by TRACE_EVENTx macro. Do not use directly.
+class CefTraceEndOnScopeClose {
+ public:
+  CefTraceEndOnScopeClose(const char* category, const char* name)
+      : category_(category), name_(name) {
+  }
+  ~CefTraceEndOnScopeClose() {
+    cef_trace_event_end(category_, name_, NULL, 0, NULL, 0, false);
+  }
+
+ private:
+  const char* category_;
+  const char* name_;
+};
+
+}  // cef_trace_event
+
+#endif  // !USING_CHROMIUM_INCLUDES
+
+#endif  // CEF_INCLUDE_BASE_CEF_TRACE_EVENT_H_
diff --git a/src/include/libcef/base/cef_tuple.h b/src/include/libcef/base/cef_tuple.h
new file mode 100644
index 0000000..f873638
--- /dev/null
+++ b/src/include/libcef/base/cef_tuple.h
@@ -0,0 +1,1337 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2011
+// Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// A Tuple is a generic templatized container, similar in concept to std::pair.
+// There are classes Tuple0 to Tuple6, cooresponding to the number of elements
+// it contains.  The convenient MakeTuple() function takes 0 to 6 arguments,
+// and will construct and return the appropriate Tuple object.  The functions
+// DispatchToMethod and DispatchToFunction take a function pointer or instance
+// and method pointer, and unpack a tuple into arguments to the call.
+//
+// Tuple elements are copied by value, and stored in the tuple.  See the unit
+// tests for more details of how/when the values are copied.
+//
+// Example usage:
+//   // These two methods of creating a Tuple are identical.
+//   Tuple2<int, const char*> tuple_a(1, "wee");
+//   Tuple2<int, const char*> tuple_b = MakeTuple(1, "wee");
+//
+//   void SomeFunc(int a, const char* b) { }
+//   DispatchToFunction(&SomeFunc, tuple_a);  // SomeFunc(1, "wee")
+//   DispatchToFunction(
+//       &SomeFunc, MakeTuple(10, "foo"));    // SomeFunc(10, "foo")
+//
+//   struct { void SomeMeth(int a, int b, int c) { } } foo;
+//   DispatchToMethod(&foo, &Foo::SomeMeth, MakeTuple(1, 2, 3));
+//   // foo->SomeMeth(1, 2, 3);
+
+#ifndef CEF_INCLUDE_BASE_CEF_TUPLE_H_
+#define CEF_INCLUDE_BASE_CEF_TUPLE_H_
+#pragma once
+
+#if defined(BASE_TUPLE_H_)
+// Do nothing if the Chromium header has already been included.
+// This can happen in cases where Chromium code is used directly by the
+// client application. When using Chromium code directly always include
+// the Chromium header first to avoid type conflicts.
+#elif defined(USING_CHROMIUM_INCLUDES)
+// When building CEF include the Chromium header directly.
+#include "base/tuple.h"
+#else  // !USING_CHROMIUM_INCLUDES
+// The following is substantially similar to the Chromium implementation.
+// If the Chromium implementation diverges the below implementation should be
+// updated to match.
+
+#include "libcef/base/cef_bind_helpers.h"
+
+namespace base {
+
+// Traits ----------------------------------------------------------------------
+//
+// A simple traits class for tuple arguments.
+//
+// ValueType: the bare, nonref version of a type (same as the type for nonrefs).
+// RefType: the ref version of a type (same as the type for refs).
+// ParamType: what type to pass to functions (refs should not be constified).
+
+template <class P>
+struct TupleTraits {
+  typedef P ValueType;
+  typedef P& RefType;
+  typedef const P& ParamType;
+};
+
+template <class P>
+struct TupleTraits<P&> {
+  typedef P ValueType;
+  typedef P& RefType;
+  typedef P& ParamType;
+};
+
+template <class P>
+struct TupleTypes { };
+
+// Tuple -----------------------------------------------------------------------
+//
+// This set of classes is useful for bundling 0 or more heterogeneous data types
+// into a single variable.  The advantage of this is that it greatly simplifies
+// function objects that need to take an arbitrary number of parameters; see
+// RunnableMethod and IPC::MessageWithTuple.
+//
+// Tuple0 is supplied to act as a 'void' type.  It can be used, for example,
+// when dispatching to a function that accepts no arguments (see the
+// Dispatchers below).
+// Tuple1<A> is rarely useful.  One such use is when A is non-const ref that you
+// want filled by the dispatchee, and the tuple is merely a container for that
+// output (a "tier").  See MakeRefTuple and its usages.
+
+struct Tuple0 {
+  typedef Tuple0 ValueTuple;
+  typedef Tuple0 RefTuple;
+  typedef Tuple0 ParamTuple;
+};
+
+template <class A>
+struct Tuple1 {
+ public:
+  typedef A TypeA;
+
+  Tuple1() {}
+  explicit Tuple1(typename TupleTraits<A>::ParamType a) : a(a) {}
+
+  A a;
+};
+
+template <class A, class B>
+struct Tuple2 {
+ public:
+  typedef A TypeA;
+  typedef B TypeB;
+
+  Tuple2() {}
+  Tuple2(typename TupleTraits<A>::ParamType a,
+         typename TupleTraits<B>::ParamType b)
+      : a(a), b(b) {
+  }
+
+  A a;
+  B b;
+};
+
+template <class A, class B, class C>
+struct Tuple3 {
+ public:
+  typedef A TypeA;
+  typedef B TypeB;
+  typedef C TypeC;
+
+  Tuple3() {}
+  Tuple3(typename TupleTraits<A>::ParamType a,
+         typename TupleTraits<B>::ParamType b,
+         typename TupleTraits<C>::ParamType c)
+      : a(a), b(b), c(c){
+  }
+
+  A a;
+  B b;
+  C c;
+};
+
+template <class A, class B, class C, class D>
+struct Tuple4 {
+ public:
+  typedef A TypeA;
+  typedef B TypeB;
+  typedef C TypeC;
+  typedef D TypeD;
+
+  Tuple4() {}
+  Tuple4(typename TupleTraits<A>::ParamType a,
+         typename TupleTraits<B>::ParamType b,
+         typename TupleTraits<C>::ParamType c,
+         typename TupleTraits<D>::ParamType d)
+      : a(a), b(b), c(c), d(d) {
+  }
+
+  A a;
+  B b;
+  C c;
+  D d;
+};
+
+template <class A, class B, class C, class D, class E>
+struct Tuple5 {
+ public:
+  typedef A TypeA;
+  typedef B TypeB;
+  typedef C TypeC;
+  typedef D TypeD;
+  typedef E TypeE;
+
+  Tuple5() {}
+  Tuple5(typename TupleTraits<A>::ParamType a,
+    typename TupleTraits<B>::ParamType b,
+    typename TupleTraits<C>::ParamType c,
+    typename TupleTraits<D>::ParamType d,
+    typename TupleTraits<E>::ParamType e)
+    : a(a), b(b), c(c), d(d), e(e) {
+  }
+
+  A a;
+  B b;
+  C c;
+  D d;
+  E e;
+};
+
+template <class A, class B, class C, class D, class E, class F>
+struct Tuple6 {
+ public:
+  typedef A TypeA;
+  typedef B TypeB;
+  typedef C TypeC;
+  typedef D TypeD;
+  typedef E TypeE;
+  typedef F TypeF;
+
+  Tuple6() {}
+  Tuple6(typename TupleTraits<A>::ParamType a,
+    typename TupleTraits<B>::ParamType b,
+    typename TupleTraits<C>::ParamType c,
+    typename TupleTraits<D>::ParamType d,
+    typename TupleTraits<E>::ParamType e,
+    typename TupleTraits<F>::ParamType f)
+    : a(a), b(b), c(c), d(d), e(e), f(f) {
+  }
+
+  A a;
+  B b;
+  C c;
+  D d;
+  E e;
+  F f;
+};
+
+template <class A, class B, class C, class D, class E, class F, class G>
+struct Tuple7 {
+ public:
+  typedef A TypeA;
+  typedef B TypeB;
+  typedef C TypeC;
+  typedef D TypeD;
+  typedef E TypeE;
+  typedef F TypeF;
+  typedef G TypeG;
+
+  Tuple7() {}
+  Tuple7(typename TupleTraits<A>::ParamType a,
+    typename TupleTraits<B>::ParamType b,
+    typename TupleTraits<C>::ParamType c,
+    typename TupleTraits<D>::ParamType d,
+    typename TupleTraits<E>::ParamType e,
+    typename TupleTraits<F>::ParamType f,
+    typename TupleTraits<G>::ParamType g)
+    : a(a), b(b), c(c), d(d), e(e), f(f), g(g) {
+  }
+
+  A a;
+  B b;
+  C c;
+  D d;
+  E e;
+  F f;
+  G g;
+};
+
+template <class A, class B, class C, class D, class E, class F, class G,
+          class H>
+struct Tuple8 {
+ public:
+  typedef A TypeA;
+  typedef B TypeB;
+  typedef C TypeC;
+  typedef D TypeD;
+  typedef E TypeE;
+  typedef F TypeF;
+  typedef G TypeG;
+  typedef H TypeH;
+
+  Tuple8() {}
+  Tuple8(typename TupleTraits<A>::ParamType a,
+    typename TupleTraits<B>::ParamType b,
+    typename TupleTraits<C>::ParamType c,
+    typename TupleTraits<D>::ParamType d,
+    typename TupleTraits<E>::ParamType e,
+    typename TupleTraits<F>::ParamType f,
+    typename TupleTraits<G>::ParamType g,
+    typename TupleTraits<H>::ParamType h)
+    : a(a), b(b), c(c), d(d), e(e), f(f), g(g), h(h) {
+  }
+
+  A a;
+  B b;
+  C c;
+  D d;
+  E e;
+  F f;
+  G g;
+  H h;
+};
+
+// Tuple types ----------------------------------------------------------------
+//
+// Allows for selection of ValueTuple/RefTuple/ParamTuple without needing the
+// definitions of class types the tuple takes as parameters.
+
+template <>
+struct TupleTypes< Tuple0 > {
+  typedef Tuple0 ValueTuple;
+  typedef Tuple0 RefTuple;
+  typedef Tuple0 ParamTuple;
+};
+
+template <class A>
+struct TupleTypes< Tuple1<A> > {
+  typedef Tuple1<typename TupleTraits<A>::ValueType> ValueTuple;
+  typedef Tuple1<typename TupleTraits<A>::RefType> RefTuple;
+  typedef Tuple1<typename TupleTraits<A>::ParamType> ParamTuple;
+};
+
+template <class A, class B>
+struct TupleTypes< Tuple2<A, B> > {
+  typedef Tuple2<typename TupleTraits<A>::ValueType,
+                 typename TupleTraits<B>::ValueType> ValueTuple;
+typedef Tuple2<typename TupleTraits<A>::RefType,
+               typename TupleTraits<B>::RefType> RefTuple;
+  typedef Tuple2<typename TupleTraits<A>::ParamType,
+                 typename TupleTraits<B>::ParamType> ParamTuple;
+};
+
+template <class A, class B, class C>
+struct TupleTypes< Tuple3<A, B, C> > {
+  typedef Tuple3<typename TupleTraits<A>::ValueType,
+                 typename TupleTraits<B>::ValueType,
+                 typename TupleTraits<C>::ValueType> ValueTuple;
+typedef Tuple3<typename TupleTraits<A>::RefType,
+               typename TupleTraits<B>::RefType,
+               typename TupleTraits<C>::RefType> RefTuple;
+  typedef Tuple3<typename TupleTraits<A>::ParamType,
+                 typename TupleTraits<B>::ParamType,
+                 typename TupleTraits<C>::ParamType> ParamTuple;
+};
+
+template <class A, class B, class C, class D>
+struct TupleTypes< Tuple4<A, B, C, D> > {
+  typedef Tuple4<typename TupleTraits<A>::ValueType,
+                 typename TupleTraits<B>::ValueType,
+                 typename TupleTraits<C>::ValueType,
+                 typename TupleTraits<D>::ValueType> ValueTuple;
+typedef Tuple4<typename TupleTraits<A>::RefType,
+               typename TupleTraits<B>::RefType,
+               typename TupleTraits<C>::RefType,
+               typename TupleTraits<D>::RefType> RefTuple;
+  typedef Tuple4<typename TupleTraits<A>::ParamType,
+                 typename TupleTraits<B>::ParamType,
+                 typename TupleTraits<C>::ParamType,
+                 typename TupleTraits<D>::ParamType> ParamTuple;
+};
+
+template <class A, class B, class C, class D, class E>
+struct TupleTypes< Tuple5<A, B, C, D, E> > {
+  typedef Tuple5<typename TupleTraits<A>::ValueType,
+                 typename TupleTraits<B>::ValueType,
+                 typename TupleTraits<C>::ValueType,
+                 typename TupleTraits<D>::ValueType,
+                 typename TupleTraits<E>::ValueType> ValueTuple;
+typedef Tuple5<typename TupleTraits<A>::RefType,
+               typename TupleTraits<B>::RefType,
+               typename TupleTraits<C>::RefType,
+               typename TupleTraits<D>::RefType,
+               typename TupleTraits<E>::RefType> RefTuple;
+  typedef Tuple5<typename TupleTraits<A>::ParamType,
+                 typename TupleTraits<B>::ParamType,
+                 typename TupleTraits<C>::ParamType,
+                 typename TupleTraits<D>::ParamType,
+                 typename TupleTraits<E>::ParamType> ParamTuple;
+};
+
+template <class A, class B, class C, class D, class E, class F>
+struct TupleTypes< Tuple6<A, B, C, D, E, F> > {
+  typedef Tuple6<typename TupleTraits<A>::ValueType,
+                 typename TupleTraits<B>::ValueType,
+                 typename TupleTraits<C>::ValueType,
+                 typename TupleTraits<D>::ValueType,
+                 typename TupleTraits<E>::ValueType,
+                 typename TupleTraits<F>::ValueType> ValueTuple;
+typedef Tuple6<typename TupleTraits<A>::RefType,
+               typename TupleTraits<B>::RefType,
+               typename TupleTraits<C>::RefType,
+               typename TupleTraits<D>::RefType,
+               typename TupleTraits<E>::RefType,
+               typename TupleTraits<F>::RefType> RefTuple;
+  typedef Tuple6<typename TupleTraits<A>::ParamType,
+                 typename TupleTraits<B>::ParamType,
+                 typename TupleTraits<C>::ParamType,
+                 typename TupleTraits<D>::ParamType,
+                 typename TupleTraits<E>::ParamType,
+                 typename TupleTraits<F>::ParamType> ParamTuple;
+};
+
+template <class A, class B, class C, class D, class E, class F, class G>
+struct TupleTypes< Tuple7<A, B, C, D, E, F, G> > {
+  typedef Tuple7<typename TupleTraits<A>::ValueType,
+                 typename TupleTraits<B>::ValueType,
+                 typename TupleTraits<C>::ValueType,
+                 typename TupleTraits<D>::ValueType,
+                 typename TupleTraits<E>::ValueType,
+                 typename TupleTraits<F>::ValueType,
+                 typename TupleTraits<G>::ValueType> ValueTuple;
+typedef Tuple7<typename TupleTraits<A>::RefType,
+               typename TupleTraits<B>::RefType,
+               typename TupleTraits<C>::RefType,
+               typename TupleTraits<D>::RefType,
+               typename TupleTraits<E>::RefType,
+               typename TupleTraits<F>::RefType,
+               typename TupleTraits<G>::RefType> RefTuple;
+  typedef Tuple7<typename TupleTraits<A>::ParamType,
+                 typename TupleTraits<B>::ParamType,
+                 typename TupleTraits<C>::ParamType,
+                 typename TupleTraits<D>::ParamType,
+                 typename TupleTraits<E>::ParamType,
+                 typename TupleTraits<F>::ParamType,
+                 typename TupleTraits<G>::ParamType> ParamTuple;
+};
+
+template <class A, class B, class C, class D, class E, class F, class G,
+          class H>
+struct TupleTypes< Tuple8<A, B, C, D, E, F, G, H> > {
+  typedef Tuple8<typename TupleTraits<A>::ValueType,
+                 typename TupleTraits<B>::ValueType,
+                 typename TupleTraits<C>::ValueType,
+                 typename TupleTraits<D>::ValueType,
+                 typename TupleTraits<E>::ValueType,
+                 typename TupleTraits<F>::ValueType,
+                 typename TupleTraits<G>::ValueType,
+                 typename TupleTraits<H>::ValueType> ValueTuple;
+typedef Tuple8<typename TupleTraits<A>::RefType,
+               typename TupleTraits<B>::RefType,
+               typename TupleTraits<C>::RefType,
+               typename TupleTraits<D>::RefType,
+               typename TupleTraits<E>::RefType,
+               typename TupleTraits<F>::RefType,
+               typename TupleTraits<G>::RefType,
+               typename TupleTraits<H>::RefType> RefTuple;
+  typedef Tuple8<typename TupleTraits<A>::ParamType,
+                 typename TupleTraits<B>::ParamType,
+                 typename TupleTraits<C>::ParamType,
+                 typename TupleTraits<D>::ParamType,
+                 typename TupleTraits<E>::ParamType,
+                 typename TupleTraits<F>::ParamType,
+                 typename TupleTraits<G>::ParamType,
+                 typename TupleTraits<H>::ParamType> ParamTuple;
+};
+
+// Tuple creators -------------------------------------------------------------
+//
+// Helper functions for constructing tuples while inferring the template
+// argument types.
+
+inline Tuple0 MakeTuple() {
+  return Tuple0();
+}
+
+template <class A>
+inline Tuple1<A> MakeTuple(const A& a) {
+  return Tuple1<A>(a);
+}
+
+template <class A, class B>
+inline Tuple2<A, B> MakeTuple(const A& a, const B& b) {
+  return Tuple2<A, B>(a, b);
+}
+
+template <class A, class B, class C>
+inline Tuple3<A, B, C> MakeTuple(const A& a, const B& b, const C& c) {
+  return Tuple3<A, B, C>(a, b, c);
+}
+
+template <class A, class B, class C, class D>
+inline Tuple4<A, B, C, D> MakeTuple(const A& a, const B& b, const C& c,
+                                    const D& d) {
+  return Tuple4<A, B, C, D>(a, b, c, d);
+}
+
+template <class A, class B, class C, class D, class E>
+inline Tuple5<A, B, C, D, E> MakeTuple(const A& a, const B& b, const C& c,
+                                       const D& d, const E& e) {
+  return Tuple5<A, B, C, D, E>(a, b, c, d, e);
+}
+
+template <class A, class B, class C, class D, class E, class F>
+inline Tuple6<A, B, C, D, E, F> MakeTuple(const A& a, const B& b, const C& c,
+                                          const D& d, const E& e, const F& f) {
+  return Tuple6<A, B, C, D, E, F>(a, b, c, d, e, f);
+}
+
+template <class A, class B, class C, class D, class E, class F, class G>
+inline Tuple7<A, B, C, D, E, F, G> MakeTuple(const A& a, const B& b, const C& c,
+                                             const D& d, const E& e, const F& f,
+                                             const G& g) {
+  return Tuple7<A, B, C, D, E, F, G>(a, b, c, d, e, f, g);
+}
+
+template <class A, class B, class C, class D, class E, class F, class G,
+          class H>
+inline Tuple8<A, B, C, D, E, F, G, H> MakeTuple(const A& a, const B& b,
+                                                const C& c, const D& d,
+                                                const E& e, const F& f,
+                                                const G& g, const H& h) {
+  return Tuple8<A, B, C, D, E, F, G, H>(a, b, c, d, e, f, g, h);
+}
+
+// The following set of helpers make what Boost refers to as "Tiers" - a tuple
+// of references.
+
+template <class A>
+inline Tuple1<A&> MakeRefTuple(A& a) {
+  return Tuple1<A&>(a);
+}
+
+template <class A, class B>
+inline Tuple2<A&, B&> MakeRefTuple(A& a, B& b) {
+  return Tuple2<A&, B&>(a, b);
+}
+
+template <class A, class B, class C>
+inline Tuple3<A&, B&, C&> MakeRefTuple(A& a, B& b, C& c) {
+  return Tuple3<A&, B&, C&>(a, b, c);
+}
+
+template <class A, class B, class C, class D>
+inline Tuple4<A&, B&, C&, D&> MakeRefTuple(A& a, B& b, C& c, D& d) {
+  return Tuple4<A&, B&, C&, D&>(a, b, c, d);
+}
+
+template <class A, class B, class C, class D, class E>
+inline Tuple5<A&, B&, C&, D&, E&> MakeRefTuple(A& a, B& b, C& c, D& d, E& e) {
+  return Tuple5<A&, B&, C&, D&, E&>(a, b, c, d, e);
+}
+
+template <class A, class B, class C, class D, class E, class F>
+inline Tuple6<A&, B&, C&, D&, E&, F&> MakeRefTuple(A& a, B& b, C& c, D& d, E& e,
+                                                   F& f) {
+  return Tuple6<A&, B&, C&, D&, E&, F&>(a, b, c, d, e, f);
+}
+
+template <class A, class B, class C, class D, class E, class F, class G>
+inline Tuple7<A&, B&, C&, D&, E&, F&, G&> MakeRefTuple(A& a, B& b, C& c, D& d,
+                                                       E& e, F& f, G& g) {
+  return Tuple7<A&, B&, C&, D&, E&, F&, G&>(a, b, c, d, e, f, g);
+}
+
+template <class A, class B, class C, class D, class E, class F, class G,
+          class H>
+inline Tuple8<A&, B&, C&, D&, E&, F&, G&, H&> MakeRefTuple(A& a, B& b, C& c,
+                                                           D& d, E& e, F& f,
+                                                           G& g, H& h) {
+  return Tuple8<A&, B&, C&, D&, E&, F&, G&, H&>(a, b, c, d, e, f, g, h);
+}
+
+// Dispatchers ----------------------------------------------------------------
+//
+// Helper functions that call the given method on an object, with the unpacked
+// tuple arguments.  Notice that they all have the same number of arguments,
+// so you need only write:
+//   DispatchToMethod(object, &Object::method, args);
+// This is very useful for templated dispatchers, since they don't need to know
+// what type |args| is.
+
+// Non-Static Dispatchers with no out params.
+
+template <class ObjT, class Method>
+inline void DispatchToMethod(ObjT* obj, Method method, const Tuple0& arg) {
+  (obj->*method)();
+}
+
+template <class ObjT, class Method, class A>
+inline void DispatchToMethod(ObjT* obj, Method method, const A& arg) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg));
+}
+
+template <class ObjT, class Method, class A>
+inline void DispatchToMethod(ObjT* obj, Method method, const Tuple1<A>& arg) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a));
+}
+
+template<class ObjT, class Method, class A, class B>
+inline void DispatchToMethod(ObjT* obj,
+                             Method method,
+                             const Tuple2<A, B>& arg) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
+                 base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b));
+}
+
+template<class ObjT, class Method, class A, class B, class C>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple3<A, B, C>& arg) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
+                 base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b),
+                 base::cef_internal::UnwrapTraits<C>::Unwrap(arg.c));
+}
+
+template<class ObjT, class Method, class A, class B, class C, class D>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple4<A, B, C, D>& arg) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
+                 base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b),
+                 base::cef_internal::UnwrapTraits<C>::Unwrap(arg.c),
+                 base::cef_internal::UnwrapTraits<D>::Unwrap(arg.d));
+}
+
+template<class ObjT, class Method, class A, class B, class C, class D, class E>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple5<A, B, C, D, E>& arg) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
+                 base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b),
+                 base::cef_internal::UnwrapTraits<C>::Unwrap(arg.c),
+                 base::cef_internal::UnwrapTraits<D>::Unwrap(arg.d),
+                 base::cef_internal::UnwrapTraits<E>::Unwrap(arg.e));
+}
+
+template<class ObjT, class Method, class A, class B, class C, class D, class E,
+         class F>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple6<A, B, C, D, E, F>& arg) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
+                 base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b),
+                 base::cef_internal::UnwrapTraits<C>::Unwrap(arg.c),
+                 base::cef_internal::UnwrapTraits<D>::Unwrap(arg.d),
+                 base::cef_internal::UnwrapTraits<E>::Unwrap(arg.e),
+                 base::cef_internal::UnwrapTraits<F>::Unwrap(arg.f));
+}
+
+template<class ObjT, class Method, class A, class B, class C, class D, class E,
+         class F, class G>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple7<A, B, C, D, E, F, G>& arg) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
+                 base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b),
+                 base::cef_internal::UnwrapTraits<C>::Unwrap(arg.c),
+                 base::cef_internal::UnwrapTraits<D>::Unwrap(arg.d),
+                 base::cef_internal::UnwrapTraits<E>::Unwrap(arg.e),
+                 base::cef_internal::UnwrapTraits<F>::Unwrap(arg.f),
+                 base::cef_internal::UnwrapTraits<G>::Unwrap(arg.g));
+}
+
+template<class ObjT, class Method, class A, class B, class C, class D, class E,
+         class F, class G, class H>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple8<A, B, C, D, E, F, G, H>& arg) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
+                 base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b),
+                 base::cef_internal::UnwrapTraits<C>::Unwrap(arg.c),
+                 base::cef_internal::UnwrapTraits<D>::Unwrap(arg.d),
+                 base::cef_internal::UnwrapTraits<E>::Unwrap(arg.e),
+                 base::cef_internal::UnwrapTraits<F>::Unwrap(arg.f),
+                 base::cef_internal::UnwrapTraits<G>::Unwrap(arg.g),
+                 base::cef_internal::UnwrapTraits<H>::Unwrap(arg.h));
+}
+
+// Static Dispatchers with no out params.
+
+template <class Function>
+inline void DispatchToFunction(Function function, const Tuple0& arg) {
+  (*function)();
+}
+
+template <class Function, class A>
+inline void DispatchToFunction(Function function, const A& arg) {
+  (*function)(arg);
+}
+
+template <class Function, class A>
+inline void DispatchToFunction(Function function, const Tuple1<A>& arg) {
+  (*function)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a));
+}
+
+template<class Function, class A, class B>
+inline void DispatchToFunction(Function function, const Tuple2<A, B>& arg) {
+  (*function)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
+              base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b));
+}
+
+template<class Function, class A, class B, class C>
+inline void DispatchToFunction(Function function, const Tuple3<A, B, C>& arg) {
+  (*function)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
+              base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b),
+              base::cef_internal::UnwrapTraits<C>::Unwrap(arg.c));
+}
+
+template<class Function, class A, class B, class C, class D>
+inline void DispatchToFunction(Function function,
+                               const Tuple4<A, B, C, D>& arg) {
+  (*function)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
+              base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b),
+              base::cef_internal::UnwrapTraits<C>::Unwrap(arg.c),
+              base::cef_internal::UnwrapTraits<D>::Unwrap(arg.d));
+}
+
+template<class Function, class A, class B, class C, class D, class E>
+inline void DispatchToFunction(Function function,
+                               const Tuple5<A, B, C, D, E>& arg) {
+  (*function)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
+              base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b),
+              base::cef_internal::UnwrapTraits<C>::Unwrap(arg.c),
+              base::cef_internal::UnwrapTraits<D>::Unwrap(arg.d),
+              base::cef_internal::UnwrapTraits<E>::Unwrap(arg.e));
+}
+
+template<class Function, class A, class B, class C, class D, class E, class F>
+inline void DispatchToFunction(Function function,
+                               const Tuple6<A, B, C, D, E, F>& arg) {
+  (*function)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
+              base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b),
+              base::cef_internal::UnwrapTraits<C>::Unwrap(arg.c),
+              base::cef_internal::UnwrapTraits<D>::Unwrap(arg.d),
+              base::cef_internal::UnwrapTraits<E>::Unwrap(arg.e),
+              base::cef_internal::UnwrapTraits<F>::Unwrap(arg.f));
+}
+
+template<class Function, class A, class B, class C, class D, class E, class F,
+         class G>
+inline void DispatchToFunction(Function function,
+                               const Tuple7<A, B, C, D, E, F, G>& arg) {
+  (*function)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
+              base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b),
+              base::cef_internal::UnwrapTraits<C>::Unwrap(arg.c),
+              base::cef_internal::UnwrapTraits<D>::Unwrap(arg.d),
+              base::cef_internal::UnwrapTraits<E>::Unwrap(arg.e),
+              base::cef_internal::UnwrapTraits<F>::Unwrap(arg.f),
+              base::cef_internal::UnwrapTraits<G>::Unwrap(arg.g));
+}
+
+template<class Function, class A, class B, class C, class D, class E, class F,
+         class G, class H>
+inline void DispatchToFunction(Function function,
+                               const Tuple8<A, B, C, D, E, F, G, H>& arg) {
+  (*function)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
+              base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b),
+              base::cef_internal::UnwrapTraits<C>::Unwrap(arg.c),
+              base::cef_internal::UnwrapTraits<D>::Unwrap(arg.d),
+              base::cef_internal::UnwrapTraits<E>::Unwrap(arg.e),
+              base::cef_internal::UnwrapTraits<F>::Unwrap(arg.f),
+              base::cef_internal::UnwrapTraits<G>::Unwrap(arg.g),
+              base::cef_internal::UnwrapTraits<H>::Unwrap(arg.h));
+}
+
+// Dispatchers with 0 out param (as a Tuple0).
+
+template <class ObjT, class Method>
+inline void DispatchToMethod(ObjT* obj,
+                             Method method,
+                             const Tuple0& arg, Tuple0*) {
+  (obj->*method)();
+}
+
+template <class ObjT, class Method, class A>
+inline void DispatchToMethod(ObjT* obj, Method method, const A& arg, Tuple0*) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg));
+}
+
+template <class ObjT, class Method, class A>
+inline void DispatchToMethod(ObjT* obj,
+                             Method method,
+                             const Tuple1<A>& arg, Tuple0*) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a));
+}
+
+template<class ObjT, class Method, class A, class B>
+inline void DispatchToMethod(ObjT* obj,
+                             Method method,
+                             const Tuple2<A, B>& arg, Tuple0*) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
+                 base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b));
+}
+
+template<class ObjT, class Method, class A, class B, class C>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple3<A, B, C>& arg, Tuple0*) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
+                 base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b),
+                 base::cef_internal::UnwrapTraits<C>::Unwrap(arg.c));
+}
+
+template<class ObjT, class Method, class A, class B, class C, class D>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple4<A, B, C, D>& arg, Tuple0*) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
+                 base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b),
+                 base::cef_internal::UnwrapTraits<C>::Unwrap(arg.c),
+                 base::cef_internal::UnwrapTraits<D>::Unwrap(arg.d));
+}
+
+template<class ObjT, class Method, class A, class B, class C, class D, class E>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple5<A, B, C, D, E>& arg, Tuple0*) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
+                 base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b),
+                 base::cef_internal::UnwrapTraits<C>::Unwrap(arg.c),
+                 base::cef_internal::UnwrapTraits<D>::Unwrap(arg.d),
+                 base::cef_internal::UnwrapTraits<E>::Unwrap(arg.e));
+}
+
+template<class ObjT, class Method, class A, class B, class C, class D, class E,
+         class F>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple6<A, B, C, D, E, F>& arg, Tuple0*) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
+                 base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b),
+                 base::cef_internal::UnwrapTraits<C>::Unwrap(arg.c),
+                 base::cef_internal::UnwrapTraits<D>::Unwrap(arg.d),
+                 base::cef_internal::UnwrapTraits<E>::Unwrap(arg.e),
+                 base::cef_internal::UnwrapTraits<F>::Unwrap(arg.f));
+}
+
+// Dispatchers with 1 out param.
+
+template<class ObjT, class Method,
+         class OutA>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple0& in,
+                             Tuple1<OutA>* out) {
+  (obj->*method)(&out->a);
+}
+
+template<class ObjT, class Method, class InA,
+         class OutA>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const InA& in,
+                             Tuple1<OutA>* out) {
+  (obj->*method)(in, &out->a);
+}
+
+template<class ObjT, class Method, class InA,
+         class OutA>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple1<InA>& in,
+                             Tuple1<OutA>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a), &out->a);
+}
+
+template<class ObjT, class Method, class InA, class InB,
+         class OutA>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple2<InA, InB>& in,
+                             Tuple1<OutA>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
+                 base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
+                 &out->a);
+}
+
+template<class ObjT, class Method, class InA, class InB, class InC,
+         class OutA>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple3<InA, InB, InC>& in,
+                             Tuple1<OutA>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
+                 base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
+                 base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
+                 &out->a);
+}
+
+template<class ObjT, class Method, class InA, class InB, class InC, class InD,
+         class OutA>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple4<InA, InB, InC, InD>& in,
+                             Tuple1<OutA>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
+                 base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
+                 base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
+                 base::cef_internal::UnwrapTraits<InD>::Unwrap(in.d),
+                 &out->a);
+}
+
+template<class ObjT, class Method, class InA, class InB, class InC, class InD,
+         class InE, class OutA>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple5<InA, InB, InC, InD, InE>& in,
+                             Tuple1<OutA>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
+                 base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
+                 base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
+                 base::cef_internal::UnwrapTraits<InD>::Unwrap(in.d),
+                 base::cef_internal::UnwrapTraits<InE>::Unwrap(in.e),
+                 &out->a);
+}
+
+template<class ObjT, class Method,
+         class InA, class InB, class InC, class InD, class InE, class InF,
+         class OutA>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple6<InA, InB, InC, InD, InE, InF>& in,
+                             Tuple1<OutA>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
+                 base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
+                 base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
+                 base::cef_internal::UnwrapTraits<InD>::Unwrap(in.d),
+                 base::cef_internal::UnwrapTraits<InE>::Unwrap(in.e),
+                 base::cef_internal::UnwrapTraits<InF>::Unwrap(in.f),
+                 &out->a);
+}
+
+// Dispatchers with 2 out params.
+
+template<class ObjT, class Method,
+         class OutA, class OutB>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple0& in,
+                             Tuple2<OutA, OutB>* out) {
+  (obj->*method)(&out->a, &out->b);
+}
+
+template<class ObjT, class Method, class InA,
+         class OutA, class OutB>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const InA& in,
+                             Tuple2<OutA, OutB>* out) {
+  (obj->*method)(in, &out->a, &out->b);
+}
+
+template<class ObjT, class Method, class InA,
+         class OutA, class OutB>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple1<InA>& in,
+                             Tuple2<OutA, OutB>* out) {
+  (obj->*method)(
+      base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a), &out->a, &out->b);
+}
+
+template<class ObjT, class Method, class InA, class InB,
+         class OutA, class OutB>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple2<InA, InB>& in,
+                             Tuple2<OutA, OutB>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
+                 base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
+                 &out->a,
+                 &out->b);
+}
+
+template<class ObjT, class Method, class InA, class InB, class InC,
+         class OutA, class OutB>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple3<InA, InB, InC>& in,
+                             Tuple2<OutA, OutB>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
+                 base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
+                 base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
+                 &out->a,
+                 &out->b);
+}
+
+template<class ObjT, class Method, class InA, class InB, class InC, class InD,
+         class OutA, class OutB>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple4<InA, InB, InC, InD>& in,
+                             Tuple2<OutA, OutB>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
+                 base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
+                 base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
+                 base::cef_internal::UnwrapTraits<InD>::Unwrap(in.d),
+                 &out->a,
+                 &out->b);
+}
+
+template<class ObjT, class Method,
+         class InA, class InB, class InC, class InD, class InE,
+         class OutA, class OutB>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple5<InA, InB, InC, InD, InE>& in,
+                             Tuple2<OutA, OutB>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
+                 base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
+                 base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
+                 base::cef_internal::UnwrapTraits<InD>::Unwrap(in.d),
+                 base::cef_internal::UnwrapTraits<InE>::Unwrap(in.e),
+                 &out->a,
+                 &out->b);
+}
+
+template<class ObjT, class Method,
+         class InA, class InB, class InC, class InD, class InE, class InF,
+         class OutA, class OutB>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple6<InA, InB, InC, InD, InE, InF>& in,
+                             Tuple2<OutA, OutB>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
+                 base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
+                 base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
+                 base::cef_internal::UnwrapTraits<InD>::Unwrap(in.d),
+                 base::cef_internal::UnwrapTraits<InE>::Unwrap(in.e),
+                 base::cef_internal::UnwrapTraits<InF>::Unwrap(in.f),
+                 &out->a,
+                 &out->b);
+}
+
+// Dispatchers with 3 out params.
+
+template<class ObjT, class Method,
+         class OutA, class OutB, class OutC>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple0& in,
+                             Tuple3<OutA, OutB, OutC>* out) {
+  (obj->*method)(&out->a, &out->b, &out->c);
+}
+
+template<class ObjT, class Method, class InA,
+         class OutA, class OutB, class OutC>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const InA& in,
+                             Tuple3<OutA, OutB, OutC>* out) {
+  (obj->*method)(in, &out->a, &out->b, &out->c);
+}
+
+template<class ObjT, class Method, class InA,
+         class OutA, class OutB, class OutC>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple1<InA>& in,
+                             Tuple3<OutA, OutB, OutC>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
+                 &out->a,
+                 &out->b,
+                 &out->c);
+}
+
+template<class ObjT, class Method, class InA, class InB,
+         class OutA, class OutB, class OutC>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple2<InA, InB>& in,
+                             Tuple3<OutA, OutB, OutC>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
+                 base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
+                 &out->a,
+                 &out->b,
+                 &out->c);
+}
+
+template<class ObjT, class Method, class InA, class InB, class InC,
+         class OutA, class OutB, class OutC>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple3<InA, InB, InC>& in,
+                             Tuple3<OutA, OutB, OutC>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
+                 base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
+                 base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
+                 &out->a,
+                 &out->b,
+                 &out->c);
+}
+
+template<class ObjT, class Method, class InA, class InB, class InC, class InD,
+         class OutA, class OutB, class OutC>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple4<InA, InB, InC, InD>& in,
+                             Tuple3<OutA, OutB, OutC>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
+                 base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
+                 base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
+                 base::cef_internal::UnwrapTraits<InD>::Unwrap(in.d),
+                 &out->a,
+                 &out->b,
+                 &out->c);
+}
+
+template<class ObjT, class Method,
+         class InA, class InB, class InC, class InD, class InE,
+         class OutA, class OutB, class OutC>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple5<InA, InB, InC, InD, InE>& in,
+                             Tuple3<OutA, OutB, OutC>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
+                 base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
+                 base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
+                 base::cef_internal::UnwrapTraits<InD>::Unwrap(in.d),
+                 base::cef_internal::UnwrapTraits<InE>::Unwrap(in.e),
+                 &out->a,
+                 &out->b,
+                 &out->c);
+}
+
+template<class ObjT, class Method,
+         class InA, class InB, class InC, class InD, class InE, class InF,
+         class OutA, class OutB, class OutC>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple6<InA, InB, InC, InD, InE, InF>& in,
+                             Tuple3<OutA, OutB, OutC>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
+                 base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
+                 base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
+                 base::cef_internal::UnwrapTraits<InD>::Unwrap(in.d),
+                 base::cef_internal::UnwrapTraits<InE>::Unwrap(in.e),
+                 base::cef_internal::UnwrapTraits<InF>::Unwrap(in.f),
+                 &out->a,
+                 &out->b,
+                 &out->c);
+}
+
+// Dispatchers with 4 out params.
+
+template<class ObjT, class Method,
+         class OutA, class OutB, class OutC, class OutD>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple0& in,
+                             Tuple4<OutA, OutB, OutC, OutD>* out) {
+  (obj->*method)(&out->a, &out->b, &out->c, &out->d);
+}
+
+template<class ObjT, class Method, class InA,
+         class OutA, class OutB, class OutC, class OutD>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const InA& in,
+                             Tuple4<OutA, OutB, OutC, OutD>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in),
+                 &out->a,
+                 &out->b,
+                 &out->c,
+                 &out->d);
+}
+
+template<class ObjT, class Method, class InA,
+         class OutA, class OutB, class OutC, class OutD>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple1<InA>& in,
+                             Tuple4<OutA, OutB, OutC, OutD>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
+                 &out->a,
+                 &out->b,
+                 &out->c,
+                 &out->d);
+}
+
+template<class ObjT, class Method, class InA, class InB,
+         class OutA, class OutB, class OutC, class OutD>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple2<InA, InB>& in,
+                             Tuple4<OutA, OutB, OutC, OutD>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
+                 base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
+                 &out->a,
+                 &out->b,
+                 &out->c,
+                 &out->d);
+}
+
+template<class ObjT, class Method, class InA, class InB, class InC,
+         class OutA, class OutB, class OutC, class OutD>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple3<InA, InB, InC>& in,
+                             Tuple4<OutA, OutB, OutC, OutD>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
+                 base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
+                 base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
+                 &out->a,
+                 &out->b,
+                 &out->c,
+                 &out->d);
+}
+
+template<class ObjT, class Method, class InA, class InB, class InC, class InD,
+         class OutA, class OutB, class OutC, class OutD>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple4<InA, InB, InC, InD>& in,
+                             Tuple4<OutA, OutB, OutC, OutD>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
+                 base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
+                 base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
+                 base::cef_internal::UnwrapTraits<InD>::Unwrap(in.d),
+                 &out->a,
+                 &out->b,
+                 &out->c,
+                 &out->d);
+}
+
+template<class ObjT, class Method,
+         class InA, class InB, class InC, class InD, class InE,
+         class OutA, class OutB, class OutC, class OutD>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple5<InA, InB, InC, InD, InE>& in,
+                             Tuple4<OutA, OutB, OutC, OutD>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
+                 base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
+                 base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
+                 base::cef_internal::UnwrapTraits<InD>::Unwrap(in.d),
+                 base::cef_internal::UnwrapTraits<InE>::Unwrap(in.e),
+                 &out->a,
+                 &out->b,
+                 &out->c,
+                 &out->d);
+}
+
+template<class ObjT, class Method,
+         class InA, class InB, class InC, class InD, class InE, class InF,
+         class OutA, class OutB, class OutC, class OutD>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple6<InA, InB, InC, InD, InE, InF>& in,
+                             Tuple4<OutA, OutB, OutC, OutD>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
+                 base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
+                 base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
+                 base::cef_internal::UnwrapTraits<InD>::Unwrap(in.d),
+                 base::cef_internal::UnwrapTraits<InE>::Unwrap(in.e),
+                 base::cef_internal::UnwrapTraits<InF>::Unwrap(in.f),
+                 &out->a,
+                 &out->b,
+                 &out->c,
+                 &out->d);
+}
+
+// Dispatchers with 5 out params.
+
+template<class ObjT, class Method,
+         class OutA, class OutB, class OutC, class OutD, class OutE>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple0& in,
+                             Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
+  (obj->*method)(&out->a, &out->b, &out->c, &out->d, &out->e);
+}
+
+template<class ObjT, class Method, class InA,
+         class OutA, class OutB, class OutC, class OutD, class OutE>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const InA& in,
+                             Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in),
+                 &out->a,
+                 &out->b,
+                 &out->c,
+                 &out->d,
+                 &out->e);
+}
+
+template<class ObjT, class Method, class InA,
+         class OutA, class OutB, class OutC, class OutD, class OutE>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple1<InA>& in,
+                             Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
+                 &out->a,
+                 &out->b,
+                 &out->c,
+                 &out->d,
+                 &out->e);
+}
+
+template<class ObjT, class Method, class InA, class InB,
+         class OutA, class OutB, class OutC, class OutD, class OutE>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple2<InA, InB>& in,
+                             Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
+                 base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
+                 &out->a,
+                 &out->b,
+                 &out->c,
+                 &out->d,
+                 &out->e);
+}
+
+template<class ObjT, class Method, class InA, class InB, class InC,
+         class OutA, class OutB, class OutC, class OutD, class OutE>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple3<InA, InB, InC>& in,
+                             Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
+                 base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
+                 base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
+                 &out->a,
+                 &out->b,
+                 &out->c,
+                 &out->d,
+                 &out->e);
+}
+
+template<class ObjT, class Method, class InA, class InB, class InC, class InD,
+         class OutA, class OutB, class OutC, class OutD, class OutE>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple4<InA, InB, InC, InD>& in,
+                             Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
+                 base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
+                 base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
+                 base::cef_internal::UnwrapTraits<InD>::Unwrap(in.d),
+                 &out->a,
+                 &out->b,
+                 &out->c,
+                 &out->d,
+                 &out->e);
+}
+
+template<class ObjT, class Method,
+         class InA, class InB, class InC, class InD, class InE,
+         class OutA, class OutB, class OutC, class OutD, class OutE>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple5<InA, InB, InC, InD, InE>& in,
+                             Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
+                 base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
+                 base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
+                 base::cef_internal::UnwrapTraits<InD>::Unwrap(in.d),
+                 base::cef_internal::UnwrapTraits<InE>::Unwrap(in.e),
+                 &out->a,
+                 &out->b,
+                 &out->c,
+                 &out->d,
+                 &out->e);
+}
+
+template<class ObjT, class Method,
+         class InA, class InB, class InC, class InD, class InE, class InF,
+         class OutA, class OutB, class OutC, class OutD, class OutE>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple6<InA, InB, InC, InD, InE, InF>& in,
+                             Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
+                 base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
+                 base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
+                 base::cef_internal::UnwrapTraits<InD>::Unwrap(in.d),
+                 base::cef_internal::UnwrapTraits<InE>::Unwrap(in.e),
+                 base::cef_internal::UnwrapTraits<InF>::Unwrap(in.f),
+                 &out->a,
+                 &out->b,
+                 &out->c,
+                 &out->d,
+                 &out->e);
+}
+
+}  // namespace base
+
+#endif // !USING_CHROMIUM_INCLUDES
+
+#endif  // CEF_INCLUDE_BASE_CEF_TUPLE_H_
diff --git a/src/include/libcef/base/cef_weak_ptr.h b/src/include/libcef/base/cef_weak_ptr.h
new file mode 100644
index 0000000..c206e66
--- /dev/null
+++ b/src/include/libcef/base/cef_weak_ptr.h
@@ -0,0 +1,388 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2012
+// Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Weak pointers are pointers to an object that do not affect its lifetime,
+// and which may be invalidated (i.e. reset to NULL) by the object, or its
+// owner, at any time, most commonly when the object is about to be deleted.
+
+// Weak pointers are useful when an object needs to be accessed safely by one
+// or more objects other than its owner, and those callers can cope with the
+// object vanishing and e.g. tasks posted to it being silently dropped.
+// Reference-counting such an object would complicate the ownership graph and
+// make it harder to reason about the object's lifetime.
+
+// EXAMPLE:
+//
+//  class Controller {
+//   public:
+//    Controller() : weak_factory_(this) {}
+//    void SpawnWorker() { Worker::StartNew(weak_factory_.GetWeakPtr()); }
+//    void WorkComplete(const Result& result) { ... }
+//   private:
+//    // Member variables should appear before the WeakPtrFactory, to ensure
+//    // that any WeakPtrs to Controller are invalidated before its members
+//    // variable's destructors are executed, rendering them invalid.
+//    WeakPtrFactory<Controller> weak_factory_;
+//  };
+//
+//  class Worker {
+//   public:
+//    static void StartNew(const WeakPtr<Controller>& controller) {
+//      Worker* worker = new Worker(controller);
+//      // Kick off asynchronous processing...
+//    }
+//   private:
+//    Worker(const WeakPtr<Controller>& controller)
+//        : controller_(controller) {}
+//    void DidCompleteAsynchronousProcessing(const Result& result) {
+//      if (controller_)
+//        controller_->WorkComplete(result);
+//    }
+//    WeakPtr<Controller> controller_;
+//  };
+//
+// With this implementation a caller may use SpawnWorker() to dispatch multiple
+// Workers and subsequently delete the Controller, without waiting for all
+// Workers to have completed.
+
+// ------------------------- IMPORTANT: Thread-safety -------------------------
+
+// Weak pointers may be passed safely between threads, but must always be
+// dereferenced and invalidated on the same thread otherwise checking the
+// pointer would be racey.
+//
+// To ensure correct use, the first time a WeakPtr issued by a WeakPtrFactory
+// is dereferenced, the factory and its WeakPtrs become bound to the calling
+// thread, and cannot be dereferenced or invalidated on any other thread. Bound
+// WeakPtrs can still be handed off to other threads, e.g. to use to post tasks
+// back to object on the bound thread.
+//
+// If all WeakPtr objects are destroyed or invalidated then the factory is
+// unbound from the SequencedTaskRunner/Thread. The WeakPtrFactory may then be
+// destroyed, or new WeakPtr objects may be used, from a different sequence.
+//
+// Thus, at least one WeakPtr object must exist and have been dereferenced on
+// the correct thread to enforce that other WeakPtr objects will enforce they
+// are used on the desired thread.
+
+#ifndef CEF_INCLUDE_BASE_CEF_WEAK_PTR_H_
+#define CEF_INCLUDE_BASE_CEF_WEAK_PTR_H_
+#pragma once
+
+#if defined(BASE_MEMORY_WEAK_PTR_H_)
+// Do nothing if the Chromium header has already been included.
+// This can happen in cases where Chromium code is used directly by the
+// client application. When using Chromium code directly always include
+// the Chromium header first to avoid type conflicts.
+#elif defined(USING_CHROMIUM_INCLUDES)
+// When building CEF include the Chromium header directly.
+#include "base/memory/weak_ptr.h"
+#else  // !USING_CHROMIUM_INCLUDES
+// The following is substantially similar to the Chromium implementation.
+// If the Chromium implementation diverges the below implementation should be
+// updated to match.
+
+#include "libcef/base/cef_basictypes.h"
+#include "libcef/base/cef_logging.h"
+#include "libcef/base/cef_ref_counted.h"
+#include "libcef/base/cef_template_util.h"
+#include "libcef/base/cef_thread_checker.h"
+
+namespace base {
+
+template <typename T> class SupportsWeakPtr;
+template <typename T> class WeakPtr;
+
+namespace cef_internal {
+// These classes are part of the WeakPtr implementation.
+// DO NOT USE THESE CLASSES DIRECTLY YOURSELF.
+
+class WeakReference {
+ public:
+  // Although Flag is bound to a specific thread, it may be deleted from another
+  // via base::WeakPtr::~WeakPtr().
+  class Flag : public RefCountedThreadSafe<Flag> {
+   public:
+    Flag();
+
+    void Invalidate();
+    bool IsValid() const;
+
+   private:
+    friend class base::RefCountedThreadSafe<Flag>;
+
+    ~Flag();
+
+    // The current Chromium implementation uses SequenceChecker instead of
+    // ThreadChecker to support SequencedWorkerPools. CEF does not yet expose
+    // the concept of SequencedWorkerPools.
+    ThreadChecker thread_checker_;
+    bool is_valid_;
+  };
+
+  WeakReference();
+  explicit WeakReference(const Flag* flag);
+  ~WeakReference();
+
+  bool is_valid() const;
+
+ private:
+  scoped_refptr<const Flag> flag_;
+};
+
+class WeakReferenceOwner {
+ public:
+  WeakReferenceOwner();
+  ~WeakReferenceOwner();
+
+  WeakReference GetRef() const;
+
+  bool HasRefs() const {
+    return flag_.get() && !flag_->HasOneRef();
+  }
+
+  void Invalidate();
+
+ private:
+  mutable scoped_refptr<WeakReference::Flag> flag_;
+};
+
+// This class simplifies the implementation of WeakPtr's type conversion
+// constructor by avoiding the need for a public accessor for ref_.  A
+// WeakPtr<T> cannot access the private members of WeakPtr<U>, so this
+// base class gives us a way to access ref_ in a protected fashion.
+class WeakPtrBase {
+ public:
+  WeakPtrBase();
+  ~WeakPtrBase();
+
+ protected:
+  explicit WeakPtrBase(const WeakReference& ref);
+
+  WeakReference ref_;
+};
+
+// This class provides a common implementation of common functions that would
+// otherwise get instantiated separately for each distinct instantiation of
+// SupportsWeakPtr<>.
+class SupportsWeakPtrBase {
+ public:
+  // A safe static downcast of a WeakPtr<Base> to WeakPtr<Derived>. This
+  // conversion will only compile if there is exists a Base which inherits
+  // from SupportsWeakPtr<Base>. See base::AsWeakPtr() below for a helper
+  // function that makes calling this easier.
+  template<typename Derived>
+  static WeakPtr<Derived> StaticAsWeakPtr(Derived* t) {
+    typedef
+        is_convertible<Derived, cef_internal::SupportsWeakPtrBase&> convertible;
+    COMPILE_ASSERT(convertible::value,
+                   AsWeakPtr_argument_inherits_from_SupportsWeakPtr);
+    return AsWeakPtrImpl<Derived>(t, *t);
+  }
+
+ private:
+  // This template function uses type inference to find a Base of Derived
+  // which is an instance of SupportsWeakPtr<Base>. We can then safely
+  // static_cast the Base* to a Derived*.
+  template <typename Derived, typename Base>
+  static WeakPtr<Derived> AsWeakPtrImpl(
+      Derived* t, const SupportsWeakPtr<Base>&) {
+    WeakPtr<Base> ptr = t->Base::AsWeakPtr();
+    return WeakPtr<Derived>(ptr.ref_, static_cast<Derived*>(ptr.ptr_));
+  }
+};
+
+}  // namespace cef_internal
+
+template <typename T> class WeakPtrFactory;
+
+// The WeakPtr class holds a weak reference to |T*|.
+//
+// This class is designed to be used like a normal pointer.  You should always
+// null-test an object of this class before using it or invoking a method that
+// may result in the underlying object being destroyed.
+//
+// EXAMPLE:
+//
+//   class Foo { ... };
+//   WeakPtr<Foo> foo;
+//   if (foo)
+//     foo->method();
+//
+template <typename T>
+class WeakPtr : public cef_internal::WeakPtrBase {
+ public:
+  WeakPtr() : ptr_(NULL) {
+  }
+
+  // Allow conversion from U to T provided U "is a" T. Note that this
+  // is separate from the (implicit) copy constructor.
+  template <typename U>
+  WeakPtr(const WeakPtr<U>& other) : WeakPtrBase(other), ptr_(other.ptr_) {
+  }
+
+  T* get() const { return ref_.is_valid() ? ptr_ : NULL; }
+
+  T& operator*() const {
+    DCHECK(get() != NULL);
+    return *get();
+  }
+  T* operator->() const {
+    DCHECK(get() != NULL);
+    return get();
+  }
+
+  // Allow WeakPtr<element_type> to be used in boolean expressions, but not
+  // implicitly convertible to a real bool (which is dangerous).
+  //
+  // Note that this trick is only safe when the == and != operators
+  // are declared explicitly, as otherwise "weak_ptr1 == weak_ptr2"
+  // will compile but do the wrong thing (i.e., convert to Testable
+  // and then do the comparison).
+ private:
+  typedef T* WeakPtr::*Testable;
+
+ public:
+  operator Testable() const { return get() ? &WeakPtr::ptr_ : NULL; }
+
+  void reset() {
+    ref_ = cef_internal::WeakReference();
+    ptr_ = NULL;
+  }
+
+ private:
+  // Explicitly declare comparison operators as required by the bool
+  // trick, but keep them private.
+  template <class U> bool operator==(WeakPtr<U> const&) const;
+  template <class U> bool operator!=(WeakPtr<U> const&) const;
+
+  friend class cef_internal::SupportsWeakPtrBase;
+  template <typename U> friend class WeakPtr;
+  friend class SupportsWeakPtr<T>;
+  friend class WeakPtrFactory<T>;
+
+  WeakPtr(const cef_internal::WeakReference& ref, T* ptr)
+      : WeakPtrBase(ref),
+        ptr_(ptr) {
+  }
+
+  // This pointer is only valid when ref_.is_valid() is true.  Otherwise, its
+  // value is undefined (as opposed to NULL).
+  T* ptr_;
+};
+
+// A class may be composed of a WeakPtrFactory and thereby
+// control how it exposes weak pointers to itself.  This is helpful if you only
+// need weak pointers within the implementation of a class.  This class is also
+// useful when working with primitive types.  For example, you could have a
+// WeakPtrFactory<bool> that is used to pass around a weak reference to a bool.
+template <class T>
+class WeakPtrFactory {
+ public:
+  explicit WeakPtrFactory(T* ptr) : ptr_(ptr) {
+  }
+
+  ~WeakPtrFactory() {
+    ptr_ = NULL;
+  }
+
+  WeakPtr<T> GetWeakPtr() {
+    DCHECK(ptr_);
+    return WeakPtr<T>(weak_reference_owner_.GetRef(), ptr_);
+  }
+
+  // Call this method to invalidate all existing weak pointers.
+  void InvalidateWeakPtrs() {
+    DCHECK(ptr_);
+    weak_reference_owner_.Invalidate();
+  }
+
+  // Call this method to determine if any weak pointers exist.
+  bool HasWeakPtrs() const {
+    DCHECK(ptr_);
+    return weak_reference_owner_.HasRefs();
+  }
+
+ private:
+  cef_internal::WeakReferenceOwner weak_reference_owner_;
+  T* ptr_;
+  DISALLOW_IMPLICIT_CONSTRUCTORS(WeakPtrFactory);
+};
+
+// A class may extend from SupportsWeakPtr to let others take weak pointers to
+// it. This avoids the class itself implementing boilerplate to dispense weak
+// pointers.  However, since SupportsWeakPtr's destructor won't invalidate
+// weak pointers to the class until after the derived class' members have been
+// destroyed, its use can lead to subtle use-after-destroy issues.
+template <class T>
+class SupportsWeakPtr : public cef_internal::SupportsWeakPtrBase {
+ public:
+  SupportsWeakPtr() {}
+
+  WeakPtr<T> AsWeakPtr() {
+    return WeakPtr<T>(weak_reference_owner_.GetRef(), static_cast<T*>(this));
+  }
+
+ protected:
+  ~SupportsWeakPtr() {}
+
+ private:
+  cef_internal::WeakReferenceOwner weak_reference_owner_;
+  DISALLOW_COPY_AND_ASSIGN(SupportsWeakPtr);
+};
+
+// Helper function that uses type deduction to safely return a WeakPtr<Derived>
+// when Derived doesn't directly extend SupportsWeakPtr<Derived>, instead it
+// extends a Base that extends SupportsWeakPtr<Base>.
+//
+// EXAMPLE:
+//   class Base : public base::SupportsWeakPtr<Producer> {};
+//   class Derived : public Base {};
+//
+//   Derived derived;
+//   base::WeakPtr<Derived> ptr = base::AsWeakPtr(&derived);
+//
+// Note that the following doesn't work (invalid type conversion) since
+// Derived::AsWeakPtr() is WeakPtr<Base> SupportsWeakPtr<Base>::AsWeakPtr(),
+// and there's no way to safely cast WeakPtr<Base> to WeakPtr<Derived> at
+// the caller.
+//
+//   base::WeakPtr<Derived> ptr = derived.AsWeakPtr();  // Fails.
+
+template <typename Derived>
+WeakPtr<Derived> AsWeakPtr(Derived* t) {
+  return cef_internal::SupportsWeakPtrBase::StaticAsWeakPtr<Derived>(t);
+}
+
+}  // namespace base
+
+#endif  // !USING_CHROMIUM_INCLUDES
+
+#endif  // CEF_INCLUDE_BASE_CEF_WEAK_PTR_H_
diff --git a/src/include/libcef/base/internal/cef_atomicops_x86_msvc.h b/src/include/libcef/base/internal/cef_atomicops_x86_msvc.h
new file mode 100644
index 0000000..12bb0f4
--- /dev/null
+++ b/src/include/libcef/base/internal/cef_atomicops_x86_msvc.h
@@ -0,0 +1,224 @@
+// Copyright (c) 2008 Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Do not include this header file directly. Use base/cef_atomicops.h
+// instead.
+
+#ifndef CEF_INCLUDE_BASE_INTERNAL_CEF_ATOMICOPS_X86_MSVC_H_
+#define CEF_INCLUDE_BASE_INTERNAL_CEF_ATOMICOPS_X86_MSVC_H_
+
+#include <windows.h>
+
+#include <intrin.h>
+
+#include "include/base/cef_macros.h"
+
+#if defined(ARCH_CPU_64_BITS)
+// windows.h #defines this (only on x64). This causes problems because the
+// public API also uses MemoryBarrier at the public name for this fence. So, on
+// X64, undef it, and call its documented
+// (http://msdn.microsoft.com/en-us/library/windows/desktop/ms684208.aspx)
+// implementation directly.
+#undef MemoryBarrier
+#endif
+
+namespace base {
+namespace subtle {
+
+inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr,
+                                         Atomic32 old_value,
+                                         Atomic32 new_value) {
+  LONG result = _InterlockedCompareExchange(
+      reinterpret_cast<volatile LONG*>(ptr),
+      static_cast<LONG>(new_value),
+      static_cast<LONG>(old_value));
+  return static_cast<Atomic32>(result);
+}
+
+inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr,
+                                         Atomic32 new_value) {
+  LONG result = _InterlockedExchange(
+      reinterpret_cast<volatile LONG*>(ptr),
+      static_cast<LONG>(new_value));
+  return static_cast<Atomic32>(result);
+}
+
+inline Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr,
+                                        Atomic32 increment) {
+  return _InterlockedExchangeAdd(
+      reinterpret_cast<volatile LONG*>(ptr),
+      static_cast<LONG>(increment)) + increment;
+}
+
+inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr,
+                                          Atomic32 increment) {
+  return Barrier_AtomicIncrement(ptr, increment);
+}
+
+#if !(defined(_MSC_VER) && _MSC_VER >= 1400)
+#error "We require at least vs2005 for MemoryBarrier"
+#endif
+inline void MemoryBarrier() {
+#if defined(ARCH_CPU_64_BITS)
+  // See #undef and note at the top of this file.
+  __faststorefence();
+#else
+  // We use MemoryBarrier from WinNT.h
+  ::MemoryBarrier();
+#endif
+}
+
+inline Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr,
+                                       Atomic32 old_value,
+                                       Atomic32 new_value) {
+  return NoBarrier_CompareAndSwap(ptr, old_value, new_value);
+}
+
+inline Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr,
+                                       Atomic32 old_value,
+                                       Atomic32 new_value) {
+  return NoBarrier_CompareAndSwap(ptr, old_value, new_value);
+}
+
+inline void NoBarrier_Store(volatile Atomic32* ptr, Atomic32 value) {
+  *ptr = value;
+}
+
+inline void Acquire_Store(volatile Atomic32* ptr, Atomic32 value) {
+  NoBarrier_AtomicExchange(ptr, value);
+              // acts as a barrier in this implementation
+}
+
+inline void Release_Store(volatile Atomic32* ptr, Atomic32 value) {
+  *ptr = value; // works w/o barrier for current Intel chips as of June 2005
+  // See comments in Atomic64 version of Release_Store() below.
+}
+
+inline Atomic32 NoBarrier_Load(volatile const Atomic32* ptr) {
+  return *ptr;
+}
+
+inline Atomic32 Acquire_Load(volatile const Atomic32* ptr) {
+  Atomic32 value = *ptr;
+  return value;
+}
+
+inline Atomic32 Release_Load(volatile const Atomic32* ptr) {
+  MemoryBarrier();
+  return *ptr;
+}
+
+#if defined(_WIN64)
+
+// 64-bit low-level operations on 64-bit platform.
+
+COMPILE_ASSERT(sizeof(Atomic64) == sizeof(PVOID), atomic_word_is_atomic);
+
+inline Atomic64 NoBarrier_CompareAndSwap(volatile Atomic64* ptr,
+                                         Atomic64 old_value,
+                                         Atomic64 new_value) {
+  PVOID result = InterlockedCompareExchangePointer(
+    reinterpret_cast<volatile PVOID*>(ptr),
+    reinterpret_cast<PVOID>(new_value), reinterpret_cast<PVOID>(old_value));
+  return reinterpret_cast<Atomic64>(result);
+}
+
+inline Atomic64 NoBarrier_AtomicExchange(volatile Atomic64* ptr,
+                                         Atomic64 new_value) {
+  PVOID result = InterlockedExchangePointer(
+    reinterpret_cast<volatile PVOID*>(ptr),
+    reinterpret_cast<PVOID>(new_value));
+  return reinterpret_cast<Atomic64>(result);
+}
+
+inline Atomic64 Barrier_AtomicIncrement(volatile Atomic64* ptr,
+                                        Atomic64 increment) {
+  return InterlockedExchangeAdd64(
+      reinterpret_cast<volatile LONGLONG*>(ptr),
+      static_cast<LONGLONG>(increment)) + increment;
+}
+
+inline Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64* ptr,
+                                          Atomic64 increment) {
+  return Barrier_AtomicIncrement(ptr, increment);
+}
+
+inline void NoBarrier_Store(volatile Atomic64* ptr, Atomic64 value) {
+  *ptr = value;
+}
+
+inline void Acquire_Store(volatile Atomic64* ptr, Atomic64 value) {
+  NoBarrier_AtomicExchange(ptr, value);
+              // acts as a barrier in this implementation
+}
+
+inline void Release_Store(volatile Atomic64* ptr, Atomic64 value) {
+  *ptr = value; // works w/o barrier for current Intel chips as of June 2005
+
+  // When new chips come out, check:
+  //  IA-32 Intel Architecture Software Developer's Manual, Volume 3:
+  //  System Programming Guide, Chatper 7: Multiple-processor management,
+  //  Section 7.2, Memory Ordering.
+  // Last seen at:
+  //   http://developer.intel.com/design/pentium4/manuals/index_new.htm
+}
+
+inline Atomic64 NoBarrier_Load(volatile const Atomic64* ptr) {
+  return *ptr;
+}
+
+inline Atomic64 Acquire_Load(volatile const Atomic64* ptr) {
+  Atomic64 value = *ptr;
+  return value;
+}
+
+inline Atomic64 Release_Load(volatile const Atomic64* ptr) {
+  MemoryBarrier();
+  return *ptr;
+}
+
+inline Atomic64 Acquire_CompareAndSwap(volatile Atomic64* ptr,
+                                       Atomic64 old_value,
+                                       Atomic64 new_value) {
+  return NoBarrier_CompareAndSwap(ptr, old_value, new_value);
+}
+
+inline Atomic64 Release_CompareAndSwap(volatile Atomic64* ptr,
+                                       Atomic64 old_value,
+                                       Atomic64 new_value) {
+  return NoBarrier_CompareAndSwap(ptr, old_value, new_value);
+}
+
+
+#endif  // defined(_WIN64)
+
+}  // namespace base::subtle
+}  // namespace base
+
+#endif  // CEF_INCLUDE_BASE_INTERNAL_CEF_ATOMICOPS_X86_MSVC_H_
diff --git a/src/include/libcef/base/internal/cef_bind_internal.h b/src/include/libcef/base/internal/cef_bind_internal.h
new file mode 100644
index 0000000..a097978
--- /dev/null
+++ b/src/include/libcef/base/internal/cef_bind_internal.h
@@ -0,0 +1,2852 @@
+// Copyright (c) 2011 Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Do not include this header file directly. Use base/cef_bind.h instead.
+
+#ifndef CEF_INCLUDE_BASE_INTERNAL_CEF_BIND_INTERNAL_H_
+#define CEF_INCLUDE_BASE_INTERNAL_CEF_BIND_INTERNAL_H_
+
+#include "include/base/cef_bind_helpers.h"
+#include "include/base/cef_build.h"
+#include "include/base/cef_template_util.h"
+#include "include/base/cef_weak_ptr.h"
+#include "include/base/internal/cef_callback_internal.h"
+#include "include/base/internal/cef_raw_scoped_refptr_mismatch_checker.h"
+
+#if defined(OS_WIN)
+#include "include/base/internal/cef_bind_internal_win.h"
+#endif
+
+namespace base {
+namespace cef_internal {
+
+// See base/callback.h for user documentation.
+//
+//
+// CONCEPTS:
+//  Runnable -- A type (really a type class) that has a single Run() method
+//              and a RunType typedef that corresponds to the type of Run().
+//              A Runnable can declare that it should treated like a method
+//              call by including a typedef named IsMethod.  The value of
+//              this typedef is NOT inspected, only the existence.  When a
+//              Runnable declares itself a method, Bind() will enforce special
+//              refcounting + WeakPtr handling semantics for the first
+//              parameter which is expected to be an object.
+//  Functor -- A copyable type representing something that should be called.
+//             All function pointers, Callback<>, and Runnables are functors
+//             even if the invocation syntax differs.
+//  RunType -- A function type (as opposed to function _pointer_ type) for
+//             a Run() function.  Usually just a convenience typedef.
+//  (Bound)ArgsType -- A function type that is being (ab)used to store the
+//                     types of set of arguments.  The "return" type is always
+//                     void here.  We use this hack so that we do not need
+//                     a new type name for each arity of type. (eg.,
+//                     BindState1, BindState2).  This makes forward
+//                     declarations and friending much much easier.
+//
+// Types:
+//  RunnableAdapter<> -- Wraps the various "function" pointer types into an
+//                       object that adheres to the Runnable interface.
+//                       There are |3*ARITY| RunnableAdapter types.
+//  FunctionTraits<> -- Type traits that unwrap a function signature into a
+//                      a set of easier to use typedefs.  Used mainly for
+//                      compile time asserts.
+//                      There are |ARITY| FunctionTraits types.
+//  ForceVoidReturn<> -- Helper class for translating function signatures to
+//                       equivalent forms with a "void" return type.
+//                    There are |ARITY| ForceVoidReturn types.
+//  FunctorTraits<> -- Type traits used determine the correct RunType and
+//                     RunnableType for a Functor.  This is where function
+//                     signature adapters are applied.
+//                    There are |ARITY| ForceVoidReturn types.
+//  MakeRunnable<> -- Takes a Functor and returns an object in the Runnable
+//                    type class that represents the underlying Functor.
+//                    There are |O(1)| MakeRunnable types.
+//  InvokeHelper<> -- Take a Runnable + arguments and actully invokes it.
+// Handle the differing syntaxes needed for WeakPtr<> support,
+//                    and for ignoring return values.  This is separate from
+//                    Invoker to avoid creating multiple version of Invoker<>
+//                    which grows at O(n^2) with the arity.
+//                    There are |k*ARITY| InvokeHelper types.
+//  Invoker<> -- Unwraps the curried parameters and executes the Runnable.
+//               There are |(ARITY^2 + ARITY)/2| Invoketypes.
+//  BindState<> -- Stores the curried parameters, and is the main entry point
+//                 into the Bind() system, doing most of the type resolution.
+//                 There are ARITY BindState types.
+
+// RunnableAdapter<>
+//
+// The RunnableAdapter<> templates provide a uniform interface for invoking
+// a function pointer, method pointer, or const method pointer. The adapter
+// exposes a Run() method with an appropriate signature. Using this wrapper
+// allows for writing code that supports all three pointer types without
+// undue repetition.  Without it, a lot of code would need to be repeated 3
+// times.
+//
+// For method pointers and const method pointers the first argument to Run()
+// is considered to be the received of the method.  This is similar to STL's
+// mem_fun().
+//
+// This class also exposes a RunType typedef that is the function type of the
+// Run() function.
+//
+// If and only if the wrapper contains a method or const method pointer, an
+// IsMethod typedef is exposed.  The existence of this typedef (NOT the value)
+// marks that the wrapper should be considered a method wrapper.
+
+template <typename Functor>
+class RunnableAdapter;
+
+// Function: Arity 0.
+template <typename R>
+class RunnableAdapter<R(*)()> {
+ public:
+  typedef R (RunType)();
+
+  explicit RunnableAdapter(R(*function)())
+      : function_(function) {
+  }
+
+  R Run() {
+    return function_();
+  }
+
+ private:
+  R (*function_)();
+};
+
+// Method: Arity 0.
+template <typename R, typename T>
+class RunnableAdapter<R(T::*)()> {
+ public:
+  typedef R (RunType)(T*);
+  typedef true_type IsMethod;
+
+  explicit RunnableAdapter(R(T::*method)())
+      : method_(method) {
+  }
+
+  R Run(T* object) {
+    return (object->*method_)();
+  }
+
+ private:
+  R (T::*method_)();
+};
+
+// Const Method: Arity 0.
+template <typename R, typename T>
+class RunnableAdapter<R(T::*)() const> {
+ public:
+  typedef R (RunType)(const T*);
+  typedef true_type IsMethod;
+
+  explicit RunnableAdapter(R(T::*method)() const)
+      : method_(method) {
+  }
+
+  R Run(const T* object) {
+    return (object->*method_)();
+  }
+
+ private:
+  R (T::*method_)() const;
+};
+
+// Function: Arity 1.
+template <typename R, typename A1>
+class RunnableAdapter<R(*)(A1)> {
+ public:
+  typedef R (RunType)(A1);
+
+  explicit RunnableAdapter(R(*function)(A1))
+      : function_(function) {
+  }
+
+  R Run(typename CallbackParamTraits<A1>::ForwardType a1) {
+    return function_(CallbackForward(a1));
+  }
+
+ private:
+  R (*function_)(A1);
+};
+
+// Method: Arity 1.
+template <typename R, typename T, typename A1>
+class RunnableAdapter<R(T::*)(A1)> {
+ public:
+  typedef R (RunType)(T*, A1);
+  typedef true_type IsMethod;
+
+  explicit RunnableAdapter(R(T::*method)(A1))
+      : method_(method) {
+  }
+
+  R Run(T* object, typename CallbackParamTraits<A1>::ForwardType a1) {
+    return (object->*method_)(CallbackForward(a1));
+  }
+
+ private:
+  R (T::*method_)(A1);
+};
+
+// Const Method: Arity 1.
+template <typename R, typename T, typename A1>
+class RunnableAdapter<R(T::*)(A1) const> {
+ public:
+  typedef R (RunType)(const T*, A1);
+  typedef true_type IsMethod;
+
+  explicit RunnableAdapter(R(T::*method)(A1) const)
+      : method_(method) {
+  }
+
+  R Run(const T* object, typename CallbackParamTraits<A1>::ForwardType a1) {
+    return (object->*method_)(CallbackForward(a1));
+  }
+
+ private:
+  R (T::*method_)(A1) const;
+};
+
+// Function: Arity 2.
+template <typename R, typename A1, typename A2>
+class RunnableAdapter<R(*)(A1, A2)> {
+ public:
+  typedef R (RunType)(A1, A2);
+
+  explicit RunnableAdapter(R(*function)(A1, A2))
+      : function_(function) {
+  }
+
+  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2) {
+    return function_(CallbackForward(a1), CallbackForward(a2));
+  }
+
+ private:
+  R (*function_)(A1, A2);
+};
+
+// Method: Arity 2.
+template <typename R, typename T, typename A1, typename A2>
+class RunnableAdapter<R(T::*)(A1, A2)> {
+ public:
+  typedef R (RunType)(T*, A1, A2);
+  typedef true_type IsMethod;
+
+  explicit RunnableAdapter(R(T::*method)(A1, A2))
+      : method_(method) {
+  }
+
+  R Run(T* object, typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2) {
+    return (object->*method_)(CallbackForward(a1), CallbackForward(a2));
+  }
+
+ private:
+  R (T::*method_)(A1, A2);
+};
+
+// Const Method: Arity 2.
+template <typename R, typename T, typename A1, typename A2>
+class RunnableAdapter<R(T::*)(A1, A2) const> {
+ public:
+  typedef R (RunType)(const T*, A1, A2);
+  typedef true_type IsMethod;
+
+  explicit RunnableAdapter(R(T::*method)(A1, A2) const)
+      : method_(method) {
+  }
+
+  R Run(const T* object, typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2) {
+    return (object->*method_)(CallbackForward(a1), CallbackForward(a2));
+  }
+
+ private:
+  R (T::*method_)(A1, A2) const;
+};
+
+// Function: Arity 3.
+template <typename R, typename A1, typename A2, typename A3>
+class RunnableAdapter<R(*)(A1, A2, A3)> {
+ public:
+  typedef R (RunType)(A1, A2, A3);
+
+  explicit RunnableAdapter(R(*function)(A1, A2, A3))
+      : function_(function) {
+  }
+
+  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3) {
+    return function_(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3));
+  }
+
+ private:
+  R (*function_)(A1, A2, A3);
+};
+
+// Method: Arity 3.
+template <typename R, typename T, typename A1, typename A2, typename A3>
+class RunnableAdapter<R(T::*)(A1, A2, A3)> {
+ public:
+  typedef R (RunType)(T*, A1, A2, A3);
+  typedef true_type IsMethod;
+
+  explicit RunnableAdapter(R(T::*method)(A1, A2, A3))
+      : method_(method) {
+  }
+
+  R Run(T* object, typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3) {
+    return (object->*method_)(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3));
+  }
+
+ private:
+  R (T::*method_)(A1, A2, A3);
+};
+
+// Const Method: Arity 3.
+template <typename R, typename T, typename A1, typename A2, typename A3>
+class RunnableAdapter<R(T::*)(A1, A2, A3) const> {
+ public:
+  typedef R (RunType)(const T*, A1, A2, A3);
+  typedef true_type IsMethod;
+
+  explicit RunnableAdapter(R(T::*method)(A1, A2, A3) const)
+      : method_(method) {
+  }
+
+  R Run(const T* object, typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3) {
+    return (object->*method_)(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3));
+  }
+
+ private:
+  R (T::*method_)(A1, A2, A3) const;
+};
+
+// Function: Arity 4.
+template <typename R, typename A1, typename A2, typename A3, typename A4>
+class RunnableAdapter<R(*)(A1, A2, A3, A4)> {
+ public:
+  typedef R (RunType)(A1, A2, A3, A4);
+
+  explicit RunnableAdapter(R(*function)(A1, A2, A3, A4))
+      : function_(function) {
+  }
+
+  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3,
+      typename CallbackParamTraits<A4>::ForwardType a4) {
+    return function_(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3), CallbackForward(a4));
+  }
+
+ private:
+  R (*function_)(A1, A2, A3, A4);
+};
+
+// Method: Arity 4.
+template <typename R, typename T, typename A1, typename A2, typename A3,
+    typename A4>
+class RunnableAdapter<R(T::*)(A1, A2, A3, A4)> {
+ public:
+  typedef R (RunType)(T*, A1, A2, A3, A4);
+  typedef true_type IsMethod;
+
+  explicit RunnableAdapter(R(T::*method)(A1, A2, A3, A4))
+      : method_(method) {
+  }
+
+  R Run(T* object, typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3,
+      typename CallbackParamTraits<A4>::ForwardType a4) {
+    return (object->*method_)(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3), CallbackForward(a4));
+  }
+
+ private:
+  R (T::*method_)(A1, A2, A3, A4);
+};
+
+// Const Method: Arity 4.
+template <typename R, typename T, typename A1, typename A2, typename A3,
+    typename A4>
+class RunnableAdapter<R(T::*)(A1, A2, A3, A4) const> {
+ public:
+  typedef R (RunType)(const T*, A1, A2, A3, A4);
+  typedef true_type IsMethod;
+
+  explicit RunnableAdapter(R(T::*method)(A1, A2, A3, A4) const)
+      : method_(method) {
+  }
+
+  R Run(const T* object, typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3,
+      typename CallbackParamTraits<A4>::ForwardType a4) {
+    return (object->*method_)(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3), CallbackForward(a4));
+  }
+
+ private:
+  R (T::*method_)(A1, A2, A3, A4) const;
+};
+
+// Function: Arity 5.
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5>
+class RunnableAdapter<R(*)(A1, A2, A3, A4, A5)> {
+ public:
+  typedef R (RunType)(A1, A2, A3, A4, A5);
+
+  explicit RunnableAdapter(R(*function)(A1, A2, A3, A4, A5))
+      : function_(function) {
+  }
+
+  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3,
+      typename CallbackParamTraits<A4>::ForwardType a4,
+      typename CallbackParamTraits<A5>::ForwardType a5) {
+    return function_(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3), CallbackForward(a4), CallbackForward(a5));
+  }
+
+ private:
+  R (*function_)(A1, A2, A3, A4, A5);
+};
+
+// Method: Arity 5.
+template <typename R, typename T, typename A1, typename A2, typename A3,
+    typename A4, typename A5>
+class RunnableAdapter<R(T::*)(A1, A2, A3, A4, A5)> {
+ public:
+  typedef R (RunType)(T*, A1, A2, A3, A4, A5);
+  typedef true_type IsMethod;
+
+  explicit RunnableAdapter(R(T::*method)(A1, A2, A3, A4, A5))
+      : method_(method) {
+  }
+
+  R Run(T* object, typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3,
+      typename CallbackParamTraits<A4>::ForwardType a4,
+      typename CallbackParamTraits<A5>::ForwardType a5) {
+    return (object->*method_)(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3), CallbackForward(a4), CallbackForward(a5));
+  }
+
+ private:
+  R (T::*method_)(A1, A2, A3, A4, A5);
+};
+
+// Const Method: Arity 5.
+template <typename R, typename T, typename A1, typename A2, typename A3,
+    typename A4, typename A5>
+class RunnableAdapter<R(T::*)(A1, A2, A3, A4, A5) const> {
+ public:
+  typedef R (RunType)(const T*, A1, A2, A3, A4, A5);
+  typedef true_type IsMethod;
+
+  explicit RunnableAdapter(R(T::*method)(A1, A2, A3, A4, A5) const)
+      : method_(method) {
+  }
+
+  R Run(const T* object, typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3,
+      typename CallbackParamTraits<A4>::ForwardType a4,
+      typename CallbackParamTraits<A5>::ForwardType a5) {
+    return (object->*method_)(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3), CallbackForward(a4), CallbackForward(a5));
+  }
+
+ private:
+  R (T::*method_)(A1, A2, A3, A4, A5) const;
+};
+
+// Function: Arity 6.
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6>
+class RunnableAdapter<R(*)(A1, A2, A3, A4, A5, A6)> {
+ public:
+  typedef R (RunType)(A1, A2, A3, A4, A5, A6);
+
+  explicit RunnableAdapter(R(*function)(A1, A2, A3, A4, A5, A6))
+      : function_(function) {
+  }
+
+  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3,
+      typename CallbackParamTraits<A4>::ForwardType a4,
+      typename CallbackParamTraits<A5>::ForwardType a5,
+      typename CallbackParamTraits<A6>::ForwardType a6) {
+    return function_(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3), CallbackForward(a4), CallbackForward(a5),
+        CallbackForward(a6));
+  }
+
+ private:
+  R (*function_)(A1, A2, A3, A4, A5, A6);
+};
+
+// Method: Arity 6.
+template <typename R, typename T, typename A1, typename A2, typename A3,
+    typename A4, typename A5, typename A6>
+class RunnableAdapter<R(T::*)(A1, A2, A3, A4, A5, A6)> {
+ public:
+  typedef R (RunType)(T*, A1, A2, A3, A4, A5, A6);
+  typedef true_type IsMethod;
+
+  explicit RunnableAdapter(R(T::*method)(A1, A2, A3, A4, A5, A6))
+      : method_(method) {
+  }
+
+  R Run(T* object, typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3,
+      typename CallbackParamTraits<A4>::ForwardType a4,
+      typename CallbackParamTraits<A5>::ForwardType a5,
+      typename CallbackParamTraits<A6>::ForwardType a6) {
+    return (object->*method_)(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3), CallbackForward(a4), CallbackForward(a5),
+        CallbackForward(a6));
+  }
+
+ private:
+  R (T::*method_)(A1, A2, A3, A4, A5, A6);
+};
+
+// Const Method: Arity 6.
+template <typename R, typename T, typename A1, typename A2, typename A3,
+    typename A4, typename A5, typename A6>
+class RunnableAdapter<R(T::*)(A1, A2, A3, A4, A5, A6) const> {
+ public:
+  typedef R (RunType)(const T*, A1, A2, A3, A4, A5, A6);
+  typedef true_type IsMethod;
+
+  explicit RunnableAdapter(R(T::*method)(A1, A2, A3, A4, A5, A6) const)
+      : method_(method) {
+  }
+
+  R Run(const T* object, typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3,
+      typename CallbackParamTraits<A4>::ForwardType a4,
+      typename CallbackParamTraits<A5>::ForwardType a5,
+      typename CallbackParamTraits<A6>::ForwardType a6) {
+    return (object->*method_)(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3), CallbackForward(a4), CallbackForward(a5),
+        CallbackForward(a6));
+  }
+
+ private:
+  R (T::*method_)(A1, A2, A3, A4, A5, A6) const;
+};
+
+// Function: Arity 7.
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6, typename A7>
+class RunnableAdapter<R(*)(A1, A2, A3, A4, A5, A6, A7)> {
+ public:
+  typedef R (RunType)(A1, A2, A3, A4, A5, A6, A7);
+
+  explicit RunnableAdapter(R(*function)(A1, A2, A3, A4, A5, A6, A7))
+      : function_(function) {
+  }
+
+  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3,
+      typename CallbackParamTraits<A4>::ForwardType a4,
+      typename CallbackParamTraits<A5>::ForwardType a5,
+      typename CallbackParamTraits<A6>::ForwardType a6,
+      typename CallbackParamTraits<A7>::ForwardType a7) {
+    return function_(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3), CallbackForward(a4), CallbackForward(a5),
+        CallbackForward(a6), CallbackForward(a7));
+  }
+
+ private:
+  R (*function_)(A1, A2, A3, A4, A5, A6, A7);
+};
+
+// Method: Arity 7.
+template <typename R, typename T, typename A1, typename A2, typename A3,
+    typename A4, typename A5, typename A6, typename A7>
+class RunnableAdapter<R(T::*)(A1, A2, A3, A4, A5, A6, A7)> {
+ public:
+  typedef R (RunType)(T*, A1, A2, A3, A4, A5, A6, A7);
+  typedef true_type IsMethod;
+
+  explicit RunnableAdapter(R(T::*method)(A1, A2, A3, A4, A5, A6, A7))
+      : method_(method) {
+  }
+
+  R Run(T* object, typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3,
+      typename CallbackParamTraits<A4>::ForwardType a4,
+      typename CallbackParamTraits<A5>::ForwardType a5,
+      typename CallbackParamTraits<A6>::ForwardType a6,
+      typename CallbackParamTraits<A7>::ForwardType a7) {
+    return (object->*method_)(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3), CallbackForward(a4), CallbackForward(a5),
+        CallbackForward(a6), CallbackForward(a7));
+  }
+
+ private:
+  R (T::*method_)(A1, A2, A3, A4, A5, A6, A7);
+};
+
+// Const Method: Arity 7.
+template <typename R, typename T, typename A1, typename A2, typename A3,
+    typename A4, typename A5, typename A6, typename A7>
+class RunnableAdapter<R(T::*)(A1, A2, A3, A4, A5, A6, A7) const> {
+ public:
+  typedef R (RunType)(const T*, A1, A2, A3, A4, A5, A6, A7);
+  typedef true_type IsMethod;
+
+  explicit RunnableAdapter(R(T::*method)(A1, A2, A3, A4, A5, A6, A7) const)
+      : method_(method) {
+  }
+
+  R Run(const T* object, typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3,
+      typename CallbackParamTraits<A4>::ForwardType a4,
+      typename CallbackParamTraits<A5>::ForwardType a5,
+      typename CallbackParamTraits<A6>::ForwardType a6,
+      typename CallbackParamTraits<A7>::ForwardType a7) {
+    return (object->*method_)(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3), CallbackForward(a4), CallbackForward(a5),
+        CallbackForward(a6), CallbackForward(a7));
+  }
+
+ private:
+  R (T::*method_)(A1, A2, A3, A4, A5, A6, A7) const;
+};
+
+
+// FunctionTraits<>
+//
+// Breaks a function signature apart into typedefs for easier introspection.
+template <typename Sig>
+struct FunctionTraits;
+
+template <typename R>
+struct FunctionTraits<R()> {
+  typedef R ReturnType;
+};
+
+template <typename R, typename A1>
+struct FunctionTraits<R(A1)> {
+  typedef R ReturnType;
+  typedef A1 A1Type;
+};
+
+template <typename R, typename A1, typename A2>
+struct FunctionTraits<R(A1, A2)> {
+  typedef R ReturnType;
+  typedef A1 A1Type;
+  typedef A2 A2Type;
+};
+
+template <typename R, typename A1, typename A2, typename A3>
+struct FunctionTraits<R(A1, A2, A3)> {
+  typedef R ReturnType;
+  typedef A1 A1Type;
+  typedef A2 A2Type;
+  typedef A3 A3Type;
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4>
+struct FunctionTraits<R(A1, A2, A3, A4)> {
+  typedef R ReturnType;
+  typedef A1 A1Type;
+  typedef A2 A2Type;
+  typedef A3 A3Type;
+  typedef A4 A4Type;
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5>
+struct FunctionTraits<R(A1, A2, A3, A4, A5)> {
+  typedef R ReturnType;
+  typedef A1 A1Type;
+  typedef A2 A2Type;
+  typedef A3 A3Type;
+  typedef A4 A4Type;
+  typedef A5 A5Type;
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6>
+struct FunctionTraits<R(A1, A2, A3, A4, A5, A6)> {
+  typedef R ReturnType;
+  typedef A1 A1Type;
+  typedef A2 A2Type;
+  typedef A3 A3Type;
+  typedef A4 A4Type;
+  typedef A5 A5Type;
+  typedef A6 A6Type;
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6, typename A7>
+struct FunctionTraits<R(A1, A2, A3, A4, A5, A6, A7)> {
+  typedef R ReturnType;
+  typedef A1 A1Type;
+  typedef A2 A2Type;
+  typedef A3 A3Type;
+  typedef A4 A4Type;
+  typedef A5 A5Type;
+  typedef A6 A6Type;
+  typedef A7 A7Type;
+};
+
+
+// ForceVoidReturn<>
+//
+// Set of templates that support forcing the function return type to void.
+template <typename Sig>
+struct ForceVoidReturn;
+
+template <typename R>
+struct ForceVoidReturn<R()> {
+  typedef void(RunType)();
+};
+
+template <typename R, typename A1>
+struct ForceVoidReturn<R(A1)> {
+  typedef void(RunType)(A1);
+};
+
+template <typename R, typename A1, typename A2>
+struct ForceVoidReturn<R(A1, A2)> {
+  typedef void(RunType)(A1, A2);
+};
+
+template <typename R, typename A1, typename A2, typename A3>
+struct ForceVoidReturn<R(A1, A2, A3)> {
+  typedef void(RunType)(A1, A2, A3);
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4>
+struct ForceVoidReturn<R(A1, A2, A3, A4)> {
+  typedef void(RunType)(A1, A2, A3, A4);
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5>
+struct ForceVoidReturn<R(A1, A2, A3, A4, A5)> {
+  typedef void(RunType)(A1, A2, A3, A4, A5);
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6>
+struct ForceVoidReturn<R(A1, A2, A3, A4, A5, A6)> {
+  typedef void(RunType)(A1, A2, A3, A4, A5, A6);
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6, typename A7>
+struct ForceVoidReturn<R(A1, A2, A3, A4, A5, A6, A7)> {
+  typedef void(RunType)(A1, A2, A3, A4, A5, A6, A7);
+};
+
+
+// FunctorTraits<>
+//
+// See description at top of file.
+template <typename T>
+struct FunctorTraits {
+  typedef RunnableAdapter<T> RunnableType;
+  typedef typename RunnableType::RunType RunType;
+};
+
+template <typename T>
+struct FunctorTraits<IgnoreResultHelper<T> > {
+  typedef typename FunctorTraits<T>::RunnableType RunnableType;
+  typedef typename ForceVoidReturn<
+      typename RunnableType::RunType>::RunType RunType;
+};
+
+template <typename T>
+struct FunctorTraits<Callback<T> > {
+  typedef Callback<T> RunnableType;
+  typedef typename Callback<T>::RunType RunType;
+};
+
+
+// MakeRunnable<>
+//
+// Converts a passed in functor to a RunnableType using type inference.
+
+template <typename T>
+typename FunctorTraits<T>::RunnableType MakeRunnable(const T& t) {
+  return RunnableAdapter<T>(t);
+}
+
+template <typename T>
+typename FunctorTraits<T>::RunnableType
+MakeRunnable(const IgnoreResultHelper<T>& t) {
+  return MakeRunnable(t.functor_);
+}
+
+template <typename T>
+const typename FunctorTraits<Callback<T> >::RunnableType&
+MakeRunnable(const Callback<T>& t) {
+  DCHECK(!t.is_null());
+  return t;
+}
+
+
+// InvokeHelper<>
+//
+// There are 3 logical InvokeHelper<> specializations: normal, void-return,
+// WeakCalls.
+//
+// The normal type just calls the underlying runnable.
+//
+// We need a InvokeHelper to handle void return types in order to support
+// IgnoreResult().  Normally, if the Runnable's RunType had a void return,
+// the template system would just accept "return functor.Run()" ignoring
+// the fact that a void function is being used with return. This piece of
+// sugar breaks though when the Runnable's RunType is not void.  Thus, we
+// need a partial specialization to change the syntax to drop the "return"
+// from the invocation call.
+//
+// WeakCalls similarly need special syntax that is applied to the first
+// argument to check if they should no-op themselves.
+template <bool IsWeakCall, typename ReturnType, typename Runnable,
+          typename ArgsType>
+struct InvokeHelper;
+
+template <typename ReturnType, typename Runnable>
+struct InvokeHelper<false, ReturnType, Runnable,
+    void()>  {
+  static ReturnType MakeItSo(Runnable runnable) {
+    return runnable.Run();
+  }
+};
+
+template <typename Runnable>
+struct InvokeHelper<false, void, Runnable,
+    void()>  {
+  static void MakeItSo(Runnable runnable) {
+    runnable.Run();
+  }
+};
+
+template <typename ReturnType, typename Runnable,typename A1>
+struct InvokeHelper<false, ReturnType, Runnable,
+    void(A1)>  {
+  static ReturnType MakeItSo(Runnable runnable, A1 a1) {
+    return runnable.Run(CallbackForward(a1));
+  }
+};
+
+template <typename Runnable,typename A1>
+struct InvokeHelper<false, void, Runnable,
+    void(A1)>  {
+  static void MakeItSo(Runnable runnable, A1 a1) {
+    runnable.Run(CallbackForward(a1));
+  }
+};
+
+template <typename Runnable, typename BoundWeakPtr>
+struct InvokeHelper<true, void, Runnable,
+    void(BoundWeakPtr)>  {
+  static void MakeItSo(Runnable runnable, BoundWeakPtr weak_ptr) {
+    if (!weak_ptr.get()) {
+      return;
+    }
+    runnable.Run(weak_ptr.get());
+  }
+};
+
+template <typename ReturnType, typename Runnable,typename A1, typename A2>
+struct InvokeHelper<false, ReturnType, Runnable,
+    void(A1, A2)>  {
+  static ReturnType MakeItSo(Runnable runnable, A1 a1, A2 a2) {
+    return runnable.Run(CallbackForward(a1), CallbackForward(a2));
+  }
+};
+
+template <typename Runnable,typename A1, typename A2>
+struct InvokeHelper<false, void, Runnable,
+    void(A1, A2)>  {
+  static void MakeItSo(Runnable runnable, A1 a1, A2 a2) {
+    runnable.Run(CallbackForward(a1), CallbackForward(a2));
+  }
+};
+
+template <typename Runnable, typename BoundWeakPtr, typename A2>
+struct InvokeHelper<true, void, Runnable,
+    void(BoundWeakPtr, A2)>  {
+  static void MakeItSo(Runnable runnable, BoundWeakPtr weak_ptr, A2 a2) {
+    if (!weak_ptr.get()) {
+      return;
+    }
+    runnable.Run(weak_ptr.get(), CallbackForward(a2));
+  }
+};
+
+template <typename ReturnType, typename Runnable,typename A1, typename A2,
+    typename A3>
+struct InvokeHelper<false, ReturnType, Runnable,
+    void(A1, A2, A3)>  {
+  static ReturnType MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3) {
+    return runnable.Run(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3));
+  }
+};
+
+template <typename Runnable,typename A1, typename A2, typename A3>
+struct InvokeHelper<false, void, Runnable,
+    void(A1, A2, A3)>  {
+  static void MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3) {
+    runnable.Run(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3));
+  }
+};
+
+template <typename Runnable, typename BoundWeakPtr, typename A2, typename A3>
+struct InvokeHelper<true, void, Runnable,
+    void(BoundWeakPtr, A2, A3)>  {
+  static void MakeItSo(Runnable runnable, BoundWeakPtr weak_ptr, A2 a2, A3 a3) {
+    if (!weak_ptr.get()) {
+      return;
+    }
+    runnable.Run(weak_ptr.get(), CallbackForward(a2), CallbackForward(a3));
+  }
+};
+
+template <typename ReturnType, typename Runnable,typename A1, typename A2,
+    typename A3, typename A4>
+struct InvokeHelper<false, ReturnType, Runnable,
+    void(A1, A2, A3, A4)>  {
+  static ReturnType MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4) {
+    return runnable.Run(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3), CallbackForward(a4));
+  }
+};
+
+template <typename Runnable,typename A1, typename A2, typename A3, typename A4>
+struct InvokeHelper<false, void, Runnable,
+    void(A1, A2, A3, A4)>  {
+  static void MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4) {
+    runnable.Run(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3),
+        CallbackForward(a4));
+  }
+};
+
+template <typename Runnable, typename BoundWeakPtr, typename A2, typename A3,
+    typename A4>
+struct InvokeHelper<true, void, Runnable,
+    void(BoundWeakPtr, A2, A3, A4)>  {
+  static void MakeItSo(Runnable runnable, BoundWeakPtr weak_ptr, A2 a2, A3 a3,
+      A4 a4) {
+    if (!weak_ptr.get()) {
+      return;
+    }
+    runnable.Run(weak_ptr.get(), CallbackForward(a2), CallbackForward(a3),
+        CallbackForward(a4));
+  }
+};
+
+template <typename ReturnType, typename Runnable,typename A1, typename A2,
+    typename A3, typename A4, typename A5>
+struct InvokeHelper<false, ReturnType, Runnable,
+    void(A1, A2, A3, A4, A5)>  {
+  static ReturnType MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4,
+      A5 a5) {
+    return runnable.Run(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3), CallbackForward(a4), CallbackForward(a5));
+  }
+};
+
+template <typename Runnable,typename A1, typename A2, typename A3, typename A4,
+    typename A5>
+struct InvokeHelper<false, void, Runnable,
+    void(A1, A2, A3, A4, A5)>  {
+  static void MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
+    runnable.Run(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3),
+        CallbackForward(a4), CallbackForward(a5));
+  }
+};
+
+template <typename Runnable, typename BoundWeakPtr, typename A2, typename A3,
+    typename A4, typename A5>
+struct InvokeHelper<true, void, Runnable,
+    void(BoundWeakPtr, A2, A3, A4, A5)>  {
+  static void MakeItSo(Runnable runnable, BoundWeakPtr weak_ptr, A2 a2, A3 a3,
+      A4 a4, A5 a5) {
+    if (!weak_ptr.get()) {
+      return;
+    }
+    runnable.Run(weak_ptr.get(), CallbackForward(a2), CallbackForward(a3),
+        CallbackForward(a4), CallbackForward(a5));
+  }
+};
+
+template <typename ReturnType, typename Runnable,typename A1, typename A2,
+    typename A3, typename A4, typename A5, typename A6>
+struct InvokeHelper<false, ReturnType, Runnable,
+    void(A1, A2, A3, A4, A5, A6)>  {
+  static ReturnType MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4,
+      A5 a5, A6 a6) {
+    return runnable.Run(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3), CallbackForward(a4), CallbackForward(a5),
+        CallbackForward(a6));
+  }
+};
+
+template <typename Runnable,typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6>
+struct InvokeHelper<false, void, Runnable,
+    void(A1, A2, A3, A4, A5, A6)>  {
+  static void MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5,
+      A6 a6) {
+    runnable.Run(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3),
+        CallbackForward(a4), CallbackForward(a5), CallbackForward(a6));
+  }
+};
+
+template <typename Runnable, typename BoundWeakPtr, typename A2, typename A3,
+    typename A4, typename A5, typename A6>
+struct InvokeHelper<true, void, Runnable,
+    void(BoundWeakPtr, A2, A3, A4, A5, A6)>  {
+  static void MakeItSo(Runnable runnable, BoundWeakPtr weak_ptr, A2 a2, A3 a3,
+      A4 a4, A5 a5, A6 a6) {
+    if (!weak_ptr.get()) {
+      return;
+    }
+    runnable.Run(weak_ptr.get(), CallbackForward(a2), CallbackForward(a3),
+        CallbackForward(a4), CallbackForward(a5), CallbackForward(a6));
+  }
+};
+
+template <typename ReturnType, typename Runnable,typename A1, typename A2,
+    typename A3, typename A4, typename A5, typename A6, typename A7>
+struct InvokeHelper<false, ReturnType, Runnable,
+    void(A1, A2, A3, A4, A5, A6, A7)>  {
+  static ReturnType MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4,
+      A5 a5, A6 a6, A7 a7) {
+    return runnable.Run(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3), CallbackForward(a4), CallbackForward(a5),
+        CallbackForward(a6), CallbackForward(a7));
+  }
+};
+
+template <typename Runnable,typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6, typename A7>
+struct InvokeHelper<false, void, Runnable,
+    void(A1, A2, A3, A4, A5, A6, A7)>  {
+  static void MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5,
+      A6 a6, A7 a7) {
+    runnable.Run(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3),
+        CallbackForward(a4), CallbackForward(a5), CallbackForward(a6),
+        CallbackForward(a7));
+  }
+};
+
+template <typename Runnable, typename BoundWeakPtr, typename A2, typename A3,
+    typename A4, typename A5, typename A6, typename A7>
+struct InvokeHelper<true, void, Runnable,
+    void(BoundWeakPtr, A2, A3, A4, A5, A6, A7)>  {
+  static void MakeItSo(Runnable runnable, BoundWeakPtr weak_ptr, A2 a2, A3 a3,
+      A4 a4, A5 a5, A6 a6, A7 a7) {
+    if (!weak_ptr.get()) {
+      return;
+    }
+    runnable.Run(weak_ptr.get(), CallbackForward(a2), CallbackForward(a3),
+        CallbackForward(a4), CallbackForward(a5), CallbackForward(a6),
+        CallbackForward(a7));
+  }
+};
+
+#if !defined(_MSC_VER)
+
+template <typename ReturnType, typename Runnable, typename ArgsType>
+struct InvokeHelper<true, ReturnType, Runnable, ArgsType> {
+  // WeakCalls are only supported for functions with a void return type.
+  // Otherwise, the function result would be undefined if the the WeakPtr<>
+  // is invalidated.
+  COMPILE_ASSERT(is_void<ReturnType>::value,
+                 weak_ptrs_can_only_bind_to_methods_without_return_values);
+};
+
+#endif
+
+// Invoker<>
+//
+// See description at the top of the file.
+template <int NumBound, typename Storage, typename RunType>
+struct Invoker;
+
+// Arity 0 -> 0.
+template <typename StorageType, typename R>
+struct Invoker<0, StorageType, R()> {
+  typedef R(RunType)(BindStateBase*);
+
+  typedef R(UnboundRunType)();
+
+  static R Run(BindStateBase* base) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void()>
+               ::MakeItSo(storage->runnable_);
+  }
+};
+
+// Arity 1 -> 1.
+template <typename StorageType, typename R,typename X1>
+struct Invoker<0, StorageType, R(X1)> {
+  typedef R(RunType)(BindStateBase*,
+      typename CallbackParamTraits<X1>::ForwardType);
+
+  typedef R(UnboundRunType)(X1);
+
+  static R Run(BindStateBase* base,
+      typename CallbackParamTraits<X1>::ForwardType x1) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename CallbackParamTraits<X1>::ForwardType x1)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1));
+  }
+};
+
+// Arity 1 -> 0.
+template <typename StorageType, typename R,typename X1>
+struct Invoker<1, StorageType, R(X1)> {
+  typedef R(RunType)(BindStateBase*);
+
+  typedef R(UnboundRunType)();
+
+  static R Run(BindStateBase* base) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
+
+    typename Bound1UnwrapTraits::ForwardType x1 =
+        Bound1UnwrapTraits::Unwrap(storage->p1_);
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename Bound1UnwrapTraits::ForwardType)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1));
+  }
+};
+
+// Arity 2 -> 2.
+template <typename StorageType, typename R,typename X1, typename X2>
+struct Invoker<0, StorageType, R(X1, X2)> {
+  typedef R(RunType)(BindStateBase*,
+      typename CallbackParamTraits<X1>::ForwardType,
+      typename CallbackParamTraits<X2>::ForwardType);
+
+  typedef R(UnboundRunType)(X1, X2);
+
+  static R Run(BindStateBase* base,
+      typename CallbackParamTraits<X1>::ForwardType x1,
+      typename CallbackParamTraits<X2>::ForwardType x2) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename CallbackParamTraits<X1>::ForwardType x1,
+               typename CallbackParamTraits<X2>::ForwardType x2)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2));
+  }
+};
+
+// Arity 2 -> 1.
+template <typename StorageType, typename R,typename X1, typename X2>
+struct Invoker<1, StorageType, R(X1, X2)> {
+  typedef R(RunType)(BindStateBase*,
+      typename CallbackParamTraits<X2>::ForwardType);
+
+  typedef R(UnboundRunType)(X2);
+
+  static R Run(BindStateBase* base,
+      typename CallbackParamTraits<X2>::ForwardType x2) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
+
+    typename Bound1UnwrapTraits::ForwardType x1 =
+        Bound1UnwrapTraits::Unwrap(storage->p1_);
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename Bound1UnwrapTraits::ForwardType,
+               typename CallbackParamTraits<X2>::ForwardType x2)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2));
+  }
+};
+
+// Arity 2 -> 0.
+template <typename StorageType, typename R,typename X1, typename X2>
+struct Invoker<2, StorageType, R(X1, X2)> {
+  typedef R(RunType)(BindStateBase*);
+
+  typedef R(UnboundRunType)();
+
+  static R Run(BindStateBase* base) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
+    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
+
+    typename Bound1UnwrapTraits::ForwardType x1 =
+        Bound1UnwrapTraits::Unwrap(storage->p1_);
+    typename Bound2UnwrapTraits::ForwardType x2 =
+        Bound2UnwrapTraits::Unwrap(storage->p2_);
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename Bound1UnwrapTraits::ForwardType,
+               typename Bound2UnwrapTraits::ForwardType)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2));
+  }
+};
+
+// Arity 3 -> 3.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3>
+struct Invoker<0, StorageType, R(X1, X2, X3)> {
+  typedef R(RunType)(BindStateBase*,
+      typename CallbackParamTraits<X1>::ForwardType,
+      typename CallbackParamTraits<X2>::ForwardType,
+      typename CallbackParamTraits<X3>::ForwardType);
+
+  typedef R(UnboundRunType)(X1, X2, X3);
+
+  static R Run(BindStateBase* base,
+      typename CallbackParamTraits<X1>::ForwardType x1,
+      typename CallbackParamTraits<X2>::ForwardType x2,
+      typename CallbackParamTraits<X3>::ForwardType x3) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename CallbackParamTraits<X1>::ForwardType x1,
+               typename CallbackParamTraits<X2>::ForwardType x2,
+               typename CallbackParamTraits<X3>::ForwardType x3)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3));
+  }
+};
+
+// Arity 3 -> 2.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3>
+struct Invoker<1, StorageType, R(X1, X2, X3)> {
+  typedef R(RunType)(BindStateBase*,
+      typename CallbackParamTraits<X2>::ForwardType,
+      typename CallbackParamTraits<X3>::ForwardType);
+
+  typedef R(UnboundRunType)(X2, X3);
+
+  static R Run(BindStateBase* base,
+      typename CallbackParamTraits<X2>::ForwardType x2,
+      typename CallbackParamTraits<X3>::ForwardType x3) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
+
+    typename Bound1UnwrapTraits::ForwardType x1 =
+        Bound1UnwrapTraits::Unwrap(storage->p1_);
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename Bound1UnwrapTraits::ForwardType,
+               typename CallbackParamTraits<X2>::ForwardType x2,
+               typename CallbackParamTraits<X3>::ForwardType x3)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3));
+  }
+};
+
+// Arity 3 -> 1.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3>
+struct Invoker<2, StorageType, R(X1, X2, X3)> {
+  typedef R(RunType)(BindStateBase*,
+      typename CallbackParamTraits<X3>::ForwardType);
+
+  typedef R(UnboundRunType)(X3);
+
+  static R Run(BindStateBase* base,
+      typename CallbackParamTraits<X3>::ForwardType x3) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
+    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
+
+    typename Bound1UnwrapTraits::ForwardType x1 =
+        Bound1UnwrapTraits::Unwrap(storage->p1_);
+    typename Bound2UnwrapTraits::ForwardType x2 =
+        Bound2UnwrapTraits::Unwrap(storage->p2_);
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename Bound1UnwrapTraits::ForwardType,
+               typename Bound2UnwrapTraits::ForwardType,
+               typename CallbackParamTraits<X3>::ForwardType x3)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3));
+  }
+};
+
+// Arity 3 -> 0.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3>
+struct Invoker<3, StorageType, R(X1, X2, X3)> {
+  typedef R(RunType)(BindStateBase*);
+
+  typedef R(UnboundRunType)();
+
+  static R Run(BindStateBase* base) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
+    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
+    typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
+
+    typename Bound1UnwrapTraits::ForwardType x1 =
+        Bound1UnwrapTraits::Unwrap(storage->p1_);
+    typename Bound2UnwrapTraits::ForwardType x2 =
+        Bound2UnwrapTraits::Unwrap(storage->p2_);
+    typename Bound3UnwrapTraits::ForwardType x3 =
+        Bound3UnwrapTraits::Unwrap(storage->p3_);
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename Bound1UnwrapTraits::ForwardType,
+               typename Bound2UnwrapTraits::ForwardType,
+               typename Bound3UnwrapTraits::ForwardType)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3));
+  }
+};
+
+// Arity 4 -> 4.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3, typename X4>
+struct Invoker<0, StorageType, R(X1, X2, X3, X4)> {
+  typedef R(RunType)(BindStateBase*,
+      typename CallbackParamTraits<X1>::ForwardType,
+      typename CallbackParamTraits<X2>::ForwardType,
+      typename CallbackParamTraits<X3>::ForwardType,
+      typename CallbackParamTraits<X4>::ForwardType);
+
+  typedef R(UnboundRunType)(X1, X2, X3, X4);
+
+  static R Run(BindStateBase* base,
+      typename CallbackParamTraits<X1>::ForwardType x1,
+      typename CallbackParamTraits<X2>::ForwardType x2,
+      typename CallbackParamTraits<X3>::ForwardType x3,
+      typename CallbackParamTraits<X4>::ForwardType x4) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename CallbackParamTraits<X1>::ForwardType x1,
+               typename CallbackParamTraits<X2>::ForwardType x2,
+               typename CallbackParamTraits<X3>::ForwardType x3,
+               typename CallbackParamTraits<X4>::ForwardType x4)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4));
+  }
+};
+
+// Arity 4 -> 3.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3, typename X4>
+struct Invoker<1, StorageType, R(X1, X2, X3, X4)> {
+  typedef R(RunType)(BindStateBase*,
+      typename CallbackParamTraits<X2>::ForwardType,
+      typename CallbackParamTraits<X3>::ForwardType,
+      typename CallbackParamTraits<X4>::ForwardType);
+
+  typedef R(UnboundRunType)(X2, X3, X4);
+
+  static R Run(BindStateBase* base,
+      typename CallbackParamTraits<X2>::ForwardType x2,
+      typename CallbackParamTraits<X3>::ForwardType x3,
+      typename CallbackParamTraits<X4>::ForwardType x4) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
+
+    typename Bound1UnwrapTraits::ForwardType x1 =
+        Bound1UnwrapTraits::Unwrap(storage->p1_);
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename Bound1UnwrapTraits::ForwardType,
+               typename CallbackParamTraits<X2>::ForwardType x2,
+               typename CallbackParamTraits<X3>::ForwardType x3,
+               typename CallbackParamTraits<X4>::ForwardType x4)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4));
+  }
+};
+
+// Arity 4 -> 2.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3, typename X4>
+struct Invoker<2, StorageType, R(X1, X2, X3, X4)> {
+  typedef R(RunType)(BindStateBase*,
+      typename CallbackParamTraits<X3>::ForwardType,
+      typename CallbackParamTraits<X4>::ForwardType);
+
+  typedef R(UnboundRunType)(X3, X4);
+
+  static R Run(BindStateBase* base,
+      typename CallbackParamTraits<X3>::ForwardType x3,
+      typename CallbackParamTraits<X4>::ForwardType x4) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
+    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
+
+    typename Bound1UnwrapTraits::ForwardType x1 =
+        Bound1UnwrapTraits::Unwrap(storage->p1_);
+    typename Bound2UnwrapTraits::ForwardType x2 =
+        Bound2UnwrapTraits::Unwrap(storage->p2_);
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename Bound1UnwrapTraits::ForwardType,
+               typename Bound2UnwrapTraits::ForwardType,
+               typename CallbackParamTraits<X3>::ForwardType x3,
+               typename CallbackParamTraits<X4>::ForwardType x4)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4));
+  }
+};
+
+// Arity 4 -> 1.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3, typename X4>
+struct Invoker<3, StorageType, R(X1, X2, X3, X4)> {
+  typedef R(RunType)(BindStateBase*,
+      typename CallbackParamTraits<X4>::ForwardType);
+
+  typedef R(UnboundRunType)(X4);
+
+  static R Run(BindStateBase* base,
+      typename CallbackParamTraits<X4>::ForwardType x4) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
+    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
+    typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
+
+    typename Bound1UnwrapTraits::ForwardType x1 =
+        Bound1UnwrapTraits::Unwrap(storage->p1_);
+    typename Bound2UnwrapTraits::ForwardType x2 =
+        Bound2UnwrapTraits::Unwrap(storage->p2_);
+    typename Bound3UnwrapTraits::ForwardType x3 =
+        Bound3UnwrapTraits::Unwrap(storage->p3_);
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename Bound1UnwrapTraits::ForwardType,
+               typename Bound2UnwrapTraits::ForwardType,
+               typename Bound3UnwrapTraits::ForwardType,
+               typename CallbackParamTraits<X4>::ForwardType x4)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4));
+  }
+};
+
+// Arity 4 -> 0.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3, typename X4>
+struct Invoker<4, StorageType, R(X1, X2, X3, X4)> {
+  typedef R(RunType)(BindStateBase*);
+
+  typedef R(UnboundRunType)();
+
+  static R Run(BindStateBase* base) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
+    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
+    typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
+    typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits;
+
+    typename Bound1UnwrapTraits::ForwardType x1 =
+        Bound1UnwrapTraits::Unwrap(storage->p1_);
+    typename Bound2UnwrapTraits::ForwardType x2 =
+        Bound2UnwrapTraits::Unwrap(storage->p2_);
+    typename Bound3UnwrapTraits::ForwardType x3 =
+        Bound3UnwrapTraits::Unwrap(storage->p3_);
+    typename Bound4UnwrapTraits::ForwardType x4 =
+        Bound4UnwrapTraits::Unwrap(storage->p4_);
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename Bound1UnwrapTraits::ForwardType,
+               typename Bound2UnwrapTraits::ForwardType,
+               typename Bound3UnwrapTraits::ForwardType,
+               typename Bound4UnwrapTraits::ForwardType)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4));
+  }
+};
+
+// Arity 5 -> 5.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3, typename X4, typename X5>
+struct Invoker<0, StorageType, R(X1, X2, X3, X4, X5)> {
+  typedef R(RunType)(BindStateBase*,
+      typename CallbackParamTraits<X1>::ForwardType,
+      typename CallbackParamTraits<X2>::ForwardType,
+      typename CallbackParamTraits<X3>::ForwardType,
+      typename CallbackParamTraits<X4>::ForwardType,
+      typename CallbackParamTraits<X5>::ForwardType);
+
+  typedef R(UnboundRunType)(X1, X2, X3, X4, X5);
+
+  static R Run(BindStateBase* base,
+      typename CallbackParamTraits<X1>::ForwardType x1,
+      typename CallbackParamTraits<X2>::ForwardType x2,
+      typename CallbackParamTraits<X3>::ForwardType x3,
+      typename CallbackParamTraits<X4>::ForwardType x4,
+      typename CallbackParamTraits<X5>::ForwardType x5) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename CallbackParamTraits<X1>::ForwardType x1,
+               typename CallbackParamTraits<X2>::ForwardType x2,
+               typename CallbackParamTraits<X3>::ForwardType x3,
+               typename CallbackParamTraits<X4>::ForwardType x4,
+               typename CallbackParamTraits<X5>::ForwardType x5)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5));
+  }
+};
+
+// Arity 5 -> 4.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3, typename X4, typename X5>
+struct Invoker<1, StorageType, R(X1, X2, X3, X4, X5)> {
+  typedef R(RunType)(BindStateBase*,
+      typename CallbackParamTraits<X2>::ForwardType,
+      typename CallbackParamTraits<X3>::ForwardType,
+      typename CallbackParamTraits<X4>::ForwardType,
+      typename CallbackParamTraits<X5>::ForwardType);
+
+  typedef R(UnboundRunType)(X2, X3, X4, X5);
+
+  static R Run(BindStateBase* base,
+      typename CallbackParamTraits<X2>::ForwardType x2,
+      typename CallbackParamTraits<X3>::ForwardType x3,
+      typename CallbackParamTraits<X4>::ForwardType x4,
+      typename CallbackParamTraits<X5>::ForwardType x5) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
+
+    typename Bound1UnwrapTraits::ForwardType x1 =
+        Bound1UnwrapTraits::Unwrap(storage->p1_);
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename Bound1UnwrapTraits::ForwardType,
+               typename CallbackParamTraits<X2>::ForwardType x2,
+               typename CallbackParamTraits<X3>::ForwardType x3,
+               typename CallbackParamTraits<X4>::ForwardType x4,
+               typename CallbackParamTraits<X5>::ForwardType x5)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5));
+  }
+};
+
+// Arity 5 -> 3.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3, typename X4, typename X5>
+struct Invoker<2, StorageType, R(X1, X2, X3, X4, X5)> {
+  typedef R(RunType)(BindStateBase*,
+      typename CallbackParamTraits<X3>::ForwardType,
+      typename CallbackParamTraits<X4>::ForwardType,
+      typename CallbackParamTraits<X5>::ForwardType);
+
+  typedef R(UnboundRunType)(X3, X4, X5);
+
+  static R Run(BindStateBase* base,
+      typename CallbackParamTraits<X3>::ForwardType x3,
+      typename CallbackParamTraits<X4>::ForwardType x4,
+      typename CallbackParamTraits<X5>::ForwardType x5) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
+    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
+
+    typename Bound1UnwrapTraits::ForwardType x1 =
+        Bound1UnwrapTraits::Unwrap(storage->p1_);
+    typename Bound2UnwrapTraits::ForwardType x2 =
+        Bound2UnwrapTraits::Unwrap(storage->p2_);
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename Bound1UnwrapTraits::ForwardType,
+               typename Bound2UnwrapTraits::ForwardType,
+               typename CallbackParamTraits<X3>::ForwardType x3,
+               typename CallbackParamTraits<X4>::ForwardType x4,
+               typename CallbackParamTraits<X5>::ForwardType x5)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5));
+  }
+};
+
+// Arity 5 -> 2.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3, typename X4, typename X5>
+struct Invoker<3, StorageType, R(X1, X2, X3, X4, X5)> {
+  typedef R(RunType)(BindStateBase*,
+      typename CallbackParamTraits<X4>::ForwardType,
+      typename CallbackParamTraits<X5>::ForwardType);
+
+  typedef R(UnboundRunType)(X4, X5);
+
+  static R Run(BindStateBase* base,
+      typename CallbackParamTraits<X4>::ForwardType x4,
+      typename CallbackParamTraits<X5>::ForwardType x5) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
+    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
+    typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
+
+    typename Bound1UnwrapTraits::ForwardType x1 =
+        Bound1UnwrapTraits::Unwrap(storage->p1_);
+    typename Bound2UnwrapTraits::ForwardType x2 =
+        Bound2UnwrapTraits::Unwrap(storage->p2_);
+    typename Bound3UnwrapTraits::ForwardType x3 =
+        Bound3UnwrapTraits::Unwrap(storage->p3_);
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename Bound1UnwrapTraits::ForwardType,
+               typename Bound2UnwrapTraits::ForwardType,
+               typename Bound3UnwrapTraits::ForwardType,
+               typename CallbackParamTraits<X4>::ForwardType x4,
+               typename CallbackParamTraits<X5>::ForwardType x5)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5));
+  }
+};
+
+// Arity 5 -> 1.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3, typename X4, typename X5>
+struct Invoker<4, StorageType, R(X1, X2, X3, X4, X5)> {
+  typedef R(RunType)(BindStateBase*,
+      typename CallbackParamTraits<X5>::ForwardType);
+
+  typedef R(UnboundRunType)(X5);
+
+  static R Run(BindStateBase* base,
+      typename CallbackParamTraits<X5>::ForwardType x5) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
+    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
+    typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
+    typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits;
+
+    typename Bound1UnwrapTraits::ForwardType x1 =
+        Bound1UnwrapTraits::Unwrap(storage->p1_);
+    typename Bound2UnwrapTraits::ForwardType x2 =
+        Bound2UnwrapTraits::Unwrap(storage->p2_);
+    typename Bound3UnwrapTraits::ForwardType x3 =
+        Bound3UnwrapTraits::Unwrap(storage->p3_);
+    typename Bound4UnwrapTraits::ForwardType x4 =
+        Bound4UnwrapTraits::Unwrap(storage->p4_);
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename Bound1UnwrapTraits::ForwardType,
+               typename Bound2UnwrapTraits::ForwardType,
+               typename Bound3UnwrapTraits::ForwardType,
+               typename Bound4UnwrapTraits::ForwardType,
+               typename CallbackParamTraits<X5>::ForwardType x5)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5));
+  }
+};
+
+// Arity 5 -> 0.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3, typename X4, typename X5>
+struct Invoker<5, StorageType, R(X1, X2, X3, X4, X5)> {
+  typedef R(RunType)(BindStateBase*);
+
+  typedef R(UnboundRunType)();
+
+  static R Run(BindStateBase* base) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
+    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
+    typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
+    typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits;
+    typedef typename StorageType::Bound5UnwrapTraits Bound5UnwrapTraits;
+
+    typename Bound1UnwrapTraits::ForwardType x1 =
+        Bound1UnwrapTraits::Unwrap(storage->p1_);
+    typename Bound2UnwrapTraits::ForwardType x2 =
+        Bound2UnwrapTraits::Unwrap(storage->p2_);
+    typename Bound3UnwrapTraits::ForwardType x3 =
+        Bound3UnwrapTraits::Unwrap(storage->p3_);
+    typename Bound4UnwrapTraits::ForwardType x4 =
+        Bound4UnwrapTraits::Unwrap(storage->p4_);
+    typename Bound5UnwrapTraits::ForwardType x5 =
+        Bound5UnwrapTraits::Unwrap(storage->p5_);
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename Bound1UnwrapTraits::ForwardType,
+               typename Bound2UnwrapTraits::ForwardType,
+               typename Bound3UnwrapTraits::ForwardType,
+               typename Bound4UnwrapTraits::ForwardType,
+               typename Bound5UnwrapTraits::ForwardType)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5));
+  }
+};
+
+// Arity 6 -> 6.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3, typename X4, typename X5, typename X6>
+struct Invoker<0, StorageType, R(X1, X2, X3, X4, X5, X6)> {
+  typedef R(RunType)(BindStateBase*,
+      typename CallbackParamTraits<X1>::ForwardType,
+      typename CallbackParamTraits<X2>::ForwardType,
+      typename CallbackParamTraits<X3>::ForwardType,
+      typename CallbackParamTraits<X4>::ForwardType,
+      typename CallbackParamTraits<X5>::ForwardType,
+      typename CallbackParamTraits<X6>::ForwardType);
+
+  typedef R(UnboundRunType)(X1, X2, X3, X4, X5, X6);
+
+  static R Run(BindStateBase* base,
+      typename CallbackParamTraits<X1>::ForwardType x1,
+      typename CallbackParamTraits<X2>::ForwardType x2,
+      typename CallbackParamTraits<X3>::ForwardType x3,
+      typename CallbackParamTraits<X4>::ForwardType x4,
+      typename CallbackParamTraits<X5>::ForwardType x5,
+      typename CallbackParamTraits<X6>::ForwardType x6) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename CallbackParamTraits<X1>::ForwardType x1,
+               typename CallbackParamTraits<X2>::ForwardType x2,
+               typename CallbackParamTraits<X3>::ForwardType x3,
+               typename CallbackParamTraits<X4>::ForwardType x4,
+               typename CallbackParamTraits<X5>::ForwardType x5,
+               typename CallbackParamTraits<X6>::ForwardType x6)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5),
+                   CallbackForward(x6));
+  }
+};
+
+// Arity 6 -> 5.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3, typename X4, typename X5, typename X6>
+struct Invoker<1, StorageType, R(X1, X2, X3, X4, X5, X6)> {
+  typedef R(RunType)(BindStateBase*,
+      typename CallbackParamTraits<X2>::ForwardType,
+      typename CallbackParamTraits<X3>::ForwardType,
+      typename CallbackParamTraits<X4>::ForwardType,
+      typename CallbackParamTraits<X5>::ForwardType,
+      typename CallbackParamTraits<X6>::ForwardType);
+
+  typedef R(UnboundRunType)(X2, X3, X4, X5, X6);
+
+  static R Run(BindStateBase* base,
+      typename CallbackParamTraits<X2>::ForwardType x2,
+      typename CallbackParamTraits<X3>::ForwardType x3,
+      typename CallbackParamTraits<X4>::ForwardType x4,
+      typename CallbackParamTraits<X5>::ForwardType x5,
+      typename CallbackParamTraits<X6>::ForwardType x6) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
+
+    typename Bound1UnwrapTraits::ForwardType x1 =
+        Bound1UnwrapTraits::Unwrap(storage->p1_);
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename Bound1UnwrapTraits::ForwardType,
+               typename CallbackParamTraits<X2>::ForwardType x2,
+               typename CallbackParamTraits<X3>::ForwardType x3,
+               typename CallbackParamTraits<X4>::ForwardType x4,
+               typename CallbackParamTraits<X5>::ForwardType x5,
+               typename CallbackParamTraits<X6>::ForwardType x6)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5),
+                   CallbackForward(x6));
+  }
+};
+
+// Arity 6 -> 4.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3, typename X4, typename X5, typename X6>
+struct Invoker<2, StorageType, R(X1, X2, X3, X4, X5, X6)> {
+  typedef R(RunType)(BindStateBase*,
+      typename CallbackParamTraits<X3>::ForwardType,
+      typename CallbackParamTraits<X4>::ForwardType,
+      typename CallbackParamTraits<X5>::ForwardType,
+      typename CallbackParamTraits<X6>::ForwardType);
+
+  typedef R(UnboundRunType)(X3, X4, X5, X6);
+
+  static R Run(BindStateBase* base,
+      typename CallbackParamTraits<X3>::ForwardType x3,
+      typename CallbackParamTraits<X4>::ForwardType x4,
+      typename CallbackParamTraits<X5>::ForwardType x5,
+      typename CallbackParamTraits<X6>::ForwardType x6) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
+    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
+
+    typename Bound1UnwrapTraits::ForwardType x1 =
+        Bound1UnwrapTraits::Unwrap(storage->p1_);
+    typename Bound2UnwrapTraits::ForwardType x2 =
+        Bound2UnwrapTraits::Unwrap(storage->p2_);
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename Bound1UnwrapTraits::ForwardType,
+               typename Bound2UnwrapTraits::ForwardType,
+               typename CallbackParamTraits<X3>::ForwardType x3,
+               typename CallbackParamTraits<X4>::ForwardType x4,
+               typename CallbackParamTraits<X5>::ForwardType x5,
+               typename CallbackParamTraits<X6>::ForwardType x6)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5),
+                   CallbackForward(x6));
+  }
+};
+
+// Arity 6 -> 3.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3, typename X4, typename X5, typename X6>
+struct Invoker<3, StorageType, R(X1, X2, X3, X4, X5, X6)> {
+  typedef R(RunType)(BindStateBase*,
+      typename CallbackParamTraits<X4>::ForwardType,
+      typename CallbackParamTraits<X5>::ForwardType,
+      typename CallbackParamTraits<X6>::ForwardType);
+
+  typedef R(UnboundRunType)(X4, X5, X6);
+
+  static R Run(BindStateBase* base,
+      typename CallbackParamTraits<X4>::ForwardType x4,
+      typename CallbackParamTraits<X5>::ForwardType x5,
+      typename CallbackParamTraits<X6>::ForwardType x6) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
+    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
+    typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
+
+    typename Bound1UnwrapTraits::ForwardType x1 =
+        Bound1UnwrapTraits::Unwrap(storage->p1_);
+    typename Bound2UnwrapTraits::ForwardType x2 =
+        Bound2UnwrapTraits::Unwrap(storage->p2_);
+    typename Bound3UnwrapTraits::ForwardType x3 =
+        Bound3UnwrapTraits::Unwrap(storage->p3_);
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename Bound1UnwrapTraits::ForwardType,
+               typename Bound2UnwrapTraits::ForwardType,
+               typename Bound3UnwrapTraits::ForwardType,
+               typename CallbackParamTraits<X4>::ForwardType x4,
+               typename CallbackParamTraits<X5>::ForwardType x5,
+               typename CallbackParamTraits<X6>::ForwardType x6)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5),
+                   CallbackForward(x6));
+  }
+};
+
+// Arity 6 -> 2.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3, typename X4, typename X5, typename X6>
+struct Invoker<4, StorageType, R(X1, X2, X3, X4, X5, X6)> {
+  typedef R(RunType)(BindStateBase*,
+      typename CallbackParamTraits<X5>::ForwardType,
+      typename CallbackParamTraits<X6>::ForwardType);
+
+  typedef R(UnboundRunType)(X5, X6);
+
+  static R Run(BindStateBase* base,
+      typename CallbackParamTraits<X5>::ForwardType x5,
+      typename CallbackParamTraits<X6>::ForwardType x6) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
+    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
+    typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
+    typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits;
+
+    typename Bound1UnwrapTraits::ForwardType x1 =
+        Bound1UnwrapTraits::Unwrap(storage->p1_);
+    typename Bound2UnwrapTraits::ForwardType x2 =
+        Bound2UnwrapTraits::Unwrap(storage->p2_);
+    typename Bound3UnwrapTraits::ForwardType x3 =
+        Bound3UnwrapTraits::Unwrap(storage->p3_);
+    typename Bound4UnwrapTraits::ForwardType x4 =
+        Bound4UnwrapTraits::Unwrap(storage->p4_);
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename Bound1UnwrapTraits::ForwardType,
+               typename Bound2UnwrapTraits::ForwardType,
+               typename Bound3UnwrapTraits::ForwardType,
+               typename Bound4UnwrapTraits::ForwardType,
+               typename CallbackParamTraits<X5>::ForwardType x5,
+               typename CallbackParamTraits<X6>::ForwardType x6)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5),
+                   CallbackForward(x6));
+  }
+};
+
+// Arity 6 -> 1.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3, typename X4, typename X5, typename X6>
+struct Invoker<5, StorageType, R(X1, X2, X3, X4, X5, X6)> {
+  typedef R(RunType)(BindStateBase*,
+      typename CallbackParamTraits<X6>::ForwardType);
+
+  typedef R(UnboundRunType)(X6);
+
+  static R Run(BindStateBase* base,
+      typename CallbackParamTraits<X6>::ForwardType x6) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
+    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
+    typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
+    typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits;
+    typedef typename StorageType::Bound5UnwrapTraits Bound5UnwrapTraits;
+
+    typename Bound1UnwrapTraits::ForwardType x1 =
+        Bound1UnwrapTraits::Unwrap(storage->p1_);
+    typename Bound2UnwrapTraits::ForwardType x2 =
+        Bound2UnwrapTraits::Unwrap(storage->p2_);
+    typename Bound3UnwrapTraits::ForwardType x3 =
+        Bound3UnwrapTraits::Unwrap(storage->p3_);
+    typename Bound4UnwrapTraits::ForwardType x4 =
+        Bound4UnwrapTraits::Unwrap(storage->p4_);
+    typename Bound5UnwrapTraits::ForwardType x5 =
+        Bound5UnwrapTraits::Unwrap(storage->p5_);
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename Bound1UnwrapTraits::ForwardType,
+               typename Bound2UnwrapTraits::ForwardType,
+               typename Bound3UnwrapTraits::ForwardType,
+               typename Bound4UnwrapTraits::ForwardType,
+               typename Bound5UnwrapTraits::ForwardType,
+               typename CallbackParamTraits<X6>::ForwardType x6)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5),
+                   CallbackForward(x6));
+  }
+};
+
+// Arity 6 -> 0.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3, typename X4, typename X5, typename X6>
+struct Invoker<6, StorageType, R(X1, X2, X3, X4, X5, X6)> {
+  typedef R(RunType)(BindStateBase*);
+
+  typedef R(UnboundRunType)();
+
+  static R Run(BindStateBase* base) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
+    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
+    typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
+    typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits;
+    typedef typename StorageType::Bound5UnwrapTraits Bound5UnwrapTraits;
+    typedef typename StorageType::Bound6UnwrapTraits Bound6UnwrapTraits;
+
+    typename Bound1UnwrapTraits::ForwardType x1 =
+        Bound1UnwrapTraits::Unwrap(storage->p1_);
+    typename Bound2UnwrapTraits::ForwardType x2 =
+        Bound2UnwrapTraits::Unwrap(storage->p2_);
+    typename Bound3UnwrapTraits::ForwardType x3 =
+        Bound3UnwrapTraits::Unwrap(storage->p3_);
+    typename Bound4UnwrapTraits::ForwardType x4 =
+        Bound4UnwrapTraits::Unwrap(storage->p4_);
+    typename Bound5UnwrapTraits::ForwardType x5 =
+        Bound5UnwrapTraits::Unwrap(storage->p5_);
+    typename Bound6UnwrapTraits::ForwardType x6 =
+        Bound6UnwrapTraits::Unwrap(storage->p6_);
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename Bound1UnwrapTraits::ForwardType,
+               typename Bound2UnwrapTraits::ForwardType,
+               typename Bound3UnwrapTraits::ForwardType,
+               typename Bound4UnwrapTraits::ForwardType,
+               typename Bound5UnwrapTraits::ForwardType,
+               typename Bound6UnwrapTraits::ForwardType)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5),
+                   CallbackForward(x6));
+  }
+};
+
+// Arity 7 -> 7.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3, typename X4, typename X5, typename X6, typename X7>
+struct Invoker<0, StorageType, R(X1, X2, X3, X4, X5, X6, X7)> {
+  typedef R(RunType)(BindStateBase*,
+      typename CallbackParamTraits<X1>::ForwardType,
+      typename CallbackParamTraits<X2>::ForwardType,
+      typename CallbackParamTraits<X3>::ForwardType,
+      typename CallbackParamTraits<X4>::ForwardType,
+      typename CallbackParamTraits<X5>::ForwardType,
+      typename CallbackParamTraits<X6>::ForwardType,
+      typename CallbackParamTraits<X7>::ForwardType);
+
+  typedef R(UnboundRunType)(X1, X2, X3, X4, X5, X6, X7);
+
+  static R Run(BindStateBase* base,
+      typename CallbackParamTraits<X1>::ForwardType x1,
+      typename CallbackParamTraits<X2>::ForwardType x2,
+      typename CallbackParamTraits<X3>::ForwardType x3,
+      typename CallbackParamTraits<X4>::ForwardType x4,
+      typename CallbackParamTraits<X5>::ForwardType x5,
+      typename CallbackParamTraits<X6>::ForwardType x6,
+      typename CallbackParamTraits<X7>::ForwardType x7) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename CallbackParamTraits<X1>::ForwardType x1,
+               typename CallbackParamTraits<X2>::ForwardType x2,
+               typename CallbackParamTraits<X3>::ForwardType x3,
+               typename CallbackParamTraits<X4>::ForwardType x4,
+               typename CallbackParamTraits<X5>::ForwardType x5,
+               typename CallbackParamTraits<X6>::ForwardType x6,
+               typename CallbackParamTraits<X7>::ForwardType x7)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5),
+                   CallbackForward(x6), CallbackForward(x7));
+  }
+};
+
+// Arity 7 -> 6.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3, typename X4, typename X5, typename X6, typename X7>
+struct Invoker<1, StorageType, R(X1, X2, X3, X4, X5, X6, X7)> {
+  typedef R(RunType)(BindStateBase*,
+      typename CallbackParamTraits<X2>::ForwardType,
+      typename CallbackParamTraits<X3>::ForwardType,
+      typename CallbackParamTraits<X4>::ForwardType,
+      typename CallbackParamTraits<X5>::ForwardType,
+      typename CallbackParamTraits<X6>::ForwardType,
+      typename CallbackParamTraits<X7>::ForwardType);
+
+  typedef R(UnboundRunType)(X2, X3, X4, X5, X6, X7);
+
+  static R Run(BindStateBase* base,
+      typename CallbackParamTraits<X2>::ForwardType x2,
+      typename CallbackParamTraits<X3>::ForwardType x3,
+      typename CallbackParamTraits<X4>::ForwardType x4,
+      typename CallbackParamTraits<X5>::ForwardType x5,
+      typename CallbackParamTraits<X6>::ForwardType x6,
+      typename CallbackParamTraits<X7>::ForwardType x7) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
+
+    typename Bound1UnwrapTraits::ForwardType x1 =
+        Bound1UnwrapTraits::Unwrap(storage->p1_);
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename Bound1UnwrapTraits::ForwardType,
+               typename CallbackParamTraits<X2>::ForwardType x2,
+               typename CallbackParamTraits<X3>::ForwardType x3,
+               typename CallbackParamTraits<X4>::ForwardType x4,
+               typename CallbackParamTraits<X5>::ForwardType x5,
+               typename CallbackParamTraits<X6>::ForwardType x6,
+               typename CallbackParamTraits<X7>::ForwardType x7)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5),
+                   CallbackForward(x6), CallbackForward(x7));
+  }
+};
+
+// Arity 7 -> 5.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3, typename X4, typename X5, typename X6, typename X7>
+struct Invoker<2, StorageType, R(X1, X2, X3, X4, X5, X6, X7)> {
+  typedef R(RunType)(BindStateBase*,
+      typename CallbackParamTraits<X3>::ForwardType,
+      typename CallbackParamTraits<X4>::ForwardType,
+      typename CallbackParamTraits<X5>::ForwardType,
+      typename CallbackParamTraits<X6>::ForwardType,
+      typename CallbackParamTraits<X7>::ForwardType);
+
+  typedef R(UnboundRunType)(X3, X4, X5, X6, X7);
+
+  static R Run(BindStateBase* base,
+      typename CallbackParamTraits<X3>::ForwardType x3,
+      typename CallbackParamTraits<X4>::ForwardType x4,
+      typename CallbackParamTraits<X5>::ForwardType x5,
+      typename CallbackParamTraits<X6>::ForwardType x6,
+      typename CallbackParamTraits<X7>::ForwardType x7) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
+    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
+
+    typename Bound1UnwrapTraits::ForwardType x1 =
+        Bound1UnwrapTraits::Unwrap(storage->p1_);
+    typename Bound2UnwrapTraits::ForwardType x2 =
+        Bound2UnwrapTraits::Unwrap(storage->p2_);
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename Bound1UnwrapTraits::ForwardType,
+               typename Bound2UnwrapTraits::ForwardType,
+               typename CallbackParamTraits<X3>::ForwardType x3,
+               typename CallbackParamTraits<X4>::ForwardType x4,
+               typename CallbackParamTraits<X5>::ForwardType x5,
+               typename CallbackParamTraits<X6>::ForwardType x6,
+               typename CallbackParamTraits<X7>::ForwardType x7)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5),
+                   CallbackForward(x6), CallbackForward(x7));
+  }
+};
+
+// Arity 7 -> 4.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3, typename X4, typename X5, typename X6, typename X7>
+struct Invoker<3, StorageType, R(X1, X2, X3, X4, X5, X6, X7)> {
+  typedef R(RunType)(BindStateBase*,
+      typename CallbackParamTraits<X4>::ForwardType,
+      typename CallbackParamTraits<X5>::ForwardType,
+      typename CallbackParamTraits<X6>::ForwardType,
+      typename CallbackParamTraits<X7>::ForwardType);
+
+  typedef R(UnboundRunType)(X4, X5, X6, X7);
+
+  static R Run(BindStateBase* base,
+      typename CallbackParamTraits<X4>::ForwardType x4,
+      typename CallbackParamTraits<X5>::ForwardType x5,
+      typename CallbackParamTraits<X6>::ForwardType x6,
+      typename CallbackParamTraits<X7>::ForwardType x7) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
+    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
+    typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
+
+    typename Bound1UnwrapTraits::ForwardType x1 =
+        Bound1UnwrapTraits::Unwrap(storage->p1_);
+    typename Bound2UnwrapTraits::ForwardType x2 =
+        Bound2UnwrapTraits::Unwrap(storage->p2_);
+    typename Bound3UnwrapTraits::ForwardType x3 =
+        Bound3UnwrapTraits::Unwrap(storage->p3_);
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename Bound1UnwrapTraits::ForwardType,
+               typename Bound2UnwrapTraits::ForwardType,
+               typename Bound3UnwrapTraits::ForwardType,
+               typename CallbackParamTraits<X4>::ForwardType x4,
+               typename CallbackParamTraits<X5>::ForwardType x5,
+               typename CallbackParamTraits<X6>::ForwardType x6,
+               typename CallbackParamTraits<X7>::ForwardType x7)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5),
+                   CallbackForward(x6), CallbackForward(x7));
+  }
+};
+
+// Arity 7 -> 3.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3, typename X4, typename X5, typename X6, typename X7>
+struct Invoker<4, StorageType, R(X1, X2, X3, X4, X5, X6, X7)> {
+  typedef R(RunType)(BindStateBase*,
+      typename CallbackParamTraits<X5>::ForwardType,
+      typename CallbackParamTraits<X6>::ForwardType,
+      typename CallbackParamTraits<X7>::ForwardType);
+
+  typedef R(UnboundRunType)(X5, X6, X7);
+
+  static R Run(BindStateBase* base,
+      typename CallbackParamTraits<X5>::ForwardType x5,
+      typename CallbackParamTraits<X6>::ForwardType x6,
+      typename CallbackParamTraits<X7>::ForwardType x7) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
+    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
+    typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
+    typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits;
+
+    typename Bound1UnwrapTraits::ForwardType x1 =
+        Bound1UnwrapTraits::Unwrap(storage->p1_);
+    typename Bound2UnwrapTraits::ForwardType x2 =
+        Bound2UnwrapTraits::Unwrap(storage->p2_);
+    typename Bound3UnwrapTraits::ForwardType x3 =
+        Bound3UnwrapTraits::Unwrap(storage->p3_);
+    typename Bound4UnwrapTraits::ForwardType x4 =
+        Bound4UnwrapTraits::Unwrap(storage->p4_);
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename Bound1UnwrapTraits::ForwardType,
+               typename Bound2UnwrapTraits::ForwardType,
+               typename Bound3UnwrapTraits::ForwardType,
+               typename Bound4UnwrapTraits::ForwardType,
+               typename CallbackParamTraits<X5>::ForwardType x5,
+               typename CallbackParamTraits<X6>::ForwardType x6,
+               typename CallbackParamTraits<X7>::ForwardType x7)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5),
+                   CallbackForward(x6), CallbackForward(x7));
+  }
+};
+
+// Arity 7 -> 2.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3, typename X4, typename X5, typename X6, typename X7>
+struct Invoker<5, StorageType, R(X1, X2, X3, X4, X5, X6, X7)> {
+  typedef R(RunType)(BindStateBase*,
+      typename CallbackParamTraits<X6>::ForwardType,
+      typename CallbackParamTraits<X7>::ForwardType);
+
+  typedef R(UnboundRunType)(X6, X7);
+
+  static R Run(BindStateBase* base,
+      typename CallbackParamTraits<X6>::ForwardType x6,
+      typename CallbackParamTraits<X7>::ForwardType x7) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
+    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
+    typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
+    typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits;
+    typedef typename StorageType::Bound5UnwrapTraits Bound5UnwrapTraits;
+
+    typename Bound1UnwrapTraits::ForwardType x1 =
+        Bound1UnwrapTraits::Unwrap(storage->p1_);
+    typename Bound2UnwrapTraits::ForwardType x2 =
+        Bound2UnwrapTraits::Unwrap(storage->p2_);
+    typename Bound3UnwrapTraits::ForwardType x3 =
+        Bound3UnwrapTraits::Unwrap(storage->p3_);
+    typename Bound4UnwrapTraits::ForwardType x4 =
+        Bound4UnwrapTraits::Unwrap(storage->p4_);
+    typename Bound5UnwrapTraits::ForwardType x5 =
+        Bound5UnwrapTraits::Unwrap(storage->p5_);
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename Bound1UnwrapTraits::ForwardType,
+               typename Bound2UnwrapTraits::ForwardType,
+               typename Bound3UnwrapTraits::ForwardType,
+               typename Bound4UnwrapTraits::ForwardType,
+               typename Bound5UnwrapTraits::ForwardType,
+               typename CallbackParamTraits<X6>::ForwardType x6,
+               typename CallbackParamTraits<X7>::ForwardType x7)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5),
+                   CallbackForward(x6), CallbackForward(x7));
+  }
+};
+
+// Arity 7 -> 1.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3, typename X4, typename X5, typename X6, typename X7>
+struct Invoker<6, StorageType, R(X1, X2, X3, X4, X5, X6, X7)> {
+  typedef R(RunType)(BindStateBase*,
+      typename CallbackParamTraits<X7>::ForwardType);
+
+  typedef R(UnboundRunType)(X7);
+
+  static R Run(BindStateBase* base,
+      typename CallbackParamTraits<X7>::ForwardType x7) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
+    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
+    typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
+    typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits;
+    typedef typename StorageType::Bound5UnwrapTraits Bound5UnwrapTraits;
+    typedef typename StorageType::Bound6UnwrapTraits Bound6UnwrapTraits;
+
+    typename Bound1UnwrapTraits::ForwardType x1 =
+        Bound1UnwrapTraits::Unwrap(storage->p1_);
+    typename Bound2UnwrapTraits::ForwardType x2 =
+        Bound2UnwrapTraits::Unwrap(storage->p2_);
+    typename Bound3UnwrapTraits::ForwardType x3 =
+        Bound3UnwrapTraits::Unwrap(storage->p3_);
+    typename Bound4UnwrapTraits::ForwardType x4 =
+        Bound4UnwrapTraits::Unwrap(storage->p4_);
+    typename Bound5UnwrapTraits::ForwardType x5 =
+        Bound5UnwrapTraits::Unwrap(storage->p5_);
+    typename Bound6UnwrapTraits::ForwardType x6 =
+        Bound6UnwrapTraits::Unwrap(storage->p6_);
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename Bound1UnwrapTraits::ForwardType,
+               typename Bound2UnwrapTraits::ForwardType,
+               typename Bound3UnwrapTraits::ForwardType,
+               typename Bound4UnwrapTraits::ForwardType,
+               typename Bound5UnwrapTraits::ForwardType,
+               typename Bound6UnwrapTraits::ForwardType,
+               typename CallbackParamTraits<X7>::ForwardType x7)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5),
+                   CallbackForward(x6), CallbackForward(x7));
+  }
+};
+
+// Arity 7 -> 0.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3, typename X4, typename X5, typename X6, typename X7>
+struct Invoker<7, StorageType, R(X1, X2, X3, X4, X5, X6, X7)> {
+  typedef R(RunType)(BindStateBase*);
+
+  typedef R(UnboundRunType)();
+
+  static R Run(BindStateBase* base) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
+    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
+    typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
+    typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits;
+    typedef typename StorageType::Bound5UnwrapTraits Bound5UnwrapTraits;
+    typedef typename StorageType::Bound6UnwrapTraits Bound6UnwrapTraits;
+    typedef typename StorageType::Bound7UnwrapTraits Bound7UnwrapTraits;
+
+    typename Bound1UnwrapTraits::ForwardType x1 =
+        Bound1UnwrapTraits::Unwrap(storage->p1_);
+    typename Bound2UnwrapTraits::ForwardType x2 =
+        Bound2UnwrapTraits::Unwrap(storage->p2_);
+    typename Bound3UnwrapTraits::ForwardType x3 =
+        Bound3UnwrapTraits::Unwrap(storage->p3_);
+    typename Bound4UnwrapTraits::ForwardType x4 =
+        Bound4UnwrapTraits::Unwrap(storage->p4_);
+    typename Bound5UnwrapTraits::ForwardType x5 =
+        Bound5UnwrapTraits::Unwrap(storage->p5_);
+    typename Bound6UnwrapTraits::ForwardType x6 =
+        Bound6UnwrapTraits::Unwrap(storage->p6_);
+    typename Bound7UnwrapTraits::ForwardType x7 =
+        Bound7UnwrapTraits::Unwrap(storage->p7_);
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename Bound1UnwrapTraits::ForwardType,
+               typename Bound2UnwrapTraits::ForwardType,
+               typename Bound3UnwrapTraits::ForwardType,
+               typename Bound4UnwrapTraits::ForwardType,
+               typename Bound5UnwrapTraits::ForwardType,
+               typename Bound6UnwrapTraits::ForwardType,
+               typename Bound7UnwrapTraits::ForwardType)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5),
+                   CallbackForward(x6), CallbackForward(x7));
+  }
+};
+
+
+// BindState<>
+//
+// This stores all the state passed into Bind() and is also where most
+// of the template resolution magic occurs.
+//
+// Runnable is the functor we are binding arguments to.
+// RunType is type of the Run() function that the Invoker<> should use.
+// Normally, this is the same as the RunType of the Runnable, but it can
+// be different if an adapter like IgnoreResult() has been used.
+//
+// BoundArgsType contains the storage type for all the bound arguments by
+// (ab)using a function type.
+template <typename Runnable, typename RunType, typename BoundArgsType>
+struct BindState;
+
+template <typename Runnable, typename RunType>
+struct BindState<Runnable, RunType, void()> : public BindStateBase {
+  typedef Runnable RunnableType;
+  typedef false_type IsWeakCall;
+  typedef Invoker<0, BindState, RunType> InvokerType;
+  typedef typename InvokerType::UnboundRunType UnboundRunType;
+  explicit BindState(const Runnable& runnable)
+      : BindStateBase(&Destroy),
+        runnable_(runnable) {
+  }
+
+  ~BindState() {  }
+
+  static void Destroy(BindStateBase* self) {
+    delete static_cast<BindState*>(self);
+  }
+
+  RunnableType runnable_;
+};
+
+template <typename Runnable, typename RunType, typename P1>
+struct BindState<Runnable, RunType, void(P1)> : public BindStateBase {
+  typedef Runnable RunnableType;
+  typedef IsWeakMethod<HasIsMethodTag<Runnable>::value, P1> IsWeakCall;
+  typedef Invoker<1, BindState, RunType> InvokerType;
+  typedef typename InvokerType::UnboundRunType UnboundRunType;
+
+  // Convenience typedefs for bound argument types.
+  typedef UnwrapTraits<P1> Bound1UnwrapTraits;
+
+  BindState(const Runnable& runnable, const P1& p1)
+      : BindStateBase(&Destroy),
+        runnable_(runnable),
+        p1_(p1) {
+    MaybeRefcount<HasIsMethodTag<Runnable>::value, P1>::AddRef(p1_);
+  }
+
+  ~BindState() {    MaybeRefcount<HasIsMethodTag<Runnable>::value,
+      P1>::Release(p1_);  }
+
+  static void Destroy(BindStateBase* self) {
+    delete static_cast<BindState*>(self);
+  }
+
+  RunnableType runnable_;
+  P1 p1_;
+};
+
+template <typename Runnable, typename RunType, typename P1, typename P2>
+struct BindState<Runnable, RunType, void(P1, P2)> : public BindStateBase {
+  typedef Runnable RunnableType;
+  typedef IsWeakMethod<HasIsMethodTag<Runnable>::value, P1> IsWeakCall;
+  typedef Invoker<2, BindState, RunType> InvokerType;
+  typedef typename InvokerType::UnboundRunType UnboundRunType;
+
+  // Convenience typedefs for bound argument types.
+  typedef UnwrapTraits<P1> Bound1UnwrapTraits;
+  typedef UnwrapTraits<P2> Bound2UnwrapTraits;
+
+  BindState(const Runnable& runnable, const P1& p1, const P2& p2)
+      : BindStateBase(&Destroy),
+        runnable_(runnable),
+        p1_(p1),
+        p2_(p2) {
+    MaybeRefcount<HasIsMethodTag<Runnable>::value, P1>::AddRef(p1_);
+  }
+
+  ~BindState() {    MaybeRefcount<HasIsMethodTag<Runnable>::value,
+      P1>::Release(p1_);  }
+
+  static void Destroy(BindStateBase* self) {
+    delete static_cast<BindState*>(self);
+  }
+
+  RunnableType runnable_;
+  P1 p1_;
+  P2 p2_;
+};
+
+template <typename Runnable, typename RunType, typename P1, typename P2,
+    typename P3>
+struct BindState<Runnable, RunType, void(P1, P2, P3)>
+    : public BindStateBase {
+  typedef Runnable RunnableType;
+  typedef IsWeakMethod<HasIsMethodTag<Runnable>::value, P1> IsWeakCall;
+  typedef Invoker<3, BindState, RunType> InvokerType;
+  typedef typename InvokerType::UnboundRunType UnboundRunType;
+
+  // Convenience typedefs for bound argument types.
+  typedef UnwrapTraits<P1> Bound1UnwrapTraits;
+  typedef UnwrapTraits<P2> Bound2UnwrapTraits;
+  typedef UnwrapTraits<P3> Bound3UnwrapTraits;
+
+  BindState(const Runnable& runnable, const P1& p1, const P2& p2, const P3& p3)
+      : BindStateBase(&Destroy),
+        runnable_(runnable),
+        p1_(p1),
+        p2_(p2),
+        p3_(p3) {
+    MaybeRefcount<HasIsMethodTag<Runnable>::value, P1>::AddRef(p1_);
+  }
+
+  ~BindState() {    MaybeRefcount<HasIsMethodTag<Runnable>::value,
+      P1>::Release(p1_);  }
+
+  static void Destroy(BindStateBase* self) {
+    delete static_cast<BindState*>(self);
+  }
+
+  RunnableType runnable_;
+  P1 p1_;
+  P2 p2_;
+  P3 p3_;
+};
+
+template <typename Runnable, typename RunType, typename P1, typename P2,
+    typename P3, typename P4>
+struct BindState<Runnable, RunType, void(P1, P2, P3, P4)>
+    : public BindStateBase {
+  typedef Runnable RunnableType;
+  typedef IsWeakMethod<HasIsMethodTag<Runnable>::value, P1> IsWeakCall;
+  typedef Invoker<4, BindState, RunType> InvokerType;
+  typedef typename InvokerType::UnboundRunType UnboundRunType;
+
+  // Convenience typedefs for bound argument types.
+  typedef UnwrapTraits<P1> Bound1UnwrapTraits;
+  typedef UnwrapTraits<P2> Bound2UnwrapTraits;
+  typedef UnwrapTraits<P3> Bound3UnwrapTraits;
+  typedef UnwrapTraits<P4> Bound4UnwrapTraits;
+
+  BindState(const Runnable& runnable, const P1& p1, const P2& p2, const P3& p3,
+      const P4& p4)
+      : BindStateBase(&Destroy),
+        runnable_(runnable),
+        p1_(p1),
+        p2_(p2),
+        p3_(p3),
+        p4_(p4) {
+    MaybeRefcount<HasIsMethodTag<Runnable>::value, P1>::AddRef(p1_);
+  }
+
+  ~BindState() {    MaybeRefcount<HasIsMethodTag<Runnable>::value,
+      P1>::Release(p1_);  }
+
+  static void Destroy(BindStateBase* self) {
+    delete static_cast<BindState*>(self);
+  }
+
+  RunnableType runnable_;
+  P1 p1_;
+  P2 p2_;
+  P3 p3_;
+  P4 p4_;
+};
+
+template <typename Runnable, typename RunType, typename P1, typename P2,
+    typename P3, typename P4, typename P5>
+struct BindState<Runnable, RunType, void(P1, P2, P3, P4, P5)>
+    : public BindStateBase {
+  typedef Runnable RunnableType;
+  typedef IsWeakMethod<HasIsMethodTag<Runnable>::value, P1> IsWeakCall;
+  typedef Invoker<5, BindState, RunType> InvokerType;
+  typedef typename InvokerType::UnboundRunType UnboundRunType;
+
+  // Convenience typedefs for bound argument types.
+  typedef UnwrapTraits<P1> Bound1UnwrapTraits;
+  typedef UnwrapTraits<P2> Bound2UnwrapTraits;
+  typedef UnwrapTraits<P3> Bound3UnwrapTraits;
+  typedef UnwrapTraits<P4> Bound4UnwrapTraits;
+  typedef UnwrapTraits<P5> Bound5UnwrapTraits;
+
+  BindState(const Runnable& runnable, const P1& p1, const P2& p2, const P3& p3,
+      const P4& p4, const P5& p5)
+      : BindStateBase(&Destroy),
+        runnable_(runnable),
+        p1_(p1),
+        p2_(p2),
+        p3_(p3),
+        p4_(p4),
+        p5_(p5) {
+    MaybeRefcount<HasIsMethodTag<Runnable>::value, P1>::AddRef(p1_);
+  }
+
+  ~BindState() {    MaybeRefcount<HasIsMethodTag<Runnable>::value,
+      P1>::Release(p1_);  }
+
+  static void Destroy(BindStateBase* self) {
+    delete static_cast<BindState*>(self);
+  }
+
+  RunnableType runnable_;
+  P1 p1_;
+  P2 p2_;
+  P3 p3_;
+  P4 p4_;
+  P5 p5_;
+};
+
+template <typename Runnable, typename RunType, typename P1, typename P2,
+    typename P3, typename P4, typename P5, typename P6>
+struct BindState<Runnable, RunType, void(P1, P2, P3, P4, P5, P6)>
+    : public BindStateBase {
+  typedef Runnable RunnableType;
+  typedef IsWeakMethod<HasIsMethodTag<Runnable>::value, P1> IsWeakCall;
+  typedef Invoker<6, BindState, RunType> InvokerType;
+  typedef typename InvokerType::UnboundRunType UnboundRunType;
+
+  // Convenience typedefs for bound argument types.
+  typedef UnwrapTraits<P1> Bound1UnwrapTraits;
+  typedef UnwrapTraits<P2> Bound2UnwrapTraits;
+  typedef UnwrapTraits<P3> Bound3UnwrapTraits;
+  typedef UnwrapTraits<P4> Bound4UnwrapTraits;
+  typedef UnwrapTraits<P5> Bound5UnwrapTraits;
+  typedef UnwrapTraits<P6> Bound6UnwrapTraits;
+
+  BindState(const Runnable& runnable, const P1& p1, const P2& p2, const P3& p3,
+      const P4& p4, const P5& p5, const P6& p6)
+      : BindStateBase(&Destroy),
+        runnable_(runnable),
+        p1_(p1),
+        p2_(p2),
+        p3_(p3),
+        p4_(p4),
+        p5_(p5),
+        p6_(p6) {
+    MaybeRefcount<HasIsMethodTag<Runnable>::value, P1>::AddRef(p1_);
+  }
+
+  ~BindState() {    MaybeRefcount<HasIsMethodTag<Runnable>::value,
+      P1>::Release(p1_);  }
+
+  static void Destroy(BindStateBase* self) {
+    delete static_cast<BindState*>(self);
+  }
+
+  RunnableType runnable_;
+  P1 p1_;
+  P2 p2_;
+  P3 p3_;
+  P4 p4_;
+  P5 p5_;
+  P6 p6_;
+};
+
+template <typename Runnable, typename RunType, typename P1, typename P2,
+    typename P3, typename P4, typename P5, typename P6, typename P7>
+struct BindState<Runnable, RunType, void(P1, P2, P3, P4, P5, P6, P7)>
+    : public BindStateBase {
+  typedef Runnable RunnableType;
+  typedef IsWeakMethod<HasIsMethodTag<Runnable>::value, P1> IsWeakCall;
+  typedef Invoker<7, BindState, RunType> InvokerType;
+  typedef typename InvokerType::UnboundRunType UnboundRunType;
+
+  // Convenience typedefs for bound argument types.
+  typedef UnwrapTraits<P1> Bound1UnwrapTraits;
+  typedef UnwrapTraits<P2> Bound2UnwrapTraits;
+  typedef UnwrapTraits<P3> Bound3UnwrapTraits;
+  typedef UnwrapTraits<P4> Bound4UnwrapTraits;
+  typedef UnwrapTraits<P5> Bound5UnwrapTraits;
+  typedef UnwrapTraits<P6> Bound6UnwrapTraits;
+  typedef UnwrapTraits<P7> Bound7UnwrapTraits;
+
+  BindState(const Runnable& runnable, const P1& p1, const P2& p2, const P3& p3,
+      const P4& p4, const P5& p5, const P6& p6, const P7& p7)
+      : BindStateBase(&Destroy),
+        runnable_(runnable),
+        p1_(p1),
+        p2_(p2),
+        p3_(p3),
+        p4_(p4),
+        p5_(p5),
+        p6_(p6),
+        p7_(p7) {
+    MaybeRefcount<HasIsMethodTag<Runnable>::value, P1>::AddRef(p1_);
+  }
+
+  ~BindState() {    MaybeRefcount<HasIsMethodTag<Runnable>::value,
+      P1>::Release(p1_);  }
+
+  static void Destroy(BindStateBase* self) {
+    delete static_cast<BindState*>(self);
+  }
+
+  RunnableType runnable_;
+  P1 p1_;
+  P2 p2_;
+  P3 p3_;
+  P4 p4_;
+  P5 p5_;
+  P6 p6_;
+  P7 p7_;
+};
+
+}  // namespace cef_internal
+}  // namespace base
+
+#endif  // CEF_INCLUDE_BASE_INTERNAL_CEF_BIND_INTERNAL_H_
diff --git a/src/include/libcef/base/internal/cef_bind_internal_win.h b/src/include/libcef/base/internal/cef_bind_internal_win.h
new file mode 100644
index 0000000..1b061cc
--- /dev/null
+++ b/src/include/libcef/base/internal/cef_bind_internal_win.h
@@ -0,0 +1,390 @@
+// Copyright (c) 2011 Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Do not include this header file directly. Use base/cef_bind.h instead.
+
+// Specializations of RunnableAdapter<> for Windows specific calling
+// conventions.  Please see base/bind_internal.h for more info.
+
+#ifndef CEF_INCLUDE_BASE_INTERNAL_CEF_BIND_INTERNAL_WIN_H_
+#define CEF_INCLUDE_BASE_INTERNAL_CEF_BIND_INTERNAL_WIN_H_
+
+// In the x64 architecture in Windows, __fastcall, __stdcall, etc, are all
+// the same as __cdecl which would turn the following specializations into
+// multiple definitions.
+#if !defined(ARCH_CPU_X86_64)
+
+namespace base {
+namespace cef_internal {
+
+template <typename Functor>
+class RunnableAdapter;
+
+// __stdcall Function: Arity 0.
+template <typename R>
+class RunnableAdapter<R(__stdcall *)()> {
+ public:
+  typedef R (RunType)();
+
+  explicit RunnableAdapter(R(__stdcall *function)())
+      : function_(function) {
+  }
+
+  R Run() {
+    return function_();
+  }
+
+ private:
+  R (__stdcall *function_)();
+};
+
+// __fastcall Function: Arity 0.
+template <typename R>
+class RunnableAdapter<R(__fastcall *)()> {
+ public:
+  typedef R (RunType)();
+
+  explicit RunnableAdapter(R(__fastcall *function)())
+      : function_(function) {
+  }
+
+  R Run() {
+    return function_();
+  }
+
+ private:
+  R (__fastcall *function_)();
+};
+
+// __stdcall Function: Arity 1.
+template <typename R, typename A1>
+class RunnableAdapter<R(__stdcall *)(A1)> {
+ public:
+  typedef R (RunType)(A1);
+
+  explicit RunnableAdapter(R(__stdcall *function)(A1))
+      : function_(function) {
+  }
+
+  R Run(typename CallbackParamTraits<A1>::ForwardType a1) {
+    return function_(a1);
+  }
+
+ private:
+  R (__stdcall *function_)(A1);
+};
+
+// __fastcall Function: Arity 1.
+template <typename R, typename A1>
+class RunnableAdapter<R(__fastcall *)(A1)> {
+ public:
+  typedef R (RunType)(A1);
+
+  explicit RunnableAdapter(R(__fastcall *function)(A1))
+      : function_(function) {
+  }
+
+  R Run(typename CallbackParamTraits<A1>::ForwardType a1) {
+    return function_(a1);
+  }
+
+ private:
+  R (__fastcall *function_)(A1);
+};
+
+// __stdcall Function: Arity 2.
+template <typename R, typename A1, typename A2>
+class RunnableAdapter<R(__stdcall *)(A1, A2)> {
+ public:
+  typedef R (RunType)(A1, A2);
+
+  explicit RunnableAdapter(R(__stdcall *function)(A1, A2))
+      : function_(function) {
+  }
+
+  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2) {
+    return function_(a1, a2);
+  }
+
+ private:
+  R (__stdcall *function_)(A1, A2);
+};
+
+// __fastcall Function: Arity 2.
+template <typename R, typename A1, typename A2>
+class RunnableAdapter<R(__fastcall *)(A1, A2)> {
+ public:
+  typedef R (RunType)(A1, A2);
+
+  explicit RunnableAdapter(R(__fastcall *function)(A1, A2))
+      : function_(function) {
+  }
+
+  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2) {
+    return function_(a1, a2);
+  }
+
+ private:
+  R (__fastcall *function_)(A1, A2);
+};
+
+// __stdcall Function: Arity 3.
+template <typename R, typename A1, typename A2, typename A3>
+class RunnableAdapter<R(__stdcall *)(A1, A2, A3)> {
+ public:
+  typedef R (RunType)(A1, A2, A3);
+
+  explicit RunnableAdapter(R(__stdcall *function)(A1, A2, A3))
+      : function_(function) {
+  }
+
+  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3) {
+    return function_(a1, a2, a3);
+  }
+
+ private:
+  R (__stdcall *function_)(A1, A2, A3);
+};
+
+// __fastcall Function: Arity 3.
+template <typename R, typename A1, typename A2, typename A3>
+class RunnableAdapter<R(__fastcall *)(A1, A2, A3)> {
+ public:
+  typedef R (RunType)(A1, A2, A3);
+
+  explicit RunnableAdapter(R(__fastcall *function)(A1, A2, A3))
+      : function_(function) {
+  }
+
+  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3) {
+    return function_(a1, a2, a3);
+  }
+
+ private:
+  R (__fastcall *function_)(A1, A2, A3);
+};
+
+// __stdcall Function: Arity 4.
+template <typename R, typename A1, typename A2, typename A3, typename A4>
+class RunnableAdapter<R(__stdcall *)(A1, A2, A3, A4)> {
+ public:
+  typedef R (RunType)(A1, A2, A3, A4);
+
+  explicit RunnableAdapter(R(__stdcall *function)(A1, A2, A3, A4))
+      : function_(function) {
+  }
+
+  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3,
+      typename CallbackParamTraits<A4>::ForwardType a4) {
+    return function_(a1, a2, a3, a4);
+  }
+
+ private:
+  R (__stdcall *function_)(A1, A2, A3, A4);
+};
+
+// __fastcall Function: Arity 4.
+template <typename R, typename A1, typename A2, typename A3, typename A4>
+class RunnableAdapter<R(__fastcall *)(A1, A2, A3, A4)> {
+ public:
+  typedef R (RunType)(A1, A2, A3, A4);
+
+  explicit RunnableAdapter(R(__fastcall *function)(A1, A2, A3, A4))
+      : function_(function) {
+  }
+
+  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3,
+      typename CallbackParamTraits<A4>::ForwardType a4) {
+    return function_(a1, a2, a3, a4);
+  }
+
+ private:
+  R (__fastcall *function_)(A1, A2, A3, A4);
+};
+
+// __stdcall Function: Arity 5.
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5>
+class RunnableAdapter<R(__stdcall *)(A1, A2, A3, A4, A5)> {
+ public:
+  typedef R (RunType)(A1, A2, A3, A4, A5);
+
+  explicit RunnableAdapter(R(__stdcall *function)(A1, A2, A3, A4, A5))
+      : function_(function) {
+  }
+
+  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3,
+      typename CallbackParamTraits<A4>::ForwardType a4,
+      typename CallbackParamTraits<A5>::ForwardType a5) {
+    return function_(a1, a2, a3, a4, a5);
+  }
+
+ private:
+  R (__stdcall *function_)(A1, A2, A3, A4, A5);
+};
+
+// __fastcall Function: Arity 5.
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5>
+class RunnableAdapter<R(__fastcall *)(A1, A2, A3, A4, A5)> {
+ public:
+  typedef R (RunType)(A1, A2, A3, A4, A5);
+
+  explicit RunnableAdapter(R(__fastcall *function)(A1, A2, A3, A4, A5))
+      : function_(function) {
+  }
+
+  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3,
+      typename CallbackParamTraits<A4>::ForwardType a4,
+      typename CallbackParamTraits<A5>::ForwardType a5) {
+    return function_(a1, a2, a3, a4, a5);
+  }
+
+ private:
+  R (__fastcall *function_)(A1, A2, A3, A4, A5);
+};
+
+// __stdcall Function: Arity 6.
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6>
+class RunnableAdapter<R(__stdcall *)(A1, A2, A3, A4, A5, A6)> {
+ public:
+  typedef R (RunType)(A1, A2, A3, A4, A5, A6);
+
+  explicit RunnableAdapter(R(__stdcall *function)(A1, A2, A3, A4, A5, A6))
+      : function_(function) {
+  }
+
+  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3,
+      typename CallbackParamTraits<A4>::ForwardType a4,
+      typename CallbackParamTraits<A5>::ForwardType a5,
+      typename CallbackParamTraits<A6>::ForwardType a6) {
+    return function_(a1, a2, a3, a4, a5, a6);
+  }
+
+ private:
+  R (__stdcall *function_)(A1, A2, A3, A4, A5, A6);
+};
+
+// __fastcall Function: Arity 6.
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6>
+class RunnableAdapter<R(__fastcall *)(A1, A2, A3, A4, A5, A6)> {
+ public:
+  typedef R (RunType)(A1, A2, A3, A4, A5, A6);
+
+  explicit RunnableAdapter(R(__fastcall *function)(A1, A2, A3, A4, A5, A6))
+      : function_(function) {
+  }
+
+  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3,
+      typename CallbackParamTraits<A4>::ForwardType a4,
+      typename CallbackParamTraits<A5>::ForwardType a5,
+      typename CallbackParamTraits<A6>::ForwardType a6) {
+    return function_(a1, a2, a3, a4, a5, a6);
+  }
+
+ private:
+  R (__fastcall *function_)(A1, A2, A3, A4, A5, A6);
+};
+
+// __stdcall Function: Arity 7.
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6, typename A7>
+class RunnableAdapter<R(__stdcall *)(A1, A2, A3, A4, A5, A6, A7)> {
+ public:
+  typedef R (RunType)(A1, A2, A3, A4, A5, A6, A7);
+
+  explicit RunnableAdapter(R(__stdcall *function)(A1, A2, A3, A4, A5, A6, A7))
+      : function_(function) {
+  }
+
+  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3,
+      typename CallbackParamTraits<A4>::ForwardType a4,
+      typename CallbackParamTraits<A5>::ForwardType a5,
+      typename CallbackParamTraits<A6>::ForwardType a6,
+      typename CallbackParamTraits<A7>::ForwardType a7) {
+    return function_(a1, a2, a3, a4, a5, a6, a7);
+  }
+
+ private:
+  R (__stdcall *function_)(A1, A2, A3, A4, A5, A6, A7);
+};
+
+// __fastcall Function: Arity 7.
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6, typename A7>
+class RunnableAdapter<R(__fastcall *)(A1, A2, A3, A4, A5, A6, A7)> {
+ public:
+  typedef R (RunType)(A1, A2, A3, A4, A5, A6, A7);
+
+  explicit RunnableAdapter(R(__fastcall *function)(A1, A2, A3, A4, A5, A6, A7))
+      : function_(function) {
+  }
+
+  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3,
+      typename CallbackParamTraits<A4>::ForwardType a4,
+      typename CallbackParamTraits<A5>::ForwardType a5,
+      typename CallbackParamTraits<A6>::ForwardType a6,
+      typename CallbackParamTraits<A7>::ForwardType a7) {
+    return function_(a1, a2, a3, a4, a5, a6, a7);
+  }
+
+ private:
+  R (__fastcall *function_)(A1, A2, A3, A4, A5, A6, A7);
+};
+
+}  // namespace cef_internal
+}  // namespace base
+
+#endif  // !defined(ARCH_CPU_X86_64)
+
+#endif  // CEF_INCLUDE_BASE_INTERNAL_CEF_BIND_INTERNAL_WIN_H_
diff --git a/src/include/libcef/base/internal/cef_callback_internal.h b/src/include/libcef/base/internal/cef_callback_internal.h
new file mode 100644
index 0000000..542e843
--- /dev/null
+++ b/src/include/libcef/base/internal/cef_callback_internal.h
@@ -0,0 +1,223 @@
+// Copyright (c) 2012 Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Do not include this header file directly. Use base/cef_bind.h or
+// base/cef_callback.h instead.
+
+// This file contains utility functions and classes that help the
+// implementation, and management of the Callback objects.
+
+#ifndef CEF_INCLUDE_BASE_INTERNAL_CEF_CALLBACK_INTERNAL_H_
+#define CEF_INCLUDE_BASE_INTERNAL_CEF_CALLBACK_INTERNAL_H_
+
+#include <stddef.h>
+
+#include "include/base/cef_atomic_ref_count.h"
+#include "include/base/cef_macros.h"
+#include "include/base/cef_ref_counted.h"
+#include "include/base/cef_scoped_ptr.h"
+#include "include/base/cef_template_util.h"
+
+template <typename T>
+class ScopedVector;
+
+namespace base {
+namespace cef_internal {
+class CallbackBase;
+
+// At the base level, the only task is to add reference counting data. Don't use
+// RefCountedThreadSafe since it requires the destructor to be a virtual method.
+// Creating a vtable for every BindState template instantiation results in a lot
+// of bloat. Its only task is to call the destructor which can be done with a
+// function pointer.
+class BindStateBase {
+ protected:
+  explicit BindStateBase(void (*destructor)(BindStateBase*))
+      : ref_count_(0), destructor_(destructor) {}
+  ~BindStateBase() {}
+
+ private:
+  friend class scoped_refptr<BindStateBase>;
+  friend class CallbackBase;
+
+  void AddRef();
+  void Release();
+
+  AtomicRefCount ref_count_;
+
+  // Pointer to a function that will properly destroy |this|.
+  void (*destructor_)(BindStateBase*);
+
+  DISALLOW_COPY_AND_ASSIGN(BindStateBase);
+};
+
+// Holds the Callback methods that don't require specialization to reduce
+// template bloat.
+class CallbackBase {
+ public:
+  // Returns true if Callback is null (doesn't refer to anything).
+  bool is_null() const { return bind_state_.get() == NULL; }
+
+  // Returns the Callback into an uninitialized state.
+  void Reset();
+
+ protected:
+  // In C++, it is safe to cast function pointers to function pointers of
+  // another type. It is not okay to use void*. We create a InvokeFuncStorage
+  // that that can store our function pointer, and then cast it back to
+  // the original type on usage.
+  typedef void(*InvokeFuncStorage)(void);
+
+  // Returns true if this callback equals |other|. |other| may be null.
+  bool Equals(const CallbackBase& other) const;
+
+  // Allow initializing of |bind_state_| via the constructor to avoid default
+  // initialization of the scoped_refptr.  We do not also initialize
+  // |polymorphic_invoke_| here because doing a normal assignment in the
+  // derived Callback templates makes for much nicer compiler errors.
+  explicit CallbackBase(BindStateBase* bind_state);
+
+  // Force the destructor to be instantiated inside this translation unit so
+  // that our subclasses will not get inlined versions.  Avoids more template
+  // bloat.
+  ~CallbackBase();
+
+  scoped_refptr<BindStateBase> bind_state_;
+  InvokeFuncStorage polymorphic_invoke_;
+};
+
+// A helper template to determine if given type is non-const move-only-type,
+// i.e. if a value of the given type should be passed via .Pass() in a
+// destructive way.
+template <typename T> struct IsMoveOnlyType {
+  template <typename U>
+  static YesType Test(const typename U::MoveOnlyTypeForCPP03*);
+
+  template <typename U>
+  static NoType Test(...);
+
+  static const bool value = sizeof(Test<T>(0)) == sizeof(YesType) &&
+                            !is_const<T>::value;
+};
+
+// This is a typetraits object that's used to take an argument type, and
+// extract a suitable type for storing and forwarding arguments.
+//
+// In particular, it strips off references, and converts arrays to
+// pointers for storage; and it avoids accidentally trying to create a
+// "reference of a reference" if the argument is a reference type.
+//
+// This array type becomes an issue for storage because we are passing bound
+// parameters by const reference. In this case, we end up passing an actual
+// array type in the initializer list which C++ does not allow.  This will
+// break passing of C-string literals.
+template <typename T, bool is_move_only = IsMoveOnlyType<T>::value>
+struct CallbackParamTraits {
+  typedef const T& ForwardType;
+  typedef T StorageType;
+};
+
+// The Storage should almost be impossible to trigger unless someone manually
+// specifies type of the bind parameters.  However, in case they do,
+// this will guard against us accidentally storing a reference parameter.
+//
+// The ForwardType should only be used for unbound arguments.
+template <typename T>
+struct CallbackParamTraits<T&, false> {
+  typedef T& ForwardType;
+  typedef T StorageType;
+};
+
+// Note that for array types, we implicitly add a const in the conversion. This
+// means that it is not possible to bind array arguments to functions that take
+// a non-const pointer. Trying to specialize the template based on a "const
+// T[n]" does not seem to match correctly, so we are stuck with this
+// restriction.
+template <typename T, size_t n>
+struct CallbackParamTraits<T[n], false> {
+  typedef const T* ForwardType;
+  typedef const T* StorageType;
+};
+
+// See comment for CallbackParamTraits<T[n]>.
+template <typename T>
+struct CallbackParamTraits<T[], false> {
+  typedef const T* ForwardType;
+  typedef const T* StorageType;
+};
+
+// Parameter traits for movable-but-not-copyable scopers.
+//
+// Callback<>/Bind() understands movable-but-not-copyable semantics where
+// the type cannot be copied but can still have its state destructively
+// transferred (aka. moved) to another instance of the same type by calling a
+// helper function.  When used with Bind(), this signifies transferal of the
+// object's state to the target function.
+//
+// For these types, the ForwardType must not be a const reference, or a
+// reference.  A const reference is inappropriate, and would break const
+// correctness, because we are implementing a destructive move.  A non-const
+// reference cannot be used with temporaries which means the result of a
+// function or a cast would not be usable with Callback<> or Bind().
+template <typename T>
+struct CallbackParamTraits<T, true> {
+  typedef T ForwardType;
+  typedef T StorageType;
+};
+
+// CallbackForward() is a very limited simulation of C++11's std::forward()
+// used by the Callback/Bind system for a set of movable-but-not-copyable
+// types.  It is needed because forwarding a movable-but-not-copyable
+// argument to another function requires us to invoke the proper move
+// operator to create a rvalue version of the type.  The supported types are
+// whitelisted below as overloads of the CallbackForward() function. The
+// default template compiles out to be a no-op.
+//
+// In C++11, std::forward would replace all uses of this function.  However, it
+// is impossible to implement a general std::forward with C++11 due to a lack
+// of rvalue references.
+//
+// In addition to Callback/Bind, this is used by PostTaskAndReplyWithResult to
+// simulate std::forward() and forward the result of one Callback as a
+// parameter to another callback. This is to support Callbacks that return
+// the movable-but-not-copyable types whitelisted above.
+template <typename T>
+typename enable_if<!IsMoveOnlyType<T>::value, T>::type& CallbackForward(T& t) {
+  return t;
+}
+
+template <typename T>
+typename enable_if<IsMoveOnlyType<T>::value, T>::type CallbackForward(T& t) {
+  return t.Pass();
+}
+
+}  // namespace cef_internal
+}  // namespace base
+
+#endif  // CEF_INCLUDE_BASE_INTERNAL_CEF_CALLBACK_INTERNAL_H_
diff --git a/src/include/libcef/base/internal/cef_lock_impl.h b/src/include/libcef/base/internal/cef_lock_impl.h
new file mode 100644
index 0000000..470547f
--- /dev/null
+++ b/src/include/libcef/base/internal/cef_lock_impl.h
@@ -0,0 +1,87 @@
+// Copyright (c) 2011 Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Do not include this header file directly. Use base/cef_lock.h instead.
+
+#ifndef CEF_INCLUDE_BASE_INTERNAL_CEF_LOCK_IMPL_H_
+#define CEF_INCLUDE_BASE_INTERNAL_CEF_LOCK_IMPL_H_
+
+#include "include/base/cef_build.h"
+
+#if defined(OS_WIN)
+#include <windows.h>
+#elif defined(OS_POSIX)
+#include <pthread.h>
+#endif
+
+#include "include/base/cef_macros.h"
+
+namespace base {
+namespace cef_internal {
+
+// This class implements the underlying platform-specific spin-lock mechanism
+// used for the Lock class.  Most users should not use LockImpl directly, but
+// should instead use Lock.
+class LockImpl {
+ public:
+#if defined(OS_WIN)
+  typedef CRITICAL_SECTION NativeHandle;
+#elif defined(OS_POSIX)
+  typedef pthread_mutex_t NativeHandle;
+#endif
+
+  LockImpl();
+  ~LockImpl();
+
+  // If the lock is not held, take it and return true.  If the lock is already
+  // held by something else, immediately return false.
+  bool Try();
+
+  // Take the lock, blocking until it is available if necessary.
+  void Lock();
+
+  // Release the lock.  This must only be called by the lock's holder: after
+  // a successful call to Try, or a call to Lock.
+  void Unlock();
+
+  // Return the native underlying lock.
+  // TODO(awalker): refactor lock and condition variables so that this is
+  // unnecessary.
+  NativeHandle* native_handle() { return &native_handle_; }
+
+ private:
+  NativeHandle native_handle_;
+
+  DISALLOW_COPY_AND_ASSIGN(LockImpl);
+};
+
+}  // namespace cef_internal
+}  // namespace base
+
+#endif  // CEF_INCLUDE_BASE_INTERNAL_CEF_LOCK_IMPL_H_
diff --git a/src/include/libcef/base/internal/cef_raw_scoped_refptr_mismatch_checker.h b/src/include/libcef/base/internal/cef_raw_scoped_refptr_mismatch_checker.h
new file mode 100644
index 0000000..8584fcd
--- /dev/null
+++ b/src/include/libcef/base/internal/cef_raw_scoped_refptr_mismatch_checker.h
@@ -0,0 +1,154 @@
+// Copyright (c) 2011 Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Do not include this header file directly. Use base/cef_callback.h instead.
+
+#ifndef CEF_INCLUDE_BASE_INTERNAL_CEF_RAW_SCOPED_REFPTR_MISMATCH_CHECKER_H_
+#define CEF_INCLUDE_BASE_INTERNAL_CEF_RAW_SCOPED_REFPTR_MISMATCH_CHECKER_H_
+
+#include "include/base/cef_build.h"
+#include "include/base/cef_ref_counted.h"
+#include "include/base/cef_template_util.h"
+#include "include/base/cef_tuple.h"
+
+// It is dangerous to post a task with a T* argument where T is a subtype of
+// RefCounted(Base|ThreadSafeBase), since by the time the parameter is used, the
+// object may already have been deleted since it was not held with a
+// scoped_refptr. Example: http://crbug.com/27191
+// The following set of traits are designed to generate a compile error
+// whenever this antipattern is attempted.
+
+namespace base {
+
+namespace cef_internal {
+
+template <typename T>
+struct NeedsScopedRefptrButGetsRawPtr {
+#if defined(OS_WIN)
+  enum {
+    value = base::false_type::value
+  };
+#else
+  enum {
+    // Human readable translation: you needed to be a scoped_refptr if you are a
+    // raw pointer type and are convertible to a RefCounted(Base|ThreadSafeBase)
+    // type.
+    value = (is_pointer<T>::value &&
+             (is_convertible<T, subtle::RefCountedBase*>::value ||
+              is_convertible<T, subtle::RefCountedThreadSafeBase*>::value))
+  };
+#endif
+};
+
+template <typename Params>
+struct ParamsUseScopedRefptrCorrectly {
+  enum { value = 0 };
+};
+
+template <>
+struct ParamsUseScopedRefptrCorrectly<Tuple0> {
+  enum { value = 1 };
+};
+
+template <typename A>
+struct ParamsUseScopedRefptrCorrectly<Tuple1<A> > {
+  enum { value = !NeedsScopedRefptrButGetsRawPtr<A>::value };
+};
+
+template <typename A, typename B>
+struct ParamsUseScopedRefptrCorrectly<Tuple2<A, B> > {
+  enum { value = !(NeedsScopedRefptrButGetsRawPtr<A>::value ||
+                   NeedsScopedRefptrButGetsRawPtr<B>::value) };
+};
+
+template <typename A, typename B, typename C>
+struct ParamsUseScopedRefptrCorrectly<Tuple3<A, B, C> > {
+  enum { value = !(NeedsScopedRefptrButGetsRawPtr<A>::value ||
+                   NeedsScopedRefptrButGetsRawPtr<B>::value ||
+                   NeedsScopedRefptrButGetsRawPtr<C>::value) };
+};
+
+template <typename A, typename B, typename C, typename D>
+struct ParamsUseScopedRefptrCorrectly<Tuple4<A, B, C, D> > {
+  enum { value = !(NeedsScopedRefptrButGetsRawPtr<A>::value ||
+                   NeedsScopedRefptrButGetsRawPtr<B>::value ||
+                   NeedsScopedRefptrButGetsRawPtr<C>::value ||
+                   NeedsScopedRefptrButGetsRawPtr<D>::value) };
+};
+
+template <typename A, typename B, typename C, typename D, typename E>
+struct ParamsUseScopedRefptrCorrectly<Tuple5<A, B, C, D, E> > {
+  enum { value = !(NeedsScopedRefptrButGetsRawPtr<A>::value ||
+                   NeedsScopedRefptrButGetsRawPtr<B>::value ||
+                   NeedsScopedRefptrButGetsRawPtr<C>::value ||
+                   NeedsScopedRefptrButGetsRawPtr<D>::value ||
+                   NeedsScopedRefptrButGetsRawPtr<E>::value) };
+};
+
+template <typename A, typename B, typename C, typename D, typename E,
+          typename F>
+struct ParamsUseScopedRefptrCorrectly<Tuple6<A, B, C, D, E, F> > {
+  enum { value = !(NeedsScopedRefptrButGetsRawPtr<A>::value ||
+                   NeedsScopedRefptrButGetsRawPtr<B>::value ||
+                   NeedsScopedRefptrButGetsRawPtr<C>::value ||
+                   NeedsScopedRefptrButGetsRawPtr<D>::value ||
+                   NeedsScopedRefptrButGetsRawPtr<E>::value ||
+                   NeedsScopedRefptrButGetsRawPtr<F>::value) };
+};
+
+template <typename A, typename B, typename C, typename D, typename E,
+          typename F, typename G>
+struct ParamsUseScopedRefptrCorrectly<Tuple7<A, B, C, D, E, F, G> > {
+  enum { value = !(NeedsScopedRefptrButGetsRawPtr<A>::value ||
+                   NeedsScopedRefptrButGetsRawPtr<B>::value ||
+                   NeedsScopedRefptrButGetsRawPtr<C>::value ||
+                   NeedsScopedRefptrButGetsRawPtr<D>::value ||
+                   NeedsScopedRefptrButGetsRawPtr<E>::value ||
+                   NeedsScopedRefptrButGetsRawPtr<F>::value ||
+                   NeedsScopedRefptrButGetsRawPtr<G>::value) };
+};
+
+template <typename A, typename B, typename C, typename D, typename E,
+          typename F, typename G, typename H>
+struct ParamsUseScopedRefptrCorrectly<Tuple8<A, B, C, D, E, F, G, H> > {
+  enum { value = !(NeedsScopedRefptrButGetsRawPtr<A>::value ||
+                   NeedsScopedRefptrButGetsRawPtr<B>::value ||
+                   NeedsScopedRefptrButGetsRawPtr<C>::value ||
+                   NeedsScopedRefptrButGetsRawPtr<D>::value ||
+                   NeedsScopedRefptrButGetsRawPtr<E>::value ||
+                   NeedsScopedRefptrButGetsRawPtr<F>::value ||
+                   NeedsScopedRefptrButGetsRawPtr<G>::value ||
+                   NeedsScopedRefptrButGetsRawPtr<H>::value) };
+};
+
+}  // namespace cef_internal
+
+}  // namespace base
+
+#endif  // CEF_INCLUDE_BASE_INTERNAL_CEF_RAW_SCOPED_REFPTR_MISMATCH_CHECKER_H_
diff --git a/src/include/libcef/base/internal/cef_thread_checker_impl.h b/src/include/libcef/base/internal/cef_thread_checker_impl.h
new file mode 100644
index 0000000..2654698
--- /dev/null
+++ b/src/include/libcef/base/internal/cef_thread_checker_impl.h
@@ -0,0 +1,72 @@
+// Copyright (c) 2011 Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Do not include this header file directly. Use base/cef_thread_checker.h
+// instead.
+
+#ifndef CEF_INCLUDE_BASE_INTERNAL_THREAD_CHECKER_IMPL_H_
+#define CEF_INCLUDE_BASE_INTERNAL_THREAD_CHECKER_IMPL_H_
+
+#include "include/base/cef_lock.h"
+#include "include/base/cef_platform_thread.h"
+
+namespace base {
+namespace cef_internal {
+
+// Real implementation of ThreadChecker, for use in debug mode, or
+// for temporary use in release mode (e.g. to CHECK on a threading issue
+// seen only in the wild).
+//
+// Note: You should almost always use the ThreadChecker class to get the
+// right version for your build configuration.
+class ThreadCheckerImpl {
+ public:
+  ThreadCheckerImpl();
+  ~ThreadCheckerImpl();
+
+  bool CalledOnValidThread() const;
+
+  // Changes the thread that is checked for in CalledOnValidThread.  This may
+  // be useful when an object may be created on one thread and then used
+  // exclusively on another thread.
+  void DetachFromThread();
+
+ private:
+  void EnsureThreadIdAssigned() const;
+
+  mutable base::Lock lock_;
+  // This is mutable so that CalledOnValidThread can set it.
+  // It's guarded by |lock_|.
+  mutable PlatformThreadRef valid_thread_id_;
+};
+
+}  // namespace cef_internal
+}  // namespace base
+
+#endif  // CEF_INCLUDE_BASE_INTERNAL_THREAD_CHECKER_IMPL_H_
diff --git a/src/include/libcef/capi/cef_app_capi.h b/src/include/libcef/capi/cef_app_capi.h
new file mode 100644
index 0000000..6c55f53
--- /dev/null
+++ b/src/include/libcef/capi/cef_app_capi.h
@@ -0,0 +1,189 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_APP_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_APP_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+#include"libcef/capi/cef_browser_process_handler_capi.h"
+#include"libcef/capi/cef_command_line_capi.h"
+#include"libcef/capi/cef_render_process_handler_capi.h"
+#include"libcef/capi/cef_resource_bundle_handler_capi.h"
+#include"libcef/capi/cef_scheme_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _cef_app_t;
+
+///
+// Implement this structure to provide handler implementations. Methods will be
+// called by the process and/or thread indicated.
+///
+typedef struct _cef_app_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Provides an opportunity to view and/or modify command-line arguments before
+  // processing by CEF and Chromium. The |process_type| value will be NULL for
+  // the browser process. Do not keep a reference to the cef_command_line_t
+  // object passed to this function. The CefSettings.command_line_args_disabled
+  // value can be used to start with an NULL command-line object. Any values
+  // specified in CefSettings that equate to command-line arguments will be set
+  // before this function is called. Be cautious when using this function to
+  // modify command-line arguments for non-browser processes as this may result
+  // in undefined behavior including crashes.
+  ///
+  void (CEF_CALLBACK *on_before_command_line_processing)(
+      struct _cef_app_t* self, const cef_string_t* process_type,
+      struct _cef_command_line_t* command_line);
+
+  ///
+  // Provides an opportunity to register custom schemes. Do not keep a reference
+  // to the |registrar| object. This function is called on the main thread for
+  // each process and the registered schemes should be the same across all
+  // processes.
+  ///
+  void (CEF_CALLBACK *on_register_custom_schemes)(struct _cef_app_t* self,
+      struct _cef_scheme_registrar_t* registrar);
+
+  ///
+  // Return the handler for resource bundle events. If
+  // CefSettings.pack_loading_disabled is true (1) a handler must be returned.
+  // If no handler is returned resources will be loaded from pack files. This
+  // function is called by the browser and render processes on multiple threads.
+  ///
+  struct _cef_resource_bundle_handler_t* (
+      CEF_CALLBACK *get_resource_bundle_handler)(struct _cef_app_t* self);
+
+  ///
+  // Return the handler for functionality specific to the browser process. This
+  // function is called on multiple threads in the browser process.
+  ///
+  struct _cef_browser_process_handler_t* (
+      CEF_CALLBACK *get_browser_process_handler)(struct _cef_app_t* self);
+
+  ///
+  // Return the handler for functionality specific to the render process. This
+  // function is called on the render process main thread.
+  ///
+  struct _cef_render_process_handler_t* (
+      CEF_CALLBACK *get_render_process_handler)(struct _cef_app_t* self);
+} cef_app_t;
+
+
+///
+// This function should be called from the application entry point function to
+// execute a secondary process. It can be used to run secondary processes from
+// the browser client executable (default behavior) or from a separate
+// executable specified by the CefSettings.browser_subprocess_path value. If
+// called for the browser process (identified by no "type" command-line value)
+// it will return immediately with a value of -1. If called for a recognized
+// secondary process it will block until the process should exit and then return
+// the process exit code. The |application| parameter may be NULL. The
+// |windows_sandbox_info| parameter is only used on Windows and may be NULL (see
+// cef_sandbox_win.h for details).
+///
+CEF_EXPORT int cef_execute_process(const struct _cef_main_args_t* args,
+    cef_app_t* application, void* windows_sandbox_info);
+
+///
+// This function should be called on the main application thread to initialize
+// the CEF browser process. The |application| parameter may be NULL. A return
+// value of true (1) indicates that it succeeded and false (0) indicates that it
+// failed. The |windows_sandbox_info| parameter is only used on Windows and may
+// be NULL (see cef_sandbox_win.h for details).
+///
+CEF_EXPORT int cef_initialize(const struct _cef_main_args_t* args,
+    const struct _cef_settings_t* settings, cef_app_t* application,
+    void* windows_sandbox_info);
+
+///
+// This function should be called on the main application thread to shut down
+// the CEF browser process before the application exits.
+///
+CEF_EXPORT void cef_shutdown();
+
+///
+// Perform a single iteration of CEF message loop processing. This function is
+// used to integrate the CEF message loop into an existing application message
+// loop. Care must be taken to balance performance against excessive CPU usage.
+// This function should only be called on the main application thread and only
+// if cef_initialize() is called with a CefSettings.multi_threaded_message_loop
+// value of false (0). This function will not block.
+///
+CEF_EXPORT void cef_do_message_loop_work();
+
+///
+// Run the CEF message loop. Use this function instead of an application-
+// provided message loop to get the best balance between performance and CPU
+// usage. This function should only be called on the main application thread and
+// only if cef_initialize() is called with a
+// CefSettings.multi_threaded_message_loop value of false (0). This function
+// will block until a quit message is received by the system.
+///
+CEF_EXPORT void cef_run_message_loop();
+
+///
+// Quit the CEF message loop that was started by calling cef_run_message_loop().
+// This function should only be called on the main application thread and only
+// if cef_run_message_loop() was used.
+///
+CEF_EXPORT void cef_quit_message_loop();
+
+///
+// Set to true (1) before calling Windows APIs like TrackPopupMenu that enter a
+// modal message loop. Set to false (0) after exiting the modal message loop.
+///
+CEF_EXPORT void cef_set_osmodal_loop(int osModalLoop);
+
+///
+// Call during process startup to enable High-DPI support on Windows 7 or newer.
+// Older versions of Windows should be left DPI-unaware because they do not
+// support DirectWrite and GDI fonts are kerned very badly.
+///
+CEF_EXPORT void cef_enable_highdpi_support();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_APP_CAPI_H_
diff --git a/src/include/libcef/capi/cef_auth_callback_capi.h b/src/include/libcef/capi/cef_auth_callback_capi.h
new file mode 100644
index 0000000..64f71eb
--- /dev/null
+++ b/src/include/libcef/capi/cef_auth_callback_capi.h
@@ -0,0 +1,75 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_AUTH_CALLBACK_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_AUTH_CALLBACK_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Callback structure used for asynchronous continuation of authentication
+// requests.
+///
+typedef struct _cef_auth_callback_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Continue the authentication request.
+  ///
+  void (CEF_CALLBACK *cont)(struct _cef_auth_callback_t* self,
+      const cef_string_t* username, const cef_string_t* password);
+
+  ///
+  // Cancel the authentication request.
+  ///
+  void (CEF_CALLBACK *cancel)(struct _cef_auth_callback_t* self);
+} cef_auth_callback_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_AUTH_CALLBACK_CAPI_H_
diff --git a/src/include/libcef/capi/cef_base_capi.h b/src/include/libcef/capi/cef_base_capi.h
new file mode 100644
index 0000000..0574d49
--- /dev/null
+++ b/src/include/libcef/capi/cef_base_capi.h
@@ -0,0 +1,90 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+#ifndef CEF_INCLUDE_CAPI_CEF_BASE_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_BASE_CAPI_H_
+
+#include<stdint.h>
+
+#include"libcef/internal/cef_export.h"
+#include"libcef/internal/cef_string.h"
+#include"libcef/internal/cef_string_list.h"
+#include"libcef/internal/cef_string_map.h"
+#include"libcef/internal/cef_string_multimap.h"
+#include"libcef/internal/cef_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///
+// Structure defining the reference count implementation functions. All
+// framework structures must include the cef_base_t structure first.
+///
+typedef struct _cef_base_t {
+  ///
+  // Size of the data structure.
+  ///
+  size_t size;
+
+  ///
+  // Called to increment the reference count for the object. Should be called
+  // for every new copy of a pointer to a given object.
+  ///
+  void (CEF_CALLBACK *add_ref)(struct _cef_base_t* self);
+
+  ///
+  // Called to decrement the reference count for the object. If the reference
+  // count falls to 0 the object should self-delete. Returns true (1) if the
+  // resulting reference count is 0.
+  ///
+  int (CEF_CALLBACK *release)(struct _cef_base_t* self);
+
+  ///
+  // Returns true (1) if the current reference count is 1.
+  ///
+  int (CEF_CALLBACK *has_one_ref)(struct _cef_base_t* self);
+} cef_base_t;
+
+
+// Check that the structure |s|, which is defined with a cef_base_t member named
+// |base|, is large enough to contain the specified member |f|.
+#define CEF_MEMBER_EXISTS(s, f)   \
+  ((intptr_t)&((s)->f) - (intptr_t)(s) + sizeof((s)->f) <= \
+  reinterpret_cast<cef_base_t*>(s)->size)
+
+#define CEF_MEMBER_MISSING(s, f)  (!CEF_MEMBER_EXISTS(s, f) || !((s)->f))
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_BASE_CAPI_H_
diff --git a/src/include/libcef/capi/cef_browser_capi.h b/src/include/libcef/capi/cef_browser_capi.h
new file mode 100644
index 0000000..494c638
--- /dev/null
+++ b/src/include/libcef/capi/cef_browser_capi.h
@@ -0,0 +1,725 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_BROWSER_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_BROWSER_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+#include"libcef/capi/cef_drag_data_capi.h"
+#include"libcef/capi/cef_frame_capi.h"
+#include"libcef/capi/cef_image_capi.h"
+#include"libcef/capi/cef_navigation_entry_capi.h"
+#include"libcef/capi/cef_process_message_capi.h"
+#include"libcef/capi/cef_request_context_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _cef_browser_host_t;
+struct _cef_client_t;
+
+///
+// Structure used to represent a browser window. When used in the browser
+// process the functions of this structure may be called on any thread unless
+// otherwise indicated in the comments. When used in the render process the
+// functions of this structure may only be called on the main thread.
+///
+typedef struct _cef_browser_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns the browser host object. This function can only be called in the
+  // browser process.
+  ///
+  struct _cef_browser_host_t* (CEF_CALLBACK *get_host)(
+      struct _cef_browser_t* self);
+
+  ///
+  // Returns true (1) if the browser can navigate backwards.
+  ///
+  int (CEF_CALLBACK *can_go_back)(struct _cef_browser_t* self);
+
+  ///
+  // Navigate backwards.
+  ///
+  void (CEF_CALLBACK *go_back)(struct _cef_browser_t* self);
+
+  ///
+  // Returns true (1) if the browser can navigate forwards.
+  ///
+  int (CEF_CALLBACK *can_go_forward)(struct _cef_browser_t* self);
+
+  ///
+  // Navigate forwards.
+  ///
+  void (CEF_CALLBACK *go_forward)(struct _cef_browser_t* self);
+
+  ///
+  // Returns true (1) if the browser is currently loading.
+  ///
+  int (CEF_CALLBACK *is_loading)(struct _cef_browser_t* self);
+
+  ///
+  // Reload the current page.
+  ///
+  void (CEF_CALLBACK *reload)(struct _cef_browser_t* self);
+
+  ///
+  // Reload the current page ignoring any cached data.
+  ///
+  void (CEF_CALLBACK *reload_ignore_cache)(struct _cef_browser_t* self);
+
+  ///
+  // Stop loading the page.
+  ///
+  void (CEF_CALLBACK *stop_load)(struct _cef_browser_t* self);
+
+  ///
+  // Returns the globally unique identifier for this browser.
+  ///
+  int (CEF_CALLBACK *get_identifier)(struct _cef_browser_t* self);
+
+  ///
+  // Returns true (1) if this object is pointing to the same handle as |that|
+  // object.
+  ///
+  int (CEF_CALLBACK *is_same)(struct _cef_browser_t* self,
+      struct _cef_browser_t* that);
+
+  ///
+  // Returns true (1) if the window is a popup window.
+  ///
+  int (CEF_CALLBACK *is_popup)(struct _cef_browser_t* self);
+
+  ///
+  // Returns true (1) if a document has been loaded in the browser.
+  ///
+  int (CEF_CALLBACK *has_document)(struct _cef_browser_t* self);
+
+  ///
+  // Returns the main (top-level) frame for the browser window.
+  ///
+  struct _cef_frame_t* (CEF_CALLBACK *get_main_frame)(
+      struct _cef_browser_t* self);
+
+  ///
+  // Returns the focused frame for the browser window.
+  ///
+  struct _cef_frame_t* (CEF_CALLBACK *get_focused_frame)(
+      struct _cef_browser_t* self);
+
+  ///
+  // Returns the frame with the specified identifier, or NULL if not found.
+  ///
+  struct _cef_frame_t* (CEF_CALLBACK *get_frame_byident)(
+      struct _cef_browser_t* self, int64 identifier);
+
+  ///
+  // Returns the frame with the specified name, or NULL if not found.
+  ///
+  struct _cef_frame_t* (CEF_CALLBACK *get_frame)(struct _cef_browser_t* self,
+      const cef_string_t* name);
+
+  ///
+  // Returns the number of frames that currently exist.
+  ///
+  size_t (CEF_CALLBACK *get_frame_count)(struct _cef_browser_t* self);
+
+  ///
+  // Returns the identifiers of all existing frames.
+  ///
+  void (CEF_CALLBACK *get_frame_identifiers)(struct _cef_browser_t* self,
+      size_t* identifiersCount, int64* identifiers);
+
+  ///
+  // Returns the names of all existing frames.
+  ///
+  void (CEF_CALLBACK *get_frame_names)(struct _cef_browser_t* self,
+      cef_string_list_t names);
+
+  ///
+  // Send a message to the specified |target_process|. Returns true (1) if the
+  // message was sent successfully.
+  ///
+  int (CEF_CALLBACK *send_process_message)(struct _cef_browser_t* self,
+      cef_process_id_t target_process,
+      struct _cef_process_message_t* message);
+} cef_browser_t;
+
+
+///
+// Callback structure for cef_browser_host_t::RunFileDialog. The functions of
+// this structure will be called on the browser process UI thread.
+///
+typedef struct _cef_run_file_dialog_callback_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Called asynchronously after the file dialog is dismissed.
+  // |selected_accept_filter| is the 0-based index of the value selected from
+  // the accept filters array passed to cef_browser_host_t::RunFileDialog.
+  // |file_paths| will be a single value or a list of values depending on the
+  // dialog mode. If the selection was cancelled |file_paths| will be NULL.
+  ///
+  void (CEF_CALLBACK *on_file_dialog_dismissed)(
+      struct _cef_run_file_dialog_callback_t* self, int selected_accept_filter,
+      cef_string_list_t file_paths);
+} cef_run_file_dialog_callback_t;
+
+
+///
+// Callback structure for cef_browser_host_t::GetNavigationEntries. The
+// functions of this structure will be called on the browser process UI thread.
+///
+typedef struct _cef_navigation_entry_visitor_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Method that will be executed. Do not keep a reference to |entry| outside of
+  // this callback. Return true (1) to continue visiting entries or false (0) to
+  // stop. |current| is true (1) if this entry is the currently loaded
+  // navigation entry. |index| is the 0-based index of this entry and |total| is
+  // the total number of entries.
+  ///
+  int (CEF_CALLBACK *visit)(struct _cef_navigation_entry_visitor_t* self,
+      struct _cef_navigation_entry_t* entry, int current, int index,
+      int total);
+} cef_navigation_entry_visitor_t;
+
+
+///
+// Callback structure for cef_browser_host_t::PrintToPDF. The functions of this
+// structure will be called on the browser process UI thread.
+///
+typedef struct _cef_pdf_print_callback_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Method that will be executed when the PDF printing has completed. |path| is
+  // the output path. |ok| will be true (1) if the printing completed
+  // successfully or false (0) otherwise.
+  ///
+  void (CEF_CALLBACK *on_pdf_print_finished)(
+      struct _cef_pdf_print_callback_t* self, const cef_string_t* path,
+      int ok);
+} cef_pdf_print_callback_t;
+
+
+///
+// Callback structure for cef_browser_host_t::DownloadImage. The functions of
+// this structure will be called on the browser process UI thread.
+///
+typedef struct _cef_download_image_callback_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Method that will be executed when the image download has completed.
+  // |image_url| is the URL that was downloaded and |http_status_code| is the
+  // resulting HTTP status code. |image| is the resulting image, possibly at
+  // multiple scale factors, or NULL if the download failed.
+  ///
+  void (CEF_CALLBACK *on_download_image_finished)(
+      struct _cef_download_image_callback_t* self,
+      const cef_string_t* image_url, int http_status_code,
+      struct _cef_image_t* image);
+} cef_download_image_callback_t;
+
+
+///
+// Structure used to represent the browser process aspects of a browser window.
+// The functions of this structure can only be called in the browser process.
+// They may be called on any thread in that process unless otherwise indicated
+// in the comments.
+///
+typedef struct _cef_browser_host_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns the hosted browser object.
+  ///
+  struct _cef_browser_t* (CEF_CALLBACK *get_browser)(
+      struct _cef_browser_host_t* self);
+
+  ///
+  // Request that the browser close. The JavaScript 'onbeforeunload' event will
+  // be fired. If |force_close| is false (0) the event handler, if any, will be
+  // allowed to prompt the user and the user can optionally cancel the close. If
+  // |force_close| is true (1) the prompt will not be displayed and the close
+  // will proceed. Results in a call to cef_life_span_handler_t::do_close() if
+  // the event handler allows the close or if |force_close| is true (1). See
+  // cef_life_span_handler_t::do_close() documentation for additional usage
+  // information.
+  ///
+  void (CEF_CALLBACK *close_browser)(struct _cef_browser_host_t* self,
+      int force_close);
+
+  ///
+  // Helper for closing a browser. Call this function from the top-level window
+  // close handler. Internally this calls CloseBrowser(false (0)) if the close
+  // has not yet been initiated. This function returns false (0) while the close
+  // is pending and true (1) after the close has completed. See close_browser()
+  // and cef_life_span_handler_t::do_close() documentation for additional usage
+  // information. This function must be called on the browser process UI thread.
+  ///
+  int (CEF_CALLBACK *try_close_browser)(struct _cef_browser_host_t* self);
+
+  ///
+  // Set whether the browser is focused.
+  ///
+  void (CEF_CALLBACK *set_focus)(struct _cef_browser_host_t* self, int focus);
+
+  ///
+  // Retrieve the window handle for this browser. If this browser is wrapped in
+  // a cef_browser_view_t this function should be called on the browser process
+  // UI thread and it will return the handle for the top-level native window.
+  ///
+  cef_window_handle_t (CEF_CALLBACK *get_window_handle)(
+      struct _cef_browser_host_t* self);
+
+  ///
+  // Retrieve the window handle of the browser that opened this browser. Will
+  // return NULL for non-popup windows or if this browser is wrapped in a
+  // cef_browser_view_t. This function can be used in combination with custom
+  // handling of modal windows.
+  ///
+  cef_window_handle_t (CEF_CALLBACK *get_opener_window_handle)(
+      struct _cef_browser_host_t* self);
+
+  ///
+  // Returns true (1) if this browser is wrapped in a cef_browser_view_t.
+  ///
+  int (CEF_CALLBACK *has_view)(struct _cef_browser_host_t* self);
+
+  ///
+  // Returns the client for this browser.
+  ///
+  struct _cef_client_t* (CEF_CALLBACK *get_client)(
+      struct _cef_browser_host_t* self);
+
+  ///
+  // Returns the request context for this browser.
+  ///
+  struct _cef_request_context_t* (CEF_CALLBACK *get_request_context)(
+      struct _cef_browser_host_t* self);
+
+  ///
+  // Get the current zoom level. The default zoom level is 0.0. This function
+  // can only be called on the UI thread.
+  ///
+  double (CEF_CALLBACK *get_zoom_level)(struct _cef_browser_host_t* self);
+
+  ///
+  // Change the zoom level to the specified value. Specify 0.0 to reset the zoom
+  // level. If called on the UI thread the change will be applied immediately.
+  // Otherwise, the change will be applied asynchronously on the UI thread.
+  ///
+  void (CEF_CALLBACK *set_zoom_level)(struct _cef_browser_host_t* self,
+      double zoomLevel);
+
+  ///
+  // Call to run a file chooser dialog. Only a single file chooser dialog may be
+  // pending at any given time. |mode| represents the type of dialog to display.
+  // |title| to the title to be used for the dialog and may be NULL to show the
+  // default title ("Open" or "Save" depending on the mode). |default_file_path|
+  // is the path with optional directory and/or file name component that will be
+  // initially selected in the dialog. |accept_filters| are used to restrict the
+  // selectable file types and may any combination of (a) valid lower-cased MIME
+  // types (e.g. "text/*" or "image/*"), (b) individual file extensions (e.g.
+  // ".txt" or ".png"), or (c) combined description and file extension delimited
+  // using "|" and ";" (e.g. "Image Types|.png;.gif;.jpg").
+  // |selected_accept_filter| is the 0-based index of the filter that will be
+  // selected by default. |callback| will be executed after the dialog is
+  // dismissed or immediately if another dialog is already pending. The dialog
+  // will be initiated asynchronously on the UI thread.
+  ///
+  void (CEF_CALLBACK *run_file_dialog)(struct _cef_browser_host_t* self,
+      cef_file_dialog_mode_t mode, const cef_string_t* title,
+      const cef_string_t* default_file_path, cef_string_list_t accept_filters,
+      int selected_accept_filter,
+      struct _cef_run_file_dialog_callback_t* callback);
+
+  ///
+  // Download the file at |url| using cef_download_handler_t.
+  ///
+  void (CEF_CALLBACK *start_download)(struct _cef_browser_host_t* self,
+      const cef_string_t* url);
+
+  ///
+  // Download |image_url| and execute |callback| on completion with the images
+  // received from the renderer. If |is_favicon| is true (1) then cookies are
+  // not sent and not accepted during download. Images with density independent
+  // pixel (DIP) sizes larger than |max_image_size| are filtered out from the
+  // image results. Versions of the image at different scale factors may be
+  // downloaded up to the maximum scale factor supported by the system. If there
+  // are no image results <= |max_image_size| then the smallest image is resized
+  // to |max_image_size| and is the only result. A |max_image_size| of 0 means
+  // unlimited. If |bypass_cache| is true (1) then |image_url| is requested from
+  // the server even if it is present in the browser cache.
+  ///
+  void (CEF_CALLBACK *download_image)(struct _cef_browser_host_t* self,
+      const cef_string_t* image_url, int is_favicon, uint32 max_image_size,
+      int bypass_cache, struct _cef_download_image_callback_t* callback);
+
+  ///
+  // Print the current browser contents.
+  ///
+  void (CEF_CALLBACK *print)(struct _cef_browser_host_t* self);
+
+  ///
+  // Print the current browser contents to the PDF file specified by |path| and
+  // execute |callback| on completion. The caller is responsible for deleting
+  // |path| when done. For PDF printing to work on Linux you must implement the
+  // cef_print_handler_t::GetPdfPaperSize function.
+  ///
+  void (CEF_CALLBACK *print_to_pdf)(struct _cef_browser_host_t* self,
+      const cef_string_t* path,
+      const struct _cef_pdf_print_settings_t* settings,
+      struct _cef_pdf_print_callback_t* callback);
+
+  ///
+  // Search for |searchText|. |identifier| can be used to have multiple searches
+  // running simultaniously. |forward| indicates whether to search forward or
+  // backward within the page. |matchCase| indicates whether the search should
+  // be case-sensitive. |findNext| indicates whether this is the first request
+  // or a follow-up. The cef_find_handler_t instance, if any, returned via
+  // cef_client_t::GetFindHandler will be called to report find results.
+  ///
+  void (CEF_CALLBACK *find)(struct _cef_browser_host_t* self, int identifier,
+      const cef_string_t* searchText, int forward, int matchCase,
+      int findNext);
+
+  ///
+  // Cancel all searches that are currently going on.
+  ///
+  void (CEF_CALLBACK *stop_finding)(struct _cef_browser_host_t* self,
+      int clearSelection);
+
+  ///
+  // Open developer tools in its own window. If |inspect_element_at| is non-
+  // NULL the element at the specified (x,y) location will be inspected. The
+  // |windowInfo| parameter will be ignored if this browser is wrapped in a
+  // cef_browser_view_t.
+  ///
+  void (CEF_CALLBACK *show_dev_tools)(struct _cef_browser_host_t* self,
+      const struct _cef_window_info_t* windowInfo,
+      struct _cef_client_t* client,
+      const struct _cef_browser_settings_t* settings,
+      const cef_point_t* inspect_element_at);
+
+  ///
+  // Explicitly close the developer tools window if one exists for this browser
+  // instance.
+  ///
+  void (CEF_CALLBACK *close_dev_tools)(struct _cef_browser_host_t* self);
+
+  ///
+  // Retrieve a snapshot of current navigation entries as values sent to the
+  // specified visitor. If |current_only| is true (1) only the current
+  // navigation entry will be sent, otherwise all navigation entries will be
+  // sent.
+  ///
+  void (CEF_CALLBACK *get_navigation_entries)(struct _cef_browser_host_t* self,
+      struct _cef_navigation_entry_visitor_t* visitor, int current_only);
+
+  ///
+  // Set whether mouse cursor change is disabled.
+  ///
+  void (CEF_CALLBACK *set_mouse_cursor_change_disabled)(
+      struct _cef_browser_host_t* self, int disabled);
+
+  ///
+  // Returns true (1) if mouse cursor change is disabled.
+  ///
+  int (CEF_CALLBACK *is_mouse_cursor_change_disabled)(
+      struct _cef_browser_host_t* self);
+
+  ///
+  // If a misspelled word is currently selected in an editable node calling this
+  // function will replace it with the specified |word|.
+  ///
+  void (CEF_CALLBACK *replace_misspelling)(struct _cef_browser_host_t* self,
+      const cef_string_t* word);
+
+  ///
+  // Add the specified |word| to the spelling dictionary.
+  ///
+  void (CEF_CALLBACK *add_word_to_dictionary)(struct _cef_browser_host_t* self,
+      const cef_string_t* word);
+
+  ///
+  // Returns true (1) if window rendering is disabled.
+  ///
+  int (CEF_CALLBACK *is_window_rendering_disabled)(
+      struct _cef_browser_host_t* self);
+
+  ///
+  // Notify the browser that the widget has been resized. The browser will first
+  // call cef_render_handler_t::GetViewRect to get the new size and then call
+  // cef_render_handler_t::OnPaint asynchronously with the updated regions. This
+  // function is only used when window rendering is disabled.
+  ///
+  void (CEF_CALLBACK *was_resized)(struct _cef_browser_host_t* self);
+
+  ///
+  // Notify the browser that it has been hidden or shown. Layouting and
+  // cef_render_handler_t::OnPaint notification will stop when the browser is
+  // hidden. This function is only used when window rendering is disabled.
+  ///
+  void (CEF_CALLBACK *was_hidden)(struct _cef_browser_host_t* self, int hidden);
+
+  ///
+  // Send a notification to the browser that the screen info has changed. The
+  // browser will then call cef_render_handler_t::GetScreenInfo to update the
+  // screen information with the new values. This simulates moving the webview
+  // window from one display to another, or changing the properties of the
+  // current display. This function is only used when window rendering is
+  // disabled.
+  ///
+  void (CEF_CALLBACK *notify_screen_info_changed)(
+      struct _cef_browser_host_t* self);
+
+  ///
+  // Invalidate the view. The browser will call cef_render_handler_t::OnPaint
+  // asynchronously. This function is only used when window rendering is
+  // disabled.
+  ///
+  void (CEF_CALLBACK *invalidate)(struct _cef_browser_host_t* self,
+      cef_paint_element_type_t type);
+
+  ///
+  // Send a key event to the browser.
+  ///
+  void (CEF_CALLBACK *send_key_event)(struct _cef_browser_host_t* self,
+      const struct _cef_key_event_t* event);
+
+  ///
+  // Send a mouse click event to the browser. The |x| and |y| coordinates are
+  // relative to the upper-left corner of the view.
+  ///
+  void (CEF_CALLBACK *send_mouse_click_event)(struct _cef_browser_host_t* self,
+      const struct _cef_mouse_event_t* event, cef_mouse_button_type_t type,
+      int mouseUp, int clickCount);
+
+  ///
+  // Send a mouse move event to the browser. The |x| and |y| coordinates are
+  // relative to the upper-left corner of the view.
+  ///
+  void (CEF_CALLBACK *send_mouse_move_event)(struct _cef_browser_host_t* self,
+      const struct _cef_mouse_event_t* event, int mouseLeave);
+
+  ///
+  // Send a mouse wheel event to the browser. The |x| and |y| coordinates are
+  // relative to the upper-left corner of the view. The |deltaX| and |deltaY|
+  // values represent the movement delta in the X and Y directions respectively.
+  // In order to scroll inside select popups with window rendering disabled
+  // cef_render_handler_t::GetScreenPoint should be implemented properly.
+  ///
+  void (CEF_CALLBACK *send_mouse_wheel_event)(struct _cef_browser_host_t* self,
+      const struct _cef_mouse_event_t* event, int deltaX, int deltaY);
+
+  ///
+  // Send a focus event to the browser.
+  ///
+  void (CEF_CALLBACK *send_focus_event)(struct _cef_browser_host_t* self,
+      int setFocus);
+
+  ///
+  // Send a capture lost event to the browser.
+  ///
+  void (CEF_CALLBACK *send_capture_lost_event)(
+      struct _cef_browser_host_t* self);
+
+  ///
+  // Notify the browser that the window hosting it is about to be moved or
+  // resized. This function is only used on Windows and Linux.
+  ///
+  void (CEF_CALLBACK *notify_move_or_resize_started)(
+      struct _cef_browser_host_t* self);
+
+  ///
+  // Returns the maximum rate in frames per second (fps) that
+  // cef_render_handler_t:: OnPaint will be called for a windowless browser. The
+  // actual fps may be lower if the browser cannot generate frames at the
+  // requested rate. The minimum value is 1 and the maximum value is 60 (default
+  // 30). This function can only be called on the UI thread.
+  ///
+  int (CEF_CALLBACK *get_windowless_frame_rate)(
+      struct _cef_browser_host_t* self);
+
+  ///
+  // Set the maximum rate in frames per second (fps) that cef_render_handler_t::
+  // OnPaint will be called for a windowless browser. The actual fps may be
+  // lower if the browser cannot generate frames at the requested rate. The
+  // minimum value is 1 and the maximum value is 60 (default 30). Can also be
+  // set at browser creation via cef_browser_tSettings.windowless_frame_rate.
+  ///
+  void (CEF_CALLBACK *set_windowless_frame_rate)(
+      struct _cef_browser_host_t* self, int frame_rate);
+
+  ///
+  // Get the NSTextInputContext implementation for enabling IME on Mac when
+  // window rendering is disabled.
+  ///
+  cef_text_input_context_t (CEF_CALLBACK *get_nstext_input_context)(
+      struct _cef_browser_host_t* self);
+
+  ///
+  // Handles a keyDown event prior to passing it through the NSTextInputClient
+  // machinery.
+  ///
+  void (CEF_CALLBACK *handle_key_event_before_text_input_client)(
+      struct _cef_browser_host_t* self, cef_event_handle_t keyEvent);
+
+  ///
+  // Performs any additional actions after NSTextInputClient handles the event.
+  ///
+  void (CEF_CALLBACK *handle_key_event_after_text_input_client)(
+      struct _cef_browser_host_t* self, cef_event_handle_t keyEvent);
+
+  ///
+  // Call this function when the user drags the mouse into the web view (before
+  // calling DragTargetDragOver/DragTargetLeave/DragTargetDrop). |drag_data|
+  // should not contain file contents as this type of data is not allowed to be
+  // dragged into the web view. File contents can be removed using
+  // cef_drag_data_t::ResetFileContents (for example, if |drag_data| comes from
+  // cef_render_handler_t::StartDragging). This function is only used when
+  // window rendering is disabled.
+  ///
+  void (CEF_CALLBACK *drag_target_drag_enter)(struct _cef_browser_host_t* self,
+      struct _cef_drag_data_t* drag_data,
+      const struct _cef_mouse_event_t* event,
+      cef_drag_operations_mask_t allowed_ops);
+
+  ///
+  // Call this function each time the mouse is moved across the web view during
+  // a drag operation (after calling DragTargetDragEnter and before calling
+  // DragTargetDragLeave/DragTargetDrop). This function is only used when window
+  // rendering is disabled.
+  ///
+  void (CEF_CALLBACK *drag_target_drag_over)(struct _cef_browser_host_t* self,
+      const struct _cef_mouse_event_t* event,
+      cef_drag_operations_mask_t allowed_ops);
+
+  ///
+  // Call this function when the user drags the mouse out of the web view (after
+  // calling DragTargetDragEnter). This function is only used when window
+  // rendering is disabled.
+  ///
+  void (CEF_CALLBACK *drag_target_drag_leave)(struct _cef_browser_host_t* self);
+
+  ///
+  // Call this function when the user completes the drag operation by dropping
+  // the object onto the web view (after calling DragTargetDragEnter). The
+  // object being dropped is |drag_data|, given as an argument to the previous
+  // DragTargetDragEnter call. This function is only used when window rendering
+  // is disabled.
+  ///
+  void (CEF_CALLBACK *drag_target_drop)(struct _cef_browser_host_t* self,
+      const struct _cef_mouse_event_t* event);
+
+  ///
+  // Call this function when the drag operation started by a
+  // cef_render_handler_t::StartDragging call has ended either in a drop or by
+  // being cancelled. |x| and |y| are mouse coordinates relative to the upper-
+  // left corner of the view. If the web view is both the drag source and the
+  // drag target then all DragTarget* functions should be called before
+  // DragSource* mthods. This function is only used when window rendering is
+  // disabled.
+  ///
+  void (CEF_CALLBACK *drag_source_ended_at)(struct _cef_browser_host_t* self,
+      int x, int y, cef_drag_operations_mask_t op);
+
+  ///
+  // Call this function when the drag operation started by a
+  // cef_render_handler_t::StartDragging call has completed. This function may
+  // be called immediately without first calling DragSourceEndedAt to cancel a
+  // drag operation. If the web view is both the drag source and the drag target
+  // then all DragTarget* functions should be called before DragSource* mthods.
+  // This function is only used when window rendering is disabled.
+  ///
+  void (CEF_CALLBACK *drag_source_system_drag_ended)(
+      struct _cef_browser_host_t* self);
+} cef_browser_host_t;
+
+
+///
+// Create a new browser window using the window parameters specified by
+// |windowInfo|. All values will be copied internally and the actual window will
+// be created on the UI thread. If |request_context| is NULL the global request
+// context will be used. This function can be called on any browser process
+// thread and will not block.
+///
+CEF_EXPORT int cef_browser_host_create_browser(
+    const cef_window_info_t* windowInfo, struct _cef_client_t* client,
+    const cef_string_t* url, const struct _cef_browser_settings_t* settings,
+    struct _cef_request_context_t* request_context);
+
+///
+// Create a new browser window using the window parameters specified by
+// |windowInfo|. If |request_context| is NULL the global request context will be
+// used. This function can only be called on the browser process UI thread.
+///
+CEF_EXPORT cef_browser_t* cef_browser_host_create_browser_sync(
+    const cef_window_info_t* windowInfo, struct _cef_client_t* client,
+    const cef_string_t* url, const struct _cef_browser_settings_t* settings,
+    struct _cef_request_context_t* request_context);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_BROWSER_CAPI_H_
diff --git a/src/include/libcef/capi/cef_browser_process_handler_capi.h b/src/include/libcef/capi/cef_browser_process_handler_capi.h
new file mode 100644
index 0000000..7c7a711
--- /dev/null
+++ b/src/include/libcef/capi/cef_browser_process_handler_capi.h
@@ -0,0 +1,104 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_BROWSER_PROCESS_HANDLER_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_BROWSER_PROCESS_HANDLER_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+#include"libcef/capi/cef_command_line_capi.h"
+#include"libcef/capi/cef_print_handler_capi.h"
+#include"libcef/capi/cef_values_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Structure used to implement browser process callbacks. The functions of this
+// structure will be called on the browser process main thread unless otherwise
+// indicated.
+///
+typedef struct _cef_browser_process_handler_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Called on the browser process UI thread immediately after the CEF context
+  // has been initialized.
+  ///
+  void (CEF_CALLBACK *on_context_initialized)(
+      struct _cef_browser_process_handler_t* self);
+
+  ///
+  // Called before a child process is launched. Will be called on the browser
+  // process UI thread when launching a render process and on the browser
+  // process IO thread when launching a GPU or plugin process. Provides an
+  // opportunity to modify the child process command line. Do not keep a
+  // reference to |command_line| outside of this function.
+  ///
+  void (CEF_CALLBACK *on_before_child_process_launch)(
+      struct _cef_browser_process_handler_t* self,
+      struct _cef_command_line_t* command_line);
+
+  ///
+  // Called on the browser process IO thread after the main thread has been
+  // created for a new render process. Provides an opportunity to specify extra
+  // information that will be passed to
+  // cef_render_process_handler_t::on_render_thread_created() in the render
+  // process. Do not keep a reference to |extra_info| outside of this function.
+  ///
+  void (CEF_CALLBACK *on_render_process_thread_created)(
+      struct _cef_browser_process_handler_t* self,
+      struct _cef_list_value_t* extra_info);
+
+  ///
+  // Return the handler for printing on Linux. If a print handler is not
+  // provided then printing will not be supported on the Linux platform.
+  ///
+  struct _cef_print_handler_t* (CEF_CALLBACK *get_print_handler)(
+      struct _cef_browser_process_handler_t* self);
+} cef_browser_process_handler_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_BROWSER_PROCESS_HANDLER_CAPI_H_
diff --git a/src/include/libcef/capi/cef_callback_capi.h b/src/include/libcef/capi/cef_callback_capi.h
new file mode 100644
index 0000000..b56d588
--- /dev/null
+++ b/src/include/libcef/capi/cef_callback_capi.h
@@ -0,0 +1,89 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_CALLBACK_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_CALLBACK_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Generic callback structure used for asynchronous continuation.
+///
+typedef struct _cef_callback_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Continue processing.
+  ///
+  void (CEF_CALLBACK *cont)(struct _cef_callback_t* self);
+
+  ///
+  // Cancel processing.
+  ///
+  void (CEF_CALLBACK *cancel)(struct _cef_callback_t* self);
+} cef_callback_t;
+
+
+///
+// Generic callback structure used for asynchronous completion.
+///
+typedef struct _cef_completion_callback_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Method that will be called once the task is complete.
+  ///
+  void (CEF_CALLBACK *on_complete)(struct _cef_completion_callback_t* self);
+} cef_completion_callback_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_CALLBACK_CAPI_H_
diff --git a/src/include/libcef/capi/cef_client_capi.h b/src/include/libcef/capi/cef_client_capi.h
new file mode 100644
index 0000000..b09e197
--- /dev/null
+++ b/src/include/libcef/capi/cef_client_capi.h
@@ -0,0 +1,176 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_CLIENT_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_CLIENT_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+#include"libcef/capi/cef_context_menu_handler_capi.h"
+#include"libcef/capi/cef_dialog_handler_capi.h"
+#include"libcef/capi/cef_display_handler_capi.h"
+#include"libcef/capi/cef_download_handler_capi.h"
+#include"libcef/capi/cef_drag_handler_capi.h"
+#include"libcef/capi/cef_find_handler_capi.h"
+#include"libcef/capi/cef_focus_handler_capi.h"
+#include"libcef/capi/cef_geolocation_handler_capi.h"
+#include"libcef/capi/cef_jsdialog_handler_capi.h"
+#include"libcef/capi/cef_keyboard_handler_capi.h"
+#include"libcef/capi/cef_life_span_handler_capi.h"
+#include"libcef/capi/cef_load_handler_capi.h"
+#include"libcef/capi/cef_process_message_capi.h"
+#include"libcef/capi/cef_render_handler_capi.h"
+#include"libcef/capi/cef_request_handler_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Implement this structure to provide handler implementations.
+///
+typedef struct _cef_client_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Return the handler for context menus. If no handler is provided the default
+  // implementation will be used.
+  ///
+  struct _cef_context_menu_handler_t* (CEF_CALLBACK *get_context_menu_handler)(
+      struct _cef_client_t* self);
+
+  ///
+  // Return the handler for dialogs. If no handler is provided the default
+  // implementation will be used.
+  ///
+  struct _cef_dialog_handler_t* (CEF_CALLBACK *get_dialog_handler)(
+      struct _cef_client_t* self);
+
+  ///
+  // Return the handler for browser display state events.
+  ///
+  struct _cef_display_handler_t* (CEF_CALLBACK *get_display_handler)(
+      struct _cef_client_t* self);
+
+  ///
+  // Return the handler for download events. If no handler is returned downloads
+  // will not be allowed.
+  ///
+  struct _cef_download_handler_t* (CEF_CALLBACK *get_download_handler)(
+      struct _cef_client_t* self);
+
+  ///
+  // Return the handler for drag events.
+  ///
+  struct _cef_drag_handler_t* (CEF_CALLBACK *get_drag_handler)(
+      struct _cef_client_t* self);
+
+  ///
+  // Return the handler for find result events.
+  ///
+  struct _cef_find_handler_t* (CEF_CALLBACK *get_find_handler)(
+      struct _cef_client_t* self);
+
+  ///
+  // Return the handler for focus events.
+  ///
+  struct _cef_focus_handler_t* (CEF_CALLBACK *get_focus_handler)(
+      struct _cef_client_t* self);
+
+  ///
+  // Return the handler for geolocation permissions requests. If no handler is
+  // provided geolocation access will be denied by default.
+  ///
+  struct _cef_geolocation_handler_t* (CEF_CALLBACK *get_geolocation_handler)(
+      struct _cef_client_t* self);
+
+  ///
+  // Return the handler for JavaScript dialogs. If no handler is provided the
+  // default implementation will be used.
+  ///
+  struct _cef_jsdialog_handler_t* (CEF_CALLBACK *get_jsdialog_handler)(
+      struct _cef_client_t* self);
+
+  ///
+  // Return the handler for keyboard events.
+  ///
+  struct _cef_keyboard_handler_t* (CEF_CALLBACK *get_keyboard_handler)(
+      struct _cef_client_t* self);
+
+  ///
+  // Return the handler for browser life span events.
+  ///
+  struct _cef_life_span_handler_t* (CEF_CALLBACK *get_life_span_handler)(
+      struct _cef_client_t* self);
+
+  ///
+  // Return the handler for browser load status events.
+  ///
+  struct _cef_load_handler_t* (CEF_CALLBACK *get_load_handler)(
+      struct _cef_client_t* self);
+
+  ///
+  // Return the handler for off-screen rendering events.
+  ///
+  struct _cef_render_handler_t* (CEF_CALLBACK *get_render_handler)(
+      struct _cef_client_t* self);
+
+  ///
+  // Return the handler for browser request events.
+  ///
+  struct _cef_request_handler_t* (CEF_CALLBACK *get_request_handler)(
+      struct _cef_client_t* self);
+
+  ///
+  // Called when a new message is received from a different process. Return true
+  // (1) if the message was handled or false (0) otherwise. Do not keep a
+  // reference to or attempt to access the message outside of this callback.
+  ///
+  int (CEF_CALLBACK *on_process_message_received)(struct _cef_client_t* self,
+      struct _cef_browser_t* browser, cef_process_id_t source_process,
+      struct _cef_process_message_t* message);
+} cef_client_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_CLIENT_CAPI_H_
diff --git a/src/include/libcef/capi/cef_command_line_capi.h b/src/include/libcef/capi/cef_command_line_capi.h
new file mode 100644
index 0000000..dab9ad6
--- /dev/null
+++ b/src/include/libcef/capi/cef_command_line_capi.h
@@ -0,0 +1,213 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_COMMAND_LINE_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_COMMAND_LINE_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Structure used to create and/or parse command line arguments. Arguments with
+// '--', '-' and, on Windows, '/' prefixes are considered switches. Switches
+// will always precede any arguments without switch prefixes. Switches can
+// optionally have a value specified using the '=' delimiter (e.g.
+// "-switch=value"). An argument of "--" will terminate switch parsing with all
+// subsequent tokens, regardless of prefix, being interpreted as non-switch
+// arguments. Switch names are considered case-insensitive. This structure can
+// be used before cef_initialize() is called.
+///
+typedef struct _cef_command_line_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns true (1) if this object is valid. Do not call any other functions
+  // if this function returns false (0).
+  ///
+  int (CEF_CALLBACK *is_valid)(struct _cef_command_line_t* self);
+
+  ///
+  // Returns true (1) if the values of this object are read-only. Some APIs may
+  // expose read-only objects.
+  ///
+  int (CEF_CALLBACK *is_read_only)(struct _cef_command_line_t* self);
+
+  ///
+  // Returns a writable copy of this object.
+  ///
+  struct _cef_command_line_t* (CEF_CALLBACK *copy)(
+      struct _cef_command_line_t* self);
+
+  ///
+  // Initialize the command line with the specified |argc| and |argv| values.
+  // The first argument must be the name of the program. This function is only
+  // supported on non-Windows platforms.
+  ///
+  void (CEF_CALLBACK *init_from_argv)(struct _cef_command_line_t* self,
+      int argc, const char* const* argv);
+
+  ///
+  // Initialize the command line with the string returned by calling
+  // GetCommandLineW(). This function is only supported on Windows.
+  ///
+  void (CEF_CALLBACK *init_from_string)(struct _cef_command_line_t* self,
+      const cef_string_t* command_line);
+
+  ///
+  // Reset the command-line switches and arguments but leave the program
+  // component unchanged.
+  ///
+  void (CEF_CALLBACK *reset)(struct _cef_command_line_t* self);
+
+  ///
+  // Retrieve the original command line string as a vector of strings. The argv
+  // array: { program, [(--|-|/)switch[=value]]*, [--], [argument]* }
+  ///
+  void (CEF_CALLBACK *get_argv)(struct _cef_command_line_t* self,
+      cef_string_list_t argv);
+
+  ///
+  // Constructs and returns the represented command line string. Use this
+  // function cautiously because quoting behavior is unclear.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_command_line_string)(
+      struct _cef_command_line_t* self);
+
+  ///
+  // Get the program part of the command line string (the first item).
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_program)(
+      struct _cef_command_line_t* self);
+
+  ///
+  // Set the program part of the command line string (the first item).
+  ///
+  void (CEF_CALLBACK *set_program)(struct _cef_command_line_t* self,
+      const cef_string_t* program);
+
+  ///
+  // Returns true (1) if the command line has switches.
+  ///
+  int (CEF_CALLBACK *has_switches)(struct _cef_command_line_t* self);
+
+  ///
+  // Returns true (1) if the command line contains the given switch.
+  ///
+  int (CEF_CALLBACK *has_switch)(struct _cef_command_line_t* self,
+      const cef_string_t* name);
+
+  ///
+  // Returns the value associated with the given switch. If the switch has no
+  // value or isn't present this function returns the NULL string.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_switch_value)(
+      struct _cef_command_line_t* self, const cef_string_t* name);
+
+  ///
+  // Returns the map of switch names and values. If a switch has no value an
+  // NULL string is returned.
+  ///
+  void (CEF_CALLBACK *get_switches)(struct _cef_command_line_t* self,
+      cef_string_map_t switches);
+
+  ///
+  // Add a switch to the end of the command line. If the switch has no value
+  // pass an NULL value string.
+  ///
+  void (CEF_CALLBACK *append_switch)(struct _cef_command_line_t* self,
+      const cef_string_t* name);
+
+  ///
+  // Add a switch with the specified value to the end of the command line.
+  ///
+  void (CEF_CALLBACK *append_switch_with_value)(
+      struct _cef_command_line_t* self, const cef_string_t* name,
+      const cef_string_t* value);
+
+  ///
+  // True if there are remaining command line arguments.
+  ///
+  int (CEF_CALLBACK *has_arguments)(struct _cef_command_line_t* self);
+
+  ///
+  // Get the remaining command line arguments.
+  ///
+  void (CEF_CALLBACK *get_arguments)(struct _cef_command_line_t* self,
+      cef_string_list_t arguments);
+
+  ///
+  // Add an argument to the end of the command line.
+  ///
+  void (CEF_CALLBACK *append_argument)(struct _cef_command_line_t* self,
+      const cef_string_t* argument);
+
+  ///
+  // Insert a command before the current command. Common for debuggers, like
+  // "valgrind" or "gdb --args".
+  ///
+  void (CEF_CALLBACK *prepend_wrapper)(struct _cef_command_line_t* self,
+      const cef_string_t* wrapper);
+} cef_command_line_t;
+
+
+///
+// Create a new cef_command_line_t instance.
+///
+CEF_EXPORT cef_command_line_t* cef_command_line_create();
+
+///
+// Returns the singleton global cef_command_line_t object. The returned object
+// will be read-only.
+///
+CEF_EXPORT cef_command_line_t* cef_command_line_get_global();
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_COMMAND_LINE_CAPI_H_
diff --git a/src/include/libcef/capi/cef_context_menu_handler_capi.h b/src/include/libcef/capi/cef_context_menu_handler_capi.h
new file mode 100644
index 0000000..05966ff
--- /dev/null
+++ b/src/include/libcef/capi/cef_context_menu_handler_capi.h
@@ -0,0 +1,291 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_CONTEXT_MENU_HANDLER_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_CONTEXT_MENU_HANDLER_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+#include"libcef/capi/cef_browser_capi.h"
+#include"libcef/capi/cef_frame_capi.h"
+#include"libcef/capi/cef_menu_model_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _cef_context_menu_params_t;
+
+///
+// Callback structure used for continuation of custom context menu display.
+///
+typedef struct _cef_run_context_menu_callback_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Complete context menu display by selecting the specified |command_id| and
+  // |event_flags|.
+  ///
+  void (CEF_CALLBACK *cont)(struct _cef_run_context_menu_callback_t* self,
+      int command_id, cef_event_flags_t event_flags);
+
+  ///
+  // Cancel context menu display.
+  ///
+  void (CEF_CALLBACK *cancel)(struct _cef_run_context_menu_callback_t* self);
+} cef_run_context_menu_callback_t;
+
+
+///
+// Implement this structure to handle context menu events. The functions of this
+// structure will be called on the UI thread.
+///
+typedef struct _cef_context_menu_handler_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Called before a context menu is displayed. |params| provides information
+  // about the context menu state. |model| initially contains the default
+  // context menu. The |model| can be cleared to show no context menu or
+  // modified to show a custom menu. Do not keep references to |params| or
+  // |model| outside of this callback.
+  ///
+  void (CEF_CALLBACK *on_before_context_menu)(
+      struct _cef_context_menu_handler_t* self, struct _cef_browser_t* browser,
+      struct _cef_frame_t* frame, struct _cef_context_menu_params_t* params,
+      struct _cef_menu_model_t* model);
+
+  ///
+  // Called to allow custom display of the context menu. |params| provides
+  // information about the context menu state. |model| contains the context menu
+  // model resulting from OnBeforeContextMenu. For custom display return true
+  // (1) and execute |callback| either synchronously or asynchronously with the
+  // selected command ID. For default display return false (0). Do not keep
+  // references to |params| or |model| outside of this callback.
+  ///
+  int (CEF_CALLBACK *run_context_menu)(struct _cef_context_menu_handler_t* self,
+      struct _cef_browser_t* browser, struct _cef_frame_t* frame,
+      struct _cef_context_menu_params_t* params,
+      struct _cef_menu_model_t* model,
+      struct _cef_run_context_menu_callback_t* callback);
+
+  ///
+  // Called to execute a command selected from the context menu. Return true (1)
+  // if the command was handled or false (0) for the default implementation. See
+  // cef_menu_id_t for the command ids that have default implementations. All
+  // user-defined command ids should be between MENU_ID_USER_FIRST and
+  // MENU_ID_USER_LAST. |params| will have the same values as what was passed to
+  // on_before_context_menu(). Do not keep a reference to |params| outside of
+  // this callback.
+  ///
+  int (CEF_CALLBACK *on_context_menu_command)(
+      struct _cef_context_menu_handler_t* self, struct _cef_browser_t* browser,
+      struct _cef_frame_t* frame, struct _cef_context_menu_params_t* params,
+      int command_id, cef_event_flags_t event_flags);
+
+  ///
+  // Called when the context menu is dismissed irregardless of whether the menu
+  // was NULL or a command was selected.
+  ///
+  void (CEF_CALLBACK *on_context_menu_dismissed)(
+      struct _cef_context_menu_handler_t* self, struct _cef_browser_t* browser,
+      struct _cef_frame_t* frame);
+} cef_context_menu_handler_t;
+
+
+///
+// Provides information about the context menu state. The ethods of this
+// structure can only be accessed on browser process the UI thread.
+///
+typedef struct _cef_context_menu_params_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns the X coordinate of the mouse where the context menu was invoked.
+  // Coords are relative to the associated RenderView's origin.
+  ///
+  int (CEF_CALLBACK *get_xcoord)(struct _cef_context_menu_params_t* self);
+
+  ///
+  // Returns the Y coordinate of the mouse where the context menu was invoked.
+  // Coords are relative to the associated RenderView's origin.
+  ///
+  int (CEF_CALLBACK *get_ycoord)(struct _cef_context_menu_params_t* self);
+
+  ///
+  // Returns flags representing the type of node that the context menu was
+  // invoked on.
+  ///
+  cef_context_menu_type_flags_t (CEF_CALLBACK *get_type_flags)(
+      struct _cef_context_menu_params_t* self);
+
+  ///
+  // Returns the URL of the link, if any, that encloses the node that the
+  // context menu was invoked on.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_link_url)(
+      struct _cef_context_menu_params_t* self);
+
+  ///
+  // Returns the link URL, if any, to be used ONLY for "copy link address". We
+  // don't validate this field in the frontend process.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_unfiltered_link_url)(
+      struct _cef_context_menu_params_t* self);
+
+  ///
+  // Returns the source URL, if any, for the element that the context menu was
+  // invoked on. Example of elements with source URLs are img, audio, and video.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_source_url)(
+      struct _cef_context_menu_params_t* self);
+
+  ///
+  // Returns true (1) if the context menu was invoked on an image which has non-
+  // NULL contents.
+  ///
+  int (CEF_CALLBACK *has_image_contents)(
+      struct _cef_context_menu_params_t* self);
+
+  ///
+  // Returns the URL of the top level page that the context menu was invoked on.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_page_url)(
+      struct _cef_context_menu_params_t* self);
+
+  ///
+  // Returns the URL of the subframe that the context menu was invoked on.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_frame_url)(
+      struct _cef_context_menu_params_t* self);
+
+  ///
+  // Returns the character encoding of the subframe that the context menu was
+  // invoked on.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_frame_charset)(
+      struct _cef_context_menu_params_t* self);
+
+  ///
+  // Returns the type of context node that the context menu was invoked on.
+  ///
+  cef_context_menu_media_type_t (CEF_CALLBACK *get_media_type)(
+      struct _cef_context_menu_params_t* self);
+
+  ///
+  // Returns flags representing the actions supported by the media element, if
+  // any, that the context menu was invoked on.
+  ///
+  cef_context_menu_media_state_flags_t (CEF_CALLBACK *get_media_state_flags)(
+      struct _cef_context_menu_params_t* self);
+
+  ///
+  // Returns the text of the selection, if any, that the context menu was
+  // invoked on.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_selection_text)(
+      struct _cef_context_menu_params_t* self);
+
+  ///
+  // Returns the text of the misspelled word, if any, that the context menu was
+  // invoked on.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_misspelled_word)(
+      struct _cef_context_menu_params_t* self);
+
+  ///
+  // Returns true (1) if suggestions exist, false (0) otherwise. Fills in
+  // |suggestions| from the spell check service for the misspelled word if there
+  // is one.
+  ///
+  int (CEF_CALLBACK *get_dictionary_suggestions)(
+      struct _cef_context_menu_params_t* self, cef_string_list_t suggestions);
+
+  ///
+  // Returns true (1) if the context menu was invoked on an editable node.
+  ///
+  int (CEF_CALLBACK *is_editable)(struct _cef_context_menu_params_t* self);
+
+  ///
+  // Returns true (1) if the context menu was invoked on an editable node where
+  // spell-check is enabled.
+  ///
+  int (CEF_CALLBACK *is_spell_check_enabled)(
+      struct _cef_context_menu_params_t* self);
+
+  ///
+  // Returns flags representing the actions supported by the editable node, if
+  // any, that the context menu was invoked on.
+  ///
+  cef_context_menu_edit_state_flags_t (CEF_CALLBACK *get_edit_state_flags)(
+      struct _cef_context_menu_params_t* self);
+
+  ///
+  // Returns true (1) if the context menu contains items specified by the
+  // renderer process (for example, plugin placeholder or pepper plugin menu
+  // items).
+  ///
+  int (CEF_CALLBACK *is_custom_menu)(struct _cef_context_menu_params_t* self);
+
+  ///
+  // Returns true (1) if the context menu was invoked from a pepper plugin.
+  ///
+  int (CEF_CALLBACK *is_pepper_menu)(struct _cef_context_menu_params_t* self);
+} cef_context_menu_params_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_CONTEXT_MENU_HANDLER_CAPI_H_
diff --git a/src/include/libcef/capi/cef_cookie_capi.h b/src/include/libcef/capi/cef_cookie_capi.h
new file mode 100644
index 0000000..10ba193
--- /dev/null
+++ b/src/include/libcef/capi/cef_cookie_capi.h
@@ -0,0 +1,232 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_COOKIE_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_COOKIE_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+#include"libcef/capi/cef_callback_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _cef_cookie_visitor_t;
+struct _cef_delete_cookies_callback_t;
+struct _cef_set_cookie_callback_t;
+
+///
+// Structure used for managing cookies. The functions of this structure may be
+// called on any thread unless otherwise indicated.
+///
+typedef struct _cef_cookie_manager_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Set the schemes supported by this manager. The default schemes ("http",
+  // "https", "ws" and "wss") will always be supported. If |callback| is non-
+  // NULL it will be executed asnychronously on the IO thread after the change
+  // has been applied. Must be called before any cookies are accessed.
+  ///
+  void (CEF_CALLBACK *set_supported_schemes)(struct _cef_cookie_manager_t* self,
+      cef_string_list_t schemes, struct _cef_completion_callback_t* callback);
+
+  ///
+  // Visit all cookies on the IO thread. The returned cookies are ordered by
+  // longest path, then by earliest creation date. Returns false (0) if cookies
+  // cannot be accessed.
+  ///
+  int (CEF_CALLBACK *visit_all_cookies)(struct _cef_cookie_manager_t* self,
+      struct _cef_cookie_visitor_t* visitor);
+
+  ///
+  // Visit a subset of cookies on the IO thread. The results are filtered by the
+  // given url scheme, host, domain and path. If |includeHttpOnly| is true (1)
+  // HTTP-only cookies will also be included in the results. The returned
+  // cookies are ordered by longest path, then by earliest creation date.
+  // Returns false (0) if cookies cannot be accessed.
+  ///
+  int (CEF_CALLBACK *visit_url_cookies)(struct _cef_cookie_manager_t* self,
+      const cef_string_t* url, int includeHttpOnly,
+      struct _cef_cookie_visitor_t* visitor);
+
+  ///
+  // Sets a cookie given a valid URL and explicit user-provided cookie
+  // attributes. This function expects each attribute to be well-formed. It will
+  // check for disallowed characters (e.g. the ';' character is disallowed
+  // within the cookie value attribute) and fail without setting the cookie if
+  // such characters are found. If |callback| is non-NULL it will be executed
+  // asnychronously on the IO thread after the cookie has been set. Returns
+  // false (0) if an invalid URL is specified or if cookies cannot be accessed.
+  ///
+  int (CEF_CALLBACK *set_cookie)(struct _cef_cookie_manager_t* self,
+      const cef_string_t* url, const struct _cef_cookie_t* cookie,
+      struct _cef_set_cookie_callback_t* callback);
+
+  ///
+  // Delete all cookies that match the specified parameters. If both |url| and
+  // |cookie_name| values are specified all host and domain cookies matching
+  // both will be deleted. If only |url| is specified all host cookies (but not
+  // domain cookies) irrespective of path will be deleted. If |url| is NULL all
+  // cookies for all hosts and domains will be deleted. If |callback| is non-
+  // NULL it will be executed asnychronously on the IO thread after the cookies
+  // have been deleted. Returns false (0) if a non-NULL invalid URL is specified
+  // or if cookies cannot be accessed. Cookies can alternately be deleted using
+  // the Visit*Cookies() functions.
+  ///
+  int (CEF_CALLBACK *delete_cookies)(struct _cef_cookie_manager_t* self,
+      const cef_string_t* url, const cef_string_t* cookie_name,
+      struct _cef_delete_cookies_callback_t* callback);
+
+  ///
+  // Sets the directory path that will be used for storing cookie data. If
+  // |path| is NULL data will be stored in memory only. Otherwise, data will be
+  // stored at the specified |path|. To persist session cookies (cookies without
+  // an expiry date or validity interval) set |persist_session_cookies| to true
+  // (1). Session cookies are generally intended to be transient and most Web
+  // browsers do not persist them. If |callback| is non-NULL it will be executed
+  // asnychronously on the IO thread after the manager's storage has been
+  // initialized. Returns false (0) if cookies cannot be accessed.
+  ///
+  int (CEF_CALLBACK *set_storage_path)(struct _cef_cookie_manager_t* self,
+      const cef_string_t* path, int persist_session_cookies,
+      struct _cef_completion_callback_t* callback);
+
+  ///
+  // Flush the backing store (if any) to disk. If |callback| is non-NULL it will
+  // be executed asnychronously on the IO thread after the flush is complete.
+  // Returns false (0) if cookies cannot be accessed.
+  ///
+  int (CEF_CALLBACK *flush_store)(struct _cef_cookie_manager_t* self,
+      struct _cef_completion_callback_t* callback);
+} cef_cookie_manager_t;
+
+
+///
+// Returns the global cookie manager. By default data will be stored at
+// CefSettings.cache_path if specified or in memory otherwise. If |callback| is
+// non-NULL it will be executed asnychronously on the IO thread after the
+// manager's storage has been initialized. Using this function is equivalent to
+// calling cef_request_tContext::cef_request_context_get_global_context()->get_d
+// efault_cookie_manager().
+///
+CEF_EXPORT cef_cookie_manager_t* cef_cookie_manager_get_global_manager(
+    struct _cef_completion_callback_t* callback);
+
+///
+// Creates a new cookie manager. If |path| is NULL data will be stored in memory
+// only. Otherwise, data will be stored at the specified |path|. To persist
+// session cookies (cookies without an expiry date or validity interval) set
+// |persist_session_cookies| to true (1). Session cookies are generally intended
+// to be transient and most Web browsers do not persist them. If |callback| is
+// non-NULL it will be executed asnychronously on the IO thread after the
+// manager's storage has been initialized.
+///
+CEF_EXPORT cef_cookie_manager_t* cef_cookie_manager_create_manager(
+    const cef_string_t* path, int persist_session_cookies,
+    struct _cef_completion_callback_t* callback);
+
+
+///
+// Structure to implement for visiting cookie values. The functions of this
+// structure will always be called on the IO thread.
+///
+typedef struct _cef_cookie_visitor_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Method that will be called once for each cookie. |count| is the 0-based
+  // index for the current cookie. |total| is the total number of cookies. Set
+  // |deleteCookie| to true (1) to delete the cookie currently being visited.
+  // Return false (0) to stop visiting cookies. This function may never be
+  // called if no cookies are found.
+  ///
+  int (CEF_CALLBACK *visit)(struct _cef_cookie_visitor_t* self,
+      const struct _cef_cookie_t* cookie, int count, int total,
+      int* deleteCookie);
+} cef_cookie_visitor_t;
+
+
+///
+// Structure to implement to be notified of asynchronous completion via
+// cef_cookie_manager_t::set_cookie().
+///
+typedef struct _cef_set_cookie_callback_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Method that will be called upon completion. |success| will be true (1) if
+  // the cookie was set successfully.
+  ///
+  void (CEF_CALLBACK *on_complete)(struct _cef_set_cookie_callback_t* self,
+      int success);
+} cef_set_cookie_callback_t;
+
+
+///
+// Structure to implement to be notified of asynchronous completion via
+// cef_cookie_manager_t::delete_cookies().
+///
+typedef struct _cef_delete_cookies_callback_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Method that will be called upon completion. |num_deleted| will be the
+  // number of cookies that were deleted or -1 if unknown.
+  ///
+  void (CEF_CALLBACK *on_complete)(struct _cef_delete_cookies_callback_t* self,
+      int num_deleted);
+} cef_delete_cookies_callback_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_COOKIE_CAPI_H_
diff --git a/src/include/libcef/capi/cef_dialog_handler_capi.h b/src/include/libcef/capi/cef_dialog_handler_capi.h
new file mode 100644
index 0000000..355ec2e
--- /dev/null
+++ b/src/include/libcef/capi/cef_dialog_handler_capi.h
@@ -0,0 +1,112 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_DIALOG_HANDLER_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_DIALOG_HANDLER_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+#include"libcef/capi/cef_browser_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Callback structure for asynchronous continuation of file dialog requests.
+///
+typedef struct _cef_file_dialog_callback_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Continue the file selection. |selected_accept_filter| should be the 0-based
+  // index of the value selected from the accept filters array passed to
+  // cef_dialog_handler_t::OnFileDialog. |file_paths| should be a single value
+  // or a list of values depending on the dialog mode. An NULL |file_paths|
+  // value is treated the same as calling cancel().
+  ///
+  void (CEF_CALLBACK *cont)(struct _cef_file_dialog_callback_t* self,
+      int selected_accept_filter, cef_string_list_t file_paths);
+
+  ///
+  // Cancel the file selection.
+  ///
+  void (CEF_CALLBACK *cancel)(struct _cef_file_dialog_callback_t* self);
+} cef_file_dialog_callback_t;
+
+
+///
+// Implement this structure to handle dialog events. The functions of this
+// structure will be called on the browser process UI thread.
+///
+typedef struct _cef_dialog_handler_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Called to run a file chooser dialog. |mode| represents the type of dialog
+  // to display. |title| to the title to be used for the dialog and may be NULL
+  // to show the default title ("Open" or "Save" depending on the mode).
+  // |default_file_path| is the path with optional directory and/or file name
+  // component that should be initially selected in the dialog. |accept_filters|
+  // are used to restrict the selectable file types and may any combination of
+  // (a) valid lower-cased MIME types (e.g. "text/*" or "image/*"), (b)
+  // individual file extensions (e.g. ".txt" or ".png"), or (c) combined
+  // description and file extension delimited using "|" and ";" (e.g. "Image
+  // Types|.png;.gif;.jpg"). |selected_accept_filter| is the 0-based index of
+  // the filter that should be selected by default. To display a custom dialog
+  // return true (1) and execute |callback| either inline or at a later time. To
+  // display the default dialog return false (0).
+  ///
+  int (CEF_CALLBACK *on_file_dialog)(struct _cef_dialog_handler_t* self,
+      struct _cef_browser_t* browser, cef_file_dialog_mode_t mode,
+      const cef_string_t* title, const cef_string_t* default_file_path,
+      cef_string_list_t accept_filters, int selected_accept_filter,
+      struct _cef_file_dialog_callback_t* callback);
+} cef_dialog_handler_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_DIALOG_HANDLER_CAPI_H_
diff --git a/src/include/libcef/capi/cef_display_handler_capi.h b/src/include/libcef/capi/cef_display_handler_capi.h
new file mode 100644
index 0000000..46ba685
--- /dev/null
+++ b/src/include/libcef/capi/cef_display_handler_capi.h
@@ -0,0 +1,122 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_DISPLAY_HANDLER_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_DISPLAY_HANDLER_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+#include"libcef/capi/cef_browser_capi.h"
+#include"libcef/capi/cef_frame_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Implement this structure to handle events related to browser display state.
+// The functions of this structure will be called on the UI thread.
+///
+typedef struct _cef_display_handler_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Called when a frame's address has changed.
+  ///
+  void (CEF_CALLBACK *on_address_change)(struct _cef_display_handler_t* self,
+      struct _cef_browser_t* browser, struct _cef_frame_t* frame,
+      const cef_string_t* url);
+
+  ///
+  // Called when the page title changes.
+  ///
+  void (CEF_CALLBACK *on_title_change)(struct _cef_display_handler_t* self,
+      struct _cef_browser_t* browser, const cef_string_t* title);
+
+  ///
+  // Called when the page icon changes.
+  ///
+  void (CEF_CALLBACK *on_favicon_urlchange)(struct _cef_display_handler_t* self,
+      struct _cef_browser_t* browser, cef_string_list_t icon_urls);
+
+  ///
+  // Called when web content in the page has toggled fullscreen mode. If
+  // |fullscreen| is true (1) the content will automatically be sized to fill
+  // the browser content area. If |fullscreen| is false (0) the content will
+  // automatically return to its original size and position. The client is
+  // responsible for resizing the browser if desired.
+  ///
+  void (CEF_CALLBACK *on_fullscreen_mode_change)(
+      struct _cef_display_handler_t* self, struct _cef_browser_t* browser,
+      int fullscreen);
+
+  ///
+  // Called when the browser is about to display a tooltip. |text| contains the
+  // text that will be displayed in the tooltip. To handle the display of the
+  // tooltip yourself return true (1). Otherwise, you can optionally modify
+  // |text| and then return false (0) to allow the browser to display the
+  // tooltip. When window rendering is disabled the application is responsible
+  // for drawing tooltips and the return value is ignored.
+  ///
+  int (CEF_CALLBACK *on_tooltip)(struct _cef_display_handler_t* self,
+      struct _cef_browser_t* browser, cef_string_t* text);
+
+  ///
+  // Called when the browser receives a status message. |value| contains the
+  // text that will be displayed in the status message.
+  ///
+  void (CEF_CALLBACK *on_status_message)(struct _cef_display_handler_t* self,
+      struct _cef_browser_t* browser, const cef_string_t* value);
+
+  ///
+  // Called to display a console message. Return true (1) to stop the message
+  // from being output to the console.
+  ///
+  int (CEF_CALLBACK *on_console_message)(struct _cef_display_handler_t* self,
+      struct _cef_browser_t* browser, const cef_string_t* message,
+      const cef_string_t* source, int line);
+} cef_display_handler_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_DISPLAY_HANDLER_CAPI_H_
diff --git a/src/include/libcef/capi/cef_dom_capi.h b/src/include/libcef/capi/cef_dom_capi.h
new file mode 100644
index 0000000..1e69aea
--- /dev/null
+++ b/src/include/libcef/capi/cef_dom_capi.h
@@ -0,0 +1,341 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_DOM_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_DOM_CAPI_H_
+#pragma once
+
+#include "libcef/capi/cef_base_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _cef_domdocument_t;
+struct _cef_domnode_t;
+
+///
+// Structure to implement for visiting the DOM. The functions of this structure
+// will be called on the render process main thread.
+///
+typedef struct _cef_domvisitor_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Method executed for visiting the DOM. The document object passed to this
+  // function represents a snapshot of the DOM at the time this function is
+  // executed. DOM objects are only valid for the scope of this function. Do not
+  // keep references to or attempt to access any DOM objects outside the scope
+  // of this function.
+  ///
+  void (CEF_CALLBACK *visit)(struct _cef_domvisitor_t* self,
+      struct _cef_domdocument_t* document);
+} cef_domvisitor_t;
+
+
+///
+// Structure used to represent a DOM document. The functions of this structure
+// should only be called on the render process main thread thread.
+///
+typedef struct _cef_domdocument_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns the document type.
+  ///
+  cef_dom_document_type_t (CEF_CALLBACK *get_type)(
+      struct _cef_domdocument_t* self);
+
+  ///
+  // Returns the root document node.
+  ///
+  struct _cef_domnode_t* (CEF_CALLBACK *get_document)(
+      struct _cef_domdocument_t* self);
+
+  ///
+  // Returns the BODY node of an HTML document.
+  ///
+  struct _cef_domnode_t* (CEF_CALLBACK *get_body)(
+      struct _cef_domdocument_t* self);
+
+  ///
+  // Returns the HEAD node of an HTML document.
+  ///
+  struct _cef_domnode_t* (CEF_CALLBACK *get_head)(
+      struct _cef_domdocument_t* self);
+
+  ///
+  // Returns the title of an HTML document.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_title)(
+      struct _cef_domdocument_t* self);
+
+  ///
+  // Returns the document element with the specified ID value.
+  ///
+  struct _cef_domnode_t* (CEF_CALLBACK *get_element_by_id)(
+      struct _cef_domdocument_t* self, const cef_string_t* id);
+
+  ///
+  // Returns the node that currently has keyboard focus.
+  ///
+  struct _cef_domnode_t* (CEF_CALLBACK *get_focused_node)(
+      struct _cef_domdocument_t* self);
+
+  ///
+  // Returns true (1) if a portion of the document is selected.
+  ///
+  int (CEF_CALLBACK *has_selection)(struct _cef_domdocument_t* self);
+
+  ///
+  // Returns the selection offset within the start node.
+  ///
+  int (CEF_CALLBACK *get_selection_start_offset)(
+      struct _cef_domdocument_t* self);
+
+  ///
+  // Returns the selection offset within the end node.
+  ///
+  int (CEF_CALLBACK *get_selection_end_offset)(struct _cef_domdocument_t* self);
+
+  ///
+  // Returns the contents of this selection as markup.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_selection_as_markup)(
+      struct _cef_domdocument_t* self);
+
+  ///
+  // Returns the contents of this selection as text.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_selection_as_text)(
+      struct _cef_domdocument_t* self);
+
+  ///
+  // Returns the base URL for the document.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_base_url)(
+      struct _cef_domdocument_t* self);
+
+  ///
+  // Returns a complete URL based on the document base URL and the specified
+  // partial URL.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_complete_url)(
+      struct _cef_domdocument_t* self, const cef_string_t* partialURL);
+} cef_domdocument_t;
+
+
+///
+// Structure used to represent a DOM node. The functions of this structure
+// should only be called on the render process main thread.
+///
+typedef struct _cef_domnode_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns the type for this node.
+  ///
+  cef_dom_node_type_t (CEF_CALLBACK *get_type)(struct _cef_domnode_t* self);
+
+  ///
+  // Returns true (1) if this is a text node.
+  ///
+  int (CEF_CALLBACK *is_text)(struct _cef_domnode_t* self);
+
+  ///
+  // Returns true (1) if this is an element node.
+  ///
+  int (CEF_CALLBACK *is_element)(struct _cef_domnode_t* self);
+
+  ///
+  // Returns true (1) if this is an editable node.
+  ///
+  int (CEF_CALLBACK *is_editable)(struct _cef_domnode_t* self);
+
+  ///
+  // Returns true (1) if this is a form control element node.
+  ///
+  int (CEF_CALLBACK *is_form_control_element)(struct _cef_domnode_t* self);
+
+  ///
+  // Returns the type of this form control element node.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_form_control_element_type)(
+      struct _cef_domnode_t* self);
+
+  ///
+  // Returns true (1) if this object is pointing to the same handle as |that|
+  // object.
+  ///
+  int (CEF_CALLBACK *is_same)(struct _cef_domnode_t* self,
+      struct _cef_domnode_t* that);
+
+  ///
+  // Returns the name of this node.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_name)(struct _cef_domnode_t* self);
+
+  ///
+  // Returns the value of this node.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_value)(struct _cef_domnode_t* self);
+
+  ///
+  // Set the value of this node. Returns true (1) on success.
+  ///
+  int (CEF_CALLBACK *set_value)(struct _cef_domnode_t* self,
+      const cef_string_t* value);
+
+  ///
+  // Returns the contents of this node as markup.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_as_markup)(
+      struct _cef_domnode_t* self);
+
+  ///
+  // Returns the document associated with this node.
+  ///
+  struct _cef_domdocument_t* (CEF_CALLBACK *get_document)(
+      struct _cef_domnode_t* self);
+
+  ///
+  // Returns the parent node.
+  ///
+  struct _cef_domnode_t* (CEF_CALLBACK *get_parent)(
+      struct _cef_domnode_t* self);
+
+  ///
+  // Returns the previous sibling node.
+  ///
+  struct _cef_domnode_t* (CEF_CALLBACK *get_previous_sibling)(
+      struct _cef_domnode_t* self);
+
+  ///
+  // Returns the next sibling node.
+  ///
+  struct _cef_domnode_t* (CEF_CALLBACK *get_next_sibling)(
+      struct _cef_domnode_t* self);
+
+  ///
+  // Returns true (1) if this node has child nodes.
+  ///
+  int (CEF_CALLBACK *has_children)(struct _cef_domnode_t* self);
+
+  ///
+  // Return the first child node.
+  ///
+  struct _cef_domnode_t* (CEF_CALLBACK *get_first_child)(
+      struct _cef_domnode_t* self);
+
+  ///
+  // Returns the last child node.
+  ///
+  struct _cef_domnode_t* (CEF_CALLBACK *get_last_child)(
+      struct _cef_domnode_t* self);
+
+
+  // The following functions are valid only for element nodes.
+
+  ///
+  // Returns the tag name of this element.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_element_tag_name)(
+      struct _cef_domnode_t* self);
+
+  ///
+  // Returns true (1) if this element has attributes.
+  ///
+  int (CEF_CALLBACK *has_element_attributes)(struct _cef_domnode_t* self);
+
+  ///
+  // Returns true (1) if this element has an attribute named |attrName|.
+  ///
+  int (CEF_CALLBACK *has_element_attribute)(struct _cef_domnode_t* self,
+      const cef_string_t* attrName);
+
+  ///
+  // Returns the element attribute named |attrName|.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_element_attribute)(
+      struct _cef_domnode_t* self, const cef_string_t* attrName);
+
+  ///
+  // Returns a map of all element attributes.
+  ///
+  void (CEF_CALLBACK *get_element_attributes)(struct _cef_domnode_t* self,
+      cef_string_map_t attrMap);
+
+  ///
+  // Set the value for the element attribute named |attrName|. Returns true (1)
+  // on success.
+  ///
+  int (CEF_CALLBACK *set_element_attribute)(struct _cef_domnode_t* self,
+      const cef_string_t* attrName, const cef_string_t* value);
+
+  ///
+  // Returns the inner text of the element.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_element_inner_text)(
+      struct _cef_domnode_t* self);
+} cef_domnode_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_DOM_CAPI_H_
diff --git a/src/include/libcef/capi/cef_download_handler_capi.h b/src/include/libcef/capi/cef_download_handler_capi.h
new file mode 100644
index 0000000..d601c7f
--- /dev/null
+++ b/src/include/libcef/capi/cef_download_handler_capi.h
@@ -0,0 +1,137 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_DOWNLOAD_HANDLER_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_DOWNLOAD_HANDLER_CAPI_H_
+#pragma once
+
+#include "libcef/capi/cef_base_capi.h"
+#include "libcef/capi/cef_browser_capi.h"
+#include "libcef/capi/cef_download_item_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Callback structure used to asynchronously continue a download.
+///
+typedef struct _cef_before_download_callback_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Call to continue the download. Set |download_path| to the full file path
+  // for the download including the file name or leave blank to use the
+  // suggested name and the default temp directory. Set |show_dialog| to true
+  // (1) if you do wish to show the default "Save As" dialog.
+  ///
+  void (CEF_CALLBACK *cont)(struct _cef_before_download_callback_t* self,
+      const cef_string_t* download_path, int show_dialog);
+} cef_before_download_callback_t;
+
+
+///
+// Callback structure used to asynchronously cancel a download.
+///
+typedef struct _cef_download_item_callback_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Call to cancel the download.
+  ///
+  void (CEF_CALLBACK *cancel)(struct _cef_download_item_callback_t* self);
+
+  ///
+  // Call to pause the download.
+  ///
+  void (CEF_CALLBACK *pause)(struct _cef_download_item_callback_t* self);
+
+  ///
+  // Call to resume the download.
+  ///
+  void (CEF_CALLBACK *resume)(struct _cef_download_item_callback_t* self);
+} cef_download_item_callback_t;
+
+
+///
+// Structure used to handle file downloads. The functions of this structure will
+// called on the browser process UI thread.
+///
+typedef struct _cef_download_handler_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Called before a download begins. |suggested_name| is the suggested name for
+  // the download file. By default the download will be canceled. Execute
+  // |callback| either asynchronously or in this function to continue the
+  // download if desired. Do not keep a reference to |download_item| outside of
+  // this function.
+  ///
+  void (CEF_CALLBACK *on_before_download)(struct _cef_download_handler_t* self,
+      struct _cef_browser_t* browser,
+      struct _cef_download_item_t* download_item,
+      const cef_string_t* suggested_name,
+      struct _cef_before_download_callback_t* callback);
+
+  ///
+  // Called when a download's status or progress information has been updated.
+  // This may be called multiple times before and after on_before_download().
+  // Execute |callback| either asynchronously or in this function to cancel the
+  // download if desired. Do not keep a reference to |download_item| outside of
+  // this function.
+  ///
+  void (CEF_CALLBACK *on_download_updated)(struct _cef_download_handler_t* self,
+      struct _cef_browser_t* browser,
+      struct _cef_download_item_t* download_item,
+      struct _cef_download_item_callback_t* callback);
+} cef_download_handler_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_DOWNLOAD_HANDLER_CAPI_H_
diff --git a/src/include/libcef/capi/cef_download_item_capi.h b/src/include/libcef/capi/cef_download_item_capi.h
new file mode 100644
index 0000000..cd4b679
--- /dev/null
+++ b/src/include/libcef/capi/cef_download_item_capi.h
@@ -0,0 +1,162 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_DOWNLOAD_ITEM_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_DOWNLOAD_ITEM_CAPI_H_
+#pragma once
+
+#include "libcef/capi/cef_base_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Structure used to represent a download item.
+///
+typedef struct _cef_download_item_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns true (1) if this object is valid. Do not call any other functions
+  // if this function returns false (0).
+  ///
+  int (CEF_CALLBACK *is_valid)(struct _cef_download_item_t* self);
+
+  ///
+  // Returns true (1) if the download is in progress.
+  ///
+  int (CEF_CALLBACK *is_in_progress)(struct _cef_download_item_t* self);
+
+  ///
+  // Returns true (1) if the download is complete.
+  ///
+  int (CEF_CALLBACK *is_complete)(struct _cef_download_item_t* self);
+
+  ///
+  // Returns true (1) if the download has been canceled or interrupted.
+  ///
+  int (CEF_CALLBACK *is_canceled)(struct _cef_download_item_t* self);
+
+  ///
+  // Returns a simple speed estimate in bytes/s.
+  ///
+  int64 (CEF_CALLBACK *get_current_speed)(struct _cef_download_item_t* self);
+
+  ///
+  // Returns the rough percent complete or -1 if the receive total size is
+  // unknown.
+  ///
+  int (CEF_CALLBACK *get_percent_complete)(struct _cef_download_item_t* self);
+
+  ///
+  // Returns the total number of bytes.
+  ///
+  int64 (CEF_CALLBACK *get_total_bytes)(struct _cef_download_item_t* self);
+
+  ///
+  // Returns the number of received bytes.
+  ///
+  int64 (CEF_CALLBACK *get_received_bytes)(struct _cef_download_item_t* self);
+
+  ///
+  // Returns the time that the download started.
+  ///
+  cef_time_t (CEF_CALLBACK *get_start_time)(struct _cef_download_item_t* self);
+
+  ///
+  // Returns the time that the download ended.
+  ///
+  cef_time_t (CEF_CALLBACK *get_end_time)(struct _cef_download_item_t* self);
+
+  ///
+  // Returns the full path to the downloaded or downloading file.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_full_path)(
+      struct _cef_download_item_t* self);
+
+  ///
+  // Returns the unique identifier for this download.
+  ///
+  uint32 (CEF_CALLBACK *get_id)(struct _cef_download_item_t* self);
+
+  ///
+  // Returns the URL.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_url)(
+      struct _cef_download_item_t* self);
+
+  ///
+  // Returns the original URL before any redirections.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_original_url)(
+      struct _cef_download_item_t* self);
+
+  ///
+  // Returns the suggested file name.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_suggested_file_name)(
+      struct _cef_download_item_t* self);
+
+  ///
+  // Returns the content disposition.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_content_disposition)(
+      struct _cef_download_item_t* self);
+
+  ///
+  // Returns the mime type.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_mime_type)(
+      struct _cef_download_item_t* self);
+} cef_download_item_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_DOWNLOAD_ITEM_CAPI_H_
diff --git a/src/include/libcef/capi/cef_drag_data_capi.h b/src/include/libcef/capi/cef_drag_data_capi.h
new file mode 100644
index 0000000..f976dd7
--- /dev/null
+++ b/src/include/libcef/capi/cef_drag_data_capi.h
@@ -0,0 +1,211 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_DRAG_DATA_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_DRAG_DATA_CAPI_H_
+#pragma once
+
+#include "libcef/capi/cef_base_capi.h"
+#include "libcef/capi/cef_stream_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Structure used to represent drag data. The functions of this structure may be
+// called on any thread.
+///
+typedef struct _cef_drag_data_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns a copy of the current object.
+  ///
+  struct _cef_drag_data_t* (CEF_CALLBACK *clone)(struct _cef_drag_data_t* self);
+
+  ///
+  // Returns true (1) if this object is read-only.
+  ///
+  int (CEF_CALLBACK *is_read_only)(struct _cef_drag_data_t* self);
+
+  ///
+  // Returns true (1) if the drag data is a link.
+  ///
+  int (CEF_CALLBACK *is_link)(struct _cef_drag_data_t* self);
+
+  ///
+  // Returns true (1) if the drag data is a text or html fragment.
+  ///
+  int (CEF_CALLBACK *is_fragment)(struct _cef_drag_data_t* self);
+
+  ///
+  // Returns true (1) if the drag data is a file.
+  ///
+  int (CEF_CALLBACK *is_file)(struct _cef_drag_data_t* self);
+
+  ///
+  // Return the link URL that is being dragged.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_link_url)(
+      struct _cef_drag_data_t* self);
+
+  ///
+  // Return the title associated with the link being dragged.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_link_title)(
+      struct _cef_drag_data_t* self);
+
+  ///
+  // Return the metadata, if any, associated with the link being dragged.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_link_metadata)(
+      struct _cef_drag_data_t* self);
+
+  ///
+  // Return the plain text fragment that is being dragged.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_fragment_text)(
+      struct _cef_drag_data_t* self);
+
+  ///
+  // Return the text/html fragment that is being dragged.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_fragment_html)(
+      struct _cef_drag_data_t* self);
+
+  ///
+  // Return the base URL that the fragment came from. This value is used for
+  // resolving relative URLs and may be NULL.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_fragment_base_url)(
+      struct _cef_drag_data_t* self);
+
+  ///
+  // Return the name of the file being dragged out of the browser window.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_file_name)(
+      struct _cef_drag_data_t* self);
+
+  ///
+  // Write the contents of the file being dragged out of the web view into
+  // |writer|. Returns the number of bytes sent to |writer|. If |writer| is NULL
+  // this function will return the size of the file contents in bytes. Call
+  // get_file_name() to get a suggested name for the file.
+  ///
+  size_t (CEF_CALLBACK *get_file_contents)(struct _cef_drag_data_t* self,
+      struct _cef_stream_writer_t* writer);
+
+  ///
+  // Retrieve the list of file names that are being dragged into the browser
+  // window.
+  ///
+  int (CEF_CALLBACK *get_file_names)(struct _cef_drag_data_t* self,
+      cef_string_list_t names);
+
+  ///
+  // Set the link URL that is being dragged.
+  ///
+  void (CEF_CALLBACK *set_link_url)(struct _cef_drag_data_t* self,
+      const cef_string_t* url);
+
+  ///
+  // Set the title associated with the link being dragged.
+  ///
+  void (CEF_CALLBACK *set_link_title)(struct _cef_drag_data_t* self,
+      const cef_string_t* title);
+
+  ///
+  // Set the metadata associated with the link being dragged.
+  ///
+  void (CEF_CALLBACK *set_link_metadata)(struct _cef_drag_data_t* self,
+      const cef_string_t* data);
+
+  ///
+  // Set the plain text fragment that is being dragged.
+  ///
+  void (CEF_CALLBACK *set_fragment_text)(struct _cef_drag_data_t* self,
+      const cef_string_t* text);
+
+  ///
+  // Set the text/html fragment that is being dragged.
+  ///
+  void (CEF_CALLBACK *set_fragment_html)(struct _cef_drag_data_t* self,
+      const cef_string_t* html);
+
+  ///
+  // Set the base URL that the fragment came from.
+  ///
+  void (CEF_CALLBACK *set_fragment_base_url)(struct _cef_drag_data_t* self,
+      const cef_string_t* base_url);
+
+  ///
+  // Reset the file contents. You should do this before calling
+  // cef_browser_host_t::DragTargetDragEnter as the web view does not allow us
+  // to drag in this kind of data.
+  ///
+  void (CEF_CALLBACK *reset_file_contents)(struct _cef_drag_data_t* self);
+
+  ///
+  // Add a file that is being dragged into the webview.
+  ///
+  void (CEF_CALLBACK *add_file)(struct _cef_drag_data_t* self,
+      const cef_string_t* path, const cef_string_t* display_name);
+} cef_drag_data_t;
+
+
+///
+// Create a new cef_drag_data_t object.
+///
+CEF_EXPORT cef_drag_data_t* cef_drag_data_create();
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_DRAG_DATA_CAPI_H_
diff --git a/src/include/libcef/capi/cef_drag_handler_capi.h b/src/include/libcef/capi/cef_drag_handler_capi.h
new file mode 100644
index 0000000..47a7bea
--- /dev/null
+++ b/src/include/libcef/capi/cef_drag_handler_capi.h
@@ -0,0 +1,87 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_DRAG_HANDLER_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_DRAG_HANDLER_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+#include"libcef/capi/cef_browser_capi.h"
+#include"libcef/capi/cef_drag_data_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Implement this structure to handle events related to dragging. The functions
+// of this structure will be called on the UI thread.
+///
+typedef struct _cef_drag_handler_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Called when an external drag event enters the browser window. |dragData|
+  // contains the drag event data and |mask| represents the type of drag
+  // operation. Return false (0) for default drag handling behavior or true (1)
+  // to cancel the drag event.
+  ///
+  int (CEF_CALLBACK *on_drag_enter)(struct _cef_drag_handler_t* self,
+      struct _cef_browser_t* browser, struct _cef_drag_data_t* dragData,
+      cef_drag_operations_mask_t mask);
+
+  ///
+  // Called whenever draggable regions for the browser window change. These can
+  // be specified using the '-webkit-app-region: drag/no-drag' CSS-property. If
+  // draggable regions are never defined in a document this function will also
+  // never be called. If the last draggable region is removed from a document
+  // this function will be called with an NULL vector.
+  ///
+  void (CEF_CALLBACK *on_draggable_regions_changed)(
+      struct _cef_drag_handler_t* self, struct _cef_browser_t* browser,
+      size_t regionsCount, cef_draggable_region_t const* regions);
+} cef_drag_handler_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_DRAG_HANDLER_CAPI_H_
diff --git a/src/include/libcef/capi/cef_find_handler_capi.h b/src/include/libcef/capi/cef_find_handler_capi.h
new file mode 100644
index 0000000..0ec9442
--- /dev/null
+++ b/src/include/libcef/capi/cef_find_handler_capi.h
@@ -0,0 +1,78 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_FIND_HANDLER_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_FIND_HANDLER_CAPI_H_
+#pragma once
+
+#include "libcef/capi/cef_base_capi.h"
+#include "libcef/capi/cef_browser_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Implement this structure to handle events related to find results. The
+// functions of this structure will be called on the UI thread.
+///
+typedef struct _cef_find_handler_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Called to report find results returned by cef_browser_host_t::find().
+  // |identifer| is the identifier passed to find(), |count| is the number of
+  // matches currently identified, |selectionRect| is the location of where the
+  // match was found (in window coordinates), |activeMatchOrdinal| is the
+  // current position in the search results, and |finalUpdate| is true (1) if
+  // this is the last find notification.
+  ///
+  void (CEF_CALLBACK *on_find_result)(struct _cef_find_handler_t* self,
+      struct _cef_browser_t* browser, int identifier, int count,
+      const cef_rect_t* selectionRect, int activeMatchOrdinal,
+      int finalUpdate);
+} cef_find_handler_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_FIND_HANDLER_CAPI_H_
diff --git a/src/include/libcef/capi/cef_focus_handler_capi.h b/src/include/libcef/capi/cef_focus_handler_capi.h
new file mode 100644
index 0000000..2c33b94
--- /dev/null
+++ b/src/include/libcef/capi/cef_focus_handler_capi.h
@@ -0,0 +1,90 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_FOCUS_HANDLER_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_FOCUS_HANDLER_CAPI_H_
+#pragma once
+
+#include "libcef/capi/cef_base_capi.h"
+#include "libcef/capi/cef_browser_capi.h"
+#include "libcef/capi/cef_dom_capi.h"
+#include "libcef/capi/cef_frame_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Implement this structure to handle events related to focus. The functions of
+// this structure will be called on the UI thread.
+///
+typedef struct _cef_focus_handler_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Called when the browser component is about to loose focus. For instance, if
+  // focus was on the last HTML element and the user pressed the TAB key. |next|
+  // will be true (1) if the browser is giving focus to the next component and
+  // false (0) if the browser is giving focus to the previous component.
+  ///
+  void (CEF_CALLBACK *on_take_focus)(struct _cef_focus_handler_t* self,
+      struct _cef_browser_t* browser, int next);
+
+  ///
+  // Called when the browser component is requesting focus. |source| indicates
+  // where the focus request is originating from. Return false (0) to allow the
+  // focus to be set or true (1) to cancel setting the focus.
+  ///
+  int (CEF_CALLBACK *on_set_focus)(struct _cef_focus_handler_t* self,
+      struct _cef_browser_t* browser, cef_focus_source_t source);
+
+  ///
+  // Called when the browser component has received focus.
+  ///
+  void (CEF_CALLBACK *on_got_focus)(struct _cef_focus_handler_t* self,
+      struct _cef_browser_t* browser);
+} cef_focus_handler_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_FOCUS_HANDLER_CAPI_H_
diff --git a/src/include/libcef/capi/cef_frame_capi.h b/src/include/libcef/capi/cef_frame_capi.h
new file mode 100644
index 0000000..5a270bc
--- /dev/null
+++ b/src/include/libcef/capi/cef_frame_capi.h
@@ -0,0 +1,221 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_FRAME_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_FRAME_CAPI_H_
+#pragma once
+
+#include "libcef/capi/cef_base_capi.h"
+#include "libcef/capi/cef_dom_capi.h"
+#include "libcef/capi/cef_request_capi.h"
+#include "libcef/capi/cef_stream_capi.h"
+#include "libcef/capi/cef_string_visitor_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _cef_browser_t;
+struct _cef_v8context_t;
+
+///
+// Structure used to represent a frame in the browser window. When used in the
+// browser process the functions of this structure may be called on any thread
+// unless otherwise indicated in the comments. When used in the render process
+// the functions of this structure may only be called on the main thread.
+///
+typedef struct _cef_frame_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // True if this object is currently attached to a valid frame.
+  ///
+  int (CEF_CALLBACK *is_valid)(struct _cef_frame_t* self);
+
+  ///
+  // Execute undo in this frame.
+  ///
+  void (CEF_CALLBACK *undo)(struct _cef_frame_t* self);
+
+  ///
+  // Execute redo in this frame.
+  ///
+  void (CEF_CALLBACK *redo)(struct _cef_frame_t* self);
+
+  ///
+  // Execute cut in this frame.
+  ///
+  void (CEF_CALLBACK *cut)(struct _cef_frame_t* self);
+
+  ///
+  // Execute copy in this frame.
+  ///
+  void (CEF_CALLBACK *copy)(struct _cef_frame_t* self);
+
+  ///
+  // Execute paste in this frame.
+  ///
+  void (CEF_CALLBACK *paste)(struct _cef_frame_t* self);
+
+  ///
+  // Execute delete in this frame.
+  ///
+  void (CEF_CALLBACK *del)(struct _cef_frame_t* self);
+
+  ///
+  // Execute select all in this frame.
+  ///
+  void (CEF_CALLBACK *select_all)(struct _cef_frame_t* self);
+
+  ///
+  // Save this frame's HTML source to a temporary file and open it in the
+  // default text viewing application. This function can only be called from the
+  // browser process.
+  ///
+  void (CEF_CALLBACK *view_source)(struct _cef_frame_t* self);
+
+  ///
+  // Retrieve this frame's HTML source as a string sent to the specified
+  // visitor.
+  ///
+  void (CEF_CALLBACK *get_source)(struct _cef_frame_t* self,
+      struct _cef_string_visitor_t* visitor);
+
+  ///
+  // Retrieve this frame's display text as a string sent to the specified
+  // visitor.
+  ///
+  void (CEF_CALLBACK *get_text)(struct _cef_frame_t* self,
+      struct _cef_string_visitor_t* visitor);
+
+  ///
+  // Load the request represented by the |request| object.
+  ///
+  void (CEF_CALLBACK *load_request)(struct _cef_frame_t* self,
+      struct _cef_request_t* request);
+
+  ///
+  // Load the specified |url|.
+  ///
+  void (CEF_CALLBACK *load_url)(struct _cef_frame_t* self,
+      const cef_string_t* url);
+
+  ///
+  // Load the contents of |string_val| with the specified dummy |url|. |url|
+  // should have a standard scheme (for example, http scheme) or behaviors like
+  // link clicks and web security restrictions may not behave as expected.
+  ///
+  void (CEF_CALLBACK *load_string)(struct _cef_frame_t* self,
+      const cef_string_t* string_val, const cef_string_t* url);
+
+  ///
+  // Execute a string of JavaScript code in this frame. The |script_url|
+  // parameter is the URL where the script in question can be found, if any. The
+  // renderer may request this URL to show the developer the source of the
+  // error.  The |start_line| parameter is the base line number to use for error
+  // reporting.
+  ///
+  void (CEF_CALLBACK *execute_java_script)(struct _cef_frame_t* self,
+      const cef_string_t* code, const cef_string_t* script_url,
+      int start_line);
+
+  ///
+  // Returns true (1) if this is the main (top-level) frame.
+  ///
+  int (CEF_CALLBACK *is_main)(struct _cef_frame_t* self);
+
+  ///
+  // Returns true (1) if this is the focused frame.
+  ///
+  int (CEF_CALLBACK *is_focused)(struct _cef_frame_t* self);
+
+  ///
+  // Returns the name for this frame. If the frame has an assigned name (for
+  // example, set via the iframe "name" attribute) then that value will be
+  // returned. Otherwise a unique name will be constructed based on the frame
+  // parent hierarchy. The main (top-level) frame will always have an NULL name
+  // value.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_name)(struct _cef_frame_t* self);
+
+  ///
+  // Returns the globally unique identifier for this frame or < 0 if the
+  // underlying frame does not yet exist.
+  ///
+  int64 (CEF_CALLBACK *get_identifier)(struct _cef_frame_t* self);
+
+  ///
+  // Returns the parent of this frame or NULL if this is the main (top-level)
+  // frame.
+  ///
+  struct _cef_frame_t* (CEF_CALLBACK *get_parent)(struct _cef_frame_t* self);
+
+  ///
+  // Returns the URL currently loaded in this frame.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_url)(struct _cef_frame_t* self);
+
+  ///
+  // Returns the browser that this frame belongs to.
+  ///
+  struct _cef_browser_t* (CEF_CALLBACK *get_browser)(struct _cef_frame_t* self);
+
+  ///
+  // Get the V8 context associated with the frame. This function can only be
+  // called from the render process.
+  ///
+  struct _cef_v8context_t* (CEF_CALLBACK *get_v8context)(
+      struct _cef_frame_t* self);
+
+  ///
+  // Visit the DOM document. This function can only be called from the render
+  // process.
+  ///
+  void (CEF_CALLBACK *visit_dom)(struct _cef_frame_t* self,
+      struct _cef_domvisitor_t* visitor);
+} cef_frame_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_FRAME_CAPI_H_
diff --git a/src/include/libcef/capi/cef_geolocation_capi.h b/src/include/libcef/capi/cef_geolocation_capi.h
new file mode 100644
index 0000000..9ffeb60
--- /dev/null
+++ b/src/include/libcef/capi/cef_geolocation_capi.h
@@ -0,0 +1,79 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_GEOLOCATION_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_GEOLOCATION_CAPI_H_
+#pragma once
+
+#include "libcef/capi/cef_base_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Implement this structure to receive geolocation updates. The functions of
+// this structure will be called on the browser process UI thread.
+///
+typedef struct _cef_get_geolocation_callback_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Called with the 'best available' location information or, if the location
+  // update failed, with error information.
+  ///
+  void (CEF_CALLBACK *on_location_update)(
+      struct _cef_get_geolocation_callback_t* self,
+      const struct _cef_geoposition_t* position);
+} cef_get_geolocation_callback_t;
+
+
+///
+// Request a one-time geolocation update. This function bypasses any user
+// permission checks so should only be used by code that is allowed to access
+// location information.
+///
+CEF_EXPORT int cef_get_geolocation(cef_get_geolocation_callback_t* callback);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_GEOLOCATION_CAPI_H_
diff --git a/src/include/libcef/capi/cef_geolocation_handler_capi.h b/src/include/libcef/capi/cef_geolocation_handler_capi.h
new file mode 100644
index 0000000..5f1ae0d
--- /dev/null
+++ b/src/include/libcef/capi/cef_geolocation_handler_capi.h
@@ -0,0 +1,105 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_GEOLOCATION_HANDLER_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_GEOLOCATION_HANDLER_CAPI_H_
+#pragma once
+
+#include "libcef/capi/cef_base_capi.h"
+#include "libcef/capi/cef_browser_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Callback structure used for asynchronous continuation of geolocation
+// permission requests.
+///
+typedef struct _cef_geolocation_callback_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Call to allow or deny geolocation access.
+  ///
+  void (CEF_CALLBACK *cont)(struct _cef_geolocation_callback_t* self,
+      int allow);
+} cef_geolocation_callback_t;
+
+
+///
+// Implement this structure to handle events related to geolocation permission
+// requests. The functions of this structure will be called on the browser
+// process UI thread.
+///
+typedef struct _cef_geolocation_handler_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Called when a page requests permission to access geolocation information.
+  // |requesting_url| is the URL requesting permission and |request_id| is the
+  // unique ID for the permission request. Return true (1) and call
+  // cef_geolocation_callback_t::cont() either in this function or at a later
+  // time to continue or cancel the request. Return false (0) to cancel the
+  // request immediately.
+  ///
+  int (CEF_CALLBACK *on_request_geolocation_permission)(
+      struct _cef_geolocation_handler_t* self, struct _cef_browser_t* browser,
+      const cef_string_t* requesting_url, int request_id,
+      struct _cef_geolocation_callback_t* callback);
+
+  ///
+  // Called when a geolocation access request is canceled. |request_id| is the
+  // unique ID for the permission request.
+  ///
+  void (CEF_CALLBACK *on_cancel_geolocation_permission)(
+      struct _cef_geolocation_handler_t* self, struct _cef_browser_t* browser,
+      int request_id);
+} cef_geolocation_handler_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_GEOLOCATION_HANDLER_CAPI_H_
diff --git a/src/include/libcef/capi/cef_image_capi.h b/src/include/libcef/capi/cef_image_capi.h
new file mode 100644
index 0000000..d8e47c3
--- /dev/null
+++ b/src/include/libcef/capi/cef_image_capi.h
@@ -0,0 +1,187 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_IMAGE_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_IMAGE_CAPI_H_
+#pragma once
+
+#include "libcef/capi/cef_base_capi.h"
+#include "libcef/capi/cef_values_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Container for a single image represented at different scale factors. All
+// image representations should be the same size in density independent pixel
+// (DIP) units. For example, if the image at scale factor 1.0 is 100x100 pixels
+// then the image at scale factor 2.0 should be 200x200 pixels -- both images
+// will display with a DIP size of 100x100 units. The functions of this
+// structure must be called on the browser process UI thread.
+///
+typedef struct _cef_image_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns true (1) if this Image is NULL.
+  ///
+  int (CEF_CALLBACK *is_empty)(struct _cef_image_t* self);
+
+  ///
+  // Returns true (1) if this Image and |that| Image share the same underlying
+  // storage. Will also return true (1) if both images are NULL.
+  ///
+  int (CEF_CALLBACK *is_same)(struct _cef_image_t* self,
+      struct _cef_image_t* that);
+
+  ///
+  // Add a bitmap image representation for |scale_factor|. Only 32-bit RGBA/BGRA
+  // formats are supported. |pixel_width| and |pixel_height| are the bitmap
+  // representation size in pixel coordinates. |pixel_data| is the array of
+  // pixel data and should be |pixel_width| x |pixel_height| x 4 bytes in size.
+  // |color_type| and |alpha_type| values specify the pixel format.
+  ///
+  int (CEF_CALLBACK *add_bitmap)(struct _cef_image_t* self, float scale_factor,
+      int pixel_width, int pixel_height, cef_color_type_t color_type,
+      cef_alpha_type_t alpha_type, const void* pixel_data,
+      size_t pixel_data_size);
+
+  ///
+  // Add a PNG image representation for |scale_factor|. |png_data| is the image
+  // data of size |png_data_size|. Any alpha transparency in the PNG data will
+  // be maintained.
+  ///
+  int (CEF_CALLBACK *add_png)(struct _cef_image_t* self, float scale_factor,
+      const void* png_data, size_t png_data_size);
+
+  ///
+  // Create a JPEG image representation for |scale_factor|. |jpeg_data| is the
+  // image data of size |jpeg_data_size|. The JPEG format does not support
+  // transparency so the alpha byte will be set to 0xFF for all pixels.
+  ///
+  int (CEF_CALLBACK *add_jpeg)(struct _cef_image_t* self, float scale_factor,
+      const void* jpeg_data, size_t jpeg_data_size);
+
+  ///
+  // Returns the image width in density independent pixel (DIP) units.
+  ///
+  size_t (CEF_CALLBACK *get_width)(struct _cef_image_t* self);
+
+  ///
+  // Returns the image height in density independent pixel (DIP) units.
+  ///
+  size_t (CEF_CALLBACK *get_height)(struct _cef_image_t* self);
+
+  ///
+  // Returns true (1) if this image contains a representation for
+  // |scale_factor|.
+  ///
+  int (CEF_CALLBACK *has_representation)(struct _cef_image_t* self,
+      float scale_factor);
+
+  ///
+  // Removes the representation for |scale_factor|. Returns true (1) on success.
+  ///
+  int (CEF_CALLBACK *remove_representation)(struct _cef_image_t* self,
+      float scale_factor);
+
+  ///
+  // Returns information for the representation that most closely matches
+  // |scale_factor|. |actual_scale_factor| is the actual scale factor for the
+  // representation. |pixel_width| and |pixel_height| are the representation
+  // size in pixel coordinates. Returns true (1) on success.
+  ///
+  int (CEF_CALLBACK *get_representation_info)(struct _cef_image_t* self,
+      float scale_factor, float* actual_scale_factor, int* pixel_width,
+      int* pixel_height);
+
+  ///
+  // Returns the bitmap representation that most closely matches |scale_factor|.
+  // Only 32-bit RGBA/BGRA formats are supported. |color_type| and |alpha_type|
+  // values specify the desired output pixel format. |pixel_width| and
+  // |pixel_height| are the output representation size in pixel coordinates.
+  // Returns a cef_binary_value_t containing the pixel data on success or NULL
+  // on failure.
+  ///
+  struct _cef_binary_value_t* (CEF_CALLBACK *get_as_bitmap)(
+      struct _cef_image_t* self, float scale_factor,
+      cef_color_type_t color_type, cef_alpha_type_t alpha_type,
+      int* pixel_width, int* pixel_height);
+
+  ///
+  // Returns the PNG representation that most closely matches |scale_factor|. If
+  // |with_transparency| is true (1) any alpha transparency in the image will be
+  // represented in the resulting PNG data. |pixel_width| and |pixel_height| are
+  // the output representation size in pixel coordinates. Returns a
+  // cef_binary_value_t containing the PNG image data on success or NULL on
+  // failure.
+  ///
+  struct _cef_binary_value_t* (CEF_CALLBACK *get_as_png)(
+      struct _cef_image_t* self, float scale_factor, int with_transparency,
+      int* pixel_width, int* pixel_height);
+
+  ///
+  // Returns the JPEG representation that most closely matches |scale_factor|.
+  // |quality| determines the compression level with 0 == lowest and 100 ==
+  // highest. The JPEG format does not support alpha transparency and the alpha
+  // channel, if any, will be discarded. |pixel_width| and |pixel_height| are
+  // the output representation size in pixel coordinates. Returns a
+  // cef_binary_value_t containing the JPEG image data on success or NULL on
+  // failure.
+  ///
+  struct _cef_binary_value_t* (CEF_CALLBACK *get_as_jpeg)(
+      struct _cef_image_t* self, float scale_factor, int quality,
+      int* pixel_width, int* pixel_height);
+} cef_image_t;
+
+
+///
+// Create a new cef_image_t. It will initially be NULL. Use the Add*() functions
+// to add representations at different scale factors.
+///
+CEF_EXPORT cef_image_t* cef_image_create();
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_IMAGE_CAPI_H_
diff --git a/src/include/libcef/capi/cef_jsdialog_handler_capi.h b/src/include/libcef/capi/cef_jsdialog_handler_capi.h
new file mode 100644
index 0000000..a8e966c
--- /dev/null
+++ b/src/include/libcef/capi/cef_jsdialog_handler_capi.h
@@ -0,0 +1,134 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_JSDIALOG_HANDLER_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_JSDIALOG_HANDLER_CAPI_H_
+#pragma once
+
+#include "libcef/capi/cef_base_capi.h"
+#include "libcef/capi/cef_browser_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Callback structure used for asynchronous continuation of JavaScript dialog
+// requests.
+///
+typedef struct _cef_jsdialog_callback_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Continue the JS dialog request. Set |success| to true (1) if the OK button
+  // was pressed. The |user_input| value should be specified for prompt dialogs.
+  ///
+  void (CEF_CALLBACK *cont)(struct _cef_jsdialog_callback_t* self, int success,
+      const cef_string_t* user_input);
+} cef_jsdialog_callback_t;
+
+
+///
+// Implement this structure to handle events related to JavaScript dialogs. The
+// functions of this structure will be called on the UI thread.
+///
+typedef struct _cef_jsdialog_handler_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Called to run a JavaScript dialog. If |origin_url| is non-NULL it can be
+  // passed to the CefFormatUrlForSecurityDisplay function to retrieve a secure
+  // and user-friendly display string. The |default_prompt_text| value will be
+  // specified for prompt dialogs only. Set |suppress_message| to true (1) and
+  // return false (0) to suppress the message (suppressing messages is
+  // preferable to immediately executing the callback as this is used to detect
+  // presumably malicious behavior like spamming alert messages in
+  // onbeforeunload). Set |suppress_message| to false (0) and return false (0)
+  // to use the default implementation (the default implementation will show one
+  // modal dialog at a time and suppress any additional dialog requests until
+  // the displayed dialog is dismissed). Return true (1) if the application will
+  // use a custom dialog or if the callback has been executed immediately.
+  // Custom dialogs may be either modal or modeless. If a custom dialog is used
+  // the application must execute |callback| once the custom dialog is
+  // dismissed.
+  ///
+  int (CEF_CALLBACK *on_jsdialog)(struct _cef_jsdialog_handler_t* self,
+      struct _cef_browser_t* browser, const cef_string_t* origin_url,
+      cef_jsdialog_type_t dialog_type, const cef_string_t* message_text,
+      const cef_string_t* default_prompt_text,
+      struct _cef_jsdialog_callback_t* callback, int* suppress_message);
+
+  ///
+  // Called to run a dialog asking the user if they want to leave a page. Return
+  // false (0) to use the default dialog implementation. Return true (1) if the
+  // application will use a custom dialog or if the callback has been executed
+  // immediately. Custom dialogs may be either modal or modeless. If a custom
+  // dialog is used the application must execute |callback| once the custom
+  // dialog is dismissed.
+  ///
+  int (CEF_CALLBACK *on_before_unload_dialog)(
+      struct _cef_jsdialog_handler_t* self, struct _cef_browser_t* browser,
+      const cef_string_t* message_text, int is_reload,
+      struct _cef_jsdialog_callback_t* callback);
+
+  ///
+  // Called to cancel any pending dialogs and reset any saved dialog state. Will
+  // be called due to events like page navigation irregardless of whether any
+  // dialogs are currently pending.
+  ///
+  void (CEF_CALLBACK *on_reset_dialog_state)(
+      struct _cef_jsdialog_handler_t* self, struct _cef_browser_t* browser);
+
+  ///
+  // Called when the default implementation dialog is closed.
+  ///
+  void (CEF_CALLBACK *on_dialog_closed)(struct _cef_jsdialog_handler_t* self,
+      struct _cef_browser_t* browser);
+} cef_jsdialog_handler_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_JSDIALOG_HANDLER_CAPI_H_
diff --git a/src/include/libcef/capi/cef_keyboard_handler_capi.h b/src/include/libcef/capi/cef_keyboard_handler_capi.h
new file mode 100644
index 0000000..dccd043
--- /dev/null
+++ b/src/include/libcef/capi/cef_keyboard_handler_capi.h
@@ -0,0 +1,86 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_KEYBOARD_HANDLER_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_KEYBOARD_HANDLER_CAPI_H_
+#pragma once
+
+#include "libcef/capi/cef_base_capi.h"
+#include "libcef/capi/cef_browser_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Implement this structure to handle events related to keyboard input. The
+// functions of this structure will be called on the UI thread.
+///
+typedef struct _cef_keyboard_handler_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Called before a keyboard event is sent to the renderer. |event| contains
+  // information about the keyboard event. |os_event| is the operating system
+  // event message, if any. Return true (1) if the event was handled or false
+  // (0) otherwise. If the event will be handled in on_key_event() as a keyboard
+  // shortcut set |is_keyboard_shortcut| to true (1) and return false (0).
+  ///
+  int (CEF_CALLBACK *on_pre_key_event)(struct _cef_keyboard_handler_t* self,
+      struct _cef_browser_t* browser, const struct _cef_key_event_t* event,
+      cef_event_handle_t os_event, int* is_keyboard_shortcut);
+
+  ///
+  // Called after the renderer and JavaScript in the page has had a chance to
+  // handle the event. |event| contains information about the keyboard event.
+  // |os_event| is the operating system event message, if any. Return true (1)
+  // if the keyboard event was handled or false (0) otherwise.
+  ///
+  int (CEF_CALLBACK *on_key_event)(struct _cef_keyboard_handler_t* self,
+      struct _cef_browser_t* browser, const struct _cef_key_event_t* event,
+      cef_event_handle_t os_event);
+} cef_keyboard_handler_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_KEYBOARD_HANDLER_CAPI_H_
diff --git a/src/include/libcef/capi/cef_life_span_handler_capi.h b/src/include/libcef/capi/cef_life_span_handler_capi.h
new file mode 100644
index 0000000..537f27e
--- /dev/null
+++ b/src/include/libcef/capi/cef_life_span_handler_capi.h
@@ -0,0 +1,204 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_LIFE_SPAN_HANDLER_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_LIFE_SPAN_HANDLER_CAPI_H_
+#pragma once
+
+#include "libcef/capi/cef_base_capi.h"
+#include "libcef/capi/cef_browser_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _cef_client_t;
+
+///
+// Implement this structure to handle events related to browser life span. The
+// functions of this structure will be called on the UI thread unless otherwise
+// indicated.
+///
+typedef struct _cef_life_span_handler_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Called on the IO thread before a new popup browser is created. The
+  // |browser| and |frame| values represent the source of the popup request. The
+  // |target_url| and |target_frame_name| values indicate where the popup
+  // browser should navigate and may be NULL if not specified with the request.
+  // The |target_disposition| value indicates where the user intended to open
+  // the popup (e.g. current tab, new tab, etc). The |user_gesture| value will
+  // be true (1) if the popup was opened via explicit user gesture (e.g.
+  // clicking a link) or false (0) if the popup opened automatically (e.g. via
+  // the DomContentLoaded event). The |popupFeatures| structure contains
+  // additional information about the requested popup window. To allow creation
+  // of the popup browser optionally modify |windowInfo|, |client|, |settings|
+  // and |no_javascript_access| and return false (0). To cancel creation of the
+  // popup browser return true (1). The |client| and |settings| values will
+  // default to the source browser's values. If the |no_javascript_access| value
+  // is set to false (0) the new browser will not be scriptable and may not be
+  // hosted in the same renderer process as the source browser. Any
+  // modifications to |windowInfo| will be ignored if the parent browser is
+  // wrapped in a cef_browser_view_t.
+  ///
+  int (CEF_CALLBACK *on_before_popup)(struct _cef_life_span_handler_t* self,
+      struct _cef_browser_t* browser, struct _cef_frame_t* frame,
+      const cef_string_t* target_url, const cef_string_t* target_frame_name,
+      cef_window_open_disposition_t target_disposition, int user_gesture,
+      const struct _cef_popup_features_t* popupFeatures,
+      struct _cef_window_info_t* windowInfo, struct _cef_client_t** client,
+      struct _cef_browser_settings_t* settings, int* no_javascript_access);
+
+  ///
+  // Called after a new browser is created. This callback will be the first
+  // notification that references |browser|.
+  ///
+  void (CEF_CALLBACK *on_after_created)(struct _cef_life_span_handler_t* self,
+      struct _cef_browser_t* browser);
+
+  ///
+  // Called when a browser has recieved a request to close. This may result
+  // directly from a call to cef_browser_host_t::*close_browser() or indirectly
+  // if the browser is parented to a top-level window created by CEF and the
+  // user attempts to close that window (by clicking the 'X', for example). The
+  // do_close() function will be called after the JavaScript 'onunload' event
+  // has been fired.
+  //
+  // An application should handle top-level owner window close notifications by
+  // calling cef_browser_host_t::Tryclose_browser() or
+  // cef_browser_host_t::CloseBrowser(false (0)) instead of allowing the window
+  // to close immediately (see the examples below). This gives CEF an
+  // opportunity to process the 'onbeforeunload' event and optionally cancel the
+  // close before do_close() is called.
+  //
+  // When windowed rendering is enabled CEF will internally create a window or
+  // view to host the browser. In that case returning false (0) from do_close()
+  // will send the standard close notification to the browser's top-level owner
+  // window (e.g. WM_CLOSE on Windows, performClose: on OS X, "delete_event" on
+  // Linux or cef_window_delegate_t::can_close() callback from Views). If the
+  // browser's host window/view has already been destroyed (via view hierarchy
+  // tear-down, for example) then do_close() will not be called for that browser
+  // since is no longer possible to cancel the close.
+  //
+  // When windowed rendering is disabled returning false (0) from do_close()
+  // will cause the browser object to be destroyed immediately.
+  //
+  // If the browser's top-level owner window requires a non-standard close
+  // notification then send that notification from do_close() and return true
+  // (1).
+  //
+  // The cef_life_span_handler_t::on_before_close() function will be called
+  // after do_close() (if do_close() is called) and immediately before the
+  // browser object is destroyed. The application should only exit after
+  // on_before_close() has been called for all existing browsers.
+  //
+  // The below examples describe what should happen during window close when the
+  // browser is parented to an application-provided top-level window.
+  //
+  // Example 1: Using cef_browser_host_t::Tryclose_browser(). This is
+  // recommended for clients using standard close handling and windows created
+  // on the browser process UI thread. 1.  User clicks the window close button
+  // which sends a close notification to
+  //     the application's top-level window.
+  // 2.  Application's top-level window receives the close notification and
+  //     calls TryCloseBrowser() (which internally calls CloseBrowser(false)).
+  //     TryCloseBrowser() returns false so the client cancels the window close.
+  // 3.  JavaScript 'onbeforeunload' handler executes and shows the close
+  //     confirmation dialog (which can be overridden via
+  //     CefJSDialogHandler::OnBeforeUnloadDialog()).
+  // 4.  User approves the close. 5.  JavaScript 'onunload' handler executes. 6.
+  // CEF sends a close notification to the application's top-level window
+  //     (because DoClose() returned false by default).
+  // 7.  Application's top-level window receives the close notification and
+  //     calls TryCloseBrowser(). TryCloseBrowser() returns true so the client
+  //     allows the window close.
+  // 8.  Application's top-level window is destroyed. 9.  Application's
+  // on_before_close() handler is called and the browser object
+  //     is destroyed.
+  // 10. Application exits by calling cef_quit_message_loop() if no other
+  // browsers
+  //     exist.
+  //
+  // Example 2: Using cef_browser_host_t::CloseBrowser(false (0)) and
+  // implementing the do_close() callback. This is recommended for clients using
+  // non-standard close handling or windows that were not created on the browser
+  // process UI thread. 1.  User clicks the window close button which sends a
+  // close notification to
+  //     the application's top-level window.
+  // 2.  Application's top-level window receives the close notification and:
+  //     A. Calls CefBrowserHost::CloseBrowser(false).
+  //     B. Cancels the window close.
+  // 3.  JavaScript 'onbeforeunload' handler executes and shows the close
+  //     confirmation dialog (which can be overridden via
+  //     CefJSDialogHandler::OnBeforeUnloadDialog()).
+  // 4.  User approves the close. 5.  JavaScript 'onunload' handler executes. 6.
+  // Application's do_close() handler is called. Application will:
+  //     A. Set a flag to indicate that the next close attempt will be allowed.
+  //     B. Return false.
+  // 7.  CEF sends an close notification to the application's top-level window.
+  // 8.  Application's top-level window receives the close notification and
+  //     allows the window to close based on the flag from #6B.
+  // 9.  Application's top-level window is destroyed. 10. Application's
+  // on_before_close() handler is called and the browser object
+  //     is destroyed.
+  // 11. Application exits by calling cef_quit_message_loop() if no other
+  // browsers
+  //     exist.
+  ///
+  int (CEF_CALLBACK *do_close)(struct _cef_life_span_handler_t* self,
+      struct _cef_browser_t* browser);
+
+  ///
+  // Called just before a browser is destroyed. Release all references to the
+  // browser object and do not attempt to execute any functions on the browser
+  // object after this callback returns. This callback will be the last
+  // notification that references |browser|. See do_close() documentation for
+  // additional usage information.
+  ///
+  void (CEF_CALLBACK *on_before_close)(struct _cef_life_span_handler_t* self,
+      struct _cef_browser_t* browser);
+} cef_life_span_handler_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_LIFE_SPAN_HANDLER_CAPI_H_
diff --git a/src/include/libcef/capi/cef_load_handler_capi.h b/src/include/libcef/capi/cef_load_handler_capi.h
new file mode 100644
index 0000000..bdc8dcb
--- /dev/null
+++ b/src/include/libcef/capi/cef_load_handler_capi.h
@@ -0,0 +1,114 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_LOAD_HANDLER_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_LOAD_HANDLER_CAPI_H_
+#pragma once
+
+#include "libcef/capi/cef_base_capi.h"
+#include "libcef/capi/cef_browser_capi.h"
+#include "libcef/capi/cef_frame_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Implement this structure to handle events related to browser load status. The
+// functions of this structure will be called on the browser process UI thread
+// or render process main thread (TID_RENDERER).
+///
+typedef struct _cef_load_handler_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Called when the loading state has changed. This callback will be executed
+  // twice -- once when loading is initiated either programmatically or by user
+  // action, and once when loading is terminated due to completion, cancellation
+  // of failure. It will be called before any calls to OnLoadStart and after all
+  // calls to OnLoadError and/or OnLoadEnd.
+  ///
+  void (CEF_CALLBACK *on_loading_state_change)(struct _cef_load_handler_t* self,
+      struct _cef_browser_t* browser, int isLoading, int canGoBack,
+      int canGoForward);
+
+  ///
+  // Called when the browser begins loading a frame. The |frame| value will
+  // never be NULL -- call the is_main() function to check if this frame is the
+  // main frame. Multiple frames may be loading at the same time. Sub-frames may
+  // start or continue loading after the main frame load has ended. This
+  // function will always be called for all frames irrespective of whether the
+  // request completes successfully. For notification of overall browser load
+  // status use OnLoadingStateChange instead.
+  ///
+  void (CEF_CALLBACK *on_load_start)(struct _cef_load_handler_t* self,
+      struct _cef_browser_t* browser, struct _cef_frame_t* frame);
+
+  ///
+  // Called when the browser is done loading a frame. The |frame| value will
+  // never be NULL -- call the is_main() function to check if this frame is the
+  // main frame. Multiple frames may be loading at the same time. Sub-frames may
+  // start or continue loading after the main frame load has ended. This
+  // function will always be called for all frames irrespective of whether the
+  // request completes successfully. For notification of overall browser load
+  // status use OnLoadingStateChange instead.
+  ///
+  void (CEF_CALLBACK *on_load_end)(struct _cef_load_handler_t* self,
+      struct _cef_browser_t* browser, struct _cef_frame_t* frame,
+      int httpStatusCode);
+
+  ///
+  // Called when the resource load for a navigation fails or is canceled.
+  // |errorCode| is the error code number, |errorText| is the error text and
+  // |failedUrl| is the URL that failed to load. See net\base\net_error_list.h
+  // for complete descriptions of the error codes.
+  ///
+  void (CEF_CALLBACK *on_load_error)(struct _cef_load_handler_t* self,
+      struct _cef_browser_t* browser, struct _cef_frame_t* frame,
+      cef_errorcode_t errorCode, const cef_string_t* errorText,
+      const cef_string_t* failedUrl);
+} cef_load_handler_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_LOAD_HANDLER_CAPI_H_
diff --git a/src/include/libcef/capi/cef_menu_model_capi.h b/src/include/libcef/capi/cef_menu_model_capi.h
new file mode 100644
index 0000000..8162c83
--- /dev/null
+++ b/src/include/libcef/capi/cef_menu_model_capi.h
@@ -0,0 +1,396 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_MENU_MODEL_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_MENU_MODEL_CAPI_H_
+#pragma once
+
+#include "libcef/capi/cef_base_capi.h"
+#include "libcef/capi/cef_menu_model_delegate_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Supports creation and modification of menus. See cef_menu_id_t for the
+// command ids that have default implementations. All user-defined command ids
+// should be between MENU_ID_USER_FIRST and MENU_ID_USER_LAST. The functions of
+// this structure can only be accessed on the browser process the UI thread.
+///
+typedef struct _cef_menu_model_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Clears the menu. Returns true (1) on success.
+  ///
+  int (CEF_CALLBACK *clear)(struct _cef_menu_model_t* self);
+
+  ///
+  // Returns the number of items in this menu.
+  ///
+  int (CEF_CALLBACK *get_count)(struct _cef_menu_model_t* self);
+
+  ///
+  // Add a separator to the menu. Returns true (1) on success.
+  ///
+  int (CEF_CALLBACK *add_separator)(struct _cef_menu_model_t* self);
+
+  ///
+  // Add an item to the menu. Returns true (1) on success.
+  ///
+  int (CEF_CALLBACK *add_item)(struct _cef_menu_model_t* self, int command_id,
+      const cef_string_t* label);
+
+  ///
+  // Add a check item to the menu. Returns true (1) on success.
+  ///
+  int (CEF_CALLBACK *add_check_item)(struct _cef_menu_model_t* self,
+      int command_id, const cef_string_t* label);
+
+  ///
+  // Add a radio item to the menu. Only a single item with the specified
+  // |group_id| can be checked at a time. Returns true (1) on success.
+  ///
+  int (CEF_CALLBACK *add_radio_item)(struct _cef_menu_model_t* self,
+      int command_id, const cef_string_t* label, int group_id);
+
+  ///
+  // Add a sub-menu to the menu. The new sub-menu is returned.
+  ///
+  struct _cef_menu_model_t* (CEF_CALLBACK *add_sub_menu)(
+      struct _cef_menu_model_t* self, int command_id,
+      const cef_string_t* label);
+
+  ///
+  // Insert a separator in the menu at the specified |index|. Returns true (1)
+  // on success.
+  ///
+  int (CEF_CALLBACK *insert_separator_at)(struct _cef_menu_model_t* self,
+      int index);
+
+  ///
+  // Insert an item in the menu at the specified |index|. Returns true (1) on
+  // success.
+  ///
+  int (CEF_CALLBACK *insert_item_at)(struct _cef_menu_model_t* self, int index,
+      int command_id, const cef_string_t* label);
+
+  ///
+  // Insert a check item in the menu at the specified |index|. Returns true (1)
+  // on success.
+  ///
+  int (CEF_CALLBACK *insert_check_item_at)(struct _cef_menu_model_t* self,
+      int index, int command_id, const cef_string_t* label);
+
+  ///
+  // Insert a radio item in the menu at the specified |index|. Only a single
+  // item with the specified |group_id| can be checked at a time. Returns true
+  // (1) on success.
+  ///
+  int (CEF_CALLBACK *insert_radio_item_at)(struct _cef_menu_model_t* self,
+      int index, int command_id, const cef_string_t* label, int group_id);
+
+  ///
+  // Insert a sub-menu in the menu at the specified |index|. The new sub-menu is
+  // returned.
+  ///
+  struct _cef_menu_model_t* (CEF_CALLBACK *insert_sub_menu_at)(
+      struct _cef_menu_model_t* self, int index, int command_id,
+      const cef_string_t* label);
+
+  ///
+  // Removes the item with the specified |command_id|. Returns true (1) on
+  // success.
+  ///
+  int (CEF_CALLBACK *remove)(struct _cef_menu_model_t* self, int command_id);
+
+  ///
+  // Removes the item at the specified |index|. Returns true (1) on success.
+  ///
+  int (CEF_CALLBACK *remove_at)(struct _cef_menu_model_t* self, int index);
+
+  ///
+  // Returns the index associated with the specified |command_id| or -1 if not
+  // found due to the command id not existing in the menu.
+  ///
+  int (CEF_CALLBACK *get_index_of)(struct _cef_menu_model_t* self,
+      int command_id);
+
+  ///
+  // Returns the command id at the specified |index| or -1 if not found due to
+  // invalid range or the index being a separator.
+  ///
+  int (CEF_CALLBACK *get_command_id_at)(struct _cef_menu_model_t* self,
+      int index);
+
+  ///
+  // Sets the command id at the specified |index|. Returns true (1) on success.
+  ///
+  int (CEF_CALLBACK *set_command_id_at)(struct _cef_menu_model_t* self,
+      int index, int command_id);
+
+  ///
+  // Returns the label for the specified |command_id| or NULL if not found.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_label)(
+      struct _cef_menu_model_t* self, int command_id);
+
+  ///
+  // Returns the label at the specified |index| or NULL if not found due to
+  // invalid range or the index being a separator.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_label_at)(
+      struct _cef_menu_model_t* self, int index);
+
+  ///
+  // Sets the label for the specified |command_id|. Returns true (1) on success.
+  ///
+  int (CEF_CALLBACK *set_label)(struct _cef_menu_model_t* self, int command_id,
+      const cef_string_t* label);
+
+  ///
+  // Set the label at the specified |index|. Returns true (1) on success.
+  ///
+  int (CEF_CALLBACK *set_label_at)(struct _cef_menu_model_t* self, int index,
+      const cef_string_t* label);
+
+  ///
+  // Returns the item type for the specified |command_id|.
+  ///
+  cef_menu_item_type_t (CEF_CALLBACK *get_type)(struct _cef_menu_model_t* self,
+      int command_id);
+
+  ///
+  // Returns the item type at the specified |index|.
+  ///
+  cef_menu_item_type_t (CEF_CALLBACK *get_type_at)(
+      struct _cef_menu_model_t* self, int index);
+
+  ///
+  // Returns the group id for the specified |command_id| or -1 if invalid.
+  ///
+  int (CEF_CALLBACK *get_group_id)(struct _cef_menu_model_t* self,
+      int command_id);
+
+  ///
+  // Returns the group id at the specified |index| or -1 if invalid.
+  ///
+  int (CEF_CALLBACK *get_group_id_at)(struct _cef_menu_model_t* self,
+      int index);
+
+  ///
+  // Sets the group id for the specified |command_id|. Returns true (1) on
+  // success.
+  ///
+  int (CEF_CALLBACK *set_group_id)(struct _cef_menu_model_t* self,
+      int command_id, int group_id);
+
+  ///
+  // Sets the group id at the specified |index|. Returns true (1) on success.
+  ///
+  int (CEF_CALLBACK *set_group_id_at)(struct _cef_menu_model_t* self, int index,
+      int group_id);
+
+  ///
+  // Returns the submenu for the specified |command_id| or NULL if invalid.
+  ///
+  struct _cef_menu_model_t* (CEF_CALLBACK *get_sub_menu)(
+      struct _cef_menu_model_t* self, int command_id);
+
+  ///
+  // Returns the submenu at the specified |index| or NULL if invalid.
+  ///
+  struct _cef_menu_model_t* (CEF_CALLBACK *get_sub_menu_at)(
+      struct _cef_menu_model_t* self, int index);
+
+  ///
+  // Returns true (1) if the specified |command_id| is visible.
+  ///
+  int (CEF_CALLBACK *is_visible)(struct _cef_menu_model_t* self,
+      int command_id);
+
+  ///
+  // Returns true (1) if the specified |index| is visible.
+  ///
+  int (CEF_CALLBACK *is_visible_at)(struct _cef_menu_model_t* self, int index);
+
+  ///
+  // Change the visibility of the specified |command_id|. Returns true (1) on
+  // success.
+  ///
+  int (CEF_CALLBACK *set_visible)(struct _cef_menu_model_t* self,
+      int command_id, int visible);
+
+  ///
+  // Change the visibility at the specified |index|. Returns true (1) on
+  // success.
+  ///
+  int (CEF_CALLBACK *set_visible_at)(struct _cef_menu_model_t* self, int index,
+      int visible);
+
+  ///
+  // Returns true (1) if the specified |command_id| is enabled.
+  ///
+  int (CEF_CALLBACK *is_enabled)(struct _cef_menu_model_t* self,
+      int command_id);
+
+  ///
+  // Returns true (1) if the specified |index| is enabled.
+  ///
+  int (CEF_CALLBACK *is_enabled_at)(struct _cef_menu_model_t* self, int index);
+
+  ///
+  // Change the enabled status of the specified |command_id|. Returns true (1)
+  // on success.
+  ///
+  int (CEF_CALLBACK *set_enabled)(struct _cef_menu_model_t* self,
+      int command_id, int enabled);
+
+  ///
+  // Change the enabled status at the specified |index|. Returns true (1) on
+  // success.
+  ///
+  int (CEF_CALLBACK *set_enabled_at)(struct _cef_menu_model_t* self, int index,
+      int enabled);
+
+  ///
+  // Returns true (1) if the specified |command_id| is checked. Only applies to
+  // check and radio items.
+  ///
+  int (CEF_CALLBACK *is_checked)(struct _cef_menu_model_t* self,
+      int command_id);
+
+  ///
+  // Returns true (1) if the specified |index| is checked. Only applies to check
+  // and radio items.
+  ///
+  int (CEF_CALLBACK *is_checked_at)(struct _cef_menu_model_t* self, int index);
+
+  ///
+  // Check the specified |command_id|. Only applies to check and radio items.
+  // Returns true (1) on success.
+  ///
+  int (CEF_CALLBACK *set_checked)(struct _cef_menu_model_t* self,
+      int command_id, int checked);
+
+  ///
+  // Check the specified |index|. Only applies to check and radio items. Returns
+  // true (1) on success.
+  ///
+  int (CEF_CALLBACK *set_checked_at)(struct _cef_menu_model_t* self, int index,
+      int checked);
+
+  ///
+  // Returns true (1) if the specified |command_id| has a keyboard accelerator
+  // assigned.
+  ///
+  int (CEF_CALLBACK *has_accelerator)(struct _cef_menu_model_t* self,
+      int command_id);
+
+  ///
+  // Returns true (1) if the specified |index| has a keyboard accelerator
+  // assigned.
+  ///
+  int (CEF_CALLBACK *has_accelerator_at)(struct _cef_menu_model_t* self,
+      int index);
+
+  ///
+  // Set the keyboard accelerator for the specified |command_id|. |key_code| can
+  // be any virtual key or character value. Returns true (1) on success.
+  ///
+  int (CEF_CALLBACK *set_accelerator)(struct _cef_menu_model_t* self,
+      int command_id, int key_code, int shift_pressed, int ctrl_pressed,
+      int alt_pressed);
+
+  ///
+  // Set the keyboard accelerator at the specified |index|. |key_code| can be
+  // any virtual key or character value. Returns true (1) on success.
+  ///
+  int (CEF_CALLBACK *set_accelerator_at)(struct _cef_menu_model_t* self,
+      int index, int key_code, int shift_pressed, int ctrl_pressed,
+      int alt_pressed);
+
+  ///
+  // Remove the keyboard accelerator for the specified |command_id|. Returns
+  // true (1) on success.
+  ///
+  int (CEF_CALLBACK *remove_accelerator)(struct _cef_menu_model_t* self,
+      int command_id);
+
+  ///
+  // Remove the keyboard accelerator at the specified |index|. Returns true (1)
+  // on success.
+  ///
+  int (CEF_CALLBACK *remove_accelerator_at)(struct _cef_menu_model_t* self,
+      int index);
+
+  ///
+  // Retrieves the keyboard accelerator for the specified |command_id|. Returns
+  // true (1) on success.
+  ///
+  int (CEF_CALLBACK *get_accelerator)(struct _cef_menu_model_t* self,
+      int command_id, int* key_code, int* shift_pressed, int* ctrl_pressed,
+      int* alt_pressed);
+
+  ///
+  // Retrieves the keyboard accelerator for the specified |index|. Returns true
+  // (1) on success.
+  ///
+  int (CEF_CALLBACK *get_accelerator_at)(struct _cef_menu_model_t* self,
+      int index, int* key_code, int* shift_pressed, int* ctrl_pressed,
+      int* alt_pressed);
+} cef_menu_model_t;
+
+
+///
+// Create a new MenuModel with the specified |delegate|.
+///
+CEF_EXPORT cef_menu_model_t* cef_menu_model_create(
+    struct _cef_menu_model_delegate_t* delegate);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_MENU_MODEL_CAPI_H_
diff --git a/src/include/libcef/capi/cef_menu_model_delegate_capi.h b/src/include/libcef/capi/cef_menu_model_delegate_capi.h
new file mode 100644
index 0000000..526c479
--- /dev/null
+++ b/src/include/libcef/capi/cef_menu_model_delegate_capi.h
@@ -0,0 +1,80 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_MENU_MODEL_DELEGATE_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_MENU_MODEL_DELEGATE_CAPI_H_
+#pragma once
+
+#include "libcef/capi/cef_base_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _cef_menu_model_t;
+
+///
+// Implement this structure to handle menu model events. The functions of this
+// structure will be called on the browser process UI thread unless otherwise
+// indicated.
+///
+typedef struct _cef_menu_model_delegate_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Perform the action associated with the specified |command_id| and optional
+  // |event_flags|.
+  ///
+  void (CEF_CALLBACK *execute_command)(struct _cef_menu_model_delegate_t* self,
+      struct _cef_menu_model_t* menu_model, int command_id,
+      cef_event_flags_t event_flags);
+
+  ///
+  // The menu is about to show.
+  ///
+  void (CEF_CALLBACK *menu_will_show)(struct _cef_menu_model_delegate_t* self,
+      struct _cef_menu_model_t* menu_model);
+} cef_menu_model_delegate_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_MENU_MODEL_DELEGATE_CAPI_H_
diff --git a/src/include/libcef/capi/cef_navigation_entry_capi.h b/src/include/libcef/capi/cef_navigation_entry_capi.h
new file mode 100644
index 0000000..6f1d1ae
--- /dev/null
+++ b/src/include/libcef/capi/cef_navigation_entry_capi.h
@@ -0,0 +1,126 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_NAVIGATION_ENTRY_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_NAVIGATION_ENTRY_CAPI_H_
+#pragma once
+
+#include "libcef/capi/cef_base_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Structure used to represent an entry in navigation history.
+///
+typedef struct _cef_navigation_entry_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns true (1) if this object is valid. Do not call any other functions
+  // if this function returns false (0).
+  ///
+  int (CEF_CALLBACK *is_valid)(struct _cef_navigation_entry_t* self);
+
+  ///
+  // Returns the actual URL of the page. For some pages this may be data: URL or
+  // similar. Use get_display_url() to return a display-friendly version.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_url)(
+      struct _cef_navigation_entry_t* self);
+
+  ///
+  // Returns a display-friendly version of the URL.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_display_url)(
+      struct _cef_navigation_entry_t* self);
+
+  ///
+  // Returns the original URL that was entered by the user before any redirects.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_original_url)(
+      struct _cef_navigation_entry_t* self);
+
+  ///
+  // Returns the title set by the page. This value may be NULL.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_title)(
+      struct _cef_navigation_entry_t* self);
+
+  ///
+  // Returns the transition type which indicates what the user did to move to
+  // this page from the previous page.
+  ///
+  cef_transition_type_t (CEF_CALLBACK *get_transition_type)(
+      struct _cef_navigation_entry_t* self);
+
+  ///
+  // Returns true (1) if this navigation includes post data.
+  ///
+  int (CEF_CALLBACK *has_post_data)(struct _cef_navigation_entry_t* self);
+
+  ///
+  // Returns the time for the last known successful navigation completion. A
+  // navigation may be completed more than once if the page is reloaded. May be
+  // 0 if the navigation has not yet completed.
+  ///
+  cef_time_t (CEF_CALLBACK *get_completion_time)(
+      struct _cef_navigation_entry_t* self);
+
+  ///
+  // Returns the HTTP status code for the last known successful navigation
+  // response. May be 0 if the response has not yet been received or if the
+  // navigation has not yet completed.
+  ///
+  int (CEF_CALLBACK *get_http_status_code)(
+      struct _cef_navigation_entry_t* self);
+} cef_navigation_entry_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_NAVIGATION_ENTRY_CAPI_H_
diff --git a/src/include/libcef/capi/cef_origin_whitelist_capi.h b/src/include/libcef/capi/cef_origin_whitelist_capi.h
new file mode 100644
index 0000000..30f702a
--- /dev/null
+++ b/src/include/libcef/capi/cef_origin_whitelist_capi.h
@@ -0,0 +1,106 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_ORIGIN_WHITELIST_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_ORIGIN_WHITELIST_CAPI_H_
+#pragma once
+
+#include "libcef/capi/cef_base_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Add an entry to the cross-origin access whitelist.
+//
+// The same-origin policy restricts how scripts hosted from different origins
+// (scheme + domain + port) can communicate. By default, scripts can only access
+// resources with the same origin. Scripts hosted on the HTTP and HTTPS schemes
+// (but no other schemes) can use the "Access-Control-Allow-Origin" header to
+// allow cross-origin requests. For example, https://source.example.com can make
+// XMLHttpRequest requests on http://target.example.com if the
+// http://target.example.com request returns an "Access-Control-Allow-Origin:
+// https://source.example.com" response header.
+//
+// Scripts in separate frames or iframes and hosted from the same protocol and
+// domain suffix can execute cross-origin JavaScript if both pages set the
+// document.domain value to the same domain suffix. For example,
+// scheme://foo.example.com and scheme://bar.example.com can communicate using
+// JavaScript if both domains set document.domain="example.com".
+//
+// This function is used to allow access to origins that would otherwise violate
+// the same-origin policy. Scripts hosted underneath the fully qualified
+// |source_origin| URL (like http://www.example.com) will be allowed access to
+// all resources hosted on the specified |target_protocol| and |target_domain|.
+// If |target_domain| is non-NULL and |allow_target_subdomains| if false (0)
+// only exact domain matches will be allowed. If |target_domain| contains a top-
+// level domain component (like "example.com") and |allow_target_subdomains| is
+// true (1) sub-domain matches will be allowed. If |target_domain| is NULL and
+// |allow_target_subdomains| if true (1) all domains and IP addresses will be
+// allowed.
+//
+// This function cannot be used to bypass the restrictions on local or display
+// isolated schemes. See the comments on CefRegisterCustomScheme for more
+// information.
+//
+// This function may be called on any thread. Returns false (0) if
+// |source_origin| is invalid or the whitelist cannot be accessed.
+///
+CEF_EXPORT int cef_add_cross_origin_whitelist_entry(
+    const cef_string_t* source_origin, const cef_string_t* target_protocol,
+    const cef_string_t* target_domain, int allow_target_subdomains);
+
+///
+// Remove an entry from the cross-origin access whitelist. Returns false (0) if
+// |source_origin| is invalid or the whitelist cannot be accessed.
+///
+CEF_EXPORT int cef_remove_cross_origin_whitelist_entry(
+    const cef_string_t* source_origin, const cef_string_t* target_protocol,
+    const cef_string_t* target_domain, int allow_target_subdomains);
+
+///
+// Remove all entries from the cross-origin access whitelist. Returns false (0)
+// if the whitelist cannot be accessed.
+///
+CEF_EXPORT int cef_clear_cross_origin_whitelist();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_ORIGIN_WHITELIST_CAPI_H_
diff --git a/src/include/libcef/capi/cef_parser_capi.h b/src/include/libcef/capi/cef_parser_capi.h
new file mode 100644
index 0000000..ece205d
--- /dev/null
+++ b/src/include/libcef/capi/cef_parser_capi.h
@@ -0,0 +1,162 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_PARSER_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_PARSER_CAPI_H_
+#pragma once
+
+#include "libcef/capi/cef_base_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Parse the specified |url| into its component parts. Returns false (0) if the
+// URL is NULL or invalid.
+///
+CEF_EXPORT int cef_parse_url(const cef_string_t* url,
+    struct _cef_urlparts_t* parts);
+
+///
+// Creates a URL from the specified |parts|, which must contain a non-NULL spec
+// or a non-NULL host and path (at a minimum), but not both. Returns false (0)
+// if |parts| isn't initialized as described.
+///
+CEF_EXPORT int cef_create_url(const struct _cef_urlparts_t* parts,
+    cef_string_t* url);
+
+///
+// This is a convenience function for formatting a URL in a concise and human-
+// friendly way to help users make security-related decisions (or in other
+// circumstances when people need to distinguish sites, origins, or otherwise-
+// simplified URLs from each other). Internationalized domain names (IDN) may be
+// presented in Unicode if the conversion is considered safe. The returned value
+// will (a) omit the path for standard schemes, excepting file and filesystem,
+// and (b) omit the port if it is the default for the scheme. Do not use this
+// for URLs which will be parsed or sent to other applications.
+///
+// The resulting string must be freed by calling cef_string_userfree_free().
+CEF_EXPORT cef_string_userfree_t cef_format_url_for_security_display(
+    const cef_string_t* origin_url);
+
+///
+// Returns the mime type for the specified file extension or an NULL string if
+// unknown.
+///
+// The resulting string must be freed by calling cef_string_userfree_free().
+CEF_EXPORT cef_string_userfree_t cef_get_mime_type(
+    const cef_string_t* extension);
+
+///
+// Get the extensions associated with the given mime type. This should be passed
+// in lower case. There could be multiple extensions for a given mime type, like
+// "html,htm" for "text/html", or "txt,text,html,..." for "text/*". Any existing
+// elements in the provided vector will not be erased.
+///
+CEF_EXPORT void cef_get_extensions_for_mime_type(const cef_string_t* mime_type,
+    cef_string_list_t extensions);
+
+///
+// Encodes |data| as a base64 string.
+///
+// The resulting string must be freed by calling cef_string_userfree_free().
+CEF_EXPORT cef_string_userfree_t cef_base64encode(const void* data,
+    size_t data_size);
+
+///
+// Decodes the base64 encoded string |data|. The returned value will be NULL if
+// the decoding fails.
+///
+CEF_EXPORT struct _cef_binary_value_t* cef_base64decode(
+    const cef_string_t* data);
+
+///
+// Escapes characters in |text| which are unsuitable for use as a query
+// parameter value. Everything except alphanumerics and -_.!~*'() will be
+// converted to "%XX". If |use_plus| is true (1) spaces will change to "+". The
+// result is basically the same as encodeURIComponent in Javacript.
+///
+// The resulting string must be freed by calling cef_string_userfree_free().
+CEF_EXPORT cef_string_userfree_t cef_uriencode(const cef_string_t* text,
+    int use_plus);
+
+///
+// Unescapes |text| and returns the result. Unescaping consists of looking for
+// the exact pattern "%XX" where each X is a hex digit and converting to the
+// character with the numerical value of those digits (e.g. "i%20=%203%3b"
+// unescapes to "i = 3;"). If |convert_to_utf8| is true (1) this function will
+// attempt to interpret the initial decoded result as UTF-8. If the result is
+// convertable into UTF-8 it will be returned as converted. Otherwise the
+// initial decoded result will be returned.  The |unescape_rule| parameter
+// supports further customization the decoding process.
+///
+// The resulting string must be freed by calling cef_string_userfree_free().
+CEF_EXPORT cef_string_userfree_t cef_uridecode(const cef_string_t* text,
+    int convert_to_utf8, cef_uri_unescape_rule_t unescape_rule);
+
+///
+// Parses the specified |json_string| and returns a dictionary or list
+// representation. If JSON parsing fails this function returns NULL.
+///
+CEF_EXPORT struct _cef_value_t* cef_parse_json(const cef_string_t* json_string,
+    cef_json_parser_options_t options);
+
+///
+// Parses the specified |json_string| and returns a dictionary or list
+// representation. If JSON parsing fails this function returns NULL and
+// populates |error_code_out| and |error_msg_out| with an error code and a
+// formatted error message respectively.
+///
+CEF_EXPORT struct _cef_value_t* cef_parse_jsonand_return_error(
+    const cef_string_t* json_string, cef_json_parser_options_t options,
+    cef_json_parser_error_t* error_code_out, cef_string_t* error_msg_out);
+
+///
+// Generates a JSON string from the specified root |node| which should be a
+// dictionary or list value. Returns an NULL string on failure. This function
+// requires exclusive access to |node| including any underlying data.
+///
+// The resulting string must be freed by calling cef_string_userfree_free().
+CEF_EXPORT cef_string_userfree_t cef_write_json(struct _cef_value_t* node,
+    cef_json_writer_options_t options);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_PARSER_CAPI_H_
diff --git a/src/include/libcef/capi/cef_path_util_capi.h b/src/include/libcef/capi/cef_path_util_capi.h
new file mode 100644
index 0000000..72d6910
--- /dev/null
+++ b/src/include/libcef/capi/cef_path_util_capi.h
@@ -0,0 +1,58 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_PATH_UTIL_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_PATH_UTIL_CAPI_H_
+#pragma once
+
+#include "libcef/capi/cef_base_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Retrieve the path associated with the specified |key|. Returns true (1) on
+// success. Can be called on any thread in the browser process.
+///
+CEF_EXPORT int cef_get_path(cef_path_key_t key, cef_string_t* path);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_PATH_UTIL_CAPI_H_
diff --git a/src/include/libcef/capi/cef_print_handler_capi.h b/src/include/libcef/capi/cef_print_handler_capi.h
new file mode 100644
index 0000000..fb45270
--- /dev/null
+++ b/src/include/libcef/capi/cef_print_handler_capi.h
@@ -0,0 +1,150 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_PRINT_HANDLER_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_PRINT_HANDLER_CAPI_H_
+#pragma once
+
+#include "libcef/capi/cef_base_capi.h"
+#include "libcef/capi/cef_browser_capi.h"
+#include "libcef/capi/cef_print_settings_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Callback structure for asynchronous continuation of print dialog requests.
+///
+typedef struct _cef_print_dialog_callback_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Continue printing with the specified |settings|.
+  ///
+  void (CEF_CALLBACK *cont)(struct _cef_print_dialog_callback_t* self,
+      struct _cef_print_settings_t* settings);
+
+  ///
+  // Cancel the printing.
+  ///
+  void (CEF_CALLBACK *cancel)(struct _cef_print_dialog_callback_t* self);
+} cef_print_dialog_callback_t;
+
+
+///
+// Callback structure for asynchronous continuation of print job requests.
+///
+typedef struct _cef_print_job_callback_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Indicate completion of the print job.
+  ///
+  void (CEF_CALLBACK *cont)(struct _cef_print_job_callback_t* self);
+} cef_print_job_callback_t;
+
+
+///
+// Implement this structure to handle printing on Linux. The functions of this
+// structure will be called on the browser process UI thread.
+///
+typedef struct _cef_print_handler_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Called when printing has started for the specified |browser|. This function
+  // will be called before the other OnPrint*() functions and irrespective of
+  // how printing was initiated (e.g. cef_browser_host_t::print(), JavaScript
+  // window.print() or PDF extension print button).
+  ///
+  void (CEF_CALLBACK *on_print_start)(struct _cef_print_handler_t* self,
+      struct _cef_browser_t* browser);
+
+  ///
+  // Synchronize |settings| with client state. If |get_defaults| is true (1)
+  // then populate |settings| with the default print settings. Do not keep a
+  // reference to |settings| outside of this callback.
+  ///
+  void (CEF_CALLBACK *on_print_settings)(struct _cef_print_handler_t* self,
+      struct _cef_print_settings_t* settings, int get_defaults);
+
+  ///
+  // Show the print dialog. Execute |callback| once the dialog is dismissed.
+  // Return true (1) if the dialog will be displayed or false (0) to cancel the
+  // printing immediately.
+  ///
+  int (CEF_CALLBACK *on_print_dialog)(struct _cef_print_handler_t* self,
+      int has_selection, struct _cef_print_dialog_callback_t* callback);
+
+  ///
+  // Send the print job to the printer. Execute |callback| once the job is
+  // completed. Return true (1) if the job will proceed or false (0) to cancel
+  // the job immediately.
+  ///
+  int (CEF_CALLBACK *on_print_job)(struct _cef_print_handler_t* self,
+      const cef_string_t* document_name, const cef_string_t* pdf_file_path,
+      struct _cef_print_job_callback_t* callback);
+
+  ///
+  // Reset client state related to printing.
+  ///
+  void (CEF_CALLBACK *on_print_reset)(struct _cef_print_handler_t* self);
+
+  ///
+  // Return the PDF paper size in device units. Used in combination with
+  // cef_browser_host_t::print_to_pdf().
+  ///
+  cef_size_t (CEF_CALLBACK *get_pdf_paper_size)(
+      struct _cef_print_handler_t* self, int device_units_per_inch);
+} cef_print_handler_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_PRINT_HANDLER_CAPI_H_
diff --git a/src/include/libcef/capi/cef_print_settings_capi.h b/src/include/libcef/capi/cef_print_settings_capi.h
new file mode 100644
index 0000000..f80870f
--- /dev/null
+++ b/src/include/libcef/capi/cef_print_settings_capi.h
@@ -0,0 +1,207 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_PRINT_SETTINGS_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_PRINT_SETTINGS_CAPI_H_
+#pragma once
+
+#include "libcef/capi/cef_base_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Structure representing print settings.
+///
+typedef struct _cef_print_settings_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns true (1) if this object is valid. Do not call any other functions
+  // if this function returns false (0).
+  ///
+  int (CEF_CALLBACK *is_valid)(struct _cef_print_settings_t* self);
+
+  ///
+  // Returns true (1) if the values of this object are read-only. Some APIs may
+  // expose read-only objects.
+  ///
+  int (CEF_CALLBACK *is_read_only)(struct _cef_print_settings_t* self);
+
+  ///
+  // Returns a writable copy of this object.
+  ///
+  struct _cef_print_settings_t* (CEF_CALLBACK *copy)(
+      struct _cef_print_settings_t* self);
+
+  ///
+  // Set the page orientation.
+  ///
+  void (CEF_CALLBACK *set_orientation)(struct _cef_print_settings_t* self,
+      int landscape);
+
+  ///
+  // Returns true (1) if the orientation is landscape.
+  ///
+  int (CEF_CALLBACK *is_landscape)(struct _cef_print_settings_t* self);
+
+  ///
+  // Set the printer printable area in device units. Some platforms already
+  // provide flipped area. Set |landscape_needs_flip| to false (0) on those
+  // platforms to avoid double flipping.
+  ///
+  void (CEF_CALLBACK *set_printer_printable_area)(
+      struct _cef_print_settings_t* self,
+      const cef_size_t* physical_size_device_units,
+      const cef_rect_t* printable_area_device_units,
+      int landscape_needs_flip);
+
+  ///
+  // Set the device name.
+  ///
+  void (CEF_CALLBACK *set_device_name)(struct _cef_print_settings_t* self,
+      const cef_string_t* name);
+
+  ///
+  // Get the device name.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_device_name)(
+      struct _cef_print_settings_t* self);
+
+  ///
+  // Set the DPI (dots per inch).
+  ///
+  void (CEF_CALLBACK *set_dpi)(struct _cef_print_settings_t* self, int dpi);
+
+  ///
+  // Get the DPI (dots per inch).
+  ///
+  int (CEF_CALLBACK *get_dpi)(struct _cef_print_settings_t* self);
+
+  ///
+  // Set the page ranges.
+  ///
+  void (CEF_CALLBACK *set_page_ranges)(struct _cef_print_settings_t* self,
+      size_t rangesCount, cef_range_t const* ranges);
+
+  ///
+  // Returns the number of page ranges that currently exist.
+  ///
+  size_t (CEF_CALLBACK *get_page_ranges_count)(
+      struct _cef_print_settings_t* self);
+
+  ///
+  // Retrieve the page ranges.
+  ///
+  void (CEF_CALLBACK *get_page_ranges)(struct _cef_print_settings_t* self,
+      size_t* rangesCount, cef_range_t* ranges);
+
+  ///
+  // Set whether only the selection will be printed.
+  ///
+  void (CEF_CALLBACK *set_selection_only)(struct _cef_print_settings_t* self,
+      int selection_only);
+
+  ///
+  // Returns true (1) if only the selection will be printed.
+  ///
+  int (CEF_CALLBACK *is_selection_only)(struct _cef_print_settings_t* self);
+
+  ///
+  // Set whether pages will be collated.
+  ///
+  void (CEF_CALLBACK *set_collate)(struct _cef_print_settings_t* self,
+      int collate);
+
+  ///
+  // Returns true (1) if pages will be collated.
+  ///
+  int (CEF_CALLBACK *will_collate)(struct _cef_print_settings_t* self);
+
+  ///
+  // Set the color model.
+  ///
+  void (CEF_CALLBACK *set_color_model)(struct _cef_print_settings_t* self,
+      cef_color_model_t model);
+
+  ///
+  // Get the color model.
+  ///
+  cef_color_model_t (CEF_CALLBACK *get_color_model)(
+      struct _cef_print_settings_t* self);
+
+  ///
+  // Set the number of copies.
+  ///
+  void (CEF_CALLBACK *set_copies)(struct _cef_print_settings_t* self,
+      int copies);
+
+  ///
+  // Get the number of copies.
+  ///
+  int (CEF_CALLBACK *get_copies)(struct _cef_print_settings_t* self);
+
+  ///
+  // Set the duplex mode.
+  ///
+  void (CEF_CALLBACK *set_duplex_mode)(struct _cef_print_settings_t* self,
+      cef_duplex_mode_t mode);
+
+  ///
+  // Get the duplex mode.
+  ///
+  cef_duplex_mode_t (CEF_CALLBACK *get_duplex_mode)(
+      struct _cef_print_settings_t* self);
+} cef_print_settings_t;
+
+
+///
+// Create a new cef_print_settings_t object.
+///
+CEF_EXPORT cef_print_settings_t* cef_print_settings_create();
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_PRINT_SETTINGS_CAPI_H_
diff --git a/src/include/libcef/capi/cef_process_message_capi.h b/src/include/libcef/capi/cef_process_message_capi.h
new file mode 100644
index 0000000..b2cbae2
--- /dev/null
+++ b/src/include/libcef/capi/cef_process_message_capi.h
@@ -0,0 +1,102 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_PROCESS_MESSAGE_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_PROCESS_MESSAGE_CAPI_H_
+#pragma once
+
+#include "libcef/capi/cef_base_capi.h"
+#include "libcef/capi/cef_values_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Structure representing a message. Can be used on any process and thread.
+///
+typedef struct _cef_process_message_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns true (1) if this object is valid. Do not call any other functions
+  // if this function returns false (0).
+  ///
+  int (CEF_CALLBACK *is_valid)(struct _cef_process_message_t* self);
+
+  ///
+  // Returns true (1) if the values of this object are read-only. Some APIs may
+  // expose read-only objects.
+  ///
+  int (CEF_CALLBACK *is_read_only)(struct _cef_process_message_t* self);
+
+  ///
+  // Returns a writable copy of this object.
+  ///
+  struct _cef_process_message_t* (CEF_CALLBACK *copy)(
+      struct _cef_process_message_t* self);
+
+  ///
+  // Returns the message name.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_name)(
+      struct _cef_process_message_t* self);
+
+  ///
+  // Returns the list of arguments.
+  ///
+  struct _cef_list_value_t* (CEF_CALLBACK *get_argument_list)(
+      struct _cef_process_message_t* self);
+} cef_process_message_t;
+
+
+///
+// Create a new cef_process_message_t object with the specified name.
+///
+CEF_EXPORT cef_process_message_t* cef_process_message_create(
+    const cef_string_t* name);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_PROCESS_MESSAGE_CAPI_H_
diff --git a/src/include/libcef/capi/cef_process_util_capi.h b/src/include/libcef/capi/cef_process_util_capi.h
new file mode 100644
index 0000000..7300a44
--- /dev/null
+++ b/src/include/libcef/capi/cef_process_util_capi.h
@@ -0,0 +1,64 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_PROCESS_UTIL_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_PROCESS_UTIL_CAPI_H_
+#pragma once
+
+#include "libcef/capi/cef_base_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Launches the process specified via |command_line|. Returns true (1) upon
+// success. Must be called on the browser process TID_PROCESS_LAUNCHER thread.
+//
+// Unix-specific notes: - All file descriptors open in the parent process will
+// be closed in the
+//   child process except for stdin, stdout, and stderr.
+// - If the first argument on the command line does not contain a slash,
+//   PATH will be searched. (See man execvp.)
+///
+CEF_EXPORT int cef_launch_process(struct _cef_command_line_t* command_line);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_PROCESS_UTIL_CAPI_H_
diff --git a/src/include/libcef/capi/cef_render_handler_capi.h b/src/include/libcef/capi/cef_render_handler_capi.h
new file mode 100644
index 0000000..538dd09
--- /dev/null
+++ b/src/include/libcef/capi/cef_render_handler_capi.h
@@ -0,0 +1,171 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_RENDER_HANDLER_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_RENDER_HANDLER_CAPI_H_
+#pragma once
+
+#include "libcef/capi/cef_base_capi.h"
+#include "libcef/capi/cef_browser_capi.h"
+#include "libcef/capi/cef_drag_data_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Implement this structure to handle events when window rendering is disabled.
+// The functions of this structure will be called on the UI thread.
+///
+typedef struct _cef_render_handler_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Called to retrieve the root window rectangle in screen coordinates. Return
+  // true (1) if the rectangle was provided.
+  ///
+  int (CEF_CALLBACK *get_root_screen_rect)(struct _cef_render_handler_t* self,
+      struct _cef_browser_t* browser, cef_rect_t* rect);
+
+  ///
+  // Called to retrieve the view rectangle which is relative to screen
+  // coordinates. Return true (1) if the rectangle was provided.
+  ///
+  int (CEF_CALLBACK *get_view_rect)(struct _cef_render_handler_t* self,
+      struct _cef_browser_t* browser, cef_rect_t* rect);
+
+  ///
+  // Called to retrieve the translation from view coordinates to actual screen
+  // coordinates. Return true (1) if the screen coordinates were provided.
+  ///
+  int (CEF_CALLBACK *get_screen_point)(struct _cef_render_handler_t* self,
+      struct _cef_browser_t* browser, int viewX, int viewY, int* screenX,
+      int* screenY);
+
+  ///
+  // Called to allow the client to fill in the CefScreenInfo object with
+  // appropriate values. Return true (1) if the |screen_info| structure has been
+  // modified.
+  //
+  // If the screen info rectangle is left NULL the rectangle from GetViewRect
+  // will be used. If the rectangle is still NULL or invalid popups may not be
+  // drawn correctly.
+  ///
+  int (CEF_CALLBACK *get_screen_info)(struct _cef_render_handler_t* self,
+      struct _cef_browser_t* browser, struct _cef_screen_info_t* screen_info);
+
+  ///
+  // Called when the browser wants to show or hide the popup widget. The popup
+  // should be shown if |show| is true (1) and hidden if |show| is false (0).
+  ///
+  void (CEF_CALLBACK *on_popup_show)(struct _cef_render_handler_t* self,
+      struct _cef_browser_t* browser, int show);
+
+  ///
+  // Called when the browser wants to move or resize the popup widget. |rect|
+  // contains the new location and size in view coordinates.
+  ///
+  void (CEF_CALLBACK *on_popup_size)(struct _cef_render_handler_t* self,
+      struct _cef_browser_t* browser, const cef_rect_t* rect);
+
+  ///
+  // Called when an element should be painted. Pixel values passed to this
+  // function are scaled relative to view coordinates based on the value of
+  // CefScreenInfo.device_scale_factor returned from GetScreenInfo. |type|
+  // indicates whether the element is the view or the popup widget. |buffer|
+  // contains the pixel data for the whole image. |dirtyRects| contains the set
+  // of rectangles in pixel coordinates that need to be repainted. |buffer| will
+  // be |width|*|height|*4 bytes in size and represents a BGRA image with an
+  // upper-left origin.
+  ///
+  void (CEF_CALLBACK *on_paint)(struct _cef_render_handler_t* self,
+      struct _cef_browser_t* browser, cef_paint_element_type_t type,
+      size_t dirtyRectsCount, cef_rect_t const* dirtyRects, const void* buffer,
+      int width, int height);
+
+  ///
+  // Called when the browser's cursor has changed. If |type| is CT_CUSTOM then
+  // |custom_cursor_info| will be populated with the custom cursor information.
+  ///
+  void (CEF_CALLBACK *on_cursor_change)(struct _cef_render_handler_t* self,
+      struct _cef_browser_t* browser, cef_cursor_handle_t cursor,
+      cef_cursor_type_t type,
+      const struct _cef_cursor_info_t* custom_cursor_info);
+
+  ///
+  // Called when the user starts dragging content in the web view. Contextual
+  // information about the dragged content is supplied by |drag_data|. (|x|,
+  // |y|) is the drag start location in screen coordinates. OS APIs that run a
+  // system message loop may be used within the StartDragging call.
+  //
+  // Return false (0) to abort the drag operation. Don't call any of
+  // cef_browser_host_t::DragSource*Ended* functions after returning false (0).
+  //
+  // Return true (1) to handle the drag operation. Call
+  // cef_browser_host_t::DragSourceEndedAt and DragSourceSystemDragEnded either
+  // synchronously or asynchronously to inform the web view that the drag
+  // operation has ended.
+  ///
+  int (CEF_CALLBACK *start_dragging)(struct _cef_render_handler_t* self,
+      struct _cef_browser_t* browser, struct _cef_drag_data_t* drag_data,
+      cef_drag_operations_mask_t allowed_ops, int x, int y);
+
+  ///
+  // Called when the web view wants to update the mouse cursor during a drag &
+  // drop operation. |operation| describes the allowed operation (none, move,
+  // copy, link).
+  ///
+  void (CEF_CALLBACK *update_drag_cursor)(struct _cef_render_handler_t* self,
+      struct _cef_browser_t* browser, cef_drag_operations_mask_t operation);
+
+  ///
+  // Called when the scroll offset has changed.
+  ///
+  void (CEF_CALLBACK *on_scroll_offset_changed)(
+      struct _cef_render_handler_t* self, struct _cef_browser_t* browser,
+      double x, double y);
+} cef_render_handler_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_RENDER_HANDLER_CAPI_H_
diff --git a/src/include/libcef/capi/cef_render_process_handler_capi.h b/src/include/libcef/capi/cef_render_process_handler_capi.h
new file mode 100644
index 0000000..93a27d8
--- /dev/null
+++ b/src/include/libcef/capi/cef_render_process_handler_capi.h
@@ -0,0 +1,177 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_RENDER_PROCESS_HANDLER_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_RENDER_PROCESS_HANDLER_CAPI_H_
+#pragma once
+
+#include "libcef/capi/cef_base_capi.h"
+#include "libcef/capi/cef_browser_capi.h"
+#include "libcef/capi/cef_dom_capi.h"
+#include "libcef/capi/cef_frame_capi.h"
+#include "libcef/capi/cef_load_handler_capi.h"
+#include "libcef/capi/cef_process_message_capi.h"
+#include "libcef/capi/cef_v8_capi.h"
+#include "libcef/capi/cef_values_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Structure used to implement render process callbacks. The functions of this
+// structure will be called on the render process main thread (TID_RENDERER)
+// unless otherwise indicated.
+///
+typedef struct _cef_render_process_handler_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Called after the render process main thread has been created. |extra_info|
+  // is a read-only value originating from
+  // cef_browser_process_handler_t::on_render_process_thread_created(). Do not
+  // keep a reference to |extra_info| outside of this function.
+  ///
+  void (CEF_CALLBACK *on_render_thread_created)(
+      struct _cef_render_process_handler_t* self,
+      struct _cef_list_value_t* extra_info);
+
+  ///
+  // Called after WebKit has been initialized.
+  ///
+  void (CEF_CALLBACK *on_web_kit_initialized)(
+      struct _cef_render_process_handler_t* self);
+
+  ///
+  // Called after a browser has been created. When browsing cross-origin a new
+  // browser will be created before the old browser with the same identifier is
+  // destroyed.
+  ///
+  void (CEF_CALLBACK *on_browser_created)(
+      struct _cef_render_process_handler_t* self,
+      struct _cef_browser_t* browser);
+
+  ///
+  // Called before a browser is destroyed.
+  ///
+  void (CEF_CALLBACK *on_browser_destroyed)(
+      struct _cef_render_process_handler_t* self,
+      struct _cef_browser_t* browser);
+
+  ///
+  // Return the handler for browser load status events.
+  ///
+  struct _cef_load_handler_t* (CEF_CALLBACK *get_load_handler)(
+      struct _cef_render_process_handler_t* self);
+
+  ///
+  // Called before browser navigation. Return true (1) to cancel the navigation
+  // or false (0) to allow the navigation to proceed. The |request| object
+  // cannot be modified in this callback.
+  ///
+  int (CEF_CALLBACK *on_before_navigation)(
+      struct _cef_render_process_handler_t* self,
+      struct _cef_browser_t* browser, struct _cef_frame_t* frame,
+      struct _cef_request_t* request, cef_navigation_type_t navigation_type,
+      int is_redirect);
+
+  ///
+  // Called immediately after the V8 context for a frame has been created. To
+  // retrieve the JavaScript 'window' object use the
+  // cef_v8context_t::get_global() function. V8 handles can only be accessed
+  // from the thread on which they are created. A task runner for posting tasks
+  // on the associated thread can be retrieved via the
+  // cef_v8context_t::get_task_runner() function.
+  ///
+  void (CEF_CALLBACK *on_context_created)(
+      struct _cef_render_process_handler_t* self,
+      struct _cef_browser_t* browser, struct _cef_frame_t* frame,
+      struct _cef_v8context_t* context);
+
+  ///
+  // Called immediately before the V8 context for a frame is released. No
+  // references to the context should be kept after this function is called.
+  ///
+  void (CEF_CALLBACK *on_context_released)(
+      struct _cef_render_process_handler_t* self,
+      struct _cef_browser_t* browser, struct _cef_frame_t* frame,
+      struct _cef_v8context_t* context);
+
+  ///
+  // Called for global uncaught exceptions in a frame. Execution of this
+  // callback is disabled by default. To enable set
+  // CefSettings.uncaught_exception_stack_size > 0.
+  ///
+  void (CEF_CALLBACK *on_uncaught_exception)(
+      struct _cef_render_process_handler_t* self,
+      struct _cef_browser_t* browser, struct _cef_frame_t* frame,
+      struct _cef_v8context_t* context, struct _cef_v8exception_t* exception,
+      struct _cef_v8stack_trace_t* stackTrace);
+
+  ///
+  // Called when a new node in the the browser gets focus. The |node| value may
+  // be NULL if no specific node has gained focus. The node object passed to
+  // this function represents a snapshot of the DOM at the time this function is
+  // executed. DOM objects are only valid for the scope of this function. Do not
+  // keep references to or attempt to access any DOM objects outside the scope
+  // of this function.
+  ///
+  void (CEF_CALLBACK *on_focused_node_changed)(
+      struct _cef_render_process_handler_t* self,
+      struct _cef_browser_t* browser, struct _cef_frame_t* frame,
+      struct _cef_domnode_t* node);
+
+  ///
+  // Called when a new message is received from a different process. Return true
+  // (1) if the message was handled or false (0) otherwise. Do not keep a
+  // reference to or attempt to access the message outside of this callback.
+  ///
+  int (CEF_CALLBACK *on_process_message_received)(
+      struct _cef_render_process_handler_t* self,
+      struct _cef_browser_t* browser, cef_process_id_t source_process,
+      struct _cef_process_message_t* message);
+} cef_render_process_handler_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_RENDER_PROCESS_HANDLER_CAPI_H_
diff --git a/src/include/libcef/capi/cef_request_capi.h b/src/include/libcef/capi/cef_request_capi.h
new file mode 100644
index 0000000..21b12ee
--- /dev/null
+++ b/src/include/libcef/capi/cef_request_capi.h
@@ -0,0 +1,330 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_REQUEST_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_REQUEST_CAPI_H_
+#pragma once
+
+#include "libcef/capi/cef_base_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _cef_post_data_element_t;
+struct _cef_post_data_t;
+
+///
+// Structure used to represent a web request. The functions of this structure
+// may be called on any thread.
+///
+typedef struct _cef_request_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns true (1) if this object is read-only.
+  ///
+  int (CEF_CALLBACK *is_read_only)(struct _cef_request_t* self);
+
+  ///
+  // Get the fully qualified URL.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_url)(struct _cef_request_t* self);
+
+  ///
+  // Set the fully qualified URL.
+  ///
+  void (CEF_CALLBACK *set_url)(struct _cef_request_t* self,
+      const cef_string_t* url);
+
+  ///
+  // Get the request function type. The value will default to POST if post data
+  // is provided and GET otherwise.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_method)(struct _cef_request_t* self);
+
+  ///
+  // Set the request function type.
+  ///
+  void (CEF_CALLBACK *set_method)(struct _cef_request_t* self,
+      const cef_string_t* method);
+
+  ///
+  // Set the referrer URL and policy. If non-NULL the referrer URL must be fully
+  // qualified with an HTTP or HTTPS scheme component. Any username, password or
+  // ref component will be removed.
+  ///
+  void (CEF_CALLBACK *set_referrer)(struct _cef_request_t* self,
+      const cef_string_t* referrer_url, cef_referrer_policy_t policy);
+
+  ///
+  // Get the referrer URL.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_referrer_url)(
+      struct _cef_request_t* self);
+
+  ///
+  // Get the referrer policy.
+  ///
+  cef_referrer_policy_t (CEF_CALLBACK *get_referrer_policy)(
+      struct _cef_request_t* self);
+
+  ///
+  // Get the post data.
+  ///
+  struct _cef_post_data_t* (CEF_CALLBACK *get_post_data)(
+      struct _cef_request_t* self);
+
+  ///
+  // Set the post data.
+  ///
+  void (CEF_CALLBACK *set_post_data)(struct _cef_request_t* self,
+      struct _cef_post_data_t* postData);
+
+  ///
+  // Get the header values. Will not include the Referer value if any.
+  ///
+  void (CEF_CALLBACK *get_header_map)(struct _cef_request_t* self,
+      cef_string_multimap_t headerMap);
+
+  ///
+  // Set the header values. If a Referer value exists in the header map it will
+  // be removed and ignored.
+  ///
+  void (CEF_CALLBACK *set_header_map)(struct _cef_request_t* self,
+      cef_string_multimap_t headerMap);
+
+  ///
+  // Set all values at one time.
+  ///
+  void (CEF_CALLBACK *set)(struct _cef_request_t* self, const cef_string_t* url,
+      const cef_string_t* method, struct _cef_post_data_t* postData,
+      cef_string_multimap_t headerMap);
+
+  ///
+  // Get the flags used in combination with cef_urlrequest_t. See
+  // cef_urlrequest_flags_t for supported values.
+  ///
+  int (CEF_CALLBACK *get_flags)(struct _cef_request_t* self);
+
+  ///
+  // Set the flags used in combination with cef_urlrequest_t.  See
+  // cef_urlrequest_flags_t for supported values.
+  ///
+  void (CEF_CALLBACK *set_flags)(struct _cef_request_t* self, int flags);
+
+  ///
+  // Set the URL to the first party for cookies used in combination with
+  // cef_urlrequest_t.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_first_party_for_cookies)(
+      struct _cef_request_t* self);
+
+  ///
+  // Get the URL to the first party for cookies used in combination with
+  // cef_urlrequest_t.
+  ///
+  void (CEF_CALLBACK *set_first_party_for_cookies)(struct _cef_request_t* self,
+      const cef_string_t* url);
+
+  ///
+  // Get the resource type for this request. Only available in the browser
+  // process.
+  ///
+  cef_resource_type_t (CEF_CALLBACK *get_resource_type)(
+      struct _cef_request_t* self);
+
+  ///
+  // Get the transition type for this request. Only available in the browser
+  // process and only applies to requests that represent a main frame or sub-
+  // frame navigation.
+  ///
+  cef_transition_type_t (CEF_CALLBACK *get_transition_type)(
+      struct _cef_request_t* self);
+
+  ///
+  // Returns the globally unique identifier for this request or 0 if not
+  // specified. Can be used by cef_request_tHandler implementations in the
+  // browser process to track a single request across multiple callbacks.
+  ///
+  uint64 (CEF_CALLBACK *get_identifier)(struct _cef_request_t* self);
+} cef_request_t;
+
+
+///
+// Create a new cef_request_t object.
+///
+CEF_EXPORT cef_request_t* cef_request_create();
+
+
+///
+// Structure used to represent post data for a web request. The functions of
+// this structure may be called on any thread.
+///
+typedef struct _cef_post_data_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns true (1) if this object is read-only.
+  ///
+  int (CEF_CALLBACK *is_read_only)(struct _cef_post_data_t* self);
+
+  ///
+  // Returns true (1) if the underlying POST data includes elements that are not
+  // represented by this cef_post_data_t object (for example, multi-part file
+  // upload data). Modifying cef_post_data_t objects with excluded elements may
+  // result in the request failing.
+  ///
+  int (CEF_CALLBACK *has_excluded_elements)(struct _cef_post_data_t* self);
+
+  ///
+  // Returns the number of existing post data elements.
+  ///
+  size_t (CEF_CALLBACK *get_element_count)(struct _cef_post_data_t* self);
+
+  ///
+  // Retrieve the post data elements.
+  ///
+  void (CEF_CALLBACK *get_elements)(struct _cef_post_data_t* self,
+      size_t* elementsCount, struct _cef_post_data_element_t** elements);
+
+  ///
+  // Remove the specified post data element.  Returns true (1) if the removal
+  // succeeds.
+  ///
+  int (CEF_CALLBACK *remove_element)(struct _cef_post_data_t* self,
+      struct _cef_post_data_element_t* element);
+
+  ///
+  // Add the specified post data element.  Returns true (1) if the add succeeds.
+  ///
+  int (CEF_CALLBACK *add_element)(struct _cef_post_data_t* self,
+      struct _cef_post_data_element_t* element);
+
+  ///
+  // Remove all existing post data elements.
+  ///
+  void (CEF_CALLBACK *remove_elements)(struct _cef_post_data_t* self);
+} cef_post_data_t;
+
+
+///
+// Create a new cef_post_data_t object.
+///
+CEF_EXPORT cef_post_data_t* cef_post_data_create();
+
+
+///
+// Structure used to represent a single element in the request post data. The
+// functions of this structure may be called on any thread.
+///
+typedef struct _cef_post_data_element_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns true (1) if this object is read-only.
+  ///
+  int (CEF_CALLBACK *is_read_only)(struct _cef_post_data_element_t* self);
+
+  ///
+  // Remove all contents from the post data element.
+  ///
+  void (CEF_CALLBACK *set_to_empty)(struct _cef_post_data_element_t* self);
+
+  ///
+  // The post data element will represent a file.
+  ///
+  void (CEF_CALLBACK *set_to_file)(struct _cef_post_data_element_t* self,
+      const cef_string_t* fileName);
+
+  ///
+  // The post data element will represent bytes.  The bytes passed in will be
+  // copied.
+  ///
+  void (CEF_CALLBACK *set_to_bytes)(struct _cef_post_data_element_t* self,
+      size_t size, const void* bytes);
+
+  ///
+  // Return the type of this post data element.
+  ///
+  cef_postdataelement_type_t (CEF_CALLBACK *get_type)(
+      struct _cef_post_data_element_t* self);
+
+  ///
+  // Return the file name.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_file)(
+      struct _cef_post_data_element_t* self);
+
+  ///
+  // Return the number of bytes.
+  ///
+  size_t (CEF_CALLBACK *get_bytes_count)(struct _cef_post_data_element_t* self);
+
+  ///
+  // Read up to |size| bytes into |bytes| and return the number of bytes
+  // actually read.
+  ///
+  size_t (CEF_CALLBACK *get_bytes)(struct _cef_post_data_element_t* self,
+      size_t size, void* bytes);
+} cef_post_data_element_t;
+
+
+///
+// Create a new cef_post_data_element_t object.
+///
+CEF_EXPORT cef_post_data_element_t* cef_post_data_element_create();
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_REQUEST_CAPI_H_
diff --git a/src/include/libcef/capi/cef_request_context_capi.h b/src/include/libcef/capi/cef_request_context_capi.h
new file mode 100644
index 0000000..f464260
--- /dev/null
+++ b/src/include/libcef/capi/cef_request_context_capi.h
@@ -0,0 +1,291 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_REQUEST_CONTEXT_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_REQUEST_CONTEXT_CAPI_H_
+#pragma once
+
+#include "libcef/capi/cef_callback_capi.h"
+#include "libcef/capi/cef_cookie_capi.h"
+#include "libcef/capi/cef_request_context_handler_capi.h"
+#include "libcef/capi/cef_values_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _cef_scheme_handler_factory_t;
+
+///
+// Callback structure for cef_request_tContext::ResolveHost.
+///
+typedef struct _cef_resolve_callback_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Called after the ResolveHost request has completed. |result| will be the
+  // result code. |resolved_ips| will be the list of resolved IP addresses or
+  // NULL if the resolution failed.
+  ///
+  void (CEF_CALLBACK *on_resolve_completed)(
+      struct _cef_resolve_callback_t* self, cef_errorcode_t result,
+      cef_string_list_t resolved_ips);
+} cef_resolve_callback_t;
+
+
+///
+// A request context provides request handling for a set of related browser or
+// URL request objects. A request context can be specified when creating a new
+// browser via the cef_browser_host_t static factory functions or when creating
+// a new URL request via the cef_urlrequest_t static factory functions. Browser
+// objects with different request contexts will never be hosted in the same
+// render process. Browser objects with the same request context may or may not
+// be hosted in the same render process depending on the process model. Browser
+// objects created indirectly via the JavaScript window.open function or
+// targeted links will share the same render process and the same request
+// context as the source browser. When running in single-process mode there is
+// only a single render process (the main process) and so all browsers created
+// in single-process mode will share the same request context. This will be the
+// first request context passed into a cef_browser_host_t static factory
+// function and all other request context objects will be ignored.
+///
+typedef struct _cef_request_context_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns true (1) if this object is pointing to the same context as |that|
+  // object.
+  ///
+  int (CEF_CALLBACK *is_same)(struct _cef_request_context_t* self,
+      struct _cef_request_context_t* other);
+
+  ///
+  // Returns true (1) if this object is sharing the same storage as |that|
+  // object.
+  ///
+  int (CEF_CALLBACK *is_sharing_with)(struct _cef_request_context_t* self,
+      struct _cef_request_context_t* other);
+
+  ///
+  // Returns true (1) if this object is the global context. The global context
+  // is used by default when creating a browser or URL request with a NULL
+  // context argument.
+  ///
+  int (CEF_CALLBACK *is_global)(struct _cef_request_context_t* self);
+
+  ///
+  // Returns the handler for this context if any.
+  ///
+  struct _cef_request_context_handler_t* (CEF_CALLBACK *get_handler)(
+      struct _cef_request_context_t* self);
+
+  ///
+  // Returns the cache path for this object. If NULL an "incognito mode" in-
+  // memory cache is being used.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_cache_path)(
+      struct _cef_request_context_t* self);
+
+  ///
+  // Returns the default cookie manager for this object. This will be the global
+  // cookie manager if this object is the global request context. Otherwise,
+  // this will be the default cookie manager used when this request context does
+  // not receive a value via cef_request_tContextHandler::get_cookie_manager().
+  // If |callback| is non-NULL it will be executed asnychronously on the IO
+  // thread after the manager's storage has been initialized.
+  ///
+  struct _cef_cookie_manager_t* (CEF_CALLBACK *get_default_cookie_manager)(
+      struct _cef_request_context_t* self,
+      struct _cef_completion_callback_t* callback);
+
+  ///
+  // Register a scheme handler factory for the specified |scheme_name| and
+  // optional |domain_name|. An NULL |domain_name| value for a standard scheme
+  // will cause the factory to match all domain names. The |domain_name| value
+  // will be ignored for non-standard schemes. If |scheme_name| is a built-in
+  // scheme and no handler is returned by |factory| then the built-in scheme
+  // handler factory will be called. If |scheme_name| is a custom scheme then
+  // you must also implement the cef_app_t::on_register_custom_schemes()
+  // function in all processes. This function may be called multiple times to
+  // change or remove the factory that matches the specified |scheme_name| and
+  // optional |domain_name|. Returns false (0) if an error occurs. This function
+  // may be called on any thread in the browser process.
+  ///
+  int (CEF_CALLBACK *register_scheme_handler_factory)(
+      struct _cef_request_context_t* self, const cef_string_t* scheme_name,
+      const cef_string_t* domain_name,
+      struct _cef_scheme_handler_factory_t* factory);
+
+  ///
+  // Clear all registered scheme handler factories. Returns false (0) on error.
+  // This function may be called on any thread in the browser process.
+  ///
+  int (CEF_CALLBACK *clear_scheme_handler_factories)(
+      struct _cef_request_context_t* self);
+
+  ///
+  // Tells all renderer processes associated with this context to throw away
+  // their plugin list cache. If |reload_pages| is true (1) they will also
+  // reload all pages with plugins.
+  // cef_request_tContextHandler::OnBeforePluginLoad may be called to rebuild
+  // the plugin list cache.
+  ///
+  void (CEF_CALLBACK *purge_plugin_list_cache)(
+      struct _cef_request_context_t* self, int reload_pages);
+
+  ///
+  // Returns true (1) if a preference with the specified |name| exists. This
+  // function must be called on the browser process UI thread.
+  ///
+  int (CEF_CALLBACK *has_preference)(struct _cef_request_context_t* self,
+      const cef_string_t* name);
+
+  ///
+  // Returns the value for the preference with the specified |name|. Returns
+  // NULL if the preference does not exist. The returned object contains a copy
+  // of the underlying preference value and modifications to the returned object
+  // will not modify the underlying preference value. This function must be
+  // called on the browser process UI thread.
+  ///
+  struct _cef_value_t* (CEF_CALLBACK *get_preference)(
+      struct _cef_request_context_t* self, const cef_string_t* name);
+
+  ///
+  // Returns all preferences as a dictionary. If |include_defaults| is true (1)
+  // then preferences currently at their default value will be included. The
+  // returned object contains a copy of the underlying preference values and
+  // modifications to the returned object will not modify the underlying
+  // preference values. This function must be called on the browser process UI
+  // thread.
+  ///
+  struct _cef_dictionary_value_t* (CEF_CALLBACK *get_all_preferences)(
+      struct _cef_request_context_t* self, int include_defaults);
+
+  ///
+  // Returns true (1) if the preference with the specified |name| can be
+  // modified using SetPreference. As one example preferences set via the
+  // command-line usually cannot be modified. This function must be called on
+  // the browser process UI thread.
+  ///
+  int (CEF_CALLBACK *can_set_preference)(struct _cef_request_context_t* self,
+      const cef_string_t* name);
+
+  ///
+  // Set the |value| associated with preference |name|. Returns true (1) if the
+  // value is set successfully and false (0) otherwise. If |value| is NULL the
+  // preference will be restored to its default value. If setting the preference
+  // fails then |error| will be populated with a detailed description of the
+  // problem. This function must be called on the browser process UI thread.
+  ///
+  int (CEF_CALLBACK *set_preference)(struct _cef_request_context_t* self,
+      const cef_string_t* name, struct _cef_value_t* value,
+      cef_string_t* error);
+
+  ///
+  // Clears all certificate exceptions that were added as part of handling
+  // cef_request_tHandler::on_certificate_error(). If you call this it is
+  // recommended that you also call close_all_connections() or you risk not
+  // being prompted again for server certificates if you reconnect quickly. If
+  // |callback| is non-NULL it will be executed on the UI thread after
+  // completion.
+  ///
+  void (CEF_CALLBACK *clear_certificate_exceptions)(
+      struct _cef_request_context_t* self,
+      struct _cef_completion_callback_t* callback);
+
+  ///
+  // Clears all active and idle connections that Chromium currently has. This is
+  // only recommended if you have released all other CEF objects but don't yet
+  // want to call cef_shutdown(). If |callback| is non-NULL it will be executed
+  // on the UI thread after completion.
+  ///
+  void (CEF_CALLBACK *close_all_connections)(
+      struct _cef_request_context_t* self,
+      struct _cef_completion_callback_t* callback);
+
+  ///
+  // Attempts to resolve |origin| to a list of associated IP addresses.
+  // |callback| will be executed on the UI thread after completion.
+  ///
+  void (CEF_CALLBACK *resolve_host)(struct _cef_request_context_t* self,
+      const cef_string_t* origin, struct _cef_resolve_callback_t* callback);
+
+  ///
+  // Attempts to resolve |origin| to a list of associated IP addresses using
+  // cached data. |resolved_ips| will be populated with the list of resolved IP
+  // addresses or NULL if no cached data is available. Returns ERR_NONE on
+  // success. This function must be called on the browser process IO thread.
+  ///
+  cef_errorcode_t (CEF_CALLBACK *resolve_host_cached)(
+      struct _cef_request_context_t* self, const cef_string_t* origin,
+      cef_string_list_t resolved_ips);
+} cef_request_context_t;
+
+
+///
+// Returns the global context object.
+///
+CEF_EXPORT cef_request_context_t* cef_request_context_get_global_context();
+
+///
+// Creates a new context object with the specified |settings| and optional
+// |handler|.
+///
+CEF_EXPORT cef_request_context_t* cef_request_context_create_context(
+    const struct _cef_request_context_settings_t* settings,
+    struct _cef_request_context_handler_t* handler);
+
+///
+// Creates a new context object that shares storage with |other| and uses an
+// optional |handler|.
+///
+CEF_EXPORT cef_request_context_t* create_context_shared(
+    cef_request_context_t* other,
+    struct _cef_request_context_handler_t* handler);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_REQUEST_CONTEXT_CAPI_H_
diff --git a/src/include/libcef/capi/cef_request_context_handler_capi.h b/src/include/libcef/capi/cef_request_context_handler_capi.h
new file mode 100644
index 0000000..6c2ff51
--- /dev/null
+++ b/src/include/libcef/capi/cef_request_context_handler_capi.h
@@ -0,0 +1,99 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_REQUEST_CONTEXT_HANDLER_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_REQUEST_CONTEXT_HANDLER_CAPI_H_
+#pragma once
+
+#include "libcef/capi/cef_base_capi.h"
+#include "libcef/capi/cef_cookie_capi.h"
+#include "libcef/capi/cef_web_plugin_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Implement this structure to provide handler implementations. The handler
+// instance will not be released until all objects related to the context have
+// been destroyed.
+///
+typedef struct _cef_request_context_handler_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Called on the browser process IO thread to retrieve the cookie manager. If
+  // this function returns NULL the default cookie manager retrievable via
+  // cef_request_tContext::get_default_cookie_manager() will be used.
+  ///
+  struct _cef_cookie_manager_t* (CEF_CALLBACK *get_cookie_manager)(
+      struct _cef_request_context_handler_t* self);
+
+  ///
+  // Called on multiple browser process threads before a plugin instance is
+  // loaded. |mime_type| is the mime type of the plugin that will be loaded.
+  // |plugin_url| is the content URL that the plugin will load and may be NULL.
+  // |top_origin_url| is the URL for the top-level frame that contains the
+  // plugin when loading a specific plugin instance or NULL when building the
+  // initial list of enabled plugins for 'navigator.plugins' JavaScript state.
+  // |plugin_info| includes additional information about the plugin that will be
+  // loaded. |plugin_policy| is the recommended policy. Modify |plugin_policy|
+  // and return true (1) to change the policy. Return false (0) to use the
+  // recommended policy. The default plugin policy can be set at runtime using
+  // the `--plugin-policy=[allow|detect|block]` command-line flag. Decisions to
+  // mark a plugin as disabled by setting |plugin_policy| to
+  // PLUGIN_POLICY_DISABLED may be cached when |top_origin_url| is NULL. To
+  // purge the plugin list cache and potentially trigger new calls to this
+  // function call cef_request_tContext::PurgePluginListCache.
+  ///
+  int (CEF_CALLBACK *on_before_plugin_load)(
+      struct _cef_request_context_handler_t* self,
+      const cef_string_t* mime_type, const cef_string_t* plugin_url,
+      const cef_string_t* top_origin_url,
+      struct _cef_web_plugin_info_t* plugin_info,
+      cef_plugin_policy_t* plugin_policy);
+} cef_request_context_handler_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_REQUEST_CONTEXT_HANDLER_CAPI_H_
diff --git a/src/include/libcef/capi/cef_request_handler_capi.h b/src/include/libcef/capi/cef_request_handler_capi.h
new file mode 100644
index 0000000..6573f6b
--- /dev/null
+++ b/src/include/libcef/capi/cef_request_handler_capi.h
@@ -0,0 +1,270 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_REQUEST_HANDLER_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_REQUEST_HANDLER_CAPI_H_
+#pragma once
+
+#include "libcef/capi/cef_auth_callback_capi.h"
+#include "libcef/capi/cef_base_capi.h"
+#include "libcef/capi/cef_browser_capi.h"
+#include "libcef/capi/cef_frame_capi.h"
+#include "libcef/capi/cef_request_capi.h"
+#include "libcef/capi/cef_resource_handler_capi.h"
+#include "libcef/capi/cef_response_capi.h"
+#include "libcef/capi/cef_response_filter_capi.h"
+#include "libcef/capi/cef_ssl_info_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Callback structure used for asynchronous continuation of url requests.
+///
+typedef struct _cef_request_callback_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Continue the url request. If |allow| is true (1) the request will be
+  // continued. Otherwise, the request will be canceled.
+  ///
+  void (CEF_CALLBACK *cont)(struct _cef_request_callback_t* self, int allow);
+
+  ///
+  // Cancel the url request.
+  ///
+  void (CEF_CALLBACK *cancel)(struct _cef_request_callback_t* self);
+} cef_request_callback_t;
+
+
+///
+// Implement this structure to handle events related to browser requests. The
+// functions of this structure will be called on the thread indicated.
+///
+typedef struct _cef_request_handler_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Called on the UI thread before browser navigation. Return true (1) to
+  // cancel the navigation or false (0) to allow the navigation to proceed. The
+  // |request| object cannot be modified in this callback.
+  // cef_load_handler_t::OnLoadingStateChange will be called twice in all cases.
+  // If the navigation is allowed cef_load_handler_t::OnLoadStart and
+  // cef_load_handler_t::OnLoadEnd will be called. If the navigation is canceled
+  // cef_load_handler_t::OnLoadError will be called with an |errorCode| value of
+  // ERR_ABORTED.
+  ///
+  int (CEF_CALLBACK *on_before_browse)(struct _cef_request_handler_t* self,
+      struct _cef_browser_t* browser, struct _cef_frame_t* frame,
+      struct _cef_request_t* request, int is_redirect);
+
+  ///
+  // Called on the UI thread before OnBeforeBrowse in certain limited cases
+  // where navigating a new or different browser might be desirable. This
+  // includes user-initiated navigation that might open in a special way (e.g.
+  // links clicked via middle-click or ctrl + left-click) and certain types of
+  // cross-origin navigation initiated from the renderer process (e.g.
+  // navigating the top-level frame to/from a file URL). The |browser| and
+  // |frame| values represent the source of the navigation. The
+  // |target_disposition| value indicates where the user intended to navigate
+  // the browser based on standard Chromium behaviors (e.g. current tab, new
+  // tab, etc). The |user_gesture| value will be true (1) if the browser
+  // navigated via explicit user gesture (e.g. clicking a link) or false (0) if
+  // it navigated automatically (e.g. via the DomContentLoaded event). Return
+  // true (1) to cancel the navigation or false (0) to allow the navigation to
+  // proceed in the source browser's top-level frame.
+  ///
+  int (CEF_CALLBACK *on_open_urlfrom_tab)(struct _cef_request_handler_t* self,
+      struct _cef_browser_t* browser, struct _cef_frame_t* frame,
+      const cef_string_t* target_url,
+      cef_window_open_disposition_t target_disposition, int user_gesture);
+
+  ///
+  // Called on the IO thread before a resource request is loaded. The |request|
+  // object may be modified. Return RV_CONTINUE to continue the request
+  // immediately. Return RV_CONTINUE_ASYNC and call cef_request_tCallback::
+  // cont() at a later time to continue or cancel the request asynchronously.
+  // Return RV_CANCEL to cancel the request immediately.
+  //
+  ///
+  cef_return_value_t (CEF_CALLBACK *on_before_resource_load)(
+      struct _cef_request_handler_t* self, struct _cef_browser_t* browser,
+      struct _cef_frame_t* frame, struct _cef_request_t* request,
+      struct _cef_request_callback_t* callback);
+
+  ///
+  // Called on the IO thread before a resource is loaded. To allow the resource
+  // to load normally return NULL. To specify a handler for the resource return
+  // a cef_resource_handler_t object. The |request| object should not be
+  // modified in this callback.
+  ///
+  struct _cef_resource_handler_t* (CEF_CALLBACK *get_resource_handler)(
+      struct _cef_request_handler_t* self, struct _cef_browser_t* browser,
+      struct _cef_frame_t* frame, struct _cef_request_t* request);
+
+  ///
+  // Called on the IO thread when a resource load is redirected. The |request|
+  // parameter will contain the old URL and other request-related information.
+  // The |new_url| parameter will contain the new URL and can be changed if
+  // desired. The |request| object cannot be modified in this callback.
+  ///
+  void (CEF_CALLBACK *on_resource_redirect)(struct _cef_request_handler_t* self,
+      struct _cef_browser_t* browser, struct _cef_frame_t* frame,
+      struct _cef_request_t* request, cef_string_t* new_url);
+
+  ///
+  // Called on the IO thread when a resource response is received. To allow the
+  // resource to load normally return false (0). To redirect or retry the
+  // resource modify |request| (url, headers or post body) and return true (1).
+  // The |response| object cannot be modified in this callback.
+  ///
+  int (CEF_CALLBACK *on_resource_response)(struct _cef_request_handler_t* self,
+      struct _cef_browser_t* browser, struct _cef_frame_t* frame,
+      struct _cef_request_t* request, struct _cef_response_t* response);
+
+  ///
+  // Called on the IO thread to optionally filter resource response content.
+  // |request| and |response| represent the request and response respectively
+  // and cannot be modified in this callback.
+  ///
+  struct _cef_response_filter_t* (CEF_CALLBACK *get_resource_response_filter)(
+      struct _cef_request_handler_t* self, struct _cef_browser_t* browser,
+      struct _cef_frame_t* frame, struct _cef_request_t* request,
+      struct _cef_response_t* response);
+
+  ///
+  // Called on the IO thread when a resource load has completed. |request| and
+  // |response| represent the request and response respectively and cannot be
+  // modified in this callback. |status| indicates the load completion status.
+  // |received_content_length| is the number of response bytes actually read.
+  ///
+  void (CEF_CALLBACK *on_resource_load_complete)(
+      struct _cef_request_handler_t* self, struct _cef_browser_t* browser,
+      struct _cef_frame_t* frame, struct _cef_request_t* request,
+      struct _cef_response_t* response, cef_urlrequest_status_t status,
+      int64 received_content_length);
+
+  ///
+  // Called on the IO thread when the browser needs credentials from the user.
+  // |isProxy| indicates whether the host is a proxy server. |host| contains the
+  // hostname and |port| contains the port number. |realm| is the realm of the
+  // challenge and may be NULL. |scheme| is the authentication scheme used, such
+  // as "basic" or "digest", and will be NULL if the source of the request is an
+  // FTP server. Return true (1) to continue the request and call
+  // cef_auth_callback_t::cont() either in this function or at a later time when
+  // the authentication information is available. Return false (0) to cancel the
+  // request immediately.
+  ///
+  int (CEF_CALLBACK *get_auth_credentials)(struct _cef_request_handler_t* self,
+      struct _cef_browser_t* browser, struct _cef_frame_t* frame, int isProxy,
+      const cef_string_t* host, int port, const cef_string_t* realm,
+      const cef_string_t* scheme, struct _cef_auth_callback_t* callback);
+
+  ///
+  // Called on the IO thread when JavaScript requests a specific storage quota
+  // size via the webkitStorageInfo.requestQuota function. |origin_url| is the
+  // origin of the page making the request. |new_size| is the requested quota
+  // size in bytes. Return true (1) to continue the request and call
+  // cef_request_tCallback::cont() either in this function or at a later time to
+  // grant or deny the request. Return false (0) to cancel the request
+  // immediately.
+  ///
+  int (CEF_CALLBACK *on_quota_request)(struct _cef_request_handler_t* self,
+      struct _cef_browser_t* browser, const cef_string_t* origin_url,
+      int64 new_size, struct _cef_request_callback_t* callback);
+
+  ///
+  // Called on the UI thread to handle requests for URLs with an unknown
+  // protocol component. Set |allow_os_execution| to true (1) to attempt
+  // execution via the registered OS protocol handler, if any. SECURITY WARNING:
+  // YOU SHOULD USE THIS METHOD TO ENFORCE RESTRICTIONS BASED ON SCHEME, HOST OR
+  // OTHER URL ANALYSIS BEFORE ALLOWING OS EXECUTION.
+  ///
+  void (CEF_CALLBACK *on_protocol_execution)(
+      struct _cef_request_handler_t* self, struct _cef_browser_t* browser,
+      const cef_string_t* url, int* allow_os_execution);
+
+  ///
+  // Called on the UI thread to handle requests for URLs with an invalid SSL
+  // certificate. Return true (1) and call cef_request_tCallback::cont() either
+  // in this function or at a later time to continue or cancel the request.
+  // Return false (0) to cancel the request immediately. If
+  // CefSettings.ignore_certificate_errors is set all invalid certificates will
+  // be accepted without calling this function.
+  ///
+  int (CEF_CALLBACK *on_certificate_error)(struct _cef_request_handler_t* self,
+      struct _cef_browser_t* browser, cef_errorcode_t cert_error,
+      const cef_string_t* request_url, struct _cef_sslinfo_t* ssl_info,
+      struct _cef_request_callback_t* callback);
+
+  ///
+  // Called on the browser process UI thread when a plugin has crashed.
+  // |plugin_path| is the path of the plugin that crashed.
+  ///
+  void (CEF_CALLBACK *on_plugin_crashed)(struct _cef_request_handler_t* self,
+      struct _cef_browser_t* browser, const cef_string_t* plugin_path);
+
+  ///
+  // Called on the browser process UI thread when the render view associated
+  // with |browser| is ready to receive/handle IPC messages in the render
+  // process.
+  ///
+  void (CEF_CALLBACK *on_render_view_ready)(struct _cef_request_handler_t* self,
+      struct _cef_browser_t* browser);
+
+  ///
+  // Called on the browser process UI thread when the render process terminates
+  // unexpectedly. |status| indicates how the process terminated.
+  ///
+  void (CEF_CALLBACK *on_render_process_terminated)(
+      struct _cef_request_handler_t* self, struct _cef_browser_t* browser,
+      cef_termination_status_t status);
+} cef_request_handler_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_REQUEST_HANDLER_CAPI_H_
diff --git a/src/include/libcef/capi/cef_resource_bundle_capi.h b/src/include/libcef/capi/cef_resource_bundle_capi.h
new file mode 100644
index 0000000..6f94e0e
--- /dev/null
+++ b/src/include/libcef/capi/cef_resource_bundle_capi.h
@@ -0,0 +1,107 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_RESOURCE_BUNDLE_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_RESOURCE_BUNDLE_CAPI_H_
+#pragma once
+
+#include "libcef/capi/cef_base_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Structure used for retrieving resources from the resource bundle (*.pak)
+// files loaded by CEF during startup or via the cef_resource_bundle_tHandler
+// returned from cef_app_t::GetResourceBundleHandler. See CefSettings for
+// additional options related to resource bundle loading. The functions of this
+// structure may be called on any thread unless otherwise indicated.
+///
+typedef struct _cef_resource_bundle_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns the localized string for the specified |string_id| or an NULL
+  // string if the value is not found. Include cef_pack_strings.h for a listing
+  // of valid string ID values.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_localized_string)(
+      struct _cef_resource_bundle_t* self, int string_id);
+
+  ///
+  // Retrieves the contents of the specified scale independent |resource_id|. If
+  // the value is found then |data| and |data_size| will be populated and this
+  // function will return true (1). If the value is not found then this function
+  // will return false (0). The returned |data| pointer will remain resident in
+  // memory and should not be freed. Include cef_pack_resources.h for a listing
+  // of valid resource ID values.
+  ///
+  int (CEF_CALLBACK *get_data_resource)(struct _cef_resource_bundle_t* self,
+      int resource_id, void** data, size_t* data_size);
+
+  ///
+  // Retrieves the contents of the specified |resource_id| nearest the scale
+  // factor |scale_factor|. Use a |scale_factor| value of SCALE_FACTOR_NONE for
+  // scale independent resources or call GetDataResource instead. If the value
+  // is found then |data| and |data_size| will be populated and this function
+  // will return true (1). If the value is not found then this function will
+  // return false (0). The returned |data| pointer will remain resident in
+  // memory and should not be freed. Include cef_pack_resources.h for a listing
+  // of valid resource ID values.
+  ///
+  int (CEF_CALLBACK *get_data_resource_for_scale)(
+      struct _cef_resource_bundle_t* self, int resource_id,
+      cef_scale_factor_t scale_factor, void** data, size_t* data_size);
+} cef_resource_bundle_t;
+
+
+///
+// Returns the global resource bundle instance.
+///
+CEF_EXPORT cef_resource_bundle_t* cef_resource_bundle_get_global();
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_RESOURCE_BUNDLE_CAPI_H_
diff --git a/src/include/libcef/capi/cef_resource_bundle_handler_capi.h b/src/include/libcef/capi/cef_resource_bundle_handler_capi.h
new file mode 100644
index 0000000..156ba06
--- /dev/null
+++ b/src/include/libcef/capi/cef_resource_bundle_handler_capi.h
@@ -0,0 +1,99 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_RESOURCE_BUNDLE_HANDLER_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_RESOURCE_BUNDLE_HANDLER_CAPI_H_
+#pragma once
+
+#include "libcef/capi/cef_base_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Structure used to implement a custom resource bundle structure. See
+// CefSettings for additional options related to resource bundle loading. The
+// functions of this structure may be called on multiple threads.
+///
+typedef struct _cef_resource_bundle_handler_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Called to retrieve a localized translation for the specified |string_id|.
+  // To provide the translation set |string| to the translation string and
+  // return true (1). To use the default translation return false (0). Include
+  // cef_pack_strings.h for a listing of valid string ID values.
+  ///
+  int (CEF_CALLBACK *get_localized_string)(
+      struct _cef_resource_bundle_handler_t* self, int string_id,
+      cef_string_t* string);
+
+  ///
+  // Called to retrieve data for the specified scale independent |resource_id|.
+  // To provide the resource data set |data| and |data_size| to the data pointer
+  // and size respectively and return true (1). To use the default resource data
+  // return false (0). The resource data will not be copied and must remain
+  // resident in memory. Include cef_pack_resources.h for a listing of valid
+  // resource ID values.
+  ///
+  int (CEF_CALLBACK *get_data_resource)(
+      struct _cef_resource_bundle_handler_t* self, int resource_id, void** data,
+      size_t* data_size);
+
+  ///
+  // Called to retrieve data for the specified |resource_id| nearest the scale
+  // factor |scale_factor|. To provide the resource data set |data| and
+  // |data_size| to the data pointer and size respectively and return true (1).
+  // To use the default resource data return false (0). The resource data will
+  // not be copied and must remain resident in memory. Include
+  // cef_pack_resources.h for a listing of valid resource ID values.
+  ///
+  int (CEF_CALLBACK *get_data_resource_for_scale)(
+      struct _cef_resource_bundle_handler_t* self, int resource_id,
+      cef_scale_factor_t scale_factor, void** data, size_t* data_size);
+} cef_resource_bundle_handler_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_RESOURCE_BUNDLE_HANDLER_CAPI_H_
diff --git a/src/include/libcef/capi/cef_resource_handler_capi.h b/src/include/libcef/capi/cef_resource_handler_capi.h
new file mode 100644
index 0000000..c32a5f8
--- /dev/null
+++ b/src/include/libcef/capi/cef_resource_handler_capi.h
@@ -0,0 +1,125 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_RESOURCE_HANDLER_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_RESOURCE_HANDLER_CAPI_H_
+#pragma once
+
+#include "libcef/capi/cef_base_capi.h"
+#include "libcef/capi/cef_browser_capi.h"
+#include "libcef/capi/cef_callback_capi.h"
+#include "libcef/capi/cef_cookie_capi.h"
+#include "libcef/capi/cef_request_capi.h"
+#include "libcef/capi/cef_response_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Structure used to implement a custom request handler structure. The functions
+// of this structure will always be called on the IO thread.
+///
+typedef struct _cef_resource_handler_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Begin processing the request. To handle the request return true (1) and
+  // call cef_callback_t::cont() once the response header information is
+  // available (cef_callback_t::cont() can also be called from inside this
+  // function if header information is available immediately). To cancel the
+  // request return false (0).
+  ///
+  int (CEF_CALLBACK *process_request)(struct _cef_resource_handler_t* self,
+      struct _cef_request_t* request, struct _cef_callback_t* callback);
+
+  ///
+  // Retrieve response header information. If the response length is not known
+  // set |response_length| to -1 and read_response() will be called until it
+  // returns false (0). If the response length is known set |response_length| to
+  // a positive value and read_response() will be called until it returns false
+  // (0) or the specified number of bytes have been read. Use the |response|
+  // object to set the mime type, http status code and other optional header
+  // values. To redirect the request to a new URL set |redirectUrl| to the new
+  // URL. If an error occured while setting up the request you can call
+  // set_error() on |response| to indicate the error condition.
+  ///
+  void (CEF_CALLBACK *get_response_headers)(
+      struct _cef_resource_handler_t* self, struct _cef_response_t* response,
+      int64* response_length, cef_string_t* redirectUrl);
+
+  ///
+  // Read response data. If data is available immediately copy up to
+  // |bytes_to_read| bytes into |data_out|, set |bytes_read| to the number of
+  // bytes copied, and return true (1). To read the data at a later time set
+  // |bytes_read| to 0, return true (1) and call cef_callback_t::cont() when the
+  // data is available. To indicate response completion return false (0).
+  ///
+  int (CEF_CALLBACK *read_response)(struct _cef_resource_handler_t* self,
+      void* data_out, int bytes_to_read, int* bytes_read,
+      struct _cef_callback_t* callback);
+
+  ///
+  // Return true (1) if the specified cookie can be sent with the request or
+  // false (0) otherwise. If false (0) is returned for any cookie then no
+  // cookies will be sent with the request.
+  ///
+  int (CEF_CALLBACK *can_get_cookie)(struct _cef_resource_handler_t* self,
+      const struct _cef_cookie_t* cookie);
+
+  ///
+  // Return true (1) if the specified cookie returned with the response can be
+  // set or false (0) otherwise.
+  ///
+  int (CEF_CALLBACK *can_set_cookie)(struct _cef_resource_handler_t* self,
+      const struct _cef_cookie_t* cookie);
+
+  ///
+  // Request processing has been canceled.
+  ///
+  void (CEF_CALLBACK *cancel)(struct _cef_resource_handler_t* self);
+} cef_resource_handler_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_RESOURCE_HANDLER_CAPI_H_
diff --git a/src/include/libcef/capi/cef_response_capi.h b/src/include/libcef/capi/cef_response_capi.h
new file mode 100644
index 0000000..e5c746d
--- /dev/null
+++ b/src/include/libcef/capi/cef_response_capi.h
@@ -0,0 +1,142 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_RESPONSE_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_RESPONSE_CAPI_H_
+#pragma once
+
+#include "libcef/capi/cef_base_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Structure used to represent a web response. The functions of this structure
+// may be called on any thread.
+///
+typedef struct _cef_response_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns true (1) if this object is read-only.
+  ///
+  int (CEF_CALLBACK *is_read_only)(struct _cef_response_t* self);
+
+  ///
+  // Get the response error code. Returns ERR_NONE if there was no error.
+  ///
+  cef_errorcode_t (CEF_CALLBACK *get_error)(struct _cef_response_t* self);
+
+  ///
+  // Set the response error code. This can be used by custom scheme handlers to
+  // return errors during initial request processing.
+  ///
+  void (CEF_CALLBACK *set_error)(struct _cef_response_t* self,
+      cef_errorcode_t error);
+
+  ///
+  // Get the response status code.
+  ///
+  int (CEF_CALLBACK *get_status)(struct _cef_response_t* self);
+
+  ///
+  // Set the response status code.
+  ///
+  void (CEF_CALLBACK *set_status)(struct _cef_response_t* self, int status);
+
+  ///
+  // Get the response status text.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_status_text)(
+      struct _cef_response_t* self);
+
+  ///
+  // Set the response status text.
+  ///
+  void (CEF_CALLBACK *set_status_text)(struct _cef_response_t* self,
+      const cef_string_t* statusText);
+
+  ///
+  // Get the response mime type.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_mime_type)(
+      struct _cef_response_t* self);
+
+  ///
+  // Set the response mime type.
+  ///
+  void (CEF_CALLBACK *set_mime_type)(struct _cef_response_t* self,
+      const cef_string_t* mimeType);
+
+  ///
+  // Get the value for the specified response header field.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_header)(struct _cef_response_t* self,
+      const cef_string_t* name);
+
+  ///
+  // Get all response header fields.
+  ///
+  void (CEF_CALLBACK *get_header_map)(struct _cef_response_t* self,
+      cef_string_multimap_t headerMap);
+
+  ///
+  // Set all response header fields.
+  ///
+  void (CEF_CALLBACK *set_header_map)(struct _cef_response_t* self,
+      cef_string_multimap_t headerMap);
+} cef_response_t;
+
+
+///
+// Create a new cef_response_t object.
+///
+CEF_EXPORT cef_response_t* cef_response_create();
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_RESPONSE_CAPI_H_
diff --git a/src/include/libcef/capi/cef_response_filter_capi.h b/src/include/libcef/capi/cef_response_filter_capi.h
new file mode 100644
index 0000000..f8d4933
--- /dev/null
+++ b/src/include/libcef/capi/cef_response_filter_capi.h
@@ -0,0 +1,93 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_RESPONSE_FILTER_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_RESPONSE_FILTER_CAPI_H_
+#pragma once
+
+#include "libcef/capi/cef_base_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Implement this structure to filter resource response content. The functions
+// of this structure will be called on the browser process IO thread.
+///
+typedef struct _cef_response_filter_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Initialize the response filter. Will only be called a single time. The
+  // filter will not be installed if this function returns false (0).
+  ///
+  int (CEF_CALLBACK *init_filter)(struct _cef_response_filter_t* self);
+
+  ///
+  // Called to filter a chunk of data. |data_in| is the input buffer containing
+  // |data_in_size| bytes of pre-filter data (|data_in| will be NULL if
+  // |data_in_size| is zero). |data_out| is the output buffer that can accept up
+  // to |data_out_size| bytes of filtered output data. Set |data_in_read| to the
+  // number of bytes that were read from |data_in|. Set |data_out_written| to
+  // the number of bytes that were written into |data_out|. If some or all of
+  // the pre-filter data was read successfully but more data is needed in order
+  // to continue filtering (filtered output is pending) return
+  // RESPONSE_FILTER_NEED_MORE_DATA. If some or all of the pre-filter data was
+  // read successfully and all available filtered output has been written return
+  // RESPONSE_FILTER_DONE. If an error occurs during filtering return
+  // RESPONSE_FILTER_ERROR. This function will be called repeatedly until there
+  // is no more data to filter (resource response is complete), |data_in_read|
+  // matches |data_in_size| (all available pre-filter bytes have been read), and
+  // the function returns RESPONSE_FILTER_DONE or RESPONSE_FILTER_ERROR. Do not
+  // keep a reference to the buffers passed to this function.
+  ///
+  cef_response_filter_status_t (CEF_CALLBACK *filter)(
+      struct _cef_response_filter_t* self, void* data_in, size_t data_in_size,
+      size_t* data_in_read, void* data_out, size_t data_out_size,
+      size_t* data_out_written);
+} cef_response_filter_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_RESPONSE_FILTER_CAPI_H_
diff --git a/src/include/libcef/capi/cef_scheme_capi.h b/src/include/libcef/capi/cef_scheme_capi.h
new file mode 100644
index 0000000..85206bb
--- /dev/null
+++ b/src/include/libcef/capi/cef_scheme_capi.h
@@ -0,0 +1,173 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_SCHEME_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_SCHEME_CAPI_H_
+#pragma once
+
+#include "libcef/capi/cef_base_capi.h"
+#include "libcef/capi/cef_browser_capi.h"
+#include "libcef/capi/cef_frame_capi.h"
+#include "libcef/capi/cef_request_capi.h"
+#include "libcef/capi/cef_resource_handler_capi.h"
+#include "libcef/capi/cef_response_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _cef_scheme_handler_factory_t;
+
+///
+// Structure that manages custom scheme registrations.
+///
+typedef struct _cef_scheme_registrar_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Register a custom scheme. This function should not be called for the built-
+  // in HTTP, HTTPS, FILE, FTP, ABOUT and DATA schemes.
+  //
+  // If |is_standard| is true (1) the scheme will be treated as a standard
+  // scheme. Standard schemes are subject to URL canonicalization and parsing
+  // rules as defined in the Common Internet Scheme Syntax RFC 1738 Section 3.1
+  // available at http://www.ietf.org/rfc/rfc1738.txt
+  //
+  // In particular, the syntax for standard scheme URLs must be of the form:
+  // <pre>
+  //  [scheme]://[username]:[password]@[host]:[port]/[url-path]
+  // </pre> Standard scheme URLs must have a host component that is a fully
+  // qualified domain name as defined in Section 3.5 of RFC 1034 [13] and
+  // Section 2.1 of RFC 1123. These URLs will be canonicalized to
+  // "scheme://host/path" in the simplest case and
+  // "scheme://username:password@host:port/path" in the most explicit case. For
+  // example, "scheme:host/path" and "scheme:///host/path" will both be
+  // canonicalized to "scheme://host/path". The origin of a standard scheme URL
+  // is the combination of scheme, host and port (i.e., "scheme://host:port" in
+  // the most explicit case).
+  //
+  // For non-standard scheme URLs only the "scheme:" component is parsed and
+  // canonicalized. The remainder of the URL will be passed to the handler as-
+  // is. For example, "scheme:///some%20text" will remain the same. Non-standard
+  // scheme URLs cannot be used as a target for form submission.
+  //
+  // If |is_local| is true (1) the scheme will be treated as local (i.e., with
+  // the same security rules as those applied to "file" URLs). Normal pages
+  // cannot link to or access local URLs. Also, by default, local URLs can only
+  // perform XMLHttpRequest calls to the same URL (origin + path) that
+  // originated the request. To allow XMLHttpRequest calls from a local URL to
+  // other URLs with the same origin set the
+  // CefSettings.file_access_from_file_urls_allowed value to true (1). To allow
+  // XMLHttpRequest calls from a local URL to all origins set the
+  // CefSettings.universal_access_from_file_urls_allowed value to true (1).
+  //
+  // If |is_display_isolated| is true (1) the scheme will be treated as display-
+  // isolated. This means that pages cannot display these URLs unless they are
+  // from the same scheme. For example, pages in another origin cannot create
+  // iframes or hyperlinks to URLs with this scheme.
+  //
+  // This function may be called on any thread. It should only be called once
+  // per unique |scheme_name| value. If |scheme_name| is already registered or
+  // if an error occurs this function will return false (0).
+  ///
+  int (CEF_CALLBACK *add_custom_scheme)(struct _cef_scheme_registrar_t* self,
+      const cef_string_t* scheme_name, int is_standard, int is_local,
+      int is_display_isolated);
+} cef_scheme_registrar_t;
+
+
+///
+// Structure that creates cef_resource_handler_t instances for handling scheme
+// requests. The functions of this structure will always be called on the IO
+// thread.
+///
+typedef struct _cef_scheme_handler_factory_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Return a new resource handler instance to handle the request or an NULL
+  // reference to allow default handling of the request. |browser| and |frame|
+  // will be the browser window and frame respectively that originated the
+  // request or NULL if the request did not originate from a browser window (for
+  // example, if the request came from cef_urlrequest_t). The |request| object
+  // passed to this function will not contain cookie data.
+  ///
+  struct _cef_resource_handler_t* (CEF_CALLBACK *create)(
+      struct _cef_scheme_handler_factory_t* self,
+      struct _cef_browser_t* browser, struct _cef_frame_t* frame,
+      const cef_string_t* scheme_name, struct _cef_request_t* request);
+} cef_scheme_handler_factory_t;
+
+
+///
+// Register a scheme handler factory with the global request context. An NULL
+// |domain_name| value for a standard scheme will cause the factory to match all
+// domain names. The |domain_name| value will be ignored for non-standard
+// schemes. If |scheme_name| is a built-in scheme and no handler is returned by
+// |factory| then the built-in scheme handler factory will be called. If
+// |scheme_name| is a custom scheme then you must also implement the
+// cef_app_t::on_register_custom_schemes() function in all processes. This
+// function may be called multiple times to change or remove the factory that
+// matches the specified |scheme_name| and optional |domain_name|. Returns false
+// (0) if an error occurs. This function may be called on any thread in the
+// browser process. Using this function is equivalent to calling cef_request_tCo
+// ntext::cef_request_context_get_global_context()->register_scheme_handler_fact
+// ory().
+///
+CEF_EXPORT int cef_register_scheme_handler_factory(
+    const cef_string_t* scheme_name, const cef_string_t* domain_name,
+    cef_scheme_handler_factory_t* factory);
+
+///
+// Clear all scheme handler factories registered with the global request
+// context. Returns false (0) on error. This function may be called on any
+// thread in the browser process. Using this function is equivalent to calling c
+// ef_request_tContext::cef_request_context_get_global_context()->clear_scheme_h
+// andler_factories().
+///
+CEF_EXPORT int cef_clear_scheme_handler_factories();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_SCHEME_CAPI_H_
diff --git a/src/include/libcef/capi/cef_ssl_info_capi.h b/src/include/libcef/capi/cef_ssl_info_capi.h
new file mode 100644
index 0000000..98fdbca
--- /dev/null
+++ b/src/include/libcef/capi/cef_ssl_info_capi.h
@@ -0,0 +1,220 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_SSL_INFO_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_SSL_INFO_CAPI_H_
+#pragma once
+
+#include "libcef/capi/cef_base_capi.h"
+#include "libcef/capi/cef_values_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Structure representing the issuer or subject field of an X.509 certificate.
+///
+typedef struct _cef_sslcert_principal_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns a name that can be used to represent the issuer.  It tries in this
+  // order: CN, O and OU and returns the first non-NULL one found.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_display_name)(
+      struct _cef_sslcert_principal_t* self);
+
+  ///
+  // Returns the common name.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_common_name)(
+      struct _cef_sslcert_principal_t* self);
+
+  ///
+  // Returns the locality name.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_locality_name)(
+      struct _cef_sslcert_principal_t* self);
+
+  ///
+  // Returns the state or province name.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_state_or_province_name)(
+      struct _cef_sslcert_principal_t* self);
+
+  ///
+  // Returns the country name.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_country_name)(
+      struct _cef_sslcert_principal_t* self);
+
+  ///
+  // Retrieve the list of street addresses.
+  ///
+  void (CEF_CALLBACK *get_street_addresses)(
+      struct _cef_sslcert_principal_t* self, cef_string_list_t addresses);
+
+  ///
+  // Retrieve the list of organization names.
+  ///
+  void (CEF_CALLBACK *get_organization_names)(
+      struct _cef_sslcert_principal_t* self, cef_string_list_t names);
+
+  ///
+  // Retrieve the list of organization unit names.
+  ///
+  void (CEF_CALLBACK *get_organization_unit_names)(
+      struct _cef_sslcert_principal_t* self, cef_string_list_t names);
+
+  ///
+  // Retrieve the list of domain components.
+  ///
+  void (CEF_CALLBACK *get_domain_components)(
+      struct _cef_sslcert_principal_t* self, cef_string_list_t components);
+} cef_sslcert_principal_t;
+
+
+///
+// Structure representing SSL information.
+///
+typedef struct _cef_sslinfo_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns a bitmask containing any and all problems verifying the server
+  // certificate.
+  ///
+  cef_cert_status_t (CEF_CALLBACK *get_cert_status)(
+      struct _cef_sslinfo_t* self);
+
+  ///
+  // Returns true (1) if the certificate status has any error, major or minor.
+  ///
+  int (CEF_CALLBACK *is_cert_status_error)(struct _cef_sslinfo_t* self);
+
+  ///
+  // Returns true (1) if the certificate status represents only minor errors
+  // (e.g. failure to verify certificate revocation).
+  ///
+  int (CEF_CALLBACK *is_cert_status_minor_error)(struct _cef_sslinfo_t* self);
+
+  ///
+  // Returns the subject of the X.509 certificate. For HTTPS server certificates
+  // this represents the web server.  The common name of the subject should
+  // match the host name of the web server.
+  ///
+  struct _cef_sslcert_principal_t* (CEF_CALLBACK *get_subject)(
+      struct _cef_sslinfo_t* self);
+
+  ///
+  // Returns the issuer of the X.509 certificate.
+  ///
+  struct _cef_sslcert_principal_t* (CEF_CALLBACK *get_issuer)(
+      struct _cef_sslinfo_t* self);
+
+  ///
+  // Returns the DER encoded serial number for the X.509 certificate. The value
+  // possibly includes a leading 00 byte.
+  ///
+  struct _cef_binary_value_t* (CEF_CALLBACK *get_serial_number)(
+      struct _cef_sslinfo_t* self);
+
+  ///
+  // Returns the date before which the X.509 certificate is invalid.
+  // CefTime.GetTimeT() will return 0 if no date was specified.
+  ///
+  cef_time_t (CEF_CALLBACK *get_valid_start)(struct _cef_sslinfo_t* self);
+
+  ///
+  // Returns the date after which the X.509 certificate is invalid.
+  // CefTime.GetTimeT() will return 0 if no date was specified.
+  ///
+  cef_time_t (CEF_CALLBACK *get_valid_expiry)(struct _cef_sslinfo_t* self);
+
+  ///
+  // Returns the DER encoded data for the X.509 certificate.
+  ///
+  struct _cef_binary_value_t* (CEF_CALLBACK *get_derencoded)(
+      struct _cef_sslinfo_t* self);
+
+  ///
+  // Returns the PEM encoded data for the X.509 certificate.
+  ///
+  struct _cef_binary_value_t* (CEF_CALLBACK *get_pemencoded)(
+      struct _cef_sslinfo_t* self);
+
+  ///
+  // Returns the number of certificates in the issuer chain. If 0, the
+  // certificate is self-signed.
+  ///
+  size_t (CEF_CALLBACK *get_issuer_chain_size)(struct _cef_sslinfo_t* self);
+
+  ///
+  // Returns the DER encoded data for the certificate issuer chain. If we failed
+  // to encode a certificate in the chain it is still present in the array but
+  // is an NULL string.
+  ///
+  void (CEF_CALLBACK *get_derencoded_issuer_chain)(struct _cef_sslinfo_t* self,
+      size_t* chainCount, struct _cef_binary_value_t** chain);
+
+  ///
+  // Returns the PEM encoded data for the certificate issuer chain. If we failed
+  // to encode a certificate in the chain it is still present in the array but
+  // is an NULL string.
+  ///
+  void (CEF_CALLBACK *get_pemencoded_issuer_chain)(struct _cef_sslinfo_t* self,
+      size_t* chainCount, struct _cef_binary_value_t** chain);
+} cef_sslinfo_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_SSL_INFO_CAPI_H_
diff --git a/src/include/libcef/capi/cef_stream_capi.h b/src/include/libcef/capi/cef_stream_capi.h
new file mode 100644
index 0000000..2083f18
--- /dev/null
+++ b/src/include/libcef/capi/cef_stream_capi.h
@@ -0,0 +1,252 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_STREAM_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_STREAM_CAPI_H_
+#pragma once
+
+#include "libcef/capi/cef_base_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Structure the client can implement to provide a custom stream reader. The
+// functions of this structure may be called on any thread.
+///
+typedef struct _cef_read_handler_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Read raw binary data.
+  ///
+  size_t (CEF_CALLBACK *read)(struct _cef_read_handler_t* self, void* ptr,
+      size_t size, size_t n);
+
+  ///
+  // Seek to the specified offset position. |whence| may be any one of SEEK_CUR,
+  // SEEK_END or SEEK_SET. Return zero on success and non-zero on failure.
+  ///
+  int (CEF_CALLBACK *seek)(struct _cef_read_handler_t* self, int64 offset,
+      int whence);
+
+  ///
+  // Return the current offset position.
+  ///
+  int64 (CEF_CALLBACK *tell)(struct _cef_read_handler_t* self);
+
+  ///
+  // Return non-zero if at end of file.
+  ///
+  int (CEF_CALLBACK *eof)(struct _cef_read_handler_t* self);
+
+  ///
+  // Return true (1) if this handler performs work like accessing the file
+  // system which may block. Used as a hint for determining the thread to access
+  // the handler from.
+  ///
+  int (CEF_CALLBACK *may_block)(struct _cef_read_handler_t* self);
+} cef_read_handler_t;
+
+
+///
+// Structure used to read data from a stream. The functions of this structure
+// may be called on any thread.
+///
+typedef struct _cef_stream_reader_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Read raw binary data.
+  ///
+  size_t (CEF_CALLBACK *read)(struct _cef_stream_reader_t* self, void* ptr,
+      size_t size, size_t n);
+
+  ///
+  // Seek to the specified offset position. |whence| may be any one of SEEK_CUR,
+  // SEEK_END or SEEK_SET. Returns zero on success and non-zero on failure.
+  ///
+  int (CEF_CALLBACK *seek)(struct _cef_stream_reader_t* self, int64 offset,
+      int whence);
+
+  ///
+  // Return the current offset position.
+  ///
+  int64 (CEF_CALLBACK *tell)(struct _cef_stream_reader_t* self);
+
+  ///
+  // Return non-zero if at end of file.
+  ///
+  int (CEF_CALLBACK *eof)(struct _cef_stream_reader_t* self);
+
+  ///
+  // Returns true (1) if this reader performs work like accessing the file
+  // system which may block. Used as a hint for determining the thread to access
+  // the reader from.
+  ///
+  int (CEF_CALLBACK *may_block)(struct _cef_stream_reader_t* self);
+} cef_stream_reader_t;
+
+
+///
+// Create a new cef_stream_reader_t object from a file.
+///
+CEF_EXPORT cef_stream_reader_t* cef_stream_reader_create_for_file(
+    const cef_string_t* fileName);
+
+///
+// Create a new cef_stream_reader_t object from data.
+///
+CEF_EXPORT cef_stream_reader_t* cef_stream_reader_create_for_data(void* data,
+    size_t size);
+
+///
+// Create a new cef_stream_reader_t object from a custom handler.
+///
+CEF_EXPORT cef_stream_reader_t* cef_stream_reader_create_for_handler(
+    cef_read_handler_t* handler);
+
+
+///
+// Structure the client can implement to provide a custom stream writer. The
+// functions of this structure may be called on any thread.
+///
+typedef struct _cef_write_handler_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Write raw binary data.
+  ///
+  size_t (CEF_CALLBACK *write)(struct _cef_write_handler_t* self,
+      const void* ptr, size_t size, size_t n);
+
+  ///
+  // Seek to the specified offset position. |whence| may be any one of SEEK_CUR,
+  // SEEK_END or SEEK_SET. Return zero on success and non-zero on failure.
+  ///
+  int (CEF_CALLBACK *seek)(struct _cef_write_handler_t* self, int64 offset,
+      int whence);
+
+  ///
+  // Return the current offset position.
+  ///
+  int64 (CEF_CALLBACK *tell)(struct _cef_write_handler_t* self);
+
+  ///
+  // Flush the stream.
+  ///
+  int (CEF_CALLBACK *flush)(struct _cef_write_handler_t* self);
+
+  ///
+  // Return true (1) if this handler performs work like accessing the file
+  // system which may block. Used as a hint for determining the thread to access
+  // the handler from.
+  ///
+  int (CEF_CALLBACK *may_block)(struct _cef_write_handler_t* self);
+} cef_write_handler_t;
+
+
+///
+// Structure used to write data to a stream. The functions of this structure may
+// be called on any thread.
+///
+typedef struct _cef_stream_writer_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Write raw binary data.
+  ///
+  size_t (CEF_CALLBACK *write)(struct _cef_stream_writer_t* self,
+      const void* ptr, size_t size, size_t n);
+
+  ///
+  // Seek to the specified offset position. |whence| may be any one of SEEK_CUR,
+  // SEEK_END or SEEK_SET. Returns zero on success and non-zero on failure.
+  ///
+  int (CEF_CALLBACK *seek)(struct _cef_stream_writer_t* self, int64 offset,
+      int whence);
+
+  ///
+  // Return the current offset position.
+  ///
+  int64 (CEF_CALLBACK *tell)(struct _cef_stream_writer_t* self);
+
+  ///
+  // Flush the stream.
+  ///
+  int (CEF_CALLBACK *flush)(struct _cef_stream_writer_t* self);
+
+  ///
+  // Returns true (1) if this writer performs work like accessing the file
+  // system which may block. Used as a hint for determining the thread to access
+  // the writer from.
+  ///
+  int (CEF_CALLBACK *may_block)(struct _cef_stream_writer_t* self);
+} cef_stream_writer_t;
+
+
+///
+// Create a new cef_stream_writer_t object for a file.
+///
+CEF_EXPORT cef_stream_writer_t* cef_stream_writer_create_for_file(
+    const cef_string_t* fileName);
+
+///
+// Create a new cef_stream_writer_t object for a custom handler.
+///
+CEF_EXPORT cef_stream_writer_t* cef_stream_writer_create_for_handler(
+    cef_write_handler_t* handler);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_STREAM_CAPI_H_
diff --git a/src/include/libcef/capi/cef_string_visitor_capi.h b/src/include/libcef/capi/cef_string_visitor_capi.h
new file mode 100644
index 0000000..6aa6ac6
--- /dev/null
+++ b/src/include/libcef/capi/cef_string_visitor_capi.h
@@ -0,0 +1,69 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_STRING_VISITOR_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_STRING_VISITOR_CAPI_H_
+#pragma once
+
+#include "libcef/capi/cef_base_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Implement this structure to receive string values asynchronously.
+///
+typedef struct _cef_string_visitor_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Method that will be executed.
+  ///
+  void (CEF_CALLBACK *visit)(struct _cef_string_visitor_t* self,
+      const cef_string_t* string);
+} cef_string_visitor_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_STRING_VISITOR_CAPI_H_
diff --git a/src/include/libcef/capi/cef_task_capi.h b/src/include/libcef/capi/cef_task_capi.h
new file mode 100644
index 0000000..38d390c
--- /dev/null
+++ b/src/include/libcef/capi/cef_task_capi.h
@@ -0,0 +1,159 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_TASK_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_TASK_CAPI_H_
+#pragma once
+
+#include "libcef/capi/cef_base_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Implement this structure for asynchronous task execution. If the task is
+// posted successfully and if the associated message loop is still running then
+// the execute() function will be called on the target thread. If the task fails
+// to post then the task object may be destroyed on the source thread instead of
+// the target thread. For this reason be cautious when performing work in the
+// task object destructor.
+///
+typedef struct _cef_task_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Method that will be executed on the target thread.
+  ///
+  void (CEF_CALLBACK *execute)(struct _cef_task_t* self);
+} cef_task_t;
+
+
+///
+// Structure that asynchronously executes tasks on the associated thread. It is
+// safe to call the functions of this structure on any thread.
+//
+// CEF maintains multiple internal threads that are used for handling different
+// types of tasks in different processes. The cef_thread_id_t definitions in
+// cef_types.h list the common CEF threads. Task runners are also available for
+// other CEF threads as appropriate (for example, V8 WebWorker threads).
+///
+typedef struct _cef_task_runner_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns true (1) if this object is pointing to the same task runner as
+  // |that| object.
+  ///
+  int (CEF_CALLBACK *is_same)(struct _cef_task_runner_t* self,
+      struct _cef_task_runner_t* that);
+
+  ///
+  // Returns true (1) if this task runner belongs to the current thread.
+  ///
+  int (CEF_CALLBACK *belongs_to_current_thread)(
+      struct _cef_task_runner_t* self);
+
+  ///
+  // Returns true (1) if this task runner is for the specified CEF thread.
+  ///
+  int (CEF_CALLBACK *belongs_to_thread)(struct _cef_task_runner_t* self,
+      cef_thread_id_t threadId);
+
+  ///
+  // Post a task for execution on the thread associated with this task runner.
+  // Execution will occur asynchronously.
+  ///
+  int (CEF_CALLBACK *post_task)(struct _cef_task_runner_t* self,
+      struct _cef_task_t* task);
+
+  ///
+  // Post a task for delayed execution on the thread associated with this task
+  // runner. Execution will occur asynchronously. Delayed tasks are not
+  // supported on V8 WebWorker threads and will be executed without the
+  // specified delay.
+  ///
+  int (CEF_CALLBACK *post_delayed_task)(struct _cef_task_runner_t* self,
+      struct _cef_task_t* task, int64 delay_ms);
+} cef_task_runner_t;
+
+
+///
+// Returns the task runner for the current thread. Only CEF threads will have
+// task runners. An NULL reference will be returned if this function is called
+// on an invalid thread.
+///
+CEF_EXPORT cef_task_runner_t* cef_task_runner_get_for_current_thread();
+
+///
+// Returns the task runner for the specified CEF thread.
+///
+CEF_EXPORT cef_task_runner_t* cef_task_runner_get_for_thread(
+    cef_thread_id_t threadId);
+
+
+///
+// Returns true (1) if called on the specified thread. Equivalent to using
+// cef_task_tRunner::GetForThread(threadId)->belongs_to_current_thread().
+///
+CEF_EXPORT int cef_currently_on(cef_thread_id_t threadId);
+
+///
+// Post a task for execution on the specified thread. Equivalent to using
+// cef_task_tRunner::GetForThread(threadId)->PostTask(task).
+///
+CEF_EXPORT int cef_post_task(cef_thread_id_t threadId, cef_task_t* task);
+
+///
+// Post a task for delayed execution on the specified thread. Equivalent to
+// using cef_task_tRunner::GetForThread(threadId)->PostDelayedTask(task,
+// delay_ms).
+///
+CEF_EXPORT int cef_post_delayed_task(cef_thread_id_t threadId, cef_task_t* task,
+    int64 delay_ms);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_TASK_CAPI_H_
diff --git a/src/include/libcef/capi/cef_trace_capi.h b/src/include/libcef/capi/cef_trace_capi.h
new file mode 100644
index 0000000..b8c1bfd
--- /dev/null
+++ b/src/include/libcef/capi/cef_trace_capi.h
@@ -0,0 +1,118 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_TRACE_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_TRACE_CAPI_H_
+#pragma once
+
+#include "libcef/capi/cef_base_capi.h"
+#include "libcef/capi/cef_callback_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Implement this structure to receive notification when tracing has completed.
+// The functions of this structure will be called on the browser process UI
+// thread.
+///
+typedef struct _cef_end_tracing_callback_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Called after all processes have sent their trace data. |tracing_file| is
+  // the path at which tracing data was written. The client is responsible for
+  // deleting |tracing_file|.
+  ///
+  void (CEF_CALLBACK *on_end_tracing_complete)(
+      struct _cef_end_tracing_callback_t* self,
+      const cef_string_t* tracing_file);
+} cef_end_tracing_callback_t;
+
+
+///
+// Start tracing events on all processes. Tracing is initialized asynchronously
+// and |callback| will be executed on the UI thread after initialization is
+// complete.
+//
+// If CefBeginTracing was called previously, or if a CefEndTracingAsync call is
+// pending, CefBeginTracing will fail and return false (0).
+//
+// |categories| is a comma-delimited list of category wildcards. A category can
+// have an optional '-' prefix to make it an excluded category. Having both
+// included and excluded categories in the same list is not supported.
+//
+// Example: "test_MyTest*" Example: "test_MyTest*,test_OtherStuff" Example:
+// "-excluded_category1,-excluded_category2"
+//
+// This function must be called on the browser process UI thread.
+///
+CEF_EXPORT int cef_begin_tracing(const cef_string_t* categories,
+    struct _cef_completion_callback_t* callback);
+
+///
+// Stop tracing events on all processes.
+//
+// This function will fail and return false (0) if a previous call to
+// CefEndTracingAsync is already pending or if CefBeginTracing was not called.
+//
+// |tracing_file| is the path at which tracing data will be written and
+// |callback| is the callback that will be executed once all processes have sent
+// their trace data. If |tracing_file| is NULL a new temporary file path will be
+// used. If |callback| is NULL no trace data will be written.
+//
+// This function must be called on the browser process UI thread.
+///
+CEF_EXPORT int cef_end_tracing(const cef_string_t* tracing_file,
+    cef_end_tracing_callback_t* callback);
+
+///
+// Returns the current system trace time or, if none is defined, the current
+// high-res time. Can be used by clients to synchronize with the time
+// information in trace events.
+///
+CEF_EXPORT int64 cef_now_from_system_trace_time();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_TRACE_CAPI_H_
diff --git a/src/include/libcef/capi/cef_urlrequest_capi.h b/src/include/libcef/capi/cef_urlrequest_capi.h
new file mode 100644
index 0000000..e4264f8
--- /dev/null
+++ b/src/include/libcef/capi/cef_urlrequest_capi.h
@@ -0,0 +1,194 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_URLREQUEST_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_URLREQUEST_CAPI_H_
+#pragma once
+
+#include "libcef/capi/cef_auth_callback_capi.h"
+#include "libcef/capi/cef_base_capi.h"
+#include "libcef/capi/cef_request_capi.h"
+#include "libcef/capi/cef_request_context_capi.h"
+#include "libcef/capi/cef_response_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _cef_urlrequest_client_t;
+
+///
+// Structure used to make a URL request. URL requests are not associated with a
+// browser instance so no cef_client_t callbacks will be executed. URL requests
+// can be created on any valid CEF thread in either the browser or render
+// process. Once created the functions of the URL request object must be
+// accessed on the same thread that created it.
+///
+typedef struct _cef_urlrequest_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns the request object used to create this URL request. The returned
+  // object is read-only and should not be modified.
+  ///
+  struct _cef_request_t* (CEF_CALLBACK *get_request)(
+      struct _cef_urlrequest_t* self);
+
+  ///
+  // Returns the client.
+  ///
+  struct _cef_urlrequest_client_t* (CEF_CALLBACK *get_client)(
+      struct _cef_urlrequest_t* self);
+
+  ///
+  // Returns the request status.
+  ///
+  cef_urlrequest_status_t (CEF_CALLBACK *get_request_status)(
+      struct _cef_urlrequest_t* self);
+
+  ///
+  // Returns the request error if status is UR_CANCELED or UR_FAILED, or 0
+  // otherwise.
+  ///
+  cef_errorcode_t (CEF_CALLBACK *get_request_error)(
+      struct _cef_urlrequest_t* self);
+
+  ///
+  // Returns the response, or NULL if no response information is available.
+  // Response information will only be available after the upload has completed.
+  // The returned object is read-only and should not be modified.
+  ///
+  struct _cef_response_t* (CEF_CALLBACK *get_response)(
+      struct _cef_urlrequest_t* self);
+
+  ///
+  // Cancel the request.
+  ///
+  void (CEF_CALLBACK *cancel)(struct _cef_urlrequest_t* self);
+} cef_urlrequest_t;
+
+
+///
+// Create a new URL request. Only GET, POST, HEAD, DELETE and PUT request
+// functions are supported. Multiple post data elements are not supported and
+// elements of type PDE_TYPE_FILE are only supported for requests originating
+// from the browser process. Requests originating from the render process will
+// receive the same handling as requests originating from Web content -- if the
+// response contains Content-Disposition or Mime-Type header values that would
+// not normally be rendered then the response may receive special handling
+// inside the browser (for example, via the file download code path instead of
+// the URL request code path). The |request| object will be marked as read-only
+// after calling this function. In the browser process if |request_context| is
+// NULL the global request context will be used. In the render process
+// |request_context| must be NULL and the context associated with the current
+// renderer process' browser will be used.
+///
+CEF_EXPORT cef_urlrequest_t* cef_urlrequest_create(
+    struct _cef_request_t* request, struct _cef_urlrequest_client_t* client,
+    struct _cef_request_context_t* request_context);
+
+
+///
+// Structure that should be implemented by the cef_urlrequest_t client. The
+// functions of this structure will be called on the same thread that created
+// the request unless otherwise documented.
+///
+typedef struct _cef_urlrequest_client_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Notifies the client that the request has completed. Use the
+  // cef_urlrequest_t::GetRequestStatus function to determine if the request was
+  // successful or not.
+  ///
+  void (CEF_CALLBACK *on_request_complete)(
+      struct _cef_urlrequest_client_t* self,
+      struct _cef_urlrequest_t* request);
+
+  ///
+  // Notifies the client of upload progress. |current| denotes the number of
+  // bytes sent so far and |total| is the total size of uploading data (or -1 if
+  // chunked upload is enabled). This function will only be called if the
+  // UR_FLAG_REPORT_UPLOAD_PROGRESS flag is set on the request.
+  ///
+  void (CEF_CALLBACK *on_upload_progress)(struct _cef_urlrequest_client_t* self,
+      struct _cef_urlrequest_t* request, int64 current, int64 total);
+
+  ///
+  // Notifies the client of download progress. |current| denotes the number of
+  // bytes received up to the call and |total| is the expected total size of the
+  // response (or -1 if not determined).
+  ///
+  void (CEF_CALLBACK *on_download_progress)(
+      struct _cef_urlrequest_client_t* self, struct _cef_urlrequest_t* request,
+      int64 current, int64 total);
+
+  ///
+  // Called when some part of the response is read. |data| contains the current
+  // bytes received since the last call. This function will not be called if the
+  // UR_FLAG_NO_DOWNLOAD_DATA flag is set on the request.
+  ///
+  void (CEF_CALLBACK *on_download_data)(struct _cef_urlrequest_client_t* self,
+      struct _cef_urlrequest_t* request, const void* data,
+      size_t data_length);
+
+  ///
+  // Called on the IO thread when the browser needs credentials from the user.
+  // |isProxy| indicates whether the host is a proxy server. |host| contains the
+  // hostname and |port| contains the port number. Return true (1) to continue
+  // the request and call cef_auth_callback_t::cont() when the authentication
+  // information is available. Return false (0) to cancel the request. This
+  // function will only be called for requests initiated from the browser
+  // process.
+  ///
+  int (CEF_CALLBACK *get_auth_credentials)(
+      struct _cef_urlrequest_client_t* self, int isProxy,
+      const cef_string_t* host, int port, const cef_string_t* realm,
+      const cef_string_t* scheme, struct _cef_auth_callback_t* callback);
+} cef_urlrequest_client_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_URLREQUEST_CAPI_H_
diff --git a/src/include/libcef/capi/cef_v8_capi.h b/src/include/libcef/capi/cef_v8_capi.h
new file mode 100644
index 0000000..34153d4
--- /dev/null
+++ b/src/include/libcef/capi/cef_v8_capi.h
@@ -0,0 +1,852 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_V8_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_V8_CAPI_H_
+#pragma once
+
+#include "libcef/capi/cef_base_capi.h"
+#include "libcef/capi/cef_browser_capi.h"
+#include "libcef/capi/cef_frame_capi.h"
+#include "libcef/capi/cef_task_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _cef_v8exception_t;
+struct _cef_v8handler_t;
+struct _cef_v8stack_frame_t;
+struct _cef_v8value_t;
+
+///
+// Structure representing a V8 context handle. V8 handles can only be accessed
+// from the thread on which they are created. Valid threads for creating a V8
+// handle include the render process main thread (TID_RENDERER) and WebWorker
+// threads. A task runner for posting tasks on the associated thread can be
+// retrieved via the cef_v8context_t::get_task_runner() function.
+///
+typedef struct _cef_v8context_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns the task runner associated with this context. V8 handles can only
+  // be accessed from the thread on which they are created. This function can be
+  // called on any render process thread.
+  ///
+  struct _cef_task_runner_t* (CEF_CALLBACK *get_task_runner)(
+      struct _cef_v8context_t* self);
+
+  ///
+  // Returns true (1) if the underlying handle is valid and it can be accessed
+  // on the current thread. Do not call any other functions if this function
+  // returns false (0).
+  ///
+  int (CEF_CALLBACK *is_valid)(struct _cef_v8context_t* self);
+
+  ///
+  // Returns the browser for this context. This function will return an NULL
+  // reference for WebWorker contexts.
+  ///
+  struct _cef_browser_t* (CEF_CALLBACK *get_browser)(
+      struct _cef_v8context_t* self);
+
+  ///
+  // Returns the frame for this context. This function will return an NULL
+  // reference for WebWorker contexts.
+  ///
+  struct _cef_frame_t* (CEF_CALLBACK *get_frame)(struct _cef_v8context_t* self);
+
+  ///
+  // Returns the global object for this context. The context must be entered
+  // before calling this function.
+  ///
+  struct _cef_v8value_t* (CEF_CALLBACK *get_global)(
+      struct _cef_v8context_t* self);
+
+  ///
+  // Enter this context. A context must be explicitly entered before creating a
+  // V8 Object, Array, Function or Date asynchronously. exit() must be called
+  // the same number of times as enter() before releasing this context. V8
+  // objects belong to the context in which they are created. Returns true (1)
+  // if the scope was entered successfully.
+  ///
+  int (CEF_CALLBACK *enter)(struct _cef_v8context_t* self);
+
+  ///
+  // Exit this context. Call this function only after calling enter(). Returns
+  // true (1) if the scope was exited successfully.
+  ///
+  int (CEF_CALLBACK *exit)(struct _cef_v8context_t* self);
+
+  ///
+  // Returns true (1) if this object is pointing to the same handle as |that|
+  // object.
+  ///
+  int (CEF_CALLBACK *is_same)(struct _cef_v8context_t* self,
+      struct _cef_v8context_t* that);
+
+  ///
+  // Evaluates the specified JavaScript code using this context's global object.
+  // On success |retval| will be set to the return value, if any, and the
+  // function will return true (1). On failure |exception| will be set to the
+  // exception, if any, and the function will return false (0).
+  ///
+  int (CEF_CALLBACK *eval)(struct _cef_v8context_t* self,
+      const cef_string_t* code, struct _cef_v8value_t** retval,
+      struct _cef_v8exception_t** exception);
+} cef_v8context_t;
+
+
+///
+// Returns the current (top) context object in the V8 context stack.
+///
+CEF_EXPORT cef_v8context_t* cef_v8context_get_current_context();
+
+///
+// Returns the entered (bottom) context object in the V8 context stack.
+///
+CEF_EXPORT cef_v8context_t* cef_v8context_get_entered_context();
+
+///
+// Returns true (1) if V8 is currently inside a context.
+///
+CEF_EXPORT int cef_v8context_in_context();
+
+
+///
+// Structure that should be implemented to handle V8 function calls. The
+// functions of this structure will be called on the thread associated with the
+// V8 function.
+///
+typedef struct _cef_v8handler_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Handle execution of the function identified by |name|. |object| is the
+  // receiver ('this' object) of the function. |arguments| is the list of
+  // arguments passed to the function. If execution succeeds set |retval| to the
+  // function return value. If execution fails set |exception| to the exception
+  // that will be thrown. Return true (1) if execution was handled.
+  ///
+  int (CEF_CALLBACK *execute)(struct _cef_v8handler_t* self,
+      const cef_string_t* name, struct _cef_v8value_t* object,
+      size_t argumentsCount, struct _cef_v8value_t* const* arguments,
+      struct _cef_v8value_t** retval, cef_string_t* exception);
+} cef_v8handler_t;
+
+
+///
+// Structure that should be implemented to handle V8 accessor calls. Accessor
+// identifiers are registered by calling cef_v8value_t::set_value(). The
+// functions of this structure will be called on the thread associated with the
+// V8 accessor.
+///
+typedef struct _cef_v8accessor_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Handle retrieval the accessor value identified by |name|. |object| is the
+  // receiver ('this' object) of the accessor. If retrieval succeeds set
+  // |retval| to the return value. If retrieval fails set |exception| to the
+  // exception that will be thrown. Return true (1) if accessor retrieval was
+  // handled.
+  ///
+  int (CEF_CALLBACK *get)(struct _cef_v8accessor_t* self,
+      const cef_string_t* name, struct _cef_v8value_t* object,
+      struct _cef_v8value_t** retval, cef_string_t* exception);
+
+  ///
+  // Handle assignment of the accessor value identified by |name|. |object| is
+  // the receiver ('this' object) of the accessor. |value| is the new value
+  // being assigned to the accessor. If assignment fails set |exception| to the
+  // exception that will be thrown. Return true (1) if accessor assignment was
+  // handled.
+  ///
+  int (CEF_CALLBACK *set)(struct _cef_v8accessor_t* self,
+      const cef_string_t* name, struct _cef_v8value_t* object,
+      struct _cef_v8value_t* value, cef_string_t* exception);
+} cef_v8accessor_t;
+
+
+///
+// Structure representing a V8 exception. The functions of this structure may be
+// called on any render process thread.
+///
+typedef struct _cef_v8exception_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns the exception message.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_message)(
+      struct _cef_v8exception_t* self);
+
+  ///
+  // Returns the line of source code that the exception occurred within.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_source_line)(
+      struct _cef_v8exception_t* self);
+
+  ///
+  // Returns the resource name for the script from where the function causing
+  // the error originates.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_script_resource_name)(
+      struct _cef_v8exception_t* self);
+
+  ///
+  // Returns the 1-based number of the line where the error occurred or 0 if the
+  // line number is unknown.
+  ///
+  int (CEF_CALLBACK *get_line_number)(struct _cef_v8exception_t* self);
+
+  ///
+  // Returns the index within the script of the first character where the error
+  // occurred.
+  ///
+  int (CEF_CALLBACK *get_start_position)(struct _cef_v8exception_t* self);
+
+  ///
+  // Returns the index within the script of the last character where the error
+  // occurred.
+  ///
+  int (CEF_CALLBACK *get_end_position)(struct _cef_v8exception_t* self);
+
+  ///
+  // Returns the index within the line of the first character where the error
+  // occurred.
+  ///
+  int (CEF_CALLBACK *get_start_column)(struct _cef_v8exception_t* self);
+
+  ///
+  // Returns the index within the line of the last character where the error
+  // occurred.
+  ///
+  int (CEF_CALLBACK *get_end_column)(struct _cef_v8exception_t* self);
+} cef_v8exception_t;
+
+
+///
+// Structure representing a V8 value handle. V8 handles can only be accessed
+// from the thread on which they are created. Valid threads for creating a V8
+// handle include the render process main thread (TID_RENDERER) and WebWorker
+// threads. A task runner for posting tasks on the associated thread can be
+// retrieved via the cef_v8context_t::get_task_runner() function.
+///
+typedef struct _cef_v8value_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns true (1) if the underlying handle is valid and it can be accessed
+  // on the current thread. Do not call any other functions if this function
+  // returns false (0).
+  ///
+  int (CEF_CALLBACK *is_valid)(struct _cef_v8value_t* self);
+
+  ///
+  // True if the value type is undefined.
+  ///
+  int (CEF_CALLBACK *is_undefined)(struct _cef_v8value_t* self);
+
+  ///
+  // True if the value type is null.
+  ///
+  int (CEF_CALLBACK *is_null)(struct _cef_v8value_t* self);
+
+  ///
+  // True if the value type is bool.
+  ///
+  int (CEF_CALLBACK *is_bool)(struct _cef_v8value_t* self);
+
+  ///
+  // True if the value type is int.
+  ///
+  int (CEF_CALLBACK *is_int)(struct _cef_v8value_t* self);
+
+  ///
+  // True if the value type is unsigned int.
+  ///
+  int (CEF_CALLBACK *is_uint)(struct _cef_v8value_t* self);
+
+  ///
+  // True if the value type is double.
+  ///
+  int (CEF_CALLBACK *is_double)(struct _cef_v8value_t* self);
+
+  ///
+  // True if the value type is Date.
+  ///
+  int (CEF_CALLBACK *is_date)(struct _cef_v8value_t* self);
+
+  ///
+  // True if the value type is string.
+  ///
+  int (CEF_CALLBACK *is_string)(struct _cef_v8value_t* self);
+
+  ///
+  // True if the value type is object.
+  ///
+  int (CEF_CALLBACK *is_object)(struct _cef_v8value_t* self);
+
+  ///
+  // True if the value type is array.
+  ///
+  int (CEF_CALLBACK *is_array)(struct _cef_v8value_t* self);
+
+  ///
+  // True if the value type is function.
+  ///
+  int (CEF_CALLBACK *is_function)(struct _cef_v8value_t* self);
+
+  ///
+  // Returns true (1) if this object is pointing to the same handle as |that|
+  // object.
+  ///
+  int (CEF_CALLBACK *is_same)(struct _cef_v8value_t* self,
+      struct _cef_v8value_t* that);
+
+  ///
+  // Return a bool value.  The underlying data will be converted to if
+  // necessary.
+  ///
+  int (CEF_CALLBACK *get_bool_value)(struct _cef_v8value_t* self);
+
+  ///
+  // Return an int value.  The underlying data will be converted to if
+  // necessary.
+  ///
+  int32 (CEF_CALLBACK *get_int_value)(struct _cef_v8value_t* self);
+
+  ///
+  // Return an unisgned int value.  The underlying data will be converted to if
+  // necessary.
+  ///
+  uint32 (CEF_CALLBACK *get_uint_value)(struct _cef_v8value_t* self);
+
+  ///
+  // Return a double value.  The underlying data will be converted to if
+  // necessary.
+  ///
+  double (CEF_CALLBACK *get_double_value)(struct _cef_v8value_t* self);
+
+  ///
+  // Return a Date value.  The underlying data will be converted to if
+  // necessary.
+  ///
+  cef_time_t (CEF_CALLBACK *get_date_value)(struct _cef_v8value_t* self);
+
+  ///
+  // Return a string value.  The underlying data will be converted to if
+  // necessary.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_string_value)(
+      struct _cef_v8value_t* self);
+
+
+  // OBJECT METHODS - These functions are only available on objects. Arrays and
+  // functions are also objects. String- and integer-based keys can be used
+  // interchangably with the framework converting between them as necessary.
+
+  ///
+  // Returns true (1) if this is a user created object.
+  ///
+  int (CEF_CALLBACK *is_user_created)(struct _cef_v8value_t* self);
+
+  ///
+  // Returns true (1) if the last function call resulted in an exception. This
+  // attribute exists only in the scope of the current CEF value object.
+  ///
+  int (CEF_CALLBACK *has_exception)(struct _cef_v8value_t* self);
+
+  ///
+  // Returns the exception resulting from the last function call. This attribute
+  // exists only in the scope of the current CEF value object.
+  ///
+  struct _cef_v8exception_t* (CEF_CALLBACK *get_exception)(
+      struct _cef_v8value_t* self);
+
+  ///
+  // Clears the last exception and returns true (1) on success.
+  ///
+  int (CEF_CALLBACK *clear_exception)(struct _cef_v8value_t* self);
+
+  ///
+  // Returns true (1) if this object will re-throw future exceptions. This
+  // attribute exists only in the scope of the current CEF value object.
+  ///
+  int (CEF_CALLBACK *will_rethrow_exceptions)(struct _cef_v8value_t* self);
+
+  ///
+  // Set whether this object will re-throw future exceptions. By default
+  // exceptions are not re-thrown. If a exception is re-thrown the current
+  // context should not be accessed again until after the exception has been
+  // caught and not re-thrown. Returns true (1) on success. This attribute
+  // exists only in the scope of the current CEF value object.
+  ///
+  int (CEF_CALLBACK *set_rethrow_exceptions)(struct _cef_v8value_t* self,
+      int rethrow);
+
+  ///
+  // Returns true (1) if the object has a value with the specified identifier.
+  ///
+  int (CEF_CALLBACK *has_value_bykey)(struct _cef_v8value_t* self,
+      const cef_string_t* key);
+
+  ///
+  // Returns true (1) if the object has a value with the specified identifier.
+  ///
+  int (CEF_CALLBACK *has_value_byindex)(struct _cef_v8value_t* self, int index);
+
+  ///
+  // Deletes the value with the specified identifier and returns true (1) on
+  // success. Returns false (0) if this function is called incorrectly or an
+  // exception is thrown. For read-only and don't-delete values this function
+  // will return true (1) even though deletion failed.
+  ///
+  int (CEF_CALLBACK *delete_value_bykey)(struct _cef_v8value_t* self,
+      const cef_string_t* key);
+
+  ///
+  // Deletes the value with the specified identifier and returns true (1) on
+  // success. Returns false (0) if this function is called incorrectly, deletion
+  // fails or an exception is thrown. For read-only and don't-delete values this
+  // function will return true (1) even though deletion failed.
+  ///
+  int (CEF_CALLBACK *delete_value_byindex)(struct _cef_v8value_t* self,
+      int index);
+
+  ///
+  // Returns the value with the specified identifier on success. Returns NULL if
+  // this function is called incorrectly or an exception is thrown.
+  ///
+  struct _cef_v8value_t* (CEF_CALLBACK *get_value_bykey)(
+      struct _cef_v8value_t* self, const cef_string_t* key);
+
+  ///
+  // Returns the value with the specified identifier on success. Returns NULL if
+  // this function is called incorrectly or an exception is thrown.
+  ///
+  struct _cef_v8value_t* (CEF_CALLBACK *get_value_byindex)(
+      struct _cef_v8value_t* self, int index);
+
+  ///
+  // Associates a value with the specified identifier and returns true (1) on
+  // success. Returns false (0) if this function is called incorrectly or an
+  // exception is thrown. For read-only values this function will return true
+  // (1) even though assignment failed.
+  ///
+  int (CEF_CALLBACK *set_value_bykey)(struct _cef_v8value_t* self,
+      const cef_string_t* key, struct _cef_v8value_t* value,
+      cef_v8_propertyattribute_t attribute);
+
+  ///
+  // Associates a value with the specified identifier and returns true (1) on
+  // success. Returns false (0) if this function is called incorrectly or an
+  // exception is thrown. For read-only values this function will return true
+  // (1) even though assignment failed.
+  ///
+  int (CEF_CALLBACK *set_value_byindex)(struct _cef_v8value_t* self, int index,
+      struct _cef_v8value_t* value);
+
+  ///
+  // Registers an identifier and returns true (1) on success. Access to the
+  // identifier will be forwarded to the cef_v8accessor_t instance passed to
+  // cef_v8value_t::cef_v8value_create_object(). Returns false (0) if this
+  // function is called incorrectly or an exception is thrown. For read-only
+  // values this function will return true (1) even though assignment failed.
+  ///
+  int (CEF_CALLBACK *set_value_byaccessor)(struct _cef_v8value_t* self,
+      const cef_string_t* key, cef_v8_accesscontrol_t settings,
+      cef_v8_propertyattribute_t attribute);
+
+  ///
+  // Read the keys for the object's values into the specified vector. Integer-
+  // based keys will also be returned as strings.
+  ///
+  int (CEF_CALLBACK *get_keys)(struct _cef_v8value_t* self,
+      cef_string_list_t keys);
+
+  ///
+  // Sets the user data for this object and returns true (1) on success. Returns
+  // false (0) if this function is called incorrectly. This function can only be
+  // called on user created objects.
+  ///
+  int (CEF_CALLBACK *set_user_data)(struct _cef_v8value_t* self,
+      struct _cef_base_t* user_data);
+
+  ///
+  // Returns the user data, if any, assigned to this object.
+  ///
+  struct _cef_base_t* (CEF_CALLBACK *get_user_data)(
+      struct _cef_v8value_t* self);
+
+  ///
+  // Returns the amount of externally allocated memory registered for the
+  // object.
+  ///
+  int (CEF_CALLBACK *get_externally_allocated_memory)(
+      struct _cef_v8value_t* self);
+
+  ///
+  // Adjusts the amount of registered external memory for the object. Used to
+  // give V8 an indication of the amount of externally allocated memory that is
+  // kept alive by JavaScript objects. V8 uses this information to decide when
+  // to perform global garbage collection. Each cef_v8value_t tracks the amount
+  // of external memory associated with it and automatically decreases the
+  // global total by the appropriate amount on its destruction.
+  // |change_in_bytes| specifies the number of bytes to adjust by. This function
+  // returns the number of bytes associated with the object after the
+  // adjustment. This function can only be called on user created objects.
+  ///
+  int (CEF_CALLBACK *adjust_externally_allocated_memory)(
+      struct _cef_v8value_t* self, int change_in_bytes);
+
+
+  // ARRAY METHODS - These functions are only available on arrays.
+
+  ///
+  // Returns the number of elements in the array.
+  ///
+  int (CEF_CALLBACK *get_array_length)(struct _cef_v8value_t* self);
+
+
+  // FUNCTION METHODS - These functions are only available on functions.
+
+  ///
+  // Returns the function name.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_function_name)(
+      struct _cef_v8value_t* self);
+
+  ///
+  // Returns the function handler or NULL if not a CEF-created function.
+  ///
+  struct _cef_v8handler_t* (CEF_CALLBACK *get_function_handler)(
+      struct _cef_v8value_t* self);
+
+  ///
+  // Execute the function using the current V8 context. This function should
+  // only be called from within the scope of a cef_v8handler_t or
+  // cef_v8accessor_t callback, or in combination with calling enter() and
+  // exit() on a stored cef_v8context_t reference. |object| is the receiver
+  // ('this' object) of the function. If |object| is NULL the current context's
+  // global object will be used. |arguments| is the list of arguments that will
+  // be passed to the function. Returns the function return value on success.
+  // Returns NULL if this function is called incorrectly or an exception is
+  // thrown.
+  ///
+  struct _cef_v8value_t* (CEF_CALLBACK *execute_function)(
+      struct _cef_v8value_t* self, struct _cef_v8value_t* object,
+      size_t argumentsCount, struct _cef_v8value_t* const* arguments);
+
+  ///
+  // Execute the function using the specified V8 context. |object| is the
+  // receiver ('this' object) of the function. If |object| is NULL the specified
+  // context's global object will be used. |arguments| is the list of arguments
+  // that will be passed to the function. Returns the function return value on
+  // success. Returns NULL if this function is called incorrectly or an
+  // exception is thrown.
+  ///
+  struct _cef_v8value_t* (CEF_CALLBACK *execute_function_with_context)(
+      struct _cef_v8value_t* self, struct _cef_v8context_t* context,
+      struct _cef_v8value_t* object, size_t argumentsCount,
+      struct _cef_v8value_t* const* arguments);
+} cef_v8value_t;
+
+
+///
+// Create a new cef_v8value_t object of type undefined.
+///
+CEF_EXPORT cef_v8value_t* cef_v8value_create_undefined();
+
+///
+// Create a new cef_v8value_t object of type null.
+///
+CEF_EXPORT cef_v8value_t* cef_v8value_create_null();
+
+///
+// Create a new cef_v8value_t object of type bool.
+///
+CEF_EXPORT cef_v8value_t* cef_v8value_create_bool(int value);
+
+///
+// Create a new cef_v8value_t object of type int.
+///
+CEF_EXPORT cef_v8value_t* cef_v8value_create_int(int32 value);
+
+///
+// Create a new cef_v8value_t object of type unsigned int.
+///
+CEF_EXPORT cef_v8value_t* cef_v8value_create_uint(uint32 value);
+
+///
+// Create a new cef_v8value_t object of type double.
+///
+CEF_EXPORT cef_v8value_t* cef_v8value_create_double(double value);
+
+///
+// Create a new cef_v8value_t object of type Date. This function should only be
+// called from within the scope of a cef_render_process_handler_t,
+// cef_v8handler_t or cef_v8accessor_t callback, or in combination with calling
+// enter() and exit() on a stored cef_v8context_t reference.
+///
+CEF_EXPORT cef_v8value_t* cef_v8value_create_date(const cef_time_t* date);
+
+///
+// Create a new cef_v8value_t object of type string.
+///
+CEF_EXPORT cef_v8value_t* cef_v8value_create_string(const cef_string_t* value);
+
+///
+// Create a new cef_v8value_t object of type object with optional accessor. This
+// function should only be called from within the scope of a
+// cef_render_process_handler_t, cef_v8handler_t or cef_v8accessor_t callback,
+// or in combination with calling enter() and exit() on a stored cef_v8context_t
+// reference.
+///
+CEF_EXPORT cef_v8value_t* cef_v8value_create_object(cef_v8accessor_t* accessor);
+
+///
+// Create a new cef_v8value_t object of type array with the specified |length|.
+// If |length| is negative the returned array will have length 0. This function
+// should only be called from within the scope of a
+// cef_render_process_handler_t, cef_v8handler_t or cef_v8accessor_t callback,
+// or in combination with calling enter() and exit() on a stored cef_v8context_t
+// reference.
+///
+CEF_EXPORT cef_v8value_t* cef_v8value_create_array(int length);
+
+///
+// Create a new cef_v8value_t object of type function. This function should only
+// be called from within the scope of a cef_render_process_handler_t,
+// cef_v8handler_t or cef_v8accessor_t callback, or in combination with calling
+// enter() and exit() on a stored cef_v8context_t reference.
+///
+CEF_EXPORT cef_v8value_t* cef_v8value_create_function(const cef_string_t* name,
+    cef_v8handler_t* handler);
+
+
+///
+// Structure representing a V8 stack trace handle. V8 handles can only be
+// accessed from the thread on which they are created. Valid threads for
+// creating a V8 handle include the render process main thread (TID_RENDERER)
+// and WebWorker threads. A task runner for posting tasks on the associated
+// thread can be retrieved via the cef_v8context_t::get_task_runner() function.
+///
+typedef struct _cef_v8stack_trace_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns true (1) if the underlying handle is valid and it can be accessed
+  // on the current thread. Do not call any other functions if this function
+  // returns false (0).
+  ///
+  int (CEF_CALLBACK *is_valid)(struct _cef_v8stack_trace_t* self);
+
+  ///
+  // Returns the number of stack frames.
+  ///
+  int (CEF_CALLBACK *get_frame_count)(struct _cef_v8stack_trace_t* self);
+
+  ///
+  // Returns the stack frame at the specified 0-based index.
+  ///
+  struct _cef_v8stack_frame_t* (CEF_CALLBACK *get_frame)(
+      struct _cef_v8stack_trace_t* self, int index);
+} cef_v8stack_trace_t;
+
+
+///
+// Returns the stack trace for the currently active context. |frame_limit| is
+// the maximum number of frames that will be captured.
+///
+CEF_EXPORT cef_v8stack_trace_t* cef_v8stack_trace_get_current(int frame_limit);
+
+
+///
+// Structure representing a V8 stack frame handle. V8 handles can only be
+// accessed from the thread on which they are created. Valid threads for
+// creating a V8 handle include the render process main thread (TID_RENDERER)
+// and WebWorker threads. A task runner for posting tasks on the associated
+// thread can be retrieved via the cef_v8context_t::get_task_runner() function.
+///
+typedef struct _cef_v8stack_frame_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns true (1) if the underlying handle is valid and it can be accessed
+  // on the current thread. Do not call any other functions if this function
+  // returns false (0).
+  ///
+  int (CEF_CALLBACK *is_valid)(struct _cef_v8stack_frame_t* self);
+
+  ///
+  // Returns the name of the resource script that contains the function.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_script_name)(
+      struct _cef_v8stack_frame_t* self);
+
+  ///
+  // Returns the name of the resource script that contains the function or the
+  // sourceURL value if the script name is undefined and its source ends with a
+  // "//@ sourceURL=..." string.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_script_name_or_source_url)(
+      struct _cef_v8stack_frame_t* self);
+
+  ///
+  // Returns the name of the function.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_function_name)(
+      struct _cef_v8stack_frame_t* self);
+
+  ///
+  // Returns the 1-based line number for the function call or 0 if unknown.
+  ///
+  int (CEF_CALLBACK *get_line_number)(struct _cef_v8stack_frame_t* self);
+
+  ///
+  // Returns the 1-based column offset on the line for the function call or 0 if
+  // unknown.
+  ///
+  int (CEF_CALLBACK *get_column)(struct _cef_v8stack_frame_t* self);
+
+  ///
+  // Returns true (1) if the function was compiled using eval().
+  ///
+  int (CEF_CALLBACK *is_eval)(struct _cef_v8stack_frame_t* self);
+
+  ///
+  // Returns true (1) if the function was called as a constructor via "new".
+  ///
+  int (CEF_CALLBACK *is_constructor)(struct _cef_v8stack_frame_t* self);
+} cef_v8stack_frame_t;
+
+
+///
+// Register a new V8 extension with the specified JavaScript extension code and
+// handler. Functions implemented by the handler are prototyped using the
+// keyword 'native'. The calling of a native function is restricted to the scope
+// in which the prototype of the native function is defined. This function may
+// only be called on the render process main thread.
+//
+// Example JavaScript extension code: <pre>
+//   // create the 'example' global object if it doesn't already exist.
+//   if (!example)
+//     example = {};
+//   // create the 'example.test' global object if it doesn't already exist.
+//   if (!example.test)
+//     example.test = {};
+//   (function() {
+//     // Define the function 'example.test.myfunction'.
+//     example.test.myfunction = function() {
+//       // Call CefV8Handler::Execute() with the function name 'MyFunction'
+//       // and no arguments.
+//       native function MyFunction();
+//       return MyFunction();
+//     };
+//     // Define the getter function for parameter 'example.test.myparam'.
+//     example.test.__defineGetter__('myparam', function() {
+//       // Call CefV8Handler::Execute() with the function name 'GetMyParam'
+//       // and no arguments.
+//       native function GetMyParam();
+//       return GetMyParam();
+//     });
+//     // Define the setter function for parameter 'example.test.myparam'.
+//     example.test.__defineSetter__('myparam', function(b) {
+//       // Call CefV8Handler::Execute() with the function name 'SetMyParam'
+//       // and a single argument.
+//       native function SetMyParam();
+//       if(b) SetMyParam(b);
+//     });
+//
+//     // Extension definitions can also contain normal JavaScript variables
+//     // and functions.
+//     var myint = 0;
+//     example.test.increment = function() {
+//       myint += 1;
+//       return myint;
+//     };
+//   })();
+// </pre> Example usage in the page: <pre>
+//   // Call the function.
+//   example.test.myfunction();
+//   // Set the parameter.
+//   example.test.myparam = value;
+//   // Get the parameter.
+//   value = example.test.myparam;
+//   // Call another function.
+//   example.test.increment();
+// </pre>
+///
+CEF_EXPORT int cef_register_extension(const cef_string_t* extension_name,
+    const cef_string_t* javascript_code, cef_v8handler_t* handler);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_V8_CAPI_H_
diff --git a/src/include/libcef/capi/cef_values_capi.h b/src/include/libcef/capi/cef_values_capi.h
new file mode 100644
index 0000000..f25f87c
--- /dev/null
+++ b/src/include/libcef/capi/cef_values_capi.h
@@ -0,0 +1,734 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_VALUES_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_VALUES_CAPI_H_
+#pragma once
+
+#include "libcef/capi/cef_base_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _cef_binary_value_t;
+struct _cef_dictionary_value_t;
+struct _cef_list_value_t;
+
+///
+// Structure that wraps other data value types. Complex types (binary,
+// dictionary and list) will be referenced but not owned by this object. Can be
+// used on any process and thread.
+///
+typedef struct _cef_value_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns true (1) if the underlying data is valid. This will always be true
+  // (1) for simple types. For complex types (binary, dictionary and list) the
+  // underlying data may become invalid if owned by another object (e.g. list or
+  // dictionary) and that other object is then modified or destroyed. This value
+  // object can be re-used by calling Set*() even if the underlying data is
+  // invalid.
+  ///
+  int (CEF_CALLBACK *is_valid)(struct _cef_value_t* self);
+
+  ///
+  // Returns true (1) if the underlying data is owned by another object.
+  ///
+  int (CEF_CALLBACK *is_owned)(struct _cef_value_t* self);
+
+  ///
+  // Returns true (1) if the underlying data is read-only. Some APIs may expose
+  // read-only objects.
+  ///
+  int (CEF_CALLBACK *is_read_only)(struct _cef_value_t* self);
+
+  ///
+  // Returns true (1) if this object and |that| object have the same underlying
+  // data. If true (1) modifications to this object will also affect |that|
+  // object and vice-versa.
+  ///
+  int (CEF_CALLBACK *is_same)(struct _cef_value_t* self,
+      struct _cef_value_t* that);
+
+  ///
+  // Returns true (1) if this object and |that| object have an equivalent
+  // underlying value but are not necessarily the same object.
+  ///
+  int (CEF_CALLBACK *is_equal)(struct _cef_value_t* self,
+      struct _cef_value_t* that);
+
+  ///
+  // Returns a copy of this object. The underlying data will also be copied.
+  ///
+  struct _cef_value_t* (CEF_CALLBACK *copy)(struct _cef_value_t* self);
+
+  ///
+  // Returns the underlying value type.
+  ///
+  cef_value_type_t (CEF_CALLBACK *get_type)(struct _cef_value_t* self);
+
+  ///
+  // Returns the underlying value as type bool.
+  ///
+  int (CEF_CALLBACK *get_bool)(struct _cef_value_t* self);
+
+  ///
+  // Returns the underlying value as type int.
+  ///
+  int (CEF_CALLBACK *get_int)(struct _cef_value_t* self);
+
+  ///
+  // Returns the underlying value as type double.
+  ///
+  double (CEF_CALLBACK *get_double)(struct _cef_value_t* self);
+
+  ///
+  // Returns the underlying value as type string.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_string)(struct _cef_value_t* self);
+
+  ///
+  // Returns the underlying value as type binary. The returned reference may
+  // become invalid if the value is owned by another object or if ownership is
+  // transferred to another object in the future. To maintain a reference to the
+  // value after assigning ownership to a dictionary or list pass this object to
+  // the set_value() function instead of passing the returned reference to
+  // set_binary().
+  ///
+  struct _cef_binary_value_t* (CEF_CALLBACK *get_binary)(
+      struct _cef_value_t* self);
+
+  ///
+  // Returns the underlying value as type dictionary. The returned reference may
+  // become invalid if the value is owned by another object or if ownership is
+  // transferred to another object in the future. To maintain a reference to the
+  // value after assigning ownership to a dictionary or list pass this object to
+  // the set_value() function instead of passing the returned reference to
+  // set_dictionary().
+  ///
+  struct _cef_dictionary_value_t* (CEF_CALLBACK *get_dictionary)(
+      struct _cef_value_t* self);
+
+  ///
+  // Returns the underlying value as type list. The returned reference may
+  // become invalid if the value is owned by another object or if ownership is
+  // transferred to another object in the future. To maintain a reference to the
+  // value after assigning ownership to a dictionary or list pass this object to
+  // the set_value() function instead of passing the returned reference to
+  // set_list().
+  ///
+  struct _cef_list_value_t* (CEF_CALLBACK *get_list)(struct _cef_value_t* self);
+
+  ///
+  // Sets the underlying value as type null. Returns true (1) if the value was
+  // set successfully.
+  ///
+  int (CEF_CALLBACK *set_null)(struct _cef_value_t* self);
+
+  ///
+  // Sets the underlying value as type bool. Returns true (1) if the value was
+  // set successfully.
+  ///
+  int (CEF_CALLBACK *set_bool)(struct _cef_value_t* self, int value);
+
+  ///
+  // Sets the underlying value as type int. Returns true (1) if the value was
+  // set successfully.
+  ///
+  int (CEF_CALLBACK *set_int)(struct _cef_value_t* self, int value);
+
+  ///
+  // Sets the underlying value as type double. Returns true (1) if the value was
+  // set successfully.
+  ///
+  int (CEF_CALLBACK *set_double)(struct _cef_value_t* self, double value);
+
+  ///
+  // Sets the underlying value as type string. Returns true (1) if the value was
+  // set successfully.
+  ///
+  int (CEF_CALLBACK *set_string)(struct _cef_value_t* self,
+      const cef_string_t* value);
+
+  ///
+  // Sets the underlying value as type binary. Returns true (1) if the value was
+  // set successfully. This object keeps a reference to |value| and ownership of
+  // the underlying data remains unchanged.
+  ///
+  int (CEF_CALLBACK *set_binary)(struct _cef_value_t* self,
+      struct _cef_binary_value_t* value);
+
+  ///
+  // Sets the underlying value as type dict. Returns true (1) if the value was
+  // set successfully. This object keeps a reference to |value| and ownership of
+  // the underlying data remains unchanged.
+  ///
+  int (CEF_CALLBACK *set_dictionary)(struct _cef_value_t* self,
+      struct _cef_dictionary_value_t* value);
+
+  ///
+  // Sets the underlying value as type list. Returns true (1) if the value was
+  // set successfully. This object keeps a reference to |value| and ownership of
+  // the underlying data remains unchanged.
+  ///
+  int (CEF_CALLBACK *set_list)(struct _cef_value_t* self,
+      struct _cef_list_value_t* value);
+} cef_value_t;
+
+
+///
+// Creates a new object.
+///
+CEF_EXPORT cef_value_t* cef_value_create();
+
+
+///
+// Structure representing a binary value. Can be used on any process and thread.
+///
+typedef struct _cef_binary_value_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns true (1) if this object is valid. This object may become invalid if
+  // the underlying data is owned by another object (e.g. list or dictionary)
+  // and that other object is then modified or destroyed. Do not call any other
+  // functions if this function returns false (0).
+  ///
+  int (CEF_CALLBACK *is_valid)(struct _cef_binary_value_t* self);
+
+  ///
+  // Returns true (1) if this object is currently owned by another object.
+  ///
+  int (CEF_CALLBACK *is_owned)(struct _cef_binary_value_t* self);
+
+  ///
+  // Returns true (1) if this object and |that| object have the same underlying
+  // data.
+  ///
+  int (CEF_CALLBACK *is_same)(struct _cef_binary_value_t* self,
+      struct _cef_binary_value_t* that);
+
+  ///
+  // Returns true (1) if this object and |that| object have an equivalent
+  // underlying value but are not necessarily the same object.
+  ///
+  int (CEF_CALLBACK *is_equal)(struct _cef_binary_value_t* self,
+      struct _cef_binary_value_t* that);
+
+  ///
+  // Returns a copy of this object. The data in this object will also be copied.
+  ///
+  struct _cef_binary_value_t* (CEF_CALLBACK *copy)(
+      struct _cef_binary_value_t* self);
+
+  ///
+  // Returns the data size.
+  ///
+  size_t (CEF_CALLBACK *get_size)(struct _cef_binary_value_t* self);
+
+  ///
+  // Read up to |buffer_size| number of bytes into |buffer|. Reading begins at
+  // the specified byte |data_offset|. Returns the number of bytes read.
+  ///
+  size_t (CEF_CALLBACK *get_data)(struct _cef_binary_value_t* self,
+      void* buffer, size_t buffer_size, size_t data_offset);
+} cef_binary_value_t;
+
+
+///
+// Creates a new object that is not owned by any other object. The specified
+// |data| will be copied.
+///
+CEF_EXPORT cef_binary_value_t* cef_binary_value_create(const void* data,
+    size_t data_size);
+
+
+///
+// Structure representing a dictionary value. Can be used on any process and
+// thread.
+///
+typedef struct _cef_dictionary_value_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns true (1) if this object is valid. This object may become invalid if
+  // the underlying data is owned by another object (e.g. list or dictionary)
+  // and that other object is then modified or destroyed. Do not call any other
+  // functions if this function returns false (0).
+  ///
+  int (CEF_CALLBACK *is_valid)(struct _cef_dictionary_value_t* self);
+
+  ///
+  // Returns true (1) if this object is currently owned by another object.
+  ///
+  int (CEF_CALLBACK *is_owned)(struct _cef_dictionary_value_t* self);
+
+  ///
+  // Returns true (1) if the values of this object are read-only. Some APIs may
+  // expose read-only objects.
+  ///
+  int (CEF_CALLBACK *is_read_only)(struct _cef_dictionary_value_t* self);
+
+  ///
+  // Returns true (1) if this object and |that| object have the same underlying
+  // data. If true (1) modifications to this object will also affect |that|
+  // object and vice-versa.
+  ///
+  int (CEF_CALLBACK *is_same)(struct _cef_dictionary_value_t* self,
+      struct _cef_dictionary_value_t* that);
+
+  ///
+  // Returns true (1) if this object and |that| object have an equivalent
+  // underlying value but are not necessarily the same object.
+  ///
+  int (CEF_CALLBACK *is_equal)(struct _cef_dictionary_value_t* self,
+      struct _cef_dictionary_value_t* that);
+
+  ///
+  // Returns a writable copy of this object. If |exclude_NULL_children| is true
+  // (1) any NULL dictionaries or lists will be excluded from the copy.
+  ///
+  struct _cef_dictionary_value_t* (CEF_CALLBACK *copy)(
+      struct _cef_dictionary_value_t* self, int exclude_empty_children);
+
+  ///
+  // Returns the number of values.
+  ///
+  size_t (CEF_CALLBACK *get_size)(struct _cef_dictionary_value_t* self);
+
+  ///
+  // Removes all values. Returns true (1) on success.
+  ///
+  int (CEF_CALLBACK *clear)(struct _cef_dictionary_value_t* self);
+
+  ///
+  // Returns true (1) if the current dictionary has a value for the given key.
+  ///
+  int (CEF_CALLBACK *has_key)(struct _cef_dictionary_value_t* self,
+      const cef_string_t* key);
+
+  ///
+  // Reads all keys for this dictionary into the specified vector.
+  ///
+  int (CEF_CALLBACK *get_keys)(struct _cef_dictionary_value_t* self,
+      cef_string_list_t keys);
+
+  ///
+  // Removes the value at the specified key. Returns true (1) is the value was
+  // removed successfully.
+  ///
+  int (CEF_CALLBACK *remove)(struct _cef_dictionary_value_t* self,
+      const cef_string_t* key);
+
+  ///
+  // Returns the value type for the specified key.
+  ///
+  cef_value_type_t (CEF_CALLBACK *get_type)(
+      struct _cef_dictionary_value_t* self, const cef_string_t* key);
+
+  ///
+  // Returns the value at the specified key. For simple types the returned value
+  // will copy existing data and modifications to the value will not modify this
+  // object. For complex types (binary, dictionary and list) the returned value
+  // will reference existing data and modifications to the value will modify
+  // this object.
+  ///
+  struct _cef_value_t* (CEF_CALLBACK *get_value)(
+      struct _cef_dictionary_value_t* self, const cef_string_t* key);
+
+  ///
+  // Returns the value at the specified key as type bool.
+  ///
+  int (CEF_CALLBACK *get_bool)(struct _cef_dictionary_value_t* self,
+      const cef_string_t* key);
+
+  ///
+  // Returns the value at the specified key as type int.
+  ///
+  int (CEF_CALLBACK *get_int)(struct _cef_dictionary_value_t* self,
+      const cef_string_t* key);
+
+  ///
+  // Returns the value at the specified key as type double.
+  ///
+  double (CEF_CALLBACK *get_double)(struct _cef_dictionary_value_t* self,
+      const cef_string_t* key);
+
+  ///
+  // Returns the value at the specified key as type string.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_string)(
+      struct _cef_dictionary_value_t* self, const cef_string_t* key);
+
+  ///
+  // Returns the value at the specified key as type binary. The returned value
+  // will reference existing data.
+  ///
+  struct _cef_binary_value_t* (CEF_CALLBACK *get_binary)(
+      struct _cef_dictionary_value_t* self, const cef_string_t* key);
+
+  ///
+  // Returns the value at the specified key as type dictionary. The returned
+  // value will reference existing data and modifications to the value will
+  // modify this object.
+  ///
+  struct _cef_dictionary_value_t* (CEF_CALLBACK *get_dictionary)(
+      struct _cef_dictionary_value_t* self, const cef_string_t* key);
+
+  ///
+  // Returns the value at the specified key as type list. The returned value
+  // will reference existing data and modifications to the value will modify
+  // this object.
+  ///
+  struct _cef_list_value_t* (CEF_CALLBACK *get_list)(
+      struct _cef_dictionary_value_t* self, const cef_string_t* key);
+
+  ///
+  // Sets the value at the specified key. Returns true (1) if the value was set
+  // successfully. If |value| represents simple data then the underlying data
+  // will be copied and modifications to |value| will not modify this object. If
+  // |value| represents complex data (binary, dictionary or list) then the
+  // underlying data will be referenced and modifications to |value| will modify
+  // this object.
+  ///
+  int (CEF_CALLBACK *set_value)(struct _cef_dictionary_value_t* self,
+      const cef_string_t* key, struct _cef_value_t* value);
+
+  ///
+  // Sets the value at the specified key as type null. Returns true (1) if the
+  // value was set successfully.
+  ///
+  int (CEF_CALLBACK *set_null)(struct _cef_dictionary_value_t* self,
+      const cef_string_t* key);
+
+  ///
+  // Sets the value at the specified key as type bool. Returns true (1) if the
+  // value was set successfully.
+  ///
+  int (CEF_CALLBACK *set_bool)(struct _cef_dictionary_value_t* self,
+      const cef_string_t* key, int value);
+
+  ///
+  // Sets the value at the specified key as type int. Returns true (1) if the
+  // value was set successfully.
+  ///
+  int (CEF_CALLBACK *set_int)(struct _cef_dictionary_value_t* self,
+      const cef_string_t* key, int value);
+
+  ///
+  // Sets the value at the specified key as type double. Returns true (1) if the
+  // value was set successfully.
+  ///
+  int (CEF_CALLBACK *set_double)(struct _cef_dictionary_value_t* self,
+      const cef_string_t* key, double value);
+
+  ///
+  // Sets the value at the specified key as type string. Returns true (1) if the
+  // value was set successfully.
+  ///
+  int (CEF_CALLBACK *set_string)(struct _cef_dictionary_value_t* self,
+      const cef_string_t* key, const cef_string_t* value);
+
+  ///
+  // Sets the value at the specified key as type binary. Returns true (1) if the
+  // value was set successfully. If |value| is currently owned by another object
+  // then the value will be copied and the |value| reference will not change.
+  // Otherwise, ownership will be transferred to this object and the |value|
+  // reference will be invalidated.
+  ///
+  int (CEF_CALLBACK *set_binary)(struct _cef_dictionary_value_t* self,
+      const cef_string_t* key, struct _cef_binary_value_t* value);
+
+  ///
+  // Sets the value at the specified key as type dict. Returns true (1) if the
+  // value was set successfully. If |value| is currently owned by another object
+  // then the value will be copied and the |value| reference will not change.
+  // Otherwise, ownership will be transferred to this object and the |value|
+  // reference will be invalidated.
+  ///
+  int (CEF_CALLBACK *set_dictionary)(struct _cef_dictionary_value_t* self,
+      const cef_string_t* key, struct _cef_dictionary_value_t* value);
+
+  ///
+  // Sets the value at the specified key as type list. Returns true (1) if the
+  // value was set successfully. If |value| is currently owned by another object
+  // then the value will be copied and the |value| reference will not change.
+  // Otherwise, ownership will be transferred to this object and the |value|
+  // reference will be invalidated.
+  ///
+  int (CEF_CALLBACK *set_list)(struct _cef_dictionary_value_t* self,
+      const cef_string_t* key, struct _cef_list_value_t* value);
+} cef_dictionary_value_t;
+
+
+///
+// Creates a new object that is not owned by any other object.
+///
+CEF_EXPORT cef_dictionary_value_t* cef_dictionary_value_create();
+
+
+///
+// Structure representing a list value. Can be used on any process and thread.
+///
+typedef struct _cef_list_value_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns true (1) if this object is valid. This object may become invalid if
+  // the underlying data is owned by another object (e.g. list or dictionary)
+  // and that other object is then modified or destroyed. Do not call any other
+  // functions if this function returns false (0).
+  ///
+  int (CEF_CALLBACK *is_valid)(struct _cef_list_value_t* self);
+
+  ///
+  // Returns true (1) if this object is currently owned by another object.
+  ///
+  int (CEF_CALLBACK *is_owned)(struct _cef_list_value_t* self);
+
+  ///
+  // Returns true (1) if the values of this object are read-only. Some APIs may
+  // expose read-only objects.
+  ///
+  int (CEF_CALLBACK *is_read_only)(struct _cef_list_value_t* self);
+
+  ///
+  // Returns true (1) if this object and |that| object have the same underlying
+  // data. If true (1) modifications to this object will also affect |that|
+  // object and vice-versa.
+  ///
+  int (CEF_CALLBACK *is_same)(struct _cef_list_value_t* self,
+      struct _cef_list_value_t* that);
+
+  ///
+  // Returns true (1) if this object and |that| object have an equivalent
+  // underlying value but are not necessarily the same object.
+  ///
+  int (CEF_CALLBACK *is_equal)(struct _cef_list_value_t* self,
+      struct _cef_list_value_t* that);
+
+  ///
+  // Returns a writable copy of this object.
+  ///
+  struct _cef_list_value_t* (CEF_CALLBACK *copy)(
+      struct _cef_list_value_t* self);
+
+  ///
+  // Sets the number of values. If the number of values is expanded all new
+  // value slots will default to type null. Returns true (1) on success.
+  ///
+  int (CEF_CALLBACK *set_size)(struct _cef_list_value_t* self, size_t size);
+
+  ///
+  // Returns the number of values.
+  ///
+  size_t (CEF_CALLBACK *get_size)(struct _cef_list_value_t* self);
+
+  ///
+  // Removes all values. Returns true (1) on success.
+  ///
+  int (CEF_CALLBACK *clear)(struct _cef_list_value_t* self);
+
+  ///
+  // Removes the value at the specified index.
+  ///
+  int (CEF_CALLBACK *remove)(struct _cef_list_value_t* self, int index);
+
+  ///
+  // Returns the value type at the specified index.
+  ///
+  cef_value_type_t (CEF_CALLBACK *get_type)(struct _cef_list_value_t* self,
+      int index);
+
+  ///
+  // Returns the value at the specified index. For simple types the returned
+  // value will copy existing data and modifications to the value will not
+  // modify this object. For complex types (binary, dictionary and list) the
+  // returned value will reference existing data and modifications to the value
+  // will modify this object.
+  ///
+  struct _cef_value_t* (CEF_CALLBACK *get_value)(struct _cef_list_value_t* self,
+      int index);
+
+  ///
+  // Returns the value at the specified index as type bool.
+  ///
+  int (CEF_CALLBACK *get_bool)(struct _cef_list_value_t* self, int index);
+
+  ///
+  // Returns the value at the specified index as type int.
+  ///
+  int (CEF_CALLBACK *get_int)(struct _cef_list_value_t* self, int index);
+
+  ///
+  // Returns the value at the specified index as type double.
+  ///
+  double (CEF_CALLBACK *get_double)(struct _cef_list_value_t* self, int index);
+
+  ///
+  // Returns the value at the specified index as type string.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_string)(
+      struct _cef_list_value_t* self, int index);
+
+  ///
+  // Returns the value at the specified index as type binary. The returned value
+  // will reference existing data.
+  ///
+  struct _cef_binary_value_t* (CEF_CALLBACK *get_binary)(
+      struct _cef_list_value_t* self, int index);
+
+  ///
+  // Returns the value at the specified index as type dictionary. The returned
+  // value will reference existing data and modifications to the value will
+  // modify this object.
+  ///
+  struct _cef_dictionary_value_t* (CEF_CALLBACK *get_dictionary)(
+      struct _cef_list_value_t* self, int index);
+
+  ///
+  // Returns the value at the specified index as type list. The returned value
+  // will reference existing data and modifications to the value will modify
+  // this object.
+  ///
+  struct _cef_list_value_t* (CEF_CALLBACK *get_list)(
+      struct _cef_list_value_t* self, int index);
+
+  ///
+  // Sets the value at the specified index. Returns true (1) if the value was
+  // set successfully. If |value| represents simple data then the underlying
+  // data will be copied and modifications to |value| will not modify this
+  // object. If |value| represents complex data (binary, dictionary or list)
+  // then the underlying data will be referenced and modifications to |value|
+  // will modify this object.
+  ///
+  int (CEF_CALLBACK *set_value)(struct _cef_list_value_t* self, int index,
+      struct _cef_value_t* value);
+
+  ///
+  // Sets the value at the specified index as type null. Returns true (1) if the
+  // value was set successfully.
+  ///
+  int (CEF_CALLBACK *set_null)(struct _cef_list_value_t* self, int index);
+
+  ///
+  // Sets the value at the specified index as type bool. Returns true (1) if the
+  // value was set successfully.
+  ///
+  int (CEF_CALLBACK *set_bool)(struct _cef_list_value_t* self, int index,
+      int value);
+
+  ///
+  // Sets the value at the specified index as type int. Returns true (1) if the
+  // value was set successfully.
+  ///
+  int (CEF_CALLBACK *set_int)(struct _cef_list_value_t* self, int index,
+      int value);
+
+  ///
+  // Sets the value at the specified index as type double. Returns true (1) if
+  // the value was set successfully.
+  ///
+  int (CEF_CALLBACK *set_double)(struct _cef_list_value_t* self, int index,
+      double value);
+
+  ///
+  // Sets the value at the specified index as type string. Returns true (1) if
+  // the value was set successfully.
+  ///
+  int (CEF_CALLBACK *set_string)(struct _cef_list_value_t* self, int index,
+      const cef_string_t* value);
+
+  ///
+  // Sets the value at the specified index as type binary. Returns true (1) if
+  // the value was set successfully. If |value| is currently owned by another
+  // object then the value will be copied and the |value| reference will not
+  // change. Otherwise, ownership will be transferred to this object and the
+  // |value| reference will be invalidated.
+  ///
+  int (CEF_CALLBACK *set_binary)(struct _cef_list_value_t* self, int index,
+      struct _cef_binary_value_t* value);
+
+  ///
+  // Sets the value at the specified index as type dict. Returns true (1) if the
+  // value was set successfully. If |value| is currently owned by another object
+  // then the value will be copied and the |value| reference will not change.
+  // Otherwise, ownership will be transferred to this object and the |value|
+  // reference will be invalidated.
+  ///
+  int (CEF_CALLBACK *set_dictionary)(struct _cef_list_value_t* self, int index,
+      struct _cef_dictionary_value_t* value);
+
+  ///
+  // Sets the value at the specified index as type list. Returns true (1) if the
+  // value was set successfully. If |value| is currently owned by another object
+  // then the value will be copied and the |value| reference will not change.
+  // Otherwise, ownership will be transferred to this object and the |value|
+  // reference will be invalidated.
+  ///
+  int (CEF_CALLBACK *set_list)(struct _cef_list_value_t* self, int index,
+      struct _cef_list_value_t* value);
+} cef_list_value_t;
+
+
+///
+// Creates a new object that is not owned by any other object.
+///
+CEF_EXPORT cef_list_value_t* cef_list_value_create();
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_VALUES_CAPI_H_
diff --git a/src/include/libcef/capi/cef_web_plugin_capi.h b/src/include/libcef/capi/cef_web_plugin_capi.h
new file mode 100644
index 0000000..0c3ffb1
--- /dev/null
+++ b/src/include/libcef/capi/cef_web_plugin_capi.h
@@ -0,0 +1,168 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_WEB_PLUGIN_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_WEB_PLUGIN_CAPI_H_
+#pragma once
+
+#include "libcef/capi/cef_base_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _cef_browser_t;
+
+///
+// Information about a specific web plugin.
+///
+typedef struct _cef_web_plugin_info_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns the plugin name (i.e. Flash).
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_name)(
+      struct _cef_web_plugin_info_t* self);
+
+  ///
+  // Returns the plugin file path (DLL/bundle/library).
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_path)(
+      struct _cef_web_plugin_info_t* self);
+
+  ///
+  // Returns the version of the plugin (may be OS-specific).
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_version)(
+      struct _cef_web_plugin_info_t* self);
+
+  ///
+  // Returns a description of the plugin from the version information.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_description)(
+      struct _cef_web_plugin_info_t* self);
+} cef_web_plugin_info_t;
+
+
+///
+// Structure to implement for visiting web plugin information. The functions of
+// this structure will be called on the browser process UI thread.
+///
+typedef struct _cef_web_plugin_info_visitor_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Method that will be called once for each plugin. |count| is the 0-based
+  // index for the current plugin. |total| is the total number of plugins.
+  // Return false (0) to stop visiting plugins. This function may never be
+  // called if no plugins are found.
+  ///
+  int (CEF_CALLBACK *visit)(struct _cef_web_plugin_info_visitor_t* self,
+      struct _cef_web_plugin_info_t* info, int count, int total);
+} cef_web_plugin_info_visitor_t;
+
+
+///
+// Structure to implement for receiving unstable plugin information. The
+// functions of this structure will be called on the browser process IO thread.
+///
+typedef struct _cef_web_plugin_unstable_callback_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Method that will be called for the requested plugin. |unstable| will be
+  // true (1) if the plugin has reached the crash count threshold of 3 times in
+  // 120 seconds.
+  ///
+  void (CEF_CALLBACK *is_unstable)(
+      struct _cef_web_plugin_unstable_callback_t* self,
+      const cef_string_t* path, int unstable);
+} cef_web_plugin_unstable_callback_t;
+
+
+///
+// Visit web plugin information. Can be called on any thread in the browser
+// process.
+///
+CEF_EXPORT void cef_visit_web_plugin_info(
+    cef_web_plugin_info_visitor_t* visitor);
+
+///
+// Cause the plugin list to refresh the next time it is accessed regardless of
+// whether it has already been loaded. Can be called on any thread in the
+// browser process.
+///
+CEF_EXPORT void cef_refresh_web_plugins();
+
+///
+// Unregister an internal plugin. This may be undone the next time
+// cef_refresh_web_plugins() is called. Can be called on any thread in the
+// browser process.
+///
+CEF_EXPORT void cef_unregister_internal_web_plugin(const cef_string_t* path);
+
+///
+// Register a plugin crash. Can be called on any thread in the browser process
+// but will be executed on the IO thread.
+///
+CEF_EXPORT void cef_register_web_plugin_crash(const cef_string_t* path);
+
+///
+// Query if a plugin is unstable. Can be called on any thread in the browser
+// process.
+///
+CEF_EXPORT void cef_is_web_plugin_unstable(const cef_string_t* path,
+    cef_web_plugin_unstable_callback_t* callback);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_WEB_PLUGIN_CAPI_H_
diff --git a/src/include/libcef/capi/cef_xml_reader_capi.h b/src/include/libcef/capi/cef_xml_reader_capi.h
new file mode 100644
index 0000000..9ca047a
--- /dev/null
+++ b/src/include/libcef/capi/cef_xml_reader_capi.h
@@ -0,0 +1,278 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_XML_READER_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_XML_READER_CAPI_H_
+#pragma once
+
+#include "libcef/capi/cef_base_capi.h"
+#include "libcef/capi/cef_stream_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Structure that supports the reading of XML data via the libxml streaming API.
+// The functions of this structure should only be called on the thread that
+// creates the object.
+///
+typedef struct _cef_xml_reader_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Moves the cursor to the next node in the document. This function must be
+  // called at least once to set the current cursor position. Returns true (1)
+  // if the cursor position was set successfully.
+  ///
+  int (CEF_CALLBACK *move_to_next_node)(struct _cef_xml_reader_t* self);
+
+  ///
+  // Close the document. This should be called directly to ensure that cleanup
+  // occurs on the correct thread.
+  ///
+  int (CEF_CALLBACK *close)(struct _cef_xml_reader_t* self);
+
+  ///
+  // Returns true (1) if an error has been reported by the XML parser.
+  ///
+  int (CEF_CALLBACK *has_error)(struct _cef_xml_reader_t* self);
+
+  ///
+  // Returns the error string.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_error)(
+      struct _cef_xml_reader_t* self);
+
+
+  // The below functions retrieve data for the node at the current cursor
+  // position.
+
+  ///
+  // Returns the node type.
+  ///
+  cef_xml_node_type_t (CEF_CALLBACK *get_type)(struct _cef_xml_reader_t* self);
+
+  ///
+  // Returns the node depth. Depth starts at 0 for the root node.
+  ///
+  int (CEF_CALLBACK *get_depth)(struct _cef_xml_reader_t* self);
+
+  ///
+  // Returns the local name. See http://www.w3.org/TR/REC-xml-names/#NT-
+  // LocalPart for additional details.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_local_name)(
+      struct _cef_xml_reader_t* self);
+
+  ///
+  // Returns the namespace prefix. See http://www.w3.org/TR/REC-xml-names/ for
+  // additional details.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_prefix)(
+      struct _cef_xml_reader_t* self);
+
+  ///
+  // Returns the qualified name, equal to (Prefix:)LocalName. See
+  // http://www.w3.org/TR/REC-xml-names/#ns-qualnames for additional details.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_qualified_name)(
+      struct _cef_xml_reader_t* self);
+
+  ///
+  // Returns the URI defining the namespace associated with the node. See
+  // http://www.w3.org/TR/REC-xml-names/ for additional details.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_namespace_uri)(
+      struct _cef_xml_reader_t* self);
+
+  ///
+  // Returns the base URI of the node. See http://www.w3.org/TR/xmlbase/ for
+  // additional details.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_base_uri)(
+      struct _cef_xml_reader_t* self);
+
+  ///
+  // Returns the xml:lang scope within which the node resides. See
+  // http://www.w3.org/TR/REC-xml/#sec-lang-tag for additional details.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_xml_lang)(
+      struct _cef_xml_reader_t* self);
+
+  ///
+  // Returns true (1) if the node represents an NULL element. <a/> is considered
+  // NULL but <a></a> is not.
+  ///
+  int (CEF_CALLBACK *is_empty_element)(struct _cef_xml_reader_t* self);
+
+  ///
+  // Returns true (1) if the node has a text value.
+  ///
+  int (CEF_CALLBACK *has_value)(struct _cef_xml_reader_t* self);
+
+  ///
+  // Returns the text value.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_value)(
+      struct _cef_xml_reader_t* self);
+
+  ///
+  // Returns true (1) if the node has attributes.
+  ///
+  int (CEF_CALLBACK *has_attributes)(struct _cef_xml_reader_t* self);
+
+  ///
+  // Returns the number of attributes.
+  ///
+  size_t (CEF_CALLBACK *get_attribute_count)(struct _cef_xml_reader_t* self);
+
+  ///
+  // Returns the value of the attribute at the specified 0-based index.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_attribute_byindex)(
+      struct _cef_xml_reader_t* self, int index);
+
+  ///
+  // Returns the value of the attribute with the specified qualified name.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_attribute_byqname)(
+      struct _cef_xml_reader_t* self, const cef_string_t* qualifiedName);
+
+  ///
+  // Returns the value of the attribute with the specified local name and
+  // namespace URI.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_attribute_bylname)(
+      struct _cef_xml_reader_t* self, const cef_string_t* localName,
+      const cef_string_t* namespaceURI);
+
+  ///
+  // Returns an XML representation of the current node's children.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_inner_xml)(
+      struct _cef_xml_reader_t* self);
+
+  ///
+  // Returns an XML representation of the current node including its children.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_outer_xml)(
+      struct _cef_xml_reader_t* self);
+
+  ///
+  // Returns the line number for the current node.
+  ///
+  int (CEF_CALLBACK *get_line_number)(struct _cef_xml_reader_t* self);
+
+
+  // Attribute nodes are not traversed by default. The below functions can be
+  // used to move the cursor to an attribute node. move_to_carrying_element()
+  // can be called afterwards to return the cursor to the carrying element. The
+  // depth of an attribute node will be 1 + the depth of the carrying element.
+
+  ///
+  // Moves the cursor to the attribute at the specified 0-based index. Returns
+  // true (1) if the cursor position was set successfully.
+  ///
+  int (CEF_CALLBACK *move_to_attribute_byindex)(struct _cef_xml_reader_t* self,
+      int index);
+
+  ///
+  // Moves the cursor to the attribute with the specified qualified name.
+  // Returns true (1) if the cursor position was set successfully.
+  ///
+  int (CEF_CALLBACK *move_to_attribute_byqname)(struct _cef_xml_reader_t* self,
+      const cef_string_t* qualifiedName);
+
+  ///
+  // Moves the cursor to the attribute with the specified local name and
+  // namespace URI. Returns true (1) if the cursor position was set
+  // successfully.
+  ///
+  int (CEF_CALLBACK *move_to_attribute_bylname)(struct _cef_xml_reader_t* self,
+      const cef_string_t* localName, const cef_string_t* namespaceURI);
+
+  ///
+  // Moves the cursor to the first attribute in the current element. Returns
+  // true (1) if the cursor position was set successfully.
+  ///
+  int (CEF_CALLBACK *move_to_first_attribute)(struct _cef_xml_reader_t* self);
+
+  ///
+  // Moves the cursor to the next attribute in the current element. Returns true
+  // (1) if the cursor position was set successfully.
+  ///
+  int (CEF_CALLBACK *move_to_next_attribute)(struct _cef_xml_reader_t* self);
+
+  ///
+  // Moves the cursor back to the carrying element. Returns true (1) if the
+  // cursor position was set successfully.
+  ///
+  int (CEF_CALLBACK *move_to_carrying_element)(struct _cef_xml_reader_t* self);
+} cef_xml_reader_t;
+
+
+///
+// Create a new cef_xml_reader_t object. The returned object's functions can
+// only be called from the thread that created the object.
+///
+CEF_EXPORT cef_xml_reader_t* cef_xml_reader_create(
+    struct _cef_stream_reader_t* stream, cef_xml_encoding_type_t encodingType,
+    const cef_string_t* URI);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_XML_READER_CAPI_H_
diff --git a/src/include/libcef/capi/cef_zip_reader_capi.h b/src/include/libcef/capi/cef_zip_reader_capi.h
new file mode 100644
index 0000000..30ef406
--- /dev/null
+++ b/src/include/libcef/capi/cef_zip_reader_capi.h
@@ -0,0 +1,150 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_ZIP_READER_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_ZIP_READER_CAPI_H_
+#pragma once
+
+#include "libcef/capi/cef_base_capi.h"
+#include "libcef/capi/cef_stream_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Structure that supports the reading of zip archives via the zlib unzip API.
+// The functions of this structure should only be called on the thread that
+// creates the object.
+///
+typedef struct _cef_zip_reader_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Moves the cursor to the first file in the archive. Returns true (1) if the
+  // cursor position was set successfully.
+  ///
+  int (CEF_CALLBACK *move_to_first_file)(struct _cef_zip_reader_t* self);
+
+  ///
+  // Moves the cursor to the next file in the archive. Returns true (1) if the
+  // cursor position was set successfully.
+  ///
+  int (CEF_CALLBACK *move_to_next_file)(struct _cef_zip_reader_t* self);
+
+  ///
+  // Moves the cursor to the specified file in the archive. If |caseSensitive|
+  // is true (1) then the search will be case sensitive. Returns true (1) if the
+  // cursor position was set successfully.
+  ///
+  int (CEF_CALLBACK *move_to_file)(struct _cef_zip_reader_t* self,
+      const cef_string_t* fileName, int caseSensitive);
+
+  ///
+  // Closes the archive. This should be called directly to ensure that cleanup
+  // occurs on the correct thread.
+  ///
+  int (CEF_CALLBACK *close)(struct _cef_zip_reader_t* self);
+
+
+  // The below functions act on the file at the current cursor position.
+
+  ///
+  // Returns the name of the file.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_file_name)(
+      struct _cef_zip_reader_t* self);
+
+  ///
+  // Returns the uncompressed size of the file.
+  ///
+  int64 (CEF_CALLBACK *get_file_size)(struct _cef_zip_reader_t* self);
+
+  ///
+  // Returns the last modified timestamp for the file.
+  ///
+  cef_time_t (CEF_CALLBACK *get_file_last_modified)(
+      struct _cef_zip_reader_t* self);
+
+  ///
+  // Opens the file for reading of uncompressed data. A read password may
+  // optionally be specified.
+  ///
+  int (CEF_CALLBACK *open_file)(struct _cef_zip_reader_t* self,
+      const cef_string_t* password);
+
+  ///
+  // Closes the file.
+  ///
+  int (CEF_CALLBACK *close_file)(struct _cef_zip_reader_t* self);
+
+  ///
+  // Read uncompressed file contents into the specified buffer. Returns < 0 if
+  // an error occurred, 0 if at the end of file, or the number of bytes read.
+  ///
+  int (CEF_CALLBACK *read_file)(struct _cef_zip_reader_t* self, void* buffer,
+      size_t bufferSize);
+
+  ///
+  // Returns the current offset in the uncompressed file contents.
+  ///
+  int64 (CEF_CALLBACK *tell)(struct _cef_zip_reader_t* self);
+
+  ///
+  // Returns true (1) if at end of the file contents.
+  ///
+  int (CEF_CALLBACK *eof)(struct _cef_zip_reader_t* self);
+} cef_zip_reader_t;
+
+
+///
+// Create a new cef_zip_reader_t object. The returned object's functions can
+// only be called from the thread that created the object.
+///
+CEF_EXPORT cef_zip_reader_t* cef_zip_reader_create(
+    struct _cef_stream_reader_t* stream);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_ZIP_READER_CAPI_H_
diff --git a/src/include/libcef/capi/views/cef_box_layout_capi.h b/src/include/libcef/capi/views/cef_box_layout_capi.h
new file mode 100644
index 0000000..32a978d
--- /dev/null
+++ b/src/include/libcef/capi/views/cef_box_layout_capi.h
@@ -0,0 +1,86 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_VIEWS_CEF_BOX_LAYOUT_CAPI_H_
+#define CEF_INCLUDE_CAPI_VIEWS_CEF_BOX_LAYOUT_CAPI_H_
+#pragma once
+
+#include "libcef/capi/views/cef_layout_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _cef_view_t;
+
+///
+// A Layout manager that arranges child views vertically or horizontally in a
+// side-by-side fashion with spacing around and between the child views. The
+// child views are always sized according to their preferred size. If the host's
+// bounds provide insufficient space, child views will be clamped. Excess space
+// will not be distributed. Methods must be called on the browser process UI
+// thread unless otherwise indicated.
+///
+typedef struct _cef_box_layout_t {
+  ///
+  // Base structure.
+  ///
+  cef_layout_t base;
+
+  ///
+  // Set the flex weight for the given |view|. Using the preferred size as the
+  // basis, free space along the main axis is distributed to views in the ratio
+  // of their flex weights. Similarly, if the views will overflow the parent,
+  // space is subtracted in these ratios. A flex of 0 means this view is not
+  // resized. Flex values must not be negative.
+  ///
+  void (CEF_CALLBACK *set_flex_for_view)(struct _cef_box_layout_t* self,
+      struct _cef_view_t* view, int flex);
+
+  ///
+  // Clears the flex for the given |view|, causing it to use the default flex
+  // specified via cef_box_layout_tSettings.default_flex.
+  ///
+  void (CEF_CALLBACK *clear_flex_for_view)(struct _cef_box_layout_t* self,
+      struct _cef_view_t* view);
+} cef_box_layout_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_VIEWS_CEF_BOX_LAYOUT_CAPI_H_
diff --git a/src/include/libcef/capi/views/cef_browser_view_capi.h b/src/include/libcef/capi/views/cef_browser_view_capi.h
new file mode 100644
index 0000000..f4d580b
--- /dev/null
+++ b/src/include/libcef/capi/views/cef_browser_view_capi.h
@@ -0,0 +1,90 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_VIEWS_CEF_BROWSER_VIEW_CAPI_H_
+#define CEF_INCLUDE_CAPI_VIEWS_CEF_BROWSER_VIEW_CAPI_H_
+#pragma once
+
+#include "libcef/capi/cef_browser_capi.h"
+#include "libcef/capi/views/cef_browser_view_delegate_capi.h"
+#include "libcef/capi/views/cef_view_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// A View hosting a cef_browser_t instance. Methods must be called on the
+// browser process UI thread unless otherwise indicated.
+///
+typedef struct _cef_browser_view_t {
+  ///
+  // Base structure.
+  ///
+  cef_view_t base;
+
+  ///
+  // Returns the cef_browser_t hosted by this BrowserView. Will return NULL if
+  // the browser has not yet been created or has already been destroyed.
+  ///
+  struct _cef_browser_t* (CEF_CALLBACK *get_browser)(
+      struct _cef_browser_view_t* self);
+} cef_browser_view_t;
+
+
+///
+// Create a new BrowserView. The underlying cef_browser_t will not be created
+// until this view is added to the views hierarchy.
+///
+CEF_EXPORT cef_browser_view_t* cef_browser_view_create(
+    struct _cef_client_t* client, const cef_string_t* url,
+    const struct _cef_browser_settings_t* settings,
+    struct _cef_request_context_t* request_context,
+    struct _cef_browser_view_delegate_t* delegate);
+
+///
+// Returns the BrowserView associated with |browser|.
+///
+CEF_EXPORT cef_browser_view_t* cef_browser_view_get_for_browser(
+    struct _cef_browser_t* browser);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_VIEWS_CEF_BROWSER_VIEW_CAPI_H_
diff --git a/src/include/libcef/capi/views/cef_browser_view_delegate_capi.h b/src/include/libcef/capi/views/cef_browser_view_delegate_capi.h
new file mode 100644
index 0000000..cff0998
--- /dev/null
+++ b/src/include/libcef/capi/views/cef_browser_view_delegate_capi.h
@@ -0,0 +1,118 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_VIEWS_CEF_BROWSER_VIEW_DELEGATE_CAPI_H_
+#define CEF_INCLUDE_CAPI_VIEWS_CEF_BROWSER_VIEW_DELEGATE_CAPI_H_
+#pragma once
+
+#include "libcef/capi/cef_client_capi.h"
+#include "libcef/capi/views/cef_view_delegate_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _cef_browser_t;
+struct _cef_browser_view_t;
+
+///
+// Implement this structure to handle BrowserView events. The functions of this
+// structure will be called on the browser process UI thread unless otherwise
+// indicated.
+///
+typedef struct _cef_browser_view_delegate_t {
+  ///
+  // Base structure.
+  ///
+  cef_view_delegate_t base;
+
+  ///
+  // Called when |browser| associated with |browser_view| is created. This
+  // function will be called after cef_life_span_handler_t::on_after_created()
+  // is called for |browser| and before on_popup_browser_view_created() is
+  // called for |browser|'s parent delegate if |browser| is a popup.
+  ///
+  void (CEF_CALLBACK *on_browser_created)(
+      struct _cef_browser_view_delegate_t* self,
+      struct _cef_browser_view_t* browser_view,
+      struct _cef_browser_t* browser);
+
+  ///
+  // Called when |browser| associated with |browser_view| is destroyed. Release
+  // all references to |browser| and do not attempt to execute any functions on
+  // |browser| after this callback returns. This function will be called before
+  // cef_life_span_handler_t::on_before_close() is called for |browser|.
+  ///
+  void (CEF_CALLBACK *on_browser_destroyed)(
+      struct _cef_browser_view_delegate_t* self,
+      struct _cef_browser_view_t* browser_view,
+      struct _cef_browser_t* browser);
+
+  ///
+  // Called before a new popup BrowserView is created. The popup originated from
+  // |browser_view|. |settings| and |client| are the values returned from
+  // cef_life_span_handler_t::on_before_popup(). |is_devtools| will be true (1)
+  // if the popup will be a DevTools browser. Return the delegate that will be
+  // used for the new popup BrowserView.
+  ///
+  struct _cef_browser_view_delegate_t* (
+      CEF_CALLBACK *get_delegate_for_popup_browser_view)(
+      struct _cef_browser_view_delegate_t* self,
+      struct _cef_browser_view_t* browser_view,
+      const struct _cef_browser_settings_t* settings,
+      struct _cef_client_t* client, int is_devtools);
+
+  ///
+  // Called after |popup_browser_view| is created. This function will be called
+  // after cef_life_span_handler_t::on_after_created() and on_browser_created()
+  // are called for the new popup browser. The popup originated from
+  // |browser_view|. |is_devtools| will be true (1) if the popup is a DevTools
+  // browser. Optionally add |popup_browser_view| to the views hierarchy
+  // yourself and return true (1). Otherwise return false (0) and a default
+  // cef_window_t will be created for the popup.
+  ///
+  int (CEF_CALLBACK *on_popup_browser_view_created)(
+      struct _cef_browser_view_delegate_t* self,
+      struct _cef_browser_view_t* browser_view,
+      struct _cef_browser_view_t* popup_browser_view, int is_devtools);
+} cef_browser_view_delegate_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_VIEWS_CEF_BROWSER_VIEW_DELEGATE_CAPI_H_
diff --git a/src/include/libcef/capi/views/cef_button_capi.h b/src/include/libcef/capi/views/cef_button_capi.h
new file mode 100644
index 0000000..a8034a6
--- /dev/null
+++ b/src/include/libcef/capi/views/cef_button_capi.h
@@ -0,0 +1,96 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_VIEWS_CEF_BUTTON_CAPI_H_
+#define CEF_INCLUDE_CAPI_VIEWS_CEF_BUTTON_CAPI_H_
+#pragma once
+
+#include "libcef/capi/views/cef_view_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _cef_label_button_t;
+
+///
+// A View representing a button. Depending on the specific type, the button
+// could be implemented by a native control or custom rendered. Methods must be
+// called on the browser process UI thread unless otherwise indicated.
+///
+typedef struct _cef_button_t {
+  ///
+  // Base structure.
+  ///
+  cef_view_t base;
+
+  ///
+  // Returns this Button as a LabelButton or NULL if this is not a LabelButton.
+  ///
+  struct _cef_label_button_t* (CEF_CALLBACK *as_label_button)(
+      struct _cef_button_t* self);
+
+  ///
+  // Sets the current display state of the Button.
+  ///
+  void (CEF_CALLBACK *set_state)(struct _cef_button_t* self,
+      cef_button_state_t state);
+
+  ///
+  // Returns the current display state of the Button.
+  ///
+  cef_button_state_t (CEF_CALLBACK *get_state)(struct _cef_button_t* self);
+
+  ///
+  // Sets the tooltip text that will be displayed when the user hovers the mouse
+  // cursor over the Button.
+  ///
+  void (CEF_CALLBACK *set_tooltip_text)(struct _cef_button_t* self,
+      const cef_string_t* tooltip_text);
+
+  ///
+  // Sets the accessible name that will be exposed to assistive technology (AT).
+  ///
+  void (CEF_CALLBACK *set_accessible_name)(struct _cef_button_t* self,
+      const cef_string_t* name);
+} cef_button_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_VIEWS_CEF_BUTTON_CAPI_H_
diff --git a/src/include/libcef/capi/views/cef_button_delegate_capi.h b/src/include/libcef/capi/views/cef_button_delegate_capi.h
new file mode 100644
index 0000000..a9b19ed
--- /dev/null
+++ b/src/include/libcef/capi/views/cef_button_delegate_capi.h
@@ -0,0 +1,72 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_VIEWS_CEF_BUTTON_DELEGATE_CAPI_H_
+#define CEF_INCLUDE_CAPI_VIEWS_CEF_BUTTON_DELEGATE_CAPI_H_
+#pragma once
+
+#include "libcef/capi/views/cef_view_delegate_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _cef_button_t;
+
+///
+// Implement this structure to handle Button events. The functions of this
+// structure will be called on the browser process UI thread unless otherwise
+// indicated.
+///
+typedef struct _cef_button_delegate_t {
+  ///
+  // Base structure.
+  ///
+  cef_view_delegate_t base;
+
+  ///
+  // Called when |button| is pressed.
+  ///
+  void (CEF_CALLBACK *on_button_pressed)(struct _cef_button_delegate_t* self,
+      struct _cef_button_t* button);
+} cef_button_delegate_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_VIEWS_CEF_BUTTON_DELEGATE_CAPI_H_
diff --git a/src/include/libcef/capi/views/cef_display_capi.h b/src/include/libcef/capi/views/cef_display_capi.h
new file mode 100644
index 0000000..a3b0892
--- /dev/null
+++ b/src/include/libcef/capi/views/cef_display_capi.h
@@ -0,0 +1,145 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_VIEWS_CEF_DISPLAY_CAPI_H_
+#define CEF_INCLUDE_CAPI_VIEWS_CEF_DISPLAY_CAPI_H_
+#pragma once
+
+#include "libcef/capi/cef_base_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// This structure typically, but not always, corresponds to a physical display
+// connected to the system. A fake Display may exist on a headless system, or a
+// Display may correspond to a remote, virtual display. All size and position
+// values are in density independent pixels (DIP) unless otherwise indicated.
+// Methods must be called on the browser process UI thread unless otherwise
+// indicated.
+///
+typedef struct _cef_display_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns the unique identifier for this Display.
+  ///
+  int64 (CEF_CALLBACK *get_id)(struct _cef_display_t* self);
+
+  ///
+  // Returns this Display's device pixel scale factor. This specifies how much
+  // the UI should be scaled when the actual output has more pixels than
+  // standard displays (which is around 100~120dpi). The potential return values
+  // differ by platform.
+  ///
+  float (CEF_CALLBACK *get_device_scale_factor)(struct _cef_display_t* self);
+
+  ///
+  // Convert |point| from density independent pixels (DIP) to pixel coordinates
+  // using this Display's device scale factor.
+  ///
+  void (CEF_CALLBACK *convert_point_to_pixels)(struct _cef_display_t* self,
+      cef_point_t* point);
+
+  ///
+  // Convert |point| from pixel coordinates to density independent pixels (DIP)
+  // using this Display's device scale factor.
+  ///
+  void (CEF_CALLBACK *convert_point_from_pixels)(struct _cef_display_t* self,
+      cef_point_t* point);
+
+  ///
+  // Returns this Display's bounds. This is the full size of the display.
+  ///
+  cef_rect_t (CEF_CALLBACK *get_bounds)(struct _cef_display_t* self);
+
+  ///
+  // Returns this Display's work area. This excludes areas of the display that
+  // are occupied for window manager toolbars, etc.
+  ///
+  cef_rect_t (CEF_CALLBACK *get_work_area)(struct _cef_display_t* self);
+
+  ///
+  // Returns this Display's rotation in degrees.
+  ///
+  int (CEF_CALLBACK *get_rotation)(struct _cef_display_t* self);
+} cef_display_t;
+
+
+///
+// Returns the primary Display.
+///
+CEF_EXPORT cef_display_t* cef_display_get_primary();
+
+///
+// Returns the Display nearest |point|. Set |input_pixel_coords| to true (1) if
+// |point| is in pixel coordinates instead of density independent pixels (DIP).
+///
+CEF_EXPORT cef_display_t* cef_display_get_nearest_point(
+    const cef_point_t* point, int input_pixel_coords);
+
+///
+// Returns the Display that most closely intersects |bounds|.  Set
+// |input_pixel_coords| to true (1) if |bounds| is in pixel coordinates instead
+// of density independent pixels (DIP).
+///
+CEF_EXPORT cef_display_t* cef_display_get_matching_bounds(
+    const cef_rect_t* bounds, int input_pixel_coords);
+
+///
+// Returns the total number of Displays. Mirrored displays are excluded; this
+// function is intended to return the number of distinct, usable displays.
+///
+CEF_EXPORT size_t cef_display_get_count();
+
+///
+// Returns all Displays. Mirrored displays are excluded; this function is
+// intended to return distinct, usable displays.
+///
+CEF_EXPORT void cef_display_get_alls(size_t* displaysCount,
+    cef_display_t** displays);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_VIEWS_CEF_DISPLAY_CAPI_H_
diff --git a/src/include/libcef/capi/views/cef_fill_layout_capi.h b/src/include/libcef/capi/views/cef_fill_layout_capi.h
new file mode 100644
index 0000000..e137326
--- /dev/null
+++ b/src/include/libcef/capi/views/cef_fill_layout_capi.h
@@ -0,0 +1,65 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_VIEWS_CEF_FILL_LAYOUT_CAPI_H_
+#define CEF_INCLUDE_CAPI_VIEWS_CEF_FILL_LAYOUT_CAPI_H_
+#pragma once
+
+#include "libcef/capi/views/cef_layout_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// A simple Layout that causes the associated Panel's one child to be sized to
+// match the bounds of its parent. Methods must be called on the browser process
+// UI thread unless otherwise indicated.
+///
+typedef struct _cef_fill_layout_t {
+  ///
+  // Base structure.
+  ///
+  cef_layout_t base;
+} cef_fill_layout_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_VIEWS_CEF_FILL_LAYOUT_CAPI_H_
diff --git a/src/include/libcef/capi/views/cef_label_button_capi.h b/src/include/libcef/capi/views/cef_label_button_capi.h
new file mode 100644
index 0000000..90e66b0
--- /dev/null
+++ b/src/include/libcef/capi/views/cef_label_button_capi.h
@@ -0,0 +1,161 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_VIEWS_CEF_LABEL_BUTTON_CAPI_H_
+#define CEF_INCLUDE_CAPI_VIEWS_CEF_LABEL_BUTTON_CAPI_H_
+#pragma once
+
+#include "libcef/capi/cef_image_capi.h"
+#include "libcef/capi/views/cef_button_capi.h"
+#include "libcef/capi/views/cef_button_delegate_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _cef_menu_button_t;
+
+///
+// LabelButton is a button with optional text and/or icon. Methods must be
+// called on the browser process UI thread unless otherwise indicated.
+///
+typedef struct _cef_label_button_t {
+  ///
+  // Base structure.
+  ///
+  cef_button_t base;
+
+  ///
+  // Returns this LabelButton as a MenuButton or NULL if this is not a
+  // MenuButton.
+  ///
+  struct _cef_menu_button_t* (CEF_CALLBACK *as_menu_button)(
+      struct _cef_label_button_t* self);
+
+  ///
+  // Sets the text shown on the LabelButton. By default |text| will also be used
+  // as the accessible name.
+  ///
+  void (CEF_CALLBACK *set_text)(struct _cef_label_button_t* self,
+      const cef_string_t* text);
+
+  ///
+  // Returns the text shown on the LabelButton.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_text)(
+      struct _cef_label_button_t* self);
+
+  ///
+  // Sets the image shown for |button_state|. When this Button is drawn if no
+  // image exists for the current state then the image for
+  // CEF_BUTTON_STATE_NORMAL, if any, will be shown.
+  ///
+  void (CEF_CALLBACK *set_image)(struct _cef_label_button_t* self,
+      cef_button_state_t button_state, struct _cef_image_t* image);
+
+  ///
+  // Returns the image shown for |button_state|. If no image exists for that
+  // state then the image for CEF_BUTTON_STATE_NORMAL will be returned.
+  ///
+  struct _cef_image_t* (CEF_CALLBACK *get_image)(
+      struct _cef_label_button_t* self, cef_button_state_t button_state);
+
+  ///
+  // Sets the text color shown for the specified button |for_state| to |color|.
+  ///
+  void (CEF_CALLBACK *set_text_color)(struct _cef_label_button_t* self,
+      cef_button_state_t for_state, cef_color_t color);
+
+  ///
+  // Sets the text colors shown for the non-disabled states to |color|.
+  ///
+  void (CEF_CALLBACK *set_enabled_text_colors)(struct _cef_label_button_t* self,
+      cef_color_t color);
+
+  ///
+  // Sets the font list. The format is "<FONT_FAMILY_LIST>,[STYLES] <SIZE>",
+  // where: - FONT_FAMILY_LIST is a comma-separated list of font family names, -
+  // STYLES is an optional space-separated list of style names (case-sensitive
+  //   "Bold" and "Italic" are supported), and
+  // - SIZE is an integer font size in pixels with the suffix "px".
+  //
+  // Here are examples of valid font description strings: - "Arial, Helvetica,
+  // Bold Italic 14px" - "Arial, 14px"
+  ///
+  void (CEF_CALLBACK *set_font_list)(struct _cef_label_button_t* self,
+      const cef_string_t* font_list);
+
+  ///
+  // Sets the horizontal alignment; reversed in RTL. Default is
+  // CEF_HORIZONTAL_ALIGNMENT_CENTER.
+  ///
+  void (CEF_CALLBACK *set_horizontal_alignment)(
+      struct _cef_label_button_t* self, cef_horizontal_alignment_t alignment);
+
+  ///
+  // Reset the minimum size of this LabelButton to |size|.
+  ///
+  void (CEF_CALLBACK *set_minimum_size)(struct _cef_label_button_t* self,
+      const cef_size_t* size);
+
+  ///
+  // Reset the maximum size of this LabelButton to |size|.
+  ///
+  void (CEF_CALLBACK *set_maximum_size)(struct _cef_label_button_t* self,
+      const cef_size_t* size);
+} cef_label_button_t;
+
+
+///
+// Create a new LabelButton. A |delegate| must be provided to handle the button
+// click. |text| will be shown on the LabelButton and used as the default
+// accessible name. If |with_frame| is true (1) the button will have a visible
+// frame at all times, center alignment, additional padding and a default
+// minimum size of 70x33 DIP. If |with_frame| is false (0) the button will only
+// have a visible frame on hover/press, left alignment, less padding and no
+// default minimum size.
+///
+CEF_EXPORT cef_label_button_t* cef_label_button_create(
+    struct _cef_button_delegate_t* delegate, const cef_string_t* text,
+    int with_frame);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_VIEWS_CEF_LABEL_BUTTON_CAPI_H_
diff --git a/src/include/libcef/capi/views/cef_layout_capi.h b/src/include/libcef/capi/views/cef_layout_capi.h
new file mode 100644
index 0000000..e63697c
--- /dev/null
+++ b/src/include/libcef/capi/views/cef_layout_capi.h
@@ -0,0 +1,84 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_VIEWS_CEF_LAYOUT_CAPI_H_
+#define CEF_INCLUDE_CAPI_VIEWS_CEF_LAYOUT_CAPI_H_
+#pragma once
+
+#include "libcef/capi/cef_base_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _cef_box_layout_t;
+struct _cef_fill_layout_t;
+
+///
+// A Layout handles the sizing of the children of a Panel according to
+// implementation-specific heuristics. Methods must be called on the browser
+// process UI thread unless otherwise indicated.
+///
+typedef struct _cef_layout_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns this Layout as a BoxLayout or NULL if this is not a BoxLayout.
+  ///
+  struct _cef_box_layout_t* (CEF_CALLBACK *as_box_layout)(
+      struct _cef_layout_t* self);
+
+  ///
+  // Returns this Layout as a FillLayout or NULL if this is not a FillLayout.
+  ///
+  struct _cef_fill_layout_t* (CEF_CALLBACK *as_fill_layout)(
+      struct _cef_layout_t* self);
+
+  ///
+  // Returns true (1) if this Layout is valid.
+  ///
+  int (CEF_CALLBACK *is_valid)(struct _cef_layout_t* self);
+} cef_layout_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_VIEWS_CEF_LAYOUT_CAPI_H_
diff --git a/src/include/libcef/capi/views/cef_menu_button_capi.h b/src/include/libcef/capi/views/cef_menu_button_capi.h
new file mode 100644
index 0000000..9c5ae20
--- /dev/null
+++ b/src/include/libcef/capi/views/cef_menu_button_capi.h
@@ -0,0 +1,93 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_VIEWS_CEF_MENU_BUTTON_CAPI_H_
+#define CEF_INCLUDE_CAPI_VIEWS_CEF_MENU_BUTTON_CAPI_H_
+#pragma once
+
+#include "libcef/capi/cef_menu_model_capi.h"
+#include "libcef/capi/views/cef_label_button_capi.h"
+#include "libcef/capi/views/cef_menu_button_delegate_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// MenuButton is a button with optional text, icon and/or menu marker that shows
+// a menu when clicked with the left mouse button. All size and position values
+// are in density independent pixels (DIP) unless otherwise indicated. Methods
+// must be called on the browser process UI thread unless otherwise indicated.
+///
+typedef struct _cef_menu_button_t {
+  ///
+  // Base structure.
+  ///
+  cef_label_button_t base;
+
+  ///
+  // Show a menu with contents |menu_model|. |screen_point| specifies the menu
+  // position in screen coordinates. |anchor_position| specifies how the menu
+  // will be anchored relative to |screen_point|. This function should be called
+  // from cef_menu_button_delegate_t::on_menu_button_pressed().
+  ///
+  void (CEF_CALLBACK *show_menu)(struct _cef_menu_button_t* self,
+      struct _cef_menu_model_t* menu_model, const cef_point_t* screen_point,
+      cef_menu_anchor_position_t anchor_position);
+} cef_menu_button_t;
+
+
+///
+// Create a new MenuButton. A |delegate| must be provided to call show_menu()
+// when the button is clicked. |text| will be shown on the MenuButton and used
+// as the default accessible name. If |with_frame| is true (1) the button will
+// have a visible frame at all times, center alignment, additional padding and a
+// default minimum size of 70x33 DIP. If |with_frame| is false (0) the button
+// will only have a visible frame on hover/press, left alignment, less padding
+// and no default minimum size. If |with_menu_marker| is true (1) a menu marker
+// will be added to the button.
+///
+CEF_EXPORT cef_menu_button_t* cef_menu_button_create(
+    struct _cef_menu_button_delegate_t* delegate, const cef_string_t* text,
+    int with_frame, int with_menu_marker);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_VIEWS_CEF_MENU_BUTTON_CAPI_H_
diff --git a/src/include/libcef/capi/views/cef_menu_button_delegate_capi.h b/src/include/libcef/capi/views/cef_menu_button_delegate_capi.h
new file mode 100644
index 0000000..e8099aa
--- /dev/null
+++ b/src/include/libcef/capi/views/cef_menu_button_delegate_capi.h
@@ -0,0 +1,75 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_VIEWS_CEF_MENU_BUTTON_DELEGATE_CAPI_H_
+#define CEF_INCLUDE_CAPI_VIEWS_CEF_MENU_BUTTON_DELEGATE_CAPI_H_
+#pragma once
+
+#include "libcef/capi/views/cef_button_delegate_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _cef_menu_button_t;
+
+///
+// Implement this structure to handle MenuButton events. The functions of this
+// structure will be called on the browser process UI thread unless otherwise
+// indicated.
+///
+typedef struct _cef_menu_button_delegate_t {
+  ///
+  // Base structure.
+  ///
+  cef_button_delegate_t base;
+
+  ///
+  // Called when |button| is pressed. Call cef_menu_button_t::show_menu() to
+  // show the resulting menu at |screen_point|.
+  ///
+  void (CEF_CALLBACK *on_menu_button_pressed)(
+      struct _cef_menu_button_delegate_t* self,
+      struct _cef_menu_button_t* menu_button,
+      const cef_point_t* screen_point);
+} cef_menu_button_delegate_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_VIEWS_CEF_MENU_BUTTON_DELEGATE_CAPI_H_
diff --git a/src/include/libcef/capi/views/cef_panel_capi.h b/src/include/libcef/capi/views/cef_panel_capi.h
new file mode 100644
index 0000000..ad76374
--- /dev/null
+++ b/src/include/libcef/capi/views/cef_panel_capi.h
@@ -0,0 +1,149 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_VIEWS_CEF_PANEL_CAPI_H_
+#define CEF_INCLUDE_CAPI_VIEWS_CEF_PANEL_CAPI_H_
+#pragma once
+
+#include "libcef/capi/views/cef_panel_delegate_capi.h"
+#include "libcef/capi/views/cef_view_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _cef_box_layout_t;
+struct _cef_fill_layout_t;
+struct _cef_layout_t;
+struct _cef_window_t;
+
+///
+// A Panel is a container in the views hierarchy that can contain other Views as
+// children. Methods must be called on the browser process UI thread unless
+// otherwise indicated.
+///
+typedef struct _cef_panel_t {
+  ///
+  // Base structure.
+  ///
+  cef_view_t base;
+
+  ///
+  // Returns this Panel as a Window or NULL if this is not a Window.
+  ///
+  struct _cef_window_t* (CEF_CALLBACK *as_window)(struct _cef_panel_t* self);
+
+  ///
+  // Set this Panel's Layout to FillLayout and return the FillLayout object.
+  ///
+  struct _cef_fill_layout_t* (CEF_CALLBACK *set_to_fill_layout)(
+      struct _cef_panel_t* self);
+
+  ///
+  // Set this Panel's Layout to BoxLayout and return the BoxLayout object.
+  ///
+  struct _cef_box_layout_t* (CEF_CALLBACK *set_to_box_layout)(
+      struct _cef_panel_t* self,
+      const struct _cef_box_layout_settings_t* settings);
+
+  ///
+  // Get the Layout.
+  ///
+  struct _cef_layout_t* (CEF_CALLBACK *get_layout)(struct _cef_panel_t* self);
+
+  ///
+  // Lay out the child Views (set their bounds based on sizing heuristics
+  // specific to the current Layout).
+  ///
+  void (CEF_CALLBACK *layout)(struct _cef_panel_t* self);
+
+  ///
+  // Add a child View.
+  ///
+  void (CEF_CALLBACK *add_child_view)(struct _cef_panel_t* self,
+      struct _cef_view_t* view);
+
+  ///
+  // Add a child View at the specified |index|. If |index| matches the result of
+  // GetChildCount() then the View will be added at the end.
+  ///
+  void (CEF_CALLBACK *add_child_view_at)(struct _cef_panel_t* self,
+      struct _cef_view_t* view, int index);
+
+  ///
+  // Move the child View to the specified |index|. A negative value for |index|
+  // will move the View to the end.
+  ///
+  void (CEF_CALLBACK *reorder_child_view)(struct _cef_panel_t* self,
+      struct _cef_view_t* view, int index);
+
+  ///
+  // Remove a child View. The View can then be added to another Panel.
+  ///
+  void (CEF_CALLBACK *remove_child_view)(struct _cef_panel_t* self,
+      struct _cef_view_t* view);
+
+  ///
+  // Remove all child Views. The removed Views will be deleted if the client
+  // holds no references to them.
+  ///
+  void (CEF_CALLBACK *remove_all_child_views)(struct _cef_panel_t* self);
+
+  ///
+  // Returns the number of child Views.
+  ///
+  size_t (CEF_CALLBACK *get_child_view_count)(struct _cef_panel_t* self);
+
+  ///
+  // Returns the child View at the specified |index|.
+  ///
+  struct _cef_view_t* (CEF_CALLBACK *get_child_view_at)(
+      struct _cef_panel_t* self, int index);
+} cef_panel_t;
+
+
+///
+// Create a new Panel.
+///
+CEF_EXPORT cef_panel_t* cef_panel_create(
+    struct _cef_panel_delegate_t* delegate);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_VIEWS_CEF_PANEL_CAPI_H_
diff --git a/src/include/libcef/capi/views/cef_panel_delegate_capi.h b/src/include/libcef/capi/views/cef_panel_delegate_capi.h
new file mode 100644
index 0000000..24d6e13
--- /dev/null
+++ b/src/include/libcef/capi/views/cef_panel_delegate_capi.h
@@ -0,0 +1,65 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_VIEWS_CEF_PANEL_DELEGATE_CAPI_H_
+#define CEF_INCLUDE_CAPI_VIEWS_CEF_PANEL_DELEGATE_CAPI_H_
+#pragma once
+
+#include "libcef/capi/views/cef_view_delegate_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Implement this structure to handle Panel events. The functions of this
+// structure will be called on the browser process UI thread unless otherwise
+// indicated.
+///
+typedef struct _cef_panel_delegate_t {
+  ///
+  // Base structure.
+  ///
+  cef_view_delegate_t base;
+} cef_panel_delegate_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_VIEWS_CEF_PANEL_DELEGATE_CAPI_H_
diff --git a/src/include/libcef/capi/views/cef_scroll_view_capi.h b/src/include/libcef/capi/views/cef_scroll_view_capi.h
new file mode 100644
index 0000000..f153a4f
--- /dev/null
+++ b/src/include/libcef/capi/views/cef_scroll_view_capi.h
@@ -0,0 +1,113 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_VIEWS_CEF_SCROLL_VIEW_CAPI_H_
+#define CEF_INCLUDE_CAPI_VIEWS_CEF_SCROLL_VIEW_CAPI_H_
+#pragma once
+
+#include "libcef/capi/views/cef_view_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// A ScrollView will show horizontal and/or vertical scrollbars when necessary
+// based on the size of the attached content view. Methods must be called on the
+// browser process UI thread unless otherwise indicated.
+///
+typedef struct _cef_scroll_view_t {
+  ///
+  // Base structure.
+  ///
+  cef_view_t base;
+
+  ///
+  // Set the content View. The content View must have a specified size (e.g. via
+  // cef_view_t::SetBounds or cef_view_tDelegate::GetPreferredSize).
+  ///
+  void (CEF_CALLBACK *set_content_view)(struct _cef_scroll_view_t* self,
+      struct _cef_view_t* view);
+
+  ///
+  // Returns the content View.
+  ///
+  struct _cef_view_t* (CEF_CALLBACK *get_content_view)(
+      struct _cef_scroll_view_t* self);
+
+  ///
+  // Returns the visible region of the content View.
+  ///
+  cef_rect_t (CEF_CALLBACK *get_visible_content_rect)(
+      struct _cef_scroll_view_t* self);
+
+  ///
+  // Returns true (1) if the horizontal scrollbar is currently showing.
+  ///
+  int (CEF_CALLBACK *has_horizontal_scrollbar)(struct _cef_scroll_view_t* self);
+
+  ///
+  // Returns the height of the horizontal scrollbar.
+  ///
+  int (CEF_CALLBACK *get_horizontal_scrollbar_height)(
+      struct _cef_scroll_view_t* self);
+
+  ///
+  // Returns true (1) if the vertical scrollbar is currently showing.
+  ///
+  int (CEF_CALLBACK *has_vertical_scrollbar)(struct _cef_scroll_view_t* self);
+
+  ///
+  // Returns the width of the vertical scrollbar.
+  ///
+  int (CEF_CALLBACK *get_vertical_scrollbar_width)(
+      struct _cef_scroll_view_t* self);
+} cef_scroll_view_t;
+
+
+///
+// Create a new ScrollView.
+///
+CEF_EXPORT cef_scroll_view_t* cef_scroll_view_create(
+    struct _cef_view_delegate_t* delegate);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_VIEWS_CEF_SCROLL_VIEW_CAPI_H_
diff --git a/src/include/libcef/capi/views/cef_textfield_capi.h b/src/include/libcef/capi/views/cef_textfield_capi.h
new file mode 100644
index 0000000..c03f6b7
--- /dev/null
+++ b/src/include/libcef/capi/views/cef_textfield_capi.h
@@ -0,0 +1,279 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_VIEWS_CEF_TEXTFIELD_CAPI_H_
+#define CEF_INCLUDE_CAPI_VIEWS_CEF_TEXTFIELD_CAPI_H_
+#pragma once
+
+#include "libcef/capi/views/cef_textfield_delegate_capi.h"
+#include "libcef/capi/views/cef_view_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// A Textfield supports editing of text. This control is custom rendered with no
+// platform-specific code. Methods must be called on the browser process UI
+// thread unless otherwise indicated.
+///
+typedef struct _cef_textfield_t {
+  ///
+  // Base structure.
+  ///
+  cef_view_t base;
+
+  ///
+  // Sets whether the text will be displayed as asterisks.
+  ///
+  void (CEF_CALLBACK *set_password_input)(struct _cef_textfield_t* self,
+      int password_input);
+
+  ///
+  // Returns true (1) if the text will be displayed as asterisks.
+  ///
+  int (CEF_CALLBACK *is_password_input)(struct _cef_textfield_t* self);
+
+  ///
+  // Sets whether the text will read-only.
+  ///
+  void (CEF_CALLBACK *set_read_only)(struct _cef_textfield_t* self,
+      int read_only);
+
+  ///
+  // Returns true (1) if the text is read-only.
+  ///
+  int (CEF_CALLBACK *is_read_only)(struct _cef_textfield_t* self);
+
+  ///
+  // Returns the currently displayed text.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_text)(struct _cef_textfield_t* self);
+
+  ///
+  // Sets the contents to |text|. The cursor will be moved to end of the text if
+  // the current position is outside of the text range.
+  ///
+  void (CEF_CALLBACK *set_text)(struct _cef_textfield_t* self,
+      const cef_string_t* text);
+
+  ///
+  // Appends |text| to the previously-existing text.
+  ///
+  void (CEF_CALLBACK *append_text)(struct _cef_textfield_t* self,
+      const cef_string_t* text);
+
+  ///
+  // Inserts |text| at the current cursor position replacing any selected text.
+  ///
+  void (CEF_CALLBACK *insert_or_replace_text)(struct _cef_textfield_t* self,
+      const cef_string_t* text);
+
+  ///
+  // Returns true (1) if there is any selected text.
+  ///
+  int (CEF_CALLBACK *has_selection)(struct _cef_textfield_t* self);
+
+  ///
+  // Returns the currently selected text.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_selected_text)(
+      struct _cef_textfield_t* self);
+
+  ///
+  // Selects all text. If |reversed| is true (1) the range will end at the
+  // logical beginning of the text; this generally shows the leading portion of
+  // text that overflows its display area.
+  ///
+  void (CEF_CALLBACK *select_all)(struct _cef_textfield_t* self, int reversed);
+
+  ///
+  // Clears the text selection and sets the caret to the end.
+  ///
+  void (CEF_CALLBACK *clear_selection)(struct _cef_textfield_t* self);
+
+  ///
+  // Returns the selected logical text range.
+  ///
+  cef_range_t (CEF_CALLBACK *get_selected_range)(struct _cef_textfield_t* self);
+
+  ///
+  // Selects the specified logical text range.
+  ///
+  void (CEF_CALLBACK *select_range)(struct _cef_textfield_t* self,
+      const cef_range_t* range);
+
+  ///
+  // Returns the current cursor position.
+  ///
+  size_t (CEF_CALLBACK *get_cursor_position)(struct _cef_textfield_t* self);
+
+  ///
+  // Sets the text color.
+  ///
+  void (CEF_CALLBACK *set_text_color)(struct _cef_textfield_t* self,
+      cef_color_t color);
+
+  ///
+  // Returns the text color.
+  ///
+  cef_color_t (CEF_CALLBACK *get_text_color)(struct _cef_textfield_t* self);
+
+  ///
+  // Sets the selection text color.
+  ///
+  void (CEF_CALLBACK *set_selection_text_color)(struct _cef_textfield_t* self,
+      cef_color_t color);
+
+  ///
+  // Returns the selection text color.
+  ///
+  cef_color_t (CEF_CALLBACK *get_selection_text_color)(
+      struct _cef_textfield_t* self);
+
+  ///
+  // Sets the selection background color.
+  ///
+  void (CEF_CALLBACK *set_selection_background_color)(
+      struct _cef_textfield_t* self, cef_color_t color);
+
+  ///
+  // Returns the selection background color.
+  ///
+  cef_color_t (CEF_CALLBACK *get_selection_background_color)(
+      struct _cef_textfield_t* self);
+
+  ///
+  // Sets the font list. The format is "<FONT_FAMILY_LIST>,[STYLES] <SIZE>",
+  // where: - FONT_FAMILY_LIST is a comma-separated list of font family names, -
+  // STYLES is an optional space-separated list of style names (case-sensitive
+  //   "Bold" and "Italic" are supported), and
+  // - SIZE is an integer font size in pixels with the suffix "px".
+  //
+  // Here are examples of valid font description strings: - "Arial, Helvetica,
+  // Bold Italic 14px" - "Arial, 14px"
+  ///
+  void (CEF_CALLBACK *set_font_list)(struct _cef_textfield_t* self,
+      const cef_string_t* font_list);
+
+  ///
+  // Applies |color| to the specified |range| without changing the default
+  // color. If |range| is NULL the color will be set on the complete text
+  // contents.
+  ///
+  void (CEF_CALLBACK *apply_text_color)(struct _cef_textfield_t* self,
+      cef_color_t color, const cef_range_t* range);
+
+  ///
+  // Applies |style| to the specified |range| without changing the default
+  // style. If |add| is true (1) the style will be added, otherwise the style
+  // will be removed. If |range| is NULL the style will be set on the complete
+  // text contents.
+  ///
+  void (CEF_CALLBACK *apply_text_style)(struct _cef_textfield_t* self,
+      cef_text_style_t style, int add, const cef_range_t* range);
+
+  ///
+  // Returns true (1) if the action associated with the specified command id is
+  // enabled. See additional comments on execute_command().
+  ///
+  int (CEF_CALLBACK *is_command_enabled)(struct _cef_textfield_t* self,
+      int command_id);
+
+  ///
+  // Performs the action associated with the specified command id. Valid values
+  // include IDS_APP_UNDO, IDS_APP_REDO, IDS_APP_CUT, IDS_APP_COPY,
+  // IDS_APP_PASTE, IDS_APP_DELETE, IDS_APP_SELECT_ALL, IDS_DELETE_* and
+  // IDS_MOVE_*. See include/cef_pack_strings.h for definitions.
+  ///
+  void (CEF_CALLBACK *execute_command)(struct _cef_textfield_t* self,
+      int command_id);
+
+  ///
+  // Clears Edit history.
+  ///
+  void (CEF_CALLBACK *clear_edit_history)(struct _cef_textfield_t* self);
+
+  ///
+  // Sets the placeholder text that will be displayed when the Textfield is
+  // NULL.
+  ///
+  void (CEF_CALLBACK *set_placeholder_text)(struct _cef_textfield_t* self,
+      const cef_string_t* text);
+
+  ///
+  // Returns the placeholder text that will be displayed when the Textfield is
+  // NULL.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_placeholder_text)(
+      struct _cef_textfield_t* self);
+
+  ///
+  // Sets the placeholder text color.
+  ///
+  void (CEF_CALLBACK *set_placeholder_text_color)(struct _cef_textfield_t* self,
+      cef_color_t color);
+
+  ///
+  // Returns the placeholder text color.
+  ///
+  cef_color_t (CEF_CALLBACK *get_placeholder_text_color)(
+      struct _cef_textfield_t* self);
+
+  ///
+  // Set the accessible name that will be exposed to assistive technology (AT).
+  ///
+  void (CEF_CALLBACK *set_accessible_name)(struct _cef_textfield_t* self,
+      const cef_string_t* name);
+} cef_textfield_t;
+
+
+///
+// Create a new Textfield.
+///
+CEF_EXPORT cef_textfield_t* cef_textfield_create(
+    struct _cef_textfield_delegate_t* delegate);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_VIEWS_CEF_TEXTFIELD_CAPI_H_
diff --git a/src/include/libcef/capi/views/cef_textfield_delegate_capi.h b/src/include/libcef/capi/views/cef_textfield_delegate_capi.h
new file mode 100644
index 0000000..a229591
--- /dev/null
+++ b/src/include/libcef/capi/views/cef_textfield_delegate_capi.h
@@ -0,0 +1,82 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_VIEWS_CEF_TEXTFIELD_DELEGATE_CAPI_H_
+#define CEF_INCLUDE_CAPI_VIEWS_CEF_TEXTFIELD_DELEGATE_CAPI_H_
+#pragma once
+
+#include "libcef/capi/views/cef_view_delegate_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _cef_textfield_t;
+
+///
+// Implement this structure to handle Textfield events. The functions of this
+// structure will be called on the browser process UI thread unless otherwise
+// indicated.
+///
+typedef struct _cef_textfield_delegate_t {
+  ///
+  // Base structure.
+  ///
+  cef_view_delegate_t base;
+
+  ///
+  // Called when |textfield| recieves a keyboard event. |event| contains
+  // information about the keyboard event. Return true (1) if the keyboard event
+  // was handled or false (0) otherwise for default handling.
+  ///
+  int (CEF_CALLBACK *on_key_event)(struct _cef_textfield_delegate_t* self,
+      struct _cef_textfield_t* textfield,
+      const struct _cef_key_event_t* event);
+
+  ///
+  // Called after performing a user action that may change |textfield|.
+  ///
+  void (CEF_CALLBACK *on_after_user_action)(
+      struct _cef_textfield_delegate_t* self,
+      struct _cef_textfield_t* textfield);
+} cef_textfield_delegate_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_VIEWS_CEF_TEXTFIELD_DELEGATE_CAPI_H_
diff --git a/src/include/libcef/capi/views/cef_view_capi.h b/src/include/libcef/capi/views/cef_view_capi.h
new file mode 100644
index 0000000..a821a8b
--- /dev/null
+++ b/src/include/libcef/capi/views/cef_view_capi.h
@@ -0,0 +1,374 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_VIEWS_CEF_VIEW_CAPI_H_
+#define CEF_INCLUDE_CAPI_VIEWS_CEF_VIEW_CAPI_H_
+#pragma once
+
+#include "libcef/capi/views/cef_view_delegate_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _cef_browser_view_t;
+struct _cef_button_t;
+struct _cef_panel_t;
+struct _cef_scroll_view_t;
+struct _cef_textfield_t;
+struct _cef_window_t;
+
+///
+// A View is a rectangle within the views View hierarchy. It is the base
+// structure for all Views. All size and position values are in density
+// independent pixels (DIP) unless otherwise indicated. Methods must be called
+// on the browser process UI thread unless otherwise indicated.
+///
+typedef struct _cef_view_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns this View as a BrowserView or NULL if this is not a BrowserView.
+  ///
+  struct _cef_browser_view_t* (CEF_CALLBACK *as_browser_view)(
+      struct _cef_view_t* self);
+
+  ///
+  // Returns this View as a Button or NULL if this is not a Button.
+  ///
+  struct _cef_button_t* (CEF_CALLBACK *as_button)(struct _cef_view_t* self);
+
+  ///
+  // Returns this View as a Panel or NULL if this is not a Panel.
+  ///
+  struct _cef_panel_t* (CEF_CALLBACK *as_panel)(struct _cef_view_t* self);
+
+  ///
+  // Returns this View as a ScrollView or NULL if this is not a ScrollView.
+  ///
+  struct _cef_scroll_view_t* (CEF_CALLBACK *as_scroll_view)(
+      struct _cef_view_t* self);
+
+  ///
+  // Returns this View as a Textfield or NULL if this is not a Textfield.
+  ///
+  struct _cef_textfield_t* (CEF_CALLBACK *as_textfield)(
+      struct _cef_view_t* self);
+
+  ///
+  // Returns the type of this View as a string. Used primarily for testing
+  // purposes.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_type_string)(
+      struct _cef_view_t* self);
+
+  ///
+  // Returns a string representation of this View which includes the type and
+  // various type-specific identifying attributes. If |include_children| is true
+  // (1) any child Views will also be included. Used primarily for testing
+  // purposes.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *to_string)(struct _cef_view_t* self,
+      int include_children);
+
+  ///
+  // Returns true (1) if this View is valid.
+  ///
+  int (CEF_CALLBACK *is_valid)(struct _cef_view_t* self);
+
+  ///
+  // Returns true (1) if this View is currently attached to another View. A View
+  // can only be attached to one View at a time.
+  ///
+  int (CEF_CALLBACK *is_attached)(struct _cef_view_t* self);
+
+  ///
+  // Returns true (1) if this View is the same as |that| View.
+  ///
+  int (CEF_CALLBACK *is_same)(struct _cef_view_t* self,
+      struct _cef_view_t* that);
+
+  ///
+  // Returns the delegate associated with this View, if any.
+  ///
+  struct _cef_view_delegate_t* (CEF_CALLBACK *get_delegate)(
+      struct _cef_view_t* self);
+
+  ///
+  // Returns the top-level Window hosting this View, if any.
+  ///
+  struct _cef_window_t* (CEF_CALLBACK *get_window)(struct _cef_view_t* self);
+
+  ///
+  // Returns the ID for this View.
+  ///
+  int (CEF_CALLBACK *get_id)(struct _cef_view_t* self);
+
+  ///
+  // Sets the ID for this View. ID should be unique within the subtree that you
+  // intend to search for it. 0 is the default ID for views.
+  ///
+  void (CEF_CALLBACK *set_id)(struct _cef_view_t* self, int id);
+
+  ///
+  // Returns the View that contains this View, if any.
+  ///
+  struct _cef_view_t* (CEF_CALLBACK *get_parent_view)(struct _cef_view_t* self);
+
+  ///
+  // Recursively descends the view tree starting at this View, and returns the
+  // first child that it encounters with the given ID. Returns NULL if no
+  // matching child view is found.
+  ///
+  struct _cef_view_t* (CEF_CALLBACK *get_view_for_id)(struct _cef_view_t* self,
+      int id);
+
+  ///
+  // Sets the bounds (size and position) of this View. Position is in parent
+  // coordinates.
+  ///
+  void (CEF_CALLBACK *set_bounds)(struct _cef_view_t* self,
+      const cef_rect_t* bounds);
+
+  ///
+  // Returns the bounds (size and position) of this View. Position is in parent
+  // coordinates.
+  ///
+  cef_rect_t (CEF_CALLBACK *get_bounds)(struct _cef_view_t* self);
+
+  ///
+  // Returns the bounds (size and position) of this View. Position is in screen
+  // coordinates.
+  ///
+  cef_rect_t (CEF_CALLBACK *get_bounds_in_screen)(struct _cef_view_t* self);
+
+  ///
+  // Sets the size of this View without changing the position.
+  ///
+  void (CEF_CALLBACK *set_size)(struct _cef_view_t* self,
+      const cef_size_t* size);
+
+  ///
+  // Returns the size of this View.
+  ///
+  cef_size_t (CEF_CALLBACK *get_size)(struct _cef_view_t* self);
+
+  ///
+  // Sets the position of this View without changing the size. |position| is in
+  // parent coordinates.
+  ///
+  void (CEF_CALLBACK *set_position)(struct _cef_view_t* self,
+      const cef_point_t* position);
+
+  ///
+  // Returns the position of this View. Position is in parent coordinates.
+  ///
+  cef_point_t (CEF_CALLBACK *get_position)(struct _cef_view_t* self);
+
+  ///
+  // Returns the size this View would like to be if enough space is available.
+  ///
+  cef_size_t (CEF_CALLBACK *get_preferred_size)(struct _cef_view_t* self);
+
+  ///
+  // Size this View to its preferred size.
+  ///
+  void (CEF_CALLBACK *size_to_preferred_size)(struct _cef_view_t* self);
+
+  ///
+  // Returns the minimum size for this View.
+  ///
+  cef_size_t (CEF_CALLBACK *get_minimum_size)(struct _cef_view_t* self);
+
+  ///
+  // Returns the maximum size for this View.
+  ///
+  cef_size_t (CEF_CALLBACK *get_maximum_size)(struct _cef_view_t* self);
+
+  ///
+  // Returns the height necessary to display this View with the provided width.
+  ///
+  int (CEF_CALLBACK *get_height_for_width)(struct _cef_view_t* self, int width);
+
+  ///
+  // Indicate that this View and all parent Views require a re-layout. This
+  // ensures the next call to layout() will propagate to this View even if the
+  // bounds of parent Views do not change.
+  ///
+  void (CEF_CALLBACK *invalidate_layout)(struct _cef_view_t* self);
+
+  ///
+  // Sets whether this View is visible. Windows are hidden by default and other
+  // views are visible by default. This View and any parent views must be set as
+  // visible for this View to be drawn in a Window. If this View is set as
+  // hidden then it and any child views will not be drawn and, if any of those
+  // views currently have focus, then focus will also be cleared. Painting is
+  // scheduled as needed. If this View is a Window then calling this function is
+  // equivalent to calling the Window show() and hide() functions.
+  ///
+  void (CEF_CALLBACK *set_visible)(struct _cef_view_t* self, int visible);
+
+  ///
+  // Returns whether this View is visible. A view may be visible but still not
+  // drawn in a Window if any parent views are hidden. If this View is a Window
+  // then a return value of true (1) indicates that this Window is currently
+  // visible to the user on-screen. If this View is not a Window then call
+  // is_drawn() to determine whether this View and all parent views are visible
+  // and will be drawn.
+  ///
+  int (CEF_CALLBACK *is_visible)(struct _cef_view_t* self);
+
+  ///
+  // Returns whether this View is visible and drawn in a Window. A view is drawn
+  // if it and all parent views are visible. If this View is a Window then
+  // calling this function is equivalent to calling is_visible(). Otherwise, to
+  // determine if the containing Window is visible to the user on-screen call
+  // is_visible() on the Window.
+  ///
+  int (CEF_CALLBACK *is_drawn)(struct _cef_view_t* self);
+
+  ///
+  // Set whether this View is enabled. A disabled View does not receive keyboard
+  // or mouse inputs. If |enabled| differs from the current value the View will
+  // be repainted. Also, clears focus if the focused View is disabled.
+  ///
+  void (CEF_CALLBACK *set_enabled)(struct _cef_view_t* self, int enabled);
+
+  ///
+  // Returns whether this View is enabled.
+  ///
+  int (CEF_CALLBACK *is_enabled)(struct _cef_view_t* self);
+
+  ///
+  // Sets whether this View is capable of taking focus. It will clear focus if
+  // the focused View is set to be non-focusable. This is false (0) by default
+  // so that a View used as a container does not get the focus.
+  ///
+  void (CEF_CALLBACK *set_focusable)(struct _cef_view_t* self, int focusable);
+
+  ///
+  // Returns true (1) if this View is focusable, enabled and drawn.
+  ///
+  int (CEF_CALLBACK *is_focusable)(struct _cef_view_t* self);
+
+  ///
+  // Return whether this View is focusable when the user requires full keyboard
+  // access, even though it may not be normally focusable.
+  ///
+  int (CEF_CALLBACK *is_accessibility_focusable)(struct _cef_view_t* self);
+
+  ///
+  // Request keyboard focus. If this View is focusable it will become the
+  // focused View.
+  ///
+  void (CEF_CALLBACK *request_focus)(struct _cef_view_t* self);
+
+  ///
+  // Sets the background color for this View.
+  ///
+  void (CEF_CALLBACK *set_background_color)(struct _cef_view_t* self,
+      cef_color_t color);
+
+  ///
+  // Returns the background color for this View.
+  ///
+  cef_color_t (CEF_CALLBACK *get_background_color)(struct _cef_view_t* self);
+
+  ///
+  // Convert |point| from this View's coordinate system to that of the screen.
+  // This View must belong to a Window when calling this function. Returns true
+  // (1) if the conversion is successful or false (0) otherwise. Use
+  // cef_display_t::convert_point_to_pixels() after calling this function if
+  // further conversion to display-specific pixel coordinates is desired.
+  ///
+  int (CEF_CALLBACK *convert_point_to_screen)(struct _cef_view_t* self,
+      cef_point_t* point);
+
+  ///
+  // Convert |point| to this View's coordinate system from that of the screen.
+  // This View must belong to a Window when calling this function. Returns true
+  // (1) if the conversion is successful or false (0) otherwise. Use
+  // cef_display_t::convert_point_from_pixels() before calling this function if
+  // conversion from display-specific pixel coordinates is necessary.
+  ///
+  int (CEF_CALLBACK *convert_point_from_screen)(struct _cef_view_t* self,
+      cef_point_t* point);
+
+  ///
+  // Convert |point| from this View's coordinate system to that of the Window.
+  // This View must belong to a Window when calling this function. Returns true
+  // (1) if the conversion is successful or false (0) otherwise.
+  ///
+  int (CEF_CALLBACK *convert_point_to_window)(struct _cef_view_t* self,
+      cef_point_t* point);
+
+  ///
+  // Convert |point| to this View's coordinate system from that of the Window.
+  // This View must belong to a Window when calling this function. Returns true
+  // (1) if the conversion is successful or false (0) otherwise.
+  ///
+  int (CEF_CALLBACK *convert_point_from_window)(struct _cef_view_t* self,
+      cef_point_t* point);
+
+  ///
+  // Convert |point| from this View's coordinate system to that of |view|.
+  // |view| needs to be in the same Window but not necessarily the same view
+  // hierarchy. Returns true (1) if the conversion is successful or false (0)
+  // otherwise.
+  ///
+  int (CEF_CALLBACK *convert_point_to_view)(struct _cef_view_t* self,
+      struct _cef_view_t* view, cef_point_t* point);
+
+  ///
+  // Convert |point| to this View's coordinate system from that |view|. |view|
+  // needs to be in the same Window but not necessarily the same view hierarchy.
+  // Returns true (1) if the conversion is successful or false (0) otherwise.
+  ///
+  int (CEF_CALLBACK *convert_point_from_view)(struct _cef_view_t* self,
+      struct _cef_view_t* view, cef_point_t* point);
+} cef_view_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_VIEWS_CEF_VIEW_CAPI_H_
diff --git a/src/include/libcef/capi/views/cef_view_delegate_capi.h b/src/include/libcef/capi/views/cef_view_delegate_capi.h
new file mode 100644
index 0000000..851cf7c
--- /dev/null
+++ b/src/include/libcef/capi/views/cef_view_delegate_capi.h
@@ -0,0 +1,115 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_VIEWS_CEF_VIEW_DELEGATE_CAPI_H_
+#define CEF_INCLUDE_CAPI_VIEWS_CEF_VIEW_DELEGATE_CAPI_H_
+#pragma once
+
+#include "libcef/capi/cef_base_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _cef_view_t;
+
+///
+// Implement this structure to handle view events. The functions of this
+// structure will be called on the browser process UI thread unless otherwise
+// indicated.
+///
+typedef struct _cef_view_delegate_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Return the preferred size for |view|. The Layout will use this information
+  // to determine the display size.
+  ///
+  cef_size_t (CEF_CALLBACK *get_preferred_size)(
+      struct _cef_view_delegate_t* self, struct _cef_view_t* view);
+
+  ///
+  // Return the minimum size for |view|.
+  ///
+  cef_size_t (CEF_CALLBACK *get_minimum_size)(struct _cef_view_delegate_t* self,
+      struct _cef_view_t* view);
+
+  ///
+  // Return the maximum size for |view|.
+  ///
+  cef_size_t (CEF_CALLBACK *get_maximum_size)(struct _cef_view_delegate_t* self,
+      struct _cef_view_t* view);
+
+  ///
+  // Return the height necessary to display |view| with the provided |width|. If
+  // not specified the result of get_preferred_size().height will be used by
+  // default. Override if |view|'s preferred height depends upon the width (for
+  // example, with Labels).
+  ///
+  int (CEF_CALLBACK *get_height_for_width)(struct _cef_view_delegate_t* self,
+      struct _cef_view_t* view, int width);
+
+  ///
+  // Called when the parent of |view| has changed. If |view| is being added to
+  // |parent| then |added| will be true (1). If |view| is being removed from
+  // |parent| then |added| will be false (0). If |view| is being reparented the
+  // remove notification will be sent before the add notification. Do not modify
+  // the view hierarchy in this callback.
+  ///
+  void (CEF_CALLBACK *on_parent_view_changed)(struct _cef_view_delegate_t* self,
+      struct _cef_view_t* view, int added, struct _cef_view_t* parent);
+
+  ///
+  // Called when a child of |view| has changed. If |child| is being added to
+  // |view| then |added| will be true (1). If |child| is being removed from
+  // |view| then |added| will be false (0). If |child| is being reparented the
+  // remove notification will be sent to the old parent before the add
+  // notification is sent to the new parent. Do not modify the view hierarchy in
+  // this callback.
+  ///
+  void (CEF_CALLBACK *on_child_view_changed)(struct _cef_view_delegate_t* self,
+      struct _cef_view_t* view, int added, struct _cef_view_t* child);
+} cef_view_delegate_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_VIEWS_CEF_VIEW_DELEGATE_CAPI_H_
diff --git a/src/include/libcef/capi/views/cef_window_capi.h b/src/include/libcef/capi/views/cef_window_capi.h
new file mode 100644
index 0000000..3d887d4
--- /dev/null
+++ b/src/include/libcef/capi/views/cef_window_capi.h
@@ -0,0 +1,286 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_VIEWS_CEF_WINDOW_CAPI_H_
+#define CEF_INCLUDE_CAPI_VIEWS_CEF_WINDOW_CAPI_H_
+#pragma once
+
+#include "libcef/capi/cef_image_capi.h"
+#include "libcef/capi/cef_menu_model_capi.h"
+#include "libcef/capi/views/cef_display_capi.h"
+#include "libcef/capi/views/cef_panel_capi.h"
+#include "libcef/capi/views/cef_window_delegate_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// A Window is a top-level Window/widget in the Views hierarchy. By default it
+// will have a non-client area with title bar, icon and buttons that supports
+// moving and resizing. All size and position values are in density independent
+// pixels (DIP) unless otherwise indicated. Methods must be called on the
+// browser process UI thread unless otherwise indicated.
+///
+typedef struct _cef_window_t {
+  ///
+  // Base structure.
+  ///
+  cef_panel_t base;
+
+  ///
+  // Show the Window.
+  ///
+  void (CEF_CALLBACK *show)(struct _cef_window_t* self);
+
+  ///
+  // Hide the Window.
+  ///
+  void (CEF_CALLBACK *hide)(struct _cef_window_t* self);
+
+  ///
+  // Sizes the Window to |size| and centers it in the current display.
+  ///
+  void (CEF_CALLBACK *center_window)(struct _cef_window_t* self,
+      const cef_size_t* size);
+
+  ///
+  // Close the Window.
+  ///
+  void (CEF_CALLBACK *close)(struct _cef_window_t* self);
+
+  ///
+  // Returns true (1) if the Window has been closed.
+  ///
+  int (CEF_CALLBACK *is_closed)(struct _cef_window_t* self);
+
+  ///
+  // Activate the Window, assuming it already exists and is visible.
+  ///
+  void (CEF_CALLBACK *activate)(struct _cef_window_t* self);
+
+  ///
+  // Deactivate the Window, making the next Window in the Z order the active
+  // Window.
+  ///
+  void (CEF_CALLBACK *deactivate)(struct _cef_window_t* self);
+
+  ///
+  // Returns whether the Window is the currently active Window.
+  ///
+  int (CEF_CALLBACK *is_active)(struct _cef_window_t* self);
+
+  ///
+  // Bring this Window to the top of other Windows in the Windowing system.
+  ///
+  void (CEF_CALLBACK *bring_to_top)(struct _cef_window_t* self);
+
+  ///
+  // Set the Window to be on top of other Windows in the Windowing system.
+  ///
+  void (CEF_CALLBACK *set_always_on_top)(struct _cef_window_t* self,
+      int on_top);
+
+  ///
+  // Returns whether the Window has been set to be on top of other Windows in
+  // the Windowing system.
+  ///
+  int (CEF_CALLBACK *is_always_on_top)(struct _cef_window_t* self);
+
+  ///
+  // Maximize the Window.
+  ///
+  void (CEF_CALLBACK *maximize)(struct _cef_window_t* self);
+
+  ///
+  // Minimize the Window.
+  ///
+  void (CEF_CALLBACK *minimize)(struct _cef_window_t* self);
+
+  ///
+  // Restore the Window.
+  ///
+  void (CEF_CALLBACK *restore)(struct _cef_window_t* self);
+
+  ///
+  // Set fullscreen Window state.
+  ///
+  void (CEF_CALLBACK *set_fullscreen)(struct _cef_window_t* self,
+      int fullscreen);
+
+  ///
+  // Returns true (1) if the Window is maximized.
+  ///
+  int (CEF_CALLBACK *is_maximized)(struct _cef_window_t* self);
+
+  ///
+  // Returns true (1) if the Window is minimized.
+  ///
+  int (CEF_CALLBACK *is_minimized)(struct _cef_window_t* self);
+
+  ///
+  // Returns true (1) if the Window is fullscreen.
+  ///
+  int (CEF_CALLBACK *is_fullscreen)(struct _cef_window_t* self);
+
+  ///
+  // Set the Window title.
+  ///
+  void (CEF_CALLBACK *set_title)(struct _cef_window_t* self,
+      const cef_string_t* title);
+
+  ///
+  // Get the Window title.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_title)(struct _cef_window_t* self);
+
+  ///
+  // Set the Window icon. This should be a 16x16 icon suitable for use in the
+  // Windows's title bar.
+  ///
+  void (CEF_CALLBACK *set_window_icon)(struct _cef_window_t* self,
+      struct _cef_image_t* image);
+
+  ///
+  // Get the Window icon.
+  ///
+  struct _cef_image_t* (CEF_CALLBACK *get_window_icon)(
+      struct _cef_window_t* self);
+
+  ///
+  // Set the Window App icon. This should be a larger icon for use in the host
+  // environment app switching UI. On Windows, this is the ICON_BIG used in Alt-
+  // Tab list and Windows taskbar. The Window icon will be used by default if no
+  // Window App icon is specified.
+  ///
+  void (CEF_CALLBACK *set_window_app_icon)(struct _cef_window_t* self,
+      struct _cef_image_t* image);
+
+  ///
+  // Get the Window App icon.
+  ///
+  struct _cef_image_t* (CEF_CALLBACK *get_window_app_icon)(
+      struct _cef_window_t* self);
+
+  ///
+  // Show a menu with contents |menu_model|. |screen_point| specifies the menu
+  // position in screen coordinates. |anchor_position| specifies how the menu
+  // will be anchored relative to |screen_point|.
+  ///
+  void (CEF_CALLBACK *show_menu)(struct _cef_window_t* self,
+      struct _cef_menu_model_t* menu_model, const cef_point_t* screen_point,
+      cef_menu_anchor_position_t anchor_position);
+
+  ///
+  // Cancel the menu that is currently showing, if any.
+  ///
+  void (CEF_CALLBACK *cancel_menu)(struct _cef_window_t* self);
+
+  ///
+  // Returns the Display that most closely intersects the bounds of this Window.
+  // May return NULL if this Window is not currently displayed.
+  ///
+  struct _cef_display_t* (CEF_CALLBACK *get_display)(
+      struct _cef_window_t* self);
+
+  ///
+  // Returns the bounds (size and position) of this Window's client area.
+  // Position is in screen coordinates.
+  ///
+  cef_rect_t (CEF_CALLBACK *get_client_area_bounds_in_screen)(
+      struct _cef_window_t* self);
+
+  ///
+  // Set the regions where mouse events will be intercepted by this Window to
+  // support drag operations. Call this function with an NULL vector to clear
+  // the draggable regions. The draggable region bounds should be in window
+  // coordinates.
+  ///
+  void (CEF_CALLBACK *set_draggable_regions)(struct _cef_window_t* self,
+      size_t regionsCount, cef_draggable_region_t const* regions);
+
+  ///
+  // Retrieve the platform window handle for this Window.
+  ///
+  cef_window_handle_t (CEF_CALLBACK *get_window_handle)(
+      struct _cef_window_t* self);
+
+  ///
+  // Simulate a key press. |key_code| is the VKEY_* value from Chromium's
+  // ui/events/keycodes/keyboard_codes.h header (VK_* values on Windows).
+  // |event_flags| is some combination of EVENTFLAG_SHIFT_DOWN,
+  // EVENTFLAG_CONTROL_DOWN and/or EVENTFLAG_ALT_DOWN. This function is exposed
+  // primarily for testing purposes.
+  ///
+  void (CEF_CALLBACK *send_key_press)(struct _cef_window_t* self, int key_code,
+      uint32 event_flags);
+
+  ///
+  // Simulate a mouse move. The mouse cursor will be moved to the specified
+  // (screen_x, screen_y) position. This function is exposed primarily for
+  // testing purposes.
+  ///
+  void (CEF_CALLBACK *send_mouse_move)(struct _cef_window_t* self, int screen_x,
+      int screen_y);
+
+  ///
+  // Simulate mouse down and/or mouse up events. |button| is the mouse button
+  // type. If |mouse_down| is true (1) a mouse down event will be sent. If
+  // |mouse_up| is true (1) a mouse up event will be sent. If both are true (1)
+  // a mouse down event will be sent followed by a mouse up event (equivalent to
+  // clicking the mouse button). The events will be sent using the current
+  // cursor position so make sure to call send_mouse_move() first to position
+  // the mouse. This function is exposed primarily for testing purposes.
+  ///
+  void (CEF_CALLBACK *send_mouse_events)(struct _cef_window_t* self,
+      cef_mouse_button_type_t button, int mouse_down, int mouse_up);
+} cef_window_t;
+
+
+///
+// Create a new Window.
+///
+CEF_EXPORT cef_window_t* cef_window_create_top_level(
+    struct _cef_window_delegate_t* delegate);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_VIEWS_CEF_WINDOW_CAPI_H_
diff --git a/src/include/libcef/capi/views/cef_window_delegate_capi.h b/src/include/libcef/capi/views/cef_window_delegate_capi.h
new file mode 100644
index 0000000..c9d31e1
--- /dev/null
+++ b/src/include/libcef/capi/views/cef_window_delegate_capi.h
@@ -0,0 +1,113 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_VIEWS_CEF_WINDOW_DELEGATE_CAPI_H_
+#define CEF_INCLUDE_CAPI_VIEWS_CEF_WINDOW_DELEGATE_CAPI_H_
+#pragma once
+
+#include "libcef/capi/views/cef_panel_delegate_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _cef_window_t;
+
+///
+// Implement this structure to handle window events. The functions of this
+// structure will be called on the browser process UI thread unless otherwise
+// indicated.
+///
+typedef struct _cef_window_delegate_t {
+  ///
+  // Base structure.
+  ///
+  cef_panel_delegate_t base;
+
+  ///
+  // Called when |window| is created.
+  ///
+  void (CEF_CALLBACK *on_window_created)(struct _cef_window_delegate_t* self,
+      struct _cef_window_t* window);
+
+  ///
+  // Called when |window| is destroyed. Release all references to |window| and
+  // do not attempt to execute any functions on |window| after this callback
+  // returns.
+  ///
+  void (CEF_CALLBACK *on_window_destroyed)(struct _cef_window_delegate_t* self,
+      struct _cef_window_t* window);
+
+  ///
+  // Return true (1) if |window| should be created without a frame or title bar.
+  // The window will be resizable if can_resize() returns true (1). Use
+  // cef_window_t::set_draggable_regions() to specify draggable regions.
+  ///
+  int (CEF_CALLBACK *is_frameless)(struct _cef_window_delegate_t* self,
+      struct _cef_window_t* window);
+
+  ///
+  // Return true (1) if |window| can be resized.
+  ///
+  int (CEF_CALLBACK *can_resize)(struct _cef_window_delegate_t* self,
+      struct _cef_window_t* window);
+
+  ///
+  // Return true (1) if |window| can be maximized.
+  ///
+  int (CEF_CALLBACK *can_maximize)(struct _cef_window_delegate_t* self,
+      struct _cef_window_t* window);
+
+  ///
+  // Return true (1) if |window| can be minimized.
+  ///
+  int (CEF_CALLBACK *can_minimize)(struct _cef_window_delegate_t* self,
+      struct _cef_window_t* window);
+
+  ///
+  // Return true (1) if |window| can be closed. This will be called for user-
+  // initiated window close actions and when cef_window_t::close() is called.
+  ///
+  int (CEF_CALLBACK *can_close)(struct _cef_window_delegate_t* self,
+      struct _cef_window_t* window);
+} cef_window_delegate_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_VIEWS_CEF_WINDOW_DELEGATE_CAPI_H_
diff --git a/src/include/libcef/cef_app.h b/src/include/libcef/cef_app.h
new file mode 100644
index 0000000..03f31f5
--- /dev/null
+++ b/src/include/libcef/cef_app.h
@@ -0,0 +1,200 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+
+#ifndef CEF_INCLUDE_CEF_APP_H_
+#define CEF_INCLUDE_CEF_APP_H_
+#pragma once
+
+#include "include/cef_base.h"
+#include "include/cef_browser_process_handler.h"
+#include "include/cef_command_line.h"
+#include "include/cef_render_process_handler.h"
+#include "include/cef_resource_bundle_handler.h"
+#include "include/cef_scheme.h"
+
+class CefApp;
+
+///
+// This function should be called from the application entry point function to
+// execute a secondary process. It can be used to run secondary processes from
+// the browser client executable (default behavior) or from a separate
+// executable specified by the CefSettings.browser_subprocess_path value. If
+// called for the browser process (identified by no "type" command-line value)
+// it will return immediately with a value of -1. If called for a recognized
+// secondary process it will block until the process should exit and then return
+// the process exit code. The |application| parameter may be empty. The
+// |windows_sandbox_info| parameter is only used on Windows and may be NULL (see
+// cef_sandbox_win.h for details).
+///
+/*--cef(api_hash_check,optional_param=application,
+        optional_param=windows_sandbox_info)--*/
+int CefExecuteProcess(const CefMainArgs& args,
+                      CefRefPtr<CefApp> application,
+                      void* windows_sandbox_info);
+
+///
+// This function should be called on the main application thread to initialize
+// the CEF browser process. The |application| parameter may be empty. A return
+// value of true indicates that it succeeded and false indicates that it failed.
+// The |windows_sandbox_info| parameter is only used on Windows and may be NULL
+// (see cef_sandbox_win.h for details).
+///
+/*--cef(api_hash_check,optional_param=application,
+        optional_param=windows_sandbox_info)--*/
+bool CefInitialize(const CefMainArgs& args,
+                   const CefSettings& settings,
+                   CefRefPtr<CefApp> application,
+                   void* windows_sandbox_info);
+
+///
+// This function should be called on the main application thread to shut down
+// the CEF browser process before the application exits.
+///
+/*--cef()--*/
+void CefShutdown();
+
+///
+// Perform a single iteration of CEF message loop processing. This function is
+// used to integrate the CEF message loop into an existing application message
+// loop. Care must be taken to balance performance against excessive CPU usage.
+// This function should only be called on the main application thread and only
+// if CefInitialize() is called with a CefSettings.multi_threaded_message_loop
+// value of false. This function will not block.
+///
+/*--cef()--*/
+void CefDoMessageLoopWork();
+
+///
+// Run the CEF message loop. Use this function instead of an application-
+// provided message loop to get the best balance between performance and CPU
+// usage. This function should only be called on the main application thread and
+// only if CefInitialize() is called with a
+// CefSettings.multi_threaded_message_loop value of false. This function will
+// block until a quit message is received by the system.
+///
+/*--cef()--*/
+void CefRunMessageLoop();
+
+///
+// Quit the CEF message loop that was started by calling CefRunMessageLoop().
+// This function should only be called on the main application thread and only
+// if CefRunMessageLoop() was used.
+///
+/*--cef()--*/
+void CefQuitMessageLoop();
+
+///
+// Set to true before calling Windows APIs like TrackPopupMenu that enter a
+// modal message loop. Set to false after exiting the modal message loop.
+///
+/*--cef()--*/
+void CefSetOSModalLoop(bool osModalLoop);
+
+///
+// Call during process startup to enable High-DPI support on Windows 7 or newer.
+// Older versions of Windows should be left DPI-unaware because they do not
+// support DirectWrite and GDI fonts are kerned very badly.
+///
+/*--cef(capi_name=cef_enable_highdpi_support)--*/
+void CefEnableHighDPISupport();
+
+///
+// Implement this interface to provide handler implementations. Methods will be
+// called by the process and/or thread indicated.
+///
+/*--cef(source=client,no_debugct_check)--*/
+class CefApp : public virtual CefBase {
+ public:
+  ///
+  // Provides an opportunity to view and/or modify command-line arguments before
+  // processing by CEF and Chromium. The |process_type| value will be empty for
+  // the browser process. Do not keep a reference to the CefCommandLine object
+  // passed to this method. The CefSettings.command_line_args_disabled value
+  // can be used to start with an empty command-line object. Any values
+  // specified in CefSettings that equate to command-line arguments will be set
+  // before this method is called. Be cautious when using this method to modify
+  // command-line arguments for non-browser processes as this may result in
+  // undefined behavior including crashes.
+  ///
+  /*--cef(optional_param=process_type)--*/
+  virtual void OnBeforeCommandLineProcessing(
+      const CefString& process_type,
+      CefRefPtr<CefCommandLine> command_line) {
+  }
+
+  ///
+  // Provides an opportunity to register custom schemes. Do not keep a reference
+  // to the |registrar| object. This method is called on the main thread for
+  // each process and the registered schemes should be the same across all
+  // processes.
+  ///
+  /*--cef()--*/
+  virtual void OnRegisterCustomSchemes(
+      CefRefPtr<CefSchemeRegistrar> registrar) {
+  }
+
+  ///
+  // Return the handler for resource bundle events. If
+  // CefSettings.pack_loading_disabled is true a handler must be returned. If no
+  // handler is returned resources will be loaded from pack files. This method
+  // is called by the browser and render processes on multiple threads.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefResourceBundleHandler> GetResourceBundleHandler() {
+    return NULL;
+  }
+
+  ///
+  // Return the handler for functionality specific to the browser process. This
+  // method is called on multiple threads in the browser process.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefBrowserProcessHandler> GetBrowserProcessHandler() {
+    return NULL;
+  }
+
+  ///
+  // Return the handler for functionality specific to the render process. This
+  // method is called on the render process main thread.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefRenderProcessHandler> GetRenderProcessHandler() {
+    return NULL;
+  }
+};
+
+#endif  // CEF_INCLUDE_CEF_APP_H_
diff --git a/src/include/libcef/cef_auth_callback.h b/src/include/libcef/cef_auth_callback.h
new file mode 100644
index 0000000..86d249a
--- /dev/null
+++ b/src/include/libcef/cef_auth_callback.h
@@ -0,0 +1,64 @@
+// Copyright (c) 2013 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_AUTH_CALLBACK_H_
+#define CEF_INCLUDE_CEF_AUTH_CALLBACK_H_
+#pragma once
+
+#include "include/cef_base.h"
+
+///
+// Callback interface used for asynchronous continuation of authentication
+// requests.
+///
+/*--cef(source=library)--*/
+class CefAuthCallback : public virtual CefBase {
+ public:
+  ///
+  // Continue the authentication request.
+  ///
+  /*--cef(capi_name=cont)--*/
+  virtual void Continue(const CefString& username,
+                        const CefString& password) =0;
+
+  ///
+  // Cancel the authentication request.
+  ///
+  /*--cef()--*/
+  virtual void Cancel() =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_AUTH_CALLBACK_H_
diff --git a/src/include/libcef/cef_base.h b/src/include/libcef/cef_base.h
new file mode 100644
index 0000000..c921358
--- /dev/null
+++ b/src/include/libcef/cef_base.h
@@ -0,0 +1,180 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+#ifndef CEF_INCLUDE_CEF_BASE_H_
+#define CEF_INCLUDE_CEF_BASE_H_
+#pragma once
+
+#include "include/base/cef_atomic_ref_count.h"
+#include "include/base/cef_build.h"
+#include "include/base/cef_macros.h"
+
+// Bring in common C++ type definitions used by CEF consumers.
+#include "include/internal/cef_ptr.h"
+#include "include/internal/cef_types_wrappers.h"
+#if defined(OS_WIN)
+#include "include/internal/cef_win.h"
+#elif defined(OS_MACOSX)
+#include "include/internal/cef_mac.h"
+#elif defined(OS_LINUX)
+#include "include/internal/cef_linux.h"
+#endif
+
+///
+// Interface defining the reference count implementation methods. All framework
+// classes must extend the CefBase class.
+///
+class CefBase {
+ public:
+  ///
+  // Called to increment the reference count for the object. Should be called
+  // for every new copy of a pointer to a given object.
+  ///
+  virtual void AddRef() const =0;
+
+  ///
+  // Called to decrement the reference count for the object. Returns true if
+  // the reference count is 0, in which case the object should self-delete.
+  ///
+  virtual bool Release() const =0;
+
+  ///
+  // Returns true if the reference count is 1.
+  ///
+  virtual bool HasOneRef() const =0;
+
+ protected:
+  virtual ~CefBase() {}
+};
+
+///
+// Class that implements atomic reference counting.
+///
+class CefRefCount {
+ public:
+  CefRefCount() : ref_count_(0) {}
+
+  ///
+  // Increment the reference count.
+  ///
+  void AddRef() const {
+    base::AtomicRefCountInc(&ref_count_); 
+  }
+
+  ///
+  // Decrement the reference count. Returns true if the reference count is 0.
+  ///
+  bool Release() const {
+    return !base::AtomicRefCountDec(&ref_count_);
+  }
+
+  ///
+  // Returns true if the reference count is 1.
+  ///
+  bool HasOneRef() const {
+    return base::AtomicRefCountIsOne(&ref_count_);
+  }
+
+ private:
+  mutable base::AtomicRefCount ref_count_;
+  DISALLOW_COPY_AND_ASSIGN(CefRefCount);
+};
+
+///
+// Macro that provides a reference counting implementation for classes extending
+// CefBase.
+///
+#define IMPLEMENT_REFCOUNTING(ClassName)            \
+  public:                                           \
+    void AddRef() const OVERRIDE {                  \
+      ref_count_.AddRef();                          \
+    }                                               \
+    bool Release() const OVERRIDE {                 \
+      if (ref_count_.Release()) {                   \
+        delete static_cast<const ClassName*>(this); \
+        return true;                                \
+      }                                             \
+      return false;                                 \
+    }                                               \
+    bool HasOneRef() const OVERRIDE {               \
+      return ref_count_.HasOneRef();                \
+    }                                               \
+  private:                                          \
+    CefRefCount ref_count_;
+
+///
+// Macro that provides a locking implementation. Use the Lock() and Unlock()
+// methods to protect a section of code from simultaneous access by multiple
+// threads. The AutoLock class is a helper that will hold the lock while in
+// scope.
+//
+// THIS MACRO IS DEPRECATED. Use an explicit base::Lock member variable and
+// base::AutoLock instead. For example:
+//
+// #include "include/base/cef_lock.h"
+//
+// // Class declaration.
+// class MyClass : public CefBase {
+//  public:
+//   MyClass() : value_(0) {}
+//   // Method that may be called on multiple threads.
+//   void IncrementValue();
+//  private:
+//   // Value that may be accessed on multiple theads.
+//   int value_;
+//   // Lock used to protect access to |value_|.
+//   base::Lock lock_;
+//   IMPLEMENT_REFCOUNTING(MyClass);
+// };
+//
+// // Class implementation.
+// void MyClass::IncrementValue() {
+//   // Acquire the lock for the scope of this method.
+//   base::AutoLock lock_scope(lock_);
+//   // |value_| can now be modified safely.
+//   value_++;
+// }
+///
+#define IMPLEMENT_LOCKING(ClassName)                                       \
+  public:                                                                  \
+    class AutoLock {                                                       \
+     public:                                                               \
+      explicit AutoLock(ClassName* base) : base_(base) { base_->Lock(); }  \
+      ~AutoLock() { base_->Unlock(); }                                     \
+     private:                                                              \
+      ClassName* base_;                                                    \
+      DISALLOW_COPY_AND_ASSIGN(AutoLock);                                  \
+    };                                                                     \
+    void Lock() { lock_.Acquire(); }                                       \
+    void Unlock() { lock_.Release(); }                                     \
+  private:                                                                 \
+    base::Lock lock_;
+
+#endif  // CEF_INCLUDE_CEF_BASE_H_
diff --git a/src/include/libcef/cef_browser.h b/src/include/libcef/cef_browser.h
new file mode 100644
index 0000000..4d0ca26
--- /dev/null
+++ b/src/include/libcef/cef_browser.h
@@ -0,0 +1,748 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_BROWSER_H_
+#define CEF_INCLUDE_CEF_BROWSER_H_
+#pragma once
+
+#include "include/cef_base.h"
+#include "include/cef_drag_data.h"
+#include "include/cef_frame.h"
+#include "include/cef_image.h"
+#include "include/cef_navigation_entry.h"
+#include "include/cef_process_message.h"
+#include "include/cef_request_context.h"
+#include <vector>
+
+class CefBrowserHost;
+class CefClient;
+
+
+///
+// Class used to represent a browser window. When used in the browser process
+// the methods of this class may be called on any thread unless otherwise
+// indicated in the comments. When used in the render process the methods of
+// this class may only be called on the main thread.
+///
+/*--cef(source=library)--*/
+class CefBrowser : public virtual CefBase {
+ public:
+  ///
+  // Returns the browser host object. This method can only be called in the
+  // browser process.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefBrowserHost> GetHost() =0;
+
+  ///
+  // Returns true if the browser can navigate backwards.
+  ///
+  /*--cef()--*/
+  virtual bool CanGoBack() =0;
+
+  ///
+  // Navigate backwards.
+  ///
+  /*--cef()--*/
+  virtual void GoBack() =0;
+
+  ///
+  // Returns true if the browser can navigate forwards.
+  ///
+  /*--cef()--*/
+  virtual bool CanGoForward() =0;
+
+  ///
+  // Navigate forwards.
+  ///
+  /*--cef()--*/
+  virtual void GoForward() =0;
+
+  ///
+  // Returns true if the browser is currently loading.
+  ///
+  /*--cef()--*/
+  virtual bool IsLoading() =0;
+
+  ///
+  // Reload the current page.
+  ///
+  /*--cef()--*/
+  virtual void Reload() =0;
+
+  ///
+  // Reload the current page ignoring any cached data.
+  ///
+  /*--cef()--*/
+  virtual void ReloadIgnoreCache() =0;
+
+  ///
+  // Stop loading the page.
+  ///
+  /*--cef()--*/
+  virtual void StopLoad() =0;
+
+  ///
+  // Returns the globally unique identifier for this browser.
+  ///
+  /*--cef()--*/
+  virtual int GetIdentifier() =0;
+
+  ///
+  // Returns true if this object is pointing to the same handle as |that|
+  // object.
+  ///
+  /*--cef()--*/
+  virtual bool IsSame(CefRefPtr<CefBrowser> that) =0;
+
+  ///
+  // Returns true if the window is a popup window.
+  ///
+  /*--cef()--*/
+  virtual bool IsPopup() =0;
+
+  ///
+  // Returns true if a document has been loaded in the browser.
+  ///
+  /*--cef()--*/
+  virtual bool HasDocument() =0;
+
+  ///
+  // Returns the main (top-level) frame for the browser window.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefFrame> GetMainFrame() =0;
+
+  ///
+  // Returns the focused frame for the browser window.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefFrame> GetFocusedFrame() =0;
+
+  ///
+  // Returns the frame with the specified identifier, or NULL if not found.
+  ///
+  /*--cef(capi_name=get_frame_byident)--*/
+  virtual CefRefPtr<CefFrame> GetFrame(int64 identifier) =0;
+
+  ///
+  // Returns the frame with the specified name, or NULL if not found.
+  ///
+  /*--cef(optional_param=name)--*/
+  virtual CefRefPtr<CefFrame> GetFrame(const CefString& name) =0;
+
+  ///
+  // Returns the number of frames that currently exist.
+  ///
+  /*--cef()--*/
+  virtual size_t GetFrameCount() =0;
+
+  ///
+  // Returns the identifiers of all existing frames.
+  ///
+  /*--cef(count_func=identifiers:GetFrameCount)--*/
+  virtual void GetFrameIdentifiers(std::vector<int64>& identifiers) =0;
+
+  ///
+  // Returns the names of all existing frames.
+  ///
+  /*--cef()--*/
+  virtual void GetFrameNames(std::vector<CefString>& names) =0;
+
+  ///
+  // Send a message to the specified |target_process|. Returns true if the
+  // message was sent successfully.
+  ///
+  /*--cef()--*/
+  virtual bool SendProcessMessage(CefProcessId target_process,
+                                  CefRefPtr<CefProcessMessage> message) =0;
+};
+
+
+///
+// Callback interface for CefBrowserHost::RunFileDialog. The methods of this
+// class will be called on the browser process UI thread.
+///
+/*--cef(source=client)--*/
+class CefRunFileDialogCallback : public virtual CefBase {
+ public:
+  ///
+  // Called asynchronously after the file dialog is dismissed.
+  // |selected_accept_filter| is the 0-based index of the value selected from
+  // the accept filters array passed to CefBrowserHost::RunFileDialog.
+  // |file_paths| will be a single value or a list of values depending on the
+  // dialog mode. If the selection was cancelled |file_paths| will be empty.
+  ///
+  /*--cef(index_param=selected_accept_filter,optional_param=file_paths)--*/
+  virtual void OnFileDialogDismissed(
+      int selected_accept_filter,
+      const std::vector<CefString>& file_paths) =0;
+};
+
+
+///
+// Callback interface for CefBrowserHost::GetNavigationEntries. The methods of
+// this class will be called on the browser process UI thread.
+///
+/*--cef(source=client)--*/
+class CefNavigationEntryVisitor : public virtual CefBase {
+ public:
+  ///
+  // Method that will be executed. Do not keep a reference to |entry| outside of
+  // this callback. Return true to continue visiting entries or false to stop.
+  // |current| is true if this entry is the currently loaded navigation entry.
+  // |index| is the 0-based index of this entry and |total| is the total number
+  // of entries.
+  ///
+  /*--cef()--*/
+  virtual bool Visit(CefRefPtr<CefNavigationEntry> entry,
+                     bool current,
+                     int index,
+                     int total) =0;
+};
+
+
+///
+// Callback interface for CefBrowserHost::PrintToPDF. The methods of this class
+// will be called on the browser process UI thread.
+///
+/*--cef(source=client)--*/
+class CefPdfPrintCallback : public virtual CefBase {
+ public:
+  ///
+  // Method that will be executed when the PDF printing has completed. |path|
+  // is the output path. |ok| will be true if the printing completed
+  // successfully or false otherwise.
+  ///
+  /*--cef()--*/
+  virtual void OnPdfPrintFinished(const CefString& path, bool ok) =0;
+};
+
+
+///
+// Callback interface for CefBrowserHost::DownloadImage. The methods of this
+// class will be called on the browser process UI thread.
+///
+/*--cef(source=client)--*/
+class CefDownloadImageCallback : public virtual CefBase {
+ public:
+  ///
+  // Method that will be executed when the image download has completed.
+  // |image_url| is the URL that was downloaded and |http_status_code| is the
+  // resulting HTTP status code. |image| is the resulting image, possibly at
+  // multiple scale factors, or empty if the download failed.
+  ///
+  /*--cef(optional_param=image)--*/
+  virtual void OnDownloadImageFinished(
+     const CefString& image_url,
+     int http_status_code,
+     CefRefPtr<CefImage> image) =0;
+};
+
+
+///
+// Class used to represent the browser process aspects of a browser window. The
+// methods of this class can only be called in the browser process. They may be
+// called on any thread in that process unless otherwise indicated in the
+// comments.
+///
+/*--cef(source=library)--*/
+class CefBrowserHost : public virtual CefBase {
+ public:
+  typedef cef_drag_operations_mask_t DragOperationsMask;
+  typedef cef_file_dialog_mode_t FileDialogMode;
+  typedef cef_mouse_button_type_t MouseButtonType;
+  typedef cef_paint_element_type_t PaintElementType;
+
+  ///
+  // Create a new browser window using the window parameters specified by
+  // |windowInfo|. All values will be copied internally and the actual window
+  // will be created on the UI thread. If |request_context| is empty the
+  // global request context will be used. This method can be called on any
+  // browser process thread and will not block.
+  ///
+  /*--cef(optional_param=client,optional_param=url,
+          optional_param=request_context)--*/
+  static bool CreateBrowser(const CefWindowInfo& windowInfo,
+                            CefRefPtr<CefClient> client,
+                            const CefString& url,
+                            const CefBrowserSettings& settings,
+                            CefRefPtr<CefRequestContext> request_context);
+
+  ///
+  // Create a new browser window using the window parameters specified by
+  // |windowInfo|. If |request_context| is empty the global request context
+  // will be used. This method can only be called on the browser process UI
+  // thread.
+  ///
+  /*--cef(optional_param=client,optional_param=url,
+          optional_param=request_context)--*/
+  static CefRefPtr<CefBrowser> CreateBrowserSync(
+      const CefWindowInfo& windowInfo,
+      CefRefPtr<CefClient> client,
+      const CefString& url,
+      const CefBrowserSettings& settings,
+      CefRefPtr<CefRequestContext> request_context);
+
+  ///
+  // Returns the hosted browser object.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefBrowser> GetBrowser() =0;
+
+  ///
+  // Request that the browser close. The JavaScript 'onbeforeunload' event will
+  // be fired. If |force_close| is false the event handler, if any, will be
+  // allowed to prompt the user and the user can optionally cancel the close.
+  // If |force_close| is true the prompt will not be displayed and the close
+  // will proceed. Results in a call to CefLifeSpanHandler::DoClose() if the
+  // event handler allows the close or if |force_close| is true. See
+  // CefLifeSpanHandler::DoClose() documentation for additional usage
+  // information.
+  ///
+  /*--cef()--*/
+  virtual void CloseBrowser(bool force_close) =0;
+
+  ///
+  // Helper for closing a browser. Call this method from the top-level window
+  // close handler. Internally this calls CloseBrowser(false) if the close has
+  // not yet been initiated. This method returns false while the close is
+  // pending and true after the close has completed. See CloseBrowser() and
+  // CefLifeSpanHandler::DoClose() documentation for additional usage
+  // information. This method must be called on the browser process UI thread.
+  ///
+  /*--cef()--*/
+  virtual bool TryCloseBrowser() =0;
+
+  ///
+  // Set whether the browser is focused.
+  ///
+  /*--cef()--*/
+  virtual void SetFocus(bool focus) =0;
+
+  ///
+  // Retrieve the window handle for this browser. If this browser is wrapped in
+  // a CefBrowserView this method should be called on the browser process UI
+  // thread and it will return the handle for the top-level native window.
+  ///
+  /*--cef()--*/
+  virtual CefWindowHandle GetWindowHandle() =0;
+
+  ///
+  // Retrieve the window handle of the browser that opened this browser. Will
+  // return NULL for non-popup windows or if this browser is wrapped in a
+  // CefBrowserView. This method can be used in combination with custom handling
+  // of modal windows. 
+  ///
+  /*--cef()--*/
+  virtual CefWindowHandle GetOpenerWindowHandle() =0;
+
+  ///
+  // Returns true if this browser is wrapped in a CefBrowserView.
+  ///
+  /*--cef()--*/
+  virtual bool HasView() =0;
+
+  ///
+  // Returns the client for this browser.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefClient> GetClient() =0;
+
+  ///
+  // Returns the request context for this browser.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefRequestContext> GetRequestContext() =0;
+
+  ///
+  // Get the current zoom level. The default zoom level is 0.0. This method can
+  // only be called on the UI thread.
+  ///
+  /*--cef()--*/
+  virtual double GetZoomLevel() =0;
+
+  ///
+  // Change the zoom level to the specified value. Specify 0.0 to reset the
+  // zoom level. If called on the UI thread the change will be applied
+  // immediately. Otherwise, the change will be applied asynchronously on the
+  // UI thread.
+  ///
+  /*--cef()--*/
+  virtual void SetZoomLevel(double zoomLevel) =0;
+
+  ///
+  // Call to run a file chooser dialog. Only a single file chooser dialog may be
+  // pending at any given time. |mode| represents the type of dialog to display.
+  // |title| to the title to be used for the dialog and may be empty to show the
+  // default title ("Open" or "Save" depending on the mode). |default_file_path|
+  // is the path with optional directory and/or file name component that will be
+  // initially selected in the dialog. |accept_filters| are used to restrict the
+  // selectable file types and may any combination of (a) valid lower-cased MIME
+  // types (e.g. "text/*" or "image/*"), (b) individual file extensions (e.g.
+  // ".txt" or ".png"), or (c) combined description and file extension delimited
+  // using "|" and ";" (e.g. "Image Types|.png;.gif;.jpg").
+  // |selected_accept_filter| is the 0-based index of the filter that will be
+  // selected by default. |callback| will be executed after the dialog is
+  // dismissed or immediately if another dialog is already pending. The dialog
+  // will be initiated asynchronously on the UI thread.
+  ///
+  /*--cef(optional_param=title,optional_param=default_file_path,
+          optional_param=accept_filters,index_param=selected_accept_filter)--*/
+  virtual void RunFileDialog(FileDialogMode mode,
+                             const CefString& title,
+                             const CefString& default_file_path,
+                             const std::vector<CefString>& accept_filters,
+                             int selected_accept_filter,
+                             CefRefPtr<CefRunFileDialogCallback> callback) =0;
+
+  ///
+  // Download the file at |url| using CefDownloadHandler.
+  ///
+  /*--cef()--*/
+  virtual void StartDownload(const CefString& url) =0;
+
+  ///
+  // Download |image_url| and execute |callback| on completion with the images
+  // received from the renderer. If |is_favicon| is true then cookies are not
+  // sent and not accepted during download. Images with density independent
+  // pixel (DIP) sizes larger than |max_image_size| are filtered out from the
+  // image results. Versions of the image at different scale factors may be
+  // downloaded up to the maximum scale factor supported by the system. If there
+  // are no image results <= |max_image_size| then the smallest image is resized
+  // to |max_image_size| and is the only result. A |max_image_size| of 0 means
+  // unlimited. If |bypass_cache| is true then |image_url| is requested from the
+  // server even if it is present in the browser cache.
+  ///
+  /*--cef()--*/
+  virtual void DownloadImage(const CefString& image_url,
+                             bool is_favicon,
+                             uint32 max_image_size,
+                             bool bypass_cache,
+                             CefRefPtr<CefDownloadImageCallback> callback) =0;
+
+  ///
+  // Print the current browser contents.
+  ///
+  /*--cef()--*/
+  virtual void Print() =0;
+
+  ///
+  // Print the current browser contents to the PDF file specified by |path| and
+  // execute |callback| on completion. The caller is responsible for deleting
+  // |path| when done. For PDF printing to work on Linux you must implement the
+  // CefPrintHandler::GetPdfPaperSize method.
+  ///
+  /*--cef(optional_param=callback)--*/
+  virtual void PrintToPDF(const CefString& path,
+                          const CefPdfPrintSettings& settings,
+                          CefRefPtr<CefPdfPrintCallback> callback) =0;
+
+  ///
+  // Search for |searchText|. |identifier| can be used to have multiple searches
+  // running simultaniously. |forward| indicates whether to search forward or
+  // backward within the page. |matchCase| indicates whether the search should
+  // be case-sensitive. |findNext| indicates whether this is the first request
+  // or a follow-up. The CefFindHandler instance, if any, returned via
+  // CefClient::GetFindHandler will be called to report find results.
+  ///
+  /*--cef()--*/
+  virtual void Find(int identifier, const CefString& searchText,
+                    bool forward, bool matchCase, bool findNext) =0;
+
+  ///
+  // Cancel all searches that are currently going on.
+  ///
+  /*--cef()--*/
+  virtual void StopFinding(bool clearSelection) =0;
+
+  ///
+  // Open developer tools in its own window. If |inspect_element_at| is non-
+  // empty the element at the specified (x,y) location will be inspected. The
+  // |windowInfo| parameter will be ignored if this browser is wrapped in a
+  // CefBrowserView.
+  ///
+  /*--cef(optional_param=inspect_element_at)--*/
+  virtual void ShowDevTools(const CefWindowInfo& windowInfo,
+                            CefRefPtr<CefClient> client,
+                            const CefBrowserSettings& settings,
+                            const CefPoint& inspect_element_at) =0;
+
+  ///
+  // Explicitly close the developer tools window if one exists for this browser
+  // instance.
+  ///
+  /*--cef()--*/
+  virtual void CloseDevTools() =0;
+
+  ///
+  // Retrieve a snapshot of current navigation entries as values sent to the
+  // specified visitor. If |current_only| is true only the current navigation
+  // entry will be sent, otherwise all navigation entries will be sent.
+  ///
+  /*--cef()--*/
+  virtual void GetNavigationEntries(
+      CefRefPtr<CefNavigationEntryVisitor> visitor,
+      bool current_only) =0;
+
+  ///
+  // Set whether mouse cursor change is disabled.
+  ///
+  /*--cef()--*/
+  virtual void SetMouseCursorChangeDisabled(bool disabled) =0;
+
+  ///
+  // Returns true if mouse cursor change is disabled.
+  ///
+  /*--cef()--*/
+  virtual bool IsMouseCursorChangeDisabled() =0;
+
+  ///
+  // If a misspelled word is currently selected in an editable node calling
+  // this method will replace it with the specified |word|.
+  ///
+  /*--cef()--*/
+  virtual void ReplaceMisspelling(const CefString& word) =0;
+
+  ///
+  // Add the specified |word| to the spelling dictionary.
+  ///
+  /*--cef()--*/
+  virtual void AddWordToDictionary(const CefString& word) =0;
+
+  ///
+  // Returns true if window rendering is disabled.
+  ///
+  /*--cef()--*/
+  virtual bool IsWindowRenderingDisabled() =0;
+
+  ///
+  // Notify the browser that the widget has been resized. The browser will first
+  // call CefRenderHandler::GetViewRect to get the new size and then call
+  // CefRenderHandler::OnPaint asynchronously with the updated regions. This
+  // method is only used when window rendering is disabled.
+  ///
+  /*--cef()--*/
+  virtual void WasResized() =0;
+
+  ///
+  // Notify the browser that it has been hidden or shown. Layouting and
+  // CefRenderHandler::OnPaint notification will stop when the browser is
+  // hidden. This method is only used when window rendering is disabled.
+  ///
+  /*--cef()--*/
+  virtual void WasHidden(bool hidden) =0;
+
+  ///
+  // Send a notification to the browser that the screen info has changed. The
+  // browser will then call CefRenderHandler::GetScreenInfo to update the
+  // screen information with the new values. This simulates moving the webview
+  // window from one display to another, or changing the properties of the
+  // current display. This method is only used when window rendering is
+  // disabled.
+  ///
+  /*--cef()--*/
+  virtual void NotifyScreenInfoChanged() =0;
+
+  ///
+  // Invalidate the view. The browser will call CefRenderHandler::OnPaint
+  // asynchronously. This method is only used when window rendering is
+  // disabled.
+  ///
+  /*--cef()--*/
+  virtual void Invalidate(PaintElementType type) =0;
+
+  ///
+  // Send a key event to the browser.
+  ///
+  /*--cef()--*/
+  virtual void SendKeyEvent(const CefKeyEvent& event) =0;
+
+  ///
+  // Send a mouse click event to the browser. The |x| and |y| coordinates are
+  // relative to the upper-left corner of the view.
+  ///
+  /*--cef()--*/
+  virtual void SendMouseClickEvent(const CefMouseEvent& event,
+                                   MouseButtonType type,
+                                   bool mouseUp, int clickCount) =0;
+
+  ///
+  // Send a mouse move event to the browser. The |x| and |y| coordinates are
+  // relative to the upper-left corner of the view.
+  ///
+  /*--cef()--*/
+  virtual void SendMouseMoveEvent(const CefMouseEvent& event,
+                                  bool mouseLeave) =0;
+
+  ///
+  // Send a mouse wheel event to the browser. The |x| and |y| coordinates are
+  // relative to the upper-left corner of the view. The |deltaX| and |deltaY|
+  // values represent the movement delta in the X and Y directions respectively.
+  // In order to scroll inside select popups with window rendering disabled
+  // CefRenderHandler::GetScreenPoint should be implemented properly.
+  ///
+  /*--cef()--*/
+  virtual void SendMouseWheelEvent(const CefMouseEvent& event,
+                                   int deltaX, int deltaY) =0;
+
+  ///
+  // Send a focus event to the browser.
+  ///
+  /*--cef()--*/
+  virtual void SendFocusEvent(bool setFocus) =0;
+
+  ///
+  // Send a capture lost event to the browser.
+  ///
+  /*--cef()--*/
+  virtual void SendCaptureLostEvent() =0;
+
+  ///
+  // Notify the browser that the window hosting it is about to be moved or
+  // resized. This method is only used on Windows and Linux.
+  ///
+  /*--cef()--*/
+  virtual void NotifyMoveOrResizeStarted() =0;
+
+  ///
+  // Returns the maximum rate in frames per second (fps) that CefRenderHandler::
+  // OnPaint will be called for a windowless browser. The actual fps may be
+  // lower if the browser cannot generate frames at the requested rate. The
+  // minimum value is 1 and the maximum value is 60 (default 30). This method
+  // can only be called on the UI thread.
+  ///
+  /*--cef()--*/
+  virtual int GetWindowlessFrameRate() =0;
+
+  ///
+  // Set the maximum rate in frames per second (fps) that CefRenderHandler::
+  // OnPaint will be called for a windowless browser. The actual fps may be
+  // lower if the browser cannot generate frames at the requested rate. The
+  // minimum value is 1 and the maximum value is 60 (default 30). Can also be
+  // set at browser creation via CefBrowserSettings.windowless_frame_rate.
+  ///
+  /*--cef()--*/
+  virtual void SetWindowlessFrameRate(int frame_rate) =0;
+
+  ///
+  // Get the NSTextInputContext implementation for enabling IME on Mac when
+  // window rendering is disabled.
+  ///
+  /*--cef(default_retval=NULL)--*/
+  virtual CefTextInputContext GetNSTextInputContext() =0;
+
+  ///
+  // Handles a keyDown event prior to passing it through the NSTextInputClient
+  // machinery.
+  ///
+  /*--cef()--*/
+  virtual void HandleKeyEventBeforeTextInputClient(CefEventHandle keyEvent) =0;
+
+  ///
+  // Performs any additional actions after NSTextInputClient handles the event.
+  ///
+  /*--cef()--*/
+  virtual void HandleKeyEventAfterTextInputClient(CefEventHandle keyEvent) =0;
+
+  ///
+  // Call this method when the user drags the mouse into the web view (before
+  // calling DragTargetDragOver/DragTargetLeave/DragTargetDrop).
+  // |drag_data| should not contain file contents as this type of data is not
+  // allowed to be dragged into the web view. File contents can be removed using
+  // CefDragData::ResetFileContents (for example, if |drag_data| comes from
+  // CefRenderHandler::StartDragging).
+  // This method is only used when window rendering is disabled.
+  ///
+  /*--cef()--*/
+  virtual void DragTargetDragEnter(CefRefPtr<CefDragData> drag_data,
+                                  const CefMouseEvent& event,
+                                  DragOperationsMask allowed_ops) =0;
+
+  ///
+  // Call this method each time the mouse is moved across the web view during
+  // a drag operation (after calling DragTargetDragEnter and before calling
+  // DragTargetDragLeave/DragTargetDrop).
+  // This method is only used when window rendering is disabled.
+  ///
+  /*--cef()--*/
+  virtual void DragTargetDragOver(const CefMouseEvent& event,
+                                  DragOperationsMask allowed_ops) =0;
+
+  ///
+  // Call this method when the user drags the mouse out of the web view (after
+  // calling DragTargetDragEnter).
+  // This method is only used when window rendering is disabled.
+  ///
+  /*--cef()--*/
+  virtual void DragTargetDragLeave() =0;
+
+  ///
+  // Call this method when the user completes the drag operation by dropping
+  // the object onto the web view (after calling DragTargetDragEnter).
+  // The object being dropped is |drag_data|, given as an argument to
+  // the previous DragTargetDragEnter call.
+  // This method is only used when window rendering is disabled.
+  ///
+  /*--cef()--*/
+  virtual void DragTargetDrop(const CefMouseEvent& event) =0;
+
+  ///
+  // Call this method when the drag operation started by a
+  // CefRenderHandler::StartDragging call has ended either in a drop or
+  // by being cancelled. |x| and |y| are mouse coordinates relative to the
+  // upper-left corner of the view. If the web view is both the drag source
+  // and the drag target then all DragTarget* methods should be called before
+  // DragSource* mthods.
+  // This method is only used when window rendering is disabled.
+  ///
+  /*--cef()--*/
+  virtual void DragSourceEndedAt(int x, int y, DragOperationsMask op) =0;
+
+  ///
+  // Call this method when the drag operation started by a
+  // CefRenderHandler::StartDragging call has completed. This method may be
+  // called immediately without first calling DragSourceEndedAt to cancel a
+  // drag operation. If the web view is both the drag source and the drag
+  // target then all DragTarget* methods should be called before DragSource*
+  // mthods.
+  // This method is only used when window rendering is disabled.
+  ///
+  /*--cef()--*/
+  virtual void DragSourceSystemDragEnded() =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_BROWSER_H_
diff --git a/src/include/libcef/cef_browser_process_handler.h b/src/include/libcef/cef_browser_process_handler.h
new file mode 100644
index 0000000..5d62cb3
--- /dev/null
+++ b/src/include/libcef/cef_browser_process_handler.h
@@ -0,0 +1,92 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_BROWSER_PROCESS_HANDLER_H_
+#define CEF_INCLUDE_CEF_BROWSER_PROCESS_HANDLER_H_
+#pragma once
+
+#include "include/cef_base.h"
+#include "include/cef_command_line.h"
+#include "include/cef_print_handler.h"
+#include "include/cef_values.h"
+
+///
+// Class used to implement browser process callbacks. The methods of this class
+// will be called on the browser process main thread unless otherwise indicated.
+///
+/*--cef(source=client)--*/
+class CefBrowserProcessHandler : public virtual CefBase {
+ public:
+  ///
+  // Called on the browser process UI thread immediately after the CEF context
+  // has been initialized.
+  ///
+  /*--cef()--*/
+  virtual void OnContextInitialized() {}
+
+  ///
+  // Called before a child process is launched. Will be called on the browser
+  // process UI thread when launching a render process and on the browser
+  // process IO thread when launching a GPU or plugin process. Provides an
+  // opportunity to modify the child process command line. Do not keep a
+  // reference to |command_line| outside of this method.
+  ///
+  /*--cef()--*/
+  virtual void OnBeforeChildProcessLaunch(
+      CefRefPtr<CefCommandLine> command_line) {}
+
+  ///
+  // Called on the browser process IO thread after the main thread has been
+  // created for a new render process. Provides an opportunity to specify extra
+  // information that will be passed to
+  // CefRenderProcessHandler::OnRenderThreadCreated() in the render process. Do
+  // not keep a reference to |extra_info| outside of this method.
+  ///
+  /*--cef()--*/
+  virtual void OnRenderProcessThreadCreated(
+      CefRefPtr<CefListValue> extra_info) {}
+
+  ///
+  // Return the handler for printing on Linux. If a print handler is not
+  // provided then printing will not be supported on the Linux platform.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefPrintHandler> GetPrintHandler() {
+    return NULL;
+  }
+};
+
+#endif  // CEF_INCLUDE_CEF_BROWSER_PROCESS_HANDLER_H_
diff --git a/src/include/libcef/cef_callback.h b/src/include/libcef/cef_callback.h
new file mode 100644
index 0000000..e5efebd
--- /dev/null
+++ b/src/include/libcef/cef_callback.h
@@ -0,0 +1,75 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_CALLBACK_H_
+#define CEF_INCLUDE_CEF_CALLBACK_H_
+#pragma once
+
+#include "include/cef_base.h"
+
+///
+// Generic callback interface used for asynchronous continuation.
+///
+/*--cef(source=library)--*/
+class CefCallback : public virtual CefBase {
+ public:
+  ///
+  // Continue processing.
+  ///
+  /*--cef(capi_name=cont)--*/
+  virtual void Continue() =0;
+
+  ///
+  // Cancel processing.
+  ///
+  /*--cef()--*/
+  virtual void Cancel() =0;
+};
+
+///
+// Generic callback interface used for asynchronous completion.
+///
+/*--cef(source=client)--*/
+class CefCompletionCallback : public virtual CefBase {
+ public:
+  ///
+  // Method that will be called once the task is complete.
+  ///
+  /*--cef()--*/
+  virtual void OnComplete() =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_CALLBACK_H_
diff --git a/src/include/libcef/cef_client.h b/src/include/libcef/cef_client.h
new file mode 100644
index 0000000..81a67eb
--- /dev/null
+++ b/src/include/libcef/cef_client.h
@@ -0,0 +1,194 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_CLIENT_H_
+#define CEF_INCLUDE_CEF_CLIENT_H_
+#pragma once
+
+#include "include/cef_base.h"
+#include "include/cef_context_menu_handler.h"
+#include "include/cef_dialog_handler.h"
+#include "include/cef_display_handler.h"
+#include "include/cef_download_handler.h"
+#include "include/cef_drag_handler.h"
+#include "include/cef_find_handler.h"
+#include "include/cef_focus_handler.h"
+#include "include/cef_geolocation_handler.h"
+#include "include/cef_jsdialog_handler.h"
+#include "include/cef_keyboard_handler.h"
+#include "include/cef_life_span_handler.h"
+#include "include/cef_load_handler.h"
+#include "include/cef_process_message.h"
+#include "include/cef_render_handler.h"
+#include "include/cef_request_handler.h"
+
+///
+// Implement this interface to provide handler implementations.
+///
+/*--cef(source=client,no_debugct_check)--*/
+class CefClient : public virtual CefBase {
+ public:
+  ///
+  // Return the handler for context menus. If no handler is provided the default
+  // implementation will be used.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefContextMenuHandler> GetContextMenuHandler() {
+    return NULL;
+  }
+
+  ///
+  // Return the handler for dialogs. If no handler is provided the default
+  // implementation will be used.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefDialogHandler> GetDialogHandler() {
+    return NULL;
+  }
+
+  ///
+  // Return the handler for browser display state events.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefDisplayHandler> GetDisplayHandler() {
+    return NULL;
+  }
+
+  ///
+  // Return the handler for download events. If no handler is returned downloads
+  // will not be allowed.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefDownloadHandler> GetDownloadHandler() {
+    return NULL;
+  }
+
+  ///
+  // Return the handler for drag events.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefDragHandler> GetDragHandler() {
+    return NULL;
+  }
+
+  ///
+  // Return the handler for find result events.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefFindHandler> GetFindHandler() {
+    return NULL;
+  }
+
+  ///
+  // Return the handler for focus events.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefFocusHandler> GetFocusHandler() {
+    return NULL;
+  }
+
+  ///
+  // Return the handler for geolocation permissions requests. If no handler is
+  // provided geolocation access will be denied by default.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefGeolocationHandler> GetGeolocationHandler() {
+    return NULL;
+  }
+
+  ///
+  // Return the handler for JavaScript dialogs. If no handler is provided the
+  // default implementation will be used.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefJSDialogHandler> GetJSDialogHandler() {
+    return NULL;
+  }
+
+  ///
+  // Return the handler for keyboard events.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefKeyboardHandler> GetKeyboardHandler() {
+    return NULL;
+  }
+
+  ///
+  // Return the handler for browser life span events.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefLifeSpanHandler> GetLifeSpanHandler() {
+    return NULL;
+  }
+
+  ///
+  // Return the handler for browser load status events.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefLoadHandler> GetLoadHandler() {
+    return NULL;
+  }
+
+  ///
+  // Return the handler for off-screen rendering events.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefRenderHandler> GetRenderHandler() {
+    return NULL;
+  }
+
+  ///
+  // Return the handler for browser request events.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefRequestHandler> GetRequestHandler() {
+    return NULL;
+  }
+
+  ///
+  // Called when a new message is received from a different process. Return true
+  // if the message was handled or false otherwise. Do not keep a reference to
+  // or attempt to access the message outside of this callback.
+  ///
+  /*--cef()--*/
+  virtual bool OnProcessMessageReceived(CefRefPtr<CefBrowser> browser,
+                                        CefProcessId source_process,
+                                        CefRefPtr<CefProcessMessage> message) {
+    return false;
+  }
+};
+
+#endif  // CEF_INCLUDE_CEF_CLIENT_H_
diff --git a/src/include/libcef/cef_command_line.h b/src/include/libcef/cef_command_line.h
new file mode 100644
index 0000000..96241cf
--- /dev/null
+++ b/src/include/libcef/cef_command_line.h
@@ -0,0 +1,208 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_COMMAND_LINE_H_
+#define CEF_INCLUDE_CEF_COMMAND_LINE_H_
+#pragma once
+
+#include "include/cef_base.h"
+#include <map>
+#include <vector>
+
+///
+// Class used to create and/or parse command line arguments. Arguments with
+// '--', '-' and, on Windows, '/' prefixes are considered switches. Switches
+// will always precede any arguments without switch prefixes. Switches can
+// optionally have a value specified using the '=' delimiter (e.g.
+// "-switch=value"). An argument of "--" will terminate switch parsing with all
+// subsequent tokens, regardless of prefix, being interpreted as non-switch
+// arguments. Switch names are considered case-insensitive. This class can be
+// used before CefInitialize() is called.
+///
+/*--cef(source=library,no_debugct_check)--*/
+class CefCommandLine : public virtual CefBase {
+ public:
+  typedef std::vector<CefString> ArgumentList;
+  typedef std::map<CefString, CefString> SwitchMap;
+
+  ///
+  // Create a new CefCommandLine instance.
+  ///
+  /*--cef(api_hash_check)--*/
+  static CefRefPtr<CefCommandLine> CreateCommandLine();
+
+  ///
+  // Returns the singleton global CefCommandLine object. The returned object
+  // will be read-only.
+  ///
+  /*--cef(api_hash_check)--*/
+  static CefRefPtr<CefCommandLine> GetGlobalCommandLine();
+
+  ///
+  // Returns true if this object is valid. Do not call any other methods if this
+  // function returns false.
+  ///
+  /*--cef()--*/
+  virtual bool IsValid() =0;
+
+  ///
+  // Returns true if the values of this object are read-only. Some APIs may
+  // expose read-only objects.
+  ///
+  /*--cef()--*/
+  virtual bool IsReadOnly() =0;
+
+  ///
+  // Returns a writable copy of this object.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefCommandLine> Copy() =0;
+
+  ///
+  // Initialize the command line with the specified |argc| and |argv| values.
+  // The first argument must be the name of the program. This method is only
+  // supported on non-Windows platforms.
+  ///
+  /*--cef()--*/
+  virtual void InitFromArgv(int argc, const char* const* argv) =0;
+
+  ///
+  // Initialize the command line with the string returned by calling
+  // GetCommandLineW(). This method is only supported on Windows.
+  ///
+  /*--cef()--*/
+  virtual void InitFromString(const CefString& command_line) =0;
+
+  ///
+  // Reset the command-line switches and arguments but leave the program
+  // component unchanged.
+  ///
+  /*--cef()--*/
+  virtual void Reset() =0;
+
+  ///
+  // Retrieve the original command line string as a vector of strings.
+  // The argv array: { program, [(--|-|/)switch[=value]]*, [--], [argument]* }
+  ///
+  /*--cef()--*/
+  virtual void GetArgv(std::vector<CefString>& argv) =0;
+
+  ///
+  // Constructs and returns the represented command line string. Use this method
+  // cautiously because quoting behavior is unclear.
+  ///
+  /*--cef()--*/
+  virtual CefString GetCommandLineString() =0;
+
+  ///
+  // Get the program part of the command line string (the first item).
+  ///
+  /*--cef()--*/
+  virtual CefString GetProgram() =0;
+
+  ///
+  // Set the program part of the command line string (the first item).
+  ///
+  /*--cef()--*/
+  virtual void SetProgram(const CefString& program) =0;
+
+  ///
+  // Returns true if the command line has switches.
+  ///
+  /*--cef()--*/
+  virtual bool HasSwitches() =0;
+
+  ///
+  // Returns true if the command line contains the given switch.
+  ///
+  /*--cef()--*/
+  virtual bool HasSwitch(const CefString& name) =0;
+
+  ///
+  // Returns the value associated with the given switch. If the switch has no
+  // value or isn't present this method returns the empty string.
+  ///
+  /*--cef()--*/
+  virtual CefString GetSwitchValue(const CefString& name) =0;
+
+  ///
+  // Returns the map of switch names and values. If a switch has no value an
+  // empty string is returned.
+  ///
+  /*--cef()--*/
+  virtual void GetSwitches(SwitchMap& switches) =0;
+
+  ///
+  // Add a switch to the end of the command line. If the switch has no value
+  // pass an empty value string.
+  ///
+  /*--cef()--*/
+  virtual void AppendSwitch(const CefString& name) =0;
+
+  ///
+  // Add a switch with the specified value to the end of the command line.
+  ///
+  /*--cef()--*/
+  virtual void AppendSwitchWithValue(const CefString& name,
+                                     const CefString& value) =0;
+
+  ///
+  // True if there are remaining command line arguments.
+  ///
+  /*--cef()--*/
+  virtual bool HasArguments() =0;
+
+  ///
+  // Get the remaining command line arguments.
+  ///
+  /*--cef()--*/
+  virtual void GetArguments(ArgumentList& arguments) =0;
+
+  ///
+  // Add an argument to the end of the command line.
+  ///
+  /*--cef()--*/
+  virtual void AppendArgument(const CefString& argument) =0;
+
+  ///
+  // Insert a command before the current command.
+  // Common for debuggers, like "valgrind" or "gdb --args".
+  ///
+  /*--cef()--*/
+  virtual void PrependWrapper(const CefString& wrapper) =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_COMMAND_LINE_H_
diff --git a/src/include/libcef/cef_context_menu_handler.h b/src/include/libcef/cef_context_menu_handler.h
new file mode 100644
index 0000000..ab45035
--- /dev/null
+++ b/src/include/libcef/cef_context_menu_handler.h
@@ -0,0 +1,285 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_CONTEXT_MENU_HANDLER_H_
+#define CEF_INCLUDE_CEF_CONTEXT_MENU_HANDLER_H_
+#pragma once
+
+#include "include/cef_base.h"
+#include "include/cef_browser.h"
+#include "include/cef_frame.h"
+#include "include/cef_menu_model.h"
+
+class CefContextMenuParams;
+
+
+///
+// Callback interface used for continuation of custom context menu display.
+///
+/*--cef(source=library)--*/
+class CefRunContextMenuCallback : public virtual CefBase {
+ public:
+  typedef cef_event_flags_t EventFlags;
+
+  ///
+  // Complete context menu display by selecting the specified |command_id| and
+  // |event_flags|.
+  ///
+  /*--cef(capi_name=cont)--*/
+  virtual void Continue(int command_id, EventFlags event_flags) =0;
+
+  ///
+  // Cancel context menu display.
+  ///
+  /*--cef()--*/
+  virtual void Cancel() =0;
+};
+
+
+///
+// Implement this interface to handle context menu events. The methods of this
+// class will be called on the UI thread.
+///
+/*--cef(source=client)--*/
+class CefContextMenuHandler : public virtual CefBase {
+ public:
+  typedef cef_event_flags_t EventFlags;
+
+  ///
+  // Called before a context menu is displayed. |params| provides information
+  // about the context menu state. |model| initially contains the default
+  // context menu. The |model| can be cleared to show no context menu or
+  // modified to show a custom menu. Do not keep references to |params| or
+  // |model| outside of this callback.
+  ///
+  /*--cef()--*/
+  virtual void OnBeforeContextMenu(CefRefPtr<CefBrowser> browser,
+                                   CefRefPtr<CefFrame> frame,
+                                   CefRefPtr<CefContextMenuParams> params,
+                                   CefRefPtr<CefMenuModel> model) {}
+
+  ///
+  // Called to allow custom display of the context menu. |params| provides
+  // information about the context menu state. |model| contains the context menu
+  // model resulting from OnBeforeContextMenu. For custom display return true
+  // and execute |callback| either synchronously or asynchronously with the
+  // selected command ID. For default display return false. Do not keep
+  // references to |params| or |model| outside of this callback.
+  ///
+  /*--cef()--*/
+  virtual bool RunContextMenu(CefRefPtr<CefBrowser> browser,
+                              CefRefPtr<CefFrame> frame,
+                              CefRefPtr<CefContextMenuParams> params,
+                              CefRefPtr<CefMenuModel> model,
+                              CefRefPtr<CefRunContextMenuCallback> callback) {
+    return false;
+  }
+
+  ///
+  // Called to execute a command selected from the context menu. Return true if
+  // the command was handled or false for the default implementation. See
+  // cef_menu_id_t for the command ids that have default implementations. All
+  // user-defined command ids should be between MENU_ID_USER_FIRST and
+  // MENU_ID_USER_LAST. |params| will have the same values as what was passed to
+  // OnBeforeContextMenu(). Do not keep a reference to |params| outside of this
+  // callback.
+  ///
+  /*--cef()--*/
+  virtual bool OnContextMenuCommand(CefRefPtr<CefBrowser> browser,
+                                    CefRefPtr<CefFrame> frame,
+                                    CefRefPtr<CefContextMenuParams> params,
+                                    int command_id,
+                                    EventFlags event_flags) { return false; }
+
+  ///
+  // Called when the context menu is dismissed irregardless of whether the menu
+  // was empty or a command was selected.
+  ///
+  /*--cef()--*/
+  virtual void OnContextMenuDismissed(CefRefPtr<CefBrowser> browser,
+                                      CefRefPtr<CefFrame> frame) {}
+};
+
+
+///
+// Provides information about the context menu state. The ethods of this class
+// can only be accessed on browser process the UI thread.
+///
+/*--cef(source=library)--*/
+class CefContextMenuParams : public virtual CefBase {
+ public:
+  typedef cef_context_menu_type_flags_t TypeFlags;
+  typedef cef_context_menu_media_type_t MediaType;
+  typedef cef_context_menu_media_state_flags_t MediaStateFlags;
+  typedef cef_context_menu_edit_state_flags_t EditStateFlags;
+
+  ///
+  // Returns the X coordinate of the mouse where the context menu was invoked.
+  // Coords are relative to the associated RenderView's origin.
+  ///
+  /*--cef()--*/
+  virtual int GetXCoord() =0;
+
+  ///
+  // Returns the Y coordinate of the mouse where the context menu was invoked.
+  // Coords are relative to the associated RenderView's origin.
+  ///
+  /*--cef()--*/
+  virtual int GetYCoord() =0;
+
+  ///
+  // Returns flags representing the type of node that the context menu was
+  // invoked on.
+  ///
+  /*--cef(default_retval=CM_TYPEFLAG_NONE)--*/
+  virtual TypeFlags GetTypeFlags() =0;
+
+  ///
+  // Returns the URL of the link, if any, that encloses the node that the
+  // context menu was invoked on.
+  ///
+  /*--cef()--*/
+  virtual CefString GetLinkUrl() =0;
+
+  ///
+  // Returns the link URL, if any, to be used ONLY for "copy link address". We
+  // don't validate this field in the frontend process.
+  ///
+  /*--cef()--*/
+  virtual CefString GetUnfilteredLinkUrl() =0;
+
+  ///
+  // Returns the source URL, if any, for the element that the context menu was
+  // invoked on. Example of elements with source URLs are img, audio, and video.
+  ///
+  /*--cef()--*/
+  virtual CefString GetSourceUrl() =0;
+
+  ///
+  // Returns true if the context menu was invoked on an image which has
+  // non-empty contents.
+  ///
+  /*--cef()--*/
+  virtual bool HasImageContents() =0;
+
+  ///
+  // Returns the URL of the top level page that the context menu was invoked on.
+  ///
+  /*--cef()--*/
+  virtual CefString GetPageUrl() =0;
+
+  ///
+  // Returns the URL of the subframe that the context menu was invoked on.
+  ///
+  /*--cef()--*/
+  virtual CefString GetFrameUrl() =0;
+
+  ///
+  // Returns the character encoding of the subframe that the context menu was
+  // invoked on.
+  ///
+  /*--cef()--*/
+  virtual CefString GetFrameCharset() =0;
+
+  ///
+  // Returns the type of context node that the context menu was invoked on.
+  ///
+  /*--cef(default_retval=CM_MEDIATYPE_NONE)--*/
+  virtual MediaType GetMediaType() =0;
+
+  ///
+  // Returns flags representing the actions supported by the media element, if
+  // any, that the context menu was invoked on.
+  ///
+  /*--cef(default_retval=CM_MEDIAFLAG_NONE)--*/
+  virtual MediaStateFlags GetMediaStateFlags() =0;
+
+  ///
+  // Returns the text of the selection, if any, that the context menu was
+  // invoked on.
+  ///
+  /*--cef()--*/
+  virtual CefString GetSelectionText() =0;
+
+  ///
+  // Returns the text of the misspelled word, if any, that the context menu was
+  // invoked on.
+  ///
+  /*--cef()--*/
+  virtual CefString GetMisspelledWord() =0;
+
+  ///
+  // Returns true if suggestions exist, false otherwise. Fills in |suggestions|
+  // from the spell check service for the misspelled word if there is one.
+  ///
+  /*--cef()--*/
+  virtual bool GetDictionarySuggestions(std::vector<CefString>& suggestions) =0;
+
+  ///
+  // Returns true if the context menu was invoked on an editable node.
+  ///
+  /*--cef()--*/
+  virtual bool IsEditable() =0;
+
+  ///
+  // Returns true if the context menu was invoked on an editable node where
+  // spell-check is enabled.
+  ///
+  /*--cef()--*/
+  virtual bool IsSpellCheckEnabled() =0;
+
+  ///
+  // Returns flags representing the actions supported by the editable node, if
+  // any, that the context menu was invoked on.
+  ///
+  /*--cef(default_retval=CM_EDITFLAG_NONE)--*/
+  virtual EditStateFlags GetEditStateFlags() =0;
+
+  ///
+  // Returns true if the context menu contains items specified by the renderer
+  // process (for example, plugin placeholder or pepper plugin menu items).
+  ///
+  /*--cef()--*/
+  virtual bool IsCustomMenu() =0;
+
+  ///
+  // Returns true if the context menu was invoked from a pepper plugin.
+  ///
+  /*--cef()--*/
+  virtual bool IsPepperMenu() =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_CONTEXT_MENU_HANDLER_H_
diff --git a/src/include/libcef/cef_cookie.h b/src/include/libcef/cef_cookie.h
new file mode 100644
index 0000000..b4cb33c
--- /dev/null
+++ b/src/include/libcef/cef_cookie.h
@@ -0,0 +1,220 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_COOKIE_H_
+#define CEF_INCLUDE_CEF_COOKIE_H_
+#pragma once
+
+#include "include/cef_base.h"
+#include "include/cef_callback.h"
+#include <vector>
+
+class CefCookieVisitor;
+class CefSetCookieCallback;
+class CefDeleteCookiesCallback;
+
+///
+// Class used for managing cookies. The methods of this class may be called on
+// any thread unless otherwise indicated.
+///
+/*--cef(source=library,no_debugct_check)--*/
+class CefCookieManager : public virtual CefBase {
+ public:
+  ///
+  // Returns the global cookie manager. By default data will be stored at
+  // CefSettings.cache_path if specified or in memory otherwise. If |callback|
+  // is non-NULL it will be executed asnychronously on the IO thread after the
+  // manager's storage has been initialized. Using this method is equivalent to
+  // calling CefRequestContext::GetGlobalContext()->GetDefaultCookieManager().
+  ///
+  /*--cef(optional_param=callback)--*/
+  static CefRefPtr<CefCookieManager> GetGlobalManager(
+      CefRefPtr<CefCompletionCallback> callback);
+
+  ///
+  // Creates a new cookie manager. If |path| is empty data will be stored in
+  // memory only. Otherwise, data will be stored at the specified |path|. To
+  // persist session cookies (cookies without an expiry date or validity
+  // interval) set |persist_session_cookies| to true. Session cookies are
+  // generally intended to be transient and most Web browsers do not persist
+  // them. If |callback| is non-NULL it will be executed asnychronously on the
+  // IO thread after the manager's storage has been initialized.
+  ///
+  /*--cef(optional_param=path,optional_param=callback)--*/
+  static CefRefPtr<CefCookieManager> CreateManager(
+      const CefString& path,
+      bool persist_session_cookies,
+      CefRefPtr<CefCompletionCallback> callback);
+
+  ///
+  // Set the schemes supported by this manager. The default schemes ("http",
+  // "https", "ws" and "wss") will always be supported. If |callback| is non-
+  // NULL it will be executed asnychronously on the IO thread after the change
+  // has been applied. Must be called before any cookies are accessed.
+  ///
+  /*--cef(optional_param=callback)--*/
+  virtual void SetSupportedSchemes(
+      const std::vector<CefString>& schemes,
+      CefRefPtr<CefCompletionCallback> callback) =0;
+
+  ///
+  // Visit all cookies on the IO thread. The returned cookies are ordered by
+  // longest path, then by earliest creation date. Returns false if cookies
+  // cannot be accessed.
+  ///
+  /*--cef()--*/
+  virtual bool VisitAllCookies(CefRefPtr<CefCookieVisitor> visitor) =0;
+
+  ///
+  // Visit a subset of cookies on the IO thread. The results are filtered by the
+  // given url scheme, host, domain and path. If |includeHttpOnly| is true
+  // HTTP-only cookies will also be included in the results. The returned
+  // cookies are ordered by longest path, then by earliest creation date.
+  // Returns false if cookies cannot be accessed.
+  ///
+  /*--cef()--*/
+  virtual bool VisitUrlCookies(const CefString& url,
+                               bool includeHttpOnly,
+                               CefRefPtr<CefCookieVisitor> visitor) =0;
+
+  ///
+  // Sets a cookie given a valid URL and explicit user-provided cookie
+  // attributes. This function expects each attribute to be well-formed. It will
+  // check for disallowed characters (e.g. the ';' character is disallowed
+  // within the cookie value attribute) and fail without setting the cookie if
+  // such characters are found. If |callback| is non-NULL it will be executed
+  // asnychronously on the IO thread after the cookie has been set. Returns
+  // false if an invalid URL is specified or if cookies cannot be accessed.
+  ///
+  /*--cef(optional_param=callback)--*/
+  virtual bool SetCookie(const CefString& url,
+                         const CefCookie& cookie,
+                         CefRefPtr<CefSetCookieCallback> callback) =0;
+
+  ///
+  // Delete all cookies that match the specified parameters. If both |url| and
+  // |cookie_name| values are specified all host and domain cookies matching
+  // both will be deleted. If only |url| is specified all host cookies (but not
+  // domain cookies) irrespective of path will be deleted. If |url| is empty all
+  // cookies for all hosts and domains will be deleted. If |callback| is
+  // non-NULL it will be executed asnychronously on the IO thread after the
+  // cookies have been deleted. Returns false if a non-empty invalid URL is
+  // specified or if cookies cannot be accessed. Cookies can alternately be
+  // deleted using the Visit*Cookies() methods.
+  ///
+  /*--cef(optional_param=url,optional_param=cookie_name,
+          optional_param=callback)--*/
+  virtual bool DeleteCookies(const CefString& url,
+                             const CefString& cookie_name,
+                             CefRefPtr<CefDeleteCookiesCallback> callback) =0;
+
+  ///
+  // Sets the directory path that will be used for storing cookie data. If
+  // |path| is empty data will be stored in memory only. Otherwise, data will be
+  // stored at the specified |path|. To persist session cookies (cookies without
+  // an expiry date or validity interval) set |persist_session_cookies| to true.
+  // Session cookies are generally intended to be transient and most Web
+  // browsers do not persist them. If |callback| is non-NULL it will be executed
+  // asnychronously on the IO thread after the manager's storage has been
+  // initialized. Returns false if cookies cannot be accessed.
+  ///
+  /*--cef(optional_param=path,optional_param=callback)--*/
+  virtual bool SetStoragePath(const CefString& path,
+                              bool persist_session_cookies,
+                              CefRefPtr<CefCompletionCallback> callback) =0;
+
+  ///
+  // Flush the backing store (if any) to disk. If |callback| is non-NULL it will
+  // be executed asnychronously on the IO thread after the flush is complete.
+  // Returns false if cookies cannot be accessed.
+  ///
+  /*--cef(optional_param=callback)--*/
+  virtual bool FlushStore(CefRefPtr<CefCompletionCallback> callback) =0;
+};
+
+
+///
+// Interface to implement for visiting cookie values. The methods of this class
+// will always be called on the IO thread.
+///
+/*--cef(source=client)--*/
+class CefCookieVisitor : public virtual CefBase {
+ public:
+  ///
+  // Method that will be called once for each cookie. |count| is the 0-based
+  // index for the current cookie. |total| is the total number of cookies.
+  // Set |deleteCookie| to true to delete the cookie currently being visited.
+  // Return false to stop visiting cookies. This method may never be called if
+  // no cookies are found.
+  ///
+  /*--cef()--*/
+  virtual bool Visit(const CefCookie& cookie, int count, int total,
+                     bool& deleteCookie) =0;
+};
+
+
+///
+// Interface to implement to be notified of asynchronous completion via
+// CefCookieManager::SetCookie().
+///
+/*--cef(source=client)--*/
+class CefSetCookieCallback : public virtual CefBase {
+ public:
+  ///
+  // Method that will be called upon completion. |success| will be true if the
+  // cookie was set successfully.
+  ///
+  /*--cef()--*/
+  virtual void OnComplete(bool success) =0;
+};
+
+
+///
+// Interface to implement to be notified of asynchronous completion via
+// CefCookieManager::DeleteCookies().
+///
+/*--cef(source=client)--*/
+class CefDeleteCookiesCallback : public virtual CefBase {
+ public:
+  ///
+  // Method that will be called upon completion. |num_deleted| will be the
+  // number of cookies that were deleted or -1 if unknown.
+  ///
+  /*--cef()--*/
+  virtual void OnComplete(int num_deleted) =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_COOKIE_H_
diff --git a/src/include/libcef/cef_dialog_handler.h b/src/include/libcef/cef_dialog_handler.h
new file mode 100644
index 0000000..93cd5de
--- /dev/null
+++ b/src/include/libcef/cef_dialog_handler.h
@@ -0,0 +1,107 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_DIALOG_HANDLER_H_
+#define CEF_INCLUDE_CEF_DIALOG_HANDLER_H_
+#pragma once
+
+#include "include/cef_base.h"
+#include "include/cef_browser.h"
+
+///
+// Callback interface for asynchronous continuation of file dialog requests.
+///
+/*--cef(source=library)--*/
+class CefFileDialogCallback : public virtual CefBase {
+ public:
+  ///
+  // Continue the file selection. |selected_accept_filter| should be the 0-based
+  // index of the value selected from the accept filters array passed to
+  // CefDialogHandler::OnFileDialog. |file_paths| should be a single value or a
+  // list of values depending on the dialog mode. An empty |file_paths| value is
+  // treated the same as calling Cancel().
+  ///
+  /*--cef(capi_name=cont,index_param=selected_accept_filter,
+          optional_param=file_paths)--*/
+  virtual void Continue(int selected_accept_filter,
+                        const std::vector<CefString>& file_paths) =0;
+
+  ///
+  // Cancel the file selection.
+  ///
+  /*--cef()--*/
+  virtual void Cancel() =0;
+};
+
+
+///
+// Implement this interface to handle dialog events. The methods of this class
+// will be called on the browser process UI thread.
+///
+/*--cef(source=client)--*/
+class CefDialogHandler : public virtual CefBase {
+ public:
+  typedef cef_file_dialog_mode_t FileDialogMode;
+
+  ///
+  // Called to run a file chooser dialog. |mode| represents the type of dialog
+  // to display. |title| to the title to be used for the dialog and may be empty
+  // to show the default title ("Open" or "Save" depending on the mode).
+  // |default_file_path| is the path with optional directory and/or file name
+  // component that should be initially selected in the dialog. |accept_filters|
+  // are used to restrict the selectable file types and may any combination of
+  // (a) valid lower-cased MIME types (e.g. "text/*" or "image/*"),
+  // (b) individual file extensions (e.g. ".txt" or ".png"), or (c) combined
+  // description and file extension delimited using "|" and ";" (e.g.
+  // "Image Types|.png;.gif;.jpg"). |selected_accept_filter| is the 0-based
+  // index of the filter that should be selected by default. To display a custom
+  // dialog return true and execute |callback| either inline or at a later time.
+  // To display the default dialog return false.
+  ///
+  /*--cef(optional_param=title,optional_param=default_file_path,
+          optional_param=accept_filters,index_param=selected_accept_filter)--*/
+  virtual bool OnFileDialog(CefRefPtr<CefBrowser> browser,
+                            FileDialogMode mode,
+                            const CefString& title,
+                            const CefString& default_file_path,
+                            const std::vector<CefString>& accept_filters,
+                            int selected_accept_filter,
+                            CefRefPtr<CefFileDialogCallback> callback) {
+    return false;
+  }
+};
+
+#endif  // CEF_INCLUDE_CEF_DIALOG_HANDLER_H_
diff --git a/src/include/libcef/cef_display_handler.h b/src/include/libcef/cef_display_handler.h
new file mode 100644
index 0000000..3f06461
--- /dev/null
+++ b/src/include/libcef/cef_display_handler.h
@@ -0,0 +1,116 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_DISPLAY_HANDLER_H_
+#define CEF_INCLUDE_CEF_DISPLAY_HANDLER_H_
+#pragma once
+
+#include "include/cef_base.h"
+#include "include/cef_browser.h"
+#include "include/cef_frame.h"
+
+///
+// Implement this interface to handle events related to browser display state.
+// The methods of this class will be called on the UI thread.
+///
+/*--cef(source=client)--*/
+class CefDisplayHandler : public virtual CefBase {
+ public:
+  ///
+  // Called when a frame's address has changed.
+  ///
+  /*--cef()--*/
+  virtual void OnAddressChange(CefRefPtr<CefBrowser> browser,
+                               CefRefPtr<CefFrame> frame,
+                               const CefString& url) {}
+
+  ///
+  // Called when the page title changes.
+  ///
+  /*--cef(optional_param=title)--*/
+  virtual void OnTitleChange(CefRefPtr<CefBrowser> browser,
+                             const CefString& title) {}
+
+  ///
+  // Called when the page icon changes.
+  ///
+  /*--cef(optional_param=icon_urls)--*/
+  virtual void OnFaviconURLChange(CefRefPtr<CefBrowser> browser,
+                                  const std::vector<CefString>& icon_urls) {}
+
+  ///
+  // Called when web content in the page has toggled fullscreen mode. If
+  // |fullscreen| is true the content will automatically be sized to fill the
+  // browser content area. If |fullscreen| is false the content will
+  // automatically return to its original size and position. The client is
+  // responsible for resizing the browser if desired.
+  ///
+  /*--cef()--*/
+  virtual void OnFullscreenModeChange(CefRefPtr<CefBrowser> browser,
+                                      bool fullscreen) {}
+
+  ///
+  // Called when the browser is about to display a tooltip. |text| contains the
+  // text that will be displayed in the tooltip. To handle the display of the
+  // tooltip yourself return true. Otherwise, you can optionally modify |text|
+  // and then return false to allow the browser to display the tooltip.
+  // When window rendering is disabled the application is responsible for
+  // drawing tooltips and the return value is ignored.
+  ///
+  /*--cef(optional_param=text)--*/
+  virtual bool OnTooltip(CefRefPtr<CefBrowser> browser,
+                         CefString& text) { return false; }
+
+  ///
+  // Called when the browser receives a status message. |value| contains the
+  // text that will be displayed in the status message.
+  ///
+  /*--cef(optional_param=value)--*/
+  virtual void OnStatusMessage(CefRefPtr<CefBrowser> browser,
+                               const CefString& value) {}
+
+  ///
+  // Called to display a console message. Return true to stop the message from
+  // being output to the console.
+  ///
+  /*--cef(optional_param=message,optional_param=source)--*/
+  virtual bool OnConsoleMessage(CefRefPtr<CefBrowser> browser,
+                                const CefString& message,
+                                const CefString& source,
+                                int line) { return false; }
+};
+
+#endif  // CEF_INCLUDE_CEF_DISPLAY_HANDLER_H_
diff --git a/src/include/libcef/cef_dom.h b/src/include/libcef/cef_dom.h
new file mode 100644
index 0000000..9f9a3d5
--- /dev/null
+++ b/src/include/libcef/cef_dom.h
@@ -0,0 +1,328 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_DOM_H_
+#define CEF_INCLUDE_CEF_DOM_H_
+#pragma once
+
+#include "include/cef_base.h"
+#include <map>
+
+class CefDOMDocument;
+class CefDOMNode;
+
+///
+// Interface to implement for visiting the DOM. The methods of this class will
+// be called on the render process main thread.
+///
+/*--cef(source=client)--*/
+class CefDOMVisitor : public virtual CefBase {
+ public:
+  ///
+  // Method executed for visiting the DOM. The document object passed to this
+  // method represents a snapshot of the DOM at the time this method is
+  // executed. DOM objects are only valid for the scope of this method. Do not
+  // keep references to or attempt to access any DOM objects outside the scope
+  // of this method.
+  ///
+  /*--cef()--*/
+  virtual void Visit(CefRefPtr<CefDOMDocument> document) =0;
+};
+
+
+///
+// Class used to represent a DOM document. The methods of this class should only
+// be called on the render process main thread thread.
+///
+/*--cef(source=library)--*/
+class CefDOMDocument : public virtual CefBase {
+ public:
+  typedef cef_dom_document_type_t Type;
+
+  ///
+  // Returns the document type.
+  ///
+  /*--cef(default_retval=DOM_DOCUMENT_TYPE_UNKNOWN)--*/
+  virtual Type GetType() =0;
+
+  ///
+  // Returns the root document node.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefDOMNode> GetDocument() =0;
+
+  ///
+  // Returns the BODY node of an HTML document.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefDOMNode> GetBody() =0;
+
+  ///
+  // Returns the HEAD node of an HTML document.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefDOMNode> GetHead() =0;
+
+  ///
+  // Returns the title of an HTML document.
+  ///
+  /*--cef()--*/
+  virtual CefString GetTitle() =0;
+
+  ///
+  // Returns the document element with the specified ID value.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefDOMNode> GetElementById(const CefString& id) =0;
+
+  ///
+  // Returns the node that currently has keyboard focus.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefDOMNode> GetFocusedNode() =0;
+
+  ///
+  // Returns true if a portion of the document is selected.
+  ///
+  /*--cef()--*/
+  virtual bool HasSelection() =0;
+
+  ///
+  // Returns the selection offset within the start node.
+  ///
+  /*--cef()--*/
+  virtual int GetSelectionStartOffset() =0;
+
+  ///
+  // Returns the selection offset within the end node.
+  ///
+  /*--cef()--*/
+  virtual int GetSelectionEndOffset() =0;
+
+  ///
+  // Returns the contents of this selection as markup.
+  ///
+  /*--cef()--*/
+  virtual CefString GetSelectionAsMarkup() =0;
+
+  ///
+  // Returns the contents of this selection as text.
+  ///
+  /*--cef()--*/
+  virtual CefString GetSelectionAsText() =0;
+
+  ///
+  // Returns the base URL for the document.
+  ///
+  /*--cef()--*/
+  virtual CefString GetBaseURL() =0;
+
+  ///
+  // Returns a complete URL based on the document base URL and the specified
+  // partial URL.
+  ///
+  /*--cef()--*/
+  virtual CefString GetCompleteURL(const CefString& partialURL) =0;
+};
+
+
+///
+// Class used to represent a DOM node. The methods of this class should only be
+// called on the render process main thread.
+///
+/*--cef(source=library)--*/
+class CefDOMNode : public virtual CefBase {
+ public:
+  typedef std::map<CefString, CefString> AttributeMap;
+  typedef cef_dom_node_type_t Type;
+
+  ///
+  // Returns the type for this node.
+  ///
+  /*--cef(default_retval=DOM_NODE_TYPE_UNSUPPORTED)--*/
+  virtual Type GetType() =0;
+
+  ///
+  // Returns true if this is a text node.
+  ///
+  /*--cef()--*/
+  virtual bool IsText() =0;
+
+  ///
+  // Returns true if this is an element node.
+  ///
+  /*--cef()--*/
+  virtual bool IsElement() =0;
+
+  ///
+  // Returns true if this is an editable node.
+  ///
+  /*--cef()--*/
+  virtual bool IsEditable() =0;
+
+  ///
+  // Returns true if this is a form control element node.
+  ///
+  /*--cef()--*/
+  virtual bool IsFormControlElement() =0;
+
+  ///
+  // Returns the type of this form control element node.
+  ///
+  /*--cef()--*/
+  virtual CefString GetFormControlElementType() =0;
+
+  ///
+  // Returns true if this object is pointing to the same handle as |that|
+  // object.
+  ///
+  /*--cef()--*/
+  virtual bool IsSame(CefRefPtr<CefDOMNode> that) =0;
+
+  ///
+  // Returns the name of this node.
+  ///
+  /*--cef()--*/
+  virtual CefString GetName() =0;
+
+  ///
+  // Returns the value of this node.
+  ///
+  /*--cef()--*/
+  virtual CefString GetValue() =0;
+
+  ///
+  // Set the value of this node. Returns true on success.
+  ///
+  /*--cef()--*/
+  virtual bool SetValue(const CefString& value) =0;
+
+  ///
+  // Returns the contents of this node as markup.
+  ///
+  /*--cef()--*/
+  virtual CefString GetAsMarkup() =0;
+
+  ///
+  // Returns the document associated with this node.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefDOMDocument> GetDocument() =0;
+
+  ///
+  // Returns the parent node.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefDOMNode> GetParent() =0;
+
+  ///
+  // Returns the previous sibling node.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefDOMNode> GetPreviousSibling() =0;
+
+  ///
+  // Returns the next sibling node.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefDOMNode> GetNextSibling() =0;
+
+  ///
+  // Returns true if this node has child nodes.
+  ///
+  /*--cef()--*/
+  virtual bool HasChildren() =0;
+
+  ///
+  // Return the first child node.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefDOMNode> GetFirstChild() =0;
+
+  ///
+  // Returns the last child node.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefDOMNode> GetLastChild() =0;
+
+  // The following methods are valid only for element nodes.
+
+  ///
+  // Returns the tag name of this element.
+  ///
+  /*--cef()--*/
+  virtual CefString GetElementTagName() =0;
+
+  ///
+  // Returns true if this element has attributes.
+  ///
+  /*--cef()--*/
+  virtual bool HasElementAttributes() =0;
+
+  ///
+  // Returns true if this element has an attribute named |attrName|.
+  ///
+  /*--cef()--*/
+  virtual bool HasElementAttribute(const CefString& attrName) =0;
+
+  ///
+  // Returns the element attribute named |attrName|.
+  ///
+  /*--cef()--*/
+  virtual CefString GetElementAttribute(const CefString& attrName) =0;
+
+  ///
+  // Returns a map of all element attributes.
+  ///
+  /*--cef()--*/
+  virtual void GetElementAttributes(AttributeMap& attrMap) =0;
+
+  ///
+  // Set the value for the element attribute named |attrName|. Returns true on
+  // success.
+  ///
+  /*--cef()--*/
+  virtual bool SetElementAttribute(const CefString& attrName,
+                                   const CefString& value) =0;
+
+  ///
+  // Returns the inner text of the element.
+  ///
+  /*--cef()--*/
+  virtual CefString GetElementInnerText() =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_DOM_H_
diff --git a/src/include/libcef/cef_download_handler.h b/src/include/libcef/cef_download_handler.h
new file mode 100644
index 0000000..4f58af4
--- /dev/null
+++ b/src/include/libcef/cef_download_handler.h
@@ -0,0 +1,124 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_DOWNLOAD_HANDLER_H_
+#define CEF_INCLUDE_CEF_DOWNLOAD_HANDLER_H_
+#pragma once
+
+#include "include/cef_base.h"
+#include "include/cef_browser.h"
+#include "include/cef_download_item.h"
+
+
+///
+// Callback interface used to asynchronously continue a download.
+///
+/*--cef(source=library)--*/
+class CefBeforeDownloadCallback : public virtual CefBase {
+ public:
+  ///
+  // Call to continue the download. Set |download_path| to the full file path
+  // for the download including the file name or leave blank to use the
+  // suggested name and the default temp directory. Set |show_dialog| to true
+  // if you do wish to show the default "Save As" dialog.
+  ///
+  /*--cef(capi_name=cont,optional_param=download_path)--*/
+  virtual void Continue(const CefString& download_path, bool show_dialog) =0;
+};
+
+
+///
+// Callback interface used to asynchronously cancel a download.
+///
+/*--cef(source=library)--*/
+class CefDownloadItemCallback : public virtual CefBase {
+ public:
+  ///
+  // Call to cancel the download.
+  ///
+  /*--cef()--*/
+  virtual void Cancel() =0;
+
+  ///
+  // Call to pause the download.
+  ///
+  /*--cef()--*/
+  virtual void Pause() =0;
+
+  ///
+  // Call to resume the download.
+  ///
+  /*--cef()--*/
+  virtual void Resume() =0;
+};
+
+
+///
+// Class used to handle file downloads. The methods of this class will called
+// on the browser process UI thread.
+///
+/*--cef(source=client)--*/
+class CefDownloadHandler : public virtual CefBase {
+ public:
+  ///
+  // Called before a download begins. |suggested_name| is the suggested name for
+  // the download file. By default the download will be canceled. Execute
+  // |callback| either asynchronously or in this method to continue the download
+  // if desired. Do not keep a reference to |download_item| outside of this
+  // method.
+  ///
+  /*--cef()--*/
+  virtual void OnBeforeDownload(
+      CefRefPtr<CefBrowser> browser,
+      CefRefPtr<CefDownloadItem> download_item,
+      const CefString& suggested_name,
+      CefRefPtr<CefBeforeDownloadCallback> callback) =0;
+
+  ///
+  // Called when a download's status or progress information has been updated.
+  // This may be called multiple times before and after OnBeforeDownload().
+  // Execute |callback| either asynchronously or in this method to cancel the
+  // download if desired. Do not keep a reference to |download_item| outside of
+  // this method.
+  ///
+  /*--cef()--*/
+  virtual void OnDownloadUpdated(
+      CefRefPtr<CefBrowser> browser,
+      CefRefPtr<CefDownloadItem> download_item,
+      CefRefPtr<CefDownloadItemCallback> callback) {}
+};
+
+#endif  // CEF_INCLUDE_CEF_DOWNLOAD_HANDLER_H_
diff --git a/src/include/libcef/cef_download_item.h b/src/include/libcef/cef_download_item.h
new file mode 100644
index 0000000..988ef6b
--- /dev/null
+++ b/src/include/libcef/cef_download_item.h
@@ -0,0 +1,154 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_DOWNLOAD_ITEM_H_
+#define CEF_INCLUDE_CEF_DOWNLOAD_ITEM_H_
+#pragma once
+
+#include "include/cef_base.h"
+
+///
+// Class used to represent a download item.
+///
+/*--cef(source=library)--*/
+class CefDownloadItem : public virtual CefBase {
+ public:
+  ///
+  // Returns true if this object is valid. Do not call any other methods if this
+  // function returns false.
+  ///
+  /*--cef()--*/
+  virtual bool IsValid() =0;
+
+  ///
+  // Returns true if the download is in progress.
+  ///
+  /*--cef()--*/
+  virtual bool IsInProgress() =0;
+
+  ///
+  // Returns true if the download is complete.
+  ///
+  /*--cef()--*/
+  virtual bool IsComplete() =0;
+
+  ///
+  // Returns true if the download has been canceled or interrupted.
+  ///
+  /*--cef()--*/
+  virtual bool IsCanceled() =0;
+
+  ///
+  // Returns a simple speed estimate in bytes/s.
+  ///
+  /*--cef()--*/
+  virtual int64 GetCurrentSpeed() =0;
+
+  ///
+  // Returns the rough percent complete or -1 if the receive total size is
+  // unknown.
+  ///
+  /*--cef()--*/
+  virtual int GetPercentComplete() =0;
+
+  ///
+  // Returns the total number of bytes.
+  ///
+  /*--cef()--*/
+  virtual int64 GetTotalBytes() =0;
+
+  ///
+  // Returns the number of received bytes.
+  ///
+  /*--cef()--*/
+  virtual int64 GetReceivedBytes() =0;
+
+  ///
+  // Returns the time that the download started.
+  ///
+  /*--cef()--*/
+  virtual CefTime GetStartTime() =0;
+
+  ///
+  // Returns the time that the download ended.
+  ///
+  /*--cef()--*/
+  virtual CefTime GetEndTime() =0;
+
+  ///
+  // Returns the full path to the downloaded or downloading file.
+  ///
+  /*--cef()--*/
+  virtual CefString GetFullPath() =0;
+
+  ///
+  // Returns the unique identifier for this download.
+  ///
+  /*--cef()--*/
+  virtual uint32 GetId() =0;
+
+  ///
+  // Returns the URL.
+  ///
+  /*--cef()--*/
+  virtual CefString GetURL() =0;
+
+  ///
+  // Returns the original URL before any redirections.
+  ///
+  /*--cef()--*/
+  virtual CefString GetOriginalUrl() =0;
+
+  ///
+  // Returns the suggested file name.
+  ///
+  /*--cef()--*/
+  virtual CefString GetSuggestedFileName() =0;
+
+  ///
+  // Returns the content disposition.
+  ///
+  /*--cef()--*/
+  virtual CefString GetContentDisposition() =0;
+
+  ///
+  // Returns the mime type.
+  ///
+  /*--cef()--*/
+  virtual CefString GetMimeType() =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_DOWNLOAD_ITEM_H_
diff --git a/src/include/libcef/cef_drag_data.h b/src/include/libcef/cef_drag_data.h
new file mode 100644
index 0000000..8f8094b
--- /dev/null
+++ b/src/include/libcef/cef_drag_data.h
@@ -0,0 +1,198 @@
+// Copyright (c) 2013 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_DRAG_DATA_H_
+#define CEF_INCLUDE_CEF_DRAG_DATA_H_
+#pragma once
+
+#include "include/cef_base.h"
+#include "include/cef_stream.h"
+#include <vector>
+
+///
+// Class used to represent drag data. The methods of this class may be called
+// on any thread.
+///
+/*--cef(source=library)--*/
+class CefDragData : public virtual CefBase {
+ public:
+  ///
+  // Create a new CefDragData object.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefDragData> Create();
+
+  ///
+  // Returns a copy of the current object.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefDragData> Clone() =0;
+
+  ///
+  // Returns true if this object is read-only.
+  ///
+  /*--cef()--*/
+  virtual bool IsReadOnly() =0;
+
+  ///
+  // Returns true if the drag data is a link.
+  ///
+  /*--cef()--*/
+  virtual bool IsLink() =0;
+
+  ///
+  // Returns true if the drag data is a text or html fragment.
+  ///
+  /*--cef()--*/
+  virtual bool IsFragment() =0;
+
+  ///
+  // Returns true if the drag data is a file.
+  ///
+  /*--cef()--*/
+  virtual bool IsFile() =0;
+
+  ///
+  // Return the link URL that is being dragged.
+  ///
+  /*--cef()--*/
+  virtual CefString GetLinkURL() =0;
+
+  ///
+  // Return the title associated with the link being dragged.
+  ///
+  /*--cef()--*/
+  virtual CefString GetLinkTitle() =0;
+
+  ///
+  // Return the metadata, if any, associated with the link being dragged.
+  ///
+  /*--cef()--*/
+  virtual CefString GetLinkMetadata() =0;
+
+  ///
+  // Return the plain text fragment that is being dragged.
+  ///
+  /*--cef()--*/
+  virtual CefString GetFragmentText() =0;
+
+  ///
+  // Return the text/html fragment that is being dragged.
+  ///
+  /*--cef()--*/
+  virtual CefString GetFragmentHtml() =0;
+
+  ///
+  // Return the base URL that the fragment came from. This value is used for
+  // resolving relative URLs and may be empty.
+  ///
+  /*--cef()--*/
+  virtual CefString GetFragmentBaseURL() =0;
+
+  ///
+  // Return the name of the file being dragged out of the browser window.
+  ///
+  /*--cef()--*/
+  virtual CefString GetFileName() =0;
+
+  ///
+  // Write the contents of the file being dragged out of the web view into
+  // |writer|. Returns the number of bytes sent to |writer|. If |writer| is
+  // NULL this method will return the size of the file contents in bytes.
+  // Call GetFileName() to get a suggested name for the file.
+  ///
+  /*--cef(optional_param=writer)--*/
+  virtual size_t GetFileContents(CefRefPtr<CefStreamWriter> writer) =0;
+
+  ///
+  // Retrieve the list of file names that are being dragged into the browser
+  // window.
+  ///
+  /*--cef()--*/
+  virtual bool GetFileNames(std::vector<CefString>& names) =0;
+
+  ///
+  // Set the link URL that is being dragged.
+  ///
+  /*--cef(optional_param=url)--*/
+  virtual void SetLinkURL(const CefString& url) =0;
+
+  ///
+  // Set the title associated with the link being dragged.
+  ///
+  /*--cef(optional_param=title)--*/
+  virtual void SetLinkTitle(const CefString& title) =0;
+
+  ///
+  // Set the metadata associated with the link being dragged.
+  ///
+  /*--cef(optional_param=data)--*/
+  virtual void SetLinkMetadata(const CefString& data) =0;
+
+  ///
+  // Set the plain text fragment that is being dragged.
+  ///
+  /*--cef(optional_param=text)--*/
+  virtual void SetFragmentText(const CefString& text) =0;
+
+  ///
+  // Set the text/html fragment that is being dragged.
+  ///
+  /*--cef(optional_param=html)--*/
+  virtual void SetFragmentHtml(const CefString& html) =0;
+
+  ///
+  // Set the base URL that the fragment came from.
+  ///
+  /*--cef(optional_param=base_url)--*/
+  virtual void SetFragmentBaseURL(const CefString& base_url) =0;
+
+  ///
+  // Reset the file contents. You should do this before calling
+  // CefBrowserHost::DragTargetDragEnter as the web view does not allow us to
+  // drag in this kind of data.
+  ///
+  /*--cef()--*/
+  virtual void ResetFileContents() =0;
+
+  ///
+  // Add a file that is being dragged into the webview.
+  ///
+  /*--cef(optional_param=display_name)--*/
+  virtual void AddFile(const CefString& path, const CefString& display_name) =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_DRAG_DATA_H_
diff --git a/src/include/libcef/cef_drag_handler.h b/src/include/libcef/cef_drag_handler.h
new file mode 100644
index 0000000..3e26f97
--- /dev/null
+++ b/src/include/libcef/cef_drag_handler.h
@@ -0,0 +1,78 @@
+// Copyright (c) 2013 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_DRAG_HANDLER_H_
+#define CEF_INCLUDE_CEF_DRAG_HANDLER_H_
+#pragma once
+
+#include "include/cef_base.h"
+#include "include/cef_drag_data.h"
+#include "include/cef_browser.h"
+
+///
+// Implement this interface to handle events related to dragging. The methods of
+// this class will be called on the UI thread.
+///
+/*--cef(source=client)--*/
+class CefDragHandler : public virtual CefBase {
+ public:
+  typedef cef_drag_operations_mask_t DragOperationsMask;
+
+  ///
+  // Called when an external drag event enters the browser window. |dragData|
+  // contains the drag event data and |mask| represents the type of drag
+  // operation. Return false for default drag handling behavior or true to
+  // cancel the drag event.
+  ///
+  /*--cef()--*/
+  virtual bool OnDragEnter(CefRefPtr<CefBrowser> browser,
+                           CefRefPtr<CefDragData> dragData,
+                           DragOperationsMask mask) { return false; }
+
+  ///
+  // Called whenever draggable regions for the browser window change. These can
+  // be specified using the '-webkit-app-region: drag/no-drag' CSS-property. If
+  // draggable regions are never defined in a document this method will also
+  // never be called. If the last draggable region is removed from a document
+  // this method will be called with an empty vector.
+  ///
+  /*--cef()--*/
+  virtual void OnDraggableRegionsChanged(
+      CefRefPtr<CefBrowser> browser,
+      const std::vector<CefDraggableRegion>& regions) {}
+};
+
+#endif  // CEF_INCLUDE_CEF_DRAG_HANDLER_H_
diff --git a/src/include/libcef/cef_find_handler.h b/src/include/libcef/cef_find_handler.h
new file mode 100644
index 0000000..410cf5f
--- /dev/null
+++ b/src/include/libcef/cef_find_handler.h
@@ -0,0 +1,68 @@
+// Copyright (c) 2015 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_FIND_HANDLER_H_
+#define CEF_INCLUDE_CEF_FIND_HANDLER_H_
+#pragma once
+
+#include "include/cef_base.h"
+#include "include/cef_browser.h"
+
+///
+// Implement this interface to handle events related to find results. The
+// methods of this class will be called on the UI thread.
+///
+/*--cef(source=client)--*/
+class CefFindHandler : public virtual CefBase {
+ public:
+  ///
+  // Called to report find results returned by CefBrowserHost::Find().
+  // |identifer| is the identifier passed to Find(), |count| is the number of
+  // matches currently identified, |selectionRect| is the location of where the
+  // match was found (in window coordinates), |activeMatchOrdinal| is the
+  // current position in the search results, and |finalUpdate| is true if this
+  // is the last find notification.
+  ///
+  /*--cef()--*/
+  virtual void OnFindResult(CefRefPtr<CefBrowser> browser,
+                            int identifier,
+                            int count,
+                            const CefRect& selectionRect,
+                            int activeMatchOrdinal,
+                            bool finalUpdate) {}
+};
+
+#endif  // CEF_INCLUDE_CEF_FIND_HANDLER_H_
diff --git a/src/include/libcef/cef_focus_handler.h b/src/include/libcef/cef_focus_handler.h
new file mode 100644
index 0000000..1d91c42
--- /dev/null
+++ b/src/include/libcef/cef_focus_handler.h
@@ -0,0 +1,81 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_FOCUS_HANDLER_H_
+#define CEF_INCLUDE_CEF_FOCUS_HANDLER_H_
+#pragma once
+
+#include "include/cef_base.h"
+#include "include/cef_browser.h"
+#include "include/cef_dom.h"
+#include "include/cef_frame.h"
+
+///
+// Implement this interface to handle events related to focus. The methods of
+// this class will be called on the UI thread.
+///
+/*--cef(source=client)--*/
+class CefFocusHandler : public virtual CefBase {
+ public:
+  typedef cef_focus_source_t FocusSource;
+
+  ///
+  // Called when the browser component is about to loose focus. For instance, if
+  // focus was on the last HTML element and the user pressed the TAB key. |next|
+  // will be true if the browser is giving focus to the next component and false
+  // if the browser is giving focus to the previous component.
+  ///
+  /*--cef()--*/
+  virtual void OnTakeFocus(CefRefPtr<CefBrowser> browser,
+                           bool next) {}
+
+  ///
+  // Called when the browser component is requesting focus. |source| indicates
+  // where the focus request is originating from. Return false to allow the
+  // focus to be set or true to cancel setting the focus.
+  ///
+  /*--cef()--*/
+  virtual bool OnSetFocus(CefRefPtr<CefBrowser> browser,
+                          FocusSource source) { return false; }
+
+  ///
+  // Called when the browser component has received focus.
+  ///
+  /*--cef()--*/
+  virtual void OnGotFocus(CefRefPtr<CefBrowser> browser) {}
+};
+
+#endif  // CEF_INCLUDE_CEF_FOCUS_HANDLER_H_
diff --git a/src/include/libcef/cef_frame.h b/src/include/libcef/cef_frame.h
new file mode 100644
index 0000000..1ea172f
--- /dev/null
+++ b/src/include/libcef/cef_frame.h
@@ -0,0 +1,225 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_FRAME_H_
+#define CEF_INCLUDE_CEF_FRAME_H_
+#pragma once
+
+#include "include/cef_base.h"
+#include "include/cef_dom.h"
+#include "include/cef_request.h"
+#include "include/cef_stream.h"
+#include "include/cef_string_visitor.h"
+
+class CefBrowser;
+class CefV8Context;
+
+///
+// Class used to represent a frame in the browser window. When used in the
+// browser process the methods of this class may be called on any thread unless
+// otherwise indicated in the comments. When used in the render process the
+// methods of this class may only be called on the main thread.
+///
+/*--cef(source=library)--*/
+class CefFrame : public virtual CefBase {
+ public:
+  ///
+  // True if this object is currently attached to a valid frame.
+  ///
+  /*--cef()--*/
+  virtual bool IsValid() =0;
+
+  ///
+  // Execute undo in this frame.
+  ///
+  /*--cef()--*/
+  virtual void Undo() =0;
+
+  ///
+  // Execute redo in this frame.
+  ///
+  /*--cef()--*/
+  virtual void Redo() =0;
+
+  ///
+  // Execute cut in this frame.
+  ///
+  /*--cef()--*/
+  virtual void Cut() =0;
+
+  ///
+  // Execute copy in this frame.
+  ///
+  /*--cef()--*/
+  virtual void Copy() =0;
+
+  ///
+  // Execute paste in this frame.
+  ///
+  /*--cef()--*/
+  virtual void Paste() =0;
+
+  ///
+  // Execute delete in this frame.
+  ///
+  /*--cef(capi_name=del)--*/
+  virtual void Delete() =0;
+
+  ///
+  // Execute select all in this frame.
+  ///
+  /*--cef()--*/
+  virtual void SelectAll() =0;
+
+  ///
+  // Save this frame's HTML source to a temporary file and open it in the
+  // default text viewing application. This method can only be called from the
+  // browser process.
+  ///
+  /*--cef()--*/
+  virtual void ViewSource() =0;
+
+  ///
+  // Retrieve this frame's HTML source as a string sent to the specified
+  // visitor.
+  ///
+  /*--cef()--*/
+  virtual void GetSource(CefRefPtr<CefStringVisitor> visitor) =0;
+
+  ///
+  // Retrieve this frame's display text as a string sent to the specified
+  // visitor.
+  ///
+  /*--cef()--*/
+  virtual void GetText(CefRefPtr<CefStringVisitor> visitor) =0;
+
+  ///
+  // Load the request represented by the |request| object.
+  ///
+  /*--cef()--*/
+  virtual void LoadRequest(CefRefPtr<CefRequest> request) =0;
+
+  ///
+  // Load the specified |url|.
+  ///
+  /*--cef()--*/
+  virtual void LoadURL(const CefString& url) =0;
+
+  ///
+  // Load the contents of |string_val| with the specified dummy |url|. |url|
+  // should have a standard scheme (for example, http scheme) or behaviors like
+  // link clicks and web security restrictions may not behave as expected.
+  ///
+  /*--cef()--*/
+  virtual void LoadString(const CefString& string_val,
+                          const CefString& url) =0;
+
+  ///
+  // Execute a string of JavaScript code in this frame. The |script_url|
+  // parameter is the URL where the script in question can be found, if any.
+  // The renderer may request this URL to show the developer the source of the
+  // error.  The |start_line| parameter is the base line number to use for error
+  // reporting.
+  ///
+  /*--cef(optional_param=script_url)--*/
+  virtual void ExecuteJavaScript(const CefString& code,
+                                 const CefString& script_url,
+                                 int start_line) =0;
+
+  ///
+  // Returns true if this is the main (top-level) frame.
+  ///
+  /*--cef()--*/
+  virtual bool IsMain() =0;
+
+  ///
+  // Returns true if this is the focused frame.
+  ///
+  /*--cef()--*/
+  virtual bool IsFocused() =0;
+
+  ///
+  // Returns the name for this frame. If the frame has an assigned name (for
+  // example, set via the iframe "name" attribute) then that value will be
+  // returned. Otherwise a unique name will be constructed based on the frame
+  // parent hierarchy. The main (top-level) frame will always have an empty name
+  // value.
+  ///
+  /*--cef()--*/
+  virtual CefString GetName() =0;
+
+  ///
+  // Returns the globally unique identifier for this frame or < 0 if the
+  // underlying frame does not yet exist.
+  ///
+  /*--cef()--*/
+  virtual int64 GetIdentifier() =0;
+
+  ///
+  // Returns the parent of this frame or NULL if this is the main (top-level)
+  // frame.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefFrame> GetParent() =0;
+
+  ///
+  // Returns the URL currently loaded in this frame.
+  ///
+  /*--cef()--*/
+  virtual CefString GetURL() =0;
+
+  ///
+  // Returns the browser that this frame belongs to.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefBrowser> GetBrowser() =0;
+
+  ///
+  // Get the V8 context associated with the frame. This method can only be
+  // called from the render process.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefV8Context> GetV8Context() =0;
+  
+  ///
+  // Visit the DOM document. This method can only be called from the render
+  // process.
+  ///
+  /*--cef()--*/
+  virtual void VisitDOM(CefRefPtr<CefDOMVisitor> visitor) =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_FRAME_H_
diff --git a/src/include/libcef/cef_geolocation.h b/src/include/libcef/cef_geolocation.h
new file mode 100644
index 0000000..69c0877
--- /dev/null
+++ b/src/include/libcef/cef_geolocation.h
@@ -0,0 +1,66 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_GEOLOCATION_H_
+#define CEF_INCLUDE_CEF_GEOLOCATION_H_
+#pragma once
+
+#include "include/cef_base.h"
+
+///
+// Implement this interface to receive geolocation updates. The methods of this
+// class will be called on the browser process UI thread.
+///
+/*--cef(source=client)--*/
+class CefGetGeolocationCallback : public virtual CefBase {
+ public:
+  ///
+  // Called with the 'best available' location information or, if the location
+  // update failed, with error information.
+  ///
+  /*--cef()--*/
+  virtual void OnLocationUpdate(const CefGeoposition& position) =0;
+};
+
+///
+// Request a one-time geolocation update. This function bypasses any user
+// permission checks so should only be used by code that is allowed to access
+// location information.
+///
+/*--cef()--*/
+bool CefGetGeolocation(CefRefPtr<CefGetGeolocationCallback> callback);
+
+#endif  // CEF_INCLUDE_CEF_GEOLOCATION_H_
diff --git a/src/include/libcef/cef_geolocation_handler.h b/src/include/libcef/cef_geolocation_handler.h
new file mode 100644
index 0000000..dda5283
--- /dev/null
+++ b/src/include/libcef/cef_geolocation_handler.h
@@ -0,0 +1,95 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_GEOLOCATION_HANDLER_H_
+#define CEF_INCLUDE_CEF_GEOLOCATION_HANDLER_H_
+#pragma once
+
+#include "include/cef_base.h"
+#include "include/cef_browser.h"
+
+///
+// Callback interface used for asynchronous continuation of geolocation
+// permission requests.
+///
+/*--cef(source=library)--*/
+class CefGeolocationCallback : public virtual CefBase {
+ public:
+  ///
+  // Call to allow or deny geolocation access.
+  ///
+  /*--cef(capi_name=cont)--*/
+  virtual void Continue(bool allow) =0;
+};
+
+
+///
+// Implement this interface to handle events related to geolocation permission
+// requests. The methods of this class will be called on the browser process UI
+// thread.
+///
+/*--cef(source=client)--*/
+class CefGeolocationHandler : public virtual CefBase {
+ public:
+  ///
+  // Called when a page requests permission to access geolocation information.
+  // |requesting_url| is the URL requesting permission and |request_id| is the
+  // unique ID for the permission request. Return true and call
+  // CefGeolocationCallback::Continue() either in this method or at a later
+  // time to continue or cancel the request. Return false to cancel the request
+  // immediately.
+  ///
+  /*--cef()--*/
+  virtual bool OnRequestGeolocationPermission(
+      CefRefPtr<CefBrowser> browser,
+      const CefString& requesting_url,
+      int request_id,
+      CefRefPtr<CefGeolocationCallback> callback) {
+    return false;
+  }
+
+  ///
+  // Called when a geolocation access request is canceled. |request_id| is the
+  // unique ID for the permission request.
+  ///
+  /*--cef()--*/
+  virtual void OnCancelGeolocationPermission(
+      CefRefPtr<CefBrowser> browser,
+      int request_id) {
+  }
+};
+
+#endif  // CEF_INCLUDE_CEF_GEOLOCATION_HANDLER_H_
diff --git a/src/include/libcef/cef_image.h b/src/include/libcef/cef_image.h
new file mode 100644
index 0000000..170a237
--- /dev/null
+++ b/src/include/libcef/cef_image.h
@@ -0,0 +1,191 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_IMAGE_H_
+#define CEF_INCLUDE_CEF_IMAGE_H_
+#pragma once
+
+#include "include/cef_base.h"
+#include "include/cef_values.h"
+
+///
+// Container for a single image represented at different scale factors. All
+// image representations should be the same size in density independent pixel
+// (DIP) units. For example, if the image at scale factor 1.0 is 100x100 pixels
+// then the image at scale factor 2.0 should be 200x200 pixels -- both images
+// will display with a DIP size of 100x100 units. The methods of this class must
+// be called on the browser process UI thread.
+///
+/*--cef(source=library)--*/
+class CefImage : public virtual CefBase {
+ public:
+  ///
+  // Create a new CefImage. It will initially be empty. Use the Add*() methods
+  // to add representations at different scale factors.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefImage> CreateImage();
+
+  ///
+  // Returns true if this Image is empty.
+  ///
+  /*--cef()--*/
+  virtual bool IsEmpty() =0;
+
+  ///
+  // Returns true if this Image and |that| Image share the same underlying
+  // storage. Will also return true if both images are empty.
+  ///
+  /*--cef()--*/
+  virtual bool IsSame(CefRefPtr<CefImage> that) =0;
+
+  ///
+  // Add a bitmap image representation for |scale_factor|. Only 32-bit RGBA/BGRA
+  // formats are supported. |pixel_width| and |pixel_height| are the bitmap
+  // representation size in pixel coordinates. |pixel_data| is the array of
+  // pixel data and should be |pixel_width| x |pixel_height| x 4 bytes in size.
+  // |color_type| and |alpha_type| values specify the pixel format.
+  ///
+  /*--cef()--*/
+  virtual bool AddBitmap(float scale_factor,
+                         int pixel_width,
+                         int pixel_height,
+                         cef_color_type_t color_type,
+                         cef_alpha_type_t alpha_type,
+                         const void* pixel_data,
+                         size_t pixel_data_size) =0;
+
+  ///
+  // Add a PNG image representation for |scale_factor|. |png_data| is the image
+  // data of size |png_data_size|. Any alpha transparency in the PNG data will
+  // be maintained.
+  ///
+  /*--cef()--*/
+  virtual bool AddPNG(float scale_factor,
+                      const void* png_data,
+                      size_t png_data_size) =0;
+
+  ///
+  // Create a JPEG image representation for |scale_factor|. |jpeg_data| is the
+  // image data of size |jpeg_data_size|. The JPEG format does not support
+  // transparency so the alpha byte will be set to 0xFF for all pixels.
+  ///
+  /*--cef()--*/
+  virtual bool AddJPEG(float scale_factor,
+                       const void* jpeg_data,
+                       size_t jpeg_data_size) =0;
+
+  ///
+  // Returns the image width in density independent pixel (DIP) units.
+  ///
+  /*--cef()--*/
+  virtual size_t GetWidth() =0;
+
+  ///
+  // Returns the image height in density independent pixel (DIP) units.
+  ///
+  /*--cef()--*/
+  virtual size_t GetHeight() =0;
+
+  ///
+  // Returns true if this image contains a representation for |scale_factor|.
+  ///
+  /*--cef()--*/
+  virtual bool HasRepresentation(float scale_factor) =0;
+
+  ///
+  // Removes the representation for |scale_factor|. Returns true on success.
+  ///
+  /*--cef()--*/
+  virtual bool RemoveRepresentation(float scale_factor) =0;
+
+  ///
+  // Returns information for the representation that most closely matches
+  // |scale_factor|. |actual_scale_factor| is the actual scale factor for the
+  // representation. |pixel_width| and |pixel_height| are the representation
+  // size in pixel coordinates. Returns true on success.
+  ///
+  /*--cef()--*/
+  virtual bool GetRepresentationInfo(float scale_factor,
+                                     float& actual_scale_factor,
+                                     int& pixel_width,
+                                     int& pixel_height) =0;
+
+  ///
+  // Returns the bitmap representation that most closely matches |scale_factor|.
+  // Only 32-bit RGBA/BGRA formats are supported. |color_type| and |alpha_type|
+  // values specify the desired output pixel format. |pixel_width| and
+  // |pixel_height| are the output representation size in pixel coordinates.
+  // Returns a CefBinaryValue containing the pixel data on success or NULL on
+  // failure.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefBinaryValue> GetAsBitmap(float scale_factor,
+                                                cef_color_type_t color_type,
+                                                cef_alpha_type_t alpha_type,
+                                                int& pixel_width,
+                                                int& pixel_height) =0;
+
+  ///
+  // Returns the PNG representation that most closely matches |scale_factor|. If
+  // |with_transparency| is true any alpha transparency in the image will be
+  // represented in the resulting PNG data. |pixel_width| and |pixel_height| are
+  // the output representation size in pixel coordinates. Returns a
+  // CefBinaryValue containing the PNG image data on success or NULL on failure.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefBinaryValue> GetAsPNG(float scale_factor,
+                                             bool with_transparency,
+                                             int& pixel_width,
+                                             int& pixel_height) =0;
+
+  ///
+  // Returns the JPEG representation that most closely matches |scale_factor|.
+  // |quality| determines the compression level with 0 == lowest and 100 ==
+  // highest. The JPEG format does not support alpha transparency and the alpha
+  // channel, if any, will be discarded. |pixel_width| and |pixel_height| are
+  // the output representation size in pixel coordinates. Returns a
+  // CefBinaryValue containing the JPEG image data on success or NULL on
+  // failure.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefBinaryValue> GetAsJPEG(float scale_factor,
+                                              int quality,
+                                              int& pixel_width,
+                                              int& pixel_height) =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_IMAGE_H_
diff --git a/src/include/libcef/cef_jsdialog_handler.h b/src/include/libcef/cef_jsdialog_handler.h
new file mode 100644
index 0000000..fecaa7f
--- /dev/null
+++ b/src/include/libcef/cef_jsdialog_handler.h
@@ -0,0 +1,129 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_JSDIALOG_HANDLER_H_
+#define CEF_INCLUDE_CEF_JSDIALOG_HANDLER_H_
+#pragma once
+
+#include "include/cef_base.h"
+#include "include/cef_browser.h"
+
+///
+// Callback interface used for asynchronous continuation of JavaScript dialog
+// requests.
+///
+/*--cef(source=library)--*/
+class CefJSDialogCallback : public virtual CefBase {
+ public:
+  ///
+  // Continue the JS dialog request. Set |success| to true if the OK button was
+  // pressed. The |user_input| value should be specified for prompt dialogs.
+  ///
+  /*--cef(capi_name=cont,optional_param=user_input)--*/
+  virtual void Continue(bool success,
+                        const CefString& user_input) =0;
+};
+
+
+///
+// Implement this interface to handle events related to JavaScript dialogs. The
+// methods of this class will be called on the UI thread.
+///
+/*--cef(source=client)--*/
+class CefJSDialogHandler : public virtual CefBase {
+ public:
+  typedef cef_jsdialog_type_t JSDialogType;
+
+  ///
+  // Called to run a JavaScript dialog. If |origin_url| is non-empty it can be
+  // passed to the CefFormatUrlForSecurityDisplay function to retrieve a secure
+  // and user-friendly display string. The |default_prompt_text| value will be
+  // specified for prompt dialogs only. Set |suppress_message| to true and
+  // return false to suppress the message (suppressing messages is preferable to
+  // immediately executing the callback as this is used to detect presumably
+  // malicious behavior like spamming alert messages in onbeforeunload). Set
+  // |suppress_message| to false and return false to use the default
+  // implementation (the default implementation will show one modal dialog at a
+  // time and suppress any additional dialog requests until the displayed dialog
+  // is dismissed). Return true if the application will use a custom dialog or
+  // if the callback has been executed immediately. Custom dialogs may be either
+  // modal or modeless. If a custom dialog is used the application must execute
+  // |callback| once the custom dialog is dismissed.
+  ///
+  /*--cef(optional_param=origin_url,optional_param=accept_lang,
+          optional_param=message_text,optional_param=default_prompt_text)--*/
+  virtual bool OnJSDialog(CefRefPtr<CefBrowser> browser,
+                          const CefString& origin_url,
+                          JSDialogType dialog_type,
+                          const CefString& message_text,
+                          const CefString& default_prompt_text,
+                          CefRefPtr<CefJSDialogCallback> callback,
+                          bool& suppress_message) {
+    return false;
+  }
+
+  ///
+  // Called to run a dialog asking the user if they want to leave a page. Return
+  // false to use the default dialog implementation. Return true if the
+  // application will use a custom dialog or if the callback has been executed
+  // immediately. Custom dialogs may be either modal or modeless. If a custom
+  // dialog is used the application must execute |callback| once the custom
+  // dialog is dismissed.
+  ///
+  /*--cef(optional_param=message_text)--*/
+  virtual bool OnBeforeUnloadDialog(CefRefPtr<CefBrowser> browser,
+                                    const CefString& message_text,
+                                    bool is_reload,
+                                    CefRefPtr<CefJSDialogCallback> callback) {
+    return false;
+  }
+
+  ///
+  // Called to cancel any pending dialogs and reset any saved dialog state. Will
+  // be called due to events like page navigation irregardless of whether any
+  // dialogs are currently pending.
+  ///
+  /*--cef()--*/
+  virtual void OnResetDialogState(CefRefPtr<CefBrowser> browser) {}
+  
+  ///
+  // Called when the default implementation dialog is closed.
+  ///
+  /*--cef()--*/
+  virtual void OnDialogClosed(CefRefPtr<CefBrowser> browser) {}
+};
+
+#endif  // CEF_INCLUDE_CEF_JSDIALOG_HANDLER_H_
diff --git a/src/include/libcef/cef_keyboard_handler.h b/src/include/libcef/cef_keyboard_handler.h
new file mode 100644
index 0000000..0346aa4
--- /dev/null
+++ b/src/include/libcef/cef_keyboard_handler.h
@@ -0,0 +1,76 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_KEYBOARD_HANDLER_H_
+#define CEF_INCLUDE_CEF_KEYBOARD_HANDLER_H_
+#pragma once
+
+#include "include/cef_base.h"
+#include "include/cef_browser.h"
+
+///
+// Implement this interface to handle events related to keyboard input. The
+// methods of this class will be called on the UI thread.
+///
+/*--cef(source=client)--*/
+class CefKeyboardHandler : public virtual CefBase {
+ public:
+  ///
+  // Called before a keyboard event is sent to the renderer. |event| contains
+  // information about the keyboard event. |os_event| is the operating system
+  // event message, if any. Return true if the event was handled or false
+  // otherwise. If the event will be handled in OnKeyEvent() as a keyboard
+  // shortcut set |is_keyboard_shortcut| to true and return false.
+  ///
+  /*--cef()--*/
+  virtual bool OnPreKeyEvent(CefRefPtr<CefBrowser> browser,
+                             const CefKeyEvent& event,
+                             CefEventHandle os_event,
+                             bool* is_keyboard_shortcut) { return false; }
+
+  ///
+  // Called after the renderer and JavaScript in the page has had a chance to
+  // handle the event. |event| contains information about the keyboard event.
+  // |os_event| is the operating system event message, if any. Return true if
+  // the keyboard event was handled or false otherwise.
+  ///
+  /*--cef()--*/
+  virtual bool OnKeyEvent(CefRefPtr<CefBrowser> browser,
+                          const CefKeyEvent& event,
+                          CefEventHandle os_event) { return false; }
+};
+
+#endif  // CEF_INCLUDE_CEF_KEYBOARD_HANDLER_H_
diff --git a/src/include/libcef/cef_life_span_handler.h b/src/include/libcef/cef_life_span_handler.h
new file mode 100644
index 0000000..6967e3e
--- /dev/null
+++ b/src/include/libcef/cef_life_span_handler.h
@@ -0,0 +1,200 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_LIFE_SPAN_HANDLER_H_
+#define CEF_INCLUDE_CEF_LIFE_SPAN_HANDLER_H_
+#pragma once
+
+#include "include/cef_base.h"
+#include "include/cef_browser.h"
+
+class CefClient;
+
+///
+// Implement this interface to handle events related to browser life span. The
+// methods of this class will be called on the UI thread unless otherwise
+// indicated.
+///
+/*--cef(source=client)--*/
+class CefLifeSpanHandler : public virtual CefBase {
+ public:
+  typedef cef_window_open_disposition_t WindowOpenDisposition;
+
+  ///
+  // Called on the IO thread before a new popup browser is created. The
+  // |browser| and |frame| values represent the source of the popup request. The
+  // |target_url| and |target_frame_name| values indicate where the popup
+  // browser should navigate and may be empty if not specified with the request.
+  // The |target_disposition| value indicates where the user intended to open
+  // the popup (e.g. current tab, new tab, etc). The |user_gesture| value will
+  // be true if the popup was opened via explicit user gesture (e.g. clicking a
+  // link) or false if the popup opened automatically (e.g. via the
+  // DomContentLoaded event). The |popupFeatures| structure contains additional
+  // information about the requested popup window. To allow creation of the
+  // popup browser optionally modify |windowInfo|, |client|, |settings| and
+  // |no_javascript_access| and return false. To cancel creation of the popup
+  // browser return true. The |client| and |settings| values will default to the
+  // source browser's values. If the |no_javascript_access| value is set to
+  // false the new browser will not be scriptable and may not be hosted in the
+  // same renderer process as the source browser. Any modifications to
+  // |windowInfo| will be ignored if the parent browser is wrapped in a
+  // CefBrowserView.
+  ///
+  /*--cef(optional_param=target_url,optional_param=target_frame_name)--*/
+  virtual bool OnBeforePopup(CefRefPtr<CefBrowser> browser,
+                             CefRefPtr<CefFrame> frame,
+                             const CefString& target_url,
+                             const CefString& target_frame_name,
+                             WindowOpenDisposition target_disposition,
+                             bool user_gesture,
+                             const CefPopupFeatures& popupFeatures,
+                             CefWindowInfo& windowInfo,
+                             CefRefPtr<CefClient>& client,
+                             CefBrowserSettings& settings,
+                             bool* no_javascript_access) {
+    return false;
+  }
+
+  ///
+  // Called after a new browser is created. This callback will be the first
+  // notification that references |browser|.
+  ///
+  /*--cef()--*/
+  virtual void OnAfterCreated(CefRefPtr<CefBrowser> browser) {}
+
+  ///
+  // Called when a browser has recieved a request to close. This may result
+  // directly from a call to CefBrowserHost::*CloseBrowser() or indirectly if
+  // the browser is parented to a top-level window created by CEF and the user
+  // attempts to close that window (by clicking the 'X', for example). The
+  // DoClose() method will be called after the JavaScript 'onunload' event has
+  // been fired.
+  //
+  // An application should handle top-level owner window close notifications by
+  // calling CefBrowserHost::TryCloseBrowser() or
+  // CefBrowserHost::CloseBrowser(false) instead of allowing the window to close
+  // immediately (see the examples below). This gives CEF an opportunity to
+  // process the 'onbeforeunload' event and optionally cancel the close before
+  // DoClose() is called.
+  //
+  // When windowed rendering is enabled CEF will internally create a window or
+  // view to host the browser. In that case returning false from DoClose() will
+  // send the standard close notification to the browser's top-level owner
+  // window (e.g. WM_CLOSE on Windows, performClose: on OS X, "delete_event" on
+  // Linux or CefWindowDelegate::CanClose() callback from Views). If the
+  // browser's host window/view has already been destroyed (via view hierarchy
+  // tear-down, for example) then DoClose() will not be called for that browser
+  // since is no longer possible to cancel the close.
+  //
+  // When windowed rendering is disabled returning false from DoClose() will
+  // cause the browser object to be destroyed immediately.
+  //
+  // If the browser's top-level owner window requires a non-standard close
+  // notification then send that notification from DoClose() and return true.
+  //
+  // The CefLifeSpanHandler::OnBeforeClose() method will be called after
+  // DoClose() (if DoClose() is called) and immediately before the browser
+  // object is destroyed. The application should only exit after OnBeforeClose()
+  // has been called for all existing browsers.
+  //
+  // The below examples describe what should happen during window close when the
+  // browser is parented to an application-provided top-level window.
+  //
+  // Example 1: Using CefBrowserHost::TryCloseBrowser(). This is recommended for
+  // clients using standard close handling and windows created on the browser
+  // process UI thread.
+  // 1.  User clicks the window close button which sends a close notification to
+  //     the application's top-level window.
+  // 2.  Application's top-level window receives the close notification and
+  //     calls TryCloseBrowser() (which internally calls CloseBrowser(false)).
+  //     TryCloseBrowser() returns false so the client cancels the window close.
+  // 3.  JavaScript 'onbeforeunload' handler executes and shows the close
+  //     confirmation dialog (which can be overridden via
+  //     CefJSDialogHandler::OnBeforeUnloadDialog()).
+  // 4.  User approves the close.
+  // 5.  JavaScript 'onunload' handler executes.
+  // 6.  CEF sends a close notification to the application's top-level window
+  //     (because DoClose() returned false by default).
+  // 7.  Application's top-level window receives the close notification and
+  //     calls TryCloseBrowser(). TryCloseBrowser() returns true so the client
+  //     allows the window close.
+  // 8.  Application's top-level window is destroyed.
+  // 9.  Application's OnBeforeClose() handler is called and the browser object
+  //     is destroyed.
+  // 10. Application exits by calling CefQuitMessageLoop() if no other browsers
+  //     exist.
+  //
+  // Example 2: Using CefBrowserHost::CloseBrowser(false) and implementing the
+  // DoClose() callback. This is recommended for clients using non-standard
+  // close handling or windows that were not created on the browser process UI
+  // thread.
+  // 1.  User clicks the window close button which sends a close notification to
+  //     the application's top-level window.
+  // 2.  Application's top-level window receives the close notification and:
+  //     A. Calls CefBrowserHost::CloseBrowser(false).
+  //     B. Cancels the window close.
+  // 3.  JavaScript 'onbeforeunload' handler executes and shows the close
+  //     confirmation dialog (which can be overridden via
+  //     CefJSDialogHandler::OnBeforeUnloadDialog()).
+  // 4.  User approves the close.
+  // 5.  JavaScript 'onunload' handler executes.
+  // 6.  Application's DoClose() handler is called. Application will:
+  //     A. Set a flag to indicate that the next close attempt will be allowed.
+  //     B. Return false.
+  // 7.  CEF sends an close notification to the application's top-level window.
+  // 8.  Application's top-level window receives the close notification and
+  //     allows the window to close based on the flag from #6B.
+  // 9.  Application's top-level window is destroyed.
+  // 10. Application's OnBeforeClose() handler is called and the browser object
+  //     is destroyed.
+  // 11. Application exits by calling CefQuitMessageLoop() if no other browsers
+  //     exist.
+  ///
+  /*--cef()--*/
+  virtual bool DoClose(CefRefPtr<CefBrowser> browser) { return false; }
+
+  ///
+  // Called just before a browser is destroyed. Release all references to the
+  // browser object and do not attempt to execute any methods on the browser
+  // object after this callback returns. This callback will be the last
+  // notification that references |browser|. See DoClose() documentation for
+  // additional usage information.
+  ///
+  /*--cef()--*/
+  virtual void OnBeforeClose(CefRefPtr<CefBrowser> browser) {}
+};
+
+#endif  // CEF_INCLUDE_CEF_LIFE_SPAN_HANDLER_H_
diff --git a/src/include/libcef/cef_load_handler.h b/src/include/libcef/cef_load_handler.h
new file mode 100644
index 0000000..29f7b74
--- /dev/null
+++ b/src/include/libcef/cef_load_handler.h
@@ -0,0 +1,109 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_LOAD_HANDLER_H_
+#define CEF_INCLUDE_CEF_LOAD_HANDLER_H_
+#pragma once
+
+#include "include/cef_base.h"
+#include "include/cef_browser.h"
+#include "include/cef_frame.h"
+
+///
+// Implement this interface to handle events related to browser load status. The
+// methods of this class will be called on the browser process UI thread or
+// render process main thread (TID_RENDERER).
+///
+/*--cef(source=client)--*/
+class CefLoadHandler : public virtual CefBase {
+ public:
+  typedef cef_errorcode_t ErrorCode;
+
+  ///
+  // Called when the loading state has changed. This callback will be executed
+  // twice -- once when loading is initiated either programmatically or by user
+  // action, and once when loading is terminated due to completion, cancellation
+  // of failure. It will be called before any calls to OnLoadStart and after all
+  // calls to OnLoadError and/or OnLoadEnd.
+  ///
+  /*--cef()--*/
+  virtual void OnLoadingStateChange(CefRefPtr<CefBrowser> browser,
+                                    bool isLoading,
+                                    bool canGoBack,
+                                    bool canGoForward) {}
+
+  ///
+  // Called when the browser begins loading a frame. The |frame| value will
+  // never be empty -- call the IsMain() method to check if this frame is the
+  // main frame. Multiple frames may be loading at the same time. Sub-frames may
+  // start or continue loading after the main frame load has ended. This method
+  // will always be called for all frames irrespective of whether the request
+  // completes successfully. For notification of overall browser load status use
+  // OnLoadingStateChange instead.
+  ///
+  /*--cef()--*/
+  virtual void OnLoadStart(CefRefPtr<CefBrowser> browser,
+                           CefRefPtr<CefFrame> frame) {}
+
+  ///
+  // Called when the browser is done loading a frame. The |frame| value will
+  // never be empty -- call the IsMain() method to check if this frame is the
+  // main frame. Multiple frames may be loading at the same time. Sub-frames may
+  // start or continue loading after the main frame load has ended. This method
+  // will always be called for all frames irrespective of whether the request
+  // completes successfully. For notification of overall browser load status use
+  // OnLoadingStateChange instead.
+  ///
+  /*--cef()--*/
+  virtual void OnLoadEnd(CefRefPtr<CefBrowser> browser,
+                         CefRefPtr<CefFrame> frame,
+                         int httpStatusCode) {}
+
+  ///
+  // Called when the resource load for a navigation fails or is canceled.
+  // |errorCode| is the error code number, |errorText| is the error text and
+  // |failedUrl| is the URL that failed to load. See net\base\net_error_list.h
+  // for complete descriptions of the error codes.
+  ///
+  /*--cef(optional_param=errorText)--*/
+  virtual void OnLoadError(CefRefPtr<CefBrowser> browser,
+                           CefRefPtr<CefFrame> frame,
+                           ErrorCode errorCode,
+                           const CefString& errorText,
+                           const CefString& failedUrl) {}
+};
+
+#endif  // CEF_INCLUDE_CEF_LOAD_HANDLER_H_
diff --git a/src/include/libcef/cef_menu_model.h b/src/include/libcef/cef_menu_model.h
new file mode 100644
index 0000000..beb95fb
--- /dev/null
+++ b/src/include/libcef/cef_menu_model.h
@@ -0,0 +1,410 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_MENU_MODEL_H_
+#define CEF_INCLUDE_CEF_MENU_MODEL_H_
+#pragma once
+
+#include "include/cef_base.h"
+#include "include/cef_menu_model_delegate.h"
+
+///
+// Supports creation and modification of menus. See cef_menu_id_t for the
+// command ids that have default implementations. All user-defined command ids
+// should be between MENU_ID_USER_FIRST and MENU_ID_USER_LAST. The methods of
+// this class can only be accessed on the browser process the UI thread.
+///
+/*--cef(source=library)--*/
+class CefMenuModel : public virtual CefBase {
+ public:
+  typedef cef_menu_item_type_t MenuItemType;
+
+  ///
+  // Create a new MenuModel with the specified |delegate|.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefMenuModel> CreateMenuModel(
+      CefRefPtr<CefMenuModelDelegate> delegate);
+
+  ///
+  // Clears the menu. Returns true on success.
+  ///
+  /*--cef()--*/
+  virtual bool Clear() =0;
+
+  ///
+  // Returns the number of items in this menu.
+  ///
+  /*--cef()--*/
+  virtual int GetCount() =0;
+
+  ///
+  // Add a separator to the menu. Returns true on success.
+  ///
+  /*--cef()--*/
+  virtual bool AddSeparator() =0;
+
+  ///
+  // Add an item to the menu. Returns true on success.
+  ///
+  /*--cef()--*/
+  virtual bool AddItem(int command_id,
+                       const CefString& label) =0;
+
+  ///
+  // Add a check item to the menu. Returns true on success.
+  ///
+  /*--cef()--*/
+  virtual bool AddCheckItem(int command_id,
+                            const CefString& label) =0;
+  ///
+  // Add a radio item to the menu. Only a single item with the specified
+  // |group_id| can be checked at a time. Returns true on success.
+  ///
+  /*--cef()--*/
+  virtual bool AddRadioItem(int command_id,
+                            const CefString& label,
+                            int group_id) =0;
+
+  ///
+  // Add a sub-menu to the menu. The new sub-menu is returned.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefMenuModel> AddSubMenu(int command_id,
+                                             const CefString& label) =0;
+
+  ///
+  // Insert a separator in the menu at the specified |index|. Returns true on
+  // success.
+  ///
+  /*--cef()--*/
+  virtual bool InsertSeparatorAt(int index) =0;
+
+  ///
+  // Insert an item in the menu at the specified |index|. Returns true on
+  // success.
+  ///
+  /*--cef()--*/
+  virtual bool InsertItemAt(int index,
+                            int command_id,
+                            const CefString& label) =0;
+
+  ///
+  // Insert a check item in the menu at the specified |index|. Returns true on
+  // success.
+  ///
+  /*--cef()--*/
+  virtual bool InsertCheckItemAt(int index,
+                                 int command_id,
+                                 const CefString& label) =0;
+
+  ///
+  // Insert a radio item in the menu at the specified |index|. Only a single
+  // item with the specified |group_id| can be checked at a time. Returns true
+  // on success.
+  ///
+  /*--cef()--*/
+  virtual bool InsertRadioItemAt(int index,
+                                 int command_id,
+                                 const CefString& label,
+                                 int group_id) =0;
+
+  ///
+  // Insert a sub-menu in the menu at the specified |index|. The new sub-menu
+  // is returned.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefMenuModel> InsertSubMenuAt(int index,
+                                                  int command_id,
+                                                  const CefString& label) =0;
+
+  ///
+  // Removes the item with the specified |command_id|. Returns true on success.
+  ///
+  /*--cef()--*/
+  virtual bool Remove(int command_id) =0;
+
+  ///
+  // Removes the item at the specified |index|. Returns true on success.
+  ///
+  /*--cef()--*/
+  virtual bool RemoveAt(int index) =0;
+
+  ///
+  // Returns the index associated with the specified |command_id| or -1 if not
+  // found due to the command id not existing in the menu.
+  ///
+  /*--cef()--*/
+  virtual int GetIndexOf(int command_id) =0;
+
+  ///
+  // Returns the command id at the specified |index| or -1 if not found due to
+  // invalid range or the index being a separator.
+  ///
+  /*--cef()--*/
+  virtual int GetCommandIdAt(int index) =0;
+
+  ///
+  // Sets the command id at the specified |index|. Returns true on success.
+  ///
+  /*--cef()--*/
+  virtual bool SetCommandIdAt(int index, int command_id) =0;
+
+  ///
+  // Returns the label for the specified |command_id| or empty if not found.
+  ///
+  /*--cef()--*/
+  virtual CefString GetLabel(int command_id) =0;
+
+  ///
+  // Returns the label at the specified |index| or empty if not found due to
+  // invalid range or the index being a separator.
+  ///
+  /*--cef()--*/
+  virtual CefString GetLabelAt(int index) =0;
+
+  ///
+  // Sets the label for the specified |command_id|. Returns true on success.
+  ///
+  /*--cef()--*/
+  virtual bool SetLabel(int command_id, const CefString& label) =0;
+
+  ///
+  // Set the label at the specified |index|. Returns true on success.
+  ///
+  /*--cef()--*/
+  virtual bool SetLabelAt(int index, const CefString& label) =0;
+
+  ///
+  // Returns the item type for the specified |command_id|.
+  ///
+  /*--cef(default_retval=MENUITEMTYPE_NONE)--*/
+  virtual MenuItemType GetType(int command_id) =0;
+
+  ///
+  // Returns the item type at the specified |index|.
+  ///
+  /*--cef(default_retval=MENUITEMTYPE_NONE)--*/
+  virtual MenuItemType GetTypeAt(int index) =0;
+
+  ///
+  // Returns the group id for the specified |command_id| or -1 if invalid.
+  ///
+  /*--cef()--*/
+  virtual int GetGroupId(int command_id) =0;
+
+  ///
+  // Returns the group id at the specified |index| or -1 if invalid.
+  ///
+  /*--cef()--*/
+  virtual int GetGroupIdAt(int index) =0;
+
+  ///
+  // Sets the group id for the specified |command_id|. Returns true on success.
+  ///
+  /*--cef()--*/
+  virtual bool SetGroupId(int command_id, int group_id) =0;
+
+  ///
+  // Sets the group id at the specified |index|. Returns true on success.
+  ///
+  /*--cef()--*/
+  virtual bool SetGroupIdAt(int index, int group_id) =0;
+
+  ///
+  // Returns the submenu for the specified |command_id| or empty if invalid.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefMenuModel> GetSubMenu(int command_id) =0;
+
+  ///
+  // Returns the submenu at the specified |index| or empty if invalid.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefMenuModel> GetSubMenuAt(int index) =0;
+
+  ///
+  // Returns true if the specified |command_id| is visible.
+  ///
+  /*--cef()--*/
+  virtual bool IsVisible(int command_id) =0;
+
+  ///
+  // Returns true if the specified |index| is visible.
+  ///
+  /*--cef()--*/
+  virtual bool IsVisibleAt(int index) =0;
+
+  ///
+  // Change the visibility of the specified |command_id|. Returns true on
+  // success.
+  ///
+  /*--cef()--*/
+  virtual bool SetVisible(int command_id, bool visible) =0;
+
+  ///
+  // Change the visibility at the specified |index|. Returns true on success.
+  ///
+  /*--cef()--*/
+  virtual bool SetVisibleAt(int index, bool visible) =0;
+
+  ///
+  // Returns true if the specified |command_id| is enabled.
+  ///
+  /*--cef()--*/
+  virtual bool IsEnabled(int command_id) =0;
+
+  ///
+  // Returns true if the specified |index| is enabled.
+  ///
+  /*--cef()--*/
+  virtual bool IsEnabledAt(int index) =0;
+
+  ///
+  // Change the enabled status of the specified |command_id|. Returns true on
+  // success.
+  ///
+  /*--cef()--*/
+  virtual bool SetEnabled(int command_id, bool enabled) =0;
+
+  ///
+  // Change the enabled status at the specified |index|. Returns true on
+  // success.
+  ///
+  /*--cef()--*/
+  virtual bool SetEnabledAt(int index, bool enabled) =0;
+
+  ///
+  // Returns true if the specified |command_id| is checked. Only applies to
+  // check and radio items.
+  ///
+  /*--cef()--*/
+  virtual bool IsChecked(int command_id) =0;
+
+  ///
+  // Returns true if the specified |index| is checked. Only applies to check
+  // and radio items.
+  ///
+  /*--cef()--*/
+  virtual bool IsCheckedAt(int index) =0;
+
+  ///
+  // Check the specified |command_id|. Only applies to check and radio items.
+  // Returns true on success.
+  ///
+  /*--cef()--*/
+  virtual bool SetChecked(int command_id, bool checked) =0;
+
+  ///
+  // Check the specified |index|. Only applies to check and radio items. Returns
+  // true on success.
+  ///
+  /*--cef()--*/
+  virtual bool SetCheckedAt(int index, bool checked) =0;
+
+  ///
+  // Returns true if the specified |command_id| has a keyboard accelerator
+  // assigned.
+  ///
+  /*--cef()--*/
+  virtual bool HasAccelerator(int command_id) =0;
+
+  ///
+  // Returns true if the specified |index| has a keyboard accelerator assigned.
+  ///
+  /*--cef()--*/
+  virtual bool HasAcceleratorAt(int index) =0;
+
+  ///
+  // Set the keyboard accelerator for the specified |command_id|. |key_code| can
+  // be any virtual key or character value. Returns true on success.
+  ///
+  /*--cef()--*/
+  virtual bool SetAccelerator(int command_id,
+                              int key_code,
+                              bool shift_pressed,
+                              bool ctrl_pressed,
+                              bool alt_pressed) =0;
+
+  ///
+  // Set the keyboard accelerator at the specified |index|. |key_code| can be
+  // any virtual key or character value. Returns true on success.
+  ///
+  /*--cef()--*/
+  virtual bool SetAcceleratorAt(int index,
+                                int key_code,
+                                bool shift_pressed,
+                                bool ctrl_pressed,
+                                bool alt_pressed) =0;
+
+  ///
+  // Remove the keyboard accelerator for the specified |command_id|. Returns
+  // true on success.
+  ///
+  /*--cef()--*/
+  virtual bool RemoveAccelerator(int command_id) =0;
+
+  ///
+  // Remove the keyboard accelerator at the specified |index|. Returns true on
+  // success.
+  ///
+  /*--cef()--*/
+  virtual bool RemoveAcceleratorAt(int index) =0;
+
+  ///
+  // Retrieves the keyboard accelerator for the specified |command_id|. Returns
+  // true on success.
+  ///
+  /*--cef()--*/
+  virtual bool GetAccelerator(int command_id,
+                              int& key_code,
+                              bool& shift_pressed,
+                              bool& ctrl_pressed,
+                              bool& alt_pressed) =0;
+
+  ///
+  // Retrieves the keyboard accelerator for the specified |index|. Returns true
+  // on success.
+  ///
+  /*--cef()--*/
+  virtual bool GetAcceleratorAt(int index,
+                                int& key_code,
+                                bool& shift_pressed,
+                                bool& ctrl_pressed,
+                                bool& alt_pressed) =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_MENU_MODEL_H_
diff --git a/src/include/libcef/cef_menu_model_delegate.h b/src/include/libcef/cef_menu_model_delegate.h
new file mode 100644
index 0000000..b4e2341
--- /dev/null
+++ b/src/include/libcef/cef_menu_model_delegate.h
@@ -0,0 +1,82 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_VIEWS_CEF_MENU_MODEL_DELEGATE_H_
+#define CEF_INCLUDE_VIEWS_CEF_MENU_MODEL_DELEGATE_H_
+#pragma once
+
+#include "include/cef_base.h"
+
+class CefMenuModel;
+
+///
+// Implement this interface to handle menu model events. The methods of this
+// class will be called on the browser process UI thread unless otherwise
+// indicated.
+///
+/*--cef(source=client)--*/
+class CefMenuModelDelegate : public virtual CefBase {
+ public:
+  ///
+  // Perform the action associated with the specified |command_id| and
+  // optional |event_flags|.
+  ///
+  /*--cef()--*/
+  virtual void ExecuteCommand(CefRefPtr<CefMenuModel> menu_model,
+                              int command_id,
+                              cef_event_flags_t event_flags) =0;
+
+  ///
+  // The menu is about to show.
+  ///
+  /*--cef()--*/
+  virtual void MenuWillShow(CefRefPtr<CefMenuModel> menu_model) {};
+
+  ///
+  // The menu has closed.
+  ///
+  /*--cef()--*/
+  virtual void MenuClosed(CefRefPtr<CefMenuModel> menu_model) {};
+
+  ///
+  // Optionally modify a menu item label. Return true if |label| was modified.
+  ///
+  /*--cef()--*/
+  virtual bool FormatLabel(CefRefPtr<CefMenuModel> menu_model,
+                           CefString& label) { return false; };
+};
+
+#endif  // CEF_INCLUDE_VIEWS_CEF_MENU_MODEL_DELEGATE_H_
diff --git a/src/include/libcef/cef_navigation_entry.h b/src/include/libcef/cef_navigation_entry.h
new file mode 100644
index 0000000..211351f
--- /dev/null
+++ b/src/include/libcef/cef_navigation_entry.h
@@ -0,0 +1,113 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_NAVIGATION_ENTRY_H_
+#define CEF_INCLUDE_CEF_NAVIGATION_ENTRY_H_
+#pragma once
+
+#include "include/cef_base.h"
+
+///
+// Class used to represent an entry in navigation history.
+///
+/*--cef(source=library)--*/
+class CefNavigationEntry : public virtual CefBase {
+ public:
+  typedef cef_transition_type_t TransitionType;
+
+  ///
+  // Returns true if this object is valid. Do not call any other methods if this
+  // function returns false.
+  ///
+  /*--cef()--*/
+  virtual bool IsValid() =0;
+
+  ///
+  // Returns the actual URL of the page. For some pages this may be data: URL or
+  // similar. Use GetDisplayURL() to return a display-friendly version.
+  ///
+  /*--cef()--*/
+  virtual CefString GetURL() =0;
+
+  ///
+  // Returns a display-friendly version of the URL.
+  ///
+  /*--cef()--*/
+  virtual CefString GetDisplayURL() =0;
+
+  ///
+  // Returns the original URL that was entered by the user before any redirects.
+  ///
+  /*--cef()--*/
+  virtual CefString GetOriginalURL() =0;
+
+  ///
+  // Returns the title set by the page. This value may be empty.
+  ///
+  /*--cef()--*/
+  virtual CefString GetTitle() =0;
+
+  ///
+  // Returns the transition type which indicates what the user did to move to
+  // this page from the previous page.
+  ///
+  /*--cef(default_retval=TT_EXPLICIT)--*/
+  virtual TransitionType GetTransitionType() =0;
+
+  ///
+  // Returns true if this navigation includes post data.
+  ///
+  /*--cef()--*/
+  virtual bool HasPostData() =0;
+
+  ///
+  // Returns the time for the last known successful navigation completion. A
+  // navigation may be completed more than once if the page is reloaded. May be
+  // 0 if the navigation has not yet completed.
+  ///
+  /*--cef()--*/
+  virtual CefTime GetCompletionTime() =0;
+
+  ///
+  // Returns the HTTP status code for the last known successful navigation
+  // response. May be 0 if the response has not yet been received or if the
+  // navigation has not yet completed.
+  ///
+  /*--cef()--*/
+  virtual int GetHttpStatusCode() =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_NAVIGATION_ENTRY_H_
diff --git a/src/include/libcef/cef_origin_whitelist.h b/src/include/libcef/cef_origin_whitelist.h
new file mode 100644
index 0000000..7fed345
--- /dev/null
+++ b/src/include/libcef/cef_origin_whitelist.h
@@ -0,0 +1,103 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_ORIGIN_WHITELIST_H_
+#define CEF_INCLUDE_CEF_ORIGIN_WHITELIST_H_
+#pragma once
+
+#include "include/cef_base.h"
+
+
+///
+// Add an entry to the cross-origin access whitelist.
+//
+// The same-origin policy restricts how scripts hosted from different origins
+// (scheme + domain + port) can communicate. By default, scripts can only access
+// resources with the same origin. Scripts hosted on the HTTP and HTTPS schemes
+// (but no other schemes) can use the "Access-Control-Allow-Origin" header to
+// allow cross-origin requests. For example, https://source.example.com can make
+// XMLHttpRequest requests on http://target.example.com if the
+// http://target.example.com request returns an "Access-Control-Allow-Origin:
+// https://source.example.com" response header.
+//
+// Scripts in separate frames or iframes and hosted from the same protocol and
+// domain suffix can execute cross-origin JavaScript if both pages set the
+// document.domain value to the same domain suffix. For example,
+// scheme://foo.example.com and scheme://bar.example.com can communicate using
+// JavaScript if both domains set document.domain="example.com".
+//
+// This method is used to allow access to origins that would otherwise violate
+// the same-origin policy. Scripts hosted underneath the fully qualified
+// |source_origin| URL (like http://www.example.com) will be allowed access to
+// all resources hosted on the specified |target_protocol| and |target_domain|.
+// If |target_domain| is non-empty and |allow_target_subdomains| if false only
+// exact domain matches will be allowed. If |target_domain| contains a top-
+// level domain component (like "example.com") and |allow_target_subdomains| is
+// true sub-domain matches will be allowed. If |target_domain| is empty and
+// |allow_target_subdomains| if true all domains and IP addresses will be
+// allowed.
+//
+// This method cannot be used to bypass the restrictions on local or display
+// isolated schemes. See the comments on CefRegisterCustomScheme for more
+// information.
+//
+// This function may be called on any thread. Returns false if |source_origin|
+// is invalid or the whitelist cannot be accessed.
+///
+/*--cef(optional_param=target_domain)--*/
+bool CefAddCrossOriginWhitelistEntry(const CefString& source_origin,
+                                     const CefString& target_protocol,
+                                     const CefString& target_domain,
+                                     bool allow_target_subdomains);
+
+///
+// Remove an entry from the cross-origin access whitelist. Returns false if
+// |source_origin| is invalid or the whitelist cannot be accessed.
+///
+/*--cef(optional_param=target_domain)--*/
+bool CefRemoveCrossOriginWhitelistEntry(const CefString& source_origin,
+                                        const CefString& target_protocol,
+                                        const CefString& target_domain,
+                                        bool allow_target_subdomains);
+
+///
+// Remove all entries from the cross-origin access whitelist. Returns false if
+// the whitelist cannot be accessed.
+///
+/*--cef()--*/
+bool CefClearCrossOriginWhitelist();
+
+#endif  // CEF_INCLUDE_CEF_ORIGIN_WHITELIST_H_
diff --git a/src/include/libcef/cef_pack_resources.h b/src/include/libcef/cef_pack_resources.h
new file mode 100644
index 0000000..6e7574c
--- /dev/null
+++ b/src/include/libcef/cef_pack_resources.h
@@ -0,0 +1,1662 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file is generated by the make_pack_header.py tool.
+//
+
+#ifndef CEF_INCLUDE_CEF_PACK_RESOURCES_H_
+#define CEF_INCLUDE_CEF_PACK_RESOURCES_H_
+#pragma once
+
+// ---------------------------------------------------------------------------
+// From blink_resources.h:
+
+#define IDR_UASTYLE_HTML_CSS 30370
+#define IDR_UASTYLE_QUIRKS_CSS 30371
+#define IDR_UASTYLE_VIEW_SOURCE_CSS 30372
+#define IDR_UASTYLE_THEME_CHROMIUM_ANDROID_CSS 30373
+#define IDR_UASTYLE_MEDIA_CONTROLS_ANDROID_CSS 30374
+#define IDR_UASTYLE_MEDIA_CONTROLS_ANDROID_NEW_CSS 30375
+#define IDR_UASTYLE_THEME_CHROMIUM_LINUX_CSS 30376
+#define IDR_UASTYLE_THEME_MAC_CSS 30377
+#define IDR_UASTYLE_THEME_INPUT_MULTIPLE_FIELDS_CSS 30378
+#define IDR_UASTYLE_THEME_WIN_CSS 30379
+#define IDR_UASTYLE_THEME_WIN_QUIRKS_CSS 30380
+#define IDR_UASTYLE_SVG_CSS 30381
+#define IDR_UASTYLE_MATHML_CSS 30382
+#define IDR_UASTYLE_MEDIA_CONTROLS_CSS 30383
+#define IDR_UASTYLE_MEDIA_CONTROLS_NEW_CSS 30384
+#define IDR_UASTYLE_FULLSCREEN_CSS 30385
+#define IDR_UASTYLE_XHTMLMP_CSS 30386
+#define IDR_UASTYLE_VIEWPORT_ANDROID_CSS 30387
+#define IDR_INSPECTOR_OVERLAY_PAGE_HTML 30388
+#define IDR_PRIVATE_SCRIPT_DOCUMENTEXECCOMMAND_JS 30389
+#define IDR_PRIVATE_SCRIPT_DOCUMENTXMLTREEVIEWER_CSS 30390
+#define IDR_PRIVATE_SCRIPT_DOCUMENTXMLTREEVIEWER_JS 30391
+#define IDR_PRIVATE_SCRIPT_HTMLMARQUEEELEMENT_JS 30392
+#define IDR_PRIVATE_SCRIPT_PRIVATESCRIPTRUNNER_JS 30393
+#define IDR_PICKER_COMMON_JS 30394
+#define IDR_PICKER_COMMON_CSS 30395
+#define IDR_CALENDAR_PICKER_CSS 30396
+#define IDR_CALENDAR_PICKER_JS 30397
+#define IDR_PICKER_BUTTON_CSS 30398
+#define IDR_SUGGESTION_PICKER_CSS 30399
+#define IDR_SUGGESTION_PICKER_JS 30400
+#define IDR_COLOR_SUGGESTION_PICKER_CSS 30401
+#define IDR_COLOR_SUGGESTION_PICKER_JS 30402
+#define IDR_LIST_PICKER_CSS 30403
+#define IDR_LIST_PICKER_JS 30404
+#define IDR_AUDIO_SPATIALIZATION_COMPOSITE 30405
+#define IDR_AUDIO_SPATIALIZATION_T000_P000 30406
+#define IDR_AUDIO_SPATIALIZATION_T000_P015 30407
+#define IDR_AUDIO_SPATIALIZATION_T000_P030 30408
+#define IDR_AUDIO_SPATIALIZATION_T000_P045 30409
+#define IDR_AUDIO_SPATIALIZATION_T000_P060 30410
+#define IDR_AUDIO_SPATIALIZATION_T000_P075 30411
+#define IDR_AUDIO_SPATIALIZATION_T000_P090 30412
+#define IDR_AUDIO_SPATIALIZATION_T000_P315 30413
+#define IDR_AUDIO_SPATIALIZATION_T000_P330 30414
+#define IDR_AUDIO_SPATIALIZATION_T000_P345 30415
+#define IDR_AUDIO_SPATIALIZATION_T015_P000 30416
+#define IDR_AUDIO_SPATIALIZATION_T015_P015 30417
+#define IDR_AUDIO_SPATIALIZATION_T015_P030 30418
+#define IDR_AUDIO_SPATIALIZATION_T015_P045 30419
+#define IDR_AUDIO_SPATIALIZATION_T015_P060 30420
+#define IDR_AUDIO_SPATIALIZATION_T015_P075 30421
+#define IDR_AUDIO_SPATIALIZATION_T015_P090 30422
+#define IDR_AUDIO_SPATIALIZATION_T015_P315 30423
+#define IDR_AUDIO_SPATIALIZATION_T015_P330 30424
+#define IDR_AUDIO_SPATIALIZATION_T015_P345 30425
+#define IDR_AUDIO_SPATIALIZATION_T030_P000 30426
+#define IDR_AUDIO_SPATIALIZATION_T030_P015 30427
+#define IDR_AUDIO_SPATIALIZATION_T030_P030 30428
+#define IDR_AUDIO_SPATIALIZATION_T030_P045 30429
+#define IDR_AUDIO_SPATIALIZATION_T030_P060 30430
+#define IDR_AUDIO_SPATIALIZATION_T030_P075 30431
+#define IDR_AUDIO_SPATIALIZATION_T030_P090 30432
+#define IDR_AUDIO_SPATIALIZATION_T030_P315 30433
+#define IDR_AUDIO_SPATIALIZATION_T030_P330 30434
+#define IDR_AUDIO_SPATIALIZATION_T030_P345 30435
+#define IDR_AUDIO_SPATIALIZATION_T045_P000 30436
+#define IDR_AUDIO_SPATIALIZATION_T045_P015 30437
+#define IDR_AUDIO_SPATIALIZATION_T045_P030 30438
+#define IDR_AUDIO_SPATIALIZATION_T045_P045 30439
+#define IDR_AUDIO_SPATIALIZATION_T045_P060 30440
+#define IDR_AUDIO_SPATIALIZATION_T045_P075 30441
+#define IDR_AUDIO_SPATIALIZATION_T045_P090 30442
+#define IDR_AUDIO_SPATIALIZATION_T045_P315 30443
+#define IDR_AUDIO_SPATIALIZATION_T045_P330 30444
+#define IDR_AUDIO_SPATIALIZATION_T045_P345 30445
+#define IDR_AUDIO_SPATIALIZATION_T060_P000 30446
+#define IDR_AUDIO_SPATIALIZATION_T060_P015 30447
+#define IDR_AUDIO_SPATIALIZATION_T060_P030 30448
+#define IDR_AUDIO_SPATIALIZATION_T060_P045 30449
+#define IDR_AUDIO_SPATIALIZATION_T060_P060 30450
+#define IDR_AUDIO_SPATIALIZATION_T060_P075 30451
+#define IDR_AUDIO_SPATIALIZATION_T060_P090 30452
+#define IDR_AUDIO_SPATIALIZATION_T060_P315 30453
+#define IDR_AUDIO_SPATIALIZATION_T060_P330 30454
+#define IDR_AUDIO_SPATIALIZATION_T060_P345 30455
+#define IDR_AUDIO_SPATIALIZATION_T075_P000 30456
+#define IDR_AUDIO_SPATIALIZATION_T075_P015 30457
+#define IDR_AUDIO_SPATIALIZATION_T075_P030 30458
+#define IDR_AUDIO_SPATIALIZATION_T075_P045 30459
+#define IDR_AUDIO_SPATIALIZATION_T075_P060 30460
+#define IDR_AUDIO_SPATIALIZATION_T075_P075 30461
+#define IDR_AUDIO_SPATIALIZATION_T075_P090 30462
+#define IDR_AUDIO_SPATIALIZATION_T075_P315 30463
+#define IDR_AUDIO_SPATIALIZATION_T075_P330 30464
+#define IDR_AUDIO_SPATIALIZATION_T075_P345 30465
+#define IDR_AUDIO_SPATIALIZATION_T090_P000 30466
+#define IDR_AUDIO_SPATIALIZATION_T090_P015 30467
+#define IDR_AUDIO_SPATIALIZATION_T090_P030 30468
+#define IDR_AUDIO_SPATIALIZATION_T090_P045 30469
+#define IDR_AUDIO_SPATIALIZATION_T090_P060 30470
+#define IDR_AUDIO_SPATIALIZATION_T090_P075 30471
+#define IDR_AUDIO_SPATIALIZATION_T090_P090 30472
+#define IDR_AUDIO_SPATIALIZATION_T090_P315 30473
+#define IDR_AUDIO_SPATIALIZATION_T090_P330 30474
+#define IDR_AUDIO_SPATIALIZATION_T090_P345 30475
+#define IDR_AUDIO_SPATIALIZATION_T105_P000 30476
+#define IDR_AUDIO_SPATIALIZATION_T105_P015 30477
+#define IDR_AUDIO_SPATIALIZATION_T105_P030 30478
+#define IDR_AUDIO_SPATIALIZATION_T105_P045 30479
+#define IDR_AUDIO_SPATIALIZATION_T105_P060 30480
+#define IDR_AUDIO_SPATIALIZATION_T105_P075 30481
+#define IDR_AUDIO_SPATIALIZATION_T105_P090 30482
+#define IDR_AUDIO_SPATIALIZATION_T105_P315 30483
+#define IDR_AUDIO_SPATIALIZATION_T105_P330 30484
+#define IDR_AUDIO_SPATIALIZATION_T105_P345 30485
+#define IDR_AUDIO_SPATIALIZATION_T120_P000 30486
+#define IDR_AUDIO_SPATIALIZATION_T120_P015 30487
+#define IDR_AUDIO_SPATIALIZATION_T120_P030 30488
+#define IDR_AUDIO_SPATIALIZATION_T120_P045 30489
+#define IDR_AUDIO_SPATIALIZATION_T120_P060 30490
+#define IDR_AUDIO_SPATIALIZATION_T120_P075 30491
+#define IDR_AUDIO_SPATIALIZATION_T120_P090 30492
+#define IDR_AUDIO_SPATIALIZATION_T120_P315 30493
+#define IDR_AUDIO_SPATIALIZATION_T120_P330 30494
+#define IDR_AUDIO_SPATIALIZATION_T120_P345 30495
+#define IDR_AUDIO_SPATIALIZATION_T135_P000 30496
+#define IDR_AUDIO_SPATIALIZATION_T135_P015 30497
+#define IDR_AUDIO_SPATIALIZATION_T135_P030 30498
+#define IDR_AUDIO_SPATIALIZATION_T135_P045 30499
+#define IDR_AUDIO_SPATIALIZATION_T135_P060 30500
+#define IDR_AUDIO_SPATIALIZATION_T135_P075 30501
+#define IDR_AUDIO_SPATIALIZATION_T135_P090 30502
+#define IDR_AUDIO_SPATIALIZATION_T135_P315 30503
+#define IDR_AUDIO_SPATIALIZATION_T135_P330 30504
+#define IDR_AUDIO_SPATIALIZATION_T135_P345 30505
+#define IDR_AUDIO_SPATIALIZATION_T150_P000 30506
+#define IDR_AUDIO_SPATIALIZATION_T150_P015 30507
+#define IDR_AUDIO_SPATIALIZATION_T150_P030 30508
+#define IDR_AUDIO_SPATIALIZATION_T150_P045 30509
+#define IDR_AUDIO_SPATIALIZATION_T150_P060 30510
+#define IDR_AUDIO_SPATIALIZATION_T150_P075 30511
+#define IDR_AUDIO_SPATIALIZATION_T150_P090 30512
+#define IDR_AUDIO_SPATIALIZATION_T150_P315 30513
+#define IDR_AUDIO_SPATIALIZATION_T150_P330 30514
+#define IDR_AUDIO_SPATIALIZATION_T150_P345 30515
+#define IDR_AUDIO_SPATIALIZATION_T165_P000 30516
+#define IDR_AUDIO_SPATIALIZATION_T165_P015 30517
+#define IDR_AUDIO_SPATIALIZATION_T165_P030 30518
+#define IDR_AUDIO_SPATIALIZATION_T165_P045 30519
+#define IDR_AUDIO_SPATIALIZATION_T165_P060 30520
+#define IDR_AUDIO_SPATIALIZATION_T165_P075 30521
+#define IDR_AUDIO_SPATIALIZATION_T165_P090 30522
+#define IDR_AUDIO_SPATIALIZATION_T165_P315 30523
+#define IDR_AUDIO_SPATIALIZATION_T165_P330 30524
+#define IDR_AUDIO_SPATIALIZATION_T165_P345 30525
+#define IDR_AUDIO_SPATIALIZATION_T180_P000 30526
+#define IDR_AUDIO_SPATIALIZATION_T180_P015 30527
+#define IDR_AUDIO_SPATIALIZATION_T180_P030 30528
+#define IDR_AUDIO_SPATIALIZATION_T180_P045 30529
+#define IDR_AUDIO_SPATIALIZATION_T180_P060 30530
+#define IDR_AUDIO_SPATIALIZATION_T180_P075 30531
+#define IDR_AUDIO_SPATIALIZATION_T180_P090 30532
+#define IDR_AUDIO_SPATIALIZATION_T180_P315 30533
+#define IDR_AUDIO_SPATIALIZATION_T180_P330 30534
+#define IDR_AUDIO_SPATIALIZATION_T180_P345 30535
+#define IDR_AUDIO_SPATIALIZATION_T195_P000 30536
+#define IDR_AUDIO_SPATIALIZATION_T195_P015 30537
+#define IDR_AUDIO_SPATIALIZATION_T195_P030 30538
+#define IDR_AUDIO_SPATIALIZATION_T195_P045 30539
+#define IDR_AUDIO_SPATIALIZATION_T195_P060 30540
+#define IDR_AUDIO_SPATIALIZATION_T195_P075 30541
+#define IDR_AUDIO_SPATIALIZATION_T195_P090 30542
+#define IDR_AUDIO_SPATIALIZATION_T195_P315 30543
+#define IDR_AUDIO_SPATIALIZATION_T195_P330 30544
+#define IDR_AUDIO_SPATIALIZATION_T195_P345 30545
+#define IDR_AUDIO_SPATIALIZATION_T210_P000 30546
+#define IDR_AUDIO_SPATIALIZATION_T210_P015 30547
+#define IDR_AUDIO_SPATIALIZATION_T210_P030 30548
+#define IDR_AUDIO_SPATIALIZATION_T210_P045 30549
+#define IDR_AUDIO_SPATIALIZATION_T210_P060 30550
+#define IDR_AUDIO_SPATIALIZATION_T210_P075 30551
+#define IDR_AUDIO_SPATIALIZATION_T210_P090 30552
+#define IDR_AUDIO_SPATIALIZATION_T210_P315 30553
+#define IDR_AUDIO_SPATIALIZATION_T210_P330 30554
+#define IDR_AUDIO_SPATIALIZATION_T210_P345 30555
+#define IDR_AUDIO_SPATIALIZATION_T225_P000 30556
+#define IDR_AUDIO_SPATIALIZATION_T225_P015 30557
+#define IDR_AUDIO_SPATIALIZATION_T225_P030 30558
+#define IDR_AUDIO_SPATIALIZATION_T225_P045 30559
+#define IDR_AUDIO_SPATIALIZATION_T225_P060 30560
+#define IDR_AUDIO_SPATIALIZATION_T225_P075 30561
+#define IDR_AUDIO_SPATIALIZATION_T225_P090 30562
+#define IDR_AUDIO_SPATIALIZATION_T225_P315 30563
+#define IDR_AUDIO_SPATIALIZATION_T225_P330 30564
+#define IDR_AUDIO_SPATIALIZATION_T225_P345 30565
+#define IDR_AUDIO_SPATIALIZATION_T240_P000 30566
+#define IDR_AUDIO_SPATIALIZATION_T240_P015 30567
+#define IDR_AUDIO_SPATIALIZATION_T240_P030 30568
+#define IDR_AUDIO_SPATIALIZATION_T240_P045 30569
+#define IDR_AUDIO_SPATIALIZATION_T240_P060 30570
+#define IDR_AUDIO_SPATIALIZATION_T240_P075 30571
+#define IDR_AUDIO_SPATIALIZATION_T240_P090 30572
+#define IDR_AUDIO_SPATIALIZATION_T240_P315 30573
+#define IDR_AUDIO_SPATIALIZATION_T240_P330 30574
+#define IDR_AUDIO_SPATIALIZATION_T240_P345 30575
+#define IDR_AUDIO_SPATIALIZATION_T255_P000 30576
+#define IDR_AUDIO_SPATIALIZATION_T255_P015 30577
+#define IDR_AUDIO_SPATIALIZATION_T255_P030 30578
+#define IDR_AUDIO_SPATIALIZATION_T255_P045 30579
+#define IDR_AUDIO_SPATIALIZATION_T255_P060 30580
+#define IDR_AUDIO_SPATIALIZATION_T255_P075 30581
+#define IDR_AUDIO_SPATIALIZATION_T255_P090 30582
+#define IDR_AUDIO_SPATIALIZATION_T255_P315 30583
+#define IDR_AUDIO_SPATIALIZATION_T255_P330 30584
+#define IDR_AUDIO_SPATIALIZATION_T255_P345 30585
+#define IDR_AUDIO_SPATIALIZATION_T270_P000 30586
+#define IDR_AUDIO_SPATIALIZATION_T270_P015 30587
+#define IDR_AUDIO_SPATIALIZATION_T270_P030 30588
+#define IDR_AUDIO_SPATIALIZATION_T270_P045 30589
+#define IDR_AUDIO_SPATIALIZATION_T270_P060 30590
+#define IDR_AUDIO_SPATIALIZATION_T270_P075 30591
+#define IDR_AUDIO_SPATIALIZATION_T270_P090 30592
+#define IDR_AUDIO_SPATIALIZATION_T270_P315 30593
+#define IDR_AUDIO_SPATIALIZATION_T270_P330 30594
+#define IDR_AUDIO_SPATIALIZATION_T270_P345 30595
+#define IDR_AUDIO_SPATIALIZATION_T285_P000 30596
+#define IDR_AUDIO_SPATIALIZATION_T285_P015 30597
+#define IDR_AUDIO_SPATIALIZATION_T285_P030 30598
+#define IDR_AUDIO_SPATIALIZATION_T285_P045 30599
+#define IDR_AUDIO_SPATIALIZATION_T285_P060 30600
+#define IDR_AUDIO_SPATIALIZATION_T285_P075 30601
+#define IDR_AUDIO_SPATIALIZATION_T285_P090 30602
+#define IDR_AUDIO_SPATIALIZATION_T285_P315 30603
+#define IDR_AUDIO_SPATIALIZATION_T285_P330 30604
+#define IDR_AUDIO_SPATIALIZATION_T285_P345 30605
+#define IDR_AUDIO_SPATIALIZATION_T300_P000 30606
+#define IDR_AUDIO_SPATIALIZATION_T300_P015 30607
+#define IDR_AUDIO_SPATIALIZATION_T300_P030 30608
+#define IDR_AUDIO_SPATIALIZATION_T300_P045 30609
+#define IDR_AUDIO_SPATIALIZATION_T300_P060 30610
+#define IDR_AUDIO_SPATIALIZATION_T300_P075 30611
+#define IDR_AUDIO_SPATIALIZATION_T300_P090 30612
+#define IDR_AUDIO_SPATIALIZATION_T300_P315 30613
+#define IDR_AUDIO_SPATIALIZATION_T300_P330 30614
+#define IDR_AUDIO_SPATIALIZATION_T300_P345 30615
+#define IDR_AUDIO_SPATIALIZATION_T315_P000 30616
+#define IDR_AUDIO_SPATIALIZATION_T315_P015 30617
+#define IDR_AUDIO_SPATIALIZATION_T315_P030 30618
+#define IDR_AUDIO_SPATIALIZATION_T315_P045 30619
+#define IDR_AUDIO_SPATIALIZATION_T315_P060 30620
+#define IDR_AUDIO_SPATIALIZATION_T315_P075 30621
+#define IDR_AUDIO_SPATIALIZATION_T315_P090 30622
+#define IDR_AUDIO_SPATIALIZATION_T315_P315 30623
+#define IDR_AUDIO_SPATIALIZATION_T315_P330 30624
+#define IDR_AUDIO_SPATIALIZATION_T315_P345 30625
+#define IDR_AUDIO_SPATIALIZATION_T330_P000 30626
+#define IDR_AUDIO_SPATIALIZATION_T330_P015 30627
+#define IDR_AUDIO_SPATIALIZATION_T330_P030 30628
+#define IDR_AUDIO_SPATIALIZATION_T330_P045 30629
+#define IDR_AUDIO_SPATIALIZATION_T330_P060 30630
+#define IDR_AUDIO_SPATIALIZATION_T330_P075 30631
+#define IDR_AUDIO_SPATIALIZATION_T330_P090 30632
+#define IDR_AUDIO_SPATIALIZATION_T330_P315 30633
+#define IDR_AUDIO_SPATIALIZATION_T330_P330 30634
+#define IDR_AUDIO_SPATIALIZATION_T330_P345 30635
+#define IDR_AUDIO_SPATIALIZATION_T345_P000 30636
+#define IDR_AUDIO_SPATIALIZATION_T345_P015 30637
+#define IDR_AUDIO_SPATIALIZATION_T345_P030 30638
+#define IDR_AUDIO_SPATIALIZATION_T345_P045 30639
+#define IDR_AUDIO_SPATIALIZATION_T345_P060 30640
+#define IDR_AUDIO_SPATIALIZATION_T345_P075 30641
+#define IDR_AUDIO_SPATIALIZATION_T345_P090 30642
+#define IDR_AUDIO_SPATIALIZATION_T345_P315 30643
+#define IDR_AUDIO_SPATIALIZATION_T345_P330 30644
+#define IDR_AUDIO_SPATIALIZATION_T345_P345 30645
+
+// ---------------------------------------------------------------------------
+// From cef_resources.h:
+
+#define IDR_CEF_DEVTOOLS_DISCOVERY_PAGE 27500
+#define IDR_CEF_LICENSE_TXT 27501
+#define IDR_CEF_VERSION_HTML 27502
+#define IDR_CEF_EXTENSION_API_FEATURES 27503
+#define IDR_PDF_MANIFEST 27504
+#define IDR_BLOCKED_PLUGIN_HTML 27505
+#define IDR_PLUGIN_POSTER_HTML 27506
+#define IDR_PLUGIN_DB_JSON 27507
+
+// ---------------------------------------------------------------------------
+// From component_extension_resources.h:
+
+#define IDR_BOOKMARK_MANAGER_MAIN 1450
+#define IDR_HOTWORD_AUDIO_VERIFICATION_MAIN 1451
+#define IDR_WALLPAPER_MANAGER_MAIN 1452
+#define IDR_FIRST_RUN_DIALOG_MAIN 1453
+#define IDR_NETWORK_SPEECH_SYNTHESIS_JS 1000
+#define IDR_BRAILLE_IME_JS 1001
+#define IDR_BRAILLE_IME_MAIN_JS 1002
+#define IDR_BOOKMARK_MANAGER_BOOKMARK_MANAGER_SEARCH 1003
+#define IDR_BOOKMARK_MANAGER_BOOKMARK_MANAGER_SEARCH_RTL 1004
+#define IDR_BOOKMARK_MANAGER_BOOKMARK_MAIN_JS 1005
+#define IDR_BOOKMARK_MANAGER_BOOKMARK_BMM_LIST_JS 1006
+#define IDR_BOOKMARK_MANAGER_BOOKMARK_BMM_TREE_JS 1007
+#define IDR_BOOKMARK_MANAGER_BOOKMARK_DND_JS 1008
+#define IDR_BOOKMARK_MANAGER_BOOKMARK_BMM_JS 1009
+#define IDR_GAIA_AUTH_MAIN 1010
+#define IDR_GAIA_AUTH_MAIN_JS 1011
+#define IDR_GAIA_AUTH_MAIN_CSS 1012
+#define IDR_GAIA_AUTH_OFFLINE 1013
+#define IDR_GAIA_AUTH_OFFLINE_JS 1014
+#define IDR_GAIA_AUTH_OFFLINE_CSS 1015
+#define IDR_GAIA_AUTH_SUCCESS 1016
+#define IDR_GAIA_AUTH_UTIL_JS 1017
+#define IDR_GAIA_AUTH_BACKGROUND_JS 1018
+#define IDR_GAIA_AUTH_SAML_INJECTED_JS 1019
+#define IDR_GAIA_AUTH_CHANNEL_JS 1020
+#define IDR_HANGOUT_SERVICES_BACKGROUND_HTML 1021
+#define IDR_HANGOUT_SERVICES_THUNK_JS 1022
+#define IDR_HOTWORD_AUDIO_VERIFICATION_BACKGROUND_JS 1023
+#define IDR_HOTWORD_AUDIO_VERIFICATION_MAIN_JS 1024
+#define IDR_HOTWORD_AUDIO_VERIFICATION_FLOW_JS 1025
+#define IDR_START_STEP_HTML 1026
+#define IDR_AUDIO_HISTORY_STEP_HTML 1027
+#define IDR_SPEECH_TRAINING_STEP_HTML 1028
+#define IDR_FINISHED_STEP_HTML 1029
+#define IDR_HOTWORD_AUDIO_VERIFICATION_STYLE_CSS 1030
+#define IDR_HOTWORD_AUDIO_VERIFICATION_IMAGE_CLOSE_1X 1031
+#define IDR_HOTWORD_AUDIO_VERIFICATION_IMAGE_CLOSE_2X 1032
+#define IDR_HOTWORD_AUDIO_VERIFICATION_IMAGE_INTRO_1X 1033
+#define IDR_HOTWORD_AUDIO_VERIFICATION_IMAGE_INTRO_2X 1034
+#define IDR_HOTWORD_AUDIO_VERIFICATION_IMAGE_HEADER_1X 1035
+#define IDR_HOTWORD_AUDIO_VERIFICATION_IMAGE_HEADER_2X 1036
+#define IDR_HOTWORD_AUDIO_VERIFICATION_IMAGE_CHECK_BLUE_1X 1037
+#define IDR_HOTWORD_AUDIO_VERIFICATION_IMAGE_CHECK_BLUE_2X 1038
+#define IDR_HOTWORD_AUDIO_VERIFICATION_IMAGE_CHECK_GRAY_1X 1039
+#define IDR_HOTWORD_AUDIO_VERIFICATION_IMAGE_CHECK_GRAY_2X 1040
+#define IDR_HOTWORD_AUDIO_VERIFICATION_IMAGE_LOADER_1X 1041
+#define IDR_HOTWORD_AUDIO_VERIFICATION_IMAGE_LOADER_2X 1042
+#define IDR_HOTWORD_AUDIO_VERIFICATION_IMAGE_ERROR_1X 1043
+#define IDR_HOTWORD_AUDIO_VERIFICATION_IMAGE_ERROR_2X 1044
+#define IDR_HOTWORD_AUDIO_VERIFICATION_IMAGE_ICON_16 1045
+#define IDR_HOTWORD_AUDIO_VERIFICATION_IMAGE_ICON_48 1046
+#define IDR_HOTWORD_AUDIO_VERIFICATION_IMAGE_ICON_128 1047
+#define IDR_HOTWORD_ALWAYS_ON_MANAGER_JS 1048
+#define IDR_HOTWORD_AUDIO_CLIENT_JS 1049
+#define IDR_HOTWORD_BASE_SESSION_MANAGER_JS 1050
+#define IDR_HOTWORD_CONSTANTS_JS 1051
+#define IDR_HOTWORD_KEEP_ALIVE_JS 1052
+#define IDR_HOTWORD_LAUNCHER_MANAGER_JS 1053
+#define IDR_HOTWORD_LOGGING_JS 1054
+#define IDR_HOTWORD_MANAGER_JS 1055
+#define IDR_HOTWORD_METRICS_JS 1056
+#define IDR_HOTWORD_NACL_MANAGER_JS 1057
+#define IDR_HOTWORD_PAGE_AUDIO_MANAGER_JS 1058
+#define IDR_HOTWORD_STATE_MANAGER_JS 1059
+#define IDR_HOTWORD_TRAINING_MANAGER_JS 1060
+#define IDR_FEEDBACK_DEFAULT_HTML 1061
+#define IDR_FEEDBACK_SYSINFO_HTML 1062
+#define IDR_FEEDBACK_EVENT_HANDLER_JS 1063
+#define IDR_FEEDBACK_FEEDBACK_JS 1064
+#define IDR_FEEDBACK_SYSINFO_JS 1065
+#define IDR_FEEDBACK_TAKE_SCREENSHOT_JS 1066
+#define IDR_FEEDBACK_TOPBAR_HANDLER_JS 1067
+#define IDR_FEEDBACK_FEEDBACK_CSS 1068
+#define IDR_FEEDBACK_ICON_32 1069
+#define IDR_FEEDBACK_ICON_64 1070
+#define IDR_GOOGLE_NOW_BACKGROUND_JS 1071
+#define IDR_GOOGLE_NOW_CARDS_JS 1072
+#define IDR_GOOGLE_NOW_UTILITY_JS 1073
+#define IDR_GOOGLE_NOW_ICON_16 1074
+#define IDR_GOOGLE_NOW_ICON_48 1075
+#define IDR_GOOGLE_NOW_ICON_128 1076
+#define IDR_IDENTITY_API_SCOPE_APPROVAL_BACKGROUND_JS 1077
+#define IDR_IDENTITY_API_SCOPE_APPROVAL_DIALOG_CSS 1078
+#define IDR_IDENTITY_API_SCOPE_APPROVAL_DIALOG 1079
+#define IDR_IDENTITY_API_SCOPE_APPROVAL_DIALOG_JS 1080
+#define IDR_WALLPAPER_MANAGER_CONSTANTS_JS 1081
+#define IDR_WALLPAPER_MANAGER_EVENT_JS 1082
+#define IDR_WALLPAPER_MANAGER_ICON_16 1083
+#define IDR_WALLPAPER_MANAGER_ICON_32 1084
+#define IDR_WALLPAPER_MANAGER_ICON_48 1085
+#define IDR_WALLPAPER_MANAGER_ICON_64 1086
+#define IDR_WALLPAPER_MANAGER_ICON_96 1087
+#define IDR_WALLPAPER_MANAGER_ICON_128 1088
+#define IDR_WALLPAPER_MANAGER_ICON_256 1089
+#define IDR_WALLPAPER_MANAGER_MAIN_JS 1090
+#define IDR_WALLPAPER_MANAGER_UTIL_JS 1091
+#define IDR_FIRST_RUN_DIALOG_BACKGROUND_JS 1092
+#define IDR_FIRST_RUN_DIALOG_MAIN_JS 1093
+#define IDR_FIRST_RUN_DIALOG_ICON_16 1094
+#define IDR_FIRST_RUN_DIALOG_ICON_32 1095
+#define IDR_FIRST_RUN_DIALOG_ICON_48 1096
+#define IDR_FIRST_RUN_DIALOG_ICON_64 1097
+#define IDR_FIRST_RUN_DIALOG_ICON_96 1098
+#define IDR_FIRST_RUN_DIALOG_ICON_128 1099
+#define IDR_FIRST_RUN_DIALOG_ICON_256 1100
+#define IDR_ARC_SUPPORT_BACKGROUND_JS 1101
+#define IDR_ARC_SUPPORT_MAIN_CSS 1102
+#define IDR_ARC_SUPPORT_MAIN 1103
+#define IDR_ARC_SUPPORT_ICON 1104
+#define IDR_ARC_SUPPORT_ICON_PLAYSTORE 1105
+#define IDR_ARC_SUPPORT_ICON_CHROME 1106
+#define IDR_SETTINGS_APP_JS 1107
+#define IDR_PDF_INDEX_CSS 1108
+#define IDR_PDF_INDEX_HTML 1109
+#define IDR_PDF_MAIN_JS 1110
+#define IDR_PDF_PDF_JS 1111
+#define IDR_PDF_UI_MANAGER_JS 1112
+#define IDR_PDF_VIEWPORT_JS 1113
+#define IDR_PDF_OPEN_PDF_PARAMS_PARSER_JS 1114
+#define IDR_PDF_NAVIGATOR_JS 1115
+#define IDR_PDF_VIEWPORT_SCROLLER_JS 1116
+#define IDR_PDF_PDF_SCRIPTING_API_JS 1117
+#define IDR_PDF_ZOOM_MANAGER_JS 1118
+#define IDR_PDF_BROWSER_API_JS 1119
+#define IDR_PDF_CONTENT_SCRIPT_JS 1120
+#define IDR_PDF_SHARED_ICON_STYLE_CSS 1121
+#define IDR_PDF_VIEWER_BOOKMARK_CSS 1122
+#define IDR_PDF_VIEWER_BOOKMARK_HTML 1123
+#define IDR_PDF_VIEWER_BOOKMARK_JS 1124
+#define IDR_PDF_VIEWER_BOOKMARKS_CONTENT_HTML 1125
+#define IDR_PDF_VIEWER_BOOKMARKS_CONTENT_JS 1126
+#define IDR_PDF_VIEWER_ERROR_SCREEN_CSS 1127
+#define IDR_PDF_VIEWER_ERROR_SCREEN_HTML 1128
+#define IDR_PDF_VIEWER_ERROR_SCREEN_JS 1129
+#define IDR_PDF_VIEWER_PAGE_INDICATOR_CSS 1130
+#define IDR_PDF_VIEWER_PAGE_INDICATOR_HTML 1131
+#define IDR_PDF_VIEWER_PAGE_INDICATOR_JS 1132
+#define IDR_PDF_VIEWER_PAGE_SELECTOR_CSS 1133
+#define IDR_PDF_VIEWER_PAGE_SELECTOR_HTML 1134
+#define IDR_PDF_VIEWER_PAGE_SELECTOR_JS 1135
+#define IDR_PDF_VIEWER_PASSWORD_SCREEN_HTML 1136
+#define IDR_PDF_VIEWER_PASSWORD_SCREEN_JS 1137
+#define IDR_PDF_VIEWER_PDF_TOOLBAR_CSS 1138
+#define IDR_PDF_VIEWER_PDF_TOOLBAR_HTML 1139
+#define IDR_PDF_VIEWER_PDF_TOOLBAR_JS 1140
+#define IDR_PDF_VIEWER_TOOLBAR_DROPDOWN_CSS 1141
+#define IDR_PDF_VIEWER_TOOLBAR_DROPDOWN_HTML 1142
+#define IDR_PDF_VIEWER_TOOLBAR_DROPDOWN_JS 1143
+#define IDR_PDF_VIEWER_ZOOM_BUTTON_CSS 1144
+#define IDR_PDF_VIEWER_ZOOM_BUTTON_HTML 1145
+#define IDR_PDF_VIEWER_ZOOM_BUTTON_JS 1146
+#define IDR_PDF_VIEWER_ZOOM_SELECTOR_CSS 1147
+#define IDR_PDF_VIEWER_ZOOM_SELECTOR_HTML 1148
+#define IDR_PDF_VIEWER_ZOOM_SELECTOR_JS 1149
+#define IDR_CRYPTOTOKEN_UTIL_JS 1150
+#define IDR_CRYPTOTOKEN_B64_JS 1151
+#define IDR_CRYPTOTOKEN_CLOSEABLE_JS 1152
+#define IDR_CRYPTOTOKEN_COUNTDOWN_JS 1153
+#define IDR_CRYPTOTOKEN_COUNTDOWNTIMER_JS 1154
+#define IDR_CRYPTOTOKEN_SHA256_JS 1155
+#define IDR_CRYPTOTOKEN_TIMER_JS 1156
+#define IDR_CRYPTOTOKEN_HIDGNUBBYDEVICE_JS 1157
+#define IDR_CRYPTOTOKEN_USBGNUBBYDEVICE_JS 1158
+#define IDR_CRYPTOTOKEN_GNUBBIES_JS 1159
+#define IDR_CRYPTOTOKEN_GNUBBY_JS 1160
+#define IDR_CRYPTOTOKEN_GNUBBY_U2F_JS 1161
+#define IDR_CRYPTOTOKEN_GNUBBYFACTORY_JS 1162
+#define IDR_CRYPTOTOKEN_USBGNUBBYFACTORY_JS 1163
+#define IDR_CRYPTOTOKEN_DEVICESTATUSCODES_JS 1164
+#define IDR_CRYPTOTOKEN_ENROLLER_JS 1165
+#define IDR_CRYPTOTOKEN_USBENROLLHANDLER_JS 1166
+#define IDR_CRYPTOTOKEN_REQUESTQUEUE_JS 1167
+#define IDR_CRYPTOTOKEN_SIGNER_JS 1168
+#define IDR_CRYPTOTOKEN_SINGLESIGNER_JS 1169
+#define IDR_CRYPTOTOKEN_MULTIPLESIGNER_JS 1170
+#define IDR_CRYPTOTOKEN_USBSIGNHANDLER_JS 1171
+#define IDR_CRYPTOTOKEN_WEBREQUEST_JS 1172
+#define IDR_CRYPTOTOKEN_APPID_JS 1173
+#define IDR_CRYPTOTOKEN_USBHELPER_JS 1174
+#define IDR_CRYPTOTOKEN_TEXTFETCHER_JS 1175
+#define IDR_CRYPTOTOKEN_REQUESTHELPER_JS 1176
+#define IDR_CRYPTOTOKEN_MESSAGETYPES_JS 1177
+#define IDR_CRYPTOTOKEN_INHERITS_JS 1178
+#define IDR_CRYPTOTOKEN_GNUBBYDEVICE_JS 1179
+#define IDR_CRYPTOTOKEN_GENERICHELPER_JS 1180
+#define IDR_CRYPTOTOKEN_FACTORYREGISTRY_JS 1181
+#define IDR_CRYPTOTOKEN_ERRORCODES_JS 1182
+#define IDR_CRYPTOTOKEN_DEVICEFACTORYREGISTRY_JS 1183
+#define IDR_CRYPTOTOKEN_ORIGINCHECK_JS 1184
+#define IDR_CRYPTOTOKEN_INDIVIDUALATTEST_JS 1185
+#define IDR_CRYPTOTOKEN_GOOGLECORPINDIVIDUALATTEST_JS 1186
+#define IDR_CRYPTOTOKEN_APPROVEDORIGINS_JS 1187
+#define IDR_CRYPTOTOKEN_WEBREQUESTSENDER_JS 1188
+#define IDR_CRYPTOTOKEN_WINDOW_TIMER_JS 1189
+#define IDR_CRYPTOTOKEN_WATCHDOG_JS 1190
+#define IDR_CRYPTOTOKEN_LOGGING_JS 1191
+#define IDR_CRYPTOTOKEN_CRYPTOTOKENAPPROVEDORIGIN_JS 1192
+#define IDR_CRYPTOTOKEN_CRYPTOTOKENORIGINCHECK_JS 1193
+#define IDR_CRYPTOTOKEN_CRYPTOTOKENBACKGROUND_JS 1194
+#define IDR_WHISPERNET_PROXY_BACKGROUND_HTML 1195
+#define IDR_WHISPERNET_PROXY_INIT_JS 1196
+#define IDR_WHISPERNET_PROXY_NACL_JS 1197
+#define IDR_WHISPERNET_PROXY_WRAPPER_JS 1198
+#define IDR_WHISPERNET_PROXY_WHISPERNET_PROXY_PROXY_NMF 1199
+#define IDR_WHISPERNET_PROXY_WHISPERNET_PROXY_PROXY_PEXE 1200
+
+// ---------------------------------------------------------------------------
+// From content_resources.h:
+
+#define IDR_ACCESSIBILITY_HTML 23950
+#define IDR_ACCESSIBILITY_CSS 23951
+#define IDR_ACCESSIBILITY_JS 23952
+#define IDR_APPCACHE_INTERNALS_HTML 23953
+#define IDR_APPCACHE_INTERNALS_JS 23954
+#define IDR_APPCACHE_INTERNALS_CSS 23955
+#define IDR_DEVTOOLS_PINCH_CURSOR_ICON 23956
+#define IDR_DEVTOOLS_PINCH_CURSOR_ICON_2X 23957
+#define IDR_DEVTOOLS_TOUCH_CURSOR_ICON 23958
+#define IDR_DEVTOOLS_TOUCH_CURSOR_ICON_2X 23959
+#define IDR_GPU_INTERNALS_HTML 23960
+#define IDR_GPU_INTERNALS_JS 23961
+#define IDR_INDEXED_DB_INTERNALS_HTML 23962
+#define IDR_INDEXED_DB_INTERNALS_JS 23963
+#define IDR_INDEXED_DB_INTERNALS_CSS 23964
+#define IDR_MEDIA_INTERNALS_HTML 23965
+#define IDR_MEDIA_INTERNALS_JS 23966
+#define IDR_MOJO_CATALOG_MANIFEST 23967
+#define IDR_MOJO_CONTENT_BROWSER_MANIFEST 23968
+#define IDR_MOJO_CONTENT_RENDERER_MANIFEST 23969
+#define IDR_NETWORK_ERROR_LISTING_HTML 23970
+#define IDR_NETWORK_ERROR_LISTING_JS 23971
+#define IDR_NETWORK_ERROR_LISTING_CSS 23972
+#define IDR_SERVICE_WORKER_INTERNALS_HTML 23973
+#define IDR_SERVICE_WORKER_INTERNALS_JS 23974
+#define IDR_SERVICE_WORKER_INTERNALS_CSS 23975
+#define IDR_WEBRTC_INTERNALS_HTML 23976
+#define IDR_WEBRTC_INTERNALS_JS 23977
+#define IDR_GPU_SANDBOX_PROFILE 23978
+#define IDR_COMMON_SANDBOX_PROFILE 23979
+#define IDR_PPAPI_SANDBOX_PROFILE 23980
+#define IDR_RENDERER_SANDBOX_PROFILE 23981
+#define IDR_UTILITY_SANDBOX_PROFILE 23982
+#define IDR_MOJO_BINDINGS_JS 23983
+#define IDR_MOJO_BUFFER_JS 23984
+#define IDR_MOJO_CODEC_JS 23985
+#define IDR_MOJO_CONNECTION_JS 23986
+#define IDR_MOJO_CONNECTOR_JS 23987
+#define IDR_MOJO_ROUTER_JS 23988
+#define IDR_MOJO_UNICODE_JS 23989
+#define IDR_MOJO_VALIDATOR_JS 23990
+
+// ---------------------------------------------------------------------------
+// From devtools_resources.h:
+
+#define INSPECTOR_HTML 21450
+#define INSPECTOR_JS 21451
+#define TOOLBOX_HTML 21452
+#define TOOLBOX_JS 21453
+#define ACCESSIBILITY_MODULE_JS 21454
+#define ANIMATION_MODULE_JS 21455
+#define AUDITS_MODULE_JS 21456
+#define COMPONENTS_LAZY_MODULE_JS 21457
+#define CONSOLE_MODULE_JS 21458
+#define DEVICES_MODULE_JS 21459
+#define DIFF_MODULE_JS 21460
+#define ELEMENTS_MODULE_JS 21461
+#define ES_TREE_MODULE_JS 21462
+#define HEAP_SNAPSHOT_WORKER_MODULE_JS 21463
+#define LAYERS_MODULE_JS 21464
+#define NETWORK_MODULE_JS 21465
+#define PROFILER_MODULE_JS 21466
+#define RESOURCES_MODULE_JS 21467
+#define SASS_MODULE_JS 21468
+#define SECURITY_MODULE_JS 21469
+#define FORMATTER_WORKER_MODULE_JS 21470
+#define SETTINGS_MODULE_JS 21471
+#define SNIPPETS_MODULE_JS 21472
+#define SOURCE_FRAME_MODULE_JS 21473
+#define SOURCES_MODULE_JS 21474
+#define TEMP_STORAGE_SHARED_WORKER_MODULE_JS 21475
+#define TIMELINE_MODULE_JS 21476
+#define UI_LAZY_MODULE_JS 21477
+#define DEVTOOLS_EXTENSION_API_JS 21478
+#define DEVTOOLS_JS 21479
+#define TESTS_JS 21480
+#define IMAGES_APPLICATIONCACHE_PNG 21481
+#define IMAGES_BREAKPOINT_PNG 21482
+#define IMAGES_BREAKPOINTCONDITIONAL_PNG 21483
+#define IMAGES_BREAKPOINTCONDITIONAL_2X_PNG 21484
+#define IMAGES_BREAKPOINT_2X_PNG 21485
+#define IMAGES_CHECKER_PNG 21486
+#define IMAGES_CHROMEDISABLEDSELECT_PNG 21487
+#define IMAGES_CHROMEDISABLEDSELECT_2X_PNG 21488
+#define IMAGES_CHROMELEFT_PNG 21489
+#define IMAGES_CHROMEMIDDLE_PNG 21490
+#define IMAGES_CHROMERIGHT_PNG 21491
+#define IMAGES_CHROMESELECT_PNG 21492
+#define IMAGES_CHROMESELECT_2X_PNG 21493
+#define IMAGES_COOKIE_PNG 21494
+#define IMAGES_DATABASE_PNG 21495
+#define IMAGES_DATABASETABLE_PNG 21496
+#define IMAGES_DELETEICON_PNG 21497
+#define IMAGES_DOMAIN_PNG 21498
+#define IMAGES_ERRORWAVE_PNG 21499
+#define IMAGES_ERRORWAVE_2X_PNG 21500
+#define IMAGES_FILESYSTEM_PNG 21501
+#define IMAGES_FORWARD_PNG 21502
+#define IMAGES_FRAME_PNG 21503
+#define IMAGES_GRAPHLABELCALLOUTLEFT_PNG 21504
+#define IMAGES_GRAPHLABELCALLOUTRIGHT_PNG 21505
+#define IMAGES_IC_INFO_BLACK_18DP_SVG 21506
+#define IMAGES_IC_WARNING_BLACK_18DP_SVG 21507
+#define IMAGES_INDEXEDDB_PNG 21508
+#define IMAGES_INDEXEDDBINDEX_PNG 21509
+#define IMAGES_INDEXEDDBOBJECTSTORE_PNG 21510
+#define IMAGES_LOCALSTORAGE_PNG 21511
+#define IMAGES_NAVIGATIONCONTROLS_PNG 21512
+#define IMAGES_NAVIGATIONCONTROLS_2X_PNG 21513
+#define IMAGES_PANEADDBUTTONS_PNG 21514
+#define IMAGES_PANEFILTERBUTTONS_PNG 21515
+#define IMAGES_PANEREFRESHBUTTONS_PNG 21516
+#define IMAGES_POPOVERARROWS_PNG 21517
+#define IMAGES_PROFILEGROUPICON_PNG 21518
+#define IMAGES_PROFILEICON_PNG 21519
+#define IMAGES_PROFILESMALLICON_PNG 21520
+#define IMAGES_RADIODOT_PNG 21521
+#define IMAGES_RESIZEDIAGONAL_PNG 21522
+#define IMAGES_RESIZEDIAGONAL_2X_PNG 21523
+#define IMAGES_RESIZEHORIZONTAL_PNG 21524
+#define IMAGES_RESIZEHORIZONTAL_2X_PNG 21525
+#define IMAGES_RESIZEVERTICAL_PNG 21526
+#define IMAGES_RESIZEVERTICAL_2X_PNG 21527
+#define IMAGES_RESOURCECSSICON_PNG 21528
+#define IMAGES_RESOURCEDOCUMENTICON_PNG 21529
+#define IMAGES_RESOURCEDOCUMENTICONSMALL_PNG 21530
+#define IMAGES_RESOURCEJSICON_PNG 21531
+#define IMAGES_RESOURCEPLAINICON_PNG 21532
+#define IMAGES_RESOURCEPLAINICONSMALL_PNG 21533
+#define IMAGES_RESOURCESTIMEGRAPHICON_PNG 21534
+#define IMAGES_SEARCHNEXT_PNG 21535
+#define IMAGES_SEARCHPREV_PNG 21536
+#define IMAGES_SECURITYPROPERTYINFO_SVG 21537
+#define IMAGES_SECURITYPROPERTYINSECURE_SVG 21538
+#define IMAGES_SECURITYPROPERTYSECURE_SVG 21539
+#define IMAGES_SECURITYPROPERTYUNKNOWN_SVG 21540
+#define IMAGES_SECURITYPROPERTYWARNING_SVG 21541
+#define IMAGES_SECURITYSTATEINSECURE_SVG 21542
+#define IMAGES_SECURITYSTATENEUTRAL_SVG 21543
+#define IMAGES_SECURITYSTATESECURE_SVG 21544
+#define IMAGES_SERVICEWORKER_SVG 21545
+#define IMAGES_SESSIONSTORAGE_PNG 21546
+#define IMAGES_SETTINGSLISTREMOVE_PNG 21547
+#define IMAGES_SETTINGSLISTREMOVE_2X_PNG 21548
+#define IMAGES_SPEECH_PNG 21549
+#define IMAGES_TOOLBARBUTTONGLYPHS_PNG 21550
+#define IMAGES_TOOLBARBUTTONGLYPHS_2X_PNG 21551
+#define IMAGES_TOOLBARITEMSELECTED_PNG 21552
+#define IMAGES_TOOLBARRESIZERHORIZONTAL_PNG 21553
+#define IMAGES_TOOLBARRESIZERVERTICAL_PNG 21554
+#define IMAGES_TOUCHCURSOR_PNG 21555
+#define IMAGES_TOUCHCURSOR_2X_PNG 21556
+#define IMAGES_TRANSFORMCONTROLS_PNG 21557
+#define IMAGES_TRANSFORMCONTROLS_2X_PNG 21558
+
+// ---------------------------------------------------------------------------
+// From extensions_browser_resources.h:
+
+#define IDR_APP_DEFAULT_ICON 25750
+#define IDR_EXTENSION_DEFAULT_ICON 25751
+#define IDR_EXTENSION_ACTION_PLAIN_BACKGROUND 25752
+#define IDR_EXTENSION_ICON_PLAIN_BACKGROUND 25753
+
+// ---------------------------------------------------------------------------
+// From extensions_renderer_resources.h:
+
+#define IDR_APP_VIEW_JS 25800
+#define IDR_ASYNC_WAITER_JS 25801
+#define IDR_BROWSER_TEST_ENVIRONMENT_SPECIFIC_BINDINGS_JS 25802
+#define IDR_DATA_RECEIVER_JS 25803
+#define IDR_DATA_SENDER_JS 25804
+#define IDR_DATA_STREAM_MOJOM_JS 25805
+#define IDR_DATA_STREAM_SERIALIZATION_MOJOM_JS 25806
+#define IDR_ENTRY_ID_MANAGER 25807
+#define IDR_EVENT_BINDINGS_JS 25808
+#define IDR_EXTENSION_OPTIONS_JS 25809
+#define IDR_EXTENSION_OPTIONS_ATTRIBUTES_JS 25810
+#define IDR_EXTENSION_OPTIONS_CONSTANTS_JS 25811
+#define IDR_EXTENSION_OPTIONS_EVENTS_JS 25812
+#define IDR_EXTENSION_VIEW_JS 25813
+#define IDR_EXTENSION_VIEW_API_METHODS_JS 25814
+#define IDR_EXTENSION_VIEW_ATTRIBUTES_JS 25815
+#define IDR_EXTENSION_VIEW_CONSTANTS_JS 25816
+#define IDR_EXTENSION_VIEW_EVENTS_JS 25817
+#define IDR_EXTENSION_VIEW_INTERNAL_CUSTOM_BINDINGS_JS 25818
+#define IDR_GUEST_VIEW_ATTRIBUTES_JS 25819
+#define IDR_GUEST_VIEW_CONTAINER_JS 25820
+#define IDR_GUEST_VIEW_DENY_JS 25821
+#define IDR_GUEST_VIEW_EVENTS_JS 25822
+#define IDR_GUEST_VIEW_IFRAME_CONTAINER_JS 25823
+#define IDR_GUEST_VIEW_IFRAME_JS 25824
+#define IDR_GUEST_VIEW_JS 25825
+#define IDR_IMAGE_UTIL_JS 25826
+#define IDR_JSON_SCHEMA_JS 25827
+#define IDR_KEEP_ALIVE_JS 25828
+#define IDR_KEEP_ALIVE_MOJOM_JS 25829
+#define IDR_LAST_ERROR_JS 25830
+#define IDR_MESSAGING_JS 25831
+#define IDR_MESSAGING_UTILS_JS 25832
+#define IDR_MIME_HANDLER_PRIVATE_CUSTOM_BINDINGS_JS 25833
+#define IDR_MIME_HANDLER_MOJOM_JS 25834
+#define IDR_SCHEMA_UTILS_JS 25835
+#define IDR_SEND_REQUEST_JS 25836
+#define IDR_SERIAL_CUSTOM_BINDINGS_JS 25837
+#define IDR_SERIAL_MOJOM_JS 25838
+#define IDR_SERIAL_SERIALIZATION_MOJOM_JS 25839
+#define IDR_SERIAL_SERVICE_JS 25840
+#define IDR_SET_ICON_JS 25841
+#define IDR_STASH_CLIENT_JS 25842
+#define IDR_STASH_MOJOM_JS 25843
+#define IDR_TEST_CUSTOM_BINDINGS_JS 25844
+#define IDR_UNCAUGHT_EXCEPTION_HANDLER_JS 25845
+#define IDR_UTILS_JS 25846
+#define IDR_WEB_VIEW_ACTION_REQUESTS_JS 25847
+#define IDR_WEB_VIEW_API_METHODS_JS 25848
+#define IDR_WEB_VIEW_ATTRIBUTES_JS 25849
+#define IDR_WEB_VIEW_CONSTANTS_JS 25850
+#define IDR_WEB_VIEW_EVENTS_JS 25851
+#define IDR_WEB_VIEW_EXPERIMENTAL_JS 25852
+#define IDR_WEB_VIEW_INTERNAL_CUSTOM_BINDINGS_JS 25853
+#define IDR_WEB_VIEW_JS 25854
+#define IDR_APP_RUNTIME_CUSTOM_BINDINGS_JS 25855
+#define IDR_APP_WINDOW_CUSTOM_BINDINGS_JS 25856
+#define IDR_BINDING_JS 25857
+#define IDR_CONTEXT_MENUS_CUSTOM_BINDINGS_JS 25858
+#define IDR_CONTEXT_MENUS_HANDLERS_JS 25859
+#define IDR_DECLARATIVE_WEBREQUEST_CUSTOM_BINDINGS_JS 25860
+#define IDR_DISPLAY_SOURCE_CUSTOM_BINDINGS_JS 25861
+#define IDR_EXTENSION_CUSTOM_BINDINGS_JS 25862
+#define IDR_GREASEMONKEY_API_JS 25863
+#define IDR_I18N_CUSTOM_BINDINGS_JS 25864
+#define IDR_MOJO_PRIVATE_CUSTOM_BINDINGS_JS 25865
+#define IDR_PERMISSIONS_CUSTOM_BINDINGS_JS 25866
+#define IDR_PRINTER_PROVIDER_CUSTOM_BINDINGS_JS 25867
+#define IDR_RUNTIME_CUSTOM_BINDINGS_JS 25868
+#define IDR_SERVICE_WORKER_BINDINGS_JS 25869
+#define IDR_WEB_REQUEST_CUSTOM_BINDINGS_JS 25870
+#define IDR_WEB_REQUEST_INTERNAL_CUSTOM_BINDINGS_JS 25871
+#define IDR_WINDOW_CONTROLS_JS 25872
+#define IDR_WINDOW_CONTROLS_TEMPLATE_HTML 25873
+#define IDR_WEB_VIEW_REQUEST_CUSTOM_BINDINGS_JS 25874
+#define IDR_STORAGE_AREA_JS 25875
+#define IDR_PLATFORM_APP_CSS 25876
+#define IDR_PLATFORM_APP_JS 25877
+#define IDR_EXTENSION_FONTS_CSS 25878
+#define IDR_MEDIA_ROUTER_MOJOM_JS 25879
+#define IDR_MEDIA_ROUTER_BINDINGS_JS 25880
+#define IDR_EXTENSION_CSS 25900
+
+// ---------------------------------------------------------------------------
+// From extensions_resources.h:
+
+#define IDR_EXTENSION_API_FEATURES 25550
+#define IDR_EXTENSION_API_JSON_DECLARATIVE_WEBREQUEST 25551
+#define IDR_EXTENSION_API_JSON_WEB_VIEW_REQUEST 25552
+#define IDR_EXTENSION_MANIFEST_FEATURES 25553
+#define IDR_EXTENSION_PERMISSION_FEATURES 25554
+#define IDR_EXTENSION_BEHAVIOR_FEATURES 25555
+
+// ---------------------------------------------------------------------------
+// From net_resources.h:
+
+#define IDR_DIR_HEADER_HTML 4000
+
+// ---------------------------------------------------------------------------
+// From ui_resources.h:
+
+#define IDR_AURA_CURSOR_BIG_ALIAS 5500
+#define IDR_AURA_CURSOR_BIG_CELL 5501
+#define IDR_AURA_CURSOR_BIG_COL_RESIZE 5502
+#define IDR_AURA_CURSOR_BIG_CONTEXT_MENU 5503
+#define IDR_AURA_CURSOR_BIG_COPY 5504
+#define IDR_AURA_CURSOR_BIG_CROSSHAIR 5505
+#define IDR_AURA_CURSOR_BIG_EAST_RESIZE 5506
+#define IDR_AURA_CURSOR_BIG_EAST_WEST_RESIZE 5507
+#define IDR_AURA_CURSOR_BIG_HAND 5508
+#define IDR_AURA_CURSOR_BIG_HELP 5509
+#define IDR_AURA_CURSOR_BIG_IBEAM 5510
+#define IDR_AURA_CURSOR_BIG_MOVE 5511
+#define IDR_AURA_CURSOR_BIG_NORTH_EAST_RESIZE 5512
+#define IDR_AURA_CURSOR_BIG_NORTH_EAST_SOUTH_WEST_RESIZE 5513
+#define IDR_AURA_CURSOR_BIG_NORTH_RESIZE 5514
+#define IDR_AURA_CURSOR_BIG_NORTH_SOUTH_RESIZE 5515
+#define IDR_AURA_CURSOR_BIG_NORTH_WEST_RESIZE 5516
+#define IDR_AURA_CURSOR_BIG_NORTH_WEST_SOUTH_EAST_RESIZE 5517
+#define IDR_AURA_CURSOR_BIG_NO_DROP 5518
+#define IDR_AURA_CURSOR_BIG_PTR 5519
+#define IDR_AURA_CURSOR_BIG_ROW_RESIZE 5520
+#define IDR_AURA_CURSOR_BIG_SOUTH_EAST_RESIZE 5521
+#define IDR_AURA_CURSOR_BIG_SOUTH_RESIZE 5522
+#define IDR_AURA_CURSOR_BIG_SOUTH_WEST_RESIZE 5523
+#define IDR_AURA_CURSOR_BIG_WEST_RESIZE 5524
+#define IDR_AURA_CURSOR_BIG_XTERM_HORIZ 5525
+#define IDR_AURA_CURSOR_BIG_ZOOM_IN 5526
+#define IDR_AURA_CURSOR_BIG_ZOOM_OUT 5527
+#define IDR_AURA_CURSOR_BIG_GRAB 5528
+#define IDR_AURA_CURSOR_BIG_GRABBING 5529
+#define IDR_AURA_CURSOR_ALIAS 5530
+#define IDR_AURA_CURSOR_CELL 5531
+#define IDR_AURA_CURSOR_COL_RESIZE 5532
+#define IDR_AURA_CURSOR_CONTEXT_MENU 5533
+#define IDR_AURA_CURSOR_COPY 5534
+#define IDR_AURA_CURSOR_CROSSHAIR 5535
+#define IDR_AURA_CURSOR_EAST_RESIZE 5536
+#define IDR_AURA_CURSOR_EAST_WEST_RESIZE 5537
+#define IDR_AURA_CURSOR_HAND 5538
+#define IDR_AURA_CURSOR_HELP 5539
+#define IDR_AURA_CURSOR_IBEAM 5540
+#define IDR_AURA_CURSOR_MOVE 5541
+#define IDR_AURA_CURSOR_NORTH_EAST_RESIZE 5542
+#define IDR_AURA_CURSOR_NORTH_EAST_SOUTH_WEST_RESIZE 5543
+#define IDR_AURA_CURSOR_NORTH_RESIZE 5544
+#define IDR_AURA_CURSOR_NORTH_SOUTH_RESIZE 5545
+#define IDR_AURA_CURSOR_NORTH_WEST_RESIZE 5546
+#define IDR_AURA_CURSOR_NORTH_WEST_SOUTH_EAST_RESIZE 5547
+#define IDR_AURA_CURSOR_NO_DROP 5548
+#define IDR_AURA_CURSOR_PTR 5549
+#define IDR_AURA_CURSOR_ROW_RESIZE 5550
+#define IDR_AURA_CURSOR_SOUTH_EAST_RESIZE 5551
+#define IDR_AURA_CURSOR_SOUTH_RESIZE 5552
+#define IDR_AURA_CURSOR_SOUTH_WEST_RESIZE 5553
+#define IDR_AURA_CURSOR_THROBBER 5554
+#define IDR_AURA_CURSOR_WEST_RESIZE 5555
+#define IDR_AURA_CURSOR_XTERM_HORIZ 5556
+#define IDR_AURA_CURSOR_ZOOM_IN 5557
+#define IDR_AURA_CURSOR_ZOOM_OUT 5558
+#define IDR_AURA_CURSOR_GRAB 5559
+#define IDR_AURA_CURSOR_GRABBING 5560
+#define IDR_AURA_SHADOW_ACTIVE 5561
+#define IDR_AURA_SHADOW_INACTIVE 5562
+#define IDR_WINDOW_BUBBLE_SHADOW_SMALL 5563
+#define IDR_BACK_ARROW 5564
+#define IDR_FORWARD_ARROW 5565
+#define IDR_BROWSER_ACTION_BADGE_CENTER 5566
+#define IDR_BROWSER_ACTION_BADGE_LEFT 5567
+#define IDR_BROWSER_ACTION_BADGE_RIGHT 5568
+#define IDR_CLOSE_2 5569
+#define IDR_CLOSE_2_H 5570
+#define IDR_CLOSE_2_MASK 5571
+#define IDR_CLOSE_2_P 5572
+#define IDR_CLOSE_3_MASK 5573
+#define IDR_CLOSE_4_BUTTON 5574
+#define IDR_CLOSE_DIALOG 5575
+#define IDR_CLOSE_DIALOG_H 5576
+#define IDR_CLOSE_DIALOG_P 5577
+#define IDR_DISABLE 5578
+#define IDR_DISABLE_H 5579
+#define IDR_DISABLE_P 5580
+#define IDR_DEFAULT_FAVICON 5581
+#define IDR_DEFAULT_FAVICON_32 5582
+#define IDR_DEFAULT_FAVICON_64 5583
+#define IDR_EASY_UNLOCK_HARDLOCKED 5584
+#define IDR_EASY_UNLOCK_HARDLOCKED_HOVER 5585
+#define IDR_EASY_UNLOCK_HARDLOCKED_PRESSED 5586
+#define IDR_EASY_UNLOCK_LOCKED 5587
+#define IDR_EASY_UNLOCK_LOCKED_HOVER 5588
+#define IDR_EASY_UNLOCK_LOCKED_PRESSED 5589
+#define IDR_EASY_UNLOCK_LOCKED_TO_BE_ACTIVATED 5590
+#define IDR_EASY_UNLOCK_LOCKED_TO_BE_ACTIVATED_HOVER 5591
+#define IDR_EASY_UNLOCK_LOCKED_TO_BE_ACTIVATED_PRESSED 5592
+#define IDR_EASY_UNLOCK_LOCKED_WITH_PROXIMITY_HINT 5593
+#define IDR_EASY_UNLOCK_LOCKED_WITH_PROXIMITY_HINT_HOVER 5594
+#define IDR_EASY_UNLOCK_LOCKED_WITH_PROXIMITY_HINT_PRESSED 5595
+#define IDR_EASY_UNLOCK_SPINNER 5596
+#define IDR_EASY_UNLOCK_UNLOCKED 5597
+#define IDR_EASY_UNLOCK_UNLOCKED_HOVER 5598
+#define IDR_EASY_UNLOCK_UNLOCKED_PRESSED 5599
+#define IDR_FOLDER_CLOSED 5600
+#define IDR_FOLDER_CLOSED_RTL 5601
+#define IDR_MENU_CHECK_CHECKED 5602
+#define IDR_MENU_HIERARCHY_ARROW 5603
+#define IDR_MENU_DROPARROW 5604
+#define IDR_MESSAGE_CLOSE 5605
+#define IDR_NOTIFICATION_ARROW 5606
+#define IDR_NOTIFICATION_ARROW_HOVER 5607
+#define IDR_NOTIFICATION_ARROW_PRESSED 5608
+#define IDR_NOTIFICATION_ADVANCED_SETTINGS 5609
+#define IDR_NOTIFICATION_ADVANCED_SETTINGS_HOVER 5610
+#define IDR_NOTIFICATION_ADVANCED_SETTINGS_PRESSED 5611
+#define IDR_NOTIFICATION_CLEAR_ALL 5612
+#define IDR_NOTIFICATION_CLEAR_ALL_DISABLED 5613
+#define IDR_NOTIFICATION_CLEAR_ALL_HOVER 5614
+#define IDR_NOTIFICATION_CLEAR_ALL_PRESSED 5615
+#define IDR_NOTIFICATION_CLOSE 5616
+#define IDR_NOTIFICATION_CLOSE_HOVER 5617
+#define IDR_NOTIFICATION_CLOSE_PRESSED 5618
+#define IDR_NOTIFICATION_BUBBLE_CLOSE 5619
+#define IDR_NOTIFICATION_BUBBLE_CLOSE_HOVER 5620
+#define IDR_NOTIFICATION_BUBBLE_CLOSE_PRESSED 5621
+#define IDR_NOTIFICATION_DO_NOT_DISTURB 5622
+#define IDR_NOTIFICATION_DO_NOT_DISTURB_HOVER 5623
+#define IDR_NOTIFICATION_DO_NOT_DISTURB_PRESSED 5624
+#define IDR_NOTIFICATION_SETTINGS 5625
+#define IDR_NOTIFICATION_SETTINGS_BUTTON_ICON 5626
+#define IDR_NOTIFICATION_SETTINGS_BUTTON_ICON_HOVER 5627
+#define IDR_NOTIFICATION_SETTINGS_BUTTON_ICON_PRESSED 5628
+#define IDR_NOTIFICATION_SETTINGS_HOVER 5629
+#define IDR_NOTIFICATION_SETTINGS_PRESSED 5630
+#define IDR_NTP_DEFAULT_FAVICON 5631
+#define IDR_OOBE_ACTION_BOX_BUTTON_HOVER 5632
+#define IDR_OOBE_ACTION_BOX_BUTTON_NORMAL 5633
+#define IDR_OOBE_ACTION_BOX_BUTTON_PRESSED 5634
+#define IDR_PANEL_TOP_LEFT_CORNER 5635
+#define IDR_PANEL_TOP_RIGHT_CORNER 5636
+#define IDR_PANEL_BOTTOM_LEFT_CORNER 5637
+#define IDR_PANEL_BOTTOM_RIGHT_CORNER 5638
+#define IDR_TEXT_SELECTION_HANDLE_CENTER 5639
+#define IDR_TEXT_SELECTION_HANDLE_LEFT 5640
+#define IDR_TEXT_SELECTION_HANDLE_RIGHT 5641
+#define IDR_THROBBER 5642
+#define IDR_TOUCH_DRAG_TIP_COPY 5643
+#define IDR_TOUCH_DRAG_TIP_MOVE 5644
+#define IDR_TOUCH_DRAG_TIP_LINK 5645
+#define IDR_TOUCH_DRAG_TIP_NODROP 5646
+
+// ---------------------------------------------------------------------------
+// From views_resources.h:
+
+#define IDR_APP_TOP_CENTER 5800
+#define IDR_APP_TOP_LEFT 5801
+#define IDR_APP_TOP_RIGHT 5802
+#define IDR_BUBBLE_B 5803
+#define IDR_BUBBLE_BL 5804
+#define IDR_BUBBLE_BR 5805
+#define IDR_BUBBLE_B_ARROW 5806
+#define IDR_BUBBLE_L 5807
+#define IDR_BUBBLE_L_ARROW 5808
+#define IDR_BUBBLE_R 5809
+#define IDR_BUBBLE_R_ARROW 5810
+#define IDR_BUBBLE_T 5811
+#define IDR_BUBBLE_TL 5812
+#define IDR_BUBBLE_TR 5813
+#define IDR_BUBBLE_T_ARROW 5814
+#define IDR_BUTTON_DISABLED 5815
+#define IDR_BUTTON_FOCUSED_HOVER 5816
+#define IDR_BUTTON_FOCUSED_NORMAL 5817
+#define IDR_BUTTON_FOCUSED_PRESSED 5818
+#define IDR_BUTTON_HOVER 5819
+#define IDR_BUTTON_NORMAL 5820
+#define IDR_BUTTON_PRESSED 5821
+#define IDR_BLUE_BUTTON_DISABLED 5822
+#define IDR_BLUE_BUTTON_FOCUSED_HOVER 5823
+#define IDR_BLUE_BUTTON_FOCUSED_NORMAL 5824
+#define IDR_BLUE_BUTTON_FOCUSED_PRESSED 5825
+#define IDR_BLUE_BUTTON_HOVER 5826
+#define IDR_BLUE_BUTTON_NORMAL 5827
+#define IDR_BLUE_BUTTON_PRESSED 5828
+#define IDR_CHECKBOX 5829
+#define IDR_CHECKBOX_CHECKED 5830
+#define IDR_CHECKBOX_CHECKED_DISABLED 5831
+#define IDR_CHECKBOX_CHECKED_HOVER 5832
+#define IDR_CHECKBOX_CHECKED_PRESSED 5833
+#define IDR_CHECKBOX_DISABLED 5834
+#define IDR_CHECKBOX_FOCUSED 5835
+#define IDR_CHECKBOX_FOCUSED_CHECKED 5836
+#define IDR_CHECKBOX_FOCUSED_CHECKED_HOVER 5837
+#define IDR_CHECKBOX_FOCUSED_CHECKED_PRESSED 5838
+#define IDR_CHECKBOX_FOCUSED_HOVER 5839
+#define IDR_CHECKBOX_FOCUSED_PRESSED 5840
+#define IDR_CHECKBOX_HOVER 5841
+#define IDR_CHECKBOX_PRESSED 5842
+#define IDR_CLOSE 5843
+#define IDR_CLOSE_H 5844
+#define IDR_CLOSE_P 5845
+#define IDR_COMBOBOX_BUTTON_BOTTOM 5846
+#define IDR_COMBOBOX_BUTTON_H_BOTTOM 5847
+#define IDR_COMBOBOX_BUTTON_P_BOTTOM 5848
+#define IDR_COMBOBOX_BUTTON_BOTTOM_LEFT 5849
+#define IDR_COMBOBOX_BUTTON_H_BOTTOM_LEFT 5850
+#define IDR_COMBOBOX_BUTTON_P_BOTTOM_LEFT 5851
+#define IDR_COMBOBOX_BUTTON_BOTTOM_RIGHT 5852
+#define IDR_COMBOBOX_BUTTON_H_BOTTOM_RIGHT 5853
+#define IDR_COMBOBOX_BUTTON_P_BOTTOM_RIGHT 5854
+#define IDR_COMBOBOX_BUTTON_CENTER 5855
+#define IDR_COMBOBOX_BUTTON_H_CENTER 5856
+#define IDR_COMBOBOX_BUTTON_P_CENTER 5857
+#define IDR_COMBOBOX_BUTTON_LEFT 5858
+#define IDR_COMBOBOX_BUTTON_H_LEFT 5859
+#define IDR_COMBOBOX_BUTTON_P_LEFT 5860
+#define IDR_COMBOBOX_BUTTON_RIGHT 5861
+#define IDR_COMBOBOX_BUTTON_H_RIGHT 5862
+#define IDR_COMBOBOX_BUTTON_P_RIGHT 5863
+#define IDR_COMBOBOX_BUTTON_MENU_BOTTOM 5864
+#define IDR_COMBOBOX_BUTTON_H_MENU_BOTTOM 5865
+#define IDR_COMBOBOX_BUTTON_P_MENU_BOTTOM 5866
+#define IDR_COMBOBOX_BUTTON_MENU_CENTER 5867
+#define IDR_COMBOBOX_BUTTON_H_MENU_CENTER 5868
+#define IDR_COMBOBOX_BUTTON_P_MENU_CENTER 5869
+#define IDR_COMBOBOX_BUTTON_MENU_TOP 5870
+#define IDR_COMBOBOX_BUTTON_H_MENU_TOP 5871
+#define IDR_COMBOBOX_BUTTON_P_MENU_TOP 5872
+#define IDR_COMBOBOX_BUTTON_TOP 5873
+#define IDR_COMBOBOX_BUTTON_H_TOP 5874
+#define IDR_COMBOBOX_BUTTON_P_TOP 5875
+#define IDR_COMBOBOX_BUTTON_TOP_LEFT 5876
+#define IDR_COMBOBOX_BUTTON_H_TOP_LEFT 5877
+#define IDR_COMBOBOX_BUTTON_P_TOP_LEFT 5878
+#define IDR_COMBOBOX_BUTTON_TOP_RIGHT 5879
+#define IDR_COMBOBOX_BUTTON_H_TOP_RIGHT 5880
+#define IDR_COMBOBOX_BUTTON_P_TOP_RIGHT 5881
+#define IDR_COMBOBOX_BUTTON_F_BOTTOM 5882
+#define IDR_COMBOBOX_BUTTON_F_H_BOTTOM 5883
+#define IDR_COMBOBOX_BUTTON_F_P_BOTTOM 5884
+#define IDR_COMBOBOX_BUTTON_F_BOTTOM_LEFT 5885
+#define IDR_COMBOBOX_BUTTON_F_H_BOTTOM_LEFT 5886
+#define IDR_COMBOBOX_BUTTON_F_P_BOTTOM_LEFT 5887
+#define IDR_COMBOBOX_BUTTON_F_BOTTOM_RIGHT 5888
+#define IDR_COMBOBOX_BUTTON_F_H_BOTTOM_RIGHT 5889
+#define IDR_COMBOBOX_BUTTON_F_P_BOTTOM_RIGHT 5890
+#define IDR_COMBOBOX_BUTTON_F_CENTER 5891
+#define IDR_COMBOBOX_BUTTON_F_H_CENTER 5892
+#define IDR_COMBOBOX_BUTTON_F_P_CENTER 5893
+#define IDR_COMBOBOX_BUTTON_F_LEFT 5894
+#define IDR_COMBOBOX_BUTTON_F_H_LEFT 5895
+#define IDR_COMBOBOX_BUTTON_F_P_LEFT 5896
+#define IDR_COMBOBOX_BUTTON_F_RIGHT 5897
+#define IDR_COMBOBOX_BUTTON_F_H_RIGHT 5898
+#define IDR_COMBOBOX_BUTTON_F_P_RIGHT 5899
+#define IDR_COMBOBOX_BUTTON_F_MENU_BOTTOM 5900
+#define IDR_COMBOBOX_BUTTON_F_H_MENU_BOTTOM 5901
+#define IDR_COMBOBOX_BUTTON_F_P_MENU_BOTTOM 5902
+#define IDR_COMBOBOX_BUTTON_F_MENU_CENTER 5903
+#define IDR_COMBOBOX_BUTTON_F_H_MENU_CENTER 5904
+#define IDR_COMBOBOX_BUTTON_F_P_MENU_CENTER 5905
+#define IDR_COMBOBOX_BUTTON_F_MENU_TOP 5906
+#define IDR_COMBOBOX_BUTTON_F_H_MENU_TOP 5907
+#define IDR_COMBOBOX_BUTTON_F_P_MENU_TOP 5908
+#define IDR_COMBOBOX_BUTTON_F_TOP 5909
+#define IDR_COMBOBOX_BUTTON_F_H_TOP 5910
+#define IDR_COMBOBOX_BUTTON_F_P_TOP 5911
+#define IDR_COMBOBOX_BUTTON_F_TOP_LEFT 5912
+#define IDR_COMBOBOX_BUTTON_F_H_TOP_LEFT 5913
+#define IDR_COMBOBOX_BUTTON_F_P_TOP_LEFT 5914
+#define IDR_COMBOBOX_BUTTON_F_TOP_RIGHT 5915
+#define IDR_COMBOBOX_BUTTON_F_H_TOP_RIGHT 5916
+#define IDR_COMBOBOX_BUTTON_F_P_TOP_RIGHT 5917
+#define IDR_CONTENT_BOTTOM_CENTER 5918
+#define IDR_CONTENT_BOTTOM_LEFT_CORNER 5919
+#define IDR_CONTENT_BOTTOM_RIGHT_CORNER 5920
+#define IDR_CONTENT_LEFT_SIDE 5921
+#define IDR_CONTENT_RIGHT_SIDE 5922
+#define IDR_FOLDER_OPEN 5923
+#define IDR_FOLDER_OPEN_RTL 5924
+#define IDR_FRAME 5925
+#define IDR_FRAME_INACTIVE 5926
+#define IDR_MAXIMIZE 5927
+#define IDR_MAXIMIZE_H 5928
+#define IDR_MAXIMIZE_P 5929
+#define IDR_MENU_CHECK 5930
+#define IDR_SLIDER_ACTIVE_LEFT 5931
+#define IDR_SLIDER_ACTIVE_RIGHT 5932
+#define IDR_SLIDER_ACTIVE_CENTER 5933
+#define IDR_SLIDER_DISABLED_LEFT 5934
+#define IDR_SLIDER_DISABLED_RIGHT 5935
+#define IDR_SLIDER_DISABLED_CENTER 5936
+#define IDR_SLIDER_PRESSED_LEFT 5937
+#define IDR_SLIDER_PRESSED_RIGHT 5938
+#define IDR_SLIDER_PRESSED_CENTER 5939
+#define IDR_SLIDER_ACTIVE_THUMB 5940
+#define IDR_SLIDER_DISABLED_THUMB 5941
+#define IDR_MINIMIZE 5942
+#define IDR_MINIMIZE_H 5943
+#define IDR_MINIMIZE_P 5944
+#define IDR_RADIO 5945
+#define IDR_RADIO_CHECKED 5946
+#define IDR_RADIO_CHECKED_DISABLED 5947
+#define IDR_RADIO_CHECKED_HOVER 5948
+#define IDR_RADIO_CHECKED_PRESSED 5949
+#define IDR_RADIO_DISABLED 5950
+#define IDR_RADIO_FOCUSED 5951
+#define IDR_RADIO_FOCUSED_CHECKED 5952
+#define IDR_RADIO_FOCUSED_CHECKED_HOVER 5953
+#define IDR_RADIO_FOCUSED_CHECKED_PRESSED 5954
+#define IDR_RADIO_FOCUSED_HOVER 5955
+#define IDR_RADIO_FOCUSED_PRESSED 5956
+#define IDR_RADIO_HOVER 5957
+#define IDR_RADIO_PRESSED 5958
+#define IDR_RESTORE 5959
+#define IDR_RESTORE_H 5960
+#define IDR_RESTORE_P 5961
+#define IDR_TEXTBUTTON_HOVER_BOTTOM 5962
+#define IDR_TEXTBUTTON_HOVER_BOTTOM_LEFT 5963
+#define IDR_TEXTBUTTON_HOVER_BOTTOM_RIGHT 5964
+#define IDR_TEXTBUTTON_HOVER_CENTER 5965
+#define IDR_TEXTBUTTON_HOVER_LEFT 5966
+#define IDR_TEXTBUTTON_HOVER_RIGHT 5967
+#define IDR_TEXTBUTTON_HOVER_TOP 5968
+#define IDR_TEXTBUTTON_HOVER_TOP_LEFT 5969
+#define IDR_TEXTBUTTON_HOVER_TOP_RIGHT 5970
+#define IDR_TEXTBUTTON_PRESSED_BOTTOM 5971
+#define IDR_TEXTBUTTON_PRESSED_BOTTOM_LEFT 5972
+#define IDR_TEXTBUTTON_PRESSED_BOTTOM_RIGHT 5973
+#define IDR_TEXTBUTTON_PRESSED_CENTER 5974
+#define IDR_TEXTBUTTON_PRESSED_LEFT 5975
+#define IDR_TEXTBUTTON_PRESSED_RIGHT 5976
+#define IDR_TEXTBUTTON_PRESSED_TOP 5977
+#define IDR_TEXTBUTTON_PRESSED_TOP_LEFT 5978
+#define IDR_TEXTBUTTON_PRESSED_TOP_RIGHT 5979
+#define IDR_WINDOW_BOTTOM_CENTER 5980
+#define IDR_WINDOW_BOTTOM_LEFT_CORNER 5981
+#define IDR_WINDOW_BOTTOM_RIGHT_CORNER 5982
+#define IDR_WINDOW_LEFT_SIDE 5983
+#define IDR_WINDOW_RIGHT_SIDE 5984
+#define IDR_WINDOW_TOP_CENTER 5985
+#define IDR_WINDOW_TOP_LEFT_CORNER 5986
+#define IDR_WINDOW_TOP_RIGHT_CORNER 5987
+#define IDR_WINDOW_BUBBLE_SHADOW_BIG_BOTTOM 5988
+#define IDR_WINDOW_BUBBLE_SHADOW_BIG_BOTTOM_LEFT 5989
+#define IDR_WINDOW_BUBBLE_SHADOW_BIG_BOTTOM_RIGHT 5990
+#define IDR_WINDOW_BUBBLE_SHADOW_BIG_LEFT 5991
+#define IDR_WINDOW_BUBBLE_SHADOW_BIG_RIGHT 5992
+#define IDR_WINDOW_BUBBLE_SHADOW_BIG_TOP 5993
+#define IDR_WINDOW_BUBBLE_SHADOW_BIG_TOP_LEFT 5994
+#define IDR_WINDOW_BUBBLE_SHADOW_BIG_TOP_RIGHT 5995
+#define IDR_WINDOW_BUBBLE_SHADOW_SPIKE_BIG_BOTTOM 5996
+#define IDR_WINDOW_BUBBLE_SHADOW_SPIKE_BIG_LEFT 5997
+#define IDR_WINDOW_BUBBLE_SHADOW_SPIKE_BIG_RIGHT 5998
+#define IDR_WINDOW_BUBBLE_SHADOW_SPIKE_BIG_TOP 5999
+#define IDR_WINDOW_BUBBLE_SHADOW_SMALL_BOTTOM 6000
+#define IDR_WINDOW_BUBBLE_SHADOW_SMALL_BOTTOM_LEFT 6001
+#define IDR_WINDOW_BUBBLE_SHADOW_SMALL_BOTTOM_RIGHT 6002
+#define IDR_WINDOW_BUBBLE_SHADOW_SMALL_LEFT 6003
+#define IDR_WINDOW_BUBBLE_SHADOW_SMALL_RIGHT 6004
+#define IDR_WINDOW_BUBBLE_SHADOW_SMALL_TOP 6005
+#define IDR_WINDOW_BUBBLE_SHADOW_SMALL_TOP_LEFT 6006
+#define IDR_WINDOW_BUBBLE_SHADOW_SMALL_TOP_RIGHT 6007
+#define IDR_WINDOW_BUBBLE_SHADOW_SPIKE_SMALL_BOTTOM 6008
+#define IDR_WINDOW_BUBBLE_SHADOW_SPIKE_SMALL_LEFT 6009
+#define IDR_WINDOW_BUBBLE_SHADOW_SPIKE_SMALL_RIGHT 6010
+#define IDR_WINDOW_BUBBLE_SHADOW_SPIKE_SMALL_TOP 6011
+
+// ---------------------------------------------------------------------------
+// From webui_resources.h:
+
+#define IDR_WEBUI_I18N_TEMPLATE_JS 2000
+#define IDR_WEBUI_JSTEMPLATE_JS 2001
+#define IDR_WEBUI_ANALYTICS_JS 2002
+#define IDR_WEBUI_ROBOTO_ROBOTO_LIGHT_WOFF2 2003
+#define IDR_WEBUI_ROBOTO_ROBOTO_REGULAR_WOFF2 2004
+#define IDR_WEBUI_ROBOTO_ROBOTO_MEDIUM_WOFF2 2005
+#define IDR_WEBUI_IMAGES_APPS_BUTTON 2006
+#define IDR_WEBUI_IMAGES_APPS_BUTTON_PRESSED 2007
+#define IDR_WEBUI_IMAGES_APPS_BUTTON_HOVER 2008
+#define IDR_WEBUI_IMAGES_APPS_BUTTON_DISABLED 2009
+#define IDR_WEBUI_IMAGES_APPS_BUTTON_FOCUSED 2010
+#define IDR_WEBUI_IMAGES_APPS_BUTTON_FOCUSED_PRESSED 2011
+#define IDR_WEBUI_IMAGES_APPS_BUTTON_FOCUSED_HOVER 2012
+#define IDR_WEBUI_IMAGES_APPS_BLUE_BUTTON 2013
+#define IDR_WEBUI_IMAGES_APPS_BLUE_BUTTON_PRESSED 2014
+#define IDR_WEBUI_IMAGES_APPS_BLUE_BUTTON_HOVER 2015
+#define IDR_WEBUI_IMAGES_APPS_BLUE_BUTTON_DISABLED 2016
+#define IDR_WEBUI_IMAGES_APPS_BLUE_BUTTON_FOCUSED 2017
+#define IDR_WEBUI_IMAGES_APPS_BLUE_BUTTON_FOCUSED_PRESSED 2018
+#define IDR_WEBUI_IMAGES_APPS_BLUE_BUTTON_FOCUSED_HOVER 2019
+#define IDR_WEBUI_IMAGES_APPS_CHECKBOX 2020
+#define IDR_WEBUI_IMAGES_APPS_CHECKBOX_HOVER 2021
+#define IDR_WEBUI_IMAGES_APPS_CHECKBOX_PRESSED 2022
+#define IDR_WEBUI_IMAGES_APPS_CHECKBOX_FOCUSED 2023
+#define IDR_WEBUI_IMAGES_APPS_CHECKBOX_FOCUSED_HOVER 2024
+#define IDR_WEBUI_IMAGES_APPS_CHECKBOX_FOCUSED_PRESSED 2025
+#define IDR_WEBUI_IMAGES_APPS_CHECKBOX_INACTIVE 2026
+#define IDR_WEBUI_IMAGES_APPS_CHECKBOX_CHECKED 2027
+#define IDR_WEBUI_IMAGES_APPS_CHECKBOX_CHECKED_HOVER 2028
+#define IDR_WEBUI_IMAGES_APPS_CHECKBOX_CHECKED_PRESSED 2029
+#define IDR_WEBUI_IMAGES_APPS_CHECKBOX_FOCUSED_CHECKED 2030
+#define IDR_WEBUI_IMAGES_APPS_CHECKBOX_FOCUSED_CHECKED_HOVER 2031
+#define IDR_WEBUI_IMAGES_APPS_CHECKBOX_FOCUSED_CHECKED_PRESSED 2032
+#define IDR_WEBUI_IMAGES_APPS_CHECKBOX_CHECKED_INACTIVE 2033
+#define IDR_WEBUI_IMAGES_APPS_TOPBAR_BUTTON_CLOSE 2034
+#define IDR_WEBUI_IMAGES_APPS_TOPBAR_BUTTON_MAXIMIZE 2035
+#define IDR_WEBUI_IMAGES_APPS_TOPBAR_BUTTON_MINIMIZE 2036
+#define IDR_WEBUI_IMAGES_APPS_BUTTON_BUTTER_BAR_CLOSE 2037
+#define IDR_WEBUI_IMAGES_APPS_BUTTON_BUTTER_BAR_CLOSE_HOVER 2038
+#define IDR_WEBUI_IMAGES_APPS_BUTTON_BUTTER_BAR_CLOSE_PRESSED 2039
+#define IDR_WEBUI_IMAGES_APPS_BUTTON_2X 2040
+#define IDR_WEBUI_IMAGES_APPS_BUTTON_2X_PRESSED 2041
+#define IDR_WEBUI_IMAGES_APPS_BUTTON_2X_HOVER 2042
+#define IDR_WEBUI_IMAGES_APPS_BUTTON_2X_DISABLED 2043
+#define IDR_WEBUI_IMAGES_APPS_BUTTON_2X_FOCUSED 2044
+#define IDR_WEBUI_IMAGES_APPS_BUTTON_2X_FOCUSED_PRESSED 2045
+#define IDR_WEBUI_IMAGES_APPS_BUTTON_2X_FOCUSED_HOVER 2046
+#define IDR_WEBUI_IMAGES_APPS_BLUE_BUTTON_2X 2047
+#define IDR_WEBUI_IMAGES_APPS_BLUE_BUTTON_2X_PRESSED 2048
+#define IDR_WEBUI_IMAGES_APPS_BLUE_BUTTON_2X_HOVER 2049
+#define IDR_WEBUI_IMAGES_APPS_BLUE_BUTTON_2X_DISABLED 2050
+#define IDR_WEBUI_IMAGES_APPS_BLUE_BUTTON_2X_FOCUSED 2051
+#define IDR_WEBUI_IMAGES_APPS_BLUE_BUTTON_2X_FOCUSED_PRESSED 2052
+#define IDR_WEBUI_IMAGES_APPS_BLUE_BUTTON_2X_FOCUSED_HOVER 2053
+#define IDR_WEBUI_IMAGES_APPS_CHECKBOX_2X 2054
+#define IDR_WEBUI_IMAGES_APPS_CHECKBOX_2X_HOVER 2055
+#define IDR_WEBUI_IMAGES_APPS_CHECKBOX_2X_PRESSED 2056
+#define IDR_WEBUI_IMAGES_APPS_CHECKBOX_2X_FOCUSED 2057
+#define IDR_WEBUI_IMAGES_APPS_CHECKBOX_2X_FOCUSED_HOVER 2058
+#define IDR_WEBUI_IMAGES_APPS_CHECKBOX_2X_FOCUSED_PRESSED 2059
+#define IDR_WEBUI_IMAGES_APPS_CHECKBOX_INACTIVE_2X 2060
+#define IDR_WEBUI_IMAGES_APPS_CHECKBOX_CHECKED_2X 2061
+#define IDR_WEBUI_IMAGES_APPS_CHECKBOX_CHECKED_2X_HOVER 2062
+#define IDR_WEBUI_IMAGES_APPS_CHECKBOX_CHECKED_2X_PRESSED 2063
+#define IDR_WEBUI_IMAGES_APPS_CHECKBOX_FOCUSED_CHECKED_2X 2064
+#define IDR_WEBUI_IMAGES_APPS_CHECKBOX_FOCUSED_CHECKED_2X_HOVER 2065
+#define IDR_WEBUI_IMAGES_APPS_CHECKBOX_FOCUSED_CHECKED_2X_PRESSED 2066
+#define IDR_WEBUI_IMAGES_APPS_CHECKBOX_CHECKED_INACTIVE_2X 2067
+#define IDR_WEBUI_IMAGES_APPS_TOPBAR_BUTTON_2X_CLOSE 2068
+#define IDR_WEBUI_IMAGES_APPS_TOPBAR_BUTTON_2X_MAXIMIZE 2069
+#define IDR_WEBUI_IMAGES_APPS_TOPBAR_BUTTON_2X_MINIMIZE 2070
+#define IDR_WEBUI_IMAGES_APPS_BUTTON_BUTTER_BAR_CLOSE_2X 2071
+#define IDR_WEBUI_IMAGES_APPS_BUTTON_BUTTER_BAR_CLOSE_HOVER_2X 2072
+#define IDR_WEBUI_IMAGES_APPS_BUTTON_BUTTER_BAR_CLOSE_PRESSED_2X 2073
+#define IDR_WEBUI_IMAGES_CHECK 2074
+#define IDR_WEBUI_IMAGES_CHECKBOX_BLACK 2075
+#define IDR_WEBUI_IMAGES_CHECKBOX_WHITE 2076
+#define IDR_WEBUI_IMAGES_DISABLED_SELECT 2077
+#define IDR_WEBUI_IMAGES_ERROR 2078
+#define IDR_WEBUI_IMAGES_SELECT 2079
+#define IDR_WEBUI_IMAGES_THROBBER_MEDIUM 2080
+#define IDR_WEBUI_IMAGES_THROBBER_SMALL 2081
+#define IDR_WEBUI_IMAGES_TRASH 2082
+#define IDR_WEBUI_CR_ELEMENTS_NETWORK_BADGE_CDMA1XRTT 2083
+#define IDR_WEBUI_CR_ELEMENTS_NETWORK_BADGE_3G 2084
+#define IDR_WEBUI_CR_ELEMENTS_NETWORK_BADGE_4G 2085
+#define IDR_WEBUI_CR_ELEMENTS_NETWORK_BADGE_EDGE 2086
+#define IDR_WEBUI_CR_ELEMENTS_NETWORK_BADGE_EVDO 2087
+#define IDR_WEBUI_CR_ELEMENTS_NETWORK_BADGE_GPRS 2088
+#define IDR_WEBUI_CR_ELEMENTS_NETWORK_BADGE_HSPA 2089
+#define IDR_WEBUI_CR_ELEMENTS_NETWORK_BADGE_HSPA_PLUS 2090
+#define IDR_WEBUI_CR_ELEMENTS_NETWORK_BADGE_LTE 2091
+#define IDR_WEBUI_CR_ELEMENTS_NETWORK_BADGE_LTE_ADVANCED 2092
+#define IDR_WEBUI_CR_ELEMENTS_NETWORK_BADGE_ROAMING 2093
+#define IDR_WEBUI_CR_ELEMENTS_NETWORK_BADGE_SECURE 2094
+#define IDR_WEBUI_CR_ELEMENTS_NETWORK_ICON_ETHERNET 2095
+#define IDR_WEBUI_CR_ELEMENTS_NETWORK_ICON_MOBILE 2096
+#define IDR_WEBUI_CR_ELEMENTS_NETWORK_ICON_VPN 2097
+#define IDR_WEBUI_CR_ELEMENTS_NETWORK_ICON_WIFI 2098
+#define IDR_WEBUI_CSS_ACTION_LINK 2200
+#define IDR_WEBUI_CSS_ALERT_OVERLAY 2201
+#define IDR_WEBUI_CSS_APPS_COMMON 2202
+#define IDR_WEBUI_CSS_APPS_TOPBUTTON_BAR 2203
+#define IDR_WEBUI_CSS_BUBBLE 2204
+#define IDR_WEBUI_CSS_BUBBLE_BUTTON 2205
+#define IDR_WEBUI_CSS_BUTTER_BAR 2206
+#define IDR_WEBUI_CSS_CHROME 2207
+#define IDR_WEBUI_CSS_CONTROLLED_INDICATOR 2208
+#define IDR_WEBUI_CSS_DIALOGS 2209
+#define IDR_WEBUI_CSS_I18N_PROCESS 2210
+#define IDR_WEBUI_CSS_LIST 2211
+#define IDR_WEBUI_CSS_MENU 2212
+#define IDR_WEBUI_CSS_MENU_BUTTON 2213
+#define IDR_WEBUI_CSS_TEXT_DEFAULTS 2214
+#define IDR_WEBUI_CSS_TEXT_DEFAULTS_MD 2215
+#define IDR_WEBUI_CSS_OVERLAY 2216
+#define IDR_WEBUI_CSS_ROBOTO 2217
+#define IDR_WEBUI_CSS_SPINNER 2218
+#define IDR_WEBUI_CSS_TABLE 2219
+#define IDR_WEBUI_CSS_TABS 2220
+#define IDR_WEBUI_CSS_THROBBER 2221
+#define IDR_WEBUI_CSS_TRASH 2222
+#define IDR_WEBUI_CSS_TREE 2223
+#define IDR_WEBUI_CSS_WIDGETS 2224
+#define IDR_WEBUI_HTML_ACTION_LINK 2225
+#define IDR_WEBUI_HTML_ASSERT 2226
+#define IDR_WEBUI_HTML_PROMISE_RESOLVER 2227
+#define IDR_WEBUI_HTML_CR 2228
+#define IDR_WEBUI_HTML_CR_EVENT_TARGET 2229
+#define IDR_WEBUI_HTML_CR_UI 2230
+#define IDR_WEBUI_HTML_CR_UI_ALERT_OVERLAY 2231
+#define IDR_WEBUI_HTML_CR_UI_COMMAND 2232
+#define IDR_WEBUI_HTML_CR_UI_CONTEXT_MENU_BUTTON 2233
+#define IDR_WEBUI_HTML_CR_UI_CONTEXT_MENU_HANDLER 2234
+#define IDR_WEBUI_HTML_CR_UI_FOCUS_GRID 2235
+#define IDR_WEBUI_HTML_CR_UI_FOCUS_MANAGER 2236
+#define IDR_WEBUI_HTML_CR_UI_FOCUS_OUTLINE_MANAGER 2237
+#define IDR_WEBUI_HTML_CR_UI_FOCUS_ROW 2238
+#define IDR_WEBUI_HTML_CR_UI_MENU 2239
+#define IDR_WEBUI_HTML_CR_UI_MENU_BUTTON 2240
+#define IDR_WEBUI_HTML_CR_UI_MENU_ITEM 2241
+#define IDR_WEBUI_HTML_CR_UI_OVERLAY 2242
+#define IDR_WEBUI_HTML_CR_UI_POSITION_UTIL 2243
+#define IDR_WEBUI_HTML_EVENT_TRACKER 2244
+#define IDR_WEBUI_HTML_I18N_TEMPLATE 2245
+#define IDR_WEBUI_HTML_LOAD_TIME_DATA 2246
+#define IDR_WEBUI_HTML_POLYMER 2247
+#define IDR_WEBUI_HTML_I18N_BEHAVIOR 2248
+#define IDR_WEBUI_HTML_UTIL 2249
+#define IDR_WEBUI_HTML_WEBUI_LISTENER_BEHAVIOR 2250
+#define IDR_WEBUI_JS_ACTION_LINK 2251
+#define IDR_WEBUI_JS_ASSERT 2252
+#define IDR_WEBUI_JS_PROMISE_RESOLVER 2253
+#define IDR_WEBUI_JS_CR 2254
+#define IDR_WEBUI_JS_CR_EVENT_TARGET 2255
+#define IDR_WEBUI_JS_CR_LINK_CONTROLLER 2256
+#define IDR_WEBUI_JS_CR_UI 2257
+#define IDR_WEBUI_JS_CR_UI_ALERT_OVERLAY 2258
+#define IDR_WEBUI_JS_CR_UI_ARRAY_DATA_MODEL 2259
+#define IDR_WEBUI_JS_CR_UI_AUTOCOMPLETE_LIST 2260
+#define IDR_WEBUI_JS_CR_UI_BUBBLE 2261
+#define IDR_WEBUI_JS_CR_UI_BUBBLE_BUTTON 2262
+#define IDR_WEBUI_JS_CR_UI_CARD_SLIDER 2263
+#define IDR_WEBUI_JS_CR_UI_COMMAND 2264
+#define IDR_WEBUI_JS_CR_UI_CONTEXT_MENU_BUTTON 2265
+#define IDR_WEBUI_JS_CR_UI_CONTEXT_MENU_HANDLER 2266
+#define IDR_WEBUI_JS_CR_UI_CONTROLLED_INDICATOR 2267
+#define IDR_WEBUI_JS_CR_UI_DIALOGS 2268
+#define IDR_WEBUI_JS_CR_UI_DRAG_WRAPPER 2269
+#define IDR_WEBUI_JS_CR_UI_FOCUS_GRID 2270
+#define IDR_WEBUI_JS_CR_UI_FOCUS_MANAGER 2271
+#define IDR_WEBUI_JS_CR_UI_FOCUS_OUTLINE_MANAGER 2272
+#define IDR_WEBUI_JS_CR_UI_FOCUS_ROW 2273
+#define IDR_WEBUI_JS_CR_UI_LIST 2274
+#define IDR_WEBUI_JS_CR_UI_LIST_ITEM 2275
+#define IDR_WEBUI_JS_CR_UI_LIST_SELECTION_CONTROLLER 2276
+#define IDR_WEBUI_JS_CR_UI_LIST_SELECTION_MODEL 2277
+#define IDR_WEBUI_JS_CR_UI_LIST_SINGLE_SELECTION_MODEL 2278
+#define IDR_WEBUI_JS_CR_UI_MENU 2279
+#define IDR_WEBUI_JS_CR_UI_MENU_BUTTON 2280
+#define IDR_WEBUI_JS_CR_UI_MENU_ITEM 2281
+#define IDR_WEBUI_JS_CR_UI_NODE_UTILS 2282
+#define IDR_WEBUI_JS_CR_UI_OVERLAY 2283
+#define IDR_WEBUI_JS_CR_UI_PAGE_MANAGER_PAGE 2284
+#define IDR_WEBUI_JS_CR_UI_PAGE_MANAGER_PAGE_MANAGER 2285
+#define IDR_WEBUI_JS_CR_UI_POSITION_UTIL 2286
+#define IDR_WEBUI_JS_CR_UI_SPLITTER 2287
+#define IDR_WEBUI_JS_CR_UI_GRID 2288
+#define IDR_WEBUI_JS_CR_UI_REPEATING_BUTTON 2289
+#define IDR_WEBUI_JS_CR_UI_TABLE 2290
+#define IDR_WEBUI_JS_CR_UI_TABLE_COLUMN 2291
+#define IDR_WEBUI_JS_CR_UI_TABLE_COLUMN_MODEL 2292
+#define IDR_WEBUI_JS_CR_UI_TABLE_HEADER 2293
+#define IDR_WEBUI_JS_CR_UI_TABLE_LIST 2294
+#define IDR_WEBUI_JS_CR_UI_TABLE_SPLITTER 2295
+#define IDR_WEBUI_JS_CR_UI_TABS 2296
+#define IDR_WEBUI_JS_CR_UI_TREE 2297
+#define IDR_WEBUI_JS_CR_UI_TOUCH_HANDLER 2298
+#define IDR_WEBUI_JS_EVENT_TRACKER 2299
+#define IDR_WEBUI_JS_I18N_TEMPLATE_NO_PROCESS 2300
+#define IDR_WEBUI_JS_LOAD_TIME_DATA 2301
+#define IDR_WEBUI_JS_MEDIA_COMMON 2302
+#define IDR_WEBUI_JS_PARSE_HTML_SUBSET 2303
+#define IDR_WEBUI_JS_POLYMER_CONFIG 2304
+#define IDR_WEBUI_JS_I18N_BEHAVIOR 2305
+#define IDR_WEBUI_JS_UTIL 2306
+#define IDR_WEBUI_JS_WEBUI_LISTENER_BEHAVIOR 2307
+#define IDR_WEBUI_JS_WEBUI_RESOURCE_TEST 2308
+#define IDR_WEBUI_CSS_UI_ACCOUNT_TWEAKS 2309
+#define IDR_WEBUI_HTML_UI_ACCOUNT_TWEAKS 2310
+#define IDR_WEBUI_JS_UI_ACCOUNT_TWEAKS 2311
+#define IDR_CR_ELEMENTS_CR_DEMO_ELEMENT_CSS 2312
+#define IDR_CR_ELEMENTS_CR_DEMO_ELEMENT_HTML 2313
+#define IDR_CR_ELEMENTS_CR_DEMO_ELEMENT_JS 2314
+#define IDR_CR_ELEMENTS_CR_DEMO_CONFIG_JS 2315
+#define IDR_CR_ELEMENTS_CR_DEMO_PAGE_HTML 2316
+#define IDR_CR_ELEMENTS_CR_EVENTS_HTML 2317
+#define IDR_CR_ELEMENTS_CR_EVENTS_JS 2318
+#define IDR_CR_ELEMENTS_CR_EXPAND_BUTTON_CSS 2319
+#define IDR_CR_ELEMENTS_CR_EXPAND_BUTTON_HTML 2320
+#define IDR_CR_ELEMENTS_CR_EXPAND_BUTTON_JS 2321
+#define IDR_CR_ELEMENTS_CR_NETWORK_ICON_CSS 2322
+#define IDR_CR_ELEMENTS_CR_NETWORK_ICON_HTML 2323
+#define IDR_CR_ELEMENTS_CR_NETWORK_ICON_JS 2324
+#define IDR_CR_ELEMENTS_CR_NETWORK_LIST_CSS 2325
+#define IDR_CR_ELEMENTS_CR_NETWORK_LIST_HTML 2326
+#define IDR_CR_ELEMENTS_CR_NETWORK_LIST_JS 2327
+#define IDR_CR_ELEMENTS_CR_NETWORK_LIST_ITEM_CSS 2328
+#define IDR_CR_ELEMENTS_CR_NETWORK_LIST_ITEM_HTML 2329
+#define IDR_CR_ELEMENTS_CR_NETWORK_LIST_ITEM_JS 2330
+#define IDR_CR_ELEMENTS_CR_NETWORK_SELECT_CSS 2331
+#define IDR_CR_ELEMENTS_CR_NETWORK_SELECT_HTML 2332
+#define IDR_CR_ELEMENTS_CR_NETWORK_SELECT_JS 2333
+#define IDR_CR_ELEMENTS_CR_ONC_TYPES_HTML 2334
+#define IDR_CR_ELEMENTS_CR_ONC_TYPES_JS 2335
+#define IDR_CR_ELEMENTS_CR_POLICY_INDICATOR_CSS 2336
+#define IDR_CR_ELEMENTS_CR_POLICY_INDICATOR_BEHAVIOR_HTML 2337
+#define IDR_CR_ELEMENTS_CR_POLICY_INDICATOR_BEHAVIOR_JS 2338
+#define IDR_CR_ELEMENTS_CR_POLICY_NETWORK_BEHAVIOR_HTML 2339
+#define IDR_CR_ELEMENTS_CR_POLICY_NETWORK_BEHAVIOR_JS 2340
+#define IDR_CR_ELEMENTS_CR_POLICY_NETWORK_INDICATOR_JS 2341
+#define IDR_CR_ELEMENTS_CR_POLICY_NETWORK_INDICATOR_HTML 2342
+#define IDR_CR_ELEMENTS_CR_POLICY_PREF_BEHAVIOR_HTML 2343
+#define IDR_CR_ELEMENTS_CR_POLICY_PREF_BEHAVIOR_JS 2344
+#define IDR_CR_ELEMENTS_CR_POLICY_PREF_INDICATOR_JS 2345
+#define IDR_CR_ELEMENTS_CR_POLICY_PREF_INDICATOR_HTML 2346
+#define IDR_CR_ELEMENTS_CR_SEARCH_FIELD_CSS 2347
+#define IDR_CR_ELEMENTS_CR_SEARCH_FIELD_HTML 2348
+#define IDR_CR_ELEMENTS_CR_SEARCH_FIELD_JS 2349
+#define IDR_CR_ELEMENTS_CR_SHARED_MENU_HTML 2350
+#define IDR_CR_ELEMENTS_CR_SHARED_MENU_JS 2351
+#define IDR_CR_ELEMENTS_SHARED_CSS 2352
+#define IDR_POLYMER_1_0_FONT_ROBOTO_ROBOTO_HTML 2353
+#define IDR_POLYMER_1_0_IRON_A11Y_KEYS_BEHAVIOR_IRON_A11Y_KEYS_BEHAVIOR_EXTRACTED_JS 2354
+#define IDR_POLYMER_1_0_IRON_A11Y_KEYS_BEHAVIOR_IRON_A11Y_KEYS_BEHAVIOR_HTML 2355
+#define IDR_POLYMER_1_0_IRON_A11Y_KEYS_IRON_A11Y_KEYS_EXTRACTED_JS 2356
+#define IDR_POLYMER_1_0_IRON_A11Y_KEYS_IRON_A11Y_KEYS_HTML 2357
+#define IDR_POLYMER_1_0_IRON_BEHAVIORS_IRON_BUTTON_STATE_EXTRACTED_JS 2358
+#define IDR_POLYMER_1_0_IRON_BEHAVIORS_IRON_BUTTON_STATE_HTML 2359
+#define IDR_POLYMER_1_0_IRON_BEHAVIORS_IRON_CONTROL_STATE_EXTRACTED_JS 2360
+#define IDR_POLYMER_1_0_IRON_BEHAVIORS_IRON_CONTROL_STATE_HTML 2361
+#define IDR_POLYMER_1_0_IRON_CHECKED_ELEMENT_BEHAVIOR_IRON_CHECKED_ELEMENT_BEHAVIOR_EXTRACTED_JS 2362
+#define IDR_POLYMER_1_0_IRON_CHECKED_ELEMENT_BEHAVIOR_IRON_CHECKED_ELEMENT_BEHAVIOR_HTML 2363
+#define IDR_POLYMER_1_0_IRON_COLLAPSE_IRON_COLLAPSE_EXTRACTED_JS 2364
+#define IDR_POLYMER_1_0_IRON_COLLAPSE_IRON_COLLAPSE_HTML 2365
+#define IDR_POLYMER_1_0_IRON_DROPDOWN_IRON_DROPDOWN_EXTRACTED_JS 2366
+#define IDR_POLYMER_1_0_IRON_DROPDOWN_IRON_DROPDOWN_SCROLL_MANAGER_EXTRACTED_JS 2367
+#define IDR_POLYMER_1_0_IRON_DROPDOWN_IRON_DROPDOWN_SCROLL_MANAGER_HTML 2368
+#define IDR_POLYMER_1_0_IRON_DROPDOWN_IRON_DROPDOWN_HTML 2369
+#define IDR_POLYMER_1_0_IRON_FIT_BEHAVIOR_IRON_FIT_BEHAVIOR_EXTRACTED_JS 2370
+#define IDR_POLYMER_1_0_IRON_FIT_BEHAVIOR_IRON_FIT_BEHAVIOR_HTML 2371
+#define IDR_POLYMER_1_0_IRON_FLEX_LAYOUT_CLASSES_IRON_FLEX_LAYOUT_HTML 2372
+#define IDR_POLYMER_1_0_IRON_FLEX_LAYOUT_CLASSES_IRON_FLEX_LAYOUT_EXTRACTED_JS 2373
+#define IDR_POLYMER_1_0_IRON_FLEX_LAYOUT_CLASSES_IRON_SHADOW_FLEX_LAYOUT_HTML 2374
+#define IDR_POLYMER_1_0_IRON_FLEX_LAYOUT_CLASSES_IRON_SHADOW_FLEX_LAYOUT_EXTRACTED_JS 2375
+#define IDR_POLYMER_1_0_IRON_FLEX_LAYOUT_IRON_FLEX_LAYOUT_HTML 2376
+#define IDR_POLYMER_1_0_IRON_FORM_ELEMENT_BEHAVIOR_IRON_FORM_ELEMENT_BEHAVIOR_EXTRACTED_JS 2377
+#define IDR_POLYMER_1_0_IRON_FORM_ELEMENT_BEHAVIOR_IRON_FORM_ELEMENT_BEHAVIOR_HTML 2378
+#define IDR_POLYMER_1_0_IRON_ICON_IRON_ICON_EXTRACTED_JS 2379
+#define IDR_POLYMER_1_0_IRON_ICON_IRON_ICON_HTML 2380
+#define IDR_POLYMER_1_0_IRON_ICONS_AV_ICONS_HTML 2381
+#define IDR_POLYMER_1_0_IRON_ICONS_COMMUNICATION_ICONS_HTML 2382
+#define IDR_POLYMER_1_0_IRON_ICONS_DEVICE_ICONS_HTML 2383
+#define IDR_POLYMER_1_0_IRON_ICONS_HARDWARE_ICONS_HTML 2384
+#define IDR_POLYMER_1_0_IRON_ICONS_IMAGE_ICONS_HTML 2385
+#define IDR_POLYMER_1_0_IRON_ICONS_IRON_ICONS_HTML 2386
+#define IDR_POLYMER_1_0_IRON_ICONS_NOTIFICATION_ICONS_HTML 2387
+#define IDR_POLYMER_1_0_IRON_ICONS_PLACES_ICONS_HTML 2388
+#define IDR_POLYMER_1_0_IRON_ICONS_SOCIAL_ICONS_HTML 2389
+#define IDR_POLYMER_1_0_IRON_ICONSET_SVG_IRON_ICONSET_SVG_EXTRACTED_JS 2390
+#define IDR_POLYMER_1_0_IRON_ICONSET_SVG_IRON_ICONSET_SVG_HTML 2391
+#define IDR_POLYMER_1_0_IRON_IMAGE_IRON_IMAGE_EXTRACTED_JS 2392
+#define IDR_POLYMER_1_0_IRON_IMAGE_IRON_IMAGE_HTML 2393
+#define IDR_POLYMER_1_0_IRON_INPUT_IRON_INPUT_EXTRACTED_JS 2394
+#define IDR_POLYMER_1_0_IRON_INPUT_IRON_INPUT_HTML 2395
+#define IDR_POLYMER_1_0_IRON_LIST_IRON_LIST_EXTRACTED_JS 2396
+#define IDR_POLYMER_1_0_IRON_LIST_IRON_LIST_HTML 2397
+#define IDR_POLYMER_1_0_IRON_MEDIA_QUERY_IRON_MEDIA_QUERY_EXTRACTED_JS 2398
+#define IDR_POLYMER_1_0_IRON_MEDIA_QUERY_IRON_MEDIA_QUERY_HTML 2399
+#define IDR_POLYMER_1_0_IRON_MENU_BEHAVIOR_IRON_MENU_BEHAVIOR_EXTRACTED_JS 2400
+#define IDR_POLYMER_1_0_IRON_MENU_BEHAVIOR_IRON_MENU_BEHAVIOR_HTML 2401
+#define IDR_POLYMER_1_0_IRON_MENU_BEHAVIOR_IRON_MENUBAR_BEHAVIOR_EXTRACTED_JS 2402
+#define IDR_POLYMER_1_0_IRON_MENU_BEHAVIOR_IRON_MENUBAR_BEHAVIOR_HTML 2403
+#define IDR_POLYMER_1_0_IRON_META_IRON_META_EXTRACTED_JS 2404
+#define IDR_POLYMER_1_0_IRON_META_IRON_META_HTML 2405
+#define IDR_POLYMER_1_0_IRON_OVERLAY_BEHAVIOR_IRON_OVERLAY_BACKDROP_EXTRACTED_JS 2406
+#define IDR_POLYMER_1_0_IRON_OVERLAY_BEHAVIOR_IRON_OVERLAY_BACKDROP_HTML 2407
+#define IDR_POLYMER_1_0_IRON_OVERLAY_BEHAVIOR_IRON_OVERLAY_BEHAVIOR_EXTRACTED_JS 2408
+#define IDR_POLYMER_1_0_IRON_OVERLAY_BEHAVIOR_IRON_OVERLAY_BEHAVIOR_HTML 2409
+#define IDR_POLYMER_1_0_IRON_OVERLAY_BEHAVIOR_IRON_OVERLAY_MANAGER_EXTRACTED_JS 2410
+#define IDR_POLYMER_1_0_IRON_OVERLAY_BEHAVIOR_IRON_OVERLAY_MANAGER_HTML 2411
+#define IDR_POLYMER_1_0_IRON_PAGES_IRON_PAGES_EXTRACTED_JS 2412
+#define IDR_POLYMER_1_0_IRON_PAGES_IRON_PAGES_HTML 2413
+#define IDR_POLYMER_1_0_IRON_RANGE_BEHAVIOR_IRON_RANGE_BEHAVIOR_EXTRACTED_JS 2414
+#define IDR_POLYMER_1_0_IRON_RANGE_BEHAVIOR_IRON_RANGE_BEHAVIOR_HTML 2415
+#define IDR_POLYMER_1_0_IRON_RESIZABLE_BEHAVIOR_IRON_RESIZABLE_BEHAVIOR_EXTRACTED_JS 2416
+#define IDR_POLYMER_1_0_IRON_RESIZABLE_BEHAVIOR_IRON_RESIZABLE_BEHAVIOR_HTML 2417
+#define IDR_POLYMER_1_0_IRON_SCROLL_TARGET_BEHAVIOR_IRON_SCROLL_TARGET_BEHAVIOR_EXTRACTED_JS 2418
+#define IDR_POLYMER_1_0_IRON_SCROLL_TARGET_BEHAVIOR_IRON_SCROLL_TARGET_BEHAVIOR_HTML 2419
+#define IDR_POLYMER_1_0_IRON_SELECTOR_IRON_MULTI_SELECTABLE_EXTRACTED_JS 2420
+#define IDR_POLYMER_1_0_IRON_SELECTOR_IRON_MULTI_SELECTABLE_HTML 2421
+#define IDR_POLYMER_1_0_IRON_SELECTOR_IRON_SELECTABLE_EXTRACTED_JS 2422
+#define IDR_POLYMER_1_0_IRON_SELECTOR_IRON_SELECTABLE_HTML 2423
+#define IDR_POLYMER_1_0_IRON_SELECTOR_IRON_SELECTION_EXTRACTED_JS 2424
+#define IDR_POLYMER_1_0_IRON_SELECTOR_IRON_SELECTION_HTML 2425
+#define IDR_POLYMER_1_0_IRON_SELECTOR_IRON_SELECTOR_EXTRACTED_JS 2426
+#define IDR_POLYMER_1_0_IRON_SELECTOR_IRON_SELECTOR_HTML 2427
+#define IDR_POLYMER_1_0_IRON_TEST_HELPERS_IRON_TEST_HELPERS_HTML 2428
+#define IDR_POLYMER_1_0_IRON_TEST_HELPERS_MOCK_INTERACTIONS_HTML 2429
+#define IDR_POLYMER_1_0_IRON_TEST_HELPERS_MOCK_INTERACTIONS_JS 2430
+#define IDR_POLYMER_1_0_IRON_TEST_HELPERS_TEST_HELPERS_HTML 2431
+#define IDR_POLYMER_1_0_IRON_TEST_HELPERS_TEST_HELPERS_JS 2432
+#define IDR_POLYMER_1_0_IRON_VALIDATABLE_BEHAVIOR_IRON_VALIDATABLE_BEHAVIOR_EXTRACTED_JS 2433
+#define IDR_POLYMER_1_0_IRON_VALIDATABLE_BEHAVIOR_IRON_VALIDATABLE_BEHAVIOR_HTML 2434
+#define IDR_POLYMER_1_0_NEON_ANIMATION_ANIMATIONS_FADE_IN_ANIMATION_EXTRACTED_JS 2435
+#define IDR_POLYMER_1_0_NEON_ANIMATION_ANIMATIONS_FADE_IN_ANIMATION_HTML 2436
+#define IDR_POLYMER_1_0_NEON_ANIMATION_ANIMATIONS_FADE_OUT_ANIMATION_EXTRACTED_JS 2437
+#define IDR_POLYMER_1_0_NEON_ANIMATION_ANIMATIONS_FADE_OUT_ANIMATION_HTML 2438
+#define IDR_POLYMER_1_0_NEON_ANIMATION_ANIMATIONS_HERO_ANIMATION_EXTRACTED_JS 2439
+#define IDR_POLYMER_1_0_NEON_ANIMATION_ANIMATIONS_HERO_ANIMATION_HTML 2440
+#define IDR_POLYMER_1_0_NEON_ANIMATION_ANIMATIONS_OPAQUE_ANIMATION_EXTRACTED_JS 2441
+#define IDR_POLYMER_1_0_NEON_ANIMATION_ANIMATIONS_OPAQUE_ANIMATION_HTML 2442
+#define IDR_POLYMER_1_0_NEON_ANIMATION_ANIMATIONS_SLIDE_DOWN_ANIMATION_EXTRACTED_JS 2443
+#define IDR_POLYMER_1_0_NEON_ANIMATION_ANIMATIONS_SLIDE_DOWN_ANIMATION_HTML 2444
+#define IDR_POLYMER_1_0_NEON_ANIMATION_ANIMATIONS_SLIDE_FROM_BOTTOM_ANIMATION_EXTRACTED_JS 2445
+#define IDR_POLYMER_1_0_NEON_ANIMATION_ANIMATIONS_SLIDE_FROM_BOTTOM_ANIMATION_HTML 2446
+#define IDR_POLYMER_1_0_NEON_ANIMATION_ANIMATIONS_SLIDE_FROM_LEFT_ANIMATION_EXTRACTED_JS 2447
+#define IDR_POLYMER_1_0_NEON_ANIMATION_ANIMATIONS_SLIDE_FROM_LEFT_ANIMATION_HTML 2448
+#define IDR_POLYMER_1_0_NEON_ANIMATION_ANIMATIONS_SLIDE_FROM_RIGHT_ANIMATION_EXTRACTED_JS 2449
+#define IDR_POLYMER_1_0_NEON_ANIMATION_ANIMATIONS_SLIDE_FROM_RIGHT_ANIMATION_HTML 2450
+#define IDR_POLYMER_1_0_NEON_ANIMATION_ANIMATIONS_SLIDE_FROM_TOP_ANIMATION_EXTRACTED_JS 2451
+#define IDR_POLYMER_1_0_NEON_ANIMATION_ANIMATIONS_SLIDE_FROM_TOP_ANIMATION_HTML 2452
+#define IDR_POLYMER_1_0_NEON_ANIMATION_ANIMATIONS_SLIDE_LEFT_ANIMATION_EXTRACTED_JS 2453
+#define IDR_POLYMER_1_0_NEON_ANIMATION_ANIMATIONS_SLIDE_LEFT_ANIMATION_HTML 2454
+#define IDR_POLYMER_1_0_NEON_ANIMATION_ANIMATIONS_SLIDE_RIGHT_ANIMATION_EXTRACTED_JS 2455
+#define IDR_POLYMER_1_0_NEON_ANIMATION_ANIMATIONS_SLIDE_RIGHT_ANIMATION_HTML 2456
+#define IDR_POLYMER_1_0_NEON_ANIMATION_ANIMATIONS_SLIDE_UP_ANIMATION_EXTRACTED_JS 2457
+#define IDR_POLYMER_1_0_NEON_ANIMATION_ANIMATIONS_SLIDE_UP_ANIMATION_HTML 2458
+#define IDR_POLYMER_1_0_NEON_ANIMATION_ANIMATIONS_TRANSFORM_ANIMATION_EXTRACTED_JS 2459
+#define IDR_POLYMER_1_0_NEON_ANIMATION_ANIMATIONS_TRANSFORM_ANIMATION_HTML 2460
+#define IDR_POLYMER_1_0_NEON_ANIMATION_NEON_ANIMATABLE_BEHAVIOR_EXTRACTED_JS 2461
+#define IDR_POLYMER_1_0_NEON_ANIMATION_NEON_ANIMATABLE_BEHAVIOR_HTML 2462
+#define IDR_POLYMER_1_0_NEON_ANIMATION_NEON_ANIMATABLE_EXTRACTED_JS 2463
+#define IDR_POLYMER_1_0_NEON_ANIMATION_NEON_ANIMATABLE_HTML 2464
+#define IDR_POLYMER_1_0_NEON_ANIMATION_NEON_ANIMATED_PAGES_EXTRACTED_JS 2465
+#define IDR_POLYMER_1_0_NEON_ANIMATION_NEON_ANIMATED_PAGES_HTML 2466
+#define IDR_POLYMER_1_0_NEON_ANIMATION_NEON_ANIMATION_BEHAVIOR_EXTRACTED_JS 2467
+#define IDR_POLYMER_1_0_NEON_ANIMATION_NEON_ANIMATION_BEHAVIOR_HTML 2468
+#define IDR_POLYMER_1_0_NEON_ANIMATION_NEON_ANIMATION_RUNNER_BEHAVIOR_EXTRACTED_JS 2469
+#define IDR_POLYMER_1_0_NEON_ANIMATION_NEON_ANIMATION_RUNNER_BEHAVIOR_HTML 2470
+#define IDR_POLYMER_1_0_NEON_ANIMATION_NEON_SHARED_ELEMENT_ANIMATABLE_BEHAVIOR_EXTRACTED_JS 2471
+#define IDR_POLYMER_1_0_NEON_ANIMATION_NEON_SHARED_ELEMENT_ANIMATABLE_BEHAVIOR_HTML 2472
+#define IDR_POLYMER_1_0_NEON_ANIMATION_NEON_SHARED_ELEMENT_ANIMATION_BEHAVIOR_EXTRACTED_JS 2473
+#define IDR_POLYMER_1_0_NEON_ANIMATION_NEON_SHARED_ELEMENT_ANIMATION_BEHAVIOR_HTML 2474
+#define IDR_POLYMER_1_0_NEON_ANIMATION_WEB_ANIMATIONS_HTML 2475
+#define IDR_POLYMER_1_0_PAPER_BEHAVIORS_PAPER_BUTTON_BEHAVIOR_EXTRACTED_JS 2476
+#define IDR_POLYMER_1_0_PAPER_BEHAVIORS_PAPER_BUTTON_BEHAVIOR_HTML 2477
+#define IDR_POLYMER_1_0_PAPER_BEHAVIORS_PAPER_CHECKED_ELEMENT_BEHAVIOR_EXTRACTED_JS 2478
+#define IDR_POLYMER_1_0_PAPER_BEHAVIORS_PAPER_CHECKED_ELEMENT_BEHAVIOR_HTML 2479
+#define IDR_POLYMER_1_0_PAPER_BEHAVIORS_PAPER_INKY_FOCUS_BEHAVIOR_EXTRACTED_JS 2480
+#define IDR_POLYMER_1_0_PAPER_BEHAVIORS_PAPER_INKY_FOCUS_BEHAVIOR_HTML 2481
+#define IDR_POLYMER_1_0_PAPER_BEHAVIORS_PAPER_RIPPLE_BEHAVIOR_EXTRACTED_JS 2482
+#define IDR_POLYMER_1_0_PAPER_BEHAVIORS_PAPER_RIPPLE_BEHAVIOR_HTML 2483
+#define IDR_POLYMER_1_0_PAPER_BUTTON_PAPER_BUTTON_EXTRACTED_JS 2484
+#define IDR_POLYMER_1_0_PAPER_BUTTON_PAPER_BUTTON_HTML 2485
+#define IDR_POLYMER_1_0_PAPER_CARD_PAPER_CARD_EXTRACTED_JS 2486
+#define IDR_POLYMER_1_0_PAPER_CARD_PAPER_CARD_HTML 2487
+#define IDR_POLYMER_1_0_PAPER_CHECKBOX_PAPER_CHECKBOX_EXTRACTED_JS 2488
+#define IDR_POLYMER_1_0_PAPER_CHECKBOX_PAPER_CHECKBOX_HTML 2489
+#define IDR_POLYMER_1_0_PAPER_DIALOG_BEHAVIOR_PAPER_DIALOG_BEHAVIOR_EXTRACTED_JS 2490
+#define IDR_POLYMER_1_0_PAPER_DIALOG_BEHAVIOR_PAPER_DIALOG_BEHAVIOR_HTML 2491
+#define IDR_POLYMER_1_0_PAPER_DIALOG_BEHAVIOR_PAPER_DIALOG_COMMON_CSS 2492
+#define IDR_POLYMER_1_0_PAPER_DIALOG_BEHAVIOR_PAPER_DIALOG_SHARED_STYLES_HTML 2493
+#define IDR_POLYMER_1_0_PAPER_DIALOG_PAPER_DIALOG_EXTRACTED_JS 2494
+#define IDR_POLYMER_1_0_PAPER_DIALOG_PAPER_DIALOG_HTML 2495
+#define IDR_POLYMER_1_0_PAPER_DRAWER_PANEL_PAPER_DRAWER_PANEL_EXTRACTED_JS 2496
+#define IDR_POLYMER_1_0_PAPER_DRAWER_PANEL_PAPER_DRAWER_PANEL_HTML 2497
+#define IDR_POLYMER_1_0_PAPER_DROPDOWN_MENU_PAPER_DROPDOWN_MENU_EXTRACTED_JS 2498
+#define IDR_POLYMER_1_0_PAPER_DROPDOWN_MENU_PAPER_DROPDOWN_MENU_HTML 2499
+#define IDR_POLYMER_1_0_PAPER_FAB_PAPER_FAB_EXTRACTED_JS 2500
+#define IDR_POLYMER_1_0_PAPER_FAB_PAPER_FAB_HTML 2501
+#define IDR_POLYMER_1_0_PAPER_HEADER_PANEL_PAPER_HEADER_PANEL_EXTRACTED_JS 2502
+#define IDR_POLYMER_1_0_PAPER_HEADER_PANEL_PAPER_HEADER_PANEL_HTML 2503
+#define IDR_POLYMER_1_0_PAPER_ICON_BUTTON_PAPER_ICON_BUTTON_EXTRACTED_JS 2504
+#define IDR_POLYMER_1_0_PAPER_ICON_BUTTON_PAPER_ICON_BUTTON_HTML 2505
+#define IDR_POLYMER_1_0_PAPER_INPUT_PAPER_INPUT_ADDON_BEHAVIOR_EXTRACTED_JS 2506
+#define IDR_POLYMER_1_0_PAPER_INPUT_PAPER_INPUT_ADDON_BEHAVIOR_HTML 2507
+#define IDR_POLYMER_1_0_PAPER_INPUT_PAPER_INPUT_BEHAVIOR_EXTRACTED_JS 2508
+#define IDR_POLYMER_1_0_PAPER_INPUT_PAPER_INPUT_BEHAVIOR_HTML 2509
+#define IDR_POLYMER_1_0_PAPER_INPUT_PAPER_INPUT_CHAR_COUNTER_EXTRACTED_JS 2510
+#define IDR_POLYMER_1_0_PAPER_INPUT_PAPER_INPUT_CHAR_COUNTER_HTML 2511
+#define IDR_POLYMER_1_0_PAPER_INPUT_PAPER_INPUT_CONTAINER_EXTRACTED_JS 2512
+#define IDR_POLYMER_1_0_PAPER_INPUT_PAPER_INPUT_CONTAINER_HTML 2513
+#define IDR_POLYMER_1_0_PAPER_INPUT_PAPER_INPUT_ERROR_EXTRACTED_JS 2514
+#define IDR_POLYMER_1_0_PAPER_INPUT_PAPER_INPUT_ERROR_HTML 2515
+#define IDR_POLYMER_1_0_PAPER_INPUT_PAPER_INPUT_EXTRACTED_JS 2516
+#define IDR_POLYMER_1_0_PAPER_INPUT_PAPER_INPUT_HTML 2517
+#define IDR_POLYMER_1_0_PAPER_ITEM_PAPER_ICON_ITEM_EXTRACTED_JS 2518
+#define IDR_POLYMER_1_0_PAPER_ITEM_PAPER_ICON_ITEM_HTML 2519
+#define IDR_POLYMER_1_0_PAPER_ITEM_PAPER_ITEM_BEHAVIOR_EXTRACTED_JS 2520
+#define IDR_POLYMER_1_0_PAPER_ITEM_PAPER_ITEM_BEHAVIOR_HTML 2521
+#define IDR_POLYMER_1_0_PAPER_ITEM_PAPER_ITEM_BODY_EXTRACTED_JS 2522
+#define IDR_POLYMER_1_0_PAPER_ITEM_PAPER_ITEM_BODY_HTML 2523
+#define IDR_POLYMER_1_0_PAPER_ITEM_PAPER_ITEM_EXTRACTED_JS 2524
+#define IDR_POLYMER_1_0_PAPER_ITEM_PAPER_ITEM_SHARED_STYLES_HTML 2525
+#define IDR_POLYMER_1_0_PAPER_ITEM_PAPER_ITEM_HTML 2526
+#define IDR_POLYMER_1_0_PAPER_LISTBOX_PAPER_LISTBOX_EXTRACTED_JS 2527
+#define IDR_POLYMER_1_0_PAPER_LISTBOX_PAPER_LISTBOX_HTML 2528
+#define IDR_POLYMER_1_0_PAPER_MATERIAL_PAPER_MATERIAL_EXTRACTED_JS 2529
+#define IDR_POLYMER_1_0_PAPER_MATERIAL_PAPER_MATERIAL_SHARED_STYLES_HTML 2530
+#define IDR_POLYMER_1_0_PAPER_MATERIAL_PAPER_MATERIAL_HTML 2531
+#define IDR_POLYMER_1_0_PAPER_MENU_BUTTON_PAPER_MENU_BUTTON_ANIMATIONS_EXTRACTED_JS 2532
+#define IDR_POLYMER_1_0_PAPER_MENU_BUTTON_PAPER_MENU_BUTTON_ANIMATIONS_HTML 2533
+#define IDR_POLYMER_1_0_PAPER_MENU_BUTTON_PAPER_MENU_BUTTON_EXTRACTED_JS 2534
+#define IDR_POLYMER_1_0_PAPER_MENU_BUTTON_PAPER_MENU_BUTTON_HTML 2535
+#define IDR_POLYMER_1_0_PAPER_MENU_PAPER_MENU_EXTRACTED_JS 2536
+#define IDR_POLYMER_1_0_PAPER_MENU_PAPER_MENU_SHARED_STYLES_HTML 2537
+#define IDR_POLYMER_1_0_PAPER_MENU_PAPER_MENU_HTML 2538
+#define IDR_POLYMER_1_0_PAPER_MENU_PAPER_SUBMENU_EXTRACTED_JS 2539
+#define IDR_POLYMER_1_0_PAPER_MENU_PAPER_SUBMENU_HTML 2540
+#define IDR_POLYMER_1_0_PAPER_PROGRESS_PAPER_PROGRESS_EXTRACTED_JS 2541
+#define IDR_POLYMER_1_0_PAPER_PROGRESS_PAPER_PROGRESS_HTML 2542
+#define IDR_POLYMER_1_0_PAPER_RADIO_BUTTON_PAPER_RADIO_BUTTON_EXTRACTED_JS 2543
+#define IDR_POLYMER_1_0_PAPER_RADIO_BUTTON_PAPER_RADIO_BUTTON_HTML 2544
+#define IDR_POLYMER_1_0_PAPER_RADIO_GROUP_PAPER_RADIO_GROUP_EXTRACTED_JS 2545
+#define IDR_POLYMER_1_0_PAPER_RADIO_GROUP_PAPER_RADIO_GROUP_HTML 2546
+#define IDR_POLYMER_1_0_PAPER_RIPPLE_PAPER_RIPPLE_EXTRACTED_JS 2547
+#define IDR_POLYMER_1_0_PAPER_RIPPLE_PAPER_RIPPLE_HTML 2548
+#define IDR_POLYMER_1_0_PAPER_SLIDER_PAPER_SLIDER_EXTRACTED_JS 2549
+#define IDR_POLYMER_1_0_PAPER_SLIDER_PAPER_SLIDER_HTML 2550
+#define IDR_POLYMER_1_0_PAPER_SPINNER_PAPER_SPINNER_BEHAVIOR_EXTRACTED_JS 2551
+#define IDR_POLYMER_1_0_PAPER_SPINNER_PAPER_SPINNER_BEHAVIOR_HTML 2552
+#define IDR_POLYMER_1_0_PAPER_SPINNER_PAPER_SPINNER_EXTRACTED_JS 2553
+#define IDR_POLYMER_1_0_PAPER_SPINNER_PAPER_SPINNER_LITE_EXTRACTED_JS 2554
+#define IDR_POLYMER_1_0_PAPER_SPINNER_PAPER_SPINNER_LITE_HTML 2555
+#define IDR_POLYMER_1_0_PAPER_SPINNER_PAPER_SPINNER_STYLES_HTML 2556
+#define IDR_POLYMER_1_0_PAPER_SPINNER_PAPER_SPINNER_HTML 2557
+#define IDR_POLYMER_1_0_PAPER_STYLES_CLASSES_SHADOW_LAYOUT_HTML 2558
+#define IDR_POLYMER_1_0_PAPER_STYLES_CLASSES_SHADOW_HTML 2559
+#define IDR_POLYMER_1_0_PAPER_STYLES_CLASSES_TYPOGRAPHY_HTML 2560
+#define IDR_POLYMER_1_0_PAPER_STYLES_COLOR_HTML 2561
+#define IDR_POLYMER_1_0_PAPER_STYLES_DEFAULT_THEME_HTML 2562
+#define IDR_POLYMER_1_0_PAPER_STYLES_PAPER_STYLES_CLASSES_HTML 2563
+#define IDR_POLYMER_1_0_PAPER_STYLES_PAPER_STYLES_HTML 2564
+#define IDR_POLYMER_1_0_PAPER_STYLES_SHADOW_HTML 2565
+#define IDR_POLYMER_1_0_PAPER_STYLES_TYPOGRAPHY_HTML 2566
+#define IDR_POLYMER_1_0_PAPER_TABS_PAPER_TAB_EXTRACTED_JS 2567
+#define IDR_POLYMER_1_0_PAPER_TABS_PAPER_TAB_HTML 2568
+#define IDR_POLYMER_1_0_PAPER_TABS_PAPER_TABS_EXTRACTED_JS 2569
+#define IDR_POLYMER_1_0_PAPER_TABS_PAPER_TABS_ICONS_HTML 2570
+#define IDR_POLYMER_1_0_PAPER_TABS_PAPER_TABS_HTML 2571
+#define IDR_POLYMER_1_0_PAPER_TOGGLE_BUTTON_PAPER_TOGGLE_BUTTON_EXTRACTED_JS 2572
+#define IDR_POLYMER_1_0_PAPER_TOGGLE_BUTTON_PAPER_TOGGLE_BUTTON_HTML 2573
+#define IDR_POLYMER_1_0_PAPER_TOOLBAR_PAPER_TOOLBAR_EXTRACTED_JS 2574
+#define IDR_POLYMER_1_0_PAPER_TOOLBAR_PAPER_TOOLBAR_HTML 2575
+#define IDR_POLYMER_1_0_PAPER_TOOLTIP_PAPER_TOOLTIP_EXTRACTED_JS 2576
+#define IDR_POLYMER_1_0_PAPER_TOOLTIP_PAPER_TOOLTIP_HTML 2577
+#define IDR_POLYMER_1_0_POLYMER_POLYMER_EXTRACTED_JS 2578
+#define IDR_POLYMER_1_0_POLYMER_POLYMER_MICRO_EXTRACTED_JS 2579
+#define IDR_POLYMER_1_0_POLYMER_POLYMER_MICRO_HTML 2580
+#define IDR_POLYMER_1_0_POLYMER_POLYMER_MINI_EXTRACTED_JS 2581
+#define IDR_POLYMER_1_0_POLYMER_POLYMER_MINI_HTML 2582
+#define IDR_POLYMER_1_0_POLYMER_POLYMER_HTML 2583
+#define IDR_POLYMER_1_0_WEB_ANIMATIONS_JS_WEB_ANIMATIONS_NEXT_LITE_MIN_JS 2584
+
+#endif  // CEF_INCLUDE_CEF_PACK_RESOURCES_H_
diff --git a/src/include/libcef/cef_pack_strings.h b/src/include/libcef/cef_pack_strings.h
new file mode 100644
index 0000000..823a670
--- /dev/null
+++ b/src/include/libcef/cef_pack_strings.h
@@ -0,0 +1,1178 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file is generated by the make_pack_header.py tool.
+//
+
+#ifndef CEF_INCLUDE_CEF_PACK_STRINGS_H_
+#define CEF_INCLUDE_CEF_PACK_STRINGS_H_
+#pragma once
+
+// ---------------------------------------------------------------------------
+// From cef_strings.h:
+
+#define IDS_MENU_BACK 28000
+#define IDS_MENU_FORWARD 28001
+#define IDS_MENU_RELOAD 28002
+#define IDS_MENU_RELOAD_NOCACHE 28003
+#define IDS_MENU_STOPLOAD 28004
+#define IDS_MENU_UNDO 28005
+#define IDS_MENU_REDO 28006
+#define IDS_MENU_CUT 28007
+#define IDS_MENU_COPY 28008
+#define IDS_MENU_PASTE 28009
+#define IDS_MENU_DELETE 28010
+#define IDS_MENU_SELECT_ALL 28011
+#define IDS_MENU_FIND 28012
+#define IDS_MENU_PRINT 28013
+#define IDS_MENU_VIEW_SOURCE 28014
+#define IDS_APP_AUDIO_FILES 28015
+#define IDS_APP_IMAGE_FILES 28016
+#define IDS_APP_TEXT_FILES 28017
+#define IDS_APP_VIDEO_FILES 28018
+#define IDS_DEFAULT_PRINT_DOCUMENT_TITLE 28019
+#define IDS_PRINT_SPOOL_FAILED_TITLE_TEXT 28020
+#define IDS_PRINT_SPOOL_FAILED_ERROR_TEXT 28021
+#define IDS_PRINT_INVALID_PRINTER_SETTINGS 28022
+#define IDS_UTILITY_PROCESS_EMF_CONVERTOR_NAME 28023
+#define IDS_UTILITY_PROCESS_PROXY_RESOLVER_NAME 28024
+#define IDS_SPELLCHECK_DICTIONARY 28025
+#define IDS_CONTENT_CONTEXT_ADD_TO_DICTIONARY 28026
+#define IDS_CONTENT_CONTEXT_NO_SPELLING_SUGGESTIONS 28027
+#define IDS_UTILITY_PROCESS_FONT_CACHE_BUILDER_NAME 28028
+#define IDS_PLUGIN_HIDE 28029
+#define IDS_PLUGIN_BLOCKED 28030
+#define IDS_PLUGIN_NOT_SUPPORTED_METRO 28031
+#define IDS_PLUGIN_OUTDATED 28032
+#define IDS_PLUGIN_NOT_AUTHORIZED 28033
+#define IDS_PLUGIN_BLOCKED_BY_POLICY 28034
+#define IDS_CONTENT_CONTEXT_PLUGIN_RUN 28035
+#define IDS_CONTENT_CONTEXT_PLUGIN_HIDE 28036
+#define IDS_USES_UNIVERSAL_DETECTOR 28037
+#define IDS_STATIC_ENCODING_LIST 28038
+#define IDS_ENCODING_DISPLAY_TEMPLATE 28039
+#define IDS_ENCODING_UNICODE 28040
+#define IDS_ENCODING_WESTERN 28041
+#define IDS_ENCODING_SIMP_CHINESE 28042
+#define IDS_ENCODING_TRAD_CHINESE 28043
+#define IDS_ENCODING_KOREAN 28044
+#define IDS_ENCODING_JAPANESE 28045
+#define IDS_ENCODING_THAI 28046
+#define IDS_ENCODING_CENTRAL_EUROPEAN 28047
+#define IDS_ENCODING_CYRILLIC 28048
+#define IDS_ENCODING_GREEK 28049
+#define IDS_ENCODING_BALTIC 28050
+#define IDS_ENCODING_SOUTH_EUROPEAN 28051
+#define IDS_ENCODING_NORDIC 28052
+#define IDS_ENCODING_CELTIC 28053
+#define IDS_ENCODING_ROMANIAN 28054
+#define IDS_ENCODING_TURKISH 28055
+#define IDS_ENCODING_ARABIC 28056
+#define IDS_ENCODING_HEBREW 28057
+#define IDS_ENCODING_VIETNAMESE 28058
+
+// ---------------------------------------------------------------------------
+// From components_strings.h:
+
+#define IDS_JAVASCRIPT_MESSAGEBOX_TITLE 28290
+#define IDS_JAVASCRIPT_MESSAGEBOX_TITLE_IFRAME 28291
+#define IDS_JAVASCRIPT_MESSAGEBOX_TITLE_NONSTANDARD_URL 28292
+#define IDS_JAVASCRIPT_MESSAGEBOX_TITLE_NONSTANDARD_URL_IFRAME 28293
+#define IDS_JAVASCRIPT_MESSAGEBOX_SUPPRESS_OPTION 28294
+#define IDS_BEFOREUNLOAD_MESSAGEBOX_TITLE 28295
+#define IDS_BEFOREUNLOAD_MESSAGEBOX_MESSAGE 28296
+#define IDS_BEFOREUNLOAD_MESSAGEBOX_OK_BUTTON_LABEL 28297
+#define IDS_BEFOREUNLOAD_MESSAGEBOX_CANCEL_BUTTON_LABEL 28298
+#define IDS_BEFORERELOAD_MESSAGEBOX_TITLE 28299
+#define IDS_BEFORERELOAD_MESSAGEBOX_OK_BUTTON_LABEL 28300
+#define IDS_BEFORERELOAD_MESSAGEBOX_CANCEL_BUTTON_LABEL 28301
+#define IDS_AUTOFILL_CLEAR_FORM_MENU_ITEM 28302
+#define IDS_AUTOFILL_CLEAR_LOCAL_COPY_BUTTON 28303
+#define IDS_AUTOFILL_WARNING_FORM_DISABLED 28304
+#define IDS_AUTOFILL_WARNING_INSECURE_CONNECTION 28305
+#define IDS_AUTOFILL_DELETE_AUTOCOMPLETE_SUGGESTION_CONFIRMATION_BODY 28306
+#define IDS_AUTOFILL_DELETE_CREDIT_CARD_SUGGESTION_CONFIRMATION_BODY 28307
+#define IDS_AUTOFILL_DELETE_PROFILE_SUGGESTION_CONFIRMATION_BODY 28308
+#define IDS_AUTOFILL_CC_AMEX 28309
+#define IDS_AUTOFILL_CC_AMEX_SHORT 28310
+#define IDS_AUTOFILL_CC_DINERS 28311
+#define IDS_AUTOFILL_CC_DISCOVER 28312
+#define IDS_AUTOFILL_CC_JCB 28313
+#define IDS_AUTOFILL_CC_MASTERCARD 28314
+#define IDS_AUTOFILL_CC_UNION_PAY 28315
+#define IDS_AUTOFILL_CC_VISA 28316
+#define IDS_AUTOFILL_CC_GENERIC 28317
+#define IDS_AUTOFILL_ADDRESS_LINE_SEPARATOR 28318
+#define IDS_AUTOFILL_ADDRESS_SUMMARY_SEPARATOR 28319
+#define IDS_AUTOFILL_FIELD_LABEL_STATE 28320
+#define IDS_AUTOFILL_FIELD_LABEL_AREA 28321
+#define IDS_AUTOFILL_FIELD_LABEL_COUNTY 28322
+#define IDS_AUTOFILL_FIELD_LABEL_DEPARTMENT 28323
+#define IDS_AUTOFILL_FIELD_LABEL_DISTRICT 28324
+#define IDS_AUTOFILL_FIELD_LABEL_EMIRATE 28325
+#define IDS_AUTOFILL_FIELD_LABEL_ISLAND 28326
+#define IDS_AUTOFILL_FIELD_LABEL_PARISH 28327
+#define IDS_AUTOFILL_FIELD_LABEL_PREFECTURE 28328
+#define IDS_AUTOFILL_FIELD_LABEL_PROVINCE 28329
+#define IDS_AUTOFILL_FIELD_LABEL_ZIP_CODE 28330
+#define IDS_AUTOFILL_FIELD_LABEL_POSTAL_CODE 28331
+#define IDS_AUTOFILL_FIELD_LABEL_COUNTRY 28332
+#define IDS_AUTOFILL_SHOW_PREDICTIONS_TITLE 28333
+#define IDS_AUTOFILL_DIALOG_PRIVACY_POLICY_LINK 28334
+#define IDS_AUTOFILL_OPTIONS_POPUP 28335
+#define IDS_AUTOFILL_OPTIONS_CONTENT_DESCRIPTION 28336
+#define IDS_AUTOFILL_CREDIT_CARD_NOT_SUPPORTED_BY_WALLET 28337
+#define IDS_AUTOFILL_CREDIT_CARD_NOT_SUPPORTED_BY_WALLET_FOR_MERCHANT 28338
+#define IDS_AUTOFILL_SCAN_CREDIT_CARD 28340
+#define IDS_AUTOFILL_PASSWORD_FIELD_SUGGESTIONS_TITLE 28341
+#define IDS_AUTOFILL_SAVE_CARD_PROMPT_ACCEPT 28342
+#define IDS_AUTOFILL_SAVE_CARD_PROMPT_DENY 28343
+#define IDS_AUTOFILL_SAVE_CARD_PROMPT_TITLE_LOCAL 28344
+#define IDS_AUTOFILL_SAVE_CARD_PROMPT_TITLE_TO_CLOUD 28345
+#define IDS_AUTOFILL_SAVE_CARD_PROMPT_UPLOAD_EXPLANATION 28346
+#define IDS_AUTOFILL_CREDIT_CARD_EXPIRATION_DATE_ABBR 28347
+#define IDS_AUTOFILL_CARD_UNMASK_PROMPT_ERROR_TRY_AGAIN 28348
+#define IDS_AUTOFILL_CARD_UNMASK_PROMPT_ERROR_TRY_AGAIN_WITH_EXPIRATION 28349
+#define IDS_AUTOFILL_CARD_UNMASK_PROMPT_ERROR_PERMANENT 28350
+#define IDS_AUTOFILL_CARD_UNMASK_PROMPT_ERROR_NETWORK 28351
+#define IDS_AUTOFILL_CARD_UNMASK_PROMPT_TITLE 28352
+#define IDS_AUTOFILL_CARD_UNMASK_PROMPT_UPDATE_TITLE 28353
+#define IDS_AUTOFILL_CARD_UNMASK_PROMPT_INSTRUCTIONS 28354
+#define IDS_AUTOFILL_CARD_UNMASK_PROMPT_INSTRUCTIONS_AMEX 28355
+#define IDS_AUTOFILL_CARD_UNMASK_PROMPT_INSTRUCTIONS_EXPIRED 28356
+#define IDS_AUTOFILL_CARD_UNMASK_PROMPT_INSTRUCTIONS_EXPIRED_AMEX 28357
+#define IDS_AUTOFILL_CARD_UNMASK_PROMPT_STORAGE_CHECKBOX 28358
+#define IDS_AUTOFILL_CARD_UNMASK_PROMPT_STORAGE_TOOLTIP 28359
+#define IDS_AUTOFILL_CARD_UNMASK_CONFIRM_BUTTON 28360
+#define IDS_AUTOFILL_CARD_UNMASK_VERIFICATION_IN_PROGRESS 28361
+#define IDS_AUTOFILL_CARD_UNMASK_VERIFICATION_SUCCESS 28362
+#define IDS_AUTOFILL_CARD_UNMASK_INVALID_EXPIRATION_DATE 28363
+#define IDS_AUTOFILL_CARD_UNMASK_EXPIRATION_DATE_SEPARATOR 28364
+#define IDS_AUTOFILL_CARD_UNMASK_NEW_CARD_LINK 28365
+#define IDS_AUTOFILL_DIALOG_PLACEHOLDER_CVC 28366
+#define IDS_BOOKMARK_BAR_FOLDER_NAME 28367
+#define IDS_BOOKMARK_BAR_MOBILE_FOLDER_NAME 28368
+#define IDS_BOOKMARK_BAR_OTHER_FOLDER_NAME 28369
+#define IDS_BOOKMARK_BAR_MANAGED_FOLDER_DOMAIN_NAME 28370
+#define IDS_BOOKMARK_BAR_MANAGED_FOLDER_DEFAULT_NAME 28371
+#define IDS_BOOKMARK_BAR_SUPERVISED_FOLDER_DEFAULT_NAME 28372
+#define IDS_BOOKMARK_BUBBLE_REMOVE_BOOKMARK 28373
+#define IDS_BOOKMARK_EDITOR_NEW_FOLDER_NAME 28374
+#define IDS_BOOKMARK_EDITOR_TITLE 28375
+#define IDS_BOOKMARK_MANAGER_NAME_INPUT_PLACE_HOLDER 28376
+#define IDS_BOOKMARK_MANAGER_URL_INPUT_PLACE_HOLDER 28377
+#define IDS_TOOLTIP_STAR 28385
+#define IDS_SYNC_TIME_NEVER 28386
+#define IDS_SYNC_TIME_JUST_NOW 28387
+#define IDS_SETTINGS_TITLE 28388
+#define IDS_SETTINGS_HIDE_ADVANCED_SETTINGS 28389
+#define IDS_SETTINGS_SHOW_ADVANCED_SETTINGS 28390
+#define IDS_NETWORK_PREDICTION_ENABLED_DESCRIPTION 28391
+#define IDS_OPTIONS_PROXIES_CONFIGURE_BUTTON 28392
+#define IDS_CRASH_TITLE 28393
+#define IDS_CRASH_CRASH_COUNT_BANNER_FORMAT 28394
+#define IDS_CRASH_CRASH_HEADER_FORMAT 28395
+#define IDS_CRASH_CRASH_TIME_FORMAT 28396
+#define IDS_CRASH_BUG_LINK_LABEL 28397
+#define IDS_CRASH_NO_CRASHES_MESSAGE 28398
+#define IDS_CRASH_DISABLED_HEADER 28399
+#define IDS_CRASH_UPLOAD_MESSAGE 28400
+#define IDS_HTTP_POST_WARNING_TITLE 28401
+#define IDS_HTTP_POST_WARNING 28402
+#define IDS_HTTP_POST_WARNING_RESEND 28403
+#define IDS_DOM_DISTILLER_JAVASCRIPT_DISABLED_CONTENT 28404
+#define IDS_DOM_DISTILLER_WEBUI_ENTRY_URL 28405
+#define IDS_DOM_DISTILLER_WEBUI_ENTRY_ADD 28406
+#define IDS_DOM_DISTILLER_WEBUI_ENTRY_ADD_FAILED 28407
+#define IDS_DOM_DISTILLER_WEBUI_VIEW_URL 28408
+#define IDS_DOM_DISTILLER_WEBUI_VIEW_URL_FAILED 28409
+#define IDS_DOM_DISTILLER_WEBUI_REFRESH 28410
+#define IDS_DOM_DISTILLER_WEBUI_FETCHING_ENTRIES 28411
+#define IDS_DOM_DISTILLER_VIEWER_CLOSE_READER_VIEW 28412
+#define IDS_DOM_DISTILLER_VIEWER_FAILED_TO_FIND_ARTICLE_TITLE 28413
+#define IDS_DOM_DISTILLER_VIEWER_FAILED_TO_FIND_ARTICLE_CONTENT 28414
+#define IDS_DOM_DISTILLER_VIEWER_LOADING_TITLE 28415
+#define IDS_DOM_DISTILLER_VIEWER_NO_DATA_CONTENT 28416
+#define IDS_DOM_DISTILLER_VIEWER_LOADING_STRING 28417
+#define IDS_DOM_DISTILLER_QUALITY_QUESTION 28418
+#define IDS_DOM_DISTILLER_QUALITY_ANSWER_YES 28419
+#define IDS_DOM_DISTILLER_QUALITY_ANSWER_NO 28420
+#define IDS_DOM_DISTILLER_WEBUI_TITLE 28421
+#define IDS_ERRORPAGE_NET_BUTTON_DETAILS 28422
+#define IDS_ERRORPAGE_NET_BUTTON_HIDE_DETAILS 28423
+#define IDS_ERRORPAGES_BUTTON_MORE 28424
+#define IDS_ERRORPAGES_BUTTON_LESS 28425
+#define IDS_ERRORPAGES_BUTTON_RELOAD 28426
+#define IDS_ERRORPAGES_BUTTON_SHOW_SAVED_COPY 28427
+#define IDS_ERRORPAGES_BUTTON_SHOW_SAVED_COPY_HELP 28428
+#define IDS_ERRORPAGE_FUN_DISABLED 28431
+#define IDS_ERRORPAGES_BUTTON_DIAGNOSE 28432
+#define IDS_ERRORPAGES_SUGGESTION_VISIT_GOOGLE_CACHE 28434
+#define IDS_ERRORPAGES_SUGGESTION_CORRECTED_URL 28435
+#define IDS_ERRORPAGES_SUGGESTION_ALTERNATE_URL 28436
+#define IDS_ERRORPAGES_SUGGESTION_RELOAD_REPOST_SUMMARY 28437
+#define IDS_ERRORPAGES_SUGGESTION_CHECK_CONNECTION_HEADER 28438
+#define IDS_ERRORPAGES_SUGGESTION_CHECK_CONNECTION_BODY 28439
+#define IDS_ERRORPAGES_SUGGESTION_DNS_CONFIG_HEADER 28440
+#define IDS_ERRORPAGES_SUGGESTION_DNS_CONFIG_BODY 28441
+#define IDS_ERRORPAGES_SUGGESTION_NETWORK_PREDICTION_HEADER 28442
+#define IDS_ERRORPAGES_SUGGESTION_FIREWALL_CONFIG_BODY 28443
+#define IDS_ERRORPAGES_SUGGESTION_PROXY_CONFIG_HEADER 28444
+#define IDS_ERRORPAGES_SUGGESTION_PROXY_CONFIG_BODY 28445
+#define IDS_ERRORPAGES_SUGGESTION_VIEW_POLICIES_HEADER 28447
+#define IDS_ERRORPAGES_SUGGESTION_VIEW_POLICIES_BODY 28448
+#define IDS_ERRORPAGES_SUGGESTION_UNSUPPORTED_CIPHER_HEADER 28449
+#define IDS_ERRORPAGES_SUGGESTION_UNSUPPORTED_CIPHER_BODY 28450
+#define IDS_ERRORPAGES_TITLE_NOT_AVAILABLE 28451
+#define IDS_ERRORPAGES_TITLE_ACCESS_DENIED 28452
+#define IDS_ERRORPAGES_TITLE_NOT_FOUND 28453
+#define IDS_ERRORPAGES_TITLE_LOAD_FAILED 28454
+#define IDS_ERRORPAGES_TITLE_BLOCKED 28455
+#define IDS_ERRORPAGES_HEADING_NOT_AVAILABLE 28456
+#define IDS_ERRORPAGES_HEADING_NETWORK_ACCESS_DENIED 28457
+#define IDS_ERRORPAGES_HEADING_INTERNET_DISCONNECTED 28458
+#define IDS_ERRORPAGES_HEADING_CACHE_READ_FAILURE 28459
+#define IDS_ERRORPAGES_HEADING_CONNECTION_INTERRUPTED 28460
+#define IDS_ERRORPAGES_HEADING_NOT_FOUND 28461
+#define IDS_ERRORPAGES_HEADING_FILE_NOT_FOUND 28462
+#define IDS_ERRORPAGES_HEADING_TOO_MANY_REDIRECTS 28463
+#define IDS_ERRORPAGES_HEADING_EMPTY_RESPONSE 28464
+#define IDS_ERRORPAGES_HEADING_BLOCKED 28465
+#define IDS_ERRORPAGES_SUMMARY_NOT_AVAILABLE 28466
+#define IDS_ERRORPAGES_SUMMARY_TIMED_OUT 28467
+#define IDS_ERRORPAGES_SUMMARY_CONNECTION_RESET 28468
+#define IDS_ERRORPAGES_SUMMARY_CONNECTION_CLOSED 28469
+#define IDS_ERRORPAGES_SUMMARY_CONNECTION_FAILED 28470
+#define IDS_ERRORPAGES_SUMMARY_NETWORK_CHANGED 28471
+#define IDS_ERRORPAGES_SUMMARY_CONNECTION_REFUSED 28472
+#define IDS_ERRORPAGES_SUMMARY_NAME_NOT_RESOLVED 28473
+#define IDS_ERRORPAGES_SUMMARY_DNS_DEFINITION 28474
+#define IDS_ERRORPAGES_SUMMARY_ICANN_NAME_COLLISION 28475
+#define IDS_ERRORPAGES_SUMMARY_ADDRESS_UNREACHABLE 28476
+#define IDS_ERRORPAGES_SUMMARY_FILE_ACCESS_DENIED 28477
+#define IDS_ERRORPAGES_SUMMARY_NETWORK_ACCESS_DENIED 28478
+#define IDS_ERRORPAGES_SUMMARY_PROXY_CONNECTION_FAILED 28479
+#define IDS_ERRORPAGES_SUMMARY_INTERNET_DISCONNECTED_INSTRUCTIONS_TEMPLATE 28481
+#define IDS_ERRORPAGES_SUMMARY_INTERNET_DISCONNECTED 28480
+#define IDS_ERRORPAGES_SUMMARY_INTERNET_DISCONNECTED_PLATFORM 28482
+#define IDS_ERRORPAGES_SUMMARY_INTERNET_DISCONNECTED_PLATFORM_VISTA 28483
+#define IDS_ERRORPAGES_SUMMARY_INTERNET_DISCONNECTED_PLATFORM_XP 28484
+#define IDS_ERRORPAGES_SUMMARY_CACHE_READ_FAILURE 28485
+#define IDS_ERRORPAGES_SUMMARY_NETWORK_IO_SUSPENDED 28486
+#define IDS_ERRORPAGES_SUMMARY_NOT_FOUND 28487
+#define IDS_ERRORPAGES_SUMMARY_FILE_NOT_FOUND 28488
+#define IDS_ERRORPAGES_SUMMARY_TOO_MANY_REDIRECTS 28489
+#define IDS_ERRORPAGES_SUMMARY_EMPTY_RESPONSE 28490
+#define IDS_ERRORPAGES_SUMMARY_INVALID_RESPONSE 28491
+#define IDS_ERRORPAGES_SUMMARY_DNS_PROBE_RUNNING 28492
+#define IDS_ERRORPAGES_DETAILS_TIMED_OUT 28493
+#define IDS_ERRORPAGES_DETAILS_CONNECTION_CLOSED 28494
+#define IDS_ERRORPAGES_DETAILS_CONNECTION_RESET 28495
+#define IDS_ERRORPAGES_DETAILS_CONNECTION_REFUSED 28496
+#define IDS_ERRORPAGES_DETAILS_CONNECTION_FAILED 28497
+#define IDS_ERRORPAGES_DETAILS_NETWORK_CHANGED 28498
+#define IDS_ERRORPAGES_DETAILS_NAME_NOT_RESOLVED 28499
+#define IDS_ERRORPAGES_DETAILS_ICANN_NAME_COLLISION 28500
+#define IDS_ERRORPAGES_DETAILS_ADDRESS_UNREACHABLE 28501
+#define IDS_ERRORPAGES_DETAILS_NETWORK_ACCESS_DENIED 28502
+#define IDS_ERRORPAGES_DETAILS_FILE_ACCESS_DENIED 28503
+#define IDS_ERRORPAGES_DETAILS_PROXY_CONNECTION_FAILED 28504
+#define IDS_ERRORPAGES_DETAILS_INTERNET_DISCONNECTED 28505
+#define IDS_ERRORPAGES_DETAILS_CACHE_READ_FAILURE 28506
+#define IDS_ERRORPAGES_DETAILS_NETWORK_IO_SUSPENDED 28507
+#define IDS_ERRORPAGES_DETAILS_FILE_NOT_FOUND 28508
+#define IDS_ERRORPAGES_DETAILS_TOO_MANY_REDIRECTS 28509
+#define IDS_ERRORPAGES_DETAILS_EMPTY_RESPONSE 28510
+#define IDS_ERRORPAGES_DETAILS_RESPONSE_HEADERS_MULTIPLE_CONTENT_LENGTH 28511
+#define IDS_ERRORPAGES_DETAILS_RESPONSE_HEADERS_MULTIPLE_CONTENT_DISPOSITION 28512
+#define IDS_ERRORPAGES_DETAILS_RESPONSE_HEADERS_MULTIPLE_LOCATION 28513
+#define IDS_ERRORPAGES_DETAILS_DNS_PROBE_RUNNING 28514
+#define IDS_ERRORPAGES_DETAILS_UNKNOWN 28515
+#define IDS_ERRORPAGES_HEADING_ACCESS_DENIED 28516
+#define IDS_ERRORPAGES_HEADING_FILE_ACCESS_DENIED 28517
+#define IDS_ERRORPAGES_SUMMARY_FORBIDDEN 28518
+#define IDS_ERRORPAGES_DETAILS_FORBIDDEN 28519
+#define IDS_ERRORPAGES_SUMMARY_GONE 28520
+#define IDS_ERRORPAGES_DETAILS_GONE 28521
+#define IDS_ERRORPAGES_HEADING_PAGE_NOT_WORKING 28522
+#define IDS_ERRORPAGES_DETAILS_INTERNAL_SERVER_ERROR 28523
+#define IDS_ERRORPAGES_SUMMARY_WEBSITE_CANNOT_HANDLE_REQUEST 28524
+#define IDS_ERRORPAGES_DETAILS_NOT_IMPLEMENTED 28525
+#define IDS_ERRORPAGES_DETAILS_BAD_GATEWAY 28526
+#define IDS_ERRORPAGES_SUMMARY_SERVICE_UNAVAILABLE 28527
+#define IDS_ERRORPAGES_DETAILS_SERVICE_UNAVAILABLE 28528
+#define IDS_ERRORPAGES_SUMMARY_GATEWAY_TIMEOUT 28529
+#define IDS_ERRORPAGES_DETAILS_GATEWAY_TIMEOUT 28530
+#define IDS_ERRORPAGES_SUMMARY_SSL_SECURITY_ERROR 28531
+#define IDS_ERRORPAGES_DETAILS_SSL_PROTOCOL_ERROR 28532
+#define IDS_ERRORPAGES_DETAILS_SSL_FALLBACK_BEYOND_MINIMUM_VERSION 28533
+#define IDS_ERRORPAGES_SUMMARY_SSL_VERSION_OR_CIPHER_MISMATCH 28534
+#define IDS_ERRORPAGES_DETAILS_SSL_VERSION_OR_CIPHER_MISMATCH 28535
+#define IDS_ERRORPAGES_SUMMARY_PINNING_FAILURE_DETAILS 28536
+#define IDS_ERRORPAGES_HEADING_INSECURE_CONNECTION 28537
+#define IDS_ERRORPAGES_SUMMARY_BAD_SSL_CLIENT_AUTH_CERT 28538
+#define IDS_ERRORPAGES_DETAILS_BAD_SSL_CLIENT_AUTH_CERT 28539
+#define IDS_ERRORPAGES_DETAILS_TEMPORARILY_THROTTLED 28540
+#define IDS_ERRORPAGES_SUMMARY_TEMPORARY_BACKOFF 28541
+#define IDS_ERRORPAGES_DETAILS_TEMPORARY_BACKOFF 28542
+#define IDS_ERRORPAGES_SUMMARY_BLOCKED_BY_EXTENSION 28543
+#define IDS_ERRORPAGES_SUMMARY_BLOCKED_BY_ADMINISTRATOR 28544
+#define IDS_ERRORPAGES_DETAILS_BLOCKED_BY_EXTENSION 28545
+#define IDS_ERRORPAGES_DETAILS_BLOCKED_BY_ADMINISTRATOR 28546
+#define IDS_ERRORPAGES_DETAILS_BLOCKED_ENROLLMENT_CHECK_PENDING 28547
+#define IDS_ERRORPAGES_HTTP_POST_WARNING 28548
+#define IDS_ERRORPAGES_SUGGESTION_LIST_HEADER 28549
+#define IDS_ERRORPAGES_SUGGESTION_CHECK_CONNECTION_SUMMARY 28550
+#define IDS_ERRORPAGES_SUGGESTION_CHECK_PROXY_FIREWALL_DNS_SUMMARY 28551
+#define IDS_ERRORPAGES_SUGGESTION_CHECK_FIREWALL_ANTIVIRUS_SUMMARY 28552
+#define IDS_ERRORPAGES_SUGGESTION_CHECK_PROXY_FIREWALL_SUMMARY 28553
+#define IDS_ERRORPAGES_SUGGESTION_CHECK_PROXY_ADDRESS_SUMMARY 28554
+#define IDS_ERRORPAGES_SUGGESTION_CONTACT_ADMIN_SUMMARY 28555
+#define IDS_ERRORPAGES_SUGGESTION_CONTACT_ADMIN_SUMMARY_WITH_PREFIX 28556
+#define IDS_ERRORPAGES_SUGGESTION_LEARNMORE_SUMMARY 28557
+#define IDS_ERRORPAGES_SUGGESTION_CLEAR_COOKIES_SUMMARY 28558
+#define IDS_ERRORPAGES_SUGGESTION_CHECK_CABLES_SUMMARY 28562
+#define IDS_ERRORPAGES_SUGGESTION_RESET_HARDWARE_SUMMARY 28563
+#define IDS_ERRORPAGES_SUGGESTION_CHECK_WIFI_SUMMARY 28564
+#define IDS_ERRORPAGES_SUGGESTION_DIAGNOSE_CONNECTION_SUMMARY 28565
+#define IDS_ERRORPAGES_SUGGESTION_COMPLETE_SETUP_SUMMARY 28566
+#define IDS_ERRORPAGES_SUGGESTION_DISABLE_EXTENSION_SUMMARY 28567
+#define IDS_ERRORPAGES_SUGGESTION_RELOAD_SUMMARY 28568
+#define IDS_ERRORPAGES_SUGGESTION_GOOGLE_SEARCH_SUMMARY 28569
+#define IDS_FIND_IN_PAGE_COUNT 28581
+#define IDS_FIND_IN_PAGE_PREVIOUS_TOOLTIP 28582
+#define IDS_FIND_IN_PAGE_NEXT_TOOLTIP 28583
+#define IDS_FIND_IN_PAGE_CLOSE_TOOLTIP 28584
+#define IDS_FLAGS_UI_LONG_TITLE 28585
+#define IDS_FLAGS_UI_TABLE_TITLE 28586
+#define IDS_FLAGS_UI_WARNING_HEADER 28587
+#define IDS_FLAGS_UI_WARNING_TEXT 28588
+#define IDS_FLAGS_UI_PROMOTE_BETA_CHANNEL 28589
+#define IDS_FLAGS_UI_PROMOTE_DEV_CHANNEL 28590
+#define IDS_FLAGS_UI_DISABLE 28591
+#define IDS_FLAGS_UI_ENABLE 28592
+#define IDS_FLAGS_UI_RESET_ALL_BUTTON 28593
+#define IDS_FLAGS_UI_UNSUPPORTED_TABLE_TITLE 28594
+#define IDS_FLAGS_UI_NOT_AVAILABLE 28595
+#define IDS_FLAGS_UI_ENABLE_NACL_NAME 28596
+#define IDS_FLAGS_UI_RELAUNCH_BUTTON 28597
+#define IDS_GENERIC_EXPERIMENT_CHOICE_AUTOMATIC 28599
+#define IDS_GENERIC_EXPERIMENT_CHOICE_DEFAULT 28600
+#define IDS_GENERIC_EXPERIMENT_CHOICE_ENABLED 28601
+#define IDS_GENERIC_EXPERIMENT_CHOICE_DISABLED 28602
+#define IDS_HISTORY_ACTION_MENU_DESCRIPTION 28605
+#define IDS_HISTORY_BLOCKED_VISIT_TEXT 28606
+#define IDS_HISTORY_BROWSERESULTS 28607
+#define IDS_HISTORY_CONTINUED 28608
+#define IDS_HISTORY_DATE_WITH_RELATIVE_TIME 28609
+#define IDS_HISTORY_DELETE_PRIOR_VISITS_CONFIRM_BUTTON 28610
+#define IDS_HISTORY_DELETE_PRIOR_VISITS_WARNING 28611
+#define IDS_HISTORY_DELETE_PRIOR_VISITS_WARNING_NO_INCOGNITO 28612
+#define IDS_HISTORY_ENTRY_BOOKMARKED 28613
+#define IDS_HISTORY_ENTRY_SUMMARY 28614
+#define IDS_HISTORY_FILTER_ALLOW_ITEMS 28615
+#define IDS_HISTORY_FILTER_ALLOWED 28616
+#define IDS_HISTORY_FILTER_BLOCK_ITEMS 28617
+#define IDS_HISTORY_FILTER_BLOCKED 28618
+#define IDS_HISTORY_FOUND_SEARCH_RESULTS 28619
+#define IDS_HISTORY_GROUP_BY_DOMAIN_LABEL 28620
+#define IDS_HISTORY_HAS_SYNCED_RESULTS 28621
+#define IDS_HISTORY_OTHER_FORMS_OF_HISTORY 28622
+#define IDS_HISTORY_IN_CONTENT_PACK 28623
+#define IDS_HISTORY_INTERVAL 28624
+#define IDS_HISTORY_LOADING 28625
+#define IDS_HISTORY_MORE_FROM_SITE 28626
+#define IDS_HISTORY_NEWER 28627
+#define IDS_HISTORY_NEWEST 28628
+#define IDS_HISTORY_NO_RESULTS 28629
+#define IDS_HISTORY_NO_SEARCH_RESULTS 28630
+#define IDS_HISTORY_NO_SYNCED_RESULTS 28631
+#define IDS_HISTORY_NUMBER_VISITS 28632
+#define IDS_HISTORY_OLDER 28633
+#define IDS_HISTORY_OPEN_CLEAR_BROWSING_DATA_DIALOG 28634
+#define IDS_HISTORY_OTHER_DEVICES_X_MORE 28635
+#define IDS_HISTORY_OTHER_SESSIONS_COLLAPSE_SESSION 28636
+#define IDS_HISTORY_OTHER_SESSIONS_EXPAND_SESSION 28637
+#define IDS_HISTORY_OTHER_SESSIONS_OPEN_ALL 28638
+#define IDS_HISTORY_RANGE_ALL_TIME 28639
+#define IDS_HISTORY_RANGE_LABEL 28640
+#define IDS_HISTORY_RANGE_MONTH 28641
+#define IDS_HISTORY_RANGE_NEXT 28642
+#define IDS_HISTORY_RANGE_PREVIOUS 28643
+#define IDS_HISTORY_RANGE_TODAY 28644
+#define IDS_HISTORY_RANGE_WEEK 28645
+#define IDS_HISTORY_REMOVE_BOOKMARK 28646
+#define IDS_HISTORY_REMOVE_PAGE 28647
+#define IDS_HISTORY_REMOVE_SELECTED_ITEMS 28648
+#define IDS_HISTORY_SEARCH_BUTTON 28649
+#define IDS_HISTORY_SEARCH_RESULT 28650
+#define IDS_HISTORY_SEARCH_RESULTS 28651
+#define IDS_HISTORY_SEARCHRESULTSFOR 28652
+#define IDS_HISTORY_SHOW_HISTORY 28653
+#define IDS_HISTORY_SHOWFULLHISTORY_LINK 28654
+#define IDS_HISTORY_TITLE 28655
+#define IDS_HISTORY_UNKNOWN_DEVICE 28656
+#define IDS_LOGIN_DIALOG_TITLE 28657
+#define IDS_LOGIN_DIALOG_AUTHORITY 28658
+#define IDS_LOGIN_DIALOG_PROXY_AUTHORITY 28659
+#define IDS_LOGIN_DIALOG_USERNAME_FIELD 28660
+#define IDS_LOGIN_DIALOG_PASSWORD_FIELD 28661
+#define IDS_LOGIN_DIALOG_OK_BUTTON_LABEL 28662
+#define IDS_DEFAULT_TAB_TITLE 28663
+#define IDS_SAD_TAB_TITLE 28664
+#define IDS_SAD_TAB_MESSAGE 28665
+#define IDS_SAD_TAB_HELP_MESSAGE 28666
+#define IDS_SAD_TAB_HELP_LINK 28667
+#define IDS_SAD_TAB_RELOAD_LABEL 28668
+#define IDS_NEW_TAB_TITLE 28669
+#define IDS_NEW_TAB_OTR_HEADING 28670
+#define IDS_NEW_TAB_OTR_DESCRIPTION 28671
+#define IDS_NEW_TAB_OTR_LEARN_MORE_LINK 28672
+#define IDS_NEW_TAB_OTR_MESSAGE_WARNING 28673
+#define IDS_NEW_TAB_UNDO_THUMBNAIL_REMOVE 28674
+#define IDS_AUTOCOMPLETE_SEARCH_DESCRIPTION 28675
+#define IDS_EMPTY_KEYWORD_VALUE 28676
+#define IDS_LINK_FROM_CLIPBOARD 28677
+#define IDS_SECURE_CONNECTION_EV 28678
+#define IDS_PAGE_INFO_HELP_CENTER_LINK 28680
+#define IDS_PAGE_INFO_SECURITY_TAB_DEPRECATED_SIGNATURE_ALGORITHM_MINOR 28681
+#define IDS_PAGE_INFO_SECURITY_TAB_DEPRECATED_SIGNATURE_ALGORITHM_MAJOR 28682
+#define IDS_PAGE_INFO_SECURITY_TAB_ENCRYPTED_CONNECTION_TEXT 28683
+#define IDS_PAGE_INFO_SECURITY_TAB_ENCRYPTED_INSECURE_CONTENT_ERROR 28684
+#define IDS_PAGE_INFO_SECURITY_TAB_ENCRYPTED_INSECURE_CONTENT_WARNING 28685
+#define IDS_PAGE_INFO_SECURITY_TAB_ENCRYPTED_SENTENCE_LINK 28686
+#define IDS_PAGE_INFO_SECURITY_TAB_ENCRYPTION_DETAILS 28687
+#define IDS_PAGE_INFO_SECURITY_TAB_ENCRYPTION_DETAILS_AEAD 28688
+#define IDS_PAGE_INFO_SECURITY_TAB_FALLBACK_MESSAGE 28689
+#define IDS_PAGE_INFO_SECURITY_TAB_INSECURE_IDENTITY 28690
+#define IDS_PAGE_INFO_SECURITY_TAB_NON_UNIQUE_NAME 28691
+#define IDS_PAGE_INFO_SECURITY_TAB_NOT_ENCRYPTED_CONNECTION_TEXT 28692
+#define IDS_PAGE_INFO_SECURITY_TAB_NO_REVOCATION_MECHANISM 28693
+#define IDS_PAGE_INFO_SECURITY_TAB_RENEGOTIATION_MESSAGE 28694
+#define IDS_PAGE_INFO_SECURITY_TAB_SSL_VERSION 28695
+#define IDS_PAGE_INFO_SECURITY_TAB_UNABLE_TO_CHECK_REVOCATION 28696
+#define IDS_PAGE_INFO_SECURITY_TAB_UNKNOWN_PARTY 28697
+#define IDS_PAGE_INFO_SECURITY_TAB_WEAK_ENCRYPTION_CONNECTION_TEXT 28698
+#define IDS_PAGEINFO_CERT_INFO_BUTTON 28699
+#define IDS_PASSWORD_MANAGER_EMPTY_LOGIN 28700
+#define IDS_PASSWORD_MANAGER_EXCEPTIONS_TAB_TITLE 28701
+#define IDS_PASSWORD_MANAGER_SHOW_PASSWORDS_TAB_TITLE 28702
+#define IDS_PASSWORD_MANAGER_SMART_LOCK 28703
+#define IDS_PDF_NEED_PASSWORD 28704
+#define IDS_PDF_PASSWORD_SUBMIT 28705
+#define IDS_PDF_PASSWORD_INVALID 28706
+#define IDS_PDF_PAGE_LOADING 28707
+#define IDS_PDF_PAGE_LOAD_FAILED 28708
+#define IDS_PDF_PAGE_RELOAD_BUTTON 28709
+#define IDS_PDF_BOOKMARKS 28710
+#define IDS_PDF_TOOLTIP_ROTATE_CW 28711
+#define IDS_PDF_TOOLTIP_DOWNLOAD 28712
+#define IDS_PDF_TOOLTIP_PRINT 28713
+#define IDS_PDF_TOOLTIP_FIT_PAGE 28714
+#define IDS_PDF_TOOLTIP_FIT_WIDTH 28715
+#define IDS_PDF_TOOLTIP_ZOOM_IN 28716
+#define IDS_PDF_TOOLTIP_ZOOM_OUT 28717
+#define IDS_PDF_LABEL_PAGE_NUMBER 28718
+#define IDS_POLICY_DM_STATUS_SUCCESS 28719
+#define IDS_POLICY_DM_STATUS_REQUEST_INVALID 28720
+#define IDS_POLICY_DM_STATUS_REQUEST_FAILED 28721
+#define IDS_POLICY_DM_STATUS_TEMPORARY_UNAVAILABLE 28722
+#define IDS_POLICY_DM_STATUS_HTTP_STATUS_ERROR 28723
+#define IDS_POLICY_DM_STATUS_RESPONSE_DECODING_ERROR 28724
+#define IDS_POLICY_DM_STATUS_SERVICE_MANAGEMENT_NOT_SUPPORTED 28725
+#define IDS_POLICY_DM_STATUS_SERVICE_DEVICE_NOT_FOUND 28726
+#define IDS_POLICY_DM_STATUS_SERVICE_MANAGEMENT_TOKEN_INVALID 28727
+#define IDS_POLICY_DM_STATUS_SERVICE_ACTIVATION_PENDING 28728
+#define IDS_POLICY_DM_STATUS_SERVICE_INVALID_SERIAL_NUMBER 28729
+#define IDS_POLICY_DM_STATUS_SERVICE_DEVICE_ID_CONFLICT 28730
+#define IDS_POLICY_DM_STATUS_SERVICE_MISSING_LICENSES 28731
+#define IDS_POLICY_DM_STATUS_SERVICE_DEPROVISIONED 28732
+#define IDS_POLICY_DM_STATUS_SERVICE_POLICY_NOT_FOUND 28733
+#define IDS_POLICY_DM_STATUS_UNKNOWN_ERROR 28734
+#define IDS_POLICY_DM_STATUS_SERVICE_DOMAIN_MISMATCH 28735
+#define IDS_POLICY_VALIDATION_OK 28736
+#define IDS_POLICY_VALIDATION_BAD_INITIAL_SIGNATURE 28737
+#define IDS_POLICY_VALIDATION_BAD_SIGNATURE 28738
+#define IDS_POLICY_VALIDATION_ERROR_CODE_PRESENT 28739
+#define IDS_POLICY_VALIDATION_PAYLOAD_PARSE_ERROR 28740
+#define IDS_POLICY_VALIDATION_WRONG_POLICY_TYPE 28741
+#define IDS_POLICY_VALIDATION_WRONG_SETTINGS_ENTITY_ID 28742
+#define IDS_POLICY_VALIDATION_BAD_TIMESTAMP 28743
+#define IDS_POLICY_VALIDATION_WRONG_TOKEN 28744
+#define IDS_POLICY_VALIDATION_BAD_USERNAME 28745
+#define IDS_POLICY_VALIDATION_POLICY_PARSE_ERROR 28746
+#define IDS_POLICY_VALIDATION_BAD_KEY_VERIFICATION_SIGNATURE 28747
+#define IDS_POLICY_VALIDATION_UNKNOWN_ERROR 28748
+#define IDS_POLICY_STORE_STATUS_OK 28749
+#define IDS_POLICY_STORE_STATUS_LOAD_ERROR 28750
+#define IDS_POLICY_STORE_STATUS_STORE_ERROR 28751
+#define IDS_POLICY_STORE_STATUS_PARSE_ERROR 28752
+#define IDS_POLICY_STORE_STATUS_SERIALIZE_ERROR 28753
+#define IDS_POLICY_STORE_STATUS_VALIDATION_ERROR 28754
+#define IDS_POLICY_STORE_STATUS_BAD_STATE 28755
+#define IDS_POLICY_STORE_STATUS_UNKNOWN_ERROR 28756
+#define IDS_POLICY_ASSOCIATION_STATE_ACTIVE 28757
+#define IDS_POLICY_ASSOCIATION_STATE_UNMANAGED 28758
+#define IDS_POLICY_ASSOCIATION_STATE_DEPROVISIONED 28759
+#define IDS_POLICY_TYPE_ERROR 28760
+#define IDS_POLICY_OUT_OF_RANGE_ERROR 28761
+#define IDS_POLICY_VALUE_FORMAT_ERROR 28762
+#define IDS_POLICY_DEFAULT_SEARCH_DISABLED 28763
+#define IDS_POLICY_NOT_SPECIFIED_ERROR 28764
+#define IDS_POLICY_SUBKEY_ERROR 28765
+#define IDS_POLICY_LIST_ENTRY_ERROR 28766
+#define IDS_POLICY_SCHEMA_VALIDATION_ERROR 28767
+#define IDS_POLICY_INVALID_SEARCH_URL_ERROR 28768
+#define IDS_POLICY_INVALID_PROXY_MODE_ERROR 28769
+#define IDS_POLICY_INVALID_UPDATE_URL_ERROR 28770
+#define IDS_POLICY_PROXY_MODE_DISABLED_ERROR 28771
+#define IDS_POLICY_PROXY_MODE_AUTO_DETECT_ERROR 28772
+#define IDS_POLICY_PROXY_MODE_PAC_URL_ERROR 28773
+#define IDS_POLICY_PROXY_MODE_FIXED_SERVERS_ERROR 28774
+#define IDS_POLICY_PROXY_MODE_SYSTEM_ERROR 28775
+#define IDS_POLICY_PROXY_BOTH_SPECIFIED_ERROR 28776
+#define IDS_POLICY_PROXY_NEITHER_SPECIFIED_ERROR 28777
+#define IDS_POLICY_OVERRIDDEN 28778
+#define IDS_POLICY_DEPRECATED 28779
+#define IDS_POLICY_VALUE_DEPRECATED 28780
+#define IDS_POLICY_LEVEL_ERROR 28785
+#define IDS_POLICY_OK 28786
+#define IDS_POLICY_UNSET 28787
+#define IDS_POLICY_UNKNOWN 28788
+#define IDS_POLICY_TITLE 28789
+#define IDS_POLICY_FILTER_PLACEHOLDER 28790
+#define IDS_POLICY_RELOAD_POLICIES 28791
+#define IDS_POLICY_STATUS 28792
+#define IDS_POLICY_STATUS_DEVICE 28793
+#define IDS_POLICY_STATUS_USER 28794
+#define IDS_POLICY_LABEL_DOMAIN 28795
+#define IDS_POLICY_LABEL_USERNAME 28796
+#define IDS_POLICY_LABEL_CLIENT_ID 28797
+#define IDS_POLICY_LABEL_ASSET_ID 28798
+#define IDS_POLICY_LABEL_LOCATION 28799
+#define IDS_POLICY_LABEL_DIRECTORY_API_ID 28800
+#define IDS_POLICY_LABEL_TIME_SINCE_LAST_REFRESH 28801
+#define IDS_POLICY_NOT_SPECIFIED 28802
+#define IDS_POLICY_NEVER_FETCHED 28803
+#define IDS_POLICY_LABEL_REFRESH_INTERVAL 28804
+#define IDS_POLICY_LABEL_STATUS 28805
+#define IDS_POLICY_SHOW_UNSET 28806
+#define IDS_POLICY_NO_POLICIES_SET 28807
+#define IDS_POLICY_HEADER_SCOPE 28808
+#define IDS_POLICY_HEADER_LEVEL 28809
+#define IDS_POLICY_HEADER_NAME 28810
+#define IDS_POLICY_HEADER_VALUE 28811
+#define IDS_POLICY_HEADER_STATUS 28812
+#define IDS_POLICY_HEADER_SOURCE 28813
+#define IDS_POLICY_SHOW_EXPANDED_VALUE 28814
+#define IDS_POLICY_HIDE_EXPANDED_VALUE 28815
+#define IDS_POLICY_SCOPE_USER 28816
+#define IDS_POLICY_SCOPE_DEVICE 28817
+#define IDS_POLICY_LEVEL_RECOMMENDED 28818
+#define IDS_POLICY_LEVEL_MANDATORY 28819
+#define IDS_POLICY_INVALID_BOOKMARK 28820
+#define IDS_POLICY_SOURCE_ENTERPRISE_DEFAULT 28821
+#define IDS_POLICY_SOURCE_CLOUD 28822
+#define IDS_POLICY_SOURCE_PLATFORM 28823
+#define IDS_POLICY_SOURCE_PUBLIC_SESSION_OVERRIDE 28824
+#define IDS_POLICY_RISK_TAG_FULL_ADMIN_ACCESS 28825
+#define IDS_POLICY_RISK_TAG_SYSTEM_SECURITY 28826
+#define IDS_POLICY_RISK_TAG_WEBSITE_SHARING 28827
+#define IDS_POLICY_RISK_TAG_ADMIN_SHARING 28828
+#define IDS_POLICY_RISK_TAG_FILTERING 28829
+#define IDS_POLICY_RISK_TAG_LOCAL_DATA_ACCESS 28830
+#define IDS_POLICY_RISK_TAG_GOOGLE_SHARING 28831
+#define IDS_DESKTOP_SEARCH_REDIRECTION_INFOBAR_MESSAGE 28832
+#define IDS_DESKTOP_SEARCH_REDIRECTION_INFOBAR_BUTTON 28833
+#define IDS_SSL_OPEN_DETAILS_BUTTON 28834
+#define IDS_SSL_CLOSE_DETAILS_BUTTON 28835
+#define IDS_CLOCK_ERROR_TITLE 28836
+#define IDS_CLOCK_ERROR_AHEAD_HEADING 28837
+#define IDS_CLOCK_ERROR_BEHIND_HEADING 28838
+#define IDS_CLOCK_ERROR_UPDATE_DATE_AND_TIME 28839
+#define IDS_CLOCK_ERROR_PRIMARY_PARAGRAPH 28840
+#define IDS_CLOCK_ERROR_EXPLANATION 28841
+#define IDS_SAFE_BROWSING_PRIVACY_POLICY_URL 28842
+#define IDS_SSL_V2_TITLE 28843
+#define IDS_SSL_V2_HEADING 28844
+#define IDS_SSL_V2_PRIMARY_PARAGRAPH 28845
+#define IDS_SSL_NONOVERRIDABLE_MORE 28846
+#define IDS_SSL_NONOVERRIDABLE_INVALID 28847
+#define IDS_SSL_OVERRIDABLE_SAFETY_BUTTON 28848
+#define IDS_SSL_OVERRIDABLE_PROCEED_PARAGRAPH 28849
+#define IDS_SSL_RELOAD 28850
+#define IDS_SSL_NONOVERRIDABLE_PINNED 28851
+#define IDS_SSL_NONOVERRIDABLE_HSTS 28852
+#define IDS_SSL_NONOVERRIDABLE_REVOKED 28853
+#define IDS_CERT_ERROR_COMMON_NAME_INVALID_DETAILS 28854
+#define IDS_CERT_ERROR_COMMON_NAME_INVALID_DESCRIPTION 28855
+#define IDS_CERT_ERROR_EXPIRED_DETAILS 28856
+#define IDS_CERT_ERROR_EXPIRED_DESCRIPTION 28857
+#define IDS_CERT_ERROR_NOT_YET_VALID_DETAILS 28858
+#define IDS_CERT_ERROR_NOT_YET_VALID_DESCRIPTION 28859
+#define IDS_CERT_ERROR_NOT_VALID_AT_THIS_TIME_DETAILS 28860
+#define IDS_CERT_ERROR_NOT_VALID_AT_THIS_TIME_DESCRIPTION 28861
+#define IDS_CERT_ERROR_CHAIN_EXPIRED_DETAILS 28862
+#define IDS_CERT_ERROR_CHAIN_EXPIRED_DESCRIPTION 28863
+#define IDS_CERT_ERROR_AUTHORITY_INVALID_DESCRIPTION 28864
+#define IDS_CERT_ERROR_CONTAINS_ERRORS_DETAILS 28865
+#define IDS_CERT_ERROR_CONTAINS_ERRORS_DESCRIPTION 28866
+#define IDS_CERT_ERROR_UNABLE_TO_CHECK_REVOCATION_DETAILS 28867
+#define IDS_CERT_ERROR_UNABLE_TO_CHECK_REVOCATION_DESCRIPTION 28868
+#define IDS_CERT_ERROR_NO_REVOCATION_MECHANISM_DETAILS 28869
+#define IDS_CERT_ERROR_NO_REVOCATION_MECHANISM_DESCRIPTION 28870
+#define IDS_CERT_ERROR_REVOKED_CERT_DETAILS 28871
+#define IDS_CERT_ERROR_REVOKED_CERT_DESCRIPTION 28872
+#define IDS_CERT_ERROR_INVALID_CERT_DETAILS 28873
+#define IDS_CERT_ERROR_INVALID_CERT_DESCRIPTION 28874
+#define IDS_CERT_ERROR_WEAK_SIGNATURE_ALGORITHM_DETAILS 28875
+#define IDS_CERT_ERROR_WEAK_SIGNATURE_ALGORITHM_DESCRIPTION 28876
+#define IDS_CERT_ERROR_WEAK_KEY_DETAILS 28877
+#define IDS_CERT_ERROR_WEAK_KEY_DESCRIPTION 28878
+#define IDS_CERT_ERROR_NAME_CONSTRAINT_VIOLATION_DETAILS 28879
+#define IDS_CERT_ERROR_NAME_CONSTRAINT_VIOLATION_DESCRIPTION 28880
+#define IDS_CERT_ERROR_VALIDITY_TOO_LONG_DETAILS 28881
+#define IDS_CERT_ERROR_VALIDITY_TOO_LONG_DESCRIPTION 28882
+#define IDS_CERT_ERROR_UNKNOWN_ERROR_DETAILS 28883
+#define IDS_CERT_ERROR_UNKNOWN_ERROR_DESCRIPTION 28884
+#define IDS_CERT_ERROR_SUMMARY_PINNING_FAILURE_DETAILS 28885
+#define IDS_CERT_ERROR_SUMMARY_PINNING_FAILURE_DESCRIPTION 28886
+#define IDS_CERT_ERROR_AUTHORITY_INVALID_DETAILS 28887
+#define IDS_BLOCK_INTERSTITIAL_TITLE 28888
+#define IDS_BLOCK_INTERSTITIAL_MESSAGE 28889
+#define IDS_CHILD_BLOCK_INTERSTITIAL_MESSAGE_SINGLE_PARENT 28890
+#define IDS_CHILD_BLOCK_INTERSTITIAL_MESSAGE_MULTI_PARENT 28891
+#define IDS_BLOCK_INTERSTITIAL_MESSAGE_ACCESS_REQUESTS_DISABLED 28892
+#define IDS_BACK_BUTTON 28893
+#define IDS_BLOCK_INTERSTITIAL_REQUEST_ACCESS_BUTTON 28894
+#define IDS_CHILD_BLOCK_INTERSTITIAL_REQUEST_ACCESS_BUTTON 28895
+#define IDS_BLOCK_INTERSTITIAL_REQUEST_SENT_MESSAGE 28896
+#define IDS_BLOCK_INTERSTITIAL_REQUEST_FAILED_MESSAGE 28897
+#define IDS_CHILD_BLOCK_INTERSTITIAL_REQUEST_SENT_MESSAGE_SINGLE_PARENT 28898
+#define IDS_CHILD_BLOCK_INTERSTITIAL_REQUEST_SENT_MESSAGE_MULTI_PARENT 28899
+#define IDS_CHILD_BLOCK_INTERSTITIAL_REQUEST_FAILED_MESSAGE_SINGLE_PARENT 28900
+#define IDS_CHILD_BLOCK_INTERSTITIAL_REQUEST_FAILED_MESSAGE_MULTI_PARENT 28901
+#define IDS_BLOCK_INTERSTITIAL_SEND_FEEDBACK 28902
+#define IDS_BLOCK_INTERSTITIAL_SHOW_DETAILS 28903
+#define IDS_BLOCK_INTERSTITIAL_HIDE_DETAILS 28904
+#define IDS_CHILD_BLOCK_MESSAGE_DEFAULT_SINGLE_PARENT 28905
+#define IDS_CHILD_BLOCK_MESSAGE_DEFAULT_MULTI_PARENT 28906
+#define IDS_SUPERVISED_USER_BLOCK_MESSAGE_DEFAULT 28907
+#define IDS_SUPERVISED_USER_BLOCK_HEADER_DEFAULT 28908
+#define IDS_SUPERVISED_USER_BLOCK_MESSAGE_SAFE_SITES 28909
+#define IDS_SUPERVISED_USER_BLOCK_HEADER_SAFE_SITES 28910
+#define IDS_CHILD_BLOCK_MESSAGE_MANUAL_SINGLE_PARENT 28911
+#define IDS_CHILD_BLOCK_MESSAGE_MANUAL_MULTI_PARENT 28912
+#define IDS_SUPERVISED_USER_BLOCK_MESSAGE_MANUAL 28913
+#define IDS_SUPERVISED_USER_BLOCK_HEADER_MANUAL 28914
+#define IDS_SYNC_BASIC_ENCRYPTION_DATA 28915
+#define IDS_SYNC_CONFIGURE_ENCRYPTION 28916
+#define IDS_SYNC_DATATYPE_AUTOFILL 28917
+#define IDS_SYNC_DATATYPE_BOOKMARKS 28918
+#define IDS_SYNC_DATATYPE_PASSWORDS 28919
+#define IDS_SYNC_DATATYPE_TABS 28920
+#define IDS_SYNC_DATATYPE_TYPED_URLS 28921
+#define IDS_SYNC_EMPTY_PASSPHRASE_ERROR 28922
+#define IDS_SYNC_ENCRYPTION_SECTION_TITLE 28923
+#define IDS_SYNC_ENTER_GOOGLE_PASSPHRASE_BODY 28924
+#define IDS_SYNC_FULL_ENCRYPTION_DATA 28925
+#define IDS_SYNC_LOGIN_INFO_OUT_OF_DATE 28926
+#define IDS_SYNC_LOGIN_SETTING_UP 28927
+#define IDS_SYNC_PASSPHRASE_LABEL 28928
+#define IDS_SYNC_PASSPHRASE_MISMATCH_ERROR 28929
+#define IDS_SYNC_SERVICE_UNAVAILABLE 28930
+#define IDS_SYNC_ENTER_PASSPHRASE_BODY_WITH_DATE 28931
+#define IDS_SYNC_ENTER_PASSPHRASE_BODY 28932
+#define IDS_TRANSLATE_INFOBAR_OPTIONS 28933
+#define IDS_TRANSLATE_INFOBAR_OPTIONS_NEVER_TRANSLATE_LANG 28934
+#define IDS_TRANSLATE_INFOBAR_OPTIONS_NEVER_TRANSLATE_SITE 28935
+#define IDS_TRANSLATE_INFOBAR_OPTIONS_ALWAYS 28936
+#define IDS_TRANSLATE_INFOBAR_OPTIONS_REPORT_ERROR 28937
+#define IDS_TRANSLATE_INFOBAR_OPTIONS_ABOUT 28938
+#define IDS_TRANSLATE_INFOBAR_BEFORE_MESSAGE 28939
+#define IDS_TRANSLATE_INFOBAR_ACCEPT 28942
+#define IDS_TRANSLATE_INFOBAR_DENY 28943
+#define IDS_TRANSLATE_INFOBAR_NEVER_TRANSLATE 28944
+#define IDS_TRANSLATE_INFOBAR_ALWAYS_TRANSLATE 28945
+#define IDS_TRANSLATE_INFOBAR_TRANSLATING_TO 28946
+#define IDS_TRANSLATE_INFOBAR_AFTER_MESSAGE 28947
+#define IDS_TRANSLATE_INFOBAR_AFTER_MESSAGE_AUTODETERMINED_SOURCE_LANGUAGE 28948
+#define IDS_TRANSLATE_INFOBAR_REVERT 28950
+#define IDS_TRANSLATE_INFOBAR_RETRY 28951
+#define IDS_TRANSLATE_INFOBAR_ERROR_CANT_CONNECT 28952
+#define IDS_TRANSLATE_INFOBAR_ERROR_CANT_TRANSLATE 28953
+#define IDS_TRANSLATE_INFOBAR_UNKNOWN_PAGE_LANGUAGE 28954
+#define IDS_TRANSLATE_INFOBAR_ERROR_SAME_LANGUAGE 28955
+#define IDS_TRANSLATE_INFOBAR_UNSUPPORTED_PAGE_LANGUAGE 28956
+#define IDS_BOOKMARK_BAR_UNDO 28958
+#define IDS_BOOKMARK_BAR_REDO 28959
+#define IDS_BOOKMARK_BAR_UNDO_ADD 28960
+#define IDS_BOOKMARK_BAR_REDO_ADD 28961
+#define IDS_BOOKMARK_BAR_UNDO_DELETE 28962
+#define IDS_BOOKMARK_BAR_REDO_DELETE 28963
+#define IDS_BOOKMARK_BAR_UNDO_EDIT 28964
+#define IDS_BOOKMARK_BAR_REDO_EDIT 28965
+#define IDS_BOOKMARK_BAR_UNDO_MOVE 28966
+#define IDS_BOOKMARK_BAR_REDO_MOVE 28967
+#define IDS_BOOKMARK_BAR_UNDO_REORDER 28968
+#define IDS_BOOKMARK_BAR_REDO_REORDER 28969
+#define IDS_VERSION_UI_TITLE 28970
+#define IDS_VERSION_UI_OFFICIAL 28971
+#define IDS_VERSION_UI_UNOFFICIAL 28972
+#define IDS_VERSION_UI_32BIT 28973
+#define IDS_VERSION_UI_64BIT 28974
+#define IDS_VERSION_UI_REVISION 28975
+#define IDS_VERSION_UI_OS 28976
+#define IDS_VERSION_UI_USER_AGENT 28977
+#define IDS_VERSION_UI_COMMAND_LINE 28978
+#define IDS_VERSION_UI_EXECUTABLE_PATH 28980
+#define IDS_VERSION_UI_PROFILE_PATH 28981
+#define IDS_VERSION_UI_PATH_NOTFOUND 28982
+#define IDS_VERSION_UI_VARIATIONS 28983
+#define IDS_CANCEL 28985
+#define IDS_CLOSE 28986
+#define IDS_DONE 28987
+#define IDS_LEARN_MORE 28988
+#define IDS_OK 28989
+#define IDS_PLUGIN_NOT_SUPPORTED 28990
+#define IDS_PRINT 28991
+#define IDS_RECENTLY_CLOSED 28992
+#define IDS_ACCNAME_BACK 28993
+#define IDS_ACCNAME_FORWARD 28994
+#define IDS_ACCNAME_CLOSE 28995
+#define IDS_ACCNAME_LOCATION 28996
+#define IDS_UTILITY_PROCESS_JSON_PARSER_NAME 28997
+#define IDS_SESSION_CRASHED_VIEW_RESTORE_BUTTON 28998
+#define IDS_WEBSITE_SETTINGS_NON_SECURE_TRANSPORT 28999
+#define IDS_OPTIONS_ADVANCED_SECTION_TITLE_PRIVACY 29000
+
+// ---------------------------------------------------------------------------
+// From content_strings.h:
+
+#define IDS_DETAILS_WITHOUT_SUMMARY_LABEL 18900
+#define IDS_DOWNLOAD_BUTTON_LABEL 18901
+#define IDS_SEARCHABLE_INDEX_INTRO 18902
+#define IDS_FORM_CALENDAR_CLEAR 18903
+#define IDS_FORM_CALENDAR_TODAY 18904
+#define IDS_FORM_DATE_FORMAT_DAY_IN_MONTH 18905
+#define IDS_FORM_DATE_FORMAT_MONTH 18906
+#define IDS_FORM_DATE_FORMAT_YEAR 18907
+#define IDS_FORM_SUBMIT_LABEL 18908
+#define IDS_FORM_INPUT_ALT 18909
+#define IDS_FORM_RESET_LABEL 18910
+#define IDS_FORM_FILE_BUTTON_LABEL 18911
+#define IDS_FORM_MULTIPLE_FILES_BUTTON_LABEL 18912
+#define IDS_FORM_FILE_NO_FILE_LABEL 18913
+#define IDS_FORM_FILE_MULTIPLE_UPLOAD 18914
+#define IDS_FORM_OTHER_COLOR_LABEL 18915
+#define IDS_FORM_OTHER_DATE_LABEL 18916
+#define IDS_FORM_OTHER_MONTH_LABEL 18917
+#define IDS_FORM_OTHER_TIME_LABEL 18918
+#define IDS_FORM_OTHER_WEEK_LABEL 18919
+#define IDS_FORM_PLACEHOLDER_FOR_DAY_OF_MONTH_FIELD 18920
+#define IDS_FORM_PLACEHOLDER_FOR_MONTH_FIELD 18921
+#define IDS_FORM_PLACEHOLDER_FOR_YEAR_FIELD 18922
+#define IDS_FORM_SELECT_MENU_LIST_TEXT 18923
+#define IDS_FORM_THIS_MONTH_LABEL 18924
+#define IDS_FORM_THIS_WEEK_LABEL 18925
+#define IDS_FORM_WEEK_NUMBER_LABEL 18926
+#define IDS_RECENT_SEARCHES_NONE 18927
+#define IDS_RECENT_SEARCHES 18928
+#define IDS_RECENT_SEARCHES_CLEAR 18929
+#define IDS_AX_CALENDAR_SHOW_MONTH_SELECTOR 18930
+#define IDS_AX_CALENDAR_SHOW_NEXT_MONTH 18931
+#define IDS_AX_CALENDAR_SHOW_PREVIOUS_MONTH 18932
+#define IDS_AX_CALENDAR_WEEK_DESCRIPTION 18933
+#define IDS_AX_ROLE_ARTICLE 18934
+#define IDS_AX_ROLE_BANNER 18935
+#define IDS_AX_ROLE_COMPLEMENTARY 18936
+#define IDS_AX_ROLE_CHECK_BOX 18937
+#define IDS_AX_ROLE_CONTENT_INFO 18938
+#define IDS_AX_ROLE_DEFINITION 18939
+#define IDS_AX_ROLE_DESCRIPTION_LIST 18940
+#define IDS_AX_ROLE_DESCRIPTION_TERM 18941
+#define IDS_AX_ROLE_FIGURE 18942
+#define IDS_AX_ROLE_FORM 18943
+#define IDS_AX_ROLE_FOOTER 18944
+#define IDS_AX_ROLE_TOGGLE_BUTTON 18946
+#define IDS_AX_ROLE_HEADING 18947
+#define IDS_AX_ROLE_IMAGE_MAP 18948
+#define IDS_AX_ROLE_LINK 18949
+#define IDS_AX_ROLE_LIST_MARKER 18950
+#define IDS_AX_ROLE_MAIN_CONTENT 18951
+#define IDS_AX_ROLE_MARK 18952
+#define IDS_AX_ROLE_MATH 18953
+#define IDS_AX_ROLE_NAVIGATIONAL_LINK 18954
+#define IDS_AX_ROLE_REGION 18955
+#define IDS_AX_ROLE_SEARCH_BOX 18956
+#define IDS_AX_ROLE_STATUS 18957
+#define IDS_AX_ROLE_SWITCH 18958
+#define IDS_AX_ROLE_WEB_AREA 18959
+#define IDS_AX_BUTTON_ACTION_VERB 19013
+#define IDS_AX_RADIO_BUTTON_ACTION_VERB 19014
+#define IDS_AX_TEXT_FIELD_ACTION_VERB 19015
+#define IDS_AX_CHECKED_CHECK_BOX_ACTION_VERB 19016
+#define IDS_AX_UNCHECKED_CHECK_BOX_ACTION_VERB 19017
+#define IDS_AX_LINK_ACTION_VERB 19018
+#define IDS_AX_POP_UP_BUTTON_ACTION_VERB 19019
+#define IDS_AX_DEFAULT_ACTION_VERB 19020
+#define IDS_AX_AM_PM_FIELD_TEXT 19021
+#define IDS_AX_DAY_OF_MONTH_FIELD_TEXT 19022
+#define IDS_AX_DATE_TIME_FIELD_EMPTY_VALUE_TEXT 19023
+#define IDS_AX_HOUR_FIELD_TEXT 19024
+#define IDS_AX_MEDIA_DEFAULT 19025
+#define IDS_AX_MEDIA_AUDIO_ELEMENT 19026
+#define IDS_AX_MEDIA_VIDEO_ELEMENT 19027
+#define IDS_AX_MEDIA_MUTE_BUTTON 19028
+#define IDS_AX_MEDIA_UNMUTE_BUTTON 19029
+#define IDS_AX_MEDIA_PLAY_BUTTON 19030
+#define IDS_AX_MEDIA_PAUSE_BUTTON 19031
+#define IDS_AX_MEDIA_SLIDER 19032
+#define IDS_AX_MEDIA_SLIDER_THUMB 19033
+#define IDS_AX_MEDIA_CURRENT_TIME_DISPLAY 19034
+#define IDS_AX_MEDIA_TIME_REMAINING_DISPLAY 19035
+#define IDS_AX_MEDIA_STATUS_DISPLAY 19036
+#define IDS_AX_MEDIA_ENTER_FULL_SCREEN_BUTTON 19037
+#define IDS_AX_MEDIA_EXIT_FULL_SCREEN_BUTTON 19038
+#define IDS_AX_MEDIA_SHOW_CLOSED_CAPTIONS_BUTTON 19039
+#define IDS_AX_MEDIA_HIDE_CLOSED_CAPTIONS_BUTTON 19040
+#define IDS_AX_MEDIA_CAST_OFF_BUTTON 19041
+#define IDS_AX_MEDIA_CAST_ON_BUTTON 19042
+#define IDS_AX_MEDIA_AUDIO_ELEMENT_HELP 19043
+#define IDS_AX_MEDIA_VIDEO_ELEMENT_HELP 19044
+#define IDS_AX_MEDIA_MUTE_BUTTON_HELP 19045
+#define IDS_AX_MEDIA_UNMUTE_BUTTON_HELP 19046
+#define IDS_AX_MEDIA_PLAY_BUTTON_HELP 19047
+#define IDS_AX_MEDIA_PAUSE_BUTTON_HELP 19048
+#define IDS_AX_MEDIA_AUDIO_SLIDER_HELP 19049
+#define IDS_AX_MEDIA_VIDEO_SLIDER_HELP 19050
+#define IDS_AX_MEDIA_SLIDER_THUMB_HELP 19051
+#define IDS_AX_MEDIA_CURRENT_TIME_DISPLAY_HELP 19052
+#define IDS_AX_MEDIA_TIME_REMAINING_DISPLAY_HELP 19053
+#define IDS_AX_MEDIA_STATUS_DISPLAY_HELP 19054
+#define IDS_AX_MEDIA_ENTER_FULL_SCREEN_BUTTON_HELP 19055
+#define IDS_AX_MEDIA_EXIT_FULL_SCREEN_BUTTON_HELP 19056
+#define IDS_AX_MEDIA_SHOW_CLOSED_CAPTIONS_BUTTON_HELP 19057
+#define IDS_AX_MEDIA_HIDE_CLOSED_CAPTIONS_BUTTON_HELP 19058
+#define IDS_AX_MEDIA_CAST_OFF_BUTTON_HELP 19059
+#define IDS_AX_MEDIA_CAST_ON_BUTTON_HELP 19060
+#define IDS_AX_MILLISECOND_FIELD_TEXT 19061
+#define IDS_AX_MINUTE_FIELD_TEXT 19062
+#define IDS_AX_MONTH_FIELD_TEXT 19063
+#define IDS_AX_SECOND_FIELD_TEXT 19064
+#define IDS_AX_WEEK_OF_YEAR_FIELD_TEXT 19065
+#define IDS_AX_YEAR_FIELD_TEXT 19066
+#define IDS_KEYGEN_HIGH_GRADE_KEY 19067
+#define IDS_KEYGEN_MED_GRADE_KEY 19068
+#define IDS_FORM_INPUT_WEEK_TEMPLATE 19069
+#define IDS_FORM_VALIDATION_VALUE_MISSING_MULTIPLE_FILE 19070
+#define IDS_FORM_VALIDATION_TYPE_MISMATCH 19071
+#define IDS_FORM_VALIDATION_TYPE_MISMATCH_EMAIL_EMPTY 19072
+#define IDS_FORM_VALIDATION_TYPE_MISMATCH_EMAIL_EMPTY_DOMAIN 19073
+#define IDS_FORM_VALIDATION_TYPE_MISMATCH_EMAIL_EMPTY_LOCAL 19074
+#define IDS_FORM_VALIDATION_TYPE_MISMATCH_EMAIL_INVALID_DOMAIN 19075
+#define IDS_FORM_VALIDATION_TYPE_MISMATCH_EMAIL_INVALID_DOTS 19076
+#define IDS_FORM_VALIDATION_TYPE_MISMATCH_EMAIL_INVALID_LOCAL 19077
+#define IDS_FORM_VALIDATION_TYPE_MISMATCH_EMAIL_NO_AT_SIGN 19078
+#define IDS_FORM_VALIDATION_TYPE_MISMATCH_MULTIPLE_EMAIL 19079
+#define IDS_FORM_VALIDATION_RANGE_UNDERFLOW 19080
+#define IDS_FORM_VALIDATION_RANGE_UNDERFLOW_DATETIME 19081
+#define IDS_FORM_VALIDATION_RANGE_OVERFLOW 19082
+#define IDS_FORM_VALIDATION_RANGE_OVERFLOW_DATETIME 19083
+#define IDS_FORM_VALIDATION_BAD_INPUT_DATETIME 19084
+#define IDS_FORM_VALIDATION_BAD_INPUT_NUMBER 19085
+#define IDS_FORM_VALIDATION_VALUE_MISSING 19086
+#define IDS_FORM_VALIDATION_VALUE_MISSING_CHECKBOX 19087
+#define IDS_FORM_VALIDATION_VALUE_MISSING_FILE 19088
+#define IDS_FORM_VALIDATION_VALUE_MISSING_RADIO 19089
+#define IDS_FORM_VALIDATION_VALUE_MISSING_SELECT 19090
+#define IDS_FORM_VALIDATION_TYPE_MISMATCH_EMAIL 19091
+#define IDS_FORM_VALIDATION_TYPE_MISMATCH_URL 19092
+#define IDS_FORM_VALIDATION_PATTERN_MISMATCH 19093
+#define IDS_FORM_VALIDATION_STEP_MISMATCH 19094
+#define IDS_FORM_VALIDATION_STEP_MISMATCH_CLOSE_TO_LIMIT 19095
+#define IDS_FORM_VALIDATION_TOO_LONG 19096
+#define IDS_FORM_VALIDATION_TOO_SHORT 19097
+#define IDS_PLUGIN_INITIALIZATION_ERROR 19098
+
+// ---------------------------------------------------------------------------
+// From extensions_strings.h:
+
+#define IDS_EXTENSION_CONTAINS_PRIVATE_KEY 25950
+#define IDS_EXTENSION_LOAD_ABOUT_PAGE_FAILED 25951
+#define IDS_EXTENSION_LOAD_BACKGROUND_SCRIPT_FAILED 25952
+#define IDS_EXTENSION_LOAD_BACKGROUND_PAGE_FAILED 25953
+#define IDS_EXTENSION_LOAD_ICON_FAILED 25954
+#define IDS_EXTENSION_LOAD_LAUNCHER_PAGE_FAILED 25955
+#define IDS_EXTENSION_LOAD_OPTIONS_PAGE_FAILED 25956
+#define IDS_EXTENSION_LOCALES_NO_DEFAULT_LOCALE_SPECIFIED 25957
+#define IDS_EXTENSION_MANIFEST_UNREADABLE 25958
+#define IDS_EXTENSION_MANIFEST_INVALID 25959
+#define IDS_EXTENSION_PACKAGE_DIRECTORY_ERROR 25960
+#define IDS_EXTENSION_PACKAGE_IMAGE_PATH_ERROR 25961
+#define IDS_EXTENSION_PACKAGE_IMAGE_ERROR 25962
+#define IDS_EXTENSION_PACKAGE_UNZIP_ERROR 25963
+#define IDS_LOAD_STATE_PARAMETER_EXTENSION 25964
+#define IDS_EXTENSION_CANT_INSTALL_POLICY_BLOCKED 25965
+#define IDS_EXTENSION_CANT_MODIFY_POLICY_REQUIRED 25966
+#define IDS_EXTENSION_CANT_UNINSTALL_POLICY_REQUIRED 25967
+#define IDS_EXTENSION_DISABLED_UPDATE_REQUIRED_BY_POLICY 25968
+#define IDS_DEVICE_NAME_WITH_PRODUCT_SERIAL 25969
+#define IDS_DEVICE_NAME_WITH_PRODUCT_UNKNOWN_VENDOR 25970
+#define IDS_DEVICE_NAME_WITH_PRODUCT_UNKNOWN_VENDOR_SERIAL 25971
+#define IDS_DEVICE_NAME_WITH_PRODUCT_VENDOR 25972
+#define IDS_DEVICE_NAME_WITH_PRODUCT_VENDOR_SERIAL 25973
+#define IDS_DEVICE_NAME_WITH_UNKNOWN_PRODUCT_UNKNOWN_VENDOR 25974
+#define IDS_DEVICE_NAME_WITH_UNKNOWN_PRODUCT_UNKNOWN_VENDOR_SERIAL 25975
+#define IDS_DEVICE_NAME_WITH_UNKNOWN_PRODUCT_VENDOR 25976
+#define IDS_DEVICE_NAME_WITH_UNKNOWN_PRODUCT_VENDOR_SERIAL 25977
+#define IDS_DEVICE_PERMISSIONS_PROMPT 25978
+#define IDS_EXTENSION_USB_DEVICE_PRODUCT_NAME_AND_VENDOR 25979
+#define IDS_HID_DEVICE_PERMISSIONS_PROMPT_TITLE 25980
+#define IDS_USB_DEVICE_PERMISSIONS_PROMPT_TITLE 25981
+#define IDS_EXTENSION_TASK_MANAGER_APPVIEW_TAG_PREFIX 25982
+#define IDS_EXTENSION_TASK_MANAGER_EXTENSIONOPTIONS_TAG_PREFIX 25983
+#define IDS_EXTENSION_TASK_MANAGER_EXTENSIONVIEW_TAG_PREFIX 25984
+#define IDS_EXTENSION_TASK_MANAGER_MIMEHANDLERVIEW_TAG_PREFIX 25985
+#define IDS_EXTENSION_TASK_MANAGER_WEBVIEW_TAG_PREFIX 25986
+#define IDS_EXTENSION_WARNINGS_NETWORK_DELAY 25987
+#define IDS_EXTENSION_WARNINGS_NETWORK_CONFLICT 25988
+#define IDS_EXTENSION_WARNINGS_REDIRECT_CONFLICT 25989
+#define IDS_EXTENSION_WARNINGS_REQUEST_HEADER_CONFLICT 25990
+#define IDS_EXTENSION_WARNINGS_RESPONSE_HEADER_CONFLICT 25991
+#define IDS_EXTENSION_WARNINGS_CREDENTIALS_CONFLICT 25992
+#define IDS_EXTENSION_WARNINGS_DOWNLOAD_FILENAME_CONFLICT 25993
+#define IDS_EXTENSION_WARNING_RELOAD_TOO_FREQUENT 25994
+#define IDS_EXTENSION_INSTALL_PROCESS_CRASHED 25995
+#define IDS_EXTENSION_PACKAGE_ERROR_CODE 25996
+#define IDS_EXTENSION_PACKAGE_ERROR_MESSAGE 25997
+#define IDS_EXTENSION_PACKAGE_INSTALL_ERROR 25998
+#define IDS_EXTENSION_UNPACK_FAILED 25999
+#define IDS_UTILITY_PROCESS_EXTENSION_UNPACKER_NAME 26000
+#define IDS_UTILITY_PROCESS_MANIFEST_PARSER_NAME 26001
+
+// ---------------------------------------------------------------------------
+// From platform_locale_settings.h:
+
+#define IDS_STANDARD_FONT_FAMILY 10500
+#define IDS_FIXED_FONT_FAMILY 10501
+#define IDS_FIXED_FONT_FAMILY_ALT_WIN 10502
+#define IDS_SERIF_FONT_FAMILY 10503
+#define IDS_SANS_SERIF_FONT_FAMILY 10504
+#define IDS_CURSIVE_FONT_FAMILY 10505
+#define IDS_FANTASY_FONT_FAMILY 10506
+#define IDS_PICTOGRAPH_FONT_FAMILY 10507
+#define IDS_STANDARD_FONT_FAMILY_CYRILLIC 10508
+#define IDS_FIXED_FONT_FAMILY_ARABIC 10509
+#define IDS_FIXED_FONT_FAMILY_CYRILLIC 10510
+#define IDS_SANS_SERIF_FONT_FAMILY_ARABIC 10511
+#define IDS_SERIF_FONT_FAMILY_CYRILLIC 10512
+#define IDS_SANS_SERIF_FONT_FAMILY_CYRILLIC 10513
+#define IDS_STANDARD_FONT_FAMILY_GREEK 10514
+#define IDS_FIXED_FONT_FAMILY_GREEK 10515
+#define IDS_SERIF_FONT_FAMILY_GREEK 10516
+#define IDS_SANS_SERIF_FONT_FAMILY_GREEK 10517
+#define IDS_STANDARD_FONT_FAMILY_JAPANESE 10518
+#define IDS_STANDARD_FONT_FAMILY_JAPANESE_ALT_WIN 10519
+#define IDS_FIXED_FONT_FAMILY_JAPANESE 10520
+#define IDS_SERIF_FONT_FAMILY_JAPANESE 10521
+#define IDS_SANS_SERIF_FONT_FAMILY_JAPANESE 10522
+#define IDS_SANS_SERIF_FONT_FAMILY_JAPANESE_ALT_WIN 10523
+#define IDS_STANDARD_FONT_FAMILY_KOREAN 10524
+#define IDS_FIXED_FONT_FAMILY_KOREAN 10525
+#define IDS_SERIF_FONT_FAMILY_KOREAN 10526
+#define IDS_SANS_SERIF_FONT_FAMILY_KOREAN 10527
+#define IDS_CURSIVE_FONT_FAMILY_KOREAN 10528
+#define IDS_STANDARD_FONT_FAMILY_SIMPLIFIED_HAN 10529
+#define IDS_FIXED_FONT_FAMILY_SIMPLIFIED_HAN 10530
+#define IDS_SERIF_FONT_FAMILY_SIMPLIFIED_HAN 10531
+#define IDS_SANS_SERIF_FONT_FAMILY_SIMPLIFIED_HAN 10532
+#define IDS_STANDARD_FONT_FAMILY_TRADITIONAL_HAN 10533
+#define IDS_FIXED_FONT_FAMILY_TRADITIONAL_HAN 10534
+#define IDS_SERIF_FONT_FAMILY_TRADITIONAL_HAN 10535
+#define IDS_SANS_SERIF_FONT_FAMILY_TRADITIONAL_HAN 10536
+#define IDS_DEFAULT_FONT_SIZE 10537
+#define IDS_DEFAULT_FIXED_FONT_SIZE 10538
+#define IDS_MINIMUM_FONT_SIZE 10539
+#define IDS_MINIMUM_LOGICAL_FONT_SIZE 10540
+
+// ---------------------------------------------------------------------------
+// From ui_strings.h:
+
+#define IDS_TIME_SECS 11000
+#define IDS_TIME_LONG_SECS 11001
+#define IDS_TIME_LONG_SECS_2ND 11002
+#define IDS_TIME_MINS 11003
+#define IDS_TIME_LONG_MINS 11004
+#define IDS_TIME_LONG_MINS_1ST 11005
+#define IDS_TIME_LONG_MINS_2ND 11006
+#define IDS_TIME_HOURS 11007
+#define IDS_TIME_HOURS_1ST 11008
+#define IDS_TIME_HOURS_2ND 11009
+#define IDS_TIME_DAYS 11010
+#define IDS_TIME_DAYS_1ST 11011
+#define IDS_TIME_REMAINING_SECS 11012
+#define IDS_TIME_REMAINING_LONG_SECS 11013
+#define IDS_TIME_REMAINING_MINS 11014
+#define IDS_TIME_REMAINING_LONG_MINS 11015
+#define IDS_TIME_REMAINING_HOURS 11016
+#define IDS_TIME_REMAINING_DAYS 11017
+#define IDS_TIME_ELAPSED_SECS 11018
+#define IDS_TIME_ELAPSED_MINS 11019
+#define IDS_TIME_ELAPSED_HOURS 11020
+#define IDS_TIME_ELAPSED_DAYS 11021
+#define IDS_PAST_TIME_TODAY 11022
+#define IDS_PAST_TIME_YESTERDAY 11023
+#define IDS_APP_MENU_EMPTY_SUBMENU 11024
+#define IDS_APP_UNTITLED_SHORTCUT_FILE_NAME 11025
+#define IDS_APP_SAVEAS_ALL_FILES 11026
+#define IDS_APP_SAVEAS_EXTENSION_FORMAT 11027
+#define IDS_SELECT_UPLOAD_FOLDER_DIALOG_TITLE 11028
+#define IDS_SELECT_FOLDER_DIALOG_TITLE 11031
+#define IDS_SAVE_AS_DIALOG_TITLE 11032
+#define IDS_OPEN_FILE_DIALOG_TITLE 11033
+#define IDS_OPEN_FILES_DIALOG_TITLE 11034
+#define IDS_SAVEAS_ALL_FILES 11035
+#define IDS_SELECT_UPLOAD_FOLDER_DIALOG_UPLOAD_BUTTON 11036
+#define IDS_APP_ACCACTION_PRESS 11037
+#define IDS_APP_ACCNAME_CLOSE 11038
+#define IDS_APP_ACCNAME_MINIMIZE 11039
+#define IDS_APP_ACCNAME_MAXIMIZE 11040
+#define IDS_APP_ACCNAME_RESTORE 11041
+#define IDS_APP_SCROLLBAR_CXMENU_SCROLLHERE 11042
+#define IDS_APP_SCROLLBAR_CXMENU_SCROLLLEFTEDGE 11043
+#define IDS_APP_SCROLLBAR_CXMENU_SCROLLRIGHTEDGE 11044
+#define IDS_APP_SCROLLBAR_CXMENU_SCROLLHOME 11045
+#define IDS_APP_SCROLLBAR_CXMENU_SCROLLEND 11046
+#define IDS_APP_SCROLLBAR_CXMENU_SCROLLPAGEUP 11047
+#define IDS_APP_SCROLLBAR_CXMENU_SCROLLPAGEDOWN 11048
+#define IDS_APP_SCROLLBAR_CXMENU_SCROLLLEFT 11049
+#define IDS_APP_SCROLLBAR_CXMENU_SCROLLRIGHT 11050
+#define IDS_APP_SCROLLBAR_CXMENU_SCROLLUP 11051
+#define IDS_APP_SCROLLBAR_CXMENU_SCROLLDOWN 11052
+#define IDS_APP_UNDO 11053
+#define IDS_APP_CUT 11054
+#define IDS_APP_COPY 11055
+#define IDS_APP_PASTE 11056
+#define IDS_APP_DELETE 11057
+#define IDS_APP_SELECT_ALL 11058
+#define IDS_DELETE_BACKWARD 11059
+#define IDS_DELETE_FORWARD 11060
+#define IDS_DELETE_TO_BEGINNING_OF_LINE 11061
+#define IDS_DELETE_TO_END_OF_LINE 11062
+#define IDS_DELETE_WORD_BACKWARD 11063
+#define IDS_DELETE_WORD_FORWARD 11064
+#define IDS_MOVE_DOWN 11065
+#define IDS_MOVE_LEFT 11066
+#define IDS_MOVE_LEFT_AND_MODIFY_SELECTION 11067
+#define IDS_MOVE_RIGHT 11068
+#define IDS_MOVE_RIGHT_AND_MODIFY_SELECTION 11069
+#define IDS_MOVE_WORD_LEFT 11070
+#define IDS_MOVE_WORD_LEFT_AND_MODIFY_SELECTION 11071
+#define IDS_MOVE_WORD_RIGHT 11072
+#define IDS_MOVE_WORD_RIGHT_AND_MODIFY_SELECTION 11073
+#define IDS_MOVE_TO_BEGINNING_OF_LINE 11074
+#define IDS_MOVE_TO_BEGINNING_OF_LINE_AND_MODIFY_SELECTION 11075
+#define IDS_MOVE_TO_END_OF_LINE 11076
+#define IDS_MOVE_TO_END_OF_LINE_AND_MODIFY_SELECTION 11077
+#define IDS_MOVE_UP 11078
+#define IDS_APP_REDO 11079
+#define IDS_APP_OK 11080
+#define IDS_APP_CANCEL 11081
+#define IDS_APP_CLOSE 11082
+#define IDS_APP_ESC_KEY 11083
+#define IDS_APP_TAB_KEY 11084
+#define IDS_APP_INSERT_KEY 11085
+#define IDS_APP_HOME_KEY 11086
+#define IDS_APP_DELETE_KEY 11087
+#define IDS_APP_END_KEY 11088
+#define IDS_APP_PAGEUP_KEY 11089
+#define IDS_APP_PAGEDOWN_KEY 11090
+#define IDS_APP_LEFT_ARROW_KEY 11091
+#define IDS_APP_RIGHT_ARROW_KEY 11092
+#define IDS_APP_UP_ARROW_KEY 11093
+#define IDS_APP_DOWN_ARROW_KEY 11094
+#define IDS_APP_ENTER_KEY 11095
+#define IDS_APP_SPACE_KEY 11096
+#define IDS_APP_F1_KEY 11097
+#define IDS_APP_F11_KEY 11098
+#define IDS_APP_BACKSPACE_KEY 11099
+#define IDS_APP_COMMA_KEY 11100
+#define IDS_APP_PERIOD_KEY 11101
+#define IDS_APP_MEDIA_NEXT_TRACK_KEY 11102
+#define IDS_APP_MEDIA_PLAY_PAUSE_KEY 11103
+#define IDS_APP_MEDIA_PREV_TRACK_KEY 11104
+#define IDS_APP_MEDIA_STOP_KEY 11105
+#define IDS_APP_CONTROL_MODIFIER 11106
+#define IDS_APP_ALT_MODIFIER 11107
+#define IDS_APP_SHIFT_MODIFIER 11108
+#define IDS_APP_COMMAND_MODIFIER 11109
+#define IDS_APP_SEARCH_MODIFIER 11110
+#define IDS_APP_BYTES 11111
+#define IDS_APP_KIBIBYTES 11112
+#define IDS_APP_MEBIBYTES 11113
+#define IDS_APP_GIBIBYTES 11114
+#define IDS_APP_TEBIBYTES 11115
+#define IDS_APP_PEBIBYTES 11116
+#define IDS_APP_BYTES_PER_SECOND 11117
+#define IDS_APP_KIBIBYTES_PER_SECOND 11118
+#define IDS_APP_MEBIBYTES_PER_SECOND 11119
+#define IDS_APP_GIBIBYTES_PER_SECOND 11120
+#define IDS_APP_TEBIBYTES_PER_SECOND 11121
+#define IDS_APP_PEBIBYTES_PER_SECOND 11122
+#define IDS_MESSAGE_CENTER_ACCESSIBLE_NAME 11123
+#define IDS_MESSAGE_CENTER_NOTIFIER_DISABLE 11124
+#define IDS_MESSAGE_CENTER_FOOTER_TITLE 11125
+#define IDS_MESSAGE_CENTER_SETTINGS_BUTTON_LABEL 11126
+#define IDS_MESSAGE_CENTER_SETTINGS_DIALOG_DESCRIPTION 11128
+#define IDS_MESSAGE_CENTER_SETTINGS_DESCRIPTION_MULTIUSER 11129
+#define IDS_MESSAGE_CENTER_SETTINGS 11130
+#define IDS_MESSAGE_CENTER_CLEAR_ALL 11131
+#define IDS_MESSAGE_CENTER_QUIET_MODE_BUTTON_TOOLTIP 11132
+#define IDS_MESSAGE_CENTER_NO_MESSAGES 11133
+#define IDS_MESSAGE_CENTER_QUIET_MODE 11134
+#define IDS_MESSAGE_CENTER_QUIET_MODE_1HOUR 11135
+#define IDS_MESSAGE_CENTER_QUIET_MODE_1DAY 11136
+#define IDS_MESSAGE_CENTER_CLOSE_NOTIFICATION_BUTTON_ACCESSIBLE_NAME 11137
+#define IDS_MESSAGE_NOTIFICATION_SETTINGS_BUTTON_ACCESSIBLE_NAME 11138
+#define IDS_APP_LIST_HELP 11141
+#define IDS_APP_LIST_OPEN_SETTINGS 11142
+#define IDS_APP_LIST_OPEN_FEEDBACK 11143
+#define IDS_APP_LIST_BACK 11144
+#define IDS_APP_LIST_ALL_APPS 11145
+#define IDS_APP_LIST_FOLDER_NAME_PLACEHOLDER 11146
+#define IDS_APP_LIST_FOLDER_BUTTON_ACCESSIBILE_NAME 11147
+#define IDS_APP_LIST_FOLDER_OPEN_FOLDER_ACCESSIBILE_NAME 11148
+#define IDS_APP_LIST_FOLDER_CLOSE_FOLDER_ACCESSIBILE_NAME 11149
+#define IDS_APP_LIST_SPEECH_HINT_TEXT 11150
+#define IDS_APP_LIST_SPEECH_NETWORK_ERROR_HINT_TEXT 11151
+
+#endif  // CEF_INCLUDE_CEF_PACK_STRINGS_H_
diff --git a/src/include/libcef/cef_parser.h b/src/include/libcef/cef_parser.h
new file mode 100644
index 0000000..44c3629
--- /dev/null
+++ b/src/include/libcef/cef_parser.h
@@ -0,0 +1,160 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_PARSER_H_
+#define CEF_INCLUDE_CEF_PARSER_H_
+#pragma once
+
+#include <vector>
+
+#include "include/cef_base.h"
+#include "include/cef_values.h"
+
+///
+// Parse the specified |url| into its component parts.
+// Returns false if the URL is empty or invalid.
+///
+/*--cef()--*/
+bool CefParseURL(const CefString& url,
+                 CefURLParts& parts);
+
+///
+// Creates a URL from the specified |parts|, which must contain a non-empty
+// spec or a non-empty host and path (at a minimum), but not both.
+// Returns false if |parts| isn't initialized as described.
+///
+/*--cef()--*/
+bool CefCreateURL(const CefURLParts& parts,
+                  CefString& url);
+
+///
+// This is a convenience function for formatting a URL in a concise and human-
+// friendly way to help users make security-related decisions (or in other
+// circumstances when people need to distinguish sites, origins, or otherwise-
+// simplified URLs from each other). Internationalized domain names (IDN) may be
+// presented in Unicode if the conversion is considered safe. The returned value
+// will (a) omit the path for standard schemes, excepting file and filesystem,
+// and (b) omit the port if it is the default for the scheme. Do not use this
+// for URLs which will be parsed or sent to other applications.
+///
+/*--cef(optional_param=languages)--*/
+CefString CefFormatUrlForSecurityDisplay(const CefString& origin_url);
+
+///
+// Returns the mime type for the specified file extension or an empty string if
+// unknown.
+///
+/*--cef()--*/
+CefString CefGetMimeType(const CefString& extension);
+
+///
+// Get the extensions associated with the given mime type. This should be passed
+// in lower case. There could be multiple extensions for a given mime type, like
+// "html,htm" for "text/html", or "txt,text,html,..." for "text/*". Any existing
+// elements in the provided vector will not be erased.
+///
+/*--cef()--*/
+void CefGetExtensionsForMimeType(const CefString& mime_type,
+                                 std::vector<CefString>& extensions);
+
+///
+// Encodes |data| as a base64 string.
+///
+/*--cef()--*/
+CefString CefBase64Encode(const void* data, size_t data_size);
+
+///
+// Decodes the base64 encoded string |data|. The returned value will be NULL if
+// the decoding fails.
+///
+/*--cef()--*/
+CefRefPtr<CefBinaryValue> CefBase64Decode(const CefString& data);
+
+///
+// Escapes characters in |text| which are unsuitable for use as a query
+// parameter value. Everything except alphanumerics and -_.!~*'() will be
+// converted to "%XX". If |use_plus| is true spaces will change to "+". The
+// result is basically the same as encodeURIComponent in Javacript.
+///
+/*--cef()--*/
+CefString CefURIEncode(const CefString& text, bool use_plus);
+
+///
+// Unescapes |text| and returns the result. Unescaping consists of looking for
+// the exact pattern "%XX" where each X is a hex digit and converting to the
+// character with the numerical value of those digits (e.g. "i%20=%203%3b"
+// unescapes to "i = 3;"). If |convert_to_utf8| is true this function will
+// attempt to interpret the initial decoded result as UTF-8. If the result is
+// convertable into UTF-8 it will be returned as converted. Otherwise the
+// initial decoded result will be returned.  The |unescape_rule| parameter
+// supports further customization the decoding process.
+///
+/*--cef()--*/
+CefString CefURIDecode(const CefString& text,
+                       bool convert_to_utf8,
+                       cef_uri_unescape_rule_t unescape_rule);
+
+///
+// Parses the specified |json_string| and returns a dictionary or list
+// representation. If JSON parsing fails this method returns NULL.
+///
+/*--cef()--*/
+CefRefPtr<CefValue> CefParseJSON(const CefString& json_string,
+                                 cef_json_parser_options_t options);
+
+///
+// Parses the specified |json_string| and returns a dictionary or list
+// representation. If JSON parsing fails this method returns NULL and populates
+// |error_code_out| and |error_msg_out| with an error code and a formatted error
+// message respectively.
+///
+/*--cef()--*/
+CefRefPtr<CefValue> CefParseJSONAndReturnError(
+    const CefString& json_string,
+    cef_json_parser_options_t options,
+    cef_json_parser_error_t& error_code_out,
+    CefString& error_msg_out);
+
+///
+// Generates a JSON string from the specified root |node| which should be a
+// dictionary or list value. Returns an empty string on failure. This method
+// requires exclusive access to |node| including any underlying data.
+///
+/*--cef()--*/
+CefString CefWriteJSON(CefRefPtr<CefValue> node,
+                       cef_json_writer_options_t options);
+
+#endif  // CEF_INCLUDE_CEF_PARSER_H_
diff --git a/src/include/libcef/cef_path_util.h b/src/include/libcef/cef_path_util.h
new file mode 100644
index 0000000..552f4ba
--- /dev/null
+++ b/src/include/libcef/cef_path_util.h
@@ -0,0 +1,52 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_PATH_UTIL_H_
+#define CEF_INCLUDE_CEF_PATH_UTIL_H_
+#pragma once
+
+#include "include/cef_base.h"
+
+typedef cef_path_key_t PathKey;
+
+///
+// Retrieve the path associated with the specified |key|. Returns true on
+// success. Can be called on any thread in the browser process.
+///
+/*--cef()--*/
+bool CefGetPath(PathKey key, CefString& path);
+
+#endif  // CEF_INCLUDE_CEF_PATH_UTIL_H_
diff --git a/src/include/libcef/cef_print_handler.h b/src/include/libcef/cef_print_handler.h
new file mode 100644
index 0000000..cac1624
--- /dev/null
+++ b/src/include/libcef/cef_print_handler.h
@@ -0,0 +1,138 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_PRINT_HANDLER_H_
+#define CEF_INCLUDE_CEF_PRINT_HANDLER_H_
+#pragma once
+
+#include "include/cef_base.h"
+#include "include/cef_browser.h"
+#include "include/cef_print_settings.h"
+
+///
+// Callback interface for asynchronous continuation of print dialog requests.
+///
+/*--cef(source=library)--*/
+class CefPrintDialogCallback : public virtual CefBase {
+ public:
+  ///
+  // Continue printing with the specified |settings|.
+  ///
+  /*--cef(capi_name=cont)--*/
+  virtual void Continue(CefRefPtr<CefPrintSettings> settings) =0;
+
+  ///
+  // Cancel the printing.
+  ///
+  /*--cef()--*/
+  virtual void Cancel() =0;
+};
+
+///
+// Callback interface for asynchronous continuation of print job requests.
+///
+/*--cef(source=library)--*/
+class CefPrintJobCallback : public virtual CefBase {
+ public:
+  ///
+  // Indicate completion of the print job.
+  ///
+  /*--cef(capi_name=cont)--*/
+  virtual void Continue() =0;
+};
+
+
+///
+// Implement this interface to handle printing on Linux. The methods of this
+// class will be called on the browser process UI thread.
+///
+/*--cef(source=client)--*/
+class CefPrintHandler : public virtual CefBase {
+ public:
+  ///
+  // Called when printing has started for the specified |browser|. This method
+  // will be called before the other OnPrint*() methods and irrespective of how
+  // printing was initiated (e.g. CefBrowserHost::Print(), JavaScript
+  // window.print() or PDF extension print button).
+  ///
+  /*--cef()--*/
+  virtual void OnPrintStart(CefRefPtr<CefBrowser> browser) =0;
+
+  ///
+  // Synchronize |settings| with client state. If |get_defaults| is true then
+  // populate |settings| with the default print settings. Do not keep a
+  // reference to |settings| outside of this callback.
+  ///
+  /*--cef()--*/
+  virtual void OnPrintSettings(CefRefPtr<CefPrintSettings> settings,
+                               bool get_defaults) =0;
+
+  ///
+  // Show the print dialog. Execute |callback| once the dialog is dismissed.
+  // Return true if the dialog will be displayed or false to cancel the
+  // printing immediately.
+  ///
+  /*--cef()--*/
+  virtual bool OnPrintDialog(bool has_selection,
+                             CefRefPtr<CefPrintDialogCallback> callback) =0;
+
+  ///
+  // Send the print job to the printer. Execute |callback| once the job is
+  // completed. Return true if the job will proceed or false to cancel the job
+  // immediately.
+  ///
+  /*--cef()--*/
+  virtual bool OnPrintJob(const CefString& document_name,
+                          const CefString& pdf_file_path,
+                          CefRefPtr<CefPrintJobCallback> callback) =0;
+
+  ///
+  // Reset client state related to printing.
+  ///
+  /*--cef()--*/
+  virtual void OnPrintReset() =0;
+
+  ///
+  // Return the PDF paper size in device units. Used in combination with
+  // CefBrowserHost::PrintToPDF().
+  ///
+  /*--cef()--*/
+  virtual CefSize GetPdfPaperSize(int device_units_per_inch) {
+    return CefSize();
+  }
+};
+
+#endif  // CEF_INCLUDE_CEF_PRINT_HANDLER_H_
diff --git a/src/include/libcef/cef_print_settings.h b/src/include/libcef/cef_print_settings.h
new file mode 100644
index 0000000..709d36b
--- /dev/null
+++ b/src/include/libcef/cef_print_settings.h
@@ -0,0 +1,208 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_PRINT_SETTINGS_H_
+#define CEF_INCLUDE_CEF_PRINT_SETTINGS_H_
+#pragma once
+
+#include <vector>
+
+#include "include/cef_base.h"
+
+///
+// Class representing print settings.
+///
+/*--cef(source=library)--*/
+class CefPrintSettings : public virtual CefBase {
+ public:
+  typedef cef_color_model_t ColorModel;
+  typedef cef_duplex_mode_t DuplexMode;
+  typedef std::vector<CefRange> PageRangeList;
+
+  ///
+  // Create a new CefPrintSettings object.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefPrintSettings> Create();
+
+  ///
+  // Returns true if this object is valid. Do not call any other methods if this
+  // function returns false.
+  ///
+  /*--cef()--*/
+  virtual bool IsValid() =0;
+
+  ///
+  // Returns true if the values of this object are read-only. Some APIs may
+  // expose read-only objects.
+  ///
+  /*--cef()--*/
+  virtual bool IsReadOnly() =0;
+
+  ///
+  // Returns a writable copy of this object.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefPrintSettings> Copy() =0;
+
+  ///
+  // Set the page orientation.
+  ///
+  /*--cef()--*/
+  virtual void SetOrientation(bool landscape) =0;
+
+  ///
+  // Returns true if the orientation is landscape.
+  ///
+  /*--cef()--*/
+  virtual bool IsLandscape() =0;
+
+  ///
+  // Set the printer printable area in device units.
+  // Some platforms already provide flipped area. Set |landscape_needs_flip|
+  // to false on those platforms to avoid double flipping.
+  ///
+  /*--cef()--*/
+  virtual void SetPrinterPrintableArea(
+      const CefSize& physical_size_device_units,
+      const CefRect& printable_area_device_units,
+      bool landscape_needs_flip) =0;
+
+  ///
+  // Set the device name.
+  ///
+  /*--cef(optional_param=name)--*/
+  virtual void SetDeviceName(const CefString& name) =0;
+
+  ///
+  // Get the device name.
+  ///
+  /*--cef()--*/
+  virtual CefString GetDeviceName() =0;
+
+  ///
+  // Set the DPI (dots per inch).
+  ///
+  /*--cef()--*/
+  virtual void SetDPI(int dpi) =0;
+
+  ///
+  // Get the DPI (dots per inch).
+  ///
+  /*--cef()--*/
+  virtual int GetDPI() =0;
+
+  ///
+  // Set the page ranges.
+  ///
+  /*--cef()--*/
+  virtual void SetPageRanges(const PageRangeList& ranges) =0;
+
+  ///
+  // Returns the number of page ranges that currently exist.
+  ///
+  /*--cef()--*/
+  virtual size_t GetPageRangesCount() =0;
+
+  ///
+  // Retrieve the page ranges.
+  ///
+  /*--cef(count_func=ranges:GetPageRangesCount)--*/
+  virtual void GetPageRanges(PageRangeList& ranges) =0;
+
+  ///
+  // Set whether only the selection will be printed.
+  ///
+  /*--cef()--*/
+  virtual void SetSelectionOnly(bool selection_only) =0;
+
+  ///
+  // Returns true if only the selection will be printed.
+  ///
+  /*--cef()--*/
+  virtual bool IsSelectionOnly() =0;
+
+  ///
+  // Set whether pages will be collated.
+  ///
+  /*--cef()--*/
+  virtual void SetCollate(bool collate) =0;
+
+  ///
+  // Returns true if pages will be collated.
+  ///
+  /*--cef()--*/
+  virtual bool WillCollate() =0;
+
+  ///
+  // Set the color model.
+  ///
+  /*--cef()--*/
+  virtual void SetColorModel(ColorModel model) =0;
+
+  ///
+  // Get the color model.
+  ///
+  /*--cef(default_retval=COLOR_MODEL_UNKNOWN)--*/
+  virtual ColorModel GetColorModel() =0;
+
+  ///
+  // Set the number of copies.
+  ///
+  /*--cef()--*/
+  virtual void SetCopies(int copies) =0;
+
+  ///
+  // Get the number of copies.
+  ///
+  /*--cef()--*/
+  virtual int GetCopies() =0;
+
+  ///
+  // Set the duplex mode.
+  ///
+  /*--cef()--*/
+  virtual void SetDuplexMode(DuplexMode mode) =0;
+
+  ///
+  // Get the duplex mode.
+  ///
+  /*--cef(default_retval=DUPLEX_MODE_UNKNOWN)--*/
+  virtual DuplexMode GetDuplexMode() =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_PRINT_SETTINGS_H_
+
diff --git a/src/include/libcef/cef_process_message.h b/src/include/libcef/cef_process_message.h
new file mode 100644
index 0000000..1e27bd6
--- /dev/null
+++ b/src/include/libcef/cef_process_message.h
@@ -0,0 +1,91 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_MESSAGE_H_
+#define CEF_INCLUDE_CEF_MESSAGE_H_
+#pragma once
+
+#include "include/cef_base.h"
+#include "include/cef_values.h"
+
+typedef cef_process_id_t CefProcessId;
+
+///
+// Class representing a message. Can be used on any process and thread.
+///
+/*--cef(source=library)--*/
+class CefProcessMessage : public virtual CefBase {
+ public:
+  ///
+  // Create a new CefProcessMessage object with the specified name.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefProcessMessage> Create(const CefString& name);
+
+  ///
+  // Returns true if this object is valid. Do not call any other methods if this
+  // function returns false.
+  ///
+  /*--cef()--*/
+  virtual bool IsValid() =0;
+
+  ///
+  // Returns true if the values of this object are read-only. Some APIs may
+  // expose read-only objects.
+  ///
+  /*--cef()--*/
+  virtual bool IsReadOnly() =0;
+
+  ///
+  // Returns a writable copy of this object.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefProcessMessage> Copy() =0;
+
+  ///
+  // Returns the message name.
+  ///
+  /*--cef()--*/
+  virtual CefString GetName() =0;
+
+  ///
+  // Returns the list of arguments.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefListValue> GetArgumentList() =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_MESSAGE_H_
diff --git a/src/include/libcef/cef_process_util.h b/src/include/libcef/cef_process_util.h
new file mode 100644
index 0000000..4fce778
--- /dev/null
+++ b/src/include/libcef/cef_process_util.h
@@ -0,0 +1,57 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_PROCESS_UTIL_H_
+#define CEF_INCLUDE_CEF_PROCESS_UTIL_H_
+#pragma once
+
+#include "include/cef_base.h"
+#include "include/cef_command_line.h"
+
+///
+// Launches the process specified via |command_line|. Returns true upon
+// success. Must be called on the browser process TID_PROCESS_LAUNCHER thread.
+//
+// Unix-specific notes:
+// - All file descriptors open in the parent process will be closed in the
+//   child process except for stdin, stdout, and stderr.
+// - If the first argument on the command line does not contain a slash,
+//   PATH will be searched. (See man execvp.)
+///
+/*--cef()--*/
+bool CefLaunchProcess(CefRefPtr<CefCommandLine> command_line);
+
+#endif  // CEF_INCLUDE_CEF_PROCESS_UTIL_H_
diff --git a/src/include/libcef/cef_render_handler.h b/src/include/libcef/cef_render_handler.h
new file mode 100644
index 0000000..636d72e
--- /dev/null
+++ b/src/include/libcef/cef_render_handler.h
@@ -0,0 +1,180 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_RENDER_HANDLER_H_
+#define CEF_INCLUDE_CEF_RENDER_HANDLER_H_
+#pragma once
+
+#include "include/cef_base.h"
+#include "include/cef_browser.h"
+#include "include/cef_drag_data.h"
+#include <vector>
+
+///
+// Implement this interface to handle events when window rendering is disabled.
+// The methods of this class will be called on the UI thread.
+///
+/*--cef(source=client)--*/
+class CefRenderHandler : public virtual CefBase {
+ public:
+  typedef cef_cursor_type_t CursorType;
+  typedef cef_drag_operations_mask_t DragOperation;
+  typedef cef_drag_operations_mask_t DragOperationsMask;
+  typedef cef_paint_element_type_t PaintElementType;
+  typedef std::vector<CefRect> RectList;
+
+  ///
+  // Called to retrieve the root window rectangle in screen coordinates. Return
+  // true if the rectangle was provided.
+  ///
+  /*--cef()--*/
+  virtual bool GetRootScreenRect(CefRefPtr<CefBrowser> browser,
+                                 CefRect& rect) { return false; }
+
+  ///
+  // Called to retrieve the view rectangle which is relative to screen
+  // coordinates. Return true if the rectangle was provided.
+  ///
+  /*--cef()--*/
+  virtual bool GetViewRect(CefRefPtr<CefBrowser> browser, CefRect& rect) =0;
+
+  ///
+  // Called to retrieve the translation from view coordinates to actual screen
+  // coordinates. Return true if the screen coordinates were provided.
+  ///
+  /*--cef()--*/
+  virtual bool GetScreenPoint(CefRefPtr<CefBrowser> browser,
+                              int viewX,
+                              int viewY,
+                              int& screenX,
+                              int& screenY) { return false; }
+
+  ///
+  // Called to allow the client to fill in the CefScreenInfo object with
+  // appropriate values. Return true if the |screen_info| structure has been
+  // modified.
+  //
+  // If the screen info rectangle is left empty the rectangle from GetViewRect
+  // will be used. If the rectangle is still empty or invalid popups may not be
+  // drawn correctly.
+  ///
+  /*--cef()--*/
+  virtual bool GetScreenInfo(CefRefPtr<CefBrowser> browser,
+                             CefScreenInfo& screen_info) { return false; }
+
+  ///
+  // Called when the browser wants to show or hide the popup widget. The popup
+  // should be shown if |show| is true and hidden if |show| is false.
+  ///
+  /*--cef()--*/
+  virtual void OnPopupShow(CefRefPtr<CefBrowser> browser,
+                           bool show) {}
+
+  ///
+  // Called when the browser wants to move or resize the popup widget. |rect|
+  // contains the new location and size in view coordinates.
+  ///
+  /*--cef()--*/
+  virtual void OnPopupSize(CefRefPtr<CefBrowser> browser,
+                           const CefRect& rect) {}
+
+  ///
+  // Called when an element should be painted. Pixel values passed to this
+  // method are scaled relative to view coordinates based on the value of
+  // CefScreenInfo.device_scale_factor returned from GetScreenInfo. |type|
+  // indicates whether the element is the view or the popup widget. |buffer|
+  // contains the pixel data for the whole image. |dirtyRects| contains the set
+  // of rectangles in pixel coordinates that need to be repainted. |buffer| will
+  // be |width|*|height|*4 bytes in size and represents a BGRA image with an
+  // upper-left origin.
+  ///
+  /*--cef()--*/
+  virtual void OnPaint(CefRefPtr<CefBrowser> browser,
+                       PaintElementType type,
+                       const RectList& dirtyRects,
+                       const void* buffer,
+                       int width, int height) =0;
+
+  ///
+  // Called when the browser's cursor has changed. If |type| is CT_CUSTOM then
+  // |custom_cursor_info| will be populated with the custom cursor information.
+  ///
+  /*--cef()--*/
+  virtual void OnCursorChange(CefRefPtr<CefBrowser> browser,
+                              CefCursorHandle cursor,
+                              CursorType type,
+                              const CefCursorInfo& custom_cursor_info) {}
+
+  ///
+  // Called when the user starts dragging content in the web view. Contextual
+  // information about the dragged content is supplied by |drag_data|.
+  // (|x|, |y|) is the drag start location in screen coordinates.
+  // OS APIs that run a system message loop may be used within the
+  // StartDragging call.
+  //
+  // Return false to abort the drag operation. Don't call any of
+  // CefBrowserHost::DragSource*Ended* methods after returning false.
+  //
+  // Return true to handle the drag operation. Call
+  // CefBrowserHost::DragSourceEndedAt and DragSourceSystemDragEnded either
+  // synchronously or asynchronously to inform the web view that the drag
+  // operation has ended.
+  ///
+  /*--cef()--*/
+  virtual bool StartDragging(CefRefPtr<CefBrowser> browser,
+                             CefRefPtr<CefDragData> drag_data,
+                             DragOperationsMask allowed_ops,
+                             int x, int y) { return false; }
+
+  ///
+  // Called when the web view wants to update the mouse cursor during a
+  // drag & drop operation. |operation| describes the allowed operation
+  // (none, move, copy, link).
+  ///
+  /*--cef()--*/
+  virtual void UpdateDragCursor(CefRefPtr<CefBrowser> browser,
+                                DragOperation operation) {}
+
+  ///
+  // Called when the scroll offset has changed.
+  ///
+  /*--cef()--*/
+  virtual void OnScrollOffsetChanged(CefRefPtr<CefBrowser> browser,
+                                     double x,
+                                     double y) {}
+};
+
+#endif  // CEF_INCLUDE_CEF_RENDER_HANDLER_H_
diff --git a/src/include/libcef/cef_render_process_handler.h b/src/include/libcef/cef_render_process_handler.h
new file mode 100644
index 0000000..98ab391
--- /dev/null
+++ b/src/include/libcef/cef_render_process_handler.h
@@ -0,0 +1,168 @@
+// Copyright (c) 2013 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_RENDER_PROCESS_HANDLER_H_
+#define CEF_INCLUDE_CEF_RENDER_PROCESS_HANDLER_H_
+#pragma once
+
+#include "include/cef_base.h"
+#include "include/cef_browser.h"
+#include "include/cef_dom.h"
+#include "include/cef_frame.h"
+#include "include/cef_load_handler.h"
+#include "include/cef_process_message.h"
+#include "include/cef_v8.h"
+#include "include/cef_values.h"
+
+///
+// Class used to implement render process callbacks. The methods of this class
+// will be called on the render process main thread (TID_RENDERER) unless
+// otherwise indicated.
+///
+/*--cef(source=client)--*/
+class CefRenderProcessHandler : public virtual CefBase {
+ public:
+  typedef cef_navigation_type_t NavigationType;
+
+  ///
+  // Called after the render process main thread has been created. |extra_info|
+  // is a read-only value originating from
+  // CefBrowserProcessHandler::OnRenderProcessThreadCreated(). Do not keep a
+  // reference to |extra_info| outside of this method.
+  ///
+  /*--cef()--*/
+  virtual void OnRenderThreadCreated(CefRefPtr<CefListValue> extra_info) {}
+
+  ///
+  // Called after WebKit has been initialized.
+  ///
+  /*--cef()--*/
+  virtual void OnWebKitInitialized() {}
+
+  ///
+  // Called after a browser has been created. When browsing cross-origin a new
+  // browser will be created before the old browser with the same identifier is
+  // destroyed.
+  ///
+  /*--cef()--*/
+  virtual void OnBrowserCreated(CefRefPtr<CefBrowser> browser) {}
+
+  ///
+  // Called before a browser is destroyed.
+  ///
+  /*--cef()--*/
+  virtual void OnBrowserDestroyed(CefRefPtr<CefBrowser> browser) {}
+
+  ///
+  // Return the handler for browser load status events.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefLoadHandler> GetLoadHandler() {
+    return NULL;
+  }
+
+  ///
+  // Called before browser navigation. Return true to cancel the navigation or
+  // false to allow the navigation to proceed. The |request| object cannot be
+  // modified in this callback.
+  ///
+  /*--cef()--*/
+  virtual bool OnBeforeNavigation(CefRefPtr<CefBrowser> browser,
+                                  CefRefPtr<CefFrame> frame,
+                                  CefRefPtr<CefRequest> request,
+                                  NavigationType navigation_type,
+                                  bool is_redirect) { return false; }
+
+  ///
+  // Called immediately after the V8 context for a frame has been created. To
+  // retrieve the JavaScript 'window' object use the CefV8Context::GetGlobal()
+  // method. V8 handles can only be accessed from the thread on which they are
+  // created. A task runner for posting tasks on the associated thread can be
+  // retrieved via the CefV8Context::GetTaskRunner() method.
+  ///
+  /*--cef()--*/
+  virtual void OnContextCreated(CefRefPtr<CefBrowser> browser,
+                                CefRefPtr<CefFrame> frame,
+                                CefRefPtr<CefV8Context> context) {}
+
+  ///
+  // Called immediately before the V8 context for a frame is released. No
+  // references to the context should be kept after this method is called.
+  ///
+  /*--cef()--*/
+  virtual void OnContextReleased(CefRefPtr<CefBrowser> browser,
+                                 CefRefPtr<CefFrame> frame,
+                                 CefRefPtr<CefV8Context> context) {}
+
+  ///
+  // Called for global uncaught exceptions in a frame. Execution of this
+  // callback is disabled by default. To enable set
+  // CefSettings.uncaught_exception_stack_size > 0.
+  ///
+  /*--cef()--*/
+  virtual void OnUncaughtException(CefRefPtr<CefBrowser> browser,
+                                   CefRefPtr<CefFrame> frame,
+                                   CefRefPtr<CefV8Context> context,
+                                   CefRefPtr<CefV8Exception> exception,
+                                   CefRefPtr<CefV8StackTrace> stackTrace) {}
+
+  ///
+  // Called when a new node in the the browser gets focus. The |node| value may
+  // be empty if no specific node has gained focus. The node object passed to
+  // this method represents a snapshot of the DOM at the time this method is
+  // executed. DOM objects are only valid for the scope of this method. Do not
+  // keep references to or attempt to access any DOM objects outside the scope
+  // of this method.
+  ///
+  /*--cef(optional_param=frame,optional_param=node)--*/
+  virtual void OnFocusedNodeChanged(CefRefPtr<CefBrowser> browser,
+                                    CefRefPtr<CefFrame> frame,
+                                    CefRefPtr<CefDOMNode> node) {}
+
+  ///
+  // Called when a new message is received from a different process. Return true
+  // if the message was handled or false otherwise. Do not keep a reference to
+  // or attempt to access the message outside of this callback.
+  ///
+  /*--cef()--*/
+  virtual bool OnProcessMessageReceived(CefRefPtr<CefBrowser> browser,
+                                        CefProcessId source_process,
+                                        CefRefPtr<CefProcessMessage> message) {
+    return false;
+  }
+};
+
+#endif  // CEF_INCLUDE_CEF_RENDER_PROCESS_HANDLER_H_
diff --git a/src/include/libcef/cef_request.h b/src/include/libcef/cef_request.h
new file mode 100644
index 0000000..a4626aa
--- /dev/null
+++ b/src/include/libcef/cef_request.h
@@ -0,0 +1,337 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_REQUEST_H_
+#define CEF_INCLUDE_CEF_REQUEST_H_
+#pragma once
+
+#include "include/cef_base.h"
+#include <map>
+#include <vector>
+
+class CefPostData;
+class CefPostDataElement;
+
+///
+// Class used to represent a web request. The methods of this class may be
+// called on any thread.
+///
+/*--cef(source=library,no_debugct_check)--*/
+class CefRequest : public virtual CefBase {
+ public:
+  typedef std::multimap<CefString, CefString> HeaderMap;
+  typedef cef_referrer_policy_t ReferrerPolicy;
+  typedef cef_resource_type_t ResourceType;
+  typedef cef_transition_type_t TransitionType;
+
+  ///
+  // Create a new CefRequest object.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefRequest> Create();
+
+  ///
+  // Returns true if this object is read-only.
+  ///
+  /*--cef()--*/
+  virtual bool IsReadOnly() =0;
+
+  ///
+  // Get the fully qualified URL.
+  ///
+  /*--cef()--*/
+  virtual CefString GetURL() =0;
+
+  ///
+  // Set the fully qualified URL.
+  ///
+  /*--cef()--*/
+  virtual void SetURL(const CefString& url) =0;
+
+  ///
+  // Get the request method type. The value will default to POST if post data
+  // is provided and GET otherwise.
+  ///
+  /*--cef()--*/
+  virtual CefString GetMethod() =0;
+
+  ///
+  // Set the request method type.
+  ///
+  /*--cef()--*/
+  virtual void SetMethod(const CefString& method) =0;
+
+  ///
+  // Set the referrer URL and policy. If non-empty the referrer URL must be
+  // fully qualified with an HTTP or HTTPS scheme component. Any username,
+  // password or ref component will be removed.
+  ///
+  /*--cef()--*/
+  virtual void SetReferrer(const CefString& referrer_url,
+                           ReferrerPolicy policy) =0;
+
+  ///
+  // Get the referrer URL.
+  ///
+  /*--cef()--*/
+  virtual CefString GetReferrerURL() =0;
+
+  ///
+  // Get the referrer policy.
+  ///
+  /*--cef(default_retval=REFERRER_POLICY_DEFAULT)--*/
+  virtual ReferrerPolicy GetReferrerPolicy() =0;
+
+  ///
+  // Get the post data.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefPostData> GetPostData() =0;
+
+  ///
+  // Set the post data.
+  ///
+  /*--cef()--*/
+  virtual void SetPostData(CefRefPtr<CefPostData> postData) =0;
+
+  ///
+  // Get the header values. Will not include the Referer value if any.
+  ///
+  /*--cef()--*/
+  virtual void GetHeaderMap(HeaderMap& headerMap) =0;
+
+  ///
+  // Set the header values. If a Referer value exists in the header map it will
+  // be removed and ignored.
+  ///
+  /*--cef()--*/
+  virtual void SetHeaderMap(const HeaderMap& headerMap) =0;
+
+  ///
+  // Set all values at one time.
+  ///
+  /*--cef(optional_param=postData)--*/
+  virtual void Set(const CefString& url,
+                   const CefString& method,
+                   CefRefPtr<CefPostData> postData,
+                   const HeaderMap& headerMap) =0;
+
+  ///
+  // Get the flags used in combination with CefURLRequest. See
+  // cef_urlrequest_flags_t for supported values.
+  ///
+  /*--cef(default_retval=UR_FLAG_NONE)--*/
+  virtual int GetFlags() =0;
+
+  ///
+  // Set the flags used in combination with CefURLRequest.  See
+  // cef_urlrequest_flags_t for supported values.
+  ///
+  /*--cef()--*/
+  virtual void SetFlags(int flags) =0;
+
+  ///
+  // Set the URL to the first party for cookies used in combination with
+  // CefURLRequest.
+  ///
+  /*--cef()--*/
+  virtual CefString GetFirstPartyForCookies() =0;
+
+  ///
+  // Get the URL to the first party for cookies used in combination with
+  // CefURLRequest.
+  ///
+  /*--cef()--*/
+  virtual void SetFirstPartyForCookies(const CefString& url) =0;
+
+  ///
+  // Get the resource type for this request. Only available in the browser
+  // process.
+  ///
+  /*--cef(default_retval=RT_SUB_RESOURCE)--*/
+  virtual ResourceType GetResourceType() =0;
+
+  ///
+  // Get the transition type for this request. Only available in the browser
+  // process and only applies to requests that represent a main frame or
+  // sub-frame navigation.
+  ///
+  /*--cef(default_retval=TT_EXPLICIT)--*/
+  virtual TransitionType GetTransitionType() =0;
+
+  ///
+  // Returns the globally unique identifier for this request or 0 if not
+  // specified. Can be used by CefRequestHandler implementations in the browser
+  // process to track a single request across multiple callbacks.
+  ///
+  /*--cef()--*/
+  virtual uint64 GetIdentifier() =0;
+};
+
+
+///
+// Class used to represent post data for a web request. The methods of this
+// class may be called on any thread.
+///
+/*--cef(source=library,no_debugct_check)--*/
+class CefPostData : public virtual CefBase {
+ public:
+  typedef std::vector<CefRefPtr<CefPostDataElement> > ElementVector;
+
+  ///
+  // Create a new CefPostData object.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefPostData> Create();
+
+  ///
+  // Returns true if this object is read-only.
+  ///
+  /*--cef()--*/
+  virtual bool IsReadOnly() =0;
+
+  ///
+  // Returns true if the underlying POST data includes elements that are not
+  // represented by this CefPostData object (for example, multi-part file upload
+  // data). Modifying CefPostData objects with excluded elements may result in
+  // the request failing.
+  ///
+  /*--cef()--*/
+  virtual bool HasExcludedElements() = 0;
+
+  ///
+  // Returns the number of existing post data elements.
+  ///
+  /*--cef()--*/
+  virtual size_t GetElementCount() =0;
+
+  ///
+  // Retrieve the post data elements.
+  ///
+  /*--cef(count_func=elements:GetElementCount)--*/
+  virtual void GetElements(ElementVector& elements) =0;
+
+  ///
+  // Remove the specified post data element.  Returns true if the removal
+  // succeeds.
+  ///
+  /*--cef()--*/
+  virtual bool RemoveElement(CefRefPtr<CefPostDataElement> element) =0;
+
+  ///
+  // Add the specified post data element.  Returns true if the add succeeds.
+  ///
+  /*--cef()--*/
+  virtual bool AddElement(CefRefPtr<CefPostDataElement> element) =0;
+
+  ///
+  // Remove all existing post data elements.
+  ///
+  /*--cef()--*/
+  virtual void RemoveElements() =0;
+};
+
+
+///
+// Class used to represent a single element in the request post data. The
+// methods of this class may be called on any thread.
+///
+/*--cef(source=library,no_debugct_check)--*/
+class CefPostDataElement : public virtual CefBase {
+ public:
+  ///
+  // Post data elements may represent either bytes or files.
+  ///
+  typedef cef_postdataelement_type_t Type;
+
+  ///
+  // Create a new CefPostDataElement object.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefPostDataElement> Create();
+
+  ///
+  // Returns true if this object is read-only.
+  ///
+  /*--cef()--*/
+  virtual bool IsReadOnly() =0;
+
+  ///
+  // Remove all contents from the post data element.
+  ///
+  /*--cef()--*/
+  virtual void SetToEmpty() =0;
+
+  ///
+  // The post data element will represent a file.
+  ///
+  /*--cef()--*/
+  virtual void SetToFile(const CefString& fileName) =0;
+
+  ///
+  // The post data element will represent bytes.  The bytes passed
+  // in will be copied.
+  ///
+  /*--cef()--*/
+  virtual void SetToBytes(size_t size, const void* bytes) =0;
+
+  ///
+  // Return the type of this post data element.
+  ///
+  /*--cef(default_retval=PDE_TYPE_EMPTY)--*/
+  virtual Type GetType() =0;
+
+  ///
+  // Return the file name.
+  ///
+  /*--cef()--*/
+  virtual CefString GetFile() =0;
+
+  ///
+  // Return the number of bytes.
+  ///
+  /*--cef()--*/
+  virtual size_t GetBytesCount() =0;
+
+  ///
+  // Read up to |size| bytes into |bytes| and return the number of bytes
+  // actually read.
+  ///
+  /*--cef()--*/
+  virtual size_t GetBytes(size_t size, void* bytes) =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_REQUEST_H_
diff --git a/src/include/libcef/cef_request_context.h b/src/include/libcef/cef_request_context.h
new file mode 100644
index 0000000..d8cd558
--- /dev/null
+++ b/src/include/libcef/cef_request_context.h
@@ -0,0 +1,286 @@
+// Copyright (c) 2013 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_REQUEST_CONTEXT_H_
+#define CEF_INCLUDE_CEF_REQUEST_CONTEXT_H_
+#pragma once
+
+#include <vector>
+
+#include "include/cef_callback.h"
+#include "include/cef_cookie.h"
+#include "include/cef_request_context_handler.h"
+#include "include/cef_values.h"
+
+class CefSchemeHandlerFactory;
+
+
+///
+// Callback interface for CefRequestContext::ResolveHost.
+///
+/*--cef(source=client)--*/
+class CefResolveCallback : public virtual CefBase {
+ public:
+  ///
+  // Called after the ResolveHost request has completed. |result| will be the
+  // result code. |resolved_ips| will be the list of resolved IP addresses or
+  // empty if the resolution failed.
+  ///
+  /*--cef(optional_param=resolved_ips)--*/
+  virtual void OnResolveCompleted(
+      cef_errorcode_t result,
+      const std::vector<CefString>& resolved_ips) =0;
+};
+
+
+///
+// A request context provides request handling for a set of related browser
+// or URL request objects. A request context can be specified when creating a
+// new browser via the CefBrowserHost static factory methods or when creating a
+// new URL request via the CefURLRequest static factory methods. Browser objects
+// with different request contexts will never be hosted in the same render
+// process. Browser objects with the same request context may or may not be
+// hosted in the same render process depending on the process model. Browser
+// objects created indirectly via the JavaScript window.open function or
+// targeted links will share the same render process and the same request
+// context as the source browser. When running in single-process mode there is
+// only a single render process (the main process) and so all browsers created
+// in single-process mode will share the same request context. This will be the
+// first request context passed into a CefBrowserHost static factory method and
+// all other request context objects will be ignored.
+///
+/*--cef(source=library,no_debugct_check)--*/
+class CefRequestContext : public virtual CefBase {
+ public:
+  ///
+  // Returns the global context object.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefRequestContext> GetGlobalContext();
+
+  ///
+  // Creates a new context object with the specified |settings| and optional
+  // |handler|.
+  ///
+  /*--cef(optional_param=handler)--*/
+  static CefRefPtr<CefRequestContext> CreateContext(
+      const CefRequestContextSettings& settings,
+      CefRefPtr<CefRequestContextHandler> handler);
+
+  ///
+  // Creates a new context object that shares storage with |other| and uses an
+  // optional |handler|.
+  ///
+  /*--cef(capi_name=create_context_shared,optional_param=handler)--*/
+  static CefRefPtr<CefRequestContext> CreateContext(
+      CefRefPtr<CefRequestContext> other,
+      CefRefPtr<CefRequestContextHandler> handler);
+
+  ///
+  // Returns true if this object is pointing to the same context as |that|
+  // object.
+  ///
+  /*--cef()--*/
+  virtual bool IsSame(CefRefPtr<CefRequestContext> other) =0;
+
+  ///
+  // Returns true if this object is sharing the same storage as |that| object.
+  ///
+  /*--cef()--*/
+  virtual bool IsSharingWith(CefRefPtr<CefRequestContext> other) =0;
+
+  ///
+  // Returns true if this object is the global context. The global context is
+  // used by default when creating a browser or URL request with a NULL context
+  // argument.
+  ///
+  /*--cef()--*/
+  virtual bool IsGlobal() =0;
+
+  ///
+  // Returns the handler for this context if any.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefRequestContextHandler> GetHandler() =0;
+
+  ///
+  // Returns the cache path for this object. If empty an "incognito mode"
+  // in-memory cache is being used.
+  ///
+  /*--cef()--*/
+  virtual CefString GetCachePath() =0;
+
+  ///
+  // Returns the default cookie manager for this object. This will be the global
+  // cookie manager if this object is the global request context. Otherwise,
+  // this will be the default cookie manager used when this request context does
+  // not receive a value via CefRequestContextHandler::GetCookieManager(). If
+  // |callback| is non-NULL it will be executed asnychronously on the IO thread
+  // after the manager's storage has been initialized.
+  ///
+  /*--cef(optional_param=callback)--*/
+  virtual CefRefPtr<CefCookieManager> GetDefaultCookieManager(
+      CefRefPtr<CefCompletionCallback> callback) =0;
+
+  ///
+  // Register a scheme handler factory for the specified |scheme_name| and
+  // optional |domain_name|. An empty |domain_name| value for a standard scheme
+  // will cause the factory to match all domain names. The |domain_name| value
+  // will be ignored for non-standard schemes. If |scheme_name| is a built-in
+  // scheme and no handler is returned by |factory| then the built-in scheme
+  // handler factory will be called. If |scheme_name| is a custom scheme then
+  // you must also implement the CefApp::OnRegisterCustomSchemes() method in all
+  // processes. This function may be called multiple times to change or remove
+  // the factory that matches the specified |scheme_name| and optional
+  // |domain_name|. Returns false if an error occurs. This function may be
+  // called on any thread in the browser process.
+  ///
+  /*--cef(optional_param=domain_name,optional_param=factory)--*/
+  virtual bool RegisterSchemeHandlerFactory(
+      const CefString& scheme_name,
+      const CefString& domain_name,
+      CefRefPtr<CefSchemeHandlerFactory> factory) =0;
+
+  ///
+  // Clear all registered scheme handler factories. Returns false on error. This
+  // function may be called on any thread in the browser process.
+  ///
+  /*--cef()--*/
+  virtual bool ClearSchemeHandlerFactories() =0;
+
+  ///
+  // Tells all renderer processes associated with this context to throw away
+  // their plugin list cache. If |reload_pages| is true they will also reload
+  // all pages with plugins. CefRequestContextHandler::OnBeforePluginLoad may
+  // be called to rebuild the plugin list cache.
+  ///
+  /*--cef()--*/
+  virtual void PurgePluginListCache(bool reload_pages) =0;
+
+  ///
+  // Returns true if a preference with the specified |name| exists. This method
+  // must be called on the browser process UI thread.
+  ///
+  /*--cef()--*/
+  virtual bool HasPreference(const CefString& name) =0;
+
+  ///
+  // Returns the value for the preference with the specified |name|. Returns
+  // NULL if the preference does not exist. The returned object contains a copy
+  // of the underlying preference value and modifications to the returned object
+  // will not modify the underlying preference value. This method must be called
+  // on the browser process UI thread.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefValue> GetPreference(const CefString& name) =0;
+
+  ///
+  // Returns all preferences as a dictionary. If |include_defaults| is true then
+  // preferences currently at their default value will be included. The returned
+  // object contains a copy of the underlying preference values and
+  // modifications to the returned object will not modify the underlying
+  // preference values. This method must be called on the browser process UI
+  // thread.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefDictionaryValue> GetAllPreferences(
+      bool include_defaults) =0;
+
+  ///
+  // Returns true if the preference with the specified |name| can be modified
+  // using SetPreference. As one example preferences set via the command-line
+  // usually cannot be modified. This method must be called on the browser
+  // process UI thread.
+  ///
+  /*--cef()--*/
+  virtual bool CanSetPreference(const CefString& name) =0;
+
+  ///
+  // Set the |value| associated with preference |name|. Returns true if the
+  // value is set successfully and false otherwise. If |value| is NULL the
+  // preference will be restored to its default value. If setting the preference
+  // fails then |error| will be populated with a detailed description of the
+  // problem. This method must be called on the browser process UI thread.
+  ///
+  /*--cef(optional_param=value)--*/
+  virtual bool SetPreference(const CefString& name,
+                             CefRefPtr<CefValue> value,
+                             CefString& error) =0;
+
+  ///
+  // Clears all certificate exceptions that were added as part of handling
+  // CefRequestHandler::OnCertificateError(). If you call this it is
+  // recommended that you also call CloseAllConnections() or you risk not
+  // being prompted again for server certificates if you reconnect quickly.
+  // If |callback| is non-NULL it will be executed on the UI thread after
+  // completion.
+  ///
+  /*--cef(optional_param=callback)--*/
+  virtual void ClearCertificateExceptions(
+      CefRefPtr<CefCompletionCallback> callback) =0;
+
+  ///
+  // Clears all active and idle connections that Chromium currently has.
+  // This is only recommended if you have released all other CEF objects but
+  // don't yet want to call CefShutdown(). If |callback| is non-NULL it will be
+  // executed on the UI thread after completion.
+  ///
+  /*--cef(optional_param=callback)--*/
+  virtual void CloseAllConnections(
+      CefRefPtr<CefCompletionCallback> callback) =0;
+
+  ///
+  // Attempts to resolve |origin| to a list of associated IP addresses.
+  // |callback| will be executed on the UI thread after completion.
+  ///
+  /*--cef()--*/
+  virtual void ResolveHost(
+      const CefString& origin,
+      CefRefPtr<CefResolveCallback> callback) =0;
+
+  ///
+  // Attempts to resolve |origin| to a list of associated IP addresses using
+  // cached data. |resolved_ips| will be populated with the list of resolved IP
+  // addresses or empty if no cached data is available. Returns ERR_NONE on
+  // success. This method must be called on the browser process IO thread.
+  ///
+  /*--cef(default_retval=ERR_FAILED)--*/
+  virtual cef_errorcode_t ResolveHostCached(
+      const CefString& origin,
+      std::vector<CefString>& resolved_ips) =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_REQUEST_CONTEXT_H_
diff --git a/src/include/libcef/cef_request_context_handler.h b/src/include/libcef/cef_request_context_handler.h
new file mode 100644
index 0000000..c2d3c7a
--- /dev/null
+++ b/src/include/libcef/cef_request_context_handler.h
@@ -0,0 +1,90 @@
+// Copyright (c) 2013 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_REQUEST_CONTEXT_HANDLER_H_
+#define CEF_INCLUDE_CEF_REQUEST_CONTEXT_HANDLER_H_
+#pragma once
+
+#include "include/cef_base.h"
+#include "include/cef_cookie.h"
+#include "include/cef_web_plugin.h"
+
+///
+// Implement this interface to provide handler implementations. The handler
+// instance will not be released until all objects related to the context have
+// been destroyed.
+///
+/*--cef(source=client,no_debugct_check)--*/
+class CefRequestContextHandler : public virtual CefBase {
+ public:
+  typedef cef_plugin_policy_t PluginPolicy;
+
+  ///
+  // Called on the browser process IO thread to retrieve the cookie manager. If
+  // this method returns NULL the default cookie manager retrievable via
+  // CefRequestContext::GetDefaultCookieManager() will be used.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefCookieManager> GetCookieManager() { return NULL; }
+
+  ///
+  // Called on multiple browser process threads before a plugin instance is
+  // loaded. |mime_type| is the mime type of the plugin that will be loaded.
+  // |plugin_url| is the content URL that the plugin will load and may be empty.
+  // |top_origin_url| is the URL for the top-level frame that contains the
+  // plugin when loading a specific plugin instance or empty when building the
+  // initial list of enabled plugins for 'navigator.plugins' JavaScript state.
+  // |plugin_info| includes additional information about the plugin that will be
+  // loaded. |plugin_policy| is the recommended policy. Modify |plugin_policy|
+  // and return true to change the policy. Return false to use the recommended
+  // policy. The default plugin policy can be set at runtime using the
+  // `--plugin-policy=[allow|detect|block]` command-line flag. Decisions to mark
+  // a plugin as disabled by setting |plugin_policy| to PLUGIN_POLICY_DISABLED
+  // may be cached when |top_origin_url| is empty. To purge the plugin list
+  // cache and potentially trigger new calls to this method call
+  // CefRequestContext::PurgePluginListCache.
+  ///
+  /*--cef(optional_param=plugin_url,optional_param=top_origin_url)--*/
+  virtual bool OnBeforePluginLoad(const CefString& mime_type,
+                                  const CefString& plugin_url,
+                                  const CefString& top_origin_url,
+                                  CefRefPtr<CefWebPluginInfo> plugin_info,
+                                  PluginPolicy* plugin_policy) {
+    return false;
+  }
+};
+
+#endif  // CEF_INCLUDE_CEF_REQUEST_CONTEXT_HANDLER_H_
diff --git a/src/include/libcef/cef_request_handler.h b/src/include/libcef/cef_request_handler.h
new file mode 100644
index 0000000..5ffb3b9
--- /dev/null
+++ b/src/include/libcef/cef_request_handler.h
@@ -0,0 +1,308 @@
+// Copyright (c) 2011 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_REQUEST_HANDLER_H_
+#define CEF_INCLUDE_CEF_REQUEST_HANDLER_H_
+#pragma once
+
+#include "include/cef_auth_callback.h"
+#include "include/cef_base.h"
+#include "include/cef_browser.h"
+#include "include/cef_frame.h"
+#include "include/cef_resource_handler.h"
+#include "include/cef_response.h"
+#include "include/cef_response_filter.h"
+#include "include/cef_request.h"
+#include "include/cef_ssl_info.h"
+
+
+///
+// Callback interface used for asynchronous continuation of url requests.
+///
+/*--cef(source=library)--*/
+class CefRequestCallback : public virtual CefBase {
+ public:
+  ///
+  // Continue the url request. If |allow| is true the request will be continued.
+  // Otherwise, the request will be canceled.
+  ///
+  /*--cef(capi_name=cont)--*/
+  virtual void Continue(bool allow) =0;
+
+  ///
+  // Cancel the url request.
+  ///
+  /*--cef()--*/
+  virtual void Cancel() =0;
+};
+
+
+///
+// Implement this interface to handle events related to browser requests. The
+// methods of this class will be called on the thread indicated.
+///
+/*--cef(source=client)--*/
+class CefRequestHandler : public virtual CefBase {
+ public:
+  typedef cef_return_value_t ReturnValue;
+  typedef cef_termination_status_t TerminationStatus;
+  typedef cef_urlrequest_status_t URLRequestStatus;
+  typedef cef_window_open_disposition_t WindowOpenDisposition;
+
+  ///
+  // Called on the UI thread before browser navigation. Return true to cancel
+  // the navigation or false to allow the navigation to proceed. The |request|
+  // object cannot be modified in this callback.
+  // CefLoadHandler::OnLoadingStateChange will be called twice in all cases.
+  // If the navigation is allowed CefLoadHandler::OnLoadStart and
+  // CefLoadHandler::OnLoadEnd will be called. If the navigation is canceled
+  // CefLoadHandler::OnLoadError will be called with an |errorCode| value of
+  // ERR_ABORTED.
+  ///
+  /*--cef()--*/
+  virtual bool OnBeforeBrowse(CefRefPtr<CefBrowser> browser,
+                              CefRefPtr<CefFrame> frame,
+                              CefRefPtr<CefRequest> request,
+                              bool is_redirect) {
+    return false;
+  }
+
+  ///
+  // Called on the UI thread before OnBeforeBrowse in certain limited cases
+  // where navigating a new or different browser might be desirable. This
+  // includes user-initiated navigation that might open in a special way (e.g.
+  // links clicked via middle-click or ctrl + left-click) and certain types of
+  // cross-origin navigation initiated from the renderer process (e.g.
+  // navigating the top-level frame to/from a file URL). The |browser| and
+  // |frame| values represent the source of the navigation. The
+  // |target_disposition| value indicates where the user intended to navigate
+  // the browser based on standard Chromium behaviors (e.g. current tab,
+  // new tab, etc). The |user_gesture| value will be true if the browser
+  // navigated via explicit user gesture (e.g. clicking a link) or false if it
+  // navigated automatically (e.g. via the DomContentLoaded event). Return true
+  // to cancel the navigation or false to allow the navigation to proceed in the
+  // source browser's top-level frame.
+  ///
+  /*--cef()--*/
+  virtual bool OnOpenURLFromTab(CefRefPtr<CefBrowser> browser,
+                                CefRefPtr<CefFrame> frame,
+                                const CefString& target_url,
+                                WindowOpenDisposition target_disposition,
+                                bool user_gesture) {
+    return false;
+  }
+
+  ///
+  // Called on the IO thread before a resource request is loaded. The |request|
+  // object may be modified. Return RV_CONTINUE to continue the request
+  // immediately. Return RV_CONTINUE_ASYNC and call CefRequestCallback::
+  // Continue() at a later time to continue or cancel the request
+  // asynchronously. Return RV_CANCEL to cancel the request immediately.
+  // 
+  ///
+  /*--cef(default_retval=RV_CONTINUE)--*/
+  virtual ReturnValue OnBeforeResourceLoad(
+      CefRefPtr<CefBrowser> browser,
+      CefRefPtr<CefFrame> frame,
+      CefRefPtr<CefRequest> request,
+      CefRefPtr<CefRequestCallback> callback) {
+    return RV_CONTINUE;
+  }
+
+  ///
+  // Called on the IO thread before a resource is loaded. To allow the resource
+  // to load normally return NULL. To specify a handler for the resource return
+  // a CefResourceHandler object. The |request| object should not be modified in
+  // this callback.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefResourceHandler> GetResourceHandler(
+      CefRefPtr<CefBrowser> browser,
+      CefRefPtr<CefFrame> frame,
+      CefRefPtr<CefRequest> request) {
+    return NULL;
+  }
+
+  ///
+  // Called on the IO thread when a resource load is redirected. The |request|
+  // parameter will contain the old URL and other request-related information.
+  // The |new_url| parameter will contain the new URL and can be changed if
+  // desired. The |request| object cannot be modified in this callback.
+  ///
+  /*--cef()--*/
+  virtual void OnResourceRedirect(CefRefPtr<CefBrowser> browser,
+                                  CefRefPtr<CefFrame> frame,
+                                  CefRefPtr<CefRequest> request,
+                                  CefString& new_url) {}
+
+  ///
+  // Called on the IO thread when a resource response is received. To allow the
+  // resource to load normally return false. To redirect or retry the resource
+  // modify |request| (url, headers or post body) and return true. The
+  // |response| object cannot be modified in this callback.
+  ///
+  /*--cef()--*/
+  virtual bool OnResourceResponse(CefRefPtr<CefBrowser> browser,
+                                  CefRefPtr<CefFrame> frame,
+                                  CefRefPtr<CefRequest> request,
+                                  CefRefPtr<CefResponse> response) {
+    return false;
+  }
+
+  ///
+  // Called on the IO thread to optionally filter resource response content.
+  // |request| and |response| represent the request and response respectively
+  // and cannot be modified in this callback.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefResponseFilter> GetResourceResponseFilter(
+      CefRefPtr<CefBrowser> browser,
+      CefRefPtr<CefFrame> frame,
+      CefRefPtr<CefRequest> request,
+      CefRefPtr<CefResponse> response) {
+    return NULL;
+  }
+
+  ///
+  // Called on the IO thread when a resource load has completed. |request| and
+  // |response| represent the request and response respectively and cannot be
+  // modified in this callback. |status| indicates the load completion status.
+  // |received_content_length| is the number of response bytes actually read.
+  ///
+  /*--cef()--*/
+  virtual void OnResourceLoadComplete(CefRefPtr<CefBrowser> browser,
+                                      CefRefPtr<CefFrame> frame,
+                                      CefRefPtr<CefRequest> request,
+                                      CefRefPtr<CefResponse> response,
+                                      URLRequestStatus status,
+                                      int64 received_content_length) {}
+
+  ///
+  // Called on the IO thread when the browser needs credentials from the user.
+  // |isProxy| indicates whether the host is a proxy server. |host| contains the
+  // hostname and |port| contains the port number. |realm| is the realm of the
+  // challenge and may be empty. |scheme| is the authentication scheme used,
+  // such as "basic" or "digest", and will be empty if the source of the request
+  // is an FTP server. Return true to continue the request and call
+  // CefAuthCallback::Continue() either in this method or at a later time when
+  // the authentication information is available. Return false to cancel the
+  // request immediately.
+  ///
+  /*--cef(optional_param=realm,optional_param=scheme)--*/
+  virtual bool GetAuthCredentials(CefRefPtr<CefBrowser> browser,
+                                  CefRefPtr<CefFrame> frame,
+                                  bool isProxy,
+                                  const CefString& host,
+                                  int port,
+                                  const CefString& realm,
+                                  const CefString& scheme,
+                                  CefRefPtr<CefAuthCallback> callback) {
+    return false;
+  }
+
+  ///
+  // Called on the IO thread when JavaScript requests a specific storage quota
+  // size via the webkitStorageInfo.requestQuota function. |origin_url| is the
+  // origin of the page making the request. |new_size| is the requested quota
+  // size in bytes. Return true to continue the request and call
+  // CefRequestCallback::Continue() either in this method or at a later time to
+  // grant or deny the request. Return false to cancel the request immediately.
+  ///
+  /*--cef()--*/
+  virtual bool OnQuotaRequest(CefRefPtr<CefBrowser> browser,
+                              const CefString& origin_url,
+                              int64 new_size,
+                              CefRefPtr<CefRequestCallback> callback) {
+    return false;
+  }
+
+  ///
+  // Called on the UI thread to handle requests for URLs with an unknown
+  // protocol component. Set |allow_os_execution| to true to attempt execution
+  // via the registered OS protocol handler, if any.
+  // SECURITY WARNING: YOU SHOULD USE THIS METHOD TO ENFORCE RESTRICTIONS BASED
+  // ON SCHEME, HOST OR OTHER URL ANALYSIS BEFORE ALLOWING OS EXECUTION.
+  ///
+  /*--cef()--*/
+  virtual void OnProtocolExecution(CefRefPtr<CefBrowser> browser,
+                                   const CefString& url,
+                                   bool& allow_os_execution) {}
+
+  ///
+  // Called on the UI thread to handle requests for URLs with an invalid
+  // SSL certificate. Return true and call CefRequestCallback::Continue() either
+  // in this method or at a later time to continue or cancel the request. Return
+  // false to cancel the request immediately. If
+  // CefSettings.ignore_certificate_errors is set all invalid certificates will
+  // be accepted without calling this method.
+  ///
+  /*--cef()--*/
+  virtual bool OnCertificateError(
+      CefRefPtr<CefBrowser> browser,
+      cef_errorcode_t cert_error,
+      const CefString& request_url,
+      CefRefPtr<CefSSLInfo> ssl_info,
+      CefRefPtr<CefRequestCallback> callback) {
+    return false;
+  }
+
+  ///
+  // Called on the browser process UI thread when a plugin has crashed.
+  // |plugin_path| is the path of the plugin that crashed.
+  ///
+  /*--cef()--*/
+  virtual void OnPluginCrashed(CefRefPtr<CefBrowser> browser,
+                               const CefString& plugin_path) {}
+
+  ///
+  // Called on the browser process UI thread when the render view associated
+  // with |browser| is ready to receive/handle IPC messages in the render
+  // process.
+  ///
+  /*--cef()--*/
+  virtual void OnRenderViewReady(CefRefPtr<CefBrowser> browser) {}
+
+  ///
+  // Called on the browser process UI thread when the render process
+  // terminates unexpectedly. |status| indicates how the process
+  // terminated.
+  ///
+  /*--cef()--*/
+  virtual void OnRenderProcessTerminated(CefRefPtr<CefBrowser> browser,
+                                         TerminationStatus status) {}
+};
+
+#endif  // CEF_INCLUDE_CEF_REQUEST_HANDLER_H_
diff --git a/src/include/libcef/cef_resource_bundle.h b/src/include/libcef/cef_resource_bundle.h
new file mode 100644
index 0000000..3b064ff
--- /dev/null
+++ b/src/include/libcef/cef_resource_bundle.h
@@ -0,0 +1,99 @@
+// Copyright (c) 2015 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_RESOURCE_BUNDLE_H_
+#define CEF_INCLUDE_CEF_RESOURCE_BUNDLE_H_
+#pragma once
+
+#include "include/cef_base.h"
+
+///
+// Class used for retrieving resources from the resource bundle (*.pak) files
+// loaded by CEF during startup or via the CefResourceBundleHandler returned
+// from CefApp::GetResourceBundleHandler. See CefSettings for additional options
+// related to resource bundle loading. The methods of this class may be called
+// on any thread unless otherwise indicated.
+///
+/*--cef(source=library,no_debugct_check)--*/
+class CefResourceBundle : public virtual CefBase {
+ public:
+  typedef cef_scale_factor_t ScaleFactor;
+
+  ///
+  // Returns the global resource bundle instance.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefResourceBundle> GetGlobal();
+
+  ///
+  // Returns the localized string for the specified |string_id| or an empty
+  // string if the value is not found. Include cef_pack_strings.h for a listing
+  // of valid string ID values.
+  ///
+  /*--cef()--*/
+  virtual CefString GetLocalizedString(int string_id) =0;
+
+  ///
+  // Retrieves the contents of the specified scale independent |resource_id|.
+  // If the value is found then |data| and |data_size| will be populated and
+  // this method will return true. If the value is not found then this method
+  // will return false. The returned |data| pointer will remain resident in
+  // memory and should not be freed. Include cef_pack_resources.h for a listing
+  // of valid resource ID values.
+  ///
+  /*--cef()--*/
+  virtual bool GetDataResource(int resource_id,
+                               void*& data,
+                               size_t& data_size) =0;
+
+  ///
+  // Retrieves the contents of the specified |resource_id| nearest the scale
+  // factor |scale_factor|. Use a |scale_factor| value of SCALE_FACTOR_NONE for
+  // scale independent resources or call GetDataResource instead. If the value
+  // is found then |data| and |data_size| will be populated and this method will
+  // return true. If the value is not found then this method will return false.
+  // The returned |data| pointer will remain resident in memory and should not
+  // be freed. Include cef_pack_resources.h for a listing of valid resource ID
+  // values.
+  ///
+  /*--cef()--*/
+  virtual bool GetDataResourceForScale(int resource_id,
+                                       ScaleFactor scale_factor,
+                                       void*& data,
+                                       size_t& data_size) =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_RESOURCE_BUNDLE_H_
diff --git a/src/include/libcef/cef_resource_bundle_handler.h b/src/include/libcef/cef_resource_bundle_handler.h
new file mode 100644
index 0000000..afc46da
--- /dev/null
+++ b/src/include/libcef/cef_resource_bundle_handler.h
@@ -0,0 +1,91 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_RESOURCE_BUNDLE_HANDLER_H_
+#define CEF_INCLUDE_CEF_RESOURCE_BUNDLE_HANDLER_H_
+#pragma once
+
+#include "include/cef_base.h"
+
+///
+// Class used to implement a custom resource bundle interface. See CefSettings
+// for additional options related to resource bundle loading. The methods of
+// this class may be called on multiple threads.
+///
+/*--cef(source=client)--*/
+class CefResourceBundleHandler : public virtual CefBase {
+ public:
+  typedef cef_scale_factor_t ScaleFactor;
+
+  ///
+  // Called to retrieve a localized translation for the specified |string_id|.
+  // To provide the translation set |string| to the translation string and
+  // return true. To use the default translation return false. Include
+  // cef_pack_strings.h for a listing of valid string ID values.
+  ///
+  /*--cef()--*/
+  virtual bool GetLocalizedString(int string_id,
+                                  CefString& string) =0;
+
+  ///
+  // Called to retrieve data for the specified scale independent |resource_id|.
+  // To provide the resource data set |data| and |data_size| to the data pointer
+  // and size respectively and return true. To use the default resource data
+  // return false. The resource data will not be copied and must remain resident
+  // in memory. Include cef_pack_resources.h for a listing of valid resource ID
+  // values.
+  ///
+  /*--cef()--*/
+  virtual bool GetDataResource(int resource_id,
+                               void*& data,
+                               size_t& data_size) =0;
+
+  ///
+  // Called to retrieve data for the specified |resource_id| nearest the scale
+  // factor |scale_factor|. To provide the resource data set |data| and
+  // |data_size| to the data pointer and size respectively and return true. To
+  // use the default resource data return false. The resource data will not be
+  // copied and must remain resident in memory. Include cef_pack_resources.h for
+  // a listing of valid resource ID values.
+  ///
+  /*--cef()--*/
+  virtual bool GetDataResourceForScale(int resource_id,
+                                       ScaleFactor scale_factor,
+                                       void*& data,
+                                       size_t& data_size) =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_RESOURCE_BUNDLE_HANDLER_H_
diff --git a/src/include/libcef/cef_resource_handler.h b/src/include/libcef/cef_resource_handler.h
new file mode 100644
index 0000000..19913c7
--- /dev/null
+++ b/src/include/libcef/cef_resource_handler.h
@@ -0,0 +1,117 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_RESOURCE_HANDLER_H_
+#define CEF_INCLUDE_CEF_RESOURCE_HANDLER_H_
+#pragma once
+
+#include "include/cef_base.h"
+#include "include/cef_browser.h"
+#include "include/cef_callback.h"
+#include "include/cef_cookie.h"
+#include "include/cef_request.h"
+#include "include/cef_response.h"
+
+///
+// Class used to implement a custom request handler interface. The methods of
+// this class will always be called on the IO thread.
+///
+/*--cef(source=client)--*/
+class CefResourceHandler : public virtual CefBase {
+ public:
+  ///
+  // Begin processing the request. To handle the request return true and call
+  // CefCallback::Continue() once the response header information is available
+  // (CefCallback::Continue() can also be called from inside this method if
+  // header information is available immediately). To cancel the request return
+  // false.
+  ///
+  /*--cef()--*/
+  virtual bool ProcessRequest(CefRefPtr<CefRequest> request,
+                              CefRefPtr<CefCallback> callback) =0;
+
+  ///
+  // Retrieve response header information. If the response length is not known
+  // set |response_length| to -1 and ReadResponse() will be called until it
+  // returns false. If the response length is known set |response_length|
+  // to a positive value and ReadResponse() will be called until it returns
+  // false or the specified number of bytes have been read. Use the |response|
+  // object to set the mime type, http status code and other optional header
+  // values. To redirect the request to a new URL set |redirectUrl| to the new
+  // URL. If an error occured while setting up the request you can call
+  // SetError() on |response| to indicate the error condition.
+  ///
+  /*--cef()--*/
+  virtual void GetResponseHeaders(CefRefPtr<CefResponse> response,
+                                  int64& response_length,
+                                  CefString& redirectUrl) =0;
+
+  ///
+  // Read response data. If data is available immediately copy up to
+  // |bytes_to_read| bytes into |data_out|, set |bytes_read| to the number of
+  // bytes copied, and return true. To read the data at a later time set
+  // |bytes_read| to 0, return true and call CefCallback::Continue() when the
+  // data is available. To indicate response completion return false.
+  ///
+  /*--cef()--*/
+  virtual bool ReadResponse(void* data_out,
+                            int bytes_to_read,
+                            int& bytes_read,
+                            CefRefPtr<CefCallback> callback) =0;
+
+  ///
+  // Return true if the specified cookie can be sent with the request or false
+  // otherwise. If false is returned for any cookie then no cookies will be sent
+  // with the request.
+  ///
+  /*--cef()--*/
+  virtual bool CanGetCookie(const CefCookie& cookie) { return true; }
+
+  ///
+  // Return true if the specified cookie returned with the response can be set
+  // or false otherwise.
+  ///
+  /*--cef()--*/
+  virtual bool CanSetCookie(const CefCookie& cookie) { return true; }
+
+  ///
+  // Request processing has been canceled.
+  ///
+  /*--cef()--*/
+  virtual void Cancel() =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_RESOURCE_HANDLER_H_
diff --git a/src/include/libcef/cef_response.h b/src/include/libcef/cef_response.h
new file mode 100644
index 0000000..6fcb4e2
--- /dev/null
+++ b/src/include/libcef/cef_response.h
@@ -0,0 +1,133 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_RESPONSE_H_
+#define CEF_INCLUDE_CEF_RESPONSE_H_
+#pragma once
+
+#include "include/cef_base.h"
+#include <map>
+
+///
+// Class used to represent a web response. The methods of this class may be
+// called on any thread.
+///
+/*--cef(source=library,no_debugct_check)--*/
+class CefResponse : public virtual CefBase {
+ public:
+  typedef std::multimap<CefString, CefString> HeaderMap;
+
+  ///
+  // Create a new CefResponse object.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefResponse> Create();
+
+  ///
+  // Returns true if this object is read-only.
+  ///
+  /*--cef()--*/
+  virtual bool IsReadOnly() =0;
+
+  ///
+  // Get the response error code. Returns ERR_NONE if there was no error.
+  ///
+  /*--cef(default_retval=ERR_NONE)--*/
+  virtual cef_errorcode_t GetError() = 0;
+
+  ///
+  // Set the response error code. This can be used by custom scheme handlers
+  // to return errors during initial request processing.
+  ///
+  /*--cef()--*/
+  virtual void SetError(cef_errorcode_t error) = 0;
+
+  ///
+  // Get the response status code.
+  ///
+  /*--cef()--*/
+  virtual int GetStatus() =0;
+
+  ///
+  // Set the response status code.
+  ///
+  /*--cef()--*/
+  virtual void SetStatus(int status) = 0;
+
+  ///
+  // Get the response status text.
+  ///
+  /*--cef()--*/
+  virtual CefString GetStatusText() =0;
+
+  ///
+  // Set the response status text.
+  ///
+  /*--cef()--*/
+  virtual void SetStatusText(const CefString& statusText) = 0;
+
+  ///
+  // Get the response mime type.
+  ///
+  /*--cef()--*/
+  virtual CefString GetMimeType() = 0;
+
+  ///
+  // Set the response mime type.
+  ///
+  /*--cef()--*/
+  virtual void SetMimeType(const CefString& mimeType) = 0;
+
+  ///
+  // Get the value for the specified response header field.
+  ///
+  /*--cef()--*/
+  virtual CefString GetHeader(const CefString& name) =0;
+
+  ///
+  // Get all response header fields.
+  ///
+  /*--cef()--*/
+  virtual void GetHeaderMap(HeaderMap& headerMap) =0;
+
+  ///
+  // Set all response header fields.
+  ///
+  /*--cef()--*/
+  virtual void SetHeaderMap(const HeaderMap& headerMap) =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_RESPONSE_H_
diff --git a/src/include/libcef/cef_response_filter.h b/src/include/libcef/cef_response_filter.h
new file mode 100644
index 0000000..594d4a9
--- /dev/null
+++ b/src/include/libcef/cef_response_filter.h
@@ -0,0 +1,86 @@
+// Copyright (c) 2015 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_RESPONSE_FILTER_H_
+#define CEF_INCLUDE_CEF_RESPONSE_FILTER_H_
+#pragma once
+
+#include "include/cef_base.h"
+
+///
+// Implement this interface to filter resource response content. The methods of
+// this class will be called on the browser process IO thread.
+///
+/*--cef(source=client)--*/
+class CefResponseFilter : public virtual CefBase {
+ public:
+  typedef cef_response_filter_status_t FilterStatus;
+
+  ///
+  // Initialize the response filter. Will only be called a single time. The
+  // filter will not be installed if this method returns false.
+  ///
+  /*--cef()--*/
+  virtual bool InitFilter() =0;
+
+  ///
+  // Called to filter a chunk of data. |data_in| is the input buffer containing
+  // |data_in_size| bytes of pre-filter data (|data_in| will be NULL if
+  // |data_in_size| is zero). |data_out| is the output buffer that can accept up
+  // to |data_out_size| bytes of filtered output data. Set |data_in_read| to the
+  // number of bytes that were read from |data_in|. Set |data_out_written| to
+  // the number of bytes that were written into |data_out|. If some or all of
+  // the pre-filter data was read successfully but more data is needed in order
+  // to continue filtering (filtered output is pending) return
+  // RESPONSE_FILTER_NEED_MORE_DATA. If some or all of the pre-filter data was
+  // read successfully and all available filtered output has been written return
+  // RESPONSE_FILTER_DONE. If an error occurs during filtering return
+  // RESPONSE_FILTER_ERROR. This method will be called repeatedly until there is
+  // no more data to filter (resource response is complete), |data_in_read|
+  // matches |data_in_size| (all available pre-filter bytes have been read), and
+  // the method returns RESPONSE_FILTER_DONE or RESPONSE_FILTER_ERROR. Do not
+  // keep a reference to the buffers passed to this method.
+  ///
+  /*--cef(optional_param=data_in,default_retval=RESPONSE_FILTER_ERROR)--*/
+  virtual FilterStatus Filter(void* data_in,
+                              size_t data_in_size,
+                              size_t& data_in_read,
+                              void* data_out,
+                              size_t data_out_size,
+                              size_t& data_out_written) =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_RESPONSE_FILTER_H_
diff --git a/src/include/libcef/cef_sandbox_win.h b/src/include/libcef/cef_sandbox_win.h
new file mode 100644
index 0000000..9b6c48b
--- /dev/null
+++ b/src/include/libcef/cef_sandbox_win.h
@@ -0,0 +1,92 @@
+// Copyright (c) 2013 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef CEF_INCLUDE_CEF_SANDBOX_WIN_H_
+#define CEF_INCLUDE_CEF_SANDBOX_WIN_H_
+#pragma once
+
+#include "include/cef_base.h"
+
+#if defined(OS_WIN)
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// The sandbox is used to restrict sub-processes (renderer, plugin, GPU, etc)
+// from directly accessing system resources. This helps to protect the user
+// from untrusted and potentially malicious Web content.
+// See http://www.chromium.org/developers/design-documents/sandbox for
+// complete details.
+//
+// To enable the sandbox on Windows the following requirements must be met:
+// 1. Use the same executable for the browser process and all sub-processes.
+// 2. Link the executable with the cef_sandbox static library.
+// 3. Call the cef_sandbox_info_create() function from within the executable
+//    (not from a separate DLL) and pass the resulting pointer into both the
+//    CefExecutProcess() and CefInitialize() functions via the
+//    |windows_sandbox_info| parameter.
+
+///
+// Create the sandbox information object for this process. It is safe to create
+// multiple of this object and to destroy the object immediately after passing
+// into the CefExecutProcess() and/or CefInitialize() functions.
+///
+void* cef_sandbox_info_create();
+
+///
+// Destroy the specified sandbox information object.
+///
+void cef_sandbox_info_destroy(void* sandbox_info);
+
+#ifdef __cplusplus
+}
+
+///
+// Manages the life span of a sandbox information object.
+///
+class CefScopedSandboxInfo {
+ public:
+  CefScopedSandboxInfo() {
+    sandbox_info_ = cef_sandbox_info_create();
+  }
+  ~CefScopedSandboxInfo() {
+    cef_sandbox_info_destroy(sandbox_info_);
+  }
+
+  void* sandbox_info() const { return sandbox_info_; }
+
+ private:
+  void* sandbox_info_;
+};
+#endif  // __cplusplus
+
+#endif  // defined(OS_WIN)
+
+#endif  // CEF_INCLUDE_CEF_SANDBOX_WIN_H_
diff --git a/src/include/libcef/cef_scheme.h b/src/include/libcef/cef_scheme.h
new file mode 100644
index 0000000..a966a9a
--- /dev/null
+++ b/src/include/libcef/cef_scheme.h
@@ -0,0 +1,164 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_SCHEME_H_
+#define CEF_INCLUDE_CEF_SCHEME_H_
+#pragma once
+
+#include "include/cef_base.h"
+#include "include/cef_browser.h"
+#include "include/cef_frame.h"
+#include "include/cef_request.h"
+#include "include/cef_response.h"
+#include "include/cef_resource_handler.h"
+
+class CefSchemeHandlerFactory;
+
+
+///
+// Register a scheme handler factory with the global request context. An empty
+// |domain_name| value for a standard scheme will cause the factory to match all
+// domain names. The |domain_name| value will be ignored for non-standard
+// schemes. If |scheme_name| is a built-in scheme and no handler is returned by
+// |factory| then the built-in scheme handler factory will be called. If
+// |scheme_name| is a custom scheme then you must also implement the
+// CefApp::OnRegisterCustomSchemes() method in all processes. This function may
+// be called multiple times to change or remove the factory that matches the
+// specified |scheme_name| and optional |domain_name|. Returns false if an error
+// occurs. This function may be called on any thread in the browser process.
+// Using this function is equivalent to calling
+// CefRequestContext::GetGlobalContext()->RegisterSchemeHandlerFactory().
+///
+/*--cef(optional_param=domain_name,optional_param=factory)--*/
+bool CefRegisterSchemeHandlerFactory(
+    const CefString& scheme_name,
+    const CefString& domain_name,
+    CefRefPtr<CefSchemeHandlerFactory> factory);
+
+///
+// Clear all scheme handler factories registered with the global request
+// context. Returns false on error. This function may be called on any thread in
+// the browser process. Using this function is equivalent to calling
+// CefRequestContext::GetGlobalContext()->ClearSchemeHandlerFactories().
+///
+/*--cef()--*/
+bool CefClearSchemeHandlerFactories();
+
+
+///
+// Class that manages custom scheme registrations.
+///
+/*--cef(source=library)--*/
+class CefSchemeRegistrar : public virtual CefBase {
+ public:
+  ///
+  // Register a custom scheme. This method should not be called for the built-in
+  // HTTP, HTTPS, FILE, FTP, ABOUT and DATA schemes.
+  //
+  // If |is_standard| is true the scheme will be treated as a standard scheme.
+  // Standard schemes are subject to URL canonicalization and parsing rules as
+  // defined in the Common Internet Scheme Syntax RFC 1738 Section 3.1 available
+  // at http://www.ietf.org/rfc/rfc1738.txt
+  //
+  // In particular, the syntax for standard scheme URLs must be of the form:
+  // <pre>
+  //  [scheme]://[username]:[password]@[host]:[port]/[url-path]
+  // </pre>
+  // Standard scheme URLs must have a host component that is a fully qualified
+  // domain name as defined in Section 3.5 of RFC 1034 [13] and Section 2.1 of
+  // RFC 1123. These URLs will be canonicalized to "scheme://host/path" in the
+  // simplest case and "scheme://username:password@host:port/path" in the most
+  // explicit case. For example, "scheme:host/path" and "scheme:///host/path"
+  // will both be canonicalized to "scheme://host/path". The origin of a
+  // standard scheme URL is the combination of scheme, host and port (i.e.,
+  // "scheme://host:port" in the most explicit case).
+  //
+  // For non-standard scheme URLs only the "scheme:" component is parsed and
+  // canonicalized. The remainder of the URL will be passed to the handler
+  // as-is. For example, "scheme:///some%20text" will remain the same.
+  // Non-standard scheme URLs cannot be used as a target for form submission.
+  //
+  // If |is_local| is true the scheme will be treated as local (i.e., with the
+  // same security rules as those applied to "file" URLs). Normal pages cannot
+  // link to or access local URLs. Also, by default, local URLs can only perform
+  // XMLHttpRequest calls to the same URL (origin + path) that originated the
+  // request. To allow XMLHttpRequest calls from a local URL to other URLs with
+  // the same origin set the CefSettings.file_access_from_file_urls_allowed
+  // value to true. To allow XMLHttpRequest calls from a local URL to all
+  // origins set the CefSettings.universal_access_from_file_urls_allowed value
+  // to true.
+  //
+  // If |is_display_isolated| is true the scheme will be treated as display-
+  // isolated. This means that pages cannot display these URLs unless they are
+  // from the same scheme. For example, pages in another origin cannot create
+  // iframes or hyperlinks to URLs with this scheme.
+  //
+  // This function may be called on any thread. It should only be called once
+  // per unique |scheme_name| value. If |scheme_name| is already registered or
+  // if an error occurs this method will return false.
+  ///
+  /*--cef()--*/
+  virtual bool AddCustomScheme(const CefString& scheme_name,
+                               bool is_standard,
+                               bool is_local,
+                               bool is_display_isolated) =0;
+};
+
+
+///
+// Class that creates CefResourceHandler instances for handling scheme requests.
+// The methods of this class will always be called on the IO thread.
+///
+/*--cef(source=client)--*/
+class CefSchemeHandlerFactory : public virtual CefBase {
+ public:
+  ///
+  // Return a new resource handler instance to handle the request or an empty
+  // reference to allow default handling of the request. |browser| and |frame|
+  // will be the browser window and frame respectively that originated the
+  // request or NULL if the request did not originate from a browser window
+  // (for example, if the request came from CefURLRequest). The |request| object
+  // passed to this method will not contain cookie data.
+  ///
+  /*--cef(optional_param=browser,optional_param=frame)--*/
+  virtual CefRefPtr<CefResourceHandler> Create(
+      CefRefPtr<CefBrowser> browser,
+      CefRefPtr<CefFrame> frame,
+      const CefString& scheme_name,
+      CefRefPtr<CefRequest> request) =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_SCHEME_H_
diff --git a/src/include/libcef/cef_ssl_info.h b/src/include/libcef/cef_ssl_info.h
new file mode 100644
index 0000000..1ebc894
--- /dev/null
+++ b/src/include/libcef/cef_ssl_info.h
@@ -0,0 +1,207 @@
+// Copyright (c) 2015 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_SSL_INFO_H_
+#define CEF_INCLUDE_CEF_SSL_INFO_H_
+#pragma once
+
+#include <vector>
+
+#include "include/cef_base.h"
+#include "include/cef_values.h"
+
+///
+// Class representing the issuer or subject field of an X.509 certificate.
+///
+/*--cef(source=library)--*/
+class CefSSLCertPrincipal : public virtual CefBase {
+ public:
+  ///
+  // Returns a name that can be used to represent the issuer.  It tries in this
+  // order: CN, O and OU and returns the first non-empty one found.
+  ///
+  /*--cef()--*/
+  virtual CefString GetDisplayName() =0;
+
+  ///
+  // Returns the common name.
+  ///
+  /*--cef()--*/
+  virtual CefString GetCommonName() =0;
+
+  ///
+  // Returns the locality name.
+  ///
+  /*--cef()--*/
+  virtual CefString GetLocalityName() =0;
+
+  ///
+  // Returns the state or province name.
+  ///
+  /*--cef()--*/
+  virtual CefString GetStateOrProvinceName() =0;
+
+  ///
+  // Returns the country name.
+  ///
+  /*--cef()--*/
+  virtual CefString GetCountryName() =0;
+
+  ///
+  // Retrieve the list of street addresses.
+  ///
+  /*--cef()--*/
+  virtual void GetStreetAddresses(std::vector<CefString>& addresses) =0;
+
+  ///
+  // Retrieve the list of organization names.
+  ///
+  /*--cef()--*/
+  virtual void GetOrganizationNames(std::vector<CefString>& names) =0;
+
+  ///
+  // Retrieve the list of organization unit names.
+  ///
+  /*--cef()--*/
+  virtual void GetOrganizationUnitNames(std::vector<CefString>& names) =0;
+
+  ///
+  // Retrieve the list of domain components.
+  ///
+  /*--cef()--*/
+  virtual void GetDomainComponents(std::vector<CefString>& components) =0;
+};
+
+///
+// Class representing SSL information.
+///
+/*--cef(source=library)--*/
+class CefSSLInfo : public virtual CefBase {
+ public:
+  typedef std::vector<CefRefPtr<CefBinaryValue> > IssuerChainBinaryList;
+
+  ///
+  // Returns a bitmask containing any and all problems verifying the server
+  // certificate.
+  ///
+  /*--cef(default_retval=CERT_STATUS_NONE)--*/
+  virtual cef_cert_status_t GetCertStatus() =0;
+
+  ///
+  // Returns true if the certificate status has any error, major or minor.
+  ///
+  /*--cef()--*/
+  virtual bool IsCertStatusError() =0;
+
+  ///
+  // Returns true if the certificate status represents only minor errors
+  // (e.g. failure to verify certificate revocation).
+  ///
+  /*--cef()--*/
+  virtual bool IsCertStatusMinorError() =0;
+
+  ///
+  // Returns the subject of the X.509 certificate. For HTTPS server
+  // certificates this represents the web server.  The common name of the
+  // subject should match the host name of the web server.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefSSLCertPrincipal> GetSubject() =0;
+
+  ///
+  // Returns the issuer of the X.509 certificate.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefSSLCertPrincipal> GetIssuer() =0;
+
+  ///
+  // Returns the DER encoded serial number for the X.509 certificate. The value
+  // possibly includes a leading 00 byte.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefBinaryValue> GetSerialNumber() =0;
+  
+  ///
+  // Returns the date before which the X.509 certificate is invalid.
+  // CefTime.GetTimeT() will return 0 if no date was specified.
+  ///
+  /*--cef()--*/
+  virtual CefTime GetValidStart() =0;
+
+  ///
+  // Returns the date after which the X.509 certificate is invalid.
+  // CefTime.GetTimeT() will return 0 if no date was specified.
+  ///
+  /*--cef()--*/
+  virtual CefTime GetValidExpiry() =0;
+
+  ///
+  // Returns the DER encoded data for the X.509 certificate.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefBinaryValue> GetDEREncoded() =0;
+
+  ///
+  // Returns the PEM encoded data for the X.509 certificate.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefBinaryValue> GetPEMEncoded() =0;
+
+  ///
+  // Returns the number of certificates in the issuer chain.
+  // If 0, the certificate is self-signed.
+  ///
+  /*--cef()--*/
+  virtual size_t GetIssuerChainSize() =0;
+
+  ///
+  // Returns the DER encoded data for the certificate issuer chain.
+  // If we failed to encode a certificate in the chain it is still
+  // present in the array but is an empty string.
+  ///
+  /*--cef(count_func=chain:GetIssuerChainSize)--*/
+  virtual void GetDEREncodedIssuerChain(IssuerChainBinaryList& chain) =0;
+
+  ///
+  // Returns the PEM encoded data for the certificate issuer chain.
+  // If we failed to encode a certificate in the chain it is still
+  // present in the array but is an empty string.
+  ///
+  /*--cef(count_func=chain:GetIssuerChainSize)--*/
+  virtual void GetPEMEncodedIssuerChain(IssuerChainBinaryList& chain) =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_SSL_INFO_H_
diff --git a/src/include/libcef/cef_stream.h b/src/include/libcef/cef_stream.h
new file mode 100644
index 0000000..3d0633c
--- /dev/null
+++ b/src/include/libcef/cef_stream.h
@@ -0,0 +1,242 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_STREAM_H_
+#define CEF_INCLUDE_CEF_STREAM_H_
+
+#include "include/cef_base.h"
+
+///
+// Interface the client can implement to provide a custom stream reader. The
+// methods of this class may be called on any thread.
+///
+/*--cef(source=client)--*/
+class CefReadHandler : public virtual CefBase {
+ public:
+  ///
+  // Read raw binary data.
+  ///
+  /*--cef()--*/
+  virtual size_t Read(void* ptr, size_t size, size_t n) =0;
+
+  ///
+  // Seek to the specified offset position. |whence| may be any one of
+  // SEEK_CUR, SEEK_END or SEEK_SET. Return zero on success and non-zero on
+  // failure.
+  ///
+  /*--cef()--*/
+  virtual int Seek(int64 offset, int whence) =0;
+
+  ///
+  // Return the current offset position.
+  ///
+  /*--cef()--*/
+  virtual int64 Tell() =0;
+
+  ///
+  // Return non-zero if at end of file.
+  ///
+  /*--cef()--*/
+  virtual int Eof() =0;
+
+  ///
+  // Return true if this handler performs work like accessing the file system
+  // which may block. Used as a hint for determining the thread to access the
+  // handler from.
+  ///
+  /*--cef()--*/
+  virtual bool MayBlock() =0;
+};
+
+
+///
+// Class used to read data from a stream. The methods of this class may be
+// called on any thread.
+///
+/*--cef(source=library)--*/
+class CefStreamReader : public virtual CefBase {
+ public:
+  ///
+  // Create a new CefStreamReader object from a file.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefStreamReader> CreateForFile(const CefString& fileName);
+  ///
+  // Create a new CefStreamReader object from data.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefStreamReader> CreateForData(void* data, size_t size);
+  ///
+  // Create a new CefStreamReader object from a custom handler.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefStreamReader> CreateForHandler(
+      CefRefPtr<CefReadHandler> handler);
+
+  ///
+  // Read raw binary data.
+  ///
+  /*--cef()--*/
+  virtual size_t Read(void* ptr, size_t size, size_t n) =0;
+
+  ///
+  // Seek to the specified offset position. |whence| may be any one of
+  // SEEK_CUR, SEEK_END or SEEK_SET. Returns zero on success and non-zero on
+  // failure.
+  ///
+  /*--cef()--*/
+  virtual int Seek(int64 offset, int whence) =0;
+
+  ///
+  // Return the current offset position.
+  ///
+  /*--cef()--*/
+  virtual int64 Tell() =0;
+
+  ///
+  // Return non-zero if at end of file.
+  ///
+  /*--cef()--*/
+  virtual int Eof() =0;
+
+  ///
+  // Returns true if this reader performs work like accessing the file system
+  // which may block. Used as a hint for determining the thread to access the
+  // reader from.
+  ///
+  /*--cef()--*/
+  virtual bool MayBlock() =0;
+};
+
+
+///
+// Interface the client can implement to provide a custom stream writer. The
+// methods of this class may be called on any thread.
+///
+/*--cef(source=client)--*/
+class CefWriteHandler : public virtual CefBase {
+ public:
+  ///
+  // Write raw binary data.
+  ///
+  /*--cef()--*/
+  virtual size_t Write(const void* ptr, size_t size, size_t n) =0;
+
+  ///
+  // Seek to the specified offset position. |whence| may be any one of
+  // SEEK_CUR, SEEK_END or SEEK_SET. Return zero on success and non-zero on
+  // failure.
+  ///
+  /*--cef()--*/
+  virtual int Seek(int64 offset, int whence) =0;
+
+  ///
+  // Return the current offset position.
+  ///
+  /*--cef()--*/
+  virtual int64 Tell() =0;
+
+  ///
+  // Flush the stream.
+  ///
+  /*--cef()--*/
+  virtual int Flush() =0;
+
+  ///
+  // Return true if this handler performs work like accessing the file system
+  // which may block. Used as a hint for determining the thread to access the
+  // handler from.
+  ///
+  /*--cef()--*/
+  virtual bool MayBlock() =0;
+};
+
+
+///
+// Class used to write data to a stream. The methods of this class may be called
+// on any thread.
+///
+/*--cef(source=library)--*/
+class CefStreamWriter : public virtual CefBase {
+ public:
+  ///
+  // Create a new CefStreamWriter object for a file.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefStreamWriter> CreateForFile(const CefString& fileName);
+  ///
+  // Create a new CefStreamWriter object for a custom handler.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefStreamWriter> CreateForHandler(
+      CefRefPtr<CefWriteHandler> handler);
+
+  ///
+  // Write raw binary data.
+  ///
+  /*--cef()--*/
+  virtual size_t Write(const void* ptr, size_t size, size_t n) =0;
+
+  ///
+  // Seek to the specified offset position. |whence| may be any one of
+  // SEEK_CUR, SEEK_END or SEEK_SET. Returns zero on success and non-zero on
+  // failure.
+  ///
+  /*--cef()--*/
+  virtual int Seek(int64 offset, int whence) =0;
+
+  ///
+  // Return the current offset position.
+  ///
+  /*--cef()--*/
+  virtual int64 Tell() =0;
+
+  ///
+  // Flush the stream.
+  ///
+  /*--cef()--*/
+  virtual int Flush() =0;
+
+  ///
+  // Returns true if this writer performs work like accessing the file system
+  // which may block. Used as a hint for determining the thread to access the
+  // writer from.
+  ///
+  /*--cef()--*/
+  virtual bool MayBlock() =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_STREAM_H_
diff --git a/src/include/libcef/cef_string_visitor.h b/src/include/libcef/cef_string_visitor.h
new file mode 100644
index 0000000..5493714
--- /dev/null
+++ b/src/include/libcef/cef_string_visitor.h
@@ -0,0 +1,55 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_STRING_VISITOR_H_
+#define CEF_INCLUDE_CEF_STRING_VISITOR_H_
+
+#include "include/cef_base.h"
+
+///
+// Implement this interface to receive string values asynchronously.
+///
+/*--cef(source=client)--*/
+class CefStringVisitor : public virtual CefBase {
+ public:
+  ///
+  // Method that will be executed.
+  ///
+  /*--cef(optional_param=string)--*/
+  virtual void Visit(const CefString& string) =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_STRING_VISITOR_H_
diff --git a/src/include/libcef/cef_task.h b/src/include/libcef/cef_task.h
new file mode 100644
index 0000000..0ecaa75
--- /dev/null
+++ b/src/include/libcef/cef_task.h
@@ -0,0 +1,148 @@
+// Copyright (c) 2013 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_TASK_H_
+#define CEF_INCLUDE_CEF_TASK_H_
+
+#include "include/cef_base.h"
+
+typedef cef_thread_id_t CefThreadId;
+
+///
+// Implement this interface for asynchronous task execution. If the task is
+// posted successfully and if the associated message loop is still running then
+// the Execute() method will be called on the target thread. If the task fails
+// to post then the task object may be destroyed on the source thread instead of
+// the target thread. For this reason be cautious when performing work in the
+// task object destructor.
+///
+/*--cef(source=client)--*/
+class CefTask : public virtual CefBase {
+ public:
+  ///
+  // Method that will be executed on the target thread.
+  ///
+  /*--cef()--*/
+  virtual void Execute() =0;
+};
+
+///
+// Class that asynchronously executes tasks on the associated thread. It is safe
+// to call the methods of this class on any thread.
+//
+// CEF maintains multiple internal threads that are used for handling different
+// types of tasks in different processes. The cef_thread_id_t definitions in
+// cef_types.h list the common CEF threads. Task runners are also available for
+// other CEF threads as appropriate (for example, V8 WebWorker threads).
+///
+/*--cef(source=library)--*/
+class CefTaskRunner : public virtual CefBase {
+ public:
+  ///
+  // Returns the task runner for the current thread. Only CEF threads will have
+  // task runners. An empty reference will be returned if this method is called
+  // on an invalid thread.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefTaskRunner> GetForCurrentThread();
+
+  ///
+  // Returns the task runner for the specified CEF thread.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefTaskRunner> GetForThread(CefThreadId threadId);
+
+  ///
+  // Returns true if this object is pointing to the same task runner as |that|
+  // object.
+  ///
+  /*--cef()--*/
+  virtual bool IsSame(CefRefPtr<CefTaskRunner> that) =0;
+
+  ///
+  // Returns true if this task runner belongs to the current thread.
+  ///
+  /*--cef()--*/
+  virtual bool BelongsToCurrentThread() =0;
+
+  ///
+  // Returns true if this task runner is for the specified CEF thread.
+  ///
+  /*--cef()--*/
+  virtual bool BelongsToThread(CefThreadId threadId) =0;
+
+  ///
+  // Post a task for execution on the thread associated with this task runner.
+  // Execution will occur asynchronously.
+  ///
+  /*--cef()--*/
+  virtual bool PostTask(CefRefPtr<CefTask> task) =0;
+
+  ///
+  // Post a task for delayed execution on the thread associated with this task
+  // runner. Execution will occur asynchronously. Delayed tasks are not
+  // supported on V8 WebWorker threads and will be executed without the
+  // specified delay.
+  ///
+  /*--cef()--*/
+  virtual bool PostDelayedTask(CefRefPtr<CefTask> task, int64 delay_ms) =0;
+};
+
+
+///
+// Returns true if called on the specified thread. Equivalent to using
+// CefTaskRunner::GetForThread(threadId)->BelongsToCurrentThread().
+///
+/*--cef()--*/
+bool CefCurrentlyOn(CefThreadId threadId);
+
+///
+// Post a task for execution on the specified thread. Equivalent to
+// using CefTaskRunner::GetForThread(threadId)->PostTask(task).
+///
+/*--cef()--*/
+bool CefPostTask(CefThreadId threadId, CefRefPtr<CefTask> task);
+
+///
+// Post a task for delayed execution on the specified thread. Equivalent to
+// using CefTaskRunner::GetForThread(threadId)->PostDelayedTask(task, delay_ms).
+///
+/*--cef()--*/
+bool CefPostDelayedTask(CefThreadId threadId, CefRefPtr<CefTask> task,
+                        int64 delay_ms);
+
+
+#endif  // CEF_INCLUDE_CEF_TASK_H_
diff --git a/src/include/libcef/cef_trace.h b/src/include/libcef/cef_trace.h
new file mode 100644
index 0000000..5b977c6
--- /dev/null
+++ b/src/include/libcef/cef_trace.h
@@ -0,0 +1,111 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. Portons copyright (c) 2012
+// Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+// See cef_trace_event.h for trace macros and additonal documentation.
+
+#ifndef CEF_INCLUDE_CEF_TRACE_H_
+#define CEF_INCLUDE_CEF_TRACE_H_
+#pragma once
+
+#include "include/cef_base.h"
+#include "include/cef_callback.h"
+
+///
+// Implement this interface to receive notification when tracing has completed.
+// The methods of this class will be called on the browser process UI thread.
+///
+/*--cef(source=client)--*/
+class CefEndTracingCallback : public virtual CefBase {
+ public:
+  ///
+  // Called after all processes have sent their trace data. |tracing_file| is
+  // the path at which tracing data was written. The client is responsible for
+  // deleting |tracing_file|.
+  ///
+  /*--cef()--*/
+  virtual void OnEndTracingComplete(const CefString& tracing_file) =0;
+};
+
+
+///
+// Start tracing events on all processes. Tracing is initialized asynchronously
+// and |callback| will be executed on the UI thread after initialization is
+// complete.
+//
+// If CefBeginTracing was called previously, or if a CefEndTracingAsync call is
+// pending, CefBeginTracing will fail and return false.
+//
+// |categories| is a comma-delimited list of category wildcards. A category can
+// have an optional '-' prefix to make it an excluded category. Having both
+// included and excluded categories in the same list is not supported.
+//
+// Example: "test_MyTest*"
+// Example: "test_MyTest*,test_OtherStuff"
+// Example: "-excluded_category1,-excluded_category2"
+//
+// This function must be called on the browser process UI thread.
+///
+/*--cef(optional_param=categories,optional_param=callback)--*/
+bool CefBeginTracing(const CefString& categories,
+                     CefRefPtr<CefCompletionCallback> callback);
+
+///
+// Stop tracing events on all processes.
+//
+// This function will fail and return false if a previous call to
+// CefEndTracingAsync is already pending or if CefBeginTracing was not called.
+//
+// |tracing_file| is the path at which tracing data will be written and
+// |callback| is the callback that will be executed once all processes have
+// sent their trace data. If |tracing_file| is empty a new temporary file path
+// will be used. If |callback| is empty no trace data will be written.
+//
+// This function must be called on the browser process UI thread.
+///
+/*--cef(optional_param=tracing_file,optional_param=callback)--*/
+bool CefEndTracing(const CefString& tracing_file,
+                   CefRefPtr<CefEndTracingCallback> callback);
+
+///
+// Returns the current system trace time or, if none is defined, the current
+// high-res time. Can be used by clients to synchronize with the time
+// information in trace events.
+///
+/*--cef()--*/
+int64 CefNowFromSystemTraceTime();
+
+#endif  // CEF_INCLUDE_CEF_TRACE_H_
diff --git a/src/include/libcef/cef_urlrequest.h b/src/include/libcef/cef_urlrequest.h
new file mode 100644
index 0000000..5b58b63
--- /dev/null
+++ b/src/include/libcef/cef_urlrequest.h
@@ -0,0 +1,188 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_URLREQUEST_H_
+#define CEF_INCLUDE_CEF_URLREQUEST_H_
+#pragma once
+
+#include "include/cef_auth_callback.h"
+#include "include/cef_base.h"
+#include "include/cef_request.h"
+#include "include/cef_request_context.h"
+#include "include/cef_response.h"
+
+class CefURLRequestClient;
+
+///
+// Class used to make a URL request. URL requests are not associated with a
+// browser instance so no CefClient callbacks will be executed. URL requests
+// can be created on any valid CEF thread in either the browser or render
+// process. Once created the methods of the URL request object must be accessed
+// on the same thread that created it.
+///
+/*--cef(source=library)--*/
+class CefURLRequest : public virtual CefBase {
+ public:
+  typedef cef_urlrequest_status_t Status;
+  typedef cef_errorcode_t ErrorCode;
+
+  ///
+  // Create a new URL request. Only GET, POST, HEAD, DELETE and PUT request
+  // methods are supported. Multiple post data elements are not supported and
+  // elements of type PDE_TYPE_FILE are only supported for requests originating
+  // from the browser process. Requests originating from the render process will
+  // receive the same handling as requests originating from Web content -- if
+  // the response contains Content-Disposition or Mime-Type header values that
+  // would not normally be rendered then the response may receive special
+  // handling inside the browser (for example, via the file download code path
+  // instead of the URL request code path). The |request| object will be marked
+  // as read-only after calling this method. In the browser process if
+  // |request_context| is empty the global request context will be used. In the
+  // render process |request_context| must be empty and the context associated
+  // with the current renderer process' browser will be used.
+  ///
+  /*--cef(optional_param=request_context)--*/
+  static CefRefPtr<CefURLRequest> Create(
+      CefRefPtr<CefRequest> request,
+      CefRefPtr<CefURLRequestClient> client,
+      CefRefPtr<CefRequestContext> request_context);
+
+  ///
+  // Returns the request object used to create this URL request. The returned
+  // object is read-only and should not be modified.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefRequest> GetRequest() =0;
+
+  ///
+  // Returns the client.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefURLRequestClient> GetClient() =0;
+
+  ///
+  // Returns the request status.
+  ///
+  /*--cef(default_retval=UR_UNKNOWN)--*/
+  virtual Status GetRequestStatus() =0;
+
+  ///
+  // Returns the request error if status is UR_CANCELED or UR_FAILED, or 0
+  // otherwise.
+  ///
+  /*--cef(default_retval=ERR_NONE)--*/
+  virtual ErrorCode GetRequestError() =0;
+
+  ///
+  // Returns the response, or NULL if no response information is available.
+  // Response information will only be available after the upload has completed.
+  // The returned object is read-only and should not be modified.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefResponse> GetResponse() =0;
+
+  ///
+  // Cancel the request.
+  ///
+  /*--cef()--*/
+  virtual void Cancel() =0;
+};
+
+///
+// Interface that should be implemented by the CefURLRequest client. The
+// methods of this class will be called on the same thread that created the
+// request unless otherwise documented.
+///
+/*--cef(source=client)--*/
+class CefURLRequestClient : public virtual CefBase {
+ public:
+  ///
+  // Notifies the client that the request has completed. Use the
+  // CefURLRequest::GetRequestStatus method to determine if the request was
+  // successful or not.
+  ///
+  /*--cef()--*/
+  virtual void OnRequestComplete(CefRefPtr<CefURLRequest> request) =0;
+
+  ///
+  // Notifies the client of upload progress. |current| denotes the number of
+  // bytes sent so far and |total| is the total size of uploading data (or -1 if
+  // chunked upload is enabled). This method will only be called if the
+  // UR_FLAG_REPORT_UPLOAD_PROGRESS flag is set on the request.
+  ///
+  /*--cef()--*/
+  virtual void OnUploadProgress(CefRefPtr<CefURLRequest> request,
+                                int64 current,
+                                int64 total) =0;
+
+  ///
+  // Notifies the client of download progress. |current| denotes the number of
+  // bytes received up to the call and |total| is the expected total size of the
+  // response (or -1 if not determined).
+  ///
+  /*--cef()--*/
+  virtual void OnDownloadProgress(CefRefPtr<CefURLRequest> request,
+                                  int64 current,
+                                  int64 total) =0;
+
+  ///
+  // Called when some part of the response is read. |data| contains the current
+  // bytes received since the last call. This method will not be called if the
+  // UR_FLAG_NO_DOWNLOAD_DATA flag is set on the request.
+  ///
+  /*--cef()--*/
+  virtual void OnDownloadData(CefRefPtr<CefURLRequest> request,
+                              const void* data,
+                              size_t data_length) =0;
+
+  ///
+  // Called on the IO thread when the browser needs credentials from the user.
+  // |isProxy| indicates whether the host is a proxy server. |host| contains the
+  // hostname and |port| contains the port number. Return true to continue the
+  // request and call CefAuthCallback::Continue() when the authentication
+  // information is available. Return false to cancel the request. This method
+  // will only be called for requests initiated from the browser process.
+  ///
+  /*--cef(optional_param=realm)--*/
+  virtual bool GetAuthCredentials(bool isProxy,
+                                  const CefString& host,
+                                  int port,
+                                  const CefString& realm,
+                                  const CefString& scheme,
+                                  CefRefPtr<CefAuthCallback> callback) =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_URLREQUEST_H_
diff --git a/src/include/libcef/cef_v8.h b/src/include/libcef/cef_v8.h
new file mode 100644
index 0000000..070d439
--- /dev/null
+++ b/src/include/libcef/cef_v8.h
@@ -0,0 +1,879 @@
+// Copyright (c) 2013 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+
+#ifndef CEF_INCLUDE_CEF_V8_H_
+#define CEF_INCLUDE_CEF_V8_H_
+#pragma once
+
+#include "include/cef_base.h"
+#include "include/cef_browser.h"
+#include "include/cef_frame.h"
+#include "include/cef_task.h"
+#include <vector>
+
+class CefV8Exception;
+class CefV8Handler;
+class CefV8StackFrame;
+class CefV8Value;
+
+
+///
+// Register a new V8 extension with the specified JavaScript extension code and
+// handler. Functions implemented by the handler are prototyped using the
+// keyword 'native'. The calling of a native function is restricted to the scope
+// in which the prototype of the native function is defined. This function may
+// only be called on the render process main thread.
+//
+// Example JavaScript extension code:
+// <pre>
+//   // create the 'example' global object if it doesn't already exist.
+//   if (!example)
+//     example = {};
+//   // create the 'example.test' global object if it doesn't already exist.
+//   if (!example.test)
+//     example.test = {};
+//   (function() {
+//     // Define the function 'example.test.myfunction'.
+//     example.test.myfunction = function() {
+//       // Call CefV8Handler::Execute() with the function name 'MyFunction'
+//       // and no arguments.
+//       native function MyFunction();
+//       return MyFunction();
+//     };
+//     // Define the getter function for parameter 'example.test.myparam'.
+//     example.test.__defineGetter__('myparam', function() {
+//       // Call CefV8Handler::Execute() with the function name 'GetMyParam'
+//       // and no arguments.
+//       native function GetMyParam();
+//       return GetMyParam();
+//     });
+//     // Define the setter function for parameter 'example.test.myparam'.
+//     example.test.__defineSetter__('myparam', function(b) {
+//       // Call CefV8Handler::Execute() with the function name 'SetMyParam'
+//       // and a single argument.
+//       native function SetMyParam();
+//       if(b) SetMyParam(b);
+//     });
+//
+//     // Extension definitions can also contain normal JavaScript variables
+//     // and functions.
+//     var myint = 0;
+//     example.test.increment = function() {
+//       myint += 1;
+//       return myint;
+//     };
+//   })();
+// </pre>
+// Example usage in the page:
+// <pre>
+//   // Call the function.
+//   example.test.myfunction();
+//   // Set the parameter.
+//   example.test.myparam = value;
+//   // Get the parameter.
+//   value = example.test.myparam;
+//   // Call another function.
+//   example.test.increment();
+// </pre>
+///
+/*--cef(optional_param=handler)--*/
+bool CefRegisterExtension(const CefString& extension_name,
+                          const CefString& javascript_code,
+                          CefRefPtr<CefV8Handler> handler);
+
+
+///
+// Class representing a V8 context handle. V8 handles can only be accessed from
+// the thread on which they are created. Valid threads for creating a V8 handle
+// include the render process main thread (TID_RENDERER) and WebWorker threads.
+// A task runner for posting tasks on the associated thread can be retrieved via
+// the CefV8Context::GetTaskRunner() method.
+///
+/*--cef(source=library)--*/
+class CefV8Context : public virtual CefBase {
+ public:
+  ///
+  // Returns the current (top) context object in the V8 context stack.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefV8Context> GetCurrentContext();
+
+  ///
+  // Returns the entered (bottom) context object in the V8 context stack.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefV8Context> GetEnteredContext();
+
+  ///
+  // Returns true if V8 is currently inside a context.
+  ///
+  /*--cef()--*/
+  static bool InContext();
+
+  ///
+  // Returns the task runner associated with this context. V8 handles can only
+  // be accessed from the thread on which they are created. This method can be
+  // called on any render process thread.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefTaskRunner> GetTaskRunner() =0;
+
+  ///
+  // Returns true if the underlying handle is valid and it can be accessed on
+  // the current thread. Do not call any other methods if this method returns
+  // false.
+  ///
+  /*--cef()--*/
+  virtual bool IsValid() =0;
+
+  ///
+  // Returns the browser for this context. This method will return an empty
+  // reference for WebWorker contexts.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefBrowser> GetBrowser() =0;
+
+  ///
+  // Returns the frame for this context. This method will return an empty
+  // reference for WebWorker contexts.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefFrame> GetFrame() =0;
+
+  ///
+  // Returns the global object for this context. The context must be entered
+  // before calling this method.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefV8Value> GetGlobal() =0;
+
+  ///
+  // Enter this context. A context must be explicitly entered before creating a
+  // V8 Object, Array, Function or Date asynchronously. Exit() must be called
+  // the same number of times as Enter() before releasing this context. V8
+  // objects belong to the context in which they are created. Returns true if
+  // the scope was entered successfully.
+  ///
+  /*--cef()--*/
+  virtual bool Enter() =0;
+
+  ///
+  // Exit this context. Call this method only after calling Enter(). Returns
+  // true if the scope was exited successfully.
+  ///
+  /*--cef()--*/
+  virtual bool Exit() =0;
+
+  ///
+  // Returns true if this object is pointing to the same handle as |that|
+  // object.
+  ///
+  /*--cef()--*/
+  virtual bool IsSame(CefRefPtr<CefV8Context> that) =0;
+
+  ///
+  // Evaluates the specified JavaScript code using this context's global object.
+  // On success |retval| will be set to the return value, if any, and the
+  // function will return true. On failure |exception| will be set to the
+  // exception, if any, and the function will return false.
+  ///
+  /*--cef()--*/
+  virtual bool Eval(const CefString& code,
+                    CefRefPtr<CefV8Value>& retval,
+                    CefRefPtr<CefV8Exception>& exception) =0;
+};
+
+
+typedef std::vector<CefRefPtr<CefV8Value> > CefV8ValueList;
+
+///
+// Interface that should be implemented to handle V8 function calls. The methods
+// of this class will be called on the thread associated with the V8 function.
+///
+/*--cef(source=client)--*/
+class CefV8Handler : public virtual CefBase {
+ public:
+  ///
+  // Handle execution of the function identified by |name|. |object| is the
+  // receiver ('this' object) of the function. |arguments| is the list of
+  // arguments passed to the function. If execution succeeds set |retval| to the
+  // function return value. If execution fails set |exception| to the exception
+  // that will be thrown. Return true if execution was handled.
+  ///
+  /*--cef()--*/
+  virtual bool Execute(const CefString& name,
+                       CefRefPtr<CefV8Value> object,
+                       const CefV8ValueList& arguments,
+                       CefRefPtr<CefV8Value>& retval,
+                       CefString& exception) =0;
+};
+
+///
+// Interface that should be implemented to handle V8 accessor calls. Accessor
+// identifiers are registered by calling CefV8Value::SetValue(). The methods
+// of this class will be called on the thread associated with the V8 accessor.
+///
+/*--cef(source=client)--*/
+class CefV8Accessor : public virtual CefBase {
+ public:
+  ///
+  // Handle retrieval the accessor value identified by |name|. |object| is the
+  // receiver ('this' object) of the accessor. If retrieval succeeds set
+  // |retval| to the return value. If retrieval fails set |exception| to the
+  // exception that will be thrown. Return true if accessor retrieval was
+  // handled.
+  ///
+  /*--cef()--*/
+  virtual bool Get(const CefString& name,
+                   const CefRefPtr<CefV8Value> object,
+                   CefRefPtr<CefV8Value>& retval,
+                   CefString& exception) =0;
+
+  ///
+  // Handle assignment of the accessor value identified by |name|. |object| is
+  // the receiver ('this' object) of the accessor. |value| is the new value
+  // being assigned to the accessor. If assignment fails set |exception| to the
+  // exception that will be thrown. Return true if accessor assignment was
+  // handled.
+  ///
+  /*--cef()--*/
+  virtual bool Set(const CefString& name,
+                   const CefRefPtr<CefV8Value> object,
+                   const CefRefPtr<CefV8Value> value,
+                   CefString& exception) =0;
+};
+
+///
+// Class representing a V8 exception. The methods of this class may be called on
+// any render process thread.
+///
+/*--cef(source=library)--*/
+class CefV8Exception : public virtual CefBase {
+ public:
+  ///
+  // Returns the exception message.
+  ///
+  /*--cef()--*/
+  virtual CefString GetMessage() =0;
+
+  ///
+  // Returns the line of source code that the exception occurred within.
+  ///
+  /*--cef()--*/
+  virtual CefString GetSourceLine() =0;
+
+  ///
+  // Returns the resource name for the script from where the function causing
+  // the error originates.
+  ///
+  /*--cef()--*/
+  virtual CefString GetScriptResourceName() =0;
+
+  ///
+  // Returns the 1-based number of the line where the error occurred or 0 if the
+  // line number is unknown.
+  ///
+  /*--cef()--*/
+  virtual int GetLineNumber() =0;
+
+  ///
+  // Returns the index within the script of the first character where the error
+  // occurred.
+  ///
+  /*--cef()--*/
+  virtual int GetStartPosition() =0;
+
+  ///
+  // Returns the index within the script of the last character where the error
+  // occurred.
+  ///
+  /*--cef()--*/
+  virtual int GetEndPosition() =0;
+
+  ///
+  // Returns the index within the line of the first character where the error
+  // occurred.
+  ///
+  /*--cef()--*/
+  virtual int GetStartColumn() =0;
+
+  ///
+  // Returns the index within the line of the last character where the error
+  // occurred.
+  ///
+  /*--cef()--*/
+  virtual int GetEndColumn() =0;
+};
+
+///
+// Class representing a V8 value handle. V8 handles can only be accessed from
+// the thread on which they are created. Valid threads for creating a V8 handle
+// include the render process main thread (TID_RENDERER) and WebWorker threads.
+// A task runner for posting tasks on the associated thread can be retrieved via
+// the CefV8Context::GetTaskRunner() method.
+///
+/*--cef(source=library)--*/
+class CefV8Value : public virtual CefBase {
+ public:
+  typedef cef_v8_accesscontrol_t AccessControl;
+  typedef cef_v8_propertyattribute_t PropertyAttribute;
+
+  ///
+  // Create a new CefV8Value object of type undefined.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefV8Value> CreateUndefined();
+
+  ///
+  // Create a new CefV8Value object of type null.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefV8Value> CreateNull();
+
+  ///
+  // Create a new CefV8Value object of type bool.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefV8Value> CreateBool(bool value);
+
+  ///
+  // Create a new CefV8Value object of type int.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefV8Value> CreateInt(int32 value);
+
+  ///
+  // Create a new CefV8Value object of type unsigned int.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefV8Value> CreateUInt(uint32 value);
+
+  ///
+  // Create a new CefV8Value object of type double.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefV8Value> CreateDouble(double value);
+
+  ///
+  // Create a new CefV8Value object of type Date. This method should only be
+  // called from within the scope of a CefRenderProcessHandler, CefV8Handler or
+  // CefV8Accessor callback, or in combination with calling Enter() and Exit()
+  // on a stored CefV8Context reference.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefV8Value> CreateDate(const CefTime& date);
+
+  ///
+  // Create a new CefV8Value object of type string.
+  ///
+  /*--cef(optional_param=value)--*/
+  static CefRefPtr<CefV8Value> CreateString(const CefString& value);
+
+  ///
+  // Create a new CefV8Value object of type object with optional accessor. This
+  // method should only be called from within the scope of a
+  // CefRenderProcessHandler, CefV8Handler or CefV8Accessor callback, or in
+  // combination with calling Enter() and Exit() on a stored CefV8Context
+  // reference.
+  ///
+  /*--cef(optional_param=accessor)--*/
+  static CefRefPtr<CefV8Value> CreateObject(CefRefPtr<CefV8Accessor> accessor);
+
+  ///
+  // Create a new CefV8Value object of type array with the specified |length|.
+  // If |length| is negative the returned array will have length 0. This method
+  // should only be called from within the scope of a CefRenderProcessHandler,
+  // CefV8Handler or CefV8Accessor callback, or in combination with calling
+  // Enter() and Exit() on a stored CefV8Context reference.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefV8Value> CreateArray(int length);
+
+  ///
+  // Create a new CefV8Value object of type function. This method should only be
+  // called from within the scope of a CefRenderProcessHandler, CefV8Handler or
+  // CefV8Accessor callback, or in combination with calling Enter() and Exit()
+  // on a stored CefV8Context reference.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefV8Value> CreateFunction(const CefString& name,
+                                              CefRefPtr<CefV8Handler> handler);
+
+  ///
+  // Returns true if the underlying handle is valid and it can be accessed on
+  // the current thread. Do not call any other methods if this method returns
+  // false.
+  ///
+  /*--cef()--*/
+  virtual bool IsValid() =0;
+
+  ///
+  // True if the value type is undefined.
+  ///
+  /*--cef()--*/
+  virtual bool IsUndefined() =0;
+
+  ///
+  // True if the value type is null.
+  ///
+  /*--cef()--*/
+  virtual bool IsNull() =0;
+
+  ///
+  // True if the value type is bool.
+  ///
+  /*--cef()--*/
+  virtual bool IsBool() =0;
+
+  ///
+  // True if the value type is int.
+  ///
+  /*--cef()--*/
+  virtual bool IsInt() =0;
+
+  ///
+  // True if the value type is unsigned int.
+  ///
+  /*--cef()--*/
+  virtual bool IsUInt() =0;
+
+  ///
+  // True if the value type is double.
+  ///
+  /*--cef()--*/
+  virtual bool IsDouble() =0;
+
+  ///
+  // True if the value type is Date.
+  ///
+  /*--cef()--*/
+  virtual bool IsDate() =0;
+
+  ///
+  // True if the value type is string.
+  ///
+  /*--cef()--*/
+  virtual bool IsString() =0;
+
+  ///
+  // True if the value type is object.
+  ///
+  /*--cef()--*/
+  virtual bool IsObject() =0;
+
+  ///
+  // True if the value type is array.
+  ///
+  /*--cef()--*/
+  virtual bool IsArray() =0;
+
+  ///
+  // True if the value type is function.
+  ///
+  /*--cef()--*/
+  virtual bool IsFunction() =0;
+
+  ///
+  // Returns true if this object is pointing to the same handle as |that|
+  // object.
+  ///
+  /*--cef()--*/
+  virtual bool IsSame(CefRefPtr<CefV8Value> that) =0;
+
+  ///
+  // Return a bool value.  The underlying data will be converted to if
+  // necessary.
+  ///
+  /*--cef()--*/
+  virtual bool GetBoolValue() =0;
+
+  ///
+  // Return an int value.  The underlying data will be converted to if
+  // necessary.
+  ///
+  /*--cef()--*/
+  virtual int32 GetIntValue() =0;
+
+  ///
+  // Return an unisgned int value.  The underlying data will be converted to if
+  // necessary.
+  ///
+  /*--cef()--*/
+  virtual uint32 GetUIntValue() =0;
+
+  ///
+  // Return a double value.  The underlying data will be converted to if
+  // necessary.
+  ///
+  /*--cef()--*/
+  virtual double GetDoubleValue() =0;
+
+  ///
+  // Return a Date value.  The underlying data will be converted to if
+  // necessary.
+  ///
+  /*--cef()--*/
+  virtual CefTime GetDateValue() =0;
+
+  ///
+  // Return a string value.  The underlying data will be converted to if
+  // necessary.
+  ///
+  /*--cef()--*/
+  virtual CefString GetStringValue() =0;
+
+
+  // OBJECT METHODS - These methods are only available on objects. Arrays and
+  // functions are also objects. String- and integer-based keys can be used
+  // interchangably with the framework converting between them as necessary.
+
+  ///
+  // Returns true if this is a user created object.
+  ///
+  /*--cef()--*/
+  virtual bool IsUserCreated() =0;
+
+  ///
+  // Returns true if the last method call resulted in an exception. This
+  // attribute exists only in the scope of the current CEF value object.
+  ///
+  /*--cef()--*/
+  virtual bool HasException() =0;
+
+  ///
+  // Returns the exception resulting from the last method call. This attribute
+  // exists only in the scope of the current CEF value object.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefV8Exception> GetException() =0;
+
+  ///
+  // Clears the last exception and returns true on success.
+  ///
+  /*--cef()--*/
+  virtual bool ClearException() =0;
+
+  ///
+  // Returns true if this object will re-throw future exceptions. This attribute
+  // exists only in the scope of the current CEF value object.
+  ///
+  /*--cef()--*/
+  virtual bool WillRethrowExceptions() =0;
+
+  ///
+  // Set whether this object will re-throw future exceptions. By default
+  // exceptions are not re-thrown. If a exception is re-thrown the current
+  // context should not be accessed again until after the exception has been
+  // caught and not re-thrown. Returns true on success. This attribute exists
+  // only in the scope of the current CEF value object.
+  ///
+  /*--cef()--*/
+  virtual bool SetRethrowExceptions(bool rethrow) =0;
+
+  ///
+  // Returns true if the object has a value with the specified identifier.
+  ///
+  /*--cef(capi_name=has_value_bykey,optional_param=key)--*/
+  virtual bool HasValue(const CefString& key) =0;
+
+  ///
+  // Returns true if the object has a value with the specified identifier.
+  ///
+  /*--cef(capi_name=has_value_byindex,index_param=index)--*/
+  virtual bool HasValue(int index) =0;
+
+  ///
+  // Deletes the value with the specified identifier and returns true on
+  // success. Returns false if this method is called incorrectly or an exception
+  // is thrown. For read-only and don't-delete values this method will return
+  // true even though deletion failed.
+  ///
+  /*--cef(capi_name=delete_value_bykey,optional_param=key)--*/
+  virtual bool DeleteValue(const CefString& key) =0;
+
+  ///
+  // Deletes the value with the specified identifier and returns true on
+  // success. Returns false if this method is called incorrectly, deletion fails
+  // or an exception is thrown. For read-only and don't-delete values this
+  // method will return true even though deletion failed.
+  ///
+  /*--cef(capi_name=delete_value_byindex,index_param=index)--*/
+  virtual bool DeleteValue(int index) =0;
+
+  ///
+  // Returns the value with the specified identifier on success. Returns NULL
+  // if this method is called incorrectly or an exception is thrown.
+  ///
+  /*--cef(capi_name=get_value_bykey,optional_param=key)--*/
+  virtual CefRefPtr<CefV8Value> GetValue(const CefString& key) =0;
+
+  ///
+  // Returns the value with the specified identifier on success. Returns NULL
+  // if this method is called incorrectly or an exception is thrown.
+  ///
+  /*--cef(capi_name=get_value_byindex,index_param=index)--*/
+  virtual CefRefPtr<CefV8Value> GetValue(int index) =0;
+
+  ///
+  // Associates a value with the specified identifier and returns true on
+  // success. Returns false if this method is called incorrectly or an exception
+  // is thrown. For read-only values this method will return true even though
+  // assignment failed.
+  ///
+  /*--cef(capi_name=set_value_bykey,optional_param=key)--*/
+  virtual bool SetValue(const CefString& key, CefRefPtr<CefV8Value> value,
+                        PropertyAttribute attribute) =0;
+
+  ///
+  // Associates a value with the specified identifier and returns true on
+  // success. Returns false if this method is called incorrectly or an exception
+  // is thrown. For read-only values this method will return true even though
+  // assignment failed.
+  ///
+  /*--cef(capi_name=set_value_byindex,index_param=index)--*/
+  virtual bool SetValue(int index, CefRefPtr<CefV8Value> value) =0;
+
+  ///
+  // Registers an identifier and returns true on success. Access to the
+  // identifier will be forwarded to the CefV8Accessor instance passed to
+  // CefV8Value::CreateObject(). Returns false if this method is called
+  // incorrectly or an exception is thrown. For read-only values this method
+  // will return true even though assignment failed.
+  ///
+  /*--cef(capi_name=set_value_byaccessor,optional_param=key)--*/
+  virtual bool SetValue(const CefString& key, AccessControl settings,
+                        PropertyAttribute attribute) =0;
+
+  ///
+  // Read the keys for the object's values into the specified vector. Integer-
+  // based keys will also be returned as strings.
+  ///
+  /*--cef()--*/
+  virtual bool GetKeys(std::vector<CefString>& keys) =0;
+
+  ///
+  // Sets the user data for this object and returns true on success. Returns
+  // false if this method is called incorrectly. This method can only be called
+  // on user created objects.
+  ///
+  /*--cef(optional_param=user_data)--*/
+  virtual bool SetUserData(CefRefPtr<CefBase> user_data) =0;
+
+  ///
+  // Returns the user data, if any, assigned to this object.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefBase> GetUserData() =0;
+
+  ///
+  // Returns the amount of externally allocated memory registered for the
+  // object.
+  ///
+  /*--cef()--*/
+  virtual int GetExternallyAllocatedMemory() =0;
+
+  ///
+  // Adjusts the amount of registered external memory for the object. Used to
+  // give V8 an indication of the amount of externally allocated memory that is
+  // kept alive by JavaScript objects. V8 uses this information to decide when
+  // to perform global garbage collection. Each CefV8Value tracks the amount of
+  // external memory associated with it and automatically decreases the global
+  // total by the appropriate amount on its destruction. |change_in_bytes|
+  // specifies the number of bytes to adjust by. This method returns the number
+  // of bytes associated with the object after the adjustment. This method can
+  // only be called on user created objects.
+  ///
+  /*--cef()--*/
+  virtual int AdjustExternallyAllocatedMemory(int change_in_bytes) =0;
+
+
+  // ARRAY METHODS - These methods are only available on arrays.
+
+  ///
+  // Returns the number of elements in the array.
+  ///
+  /*--cef()--*/
+  virtual int GetArrayLength() =0;
+
+
+  // FUNCTION METHODS - These methods are only available on functions.
+
+  ///
+  // Returns the function name.
+  ///
+  /*--cef()--*/
+  virtual CefString GetFunctionName() =0;
+
+  ///
+  // Returns the function handler or NULL if not a CEF-created function.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefV8Handler> GetFunctionHandler() =0;
+
+  ///
+  // Execute the function using the current V8 context. This method should only
+  // be called from within the scope of a CefV8Handler or CefV8Accessor
+  // callback, or in combination with calling Enter() and Exit() on a stored
+  // CefV8Context reference. |object| is the receiver ('this' object) of the
+  // function. If |object| is empty the current context's global object will be
+  // used. |arguments| is the list of arguments that will be passed to the
+  // function. Returns the function return value on success. Returns NULL if
+  // this method is called incorrectly or an exception is thrown.
+  ///
+  /*--cef(optional_param=object)--*/
+  virtual CefRefPtr<CefV8Value> ExecuteFunction(
+      CefRefPtr<CefV8Value> object,
+      const CefV8ValueList& arguments) =0;
+
+  ///
+  // Execute the function using the specified V8 context. |object| is the
+  // receiver ('this' object) of the function. If |object| is empty the
+  // specified context's global object will be used. |arguments| is the list of
+  // arguments that will be passed to the function. Returns the function return
+  // value on success. Returns NULL if this method is called incorrectly or an
+  // exception is thrown.
+  ///
+  /*--cef(optional_param=object)--*/
+  virtual CefRefPtr<CefV8Value> ExecuteFunctionWithContext(
+      CefRefPtr<CefV8Context> context,
+      CefRefPtr<CefV8Value> object,
+      const CefV8ValueList& arguments) =0;
+};
+
+///
+// Class representing a V8 stack trace handle. V8 handles can only be accessed
+// from the thread on which they are created. Valid threads for creating a V8
+// handle include the render process main thread (TID_RENDERER) and WebWorker
+// threads. A task runner for posting tasks on the associated thread can be
+// retrieved via the CefV8Context::GetTaskRunner() method.
+///
+/*--cef(source=library)--*/
+class CefV8StackTrace : public virtual CefBase {
+ public:
+  ///
+  // Returns the stack trace for the currently active context. |frame_limit| is
+  // the maximum number of frames that will be captured.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefV8StackTrace> GetCurrent(int frame_limit);
+
+  ///
+  // Returns true if the underlying handle is valid and it can be accessed on
+  // the current thread. Do not call any other methods if this method returns
+  // false.
+  ///
+  /*--cef()--*/
+  virtual bool IsValid() =0;
+
+  ///
+  // Returns the number of stack frames.
+  ///
+  /*--cef()--*/
+  virtual int GetFrameCount() =0;
+
+  ///
+  // Returns the stack frame at the specified 0-based index.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefV8StackFrame> GetFrame(int index) =0;
+};
+
+///
+// Class representing a V8 stack frame handle. V8 handles can only be accessed
+// from the thread on which they are created. Valid threads for creating a V8
+// handle include the render process main thread (TID_RENDERER) and WebWorker
+// threads. A task runner for posting tasks on the associated thread can be
+// retrieved via the CefV8Context::GetTaskRunner() method.
+///
+/*--cef(source=library)--*/
+class CefV8StackFrame : public virtual CefBase {
+ public:
+  ///
+  // Returns true if the underlying handle is valid and it can be accessed on
+  // the current thread. Do not call any other methods if this method returns
+  // false.
+  ///
+  /*--cef()--*/
+  virtual bool IsValid() =0;
+
+  ///
+  // Returns the name of the resource script that contains the function.
+  ///
+  /*--cef()--*/
+  virtual CefString GetScriptName() =0;
+
+  ///
+  // Returns the name of the resource script that contains the function or the
+  // sourceURL value if the script name is undefined and its source ends with
+  // a "//@ sourceURL=..." string.
+  ///
+  /*--cef()--*/
+  virtual CefString GetScriptNameOrSourceURL() =0;
+
+  ///
+  // Returns the name of the function.
+  ///
+  /*--cef()--*/
+  virtual CefString GetFunctionName() =0;
+
+  ///
+  // Returns the 1-based line number for the function call or 0 if unknown.
+  ///
+  /*--cef()--*/
+  virtual int GetLineNumber() =0;
+
+  ///
+  // Returns the 1-based column offset on the line for the function call or 0 if
+  // unknown.
+  ///
+  /*--cef()--*/
+  virtual int GetColumn() =0;
+
+  ///
+  // Returns true if the function was compiled using eval().
+  ///
+  /*--cef()--*/
+  virtual bool IsEval() =0;
+
+  ///
+  // Returns true if the function was called as a constructor via "new".
+  ///
+  /*--cef()--*/
+  virtual bool IsConstructor() =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_V8_H_
diff --git a/src/include/libcef/cef_values.h b/src/include/libcef/cef_values.h
new file mode 100644
index 0000000..6ab6adf
--- /dev/null
+++ b/src/include/libcef/cef_values.h
@@ -0,0 +1,752 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_VALUES_H_
+#define CEF_INCLUDE_CEF_VALUES_H_
+#pragma once
+
+#include <vector>
+#include "include/cef_base.h"
+
+class CefBinaryValue;
+class CefDictionaryValue;
+class CefListValue;
+
+typedef cef_value_type_t CefValueType;
+
+///
+// Class that wraps other data value types. Complex types (binary, dictionary
+// and list) will be referenced but not owned by this object. Can be used on any
+// process and thread.
+///
+/*--cef(source=library)--*/
+class CefValue : public virtual CefBase {
+ public:
+  ///
+  // Creates a new object.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefValue> Create();
+
+  ///
+  // Returns true if the underlying data is valid. This will always be true for
+  // simple types. For complex types (binary, dictionary and list) the
+  // underlying data may become invalid if owned by another object (e.g. list or
+  // dictionary) and that other object is then modified or destroyed. This value
+  // object can be re-used by calling Set*() even if the underlying data is
+  // invalid.
+  ///
+  /*--cef()--*/
+  virtual bool IsValid() =0;
+
+  ///
+  // Returns true if the underlying data is owned by another object.
+  ///
+  /*--cef()--*/
+  virtual bool IsOwned() =0;
+
+  ///
+  // Returns true if the underlying data is read-only. Some APIs may expose
+  // read-only objects.
+  ///
+  /*--cef()--*/
+  virtual bool IsReadOnly() =0;
+
+  ///
+  // Returns true if this object and |that| object have the same underlying
+  // data. If true modifications to this object will also affect |that| object
+  // and vice-versa.
+  ///
+  /*--cef()--*/
+  virtual bool IsSame(CefRefPtr<CefValue> that) =0;
+
+  ///
+  // Returns true if this object and |that| object have an equivalent underlying
+  // value but are not necessarily the same object.
+  ///
+  /*--cef()--*/
+  virtual bool IsEqual(CefRefPtr<CefValue> that) =0;
+
+  ///
+  // Returns a copy of this object. The underlying data will also be copied.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefValue> Copy() =0;
+
+  ///
+  // Returns the underlying value type.
+  ///
+  /*--cef(default_retval=VTYPE_INVALID)--*/
+  virtual CefValueType GetType() =0;
+
+  ///
+  // Returns the underlying value as type bool.
+  ///
+  /*--cef()--*/
+  virtual bool GetBool() =0;
+
+  ///
+  // Returns the underlying value as type int.
+  ///
+  /*--cef()--*/
+  virtual int GetInt() =0;
+
+  ///
+  // Returns the underlying value as type double.
+  ///
+  /*--cef()--*/
+  virtual double GetDouble() =0;
+
+  ///
+  // Returns the underlying value as type string.
+  ///
+  /*--cef()--*/
+  virtual CefString GetString() =0;
+
+  ///
+  // Returns the underlying value as type binary. The returned reference may
+  // become invalid if the value is owned by another object or if ownership is
+  // transferred to another object in the future. To maintain a reference to
+  // the value after assigning ownership to a dictionary or list pass this
+  // object to the SetValue() method instead of passing the returned reference
+  // to SetBinary().
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefBinaryValue> GetBinary() =0;
+
+  ///
+  // Returns the underlying value as type dictionary. The returned reference may
+  // become invalid if the value is owned by another object or if ownership is
+  // transferred to another object in the future. To maintain a reference to
+  // the value after assigning ownership to a dictionary or list pass this
+  // object to the SetValue() method instead of passing the returned reference
+  // to SetDictionary().
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefDictionaryValue> GetDictionary() =0;
+
+  ///
+  // Returns the underlying value as type list. The returned reference may
+  // become invalid if the value is owned by another object or if ownership is
+  // transferred to another object in the future. To maintain a reference to
+  // the value after assigning ownership to a dictionary or list pass this
+  // object to the SetValue() method instead of passing the returned reference
+  // to SetList().
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefListValue> GetList() =0;
+
+  ///
+  // Sets the underlying value as type null. Returns true if the value was set
+  // successfully.
+  ///
+  /*--cef()--*/
+  virtual bool SetNull() =0;
+
+  ///
+  // Sets the underlying value as type bool. Returns true if the value was set
+  // successfully.
+  ///
+  /*--cef()--*/
+  virtual bool SetBool(bool value) =0;
+
+  ///
+  // Sets the underlying value as type int. Returns true if the value was set
+  // successfully.
+  ///
+  /*--cef()--*/
+  virtual bool SetInt(int value) =0;
+
+  ///
+  // Sets the underlying value as type double. Returns true if the value was set
+  // successfully.
+  ///
+  /*--cef()--*/
+  virtual bool SetDouble(double value) =0;
+
+  ///
+  // Sets the underlying value as type string. Returns true if the value was set
+  // successfully.
+  ///
+  /*--cef(optional_param=value)--*/
+  virtual bool SetString(const CefString& value) =0;
+
+  ///
+  // Sets the underlying value as type binary. Returns true if the value was set
+  // successfully. This object keeps a reference to |value| and ownership of the
+  // underlying data remains unchanged.
+  ///
+  /*--cef()--*/
+  virtual bool SetBinary(CefRefPtr<CefBinaryValue> value) =0;
+
+  ///
+  // Sets the underlying value as type dict. Returns true if the value was set
+  // successfully. This object keeps a reference to |value| and ownership of the
+  // underlying data remains unchanged.
+  ///
+  /*--cef()--*/
+  virtual bool SetDictionary(CefRefPtr<CefDictionaryValue> value) =0;
+
+  ///
+  // Sets the underlying value as type list. Returns true if the value was set
+  // successfully. This object keeps a reference to |value| and ownership of the
+  // underlying data remains unchanged.
+  ///
+  /*--cef()--*/
+  virtual bool SetList(CefRefPtr<CefListValue> value) =0;
+};
+
+
+///
+// Class representing a binary value. Can be used on any process and thread.
+///
+/*--cef(source=library)--*/
+class CefBinaryValue : public virtual CefBase {
+ public:
+  ///
+  // Creates a new object that is not owned by any other object. The specified
+  // |data| will be copied.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefBinaryValue> Create(const void* data,
+                                          size_t data_size);
+
+  ///
+  // Returns true if this object is valid. This object may become invalid if
+  // the underlying data is owned by another object (e.g. list or dictionary)
+  // and that other object is then modified or destroyed. Do not call any other
+  // methods if this method returns false.
+  ///
+  /*--cef()--*/
+  virtual bool IsValid() =0;
+
+  ///
+  // Returns true if this object is currently owned by another object.
+  ///
+  /*--cef()--*/
+  virtual bool IsOwned() =0;
+
+  ///
+  // Returns true if this object and |that| object have the same underlying
+  // data.
+  ///
+  /*--cef()--*/
+  virtual bool IsSame(CefRefPtr<CefBinaryValue> that) =0;
+
+  ///
+  // Returns true if this object and |that| object have an equivalent underlying
+  // value but are not necessarily the same object.
+  ///
+  /*--cef()--*/
+  virtual bool IsEqual(CefRefPtr<CefBinaryValue> that) =0;
+
+  ///
+  // Returns a copy of this object. The data in this object will also be copied.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefBinaryValue> Copy() =0;
+
+  ///
+  // Returns the data size.
+  ///
+  /*--cef()--*/
+  virtual size_t GetSize() =0;
+
+  ///
+  // Read up to |buffer_size| number of bytes into |buffer|. Reading begins at
+  // the specified byte |data_offset|. Returns the number of bytes read.
+  ///
+  /*--cef()--*/
+  virtual size_t GetData(void* buffer,
+                         size_t buffer_size,
+                         size_t data_offset) =0;
+};
+
+
+///
+// Class representing a dictionary value. Can be used on any process and thread.
+///
+/*--cef(source=library)--*/
+class CefDictionaryValue : public virtual CefBase {
+ public:
+  typedef std::vector<CefString> KeyList;
+
+  ///
+  // Creates a new object that is not owned by any other object.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefDictionaryValue> Create();
+
+  ///
+  // Returns true if this object is valid. This object may become invalid if
+  // the underlying data is owned by another object (e.g. list or dictionary)
+  // and that other object is then modified or destroyed. Do not call any other
+  // methods if this method returns false.
+  ///
+  /*--cef()--*/
+  virtual bool IsValid() =0;
+
+  ///
+  // Returns true if this object is currently owned by another object.
+  ///
+  /*--cef()--*/
+  virtual bool IsOwned() =0;
+
+  ///
+  // Returns true if the values of this object are read-only. Some APIs may
+  // expose read-only objects.
+  ///
+  /*--cef()--*/
+  virtual bool IsReadOnly() =0;
+
+  ///
+  // Returns true if this object and |that| object have the same underlying
+  // data. If true modifications to this object will also affect |that| object
+  // and vice-versa.
+  ///
+  /*--cef()--*/
+  virtual bool IsSame(CefRefPtr<CefDictionaryValue> that) =0;
+
+  ///
+  // Returns true if this object and |that| object have an equivalent underlying
+  // value but are not necessarily the same object.
+  ///
+  /*--cef()--*/
+  virtual bool IsEqual(CefRefPtr<CefDictionaryValue> that) =0;
+
+  ///
+  // Returns a writable copy of this object. If |exclude_empty_children| is true
+  // any empty dictionaries or lists will be excluded from the copy.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefDictionaryValue> Copy(bool exclude_empty_children) =0;
+
+  ///
+  // Returns the number of values.
+  ///
+  /*--cef()--*/
+  virtual size_t GetSize() =0;
+
+  ///
+  // Removes all values. Returns true on success.
+  ///
+  /*--cef()--*/
+  virtual bool Clear() =0;
+
+  ///
+  // Returns true if the current dictionary has a value for the given key.
+  ///
+  /*--cef()--*/
+  virtual bool HasKey(const CefString& key) =0;
+
+  ///
+  // Reads all keys for this dictionary into the specified vector.
+  ///
+  /*--cef()--*/
+  virtual bool GetKeys(KeyList& keys) =0;
+
+  ///
+  // Removes the value at the specified key. Returns true is the value was
+  // removed successfully.
+  ///
+  /*--cef()--*/
+  virtual bool Remove(const CefString& key) =0;
+
+  ///
+  // Returns the value type for the specified key.
+  ///
+  /*--cef(default_retval=VTYPE_INVALID)--*/
+  virtual CefValueType GetType(const CefString& key) =0;
+
+  ///
+  // Returns the value at the specified key. For simple types the returned
+  // value will copy existing data and modifications to the value will not
+  // modify this object. For complex types (binary, dictionary and list) the
+  // returned value will reference existing data and modifications to the value
+  // will modify this object.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefValue> GetValue(const CefString& key) =0;
+
+  ///
+  // Returns the value at the specified key as type bool.
+  ///
+  /*--cef()--*/
+  virtual bool GetBool(const CefString& key) =0;
+
+  ///
+  // Returns the value at the specified key as type int.
+  ///
+  /*--cef()--*/
+  virtual int GetInt(const CefString& key) =0;
+
+  ///
+  // Returns the value at the specified key as type double.
+  ///
+  /*--cef()--*/
+  virtual double GetDouble(const CefString& key) =0;
+
+  ///
+  // Returns the value at the specified key as type string.
+  ///
+  /*--cef()--*/
+  virtual CefString GetString(const CefString& key) =0;
+
+  ///
+  // Returns the value at the specified key as type binary. The returned
+  // value will reference existing data.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefBinaryValue> GetBinary(const CefString& key) =0;
+
+  ///
+  // Returns the value at the specified key as type dictionary. The returned
+  // value will reference existing data and modifications to the value will
+  // modify this object.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefDictionaryValue> GetDictionary(const CefString& key) =0;
+
+  ///
+  // Returns the value at the specified key as type list. The returned value
+  // will reference existing data and modifications to the value will modify
+  // this object.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefListValue> GetList(const CefString& key) =0;
+
+  ///
+  // Sets the value at the specified key. Returns true if the value was set
+  // successfully. If |value| represents simple data then the underlying data
+  // will be copied and modifications to |value| will not modify this object. If
+  // |value| represents complex data (binary, dictionary or list) then the
+  // underlying data will be referenced and modifications to |value| will modify
+  // this object.
+  ///
+  /*--cef()--*/
+  virtual bool SetValue(const CefString& key, CefRefPtr<CefValue> value) =0;
+
+  ///
+  // Sets the value at the specified key as type null. Returns true if the
+  // value was set successfully.
+  ///
+  /*--cef()--*/
+  virtual bool SetNull(const CefString& key) =0;
+
+  ///
+  // Sets the value at the specified key as type bool. Returns true if the
+  // value was set successfully.
+  ///
+  /*--cef()--*/
+  virtual bool SetBool(const CefString& key, bool value) =0;
+
+  ///
+  // Sets the value at the specified key as type int. Returns true if the
+  // value was set successfully.
+  ///
+  /*--cef()--*/
+  virtual bool SetInt(const CefString& key, int value) =0;
+
+  ///
+  // Sets the value at the specified key as type double. Returns true if the
+  // value was set successfully.
+  ///
+  /*--cef()--*/
+  virtual bool SetDouble(const CefString& key, double value) =0;
+
+  ///
+  // Sets the value at the specified key as type string. Returns true if the
+  // value was set successfully.
+  ///
+  /*--cef(optional_param=value)--*/
+  virtual bool SetString(const CefString& key, const CefString& value) =0;
+
+  ///
+  // Sets the value at the specified key as type binary. Returns true if the
+  // value was set successfully. If |value| is currently owned by another object
+  // then the value will be copied and the |value| reference will not change.
+  // Otherwise, ownership will be transferred to this object and the |value|
+  // reference will be invalidated.
+  ///
+  /*--cef()--*/
+  virtual bool SetBinary(const CefString& key,
+                         CefRefPtr<CefBinaryValue> value) =0;
+
+  ///
+  // Sets the value at the specified key as type dict. Returns true if the
+  // value was set successfully. If |value| is currently owned by another object
+  // then the value will be copied and the |value| reference will not change.
+  // Otherwise, ownership will be transferred to this object and the |value|
+  // reference will be invalidated.
+  ///
+  /*--cef()--*/
+  virtual bool SetDictionary(const CefString& key,
+                             CefRefPtr<CefDictionaryValue> value) =0;
+
+  ///
+  // Sets the value at the specified key as type list. Returns true if the
+  // value was set successfully. If |value| is currently owned by another object
+  // then the value will be copied and the |value| reference will not change.
+  // Otherwise, ownership will be transferred to this object and the |value|
+  // reference will be invalidated.
+  ///
+  /*--cef()--*/
+  virtual bool SetList(const CefString& key,
+                       CefRefPtr<CefListValue> value) =0;
+};
+
+
+///
+// Class representing a list value. Can be used on any process and thread.
+///
+/*--cef(source=library)--*/
+class CefListValue : public virtual CefBase {
+ public:
+  ///
+  // Creates a new object that is not owned by any other object.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefListValue> Create();
+
+  ///
+  // Returns true if this object is valid. This object may become invalid if
+  // the underlying data is owned by another object (e.g. list or dictionary)
+  // and that other object is then modified or destroyed. Do not call any other
+  // methods if this method returns false.
+  ///
+  /*--cef()--*/
+  virtual bool IsValid() =0;
+
+  ///
+  // Returns true if this object is currently owned by another object.
+  ///
+  /*--cef()--*/
+  virtual bool IsOwned() =0;
+
+  ///
+  // Returns true if the values of this object are read-only. Some APIs may
+  // expose read-only objects.
+  ///
+  /*--cef()--*/
+  virtual bool IsReadOnly() =0;
+
+  ///
+  // Returns true if this object and |that| object have the same underlying
+  // data. If true modifications to this object will also affect |that| object
+  // and vice-versa.
+  ///
+  /*--cef()--*/
+  virtual bool IsSame(CefRefPtr<CefListValue> that) =0;
+
+  ///
+  // Returns true if this object and |that| object have an equivalent underlying
+  // value but are not necessarily the same object.
+  ///
+  /*--cef()--*/
+  virtual bool IsEqual(CefRefPtr<CefListValue> that) =0;
+
+  ///
+  // Returns a writable copy of this object.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefListValue> Copy() =0;
+
+  ///
+  // Sets the number of values. If the number of values is expanded all
+  // new value slots will default to type null. Returns true on success.
+  ///
+  /*--cef()--*/
+  virtual bool SetSize(size_t size) =0;
+
+  ///
+  // Returns the number of values.
+  ///
+  /*--cef()--*/
+  virtual size_t GetSize() =0;
+
+  ///
+  // Removes all values. Returns true on success.
+  ///
+  /*--cef()--*/
+  virtual bool Clear() =0;
+
+  ///
+  // Removes the value at the specified index.
+  ///
+  /*--cef(index_param=index)--*/
+  virtual bool Remove(int index) =0;
+
+  ///
+  // Returns the value type at the specified index.
+  ///
+  /*--cef(default_retval=VTYPE_INVALID,index_param=index)--*/
+  virtual CefValueType GetType(int index) =0;
+
+  ///
+  // Returns the value at the specified index. For simple types the returned
+  // value will copy existing data and modifications to the value will not
+  // modify this object. For complex types (binary, dictionary and list) the
+  // returned value will reference existing data and modifications to the value
+  // will modify this object.
+  ///
+  /*--cef(index_param=index)--*/
+  virtual CefRefPtr<CefValue> GetValue(int index) =0;
+
+  ///
+  // Returns the value at the specified index as type bool.
+  ///
+  /*--cef(index_param=index)--*/
+  virtual bool GetBool(int index) =0;
+
+  ///
+  // Returns the value at the specified index as type int.
+  ///
+  /*--cef(index_param=index)--*/
+  virtual int GetInt(int index) =0;
+
+  ///
+  // Returns the value at the specified index as type double.
+  ///
+  /*--cef(index_param=index)--*/
+  virtual double GetDouble(int index) =0;
+
+  ///
+  // Returns the value at the specified index as type string.
+  ///
+  /*--cef(index_param=index)--*/
+  virtual CefString GetString(int index) =0;
+
+  ///
+  // Returns the value at the specified index as type binary. The returned
+  // value will reference existing data.
+  ///
+  /*--cef(index_param=index)--*/
+  virtual CefRefPtr<CefBinaryValue> GetBinary(int index) =0;
+
+  ///
+  // Returns the value at the specified index as type dictionary. The returned
+  // value will reference existing data and modifications to the value will
+  // modify this object.
+  ///
+  /*--cef(index_param=index)--*/
+  virtual CefRefPtr<CefDictionaryValue> GetDictionary(int index) =0;
+
+  ///
+  // Returns the value at the specified index as type list. The returned
+  // value will reference existing data and modifications to the value will
+  // modify this object.
+  ///
+  /*--cef(index_param=index)--*/
+  virtual CefRefPtr<CefListValue> GetList(int index) =0;
+
+  ///
+  // Sets the value at the specified index. Returns true if the value was set
+  // successfully. If |value| represents simple data then the underlying data
+  // will be copied and modifications to |value| will not modify this object. If
+  // |value| represents complex data (binary, dictionary or list) then the
+  // underlying data will be referenced and modifications to |value| will modify
+  // this object.
+  ///
+  /*--cef(index_param=index)--*/
+  virtual bool SetValue(int index, CefRefPtr<CefValue> value) =0;
+
+  ///
+  // Sets the value at the specified index as type null. Returns true if the
+  // value was set successfully.
+  ///
+  /*--cef(index_param=index)--*/
+  virtual bool SetNull(int index) =0;
+
+  ///
+  // Sets the value at the specified index as type bool. Returns true if the
+  // value was set successfully.
+  ///
+  /*--cef(index_param=index)--*/
+  virtual bool SetBool(int index, bool value) =0;
+
+  ///
+  // Sets the value at the specified index as type int. Returns true if the
+  // value was set successfully.
+  ///
+  /*--cef(index_param=index)--*/
+  virtual bool SetInt(int index, int value) =0;
+
+  ///
+  // Sets the value at the specified index as type double. Returns true if the
+  // value was set successfully.
+  ///
+  /*--cef(index_param=index)--*/
+  virtual bool SetDouble(int index, double value) =0;
+
+  ///
+  // Sets the value at the specified index as type string. Returns true if the
+  // value was set successfully.
+  ///
+  /*--cef(optional_param=value,index_param=index)--*/
+  virtual bool SetString(int index, const CefString& value) =0;
+
+  ///
+  // Sets the value at the specified index as type binary. Returns true if the
+  // value was set successfully. If |value| is currently owned by another object
+  // then the value will be copied and the |value| reference will not change.
+  // Otherwise, ownership will be transferred to this object and the |value|
+  // reference will be invalidated.
+  ///
+  /*--cef(index_param=index)--*/
+  virtual bool SetBinary(int index, CefRefPtr<CefBinaryValue> value) =0;
+
+  ///
+  // Sets the value at the specified index as type dict. Returns true if the
+  // value was set successfully. If |value| is currently owned by another object
+  // then the value will be copied and the |value| reference will not change.
+  // Otherwise, ownership will be transferred to this object and the |value|
+  // reference will be invalidated.
+  ///
+  /*--cef(index_param=index)--*/
+  virtual bool SetDictionary(int index, CefRefPtr<CefDictionaryValue> value) =0;
+
+  ///
+  // Sets the value at the specified index as type list. Returns true if the
+  // value was set successfully. If |value| is currently owned by another object
+  // then the value will be copied and the |value| reference will not change.
+  // Otherwise, ownership will be transferred to this object and the |value|
+  // reference will be invalidated.
+  ///
+  /*--cef(index_param=index)--*/
+  virtual bool SetList(int index, CefRefPtr<CefListValue> value) =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_VALUES_H_
diff --git a/src/include/libcef/cef_version.h b/src/include/libcef/cef_version.h
new file mode 100644
index 0000000..7f82ded
--- /dev/null
+++ b/src/include/libcef/cef_version.h
@@ -0,0 +1,102 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file is generated by the make_version_header.py tool.
+//
+
+#ifndef CEF_INCLUDE_CEF_VERSION_H_
+#define CEF_INCLUDE_CEF_VERSION_H_
+
+#define CEF_VERSION "3.2704.1415.g90c8571"
+#define CEF_VERSION_MAJOR 3
+#define CEF_COMMIT_NUMBER 1415
+#define CEF_COMMIT_HASH "90c8571f731a019158b31e6e33af1907a7184557"
+#define COPYRIGHT_YEAR 2016
+
+#define CHROME_VERSION_MAJOR 51
+#define CHROME_VERSION_MINOR 0
+#define CHROME_VERSION_BUILD 2704
+#define CHROME_VERSION_PATCH 63
+
+#define DO_MAKE_STRING(p) #p
+#define MAKE_STRING(p) DO_MAKE_STRING(p)
+
+#ifndef APSTUDIO_HIDDEN_SYMBOLS
+
+#include "include/internal/cef_export.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// The API hash is created by analyzing CEF header files for C API type
+// definitions. The hash value will change when header files are modified
+// in a way that may cause binary incompatibility with other builds. The
+// universal hash value will change if any platform is affected whereas the
+// platform hash values will change only if that particular platform is
+// affected.
+#define CEF_API_HASH_UNIVERSAL "0b16f480992a3e268258b39d728782f2349edab2"
+#if defined(OS_WIN)
+#define CEF_API_HASH_PLATFORM "8e32000be3c4a4057057f32973e413b3c9517a9c"
+#elif defined(OS_MACOSX)
+#define CEF_API_HASH_PLATFORM "698ca8f4b36d446333755ba6431ba0ab42a814cb"
+#elif defined(OS_LINUX)
+#define CEF_API_HASH_PLATFORM "9d132433b77eaf33fc9f0fc9059a6eae3d386e63"
+#endif
+
+// Returns CEF version information for the libcef library. The |entry|
+// parameter describes which version component will be returned:
+// 0 - CEF_VERSION_MAJOR
+// 1 - CEF_COMMIT_NUMBER
+// 2 - CHROME_VERSION_MAJOR
+// 3 - CHROME_VERSION_MINOR
+// 4 - CHROME_VERSION_BUILD
+// 5 - CHROME_VERSION_PATCH
+///
+CEF_EXPORT int cef_version_info(int entry);
+
+///
+// Returns CEF API hashes for the libcef library. The returned string is owned
+// by the library and should not be freed. The |entry| parameter describes which
+// hash value will be returned:
+// 0 - CEF_API_HASH_PLATFORM
+// 1 - CEF_API_HASH_UNIVERSAL
+// 2 - CEF_COMMIT_HASH
+///
+CEF_EXPORT const char* cef_api_hash(int entry);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // APSTUDIO_HIDDEN_SYMBOLS
+
+#endif  // CEF_INCLUDE_CEF_VERSION_H_
diff --git a/src/include/libcef/cef_web_plugin.h b/src/include/libcef/cef_web_plugin.h
new file mode 100644
index 0000000..b7e199b
--- /dev/null
+++ b/src/include/libcef/cef_web_plugin.h
@@ -0,0 +1,148 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_WEB_PLUGIN_H_
+#define CEF_INCLUDE_CEF_WEB_PLUGIN_H_
+
+#include "include/cef_base.h"
+
+class CefBrowser;
+
+///
+// Information about a specific web plugin.
+///
+/*--cef(source=library)--*/
+class CefWebPluginInfo : public virtual CefBase {
+ public:
+  ///
+  // Returns the plugin name (i.e. Flash).
+  ///
+  /*--cef()--*/
+  virtual CefString GetName() =0;
+
+  ///
+  // Returns the plugin file path (DLL/bundle/library).
+  ///
+  /*--cef()--*/
+  virtual CefString GetPath() =0;
+
+  ///
+  // Returns the version of the plugin (may be OS-specific).
+  ///
+  /*--cef()--*/
+  virtual CefString GetVersion() =0;
+
+  ///
+  // Returns a description of the plugin from the version information.
+  ///
+  /*--cef()--*/
+  virtual CefString GetDescription() =0;
+};
+
+///
+// Interface to implement for visiting web plugin information. The methods of
+// this class will be called on the browser process UI thread.
+///
+/*--cef(source=client)--*/
+class CefWebPluginInfoVisitor : public virtual CefBase {
+ public:
+  ///
+  // Method that will be called once for each plugin. |count| is the 0-based
+  // index for the current plugin. |total| is the total number of plugins.
+  // Return false to stop visiting plugins. This method may never be called if
+  // no plugins are found.
+  ///
+  /*--cef()--*/
+  virtual bool Visit(CefRefPtr<CefWebPluginInfo> info, int count, int total) =0;
+};
+
+///
+// Visit web plugin information. Can be called on any thread in the browser
+// process.
+///
+/*--cef()--*/
+void CefVisitWebPluginInfo(CefRefPtr<CefWebPluginInfoVisitor> visitor);
+
+///
+// Cause the plugin list to refresh the next time it is accessed regardless
+// of whether it has already been loaded. Can be called on any thread in the
+// browser process.
+///
+/*--cef()--*/
+void CefRefreshWebPlugins();
+
+///
+// Unregister an internal plugin. This may be undone the next time
+// CefRefreshWebPlugins() is called. Can be called on any thread in the browser
+// process.
+///
+/*--cef()--*/
+void CefUnregisterInternalWebPlugin(const CefString& path);
+
+///
+// Register a plugin crash. Can be called on any thread in the browser process
+// but will be executed on the IO thread.
+///
+/*--cef()--*/
+void CefRegisterWebPluginCrash(const CefString& path);
+
+///
+// Interface to implement for receiving unstable plugin information. The methods
+// of this class will be called on the browser process IO thread.
+///
+/*--cef(source=client)--*/
+class CefWebPluginUnstableCallback : public virtual CefBase {
+ public:
+  ///
+  // Method that will be called for the requested plugin. |unstable| will be
+  // true if the plugin has reached the crash count threshold of 3 times in 120
+  // seconds.
+  ///
+  /*--cef()--*/
+  virtual void IsUnstable(const CefString& path,
+                          bool unstable) =0;
+};
+
+///
+// Query if a plugin is unstable. Can be called on any thread in the browser
+// process.
+///
+/*--cef()--*/
+void CefIsWebPluginUnstable(const CefString& path,
+                            CefRefPtr<CefWebPluginUnstableCallback> callback);
+
+
+#endif  // CEF_INCLUDE_CEF_WEB_PLUGIN_H_
diff --git a/src/include/libcef/cef_xml_reader.h b/src/include/libcef/cef_xml_reader.h
new file mode 100644
index 0000000..86be8ba
--- /dev/null
+++ b/src/include/libcef/cef_xml_reader.h
@@ -0,0 +1,268 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_XML_READER_H_
+#define CEF_INCLUDE_CEF_XML_READER_H_
+#pragma once
+
+#include "include/cef_base.h"
+#include "include/cef_stream.h"
+
+///
+// Class that supports the reading of XML data via the libxml streaming API.
+// The methods of this class should only be called on the thread that creates
+// the object.
+///
+/*--cef(source=library)--*/
+class CefXmlReader : public virtual CefBase {
+ public:
+  typedef cef_xml_encoding_type_t EncodingType;
+  typedef cef_xml_node_type_t NodeType;
+
+  ///
+  // Create a new CefXmlReader object. The returned object's methods can only
+  // be called from the thread that created the object.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefXmlReader> Create(CefRefPtr<CefStreamReader> stream,
+                                        EncodingType encodingType,
+                                        const CefString& URI);
+
+  ///
+  // Moves the cursor to the next node in the document. This method must be
+  // called at least once to set the current cursor position. Returns true if
+  // the cursor position was set successfully.
+  ///
+  /*--cef()--*/
+  virtual bool MoveToNextNode() =0;
+
+  ///
+  // Close the document. This should be called directly to ensure that cleanup
+  // occurs on the correct thread.
+  ///
+  /*--cef()--*/
+  virtual bool Close() =0;
+
+  ///
+  // Returns true if an error has been reported by the XML parser.
+  ///
+  /*--cef()--*/
+  virtual bool HasError() =0;
+
+  ///
+  // Returns the error string.
+  ///
+  /*--cef()--*/
+  virtual CefString GetError() =0;
+
+
+  // The below methods retrieve data for the node at the current cursor
+  // position.
+
+  ///
+  // Returns the node type.
+  ///
+  /*--cef(default_retval=XML_NODE_UNSUPPORTED)--*/
+  virtual NodeType GetType() =0;
+
+  ///
+  // Returns the node depth. Depth starts at 0 for the root node.
+  ///
+  /*--cef()--*/
+  virtual int GetDepth() =0;
+
+  ///
+  // Returns the local name. See
+  // http://www.w3.org/TR/REC-xml-names/#NT-LocalPart for additional details.
+  ///
+  /*--cef()--*/
+  virtual CefString GetLocalName() =0;
+
+  ///
+  // Returns the namespace prefix. See http://www.w3.org/TR/REC-xml-names/ for
+  // additional details.
+  ///
+  /*--cef()--*/
+  virtual CefString GetPrefix() =0;
+
+  ///
+  // Returns the qualified name, equal to (Prefix:)LocalName. See
+  // http://www.w3.org/TR/REC-xml-names/#ns-qualnames for additional details.
+  ///
+  /*--cef()--*/
+  virtual CefString GetQualifiedName() =0;
+
+  ///
+  // Returns the URI defining the namespace associated with the node. See
+  // http://www.w3.org/TR/REC-xml-names/ for additional details.
+  ///
+  /*--cef()--*/
+  virtual CefString GetNamespaceURI() =0;
+
+  ///
+  // Returns the base URI of the node. See http://www.w3.org/TR/xmlbase/ for
+  // additional details.
+  ///
+  /*--cef()--*/
+  virtual CefString GetBaseURI() =0;
+
+  ///
+  // Returns the xml:lang scope within which the node resides. See
+  // http://www.w3.org/TR/REC-xml/#sec-lang-tag for additional details.
+  ///
+  /*--cef()--*/
+  virtual CefString GetXmlLang() =0;
+
+  ///
+  // Returns true if the node represents an empty element. <a/> is considered
+  // empty but <a></a> is not.
+  ///
+  /*--cef()--*/
+  virtual bool IsEmptyElement() =0;
+
+  ///
+  // Returns true if the node has a text value.
+  ///
+  /*--cef()--*/
+  virtual bool HasValue() =0;
+
+  ///
+  // Returns the text value.
+  ///
+  /*--cef()--*/
+  virtual CefString GetValue() =0;
+
+  ///
+  // Returns true if the node has attributes.
+  ///
+  /*--cef()--*/
+  virtual bool HasAttributes() =0;
+
+  ///
+  // Returns the number of attributes.
+  ///
+  /*--cef()--*/
+  virtual size_t GetAttributeCount() =0;
+
+  ///
+  // Returns the value of the attribute at the specified 0-based index.
+  ///
+  /*--cef(capi_name=get_attribute_byindex,index_param=index)--*/
+  virtual CefString GetAttribute(int index) =0;
+
+  ///
+  // Returns the value of the attribute with the specified qualified name.
+  ///
+  /*--cef(capi_name=get_attribute_byqname)--*/
+  virtual CefString GetAttribute(const CefString& qualifiedName) =0;
+
+  ///
+  // Returns the value of the attribute with the specified local name and
+  // namespace URI.
+  ///
+  /*--cef(capi_name=get_attribute_bylname)--*/
+  virtual CefString GetAttribute(const CefString& localName,
+                                 const CefString& namespaceURI) =0;
+
+  ///
+  // Returns an XML representation of the current node's children.
+  ///
+  /*--cef()--*/
+  virtual CefString GetInnerXml() =0;
+
+  ///
+  // Returns an XML representation of the current node including its children.
+  ///
+  /*--cef()--*/
+  virtual CefString GetOuterXml() =0;
+
+  ///
+  // Returns the line number for the current node.
+  ///
+  /*--cef()--*/
+  virtual int GetLineNumber() =0;
+
+
+  // Attribute nodes are not traversed by default. The below methods can be
+  // used to move the cursor to an attribute node. MoveToCarryingElement() can
+  // be called afterwards to return the cursor to the carrying element. The
+  // depth of an attribute node will be 1 + the depth of the carrying element.
+
+  ///
+  // Moves the cursor to the attribute at the specified 0-based index. Returns
+  // true if the cursor position was set successfully.
+  ///
+  /*--cef(capi_name=move_to_attribute_byindex,index_param=index)--*/
+  virtual bool MoveToAttribute(int index) =0;
+
+  ///
+  // Moves the cursor to the attribute with the specified qualified name.
+  // Returns true if the cursor position was set successfully.
+  ///
+  /*--cef(capi_name=move_to_attribute_byqname)--*/
+  virtual bool MoveToAttribute(const CefString& qualifiedName) =0;
+
+  ///
+  // Moves the cursor to the attribute with the specified local name and
+  // namespace URI. Returns true if the cursor position was set successfully.
+  ///
+  /*--cef(capi_name=move_to_attribute_bylname)--*/
+  virtual bool MoveToAttribute(const CefString& localName,
+                               const CefString& namespaceURI) =0;
+
+  ///
+  // Moves the cursor to the first attribute in the current element. Returns
+  // true if the cursor position was set successfully.
+  ///
+  /*--cef()--*/
+  virtual bool MoveToFirstAttribute() =0;
+
+  ///
+  // Moves the cursor to the next attribute in the current element. Returns
+  // true if the cursor position was set successfully.
+  ///
+  /*--cef()--*/
+  virtual bool MoveToNextAttribute() =0;
+
+  ///
+  // Moves the cursor back to the carrying element. Returns true if the cursor
+  // position was set successfully.
+  ///
+  /*--cef()--*/
+  virtual bool MoveToCarryingElement() =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_XML_READER_H_
diff --git a/src/include/libcef/cef_zip_reader.h b/src/include/libcef/cef_zip_reader.h
new file mode 100644
index 0000000..5d8788e
--- /dev/null
+++ b/src/include/libcef/cef_zip_reader.h
@@ -0,0 +1,141 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_ZIP_READER_H_
+#define CEF_INCLUDE_CEF_ZIP_READER_H_
+
+#include "include/cef_base.h"
+#include "include/cef_stream.h"
+
+///
+// Class that supports the reading of zip archives via the zlib unzip API.
+// The methods of this class should only be called on the thread that creates
+// the object.
+///
+/*--cef(source=library)--*/
+class CefZipReader : public virtual CefBase {
+ public:
+  ///
+  // Create a new CefZipReader object. The returned object's methods can only
+  // be called from the thread that created the object.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefZipReader> Create(CefRefPtr<CefStreamReader> stream);
+
+  ///
+  // Moves the cursor to the first file in the archive. Returns true if the
+  // cursor position was set successfully.
+  ///
+  /*--cef()--*/
+  virtual bool MoveToFirstFile() =0;
+
+  ///
+  // Moves the cursor to the next file in the archive. Returns true if the
+  // cursor position was set successfully.
+  ///
+  /*--cef()--*/
+  virtual bool MoveToNextFile() =0;
+
+  ///
+  // Moves the cursor to the specified file in the archive. If |caseSensitive|
+  // is true then the search will be case sensitive. Returns true if the cursor
+  // position was set successfully.
+  ///
+  /*--cef()--*/
+  virtual bool MoveToFile(const CefString& fileName, bool caseSensitive) =0;
+
+  ///
+  // Closes the archive. This should be called directly to ensure that cleanup
+  // occurs on the correct thread.
+  ///
+  /*--cef()--*/
+  virtual bool Close() =0;
+
+
+  // The below methods act on the file at the current cursor position.
+
+  ///
+  // Returns the name of the file.
+  ///
+  /*--cef()--*/
+  virtual CefString GetFileName() =0;
+
+  ///
+  // Returns the uncompressed size of the file.
+  ///
+  /*--cef()--*/
+  virtual int64 GetFileSize() =0;
+
+  ///
+  // Returns the last modified timestamp for the file.
+  ///
+  /*--cef()--*/
+  virtual CefTime GetFileLastModified() =0;
+
+  ///
+  // Opens the file for reading of uncompressed data. A read password may
+  // optionally be specified.
+  ///
+  /*--cef(optional_param=password)--*/
+  virtual bool OpenFile(const CefString& password) =0;
+
+  ///
+  // Closes the file.
+  ///
+  /*--cef()--*/
+  virtual bool CloseFile() =0;
+
+  ///
+  // Read uncompressed file contents into the specified buffer. Returns < 0 if
+  // an error occurred, 0 if at the end of file, or the number of bytes read.
+  ///
+  /*--cef()--*/
+  virtual int ReadFile(void* buffer, size_t bufferSize) =0;
+
+  ///
+  // Returns the current offset in the uncompressed file contents.
+  ///
+  /*--cef()--*/
+  virtual int64 Tell() =0;
+
+  ///
+  // Returns true if at end of the file contents.
+  ///
+  /*--cef()--*/
+  virtual bool Eof() =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_ZIP_READER_H_
diff --git a/src/include/libcef/internal/cef_export.h b/src/include/libcef/internal/cef_export.h
new file mode 100644
index 0000000..4f9081b
--- /dev/null
+++ b/src/include/libcef/internal/cef_export.h
@@ -0,0 +1,58 @@
+// Copyright (c) 2009 The Chromium Embedded Framework Authors. All rights
+// reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef CEF_INCLUDE_INTERNAL_CEF_EXPORT_H_
+#define CEF_INCLUDE_INTERNAL_CEF_EXPORT_H_
+#pragma once
+
+#include"libcef/base/cef_build.h"
+
+#if defined(COMPILER_MSVC)
+	#ifdef BUILDING_CEF_SHARED
+		#define CEF_EXPORT __declspec(dllexport)
+	#elif USING_CEF_SHARED
+		#define CEF_EXPORT __declspec(dllimport)
+	#else
+		#define CEF_EXPORT
+	#endif
+		#define CEF_CALLBACK __stdcall
+#elif defined(COMPILER_GCC)
+	#define CEF_EXPORT __attribute__ ((visibility("default")))
+	#define CEF_CALLBACK
+#endif  // COMPILER_GCC
+
+#ifdef __WATCOMC__
+    // Watcom usa exportações via pragma, mas podemos definir como vazio
+    #define CEF_EXPORT __declspec(dllexport)
+	#define CEF_EXPORT_WAT __cdecl
+    #define CEF_CALLBACK __stdcall
+#endif
+
+#endif  // CEF_INCLUDE_INTERNAL_CEF_EXPORT_H_
diff --git a/src/include/libcef/internal/cef_logging_internal.h b/src/include/libcef/internal/cef_logging_internal.h
new file mode 100644
index 0000000..49f8ddc
--- /dev/null
+++ b/src/include/libcef/internal/cef_logging_internal.h
@@ -0,0 +1,66 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef CEF_INCLUDE_INTERNAL_CEF_LOGGING_INTERNAL_H_
+#define CEF_INCLUDE_INTERNAL_CEF_LOGGING_INTERNAL_H_
+#pragma once
+
+#include "libcef/internal/cef_export.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// See include/base/cef_logging.h for macros and intended usage.
+
+///
+// Gets the current log level.
+///
+CEF_EXPORT int cef_get_min_log_level();
+
+///
+// Gets the current vlog level for the given file (usually taken from
+// __FILE__). Note that |N| is the size *with* the null terminator.
+///
+CEF_EXPORT int cef_get_vlog_level(const char* file_start, size_t N);
+
+///
+// Add a log message. See the LogSeverity defines for supported |severity|
+// values.
+///
+CEF_EXPORT void cef_log(const char* file,
+                        int line,
+                        int severity,
+                        const char* message);
+
+#ifdef __cplusplus
+}
+#endif  // __cplusplus
+
+#endif  // CEF_INCLUDE_INTERNAL_CEF_LOGGING_INTERNAL_H_
diff --git a/src/include/libcef/internal/cef_ptr.h b/src/include/libcef/internal/cef_ptr.h
new file mode 100644
index 0000000..4bb372f
--- /dev/null
+++ b/src/include/libcef/internal/cef_ptr.h
@@ -0,0 +1,161 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+#ifndef CEF_INCLUDE_INTERNAL_CEF_PTR_H_
+#define CEF_INCLUDE_INTERNAL_CEF_PTR_H_
+#pragma once
+
+#include "libcef/base/cef_ref_counted.h"
+
+///
+// Smart pointer implementation that is an alias of scoped_refptr from
+// include/base/cef_ref_counted.h.
+// <p>
+// A smart pointer class for reference counted objects.  Use this class instead
+// of calling AddRef and Release manually on a reference counted object to
+// avoid common memory leaks caused by forgetting to Release an object
+// reference.  Sample usage:
+// <pre>
+//   class MyFoo : public CefBase {
+//    ...
+//   };
+//
+//   void some_function() {
+//     // The MyFoo object that |foo| represents starts with a single
+//     // reference.
+//     CefRefPtr&lt;MyFoo&gt; foo = new MyFoo();
+//     foo-&gt;Method(param);
+//     // |foo| is released when this function returns
+//   }
+//
+//   void some_other_function() {
+//     CefRefPtr&lt;MyFoo&gt; foo = new MyFoo();
+//     ...
+//     foo = NULL;  // explicitly releases |foo|
+//     ...
+//     if (foo)
+//       foo-&gt;Method(param);
+//   }
+// </pre>
+// The above examples show how CefRefPtr&lt;T&gt; acts like a pointer to T.
+// Given two CefRefPtr&lt;T&gt; classes, it is also possible to exchange
+// references between the two objects, like so:
+// <pre>
+//   {
+//     CefRefPtr&lt;MyFoo&gt; a = new MyFoo();
+//     CefRefPtr&lt;MyFoo&gt; b;
+//
+//     b.swap(a);
+//     // now, |b| references the MyFoo object, and |a| references NULL.
+//   }
+// </pre>
+// To make both |a| and |b| in the above example reference the same MyFoo
+// object, simply use the assignment operator:
+// <pre>
+//   {
+//     CefRefPtr&lt;MyFoo&gt; a = new MyFoo();
+//     CefRefPtr&lt;MyFoo&gt; b;
+//
+//     b = a;
+//     // now, |a| and |b| each own a reference to the same MyFoo object.
+//     // the reference count of the underlying MyFoo object will be 2.
+//   }
+// </pre>
+// Reference counted objects can also be passed as function parameters and
+// used as function return values:
+// <pre>
+//   void some_func_with_param(CefRefPtr&lt;MyFoo&gt; param) {
+//     // A reference is added to the MyFoo object that |param| represents
+//     // during the scope of some_func_with_param() and released when
+//     // some_func_with_param() goes out of scope.
+//   }
+//
+//   CefRefPtr&lt;MyFoo&gt; some_func_with_retval() {
+//     // The MyFoo object that |foox| represents starts with a single
+//     // reference.
+//     CefRefPtr&lt;MyFoo&gt; foox = new MyFoo();
+//
+//     // Creating the return value adds an additional reference.
+//     return foox;
+//
+//     // When some_func_with_retval() goes out of scope the original |foox|
+//     // reference is released.
+//   }
+//
+//   void and_another_function() {
+//     CefRefPtr&lt;MyFoo&gt; foo = new MyFoo();
+//
+//     // pass |foo| as a parameter.
+//     some_function(foo);
+//
+//     CefRefPtr&lt;MyFoo&gt; foo2 = some_func_with_retval();
+//     // Now, since we kept a reference to the some_func_with_retval() return
+//     // value, |foo2| is the only class pointing to the MyFoo object created
+//     in some_func_with_retval(), and it has a reference count of 1.
+//
+//     some_func_with_retval();
+//     // Now, since we didn't keep a reference to the some_func_with_retval()
+//     // return value, the MyFoo object created in some_func_with_retval()
+//     // will automatically be released.
+//   }
+// </pre>
+// And in standard containers:
+// <pre>
+//   {
+//      // Create a vector that holds MyFoo objects.
+//      std::vector&lt;CefRefPtr&lt;MyFoo&gt; &gt; MyFooVec;
+//
+//     // The MyFoo object that |foo| represents starts with a single
+//     // reference.
+//     CefRefPtr&lt;MyFoo&gt; foo = new MyFoo();
+//
+//     // When the MyFoo object is added to |MyFooVec| the reference count
+//     // is increased to 2.
+//     MyFooVec.push_back(foo);
+//   }
+// </pre>
+// </p>
+///
+template <class T>
+class CefRefPtr : public scoped_refptr<T> {
+ public:
+  typedef scoped_refptr<T> parent;
+
+  CefRefPtr() : parent() {}
+
+  CefRefPtr(T* p) : parent(p) {}
+
+  CefRefPtr(const scoped_refptr<T>& r) : parent(r) {}
+
+  template <typename U>
+  CefRefPtr(const scoped_refptr<U>& r) : parent(r) {}
+};
+
+#endif  // CEF_INCLUDE_INTERNAL_CEF_PTR_H_
diff --git a/src/include/libcef/internal/cef_string.h b/src/include/libcef/internal/cef_string.h
new file mode 100644
index 0000000..9ebd6b4
--- /dev/null
+++ b/src/include/libcef/internal/cef_string.h
@@ -0,0 +1,113 @@
+// Copyright (c) 2010 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef CEF_INCLUDE_INTERNAL_CEF_STRING_H_
+#define CEF_INCLUDE_INTERNAL_CEF_STRING_H_
+#pragma once
+
+// The CEF interface is built with one string type as the default. Comment out
+// all but one of the CEF_STRING_TYPE_* defines below to specify the default.
+// If you change the default you MUST recompile all of CEF.
+
+// Build with the UTF8 string type as default.
+// #define CEF_STRING_TYPE_UTF8 1
+
+// Build with the UTF16 string type as default.
+#define CEF_STRING_TYPE_UTF16 1
+
+// Build with the wide string type as default.
+// #define CEF_STRING_TYPE_WIDE 1
+
+
+#include "libcef/internal/cef_string_types.h"
+
+#ifdef __cplusplus
+#include "libcef/internal/cef_string_wrappers.h"
+#if defined(CEF_STRING_TYPE_UTF16)
+typedef CefStringUTF16 CefString;
+#elif defined(CEF_STRING_TYPE_UTF8)
+typedef CefStringUTF8 CefString;
+#elif defined(CEF_STRING_TYPE_WIDE)
+typedef CefStringWide CefString;
+#endif
+#endif  // __cplusplus
+
+#if defined(CEF_STRING_TYPE_UTF8)
+typedef char cef_char_t;
+typedef cef_string_utf8_t cef_string_t;
+typedef cef_string_userfree_utf8_t cef_string_userfree_t;
+#define cef_string_set cef_string_utf8_set
+#define cef_string_copy cef_string_utf8_copy
+#define cef_string_clear cef_string_utf8_clear
+#define cef_string_userfree_alloc cef_string_userfree_utf8_alloc
+#define cef_string_userfree_free cef_string_userfree_utf8_free
+#define cef_string_from_ascii cef_string_utf8_copy
+#define cef_string_to_utf8 cef_string_utf8_copy
+#define cef_string_from_utf8 cef_string_utf8_copy
+#define cef_string_to_utf16 cef_string_utf8_to_utf16
+#define cef_string_from_utf16 cef_string_utf16_to_utf8
+#define cef_string_to_wide cef_string_utf8_to_wide
+#define cef_string_from_wide cef_string_wide_to_utf8
+#elif defined(CEF_STRING_TYPE_UTF16)
+typedef char16 cef_char_t;
+typedef cef_string_userfree_utf16_t cef_string_userfree_t;
+typedef cef_string_utf16_t cef_string_t;
+#define cef_string_set cef_string_utf16_set
+#define cef_string_copy cef_string_utf16_copy
+#define cef_string_clear cef_string_utf16_clear
+#define cef_string_userfree_alloc cef_string_userfree_utf16_alloc
+#define cef_string_userfree_free cef_string_userfree_utf16_free
+#define cef_string_from_ascii cef_string_ascii_to_utf16
+#define cef_string_to_utf8 cef_string_utf16_to_utf8
+#define cef_string_from_utf8 cef_string_utf8_to_utf16
+#define cef_string_to_utf16 cef_string_utf16_copy
+#define cef_string_from_utf16 cef_string_utf16_copy
+#define cef_string_to_wide cef_string_utf16_to_wide
+#define cef_string_from_wide cef_string_wide_to_utf16
+#elif defined(CEF_STRING_TYPE_WIDE)
+typedef wchar_t cef_char_t;
+typedef cef_string_wide_t cef_string_t;
+typedef cef_string_userfree_wide_t cef_string_userfree_t;
+#define cef_string_set cef_string_wide_set
+#define cef_string_copy cef_string_wide_copy
+#define cef_string_clear cef_string_wide_clear
+#define cef_string_userfree_alloc cef_string_userfree_wide_alloc
+#define cef_string_userfree_free cef_string_userfree_wide_free
+#define cef_string_from_ascii cef_string_ascii_to_wide
+#define cef_string_to_utf8 cef_string_wide_to_utf8
+#define cef_string_from_utf8 cef_string_utf8_to_wide
+#define cef_string_to_utf16 cef_string_wide_to_utf16
+#define cef_string_from_utf16 cef_string_utf16_to_wide
+#define cef_string_to_wide cef_string_wide_copy
+#define cef_string_from_wide cef_string_wide_copy
+#else
+#error Please choose a string type.
+#endif
+
+#endif  // CEF_INCLUDE_INTERNAL_CEF_STRING_H_
diff --git a/src/include/libcef/internal/cef_string_list.h b/src/include/libcef/internal/cef_string_list.h
new file mode 100644
index 0000000..8356d71
--- /dev/null
+++ b/src/include/libcef/internal/cef_string_list.h
@@ -0,0 +1,88 @@
+// Copyright (c) 2009 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef CEF_INCLUDE_INTERNAL_CEF_STRING_LIST_H_
+#define CEF_INCLUDE_INTERNAL_CEF_STRING_LIST_H_
+#pragma once
+
+#include "libcef/internal/cef_export.h"
+#include "libcef/internal/cef_string.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///
+// CEF string maps are a set of key/value string pairs.
+///
+typedef void* cef_string_list_t;
+
+///
+// Allocate a new string map.
+///
+CEF_EXPORT cef_string_list_t cef_string_list_alloc();
+
+///
+// Return the number of elements in the string list.
+///
+CEF_EXPORT int cef_string_list_size(cef_string_list_t list);
+
+///
+// Retrieve the value at the specified zero-based string list index. Returns
+// true (1) if the value was successfully retrieved.
+///
+CEF_EXPORT int cef_string_list_value(cef_string_list_t list,
+                                     int index, cef_string_t* value);
+
+///
+// Append a new value at the end of the string list.
+///
+CEF_EXPORT void cef_string_list_append(cef_string_list_t list,
+                                       const cef_string_t* value);
+
+///
+// Clear the string list.
+///
+CEF_EXPORT void cef_string_list_clear(cef_string_list_t list);
+
+///
+// Free the string list.
+///
+CEF_EXPORT void cef_string_list_free(cef_string_list_t list);
+
+///
+// Creates a copy of an existing string list.
+///
+CEF_EXPORT cef_string_list_t cef_string_list_copy(cef_string_list_t list);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_INTERNAL_CEF_STRING_LIST_H_
diff --git a/src/include/libcef/internal/cef_string_map.h b/src/include/libcef/internal/cef_string_map.h
new file mode 100644
index 0000000..bdb5e31
--- /dev/null
+++ b/src/include/libcef/internal/cef_string_map.h
@@ -0,0 +1,97 @@
+// Copyright (c) 2009 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef CEF_INCLUDE_INTERNAL_CEF_STRING_MAP_H_
+#define CEF_INCLUDE_INTERNAL_CEF_STRING_MAP_H_
+#pragma once
+
+#include "libcef/internal/cef_export.h"
+#include "libcef/internal/cef_string.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///
+// CEF string maps are a set of key/value string pairs.
+///
+typedef void* cef_string_map_t;
+
+///
+// Allocate a new string map.
+///
+CEF_EXPORT cef_string_map_t cef_string_map_alloc();
+
+///
+// Return the number of elements in the string map.
+///
+CEF_EXPORT int cef_string_map_size(cef_string_map_t map);
+
+///
+// Return the value assigned to the specified key.
+///
+CEF_EXPORT int cef_string_map_find(cef_string_map_t map,
+                                   const cef_string_t* key,
+                                   cef_string_t* value);
+
+///
+// Return the key at the specified zero-based string map index.
+///
+CEF_EXPORT int cef_string_map_key(cef_string_map_t map, int index,
+                                  cef_string_t* key);
+
+///
+// Return the value at the specified zero-based string map index.
+///
+CEF_EXPORT int cef_string_map_value(cef_string_map_t map, int index,
+                                    cef_string_t* value);
+
+///
+// Append a new key/value pair at the end of the string map.
+///
+CEF_EXPORT int cef_string_map_append(cef_string_map_t map,
+                                     const cef_string_t* key,
+                                     const cef_string_t* value);
+
+///
+// Clear the string map.
+///
+CEF_EXPORT void cef_string_map_clear(cef_string_map_t map);
+
+///
+// Free the string map.
+///
+CEF_EXPORT void cef_string_map_free(cef_string_map_t map);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_INTERNAL_CEF_STRING_MAP_H_
diff --git a/src/include/libcef/internal/cef_string_multimap.h b/src/include/libcef/internal/cef_string_multimap.h
new file mode 100644
index 0000000..a2045f6
--- /dev/null
+++ b/src/include/libcef/internal/cef_string_multimap.h
@@ -0,0 +1,105 @@
+// Copyright (c) 2011 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef CEF_INCLUDE_INTERNAL_CEF_STRING_MULTIMAP_H_
+#define CEF_INCLUDE_INTERNAL_CEF_STRING_MULTIMAP_H_
+#pragma once
+
+#include "libcef/internal/cef_export.h"
+#include "libcef/internal/cef_string.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///
+// CEF string multimaps are a set of key/value string pairs.
+// More than one value can be assigned to a single key.
+///
+typedef void* cef_string_multimap_t;
+
+///
+// Allocate a new string multimap.
+///
+CEF_EXPORT cef_string_multimap_t cef_string_multimap_alloc();
+
+///
+// Return the number of elements in the string multimap.
+///
+CEF_EXPORT int cef_string_multimap_size(cef_string_multimap_t map);
+
+///
+// Return the number of values with the specified key.
+///
+CEF_EXPORT int cef_string_multimap_find_count(cef_string_multimap_t map,
+                                              const cef_string_t* key);
+
+///
+// Return the value_index-th value with the specified key.
+///
+CEF_EXPORT int cef_string_multimap_enumerate(cef_string_multimap_t map,
+                                             const cef_string_t* key,
+                                             int value_index,
+                                             cef_string_t* value);
+
+///
+// Return the key at the specified zero-based string multimap index.
+///
+CEF_EXPORT int cef_string_multimap_key(cef_string_multimap_t map, int index,
+                                       cef_string_t* key);
+
+///
+// Return the value at the specified zero-based string multimap index.
+///
+CEF_EXPORT int cef_string_multimap_value(cef_string_multimap_t map, int index,
+                                         cef_string_t* value);
+
+///
+// Append a new key/value pair at the end of the string multimap.
+///
+CEF_EXPORT int cef_string_multimap_append(cef_string_multimap_t map,
+                                          const cef_string_t* key,
+                                          const cef_string_t* value);
+
+///
+// Clear the string multimap.
+///
+CEF_EXPORT void cef_string_multimap_clear(cef_string_multimap_t map);
+
+///
+// Free the string multimap.
+///
+CEF_EXPORT void cef_string_multimap_free(cef_string_multimap_t map);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_INTERNAL_CEF_STRING_MULTIMAP_H_
diff --git a/src/include/libcef/internal/cef_string_types.h b/src/include/libcef/internal/cef_string_types.h
new file mode 100644
index 0000000..6145b3c
--- /dev/null
+++ b/src/include/libcef/internal/cef_string_types.h
@@ -0,0 +1,192 @@
+// Copyright (c) 2010 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef CEF_INCLUDE_INTERNAL_CEF_STRING_TYPES_H_
+#define CEF_INCLUDE_INTERNAL_CEF_STRING_TYPES_H_
+#pragma once
+
+// CEF provides functions for converting between UTF-8, -16 and -32 strings.
+// CEF string types are safe for reading from multiple threads but not for
+// modification. It is the user's responsibility to provide synchronization if
+// modifying CEF strings from multiple threads.
+
+#include <stddef.h>
+
+#include "libcef/base/cef_basictypes.h"
+#include "libcef/internal/cef_export.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// CEF string type definitions. Whomever allocates |str| is responsible for
+// providing an appropriate |dtor| implementation that will free the string in
+// the same memory space. When reusing an existing string structure make sure
+// to call |dtor| for the old value before assigning new |str| and |dtor|
+// values. Static strings will have a NULL |dtor| value. Using the below
+// functions if you want this managed for you.
+
+typedef struct _cef_string_wide_t {
+  wchar_t* str;
+  size_t length;
+  void (*dtor)(wchar_t* str);
+} cef_string_wide_t;
+
+typedef struct _cef_string_utf8_t {
+  char* str;
+  size_t length;
+  void (*dtor)(char* str);
+} cef_string_utf8_t;
+
+typedef struct _cef_string_utf16_t {
+  char16* str;
+  size_t length;
+  void (*dtor)(char16* str);
+} cef_string_utf16_t;
+
+
+///
+// These functions set string values. If |copy| is true (1) the value will be
+// copied instead of referenced. It is up to the user to properly manage
+// the lifespan of references.
+///
+
+CEF_EXPORT int cef_string_wide_set(const wchar_t* src, size_t src_len,
+                                   cef_string_wide_t* output, int copy);
+CEF_EXPORT int cef_string_utf8_set(const char* src, size_t src_len,
+                                   cef_string_utf8_t* output, int copy);
+CEF_EXPORT int cef_string_utf16_set(const char16* src, size_t src_len,
+                                    cef_string_utf16_t* output, int copy);
+
+
+///
+// Convenience macros for copying values.
+///
+
+#define cef_string_wide_copy(src, src_len, output)  \
+    cef_string_wide_set(src, src_len, output, true)
+#define cef_string_utf8_copy(src, src_len, output)  \
+    cef_string_utf8_set(src, src_len, output, true)
+#define cef_string_utf16_copy(src, src_len, output)  \
+    cef_string_utf16_set(src, src_len, output, true)
+
+
+///
+// These functions clear string values. The structure itself is not freed.
+///
+
+CEF_EXPORT void cef_string_wide_clear(cef_string_wide_t* str);
+CEF_EXPORT void cef_string_utf8_clear(cef_string_utf8_t* str);
+CEF_EXPORT void cef_string_utf16_clear(cef_string_utf16_t* str);
+
+
+///
+// These functions compare two string values with the same results as strcmp().
+///
+
+CEF_EXPORT int cef_string_wide_cmp(const cef_string_wide_t* str1,
+                                   const cef_string_wide_t* str2);
+CEF_EXPORT int cef_string_utf8_cmp(const cef_string_utf8_t* str1,
+                                   const cef_string_utf8_t* str2);
+CEF_EXPORT int cef_string_utf16_cmp(const cef_string_utf16_t* str1,
+                                    const cef_string_utf16_t* str2);
+
+
+///
+// These functions convert between UTF-8, -16, and -32 strings. They are
+// potentially slow so unnecessary conversions should be avoided. The best
+// possible result will always be written to |output| with the boolean return
+// value indicating whether the conversion is 100% valid.
+///
+
+CEF_EXPORT int cef_string_wide_to_utf8(const wchar_t* src, size_t src_len,
+                                       cef_string_utf8_t* output);
+CEF_EXPORT int cef_string_utf8_to_wide(const char* src, size_t src_len,
+                                       cef_string_wide_t* output);
+
+CEF_EXPORT int cef_string_wide_to_utf16(const wchar_t* src, size_t src_len,
+                                        cef_string_utf16_t* output);
+CEF_EXPORT int cef_string_utf16_to_wide(const char16* src, size_t src_len,
+                                        cef_string_wide_t* output);
+
+CEF_EXPORT int cef_string_utf8_to_utf16(const char* src, size_t src_len,
+                                        cef_string_utf16_t* output);
+CEF_EXPORT int cef_string_utf16_to_utf8(const char16* src, size_t src_len,
+                                        cef_string_utf8_t* output);
+
+
+///
+// These functions convert an ASCII string, typically a hardcoded constant, to a
+// Wide/UTF16 string. Use instead of the UTF8 conversion routines if you know
+// the string is ASCII.
+///
+
+CEF_EXPORT int cef_string_ascii_to_wide(const char* src, size_t src_len,
+                                        cef_string_wide_t* output);
+CEF_EXPORT int cef_string_ascii_to_utf16(const char* src, size_t src_len,
+                                         cef_string_utf16_t* output);
+
+
+
+///
+// It is sometimes necessary for the system to allocate string structures with
+// the expectation that the user will free them. The userfree types act as a
+// hint that the user is responsible for freeing the structure.
+///
+
+typedef cef_string_wide_t* cef_string_userfree_wide_t;
+typedef cef_string_utf8_t* cef_string_userfree_utf8_t;
+typedef cef_string_utf16_t* cef_string_userfree_utf16_t;
+
+
+///
+// These functions allocate a new string structure. They must be freed by
+// calling the associated free function.
+///
+
+CEF_EXPORT cef_string_userfree_wide_t cef_string_userfree_wide_alloc();
+CEF_EXPORT cef_string_userfree_utf8_t cef_string_userfree_utf8_alloc();
+CEF_EXPORT cef_string_userfree_utf16_t cef_string_userfree_utf16_alloc();
+
+
+///
+// These functions free the string structure allocated by the associated
+// alloc function. Any string contents will first be cleared.
+///
+
+CEF_EXPORT void cef_string_userfree_wide_free(cef_string_userfree_wide_t str);
+CEF_EXPORT void cef_string_userfree_utf8_free(cef_string_userfree_utf8_t str);
+CEF_EXPORT void cef_string_userfree_utf16_free(cef_string_userfree_utf16_t str);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_INTERNAL_CEF_STRING_TYPES_H_
diff --git a/src/include/libcef/internal/cef_string_wrappers.h b/src/include/libcef/internal/cef_string_wrappers.h
new file mode 100644
index 0000000..7d77dda
--- /dev/null
+++ b/src/include/libcef/internal/cef_string_wrappers.h
@@ -0,0 +1,730 @@
+// Copyright (c) 2010 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef CEF_INCLUDE_INTERNAL_CEF_STRING_WRAPPERS_H_
+#define CEF_INCLUDE_INTERNAL_CEF_STRING_WRAPPERS_H_
+#pragma once
+
+#include <memory.h>
+#include <string>
+
+#include "libcef/base/cef_string16.h"
+#include "libcef/internal/cef_string_types.h"
+
+#if defined(USING_CHROMIUM_INCLUDES)
+#include "base/files/file_path.h"
+#endif
+
+///
+// Traits implementation for wide character strings.
+///
+struct CefStringTraitsWide {
+  typedef wchar_t char_type;
+  typedef cef_string_wide_t struct_type;
+  typedef cef_string_userfree_wide_t userfree_struct_type;
+
+  static inline void clear(struct_type *s) { cef_string_wide_clear(s); }
+  static inline int set(const char_type* src, size_t src_size,
+                        struct_type* output, int copy) {
+    return cef_string_wide_set(src, src_size, output, copy);
+  }
+  static inline int compare(const struct_type* s1, const struct_type* s2) {
+    return cef_string_wide_cmp(s1, s2);
+  }
+  static inline userfree_struct_type userfree_alloc() {
+    return cef_string_userfree_wide_alloc();
+  }
+  static inline void userfree_free(userfree_struct_type ufs) {
+    return cef_string_userfree_wide_free(ufs);
+  }
+
+  // Conversion methods.
+  static inline bool from_ascii(const char* str, size_t len, struct_type *s) {
+    return cef_string_ascii_to_wide(str, len, s) ? true : false;
+  }
+  static inline std::string to_string(const struct_type *s) {
+    cef_string_utf8_t cstr;
+    memset(&cstr, 0, sizeof(cstr));
+    cef_string_wide_to_utf8(s->str, s->length, &cstr);
+    std::string str;
+    if (cstr.length > 0)
+      str = std::string(cstr.str, cstr.length);
+    cef_string_utf8_clear(&cstr);
+    return str;
+  }
+  static inline bool from_string(const std::string& str, struct_type *s) {
+    return cef_string_utf8_to_wide(str.c_str(), str.length(), s) ? true : false;
+  }
+  static inline std::wstring to_wstring(const struct_type *s) {
+    return std::wstring(s->str, s->length);
+  }
+  static inline bool from_wstring(const std::wstring& str, struct_type *s) {
+    return cef_string_wide_set(str.c_str(), str.length(), s, true) ?
+        true : false;
+  }
+#if defined(WCHAR_T_IS_UTF32)
+  static inline base::string16 to_string16(const struct_type *s) {
+    cef_string_utf16_t cstr;
+    memset(&cstr, 0, sizeof(cstr));
+    cef_string_wide_to_utf16(s->str, s->length, &cstr);
+    base::string16 str;
+    if (cstr.length > 0)
+      str = base::string16(cstr.str, cstr.length);
+    cef_string_utf16_clear(&cstr);
+    return str;
+  }
+  static inline bool from_string16(const base::string16& str,
+                                         struct_type *s) {
+    return cef_string_utf16_to_wide(str.c_str(), str.length(), s) ?
+        true : false;
+  }
+#else  // WCHAR_T_IS_UTF32
+  static inline base::string16 to_string16(const struct_type *s) {
+    return base::string16(s->str, s->length);
+  }
+  static inline bool from_string16(const base::string16& str, struct_type *s) {
+    return cef_string_wide_set(str.c_str(), str.length(), s, true) ?
+        true : false;
+  }
+#endif  // WCHAR_T_IS_UTF32
+};
+
+///
+// Traits implementation for utf8 character strings.
+///
+struct CefStringTraitsUTF8 {
+  typedef char char_type;
+  typedef cef_string_utf8_t struct_type;
+  typedef cef_string_userfree_utf8_t userfree_struct_type;
+
+  static inline void clear(struct_type *s) { cef_string_utf8_clear(s); }
+  static inline int set(const char_type* src, size_t src_size,
+                        struct_type* output, int copy) {
+    return cef_string_utf8_set(src, src_size, output, copy);
+  }
+  static inline int compare(const struct_type* s1, const struct_type* s2) {
+    return cef_string_utf8_cmp(s1, s2);
+  }
+  static inline userfree_struct_type userfree_alloc() {
+    return cef_string_userfree_utf8_alloc();
+  }
+  static inline void userfree_free(userfree_struct_type ufs) {
+    return cef_string_userfree_utf8_free(ufs);
+  }
+
+  // Conversion methods.
+  static inline bool from_ascii(const char* str, size_t len, struct_type* s) {
+    return cef_string_utf8_copy(str, len, s) ? true : false;
+  }
+  static inline std::string to_string(const struct_type* s) {
+    return std::string(s->str, s->length);
+  }
+  static inline bool from_string(const std::string& str, struct_type* s) {
+    return cef_string_utf8_copy(str.c_str(), str.length(), s) ? true : false;
+  }
+  static inline std::wstring to_wstring(const struct_type* s) {
+    cef_string_wide_t cstr;
+    memset(&cstr, 0, sizeof(cstr));
+    cef_string_utf8_to_wide(s->str, s->length, &cstr);
+    std::wstring str;
+    if (cstr.length > 0)
+      str = std::wstring(cstr.str, cstr.length);
+    cef_string_wide_clear(&cstr);
+    return str;
+  }
+  static inline bool from_wstring(const std::wstring& str, struct_type* s) {
+    return cef_string_wide_to_utf8(str.c_str(), str.length(), s) ? true : false;
+  }
+  static inline base::string16 to_string16(const struct_type* s) {
+    cef_string_utf16_t cstr;
+    memset(&cstr, 0, sizeof(cstr));
+    cef_string_utf8_to_utf16(s->str, s->length, &cstr);
+    base::string16 str;
+    if (cstr.length > 0)
+      str = base::string16(cstr.str, cstr.length);
+    cef_string_utf16_clear(&cstr);
+    return str;
+  }
+  static inline bool from_string16(const base::string16& str, struct_type* s) {
+    return cef_string_utf16_to_utf8(str.c_str(), str.length(), s) ?
+        true : false;
+  }
+};
+
+///
+// Traits implementation for utf16 character strings.
+///
+struct CefStringTraitsUTF16 {
+  typedef char16 char_type;
+  typedef cef_string_utf16_t struct_type;
+  typedef cef_string_userfree_utf16_t userfree_struct_type;
+
+  static inline void clear(struct_type *s) { cef_string_utf16_clear(s); }
+  static inline int set(const char_type* src, size_t src_size,
+                        struct_type* output, int copy) {
+    return cef_string_utf16_set(src, src_size, output, copy);
+  }
+  static inline int compare(const struct_type* s1, const struct_type* s2) {
+    return cef_string_utf16_cmp(s1, s2);
+  }
+  static inline userfree_struct_type userfree_alloc() {
+    return cef_string_userfree_utf16_alloc();
+  }
+  static inline void userfree_free(userfree_struct_type ufs) {
+    return cef_string_userfree_utf16_free(ufs);
+  }
+
+  // Conversion methods.
+  static inline bool from_ascii(const char* str, size_t len, struct_type* s) {
+    return cef_string_ascii_to_utf16(str, len, s) ? true : false;
+  }
+  static inline std::string to_string(const struct_type* s) {
+    cef_string_utf8_t cstr;
+    memset(&cstr, 0, sizeof(cstr));
+    cef_string_utf16_to_utf8(s->str, s->length, &cstr);
+    std::string str;
+    if (cstr.length > 0)
+      str = std::string(cstr.str, cstr.length);
+    cef_string_utf8_clear(&cstr);
+    return str;
+  }
+  static inline bool from_string(const std::string& str, struct_type* s) {
+    return cef_string_utf8_to_utf16(str.c_str(), str.length(), s) ?
+        true : false;
+  }
+#if defined(WCHAR_T_IS_UTF32)
+  static inline std::wstring to_wstring(const struct_type* s) {
+    cef_string_wide_t cstr;
+    memset(&cstr, 0, sizeof(cstr));
+    cef_string_utf16_to_wide(s->str, s->length, &cstr);
+    std::wstring str;
+    if (cstr.length > 0)
+      str = std::wstring(cstr.str, cstr.length);
+    cef_string_wide_clear(&cstr);
+    return str;
+  }
+  static inline bool from_wstring(const std::wstring& str, struct_type* s) {
+    return cef_string_wide_to_utf16(str.c_str(), str.length(), s) ?
+        true : false;
+  }
+#else  // WCHAR_T_IS_UTF32
+  static inline std::wstring to_wstring(const struct_type* s) {
+    return std::wstring(s->str, s->length);
+  }
+  static inline bool from_wstring(const std::wstring& str, struct_type* s) {
+    return cef_string_utf16_set(str.c_str(), str.length(), s, true) ?
+        true : false;
+  }
+#endif  // WCHAR_T_IS_UTF32
+  static inline base::string16 to_string16(const struct_type* s) {
+    return base::string16(s->str, s->length);
+  }
+  static inline bool from_string16(const base::string16& str, struct_type* s) {
+    return cef_string_utf16_set(str.c_str(), str.length(), s, true) ?
+        true : false;
+  }
+};
+
+///
+// CEF string classes can convert between all supported string types. For
+// example, the CefStringWide class uses wchar_t as the underlying character
+// type and provides two approaches for converting data to/from a UTF8 string
+// (std::string).
+// <p>
+// 1. Implicit conversion using the assignment operator overload.
+// <pre>
+//   CefStringWide aCefString;
+//   std::string aUTF8String;
+//   aCefString = aUTF8String; // Assign std::string to CefStringWide
+//   aUTF8String = aCefString; // Assign CefStringWide to std::string
+// </pre>
+// 2. Explicit conversion using the FromString/ToString methods.
+// <pre>
+//   CefStringWide aCefString;
+//   std::string aUTF8String;
+//   aCefString.FromString(aUTF8String); // Assign std::string to CefStringWide
+//   aUTF8String = aCefString.ToString(); // Assign CefStringWide to std::string
+// </pre>
+// Conversion will only occur if the assigned value is a different string type.
+// Assigning a std::string to a CefStringUTF8, for example, will copy the data
+// without performing a conversion.
+// </p>
+// CEF string classes are safe for reading from multiple threads but not for
+// modification. It is the user's responsibility to provide synchronization if
+// modifying CEF strings from multiple threads.
+///
+template <class traits>
+class CefStringBase {
+ public:
+  typedef typename traits::char_type char_type;
+  typedef typename traits::struct_type struct_type;
+  typedef typename traits::userfree_struct_type userfree_struct_type;
+
+  ///
+  // Default constructor.
+  ///
+  CefStringBase() : string_(NULL), owner_(false) {}
+
+  ///
+  // Create a new string from an existing string. Data will always be copied.
+  ///
+  CefStringBase(const CefStringBase& str)
+    : string_(NULL), owner_(false) {
+    FromString(str.c_str(), str.length(), true);
+  }
+
+  ///
+  // Create a new string from an existing std::string. Data will be always
+  // copied. Translation will occur if necessary based on the underlying string
+  // type.
+  ///
+  CefStringBase(const std::string& src)  // NOLINT(runtime/explicit)
+    : string_(NULL), owner_(false) {
+    FromString(src);
+  }
+  CefStringBase(const char* src)  // NOLINT(runtime/explicit)
+    : string_(NULL), owner_(false) {
+    if (src)
+      FromString(std::string(src));
+  }
+
+  ///
+  // Create a new string from an existing std::wstring. Data will be always
+  // copied. Translation will occur if necessary based on the underlying string
+  // type.
+  ///
+  CefStringBase(const std::wstring& src)  // NOLINT(runtime/explicit)
+    : string_(NULL), owner_(false) {
+    FromWString(src);
+  }
+  CefStringBase(const wchar_t* src)  // NOLINT(runtime/explicit)
+    : string_(NULL), owner_(false) {
+    if (src)
+      FromWString(std::wstring(src));
+  }
+
+#if defined(WCHAR_T_IS_UTF32)
+  ///
+  // Create a new string from an existing string16. Data will be always
+  // copied. Translation will occur if necessary based on the underlying string
+  // type.
+  ///
+  CefStringBase(const base::string16& src)  // NOLINT(runtime/explicit)
+    : string_(NULL), owner_(false) {
+    FromString16(src);
+  }
+  CefStringBase(const char16* src)  // NOLINT(runtime/explicit)
+    : string_(NULL), owner_(false) {
+    if (src)
+      FromString16(base::string16(src));
+  }
+#endif  // WCHAR_T_IS_UTF32
+
+  ///
+  // Create a new string from an existing character array. If |copy| is true
+  // this class will copy the data. Otherwise, this class will reference the
+  // existing data. Referenced data must exist for the lifetime of this class
+  // and will not be freed by this class.
+  ///
+  CefStringBase(const char_type* src, size_t src_len, bool copy)
+    : string_(NULL), owner_(false) {
+    if (src && src_len > 0)
+      FromString(src, src_len, copy);
+  }
+
+  ///
+  // Create a new string referencing an existing string structure without taking
+  // ownership. Referenced structures must exist for the lifetime of this class
+  // and will not be freed by this class.
+  ///
+  CefStringBase(const struct_type* src)  // NOLINT(runtime/explicit)
+    : string_(NULL), owner_(false) {
+    if (!src)
+      return;
+    // Reference the existing structure without taking ownership.
+    Attach(const_cast<struct_type*>(src), false);
+  }
+
+  virtual ~CefStringBase() { ClearAndFree(); }
+
+
+  // The following methods are named for compatibility with the standard library
+  // string template types.
+
+  ///
+  // Return a read-only pointer to the string data.
+  ///
+  const char_type* c_str() const { return (string_ ? string_->str : NULL); }
+
+  ///
+  // Return the length of the string data.
+  ///
+  size_t length() const { return (string_ ? string_->length : 0); }
+
+  ///
+  // Return the length of the string data.
+  ///
+  inline size_t size() const { return length(); }
+
+  ///
+  // Returns true if the string is empty.
+  ///
+  bool empty() const { return (string_ == NULL || string_->length == 0); }
+
+  ///
+  // Compare this string to the specified string.
+  ///
+  int compare(const CefStringBase& str) const {
+    if (empty() && str.empty())
+      return 0;
+    if (empty())
+      return -1;
+    if (str.empty())
+      return 1;
+    return traits::compare(string_, str.GetStruct());
+  }
+
+  ///
+  // Clear the string data.
+  ///
+  void clear() {
+    if (string_)
+      traits::clear(string_);
+  }
+
+  ///
+  // Swap this string's contents with the specified string.
+  ///
+  void swap(CefStringBase& str) {
+    struct_type* tmp_string = string_;
+    bool tmp_owner = owner_;
+    string_ = str.string_;
+    owner_ = str.owner_;
+    str.string_ = tmp_string;
+    str.owner_ = tmp_owner;
+  }
+
+
+  // The following methods are unique to CEF string template types.
+
+  ///
+  // Returns true if this class owns the underlying string structure.
+  ///
+  bool IsOwner() const { return owner_; }
+
+  ///
+  // Returns a read-only pointer to the underlying string structure. May return
+  // NULL if no structure is currently allocated.
+  ///
+  const struct_type* GetStruct() const { return string_; }
+
+  ///
+  // Returns a writable pointer to the underlying string structure. Will never
+  // return NULL.
+  ///
+  struct_type* GetWritableStruct() {
+    AllocIfNeeded();
+    return string_;
+  }
+
+  ///
+  // Clear the state of this class. The underlying string structure and data
+  // will be freed if this class owns the structure.
+  ///
+  void ClearAndFree() {
+    if (!string_)
+      return;
+    if (owner_) {
+      clear();
+      delete string_;
+    }
+    string_ = NULL;
+    owner_ = false;
+  }
+
+  ///
+  // Attach to the specified string structure. If |owner| is true this class
+  // will take ownership of the structure.
+  ///
+  void Attach(struct_type* str, bool owner) {
+    // Free the previous structure and data, if any.
+    ClearAndFree();
+
+    string_ = str;
+    owner_ = owner;
+  }
+
+  ///
+  // Take ownership of the specified userfree structure's string data. The
+  // userfree structure itself will be freed. Only use this method with userfree
+  // structures.
+  ///
+  void AttachToUserFree(userfree_struct_type str) {
+    // Free the previous structure and data, if any.
+    ClearAndFree();
+
+    if (!str)
+      return;
+
+    AllocIfNeeded();
+    owner_ = true;
+    memcpy(string_, str, sizeof(struct_type));
+
+    // Free the |str| structure but not the data.
+    memset(str, 0, sizeof(struct_type));
+    traits::userfree_free(str);
+  }
+
+  ///
+  // Detach from the underlying string structure. To avoid memory leaks only use
+  // this method if you already hold a pointer to the underlying string
+  // structure.
+  ///
+  void Detach() {
+    string_ = NULL;
+    owner_ = false;
+  }
+
+  ///
+  // Create a userfree structure and give it ownership of this class' string
+  // data. This class will be disassociated from the data. May return NULL if
+  // this string class currently contains no data.
+  ///
+  userfree_struct_type DetachToUserFree() {
+    if (empty())
+      return NULL;
+
+    userfree_struct_type str = traits::userfree_alloc();
+    memcpy(str, string_, sizeof(struct_type));
+
+    // Free this class' structure but not the data.
+    memset(string_, 0, sizeof(struct_type));
+    ClearAndFree();
+
+    return str;
+  }
+
+  ///
+  // Set this string's data to the specified character array. If |copy| is true
+  // this class will copy the data. Otherwise, this class will reference the
+  // existing data. Referenced data must exist for the lifetime of this class
+  // and will not be freed by this class.
+  ///
+  bool FromString(const char_type* src, size_t src_len, bool copy) {
+    if (src == NULL || src_len == 0) {
+      clear();
+      return true;
+    }
+    AllocIfNeeded();
+    return traits::set(src, src_len, string_, copy) ? true : false;
+  }
+
+  ///
+  // Set this string's data from an existing ASCII string. Data will be always
+  // copied. Translation will occur if necessary based on the underlying string
+  // type.
+  ///
+  bool FromASCII(const char* str) {
+    size_t len = str ? strlen(str) : 0;
+    if (len == 0) {
+      clear();
+      return true;
+    }
+    AllocIfNeeded();
+    return traits::from_ascii(str, len, string_);
+  }
+
+  ///
+  // Return this string's data as a std::string. Translation will occur if
+  // necessary based on the underlying string type.
+  ///
+  std::string ToString() const {
+    if (empty())
+      return std::string();
+    return traits::to_string(string_);
+  }
+
+  ///
+  // Set this string's data from an existing std::string. Data will be always
+  // copied. Translation will occur if necessary based on the underlying string
+  // type.
+  ///
+  bool FromString(const std::string& str) {
+    if (str.empty()) {
+      clear();
+      return true;
+    }
+    AllocIfNeeded();
+    return traits::from_string(str, string_);
+  }
+
+  ///
+  // Return this string's data as a std::wstring. Translation will occur if
+  // necessary based on the underlying string type.
+  ///
+  std::wstring ToWString() const {
+    if (empty())
+      return std::wstring();
+    return traits::to_wstring(string_);
+  }
+
+  ///
+  // Set this string's data from an existing std::wstring. Data will be always
+  // copied. Translation will occur if necessary based on the underlying string
+  // type.
+  ///
+  bool FromWString(const std::wstring& str) {
+    if (str.empty()) {
+      clear();
+      return true;
+    }
+    AllocIfNeeded();
+    return traits::from_wstring(str, string_);
+  }
+
+  ///
+  // Return this string's data as a string16. Translation will occur if
+  // necessary based on the underlying string type.
+  ///
+  base::string16 ToString16() const {
+    if (empty())
+      return base::string16();
+    return traits::to_string16(string_);
+  }
+
+  ///
+  // Set this string's data from an existing string16. Data will be always
+  // copied. Translation will occur if necessary based on the underlying string
+  // type.
+  ///
+  bool FromString16(const base::string16& str) {
+    if (str.empty()) {
+      clear();
+      return true;
+    }
+    AllocIfNeeded();
+    return traits::from_string16(str, string_);
+  }
+
+  ///
+  // Comparison operator overloads.
+  ///
+  bool operator<(const CefStringBase& str) const {
+    return (compare(str) < 0);
+  }
+  bool operator<=(const CefStringBase& str) const {
+    return (compare(str) <= 0);
+  }
+  bool operator>(const CefStringBase& str) const {
+    return (compare(str) > 0);
+  }
+  bool operator>=(const CefStringBase& str) const {
+    return (compare(str) >= 0);
+  }
+  bool operator==(const CefStringBase& str) const {
+    return (compare(str) == 0);
+  }
+  bool operator!=(const CefStringBase& str) const {
+    return (compare(str) != 0);
+  }
+
+  ///
+  // Assignment operator overloads.
+  ///
+  CefStringBase& operator=(const CefStringBase& str) {
+    FromString(str.c_str(), str.length(), true);
+    return *this;
+  }
+  operator std::string() const {
+    return ToString();
+  }
+  CefStringBase& operator=(const std::string& str) {
+    FromString(str);
+    return *this;
+  }
+  CefStringBase& operator=(const char* str) {
+    FromString(std::string(str));
+    return *this;
+  }
+  operator std::wstring() const {
+    return ToWString();
+  }
+  CefStringBase& operator=(const std::wstring& str) {
+    FromWString(str);
+    return *this;
+  }
+  CefStringBase& operator=(const wchar_t* str) {
+    FromWString(std::wstring(str));
+    return *this;
+  }
+#if defined(WCHAR_T_IS_UTF32)
+  operator base::string16() const {
+    return ToString16();
+  }
+  CefStringBase& operator=(const base::string16& str) {
+    FromString16(str);
+    return *this;
+  }
+  CefStringBase& operator=(const char16* str) {
+    FromString16(base::string16(str));
+    return *this;
+  }
+#endif  // WCHAR_T_IS_UTF32
+#if defined(USING_CHROMIUM_INCLUDES)
+  // The base::FilePath constructor is marked as explicit so provide the
+  // conversion here for convenience.
+  operator base::FilePath() const {
+#if defined(OS_WIN)
+    return base::FilePath(ToWString());
+#else
+    return base::FilePath(ToString());
+#endif
+  }
+#endif  // USING_CHROMIUM_INCLUDES
+
+ private:
+  // Allocate the string structure if it doesn't already exist.
+  void AllocIfNeeded() {
+    if (string_ == NULL) {
+      string_ = new struct_type;
+      memset(string_, 0, sizeof(struct_type));
+      owner_ = true;
+    }
+  }
+
+  struct_type* string_;
+  bool owner_;
+};
+
+
+typedef CefStringBase<CefStringTraitsWide> CefStringWide;
+typedef CefStringBase<CefStringTraitsUTF8> CefStringUTF8;
+typedef CefStringBase<CefStringTraitsUTF16> CefStringUTF16;
+
+#endif  // CEF_INCLUDE_INTERNAL_CEF_STRING_WRAPPERS_H_
diff --git a/src/include/libcef/internal/cef_thread_internal.h b/src/include/libcef/internal/cef_thread_internal.h
new file mode 100644
index 0000000..9224d49
--- /dev/null
+++ b/src/include/libcef/internal/cef_thread_internal.h
@@ -0,0 +1,74 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef CEF_INCLUDE_INTERNAL_CEF_THREAD_INTERNAL_H_
+#define CEF_INCLUDE_INTERNAL_CEF_THREAD_INTERNAL_H_
+#pragma once
+
+#if defined(OS_WIN)
+    #include <windows.h>
+#elif defined(OS_POSIX)
+    #include <pthread.h>
+    #include <unistd.h>
+#endif
+
+#include "libcef/internal/cef_export.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if defined(OS_WIN)
+typedef DWORD cef_platform_thread_id_t;
+#elif defined(OS_POSIX)
+typedef pid_t cef_platform_thread_id_t;
+#endif
+
+///
+// Returns the current platform thread ID.
+///
+CEF_EXPORT cef_platform_thread_id_t cef_get_current_platform_thread_id();
+
+#if defined(OS_WIN)
+typedef DWORD cef_platform_thread_handle_t;
+#elif defined(OS_POSIX)
+typedef pthread_t cef_platform_thread_handle_t;
+#endif
+
+///
+// Returns the current platform thread handle.
+///
+CEF_EXPORT cef_platform_thread_handle_t
+    cef_get_current_platform_thread_handle();
+
+#ifdef __cplusplus
+}
+#endif  // __cplusplus
+
+#endif  // CEF_INCLUDE_INTERNAL_CEF_THREAD_INTERNAL_H_
diff --git a/src/include/libcef/internal/cef_time.h b/src/include/libcef/internal/cef_time.h
new file mode 100644
index 0000000..9101379
--- /dev/null
+++ b/src/include/libcef/internal/cef_time.h
@@ -0,0 +1,88 @@
+// Copyright (c) 2011 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef CEF_INCLUDE_INTERNAL_CEF_TIME_H_
+#define CEF_INCLUDE_INTERNAL_CEF_TIME_H_
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "libcef/internal/cef_export.h"
+#include <time.h>
+
+///
+// Time information. Values should always be in UTC.
+///
+typedef struct _cef_time_t {
+  int year;          // Four digit year "2007"
+  int month;         // 1-based month (values 1 = January, etc.)
+  int day_of_week;   // 0-based day of week (0 = Sunday, etc.)
+  int day_of_month;  // 1-based day of month (1-31)
+  int hour;          // Hour within the current day (0-23)
+  int minute;        // Minute within the current hour (0-59)
+  int second;        // Second within the current minute (0-59 plus leap
+                     //   seconds which may take it up to 60).
+  int millisecond;   // Milliseconds within the current second (0-999)
+} cef_time_t;
+
+///
+// Converts cef_time_t to/from time_t. Returns true (1) on success and false (0)
+// on failure.
+///
+CEF_EXPORT int cef_time_to_timet(const cef_time_t* cef_time, time_t* time);
+CEF_EXPORT int cef_time_from_timet(time_t time, cef_time_t* cef_time);
+
+///
+// Converts cef_time_t to/from a double which is the number of seconds since
+// epoch (Jan 1, 1970). Webkit uses this format to represent time. A value of 0
+// means "not initialized". Returns true (1) on success and false (0) on
+// failure.
+///
+CEF_EXPORT int cef_time_to_doublet(const cef_time_t* cef_time, double* time);
+CEF_EXPORT int cef_time_from_doublet(double time, cef_time_t* cef_time);
+
+///
+// Retrieve the current system time.
+//
+CEF_EXPORT int cef_time_now(cef_time_t* cef_time);
+
+///
+// Retrieve the delta in milliseconds between two time values.
+//
+CEF_EXPORT int cef_time_delta(const cef_time_t* cef_time1,
+                              const cef_time_t* cef_time2,
+                              long long* delta);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_INTERNAL_CEF_TIME_H_
diff --git a/src/include/libcef/internal/cef_trace_event_internal.h b/src/include/libcef/internal/cef_trace_event_internal.h
new file mode 100644
index 0000000..82949a0
--- /dev/null
+++ b/src/include/libcef/internal/cef_trace_event_internal.h
@@ -0,0 +1,124 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef CEF_INCLUDE_INTERNAL_CEF_TRACE_EVENT_INTERNAL_H_
+#define CEF_INCLUDE_INTERNAL_CEF_TRACE_EVENT_INTERNAL_H_
+#pragma once
+
+#include "libcef/internal/cef_export.h"
+#include "libcef/internal/cef_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// See include/base/cef_trace_event.h for macros and intended usage.
+
+// Functions for tracing counters and functions; called from macros.
+// - |category| string must have application lifetime (static or literal). They
+//   may not include "(quotes) chars.
+// - |argX_name|, |argX_val|, |valueX_name|, |valeX_val| are optional parameters
+//   and represent pairs of name and values of arguments
+// - |copy| is used to avoid memory scoping issues with the |name| and
+//   |arg_name| parameters by copying them
+// - |id| is used to disambiguate counters with the same name, or match async
+//   trace events
+
+CEF_EXPORT void cef_trace_event_instant(const char* category,
+                                        const char* name,
+                                        const char* arg1_name,
+                                        uint64 arg1_val,
+                                        const char* arg2_name,
+                                        uint64 arg2_val,
+                                        int copy);
+CEF_EXPORT void cef_trace_event_begin(const char* category,
+                                      const char* name,
+                                      const char* arg1_name,
+                                      uint64 arg1_val,
+                                      const char* arg2_name,
+                                      uint64 arg2_val,
+                                      int copy);
+CEF_EXPORT void cef_trace_event_end(const char* category,
+                                    const char* name,
+                                    const char* arg1_name,
+                                    uint64 arg1_val,
+                                    const char* arg2_name,
+                                    uint64 arg2_val,
+                                    int copy);
+CEF_EXPORT void cef_trace_counter(const char* category,
+                                  const char* name,
+                                  const char* value1_name,
+                                  uint64 value1_val,
+                                  const char* value2_name,
+                                  uint64 value2_val,
+                                  int copy);
+CEF_EXPORT void cef_trace_counter_id(const char* category,
+                                     const char* name,
+                                     uint64 id,
+                                     const char* value1_name,
+                                     uint64 value1_val,
+                                     const char* value2_name,
+                                     uint64 value2_val,
+                                     int copy);
+CEF_EXPORT void cef_trace_event_async_begin(const char* category,
+                                            const char* name,
+                                            uint64 id,
+                                            const char* arg1_name,
+                                            uint64 arg1_val,
+                                            const char* arg2_name,
+                                            uint64 arg2_val,
+                                            int copy);
+CEF_EXPORT void cef_trace_event_async_step_into(const char* category,
+                                                const char* name,
+                                                uint64 id,
+                                                uint64 step,
+                                                const char* arg1_name,
+                                                uint64 arg1_val,
+                                                int copy);
+CEF_EXPORT void cef_trace_event_async_step_past(const char* category,
+                                                const char* name,
+                                                uint64 id,
+                                                uint64 step,
+                                                const char* arg1_name,
+                                                uint64 arg1_val,
+                                                int copy);
+CEF_EXPORT void cef_trace_event_async_end(const char* category,
+                                          const char* name,
+                                          uint64 id,
+                                          const char* arg1_name,
+                                          uint64 arg1_val,
+                                          const char* arg2_name,
+                                          uint64 arg2_val,
+                                          int copy);
+
+#ifdef __cplusplus
+}
+#endif  // __cplusplus
+
+#endif  // CEF_INCLUDE_INTERNAL_CEF_TRACE_EVENT_INTERNAL_H_
diff --git a/src/include/libcef/internal/cef_types.h b/src/include/libcef/internal/cef_types.h
new file mode 100644
index 0000000..4044379
--- /dev/null
+++ b/src/include/libcef/internal/cef_types.h
@@ -0,0 +1,2630 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+#ifndef CEF_INCLUDE_INTERNAL_CEF_TYPES_H_
+#define CEF_INCLUDE_INTERNAL_CEF_TYPES_H_
+#pragma once
+
+#include "libcef/base/cef_basictypes.h"
+#include "libcef/internal/cef_string.h"
+#include "libcef/internal/cef_string_list.h"
+#include "libcef/internal/cef_time.h"
+
+// Bring in platform-specific definitions.
+#if defined(OS_WIN)
+#include "libcef/internal/cef_types_win.h"
+#elif defined(OS_MACOSX)
+#include "libcef/internal/cef_types_mac.h"
+#elif defined(OS_LINUX)
+#include "libcef/internal/cef_types_linux.h"
+#endif
+
+// 32-bit ARGB color value, not premultiplied. The color components are always
+// in a known order. Equivalent to the SkColor type.
+typedef uint32              cef_color_t;
+
+// Return the alpha byte from a cef_color_t value.
+#define CefColorGetA(color)      (((color) >> 24) & 0xFF)
+// Return the red byte from a cef_color_t value.
+#define CefColorGetR(color)      (((color) >> 16) & 0xFF)
+// Return the green byte from a cef_color_t value.
+#define CefColorGetG(color)      (((color) >>  8) & 0xFF)
+// Return the blue byte from a cef_color_t value.
+#define CefColorGetB(color)      (((color) >>  0) & 0xFF)
+
+// Return an cef_color_t value with the specified byte component values.
+#define CefColorSetARGB(a, r, g, b) \
+    static_cast<cef_color_t>( \
+        (static_cast<unsigned>(a) << 24) | \
+        (static_cast<unsigned>(r) << 16) | \
+        (static_cast<unsigned>(g) << 8) | \
+        (static_cast<unsigned>(b) << 0))
+
+// Return an int64 value with the specified low and high int32 component values.
+#define CefInt64Set(int32_low, int32_high) \
+    static_cast<int64>((static_cast<uint32>(int32_low)) | \
+        (static_cast<int64>(static_cast<int32>(int32_high))) << 32)
+
+// Return the low int32 value from an int64 value.
+#define CefInt64GetLow(int64_val) static_cast<int32>(int64_val)
+// Return the high int32 value from an int64 value.
+#define CefInt64GetHigh(int64_val) \
+    static_cast<int32>((static_cast<int64>(int64_val) >> 32) & 0xFFFFFFFFL)
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///
+// Log severity levels.
+///
+typedef enum {
+  ///
+  // Default logging (currently INFO logging).
+  ///
+  LOGSEVERITY_DEFAULT,
+
+  ///
+  // Verbose logging.
+  ///
+  LOGSEVERITY_VERBOSE,
+
+  ///
+  // INFO logging.
+  ///
+  LOGSEVERITY_INFO,
+
+  ///
+  // WARNING logging.
+  ///
+  LOGSEVERITY_WARNING,
+
+  ///
+  // ERROR logging.
+  ///
+  LOGSEVERITY_ERROR,
+
+  ///
+  // Completely disable logging.
+  ///
+  LOGSEVERITY_DISABLE = 99
+} cef_log_severity_t;
+
+///
+// Represents the state of a setting.
+///
+typedef enum {
+  ///
+  // Use the default state for the setting.
+  ///
+  STATE_DEFAULT = 0,
+
+  ///
+  // Enable or allow the setting.
+  ///
+  STATE_ENABLED,
+
+  ///
+  // Disable or disallow the setting.
+  ///
+  STATE_DISABLED,
+} cef_state_t;
+
+///
+// Initialization settings. Specify NULL or 0 to get the recommended default
+// values. Many of these and other settings can also configured using command-
+// line switches.
+///
+typedef struct _cef_settings_t {
+  ///
+  // Size of this structure.
+  ///
+  size_t size;
+
+  ///
+  // Set to true (1) to use a single process for the browser and renderer. This
+  // run mode is not officially supported by Chromium and is less stable than
+  // the multi-process default. Also configurable using the "single-process"
+  // command-line switch.
+  ///
+  int single_process;
+
+  ///
+  // Set to true (1) to disable the sandbox for sub-processes. See
+  // cef_sandbox_win.h for requirements to enable the sandbox on Windows. Also
+  // configurable using the "no-sandbox" command-line switch.
+  ///
+  int no_sandbox;
+
+  ///
+  // The path to a separate executable that will be launched for sub-processes.
+  // By default the browser process executable is used. See the comments on
+  // CefExecuteProcess() for details. Also configurable using the
+  // "browser-subprocess-path" command-line switch.
+  ///
+  cef_string_t browser_subprocess_path;
+
+  ///
+  // Set to true (1) to have the browser process message loop run in a separate
+  // thread. If false (0) than the CefDoMessageLoopWork() function must be
+  // called from your application message loop. This option is only supported on
+  // Windows.
+  ///
+  int multi_threaded_message_loop;
+
+  ///
+  // Set to true (1) to enable windowless (off-screen) rendering support. Do not
+  // enable this value if the application does not use windowless rendering as
+  // it may reduce rendering performance on some systems.
+  ///
+  int windowless_rendering_enabled;
+
+  ///
+  // Set to true (1) to disable configuration of browser process features using
+  // standard CEF and Chromium command-line arguments. Configuration can still
+  // be specified using CEF data structures or via the
+  // CefApp::OnBeforeCommandLineProcessing() method.
+  ///
+  int command_line_args_disabled;
+
+  ///
+  // The location where cache data will be stored on disk. If empty then
+  // browsers will be created in "incognito mode" where in-memory caches are
+  // used for storage and no data is persisted to disk. HTML5 databases such as
+  // localStorage will only persist across sessions if a cache path is
+  // specified. Can be overridden for individual CefRequestContext instances via
+  // the CefRequestContextSettings.cache_path value.
+  ///
+  cef_string_t cache_path;
+
+  ///
+  // The location where user data such as spell checking dictionary files will
+  // be stored on disk. If empty then the default platform-specific user data
+  // directory will be used ("~/.cef_user_data" directory on Linux,
+  // "~/Library/Application Support/CEF/User Data" directory on Mac OS X,
+  // "Local Settings\Application Data\CEF\User Data" directory under the user
+  // profile directory on Windows).
+  ///
+  cef_string_t user_data_path;
+
+  ///
+  // To persist session cookies (cookies without an expiry date or validity
+  // interval) by default when using the global cookie manager set this value to
+  // true (1). Session cookies are generally intended to be transient and most
+  // Web browsers do not persist them. A |cache_path| value must also be
+  // specified to enable this feature. Also configurable using the
+  // "persist-session-cookies" command-line switch. Can be overridden for
+  // individual CefRequestContext instances via the
+  // CefRequestContextSettings.persist_session_cookies value.
+  ///
+  int persist_session_cookies;
+
+  ///
+  // To persist user preferences as a JSON file in the cache path directory set
+  // this value to true (1). A |cache_path| value must also be specified
+  // to enable this feature. Also configurable using the
+  // "persist-user-preferences" command-line switch. Can be overridden for
+  // individual CefRequestContext instances via the
+  // CefRequestContextSettings.persist_user_preferences value.
+  ///
+  int persist_user_preferences;
+
+  ///
+  // Value that will be returned as the User-Agent HTTP header. If empty the
+  // default User-Agent string will be used. Also configurable using the
+  // "user-agent" command-line switch.
+  ///
+  cef_string_t user_agent;
+
+  ///
+  // Value that will be inserted as the product portion of the default
+  // User-Agent string. If empty the Chromium product version will be used. If
+  // |userAgent| is specified this value will be ignored. Also configurable
+  // using the "product-version" command-line switch.
+  ///
+  cef_string_t product_version;
+
+  ///
+  // The locale string that will be passed to WebKit. If empty the default
+  // locale of "en-US" will be used. This value is ignored on Linux where locale
+  // is determined using environment variable parsing with the precedence order:
+  // LANGUAGE, LC_ALL, LC_MESSAGES and LANG. Also configurable using the "lang"
+  // command-line switch.
+  ///
+  cef_string_t locale;
+
+  ///
+  // The directory and file name to use for the debug log. If empty a default
+  // log file name and location will be used. On Windows and Linux a "debug.log"
+  // file will be written in the main executable directory. On Mac OS X a
+  // "~/Library/Logs/<app name>_debug.log" file will be written where <app name>
+  // is the name of the main app executable. Also configurable using the
+  // "log-file" command-line switch.
+  ///
+  cef_string_t log_file;
+
+  ///
+  // The log severity. Only messages of this severity level or higher will be
+  // logged. Also configurable using the "log-severity" command-line switch with
+  // a value of "verbose", "info", "warning", "error", "error-report" or
+  // "disable".
+  ///
+  cef_log_severity_t log_severity;
+
+  ///
+  // Custom flags that will be used when initializing the V8 JavaScript engine.
+  // The consequences of using custom flags may not be well tested. Also
+  // configurable using the "js-flags" command-line switch.
+  ///
+  cef_string_t javascript_flags;
+
+  ///
+  // The fully qualified path for the resources directory. If this value is
+  // empty the cef.pak and/or devtools_resources.pak files must be located in
+  // the module directory on Windows/Linux or the app bundle Resources directory
+  // on Mac OS X. Also configurable using the "resources-dir-path" command-line
+  // switch.
+  ///
+  cef_string_t resources_dir_path;
+
+  ///
+  // The fully qualified path for the locales directory. If this value is empty
+  // the locales directory must be located in the module directory. This value
+  // is ignored on Mac OS X where pack files are always loaded from the app
+  // bundle Resources directory. Also configurable using the "locales-dir-path"
+  // command-line switch.
+  ///
+  cef_string_t locales_dir_path;
+
+  ///
+  // Set to true (1) to disable loading of pack files for resources and locales.
+  // A resource bundle handler must be provided for the browser and render
+  // processes via CefApp::GetResourceBundleHandler() if loading of pack files
+  // is disabled. Also configurable using the "disable-pack-loading" command-
+  // line switch.
+  ///
+  int pack_loading_disabled;
+
+  ///
+  // Set to a value between 1024 and 65535 to enable remote debugging on the
+  // specified port. For example, if 8080 is specified the remote debugging URL
+  // will be http://localhost:8080. CEF can be remotely debugged from any CEF or
+  // Chrome browser window. Also configurable using the "remote-debugging-port"
+  // command-line switch.
+  ///
+  int remote_debugging_port;
+
+  ///
+  // The number of stack trace frames to capture for uncaught exceptions.
+  // Specify a positive value to enable the CefRenderProcessHandler::
+  // OnUncaughtException() callback. Specify 0 (default value) and
+  // OnUncaughtException() will not be called. Also configurable using the
+  // "uncaught-exception-stack-size" command-line switch.
+  ///
+  int uncaught_exception_stack_size;
+
+  ///
+  // By default CEF V8 references will be invalidated (the IsValid() method will
+  // return false) after the owning context has been released. This reduces the
+  // need for external record keeping and avoids crashes due to the use of V8
+  // references after the associated context has been released.
+  //
+  // CEF currently offers two context safety implementations with different
+  // performance characteristics. The default implementation (value of 0) uses a
+  // map of hash values and should provide better performance in situations with
+  // a small number contexts. The alternate implementation (value of 1) uses a
+  // hidden value attached to each context and should provide better performance
+  // in situations with a large number of contexts.
+  //
+  // If you need better performance in the creation of V8 references and you
+  // plan to manually track context lifespan you can disable context safety by
+  // specifying a value of -1.
+  //
+  // Also configurable using the "context-safety-implementation" command-line
+  // switch.
+  ///
+  int context_safety_implementation;
+
+  ///
+  // Set to true (1) to ignore errors related to invalid SSL certificates.
+  // Enabling this setting can lead to potential security vulnerabilities like
+  // "man in the middle" attacks. Applications that load content from the
+  // internet should not enable this setting. Also configurable using the
+  // "ignore-certificate-errors" command-line switch. Can be overridden for
+  // individual CefRequestContext instances via the
+  // CefRequestContextSettings.ignore_certificate_errors value.
+  ///
+  int ignore_certificate_errors;
+
+  ///
+  // Opaque background color used for accelerated content. By default the
+  // background color will be white. Only the RGB compontents of the specified
+  // value will be used. The alpha component must greater than 0 to enable use
+  // of the background color but will be otherwise ignored.
+  ///
+  cef_color_t background_color;
+
+  ///
+  // Comma delimited ordered list of language codes without any whitespace that
+  // will be used in the "Accept-Language" HTTP header. May be overridden on a
+  // per-browser basis using the CefBrowserSettings.accept_language_list value.
+  // If both values are empty then "en-US,en" will be used. Can be overridden
+  // for individual CefRequestContext instances via the
+  // CefRequestContextSettings.accept_language_list value.
+  ///
+  cef_string_t accept_language_list;
+} cef_settings_t;
+
+///
+// Request context initialization settings. Specify NULL or 0 to get the
+// recommended default values.
+///
+typedef struct _cef_request_context_settings_t {
+  ///
+  // Size of this structure.
+  ///
+  size_t size;
+
+  ///
+  // The location where cache data will be stored on disk. If empty then
+  // browsers will be created in "incognito mode" where in-memory caches are
+  // used for storage and no data is persisted to disk. HTML5 databases such as
+  // localStorage will only persist across sessions if a cache path is
+  // specified. To share the global browser cache and related configuration set
+  // this value to match the CefSettings.cache_path value.
+  ///
+  cef_string_t cache_path;
+
+  ///
+  // To persist session cookies (cookies without an expiry date or validity
+  // interval) by default when using the global cookie manager set this value to
+  // true (1). Session cookies are generally intended to be transient and most
+  // Web browsers do not persist them. Can be set globally using the
+  // CefSettings.persist_session_cookies value. This value will be ignored if
+  // |cache_path| is empty or if it matches the CefSettings.cache_path value.
+  ///
+  int persist_session_cookies;
+
+  ///
+  // To persist user preferences as a JSON file in the cache path directory set
+  // this value to true (1). Can be set globally using the
+  // CefSettings.persist_user_preferences value. This value will be ignored if
+  // |cache_path| is empty or if it matches the CefSettings.cache_path value.
+  ///
+  int persist_user_preferences;
+
+  ///
+  // Set to true (1) to ignore errors related to invalid SSL certificates.
+  // Enabling this setting can lead to potential security vulnerabilities like
+  // "man in the middle" attacks. Applications that load content from the
+  // internet should not enable this setting. Can be set globally using the
+  // CefSettings.ignore_certificate_errors value. This value will be ignored if
+  // |cache_path| matches the CefSettings.cache_path value.
+  ///
+  int ignore_certificate_errors;
+
+  ///
+  // Comma delimited ordered list of language codes without any whitespace that
+  // will be used in the "Accept-Language" HTTP header. Can be set globally
+  // using the CefSettings.accept_language_list value or overridden on a per-
+  // browser basis using the CefBrowserSettings.accept_language_list value. If
+  // all values are empty then "en-US,en" will be used. This value will be
+  // ignored if |cache_path| matches the CefSettings.cache_path value.
+  ///
+  cef_string_t accept_language_list;
+} cef_request_context_settings_t;
+
+///
+// Browser initialization settings. Specify NULL or 0 to get the recommended
+// default values. The consequences of using custom values may not be well
+// tested. Many of these and other settings can also configured using command-
+// line switches.
+///
+typedef struct _cef_browser_settings_t {
+  ///
+  // Size of this structure.
+  ///
+  size_t size;
+
+  ///
+  // The maximum rate in frames per second (fps) that CefRenderHandler::OnPaint
+  // will be called for a windowless browser. The actual fps may be lower if
+  // the browser cannot generate frames at the requested rate. The minimum
+  // value is 1 and the maximum value is 60 (default 30). This value can also be
+  // changed dynamically via CefBrowserHost::SetWindowlessFrameRate.
+  ///
+  int windowless_frame_rate;
+
+  // The below values map to WebPreferences settings.
+
+  ///
+  // Font settings.
+  ///
+  cef_string_t standard_font_family;
+  cef_string_t fixed_font_family;
+  cef_string_t serif_font_family;
+  cef_string_t sans_serif_font_family;
+  cef_string_t cursive_font_family;
+  cef_string_t fantasy_font_family;
+  int default_font_size;
+  int default_fixed_font_size;
+  int minimum_font_size;
+  int minimum_logical_font_size;
+
+  ///
+  // Default encoding for Web content. If empty "ISO-8859-1" will be used. Also
+  // configurable using the "default-encoding" command-line switch.
+  ///
+  cef_string_t default_encoding;
+
+  ///
+  // Controls the loading of fonts from remote sources. Also configurable using
+  // the "disable-remote-fonts" command-line switch.
+  ///
+  cef_state_t remote_fonts;
+
+  ///
+  // Controls whether JavaScript can be executed. Also configurable using the
+  // "disable-javascript" command-line switch.
+  ///
+  cef_state_t javascript;
+
+  ///
+  // Controls whether JavaScript can be used for opening windows. Also
+  // configurable using the "disable-javascript-open-windows" command-line
+  // switch.
+  ///
+  cef_state_t javascript_open_windows;
+
+  ///
+  // Controls whether JavaScript can be used to close windows that were not
+  // opened via JavaScript. JavaScript can still be used to close windows that
+  // were opened via JavaScript or that have no back/forward history. Also
+  // configurable using the "disable-javascript-close-windows" command-line
+  // switch.
+  ///
+  cef_state_t javascript_close_windows;
+
+  ///
+  // Controls whether JavaScript can access the clipboard. Also configurable
+  // using the "disable-javascript-access-clipboard" command-line switch.
+  ///
+  cef_state_t javascript_access_clipboard;
+
+  ///
+  // Controls whether DOM pasting is supported in the editor via
+  // execCommand("paste"). The |javascript_access_clipboard| setting must also
+  // be enabled. Also configurable using the "disable-javascript-dom-paste"
+  // command-line switch.
+  ///
+  cef_state_t javascript_dom_paste;
+
+  ///
+  // Controls whether the caret position will be drawn. Also configurable using
+  // the "enable-caret-browsing" command-line switch.
+  ///
+  cef_state_t caret_browsing;
+
+  ///
+  // Controls whether any plugins will be loaded. Also configurable using the
+  // "disable-plugins" command-line switch.
+  ///
+  cef_state_t plugins;
+
+  ///
+  // Controls whether file URLs will have access to all URLs. Also configurable
+  // using the "allow-universal-access-from-files" command-line switch.
+  ///
+  cef_state_t universal_access_from_file_urls;
+
+  ///
+  // Controls whether file URLs will have access to other file URLs. Also
+  // configurable using the "allow-access-from-files" command-line switch.
+  ///
+  cef_state_t file_access_from_file_urls;
+
+  ///
+  // Controls whether web security restrictions (same-origin policy) will be
+  // enforced. Disabling this setting is not recommend as it will allow risky
+  // security behavior such as cross-site scripting (XSS). Also configurable
+  // using the "disable-web-security" command-line switch.
+  ///
+  cef_state_t web_security;
+
+  ///
+  // Controls whether image URLs will be loaded from the network. A cached image
+  // will still be rendered if requested. Also configurable using the
+  // "disable-image-loading" command-line switch.
+  ///
+  cef_state_t image_loading;
+
+  ///
+  // Controls whether standalone images will be shrunk to fit the page. Also
+  // configurable using the "image-shrink-standalone-to-fit" command-line
+  // switch.
+  ///
+  cef_state_t image_shrink_standalone_to_fit;
+
+  ///
+  // Controls whether text areas can be resized. Also configurable using the
+  // "disable-text-area-resize" command-line switch.
+  ///
+  cef_state_t text_area_resize;
+
+  ///
+  // Controls whether the tab key can advance focus to links. Also configurable
+  // using the "disable-tab-to-links" command-line switch.
+  ///
+  cef_state_t tab_to_links;
+
+  ///
+  // Controls whether local storage can be used. Also configurable using the
+  // "disable-local-storage" command-line switch.
+  ///
+  cef_state_t local_storage;
+
+  ///
+  // Controls whether databases can be used. Also configurable using the
+  // "disable-databases" command-line switch.
+  ///
+  cef_state_t databases;
+
+  ///
+  // Controls whether the application cache can be used. Also configurable using
+  // the "disable-application-cache" command-line switch.
+  ///
+  cef_state_t application_cache;
+
+  ///
+  // Controls whether WebGL can be used. Note that WebGL requires hardware
+  // support and may not work on all systems even when enabled. Also
+  // configurable using the "disable-webgl" command-line switch.
+  ///
+  cef_state_t webgl;
+
+  ///
+  // Opaque background color used for the browser before a document is loaded
+  // and when no document color is specified. By default the background color
+  // will be the same as CefSettings.background_color. Only the RGB compontents
+  // of the specified value will be used. The alpha component must greater than
+  // 0 to enable use of the background color but will be otherwise ignored.
+  ///
+  cef_color_t background_color;
+
+  ///
+  // Comma delimited ordered list of language codes without any whitespace that
+  // will be used in the "Accept-Language" HTTP header. May be set globally
+  // using the CefBrowserSettings.accept_language_list value. If both values are
+  // empty then "en-US,en" will be used.
+  ///
+  cef_string_t accept_language_list;
+} cef_browser_settings_t;
+
+///
+// Return value types.
+///
+typedef enum {
+  ///
+  // Cancel immediately.
+  ///
+  RV_CANCEL = 0,
+
+  ///
+  // Continue immediately.
+  ///
+  RV_CONTINUE,
+
+  ///
+  // Continue asynchronously (usually via a callback).
+  ///
+  RV_CONTINUE_ASYNC,
+} cef_return_value_t;
+
+///
+// URL component parts.
+///
+typedef struct _cef_urlparts_t {
+  ///
+  // The complete URL specification.
+  ///
+  cef_string_t spec;
+
+  ///
+  // Scheme component not including the colon (e.g., "http").
+  ///
+  cef_string_t scheme;
+
+  ///
+  // User name component.
+  ///
+  cef_string_t username;
+
+  ///
+  // Password component.
+  ///
+  cef_string_t password;
+
+  ///
+  // Host component. This may be a hostname, an IPv4 address or an IPv6 literal
+  // surrounded by square brackets (e.g., "[2001:db8::1]").
+  ///
+  cef_string_t host;
+
+  ///
+  // Port number component.
+  ///
+  cef_string_t port;
+
+  ///
+  // Origin contains just the scheme, host, and port from a URL. Equivalent to
+  // clearing any username and password, replacing the path with a slash, and
+  // clearing everything after that. This value will be empty for non-standard
+  // URLs.
+  ///
+  cef_string_t origin;
+
+  ///
+  // Path component including the first slash following the host.
+  ///
+  cef_string_t path;
+
+  ///
+  // Query string component (i.e., everything following the '?').
+  ///
+  cef_string_t query;
+} cef_urlparts_t;
+
+///
+// Cookie information.
+///
+typedef struct _cef_cookie_t {
+  ///
+  // The cookie name.
+  ///
+  cef_string_t name;
+
+  ///
+  // The cookie value.
+  ///
+  cef_string_t value;
+
+  ///
+  // If |domain| is empty a host cookie will be created instead of a domain
+  // cookie. Domain cookies are stored with a leading "." and are visible to
+  // sub-domains whereas host cookies are not.
+  ///
+  cef_string_t domain;
+
+  ///
+  // If |path| is non-empty only URLs at or below the path will get the cookie
+  // value.
+  ///
+  cef_string_t path;
+
+  ///
+  // If |secure| is true the cookie will only be sent for HTTPS requests.
+  ///
+  int secure;
+
+  ///
+  // If |httponly| is true the cookie will only be sent for HTTP requests.
+  ///
+  int httponly;
+
+  ///
+  // The cookie creation date. This is automatically populated by the system on
+  // cookie creation.
+  ///
+  cef_time_t creation;
+
+  ///
+  // The cookie last access date. This is automatically populated by the system
+  // on access.
+  ///
+  cef_time_t last_access;
+
+  ///
+  // The cookie expiration date is only valid if |has_expires| is true.
+  ///
+  int has_expires;
+  cef_time_t expires;
+} cef_cookie_t;
+
+///
+// Process termination status values.
+///
+typedef enum {
+  ///
+  // Non-zero exit status.
+  ///
+  TS_ABNORMAL_TERMINATION,
+
+  ///
+  // SIGKILL or task manager kill.
+  ///
+  TS_PROCESS_WAS_KILLED,
+
+  ///
+  // Segmentation fault.
+  ///
+  TS_PROCESS_CRASHED,
+} cef_termination_status_t;
+
+///
+// Path key values.
+///
+typedef enum {
+  ///
+  // Current directory.
+  ///
+  PK_DIR_CURRENT,
+
+  ///
+  // Directory containing PK_FILE_EXE.
+  ///
+  PK_DIR_EXE,
+
+  ///
+  // Directory containing PK_FILE_MODULE.
+  ///
+  PK_DIR_MODULE,
+
+  ///
+  // Temporary directory.
+  ///
+  PK_DIR_TEMP,
+
+  ///
+  // Path and filename of the current executable.
+  ///
+  PK_FILE_EXE,
+
+  ///
+  // Path and filename of the module containing the CEF code (usually the libcef
+  // module).
+  ///
+  PK_FILE_MODULE,
+
+  ///
+  // "Local Settings\Application Data" directory under the user profile
+  // directory on Windows.
+  ///
+  PK_LOCAL_APP_DATA,
+
+  ///
+  // "Application Data" directory under the user profile directory on Windows
+  // and "~/Library/Application Support" directory on Mac OS X.
+  ///
+  PK_USER_DATA,
+} cef_path_key_t;
+
+///
+// Storage types.
+///
+typedef enum {
+  ST_LOCALSTORAGE = 0,
+  ST_SESSIONSTORAGE,
+} cef_storage_type_t;
+
+///
+// Supported error code values. See net\base\net_error_list.h for complete
+// descriptions of the error codes.
+///
+typedef enum {
+  ERR_NONE = 0,
+  ERR_FAILED = -2,
+  ERR_ABORTED = -3,
+  ERR_INVALID_ARGUMENT = -4,
+  ERR_INVALID_HANDLE = -5,
+  ERR_FILE_NOT_FOUND = -6,
+  ERR_TIMED_OUT = -7,
+  ERR_FILE_TOO_BIG = -8,
+  ERR_UNEXPECTED = -9,
+  ERR_ACCESS_DENIED = -10,
+  ERR_NOT_IMPLEMENTED = -11,
+  ERR_CONNECTION_CLOSED = -100,
+  ERR_CONNECTION_RESET = -101,
+  ERR_CONNECTION_REFUSED = -102,
+  ERR_CONNECTION_ABORTED = -103,
+  ERR_CONNECTION_FAILED = -104,
+  ERR_NAME_NOT_RESOLVED = -105,
+  ERR_INTERNET_DISCONNECTED = -106,
+  ERR_SSL_PROTOCOL_ERROR = -107,
+  ERR_ADDRESS_INVALID = -108,
+  ERR_ADDRESS_UNREACHABLE = -109,
+  ERR_SSL_CLIENT_AUTH_CERT_NEEDED = -110,
+  ERR_TUNNEL_CONNECTION_FAILED = -111,
+  ERR_NO_SSL_VERSIONS_ENABLED = -112,
+  ERR_SSL_VERSION_OR_CIPHER_MISMATCH = -113,
+  ERR_SSL_RENEGOTIATION_REQUESTED = -114,
+  ERR_CERT_COMMON_NAME_INVALID = -200,
+  ERR_CERT_BEGIN = ERR_CERT_COMMON_NAME_INVALID,
+  ERR_CERT_DATE_INVALID = -201,
+  ERR_CERT_AUTHORITY_INVALID = -202,
+  ERR_CERT_CONTAINS_ERRORS = -203,
+  ERR_CERT_NO_REVOCATION_MECHANISM = -204,
+  ERR_CERT_UNABLE_TO_CHECK_REVOCATION = -205,
+  ERR_CERT_REVOKED = -206,
+  ERR_CERT_INVALID = -207,
+  ERR_CERT_WEAK_SIGNATURE_ALGORITHM = -208,
+  // -209 is available: was ERR_CERT_NOT_IN_DNS.
+  ERR_CERT_NON_UNIQUE_NAME = -210,
+  ERR_CERT_WEAK_KEY = -211,
+  ERR_CERT_NAME_CONSTRAINT_VIOLATION = -212,
+  ERR_CERT_VALIDITY_TOO_LONG = -213,
+  ERR_CERT_END = ERR_CERT_VALIDITY_TOO_LONG,
+  ERR_INVALID_URL = -300,
+  ERR_DISALLOWED_URL_SCHEME = -301,
+  ERR_UNKNOWN_URL_SCHEME = -302,
+  ERR_TOO_MANY_REDIRECTS = -310,
+  ERR_UNSAFE_REDIRECT = -311,
+  ERR_UNSAFE_PORT = -312,
+  ERR_INVALID_RESPONSE = -320,
+  ERR_INVALID_CHUNKED_ENCODING = -321,
+  ERR_METHOD_NOT_SUPPORTED = -322,
+  ERR_UNEXPECTED_PROXY_AUTH = -323,
+  ERR_EMPTY_RESPONSE = -324,
+  ERR_RESPONSE_HEADERS_TOO_BIG = -325,
+  ERR_CACHE_MISS = -400,
+  ERR_INSECURE_RESPONSE = -501,
+} cef_errorcode_t;
+
+///
+// Supported certificate status code values. See net\cert\cert_status_flags.h
+// for more information. CERT_STATUS_NONE is new in CEF because we use an
+// enum while cert_status_flags.h uses a typedef and static const variables.
+///
+typedef enum {
+  CERT_STATUS_NONE = 0,
+  CERT_STATUS_COMMON_NAME_INVALID = 1 << 0,
+  CERT_STATUS_DATE_INVALID = 1 << 1,
+  CERT_STATUS_AUTHORITY_INVALID = 1 << 2,
+  // 1 << 3 is reserved for ERR_CERT_CONTAINS_ERRORS (not useful with WinHTTP).
+  CERT_STATUS_NO_REVOCATION_MECHANISM = 1 << 4,
+  CERT_STATUS_UNABLE_TO_CHECK_REVOCATION = 1 << 5,
+  CERT_STATUS_REVOKED = 1 << 6,
+  CERT_STATUS_INVALID = 1 << 7,
+  CERT_STATUS_WEAK_SIGNATURE_ALGORITHM = 1 << 8,
+  // 1 << 9 was used for CERT_STATUS_NOT_IN_DNS
+  CERT_STATUS_NON_UNIQUE_NAME = 1 << 10,
+  CERT_STATUS_WEAK_KEY = 1 << 11,
+  // 1 << 12 was used for CERT_STATUS_WEAK_DH_KEY
+  CERT_STATUS_PINNED_KEY_MISSING = 1 << 13,
+  CERT_STATUS_NAME_CONSTRAINT_VIOLATION = 1 << 14,
+  CERT_STATUS_VALIDITY_TOO_LONG = 1 << 15,
+
+  // Bits 16 to 31 are for non-error statuses.
+  CERT_STATUS_IS_EV = 1 << 16,
+  CERT_STATUS_REV_CHECKING_ENABLED = 1 << 17,
+  // Bit 18 was CERT_STATUS_IS_DNSSEC
+  CERT_STATUS_SHA1_SIGNATURE_PRESENT = 1 << 19,
+  CERT_STATUS_CT_COMPLIANCE_FAILED = 1 << 20,
+} cef_cert_status_t;
+
+///
+// The manner in which a link click should be opened.
+///
+typedef enum {
+  WOD_UNKNOWN,
+  WOD_SUPPRESS_OPEN,
+  WOD_CURRENT_TAB,
+  WOD_SINGLETON_TAB,
+  WOD_NEW_FOREGROUND_TAB,
+  WOD_NEW_BACKGROUND_TAB,
+  WOD_NEW_POPUP,
+  WOD_NEW_WINDOW,
+  WOD_SAVE_TO_DISK,
+  WOD_OFF_THE_RECORD,
+  WOD_IGNORE_ACTION
+} cef_window_open_disposition_t;
+
+///
+// "Verb" of a drag-and-drop operation as negotiated between the source and
+// destination. These constants match their equivalents in WebCore's
+// DragActions.h and should not be renumbered.
+///
+typedef enum {
+    DRAG_OPERATION_NONE    = 0,
+    DRAG_OPERATION_COPY    = 1,
+    DRAG_OPERATION_LINK    = 2,
+    DRAG_OPERATION_GENERIC = 4,
+    DRAG_OPERATION_PRIVATE = 8,
+    DRAG_OPERATION_MOVE    = 16,
+    DRAG_OPERATION_DELETE  = 32,
+    DRAG_OPERATION_EVERY   = UINT_MAX
+} cef_drag_operations_mask_t;
+
+///
+// V8 access control values.
+///
+typedef enum {
+  V8_ACCESS_CONTROL_DEFAULT               = 0,
+  V8_ACCESS_CONTROL_ALL_CAN_READ          = 1,
+  V8_ACCESS_CONTROL_ALL_CAN_WRITE         = 1 << 1,
+  V8_ACCESS_CONTROL_PROHIBITS_OVERWRITING = 1 << 2
+} cef_v8_accesscontrol_t;
+
+///
+// V8 property attribute values.
+///
+typedef enum {
+  V8_PROPERTY_ATTRIBUTE_NONE       = 0,       // Writeable, Enumerable,
+                                              //   Configurable
+  V8_PROPERTY_ATTRIBUTE_READONLY   = 1 << 0,  // Not writeable
+  V8_PROPERTY_ATTRIBUTE_DONTENUM   = 1 << 1,  // Not enumerable
+  V8_PROPERTY_ATTRIBUTE_DONTDELETE = 1 << 2   // Not configurable
+} cef_v8_propertyattribute_t;
+
+///
+// Post data elements may represent either bytes or files.
+///
+typedef enum {
+  PDE_TYPE_EMPTY  = 0,
+  PDE_TYPE_BYTES,
+  PDE_TYPE_FILE,
+} cef_postdataelement_type_t;
+
+///
+// Resource type for a request.
+///
+typedef enum {
+  ///
+  // Top level page.
+  ///
+  RT_MAIN_FRAME = 0,
+
+  ///
+  // Frame or iframe.
+  ///
+  RT_SUB_FRAME,
+
+  ///
+  // CSS stylesheet.
+  ///
+  RT_STYLESHEET,
+
+  ///
+  // External script.
+  ///
+  RT_SCRIPT,
+
+  ///
+  // Image (jpg/gif/png/etc).
+  ///
+  RT_IMAGE,
+
+  ///
+  // Font.
+  ///
+  RT_FONT_RESOURCE,
+
+  ///
+  // Some other subresource. This is the default type if the actual type is
+  // unknown.
+  ///
+  RT_SUB_RESOURCE,
+
+  ///
+  // Object (or embed) tag for a plugin, or a resource that a plugin requested.
+  ///
+  RT_OBJECT,
+
+  ///
+  // Media resource.
+  ///
+  RT_MEDIA,
+
+  ///
+  // Main resource of a dedicated worker.
+  ///
+  RT_WORKER,
+
+  ///
+  // Main resource of a shared worker.
+  ///
+  RT_SHARED_WORKER,
+
+  ///
+  // Explicitly requested prefetch.
+  ///
+  RT_PREFETCH,
+
+  ///
+  // Favicon.
+  ///
+  RT_FAVICON,
+
+  ///
+  // XMLHttpRequest.
+  ///
+  RT_XHR,
+
+  ///
+  // A request for a <ping>
+  ///
+  RT_PING,
+
+  ///
+  // Main resource of a service worker.
+  ///
+  RT_SERVICE_WORKER,
+
+  ///
+  // A report of Content Security Policy violations.
+  ///
+  RT_CSP_REPORT,
+
+  ///
+  // A resource that a plugin requested.
+  ///
+  RT_PLUGIN_RESOURCE,
+} cef_resource_type_t;
+
+///
+// Transition type for a request. Made up of one source value and 0 or more
+// qualifiers.
+///
+typedef enum {
+  ///
+  // Source is a link click or the JavaScript window.open function. This is
+  // also the default value for requests like sub-resource loads that are not
+  // navigations.
+  ///
+  TT_LINK = 0,
+
+  ///
+  // Source is some other "explicit" navigation action such as creating a new
+  // browser or using the LoadURL function. This is also the default value
+  // for navigations where the actual type is unknown.
+  ///
+  TT_EXPLICIT = 1,
+
+  ///
+  // Source is a subframe navigation. This is any content that is automatically
+  // loaded in a non-toplevel frame. For example, if a page consists of several
+  // frames containing ads, those ad URLs will have this transition type.
+  // The user may not even realize the content in these pages is a separate
+  // frame, so may not care about the URL.
+  ///
+  TT_AUTO_SUBFRAME = 3,
+
+  ///
+  // Source is a subframe navigation explicitly requested by the user that will
+  // generate new navigation entries in the back/forward list. These are
+  // probably more important than frames that were automatically loaded in
+  // the background because the user probably cares about the fact that this
+  // link was loaded.
+  ///
+  TT_MANUAL_SUBFRAME = 4,
+
+  ///
+  // Source is a form submission by the user. NOTE: In some situations
+  // submitting a form does not result in this transition type. This can happen
+  // if the form uses a script to submit the contents.
+  ///
+  TT_FORM_SUBMIT = 7,
+
+  ///
+  // Source is a "reload" of the page via the Reload function or by re-visiting
+  // the same URL. NOTE: This is distinct from the concept of whether a
+  // particular load uses "reload semantics" (i.e. bypasses cached data).
+  ///
+  TT_RELOAD = 8,
+
+  ///
+  // General mask defining the bits used for the source values.
+  ///
+  TT_SOURCE_MASK = 0xFF,
+
+  // Qualifiers.
+  // Any of the core values above can be augmented by one or more qualifiers.
+  // These qualifiers further define the transition.
+
+  ///
+  // Attempted to visit a URL but was blocked.
+  ///
+  TT_BLOCKED_FLAG = 0x00800000,
+
+  ///
+  // Used the Forward or Back function to navigate among browsing history.
+  ///
+  TT_FORWARD_BACK_FLAG = 0x01000000,
+
+  ///
+  // The beginning of a navigation chain.
+  ///
+  TT_CHAIN_START_FLAG = 0x10000000,
+
+  ///
+  // The last transition in a redirect chain.
+  ///
+  TT_CHAIN_END_FLAG = 0x20000000,
+
+  ///
+  // Redirects caused by JavaScript or a meta refresh tag on the page.
+  ///
+  TT_CLIENT_REDIRECT_FLAG = 0x40000000,
+
+  ///
+  // Redirects sent from the server by HTTP headers.
+  ///
+  TT_SERVER_REDIRECT_FLAG = 0x80000000,
+
+  ///
+  // Used to test whether a transition involves a redirect.
+  ///
+  TT_IS_REDIRECT_MASK = 0xC0000000,
+
+  ///
+  // General mask defining the bits used for the qualifiers.
+  ///
+  TT_QUALIFIER_MASK = 0xFFFFFF00,
+} cef_transition_type_t;
+
+///
+// Flags used to customize the behavior of CefURLRequest.
+///
+typedef enum {
+  ///
+  // Default behavior.
+  ///
+  UR_FLAG_NONE                      = 0,
+
+  ///
+  // If set the cache will be skipped when handling the request.
+  ///
+  UR_FLAG_SKIP_CACHE                = 1 << 0,
+
+  ///
+  // If set user name, password, and cookies may be sent with the request, and
+  // cookies may be saved from the response.
+  ///
+  UR_FLAG_ALLOW_CACHED_CREDENTIALS  = 1 << 1,
+
+  ///
+  // If set upload progress events will be generated when a request has a body.
+  ///
+  UR_FLAG_REPORT_UPLOAD_PROGRESS    = 1 << 3,
+
+  ///
+  // If set the CefURLRequestClient::OnDownloadData method will not be called.
+  ///
+  UR_FLAG_NO_DOWNLOAD_DATA          = 1 << 6,
+
+  ///
+  // If set 5XX redirect errors will be propagated to the observer instead of
+  // automatically re-tried. This currently only applies for requests
+  // originated in the browser process.
+  ///
+  UR_FLAG_NO_RETRY_ON_5XX           = 1 << 7,
+} cef_urlrequest_flags_t;
+
+///
+// Flags that represent CefURLRequest status.
+///
+typedef enum {
+  ///
+  // Unknown status.
+  ///
+  UR_UNKNOWN = 0,
+
+  ///
+  // Request succeeded.
+  ///
+  UR_SUCCESS,
+
+  ///
+  // An IO request is pending, and the caller will be informed when it is
+  // completed.
+  ///
+  UR_IO_PENDING,
+
+  ///
+  // Request was canceled programatically.
+  ///
+  UR_CANCELED,
+
+  ///
+  // Request failed for some reason.
+  ///
+  UR_FAILED,
+} cef_urlrequest_status_t;
+
+///
+// Structure representing a point.
+///
+typedef struct _cef_point_t {
+  int x;
+  int y;
+} cef_point_t;
+
+///
+// Structure representing a rectangle.
+///
+typedef struct _cef_rect_t {
+  int x;
+  int y;
+  int width;
+  int height;
+} cef_rect_t;
+
+///
+// Structure representing a size.
+///
+typedef struct _cef_size_t {
+  int width;
+  int height;
+} cef_size_t;
+
+///
+// Structure representing a range.
+///
+typedef struct _cef_range_t {
+  int from;
+  int to;
+} cef_range_t;
+
+///
+// Structure representing insets.
+///
+typedef struct _cef_insets_t {
+  int top;
+  int left;
+  int bottom;
+  int right;
+} cef_insets_t;
+
+///
+// Structure representing a draggable region.
+///
+typedef struct _cef_draggable_region_t {
+  ///
+  // Bounds of the region.
+  ///
+  cef_rect_t bounds;
+
+  ///
+  // True (1) this this region is draggable and false (0) otherwise.
+  ///
+  int draggable;
+} cef_draggable_region_t;
+
+///
+// Existing process IDs.
+///
+typedef enum {
+  ///
+  // Browser process.
+  ///
+  PID_BROWSER,
+  ///
+  // Renderer process.
+  ///
+  PID_RENDERER,
+} cef_process_id_t;
+
+///
+// Existing thread IDs.
+///
+typedef enum {
+// BROWSER PROCESS THREADS -- Only available in the browser process.
+
+  ///
+  // The main thread in the browser. This will be the same as the main
+  // application thread if CefInitialize() is called with a
+  // CefSettings.multi_threaded_message_loop value of false.
+  ///
+  TID_UI,
+
+  ///
+  // Used to interact with the database.
+  ///
+  TID_DB,
+
+  ///
+  // Used to interact with the file system.
+  ///
+  TID_FILE,
+
+  ///
+  // Used for file system operations that block user interactions.
+  // Responsiveness of this thread affects users.
+  ///
+  TID_FILE_USER_BLOCKING,
+
+  ///
+  // Used to launch and terminate browser processes.
+  ///
+  TID_PROCESS_LAUNCHER,
+
+  ///
+  // Used to handle slow HTTP cache operations.
+  ///
+  TID_CACHE,
+
+  ///
+  // Used to process IPC and network messages.
+  ///
+  TID_IO,
+
+// RENDER PROCESS THREADS -- Only available in the render process.
+
+  ///
+  // The main thread in the renderer. Used for all WebKit and V8 interaction.
+  ///
+  TID_RENDERER,
+} cef_thread_id_t;
+
+///
+// Supported value types.
+///
+typedef enum {
+  VTYPE_INVALID = 0,
+  VTYPE_NULL,
+  VTYPE_BOOL,
+  VTYPE_INT,
+  VTYPE_DOUBLE,
+  VTYPE_STRING,
+  VTYPE_BINARY,
+  VTYPE_DICTIONARY,
+  VTYPE_LIST,
+} cef_value_type_t;
+
+///
+// Supported JavaScript dialog types.
+///
+typedef enum {
+  JSDIALOGTYPE_ALERT = 0,
+  JSDIALOGTYPE_CONFIRM,
+  JSDIALOGTYPE_PROMPT,
+} cef_jsdialog_type_t;
+
+///
+// Screen information used when window rendering is disabled. This structure is
+// passed as a parameter to CefRenderHandler::GetScreenInfo and should be filled
+// in by the client.
+///
+typedef struct _cef_screen_info_t {
+  ///
+  // Device scale factor. Specifies the ratio between physical and logical
+  // pixels.
+  ///
+  float device_scale_factor;
+
+  ///
+  // The screen depth in bits per pixel.
+  ///
+  int depth;
+
+  ///
+  // The bits per color component. This assumes that the colors are balanced
+  // equally.
+  ///
+  int depth_per_component;
+
+  ///
+  // This can be true for black and white printers.
+  ///
+  int is_monochrome;
+
+  ///
+  // This is set from the rcMonitor member of MONITORINFOEX, to whit:
+  //   "A RECT structure that specifies the display monitor rectangle,
+  //   expressed in virtual-screen coordinates. Note that if the monitor
+  //   is not the primary display monitor, some of the rectangle's
+  //   coordinates may be negative values."
+  //
+  // The |rect| and |available_rect| properties are used to determine the
+  // available surface for rendering popup views.
+  ///
+  cef_rect_t rect;
+
+  ///
+  // This is set from the rcWork member of MONITORINFOEX, to whit:
+  //   "A RECT structure that specifies the work area rectangle of the
+  //   display monitor that can be used by applications, expressed in
+  //   virtual-screen coordinates. Windows uses this rectangle to
+  //   maximize an application on the monitor. The rest of the area in
+  //   rcMonitor contains system windows such as the task bar and side
+  //   bars. Note that if the monitor is not the primary display monitor,
+  //   some of the rectangle's coordinates may be negative values".
+  //
+  // The |rect| and |available_rect| properties are used to determine the
+  // available surface for rendering popup views.
+  ///
+  cef_rect_t available_rect;
+} cef_screen_info_t;
+
+///
+// Supported menu IDs. Non-English translations can be provided for the
+// IDS_MENU_* strings in CefResourceBundleHandler::GetLocalizedString().
+///
+typedef enum {
+  // Navigation.
+  MENU_ID_BACK                = 100,
+  MENU_ID_FORWARD             = 101,
+  MENU_ID_RELOAD              = 102,
+  MENU_ID_RELOAD_NOCACHE      = 103,
+  MENU_ID_STOPLOAD            = 104,
+
+  // Editing.
+  MENU_ID_UNDO                = 110,
+  MENU_ID_REDO                = 111,
+  MENU_ID_CUT                 = 112,
+  MENU_ID_COPY                = 113,
+  MENU_ID_PASTE               = 114,
+  MENU_ID_DELETE              = 115,
+  MENU_ID_SELECT_ALL          = 116,
+
+  // Miscellaneous.
+  MENU_ID_FIND                = 130,
+  MENU_ID_PRINT               = 131,
+  MENU_ID_VIEW_SOURCE         = 132,
+
+  // Spell checking word correction suggestions.
+  MENU_ID_SPELLCHECK_SUGGESTION_0        = 200,
+  MENU_ID_SPELLCHECK_SUGGESTION_1        = 201,
+  MENU_ID_SPELLCHECK_SUGGESTION_2        = 202,
+  MENU_ID_SPELLCHECK_SUGGESTION_3        = 203,
+  MENU_ID_SPELLCHECK_SUGGESTION_4        = 204,
+  MENU_ID_SPELLCHECK_SUGGESTION_LAST     = 204,
+  MENU_ID_NO_SPELLING_SUGGESTIONS        = 205,
+  MENU_ID_ADD_TO_DICTIONARY              = 206,
+
+  // Custom menu items originating from the renderer process. For example,
+  // plugin placeholder menu items or Flash menu items.
+  MENU_ID_CUSTOM_FIRST        = 220,
+  MENU_ID_CUSTOM_LAST         = 250,
+
+  // All user-defined menu IDs should come between MENU_ID_USER_FIRST and
+  // MENU_ID_USER_LAST to avoid overlapping the Chromium and CEF ID ranges
+  // defined in the tools/gritsettings/resource_ids file.
+  MENU_ID_USER_FIRST          = 26500,
+  MENU_ID_USER_LAST           = 28500,
+} cef_menu_id_t;
+
+///
+// Mouse button types.
+///
+typedef enum {
+  MBT_LEFT   = 0,
+  MBT_MIDDLE,
+  MBT_RIGHT,
+} cef_mouse_button_type_t;
+
+///
+// Structure representing mouse event information.
+///
+typedef struct _cef_mouse_event_t {
+  ///
+  // X coordinate relative to the left side of the view.
+  ///
+  int x;
+
+  ///
+  // Y coordinate relative to the top side of the view.
+  ///
+  int y;
+
+  ///
+  // Bit flags describing any pressed modifier keys. See
+  // cef_event_flags_t for values.
+  ///
+  uint32 modifiers;
+} cef_mouse_event_t;
+
+///
+// Paint element types.
+///
+typedef enum {
+  PET_VIEW  = 0,
+  PET_POPUP,
+} cef_paint_element_type_t;
+
+///
+// Supported event bit flags.
+///
+typedef enum {
+  EVENTFLAG_NONE                = 0,
+  EVENTFLAG_CAPS_LOCK_ON        = 1 << 0,
+  EVENTFLAG_SHIFT_DOWN          = 1 << 1,
+  EVENTFLAG_CONTROL_DOWN        = 1 << 2,
+  EVENTFLAG_ALT_DOWN            = 1 << 3,
+  EVENTFLAG_LEFT_MOUSE_BUTTON   = 1 << 4,
+  EVENTFLAG_MIDDLE_MOUSE_BUTTON = 1 << 5,
+  EVENTFLAG_RIGHT_MOUSE_BUTTON  = 1 << 6,
+  // Mac OS-X command key.
+  EVENTFLAG_COMMAND_DOWN        = 1 << 7,
+  EVENTFLAG_NUM_LOCK_ON         = 1 << 8,
+  EVENTFLAG_IS_KEY_PAD          = 1 << 9,
+  EVENTFLAG_IS_LEFT             = 1 << 10,
+  EVENTFLAG_IS_RIGHT            = 1 << 11,
+} cef_event_flags_t;
+
+///
+// Supported menu item types.
+///
+typedef enum {
+  MENUITEMTYPE_NONE,
+  MENUITEMTYPE_COMMAND,
+  MENUITEMTYPE_CHECK,
+  MENUITEMTYPE_RADIO,
+  MENUITEMTYPE_SEPARATOR,
+  MENUITEMTYPE_SUBMENU,
+} cef_menu_item_type_t;
+
+///
+// Supported context menu type flags.
+///
+typedef enum {
+  ///
+  // No node is selected.
+  ///
+  CM_TYPEFLAG_NONE        = 0,
+  ///
+  // The top page is selected.
+  ///
+  CM_TYPEFLAG_PAGE        = 1 << 0,
+  ///
+  // A subframe page is selected.
+  ///
+  CM_TYPEFLAG_FRAME       = 1 << 1,
+  ///
+  // A link is selected.
+  ///
+  CM_TYPEFLAG_LINK        = 1 << 2,
+  ///
+  // A media node is selected.
+  ///
+  CM_TYPEFLAG_MEDIA       = 1 << 3,
+  ///
+  // There is a textual or mixed selection that is selected.
+  ///
+  CM_TYPEFLAG_SELECTION   = 1 << 4,
+  ///
+  // An editable element is selected.
+  ///
+  CM_TYPEFLAG_EDITABLE    = 1 << 5,
+} cef_context_menu_type_flags_t;
+
+///
+// Supported context menu media types.
+///
+typedef enum {
+  ///
+  // No special node is in context.
+  ///
+  CM_MEDIATYPE_NONE,
+  ///
+  // An image node is selected.
+  ///
+  CM_MEDIATYPE_IMAGE,
+  ///
+  // A video node is selected.
+  ///
+  CM_MEDIATYPE_VIDEO,
+  ///
+  // An audio node is selected.
+  ///
+  CM_MEDIATYPE_AUDIO,
+  ///
+  // A file node is selected.
+  ///
+  CM_MEDIATYPE_FILE,
+  ///
+  // A plugin node is selected.
+  ///
+  CM_MEDIATYPE_PLUGIN,
+} cef_context_menu_media_type_t;
+
+///
+// Supported context menu media state bit flags.
+///
+typedef enum {
+  CM_MEDIAFLAG_NONE                  = 0,
+  CM_MEDIAFLAG_ERROR                 = 1 << 0,
+  CM_MEDIAFLAG_PAUSED                = 1 << 1,
+  CM_MEDIAFLAG_MUTED                 = 1 << 2,
+  CM_MEDIAFLAG_LOOP                  = 1 << 3,
+  CM_MEDIAFLAG_CAN_SAVE              = 1 << 4,
+  CM_MEDIAFLAG_HAS_AUDIO             = 1 << 5,
+  CM_MEDIAFLAG_HAS_VIDEO             = 1 << 6,
+  CM_MEDIAFLAG_CONTROL_ROOT_ELEMENT  = 1 << 7,
+  CM_MEDIAFLAG_CAN_PRINT             = 1 << 8,
+  CM_MEDIAFLAG_CAN_ROTATE            = 1 << 9,
+} cef_context_menu_media_state_flags_t;
+
+///
+// Supported context menu edit state bit flags.
+///
+typedef enum {
+  CM_EDITFLAG_NONE            = 0,
+  CM_EDITFLAG_CAN_UNDO        = 1 << 0,
+  CM_EDITFLAG_CAN_REDO        = 1 << 1,
+  CM_EDITFLAG_CAN_CUT         = 1 << 2,
+  CM_EDITFLAG_CAN_COPY        = 1 << 3,
+  CM_EDITFLAG_CAN_PASTE       = 1 << 4,
+  CM_EDITFLAG_CAN_DELETE      = 1 << 5,
+  CM_EDITFLAG_CAN_SELECT_ALL  = 1 << 6,
+  CM_EDITFLAG_CAN_TRANSLATE   = 1 << 7,
+} cef_context_menu_edit_state_flags_t;
+
+///
+// Key event types.
+///
+typedef enum {
+  ///
+  // Notification that a key transitioned from "up" to "down".
+  ///
+  KEYEVENT_RAWKEYDOWN = 0,
+
+  ///
+  // Notification that a key was pressed. This does not necessarily correspond
+  // to a character depending on the key and language. Use KEYEVENT_CHAR for
+  // character input.
+  ///
+  KEYEVENT_KEYDOWN,
+
+  ///
+  // Notification that a key was released.
+  ///
+  KEYEVENT_KEYUP,
+
+  ///
+  // Notification that a character was typed. Use this for text input. Key
+  // down events may generate 0, 1, or more than one character event depending
+  // on the key, locale, and operating system.
+  ///
+  KEYEVENT_CHAR
+} cef_key_event_type_t;
+
+///
+// Structure representing keyboard event information.
+///
+typedef struct _cef_key_event_t {
+  ///
+  // The type of keyboard event.
+  ///
+  cef_key_event_type_t type;
+
+  ///
+  // Bit flags describing any pressed modifier keys. See
+  // cef_event_flags_t for values.
+  ///
+  uint32 modifiers;
+
+  ///
+  // The Windows key code for the key event. This value is used by the DOM
+  // specification. Sometimes it comes directly from the event (i.e. on
+  // Windows) and sometimes it's determined using a mapping function. See
+  // WebCore/platform/chromium/KeyboardCodes.h for the list of values.
+  ///
+  int windows_key_code;
+
+  ///
+  // The actual key code genenerated by the platform.
+  ///
+  int native_key_code;
+
+  ///
+  // Indicates whether the event is considered a "system key" event (see
+  // http://msdn.microsoft.com/en-us/library/ms646286(VS.85).aspx for details).
+  // This value will always be false on non-Windows platforms.
+  ///
+  int is_system_key;
+
+  ///
+  // The character generated by the keystroke.
+  ///
+  char16 character;
+
+  ///
+  // Same as |character| but unmodified by any concurrently-held modifiers
+  // (except shift). This is useful for working out shortcut keys.
+  ///
+  char16 unmodified_character;
+
+  ///
+  // True if the focus is currently on an editable field on the page. This is
+  // useful for determining if standard key events should be intercepted.
+  ///
+  int focus_on_editable_field;
+} cef_key_event_t;
+
+///
+// Focus sources.
+///
+typedef enum {
+  ///
+  // The source is explicit navigation via the API (LoadURL(), etc).
+  ///
+  FOCUS_SOURCE_NAVIGATION = 0,
+  ///
+  // The source is a system-generated focus event.
+  ///
+  FOCUS_SOURCE_SYSTEM,
+} cef_focus_source_t;
+
+///
+// Navigation types.
+///
+typedef enum {
+  NAVIGATION_LINK_CLICKED = 0,
+  NAVIGATION_FORM_SUBMITTED,
+  NAVIGATION_BACK_FORWARD,
+  NAVIGATION_RELOAD,
+  NAVIGATION_FORM_RESUBMITTED,
+  NAVIGATION_OTHER,
+} cef_navigation_type_t;
+
+///
+// Supported XML encoding types. The parser supports ASCII, ISO-8859-1, and
+// UTF16 (LE and BE) by default. All other types must be translated to UTF8
+// before being passed to the parser. If a BOM is detected and the correct
+// decoder is available then that decoder will be used automatically.
+///
+typedef enum {
+  XML_ENCODING_NONE = 0,
+  XML_ENCODING_UTF8,
+  XML_ENCODING_UTF16LE,
+  XML_ENCODING_UTF16BE,
+  XML_ENCODING_ASCII,
+} cef_xml_encoding_type_t;
+
+///
+// XML node types.
+///
+typedef enum {
+  XML_NODE_UNSUPPORTED = 0,
+  XML_NODE_PROCESSING_INSTRUCTION,
+  XML_NODE_DOCUMENT_TYPE,
+  XML_NODE_ELEMENT_START,
+  XML_NODE_ELEMENT_END,
+  XML_NODE_ATTRIBUTE,
+  XML_NODE_TEXT,
+  XML_NODE_CDATA,
+  XML_NODE_ENTITY_REFERENCE,
+  XML_NODE_WHITESPACE,
+  XML_NODE_COMMENT,
+} cef_xml_node_type_t;
+
+///
+// Popup window features.
+///
+typedef struct _cef_popup_features_t {
+  int x;
+  int xSet;
+  int y;
+  int ySet;
+  int width;
+  int widthSet;
+  int height;
+  int heightSet;
+
+  int menuBarVisible;
+  int statusBarVisible;
+  int toolBarVisible;
+  int locationBarVisible;
+  int scrollbarsVisible;
+  int resizable;
+
+  int fullscreen;
+  int dialog;
+  cef_string_list_t additionalFeatures;
+} cef_popup_features_t;
+
+///
+// DOM document types.
+///
+typedef enum {
+  DOM_DOCUMENT_TYPE_UNKNOWN = 0,
+  DOM_DOCUMENT_TYPE_HTML,
+  DOM_DOCUMENT_TYPE_XHTML,
+  DOM_DOCUMENT_TYPE_PLUGIN,
+} cef_dom_document_type_t;
+
+///
+// DOM event category flags.
+///
+typedef enum {
+  DOM_EVENT_CATEGORY_UNKNOWN = 0x0,
+  DOM_EVENT_CATEGORY_UI = 0x1,
+  DOM_EVENT_CATEGORY_MOUSE = 0x2,
+  DOM_EVENT_CATEGORY_MUTATION = 0x4,
+  DOM_EVENT_CATEGORY_KEYBOARD = 0x8,
+  DOM_EVENT_CATEGORY_TEXT = 0x10,
+  DOM_EVENT_CATEGORY_COMPOSITION = 0x20,
+  DOM_EVENT_CATEGORY_DRAG = 0x40,
+  DOM_EVENT_CATEGORY_CLIPBOARD = 0x80,
+  DOM_EVENT_CATEGORY_MESSAGE = 0x100,
+  DOM_EVENT_CATEGORY_WHEEL = 0x200,
+  DOM_EVENT_CATEGORY_BEFORE_TEXT_INSERTED = 0x400,
+  DOM_EVENT_CATEGORY_OVERFLOW = 0x800,
+  DOM_EVENT_CATEGORY_PAGE_TRANSITION = 0x1000,
+  DOM_EVENT_CATEGORY_POPSTATE = 0x2000,
+  DOM_EVENT_CATEGORY_PROGRESS = 0x4000,
+  DOM_EVENT_CATEGORY_XMLHTTPREQUEST_PROGRESS = 0x8000,
+} cef_dom_event_category_t;
+
+///
+// DOM event processing phases.
+///
+typedef enum {
+  DOM_EVENT_PHASE_UNKNOWN = 0,
+  DOM_EVENT_PHASE_CAPTURING,
+  DOM_EVENT_PHASE_AT_TARGET,
+  DOM_EVENT_PHASE_BUBBLING,
+} cef_dom_event_phase_t;
+
+///
+// DOM node types.
+///
+typedef enum {
+  DOM_NODE_TYPE_UNSUPPORTED = 0,
+  DOM_NODE_TYPE_ELEMENT,
+  DOM_NODE_TYPE_ATTRIBUTE,
+  DOM_NODE_TYPE_TEXT,
+  DOM_NODE_TYPE_CDATA_SECTION,
+  DOM_NODE_TYPE_PROCESSING_INSTRUCTIONS,
+  DOM_NODE_TYPE_COMMENT,
+  DOM_NODE_TYPE_DOCUMENT,
+  DOM_NODE_TYPE_DOCUMENT_TYPE,
+  DOM_NODE_TYPE_DOCUMENT_FRAGMENT,
+} cef_dom_node_type_t;
+
+///
+// Supported file dialog modes.
+///
+typedef enum {
+  ///
+  // Requires that the file exists before allowing the user to pick it.
+  ///
+  FILE_DIALOG_OPEN = 0,
+
+  ///
+  // Like Open, but allows picking multiple files to open.
+  ///
+  FILE_DIALOG_OPEN_MULTIPLE,
+
+  ///
+  // Like Open, but selects a folder to open.
+  ///
+  FILE_DIALOG_OPEN_FOLDER,
+
+  ///
+  // Allows picking a nonexistent file, and prompts to overwrite if the file
+  // already exists.
+  ///
+  FILE_DIALOG_SAVE,
+
+  ///
+  // General mask defining the bits used for the type values.
+  ///
+  FILE_DIALOG_TYPE_MASK = 0xFF,
+
+  // Qualifiers.
+  // Any of the type values above can be augmented by one or more qualifiers.
+  // These qualifiers further define the dialog behavior.
+
+  ///
+  // Prompt to overwrite if the user selects an existing file with the Save
+  // dialog.
+  ///
+  FILE_DIALOG_OVERWRITEPROMPT_FLAG = 0x01000000,
+
+  ///
+  // Do not display read-only files.
+  ///
+  FILE_DIALOG_HIDEREADONLY_FLAG = 0x02000000,
+} cef_file_dialog_mode_t;
+
+///
+// Geoposition error codes.
+///
+typedef enum {
+  GEOPOSITON_ERROR_NONE = 0,
+  GEOPOSITON_ERROR_PERMISSION_DENIED,
+  GEOPOSITON_ERROR_POSITION_UNAVAILABLE,
+  GEOPOSITON_ERROR_TIMEOUT,
+} cef_geoposition_error_code_t;
+
+///
+// Structure representing geoposition information. The properties of this
+// structure correspond to those of the JavaScript Position object although
+// their types may differ.
+///
+typedef struct _cef_geoposition_t {
+  ///
+  // Latitude in decimal degrees north (WGS84 coordinate frame).
+  ///
+  double latitude;
+
+  ///
+  // Longitude in decimal degrees west (WGS84 coordinate frame).
+  ///
+  double longitude;
+
+  ///
+  // Altitude in meters (above WGS84 datum).
+  ///
+  double altitude;
+
+  ///
+  // Accuracy of horizontal position in meters.
+  ///
+  double accuracy;
+
+  ///
+  // Accuracy of altitude in meters.
+  ///
+  double altitude_accuracy;
+
+  ///
+  // Heading in decimal degrees clockwise from true north.
+  ///
+  double heading;
+
+  ///
+  // Horizontal component of device velocity in meters per second.
+  ///
+  double speed;
+
+  ///
+  // Time of position measurement in milliseconds since Epoch in UTC time. This
+  // is taken from the host computer's system clock.
+  ///
+  cef_time_t timestamp;
+
+  ///
+  // Error code, see enum above.
+  ///
+  cef_geoposition_error_code_t error_code;
+
+  ///
+  // Human-readable error message.
+  ///
+  cef_string_t error_message;
+} cef_geoposition_t;
+
+///
+// Print job color mode values.
+///
+typedef enum {
+  COLOR_MODEL_UNKNOWN,
+  COLOR_MODEL_GRAY,
+  COLOR_MODEL_COLOR,
+  COLOR_MODEL_CMYK,
+  COLOR_MODEL_CMY,
+  COLOR_MODEL_KCMY,
+  COLOR_MODEL_CMY_K,  // CMY_K represents CMY+K.
+  COLOR_MODEL_BLACK,
+  COLOR_MODEL_GRAYSCALE,
+  COLOR_MODEL_RGB,
+  COLOR_MODEL_RGB16,
+  COLOR_MODEL_RGBA,
+  COLOR_MODEL_COLORMODE_COLOR,  // Used in samsung printer ppds.
+  COLOR_MODEL_COLORMODE_MONOCHROME,  // Used in samsung printer ppds.
+  COLOR_MODEL_HP_COLOR_COLOR,  // Used in HP color printer ppds.
+  COLOR_MODEL_HP_COLOR_BLACK,  // Used in HP color printer ppds.
+  COLOR_MODEL_PRINTOUTMODE_NORMAL,  // Used in foomatic ppds.
+  COLOR_MODEL_PRINTOUTMODE_NORMAL_GRAY,  // Used in foomatic ppds.
+  COLOR_MODEL_PROCESSCOLORMODEL_CMYK,  // Used in canon printer ppds.
+  COLOR_MODEL_PROCESSCOLORMODEL_GREYSCALE,  // Used in canon printer ppds.
+  COLOR_MODEL_PROCESSCOLORMODEL_RGB,  // Used in canon printer ppds
+} cef_color_model_t;
+
+///
+// Print job duplex mode values.
+///
+typedef enum {
+  DUPLEX_MODE_UNKNOWN = -1,
+  DUPLEX_MODE_SIMPLEX,
+  DUPLEX_MODE_LONG_EDGE,
+  DUPLEX_MODE_SHORT_EDGE,
+} cef_duplex_mode_t;
+
+///
+// Cursor type values.
+///
+typedef enum {
+  CT_POINTER = 0,
+  CT_CROSS,
+  CT_HAND,
+  CT_IBEAM,
+  CT_WAIT,
+  CT_HELP,
+  CT_EASTRESIZE,
+  CT_NORTHRESIZE,
+  CT_NORTHEASTRESIZE,
+  CT_NORTHWESTRESIZE,
+  CT_SOUTHRESIZE,
+  CT_SOUTHEASTRESIZE,
+  CT_SOUTHWESTRESIZE,
+  CT_WESTRESIZE,
+  CT_NORTHSOUTHRESIZE,
+  CT_EASTWESTRESIZE,
+  CT_NORTHEASTSOUTHWESTRESIZE,
+  CT_NORTHWESTSOUTHEASTRESIZE,
+  CT_COLUMNRESIZE,
+  CT_ROWRESIZE,
+  CT_MIDDLEPANNING,
+  CT_EASTPANNING,
+  CT_NORTHPANNING,
+  CT_NORTHEASTPANNING,
+  CT_NORTHWESTPANNING,
+  CT_SOUTHPANNING,
+  CT_SOUTHEASTPANNING,
+  CT_SOUTHWESTPANNING,
+  CT_WESTPANNING,
+  CT_MOVE,
+  CT_VERTICALTEXT,
+  CT_CELL,
+  CT_CONTEXTMENU,
+  CT_ALIAS,
+  CT_PROGRESS,
+  CT_NODROP,
+  CT_COPY,
+  CT_NONE,
+  CT_NOTALLOWED,
+  CT_ZOOMIN,
+  CT_ZOOMOUT,
+  CT_GRAB,
+  CT_GRABBING,
+  CT_CUSTOM,
+} cef_cursor_type_t;
+
+///
+// Structure representing cursor information. |buffer| will be
+// |size.width|*|size.height|*4 bytes in size and represents a BGRA image with
+// an upper-left origin.
+///
+typedef struct _cef_cursor_info_t {
+  cef_point_t hotspot;
+  float image_scale_factor;
+  void* buffer;
+  cef_size_t size;
+} cef_cursor_info_t;
+
+///
+// URI unescape rules passed to CefURIDecode().
+///
+typedef enum {
+  ///
+  // Don't unescape anything at all.
+  ///
+  UU_NONE = 0,
+
+  ///
+  // Don't unescape anything special, but all normal unescaping will happen.
+  // This is a placeholder and can't be combined with other flags (since it's
+  // just the absence of them). All other unescape rules imply "normal" in
+  // addition to their special meaning. Things like escaped letters, digits,
+  // and most symbols will get unescaped with this mode.
+  ///
+  UU_NORMAL = 1 << 0,
+
+  ///
+  // Convert %20 to spaces. In some places where we're showing URLs, we may
+  // want this. In places where the URL may be copied and pasted out, then
+  // you wouldn't want this since it might not be interpreted in one piece
+  // by other applications.
+  ///
+  UU_SPACES = 1 << 1,
+
+  ///
+  // Unescapes '/' and '\\'. If these characters were unescaped, the resulting
+  // URL won't be the same as the source one. Moreover, they are dangerous to
+  // unescape in strings that will be used as file paths or names. This value
+  // should only be used when slashes don't have special meaning, like data
+  // URLs.
+  ///
+  UU_PATH_SEPARATORS = 1 << 2,
+
+  ///
+  // Unescapes various characters that will change the meaning of URLs,
+  // including '%', '+', '&', '#'. Does not unescape path separators.
+  // If these characters were unescaped, the resulting URL won't be the same
+  // as the source one. This flag is used when generating final output like
+  // filenames for URLs where we won't be interpreting as a URL and want to do
+  // as much unescaping as possible.
+  ///
+  UU_URL_SPECIAL_CHARS_EXCEPT_PATH_SEPARATORS = 1 << 3,
+
+  ///
+  // Unescapes characters that can be used in spoofing attempts (such as LOCK)
+  // and control characters (such as BiDi control characters and %01).  This
+  // INCLUDES NULLs.  This is used for rare cases such as data: URL decoding
+  // where the result is binary data.
+  //
+  // DO NOT use UU_SPOOFING_AND_CONTROL_CHARS if the URL is going to be
+  // displayed in the UI for security reasons.
+  ///
+  UU_SPOOFING_AND_CONTROL_CHARS = 1 << 4,
+
+  ///
+  // URL queries use "+" for space. This flag controls that replacement.
+  ///
+  UU_REPLACE_PLUS_WITH_SPACE = 1 << 5,
+} cef_uri_unescape_rule_t;
+
+///
+// Options that can be passed to CefParseJSON.
+///
+typedef enum {
+  ///
+  // Parses the input strictly according to RFC 4627. See comments in Chromium's
+  // base/json/json_reader.h file for known limitations/deviations from the RFC.
+  ///
+  JSON_PARSER_RFC = 0,
+
+  ///
+  // Allows commas to exist after the last element in structures.
+  ///
+  JSON_PARSER_ALLOW_TRAILING_COMMAS = 1 << 0,
+} cef_json_parser_options_t;
+
+///
+// Error codes that can be returned from CefParseJSONAndReturnError.
+///
+typedef enum {
+  JSON_NO_ERROR = 0,
+  JSON_INVALID_ESCAPE,
+  JSON_SYNTAX_ERROR,
+  JSON_UNEXPECTED_TOKEN,
+  JSON_TRAILING_COMMA,
+  JSON_TOO_MUCH_NESTING,
+  JSON_UNEXPECTED_DATA_AFTER_ROOT,
+  JSON_UNSUPPORTED_ENCODING,
+  JSON_UNQUOTED_DICTIONARY_KEY,
+  JSON_PARSE_ERROR_COUNT
+} cef_json_parser_error_t;
+
+///
+// Options that can be passed to CefWriteJSON.
+///
+typedef enum {
+  ///
+  // Default behavior.
+  ///
+  JSON_WRITER_DEFAULT = 0,
+
+  ///
+  // This option instructs the writer that if a Binary value is encountered,
+  // the value (and key if within a dictionary) will be omitted from the
+  // output, and success will be returned. Otherwise, if a binary value is
+  // encountered, failure will be returned.
+  ///
+  JSON_WRITER_OMIT_BINARY_VALUES = 1 << 0,
+
+  ///
+  // This option instructs the writer to write doubles that have no fractional
+  // part as a normal integer (i.e., without using exponential notation
+  // or appending a '.0') as long as the value is within the range of a
+  // 64-bit int.
+  ///
+  JSON_WRITER_OMIT_DOUBLE_TYPE_PRESERVATION = 1 << 1,
+
+  ///
+  // Return a slightly nicer formatted json string (pads with whitespace to
+  // help with readability).
+  ///
+  JSON_WRITER_PRETTY_PRINT = 1 << 2,
+} cef_json_writer_options_t;
+
+///
+// Margin type for PDF printing.
+///
+typedef enum {
+  ///
+  // Default margins.
+  ///
+  PDF_PRINT_MARGIN_DEFAULT,
+
+  ///
+  // No margins.
+  ///
+  PDF_PRINT_MARGIN_NONE,
+
+  ///
+  // Minimum margins.
+  ///
+  PDF_PRINT_MARGIN_MINIMUM,
+
+  ///
+  // Custom margins using the |margin_*| values from cef_pdf_print_settings_t.
+  ///
+  PDF_PRINT_MARGIN_CUSTOM,
+} cef_pdf_print_margin_type_t;
+
+///
+// Structure representing PDF print settings.
+///
+typedef struct _cef_pdf_print_settings_t {
+  ///
+  // Page title to display in the header. Only used if |header_footer_enabled|
+  // is set to true (1).
+  ///
+  cef_string_t header_footer_title;
+
+  ///
+  // URL to display in the footer. Only used if |header_footer_enabled| is set
+  // to true (1).
+  ///
+  cef_string_t header_footer_url;
+
+  ///
+  // Output page size in microns. If either of these values is less than or
+  // equal to zero then the default paper size (A4) will be used.
+  ///
+  int page_width;
+  int page_height;
+
+  ///
+  // Margins in millimeters. Only used if |margin_type| is set to
+  // PDF_PRINT_MARGIN_CUSTOM.
+  ///
+  double margin_top;
+  double margin_right;
+  double margin_bottom;
+  double margin_left;
+
+  ///
+  // Margin type.
+  ///
+  cef_pdf_print_margin_type_t margin_type;
+
+  ///
+  // Set to true (1) to print headers and footers or false (0) to not print
+  // headers and footers.
+  ///
+  int header_footer_enabled;
+
+  ///
+  // Set to true (1) to print the selection only or false (0) to print all.
+  ///
+  int selection_only;
+
+  ///
+  // Set to true (1) for landscape mode or false (0) for portrait mode.
+  ///
+  int landscape;
+
+  ///
+  // Set to true (1) to print background graphics or false (0) to not print
+  // background graphics.
+  ///
+  int backgrounds_enabled;
+
+} cef_pdf_print_settings_t;
+
+///
+// Supported UI scale factors for the platform. SCALE_FACTOR_NONE is used for
+// density independent resources such as string, html/js files or an image that
+// can be used for any scale factors (such as wallpapers).
+///
+typedef enum {
+  SCALE_FACTOR_NONE = 0,
+  SCALE_FACTOR_100P,
+  SCALE_FACTOR_125P,
+  SCALE_FACTOR_133P,
+  SCALE_FACTOR_140P,
+  SCALE_FACTOR_150P,
+  SCALE_FACTOR_180P,
+  SCALE_FACTOR_200P,
+  SCALE_FACTOR_250P,
+  SCALE_FACTOR_300P,
+} cef_scale_factor_t;
+
+///
+// Plugin policies supported by CefRequestContextHandler::OnBeforePluginLoad.
+///
+typedef enum {
+  ///
+  // Allow the content.
+  ///
+  PLUGIN_POLICY_ALLOW,
+
+  ///
+  // Allow important content and block unimportant content based on heuristics.
+  // The user can manually load blocked content.
+  ///
+  PLUGIN_POLICY_DETECT_IMPORTANT,
+
+  ///
+  // Block the content. The user can manually load blocked content.
+  ///
+  PLUGIN_POLICY_BLOCK,
+
+  ///
+  // Disable the content. The user cannot load disabled content.
+  ///
+  PLUGIN_POLICY_DISABLE,
+} cef_plugin_policy_t;
+
+///
+// Policy for how the Referrer HTTP header value will be sent during navigation.
+// If the `--no-referrers` command-line flag is specified then the policy value
+// will be ignored and the Referrer value will never be sent.
+///
+typedef enum {
+  ///
+  // Always send the complete Referrer value.
+  ///
+  REFERRER_POLICY_ALWAYS,
+
+  ///
+  // Use the default policy. This is REFERRER_POLICY_ORIGIN_WHEN_CROSS_ORIGIN
+  // when the `--reduced-referrer-granularity` command-line flag is specified
+  // and REFERRER_POLICY_NO_REFERRER_WHEN_DOWNGRADE otherwise.
+  //
+  ///
+  REFERRER_POLICY_DEFAULT,
+
+  ///
+  // When navigating from HTTPS to HTTP do not send the Referrer value.
+  // Otherwise, send the complete Referrer value.
+  ///
+  REFERRER_POLICY_NO_REFERRER_WHEN_DOWNGRADE,
+
+  ///
+  // Never send the Referrer value.
+  ///
+  REFERRER_POLICY_NEVER,
+
+  ///
+  // Only send the origin component of the Referrer value.
+  ///
+  REFERRER_POLICY_ORIGIN,
+
+  ///
+  // When navigating cross-origin only send the origin component of the Referrer
+  // value. Otherwise, send the complete Referrer value.
+  ///
+  REFERRER_POLICY_ORIGIN_WHEN_CROSS_ORIGIN,
+} cef_referrer_policy_t;
+
+///
+// Return values for CefResponseFilter::Filter().
+///
+typedef enum {
+  ///
+  // Some or all of the pre-filter data was read successfully but more data is
+  // needed in order to continue filtering (filtered output is pending).
+  ///
+  RESPONSE_FILTER_NEED_MORE_DATA,
+
+  ///
+  // Some or all of the pre-filter data was read successfully and all available
+  // filtered output has been written.
+  ///
+  RESPONSE_FILTER_DONE,
+
+  ///
+  // An error occurred during filtering.
+  ///
+  RESPONSE_FILTER_ERROR
+} cef_response_filter_status_t;
+
+///
+// Describes how to interpret the components of a pixel.
+///
+typedef enum {
+  ///
+  // RGBA with 8 bits per pixel (32bits total).
+  ///
+  CEF_COLOR_TYPE_RGBA_8888,
+
+  ///
+  // BGRA with 8 bits per pixel (32bits total).
+  ///
+  CEF_COLOR_TYPE_BGRA_8888,
+} cef_color_type_t;
+
+///
+// Describes how to interpret the alpha component of a pixel.
+///
+typedef enum {
+  ///
+  // No transparency. The alpha component is ignored.
+  ///
+  CEF_ALPHA_TYPE_OPAQUE,
+
+  ///
+  // Transparency with pre-multiplied alpha component.
+  ///
+  CEF_ALPHA_TYPE_PREMULTIPLIED,
+  
+  ///
+  // Transparency with post-multiplied alpha component.
+  ///
+  CEF_ALPHA_TYPE_POSTMULTIPLIED,
+} cef_alpha_type_t;
+
+///
+// Text style types. Should be kepy in sync with gfx::TextStyle.
+///
+typedef enum {
+  CEF_TEXT_STYLE_BOLD,
+  CEF_TEXT_STYLE_ITALIC,
+  CEF_TEXT_STYLE_STRIKE,
+  CEF_TEXT_STYLE_DIAGONAL_STRIKE,
+  CEF_TEXT_STYLE_UNDERLINE,
+} cef_text_style_t;
+
+///
+// Specifies where along the main axis the CefBoxLayout child views should be
+// laid out.
+///
+typedef enum {
+  ///
+  // Child views will be left-aligned.
+  ///
+  CEF_MAIN_AXIS_ALIGNMENT_START,
+
+  ///
+  // Child views will be center-aligned.
+  ///
+  CEF_MAIN_AXIS_ALIGNMENT_CENTER,
+
+  ///
+  // Child views will be right-aligned.
+  ///
+  CEF_MAIN_AXIS_ALIGNMENT_END,
+} cef_main_axis_alignment_t;
+
+///
+// Specifies where along the cross axis the CefBoxLayout child views should be
+// laid out.
+///
+typedef enum {
+  ///
+  // Child views will be stretched to fit.
+  ///
+  CEF_CROSS_AXIS_ALIGNMENT_STRETCH,
+
+  ///
+  // Child views will be left-aligned.
+  ///
+  CEF_CROSS_AXIS_ALIGNMENT_START,
+
+  ///
+  // Child views will be center-aligned.
+  ///
+  CEF_CROSS_AXIS_ALIGNMENT_CENTER,
+
+  ///
+  // Child views will be right-aligned.
+  ///
+  CEF_CROSS_AXIS_ALIGNMENT_END,
+} cef_cross_axis_alignment_t;
+
+///
+// Settings used when initializing a CefBoxLayout.
+///
+typedef struct _cef_box_layout_settings_t {
+  ///
+  // If true (1) the layout will be horizontal, otherwise the layout will be
+  // vertical.
+  ///
+  int horizontal;
+
+  ///
+  // Adds additional horizontal space between the child view area and the host
+  // view border.
+  ///
+  int inside_border_horizontal_spacing;
+
+  ///
+  // Adds additional vertical space between the child view area and the host
+  // view border.
+  ///
+  int inside_border_vertical_spacing;
+
+  ///
+  // Adds additional space around the child view area.
+  ///
+  cef_insets_t inside_border_insets;
+
+  ///
+  // Adds additional space between child views.
+  ///
+  int between_child_spacing;
+
+  ///
+  // Specifies where along the main axis the child views should be laid out.
+  ///
+  cef_main_axis_alignment_t main_axis_alignment;
+
+  ///
+  // Specifies where along the cross axis the child views should be laid out.
+  ///
+  cef_cross_axis_alignment_t cross_axis_alignment;
+
+  ///
+  // Minimum cross axis size.
+  ///
+  int minimum_cross_axis_size;
+
+  ///
+  // Default flex for views when none is specified via CefBoxLayout methods.
+  // Using the preferred size as the basis, free space along the main axis is
+  // distributed to views in the ratio of their flex weights. Similarly, if the
+  // views will overflow the parent, space is subtracted in these ratios. A flex
+  // of 0 means this view is not resized. Flex values must not be negative.
+  ///
+  int default_flex;
+} cef_box_layout_settings_t;
+
+///
+// Specifies the button display state.
+///
+typedef enum {
+  CEF_BUTTON_STATE_NORMAL,
+  CEF_BUTTON_STATE_HOVERED,
+  CEF_BUTTON_STATE_PRESSED,
+  CEF_BUTTON_STATE_DISABLED,
+} cef_button_state_t;
+
+///
+// Specifies the horizontal text alignment mode.
+///
+typedef enum {
+  ///
+  // Align the text's left edge with that of its display area.
+  ///
+  CEF_HORIZONTAL_ALIGNMENT_LEFT,
+
+  ///
+  // Align the text's center with that of its display area.
+  ///
+  CEF_HORIZONTAL_ALIGNMENT_CENTER,
+
+  ///
+  // Align the text's right edge with that of its display area.
+  ///
+  CEF_HORIZONTAL_ALIGNMENT_RIGHT,
+} cef_horizontal_alignment_t;
+
+///
+// Specifies how a menu will be anchored for non-RTL languages. The opposite
+// position will be used for RTL languages.
+///
+typedef enum {
+  CEF_MENU_ANCHOR_TOPLEFT,
+  CEF_MENU_ANCHOR_TOPRIGHT,
+  CEF_MENU_ANCHOR_BOTTOMCENTER,
+} cef_menu_anchor_position_t;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_INTERNAL_CEF_TYPES_H_
diff --git a/src/include/libcef/internal/cef_types_win.h b/src/include/libcef/internal/cef_types_win.h
new file mode 100644
index 0000000..75e0276
--- /dev/null
+++ b/src/include/libcef/internal/cef_types_win.h
@@ -0,0 +1,109 @@
+// Copyright (c) 2009 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+#ifndef CEF_INCLUDE_INTERNAL_CEF_TYPES_WIN_H_
+#define CEF_INCLUDE_INTERNAL_CEF_TYPES_WIN_H_
+#pragma once
+
+#include "libcef/base/cef_build.h"
+
+#if defined(OS_WIN)
+  #include <windows.h>
+  #include "libcef/internal/cef_string.h"
+
+// Handle types.
+#define cef_cursor_handle_t HCURSOR
+#define cef_event_handle_t MSG*
+#define cef_window_handle_t HWND
+#define cef_text_input_context_t void*
+
+#define kNullCursorHandle NULL
+#define kNullEventHandle NULL
+#define kNullWindowHandle NULL
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///
+// Structure representing CefExecuteProcess arguments.
+///
+typedef struct _cef_main_args_t {
+  HINSTANCE instance;
+} cef_main_args_t;
+
+///
+// Structure representing window information.
+///
+typedef struct _cef_window_info_t {
+  // Standard parameters required by CreateWindowEx()
+  DWORD ex_style;
+  cef_string_t window_name;
+  DWORD style;
+  int x;
+  int y;
+  int width;
+  int height;
+  cef_window_handle_t parent_window;
+  HMENU menu;
+
+  ///
+  // Set to true (1) to create the browser using windowless (off-screen)
+  // rendering. No window will be created for the browser and all rendering will
+  // occur via the CefRenderHandler interface. The |parent_window| value will be
+  // used to identify monitor info and to act as the parent window for dialogs,
+  // context menus, etc. If |parent_window| is not provided then the main screen
+  // monitor will be used and some functionality that requires a parent window
+  // may not function correctly. In order to create windowless browsers the
+  // CefSettings.windowless_rendering_enabled value must be set to true.
+  ///
+  int windowless_rendering_enabled;
+
+  ///
+  // Set to true (1) to enable transparent painting in combination with
+  // windowless rendering. When this value is true a transparent background
+  // color will be used (RGBA=0x00000000). When this value is false the
+  // background will be white and opaque.
+  ///
+  int transparent_painting_enabled;
+
+  ///
+  // Handle for the new browser window. Only used with windowed rendering.
+  ///
+  cef_window_handle_t window;
+} cef_window_info_t;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // OS_WIN
+
+#endif  // CEF_INCLUDE_INTERNAL_CEF_TYPES_WIN_H_
diff --git a/src/include/libcef/internal/cef_types_wrappers.h b/src/include/libcef/internal/cef_types_wrappers.h
new file mode 100644
index 0000000..1f6d8ed
--- /dev/null
+++ b/src/include/libcef/internal/cef_types_wrappers.h
@@ -0,0 +1,977 @@
+// Copyright (c) 2013 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef CEF_INCLUDE_INTERNAL_CEF_TYPES_WRAPPERS_H_
+#define CEF_INCLUDE_INTERNAL_CEF_TYPES_WRAPPERS_H_
+#pragma once
+
+#include "libcef/internal/cef_string.h"
+#include "libcef/internal/cef_string_list.h"
+#include "libcef/internal/cef_types.h"
+
+///
+// Template class that provides common functionality for CEF structure wrapping.
+///
+template <class traits>
+class CefStructBase : public traits::struct_type {
+ public:
+  typedef typename traits::struct_type struct_type;
+
+  CefStructBase() : attached_to_(NULL) {
+    Init();
+  }
+  virtual ~CefStructBase() {
+    // Only clear this object's data if it isn't currently attached to a
+    // structure.
+    if (!attached_to_)
+      Clear(this);
+  }
+
+  CefStructBase(const CefStructBase& r) {
+    Init();
+    *this = r;
+  }
+  CefStructBase(const struct_type& r) {  // NOLINT(runtime/explicit)
+    Init();
+    *this = r;
+  }
+
+  ///
+  // Clear this object's values.
+  ///
+  void Reset() {
+    Clear(this);
+    Init();
+  }
+
+  ///
+  // Attach to the source structure's existing values. DetachTo() can be called
+  // to insert the values back into the existing structure.
+  ///
+  void AttachTo(struct_type& source) {
+    // Only clear this object's data if it isn't currently attached to a
+    // structure.
+    if (!attached_to_)
+      Clear(this);
+
+    // This object is now attached to the new structure.
+    attached_to_ = &source;
+
+    // Transfer ownership of the values from the source structure.
+    memcpy(static_cast<struct_type*>(this), &source, sizeof(struct_type));
+  }
+
+  ///
+  // Relinquish ownership of values to the target structure.
+  ///
+  void DetachTo(struct_type& target) {
+    if (attached_to_ != &target) {
+      // Clear the target structure's values only if we are not currently
+      // attached to that structure.
+      Clear(&target);
+    }
+
+    // Transfer ownership of the values to the target structure.
+    memcpy(&target, static_cast<struct_type*>(this), sizeof(struct_type));
+
+    // Remove the references from this object.
+    Init();
+  }
+
+  ///
+  // Set this object's values. If |copy| is true the source structure's values
+  // will be copied instead of referenced.
+  ///
+  void Set(const struct_type& source, bool copy) {
+    traits::set(&source, this, copy);
+  }
+
+  CefStructBase& operator=(const CefStructBase& s) {
+    return operator=(static_cast<const struct_type&>(s));
+  }
+
+  CefStructBase& operator=(const struct_type& s) {
+    Set(s, true);
+    return *this;
+  }
+
+ protected:
+  void Init() {
+    memset(static_cast<struct_type*>(this), 0, sizeof(struct_type));
+    attached_to_ = NULL;
+    traits::init(this);
+  }
+
+  static void Clear(struct_type* s) { traits::clear(s); }
+
+  struct_type* attached_to_;
+};
+
+
+struct CefPointTraits {
+  typedef cef_point_t struct_type;
+
+  static inline void init(struct_type* s) {}
+  static inline void clear(struct_type* s) {}
+
+  static inline void set(const struct_type* src, struct_type* target,
+      bool copy) {
+    *target = *src;
+  }
+};
+
+///
+// Class representing a point.
+///
+class CefPoint : public CefStructBase<CefPointTraits> {
+ public:
+  typedef CefStructBase<CefPointTraits> parent;
+
+  CefPoint() : parent() {}
+  CefPoint(const cef_point_t& r) : parent(r) {}  // NOLINT(runtime/explicit)
+  CefPoint(const CefPoint& r) : parent(r) {}  // NOLINT(runtime/explicit)
+  CefPoint(int x, int y) : parent() {
+    Set(x, y);
+  }
+
+  bool IsEmpty() const { return x <= 0 && y <= 0; }
+  void Set(int x_val, int y_val) {
+    x = x_val, y = y_val;
+  }
+};
+
+inline bool operator==(const CefPoint& a, const CefPoint& b) {
+  return a.x == b.x && a.y == b.y;
+}
+
+inline bool operator!=(const CefPoint& a, const CefPoint& b) {
+  return !(a == b);
+}
+
+
+struct CefRectTraits {
+  typedef cef_rect_t struct_type;
+
+  static inline void init(struct_type* s) {}
+  static inline void clear(struct_type* s) {}
+
+  static inline void set(const struct_type* src, struct_type* target,
+      bool copy) {
+    *target = *src;
+  }
+};
+
+///
+// Class representing a rectangle.
+///
+class CefRect : public CefStructBase<CefRectTraits> {
+ public:
+  typedef CefStructBase<CefRectTraits> parent;
+
+  CefRect() : parent() {}
+  CefRect(const cef_rect_t& r) : parent(r) {}  // NOLINT(runtime/explicit)
+  CefRect(const CefRect& r) : parent(r) {}  // NOLINT(runtime/explicit)
+  CefRect(int x, int y, int width, int height) : parent() {
+    Set(x, y, width, height);
+  }
+
+  bool IsEmpty() const { return width <= 0 || height <= 0; }
+  void Set(int x_val, int y_val, int width_val, int height_val) {
+    x = x_val, y = y_val, width = width_val, height = height_val;
+  }
+
+  // Returns true if the point identified by point_x and point_y falls inside
+  // this rectangle.  The point (x, y) is inside the rectangle, but the
+  // point (x + width, y + height) is not.
+  bool Contains(int point_x, int point_y) const {
+    return (point_x >= x) && (point_x < x + width) && (point_y >= y) &&
+           (point_y < y + height);
+  }
+  bool Contains(const CefPoint& point) const {
+    return Contains(point.x, point.y);
+  }
+};
+
+inline bool operator==(const CefRect& a, const CefRect& b) {
+  return a.x == b.x && a.y == b.y && a.width == b.width && a.height == b.height;
+}
+
+inline bool operator!=(const CefRect& a, const CefRect& b) {
+  return !(a == b);
+}
+
+
+struct CefSizeTraits {
+  typedef cef_size_t struct_type;
+
+  static inline void init(struct_type* s) {}
+  static inline void clear(struct_type* s) {}
+
+  static inline void set(const struct_type* src, struct_type* target,
+      bool copy) {
+    *target = *src;
+  }
+};
+
+///
+// Class representing a size.
+///
+class CefSize : public CefStructBase<CefSizeTraits> {
+ public:
+  typedef CefStructBase<CefSizeTraits> parent;
+
+  CefSize() : parent() {}
+  CefSize(const cef_size_t& r) : parent(r) {}  // NOLINT(runtime/explicit)
+  CefSize(const CefSize& r) : parent(r) {}  // NOLINT(runtime/explicit)
+  CefSize(int width, int height) : parent() {
+    Set(width, height);
+  }
+
+  bool IsEmpty() const { return width <= 0 || height <= 0; }
+  void Set(int width_val, int height_val) {
+    width = width_val, height = height_val;
+  }
+};
+
+inline bool operator==(const CefSize& a, const CefSize& b) {
+  return a.width == b.width && a.height == b.height;
+}
+
+inline bool operator!=(const CefSize& a, const CefSize& b) {
+  return !(a == b);
+}
+
+
+struct CefRangeTraits {
+  typedef cef_range_t struct_type;
+
+  static inline void init(struct_type* s) {}
+  static inline void clear(struct_type* s) {}
+
+  static inline void set(const struct_type* src, struct_type* target,
+      bool copy) {
+    *target = *src;
+  }
+};
+
+///
+// Class representing a range.
+///
+class CefRange : public CefStructBase<CefRangeTraits> {
+ public:
+  typedef CefStructBase<CefRangeTraits> parent;
+
+  CefRange() : parent() {}
+  CefRange(const cef_range_t& r)  // NOLINT(runtime/explicit)
+      : parent(r) {}
+  CefRange(const CefRange& r)  // NOLINT(runtime/explicit)
+      : parent(r) {}
+  CefRange(int from, int to) : parent() {
+    Set(from, to);
+  }
+
+  void Set(int from_val, int to_val) {
+    from = from_val, to = to_val;
+  }
+};
+
+inline bool operator==(const CefRange& a, const CefRange& b) {
+  return a.from == b.from && a.to == b.to;
+}
+
+inline bool operator!=(const CefRange& a, const CefRange& b) {
+  return !(a == b);
+}
+
+
+struct CefInsetsTraits {
+  typedef cef_insets_t struct_type;
+
+  static inline void init(struct_type* s) {}
+  static inline void clear(struct_type* s) {}
+
+  static inline void set(const struct_type* src, struct_type* target,
+      bool copy) {
+    *target = *src;
+  }
+};
+
+///
+// Class representing insets.
+///
+class CefInsets : public CefStructBase<CefInsetsTraits> {
+ public:
+  typedef CefStructBase<CefInsetsTraits> parent;
+
+  CefInsets() : parent() {}
+  CefInsets(const cef_insets_t& r) : parent(r) {}  // NOLINT(runtime/explicit)
+  CefInsets(const CefInsets& r) : parent(r) {}  // NOLINT(runtime/explicit)
+  CefInsets(int top, int left, int bottom, int right) : parent() {
+    Set(top, left, bottom, right);
+  }
+
+  void Set(int top_val, int left_val, int bottom_val, int right_val) {
+    top = top_val, left = left_val, bottom = bottom_val, right = right_val;
+  }
+};
+
+inline bool operator==(const CefInsets& a, const CefInsets& b) {
+  return a.top == b.top && a.left == b.left && a.bottom == b.bottom &&
+         a.right == b.right;
+}
+
+inline bool operator!=(const CefInsets& a, const CefInsets& b) {
+  return !(a == b);
+}
+
+
+struct CefDraggableRegionTraits {
+  typedef cef_draggable_region_t struct_type;
+
+  static inline void init(struct_type* s) {}
+  static inline void clear(struct_type* s) {}
+
+  static inline void set(const struct_type* src, struct_type* target,
+      bool copy) {
+    *target = *src;
+  }
+};
+
+///
+// Class representing a draggable region.
+///
+class CefDraggableRegion : public CefStructBase<CefDraggableRegionTraits> {
+ public:
+  typedef CefStructBase<CefDraggableRegionTraits> parent;
+
+  CefDraggableRegion() : parent() {}
+  CefDraggableRegion(const cef_draggable_region_t& r)  // NOLINT(runtime/explicit)
+    : parent(r) {}
+  CefDraggableRegion(const CefDraggableRegion& r)  // NOLINT(runtime/explicit)
+    : parent(r) {}
+  CefDraggableRegion(const CefRect& bounds, bool draggable) : parent() {
+    Set(bounds, draggable);
+  }
+
+  void Set(const CefRect& bounds_val, bool draggable_val) {
+    bounds = bounds_val, draggable = draggable_val;
+  }
+};
+
+inline bool operator==(const CefDraggableRegion& a,
+    const CefDraggableRegion& b) {
+  return a.bounds == b.bounds && a.draggable == b.draggable;
+}
+
+inline bool operator!=(const CefDraggableRegion& a,
+    const CefDraggableRegion& b) {
+  return !(a == b);
+}
+
+
+struct CefScreenInfoTraits {
+  typedef cef_screen_info_t struct_type;
+
+  static inline void init(struct_type* s) {}
+
+  static inline void clear(struct_type* s) {}
+
+  static inline void set(const struct_type* src, struct_type* target,
+      bool copy) {
+    target->device_scale_factor = src->device_scale_factor;
+    target->depth = src->depth;
+    target->depth_per_component = src->depth_per_component;
+    target->is_monochrome = src->is_monochrome;
+    target->rect = src->rect;
+    target->available_rect = src->available_rect;
+  }
+};
+
+///
+// Class representing the virtual screen information for use when window
+// rendering is disabled.
+///
+class CefScreenInfo : public CefStructBase<CefScreenInfoTraits> {
+ public:
+  typedef CefStructBase<CefScreenInfoTraits> parent;
+
+  CefScreenInfo() : parent() {}
+  CefScreenInfo(const cef_screen_info_t& r) : parent(r) {}  // NOLINT(runtime/explicit)
+  CefScreenInfo(const CefScreenInfo& r) : parent(r) {}  // NOLINT(runtime/explicit)
+  CefScreenInfo(float device_scale_factor,
+                int depth,
+                int depth_per_component,
+                bool is_monochrome,
+                const CefRect& rect,
+                const CefRect& available_rect) : parent() {
+    Set(device_scale_factor, depth, depth_per_component,
+        is_monochrome, rect, available_rect);
+  }
+
+  void Set(float device_scale_factor_val,
+           int depth_val,
+           int depth_per_component_val,
+           bool is_monochrome_val,
+           const CefRect& rect_val,
+           const CefRect& available_rect_val) {
+    device_scale_factor = device_scale_factor_val;
+    depth = depth_val;
+    depth_per_component = depth_per_component_val;
+    is_monochrome = is_monochrome_val;
+    rect = rect_val;
+    available_rect = available_rect_val;
+  }
+};
+
+
+struct CefKeyEventTraits {
+  typedef cef_key_event_t struct_type;
+
+  static inline void init(struct_type* s) {}
+
+  static inline void clear(struct_type* s) {}
+
+  static inline void set(const struct_type* src, struct_type* target,
+      bool copy) {
+    target->type = src->type;
+    target->modifiers = src->modifiers;
+    target->windows_key_code = src->windows_key_code;
+    target->native_key_code = src->native_key_code;
+    target->is_system_key = src->is_system_key;
+    target->character = src->character;
+    target->unmodified_character = src->unmodified_character;
+    target->focus_on_editable_field = src->focus_on_editable_field;
+  }
+};
+
+///
+// Class representing a a keyboard event.
+///
+typedef CefStructBase<CefKeyEventTraits> CefKeyEvent;
+
+
+struct CefMouseEventTraits {
+  typedef cef_mouse_event_t struct_type;
+
+  static inline void init(struct_type* s) {}
+
+  static inline void clear(struct_type* s) {}
+
+  static inline void set(const struct_type* src, struct_type* target,
+      bool copy) {
+    target->x = src->x;
+    target->y = src->y;
+    target->modifiers = src->modifiers;
+  }
+};
+
+///
+// Class representing a mouse event.
+///
+typedef CefStructBase<CefMouseEventTraits> CefMouseEvent;
+
+
+struct CefPopupFeaturesTraits {
+  typedef cef_popup_features_t struct_type;
+
+  static inline void init(struct_type* s) {
+    s->menuBarVisible = true;
+    s->statusBarVisible = true;
+    s->toolBarVisible = true;
+    s->locationBarVisible = true;
+    s->scrollbarsVisible = true;
+    s->resizable = true;
+  }
+
+  static inline void clear(struct_type* s) {
+    if (s->additionalFeatures)
+      cef_string_list_free(s->additionalFeatures);
+  }
+
+  static inline void set(const struct_type* src, struct_type* target,
+      bool copy) {
+    if (target->additionalFeatures)
+      cef_string_list_free(target->additionalFeatures);
+    target->additionalFeatures = src->additionalFeatures ?
+        cef_string_list_copy(src->additionalFeatures) : NULL;
+
+    target->x = src->x;
+    target->xSet = src->xSet;
+    target->y = src->y;
+    target->ySet = src->ySet;
+    target->width = src->width;
+    target->widthSet = src->widthSet;
+    target->height = src->height;
+    target->heightSet = src->heightSet;
+    target->menuBarVisible = src->menuBarVisible;
+    target->statusBarVisible = src->statusBarVisible;
+    target->toolBarVisible = src->toolBarVisible;
+    target->locationBarVisible = src->locationBarVisible;
+    target->scrollbarsVisible = src->scrollbarsVisible;
+    target->resizable = src->resizable;
+    target->fullscreen = src->fullscreen;
+    target->dialog = src->dialog;
+  }
+};
+
+///
+// Class representing popup window features.
+///
+typedef CefStructBase<CefPopupFeaturesTraits> CefPopupFeatures;
+
+
+struct CefSettingsTraits {
+  typedef cef_settings_t struct_type;
+
+  static inline void init(struct_type* s) {
+    s->size = sizeof(struct_type);
+  }
+
+  static inline void clear(struct_type* s) {
+    cef_string_clear(&s->browser_subprocess_path);
+    cef_string_clear(&s->cache_path);
+    cef_string_clear(&s->user_data_path);
+    cef_string_clear(&s->user_agent);
+    cef_string_clear(&s->product_version);
+    cef_string_clear(&s->locale);
+    cef_string_clear(&s->log_file);
+    cef_string_clear(&s->javascript_flags);
+    cef_string_clear(&s->resources_dir_path);
+    cef_string_clear(&s->locales_dir_path);
+    cef_string_clear(&s->accept_language_list);
+  }
+
+  static inline void set(const struct_type* src, struct_type* target,
+      bool copy) {
+    target->single_process = src->single_process;
+    target->no_sandbox = src->no_sandbox;
+    cef_string_set(src->browser_subprocess_path.str,
+        src->browser_subprocess_path.length,
+        &target->browser_subprocess_path, copy);
+    target->multi_threaded_message_loop = src->multi_threaded_message_loop;
+    target->windowless_rendering_enabled = src->windowless_rendering_enabled;
+    target->command_line_args_disabled = src->command_line_args_disabled;
+
+    cef_string_set(src->cache_path.str, src->cache_path.length,
+        &target->cache_path, copy);
+    cef_string_set(src->user_data_path.str, src->user_data_path.length,
+        &target->user_data_path, copy);
+    target->persist_session_cookies = src->persist_session_cookies;
+    target->persist_user_preferences = src->persist_user_preferences;
+
+    cef_string_set(src->user_agent.str, src->user_agent.length,
+        &target->user_agent, copy);
+    cef_string_set(src->product_version.str, src->product_version.length,
+        &target->product_version, copy);
+    cef_string_set(src->locale.str, src->locale.length, &target->locale, copy);
+
+    cef_string_set(src->log_file.str, src->log_file.length, &target->log_file,
+        copy);
+    target->log_severity = src->log_severity;
+    cef_string_set(src->javascript_flags.str, src->javascript_flags.length,
+        &target->javascript_flags, copy);
+
+    cef_string_set(src->resources_dir_path.str, src->resources_dir_path.length,
+        &target->resources_dir_path, copy);
+    cef_string_set(src->locales_dir_path.str, src->locales_dir_path.length,
+        &target->locales_dir_path, copy);
+    target->pack_loading_disabled = src->pack_loading_disabled;
+    target->remote_debugging_port = src->remote_debugging_port;
+    target->uncaught_exception_stack_size = src->uncaught_exception_stack_size;
+    target->context_safety_implementation = src->context_safety_implementation;
+    target->ignore_certificate_errors = src->ignore_certificate_errors;
+    target->background_color = src->background_color;
+
+    cef_string_set(src->accept_language_list.str,
+        src->accept_language_list.length, &target->accept_language_list, copy);
+  }
+};
+
+///
+// Class representing initialization settings.
+///
+typedef CefStructBase<CefSettingsTraits> CefSettings;
+
+
+struct CefRequestContextSettingsTraits {
+  typedef cef_request_context_settings_t struct_type;
+
+  static inline void init(struct_type* s) {
+    s->size = sizeof(struct_type);
+  }
+
+  static inline void clear(struct_type* s) {
+    cef_string_clear(&s->cache_path);
+    cef_string_clear(&s->accept_language_list);
+  }
+
+  static inline void set(const struct_type* src, struct_type* target,
+      bool copy) {
+    cef_string_set(src->cache_path.str, src->cache_path.length,
+        &target->cache_path, copy);
+    target->persist_session_cookies = src->persist_session_cookies;
+    target->persist_user_preferences = src->persist_user_preferences;
+    target->ignore_certificate_errors = src->ignore_certificate_errors;
+    cef_string_set(src->accept_language_list.str,
+        src->accept_language_list.length, &target->accept_language_list, copy);
+  }
+};
+
+///
+// Class representing request context initialization settings.
+///
+typedef CefStructBase<CefRequestContextSettingsTraits>
+    CefRequestContextSettings;
+
+
+struct CefBrowserSettingsTraits {
+  typedef cef_browser_settings_t struct_type;
+
+  static inline void init(struct_type* s) {
+    s->size = sizeof(struct_type);
+  }
+
+  static inline void clear(struct_type* s) {
+    cef_string_clear(&s->standard_font_family);
+    cef_string_clear(&s->fixed_font_family);
+    cef_string_clear(&s->serif_font_family);
+    cef_string_clear(&s->sans_serif_font_family);
+    cef_string_clear(&s->cursive_font_family);
+    cef_string_clear(&s->fantasy_font_family);
+    cef_string_clear(&s->default_encoding);
+    cef_string_clear(&s->accept_language_list);
+  }
+
+  static inline void set(const struct_type* src, struct_type* target,
+      bool copy) {
+    target->windowless_frame_rate = src->windowless_frame_rate;
+
+    cef_string_set(src->standard_font_family.str,
+        src->standard_font_family.length, &target->standard_font_family, copy);
+    cef_string_set(src->fixed_font_family.str, src->fixed_font_family.length,
+        &target->fixed_font_family, copy);
+    cef_string_set(src->serif_font_family.str, src->serif_font_family.length,
+        &target->serif_font_family, copy);
+    cef_string_set(src->sans_serif_font_family.str,
+        src->sans_serif_font_family.length, &target->sans_serif_font_family,
+        copy);
+    cef_string_set(src->cursive_font_family.str,
+        src->cursive_font_family.length, &target->cursive_font_family, copy);
+    cef_string_set(src->fantasy_font_family.str,
+        src->fantasy_font_family.length, &target->fantasy_font_family, copy);
+
+    target->default_font_size = src->default_font_size;
+    target->default_fixed_font_size = src->default_fixed_font_size;
+    target->minimum_font_size = src->minimum_font_size;
+    target->minimum_logical_font_size = src->minimum_logical_font_size;
+
+    cef_string_set(src->default_encoding.str, src->default_encoding.length,
+        &target->default_encoding, copy);
+
+    target->remote_fonts = src->remote_fonts;
+    target->javascript = src->javascript;
+    target->javascript_open_windows = src->javascript_open_windows;
+    target->javascript_close_windows = src->javascript_close_windows;
+    target->javascript_access_clipboard = src->javascript_access_clipboard;
+    target->javascript_dom_paste = src->javascript_dom_paste;
+    target->caret_browsing = src->caret_browsing;
+    target->plugins = src->plugins;
+    target->universal_access_from_file_urls =
+        src->universal_access_from_file_urls;
+    target->file_access_from_file_urls = src->file_access_from_file_urls;
+    target->web_security = src->web_security;
+    target->image_loading = src->image_loading;
+    target->image_shrink_standalone_to_fit =
+        src->image_shrink_standalone_to_fit;
+    target->text_area_resize = src->text_area_resize;
+    target->tab_to_links = src->tab_to_links;
+    target->local_storage = src->local_storage;
+    target->databases= src->databases;
+    target->application_cache = src->application_cache;
+    target->webgl = src->webgl;
+
+    target->background_color = src->background_color;
+
+    cef_string_set(src->accept_language_list.str,
+        src->accept_language_list.length, &target->accept_language_list, copy);
+  }
+};
+
+///
+// Class representing browser initialization settings.
+///
+typedef CefStructBase<CefBrowserSettingsTraits> CefBrowserSettings;
+
+
+struct CefURLPartsTraits {
+  typedef cef_urlparts_t struct_type;
+
+  static inline void init(struct_type* s) {}
+
+  static inline void clear(struct_type* s) {
+    cef_string_clear(&s->spec);
+    cef_string_clear(&s->scheme);
+    cef_string_clear(&s->username);
+    cef_string_clear(&s->password);
+    cef_string_clear(&s->host);
+    cef_string_clear(&s->port);
+    cef_string_clear(&s->origin);
+    cef_string_clear(&s->path);
+    cef_string_clear(&s->query);
+  }
+
+  static inline void set(const struct_type* src, struct_type* target,
+      bool copy) {
+    cef_string_set(src->spec.str, src->spec.length, &target->spec, copy);
+    cef_string_set(src->scheme.str, src->scheme.length, &target->scheme, copy);
+    cef_string_set(src->username.str, src->username.length, &target->username,
+        copy);
+    cef_string_set(src->password.str, src->password.length, &target->password,
+        copy);
+    cef_string_set(src->host.str, src->host.length, &target->host, copy);
+    cef_string_set(src->port.str, src->port.length, &target->port, copy);
+    cef_string_set(src->origin.str, src->origin.length, &target->origin, copy);
+    cef_string_set(src->path.str, src->path.length, &target->path, copy);
+    cef_string_set(src->query.str, src->query.length, &target->query, copy);
+  }
+};
+
+///
+// Class representing a URL's component parts.
+///
+typedef CefStructBase<CefURLPartsTraits> CefURLParts;
+
+
+struct CefTimeTraits {
+  typedef cef_time_t struct_type;
+
+  static inline void init(struct_type* s) {}
+
+  static inline void clear(struct_type* s) {}
+
+  static inline void set(const struct_type* src, struct_type* target,
+      bool copy) {
+    *target = *src;
+  }
+};
+
+///
+// Class representing a time.
+///
+class CefTime : public CefStructBase<CefTimeTraits> {
+ public:
+  typedef CefStructBase<CefTimeTraits> parent;
+
+  CefTime() : parent() {}
+  CefTime(const cef_time_t& r) : parent(r) {}  // NOLINT(runtime/explicit)
+  CefTime(const CefTime& r) : parent(r) {}  // NOLINT(runtime/explicit)
+  explicit CefTime(time_t r) : parent() { SetTimeT(r); }
+  explicit CefTime(double r) : parent() { SetDoubleT(r); }
+
+  // Converts to/from time_t.
+  void SetTimeT(time_t r) {
+    cef_time_from_timet(r, this);
+  }
+  time_t GetTimeT() const {
+    time_t time = 0;
+    cef_time_to_timet(this, &time);
+    return time;
+  }
+
+  // Converts to/from a double which is the number of seconds since epoch
+  // (Jan 1, 1970). Webkit uses this format to represent time. A value of 0
+  // means "not initialized".
+  void SetDoubleT(double r) {
+    cef_time_from_doublet(r, this);
+  }
+  double GetDoubleT() const {
+    double time = 0;
+    cef_time_to_doublet(this, &time);
+    return time;
+  }
+
+  // Set this object to now.
+  void Now() {
+    cef_time_now(this);
+  }
+
+  // Return the delta between this object and |other| in milliseconds.
+  long long Delta(const CefTime& other) {
+    long long delta = 0;
+    cef_time_delta(this, &other, &delta);
+    return delta;
+  }
+};
+
+
+struct CefCookieTraits {
+  typedef cef_cookie_t struct_type;
+
+  static inline void init(struct_type* s) {}
+
+  static inline void clear(struct_type* s) {
+    cef_string_clear(&s->name);
+    cef_string_clear(&s->value);
+    cef_string_clear(&s->domain);
+    cef_string_clear(&s->path);
+  }
+
+  static inline void set(const struct_type* src, struct_type* target,
+      bool copy) {
+    cef_string_set(src->name.str, src->name.length, &target->name, copy);
+    cef_string_set(src->value.str, src->value.length, &target->value, copy);
+    cef_string_set(src->domain.str, src->domain.length, &target->domain, copy);
+    cef_string_set(src->path.str, src->path.length, &target->path, copy);
+    target->secure = src->secure;
+    target->httponly = src->httponly;
+    target->creation = src->creation;
+    target->last_access = src->last_access;
+    target->has_expires = src->has_expires;
+    target->expires = src->expires;
+  }
+};
+
+///
+// Class representing a cookie.
+///
+typedef CefStructBase<CefCookieTraits> CefCookie;
+
+
+struct CefGeopositionTraits {
+  typedef cef_geoposition_t struct_type;
+
+  static inline void init(struct_type* s) {}
+
+  static inline void clear(struct_type* s) {
+    cef_string_clear(&s->error_message);
+  }
+
+  static inline void set(const struct_type* src, struct_type* target,
+      bool copy) {
+    target->latitude = src->latitude;
+    target->longitude = src->longitude;
+    target->altitude = src->altitude;
+    target->accuracy = src->accuracy;
+    target->altitude_accuracy = src->altitude_accuracy;
+    target->heading = src->heading;
+    target->speed = src->speed;
+    target->timestamp = src->timestamp;
+    target->error_code = src->error_code;
+    cef_string_set(src->error_message.str, src->error_message.length,
+        &target->error_message, copy);
+  }
+};
+
+///
+// Class representing a geoposition.
+///
+typedef CefStructBase<CefGeopositionTraits> CefGeoposition;
+
+
+struct CefCursorInfoTraits {
+  typedef cef_cursor_info_t struct_type;
+
+  static inline void init(struct_type* s) {}
+
+  static inline void clear(struct_type* s) {}
+
+  static inline void set(const struct_type* src, struct_type* target,
+      bool copy) {
+    target->hotspot = src->hotspot;
+    target->image_scale_factor = src->image_scale_factor;
+    target->buffer = src->buffer;
+    target->size = src->size;
+  }
+};
+
+///
+// Class representing cursor information.
+///
+typedef CefStructBase<CefCursorInfoTraits> CefCursorInfo;
+
+
+struct CefPdfPrintSettingsTraits {
+  typedef cef_pdf_print_settings_t struct_type;
+
+  static inline void init(struct_type* s) {}
+
+  static inline void clear(struct_type* s) {
+    cef_string_clear(&s->header_footer_title);
+    cef_string_clear(&s->header_footer_url);
+  }
+
+  static inline void set(const struct_type* src, struct_type* target,
+      bool copy) {
+
+    cef_string_set(src->header_footer_title.str,
+        src->header_footer_title.length, &target->header_footer_title, copy);
+    cef_string_set(src->header_footer_url.str, src->header_footer_url.length,
+        &target->header_footer_url, copy);
+
+    target->page_width = src->page_width;
+    target->page_height = src->page_height;
+
+    target->margin_top = src->margin_top;
+    target->margin_right = src->margin_right;
+    target->margin_bottom = src->margin_bottom;
+    target->margin_left = src->margin_left;
+    target->margin_type = src->margin_type;
+
+    target->header_footer_enabled = src->header_footer_enabled;
+    target->selection_only = src->selection_only;
+    target->landscape = src->landscape;
+    target->backgrounds_enabled = src->backgrounds_enabled;
+  }
+};
+
+///
+// Class representing PDF print settings
+///
+typedef CefStructBase<CefPdfPrintSettingsTraits> CefPdfPrintSettings;
+
+
+struct CefBoxLayoutSettingsTraits {
+  typedef cef_box_layout_settings_t struct_type;
+
+  static inline void init(struct_type* s) {}
+
+  static inline void clear(struct_type* s) {}
+
+  static inline void set(const struct_type* src, struct_type* target,
+      bool copy) {
+    *target = *src;
+  }
+};
+
+///
+// Class representing CefBoxLayout settings.
+///
+typedef CefStructBase<CefBoxLayoutSettingsTraits> CefBoxLayoutSettings;
+
+#endif  // CEF_INCLUDE_INTERNAL_CEF_TYPES_WRAPPERS_H_
diff --git a/src/include/libcef/internal/cef_win.h b/src/include/libcef/internal/cef_win.h
new file mode 100644
index 0000000..6a6b8d2
--- /dev/null
+++ b/src/include/libcef/internal/cef_win.h
@@ -0,0 +1,156 @@
+// Copyright (c) 2008 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+#ifndef CEF_INCLUDE_INTERNAL_CEF_WIN_H_
+#define CEF_INCLUDE_INTERNAL_CEF_WIN_H_
+#pragma once
+
+#include "libcef/internal/cef_types_win.h"
+#include "libcef/internal/cef_types_wrappers.h"
+
+///
+// Handle types.
+///
+#define CefCursorHandle cef_cursor_handle_t
+#define CefEventHandle cef_event_handle_t
+#define CefWindowHandle cef_window_handle_t
+#define CefTextInputContext cef_text_input_context_t
+
+struct CefMainArgsTraits {
+  typedef cef_main_args_t struct_type;
+
+  static inline void init(struct_type* s) {}
+  static inline void clear(struct_type* s) {}
+
+  static inline void set(const struct_type* src, struct_type* target,
+      bool copy) {
+    target->instance = src->instance;
+  }
+};
+
+// Class representing CefExecuteProcess arguments.
+class CefMainArgs : public CefStructBase<CefMainArgsTraits> {
+ public:
+  typedef CefStructBase<CefMainArgsTraits> parent;
+
+  CefMainArgs() : parent() {}
+  explicit CefMainArgs(const cef_main_args_t& r) : parent(r) {}
+  explicit CefMainArgs(const CefMainArgs& r) : parent(r) {}
+  explicit CefMainArgs(HINSTANCE hInstance) : parent() {
+    instance = hInstance;
+  }
+};
+
+struct CefWindowInfoTraits {
+  typedef cef_window_info_t struct_type;
+
+  static inline void init(struct_type* s) {}
+
+  static inline void clear(struct_type* s) {
+    cef_string_clear(&s->window_name);
+  }
+
+  static inline void set(const struct_type* src, struct_type* target,
+      bool copy) {
+    target->ex_style = src->ex_style;
+    cef_string_set(src->window_name.str, src->window_name.length,
+        &target->window_name, copy);
+    target->style = src->style;
+    target->x = src->x;
+    target->y = src->y;
+    target->width = src->width;
+    target->height = src->height;
+    target->parent_window = src->parent_window;
+    target->menu = src->menu;
+    target->transparent_painting_enabled = src->transparent_painting_enabled;
+    target->windowless_rendering_enabled = src->windowless_rendering_enabled;
+    target->window = src->window;
+  }
+};
+
+///
+// Class representing window information.
+///
+class CefWindowInfo : public CefStructBase<CefWindowInfoTraits> {
+ public:
+  typedef CefStructBase<CefWindowInfoTraits> parent;
+
+  CefWindowInfo() : parent() {}
+  explicit CefWindowInfo(const cef_window_info_t& r) : parent(r) {}
+  explicit CefWindowInfo(const CefWindowInfo& r) : parent(r) {}
+
+  ///
+  // Create the browser as a child window.
+  ///
+  void SetAsChild(CefWindowHandle parent, RECT windowRect) {
+    style = WS_CHILD | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | WS_TABSTOP |
+            WS_VISIBLE;
+    parent_window = parent;
+    x = windowRect.left;
+    y = windowRect.top;
+    width = windowRect.right - windowRect.left;
+    height = windowRect.bottom - windowRect.top;
+  }
+
+  ///
+  // Create the browser as a popup window.
+  ///
+  void SetAsPopup(CefWindowHandle parent, const CefString& windowName) {
+    style = WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS |
+            WS_VISIBLE;
+    parent_window = parent;
+    x = CW_USEDEFAULT;
+    y = CW_USEDEFAULT;
+    width = CW_USEDEFAULT;
+    height = CW_USEDEFAULT;
+
+    cef_string_copy(windowName.c_str(), windowName.length(), &window_name);
+  }
+
+  ///
+  // Create the browser using windowless (off-screen) rendering. No window
+  // will be created for the browser and all rendering will occur via the
+  // CefRenderHandler interface. The |parent| value will be used to identify
+  // monitor info and to act as the parent window for dialogs, context menus,
+  // etc. If |parent| is not provided then the main screen monitor will be used
+  // and some functionality that requires a parent window may not function
+  // correctly. If |transparent| is true a transparent background color will be
+  // used (RGBA=0x00000000). If |transparent| is false the background will be
+  // white and opaque. In order to create windowless browsers the
+  // CefSettings.windowless_rendering_enabled value must be set to true.
+  ///
+  void SetAsWindowless(CefWindowHandle parent, bool transparent) {
+    windowless_rendering_enabled = TRUE;
+    parent_window = parent;
+    transparent_painting_enabled = transparent;
+  }
+};
+
+#endif  // CEF_INCLUDE_INTERNAL_CEF_WIN_H_
diff --git a/src/include/libcef/views/cef_box_layout.h b/src/include/libcef/views/cef_box_layout.h
new file mode 100644
index 0000000..3cf7a55
--- /dev/null
+++ b/src/include/libcef/views/cef_box_layout.h
@@ -0,0 +1,74 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_VIEWS_CEF_BOX_LAYOUT_H_
+#define CEF_INCLUDE_VIEWS_CEF_BOX_LAYOUT_H_
+#pragma once
+
+#include "include/views/cef_layout.h"
+
+class CefView;
+
+///
+// A Layout manager that arranges child views vertically or horizontally in a
+// side-by-side fashion with spacing around and between the child views. The
+// child views are always sized according to their preferred size. If the
+// host's bounds provide insufficient space, child views will be clamped.
+// Excess space will not be distributed. Methods must be called on the browser
+// process UI thread unless otherwise indicated.
+///
+/*--cef(source=library)--*/
+class CefBoxLayout : public CefLayout {
+ public:
+  ///
+  // Set the flex weight for the given |view|. Using the preferred size as
+  // the basis, free space along the main axis is distributed to views in the
+  // ratio of their flex weights. Similarly, if the views will overflow the
+  // parent, space is subtracted in these ratios. A flex of 0 means this view is
+  // not resized. Flex values must not be negative.
+  ///
+  /*--cef()--*/
+  virtual void SetFlexForView(CefRefPtr<CefView> view, int flex) =0;
+
+  ///
+  // Clears the flex for the given |view|, causing it to use the default flex
+  // specified via CefBoxLayoutSettings.default_flex.
+  ///
+  /*--cef()--*/
+  virtual void ClearFlexForView(CefRefPtr<CefView> view) =0;
+};
+
+#endif  // CEF_INCLUDE_VIEWS_CEF_BOX_LAYOUT_H_
diff --git a/src/include/libcef/views/cef_browser_view.h b/src/include/libcef/views/cef_browser_view.h
new file mode 100644
index 0000000..2ae068d
--- /dev/null
+++ b/src/include/libcef/views/cef_browser_view.h
@@ -0,0 +1,79 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_VIEWS_CEF_BROWSER_VIEW_H_
+#define CEF_INCLUDE_VIEWS_CEF_BROWSER_VIEW_H_
+#pragma once
+
+#include "include/cef_browser.h"
+#include "include/views/cef_browser_view_delegate.h"
+#include "include/views/cef_view.h"
+
+///
+// A View hosting a CefBrowser instance. Methods must be called on the browser
+// process UI thread unless otherwise indicated.
+///
+/*--cef(source=library)--*/
+class CefBrowserView : public CefView {
+ public:
+  ///
+  // Create a new BrowserView. The underlying CefBrowser will not be created
+  // until this view is added to the views hierarchy.
+  ///
+  /*--cef(optional_param=client,optional_param=url,
+          optional_param=request_context,optional_param=delegate)--*/
+  static CefRefPtr<CefBrowserView> CreateBrowserView(
+      CefRefPtr<CefClient> client,
+      const CefString& url,
+      const CefBrowserSettings& settings,
+      CefRefPtr<CefRequestContext> request_context,
+      CefRefPtr<CefBrowserViewDelegate> delegate);
+
+  ///
+  // Returns the BrowserView associated with |browser|.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefBrowserView> GetForBrowser(CefRefPtr<CefBrowser> browser);
+
+  ///
+  // Returns the CefBrowser hosted by this BrowserView. Will return NULL if the
+  // browser has not yet been created or has already been destroyed.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefBrowser> GetBrowser() =0;
+};
+
+#endif  // CEF_INCLUDE_VIEWS_CEF_BROWSER_VIEW_H_
diff --git a/src/include/libcef/views/cef_browser_view_delegate.h b/src/include/libcef/views/cef_browser_view_delegate.h
new file mode 100644
index 0000000..93eea91
--- /dev/null
+++ b/src/include/libcef/views/cef_browser_view_delegate.h
@@ -0,0 +1,109 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_VIEWS_CEF_BROWSER_VIEW_DELEGATE_H_
+#define CEF_INCLUDE_VIEWS_CEF_BROWSER_VIEW_DELEGATE_H_
+#pragma once
+
+#include "include/cef_client.h"
+#include "include/views/cef_view_delegate.h"
+
+class CefBrowser;
+class CefBrowserView;
+
+///
+// Implement this interface to handle BrowserView events. The methods of this
+// class will be called on the browser process UI thread unless otherwise
+// indicated.
+///
+/*--cef(source=client)--*/
+class CefBrowserViewDelegate : public CefViewDelegate {
+ public:
+  ///
+  // Called when |browser| associated with |browser_view| is created. This
+  // method will be called after CefLifeSpanHandler::OnAfterCreated() is called
+  // for |browser| and before OnPopupBrowserViewCreated() is called for
+  // |browser|'s parent delegate if |browser| is a popup.
+  ///
+  /*--cef()--*/
+  virtual void OnBrowserCreated(CefRefPtr<CefBrowserView> browser_view,
+                                CefRefPtr<CefBrowser> browser) {}
+
+  ///
+  // Called when |browser| associated with |browser_view| is destroyed. Release
+  // all references to |browser| and do not attempt to execute any methods on
+  // |browser| after this callback returns. This method will be called before
+  // CefLifeSpanHandler::OnBeforeClose() is called for |browser|.
+  ///
+  /*--cef()--*/
+  virtual void OnBrowserDestroyed(CefRefPtr<CefBrowserView> browser_view,
+                                  CefRefPtr<CefBrowser> browser) {}
+
+  ///
+  // Called before a new popup BrowserView is created. The popup originated
+  // from |browser_view|. |settings| and |client| are the values returned from
+  // CefLifeSpanHandler::OnBeforePopup(). |is_devtools| will be true if the
+  // popup will be a DevTools browser. Return the delegate that will be used for
+  // the new popup BrowserView.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefBrowserViewDelegate> GetDelegateForPopupBrowserView(
+      CefRefPtr<CefBrowserView> browser_view,
+      const CefBrowserSettings& settings,
+      CefRefPtr<CefClient> client,
+      bool is_devtools) {
+    return this;
+  }
+
+  ///
+  // Called after |popup_browser_view| is created. This method will be called
+  // after CefLifeSpanHandler::OnAfterCreated() and OnBrowserCreated() are
+  // called for the new popup browser. The popup originated from |browser_view|.
+  // |is_devtools| will be true if the popup is a DevTools browser. Optionally
+  // add |popup_browser_view| to the views hierarchy yourself and return true.
+  // Otherwise return false and a default CefWindow will be created for the
+  // popup.
+  ///
+  /*--cef()--*/
+  virtual bool OnPopupBrowserViewCreated(
+      CefRefPtr<CefBrowserView> browser_view,
+      CefRefPtr<CefBrowserView> popup_browser_view,
+      bool is_devtools) {
+    return false;
+  }
+};
+
+#endif  // CEF_INCLUDE_VIEWS_CEF_BROWSER_VIEW_DELEGATE_H_
diff --git a/src/include/libcef/views/cef_button.h b/src/include/libcef/views/cef_button.h
new file mode 100644
index 0000000..2feda9a
--- /dev/null
+++ b/src/include/libcef/views/cef_button.h
@@ -0,0 +1,85 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_VIEWS_CEF_BUTTON_H_
+#define CEF_INCLUDE_VIEWS_CEF_BUTTON_H_
+#pragma once
+
+#include "include/views/cef_view.h"
+
+class CefLabelButton;
+
+///
+// A View representing a button. Depending on the specific type, the button
+// could be implemented by a native control or custom rendered. Methods must be
+// called on the browser process UI thread unless otherwise indicated.
+///
+/*--cef(source=library)--*/
+class CefButton : public CefView {
+ public:
+  ///
+  // Returns this Button as a LabelButton or NULL if this is not a LabelButton.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefLabelButton> AsLabelButton() =0;
+
+  ///
+  // Sets the current display state of the Button.
+  ///
+  /*--cef()--*/
+  virtual void SetState(cef_button_state_t state) =0;
+
+  ///
+  // Returns the current display state of the Button.
+  ///
+  /*--cef(default_retval=CEF_BUTTON_STATE_NORMAL)--*/
+  virtual cef_button_state_t GetState() =0;
+
+  ///
+  // Sets the tooltip text that will be displayed when the user hovers the mouse
+  // cursor over the Button.
+  ///
+  /*--cef()--*/
+  virtual void SetTooltipText(const CefString& tooltip_text) =0;
+
+  ///
+  // Sets the accessible name that will be exposed to assistive technology (AT).
+  ///
+  /*--cef()--*/
+  virtual void SetAccessibleName(const CefString& name) =0;
+};
+
+#endif  // CEF_INCLUDE_VIEWS_CEF_BUTTON_H_
diff --git a/src/include/libcef/views/cef_button_delegate.h b/src/include/libcef/views/cef_button_delegate.h
new file mode 100644
index 0000000..99bd126
--- /dev/null
+++ b/src/include/libcef/views/cef_button_delegate.h
@@ -0,0 +1,59 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_VIEWS_CEF_BUTTON_DELEGATE_H_
+#define CEF_INCLUDE_VIEWS_CEF_BUTTON_DELEGATE_H_
+#pragma once
+
+#include "include/views/cef_view_delegate.h"
+
+class CefButton;
+
+///
+// Implement this interface to handle Button events. The methods of this class
+// will be called on the browser process UI thread unless otherwise indicated.
+///
+/*--cef(source=client)--*/
+class CefButtonDelegate : public CefViewDelegate {
+ public:
+  ///
+  // Called when |button| is pressed.
+  ///
+  /*--cef()--*/
+  virtual void OnButtonPressed(CefRefPtr<CefButton> button) =0;
+};
+
+#endif  // CEF_INCLUDE_VIEWS_CEF_BUTTON_DELEGATE_H_
diff --git a/src/include/libcef/views/cef_display.h b/src/include/libcef/views/cef_display.h
new file mode 100644
index 0000000..d9da060
--- /dev/null
+++ b/src/include/libcef/views/cef_display.h
@@ -0,0 +1,144 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_VIEWS_CEF_DISPLAY_H_
+#define CEF_INCLUDE_VIEWS_CEF_DISPLAY_H_
+#pragma once
+
+#include <vector>
+
+#include "include/cef_base.h"
+
+///
+// This class typically, but not always, corresponds to a physical display
+// connected to the system. A fake Display may exist on a headless system, or a
+// Display may correspond to a remote, virtual display. All size and position
+// values are in density independent pixels (DIP) unless otherwise indicated.
+// Methods must be called on the browser process UI thread unless otherwise
+// indicated.
+///
+/*--cef(source=library)--*/
+class CefDisplay : public CefBase {
+ public:
+  ///
+  // Returns the primary Display.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefDisplay> GetPrimaryDisplay();
+
+  ///
+  // Returns the Display nearest |point|. Set |input_pixel_coords| to true if
+  // |point| is in pixel coordinates instead of density independent pixels
+  // (DIP).
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefDisplay> GetDisplayNearestPoint(const CefPoint& point,
+                                                      bool input_pixel_coords);
+
+  ///
+  // Returns the Display that most closely intersects |bounds|.  Set
+  // |input_pixel_coords| to true if |bounds| is in pixel coordinates instead of
+  // density independent pixels (DIP).
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefDisplay> GetDisplayMatchingBounds(
+      const CefRect& bounds,
+      bool input_pixel_coords);
+
+  ///
+  // Returns the total number of Displays. Mirrored displays are excluded; this
+  // method is intended to return the number of distinct, usable displays.
+  ///
+  /*--cef()--*/
+  static size_t GetDisplayCount();
+
+  ///
+  // Returns all Displays. Mirrored displays are excluded; this method is
+  // intended to return distinct, usable displays.
+  ///
+  /*--cef(count_func=displays:GetDisplayCount)--*/
+  static void GetAllDisplays(std::vector<CefRefPtr<CefDisplay> >& displays);
+
+  ///
+  // Returns the unique identifier for this Display.
+  ///
+  /*--cef()--*/
+  virtual int64 GetID() =0;
+
+  ///
+  // Returns this Display's device pixel scale factor. This specifies how much
+  // the UI should be scaled when the actual output has more pixels than
+  // standard displays (which is around 100~120dpi). The potential return values
+  // differ by platform.
+  ///
+  /*--cef()--*/
+  virtual float GetDeviceScaleFactor() =0;
+
+  ///
+  // Convert |point| from density independent pixels (DIP) to pixel coordinates
+  // using this Display's device scale factor.
+  ///
+  /*--cef()--*/
+  virtual void ConvertPointToPixels(CefPoint& point) =0;
+
+  ///
+  // Convert |point| from pixel coordinates to density independent pixels (DIP)
+  // using this Display's device scale factor.
+  ///
+  /*--cef()--*/
+  virtual void ConvertPointFromPixels(CefPoint& point) =0;
+
+  ///
+  // Returns this Display's bounds. This is the full size of the display.
+  ///
+  /*--cef()--*/
+  virtual CefRect GetBounds() =0;
+
+  ///
+  // Returns this Display's work area. This excludes areas of the display that
+  // are occupied for window manager toolbars, etc.
+  ///
+  /*--cef()--*/
+  virtual CefRect GetWorkArea() =0;
+
+  ///
+  // Returns this Display's rotation in degrees.
+  ///
+  /*--cef()--*/
+  virtual int GetRotation() =0;
+};
+
+#endif  // CEF_INCLUDE_VIEWS_CEF_DISPLAY_H_
diff --git a/src/include/libcef/views/cef_fill_layout.h b/src/include/libcef/views/cef_fill_layout.h
new file mode 100644
index 0000000..470fefc
--- /dev/null
+++ b/src/include/libcef/views/cef_fill_layout.h
@@ -0,0 +1,52 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_VIEWS_CEF_FILL_LAYOUT_H_
+#define CEF_INCLUDE_VIEWS_CEF_FILL_LAYOUT_H_
+#pragma once
+
+#include "include/views/cef_layout.h"
+
+///
+// A simple Layout that causes the associated Panel's one child to be sized to
+// match the bounds of its parent. Methods must be called on the browser process
+// UI thread unless otherwise indicated.
+///
+/*--cef(source=library)--*/
+class CefFillLayout : public CefLayout {
+};
+
+#endif  // CEF_INCLUDE_VIEWS_CEF_FILL_LAYOUT_H_
diff --git a/src/include/libcef/views/cef_label_button.h b/src/include/libcef/views/cef_label_button.h
new file mode 100644
index 0000000..1447b98
--- /dev/null
+++ b/src/include/libcef/views/cef_label_button.h
@@ -0,0 +1,152 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_VIEWS_CEF_LABEL_BUTTON_H_
+#define CEF_INCLUDE_VIEWS_CEF_LABEL_BUTTON_H_
+#pragma once
+
+#include "include/cef_image.h"
+#include "include/views/cef_button.h"
+#include "include/views/cef_button_delegate.h"
+
+class CefMenuButton;
+
+///
+// LabelButton is a button with optional text and/or icon. Methods must be
+// called on the browser process UI thread unless otherwise indicated.
+///
+/*--cef(source=library)--*/
+class CefLabelButton : public CefButton {
+ public:
+  ///
+  // Create a new LabelButton. A |delegate| must be provided to handle the
+  // button click. |text| will be shown on the LabelButton and used as the
+  // default accessible name. If |with_frame| is true the button will have a
+  // visible frame at all times, center alignment, additional padding and a
+  // default minimum size of 70x33 DIP. If |with_frame| is false the button will
+  // only have a visible frame on hover/press, left alignment, less padding and
+  // no default minimum size.
+  ///
+  /*--cef(optional_param=text)--*/
+  static CefRefPtr<CefLabelButton> CreateLabelButton(
+      CefRefPtr<CefButtonDelegate> delegate,
+      const CefString& text,
+      bool with_frame);
+
+  ///
+  // Returns this LabelButton as a MenuButton or NULL if this is not a
+  // MenuButton.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefMenuButton> AsMenuButton() =0;
+
+  ///
+  // Sets the text shown on the LabelButton. By default |text| will also be used
+  // as the accessible name.
+  ///
+  /*--cef()--*/
+  virtual void SetText(const CefString& text) =0;
+
+  ///
+  // Returns the text shown on the LabelButton.
+  ///
+  /*--cef()--*/
+  virtual CefString GetText() =0;
+
+  ///
+  // Sets the image shown for |button_state|. When this Button is drawn if no
+  // image exists for the current state then the image for
+  // CEF_BUTTON_STATE_NORMAL, if any, will be shown.
+  ///
+  /*--cef(optional_param=image)--*/
+  virtual void SetImage(cef_button_state_t button_state,
+                        CefRefPtr<CefImage> image) =0;
+
+  ///
+  // Returns the image shown for |button_state|. If no image exists for that
+  // state then the image for CEF_BUTTON_STATE_NORMAL will be returned.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefImage> GetImage(cef_button_state_t button_state) =0;
+
+  ///
+  // Sets the text color shown for the specified button |for_state| to |color|.
+  ///
+  /*--cef()--*/
+  virtual void SetTextColor(cef_button_state_t for_state, cef_color_t color) =0;
+
+  ///
+  // Sets the text colors shown for the non-disabled states to |color|.
+  ///
+  /*--cef()--*/
+  virtual void SetEnabledTextColors(cef_color_t color) =0;
+
+  ///
+  // Sets the font list. The format is "<FONT_FAMILY_LIST>,[STYLES] <SIZE>",
+  // where:
+  // - FONT_FAMILY_LIST is a comma-separated list of font family names,
+  // - STYLES is an optional space-separated list of style names (case-sensitive
+  //   "Bold" and "Italic" are supported), and
+  // - SIZE is an integer font size in pixels with the suffix "px".
+  //
+  // Here are examples of valid font description strings:
+  // - "Arial, Helvetica, Bold Italic 14px"
+  // - "Arial, 14px"
+  ///
+  /*--cef()--*/
+  virtual void SetFontList(const CefString& font_list) =0;
+
+  ///
+  // Sets the horizontal alignment; reversed in RTL. Default is
+  // CEF_HORIZONTAL_ALIGNMENT_CENTER.
+  ///
+  /*--cef()--*/
+  virtual void SetHorizontalAlignment(cef_horizontal_alignment_t alignment) =0;
+
+  ///
+  // Reset the minimum size of this LabelButton to |size|.
+  ///
+  /*--cef()--*/
+  virtual void SetMinimumSize(const CefSize& size) =0;
+
+  ///
+  // Reset the maximum size of this LabelButton to |size|.
+  ///
+  /*--cef()--*/
+  virtual void SetMaximumSize(const CefSize& size) =0;
+};
+
+#endif  // CEF_INCLUDE_VIEWS_CEF_LABEL_BUTTON_H_
diff --git a/src/include/libcef/views/cef_layout.h b/src/include/libcef/views/cef_layout.h
new file mode 100644
index 0000000..d820a27
--- /dev/null
+++ b/src/include/libcef/views/cef_layout.h
@@ -0,0 +1,73 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_VIEWS_CEF_LAYOUT_H_
+#define CEF_INCLUDE_VIEWS_CEF_LAYOUT_H_
+#pragma once
+
+#include "include/cef_base.h"
+
+class CefBoxLayout;
+class CefFillLayout;
+
+///
+// A Layout handles the sizing of the children of a Panel according to
+// implementation-specific heuristics. Methods must be called on the browser
+// process UI thread unless otherwise indicated.
+///
+/*--cef(source=library)--*/
+class CefLayout : public CefBase {
+ public:
+  ///
+  // Returns this Layout as a BoxLayout or NULL if this is not a BoxLayout.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefBoxLayout> AsBoxLayout() =0;
+
+  ///
+  // Returns this Layout as a FillLayout or NULL if this is not a FillLayout.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefFillLayout> AsFillLayout() =0;
+
+  ///
+  // Returns true if this Layout is valid.
+  ///
+  /*--cef()--*/
+  virtual bool IsValid() =0;
+};
+
+#endif  // CEF_INCLUDE_VIEWS_CEF_LAYOUT_H_
diff --git a/src/include/libcef/views/cef_menu_button.h b/src/include/libcef/views/cef_menu_button.h
new file mode 100644
index 0000000..4ae8c4f
--- /dev/null
+++ b/src/include/libcef/views/cef_menu_button.h
@@ -0,0 +1,83 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_VIEWS_CEF_MENU_BUTTON_H_
+#define CEF_INCLUDE_VIEWS_CEF_MENU_BUTTON_H_
+#pragma once
+
+#include "include/cef_menu_model.h"
+#include "include/views/cef_label_button.h"
+#include "include/views/cef_menu_button_delegate.h"
+
+///
+// MenuButton is a button with optional text, icon and/or menu marker that shows
+// a menu when clicked with the left mouse button. All size and position values
+// are in density independent pixels (DIP) unless otherwise indicated. Methods
+// must be called on the browser process UI thread unless otherwise indicated.
+///
+/*--cef(source=library)--*/
+class CefMenuButton : public CefLabelButton {
+ public:
+  ///
+  // Create a new MenuButton. A |delegate| must be provided to call ShowMenu()
+  // when the button is clicked. |text| will be shown on the MenuButton and used
+  // as the default accessible name. If |with_frame| is true the button will
+  // have a visible frame at all times, center alignment, additional padding and
+  // a default minimum size of 70x33 DIP. If |with_frame| is false the button
+  // will only have a visible frame on hover/press, left alignment, less padding
+  // and no default minimum size. If |with_menu_marker| is true a menu marker
+  // will be added to the button.
+  ///
+  /*--cef(optional_param=text)--*/
+  static CefRefPtr<CefMenuButton> CreateMenuButton(
+      CefRefPtr<CefMenuButtonDelegate> delegate,
+      const CefString& text,
+      bool with_frame,
+      bool with_menu_marker);
+
+  ///
+  // Show a menu with contents |menu_model|. |screen_point| specifies the menu
+  // position in screen coordinates. |anchor_position| specifies how the menu
+  // will be anchored relative to |screen_point|. This method should be called
+  // from CefMenuButtonDelegate::OnMenuButtonPressed().
+  ///
+  /*--cef()--*/
+  virtual void ShowMenu(CefRefPtr<CefMenuModel> menu_model,
+                        const CefPoint& screen_point,
+                        cef_menu_anchor_position_t anchor_position) =0;
+};
+
+#endif  // CEF_INCLUDE_VIEWS_CEF_MENU_BUTTON_H_
diff --git a/src/include/libcef/views/cef_menu_button_delegate.h b/src/include/libcef/views/cef_menu_button_delegate.h
new file mode 100644
index 0000000..43bce7e
--- /dev/null
+++ b/src/include/libcef/views/cef_menu_button_delegate.h
@@ -0,0 +1,62 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_VIEWS_CEF_MENU_BUTTON_DELEGATE_H_
+#define CEF_INCLUDE_VIEWS_CEF_MENU_BUTTON_DELEGATE_H_
+#pragma once
+
+#include "include/views/cef_button_delegate.h"
+
+class CefMenuButton;
+
+///
+// Implement this interface to handle MenuButton events. The methods of this
+// class will be called on the browser process UI thread unless otherwise
+// indicated.
+///
+/*--cef(source=client)--*/
+class CefMenuButtonDelegate : public CefButtonDelegate {
+ public:
+  ///
+  // Called when |button| is pressed. Call CefMenuButton::ShowMenu() to show the
+  // resulting menu at |screen_point|.
+  ///
+  /*--cef()--*/
+  virtual void OnMenuButtonPressed(CefRefPtr<CefMenuButton> menu_button,
+                                   const CefPoint& screen_point) =0;
+};
+
+#endif  // CEF_INCLUDE_VIEWS_CEF_MENU_BUTTON_DELEGATE_H_
diff --git a/src/include/libcef/views/cef_panel.h b/src/include/libcef/views/cef_panel.h
new file mode 100644
index 0000000..2c5a2b1
--- /dev/null
+++ b/src/include/libcef/views/cef_panel.h
@@ -0,0 +1,143 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_VIEWS_CEF_PANEL_H_
+#define CEF_INCLUDE_VIEWS_CEF_PANEL_H_
+#pragma once
+
+#include "include/views/cef_view.h"
+#include "include/views/cef_panel_delegate.h"
+
+class CefBoxLayout;
+class CefFillLayout;
+class CefLayout;
+class CefWindow;
+
+///
+// A Panel is a container in the views hierarchy that can contain other Views
+// as children. Methods must be called on the browser process UI thread unless
+// otherwise indicated.
+///
+/*--cef(source=library)--*/
+class CefPanel : public CefView {
+ public:
+  ///
+  // Create a new Panel.
+  ///
+  /*--cef(optional_param=delegate)--*/
+  static CefRefPtr<CefPanel> CreatePanel(CefRefPtr<CefPanelDelegate> delegate);
+
+  ///
+  // Returns this Panel as a Window or NULL if this is not a Window.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefWindow> AsWindow() =0;
+
+  ///
+  // Set this Panel's Layout to FillLayout and return the FillLayout object.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefFillLayout> SetToFillLayout() =0;
+
+  ///
+  // Set this Panel's Layout to BoxLayout and return the BoxLayout object.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefBoxLayout> SetToBoxLayout(
+      const CefBoxLayoutSettings& settings) =0;
+
+  ///
+  // Get the Layout.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefLayout> GetLayout() =0;
+
+  ///
+  // Lay out the child Views (set their bounds based on sizing heuristics
+  // specific to the current Layout).
+  ///
+  /*--cef()--*/
+  virtual void Layout() =0;
+
+  ///
+  // Add a child View.
+  ///
+  /*--cef()--*/
+  virtual void AddChildView(CefRefPtr<CefView> view) =0;
+
+  ///
+  // Add a child View at the specified |index|. If |index| matches the result of
+  // GetChildCount() then the View will be added at the end.
+  ///
+  /*--cef(index_param=index)--*/
+  virtual void AddChildViewAt(CefRefPtr<CefView> view,
+                              int index) =0;
+
+  ///
+  // Move the child View to the specified |index|. A negative value for |index|
+  // will move the View to the end.
+  ///
+  /*--cef()--*/
+  virtual void ReorderChildView(CefRefPtr<CefView> view,
+                                int index) =0;
+
+  ///
+  // Remove a child View. The View can then be added to another Panel.
+  ///
+  /*--cef()--*/
+  virtual void RemoveChildView(CefRefPtr<CefView> view) =0;
+
+  ///
+  // Remove all child Views. The removed Views will be deleted if the client
+  // holds no references to them.
+  ///
+  /*--cef()--*/
+  virtual void RemoveAllChildViews() =0;
+
+  ///
+  // Returns the number of child Views.
+  ///
+  /*--cef()--*/
+  virtual size_t GetChildViewCount() =0;
+
+  ///
+  // Returns the child View at the specified |index|.
+  ///
+  /*--cef(index_param=index)--*/
+  virtual CefRefPtr<CefView> GetChildViewAt(int index) =0;
+};
+
+#endif  // CEF_INCLUDE_VIEWS_CEF_PANEL_H_
diff --git a/src/include/libcef/views/cef_panel_delegate.h b/src/include/libcef/views/cef_panel_delegate.h
new file mode 100644
index 0000000..099a5e6
--- /dev/null
+++ b/src/include/libcef/views/cef_panel_delegate.h
@@ -0,0 +1,51 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_VIEWS_CEF_PANEL_DELEGATE_H_
+#define CEF_INCLUDE_VIEWS_CEF_PANEL_DELEGATE_H_
+#pragma once
+
+#include "include/views/cef_view_delegate.h"
+
+///
+// Implement this interface to handle Panel events. The methods of this class
+// will be called on the browser process UI thread unless otherwise indicated.
+///
+/*--cef(source=client)--*/
+class CefPanelDelegate : public CefViewDelegate {
+};
+
+#endif  // CEF_INCLUDE_VIEWS_CEF_PANEL_DELEGATE_H_
diff --git a/src/include/libcef/views/cef_scroll_view.h b/src/include/libcef/views/cef_scroll_view.h
new file mode 100644
index 0000000..65378d8
--- /dev/null
+++ b/src/include/libcef/views/cef_scroll_view.h
@@ -0,0 +1,102 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_VIEWS_CEF_SCROLL_VIEW_H_
+#define CEF_INCLUDE_VIEWS_CEF_SCROLL_VIEW_H_
+#pragma once
+
+#include "include/views/cef_view.h"
+
+///
+// A ScrollView will show horizontal and/or vertical scrollbars when necessary
+// based on the size of the attached content view. Methods must be called on the
+// browser process UI thread unless otherwise indicated.
+///
+/*--cef(source=library)--*/
+class CefScrollView : public CefView {
+ public:
+  ///
+  // Create a new ScrollView.
+  ///
+  /*--cef(optional_param=delegate)--*/
+  static CefRefPtr<CefScrollView> CreateScrollView(
+      CefRefPtr<CefViewDelegate> delegate);
+
+  ///
+  // Set the content View. The content View must have a specified size (e.g.
+  // via CefView::SetBounds or CefViewDelegate::GetPreferredSize).
+  ///
+  /*--cef()--*/
+  virtual void SetContentView(CefRefPtr<CefView> view) =0;
+
+  ///
+  // Returns the content View.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefView> GetContentView() =0;
+
+  ///
+  // Returns the visible region of the content View.
+  ///
+  /*--cef()--*/
+  virtual CefRect GetVisibleContentRect() =0;
+
+  ///
+  // Returns true if the horizontal scrollbar is currently showing.
+  ///
+  /*--cef()--*/
+  virtual bool HasHorizontalScrollbar() =0;
+
+  ///
+  // Returns the height of the horizontal scrollbar.
+  ///
+  /*--cef()--*/
+  virtual int GetHorizontalScrollbarHeight() =0;
+
+  ///
+  // Returns true if the vertical scrollbar is currently showing.
+  ///
+  /*--cef()--*/
+  virtual bool HasVerticalScrollbar() =0;
+
+  ///
+  // Returns the width of the vertical scrollbar.
+  ///
+  /*--cef()--*/
+  virtual int GetVerticalScrollbarWidth() =0;
+};
+
+#endif  // CEF_INCLUDE_VIEWS_CEF_SCROLL_VIEW_H_
diff --git a/src/include/libcef/views/cef_textfield.h b/src/include/libcef/views/cef_textfield.h
new file mode 100644
index 0000000..fadd89d
--- /dev/null
+++ b/src/include/libcef/views/cef_textfield.h
@@ -0,0 +1,278 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_VIEWS_CEF_TEXTFIELD_H_
+#define CEF_INCLUDE_VIEWS_CEF_TEXTFIELD_H_
+#pragma once
+
+#include "include/views/cef_view.h"
+#include "include/views/cef_textfield_delegate.h"
+
+///
+// A Textfield supports editing of text. This control is custom rendered with no
+// platform-specific code. Methods must be called on the browser process UI
+// thread unless otherwise indicated.
+///
+/*--cef(source=library)--*/
+class CefTextfield : public CefView {
+ public:
+  ///
+  // Create a new Textfield.
+  ///
+  /*--cef(optional_param=delegate)--*/
+  static CefRefPtr<CefTextfield> CreateTextfield(
+      CefRefPtr<CefTextfieldDelegate> delegate);
+
+  ///
+  // Sets whether the text will be displayed as asterisks.
+  ///
+  /*--cef()--*/
+  virtual void SetPasswordInput(bool password_input) =0;
+
+  ///
+  // Returns true if the text will be displayed as asterisks.
+  ///
+  /*--cef()--*/
+  virtual bool IsPasswordInput() =0;
+
+  ///
+  // Sets whether the text will read-only.
+  ///
+  /*--cef()--*/
+  virtual void SetReadOnly(bool read_only) =0;
+
+  ///
+  // Returns true if the text is read-only.
+  ///
+  /*--cef()--*/
+  virtual bool IsReadOnly() =0;
+
+  ///
+  // Returns the currently displayed text.
+  ///
+  /*--cef()--*/
+  virtual CefString GetText() =0;
+
+  ///
+  // Sets the contents to |text|. The cursor will be moved to end of the text if
+  // the current position is outside of the text range.
+  ///
+  /*--cef()--*/
+  virtual void SetText(const CefString& text) =0;
+
+  ///
+  // Appends |text| to the previously-existing text.
+  ///
+  /*--cef()--*/
+  virtual void AppendText(const CefString& text) =0;
+
+  ///
+  // Inserts |text| at the current cursor position replacing any selected text.
+  ///
+  /*--cef()--*/
+  virtual void InsertOrReplaceText(const CefString& text) =0;
+
+  ///
+  // Returns true if there is any selected text.
+  ///
+  /*--cef()--*/
+  virtual bool HasSelection() =0;
+
+  ///
+  // Returns the currently selected text.
+  ///
+  /*--cef()--*/
+  virtual CefString GetSelectedText() =0;
+
+  ///
+  // Selects all text. If |reversed| is true the range will end at the logical
+  // beginning of the text; this generally shows the leading portion of text
+  // that overflows its display area.
+  ///
+  /*--cef()--*/
+  virtual void SelectAll(bool reversed) =0;
+  
+  ///
+  // Clears the text selection and sets the caret to the end.
+  ///
+  /*--cef()--*/
+  virtual void ClearSelection() =0;
+
+  ///
+  // Returns the selected logical text range.
+  ///
+  /*--cef()--*/
+  virtual CefRange GetSelectedRange() =0;
+  
+  ///
+  // Selects the specified logical text range.
+  ///
+  /*--cef()--*/
+  virtual void SelectRange(const CefRange& range) =0;
+  
+  ///
+  // Returns the current cursor position.
+  ///
+  /*--cef()--*/
+  virtual size_t GetCursorPosition() =0;
+
+  ///
+  // Sets the text color.
+  ///
+  /*--cef()--*/
+  virtual void SetTextColor(cef_color_t color) =0;
+
+  ///
+  // Returns the text color.
+  ///
+  /*--cef()--*/
+  virtual cef_color_t GetTextColor() =0;
+
+  ///
+  // Sets the selection text color.
+  ///
+  /*--cef()--*/
+  virtual void SetSelectionTextColor(cef_color_t color) =0;
+
+  ///
+  // Returns the selection text color.
+  ///
+  /*--cef()--*/
+  virtual cef_color_t GetSelectionTextColor() =0;
+
+  ///
+  // Sets the selection background color.
+  ///
+  /*--cef()--*/
+  virtual void SetSelectionBackgroundColor(cef_color_t color) =0;
+
+  ///
+  // Returns the selection background color.
+  ///
+  /*--cef()--*/
+  virtual cef_color_t GetSelectionBackgroundColor() =0;
+
+  ///
+  // Sets the font list. The format is "<FONT_FAMILY_LIST>,[STYLES] <SIZE>",
+  // where:
+  // - FONT_FAMILY_LIST is a comma-separated list of font family names,
+  // - STYLES is an optional space-separated list of style names (case-sensitive
+  //   "Bold" and "Italic" are supported), and
+  // - SIZE is an integer font size in pixels with the suffix "px".
+  //
+  // Here are examples of valid font description strings:
+  // - "Arial, Helvetica, Bold Italic 14px"
+  // - "Arial, 14px"
+  ///
+  /*--cef()--*/
+  virtual void SetFontList(const CefString& font_list) =0;
+
+  ///
+  // Applies |color| to the specified |range| without changing the default
+  // color. If |range| is empty the color will be set on the complete text
+  // contents.
+  ///
+  /*--cef()--*/
+  virtual void ApplyTextColor(cef_color_t color,
+                              const CefRange& range) =0;
+
+  ///
+  // Applies |style| to the specified |range| without changing the default
+  // style. If |add| is true the style will be added, otherwise the style will
+  // be removed. If |range| is empty the style will be set on the complete text
+  // contents.
+  ///
+  /*--cef()--*/
+  virtual void ApplyTextStyle(cef_text_style_t style,
+                              bool add,
+                              const CefRange& range) =0;
+
+  ///
+  // Returns true if the action associated with the specified command id is
+  // enabled. See additional comments on ExecuteCommand().
+  ///
+  /*--cef()--*/
+  virtual bool IsCommandEnabled(int command_id) =0;
+
+  ///
+  // Performs the action associated with the specified command id. Valid values
+  // include IDS_APP_UNDO, IDS_APP_REDO, IDS_APP_CUT, IDS_APP_COPY,
+  // IDS_APP_PASTE, IDS_APP_DELETE, IDS_APP_SELECT_ALL, IDS_DELETE_* and
+  // IDS_MOVE_*. See include/cef_pack_strings.h for definitions.
+  ///
+  /*--cef()--*/
+  virtual void ExecuteCommand(int command_id) =0;
+  
+  ///
+  // Clears Edit history.
+  ///
+  /*--cef()--*/
+  virtual void ClearEditHistory() =0;
+
+  ///
+  // Sets the placeholder text that will be displayed when the Textfield is
+  // empty.
+  ///
+  /*--cef()--*/
+  virtual void SetPlaceholderText(const CefString& text) =0;
+
+  ///
+  // Returns the placeholder text that will be displayed when the Textfield is
+  // empty.
+  ///
+  /*--cef()--*/
+  virtual CefString GetPlaceholderText() =0;
+
+  ///
+  // Sets the placeholder text color.
+  ///
+  /*--cef()--*/
+  virtual void SetPlaceholderTextColor(cef_color_t color) =0;
+
+  ///
+  // Returns the placeholder text color.
+  ///
+  /*--cef()--*/
+  virtual cef_color_t GetPlaceholderTextColor() =0;
+
+  ///
+  // Set the accessible name that will be exposed to assistive technology (AT).
+  ///
+  /*--cef()--*/
+  virtual void SetAccessibleName(const CefString& name) =0;
+};
+
+#endif  // CEF_INCLUDE_VIEWS_CEF_TEXTFIELD_H_
diff --git a/src/include/libcef/views/cef_textfield_delegate.h b/src/include/libcef/views/cef_textfield_delegate.h
new file mode 100644
index 0000000..ed3f607
--- /dev/null
+++ b/src/include/libcef/views/cef_textfield_delegate.h
@@ -0,0 +1,69 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_VIEWS_CEF_TEXTFIELD_DELEGATE_H_
+#define CEF_INCLUDE_VIEWS_CEF_TEXTFIELD_DELEGATE_H_
+#pragma once
+
+#include "include/views/cef_view_delegate.h"
+
+class CefTextfield;
+
+///
+// Implement this interface to handle Textfield events. The methods of this
+// class will be called on the browser process UI thread unless otherwise
+// indicated.
+///
+/*--cef(source=client)--*/
+class CefTextfieldDelegate : public CefViewDelegate {
+ public:
+  ///
+  // Called when |textfield| recieves a keyboard event. |event| contains
+  // information about the keyboard event. Return true if the keyboard event was
+  // handled or false otherwise for default handling.
+  ///
+  /*--cef()--*/
+  virtual bool OnKeyEvent(CefRefPtr<CefTextfield> textfield,
+                          const CefKeyEvent& event) { return false; }
+
+  ///
+  // Called after performing a user action that may change |textfield|.
+  ///
+  /*--cef()--*/
+  virtual void OnAfterUserAction(CefRefPtr<CefTextfield> textfield) {}
+};
+
+#endif  // CEF_INCLUDE_VIEWS_CEF_TEXTFIELD_DELEGATE_H_
diff --git a/src/include/libcef/views/cef_view.h b/src/include/libcef/views/cef_view.h
new file mode 100644
index 0000000..b6f321e
--- /dev/null
+++ b/src/include/libcef/views/cef_view.h
@@ -0,0 +1,388 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_VIEWS_CEF_VIEW_H_
+#define CEF_INCLUDE_VIEWS_CEF_VIEW_H_
+#pragma once
+
+#include "include/views/cef_view_delegate.h"
+
+class CefBrowserView;
+class CefButton;
+class CefPanel;
+class CefScrollView;
+class CefTextfield;
+class CefWindow;
+
+///
+// A View is a rectangle within the views View hierarchy. It is the base class
+// for all Views. All size and position values are in density independent pixels
+// (DIP) unless otherwise indicated. Methods must be called on the browser
+// process UI thread unless otherwise indicated.
+///
+/*--cef(source=library)--*/
+class CefView : public CefBase {
+ public:
+  ///
+  // Returns this View as a BrowserView or NULL if this is not a BrowserView.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefBrowserView> AsBrowserView() =0;
+
+  ///
+  // Returns this View as a Button or NULL if this is not a Button.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefButton> AsButton() =0;
+
+  ///
+  // Returns this View as a Panel or NULL if this is not a Panel.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefPanel> AsPanel() =0;
+
+  ///
+  // Returns this View as a ScrollView or NULL if this is not a ScrollView.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefScrollView> AsScrollView() =0;
+
+  ///
+  // Returns this View as a Textfield or NULL if this is not a Textfield.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefTextfield> AsTextfield() =0;
+
+  ///
+  // Returns the type of this View as a string. Used primarily for testing
+  // purposes.
+  ///
+  /*--cef()--*/
+  virtual CefString GetTypeString() =0;
+
+  ///
+  // Returns a string representation of this View which includes the type and
+  // various type-specific identifying attributes. If |include_children| is true
+  // any child Views will also be included. Used primarily for testing purposes.
+  ///
+  /*--cef()--*/
+  virtual CefString ToString(bool include_children) =0;
+
+  ///
+  // Returns true if this View is valid.
+  ///
+  /*--cef()--*/
+  virtual bool IsValid() =0;
+
+  ///
+  // Returns true if this View is currently attached to another View. A View can
+  // only be attached to one View at a time.
+  ///
+  /*--cef()--*/
+  virtual bool IsAttached() =0;
+
+  ///
+  // Returns true if this View is the same as |that| View.
+  ///
+  /*--cef()--*/
+  virtual bool IsSame(CefRefPtr<CefView> that) =0;
+
+  ///
+  // Returns the delegate associated with this View, if any.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefViewDelegate> GetDelegate() =0;
+
+  ///
+  // Returns the top-level Window hosting this View, if any.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefWindow> GetWindow() =0;
+
+  ///
+  // Returns the ID for this View.
+  ///
+  /*--cef()--*/
+  virtual int GetID() =0;
+
+  ///
+  // Sets the ID for this View. ID should be unique within the subtree that you
+  // intend to search for it. 0 is the default ID for views.
+  ///
+  /*--cef()--*/
+  virtual void SetID(int id) =0;
+
+  ///
+  // Returns the View that contains this View, if any.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefView> GetParentView() =0;
+
+  ///
+  // Recursively descends the view tree starting at this View, and returns the
+  // first child that it encounters with the given ID. Returns NULL if no
+  // matching child view is found.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefView> GetViewForID(int id) =0;
+
+  ///
+  // Sets the bounds (size and position) of this View. Position is in parent
+  // coordinates.
+  ///
+  /*--cef()--*/
+  virtual void SetBounds(const CefRect& bounds) =0;
+
+  ///
+  // Returns the bounds (size and position) of this View. Position is in parent
+  // coordinates.
+  ///
+  /*--cef()--*/
+  virtual CefRect GetBounds() =0;
+
+  ///
+  // Returns the bounds (size and position) of this View. Position is in screen
+  // coordinates.
+  ///
+  /*--cef()--*/
+  virtual CefRect GetBoundsInScreen() =0;
+
+  ///
+  // Sets the size of this View without changing the position.
+  ///
+  /*--cef()--*/
+  virtual void SetSize(const CefSize& size) =0;
+
+  ///
+  // Returns the size of this View.
+  ///
+  /*--cef()--*/
+  virtual CefSize GetSize() =0;
+
+  ///
+  // Sets the position of this View without changing the size. |position| is in
+  // parent coordinates.
+  ///
+  /*--cef()--*/
+  virtual void SetPosition(const CefPoint& position) =0;
+
+  ///
+  // Returns the position of this View. Position is in parent coordinates.
+  ///
+  /*--cef()--*/
+  virtual CefPoint GetPosition() =0;
+
+  ///
+  // Returns the size this View would like to be if enough space is available.
+  ///
+  /*--cef()--*/
+  virtual CefSize GetPreferredSize() =0;
+
+  ///
+  // Size this View to its preferred size.
+  ///
+  /*--cef()--*/
+  virtual void SizeToPreferredSize() =0;
+
+  ///
+  // Returns the minimum size for this View.
+  ///
+  /*--cef()--*/
+  virtual CefSize GetMinimumSize() =0;
+
+  ///
+  // Returns the maximum size for this View.
+  ///
+  /*--cef()--*/
+  virtual CefSize GetMaximumSize() =0;
+
+  ///
+  // Returns the height necessary to display this View with the provided width.
+  ///
+  /*--cef()--*/
+  virtual int GetHeightForWidth(int width) =0;
+
+  ///
+  // Indicate that this View and all parent Views require a re-layout. This
+  // ensures the next call to Layout() will propagate to this View even if the
+  // bounds of parent Views do not change.
+  ///
+  /*--cef()--*/
+  virtual void InvalidateLayout() =0;
+
+  ///
+  // Sets whether this View is visible. Windows are hidden by default and other
+  // views are visible by default. This View and any parent views must be set as
+  // visible for this View to be drawn in a Window. If this View is set as
+  // hidden then it and any child views will not be drawn and, if any of those
+  // views currently have focus, then focus will also be cleared. Painting is
+  // scheduled as needed. If this View is a Window then calling this method is
+  // equivalent to calling the Window Show() and Hide() methods.
+  ///
+  /*--cef()--*/
+  virtual void SetVisible(bool visible) =0;
+
+  ///
+  // Returns whether this View is visible. A view may be visible but still not
+  // drawn in a Window if any parent views are hidden. If this View is a Window
+  // then a return value of true indicates that this Window is currently visible
+  // to the user on-screen. If this View is not a Window then call IsDrawn() to
+  // determine whether this View and all parent views are visible and will be
+  // drawn.
+  ///
+  /*--cef()--*/
+  virtual bool IsVisible() =0;
+
+  ///
+  // Returns whether this View is visible and drawn in a Window. A view is drawn
+  // if it and all parent views are visible. If this View is a Window then
+  // calling this method is equivalent to calling IsVisible(). Otherwise, to
+  // determine if the containing Window is visible to the user on-screen call
+  // IsVisible() on the Window.
+  ///
+  /*--cef()--*/
+  virtual bool IsDrawn() =0;
+
+  ///
+  // Set whether this View is enabled. A disabled View does not receive keyboard
+  // or mouse inputs. If |enabled| differs from the current value the View will
+  // be repainted. Also, clears focus if the focused View is disabled.
+  ///
+  /*--cef()--*/
+  virtual void SetEnabled(bool enabled) =0;
+
+  ///
+  // Returns whether this View is enabled.
+  ///
+  /*--cef()--*/
+  virtual bool IsEnabled() =0;
+
+  ///
+  // Sets whether this View is capable of taking focus. It will clear focus if
+  // the focused View is set to be non-focusable. This is false by default so
+  // that a View used as a container does not get the focus.
+  ///
+  /*--cef()--*/
+  virtual void SetFocusable(bool focusable) =0;
+
+  ///
+  // Returns true if this View is focusable, enabled and drawn.
+  ///
+  /*--cef()--*/
+  virtual bool IsFocusable() =0;
+
+  ///
+  // Return whether this View is focusable when the user requires full keyboard
+  // access, even though it may not be normally focusable.
+  ///
+  /*--cef()--*/
+  virtual bool IsAccessibilityFocusable() =0;
+
+  ///
+  // Request keyboard focus. If this View is focusable it will become the
+  // focused View.
+  ///
+  /*--cef()--*/
+  virtual void RequestFocus() =0;
+
+  ///
+  // Sets the background color for this View.
+  ///
+  /*--cef()--*/
+  virtual void SetBackgroundColor(cef_color_t color) =0;
+
+  ///
+  // Returns the background color for this View.
+  ///
+  /*--cef()--*/
+  virtual cef_color_t GetBackgroundColor() =0;
+
+  ///
+  // Convert |point| from this View's coordinate system to that of the screen.
+  // This View must belong to a Window when calling this method. Returns true
+  // if the conversion is successful or false otherwise. Use
+  // CefDisplay::ConvertPointToPixels() after calling this method if further
+  // conversion to display-specific pixel coordinates is desired.
+  ///
+  /*--cef()--*/
+  virtual bool ConvertPointToScreen(CefPoint& point) =0;
+
+  ///
+  // Convert |point| to this View's coordinate system from that of the screen.
+  // This View must belong to a Window when calling this method. Returns true if
+  // the conversion is successful or false otherwise. Use
+  // CefDisplay::ConvertPointFromPixels() before calling this method if
+  // conversion from display-specific pixel coordinates is necessary.
+  ///
+  /*--cef()--*/
+  virtual bool ConvertPointFromScreen(CefPoint& point) =0;
+
+  ///
+  // Convert |point| from this View's coordinate system to that of the Window.
+  // This View must belong to a Window when calling this method. Returns true if
+  // the conversion is successful or false otherwise.
+  ///
+  /*--cef()--*/
+  virtual bool ConvertPointToWindow(CefPoint& point) =0;
+
+  ///
+  // Convert |point| to this View's coordinate system from that of the Window.
+  // This View must belong to a Window when calling this method. Returns true if
+  // the conversion is successful or false otherwise.
+  ///
+  /*--cef()--*/
+  virtual bool ConvertPointFromWindow(CefPoint& point) =0;
+
+  ///
+  // Convert |point| from this View's coordinate system to that of |view|.
+  // |view| needs to be in the same Window but not necessarily the same view
+  // hierarchy. Returns true if the conversion is successful or false otherwise.
+  ///
+  /*--cef()--*/
+  virtual bool ConvertPointToView(CefRefPtr<CefView> view,
+                                  CefPoint& point) =0;
+
+  ///
+  // Convert |point| to this View's coordinate system from that |view|. |view|
+  // needs to be in the same Window but not necessarily the same view hierarchy.
+  // Returns true if the conversion is successful or false otherwise.
+  ///
+  /*--cef()--*/
+  virtual bool ConvertPointFromView(CefRefPtr<CefView> view,
+                                    CefPoint& point) =0;
+};
+
+#endif  // CEF_INCLUDE_VIEWS_CEF_VIEW_H_
diff --git a/src/include/libcef/views/cef_view_delegate.h b/src/include/libcef/views/cef_view_delegate.h
new file mode 100644
index 0000000..70fd176
--- /dev/null
+++ b/src/include/libcef/views/cef_view_delegate.h
@@ -0,0 +1,113 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_VIEWS_CEF_VIEW_DELEGATE_H_
+#define CEF_INCLUDE_VIEWS_CEF_VIEW_DELEGATE_H_
+#pragma once
+
+#include "include/cef_base.h"
+
+class CefView;
+
+///
+// Implement this interface to handle view events. The methods of this class
+// will be called on the browser process UI thread unless otherwise indicated.
+///
+/*--cef(source=client)--*/
+class CefViewDelegate : public virtual CefBase {
+ public:
+  ///
+  // Return the preferred size for |view|. The Layout will use this information
+  // to determine the display size.
+  ///
+  /*--cef()--*/
+  virtual CefSize GetPreferredSize(CefRefPtr<CefView> view) {
+    return CefSize();
+  }
+
+  ///
+  // Return the minimum size for |view|.
+  ///
+  /*--cef()--*/
+  virtual CefSize GetMinimumSize(CefRefPtr<CefView> view) {
+    return CefSize();
+  }
+
+  ///
+  // Return the maximum size for |view|.
+  ///
+  /*--cef()--*/
+  virtual CefSize GetMaximumSize(CefRefPtr<CefView> view) {
+    return CefSize();
+  }
+
+  ///
+  // Return the height necessary to display |view| with the provided |width|.
+  // If not specified the result of GetPreferredSize().height will be used by
+  // default. Override if |view|'s preferred height depends upon the width
+  // (for example, with Labels).
+  ///
+  /*--cef()--*/
+  virtual int GetHeightForWidth(CefRefPtr<CefView> view, int width) {
+    return 0;
+  }
+
+  ///
+  // Called when the parent of |view| has changed. If |view| is being added to
+  // |parent| then |added| will be true. If |view| is being removed from
+  // |parent| then |added| will be false. If |view| is being reparented the
+  // remove notification will be sent before the add notification. Do not modify
+  // the view hierarchy in this callback.
+  ///
+  /*--cef()--*/
+  virtual void OnParentViewChanged(CefRefPtr<CefView> view,
+                                   bool added,
+                                   CefRefPtr<CefView> parent) {}
+
+  ///
+  // Called when a child of |view| has changed. If |child| is being added to
+  // |view| then |added| will be true. If |child| is being removed from |view|
+  // then |added| will be false. If |child| is being reparented the remove
+  // notification will be sent to the old parent before the add notification is
+  // sent to the new parent. Do not modify the view hierarchy in this callback.
+  ///
+  /*--cef()--*/
+  virtual void OnChildViewChanged(CefRefPtr<CefView> view,
+                                  bool added,
+                                  CefRefPtr<CefView> child) {}
+};
+
+#endif  // CEF_INCLUDE_VIEWS_CEF_WINDOW_DELEGATE_H_
diff --git a/src/include/libcef/views/cef_window.h b/src/include/libcef/views/cef_window.h
new file mode 100644
index 0000000..b6ec638
--- /dev/null
+++ b/src/include/libcef/views/cef_window.h
@@ -0,0 +1,294 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_VIEWS_CEF_WINDOW_H_
+#define CEF_INCLUDE_VIEWS_CEF_WINDOW_H_
+#pragma once
+
+#include "include/cef_image.h"
+#include "include/cef_menu_model.h"
+#include "include/views/cef_display.h"
+#include "include/views/cef_panel.h"
+#include "include/views/cef_window_delegate.h"
+
+///
+// A Window is a top-level Window/widget in the Views hierarchy. By default it
+// will have a non-client area with title bar, icon and buttons that supports
+// moving and resizing. All size and position values are in density independent
+// pixels (DIP) unless otherwise indicated. Methods must be called on the
+// browser process UI thread unless otherwise indicated.
+///
+/*--cef(source=library)--*/
+class CefWindow : public CefPanel {
+ public:
+  ///
+  // Create a new Window.
+  ///
+  /*--cef(optional_param=delegate)--*/
+  static CefRefPtr<CefWindow> CreateTopLevelWindow(
+      CefRefPtr<CefWindowDelegate> delegate);
+
+  ///
+  // Show the Window.
+  ///
+  /*--cef()--*/
+  virtual void Show() =0;
+
+  ///
+  // Hide the Window.
+  ///
+  /*--cef()--*/
+  virtual void Hide() =0;
+
+  ///
+  // Sizes the Window to |size| and centers it in the current display.
+  ///
+  /*--cef()--*/
+  virtual void CenterWindow(const CefSize& size) =0;
+
+  ///
+  // Close the Window.
+  ///
+  /*--cef()--*/
+  virtual void Close() =0;
+
+  ///
+  // Returns true if the Window has been closed.
+  ///
+  /*--cef()--*/
+  virtual bool IsClosed() =0;
+
+  ///
+  // Activate the Window, assuming it already exists and is visible.
+  ///
+  /*--cef()--*/
+  virtual void Activate() =0;
+
+  ///
+  // Deactivate the Window, making the next Window in the Z order the active
+  // Window.
+  ///
+  /*--cef()--*/
+  virtual void Deactivate() =0;
+
+  ///
+  // Returns whether the Window is the currently active Window.
+  ///
+  /*--cef()--*/
+  virtual bool IsActive() =0;
+
+  ///
+  // Bring this Window to the top of other Windows in the Windowing system.
+  ///
+  /*--cef()--*/
+  virtual void BringToTop() =0;
+
+  ///
+  // Set the Window to be on top of other Windows in the Windowing system.
+  ///
+  /*--cef()--*/
+  virtual void SetAlwaysOnTop(bool on_top) =0;
+
+  ///
+  // Returns whether the Window has been set to be on top of other Windows in
+  // the Windowing system.
+  ///
+  /*--cef()--*/
+  virtual bool IsAlwaysOnTop() =0;
+
+  ///
+  // Maximize the Window.
+  ///
+  /*--cef()--*/
+  virtual void Maximize() =0;
+
+  ///
+  // Minimize the Window.
+  ///
+  /*--cef()--*/
+  virtual void Minimize() =0;
+
+  ///
+  // Restore the Window.
+  ///
+  /*--cef()--*/
+  virtual void Restore() =0;
+
+  ///
+  // Set fullscreen Window state.
+  ///
+  /*--cef()--*/
+  virtual void SetFullscreen(bool fullscreen) =0;
+  
+  ///
+  // Returns true if the Window is maximized.
+  ///
+  /*--cef()--*/
+  virtual bool IsMaximized() =0;
+
+  ///
+  // Returns true if the Window is minimized.
+  ///
+  /*--cef()--*/
+  virtual bool IsMinimized() =0;
+
+  ///
+  // Returns true if the Window is fullscreen.
+  ///
+  /*--cef()--*/
+  virtual bool IsFullscreen() =0;
+
+  ///
+  // Set the Window title.
+  ///
+  /*--cef(optional_param=title)--*/
+  virtual void SetTitle(const CefString& title) =0;
+
+  ///
+  // Get the Window title.
+  ///
+  /*--cef()--*/
+  virtual CefString GetTitle() =0;
+
+  ///
+  // Set the Window icon. This should be a 16x16 icon suitable for use in the
+  // Windows's title bar.
+  ///
+  /*--cef()--*/
+  virtual void SetWindowIcon(CefRefPtr<CefImage> image) =0;
+
+  ///
+  // Get the Window icon.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefImage> GetWindowIcon() =0;
+
+  ///
+  // Set the Window App icon. This should be a larger icon for use in the host
+  // environment app switching UI. On Windows, this is the ICON_BIG used in
+  // Alt-Tab list and Windows taskbar. The Window icon will be used by default
+  // if no Window App icon is specified.
+  ///
+  /*--cef()--*/
+  virtual void SetWindowAppIcon(CefRefPtr<CefImage> image) =0;
+
+  ///
+  // Get the Window App icon.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefImage> GetWindowAppIcon() =0;
+
+  ///
+  // Show a menu with contents |menu_model|. |screen_point| specifies the menu
+  // position in screen coordinates. |anchor_position| specifies how the menu
+  // will be anchored relative to |screen_point|.
+  ///
+  /*--cef()--*/
+  virtual void ShowMenu(CefRefPtr<CefMenuModel> menu_model,
+                        const CefPoint& screen_point,
+                        cef_menu_anchor_position_t anchor_position) =0;
+
+  ///
+  // Cancel the menu that is currently showing, if any.
+  ///
+  /*--cef()--*/
+  virtual void CancelMenu() =0;
+
+  ///
+  // Returns the Display that most closely intersects the bounds of this Window.
+  // May return NULL if this Window is not currently displayed.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefDisplay> GetDisplay() =0;
+
+  ///
+  // Returns the bounds (size and position) of this Window's client area.
+  // Position is in screen coordinates.
+  ///
+  /*--cef()--*/
+  virtual CefRect GetClientAreaBoundsInScreen() =0;
+
+  ///
+  // Set the regions where mouse events will be intercepted by this Window to
+  // support drag operations. Call this method with an empty vector to clear the
+  // draggable regions. The draggable region bounds should be in window
+  // coordinates.
+  ///
+  /*--cef(optional_param=regions)--*/
+  virtual void SetDraggableRegions(
+      const std::vector<CefDraggableRegion>& regions) =0;
+
+  ///
+  // Retrieve the platform window handle for this Window.
+  ///
+  /*--cef()--*/
+  virtual CefWindowHandle GetWindowHandle() =0;
+
+  ///
+  // Simulate a key press. |key_code| is the VKEY_* value from Chromium's
+  // ui/events/keycodes/keyboard_codes.h header (VK_* values on Windows).
+  // |event_flags| is some combination of EVENTFLAG_SHIFT_DOWN,
+  // EVENTFLAG_CONTROL_DOWN and/or EVENTFLAG_ALT_DOWN. This method is exposed
+  // primarily for testing purposes.
+  ///
+  /*--cef()--*/
+  virtual void SendKeyPress(int key_code,
+                            uint32 event_flags) =0;
+
+  ///
+  // Simulate a mouse move. The mouse cursor will be moved to the specified
+  // (screen_x, screen_y) position. This method is exposed primarily for testing
+  // purposes.
+  ///
+  /*--cef()--*/
+  virtual void SendMouseMove(int screen_x, int screen_y) =0;
+
+  ///
+  // Simulate mouse down and/or mouse up events. |button| is the mouse button
+  // type. If |mouse_down| is true a mouse down event will be sent. If
+  // |mouse_up| is true a mouse up event will be sent. If both are true a mouse
+  // down event will be sent followed by a mouse up event (equivalent to
+  // clicking the mouse button). The events will be sent using the current
+  // cursor position so make sure to call SendMouseMove() first to position the
+  // mouse. This method is exposed primarily for testing purposes.
+  ///
+  /*--cef()--*/
+  virtual void SendMouseEvents(cef_mouse_button_type_t button,
+                               bool mouse_down,
+                               bool mouse_up) =0;
+};
+
+#endif  // CEF_INCLUDE_VIEWS_CEF_WINDOW_H_
diff --git a/src/include/libcef/views/cef_window_delegate.h b/src/include/libcef/views/cef_window_delegate.h
new file mode 100644
index 0000000..19deae7
--- /dev/null
+++ b/src/include/libcef/views/cef_window_delegate.h
@@ -0,0 +1,100 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_VIEWS_CEF_WINDOW_DELEGATE_H_
+#define CEF_INCLUDE_VIEWS_CEF_WINDOW_DELEGATE_H_
+#pragma once
+
+#include "include/views/cef_panel_delegate.h"
+
+class CefWindow;
+
+///
+// Implement this interface to handle window events. The methods of this class
+// will be called on the browser process UI thread unless otherwise indicated.
+///
+/*--cef(source=client)--*/
+class CefWindowDelegate : public CefPanelDelegate {
+ public:
+  ///
+  // Called when |window| is created.
+  ///
+  /*--cef()--*/
+  virtual void OnWindowCreated(CefRefPtr<CefWindow> window) {}
+
+  ///
+  // Called when |window| is destroyed. Release all references to |window| and
+  // do not attempt to execute any methods on |window| after this callback
+  // returns.
+  ///
+  /*--cef()--*/
+  virtual void OnWindowDestroyed(CefRefPtr<CefWindow> window) {}
+
+  ///
+  // Return true if |window| should be created without a frame or title bar. The
+  // window will be resizable if CanResize() returns true. Use
+  // CefWindow::SetDraggableRegions() to specify draggable regions.
+  ///
+  /*--cef()--*/
+  virtual bool IsFrameless(CefRefPtr<CefWindow> window) { return false; }
+
+  ///
+  // Return true if |window| can be resized.
+  ///
+  /*--cef()--*/
+  virtual bool CanResize(CefRefPtr<CefWindow> window) { return true; }
+
+  ///
+  // Return true if |window| can be maximized.
+  ///
+  /*--cef()--*/
+  virtual bool CanMaximize(CefRefPtr<CefWindow> window) { return true; }
+
+  ///
+  // Return true if |window| can be minimized.
+  ///
+  /*--cef()--*/
+  virtual bool CanMinimize(CefRefPtr<CefWindow> window) { return true; }
+
+  ///
+  // Return true if |window| can be closed. This will be called for user-
+  // initiated window close actions and when CefWindow::Close() is called.
+  ///
+  /*--cef()--*/
+  virtual bool CanClose(CefRefPtr<CefWindow> window) { return true; }
+};
+
+#endif  // CEF_INCLUDE_VIEWS_CEF_WINDOW_DELEGATE_H_
diff --git a/src/include/libcef/wrapper/cef_byte_read_handler.h b/src/include/libcef/wrapper/cef_byte_read_handler.h
new file mode 100644
index 0000000..559cdd8
--- /dev/null
+++ b/src/include/libcef/wrapper/cef_byte_read_handler.h
@@ -0,0 +1,79 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file are only available to applications that link
+// against the libcef_dll_wrapper target.
+//
+
+#ifndef CEF_INCLUDE_WRAPPER_CEF_BYTE_READ_HANDLER_H_
+#define CEF_INCLUDE_WRAPPER_CEF_BYTE_READ_HANDLER_H_
+#pragma once
+
+#include "include/base/cef_lock.h"
+#include "include/base/cef_macros.h"
+#include "include/cef_base.h"
+#include "include/cef_stream.h"
+
+///
+// Thread safe implementation of the CefReadHandler class for reading an
+// in-memory array of bytes.
+///
+class CefByteReadHandler : public CefReadHandler {
+ public:
+  ///
+  // Create a new object for reading an array of bytes. An optional |source|
+  // reference can be kept to keep the underlying data source from being
+  // released while the reader exists.
+  ///
+  CefByteReadHandler(const unsigned char* bytes,
+                     size_t size,
+                     CefRefPtr<CefBase> source);
+
+  // CefReadHandler methods.
+  virtual size_t Read(void* ptr, size_t size, size_t n) OVERRIDE;
+  virtual int Seek(int64 offset, int whence) OVERRIDE;
+  virtual int64 Tell() OVERRIDE;
+  virtual int Eof() OVERRIDE;
+  virtual bool MayBlock() OVERRIDE { return false; }
+
+ private:
+  const unsigned char* bytes_;
+  int64 size_;
+  int64 offset_;
+  CefRefPtr<CefBase> source_;
+
+  base::Lock lock_;
+
+  IMPLEMENT_REFCOUNTING(CefByteReadHandler);
+  DISALLOW_COPY_AND_ASSIGN(CefByteReadHandler);
+};
+
+#endif  // CEF_INCLUDE_WRAPPER_CEF_BYTE_READ_HANDLER_H_
diff --git a/src/include/libcef/wrapper/cef_closure_task.h b/src/include/libcef/wrapper/cef_closure_task.h
new file mode 100644
index 0000000..8828c65
--- /dev/null
+++ b/src/include/libcef/wrapper/cef_closure_task.h
@@ -0,0 +1,101 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file are only available to applications that link
+// against the libcef_dll_wrapper target.
+//
+
+#ifndef CEF_INCLUDE_WRAPPER_CEF_CLOSURE_TASK_H_
+#define CEF_INCLUDE_WRAPPER_CEF_CLOSURE_TASK_H_
+#pragma once
+
+#include "include/base/cef_callback_forward.h"
+#include "include/base/cef_macros.h"
+#include "include/cef_task.h"
+
+///
+// Helpers for asynchronously executing a base::Closure (bound function or
+// method) on a CEF thread. Creation of base::Closures can be facilitated using
+// base::Bind. See include/base/cef_callback.h for complete usage instructions.
+//
+// TO use these helpers you should include this header and the header that
+// defines base::Bind.
+//
+// #include "include/base/cef_bind.h"
+// #include "include/wrapper/cef_closure_task.h"
+//
+// Example of executing a bound function:
+//
+// // Define a function.
+// void MyFunc(int arg) { /* do something with |arg| on the UI thread */ }
+//
+// // Post a task that will execute MyFunc on the UI thread and pass an |arg|
+// // value of 5.
+// CefPostTask(TID_UI, base::Bind(&MyFunc, 5));
+//
+// Example of executing a bound method:
+//
+// // Define a class.
+// class MyClass : public CefBase {
+//  public:
+//   MyClass() {}
+//   void MyMethod(int arg) { /* do something with |arg| on the UI thread */ }
+//  private:
+//   IMPLEMENT_REFCOUNTING(MyClass);
+// };
+//
+// // Create an instance of MyClass.
+// CefRefPtr<MyClass> instance = new MyClass();
+//
+// // Post a task that will execute MyClass::MyMethod on the UI thread and pass
+// // an |arg| value of 5. |instance| will be kept alive until after the task
+// // completes.
+// CefPostTask(TID_UI, base::Bind(&MyClass::MyMethod, instance, 5));
+///
+
+///
+// Create a CefTask that wraps a base::Closure. Can be used in combination with
+// CefTaskRunner.
+///
+CefRefPtr<CefTask> CefCreateClosureTask(const base::Closure& closure);
+
+///
+// Post a Closure for execution on the specified thread.
+///
+bool CefPostTask(CefThreadId threadId, const base::Closure& closure);
+
+///
+// Post a Closure for delayed execution on the specified thread.
+///
+bool CefPostDelayedTask(CefThreadId threadId, const base::Closure& closure,
+                        int64 delay_ms);
+
+#endif  // CEF_INCLUDE_WRAPPER_CEF_CLOSURE_TASK_H_
diff --git a/src/include/libcef/wrapper/cef_helpers.h b/src/include/libcef/wrapper/cef_helpers.h
new file mode 100644
index 0000000..639cde8
--- /dev/null
+++ b/src/include/libcef/wrapper/cef_helpers.h
@@ -0,0 +1,124 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file are only available to applications that link
+// against the libcef_dll_wrapper target.
+//
+
+#ifndef CEF_INCLUDE_WRAPPER_CEF_HELPERS_H_
+#define CEF_INCLUDE_WRAPPER_CEF_HELPERS_H_
+#pragma once
+
+#include <cstring>
+#include <string>
+#include <vector>
+
+#include "include/base/cef_bind.h"
+#include "include/base/cef_logging.h"
+#include "include/base/cef_macros.h"
+#include "include/cef_task.h"
+
+#define CEF_REQUIRE_UI_THREAD()       DCHECK(CefCurrentlyOn(TID_UI));
+#define CEF_REQUIRE_IO_THREAD()       DCHECK(CefCurrentlyOn(TID_IO));
+#define CEF_REQUIRE_FILE_THREAD()     DCHECK(CefCurrentlyOn(TID_FILE));
+#define CEF_REQUIRE_RENDERER_THREAD() DCHECK(CefCurrentlyOn(TID_RENDERER));
+
+
+// Use this struct in conjuction with refcounted types to ensure that an
+// object is deleted on the specified thread. For example:
+//
+// class Foo : public base::RefCountedThreadSafe<Foo, CefDeleteOnUIThread> {
+//  public:
+//   Foo();
+//   void DoSomething();
+//
+//  private:
+//   // Allow deletion via scoped_refptr only.
+//   friend struct CefDeleteOnThread<TID_UI>;
+//   friend class base::RefCountedThreadSafe<Foo, CefDeleteOnUIThread>;
+//
+//   virtual ~Foo() {}
+// };
+//
+// base::scoped_refptr<Foo> foo = new Foo();
+// foo->DoSomething();
+// foo = NULL;  // Deletion of |foo| will occur on the UI thread.
+//
+template<CefThreadId thread>
+struct CefDeleteOnThread {
+  template<typename T>
+  static void Destruct(const T* x) {
+    if (CefCurrentlyOn(thread)) {
+      delete x;
+    } else {
+      CefPostTask(thread,
+                  base::Bind(&CefDeleteOnThread<thread>::Destruct<T>, x));
+    }
+  }
+};
+
+struct CefDeleteOnUIThread : public CefDeleteOnThread<TID_UI> { };
+struct CefDeleteOnIOThread : public CefDeleteOnThread<TID_IO> { };
+struct CefDeleteOnFileThread : public CefDeleteOnThread<TID_FILE> { };
+struct CefDeleteOnRendererThread : public CefDeleteOnThread<TID_RENDERER> { };
+
+
+///
+// Helper class to manage a scoped copy of |argv|.
+///
+class CefScopedArgArray {
+ public:
+  CefScopedArgArray(int argc, char* argv[]) {
+    // argv should have (argc + 1) elements, the last one always being NULL.
+    array_ = new char*[argc + 1];
+    for (int i = 0; i < argc; ++i) {
+      values_.push_back(argv[i]);
+      array_[i] = const_cast<char*>(values_[i].c_str());
+    }
+    array_[argc] = NULL;
+  }
+  ~CefScopedArgArray() {
+    delete [] array_;
+  }
+
+  char** array() const { return array_; }
+
+ private:
+  char** array_;
+
+  // Keep values in a vector separate from |array_| because various users may
+  // modify |array_| and we still want to clean up memory properly.
+  std::vector<std::string> values_;
+  
+  DISALLOW_COPY_AND_ASSIGN(CefScopedArgArray);
+};
+
+#endif  // CEF_INCLUDE_WRAPPER_CEF_HELPERS_H_
diff --git a/src/include/libcef/wrapper/cef_message_router.h b/src/include/libcef/wrapper/cef_message_router.h
new file mode 100644
index 0000000..2a6fcfe
--- /dev/null
+++ b/src/include/libcef/wrapper/cef_message_router.h
@@ -0,0 +1,428 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file are only available to applications that link
+// against the libcef_dll_wrapper target.
+//
+
+#ifndef CEF_INCLUDE_WRAPPER_CEF_MESSAGE_ROUTER_H_
+#define CEF_INCLUDE_WRAPPER_CEF_MESSAGE_ROUTER_H_
+#pragma once
+
+#include "include/base/cef_ref_counted.h"
+#include "include/cef_base.h"
+#include "include/cef_browser.h"
+#include "include/cef_process_message.h"
+#include "include/cef_v8.h"
+
+// The below classes implement support for routing aynchronous messages between
+// JavaScript running in the renderer process and C++ running in the browser
+// process. An application interacts with the router by passing it data from
+// standard CEF C++ callbacks (OnBeforeBrowse, OnProcessMessageRecieved,
+// OnContextCreated, etc). The renderer-side router supports generic JavaScript
+// callback registration and execution while the browser-side router supports
+// application-specific logic via one or more application-provided Handler
+// instances.
+//
+// The renderer-side router implementation exposes a query function and a cancel
+// function via the JavaScript 'window' object:
+//
+//    // Create and send a new query.
+//    var request_id = window.cefQuery({
+//        request: 'my_request',
+//        persistent: false,
+//        onSuccess: function(response) {},
+//        onFailure: function(error_code, error_message) {}
+//    });
+//
+//    // Optionally cancel the query.
+//    window.cefQueryCancel(request_id);
+//
+// When |window.cefQuery| is executed the request is sent asynchronously to one
+// or more C++ Handler objects registered in the browser process. Each C++
+// Handler can choose to either handle or ignore the query in the
+// Handler::OnQuery callback. If a Handler chooses to handle the query then it
+// should execute Callback::Success when a response is available or
+// Callback::Failure if an error occurs. This will result in asynchronous
+// execution of the associated JavaScript callback in the renderer process. Any
+// queries unhandled by C++ code in the browser process will be automatically
+// canceled and the associated JavaScript onFailure callback will be executed
+// with an error code of -1.
+//
+// Queries can be either persistent or non-persistent. If the query is
+// persistent than the callbacks will remain registered until one of the
+// following conditions are met:
+//
+// A. The query is canceled in JavaScript using the |window.cefQueryCancel|
+//    function.
+// B. The query is canceled in C++ code using the Callback::Failure function.
+// C. The context associated with the query is released due to browser
+//    destruction, navigation or renderer process termination.
+//
+// If the query is non-persistent then the registration will be removed after
+// the JavaScript callback is executed a single time. If a query is canceled for
+// a reason other than Callback::Failure being executed then the associated
+// Handler's OnQueryCanceled method will be called.
+//
+// Some possible usage patterns include:
+//
+// One-time Request. Use a non-persistent query to send a JavaScript request.
+//    The Handler evaluates the request and returns the response. The query is
+//    then discarded.
+//
+// Broadcast. Use a persistent query to register as a JavaScript broadcast
+//    receiver. The Handler keeps track of all registered Callbacks and executes
+//    them sequentially to deliver the broadcast message.
+//
+// Subscription. Use a persistent query to register as a JavaScript subscription
+//    receiver. The Handler initiates the subscription feed on the first request
+//    and delivers responses to all registered subscribers as they become
+//    available. The Handler cancels the subscription feed when there are no
+//    longer any registered JavaScript receivers.
+//
+// Message routing occurs on a per-browser and per-context basis. Consequently,
+// additional application logic can be applied by restricting which browser or
+// context instances are passed into the router. If you choose to use this
+// approach do so cautiously. In order for the router to function correctly any
+// browser or context instance passed into a single router callback must then
+// be passed into all router callbacks.
+//
+// There is generally no need to have multiple renderer-side routers unless you
+// wish to have multiple bindings with different JavaScript function names. It
+// can be useful to have multiple browser-side routers with different client-
+// provided Handler instances when implementing different behaviors on a per-
+// browser basis.
+//
+// This implementation places no formatting restrictions on payload content.
+// An application may choose to exchange anything from simple formatted
+// strings to serialized XML or JSON data.
+//
+//
+// EXAMPLE USAGE
+//
+// 1. Define the router configuration. You can optionally specify settings
+//    like the JavaScript function names. The configuration must be the same in
+//    both the browser and renderer processes. If using multiple routers in the
+//    same application make sure to specify unique function names for each
+//    router configuration.
+//
+//    // Example config object showing the default values.
+//    CefMessageRouterConfig config;
+//    config.js_query_function = "cefQuery";
+//    config.js_cancel_function = "cefQueryCancel";
+//
+// 2. Create an instance of CefMessageRouterBrowserSide in the browser process.
+//    You might choose to make it a member of your CefClient implementation,
+//    for example.
+//
+//    browser_side_router_ = CefMessageRouterBrowserSide::Create(config);
+//
+// 3. Register one or more Handlers. The Handler instances must either outlive
+//    the router or be removed from the router before they're deleted.
+//
+//    browser_side_router_->AddHandler(my_handler);
+//
+// 4. Call all required CefMessageRouterBrowserSide methods from other callbacks
+//    in your CefClient implementation (OnBeforeClose, etc). See the
+//    CefMessageRouterBrowserSide class documentation for the complete list of
+//    methods.
+//
+// 5. Create an instance of CefMessageRouterRendererSide in the renderer process.
+//    You might choose to make it a member of your CefApp implementation, for
+//    example.
+//
+//    renderer_side_router_ = CefMessageRouterRendererSide::Create(config);
+//
+// 6. Call all required CefMessageRouterRendererSide methods from other
+//    callbacks in your CefRenderProcessHandler implementation
+//    (OnContextCreated, etc). See the CefMessageRouterRendererSide class
+//    documentation for the complete list of methods.
+//
+// 7. Execute the query function from JavaScript code.
+//
+//    window.cefQuery({request: 'my_request',
+//                     persistent: false,
+//                     onSuccess: function(response) { print(response); },
+//                     onFailure: function(error_code, error_message) {} });
+//
+// 8. Handle the query in your Handler::OnQuery implementation and execute the
+//    appropriate callback either immediately or asynchronously.
+//
+//    void MyHandler::OnQuery(int64 query_id,
+//                            CefRefPtr<CefBrowser> browser,
+//                            CefRefPtr<CefFrame> frame,
+//                            const CefString& request,
+//                            bool persistent,
+//                            CefRefPtr<Callback> callback) {
+//      if (request == "my_request") {
+//        callback->Continue("my_response");
+//        return true;
+//      }
+//      return false;  // Not handled.
+//    }
+//
+// 9. Notice that the onSuccess callback is executed in JavaScript.
+
+///
+// Used to configure the query router. The same values must be passed to both
+// CefMessageRouterBrowserSide and CefMessageRouterRendererSide. If using multiple
+// router pairs make sure to choose values that do not conflict.
+///
+struct CefMessageRouterConfig {
+  CefMessageRouterConfig();
+
+  // Name of the JavaScript function that will be added to the 'window' object
+  // for sending a query. The default value is "cefQuery".
+  CefString js_query_function;
+
+  // Name of the JavaScript function that will be added to the 'window' object
+  // for canceling a pending query. The default value is "cefQueryCancel".
+  CefString js_cancel_function;
+};
+
+///
+// Implements the browser side of query routing. The methods of this class may
+// be called on any browser process thread unless otherwise indicated.
+///
+class CefMessageRouterBrowserSide :
+    public base::RefCountedThreadSafe<CefMessageRouterBrowserSide> {
+ public:
+  ///
+  // Callback associated with a single pending asynchronous query. Execute the
+  // Success or Failure method to send an asynchronous response to the
+  // associated JavaScript handler. It is a runtime error to destroy a Callback
+  // object associated with an uncanceled query without first executing one of
+  // the callback methods. The methods of this class may be called on any
+  // browser process thread.
+  ///
+  class Callback : public CefBase {
+   public:
+    ///
+    // Notify the associated JavaScript onSuccess callback that the query has
+    // completed successfully with the specified |response|.
+    ///
+    virtual void Success(const CefString& response) =0;
+
+    ///
+    // Notify the associated JavaScript onFailure callback that the query has
+    // failed with the specified |error_code| and |error_message|.
+    ///
+    virtual void Failure(int error_code, const CefString& error_message) =0;
+  };
+
+  ///
+  // Implement this interface to handle queries. All methods will be executed on
+  // the browser process UI thread.
+  ///
+  class Handler {
+   public:
+    typedef CefMessageRouterBrowserSide::Callback Callback;
+
+    ///
+    // Executed when a new query is received. |query_id| uniquely identifies the
+    // query for the life span of the router. Return true to handle the query
+    // or false to propagate the query to other registered handlers, if any. If
+    // no handlers return true from this method then the query will be
+    // automatically canceled with an error code of -1 delivered to the
+    // JavaScript onFailure callback. If this method returns true then a
+    // Callback method must be executed either in this method or asynchronously
+    // to complete the query.
+    ///
+    virtual bool OnQuery(CefRefPtr<CefBrowser> browser,
+                         CefRefPtr<CefFrame> frame,
+                         int64 query_id,
+                         const CefString& request,
+                         bool persistent,
+                         CefRefPtr<Callback> callback) {
+      return false;
+    }
+
+    ///
+    // Executed when a query has been canceled either explicitly using the
+    // JavaScript cancel function or implicitly due to browser destruction,
+    // navigation or renderer process termination. It will only be called for
+    // the single handler that returned true from OnQuery for the same
+    // |query_id|. No references to the associated Callback object should be
+    // kept after this method is called, nor should any Callback methods be
+    // executed.
+    ///
+    virtual void OnQueryCanceled(CefRefPtr<CefBrowser> browser,
+                                 CefRefPtr<CefFrame> frame,
+                                 int64 query_id) {}
+
+    virtual ~Handler() {}
+  };
+
+  ///
+  // Create a new router with the specified configuration.
+  ///
+  static CefRefPtr<CefMessageRouterBrowserSide> Create(
+      const CefMessageRouterConfig& config);
+
+  ///
+  // Add a new query handler. If |first| is true it will be added as the first
+  // handler, otherwise it will be added as the last handler. Returns true if
+  // the handler is added successfully or false if the handler has already been
+  // added. Must be called on the browser process UI thread. The Handler object
+  // must either outlive the router or be removed before deletion.
+  ///
+  virtual bool AddHandler(Handler* handler, bool first) =0;
+
+  ///
+  // Remove an existing query handler. Any pending queries associated with the
+  // handler will be canceled. Handler::OnQueryCanceled will be called and the
+  // associated JavaScript onFailure callback will be executed with an error
+  // code of -1. Returns true if the handler is removed successfully or false
+  // if the handler is not found. Must be called on the browser process UI
+  // thread.
+  ///
+  virtual bool RemoveHandler(Handler* handler) =0;
+
+  ///
+  // Cancel all pending queries associated with either |browser| or |handler|.
+  // If both |browser| and |handler| are NULL all pending queries will be
+  // canceled. Handler::OnQueryCanceled will be called and the associated
+  // JavaScript onFailure callback will be executed in all cases with an error
+  // code of -1.
+  ///
+  virtual void CancelPending(CefRefPtr<CefBrowser> browser,
+                             Handler* handler) =0;
+
+  ///
+  // Returns the number of queries currently pending for the specified |browser|
+  // and/or |handler|. Either or both values may be empty. Must be called on the
+  // browser process UI thread.
+  ///
+  virtual int GetPendingCount(CefRefPtr<CefBrowser> browser,
+                              Handler* handler) =0;
+
+
+  // The below methods should be called from other CEF handlers. They must be
+  // called exactly as documented for the router to function correctly.
+
+  ///
+  // Call from CefLifeSpanHandler::OnBeforeClose. Any pending queries associated
+  // with |browser| will be canceled and Handler::OnQueryCanceled will be called.
+  // No JavaScript callbacks will be executed since this indicates destruction
+  // of the browser.
+  ///
+  virtual void OnBeforeClose(CefRefPtr<CefBrowser> browser) =0;
+
+  ///
+  // Call from CefRequestHandler::OnRenderProcessTerminated. Any pending queries
+  // associated with |browser| will be canceled and Handler::OnQueryCanceled
+  // will be called. No JavaScript callbacks will be executed since this
+  // indicates destruction of the context.
+  ///
+  virtual void OnRenderProcessTerminated(CefRefPtr<CefBrowser> browser) =0;
+
+  ///
+  // Call from CefRequestHandler::OnBeforeBrowse only if the navigation is
+  // allowed to proceed. If |frame| is the main frame then any pending queries
+  // associated with |browser| will be canceled and Handler::OnQueryCanceled
+  // will be called. No JavaScript callbacks will be executed since this
+  // indicates destruction of the context.
+  ///
+  virtual void OnBeforeBrowse(CefRefPtr<CefBrowser> browser,
+                              CefRefPtr<CefFrame> frame) =0;
+
+  ///
+  // Call from CefClient::OnProcessMessageReceived. Returns true if the message
+  // is handled by this router or false otherwise.
+  ///
+  virtual bool OnProcessMessageReceived(
+      CefRefPtr<CefBrowser> browser,
+      CefProcessId source_process,
+      CefRefPtr<CefProcessMessage> message) =0;
+
+ protected:
+  // Protect against accidental deletion of this object.
+  friend class base::RefCountedThreadSafe<CefMessageRouterBrowserSide>;
+  virtual ~CefMessageRouterBrowserSide() {}
+};
+
+///
+// Implements the renderer side of query routing. The methods of this class must
+// be called on the render process main thread.
+///
+class CefMessageRouterRendererSide :
+    public base::RefCountedThreadSafe<CefMessageRouterRendererSide> {
+ public:
+  ///
+  // Create a new router with the specified configuration.
+  ///
+  static CefRefPtr<CefMessageRouterRendererSide> Create(
+      const CefMessageRouterConfig& config);
+
+  ///
+  // Returns the number of queries currently pending for the specified |browser|
+  // and/or |context|. Either or both values may be empty.
+  ///
+  virtual int GetPendingCount(CefRefPtr<CefBrowser> browser,
+                              CefRefPtr<CefV8Context> context) =0;
+
+
+  // The below methods should be called from other CEF handlers. They must be
+  // called exactly as documented for the router to function correctly.
+
+  ///
+  // Call from CefRenderProcessHandler::OnContextCreated. Registers the
+  // JavaScripts functions with the new context.
+  ///
+  virtual void OnContextCreated(CefRefPtr<CefBrowser> browser,
+                                CefRefPtr<CefFrame> frame,
+                                CefRefPtr<CefV8Context> context) =0;
+
+  ///
+  // Call from CefRenderProcessHandler::OnContextReleased. Any pending queries
+  // associated with the released context will be canceled and
+  // Handler::OnQueryCanceled will be called in the browser process.
+  ///
+  virtual void OnContextReleased(CefRefPtr<CefBrowser> browser,
+                                 CefRefPtr<CefFrame> frame,
+                                 CefRefPtr<CefV8Context> context) =0;
+  
+  ///
+  // Call from CefRenderProcessHandler::OnProcessMessageReceived. Returns true
+  // if the message is handled by this router or false otherwise.
+  ///
+  virtual bool OnProcessMessageReceived(
+      CefRefPtr<CefBrowser> browser,
+      CefProcessId source_process,
+      CefRefPtr<CefProcessMessage> message) =0;
+
+ protected:
+  // Protect against accidental deletion of this object.
+  friend class base::RefCountedThreadSafe<CefMessageRouterRendererSide>;
+  virtual ~CefMessageRouterRendererSide() {}
+};
+
+#endif  // CEF_INCLUDE_WRAPPER_CEF_MESSAGE_ROUTER_H_
diff --git a/src/include/libcef/wrapper/cef_resource_manager.h b/src/include/libcef/wrapper/cef_resource_manager.h
new file mode 100644
index 0000000..9ab8afa
--- /dev/null
+++ b/src/include/libcef/wrapper/cef_resource_manager.h
@@ -0,0 +1,373 @@
+// Copyright (c) 2015 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file are only available to applications that link
+// against the libcef_dll_wrapper target.
+//
+
+#ifndef CEF_INCLUDE_WRAPPER_CEF_RESOURCE_MANAGER_H_
+#define CEF_INCLUDE_WRAPPER_CEF_RESOURCE_MANAGER_H_
+#pragma once
+
+#include <list>
+
+#include "include/base/cef_macros.h"
+#include "include/base/cef_ref_counted.h"
+#include "include/base/cef_scoped_ptr.h"
+#include "include/base/cef_weak_ptr.h"
+#include "include/cef_request_handler.h"
+#include "include/wrapper/cef_closure_task.h"
+#include "include/wrapper/cef_helpers.h"
+
+///
+// Class for managing multiple resource providers. For each resource request
+// providers will be called in order and have the option to (a) handle the
+// request by returning a CefResourceHandler, (b) pass the request to the next
+// provider in order, or (c) stop handling the request. See comments on the
+// Request object for additional usage information. The methods of this class
+// may be called on any browser process thread unless otherwise indicated.
+///
+class CefResourceManager :
+    public base::RefCountedThreadSafe<CefResourceManager, CefDeleteOnIOThread> {
+ public:
+  ///
+  // Provides an opportunity to modify |url| before it is passed to a provider.
+  // For example, the implementation could rewrite |url| to include a default
+  // file extension. |url| will be fully qualified and may contain query or
+  // fragment components.
+  ///
+  typedef base::Callback<std::string(
+      const std::string& /*url*/)> UrlFilter;
+
+  ///
+  // Used to resolve mime types for URLs, usually based on the file extension.
+  // |url| will be fully qualified and may contain query or fragment components.
+  ///
+  typedef base::Callback<std::string(
+      const std::string& /*url*/)> MimeTypeResolver;
+
+ private:
+  // Values that stay with a request as it moves between providers.
+  struct RequestParams {
+    std::string url_;
+    CefRefPtr<CefBrowser> browser_;
+    CefRefPtr<CefFrame> frame_;
+    CefRefPtr<CefRequest> request_;
+    UrlFilter url_filter_;
+    MimeTypeResolver mime_type_resolver_;
+  };
+
+  // Values that are associated with the pending request only.
+  struct RequestState;
+
+ public:
+  ///
+  // Object representing a request. Each request object is used for a single
+  // call to Provider::OnRequest and will become detached (meaning the callbacks
+  // will no longer trigger) after Request::Continue or Request::Stop is called.
+  // A request passed to Provider::OnRequestCanceled will already have been
+  // detached. The methods of this class may be called on any browser process
+  // thread. 
+  ///
+  class Request : public base::RefCountedThreadSafe<Request> {
+   public:
+    ///
+    // Returns the URL associated with this request. The returned value will be
+    // fully qualified but will not contain query or fragment components. It
+    // will already have been passed through the URL filter.
+    ///
+    std::string url() const { return params_.url_; }
+
+    ///
+    // Returns the CefBrowser associated with this request.
+    ///
+    CefRefPtr<CefBrowser> browser() const { return params_.browser_; }
+ 
+    ///
+    // Returns the CefFrame associated with this request.
+    ///
+    CefRefPtr<CefFrame> frame() const { return params_.frame_; }
+
+    ///
+    // Returns the CefRequest associated with this request.
+    ///
+    CefRefPtr<CefRequest> request() const { return params_.request_; }
+
+    ///
+    // Returns the current URL filter.
+    ///
+    const CefResourceManager::UrlFilter& url_filter() const {
+      return params_.url_filter_;
+    }
+
+    ///
+    // Returns the current mime type resolver.
+    ///
+    const CefResourceManager::MimeTypeResolver& mime_type_resolver() const {
+      return params_.mime_type_resolver_;
+    }
+
+    ///
+    // Continue handling the request. If |handler| is non-NULL then no
+    // additional providers will be called and the |handler| value will be
+    // returned via CefResourceManager::GetResourceHandler. If |handler| is NULL
+    // then the next provider in order, if any, will be called. If there are no
+    // additional providers then NULL will be returned via CefResourceManager::
+    // GetResourceHandler. 
+    ///
+    void Continue(CefRefPtr<CefResourceHandler> handler);
+
+    ///
+    // Stop handling the request. No additional providers will be called and
+    // NULL will be returned via CefResourceManager::GetResourceHandler.
+    ///
+    void Stop();
+
+  private:
+    // Only allow deletion via scoped_refptr.
+    friend class base::RefCountedThreadSafe<Request>;
+
+    friend class CefResourceManager;
+
+    // The below methods are called on the browser process IO thread.
+
+    explicit Request(scoped_ptr<RequestState> state);
+
+    scoped_ptr<RequestState> SendRequest();
+    bool HasState();
+
+    static void ContinueOnIOThread(scoped_ptr<RequestState> state,
+                                   CefRefPtr<CefResourceHandler> handler);
+    static void StopOnIOThread(scoped_ptr<RequestState> state);
+
+    // Will be non-NULL while the request is pending. Only accessed on the
+    // browser process IO thread.
+    scoped_ptr<RequestState> state_;
+
+    // Params that stay with this request object. Safe to access on any thread.
+    RequestParams params_;
+
+    DISALLOW_COPY_AND_ASSIGN(Request);
+  };
+
+  typedef std::list<scoped_refptr<Request> > RequestList;
+
+
+  ///
+  // Interface implemented by resource providers. A provider may be created on
+  // any thread but the methods will be called on, and the object will be
+  // destroyed on, the browser process IO thread.
+  ///
+  class Provider {
+   public:
+    ///
+    // Called to handle a request. If the provider knows immediately that it
+    // will not handle the request return false. Otherwise, return true and call
+    // Request::Continue or Request::Stop either in this method or
+    // asynchronously to indicate completion. See comments on Request for
+    // additional usage information.
+    ///
+    virtual bool OnRequest(scoped_refptr<Request> request) =0;
+
+    ///
+    // Called when a request has been canceled. It is still safe to dereference
+    // |request| but any calls to Request::Continue or Request::Stop will be
+    // ignored.
+    ///
+    virtual void OnRequestCanceled(scoped_refptr<Request> request) {}
+
+    virtual ~Provider() {}
+  };
+
+  CefResourceManager();
+
+  ///
+  // Add a provider that maps requests for |url| to |content|. |url| should be
+  // fully qualified but not include a query or fragment component. If
+  // |mime_type| is empty the MimeTypeResolver will be used. See comments on
+  // AddProvider for usage of the |order| and |identifier| parameters.
+  ///
+  void AddContentProvider(const std::string& url,
+                          const std::string& content,
+                          const std::string& mime_type,
+                          int order,
+                          const std::string& identifier);
+
+  ///
+  // Add a provider that maps requests that start with |url_path| to files under
+  // |directory_path|. |url_path| should include an origin and optional path
+  // component only. Files will be loaded when a matching URL is requested.
+  // See comments on AddProvider for usage of the |order| and |identifier|
+  // parameters.
+  ///
+  void AddDirectoryProvider(const std::string& url_path,
+                            const std::string& directory_path,
+                            int order,
+                            const std::string& identifier);
+                    
+  ///
+  // Add a provider that maps requests that start with |url_path| to files
+  // stored in the archive file at |archive_path|. |url_path| should include an
+  // origin and optional path component only. The archive file will be loaded
+  // when a matching URL is requested for the first time. See comments on
+  // AddProvider for usage of the |order| and |identifier| parameters.
+  ///
+  void AddArchiveProvider(const std::string& url_path,
+                          const std::string& archive_path,
+                          const std::string& password,
+                          int order,
+                          const std::string& identifier);
+
+  ///
+  // Add a provider. This object takes ownership of |provider|. Providers will
+  // be called in ascending order based on the |order| value. Multiple providers
+  // sharing the same |order| value will be called in the order that they were
+  // added. The |identifier| value, which does not need to be unique, can be
+  // used to remove the provider at a later time.
+  ///
+  void AddProvider(Provider* provider,
+                   int order,
+                   const std::string& identifier);
+
+  ///
+  // Remove all providers with the specified |identifier| value. If any removed
+  // providers have pending requests the Provider::OnRequestCancel method will
+  // be called. The removed providers may be deleted immediately or at a later
+  // time.
+  ///
+  void RemoveProviders(const std::string& identifier);
+
+  ///
+  // Remove all providers. If any removed providers have pending requests the
+  // Provider::OnRequestCancel method will be called. The removed providers may
+  // be deleted immediately or at a later time.
+  ///
+  void RemoveAllProviders();
+
+  ///
+  // Set the url filter. If not set the default no-op filter will be used.
+  // Changes to this value will not affect currently pending requests.
+  ///
+  void SetUrlFilter(const UrlFilter& filter);
+
+  ///
+  // Set the mime type resolver. If not set the default resolver will be used.
+  // Changes to this value will not affect currently pending requests.
+  ///
+  void SetMimeTypeResolver(const MimeTypeResolver& resolver);
+
+
+  // The below methods should be called from other CEF handlers. They must be
+  // called exactly as documented for the manager to function correctly.
+
+  ///
+  // Called from CefRequestHandler::OnBeforeResourceLoad on the browser process
+  // IO thread.
+  ///
+  cef_return_value_t OnBeforeResourceLoad(
+      CefRefPtr<CefBrowser> browser,
+      CefRefPtr<CefFrame> frame,
+      CefRefPtr<CefRequest> request,
+      CefRefPtr<CefRequestCallback> callback);
+
+  ///
+  // Called from CefRequestHandler::GetResourceHandler on the browser process
+  // IO thread.
+  ///
+  CefRefPtr<CefResourceHandler> GetResourceHandler(
+      CefRefPtr<CefBrowser> browser,
+      CefRefPtr<CefFrame> frame,
+      CefRefPtr<CefRequest> request);
+
+ private:
+  // Only allow deletion via scoped_refptr.
+  friend struct CefDeleteOnThread<TID_IO>;
+  friend class base::RefCountedThreadSafe<CefResourceManager,
+                                          CefDeleteOnIOThread>;
+
+  ~CefResourceManager();
+  
+  // Provider and associated information.
+  struct ProviderEntry;
+  typedef std::list<ProviderEntry*> ProviderEntryList;
+
+  // Values associated with the pending request only. Ownership will be passed
+  // between requests and the resource manager as request handling proceeds.
+  struct RequestState {
+    ~RequestState();
+
+    base::WeakPtr<CefResourceManager> manager_;
+
+    // Callback to execute once request handling is complete.
+    CefRefPtr<CefRequestCallback> callback_;
+
+    // Position of the currently associated ProviderEntry in the |providers_|
+    // list.
+    ProviderEntryList::iterator current_entry_pos_;
+
+    // Position of this request object in the currently associated
+    // ProviderEntry's |pending_requests_| list.
+    RequestList::iterator current_request_pos_;
+
+    // Params that will be copied to each request object.
+    RequestParams params_;
+  };
+
+  // Methods that manage request state between requests. Called on the browser
+  // process IO thread.
+  bool SendRequest(scoped_ptr<RequestState> state);
+  void ContinueRequest(scoped_ptr<RequestState> state,
+                       CefRefPtr<CefResourceHandler> handler);
+  void StopRequest(scoped_ptr<RequestState> state);
+  bool IncrementProvider(RequestState* state);
+  void DetachRequestFromProvider(RequestState* state);
+  void GetNextValidProvider(ProviderEntryList::iterator& iterator);
+  void DeleteProvider(ProviderEntryList::iterator& iterator, bool stop);
+
+  // The below members are only accessed on the browser process IO thread.
+
+  // List of providers including additional associated information.
+  ProviderEntryList providers_;
+
+  // Map of response ID to pending CefResourceHandler object.
+  typedef std::map<uint64, CefRefPtr<CefResourceHandler> > PendingHandlersMap;
+  PendingHandlersMap pending_handlers_;
+
+  UrlFilter url_filter_;
+  MimeTypeResolver mime_type_resolver_;
+
+  // Must be the last member. Created and accessed on the IO thread.
+  scoped_ptr<base::WeakPtrFactory<CefResourceManager> > weak_ptr_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(CefResourceManager);
+};
+
+#endif  // CEF_INCLUDE_WRAPPER_CEF_RESOURCE_MANAGER_H_
diff --git a/src/include/libcef/wrapper/cef_stream_resource_handler.h b/src/include/libcef/wrapper/cef_stream_resource_handler.h
new file mode 100644
index 0000000..6a9a698
--- /dev/null
+++ b/src/include/libcef/wrapper/cef_stream_resource_handler.h
@@ -0,0 +1,104 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file are only available to applications that link
+// against the libcef_dll_wrapper target.
+//
+
+#ifndef CEF_INCLUDE_WRAPPER_CEF_STREAM_RESOURCE_HANDLER_H_
+#define CEF_INCLUDE_WRAPPER_CEF_STREAM_RESOURCE_HANDLER_H_
+#pragma once
+
+#include "include/base/cef_macros.h"
+#include "include/base/cef_scoped_ptr.h"
+#include "include/cef_base.h"
+#include "include/cef_resource_handler.h"
+#include "include/cef_response.h"
+
+class CefStreamReader;
+
+///
+// Implementation of the CefResourceHandler class for reading from a CefStream.
+///
+class CefStreamResourceHandler : public CefResourceHandler {
+ public:
+  ///
+  // Create a new object with default response values.
+  ///
+  CefStreamResourceHandler(const CefString& mime_type,
+                           CefRefPtr<CefStreamReader> stream);
+  ///
+  // Create a new object with explicit response values.
+  ///
+  CefStreamResourceHandler(int status_code,
+                           const CefString& status_text,
+                           const CefString& mime_type,
+                           CefResponse::HeaderMap header_map,
+                           CefRefPtr<CefStreamReader> stream);
+
+  virtual ~CefStreamResourceHandler();
+
+  // CefResourceHandler methods.
+  virtual bool ProcessRequest(CefRefPtr<CefRequest> request,
+                              CefRefPtr<CefCallback> callback) OVERRIDE;
+  virtual void GetResponseHeaders(CefRefPtr<CefResponse> response,
+                                  int64& response_length,
+                                  CefString& redirectUrl) OVERRIDE;
+  virtual bool ReadResponse(void* data_out,
+                            int bytes_to_read,
+                            int& bytes_read,
+                            CefRefPtr<CefCallback> callback) OVERRIDE;
+  virtual void Cancel() OVERRIDE;
+
+ private:
+  void ReadOnFileThread(int bytes_to_read,
+                        CefRefPtr<CefCallback> callback);
+
+  const int status_code_;
+  const CefString status_text_;
+  const CefString mime_type_;
+  const CefResponse::HeaderMap header_map_;
+  const CefRefPtr<CefStreamReader> stream_;
+  bool read_on_file_thread_;
+
+  class Buffer;
+  scoped_ptr<Buffer> buffer_;
+#ifndef NDEBUG
+  // Used in debug builds to verify that |buffer_| isn't being accessed on
+  // multiple threads at the same time.
+  bool buffer_owned_by_file_thread_;
+#endif
+
+  IMPLEMENT_REFCOUNTING(CefStreamResourceHandler);
+  DISALLOW_COPY_AND_ASSIGN(CefStreamResourceHandler);
+};
+
+#endif  // CEF_INCLUDE_WRAPPER_CEF_STREAM_RESOURCE_HANDLER_H_
diff --git a/src/include/libcef/wrapper/cef_xml_object.h b/src/include/libcef/wrapper/cef_xml_object.h
new file mode 100644
index 0000000..bf17554
--- /dev/null
+++ b/src/include/libcef/wrapper/cef_xml_object.h
@@ -0,0 +1,196 @@
+// Copyright (c) 2011 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file are only available to applications that link
+// against the libcef_dll_wrapper target.
+//
+
+#ifndef CEF_INCLUDE_WRAPPER_CEF_XML_OBJECT_H_
+#define CEF_INCLUDE_WRAPPER_CEF_XML_OBJECT_H_
+#pragma once
+
+#include <map>
+#include <vector>
+
+#include "include/base/cef_lock.h"
+#include "include/base/cef_macros.h"
+#include "include/base/cef_ref_counted.h"
+#include "include/cef_base.h"
+#include "include/cef_xml_reader.h"
+
+class CefStreamReader;
+
+///
+// Thread safe class for representing XML data as a structured object. This
+// class should not be used with large XML documents because all data will be
+// resident in memory at the same time. This implementation supports a
+// restricted set of XML features:
+// <pre>
+// (1) Processing instructions, whitespace and comments are ignored.
+// (2) Elements and attributes must always be referenced using the fully
+//     qualified name (ie, namespace:localname).
+// (3) Empty elements (<a/>) and elements with zero-length values (<a></a>)
+//     are considered the same.
+// (4) Element nodes are considered part of a value if:
+//     (a) The element node follows a non-element node at the same depth
+//         (see 5), or
+//     (b) The element node does not have a namespace and the parent node does.
+// (5) Mixed node types at the same depth are combined into a single element
+//     value as follows:
+//     (a) All node values are concatenated to form a single string value.
+//     (b) Entity reference nodes are resolved to the corresponding entity
+//         value.
+//     (c) Element nodes are represented by their outer XML string.
+// </pre>
+///
+class CefXmlObject : public base::RefCountedThreadSafe<CefXmlObject> {
+ public:
+  typedef std::vector<CefRefPtr<CefXmlObject> > ObjectVector;
+  typedef std::map<CefString, CefString > AttributeMap;
+
+  ///
+  // Create a new object with the specified name. An object name must always be
+  // at least one character long.
+  ///
+  explicit CefXmlObject(const CefString& name);
+
+  ///
+  // Load the contents of the specified XML stream into this object.  The
+  // existing children and attributes, if any, will first be cleared.
+  ///
+  bool Load(CefRefPtr<CefStreamReader> stream,
+            CefXmlReader::EncodingType encodingType,
+            const CefString& URI, CefString* loadError);
+
+  ///
+  // Set the name, children and attributes of this object to a duplicate of the
+  // specified object's contents. The existing children and attributes, if any,
+  // will first be cleared.
+  ///
+  void Set(CefRefPtr<CefXmlObject> object);
+
+  ///
+  // Append a duplicate of the children and attributes of the specified object
+  // to this object. If |overwriteAttributes| is true then any attributes in
+  // this object that also exist in the specified object will be overwritten
+  // with the new values. The name of this object is not changed.
+  ///
+  void Append(CefRefPtr<CefXmlObject> object, bool overwriteAttributes);
+
+  ///
+  // Return a new object with the same name, children and attributes as this
+  // object. The parent of the new object will be NULL.
+  ///
+  CefRefPtr<CefXmlObject> Duplicate();
+
+  ///
+  // Clears this object's children and attributes. The name and parenting of
+  // this object are not changed.
+  ///
+  void Clear();
+
+  ///
+  // Access the object's name. An object name must always be at least one
+  // character long.
+  ///
+  CefString GetName();
+  bool SetName(const CefString& name);
+
+  ///
+  // Access the object's parent. The parent can be NULL if this object has not
+  // been added as the child on another object.
+  ///
+  bool HasParent();
+  CefRefPtr<CefXmlObject> GetParent();
+
+  ///
+  // Access the object's value. An object cannot have a value if it also has
+  // children. Attempting to set the value while children exist will fail.
+  ///
+  bool HasValue();
+  CefString GetValue();
+  bool SetValue(const CefString& value);
+
+  ///
+  // Access the object's attributes. Attributes must have unique names.
+  ///
+  bool HasAttributes();
+  size_t GetAttributeCount();
+  bool HasAttribute(const CefString& name);
+  CefString GetAttributeValue(const CefString& name);
+  bool SetAttributeValue(const CefString& name, const CefString& value);
+  size_t GetAttributes(AttributeMap& attributes);
+  void ClearAttributes();
+
+  ///
+  // Access the object's children. Each object can only have one parent so
+  // attempting to add an object that already has a parent will fail. Removing a
+  // child will set the child's parent to NULL. Adding a child will set the
+  // child's parent to this object. This object's value, if any, will be cleared
+  // if a child is added.
+  ///
+  bool HasChildren();
+  size_t GetChildCount();
+  bool HasChild(CefRefPtr<CefXmlObject> child);
+  bool AddChild(CefRefPtr<CefXmlObject> child);
+  bool RemoveChild(CefRefPtr<CefXmlObject> child);
+  size_t GetChildren(ObjectVector& children);
+  void ClearChildren();
+
+  ///
+  // Find the first child with the specified name.
+  ///
+  CefRefPtr<CefXmlObject> FindChild(const CefString& name);
+
+  ///
+  // Find all children with the specified name.
+  ///
+  size_t FindChildren(const CefString& name, ObjectVector& children);
+
+ private:
+  // Protect against accidental deletion of this object.
+  friend class base::RefCountedThreadSafe<CefXmlObject>;
+  ~CefXmlObject();
+
+  void SetParent(CefXmlObject* parent);
+
+  CefString name_;
+  CefXmlObject* parent_;
+  CefString value_;
+  AttributeMap attributes_;
+  ObjectVector children_;
+
+  base::Lock lock_;
+
+  DISALLOW_COPY_AND_ASSIGN(CefXmlObject);
+};
+
+#endif  // CEF_INCLUDE_WRAPPER_CEF_XML_OBJECT_H_
diff --git a/src/include/libcef/wrapper/cef_zip_archive.h b/src/include/libcef/wrapper/cef_zip_archive.h
new file mode 100644
index 0000000..7ad10bd
--- /dev/null
+++ b/src/include/libcef/wrapper/cef_zip_archive.h
@@ -0,0 +1,143 @@
+// Copyright (c) 2011 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file are only available to applications that link
+// against the libcef_dll_wrapper target.
+//
+
+#ifndef CEF_INCLUDE_WRAPPER_CEF_ZIP_ARCHIVE_H_
+#define CEF_INCLUDE_WRAPPER_CEF_ZIP_ARCHIVE_H_
+#pragma once
+
+#include <map>
+
+#include "include/base/cef_lock.h"
+#include "include/base/cef_macros.h"
+#include "include/base/cef_ref_counted.h"
+#include "include/cef_base.h"
+
+class CefStreamReader;
+
+///
+// Thread-safe class for accessing zip archive file contents. This class should
+// not be used with large archive files because all data will be resident in
+// memory at the same time. This implementation supports a restricted set of zip
+// archive features:
+// (1) All file names are stored and compared in lower case.
+// (2) File ordering from the original zip archive is not maintained. This
+//     means that files from the same folder may not be located together in the
+//     file content map.
+///
+class CefZipArchive : public base::RefCountedThreadSafe<CefZipArchive> {
+ public:
+  ///
+  // Class representing a file in the archive. Accessing the file data from
+  // multiple threads is safe provided a reference to the File object is kept.
+  ///
+  class File : public CefBase {
+   public:
+    ///
+    // Returns the read-only data contained in the file.
+    ///
+    virtual const unsigned char* GetData() const =0;
+
+    ///
+    // Returns the size of the data in the file.
+    ///
+    virtual size_t GetDataSize() const =0;
+
+    ///
+    // Returns a CefStreamReader object for streaming the contents of the file.
+    ///
+    virtual CefRefPtr<CefStreamReader> GetStreamReader() const =0;
+  };
+
+  typedef std::map<CefString, CefRefPtr<File> > FileMap;
+
+  ///
+  // Create a new object.
+  ///
+  CefZipArchive();
+
+  ///
+  // Load the contents of the specified zip archive stream into this object.
+  // If the zip archive requires a password then provide it via |password|.
+  // If |overwriteExisting| is true then any files in this object that also
+  // exist in the specified archive will be replaced with the new files.
+  // Returns the number of files successfully loaded.
+  ///
+  size_t Load(CefRefPtr<CefStreamReader> stream,
+              const CefString& password,
+              bool overwriteExisting);
+
+  ///
+  // Clears the contents of this object.
+  ///
+  void Clear();
+
+  ///
+  // Returns the number of files in the archive.
+  ///
+  size_t GetFileCount() const;
+
+  ///
+  // Returns true if the specified file exists and has contents.
+  ///
+  bool HasFile(const CefString& fileName) const;
+
+  ///
+  // Returns the specified file.
+  ///
+  CefRefPtr<File> GetFile(const CefString& fileName) const;
+
+  ///
+  // Removes the specified file.
+  ///
+  bool RemoveFile(const CefString& fileName);
+
+  ///
+  // Returns the map of all files.
+  ///
+  size_t GetFiles(FileMap& map) const;
+
+ private:
+  // Protect against accidental deletion of this object.
+  friend class base::RefCountedThreadSafe<CefZipArchive>;
+  ~CefZipArchive();
+
+  FileMap contents_;
+
+  mutable base::Lock lock_;
+
+  DISALLOW_COPY_AND_ASSIGN(CefZipArchive);
+};
+
+#endif  // CEF_INCLUDE_WRAPPER_CEF_ZIP_ARCHIVE_H_
diff --git a/src/include/libcef_/base/cef_atomic_ref_count.h b/src/include/libcef_/base/cef_atomic_ref_count.h
new file mode 100644
index 0000000..a0ab843
--- /dev/null
+++ b/src/include/libcef_/base/cef_atomic_ref_count.h
@@ -0,0 +1,126 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2011
+// Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// This is a low level implementation of atomic semantics for reference
+// counting.  Please use cef_ref_counted.h directly instead.
+//
+// The Chromium implementation includes annotations to avoid some false
+// positives when using data race detection tools. Annotations are not
+// currently supported by the CEF implementation.
+
+#ifndef CEF_INCLUDE_BASE_CEF_ATOMIC_REF_COUNT_H_
+#define CEF_INCLUDE_BASE_CEF_ATOMIC_REF_COUNT_H_
+#pragma once
+
+#if defined(BASE_ATOMIC_REF_COUNT_H_)
+// Do nothing if the Chromium header has already been included.
+// This can happen in cases where Chromium code is used directly by the
+// client application. When using Chromium code directly always include
+// the Chromium header first to avoid type conflicts.
+#elif defined(BUILDING_CEF_SHARED)
+// When building CEF include the Chromium header directly.
+#include "base/atomic_ref_count.h"
+#else  // !BUILDING_CEF_SHARED
+// The following is substantially similar to the Chromium implementation.
+// If the Chromium implementation diverges the below implementation should be
+// updated to match.
+
+#include"libcef/base/cef_atomicops.h"
+
+// Annotations are not currently supported.
+#define ANNOTATE_HAPPENS_BEFORE(obj) /* empty */
+#define ANNOTATE_HAPPENS_AFTER(obj) /* empty */
+
+namespace base {
+
+typedef subtle::Atomic32 AtomicRefCount;
+
+// Increment a reference count by "increment", which must exceed 0.
+inline void AtomicRefCountIncN(volatile AtomicRefCount *ptr,
+                               AtomicRefCount increment) {
+  subtle::NoBarrier_AtomicIncrement(ptr, increment);
+}
+
+// Decrement a reference count by "decrement", which must exceed 0,
+// and return whether the result is non-zero.
+// Insert barriers to ensure that state written before the reference count
+// became zero will be visible to a thread that has just made the count zero.
+inline bool AtomicRefCountDecN(volatile AtomicRefCount *ptr,
+                               AtomicRefCount decrement) {
+  ANNOTATE_HAPPENS_BEFORE(ptr);
+  bool res = (subtle::Barrier_AtomicIncrement(ptr, -decrement) != 0);
+  if (!res) {
+    ANNOTATE_HAPPENS_AFTER(ptr);
+  }
+  return res;
+}
+
+// Increment a reference count by 1.
+inline void AtomicRefCountInc(volatile AtomicRefCount *ptr) {
+  base::AtomicRefCountIncN(ptr, 1);
+}
+
+// Decrement a reference count by 1 and return whether the result is non-zero.
+// Insert barriers to ensure that state written before the reference count
+// became zero will be visible to a thread that has just made the count zero.
+inline bool AtomicRefCountDec(volatile AtomicRefCount *ptr) {
+  return base::AtomicRefCountDecN(ptr, 1);
+}
+
+// Return whether the reference count is one.  If the reference count is used
+// in the conventional way, a refrerence count of 1 implies that the current
+// thread owns the reference and no other thread shares it.  This call performs
+// the test for a reference count of one, and performs the memory barrier
+// needed for the owning thread to act on the object, knowing that it has
+// exclusive access to the object.
+inline bool AtomicRefCountIsOne(volatile AtomicRefCount *ptr) {
+  bool res = (subtle::Acquire_Load(ptr) == 1);
+  if (res) {
+    ANNOTATE_HAPPENS_AFTER(ptr);
+  }
+  return res;
+}
+
+// Return whether the reference count is zero.  With conventional object
+// referencing counting, the object will be destroyed, so the reference count
+// should never be zero.  Hence this is generally used for a debug check.
+inline bool AtomicRefCountIsZero(volatile AtomicRefCount *ptr) {
+  bool res = (subtle::Acquire_Load(ptr) == 0);
+  if (res) {
+    ANNOTATE_HAPPENS_AFTER(ptr);
+  }
+  return res;
+}
+
+}  // namespace base
+
+#endif  // !BUILDING_CEF_SHARED
+
+#endif  // CEF_INCLUDE_BASE_CEF_ATOMIC_REF_COUNT_H_
diff --git a/src/include/libcef_/base/cef_atomicops.h b/src/include/libcef_/base/cef_atomicops.h
new file mode 100644
index 0000000..d6f8e3e
--- /dev/null
+++ b/src/include/libcef_/base/cef_atomicops.h
@@ -0,0 +1,204 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2012
+// Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// For atomic operations on reference counts, see cef_atomic_ref_count.h.
+
+// The routines exported by this module are subtle.  If you use them, even if
+// you get the code right, it will depend on careful reasoning about atomicity
+// and memory ordering; it will be less readable, and harder to maintain.  If
+// you plan to use these routines, you should have a good reason, such as solid
+// evidence that performance would otherwise suffer, or there being no
+// alternative.  You should assume only properties explicitly guaranteed by the
+// specifications in this file.  You are almost certainly _not_ writing code
+// just for the x86; if you assume x86 semantics, x86 hardware bugs and
+// implementations on other archtectures will cause your code to break.  If you
+// do not know what you are doing, avoid these routines, and use a Mutex.
+//
+// It is incorrect to make direct assignments to/from an atomic variable.
+// You should use one of the Load or Store routines.  The NoBarrier
+// versions are provided when no barriers are needed:
+//   NoBarrier_Store()
+//   NoBarrier_Load()
+// Although there are currently no compiler enforcement, you are encouraged
+// to use these.
+//
+
+#ifndef CEF_INCLUDE_BASE_CEF_ATOMICOPS_H_
+#define CEF_INCLUDE_BASE_CEF_ATOMICOPS_H_
+#pragma once
+
+#if defined(BASE_ATOMICOPS_H_)
+// Do nothing if the Chromium header has already been included.
+// This can happen in cases where Chromium code is used directly by the
+// client application. When using Chromium code directly always include
+// the Chromium header first to avoid type conflicts.
+#elif defined(BUILDING_CEF_SHARED)
+// When building CEF include the Chromium header directly.
+#include "base/atomicops.h"
+#else  // !BUILDING_CEF_SHARED
+// The following is substantially similar to the Chromium implementation.
+// If the Chromium implementation diverges the below implementation should be
+// updated to match.
+
+#include<stdint.h>
+
+#include"libcef/base/cef_build.h"
+
+#if defined(OS_WIN) && defined(ARCH_CPU_64_BITS)
+// windows.h #defines this (only on x64). This causes problems because the
+// public API also uses MemoryBarrier at the public name for this fence. So, on
+// X64, undef it, and call its documented
+// (http://msdn.microsoft.com/en-us/library/windows/desktop/ms684208.aspx)
+// implementation directly.
+#undef MemoryBarrier
+#endif
+
+namespace base {
+namespace subtle {
+
+typedef int32_t Atomic32;
+#ifdef ARCH_CPU_64_BITS
+// We need to be able to go between Atomic64 and AtomicWord implicitly.  This
+// means Atomic64 and AtomicWord should be the same type on 64-bit.
+#if defined(__ILP32__) || defined(OS_NACL)
+// NaCl's intptr_t is not actually 64-bits on 64-bit!
+// http://code.google.com/p/nativeclient/issues/detail?id=1162
+typedef int64_t Atomic64;
+#else
+typedef intptr_t Atomic64;
+#endif
+#endif
+
+// Use AtomicWord for a machine-sized pointer.  It will use the Atomic32 or
+// Atomic64 routines below, depending on your architecture.
+typedef intptr_t AtomicWord;
+
+// Atomically execute:
+//      result = *ptr;
+//      if (*ptr == old_value)
+//        *ptr = new_value;
+//      return result;
+//
+// I.e., replace "*ptr" with "new_value" if "*ptr" used to be "old_value".
+// Always return the old value of "*ptr"
+//
+// This routine implies no memory barriers.
+Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr,
+                                  Atomic32 old_value,
+                                  Atomic32 new_value);
+
+// Atomically store new_value into *ptr, returning the previous value held in
+// *ptr.  This routine implies no memory barriers.
+Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr, Atomic32 new_value);
+
+// Atomically increment *ptr by "increment".  Returns the new value of
+// *ptr with the increment applied.  This routine implies no memory barriers.
+Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr, Atomic32 increment);
+
+Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr,
+                                 Atomic32 increment);
+
+// These following lower-level operations are typically useful only to people
+// implementing higher-level synchronization operations like spinlocks,
+// mutexes, and condition-variables.  They combine CompareAndSwap(), a load, or
+// a store with appropriate memory-ordering instructions.  "Acquire" operations
+// ensure that no later memory access can be reordered ahead of the operation.
+// "Release" operations ensure that no previous memory access can be reordered
+// after the operation.  "Barrier" operations have both "Acquire" and "Release"
+// semantics.   A MemoryBarrier() has "Barrier" semantics, but does no memory
+// access.
+Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr,
+                                Atomic32 old_value,
+                                Atomic32 new_value);
+
+Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr,
+                                Atomic32 old_value,
+                                Atomic32 new_value);
+
+void MemoryBarrier();
+void NoBarrier_Store(volatile Atomic32* ptr, Atomic32 value);
+void Acquire_Store(volatile Atomic32* ptr, Atomic32 value);
+void Release_Store(volatile Atomic32* ptr, Atomic32 value);
+
+Atomic32 NoBarrier_Load(volatile const Atomic32* ptr);
+Atomic32 Acquire_Load(volatile const Atomic32* ptr);
+Atomic32 Release_Load(volatile const Atomic32* ptr);
+
+// 64-bit atomic operations (only available on 64-bit processors).
+#ifdef ARCH_CPU_64_BITS
+Atomic64 NoBarrier_CompareAndSwap(volatile Atomic64* ptr,
+                                  Atomic64 old_value,
+                                  Atomic64 new_value);
+
+Atomic64 NoBarrier_AtomicExchange(volatile Atomic64* ptr, Atomic64 new_value);
+Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64* ptr, Atomic64 increment);
+Atomic64 Barrier_AtomicIncrement(volatile Atomic64* ptr, Atomic64 increment);
+
+Atomic64 Acquire_CompareAndSwap(volatile Atomic64* ptr,
+                                Atomic64 old_value,
+                                Atomic64 new_value);
+
+Atomic64 Release_CompareAndSwap(volatile Atomic64* ptr,
+                                Atomic64 old_value,
+                                Atomic64 new_value);
+
+void NoBarrier_Store(volatile Atomic64* ptr, Atomic64 value);
+void Acquire_Store(volatile Atomic64* ptr, Atomic64 value);
+void Release_Store(volatile Atomic64* ptr, Atomic64 value);
+Atomic64 NoBarrier_Load(volatile const Atomic64* ptr);
+Atomic64 Acquire_Load(volatile const Atomic64* ptr);
+Atomic64 Release_Load(volatile const Atomic64* ptr);
+#endif  // ARCH_CPU_64_BITS
+
+}  // namespace subtle
+}  // namespace base
+
+// Include our platform specific implementation.
+#if defined(OS_WIN) && defined(COMPILER_MSVC) && defined(ARCH_CPU_X86_FAMILY)
+    #include"libcef/base/internal/cef_atomicops_x86_msvc.h"
+#elif defined(__WATCOMC__) && defined(__386__)
+    #include"libcef/base/internal/cef_atomicops_x86_watcom.h"
+#elif defined(OS_MACOSX)
+    #include"libcef/base/internal/cef_atomicops_mac.h"
+#elif defined(COMPILER_GCC) && defined(ARCH_CPU_X86_FAMILY)
+    #include"libcef/base/internal/cef_atomicops_x86_gcc.h"
+#else
+    #error "Atomic operations are not supported on your platform"
+#endif
+
+// On some platforms we need additional declarations to make
+// AtomicWord compatible with our other Atomic* types.
+#if defined(OS_MACOSX) || defined(OS_OPENBSD)
+    #include"libcef/base/internal/cef_atomicops_atomicword_compat.h"
+#endif
+
+#endif  // !BUILDING_CEF_SHARED
+
+#endif  // CEF_INCLUDE_BASE_CEF_ATOMICOPS_H_
diff --git a/src/include/libcef_/base/cef_basictypes.h b/src/include/libcef_/base/cef_basictypes.h
new file mode 100644
index 0000000..9b7c36c
--- /dev/null
+++ b/src/include/libcef_/base/cef_basictypes.h
@@ -0,0 +1,77 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2012
+// Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef CEF_INCLUDE_BASE_CEF_BASICTYPES_H_
+#define CEF_INCLUDE_BASE_CEF_BASICTYPES_H_
+#pragma once
+
+#include<limits.h>         // For UINT_MAX
+#include<stddef.h>         // For size_t
+
+#include"libcef/base/cef_build.h"
+
+// The NSPR system headers define 64-bit as |long| when possible, except on
+// Mac OS X.  In order to not have typedef mismatches, we do the same on LP64.
+//
+// On Mac OS X, |long long| is used for 64-bit types for compatibility with
+// <inttypes.h> format macros even in the LP64 model.
+#if defined(__LP64__) && !defined(OS_MACOSX) && !defined(OS_OPENBSD)
+	typedef long                int64;  // NOLINT(runtime/int)
+	typedef unsigned long       uint64;  // NOLINT(runtime/int)
+#else
+	typedef long long           int64;  // NOLINT(runtime/int)
+	typedef unsigned long long  uint64;  // NOLINT(runtime/int)
+#endif
+
+// TODO: Remove these type guards.  These are to avoid conflicts with
+// obsolete/protypes.h in the Gecko SDK.
+#ifndef _INT32
+	#define _INT32
+	typedef int                 int32;
+#endif
+
+// TODO: Remove these type guards.  These are to avoid conflicts with
+// obsolete/protypes.h in the Gecko SDK.
+#ifndef _UINT32
+	#define _UINT32
+	typedef unsigned int       uint32;
+#endif
+
+// UTF-16 character type.
+// This should be kept synchronized with base/strings/string16.h
+#ifndef char16
+	#if defined(WCHAR_T_IS_UTF16)
+		typedef wchar_t             char16;
+	#elif defined(WCHAR_T_IS_UTF32)
+		typedef unsigned short      char16;
+	#endif
+#endif
+
+#endif  // CEF_INCLUDE_BASE_CEF_BASICTYPES_H_
diff --git a/src/include/libcef_/base/cef_bind.h b/src/include/libcef_/base/cef_bind.h
new file mode 100644
index 0000000..8829672
--- /dev/null
+++ b/src/include/libcef_/base/cef_bind.h
@@ -0,0 +1,563 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2011
+// Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef CEF_INCLUDE_BASE_CEF_BIND_H_
+#define CEF_INCLUDE_BASE_CEF_BIND_H_
+#pragma once
+
+#if defined(BASE_BIND_H_)
+// Do nothing if the Chromium header has already been included.
+// This can happen in cases where Chromium code is used directly by the
+// client application. When using Chromium code directly always include
+// the Chromium header first to avoid type conflicts.
+#elif defined(BUILDING_CEF_SHARED)
+// When building CEF include the Chromium header directly.
+#include "base/bind.h"
+#else  // !BUILDING_CEF_SHARED
+// The following is substantially similar to the Chromium implementation.
+// If the Chromium implementation diverges the below implementation should be
+// updated to match.
+
+#include"libcef/base/internal/cef_bind_internal.h"
+#include"libcef/base/internal/cef_callback_internal.h"
+
+// -----------------------------------------------------------------------------
+// Usage documentation
+// -----------------------------------------------------------------------------
+//
+// See base/cef_callback.h for documentation.
+//
+//
+// -----------------------------------------------------------------------------
+// Implementation notes
+// -----------------------------------------------------------------------------
+//
+// If you're reading the implementation, before proceeding further, you should
+// read the top comment of base/bind_internal.h for a definition of common
+// terms and concepts.
+//
+// RETURN TYPES
+//
+// Though Bind()'s result is meant to be stored in a Callback<> type, it
+// cannot actually return the exact type without requiring a large amount
+// of extra template specializations. The problem is that in order to
+// discern the correct specialization of Callback<>, Bind would need to
+// unwrap the function signature to determine the signature's arity, and
+// whether or not it is a method.
+//
+// Each unique combination of (arity, function_type, num_prebound) where
+// function_type is one of {function, method, const_method} would require
+// one specialization.  We eventually have to do a similar number of
+// specializations anyways in the implementation (see the Invoker<>,
+// classes).  However, it is avoidable in Bind if we return the result
+// via an indirection like we do below.
+//
+// TODO(ajwong): We might be able to avoid this now, but need to test.
+//
+// It is possible to move most of the COMPILE_ASSERT asserts into BindState<>,
+// but it feels a little nicer to have the asserts here so people do not
+// need to crack open bind_internal.h.  On the other hand, it makes Bind()
+// harder to read.
+
+namespace base {
+
+template <typename Functor>
+base::Callback<
+    typename cef_internal::BindState<
+        typename cef_internal::FunctorTraits<Functor>::RunnableType,
+        typename cef_internal::FunctorTraits<Functor>::RunType,
+        void()>
+            ::UnboundRunType>
+Bind(Functor functor) {
+  // Typedefs for how to store and run the functor.
+  typedef typename cef_internal::FunctorTraits<Functor>::RunnableType RunnableType;
+  typedef typename cef_internal::FunctorTraits<Functor>::RunType RunType;
+
+  typedef cef_internal::BindState<RunnableType, RunType, void()> BindState;
+
+
+  return Callback<typename BindState::UnboundRunType>(
+      new BindState(cef_internal::MakeRunnable(functor)));
+}
+
+template <typename Functor, typename P1>
+base::Callback<
+    typename cef_internal::BindState<
+        typename cef_internal::FunctorTraits<Functor>::RunnableType,
+        typename cef_internal::FunctorTraits<Functor>::RunType,
+        void(typename cef_internal::CallbackParamTraits<P1>::StorageType)>
+            ::UnboundRunType>
+Bind(Functor functor, const P1& p1) {
+  // Typedefs for how to store and run the functor.
+  typedef typename cef_internal::FunctorTraits<Functor>::RunnableType RunnableType;
+  typedef typename cef_internal::FunctorTraits<Functor>::RunType RunType;
+
+  // Use RunnableType::RunType instead of RunType above because our
+  // checks should below for bound references need to know what the actual
+  // functor is going to interpret the argument as.
+  typedef cef_internal::FunctionTraits<typename RunnableType::RunType>
+      BoundFunctorTraits;
+
+  // Do not allow binding a non-const reference parameter. Non-const reference
+  // parameters are disallowed by the Google style guide.  Also, binding a
+  // non-const reference parameter can make for subtle bugs because the
+  // invoked function will receive a reference to the stored copy of the
+  // argument and not the original.
+  COMPILE_ASSERT(
+      !(is_non_const_reference<typename BoundFunctorTraits::A1Type>::value ),
+      do_not_bind_functions_with_nonconst_ref);
+
+  // For methods, we need to be careful for parameter 1.  We do not require
+  // a scoped_refptr because BindState<> itself takes care of AddRef() for
+  // methods. We also disallow binding of an array as the method's target
+  // object.
+  COMPILE_ASSERT(
+      cef_internal::HasIsMethodTag<RunnableType>::value ||
+          !cef_internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
+      p1_is_refcounted_type_and_needs_scoped_refptr);
+  COMPILE_ASSERT(!cef_internal::HasIsMethodTag<RunnableType>::value ||
+                     !is_array<P1>::value,
+                 first_bound_argument_to_method_cannot_be_array);
+  typedef cef_internal::BindState<RunnableType, RunType,
+      void(typename cef_internal::CallbackParamTraits<P1>::StorageType)> BindState;
+
+
+  return Callback<typename BindState::UnboundRunType>(
+      new BindState(cef_internal::MakeRunnable(functor), p1));
+}
+
+template <typename Functor, typename P1, typename P2>
+base::Callback<
+    typename cef_internal::BindState<
+        typename cef_internal::FunctorTraits<Functor>::RunnableType,
+        typename cef_internal::FunctorTraits<Functor>::RunType,
+        void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
+            typename cef_internal::CallbackParamTraits<P2>::StorageType)>
+            ::UnboundRunType>
+Bind(Functor functor, const P1& p1, const P2& p2) {
+  // Typedefs for how to store and run the functor.
+  typedef typename cef_internal::FunctorTraits<Functor>::RunnableType RunnableType;
+  typedef typename cef_internal::FunctorTraits<Functor>::RunType RunType;
+
+  // Use RunnableType::RunType instead of RunType above because our
+  // checks should below for bound references need to know what the actual
+  // functor is going to interpret the argument as.
+  typedef cef_internal::FunctionTraits<typename RunnableType::RunType>
+      BoundFunctorTraits;
+
+  // Do not allow binding a non-const reference parameter. Non-const reference
+  // parameters are disallowed by the Google style guide.  Also, binding a
+  // non-const reference parameter can make for subtle bugs because the
+  // invoked function will receive a reference to the stored copy of the
+  // argument and not the original.
+  COMPILE_ASSERT(!(is_non_const_reference<typename BoundFunctorTraits::A1Type>::value ||
+          is_non_const_reference<typename BoundFunctorTraits::A2Type>::value ),
+      do_not_bind_functions_with_nonconst_ref);
+
+  // For methods, we need to be careful for parameter 1.  We do not require
+  // a scoped_refptr because BindState<> itself takes care of AddRef() for
+  // methods. We also disallow binding of an array as the method's target
+  // object.
+  /*COMPILE_ASSERT(cef_internal::HasIsMethodTag<RunnableType>::value ||
+          !cef_internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
+        p1_is_refcounted_type_and_needs_scoped_refptr);
+  */
+
+  #if defined(__WATCOMC__)
+    // Implementação para Watcom - remove os qualificadores ::
+    typedef typename cef_internal::HasIsMethodTag<RunnableType> HasTag;
+    typedef typename cef_internal::NeedsScopedRefptrButGetsRawPtr<P1> NeedsRef;
+    COMPILE_ASSERT(HasTag::value || !NeedsRef::value,
+                 p1_is_refcounted_type_and_needs_scoped_refptr);
+  #else
+    // Implementação original
+    COMPILE_ASSERT(cef_internal::HasIsMethodTag<RunnableType>::value ||
+            !cef_internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
+        p1_is_refcounted_type_and_needs_scoped_refptr);
+  #endif
+
+  COMPILE_ASSERT(!cef_internal::HasIsMethodTag<RunnableType>::value ||
+                     !is_array<P1>::value,
+                 first_bound_argument_to_method_cannot_be_array);
+  
+  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
+                 p2_is_refcounted_type_and_needs_scoped_refptr);
+  
+  typedef cef_internal::BindState<RunnableType, RunType,
+      void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
+      typename cef_internal::CallbackParamTraits<P2>::StorageType)> BindState;
+
+
+  return Callback<typename BindState::UnboundRunType>(
+      new BindState(cef_internal::MakeRunnable(functor), p1, p2));
+}
+
+template <typename Functor, typename P1, typename P2, typename P3>
+base::Callback<
+    typename cef_internal::BindState<
+        typename cef_internal::FunctorTraits<Functor>::RunnableType,
+        typename cef_internal::FunctorTraits<Functor>::RunType,
+        void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
+            typename cef_internal::CallbackParamTraits<P2>::StorageType,
+            typename cef_internal::CallbackParamTraits<P3>::StorageType)>
+            ::UnboundRunType>
+Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3) {
+  // Typedefs for how to store and run the functor.
+  typedef typename cef_internal::FunctorTraits<Functor>::RunnableType RunnableType;
+  typedef typename cef_internal::FunctorTraits<Functor>::RunType RunType;
+
+  // Use RunnableType::RunType instead of RunType above because our
+  // checks should below for bound references need to know what the actual
+  // functor is going to interpret the argument as.
+  typedef cef_internal::FunctionTraits<typename RunnableType::RunType>
+      BoundFunctorTraits;
+
+  // Do not allow binding a non-const reference parameter. Non-const reference
+  // parameters are disallowed by the Google style guide.  Also, binding a
+  // non-const reference parameter can make for subtle bugs because the
+  // invoked function will receive a reference to the stored copy of the
+  // argument and not the original.
+  COMPILE_ASSERT(
+      !(is_non_const_reference<typename BoundFunctorTraits::A1Type>::value ||
+          is_non_const_reference<typename BoundFunctorTraits::A2Type>::value ||
+          is_non_const_reference<typename BoundFunctorTraits::A3Type>::value ),
+      do_not_bind_functions_with_nonconst_ref);
+
+  // For methods, we need to be careful for parameter 1.  We do not require
+  // a scoped_refptr because BindState<> itself takes care of AddRef() for
+  // methods. We also disallow binding of an array as the method's target
+  // object.
+  COMPILE_ASSERT(
+      cef_internal::HasIsMethodTag<RunnableType>::value ||
+          !cef_internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
+      p1_is_refcounted_type_and_needs_scoped_refptr);
+  COMPILE_ASSERT(!cef_internal::HasIsMethodTag<RunnableType>::value ||
+                     !is_array<P1>::value,
+                 first_bound_argument_to_method_cannot_be_array);
+  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
+                 p2_is_refcounted_type_and_needs_scoped_refptr);
+  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P3>::value,
+                 p3_is_refcounted_type_and_needs_scoped_refptr);
+  typedef cef_internal::BindState<RunnableType, RunType,
+      void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
+      typename cef_internal::CallbackParamTraits<P2>::StorageType,
+      typename cef_internal::CallbackParamTraits<P3>::StorageType)> BindState;
+
+
+  return Callback<typename BindState::UnboundRunType>(
+      new BindState(cef_internal::MakeRunnable(functor), p1, p2, p3));
+}
+
+template <typename Functor, typename P1, typename P2, typename P3, typename P4>
+base::Callback<
+    typename cef_internal::BindState<
+        typename cef_internal::FunctorTraits<Functor>::RunnableType,
+        typename cef_internal::FunctorTraits<Functor>::RunType,
+        void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
+            typename cef_internal::CallbackParamTraits<P2>::StorageType,
+            typename cef_internal::CallbackParamTraits<P3>::StorageType,
+            typename cef_internal::CallbackParamTraits<P4>::StorageType)>
+            ::UnboundRunType>
+Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
+  // Typedefs for how to store and run the functor.
+  typedef typename cef_internal::FunctorTraits<Functor>::RunnableType RunnableType;
+  typedef typename cef_internal::FunctorTraits<Functor>::RunType RunType;
+
+  // Use RunnableType::RunType instead of RunType above because our
+  // checks should below for bound references need to know what the actual
+  // functor is going to interpret the argument as.
+  typedef cef_internal::FunctionTraits<typename RunnableType::RunType>
+      BoundFunctorTraits;
+
+  // Do not allow binding a non-const reference parameter. Non-const reference
+  // parameters are disallowed by the Google style guide.  Also, binding a
+  // non-const reference parameter can make for subtle bugs because the
+  // invoked function will receive a reference to the stored copy of the
+  // argument and not the original.
+  COMPILE_ASSERT(
+      !(is_non_const_reference<typename BoundFunctorTraits::A1Type>::value ||
+          is_non_const_reference<typename BoundFunctorTraits::A2Type>::value ||
+          is_non_const_reference<typename BoundFunctorTraits::A3Type>::value ||
+          is_non_const_reference<typename BoundFunctorTraits::A4Type>::value ),
+      do_not_bind_functions_with_nonconst_ref);
+
+  // For methods, we need to be careful for parameter 1.  We do not require
+  // a scoped_refptr because BindState<> itself takes care of AddRef() for
+  // methods. We also disallow binding of an array as the method's target
+  // object.
+  COMPILE_ASSERT(
+      cef_internal::HasIsMethodTag<RunnableType>::value ||
+          !cef_internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
+      p1_is_refcounted_type_and_needs_scoped_refptr);
+  COMPILE_ASSERT(!cef_internal::HasIsMethodTag<RunnableType>::value ||
+                     !is_array<P1>::value,
+                 first_bound_argument_to_method_cannot_be_array);
+  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
+                 p2_is_refcounted_type_and_needs_scoped_refptr);
+  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P3>::value,
+                 p3_is_refcounted_type_and_needs_scoped_refptr);
+  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P4>::value,
+                 p4_is_refcounted_type_and_needs_scoped_refptr);
+  typedef cef_internal::BindState<RunnableType, RunType,
+      void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
+      typename cef_internal::CallbackParamTraits<P2>::StorageType,
+      typename cef_internal::CallbackParamTraits<P3>::StorageType,
+      typename cef_internal::CallbackParamTraits<P4>::StorageType)> BindState;
+
+
+  return Callback<typename BindState::UnboundRunType>(
+      new BindState(cef_internal::MakeRunnable(functor), p1, p2, p3, p4));
+}
+
+template <typename Functor, typename P1, typename P2, typename P3, typename P4,
+    typename P5>
+base::Callback<
+    typename cef_internal::BindState<
+        typename cef_internal::FunctorTraits<Functor>::RunnableType,
+        typename cef_internal::FunctorTraits<Functor>::RunType,
+        void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
+            typename cef_internal::CallbackParamTraits<P2>::StorageType,
+            typename cef_internal::CallbackParamTraits<P3>::StorageType,
+            typename cef_internal::CallbackParamTraits<P4>::StorageType,
+            typename cef_internal::CallbackParamTraits<P5>::StorageType)>
+            ::UnboundRunType>
+Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4,
+    const P5& p5) {
+  // Typedefs for how to store and run the functor.
+  typedef typename cef_internal::FunctorTraits<Functor>::RunnableType RunnableType;
+  typedef typename cef_internal::FunctorTraits<Functor>::RunType RunType;
+
+  // Use RunnableType::RunType instead of RunType above because our
+  // checks should below for bound references need to know what the actual
+  // functor is going to interpret the argument as.
+  typedef cef_internal::FunctionTraits<typename RunnableType::RunType>
+      BoundFunctorTraits;
+
+  // Do not allow binding a non-const reference parameter. Non-const reference
+  // parameters are disallowed by the Google style guide.  Also, binding a
+  // non-const reference parameter can make for subtle bugs because the
+  // invoked function will receive a reference to the stored copy of the
+  // argument and not the original.
+  COMPILE_ASSERT(
+      !(is_non_const_reference<typename BoundFunctorTraits::A1Type>::value ||
+          is_non_const_reference<typename BoundFunctorTraits::A2Type>::value ||
+          is_non_const_reference<typename BoundFunctorTraits::A3Type>::value ||
+          is_non_const_reference<typename BoundFunctorTraits::A4Type>::value ||
+          is_non_const_reference<typename BoundFunctorTraits::A5Type>::value ),
+      do_not_bind_functions_with_nonconst_ref);
+
+  // For methods, we need to be careful for parameter 1.  We do not require
+  // a scoped_refptr because BindState<> itself takes care of AddRef() for
+  // methods. We also disallow binding of an array as the method's target
+  // object.
+  COMPILE_ASSERT(
+      cef_internal::HasIsMethodTag<RunnableType>::value ||
+          !cef_internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
+      p1_is_refcounted_type_and_needs_scoped_refptr);
+  COMPILE_ASSERT(!cef_internal::HasIsMethodTag<RunnableType>::value ||
+                     !is_array<P1>::value,
+                 first_bound_argument_to_method_cannot_be_array);
+  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
+                 p2_is_refcounted_type_and_needs_scoped_refptr);
+  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P3>::value,
+                 p3_is_refcounted_type_and_needs_scoped_refptr);
+  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P4>::value,
+                 p4_is_refcounted_type_and_needs_scoped_refptr);
+  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P5>::value,
+                 p5_is_refcounted_type_and_needs_scoped_refptr);
+  typedef cef_internal::BindState<RunnableType, RunType,
+      void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
+      typename cef_internal::CallbackParamTraits<P2>::StorageType,
+      typename cef_internal::CallbackParamTraits<P3>::StorageType,
+      typename cef_internal::CallbackParamTraits<P4>::StorageType,
+      typename cef_internal::CallbackParamTraits<P5>::StorageType)> BindState;
+
+
+  return Callback<typename BindState::UnboundRunType>(
+      new BindState(cef_internal::MakeRunnable(functor), p1, p2, p3, p4, p5));
+}
+
+template <typename Functor, typename P1, typename P2, typename P3, typename P4,
+    typename P5, typename P6>
+base::Callback<
+    typename cef_internal::BindState<
+        typename cef_internal::FunctorTraits<Functor>::RunnableType,
+        typename cef_internal::FunctorTraits<Functor>::RunType,
+        void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
+            typename cef_internal::CallbackParamTraits<P2>::StorageType,
+            typename cef_internal::CallbackParamTraits<P3>::StorageType,
+            typename cef_internal::CallbackParamTraits<P4>::StorageType,
+            typename cef_internal::CallbackParamTraits<P5>::StorageType,
+            typename cef_internal::CallbackParamTraits<P6>::StorageType)>
+            ::UnboundRunType>
+Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4,
+    const P5& p5, const P6& p6) {
+  // Typedefs for how to store and run the functor.
+  typedef typename cef_internal::FunctorTraits<Functor>::RunnableType RunnableType;
+  typedef typename cef_internal::FunctorTraits<Functor>::RunType RunType;
+
+  // Use RunnableType::RunType instead of RunType above because our
+  // checks should below for bound references need to know what the actual
+  // functor is going to interpret the argument as.
+  typedef cef_internal::FunctionTraits<typename RunnableType::RunType>
+      BoundFunctorTraits;
+
+  // Do not allow binding a non-const reference parameter. Non-const reference
+  // parameters are disallowed by the Google style guide.  Also, binding a
+  // non-const reference parameter can make for subtle bugs because the
+  // invoked function will receive a reference to the stored copy of the
+  // argument and not the original.
+  COMPILE_ASSERT(
+      !(is_non_const_reference<typename BoundFunctorTraits::A1Type>::value ||
+          is_non_const_reference<typename BoundFunctorTraits::A2Type>::value ||
+          is_non_const_reference<typename BoundFunctorTraits::A3Type>::value ||
+          is_non_const_reference<typename BoundFunctorTraits::A4Type>::value ||
+          is_non_const_reference<typename BoundFunctorTraits::A5Type>::value ||
+          is_non_const_reference<typename BoundFunctorTraits::A6Type>::value ),
+      do_not_bind_functions_with_nonconst_ref);
+
+  // For methods, we need to be careful for parameter 1.  We do not require
+  // a scoped_refptr because BindState<> itself takes care of AddRef() for
+  // methods. We also disallow binding of an array as the method's target
+  // object.
+  COMPILE_ASSERT(
+      cef_internal::HasIsMethodTag<RunnableType>::value ||
+          !cef_internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
+      p1_is_refcounted_type_and_needs_scoped_refptr);
+  COMPILE_ASSERT(!cef_internal::HasIsMethodTag<RunnableType>::value ||
+                     !is_array<P1>::value,
+                 first_bound_argument_to_method_cannot_be_array);
+  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
+                 p2_is_refcounted_type_and_needs_scoped_refptr);
+  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P3>::value,
+                 p3_is_refcounted_type_and_needs_scoped_refptr);
+  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P4>::value,
+                 p4_is_refcounted_type_and_needs_scoped_refptr);
+  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P5>::value,
+                 p5_is_refcounted_type_and_needs_scoped_refptr);
+  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P6>::value,
+                 p6_is_refcounted_type_and_needs_scoped_refptr);
+  typedef cef_internal::BindState<RunnableType, RunType,
+      void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
+      typename cef_internal::CallbackParamTraits<P2>::StorageType,
+      typename cef_internal::CallbackParamTraits<P3>::StorageType,
+      typename cef_internal::CallbackParamTraits<P4>::StorageType,
+      typename cef_internal::CallbackParamTraits<P5>::StorageType,
+      typename cef_internal::CallbackParamTraits<P6>::StorageType)> BindState;
+
+
+  return Callback<typename BindState::UnboundRunType>(
+      new BindState(cef_internal::MakeRunnable(functor), p1, p2, p3, p4, p5, p6));
+}
+
+template <typename Functor, typename P1, typename P2, typename P3, typename P4,
+    typename P5, typename P6, typename P7>
+base::Callback<
+    typename cef_internal::BindState<
+        typename cef_internal::FunctorTraits<Functor>::RunnableType,
+        typename cef_internal::FunctorTraits<Functor>::RunType,
+        void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
+            typename cef_internal::CallbackParamTraits<P2>::StorageType,
+            typename cef_internal::CallbackParamTraits<P3>::StorageType,
+            typename cef_internal::CallbackParamTraits<P4>::StorageType,
+            typename cef_internal::CallbackParamTraits<P5>::StorageType,
+            typename cef_internal::CallbackParamTraits<P6>::StorageType,
+            typename cef_internal::CallbackParamTraits<P7>::StorageType)>
+            ::UnboundRunType>
+Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4,
+    const P5& p5, const P6& p6, const P7& p7) {
+  // Typedefs for how to store and run the functor.
+  typedef typename cef_internal::FunctorTraits<Functor>::RunnableType RunnableType;
+  typedef typename cef_internal::FunctorTraits<Functor>::RunType RunType;
+
+  // Use RunnableType::RunType instead of RunType above because our
+  // checks should below for bound references need to know what the actual
+  // functor is going to interpret the argument as.
+  typedef cef_internal::FunctionTraits<typename RunnableType::RunType>
+      BoundFunctorTraits;
+
+  // Do not allow binding a non-const reference parameter. Non-const reference
+  // parameters are disallowed by the Google style guide.  Also, binding a
+  // non-const reference parameter can make for subtle bugs because the
+  // invoked function will receive a reference to the stored copy of the
+  // argument and not the original.
+  COMPILE_ASSERT(
+      !(is_non_const_reference<typename BoundFunctorTraits::A1Type>::value ||
+          is_non_const_reference<typename BoundFunctorTraits::A2Type>::value ||
+          is_non_const_reference<typename BoundFunctorTraits::A3Type>::value ||
+          is_non_const_reference<typename BoundFunctorTraits::A4Type>::value ||
+          is_non_const_reference<typename BoundFunctorTraits::A5Type>::value ||
+          is_non_const_reference<typename BoundFunctorTraits::A6Type>::value ||
+          is_non_const_reference<typename BoundFunctorTraits::A7Type>::value ),
+      do_not_bind_functions_with_nonconst_ref);
+
+  // For methods, we need to be careful for parameter 1.  We do not require
+  // a scoped_refptr because BindState<> itself takes care of AddRef() for
+  // methods. We also disallow binding of an array as the method's target
+  // object.
+  COMPILE_ASSERT(
+      cef_internal::HasIsMethodTag<RunnableType>::value ||
+          !cef_internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
+      p1_is_refcounted_type_and_needs_scoped_refptr);
+  COMPILE_ASSERT(!cef_internal::HasIsMethodTag<RunnableType>::value ||
+                     !is_array<P1>::value,
+                 first_bound_argument_to_method_cannot_be_array);
+  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
+                 p2_is_refcounted_type_and_needs_scoped_refptr);
+  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P3>::value,
+                 p3_is_refcounted_type_and_needs_scoped_refptr);
+  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P4>::value,
+                 p4_is_refcounted_type_and_needs_scoped_refptr);
+  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P5>::value,
+                 p5_is_refcounted_type_and_needs_scoped_refptr);
+  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P6>::value,
+                 p6_is_refcounted_type_and_needs_scoped_refptr);
+  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P7>::value,
+                 p7_is_refcounted_type_and_needs_scoped_refptr);
+  typedef cef_internal::BindState<RunnableType, RunType,
+      void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
+      typename cef_internal::CallbackParamTraits<P2>::StorageType,
+      typename cef_internal::CallbackParamTraits<P3>::StorageType,
+      typename cef_internal::CallbackParamTraits<P4>::StorageType,
+      typename cef_internal::CallbackParamTraits<P5>::StorageType,
+      typename cef_internal::CallbackParamTraits<P6>::StorageType,
+      typename cef_internal::CallbackParamTraits<P7>::StorageType)> BindState;
+
+
+  return Callback<typename BindState::UnboundRunType>(
+      new BindState(cef_internal::MakeRunnable(functor), p1, p2, p3, p4, p5, p6,
+          p7));
+}
+
+}  // namespace base
+
+#endif  // !BUILDING_CEF_SHARED
+
+#endif  // CEF_INCLUDE_BASE_CEF_BIND_H_
diff --git a/src/include/libcef_/base/cef_bind_helpers.h b/src/include/libcef_/base/cef_bind_helpers.h
new file mode 100644
index 0000000..6cff2c5
--- /dev/null
+++ b/src/include/libcef_/base/cef_bind_helpers.h
@@ -0,0 +1,586 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2011
+// Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// This defines a set of argument wrappers and related factory methods that
+// can be used specify the refcounting and reference semantics of arguments
+// that are bound by the Bind() function in base/bind.h.
+//
+// It also defines a set of simple functions and utilities that people want
+// when using Callback<> and Bind().
+//
+//
+// ARGUMENT BINDING WRAPPERS
+//
+// The wrapper functions are base::Unretained(), base::Owned(), base::Passed(),
+// base::ConstRef(), and base::IgnoreResult().
+//
+// Unretained() allows Bind() to bind a non-refcounted class, and to disable
+// refcounting on arguments that are refcounted objects.
+//
+// Owned() transfers ownership of an object to the Callback resulting from
+// bind; the object will be deleted when the Callback is deleted.
+//
+// Passed() is for transferring movable-but-not-copyable types (eg. scoped_ptr)
+// through a Callback. Logically, this signifies a destructive transfer of
+// the state of the argument into the target function.  Invoking
+// Callback::Run() twice on a Callback that was created with a Passed()
+// argument will CHECK() because the first invocation would have already
+// transferred ownership to the target function.
+//
+// ConstRef() allows binding a constant reference to an argument rather
+// than a copy.
+//
+// IgnoreResult() is used to adapt a function or Callback with a return type to
+// one with a void return. This is most useful if you have a function with,
+// say, a pesky ignorable bool return that you want to use with PostTask or
+// something else that expect a Callback with a void return.
+//
+// EXAMPLE OF Unretained():
+//
+//   class Foo {
+//    public:
+//     void func() { cout << "Foo:f" << endl; }
+//   };
+//
+//   // In some function somewhere.
+//   Foo foo;
+//   Closure foo_callback =
+//       Bind(&Foo::func, Unretained(&foo));
+//   foo_callback.Run();  // Prints "Foo:f".
+//
+// Without the Unretained() wrapper on |&foo|, the above call would fail
+// to compile because Foo does not support the AddRef() and Release() methods.
+//
+//
+// EXAMPLE OF Owned():
+//
+//   void foo(int* arg) { cout << *arg << endl }
+//
+//   int* pn = new int(1);
+//   Closure foo_callback = Bind(&foo, Owned(pn));
+//
+//   foo_callback.Run();  // Prints "1"
+//   foo_callback.Run();  // Prints "1"
+//   *n = 2;
+//   foo_callback.Run();  // Prints "2"
+//
+//   foo_callback.Reset();  // |pn| is deleted.  Also will happen when
+//                          // |foo_callback| goes out of scope.
+//
+// Without Owned(), someone would have to know to delete |pn| when the last
+// reference to the Callback is deleted.
+//
+//
+// EXAMPLE OF ConstRef():
+//
+//   void foo(int arg) { cout << arg << endl }
+//
+//   int n = 1;
+//   Closure no_ref = Bind(&foo, n);
+//   Closure has_ref = Bind(&foo, ConstRef(n));
+//
+//   no_ref.Run();  // Prints "1"
+//   has_ref.Run();  // Prints "1"
+//
+//   n = 2;
+//   no_ref.Run();  // Prints "1"
+//   has_ref.Run();  // Prints "2"
+//
+// Note that because ConstRef() takes a reference on |n|, |n| must outlive all
+// its bound callbacks.
+//
+//
+// EXAMPLE OF IgnoreResult():
+//
+//   int DoSomething(int arg) { cout << arg << endl; }
+//
+//   // Assign to a Callback with a void return type.
+//   Callback<void(int)> cb = Bind(IgnoreResult(&DoSomething));
+//   cb->Run(1);  // Prints "1".
+//
+//   // Prints "1" on |ml|.
+//   ml->PostTask(FROM_HERE, Bind(IgnoreResult(&DoSomething), 1);
+//
+//
+// EXAMPLE OF Passed():
+//
+//   void TakesOwnership(scoped_ptr<Foo> arg) { }
+//   scoped_ptr<Foo> CreateFoo() { return scoped_ptr<Foo>(new Foo()); }
+//
+//   scoped_ptr<Foo> f(new Foo());
+//
+//   // |cb| is given ownership of Foo(). |f| is now NULL.
+//   // You can use f.Pass() in place of &f, but it's more verbose.
+//   Closure cb = Bind(&TakesOwnership, Passed(&f));
+//
+//   // Run was never called so |cb| still owns Foo() and deletes
+//   // it on Reset().
+//   cb.Reset();
+//
+//   // |cb| is given a new Foo created by CreateFoo().
+//   cb = Bind(&TakesOwnership, Passed(CreateFoo()));
+//
+//   // |arg| in TakesOwnership() is given ownership of Foo(). |cb|
+//   // no longer owns Foo() and, if reset, would not delete Foo().
+//   cb.Run();  // Foo() is now transferred to |arg| and deleted.
+//   cb.Run();  // This CHECK()s since Foo() already been used once.
+//
+// Passed() is particularly useful with PostTask() when you are transferring
+// ownership of an argument into a task, but don't necessarily know if the
+// task will always be executed. This can happen if the task is cancellable
+// or if it is posted to a MessageLoopProxy.
+//
+//
+// SIMPLE FUNCTIONS AND UTILITIES.
+//
+//   DoNothing() - Useful for creating a Closure that does nothing when called.
+//   DeletePointer<T>() - Useful for creating a Closure that will delete a
+//                        pointer when invoked. Only use this when necessary.
+//                        In most cases MessageLoop::DeleteSoon() is a better
+//                        fit.
+
+#ifndef CEF_INCLUDE_BASE_CEF_BIND_HELPERS_H_
+#define CEF_INCLUDE_BASE_CEF_BIND_HELPERS_H_
+#pragma once
+
+#if defined(BASE_BIND_HELPERS_H_)
+// Do nothing if the Chromium header has already been included.
+// This can happen in cases where Chromium code is used directly by the
+// client application. When using Chromium code directly always include
+// the Chromium header first to avoid type conflicts.
+#elif defined(BUILDING_CEF_SHARED)
+// When building CEF include the Chromium header directly.
+#include "base/bind_helpers.h"
+#else  // !BUILDING_CEF_SHARED
+// The following is substantially similar to the Chromium implementation.
+// If the Chromium implementation diverges the below implementation should be
+// updated to match.
+
+#include"libcef/base/cef_basictypes.h"
+#include"libcef/base/cef_callback.h"
+#include"libcef/base/cef_template_util.h"
+#include"libcef/base/cef_weak_ptr.h"
+
+namespace base {
+namespace cef_internal {
+
+// Use the Substitution Failure Is Not An Error (SFINAE) trick to inspect T
+// for the existence of AddRef() and Release() functions of the correct
+// signature.
+//
+// http://en.wikipedia.org/wiki/Substitution_failure_is_not_an_error
+// http://stackoverflow.com/questions/257288/is-it-possible-to-write-a-c-template-to-check-for-a-functions-existence
+// http://stackoverflow.com/questions/4358584/sfinae-approach-comparison
+// http://stackoverflow.com/questions/1966362/sfinae-to-check-for-inherited-member-functions
+//
+// The last link in particular show the method used below.
+//
+// For SFINAE to work with inherited methods, we need to pull some extra tricks
+// with multiple inheritance.  In the more standard formulation, the overloads
+// of Check would be:
+//
+//   template <typename C>
+//   Yes NotTheCheckWeWant(Helper<&C::TargetFunc>*);
+//
+//   template <typename C>
+//   No NotTheCheckWeWant(...);
+//
+//   static const bool value = sizeof(NotTheCheckWeWant<T>(0)) == sizeof(Yes);
+//
+// The problem here is that template resolution will not match
+// C::TargetFunc if TargetFunc does not exist directly in C.  That is, if
+// TargetFunc in inherited from an ancestor, &C::TargetFunc will not match,
+// |value| will be false.  This formulation only checks for whether or
+// not TargetFunc exist directly in the class being introspected.
+//
+// To get around this, we play a dirty trick with multiple inheritance.
+// First, We create a class BaseMixin that declares each function that we
+// want to probe for.  Then we create a class Base that inherits from both T
+// (the class we wish to probe) and BaseMixin.  Note that the function
+// signature in BaseMixin does not need to match the signature of the function
+// we are probing for; thus it's easiest to just use void(void).
+//
+// Now, if TargetFunc exists somewhere in T, then &Base::TargetFunc has an
+// ambiguous resolution between BaseMixin and T.  This lets us write the
+// following:
+//
+//   template <typename C>
+//   No GoodCheck(Helper<&C::TargetFunc>*);
+//
+//   template <typename C>
+//   Yes GoodCheck(...);
+//
+//   static const bool value = sizeof(GoodCheck<Base>(0)) == sizeof(Yes);
+//
+// Notice here that the variadic version of GoodCheck() returns Yes here
+// instead of No like the previous one. Also notice that we calculate |value|
+// by specializing GoodCheck() on Base instead of T.
+//
+// We've reversed the roles of the variadic, and Helper overloads.
+// GoodCheck(Helper<&C::TargetFunc>*), when C = Base, fails to be a valid
+// substitution if T::TargetFunc exists. Thus GoodCheck<Base>(0) will resolve
+// to the variadic version if T has TargetFunc.  If T::TargetFunc does not
+// exist, then &C::TargetFunc is not ambiguous, and the overload resolution
+// will prefer GoodCheck(Helper<&C::TargetFunc>*).
+//
+// This method of SFINAE will correctly probe for inherited names, but it cannot
+// typecheck those names.  It's still a good enough sanity check though.
+//
+// Works on gcc-4.2, gcc-4.4, and Visual Studio 2008.
+//
+// TODO(ajwong): Move to ref_counted.h or template_util.h when we've vetted
+// this works well.
+//
+// TODO(ajwong): Make this check for Release() as well.
+// See http://crbug.com/82038.
+template <typename T>
+class SupportsAddRefAndRelease {
+  typedef char Yes[1];
+  typedef char No[2];
+
+  struct BaseMixin {
+    void AddRef();
+  };
+
+// MSVC warns when you try to use Base if T has a private destructor, the
+// common pattern for refcounted types. It does this even though no attempt to
+// instantiate Base is made.  We disable the warning for this definition.
+#if defined(OS_WIN)
+#pragma warning(push)
+#pragma warning(disable:4624)
+#endif
+  struct Base : public T, public BaseMixin {
+  };
+#if defined(OS_WIN)
+#pragma warning(pop)
+#endif
+
+  template <void(BaseMixin::*)(void)> struct Helper {};
+
+  template <typename C>
+  static No& Check(Helper<&C::AddRef>*);
+
+  template <typename >
+  static Yes& Check(...);
+
+ public:
+  static const bool value = sizeof(Check<Base>(0)) == sizeof(Yes);
+};
+
+// Helpers to assert that arguments of a recounted type are bound with a
+// scoped_refptr.
+template <bool IsClasstype, typename T>
+struct UnsafeBindtoRefCountedArgHelper : false_type {
+};
+
+template <typename T>
+struct UnsafeBindtoRefCountedArgHelper<true, T>
+    : integral_constant<bool, SupportsAddRefAndRelease<T>::value> {
+};
+
+template <typename T>
+struct UnsafeBindtoRefCountedArg : false_type {
+};
+
+template <typename T>
+struct UnsafeBindtoRefCountedArg<T*>
+    : UnsafeBindtoRefCountedArgHelper<is_class<T>::value, T> {
+};
+
+template <typename T>
+class HasIsMethodTag {
+  typedef char Yes[1];
+  typedef char No[2];
+
+  template <typename U>
+  static Yes& Check(typename U::IsMethod*);
+
+  template <typename U>
+  static No& Check(...);
+
+ public:
+  static const bool value = sizeof(Check<T>(0)) == sizeof(Yes);
+};
+
+template <typename T>
+class UnretainedWrapper {
+ public:
+  explicit UnretainedWrapper(T* o) : ptr_(o) {}
+  T* get() const { return ptr_; }
+ private:
+  T* ptr_;
+};
+
+template <typename T>
+class ConstRefWrapper {
+ public:
+  explicit ConstRefWrapper(const T& o) : ptr_(&o) {}
+  const T& get() const { return *ptr_; }
+ private:
+  const T* ptr_;
+};
+
+template <typename T>
+struct IgnoreResultHelper {
+  explicit IgnoreResultHelper(T functor) : functor_(functor) {}
+
+  T functor_;
+};
+
+template <typename T>
+struct IgnoreResultHelper<Callback<T> > {
+  explicit IgnoreResultHelper(const Callback<T>& functor) : functor_(functor) {}
+
+  const Callback<T>& functor_;
+};
+
+// An alternate implementation is to avoid the destructive copy, and instead
+// specialize ParamTraits<> for OwnedWrapper<> to change the StorageType to
+// a class that is essentially a scoped_ptr<>.
+//
+// The current implementation has the benefit though of leaving ParamTraits<>
+// fully in callback_internal.h as well as avoiding type conversions during
+// storage.
+template <typename T>
+class OwnedWrapper {
+ public:
+  explicit OwnedWrapper(T* o) : ptr_(o) {}
+  ~OwnedWrapper() { delete ptr_; }
+  T* get() const { return ptr_; }
+  OwnedWrapper(const OwnedWrapper& other) {
+    ptr_ = other.ptr_;
+    other.ptr_ = NULL;
+  }
+
+ private:
+  mutable T* ptr_;
+};
+
+// PassedWrapper is a copyable adapter for a scoper that ignores const.
+//
+// It is needed to get around the fact that Bind() takes a const reference to
+// all its arguments.  Because Bind() takes a const reference to avoid
+// unnecessary copies, it is incompatible with movable-but-not-copyable
+// types; doing a destructive "move" of the type into Bind() would violate
+// the const correctness.
+//
+// This conundrum cannot be solved without either C++11 rvalue references or
+// a O(2^n) blowup of Bind() templates to handle each combination of regular
+// types and movable-but-not-copyable types.  Thus we introduce a wrapper type
+// that is copyable to transmit the correct type information down into
+// BindState<>. Ignoring const in this type makes sense because it is only
+// created when we are explicitly trying to do a destructive move.
+//
+// Two notes:
+//  1) PassedWrapper supports any type that has a "Pass()" function.
+//     This is intentional. The whitelisting of which specific types we
+//     support is maintained by CallbackParamTraits<>.
+//  2) is_valid_ is distinct from NULL because it is valid to bind a "NULL"
+//     scoper to a Callback and allow the Callback to execute once.
+template <typename T>
+class PassedWrapper {
+ public:
+  explicit PassedWrapper(T scoper) : is_valid_(true), scoper_(scoper.Pass()) {}
+  PassedWrapper(const PassedWrapper& other)
+      : is_valid_(other.is_valid_), scoper_(other.scoper_.Pass()) {
+  }
+  T Pass() const {
+    CHECK(is_valid_);
+    is_valid_ = false;
+    return scoper_.Pass();
+  }
+
+ private:
+  mutable bool is_valid_;
+  mutable T scoper_;
+};
+
+// Unwrap the stored parameters for the wrappers above.
+template <typename T>
+struct UnwrapTraits {
+  typedef const T& ForwardType;
+  static ForwardType Unwrap(const T& o) { return o; }
+};
+
+template <typename T>
+struct UnwrapTraits<UnretainedWrapper<T> > {
+  typedef T* ForwardType;
+  static ForwardType Unwrap(UnretainedWrapper<T> unretained) {
+    return unretained.get();
+  }
+};
+
+template <typename T>
+struct UnwrapTraits<ConstRefWrapper<T> > {
+  typedef const T& ForwardType;
+  static ForwardType Unwrap(ConstRefWrapper<T> const_ref) {
+    return const_ref.get();
+  }
+};
+
+template <typename T>
+struct UnwrapTraits<scoped_refptr<T> > {
+  typedef T* ForwardType;
+  static ForwardType Unwrap(const scoped_refptr<T>& o) { return o.get(); }
+};
+
+template <typename T>
+struct UnwrapTraits<WeakPtr<T> > {
+  typedef const WeakPtr<T>& ForwardType;
+  static ForwardType Unwrap(const WeakPtr<T>& o) { return o; }
+};
+
+template <typename T>
+struct UnwrapTraits<OwnedWrapper<T> > {
+  typedef T* ForwardType;
+  static ForwardType Unwrap(const OwnedWrapper<T>& o) {
+    return o.get();
+  }
+};
+
+template <typename T>
+struct UnwrapTraits<PassedWrapper<T> > {
+  typedef T ForwardType;
+  static T Unwrap(PassedWrapper<T>& o) {
+    return o.Pass();
+  }
+};
+
+// Utility for handling different refcounting semantics in the Bind()
+// function.
+template <bool is_method, typename T>
+struct MaybeRefcount;
+
+template <typename T>
+struct MaybeRefcount<false, T> {
+  static void AddRef(const T&) {}
+  static void Release(const T&) {}
+};
+
+template <typename T, size_t n>
+struct MaybeRefcount<false, T[n]> {
+  static void AddRef(const T*) {}
+  static void Release(const T*) {}
+};
+
+template <typename T>
+struct MaybeRefcount<true, T> {
+  static void AddRef(const T&) {}
+  static void Release(const T&) {}
+};
+
+template <typename T>
+struct MaybeRefcount<true, T*> {
+  static void AddRef(T* o) { o->AddRef(); }
+  static void Release(T* o) { o->Release(); }
+};
+
+// No need to additionally AddRef() and Release() since we are storing a
+// scoped_refptr<> inside the storage object already.
+template <typename T>
+struct MaybeRefcount<true, scoped_refptr<T> > {
+  static void AddRef(const scoped_refptr<T>& o) {}
+  static void Release(const scoped_refptr<T>& o) {}
+};
+
+template <typename T>
+struct MaybeRefcount<true, const T*> {
+  static void AddRef(const T* o) { o->AddRef(); }
+  static void Release(const T* o) { o->Release(); }
+};
+
+// IsWeakMethod is a helper that determine if we are binding a WeakPtr<> to a
+// method.  It is used internally by Bind() to select the correct
+// InvokeHelper that will no-op itself in the event the WeakPtr<> for
+// the target object is invalidated.
+//
+// P1 should be the type of the object that will be received of the method.
+template <bool IsMethod, typename P1>
+struct IsWeakMethod : public false_type {};
+
+template <typename T>
+struct IsWeakMethod<true, WeakPtr<T> > : public true_type {};
+
+template <typename T>
+struct IsWeakMethod<true, ConstRefWrapper<WeakPtr<T> > > : public true_type {};
+
+}  // namespace cef_internal
+
+template <typename T>
+static inline cef_internal::UnretainedWrapper<T> Unretained(T* o) {
+  return cef_internal::UnretainedWrapper<T>(o);
+}
+
+template <typename T>
+static inline cef_internal::ConstRefWrapper<T> ConstRef(const T& o) {
+  return cef_internal::ConstRefWrapper<T>(o);
+}
+
+template <typename T>
+static inline cef_internal::OwnedWrapper<T> Owned(T* o) {
+  return cef_internal::OwnedWrapper<T>(o);
+}
+
+// We offer 2 syntaxes for calling Passed().  The first takes a temporary and
+// is best suited for use with the return value of a function. The second
+// takes a pointer to the scoper and is just syntactic sugar to avoid having
+// to write Passed(scoper.Pass()).
+template <typename T>
+static inline cef_internal::PassedWrapper<T> Passed(T scoper) {
+  return cef_internal::PassedWrapper<T>(scoper.Pass());
+}
+template <typename T>
+static inline cef_internal::PassedWrapper<T> Passed(T* scoper) {
+  return cef_internal::PassedWrapper<T>(scoper->Pass());
+}
+
+template <typename T>
+static inline cef_internal::IgnoreResultHelper<T> IgnoreResult(T data) {
+  return cef_internal::IgnoreResultHelper<T>(data);
+}
+
+template <typename T>
+static inline cef_internal::IgnoreResultHelper<Callback<T> >
+IgnoreResult(const Callback<T>& data) {
+  return cef_internal::IgnoreResultHelper<Callback<T> >(data);
+}
+
+void DoNothing();
+
+template<typename T>
+void DeletePointer(T* obj) {
+  delete obj;
+}
+
+}  // namespace base
+
+#endif  // !BUILDING_CEF_SHARED
+
+#endif  // CEF_INCLUDE_BASE_CEF_BIND_HELPERS_H_
diff --git a/src/include/libcef_/base/cef_build.h b/src/include/libcef_/base/cef_build.h
new file mode 100644
index 0000000..2680de0
--- /dev/null
+++ b/src/include/libcef_/base/cef_build.h
@@ -0,0 +1,197 @@
+// Copyright (c) 2011 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+#ifndef CEF_INCLUDE_BASE_CEF_BUILD_H_
+#define CEF_INCLUDE_BASE_CEF_BUILD_H_
+#pragma once
+
+#if defined(BUILDING_CEF_SHARED)
+    // When building CEF include the Chromium header directly.
+    #include"base/compiler_specific.h"
+#else  // !BUILDING_CEF_SHARED
+    // The following is substantially similar to the Chromium implementation.
+    // If the Chromium implementation diverges the below implementation should be
+    // updated to match.
+
+    #if defined(_WIN32)
+        #ifndef OS_WIN
+            #define OS_WIN 1
+        #endif
+    #elif defined(__APPLE__)
+        #ifndef OS_MACOSX
+            #define OS_MACOSX 1
+        #endif
+    #elif defined(__linux__)
+        #ifndef OS_LINUX
+            #define OS_LINUX 1
+        #endif
+    #else
+        #error Please add support for your platform in cef_build.h
+    #endif
+
+    // For access to standard POSIXish features, use OS_POSIX instead of a
+    // more specific macro.
+    #if defined(OS_MACOSX) || defined(OS_LINUX)
+        #ifndef OS_POSIX
+            #define OS_POSIX 1
+        #endif
+    #endif
+
+    // Compiler detection.
+    #if defined(__GNUC__)
+        #ifndef COMPILER_GCC
+            #define COMPILER_GCC 1
+        #endif
+    #elif defined(_MSC_VER)
+        #ifndef COMPILER_MSVC
+            #define COMPILER_MSVC 1
+        #endif
+    #elif defined(__WATCOMC__)
+        #ifndef COMPILER_WATCOMC
+            #define COMPILER_WATCOMC 1
+        #endif
+    #else
+        #error Please add support for your compiler in cef_build.h
+    #endif
+
+    // Processor architecture detection.  For more info on what's defined, see:
+    //   http://msdn.microsoft.com/en-us/library/b0084kay.aspx
+    //   http://www.agner.org/optimize/calling_conventions.pdf
+    //   or with gcc, run: "echo | gcc -E -dM -"
+    #if defined(_M_X64) || defined(__x86_64__)
+        #define ARCH_CPU_X86_FAMILY 1
+        #define ARCH_CPU_X86_64 1
+        #define ARCH_CPU_64_BITS 1
+        #define ARCH_CPU_LITTLE_ENDIAN 1
+    #elif defined(_M_IX86) || defined(__i386__)
+        #define ARCH_CPU_X86_FAMILY 1
+        #define ARCH_CPU_X86 1
+        #define ARCH_CPU_32_BITS 1
+        #define ARCH_CPU_LITTLE_ENDIAN 1
+    #elif defined(__ARMEL__)
+        #define ARCH_CPU_ARM_FAMILY 1
+        #define ARCH_CPU_ARMEL 1
+        #define ARCH_CPU_32_BITS 1
+        #define ARCH_CPU_LITTLE_ENDIAN 1
+    #elif defined(__aarch64__)
+        #define ARCH_CPU_ARM_FAMILY 1
+        #define ARCH_CPU_ARM64 1
+        #define ARCH_CPU_64_BITS 1
+        #define ARCH_CPU_LITTLE_ENDIAN 1
+    #elif defined(__pnacl__)
+        #define ARCH_CPU_32_BITS 1
+        #define ARCH_CPU_LITTLE_ENDIAN 1
+    #elif defined(__MIPSEL__)
+        #define ARCH_CPU_MIPS_FAMILY 1
+        #define ARCH_CPU_MIPSEL 1
+        #define ARCH_CPU_32_BITS 1
+        #define ARCH_CPU_LITTLE_ENDIAN 1
+    #else
+        #error Please add support for your architecture in cef_build.h
+    #endif
+
+    // Type detection for wchar_t.
+    #if defined(OS_WIN)
+        #define WCHAR_T_IS_UTF16
+    #elif defined(OS_POSIX) && defined(COMPILER_GCC) && \
+        defined(__WCHAR_MAX__) && \
+        (__WCHAR_MAX__ == 0x7fffffff || __WCHAR_MAX__ == 0xffffffff)
+        #define WCHAR_T_IS_UTF32
+    #elif defined(OS_POSIX) && defined(COMPILER_GCC) && \
+        defined(__WCHAR_MAX__) && \
+        (__WCHAR_MAX__ == 0x7fff || __WCHAR_MAX__ == 0xffff)
+    // On Posix, we'll detect short wchar_t, but projects aren't guaranteed to
+    // compile in this mode (in particular, Chrome doesn't). This is intended for
+    // other projects using base who manage their own dependencies and make sure
+    // short wchar works for them.
+        #define WCHAR_T_IS_UTF16
+    #else
+        #error Please add support for your compiler in cef_build.h
+    #endif
+
+    // Annotate a function indicating the caller must examine the return value.
+    // Use like:
+    //   int foo() WARN_UNUSED_RESULT;
+    // To explicitly ignore a result, see |ignore_result()| in <base/macros.h>.
+    #ifndef WARN_UNUSED_RESULT
+        #if defined(COMPILER_GCC)
+            #define WARN_UNUSED_RESULT __attribute__((warn_unused_result))
+        #else
+            #define WARN_UNUSED_RESULT
+        #endif
+    #endif  // WARN_UNUSED_RESULT
+
+
+    // Annotate a typedef or function indicating it's ok if it's not used.
+    // Use like:
+    //   typedef Foo Bar ALLOW_UNUSED_TYPE;
+    #ifndef ALLOW_UNUSED_TYPE
+        #if defined(COMPILER_GCC)
+            #define ALLOW_UNUSED_TYPE __attribute__((unused))
+        #else
+            #define ALLOW_UNUSED_TYPE
+        #endif
+    #endif  // ALLOW_UNUSED_TYPE
+
+    // Annotate a variable indicating it's ok if the variable is not used.
+    // (Typically used to silence a compiler warning when the assignment
+    // is important for some other reason.)
+    // Use like:
+    //   int x = ...;
+    //   ALLOW_UNUSED_LOCAL(x);
+    #ifndef ALLOW_UNUSED_LOCAL
+        #define ALLOW_UNUSED_LOCAL(x) false ? (void)x : (void)0
+    #endif
+
+#endif  // !BUILDING_CEF_SHARED
+
+// Annotate a virtual method indicating it must be overriding a virtual method
+// in the parent class.
+// Use like:
+//   void foo() OVERRIDE;
+// NOTE: This define should only be used in classes exposed to the client since
+// C++11 support may not be enabled in client applications. CEF internal classes
+// should use the `override` keyword directly.
+#ifndef OVERRIDE
+    #if defined(__clang__)
+        #define OVERRIDE override
+    #elif defined(COMPILER_MSVC) && _MSC_VER >= 1600
+        // Visual Studio 2010 and later support override.
+        #define OVERRIDE override
+    #elif defined(COMPILER_GCC) && __cplusplus >= 201103 && \
+          (__GNUC__ * 10000 + __GNUC_MINOR__ * 100) >= 40700
+        // GCC 4.7 supports explicit virtual overrides when C++11 support is enabled.
+        #define OVERRIDE override
+    #else
+        #define OVERRIDE
+    #endif
+#endif  // OVERRIDE
+
+#endif  // CEF_INCLUDE_BASE_CEF_BUILD_H_
diff --git a/src/include/libcef_/base/cef_callback.h b/src/include/libcef_/base/cef_callback.h
new file mode 100644
index 0000000..373578b
--- /dev/null
+++ b/src/include/libcef_/base/cef_callback.h
@@ -0,0 +1,807 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2012
+// Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef CEF_INCLUDE_BASE_CEF_CALLBACK_H_
+#define CEF_INCLUDE_BASE_CEF_CALLBACK_H_
+#pragma once
+
+#if defined(BASE_CALLBACK_H_)
+// Do nothing if the Chromium header has already been included.
+// This can happen in cases where Chromium code is used directly by the
+// client application. When using Chromium code directly always include
+// the Chromium header first to avoid type conflicts.
+#elif defined(BUILDING_CEF_SHARED)
+// When building CEF include the Chromium header directly.
+#include "base/callback.h"
+#else  // !BUILDING_CEF_SHARED
+// The following is substantially similar to the Chromium implementation.
+// If the Chromium implementation diverges the below implementation should be
+// updated to match.
+
+#include"libcef/base/internal/cef_callback_internal.h"
+#include"libcef/base/cef_callback_forward.h"
+#include"libcef/base/cef_template_util.h"
+
+// NOTE: Header files that do not require the full definition of Callback or
+// Closure should #include "base/cef_callback_forward.h" instead of this file.
+
+// -----------------------------------------------------------------------------
+// Introduction
+// -----------------------------------------------------------------------------
+//
+// The templated Callback class is a generalized function object. Together
+// with the Bind() function in bind.h, they provide a type-safe method for
+// performing partial application of functions.
+//
+// Partial application (or "currying") is the process of binding a subset of
+// a function's arguments to produce another function that takes fewer
+// arguments. This can be used to pass around a unit of delayed execution,
+// much like lexical closures are used in other languages. For example, it
+// is used in Chromium code to schedule tasks on different MessageLoops.
+//
+// A callback with no unbound input parameters (base::Callback<void(void)>)
+// is called a base::Closure. Note that this is NOT the same as what other
+// languages refer to as a closure -- it does not retain a reference to its
+// enclosing environment.
+//
+// MEMORY MANAGEMENT AND PASSING
+//
+// The Callback objects themselves should be passed by const-reference, and
+// stored by copy. They internally store their state via a refcounted class
+// and thus do not need to be deleted.
+//
+// The reason to pass via a const-reference is to avoid unnecessary
+// AddRef/Release pairs to the internal state.
+//
+//
+// -----------------------------------------------------------------------------
+// Quick reference for basic stuff
+// -----------------------------------------------------------------------------
+//
+// BINDING A BARE FUNCTION
+//
+//   int Return5() { return 5; }
+//   base::Callback<int(void)> func_cb = base::Bind(&Return5);
+//   LOG(INFO) << func_cb.Run();  // Prints 5.
+//
+// BINDING A CLASS METHOD
+//
+//   The first argument to bind is the member function to call, the second is
+//   the object on which to call it.
+//
+//   class Ref : public base::RefCountedThreadSafe<Ref> {
+//    public:
+//     int Foo() { return 3; }
+//     void PrintBye() { LOG(INFO) << "bye."; }
+//   };
+//   scoped_refptr<Ref> ref = new Ref();
+//   base::Callback<void(void)> ref_cb = base::Bind(&Ref::Foo, ref);
+//   LOG(INFO) << ref_cb.Run();  // Prints out 3.
+//
+//   By default the object must support RefCounted or you will get a compiler
+//   error. If you're passing between threads, be sure it's
+//   RefCountedThreadSafe! See "Advanced binding of member functions" below if
+//   you don't want to use reference counting.
+//
+// RUNNING A CALLBACK
+//
+//   Callbacks can be run with their "Run" method, which has the same
+//   signature as the template argument to the callback.
+//
+//   void DoSomething(const base::Callback<void(int, std::string)>& callback) {
+//     callback.Run(5, "hello");
+//   }
+//
+//   Callbacks can be run more than once (they don't get deleted or marked when
+//   run). However, this precludes using base::Passed (see below).
+//
+//   void DoSomething(const base::Callback<double(double)>& callback) {
+//     double myresult = callback.Run(3.14159);
+//     myresult += callback.Run(2.71828);
+//   }
+//
+// PASSING UNBOUND INPUT PARAMETERS
+//
+//   Unbound parameters are specified at the time a callback is Run(). They are
+//   specified in the Callback template type:
+//
+//   void MyFunc(int i, const std::string& str) {}
+//   base::Callback<void(int, const std::string&)> cb = base::Bind(&MyFunc);
+//   cb.Run(23, "hello, world");
+//
+// PASSING BOUND INPUT PARAMETERS
+//
+//   Bound parameters are specified when you create thee callback as arguments
+//   to Bind(). They will be passed to the function and the Run()ner of the
+//   callback doesn't see those values or even know that the function it's
+//   calling.
+//
+//   void MyFunc(int i, const std::string& str) {}
+//   base::Callback<void(void)> cb = base::Bind(&MyFunc, 23, "hello world");
+//   cb.Run();
+//
+//   A callback with no unbound input parameters (base::Callback<void(void)>)
+//   is called a base::Closure. So we could have also written:
+//
+//   base::Closure cb = base::Bind(&MyFunc, 23, "hello world");
+//
+//   When calling member functions, bound parameters just go after the object
+//   pointer.
+//
+//   base::Closure cb = base::Bind(&MyClass::MyFunc, this, 23, "hello world");
+//
+// PARTIAL BINDING OF PARAMETERS
+//
+//   You can specify some parameters when you create the callback, and specify
+//   the rest when you execute the callback.
+//
+//   void MyFunc(int i, const std::string& str) {}
+//   base::Callback<void(const std::string&)> cb = base::Bind(&MyFunc, 23);
+//   cb.Run("hello world");
+//
+//   When calling a function bound parameters are first, followed by unbound
+//   parameters.
+//
+//
+// -----------------------------------------------------------------------------
+// Quick reference for advanced binding
+// -----------------------------------------------------------------------------
+//
+// BINDING A CLASS METHOD WITH WEAK POINTERS
+//
+//   base::Bind(&MyClass::Foo, GetWeakPtr());
+//
+//   The callback will not be run if the object has already been destroyed.
+//   DANGER: weak pointers are not threadsafe, so don't use this
+//   when passing between threads!
+//
+// BINDING A CLASS METHOD WITH MANUAL LIFETIME MANAGEMENT
+//
+//   base::Bind(&MyClass::Foo, base::Unretained(this));
+//
+//   This disables all lifetime management on the object. You're responsible
+//   for making sure the object is alive at the time of the call. You break it,
+//   you own it!
+//
+// BINDING A CLASS METHOD AND HAVING THE CALLBACK OWN THE CLASS
+//
+//   MyClass* myclass = new MyClass;
+//   base::Bind(&MyClass::Foo, base::Owned(myclass));
+//
+//   The object will be deleted when the callback is destroyed, even if it's
+//   not run (like if you post a task during shutdown). Potentially useful for
+//   "fire and forget" cases.
+//
+// IGNORING RETURN VALUES
+//
+//   Sometimes you want to call a function that returns a value in a callback
+//   that doesn't expect a return value.
+//
+//   int DoSomething(int arg) { cout << arg << endl; }
+//   base::Callback<void<int>) cb =
+//       base::Bind(base::IgnoreResult(&DoSomething));
+//
+//
+// -----------------------------------------------------------------------------
+// Quick reference for binding parameters to Bind()
+// -----------------------------------------------------------------------------
+//
+// Bound parameters are specified as arguments to Bind() and are passed to the
+// function. A callback with no parameters or no unbound parameters is called a
+// Closure (base::Callback<void(void)> and base::Closure are the same thing).
+//
+// PASSING PARAMETERS OWNED BY THE CALLBACK
+//
+//   void Foo(int* arg) { cout << *arg << endl; }
+//   int* pn = new int(1);
+//   base::Closure foo_callback = base::Bind(&foo, base::Owned(pn));
+//
+//   The parameter will be deleted when the callback is destroyed, even if it's
+//   not run (like if you post a task during shutdown).
+//
+// PASSING PARAMETERS AS A scoped_ptr
+//
+//   void TakesOwnership(scoped_ptr<Foo> arg) {}
+//   scoped_ptr<Foo> f(new Foo);
+//   // f becomes null during the following call.
+//   base::Closure cb = base::Bind(&TakesOwnership, base::Passed(&f));
+//
+//   Ownership of the parameter will be with the callback until the it is run,
+//   when ownership is passed to the callback function. This means the callback
+//   can only be run once. If the callback is never run, it will delete the
+//   object when it's destroyed.
+//
+// PASSING PARAMETERS AS A scoped_refptr
+//
+//   void TakesOneRef(scoped_refptr<Foo> arg) {}
+//   scoped_refptr<Foo> f(new Foo)
+//   base::Closure cb = base::Bind(&TakesOneRef, f);
+//
+//   This should "just work." The closure will take a reference as long as it
+//   is alive, and another reference will be taken for the called function.
+//
+// PASSING PARAMETERS BY REFERENCE
+//
+//   Const references are *copied* unless ConstRef is used. Example:
+//
+//   void foo(const int& arg) { printf("%d %p\n", arg, &arg); }
+//   int n = 1;
+//   base::Closure has_copy = base::Bind(&foo, n);
+//   base::Closure has_ref = base::Bind(&foo, base::ConstRef(n));
+//   n = 2;
+//   foo(n);                        // Prints "2 0xaaaaaaaaaaaa"
+//   has_copy.Run();                // Prints "1 0xbbbbbbbbbbbb"
+//   has_ref.Run();                 // Prints "2 0xaaaaaaaaaaaa"
+//
+//   Normally parameters are copied in the closure. DANGER: ConstRef stores a
+//   const reference instead, referencing the original parameter. This means
+//   that you must ensure the object outlives the callback!
+//
+//
+// -----------------------------------------------------------------------------
+// Implementation notes
+// -----------------------------------------------------------------------------
+//
+// WHERE IS THIS DESIGN FROM:
+//
+// The design Callback and Bind is heavily influenced by C++'s
+// tr1::function/tr1::bind, and by the "Google Callback" system used inside
+// Google.
+//
+//
+// HOW THE IMPLEMENTATION WORKS:
+//
+// There are three main components to the system:
+//   1) The Callback classes.
+//   2) The Bind() functions.
+//   3) The arguments wrappers (e.g., Unretained() and ConstRef()).
+//
+// The Callback classes represent a generic function pointer. Internally,
+// it stores a refcounted piece of state that represents the target function
+// and all its bound parameters.  Each Callback specialization has a templated
+// constructor that takes an BindState<>*.  In the context of the constructor,
+// the static type of this BindState<> pointer uniquely identifies the
+// function it is representing, all its bound parameters, and a Run() method
+// that is capable of invoking the target.
+//
+// Callback's constructor takes the BindState<>* that has the full static type
+// and erases the target function type as well as the types of the bound
+// parameters.  It does this by storing a pointer to the specific Run()
+// function, and upcasting the state of BindState<>* to a
+// BindStateBase*. This is safe as long as this BindStateBase pointer
+// is only used with the stored Run() pointer.
+//
+// To BindState<> objects are created inside the Bind() functions.
+// These functions, along with a set of internal templates, are responsible for
+//
+//  - Unwrapping the function signature into return type, and parameters
+//  - Determining the number of parameters that are bound
+//  - Creating the BindState storing the bound parameters
+//  - Performing compile-time asserts to avoid error-prone behavior
+//  - Returning an Callback<> with an arity matching the number of unbound
+//    parameters and that knows the correct refcounting semantics for the
+//    target object if we are binding a method.
+//
+// The Bind functions do the above using type-inference, and template
+// specializations.
+//
+// By default Bind() will store copies of all bound parameters, and attempt
+// to refcount a target object if the function being bound is a class method.
+// These copies are created even if the function takes parameters as const
+// references. (Binding to non-const references is forbidden, see bind.h.)
+//
+// To change this behavior, we introduce a set of argument wrappers
+// (e.g., Unretained(), and ConstRef()).  These are simple container templates
+// that are passed by value, and wrap a pointer to argument.  See the
+// file-level comment in base/bind_helpers.h for more info.
+//
+// These types are passed to the Unwrap() functions, and the MaybeRefcount()
+// functions respectively to modify the behavior of Bind().  The Unwrap()
+// and MaybeRefcount() functions change behavior by doing partial
+// specialization based on whether or not a parameter is a wrapper type.
+//
+// ConstRef() is similar to tr1::cref.  Unretained() is specific to Chromium.
+//
+//
+// WHY NOT TR1 FUNCTION/BIND?
+//
+// Direct use of tr1::function and tr1::bind was considered, but ultimately
+// rejected because of the number of copy constructors invocations involved
+// in the binding of arguments during construction, and the forwarding of
+// arguments during invocation.  These copies will no longer be an issue in
+// C++0x because C++0x will support rvalue reference allowing for the compiler
+// to avoid these copies.  However, waiting for C++0x is not an option.
+//
+// Measured with valgrind on gcc version 4.4.3 (Ubuntu 4.4.3-4ubuntu5), the
+// tr1::bind call itself will invoke a non-trivial copy constructor three times
+// for each bound parameter.  Also, each when passing a tr1::function, each
+// bound argument will be copied again.
+//
+// In addition to the copies taken at binding and invocation, copying a
+// tr1::function causes a copy to be made of all the bound parameters and
+// state.
+//
+// Furthermore, in Chromium, it is desirable for the Callback to take a
+// reference on a target object when representing a class method call.  This
+// is not supported by tr1.
+//
+// Lastly, tr1::function and tr1::bind has a more general and flexible API.
+// This includes things like argument reordering by use of
+// tr1::bind::placeholder, support for non-const reference parameters, and some
+// limited amount of subtyping of the tr1::function object (e.g.,
+// tr1::function<int(int)> is convertible to tr1::function<void(int)>).
+//
+// These are not features that are required in Chromium. Some of them, such as
+// allowing for reference parameters, and subtyping of functions, may actually
+// become a source of errors. Removing support for these features actually
+// allows for a simpler implementation, and a terser Currying API.
+//
+//
+// WHY NOT GOOGLE CALLBACKS?
+//
+// The Google callback system also does not support refcounting.  Furthermore,
+// its implementation has a number of strange edge cases with respect to type
+// conversion of its arguments.  In particular, the argument's constness must
+// at times match exactly the function signature, or the type-inference might
+// break.  Given the above, writing a custom solution was easier.
+//
+//
+// MISSING FUNCTIONALITY
+//  - Invoking the return of Bind.  Bind(&foo).Run() does not work;
+//  - Binding arrays to functions that take a non-const pointer.
+//    Example:
+//      void Foo(const char* ptr);
+//      void Bar(char* ptr);
+//      Bind(&Foo, "test");
+//      Bind(&Bar, "test");  // This fails because ptr is not const.
+
+namespace base {
+
+// First, we forward declare the Callback class template. This informs the
+// compiler that the template only has 1 type parameter which is the function
+// signature that the Callback is representing.
+//
+// After this, create template specializations for 0-7 parameters. Note that
+// even though the template typelist grows, the specialization still
+// only has one type: the function signature.
+//
+// If you are thinking of forward declaring Callback in your own header file,
+// please include "base/callback_forward.h" instead.
+template <typename Sig>
+class Callback;
+
+namespace cef_internal {
+template <typename Runnable, typename RunType, typename BoundArgsType>
+struct BindState;
+}  // namespace cef_internal
+
+template <typename R>
+class Callback<R(void)> : public cef_internal::CallbackBase {
+ public:
+  typedef R(RunType)();
+
+  Callback() : CallbackBase(NULL) { }
+
+  // Note that this constructor CANNOT be explicit, and that Bind() CANNOT
+  // return the exact Callback<> type.  See base/bind.h for details.
+  template <typename Runnable, typename BindRunType, typename BoundArgsType>
+  Callback(cef_internal::BindState<Runnable, BindRunType,
+           BoundArgsType>* bind_state)
+      : CallbackBase(bind_state) {
+
+    // Force the assignment to a local variable of PolymorphicInvoke
+    // so the compiler will typecheck that the passed in Run() method has
+    // the correct type.
+    PolymorphicInvoke invoke_func =
+        &cef_internal::BindState<Runnable, BindRunType, BoundArgsType>
+            ::InvokerType::Run;
+    polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
+  }
+
+  bool Equals(const Callback& other) const {
+    return CallbackBase::Equals(other);
+  }
+
+  R Run() const {
+    PolymorphicInvoke f =
+        reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_);
+
+    return f(bind_state_.get());
+  }
+
+ private:
+  typedef R(*PolymorphicInvoke)(
+      cef_internal::BindStateBase*);
+
+};
+
+template <typename R, typename A1>
+class Callback<R(A1)> : public cef_internal::CallbackBase {
+ public:
+  typedef R(RunType)(A1);
+
+  Callback() : CallbackBase(NULL) { }
+
+  // Note that this constructor CANNOT be explicit, and that Bind() CANNOT
+  // return the exact Callback<> type.  See base/bind.h for details.
+  template <typename Runnable, typename BindRunType, typename BoundArgsType>
+  Callback(cef_internal::BindState<Runnable, BindRunType,
+           BoundArgsType>* bind_state)
+      : CallbackBase(bind_state) {
+
+    // Force the assignment to a local variable of PolymorphicInvoke
+    // so the compiler will typecheck that the passed in Run() method has
+    // the correct type.
+    PolymorphicInvoke invoke_func =
+        &cef_internal::BindState<Runnable, BindRunType, BoundArgsType>
+            ::InvokerType::Run;
+    polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
+  }
+
+  bool Equals(const Callback& other) const {
+    return CallbackBase::Equals(other);
+  }
+
+  R Run(typename cef_internal::CallbackParamTraits<A1>::ForwardType a1) const {
+    PolymorphicInvoke f =
+        reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_);
+
+    return f(bind_state_.get(), cef_internal::CallbackForward(a1));
+  }
+
+ private:
+  typedef R(*PolymorphicInvoke)(
+      cef_internal::BindStateBase*,
+          typename cef_internal::CallbackParamTraits<A1>::ForwardType);
+
+};
+
+template <typename R, typename A1, typename A2>
+class Callback<R(A1, A2)> : public cef_internal::CallbackBase {
+ public:
+  typedef R(RunType)(A1, A2);
+
+  Callback() : CallbackBase(NULL) { }
+
+  // Note that this constructor CANNOT be explicit, and that Bind() CANNOT
+  // return the exact Callback<> type.  See base/bind.h for details.
+  template <typename Runnable, typename BindRunType, typename BoundArgsType>
+  Callback(cef_internal::BindState<Runnable, BindRunType,
+           BoundArgsType>* bind_state)
+      : CallbackBase(bind_state) {
+
+    // Force the assignment to a local variable of PolymorphicInvoke
+    // so the compiler will typecheck that the passed in Run() method has
+    // the correct type.
+    PolymorphicInvoke invoke_func =
+        &cef_internal::BindState<Runnable, BindRunType, BoundArgsType>
+            ::InvokerType::Run;
+    polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
+  }
+
+  bool Equals(const Callback& other) const {
+    return CallbackBase::Equals(other);
+  }
+
+  R Run(typename cef_internal::CallbackParamTraits<A1>::ForwardType a1,
+        typename cef_internal::CallbackParamTraits<A2>::ForwardType a2) const {
+    PolymorphicInvoke f =
+        reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_);
+
+    return f(bind_state_.get(), cef_internal::CallbackForward(a1),
+             cef_internal::CallbackForward(a2));
+  }
+
+ private:
+  typedef R(*PolymorphicInvoke)(
+      cef_internal::BindStateBase*,
+          typename cef_internal::CallbackParamTraits<A1>::ForwardType,
+          typename cef_internal::CallbackParamTraits<A2>::ForwardType);
+
+};
+
+template <typename R, typename A1, typename A2, typename A3>
+class Callback<R(A1, A2, A3)> : public cef_internal::CallbackBase {
+ public:
+  typedef R(RunType)(A1, A2, A3);
+
+  Callback() : CallbackBase(NULL) { }
+
+  // Note that this constructor CANNOT be explicit, and that Bind() CANNOT
+  // return the exact Callback<> type.  See base/bind.h for details.
+  template <typename Runnable, typename BindRunType, typename BoundArgsType>
+  Callback(cef_internal::BindState<Runnable, BindRunType,
+           BoundArgsType>* bind_state)
+      : CallbackBase(bind_state) {
+
+    // Force the assignment to a local variable of PolymorphicInvoke
+    // so the compiler will typecheck that the passed in Run() method has
+    // the correct type.
+    PolymorphicInvoke invoke_func =
+        &cef_internal::BindState<Runnable, BindRunType, BoundArgsType>
+            ::InvokerType::Run;
+    polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
+  }
+
+  bool Equals(const Callback& other) const {
+    return CallbackBase::Equals(other);
+  }
+
+  R Run(typename cef_internal::CallbackParamTraits<A1>::ForwardType a1,
+        typename cef_internal::CallbackParamTraits<A2>::ForwardType a2,
+        typename cef_internal::CallbackParamTraits<A3>::ForwardType a3) const {
+    PolymorphicInvoke f =
+        reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_);
+
+    return f(bind_state_.get(), cef_internal::CallbackForward(a1),
+             cef_internal::CallbackForward(a2),
+             cef_internal::CallbackForward(a3));
+  }
+
+ private:
+  typedef R(*PolymorphicInvoke)(
+      cef_internal::BindStateBase*,
+          typename cef_internal::CallbackParamTraits<A1>::ForwardType,
+          typename cef_internal::CallbackParamTraits<A2>::ForwardType,
+          typename cef_internal::CallbackParamTraits<A3>::ForwardType);
+
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4>
+class Callback<R(A1, A2, A3, A4)> : public cef_internal::CallbackBase {
+ public:
+  typedef R(RunType)(A1, A2, A3, A4);
+
+  Callback() : CallbackBase(NULL) { }
+
+  // Note that this constructor CANNOT be explicit, and that Bind() CANNOT
+  // return the exact Callback<> type.  See base/bind.h for details.
+  template <typename Runnable, typename BindRunType, typename BoundArgsType>
+  Callback(cef_internal::BindState<Runnable, BindRunType,
+           BoundArgsType>* bind_state)
+      : CallbackBase(bind_state) {
+
+    // Force the assignment to a local variable of PolymorphicInvoke
+    // so the compiler will typecheck that the passed in Run() method has
+    // the correct type.
+    PolymorphicInvoke invoke_func =
+        &cef_internal::BindState<Runnable, BindRunType, BoundArgsType>
+            ::InvokerType::Run;
+    polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
+  }
+
+  bool Equals(const Callback& other) const {
+    return CallbackBase::Equals(other);
+  }
+
+  R Run(typename cef_internal::CallbackParamTraits<A1>::ForwardType a1,
+        typename cef_internal::CallbackParamTraits<A2>::ForwardType a2,
+        typename cef_internal::CallbackParamTraits<A3>::ForwardType a3,
+        typename cef_internal::CallbackParamTraits<A4>::ForwardType a4) const {
+    PolymorphicInvoke f =
+        reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_);
+
+    return f(bind_state_.get(), cef_internal::CallbackForward(a1),
+             cef_internal::CallbackForward(a2),
+             cef_internal::CallbackForward(a3),
+             cef_internal::CallbackForward(a4));
+  }
+
+ private:
+  typedef R(*PolymorphicInvoke)(
+      cef_internal::BindStateBase*,
+          typename cef_internal::CallbackParamTraits<A1>::ForwardType,
+          typename cef_internal::CallbackParamTraits<A2>::ForwardType,
+          typename cef_internal::CallbackParamTraits<A3>::ForwardType,
+          typename cef_internal::CallbackParamTraits<A4>::ForwardType);
+
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5>
+class Callback<R(A1, A2, A3, A4, A5)> : public cef_internal::CallbackBase {
+ public:
+  typedef R(RunType)(A1, A2, A3, A4, A5);
+
+  Callback() : CallbackBase(NULL) { }
+
+  // Note that this constructor CANNOT be explicit, and that Bind() CANNOT
+  // return the exact Callback<> type.  See base/bind.h for details.
+  template <typename Runnable, typename BindRunType, typename BoundArgsType>
+  Callback(cef_internal::BindState<Runnable, BindRunType,
+           BoundArgsType>* bind_state)
+      : CallbackBase(bind_state) {
+
+    // Force the assignment to a local variable of PolymorphicInvoke
+    // so the compiler will typecheck that the passed in Run() method has
+    // the correct type.
+    PolymorphicInvoke invoke_func =
+        &cef_internal::BindState<Runnable, BindRunType, BoundArgsType>
+            ::InvokerType::Run;
+    polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
+  }
+
+  bool Equals(const Callback& other) const {
+    return CallbackBase::Equals(other);
+  }
+
+  R Run(typename cef_internal::CallbackParamTraits<A1>::ForwardType a1,
+        typename cef_internal::CallbackParamTraits<A2>::ForwardType a2,
+        typename cef_internal::CallbackParamTraits<A3>::ForwardType a3,
+        typename cef_internal::CallbackParamTraits<A4>::ForwardType a4,
+        typename cef_internal::CallbackParamTraits<A5>::ForwardType a5) const {
+    PolymorphicInvoke f =
+        reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_);
+
+    return f(bind_state_.get(), cef_internal::CallbackForward(a1),
+             cef_internal::CallbackForward(a2),
+             cef_internal::CallbackForward(a3),
+             cef_internal::CallbackForward(a4),
+             cef_internal::CallbackForward(a5));
+  }
+
+ private:
+  typedef R(*PolymorphicInvoke)(
+      cef_internal::BindStateBase*,
+          typename cef_internal::CallbackParamTraits<A1>::ForwardType,
+          typename cef_internal::CallbackParamTraits<A2>::ForwardType,
+          typename cef_internal::CallbackParamTraits<A3>::ForwardType,
+          typename cef_internal::CallbackParamTraits<A4>::ForwardType,
+          typename cef_internal::CallbackParamTraits<A5>::ForwardType);
+
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6>
+class Callback<R(A1, A2, A3, A4, A5, A6)> : public cef_internal::CallbackBase {
+ public:
+  typedef R(RunType)(A1, A2, A3, A4, A5, A6);
+
+  Callback() : CallbackBase(NULL) { }
+
+  // Note that this constructor CANNOT be explicit, and that Bind() CANNOT
+  // return the exact Callback<> type.  See base/bind.h for details.
+  template <typename Runnable, typename BindRunType, typename BoundArgsType>
+  Callback(cef_internal::BindState<Runnable, BindRunType,
+           BoundArgsType>* bind_state)
+      : CallbackBase(bind_state) {
+
+    // Force the assignment to a local variable of PolymorphicInvoke
+    // so the compiler will typecheck that the passed in Run() method has
+    // the correct type.
+    PolymorphicInvoke invoke_func =
+        &cef_internal::BindState<Runnable, BindRunType, BoundArgsType>
+            ::InvokerType::Run;
+    polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
+  }
+
+  bool Equals(const Callback& other) const {
+    return CallbackBase::Equals(other);
+  }
+
+  R Run(typename cef_internal::CallbackParamTraits<A1>::ForwardType a1,
+        typename cef_internal::CallbackParamTraits<A2>::ForwardType a2,
+        typename cef_internal::CallbackParamTraits<A3>::ForwardType a3,
+        typename cef_internal::CallbackParamTraits<A4>::ForwardType a4,
+        typename cef_internal::CallbackParamTraits<A5>::ForwardType a5,
+        typename cef_internal::CallbackParamTraits<A6>::ForwardType a6) const {
+    PolymorphicInvoke f =
+        reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_);
+
+    return f(bind_state_.get(), cef_internal::CallbackForward(a1),
+             cef_internal::CallbackForward(a2),
+             cef_internal::CallbackForward(a3),
+             cef_internal::CallbackForward(a4),
+             cef_internal::CallbackForward(a5),
+             cef_internal::CallbackForward(a6));
+  }
+
+ private:
+  typedef R(*PolymorphicInvoke)(
+      cef_internal::BindStateBase*,
+          typename cef_internal::CallbackParamTraits<A1>::ForwardType,
+          typename cef_internal::CallbackParamTraits<A2>::ForwardType,
+          typename cef_internal::CallbackParamTraits<A3>::ForwardType,
+          typename cef_internal::CallbackParamTraits<A4>::ForwardType,
+          typename cef_internal::CallbackParamTraits<A5>::ForwardType,
+          typename cef_internal::CallbackParamTraits<A6>::ForwardType);
+
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6, typename A7>
+class Callback<R(A1, A2, A3, A4, A5, A6, A7)> : public cef_internal::CallbackBase {
+ public:
+  typedef R(RunType)(A1, A2, A3, A4, A5, A6, A7);
+
+  Callback() : CallbackBase(NULL) { }
+
+  // Note that this constructor CANNOT be explicit, and that Bind() CANNOT
+  // return the exact Callback<> type.  See base/bind.h for details.
+  template <typename Runnable, typename BindRunType, typename BoundArgsType>
+  Callback(cef_internal::BindState<Runnable, BindRunType,
+           BoundArgsType>* bind_state)
+      : CallbackBase(bind_state) {
+
+    // Force the assignment to a local variable of PolymorphicInvoke
+    // so the compiler will typecheck that the passed in Run() method has
+    // the correct type.
+    PolymorphicInvoke invoke_func =
+        &cef_internal::BindState<Runnable, BindRunType, BoundArgsType>
+            ::InvokerType::Run;
+    polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
+  }
+
+  bool Equals(const Callback& other) const {
+    return CallbackBase::Equals(other);
+  }
+
+  R Run(typename cef_internal::CallbackParamTraits<A1>::ForwardType a1,
+        typename cef_internal::CallbackParamTraits<A2>::ForwardType a2,
+        typename cef_internal::CallbackParamTraits<A3>::ForwardType a3,
+        typename cef_internal::CallbackParamTraits<A4>::ForwardType a4,
+        typename cef_internal::CallbackParamTraits<A5>::ForwardType a5,
+        typename cef_internal::CallbackParamTraits<A6>::ForwardType a6,
+        typename cef_internal::CallbackParamTraits<A7>::ForwardType a7) const {
+    PolymorphicInvoke f =
+        reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_);
+
+    return f(bind_state_.get(), cef_internal::CallbackForward(a1),
+             cef_internal::CallbackForward(a2),
+             cef_internal::CallbackForward(a3),
+             cef_internal::CallbackForward(a4),
+             cef_internal::CallbackForward(a5),
+             cef_internal::CallbackForward(a6),
+             cef_internal::CallbackForward(a7));
+  }
+
+ private:
+  typedef R(*PolymorphicInvoke)(
+      cef_internal::BindStateBase*,
+          typename cef_internal::CallbackParamTraits<A1>::ForwardType,
+          typename cef_internal::CallbackParamTraits<A2>::ForwardType,
+          typename cef_internal::CallbackParamTraits<A3>::ForwardType,
+          typename cef_internal::CallbackParamTraits<A4>::ForwardType,
+          typename cef_internal::CallbackParamTraits<A5>::ForwardType,
+          typename cef_internal::CallbackParamTraits<A6>::ForwardType,
+          typename cef_internal::CallbackParamTraits<A7>::ForwardType);
+
+};
+
+
+// Syntactic sugar to make Callbacks<void(void)> easier to declare since it
+// will be used in a lot of APIs with delayed execution.
+typedef Callback<void(void)> Closure;
+
+}  // namespace base
+
+#endif  // !BUILDING_CEF_SHARED
+
+#endif  // CEF_INCLUDE_BASE_CEF_CALLBACK_H_
diff --git a/src/include/libcef_/base/cef_callback_forward.h b/src/include/libcef_/base/cef_callback_forward.h
new file mode 100644
index 0000000..4986b8f
--- /dev/null
+++ b/src/include/libcef_/base/cef_callback_forward.h
@@ -0,0 +1,59 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2011
+// Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef INCLUDE_BASE_CEF_CALLBACK_FORWARD_H_
+#define INCLUDE_BASE_CEF_CALLBACK_FORWARD_H_
+#pragma once
+
+#if defined(BASE_CALLBACK_FORWARD_H_)
+// Do nothing if the Chromium header has already been included.
+// This can happen in cases where Chromium code is used directly by the
+// client application. When using Chromium code directly always include
+// the Chromium header first to avoid type conflicts.
+#elif defined(BUILDING_CEF_SHARED)
+// When building CEF include the Chromium header directly.
+#include "base/callback_forward.h"
+#else  // !BUILDING_CEF_SHARED
+// The following is substantially similar to the Chromium implementation.
+// If the Chromium implementation diverges the below implementation should be
+// updated to match.
+
+namespace base {
+
+template <typename Sig>
+class Callback;
+
+typedef Callback<void(void)> Closure;
+
+}  // namespace base
+
+#endif  // !!BUILDING_CEF_SHARED
+
+#endif  // INCLUDE_BASE_CEF_CALLBACK_FORWARD_H_
diff --git a/src/include/libcef_/base/cef_callback_helpers.h b/src/include/libcef_/base/cef_callback_helpers.h
new file mode 100644
index 0000000..dc2b724
--- /dev/null
+++ b/src/include/libcef_/base/cef_callback_helpers.h
@@ -0,0 +1,93 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2012
+// Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// This defines helpful methods for dealing with Callbacks.  Because Callbacks
+// are implemented using templates, with a class per callback signature, adding
+// methods to Callback<> itself is unattractive (lots of extra code gets
+// generated).  Instead, consider adding methods here.
+//
+// ResetAndReturn(&cb) is like cb.Reset() but allows executing a callback (via a
+// copy) after the original callback is Reset().  This can be handy if Run()
+// reads/writes the variable holding the Callback.
+
+#ifndef CEF_INCLUDE_BASE_CEF_CALLBACK_HELPERS_H_
+#define CEF_INCLUDE_BASE_CEF_CALLBACK_HELPERS_H_
+#pragma once
+
+#if defined(BASE_CALLBACK_HELPERS_H_)
+// Do nothing if the Chromium header has already been included.
+// This can happen in cases where Chromium code is used directly by the
+// client application. When using Chromium code directly always include
+// the Chromium header first to avoid type conflicts.
+#elif defined(BUILDING_CEF_SHARED)
+// When building CEF include the Chromium header directly.
+#include "base/callback_helpers.h"
+#else  // !BUILDING_CEF_SHARED
+// The following is substantially similar to the Chromium implementation.
+// If the Chromium implementation diverges the below implementation should be
+// updated to match.
+
+#include"libcef/base/cef_basictypes.h"
+#include"libcef/base/cef_build.h"
+#include"libcef/base/cef_callback.h"
+#include"libcef/base/cef_macros.h"
+
+namespace base {
+
+template <typename Sig>
+base::Callback<Sig> ResetAndReturn(base::Callback<Sig>* cb) {
+  base::Callback<Sig> ret(*cb);
+  cb->Reset();
+  return ret;
+}
+
+// ScopedClosureRunner is akin to scoped_ptr for Closures. It ensures that the
+// Closure is executed and deleted no matter how the current scope exits.
+class ScopedClosureRunner {
+ public:
+  ScopedClosureRunner();
+  explicit ScopedClosureRunner(const Closure& closure);
+  ~ScopedClosureRunner();
+
+  void Reset();
+  void Reset(const Closure& closure);
+  Closure Release() WARN_UNUSED_RESULT;
+
+ private:
+  Closure closure_;
+
+  DISALLOW_COPY_AND_ASSIGN(ScopedClosureRunner);
+};
+
+}  // namespace base
+
+#endif  // !BUILDING_CEF_SHARED
+
+#endif  // CEF_INCLUDE_BASE_CEF_CALLBACK_HELPERS_H_
diff --git a/src/include/libcef_/base/cef_callback_list.h b/src/include/libcef_/base/cef_callback_list.h
new file mode 100644
index 0000000..d4cd1f0
--- /dev/null
+++ b/src/include/libcef_/base/cef_callback_list.h
@@ -0,0 +1,444 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2013
+// Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef CEF_INCLUDE_BASE_CEF_CALLBACK_LIST_H_
+#define CEF_INCLUDE_BASE_CEF_CALLBACK_LIST_H_
+#pragma once
+
+#if defined(BASE_CALLBACK_LIST_H_)
+// Do nothing if the Chromium header has already been included.
+// This can happen in cases where Chromium code is used directly by the
+// client application. When using Chromium code directly always include
+// the Chromium header first to avoid type conflicts.
+#elif defined(BUILDING_CEF_SHARED)
+// When building CEF include the Chromium header directly.
+#include "base/callback_list.h"
+#else  // !BUILDING_CEF_SHARED
+// The following is substantially similar to the Chromium implementation.
+// If the Chromium implementation diverges the below implementation should be
+// updated to match.
+
+#include<list>
+
+#include"libcef/base/cef_basictypes.h"
+#include"libcef/base/cef_callback.h"
+#include"libcef/base/internal/cef_callback_internal.h"
+#include"libcef/base/cef_build.h"
+#include"libcef/base/cef_logging.h"
+#include"libcef/base/cef_macros.h"
+#include"libcef/base/cef_scoped_ptr.h"
+
+// OVERVIEW:
+//
+// A container for a list of callbacks.  Unlike a normal STL vector or list,
+// this container can be modified during iteration without invalidating the
+// iterator. It safely handles the case of a callback removing itself
+// or another callback from the list while callbacks are being run.
+//
+// TYPICAL USAGE:
+//
+// class MyWidget {
+//  public:
+//   ...
+//
+//   typedef base::Callback<void(const Foo&)> OnFooCallback;
+//
+//   scoped_ptr<base::CallbackList<void(const Foo&)>::Subscription>
+//   RegisterCallback(const OnFooCallback& cb) {
+//     return callback_list_.Add(cb);
+//   }
+//
+//  private:
+//   void NotifyFoo(const Foo& foo) {
+//      callback_list_.Notify(foo);
+//   }
+//
+//   base::CallbackList<void(const Foo&)> callback_list_;
+//
+//   DISALLOW_COPY_AND_ASSIGN(MyWidget);
+// };
+//
+//
+// class MyWidgetListener {
+//  public:
+//   MyWidgetListener::MyWidgetListener() {
+//     foo_subscription_ = MyWidget::GetCurrent()->RegisterCallback(
+//             base::Bind(&MyWidgetListener::OnFoo, this)));
+//   }
+//
+//   MyWidgetListener::~MyWidgetListener() {
+//      // Subscription gets deleted automatically and will deregister
+//      // the callback in the process.
+//   }
+//
+//  private:
+//   void OnFoo(const Foo& foo) {
+//     // Do something.
+//   }
+//
+//   scoped_ptr<base::CallbackList<void(const Foo&)>::Subscription>
+//       foo_subscription_;
+//
+//   DISALLOW_COPY_AND_ASSIGN(MyWidgetListener);
+// };
+
+namespace base {
+
+namespace cef_internal {
+
+template <typename CallbackType>
+class CallbackListBase {
+ public:
+  class Subscription {
+   public:
+    Subscription(CallbackListBase<CallbackType>* list,
+                 typename std::list<CallbackType>::iterator iter)
+        : list_(list),
+          iter_(iter) {
+    }
+
+    ~Subscription() {
+      if (list_->active_iterator_count_) {
+        iter_->Reset();
+      } else {
+        list_->callbacks_.erase(iter_);
+        if (!list_->removal_callback_.is_null())
+          list_->removal_callback_.Run();
+      }
+    }
+
+   private:
+    CallbackListBase<CallbackType>* list_;
+    typename std::list<CallbackType>::iterator iter_;
+
+    DISALLOW_COPY_AND_ASSIGN(Subscription);
+  };
+
+  // Add a callback to the list. The callback will remain registered until the
+  // returned Subscription is destroyed, which must occur before the
+  // CallbackList is destroyed.
+  scoped_ptr<Subscription> Add(const CallbackType& cb) WARN_UNUSED_RESULT {
+    DCHECK(!cb.is_null());
+    return scoped_ptr<Subscription>(
+        new Subscription(this, callbacks_.insert(callbacks_.end(), cb)));
+  }
+
+  // Sets a callback which will be run when a subscription list is changed.
+  void set_removal_callback(const Closure& callback) {
+    removal_callback_ = callback;
+  }
+
+  // Returns true if there are no subscriptions. This is only valid to call when
+  // not looping through the list.
+  bool empty() {
+    DCHECK_EQ(0, active_iterator_count_);
+    return callbacks_.empty();
+  }
+
+ protected:
+  // An iterator class that can be used to access the list of callbacks.
+  class Iterator {
+   public:
+    explicit Iterator(CallbackListBase<CallbackType>* list)
+        : list_(list),
+          list_iter_(list_->callbacks_.begin()) {
+      ++list_->active_iterator_count_;
+    }
+
+    Iterator(const Iterator& iter)
+        : list_(iter.list_),
+          list_iter_(iter.list_iter_) {
+      ++list_->active_iterator_count_;
+    }
+
+    ~Iterator() {
+      if (list_ && --list_->active_iterator_count_ == 0) {
+        list_->Compact();
+      }
+    }
+
+    CallbackType* GetNext() {
+      while ((list_iter_ != list_->callbacks_.end()) && list_iter_->is_null())
+        ++list_iter_;
+
+      CallbackType* cb = NULL;
+      if (list_iter_ != list_->callbacks_.end()) {
+        cb = &(*list_iter_);
+        ++list_iter_;
+      }
+      return cb;
+    }
+
+   private:
+    CallbackListBase<CallbackType>* list_;
+    typename std::list<CallbackType>::iterator list_iter_;
+  };
+
+  CallbackListBase() : active_iterator_count_(0) {}
+
+  ~CallbackListBase() {
+    DCHECK_EQ(0, active_iterator_count_);
+    DCHECK_EQ(0U, callbacks_.size());
+  }
+
+  // Returns an instance of a CallbackListBase::Iterator which can be used
+  // to run callbacks.
+  Iterator GetIterator() {
+    return Iterator(this);
+  }
+
+  // Compact the list: remove any entries which were NULLed out during
+  // iteration.
+  void Compact() {
+    typename std::list<CallbackType>::iterator it = callbacks_.begin();
+    bool updated = false;
+    while (it != callbacks_.end()) {
+      if ((*it).is_null()) {
+        updated = true;
+        it = callbacks_.erase(it);
+      } else {
+        ++it;
+      }
+
+      if (updated && !removal_callback_.is_null())
+        removal_callback_.Run();
+    }
+  }
+
+ private:
+  std::list<CallbackType> callbacks_;
+  int active_iterator_count_;
+  Closure removal_callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(CallbackListBase);
+};
+
+}  // namespace cef_internal
+
+template <typename Sig> class CallbackList;
+
+template <>
+class CallbackList<void(void)>
+    : public cef_internal::CallbackListBase<Callback<void(void)> > {
+ public:
+  typedef Callback<void(void)> CallbackType;
+
+  CallbackList() {}
+
+  void Notify() {
+    cef_internal::CallbackListBase<CallbackType>::Iterator it =
+        this->GetIterator();
+    CallbackType* cb;
+    while ((cb = it.GetNext()) != NULL) {
+      cb->Run();
+    }
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(CallbackList);
+};
+
+template <typename A1>
+class CallbackList<void(A1)>
+    : public cef_internal::CallbackListBase<Callback<void(A1)> > {
+ public:
+  typedef Callback<void(A1)> CallbackType;
+
+  CallbackList() {}
+
+  void Notify(typename cef_internal::CallbackParamTraits<A1>::ForwardType a1) {
+    typename cef_internal::CallbackListBase<CallbackType>::Iterator it =
+        this->GetIterator();
+    CallbackType* cb;
+    while ((cb = it.GetNext()) != NULL) {
+      cb->Run(a1);
+    }
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(CallbackList);
+};
+
+template <typename A1, typename A2>
+class CallbackList<void(A1, A2)>
+    : public cef_internal::CallbackListBase<Callback<void(A1, A2)> > {
+ public:
+  typedef Callback<void(A1, A2)> CallbackType;
+
+  CallbackList() {}
+
+  void Notify(typename cef_internal::CallbackParamTraits<A1>::ForwardType a1,
+              typename cef_internal::CallbackParamTraits<A2>::ForwardType a2) {
+    typename cef_internal::CallbackListBase<CallbackType>::Iterator it =
+        this->GetIterator();
+    CallbackType* cb;
+    while ((cb = it.GetNext()) != NULL) {
+      cb->Run(a1, a2);
+    }
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(CallbackList);
+};
+
+template <typename A1, typename A2, typename A3>
+class CallbackList<void(A1, A2, A3)>
+    : public cef_internal::CallbackListBase<Callback<void(A1, A2, A3)> > {
+ public:
+  typedef Callback<void(A1, A2, A3)> CallbackType;
+
+  CallbackList() {}
+
+  void Notify(typename cef_internal::CallbackParamTraits<A1>::ForwardType a1,
+              typename cef_internal::CallbackParamTraits<A2>::ForwardType a2,
+              typename cef_internal::CallbackParamTraits<A3>::ForwardType a3) {
+    typename cef_internal::CallbackListBase<CallbackType>::Iterator it =
+        this->GetIterator();
+    CallbackType* cb;
+    while ((cb = it.GetNext()) != NULL) {
+      cb->Run(a1, a2, a3);
+    }
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(CallbackList);
+};
+
+template <typename A1, typename A2, typename A3, typename A4>
+class CallbackList<void(A1, A2, A3, A4)>
+    : public cef_internal::CallbackListBase<Callback<void(A1, A2, A3, A4)> > {
+ public:
+  typedef Callback<void(A1, A2, A3, A4)> CallbackType;
+
+  CallbackList() {}
+
+  void Notify(typename cef_internal::CallbackParamTraits<A1>::ForwardType a1,
+              typename cef_internal::CallbackParamTraits<A2>::ForwardType a2,
+              typename cef_internal::CallbackParamTraits<A3>::ForwardType a3,
+              typename cef_internal::CallbackParamTraits<A4>::ForwardType a4) {
+    typename cef_internal::CallbackListBase<CallbackType>::Iterator it =
+        this->GetIterator();
+    CallbackType* cb;
+    while ((cb = it.GetNext()) != NULL) {
+      cb->Run(a1, a2, a3, a4);
+    }
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(CallbackList);
+};
+
+template <typename A1, typename A2, typename A3, typename A4, typename A5>
+class CallbackList<void(A1, A2, A3, A4, A5)>
+    : public cef_internal::CallbackListBase<Callback<void(A1, A2, A3, A4, A5)> > {
+ public:
+  typedef Callback<void(A1, A2, A3, A4, A5)> CallbackType;
+
+  CallbackList() {}
+
+  void Notify(typename cef_internal::CallbackParamTraits<A1>::ForwardType a1,
+              typename cef_internal::CallbackParamTraits<A2>::ForwardType a2,
+              typename cef_internal::CallbackParamTraits<A3>::ForwardType a3,
+              typename cef_internal::CallbackParamTraits<A4>::ForwardType a4,
+              typename cef_internal::CallbackParamTraits<A5>::ForwardType a5) {
+    typename cef_internal::CallbackListBase<CallbackType>::Iterator it =
+        this->GetIterator();
+    CallbackType* cb;
+    while ((cb = it.GetNext()) != NULL) {
+      cb->Run(a1, a2, a3, a4, a5);
+    }
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(CallbackList);
+};
+
+template <typename A1, typename A2, typename A3, typename A4, typename A5,
+    typename A6>
+class CallbackList<void(A1, A2, A3, A4, A5, A6)>
+    : public cef_internal::CallbackListBase<Callback<void(A1, A2, A3, A4, A5,
+        A6)> > {
+ public:
+  typedef Callback<void(A1, A2, A3, A4, A5, A6)> CallbackType;
+
+  CallbackList() {}
+
+  void Notify(typename cef_internal::CallbackParamTraits<A1>::ForwardType a1,
+              typename cef_internal::CallbackParamTraits<A2>::ForwardType a2,
+              typename cef_internal::CallbackParamTraits<A3>::ForwardType a3,
+              typename cef_internal::CallbackParamTraits<A4>::ForwardType a4,
+              typename cef_internal::CallbackParamTraits<A5>::ForwardType a5,
+              typename cef_internal::CallbackParamTraits<A6>::ForwardType a6) {
+    typename cef_internal::CallbackListBase<CallbackType>::Iterator it =
+        this->GetIterator();
+    CallbackType* cb;
+    while ((cb = it.GetNext()) != NULL) {
+      cb->Run(a1, a2, a3, a4, a5, a6);
+    }
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(CallbackList);
+};
+
+template <typename A1, typename A2, typename A3, typename A4, typename A5,
+    typename A6, typename A7>
+class CallbackList<void(A1, A2, A3, A4, A5, A6, A7)>
+    : public cef_internal::CallbackListBase<Callback<void(A1, A2, A3, A4, A5, A6,
+        A7)> > {
+ public:
+  typedef Callback<void(A1, A2, A3, A4, A5, A6, A7)> CallbackType;
+
+  CallbackList() {}
+
+  void Notify(typename cef_internal::CallbackParamTraits<A1>::ForwardType a1,
+              typename cef_internal::CallbackParamTraits<A2>::ForwardType a2,
+              typename cef_internal::CallbackParamTraits<A3>::ForwardType a3,
+              typename cef_internal::CallbackParamTraits<A4>::ForwardType a4,
+              typename cef_internal::CallbackParamTraits<A5>::ForwardType a5,
+              typename cef_internal::CallbackParamTraits<A6>::ForwardType a6,
+              typename cef_internal::CallbackParamTraits<A7>::ForwardType a7) {
+    typename cef_internal::CallbackListBase<CallbackType>::Iterator it =
+        this->GetIterator();
+    CallbackType* cb;
+    while ((cb = it.GetNext()) != NULL) {
+      cb->Run(a1, a2, a3, a4, a5, a6, a7);
+    }
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(CallbackList);
+};
+
+}  // namespace base
+
+#endif  // !BUILDING_CEF_SHARED
+
+#endif  // CEF_INCLUDE_BASE_CEF_CALLBACK_LIST_H_
diff --git a/src/include/libcef_/base/cef_cancelable_callback.h b/src/include/libcef_/base/cef_cancelable_callback.h
new file mode 100644
index 0000000..4125d89
--- /dev/null
+++ b/src/include/libcef_/base/cef_cancelable_callback.h
@@ -0,0 +1,314 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2011
+// Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// CancelableCallback is a wrapper around base::Callback that allows
+// cancellation of a callback. CancelableCallback takes a reference on the
+// wrapped callback until this object is destroyed or Reset()/Cancel() are
+// called.
+//
+// NOTE:
+//
+// Calling CancelableCallback::Cancel() brings the object back to its natural,
+// default-constructed state, i.e., CancelableCallback::callback() will return
+// a null callback.
+//
+// THREAD-SAFETY:
+//
+// CancelableCallback objects must be created on, posted to, cancelled on, and
+// destroyed on the same thread.
+//
+//
+// EXAMPLE USAGE:
+//
+// In the following example, the test is verifying that RunIntensiveTest()
+// Quit()s the message loop within 4 seconds. The cancelable callback is posted
+// to the message loop, the intensive test runs, the message loop is run,
+// then the callback is cancelled.
+//
+// void TimeoutCallback(const std::string& timeout_message) {
+//   FAIL() << timeout_message;
+//   MessageLoop::current()->QuitWhenIdle();
+// }
+//
+// CancelableClosure timeout(base::Bind(&TimeoutCallback, "Test timed out."));
+// MessageLoop::current()->PostDelayedTask(FROM_HERE, timeout.callback(),
+//                                         4000)  // 4 seconds to run.
+// RunIntensiveTest();
+// MessageLoop::current()->Run();
+// timeout.Cancel();  // Hopefully this is hit before the timeout callback runs.
+//
+
+#ifndef CEF_INCLUDE_BASE_CEF_CANCELABLE_CALLBACK_H_
+#define CEF_INCLUDE_BASE_CEF_CANCELABLE_CALLBACK_H_
+#pragma once
+
+#if defined(BASE_CANCELABLE_CALLBACK_H_)
+// Do nothing if the Chromium header has already been included.
+// This can happen in cases where Chromium code is used directly by the
+// client application. When using Chromium code directly always include
+// the Chromium header first to avoid type conflicts.
+#elif defined(BUILDING_CEF_SHARED)
+// When building CEF include the Chromium header directly.
+#include "base/cancelable_callback.h"
+#else  // !BUILDING_CEF_SHARED
+// The following is substantially similar to the Chromium implementation.
+// If the Chromium implementation diverges the below implementation should be
+// updated to match.
+
+#include"libcef/base/cef_bind.h"
+#include"libcef/base/cef_callback.h"
+#include"libcef/base/cef_build.h"
+#include"libcef/base/cef_logging.h"
+#include"libcef/base/cef_macros.h"
+#include"libcef/base/cef_weak_ptr.h"
+#include"libcef/base/internal/cef_callback_internal.h"
+
+namespace base {
+
+template <typename Sig>
+class CancelableCallback;
+
+template <>
+class CancelableCallback<void(void)> {
+ public:
+  CancelableCallback() : weak_factory_(this) {}
+
+  // |callback| must not be null.
+  explicit CancelableCallback(const base::Callback<void(void)>& callback)
+      : weak_factory_(this),
+        callback_(callback) {
+    DCHECK(!callback.is_null());
+    InitializeForwarder();
+  }
+
+  ~CancelableCallback() {}
+
+  // Cancels and drops the reference to the wrapped callback.
+  void Cancel() {
+    weak_factory_.InvalidateWeakPtrs();
+    forwarder_.Reset();
+    callback_.Reset();
+  }
+
+  // Returns true if the wrapped callback has been cancelled.
+  bool IsCancelled() const {
+    return callback_.is_null();
+  }
+
+  // Sets |callback| as the closure that may be cancelled. |callback| may not
+  // be null. Outstanding and any previously wrapped callbacks are cancelled.
+  void Reset(const base::Callback<void(void)>& callback) {
+    DCHECK(!callback.is_null());
+
+    // Outstanding tasks (e.g., posted to a message loop) must not be called.
+    Cancel();
+
+    // |forwarder_| is no longer valid after Cancel(), so re-bind.
+    InitializeForwarder();
+
+    callback_ = callback;
+  }
+
+  // Returns a callback that can be disabled by calling Cancel().
+  const base::Callback<void(void)>& callback() const {
+    return forwarder_;
+  }
+
+ private:
+  void Forward() {
+    callback_.Run();
+  }
+
+  // Helper method to bind |forwarder_| using a weak pointer from
+  // |weak_factory_|.
+  void InitializeForwarder() {
+    forwarder_ = base::Bind(&CancelableCallback<void(void)>::Forward,
+                            weak_factory_.GetWeakPtr());
+  }
+
+  // Used to ensure Forward() is not run when this object is destroyed.
+  base::WeakPtrFactory<CancelableCallback<void(void)> > weak_factory_;
+
+  // The wrapper closure.
+  base::Callback<void(void)> forwarder_;
+
+  // The stored closure that may be cancelled.
+  base::Callback<void(void)> callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(CancelableCallback);
+};
+
+template <typename A1>
+class CancelableCallback<void(A1)> {
+ public:
+  CancelableCallback() : weak_factory_(this) {}
+
+  // |callback| must not be null.
+  explicit CancelableCallback(const base::Callback<void(A1)>& callback)
+      : weak_factory_(this),
+        callback_(callback) {
+    DCHECK(!callback.is_null());
+    InitializeForwarder();
+  }
+
+  ~CancelableCallback() {}
+
+  // Cancels and drops the reference to the wrapped callback.
+  void Cancel() {
+    weak_factory_.InvalidateWeakPtrs();
+    forwarder_.Reset();
+    callback_.Reset();
+  }
+
+  // Returns true if the wrapped callback has been cancelled.
+  bool IsCancelled() const {
+    return callback_.is_null();
+  }
+
+  // Sets |callback| as the closure that may be cancelled. |callback| may not
+  // be null. Outstanding and any previously wrapped callbacks are cancelled.
+  void Reset(const base::Callback<void(A1)>& callback) {
+    DCHECK(!callback.is_null());
+
+    // Outstanding tasks (e.g., posted to a message loop) must not be called.
+    Cancel();
+
+    // |forwarder_| is no longer valid after Cancel(), so re-bind.
+    InitializeForwarder();
+
+    callback_ = callback;
+  }
+
+  // Returns a callback that can be disabled by calling Cancel().
+  const base::Callback<void(A1)>& callback() const {
+    return forwarder_;
+  }
+
+ private:
+  void Forward(A1 a1) const {
+    callback_.Run(a1);
+  }
+
+  // Helper method to bind |forwarder_| using a weak pointer from
+  // |weak_factory_|.
+  void InitializeForwarder() {
+    forwarder_ = base::Bind(&CancelableCallback<void(A1)>::Forward,
+                            weak_factory_.GetWeakPtr());
+  }
+
+  // Used to ensure Forward() is not run when this object is destroyed.
+  base::WeakPtrFactory<CancelableCallback<void(A1)> > weak_factory_;
+
+  // The wrapper closure.
+  base::Callback<void(A1)> forwarder_;
+
+  // The stored closure that may be cancelled.
+  base::Callback<void(A1)> callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(CancelableCallback);
+};
+
+template <typename A1, typename A2>
+class CancelableCallback<void(A1, A2)> {
+ public:
+  CancelableCallback() : weak_factory_(this) {}
+
+  // |callback| must not be null.
+  explicit CancelableCallback(const base::Callback<void(A1, A2)>& callback)
+      : weak_factory_(this),
+        callback_(callback) {
+    DCHECK(!callback.is_null());
+    InitializeForwarder();
+  }
+
+  ~CancelableCallback() {}
+
+  // Cancels and drops the reference to the wrapped callback.
+  void Cancel() {
+    weak_factory_.InvalidateWeakPtrs();
+    forwarder_.Reset();
+    callback_.Reset();
+  }
+
+  // Returns true if the wrapped callback has been cancelled.
+  bool IsCancelled() const {
+    return callback_.is_null();
+  }
+
+  // Sets |callback| as the closure that may be cancelled. |callback| may not
+  // be null. Outstanding and any previously wrapped callbacks are cancelled.
+  void Reset(const base::Callback<void(A1, A2)>& callback) {
+    DCHECK(!callback.is_null());
+
+    // Outstanding tasks (e.g., posted to a message loop) must not be called.
+    Cancel();
+
+    // |forwarder_| is no longer valid after Cancel(), so re-bind.
+    InitializeForwarder();
+
+    callback_ = callback;
+  }
+
+  // Returns a callback that can be disabled by calling Cancel().
+  const base::Callback<void(A1, A2)>& callback() const {
+    return forwarder_;
+  }
+
+ private:
+  void Forward(A1 a1, A2 a2) const {
+    callback_.Run(a1, a2);
+  }
+
+  // Helper method to bind |forwarder_| using a weak pointer from
+  // |weak_factory_|.
+  void InitializeForwarder() {
+    forwarder_ = base::Bind(&CancelableCallback<void(A1, A2)>::Forward,
+                            weak_factory_.GetWeakPtr());
+  }
+
+  // Used to ensure Forward() is not run when this object is destroyed.
+  base::WeakPtrFactory<CancelableCallback<void(A1, A2)> > weak_factory_;
+
+  // The wrapper closure.
+  base::Callback<void(A1, A2)> forwarder_;
+
+  // The stored closure that may be cancelled.
+  base::Callback<void(A1, A2)> callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(CancelableCallback);
+};
+
+typedef CancelableCallback<void(void)> CancelableClosure;
+
+}  // namespace base
+
+#endif  // !BUILDING_CEF_SHARED
+
+#endif  // CEF_INCLUDE_BASE_CEF_CANCELABLE_CALLBACK_H_
diff --git a/src/include/libcef_/base/cef_lock.h b/src/include/libcef_/base/cef_lock.h
new file mode 100644
index 0000000..2ec626c
--- /dev/null
+++ b/src/include/libcef_/base/cef_lock.h
@@ -0,0 +1,167 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2011
+// Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef CEF_INCLUDE_BASE_CEF_LOCK_H_
+#define CEF_INCLUDE_BASE_CEF_LOCK_H_
+#pragma once
+
+#if defined(BASE_SYNCHRONIZATION_LOCK_H_)
+// Do nothing if the Chromium header has already been included.
+// This can happen in cases where Chromium code is used directly by the
+// client application. When using Chromium code directly always include
+// the Chromium header first to avoid type conflicts.
+#elif defined(BUILDING_CEF_SHARED)
+// When building CEF include the Chromium header directly.
+#include "base/synchronization/lock.h"
+#else  // !BUILDING_CEF_SHARED
+// The following is substantially similar to the Chromium implementation.
+// If the Chromium implementation diverges the below implementation should be
+// updated to match.
+
+#include"libcef/base/cef_macros.h"
+#include"libcef/base/cef_platform_thread.h"
+#include"libcef/base/internal/cef_lock_impl.h"
+
+namespace base {
+
+// A convenient wrapper for an OS specific critical section.  The only real
+// intelligence in this class is in debug mode for the support for the
+// AssertAcquired() method.
+class Lock {
+ public:
+#if defined(NDEBUG)             // Optimized wrapper implementation
+  Lock() : lock_() {}
+  ~Lock() {}
+  void Acquire() { lock_.Lock(); }
+  void Release() { lock_.Unlock(); }
+
+  // If the lock is not held, take it and return true. If the lock is already
+  // held by another thread, immediately return false. This must not be called
+  // by a thread already holding the lock (what happens is undefined and an
+  // assertion may fail).
+  bool Try() { return lock_.Try(); }
+
+  // Null implementation if not debug.
+  void AssertAcquired() const {}
+#else
+  Lock();
+  ~Lock();
+
+  // NOTE: Although windows critical sections support recursive locks, we do not
+  // allow this, and we will commonly fire a DCHECK() if a thread attempts to
+  // acquire the lock a second time (while already holding it).
+  void Acquire() {
+    lock_.Lock();
+    CheckUnheldAndMark();
+  }
+  void Release() {
+    CheckHeldAndUnmark();
+    lock_.Unlock();
+  }
+
+  bool Try() {
+    bool rv = lock_.Try();
+    if (rv) {
+      CheckUnheldAndMark();
+    }
+    return rv;
+  }
+
+  void AssertAcquired() const;
+#endif                          // NDEBUG
+
+ private:
+#if !defined(NDEBUG)
+  // Members and routines taking care of locks assertions.
+  // Note that this checks for recursive locks and allows them
+  // if the variable is set.  This is allowed by the underlying implementation
+  // on windows but not on Posix, so we're doing unneeded checks on Posix.
+  // It's worth it to share the code.
+  void CheckHeldAndUnmark();
+  void CheckUnheldAndMark();
+
+  // All private data is implicitly protected by lock_.
+  // Be VERY careful to only access members under that lock.
+  base::PlatformThreadRef owning_thread_ref_;
+#endif  // NDEBUG
+
+  // Platform specific underlying lock implementation.
+  cef_internal::LockImpl lock_;
+
+  DISALLOW_COPY_AND_ASSIGN(Lock);
+};
+
+// A helper class that acquires the given Lock while the AutoLock is in scope.
+class AutoLock {
+ public:
+  struct AlreadyAcquired {};
+
+  explicit AutoLock(Lock& lock) : lock_(lock) {
+    lock_.Acquire();
+  }
+
+  AutoLock(Lock& lock, const AlreadyAcquired&) : lock_(lock) {
+    lock_.AssertAcquired();
+  }
+
+  ~AutoLock() {
+    lock_.AssertAcquired();
+    lock_.Release();
+  }
+
+ private:
+  Lock& lock_;
+  DISALLOW_COPY_AND_ASSIGN(AutoLock);
+};
+
+// AutoUnlock is a helper that will Release() the |lock| argument in the
+// constructor, and re-Acquire() it in the destructor.
+class AutoUnlock {
+ public:
+  explicit AutoUnlock(Lock& lock) : lock_(lock) {
+    // We require our caller to have the lock.
+    lock_.AssertAcquired();
+    lock_.Release();
+  }
+
+  ~AutoUnlock() {
+    lock_.Acquire();
+  }
+
+ private:
+  Lock& lock_;
+  DISALLOW_COPY_AND_ASSIGN(AutoUnlock);
+};
+
+}  // namespace base
+
+#endif  // !BUILDING_CEF_SHARED
+
+#endif  // CEF_INCLUDE_BASE_CEF_LOCK_H_
diff --git a/src/include/libcef_/base/cef_logging.h b/src/include/libcef_/base/cef_logging.h
new file mode 100644
index 0000000..1c82c0f
--- /dev/null
+++ b/src/include/libcef_/base/cef_logging.h
@@ -0,0 +1,771 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2012
+// Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file are only available to applications that link
+// against the libcef_dll_wrapper target.
+//
+// WARNING: Logging macros should not be used in the main/browser process before
+// calling CefInitialize or in sub-processes before calling CefExecuteProcess.
+//
+// Instructions
+// ------------
+//
+// Make a bunch of macros for logging.  The way to log things is to stream
+// things to LOG(<a particular severity level>).  E.g.,
+//
+//   LOG(INFO) << "Found " << num_cookies << " cookies";
+//
+// You can also do conditional logging:
+//
+//   LOG_IF(INFO, num_cookies > 10) << "Got lots of cookies";
+//
+// The CHECK(condition) macro is active in both debug and release builds and
+// effectively performs a LOG(FATAL) which terminates the process and
+// generates a crashdump unless a debugger is attached.
+//
+// There are also "debug mode" logging macros like the ones above:
+//
+//   DLOG(INFO) << "Found cookies";
+//
+//   DLOG_IF(INFO, num_cookies > 10) << "Got lots of cookies";
+//
+// All "debug mode" logging is compiled away to nothing for non-debug mode
+// compiles.  LOG_IF and development flags also work well together
+// because the code can be compiled away sometimes.
+//
+// We also have
+//
+//   LOG_ASSERT(assertion);
+//   DLOG_ASSERT(assertion);
+//
+// which is syntactic sugar for {,D}LOG_IF(FATAL, assert fails) << assertion;
+//
+// There are "verbose level" logging macros.  They look like
+//
+//   VLOG(1) << "I'm printed when you run the program with --v=1 or more";
+//   VLOG(2) << "I'm printed when you run the program with --v=2 or more";
+//
+// These always log at the INFO log level (when they log at all).
+// The verbose logging can also be turned on module-by-module.  For instance,
+//    --vmodule=profile=2,icon_loader=1,browser_*=3,*/chromeos/*=4 --v=0
+// will cause:
+//   a. VLOG(2) and lower messages to be printed from profile.{h,cc}
+//   b. VLOG(1) and lower messages to be printed from icon_loader.{h,cc}
+//   c. VLOG(3) and lower messages to be printed from files prefixed with
+//      "browser"
+//   d. VLOG(4) and lower messages to be printed from files under a
+//     "chromeos" directory.
+//   e. VLOG(0) and lower messages to be printed from elsewhere
+//
+// The wildcarding functionality shown by (c) supports both '*' (match
+// 0 or more characters) and '?' (match any single character)
+// wildcards.  Any pattern containing a forward or backward slash will
+// be tested against the whole pathname and not just the module.
+// E.g., "*/foo/bar/*=2" would change the logging level for all code
+// in source files under a "foo/bar" directory.
+//
+// There's also VLOG_IS_ON(n) "verbose level" condition macro. To be used as
+//
+//   if (VLOG_IS_ON(2)) {
+//     // do some logging preparation and logging
+//     // that can't be accomplished with just VLOG(2) << ...;
+//   }
+//
+// There is also a VLOG_IF "verbose level" condition macro for sample
+// cases, when some extra computation and preparation for logs is not
+// needed.
+//
+//   VLOG_IF(1, (size > 1024))
+//      << "I'm printed when size is more than 1024 and when you run the "
+//         "program with --v=1 or more";
+//
+// We also override the standard 'assert' to use 'DLOG_ASSERT'.
+//
+// Lastly, there is:
+//
+//   PLOG(ERROR) << "Couldn't do foo";
+//   DPLOG(ERROR) << "Couldn't do foo";
+//   PLOG_IF(ERROR, cond) << "Couldn't do foo";
+//   DPLOG_IF(ERROR, cond) << "Couldn't do foo";
+//   PCHECK(condition) << "Couldn't do foo";
+//   DPCHECK(condition) << "Couldn't do foo";
+//
+// which append the last system error to the message in string form (taken from
+// GetLastError() on Windows and errno on POSIX).
+//
+// The supported severity levels for macros that allow you to specify one
+// are (in increasing order of severity) INFO, WARNING, ERROR, and FATAL.
+//
+// Very important: logging a message at the FATAL severity level causes
+// the program to terminate (after the message is logged).
+//
+// There is the special severity of DFATAL, which logs FATAL in debug mode,
+// ERROR in normal mode.
+//
+
+#ifndef CEF_INCLUDE_BASE_CEF_LOGGING_H_
+#define CEF_INCLUDE_BASE_CEF_LOGGING_H_
+#pragma once
+
+#if defined(DCHECK)
+// Do nothing if the macros provided by this header already exist.
+// This can happen in cases where Chromium code is used directly by the
+// client application. When using Chromium code directly always include
+// the Chromium header first to avoid type conflicts.
+
+// Always define the DCHECK_IS_ON macro which is used from other CEF headers.
+#if defined(NDEBUG) && !defined(DCHECK_ALWAYS_ON)
+#define DCHECK_IS_ON() 0
+#else
+#define DCHECK_IS_ON() 1
+#endif
+
+#elif defined(BUILDING_CEF_SHARED)
+// When building CEF include the Chromium header directly.
+#include "base/logging.h"
+#else  // !BUILDING_CEF_SHARED
+// The following is substantially similar to the Chromium implementation.
+// If the Chromium implementation diverges the below implementation should be
+// updated to match.
+
+#include<strstream> // to fix watcom compatibility
+
+#include<cassert>
+#include<string>
+#include<iostream>
+#include<cstring>
+#include<sstream>
+
+#include<stdio.h>
+#include<stdlib.h>
+#include<string.h>
+
+#include"libcef/base/cef_build.h"
+#include"libcef/base/cef_macros.h"
+#include"libcef/internal/cef_logging_internal.h"
+
+namespace cef {
+namespace logging {
+
+// Gets the current log level.
+inline int GetMinLogLevel() {
+  return cef_get_min_log_level();
+}
+
+// Gets the current vlog level for the given file (usually taken from
+// __FILE__). Note that |N| is the size *with* the null terminator.
+template <size_t N>
+int GetVlogLevel(const char (&file)[N]) {
+  return cef_get_vlog_level(file, N);
+}
+
+typedef int LogSeverity;
+const LogSeverity LOG_VERBOSE = -1;  // This is level 1 verbosity
+// Note: the log severities are used to index into the array of names,
+// see log_severity_names.
+const LogSeverity LOG_INFO = 0;
+const LogSeverity LOG_WARNING = 1;
+const LogSeverity LOG_ERROR = 2;
+const LogSeverity LOG_FATAL = 3;
+const LogSeverity LOG_NUM_SEVERITIES = 4;
+
+// LOG_DFATAL is LOG_FATAL in debug mode, ERROR in normal mode
+#ifdef NDEBUG
+const LogSeverity LOG_DFATAL = LOG_ERROR;
+#else
+const LogSeverity LOG_DFATAL = LOG_FATAL;
+#endif
+
+// A few definitions of macros that don't generate much code. These are used
+// by LOG() and LOG_IF, etc. Since these are used all over our code, it's
+// better to have compact code for these operations.
+#define COMPACT_GOOGLE_LOG_EX_INFO(ClassName, ...) \
+  cef::logging::ClassName(__FILE__, __LINE__, cef::logging::LOG_INFO , \
+                         ##__VA_ARGS__)
+#define COMPACT_GOOGLE_LOG_EX_WARNING(ClassName, ...) \
+  cef::logging::ClassName(__FILE__, __LINE__, cef::logging::LOG_WARNING , \
+                         ##__VA_ARGS__)
+#define COMPACT_GOOGLE_LOG_EX_ERROR(ClassName, ...) \
+  cef::logging::ClassName(__FILE__, __LINE__, cef::logging::LOG_ERROR , \
+                         ##__VA_ARGS__)
+#define COMPACT_GOOGLE_LOG_EX_FATAL(ClassName, ...) \
+  cef::logging::ClassName(__FILE__, __LINE__, cef::logging::LOG_FATAL , \
+                         ##__VA_ARGS__)
+#define COMPACT_GOOGLE_LOG_EX_DFATAL(ClassName, ...) \
+  cef::logging::ClassName(__FILE__, __LINE__, cef::logging::LOG_DFATAL , \
+                         ##__VA_ARGS__)
+
+#define COMPACT_GOOGLE_LOG_INFO \
+  COMPACT_GOOGLE_LOG_EX_INFO(LogMessage)
+#define COMPACT_GOOGLE_LOG_WARNING \
+  COMPACT_GOOGLE_LOG_EX_WARNING(LogMessage)
+#define COMPACT_GOOGLE_LOG_ERROR \
+  COMPACT_GOOGLE_LOG_EX_ERROR(LogMessage)
+#define COMPACT_GOOGLE_LOG_FATAL \
+  COMPACT_GOOGLE_LOG_EX_FATAL(LogMessage)
+#define COMPACT_GOOGLE_LOG_DFATAL \
+  COMPACT_GOOGLE_LOG_EX_DFATAL(LogMessage)
+
+#if defined(OS_WIN)
+// wingdi.h defines ERROR to be 0. When we call LOG(ERROR), it gets
+// substituted with 0, and it expands to COMPACT_GOOGLE_LOG_0. To allow us
+// to keep using this syntax, we define this macro to do the same thing
+// as COMPACT_GOOGLE_LOG_ERROR, and also define ERROR the same way that
+// the Windows SDK does for consistency.
+#define ERROR 0
+#define COMPACT_GOOGLE_LOG_EX_0(ClassName, ...) \
+  COMPACT_GOOGLE_LOG_EX_ERROR(ClassName , ##__VA_ARGS__)
+#define COMPACT_GOOGLE_LOG_0 COMPACT_GOOGLE_LOG_ERROR
+// Needed for LOG_IS_ON(ERROR).
+const LogSeverity LOG_0 = LOG_ERROR;
+#endif
+
+// As special cases, we can assume that LOG_IS_ON(FATAL) always holds. Also,
+// LOG_IS_ON(DFATAL) always holds in debug mode. In particular, CHECK()s will
+// always fire if they fail.
+#define LOG_IS_ON(severity) \
+  ((::cef::logging::LOG_ ## severity) >= ::cef::logging::GetMinLogLevel())
+
+// We can't do any caching tricks with VLOG_IS_ON() like the
+// google-glog version since it requires GCC extensions.  This means
+// that using the v-logging functions in conjunction with --vmodule
+// may be slow.
+#define VLOG_IS_ON(verboselevel) \
+  ((verboselevel) <= ::cef::logging::GetVlogLevel(__FILE__))
+
+// Helper macro which avoids evaluating the arguments to a stream if
+// the condition doesn't hold.
+#define LAZY_STREAM(stream, condition)                                  \
+  !(condition) ? (void) 0 : ::cef::logging::LogMessageVoidify() & (stream)
+
+// We use the preprocessor's merging operator, "##", so that, e.g.,
+// LOG(INFO) becomes the token COMPACT_GOOGLE_LOG_INFO.  There's some funny
+// subtle difference between ostream member streaming functions (e.g.,
+// ostream::operator<<(int) and ostream non-member streaming functions
+// (e.g., ::operator<<(ostream&, string&): it turns out that it's
+// impossible to stream something like a string directly to an unnamed
+// ostream. We employ a neat hack by calling the stream() member
+// function of LogMessage which seems to avoid the problem.
+#define LOG_STREAM(severity) COMPACT_GOOGLE_LOG_ ## severity.stream()
+
+#define LOG(severity) LAZY_STREAM(LOG_STREAM(severity), LOG_IS_ON(severity))
+#define LOG_IF(severity, condition) \
+  LAZY_STREAM(LOG_STREAM(severity), LOG_IS_ON(severity) && (condition))
+
+#define SYSLOG(severity) LOG(severity)
+#define SYSLOG_IF(severity, condition) LOG_IF(severity, condition)
+
+// The VLOG macros log with negative verbosities.
+#define VLOG_STREAM(verbose_level) \
+  cef::logging::LogMessage(__FILE__, __LINE__, -verbose_level).stream()
+
+#define VLOG(verbose_level) \
+  LAZY_STREAM(VLOG_STREAM(verbose_level), VLOG_IS_ON(verbose_level))
+
+#define VLOG_IF(verbose_level, condition) \
+  LAZY_STREAM(VLOG_STREAM(verbose_level), \
+      VLOG_IS_ON(verbose_level) && (condition))
+
+#if defined (OS_WIN)
+#define VPLOG_STREAM(verbose_level) \
+  cef::logging::Win32ErrorLogMessage(__FILE__, __LINE__, -verbose_level, \
+    ::cef::logging::GetLastSystemErrorCode()).stream()
+#elif defined(OS_POSIX)
+#define VPLOG_STREAM(verbose_level) \
+  cef::logging::ErrnoLogMessage(__FILE__, __LINE__, -verbose_level, \
+    ::cef::logging::GetLastSystemErrorCode()).stream()
+#endif
+
+#define VPLOG(verbose_level) \
+  LAZY_STREAM(VPLOG_STREAM(verbose_level), VLOG_IS_ON(verbose_level))
+
+#define VPLOG_IF(verbose_level, condition) \
+  LAZY_STREAM(VPLOG_STREAM(verbose_level), \
+    VLOG_IS_ON(verbose_level) && (condition))
+
+// TODO(akalin): Add more VLOG variants, e.g. VPLOG.
+
+#define LOG_ASSERT(condition)  \
+  LOG_IF(FATAL, !(condition)) << "Assert failed: " #condition ". "
+#define SYSLOG_ASSERT(condition) \
+  SYSLOG_IF(FATAL, !(condition)) << "Assert failed: " #condition ". "
+
+#if defined(OS_WIN)
+#define PLOG_STREAM(severity) \
+  COMPACT_GOOGLE_LOG_EX_ ## severity(Win32ErrorLogMessage, \
+      ::cef::logging::GetLastSystemErrorCode()).stream()
+#elif defined(OS_POSIX)
+#define PLOG_STREAM(severity) \
+  COMPACT_GOOGLE_LOG_EX_ ## severity(ErrnoLogMessage, \
+      ::cef::logging::GetLastSystemErrorCode()).stream()
+#endif
+
+#define PLOG(severity)                                          \
+  LAZY_STREAM(PLOG_STREAM(severity), LOG_IS_ON(severity))
+
+#define PLOG_IF(severity, condition) \
+  LAZY_STREAM(PLOG_STREAM(severity), LOG_IS_ON(severity) && (condition))
+
+// The actual stream used isn't important.
+#define EAT_STREAM_PARAMETERS                                           \
+  true ? (void) 0 : ::cef::logging::LogMessageVoidify() & LOG_STREAM(FATAL)
+
+// CHECK dies with a fatal error if condition is not true.  It is *not*
+// controlled by NDEBUG, so the check will be executed regardless of
+// compilation mode.
+//
+// We make sure CHECK et al. always evaluates their arguments, as
+// doing CHECK(FunctionWithSideEffect()) is a common idiom.
+
+#define CHECK(condition)                       \
+  LAZY_STREAM(LOG_STREAM(FATAL), !(condition)) \
+  << "Check failed: " #condition ". "
+
+#define PCHECK(condition) \
+  LAZY_STREAM(PLOG_STREAM(FATAL), !(condition)) \
+  << "Check failed: " #condition ". "
+
+// Helper macro for binary operators.
+// Don't use this macro directly in your code, use CHECK_EQ et al below.
+//
+// TODO(akalin): Rewrite this so that constructs like if (...)
+// CHECK_EQ(...) else { ... } work properly.
+#define CHECK_OP(name, op, val1, val2)                          \
+  if (std::string* _result =                                    \
+      cef::logging::Check##name##Impl((val1), (val2),                \
+                                 #val1 " " #op " " #val2))      \
+    cef::logging::LogMessage(__FILE__, __LINE__, _result).stream()
+
+// Build the error message string.  This is separate from the "Impl"
+// function template because it is not performance critical and so can
+// be out of line, while the "Impl" code should be inline.  Caller
+// takes ownership of the returned string.
+template<class t1, class t2>
+std::string* MakeCheckOpString(const t1& v1, const t2& v2, const char* names) 
+{
+  /*std::ostringstream ss;
+  ss << names << " (" << v1 << " vs. " << v2 << ")";
+  std::string* msg = new std::string(ss.str());
+  return msg;*/
+
+  char buffer[512];
+  sprintf(buffer, "%s (%d vs. %d)", names, (int)v1, (int)v2);
+  return new std::string(buffer);
+
+}
+
+// MSVC doesn't like complex extern templates and DLLs.
+#if !defined(COMPILER_MSVC) && !defined(COMPILER_WATCOM)
+// Commonly used instantiations of MakeCheckOpString<>. Explicitly instantiated
+// in logging.cc.
+//extern template std::string* MakeCheckOpString<int, int>(const int&, const int&, const char* names);
+//extern template std::string* MakeCheckOpString<unsigned long, unsigned long>(const unsigned long&, const unsigned long&, const char* names);
+//extern template std::string* MakeCheckOpString<unsigned long, unsigned int>(const unsigned long&,  const unsigned int&,  const char* names);
+//extern template std::string* MakeCheckOpString<unsigned int,  unsigned long>(const unsigned int&,  const unsigned long&, const char* names);
+//extern template std::string* MakeCheckOpString<std::string, std::string>(const std::string&, const std::string&, const char* name);
+#endif
+
+// Helper functions for CHECK_OP macro.
+// The (int, int) specialization works around the issue that the compiler
+// will not instantiate the template version of the function on values of
+// unnamed enum type - see comment below.
+#define DEFINE_CHECK_OP_IMPL(name, op) \
+  template <class t1, class t2> \
+  inline std::string* Check##name##Impl(const t1& v1, const t2& v2, \
+                                        const char* names) { \
+    if (v1 op v2) return NULL; \
+    else return MakeCheckOpString(v1, v2, names); \
+  } \
+  inline std::string* Check##name##Impl(int v1, int v2, const char* names) { \
+    if (v1 op v2) return NULL; \
+    else return MakeCheckOpString(v1, v2, names); \
+  }
+DEFINE_CHECK_OP_IMPL(EQ, ==)
+DEFINE_CHECK_OP_IMPL(NE, !=)
+DEFINE_CHECK_OP_IMPL(LE, <=)
+DEFINE_CHECK_OP_IMPL(LT, < )
+DEFINE_CHECK_OP_IMPL(GE, >=)
+DEFINE_CHECK_OP_IMPL(GT, > )
+#undef DEFINE_CHECK_OP_IMPL
+
+#define CHECK_EQ(val1, val2) CHECK_OP(EQ, ==, val1, val2)
+#define CHECK_NE(val1, val2) CHECK_OP(NE, !=, val1, val2)
+#define CHECK_LE(val1, val2) CHECK_OP(LE, <=, val1, val2)
+#define CHECK_LT(val1, val2) CHECK_OP(LT, < , val1, val2)
+#define CHECK_GE(val1, val2) CHECK_OP(GE, >=, val1, val2)
+#define CHECK_GT(val1, val2) CHECK_OP(GT, > , val1, val2)
+
+#if defined(NDEBUG)
+  #define ENABLE_DLOG 0
+#else
+  #define ENABLE_DLOG 1
+#endif
+
+#if defined(NDEBUG) && !defined(DCHECK_ALWAYS_ON)
+  #define DCHECK_IS_ON() 0
+#else
+  #define DCHECK_IS_ON() 1
+#endif
+
+// Definitions for DLOG et al.
+
+#if ENABLE_DLOG
+
+#define DLOG_IS_ON(severity) LOG_IS_ON(severity)
+#define DLOG_IF(severity, condition) LOG_IF(severity, condition)
+#define DLOG_ASSERT(condition) LOG_ASSERT(condition)
+#define DPLOG_IF(severity, condition) PLOG_IF(severity, condition)
+#define DVLOG_IF(verboselevel, condition) VLOG_IF(verboselevel, condition)
+#define DVPLOG_IF(verboselevel, condition) VPLOG_IF(verboselevel, condition)
+
+#else  // ENABLE_DLOG
+
+// If ENABLE_DLOG is off, we want to avoid emitting any references to
+// |condition| (which may reference a variable defined only if NDEBUG
+// is not defined).  Contrast this with DCHECK et al., which has
+// different behavior.
+
+#define DLOG_IS_ON(severity) false
+#define DLOG_IF(severity, condition) EAT_STREAM_PARAMETERS
+#define DLOG_ASSERT(condition) EAT_STREAM_PARAMETERS
+#define DPLOG_IF(severity, condition) EAT_STREAM_PARAMETERS
+#define DVLOG_IF(verboselevel, condition) EAT_STREAM_PARAMETERS
+#define DVPLOG_IF(verboselevel, condition) EAT_STREAM_PARAMETERS
+
+#endif  // ENABLE_DLOG
+
+// DEBUG_MODE is for uses like
+//   if (DEBUG_MODE) foo.CheckThatFoo();
+// instead of
+//   #ifndef NDEBUG
+//     foo.CheckThatFoo();
+//   #endif
+//
+// We tie its state to ENABLE_DLOG.
+enum { DEBUG_MODE = ENABLE_DLOG };
+
+#undef ENABLE_DLOG
+
+#define DLOG(severity)                                          \
+  LAZY_STREAM(LOG_STREAM(severity), DLOG_IS_ON(severity))
+
+#define DPLOG(severity)                                         \
+  LAZY_STREAM(PLOG_STREAM(severity), DLOG_IS_ON(severity))
+
+#define DVLOG(verboselevel) DVLOG_IF(verboselevel, VLOG_IS_ON(verboselevel))
+
+#define DVPLOG(verboselevel) DVPLOG_IF(verboselevel, VLOG_IS_ON(verboselevel))
+
+// Definitions for DCHECK et al.
+
+#if DCHECK_IS_ON()
+
+#define COMPACT_GOOGLE_LOG_EX_DCHECK(ClassName, ...) \
+  COMPACT_GOOGLE_LOG_EX_FATAL(ClassName , ##__VA_ARGS__)
+#define COMPACT_GOOGLE_LOG_DCHECK COMPACT_GOOGLE_LOG_FATAL
+const LogSeverity LOG_DCHECK = LOG_FATAL;
+
+#else  // DCHECK_IS_ON()
+
+// These are just dummy values.
+#define COMPACT_GOOGLE_LOG_EX_DCHECK(ClassName, ...) \
+  COMPACT_GOOGLE_LOG_EX_INFO(ClassName , ##__VA_ARGS__)
+#define COMPACT_GOOGLE_LOG_DCHECK COMPACT_GOOGLE_LOG_INFO
+const LogSeverity LOG_DCHECK = LOG_INFO;
+
+#endif  // DCHECK_IS_ON()
+
+// DCHECK et al. make sure to reference |condition| regardless of
+// whether DCHECKs are enabled; this is so that we don't get unused
+// variable warnings if the only use of a variable is in a DCHECK.
+// This behavior is different from DLOG_IF et al.
+
+#define DCHECK(condition)                                           \
+  LAZY_STREAM(LOG_STREAM(DCHECK), DCHECK_IS_ON() && !(condition))   \
+      << "Check failed: " #condition ". "
+
+#define DPCHECK(condition)                                          \
+  LAZY_STREAM(PLOG_STREAM(DCHECK), DCHECK_IS_ON() && !(condition))  \
+      << "Check failed: " #condition ". "
+
+// Helper macro for binary operators.
+// Don't use this macro directly in your code, use DCHECK_EQ et al below.
+#define DCHECK_OP(name, op, val1, val2)                                   \
+  if (DCHECK_IS_ON())                                                     \
+    if (std::string* _result = cef::logging::Check##name##Impl(           \
+            (val1), (val2), #val1 " " #op " " #val2))                     \
+  cef::logging::LogMessage(__FILE__, __LINE__,                            \
+      ::cef::logging::LOG_DCHECK, _result).stream()
+
+// Equality/Inequality checks - compare two values, and log a
+// LOG_DCHECK message including the two values when the result is not
+// as expected.  The values must have operator<<(ostream, ...)
+// defined.
+//
+// You may append to the error message like so:
+//   DCHECK_NE(1, 2) << ": The world must be ending!";
+//
+// We are very careful to ensure that each argument is evaluated exactly
+// once, and that anything which is legal to pass as a function argument is
+// legal here.  In particular, the arguments may be temporary expressions
+// which will end up being destroyed at the end of the apparent statement,
+// for example:
+//   DCHECK_EQ(string("abc")[1], 'b');
+//
+// WARNING: These may not compile correctly if one of the arguments is a pointer
+// and the other is NULL. To work around this, simply static_cast NULL to the
+// type of the desired pointer.
+
+#define DCHECK_EQ(val1, val2) DCHECK_OP(EQ, ==, val1, val2)
+#define DCHECK_NE(val1, val2) DCHECK_OP(NE, !=, val1, val2)
+#define DCHECK_LE(val1, val2) DCHECK_OP(LE, <=, val1, val2)
+#define DCHECK_LT(val1, val2) DCHECK_OP(LT, < , val1, val2)
+#define DCHECK_GE(val1, val2) DCHECK_OP(GE, >=, val1, val2)
+#define DCHECK_GT(val1, val2) DCHECK_OP(GT, > , val1, val2)
+
+#if defined(NDEBUG) && defined(OS_CHROMEOS)
+#define NOTREACHED() LOG(ERROR) << "NOTREACHED() hit in " << \
+    __FUNCTION__ << ". "
+#else
+#define NOTREACHED() DCHECK(false)
+#endif
+
+
+
+// Redefine the standard assert to use our nice log files
+#undef assert
+#define assert(x) DLOG_ASSERT(x)
+
+// This class more or less represents a particular log message.  You
+// create an instance of LogMessage and then stream stuff to it.
+// When you finish streaming to it, ~LogMessage is called and the
+// full message gets streamed to the appropriate destination.
+//
+// You shouldn't actually use LogMessage's constructor to log things,
+// though.  You should use the LOG() macro (and variants thereof)
+// above.
+class LogMessage 
+{
+  public:
+  
+    // Used for LOG(severity).
+    LogMessage(const char* file, int line, LogSeverity severity);
+
+    // Used for CHECK_EQ(), etc. Takes ownership of the given string.
+    // Implied severity = LOG_FATAL.
+    LogMessage(const char* file, int line, std::string* result);
+
+    // Used for DCHECK_EQ(), etc. Takes ownership of the given string.
+    LogMessage(const char* file, int line, LogSeverity severity, std::string* result);
+
+    ~LogMessage();
+
+    std::ostream& stream() { return stream_; }
+
+     private:
+      LogSeverity severity_;
+      //std::ostringstream stream_;
+      std::strstream stream_;
+
+      // The file and line information passed in to the constructor.
+      const char* file_;
+      const int line_;
+
+    #if defined(OS_WIN)
+      // Stores the current value of GetLastError in the constructor and restores
+      // it in the destructor by calling SetLastError.
+      // This is useful since the LogMessage class uses a lot of Win32 calls
+      // that will lose the value of GLE and the code that called the log function
+      // will have lost the thread error value when the log call returns.
+      class SaveLastError 
+      {
+          public:
+          SaveLastError();
+          ~SaveLastError();
+
+          unsigned long get_error() const { return last_error_; }
+
+        protected:
+          unsigned long last_error_;
+      };
+
+      SaveLastError last_error_;
+    #endif
+
+      DISALLOW_COPY_AND_ASSIGN(LogMessage);
+};
+
+// A non-macro interface to the log facility; (useful
+// when the logging level is not a compile-time constant).
+inline void LogAtLevel(int const log_level, std::string const &msg) 
+{
+  //LogMessage(__FILE__, __LINE__, log_level).stream() << msg;
+  #if defined(__WATCOMC__)
+    // Implementação simplificada para Watcom
+    LogMessage(__FILE__, __LINE__, log_level).stream() << msg.c_str();
+  #else
+    // Implementação original para outros compiladores
+    //LogMessage(__FILE__, __LINE__, log_level).stream() << msg;
+    LogMessage(__FILE__, __LINE__, log_level).stream() << msg.c_str();
+  #endif
+}
+
+// This class is used to explicitly ignore values in the conditional
+// logging macros.  This avoids compiler warnings like "value computed
+// is not used" and "statement has no effect".
+class LogMessageVoidify {
+ public:
+  LogMessageVoidify() { }
+  // This has to be an operator with a precedence lower than << but
+  // higher than ?:
+  void operator&(std::ostream&) { }
+};
+
+#if defined(OS_WIN)
+  typedef unsigned long SystemErrorCode;
+#elif defined(OS_POSIX)
+  typedef int SystemErrorCode;
+#endif
+
+// Alias for ::GetLastError() on Windows and errno on POSIX. Avoids having to
+// pull in windows.h just for GetLastError() and DWORD.
+SystemErrorCode GetLastSystemErrorCode();
+std::string SystemErrorCodeToString(SystemErrorCode error_code);
+
+#if defined(OS_WIN)
+// Appends a formatted system message of the GetLastError() type.
+class Win32ErrorLogMessage 
+{
+ public:
+  Win32ErrorLogMessage(const char* file,
+                       int line,
+                       LogSeverity severity,
+                       SystemErrorCode err);
+
+  // Appends the error message before destructing the encapsulated class.
+  ~Win32ErrorLogMessage();
+
+  std::ostream& stream() { return log_message_.stream(); }
+
+ private:
+  SystemErrorCode err_;
+  LogMessage log_message_;
+
+  DISALLOW_COPY_AND_ASSIGN(Win32ErrorLogMessage);
+};
+#elif defined(OS_POSIX)
+// Appends a formatted system message of the errno type
+class ErrnoLogMessage {
+ public:
+  ErrnoLogMessage(const char* file,
+                  int line,
+                  LogSeverity severity,
+                  SystemErrorCode err);
+
+  // Appends the error message before destructing the encapsulated class.
+  ~ErrnoLogMessage();
+
+  std::ostream& stream() { return log_message_.stream(); }
+
+ private:
+  SystemErrorCode err_;
+  LogMessage log_message_;
+
+  DISALLOW_COPY_AND_ASSIGN(ErrnoLogMessage);
+};
+#endif  // OS_WIN
+
+}  // namespace logging
+}  // namespace cef
+
+// These functions are provided as a convenience for logging, which is where we
+// use streams (it is against Google style to use streams in other places). It
+// is designed to allow you to emit non-ASCII Unicode strings to the log file,
+// which is normally ASCII. It is relatively slow, so try not to use it for
+// common cases. Non-ASCII characters will be converted to UTF-8 by these
+// operators.
+std::ostream& operator<<(std::ostream& out, const wchar_t* wstr);
+inline std::ostream& operator<<(std::ostream& out, const std::wstring& wstr) {
+  return out << wstr.c_str();
+}
+
+// The NOTIMPLEMENTED() macro annotates codepaths which have
+// not been implemented yet.
+//
+// The implementation of this macro is controlled by NOTIMPLEMENTED_POLICY:
+//   0 -- Do nothing (stripped by compiler)
+//   1 -- Warn at compile time
+//   2 -- Fail at compile time
+//   3 -- Fail at runtime (DCHECK)
+//   4 -- [default] LOG(ERROR) at runtime
+//   5 -- LOG(ERROR) at runtime, only once per call-site
+
+#ifndef NOTIMPLEMENTED_POLICY
+#if defined(OS_ANDROID) && defined(OFFICIAL_BUILD)
+#define NOTIMPLEMENTED_POLICY 0
+#else
+// Select default policy: LOG(ERROR)
+#define NOTIMPLEMENTED_POLICY 4
+#endif
+#endif
+
+#if defined(COMPILER_GCC)
+// On Linux, with GCC, we can use __PRETTY_FUNCTION__ to get the demangled name
+// of the current function in the NOTIMPLEMENTED message.
+#define NOTIMPLEMENTED_MSG "Not implemented reached in " << __PRETTY_FUNCTION__
+#else
+#define NOTIMPLEMENTED_MSG "NOT IMPLEMENTED"
+#endif
+
+#if NOTIMPLEMENTED_POLICY == 0
+  #define NOTIMPLEMENTED() EAT_STREAM_PARAMETERS
+#elif NOTIMPLEMENTED_POLICY == 1
+// TODO, figure out how to generate a warning
+  #define NOTIMPLEMENTED() COMPILE_ASSERT(false, NOT_IMPLEMENTED)
+#elif NOTIMPLEMENTED_POLICY == 2
+  #define NOTIMPLEMENTED() COMPILE_ASSERT(false, NOT_IMPLEMENTED)
+#elif NOTIMPLEMENTED_POLICY == 3
+  #define NOTIMPLEMENTED() NOTREACHED()
+#elif NOTIMPLEMENTED_POLICY == 4
+  #define NOTIMPLEMENTED() LOG(ERROR) << NOTIMPLEMENTED_MSG
+#elif NOTIMPLEMENTED_POLICY == 5
+#define NOTIMPLEMENTED() do {\
+  static bool logged_once = false;\
+  LOG_IF(ERROR, !logged_once) << NOTIMPLEMENTED_MSG;\
+  logged_once = true;\
+} while(0);\
+EAT_STREAM_PARAMETERS
+#endif
+
+#endif  // !BUILDING_CEF_SHARED
+
+#endif  // CEF_INCLUDE_BASE_CEF_LOGGING_H_
diff --git a/src/include/libcef_/base/cef_macros.h b/src/include/libcef_/base/cef_macros.h
new file mode 100644
index 0000000..0ba7dea
--- /dev/null
+++ b/src/include/libcef_/base/cef_macros.h
@@ -0,0 +1,219 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2012
+// Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef CEF_INCLUDE_BASE_CEF_MACROS_H_
+#define CEF_INCLUDE_BASE_CEF_MACROS_H_
+#pragma once
+
+#if defined(BUILDING_CEF_SHARED)
+// When building CEF include the Chromium header directly.
+#include "base/macros.h"
+#else  // !BUILDING_CEF_SHARED
+// The following is substantially similar to the Chromium implementation.
+// If the Chromium implementation diverges the below implementation should be
+// updated to match.
+
+#include <stddef.h>  // For size_t.
+#include"libcef/base/cef_build.h"  // For COMPILER_MSVC
+
+#if !defined(ALLOW_THIS_IN_INITIALIZER_LIST)
+#if defined(COMPILER_MSVC)
+
+// MSVC_PUSH_DISABLE_WARNING pushes |n| onto a stack of warnings to be disabled.
+// The warning remains disabled until popped by MSVC_POP_WARNING.
+#define MSVC_PUSH_DISABLE_WARNING(n) __pragma(warning(push)) \
+                                     __pragma(warning(disable:n))
+
+// MSVC_PUSH_WARNING_LEVEL pushes |n| as the global warning level.  The level
+// remains in effect until popped by MSVC_POP_WARNING().  Use 0 to disable all
+// warnings.
+#define MSVC_PUSH_WARNING_LEVEL(n) __pragma(warning(push, n))
+
+// Pop effects of innermost MSVC_PUSH_* macro.
+#define MSVC_POP_WARNING() __pragma(warning(pop))
+
+// Allows |this| to be passed as an argument in constructor initializer lists.
+// This uses push/pop instead of the seemingly simpler suppress feature to avoid
+// having the warning be disabled for more than just |code|.
+//
+// Example usage:
+// Foo::Foo() : x(NULL), ALLOW_THIS_IN_INITIALIZER_LIST(y(this)), z(3) {}
+//
+// Compiler warning C4355: 'this': used in base member initializer list:
+// http://msdn.microsoft.com/en-us/library/3c594ae3(VS.80).aspx
+#define ALLOW_THIS_IN_INITIALIZER_LIST(code) MSVC_PUSH_DISABLE_WARNING(4355) \
+                                             code \
+                                             MSVC_POP_WARNING()
+#else  // !COMPILER_MSVC
+
+#define ALLOW_THIS_IN_INITIALIZER_LIST(code) code
+
+#endif  // !COMPILER_MSVC
+#endif  // !ALLOW_THIS_IN_INITIALIZER_LIST
+
+#if !defined(arraysize)
+
+// The arraysize(arr) macro returns the # of elements in an array arr.
+// The expression is a compile-time constant, and therefore can be
+// used in defining new arrays, for example.  If you use arraysize on
+// a pointer by mistake, you will get a compile-time error.
+//
+// One caveat is that arraysize() doesn't accept any array of an
+// anonymous type or a type defined inside a function.  In these rare
+// cases, you have to use the unsafe ARRAYSIZE_UNSAFE() macro below.  This is
+// due to a limitation in C++'s template system.  The limitation might
+// eventually be removed, but it hasn't happened yet.
+
+// This template function declaration is used in defining arraysize.
+// Note that the function doesn't need an implementation, as we only
+// use its type.
+template <typename T, size_t N>
+char (&ArraySizeHelper(T (&array)[N]))[N];
+
+// That gcc wants both of these prototypes seems mysterious. VC, for
+// its part, can't decide which to use (another mystery). Matching of
+// template overloads: the final frontier.
+#ifndef _MSC_VER
+template <typename T, size_t N>
+char (&ArraySizeHelper(const T (&array)[N]))[N];
+#endif
+
+#define arraysize(array) (sizeof(ArraySizeHelper(array)))
+
+#endif  // !arraysize
+
+#if !defined(DISALLOW_COPY_AND_ASSIGN)
+
+// A macro to disallow the copy constructor and operator= functions
+// This should be used in the private: declarations for a class
+#define DISALLOW_COPY_AND_ASSIGN(TypeName) \
+  TypeName(const TypeName&);               \
+  void operator=(const TypeName&)
+
+#endif  // !DISALLOW_COPY_AND_ASSIGN
+
+#if !defined(DISALLOW_IMPLICIT_CONSTRUCTORS)
+
+// A macro to disallow all the implicit constructors, namely the
+// default constructor, copy constructor and operator= functions.
+//
+// This should be used in the private: declarations for a class
+// that wants to prevent anyone from instantiating it. This is
+// especially useful for classes containing only static methods.
+#define DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \
+  TypeName();                                    \
+  DISALLOW_COPY_AND_ASSIGN(TypeName)
+
+#endif  // !DISALLOW_IMPLICIT_CONSTRUCTORS
+
+#if !defined(COMPILE_ASSERT)
+
+// The COMPILE_ASSERT macro can be used to verify that a compile time
+// expression is true. For example, you could use it to verify the
+// size of a static array:
+//
+//   COMPILE_ASSERT(ARRAYSIZE_UNSAFE(content_type_names) == CONTENT_NUM_TYPES,
+//                  content_type_names_incorrect_size);
+//
+// or to make sure a struct is smaller than a certain size:
+//
+//   COMPILE_ASSERT(sizeof(foo) < 128, foo_too_large);
+//
+// The second argument to the macro is the name of the variable. If
+// the expression is false, most compilers will issue a warning/error
+// containing the name of the variable.
+
+#if __cplusplus >= 201103L
+
+// Under C++11, just use static_assert.
+#define COMPILE_ASSERT(expr, msg) static_assert(expr, #msg)
+
+#else
+
+namespace cef {
+
+template <bool>
+struct CompileAssert {
+};
+
+}  // namespace cef
+
+#define COMPILE_ASSERT(expr, msg) \
+  typedef cef::CompileAssert<(bool(expr))> msg[bool(expr) ? 1 : -1] \
+      ALLOW_UNUSED_TYPE
+
+// Implementation details of COMPILE_ASSERT:
+//
+// - COMPILE_ASSERT works by defining an array type that has -1
+//   elements (and thus is invalid) when the expression is false.
+//
+// - The simpler definition
+//
+//     #define COMPILE_ASSERT(expr, msg) typedef char msg[(expr) ? 1 : -1]
+//
+//   does not work, as gcc supports variable-length arrays whose sizes
+//   are determined at run-time (this is gcc's extension and not part
+//   of the C++ standard).  As a result, gcc fails to reject the
+//   following code with the simple definition:
+//
+//     int foo;
+//     COMPILE_ASSERT(foo, msg); // not supposed to compile as foo is
+//                               // not a compile-time constant.
+//
+// - By using the type CompileAssert<(bool(expr))>, we ensures that
+//   expr is a compile-time constant.  (Template arguments must be
+//   determined at compile-time.)
+//
+// - The outer parentheses in CompileAssert<(bool(expr))> are necessary
+//   to work around a bug in gcc 3.4.4 and 4.0.1.  If we had written
+//
+//     CompileAssert<bool(expr)>
+//
+//   instead, these compilers will refuse to compile
+//
+//     COMPILE_ASSERT(5 > 0, some_message);
+//
+//   (They seem to think the ">" in "5 > 0" marks the end of the
+//   template argument list.)
+//
+// - The array size is (bool(expr) ? 1 : -1), instead of simply
+//
+//     ((expr) ? 1 : -1).
+//
+//   This is to avoid running into a bug in MS VC 7.1, which
+//   causes ((0.0) ? 1 : -1) to incorrectly evaluate to 1.
+
+#endif  // !(__cplusplus >= 201103L)
+
+#endif  // !defined(COMPILE_ASSERT)
+
+#endif  // !BUILDING_CEF_SHARED
+
+#endif  // CEF_INCLUDE_BASE_CEF_MACROS_H_
diff --git a/src/include/libcef_/base/cef_move.h b/src/include/libcef_/base/cef_move.h
new file mode 100644
index 0000000..9106929
--- /dev/null
+++ b/src/include/libcef_/base/cef_move.h
@@ -0,0 +1,259 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2012
+// Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef CEF_INCLUDE_BASE_CEF_MOVE_H_
+#define CEF_INCLUDE_BASE_CEF_MOVE_H_
+
+#if defined(MOVE_ONLY_TYPE_FOR_CPP_03)
+// Do nothing if the macro in this header has already been defined.
+// This can happen in cases where Chromium code is used directly by the
+// client application. When using Chromium code directly always include
+// the Chromium header first to avoid type conflicts.
+#elif defined(BUILDING_CEF_SHARED)
+// When building CEF include the Chromium header directly.
+#include "base/move.h"
+#else  // !BUILDING_CEF_SHARED
+// The following is substantially similar to the Chromium implementation.
+// If the Chromium implementation diverges the below implementation should be
+// updated to match.
+
+// Macro with the boilerplate that makes a type move-only in C++03.
+//
+// USAGE
+//
+// This macro should be used instead of DISALLOW_COPY_AND_ASSIGN to create
+// a "move-only" type.  Unlike DISALLOW_COPY_AND_ASSIGN, this macro should be
+// the first line in a class declaration.
+//
+// A class using this macro must call .Pass() (or somehow be an r-value already)
+// before it can be:
+//
+//   * Passed as a function argument
+//   * Used as the right-hand side of an assignment
+//   * Returned from a function
+//
+// Each class will still need to define their own "move constructor" and "move
+// operator=" to make this useful.  Here's an example of the macro, the move
+// constructor, and the move operator= from the scoped_ptr class:
+//
+//  template <typename T>
+//  class scoped_ptr {
+//     MOVE_ONLY_TYPE_FOR_CPP_03(scoped_ptr, RValue)
+//   public:
+//    scoped_ptr(RValue& other) : ptr_(other.release()) { }
+//    scoped_ptr& operator=(RValue& other) {
+//      swap(other);
+//      return *this;
+//    }
+//  };
+//
+// Note that the constructor must NOT be marked explicit.
+//
+// For consistency, the second parameter to the macro should always be RValue
+// unless you have a strong reason to do otherwise.  It is only exposed as a
+// macro parameter so that the move constructor and move operator= don't look
+// like they're using a phantom type.
+//
+//
+// HOW THIS WORKS
+//
+// For a thorough explanation of this technique, see:
+//
+//   http://en.wikibooks.org/wiki/More_C%2B%2B_Idioms/Move_Constructor
+//
+// The summary is that we take advantage of 2 properties:
+//
+//   1) non-const references will not bind to r-values.
+//   2) C++ can apply one user-defined conversion when initializing a
+//      variable.
+//
+// The first lets us disable the copy constructor and assignment operator
+// by declaring private version of them with a non-const reference parameter.
+//
+// For l-values, direct initialization still fails like in
+// DISALLOW_COPY_AND_ASSIGN because the copy constructor and assignment
+// operators are private.
+//
+// For r-values, the situation is different. The copy constructor and
+// assignment operator are not viable due to (1), so we are trying to call
+// a non-existent constructor and non-existing operator= rather than a private
+// one.  Since we have not committed an error quite yet, we can provide an
+// alternate conversion sequence and a constructor.  We add
+//
+//   * a private struct named "RValue"
+//   * a user-defined conversion "operator RValue()"
+//   * a "move constructor" and "move operator=" that take the RValue& as
+//     their sole parameter.
+//
+// Only r-values will trigger this sequence and execute our "move constructor"
+// or "move operator=."  L-values will match the private copy constructor and
+// operator= first giving a "private in this context" error.  This combination
+// gives us a move-only type.
+//
+// For signaling a destructive transfer of data from an l-value, we provide a
+// method named Pass() which creates an r-value for the current instance
+// triggering the move constructor or move operator=.
+//
+// Other ways to get r-values is to use the result of an expression like a
+// function call.
+//
+// Here's an example with comments explaining what gets triggered where:
+//
+//    class Foo {
+//      MOVE_ONLY_TYPE_FOR_CPP_03(Foo, RValue);
+//
+//     public:
+//       ... API ...
+//       Foo(RValue other);           // Move constructor.
+//       Foo& operator=(RValue rhs);  // Move operator=
+//    };
+//
+//    Foo MakeFoo();  // Function that returns a Foo.
+//
+//    Foo f;
+//    Foo f_copy(f);  // ERROR: Foo(Foo&) is private in this context.
+//    Foo f_assign;
+//    f_assign = f;   // ERROR: operator=(Foo&) is private in this context.
+//
+//
+//    Foo f(MakeFoo());      // R-value so alternate conversion executed.
+//    Foo f_copy(f.Pass());  // R-value so alternate conversion executed.
+//    f = f_copy.Pass();     // R-value so alternate conversion executed.
+//
+//
+// IMPLEMENTATION SUBTLETIES WITH RValue
+//
+// The RValue struct is just a container for a pointer back to the original
+// object. It should only ever be created as a temporary, and no external
+// class should ever declare it or use it in a parameter.
+//
+// It is tempting to want to use the RValue type in function parameters, but
+// excluding the limited usage here for the move constructor and move
+// operator=, doing so would mean that the function could take both r-values
+// and l-values equially which is unexpected.  See COMPARED To Boost.Move for
+// more details.
+//
+// An alternate, and incorrect, implementation of the RValue class used by
+// Boost.Move makes RValue a fieldless child of the move-only type. RValue&
+// is then used in place of RValue in the various operators.  The RValue& is
+// "created" by doing *reinterpret_cast<RValue*>(this).  This has the appeal
+// of never creating a temporary RValue struct even with optimizations
+// disabled.  Also, by virtue of inheritance you can treat the RValue
+// reference as if it were the move-only type itself.  Unfortunately,
+// using the result of this reinterpret_cast<> is actually undefined behavior
+// due to C++98 5.2.10.7. In certain compilers (e.g., NaCl) the optimizer
+// will generate non-working code.
+//
+// In optimized builds, both implementations generate the same assembly so we
+// choose the one that adheres to the standard.
+//
+//
+// WHY HAVE typedef void MoveOnlyTypeForCPP03
+//
+// Callback<>/Bind() needs to understand movable-but-not-copyable semantics
+// to call .Pass() appropriately when it is expected to transfer the value.
+// The cryptic typedef MoveOnlyTypeForCPP03 is added to make this check
+// easy and automatic in helper templates for Callback<>/Bind().
+// See IsMoveOnlyType template and its usage in base/callback_internal.h
+// for more details.
+//
+//
+// COMPARED TO C++11
+//
+// In C++11, you would implement this functionality using an r-value reference
+// and our .Pass() method would be replaced with a call to std::move().
+//
+// This emulation also has a deficiency where it uses up the single
+// user-defined conversion allowed by C++ during initialization.  This can
+// cause problems in some API edge cases.  For instance, in scoped_ptr, it is
+// impossible to make a function "void Foo(scoped_ptr<Parent> p)" accept a
+// value of type scoped_ptr<Child> even if you add a constructor to
+// scoped_ptr<> that would make it look like it should work.  C++11 does not
+// have this deficiency.
+//
+//
+// COMPARED TO Boost.Move
+//
+// Our implementation similar to Boost.Move, but we keep the RValue struct
+// private to the move-only type, and we don't use the reinterpret_cast<> hack.
+//
+// In Boost.Move, RValue is the boost::rv<> template.  This type can be used
+// when writing APIs like:
+//
+//   void MyFunc(boost::rv<Foo>& f)
+//
+// that can take advantage of rv<> to avoid extra copies of a type.  However you
+// would still be able to call this version of MyFunc with an l-value:
+//
+//   Foo f;
+//   MyFunc(f);  // Uh oh, we probably just destroyed |f| w/o calling Pass().
+//
+// unless someone is very careful to also declare a parallel override like:
+//
+//   void MyFunc(const Foo& f)
+//
+// that would catch the l-values first.  This was declared unsafe in C++11 and
+// a C++11 compiler will explicitly fail MyFunc(f).  Unfortunately, we cannot
+// ensure this in C++03.
+//
+// Since we have no need for writing such APIs yet, our implementation keeps
+// RValue private and uses a .Pass() method to do the conversion instead of
+// trying to write a version of "std::move()." Writing an API like std::move()
+// would require the RValue struct to be public.
+//
+//
+// CAVEATS
+//
+// If you include a move-only type as a field inside a class that does not
+// explicitly declare a copy constructor, the containing class's implicit
+// copy constructor will change from Containing(const Containing&) to
+// Containing(Containing&).  This can cause some unexpected errors.
+//
+//   http://llvm.org/bugs/show_bug.cgi?id=11528
+//
+// The workaround is to explicitly declare your copy constructor.
+//
+#define MOVE_ONLY_TYPE_FOR_CPP_03(type, rvalue_type) \
+ private: \
+  struct rvalue_type { \
+    explicit rvalue_type(type* object) : object(object) {} \
+    type* object; \
+  }; \
+  type(type&); \
+  void operator=(type&); \
+ public: \
+  operator rvalue_type() { return rvalue_type(this); } \
+  type Pass() { return type(rvalue_type(this)); } \
+  typedef void MoveOnlyTypeForCPP03; \
+ private:
+ 
+#endif  // !BUILDING_CEF_SHARED
+
+#endif  // CEF_INCLUDE_BASE_CEF_MOVE_H_
diff --git a/src/include/libcef_/base/cef_platform_thread.h b/src/include/libcef_/base/cef_platform_thread.h
new file mode 100644
index 0000000..b601a5e
--- /dev/null
+++ b/src/include/libcef_/base/cef_platform_thread.h
@@ -0,0 +1,113 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2011
+// Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// WARNING: You should *NOT* be using this class directly.  PlatformThread is
+// the low-level platform-specific abstraction to the OS's threading interface.
+// You should instead be using a message-loop driven Thread, see thread.h.
+
+#ifndef CEF_INCLUDE_BASE_PLATFORM_THREAD_H_
+#define CEF_INCLUDE_BASE_PLATFORM_THREAD_H_
+
+#if defined(BASE_THREADING_PLATFORM_THREAD_H_)
+// Do nothing if the Chromium header has already been included.
+// This can happen in cases where Chromium code is used directly by the
+// client application. When using Chromium code directly always include
+// the Chromium header first to avoid type conflicts.
+#elif defined(BUILDING_CEF_SHARED)
+// When building CEF include the Chromium header directly.
+#include "base/threading/platform_thread.h"
+#else  // !BUILDING_CEF_SHARED
+// The following is substantially similar to the Chromium implementation.
+// If the Chromium implementation diverges the below implementation should be
+// updated to match.
+
+#include"libcef/base/cef_basictypes.h"
+#include"libcef/base/cef_build.h"
+#include"libcef/internal/cef_thread_internal.h"
+
+namespace base {
+
+// Used for logging. Always an integer value.
+typedef cef_platform_thread_id_t PlatformThreadId;
+
+// Used for thread checking and debugging.
+// Meant to be as fast as possible.
+// These are produced by PlatformThread::CurrentRef(), and used to later
+// check if we are on the same thread or not by using ==. These are safe
+// to copy between threads, but can't be copied to another process as they
+// have no meaning there. Also, the internal identifier can be re-used
+// after a thread dies, so a PlatformThreadRef cannot be reliably used
+// to distinguish a new thread from an old, dead thread.
+class PlatformThreadRef {
+ public:
+  typedef cef_platform_thread_handle_t RefType;
+
+  PlatformThreadRef()
+      : id_(0) {
+  }
+
+  explicit PlatformThreadRef(RefType id)
+      : id_(id) {
+  }
+
+  bool operator==(PlatformThreadRef other) const {
+    return id_ == other.id_;
+  }
+
+  bool is_null() const {
+    return id_ == 0;
+  }
+ private:
+  RefType id_;
+};
+
+// A namespace for low-level thread functions.
+// Chromium uses a class with static methods but CEF uses an actual namespace
+// to avoid linker problems with the sandbox libaries on Windows.
+namespace PlatformThread {
+
+// Gets the current thread id, which may be useful for logging purposes.
+inline PlatformThreadId CurrentId() {
+  return cef_get_current_platform_thread_id();
+}
+
+// Gets the current thread reference, which can be used to check if
+// we're on the right thread quickly.
+inline PlatformThreadRef CurrentRef() {
+  return PlatformThreadRef(cef_get_current_platform_thread_handle());
+}
+
+}  // namespace PlatformThread
+
+}  // namespace base
+
+#endif  // !BUILDING_CEF_SHARED
+
+#endif  // CEF_INCLUDE_BASE_PLATFORM_THREAD_H_
diff --git a/src/include/libcef_/base/cef_ref_counted.h b/src/include/libcef_/base/cef_ref_counted.h
new file mode 100644
index 0000000..6111f73
--- /dev/null
+++ b/src/include/libcef_/base/cef_ref_counted.h
@@ -0,0 +1,390 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2012
+// Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+
+#ifndef CEF_INCLUDE_BASE_CEF_REF_COUNTED_H_
+#define CEF_INCLUDE_BASE_CEF_REF_COUNTED_H_
+#pragma once
+
+#if defined(BASE_MEMORY_REF_COUNTED_H_)
+// Do nothing if the Chromium header has already been included.
+// This can happen in cases where Chromium code is used directly by the
+// client application. When using Chromium code directly always include
+// the Chromium header first to avoid type conflicts.
+#elif defined(BUILDING_CEF_SHARED)
+// When building CEF include the Chromium header directly.
+#include"base/memory/ref_counted.h"
+#else  // !BUILDING_CEF_SHARED
+// The following is substantially similar to the Chromium implementation.
+// If the Chromium implementation diverges the below implementation should be
+// updated to match.
+
+
+#include<cassert>
+
+#include"libcef/base/cef_atomic_ref_count.h"
+#include"libcef/base/cef_build.h"
+
+#ifndef NDEBUG
+  #include"libcef/base/cef_logging.h"
+#endif
+
+#include"libcef/base/cef_thread_collision_warner.h"
+
+namespace base {
+
+namespace cef_subtle {
+
+class RefCountedBase 
+{
+ public:
+  bool HasOneRef() const { return ref_count_ == 1; }
+
+ protected:
+  RefCountedBase() : ref_count_(0)
+  #ifndef NDEBUG
+      , in_dtor_(false)
+  #endif
+      {
+  }
+
+  ~RefCountedBase() 
+  {
+    #ifndef NDEBUG
+      DCHECK(in_dtor_) << "RefCounted object deleted without calling Release()";
+    #endif
+  }
+
+
+  void AddRef() const {
+    // TODO(maruel): Add back once it doesn't assert 500 times/sec.
+    // Current thread books the critical section "AddRelease"
+    // without release it.
+    // DFAKE_SCOPED_LOCK_THREAD_LOCKED(add_release_);
+  #ifndef NDEBUG
+    DCHECK(!in_dtor_);
+  #endif
+    ++ref_count_;
+  }
+
+  // Returns true if the object should self-delete.
+  bool Release() const {
+    // TODO(maruel): Add back once it doesn't assert 500 times/sec.
+    // Current thread books the critical section "AddRelease"
+    // without release it.
+    // DFAKE_SCOPED_LOCK_THREAD_LOCKED(add_release_);
+  #ifndef NDEBUG
+    DCHECK(!in_dtor_);
+  #endif
+    if (--ref_count_ == 0) {
+  #ifndef NDEBUG
+      in_dtor_ = true;
+  #endif
+      return true;
+    }
+    return false;
+  }
+
+ private:
+  mutable int ref_count_;
+#ifndef NDEBUG
+  mutable bool in_dtor_;
+#endif
+
+  DFAKE_MUTEX(add_release_);
+
+  DISALLOW_COPY_AND_ASSIGN(RefCountedBase);
+};
+
+class RefCountedThreadSafeBase {
+ public:
+  bool HasOneRef() const;
+
+ protected:
+  RefCountedThreadSafeBase();
+  ~RefCountedThreadSafeBase();
+
+  void AddRef() const;
+
+  // Returns true if the object should self-delete.
+  bool Release() const;
+
+ private:
+  mutable AtomicRefCount ref_count_;
+#ifndef NDEBUG
+  mutable bool in_dtor_;
+#endif
+
+  DISALLOW_COPY_AND_ASSIGN(RefCountedThreadSafeBase);
+};
+
+}  // namespace cef_subtle
+
+//
+// A base class for reference counted classes.  Otherwise, known as a cheap
+// knock-off of WebKit's RefCounted<T> class.  To use this guy just extend your
+// class from it like so:
+//
+//   class MyFoo : public base::RefCounted<MyFoo> {
+//    ...
+//    private:
+//     friend class base::RefCounted<MyFoo>;
+//     ~MyFoo();
+//   };
+//
+// You should always make your destructor private, to avoid any code deleting
+// the object accidently while there are references to it.
+template <class T>
+class RefCounted : public cef_subtle::RefCountedBase {
+ public:
+  RefCounted() {}
+
+  void AddRef() const {
+    cef_subtle::RefCountedBase::AddRef();
+  }
+
+  void Release() const {
+    if (cef_subtle::RefCountedBase::Release()) {
+      delete static_cast<const T*>(this);
+    }
+  }
+
+ protected:
+  ~RefCounted() {}
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(RefCounted<T>);
+};
+
+// Forward declaration.
+template <class T, typename Traits> class RefCountedThreadSafe;
+
+// Default traits for RefCountedThreadSafe<T>.  Deletes the object when its ref
+// count reaches 0.  Overload to delete it on a different thread etc.
+template<typename T>
+struct DefaultRefCountedThreadSafeTraits {
+  static void Destruct(const T* x) {
+    // Delete through RefCountedThreadSafe to make child classes only need to be
+    // friend with RefCountedThreadSafe instead of this struct, which is an
+    // implementation detail.
+    RefCountedThreadSafe<T,
+                         DefaultRefCountedThreadSafeTraits>::DeleteInternal(x);
+  }
+};
+
+//
+// A thread-safe variant of RefCounted<T>
+//
+//   class MyFoo : public base::RefCountedThreadSafe<MyFoo> {
+//    ...
+//   };
+//
+// If you're using the default trait, then you should add compile time
+// asserts that no one else is deleting your object.  i.e.
+//    private:
+//     friend class base::RefCountedThreadSafe<MyFoo>;
+//     ~MyFoo();
+template <class T, typename Traits = DefaultRefCountedThreadSafeTraits<T> >
+class RefCountedThreadSafe : public cef_subtle::RefCountedThreadSafeBase {
+ public:
+  RefCountedThreadSafe() {}
+
+  void AddRef() const {
+    cef_subtle::RefCountedThreadSafeBase::AddRef();
+  }
+
+  void Release() const {
+    if (cef_subtle::RefCountedThreadSafeBase::Release()) {
+      Traits::Destruct(static_cast<const T*>(this));
+    }
+  }
+
+ protected:
+  ~RefCountedThreadSafe() {}
+
+ private:
+  friend struct DefaultRefCountedThreadSafeTraits<T>;
+  static void DeleteInternal(const T* x) { delete x; }
+
+  DISALLOW_COPY_AND_ASSIGN(RefCountedThreadSafe);
+};
+
+//
+// A thread-safe wrapper for some piece of data so we can place other
+// things in scoped_refptrs<>.
+//
+template<typename T>
+class RefCountedData
+    : public base::RefCountedThreadSafe< base::RefCountedData<T> > {
+ public:
+  RefCountedData() : data() {}
+  RefCountedData(const T& in_value) : data(in_value) {}
+
+  T data;
+
+ private:
+  friend class base::RefCountedThreadSafe<base::RefCountedData<T> >;
+  ~RefCountedData() {}
+};
+
+}  // namespace base
+
+//
+// A smart pointer class for reference counted objects.  Use this class instead
+// of calling AddRef and Release manually on a reference counted object to
+// avoid common memory leaks caused by forgetting to Release an object
+// reference.  Sample usage:
+//
+//   class MyFoo : public RefCounted<MyFoo> {
+//    ...
+//   };
+//
+//   void some_function() {
+//     scoped_refptr<MyFoo> foo = new MyFoo();
+//     foo->Method(param);
+//     // |foo| is released when this function returns
+//   }
+//
+//   void some_other_function() {
+//     scoped_refptr<MyFoo> foo = new MyFoo();
+//     ...
+//     foo = NULL;  // explicitly releases |foo|
+//     ...
+//     if (foo)
+//       foo->Method(param);
+//   }
+//
+// The above examples show how scoped_refptr<T> acts like a pointer to T.
+// Given two scoped_refptr<T> classes, it is also possible to exchange
+// references between the two objects, like so:
+//
+//   {
+//     scoped_refptr<MyFoo> a = new MyFoo();
+//     scoped_refptr<MyFoo> b;
+//
+//     b.swap(a);
+//     // now, |b| references the MyFoo object, and |a| references NULL.
+//   }
+//
+// To make both |a| and |b| in the above example reference the same MyFoo
+// object, simply use the assignment operator:
+//
+//   {
+//     scoped_refptr<MyFoo> a = new MyFoo();
+//     scoped_refptr<MyFoo> b;
+//
+//     b = a;
+//     // now, |a| and |b| each own a reference to the same MyFoo object.
+//   }
+//
+template <class T>
+class scoped_refptr {
+ public:
+  typedef T element_type;
+
+  scoped_refptr() : ptr_(NULL) {
+  }
+
+  scoped_refptr(T* p) : ptr_(p) {
+    if (ptr_)
+      ptr_->AddRef();
+  }
+
+  scoped_refptr(const scoped_refptr<T>& r) : ptr_(r.ptr_) {
+    if (ptr_)
+      ptr_->AddRef();
+  }
+
+  template <typename U>
+  scoped_refptr(const scoped_refptr<U>& r) : ptr_(r.get()) {
+    if (ptr_)
+      ptr_->AddRef();
+  }
+
+  ~scoped_refptr() {
+    if (ptr_)
+      ptr_->Release();
+  }
+
+  T* get() const { return ptr_; }
+
+  // Allow scoped_refptr<C> to be used in boolean expression
+  // and comparison operations.
+  operator T*() const { return ptr_; }
+
+  T* operator->() const {
+    assert(ptr_ != NULL);
+    return ptr_;
+  }
+
+  scoped_refptr<T>& operator=(T* p) {
+    // AddRef first so that self assignment should work
+    if (p)
+      p->AddRef();
+    T* old_ptr = ptr_;
+    ptr_ = p;
+    if (old_ptr)
+      old_ptr->Release();
+    return *this;
+  }
+
+  scoped_refptr<T>& operator=(const scoped_refptr<T>& r) {
+    return *this = r.ptr_;
+  }
+
+  template <typename U>
+  scoped_refptr<T>& operator=(const scoped_refptr<U>& r) {
+    return *this = r.get();
+  }
+
+  void swap(T** pp) {
+    T* p = ptr_;
+    ptr_ = *pp;
+    *pp = p;
+  }
+
+  void swap(scoped_refptr<T>& r) {
+    swap(&r.ptr_);
+  }
+
+ protected:
+  T* ptr_;
+};
+
+// Handy utility for creating a scoped_refptr<T> out of a T* explicitly without
+// having to retype all the template arguments
+template <typename T>
+scoped_refptr<T> make_scoped_refptr(T* t) {
+  return scoped_refptr<T>(t);
+}
+
+#endif  // !BUILDING_CEF_SHARED
+
+#endif  // CEF_INCLUDE_BASE_CEF_REF_COUNTED_H_
diff --git a/src/include/libcef_/base/cef_scoped_ptr.h b/src/include/libcef_/base/cef_scoped_ptr.h
new file mode 100644
index 0000000..498fb52
--- /dev/null
+++ b/src/include/libcef_/base/cef_scoped_ptr.h
@@ -0,0 +1,624 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2012
+// Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Scopers help you manage ownership of a pointer, helping you easily manage a
+// pointer within a scope, and automatically destroying the pointer at the end
+// of a scope.  There are two main classes you will use, which correspond to the
+// operators new/delete and new[]/delete[].
+//
+// Example usage (scoped_ptr<T>):
+//   {
+//     scoped_ptr<Foo> foo(new Foo("wee"));
+//   }  // foo goes out of scope, releasing the pointer with it.
+//
+//   {
+//     scoped_ptr<Foo> foo;          // No pointer managed.
+//     foo.reset(new Foo("wee"));    // Now a pointer is managed.
+//     foo.reset(new Foo("wee2"));   // Foo("wee") was destroyed.
+//     foo.reset(new Foo("wee3"));   // Foo("wee2") was destroyed.
+//     foo->Method();                // Foo::Method() called.
+//     foo.get()->Method();          // Foo::Method() called.
+//     SomeFunc(foo.release());      // SomeFunc takes ownership, foo no longer
+//                                   // manages a pointer.
+//     foo.reset(new Foo("wee4"));   // foo manages a pointer again.
+//     foo.reset();                  // Foo("wee4") destroyed, foo no longer
+//                                   // manages a pointer.
+//   }  // foo wasn't managing a pointer, so nothing was destroyed.
+//
+// Example usage (scoped_ptr<T[]>):
+//   {
+//     scoped_ptr<Foo[]> foo(new Foo[100]);
+//     foo.get()->Method();  // Foo::Method on the 0th element.
+//     foo[10].Method();     // Foo::Method on the 10th element.
+//   }
+//
+// These scopers also implement part of the functionality of C++11 unique_ptr
+// in that they are "movable but not copyable."  You can use the scopers in
+// the parameter and return types of functions to signify ownership transfer
+// in to and out of a function.  When calling a function that has a scoper
+// as the argument type, it must be called with the result of an analogous
+// scoper's Pass() function or another function that generates a temporary;
+// passing by copy will NOT work.  Here is an example using scoped_ptr:
+//
+//   void TakesOwnership(scoped_ptr<Foo> arg) {
+//     // Do something with arg
+//   }
+//   scoped_ptr<Foo> CreateFoo() {
+//     // No need for calling Pass() because we are constructing a temporary
+//     // for the return value.
+//     return scoped_ptr<Foo>(new Foo("new"));
+//   }
+//   scoped_ptr<Foo> PassThru(scoped_ptr<Foo> arg) {
+//     return arg.Pass();
+//   }
+//
+//   {
+//     scoped_ptr<Foo> ptr(new Foo("yay"));  // ptr manages Foo("yay").
+//     TakesOwnership(ptr.Pass());           // ptr no longer owns Foo("yay").
+//     scoped_ptr<Foo> ptr2 = CreateFoo();   // ptr2 owns the return Foo.
+//     scoped_ptr<Foo> ptr3 =                // ptr3 now owns what was in ptr2.
+//         PassThru(ptr2.Pass());            // ptr2 is correspondingly NULL.
+//   }
+//
+// Notice that if you do not call Pass() when returning from PassThru(), or
+// when invoking TakesOwnership(), the code will not compile because scopers
+// are not copyable; they only implement move semantics which require calling
+// the Pass() function to signify a destructive transfer of state. CreateFoo()
+// is different though because we are constructing a temporary on the return
+// line and thus can avoid needing to call Pass().
+//
+// Pass() properly handles upcast in initialization, i.e. you can use a
+// scoped_ptr<Child> to initialize a scoped_ptr<Parent>:
+//
+//   scoped_ptr<Foo> foo(new Foo());
+//   scoped_ptr<FooParent> parent(foo.Pass());
+//
+// PassAs<>() should be used to upcast return value in return statement:
+//
+//   scoped_ptr<Foo> CreateFoo() {
+//     scoped_ptr<FooChild> result(new FooChild());
+//     return result.PassAs<Foo>();
+//   }
+//
+// Note that PassAs<>() is implemented only for scoped_ptr<T>, but not for
+// scoped_ptr<T[]>. This is because casting array pointers may not be safe.
+
+#ifndef CEF_INCLUDE_BASE_CEF_MEMORY_SCOPED_PTR_H_
+#define CEF_INCLUDE_BASE_CEF_MEMORY_SCOPED_PTR_H_
+#pragma once
+
+#if defined(BASE_MEMORY_SCOPED_PTR_H_)
+// Do nothing if the Chromium header has already been included.
+// This can happen in cases where Chromium code is used directly by the
+// client application. When using Chromium code directly always include
+// the Chromium header first to avoid type conflicts.
+#elif defined(BUILDING_CEF_SHARED)
+// When building CEF include the Chromium header directly.
+#include "base/memory/scoped_ptr.h"
+#else  // !BUILDING_CEF_SHARED
+// The following is substantially similar to the Chromium implementation.
+// If the Chromium implementation diverges the below implementation should be
+// updated to match.
+
+// This is an implementation designed to match the anticipated future TR2
+// implementation of the scoped_ptr class.
+
+#include<assert.h>
+#include<stddef.h>
+#include<stdlib.h>
+
+#include<algorithm>  // For std::swap().
+
+#include"libcef/base/cef_basictypes.h"
+#include"libcef/base/cef_build.h"
+#include"libcef/base/cef_macros.h"
+#include"libcef/base/cef_move.h"
+#include"libcef/base/cef_template_util.h"
+
+namespace base {
+
+namespace subtle {
+class RefCountedBase;
+class RefCountedThreadSafeBase;
+}  // namespace subtle
+
+// Function object which deletes its parameter, which must be a pointer.
+// If C is an array type, invokes 'delete[]' on the parameter; otherwise,
+// invokes 'delete'. The default deleter for scoped_ptr<T>.
+template <class T>
+struct DefaultDeleter {
+  DefaultDeleter() {}
+  template <typename U> DefaultDeleter(const DefaultDeleter<U>& other) {
+    // IMPLEMENTATION NOTE: C++11 20.7.1.1.2p2 only provides this constructor
+    // if U* is implicitly convertible to T* and U is not an array type.
+    //
+    // Correct implementation should use SFINAE to disable this
+    // constructor. However, since there are no other 1-argument constructors,
+    // using a COMPILE_ASSERT() based on is_convertible<> and requiring
+    // complete types is simpler and will cause compile failures for equivalent
+    // misuses.
+    //
+    // Note, the is_convertible<U*, T*> check also ensures that U is not an
+    // array. T is guaranteed to be a non-array, so any U* where U is an array
+    // cannot convert to T*.
+    enum { T_must_be_complete = sizeof(T) };
+    enum { U_must_be_complete = sizeof(U) };
+    COMPILE_ASSERT((base::is_convertible<U*, T*>::value),
+                   U_ptr_must_implicitly_convert_to_T_ptr);
+  }
+  inline void operator()(T* ptr) const {
+    enum { type_must_be_complete = sizeof(T) };
+    delete ptr;
+  }
+};
+
+// Specialization of DefaultDeleter for array types.
+template <class T>
+struct DefaultDeleter<T[]> {
+  inline void operator()(T* ptr) const {
+    enum { type_must_be_complete = sizeof(T) };
+    delete[] ptr;
+  }
+
+ private:
+  // Disable this operator for any U != T because it is undefined to execute
+  // an array delete when the static type of the array mismatches the dynamic
+  // type.
+  //
+  // References:
+  //   C++98 [expr.delete]p3
+  //   http://cplusplus.github.com/LWG/lwg-defects.html#938
+  template <typename U> void operator()(U* array) const;
+};
+
+template <class T, int n>
+struct DefaultDeleter<T[n]> {
+  // Never allow someone to declare something like scoped_ptr<int[10]>.
+  COMPILE_ASSERT(sizeof(T) == -1, do_not_use_array_with_size_as_type);
+};
+
+// Function object which invokes 'free' on its parameter, which must be
+// a pointer. Can be used to store malloc-allocated pointers in scoped_ptr:
+//
+// scoped_ptr<int, base::FreeDeleter> foo_ptr(
+//     static_cast<int*>(malloc(sizeof(int))));
+struct FreeDeleter {
+  inline void operator()(void* ptr) const {
+    free(ptr);
+  }
+};
+
+namespace cef_internal {
+
+template <typename T> struct IsNotRefCounted {
+  enum {
+    value = !base::is_convertible<T*, base::subtle::RefCountedBase*>::value &&
+        !base::is_convertible<T*, base::subtle::RefCountedThreadSafeBase*>::
+            value
+  };
+};
+
+// Minimal implementation of the core logic of scoped_ptr, suitable for
+// reuse in both scoped_ptr and its specializations.
+template <class T, class D>
+class scoped_ptr_impl {
+ public:
+  explicit scoped_ptr_impl(T* p) : data_(p) { }
+
+  // Initializer for deleters that have data parameters.
+  scoped_ptr_impl(T* p, const D& d) : data_(p, d) {}
+
+  // Templated constructor that destructively takes the value from another
+  // scoped_ptr_impl.
+  template <typename U, typename V>
+  scoped_ptr_impl(scoped_ptr_impl<U, V>* other)
+      : data_(other->release(), other->get_deleter()) {
+    // We do not support move-only deleters.  We could modify our move
+    // emulation to have base::subtle::move() and base::subtle::forward()
+    // functions that are imperfect emulations of their C++11 equivalents,
+    // but until there's a requirement, just assume deleters are copyable.
+  }
+
+  template <typename U, typename V>
+  void TakeState(scoped_ptr_impl<U, V>* other) {
+    // See comment in templated constructor above regarding lack of support
+    // for move-only deleters.
+    reset(other->release());
+    get_deleter() = other->get_deleter();
+  }
+
+  ~scoped_ptr_impl() {
+    if (data_.ptr != NULL) {
+      // Not using get_deleter() saves one function call in non-optimized
+      // builds.
+      static_cast<D&>(data_)(data_.ptr);
+    }
+  }
+
+  void reset(T* p) {
+    // This is a self-reset, which is no longer allowed: http://crbug.com/162971
+    if (p != NULL && p == data_.ptr)
+      abort();
+
+    // Note that running data_.ptr = p can lead to undefined behavior if
+    // get_deleter()(get()) deletes this. In order to prevent this, reset()
+    // should update the stored pointer before deleting its old value.
+    //
+    // However, changing reset() to use that behavior may cause current code to
+    // break in unexpected ways. If the destruction of the owned object
+    // dereferences the scoped_ptr when it is destroyed by a call to reset(),
+    // then it will incorrectly dispatch calls to |p| rather than the original
+    // value of |data_.ptr|.
+    //
+    // During the transition period, set the stored pointer to NULL while
+    // deleting the object. Eventually, this safety check will be removed to
+    // prevent the scenario initially described from occuring and
+    // http://crbug.com/176091 can be closed.
+    T* old = data_.ptr;
+    data_.ptr = NULL;
+    if (old != NULL)
+      static_cast<D&>(data_)(old);
+    data_.ptr = p;
+  }
+
+  T* get() const { return data_.ptr; }
+
+  D& get_deleter() { return data_; }
+  const D& get_deleter() const { return data_; }
+
+  void swap(scoped_ptr_impl& p2) {
+    // Standard swap idiom: 'using std::swap' ensures that std::swap is
+    // present in the overload set, but we call swap unqualified so that
+    // any more-specific overloads can be used, if available.
+    using std::swap;
+    swap(static_cast<D&>(data_), static_cast<D&>(p2.data_));
+    swap(data_.ptr, p2.data_.ptr);
+  }
+
+  T* release() {
+    T* old_ptr = data_.ptr;
+    data_.ptr = NULL;
+    return old_ptr;
+  }
+
+ private:
+  // Needed to allow type-converting constructor.
+  template <typename U, typename V> friend class scoped_ptr_impl;
+
+  // Use the empty base class optimization to allow us to have a D
+  // member, while avoiding any space overhead for it when D is an
+  // empty class.  See e.g. http://www.cantrip.org/emptyopt.html for a good
+  // discussion of this technique.
+  struct Data : public D {
+    explicit Data(T* ptr_in) : ptr(ptr_in) {}
+    Data(T* ptr_in, const D& other) : D(other), ptr(ptr_in) {}
+    T* ptr;
+  };
+
+  Data data_;
+
+  DISALLOW_COPY_AND_ASSIGN(scoped_ptr_impl);
+};
+
+}  // namespace cef_internal
+
+}  // namespace base
+
+// A scoped_ptr<T> is like a T*, except that the destructor of scoped_ptr<T>
+// automatically deletes the pointer it holds (if any).
+// That is, scoped_ptr<T> owns the T object that it points to.
+// Like a T*, a scoped_ptr<T> may hold either NULL or a pointer to a T object.
+// Also like T*, scoped_ptr<T> is thread-compatible, and once you
+// dereference it, you get the thread safety guarantees of T.
+//
+// The size of scoped_ptr is small. On most compilers, when using the
+// DefaultDeleter, sizeof(scoped_ptr<T>) == sizeof(T*). Custom deleters will
+// increase the size proportional to whatever state they need to have. See
+// comments inside scoped_ptr_impl<> for details.
+//
+// Current implementation targets having a strict subset of  C++11's
+// unique_ptr<> features. Known deficiencies include not supporting move-only
+// deleteres, function pointers as deleters, and deleters with reference
+// types.
+template <class T, class D = base::DefaultDeleter<T> >
+class scoped_ptr {
+  MOVE_ONLY_TYPE_FOR_CPP_03(scoped_ptr, RValue)
+
+  COMPILE_ASSERT(base::cef_internal::IsNotRefCounted<T>::value,
+                 T_is_refcounted_type_and_needs_scoped_refptr);
+
+ public:
+  // The element and deleter types.
+  typedef T element_type;
+  typedef D deleter_type;
+
+  // Constructor.  Defaults to initializing with NULL.
+  scoped_ptr() : impl_(NULL) { }
+
+  // Constructor.  Takes ownership of p.
+  explicit scoped_ptr(element_type* p) : impl_(p) { }
+
+  // Constructor.  Allows initialization of a stateful deleter.
+  scoped_ptr(element_type* p, const D& d) : impl_(p, d) { }
+
+  // Constructor.  Allows construction from a scoped_ptr rvalue for a
+  // convertible type and deleter.
+  //
+  // IMPLEMENTATION NOTE: C++11 unique_ptr<> keeps this constructor distinct
+  // from the normal move constructor. By C++11 20.7.1.2.1.21, this constructor
+  // has different post-conditions if D is a reference type. Since this
+  // implementation does not support deleters with reference type,
+  // we do not need a separate move constructor allowing us to avoid one
+  // use of SFINAE. You only need to care about this if you modify the
+  // implementation of scoped_ptr.
+  template <typename U, typename V>
+  scoped_ptr(scoped_ptr<U, V> other) : impl_(&other.impl_) {
+    COMPILE_ASSERT(!base::is_array<U>::value, U_cannot_be_an_array);
+  }
+
+  // Constructor.  Move constructor for C++03 move emulation of this type.
+  scoped_ptr(RValue rvalue) : impl_(&rvalue.object->impl_) { }
+
+  // operator=.  Allows assignment from a scoped_ptr rvalue for a convertible
+  // type and deleter.
+  //
+  // IMPLEMENTATION NOTE: C++11 unique_ptr<> keeps this operator= distinct from
+  // the normal move assignment operator. By C++11 20.7.1.2.3.4, this templated
+  // form has different requirements on for move-only Deleters. Since this
+  // implementation does not support move-only Deleters, we do not need a
+  // separate move assignment operator allowing us to avoid one use of SFINAE.
+  // You only need to care about this if you modify the implementation of
+  // scoped_ptr.
+  template <typename U, typename V>
+  scoped_ptr& operator=(scoped_ptr<U, V> rhs) {
+    COMPILE_ASSERT(!base::is_array<U>::value, U_cannot_be_an_array);
+    impl_.TakeState(&rhs.impl_);
+    return *this;
+  }
+
+  // Reset.  Deletes the currently owned object, if any.
+  // Then takes ownership of a new object, if given.
+  void reset(element_type* p = NULL) { impl_.reset(p); }
+
+  // Accessors to get the owned object.
+  // operator* and operator-> will assert() if there is no current object.
+  element_type& operator*() const {
+    assert(impl_.get() != NULL);
+    return *impl_.get();
+  }
+  element_type* operator->() const  {
+    assert(impl_.get() != NULL);
+    return impl_.get();
+  }
+  element_type* get() const { return impl_.get(); }
+
+  // Access to the deleter.
+  deleter_type& get_deleter() { return impl_.get_deleter(); }
+  const deleter_type& get_deleter() const { return impl_.get_deleter(); }
+
+  // Allow scoped_ptr<element_type> to be used in boolean expressions, but not
+  // implicitly convertible to a real bool (which is dangerous).
+  //
+  // Note that this trick is only safe when the == and != operators
+  // are declared explicitly, as otherwise "scoped_ptr1 ==
+  // scoped_ptr2" will compile but do the wrong thing (i.e., convert
+  // to Testable and then do the comparison).
+ private:
+  typedef base::cef_internal::scoped_ptr_impl<element_type, deleter_type>
+      scoped_ptr::*Testable;
+
+ public:
+  operator Testable() const { return impl_.get() ? &scoped_ptr::impl_ : NULL; }
+
+  // Comparison operators.
+  // These return whether two scoped_ptr refer to the same object, not just to
+  // two different but equal objects.
+  bool operator==(const element_type* p) const { return impl_.get() == p; }
+  bool operator!=(const element_type* p) const { return impl_.get() != p; }
+
+  // Swap two scoped pointers.
+  void swap(scoped_ptr& p2) {
+    impl_.swap(p2.impl_);
+  }
+
+  // Release a pointer.
+  // The return value is the current pointer held by this object.
+  // If this object holds a NULL pointer, the return value is NULL.
+  // After this operation, this object will hold a NULL pointer,
+  // and will not own the object any more.
+  element_type* release() WARN_UNUSED_RESULT {
+    return impl_.release();
+  }
+
+  // C++98 doesn't support functions templates with default parameters which
+  // makes it hard to write a PassAs() that understands converting the deleter
+  // while preserving simple calling semantics.
+  //
+  // Until there is a use case for PassAs() with custom deleters, just ignore
+  // the custom deleter.
+  template <typename PassAsType>
+  scoped_ptr<PassAsType> PassAs() {
+    return scoped_ptr<PassAsType>(Pass());
+  }
+
+ private:
+  // Needed to reach into |impl_| in the constructor.
+  template <typename U, typename V> friend class scoped_ptr;
+  base::cef_internal::scoped_ptr_impl<element_type, deleter_type> impl_;
+
+  // Forbidden for API compatibility with std::unique_ptr.
+  explicit scoped_ptr(int disallow_construction_from_null);
+
+  // Forbid comparison of scoped_ptr types.  If U != T, it totally
+  // doesn't make sense, and if U == T, it still doesn't make sense
+  // because you should never have the same object owned by two different
+  // scoped_ptrs.
+  template <class U> bool operator==(scoped_ptr<U> const& p2) const;
+  template <class U> bool operator!=(scoped_ptr<U> const& p2) const;
+};
+
+template <class T, class D>
+class scoped_ptr<T[], D> {
+  MOVE_ONLY_TYPE_FOR_CPP_03(scoped_ptr, RValue)
+
+ public:
+  // The element and deleter types.
+  typedef T element_type;
+  typedef D deleter_type;
+
+  // Constructor.  Defaults to initializing with NULL.
+  scoped_ptr() : impl_(NULL) { }
+
+  // Constructor. Stores the given array. Note that the argument's type
+  // must exactly match T*. In particular:
+  // - it cannot be a pointer to a type derived from T, because it is
+  //   inherently unsafe in the general case to access an array through a
+  //   pointer whose dynamic type does not match its static type (eg., if
+  //   T and the derived types had different sizes access would be
+  //   incorrectly calculated). Deletion is also always undefined
+  //   (C++98 [expr.delete]p3). If you're doing this, fix your code.
+  // - it cannot be NULL, because NULL is an integral expression, not a
+  //   pointer to T. Use the no-argument version instead of explicitly
+  //   passing NULL.
+  // - it cannot be const-qualified differently from T per unique_ptr spec
+  //   (http://cplusplus.github.com/LWG/lwg-active.html#2118). Users wanting
+  //   to work around this may use implicit_cast<const T*>().
+  //   However, because of the first bullet in this comment, users MUST
+  //   NOT use implicit_cast<Base*>() to upcast the static type of the array.
+  explicit scoped_ptr(element_type* array) : impl_(array) { }
+
+  // Constructor.  Move constructor for C++03 move emulation of this type.
+  scoped_ptr(RValue rvalue) : impl_(&rvalue.object->impl_) { }
+
+  // operator=.  Move operator= for C++03 move emulation of this type.
+  scoped_ptr& operator=(RValue rhs) {
+    impl_.TakeState(&rhs.object->impl_);
+    return *this;
+  }
+
+  // Reset.  Deletes the currently owned array, if any.
+  // Then takes ownership of a new object, if given.
+  void reset(element_type* array = NULL) { impl_.reset(array); }
+
+  // Accessors to get the owned array.
+  element_type& operator[](size_t i) const {
+    assert(impl_.get() != NULL);
+    return impl_.get()[i];
+  }
+  element_type* get() const { return impl_.get(); }
+
+  // Access to the deleter.
+  deleter_type& get_deleter() { return impl_.get_deleter(); }
+  const deleter_type& get_deleter() const { return impl_.get_deleter(); }
+
+  // Allow scoped_ptr<element_type> to be used in boolean expressions, but not
+  // implicitly convertible to a real bool (which is dangerous).
+ private:
+  typedef base::cef_internal::scoped_ptr_impl<element_type, deleter_type>
+      scoped_ptr::*Testable;
+
+ public:
+  operator Testable() const { return impl_.get() ? &scoped_ptr::impl_ : NULL; }
+
+  // Comparison operators.
+  // These return whether two scoped_ptr refer to the same object, not just to
+  // two different but equal objects.
+  bool operator==(element_type* array) const { return impl_.get() == array; }
+  bool operator!=(element_type* array) const { return impl_.get() != array; }
+
+  // Swap two scoped pointers.
+  void swap(scoped_ptr& p2) {
+    impl_.swap(p2.impl_);
+  }
+
+  // Release a pointer.
+  // The return value is the current pointer held by this object.
+  // If this object holds a NULL pointer, the return value is NULL.
+  // After this operation, this object will hold a NULL pointer,
+  // and will not own the object any more.
+  element_type* release() WARN_UNUSED_RESULT {
+    return impl_.release();
+  }
+
+ private:
+  // Force element_type to be a complete type.
+  enum { type_must_be_complete = sizeof(element_type) };
+
+  // Actually hold the data.
+  base::cef_internal::scoped_ptr_impl<element_type, deleter_type> impl_;
+
+  // Disable initialization from any type other than element_type*, by
+  // providing a constructor that matches such an initialization, but is
+  // private and has no definition. This is disabled because it is not safe to
+  // call delete[] on an array whose static type does not match its dynamic
+  // type.
+  template <typename U> explicit scoped_ptr(U* array);
+  explicit scoped_ptr(int disallow_construction_from_null);
+
+  // Disable reset() from any type other than element_type*, for the same
+  // reasons as the constructor above.
+  template <typename U> void reset(U* array);
+  void reset(int disallow_reset_from_null);
+
+  // Forbid comparison of scoped_ptr types.  If U != T, it totally
+  // doesn't make sense, and if U == T, it still doesn't make sense
+  // because you should never have the same object owned by two different
+  // scoped_ptrs.
+  template <class U> bool operator==(scoped_ptr<U> const& p2) const;
+  template <class U> bool operator!=(scoped_ptr<U> const& p2) const;
+};
+
+// Free functions
+template <class T, class D>
+void swap(scoped_ptr<T, D>& p1, scoped_ptr<T, D>& p2) {
+  p1.swap(p2);
+}
+
+template <class T, class D>
+bool operator==(T* p1, const scoped_ptr<T, D>& p2) {
+  return p1 == p2.get();
+}
+
+template <class T, class D>
+bool operator!=(T* p1, const scoped_ptr<T, D>& p2) {
+  return p1 != p2.get();
+}
+
+// A function to convert T* into scoped_ptr<T>
+// Doing e.g. make_scoped_ptr(new FooBarBaz<type>(arg)) is a shorter notation
+// for scoped_ptr<FooBarBaz<type> >(new FooBarBaz<type>(arg))
+template <typename T>
+scoped_ptr<T> make_scoped_ptr(T* ptr) {
+  return scoped_ptr<T>(ptr);
+}
+
+#endif  // !BUILDING_CEF_SHARED
+
+#endif  // CEF_INCLUDE_BASE_CEF_MEMORY_SCOPED_PTR_H_
diff --git a/src/include/libcef_/base/cef_string16.h b/src/include/libcef_/base/cef_string16.h
new file mode 100644
index 0000000..00b0283
--- /dev/null
+++ b/src/include/libcef_/base/cef_string16.h
@@ -0,0 +1,243 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2013
+// Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef CEF_INCLUDE_BASE_CEF_STRING16_H_
+#define CEF_INCLUDE_BASE_CEF_STRING16_H_
+#pragma once
+
+#if defined(BASE_STRINGS_STRING16_H_)
+// Do nothing if the Chromium header has already been included.
+// This can happen in cases where Chromium code is used directly by the
+// client application. When using Chromium code directly always include
+// the Chromium header first to avoid type conflicts.
+#elif defined(BUILDING_CEF_SHARED)
+// When building CEF include the Chromium header directly.
+#include "base/strings/string16.h"
+#else  // !BUILDING_CEF_SHARED
+// The following is substantially similar to the Chromium implementation.
+// If the Chromium implementation diverges the below implementation should be
+// updated to match.
+// WHAT:
+// A version of std::basic_string that provides 2-byte characters even when
+// wchar_t is not implemented as a 2-byte type. You can access this class as
+// string16. We also define char16, which string16 is based upon.
+//
+// WHY:
+// On Windows, wchar_t is 2 bytes, and it can conveniently handle UTF-16/UCS-2
+// data. Plenty of existing code operates on strings encoded as UTF-16.
+//
+// On many other platforms, sizeof(wchar_t) is 4 bytes by default. We can make
+// it 2 bytes by using the GCC flag -fshort-wchar. But then std::wstring fails
+// at run time, because it calls some functions (like wcslen) that come from
+// the system's native C library -- which was built with a 4-byte wchar_t!
+// It's wasteful to use 4-byte wchar_t strings to carry UTF-16 data, and it's
+// entirely improper on those systems where the encoding of wchar_t is defined
+// as UTF-32.
+//
+// Here, we define string16, which is similar to std::wstring but replaces all
+// libc functions with custom, 2-byte-char compatible routines. It is capable
+// of carrying UTF-16-encoded data.
+
+#include<stdio.h>
+#include<string>
+
+#include"libcef/base/cef_basictypes.h"
+
+#if defined(WCHAR_T_IS_UTF16)
+
+namespace base 
+{
+
+  typedef wchar_t char16;
+  typedef std::wstring string16;
+  typedef std::char_traits<wchar_t> string16_char_traits;
+}  // namespace base
+
+#elif defined(WCHAR_T_IS_UTF32)
+
+#include<stdint.h>  // For uint16_t
+
+#include"libcef/base/cef_macros.h"
+
+namespace base 
+{
+
+typedef uint16_t char16;
+
+// char16 versions of the functions required by string16_char_traits; these
+// are based on the wide character functions of similar names ("w" or "wcs"
+// instead of "c16").
+int c16memcmp(const char16* s1, const char16* s2, size_t n);
+size_t c16len(const char16* s);
+const char16* c16memchr(const char16* s, char16 c, size_t n);
+char16* c16memmove(char16* s1, const char16* s2, size_t n);
+char16* c16memcpy(char16* s1, const char16* s2, size_t n);
+char16* c16memset(char16* s, char16 c, size_t n);
+
+struct string16_char_traits 
+{
+  typedef char16 char_type;
+  typedef int int_type;
+
+  // int_type needs to be able to hold each possible value of char_type, and in
+  // addition, the distinct value of eof().
+  COMPILE_ASSERT(sizeof(int_type) > sizeof(char_type), unexpected_type_width);
+
+  typedef std::streamoff off_type;
+  typedef mbstate_t state_type;
+  typedef std::fpos<state_type> pos_type;
+
+  static void assign(char_type& c1, const char_type& c2) 
+  {
+    c1 = c2;
+  }
+
+  static bool eq(const char_type& c1, const char_type& c2) 
+  {
+    return c1 == c2;
+  }
+  static bool lt(const char_type& c1, const char_type& c2) 
+  {
+    return c1 < c2;
+  }
+
+  static int compare(const char_type* s1, const char_type* s2, size_t n) 
+  {
+    return c16memcmp(s1, s2, n);
+  }
+
+  static size_t length(const char_type* s) 
+  {
+    return c16len(s);
+  }
+
+  static const char_type* find(const char_type* s, size_t n,
+                               const char_type& a) 
+  {
+    return c16memchr(s, a, n);
+  }
+
+  static char_type* move(char_type* s1, const char_type* s2, int_type n) 
+  {
+    return c16memmove(s1, s2, n);
+  }
+
+  static char_type* copy(char_type* s1, const char_type* s2, size_t n) 
+  {
+    return c16memcpy(s1, s2, n);
+  }
+
+  static char_type* assign(char_type* s, size_t n, char_type a) 
+  {
+    return c16memset(s, a, n);
+  }
+
+  static int_type not_eof(const int_type& c) 
+  {
+    return eq_int_type(c, eof()) ? 0 : c;
+  }
+
+  static char_type to_char_type(const int_type& c) 
+  {
+    return char_type(c);
+  }
+
+  static int_type to_int_type(const char_type& c) 
+  {
+    return int_type(c);
+  }
+
+  static bool eq_int_type(const int_type& c1, const int_type& c2) 
+  {
+    return c1 == c2;
+  }
+
+  static int_type eof() 
+  {
+    return static_cast<int_type>(EOF);
+  }
+};
+
+typedef std::basic_string<char16, base::string16_char_traits> string16;
+
+extern std::ostream& operator<<(std::ostream& out, const string16& str);
+
+// This is required by googletest to print a readable output on test failures.
+extern void PrintTo(const string16& str, std::ostream* out);
+
+}  // namespace base
+
+// The string class will be explicitly instantiated only once, in string16.cc.
+//
+// std::basic_string<> in GNU libstdc++ contains a static data member,
+// _S_empty_rep_storage, to represent empty strings.  When an operation such
+// as assignment or destruction is performed on a string, causing its existing
+// data member to be invalidated, it must not be freed if this static data
+// member is being used.  Otherwise, it counts as an attempt to free static
+// (and not allocated) data, which is a memory error.
+//
+// Generally, due to C++ template magic, _S_empty_rep_storage will be marked
+// as a coalesced symbol, meaning that the linker will combine multiple
+// instances into a single one when generating output.
+//
+// If a string class is used by multiple shared libraries, a problem occurs.
+// Each library will get its own copy of _S_empty_rep_storage.  When strings
+// are passed across a library boundary for alteration or destruction, memory
+// errors will result.  GNU libstdc++ contains a configuration option,
+// --enable-fully-dynamic-string (_GLIBCXX_FULLY_DYNAMIC_STRING), which
+// disables the static data member optimization, but it's a good optimization
+// and non-STL code is generally at the mercy of the system's STL
+// configuration.  Fully-dynamic strings are not the default for GNU libstdc++
+// libstdc++ itself or for the libstdc++ installations on the systems we care
+// about, such as Mac OS X and relevant flavors of Linux.
+//
+// See also http://gcc.gnu.org/bugzilla/show_bug.cgi?id=24196 .
+//
+// To avoid problems, string classes need to be explicitly instantiated only
+// once, in exactly one library.  All other string users see it via an "extern"
+// declaration.  This is precisely how GNU libstdc++ handles
+// std::basic_string<char> (string) and std::basic_string<wchar_t> (wstring).
+//
+// This also works around a Mac OS X linker bug in ld64-85.2.1 (Xcode 3.1.2),
+// in which the linker does not fully coalesce symbols when dead code
+// stripping is enabled.  This bug causes the memory errors described above
+// to occur even when a std::basic_string<> does not cross shared library
+// boundaries, such as in statically-linked executables.
+//
+// TODO(mark): File this bug with Apple and update this note with a bug number.
+
+extern template
+class std::basic_string<base::char16, base::string16_char_traits>;
+
+#endif  // WCHAR_T_IS_UTF32
+
+#endif  // !BUILDING_CEF_SHARED
+
+#endif  // CEF_INCLUDE_BASE_CEF_STRING16_H_
diff --git a/src/include/libcef_/base/cef_template_util.h b/src/include/libcef_/base/cef_template_util.h
new file mode 100644
index 0000000..f04e2b7
--- /dev/null
+++ b/src/include/libcef_/base/cef_template_util.h
@@ -0,0 +1,247 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2011
+// Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef CEF_INCLUDE_BASE_CEF_TEMPLATE_UTIL_H_
+#define CEF_INCLUDE_BASE_CEF_TEMPLATE_UTIL_H_
+#pragma once
+
+#if defined(BASE_TEMPLATE_UTIL_H_)
+// Do nothing if the Chromium header has already been included.
+// This can happen in cases where Chromium code is used directly by the
+// client application. When using Chromium code directly always include
+// the Chromium header first to avoid type conflicts.
+#elif defined(BUILDING_CEF_SHARED)
+// When building CEF include the Chromium header directly.
+#include "base/template_util.h"
+#else  // !BUILDING_CEF_SHARED
+// The following is substantially similar to the Chromium implementation.
+// If the Chromium implementation diverges the below implementation should be
+// updated to match.
+
+#include<cstddef>  // For size_t.
+
+#include"libcef/base/cef_build.h"
+
+namespace base {
+
+// template definitions from tr1
+
+/*
+template<class T, T v>
+struct integral_constant 
+{
+  static const T value = v;
+  typedef T value_type;
+  typedef integral_constant<T, v> type;
+};*/
+
+//template <class T, T v> const T integral_constant<T, v>::value;
+
+#if defined(__WATCOMC__)
+    // Implementação específica para Watcom usando herança
+    template <class T>
+    struct integral_constant_base 
+    {
+        typedef T value_type;
+        typedef integral_constant_base<T> type;
+    };
+    
+    template <class T, T v>
+    struct integral_constant : integral_constant_base<T> 
+    {
+        static const T value = v;
+    };
+    
+    // Especializações para os tipos mais comuns
+    template <>
+    struct integral_constant<bool, true> : integral_constant_base<bool> 
+    {
+        static const bool value = true;
+    };
+    
+    template <>
+    struct integral_constant<bool, false> : integral_constant_base<bool> 
+    {
+        static const bool value = false;
+    };
+    
+    // Definições das constantes
+    const bool integral_constant<bool, true>::value;
+    const bool integral_constant<bool, false>::value;
+#else
+    // Implementação original para outros compiladores
+    template<class T, T v>
+    struct integral_constant 
+    {
+      static const T value = v;
+      typedef T value_type;
+      typedef integral_constant<T, v> type;
+    };
+    
+    template <class T, T v> const T integral_constant<T, v>::value;
+#endif
+
+typedef integral_constant<bool, true> true_type;
+typedef integral_constant<bool, false> false_type;
+
+template <class T> struct is_pointer : false_type {};
+template <class T> struct is_pointer<T*> : true_type {};
+
+// Member function pointer detection up to four params. Add more as needed
+// below. This is built-in to C++ 11, and we can remove this when we switch.
+template<typename T>
+struct is_member_function_pointer : false_type {};
+
+template <typename R, typename Z>
+struct is_member_function_pointer<R(Z::*)()> : true_type {};
+template <typename R, typename Z>
+struct is_member_function_pointer<R(Z::*)() const> : true_type {};
+
+template <typename R, typename Z, typename A>
+struct is_member_function_pointer<R(Z::*)(A)> : true_type {};
+template <typename R, typename Z, typename A>
+struct is_member_function_pointer<R(Z::*)(A) const> : true_type {};
+
+template <typename R, typename Z, typename A, typename B>
+struct is_member_function_pointer<R(Z::*)(A, B)> : true_type {};
+template <typename R, typename Z, typename A, typename B>
+struct is_member_function_pointer<R(Z::*)(A, B) const> : true_type {};
+
+template <typename R, typename Z, typename A, typename B, typename C>
+struct is_member_function_pointer<R(Z::*)(A, B, C)> : true_type {};
+template <typename R, typename Z, typename A, typename B, typename C>
+struct is_member_function_pointer<R(Z::*)(A, B, C) const> : true_type {};
+
+template <typename R, typename Z, typename A, typename B, typename C,
+          typename D>
+struct is_member_function_pointer<R(Z::*)(A, B, C, D)> : true_type {};
+template <typename R, typename Z, typename A, typename B, typename C,
+          typename D>
+struct is_member_function_pointer<R(Z::*)(A, B, C, D) const> : true_type {};
+
+
+template <class T, class U> struct is_same : public false_type {};
+template <class T> struct is_same<T,T> : true_type {};
+
+
+//template<class> struct is_array : public false_type {};
+
+#if defined(__WATCOMC__)
+    template<class T> struct is_array : public false_type {};
+#else
+    //template<class> struct is_array : public false_type {};
+    template<class T> struct is_array : public false_type {};
+#endif
+
+template<class T, size_t n> struct is_array<T[n]> : public true_type {};
+template<class T> struct is_array<T[]> : public true_type {};
+
+template <class T> struct is_non_const_reference : false_type {};
+template <class T> struct is_non_const_reference<T&> : true_type {};
+template <class T> struct is_non_const_reference<const T&> : false_type {};
+
+template <class T> struct is_const : false_type {};
+template <class T> struct is_const<const T> : true_type {};
+
+template <class T> struct is_void : false_type {};
+template <> struct is_void<void> : true_type {};
+
+namespace cef_internal {
+
+// Types YesType and NoType are guaranteed such that sizeof(YesType) <
+// sizeof(NoType).
+typedef char YesType;
+
+struct NoType {
+  YesType dummy[2];
+};
+
+// This class is an implementation detail for is_convertible, and you
+// don't need to know how it works to use is_convertible. For those
+// who care: we declare two different functions, one whose argument is
+// of type To and one with a variadic argument list. We give them
+// return types of different size, so we can use sizeof to trick the
+// compiler into telling us which function it would have chosen if we
+// had called it with an argument of type From.  See Alexandrescu's
+// _Modern C++ Design_ for more details on this sort of trick.
+
+struct ConvertHelper {
+  template <typename To>
+  static YesType Test(To);
+
+  template <typename To>
+  static NoType Test(...);
+
+  template <typename From>
+  static From& Create();
+};
+
+// Used to determine if a type is a struct/union/class. Inspired by Boost's
+// is_class type_trait implementation.
+struct IsClassHelper {
+  template <typename C>
+  static YesType Test(void(C::*)(void));
+
+  template <typename C>
+  static NoType Test(...);
+};
+
+}  // namespace cef_internal
+
+// Inherits from true_type if From is convertible to To, false_type otherwise.
+//
+// Note that if the type is convertible, this will be a true_type REGARDLESS
+// of whether or not the conversion would emit a warning.
+template <typename From, typename To>
+struct is_convertible
+    : integral_constant<bool,
+                        sizeof(cef_internal::ConvertHelper::Test<To>(
+                                   cef_internal::ConvertHelper::Create<From>())) ==
+                        sizeof(cef_internal::YesType)> {
+};
+
+template <typename T>
+struct is_class
+    : integral_constant<bool,
+                        sizeof(cef_internal::IsClassHelper::Test<T>(0)) ==
+                            sizeof(cef_internal::YesType)> {
+};
+
+template<bool B, class T = void>
+struct enable_if {};
+
+template<class T>
+struct enable_if<true, T> { typedef T type; };
+
+}  // namespace base
+
+#endif  // !BUILDING_CEF_SHARED
+
+#endif  // CEF_INCLUDE_BASE_CEF_TEMPLATE_UTIL_H_
diff --git a/src/include/libcef_/base/cef_thread_checker.h b/src/include/libcef_/base/cef_thread_checker.h
new file mode 100644
index 0000000..b938465
--- /dev/null
+++ b/src/include/libcef_/base/cef_thread_checker.h
@@ -0,0 +1,126 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2012
+// Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef CEF_INCLUDE_BASE_THREAD_CHECKER_H_
+#define CEF_INCLUDE_BASE_THREAD_CHECKER_H_
+#pragma once
+
+#if defined(BASE_THREADING_THREAD_CHECKER_H_)
+// Do nothing if the Chromium header has already been included.
+// This can happen in cases where Chromium code is used directly by the
+// client application. When using Chromium code directly always include
+// the Chromium header first to avoid type conflicts.
+#elif defined(BUILDING_CEF_SHARED)
+// When building CEF include the Chromium header directly.
+#include"base/threading/thread_checker.h"
+#else  // !BUILDING_CEF_SHARED
+// The following is substantially similar to the Chromium implementation.
+// If the Chromium implementation diverges the below implementation should be
+// updated to match.
+
+#include"libcef/base/cef_logging.h"
+#include"libcef/base/internal/cef_thread_checker_impl.h"
+
+// Apart from debug builds, we also enable the thread checker in
+// builds with DCHECK_ALWAYS_ON so that trybots and waterfall bots
+// with this define will get the same level of thread checking as
+// debug bots.
+#if DCHECK_IS_ON()
+#define ENABLE_THREAD_CHECKER 1
+#else
+#define ENABLE_THREAD_CHECKER 0
+#endif
+
+
+namespace base {
+
+namespace cef_internal {
+
+// Do nothing implementation, for use in release mode.
+//
+// Note: You should almost always use the ThreadChecker class to get the
+// right version for your build configuration.
+class ThreadCheckerDoNothing {
+ public:
+  bool CalledOnValidThread() const {
+    return true;
+  }
+
+  void DetachFromThread() {}
+};
+
+}  // namespace cef_internal
+
+// ThreadChecker is a helper class used to help verify that some methods of a
+// class are called from the same thread. It provides identical functionality to
+// base::NonThreadSafe, but it is meant to be held as a member variable, rather
+// than inherited from base::NonThreadSafe.
+//
+// While inheriting from base::NonThreadSafe may give a clear indication about
+// the thread-safety of a class, it may also lead to violations of the style
+// guide with regard to multiple inheritance. The choice between having a
+// ThreadChecker member and inheriting from base::NonThreadSafe should be based
+// on whether:
+//  - Derived classes need to know the thread they belong to, as opposed to
+//    having that functionality fully encapsulated in the base class.
+//  - Derived classes should be able to reassign the base class to another
+//    thread, via DetachFromThread.
+//
+// If neither of these are true, then having a ThreadChecker member and calling
+// CalledOnValidThread is the preferable solution.
+//
+// Example:
+// class MyClass {
+//  public:
+//   void Foo() {
+//     DCHECK(thread_checker_.CalledOnValidThread());
+//     ... (do stuff) ...
+//   }
+//
+//  private:
+//   ThreadChecker thread_checker_;
+// }
+//
+// In Release mode, CalledOnValidThread will always return true.
+#if ENABLE_THREAD_CHECKER
+class ThreadChecker : public cef_internal::ThreadCheckerImpl {
+};
+#else
+class ThreadChecker : public cef_internal::ThreadCheckerDoNothing {
+};
+#endif  // ENABLE_THREAD_CHECKER
+
+#undef ENABLE_THREAD_CHECKER
+
+}  // namespace base
+
+#endif  // !BUILDING_CEF_SHARED
+
+#endif  // CEF_INCLUDE_BASE_THREAD_CHECKER_H_
diff --git a/src/include/libcef_/base/cef_thread_collision_warner.h b/src/include/libcef_/base/cef_thread_collision_warner.h
new file mode 100644
index 0000000..0bd778f
--- /dev/null
+++ b/src/include/libcef_/base/cef_thread_collision_warner.h
@@ -0,0 +1,287 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2012
+// Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef CEF_INCLUDE_BASE_CEF_THREAD_COLLISION_WARNER_H_
+#define CEF_INCLUDE_BASE_CEF_THREAD_COLLISION_WARNER_H_
+#pragma once
+
+#if defined(BASE_THREADING_THREAD_COLLISION_WARNER_H_)
+// Do nothing if the Chromium header has already been included.
+// This can happen in cases where Chromium code is used directly by the
+// client application. When using Chromium code directly always include
+// the Chromium header first to avoid type conflicts.
+#elif defined(BUILDING_CEF_SHARED)
+// When building CEF include the Chromium header directly.
+#include "base/threading/thread_collision_warner.h"
+#else  // !BUILDING_CEF_SHARED
+// The following is substantially similar to the Chromium implementation.
+// If the Chromium implementation diverges the below implementation should be
+// updated to match.
+
+#include<memory>
+
+#include"libcef/base/cef_atomicops.h"
+#include"libcef/base/cef_basictypes.h"
+#include"libcef/base/cef_build.h"
+#include"libcef/base/cef_macros.h"
+
+// A helper class alongside macros to be used to verify assumptions about thread
+// safety of a class.
+//
+// Example: Queue implementation non thread-safe but still usable if clients
+//          are synchronized somehow.
+//
+//          In this case the macro DFAKE_SCOPED_LOCK has to be
+//          used, it checks that if a thread is inside the push/pop then
+//          noone else is still inside the pop/push
+//
+// class NonThreadSafeQueue {
+//  public:
+//   ...
+//   void push(int) { DFAKE_SCOPED_LOCK(push_pop_); ... }
+//   int pop() { DFAKE_SCOPED_LOCK(push_pop_); ... }
+//   ...
+//  private:
+//   DFAKE_MUTEX(push_pop_);
+// };
+//
+//
+// Example: Queue implementation non thread-safe but still usable if clients
+//          are synchronized somehow, it calls a method to "protect" from
+//          a "protected" method
+//
+//          In this case the macro DFAKE_SCOPED_RECURSIVE_LOCK
+//          has to be used, it checks that if a thread is inside the push/pop
+//          then noone else is still inside the pop/push
+//
+// class NonThreadSafeQueue {
+//  public:
+//   void push(int) {
+//     DFAKE_SCOPED_LOCK(push_pop_);
+//     ...
+//   }
+//   int pop() {
+//     DFAKE_SCOPED_RECURSIVE_LOCK(push_pop_);
+//     bar();
+//     ...
+//   }
+//   void bar() { DFAKE_SCOPED_RECURSIVE_LOCK(push_pop_); ... }
+//   ...
+//  private:
+//   DFAKE_MUTEX(push_pop_);
+// };
+//
+//
+// Example: Queue implementation not usable even if clients are synchronized,
+//          so only one thread in the class life cycle can use the two members
+//          push/pop.
+//
+//          In this case the macro DFAKE_SCOPED_LOCK_THREAD_LOCKED pins the
+//          specified
+//          critical section the first time a thread enters push or pop, from
+//          that time on only that thread is allowed to execute push or pop.
+//
+// class NonThreadSafeQueue {
+//  public:
+//   ...
+//   void push(int) { DFAKE_SCOPED_LOCK_THREAD_LOCKED(push_pop_); ... }
+//   int pop() { DFAKE_SCOPED_LOCK_THREAD_LOCKED(push_pop_); ... }
+//   ...
+//  private:
+//   DFAKE_MUTEX(push_pop_);
+// };
+//
+//
+// Example: Class that has to be contructed/destroyed on same thread, it has
+//          a "shareable" method (with external synchronization) and a not
+//          shareable method (even with external synchronization).
+//
+//          In this case 3 Critical sections have to be defined
+//
+// class ExoticClass {
+//  public:
+//   ExoticClass() { DFAKE_SCOPED_LOCK_THREAD_LOCKED(ctor_dtor_); ... }
+//   ~ExoticClass() { DFAKE_SCOPED_LOCK_THREAD_LOCKED(ctor_dtor_); ... }
+//
+//   void Shareable() { DFAKE_SCOPED_LOCK(shareable_section_); ... }
+//   void NotShareable() { DFAKE_SCOPED_LOCK_THREAD_LOCKED(ctor_dtor_); ... }
+//   ...
+//  private:
+//   DFAKE_MUTEX(ctor_dtor_);
+//   DFAKE_MUTEX(shareable_section_);
+// };
+
+
+#if !defined(NDEBUG)
+
+// Defines a class member that acts like a mutex. It is used only as a
+// verification tool.
+#define DFAKE_MUTEX(obj) \
+     mutable base::ThreadCollisionWarner obj
+// Asserts the call is never called simultaneously in two threads. Used at
+// member function scope.
+#define DFAKE_SCOPED_LOCK(obj) \
+     base::ThreadCollisionWarner::ScopedCheck s_check_##obj(&obj)
+// Asserts the call is never called simultaneously in two threads. Used at
+// member function scope. Same as DFAKE_SCOPED_LOCK but allows recursive locks.
+#define DFAKE_SCOPED_RECURSIVE_LOCK(obj) \
+     base::ThreadCollisionWarner::ScopedRecursiveCheck sr_check_##obj(&obj)
+// Asserts the code is always executed in the same thread.
+#define DFAKE_SCOPED_LOCK_THREAD_LOCKED(obj) \
+     base::ThreadCollisionWarner::Check check_##obj(&obj)
+
+#else
+
+#define DFAKE_MUTEX(obj) typedef void InternalFakeMutexType##obj
+#define DFAKE_SCOPED_LOCK(obj) ((void)0)
+#define DFAKE_SCOPED_RECURSIVE_LOCK(obj) ((void)0)
+#define DFAKE_SCOPED_LOCK_THREAD_LOCKED(obj) ((void)0)
+
+#endif
+
+namespace base {
+
+// The class ThreadCollisionWarner uses an Asserter to notify the collision
+// AsserterBase is the interfaces and DCheckAsserter is the default asserter
+// used. During the unit tests is used another class that doesn't "DCHECK"
+// in case of collision (check thread_collision_warner_unittests.cc)
+struct AsserterBase {
+  virtual ~AsserterBase() {}
+  virtual void warn() = 0;
+};
+
+struct DCheckAsserter : public AsserterBase {
+  virtual ~DCheckAsserter() {}
+  virtual void warn() OVERRIDE;
+};
+
+class ThreadCollisionWarner {
+ public:
+  // The parameter asserter is there only for test purpose
+  explicit ThreadCollisionWarner(AsserterBase* asserter = new DCheckAsserter())
+      : valid_thread_id_(0),
+        counter_(0),
+        asserter_(asserter) {}
+
+  ~ThreadCollisionWarner() {
+    delete asserter_;
+  }
+
+  // This class is meant to be used through the macro
+  // DFAKE_SCOPED_LOCK_THREAD_LOCKED
+  // it doesn't leave the critical section, as opposed to ScopedCheck,
+  // because the critical section being pinned is allowed to be used only
+  // from one thread
+  class Check {
+   public:
+    explicit Check(ThreadCollisionWarner* warner)
+        : warner_(warner) {
+      warner_->EnterSelf();
+    }
+
+    ~Check() {}
+
+   private:
+    ThreadCollisionWarner* warner_;
+
+    DISALLOW_COPY_AND_ASSIGN(Check);
+  };
+
+  // This class is meant to be used through the macro
+  // DFAKE_SCOPED_LOCK
+  class ScopedCheck {
+   public:
+    explicit ScopedCheck(ThreadCollisionWarner* warner)
+        : warner_(warner) {
+      warner_->Enter();
+    }
+
+    ~ScopedCheck() {
+      warner_->Leave();
+    }
+
+   private:
+    ThreadCollisionWarner* warner_;
+
+    DISALLOW_COPY_AND_ASSIGN(ScopedCheck);
+  };
+
+  // This class is meant to be used through the macro
+  // DFAKE_SCOPED_RECURSIVE_LOCK
+  class ScopedRecursiveCheck {
+   public:
+    explicit ScopedRecursiveCheck(ThreadCollisionWarner* warner)
+        : warner_(warner) {
+      warner_->EnterSelf();
+    }
+
+    ~ScopedRecursiveCheck() {
+      warner_->Leave();
+    }
+
+   private:
+    ThreadCollisionWarner* warner_;
+
+    DISALLOW_COPY_AND_ASSIGN(ScopedRecursiveCheck);
+  };
+
+ private:
+  // This method stores the current thread identifier and does a DCHECK
+  // if a another thread has already done it, it is safe if same thread
+  // calls this multiple time (recursion allowed).
+  void EnterSelf();
+
+  // Same as EnterSelf but recursion is not allowed.
+  void Enter();
+
+  // Removes the thread_id stored in order to allow other threads to
+  // call EnterSelf or Enter.
+  void Leave();
+
+  // This stores the thread id that is inside the critical section, if the
+  // value is 0 then no thread is inside.
+  volatile subtle::Atomic32 valid_thread_id_;
+
+  // Counter to trace how many time a critical section was "pinned"
+  // (when allowed) in order to unpin it when counter_ reaches 0.
+  volatile subtle::Atomic32 counter_;
+
+  // Here only for class unit tests purpose, during the test I need to not
+  // DCHECK but notify the collision with something else.
+  AsserterBase* asserter_;
+
+  DISALLOW_COPY_AND_ASSIGN(ThreadCollisionWarner);
+};
+
+}  // namespace base
+
+#endif  // !BUILDING_CEF_SHARED
+
+#endif  // CEF_INCLUDE_BASE_CEF_THREAD_COLLISION_WARNER_H_
diff --git a/src/include/libcef_/base/cef_trace_event.h b/src/include/libcef_/base/cef_trace_event.h
new file mode 100644
index 0000000..bb87248
--- /dev/null
+++ b/src/include/libcef_/base/cef_trace_event.h
@@ -0,0 +1,427 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2012
+// Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+///
+// Trace events are for tracking application performance and resource usage.
+// Macros are provided to track:
+//    Begin and end of function calls
+//    Counters
+//
+// Events are issued against categories. Whereas LOG's categories are statically
+// defined, TRACE categories are created implicitly with a string. For example:
+//   TRACE_EVENT_INSTANT0("MY_SUBSYSTEM", "SomeImportantEvent")
+//
+// Events can be INSTANT, or can be pairs of BEGIN and END in the same scope:
+//   TRACE_EVENT_BEGIN0("MY_SUBSYSTEM", "SomethingCostly")
+//   doSomethingCostly()
+//   TRACE_EVENT_END0("MY_SUBSYSTEM", "SomethingCostly")
+// Note: Our tools can't always determine the correct BEGIN/END pairs unless
+// these are used in the same scope. Use ASYNC_BEGIN/ASYNC_END macros if you
+// need them to be in separate scopes.
+//
+// A common use case is to trace entire function scopes. This issues a trace
+// BEGIN and END automatically:
+//   void doSomethingCostly() {
+//     TRACE_EVENT0("MY_SUBSYSTEM", "doSomethingCostly");
+//     ...
+//   }
+//
+// Additional parameters can be associated with an event:
+//   void doSomethingCostly2(int howMuch) {
+//     TRACE_EVENT1("MY_SUBSYSTEM", "doSomethingCostly",
+//         "howMuch", howMuch);
+//     ...
+//   }
+//
+// The trace system will automatically add to this information the current
+// process id, thread id, and a timestamp in microseconds.
+//
+// To trace an asynchronous procedure such as an IPC send/receive, use
+// ASYNC_BEGIN and ASYNC_END:
+//   [single threaded sender code]
+//     static int send_count = 0;
+//     ++send_count;
+//     TRACE_EVENT_ASYNC_BEGIN0("ipc", "message", send_count);
+//     Send(new MyMessage(send_count));
+//   [receive code]
+//     void OnMyMessage(send_count) {
+//       TRACE_EVENT_ASYNC_END0("ipc", "message", send_count);
+//     }
+// The third parameter is a unique ID to match ASYNC_BEGIN/ASYNC_END pairs.
+// ASYNC_BEGIN and ASYNC_END can occur on any thread of any traced process.
+// Pointers can be used for the ID parameter, and they will be mangled
+// internally so that the same pointer on two different processes will not
+// match. For example:
+//   class MyTracedClass {
+//    public:
+//     MyTracedClass() {
+//       TRACE_EVENT_ASYNC_BEGIN0("category", "MyTracedClass", this);
+//     }
+//     ~MyTracedClass() {
+//       TRACE_EVENT_ASYNC_END0("category", "MyTracedClass", this);
+//     }
+//   }
+//
+// The trace event also supports counters, which is a way to track a quantity
+// as it varies over time. Counters are created with the following macro:
+//   TRACE_COUNTER1("MY_SUBSYSTEM", "myCounter", g_myCounterValue);
+//
+// Counters are process-specific. The macro itself can be issued from any
+// thread, however.
+//
+// Sometimes, you want to track two counters at once. You can do this with two
+// counter macros:
+//   TRACE_COUNTER1("MY_SUBSYSTEM", "myCounter0", g_myCounterValue[0]);
+//   TRACE_COUNTER1("MY_SUBSYSTEM", "myCounter1", g_myCounterValue[1]);
+// Or you can do it with a combined macro:
+//   TRACE_COUNTER2("MY_SUBSYSTEM", "myCounter",
+//       "bytesPinned", g_myCounterValue[0],
+//       "bytesAllocated", g_myCounterValue[1]);
+// This indicates to the tracing UI that these counters should be displayed
+// in a single graph, as a summed area chart.
+//
+// Since counters are in a global namespace, you may want to disembiguate with a
+// unique ID, by using the TRACE_COUNTER_ID* variations.
+//
+// By default, trace collection is compiled in, but turned off at runtime.
+// Collecting trace data is the responsibility of the embedding application. In
+// CEF's case, calling BeginTracing will turn on tracing on all active
+// processes.
+//
+//
+// Memory scoping note:
+// Tracing copies the pointers, not the string content, of the strings passed
+// in for category, name, and arg_names.  Thus, the following code will cause
+// problems:
+//     char* str = strdup("impprtantName");
+//     TRACE_EVENT_INSTANT0("SUBSYSTEM", str);  // BAD!
+//     free(str);                   // Trace system now has dangling pointer
+//
+// To avoid this issue with the |name| and |arg_name| parameters, use the
+// TRACE_EVENT_COPY_XXX overloads of the macros at additional runtime
+// overhead.
+// Notes: The category must always be in a long-lived char* (i.e. static const).
+//        The |arg_values|, when used, are always deep copied with the _COPY
+//        macros.
+//
+//
+// Thread Safety:
+// All macros are thread safe and can be used from any process.
+///
+
+#ifndef CEF_INCLUDE_BASE_CEF_TRACE_EVENT_H_
+#define CEF_INCLUDE_BASE_CEF_TRACE_EVENT_H_
+#pragma once
+
+#if defined(TRACE_EVENT0)
+// Do nothing if the macros provided by this header already exist.
+// This can happen in cases where Chromium code is used directly by the
+// client application. When using Chromium code directly always include
+// the Chromium header first to avoid type conflicts.
+#elif defined(BUILDING_CEF_SHARED)
+// When building CEF include the Chromium header directly.
+#include "base/debug/trace_event.h"
+#else  // !BUILDING_CEF_SHARED
+// The following is substantially similar to the Chromium implementation.
+// If the Chromium implementation diverges the below implementation should be
+// updated to match.
+
+#include"libcef/internal/cef_trace_event_internal.h"
+
+// Records a pair of begin and end events called "name" for the current
+// scope, with 0, 1 or 2 associated arguments. If the category is not
+// enabled, then this does nothing.
+// - category and name strings must have application lifetime (statics or
+//   literals). They may not include " chars.
+#define TRACE_EVENT0(category, name) \
+  cef_trace_event_begin(category, name, NULL, 0, NULL, 0, false); \
+  CEF_INTERNAL_TRACE_END_ON_SCOPE_CLOSE(category, name)
+#define TRACE_EVENT1(category, name, arg1_name, arg1_val) \
+  cef_trace_event_begin(category, name, arg1_name, arg1_val, NULL, 0, false); \
+  CEF_INTERNAL_TRACE_END_ON_SCOPE_CLOSE(category, name)
+#define TRACE_EVENT2(category, name, arg1_name, arg1_val, arg2_name, \
+      arg2_val) \
+  cef_trace_event_begin(category, name, arg1_name, arg1_val, \
+                                        arg2_name, arg2_val, false); \
+  CEF_INTERNAL_TRACE_END_ON_SCOPE_CLOSE(category, name)
+
+// Implementation detail: trace event macros create temporary variable names.
+// These macros give each temporary variable a unique name based on the line
+// number to prevent name collisions.
+#define CEF_INTERNAL_TRACE_EVENT_UID3(a,b) \
+  cef_trace_event_unique_##a##b
+#define CEF_INTERNAL_TRACE_EVENT_UID2(a,b) \
+  CEF_INTERNAL_TRACE_EVENT_UID3(a,b)
+#define CEF_INTERNAL_TRACE_EVENT_UID(name_prefix) \
+  CEF_INTERNAL_TRACE_EVENT_UID2(name_prefix, __LINE__)
+
+// Implementation detail: internal macro to end end event when the scope ends.
+#define CEF_INTERNAL_TRACE_END_ON_SCOPE_CLOSE(category, name) \
+   cef_trace_event::CefTraceEndOnScopeClose \
+       CEF_INTERNAL_TRACE_EVENT_UID(profileScope)(category, name)
+
+// Records a single event called "name" immediately, with 0, 1 or 2
+// associated arguments. If the category is not enabled, then this
+// does nothing.
+// - category and name strings must have application lifetime (statics or
+//   literals). They may not include " chars.
+#define TRACE_EVENT_INSTANT0(category, name) \
+  cef_trace_event_instant(category, name, NULL, 0, NULL, 0, false)
+#define TRACE_EVENT_INSTANT1(category, name, arg1_name, arg1_val) \
+  cef_trace_event_instant(category, name, arg1_name, arg1_val, NULL, 0, false)
+#define TRACE_EVENT_INSTANT2(category, name, arg1_name, arg1_val, \
+      arg2_name, arg2_val) \
+  cef_trace_event_instant(category, name, arg1_name, arg1_val, arg2_name, \
+      arg2_val, false)
+#define TRACE_EVENT_COPY_INSTANT0(category, name) \
+  cef_trace_event_instant(category, name, NULL, 0, NULL, 0, true)
+#define TRACE_EVENT_COPY_INSTANT1(category, name, arg1_name, arg1_val) \
+  cef_trace_event_instant(category, name, arg1_name, arg1_val, NULL, 0, true)
+#define TRACE_EVENT_COPY_INSTANT2(category, name, arg1_name, arg1_val, \
+      arg2_name, arg2_val) \
+  cef_trace_event_instant(category, name, arg1_name, arg1_val, arg2_name, \
+      arg2_val, true)
+
+// Records a single BEGIN event called "name" immediately, with 0, 1 or 2
+// associated arguments. If the category is not enabled, then this
+// does nothing.
+// - category and name strings must have application lifetime (statics or
+//   literals). They may not include " chars.
+#define TRACE_EVENT_BEGIN0(category, name) \
+  cef_trace_event_begin(category, name, NULL, 0, NULL, 0, false)
+#define TRACE_EVENT_BEGIN1(category, name, arg1_name, arg1_val) \
+  cef_trace_event_begin(category, name, arg1_name, arg1_val, NULL, 0, false)
+#define TRACE_EVENT_BEGIN2(category, name, arg1_name, arg1_val, \
+      arg2_name, arg2_val) \
+  cef_trace_event_begin(category, name, arg1_name, arg1_val, arg2_name, \
+      arg2_val, false)
+#define TRACE_EVENT_COPY_BEGIN0(category, name) \
+  cef_trace_event_begin(category, name, NULL, 0, NULL, 0, true)
+#define TRACE_EVENT_COPY_BEGIN1(category, name, arg1_name, arg1_val) \
+  cef_trace_event_begin(category, name, arg1_name, arg1_val, NULL, 0, true)
+#define TRACE_EVENT_COPY_BEGIN2(category, name, arg1_name, arg1_val, \
+      arg2_name, arg2_val) \
+  cef_trace_event_begin(category, name, arg1_name, arg1_val, arg2_name, \
+      arg2_val, true)
+
+// Records a single END event for "name" immediately. If the category
+// is not enabled, then this does nothing.
+// - category and name strings must have application lifetime (statics or
+//   literals). They may not include " chars.
+#define TRACE_EVENT_END0(category, name) \
+  cef_trace_event_end(category, name, NULL, 0, NULL, 0, false)
+#define TRACE_EVENT_END1(category, name, arg1_name, arg1_val) \
+  cef_trace_event_end(category, name, arg1_name, arg1_val, NULL, 0, false)
+#define TRACE_EVENT_END2(category, name, arg1_name, arg1_val, \
+      arg2_name, arg2_val) \
+  cef_trace_event_end(category, name, arg1_name, arg1_val, arg2_name, \
+      arg2_val, false)
+#define TRACE_EVENT_COPY_END0(category, name) \
+  cef_trace_event_end(category, name, NULL, 0, NULL, 0, true)
+#define TRACE_EVENT_COPY_END1(category, name, arg1_name, arg1_val) \
+  cef_trace_event_end(category, name, arg1_name, arg1_val, NULL, 0, true)
+#define TRACE_EVENT_COPY_END2(category, name, arg1_name, arg1_val, \
+      arg2_name, arg2_val) \
+  cef_trace_event_end(category, name, arg1_name, arg1_val, arg2_name, \
+      arg2_val, true)
+
+// Records the value of a counter called "name" immediately. Value
+// must be representable as a 32 bit integer.
+// - category and name strings must have application lifetime (statics or
+//   literals). They may not include " chars.
+#define TRACE_COUNTER1(category, name, value) \
+  cef_trace_counter(category, name, NULL, value, NULL, 0, false)
+#define TRACE_COPY_COUNTER1(category, name, value) \
+  cef_trace_counter(category, name, NULL, value, NULL, 0, true)
+
+// Records the values of a multi-parted counter called "name" immediately.
+// The UI will treat value1 and value2 as parts of a whole, displaying their
+// values as a stacked-bar chart.
+// - category and name strings must have application lifetime (statics or
+//   literals). They may not include " chars.
+#define TRACE_COUNTER2(category, name, value1_name, value1_val, \
+      value2_name, value2_val) \
+  cef_trace_counter(category, name, value1_name, value1_val, value2_name, \
+      value2_val, false)
+#define TRACE_COPY_COUNTER2(category, name, value1_name, value1_val, \
+      value2_name, value2_val) \
+  cef_trace_counter(category, name, value1_name, value1_val, value2_name, \
+      value2_val, true)
+
+// Records the value of a counter called "name" immediately. Value
+// must be representable as a 32 bit integer.
+// - category and name strings must have application lifetime (statics or
+//   literals). They may not include " chars.
+// - |id| is used to disambiguate counters with the same name. It must either
+//   be a pointer or an integer value up to 64 bits. If it's a pointer, the
+//   bits will be xored with a hash of the process ID so that the same pointer
+//   on two different processes will not collide.
+#define TRACE_COUNTER_ID1(category, name, id, value) \
+  cef_trace_counter_id(category, name, id, NULL, value, NULL, 0, false)
+#define TRACE_COPY_COUNTER_ID1(category, name, id, value) \
+  cef_trace_counter_id(category, name, id, NULL, value, NULL, 0, true)
+
+// Records the values of a multi-parted counter called "name" immediately.
+// The UI will treat value1 and value2 as parts of a whole, displaying their
+// values as a stacked-bar chart.
+// - category and name strings must have application lifetime (statics or
+//   literals). They may not include " chars.
+// - |id| is used to disambiguate counters with the same name. It must either
+//   be a pointer or an integer value up to 64 bits. If it's a pointer, the
+//   bits will be xored with a hash of the process ID so that the same pointer
+//   on two different processes will not collide.
+#define TRACE_COUNTER_ID2(category, name, id, value1_name, value1_val, \
+      value2_name, value2_val) \
+  cef_trace_counter_id(category, name, id, value1_name, value1_val, \
+      value2_name, value2_val, false)
+#define TRACE_COPY_COUNTER_ID2(category, name, id, value1_name, \
+      value1_val, value2_name, value2_val) \
+  cef_trace_counter_id(category, name, id, value1_name, value1_val, \
+      value2_name, value2_val, true)
+
+
+// Records a single ASYNC_BEGIN event called "name" immediately, with 0, 1 or 2
+// associated arguments. If the category is not enabled, then this
+// does nothing.
+// - category and name strings must have application lifetime (statics or
+//   literals). They may not include " chars.
+// - |id| is used to match the ASYNC_BEGIN event with the ASYNC_END event.
+//   ASYNC events are considered to match if their category, name and id values
+//   all match. |id| must either be a pointer or an integer value up to 64
+//   bits. If it's a pointer, the bits will be xored with a hash of the process
+//   ID sothat the same pointer on two different processes will not collide.
+// An asynchronous operation can consist of multiple phases. The first phase is
+// defined by the ASYNC_BEGIN calls. Additional phases can be defined using the
+// ASYNC_STEP_BEGIN macros. When the operation completes, call ASYNC_END.
+// An async operation can span threads and processes, but all events in that
+// operation must use the same |name| and |id|. Each event can have its own
+// args.
+#define TRACE_EVENT_ASYNC_BEGIN0(category, name, id) \
+  cef_trace_event_async_begin(category, name, id, NULL, 0, NULL, 0, false)
+#define TRACE_EVENT_ASYNC_BEGIN1(category, name, id, arg1_name, arg1_val) \
+  cef_trace_event_async_begin(category, name, id, arg1_name, arg1_val, NULL, \
+      0, false)
+#define TRACE_EVENT_ASYNC_BEGIN2(category, name, id, arg1_name, arg1_val, \
+      arg2_name, arg2_val) \
+  cef_trace_event_async_begin(category, name, id, arg1_name, arg1_val, \
+      arg2_name, arg2_val, false)
+#define TRACE_EVENT_COPY_ASYNC_BEGIN0(category, name, id) \
+  cef_trace_event_async_begin(category, name, id, NULL, 0, NULL, 0, true)
+#define TRACE_EVENT_COPY_ASYNC_BEGIN1(category, name, id, arg1_name, \
+      arg1_val) \
+  cef_trace_event_async_begin(category, name, id, arg1_name, arg1_val, NULL, \
+      0, true)
+#define TRACE_EVENT_COPY_ASYNC_BEGIN2(category, name, id, arg1_name, \
+      arg1_val, arg2_name, arg2_val) \
+  cef_trace_event_async_begin(category, name, id, arg1_name, arg1_val, \
+      arg2_name, arg2_val, true)
+
+// Records a single ASYNC_STEP_INTO event for |step| immediately. If the
+// category is not enabled, then this does nothing. The |name| and |id| must
+// match the ASYNC_BEGIN event above. The |step| param identifies this step
+// within the async event. This should be called at the beginning of the next
+// phase of an asynchronous operation. The ASYNC_BEGIN event must not have any
+// ASYNC_STEP_PAST events.
+#define TRACE_EVENT_ASYNC_STEP_INTO0(category, name, id, step) \
+  cef_trace_event_async_step_into(category, name, id, step, NULL, 0, false)
+#define TRACE_EVENT_ASYNC_STEP_INTO1(category, name, id, step, \
+      arg1_name, arg1_val) \
+  cef_trace_event_async_step_into(category, name, id, step, arg1_name, \
+      arg1_val, false)
+#define TRACE_EVENT_COPY_ASYNC_STEP_INTO0(category, name, id, step) \
+  cef_trace_event_async_step_into(category, name, id, step, NULL, 0, true)
+#define TRACE_EVENT_COPY_ASYNC_STEP_INTO1(category, name, id, step, \
+      arg1_name, arg1_val) \
+  cef_trace_event_async_step_into(category, name, id, step, arg1_name, \
+      arg1_val, true)
+
+// Records a single ASYNC_STEP_PAST event for |step| immediately. If the
+// category is not enabled, then this does nothing. The |name| and |id| must
+// match the ASYNC_BEGIN event above. The |step| param identifies this step
+// within the async event. This should be called at the beginning of the next
+// phase of an asynchronous operation. The ASYNC_BEGIN event must not have any
+// ASYNC_STEP_INTO events.
+#define TRACE_EVENT_ASYNC_STEP_PAST0(category, name, id, step) \
+  cef_trace_event_async_step_past(category, name, id, step, NULL, 0, false)
+#define TRACE_EVENT_ASYNC_STEP_PAST1(category, name, id, step, \
+      arg1_name, arg1_val) \
+  cef_trace_event_async_step_past(category, name, id, step, arg1_name, \
+      arg1_val, false)
+#define TRACE_EVENT_COPY_ASYNC_STEP_PAST0(category, name, id, step) \
+  cef_trace_event_async_step_past(category, name, id, step, NULL, 0, true)
+#define TRACE_EVENT_COPY_ASYNC_STEP_PAST1(category, name, id, step, \
+      arg1_name, arg1_val) \
+  cef_trace_event_async_step_past(category, name, id, step, arg1_name, \
+      arg1_val, true)
+
+// Records a single ASYNC_END event for "name" immediately. If the category
+// is not enabled, then this does nothing.
+#define TRACE_EVENT_ASYNC_END0(category, name, id) \
+  cef_trace_event_async_end(category, name, id, NULL, 0, NULL, 0, false)
+#define TRACE_EVENT_ASYNC_END1(category, name, id, arg1_name, arg1_val) \
+  cef_trace_event_async_end(category, name, id, arg1_name, arg1_val, NULL, 0, \
+      false)
+#define TRACE_EVENT_ASYNC_END2(category, name, id, arg1_name, arg1_val, \
+      arg2_name, arg2_val) \
+  cef_trace_event_async_end(category, name, id, arg1_name, arg1_val, \
+      arg2_name, arg2_val, false)
+#define TRACE_EVENT_COPY_ASYNC_END0(category, name, id) \
+  cef_trace_event_async_end(category, name, id, NULL, 0, NULL, 0, true)
+#define TRACE_EVENT_COPY_ASYNC_END1(category, name, id, arg1_name, \
+      arg1_val) \
+  cef_trace_event_async_end(category, name, id, arg1_name, arg1_val, NULL, 0, \
+      true)
+#define TRACE_EVENT_COPY_ASYNC_END2(category, name, id, arg1_name, \
+      arg1_val, arg2_name, arg2_val) \
+  cef_trace_event_async_end(category, name, id, arg1_name, arg1_val, \
+      arg2_name, arg2_val, true)
+
+namespace cef_trace_event {
+
+// Used by TRACE_EVENTx macro. Do not use directly.
+class CefTraceEndOnScopeClose {
+ public:
+  CefTraceEndOnScopeClose(const char* category, const char* name)
+      : category_(category), name_(name) {
+  }
+  ~CefTraceEndOnScopeClose() {
+    cef_trace_event_end(category_, name_, NULL, 0, NULL, 0, false);
+  }
+
+ private:
+  const char* category_;
+  const char* name_;
+};
+
+}  // cef_trace_event
+
+#endif  // !BUILDING_CEF_SHARED
+
+#endif  // CEF_INCLUDE_BASE_CEF_TRACE_EVENT_H_
diff --git a/src/include/libcef_/base/cef_tuple.h b/src/include/libcef_/base/cef_tuple.h
new file mode 100644
index 0000000..ab71588
--- /dev/null
+++ b/src/include/libcef_/base/cef_tuple.h
@@ -0,0 +1,1407 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2011
+// Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// A Tuple is a generic templatized container, similar in concept to std::pair.
+// There are classes Tuple0 to Tuple6, cooresponding to the number of elements
+// it contains.  The convenient MakeTuple() function takes 0 to 6 arguments,
+// and will construct and return the appropriate Tuple object.  The functions
+// DispatchToMethod and DispatchToFunction take a function pointer or instance
+// and method pointer, and unpack a tuple into arguments to the call.
+//
+// Tuple elements are copied by value, and stored in the tuple.  See the unit
+// tests for more details of how/when the values are copied.
+//
+// Example usage:
+//   // These two methods of creating a Tuple are identical.
+//   Tuple2<int, const char*> tuple_a(1, "wee");
+//   Tuple2<int, const char*> tuple_b = MakeTuple(1, "wee");
+//
+//   void SomeFunc(int a, const char* b) { }
+//   DispatchToFunction(&SomeFunc, tuple_a);  // SomeFunc(1, "wee")
+//   DispatchToFunction(
+//       &SomeFunc, MakeTuple(10, "foo"));    // SomeFunc(10, "foo")
+//
+//   struct { void SomeMeth(int a, int b, int c) { } } foo;
+//   DispatchToMethod(&foo, &Foo::SomeMeth, MakeTuple(1, 2, 3));
+//   // foo->SomeMeth(1, 2, 3);
+
+#ifndef CEF_INCLUDE_BASE_CEF_TUPLE_H_
+#define CEF_INCLUDE_BASE_CEF_TUPLE_H_
+#pragma once
+
+#if defined(BASE_TUPLE_H_)
+// The Chromium header has already been included.
+// This can happen in cases where Chromium code is used directly by the
+// client application. When using Chromium code directly always include
+// the Chromium header first to avoid type conflicts.
+
+// For legacy compatibility, we name the first 8 tuple elements "a", "b", ...
+// TODO(cef): Remove this code when cef_runnable.h is deleted.
+
+namespace base {
+
+#define DEFINE_TUPLE_LEAF(N, x)                                        \
+  template <typename T>                                                \
+  struct TupleLeaf<N, T> {                                             \
+    TupleLeaf() {}                                                     \
+    explicit TupleLeaf(typename TupleTraits<T>::ParamType x) : x(x) {} \
+                                                                       \
+    T& get() { return x; }                                             \
+    const T& get() const { return x; }                                 \
+                                                                       \
+    T x;                                                               \
+  }
+
+DEFINE_TUPLE_LEAF(0, a);
+DEFINE_TUPLE_LEAF(1, b);
+DEFINE_TUPLE_LEAF(2, c);
+DEFINE_TUPLE_LEAF(3, d);
+DEFINE_TUPLE_LEAF(4, e);
+DEFINE_TUPLE_LEAF(5, f);
+DEFINE_TUPLE_LEAF(6, g);
+DEFINE_TUPLE_LEAF(7, h);
+
+#undef DEFINE_TUPLE_LEAF
+
+// Deprecated compat aliases
+// TODO(cef): Remove this code when cef_runnable.h is deleted.
+
+using Tuple0 = Tuple<>;
+template <typename A>
+using Tuple1 = Tuple<A>;
+template <typename A, typename B>
+using Tuple2 = Tuple<A, B>;
+template <typename A, typename B, typename C>
+using Tuple3 = Tuple<A, B, C>;
+template <typename A, typename B, typename C, typename D>
+using Tuple4 = Tuple<A, B, C, D>;
+template <typename A, typename B, typename C, typename D, typename E>
+using Tuple5 = Tuple<A, B, C, D, E>;
+template <typename A,
+          typename B,
+          typename C,
+          typename D,
+          typename E,
+          typename F>
+using Tuple6 = Tuple<A, B, C, D, E, F>;
+template <typename A,
+          typename B,
+          typename C,
+          typename D,
+          typename E,
+          typename F,
+          typename G>
+using Tuple7 = Tuple<A, B, C, D, E, F, G>;
+template <typename A,
+          typename B,
+          typename C,
+          typename D,
+          typename E,
+          typename F,
+          typename G,
+          typename H>
+using Tuple8 = Tuple<A, B, C, D, E, F, G, H>;
+
+}  // namespace base
+
+#elif defined(BUILDING_CEF_SHARED)
+// When building CEF include the Chromium header directly.
+#include "base/tuple.h"
+#else  // !BUILDING_CEF_SHARED
+// The following is substantially similar to the Chromium implementation.
+// If the Chromium implementation diverges the below implementation should be
+// updated to match.
+
+#include"libcef/base/cef_bind_helpers.h"
+
+namespace base {
+
+// Traits ----------------------------------------------------------------------
+//
+// A simple traits class for tuple arguments.
+//
+// ValueType: the bare, nonref version of a type (same as the type for nonrefs).
+// RefType: the ref version of a type (same as the type for refs).
+// ParamType: what type to pass to functions (refs should not be constified).
+
+template <class P>
+struct TupleTraits {
+  typedef P ValueType;
+  typedef P& RefType;
+  typedef const P& ParamType;
+};
+
+template <class P>
+struct TupleTraits<P&> {
+  typedef P ValueType;
+  typedef P& RefType;
+  typedef P& ParamType;
+};
+
+template <class P>
+struct TupleTypes { };
+
+// Tuple -----------------------------------------------------------------------
+//
+// This set of classes is useful for bundling 0 or more heterogeneous data types
+// into a single variable.  The advantage of this is that it greatly simplifies
+// function objects that need to take an arbitrary number of parameters; see
+// RunnableMethod and IPC::MessageWithTuple.
+//
+// Tuple0 is supplied to act as a 'void' type.  It can be used, for example,
+// when dispatching to a function that accepts no arguments (see the
+// Dispatchers below).
+// Tuple1<A> is rarely useful.  One such use is when A is non-const ref that you
+// want filled by the dispatchee, and the tuple is merely a container for that
+// output (a "tier").  See MakeRefTuple and its usages.
+
+struct Tuple0 {
+  typedef Tuple0 ValueTuple;
+  typedef Tuple0 RefTuple;
+  typedef Tuple0 ParamTuple;
+};
+
+template <class A>
+struct Tuple1 {
+ public:
+  typedef A TypeA;
+
+  Tuple1() {}
+  explicit Tuple1(typename TupleTraits<A>::ParamType a) : a(a) {}
+
+  A a;
+};
+
+template <class A, class B>
+struct Tuple2 {
+ public:
+  typedef A TypeA;
+  typedef B TypeB;
+
+  Tuple2() {}
+  Tuple2(typename TupleTraits<A>::ParamType a,
+         typename TupleTraits<B>::ParamType b)
+      : a(a), b(b) {
+  }
+
+  A a;
+  B b;
+};
+
+template <class A, class B, class C>
+struct Tuple3 {
+ public:
+  typedef A TypeA;
+  typedef B TypeB;
+  typedef C TypeC;
+
+  Tuple3() {}
+  Tuple3(typename TupleTraits<A>::ParamType a,
+         typename TupleTraits<B>::ParamType b,
+         typename TupleTraits<C>::ParamType c)
+      : a(a), b(b), c(c){
+  }
+
+  A a;
+  B b;
+  C c;
+};
+
+template <class A, class B, class C, class D>
+struct Tuple4 {
+ public:
+  typedef A TypeA;
+  typedef B TypeB;
+  typedef C TypeC;
+  typedef D TypeD;
+
+  Tuple4() {}
+  Tuple4(typename TupleTraits<A>::ParamType a,
+         typename TupleTraits<B>::ParamType b,
+         typename TupleTraits<C>::ParamType c,
+         typename TupleTraits<D>::ParamType d)
+      : a(a), b(b), c(c), d(d) {
+  }
+
+  A a;
+  B b;
+  C c;
+  D d;
+};
+
+template <class A, class B, class C, class D, class E>
+struct Tuple5 {
+ public:
+  typedef A TypeA;
+  typedef B TypeB;
+  typedef C TypeC;
+  typedef D TypeD;
+  typedef E TypeE;
+
+  Tuple5() {}
+  Tuple5(typename TupleTraits<A>::ParamType a,
+    typename TupleTraits<B>::ParamType b,
+    typename TupleTraits<C>::ParamType c,
+    typename TupleTraits<D>::ParamType d,
+    typename TupleTraits<E>::ParamType e)
+    : a(a), b(b), c(c), d(d), e(e) {
+  }
+
+  A a;
+  B b;
+  C c;
+  D d;
+  E e;
+};
+
+template <class A, class B, class C, class D, class E, class F>
+struct Tuple6 {
+ public:
+  typedef A TypeA;
+  typedef B TypeB;
+  typedef C TypeC;
+  typedef D TypeD;
+  typedef E TypeE;
+  typedef F TypeF;
+
+  Tuple6() {}
+  Tuple6(typename TupleTraits<A>::ParamType a,
+    typename TupleTraits<B>::ParamType b,
+    typename TupleTraits<C>::ParamType c,
+    typename TupleTraits<D>::ParamType d,
+    typename TupleTraits<E>::ParamType e,
+    typename TupleTraits<F>::ParamType f)
+    : a(a), b(b), c(c), d(d), e(e), f(f) {
+  }
+
+  A a;
+  B b;
+  C c;
+  D d;
+  E e;
+  F f;
+};
+
+template <class A, class B, class C, class D, class E, class F, class G>
+struct Tuple7 {
+ public:
+  typedef A TypeA;
+  typedef B TypeB;
+  typedef C TypeC;
+  typedef D TypeD;
+  typedef E TypeE;
+  typedef F TypeF;
+  typedef G TypeG;
+
+  Tuple7() {}
+  Tuple7(typename TupleTraits<A>::ParamType a,
+    typename TupleTraits<B>::ParamType b,
+    typename TupleTraits<C>::ParamType c,
+    typename TupleTraits<D>::ParamType d,
+    typename TupleTraits<E>::ParamType e,
+    typename TupleTraits<F>::ParamType f,
+    typename TupleTraits<G>::ParamType g)
+    : a(a), b(b), c(c), d(d), e(e), f(f), g(g) {
+  }
+
+  A a;
+  B b;
+  C c;
+  D d;
+  E e;
+  F f;
+  G g;
+};
+
+template <class A, class B, class C, class D, class E, class F, class G,
+          class H>
+struct Tuple8 {
+ public:
+  typedef A TypeA;
+  typedef B TypeB;
+  typedef C TypeC;
+  typedef D TypeD;
+  typedef E TypeE;
+  typedef F TypeF;
+  typedef G TypeG;
+  typedef H TypeH;
+
+  Tuple8() {}
+  Tuple8(typename TupleTraits<A>::ParamType a,
+    typename TupleTraits<B>::ParamType b,
+    typename TupleTraits<C>::ParamType c,
+    typename TupleTraits<D>::ParamType d,
+    typename TupleTraits<E>::ParamType e,
+    typename TupleTraits<F>::ParamType f,
+    typename TupleTraits<G>::ParamType g,
+    typename TupleTraits<H>::ParamType h)
+    : a(a), b(b), c(c), d(d), e(e), f(f), g(g), h(h) {
+  }
+
+  A a;
+  B b;
+  C c;
+  D d;
+  E e;
+  F f;
+  G g;
+  H h;
+};
+
+// Tuple types ----------------------------------------------------------------
+//
+// Allows for selection of ValueTuple/RefTuple/ParamTuple without needing the
+// definitions of class types the tuple takes as parameters.
+
+template <>
+struct TupleTypes< Tuple0 > {
+  typedef Tuple0 ValueTuple;
+  typedef Tuple0 RefTuple;
+  typedef Tuple0 ParamTuple;
+};
+
+template <class A>
+struct TupleTypes< Tuple1<A> > {
+  typedef Tuple1<typename TupleTraits<A>::ValueType> ValueTuple;
+  typedef Tuple1<typename TupleTraits<A>::RefType> RefTuple;
+  typedef Tuple1<typename TupleTraits<A>::ParamType> ParamTuple;
+};
+
+template <class A, class B>
+struct TupleTypes< Tuple2<A, B> > {
+  typedef Tuple2<typename TupleTraits<A>::ValueType,
+                 typename TupleTraits<B>::ValueType> ValueTuple;
+typedef Tuple2<typename TupleTraits<A>::RefType,
+               typename TupleTraits<B>::RefType> RefTuple;
+  typedef Tuple2<typename TupleTraits<A>::ParamType,
+                 typename TupleTraits<B>::ParamType> ParamTuple;
+};
+
+template <class A, class B, class C>
+struct TupleTypes< Tuple3<A, B, C> > {
+  typedef Tuple3<typename TupleTraits<A>::ValueType,
+                 typename TupleTraits<B>::ValueType,
+                 typename TupleTraits<C>::ValueType> ValueTuple;
+typedef Tuple3<typename TupleTraits<A>::RefType,
+               typename TupleTraits<B>::RefType,
+               typename TupleTraits<C>::RefType> RefTuple;
+  typedef Tuple3<typename TupleTraits<A>::ParamType,
+                 typename TupleTraits<B>::ParamType,
+                 typename TupleTraits<C>::ParamType> ParamTuple;
+};
+
+template <class A, class B, class C, class D>
+struct TupleTypes< Tuple4<A, B, C, D> > {
+  typedef Tuple4<typename TupleTraits<A>::ValueType,
+                 typename TupleTraits<B>::ValueType,
+                 typename TupleTraits<C>::ValueType,
+                 typename TupleTraits<D>::ValueType> ValueTuple;
+typedef Tuple4<typename TupleTraits<A>::RefType,
+               typename TupleTraits<B>::RefType,
+               typename TupleTraits<C>::RefType,
+               typename TupleTraits<D>::RefType> RefTuple;
+  typedef Tuple4<typename TupleTraits<A>::ParamType,
+                 typename TupleTraits<B>::ParamType,
+                 typename TupleTraits<C>::ParamType,
+                 typename TupleTraits<D>::ParamType> ParamTuple;
+};
+
+template <class A, class B, class C, class D, class E>
+struct TupleTypes< Tuple5<A, B, C, D, E> > {
+  typedef Tuple5<typename TupleTraits<A>::ValueType,
+                 typename TupleTraits<B>::ValueType,
+                 typename TupleTraits<C>::ValueType,
+                 typename TupleTraits<D>::ValueType,
+                 typename TupleTraits<E>::ValueType> ValueTuple;
+typedef Tuple5<typename TupleTraits<A>::RefType,
+               typename TupleTraits<B>::RefType,
+               typename TupleTraits<C>::RefType,
+               typename TupleTraits<D>::RefType,
+               typename TupleTraits<E>::RefType> RefTuple;
+  typedef Tuple5<typename TupleTraits<A>::ParamType,
+                 typename TupleTraits<B>::ParamType,
+                 typename TupleTraits<C>::ParamType,
+                 typename TupleTraits<D>::ParamType,
+                 typename TupleTraits<E>::ParamType> ParamTuple;
+};
+
+template <class A, class B, class C, class D, class E, class F>
+struct TupleTypes< Tuple6<A, B, C, D, E, F> > {
+  typedef Tuple6<typename TupleTraits<A>::ValueType,
+                 typename TupleTraits<B>::ValueType,
+                 typename TupleTraits<C>::ValueType,
+                 typename TupleTraits<D>::ValueType,
+                 typename TupleTraits<E>::ValueType,
+                 typename TupleTraits<F>::ValueType> ValueTuple;
+typedef Tuple6<typename TupleTraits<A>::RefType,
+               typename TupleTraits<B>::RefType,
+               typename TupleTraits<C>::RefType,
+               typename TupleTraits<D>::RefType,
+               typename TupleTraits<E>::RefType,
+               typename TupleTraits<F>::RefType> RefTuple;
+  typedef Tuple6<typename TupleTraits<A>::ParamType,
+                 typename TupleTraits<B>::ParamType,
+                 typename TupleTraits<C>::ParamType,
+                 typename TupleTraits<D>::ParamType,
+                 typename TupleTraits<E>::ParamType,
+                 typename TupleTraits<F>::ParamType> ParamTuple;
+};
+
+template <class A, class B, class C, class D, class E, class F, class G>
+struct TupleTypes< Tuple7<A, B, C, D, E, F, G> > {
+  typedef Tuple7<typename TupleTraits<A>::ValueType,
+                 typename TupleTraits<B>::ValueType,
+                 typename TupleTraits<C>::ValueType,
+                 typename TupleTraits<D>::ValueType,
+                 typename TupleTraits<E>::ValueType,
+                 typename TupleTraits<F>::ValueType,
+                 typename TupleTraits<G>::ValueType> ValueTuple;
+typedef Tuple7<typename TupleTraits<A>::RefType,
+               typename TupleTraits<B>::RefType,
+               typename TupleTraits<C>::RefType,
+               typename TupleTraits<D>::RefType,
+               typename TupleTraits<E>::RefType,
+               typename TupleTraits<F>::RefType,
+               typename TupleTraits<G>::RefType> RefTuple;
+  typedef Tuple7<typename TupleTraits<A>::ParamType,
+                 typename TupleTraits<B>::ParamType,
+                 typename TupleTraits<C>::ParamType,
+                 typename TupleTraits<D>::ParamType,
+                 typename TupleTraits<E>::ParamType,
+                 typename TupleTraits<F>::ParamType,
+                 typename TupleTraits<G>::ParamType> ParamTuple;
+};
+
+template <class A, class B, class C, class D, class E, class F, class G,
+          class H>
+struct TupleTypes< Tuple8<A, B, C, D, E, F, G, H> > {
+  typedef Tuple8<typename TupleTraits<A>::ValueType,
+                 typename TupleTraits<B>::ValueType,
+                 typename TupleTraits<C>::ValueType,
+                 typename TupleTraits<D>::ValueType,
+                 typename TupleTraits<E>::ValueType,
+                 typename TupleTraits<F>::ValueType,
+                 typename TupleTraits<G>::ValueType,
+                 typename TupleTraits<H>::ValueType> ValueTuple;
+typedef Tuple8<typename TupleTraits<A>::RefType,
+               typename TupleTraits<B>::RefType,
+               typename TupleTraits<C>::RefType,
+               typename TupleTraits<D>::RefType,
+               typename TupleTraits<E>::RefType,
+               typename TupleTraits<F>::RefType,
+               typename TupleTraits<G>::RefType,
+               typename TupleTraits<H>::RefType> RefTuple;
+  typedef Tuple8<typename TupleTraits<A>::ParamType,
+                 typename TupleTraits<B>::ParamType,
+                 typename TupleTraits<C>::ParamType,
+                 typename TupleTraits<D>::ParamType,
+                 typename TupleTraits<E>::ParamType,
+                 typename TupleTraits<F>::ParamType,
+                 typename TupleTraits<G>::ParamType,
+                 typename TupleTraits<H>::ParamType> ParamTuple;
+};
+
+// Tuple creators -------------------------------------------------------------
+//
+// Helper functions for constructing tuples while inferring the template
+// argument types.
+
+inline Tuple0 MakeTuple() {
+  return Tuple0();
+}
+
+template <class A>
+inline Tuple1<A> MakeTuple(const A& a) {
+  return Tuple1<A>(a);
+}
+
+template <class A, class B>
+inline Tuple2<A, B> MakeTuple(const A& a, const B& b) {
+  return Tuple2<A, B>(a, b);
+}
+
+template <class A, class B, class C>
+inline Tuple3<A, B, C> MakeTuple(const A& a, const B& b, const C& c) {
+  return Tuple3<A, B, C>(a, b, c);
+}
+
+template <class A, class B, class C, class D>
+inline Tuple4<A, B, C, D> MakeTuple(const A& a, const B& b, const C& c,
+                                    const D& d) {
+  return Tuple4<A, B, C, D>(a, b, c, d);
+}
+
+template <class A, class B, class C, class D, class E>
+inline Tuple5<A, B, C, D, E> MakeTuple(const A& a, const B& b, const C& c,
+                                       const D& d, const E& e) {
+  return Tuple5<A, B, C, D, E>(a, b, c, d, e);
+}
+
+template <class A, class B, class C, class D, class E, class F>
+inline Tuple6<A, B, C, D, E, F> MakeTuple(const A& a, const B& b, const C& c,
+                                          const D& d, const E& e, const F& f) {
+  return Tuple6<A, B, C, D, E, F>(a, b, c, d, e, f);
+}
+
+template <class A, class B, class C, class D, class E, class F, class G>
+inline Tuple7<A, B, C, D, E, F, G> MakeTuple(const A& a, const B& b, const C& c,
+                                             const D& d, const E& e, const F& f,
+                                             const G& g) {
+  return Tuple7<A, B, C, D, E, F, G>(a, b, c, d, e, f, g);
+}
+
+template <class A, class B, class C, class D, class E, class F, class G,
+          class H>
+inline Tuple8<A, B, C, D, E, F, G, H> MakeTuple(const A& a, const B& b,
+                                                const C& c, const D& d,
+                                                const E& e, const F& f,
+                                                const G& g, const H& h) {
+  return Tuple8<A, B, C, D, E, F, G, H>(a, b, c, d, e, f, g, h);
+}
+
+// The following set of helpers make what Boost refers to as "Tiers" - a tuple
+// of references.
+
+template <class A>
+inline Tuple1<A&> MakeRefTuple(A& a) {
+  return Tuple1<A&>(a);
+}
+
+template <class A, class B>
+inline Tuple2<A&, B&> MakeRefTuple(A& a, B& b) {
+  return Tuple2<A&, B&>(a, b);
+}
+
+template <class A, class B, class C>
+inline Tuple3<A&, B&, C&> MakeRefTuple(A& a, B& b, C& c) {
+  return Tuple3<A&, B&, C&>(a, b, c);
+}
+
+template <class A, class B, class C, class D>
+inline Tuple4<A&, B&, C&, D&> MakeRefTuple(A& a, B& b, C& c, D& d) {
+  return Tuple4<A&, B&, C&, D&>(a, b, c, d);
+}
+
+template <class A, class B, class C, class D, class E>
+inline Tuple5<A&, B&, C&, D&, E&> MakeRefTuple(A& a, B& b, C& c, D& d, E& e) {
+  return Tuple5<A&, B&, C&, D&, E&>(a, b, c, d, e);
+}
+
+template <class A, class B, class C, class D, class E, class F>
+inline Tuple6<A&, B&, C&, D&, E&, F&> MakeRefTuple(A& a, B& b, C& c, D& d, E& e,
+                                                   F& f) {
+  return Tuple6<A&, B&, C&, D&, E&, F&>(a, b, c, d, e, f);
+}
+
+template <class A, class B, class C, class D, class E, class F, class G>
+inline Tuple7<A&, B&, C&, D&, E&, F&, G&> MakeRefTuple(A& a, B& b, C& c, D& d,
+                                                       E& e, F& f, G& g) {
+  return Tuple7<A&, B&, C&, D&, E&, F&, G&>(a, b, c, d, e, f, g);
+}
+
+template <class A, class B, class C, class D, class E, class F, class G,
+          class H>
+inline Tuple8<A&, B&, C&, D&, E&, F&, G&, H&> MakeRefTuple(A& a, B& b, C& c,
+                                                           D& d, E& e, F& f,
+                                                           G& g, H& h) {
+  return Tuple8<A&, B&, C&, D&, E&, F&, G&, H&>(a, b, c, d, e, f, g, h);
+}
+
+// Dispatchers ----------------------------------------------------------------
+//
+// Helper functions that call the given method on an object, with the unpacked
+// tuple arguments.  Notice that they all have the same number of arguments,
+// so you need only write:
+//   DispatchToMethod(object, &Object::method, args);
+// This is very useful for templated dispatchers, since they don't need to know
+// what type |args| is.
+
+// Non-Static Dispatchers with no out params.
+
+template <class ObjT, class Method>
+inline void DispatchToMethod(ObjT* obj, Method method, const Tuple0& arg) {
+  (obj->*method)();
+}
+
+template <class ObjT, class Method, class A>
+inline void DispatchToMethod(ObjT* obj, Method method, const A& arg) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg));
+}
+
+template <class ObjT, class Method, class A>
+inline void DispatchToMethod(ObjT* obj, Method method, const Tuple1<A>& arg) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a));
+}
+
+template<class ObjT, class Method, class A, class B>
+inline void DispatchToMethod(ObjT* obj,
+                             Method method,
+                             const Tuple2<A, B>& arg) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
+                 base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b));
+}
+
+template<class ObjT, class Method, class A, class B, class C>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple3<A, B, C>& arg) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
+                 base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b),
+                 base::cef_internal::UnwrapTraits<C>::Unwrap(arg.c));
+}
+
+template<class ObjT, class Method, class A, class B, class C, class D>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple4<A, B, C, D>& arg) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
+                 base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b),
+                 base::cef_internal::UnwrapTraits<C>::Unwrap(arg.c),
+                 base::cef_internal::UnwrapTraits<D>::Unwrap(arg.d));
+}
+
+template<class ObjT, class Method, class A, class B, class C, class D, class E>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple5<A, B, C, D, E>& arg) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
+                 base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b),
+                 base::cef_internal::UnwrapTraits<C>::Unwrap(arg.c),
+                 base::cef_internal::UnwrapTraits<D>::Unwrap(arg.d),
+                 base::cef_internal::UnwrapTraits<E>::Unwrap(arg.e));
+}
+
+template<class ObjT, class Method, class A, class B, class C, class D, class E,
+         class F>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple6<A, B, C, D, E, F>& arg) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
+                 base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b),
+                 base::cef_internal::UnwrapTraits<C>::Unwrap(arg.c),
+                 base::cef_internal::UnwrapTraits<D>::Unwrap(arg.d),
+                 base::cef_internal::UnwrapTraits<E>::Unwrap(arg.e),
+                 base::cef_internal::UnwrapTraits<F>::Unwrap(arg.f));
+}
+
+template<class ObjT, class Method, class A, class B, class C, class D, class E,
+         class F, class G>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple7<A, B, C, D, E, F, G>& arg) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
+                 base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b),
+                 base::cef_internal::UnwrapTraits<C>::Unwrap(arg.c),
+                 base::cef_internal::UnwrapTraits<D>::Unwrap(arg.d),
+                 base::cef_internal::UnwrapTraits<E>::Unwrap(arg.e),
+                 base::cef_internal::UnwrapTraits<F>::Unwrap(arg.f),
+                 base::cef_internal::UnwrapTraits<G>::Unwrap(arg.g));
+}
+
+template<class ObjT, class Method, class A, class B, class C, class D, class E,
+         class F, class G, class H>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple8<A, B, C, D, E, F, G, H>& arg) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
+                 base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b),
+                 base::cef_internal::UnwrapTraits<C>::Unwrap(arg.c),
+                 base::cef_internal::UnwrapTraits<D>::Unwrap(arg.d),
+                 base::cef_internal::UnwrapTraits<E>::Unwrap(arg.e),
+                 base::cef_internal::UnwrapTraits<F>::Unwrap(arg.f),
+                 base::cef_internal::UnwrapTraits<G>::Unwrap(arg.g),
+                 base::cef_internal::UnwrapTraits<H>::Unwrap(arg.h));
+}
+
+// Static Dispatchers with no out params.
+
+template <class Function>
+inline void DispatchToFunction(Function function, const Tuple0& arg) {
+  (*function)();
+}
+
+template <class Function, class A>
+inline void DispatchToFunction(Function function, const A& arg) {
+  (*function)(arg);
+}
+
+template <class Function, class A>
+inline void DispatchToFunction(Function function, const Tuple1<A>& arg) {
+  (*function)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a));
+}
+
+template<class Function, class A, class B>
+inline void DispatchToFunction(Function function, const Tuple2<A, B>& arg) {
+  (*function)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
+              base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b));
+}
+
+template<class Function, class A, class B, class C>
+inline void DispatchToFunction(Function function, const Tuple3<A, B, C>& arg) {
+  (*function)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
+              base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b),
+              base::cef_internal::UnwrapTraits<C>::Unwrap(arg.c));
+}
+
+template<class Function, class A, class B, class C, class D>
+inline void DispatchToFunction(Function function,
+                               const Tuple4<A, B, C, D>& arg) {
+  (*function)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
+              base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b),
+              base::cef_internal::UnwrapTraits<C>::Unwrap(arg.c),
+              base::cef_internal::UnwrapTraits<D>::Unwrap(arg.d));
+}
+
+template<class Function, class A, class B, class C, class D, class E>
+inline void DispatchToFunction(Function function,
+                               const Tuple5<A, B, C, D, E>& arg) {
+  (*function)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
+              base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b),
+              base::cef_internal::UnwrapTraits<C>::Unwrap(arg.c),
+              base::cef_internal::UnwrapTraits<D>::Unwrap(arg.d),
+              base::cef_internal::UnwrapTraits<E>::Unwrap(arg.e));
+}
+
+template<class Function, class A, class B, class C, class D, class E, class F>
+inline void DispatchToFunction(Function function,
+                               const Tuple6<A, B, C, D, E, F>& arg) {
+  (*function)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
+              base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b),
+              base::cef_internal::UnwrapTraits<C>::Unwrap(arg.c),
+              base::cef_internal::UnwrapTraits<D>::Unwrap(arg.d),
+              base::cef_internal::UnwrapTraits<E>::Unwrap(arg.e),
+              base::cef_internal::UnwrapTraits<F>::Unwrap(arg.f));
+}
+
+template<class Function, class A, class B, class C, class D, class E, class F,
+         class G>
+inline void DispatchToFunction(Function function,
+                               const Tuple7<A, B, C, D, E, F, G>& arg) {
+  (*function)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
+              base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b),
+              base::cef_internal::UnwrapTraits<C>::Unwrap(arg.c),
+              base::cef_internal::UnwrapTraits<D>::Unwrap(arg.d),
+              base::cef_internal::UnwrapTraits<E>::Unwrap(arg.e),
+              base::cef_internal::UnwrapTraits<F>::Unwrap(arg.f),
+              base::cef_internal::UnwrapTraits<G>::Unwrap(arg.g));
+}
+
+template<class Function, class A, class B, class C, class D, class E, class F,
+         class G, class H>
+inline void DispatchToFunction(Function function,
+                               const Tuple8<A, B, C, D, E, F, G, H>& arg) {
+  (*function)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
+              base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b),
+              base::cef_internal::UnwrapTraits<C>::Unwrap(arg.c),
+              base::cef_internal::UnwrapTraits<D>::Unwrap(arg.d),
+              base::cef_internal::UnwrapTraits<E>::Unwrap(arg.e),
+              base::cef_internal::UnwrapTraits<F>::Unwrap(arg.f),
+              base::cef_internal::UnwrapTraits<G>::Unwrap(arg.g),
+              base::cef_internal::UnwrapTraits<H>::Unwrap(arg.h));
+}
+
+// Dispatchers with 0 out param (as a Tuple0).
+
+template <class ObjT, class Method>
+inline void DispatchToMethod(ObjT* obj,
+                             Method method,
+                             const Tuple0& arg, Tuple0*) {
+  (obj->*method)();
+}
+
+template <class ObjT, class Method, class A>
+inline void DispatchToMethod(ObjT* obj, Method method, const A& arg, Tuple0*) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg));
+}
+
+template <class ObjT, class Method, class A>
+inline void DispatchToMethod(ObjT* obj,
+                             Method method,
+                             const Tuple1<A>& arg, Tuple0*) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a));
+}
+
+template<class ObjT, class Method, class A, class B>
+inline void DispatchToMethod(ObjT* obj,
+                             Method method,
+                             const Tuple2<A, B>& arg, Tuple0*) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
+                 base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b));
+}
+
+template<class ObjT, class Method, class A, class B, class C>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple3<A, B, C>& arg, Tuple0*) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
+                 base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b),
+                 base::cef_internal::UnwrapTraits<C>::Unwrap(arg.c));
+}
+
+template<class ObjT, class Method, class A, class B, class C, class D>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple4<A, B, C, D>& arg, Tuple0*) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
+                 base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b),
+                 base::cef_internal::UnwrapTraits<C>::Unwrap(arg.c),
+                 base::cef_internal::UnwrapTraits<D>::Unwrap(arg.d));
+}
+
+template<class ObjT, class Method, class A, class B, class C, class D, class E>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple5<A, B, C, D, E>& arg, Tuple0*) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
+                 base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b),
+                 base::cef_internal::UnwrapTraits<C>::Unwrap(arg.c),
+                 base::cef_internal::UnwrapTraits<D>::Unwrap(arg.d),
+                 base::cef_internal::UnwrapTraits<E>::Unwrap(arg.e));
+}
+
+template<class ObjT, class Method, class A, class B, class C, class D, class E,
+         class F>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple6<A, B, C, D, E, F>& arg, Tuple0*) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
+                 base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b),
+                 base::cef_internal::UnwrapTraits<C>::Unwrap(arg.c),
+                 base::cef_internal::UnwrapTraits<D>::Unwrap(arg.d),
+                 base::cef_internal::UnwrapTraits<E>::Unwrap(arg.e),
+                 base::cef_internal::UnwrapTraits<F>::Unwrap(arg.f));
+}
+
+// Dispatchers with 1 out param.
+
+template<class ObjT, class Method,
+         class OutA>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple0& in,
+                             Tuple1<OutA>* out) {
+  (obj->*method)(&out->a);
+}
+
+template<class ObjT, class Method, class InA,
+         class OutA>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const InA& in,
+                             Tuple1<OutA>* out) {
+  (obj->*method)(in, &out->a);
+}
+
+template<class ObjT, class Method, class InA,
+         class OutA>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple1<InA>& in,
+                             Tuple1<OutA>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a), &out->a);
+}
+
+template<class ObjT, class Method, class InA, class InB,
+         class OutA>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple2<InA, InB>& in,
+                             Tuple1<OutA>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
+                 base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
+                 &out->a);
+}
+
+template<class ObjT, class Method, class InA, class InB, class InC,
+         class OutA>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple3<InA, InB, InC>& in,
+                             Tuple1<OutA>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
+                 base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
+                 base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
+                 &out->a);
+}
+
+template<class ObjT, class Method, class InA, class InB, class InC, class InD,
+         class OutA>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple4<InA, InB, InC, InD>& in,
+                             Tuple1<OutA>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
+                 base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
+                 base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
+                 base::cef_internal::UnwrapTraits<InD>::Unwrap(in.d),
+                 &out->a);
+}
+
+template<class ObjT, class Method, class InA, class InB, class InC, class InD,
+         class InE, class OutA>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple5<InA, InB, InC, InD, InE>& in,
+                             Tuple1<OutA>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
+                 base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
+                 base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
+                 base::cef_internal::UnwrapTraits<InD>::Unwrap(in.d),
+                 base::cef_internal::UnwrapTraits<InE>::Unwrap(in.e),
+                 &out->a);
+}
+
+template<class ObjT, class Method,
+         class InA, class InB, class InC, class InD, class InE, class InF,
+         class OutA>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple6<InA, InB, InC, InD, InE, InF>& in,
+                             Tuple1<OutA>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
+                 base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
+                 base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
+                 base::cef_internal::UnwrapTraits<InD>::Unwrap(in.d),
+                 base::cef_internal::UnwrapTraits<InE>::Unwrap(in.e),
+                 base::cef_internal::UnwrapTraits<InF>::Unwrap(in.f),
+                 &out->a);
+}
+
+// Dispatchers with 2 out params.
+
+template<class ObjT, class Method,
+         class OutA, class OutB>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple0& in,
+                             Tuple2<OutA, OutB>* out) {
+  (obj->*method)(&out->a, &out->b);
+}
+
+template<class ObjT, class Method, class InA,
+         class OutA, class OutB>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const InA& in,
+                             Tuple2<OutA, OutB>* out) {
+  (obj->*method)(in, &out->a, &out->b);
+}
+
+template<class ObjT, class Method, class InA,
+         class OutA, class OutB>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple1<InA>& in,
+                             Tuple2<OutA, OutB>* out) {
+  (obj->*method)(
+      base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a), &out->a, &out->b);
+}
+
+template<class ObjT, class Method, class InA, class InB,
+         class OutA, class OutB>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple2<InA, InB>& in,
+                             Tuple2<OutA, OutB>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
+                 base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
+                 &out->a,
+                 &out->b);
+}
+
+template<class ObjT, class Method, class InA, class InB, class InC,
+         class OutA, class OutB>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple3<InA, InB, InC>& in,
+                             Tuple2<OutA, OutB>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
+                 base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
+                 base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
+                 &out->a,
+                 &out->b);
+}
+
+template<class ObjT, class Method, class InA, class InB, class InC, class InD,
+         class OutA, class OutB>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple4<InA, InB, InC, InD>& in,
+                             Tuple2<OutA, OutB>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
+                 base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
+                 base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
+                 base::cef_internal::UnwrapTraits<InD>::Unwrap(in.d),
+                 &out->a,
+                 &out->b);
+}
+
+template<class ObjT, class Method,
+         class InA, class InB, class InC, class InD, class InE,
+         class OutA, class OutB>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple5<InA, InB, InC, InD, InE>& in,
+                             Tuple2<OutA, OutB>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
+                 base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
+                 base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
+                 base::cef_internal::UnwrapTraits<InD>::Unwrap(in.d),
+                 base::cef_internal::UnwrapTraits<InE>::Unwrap(in.e),
+                 &out->a,
+                 &out->b);
+}
+
+template<class ObjT, class Method,
+         class InA, class InB, class InC, class InD, class InE, class InF,
+         class OutA, class OutB>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple6<InA, InB, InC, InD, InE, InF>& in,
+                             Tuple2<OutA, OutB>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
+                 base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
+                 base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
+                 base::cef_internal::UnwrapTraits<InD>::Unwrap(in.d),
+                 base::cef_internal::UnwrapTraits<InE>::Unwrap(in.e),
+                 base::cef_internal::UnwrapTraits<InF>::Unwrap(in.f),
+                 &out->a,
+                 &out->b);
+}
+
+// Dispatchers with 3 out params.
+
+template<class ObjT, class Method,
+         class OutA, class OutB, class OutC>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple0& in,
+                             Tuple3<OutA, OutB, OutC>* out) {
+  (obj->*method)(&out->a, &out->b, &out->c);
+}
+
+template<class ObjT, class Method, class InA,
+         class OutA, class OutB, class OutC>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const InA& in,
+                             Tuple3<OutA, OutB, OutC>* out) {
+  (obj->*method)(in, &out->a, &out->b, &out->c);
+}
+
+template<class ObjT, class Method, class InA,
+         class OutA, class OutB, class OutC>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple1<InA>& in,
+                             Tuple3<OutA, OutB, OutC>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
+                 &out->a,
+                 &out->b,
+                 &out->c);
+}
+
+template<class ObjT, class Method, class InA, class InB,
+         class OutA, class OutB, class OutC>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple2<InA, InB>& in,
+                             Tuple3<OutA, OutB, OutC>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
+                 base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
+                 &out->a,
+                 &out->b,
+                 &out->c);
+}
+
+template<class ObjT, class Method, class InA, class InB, class InC,
+         class OutA, class OutB, class OutC>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple3<InA, InB, InC>& in,
+                             Tuple3<OutA, OutB, OutC>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
+                 base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
+                 base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
+                 &out->a,
+                 &out->b,
+                 &out->c);
+}
+
+template<class ObjT, class Method, class InA, class InB, class InC, class InD,
+         class OutA, class OutB, class OutC>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple4<InA, InB, InC, InD>& in,
+                             Tuple3<OutA, OutB, OutC>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
+                 base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
+                 base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
+                 base::cef_internal::UnwrapTraits<InD>::Unwrap(in.d),
+                 &out->a,
+                 &out->b,
+                 &out->c);
+}
+
+template<class ObjT, class Method,
+         class InA, class InB, class InC, class InD, class InE,
+         class OutA, class OutB, class OutC>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple5<InA, InB, InC, InD, InE>& in,
+                             Tuple3<OutA, OutB, OutC>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
+                 base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
+                 base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
+                 base::cef_internal::UnwrapTraits<InD>::Unwrap(in.d),
+                 base::cef_internal::UnwrapTraits<InE>::Unwrap(in.e),
+                 &out->a,
+                 &out->b,
+                 &out->c);
+}
+
+template<class ObjT, class Method,
+         class InA, class InB, class InC, class InD, class InE, class InF,
+         class OutA, class OutB, class OutC>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple6<InA, InB, InC, InD, InE, InF>& in,
+                             Tuple3<OutA, OutB, OutC>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
+                 base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
+                 base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
+                 base::cef_internal::UnwrapTraits<InD>::Unwrap(in.d),
+                 base::cef_internal::UnwrapTraits<InE>::Unwrap(in.e),
+                 base::cef_internal::UnwrapTraits<InF>::Unwrap(in.f),
+                 &out->a,
+                 &out->b,
+                 &out->c);
+}
+
+// Dispatchers with 4 out params.
+
+template<class ObjT, class Method,
+         class OutA, class OutB, class OutC, class OutD>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple0& in,
+                             Tuple4<OutA, OutB, OutC, OutD>* out) {
+  (obj->*method)(&out->a, &out->b, &out->c, &out->d);
+}
+
+template<class ObjT, class Method, class InA,
+         class OutA, class OutB, class OutC, class OutD>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const InA& in,
+                             Tuple4<OutA, OutB, OutC, OutD>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in),
+                 &out->a,
+                 &out->b,
+                 &out->c,
+                 &out->d);
+}
+
+template<class ObjT, class Method, class InA,
+         class OutA, class OutB, class OutC, class OutD>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple1<InA>& in,
+                             Tuple4<OutA, OutB, OutC, OutD>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
+                 &out->a,
+                 &out->b,
+                 &out->c,
+                 &out->d);
+}
+
+template<class ObjT, class Method, class InA, class InB,
+         class OutA, class OutB, class OutC, class OutD>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple2<InA, InB>& in,
+                             Tuple4<OutA, OutB, OutC, OutD>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
+                 base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
+                 &out->a,
+                 &out->b,
+                 &out->c,
+                 &out->d);
+}
+
+template<class ObjT, class Method, class InA, class InB, class InC,
+         class OutA, class OutB, class OutC, class OutD>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple3<InA, InB, InC>& in,
+                             Tuple4<OutA, OutB, OutC, OutD>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
+                 base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
+                 base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
+                 &out->a,
+                 &out->b,
+                 &out->c,
+                 &out->d);
+}
+
+template<class ObjT, class Method, class InA, class InB, class InC, class InD,
+         class OutA, class OutB, class OutC, class OutD>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple4<InA, InB, InC, InD>& in,
+                             Tuple4<OutA, OutB, OutC, OutD>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
+                 base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
+                 base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
+                 base::cef_internal::UnwrapTraits<InD>::Unwrap(in.d),
+                 &out->a,
+                 &out->b,
+                 &out->c,
+                 &out->d);
+}
+
+template<class ObjT, class Method,
+         class InA, class InB, class InC, class InD, class InE,
+         class OutA, class OutB, class OutC, class OutD>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple5<InA, InB, InC, InD, InE>& in,
+                             Tuple4<OutA, OutB, OutC, OutD>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
+                 base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
+                 base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
+                 base::cef_internal::UnwrapTraits<InD>::Unwrap(in.d),
+                 base::cef_internal::UnwrapTraits<InE>::Unwrap(in.e),
+                 &out->a,
+                 &out->b,
+                 &out->c,
+                 &out->d);
+}
+
+template<class ObjT, class Method,
+         class InA, class InB, class InC, class InD, class InE, class InF,
+         class OutA, class OutB, class OutC, class OutD>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple6<InA, InB, InC, InD, InE, InF>& in,
+                             Tuple4<OutA, OutB, OutC, OutD>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
+                 base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
+                 base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
+                 base::cef_internal::UnwrapTraits<InD>::Unwrap(in.d),
+                 base::cef_internal::UnwrapTraits<InE>::Unwrap(in.e),
+                 base::cef_internal::UnwrapTraits<InF>::Unwrap(in.f),
+                 &out->a,
+                 &out->b,
+                 &out->c,
+                 &out->d);
+}
+
+// Dispatchers with 5 out params.
+
+template<class ObjT, class Method,
+         class OutA, class OutB, class OutC, class OutD, class OutE>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple0& in,
+                             Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
+  (obj->*method)(&out->a, &out->b, &out->c, &out->d, &out->e);
+}
+
+template<class ObjT, class Method, class InA,
+         class OutA, class OutB, class OutC, class OutD, class OutE>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const InA& in,
+                             Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in),
+                 &out->a,
+                 &out->b,
+                 &out->c,
+                 &out->d,
+                 &out->e);
+}
+
+template<class ObjT, class Method, class InA,
+         class OutA, class OutB, class OutC, class OutD, class OutE>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple1<InA>& in,
+                             Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
+                 &out->a,
+                 &out->b,
+                 &out->c,
+                 &out->d,
+                 &out->e);
+}
+
+template<class ObjT, class Method, class InA, class InB,
+         class OutA, class OutB, class OutC, class OutD, class OutE>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple2<InA, InB>& in,
+                             Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
+                 base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
+                 &out->a,
+                 &out->b,
+                 &out->c,
+                 &out->d,
+                 &out->e);
+}
+
+template<class ObjT, class Method, class InA, class InB, class InC,
+         class OutA, class OutB, class OutC, class OutD, class OutE>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple3<InA, InB, InC>& in,
+                             Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
+                 base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
+                 base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
+                 &out->a,
+                 &out->b,
+                 &out->c,
+                 &out->d,
+                 &out->e);
+}
+
+template<class ObjT, class Method, class InA, class InB, class InC, class InD,
+         class OutA, class OutB, class OutC, class OutD, class OutE>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple4<InA, InB, InC, InD>& in,
+                             Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
+                 base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
+                 base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
+                 base::cef_internal::UnwrapTraits<InD>::Unwrap(in.d),
+                 &out->a,
+                 &out->b,
+                 &out->c,
+                 &out->d,
+                 &out->e);
+}
+
+template<class ObjT, class Method,
+         class InA, class InB, class InC, class InD, class InE,
+         class OutA, class OutB, class OutC, class OutD, class OutE>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple5<InA, InB, InC, InD, InE>& in,
+                             Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
+                 base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
+                 base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
+                 base::cef_internal::UnwrapTraits<InD>::Unwrap(in.d),
+                 base::cef_internal::UnwrapTraits<InE>::Unwrap(in.e),
+                 &out->a,
+                 &out->b,
+                 &out->c,
+                 &out->d,
+                 &out->e);
+}
+
+template<class ObjT, class Method,
+         class InA, class InB, class InC, class InD, class InE, class InF,
+         class OutA, class OutB, class OutC, class OutD, class OutE>
+inline void DispatchToMethod(ObjT* obj, Method method,
+                             const Tuple6<InA, InB, InC, InD, InE, InF>& in,
+                             Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
+  (obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
+                 base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
+                 base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
+                 base::cef_internal::UnwrapTraits<InD>::Unwrap(in.d),
+                 base::cef_internal::UnwrapTraits<InE>::Unwrap(in.e),
+                 base::cef_internal::UnwrapTraits<InF>::Unwrap(in.f),
+                 &out->a,
+                 &out->b,
+                 &out->c,
+                 &out->d,
+                 &out->e);
+}
+
+}  // namespace base
+
+#endif // !BUILDING_CEF_SHARED
+
+#endif  // CEF_INCLUDE_BASE_CEF_TUPLE_H_
diff --git a/src/include/libcef_/base/cef_weak_ptr.h b/src/include/libcef_/base/cef_weak_ptr.h
new file mode 100644
index 0000000..8638e34
--- /dev/null
+++ b/src/include/libcef_/base/cef_weak_ptr.h
@@ -0,0 +1,388 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2012
+// Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Weak pointers are pointers to an object that do not affect its lifetime,
+// and which may be invalidated (i.e. reset to NULL) by the object, or its
+// owner, at any time, most commonly when the object is about to be deleted.
+
+// Weak pointers are useful when an object needs to be accessed safely by one
+// or more objects other than its owner, and those callers can cope with the
+// object vanishing and e.g. tasks posted to it being silently dropped.
+// Reference-counting such an object would complicate the ownership graph and
+// make it harder to reason about the object's lifetime.
+
+// EXAMPLE:
+//
+//  class Controller {
+//   public:
+//    Controller() : weak_factory_(this) {}
+//    void SpawnWorker() { Worker::StartNew(weak_factory_.GetWeakPtr()); }
+//    void WorkComplete(const Result& result) { ... }
+//   private:
+//    // Member variables should appear before the WeakPtrFactory, to ensure
+//    // that any WeakPtrs to Controller are invalidated before its members
+//    // variable's destructors are executed, rendering them invalid.
+//    WeakPtrFactory<Controller> weak_factory_;
+//  };
+//
+//  class Worker {
+//   public:
+//    static void StartNew(const WeakPtr<Controller>& controller) {
+//      Worker* worker = new Worker(controller);
+//      // Kick off asynchronous processing...
+//    }
+//   private:
+//    Worker(const WeakPtr<Controller>& controller)
+//        : controller_(controller) {}
+//    void DidCompleteAsynchronousProcessing(const Result& result) {
+//      if (controller_)
+//        controller_->WorkComplete(result);
+//    }
+//    WeakPtr<Controller> controller_;
+//  };
+//
+// With this implementation a caller may use SpawnWorker() to dispatch multiple
+// Workers and subsequently delete the Controller, without waiting for all
+// Workers to have completed.
+
+// ------------------------- IMPORTANT: Thread-safety -------------------------
+
+// Weak pointers may be passed safely between threads, but must always be
+// dereferenced and invalidated on the same thread otherwise checking the
+// pointer would be racey.
+//
+// To ensure correct use, the first time a WeakPtr issued by a WeakPtrFactory
+// is dereferenced, the factory and its WeakPtrs become bound to the calling
+// thread, and cannot be dereferenced or invalidated on any other thread. Bound
+// WeakPtrs can still be handed off to other threads, e.g. to use to post tasks
+// back to object on the bound thread.
+//
+// If all WeakPtr objects are destroyed or invalidated then the factory is
+// unbound from the SequencedTaskRunner/Thread. The WeakPtrFactory may then be
+// destroyed, or new WeakPtr objects may be used, from a different sequence.
+//
+// Thus, at least one WeakPtr object must exist and have been dereferenced on
+// the correct thread to enforce that other WeakPtr objects will enforce they
+// are used on the desired thread.
+
+#ifndef CEF_INCLUDE_BASE_CEF_WEAK_PTR_H_
+#define CEF_INCLUDE_BASE_CEF_WEAK_PTR_H_
+#pragma once
+
+#if defined(BASE_MEMORY_WEAK_PTR_H_)
+// Do nothing if the Chromium header has already been included.
+// This can happen in cases where Chromium code is used directly by the
+// client application. When using Chromium code directly always include
+// the Chromium header first to avoid type conflicts.
+#elif defined(BUILDING_CEF_SHARED)
+// When building CEF include the Chromium header directly.
+#include"base/memory/weak_ptr.h"
+#else  // !BUILDING_CEF_SHARED
+// The following is substantially similar to the Chromium implementation.
+// If the Chromium implementation diverges the below implementation should be
+// updated to match.
+
+#include"libcef/base/cef_basictypes.h"
+#include"libcef/base/cef_logging.h"
+#include"libcef/base/cef_ref_counted.h"
+#include"libcef/base/cef_template_util.h"
+#include"libcef/base/cef_thread_checker.h"
+
+namespace base {
+
+template <typename T> class SupportsWeakPtr;
+template <typename T> class WeakPtr;
+
+namespace cef_internal {
+// These classes are part of the WeakPtr implementation.
+// DO NOT USE THESE CLASSES DIRECTLY YOURSELF.
+
+class WeakReference {
+ public:
+  // Although Flag is bound to a specific thread, it may be deleted from another
+  // via base::WeakPtr::~WeakPtr().
+  class Flag : public RefCountedThreadSafe<Flag> {
+   public:
+    Flag();
+
+    void Invalidate();
+    bool IsValid() const;
+
+   private:
+    friend class base::RefCountedThreadSafe<Flag>;
+
+    ~Flag();
+
+    // The current Chromium implementation uses SequenceChecker instead of
+    // ThreadChecker to support SequencedWorkerPools. CEF does not yet expose
+    // the concept of SequencedWorkerPools.
+    ThreadChecker thread_checker_;
+    bool is_valid_;
+  };
+
+  WeakReference();
+  explicit WeakReference(const Flag* flag);
+  ~WeakReference();
+
+  bool is_valid() const;
+
+ private:
+  scoped_refptr<const Flag> flag_;
+};
+
+class WeakReferenceOwner {
+ public:
+  WeakReferenceOwner();
+  ~WeakReferenceOwner();
+
+  WeakReference GetRef() const;
+
+  bool HasRefs() const {
+    return flag_.get() && !flag_->HasOneRef();
+  }
+
+  void Invalidate();
+
+ private:
+  mutable scoped_refptr<WeakReference::Flag> flag_;
+};
+
+// This class simplifies the implementation of WeakPtr's type conversion
+// constructor by avoiding the need for a public accessor for ref_.  A
+// WeakPtr<T> cannot access the private members of WeakPtr<U>, so this
+// base class gives us a way to access ref_ in a protected fashion.
+class WeakPtrBase {
+ public:
+  WeakPtrBase();
+  ~WeakPtrBase();
+
+ protected:
+  explicit WeakPtrBase(const WeakReference& ref);
+
+  WeakReference ref_;
+};
+
+// This class provides a common implementation of common functions that would
+// otherwise get instantiated separately for each distinct instantiation of
+// SupportsWeakPtr<>.
+class SupportsWeakPtrBase {
+ public:
+  // A safe static downcast of a WeakPtr<Base> to WeakPtr<Derived>. This
+  // conversion will only compile if there is exists a Base which inherits
+  // from SupportsWeakPtr<Base>. See base::AsWeakPtr() below for a helper
+  // function that makes calling this easier.
+  template<typename Derived>
+  static WeakPtr<Derived> StaticAsWeakPtr(Derived* t) {
+    typedef
+        is_convertible<Derived, cef_internal::SupportsWeakPtrBase&> convertible;
+    COMPILE_ASSERT(convertible::value,
+                   AsWeakPtr_argument_inherits_from_SupportsWeakPtr);
+    return AsWeakPtrImpl<Derived>(t, *t);
+  }
+
+ private:
+  // This template function uses type inference to find a Base of Derived
+  // which is an instance of SupportsWeakPtr<Base>. We can then safely
+  // static_cast the Base* to a Derived*.
+  template <typename Derived, typename Base>
+  static WeakPtr<Derived> AsWeakPtrImpl(
+      Derived* t, const SupportsWeakPtr<Base>&) {
+    WeakPtr<Base> ptr = t->Base::AsWeakPtr();
+    return WeakPtr<Derived>(ptr.ref_, static_cast<Derived*>(ptr.ptr_));
+  }
+};
+
+}  // namespace cef_internal
+
+template <typename T> class WeakPtrFactory;
+
+// The WeakPtr class holds a weak reference to |T*|.
+//
+// This class is designed to be used like a normal pointer.  You should always
+// null-test an object of this class before using it or invoking a method that
+// may result in the underlying object being destroyed.
+//
+// EXAMPLE:
+//
+//   class Foo { ... };
+//   WeakPtr<Foo> foo;
+//   if (foo)
+//     foo->method();
+//
+template <typename T>
+class WeakPtr : public cef_internal::WeakPtrBase {
+ public:
+  WeakPtr() : ptr_(NULL) {
+  }
+
+  // Allow conversion from U to T provided U "is a" T. Note that this
+  // is separate from the (implicit) copy constructor.
+  template <typename U>
+  WeakPtr(const WeakPtr<U>& other) : WeakPtrBase(other), ptr_(other.ptr_) {
+  }
+
+  T* get() const { return ref_.is_valid() ? ptr_ : NULL; }
+
+  T& operator*() const {
+    DCHECK(get() != NULL);
+    return *get();
+  }
+  T* operator->() const {
+    DCHECK(get() != NULL);
+    return get();
+  }
+
+  // Allow WeakPtr<element_type> to be used in boolean expressions, but not
+  // implicitly convertible to a real bool (which is dangerous).
+  //
+  // Note that this trick is only safe when the == and != operators
+  // are declared explicitly, as otherwise "weak_ptr1 == weak_ptr2"
+  // will compile but do the wrong thing (i.e., convert to Testable
+  // and then do the comparison).
+ private:
+  typedef T* WeakPtr::*Testable;
+
+ public:
+  operator Testable() const { return get() ? &WeakPtr::ptr_ : NULL; }
+
+  void reset() {
+    ref_ = cef_internal::WeakReference();
+    ptr_ = NULL;
+  }
+
+ private:
+  // Explicitly declare comparison operators as required by the bool
+  // trick, but keep them private.
+  template <class U> bool operator==(WeakPtr<U> const&) const;
+  template <class U> bool operator!=(WeakPtr<U> const&) const;
+
+  friend class cef_internal::SupportsWeakPtrBase;
+  template <typename U> friend class WeakPtr;
+  friend class SupportsWeakPtr<T>;
+  friend class WeakPtrFactory<T>;
+
+  WeakPtr(const cef_internal::WeakReference& ref, T* ptr)
+      : WeakPtrBase(ref),
+        ptr_(ptr) {
+  }
+
+  // This pointer is only valid when ref_.is_valid() is true.  Otherwise, its
+  // value is undefined (as opposed to NULL).
+  T* ptr_;
+};
+
+// A class may be composed of a WeakPtrFactory and thereby
+// control how it exposes weak pointers to itself.  This is helpful if you only
+// need weak pointers within the implementation of a class.  This class is also
+// useful when working with primitive types.  For example, you could have a
+// WeakPtrFactory<bool> that is used to pass around a weak reference to a bool.
+template <class T>
+class WeakPtrFactory {
+ public:
+  explicit WeakPtrFactory(T* ptr) : ptr_(ptr) {
+  }
+
+  ~WeakPtrFactory() {
+    ptr_ = NULL;
+  }
+
+  WeakPtr<T> GetWeakPtr() {
+    DCHECK(ptr_);
+    return WeakPtr<T>(weak_reference_owner_.GetRef(), ptr_);
+  }
+
+  // Call this method to invalidate all existing weak pointers.
+  void InvalidateWeakPtrs() {
+    DCHECK(ptr_);
+    weak_reference_owner_.Invalidate();
+  }
+
+  // Call this method to determine if any weak pointers exist.
+  bool HasWeakPtrs() const {
+    DCHECK(ptr_);
+    return weak_reference_owner_.HasRefs();
+  }
+
+ private:
+  cef_internal::WeakReferenceOwner weak_reference_owner_;
+  T* ptr_;
+  DISALLOW_IMPLICIT_CONSTRUCTORS(WeakPtrFactory);
+};
+
+// A class may extend from SupportsWeakPtr to let others take weak pointers to
+// it. This avoids the class itself implementing boilerplate to dispense weak
+// pointers.  However, since SupportsWeakPtr's destructor won't invalidate
+// weak pointers to the class until after the derived class' members have been
+// destroyed, its use can lead to subtle use-after-destroy issues.
+template <class T>
+class SupportsWeakPtr : public cef_internal::SupportsWeakPtrBase {
+ public:
+  SupportsWeakPtr() {}
+
+  WeakPtr<T> AsWeakPtr() {
+    return WeakPtr<T>(weak_reference_owner_.GetRef(), static_cast<T*>(this));
+  }
+
+ protected:
+  ~SupportsWeakPtr() {}
+
+ private:
+  cef_internal::WeakReferenceOwner weak_reference_owner_;
+  DISALLOW_COPY_AND_ASSIGN(SupportsWeakPtr);
+};
+
+// Helper function that uses type deduction to safely return a WeakPtr<Derived>
+// when Derived doesn't directly extend SupportsWeakPtr<Derived>, instead it
+// extends a Base that extends SupportsWeakPtr<Base>.
+//
+// EXAMPLE:
+//   class Base : public base::SupportsWeakPtr<Producer> {};
+//   class Derived : public Base {};
+//
+//   Derived derived;
+//   base::WeakPtr<Derived> ptr = base::AsWeakPtr(&derived);
+//
+// Note that the following doesn't work (invalid type conversion) since
+// Derived::AsWeakPtr() is WeakPtr<Base> SupportsWeakPtr<Base>::AsWeakPtr(),
+// and there's no way to safely cast WeakPtr<Base> to WeakPtr<Derived> at
+// the caller.
+//
+//   base::WeakPtr<Derived> ptr = derived.AsWeakPtr();  // Fails.
+
+template <typename Derived>
+WeakPtr<Derived> AsWeakPtr(Derived* t) {
+  return cef_internal::SupportsWeakPtrBase::StaticAsWeakPtr<Derived>(t);
+}
+
+}  // namespace base
+
+#endif  // !BUILDING_CEF_SHARED
+
+#endif  // CEF_INCLUDE_BASE_CEF_WEAK_PTR_H_
diff --git a/src/include/libcef_/base/internal/cef_atomicops_x86_msvc.h b/src/include/libcef_/base/internal/cef_atomicops_x86_msvc.h
new file mode 100644
index 0000000..dd27441
--- /dev/null
+++ b/src/include/libcef_/base/internal/cef_atomicops_x86_msvc.h
@@ -0,0 +1,251 @@
+// Copyright (c) 2008 Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Do not include this header file directly. Use base/cef_atomicops.h
+// instead.
+
+#ifndef CEF_INCLUDE_BASE_INTERNAL_CEF_ATOMICOPS_X86_MSVC_H_
+#define CEF_INCLUDE_BASE_INTERNAL_CEF_ATOMICOPS_X86_MSVC_H_
+
+#include <windows.h>
+
+#include <intrin.h>
+
+#include"libcef/base/cef_macros.h"
+
+#if defined(ARCH_CPU_64_BITS)
+    // windows.h #defines this (only on x64). This causes problems because the
+    // public API also uses MemoryBarrier at the public name for this fence. So, on
+    // X64, undef it, and call its documented
+    // (http://msdn.microsoft.com/en-us/library/windows/desktop/ms684208.aspx)
+    // implementation directly.
+    #undef MemoryBarrier
+#endif
+
+namespace base 
+{
+    namespace subtle 
+    {
+
+        inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr,
+                                                 Atomic32 old_value,
+                                                 Atomic32 new_value) 
+        {
+          LONG result = _InterlockedCompareExchange(
+              reinterpret_cast<volatile LONG*>(ptr),
+              static_cast<LONG>(new_value),
+              static_cast<LONG>(old_value));
+          return static_cast<Atomic32>(result);
+        }
+
+        inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr,
+                                                 Atomic32 new_value) 
+        {
+          LONG result = _InterlockedExchange(
+              reinterpret_cast<volatile LONG*>(ptr),
+              static_cast<LONG>(new_value));
+          return static_cast<Atomic32>(result);
+        }
+
+        inline Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr,
+                                                Atomic32 increment) 
+        {
+          return _InterlockedExchangeAdd(
+              reinterpret_cast<volatile LONG*>(ptr),
+              static_cast<LONG>(increment)) + increment;
+        }
+
+        inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr,
+                                                  Atomic32 increment) 
+        {
+          return Barrier_AtomicIncrement(ptr, increment);
+        }
+
+        #if !(defined(_MSC_VER) && _MSC_VER >= 1400)
+        #error "We require at least vs2005 for MemoryBarrier"
+        #endif
+        inline void MemoryBarrier() 
+        {
+        #if defined(ARCH_CPU_64_BITS)
+          // See #undef and note at the top of this file.
+          __faststorefence();
+        #else
+          // We use MemoryBarrier from WinNT.h
+          ::MemoryBarrier();
+        #endif
+        }
+
+        inline Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr,
+                                               Atomic32 old_value,
+                                               Atomic32 new_value) 
+        {
+          return NoBarrier_CompareAndSwap(ptr, old_value, new_value);
+        }
+
+        inline Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr,
+                                               Atomic32 old_value,
+                                               Atomic32 new_value) 
+        {
+          return NoBarrier_CompareAndSwap(ptr, old_value, new_value);
+        }
+
+        inline void NoBarrier_Store(volatile Atomic32* ptr, Atomic32 value) 
+        {
+          *ptr = value;
+        }
+
+        inline void Acquire_Store(volatile Atomic32* ptr, Atomic32 value) 
+        {
+          NoBarrier_AtomicExchange(ptr, value);
+                      // acts as a barrier in this implementation
+        }
+
+        inline void Release_Store(volatile Atomic32* ptr, Atomic32 value) 
+        {
+          *ptr = value; // works w/o barrier for current Intel chips as of June 2005
+          // See comments in Atomic64 version of Release_Store() below.
+        }
+
+        inline Atomic32 NoBarrier_Load(volatile const Atomic32* ptr) 
+        {
+          return *ptr;
+        }
+
+        inline Atomic32 Acquire_Load(volatile const Atomic32* ptr) 
+        {
+          Atomic32 value = *ptr;
+          return value;
+        }
+
+        inline Atomic32 Release_Load(volatile const Atomic32* ptr) 
+        {
+          MemoryBarrier();
+          return *ptr;
+        }
+
+        #if defined(_WIN64)
+
+        // 64-bit low-level operations on 64-bit platform.
+
+        COMPILE_ASSERT(sizeof(Atomic64) == sizeof(PVOID), atomic_word_is_atomic);
+
+        inline Atomic64 NoBarrier_CompareAndSwap(volatile Atomic64* ptr,
+                                                 Atomic64 old_value,
+                                                 Atomic64 new_value) 
+        {
+          PVOID result = InterlockedCompareExchangePointer(
+            reinterpret_cast<volatile PVOID*>(ptr),
+            reinterpret_cast<PVOID>(new_value), reinterpret_cast<PVOID>(old_value));
+          return reinterpret_cast<Atomic64>(result);
+        }
+
+        inline Atomic64 NoBarrier_AtomicExchange(volatile Atomic64* ptr,
+                                                 Atomic64 new_value) 
+        {
+          PVOID result = InterlockedExchangePointer(
+            reinterpret_cast<volatile PVOID*>(ptr),
+            reinterpret_cast<PVOID>(new_value));
+          return reinterpret_cast<Atomic64>(result);
+        }
+
+        inline Atomic64 Barrier_AtomicIncrement(volatile Atomic64* ptr,
+                                                Atomic64 increment) 
+        {
+          return InterlockedExchangeAdd64(
+              reinterpret_cast<volatile LONGLONG*>(ptr),
+              static_cast<LONGLONG>(increment)) + increment;
+        }
+
+        inline Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64* ptr,
+                                                  Atomic64 increment) 
+        {
+          return Barrier_AtomicIncrement(ptr, increment);
+        }
+
+        inline void NoBarrier_Store(volatile Atomic64* ptr, Atomic64 value) 
+        {
+          *ptr = value;
+        }
+
+        inline void Acquire_Store(volatile Atomic64* ptr, Atomic64 value) 
+        {
+          NoBarrier_AtomicExchange(ptr, value);
+                      // acts as a barrier in this implementation
+        }
+
+        inline void Release_Store(volatile Atomic64* ptr, Atomic64 value) 
+        {
+          *ptr = value; // works w/o barrier for current Intel chips as of June 2005
+
+          // When new chips come out, check:
+          //  IA-32 Intel Architecture Software Developer's Manual, Volume 3:
+          //  System Programming Guide, Chatper 7: Multiple-processor management,
+          //  Section 7.2, Memory Ordering.
+          // Last seen at:
+          //   http://developer.intel.com/design/pentium4/manuals/index_new.htm
+        }
+
+        inline Atomic64 NoBarrier_Load(volatile const Atomic64* ptr) 
+        {
+          return *ptr;
+        }
+
+        inline Atomic64 Acquire_Load(volatile const Atomic64* ptr)
+        {
+          Atomic64 value = *ptr;
+          return value;
+        }
+
+        inline Atomic64 Release_Load(volatile const Atomic64* ptr) 
+        {
+          MemoryBarrier();
+          return *ptr;
+        }
+
+        inline Atomic64 Acquire_CompareAndSwap(volatile Atomic64* ptr,
+                                               Atomic64 old_value,
+                                               Atomic64 new_value) 
+        {
+          return NoBarrier_CompareAndSwap(ptr, old_value, new_value);
+        }
+
+        inline Atomic64 Release_CompareAndSwap(volatile Atomic64* ptr,
+                                               Atomic64 old_value,
+                                               Atomic64 new_value) 
+        {
+          return NoBarrier_CompareAndSwap(ptr, old_value, new_value);
+        }
+
+
+        #endif  // defined(_WIN64)
+
+    }  // namespace base::subtle
+}  // namespace base
+
+#endif  // CEF_INCLUDE_BASE_INTERNAL_CEF_ATOMICOPS_X86_MSVC_H_
diff --git a/src/include/libcef_/base/internal/cef_atomicops_x86_watcom.h b/src/include/libcef_/base/internal/cef_atomicops_x86_watcom.h
new file mode 100644
index 0000000..3b875e5
--- /dev/null
+++ b/src/include/libcef_/base/internal/cef_atomicops_x86_watcom.h
@@ -0,0 +1,150 @@
+#ifndef CEF_INCLUDE_BASE_INTERNAL_CEF_ATOMICOPS_X86_WATCOM_H_
+#define CEF_INCLUDE_BASE_INTERNAL_CEF_ATOMICOPS_X86_WATCOM_H_
+
+#include <windows.h>
+
+#include <stdint.h>
+
+#include"libcef/base/cef_macros.h"
+
+namespace base 
+{
+	namespace subtle 
+	{
+
+		// NoBarrier_CompareAndSwap
+		// Atomic compare and swap for 32-bit integers.
+		// Returns old value at *ptr.
+		static Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr, Atomic32 old_value, Atomic32 new_value);
+		#pragma aux NoBarrier_CompareAndSwap = \
+		    "mov eax, [esp+4]"         /* old_value */ \
+		    "mov edx, [esp+8]"         /* ptr */ \
+		    "mov ecx, [esp+12]"        /* new_value */ \
+		    "lock cmpxchg [edx], ecx"  \
+		    parm caller [eax] [edx] [ecx]  \
+		    modify exact [eax edx ecx] \
+		    value [eax]
+
+
+
+		// NoBarrier_AtomicExchange
+		// Atomically sets *ptr = new_value and returns old value.
+		static Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr, Atomic32 new_value);
+		#pragma aux NoBarrier_AtomicExchange = \
+		    "xchg eax, [edx]" \
+		    parm caller [edx] [eax] \
+		    modify exact [eax] \
+		    value [eax]
+
+
+		// Barrier_AtomicIncrement
+		// Atomically adds increment to *ptr and returns new value.
+		static Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr, Atomic32 increment);
+		#pragma aux Barrier_AtomicIncrement = \
+		    "lock xadd [edx], eax" \
+		    "add eax, eax" \
+		    parm caller [edx] [eax] \
+		    modify exact [eax] \
+		    value [eax]
+
+		   
+
+		// NoBarrier_AtomicIncrement
+		// Same as Barrier_AtomicIncrement for x86.
+		static Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr, Atomic32 increment);
+		#pragma aux NoBarrier_AtomicIncrement = \
+		    "lock xadd [eax], edx" \
+		    "add edx, edx" \
+		    parm caller [eax] [edx] \
+		    modify exact [edx] \
+		    value [edx]
+
+		// MemoryBarrier
+		// Full memory fence using Windows API
+		static void MemoryBarrier(void);
+		#pragma aux MemoryBarrier = \
+		    "lock add dword ptr [esp], 0" \
+		    modify exact [eax]
+
+
+		inline Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr, Atomic32 old_value, Atomic32 new_value) 
+		{
+		    return NoBarrier_CompareAndSwap(ptr, old_value, new_value);
+		}
+
+		inline Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr, Atomic32 old_value, Atomic32 new_value) 
+		{
+		    return NoBarrier_CompareAndSwap(ptr, old_value, new_value);
+		}
+
+		// NoBarrier_Store
+		// Simple store without memory barrier
+		static void NoBarrier_Store(volatile Atomic32* ptr, Atomic32 value);
+		#pragma aux NoBarrier_Store = \
+		    "mov [eax], edx" \
+		    parm caller [eax] [edx] \
+		    modify exact []
+
+		// Acquire_Store
+		// Atomic exchange acts as a store with acquire semantics
+		static void Acquire_Store(volatile Atomic32* ptr, Atomic32 value);
+		#pragma aux Acquire_Store = \
+		    "xchg [eax], edx" \
+		    parm caller [eax] [edx] \
+		    modify exact [edx]
+
+		// Release_Store
+		// Simple store (no barrier)
+		static void Release_Store(volatile Atomic32* ptr, Atomic32 value);
+		#pragma aux Release_Store = \
+		    "mov [eax], edx" \
+		    parm caller [eax] [edx] \
+		    modify exact []
+
+
+		// NoBarrier_Load
+		// Simple load without barrier
+		static Atomic32 NoBarrier_Load(volatile const Atomic32* ptr);
+		#pragma aux NoBarrier_Load = \
+		    "mov eax, [esp+4]" \
+		    "mov eax, [eax]" \
+		    parm caller [] \
+		    modify exact [eax] \
+		    value [eax]
+
+
+		// Acquire_Load
+		// Load with acquire semantics (acts like simple load here)
+		static Atomic32 Acquire_Load(volatile const Atomic32* ptr);
+		#pragma aux Acquire_Load = \
+		    "mov eax, [esp+4]" \
+		    "mov eax, [eax]" \
+		    parm caller [] \
+		    modify exact [eax] \
+		    value [eax]
+
+
+		// Release_Load
+		// Load with memory barrier (uses mfence)
+		static Atomic32 Release_Load(volatile const Atomic32* ptr);
+		#pragma aux Release_Load = \
+		    "mfence" \
+		    "mov eax, [esp+4]" \
+		    "mov eax, [eax]" \
+		    parm caller [] \
+		    modify exact [eax] \
+		    value [eax]
+
+	}  /* namespace subtle */
+}  /* namespace base */
+
+
+
+
+
+
+
+
+
+
+#endif /* CEF_INCLUDE_BASE_INTERNAL_CEF_ATOMICOPS_X86_WATCOM_H_ */
diff --git a/src/include/libcef_/base/internal/cef_bind_internal.h b/src/include/libcef_/base/internal/cef_bind_internal.h
new file mode 100644
index 0000000..22b0280
--- /dev/null
+++ b/src/include/libcef_/base/internal/cef_bind_internal.h
@@ -0,0 +1,2852 @@
+// Copyright (c) 2011 Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Do not include this header file directly. Use base/cef_bind.h instead.
+
+#ifndef CEF_INCLUDE_BASE_INTERNAL_CEF_BIND_INTERNAL_H_
+#define CEF_INCLUDE_BASE_INTERNAL_CEF_BIND_INTERNAL_H_
+
+#include"libcef/base/cef_bind_helpers.h"
+#include"libcef/base/cef_build.h"
+#include"libcef/base/cef_template_util.h"
+#include"libcef/base/cef_weak_ptr.h"
+#include"libcef/base/internal/cef_callback_internal.h"
+#include"libcef/base/internal/cef_raw_scoped_refptr_mismatch_checker.h"
+
+#if defined(OS_WIN)
+  #include"libcef/base/internal/cef_bind_internal_win.h"
+#endif
+
+namespace base {
+namespace cef_internal {
+
+// See base/callback.h for user documentation.
+//
+//
+// CONCEPTS:
+//  Runnable -- A type (really a type class) that has a single Run() method
+//              and a RunType typedef that corresponds to the type of Run().
+//              A Runnable can declare that it should treated like a method
+//              call by including a typedef named IsMethod.  The value of
+//              this typedef is NOT inspected, only the existence.  When a
+//              Runnable declares itself a method, Bind() will enforce special
+//              refcounting + WeakPtr handling semantics for the first
+//              parameter which is expected to be an object.
+//  Functor -- A copyable type representing something that should be called.
+//             All function pointers, Callback<>, and Runnables are functors
+//             even if the invocation syntax differs.
+//  RunType -- A function type (as opposed to function _pointer_ type) for
+//             a Run() function.  Usually just a convenience typedef.
+//  (Bound)ArgsType -- A function type that is being (ab)used to store the
+//                     types of set of arguments.  The "return" type is always
+//                     void here.  We use this hack so that we do not need
+//                     a new type name for each arity of type. (eg.,
+//                     BindState1, BindState2).  This makes forward
+//                     declarations and friending much much easier.
+//
+// Types:
+//  RunnableAdapter<> -- Wraps the various "function" pointer types into an
+//                       object that adheres to the Runnable interface.
+//                       There are |3*ARITY| RunnableAdapter types.
+//  FunctionTraits<> -- Type traits that unwrap a function signature into a
+//                      a set of easier to use typedefs.  Used mainly for
+//                      compile time asserts.
+//                      There are |ARITY| FunctionTraits types.
+//  ForceVoidReturn<> -- Helper class for translating function signatures to
+//                       equivalent forms with a "void" return type.
+//                    There are |ARITY| ForceVoidReturn types.
+//  FunctorTraits<> -- Type traits used determine the correct RunType and
+//                     RunnableType for a Functor.  This is where function
+//                     signature adapters are applied.
+//                    There are |ARITY| ForceVoidReturn types.
+//  MakeRunnable<> -- Takes a Functor and returns an object in the Runnable
+//                    type class that represents the underlying Functor.
+//                    There are |O(1)| MakeRunnable types.
+//  InvokeHelper<> -- Take a Runnable + arguments and actully invokes it.
+// Handle the differing syntaxes needed for WeakPtr<> support,
+//                    and for ignoring return values.  This is separate from
+//                    Invoker to avoid creating multiple version of Invoker<>
+//                    which grows at O(n^2) with the arity.
+//                    There are |k*ARITY| InvokeHelper types.
+//  Invoker<> -- Unwraps the curried parameters and executes the Runnable.
+//               There are |(ARITY^2 + ARITY)/2| Invoketypes.
+//  BindState<> -- Stores the curried parameters, and is the main entry point
+//                 into the Bind() system, doing most of the type resolution.
+//                 There are ARITY BindState types.
+
+// RunnableAdapter<>
+//
+// The RunnableAdapter<> templates provide a uniform interface for invoking
+// a function pointer, method pointer, or const method pointer. The adapter
+// exposes a Run() method with an appropriate signature. Using this wrapper
+// allows for writing code that supports all three pointer types without
+// undue repetition.  Without it, a lot of code would need to be repeated 3
+// times.
+//
+// For method pointers and const method pointers the first argument to Run()
+// is considered to be the received of the method.  This is similar to STL's
+// mem_fun().
+//
+// This class also exposes a RunType typedef that is the function type of the
+// Run() function.
+//
+// If and only if the wrapper contains a method or const method pointer, an
+// IsMethod typedef is exposed.  The existence of this typedef (NOT the value)
+// marks that the wrapper should be considered a method wrapper.
+
+template <typename Functor>
+class RunnableAdapter;
+
+// Function: Arity 0.
+template <typename R>
+class RunnableAdapter<R(*)()> {
+ public:
+  typedef R (RunType)();
+
+  explicit RunnableAdapter(R(*function)())
+      : function_(function) {
+  }
+
+  R Run() {
+    return function_();
+  }
+
+ private:
+  R (*function_)();
+};
+
+// Method: Arity 0.
+template <typename R, typename T>
+class RunnableAdapter<R(T::*)()> {
+ public:
+  typedef R (RunType)(T*);
+  typedef true_type IsMethod;
+
+  explicit RunnableAdapter(R(T::*method)())
+      : method_(method) {
+  }
+
+  R Run(T* object) {
+    return (object->*method_)();
+  }
+
+ private:
+  R (T::*method_)();
+};
+
+// Const Method: Arity 0.
+template <typename R, typename T>
+class RunnableAdapter<R(T::*)() const> {
+ public:
+  typedef R (RunType)(const T*);
+  typedef true_type IsMethod;
+
+  explicit RunnableAdapter(R(T::*method)() const)
+      : method_(method) {
+  }
+
+  R Run(const T* object) {
+    return (object->*method_)();
+  }
+
+ private:
+  R (T::*method_)() const;
+};
+
+// Function: Arity 1.
+template <typename R, typename A1>
+class RunnableAdapter<R(*)(A1)> {
+ public:
+  typedef R (RunType)(A1);
+
+  explicit RunnableAdapter(R(*function)(A1))
+      : function_(function) {
+  }
+
+  R Run(typename CallbackParamTraits<A1>::ForwardType a1) {
+    return function_(CallbackForward(a1));
+  }
+
+ private:
+  R (*function_)(A1);
+};
+
+// Method: Arity 1.
+template <typename R, typename T, typename A1>
+class RunnableAdapter<R(T::*)(A1)> {
+ public:
+  typedef R (RunType)(T*, A1);
+  typedef true_type IsMethod;
+
+  explicit RunnableAdapter(R(T::*method)(A1))
+      : method_(method) {
+  }
+
+  R Run(T* object, typename CallbackParamTraits<A1>::ForwardType a1) {
+    return (object->*method_)(CallbackForward(a1));
+  }
+
+ private:
+  R (T::*method_)(A1);
+};
+
+// Const Method: Arity 1.
+template <typename R, typename T, typename A1>
+class RunnableAdapter<R(T::*)(A1) const> {
+ public:
+  typedef R (RunType)(const T*, A1);
+  typedef true_type IsMethod;
+
+  explicit RunnableAdapter(R(T::*method)(A1) const)
+      : method_(method) {
+  }
+
+  R Run(const T* object, typename CallbackParamTraits<A1>::ForwardType a1) {
+    return (object->*method_)(CallbackForward(a1));
+  }
+
+ private:
+  R (T::*method_)(A1) const;
+};
+
+// Function: Arity 2.
+template <typename R, typename A1, typename A2>
+class RunnableAdapter<R(*)(A1, A2)> {
+ public:
+  typedef R (RunType)(A1, A2);
+
+  explicit RunnableAdapter(R(*function)(A1, A2))
+      : function_(function) {
+  }
+
+  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2) {
+    return function_(CallbackForward(a1), CallbackForward(a2));
+  }
+
+ private:
+  R (*function_)(A1, A2);
+};
+
+// Method: Arity 2.
+template <typename R, typename T, typename A1, typename A2>
+class RunnableAdapter<R(T::*)(A1, A2)> {
+ public:
+  typedef R (RunType)(T*, A1, A2);
+  typedef true_type IsMethod;
+
+  explicit RunnableAdapter(R(T::*method)(A1, A2))
+      : method_(method) {
+  }
+
+  R Run(T* object, typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2) {
+    return (object->*method_)(CallbackForward(a1), CallbackForward(a2));
+  }
+
+ private:
+  R (T::*method_)(A1, A2);
+};
+
+// Const Method: Arity 2.
+template <typename R, typename T, typename A1, typename A2>
+class RunnableAdapter<R(T::*)(A1, A2) const> {
+ public:
+  typedef R (RunType)(const T*, A1, A2);
+  typedef true_type IsMethod;
+
+  explicit RunnableAdapter(R(T::*method)(A1, A2) const)
+      : method_(method) {
+  }
+
+  R Run(const T* object, typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2) {
+    return (object->*method_)(CallbackForward(a1), CallbackForward(a2));
+  }
+
+ private:
+  R (T::*method_)(A1, A2) const;
+};
+
+// Function: Arity 3.
+template <typename R, typename A1, typename A2, typename A3>
+class RunnableAdapter<R(*)(A1, A2, A3)> {
+ public:
+  typedef R (RunType)(A1, A2, A3);
+
+  explicit RunnableAdapter(R(*function)(A1, A2, A3))
+      : function_(function) {
+  }
+
+  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3) {
+    return function_(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3));
+  }
+
+ private:
+  R (*function_)(A1, A2, A3);
+};
+
+// Method: Arity 3.
+template <typename R, typename T, typename A1, typename A2, typename A3>
+class RunnableAdapter<R(T::*)(A1, A2, A3)> {
+ public:
+  typedef R (RunType)(T*, A1, A2, A3);
+  typedef true_type IsMethod;
+
+  explicit RunnableAdapter(R(T::*method)(A1, A2, A3))
+      : method_(method) {
+  }
+
+  R Run(T* object, typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3) {
+    return (object->*method_)(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3));
+  }
+
+ private:
+  R (T::*method_)(A1, A2, A3);
+};
+
+// Const Method: Arity 3.
+template <typename R, typename T, typename A1, typename A2, typename A3>
+class RunnableAdapter<R(T::*)(A1, A2, A3) const> {
+ public:
+  typedef R (RunType)(const T*, A1, A2, A3);
+  typedef true_type IsMethod;
+
+  explicit RunnableAdapter(R(T::*method)(A1, A2, A3) const)
+      : method_(method) {
+  }
+
+  R Run(const T* object, typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3) {
+    return (object->*method_)(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3));
+  }
+
+ private:
+  R (T::*method_)(A1, A2, A3) const;
+};
+
+// Function: Arity 4.
+template <typename R, typename A1, typename A2, typename A3, typename A4>
+class RunnableAdapter<R(*)(A1, A2, A3, A4)> {
+ public:
+  typedef R (RunType)(A1, A2, A3, A4);
+
+  explicit RunnableAdapter(R(*function)(A1, A2, A3, A4))
+      : function_(function) {
+  }
+
+  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3,
+      typename CallbackParamTraits<A4>::ForwardType a4) {
+    return function_(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3), CallbackForward(a4));
+  }
+
+ private:
+  R (*function_)(A1, A2, A3, A4);
+};
+
+// Method: Arity 4.
+template <typename R, typename T, typename A1, typename A2, typename A3,
+    typename A4>
+class RunnableAdapter<R(T::*)(A1, A2, A3, A4)> {
+ public:
+  typedef R (RunType)(T*, A1, A2, A3, A4);
+  typedef true_type IsMethod;
+
+  explicit RunnableAdapter(R(T::*method)(A1, A2, A3, A4))
+      : method_(method) {
+  }
+
+  R Run(T* object, typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3,
+      typename CallbackParamTraits<A4>::ForwardType a4) {
+    return (object->*method_)(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3), CallbackForward(a4));
+  }
+
+ private:
+  R (T::*method_)(A1, A2, A3, A4);
+};
+
+// Const Method: Arity 4.
+template <typename R, typename T, typename A1, typename A2, typename A3,
+    typename A4>
+class RunnableAdapter<R(T::*)(A1, A2, A3, A4) const> {
+ public:
+  typedef R (RunType)(const T*, A1, A2, A3, A4);
+  typedef true_type IsMethod;
+
+  explicit RunnableAdapter(R(T::*method)(A1, A2, A3, A4) const)
+      : method_(method) {
+  }
+
+  R Run(const T* object, typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3,
+      typename CallbackParamTraits<A4>::ForwardType a4) {
+    return (object->*method_)(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3), CallbackForward(a4));
+  }
+
+ private:
+  R (T::*method_)(A1, A2, A3, A4) const;
+};
+
+// Function: Arity 5.
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5>
+class RunnableAdapter<R(*)(A1, A2, A3, A4, A5)> {
+ public:
+  typedef R (RunType)(A1, A2, A3, A4, A5);
+
+  explicit RunnableAdapter(R(*function)(A1, A2, A3, A4, A5))
+      : function_(function) {
+  }
+
+  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3,
+      typename CallbackParamTraits<A4>::ForwardType a4,
+      typename CallbackParamTraits<A5>::ForwardType a5) {
+    return function_(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3), CallbackForward(a4), CallbackForward(a5));
+  }
+
+ private:
+  R (*function_)(A1, A2, A3, A4, A5);
+};
+
+// Method: Arity 5.
+template <typename R, typename T, typename A1, typename A2, typename A3,
+    typename A4, typename A5>
+class RunnableAdapter<R(T::*)(A1, A2, A3, A4, A5)> {
+ public:
+  typedef R (RunType)(T*, A1, A2, A3, A4, A5);
+  typedef true_type IsMethod;
+
+  explicit RunnableAdapter(R(T::*method)(A1, A2, A3, A4, A5))
+      : method_(method) {
+  }
+
+  R Run(T* object, typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3,
+      typename CallbackParamTraits<A4>::ForwardType a4,
+      typename CallbackParamTraits<A5>::ForwardType a5) {
+    return (object->*method_)(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3), CallbackForward(a4), CallbackForward(a5));
+  }
+
+ private:
+  R (T::*method_)(A1, A2, A3, A4, A5);
+};
+
+// Const Method: Arity 5.
+template <typename R, typename T, typename A1, typename A2, typename A3,
+    typename A4, typename A5>
+class RunnableAdapter<R(T::*)(A1, A2, A3, A4, A5) const> {
+ public:
+  typedef R (RunType)(const T*, A1, A2, A3, A4, A5);
+  typedef true_type IsMethod;
+
+  explicit RunnableAdapter(R(T::*method)(A1, A2, A3, A4, A5) const)
+      : method_(method) {
+  }
+
+  R Run(const T* object, typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3,
+      typename CallbackParamTraits<A4>::ForwardType a4,
+      typename CallbackParamTraits<A5>::ForwardType a5) {
+    return (object->*method_)(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3), CallbackForward(a4), CallbackForward(a5));
+  }
+
+ private:
+  R (T::*method_)(A1, A2, A3, A4, A5) const;
+};
+
+// Function: Arity 6.
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6>
+class RunnableAdapter<R(*)(A1, A2, A3, A4, A5, A6)> {
+ public:
+  typedef R (RunType)(A1, A2, A3, A4, A5, A6);
+
+  explicit RunnableAdapter(R(*function)(A1, A2, A3, A4, A5, A6))
+      : function_(function) {
+  }
+
+  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3,
+      typename CallbackParamTraits<A4>::ForwardType a4,
+      typename CallbackParamTraits<A5>::ForwardType a5,
+      typename CallbackParamTraits<A6>::ForwardType a6) {
+    return function_(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3), CallbackForward(a4), CallbackForward(a5),
+        CallbackForward(a6));
+  }
+
+ private:
+  R (*function_)(A1, A2, A3, A4, A5, A6);
+};
+
+// Method: Arity 6.
+template <typename R, typename T, typename A1, typename A2, typename A3,
+    typename A4, typename A5, typename A6>
+class RunnableAdapter<R(T::*)(A1, A2, A3, A4, A5, A6)> {
+ public:
+  typedef R (RunType)(T*, A1, A2, A3, A4, A5, A6);
+  typedef true_type IsMethod;
+
+  explicit RunnableAdapter(R(T::*method)(A1, A2, A3, A4, A5, A6))
+      : method_(method) {
+  }
+
+  R Run(T* object, typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3,
+      typename CallbackParamTraits<A4>::ForwardType a4,
+      typename CallbackParamTraits<A5>::ForwardType a5,
+      typename CallbackParamTraits<A6>::ForwardType a6) {
+    return (object->*method_)(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3), CallbackForward(a4), CallbackForward(a5),
+        CallbackForward(a6));
+  }
+
+ private:
+  R (T::*method_)(A1, A2, A3, A4, A5, A6);
+};
+
+// Const Method: Arity 6.
+template <typename R, typename T, typename A1, typename A2, typename A3,
+    typename A4, typename A5, typename A6>
+class RunnableAdapter<R(T::*)(A1, A2, A3, A4, A5, A6) const> {
+ public:
+  typedef R (RunType)(const T*, A1, A2, A3, A4, A5, A6);
+  typedef true_type IsMethod;
+
+  explicit RunnableAdapter(R(T::*method)(A1, A2, A3, A4, A5, A6) const)
+      : method_(method) {
+  }
+
+  R Run(const T* object, typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3,
+      typename CallbackParamTraits<A4>::ForwardType a4,
+      typename CallbackParamTraits<A5>::ForwardType a5,
+      typename CallbackParamTraits<A6>::ForwardType a6) {
+    return (object->*method_)(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3), CallbackForward(a4), CallbackForward(a5),
+        CallbackForward(a6));
+  }
+
+ private:
+  R (T::*method_)(A1, A2, A3, A4, A5, A6) const;
+};
+
+// Function: Arity 7.
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6, typename A7>
+class RunnableAdapter<R(*)(A1, A2, A3, A4, A5, A6, A7)> {
+ public:
+  typedef R (RunType)(A1, A2, A3, A4, A5, A6, A7);
+
+  explicit RunnableAdapter(R(*function)(A1, A2, A3, A4, A5, A6, A7))
+      : function_(function) {
+  }
+
+  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3,
+      typename CallbackParamTraits<A4>::ForwardType a4,
+      typename CallbackParamTraits<A5>::ForwardType a5,
+      typename CallbackParamTraits<A6>::ForwardType a6,
+      typename CallbackParamTraits<A7>::ForwardType a7) {
+    return function_(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3), CallbackForward(a4), CallbackForward(a5),
+        CallbackForward(a6), CallbackForward(a7));
+  }
+
+ private:
+  R (*function_)(A1, A2, A3, A4, A5, A6, A7);
+};
+
+// Method: Arity 7.
+template <typename R, typename T, typename A1, typename A2, typename A3,
+    typename A4, typename A5, typename A6, typename A7>
+class RunnableAdapter<R(T::*)(A1, A2, A3, A4, A5, A6, A7)> {
+ public:
+  typedef R (RunType)(T*, A1, A2, A3, A4, A5, A6, A7);
+  typedef true_type IsMethod;
+
+  explicit RunnableAdapter(R(T::*method)(A1, A2, A3, A4, A5, A6, A7))
+      : method_(method) {
+  }
+
+  R Run(T* object, typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3,
+      typename CallbackParamTraits<A4>::ForwardType a4,
+      typename CallbackParamTraits<A5>::ForwardType a5,
+      typename CallbackParamTraits<A6>::ForwardType a6,
+      typename CallbackParamTraits<A7>::ForwardType a7) {
+    return (object->*method_)(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3), CallbackForward(a4), CallbackForward(a5),
+        CallbackForward(a6), CallbackForward(a7));
+  }
+
+ private:
+  R (T::*method_)(A1, A2, A3, A4, A5, A6, A7);
+};
+
+// Const Method: Arity 7.
+template <typename R, typename T, typename A1, typename A2, typename A3,
+    typename A4, typename A5, typename A6, typename A7>
+class RunnableAdapter<R(T::*)(A1, A2, A3, A4, A5, A6, A7) const> {
+ public:
+  typedef R (RunType)(const T*, A1, A2, A3, A4, A5, A6, A7);
+  typedef true_type IsMethod;
+
+  explicit RunnableAdapter(R(T::*method)(A1, A2, A3, A4, A5, A6, A7) const)
+      : method_(method) {
+  }
+
+  R Run(const T* object, typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3,
+      typename CallbackParamTraits<A4>::ForwardType a4,
+      typename CallbackParamTraits<A5>::ForwardType a5,
+      typename CallbackParamTraits<A6>::ForwardType a6,
+      typename CallbackParamTraits<A7>::ForwardType a7) {
+    return (object->*method_)(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3), CallbackForward(a4), CallbackForward(a5),
+        CallbackForward(a6), CallbackForward(a7));
+  }
+
+ private:
+  R (T::*method_)(A1, A2, A3, A4, A5, A6, A7) const;
+};
+
+
+// FunctionTraits<>
+//
+// Breaks a function signature apart into typedefs for easier introspection.
+template <typename Sig>
+struct FunctionTraits;
+
+template <typename R>
+struct FunctionTraits<R()> {
+  typedef R ReturnType;
+};
+
+template <typename R, typename A1>
+struct FunctionTraits<R(A1)> {
+  typedef R ReturnType;
+  typedef A1 A1Type;
+};
+
+template <typename R, typename A1, typename A2>
+struct FunctionTraits<R(A1, A2)> {
+  typedef R ReturnType;
+  typedef A1 A1Type;
+  typedef A2 A2Type;
+};
+
+template <typename R, typename A1, typename A2, typename A3>
+struct FunctionTraits<R(A1, A2, A3)> {
+  typedef R ReturnType;
+  typedef A1 A1Type;
+  typedef A2 A2Type;
+  typedef A3 A3Type;
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4>
+struct FunctionTraits<R(A1, A2, A3, A4)> {
+  typedef R ReturnType;
+  typedef A1 A1Type;
+  typedef A2 A2Type;
+  typedef A3 A3Type;
+  typedef A4 A4Type;
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5>
+struct FunctionTraits<R(A1, A2, A3, A4, A5)> {
+  typedef R ReturnType;
+  typedef A1 A1Type;
+  typedef A2 A2Type;
+  typedef A3 A3Type;
+  typedef A4 A4Type;
+  typedef A5 A5Type;
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6>
+struct FunctionTraits<R(A1, A2, A3, A4, A5, A6)> {
+  typedef R ReturnType;
+  typedef A1 A1Type;
+  typedef A2 A2Type;
+  typedef A3 A3Type;
+  typedef A4 A4Type;
+  typedef A5 A5Type;
+  typedef A6 A6Type;
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6, typename A7>
+struct FunctionTraits<R(A1, A2, A3, A4, A5, A6, A7)> {
+  typedef R ReturnType;
+  typedef A1 A1Type;
+  typedef A2 A2Type;
+  typedef A3 A3Type;
+  typedef A4 A4Type;
+  typedef A5 A5Type;
+  typedef A6 A6Type;
+  typedef A7 A7Type;
+};
+
+
+// ForceVoidReturn<>
+//
+// Set of templates that support forcing the function return type to void.
+template <typename Sig>
+struct ForceVoidReturn;
+
+template <typename R>
+struct ForceVoidReturn<R()> {
+  typedef void(RunType)();
+};
+
+template <typename R, typename A1>
+struct ForceVoidReturn<R(A1)> {
+  typedef void(RunType)(A1);
+};
+
+template <typename R, typename A1, typename A2>
+struct ForceVoidReturn<R(A1, A2)> {
+  typedef void(RunType)(A1, A2);
+};
+
+template <typename R, typename A1, typename A2, typename A3>
+struct ForceVoidReturn<R(A1, A2, A3)> {
+  typedef void(RunType)(A1, A2, A3);
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4>
+struct ForceVoidReturn<R(A1, A2, A3, A4)> {
+  typedef void(RunType)(A1, A2, A3, A4);
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5>
+struct ForceVoidReturn<R(A1, A2, A3, A4, A5)> {
+  typedef void(RunType)(A1, A2, A3, A4, A5);
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6>
+struct ForceVoidReturn<R(A1, A2, A3, A4, A5, A6)> {
+  typedef void(RunType)(A1, A2, A3, A4, A5, A6);
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6, typename A7>
+struct ForceVoidReturn<R(A1, A2, A3, A4, A5, A6, A7)> {
+  typedef void(RunType)(A1, A2, A3, A4, A5, A6, A7);
+};
+
+
+// FunctorTraits<>
+//
+// See description at top of file.
+template <typename T>
+struct FunctorTraits {
+  typedef RunnableAdapter<T> RunnableType;
+  typedef typename RunnableType::RunType RunType;
+};
+
+template <typename T>
+struct FunctorTraits<IgnoreResultHelper<T> > {
+  typedef typename FunctorTraits<T>::RunnableType RunnableType;
+  typedef typename ForceVoidReturn<
+      typename RunnableType::RunType>::RunType RunType;
+};
+
+template <typename T>
+struct FunctorTraits<Callback<T> > {
+  typedef Callback<T> RunnableType;
+  typedef typename Callback<T>::RunType RunType;
+};
+
+
+// MakeRunnable<>
+//
+// Converts a passed in functor to a RunnableType using type inference.
+
+template <typename T>
+typename FunctorTraits<T>::RunnableType MakeRunnable(const T& t) {
+  return RunnableAdapter<T>(t);
+}
+
+template <typename T>
+typename FunctorTraits<T>::RunnableType
+MakeRunnable(const IgnoreResultHelper<T>& t) {
+  return MakeRunnable(t.functor_);
+}
+
+template <typename T>
+const typename FunctorTraits<Callback<T> >::RunnableType&
+MakeRunnable(const Callback<T>& t) {
+  DCHECK(!t.is_null());
+  return t;
+}
+
+
+// InvokeHelper<>
+//
+// There are 3 logical InvokeHelper<> specializations: normal, void-return,
+// WeakCalls.
+//
+// The normal type just calls the underlying runnable.
+//
+// We need a InvokeHelper to handle void return types in order to support
+// IgnoreResult().  Normally, if the Runnable's RunType had a void return,
+// the template system would just accept "return functor.Run()" ignoring
+// the fact that a void function is being used with return. This piece of
+// sugar breaks though when the Runnable's RunType is not void.  Thus, we
+// need a partial specialization to change the syntax to drop the "return"
+// from the invocation call.
+//
+// WeakCalls similarly need special syntax that is applied to the first
+// argument to check if they should no-op themselves.
+template <bool IsWeakCall, typename ReturnType, typename Runnable,
+          typename ArgsType>
+struct InvokeHelper;
+
+template <typename ReturnType, typename Runnable>
+struct InvokeHelper<false, ReturnType, Runnable,
+    void()>  {
+  static ReturnType MakeItSo(Runnable runnable) {
+    return runnable.Run();
+  }
+};
+
+template <typename Runnable>
+struct InvokeHelper<false, void, Runnable,
+    void()>  {
+  static void MakeItSo(Runnable runnable) {
+    runnable.Run();
+  }
+};
+
+template <typename ReturnType, typename Runnable,typename A1>
+struct InvokeHelper<false, ReturnType, Runnable,
+    void(A1)>  {
+  static ReturnType MakeItSo(Runnable runnable, A1 a1) {
+    return runnable.Run(CallbackForward(a1));
+  }
+};
+
+template <typename Runnable,typename A1>
+struct InvokeHelper<false, void, Runnable,
+    void(A1)>  {
+  static void MakeItSo(Runnable runnable, A1 a1) {
+    runnable.Run(CallbackForward(a1));
+  }
+};
+
+template <typename Runnable, typename BoundWeakPtr>
+struct InvokeHelper<true, void, Runnable,
+    void(BoundWeakPtr)>  {
+  static void MakeItSo(Runnable runnable, BoundWeakPtr weak_ptr) {
+    if (!weak_ptr.get()) {
+      return;
+    }
+    runnable.Run(weak_ptr.get());
+  }
+};
+
+template <typename ReturnType, typename Runnable,typename A1, typename A2>
+struct InvokeHelper<false, ReturnType, Runnable,
+    void(A1, A2)>  {
+  static ReturnType MakeItSo(Runnable runnable, A1 a1, A2 a2) {
+    return runnable.Run(CallbackForward(a1), CallbackForward(a2));
+  }
+};
+
+template <typename Runnable,typename A1, typename A2>
+struct InvokeHelper<false, void, Runnable,
+    void(A1, A2)>  {
+  static void MakeItSo(Runnable runnable, A1 a1, A2 a2) {
+    runnable.Run(CallbackForward(a1), CallbackForward(a2));
+  }
+};
+
+template <typename Runnable, typename BoundWeakPtr, typename A2>
+struct InvokeHelper<true, void, Runnable,
+    void(BoundWeakPtr, A2)>  {
+  static void MakeItSo(Runnable runnable, BoundWeakPtr weak_ptr, A2 a2) {
+    if (!weak_ptr.get()) {
+      return;
+    }
+    runnable.Run(weak_ptr.get(), CallbackForward(a2));
+  }
+};
+
+template <typename ReturnType, typename Runnable,typename A1, typename A2,
+    typename A3>
+struct InvokeHelper<false, ReturnType, Runnable,
+    void(A1, A2, A3)>  {
+  static ReturnType MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3) {
+    return runnable.Run(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3));
+  }
+};
+
+template <typename Runnable,typename A1, typename A2, typename A3>
+struct InvokeHelper<false, void, Runnable,
+    void(A1, A2, A3)>  {
+  static void MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3) {
+    runnable.Run(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3));
+  }
+};
+
+template <typename Runnable, typename BoundWeakPtr, typename A2, typename A3>
+struct InvokeHelper<true, void, Runnable,
+    void(BoundWeakPtr, A2, A3)>  {
+  static void MakeItSo(Runnable runnable, BoundWeakPtr weak_ptr, A2 a2, A3 a3) {
+    if (!weak_ptr.get()) {
+      return;
+    }
+    runnable.Run(weak_ptr.get(), CallbackForward(a2), CallbackForward(a3));
+  }
+};
+
+template <typename ReturnType, typename Runnable,typename A1, typename A2,
+    typename A3, typename A4>
+struct InvokeHelper<false, ReturnType, Runnable,
+    void(A1, A2, A3, A4)>  {
+  static ReturnType MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4) {
+    return runnable.Run(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3), CallbackForward(a4));
+  }
+};
+
+template <typename Runnable,typename A1, typename A2, typename A3, typename A4>
+struct InvokeHelper<false, void, Runnable,
+    void(A1, A2, A3, A4)>  {
+  static void MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4) {
+    runnable.Run(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3),
+        CallbackForward(a4));
+  }
+};
+
+template <typename Runnable, typename BoundWeakPtr, typename A2, typename A3,
+    typename A4>
+struct InvokeHelper<true, void, Runnable,
+    void(BoundWeakPtr, A2, A3, A4)>  {
+  static void MakeItSo(Runnable runnable, BoundWeakPtr weak_ptr, A2 a2, A3 a3,
+      A4 a4) {
+    if (!weak_ptr.get()) {
+      return;
+    }
+    runnable.Run(weak_ptr.get(), CallbackForward(a2), CallbackForward(a3),
+        CallbackForward(a4));
+  }
+};
+
+template <typename ReturnType, typename Runnable,typename A1, typename A2,
+    typename A3, typename A4, typename A5>
+struct InvokeHelper<false, ReturnType, Runnable,
+    void(A1, A2, A3, A4, A5)>  {
+  static ReturnType MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4,
+      A5 a5) {
+    return runnable.Run(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3), CallbackForward(a4), CallbackForward(a5));
+  }
+};
+
+template <typename Runnable,typename A1, typename A2, typename A3, typename A4,
+    typename A5>
+struct InvokeHelper<false, void, Runnable,
+    void(A1, A2, A3, A4, A5)>  {
+  static void MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
+    runnable.Run(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3),
+        CallbackForward(a4), CallbackForward(a5));
+  }
+};
+
+template <typename Runnable, typename BoundWeakPtr, typename A2, typename A3,
+    typename A4, typename A5>
+struct InvokeHelper<true, void, Runnable,
+    void(BoundWeakPtr, A2, A3, A4, A5)>  {
+  static void MakeItSo(Runnable runnable, BoundWeakPtr weak_ptr, A2 a2, A3 a3,
+      A4 a4, A5 a5) {
+    if (!weak_ptr.get()) {
+      return;
+    }
+    runnable.Run(weak_ptr.get(), CallbackForward(a2), CallbackForward(a3),
+        CallbackForward(a4), CallbackForward(a5));
+  }
+};
+
+template <typename ReturnType, typename Runnable,typename A1, typename A2,
+    typename A3, typename A4, typename A5, typename A6>
+struct InvokeHelper<false, ReturnType, Runnable,
+    void(A1, A2, A3, A4, A5, A6)>  {
+  static ReturnType MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4,
+      A5 a5, A6 a6) {
+    return runnable.Run(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3), CallbackForward(a4), CallbackForward(a5),
+        CallbackForward(a6));
+  }
+};
+
+template <typename Runnable,typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6>
+struct InvokeHelper<false, void, Runnable,
+    void(A1, A2, A3, A4, A5, A6)>  {
+  static void MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5,
+      A6 a6) {
+    runnable.Run(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3),
+        CallbackForward(a4), CallbackForward(a5), CallbackForward(a6));
+  }
+};
+
+template <typename Runnable, typename BoundWeakPtr, typename A2, typename A3,
+    typename A4, typename A5, typename A6>
+struct InvokeHelper<true, void, Runnable,
+    void(BoundWeakPtr, A2, A3, A4, A5, A6)>  {
+  static void MakeItSo(Runnable runnable, BoundWeakPtr weak_ptr, A2 a2, A3 a3,
+      A4 a4, A5 a5, A6 a6) {
+    if (!weak_ptr.get()) {
+      return;
+    }
+    runnable.Run(weak_ptr.get(), CallbackForward(a2), CallbackForward(a3),
+        CallbackForward(a4), CallbackForward(a5), CallbackForward(a6));
+  }
+};
+
+template <typename ReturnType, typename Runnable,typename A1, typename A2,
+    typename A3, typename A4, typename A5, typename A6, typename A7>
+struct InvokeHelper<false, ReturnType, Runnable,
+    void(A1, A2, A3, A4, A5, A6, A7)>  {
+  static ReturnType MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4,
+      A5 a5, A6 a6, A7 a7) {
+    return runnable.Run(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3), CallbackForward(a4), CallbackForward(a5),
+        CallbackForward(a6), CallbackForward(a7));
+  }
+};
+
+template <typename Runnable,typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6, typename A7>
+struct InvokeHelper<false, void, Runnable,
+    void(A1, A2, A3, A4, A5, A6, A7)>  {
+  static void MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5,
+      A6 a6, A7 a7) {
+    runnable.Run(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3),
+        CallbackForward(a4), CallbackForward(a5), CallbackForward(a6),
+        CallbackForward(a7));
+  }
+};
+
+template <typename Runnable, typename BoundWeakPtr, typename A2, typename A3,
+    typename A4, typename A5, typename A6, typename A7>
+struct InvokeHelper<true, void, Runnable,
+    void(BoundWeakPtr, A2, A3, A4, A5, A6, A7)>  {
+  static void MakeItSo(Runnable runnable, BoundWeakPtr weak_ptr, A2 a2, A3 a3,
+      A4 a4, A5 a5, A6 a6, A7 a7) {
+    if (!weak_ptr.get()) {
+      return;
+    }
+    runnable.Run(weak_ptr.get(), CallbackForward(a2), CallbackForward(a3),
+        CallbackForward(a4), CallbackForward(a5), CallbackForward(a6),
+        CallbackForward(a7));
+  }
+};
+
+#if !defined(_MSC_VER)
+
+template <typename ReturnType, typename Runnable, typename ArgsType>
+struct InvokeHelper<true, ReturnType, Runnable, ArgsType> {
+  // WeakCalls are only supported for functions with a void return type.
+  // Otherwise, the function result would be undefined if the the WeakPtr<>
+  // is invalidated.
+  COMPILE_ASSERT(is_void<ReturnType>::value,
+                 weak_ptrs_can_only_bind_to_methods_without_return_values);
+};
+
+#endif
+
+// Invoker<>
+//
+// See description at the top of the file.
+template <int NumBound, typename Storage, typename RunType>
+struct Invoker;
+
+// Arity 0 -> 0.
+template <typename StorageType, typename R>
+struct Invoker<0, StorageType, R()> {
+  typedef R(RunType)(BindStateBase*);
+
+  typedef R(UnboundRunType)();
+
+  static R Run(BindStateBase* base) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void()>
+               ::MakeItSo(storage->runnable_);
+  }
+};
+
+// Arity 1 -> 1.
+template <typename StorageType, typename R,typename X1>
+struct Invoker<0, StorageType, R(X1)> {
+  typedef R(RunType)(BindStateBase*,
+      typename CallbackParamTraits<X1>::ForwardType);
+
+  typedef R(UnboundRunType)(X1);
+
+  static R Run(BindStateBase* base,
+      typename CallbackParamTraits<X1>::ForwardType x1) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename CallbackParamTraits<X1>::ForwardType x1)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1));
+  }
+};
+
+// Arity 1 -> 0.
+template <typename StorageType, typename R,typename X1>
+struct Invoker<1, StorageType, R(X1)> {
+  typedef R(RunType)(BindStateBase*);
+
+  typedef R(UnboundRunType)();
+
+  static R Run(BindStateBase* base) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
+
+    typename Bound1UnwrapTraits::ForwardType x1 =
+        Bound1UnwrapTraits::Unwrap(storage->p1_);
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename Bound1UnwrapTraits::ForwardType)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1));
+  }
+};
+
+// Arity 2 -> 2.
+template <typename StorageType, typename R,typename X1, typename X2>
+struct Invoker<0, StorageType, R(X1, X2)> {
+  typedef R(RunType)(BindStateBase*,
+      typename CallbackParamTraits<X1>::ForwardType,
+      typename CallbackParamTraits<X2>::ForwardType);
+
+  typedef R(UnboundRunType)(X1, X2);
+
+  static R Run(BindStateBase* base,
+      typename CallbackParamTraits<X1>::ForwardType x1,
+      typename CallbackParamTraits<X2>::ForwardType x2) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename CallbackParamTraits<X1>::ForwardType x1,
+               typename CallbackParamTraits<X2>::ForwardType x2)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2));
+  }
+};
+
+// Arity 2 -> 1.
+template <typename StorageType, typename R,typename X1, typename X2>
+struct Invoker<1, StorageType, R(X1, X2)> {
+  typedef R(RunType)(BindStateBase*,
+      typename CallbackParamTraits<X2>::ForwardType);
+
+  typedef R(UnboundRunType)(X2);
+
+  static R Run(BindStateBase* base,
+      typename CallbackParamTraits<X2>::ForwardType x2) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
+
+    typename Bound1UnwrapTraits::ForwardType x1 =
+        Bound1UnwrapTraits::Unwrap(storage->p1_);
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename Bound1UnwrapTraits::ForwardType,
+               typename CallbackParamTraits<X2>::ForwardType x2)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2));
+  }
+};
+
+// Arity 2 -> 0.
+template <typename StorageType, typename R,typename X1, typename X2>
+struct Invoker<2, StorageType, R(X1, X2)> {
+  typedef R(RunType)(BindStateBase*);
+
+  typedef R(UnboundRunType)();
+
+  static R Run(BindStateBase* base) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
+    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
+
+    typename Bound1UnwrapTraits::ForwardType x1 =
+        Bound1UnwrapTraits::Unwrap(storage->p1_);
+    typename Bound2UnwrapTraits::ForwardType x2 =
+        Bound2UnwrapTraits::Unwrap(storage->p2_);
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename Bound1UnwrapTraits::ForwardType,
+               typename Bound2UnwrapTraits::ForwardType)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2));
+  }
+};
+
+// Arity 3 -> 3.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3>
+struct Invoker<0, StorageType, R(X1, X2, X3)> {
+  typedef R(RunType)(BindStateBase*,
+      typename CallbackParamTraits<X1>::ForwardType,
+      typename CallbackParamTraits<X2>::ForwardType,
+      typename CallbackParamTraits<X3>::ForwardType);
+
+  typedef R(UnboundRunType)(X1, X2, X3);
+
+  static R Run(BindStateBase* base,
+      typename CallbackParamTraits<X1>::ForwardType x1,
+      typename CallbackParamTraits<X2>::ForwardType x2,
+      typename CallbackParamTraits<X3>::ForwardType x3) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename CallbackParamTraits<X1>::ForwardType x1,
+               typename CallbackParamTraits<X2>::ForwardType x2,
+               typename CallbackParamTraits<X3>::ForwardType x3)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3));
+  }
+};
+
+// Arity 3 -> 2.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3>
+struct Invoker<1, StorageType, R(X1, X2, X3)> {
+  typedef R(RunType)(BindStateBase*,
+      typename CallbackParamTraits<X2>::ForwardType,
+      typename CallbackParamTraits<X3>::ForwardType);
+
+  typedef R(UnboundRunType)(X2, X3);
+
+  static R Run(BindStateBase* base,
+      typename CallbackParamTraits<X2>::ForwardType x2,
+      typename CallbackParamTraits<X3>::ForwardType x3) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
+
+    typename Bound1UnwrapTraits::ForwardType x1 =
+        Bound1UnwrapTraits::Unwrap(storage->p1_);
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename Bound1UnwrapTraits::ForwardType,
+               typename CallbackParamTraits<X2>::ForwardType x2,
+               typename CallbackParamTraits<X3>::ForwardType x3)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3));
+  }
+};
+
+// Arity 3 -> 1.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3>
+struct Invoker<2, StorageType, R(X1, X2, X3)> {
+  typedef R(RunType)(BindStateBase*,
+      typename CallbackParamTraits<X3>::ForwardType);
+
+  typedef R(UnboundRunType)(X3);
+
+  static R Run(BindStateBase* base,
+      typename CallbackParamTraits<X3>::ForwardType x3) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
+    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
+
+    typename Bound1UnwrapTraits::ForwardType x1 =
+        Bound1UnwrapTraits::Unwrap(storage->p1_);
+    typename Bound2UnwrapTraits::ForwardType x2 =
+        Bound2UnwrapTraits::Unwrap(storage->p2_);
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename Bound1UnwrapTraits::ForwardType,
+               typename Bound2UnwrapTraits::ForwardType,
+               typename CallbackParamTraits<X3>::ForwardType x3)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3));
+  }
+};
+
+// Arity 3 -> 0.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3>
+struct Invoker<3, StorageType, R(X1, X2, X3)> {
+  typedef R(RunType)(BindStateBase*);
+
+  typedef R(UnboundRunType)();
+
+  static R Run(BindStateBase* base) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
+    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
+    typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
+
+    typename Bound1UnwrapTraits::ForwardType x1 =
+        Bound1UnwrapTraits::Unwrap(storage->p1_);
+    typename Bound2UnwrapTraits::ForwardType x2 =
+        Bound2UnwrapTraits::Unwrap(storage->p2_);
+    typename Bound3UnwrapTraits::ForwardType x3 =
+        Bound3UnwrapTraits::Unwrap(storage->p3_);
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename Bound1UnwrapTraits::ForwardType,
+               typename Bound2UnwrapTraits::ForwardType,
+               typename Bound3UnwrapTraits::ForwardType)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3));
+  }
+};
+
+// Arity 4 -> 4.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3, typename X4>
+struct Invoker<0, StorageType, R(X1, X2, X3, X4)> {
+  typedef R(RunType)(BindStateBase*,
+      typename CallbackParamTraits<X1>::ForwardType,
+      typename CallbackParamTraits<X2>::ForwardType,
+      typename CallbackParamTraits<X3>::ForwardType,
+      typename CallbackParamTraits<X4>::ForwardType);
+
+  typedef R(UnboundRunType)(X1, X2, X3, X4);
+
+  static R Run(BindStateBase* base,
+      typename CallbackParamTraits<X1>::ForwardType x1,
+      typename CallbackParamTraits<X2>::ForwardType x2,
+      typename CallbackParamTraits<X3>::ForwardType x3,
+      typename CallbackParamTraits<X4>::ForwardType x4) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename CallbackParamTraits<X1>::ForwardType x1,
+               typename CallbackParamTraits<X2>::ForwardType x2,
+               typename CallbackParamTraits<X3>::ForwardType x3,
+               typename CallbackParamTraits<X4>::ForwardType x4)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4));
+  }
+};
+
+// Arity 4 -> 3.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3, typename X4>
+struct Invoker<1, StorageType, R(X1, X2, X3, X4)> {
+  typedef R(RunType)(BindStateBase*,
+      typename CallbackParamTraits<X2>::ForwardType,
+      typename CallbackParamTraits<X3>::ForwardType,
+      typename CallbackParamTraits<X4>::ForwardType);
+
+  typedef R(UnboundRunType)(X2, X3, X4);
+
+  static R Run(BindStateBase* base,
+      typename CallbackParamTraits<X2>::ForwardType x2,
+      typename CallbackParamTraits<X3>::ForwardType x3,
+      typename CallbackParamTraits<X4>::ForwardType x4) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
+
+    typename Bound1UnwrapTraits::ForwardType x1 =
+        Bound1UnwrapTraits::Unwrap(storage->p1_);
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename Bound1UnwrapTraits::ForwardType,
+               typename CallbackParamTraits<X2>::ForwardType x2,
+               typename CallbackParamTraits<X3>::ForwardType x3,
+               typename CallbackParamTraits<X4>::ForwardType x4)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4));
+  }
+};
+
+// Arity 4 -> 2.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3, typename X4>
+struct Invoker<2, StorageType, R(X1, X2, X3, X4)> {
+  typedef R(RunType)(BindStateBase*,
+      typename CallbackParamTraits<X3>::ForwardType,
+      typename CallbackParamTraits<X4>::ForwardType);
+
+  typedef R(UnboundRunType)(X3, X4);
+
+  static R Run(BindStateBase* base,
+      typename CallbackParamTraits<X3>::ForwardType x3,
+      typename CallbackParamTraits<X4>::ForwardType x4) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
+    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
+
+    typename Bound1UnwrapTraits::ForwardType x1 =
+        Bound1UnwrapTraits::Unwrap(storage->p1_);
+    typename Bound2UnwrapTraits::ForwardType x2 =
+        Bound2UnwrapTraits::Unwrap(storage->p2_);
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename Bound1UnwrapTraits::ForwardType,
+               typename Bound2UnwrapTraits::ForwardType,
+               typename CallbackParamTraits<X3>::ForwardType x3,
+               typename CallbackParamTraits<X4>::ForwardType x4)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4));
+  }
+};
+
+// Arity 4 -> 1.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3, typename X4>
+struct Invoker<3, StorageType, R(X1, X2, X3, X4)> {
+  typedef R(RunType)(BindStateBase*,
+      typename CallbackParamTraits<X4>::ForwardType);
+
+  typedef R(UnboundRunType)(X4);
+
+  static R Run(BindStateBase* base,
+      typename CallbackParamTraits<X4>::ForwardType x4) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
+    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
+    typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
+
+    typename Bound1UnwrapTraits::ForwardType x1 =
+        Bound1UnwrapTraits::Unwrap(storage->p1_);
+    typename Bound2UnwrapTraits::ForwardType x2 =
+        Bound2UnwrapTraits::Unwrap(storage->p2_);
+    typename Bound3UnwrapTraits::ForwardType x3 =
+        Bound3UnwrapTraits::Unwrap(storage->p3_);
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename Bound1UnwrapTraits::ForwardType,
+               typename Bound2UnwrapTraits::ForwardType,
+               typename Bound3UnwrapTraits::ForwardType,
+               typename CallbackParamTraits<X4>::ForwardType x4)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4));
+  }
+};
+
+// Arity 4 -> 0.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3, typename X4>
+struct Invoker<4, StorageType, R(X1, X2, X3, X4)> {
+  typedef R(RunType)(BindStateBase*);
+
+  typedef R(UnboundRunType)();
+
+  static R Run(BindStateBase* base) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
+    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
+    typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
+    typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits;
+
+    typename Bound1UnwrapTraits::ForwardType x1 =
+        Bound1UnwrapTraits::Unwrap(storage->p1_);
+    typename Bound2UnwrapTraits::ForwardType x2 =
+        Bound2UnwrapTraits::Unwrap(storage->p2_);
+    typename Bound3UnwrapTraits::ForwardType x3 =
+        Bound3UnwrapTraits::Unwrap(storage->p3_);
+    typename Bound4UnwrapTraits::ForwardType x4 =
+        Bound4UnwrapTraits::Unwrap(storage->p4_);
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename Bound1UnwrapTraits::ForwardType,
+               typename Bound2UnwrapTraits::ForwardType,
+               typename Bound3UnwrapTraits::ForwardType,
+               typename Bound4UnwrapTraits::ForwardType)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4));
+  }
+};
+
+// Arity 5 -> 5.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3, typename X4, typename X5>
+struct Invoker<0, StorageType, R(X1, X2, X3, X4, X5)> {
+  typedef R(RunType)(BindStateBase*,
+      typename CallbackParamTraits<X1>::ForwardType,
+      typename CallbackParamTraits<X2>::ForwardType,
+      typename CallbackParamTraits<X3>::ForwardType,
+      typename CallbackParamTraits<X4>::ForwardType,
+      typename CallbackParamTraits<X5>::ForwardType);
+
+  typedef R(UnboundRunType)(X1, X2, X3, X4, X5);
+
+  static R Run(BindStateBase* base,
+      typename CallbackParamTraits<X1>::ForwardType x1,
+      typename CallbackParamTraits<X2>::ForwardType x2,
+      typename CallbackParamTraits<X3>::ForwardType x3,
+      typename CallbackParamTraits<X4>::ForwardType x4,
+      typename CallbackParamTraits<X5>::ForwardType x5) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename CallbackParamTraits<X1>::ForwardType x1,
+               typename CallbackParamTraits<X2>::ForwardType x2,
+               typename CallbackParamTraits<X3>::ForwardType x3,
+               typename CallbackParamTraits<X4>::ForwardType x4,
+               typename CallbackParamTraits<X5>::ForwardType x5)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5));
+  }
+};
+
+// Arity 5 -> 4.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3, typename X4, typename X5>
+struct Invoker<1, StorageType, R(X1, X2, X3, X4, X5)> {
+  typedef R(RunType)(BindStateBase*,
+      typename CallbackParamTraits<X2>::ForwardType,
+      typename CallbackParamTraits<X3>::ForwardType,
+      typename CallbackParamTraits<X4>::ForwardType,
+      typename CallbackParamTraits<X5>::ForwardType);
+
+  typedef R(UnboundRunType)(X2, X3, X4, X5);
+
+  static R Run(BindStateBase* base,
+      typename CallbackParamTraits<X2>::ForwardType x2,
+      typename CallbackParamTraits<X3>::ForwardType x3,
+      typename CallbackParamTraits<X4>::ForwardType x4,
+      typename CallbackParamTraits<X5>::ForwardType x5) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
+
+    typename Bound1UnwrapTraits::ForwardType x1 =
+        Bound1UnwrapTraits::Unwrap(storage->p1_);
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename Bound1UnwrapTraits::ForwardType,
+               typename CallbackParamTraits<X2>::ForwardType x2,
+               typename CallbackParamTraits<X3>::ForwardType x3,
+               typename CallbackParamTraits<X4>::ForwardType x4,
+               typename CallbackParamTraits<X5>::ForwardType x5)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5));
+  }
+};
+
+// Arity 5 -> 3.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3, typename X4, typename X5>
+struct Invoker<2, StorageType, R(X1, X2, X3, X4, X5)> {
+  typedef R(RunType)(BindStateBase*,
+      typename CallbackParamTraits<X3>::ForwardType,
+      typename CallbackParamTraits<X4>::ForwardType,
+      typename CallbackParamTraits<X5>::ForwardType);
+
+  typedef R(UnboundRunType)(X3, X4, X5);
+
+  static R Run(BindStateBase* base,
+      typename CallbackParamTraits<X3>::ForwardType x3,
+      typename CallbackParamTraits<X4>::ForwardType x4,
+      typename CallbackParamTraits<X5>::ForwardType x5) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
+    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
+
+    typename Bound1UnwrapTraits::ForwardType x1 =
+        Bound1UnwrapTraits::Unwrap(storage->p1_);
+    typename Bound2UnwrapTraits::ForwardType x2 =
+        Bound2UnwrapTraits::Unwrap(storage->p2_);
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename Bound1UnwrapTraits::ForwardType,
+               typename Bound2UnwrapTraits::ForwardType,
+               typename CallbackParamTraits<X3>::ForwardType x3,
+               typename CallbackParamTraits<X4>::ForwardType x4,
+               typename CallbackParamTraits<X5>::ForwardType x5)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5));
+  }
+};
+
+// Arity 5 -> 2.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3, typename X4, typename X5>
+struct Invoker<3, StorageType, R(X1, X2, X3, X4, X5)> {
+  typedef R(RunType)(BindStateBase*,
+      typename CallbackParamTraits<X4>::ForwardType,
+      typename CallbackParamTraits<X5>::ForwardType);
+
+  typedef R(UnboundRunType)(X4, X5);
+
+  static R Run(BindStateBase* base,
+      typename CallbackParamTraits<X4>::ForwardType x4,
+      typename CallbackParamTraits<X5>::ForwardType x5) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
+    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
+    typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
+
+    typename Bound1UnwrapTraits::ForwardType x1 =
+        Bound1UnwrapTraits::Unwrap(storage->p1_);
+    typename Bound2UnwrapTraits::ForwardType x2 =
+        Bound2UnwrapTraits::Unwrap(storage->p2_);
+    typename Bound3UnwrapTraits::ForwardType x3 =
+        Bound3UnwrapTraits::Unwrap(storage->p3_);
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename Bound1UnwrapTraits::ForwardType,
+               typename Bound2UnwrapTraits::ForwardType,
+               typename Bound3UnwrapTraits::ForwardType,
+               typename CallbackParamTraits<X4>::ForwardType x4,
+               typename CallbackParamTraits<X5>::ForwardType x5)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5));
+  }
+};
+
+// Arity 5 -> 1.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3, typename X4, typename X5>
+struct Invoker<4, StorageType, R(X1, X2, X3, X4, X5)> {
+  typedef R(RunType)(BindStateBase*,
+      typename CallbackParamTraits<X5>::ForwardType);
+
+  typedef R(UnboundRunType)(X5);
+
+  static R Run(BindStateBase* base,
+      typename CallbackParamTraits<X5>::ForwardType x5) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
+    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
+    typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
+    typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits;
+
+    typename Bound1UnwrapTraits::ForwardType x1 =
+        Bound1UnwrapTraits::Unwrap(storage->p1_);
+    typename Bound2UnwrapTraits::ForwardType x2 =
+        Bound2UnwrapTraits::Unwrap(storage->p2_);
+    typename Bound3UnwrapTraits::ForwardType x3 =
+        Bound3UnwrapTraits::Unwrap(storage->p3_);
+    typename Bound4UnwrapTraits::ForwardType x4 =
+        Bound4UnwrapTraits::Unwrap(storage->p4_);
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename Bound1UnwrapTraits::ForwardType,
+               typename Bound2UnwrapTraits::ForwardType,
+               typename Bound3UnwrapTraits::ForwardType,
+               typename Bound4UnwrapTraits::ForwardType,
+               typename CallbackParamTraits<X5>::ForwardType x5)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5));
+  }
+};
+
+// Arity 5 -> 0.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3, typename X4, typename X5>
+struct Invoker<5, StorageType, R(X1, X2, X3, X4, X5)> {
+  typedef R(RunType)(BindStateBase*);
+
+  typedef R(UnboundRunType)();
+
+  static R Run(BindStateBase* base) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
+    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
+    typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
+    typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits;
+    typedef typename StorageType::Bound5UnwrapTraits Bound5UnwrapTraits;
+
+    typename Bound1UnwrapTraits::ForwardType x1 =
+        Bound1UnwrapTraits::Unwrap(storage->p1_);
+    typename Bound2UnwrapTraits::ForwardType x2 =
+        Bound2UnwrapTraits::Unwrap(storage->p2_);
+    typename Bound3UnwrapTraits::ForwardType x3 =
+        Bound3UnwrapTraits::Unwrap(storage->p3_);
+    typename Bound4UnwrapTraits::ForwardType x4 =
+        Bound4UnwrapTraits::Unwrap(storage->p4_);
+    typename Bound5UnwrapTraits::ForwardType x5 =
+        Bound5UnwrapTraits::Unwrap(storage->p5_);
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename Bound1UnwrapTraits::ForwardType,
+               typename Bound2UnwrapTraits::ForwardType,
+               typename Bound3UnwrapTraits::ForwardType,
+               typename Bound4UnwrapTraits::ForwardType,
+               typename Bound5UnwrapTraits::ForwardType)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5));
+  }
+};
+
+// Arity 6 -> 6.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3, typename X4, typename X5, typename X6>
+struct Invoker<0, StorageType, R(X1, X2, X3, X4, X5, X6)> {
+  typedef R(RunType)(BindStateBase*,
+      typename CallbackParamTraits<X1>::ForwardType,
+      typename CallbackParamTraits<X2>::ForwardType,
+      typename CallbackParamTraits<X3>::ForwardType,
+      typename CallbackParamTraits<X4>::ForwardType,
+      typename CallbackParamTraits<X5>::ForwardType,
+      typename CallbackParamTraits<X6>::ForwardType);
+
+  typedef R(UnboundRunType)(X1, X2, X3, X4, X5, X6);
+
+  static R Run(BindStateBase* base,
+      typename CallbackParamTraits<X1>::ForwardType x1,
+      typename CallbackParamTraits<X2>::ForwardType x2,
+      typename CallbackParamTraits<X3>::ForwardType x3,
+      typename CallbackParamTraits<X4>::ForwardType x4,
+      typename CallbackParamTraits<X5>::ForwardType x5,
+      typename CallbackParamTraits<X6>::ForwardType x6) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename CallbackParamTraits<X1>::ForwardType x1,
+               typename CallbackParamTraits<X2>::ForwardType x2,
+               typename CallbackParamTraits<X3>::ForwardType x3,
+               typename CallbackParamTraits<X4>::ForwardType x4,
+               typename CallbackParamTraits<X5>::ForwardType x5,
+               typename CallbackParamTraits<X6>::ForwardType x6)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5),
+                   CallbackForward(x6));
+  }
+};
+
+// Arity 6 -> 5.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3, typename X4, typename X5, typename X6>
+struct Invoker<1, StorageType, R(X1, X2, X3, X4, X5, X6)> {
+  typedef R(RunType)(BindStateBase*,
+      typename CallbackParamTraits<X2>::ForwardType,
+      typename CallbackParamTraits<X3>::ForwardType,
+      typename CallbackParamTraits<X4>::ForwardType,
+      typename CallbackParamTraits<X5>::ForwardType,
+      typename CallbackParamTraits<X6>::ForwardType);
+
+  typedef R(UnboundRunType)(X2, X3, X4, X5, X6);
+
+  static R Run(BindStateBase* base,
+      typename CallbackParamTraits<X2>::ForwardType x2,
+      typename CallbackParamTraits<X3>::ForwardType x3,
+      typename CallbackParamTraits<X4>::ForwardType x4,
+      typename CallbackParamTraits<X5>::ForwardType x5,
+      typename CallbackParamTraits<X6>::ForwardType x6) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
+
+    typename Bound1UnwrapTraits::ForwardType x1 =
+        Bound1UnwrapTraits::Unwrap(storage->p1_);
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename Bound1UnwrapTraits::ForwardType,
+               typename CallbackParamTraits<X2>::ForwardType x2,
+               typename CallbackParamTraits<X3>::ForwardType x3,
+               typename CallbackParamTraits<X4>::ForwardType x4,
+               typename CallbackParamTraits<X5>::ForwardType x5,
+               typename CallbackParamTraits<X6>::ForwardType x6)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5),
+                   CallbackForward(x6));
+  }
+};
+
+// Arity 6 -> 4.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3, typename X4, typename X5, typename X6>
+struct Invoker<2, StorageType, R(X1, X2, X3, X4, X5, X6)> {
+  typedef R(RunType)(BindStateBase*,
+      typename CallbackParamTraits<X3>::ForwardType,
+      typename CallbackParamTraits<X4>::ForwardType,
+      typename CallbackParamTraits<X5>::ForwardType,
+      typename CallbackParamTraits<X6>::ForwardType);
+
+  typedef R(UnboundRunType)(X3, X4, X5, X6);
+
+  static R Run(BindStateBase* base,
+      typename CallbackParamTraits<X3>::ForwardType x3,
+      typename CallbackParamTraits<X4>::ForwardType x4,
+      typename CallbackParamTraits<X5>::ForwardType x5,
+      typename CallbackParamTraits<X6>::ForwardType x6) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
+    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
+
+    typename Bound1UnwrapTraits::ForwardType x1 =
+        Bound1UnwrapTraits::Unwrap(storage->p1_);
+    typename Bound2UnwrapTraits::ForwardType x2 =
+        Bound2UnwrapTraits::Unwrap(storage->p2_);
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename Bound1UnwrapTraits::ForwardType,
+               typename Bound2UnwrapTraits::ForwardType,
+               typename CallbackParamTraits<X3>::ForwardType x3,
+               typename CallbackParamTraits<X4>::ForwardType x4,
+               typename CallbackParamTraits<X5>::ForwardType x5,
+               typename CallbackParamTraits<X6>::ForwardType x6)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5),
+                   CallbackForward(x6));
+  }
+};
+
+// Arity 6 -> 3.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3, typename X4, typename X5, typename X6>
+struct Invoker<3, StorageType, R(X1, X2, X3, X4, X5, X6)> {
+  typedef R(RunType)(BindStateBase*,
+      typename CallbackParamTraits<X4>::ForwardType,
+      typename CallbackParamTraits<X5>::ForwardType,
+      typename CallbackParamTraits<X6>::ForwardType);
+
+  typedef R(UnboundRunType)(X4, X5, X6);
+
+  static R Run(BindStateBase* base,
+      typename CallbackParamTraits<X4>::ForwardType x4,
+      typename CallbackParamTraits<X5>::ForwardType x5,
+      typename CallbackParamTraits<X6>::ForwardType x6) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
+    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
+    typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
+
+    typename Bound1UnwrapTraits::ForwardType x1 =
+        Bound1UnwrapTraits::Unwrap(storage->p1_);
+    typename Bound2UnwrapTraits::ForwardType x2 =
+        Bound2UnwrapTraits::Unwrap(storage->p2_);
+    typename Bound3UnwrapTraits::ForwardType x3 =
+        Bound3UnwrapTraits::Unwrap(storage->p3_);
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename Bound1UnwrapTraits::ForwardType,
+               typename Bound2UnwrapTraits::ForwardType,
+               typename Bound3UnwrapTraits::ForwardType,
+               typename CallbackParamTraits<X4>::ForwardType x4,
+               typename CallbackParamTraits<X5>::ForwardType x5,
+               typename CallbackParamTraits<X6>::ForwardType x6)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5),
+                   CallbackForward(x6));
+  }
+};
+
+// Arity 6 -> 2.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3, typename X4, typename X5, typename X6>
+struct Invoker<4, StorageType, R(X1, X2, X3, X4, X5, X6)> {
+  typedef R(RunType)(BindStateBase*,
+      typename CallbackParamTraits<X5>::ForwardType,
+      typename CallbackParamTraits<X6>::ForwardType);
+
+  typedef R(UnboundRunType)(X5, X6);
+
+  static R Run(BindStateBase* base,
+      typename CallbackParamTraits<X5>::ForwardType x5,
+      typename CallbackParamTraits<X6>::ForwardType x6) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
+    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
+    typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
+    typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits;
+
+    typename Bound1UnwrapTraits::ForwardType x1 =
+        Bound1UnwrapTraits::Unwrap(storage->p1_);
+    typename Bound2UnwrapTraits::ForwardType x2 =
+        Bound2UnwrapTraits::Unwrap(storage->p2_);
+    typename Bound3UnwrapTraits::ForwardType x3 =
+        Bound3UnwrapTraits::Unwrap(storage->p3_);
+    typename Bound4UnwrapTraits::ForwardType x4 =
+        Bound4UnwrapTraits::Unwrap(storage->p4_);
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename Bound1UnwrapTraits::ForwardType,
+               typename Bound2UnwrapTraits::ForwardType,
+               typename Bound3UnwrapTraits::ForwardType,
+               typename Bound4UnwrapTraits::ForwardType,
+               typename CallbackParamTraits<X5>::ForwardType x5,
+               typename CallbackParamTraits<X6>::ForwardType x6)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5),
+                   CallbackForward(x6));
+  }
+};
+
+// Arity 6 -> 1.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3, typename X4, typename X5, typename X6>
+struct Invoker<5, StorageType, R(X1, X2, X3, X4, X5, X6)> {
+  typedef R(RunType)(BindStateBase*,
+      typename CallbackParamTraits<X6>::ForwardType);
+
+  typedef R(UnboundRunType)(X6);
+
+  static R Run(BindStateBase* base,
+      typename CallbackParamTraits<X6>::ForwardType x6) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
+    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
+    typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
+    typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits;
+    typedef typename StorageType::Bound5UnwrapTraits Bound5UnwrapTraits;
+
+    typename Bound1UnwrapTraits::ForwardType x1 =
+        Bound1UnwrapTraits::Unwrap(storage->p1_);
+    typename Bound2UnwrapTraits::ForwardType x2 =
+        Bound2UnwrapTraits::Unwrap(storage->p2_);
+    typename Bound3UnwrapTraits::ForwardType x3 =
+        Bound3UnwrapTraits::Unwrap(storage->p3_);
+    typename Bound4UnwrapTraits::ForwardType x4 =
+        Bound4UnwrapTraits::Unwrap(storage->p4_);
+    typename Bound5UnwrapTraits::ForwardType x5 =
+        Bound5UnwrapTraits::Unwrap(storage->p5_);
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename Bound1UnwrapTraits::ForwardType,
+               typename Bound2UnwrapTraits::ForwardType,
+               typename Bound3UnwrapTraits::ForwardType,
+               typename Bound4UnwrapTraits::ForwardType,
+               typename Bound5UnwrapTraits::ForwardType,
+               typename CallbackParamTraits<X6>::ForwardType x6)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5),
+                   CallbackForward(x6));
+  }
+};
+
+// Arity 6 -> 0.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3, typename X4, typename X5, typename X6>
+struct Invoker<6, StorageType, R(X1, X2, X3, X4, X5, X6)> {
+  typedef R(RunType)(BindStateBase*);
+
+  typedef R(UnboundRunType)();
+
+  static R Run(BindStateBase* base) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
+    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
+    typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
+    typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits;
+    typedef typename StorageType::Bound5UnwrapTraits Bound5UnwrapTraits;
+    typedef typename StorageType::Bound6UnwrapTraits Bound6UnwrapTraits;
+
+    typename Bound1UnwrapTraits::ForwardType x1 =
+        Bound1UnwrapTraits::Unwrap(storage->p1_);
+    typename Bound2UnwrapTraits::ForwardType x2 =
+        Bound2UnwrapTraits::Unwrap(storage->p2_);
+    typename Bound3UnwrapTraits::ForwardType x3 =
+        Bound3UnwrapTraits::Unwrap(storage->p3_);
+    typename Bound4UnwrapTraits::ForwardType x4 =
+        Bound4UnwrapTraits::Unwrap(storage->p4_);
+    typename Bound5UnwrapTraits::ForwardType x5 =
+        Bound5UnwrapTraits::Unwrap(storage->p5_);
+    typename Bound6UnwrapTraits::ForwardType x6 =
+        Bound6UnwrapTraits::Unwrap(storage->p6_);
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename Bound1UnwrapTraits::ForwardType,
+               typename Bound2UnwrapTraits::ForwardType,
+               typename Bound3UnwrapTraits::ForwardType,
+               typename Bound4UnwrapTraits::ForwardType,
+               typename Bound5UnwrapTraits::ForwardType,
+               typename Bound6UnwrapTraits::ForwardType)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5),
+                   CallbackForward(x6));
+  }
+};
+
+// Arity 7 -> 7.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3, typename X4, typename X5, typename X6, typename X7>
+struct Invoker<0, StorageType, R(X1, X2, X3, X4, X5, X6, X7)> {
+  typedef R(RunType)(BindStateBase*,
+      typename CallbackParamTraits<X1>::ForwardType,
+      typename CallbackParamTraits<X2>::ForwardType,
+      typename CallbackParamTraits<X3>::ForwardType,
+      typename CallbackParamTraits<X4>::ForwardType,
+      typename CallbackParamTraits<X5>::ForwardType,
+      typename CallbackParamTraits<X6>::ForwardType,
+      typename CallbackParamTraits<X7>::ForwardType);
+
+  typedef R(UnboundRunType)(X1, X2, X3, X4, X5, X6, X7);
+
+  static R Run(BindStateBase* base,
+      typename CallbackParamTraits<X1>::ForwardType x1,
+      typename CallbackParamTraits<X2>::ForwardType x2,
+      typename CallbackParamTraits<X3>::ForwardType x3,
+      typename CallbackParamTraits<X4>::ForwardType x4,
+      typename CallbackParamTraits<X5>::ForwardType x5,
+      typename CallbackParamTraits<X6>::ForwardType x6,
+      typename CallbackParamTraits<X7>::ForwardType x7) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename CallbackParamTraits<X1>::ForwardType x1,
+               typename CallbackParamTraits<X2>::ForwardType x2,
+               typename CallbackParamTraits<X3>::ForwardType x3,
+               typename CallbackParamTraits<X4>::ForwardType x4,
+               typename CallbackParamTraits<X5>::ForwardType x5,
+               typename CallbackParamTraits<X6>::ForwardType x6,
+               typename CallbackParamTraits<X7>::ForwardType x7)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5),
+                   CallbackForward(x6), CallbackForward(x7));
+  }
+};
+
+// Arity 7 -> 6.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3, typename X4, typename X5, typename X6, typename X7>
+struct Invoker<1, StorageType, R(X1, X2, X3, X4, X5, X6, X7)> {
+  typedef R(RunType)(BindStateBase*,
+      typename CallbackParamTraits<X2>::ForwardType,
+      typename CallbackParamTraits<X3>::ForwardType,
+      typename CallbackParamTraits<X4>::ForwardType,
+      typename CallbackParamTraits<X5>::ForwardType,
+      typename CallbackParamTraits<X6>::ForwardType,
+      typename CallbackParamTraits<X7>::ForwardType);
+
+  typedef R(UnboundRunType)(X2, X3, X4, X5, X6, X7);
+
+  static R Run(BindStateBase* base,
+      typename CallbackParamTraits<X2>::ForwardType x2,
+      typename CallbackParamTraits<X3>::ForwardType x3,
+      typename CallbackParamTraits<X4>::ForwardType x4,
+      typename CallbackParamTraits<X5>::ForwardType x5,
+      typename CallbackParamTraits<X6>::ForwardType x6,
+      typename CallbackParamTraits<X7>::ForwardType x7) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
+
+    typename Bound1UnwrapTraits::ForwardType x1 =
+        Bound1UnwrapTraits::Unwrap(storage->p1_);
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename Bound1UnwrapTraits::ForwardType,
+               typename CallbackParamTraits<X2>::ForwardType x2,
+               typename CallbackParamTraits<X3>::ForwardType x3,
+               typename CallbackParamTraits<X4>::ForwardType x4,
+               typename CallbackParamTraits<X5>::ForwardType x5,
+               typename CallbackParamTraits<X6>::ForwardType x6,
+               typename CallbackParamTraits<X7>::ForwardType x7)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5),
+                   CallbackForward(x6), CallbackForward(x7));
+  }
+};
+
+// Arity 7 -> 5.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3, typename X4, typename X5, typename X6, typename X7>
+struct Invoker<2, StorageType, R(X1, X2, X3, X4, X5, X6, X7)> {
+  typedef R(RunType)(BindStateBase*,
+      typename CallbackParamTraits<X3>::ForwardType,
+      typename CallbackParamTraits<X4>::ForwardType,
+      typename CallbackParamTraits<X5>::ForwardType,
+      typename CallbackParamTraits<X6>::ForwardType,
+      typename CallbackParamTraits<X7>::ForwardType);
+
+  typedef R(UnboundRunType)(X3, X4, X5, X6, X7);
+
+  static R Run(BindStateBase* base,
+      typename CallbackParamTraits<X3>::ForwardType x3,
+      typename CallbackParamTraits<X4>::ForwardType x4,
+      typename CallbackParamTraits<X5>::ForwardType x5,
+      typename CallbackParamTraits<X6>::ForwardType x6,
+      typename CallbackParamTraits<X7>::ForwardType x7) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
+    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
+
+    typename Bound1UnwrapTraits::ForwardType x1 =
+        Bound1UnwrapTraits::Unwrap(storage->p1_);
+    typename Bound2UnwrapTraits::ForwardType x2 =
+        Bound2UnwrapTraits::Unwrap(storage->p2_);
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename Bound1UnwrapTraits::ForwardType,
+               typename Bound2UnwrapTraits::ForwardType,
+               typename CallbackParamTraits<X3>::ForwardType x3,
+               typename CallbackParamTraits<X4>::ForwardType x4,
+               typename CallbackParamTraits<X5>::ForwardType x5,
+               typename CallbackParamTraits<X6>::ForwardType x6,
+               typename CallbackParamTraits<X7>::ForwardType x7)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5),
+                   CallbackForward(x6), CallbackForward(x7));
+  }
+};
+
+// Arity 7 -> 4.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3, typename X4, typename X5, typename X6, typename X7>
+struct Invoker<3, StorageType, R(X1, X2, X3, X4, X5, X6, X7)> {
+  typedef R(RunType)(BindStateBase*,
+      typename CallbackParamTraits<X4>::ForwardType,
+      typename CallbackParamTraits<X5>::ForwardType,
+      typename CallbackParamTraits<X6>::ForwardType,
+      typename CallbackParamTraits<X7>::ForwardType);
+
+  typedef R(UnboundRunType)(X4, X5, X6, X7);
+
+  static R Run(BindStateBase* base,
+      typename CallbackParamTraits<X4>::ForwardType x4,
+      typename CallbackParamTraits<X5>::ForwardType x5,
+      typename CallbackParamTraits<X6>::ForwardType x6,
+      typename CallbackParamTraits<X7>::ForwardType x7) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
+    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
+    typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
+
+    typename Bound1UnwrapTraits::ForwardType x1 =
+        Bound1UnwrapTraits::Unwrap(storage->p1_);
+    typename Bound2UnwrapTraits::ForwardType x2 =
+        Bound2UnwrapTraits::Unwrap(storage->p2_);
+    typename Bound3UnwrapTraits::ForwardType x3 =
+        Bound3UnwrapTraits::Unwrap(storage->p3_);
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename Bound1UnwrapTraits::ForwardType,
+               typename Bound2UnwrapTraits::ForwardType,
+               typename Bound3UnwrapTraits::ForwardType,
+               typename CallbackParamTraits<X4>::ForwardType x4,
+               typename CallbackParamTraits<X5>::ForwardType x5,
+               typename CallbackParamTraits<X6>::ForwardType x6,
+               typename CallbackParamTraits<X7>::ForwardType x7)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5),
+                   CallbackForward(x6), CallbackForward(x7));
+  }
+};
+
+// Arity 7 -> 3.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3, typename X4, typename X5, typename X6, typename X7>
+struct Invoker<4, StorageType, R(X1, X2, X3, X4, X5, X6, X7)> {
+  typedef R(RunType)(BindStateBase*,
+      typename CallbackParamTraits<X5>::ForwardType,
+      typename CallbackParamTraits<X6>::ForwardType,
+      typename CallbackParamTraits<X7>::ForwardType);
+
+  typedef R(UnboundRunType)(X5, X6, X7);
+
+  static R Run(BindStateBase* base,
+      typename CallbackParamTraits<X5>::ForwardType x5,
+      typename CallbackParamTraits<X6>::ForwardType x6,
+      typename CallbackParamTraits<X7>::ForwardType x7) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
+    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
+    typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
+    typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits;
+
+    typename Bound1UnwrapTraits::ForwardType x1 =
+        Bound1UnwrapTraits::Unwrap(storage->p1_);
+    typename Bound2UnwrapTraits::ForwardType x2 =
+        Bound2UnwrapTraits::Unwrap(storage->p2_);
+    typename Bound3UnwrapTraits::ForwardType x3 =
+        Bound3UnwrapTraits::Unwrap(storage->p3_);
+    typename Bound4UnwrapTraits::ForwardType x4 =
+        Bound4UnwrapTraits::Unwrap(storage->p4_);
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename Bound1UnwrapTraits::ForwardType,
+               typename Bound2UnwrapTraits::ForwardType,
+               typename Bound3UnwrapTraits::ForwardType,
+               typename Bound4UnwrapTraits::ForwardType,
+               typename CallbackParamTraits<X5>::ForwardType x5,
+               typename CallbackParamTraits<X6>::ForwardType x6,
+               typename CallbackParamTraits<X7>::ForwardType x7)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5),
+                   CallbackForward(x6), CallbackForward(x7));
+  }
+};
+
+// Arity 7 -> 2.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3, typename X4, typename X5, typename X6, typename X7>
+struct Invoker<5, StorageType, R(X1, X2, X3, X4, X5, X6, X7)> {
+  typedef R(RunType)(BindStateBase*,
+      typename CallbackParamTraits<X6>::ForwardType,
+      typename CallbackParamTraits<X7>::ForwardType);
+
+  typedef R(UnboundRunType)(X6, X7);
+
+  static R Run(BindStateBase* base,
+      typename CallbackParamTraits<X6>::ForwardType x6,
+      typename CallbackParamTraits<X7>::ForwardType x7) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
+    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
+    typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
+    typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits;
+    typedef typename StorageType::Bound5UnwrapTraits Bound5UnwrapTraits;
+
+    typename Bound1UnwrapTraits::ForwardType x1 =
+        Bound1UnwrapTraits::Unwrap(storage->p1_);
+    typename Bound2UnwrapTraits::ForwardType x2 =
+        Bound2UnwrapTraits::Unwrap(storage->p2_);
+    typename Bound3UnwrapTraits::ForwardType x3 =
+        Bound3UnwrapTraits::Unwrap(storage->p3_);
+    typename Bound4UnwrapTraits::ForwardType x4 =
+        Bound4UnwrapTraits::Unwrap(storage->p4_);
+    typename Bound5UnwrapTraits::ForwardType x5 =
+        Bound5UnwrapTraits::Unwrap(storage->p5_);
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename Bound1UnwrapTraits::ForwardType,
+               typename Bound2UnwrapTraits::ForwardType,
+               typename Bound3UnwrapTraits::ForwardType,
+               typename Bound4UnwrapTraits::ForwardType,
+               typename Bound5UnwrapTraits::ForwardType,
+               typename CallbackParamTraits<X6>::ForwardType x6,
+               typename CallbackParamTraits<X7>::ForwardType x7)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5),
+                   CallbackForward(x6), CallbackForward(x7));
+  }
+};
+
+// Arity 7 -> 1.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3, typename X4, typename X5, typename X6, typename X7>
+struct Invoker<6, StorageType, R(X1, X2, X3, X4, X5, X6, X7)> {
+  typedef R(RunType)(BindStateBase*,
+      typename CallbackParamTraits<X7>::ForwardType);
+
+  typedef R(UnboundRunType)(X7);
+
+  static R Run(BindStateBase* base,
+      typename CallbackParamTraits<X7>::ForwardType x7) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
+    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
+    typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
+    typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits;
+    typedef typename StorageType::Bound5UnwrapTraits Bound5UnwrapTraits;
+    typedef typename StorageType::Bound6UnwrapTraits Bound6UnwrapTraits;
+
+    typename Bound1UnwrapTraits::ForwardType x1 =
+        Bound1UnwrapTraits::Unwrap(storage->p1_);
+    typename Bound2UnwrapTraits::ForwardType x2 =
+        Bound2UnwrapTraits::Unwrap(storage->p2_);
+    typename Bound3UnwrapTraits::ForwardType x3 =
+        Bound3UnwrapTraits::Unwrap(storage->p3_);
+    typename Bound4UnwrapTraits::ForwardType x4 =
+        Bound4UnwrapTraits::Unwrap(storage->p4_);
+    typename Bound5UnwrapTraits::ForwardType x5 =
+        Bound5UnwrapTraits::Unwrap(storage->p5_);
+    typename Bound6UnwrapTraits::ForwardType x6 =
+        Bound6UnwrapTraits::Unwrap(storage->p6_);
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename Bound1UnwrapTraits::ForwardType,
+               typename Bound2UnwrapTraits::ForwardType,
+               typename Bound3UnwrapTraits::ForwardType,
+               typename Bound4UnwrapTraits::ForwardType,
+               typename Bound5UnwrapTraits::ForwardType,
+               typename Bound6UnwrapTraits::ForwardType,
+               typename CallbackParamTraits<X7>::ForwardType x7)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5),
+                   CallbackForward(x6), CallbackForward(x7));
+  }
+};
+
+// Arity 7 -> 0.
+template <typename StorageType, typename R,typename X1, typename X2,
+    typename X3, typename X4, typename X5, typename X6, typename X7>
+struct Invoker<7, StorageType, R(X1, X2, X3, X4, X5, X6, X7)> {
+  typedef R(RunType)(BindStateBase*);
+
+  typedef R(UnboundRunType)();
+
+  static R Run(BindStateBase* base) {
+    StorageType* storage = static_cast<StorageType*>(base);
+
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
+    typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
+    typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits;
+    typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits;
+    typedef typename StorageType::Bound5UnwrapTraits Bound5UnwrapTraits;
+    typedef typename StorageType::Bound6UnwrapTraits Bound6UnwrapTraits;
+    typedef typename StorageType::Bound7UnwrapTraits Bound7UnwrapTraits;
+
+    typename Bound1UnwrapTraits::ForwardType x1 =
+        Bound1UnwrapTraits::Unwrap(storage->p1_);
+    typename Bound2UnwrapTraits::ForwardType x2 =
+        Bound2UnwrapTraits::Unwrap(storage->p2_);
+    typename Bound3UnwrapTraits::ForwardType x3 =
+        Bound3UnwrapTraits::Unwrap(storage->p3_);
+    typename Bound4UnwrapTraits::ForwardType x4 =
+        Bound4UnwrapTraits::Unwrap(storage->p4_);
+    typename Bound5UnwrapTraits::ForwardType x5 =
+        Bound5UnwrapTraits::Unwrap(storage->p5_);
+    typename Bound6UnwrapTraits::ForwardType x6 =
+        Bound6UnwrapTraits::Unwrap(storage->p6_);
+    typename Bound7UnwrapTraits::ForwardType x7 =
+        Bound7UnwrapTraits::Unwrap(storage->p7_);
+    return InvokeHelper<StorageType::IsWeakCall::value, R,
+           typename StorageType::RunnableType,
+           void(typename Bound1UnwrapTraits::ForwardType,
+               typename Bound2UnwrapTraits::ForwardType,
+               typename Bound3UnwrapTraits::ForwardType,
+               typename Bound4UnwrapTraits::ForwardType,
+               typename Bound5UnwrapTraits::ForwardType,
+               typename Bound6UnwrapTraits::ForwardType,
+               typename Bound7UnwrapTraits::ForwardType)>
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5),
+                   CallbackForward(x6), CallbackForward(x7));
+  }
+};
+
+
+// BindState<>
+//
+// This stores all the state passed into Bind() and is also where most
+// of the template resolution magic occurs.
+//
+// Runnable is the functor we are binding arguments to.
+// RunType is type of the Run() function that the Invoker<> should use.
+// Normally, this is the same as the RunType of the Runnable, but it can
+// be different if an adapter like IgnoreResult() has been used.
+//
+// BoundArgsType contains the storage type for all the bound arguments by
+// (ab)using a function type.
+template <typename Runnable, typename RunType, typename BoundArgsType>
+struct BindState;
+
+template <typename Runnable, typename RunType>
+struct BindState<Runnable, RunType, void()> : public BindStateBase {
+  typedef Runnable RunnableType;
+  typedef false_type IsWeakCall;
+  typedef Invoker<0, BindState, RunType> InvokerType;
+  typedef typename InvokerType::UnboundRunType UnboundRunType;
+  explicit BindState(const Runnable& runnable)
+      : BindStateBase(&Destroy),
+        runnable_(runnable) {
+  }
+
+  ~BindState() {  }
+
+  static void Destroy(BindStateBase* self) {
+    delete static_cast<BindState*>(self);
+  }
+
+  RunnableType runnable_;
+};
+
+template <typename Runnable, typename RunType, typename P1>
+struct BindState<Runnable, RunType, void(P1)> : public BindStateBase {
+  typedef Runnable RunnableType;
+  typedef IsWeakMethod<HasIsMethodTag<Runnable>::value, P1> IsWeakCall;
+  typedef Invoker<1, BindState, RunType> InvokerType;
+  typedef typename InvokerType::UnboundRunType UnboundRunType;
+
+  // Convenience typedefs for bound argument types.
+  typedef UnwrapTraits<P1> Bound1UnwrapTraits;
+
+  BindState(const Runnable& runnable, const P1& p1)
+      : BindStateBase(&Destroy),
+        runnable_(runnable),
+        p1_(p1) {
+    MaybeRefcount<HasIsMethodTag<Runnable>::value, P1>::AddRef(p1_);
+  }
+
+  ~BindState() {    MaybeRefcount<HasIsMethodTag<Runnable>::value,
+      P1>::Release(p1_);  }
+
+  static void Destroy(BindStateBase* self) {
+    delete static_cast<BindState*>(self);
+  }
+
+  RunnableType runnable_;
+  P1 p1_;
+};
+
+template <typename Runnable, typename RunType, typename P1, typename P2>
+struct BindState<Runnable, RunType, void(P1, P2)> : public BindStateBase {
+  typedef Runnable RunnableType;
+  typedef IsWeakMethod<HasIsMethodTag<Runnable>::value, P1> IsWeakCall;
+  typedef Invoker<2, BindState, RunType> InvokerType;
+  typedef typename InvokerType::UnboundRunType UnboundRunType;
+
+  // Convenience typedefs for bound argument types.
+  typedef UnwrapTraits<P1> Bound1UnwrapTraits;
+  typedef UnwrapTraits<P2> Bound2UnwrapTraits;
+
+  BindState(const Runnable& runnable, const P1& p1, const P2& p2)
+      : BindStateBase(&Destroy),
+        runnable_(runnable),
+        p1_(p1),
+        p2_(p2) {
+    MaybeRefcount<HasIsMethodTag<Runnable>::value, P1>::AddRef(p1_);
+  }
+
+  ~BindState() {    MaybeRefcount<HasIsMethodTag<Runnable>::value,
+      P1>::Release(p1_);  }
+
+  static void Destroy(BindStateBase* self) {
+    delete static_cast<BindState*>(self);
+  }
+
+  RunnableType runnable_;
+  P1 p1_;
+  P2 p2_;
+};
+
+template <typename Runnable, typename RunType, typename P1, typename P2,
+    typename P3>
+struct BindState<Runnable, RunType, void(P1, P2, P3)>
+    : public BindStateBase {
+  typedef Runnable RunnableType;
+  typedef IsWeakMethod<HasIsMethodTag<Runnable>::value, P1> IsWeakCall;
+  typedef Invoker<3, BindState, RunType> InvokerType;
+  typedef typename InvokerType::UnboundRunType UnboundRunType;
+
+  // Convenience typedefs for bound argument types.
+  typedef UnwrapTraits<P1> Bound1UnwrapTraits;
+  typedef UnwrapTraits<P2> Bound2UnwrapTraits;
+  typedef UnwrapTraits<P3> Bound3UnwrapTraits;
+
+  BindState(const Runnable& runnable, const P1& p1, const P2& p2, const P3& p3)
+      : BindStateBase(&Destroy),
+        runnable_(runnable),
+        p1_(p1),
+        p2_(p2),
+        p3_(p3) {
+    MaybeRefcount<HasIsMethodTag<Runnable>::value, P1>::AddRef(p1_);
+  }
+
+  ~BindState() {    MaybeRefcount<HasIsMethodTag<Runnable>::value,
+      P1>::Release(p1_);  }
+
+  static void Destroy(BindStateBase* self) {
+    delete static_cast<BindState*>(self);
+  }
+
+  RunnableType runnable_;
+  P1 p1_;
+  P2 p2_;
+  P3 p3_;
+};
+
+template <typename Runnable, typename RunType, typename P1, typename P2,
+    typename P3, typename P4>
+struct BindState<Runnable, RunType, void(P1, P2, P3, P4)>
+    : public BindStateBase {
+  typedef Runnable RunnableType;
+  typedef IsWeakMethod<HasIsMethodTag<Runnable>::value, P1> IsWeakCall;
+  typedef Invoker<4, BindState, RunType> InvokerType;
+  typedef typename InvokerType::UnboundRunType UnboundRunType;
+
+  // Convenience typedefs for bound argument types.
+  typedef UnwrapTraits<P1> Bound1UnwrapTraits;
+  typedef UnwrapTraits<P2> Bound2UnwrapTraits;
+  typedef UnwrapTraits<P3> Bound3UnwrapTraits;
+  typedef UnwrapTraits<P4> Bound4UnwrapTraits;
+
+  BindState(const Runnable& runnable, const P1& p1, const P2& p2, const P3& p3,
+      const P4& p4)
+      : BindStateBase(&Destroy),
+        runnable_(runnable),
+        p1_(p1),
+        p2_(p2),
+        p3_(p3),
+        p4_(p4) {
+    MaybeRefcount<HasIsMethodTag<Runnable>::value, P1>::AddRef(p1_);
+  }
+
+  ~BindState() {    MaybeRefcount<HasIsMethodTag<Runnable>::value,
+      P1>::Release(p1_);  }
+
+  static void Destroy(BindStateBase* self) {
+    delete static_cast<BindState*>(self);
+  }
+
+  RunnableType runnable_;
+  P1 p1_;
+  P2 p2_;
+  P3 p3_;
+  P4 p4_;
+};
+
+template <typename Runnable, typename RunType, typename P1, typename P2,
+    typename P3, typename P4, typename P5>
+struct BindState<Runnable, RunType, void(P1, P2, P3, P4, P5)>
+    : public BindStateBase {
+  typedef Runnable RunnableType;
+  typedef IsWeakMethod<HasIsMethodTag<Runnable>::value, P1> IsWeakCall;
+  typedef Invoker<5, BindState, RunType> InvokerType;
+  typedef typename InvokerType::UnboundRunType UnboundRunType;
+
+  // Convenience typedefs for bound argument types.
+  typedef UnwrapTraits<P1> Bound1UnwrapTraits;
+  typedef UnwrapTraits<P2> Bound2UnwrapTraits;
+  typedef UnwrapTraits<P3> Bound3UnwrapTraits;
+  typedef UnwrapTraits<P4> Bound4UnwrapTraits;
+  typedef UnwrapTraits<P5> Bound5UnwrapTraits;
+
+  BindState(const Runnable& runnable, const P1& p1, const P2& p2, const P3& p3,
+      const P4& p4, const P5& p5)
+      : BindStateBase(&Destroy),
+        runnable_(runnable),
+        p1_(p1),
+        p2_(p2),
+        p3_(p3),
+        p4_(p4),
+        p5_(p5) {
+    MaybeRefcount<HasIsMethodTag<Runnable>::value, P1>::AddRef(p1_);
+  }
+
+  ~BindState() {    MaybeRefcount<HasIsMethodTag<Runnable>::value,
+      P1>::Release(p1_);  }
+
+  static void Destroy(BindStateBase* self) {
+    delete static_cast<BindState*>(self);
+  }
+
+  RunnableType runnable_;
+  P1 p1_;
+  P2 p2_;
+  P3 p3_;
+  P4 p4_;
+  P5 p5_;
+};
+
+template <typename Runnable, typename RunType, typename P1, typename P2,
+    typename P3, typename P4, typename P5, typename P6>
+struct BindState<Runnable, RunType, void(P1, P2, P3, P4, P5, P6)>
+    : public BindStateBase {
+  typedef Runnable RunnableType;
+  typedef IsWeakMethod<HasIsMethodTag<Runnable>::value, P1> IsWeakCall;
+  typedef Invoker<6, BindState, RunType> InvokerType;
+  typedef typename InvokerType::UnboundRunType UnboundRunType;
+
+  // Convenience typedefs for bound argument types.
+  typedef UnwrapTraits<P1> Bound1UnwrapTraits;
+  typedef UnwrapTraits<P2> Bound2UnwrapTraits;
+  typedef UnwrapTraits<P3> Bound3UnwrapTraits;
+  typedef UnwrapTraits<P4> Bound4UnwrapTraits;
+  typedef UnwrapTraits<P5> Bound5UnwrapTraits;
+  typedef UnwrapTraits<P6> Bound6UnwrapTraits;
+
+  BindState(const Runnable& runnable, const P1& p1, const P2& p2, const P3& p3,
+      const P4& p4, const P5& p5, const P6& p6)
+      : BindStateBase(&Destroy),
+        runnable_(runnable),
+        p1_(p1),
+        p2_(p2),
+        p3_(p3),
+        p4_(p4),
+        p5_(p5),
+        p6_(p6) {
+    MaybeRefcount<HasIsMethodTag<Runnable>::value, P1>::AddRef(p1_);
+  }
+
+  ~BindState() {    MaybeRefcount<HasIsMethodTag<Runnable>::value,
+      P1>::Release(p1_);  }
+
+  static void Destroy(BindStateBase* self) {
+    delete static_cast<BindState*>(self);
+  }
+
+  RunnableType runnable_;
+  P1 p1_;
+  P2 p2_;
+  P3 p3_;
+  P4 p4_;
+  P5 p5_;
+  P6 p6_;
+};
+
+template <typename Runnable, typename RunType, typename P1, typename P2,
+    typename P3, typename P4, typename P5, typename P6, typename P7>
+struct BindState<Runnable, RunType, void(P1, P2, P3, P4, P5, P6, P7)>
+    : public BindStateBase {
+  typedef Runnable RunnableType;
+  typedef IsWeakMethod<HasIsMethodTag<Runnable>::value, P1> IsWeakCall;
+  typedef Invoker<7, BindState, RunType> InvokerType;
+  typedef typename InvokerType::UnboundRunType UnboundRunType;
+
+  // Convenience typedefs for bound argument types.
+  typedef UnwrapTraits<P1> Bound1UnwrapTraits;
+  typedef UnwrapTraits<P2> Bound2UnwrapTraits;
+  typedef UnwrapTraits<P3> Bound3UnwrapTraits;
+  typedef UnwrapTraits<P4> Bound4UnwrapTraits;
+  typedef UnwrapTraits<P5> Bound5UnwrapTraits;
+  typedef UnwrapTraits<P6> Bound6UnwrapTraits;
+  typedef UnwrapTraits<P7> Bound7UnwrapTraits;
+
+  BindState(const Runnable& runnable, const P1& p1, const P2& p2, const P3& p3,
+      const P4& p4, const P5& p5, const P6& p6, const P7& p7)
+      : BindStateBase(&Destroy),
+        runnable_(runnable),
+        p1_(p1),
+        p2_(p2),
+        p3_(p3),
+        p4_(p4),
+        p5_(p5),
+        p6_(p6),
+        p7_(p7) {
+    MaybeRefcount<HasIsMethodTag<Runnable>::value, P1>::AddRef(p1_);
+  }
+
+  ~BindState() {    MaybeRefcount<HasIsMethodTag<Runnable>::value,
+      P1>::Release(p1_);  }
+
+  static void Destroy(BindStateBase* self) {
+    delete static_cast<BindState*>(self);
+  }
+
+  RunnableType runnable_;
+  P1 p1_;
+  P2 p2_;
+  P3 p3_;
+  P4 p4_;
+  P5 p5_;
+  P6 p6_;
+  P7 p7_;
+};
+
+}  // namespace cef_internal
+}  // namespace base
+
+#endif  // CEF_INCLUDE_BASE_INTERNAL_CEF_BIND_INTERNAL_H_
diff --git a/src/include/libcef_/base/internal/cef_bind_internal_win.h b/src/include/libcef_/base/internal/cef_bind_internal_win.h
new file mode 100644
index 0000000..1b061cc
--- /dev/null
+++ b/src/include/libcef_/base/internal/cef_bind_internal_win.h
@@ -0,0 +1,390 @@
+// Copyright (c) 2011 Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Do not include this header file directly. Use base/cef_bind.h instead.
+
+// Specializations of RunnableAdapter<> for Windows specific calling
+// conventions.  Please see base/bind_internal.h for more info.
+
+#ifndef CEF_INCLUDE_BASE_INTERNAL_CEF_BIND_INTERNAL_WIN_H_
+#define CEF_INCLUDE_BASE_INTERNAL_CEF_BIND_INTERNAL_WIN_H_
+
+// In the x64 architecture in Windows, __fastcall, __stdcall, etc, are all
+// the same as __cdecl which would turn the following specializations into
+// multiple definitions.
+#if !defined(ARCH_CPU_X86_64)
+
+namespace base {
+namespace cef_internal {
+
+template <typename Functor>
+class RunnableAdapter;
+
+// __stdcall Function: Arity 0.
+template <typename R>
+class RunnableAdapter<R(__stdcall *)()> {
+ public:
+  typedef R (RunType)();
+
+  explicit RunnableAdapter(R(__stdcall *function)())
+      : function_(function) {
+  }
+
+  R Run() {
+    return function_();
+  }
+
+ private:
+  R (__stdcall *function_)();
+};
+
+// __fastcall Function: Arity 0.
+template <typename R>
+class RunnableAdapter<R(__fastcall *)()> {
+ public:
+  typedef R (RunType)();
+
+  explicit RunnableAdapter(R(__fastcall *function)())
+      : function_(function) {
+  }
+
+  R Run() {
+    return function_();
+  }
+
+ private:
+  R (__fastcall *function_)();
+};
+
+// __stdcall Function: Arity 1.
+template <typename R, typename A1>
+class RunnableAdapter<R(__stdcall *)(A1)> {
+ public:
+  typedef R (RunType)(A1);
+
+  explicit RunnableAdapter(R(__stdcall *function)(A1))
+      : function_(function) {
+  }
+
+  R Run(typename CallbackParamTraits<A1>::ForwardType a1) {
+    return function_(a1);
+  }
+
+ private:
+  R (__stdcall *function_)(A1);
+};
+
+// __fastcall Function: Arity 1.
+template <typename R, typename A1>
+class RunnableAdapter<R(__fastcall *)(A1)> {
+ public:
+  typedef R (RunType)(A1);
+
+  explicit RunnableAdapter(R(__fastcall *function)(A1))
+      : function_(function) {
+  }
+
+  R Run(typename CallbackParamTraits<A1>::ForwardType a1) {
+    return function_(a1);
+  }
+
+ private:
+  R (__fastcall *function_)(A1);
+};
+
+// __stdcall Function: Arity 2.
+template <typename R, typename A1, typename A2>
+class RunnableAdapter<R(__stdcall *)(A1, A2)> {
+ public:
+  typedef R (RunType)(A1, A2);
+
+  explicit RunnableAdapter(R(__stdcall *function)(A1, A2))
+      : function_(function) {
+  }
+
+  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2) {
+    return function_(a1, a2);
+  }
+
+ private:
+  R (__stdcall *function_)(A1, A2);
+};
+
+// __fastcall Function: Arity 2.
+template <typename R, typename A1, typename A2>
+class RunnableAdapter<R(__fastcall *)(A1, A2)> {
+ public:
+  typedef R (RunType)(A1, A2);
+
+  explicit RunnableAdapter(R(__fastcall *function)(A1, A2))
+      : function_(function) {
+  }
+
+  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2) {
+    return function_(a1, a2);
+  }
+
+ private:
+  R (__fastcall *function_)(A1, A2);
+};
+
+// __stdcall Function: Arity 3.
+template <typename R, typename A1, typename A2, typename A3>
+class RunnableAdapter<R(__stdcall *)(A1, A2, A3)> {
+ public:
+  typedef R (RunType)(A1, A2, A3);
+
+  explicit RunnableAdapter(R(__stdcall *function)(A1, A2, A3))
+      : function_(function) {
+  }
+
+  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3) {
+    return function_(a1, a2, a3);
+  }
+
+ private:
+  R (__stdcall *function_)(A1, A2, A3);
+};
+
+// __fastcall Function: Arity 3.
+template <typename R, typename A1, typename A2, typename A3>
+class RunnableAdapter<R(__fastcall *)(A1, A2, A3)> {
+ public:
+  typedef R (RunType)(A1, A2, A3);
+
+  explicit RunnableAdapter(R(__fastcall *function)(A1, A2, A3))
+      : function_(function) {
+  }
+
+  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3) {
+    return function_(a1, a2, a3);
+  }
+
+ private:
+  R (__fastcall *function_)(A1, A2, A3);
+};
+
+// __stdcall Function: Arity 4.
+template <typename R, typename A1, typename A2, typename A3, typename A4>
+class RunnableAdapter<R(__stdcall *)(A1, A2, A3, A4)> {
+ public:
+  typedef R (RunType)(A1, A2, A3, A4);
+
+  explicit RunnableAdapter(R(__stdcall *function)(A1, A2, A3, A4))
+      : function_(function) {
+  }
+
+  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3,
+      typename CallbackParamTraits<A4>::ForwardType a4) {
+    return function_(a1, a2, a3, a4);
+  }
+
+ private:
+  R (__stdcall *function_)(A1, A2, A3, A4);
+};
+
+// __fastcall Function: Arity 4.
+template <typename R, typename A1, typename A2, typename A3, typename A4>
+class RunnableAdapter<R(__fastcall *)(A1, A2, A3, A4)> {
+ public:
+  typedef R (RunType)(A1, A2, A3, A4);
+
+  explicit RunnableAdapter(R(__fastcall *function)(A1, A2, A3, A4))
+      : function_(function) {
+  }
+
+  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3,
+      typename CallbackParamTraits<A4>::ForwardType a4) {
+    return function_(a1, a2, a3, a4);
+  }
+
+ private:
+  R (__fastcall *function_)(A1, A2, A3, A4);
+};
+
+// __stdcall Function: Arity 5.
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5>
+class RunnableAdapter<R(__stdcall *)(A1, A2, A3, A4, A5)> {
+ public:
+  typedef R (RunType)(A1, A2, A3, A4, A5);
+
+  explicit RunnableAdapter(R(__stdcall *function)(A1, A2, A3, A4, A5))
+      : function_(function) {
+  }
+
+  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3,
+      typename CallbackParamTraits<A4>::ForwardType a4,
+      typename CallbackParamTraits<A5>::ForwardType a5) {
+    return function_(a1, a2, a3, a4, a5);
+  }
+
+ private:
+  R (__stdcall *function_)(A1, A2, A3, A4, A5);
+};
+
+// __fastcall Function: Arity 5.
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5>
+class RunnableAdapter<R(__fastcall *)(A1, A2, A3, A4, A5)> {
+ public:
+  typedef R (RunType)(A1, A2, A3, A4, A5);
+
+  explicit RunnableAdapter(R(__fastcall *function)(A1, A2, A3, A4, A5))
+      : function_(function) {
+  }
+
+  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3,
+      typename CallbackParamTraits<A4>::ForwardType a4,
+      typename CallbackParamTraits<A5>::ForwardType a5) {
+    return function_(a1, a2, a3, a4, a5);
+  }
+
+ private:
+  R (__fastcall *function_)(A1, A2, A3, A4, A5);
+};
+
+// __stdcall Function: Arity 6.
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6>
+class RunnableAdapter<R(__stdcall *)(A1, A2, A3, A4, A5, A6)> {
+ public:
+  typedef R (RunType)(A1, A2, A3, A4, A5, A6);
+
+  explicit RunnableAdapter(R(__stdcall *function)(A1, A2, A3, A4, A5, A6))
+      : function_(function) {
+  }
+
+  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3,
+      typename CallbackParamTraits<A4>::ForwardType a4,
+      typename CallbackParamTraits<A5>::ForwardType a5,
+      typename CallbackParamTraits<A6>::ForwardType a6) {
+    return function_(a1, a2, a3, a4, a5, a6);
+  }
+
+ private:
+  R (__stdcall *function_)(A1, A2, A3, A4, A5, A6);
+};
+
+// __fastcall Function: Arity 6.
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6>
+class RunnableAdapter<R(__fastcall *)(A1, A2, A3, A4, A5, A6)> {
+ public:
+  typedef R (RunType)(A1, A2, A3, A4, A5, A6);
+
+  explicit RunnableAdapter(R(__fastcall *function)(A1, A2, A3, A4, A5, A6))
+      : function_(function) {
+  }
+
+  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3,
+      typename CallbackParamTraits<A4>::ForwardType a4,
+      typename CallbackParamTraits<A5>::ForwardType a5,
+      typename CallbackParamTraits<A6>::ForwardType a6) {
+    return function_(a1, a2, a3, a4, a5, a6);
+  }
+
+ private:
+  R (__fastcall *function_)(A1, A2, A3, A4, A5, A6);
+};
+
+// __stdcall Function: Arity 7.
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6, typename A7>
+class RunnableAdapter<R(__stdcall *)(A1, A2, A3, A4, A5, A6, A7)> {
+ public:
+  typedef R (RunType)(A1, A2, A3, A4, A5, A6, A7);
+
+  explicit RunnableAdapter(R(__stdcall *function)(A1, A2, A3, A4, A5, A6, A7))
+      : function_(function) {
+  }
+
+  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3,
+      typename CallbackParamTraits<A4>::ForwardType a4,
+      typename CallbackParamTraits<A5>::ForwardType a5,
+      typename CallbackParamTraits<A6>::ForwardType a6,
+      typename CallbackParamTraits<A7>::ForwardType a7) {
+    return function_(a1, a2, a3, a4, a5, a6, a7);
+  }
+
+ private:
+  R (__stdcall *function_)(A1, A2, A3, A4, A5, A6, A7);
+};
+
+// __fastcall Function: Arity 7.
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6, typename A7>
+class RunnableAdapter<R(__fastcall *)(A1, A2, A3, A4, A5, A6, A7)> {
+ public:
+  typedef R (RunType)(A1, A2, A3, A4, A5, A6, A7);
+
+  explicit RunnableAdapter(R(__fastcall *function)(A1, A2, A3, A4, A5, A6, A7))
+      : function_(function) {
+  }
+
+  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
+      typename CallbackParamTraits<A2>::ForwardType a2,
+      typename CallbackParamTraits<A3>::ForwardType a3,
+      typename CallbackParamTraits<A4>::ForwardType a4,
+      typename CallbackParamTraits<A5>::ForwardType a5,
+      typename CallbackParamTraits<A6>::ForwardType a6,
+      typename CallbackParamTraits<A7>::ForwardType a7) {
+    return function_(a1, a2, a3, a4, a5, a6, a7);
+  }
+
+ private:
+  R (__fastcall *function_)(A1, A2, A3, A4, A5, A6, A7);
+};
+
+}  // namespace cef_internal
+}  // namespace base
+
+#endif  // !defined(ARCH_CPU_X86_64)
+
+#endif  // CEF_INCLUDE_BASE_INTERNAL_CEF_BIND_INTERNAL_WIN_H_
diff --git a/src/include/libcef_/base/internal/cef_callback_internal.h b/src/include/libcef_/base/internal/cef_callback_internal.h
new file mode 100644
index 0000000..e9920c2
--- /dev/null
+++ b/src/include/libcef_/base/internal/cef_callback_internal.h
@@ -0,0 +1,318 @@
+// Copyright (c) 2012 Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Do not include this header file directly. Use base/cef_bind.h or
+// base/cef_callback.h instead.
+
+// This file contains utility functions and classes that help the
+// implementation, and management of the Callback objects.
+
+#ifndef CEF_INCLUDE_BASE_INTERNAL_CEF_CALLBACK_INTERNAL_H_
+#define CEF_INCLUDE_BASE_INTERNAL_CEF_CALLBACK_INTERNAL_H_
+
+#include<stddef.h>
+
+#include"libcef/base/cef_atomic_ref_count.h"
+#include"libcef/base/cef_macros.h"
+#include"libcef/base/cef_ref_counted.h"
+#include"libcef/base/cef_scoped_ptr.h"
+#include"libcef/base/cef_template_util.h"
+
+template <typename T>
+class ScopedVector;
+
+namespace base 
+{
+    namespace cef_internal 
+    {
+        class CallbackBase;
+
+        // At the base level, the only task is to add reference counting data. Don't use
+        // RefCountedThreadSafe since it requires the destructor to be a virtual method.
+        // Creating a vtable for every BindState template instantiation results in a lot
+        // of bloat. Its only task is to call the destructor which can be done with a
+        // function pointer.
+        class BindStateBase 
+        {
+             protected:
+              explicit BindStateBase(void (*destructor)(BindStateBase*))
+                  : ref_count_(0), destructor_(destructor) {}
+              ~BindStateBase() {}
+
+             private:
+              friend class scoped_refptr<BindStateBase>;
+              friend class CallbackBase;
+
+              void AddRef();
+              void Release();
+
+              AtomicRefCount ref_count_;
+
+              // Pointer to a function that will properly destroy |this|.
+              void (*destructor_)(BindStateBase*);
+
+              DISALLOW_COPY_AND_ASSIGN(BindStateBase);
+        };
+
+        // Holds the Callback methods that don't require specialization to reduce
+        // template bloat.
+        class CallbackBase 
+        {
+           public:
+            // Returns true if Callback is null (doesn't refer to anything).
+            bool is_null() const { return bind_state_.get() == NULL; }
+
+            // Returns the Callback into an uninitialized state.
+            void Reset();
+
+           protected:
+            // In C++, it is safe to cast function pointers to function pointers of
+            // another type. It is not okay to use void*. We create a InvokeFuncStorage
+            // that that can store our function pointer, and then cast it back to
+            // the original type on usage.
+            typedef void(*InvokeFuncStorage)(void);
+
+            // Returns true if this callback equals |other|. |other| may be null.
+            bool Equals(const CallbackBase& other) const;
+
+            // Allow initializing of |bind_state_| via the constructor to avoid default
+            // initialization of the scoped_refptr.  We do not also initialize
+            // |polymorphic_invoke_| here because doing a normal assignment in the
+            // derived Callback templates makes for much nicer compiler errors.
+            explicit CallbackBase(BindStateBase* bind_state);
+
+            // Force the destructor to be instantiated inside this translation unit so
+            // that our subclasses will not get inlined versions.  Avoids more template
+            // bloat.
+            ~CallbackBase();
+
+            scoped_refptr<BindStateBase> bind_state_;
+            InvokeFuncStorage polymorphic_invoke_;
+        };
+
+        // A helper template to determine if given type is non-const move-only-type,
+        // i.e. if a value of the given type should be passed via .Pass() in a
+        // destructive way.
+        /*template <typename T> struct IsMoveOnlyType 
+        {
+          template <typename U>
+          static YesType Test(const typename U::MoveOnlyTypeForCPP03*);
+
+          template <typename U>
+          static NoType Test(...);
+
+          static const bool value = sizeof(Test<T>(0)) == sizeof(YesType) &&
+                                    !is_const<T>::value;
+        };*/
+
+        #if defined(__WATCOMC__)
+            // Implementação simplificada para Watcom
+            template <typename T>
+            struct IsMoveOnlyType 
+            {
+                enum { value = 0 }; // Valor padrão para tipos não move-only
+            };
+            
+            // Especializações para tipos move-only conhecidos (se necessário)
+            // template <>
+            // struct IsMoveOnlyType<SeuTipoMoveOnly> {
+            //     enum { value = 1 };
+            // };
+        #else
+            template <typename T> struct IsMoveOnlyType 
+            {
+                template <typename U>
+                static YesType Test(const typename U::MoveOnlyTypeForCPP03*);
+                
+                template <typename U>
+                static NoType Test(...);
+                
+                static const bool value = sizeof(Test<T>(0)) == sizeof(YesType) &&
+                                        !is_const<T>::value;
+            };
+        #endif
+
+        // This is a typetraits object that's used to take an argument type, and
+        // extract a suitable type for storing and forwarding arguments.
+        //
+        // In particular, it strips off references, and converts arrays to
+        // pointers for storage; and it avoids accidentally trying to create a
+        // "reference of a reference" if the argument is a reference type.
+        //
+        // This array type becomes an issue for storage because we are passing bound
+        // parameters by const reference. In this case, we end up passing an actual
+        // array type in the initializer list which C++ does not allow.  This will
+        // break passing of C-string literals.
+        
+        /*template <typename T, bool is_move_only = IsMoveOnlyType<T>::value>
+        struct CallbackParamTraits 
+        {
+          typedef const T& ForwardType;
+          typedef T StorageType;
+        };*/
+
+        #if defined(__WATCOMC__)
+            #define IS_MOVE_ONLY_TYPE(T) false  // Ou implementação alternativa
+        #else
+            #define IS_MOVE_ONLY_TYPE(T) IsMoveOnlyType<T>::value
+        #endif
+
+        template <typename T, bool is_move_only = IS_MOVE_ONLY_TYPE(T)>
+        struct CallbackParamTraits 
+        {
+            typedef const T& ForwardType;
+            typedef T StorageType;
+        };
+
+        // The Storage should almost be impossible to trigger unless someone manually
+        // specifies type of the bind parameters.  However, in case they do,
+        // this will guard against us accidentally storing a reference parameter.
+        //
+        // The ForwardType should only be used for unbound arguments.
+        template <typename T>
+        struct CallbackParamTraits<T&, false> 
+        {
+          typedef T& ForwardType;
+          typedef T StorageType;
+        };
+
+        // Note that for array types, we implicitly add a const in the conversion. This
+        // means that it is not possible to bind array arguments to functions that take
+        // a non-const pointer. Trying to specialize the template based on a "const
+        // T[n]" does not seem to match correctly, so we are stuck with this
+        // restriction.
+        template <typename T, size_t n>
+        struct CallbackParamTraits<T[n], false> 
+        {
+          typedef const T* ForwardType;
+          typedef const T* StorageType;
+        };
+
+        // See comment for CallbackParamTraits<T[n]>.
+        template <typename T>
+        struct CallbackParamTraits<T[], false> 
+        {
+          typedef const T* ForwardType;
+          typedef const T* StorageType;
+        };
+
+        // Parameter traits for movable-but-not-copyable scopers.
+        //
+        // Callback<>/Bind() understands movable-but-not-copyable semantics where
+        // the type cannot be copied but can still have its state destructively
+        // transferred (aka. moved) to another instance of the same type by calling a
+        // helper function.  When used with Bind(), this signifies transferal of the
+        // object's state to the target function.
+        //
+        // For these types, the ForwardType must not be a const reference, or a
+        // reference.  A const reference is inappropriate, and would break const
+        // correctness, because we are implementing a destructive move.  A non-const
+        // reference cannot be used with temporaries which means the result of a
+        // function or a cast would not be usable with Callback<> or Bind().
+        template <typename T>
+        struct CallbackParamTraits<T, true> 
+        {
+          typedef T ForwardType;
+          typedef T StorageType;
+        };
+
+        // CallbackForward() is a very limited simulation of C++11's std::forward()
+        // used by the Callback/Bind system for a set of movable-but-not-copyable
+        // types.  It is needed because forwarding a movable-but-not-copyable
+        // argument to another function requires us to invoke the proper move
+        // operator to create a rvalue version of the type.  The supported types are
+        // whitelisted below as overloads of the CallbackForward() function. The
+        // default template compiles out to be a no-op.
+        //
+        // In C++11, std::forward would replace all uses of this function.  However, it
+        // is impossible to implement a general std::forward with C++11 due to a lack
+        // of rvalue references.
+        //
+        // In addition to Callback/Bind, this is used by PostTaskAndReplyWithResult to
+        // simulate std::forward() and forward the result of one Callback as a
+        // parameter to another callback. This is to support Callbacks that return
+        // the movable-but-not-copyable types whitelisted above.
+        
+        /*template <typename T>
+        typename enable_if<!IsMoveOnlyType<T>::value, T>::type& CallbackForward(T& t) 
+        {
+          return t;
+        }*/
+
+        #if defined(__WATCOMC__)
+            // Helper para enable_if no Watcom
+            template<bool B, class T = void>
+            struct enable_if {};
+            
+            template<class T>
+            struct enable_if<true, T> { typedef T type; };
+        #endif
+
+
+        #if defined(__WATCOMC__)
+            // Implementação para Watcom
+            template <typename T>
+            T& CallbackForward(T& t) 
+            {
+                return t;
+            }
+        #else
+            // Implementação original para outros compiladores
+            template <typename T>
+            typename enable_if<!IsMoveOnlyType<T>::value, T>::type& CallbackForward(T& t) 
+            {
+                return t;
+            }
+        #endif
+
+        /*template <typename T>
+        typename enable_if<IsMoveOnlyType<T>::value, T>::type CallbackForward(T& t) 
+        {
+          return t.Pass();
+        }*/
+
+        #if defined(__WATCOMC__)
+            // Implementação para Watcom (simplificada)
+            template <typename T>
+            T CallbackForwardMoveOnly(T& t) 
+            {
+                return t; // Watcom não suporta move semantics adequadamente
+            }
+        #else
+            template <typename T>
+            typename enable_if<IsMoveOnlyType<T>::value, T>::type CallbackForward(T& t) 
+            {
+                return t.Pass();
+            }
+        #endif
+
+    }  // namespace cef_internal
+}  // namespace base
+
+#endif  // CEF_INCLUDE_BASE_INTERNAL_CEF_CALLBACK_INTERNAL_H_
diff --git a/src/include/libcef_/base/internal/cef_lock_impl.h b/src/include/libcef_/base/internal/cef_lock_impl.h
new file mode 100644
index 0000000..a4e6493
--- /dev/null
+++ b/src/include/libcef_/base/internal/cef_lock_impl.h
@@ -0,0 +1,87 @@
+// Copyright (c) 2011 Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Do not include this header file directly. Use base/cef_lock.h instead.
+
+#ifndef CEF_INCLUDE_BASE_INTERNAL_CEF_LOCK_IMPL_H_
+#define CEF_INCLUDE_BASE_INTERNAL_CEF_LOCK_IMPL_H_
+
+#include"libcef/base/cef_build.h"
+
+#if defined(OS_WIN)
+  #include<windows.h>
+#elif defined(OS_POSIX)
+  #include<pthread.h>
+#endif
+
+#include"libcef/base/cef_macros.h"
+
+namespace base {
+namespace cef_internal {
+
+// This class implements the underlying platform-specific spin-lock mechanism
+// used for the Lock class.  Most users should not use LockImpl directly, but
+// should instead use Lock.
+class LockImpl {
+ public:
+#if defined(OS_WIN)
+  typedef CRITICAL_SECTION NativeHandle;
+#elif defined(OS_POSIX)
+  typedef pthread_mutex_t NativeHandle;
+#endif
+
+  LockImpl();
+  ~LockImpl();
+
+  // If the lock is not held, take it and return true.  If the lock is already
+  // held by something else, immediately return false.
+  bool Try();
+
+  // Take the lock, blocking until it is available if necessary.
+  void Lock();
+
+  // Release the lock.  This must only be called by the lock's holder: after
+  // a successful call to Try, or a call to Lock.
+  void Unlock();
+
+  // Return the native underlying lock.
+  // TODO(awalker): refactor lock and condition variables so that this is
+  // unnecessary.
+  NativeHandle* native_handle() { return &native_handle_; }
+
+ private:
+  NativeHandle native_handle_;
+
+  DISALLOW_COPY_AND_ASSIGN(LockImpl);
+};
+
+}  // namespace cef_internal
+}  // namespace base
+
+#endif  // CEF_INCLUDE_BASE_INTERNAL_CEF_LOCK_IMPL_H_
diff --git a/src/include/libcef_/base/internal/cef_raw_scoped_refptr_mismatch_checker.h b/src/include/libcef_/base/internal/cef_raw_scoped_refptr_mismatch_checker.h
new file mode 100644
index 0000000..4acfe47
--- /dev/null
+++ b/src/include/libcef_/base/internal/cef_raw_scoped_refptr_mismatch_checker.h
@@ -0,0 +1,154 @@
+// Copyright (c) 2011 Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Do not include this header file directly. Use base/cef_callback.h instead.
+
+#ifndef CEF_INCLUDE_BASE_INTERNAL_CEF_RAW_SCOPED_REFPTR_MISMATCH_CHECKER_H_
+#define CEF_INCLUDE_BASE_INTERNAL_CEF_RAW_SCOPED_REFPTR_MISMATCH_CHECKER_H_
+
+#include"libcef/base/cef_build.h"
+#include"libcef/base/cef_ref_counted.h"
+#include"libcef/base/cef_template_util.h"
+#include"libcef/base/cef_tuple.h"
+
+// It is dangerous to post a task with a T* argument where T is a subtype of
+// RefCounted(Base|ThreadSafeBase), since by the time the parameter is used, the
+// object may already have been deleted since it was not held with a
+// scoped_refptr. Example: http://crbug.com/27191
+// The following set of traits are designed to generate a compile error
+// whenever this antipattern is attempted.
+
+namespace base {
+
+namespace cef_internal {
+
+template <typename T>
+struct NeedsScopedRefptrButGetsRawPtr {
+#if defined(OS_WIN)
+  enum {
+    value = base::false_type::value
+  };
+#else
+  enum {
+    // Human readable translation: you needed to be a scoped_refptr if you are a
+    // raw pointer type and are convertible to a RefCounted(Base|ThreadSafeBase)
+    // type.
+    value = (is_pointer<T>::value &&
+             (is_convertible<T, subtle::RefCountedBase*>::value ||
+              is_convertible<T, subtle::RefCountedThreadSafeBase*>::value))
+  };
+#endif
+};
+
+template <typename Params>
+struct ParamsUseScopedRefptrCorrectly {
+  enum { value = 0 };
+};
+
+template <>
+struct ParamsUseScopedRefptrCorrectly<Tuple0> {
+  enum { value = 1 };
+};
+
+template <typename A>
+struct ParamsUseScopedRefptrCorrectly<Tuple1<A> > {
+  enum { value = !NeedsScopedRefptrButGetsRawPtr<A>::value };
+};
+
+template <typename A, typename B>
+struct ParamsUseScopedRefptrCorrectly<Tuple2<A, B> > {
+  enum { value = !(NeedsScopedRefptrButGetsRawPtr<A>::value ||
+                   NeedsScopedRefptrButGetsRawPtr<B>::value) };
+};
+
+template <typename A, typename B, typename C>
+struct ParamsUseScopedRefptrCorrectly<Tuple3<A, B, C> > {
+  enum { value = !(NeedsScopedRefptrButGetsRawPtr<A>::value ||
+                   NeedsScopedRefptrButGetsRawPtr<B>::value ||
+                   NeedsScopedRefptrButGetsRawPtr<C>::value) };
+};
+
+template <typename A, typename B, typename C, typename D>
+struct ParamsUseScopedRefptrCorrectly<Tuple4<A, B, C, D> > {
+  enum { value = !(NeedsScopedRefptrButGetsRawPtr<A>::value ||
+                   NeedsScopedRefptrButGetsRawPtr<B>::value ||
+                   NeedsScopedRefptrButGetsRawPtr<C>::value ||
+                   NeedsScopedRefptrButGetsRawPtr<D>::value) };
+};
+
+template <typename A, typename B, typename C, typename D, typename E>
+struct ParamsUseScopedRefptrCorrectly<Tuple5<A, B, C, D, E> > {
+  enum { value = !(NeedsScopedRefptrButGetsRawPtr<A>::value ||
+                   NeedsScopedRefptrButGetsRawPtr<B>::value ||
+                   NeedsScopedRefptrButGetsRawPtr<C>::value ||
+                   NeedsScopedRefptrButGetsRawPtr<D>::value ||
+                   NeedsScopedRefptrButGetsRawPtr<E>::value) };
+};
+
+template <typename A, typename B, typename C, typename D, typename E,
+          typename F>
+struct ParamsUseScopedRefptrCorrectly<Tuple6<A, B, C, D, E, F> > {
+  enum { value = !(NeedsScopedRefptrButGetsRawPtr<A>::value ||
+                   NeedsScopedRefptrButGetsRawPtr<B>::value ||
+                   NeedsScopedRefptrButGetsRawPtr<C>::value ||
+                   NeedsScopedRefptrButGetsRawPtr<D>::value ||
+                   NeedsScopedRefptrButGetsRawPtr<E>::value ||
+                   NeedsScopedRefptrButGetsRawPtr<F>::value) };
+};
+
+template <typename A, typename B, typename C, typename D, typename E,
+          typename F, typename G>
+struct ParamsUseScopedRefptrCorrectly<Tuple7<A, B, C, D, E, F, G> > {
+  enum { value = !(NeedsScopedRefptrButGetsRawPtr<A>::value ||
+                   NeedsScopedRefptrButGetsRawPtr<B>::value ||
+                   NeedsScopedRefptrButGetsRawPtr<C>::value ||
+                   NeedsScopedRefptrButGetsRawPtr<D>::value ||
+                   NeedsScopedRefptrButGetsRawPtr<E>::value ||
+                   NeedsScopedRefptrButGetsRawPtr<F>::value ||
+                   NeedsScopedRefptrButGetsRawPtr<G>::value) };
+};
+
+template <typename A, typename B, typename C, typename D, typename E,
+          typename F, typename G, typename H>
+struct ParamsUseScopedRefptrCorrectly<Tuple8<A, B, C, D, E, F, G, H> > {
+  enum { value = !(NeedsScopedRefptrButGetsRawPtr<A>::value ||
+                   NeedsScopedRefptrButGetsRawPtr<B>::value ||
+                   NeedsScopedRefptrButGetsRawPtr<C>::value ||
+                   NeedsScopedRefptrButGetsRawPtr<D>::value ||
+                   NeedsScopedRefptrButGetsRawPtr<E>::value ||
+                   NeedsScopedRefptrButGetsRawPtr<F>::value ||
+                   NeedsScopedRefptrButGetsRawPtr<G>::value ||
+                   NeedsScopedRefptrButGetsRawPtr<H>::value) };
+};
+
+}  // namespace cef_internal
+
+}  // namespace base
+
+#endif  // CEF_INCLUDE_BASE_INTERNAL_CEF_RAW_SCOPED_REFPTR_MISMATCH_CHECKER_H_
diff --git a/src/include/libcef_/base/internal/cef_thread_checker_impl.h b/src/include/libcef_/base/internal/cef_thread_checker_impl.h
new file mode 100644
index 0000000..a83ceea
--- /dev/null
+++ b/src/include/libcef_/base/internal/cef_thread_checker_impl.h
@@ -0,0 +1,72 @@
+// Copyright (c) 2011 Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Do not include this header file directly. Use base/cef_thread_checker.h
+// instead.
+
+#ifndef CEF_INCLUDE_BASE_INTERNAL_THREAD_CHECKER_IMPL_H_
+#define CEF_INCLUDE_BASE_INTERNAL_THREAD_CHECKER_IMPL_H_
+
+#include"libcef/base/cef_lock.h"
+#include"libcef/base/cef_platform_thread.h"
+
+namespace base {
+namespace cef_internal {
+
+// Real implementation of ThreadChecker, for use in debug mode, or
+// for temporary use in release mode (e.g. to CHECK on a threading issue
+// seen only in the wild).
+//
+// Note: You should almost always use the ThreadChecker class to get the
+// right version for your build configuration.
+class ThreadCheckerImpl {
+ public:
+  ThreadCheckerImpl();
+  ~ThreadCheckerImpl();
+
+  bool CalledOnValidThread() const;
+
+  // Changes the thread that is checked for in CalledOnValidThread.  This may
+  // be useful when an object may be created on one thread and then used
+  // exclusively on another thread.
+  void DetachFromThread();
+
+ private:
+  void EnsureThreadIdAssigned() const;
+
+  mutable base::Lock lock_;
+  // This is mutable so that CalledOnValidThread can set it.
+  // It's guarded by |lock_|.
+  mutable PlatformThreadRef valid_thread_id_;
+};
+
+}  // namespace cef_internal
+}  // namespace base
+
+#endif  // CEF_INCLUDE_BASE_INTERNAL_THREAD_CHECKER_IMPL_H_
diff --git a/src/include/libcef_/capi/cef_app_capi.h b/src/include/libcef_/capi/cef_app_capi.h
new file mode 100644
index 0000000..6c55f53
--- /dev/null
+++ b/src/include/libcef_/capi/cef_app_capi.h
@@ -0,0 +1,189 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_APP_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_APP_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+#include"libcef/capi/cef_browser_process_handler_capi.h"
+#include"libcef/capi/cef_command_line_capi.h"
+#include"libcef/capi/cef_render_process_handler_capi.h"
+#include"libcef/capi/cef_resource_bundle_handler_capi.h"
+#include"libcef/capi/cef_scheme_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _cef_app_t;
+
+///
+// Implement this structure to provide handler implementations. Methods will be
+// called by the process and/or thread indicated.
+///
+typedef struct _cef_app_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Provides an opportunity to view and/or modify command-line arguments before
+  // processing by CEF and Chromium. The |process_type| value will be NULL for
+  // the browser process. Do not keep a reference to the cef_command_line_t
+  // object passed to this function. The CefSettings.command_line_args_disabled
+  // value can be used to start with an NULL command-line object. Any values
+  // specified in CefSettings that equate to command-line arguments will be set
+  // before this function is called. Be cautious when using this function to
+  // modify command-line arguments for non-browser processes as this may result
+  // in undefined behavior including crashes.
+  ///
+  void (CEF_CALLBACK *on_before_command_line_processing)(
+      struct _cef_app_t* self, const cef_string_t* process_type,
+      struct _cef_command_line_t* command_line);
+
+  ///
+  // Provides an opportunity to register custom schemes. Do not keep a reference
+  // to the |registrar| object. This function is called on the main thread for
+  // each process and the registered schemes should be the same across all
+  // processes.
+  ///
+  void (CEF_CALLBACK *on_register_custom_schemes)(struct _cef_app_t* self,
+      struct _cef_scheme_registrar_t* registrar);
+
+  ///
+  // Return the handler for resource bundle events. If
+  // CefSettings.pack_loading_disabled is true (1) a handler must be returned.
+  // If no handler is returned resources will be loaded from pack files. This
+  // function is called by the browser and render processes on multiple threads.
+  ///
+  struct _cef_resource_bundle_handler_t* (
+      CEF_CALLBACK *get_resource_bundle_handler)(struct _cef_app_t* self);
+
+  ///
+  // Return the handler for functionality specific to the browser process. This
+  // function is called on multiple threads in the browser process.
+  ///
+  struct _cef_browser_process_handler_t* (
+      CEF_CALLBACK *get_browser_process_handler)(struct _cef_app_t* self);
+
+  ///
+  // Return the handler for functionality specific to the render process. This
+  // function is called on the render process main thread.
+  ///
+  struct _cef_render_process_handler_t* (
+      CEF_CALLBACK *get_render_process_handler)(struct _cef_app_t* self);
+} cef_app_t;
+
+
+///
+// This function should be called from the application entry point function to
+// execute a secondary process. It can be used to run secondary processes from
+// the browser client executable (default behavior) or from a separate
+// executable specified by the CefSettings.browser_subprocess_path value. If
+// called for the browser process (identified by no "type" command-line value)
+// it will return immediately with a value of -1. If called for a recognized
+// secondary process it will block until the process should exit and then return
+// the process exit code. The |application| parameter may be NULL. The
+// |windows_sandbox_info| parameter is only used on Windows and may be NULL (see
+// cef_sandbox_win.h for details).
+///
+CEF_EXPORT int cef_execute_process(const struct _cef_main_args_t* args,
+    cef_app_t* application, void* windows_sandbox_info);
+
+///
+// This function should be called on the main application thread to initialize
+// the CEF browser process. The |application| parameter may be NULL. A return
+// value of true (1) indicates that it succeeded and false (0) indicates that it
+// failed. The |windows_sandbox_info| parameter is only used on Windows and may
+// be NULL (see cef_sandbox_win.h for details).
+///
+CEF_EXPORT int cef_initialize(const struct _cef_main_args_t* args,
+    const struct _cef_settings_t* settings, cef_app_t* application,
+    void* windows_sandbox_info);
+
+///
+// This function should be called on the main application thread to shut down
+// the CEF browser process before the application exits.
+///
+CEF_EXPORT void cef_shutdown();
+
+///
+// Perform a single iteration of CEF message loop processing. This function is
+// used to integrate the CEF message loop into an existing application message
+// loop. Care must be taken to balance performance against excessive CPU usage.
+// This function should only be called on the main application thread and only
+// if cef_initialize() is called with a CefSettings.multi_threaded_message_loop
+// value of false (0). This function will not block.
+///
+CEF_EXPORT void cef_do_message_loop_work();
+
+///
+// Run the CEF message loop. Use this function instead of an application-
+// provided message loop to get the best balance between performance and CPU
+// usage. This function should only be called on the main application thread and
+// only if cef_initialize() is called with a
+// CefSettings.multi_threaded_message_loop value of false (0). This function
+// will block until a quit message is received by the system.
+///
+CEF_EXPORT void cef_run_message_loop();
+
+///
+// Quit the CEF message loop that was started by calling cef_run_message_loop().
+// This function should only be called on the main application thread and only
+// if cef_run_message_loop() was used.
+///
+CEF_EXPORT void cef_quit_message_loop();
+
+///
+// Set to true (1) before calling Windows APIs like TrackPopupMenu that enter a
+// modal message loop. Set to false (0) after exiting the modal message loop.
+///
+CEF_EXPORT void cef_set_osmodal_loop(int osModalLoop);
+
+///
+// Call during process startup to enable High-DPI support on Windows 7 or newer.
+// Older versions of Windows should be left DPI-unaware because they do not
+// support DirectWrite and GDI fonts are kerned very badly.
+///
+CEF_EXPORT void cef_enable_highdpi_support();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_APP_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_auth_callback_capi.h b/src/include/libcef_/capi/cef_auth_callback_capi.h
new file mode 100644
index 0000000..64f71eb
--- /dev/null
+++ b/src/include/libcef_/capi/cef_auth_callback_capi.h
@@ -0,0 +1,75 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_AUTH_CALLBACK_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_AUTH_CALLBACK_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Callback structure used for asynchronous continuation of authentication
+// requests.
+///
+typedef struct _cef_auth_callback_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Continue the authentication request.
+  ///
+  void (CEF_CALLBACK *cont)(struct _cef_auth_callback_t* self,
+      const cef_string_t* username, const cef_string_t* password);
+
+  ///
+  // Cancel the authentication request.
+  ///
+  void (CEF_CALLBACK *cancel)(struct _cef_auth_callback_t* self);
+} cef_auth_callback_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_AUTH_CALLBACK_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_base_capi.h b/src/include/libcef_/capi/cef_base_capi.h
new file mode 100644
index 0000000..0574d49
--- /dev/null
+++ b/src/include/libcef_/capi/cef_base_capi.h
@@ -0,0 +1,90 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+#ifndef CEF_INCLUDE_CAPI_CEF_BASE_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_BASE_CAPI_H_
+
+#include<stdint.h>
+
+#include"libcef/internal/cef_export.h"
+#include"libcef/internal/cef_string.h"
+#include"libcef/internal/cef_string_list.h"
+#include"libcef/internal/cef_string_map.h"
+#include"libcef/internal/cef_string_multimap.h"
+#include"libcef/internal/cef_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///
+// Structure defining the reference count implementation functions. All
+// framework structures must include the cef_base_t structure first.
+///
+typedef struct _cef_base_t {
+  ///
+  // Size of the data structure.
+  ///
+  size_t size;
+
+  ///
+  // Called to increment the reference count for the object. Should be called
+  // for every new copy of a pointer to a given object.
+  ///
+  void (CEF_CALLBACK *add_ref)(struct _cef_base_t* self);
+
+  ///
+  // Called to decrement the reference count for the object. If the reference
+  // count falls to 0 the object should self-delete. Returns true (1) if the
+  // resulting reference count is 0.
+  ///
+  int (CEF_CALLBACK *release)(struct _cef_base_t* self);
+
+  ///
+  // Returns true (1) if the current reference count is 1.
+  ///
+  int (CEF_CALLBACK *has_one_ref)(struct _cef_base_t* self);
+} cef_base_t;
+
+
+// Check that the structure |s|, which is defined with a cef_base_t member named
+// |base|, is large enough to contain the specified member |f|.
+#define CEF_MEMBER_EXISTS(s, f)   \
+  ((intptr_t)&((s)->f) - (intptr_t)(s) + sizeof((s)->f) <= \
+  reinterpret_cast<cef_base_t*>(s)->size)
+
+#define CEF_MEMBER_MISSING(s, f)  (!CEF_MEMBER_EXISTS(s, f) || !((s)->f))
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_BASE_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_browser_capi.h b/src/include/libcef_/capi/cef_browser_capi.h
new file mode 100644
index 0000000..9b26388
--- /dev/null
+++ b/src/include/libcef_/capi/cef_browser_capi.h
@@ -0,0 +1,672 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_BROWSER_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_BROWSER_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+#include"libcef/capi/cef_drag_data_capi.h"
+#include"libcef/capi/cef_frame_capi.h"
+#include"libcef/capi/cef_navigation_entry_capi.h"
+#include"libcef/capi/cef_process_message_capi.h"
+#include"libcef/capi/cef_request_context_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _cef_browser_host_t;
+struct _cef_client_t;
+
+///
+// Structure used to represent a browser window. When used in the browser
+// process the functions of this structure may be called on any thread unless
+// otherwise indicated in the comments. When used in the render process the
+// functions of this structure may only be called on the main thread.
+///
+typedef struct _cef_browser_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns the browser host object. This function can only be called in the
+  // browser process.
+  ///
+  struct _cef_browser_host_t* (CEF_CALLBACK *get_host)(
+      struct _cef_browser_t* self);
+
+  ///
+  // Returns true (1) if the browser can navigate backwards.
+  ///
+  int (CEF_CALLBACK *can_go_back)(struct _cef_browser_t* self);
+
+  ///
+  // Navigate backwards.
+  ///
+  void (CEF_CALLBACK *go_back)(struct _cef_browser_t* self);
+
+  ///
+  // Returns true (1) if the browser can navigate forwards.
+  ///
+  int (CEF_CALLBACK *can_go_forward)(struct _cef_browser_t* self);
+
+  ///
+  // Navigate forwards.
+  ///
+  void (CEF_CALLBACK *go_forward)(struct _cef_browser_t* self);
+
+  ///
+  // Returns true (1) if the browser is currently loading.
+  ///
+  int (CEF_CALLBACK *is_loading)(struct _cef_browser_t* self);
+
+  ///
+  // Reload the current page.
+  ///
+  void (CEF_CALLBACK *reload)(struct _cef_browser_t* self);
+
+  ///
+  // Reload the current page ignoring any cached data.
+  ///
+  void (CEF_CALLBACK *reload_ignore_cache)(struct _cef_browser_t* self);
+
+  ///
+  // Stop loading the page.
+  ///
+  void (CEF_CALLBACK *stop_load)(struct _cef_browser_t* self);
+
+  ///
+  // Returns the globally unique identifier for this browser.
+  ///
+  int (CEF_CALLBACK *get_identifier)(struct _cef_browser_t* self);
+
+  ///
+  // Returns true (1) if this object is pointing to the same handle as |that|
+  // object.
+  ///
+  int (CEF_CALLBACK *is_same)(struct _cef_browser_t* self,
+      struct _cef_browser_t* that);
+
+  ///
+  // Returns true (1) if the window is a popup window.
+  ///
+  int (CEF_CALLBACK *is_popup)(struct _cef_browser_t* self);
+
+  ///
+  // Returns true (1) if a document has been loaded in the browser.
+  ///
+  int (CEF_CALLBACK *has_document)(struct _cef_browser_t* self);
+
+  ///
+  // Returns the main (top-level) frame for the browser window.
+  ///
+  struct _cef_frame_t* (CEF_CALLBACK *get_main_frame)(
+      struct _cef_browser_t* self);
+
+  ///
+  // Returns the focused frame for the browser window.
+  ///
+  struct _cef_frame_t* (CEF_CALLBACK *get_focused_frame)(
+      struct _cef_browser_t* self);
+
+  ///
+  // Returns the frame with the specified identifier, or NULL if not found.
+  ///
+  struct _cef_frame_t* (CEF_CALLBACK *get_frame_byident)(
+      struct _cef_browser_t* self, int64 identifier);
+
+  ///
+  // Returns the frame with the specified name, or NULL if not found.
+  ///
+  struct _cef_frame_t* (CEF_CALLBACK *get_frame)(struct _cef_browser_t* self,
+      const cef_string_t* name);
+
+  ///
+  // Returns the number of frames that currently exist.
+  ///
+  size_t (CEF_CALLBACK *get_frame_count)(struct _cef_browser_t* self);
+
+  ///
+  // Returns the identifiers of all existing frames.
+  ///
+  void (CEF_CALLBACK *get_frame_identifiers)(struct _cef_browser_t* self,
+      size_t* identifiersCount, int64* identifiers);
+
+  ///
+  // Returns the names of all existing frames.
+  ///
+  void (CEF_CALLBACK *get_frame_names)(struct _cef_browser_t* self,
+      cef_string_list_t names);
+
+  ///
+  // Send a message to the specified |target_process|. Returns true (1) if the
+  // message was sent successfully.
+  ///
+  int (CEF_CALLBACK *send_process_message)(struct _cef_browser_t* self,
+      cef_process_id_t target_process,
+      struct _cef_process_message_t* message);
+} cef_browser_t;
+
+
+///
+// Callback structure for cef_browser_host_t::RunFileDialog. The functions of
+// this structure will be called on the browser process UI thread.
+///
+typedef struct _cef_run_file_dialog_callback_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Called asynchronously after the file dialog is dismissed.
+  // |selected_accept_filter| is the 0-based index of the value selected from
+  // the accept filters array passed to cef_browser_host_t::RunFileDialog.
+  // |file_paths| will be a single value or a list of values depending on the
+  // dialog mode. If the selection was cancelled |file_paths| will be NULL.
+  ///
+  void (CEF_CALLBACK *on_file_dialog_dismissed)(
+      struct _cef_run_file_dialog_callback_t* self, int selected_accept_filter,
+      cef_string_list_t file_paths);
+} cef_run_file_dialog_callback_t;
+
+
+///
+// Callback structure for cef_browser_host_t::GetNavigationEntries. The
+// functions of this structure will be called on the browser process UI thread.
+///
+typedef struct _cef_navigation_entry_visitor_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Method that will be executed. Do not keep a reference to |entry| outside of
+  // this callback. Return true (1) to continue visiting entries or false (0) to
+  // stop. |current| is true (1) if this entry is the currently loaded
+  // navigation entry. |index| is the 0-based index of this entry and |total| is
+  // the total number of entries.
+  ///
+  int (CEF_CALLBACK *visit)(struct _cef_navigation_entry_visitor_t* self,
+      struct _cef_navigation_entry_t* entry, int current, int index,
+      int total);
+} cef_navigation_entry_visitor_t;
+
+
+///
+// Callback structure for cef_browser_host_t::PrintToPDF. The functions of this
+// structure will be called on the browser process UI thread.
+///
+typedef struct _cef_pdf_print_callback_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Method that will be executed when the PDF printing has completed. |path| is
+  // the output path. |ok| will be true (1) if the printing completed
+  // successfully or false (0) otherwise.
+  ///
+  void (CEF_CALLBACK *on_pdf_print_finished)(
+      struct _cef_pdf_print_callback_t* self, const cef_string_t* path,
+      int ok);
+} cef_pdf_print_callback_t;
+
+
+///
+// Structure used to represent the browser process aspects of a browser window.
+// The functions of this structure can only be called in the browser process.
+// They may be called on any thread in that process unless otherwise indicated
+// in the comments.
+///
+typedef struct _cef_browser_host_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns the hosted browser object.
+  ///
+  struct _cef_browser_t* (CEF_CALLBACK *get_browser)(
+      struct _cef_browser_host_t* self);
+
+  ///
+  // Request that the browser close. The JavaScript 'onbeforeunload' event will
+  // be fired. If |force_close| is false (0) the event handler, if any, will be
+  // allowed to prompt the user and the user can optionally cancel the close. If
+  // |force_close| is true (1) the prompt will not be displayed and the close
+  // will proceed. Results in a call to cef_life_span_handler_t::do_close() if
+  // the event handler allows the close or if |force_close| is true (1). See
+  // cef_life_span_handler_t::do_close() documentation for additional usage
+  // information.
+  ///
+  void (CEF_CALLBACK *close_browser)(struct _cef_browser_host_t* self,
+      int force_close);
+
+  ///
+  // Set whether the browser is focused.
+  ///
+  void (CEF_CALLBACK *set_focus)(struct _cef_browser_host_t* self, int focus);
+
+  ///
+  // Set whether the window containing the browser is visible
+  // (minimized/unminimized, app hidden/unhidden, etc). Only used on Mac OS X.
+  ///
+  void (CEF_CALLBACK *set_window_visibility)(struct _cef_browser_host_t* self,
+      int visible);
+
+  ///
+  // Retrieve the window handle for this browser.
+  ///
+  cef_window_handle_t (CEF_CALLBACK *get_window_handle)(
+      struct _cef_browser_host_t* self);
+
+  ///
+  // Retrieve the window handle of the browser that opened this browser. Will
+  // return NULL for non-popup windows. This function can be used in combination
+  // with custom handling of modal windows.
+  ///
+  cef_window_handle_t (CEF_CALLBACK *get_opener_window_handle)(
+      struct _cef_browser_host_t* self);
+
+  ///
+  // Returns the client for this browser.
+  ///
+  struct _cef_client_t* (CEF_CALLBACK *get_client)(
+      struct _cef_browser_host_t* self);
+
+  ///
+  // Returns the request context for this browser.
+  ///
+  struct _cef_request_context_t* (CEF_CALLBACK *get_request_context)(
+      struct _cef_browser_host_t* self);
+
+  ///
+  // Get the current zoom level. The default zoom level is 0.0. This function
+  // can only be called on the UI thread.
+  ///
+  double (CEF_CALLBACK *get_zoom_level)(struct _cef_browser_host_t* self);
+
+  ///
+  // Change the zoom level to the specified value. Specify 0.0 to reset the zoom
+  // level. If called on the UI thread the change will be applied immediately.
+  // Otherwise, the change will be applied asynchronously on the UI thread.
+  ///
+  void (CEF_CALLBACK *set_zoom_level)(struct _cef_browser_host_t* self,
+      double zoomLevel);
+
+  ///
+  // Call to run a file chooser dialog. Only a single file chooser dialog may be
+  // pending at any given time. |mode| represents the type of dialog to display.
+  // |title| to the title to be used for the dialog and may be NULL to show the
+  // default title ("Open" or "Save" depending on the mode). |default_file_path|
+  // is the path with optional directory and/or file name component that will be
+  // initially selected in the dialog. |accept_filters| are used to restrict the
+  // selectable file types and may any combination of (a) valid lower-cased MIME
+  // types (e.g. "text/*" or "image/*"), (b) individual file extensions (e.g.
+  // ".txt" or ".png"), or (c) combined description and file extension delimited
+  // using "|" and ";" (e.g. "Image Types|.png;.gif;.jpg").
+  // |selected_accept_filter| is the 0-based index of the filter that will be
+  // selected by default. |callback| will be executed after the dialog is
+  // dismissed or immediately if another dialog is already pending. The dialog
+  // will be initiated asynchronously on the UI thread.
+  ///
+  void (CEF_CALLBACK *run_file_dialog)(struct _cef_browser_host_t* self,
+      cef_file_dialog_mode_t mode, const cef_string_t* title,
+      const cef_string_t* default_file_path, cef_string_list_t accept_filters,
+      int selected_accept_filter,
+      struct _cef_run_file_dialog_callback_t* callback);
+
+  ///
+  // Download the file at |url| using cef_download_handler_t.
+  ///
+  void (CEF_CALLBACK *start_download)(struct _cef_browser_host_t* self,
+      const cef_string_t* url);
+
+  ///
+  // Print the current browser contents.
+  ///
+  void (CEF_CALLBACK *print)(struct _cef_browser_host_t* self);
+
+  ///
+  // Print the current browser contents to the PDF file specified by |path| and
+  // execute |callback| on completion. The caller is responsible for deleting
+  // |path| when done. For PDF printing to work on Linux you must implement the
+  // cef_print_handler_t::GetPdfPaperSize function.
+  ///
+  void (CEF_CALLBACK *print_to_pdf)(struct _cef_browser_host_t* self,
+      const cef_string_t* path,
+      const struct _cef_pdf_print_settings_t* settings,
+      struct _cef_pdf_print_callback_t* callback);
+
+  ///
+  // Search for |searchText|. |identifier| can be used to have multiple searches
+  // running simultaniously. |forward| indicates whether to search forward or
+  // backward within the page. |matchCase| indicates whether the search should
+  // be case-sensitive. |findNext| indicates whether this is the first request
+  // or a follow-up. The cef_find_handler_t instance, if any, returned via
+  // cef_client_t::GetFindHandler will be called to report find results.
+  ///
+  void (CEF_CALLBACK *find)(struct _cef_browser_host_t* self, int identifier,
+      const cef_string_t* searchText, int forward, int matchCase,
+      int findNext);
+
+  ///
+  // Cancel all searches that are currently going on.
+  ///
+  void (CEF_CALLBACK *stop_finding)(struct _cef_browser_host_t* self,
+      int clearSelection);
+
+  ///
+  // Open developer tools in its own window. If |inspect_element_at| is non-
+  // NULL the element at the specified (x,y) location will be inspected.
+  ///
+  void (CEF_CALLBACK *show_dev_tools)(struct _cef_browser_host_t* self,
+      const struct _cef_window_info_t* windowInfo,
+      struct _cef_client_t* client,
+      const struct _cef_browser_settings_t* settings,
+      const cef_point_t* inspect_element_at);
+
+  ///
+  // Explicitly close the developer tools window if one exists for this browser
+  // instance.
+  ///
+  void (CEF_CALLBACK *close_dev_tools)(struct _cef_browser_host_t* self);
+
+  ///
+  // Retrieve a snapshot of current navigation entries as values sent to the
+  // specified visitor. If |current_only| is true (1) only the current
+  // navigation entry will be sent, otherwise all navigation entries will be
+  // sent.
+  ///
+  void (CEF_CALLBACK *get_navigation_entries)(struct _cef_browser_host_t* self,
+      struct _cef_navigation_entry_visitor_t* visitor, int current_only);
+
+  ///
+  // Set whether mouse cursor change is disabled.
+  ///
+  void (CEF_CALLBACK *set_mouse_cursor_change_disabled)(
+      struct _cef_browser_host_t* self, int disabled);
+
+  ///
+  // Returns true (1) if mouse cursor change is disabled.
+  ///
+  int (CEF_CALLBACK *is_mouse_cursor_change_disabled)(
+      struct _cef_browser_host_t* self);
+
+  ///
+  // If a misspelled word is currently selected in an editable node calling this
+  // function will replace it with the specified |word|.
+  ///
+  void (CEF_CALLBACK *replace_misspelling)(struct _cef_browser_host_t* self,
+      const cef_string_t* word);
+
+  ///
+  // Add the specified |word| to the spelling dictionary.
+  ///
+  void (CEF_CALLBACK *add_word_to_dictionary)(struct _cef_browser_host_t* self,
+      const cef_string_t* word);
+
+  ///
+  // Returns true (1) if window rendering is disabled.
+  ///
+  int (CEF_CALLBACK *is_window_rendering_disabled)(
+      struct _cef_browser_host_t* self);
+
+  ///
+  // Notify the browser that the widget has been resized. The browser will first
+  // call cef_render_handler_t::GetViewRect to get the new size and then call
+  // cef_render_handler_t::OnPaint asynchronously with the updated regions. This
+  // function is only used when window rendering is disabled.
+  ///
+  void (CEF_CALLBACK *was_resized)(struct _cef_browser_host_t* self);
+
+  ///
+  // Notify the browser that it has been hidden or shown. Layouting and
+  // cef_render_handler_t::OnPaint notification will stop when the browser is
+  // hidden. This function is only used when window rendering is disabled.
+  ///
+  void (CEF_CALLBACK *was_hidden)(struct _cef_browser_host_t* self, int hidden);
+
+  ///
+  // Send a notification to the browser that the screen info has changed. The
+  // browser will then call cef_render_handler_t::GetScreenInfo to update the
+  // screen information with the new values. This simulates moving the webview
+  // window from one display to another, or changing the properties of the
+  // current display. This function is only used when window rendering is
+  // disabled.
+  ///
+  void (CEF_CALLBACK *notify_screen_info_changed)(
+      struct _cef_browser_host_t* self);
+
+  ///
+  // Invalidate the view. The browser will call cef_render_handler_t::OnPaint
+  // asynchronously. This function is only used when window rendering is
+  // disabled.
+  ///
+  void (CEF_CALLBACK *invalidate)(struct _cef_browser_host_t* self,
+      cef_paint_element_type_t type);
+
+  ///
+  // Send a key event to the browser.
+  ///
+  void (CEF_CALLBACK *send_key_event)(struct _cef_browser_host_t* self,
+      const struct _cef_key_event_t* event);
+
+  ///
+  // Send a mouse click event to the browser. The |x| and |y| coordinates are
+  // relative to the upper-left corner of the view.
+  ///
+  void (CEF_CALLBACK *send_mouse_click_event)(struct _cef_browser_host_t* self,
+      const struct _cef_mouse_event_t* event, cef_mouse_button_type_t type,
+      int mouseUp, int clickCount);
+
+  ///
+  // Send a mouse move event to the browser. The |x| and |y| coordinates are
+  // relative to the upper-left corner of the view.
+  ///
+  void (CEF_CALLBACK *send_mouse_move_event)(struct _cef_browser_host_t* self,
+      const struct _cef_mouse_event_t* event, int mouseLeave);
+
+  ///
+  // Send a mouse wheel event to the browser. The |x| and |y| coordinates are
+  // relative to the upper-left corner of the view. The |deltaX| and |deltaY|
+  // values represent the movement delta in the X and Y directions respectively.
+  // In order to scroll inside select popups with window rendering disabled
+  // cef_render_handler_t::GetScreenPoint should be implemented properly.
+  ///
+  void (CEF_CALLBACK *send_mouse_wheel_event)(struct _cef_browser_host_t* self,
+      const struct _cef_mouse_event_t* event, int deltaX, int deltaY);
+
+  ///
+  // Send a focus event to the browser.
+  ///
+  void (CEF_CALLBACK *send_focus_event)(struct _cef_browser_host_t* self,
+      int setFocus);
+
+  ///
+  // Send a capture lost event to the browser.
+  ///
+  void (CEF_CALLBACK *send_capture_lost_event)(
+      struct _cef_browser_host_t* self);
+
+  ///
+  // Notify the browser that the window hosting it is about to be moved or
+  // resized. This function is only used on Windows and Linux.
+  ///
+  void (CEF_CALLBACK *notify_move_or_resize_started)(
+      struct _cef_browser_host_t* self);
+
+  ///
+  // Returns the maximum rate in frames per second (fps) that
+  // cef_render_handler_t:: OnPaint will be called for a windowless browser. The
+  // actual fps may be lower if the browser cannot generate frames at the
+  // requested rate. The minimum value is 1 and the maximum value is 60 (default
+  // 30). This function can only be called on the UI thread.
+  ///
+  int (CEF_CALLBACK *get_windowless_frame_rate)(
+      struct _cef_browser_host_t* self);
+
+  ///
+  // Set the maximum rate in frames per second (fps) that cef_render_handler_t::
+  // OnPaint will be called for a windowless browser. The actual fps may be
+  // lower if the browser cannot generate frames at the requested rate. The
+  // minimum value is 1 and the maximum value is 60 (default 30). Can also be
+  // set at browser creation via cef_browser_tSettings.windowless_frame_rate.
+  ///
+  void (CEF_CALLBACK *set_windowless_frame_rate)(
+      struct _cef_browser_host_t* self, int frame_rate);
+
+  ///
+  // Get the NSTextInputContext implementation for enabling IME on Mac when
+  // window rendering is disabled.
+  ///
+  cef_text_input_context_t (CEF_CALLBACK *get_nstext_input_context)(
+      struct _cef_browser_host_t* self);
+
+  ///
+  // Handles a keyDown event prior to passing it through the NSTextInputClient
+  // machinery.
+  ///
+  void (CEF_CALLBACK *handle_key_event_before_text_input_client)(
+      struct _cef_browser_host_t* self, cef_event_handle_t keyEvent);
+
+  ///
+  // Performs any additional actions after NSTextInputClient handles the event.
+  ///
+  void (CEF_CALLBACK *handle_key_event_after_text_input_client)(
+      struct _cef_browser_host_t* self, cef_event_handle_t keyEvent);
+
+  ///
+  // Call this function when the user drags the mouse into the web view (before
+  // calling DragTargetDragOver/DragTargetLeave/DragTargetDrop). |drag_data|
+  // should not contain file contents as this type of data is not allowed to be
+  // dragged into the web view. File contents can be removed using
+  // cef_drag_data_t::ResetFileContents (for example, if |drag_data| comes from
+  // cef_render_handler_t::StartDragging). This function is only used when
+  // window rendering is disabled.
+  ///
+  void (CEF_CALLBACK *drag_target_drag_enter)(struct _cef_browser_host_t* self,
+      struct _cef_drag_data_t* drag_data,
+      const struct _cef_mouse_event_t* event,
+      cef_drag_operations_mask_t allowed_ops);
+
+  ///
+  // Call this function each time the mouse is moved across the web view during
+  // a drag operation (after calling DragTargetDragEnter and before calling
+  // DragTargetDragLeave/DragTargetDrop). This function is only used when window
+  // rendering is disabled.
+  ///
+  void (CEF_CALLBACK *drag_target_drag_over)(struct _cef_browser_host_t* self,
+      const struct _cef_mouse_event_t* event,
+      cef_drag_operations_mask_t allowed_ops);
+
+  ///
+  // Call this function when the user drags the mouse out of the web view (after
+  // calling DragTargetDragEnter). This function is only used when window
+  // rendering is disabled.
+  ///
+  void (CEF_CALLBACK *drag_target_drag_leave)(struct _cef_browser_host_t* self);
+
+  ///
+  // Call this function when the user completes the drag operation by dropping
+  // the object onto the web view (after calling DragTargetDragEnter). The
+  // object being dropped is |drag_data|, given as an argument to the previous
+  // DragTargetDragEnter call. This function is only used when window rendering
+  // is disabled.
+  ///
+  void (CEF_CALLBACK *drag_target_drop)(struct _cef_browser_host_t* self,
+      const struct _cef_mouse_event_t* event);
+
+  ///
+  // Call this function when the drag operation started by a
+  // cef_render_handler_t::StartDragging call has ended either in a drop or by
+  // being cancelled. |x| and |y| are mouse coordinates relative to the upper-
+  // left corner of the view. If the web view is both the drag source and the
+  // drag target then all DragTarget* functions should be called before
+  // DragSource* mthods. This function is only used when window rendering is
+  // disabled.
+  ///
+  void (CEF_CALLBACK *drag_source_ended_at)(struct _cef_browser_host_t* self,
+      int x, int y, cef_drag_operations_mask_t op);
+
+  ///
+  // Call this function when the drag operation started by a
+  // cef_render_handler_t::StartDragging call has completed. This function may
+  // be called immediately without first calling DragSourceEndedAt to cancel a
+  // drag operation. If the web view is both the drag source and the drag target
+  // then all DragTarget* functions should be called before DragSource* mthods.
+  // This function is only used when window rendering is disabled.
+  ///
+  void (CEF_CALLBACK *drag_source_system_drag_ended)(
+      struct _cef_browser_host_t* self);
+} cef_browser_host_t;
+
+
+///
+// Create a new browser window using the window parameters specified by
+// |windowInfo|. All values will be copied internally and the actual window will
+// be created on the UI thread. If |request_context| is NULL the global request
+// context will be used. This function can be called on any browser process
+// thread and will not block.
+///
+CEF_EXPORT int cef_browser_host_create_browser(
+    const cef_window_info_t* windowInfo, struct _cef_client_t* client,
+    const cef_string_t* url, const struct _cef_browser_settings_t* settings,
+    struct _cef_request_context_t* request_context);
+
+///
+// Create a new browser window using the window parameters specified by
+// |windowInfo|. If |request_context| is NULL the global request context will be
+// used. This function can only be called on the browser process UI thread.
+///
+CEF_EXPORT cef_browser_t* cef_browser_host_create_browser_sync(
+    const cef_window_info_t* windowInfo, struct _cef_client_t* client,
+    const cef_string_t* url, const struct _cef_browser_settings_t* settings,
+    struct _cef_request_context_t* request_context);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_BROWSER_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_browser_process_handler_capi.h b/src/include/libcef_/capi/cef_browser_process_handler_capi.h
new file mode 100644
index 0000000..7c7a711
--- /dev/null
+++ b/src/include/libcef_/capi/cef_browser_process_handler_capi.h
@@ -0,0 +1,104 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_BROWSER_PROCESS_HANDLER_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_BROWSER_PROCESS_HANDLER_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+#include"libcef/capi/cef_command_line_capi.h"
+#include"libcef/capi/cef_print_handler_capi.h"
+#include"libcef/capi/cef_values_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Structure used to implement browser process callbacks. The functions of this
+// structure will be called on the browser process main thread unless otherwise
+// indicated.
+///
+typedef struct _cef_browser_process_handler_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Called on the browser process UI thread immediately after the CEF context
+  // has been initialized.
+  ///
+  void (CEF_CALLBACK *on_context_initialized)(
+      struct _cef_browser_process_handler_t* self);
+
+  ///
+  // Called before a child process is launched. Will be called on the browser
+  // process UI thread when launching a render process and on the browser
+  // process IO thread when launching a GPU or plugin process. Provides an
+  // opportunity to modify the child process command line. Do not keep a
+  // reference to |command_line| outside of this function.
+  ///
+  void (CEF_CALLBACK *on_before_child_process_launch)(
+      struct _cef_browser_process_handler_t* self,
+      struct _cef_command_line_t* command_line);
+
+  ///
+  // Called on the browser process IO thread after the main thread has been
+  // created for a new render process. Provides an opportunity to specify extra
+  // information that will be passed to
+  // cef_render_process_handler_t::on_render_thread_created() in the render
+  // process. Do not keep a reference to |extra_info| outside of this function.
+  ///
+  void (CEF_CALLBACK *on_render_process_thread_created)(
+      struct _cef_browser_process_handler_t* self,
+      struct _cef_list_value_t* extra_info);
+
+  ///
+  // Return the handler for printing on Linux. If a print handler is not
+  // provided then printing will not be supported on the Linux platform.
+  ///
+  struct _cef_print_handler_t* (CEF_CALLBACK *get_print_handler)(
+      struct _cef_browser_process_handler_t* self);
+} cef_browser_process_handler_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_BROWSER_PROCESS_HANDLER_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_callback_capi.h b/src/include/libcef_/capi/cef_callback_capi.h
new file mode 100644
index 0000000..b56d588
--- /dev/null
+++ b/src/include/libcef_/capi/cef_callback_capi.h
@@ -0,0 +1,89 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_CALLBACK_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_CALLBACK_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Generic callback structure used for asynchronous continuation.
+///
+typedef struct _cef_callback_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Continue processing.
+  ///
+  void (CEF_CALLBACK *cont)(struct _cef_callback_t* self);
+
+  ///
+  // Cancel processing.
+  ///
+  void (CEF_CALLBACK *cancel)(struct _cef_callback_t* self);
+} cef_callback_t;
+
+
+///
+// Generic callback structure used for asynchronous completion.
+///
+typedef struct _cef_completion_callback_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Method that will be called once the task is complete.
+  ///
+  void (CEF_CALLBACK *on_complete)(struct _cef_completion_callback_t* self);
+} cef_completion_callback_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_CALLBACK_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_client_capi.h b/src/include/libcef_/capi/cef_client_capi.h
new file mode 100644
index 0000000..b09e197
--- /dev/null
+++ b/src/include/libcef_/capi/cef_client_capi.h
@@ -0,0 +1,176 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_CLIENT_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_CLIENT_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+#include"libcef/capi/cef_context_menu_handler_capi.h"
+#include"libcef/capi/cef_dialog_handler_capi.h"
+#include"libcef/capi/cef_display_handler_capi.h"
+#include"libcef/capi/cef_download_handler_capi.h"
+#include"libcef/capi/cef_drag_handler_capi.h"
+#include"libcef/capi/cef_find_handler_capi.h"
+#include"libcef/capi/cef_focus_handler_capi.h"
+#include"libcef/capi/cef_geolocation_handler_capi.h"
+#include"libcef/capi/cef_jsdialog_handler_capi.h"
+#include"libcef/capi/cef_keyboard_handler_capi.h"
+#include"libcef/capi/cef_life_span_handler_capi.h"
+#include"libcef/capi/cef_load_handler_capi.h"
+#include"libcef/capi/cef_process_message_capi.h"
+#include"libcef/capi/cef_render_handler_capi.h"
+#include"libcef/capi/cef_request_handler_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Implement this structure to provide handler implementations.
+///
+typedef struct _cef_client_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Return the handler for context menus. If no handler is provided the default
+  // implementation will be used.
+  ///
+  struct _cef_context_menu_handler_t* (CEF_CALLBACK *get_context_menu_handler)(
+      struct _cef_client_t* self);
+
+  ///
+  // Return the handler for dialogs. If no handler is provided the default
+  // implementation will be used.
+  ///
+  struct _cef_dialog_handler_t* (CEF_CALLBACK *get_dialog_handler)(
+      struct _cef_client_t* self);
+
+  ///
+  // Return the handler for browser display state events.
+  ///
+  struct _cef_display_handler_t* (CEF_CALLBACK *get_display_handler)(
+      struct _cef_client_t* self);
+
+  ///
+  // Return the handler for download events. If no handler is returned downloads
+  // will not be allowed.
+  ///
+  struct _cef_download_handler_t* (CEF_CALLBACK *get_download_handler)(
+      struct _cef_client_t* self);
+
+  ///
+  // Return the handler for drag events.
+  ///
+  struct _cef_drag_handler_t* (CEF_CALLBACK *get_drag_handler)(
+      struct _cef_client_t* self);
+
+  ///
+  // Return the handler for find result events.
+  ///
+  struct _cef_find_handler_t* (CEF_CALLBACK *get_find_handler)(
+      struct _cef_client_t* self);
+
+  ///
+  // Return the handler for focus events.
+  ///
+  struct _cef_focus_handler_t* (CEF_CALLBACK *get_focus_handler)(
+      struct _cef_client_t* self);
+
+  ///
+  // Return the handler for geolocation permissions requests. If no handler is
+  // provided geolocation access will be denied by default.
+  ///
+  struct _cef_geolocation_handler_t* (CEF_CALLBACK *get_geolocation_handler)(
+      struct _cef_client_t* self);
+
+  ///
+  // Return the handler for JavaScript dialogs. If no handler is provided the
+  // default implementation will be used.
+  ///
+  struct _cef_jsdialog_handler_t* (CEF_CALLBACK *get_jsdialog_handler)(
+      struct _cef_client_t* self);
+
+  ///
+  // Return the handler for keyboard events.
+  ///
+  struct _cef_keyboard_handler_t* (CEF_CALLBACK *get_keyboard_handler)(
+      struct _cef_client_t* self);
+
+  ///
+  // Return the handler for browser life span events.
+  ///
+  struct _cef_life_span_handler_t* (CEF_CALLBACK *get_life_span_handler)(
+      struct _cef_client_t* self);
+
+  ///
+  // Return the handler for browser load status events.
+  ///
+  struct _cef_load_handler_t* (CEF_CALLBACK *get_load_handler)(
+      struct _cef_client_t* self);
+
+  ///
+  // Return the handler for off-screen rendering events.
+  ///
+  struct _cef_render_handler_t* (CEF_CALLBACK *get_render_handler)(
+      struct _cef_client_t* self);
+
+  ///
+  // Return the handler for browser request events.
+  ///
+  struct _cef_request_handler_t* (CEF_CALLBACK *get_request_handler)(
+      struct _cef_client_t* self);
+
+  ///
+  // Called when a new message is received from a different process. Return true
+  // (1) if the message was handled or false (0) otherwise. Do not keep a
+  // reference to or attempt to access the message outside of this callback.
+  ///
+  int (CEF_CALLBACK *on_process_message_received)(struct _cef_client_t* self,
+      struct _cef_browser_t* browser, cef_process_id_t source_process,
+      struct _cef_process_message_t* message);
+} cef_client_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_CLIENT_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_command_line_capi.h b/src/include/libcef_/capi/cef_command_line_capi.h
new file mode 100644
index 0000000..dab9ad6
--- /dev/null
+++ b/src/include/libcef_/capi/cef_command_line_capi.h
@@ -0,0 +1,213 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_COMMAND_LINE_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_COMMAND_LINE_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Structure used to create and/or parse command line arguments. Arguments with
+// '--', '-' and, on Windows, '/' prefixes are considered switches. Switches
+// will always precede any arguments without switch prefixes. Switches can
+// optionally have a value specified using the '=' delimiter (e.g.
+// "-switch=value"). An argument of "--" will terminate switch parsing with all
+// subsequent tokens, regardless of prefix, being interpreted as non-switch
+// arguments. Switch names are considered case-insensitive. This structure can
+// be used before cef_initialize() is called.
+///
+typedef struct _cef_command_line_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns true (1) if this object is valid. Do not call any other functions
+  // if this function returns false (0).
+  ///
+  int (CEF_CALLBACK *is_valid)(struct _cef_command_line_t* self);
+
+  ///
+  // Returns true (1) if the values of this object are read-only. Some APIs may
+  // expose read-only objects.
+  ///
+  int (CEF_CALLBACK *is_read_only)(struct _cef_command_line_t* self);
+
+  ///
+  // Returns a writable copy of this object.
+  ///
+  struct _cef_command_line_t* (CEF_CALLBACK *copy)(
+      struct _cef_command_line_t* self);
+
+  ///
+  // Initialize the command line with the specified |argc| and |argv| values.
+  // The first argument must be the name of the program. This function is only
+  // supported on non-Windows platforms.
+  ///
+  void (CEF_CALLBACK *init_from_argv)(struct _cef_command_line_t* self,
+      int argc, const char* const* argv);
+
+  ///
+  // Initialize the command line with the string returned by calling
+  // GetCommandLineW(). This function is only supported on Windows.
+  ///
+  void (CEF_CALLBACK *init_from_string)(struct _cef_command_line_t* self,
+      const cef_string_t* command_line);
+
+  ///
+  // Reset the command-line switches and arguments but leave the program
+  // component unchanged.
+  ///
+  void (CEF_CALLBACK *reset)(struct _cef_command_line_t* self);
+
+  ///
+  // Retrieve the original command line string as a vector of strings. The argv
+  // array: { program, [(--|-|/)switch[=value]]*, [--], [argument]* }
+  ///
+  void (CEF_CALLBACK *get_argv)(struct _cef_command_line_t* self,
+      cef_string_list_t argv);
+
+  ///
+  // Constructs and returns the represented command line string. Use this
+  // function cautiously because quoting behavior is unclear.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_command_line_string)(
+      struct _cef_command_line_t* self);
+
+  ///
+  // Get the program part of the command line string (the first item).
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_program)(
+      struct _cef_command_line_t* self);
+
+  ///
+  // Set the program part of the command line string (the first item).
+  ///
+  void (CEF_CALLBACK *set_program)(struct _cef_command_line_t* self,
+      const cef_string_t* program);
+
+  ///
+  // Returns true (1) if the command line has switches.
+  ///
+  int (CEF_CALLBACK *has_switches)(struct _cef_command_line_t* self);
+
+  ///
+  // Returns true (1) if the command line contains the given switch.
+  ///
+  int (CEF_CALLBACK *has_switch)(struct _cef_command_line_t* self,
+      const cef_string_t* name);
+
+  ///
+  // Returns the value associated with the given switch. If the switch has no
+  // value or isn't present this function returns the NULL string.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_switch_value)(
+      struct _cef_command_line_t* self, const cef_string_t* name);
+
+  ///
+  // Returns the map of switch names and values. If a switch has no value an
+  // NULL string is returned.
+  ///
+  void (CEF_CALLBACK *get_switches)(struct _cef_command_line_t* self,
+      cef_string_map_t switches);
+
+  ///
+  // Add a switch to the end of the command line. If the switch has no value
+  // pass an NULL value string.
+  ///
+  void (CEF_CALLBACK *append_switch)(struct _cef_command_line_t* self,
+      const cef_string_t* name);
+
+  ///
+  // Add a switch with the specified value to the end of the command line.
+  ///
+  void (CEF_CALLBACK *append_switch_with_value)(
+      struct _cef_command_line_t* self, const cef_string_t* name,
+      const cef_string_t* value);
+
+  ///
+  // True if there are remaining command line arguments.
+  ///
+  int (CEF_CALLBACK *has_arguments)(struct _cef_command_line_t* self);
+
+  ///
+  // Get the remaining command line arguments.
+  ///
+  void (CEF_CALLBACK *get_arguments)(struct _cef_command_line_t* self,
+      cef_string_list_t arguments);
+
+  ///
+  // Add an argument to the end of the command line.
+  ///
+  void (CEF_CALLBACK *append_argument)(struct _cef_command_line_t* self,
+      const cef_string_t* argument);
+
+  ///
+  // Insert a command before the current command. Common for debuggers, like
+  // "valgrind" or "gdb --args".
+  ///
+  void (CEF_CALLBACK *prepend_wrapper)(struct _cef_command_line_t* self,
+      const cef_string_t* wrapper);
+} cef_command_line_t;
+
+
+///
+// Create a new cef_command_line_t instance.
+///
+CEF_EXPORT cef_command_line_t* cef_command_line_create();
+
+///
+// Returns the singleton global cef_command_line_t object. The returned object
+// will be read-only.
+///
+CEF_EXPORT cef_command_line_t* cef_command_line_get_global();
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_COMMAND_LINE_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_context_menu_handler_capi.h b/src/include/libcef_/capi/cef_context_menu_handler_capi.h
new file mode 100644
index 0000000..05966ff
--- /dev/null
+++ b/src/include/libcef_/capi/cef_context_menu_handler_capi.h
@@ -0,0 +1,291 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_CONTEXT_MENU_HANDLER_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_CONTEXT_MENU_HANDLER_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+#include"libcef/capi/cef_browser_capi.h"
+#include"libcef/capi/cef_frame_capi.h"
+#include"libcef/capi/cef_menu_model_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _cef_context_menu_params_t;
+
+///
+// Callback structure used for continuation of custom context menu display.
+///
+typedef struct _cef_run_context_menu_callback_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Complete context menu display by selecting the specified |command_id| and
+  // |event_flags|.
+  ///
+  void (CEF_CALLBACK *cont)(struct _cef_run_context_menu_callback_t* self,
+      int command_id, cef_event_flags_t event_flags);
+
+  ///
+  // Cancel context menu display.
+  ///
+  void (CEF_CALLBACK *cancel)(struct _cef_run_context_menu_callback_t* self);
+} cef_run_context_menu_callback_t;
+
+
+///
+// Implement this structure to handle context menu events. The functions of this
+// structure will be called on the UI thread.
+///
+typedef struct _cef_context_menu_handler_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Called before a context menu is displayed. |params| provides information
+  // about the context menu state. |model| initially contains the default
+  // context menu. The |model| can be cleared to show no context menu or
+  // modified to show a custom menu. Do not keep references to |params| or
+  // |model| outside of this callback.
+  ///
+  void (CEF_CALLBACK *on_before_context_menu)(
+      struct _cef_context_menu_handler_t* self, struct _cef_browser_t* browser,
+      struct _cef_frame_t* frame, struct _cef_context_menu_params_t* params,
+      struct _cef_menu_model_t* model);
+
+  ///
+  // Called to allow custom display of the context menu. |params| provides
+  // information about the context menu state. |model| contains the context menu
+  // model resulting from OnBeforeContextMenu. For custom display return true
+  // (1) and execute |callback| either synchronously or asynchronously with the
+  // selected command ID. For default display return false (0). Do not keep
+  // references to |params| or |model| outside of this callback.
+  ///
+  int (CEF_CALLBACK *run_context_menu)(struct _cef_context_menu_handler_t* self,
+      struct _cef_browser_t* browser, struct _cef_frame_t* frame,
+      struct _cef_context_menu_params_t* params,
+      struct _cef_menu_model_t* model,
+      struct _cef_run_context_menu_callback_t* callback);
+
+  ///
+  // Called to execute a command selected from the context menu. Return true (1)
+  // if the command was handled or false (0) for the default implementation. See
+  // cef_menu_id_t for the command ids that have default implementations. All
+  // user-defined command ids should be between MENU_ID_USER_FIRST and
+  // MENU_ID_USER_LAST. |params| will have the same values as what was passed to
+  // on_before_context_menu(). Do not keep a reference to |params| outside of
+  // this callback.
+  ///
+  int (CEF_CALLBACK *on_context_menu_command)(
+      struct _cef_context_menu_handler_t* self, struct _cef_browser_t* browser,
+      struct _cef_frame_t* frame, struct _cef_context_menu_params_t* params,
+      int command_id, cef_event_flags_t event_flags);
+
+  ///
+  // Called when the context menu is dismissed irregardless of whether the menu
+  // was NULL or a command was selected.
+  ///
+  void (CEF_CALLBACK *on_context_menu_dismissed)(
+      struct _cef_context_menu_handler_t* self, struct _cef_browser_t* browser,
+      struct _cef_frame_t* frame);
+} cef_context_menu_handler_t;
+
+
+///
+// Provides information about the context menu state. The ethods of this
+// structure can only be accessed on browser process the UI thread.
+///
+typedef struct _cef_context_menu_params_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns the X coordinate of the mouse where the context menu was invoked.
+  // Coords are relative to the associated RenderView's origin.
+  ///
+  int (CEF_CALLBACK *get_xcoord)(struct _cef_context_menu_params_t* self);
+
+  ///
+  // Returns the Y coordinate of the mouse where the context menu was invoked.
+  // Coords are relative to the associated RenderView's origin.
+  ///
+  int (CEF_CALLBACK *get_ycoord)(struct _cef_context_menu_params_t* self);
+
+  ///
+  // Returns flags representing the type of node that the context menu was
+  // invoked on.
+  ///
+  cef_context_menu_type_flags_t (CEF_CALLBACK *get_type_flags)(
+      struct _cef_context_menu_params_t* self);
+
+  ///
+  // Returns the URL of the link, if any, that encloses the node that the
+  // context menu was invoked on.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_link_url)(
+      struct _cef_context_menu_params_t* self);
+
+  ///
+  // Returns the link URL, if any, to be used ONLY for "copy link address". We
+  // don't validate this field in the frontend process.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_unfiltered_link_url)(
+      struct _cef_context_menu_params_t* self);
+
+  ///
+  // Returns the source URL, if any, for the element that the context menu was
+  // invoked on. Example of elements with source URLs are img, audio, and video.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_source_url)(
+      struct _cef_context_menu_params_t* self);
+
+  ///
+  // Returns true (1) if the context menu was invoked on an image which has non-
+  // NULL contents.
+  ///
+  int (CEF_CALLBACK *has_image_contents)(
+      struct _cef_context_menu_params_t* self);
+
+  ///
+  // Returns the URL of the top level page that the context menu was invoked on.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_page_url)(
+      struct _cef_context_menu_params_t* self);
+
+  ///
+  // Returns the URL of the subframe that the context menu was invoked on.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_frame_url)(
+      struct _cef_context_menu_params_t* self);
+
+  ///
+  // Returns the character encoding of the subframe that the context menu was
+  // invoked on.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_frame_charset)(
+      struct _cef_context_menu_params_t* self);
+
+  ///
+  // Returns the type of context node that the context menu was invoked on.
+  ///
+  cef_context_menu_media_type_t (CEF_CALLBACK *get_media_type)(
+      struct _cef_context_menu_params_t* self);
+
+  ///
+  // Returns flags representing the actions supported by the media element, if
+  // any, that the context menu was invoked on.
+  ///
+  cef_context_menu_media_state_flags_t (CEF_CALLBACK *get_media_state_flags)(
+      struct _cef_context_menu_params_t* self);
+
+  ///
+  // Returns the text of the selection, if any, that the context menu was
+  // invoked on.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_selection_text)(
+      struct _cef_context_menu_params_t* self);
+
+  ///
+  // Returns the text of the misspelled word, if any, that the context menu was
+  // invoked on.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_misspelled_word)(
+      struct _cef_context_menu_params_t* self);
+
+  ///
+  // Returns true (1) if suggestions exist, false (0) otherwise. Fills in
+  // |suggestions| from the spell check service for the misspelled word if there
+  // is one.
+  ///
+  int (CEF_CALLBACK *get_dictionary_suggestions)(
+      struct _cef_context_menu_params_t* self, cef_string_list_t suggestions);
+
+  ///
+  // Returns true (1) if the context menu was invoked on an editable node.
+  ///
+  int (CEF_CALLBACK *is_editable)(struct _cef_context_menu_params_t* self);
+
+  ///
+  // Returns true (1) if the context menu was invoked on an editable node where
+  // spell-check is enabled.
+  ///
+  int (CEF_CALLBACK *is_spell_check_enabled)(
+      struct _cef_context_menu_params_t* self);
+
+  ///
+  // Returns flags representing the actions supported by the editable node, if
+  // any, that the context menu was invoked on.
+  ///
+  cef_context_menu_edit_state_flags_t (CEF_CALLBACK *get_edit_state_flags)(
+      struct _cef_context_menu_params_t* self);
+
+  ///
+  // Returns true (1) if the context menu contains items specified by the
+  // renderer process (for example, plugin placeholder or pepper plugin menu
+  // items).
+  ///
+  int (CEF_CALLBACK *is_custom_menu)(struct _cef_context_menu_params_t* self);
+
+  ///
+  // Returns true (1) if the context menu was invoked from a pepper plugin.
+  ///
+  int (CEF_CALLBACK *is_pepper_menu)(struct _cef_context_menu_params_t* self);
+} cef_context_menu_params_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_CONTEXT_MENU_HANDLER_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_cookie_capi.h b/src/include/libcef_/capi/cef_cookie_capi.h
new file mode 100644
index 0000000..10ba193
--- /dev/null
+++ b/src/include/libcef_/capi/cef_cookie_capi.h
@@ -0,0 +1,232 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_COOKIE_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_COOKIE_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+#include"libcef/capi/cef_callback_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _cef_cookie_visitor_t;
+struct _cef_delete_cookies_callback_t;
+struct _cef_set_cookie_callback_t;
+
+///
+// Structure used for managing cookies. The functions of this structure may be
+// called on any thread unless otherwise indicated.
+///
+typedef struct _cef_cookie_manager_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Set the schemes supported by this manager. The default schemes ("http",
+  // "https", "ws" and "wss") will always be supported. If |callback| is non-
+  // NULL it will be executed asnychronously on the IO thread after the change
+  // has been applied. Must be called before any cookies are accessed.
+  ///
+  void (CEF_CALLBACK *set_supported_schemes)(struct _cef_cookie_manager_t* self,
+      cef_string_list_t schemes, struct _cef_completion_callback_t* callback);
+
+  ///
+  // Visit all cookies on the IO thread. The returned cookies are ordered by
+  // longest path, then by earliest creation date. Returns false (0) if cookies
+  // cannot be accessed.
+  ///
+  int (CEF_CALLBACK *visit_all_cookies)(struct _cef_cookie_manager_t* self,
+      struct _cef_cookie_visitor_t* visitor);
+
+  ///
+  // Visit a subset of cookies on the IO thread. The results are filtered by the
+  // given url scheme, host, domain and path. If |includeHttpOnly| is true (1)
+  // HTTP-only cookies will also be included in the results. The returned
+  // cookies are ordered by longest path, then by earliest creation date.
+  // Returns false (0) if cookies cannot be accessed.
+  ///
+  int (CEF_CALLBACK *visit_url_cookies)(struct _cef_cookie_manager_t* self,
+      const cef_string_t* url, int includeHttpOnly,
+      struct _cef_cookie_visitor_t* visitor);
+
+  ///
+  // Sets a cookie given a valid URL and explicit user-provided cookie
+  // attributes. This function expects each attribute to be well-formed. It will
+  // check for disallowed characters (e.g. the ';' character is disallowed
+  // within the cookie value attribute) and fail without setting the cookie if
+  // such characters are found. If |callback| is non-NULL it will be executed
+  // asnychronously on the IO thread after the cookie has been set. Returns
+  // false (0) if an invalid URL is specified or if cookies cannot be accessed.
+  ///
+  int (CEF_CALLBACK *set_cookie)(struct _cef_cookie_manager_t* self,
+      const cef_string_t* url, const struct _cef_cookie_t* cookie,
+      struct _cef_set_cookie_callback_t* callback);
+
+  ///
+  // Delete all cookies that match the specified parameters. If both |url| and
+  // |cookie_name| values are specified all host and domain cookies matching
+  // both will be deleted. If only |url| is specified all host cookies (but not
+  // domain cookies) irrespective of path will be deleted. If |url| is NULL all
+  // cookies for all hosts and domains will be deleted. If |callback| is non-
+  // NULL it will be executed asnychronously on the IO thread after the cookies
+  // have been deleted. Returns false (0) if a non-NULL invalid URL is specified
+  // or if cookies cannot be accessed. Cookies can alternately be deleted using
+  // the Visit*Cookies() functions.
+  ///
+  int (CEF_CALLBACK *delete_cookies)(struct _cef_cookie_manager_t* self,
+      const cef_string_t* url, const cef_string_t* cookie_name,
+      struct _cef_delete_cookies_callback_t* callback);
+
+  ///
+  // Sets the directory path that will be used for storing cookie data. If
+  // |path| is NULL data will be stored in memory only. Otherwise, data will be
+  // stored at the specified |path|. To persist session cookies (cookies without
+  // an expiry date or validity interval) set |persist_session_cookies| to true
+  // (1). Session cookies are generally intended to be transient and most Web
+  // browsers do not persist them. If |callback| is non-NULL it will be executed
+  // asnychronously on the IO thread after the manager's storage has been
+  // initialized. Returns false (0) if cookies cannot be accessed.
+  ///
+  int (CEF_CALLBACK *set_storage_path)(struct _cef_cookie_manager_t* self,
+      const cef_string_t* path, int persist_session_cookies,
+      struct _cef_completion_callback_t* callback);
+
+  ///
+  // Flush the backing store (if any) to disk. If |callback| is non-NULL it will
+  // be executed asnychronously on the IO thread after the flush is complete.
+  // Returns false (0) if cookies cannot be accessed.
+  ///
+  int (CEF_CALLBACK *flush_store)(struct _cef_cookie_manager_t* self,
+      struct _cef_completion_callback_t* callback);
+} cef_cookie_manager_t;
+
+
+///
+// Returns the global cookie manager. By default data will be stored at
+// CefSettings.cache_path if specified or in memory otherwise. If |callback| is
+// non-NULL it will be executed asnychronously on the IO thread after the
+// manager's storage has been initialized. Using this function is equivalent to
+// calling cef_request_tContext::cef_request_context_get_global_context()->get_d
+// efault_cookie_manager().
+///
+CEF_EXPORT cef_cookie_manager_t* cef_cookie_manager_get_global_manager(
+    struct _cef_completion_callback_t* callback);
+
+///
+// Creates a new cookie manager. If |path| is NULL data will be stored in memory
+// only. Otherwise, data will be stored at the specified |path|. To persist
+// session cookies (cookies without an expiry date or validity interval) set
+// |persist_session_cookies| to true (1). Session cookies are generally intended
+// to be transient and most Web browsers do not persist them. If |callback| is
+// non-NULL it will be executed asnychronously on the IO thread after the
+// manager's storage has been initialized.
+///
+CEF_EXPORT cef_cookie_manager_t* cef_cookie_manager_create_manager(
+    const cef_string_t* path, int persist_session_cookies,
+    struct _cef_completion_callback_t* callback);
+
+
+///
+// Structure to implement for visiting cookie values. The functions of this
+// structure will always be called on the IO thread.
+///
+typedef struct _cef_cookie_visitor_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Method that will be called once for each cookie. |count| is the 0-based
+  // index for the current cookie. |total| is the total number of cookies. Set
+  // |deleteCookie| to true (1) to delete the cookie currently being visited.
+  // Return false (0) to stop visiting cookies. This function may never be
+  // called if no cookies are found.
+  ///
+  int (CEF_CALLBACK *visit)(struct _cef_cookie_visitor_t* self,
+      const struct _cef_cookie_t* cookie, int count, int total,
+      int* deleteCookie);
+} cef_cookie_visitor_t;
+
+
+///
+// Structure to implement to be notified of asynchronous completion via
+// cef_cookie_manager_t::set_cookie().
+///
+typedef struct _cef_set_cookie_callback_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Method that will be called upon completion. |success| will be true (1) if
+  // the cookie was set successfully.
+  ///
+  void (CEF_CALLBACK *on_complete)(struct _cef_set_cookie_callback_t* self,
+      int success);
+} cef_set_cookie_callback_t;
+
+
+///
+// Structure to implement to be notified of asynchronous completion via
+// cef_cookie_manager_t::delete_cookies().
+///
+typedef struct _cef_delete_cookies_callback_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Method that will be called upon completion. |num_deleted| will be the
+  // number of cookies that were deleted or -1 if unknown.
+  ///
+  void (CEF_CALLBACK *on_complete)(struct _cef_delete_cookies_callback_t* self,
+      int num_deleted);
+} cef_delete_cookies_callback_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_COOKIE_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_dialog_handler_capi.h b/src/include/libcef_/capi/cef_dialog_handler_capi.h
new file mode 100644
index 0000000..355ec2e
--- /dev/null
+++ b/src/include/libcef_/capi/cef_dialog_handler_capi.h
@@ -0,0 +1,112 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_DIALOG_HANDLER_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_DIALOG_HANDLER_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+#include"libcef/capi/cef_browser_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Callback structure for asynchronous continuation of file dialog requests.
+///
+typedef struct _cef_file_dialog_callback_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Continue the file selection. |selected_accept_filter| should be the 0-based
+  // index of the value selected from the accept filters array passed to
+  // cef_dialog_handler_t::OnFileDialog. |file_paths| should be a single value
+  // or a list of values depending on the dialog mode. An NULL |file_paths|
+  // value is treated the same as calling cancel().
+  ///
+  void (CEF_CALLBACK *cont)(struct _cef_file_dialog_callback_t* self,
+      int selected_accept_filter, cef_string_list_t file_paths);
+
+  ///
+  // Cancel the file selection.
+  ///
+  void (CEF_CALLBACK *cancel)(struct _cef_file_dialog_callback_t* self);
+} cef_file_dialog_callback_t;
+
+
+///
+// Implement this structure to handle dialog events. The functions of this
+// structure will be called on the browser process UI thread.
+///
+typedef struct _cef_dialog_handler_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Called to run a file chooser dialog. |mode| represents the type of dialog
+  // to display. |title| to the title to be used for the dialog and may be NULL
+  // to show the default title ("Open" or "Save" depending on the mode).
+  // |default_file_path| is the path with optional directory and/or file name
+  // component that should be initially selected in the dialog. |accept_filters|
+  // are used to restrict the selectable file types and may any combination of
+  // (a) valid lower-cased MIME types (e.g. "text/*" or "image/*"), (b)
+  // individual file extensions (e.g. ".txt" or ".png"), or (c) combined
+  // description and file extension delimited using "|" and ";" (e.g. "Image
+  // Types|.png;.gif;.jpg"). |selected_accept_filter| is the 0-based index of
+  // the filter that should be selected by default. To display a custom dialog
+  // return true (1) and execute |callback| either inline or at a later time. To
+  // display the default dialog return false (0).
+  ///
+  int (CEF_CALLBACK *on_file_dialog)(struct _cef_dialog_handler_t* self,
+      struct _cef_browser_t* browser, cef_file_dialog_mode_t mode,
+      const cef_string_t* title, const cef_string_t* default_file_path,
+      cef_string_list_t accept_filters, int selected_accept_filter,
+      struct _cef_file_dialog_callback_t* callback);
+} cef_dialog_handler_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_DIALOG_HANDLER_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_display_handler_capi.h b/src/include/libcef_/capi/cef_display_handler_capi.h
new file mode 100644
index 0000000..46ba685
--- /dev/null
+++ b/src/include/libcef_/capi/cef_display_handler_capi.h
@@ -0,0 +1,122 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_DISPLAY_HANDLER_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_DISPLAY_HANDLER_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+#include"libcef/capi/cef_browser_capi.h"
+#include"libcef/capi/cef_frame_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Implement this structure to handle events related to browser display state.
+// The functions of this structure will be called on the UI thread.
+///
+typedef struct _cef_display_handler_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Called when a frame's address has changed.
+  ///
+  void (CEF_CALLBACK *on_address_change)(struct _cef_display_handler_t* self,
+      struct _cef_browser_t* browser, struct _cef_frame_t* frame,
+      const cef_string_t* url);
+
+  ///
+  // Called when the page title changes.
+  ///
+  void (CEF_CALLBACK *on_title_change)(struct _cef_display_handler_t* self,
+      struct _cef_browser_t* browser, const cef_string_t* title);
+
+  ///
+  // Called when the page icon changes.
+  ///
+  void (CEF_CALLBACK *on_favicon_urlchange)(struct _cef_display_handler_t* self,
+      struct _cef_browser_t* browser, cef_string_list_t icon_urls);
+
+  ///
+  // Called when web content in the page has toggled fullscreen mode. If
+  // |fullscreen| is true (1) the content will automatically be sized to fill
+  // the browser content area. If |fullscreen| is false (0) the content will
+  // automatically return to its original size and position. The client is
+  // responsible for resizing the browser if desired.
+  ///
+  void (CEF_CALLBACK *on_fullscreen_mode_change)(
+      struct _cef_display_handler_t* self, struct _cef_browser_t* browser,
+      int fullscreen);
+
+  ///
+  // Called when the browser is about to display a tooltip. |text| contains the
+  // text that will be displayed in the tooltip. To handle the display of the
+  // tooltip yourself return true (1). Otherwise, you can optionally modify
+  // |text| and then return false (0) to allow the browser to display the
+  // tooltip. When window rendering is disabled the application is responsible
+  // for drawing tooltips and the return value is ignored.
+  ///
+  int (CEF_CALLBACK *on_tooltip)(struct _cef_display_handler_t* self,
+      struct _cef_browser_t* browser, cef_string_t* text);
+
+  ///
+  // Called when the browser receives a status message. |value| contains the
+  // text that will be displayed in the status message.
+  ///
+  void (CEF_CALLBACK *on_status_message)(struct _cef_display_handler_t* self,
+      struct _cef_browser_t* browser, const cef_string_t* value);
+
+  ///
+  // Called to display a console message. Return true (1) to stop the message
+  // from being output to the console.
+  ///
+  int (CEF_CALLBACK *on_console_message)(struct _cef_display_handler_t* self,
+      struct _cef_browser_t* browser, const cef_string_t* message,
+      const cef_string_t* source, int line);
+} cef_display_handler_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_DISPLAY_HANDLER_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_dom_capi.h b/src/include/libcef_/capi/cef_dom_capi.h
new file mode 100644
index 0000000..05b9b72
--- /dev/null
+++ b/src/include/libcef_/capi/cef_dom_capi.h
@@ -0,0 +1,341 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_DOM_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_DOM_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _cef_domdocument_t;
+struct _cef_domnode_t;
+
+///
+// Structure to implement for visiting the DOM. The functions of this structure
+// will be called on the render process main thread.
+///
+typedef struct _cef_domvisitor_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Method executed for visiting the DOM. The document object passed to this
+  // function represents a snapshot of the DOM at the time this function is
+  // executed. DOM objects are only valid for the scope of this function. Do not
+  // keep references to or attempt to access any DOM objects outside the scope
+  // of this function.
+  ///
+  void (CEF_CALLBACK *visit)(struct _cef_domvisitor_t* self,
+      struct _cef_domdocument_t* document);
+} cef_domvisitor_t;
+
+
+///
+// Structure used to represent a DOM document. The functions of this structure
+// should only be called on the render process main thread thread.
+///
+typedef struct _cef_domdocument_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns the document type.
+  ///
+  cef_dom_document_type_t (CEF_CALLBACK *get_type)(
+      struct _cef_domdocument_t* self);
+
+  ///
+  // Returns the root document node.
+  ///
+  struct _cef_domnode_t* (CEF_CALLBACK *get_document)(
+      struct _cef_domdocument_t* self);
+
+  ///
+  // Returns the BODY node of an HTML document.
+  ///
+  struct _cef_domnode_t* (CEF_CALLBACK *get_body)(
+      struct _cef_domdocument_t* self);
+
+  ///
+  // Returns the HEAD node of an HTML document.
+  ///
+  struct _cef_domnode_t* (CEF_CALLBACK *get_head)(
+      struct _cef_domdocument_t* self);
+
+  ///
+  // Returns the title of an HTML document.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_title)(
+      struct _cef_domdocument_t* self);
+
+  ///
+  // Returns the document element with the specified ID value.
+  ///
+  struct _cef_domnode_t* (CEF_CALLBACK *get_element_by_id)(
+      struct _cef_domdocument_t* self, const cef_string_t* id);
+
+  ///
+  // Returns the node that currently has keyboard focus.
+  ///
+  struct _cef_domnode_t* (CEF_CALLBACK *get_focused_node)(
+      struct _cef_domdocument_t* self);
+
+  ///
+  // Returns true (1) if a portion of the document is selected.
+  ///
+  int (CEF_CALLBACK *has_selection)(struct _cef_domdocument_t* self);
+
+  ///
+  // Returns the selection offset within the start node.
+  ///
+  int (CEF_CALLBACK *get_selection_start_offset)(
+      struct _cef_domdocument_t* self);
+
+  ///
+  // Returns the selection offset within the end node.
+  ///
+  int (CEF_CALLBACK *get_selection_end_offset)(struct _cef_domdocument_t* self);
+
+  ///
+  // Returns the contents of this selection as markup.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_selection_as_markup)(
+      struct _cef_domdocument_t* self);
+
+  ///
+  // Returns the contents of this selection as text.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_selection_as_text)(
+      struct _cef_domdocument_t* self);
+
+  ///
+  // Returns the base URL for the document.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_base_url)(
+      struct _cef_domdocument_t* self);
+
+  ///
+  // Returns a complete URL based on the document base URL and the specified
+  // partial URL.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_complete_url)(
+      struct _cef_domdocument_t* self, const cef_string_t* partialURL);
+} cef_domdocument_t;
+
+
+///
+// Structure used to represent a DOM node. The functions of this structure
+// should only be called on the render process main thread.
+///
+typedef struct _cef_domnode_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns the type for this node.
+  ///
+  cef_dom_node_type_t (CEF_CALLBACK *get_type)(struct _cef_domnode_t* self);
+
+  ///
+  // Returns true (1) if this is a text node.
+  ///
+  int (CEF_CALLBACK *is_text)(struct _cef_domnode_t* self);
+
+  ///
+  // Returns true (1) if this is an element node.
+  ///
+  int (CEF_CALLBACK *is_element)(struct _cef_domnode_t* self);
+
+  ///
+  // Returns true (1) if this is an editable node.
+  ///
+  int (CEF_CALLBACK *is_editable)(struct _cef_domnode_t* self);
+
+  ///
+  // Returns true (1) if this is a form control element node.
+  ///
+  int (CEF_CALLBACK *is_form_control_element)(struct _cef_domnode_t* self);
+
+  ///
+  // Returns the type of this form control element node.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_form_control_element_type)(
+      struct _cef_domnode_t* self);
+
+  ///
+  // Returns true (1) if this object is pointing to the same handle as |that|
+  // object.
+  ///
+  int (CEF_CALLBACK *is_same)(struct _cef_domnode_t* self,
+      struct _cef_domnode_t* that);
+
+  ///
+  // Returns the name of this node.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_name)(struct _cef_domnode_t* self);
+
+  ///
+  // Returns the value of this node.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_value)(struct _cef_domnode_t* self);
+
+  ///
+  // Set the value of this node. Returns true (1) on success.
+  ///
+  int (CEF_CALLBACK *set_value)(struct _cef_domnode_t* self,
+      const cef_string_t* value);
+
+  ///
+  // Returns the contents of this node as markup.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_as_markup)(
+      struct _cef_domnode_t* self);
+
+  ///
+  // Returns the document associated with this node.
+  ///
+  struct _cef_domdocument_t* (CEF_CALLBACK *get_document)(
+      struct _cef_domnode_t* self);
+
+  ///
+  // Returns the parent node.
+  ///
+  struct _cef_domnode_t* (CEF_CALLBACK *get_parent)(
+      struct _cef_domnode_t* self);
+
+  ///
+  // Returns the previous sibling node.
+  ///
+  struct _cef_domnode_t* (CEF_CALLBACK *get_previous_sibling)(
+      struct _cef_domnode_t* self);
+
+  ///
+  // Returns the next sibling node.
+  ///
+  struct _cef_domnode_t* (CEF_CALLBACK *get_next_sibling)(
+      struct _cef_domnode_t* self);
+
+  ///
+  // Returns true (1) if this node has child nodes.
+  ///
+  int (CEF_CALLBACK *has_children)(struct _cef_domnode_t* self);
+
+  ///
+  // Return the first child node.
+  ///
+  struct _cef_domnode_t* (CEF_CALLBACK *get_first_child)(
+      struct _cef_domnode_t* self);
+
+  ///
+  // Returns the last child node.
+  ///
+  struct _cef_domnode_t* (CEF_CALLBACK *get_last_child)(
+      struct _cef_domnode_t* self);
+
+
+  // The following functions are valid only for element nodes.
+
+  ///
+  // Returns the tag name of this element.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_element_tag_name)(
+      struct _cef_domnode_t* self);
+
+  ///
+  // Returns true (1) if this element has attributes.
+  ///
+  int (CEF_CALLBACK *has_element_attributes)(struct _cef_domnode_t* self);
+
+  ///
+  // Returns true (1) if this element has an attribute named |attrName|.
+  ///
+  int (CEF_CALLBACK *has_element_attribute)(struct _cef_domnode_t* self,
+      const cef_string_t* attrName);
+
+  ///
+  // Returns the element attribute named |attrName|.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_element_attribute)(
+      struct _cef_domnode_t* self, const cef_string_t* attrName);
+
+  ///
+  // Returns a map of all element attributes.
+  ///
+  void (CEF_CALLBACK *get_element_attributes)(struct _cef_domnode_t* self,
+      cef_string_map_t attrMap);
+
+  ///
+  // Set the value for the element attribute named |attrName|. Returns true (1)
+  // on success.
+  ///
+  int (CEF_CALLBACK *set_element_attribute)(struct _cef_domnode_t* self,
+      const cef_string_t* attrName, const cef_string_t* value);
+
+  ///
+  // Returns the inner text of the element.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_element_inner_text)(
+      struct _cef_domnode_t* self);
+} cef_domnode_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_DOM_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_download_handler_capi.h b/src/include/libcef_/capi/cef_download_handler_capi.h
new file mode 100644
index 0000000..5d6d471
--- /dev/null
+++ b/src/include/libcef_/capi/cef_download_handler_capi.h
@@ -0,0 +1,137 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_DOWNLOAD_HANDLER_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_DOWNLOAD_HANDLER_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+#include"libcef/capi/cef_browser_capi.h"
+#include"libcef/capi/cef_download_item_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Callback structure used to asynchronously continue a download.
+///
+typedef struct _cef_before_download_callback_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Call to continue the download. Set |download_path| to the full file path
+  // for the download including the file name or leave blank to use the
+  // suggested name and the default temp directory. Set |show_dialog| to true
+  // (1) if you do wish to show the default "Save As" dialog.
+  ///
+  void (CEF_CALLBACK *cont)(struct _cef_before_download_callback_t* self,
+      const cef_string_t* download_path, int show_dialog);
+} cef_before_download_callback_t;
+
+
+///
+// Callback structure used to asynchronously cancel a download.
+///
+typedef struct _cef_download_item_callback_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Call to cancel the download.
+  ///
+  void (CEF_CALLBACK *cancel)(struct _cef_download_item_callback_t* self);
+
+  ///
+  // Call to pause the download.
+  ///
+  void (CEF_CALLBACK *pause)(struct _cef_download_item_callback_t* self);
+
+  ///
+  // Call to resume the download.
+  ///
+  void (CEF_CALLBACK *resume)(struct _cef_download_item_callback_t* self);
+} cef_download_item_callback_t;
+
+
+///
+// Structure used to handle file downloads. The functions of this structure will
+// called on the browser process UI thread.
+///
+typedef struct _cef_download_handler_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Called before a download begins. |suggested_name| is the suggested name for
+  // the download file. By default the download will be canceled. Execute
+  // |callback| either asynchronously or in this function to continue the
+  // download if desired. Do not keep a reference to |download_item| outside of
+  // this function.
+  ///
+  void (CEF_CALLBACK *on_before_download)(struct _cef_download_handler_t* self,
+      struct _cef_browser_t* browser,
+      struct _cef_download_item_t* download_item,
+      const cef_string_t* suggested_name,
+      struct _cef_before_download_callback_t* callback);
+
+  ///
+  // Called when a download's status or progress information has been updated.
+  // This may be called multiple times before and after on_before_download().
+  // Execute |callback| either asynchronously or in this function to cancel the
+  // download if desired. Do not keep a reference to |download_item| outside of
+  // this function.
+  ///
+  void (CEF_CALLBACK *on_download_updated)(struct _cef_download_handler_t* self,
+      struct _cef_browser_t* browser,
+      struct _cef_download_item_t* download_item,
+      struct _cef_download_item_callback_t* callback);
+} cef_download_handler_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_DOWNLOAD_HANDLER_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_download_item_capi.h b/src/include/libcef_/capi/cef_download_item_capi.h
new file mode 100644
index 0000000..abccbd3
--- /dev/null
+++ b/src/include/libcef_/capi/cef_download_item_capi.h
@@ -0,0 +1,162 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_DOWNLOAD_ITEM_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_DOWNLOAD_ITEM_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Structure used to represent a download item.
+///
+typedef struct _cef_download_item_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns true (1) if this object is valid. Do not call any other functions
+  // if this function returns false (0).
+  ///
+  int (CEF_CALLBACK *is_valid)(struct _cef_download_item_t* self);
+
+  ///
+  // Returns true (1) if the download is in progress.
+  ///
+  int (CEF_CALLBACK *is_in_progress)(struct _cef_download_item_t* self);
+
+  ///
+  // Returns true (1) if the download is complete.
+  ///
+  int (CEF_CALLBACK *is_complete)(struct _cef_download_item_t* self);
+
+  ///
+  // Returns true (1) if the download has been canceled or interrupted.
+  ///
+  int (CEF_CALLBACK *is_canceled)(struct _cef_download_item_t* self);
+
+  ///
+  // Returns a simple speed estimate in bytes/s.
+  ///
+  int64 (CEF_CALLBACK *get_current_speed)(struct _cef_download_item_t* self);
+
+  ///
+  // Returns the rough percent complete or -1 if the receive total size is
+  // unknown.
+  ///
+  int (CEF_CALLBACK *get_percent_complete)(struct _cef_download_item_t* self);
+
+  ///
+  // Returns the total number of bytes.
+  ///
+  int64 (CEF_CALLBACK *get_total_bytes)(struct _cef_download_item_t* self);
+
+  ///
+  // Returns the number of received bytes.
+  ///
+  int64 (CEF_CALLBACK *get_received_bytes)(struct _cef_download_item_t* self);
+
+  ///
+  // Returns the time that the download started.
+  ///
+  cef_time_t (CEF_CALLBACK *get_start_time)(struct _cef_download_item_t* self);
+
+  ///
+  // Returns the time that the download ended.
+  ///
+  cef_time_t (CEF_CALLBACK *get_end_time)(struct _cef_download_item_t* self);
+
+  ///
+  // Returns the full path to the downloaded or downloading file.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_full_path)(
+      struct _cef_download_item_t* self);
+
+  ///
+  // Returns the unique identifier for this download.
+  ///
+  uint32 (CEF_CALLBACK *get_id)(struct _cef_download_item_t* self);
+
+  ///
+  // Returns the URL.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_url)(
+      struct _cef_download_item_t* self);
+
+  ///
+  // Returns the original URL before any redirections.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_original_url)(
+      struct _cef_download_item_t* self);
+
+  ///
+  // Returns the suggested file name.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_suggested_file_name)(
+      struct _cef_download_item_t* self);
+
+  ///
+  // Returns the content disposition.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_content_disposition)(
+      struct _cef_download_item_t* self);
+
+  ///
+  // Returns the mime type.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_mime_type)(
+      struct _cef_download_item_t* self);
+} cef_download_item_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_DOWNLOAD_ITEM_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_drag_data_capi.h b/src/include/libcef_/capi/cef_drag_data_capi.h
new file mode 100644
index 0000000..fd3ef81
--- /dev/null
+++ b/src/include/libcef_/capi/cef_drag_data_capi.h
@@ -0,0 +1,211 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_DRAG_DATA_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_DRAG_DATA_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+#include"libcef/capi/cef_stream_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Structure used to represent drag data. The functions of this structure may be
+// called on any thread.
+///
+typedef struct _cef_drag_data_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns a copy of the current object.
+  ///
+  struct _cef_drag_data_t* (CEF_CALLBACK *clone)(struct _cef_drag_data_t* self);
+
+  ///
+  // Returns true (1) if this object is read-only.
+  ///
+  int (CEF_CALLBACK *is_read_only)(struct _cef_drag_data_t* self);
+
+  ///
+  // Returns true (1) if the drag data is a link.
+  ///
+  int (CEF_CALLBACK *is_link)(struct _cef_drag_data_t* self);
+
+  ///
+  // Returns true (1) if the drag data is a text or html fragment.
+  ///
+  int (CEF_CALLBACK *is_fragment)(struct _cef_drag_data_t* self);
+
+  ///
+  // Returns true (1) if the drag data is a file.
+  ///
+  int (CEF_CALLBACK *is_file)(struct _cef_drag_data_t* self);
+
+  ///
+  // Return the link URL that is being dragged.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_link_url)(
+      struct _cef_drag_data_t* self);
+
+  ///
+  // Return the title associated with the link being dragged.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_link_title)(
+      struct _cef_drag_data_t* self);
+
+  ///
+  // Return the metadata, if any, associated with the link being dragged.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_link_metadata)(
+      struct _cef_drag_data_t* self);
+
+  ///
+  // Return the plain text fragment that is being dragged.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_fragment_text)(
+      struct _cef_drag_data_t* self);
+
+  ///
+  // Return the text/html fragment that is being dragged.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_fragment_html)(
+      struct _cef_drag_data_t* self);
+
+  ///
+  // Return the base URL that the fragment came from. This value is used for
+  // resolving relative URLs and may be NULL.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_fragment_base_url)(
+      struct _cef_drag_data_t* self);
+
+  ///
+  // Return the name of the file being dragged out of the browser window.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_file_name)(
+      struct _cef_drag_data_t* self);
+
+  ///
+  // Write the contents of the file being dragged out of the web view into
+  // |writer|. Returns the number of bytes sent to |writer|. If |writer| is NULL
+  // this function will return the size of the file contents in bytes. Call
+  // get_file_name() to get a suggested name for the file.
+  ///
+  size_t (CEF_CALLBACK *get_file_contents)(struct _cef_drag_data_t* self,
+      struct _cef_stream_writer_t* writer);
+
+  ///
+  // Retrieve the list of file names that are being dragged into the browser
+  // window.
+  ///
+  int (CEF_CALLBACK *get_file_names)(struct _cef_drag_data_t* self,
+      cef_string_list_t names);
+
+  ///
+  // Set the link URL that is being dragged.
+  ///
+  void (CEF_CALLBACK *set_link_url)(struct _cef_drag_data_t* self,
+      const cef_string_t* url);
+
+  ///
+  // Set the title associated with the link being dragged.
+  ///
+  void (CEF_CALLBACK *set_link_title)(struct _cef_drag_data_t* self,
+      const cef_string_t* title);
+
+  ///
+  // Set the metadata associated with the link being dragged.
+  ///
+  void (CEF_CALLBACK *set_link_metadata)(struct _cef_drag_data_t* self,
+      const cef_string_t* data);
+
+  ///
+  // Set the plain text fragment that is being dragged.
+  ///
+  void (CEF_CALLBACK *set_fragment_text)(struct _cef_drag_data_t* self,
+      const cef_string_t* text);
+
+  ///
+  // Set the text/html fragment that is being dragged.
+  ///
+  void (CEF_CALLBACK *set_fragment_html)(struct _cef_drag_data_t* self,
+      const cef_string_t* html);
+
+  ///
+  // Set the base URL that the fragment came from.
+  ///
+  void (CEF_CALLBACK *set_fragment_base_url)(struct _cef_drag_data_t* self,
+      const cef_string_t* base_url);
+
+  ///
+  // Reset the file contents. You should do this before calling
+  // cef_browser_host_t::DragTargetDragEnter as the web view does not allow us
+  // to drag in this kind of data.
+  ///
+  void (CEF_CALLBACK *reset_file_contents)(struct _cef_drag_data_t* self);
+
+  ///
+  // Add a file that is being dragged into the webview.
+  ///
+  void (CEF_CALLBACK *add_file)(struct _cef_drag_data_t* self,
+      const cef_string_t* path, const cef_string_t* display_name);
+} cef_drag_data_t;
+
+
+///
+// Create a new cef_drag_data_t object.
+///
+CEF_EXPORT cef_drag_data_t* cef_drag_data_create();
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_DRAG_DATA_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_drag_handler_capi.h b/src/include/libcef_/capi/cef_drag_handler_capi.h
new file mode 100644
index 0000000..47a7bea
--- /dev/null
+++ b/src/include/libcef_/capi/cef_drag_handler_capi.h
@@ -0,0 +1,87 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_DRAG_HANDLER_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_DRAG_HANDLER_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+#include"libcef/capi/cef_browser_capi.h"
+#include"libcef/capi/cef_drag_data_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Implement this structure to handle events related to dragging. The functions
+// of this structure will be called on the UI thread.
+///
+typedef struct _cef_drag_handler_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Called when an external drag event enters the browser window. |dragData|
+  // contains the drag event data and |mask| represents the type of drag
+  // operation. Return false (0) for default drag handling behavior or true (1)
+  // to cancel the drag event.
+  ///
+  int (CEF_CALLBACK *on_drag_enter)(struct _cef_drag_handler_t* self,
+      struct _cef_browser_t* browser, struct _cef_drag_data_t* dragData,
+      cef_drag_operations_mask_t mask);
+
+  ///
+  // Called whenever draggable regions for the browser window change. These can
+  // be specified using the '-webkit-app-region: drag/no-drag' CSS-property. If
+  // draggable regions are never defined in a document this function will also
+  // never be called. If the last draggable region is removed from a document
+  // this function will be called with an NULL vector.
+  ///
+  void (CEF_CALLBACK *on_draggable_regions_changed)(
+      struct _cef_drag_handler_t* self, struct _cef_browser_t* browser,
+      size_t regionsCount, cef_draggable_region_t const* regions);
+} cef_drag_handler_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_DRAG_HANDLER_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_find_handler_capi.h b/src/include/libcef_/capi/cef_find_handler_capi.h
new file mode 100644
index 0000000..1b29d6a
--- /dev/null
+++ b/src/include/libcef_/capi/cef_find_handler_capi.h
@@ -0,0 +1,78 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_FIND_HANDLER_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_FIND_HANDLER_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+#include"libcef/capi/cef_browser_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Implement this structure to handle events related to find results. The
+// functions of this structure will be called on the UI thread.
+///
+typedef struct _cef_find_handler_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Called to report find results returned by cef_browser_host_t::find().
+  // |identifer| is the identifier passed to find(), |count| is the number of
+  // matches currently identified, |selectionRect| is the location of where the
+  // match was found (in window coordinates), |activeMatchOrdinal| is the
+  // current position in the search results, and |finalUpdate| is true (1) if
+  // this is the last find notification.
+  ///
+  void (CEF_CALLBACK *on_find_result)(struct _cef_find_handler_t* self,
+      struct _cef_browser_t* browser, int identifier, int count,
+      const cef_rect_t* selectionRect, int activeMatchOrdinal,
+      int finalUpdate);
+} cef_find_handler_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_FIND_HANDLER_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_focus_handler_capi.h b/src/include/libcef_/capi/cef_focus_handler_capi.h
new file mode 100644
index 0000000..3669ac1
--- /dev/null
+++ b/src/include/libcef_/capi/cef_focus_handler_capi.h
@@ -0,0 +1,90 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_FOCUS_HANDLER_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_FOCUS_HANDLER_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+#include"libcef/capi/cef_browser_capi.h"
+#include"libcef/capi/cef_dom_capi.h"
+#include"libcef/capi/cef_frame_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Implement this structure to handle events related to focus. The functions of
+// this structure will be called on the UI thread.
+///
+typedef struct _cef_focus_handler_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Called when the browser component is about to loose focus. For instance, if
+  // focus was on the last HTML element and the user pressed the TAB key. |next|
+  // will be true (1) if the browser is giving focus to the next component and
+  // false (0) if the browser is giving focus to the previous component.
+  ///
+  void (CEF_CALLBACK *on_take_focus)(struct _cef_focus_handler_t* self,
+      struct _cef_browser_t* browser, int next);
+
+  ///
+  // Called when the browser component is requesting focus. |source| indicates
+  // where the focus request is originating from. Return false (0) to allow the
+  // focus to be set or true (1) to cancel setting the focus.
+  ///
+  int (CEF_CALLBACK *on_set_focus)(struct _cef_focus_handler_t* self,
+      struct _cef_browser_t* browser, cef_focus_source_t source);
+
+  ///
+  // Called when the browser component has received focus.
+  ///
+  void (CEF_CALLBACK *on_got_focus)(struct _cef_focus_handler_t* self,
+      struct _cef_browser_t* browser);
+} cef_focus_handler_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_FOCUS_HANDLER_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_frame_capi.h b/src/include/libcef_/capi/cef_frame_capi.h
new file mode 100644
index 0000000..2d4bfe5
--- /dev/null
+++ b/src/include/libcef_/capi/cef_frame_capi.h
@@ -0,0 +1,221 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_FRAME_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_FRAME_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+#include"libcef/capi/cef_dom_capi.h"
+#include"libcef/capi/cef_request_capi.h"
+#include"libcef/capi/cef_stream_capi.h"
+#include"libcef/capi/cef_string_visitor_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _cef_browser_t;
+struct _cef_v8context_t;
+
+///
+// Structure used to represent a frame in the browser window. When used in the
+// browser process the functions of this structure may be called on any thread
+// unless otherwise indicated in the comments. When used in the render process
+// the functions of this structure may only be called on the main thread.
+///
+typedef struct _cef_frame_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // True if this object is currently attached to a valid frame.
+  ///
+  int (CEF_CALLBACK *is_valid)(struct _cef_frame_t* self);
+
+  ///
+  // Execute undo in this frame.
+  ///
+  void (CEF_CALLBACK *undo)(struct _cef_frame_t* self);
+
+  ///
+  // Execute redo in this frame.
+  ///
+  void (CEF_CALLBACK *redo)(struct _cef_frame_t* self);
+
+  ///
+  // Execute cut in this frame.
+  ///
+  void (CEF_CALLBACK *cut)(struct _cef_frame_t* self);
+
+  ///
+  // Execute copy in this frame.
+  ///
+  void (CEF_CALLBACK *copy)(struct _cef_frame_t* self);
+
+  ///
+  // Execute paste in this frame.
+  ///
+  void (CEF_CALLBACK *paste)(struct _cef_frame_t* self);
+
+  ///
+  // Execute delete in this frame.
+  ///
+  void (CEF_CALLBACK *del)(struct _cef_frame_t* self);
+
+  ///
+  // Execute select all in this frame.
+  ///
+  void (CEF_CALLBACK *select_all)(struct _cef_frame_t* self);
+
+  ///
+  // Save this frame's HTML source to a temporary file and open it in the
+  // default text viewing application. This function can only be called from the
+  // browser process.
+  ///
+  void (CEF_CALLBACK *view_source)(struct _cef_frame_t* self);
+
+  ///
+  // Retrieve this frame's HTML source as a string sent to the specified
+  // visitor.
+  ///
+  void (CEF_CALLBACK *get_source)(struct _cef_frame_t* self,
+      struct _cef_string_visitor_t* visitor);
+
+  ///
+  // Retrieve this frame's display text as a string sent to the specified
+  // visitor.
+  ///
+  void (CEF_CALLBACK *get_text)(struct _cef_frame_t* self,
+      struct _cef_string_visitor_t* visitor);
+
+  ///
+  // Load the request represented by the |request| object.
+  ///
+  void (CEF_CALLBACK *load_request)(struct _cef_frame_t* self,
+      struct _cef_request_t* request);
+
+  ///
+  // Load the specified |url|.
+  ///
+  void (CEF_CALLBACK *load_url)(struct _cef_frame_t* self,
+      const cef_string_t* url);
+
+  ///
+  // Load the contents of |string_val| with the specified dummy |url|. |url|
+  // should have a standard scheme (for example, http scheme) or behaviors like
+  // link clicks and web security restrictions may not behave as expected.
+  ///
+  void (CEF_CALLBACK *load_string)(struct _cef_frame_t* self,
+      const cef_string_t* string_val, const cef_string_t* url);
+
+  ///
+  // Execute a string of JavaScript code in this frame. The |script_url|
+  // parameter is the URL where the script in question can be found, if any. The
+  // renderer may request this URL to show the developer the source of the
+  // error.  The |start_line| parameter is the base line number to use for error
+  // reporting.
+  ///
+  void (CEF_CALLBACK *execute_java_script)(struct _cef_frame_t* self,
+      const cef_string_t* code, const cef_string_t* script_url,
+      int start_line);
+
+  ///
+  // Returns true (1) if this is the main (top-level) frame.
+  ///
+  int (CEF_CALLBACK *is_main)(struct _cef_frame_t* self);
+
+  ///
+  // Returns true (1) if this is the focused frame.
+  ///
+  int (CEF_CALLBACK *is_focused)(struct _cef_frame_t* self);
+
+  ///
+  // Returns the name for this frame. If the frame has an assigned name (for
+  // example, set via the iframe "name" attribute) then that value will be
+  // returned. Otherwise a unique name will be constructed based on the frame
+  // parent hierarchy. The main (top-level) frame will always have an NULL name
+  // value.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_name)(struct _cef_frame_t* self);
+
+  ///
+  // Returns the globally unique identifier for this frame or < 0 if the
+  // underlying frame does not yet exist.
+  ///
+  int64 (CEF_CALLBACK *get_identifier)(struct _cef_frame_t* self);
+
+  ///
+  // Returns the parent of this frame or NULL if this is the main (top-level)
+  // frame.
+  ///
+  struct _cef_frame_t* (CEF_CALLBACK *get_parent)(struct _cef_frame_t* self);
+
+  ///
+  // Returns the URL currently loaded in this frame.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_url)(struct _cef_frame_t* self);
+
+  ///
+  // Returns the browser that this frame belongs to.
+  ///
+  struct _cef_browser_t* (CEF_CALLBACK *get_browser)(struct _cef_frame_t* self);
+
+  ///
+  // Get the V8 context associated with the frame. This function can only be
+  // called from the render process.
+  ///
+  struct _cef_v8context_t* (CEF_CALLBACK *get_v8context)(
+      struct _cef_frame_t* self);
+
+  ///
+  // Visit the DOM document. This function can only be called from the render
+  // process.
+  ///
+  void (CEF_CALLBACK *visit_dom)(struct _cef_frame_t* self,
+      struct _cef_domvisitor_t* visitor);
+} cef_frame_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_FRAME_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_geolocation_capi.h b/src/include/libcef_/capi/cef_geolocation_capi.h
new file mode 100644
index 0000000..fac550e
--- /dev/null
+++ b/src/include/libcef_/capi/cef_geolocation_capi.h
@@ -0,0 +1,79 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_GEOLOCATION_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_GEOLOCATION_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Implement this structure to receive geolocation updates. The functions of
+// this structure will be called on the browser process UI thread.
+///
+typedef struct _cef_get_geolocation_callback_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Called with the 'best available' location information or, if the location
+  // update failed, with error information.
+  ///
+  void (CEF_CALLBACK *on_location_update)(
+      struct _cef_get_geolocation_callback_t* self,
+      const struct _cef_geoposition_t* position);
+} cef_get_geolocation_callback_t;
+
+
+///
+// Request a one-time geolocation update. This function bypasses any user
+// permission checks so should only be used by code that is allowed to access
+// location information.
+///
+CEF_EXPORT int cef_get_geolocation(cef_get_geolocation_callback_t* callback);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_GEOLOCATION_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_geolocation_handler_capi.h b/src/include/libcef_/capi/cef_geolocation_handler_capi.h
new file mode 100644
index 0000000..09bf7f0
--- /dev/null
+++ b/src/include/libcef_/capi/cef_geolocation_handler_capi.h
@@ -0,0 +1,105 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_GEOLOCATION_HANDLER_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_GEOLOCATION_HANDLER_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+#include"libcef/capi/cef_browser_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Callback structure used for asynchronous continuation of geolocation
+// permission requests.
+///
+typedef struct _cef_geolocation_callback_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Call to allow or deny geolocation access.
+  ///
+  void (CEF_CALLBACK *cont)(struct _cef_geolocation_callback_t* self,
+      int allow);
+} cef_geolocation_callback_t;
+
+
+///
+// Implement this structure to handle events related to geolocation permission
+// requests. The functions of this structure will be called on the browser
+// process UI thread.
+///
+typedef struct _cef_geolocation_handler_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Called when a page requests permission to access geolocation information.
+  // |requesting_url| is the URL requesting permission and |request_id| is the
+  // unique ID for the permission request. Return true (1) and call
+  // cef_geolocation_callback_t::cont() either in this function or at a later
+  // time to continue or cancel the request. Return false (0) to cancel the
+  // request immediately.
+  ///
+  int (CEF_CALLBACK *on_request_geolocation_permission)(
+      struct _cef_geolocation_handler_t* self, struct _cef_browser_t* browser,
+      const cef_string_t* requesting_url, int request_id,
+      struct _cef_geolocation_callback_t* callback);
+
+  ///
+  // Called when a geolocation access request is canceled. |request_id| is the
+  // unique ID for the permission request.
+  ///
+  void (CEF_CALLBACK *on_cancel_geolocation_permission)(
+      struct _cef_geolocation_handler_t* self, struct _cef_browser_t* browser,
+      int request_id);
+} cef_geolocation_handler_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_GEOLOCATION_HANDLER_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_jsdialog_handler_capi.h b/src/include/libcef_/capi/cef_jsdialog_handler_capi.h
new file mode 100644
index 0000000..62c6dc6
--- /dev/null
+++ b/src/include/libcef_/capi/cef_jsdialog_handler_capi.h
@@ -0,0 +1,135 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_JSDIALOG_HANDLER_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_JSDIALOG_HANDLER_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+#include"libcef/capi/cef_browser_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Callback structure used for asynchronous continuation of JavaScript dialog
+// requests.
+///
+typedef struct _cef_jsdialog_callback_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Continue the JS dialog request. Set |success| to true (1) if the OK button
+  // was pressed. The |user_input| value should be specified for prompt dialogs.
+  ///
+  void (CEF_CALLBACK *cont)(struct _cef_jsdialog_callback_t* self, int success,
+      const cef_string_t* user_input);
+} cef_jsdialog_callback_t;
+
+
+///
+// Implement this structure to handle events related to JavaScript dialogs. The
+// functions of this structure will be called on the UI thread.
+///
+typedef struct _cef_jsdialog_handler_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Called to run a JavaScript dialog. If |origin_url| and |accept_lang| are
+  // non-NULL they can be passed to the CefFormatUrlForSecurityDisplay function
+  // to retrieve a secure and user-friendly display string. The
+  // |default_prompt_text| value will be specified for prompt dialogs only. Set
+  // |suppress_message| to true (1) and return false (0) to suppress the message
+  // (suppressing messages is preferable to immediately executing the callback
+  // as this is used to detect presumably malicious behavior like spamming alert
+  // messages in onbeforeunload). Set |suppress_message| to false (0) and return
+  // false (0) to use the default implementation (the default implementation
+  // will show one modal dialog at a time and suppress any additional dialog
+  // requests until the displayed dialog is dismissed). Return true (1) if the
+  // application will use a custom dialog or if the callback has been executed
+  // immediately. Custom dialogs may be either modal or modeless. If a custom
+  // dialog is used the application must execute |callback| once the custom
+  // dialog is dismissed.
+  ///
+  int (CEF_CALLBACK *on_jsdialog)(struct _cef_jsdialog_handler_t* self,
+      struct _cef_browser_t* browser, const cef_string_t* origin_url,
+      const cef_string_t* accept_lang, cef_jsdialog_type_t dialog_type,
+      const cef_string_t* message_text,
+      const cef_string_t* default_prompt_text,
+      struct _cef_jsdialog_callback_t* callback, int* suppress_message);
+
+  ///
+  // Called to run a dialog asking the user if they want to leave a page. Return
+  // false (0) to use the default dialog implementation. Return true (1) if the
+  // application will use a custom dialog or if the callback has been executed
+  // immediately. Custom dialogs may be either modal or modeless. If a custom
+  // dialog is used the application must execute |callback| once the custom
+  // dialog is dismissed.
+  ///
+  int (CEF_CALLBACK *on_before_unload_dialog)(
+      struct _cef_jsdialog_handler_t* self, struct _cef_browser_t* browser,
+      const cef_string_t* message_text, int is_reload,
+      struct _cef_jsdialog_callback_t* callback);
+
+  ///
+  // Called to cancel any pending dialogs and reset any saved dialog state. Will
+  // be called due to events like page navigation irregardless of whether any
+  // dialogs are currently pending.
+  ///
+  void (CEF_CALLBACK *on_reset_dialog_state)(
+      struct _cef_jsdialog_handler_t* self, struct _cef_browser_t* browser);
+
+  ///
+  // Called when the default implementation dialog is closed.
+  ///
+  void (CEF_CALLBACK *on_dialog_closed)(struct _cef_jsdialog_handler_t* self,
+      struct _cef_browser_t* browser);
+} cef_jsdialog_handler_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_JSDIALOG_HANDLER_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_keyboard_handler_capi.h b/src/include/libcef_/capi/cef_keyboard_handler_capi.h
new file mode 100644
index 0000000..30d2252
--- /dev/null
+++ b/src/include/libcef_/capi/cef_keyboard_handler_capi.h
@@ -0,0 +1,86 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_KEYBOARD_HANDLER_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_KEYBOARD_HANDLER_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+#include"libcef/capi/cef_browser_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Implement this structure to handle events related to keyboard input. The
+// functions of this structure will be called on the UI thread.
+///
+typedef struct _cef_keyboard_handler_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Called before a keyboard event is sent to the renderer. |event| contains
+  // information about the keyboard event. |os_event| is the operating system
+  // event message, if any. Return true (1) if the event was handled or false
+  // (0) otherwise. If the event will be handled in on_key_event() as a keyboard
+  // shortcut set |is_keyboard_shortcut| to true (1) and return false (0).
+  ///
+  int (CEF_CALLBACK *on_pre_key_event)(struct _cef_keyboard_handler_t* self,
+      struct _cef_browser_t* browser, const struct _cef_key_event_t* event,
+      cef_event_handle_t os_event, int* is_keyboard_shortcut);
+
+  ///
+  // Called after the renderer and JavaScript in the page has had a chance to
+  // handle the event. |event| contains information about the keyboard event.
+  // |os_event| is the operating system event message, if any. Return true (1)
+  // if the keyboard event was handled or false (0) otherwise.
+  ///
+  int (CEF_CALLBACK *on_key_event)(struct _cef_keyboard_handler_t* self,
+      struct _cef_browser_t* browser, const struct _cef_key_event_t* event,
+      cef_event_handle_t os_event);
+} cef_keyboard_handler_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_KEYBOARD_HANDLER_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_life_span_handler_capi.h b/src/include/libcef_/capi/cef_life_span_handler_capi.h
new file mode 100644
index 0000000..df7cdf8
--- /dev/null
+++ b/src/include/libcef_/capi/cef_life_span_handler_capi.h
@@ -0,0 +1,178 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_LIFE_SPAN_HANDLER_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_LIFE_SPAN_HANDLER_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+#include"libcef/capi/cef_browser_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _cef_client_t;
+
+///
+// Implement this structure to handle events related to browser life span. The
+// functions of this structure will be called on the UI thread unless otherwise
+// indicated.
+///
+typedef struct _cef_life_span_handler_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Called on the IO thread before a new popup browser is created. The
+  // |browser| and |frame| values represent the source of the popup request. The
+  // |target_url| and |target_frame_name| values indicate where the popup
+  // browser should navigate and may be NULL if not specified with the request.
+  // The |target_disposition| value indicates where the user intended to open
+  // the popup (e.g. current tab, new tab, etc). The |user_gesture| value will
+  // be true (1) if the popup was opened via explicit user gesture (e.g.
+  // clicking a link) or false (0) if the popup opened automatically (e.g. via
+  // the DomContentLoaded event). The |popupFeatures| structure contains
+  // additional information about the requested popup window. To allow creation
+  // of the popup browser optionally modify |windowInfo|, |client|, |settings|
+  // and |no_javascript_access| and return false (0). To cancel creation of the
+  // popup browser return true (1). The |client| and |settings| values will
+  // default to the source browser's values. If the |no_javascript_access| value
+  // is set to false (0) the new browser will not be scriptable and may not be
+  // hosted in the same renderer process as the source browser.
+  ///
+  int (CEF_CALLBACK *on_before_popup)(struct _cef_life_span_handler_t* self,
+      struct _cef_browser_t* browser, struct _cef_frame_t* frame,
+      const cef_string_t* target_url, const cef_string_t* target_frame_name,
+      cef_window_open_disposition_t target_disposition, int user_gesture,
+      const struct _cef_popup_features_t* popupFeatures,
+      struct _cef_window_info_t* windowInfo, struct _cef_client_t** client,
+      struct _cef_browser_settings_t* settings, int* no_javascript_access);
+
+  ///
+  // Called after a new browser is created.
+  ///
+  void (CEF_CALLBACK *on_after_created)(struct _cef_life_span_handler_t* self,
+      struct _cef_browser_t* browser);
+
+  ///
+  // Called when a modal window is about to display and the modal loop should
+  // begin running. Return false (0) to use the default modal loop
+  // implementation or true (1) to use a custom implementation.
+  ///
+  int (CEF_CALLBACK *run_modal)(struct _cef_life_span_handler_t* self,
+      struct _cef_browser_t* browser);
+
+  ///
+  // Called when a browser has recieved a request to close. This may result
+  // directly from a call to cef_browser_host_t::close_browser() or indirectly
+  // if the browser is a top-level OS window created by CEF and the user
+  // attempts to close the window. This function will be called after the
+  // JavaScript 'onunload' event has been fired. It will not be called for
+  // browsers after the associated OS window has been destroyed (for those
+  // browsers it is no longer possible to cancel the close).
+  //
+  // If CEF created an OS window for the browser returning false (0) will send
+  // an OS close notification to the browser window's top-level owner (e.g.
+  // WM_CLOSE on Windows, performClose: on OS-X and "delete_event" on Linux). If
+  // no OS window exists (window rendering disabled) returning false (0) will
+  // cause the browser object to be destroyed immediately. Return true (1) if
+  // the browser is parented to another window and that other window needs to
+  // receive close notification via some non-standard technique.
+  //
+  // If an application provides its own top-level window it should handle OS
+  // close notifications by calling cef_browser_host_t::CloseBrowser(false (0))
+  // instead of immediately closing (see the example below). This gives CEF an
+  // opportunity to process the 'onbeforeunload' event and optionally cancel the
+  // close before do_close() is called.
+  //
+  // The cef_life_span_handler_t::on_before_close() function will be called
+  // immediately before the browser object is destroyed. The application should
+  // only exit after on_before_close() has been called for all existing
+  // browsers.
+  //
+  // If the browser represents a modal window and a custom modal loop
+  // implementation was provided in cef_life_span_handler_t::run_modal() this
+  // callback should be used to restore the opener window to a usable state.
+  //
+  // By way of example consider what should happen during window close when the
+  // browser is parented to an application-provided top-level OS window. 1.
+  // User clicks the window close button which sends an OS close
+  //     notification (e.g. WM_CLOSE on Windows, performClose: on OS-X and
+  //     "delete_event" on Linux).
+  // 2.  Application's top-level window receives the close notification and:
+  //     A. Calls CefBrowserHost::CloseBrowser(false).
+  //     B. Cancels the window close.
+  // 3.  JavaScript 'onbeforeunload' handler executes and shows the close
+  //     confirmation dialog (which can be overridden via
+  //     CefJSDialogHandler::OnBeforeUnloadDialog()).
+  // 4.  User approves the close. 5.  JavaScript 'onunload' handler executes. 6.
+  // Application's do_close() handler is called. Application will:
+  //     A. Set a flag to indicate that the next close attempt will be allowed.
+  //     B. Return false.
+  // 7.  CEF sends an OS close notification. 8.  Application's top-level window
+  // receives the OS close notification and
+  //     allows the window to close based on the flag from #6B.
+  // 9.  Browser OS window is destroyed. 10. Application's
+  // cef_life_span_handler_t::on_before_close() handler is called and
+  //     the browser object is destroyed.
+  // 11. Application exits by calling cef_quit_message_loop() if no other
+  // browsers
+  //     exist.
+  ///
+  int (CEF_CALLBACK *do_close)(struct _cef_life_span_handler_t* self,
+      struct _cef_browser_t* browser);
+
+  ///
+  // Called just before a browser is destroyed. Release all references to the
+  // browser object and do not attempt to execute any functions on the browser
+  // object after this callback returns. If this is a modal window and a custom
+  // modal loop implementation was provided in run_modal() this callback should
+  // be used to exit the custom modal loop. See do_close() documentation for
+  // additional usage information.
+  ///
+  void (CEF_CALLBACK *on_before_close)(struct _cef_life_span_handler_t* self,
+      struct _cef_browser_t* browser);
+} cef_life_span_handler_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_LIFE_SPAN_HANDLER_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_load_handler_capi.h b/src/include/libcef_/capi/cef_load_handler_capi.h
new file mode 100644
index 0000000..92e8bff
--- /dev/null
+++ b/src/include/libcef_/capi/cef_load_handler_capi.h
@@ -0,0 +1,114 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_LOAD_HANDLER_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_LOAD_HANDLER_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+#include"libcef/capi/cef_browser_capi.h"
+#include"libcef/capi/cef_frame_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Implement this structure to handle events related to browser load status. The
+// functions of this structure will be called on the browser process UI thread
+// or render process main thread (TID_RENDERER).
+///
+typedef struct _cef_load_handler_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Called when the loading state has changed. This callback will be executed
+  // twice -- once when loading is initiated either programmatically or by user
+  // action, and once when loading is terminated due to completion, cancellation
+  // of failure. It will be called before any calls to OnLoadStart and after all
+  // calls to OnLoadError and/or OnLoadEnd.
+  ///
+  void (CEF_CALLBACK *on_loading_state_change)(struct _cef_load_handler_t* self,
+      struct _cef_browser_t* browser, int isLoading, int canGoBack,
+      int canGoForward);
+
+  ///
+  // Called when the browser begins loading a frame. The |frame| value will
+  // never be NULL -- call the is_main() function to check if this frame is the
+  // main frame. Multiple frames may be loading at the same time. Sub-frames may
+  // start or continue loading after the main frame load has ended. This
+  // function will always be called for all frames irrespective of whether the
+  // request completes successfully. For notification of overall browser load
+  // status use OnLoadingStateChange instead.
+  ///
+  void (CEF_CALLBACK *on_load_start)(struct _cef_load_handler_t* self,
+      struct _cef_browser_t* browser, struct _cef_frame_t* frame);
+
+  ///
+  // Called when the browser is done loading a frame. The |frame| value will
+  // never be NULL -- call the is_main() function to check if this frame is the
+  // main frame. Multiple frames may be loading at the same time. Sub-frames may
+  // start or continue loading after the main frame load has ended. This
+  // function will always be called for all frames irrespective of whether the
+  // request completes successfully. For notification of overall browser load
+  // status use OnLoadingStateChange instead.
+  ///
+  void (CEF_CALLBACK *on_load_end)(struct _cef_load_handler_t* self,
+      struct _cef_browser_t* browser, struct _cef_frame_t* frame,
+      int httpStatusCode);
+
+  ///
+  // Called when the resource load for a navigation fails or is canceled.
+  // |errorCode| is the error code number, |errorText| is the error text and
+  // |failedUrl| is the URL that failed to load. See net\base\net_error_list.h
+  // for complete descriptions of the error codes.
+  ///
+  void (CEF_CALLBACK *on_load_error)(struct _cef_load_handler_t* self,
+      struct _cef_browser_t* browser, struct _cef_frame_t* frame,
+      cef_errorcode_t errorCode, const cef_string_t* errorText,
+      const cef_string_t* failedUrl);
+} cef_load_handler_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_LOAD_HANDLER_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_menu_model_capi.h b/src/include/libcef_/capi/cef_menu_model_capi.h
new file mode 100644
index 0000000..3b09ab2
--- /dev/null
+++ b/src/include/libcef_/capi/cef_menu_model_capi.h
@@ -0,0 +1,388 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_MENU_MODEL_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_MENU_MODEL_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Supports creation and modification of menus. See cef_menu_id_t for the
+// command ids that have default implementations. All user-defined command ids
+// should be between MENU_ID_USER_FIRST and MENU_ID_USER_LAST. The functions of
+// this structure can only be accessed on the browser process the UI thread.
+///
+typedef struct _cef_menu_model_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Clears the menu. Returns true (1) on success.
+  ///
+  int (CEF_CALLBACK *clear)(struct _cef_menu_model_t* self);
+
+  ///
+  // Returns the number of items in this menu.
+  ///
+  int (CEF_CALLBACK *get_count)(struct _cef_menu_model_t* self);
+
+  ///
+  // Add a separator to the menu. Returns true (1) on success.
+  ///
+  int (CEF_CALLBACK *add_separator)(struct _cef_menu_model_t* self);
+
+  ///
+  // Add an item to the menu. Returns true (1) on success.
+  ///
+  int (CEF_CALLBACK *add_item)(struct _cef_menu_model_t* self, int command_id,
+      const cef_string_t* label);
+
+  ///
+  // Add a check item to the menu. Returns true (1) on success.
+  ///
+  int (CEF_CALLBACK *add_check_item)(struct _cef_menu_model_t* self,
+      int command_id, const cef_string_t* label);
+
+  ///
+  // Add a radio item to the menu. Only a single item with the specified
+  // |group_id| can be checked at a time. Returns true (1) on success.
+  ///
+  int (CEF_CALLBACK *add_radio_item)(struct _cef_menu_model_t* self,
+      int command_id, const cef_string_t* label, int group_id);
+
+  ///
+  // Add a sub-menu to the menu. The new sub-menu is returned.
+  ///
+  struct _cef_menu_model_t* (CEF_CALLBACK *add_sub_menu)(
+      struct _cef_menu_model_t* self, int command_id,
+      const cef_string_t* label);
+
+  ///
+  // Insert a separator in the menu at the specified |index|. Returns true (1)
+  // on success.
+  ///
+  int (CEF_CALLBACK *insert_separator_at)(struct _cef_menu_model_t* self,
+      int index);
+
+  ///
+  // Insert an item in the menu at the specified |index|. Returns true (1) on
+  // success.
+  ///
+  int (CEF_CALLBACK *insert_item_at)(struct _cef_menu_model_t* self, int index,
+      int command_id, const cef_string_t* label);
+
+  ///
+  // Insert a check item in the menu at the specified |index|. Returns true (1)
+  // on success.
+  ///
+  int (CEF_CALLBACK *insert_check_item_at)(struct _cef_menu_model_t* self,
+      int index, int command_id, const cef_string_t* label);
+
+  ///
+  // Insert a radio item in the menu at the specified |index|. Only a single
+  // item with the specified |group_id| can be checked at a time. Returns true
+  // (1) on success.
+  ///
+  int (CEF_CALLBACK *insert_radio_item_at)(struct _cef_menu_model_t* self,
+      int index, int command_id, const cef_string_t* label, int group_id);
+
+  ///
+  // Insert a sub-menu in the menu at the specified |index|. The new sub-menu is
+  // returned.
+  ///
+  struct _cef_menu_model_t* (CEF_CALLBACK *insert_sub_menu_at)(
+      struct _cef_menu_model_t* self, int index, int command_id,
+      const cef_string_t* label);
+
+  ///
+  // Removes the item with the specified |command_id|. Returns true (1) on
+  // success.
+  ///
+  int (CEF_CALLBACK *remove)(struct _cef_menu_model_t* self, int command_id);
+
+  ///
+  // Removes the item at the specified |index|. Returns true (1) on success.
+  ///
+  int (CEF_CALLBACK *remove_at)(struct _cef_menu_model_t* self, int index);
+
+  ///
+  // Returns the index associated with the specified |command_id| or -1 if not
+  // found due to the command id not existing in the menu.
+  ///
+  int (CEF_CALLBACK *get_index_of)(struct _cef_menu_model_t* self,
+      int command_id);
+
+  ///
+  // Returns the command id at the specified |index| or -1 if not found due to
+  // invalid range or the index being a separator.
+  ///
+  int (CEF_CALLBACK *get_command_id_at)(struct _cef_menu_model_t* self,
+      int index);
+
+  ///
+  // Sets the command id at the specified |index|. Returns true (1) on success.
+  ///
+  int (CEF_CALLBACK *set_command_id_at)(struct _cef_menu_model_t* self,
+      int index, int command_id);
+
+  ///
+  // Returns the label for the specified |command_id| or NULL if not found.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_label)(
+      struct _cef_menu_model_t* self, int command_id);
+
+  ///
+  // Returns the label at the specified |index| or NULL if not found due to
+  // invalid range or the index being a separator.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_label_at)(
+      struct _cef_menu_model_t* self, int index);
+
+  ///
+  // Sets the label for the specified |command_id|. Returns true (1) on success.
+  ///
+  int (CEF_CALLBACK *set_label)(struct _cef_menu_model_t* self, int command_id,
+      const cef_string_t* label);
+
+  ///
+  // Set the label at the specified |index|. Returns true (1) on success.
+  ///
+  int (CEF_CALLBACK *set_label_at)(struct _cef_menu_model_t* self, int index,
+      const cef_string_t* label);
+
+  ///
+  // Returns the item type for the specified |command_id|.
+  ///
+  cef_menu_item_type_t (CEF_CALLBACK *get_type)(struct _cef_menu_model_t* self,
+      int command_id);
+
+  ///
+  // Returns the item type at the specified |index|.
+  ///
+  cef_menu_item_type_t (CEF_CALLBACK *get_type_at)(
+      struct _cef_menu_model_t* self, int index);
+
+  ///
+  // Returns the group id for the specified |command_id| or -1 if invalid.
+  ///
+  int (CEF_CALLBACK *get_group_id)(struct _cef_menu_model_t* self,
+      int command_id);
+
+  ///
+  // Returns the group id at the specified |index| or -1 if invalid.
+  ///
+  int (CEF_CALLBACK *get_group_id_at)(struct _cef_menu_model_t* self,
+      int index);
+
+  ///
+  // Sets the group id for the specified |command_id|. Returns true (1) on
+  // success.
+  ///
+  int (CEF_CALLBACK *set_group_id)(struct _cef_menu_model_t* self,
+      int command_id, int group_id);
+
+  ///
+  // Sets the group id at the specified |index|. Returns true (1) on success.
+  ///
+  int (CEF_CALLBACK *set_group_id_at)(struct _cef_menu_model_t* self, int index,
+      int group_id);
+
+  ///
+  // Returns the submenu for the specified |command_id| or NULL if invalid.
+  ///
+  struct _cef_menu_model_t* (CEF_CALLBACK *get_sub_menu)(
+      struct _cef_menu_model_t* self, int command_id);
+
+  ///
+  // Returns the submenu at the specified |index| or NULL if invalid.
+  ///
+  struct _cef_menu_model_t* (CEF_CALLBACK *get_sub_menu_at)(
+      struct _cef_menu_model_t* self, int index);
+
+  ///
+  // Returns true (1) if the specified |command_id| is visible.
+  ///
+  int (CEF_CALLBACK *is_visible)(struct _cef_menu_model_t* self,
+      int command_id);
+
+  ///
+  // Returns true (1) if the specified |index| is visible.
+  ///
+  int (CEF_CALLBACK *is_visible_at)(struct _cef_menu_model_t* self, int index);
+
+  ///
+  // Change the visibility of the specified |command_id|. Returns true (1) on
+  // success.
+  ///
+  int (CEF_CALLBACK *set_visible)(struct _cef_menu_model_t* self,
+      int command_id, int visible);
+
+  ///
+  // Change the visibility at the specified |index|. Returns true (1) on
+  // success.
+  ///
+  int (CEF_CALLBACK *set_visible_at)(struct _cef_menu_model_t* self, int index,
+      int visible);
+
+  ///
+  // Returns true (1) if the specified |command_id| is enabled.
+  ///
+  int (CEF_CALLBACK *is_enabled)(struct _cef_menu_model_t* self,
+      int command_id);
+
+  ///
+  // Returns true (1) if the specified |index| is enabled.
+  ///
+  int (CEF_CALLBACK *is_enabled_at)(struct _cef_menu_model_t* self, int index);
+
+  ///
+  // Change the enabled status of the specified |command_id|. Returns true (1)
+  // on success.
+  ///
+  int (CEF_CALLBACK *set_enabled)(struct _cef_menu_model_t* self,
+      int command_id, int enabled);
+
+  ///
+  // Change the enabled status at the specified |index|. Returns true (1) on
+  // success.
+  ///
+  int (CEF_CALLBACK *set_enabled_at)(struct _cef_menu_model_t* self, int index,
+      int enabled);
+
+  ///
+  // Returns true (1) if the specified |command_id| is checked. Only applies to
+  // check and radio items.
+  ///
+  int (CEF_CALLBACK *is_checked)(struct _cef_menu_model_t* self,
+      int command_id);
+
+  ///
+  // Returns true (1) if the specified |index| is checked. Only applies to check
+  // and radio items.
+  ///
+  int (CEF_CALLBACK *is_checked_at)(struct _cef_menu_model_t* self, int index);
+
+  ///
+  // Check the specified |command_id|. Only applies to check and radio items.
+  // Returns true (1) on success.
+  ///
+  int (CEF_CALLBACK *set_checked)(struct _cef_menu_model_t* self,
+      int command_id, int checked);
+
+  ///
+  // Check the specified |index|. Only applies to check and radio items. Returns
+  // true (1) on success.
+  ///
+  int (CEF_CALLBACK *set_checked_at)(struct _cef_menu_model_t* self, int index,
+      int checked);
+
+  ///
+  // Returns true (1) if the specified |command_id| has a keyboard accelerator
+  // assigned.
+  ///
+  int (CEF_CALLBACK *has_accelerator)(struct _cef_menu_model_t* self,
+      int command_id);
+
+  ///
+  // Returns true (1) if the specified |index| has a keyboard accelerator
+  // assigned.
+  ///
+  int (CEF_CALLBACK *has_accelerator_at)(struct _cef_menu_model_t* self,
+      int index);
+
+  ///
+  // Set the keyboard accelerator for the specified |command_id|. |key_code| can
+  // be any virtual key or character value. Returns true (1) on success.
+  ///
+  int (CEF_CALLBACK *set_accelerator)(struct _cef_menu_model_t* self,
+      int command_id, int key_code, int shift_pressed, int ctrl_pressed,
+      int alt_pressed);
+
+  ///
+  // Set the keyboard accelerator at the specified |index|. |key_code| can be
+  // any virtual key or character value. Returns true (1) on success.
+  ///
+  int (CEF_CALLBACK *set_accelerator_at)(struct _cef_menu_model_t* self,
+      int index, int key_code, int shift_pressed, int ctrl_pressed,
+      int alt_pressed);
+
+  ///
+  // Remove the keyboard accelerator for the specified |command_id|. Returns
+  // true (1) on success.
+  ///
+  int (CEF_CALLBACK *remove_accelerator)(struct _cef_menu_model_t* self,
+      int command_id);
+
+  ///
+  // Remove the keyboard accelerator at the specified |index|. Returns true (1)
+  // on success.
+  ///
+  int (CEF_CALLBACK *remove_accelerator_at)(struct _cef_menu_model_t* self,
+      int index);
+
+  ///
+  // Retrieves the keyboard accelerator for the specified |command_id|. Returns
+  // true (1) on success.
+  ///
+  int (CEF_CALLBACK *get_accelerator)(struct _cef_menu_model_t* self,
+      int command_id, int* key_code, int* shift_pressed, int* ctrl_pressed,
+      int* alt_pressed);
+
+  ///
+  // Retrieves the keyboard accelerator for the specified |index|. Returns true
+  // (1) on success.
+  ///
+  int (CEF_CALLBACK *get_accelerator_at)(struct _cef_menu_model_t* self,
+      int index, int* key_code, int* shift_pressed, int* ctrl_pressed,
+      int* alt_pressed);
+} cef_menu_model_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_MENU_MODEL_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_navigation_entry_capi.h b/src/include/libcef_/capi/cef_navigation_entry_capi.h
new file mode 100644
index 0000000..3eb4668
--- /dev/null
+++ b/src/include/libcef_/capi/cef_navigation_entry_capi.h
@@ -0,0 +1,126 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_NAVIGATION_ENTRY_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_NAVIGATION_ENTRY_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Structure used to represent an entry in navigation history.
+///
+typedef struct _cef_navigation_entry_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns true (1) if this object is valid. Do not call any other functions
+  // if this function returns false (0).
+  ///
+  int (CEF_CALLBACK *is_valid)(struct _cef_navigation_entry_t* self);
+
+  ///
+  // Returns the actual URL of the page. For some pages this may be data: URL or
+  // similar. Use get_display_url() to return a display-friendly version.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_url)(
+      struct _cef_navigation_entry_t* self);
+
+  ///
+  // Returns a display-friendly version of the URL.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_display_url)(
+      struct _cef_navigation_entry_t* self);
+
+  ///
+  // Returns the original URL that was entered by the user before any redirects.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_original_url)(
+      struct _cef_navigation_entry_t* self);
+
+  ///
+  // Returns the title set by the page. This value may be NULL.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_title)(
+      struct _cef_navigation_entry_t* self);
+
+  ///
+  // Returns the transition type which indicates what the user did to move to
+  // this page from the previous page.
+  ///
+  cef_transition_type_t (CEF_CALLBACK *get_transition_type)(
+      struct _cef_navigation_entry_t* self);
+
+  ///
+  // Returns true (1) if this navigation includes post data.
+  ///
+  int (CEF_CALLBACK *has_post_data)(struct _cef_navigation_entry_t* self);
+
+  ///
+  // Returns the time for the last known successful navigation completion. A
+  // navigation may be completed more than once if the page is reloaded. May be
+  // 0 if the navigation has not yet completed.
+  ///
+  cef_time_t (CEF_CALLBACK *get_completion_time)(
+      struct _cef_navigation_entry_t* self);
+
+  ///
+  // Returns the HTTP status code for the last known successful navigation
+  // response. May be 0 if the response has not yet been received or if the
+  // navigation has not yet completed.
+  ///
+  int (CEF_CALLBACK *get_http_status_code)(
+      struct _cef_navigation_entry_t* self);
+} cef_navigation_entry_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_NAVIGATION_ENTRY_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_origin_whitelist_capi.h b/src/include/libcef_/capi/cef_origin_whitelist_capi.h
new file mode 100644
index 0000000..99a16b2
--- /dev/null
+++ b/src/include/libcef_/capi/cef_origin_whitelist_capi.h
@@ -0,0 +1,106 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_ORIGIN_WHITELIST_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_ORIGIN_WHITELIST_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Add an entry to the cross-origin access whitelist.
+//
+// The same-origin policy restricts how scripts hosted from different origins
+// (scheme + domain + port) can communicate. By default, scripts can only access
+// resources with the same origin. Scripts hosted on the HTTP and HTTPS schemes
+// (but no other schemes) can use the "Access-Control-Allow-Origin" header to
+// allow cross-origin requests. For example, https://source.example.com can make
+// XMLHttpRequest requests on http://target.example.com if the
+// http://target.example.com request returns an "Access-Control-Allow-Origin:
+// https://source.example.com" response header.
+//
+// Scripts in separate frames or iframes and hosted from the same protocol and
+// domain suffix can execute cross-origin JavaScript if both pages set the
+// document.domain value to the same domain suffix. For example,
+// scheme://foo.example.com and scheme://bar.example.com can communicate using
+// JavaScript if both domains set document.domain="example.com".
+//
+// This function is used to allow access to origins that would otherwise violate
+// the same-origin policy. Scripts hosted underneath the fully qualified
+// |source_origin| URL (like http://www.example.com) will be allowed access to
+// all resources hosted on the specified |target_protocol| and |target_domain|.
+// If |target_domain| is non-NULL and |allow_target_subdomains| if false (0)
+// only exact domain matches will be allowed. If |target_domain| contains a top-
+// level domain component (like "example.com") and |allow_target_subdomains| is
+// true (1) sub-domain matches will be allowed. If |target_domain| is NULL and
+// |allow_target_subdomains| if true (1) all domains and IP addresses will be
+// allowed.
+//
+// This function cannot be used to bypass the restrictions on local or display
+// isolated schemes. See the comments on CefRegisterCustomScheme for more
+// information.
+//
+// This function may be called on any thread. Returns false (0) if
+// |source_origin| is invalid or the whitelist cannot be accessed.
+///
+CEF_EXPORT int cef_add_cross_origin_whitelist_entry(
+    const cef_string_t* source_origin, const cef_string_t* target_protocol,
+    const cef_string_t* target_domain, int allow_target_subdomains);
+
+///
+// Remove an entry from the cross-origin access whitelist. Returns false (0) if
+// |source_origin| is invalid or the whitelist cannot be accessed.
+///
+CEF_EXPORT int cef_remove_cross_origin_whitelist_entry(
+    const cef_string_t* source_origin, const cef_string_t* target_protocol,
+    const cef_string_t* target_domain, int allow_target_subdomains);
+
+///
+// Remove all entries from the cross-origin access whitelist. Returns false (0)
+// if the whitelist cannot be accessed.
+///
+CEF_EXPORT int cef_clear_cross_origin_whitelist();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_ORIGIN_WHITELIST_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_parser_capi.h b/src/include/libcef_/capi/cef_parser_capi.h
new file mode 100644
index 0000000..c3375f2
--- /dev/null
+++ b/src/include/libcef_/capi/cef_parser_capi.h
@@ -0,0 +1,171 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_PARSER_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_PARSER_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Parse the specified |url| into its component parts. Returns false (0) if the
+// URL is NULL or invalid.
+///
+CEF_EXPORT int cef_parse_url(const cef_string_t* url,
+    struct _cef_urlparts_t* parts);
+
+///
+// Creates a URL from the specified |parts|, which must contain a non-NULL spec
+// or a non-NULL host and path (at a minimum), but not both. Returns false (0)
+// if |parts| isn't initialized as described.
+///
+CEF_EXPORT int cef_create_url(const struct _cef_urlparts_t* parts,
+    cef_string_t* url);
+
+///
+// This is a convenience function for formatting a URL in a concise and human-
+// friendly way to help users make security-related decisions (or in other
+// circumstances when people need to distinguish sites, origins, or otherwise-
+// simplified URLs from each other). Internationalized domain names (IDN) may be
+// presented in Unicode if |languages| accepts the Unicode representation. The
+// returned value will (a) omit the path for standard schemes, excepting file
+// and filesystem, and (b) omit the port if it is the default for the scheme. Do
+// not use this for URLs which will be parsed or sent to other applications.
+///
+// The resulting string must be freed by calling cef_string_userfree_free().
+CEF_EXPORT cef_string_userfree_t cef_format_url_for_security_display(
+    const cef_string_t* origin_url, const cef_string_t* languages);
+
+///
+// Returns the mime type for the specified file extension or an NULL string if
+// unknown.
+///
+// The resulting string must be freed by calling cef_string_userfree_free().
+CEF_EXPORT cef_string_userfree_t cef_get_mime_type(
+    const cef_string_t* extension);
+
+///
+// Get the extensions associated with the given mime type. This should be passed
+// in lower case. There could be multiple extensions for a given mime type, like
+// "html,htm" for "text/html", or "txt,text,html,..." for "text/*". Any existing
+// elements in the provided vector will not be erased.
+///
+CEF_EXPORT void cef_get_extensions_for_mime_type(const cef_string_t* mime_type,
+    cef_string_list_t extensions);
+
+///
+// Encodes |data| as a base64 string.
+///
+// The resulting string must be freed by calling cef_string_userfree_free().
+CEF_EXPORT cef_string_userfree_t cef_base64encode(const void* data,
+    size_t data_size);
+
+///
+// Decodes the base64 encoded string |data|. The returned value will be NULL if
+// the decoding fails.
+///
+CEF_EXPORT struct _cef_binary_value_t* cef_base64decode(
+    const cef_string_t* data);
+
+///
+// Escapes characters in |text| which are unsuitable for use as a query
+// parameter value. Everything except alphanumerics and -_.!~*'() will be
+// converted to "%XX". If |use_plus| is true (1) spaces will change to "+". The
+// result is basically the same as encodeURIComponent in Javacript.
+///
+// The resulting string must be freed by calling cef_string_userfree_free().
+CEF_EXPORT cef_string_userfree_t cef_uriencode(const cef_string_t* text,
+    int use_plus);
+
+///
+// Unescapes |text| and returns the result. Unescaping consists of looking for
+// the exact pattern "%XX" where each X is a hex digit and converting to the
+// character with the numerical value of those digits (e.g. "i%20=%203%3b"
+// unescapes to "i = 3;"). If |convert_to_utf8| is true (1) this function will
+// attempt to interpret the initial decoded result as UTF-8. If the result is
+// convertable into UTF-8 it will be returned as converted. Otherwise the
+// initial decoded result will be returned.  The |unescape_rule| parameter
+// supports further customization the decoding process.
+///
+// The resulting string must be freed by calling cef_string_userfree_free().
+CEF_EXPORT cef_string_userfree_t cef_uridecode(const cef_string_t* text,
+    int convert_to_utf8, cef_uri_unescape_rule_t unescape_rule);
+
+///
+// Parses |string| which represents a CSS color value. If |strict| is true (1)
+// strict parsing rules will be applied. Returns true (1) on success or false
+// (0) on error. If parsing succeeds |color| will be set to the color value
+// otherwise |color| will remain unchanged.
+///
+CEF_EXPORT int cef_parse_csscolor(const cef_string_t* string, int strict,
+    cef_color_t* color);
+
+///
+// Parses the specified |json_string| and returns a dictionary or list
+// representation. If JSON parsing fails this function returns NULL.
+///
+CEF_EXPORT struct _cef_value_t* cef_parse_json(const cef_string_t* json_string,
+    cef_json_parser_options_t options);
+
+///
+// Parses the specified |json_string| and returns a dictionary or list
+// representation. If JSON parsing fails this function returns NULL and
+// populates |error_code_out| and |error_msg_out| with an error code and a
+// formatted error message respectively.
+///
+CEF_EXPORT struct _cef_value_t* cef_parse_jsonand_return_error(
+    const cef_string_t* json_string, cef_json_parser_options_t options,
+    cef_json_parser_error_t* error_code_out, cef_string_t* error_msg_out);
+
+///
+// Generates a JSON string from the specified root |node| which should be a
+// dictionary or list value. Returns an NULL string on failure. This function
+// requires exclusive access to |node| including any underlying data.
+///
+// The resulting string must be freed by calling cef_string_userfree_free().
+CEF_EXPORT cef_string_userfree_t cef_write_json(struct _cef_value_t* node,
+    cef_json_writer_options_t options);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_PARSER_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_path_util_capi.h b/src/include/libcef_/capi/cef_path_util_capi.h
new file mode 100644
index 0000000..9de0d54
--- /dev/null
+++ b/src/include/libcef_/capi/cef_path_util_capi.h
@@ -0,0 +1,58 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_PATH_UTIL_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_PATH_UTIL_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Retrieve the path associated with the specified |key|. Returns true (1) on
+// success. Can be called on any thread in the browser process.
+///
+CEF_EXPORT int cef_get_path(cef_path_key_t key, cef_string_t* path);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_PATH_UTIL_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_print_handler_capi.h b/src/include/libcef_/capi/cef_print_handler_capi.h
new file mode 100644
index 0000000..af8d57e
--- /dev/null
+++ b/src/include/libcef_/capi/cef_print_handler_capi.h
@@ -0,0 +1,150 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_PRINT_HANDLER_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_PRINT_HANDLER_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+#include"libcef/capi/cef_browser_capi.h"
+#include"libcef/capi/cef_print_settings_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Callback structure for asynchronous continuation of print dialog requests.
+///
+typedef struct _cef_print_dialog_callback_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Continue printing with the specified |settings|.
+  ///
+  void (CEF_CALLBACK *cont)(struct _cef_print_dialog_callback_t* self,
+      struct _cef_print_settings_t* settings);
+
+  ///
+  // Cancel the printing.
+  ///
+  void (CEF_CALLBACK *cancel)(struct _cef_print_dialog_callback_t* self);
+} cef_print_dialog_callback_t;
+
+
+///
+// Callback structure for asynchronous continuation of print job requests.
+///
+typedef struct _cef_print_job_callback_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Indicate completion of the print job.
+  ///
+  void (CEF_CALLBACK *cont)(struct _cef_print_job_callback_t* self);
+} cef_print_job_callback_t;
+
+
+///
+// Implement this structure to handle printing on Linux. The functions of this
+// structure will be called on the browser process UI thread.
+///
+typedef struct _cef_print_handler_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Called when printing has started for the specified |browser|. This function
+  // will be called before the other OnPrint*() functions and irrespective of
+  // how printing was initiated (e.g. cef_browser_host_t::print(), JavaScript
+  // window.print() or PDF extension print button).
+  ///
+  void (CEF_CALLBACK *on_print_start)(struct _cef_print_handler_t* self,
+      struct _cef_browser_t* browser);
+
+  ///
+  // Synchronize |settings| with client state. If |get_defaults| is true (1)
+  // then populate |settings| with the default print settings. Do not keep a
+  // reference to |settings| outside of this callback.
+  ///
+  void (CEF_CALLBACK *on_print_settings)(struct _cef_print_handler_t* self,
+      struct _cef_print_settings_t* settings, int get_defaults);
+
+  ///
+  // Show the print dialog. Execute |callback| once the dialog is dismissed.
+  // Return true (1) if the dialog will be displayed or false (0) to cancel the
+  // printing immediately.
+  ///
+  int (CEF_CALLBACK *on_print_dialog)(struct _cef_print_handler_t* self,
+      int has_selection, struct _cef_print_dialog_callback_t* callback);
+
+  ///
+  // Send the print job to the printer. Execute |callback| once the job is
+  // completed. Return true (1) if the job will proceed or false (0) to cancel
+  // the job immediately.
+  ///
+  int (CEF_CALLBACK *on_print_job)(struct _cef_print_handler_t* self,
+      const cef_string_t* document_name, const cef_string_t* pdf_file_path,
+      struct _cef_print_job_callback_t* callback);
+
+  ///
+  // Reset client state related to printing.
+  ///
+  void (CEF_CALLBACK *on_print_reset)(struct _cef_print_handler_t* self);
+
+  ///
+  // Return the PDF paper size in device units. Used in combination with
+  // cef_browser_host_t::print_to_pdf().
+  ///
+  cef_size_t (CEF_CALLBACK *get_pdf_paper_size)(
+      struct _cef_print_handler_t* self, int device_units_per_inch);
+} cef_print_handler_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_PRINT_HANDLER_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_print_settings_capi.h b/src/include/libcef_/capi/cef_print_settings_capi.h
new file mode 100644
index 0000000..31efb50
--- /dev/null
+++ b/src/include/libcef_/capi/cef_print_settings_capi.h
@@ -0,0 +1,207 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_PRINT_SETTINGS_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_PRINT_SETTINGS_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Structure representing print settings.
+///
+typedef struct _cef_print_settings_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns true (1) if this object is valid. Do not call any other functions
+  // if this function returns false (0).
+  ///
+  int (CEF_CALLBACK *is_valid)(struct _cef_print_settings_t* self);
+
+  ///
+  // Returns true (1) if the values of this object are read-only. Some APIs may
+  // expose read-only objects.
+  ///
+  int (CEF_CALLBACK *is_read_only)(struct _cef_print_settings_t* self);
+
+  ///
+  // Returns a writable copy of this object.
+  ///
+  struct _cef_print_settings_t* (CEF_CALLBACK *copy)(
+      struct _cef_print_settings_t* self);
+
+  ///
+  // Set the page orientation.
+  ///
+  void (CEF_CALLBACK *set_orientation)(struct _cef_print_settings_t* self,
+      int landscape);
+
+  ///
+  // Returns true (1) if the orientation is landscape.
+  ///
+  int (CEF_CALLBACK *is_landscape)(struct _cef_print_settings_t* self);
+
+  ///
+  // Set the printer printable area in device units. Some platforms already
+  // provide flipped area. Set |landscape_needs_flip| to false (0) on those
+  // platforms to avoid double flipping.
+  ///
+  void (CEF_CALLBACK *set_printer_printable_area)(
+      struct _cef_print_settings_t* self,
+      const cef_size_t* physical_size_device_units,
+      const cef_rect_t* printable_area_device_units,
+      int landscape_needs_flip);
+
+  ///
+  // Set the device name.
+  ///
+  void (CEF_CALLBACK *set_device_name)(struct _cef_print_settings_t* self,
+      const cef_string_t* name);
+
+  ///
+  // Get the device name.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_device_name)(
+      struct _cef_print_settings_t* self);
+
+  ///
+  // Set the DPI (dots per inch).
+  ///
+  void (CEF_CALLBACK *set_dpi)(struct _cef_print_settings_t* self, int dpi);
+
+  ///
+  // Get the DPI (dots per inch).
+  ///
+  int (CEF_CALLBACK *get_dpi)(struct _cef_print_settings_t* self);
+
+  ///
+  // Set the page ranges.
+  ///
+  void (CEF_CALLBACK *set_page_ranges)(struct _cef_print_settings_t* self,
+      size_t rangesCount, cef_page_range_t const* ranges);
+
+  ///
+  // Returns the number of page ranges that currently exist.
+  ///
+  size_t (CEF_CALLBACK *get_page_ranges_count)(
+      struct _cef_print_settings_t* self);
+
+  ///
+  // Retrieve the page ranges.
+  ///
+  void (CEF_CALLBACK *get_page_ranges)(struct _cef_print_settings_t* self,
+      size_t* rangesCount, cef_page_range_t* ranges);
+
+  ///
+  // Set whether only the selection will be printed.
+  ///
+  void (CEF_CALLBACK *set_selection_only)(struct _cef_print_settings_t* self,
+      int selection_only);
+
+  ///
+  // Returns true (1) if only the selection will be printed.
+  ///
+  int (CEF_CALLBACK *is_selection_only)(struct _cef_print_settings_t* self);
+
+  ///
+  // Set whether pages will be collated.
+  ///
+  void (CEF_CALLBACK *set_collate)(struct _cef_print_settings_t* self,
+      int collate);
+
+  ///
+  // Returns true (1) if pages will be collated.
+  ///
+  int (CEF_CALLBACK *will_collate)(struct _cef_print_settings_t* self);
+
+  ///
+  // Set the color model.
+  ///
+  void (CEF_CALLBACK *set_color_model)(struct _cef_print_settings_t* self,
+      cef_color_model_t model);
+
+  ///
+  // Get the color model.
+  ///
+  cef_color_model_t (CEF_CALLBACK *get_color_model)(
+      struct _cef_print_settings_t* self);
+
+  ///
+  // Set the number of copies.
+  ///
+  void (CEF_CALLBACK *set_copies)(struct _cef_print_settings_t* self,
+      int copies);
+
+  ///
+  // Get the number of copies.
+  ///
+  int (CEF_CALLBACK *get_copies)(struct _cef_print_settings_t* self);
+
+  ///
+  // Set the duplex mode.
+  ///
+  void (CEF_CALLBACK *set_duplex_mode)(struct _cef_print_settings_t* self,
+      cef_duplex_mode_t mode);
+
+  ///
+  // Get the duplex mode.
+  ///
+  cef_duplex_mode_t (CEF_CALLBACK *get_duplex_mode)(
+      struct _cef_print_settings_t* self);
+} cef_print_settings_t;
+
+
+///
+// Create a new cef_print_settings_t object.
+///
+CEF_EXPORT cef_print_settings_t* cef_print_settings_create();
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_PRINT_SETTINGS_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_process_message_capi.h b/src/include/libcef_/capi/cef_process_message_capi.h
new file mode 100644
index 0000000..c8bbf54
--- /dev/null
+++ b/src/include/libcef_/capi/cef_process_message_capi.h
@@ -0,0 +1,102 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_PROCESS_MESSAGE_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_PROCESS_MESSAGE_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+#include"libcef/capi/cef_values_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Structure representing a message. Can be used on any process and thread.
+///
+typedef struct _cef_process_message_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns true (1) if this object is valid. Do not call any other functions
+  // if this function returns false (0).
+  ///
+  int (CEF_CALLBACK *is_valid)(struct _cef_process_message_t* self);
+
+  ///
+  // Returns true (1) if the values of this object are read-only. Some APIs may
+  // expose read-only objects.
+  ///
+  int (CEF_CALLBACK *is_read_only)(struct _cef_process_message_t* self);
+
+  ///
+  // Returns a writable copy of this object.
+  ///
+  struct _cef_process_message_t* (CEF_CALLBACK *copy)(
+      struct _cef_process_message_t* self);
+
+  ///
+  // Returns the message name.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_name)(
+      struct _cef_process_message_t* self);
+
+  ///
+  // Returns the list of arguments.
+  ///
+  struct _cef_list_value_t* (CEF_CALLBACK *get_argument_list)(
+      struct _cef_process_message_t* self);
+} cef_process_message_t;
+
+
+///
+// Create a new cef_process_message_t object with the specified name.
+///
+CEF_EXPORT cef_process_message_t* cef_process_message_create(
+    const cef_string_t* name);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_PROCESS_MESSAGE_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_process_util_capi.h b/src/include/libcef_/capi/cef_process_util_capi.h
new file mode 100644
index 0000000..95b6557
--- /dev/null
+++ b/src/include/libcef_/capi/cef_process_util_capi.h
@@ -0,0 +1,64 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_PROCESS_UTIL_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_PROCESS_UTIL_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Launches the process specified via |command_line|. Returns true (1) upon
+// success. Must be called on the browser process TID_PROCESS_LAUNCHER thread.
+//
+// Unix-specific notes: - All file descriptors open in the parent process will
+// be closed in the
+//   child process except for stdin, stdout, and stderr.
+// - If the first argument on the command line does not contain a slash,
+//   PATH will be searched. (See man execvp.)
+///
+CEF_EXPORT int cef_launch_process(struct _cef_command_line_t* command_line);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_PROCESS_UTIL_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_render_handler_capi.h b/src/include/libcef_/capi/cef_render_handler_capi.h
new file mode 100644
index 0000000..2934c9c
--- /dev/null
+++ b/src/include/libcef_/capi/cef_render_handler_capi.h
@@ -0,0 +1,171 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_RENDER_HANDLER_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_RENDER_HANDLER_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+#include"libcef/capi/cef_browser_capi.h"
+#include"libcef/capi/cef_drag_data_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Implement this structure to handle events when window rendering is disabled.
+// The functions of this structure will be called on the UI thread.
+///
+typedef struct _cef_render_handler_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Called to retrieve the root window rectangle in screen coordinates. Return
+  // true (1) if the rectangle was provided.
+  ///
+  int (CEF_CALLBACK *get_root_screen_rect)(struct _cef_render_handler_t* self,
+      struct _cef_browser_t* browser, cef_rect_t* rect);
+
+  ///
+  // Called to retrieve the view rectangle which is relative to screen
+  // coordinates. Return true (1) if the rectangle was provided.
+  ///
+  int (CEF_CALLBACK *get_view_rect)(struct _cef_render_handler_t* self,
+      struct _cef_browser_t* browser, cef_rect_t* rect);
+
+  ///
+  // Called to retrieve the translation from view coordinates to actual screen
+  // coordinates. Return true (1) if the screen coordinates were provided.
+  ///
+  int (CEF_CALLBACK *get_screen_point)(struct _cef_render_handler_t* self,
+      struct _cef_browser_t* browser, int viewX, int viewY, int* screenX,
+      int* screenY);
+
+  ///
+  // Called to allow the client to fill in the CefScreenInfo object with
+  // appropriate values. Return true (1) if the |screen_info| structure has been
+  // modified.
+  //
+  // If the screen info rectangle is left NULL the rectangle from GetViewRect
+  // will be used. If the rectangle is still NULL or invalid popups may not be
+  // drawn correctly.
+  ///
+  int (CEF_CALLBACK *get_screen_info)(struct _cef_render_handler_t* self,
+      struct _cef_browser_t* browser, struct _cef_screen_info_t* screen_info);
+
+  ///
+  // Called when the browser wants to show or hide the popup widget. The popup
+  // should be shown if |show| is true (1) and hidden if |show| is false (0).
+  ///
+  void (CEF_CALLBACK *on_popup_show)(struct _cef_render_handler_t* self,
+      struct _cef_browser_t* browser, int show);
+
+  ///
+  // Called when the browser wants to move or resize the popup widget. |rect|
+  // contains the new location and size in view coordinates.
+  ///
+  void (CEF_CALLBACK *on_popup_size)(struct _cef_render_handler_t* self,
+      struct _cef_browser_t* browser, const cef_rect_t* rect);
+
+  ///
+  // Called when an element should be painted. Pixel values passed to this
+  // function are scaled relative to view coordinates based on the value of
+  // CefScreenInfo.device_scale_factor returned from GetScreenInfo. |type|
+  // indicates whether the element is the view or the popup widget. |buffer|
+  // contains the pixel data for the whole image. |dirtyRects| contains the set
+  // of rectangles in pixel coordinates that need to be repainted. |buffer| will
+  // be |width|*|height|*4 bytes in size and represents a BGRA image with an
+  // upper-left origin.
+  ///
+  void (CEF_CALLBACK *on_paint)(struct _cef_render_handler_t* self,
+      struct _cef_browser_t* browser, cef_paint_element_type_t type,
+      size_t dirtyRectsCount, cef_rect_t const* dirtyRects, const void* buffer,
+      int width, int height);
+
+  ///
+  // Called when the browser's cursor has changed. If |type| is CT_CUSTOM then
+  // |custom_cursor_info| will be populated with the custom cursor information.
+  ///
+  void (CEF_CALLBACK *on_cursor_change)(struct _cef_render_handler_t* self,
+      struct _cef_browser_t* browser, cef_cursor_handle_t cursor,
+      cef_cursor_type_t type,
+      const struct _cef_cursor_info_t* custom_cursor_info);
+
+  ///
+  // Called when the user starts dragging content in the web view. Contextual
+  // information about the dragged content is supplied by |drag_data|. (|x|,
+  // |y|) is the drag start location in screen coordinates. OS APIs that run a
+  // system message loop may be used within the StartDragging call.
+  //
+  // Return false (0) to abort the drag operation. Don't call any of
+  // cef_browser_host_t::DragSource*Ended* functions after returning false (0).
+  //
+  // Return true (1) to handle the drag operation. Call
+  // cef_browser_host_t::DragSourceEndedAt and DragSourceSystemDragEnded either
+  // synchronously or asynchronously to inform the web view that the drag
+  // operation has ended.
+  ///
+  int (CEF_CALLBACK *start_dragging)(struct _cef_render_handler_t* self,
+      struct _cef_browser_t* browser, struct _cef_drag_data_t* drag_data,
+      cef_drag_operations_mask_t allowed_ops, int x, int y);
+
+  ///
+  // Called when the web view wants to update the mouse cursor during a drag &
+  // drop operation. |operation| describes the allowed operation (none, move,
+  // copy, link).
+  ///
+  void (CEF_CALLBACK *update_drag_cursor)(struct _cef_render_handler_t* self,
+      struct _cef_browser_t* browser, cef_drag_operations_mask_t operation);
+
+  ///
+  // Called when the scroll offset has changed.
+  ///
+  void (CEF_CALLBACK *on_scroll_offset_changed)(
+      struct _cef_render_handler_t* self, struct _cef_browser_t* browser,
+      double x, double y);
+} cef_render_handler_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_RENDER_HANDLER_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_render_process_handler_capi.h b/src/include/libcef_/capi/cef_render_process_handler_capi.h
new file mode 100644
index 0000000..5ce725b
--- /dev/null
+++ b/src/include/libcef_/capi/cef_render_process_handler_capi.h
@@ -0,0 +1,177 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_RENDER_PROCESS_HANDLER_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_RENDER_PROCESS_HANDLER_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+#include"libcef/capi/cef_browser_capi.h"
+#include"libcef/capi/cef_dom_capi.h"
+#include"libcef/capi/cef_frame_capi.h"
+#include"libcef/capi/cef_load_handler_capi.h"
+#include"libcef/capi/cef_process_message_capi.h"
+#include"libcef/capi/cef_v8_capi.h"
+#include"libcef/capi/cef_values_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Structure used to implement render process callbacks. The functions of this
+// structure will be called on the render process main thread (TID_RENDERER)
+// unless otherwise indicated.
+///
+typedef struct _cef_render_process_handler_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Called after the render process main thread has been created. |extra_info|
+  // is a read-only value originating from
+  // cef_browser_process_handler_t::on_render_process_thread_created(). Do not
+  // keep a reference to |extra_info| outside of this function.
+  ///
+  void (CEF_CALLBACK *on_render_thread_created)(
+      struct _cef_render_process_handler_t* self,
+      struct _cef_list_value_t* extra_info);
+
+  ///
+  // Called after WebKit has been initialized.
+  ///
+  void (CEF_CALLBACK *on_web_kit_initialized)(
+      struct _cef_render_process_handler_t* self);
+
+  ///
+  // Called after a browser has been created. When browsing cross-origin a new
+  // browser will be created before the old browser with the same identifier is
+  // destroyed.
+  ///
+  void (CEF_CALLBACK *on_browser_created)(
+      struct _cef_render_process_handler_t* self,
+      struct _cef_browser_t* browser);
+
+  ///
+  // Called before a browser is destroyed.
+  ///
+  void (CEF_CALLBACK *on_browser_destroyed)(
+      struct _cef_render_process_handler_t* self,
+      struct _cef_browser_t* browser);
+
+  ///
+  // Return the handler for browser load status events.
+  ///
+  struct _cef_load_handler_t* (CEF_CALLBACK *get_load_handler)(
+      struct _cef_render_process_handler_t* self);
+
+  ///
+  // Called before browser navigation. Return true (1) to cancel the navigation
+  // or false (0) to allow the navigation to proceed. The |request| object
+  // cannot be modified in this callback.
+  ///
+  int (CEF_CALLBACK *on_before_navigation)(
+      struct _cef_render_process_handler_t* self,
+      struct _cef_browser_t* browser, struct _cef_frame_t* frame,
+      struct _cef_request_t* request, cef_navigation_type_t navigation_type,
+      int is_redirect);
+
+  ///
+  // Called immediately after the V8 context for a frame has been created. To
+  // retrieve the JavaScript 'window' object use the
+  // cef_v8context_t::get_global() function. V8 handles can only be accessed
+  // from the thread on which they are created. A task runner for posting tasks
+  // on the associated thread can be retrieved via the
+  // cef_v8context_t::get_task_runner() function.
+  ///
+  void (CEF_CALLBACK *on_context_created)(
+      struct _cef_render_process_handler_t* self,
+      struct _cef_browser_t* browser, struct _cef_frame_t* frame,
+      struct _cef_v8context_t* context);
+
+  ///
+  // Called immediately before the V8 context for a frame is released. No
+  // references to the context should be kept after this function is called.
+  ///
+  void (CEF_CALLBACK *on_context_released)(
+      struct _cef_render_process_handler_t* self,
+      struct _cef_browser_t* browser, struct _cef_frame_t* frame,
+      struct _cef_v8context_t* context);
+
+  ///
+  // Called for global uncaught exceptions in a frame. Execution of this
+  // callback is disabled by default. To enable set
+  // CefSettings.uncaught_exception_stack_size > 0.
+  ///
+  void (CEF_CALLBACK *on_uncaught_exception)(
+      struct _cef_render_process_handler_t* self,
+      struct _cef_browser_t* browser, struct _cef_frame_t* frame,
+      struct _cef_v8context_t* context, struct _cef_v8exception_t* exception,
+      struct _cef_v8stack_trace_t* stackTrace);
+
+  ///
+  // Called when a new node in the the browser gets focus. The |node| value may
+  // be NULL if no specific node has gained focus. The node object passed to
+  // this function represents a snapshot of the DOM at the time this function is
+  // executed. DOM objects are only valid for the scope of this function. Do not
+  // keep references to or attempt to access any DOM objects outside the scope
+  // of this function.
+  ///
+  void (CEF_CALLBACK *on_focused_node_changed)(
+      struct _cef_render_process_handler_t* self,
+      struct _cef_browser_t* browser, struct _cef_frame_t* frame,
+      struct _cef_domnode_t* node);
+
+  ///
+  // Called when a new message is received from a different process. Return true
+  // (1) if the message was handled or false (0) otherwise. Do not keep a
+  // reference to or attempt to access the message outside of this callback.
+  ///
+  int (CEF_CALLBACK *on_process_message_received)(
+      struct _cef_render_process_handler_t* self,
+      struct _cef_browser_t* browser, cef_process_id_t source_process,
+      struct _cef_process_message_t* message);
+} cef_render_process_handler_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_RENDER_PROCESS_HANDLER_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_request_capi.h b/src/include/libcef_/capi/cef_request_capi.h
new file mode 100644
index 0000000..c7ba52f
--- /dev/null
+++ b/src/include/libcef_/capi/cef_request_capi.h
@@ -0,0 +1,330 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_REQUEST_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_REQUEST_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _cef_post_data_element_t;
+struct _cef_post_data_t;
+
+///
+// Structure used to represent a web request. The functions of this structure
+// may be called on any thread.
+///
+typedef struct _cef_request_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns true (1) if this object is read-only.
+  ///
+  int (CEF_CALLBACK *is_read_only)(struct _cef_request_t* self);
+
+  ///
+  // Get the fully qualified URL.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_url)(struct _cef_request_t* self);
+
+  ///
+  // Set the fully qualified URL.
+  ///
+  void (CEF_CALLBACK *set_url)(struct _cef_request_t* self,
+      const cef_string_t* url);
+
+  ///
+  // Get the request function type. The value will default to POST if post data
+  // is provided and GET otherwise.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_method)(struct _cef_request_t* self);
+
+  ///
+  // Set the request function type.
+  ///
+  void (CEF_CALLBACK *set_method)(struct _cef_request_t* self,
+      const cef_string_t* method);
+
+  ///
+  // Set the referrer URL and policy. If non-NULL the referrer URL must be fully
+  // qualified with an HTTP or HTTPS scheme component. Any username, password or
+  // ref component will be removed.
+  ///
+  void (CEF_CALLBACK *set_referrer)(struct _cef_request_t* self,
+      const cef_string_t* referrer_url, cef_referrer_policy_t policy);
+
+  ///
+  // Get the referrer URL.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_referrer_url)(
+      struct _cef_request_t* self);
+
+  ///
+  // Get the referrer policy.
+  ///
+  cef_referrer_policy_t (CEF_CALLBACK *get_referrer_policy)(
+      struct _cef_request_t* self);
+
+  ///
+  // Get the post data.
+  ///
+  struct _cef_post_data_t* (CEF_CALLBACK *get_post_data)(
+      struct _cef_request_t* self);
+
+  ///
+  // Set the post data.
+  ///
+  void (CEF_CALLBACK *set_post_data)(struct _cef_request_t* self,
+      struct _cef_post_data_t* postData);
+
+  ///
+  // Get the header values. Will not include the Referer value if any.
+  ///
+  void (CEF_CALLBACK *get_header_map)(struct _cef_request_t* self,
+      cef_string_multimap_t headerMap);
+
+  ///
+  // Set the header values. If a Referer value exists in the header map it will
+  // be removed and ignored.
+  ///
+  void (CEF_CALLBACK *set_header_map)(struct _cef_request_t* self,
+      cef_string_multimap_t headerMap);
+
+  ///
+  // Set all values at one time.
+  ///
+  void (CEF_CALLBACK *set)(struct _cef_request_t* self, const cef_string_t* url,
+      const cef_string_t* method, struct _cef_post_data_t* postData,
+      cef_string_multimap_t headerMap);
+
+  ///
+  // Get the flags used in combination with cef_urlrequest_t. See
+  // cef_urlrequest_flags_t for supported values.
+  ///
+  int (CEF_CALLBACK *get_flags)(struct _cef_request_t* self);
+
+  ///
+  // Set the flags used in combination with cef_urlrequest_t.  See
+  // cef_urlrequest_flags_t for supported values.
+  ///
+  void (CEF_CALLBACK *set_flags)(struct _cef_request_t* self, int flags);
+
+  ///
+  // Set the URL to the first party for cookies used in combination with
+  // cef_urlrequest_t.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_first_party_for_cookies)(
+      struct _cef_request_t* self);
+
+  ///
+  // Get the URL to the first party for cookies used in combination with
+  // cef_urlrequest_t.
+  ///
+  void (CEF_CALLBACK *set_first_party_for_cookies)(struct _cef_request_t* self,
+      const cef_string_t* url);
+
+  ///
+  // Get the resource type for this request. Only available in the browser
+  // process.
+  ///
+  cef_resource_type_t (CEF_CALLBACK *get_resource_type)(
+      struct _cef_request_t* self);
+
+  ///
+  // Get the transition type for this request. Only available in the browser
+  // process and only applies to requests that represent a main frame or sub-
+  // frame navigation.
+  ///
+  cef_transition_type_t (CEF_CALLBACK *get_transition_type)(
+      struct _cef_request_t* self);
+
+  ///
+  // Returns the globally unique identifier for this request or 0 if not
+  // specified. Can be used by cef_request_tHandler implementations in the
+  // browser process to track a single request across multiple callbacks.
+  ///
+  uint64 (CEF_CALLBACK *get_identifier)(struct _cef_request_t* self);
+} cef_request_t;
+
+
+///
+// Create a new cef_request_t object.
+///
+CEF_EXPORT cef_request_t* cef_request_create();
+
+
+///
+// Structure used to represent post data for a web request. The functions of
+// this structure may be called on any thread.
+///
+typedef struct _cef_post_data_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns true (1) if this object is read-only.
+  ///
+  int (CEF_CALLBACK *is_read_only)(struct _cef_post_data_t* self);
+
+  ///
+  // Returns true (1) if the underlying POST data includes elements that are not
+  // represented by this cef_post_data_t object (for example, multi-part file
+  // upload data). Modifying cef_post_data_t objects with excluded elements may
+  // result in the request failing.
+  ///
+  int (CEF_CALLBACK *has_excluded_elements)(struct _cef_post_data_t* self);
+
+  ///
+  // Returns the number of existing post data elements.
+  ///
+  size_t (CEF_CALLBACK *get_element_count)(struct _cef_post_data_t* self);
+
+  ///
+  // Retrieve the post data elements.
+  ///
+  void (CEF_CALLBACK *get_elements)(struct _cef_post_data_t* self,
+      size_t* elementsCount, struct _cef_post_data_element_t** elements);
+
+  ///
+  // Remove the specified post data element.  Returns true (1) if the removal
+  // succeeds.
+  ///
+  int (CEF_CALLBACK *remove_element)(struct _cef_post_data_t* self,
+      struct _cef_post_data_element_t* element);
+
+  ///
+  // Add the specified post data element.  Returns true (1) if the add succeeds.
+  ///
+  int (CEF_CALLBACK *add_element)(struct _cef_post_data_t* self,
+      struct _cef_post_data_element_t* element);
+
+  ///
+  // Remove all existing post data elements.
+  ///
+  void (CEF_CALLBACK *remove_elements)(struct _cef_post_data_t* self);
+} cef_post_data_t;
+
+
+///
+// Create a new cef_post_data_t object.
+///
+CEF_EXPORT cef_post_data_t* cef_post_data_create();
+
+
+///
+// Structure used to represent a single element in the request post data. The
+// functions of this structure may be called on any thread.
+///
+typedef struct _cef_post_data_element_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns true (1) if this object is read-only.
+  ///
+  int (CEF_CALLBACK *is_read_only)(struct _cef_post_data_element_t* self);
+
+  ///
+  // Remove all contents from the post data element.
+  ///
+  void (CEF_CALLBACK *set_to_empty)(struct _cef_post_data_element_t* self);
+
+  ///
+  // The post data element will represent a file.
+  ///
+  void (CEF_CALLBACK *set_to_file)(struct _cef_post_data_element_t* self,
+      const cef_string_t* fileName);
+
+  ///
+  // The post data element will represent bytes.  The bytes passed in will be
+  // copied.
+  ///
+  void (CEF_CALLBACK *set_to_bytes)(struct _cef_post_data_element_t* self,
+      size_t size, const void* bytes);
+
+  ///
+  // Return the type of this post data element.
+  ///
+  cef_postdataelement_type_t (CEF_CALLBACK *get_type)(
+      struct _cef_post_data_element_t* self);
+
+  ///
+  // Return the file name.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_file)(
+      struct _cef_post_data_element_t* self);
+
+  ///
+  // Return the number of bytes.
+  ///
+  size_t (CEF_CALLBACK *get_bytes_count)(struct _cef_post_data_element_t* self);
+
+  ///
+  // Read up to |size| bytes into |bytes| and return the number of bytes
+  // actually read.
+  ///
+  size_t (CEF_CALLBACK *get_bytes)(struct _cef_post_data_element_t* self,
+      size_t size, void* bytes);
+} cef_post_data_element_t;
+
+
+///
+// Create a new cef_post_data_element_t object.
+///
+CEF_EXPORT cef_post_data_element_t* cef_post_data_element_create();
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_REQUEST_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_request_context_capi.h b/src/include/libcef_/capi/cef_request_context_capi.h
new file mode 100644
index 0000000..9b463fe
--- /dev/null
+++ b/src/include/libcef_/capi/cef_request_context_capi.h
@@ -0,0 +1,291 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_REQUEST_CONTEXT_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_REQUEST_CONTEXT_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_callback_capi.h"
+#include"libcef/capi/cef_cookie_capi.h"
+#include"libcef/capi/cef_request_context_handler_capi.h"
+#include"libcef/capi/cef_values_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _cef_scheme_handler_factory_t;
+
+///
+// Callback structure for cef_request_tContext::ResolveHost.
+///
+typedef struct _cef_resolve_callback_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Called after the ResolveHost request has completed. |result| will be the
+  // result code. |resolved_ips| will be the list of resolved IP addresses or
+  // NULL if the resolution failed.
+  ///
+  void (CEF_CALLBACK *on_resolve_completed)(
+      struct _cef_resolve_callback_t* self, cef_errorcode_t result,
+      cef_string_list_t resolved_ips);
+} cef_resolve_callback_t;
+
+
+///
+// A request context provides request handling for a set of related browser or
+// URL request objects. A request context can be specified when creating a new
+// browser via the cef_browser_host_t static factory functions or when creating
+// a new URL request via the cef_urlrequest_t static factory functions. Browser
+// objects with different request contexts will never be hosted in the same
+// render process. Browser objects with the same request context may or may not
+// be hosted in the same render process depending on the process model. Browser
+// objects created indirectly via the JavaScript window.open function or
+// targeted links will share the same render process and the same request
+// context as the source browser. When running in single-process mode there is
+// only a single render process (the main process) and so all browsers created
+// in single-process mode will share the same request context. This will be the
+// first request context passed into a cef_browser_host_t static factory
+// function and all other request context objects will be ignored.
+///
+typedef struct _cef_request_context_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns true (1) if this object is pointing to the same context as |that|
+  // object.
+  ///
+  int (CEF_CALLBACK *is_same)(struct _cef_request_context_t* self,
+      struct _cef_request_context_t* other);
+
+  ///
+  // Returns true (1) if this object is sharing the same storage as |that|
+  // object.
+  ///
+  int (CEF_CALLBACK *is_sharing_with)(struct _cef_request_context_t* self,
+      struct _cef_request_context_t* other);
+
+  ///
+  // Returns true (1) if this object is the global context. The global context
+  // is used by default when creating a browser or URL request with a NULL
+  // context argument.
+  ///
+  int (CEF_CALLBACK *is_global)(struct _cef_request_context_t* self);
+
+  ///
+  // Returns the handler for this context if any.
+  ///
+  struct _cef_request_context_handler_t* (CEF_CALLBACK *get_handler)(
+      struct _cef_request_context_t* self);
+
+  ///
+  // Returns the cache path for this object. If NULL an "incognito mode" in-
+  // memory cache is being used.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_cache_path)(
+      struct _cef_request_context_t* self);
+
+  ///
+  // Returns the default cookie manager for this object. This will be the global
+  // cookie manager if this object is the global request context. Otherwise,
+  // this will be the default cookie manager used when this request context does
+  // not receive a value via cef_request_tContextHandler::get_cookie_manager().
+  // If |callback| is non-NULL it will be executed asnychronously on the IO
+  // thread after the manager's storage has been initialized.
+  ///
+  struct _cef_cookie_manager_t* (CEF_CALLBACK *get_default_cookie_manager)(
+      struct _cef_request_context_t* self,
+      struct _cef_completion_callback_t* callback);
+
+  ///
+  // Register a scheme handler factory for the specified |scheme_name| and
+  // optional |domain_name|. An NULL |domain_name| value for a standard scheme
+  // will cause the factory to match all domain names. The |domain_name| value
+  // will be ignored for non-standard schemes. If |scheme_name| is a built-in
+  // scheme and no handler is returned by |factory| then the built-in scheme
+  // handler factory will be called. If |scheme_name| is a custom scheme then
+  // you must also implement the cef_app_t::on_register_custom_schemes()
+  // function in all processes. This function may be called multiple times to
+  // change or remove the factory that matches the specified |scheme_name| and
+  // optional |domain_name|. Returns false (0) if an error occurs. This function
+  // may be called on any thread in the browser process.
+  ///
+  int (CEF_CALLBACK *register_scheme_handler_factory)(
+      struct _cef_request_context_t* self, const cef_string_t* scheme_name,
+      const cef_string_t* domain_name,
+      struct _cef_scheme_handler_factory_t* factory);
+
+  ///
+  // Clear all registered scheme handler factories. Returns false (0) on error.
+  // This function may be called on any thread in the browser process.
+  ///
+  int (CEF_CALLBACK *clear_scheme_handler_factories)(
+      struct _cef_request_context_t* self);
+
+  ///
+  // Tells all renderer processes associated with this context to throw away
+  // their plugin list cache. If |reload_pages| is true (1) they will also
+  // reload all pages with plugins.
+  // cef_request_tContextHandler::OnBeforePluginLoad may be called to rebuild
+  // the plugin list cache.
+  ///
+  void (CEF_CALLBACK *purge_plugin_list_cache)(
+      struct _cef_request_context_t* self, int reload_pages);
+
+  ///
+  // Returns true (1) if a preference with the specified |name| exists. This
+  // function must be called on the browser process UI thread.
+  ///
+  int (CEF_CALLBACK *has_preference)(struct _cef_request_context_t* self,
+      const cef_string_t* name);
+
+  ///
+  // Returns the value for the preference with the specified |name|. Returns
+  // NULL if the preference does not exist. The returned object contains a copy
+  // of the underlying preference value and modifications to the returned object
+  // will not modify the underlying preference value. This function must be
+  // called on the browser process UI thread.
+  ///
+  struct _cef_value_t* (CEF_CALLBACK *get_preference)(
+      struct _cef_request_context_t* self, const cef_string_t* name);
+
+  ///
+  // Returns all preferences as a dictionary. If |include_defaults| is true (1)
+  // then preferences currently at their default value will be included. The
+  // returned object contains a copy of the underlying preference values and
+  // modifications to the returned object will not modify the underlying
+  // preference values. This function must be called on the browser process UI
+  // thread.
+  ///
+  struct _cef_dictionary_value_t* (CEF_CALLBACK *get_all_preferences)(
+      struct _cef_request_context_t* self, int include_defaults);
+
+  ///
+  // Returns true (1) if the preference with the specified |name| can be
+  // modified using SetPreference. As one example preferences set via the
+  // command-line usually cannot be modified. This function must be called on
+  // the browser process UI thread.
+  ///
+  int (CEF_CALLBACK *can_set_preference)(struct _cef_request_context_t* self,
+      const cef_string_t* name);
+
+  ///
+  // Set the |value| associated with preference |name|. Returns true (1) if the
+  // value is set successfully and false (0) otherwise. If |value| is NULL the
+  // preference will be restored to its default value. If setting the preference
+  // fails then |error| will be populated with a detailed description of the
+  // problem. This function must be called on the browser process UI thread.
+  ///
+  int (CEF_CALLBACK *set_preference)(struct _cef_request_context_t* self,
+      const cef_string_t* name, struct _cef_value_t* value,
+      cef_string_t* error);
+
+  ///
+  // Clears all certificate exceptions that were added as part of handling
+  // cef_request_tHandler::on_certificate_error(). If you call this it is
+  // recommended that you also call close_all_connections() or you risk not
+  // being prompted again for server certificates if you reconnect quickly. If
+  // |callback| is non-NULL it will be executed on the UI thread after
+  // completion.
+  ///
+  void (CEF_CALLBACK *clear_certificate_exceptions)(
+      struct _cef_request_context_t* self,
+      struct _cef_completion_callback_t* callback);
+
+  ///
+  // Clears all active and idle connections that Chromium currently has. This is
+  // only recommended if you have released all other CEF objects but don't yet
+  // want to call cef_shutdown(). If |callback| is non-NULL it will be executed
+  // on the UI thread after completion.
+  ///
+  void (CEF_CALLBACK *close_all_connections)(
+      struct _cef_request_context_t* self,
+      struct _cef_completion_callback_t* callback);
+
+  ///
+  // Attempts to resolve |origin| to a list of associated IP addresses.
+  // |callback| will be executed on the UI thread after completion.
+  ///
+  void (CEF_CALLBACK *resolve_host)(struct _cef_request_context_t* self,
+      const cef_string_t* origin, struct _cef_resolve_callback_t* callback);
+
+  ///
+  // Attempts to resolve |origin| to a list of associated IP addresses using
+  // cached data. |resolved_ips| will be populated with the list of resolved IP
+  // addresses or NULL if no cached data is available. Returns ERR_NONE on
+  // success. This function must be called on the browser process IO thread.
+  ///
+  cef_errorcode_t (CEF_CALLBACK *resolve_host_cached)(
+      struct _cef_request_context_t* self, const cef_string_t* origin,
+      cef_string_list_t resolved_ips);
+} cef_request_context_t;
+
+
+///
+// Returns the global context object.
+///
+CEF_EXPORT cef_request_context_t* cef_request_context_get_global_context();
+
+///
+// Creates a new context object with the specified |settings| and optional
+// |handler|.
+///
+CEF_EXPORT cef_request_context_t* cef_request_context_create_context(
+    const struct _cef_request_context_settings_t* settings,
+    struct _cef_request_context_handler_t* handler);
+
+///
+// Creates a new context object that shares storage with |other| and uses an
+// optional |handler|.
+///
+CEF_EXPORT cef_request_context_t* create_context_shared(
+    cef_request_context_t* other,
+    struct _cef_request_context_handler_t* handler);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_REQUEST_CONTEXT_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_request_context_handler_capi.h b/src/include/libcef_/capi/cef_request_context_handler_capi.h
new file mode 100644
index 0000000..f963870
--- /dev/null
+++ b/src/include/libcef_/capi/cef_request_context_handler_capi.h
@@ -0,0 +1,99 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_REQUEST_CONTEXT_HANDLER_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_REQUEST_CONTEXT_HANDLER_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+#include"libcef/capi/cef_cookie_capi.h"
+#include"libcef/capi/cef_web_plugin_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Implement this structure to provide handler implementations. The handler
+// instance will not be released until all objects related to the context have
+// been destroyed.
+///
+typedef struct _cef_request_context_handler_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Called on the browser process IO thread to retrieve the cookie manager. If
+  // this function returns NULL the default cookie manager retrievable via
+  // cef_request_tContext::get_default_cookie_manager() will be used.
+  ///
+  struct _cef_cookie_manager_t* (CEF_CALLBACK *get_cookie_manager)(
+      struct _cef_request_context_handler_t* self);
+
+  ///
+  // Called on multiple browser process threads before a plugin instance is
+  // loaded. |mime_type| is the mime type of the plugin that will be loaded.
+  // |plugin_url| is the content URL that the plugin will load and may be NULL.
+  // |top_origin_url| is the URL for the top-level frame that contains the
+  // plugin when loading a specific plugin instance or NULL when building the
+  // initial list of enabled plugins for 'navigator.plugins' JavaScript state.
+  // |plugin_info| includes additional information about the plugin that will be
+  // loaded. |plugin_policy| is the recommended policy. Modify |plugin_policy|
+  // and return true (1) to change the policy. Return false (0) to use the
+  // recommended policy. The default plugin policy can be set at runtime using
+  // the `--plugin-policy=[allow|detect|block]` command-line flag. Decisions to
+  // mark a plugin as disabled by setting |plugin_policy| to
+  // PLUGIN_POLICY_DISABLED may be cached when |top_origin_url| is NULL. To
+  // purge the plugin list cache and potentially trigger new calls to this
+  // function call cef_request_tContext::PurgePluginListCache.
+  ///
+  int (CEF_CALLBACK *on_before_plugin_load)(
+      struct _cef_request_context_handler_t* self,
+      const cef_string_t* mime_type, const cef_string_t* plugin_url,
+      const cef_string_t* top_origin_url,
+      struct _cef_web_plugin_info_t* plugin_info,
+      cef_plugin_policy_t* plugin_policy);
+} cef_request_context_handler_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_REQUEST_CONTEXT_HANDLER_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_request_handler_capi.h b/src/include/libcef_/capi/cef_request_handler_capi.h
new file mode 100644
index 0000000..aee90f9
--- /dev/null
+++ b/src/include/libcef_/capi/cef_request_handler_capi.h
@@ -0,0 +1,270 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_REQUEST_HANDLER_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_REQUEST_HANDLER_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_auth_callback_capi.h"
+#include"libcef/capi/cef_base_capi.h"
+#include"libcef/capi/cef_browser_capi.h"
+#include"libcef/capi/cef_frame_capi.h"
+#include"libcef/capi/cef_request_capi.h"
+#include"libcef/capi/cef_resource_handler_capi.h"
+#include"libcef/capi/cef_response_capi.h"
+#include"libcef/capi/cef_response_filter_capi.h"
+#include"libcef/capi/cef_ssl_info_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Callback structure used for asynchronous continuation of url requests.
+///
+typedef struct _cef_request_callback_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Continue the url request. If |allow| is true (1) the request will be
+  // continued. Otherwise, the request will be canceled.
+  ///
+  void (CEF_CALLBACK *cont)(struct _cef_request_callback_t* self, int allow);
+
+  ///
+  // Cancel the url request.
+  ///
+  void (CEF_CALLBACK *cancel)(struct _cef_request_callback_t* self);
+} cef_request_callback_t;
+
+
+///
+// Implement this structure to handle events related to browser requests. The
+// functions of this structure will be called on the thread indicated.
+///
+typedef struct _cef_request_handler_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Called on the UI thread before browser navigation. Return true (1) to
+  // cancel the navigation or false (0) to allow the navigation to proceed. The
+  // |request| object cannot be modified in this callback.
+  // cef_load_handler_t::OnLoadingStateChange will be called twice in all cases.
+  // If the navigation is allowed cef_load_handler_t::OnLoadStart and
+  // cef_load_handler_t::OnLoadEnd will be called. If the navigation is canceled
+  // cef_load_handler_t::OnLoadError will be called with an |errorCode| value of
+  // ERR_ABORTED.
+  ///
+  int (CEF_CALLBACK *on_before_browse)(struct _cef_request_handler_t* self,
+      struct _cef_browser_t* browser, struct _cef_frame_t* frame,
+      struct _cef_request_t* request, int is_redirect);
+
+  ///
+  // Called on the UI thread before OnBeforeBrowse in certain limited cases
+  // where navigating a new or different browser might be desirable. This
+  // includes user-initiated navigation that might open in a special way (e.g.
+  // links clicked via middle-click or ctrl + left-click) and certain types of
+  // cross-origin navigation initiated from the renderer process (e.g.
+  // navigating the top-level frame to/from a file URL). The |browser| and
+  // |frame| values represent the source of the navigation. The
+  // |target_disposition| value indicates where the user intended to navigate
+  // the browser based on standard Chromium behaviors (e.g. current tab, new
+  // tab, etc). The |user_gesture| value will be true (1) if the browser
+  // navigated via explicit user gesture (e.g. clicking a link) or false (0) if
+  // it navigated automatically (e.g. via the DomContentLoaded event). Return
+  // true (1) to cancel the navigation or false (0) to allow the navigation to
+  // proceed in the source browser's top-level frame.
+  ///
+  int (CEF_CALLBACK *on_open_urlfrom_tab)(struct _cef_request_handler_t* self,
+      struct _cef_browser_t* browser, struct _cef_frame_t* frame,
+      const cef_string_t* target_url,
+      cef_window_open_disposition_t target_disposition, int user_gesture);
+
+  ///
+  // Called on the IO thread before a resource request is loaded. The |request|
+  // object may be modified. Return RV_CONTINUE to continue the request
+  // immediately. Return RV_CONTINUE_ASYNC and call cef_request_tCallback::
+  // cont() at a later time to continue or cancel the request asynchronously.
+  // Return RV_CANCEL to cancel the request immediately.
+  //
+  ///
+  cef_return_value_t (CEF_CALLBACK *on_before_resource_load)(
+      struct _cef_request_handler_t* self, struct _cef_browser_t* browser,
+      struct _cef_frame_t* frame, struct _cef_request_t* request,
+      struct _cef_request_callback_t* callback);
+
+  ///
+  // Called on the IO thread before a resource is loaded. To allow the resource
+  // to load normally return NULL. To specify a handler for the resource return
+  // a cef_resource_handler_t object. The |request| object should not be
+  // modified in this callback.
+  ///
+  struct _cef_resource_handler_t* (CEF_CALLBACK *get_resource_handler)(
+      struct _cef_request_handler_t* self, struct _cef_browser_t* browser,
+      struct _cef_frame_t* frame, struct _cef_request_t* request);
+
+  ///
+  // Called on the IO thread when a resource load is redirected. The |request|
+  // parameter will contain the old URL and other request-related information.
+  // The |new_url| parameter will contain the new URL and can be changed if
+  // desired. The |request| object cannot be modified in this callback.
+  ///
+  void (CEF_CALLBACK *on_resource_redirect)(struct _cef_request_handler_t* self,
+      struct _cef_browser_t* browser, struct _cef_frame_t* frame,
+      struct _cef_request_t* request, cef_string_t* new_url);
+
+  ///
+  // Called on the IO thread when a resource response is received. To allow the
+  // resource to load normally return false (0). To redirect or retry the
+  // resource modify |request| (url, headers or post body) and return true (1).
+  // The |response| object cannot be modified in this callback.
+  ///
+  int (CEF_CALLBACK *on_resource_response)(struct _cef_request_handler_t* self,
+      struct _cef_browser_t* browser, struct _cef_frame_t* frame,
+      struct _cef_request_t* request, struct _cef_response_t* response);
+
+  ///
+  // Called on the IO thread to optionally filter resource response content.
+  // |request| and |response| represent the request and response respectively
+  // and cannot be modified in this callback.
+  ///
+  struct _cef_response_filter_t* (CEF_CALLBACK *get_resource_response_filter)(
+      struct _cef_request_handler_t* self, struct _cef_browser_t* browser,
+      struct _cef_frame_t* frame, struct _cef_request_t* request,
+      struct _cef_response_t* response);
+
+  ///
+  // Called on the IO thread when a resource load has completed. |request| and
+  // |response| represent the request and response respectively and cannot be
+  // modified in this callback. |status| indicates the load completion status.
+  // |received_content_length| is the number of response bytes actually read.
+  ///
+  void (CEF_CALLBACK *on_resource_load_complete)(
+      struct _cef_request_handler_t* self, struct _cef_browser_t* browser,
+      struct _cef_frame_t* frame, struct _cef_request_t* request,
+      struct _cef_response_t* response, cef_urlrequest_status_t status,
+      int64 received_content_length);
+
+  ///
+  // Called on the IO thread when the browser needs credentials from the user.
+  // |isProxy| indicates whether the host is a proxy server. |host| contains the
+  // hostname and |port| contains the port number. |realm| is the realm of the
+  // challenge and may be NULL. |scheme| is the authentication scheme used, such
+  // as "basic" or "digest", and will be NULL if the source of the request is an
+  // FTP server. Return true (1) to continue the request and call
+  // cef_auth_callback_t::cont() either in this function or at a later time when
+  // the authentication information is available. Return false (0) to cancel the
+  // request immediately.
+  ///
+  int (CEF_CALLBACK *get_auth_credentials)(struct _cef_request_handler_t* self,
+      struct _cef_browser_t* browser, struct _cef_frame_t* frame, int isProxy,
+      const cef_string_t* host, int port, const cef_string_t* realm,
+      const cef_string_t* scheme, struct _cef_auth_callback_t* callback);
+
+  ///
+  // Called on the IO thread when JavaScript requests a specific storage quota
+  // size via the webkitStorageInfo.requestQuota function. |origin_url| is the
+  // origin of the page making the request. |new_size| is the requested quota
+  // size in bytes. Return true (1) to continue the request and call
+  // cef_request_tCallback::cont() either in this function or at a later time to
+  // grant or deny the request. Return false (0) to cancel the request
+  // immediately.
+  ///
+  int (CEF_CALLBACK *on_quota_request)(struct _cef_request_handler_t* self,
+      struct _cef_browser_t* browser, const cef_string_t* origin_url,
+      int64 new_size, struct _cef_request_callback_t* callback);
+
+  ///
+  // Called on the UI thread to handle requests for URLs with an unknown
+  // protocol component. Set |allow_os_execution| to true (1) to attempt
+  // execution via the registered OS protocol handler, if any. SECURITY WARNING:
+  // YOU SHOULD USE THIS METHOD TO ENFORCE RESTRICTIONS BASED ON SCHEME, HOST OR
+  // OTHER URL ANALYSIS BEFORE ALLOWING OS EXECUTION.
+  ///
+  void (CEF_CALLBACK *on_protocol_execution)(
+      struct _cef_request_handler_t* self, struct _cef_browser_t* browser,
+      const cef_string_t* url, int* allow_os_execution);
+
+  ///
+  // Called on the UI thread to handle requests for URLs with an invalid SSL
+  // certificate. Return true (1) and call cef_request_tCallback::cont() either
+  // in this function or at a later time to continue or cancel the request.
+  // Return false (0) to cancel the request immediately. If
+  // CefSettings.ignore_certificate_errors is set all invalid certificates will
+  // be accepted without calling this function.
+  ///
+  int (CEF_CALLBACK *on_certificate_error)(struct _cef_request_handler_t* self,
+      struct _cef_browser_t* browser, cef_errorcode_t cert_error,
+      const cef_string_t* request_url, struct _cef_sslinfo_t* ssl_info,
+      struct _cef_request_callback_t* callback);
+
+  ///
+  // Called on the browser process UI thread when a plugin has crashed.
+  // |plugin_path| is the path of the plugin that crashed.
+  ///
+  void (CEF_CALLBACK *on_plugin_crashed)(struct _cef_request_handler_t* self,
+      struct _cef_browser_t* browser, const cef_string_t* plugin_path);
+
+  ///
+  // Called on the browser process UI thread when the render view associated
+  // with |browser| is ready to receive/handle IPC messages in the render
+  // process.
+  ///
+  void (CEF_CALLBACK *on_render_view_ready)(struct _cef_request_handler_t* self,
+      struct _cef_browser_t* browser);
+
+  ///
+  // Called on the browser process UI thread when the render process terminates
+  // unexpectedly. |status| indicates how the process terminated.
+  ///
+  void (CEF_CALLBACK *on_render_process_terminated)(
+      struct _cef_request_handler_t* self, struct _cef_browser_t* browser,
+      cef_termination_status_t status);
+} cef_request_handler_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_REQUEST_HANDLER_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_resource_bundle_capi.h b/src/include/libcef_/capi/cef_resource_bundle_capi.h
new file mode 100644
index 0000000..8029693
--- /dev/null
+++ b/src/include/libcef_/capi/cef_resource_bundle_capi.h
@@ -0,0 +1,107 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_RESOURCE_BUNDLE_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_RESOURCE_BUNDLE_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Structure used for retrieving resources from the resource bundle (*.pak)
+// files loaded by CEF during startup or via the cef_resource_bundle_tHandler
+// returned from cef_app_t::GetResourceBundleHandler. See CefSettings for
+// additional options related to resource bundle loading. The functions of this
+// structure may be called on any thread unless otherwise indicated.
+///
+typedef struct _cef_resource_bundle_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns the localized string for the specified |string_id| or an NULL
+  // string if the value is not found. Include cef_pack_strings.h for a listing
+  // of valid string ID values.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_localized_string)(
+      struct _cef_resource_bundle_t* self, int string_id);
+
+  ///
+  // Retrieves the contents of the specified scale independent |resource_id|. If
+  // the value is found then |data| and |data_size| will be populated and this
+  // function will return true (1). If the value is not found then this function
+  // will return false (0). The returned |data| pointer will remain resident in
+  // memory and should not be freed. Include cef_pack_resources.h for a listing
+  // of valid resource ID values.
+  ///
+  int (CEF_CALLBACK *get_data_resource)(struct _cef_resource_bundle_t* self,
+      int resource_id, void** data, size_t* data_size);
+
+  ///
+  // Retrieves the contents of the specified |resource_id| nearest the scale
+  // factor |scale_factor|. Use a |scale_factor| value of SCALE_FACTOR_NONE for
+  // scale independent resources or call GetDataResource instead. If the value
+  // is found then |data| and |data_size| will be populated and this function
+  // will return true (1). If the value is not found then this function will
+  // return false (0). The returned |data| pointer will remain resident in
+  // memory and should not be freed. Include cef_pack_resources.h for a listing
+  // of valid resource ID values.
+  ///
+  int (CEF_CALLBACK *get_data_resource_for_scale)(
+      struct _cef_resource_bundle_t* self, int resource_id,
+      cef_scale_factor_t scale_factor, void** data, size_t* data_size);
+} cef_resource_bundle_t;
+
+
+///
+// Returns the global resource bundle instance.
+///
+CEF_EXPORT cef_resource_bundle_t* cef_resource_bundle_get_global();
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_RESOURCE_BUNDLE_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_resource_bundle_handler_capi.h b/src/include/libcef_/capi/cef_resource_bundle_handler_capi.h
new file mode 100644
index 0000000..2ae07c0
--- /dev/null
+++ b/src/include/libcef_/capi/cef_resource_bundle_handler_capi.h
@@ -0,0 +1,99 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_RESOURCE_BUNDLE_HANDLER_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_RESOURCE_BUNDLE_HANDLER_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Structure used to implement a custom resource bundle structure. See
+// CefSettings for additional options related to resource bundle loading. The
+// functions of this structure may be called on multiple threads.
+///
+typedef struct _cef_resource_bundle_handler_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Called to retrieve a localized translation for the specified |string_id|.
+  // To provide the translation set |string| to the translation string and
+  // return true (1). To use the default translation return false (0). Include
+  // cef_pack_strings.h for a listing of valid string ID values.
+  ///
+  int (CEF_CALLBACK *get_localized_string)(
+      struct _cef_resource_bundle_handler_t* self, int string_id,
+      cef_string_t* string);
+
+  ///
+  // Called to retrieve data for the specified scale independent |resource_id|.
+  // To provide the resource data set |data| and |data_size| to the data pointer
+  // and size respectively and return true (1). To use the default resource data
+  // return false (0). The resource data will not be copied and must remain
+  // resident in memory. Include cef_pack_resources.h for a listing of valid
+  // resource ID values.
+  ///
+  int (CEF_CALLBACK *get_data_resource)(
+      struct _cef_resource_bundle_handler_t* self, int resource_id, void** data,
+      size_t* data_size);
+
+  ///
+  // Called to retrieve data for the specified |resource_id| nearest the scale
+  // factor |scale_factor|. To provide the resource data set |data| and
+  // |data_size| to the data pointer and size respectively and return true (1).
+  // To use the default resource data return false (0). The resource data will
+  // not be copied and must remain resident in memory. Include
+  // cef_pack_resources.h for a listing of valid resource ID values.
+  ///
+  int (CEF_CALLBACK *get_data_resource_for_scale)(
+      struct _cef_resource_bundle_handler_t* self, int resource_id,
+      cef_scale_factor_t scale_factor, void** data, size_t* data_size);
+} cef_resource_bundle_handler_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_RESOURCE_BUNDLE_HANDLER_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_resource_handler_capi.h b/src/include/libcef_/capi/cef_resource_handler_capi.h
new file mode 100644
index 0000000..756dfbd
--- /dev/null
+++ b/src/include/libcef_/capi/cef_resource_handler_capi.h
@@ -0,0 +1,124 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_RESOURCE_HANDLER_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_RESOURCE_HANDLER_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+#include"libcef/capi/cef_browser_capi.h"
+#include"libcef/capi/cef_callback_capi.h"
+#include"libcef/capi/cef_cookie_capi.h"
+#include"libcef/capi/cef_request_capi.h"
+#include"libcef/capi/cef_response_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Structure used to implement a custom request handler structure. The functions
+// of this structure will always be called on the IO thread.
+///
+typedef struct _cef_resource_handler_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Begin processing the request. To handle the request return true (1) and
+  // call cef_callback_t::cont() once the response header information is
+  // available (cef_callback_t::cont() can also be called from inside this
+  // function if header information is available immediately). To cancel the
+  // request return false (0).
+  ///
+  int (CEF_CALLBACK *process_request)(struct _cef_resource_handler_t* self,
+      struct _cef_request_t* request, struct _cef_callback_t* callback);
+
+  ///
+  // Retrieve response header information. If the response length is not known
+  // set |response_length| to -1 and read_response() will be called until it
+  // returns false (0). If the response length is known set |response_length| to
+  // a positive value and read_response() will be called until it returns false
+  // (0) or the specified number of bytes have been read. Use the |response|
+  // object to set the mime type, http status code and other optional header
+  // values. To redirect the request to a new URL set |redirectUrl| to the new
+  // URL.
+  ///
+  void (CEF_CALLBACK *get_response_headers)(
+      struct _cef_resource_handler_t* self, struct _cef_response_t* response,
+      int64* response_length, cef_string_t* redirectUrl);
+
+  ///
+  // Read response data. If data is available immediately copy up to
+  // |bytes_to_read| bytes into |data_out|, set |bytes_read| to the number of
+  // bytes copied, and return true (1). To read the data at a later time set
+  // |bytes_read| to 0, return true (1) and call cef_callback_t::cont() when the
+  // data is available. To indicate response completion return false (0).
+  ///
+  int (CEF_CALLBACK *read_response)(struct _cef_resource_handler_t* self,
+      void* data_out, int bytes_to_read, int* bytes_read,
+      struct _cef_callback_t* callback);
+
+  ///
+  // Return true (1) if the specified cookie can be sent with the request or
+  // false (0) otherwise. If false (0) is returned for any cookie then no
+  // cookies will be sent with the request.
+  ///
+  int (CEF_CALLBACK *can_get_cookie)(struct _cef_resource_handler_t* self,
+      const struct _cef_cookie_t* cookie);
+
+  ///
+  // Return true (1) if the specified cookie returned with the response can be
+  // set or false (0) otherwise.
+  ///
+  int (CEF_CALLBACK *can_set_cookie)(struct _cef_resource_handler_t* self,
+      const struct _cef_cookie_t* cookie);
+
+  ///
+  // Request processing has been canceled.
+  ///
+  void (CEF_CALLBACK *cancel)(struct _cef_resource_handler_t* self);
+} cef_resource_handler_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_RESOURCE_HANDLER_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_response_capi.h b/src/include/libcef_/capi/cef_response_capi.h
new file mode 100644
index 0000000..da309d9
--- /dev/null
+++ b/src/include/libcef_/capi/cef_response_capi.h
@@ -0,0 +1,130 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_RESPONSE_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_RESPONSE_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Structure used to represent a web response. The functions of this structure
+// may be called on any thread.
+///
+typedef struct _cef_response_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns true (1) if this object is read-only.
+  ///
+  int (CEF_CALLBACK *is_read_only)(struct _cef_response_t* self);
+
+  ///
+  // Get the response status code.
+  ///
+  int (CEF_CALLBACK *get_status)(struct _cef_response_t* self);
+
+  ///
+  // Set the response status code.
+  ///
+  void (CEF_CALLBACK *set_status)(struct _cef_response_t* self, int status);
+
+  ///
+  // Get the response status text.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_status_text)(
+      struct _cef_response_t* self);
+
+  ///
+  // Set the response status text.
+  ///
+  void (CEF_CALLBACK *set_status_text)(struct _cef_response_t* self,
+      const cef_string_t* statusText);
+
+  ///
+  // Get the response mime type.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_mime_type)(
+      struct _cef_response_t* self);
+
+  ///
+  // Set the response mime type.
+  ///
+  void (CEF_CALLBACK *set_mime_type)(struct _cef_response_t* self,
+      const cef_string_t* mimeType);
+
+  ///
+  // Get the value for the specified response header field.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_header)(struct _cef_response_t* self,
+      const cef_string_t* name);
+
+  ///
+  // Get all response header fields.
+  ///
+  void (CEF_CALLBACK *get_header_map)(struct _cef_response_t* self,
+      cef_string_multimap_t headerMap);
+
+  ///
+  // Set all response header fields.
+  ///
+  void (CEF_CALLBACK *set_header_map)(struct _cef_response_t* self,
+      cef_string_multimap_t headerMap);
+} cef_response_t;
+
+
+///
+// Create a new cef_response_t object.
+///
+CEF_EXPORT cef_response_t* cef_response_create();
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_RESPONSE_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_response_filter_capi.h b/src/include/libcef_/capi/cef_response_filter_capi.h
new file mode 100644
index 0000000..4507d1b
--- /dev/null
+++ b/src/include/libcef_/capi/cef_response_filter_capi.h
@@ -0,0 +1,93 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_RESPONSE_FILTER_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_RESPONSE_FILTER_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Implement this structure to filter resource response content. The functions
+// of this structure will be called on the browser process IO thread.
+///
+typedef struct _cef_response_filter_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Initialize the response filter. Will only be called a single time. The
+  // filter will not be installed if this function returns false (0).
+  ///
+  int (CEF_CALLBACK *init_filter)(struct _cef_response_filter_t* self);
+
+  ///
+  // Called to filter a chunk of data. |data_in| is the input buffer containing
+  // |data_in_size| bytes of pre-filter data (|data_in| will be NULL if
+  // |data_in_size| is zero). |data_out| is the output buffer that can accept up
+  // to |data_out_size| bytes of filtered output data. Set |data_in_read| to the
+  // number of bytes that were read from |data_in|. Set |data_out_written| to
+  // the number of bytes that were written into |data_out|. If some or all of
+  // the pre-filter data was read successfully but more data is needed in order
+  // to continue filtering (filtered output is pending) return
+  // RESPONSE_FILTER_NEED_MORE_DATA. If some or all of the pre-filter data was
+  // read successfully and all available filtered output has been written return
+  // RESPONSE_FILTER_DONE. If an error occurs during filtering return
+  // RESPONSE_FILTER_ERROR. This function will be called repeatedly until there
+  // is no more data to filter (resource response is complete), |data_in_read|
+  // matches |data_in_size| (all available pre-filter bytes have been read), and
+  // the function returns RESPONSE_FILTER_DONE or RESPONSE_FILTER_ERROR. Do not
+  // keep a reference to the buffers passed to this function.
+  ///
+  cef_response_filter_status_t (CEF_CALLBACK *filter)(
+      struct _cef_response_filter_t* self, void* data_in, size_t data_in_size,
+      size_t* data_in_read, void* data_out, size_t data_out_size,
+      size_t* data_out_written);
+} cef_response_filter_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_RESPONSE_FILTER_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_scheme_capi.h b/src/include/libcef_/capi/cef_scheme_capi.h
new file mode 100644
index 0000000..6e2c391
--- /dev/null
+++ b/src/include/libcef_/capi/cef_scheme_capi.h
@@ -0,0 +1,173 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_SCHEME_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_SCHEME_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+#include"libcef/capi/cef_browser_capi.h"
+#include"libcef/capi/cef_frame_capi.h"
+#include"libcef/capi/cef_request_capi.h"
+#include"libcef/capi/cef_resource_handler_capi.h"
+#include"libcef/capi/cef_response_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _cef_scheme_handler_factory_t;
+
+///
+// Structure that manages custom scheme registrations.
+///
+typedef struct _cef_scheme_registrar_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Register a custom scheme. This function should not be called for the built-
+  // in HTTP, HTTPS, FILE, FTP, ABOUT and DATA schemes.
+  //
+  // If |is_standard| is true (1) the scheme will be treated as a standard
+  // scheme. Standard schemes are subject to URL canonicalization and parsing
+  // rules as defined in the Common Internet Scheme Syntax RFC 1738 Section 3.1
+  // available at http://www.ietf.org/rfc/rfc1738.txt
+  //
+  // In particular, the syntax for standard scheme URLs must be of the form:
+  // <pre>
+  //  [scheme]://[username]:[password]@[host]:[port]/[url-path]
+  // </pre> Standard scheme URLs must have a host component that is a fully
+  // qualified domain name as defined in Section 3.5 of RFC 1034 [13] and
+  // Section 2.1 of RFC 1123. These URLs will be canonicalized to
+  // "scheme://host/path" in the simplest case and
+  // "scheme://username:password@host:port/path" in the most explicit case. For
+  // example, "scheme:host/path" and "scheme:///host/path" will both be
+  // canonicalized to "scheme://host/path". The origin of a standard scheme URL
+  // is the combination of scheme, host and port (i.e., "scheme://host:port" in
+  // the most explicit case).
+  //
+  // For non-standard scheme URLs only the "scheme:" component is parsed and
+  // canonicalized. The remainder of the URL will be passed to the handler as-
+  // is. For example, "scheme:///some%20text" will remain the same. Non-standard
+  // scheme URLs cannot be used as a target for form submission.
+  //
+  // If |is_local| is true (1) the scheme will be treated as local (i.e., with
+  // the same security rules as those applied to "file" URLs). Normal pages
+  // cannot link to or access local URLs. Also, by default, local URLs can only
+  // perform XMLHttpRequest calls to the same URL (origin + path) that
+  // originated the request. To allow XMLHttpRequest calls from a local URL to
+  // other URLs with the same origin set the
+  // CefSettings.file_access_from_file_urls_allowed value to true (1). To allow
+  // XMLHttpRequest calls from a local URL to all origins set the
+  // CefSettings.universal_access_from_file_urls_allowed value to true (1).
+  //
+  // If |is_display_isolated| is true (1) the scheme will be treated as display-
+  // isolated. This means that pages cannot display these URLs unless they are
+  // from the same scheme. For example, pages in another origin cannot create
+  // iframes or hyperlinks to URLs with this scheme.
+  //
+  // This function may be called on any thread. It should only be called once
+  // per unique |scheme_name| value. If |scheme_name| is already registered or
+  // if an error occurs this function will return false (0).
+  ///
+  int (CEF_CALLBACK *add_custom_scheme)(struct _cef_scheme_registrar_t* self,
+      const cef_string_t* scheme_name, int is_standard, int is_local,
+      int is_display_isolated);
+} cef_scheme_registrar_t;
+
+
+///
+// Structure that creates cef_resource_handler_t instances for handling scheme
+// requests. The functions of this structure will always be called on the IO
+// thread.
+///
+typedef struct _cef_scheme_handler_factory_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Return a new resource handler instance to handle the request or an NULL
+  // reference to allow default handling of the request. |browser| and |frame|
+  // will be the browser window and frame respectively that originated the
+  // request or NULL if the request did not originate from a browser window (for
+  // example, if the request came from cef_urlrequest_t). The |request| object
+  // passed to this function will not contain cookie data.
+  ///
+  struct _cef_resource_handler_t* (CEF_CALLBACK *create)(
+      struct _cef_scheme_handler_factory_t* self,
+      struct _cef_browser_t* browser, struct _cef_frame_t* frame,
+      const cef_string_t* scheme_name, struct _cef_request_t* request);
+} cef_scheme_handler_factory_t;
+
+
+///
+// Register a scheme handler factory with the global request context. An NULL
+// |domain_name| value for a standard scheme will cause the factory to match all
+// domain names. The |domain_name| value will be ignored for non-standard
+// schemes. If |scheme_name| is a built-in scheme and no handler is returned by
+// |factory| then the built-in scheme handler factory will be called. If
+// |scheme_name| is a custom scheme then you must also implement the
+// cef_app_t::on_register_custom_schemes() function in all processes. This
+// function may be called multiple times to change or remove the factory that
+// matches the specified |scheme_name| and optional |domain_name|. Returns false
+// (0) if an error occurs. This function may be called on any thread in the
+// browser process. Using this function is equivalent to calling cef_request_tCo
+// ntext::cef_request_context_get_global_context()->register_scheme_handler_fact
+// ory().
+///
+CEF_EXPORT int cef_register_scheme_handler_factory(
+    const cef_string_t* scheme_name, const cef_string_t* domain_name,
+    cef_scheme_handler_factory_t* factory);
+
+///
+// Clear all scheme handler factories registered with the global request
+// context. Returns false (0) on error. This function may be called on any
+// thread in the browser process. Using this function is equivalent to calling c
+// ef_request_tContext::cef_request_context_get_global_context()->clear_scheme_h
+// andler_factories().
+///
+CEF_EXPORT int cef_clear_scheme_handler_factories();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_SCHEME_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_ssl_info_capi.h b/src/include/libcef_/capi/cef_ssl_info_capi.h
new file mode 100644
index 0000000..0690362
--- /dev/null
+++ b/src/include/libcef_/capi/cef_ssl_info_capi.h
@@ -0,0 +1,220 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_SSL_INFO_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_SSL_INFO_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+#include"libcef/capi/cef_values_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Structure representing the issuer or subject field of an X.509 certificate.
+///
+typedef struct _cef_sslcert_principal_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns a name that can be used to represent the issuer.  It tries in this
+  // order: CN, O and OU and returns the first non-NULL one found.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_display_name)(
+      struct _cef_sslcert_principal_t* self);
+
+  ///
+  // Returns the common name.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_common_name)(
+      struct _cef_sslcert_principal_t* self);
+
+  ///
+  // Returns the locality name.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_locality_name)(
+      struct _cef_sslcert_principal_t* self);
+
+  ///
+  // Returns the state or province name.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_state_or_province_name)(
+      struct _cef_sslcert_principal_t* self);
+
+  ///
+  // Returns the country name.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_country_name)(
+      struct _cef_sslcert_principal_t* self);
+
+  ///
+  // Retrieve the list of street addresses.
+  ///
+  void (CEF_CALLBACK *get_street_addresses)(
+      struct _cef_sslcert_principal_t* self, cef_string_list_t addresses);
+
+  ///
+  // Retrieve the list of organization names.
+  ///
+  void (CEF_CALLBACK *get_organization_names)(
+      struct _cef_sslcert_principal_t* self, cef_string_list_t names);
+
+  ///
+  // Retrieve the list of organization unit names.
+  ///
+  void (CEF_CALLBACK *get_organization_unit_names)(
+      struct _cef_sslcert_principal_t* self, cef_string_list_t names);
+
+  ///
+  // Retrieve the list of domain components.
+  ///
+  void (CEF_CALLBACK *get_domain_components)(
+      struct _cef_sslcert_principal_t* self, cef_string_list_t components);
+} cef_sslcert_principal_t;
+
+
+///
+// Structure representing SSL information.
+///
+typedef struct _cef_sslinfo_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns a bitmask containing any and all problems verifying the server
+  // certificate.
+  ///
+  cef_cert_status_t (CEF_CALLBACK *get_cert_status)(
+      struct _cef_sslinfo_t* self);
+
+  ///
+  // Returns true (1) if the certificate status has any error, major or minor.
+  ///
+  int (CEF_CALLBACK *is_cert_status_error)(struct _cef_sslinfo_t* self);
+
+  ///
+  // Returns true (1) if the certificate status represents only minor errors
+  // (e.g. failure to verify certificate revocation).
+  ///
+  int (CEF_CALLBACK *is_cert_status_minor_error)(struct _cef_sslinfo_t* self);
+
+  ///
+  // Returns the subject of the X.509 certificate. For HTTPS server certificates
+  // this represents the web server.  The common name of the subject should
+  // match the host name of the web server.
+  ///
+  struct _cef_sslcert_principal_t* (CEF_CALLBACK *get_subject)(
+      struct _cef_sslinfo_t* self);
+
+  ///
+  // Returns the issuer of the X.509 certificate.
+  ///
+  struct _cef_sslcert_principal_t* (CEF_CALLBACK *get_issuer)(
+      struct _cef_sslinfo_t* self);
+
+  ///
+  // Returns the DER encoded serial number for the X.509 certificate. The value
+  // possibly includes a leading 00 byte.
+  ///
+  struct _cef_binary_value_t* (CEF_CALLBACK *get_serial_number)(
+      struct _cef_sslinfo_t* self);
+
+  ///
+  // Returns the date before which the X.509 certificate is invalid.
+  // CefTime.GetTimeT() will return 0 if no date was specified.
+  ///
+  cef_time_t (CEF_CALLBACK *get_valid_start)(struct _cef_sslinfo_t* self);
+
+  ///
+  // Returns the date after which the X.509 certificate is invalid.
+  // CefTime.GetTimeT() will return 0 if no date was specified.
+  ///
+  cef_time_t (CEF_CALLBACK *get_valid_expiry)(struct _cef_sslinfo_t* self);
+
+  ///
+  // Returns the DER encoded data for the X.509 certificate.
+  ///
+  struct _cef_binary_value_t* (CEF_CALLBACK *get_derencoded)(
+      struct _cef_sslinfo_t* self);
+
+  ///
+  // Returns the PEM encoded data for the X.509 certificate.
+  ///
+  struct _cef_binary_value_t* (CEF_CALLBACK *get_pemencoded)(
+      struct _cef_sslinfo_t* self);
+
+  ///
+  // Returns the number of certificates in the issuer chain. If 0, the
+  // certificate is self-signed.
+  ///
+  size_t (CEF_CALLBACK *get_issuer_chain_size)(struct _cef_sslinfo_t* self);
+
+  ///
+  // Returns the DER encoded data for the certificate issuer chain. If we failed
+  // to encode a certificate in the chain it is still present in the array but
+  // is an NULL string.
+  ///
+  void (CEF_CALLBACK *get_derencoded_issuer_chain)(struct _cef_sslinfo_t* self,
+      size_t* chainCount, struct _cef_binary_value_t** chain);
+
+  ///
+  // Returns the PEM encoded data for the certificate issuer chain. If we failed
+  // to encode a certificate in the chain it is still present in the array but
+  // is an NULL string.
+  ///
+  void (CEF_CALLBACK *get_pemencoded_issuer_chain)(struct _cef_sslinfo_t* self,
+      size_t* chainCount, struct _cef_binary_value_t** chain);
+} cef_sslinfo_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_SSL_INFO_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_stream_capi.h b/src/include/libcef_/capi/cef_stream_capi.h
new file mode 100644
index 0000000..fa47bb1
--- /dev/null
+++ b/src/include/libcef_/capi/cef_stream_capi.h
@@ -0,0 +1,252 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_STREAM_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_STREAM_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Structure the client can implement to provide a custom stream reader. The
+// functions of this structure may be called on any thread.
+///
+typedef struct _cef_read_handler_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Read raw binary data.
+  ///
+  size_t (CEF_CALLBACK *read)(struct _cef_read_handler_t* self, void* ptr,
+      size_t size, size_t n);
+
+  ///
+  // Seek to the specified offset position. |whence| may be any one of SEEK_CUR,
+  // SEEK_END or SEEK_SET. Return zero on success and non-zero on failure.
+  ///
+  int (CEF_CALLBACK *seek)(struct _cef_read_handler_t* self, int64 offset,
+      int whence);
+
+  ///
+  // Return the current offset position.
+  ///
+  int64 (CEF_CALLBACK *tell)(struct _cef_read_handler_t* self);
+
+  ///
+  // Return non-zero if at end of file.
+  ///
+  int (CEF_CALLBACK *eof)(struct _cef_read_handler_t* self);
+
+  ///
+  // Return true (1) if this handler performs work like accessing the file
+  // system which may block. Used as a hint for determining the thread to access
+  // the handler from.
+  ///
+  int (CEF_CALLBACK *may_block)(struct _cef_read_handler_t* self);
+} cef_read_handler_t;
+
+
+///
+// Structure used to read data from a stream. The functions of this structure
+// may be called on any thread.
+///
+typedef struct _cef_stream_reader_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Read raw binary data.
+  ///
+  size_t (CEF_CALLBACK *read)(struct _cef_stream_reader_t* self, void* ptr,
+      size_t size, size_t n);
+
+  ///
+  // Seek to the specified offset position. |whence| may be any one of SEEK_CUR,
+  // SEEK_END or SEEK_SET. Returns zero on success and non-zero on failure.
+  ///
+  int (CEF_CALLBACK *seek)(struct _cef_stream_reader_t* self, int64 offset,
+      int whence);
+
+  ///
+  // Return the current offset position.
+  ///
+  int64 (CEF_CALLBACK *tell)(struct _cef_stream_reader_t* self);
+
+  ///
+  // Return non-zero if at end of file.
+  ///
+  int (CEF_CALLBACK *eof)(struct _cef_stream_reader_t* self);
+
+  ///
+  // Returns true (1) if this reader performs work like accessing the file
+  // system which may block. Used as a hint for determining the thread to access
+  // the reader from.
+  ///
+  int (CEF_CALLBACK *may_block)(struct _cef_stream_reader_t* self);
+} cef_stream_reader_t;
+
+
+///
+// Create a new cef_stream_reader_t object from a file.
+///
+CEF_EXPORT cef_stream_reader_t* cef_stream_reader_create_for_file(
+    const cef_string_t* fileName);
+
+///
+// Create a new cef_stream_reader_t object from data.
+///
+CEF_EXPORT cef_stream_reader_t* cef_stream_reader_create_for_data(void* data,
+    size_t size);
+
+///
+// Create a new cef_stream_reader_t object from a custom handler.
+///
+CEF_EXPORT cef_stream_reader_t* cef_stream_reader_create_for_handler(
+    cef_read_handler_t* handler);
+
+
+///
+// Structure the client can implement to provide a custom stream writer. The
+// functions of this structure may be called on any thread.
+///
+typedef struct _cef_write_handler_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Write raw binary data.
+  ///
+  size_t (CEF_CALLBACK *write)(struct _cef_write_handler_t* self,
+      const void* ptr, size_t size, size_t n);
+
+  ///
+  // Seek to the specified offset position. |whence| may be any one of SEEK_CUR,
+  // SEEK_END or SEEK_SET. Return zero on success and non-zero on failure.
+  ///
+  int (CEF_CALLBACK *seek)(struct _cef_write_handler_t* self, int64 offset,
+      int whence);
+
+  ///
+  // Return the current offset position.
+  ///
+  int64 (CEF_CALLBACK *tell)(struct _cef_write_handler_t* self);
+
+  ///
+  // Flush the stream.
+  ///
+  int (CEF_CALLBACK *flush)(struct _cef_write_handler_t* self);
+
+  ///
+  // Return true (1) if this handler performs work like accessing the file
+  // system which may block. Used as a hint for determining the thread to access
+  // the handler from.
+  ///
+  int (CEF_CALLBACK *may_block)(struct _cef_write_handler_t* self);
+} cef_write_handler_t;
+
+
+///
+// Structure used to write data to a stream. The functions of this structure may
+// be called on any thread.
+///
+typedef struct _cef_stream_writer_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Write raw binary data.
+  ///
+  size_t (CEF_CALLBACK *write)(struct _cef_stream_writer_t* self,
+      const void* ptr, size_t size, size_t n);
+
+  ///
+  // Seek to the specified offset position. |whence| may be any one of SEEK_CUR,
+  // SEEK_END or SEEK_SET. Returns zero on success and non-zero on failure.
+  ///
+  int (CEF_CALLBACK *seek)(struct _cef_stream_writer_t* self, int64 offset,
+      int whence);
+
+  ///
+  // Return the current offset position.
+  ///
+  int64 (CEF_CALLBACK *tell)(struct _cef_stream_writer_t* self);
+
+  ///
+  // Flush the stream.
+  ///
+  int (CEF_CALLBACK *flush)(struct _cef_stream_writer_t* self);
+
+  ///
+  // Returns true (1) if this writer performs work like accessing the file
+  // system which may block. Used as a hint for determining the thread to access
+  // the writer from.
+  ///
+  int (CEF_CALLBACK *may_block)(struct _cef_stream_writer_t* self);
+} cef_stream_writer_t;
+
+
+///
+// Create a new cef_stream_writer_t object for a file.
+///
+CEF_EXPORT cef_stream_writer_t* cef_stream_writer_create_for_file(
+    const cef_string_t* fileName);
+
+///
+// Create a new cef_stream_writer_t object for a custom handler.
+///
+CEF_EXPORT cef_stream_writer_t* cef_stream_writer_create_for_handler(
+    cef_write_handler_t* handler);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_STREAM_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_string_visitor_capi.h b/src/include/libcef_/capi/cef_string_visitor_capi.h
new file mode 100644
index 0000000..c83c947
--- /dev/null
+++ b/src/include/libcef_/capi/cef_string_visitor_capi.h
@@ -0,0 +1,69 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_STRING_VISITOR_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_STRING_VISITOR_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Implement this structure to receive string values asynchronously.
+///
+typedef struct _cef_string_visitor_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Method that will be executed.
+  ///
+  void (CEF_CALLBACK *visit)(struct _cef_string_visitor_t* self,
+      const cef_string_t* string);
+} cef_string_visitor_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_STRING_VISITOR_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_task_capi.h b/src/include/libcef_/capi/cef_task_capi.h
new file mode 100644
index 0000000..bdafe1d
--- /dev/null
+++ b/src/include/libcef_/capi/cef_task_capi.h
@@ -0,0 +1,159 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_TASK_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_TASK_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Implement this structure for asynchronous task execution. If the task is
+// posted successfully and if the associated message loop is still running then
+// the execute() function will be called on the target thread. If the task fails
+// to post then the task object may be destroyed on the source thread instead of
+// the target thread. For this reason be cautious when performing work in the
+// task object destructor.
+///
+typedef struct _cef_task_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Method that will be executed on the target thread.
+  ///
+  void (CEF_CALLBACK *execute)(struct _cef_task_t* self);
+} cef_task_t;
+
+
+///
+// Structure that asynchronously executes tasks on the associated thread. It is
+// safe to call the functions of this structure on any thread.
+//
+// CEF maintains multiple internal threads that are used for handling different
+// types of tasks in different processes. The cef_thread_id_t definitions in
+// cef_types.h list the common CEF threads. Task runners are also available for
+// other CEF threads as appropriate (for example, V8 WebWorker threads).
+///
+typedef struct _cef_task_runner_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns true (1) if this object is pointing to the same task runner as
+  // |that| object.
+  ///
+  int (CEF_CALLBACK *is_same)(struct _cef_task_runner_t* self,
+      struct _cef_task_runner_t* that);
+
+  ///
+  // Returns true (1) if this task runner belongs to the current thread.
+  ///
+  int (CEF_CALLBACK *belongs_to_current_thread)(
+      struct _cef_task_runner_t* self);
+
+  ///
+  // Returns true (1) if this task runner is for the specified CEF thread.
+  ///
+  int (CEF_CALLBACK *belongs_to_thread)(struct _cef_task_runner_t* self,
+      cef_thread_id_t threadId);
+
+  ///
+  // Post a task for execution on the thread associated with this task runner.
+  // Execution will occur asynchronously.
+  ///
+  int (CEF_CALLBACK *post_task)(struct _cef_task_runner_t* self,
+      struct _cef_task_t* task);
+
+  ///
+  // Post a task for delayed execution on the thread associated with this task
+  // runner. Execution will occur asynchronously. Delayed tasks are not
+  // supported on V8 WebWorker threads and will be executed without the
+  // specified delay.
+  ///
+  int (CEF_CALLBACK *post_delayed_task)(struct _cef_task_runner_t* self,
+      struct _cef_task_t* task, int64 delay_ms);
+} cef_task_runner_t;
+
+
+///
+// Returns the task runner for the current thread. Only CEF threads will have
+// task runners. An NULL reference will be returned if this function is called
+// on an invalid thread.
+///
+CEF_EXPORT cef_task_runner_t* cef_task_runner_get_for_current_thread();
+
+///
+// Returns the task runner for the specified CEF thread.
+///
+CEF_EXPORT cef_task_runner_t* cef_task_runner_get_for_thread(
+    cef_thread_id_t threadId);
+
+
+///
+// Returns true (1) if called on the specified thread. Equivalent to using
+// cef_task_tRunner::GetForThread(threadId)->belongs_to_current_thread().
+///
+CEF_EXPORT int cef_currently_on(cef_thread_id_t threadId);
+
+///
+// Post a task for execution on the specified thread. Equivalent to using
+// cef_task_tRunner::GetForThread(threadId)->PostTask(task).
+///
+CEF_EXPORT int cef_post_task(cef_thread_id_t threadId, cef_task_t* task);
+
+///
+// Post a task for delayed execution on the specified thread. Equivalent to
+// using cef_task_tRunner::GetForThread(threadId)->PostDelayedTask(task,
+// delay_ms).
+///
+CEF_EXPORT int cef_post_delayed_task(cef_thread_id_t threadId, cef_task_t* task,
+    int64 delay_ms);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_TASK_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_trace_capi.h b/src/include/libcef_/capi/cef_trace_capi.h
new file mode 100644
index 0000000..a6f98b0
--- /dev/null
+++ b/src/include/libcef_/capi/cef_trace_capi.h
@@ -0,0 +1,118 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_TRACE_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_TRACE_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+#include"libcef/capi/cef_callback_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Implement this structure to receive notification when tracing has completed.
+// The functions of this structure will be called on the browser process UI
+// thread.
+///
+typedef struct _cef_end_tracing_callback_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Called after all processes have sent their trace data. |tracing_file| is
+  // the path at which tracing data was written. The client is responsible for
+  // deleting |tracing_file|.
+  ///
+  void (CEF_CALLBACK *on_end_tracing_complete)(
+      struct _cef_end_tracing_callback_t* self,
+      const cef_string_t* tracing_file);
+} cef_end_tracing_callback_t;
+
+
+///
+// Start tracing events on all processes. Tracing is initialized asynchronously
+// and |callback| will be executed on the UI thread after initialization is
+// complete.
+//
+// If CefBeginTracing was called previously, or if a CefEndTracingAsync call is
+// pending, CefBeginTracing will fail and return false (0).
+//
+// |categories| is a comma-delimited list of category wildcards. A category can
+// have an optional '-' prefix to make it an excluded category. Having both
+// included and excluded categories in the same list is not supported.
+//
+// Example: "test_MyTest*" Example: "test_MyTest*,test_OtherStuff" Example:
+// "-excluded_category1,-excluded_category2"
+//
+// This function must be called on the browser process UI thread.
+///
+CEF_EXPORT int cef_begin_tracing(const cef_string_t* categories,
+    struct _cef_completion_callback_t* callback);
+
+///
+// Stop tracing events on all processes.
+//
+// This function will fail and return false (0) if a previous call to
+// CefEndTracingAsync is already pending or if CefBeginTracing was not called.
+//
+// |tracing_file| is the path at which tracing data will be written and
+// |callback| is the callback that will be executed once all processes have sent
+// their trace data. If |tracing_file| is NULL a new temporary file path will be
+// used. If |callback| is NULL no trace data will be written.
+//
+// This function must be called on the browser process UI thread.
+///
+CEF_EXPORT int cef_end_tracing(const cef_string_t* tracing_file,
+    cef_end_tracing_callback_t* callback);
+
+///
+// Returns the current system trace time or, if none is defined, the current
+// high-res time. Can be used by clients to synchronize with the time
+// information in trace events.
+///
+CEF_EXPORT int64 cef_now_from_system_trace_time();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_TRACE_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_urlrequest_capi.h b/src/include/libcef_/capi/cef_urlrequest_capi.h
new file mode 100644
index 0000000..da28a67
--- /dev/null
+++ b/src/include/libcef_/capi/cef_urlrequest_capi.h
@@ -0,0 +1,194 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_URLREQUEST_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_URLREQUEST_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_auth_callback_capi.h"
+#include"libcef/capi/cef_base_capi.h"
+#include"libcef/capi/cef_request_capi.h"
+#include"libcef/capi/cef_request_context_capi.h"
+#include"libcef/capi/cef_response_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _cef_urlrequest_client_t;
+
+///
+// Structure used to make a URL request. URL requests are not associated with a
+// browser instance so no cef_client_t callbacks will be executed. URL requests
+// can be created on any valid CEF thread in either the browser or render
+// process. Once created the functions of the URL request object must be
+// accessed on the same thread that created it.
+///
+typedef struct _cef_urlrequest_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns the request object used to create this URL request. The returned
+  // object is read-only and should not be modified.
+  ///
+  struct _cef_request_t* (CEF_CALLBACK *get_request)(
+      struct _cef_urlrequest_t* self);
+
+  ///
+  // Returns the client.
+  ///
+  struct _cef_urlrequest_client_t* (CEF_CALLBACK *get_client)(
+      struct _cef_urlrequest_t* self);
+
+  ///
+  // Returns the request status.
+  ///
+  cef_urlrequest_status_t (CEF_CALLBACK *get_request_status)(
+      struct _cef_urlrequest_t* self);
+
+  ///
+  // Returns the request error if status is UR_CANCELED or UR_FAILED, or 0
+  // otherwise.
+  ///
+  cef_errorcode_t (CEF_CALLBACK *get_request_error)(
+      struct _cef_urlrequest_t* self);
+
+  ///
+  // Returns the response, or NULL if no response information is available.
+  // Response information will only be available after the upload has completed.
+  // The returned object is read-only and should not be modified.
+  ///
+  struct _cef_response_t* (CEF_CALLBACK *get_response)(
+      struct _cef_urlrequest_t* self);
+
+  ///
+  // Cancel the request.
+  ///
+  void (CEF_CALLBACK *cancel)(struct _cef_urlrequest_t* self);
+} cef_urlrequest_t;
+
+
+///
+// Create a new URL request. Only GET, POST, HEAD, DELETE and PUT request
+// functions are supported. Multiple post data elements are not supported and
+// elements of type PDE_TYPE_FILE are only supported for requests originating
+// from the browser process. Requests originating from the render process will
+// receive the same handling as requests originating from Web content -- if the
+// response contains Content-Disposition or Mime-Type header values that would
+// not normally be rendered then the response may receive special handling
+// inside the browser (for example, via the file download code path instead of
+// the URL request code path). The |request| object will be marked as read-only
+// after calling this function. In the browser process if |request_context| is
+// NULL the global request context will be used. In the render process
+// |request_context| must be NULL and the context associated with the current
+// renderer process' browser will be used.
+///
+CEF_EXPORT cef_urlrequest_t* cef_urlrequest_create(
+    struct _cef_request_t* request, struct _cef_urlrequest_client_t* client,
+    struct _cef_request_context_t* request_context);
+
+
+///
+// Structure that should be implemented by the cef_urlrequest_t client. The
+// functions of this structure will be called on the same thread that created
+// the request unless otherwise documented.
+///
+typedef struct _cef_urlrequest_client_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Notifies the client that the request has completed. Use the
+  // cef_urlrequest_t::GetRequestStatus function to determine if the request was
+  // successful or not.
+  ///
+  void (CEF_CALLBACK *on_request_complete)(
+      struct _cef_urlrequest_client_t* self,
+      struct _cef_urlrequest_t* request);
+
+  ///
+  // Notifies the client of upload progress. |current| denotes the number of
+  // bytes sent so far and |total| is the total size of uploading data (or -1 if
+  // chunked upload is enabled). This function will only be called if the
+  // UR_FLAG_REPORT_UPLOAD_PROGRESS flag is set on the request.
+  ///
+  void (CEF_CALLBACK *on_upload_progress)(struct _cef_urlrequest_client_t* self,
+      struct _cef_urlrequest_t* request, int64 current, int64 total);
+
+  ///
+  // Notifies the client of download progress. |current| denotes the number of
+  // bytes received up to the call and |total| is the expected total size of the
+  // response (or -1 if not determined).
+  ///
+  void (CEF_CALLBACK *on_download_progress)(
+      struct _cef_urlrequest_client_t* self, struct _cef_urlrequest_t* request,
+      int64 current, int64 total);
+
+  ///
+  // Called when some part of the response is read. |data| contains the current
+  // bytes received since the last call. This function will not be called if the
+  // UR_FLAG_NO_DOWNLOAD_DATA flag is set on the request.
+  ///
+  void (CEF_CALLBACK *on_download_data)(struct _cef_urlrequest_client_t* self,
+      struct _cef_urlrequest_t* request, const void* data,
+      size_t data_length);
+
+  ///
+  // Called on the IO thread when the browser needs credentials from the user.
+  // |isProxy| indicates whether the host is a proxy server. |host| contains the
+  // hostname and |port| contains the port number. Return true (1) to continue
+  // the request and call cef_auth_callback_t::cont() when the authentication
+  // information is available. Return false (0) to cancel the request. This
+  // function will only be called for requests initiated from the browser
+  // process.
+  ///
+  int (CEF_CALLBACK *get_auth_credentials)(
+      struct _cef_urlrequest_client_t* self, int isProxy,
+      const cef_string_t* host, int port, const cef_string_t* realm,
+      const cef_string_t* scheme, struct _cef_auth_callback_t* callback);
+} cef_urlrequest_client_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_URLREQUEST_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_v8_capi.h b/src/include/libcef_/capi/cef_v8_capi.h
new file mode 100644
index 0000000..169066e
--- /dev/null
+++ b/src/include/libcef_/capi/cef_v8_capi.h
@@ -0,0 +1,852 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_V8_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_V8_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+#include"libcef/capi/cef_browser_capi.h"
+#include"libcef/capi/cef_frame_capi.h"
+#include"libcef/capi/cef_task_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _cef_v8exception_t;
+struct _cef_v8handler_t;
+struct _cef_v8stack_frame_t;
+struct _cef_v8value_t;
+
+///
+// Structure representing a V8 context handle. V8 handles can only be accessed
+// from the thread on which they are created. Valid threads for creating a V8
+// handle include the render process main thread (TID_RENDERER) and WebWorker
+// threads. A task runner for posting tasks on the associated thread can be
+// retrieved via the cef_v8context_t::get_task_runner() function.
+///
+typedef struct _cef_v8context_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns the task runner associated with this context. V8 handles can only
+  // be accessed from the thread on which they are created. This function can be
+  // called on any render process thread.
+  ///
+  struct _cef_task_runner_t* (CEF_CALLBACK *get_task_runner)(
+      struct _cef_v8context_t* self);
+
+  ///
+  // Returns true (1) if the underlying handle is valid and it can be accessed
+  // on the current thread. Do not call any other functions if this function
+  // returns false (0).
+  ///
+  int (CEF_CALLBACK *is_valid)(struct _cef_v8context_t* self);
+
+  ///
+  // Returns the browser for this context. This function will return an NULL
+  // reference for WebWorker contexts.
+  ///
+  struct _cef_browser_t* (CEF_CALLBACK *get_browser)(
+      struct _cef_v8context_t* self);
+
+  ///
+  // Returns the frame for this context. This function will return an NULL
+  // reference for WebWorker contexts.
+  ///
+  struct _cef_frame_t* (CEF_CALLBACK *get_frame)(struct _cef_v8context_t* self);
+
+  ///
+  // Returns the global object for this context. The context must be entered
+  // before calling this function.
+  ///
+  struct _cef_v8value_t* (CEF_CALLBACK *get_global)(
+      struct _cef_v8context_t* self);
+
+  ///
+  // Enter this context. A context must be explicitly entered before creating a
+  // V8 Object, Array, Function or Date asynchronously. exit() must be called
+  // the same number of times as enter() before releasing this context. V8
+  // objects belong to the context in which they are created. Returns true (1)
+  // if the scope was entered successfully.
+  ///
+  int (CEF_CALLBACK *enter)(struct _cef_v8context_t* self);
+
+  ///
+  // Exit this context. Call this function only after calling enter(). Returns
+  // true (1) if the scope was exited successfully.
+  ///
+  int (CEF_CALLBACK *exit)(struct _cef_v8context_t* self);
+
+  ///
+  // Returns true (1) if this object is pointing to the same handle as |that|
+  // object.
+  ///
+  int (CEF_CALLBACK *is_same)(struct _cef_v8context_t* self,
+      struct _cef_v8context_t* that);
+
+  ///
+  // Evaluates the specified JavaScript code using this context's global object.
+  // On success |retval| will be set to the return value, if any, and the
+  // function will return true (1). On failure |exception| will be set to the
+  // exception, if any, and the function will return false (0).
+  ///
+  int (CEF_CALLBACK *eval)(struct _cef_v8context_t* self,
+      const cef_string_t* code, struct _cef_v8value_t** retval,
+      struct _cef_v8exception_t** exception);
+} cef_v8context_t;
+
+
+///
+// Returns the current (top) context object in the V8 context stack.
+///
+CEF_EXPORT cef_v8context_t* cef_v8context_get_current_context();
+
+///
+// Returns the entered (bottom) context object in the V8 context stack.
+///
+CEF_EXPORT cef_v8context_t* cef_v8context_get_entered_context();
+
+///
+// Returns true (1) if V8 is currently inside a context.
+///
+CEF_EXPORT int cef_v8context_in_context();
+
+
+///
+// Structure that should be implemented to handle V8 function calls. The
+// functions of this structure will be called on the thread associated with the
+// V8 function.
+///
+typedef struct _cef_v8handler_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Handle execution of the function identified by |name|. |object| is the
+  // receiver ('this' object) of the function. |arguments| is the list of
+  // arguments passed to the function. If execution succeeds set |retval| to the
+  // function return value. If execution fails set |exception| to the exception
+  // that will be thrown. Return true (1) if execution was handled.
+  ///
+  int (CEF_CALLBACK *execute)(struct _cef_v8handler_t* self,
+      const cef_string_t* name, struct _cef_v8value_t* object,
+      size_t argumentsCount, struct _cef_v8value_t* const* arguments,
+      struct _cef_v8value_t** retval, cef_string_t* exception);
+} cef_v8handler_t;
+
+
+///
+// Structure that should be implemented to handle V8 accessor calls. Accessor
+// identifiers are registered by calling cef_v8value_t::set_value(). The
+// functions of this structure will be called on the thread associated with the
+// V8 accessor.
+///
+typedef struct _cef_v8accessor_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Handle retrieval the accessor value identified by |name|. |object| is the
+  // receiver ('this' object) of the accessor. If retrieval succeeds set
+  // |retval| to the return value. If retrieval fails set |exception| to the
+  // exception that will be thrown. Return true (1) if accessor retrieval was
+  // handled.
+  ///
+  int (CEF_CALLBACK *get)(struct _cef_v8accessor_t* self,
+      const cef_string_t* name, struct _cef_v8value_t* object,
+      struct _cef_v8value_t** retval, cef_string_t* exception);
+
+  ///
+  // Handle assignment of the accessor value identified by |name|. |object| is
+  // the receiver ('this' object) of the accessor. |value| is the new value
+  // being assigned to the accessor. If assignment fails set |exception| to the
+  // exception that will be thrown. Return true (1) if accessor assignment was
+  // handled.
+  ///
+  int (CEF_CALLBACK *set)(struct _cef_v8accessor_t* self,
+      const cef_string_t* name, struct _cef_v8value_t* object,
+      struct _cef_v8value_t* value, cef_string_t* exception);
+} cef_v8accessor_t;
+
+
+///
+// Structure representing a V8 exception. The functions of this structure may be
+// called on any render process thread.
+///
+typedef struct _cef_v8exception_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns the exception message.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_message)(
+      struct _cef_v8exception_t* self);
+
+  ///
+  // Returns the line of source code that the exception occurred within.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_source_line)(
+      struct _cef_v8exception_t* self);
+
+  ///
+  // Returns the resource name for the script from where the function causing
+  // the error originates.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_script_resource_name)(
+      struct _cef_v8exception_t* self);
+
+  ///
+  // Returns the 1-based number of the line where the error occurred or 0 if the
+  // line number is unknown.
+  ///
+  int (CEF_CALLBACK *get_line_number)(struct _cef_v8exception_t* self);
+
+  ///
+  // Returns the index within the script of the first character where the error
+  // occurred.
+  ///
+  int (CEF_CALLBACK *get_start_position)(struct _cef_v8exception_t* self);
+
+  ///
+  // Returns the index within the script of the last character where the error
+  // occurred.
+  ///
+  int (CEF_CALLBACK *get_end_position)(struct _cef_v8exception_t* self);
+
+  ///
+  // Returns the index within the line of the first character where the error
+  // occurred.
+  ///
+  int (CEF_CALLBACK *get_start_column)(struct _cef_v8exception_t* self);
+
+  ///
+  // Returns the index within the line of the last character where the error
+  // occurred.
+  ///
+  int (CEF_CALLBACK *get_end_column)(struct _cef_v8exception_t* self);
+} cef_v8exception_t;
+
+
+///
+// Structure representing a V8 value handle. V8 handles can only be accessed
+// from the thread on which they are created. Valid threads for creating a V8
+// handle include the render process main thread (TID_RENDERER) and WebWorker
+// threads. A task runner for posting tasks on the associated thread can be
+// retrieved via the cef_v8context_t::get_task_runner() function.
+///
+typedef struct _cef_v8value_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns true (1) if the underlying handle is valid and it can be accessed
+  // on the current thread. Do not call any other functions if this function
+  // returns false (0).
+  ///
+  int (CEF_CALLBACK *is_valid)(struct _cef_v8value_t* self);
+
+  ///
+  // True if the value type is undefined.
+  ///
+  int (CEF_CALLBACK *is_undefined)(struct _cef_v8value_t* self);
+
+  ///
+  // True if the value type is null.
+  ///
+  int (CEF_CALLBACK *is_null)(struct _cef_v8value_t* self);
+
+  ///
+  // True if the value type is bool.
+  ///
+  int (CEF_CALLBACK *is_bool)(struct _cef_v8value_t* self);
+
+  ///
+  // True if the value type is int.
+  ///
+  int (CEF_CALLBACK *is_int)(struct _cef_v8value_t* self);
+
+  ///
+  // True if the value type is unsigned int.
+  ///
+  int (CEF_CALLBACK *is_uint)(struct _cef_v8value_t* self);
+
+  ///
+  // True if the value type is double.
+  ///
+  int (CEF_CALLBACK *is_double)(struct _cef_v8value_t* self);
+
+  ///
+  // True if the value type is Date.
+  ///
+  int (CEF_CALLBACK *is_date)(struct _cef_v8value_t* self);
+
+  ///
+  // True if the value type is string.
+  ///
+  int (CEF_CALLBACK *is_string)(struct _cef_v8value_t* self);
+
+  ///
+  // True if the value type is object.
+  ///
+  int (CEF_CALLBACK *is_object)(struct _cef_v8value_t* self);
+
+  ///
+  // True if the value type is array.
+  ///
+  int (CEF_CALLBACK *is_array)(struct _cef_v8value_t* self);
+
+  ///
+  // True if the value type is function.
+  ///
+  int (CEF_CALLBACK *is_function)(struct _cef_v8value_t* self);
+
+  ///
+  // Returns true (1) if this object is pointing to the same handle as |that|
+  // object.
+  ///
+  int (CEF_CALLBACK *is_same)(struct _cef_v8value_t* self,
+      struct _cef_v8value_t* that);
+
+  ///
+  // Return a bool value.  The underlying data will be converted to if
+  // necessary.
+  ///
+  int (CEF_CALLBACK *get_bool_value)(struct _cef_v8value_t* self);
+
+  ///
+  // Return an int value.  The underlying data will be converted to if
+  // necessary.
+  ///
+  int32 (CEF_CALLBACK *get_int_value)(struct _cef_v8value_t* self);
+
+  ///
+  // Return an unisgned int value.  The underlying data will be converted to if
+  // necessary.
+  ///
+  uint32 (CEF_CALLBACK *get_uint_value)(struct _cef_v8value_t* self);
+
+  ///
+  // Return a double value.  The underlying data will be converted to if
+  // necessary.
+  ///
+  double (CEF_CALLBACK *get_double_value)(struct _cef_v8value_t* self);
+
+  ///
+  // Return a Date value.  The underlying data will be converted to if
+  // necessary.
+  ///
+  cef_time_t (CEF_CALLBACK *get_date_value)(struct _cef_v8value_t* self);
+
+  ///
+  // Return a string value.  The underlying data will be converted to if
+  // necessary.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_string_value)(
+      struct _cef_v8value_t* self);
+
+
+  // OBJECT METHODS - These functions are only available on objects. Arrays and
+  // functions are also objects. String- and integer-based keys can be used
+  // interchangably with the framework converting between them as necessary.
+
+  ///
+  // Returns true (1) if this is a user created object.
+  ///
+  int (CEF_CALLBACK *is_user_created)(struct _cef_v8value_t* self);
+
+  ///
+  // Returns true (1) if the last function call resulted in an exception. This
+  // attribute exists only in the scope of the current CEF value object.
+  ///
+  int (CEF_CALLBACK *has_exception)(struct _cef_v8value_t* self);
+
+  ///
+  // Returns the exception resulting from the last function call. This attribute
+  // exists only in the scope of the current CEF value object.
+  ///
+  struct _cef_v8exception_t* (CEF_CALLBACK *get_exception)(
+      struct _cef_v8value_t* self);
+
+  ///
+  // Clears the last exception and returns true (1) on success.
+  ///
+  int (CEF_CALLBACK *clear_exception)(struct _cef_v8value_t* self);
+
+  ///
+  // Returns true (1) if this object will re-throw future exceptions. This
+  // attribute exists only in the scope of the current CEF value object.
+  ///
+  int (CEF_CALLBACK *will_rethrow_exceptions)(struct _cef_v8value_t* self);
+
+  ///
+  // Set whether this object will re-throw future exceptions. By default
+  // exceptions are not re-thrown. If a exception is re-thrown the current
+  // context should not be accessed again until after the exception has been
+  // caught and not re-thrown. Returns true (1) on success. This attribute
+  // exists only in the scope of the current CEF value object.
+  ///
+  int (CEF_CALLBACK *set_rethrow_exceptions)(struct _cef_v8value_t* self,
+      int rethrow);
+
+  ///
+  // Returns true (1) if the object has a value with the specified identifier.
+  ///
+  int (CEF_CALLBACK *has_value_bykey)(struct _cef_v8value_t* self,
+      const cef_string_t* key);
+
+  ///
+  // Returns true (1) if the object has a value with the specified identifier.
+  ///
+  int (CEF_CALLBACK *has_value_byindex)(struct _cef_v8value_t* self, int index);
+
+  ///
+  // Deletes the value with the specified identifier and returns true (1) on
+  // success. Returns false (0) if this function is called incorrectly or an
+  // exception is thrown. For read-only and don't-delete values this function
+  // will return true (1) even though deletion failed.
+  ///
+  int (CEF_CALLBACK *delete_value_bykey)(struct _cef_v8value_t* self,
+      const cef_string_t* key);
+
+  ///
+  // Deletes the value with the specified identifier and returns true (1) on
+  // success. Returns false (0) if this function is called incorrectly, deletion
+  // fails or an exception is thrown. For read-only and don't-delete values this
+  // function will return true (1) even though deletion failed.
+  ///
+  int (CEF_CALLBACK *delete_value_byindex)(struct _cef_v8value_t* self,
+      int index);
+
+  ///
+  // Returns the value with the specified identifier on success. Returns NULL if
+  // this function is called incorrectly or an exception is thrown.
+  ///
+  struct _cef_v8value_t* (CEF_CALLBACK *get_value_bykey)(
+      struct _cef_v8value_t* self, const cef_string_t* key);
+
+  ///
+  // Returns the value with the specified identifier on success. Returns NULL if
+  // this function is called incorrectly or an exception is thrown.
+  ///
+  struct _cef_v8value_t* (CEF_CALLBACK *get_value_byindex)(
+      struct _cef_v8value_t* self, int index);
+
+  ///
+  // Associates a value with the specified identifier and returns true (1) on
+  // success. Returns false (0) if this function is called incorrectly or an
+  // exception is thrown. For read-only values this function will return true
+  // (1) even though assignment failed.
+  ///
+  int (CEF_CALLBACK *set_value_bykey)(struct _cef_v8value_t* self,
+      const cef_string_t* key, struct _cef_v8value_t* value,
+      cef_v8_propertyattribute_t attribute);
+
+  ///
+  // Associates a value with the specified identifier and returns true (1) on
+  // success. Returns false (0) if this function is called incorrectly or an
+  // exception is thrown. For read-only values this function will return true
+  // (1) even though assignment failed.
+  ///
+  int (CEF_CALLBACK *set_value_byindex)(struct _cef_v8value_t* self, int index,
+      struct _cef_v8value_t* value);
+
+  ///
+  // Registers an identifier and returns true (1) on success. Access to the
+  // identifier will be forwarded to the cef_v8accessor_t instance passed to
+  // cef_v8value_t::cef_v8value_create_object(). Returns false (0) if this
+  // function is called incorrectly or an exception is thrown. For read-only
+  // values this function will return true (1) even though assignment failed.
+  ///
+  int (CEF_CALLBACK *set_value_byaccessor)(struct _cef_v8value_t* self,
+      const cef_string_t* key, cef_v8_accesscontrol_t settings,
+      cef_v8_propertyattribute_t attribute);
+
+  ///
+  // Read the keys for the object's values into the specified vector. Integer-
+  // based keys will also be returned as strings.
+  ///
+  int (CEF_CALLBACK *get_keys)(struct _cef_v8value_t* self,
+      cef_string_list_t keys);
+
+  ///
+  // Sets the user data for this object and returns true (1) on success. Returns
+  // false (0) if this function is called incorrectly. This function can only be
+  // called on user created objects.
+  ///
+  int (CEF_CALLBACK *set_user_data)(struct _cef_v8value_t* self,
+      struct _cef_base_t* user_data);
+
+  ///
+  // Returns the user data, if any, assigned to this object.
+  ///
+  struct _cef_base_t* (CEF_CALLBACK *get_user_data)(
+      struct _cef_v8value_t* self);
+
+  ///
+  // Returns the amount of externally allocated memory registered for the
+  // object.
+  ///
+  int (CEF_CALLBACK *get_externally_allocated_memory)(
+      struct _cef_v8value_t* self);
+
+  ///
+  // Adjusts the amount of registered external memory for the object. Used to
+  // give V8 an indication of the amount of externally allocated memory that is
+  // kept alive by JavaScript objects. V8 uses this information to decide when
+  // to perform global garbage collection. Each cef_v8value_t tracks the amount
+  // of external memory associated with it and automatically decreases the
+  // global total by the appropriate amount on its destruction.
+  // |change_in_bytes| specifies the number of bytes to adjust by. This function
+  // returns the number of bytes associated with the object after the
+  // adjustment. This function can only be called on user created objects.
+  ///
+  int (CEF_CALLBACK *adjust_externally_allocated_memory)(
+      struct _cef_v8value_t* self, int change_in_bytes);
+
+
+  // ARRAY METHODS - These functions are only available on arrays.
+
+  ///
+  // Returns the number of elements in the array.
+  ///
+  int (CEF_CALLBACK *get_array_length)(struct _cef_v8value_t* self);
+
+
+  // FUNCTION METHODS - These functions are only available on functions.
+
+  ///
+  // Returns the function name.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_function_name)(
+      struct _cef_v8value_t* self);
+
+  ///
+  // Returns the function handler or NULL if not a CEF-created function.
+  ///
+  struct _cef_v8handler_t* (CEF_CALLBACK *get_function_handler)(
+      struct _cef_v8value_t* self);
+
+  ///
+  // Execute the function using the current V8 context. This function should
+  // only be called from within the scope of a cef_v8handler_t or
+  // cef_v8accessor_t callback, or in combination with calling enter() and
+  // exit() on a stored cef_v8context_t reference. |object| is the receiver
+  // ('this' object) of the function. If |object| is NULL the current context's
+  // global object will be used. |arguments| is the list of arguments that will
+  // be passed to the function. Returns the function return value on success.
+  // Returns NULL if this function is called incorrectly or an exception is
+  // thrown.
+  ///
+  struct _cef_v8value_t* (CEF_CALLBACK *execute_function)(
+      struct _cef_v8value_t* self, struct _cef_v8value_t* object,
+      size_t argumentsCount, struct _cef_v8value_t* const* arguments);
+
+  ///
+  // Execute the function using the specified V8 context. |object| is the
+  // receiver ('this' object) of the function. If |object| is NULL the specified
+  // context's global object will be used. |arguments| is the list of arguments
+  // that will be passed to the function. Returns the function return value on
+  // success. Returns NULL if this function is called incorrectly or an
+  // exception is thrown.
+  ///
+  struct _cef_v8value_t* (CEF_CALLBACK *execute_function_with_context)(
+      struct _cef_v8value_t* self, struct _cef_v8context_t* context,
+      struct _cef_v8value_t* object, size_t argumentsCount,
+      struct _cef_v8value_t* const* arguments);
+} cef_v8value_t;
+
+
+///
+// Create a new cef_v8value_t object of type undefined.
+///
+CEF_EXPORT cef_v8value_t* cef_v8value_create_undefined();
+
+///
+// Create a new cef_v8value_t object of type null.
+///
+CEF_EXPORT cef_v8value_t* cef_v8value_create_null();
+
+///
+// Create a new cef_v8value_t object of type bool.
+///
+CEF_EXPORT cef_v8value_t* cef_v8value_create_bool(int value);
+
+///
+// Create a new cef_v8value_t object of type int.
+///
+CEF_EXPORT cef_v8value_t* cef_v8value_create_int(int32 value);
+
+///
+// Create a new cef_v8value_t object of type unsigned int.
+///
+CEF_EXPORT cef_v8value_t* cef_v8value_create_uint(uint32 value);
+
+///
+// Create a new cef_v8value_t object of type double.
+///
+CEF_EXPORT cef_v8value_t* cef_v8value_create_double(double value);
+
+///
+// Create a new cef_v8value_t object of type Date. This function should only be
+// called from within the scope of a cef_render_process_handler_t,
+// cef_v8handler_t or cef_v8accessor_t callback, or in combination with calling
+// enter() and exit() on a stored cef_v8context_t reference.
+///
+CEF_EXPORT cef_v8value_t* cef_v8value_create_date(const cef_time_t* date);
+
+///
+// Create a new cef_v8value_t object of type string.
+///
+CEF_EXPORT cef_v8value_t* cef_v8value_create_string(const cef_string_t* value);
+
+///
+// Create a new cef_v8value_t object of type object with optional accessor. This
+// function should only be called from within the scope of a
+// cef_render_process_handler_t, cef_v8handler_t or cef_v8accessor_t callback,
+// or in combination with calling enter() and exit() on a stored cef_v8context_t
+// reference.
+///
+CEF_EXPORT cef_v8value_t* cef_v8value_create_object(cef_v8accessor_t* accessor);
+
+///
+// Create a new cef_v8value_t object of type array with the specified |length|.
+// If |length| is negative the returned array will have length 0. This function
+// should only be called from within the scope of a
+// cef_render_process_handler_t, cef_v8handler_t or cef_v8accessor_t callback,
+// or in combination with calling enter() and exit() on a stored cef_v8context_t
+// reference.
+///
+CEF_EXPORT cef_v8value_t* cef_v8value_create_array(int length);
+
+///
+// Create a new cef_v8value_t object of type function. This function should only
+// be called from within the scope of a cef_render_process_handler_t,
+// cef_v8handler_t or cef_v8accessor_t callback, or in combination with calling
+// enter() and exit() on a stored cef_v8context_t reference.
+///
+CEF_EXPORT cef_v8value_t* cef_v8value_create_function(const cef_string_t* name,
+    cef_v8handler_t* handler);
+
+
+///
+// Structure representing a V8 stack trace handle. V8 handles can only be
+// accessed from the thread on which they are created. Valid threads for
+// creating a V8 handle include the render process main thread (TID_RENDERER)
+// and WebWorker threads. A task runner for posting tasks on the associated
+// thread can be retrieved via the cef_v8context_t::get_task_runner() function.
+///
+typedef struct _cef_v8stack_trace_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns true (1) if the underlying handle is valid and it can be accessed
+  // on the current thread. Do not call any other functions if this function
+  // returns false (0).
+  ///
+  int (CEF_CALLBACK *is_valid)(struct _cef_v8stack_trace_t* self);
+
+  ///
+  // Returns the number of stack frames.
+  ///
+  int (CEF_CALLBACK *get_frame_count)(struct _cef_v8stack_trace_t* self);
+
+  ///
+  // Returns the stack frame at the specified 0-based index.
+  ///
+  struct _cef_v8stack_frame_t* (CEF_CALLBACK *get_frame)(
+      struct _cef_v8stack_trace_t* self, int index);
+} cef_v8stack_trace_t;
+
+
+///
+// Returns the stack trace for the currently active context. |frame_limit| is
+// the maximum number of frames that will be captured.
+///
+CEF_EXPORT cef_v8stack_trace_t* cef_v8stack_trace_get_current(int frame_limit);
+
+
+///
+// Structure representing a V8 stack frame handle. V8 handles can only be
+// accessed from the thread on which they are created. Valid threads for
+// creating a V8 handle include the render process main thread (TID_RENDERER)
+// and WebWorker threads. A task runner for posting tasks on the associated
+// thread can be retrieved via the cef_v8context_t::get_task_runner() function.
+///
+typedef struct _cef_v8stack_frame_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns true (1) if the underlying handle is valid and it can be accessed
+  // on the current thread. Do not call any other functions if this function
+  // returns false (0).
+  ///
+  int (CEF_CALLBACK *is_valid)(struct _cef_v8stack_frame_t* self);
+
+  ///
+  // Returns the name of the resource script that contains the function.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_script_name)(
+      struct _cef_v8stack_frame_t* self);
+
+  ///
+  // Returns the name of the resource script that contains the function or the
+  // sourceURL value if the script name is undefined and its source ends with a
+  // "//@ sourceURL=..." string.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_script_name_or_source_url)(
+      struct _cef_v8stack_frame_t* self);
+
+  ///
+  // Returns the name of the function.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_function_name)(
+      struct _cef_v8stack_frame_t* self);
+
+  ///
+  // Returns the 1-based line number for the function call or 0 if unknown.
+  ///
+  int (CEF_CALLBACK *get_line_number)(struct _cef_v8stack_frame_t* self);
+
+  ///
+  // Returns the 1-based column offset on the line for the function call or 0 if
+  // unknown.
+  ///
+  int (CEF_CALLBACK *get_column)(struct _cef_v8stack_frame_t* self);
+
+  ///
+  // Returns true (1) if the function was compiled using eval().
+  ///
+  int (CEF_CALLBACK *is_eval)(struct _cef_v8stack_frame_t* self);
+
+  ///
+  // Returns true (1) if the function was called as a constructor via "new".
+  ///
+  int (CEF_CALLBACK *is_constructor)(struct _cef_v8stack_frame_t* self);
+} cef_v8stack_frame_t;
+
+
+///
+// Register a new V8 extension with the specified JavaScript extension code and
+// handler. Functions implemented by the handler are prototyped using the
+// keyword 'native'. The calling of a native function is restricted to the scope
+// in which the prototype of the native function is defined. This function may
+// only be called on the render process main thread.
+//
+// Example JavaScript extension code: <pre>
+//   // create the 'example' global object if it doesn't already exist.
+//   if (!example)
+//     example = {};
+//   // create the 'example.test' global object if it doesn't already exist.
+//   if (!example.test)
+//     example.test = {};
+//   (function() {
+//     // Define the function 'example.test.myfunction'.
+//     example.test.myfunction = function() {
+//       // Call CefV8Handler::Execute() with the function name 'MyFunction'
+//       // and no arguments.
+//       native function MyFunction();
+//       return MyFunction();
+//     };
+//     // Define the getter function for parameter 'example.test.myparam'.
+//     example.test.__defineGetter__('myparam', function() {
+//       // Call CefV8Handler::Execute() with the function name 'GetMyParam'
+//       // and no arguments.
+//       native function GetMyParam();
+//       return GetMyParam();
+//     });
+//     // Define the setter function for parameter 'example.test.myparam'.
+//     example.test.__defineSetter__('myparam', function(b) {
+//       // Call CefV8Handler::Execute() with the function name 'SetMyParam'
+//       // and a single argument.
+//       native function SetMyParam();
+//       if(b) SetMyParam(b);
+//     });
+//
+//     // Extension definitions can also contain normal JavaScript variables
+//     // and functions.
+//     var myint = 0;
+//     example.test.increment = function() {
+//       myint += 1;
+//       return myint;
+//     };
+//   })();
+// </pre> Example usage in the page: <pre>
+//   // Call the function.
+//   example.test.myfunction();
+//   // Set the parameter.
+//   example.test.myparam = value;
+//   // Get the parameter.
+//   value = example.test.myparam;
+//   // Call another function.
+//   example.test.increment();
+// </pre>
+///
+CEF_EXPORT int cef_register_extension(const cef_string_t* extension_name,
+    const cef_string_t* javascript_code, cef_v8handler_t* handler);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_V8_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_values_capi.h b/src/include/libcef_/capi/cef_values_capi.h
new file mode 100644
index 0000000..448e885
--- /dev/null
+++ b/src/include/libcef_/capi/cef_values_capi.h
@@ -0,0 +1,734 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_VALUES_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_VALUES_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _cef_binary_value_t;
+struct _cef_dictionary_value_t;
+struct _cef_list_value_t;
+
+///
+// Structure that wraps other data value types. Complex types (binary,
+// dictionary and list) will be referenced but not owned by this object. Can be
+// used on any process and thread.
+///
+typedef struct _cef_value_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns true (1) if the underlying data is valid. This will always be true
+  // (1) for simple types. For complex types (binary, dictionary and list) the
+  // underlying data may become invalid if owned by another object (e.g. list or
+  // dictionary) and that other object is then modified or destroyed. This value
+  // object can be re-used by calling Set*() even if the underlying data is
+  // invalid.
+  ///
+  int (CEF_CALLBACK *is_valid)(struct _cef_value_t* self);
+
+  ///
+  // Returns true (1) if the underlying data is owned by another object.
+  ///
+  int (CEF_CALLBACK *is_owned)(struct _cef_value_t* self);
+
+  ///
+  // Returns true (1) if the underlying data is read-only. Some APIs may expose
+  // read-only objects.
+  ///
+  int (CEF_CALLBACK *is_read_only)(struct _cef_value_t* self);
+
+  ///
+  // Returns true (1) if this object and |that| object have the same underlying
+  // data. If true (1) modifications to this object will also affect |that|
+  // object and vice-versa.
+  ///
+  int (CEF_CALLBACK *is_same)(struct _cef_value_t* self,
+      struct _cef_value_t* that);
+
+  ///
+  // Returns true (1) if this object and |that| object have an equivalent
+  // underlying value but are not necessarily the same object.
+  ///
+  int (CEF_CALLBACK *is_equal)(struct _cef_value_t* self,
+      struct _cef_value_t* that);
+
+  ///
+  // Returns a copy of this object. The underlying data will also be copied.
+  ///
+  struct _cef_value_t* (CEF_CALLBACK *copy)(struct _cef_value_t* self);
+
+  ///
+  // Returns the underlying value type.
+  ///
+  cef_value_type_t (CEF_CALLBACK *get_type)(struct _cef_value_t* self);
+
+  ///
+  // Returns the underlying value as type bool.
+  ///
+  int (CEF_CALLBACK *get_bool)(struct _cef_value_t* self);
+
+  ///
+  // Returns the underlying value as type int.
+  ///
+  int (CEF_CALLBACK *get_int)(struct _cef_value_t* self);
+
+  ///
+  // Returns the underlying value as type double.
+  ///
+  double (CEF_CALLBACK *get_double)(struct _cef_value_t* self);
+
+  ///
+  // Returns the underlying value as type string.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_string)(struct _cef_value_t* self);
+
+  ///
+  // Returns the underlying value as type binary. The returned reference may
+  // become invalid if the value is owned by another object or if ownership is
+  // transferred to another object in the future. To maintain a reference to the
+  // value after assigning ownership to a dictionary or list pass this object to
+  // the set_value() function instead of passing the returned reference to
+  // set_binary().
+  ///
+  struct _cef_binary_value_t* (CEF_CALLBACK *get_binary)(
+      struct _cef_value_t* self);
+
+  ///
+  // Returns the underlying value as type dictionary. The returned reference may
+  // become invalid if the value is owned by another object or if ownership is
+  // transferred to another object in the future. To maintain a reference to the
+  // value after assigning ownership to a dictionary or list pass this object to
+  // the set_value() function instead of passing the returned reference to
+  // set_dictionary().
+  ///
+  struct _cef_dictionary_value_t* (CEF_CALLBACK *get_dictionary)(
+      struct _cef_value_t* self);
+
+  ///
+  // Returns the underlying value as type list. The returned reference may
+  // become invalid if the value is owned by another object or if ownership is
+  // transferred to another object in the future. To maintain a reference to the
+  // value after assigning ownership to a dictionary or list pass this object to
+  // the set_value() function instead of passing the returned reference to
+  // set_list().
+  ///
+  struct _cef_list_value_t* (CEF_CALLBACK *get_list)(struct _cef_value_t* self);
+
+  ///
+  // Sets the underlying value as type null. Returns true (1) if the value was
+  // set successfully.
+  ///
+  int (CEF_CALLBACK *set_null)(struct _cef_value_t* self);
+
+  ///
+  // Sets the underlying value as type bool. Returns true (1) if the value was
+  // set successfully.
+  ///
+  int (CEF_CALLBACK *set_bool)(struct _cef_value_t* self, int value);
+
+  ///
+  // Sets the underlying value as type int. Returns true (1) if the value was
+  // set successfully.
+  ///
+  int (CEF_CALLBACK *set_int)(struct _cef_value_t* self, int value);
+
+  ///
+  // Sets the underlying value as type double. Returns true (1) if the value was
+  // set successfully.
+  ///
+  int (CEF_CALLBACK *set_double)(struct _cef_value_t* self, double value);
+
+  ///
+  // Sets the underlying value as type string. Returns true (1) if the value was
+  // set successfully.
+  ///
+  int (CEF_CALLBACK *set_string)(struct _cef_value_t* self,
+      const cef_string_t* value);
+
+  ///
+  // Sets the underlying value as type binary. Returns true (1) if the value was
+  // set successfully. This object keeps a reference to |value| and ownership of
+  // the underlying data remains unchanged.
+  ///
+  int (CEF_CALLBACK *set_binary)(struct _cef_value_t* self,
+      struct _cef_binary_value_t* value);
+
+  ///
+  // Sets the underlying value as type dict. Returns true (1) if the value was
+  // set successfully. This object keeps a reference to |value| and ownership of
+  // the underlying data remains unchanged.
+  ///
+  int (CEF_CALLBACK *set_dictionary)(struct _cef_value_t* self,
+      struct _cef_dictionary_value_t* value);
+
+  ///
+  // Sets the underlying value as type list. Returns true (1) if the value was
+  // set successfully. This object keeps a reference to |value| and ownership of
+  // the underlying data remains unchanged.
+  ///
+  int (CEF_CALLBACK *set_list)(struct _cef_value_t* self,
+      struct _cef_list_value_t* value);
+} cef_value_t;
+
+
+///
+// Creates a new object.
+///
+CEF_EXPORT cef_value_t* cef_value_create();
+
+
+///
+// Structure representing a binary value. Can be used on any process and thread.
+///
+typedef struct _cef_binary_value_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns true (1) if this object is valid. This object may become invalid if
+  // the underlying data is owned by another object (e.g. list or dictionary)
+  // and that other object is then modified or destroyed. Do not call any other
+  // functions if this function returns false (0).
+  ///
+  int (CEF_CALLBACK *is_valid)(struct _cef_binary_value_t* self);
+
+  ///
+  // Returns true (1) if this object is currently owned by another object.
+  ///
+  int (CEF_CALLBACK *is_owned)(struct _cef_binary_value_t* self);
+
+  ///
+  // Returns true (1) if this object and |that| object have the same underlying
+  // data.
+  ///
+  int (CEF_CALLBACK *is_same)(struct _cef_binary_value_t* self,
+      struct _cef_binary_value_t* that);
+
+  ///
+  // Returns true (1) if this object and |that| object have an equivalent
+  // underlying value but are not necessarily the same object.
+  ///
+  int (CEF_CALLBACK *is_equal)(struct _cef_binary_value_t* self,
+      struct _cef_binary_value_t* that);
+
+  ///
+  // Returns a copy of this object. The data in this object will also be copied.
+  ///
+  struct _cef_binary_value_t* (CEF_CALLBACK *copy)(
+      struct _cef_binary_value_t* self);
+
+  ///
+  // Returns the data size.
+  ///
+  size_t (CEF_CALLBACK *get_size)(struct _cef_binary_value_t* self);
+
+  ///
+  // Read up to |buffer_size| number of bytes into |buffer|. Reading begins at
+  // the specified byte |data_offset|. Returns the number of bytes read.
+  ///
+  size_t (CEF_CALLBACK *get_data)(struct _cef_binary_value_t* self,
+      void* buffer, size_t buffer_size, size_t data_offset);
+} cef_binary_value_t;
+
+
+///
+// Creates a new object that is not owned by any other object. The specified
+// |data| will be copied.
+///
+CEF_EXPORT cef_binary_value_t* cef_binary_value_create(const void* data,
+    size_t data_size);
+
+
+///
+// Structure representing a dictionary value. Can be used on any process and
+// thread.
+///
+typedef struct _cef_dictionary_value_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns true (1) if this object is valid. This object may become invalid if
+  // the underlying data is owned by another object (e.g. list or dictionary)
+  // and that other object is then modified or destroyed. Do not call any other
+  // functions if this function returns false (0).
+  ///
+  int (CEF_CALLBACK *is_valid)(struct _cef_dictionary_value_t* self);
+
+  ///
+  // Returns true (1) if this object is currently owned by another object.
+  ///
+  int (CEF_CALLBACK *is_owned)(struct _cef_dictionary_value_t* self);
+
+  ///
+  // Returns true (1) if the values of this object are read-only. Some APIs may
+  // expose read-only objects.
+  ///
+  int (CEF_CALLBACK *is_read_only)(struct _cef_dictionary_value_t* self);
+
+  ///
+  // Returns true (1) if this object and |that| object have the same underlying
+  // data. If true (1) modifications to this object will also affect |that|
+  // object and vice-versa.
+  ///
+  int (CEF_CALLBACK *is_same)(struct _cef_dictionary_value_t* self,
+      struct _cef_dictionary_value_t* that);
+
+  ///
+  // Returns true (1) if this object and |that| object have an equivalent
+  // underlying value but are not necessarily the same object.
+  ///
+  int (CEF_CALLBACK *is_equal)(struct _cef_dictionary_value_t* self,
+      struct _cef_dictionary_value_t* that);
+
+  ///
+  // Returns a writable copy of this object. If |exclude_NULL_children| is true
+  // (1) any NULL dictionaries or lists will be excluded from the copy.
+  ///
+  struct _cef_dictionary_value_t* (CEF_CALLBACK *copy)(
+      struct _cef_dictionary_value_t* self, int exclude_empty_children);
+
+  ///
+  // Returns the number of values.
+  ///
+  size_t (CEF_CALLBACK *get_size)(struct _cef_dictionary_value_t* self);
+
+  ///
+  // Removes all values. Returns true (1) on success.
+  ///
+  int (CEF_CALLBACK *clear)(struct _cef_dictionary_value_t* self);
+
+  ///
+  // Returns true (1) if the current dictionary has a value for the given key.
+  ///
+  int (CEF_CALLBACK *has_key)(struct _cef_dictionary_value_t* self,
+      const cef_string_t* key);
+
+  ///
+  // Reads all keys for this dictionary into the specified vector.
+  ///
+  int (CEF_CALLBACK *get_keys)(struct _cef_dictionary_value_t* self,
+      cef_string_list_t keys);
+
+  ///
+  // Removes the value at the specified key. Returns true (1) is the value was
+  // removed successfully.
+  ///
+  int (CEF_CALLBACK *remove)(struct _cef_dictionary_value_t* self,
+      const cef_string_t* key);
+
+  ///
+  // Returns the value type for the specified key.
+  ///
+  cef_value_type_t (CEF_CALLBACK *get_type)(
+      struct _cef_dictionary_value_t* self, const cef_string_t* key);
+
+  ///
+  // Returns the value at the specified key. For simple types the returned value
+  // will copy existing data and modifications to the value will not modify this
+  // object. For complex types (binary, dictionary and list) the returned value
+  // will reference existing data and modifications to the value will modify
+  // this object.
+  ///
+  struct _cef_value_t* (CEF_CALLBACK *get_value)(
+      struct _cef_dictionary_value_t* self, const cef_string_t* key);
+
+  ///
+  // Returns the value at the specified key as type bool.
+  ///
+  int (CEF_CALLBACK *get_bool)(struct _cef_dictionary_value_t* self,
+      const cef_string_t* key);
+
+  ///
+  // Returns the value at the specified key as type int.
+  ///
+  int (CEF_CALLBACK *get_int)(struct _cef_dictionary_value_t* self,
+      const cef_string_t* key);
+
+  ///
+  // Returns the value at the specified key as type double.
+  ///
+  double (CEF_CALLBACK *get_double)(struct _cef_dictionary_value_t* self,
+      const cef_string_t* key);
+
+  ///
+  // Returns the value at the specified key as type string.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_string)(
+      struct _cef_dictionary_value_t* self, const cef_string_t* key);
+
+  ///
+  // Returns the value at the specified key as type binary. The returned value
+  // will reference existing data.
+  ///
+  struct _cef_binary_value_t* (CEF_CALLBACK *get_binary)(
+      struct _cef_dictionary_value_t* self, const cef_string_t* key);
+
+  ///
+  // Returns the value at the specified key as type dictionary. The returned
+  // value will reference existing data and modifications to the value will
+  // modify this object.
+  ///
+  struct _cef_dictionary_value_t* (CEF_CALLBACK *get_dictionary)(
+      struct _cef_dictionary_value_t* self, const cef_string_t* key);
+
+  ///
+  // Returns the value at the specified key as type list. The returned value
+  // will reference existing data and modifications to the value will modify
+  // this object.
+  ///
+  struct _cef_list_value_t* (CEF_CALLBACK *get_list)(
+      struct _cef_dictionary_value_t* self, const cef_string_t* key);
+
+  ///
+  // Sets the value at the specified key. Returns true (1) if the value was set
+  // successfully. If |value| represents simple data then the underlying data
+  // will be copied and modifications to |value| will not modify this object. If
+  // |value| represents complex data (binary, dictionary or list) then the
+  // underlying data will be referenced and modifications to |value| will modify
+  // this object.
+  ///
+  int (CEF_CALLBACK *set_value)(struct _cef_dictionary_value_t* self,
+      const cef_string_t* key, struct _cef_value_t* value);
+
+  ///
+  // Sets the value at the specified key as type null. Returns true (1) if the
+  // value was set successfully.
+  ///
+  int (CEF_CALLBACK *set_null)(struct _cef_dictionary_value_t* self,
+      const cef_string_t* key);
+
+  ///
+  // Sets the value at the specified key as type bool. Returns true (1) if the
+  // value was set successfully.
+  ///
+  int (CEF_CALLBACK *set_bool)(struct _cef_dictionary_value_t* self,
+      const cef_string_t* key, int value);
+
+  ///
+  // Sets the value at the specified key as type int. Returns true (1) if the
+  // value was set successfully.
+  ///
+  int (CEF_CALLBACK *set_int)(struct _cef_dictionary_value_t* self,
+      const cef_string_t* key, int value);
+
+  ///
+  // Sets the value at the specified key as type double. Returns true (1) if the
+  // value was set successfully.
+  ///
+  int (CEF_CALLBACK *set_double)(struct _cef_dictionary_value_t* self,
+      const cef_string_t* key, double value);
+
+  ///
+  // Sets the value at the specified key as type string. Returns true (1) if the
+  // value was set successfully.
+  ///
+  int (CEF_CALLBACK *set_string)(struct _cef_dictionary_value_t* self,
+      const cef_string_t* key, const cef_string_t* value);
+
+  ///
+  // Sets the value at the specified key as type binary. Returns true (1) if the
+  // value was set successfully. If |value| is currently owned by another object
+  // then the value will be copied and the |value| reference will not change.
+  // Otherwise, ownership will be transferred to this object and the |value|
+  // reference will be invalidated.
+  ///
+  int (CEF_CALLBACK *set_binary)(struct _cef_dictionary_value_t* self,
+      const cef_string_t* key, struct _cef_binary_value_t* value);
+
+  ///
+  // Sets the value at the specified key as type dict. Returns true (1) if the
+  // value was set successfully. If |value| is currently owned by another object
+  // then the value will be copied and the |value| reference will not change.
+  // Otherwise, ownership will be transferred to this object and the |value|
+  // reference will be invalidated.
+  ///
+  int (CEF_CALLBACK *set_dictionary)(struct _cef_dictionary_value_t* self,
+      const cef_string_t* key, struct _cef_dictionary_value_t* value);
+
+  ///
+  // Sets the value at the specified key as type list. Returns true (1) if the
+  // value was set successfully. If |value| is currently owned by another object
+  // then the value will be copied and the |value| reference will not change.
+  // Otherwise, ownership will be transferred to this object and the |value|
+  // reference will be invalidated.
+  ///
+  int (CEF_CALLBACK *set_list)(struct _cef_dictionary_value_t* self,
+      const cef_string_t* key, struct _cef_list_value_t* value);
+} cef_dictionary_value_t;
+
+
+///
+// Creates a new object that is not owned by any other object.
+///
+CEF_EXPORT cef_dictionary_value_t* cef_dictionary_value_create();
+
+
+///
+// Structure representing a list value. Can be used on any process and thread.
+///
+typedef struct _cef_list_value_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns true (1) if this object is valid. This object may become invalid if
+  // the underlying data is owned by another object (e.g. list or dictionary)
+  // and that other object is then modified or destroyed. Do not call any other
+  // functions if this function returns false (0).
+  ///
+  int (CEF_CALLBACK *is_valid)(struct _cef_list_value_t* self);
+
+  ///
+  // Returns true (1) if this object is currently owned by another object.
+  ///
+  int (CEF_CALLBACK *is_owned)(struct _cef_list_value_t* self);
+
+  ///
+  // Returns true (1) if the values of this object are read-only. Some APIs may
+  // expose read-only objects.
+  ///
+  int (CEF_CALLBACK *is_read_only)(struct _cef_list_value_t* self);
+
+  ///
+  // Returns true (1) if this object and |that| object have the same underlying
+  // data. If true (1) modifications to this object will also affect |that|
+  // object and vice-versa.
+  ///
+  int (CEF_CALLBACK *is_same)(struct _cef_list_value_t* self,
+      struct _cef_list_value_t* that);
+
+  ///
+  // Returns true (1) if this object and |that| object have an equivalent
+  // underlying value but are not necessarily the same object.
+  ///
+  int (CEF_CALLBACK *is_equal)(struct _cef_list_value_t* self,
+      struct _cef_list_value_t* that);
+
+  ///
+  // Returns a writable copy of this object.
+  ///
+  struct _cef_list_value_t* (CEF_CALLBACK *copy)(
+      struct _cef_list_value_t* self);
+
+  ///
+  // Sets the number of values. If the number of values is expanded all new
+  // value slots will default to type null. Returns true (1) on success.
+  ///
+  int (CEF_CALLBACK *set_size)(struct _cef_list_value_t* self, size_t size);
+
+  ///
+  // Returns the number of values.
+  ///
+  size_t (CEF_CALLBACK *get_size)(struct _cef_list_value_t* self);
+
+  ///
+  // Removes all values. Returns true (1) on success.
+  ///
+  int (CEF_CALLBACK *clear)(struct _cef_list_value_t* self);
+
+  ///
+  // Removes the value at the specified index.
+  ///
+  int (CEF_CALLBACK *remove)(struct _cef_list_value_t* self, int index);
+
+  ///
+  // Returns the value type at the specified index.
+  ///
+  cef_value_type_t (CEF_CALLBACK *get_type)(struct _cef_list_value_t* self,
+      int index);
+
+  ///
+  // Returns the value at the specified index. For simple types the returned
+  // value will copy existing data and modifications to the value will not
+  // modify this object. For complex types (binary, dictionary and list) the
+  // returned value will reference existing data and modifications to the value
+  // will modify this object.
+  ///
+  struct _cef_value_t* (CEF_CALLBACK *get_value)(struct _cef_list_value_t* self,
+      int index);
+
+  ///
+  // Returns the value at the specified index as type bool.
+  ///
+  int (CEF_CALLBACK *get_bool)(struct _cef_list_value_t* self, int index);
+
+  ///
+  // Returns the value at the specified index as type int.
+  ///
+  int (CEF_CALLBACK *get_int)(struct _cef_list_value_t* self, int index);
+
+  ///
+  // Returns the value at the specified index as type double.
+  ///
+  double (CEF_CALLBACK *get_double)(struct _cef_list_value_t* self, int index);
+
+  ///
+  // Returns the value at the specified index as type string.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_string)(
+      struct _cef_list_value_t* self, int index);
+
+  ///
+  // Returns the value at the specified index as type binary. The returned value
+  // will reference existing data.
+  ///
+  struct _cef_binary_value_t* (CEF_CALLBACK *get_binary)(
+      struct _cef_list_value_t* self, int index);
+
+  ///
+  // Returns the value at the specified index as type dictionary. The returned
+  // value will reference existing data and modifications to the value will
+  // modify this object.
+  ///
+  struct _cef_dictionary_value_t* (CEF_CALLBACK *get_dictionary)(
+      struct _cef_list_value_t* self, int index);
+
+  ///
+  // Returns the value at the specified index as type list. The returned value
+  // will reference existing data and modifications to the value will modify
+  // this object.
+  ///
+  struct _cef_list_value_t* (CEF_CALLBACK *get_list)(
+      struct _cef_list_value_t* self, int index);
+
+  ///
+  // Sets the value at the specified index. Returns true (1) if the value was
+  // set successfully. If |value| represents simple data then the underlying
+  // data will be copied and modifications to |value| will not modify this
+  // object. If |value| represents complex data (binary, dictionary or list)
+  // then the underlying data will be referenced and modifications to |value|
+  // will modify this object.
+  ///
+  int (CEF_CALLBACK *set_value)(struct _cef_list_value_t* self, int index,
+      struct _cef_value_t* value);
+
+  ///
+  // Sets the value at the specified index as type null. Returns true (1) if the
+  // value was set successfully.
+  ///
+  int (CEF_CALLBACK *set_null)(struct _cef_list_value_t* self, int index);
+
+  ///
+  // Sets the value at the specified index as type bool. Returns true (1) if the
+  // value was set successfully.
+  ///
+  int (CEF_CALLBACK *set_bool)(struct _cef_list_value_t* self, int index,
+      int value);
+
+  ///
+  // Sets the value at the specified index as type int. Returns true (1) if the
+  // value was set successfully.
+  ///
+  int (CEF_CALLBACK *set_int)(struct _cef_list_value_t* self, int index,
+      int value);
+
+  ///
+  // Sets the value at the specified index as type double. Returns true (1) if
+  // the value was set successfully.
+  ///
+  int (CEF_CALLBACK *set_double)(struct _cef_list_value_t* self, int index,
+      double value);
+
+  ///
+  // Sets the value at the specified index as type string. Returns true (1) if
+  // the value was set successfully.
+  ///
+  int (CEF_CALLBACK *set_string)(struct _cef_list_value_t* self, int index,
+      const cef_string_t* value);
+
+  ///
+  // Sets the value at the specified index as type binary. Returns true (1) if
+  // the value was set successfully. If |value| is currently owned by another
+  // object then the value will be copied and the |value| reference will not
+  // change. Otherwise, ownership will be transferred to this object and the
+  // |value| reference will be invalidated.
+  ///
+  int (CEF_CALLBACK *set_binary)(struct _cef_list_value_t* self, int index,
+      struct _cef_binary_value_t* value);
+
+  ///
+  // Sets the value at the specified index as type dict. Returns true (1) if the
+  // value was set successfully. If |value| is currently owned by another object
+  // then the value will be copied and the |value| reference will not change.
+  // Otherwise, ownership will be transferred to this object and the |value|
+  // reference will be invalidated.
+  ///
+  int (CEF_CALLBACK *set_dictionary)(struct _cef_list_value_t* self, int index,
+      struct _cef_dictionary_value_t* value);
+
+  ///
+  // Sets the value at the specified index as type list. Returns true (1) if the
+  // value was set successfully. If |value| is currently owned by another object
+  // then the value will be copied and the |value| reference will not change.
+  // Otherwise, ownership will be transferred to this object and the |value|
+  // reference will be invalidated.
+  ///
+  int (CEF_CALLBACK *set_list)(struct _cef_list_value_t* self, int index,
+      struct _cef_list_value_t* value);
+} cef_list_value_t;
+
+
+///
+// Creates a new object that is not owned by any other object.
+///
+CEF_EXPORT cef_list_value_t* cef_list_value_create();
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_VALUES_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_web_plugin_capi.h b/src/include/libcef_/capi/cef_web_plugin_capi.h
new file mode 100644
index 0000000..94abb67
--- /dev/null
+++ b/src/include/libcef_/capi/cef_web_plugin_capi.h
@@ -0,0 +1,195 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_WEB_PLUGIN_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_WEB_PLUGIN_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _cef_browser_t;
+
+///
+// Information about a specific web plugin.
+///
+typedef struct _cef_web_plugin_info_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Returns the plugin name (i.e. Flash).
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_name)(
+      struct _cef_web_plugin_info_t* self);
+
+  ///
+  // Returns the plugin file path (DLL/bundle/library).
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_path)(
+      struct _cef_web_plugin_info_t* self);
+
+  ///
+  // Returns the version of the plugin (may be OS-specific).
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_version)(
+      struct _cef_web_plugin_info_t* self);
+
+  ///
+  // Returns a description of the plugin from the version information.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_description)(
+      struct _cef_web_plugin_info_t* self);
+} cef_web_plugin_info_t;
+
+
+///
+// Structure to implement for visiting web plugin information. The functions of
+// this structure will be called on the browser process UI thread.
+///
+typedef struct _cef_web_plugin_info_visitor_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Method that will be called once for each plugin. |count| is the 0-based
+  // index for the current plugin. |total| is the total number of plugins.
+  // Return false (0) to stop visiting plugins. This function may never be
+  // called if no plugins are found.
+  ///
+  int (CEF_CALLBACK *visit)(struct _cef_web_plugin_info_visitor_t* self,
+      struct _cef_web_plugin_info_t* info, int count, int total);
+} cef_web_plugin_info_visitor_t;
+
+
+///
+// Structure to implement for receiving unstable plugin information. The
+// functions of this structure will be called on the browser process IO thread.
+///
+typedef struct _cef_web_plugin_unstable_callback_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Method that will be called for the requested plugin. |unstable| will be
+  // true (1) if the plugin has reached the crash count threshold of 3 times in
+  // 120 seconds.
+  ///
+  void (CEF_CALLBACK *is_unstable)(
+      struct _cef_web_plugin_unstable_callback_t* self,
+      const cef_string_t* path, int unstable);
+} cef_web_plugin_unstable_callback_t;
+
+
+///
+// Visit web plugin information. Can be called on any thread in the browser
+// process.
+///
+CEF_EXPORT void cef_visit_web_plugin_info(
+    cef_web_plugin_info_visitor_t* visitor);
+
+///
+// Cause the plugin list to refresh the next time it is accessed regardless of
+// whether it has already been loaded. Can be called on any thread in the
+// browser process.
+///
+CEF_EXPORT void cef_refresh_web_plugins();
+
+///
+// Add a plugin path (directory + file). This change may not take affect until
+// after cef_refresh_web_plugins() is called. Can be called on any thread in the
+// browser process.
+///
+CEF_EXPORT void cef_add_web_plugin_path(const cef_string_t* path);
+
+///
+// Add a plugin directory. This change may not take affect until after
+// cef_refresh_web_plugins() is called. Can be called on any thread in the
+// browser process.
+///
+CEF_EXPORT void cef_add_web_plugin_directory(const cef_string_t* dir);
+
+///
+// Remove a plugin path (directory + file). This change may not take affect
+// until after cef_refresh_web_plugins() is called. Can be called on any thread
+// in the browser process.
+///
+CEF_EXPORT void cef_remove_web_plugin_path(const cef_string_t* path);
+
+///
+// Unregister an internal plugin. This may be undone the next time
+// cef_refresh_web_plugins() is called. Can be called on any thread in the
+// browser process.
+///
+CEF_EXPORT void cef_unregister_internal_web_plugin(const cef_string_t* path);
+
+///
+// Force a plugin to shutdown. Can be called on any thread in the browser
+// process but will be executed on the IO thread.
+///
+CEF_EXPORT void cef_force_web_plugin_shutdown(const cef_string_t* path);
+
+///
+// Register a plugin crash. Can be called on any thread in the browser process
+// but will be executed on the IO thread.
+///
+CEF_EXPORT void cef_register_web_plugin_crash(const cef_string_t* path);
+
+///
+// Query if a plugin is unstable. Can be called on any thread in the browser
+// process.
+///
+CEF_EXPORT void cef_is_web_plugin_unstable(const cef_string_t* path,
+    cef_web_plugin_unstable_callback_t* callback);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_WEB_PLUGIN_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_xml_reader_capi.h b/src/include/libcef_/capi/cef_xml_reader_capi.h
new file mode 100644
index 0000000..462bd78
--- /dev/null
+++ b/src/include/libcef_/capi/cef_xml_reader_capi.h
@@ -0,0 +1,278 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_XML_READER_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_XML_READER_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+#include"libcef/capi/cef_stream_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Structure that supports the reading of XML data via the libxml streaming API.
+// The functions of this structure should only be called on the thread that
+// creates the object.
+///
+typedef struct _cef_xml_reader_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Moves the cursor to the next node in the document. This function must be
+  // called at least once to set the current cursor position. Returns true (1)
+  // if the cursor position was set successfully.
+  ///
+  int (CEF_CALLBACK *move_to_next_node)(struct _cef_xml_reader_t* self);
+
+  ///
+  // Close the document. This should be called directly to ensure that cleanup
+  // occurs on the correct thread.
+  ///
+  int (CEF_CALLBACK *close)(struct _cef_xml_reader_t* self);
+
+  ///
+  // Returns true (1) if an error has been reported by the XML parser.
+  ///
+  int (CEF_CALLBACK *has_error)(struct _cef_xml_reader_t* self);
+
+  ///
+  // Returns the error string.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_error)(
+      struct _cef_xml_reader_t* self);
+
+
+  // The below functions retrieve data for the node at the current cursor
+  // position.
+
+  ///
+  // Returns the node type.
+  ///
+  cef_xml_node_type_t (CEF_CALLBACK *get_type)(struct _cef_xml_reader_t* self);
+
+  ///
+  // Returns the node depth. Depth starts at 0 for the root node.
+  ///
+  int (CEF_CALLBACK *get_depth)(struct _cef_xml_reader_t* self);
+
+  ///
+  // Returns the local name. See http://www.w3.org/TR/REC-xml-names/#NT-
+  // LocalPart for additional details.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_local_name)(
+      struct _cef_xml_reader_t* self);
+
+  ///
+  // Returns the namespace prefix. See http://www.w3.org/TR/REC-xml-names/ for
+  // additional details.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_prefix)(
+      struct _cef_xml_reader_t* self);
+
+  ///
+  // Returns the qualified name, equal to (Prefix:)LocalName. See
+  // http://www.w3.org/TR/REC-xml-names/#ns-qualnames for additional details.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_qualified_name)(
+      struct _cef_xml_reader_t* self);
+
+  ///
+  // Returns the URI defining the namespace associated with the node. See
+  // http://www.w3.org/TR/REC-xml-names/ for additional details.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_namespace_uri)(
+      struct _cef_xml_reader_t* self);
+
+  ///
+  // Returns the base URI of the node. See http://www.w3.org/TR/xmlbase/ for
+  // additional details.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_base_uri)(
+      struct _cef_xml_reader_t* self);
+
+  ///
+  // Returns the xml:lang scope within which the node resides. See
+  // http://www.w3.org/TR/REC-xml/#sec-lang-tag for additional details.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_xml_lang)(
+      struct _cef_xml_reader_t* self);
+
+  ///
+  // Returns true (1) if the node represents an NULL element. <a/> is considered
+  // NULL but <a></a> is not.
+  ///
+  int (CEF_CALLBACK *is_empty_element)(struct _cef_xml_reader_t* self);
+
+  ///
+  // Returns true (1) if the node has a text value.
+  ///
+  int (CEF_CALLBACK *has_value)(struct _cef_xml_reader_t* self);
+
+  ///
+  // Returns the text value.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_value)(
+      struct _cef_xml_reader_t* self);
+
+  ///
+  // Returns true (1) if the node has attributes.
+  ///
+  int (CEF_CALLBACK *has_attributes)(struct _cef_xml_reader_t* self);
+
+  ///
+  // Returns the number of attributes.
+  ///
+  size_t (CEF_CALLBACK *get_attribute_count)(struct _cef_xml_reader_t* self);
+
+  ///
+  // Returns the value of the attribute at the specified 0-based index.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_attribute_byindex)(
+      struct _cef_xml_reader_t* self, int index);
+
+  ///
+  // Returns the value of the attribute with the specified qualified name.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_attribute_byqname)(
+      struct _cef_xml_reader_t* self, const cef_string_t* qualifiedName);
+
+  ///
+  // Returns the value of the attribute with the specified local name and
+  // namespace URI.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_attribute_bylname)(
+      struct _cef_xml_reader_t* self, const cef_string_t* localName,
+      const cef_string_t* namespaceURI);
+
+  ///
+  // Returns an XML representation of the current node's children.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_inner_xml)(
+      struct _cef_xml_reader_t* self);
+
+  ///
+  // Returns an XML representation of the current node including its children.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_outer_xml)(
+      struct _cef_xml_reader_t* self);
+
+  ///
+  // Returns the line number for the current node.
+  ///
+  int (CEF_CALLBACK *get_line_number)(struct _cef_xml_reader_t* self);
+
+
+  // Attribute nodes are not traversed by default. The below functions can be
+  // used to move the cursor to an attribute node. move_to_carrying_element()
+  // can be called afterwards to return the cursor to the carrying element. The
+  // depth of an attribute node will be 1 + the depth of the carrying element.
+
+  ///
+  // Moves the cursor to the attribute at the specified 0-based index. Returns
+  // true (1) if the cursor position was set successfully.
+  ///
+  int (CEF_CALLBACK *move_to_attribute_byindex)(struct _cef_xml_reader_t* self,
+      int index);
+
+  ///
+  // Moves the cursor to the attribute with the specified qualified name.
+  // Returns true (1) if the cursor position was set successfully.
+  ///
+  int (CEF_CALLBACK *move_to_attribute_byqname)(struct _cef_xml_reader_t* self,
+      const cef_string_t* qualifiedName);
+
+  ///
+  // Moves the cursor to the attribute with the specified local name and
+  // namespace URI. Returns true (1) if the cursor position was set
+  // successfully.
+  ///
+  int (CEF_CALLBACK *move_to_attribute_bylname)(struct _cef_xml_reader_t* self,
+      const cef_string_t* localName, const cef_string_t* namespaceURI);
+
+  ///
+  // Moves the cursor to the first attribute in the current element. Returns
+  // true (1) if the cursor position was set successfully.
+  ///
+  int (CEF_CALLBACK *move_to_first_attribute)(struct _cef_xml_reader_t* self);
+
+  ///
+  // Moves the cursor to the next attribute in the current element. Returns true
+  // (1) if the cursor position was set successfully.
+  ///
+  int (CEF_CALLBACK *move_to_next_attribute)(struct _cef_xml_reader_t* self);
+
+  ///
+  // Moves the cursor back to the carrying element. Returns true (1) if the
+  // cursor position was set successfully.
+  ///
+  int (CEF_CALLBACK *move_to_carrying_element)(struct _cef_xml_reader_t* self);
+} cef_xml_reader_t;
+
+
+///
+// Create a new cef_xml_reader_t object. The returned object's functions can
+// only be called from the thread that created the object.
+///
+CEF_EXPORT cef_xml_reader_t* cef_xml_reader_create(
+    struct _cef_stream_reader_t* stream, cef_xml_encoding_type_t encodingType,
+    const cef_string_t* URI);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_XML_READER_CAPI_H_
diff --git a/src/include/libcef_/capi/cef_zip_reader_capi.h b/src/include/libcef_/capi/cef_zip_reader_capi.h
new file mode 100644
index 0000000..a8ba71e
--- /dev/null
+++ b/src/include/libcef_/capi/cef_zip_reader_capi.h
@@ -0,0 +1,150 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_ZIP_READER_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_ZIP_READER_CAPI_H_
+#pragma once
+
+#include"libcef/capi/cef_base_capi.h"
+#include"libcef/capi/cef_stream_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// Structure that supports the reading of zip archives via the zlib unzip API.
+// The functions of this structure should only be called on the thread that
+// creates the object.
+///
+typedef struct _cef_zip_reader_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Moves the cursor to the first file in the archive. Returns true (1) if the
+  // cursor position was set successfully.
+  ///
+  int (CEF_CALLBACK *move_to_first_file)(struct _cef_zip_reader_t* self);
+
+  ///
+  // Moves the cursor to the next file in the archive. Returns true (1) if the
+  // cursor position was set successfully.
+  ///
+  int (CEF_CALLBACK *move_to_next_file)(struct _cef_zip_reader_t* self);
+
+  ///
+  // Moves the cursor to the specified file in the archive. If |caseSensitive|
+  // is true (1) then the search will be case sensitive. Returns true (1) if the
+  // cursor position was set successfully.
+  ///
+  int (CEF_CALLBACK *move_to_file)(struct _cef_zip_reader_t* self,
+      const cef_string_t* fileName, int caseSensitive);
+
+  ///
+  // Closes the archive. This should be called directly to ensure that cleanup
+  // occurs on the correct thread.
+  ///
+  int (CEF_CALLBACK *close)(struct _cef_zip_reader_t* self);
+
+
+  // The below functions act on the file at the current cursor position.
+
+  ///
+  // Returns the name of the file.
+  ///
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t (CEF_CALLBACK *get_file_name)(
+      struct _cef_zip_reader_t* self);
+
+  ///
+  // Returns the uncompressed size of the file.
+  ///
+  int64 (CEF_CALLBACK *get_file_size)(struct _cef_zip_reader_t* self);
+
+  ///
+  // Returns the last modified timestamp for the file.
+  ///
+  cef_time_t (CEF_CALLBACK *get_file_last_modified)(
+      struct _cef_zip_reader_t* self);
+
+  ///
+  // Opens the file for reading of uncompressed data. A read password may
+  // optionally be specified.
+  ///
+  int (CEF_CALLBACK *open_file)(struct _cef_zip_reader_t* self,
+      const cef_string_t* password);
+
+  ///
+  // Closes the file.
+  ///
+  int (CEF_CALLBACK *close_file)(struct _cef_zip_reader_t* self);
+
+  ///
+  // Read uncompressed file contents into the specified buffer. Returns < 0 if
+  // an error occurred, 0 if at the end of file, or the number of bytes read.
+  ///
+  int (CEF_CALLBACK *read_file)(struct _cef_zip_reader_t* self, void* buffer,
+      size_t bufferSize);
+
+  ///
+  // Returns the current offset in the uncompressed file contents.
+  ///
+  int64 (CEF_CALLBACK *tell)(struct _cef_zip_reader_t* self);
+
+  ///
+  // Returns true (1) if at end of the file contents.
+  ///
+  int (CEF_CALLBACK *eof)(struct _cef_zip_reader_t* self);
+} cef_zip_reader_t;
+
+
+///
+// Create a new cef_zip_reader_t object. The returned object's functions can
+// only be called from the thread that created the object.
+///
+CEF_EXPORT cef_zip_reader_t* cef_zip_reader_create(
+    struct _cef_stream_reader_t* stream);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_ZIP_READER_CAPI_H_
diff --git a/src/include/libcef_/cef_app.h b/src/include/libcef_/cef_app.h
new file mode 100644
index 0000000..294ea09
--- /dev/null
+++ b/src/include/libcef_/cef_app.h
@@ -0,0 +1,202 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+
+#ifndef CEF_INCLUDE_CEF_APP_H_
+#define CEF_INCLUDE_CEF_APP_H_
+#pragma once
+
+#include"libcef/cef_base.h"
+#include"libcef/cef_browser_process_handler.h"
+#include"libcef/cef_command_line.h"
+#include"libcef/cef_render_process_handler.h"
+#include"libcef/cef_resource_bundle_handler.h"
+#include"libcef/cef_scheme.h"
+
+class CefApp;
+
+///
+// This function should be called from the application entry point function to
+// execute a secondary process. It can be used to run secondary processes from
+// the browser client executable (default behavior) or from a separate
+// executable specified by the CefSettings.browser_subprocess_path value. If
+// called for the browser process (identified by no "type" command-line value)
+// it will return immediately with a value of -1. If called for a recognized
+// secondary process it will block until the process should exit and then return
+// the process exit code. The |application| parameter may be empty. The
+// |windows_sandbox_info| parameter is only used on Windows and may be NULL (see
+// cef_sandbox_win.h for details).
+///
+/*--cef(api_hash_check,optional_param=application,
+        optional_param=windows_sandbox_info)--*/
+int CefExecuteProcess(const CefMainArgs& args,
+                      CefRefPtr<CefApp> application,
+                      void* windows_sandbox_info);
+
+///
+// This function should be called on the main application thread to initialize
+// the CEF browser process. The |application| parameter may be empty. A return
+// value of true indicates that it succeeded and false indicates that it failed.
+// The |windows_sandbox_info| parameter is only used on Windows and may be NULL
+// (see cef_sandbox_win.h for details).
+///
+/*--cef(api_hash_check,optional_param=application,
+        optional_param=windows_sandbox_info)--*/
+bool CefInitialize(const CefMainArgs& args,
+                   const CefSettings& settings,
+                   CefRefPtr<CefApp> application,
+                   void* windows_sandbox_info);
+
+///
+// This function should be called on the main application thread to shut down
+// the CEF browser process before the application exits.
+///
+/*--cef()--*/
+void CefShutdown();
+
+///
+// Perform a single iteration of CEF message loop processing. This function is
+// used to integrate the CEF message loop into an existing application message
+// loop. Care must be taken to balance performance against excessive CPU usage.
+// This function should only be called on the main application thread and only
+// if CefInitialize() is called with a CefSettings.multi_threaded_message_loop
+// value of false. This function will not block.
+///
+/*--cef()--*/
+void CefDoMessageLoopWork();
+
+///
+// Run the CEF message loop. Use this function instead of an application-
+// provided message loop to get the best balance between performance and CPU
+// usage. This function should only be called on the main application thread and
+// only if CefInitialize() is called with a
+// CefSettings.multi_threaded_message_loop value of false. This function will
+// block until a quit message is received by the system.
+///
+/*--cef()--*/
+void CefRunMessageLoop();
+
+///
+// Quit the CEF message loop that was started by calling CefRunMessageLoop().
+// This function should only be called on the main application thread and only
+// if CefRunMessageLoop() was used.
+///
+/*--cef()--*/
+void CefQuitMessageLoop();
+
+///
+// Set to true before calling Windows APIs like TrackPopupMenu that enter a
+// modal message loop. Set to false after exiting the modal message loop.
+///
+/*--cef()--*/
+void CefSetOSModalLoop(bool osModalLoop);
+
+///
+// Call during process startup to enable High-DPI support on Windows 7 or newer.
+// Older versions of Windows should be left DPI-unaware because they do not
+// support DirectWrite and GDI fonts are kerned very badly.
+///
+/*--cef(capi_name=cef_enable_highdpi_support)--*/
+void CefEnableHighDPISupport();
+
+
+
+///
+// Implement this interface to provide handler implementations. Methods will be
+// called by the process and/or thread indicated.
+///
+/*--cef(source=client,no_debugct_check)--*/
+class CefApp : public virtual CefBase {
+ public:
+  ///
+  // Provides an opportunity to view and/or modify command-line arguments before
+  // processing by CEF and Chromium. The |process_type| value will be empty for
+  // the browser process. Do not keep a reference to the CefCommandLine object
+  // passed to this method. The CefSettings.command_line_args_disabled value
+  // can be used to start with an empty command-line object. Any values
+  // specified in CefSettings that equate to command-line arguments will be set
+  // before this method is called. Be cautious when using this method to modify
+  // command-line arguments for non-browser processes as this may result in
+  // undefined behavior including crashes.
+  ///
+  /*--cef(optional_param=process_type)--*/
+  virtual void OnBeforeCommandLineProcessing(
+      const CefString& process_type,
+      CefRefPtr<CefCommandLine> command_line) {
+  }
+
+  ///
+  // Provides an opportunity to register custom schemes. Do not keep a reference
+  // to the |registrar| object. This method is called on the main thread for
+  // each process and the registered schemes should be the same across all
+  // processes.
+  ///
+  /*--cef()--*/
+  virtual void OnRegisterCustomSchemes(
+      CefRefPtr<CefSchemeRegistrar> registrar) {
+  }
+
+  ///
+  // Return the handler for resource bundle events. If
+  // CefSettings.pack_loading_disabled is true a handler must be returned. If no
+  // handler is returned resources will be loaded from pack files. This method
+  // is called by the browser and render processes on multiple threads.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefResourceBundleHandler> GetResourceBundleHandler() {
+    return NULL;
+  }
+
+  ///
+  // Return the handler for functionality specific to the browser process. This
+  // method is called on multiple threads in the browser process.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefBrowserProcessHandler> GetBrowserProcessHandler() {
+    return NULL;
+  }
+
+  ///
+  // Return the handler for functionality specific to the render process. This
+  // method is called on the render process main thread.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefRenderProcessHandler> GetRenderProcessHandler() {
+    return NULL;
+  }
+};
+
+#endif  // CEF_INCLUDE_CEF_APP_H_
diff --git a/src/include/libcef_/cef_auth_callback.h b/src/include/libcef_/cef_auth_callback.h
new file mode 100644
index 0000000..43eefc3
--- /dev/null
+++ b/src/include/libcef_/cef_auth_callback.h
@@ -0,0 +1,64 @@
+// Copyright (c) 2013 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_AUTH_CALLBACK_H_
+#define CEF_INCLUDE_CEF_AUTH_CALLBACK_H_
+#pragma once
+
+#include"libcef/cef_base.h"
+
+///
+// Callback interface used for asynchronous continuation of authentication
+// requests.
+///
+/*--cef(source=library)--*/
+class CefAuthCallback : public virtual CefBase {
+ public:
+  ///
+  // Continue the authentication request.
+  ///
+  /*--cef(capi_name=cont)--*/
+  virtual void Continue(const CefString& username,
+                        const CefString& password) =0;
+
+  ///
+  // Cancel the authentication request.
+  ///
+  /*--cef()--*/
+  virtual void Cancel() =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_AUTH_CALLBACK_H_
diff --git a/src/include/libcef_/cef_base.h b/src/include/libcef_/cef_base.h
new file mode 100644
index 0000000..c421a32
--- /dev/null
+++ b/src/include/libcef_/cef_base.h
@@ -0,0 +1,180 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+#ifndef CEF_INCLUDE_CEF_BASE_H_
+#define CEF_INCLUDE_CEF_BASE_H_
+#pragma once
+
+#include"libcef/base/cef_atomic_ref_count.h"
+#include"libcef/base/cef_build.h"
+#include"libcef/base/cef_macros.h"
+
+// Bring in common C++ type definitions used by CEF consumers.
+#include"libcef/internal/cef_ptr.h"
+#include"libcef/internal/cef_types_wrappers.h"
+#if defined(OS_WIN)
+  #include"libcef/internal/cef_win.h"
+#elif defined(OS_MACOSX)
+  #include "include/internal/cef_mac.h"
+#elif defined(OS_LINUX)
+  #include "include/internal/cef_linux.h"
+#endif
+
+///
+// Interface defining the reference count implementation methods. All framework
+// classes must extend the CefBase class.
+///
+class CefBase {
+ public:
+  ///
+  // Called to increment the reference count for the object. Should be called
+  // for every new copy of a pointer to a given object.
+  ///
+  virtual void AddRef() const =0;
+
+  ///
+  // Called to decrement the reference count for the object. Returns true if
+  // the reference count is 0, in which case the object should self-delete.
+  ///
+  virtual bool Release() const =0;
+
+  ///
+  // Returns true if the reference count is 1.
+  ///
+  virtual bool HasOneRef() const =0;
+
+ protected:
+  virtual ~CefBase() {}
+};
+
+///
+// Class that implements atomic reference counting.
+///
+class CefRefCount {
+ public:
+  CefRefCount() : ref_count_(0) {}
+
+  ///
+  // Increment the reference count.
+  ///
+  void AddRef() const {
+    base::AtomicRefCountInc(&ref_count_); 
+  }
+
+  ///
+  // Decrement the reference count. Returns true if the reference count is 0.
+  ///
+  bool Release() const {
+    return !base::AtomicRefCountDec(&ref_count_);
+  }
+
+  ///
+  // Returns true if the reference count is 1.
+  ///
+  bool HasOneRef() const {
+    return base::AtomicRefCountIsOne(&ref_count_);
+  }
+
+ private:
+  mutable base::AtomicRefCount ref_count_;
+  DISALLOW_COPY_AND_ASSIGN(CefRefCount);
+};
+
+///
+// Macro that provides a reference counting implementation for classes extending
+// CefBase.
+///
+#define IMPLEMENT_REFCOUNTING(ClassName)            \
+  public:                                           \
+    void AddRef() const OVERRIDE {                  \
+      ref_count_.AddRef();                          \
+    }                                               \
+    bool Release() const OVERRIDE {                 \
+      if (ref_count_.Release()) {                   \
+        delete static_cast<const ClassName*>(this); \
+        return true;                                \
+      }                                             \
+      return false;                                 \
+    }                                               \
+    bool HasOneRef() const OVERRIDE {               \
+      return ref_count_.HasOneRef();                \
+    }                                               \
+  private:                                          \
+    CefRefCount ref_count_;
+
+///
+// Macro that provides a locking implementation. Use the Lock() and Unlock()
+// methods to protect a section of code from simultaneous access by multiple
+// threads. The AutoLock class is a helper that will hold the lock while in
+// scope.
+//
+// THIS MACRO IS DEPRECATED. Use an explicit base::Lock member variable and
+// base::AutoLock instead. For example:
+//
+// #include "include/base/cef_lock.h"
+//
+// // Class declaration.
+// class MyClass : public CefBase {
+//  public:
+//   MyClass() : value_(0) {}
+//   // Method that may be called on multiple threads.
+//   void IncrementValue();
+//  private:
+//   // Value that may be accessed on multiple theads.
+//   int value_;
+//   // Lock used to protect access to |value_|.
+//   base::Lock lock_;
+//   IMPLEMENT_REFCOUNTING(MyClass);
+// };
+//
+// // Class implementation.
+// void MyClass::IncrementValue() {
+//   // Acquire the lock for the scope of this method.
+//   base::AutoLock lock_scope(lock_);
+//   // |value_| can now be modified safely.
+//   value_++;
+// }
+///
+#define IMPLEMENT_LOCKING(ClassName)                                       \
+  public:                                                                  \
+    class AutoLock {                                                       \
+     public:                                                               \
+      explicit AutoLock(ClassName* base) : base_(base) { base_->Lock(); }  \
+      ~AutoLock() { base_->Unlock(); }                                     \
+     private:                                                              \
+      ClassName* base_;                                                    \
+      DISALLOW_COPY_AND_ASSIGN(AutoLock);                                  \
+    };                                                                     \
+    void Lock() { lock_.Acquire(); }                                       \
+    void Unlock() { lock_.Release(); }                                     \
+  private:                                                                 \
+    base::Lock lock_;
+
+#endif  // CEF_INCLUDE_CEF_BASE_H_
diff --git a/src/include/libcef_/cef_browser.h b/src/include/libcef_/cef_browser.h
new file mode 100644
index 0000000..2e0f22a
--- /dev/null
+++ b/src/include/libcef_/cef_browser.h
@@ -0,0 +1,692 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_BROWSER_H_
+#define CEF_INCLUDE_CEF_BROWSER_H_
+#pragma once
+
+#include"libcef/cef_base.h"
+#include"libcef/cef_drag_data.h"
+#include"libcef/cef_frame.h"
+#include"libcef/cef_navigation_entry.h"
+#include"libcef/cef_process_message.h"
+#include"libcef/cef_request_context.h"
+#include<vector>
+
+class CefBrowserHost;
+class CefClient;
+
+
+///
+// Class used to represent a browser window. When used in the browser process
+// the methods of this class may be called on any thread unless otherwise
+// indicated in the comments. When used in the render process the methods of
+// this class may only be called on the main thread.
+///
+/*--cef(source=library)--*/
+class CefBrowser : public virtual CefBase {
+ public:
+  ///
+  // Returns the browser host object. This method can only be called in the
+  // browser process.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefBrowserHost> GetHost() =0;
+
+  ///
+  // Returns true if the browser can navigate backwards.
+  ///
+  /*--cef()--*/
+  virtual bool CanGoBack() =0;
+
+  ///
+  // Navigate backwards.
+  ///
+  /*--cef()--*/
+  virtual void GoBack() =0;
+
+  ///
+  // Returns true if the browser can navigate forwards.
+  ///
+  /*--cef()--*/
+  virtual bool CanGoForward() =0;
+
+  ///
+  // Navigate forwards.
+  ///
+  /*--cef()--*/
+  virtual void GoForward() =0;
+
+  ///
+  // Returns true if the browser is currently loading.
+  ///
+  /*--cef()--*/
+  virtual bool IsLoading() =0;
+
+  ///
+  // Reload the current page.
+  ///
+  /*--cef()--*/
+  virtual void Reload() =0;
+
+  ///
+  // Reload the current page ignoring any cached data.
+  ///
+  /*--cef()--*/
+  virtual void ReloadIgnoreCache() =0;
+
+  ///
+  // Stop loading the page.
+  ///
+  /*--cef()--*/
+  virtual void StopLoad() =0;
+
+  ///
+  // Returns the globally unique identifier for this browser.
+  ///
+  /*--cef()--*/
+  virtual int GetIdentifier() =0;
+
+  ///
+  // Returns true if this object is pointing to the same handle as |that|
+  // object.
+  ///
+  /*--cef()--*/
+  virtual bool IsSame(CefRefPtr<CefBrowser> that) =0;
+
+  ///
+  // Returns true if the window is a popup window.
+  ///
+  /*--cef()--*/
+  virtual bool IsPopup() =0;
+
+  ///
+  // Returns true if a document has been loaded in the browser.
+  ///
+  /*--cef()--*/
+  virtual bool HasDocument() =0;
+
+  ///
+  // Returns the main (top-level) frame for the browser window.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefFrame> GetMainFrame() =0;
+
+  ///
+  // Returns the focused frame for the browser window.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefFrame> GetFocusedFrame() =0;
+
+  ///
+  // Returns the frame with the specified identifier, or NULL if not found.
+  ///
+  /*--cef(capi_name=get_frame_byident)--*/
+  virtual CefRefPtr<CefFrame> GetFrame(int64 identifier) =0;
+
+  ///
+  // Returns the frame with the specified name, or NULL if not found.
+  ///
+  /*--cef(optional_param=name)--*/
+  virtual CefRefPtr<CefFrame> GetFrame(const CefString& name) =0;
+
+  ///
+  // Returns the number of frames that currently exist.
+  ///
+  /*--cef()--*/
+  virtual size_t GetFrameCount() =0;
+
+  ///
+  // Returns the identifiers of all existing frames.
+  ///
+  /*--cef(count_func=identifiers:GetFrameCount)--*/
+  virtual void GetFrameIdentifiers(std::vector<int64>& identifiers) =0;
+
+  ///
+  // Returns the names of all existing frames.
+  ///
+  /*--cef()--*/
+  virtual void GetFrameNames(std::vector<CefString>& names) =0;
+
+  ///
+  // Send a message to the specified |target_process|. Returns true if the
+  // message was sent successfully.
+  ///
+  /*--cef()--*/
+  virtual bool SendProcessMessage(CefProcessId target_process,
+                                  CefRefPtr<CefProcessMessage> message) =0;
+};
+
+
+///
+// Callback interface for CefBrowserHost::RunFileDialog. The methods of this
+// class will be called on the browser process UI thread.
+///
+/*--cef(source=client)--*/
+class CefRunFileDialogCallback : public virtual CefBase {
+ public:
+  ///
+  // Called asynchronously after the file dialog is dismissed.
+  // |selected_accept_filter| is the 0-based index of the value selected from
+  // the accept filters array passed to CefBrowserHost::RunFileDialog.
+  // |file_paths| will be a single value or a list of values depending on the
+  // dialog mode. If the selection was cancelled |file_paths| will be empty.
+  ///
+  /*--cef(index_param=selected_accept_filter,optional_param=file_paths)--*/
+  virtual void OnFileDialogDismissed(
+      int selected_accept_filter,
+      const std::vector<CefString>& file_paths) =0;
+};
+
+
+///
+// Callback interface for CefBrowserHost::GetNavigationEntries. The methods of
+// this class will be called on the browser process UI thread.
+///
+/*--cef(source=client)--*/
+class CefNavigationEntryVisitor : public virtual CefBase {
+ public:
+  ///
+  // Method that will be executed. Do not keep a reference to |entry| outside of
+  // this callback. Return true to continue visiting entries or false to stop.
+  // |current| is true if this entry is the currently loaded navigation entry.
+  // |index| is the 0-based index of this entry and |total| is the total number
+  // of entries.
+  ///
+  /*--cef()--*/
+  virtual bool Visit(CefRefPtr<CefNavigationEntry> entry,
+                     bool current,
+                     int index,
+                     int total) =0;
+};
+
+
+///
+// Callback interface for CefBrowserHost::PrintToPDF. The methods of this class
+// will be called on the browser process UI thread.
+///
+/*--cef(source=client)--*/
+class CefPdfPrintCallback : public virtual CefBase {
+ public:
+  ///
+  // Method that will be executed when the PDF printing has completed. |path|
+  // is the output path. |ok| will be true if the printing completed
+  // successfully or false otherwise.
+  ///
+  /*--cef()--*/
+  virtual void OnPdfPrintFinished(const CefString& path, bool ok) =0;
+};
+
+
+///
+// Class used to represent the browser process aspects of a browser window. The
+// methods of this class can only be called in the browser process. They may be
+// called on any thread in that process unless otherwise indicated in the
+// comments.
+///
+/*--cef(source=library)--*/
+class CefBrowserHost : public virtual CefBase {
+ public:
+  typedef cef_drag_operations_mask_t DragOperationsMask;
+  typedef cef_file_dialog_mode_t FileDialogMode;
+  typedef cef_mouse_button_type_t MouseButtonType;
+  typedef cef_paint_element_type_t PaintElementType;
+
+  ///
+  // Create a new browser window using the window parameters specified by
+  // |windowInfo|. All values will be copied internally and the actual window
+  // will be created on the UI thread. If |request_context| is empty the
+  // global request context will be used. This method can be called on any
+  // browser process thread and will not block.
+  ///
+  /*--cef(optional_param=client,optional_param=url,
+          optional_param=request_context)--*/
+  static bool CreateBrowser(const CefWindowInfo& windowInfo,
+                            CefRefPtr<CefClient> client,
+                            const CefString& url,
+                            const CefBrowserSettings& settings,
+                            CefRefPtr<CefRequestContext> request_context);
+
+  ///
+  // Create a new browser window using the window parameters specified by
+  // |windowInfo|. If |request_context| is empty the global request context
+  // will be used. This method can only be called on the browser process UI
+  // thread.
+  ///
+  /*--cef(optional_param=client,optional_param=url,
+          optional_param=request_context)--*/
+  static CefRefPtr<CefBrowser> CreateBrowserSync(
+      const CefWindowInfo& windowInfo,
+      CefRefPtr<CefClient> client,
+      const CefString& url,
+      const CefBrowserSettings& settings,
+      CefRefPtr<CefRequestContext> request_context);
+
+  ///
+  // Returns the hosted browser object.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefBrowser> GetBrowser() =0;
+
+  ///
+  // Request that the browser close. The JavaScript 'onbeforeunload' event will
+  // be fired. If |force_close| is false the event handler, if any, will be
+  // allowed to prompt the user and the user can optionally cancel the close.
+  // If |force_close| is true the prompt will not be displayed and the close
+  // will proceed. Results in a call to CefLifeSpanHandler::DoClose() if the
+  // event handler allows the close or if |force_close| is true. See
+  // CefLifeSpanHandler::DoClose() documentation for additional usage
+  // information.
+  ///
+  /*--cef()--*/
+  virtual void CloseBrowser(bool force_close) =0;
+
+  ///
+  // Set whether the browser is focused.
+  ///
+  /*--cef()--*/
+  virtual void SetFocus(bool focus) =0;
+
+  ///
+  // Set whether the window containing the browser is visible
+  // (minimized/unminimized, app hidden/unhidden, etc). Only used on Mac OS X.
+  ///
+  /*--cef()--*/
+  virtual void SetWindowVisibility(bool visible) =0;
+
+  ///
+  // Retrieve the window handle for this browser.
+  ///
+  /*--cef()--*/
+  virtual CefWindowHandle GetWindowHandle() =0;
+
+  ///
+  // Retrieve the window handle of the browser that opened this browser. Will
+  // return NULL for non-popup windows. This method can be used in combination
+  // with custom handling of modal windows.
+  ///
+  /*--cef()--*/
+  virtual CefWindowHandle GetOpenerWindowHandle() =0;
+
+  ///
+  // Returns the client for this browser.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefClient> GetClient() =0;
+
+  ///
+  // Returns the request context for this browser.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefRequestContext> GetRequestContext() =0;
+
+  ///
+  // Get the current zoom level. The default zoom level is 0.0. This method can
+  // only be called on the UI thread.
+  ///
+  /*--cef()--*/
+  virtual double GetZoomLevel() =0;
+
+  ///
+  // Change the zoom level to the specified value. Specify 0.0 to reset the
+  // zoom level. If called on the UI thread the change will be applied
+  // immediately. Otherwise, the change will be applied asynchronously on the
+  // UI thread.
+  ///
+  /*--cef()--*/
+  virtual void SetZoomLevel(double zoomLevel) =0;
+
+  ///
+  // Call to run a file chooser dialog. Only a single file chooser dialog may be
+  // pending at any given time. |mode| represents the type of dialog to display.
+  // |title| to the title to be used for the dialog and may be empty to show the
+  // default title ("Open" or "Save" depending on the mode). |default_file_path|
+  // is the path with optional directory and/or file name component that will be
+  // initially selected in the dialog. |accept_filters| are used to restrict the
+  // selectable file types and may any combination of (a) valid lower-cased MIME
+  // types (e.g. "text/*" or "image/*"), (b) individual file extensions (e.g.
+  // ".txt" or ".png"), or (c) combined description and file extension delimited
+  // using "|" and ";" (e.g. "Image Types|.png;.gif;.jpg").
+  // |selected_accept_filter| is the 0-based index of the filter that will be
+  // selected by default. |callback| will be executed after the dialog is
+  // dismissed or immediately if another dialog is already pending. The dialog
+  // will be initiated asynchronously on the UI thread.
+  ///
+  /*--cef(optional_param=title,optional_param=default_file_path,
+          optional_param=accept_filters,index_param=selected_accept_filter)--*/
+  virtual void RunFileDialog(FileDialogMode mode,
+                             const CefString& title,
+                             const CefString& default_file_path,
+                             const std::vector<CefString>& accept_filters,
+                             int selected_accept_filter,
+                             CefRefPtr<CefRunFileDialogCallback> callback) =0;
+
+  ///
+  // Download the file at |url| using CefDownloadHandler.
+  ///
+  /*--cef()--*/
+  virtual void StartDownload(const CefString& url) =0;
+
+  ///
+  // Print the current browser contents.
+  ///
+  /*--cef()--*/
+  virtual void Print() =0;
+
+  ///
+  // Print the current browser contents to the PDF file specified by |path| and
+  // execute |callback| on completion. The caller is responsible for deleting
+  // |path| when done. For PDF printing to work on Linux you must implement the
+  // CefPrintHandler::GetPdfPaperSize method.
+  ///
+  /*--cef(optional_param=callback)--*/
+  virtual void PrintToPDF(const CefString& path,
+                          const CefPdfPrintSettings& settings,
+                          CefRefPtr<CefPdfPrintCallback> callback) =0;
+
+  ///
+  // Search for |searchText|. |identifier| can be used to have multiple searches
+  // running simultaniously. |forward| indicates whether to search forward or
+  // backward within the page. |matchCase| indicates whether the search should
+  // be case-sensitive. |findNext| indicates whether this is the first request
+  // or a follow-up. The CefFindHandler instance, if any, returned via
+  // CefClient::GetFindHandler will be called to report find results.
+  ///
+  /*--cef()--*/
+  virtual void Find(int identifier, const CefString& searchText,
+                    bool forward, bool matchCase, bool findNext) =0;
+
+  ///
+  // Cancel all searches that are currently going on.
+  ///
+  /*--cef()--*/
+  virtual void StopFinding(bool clearSelection) =0;
+
+  ///
+  // Open developer tools in its own window. If |inspect_element_at| is non-
+  // empty the element at the specified (x,y) location will be inspected.
+  ///
+  /*--cef(optional_param=inspect_element_at)--*/
+  virtual void ShowDevTools(const CefWindowInfo& windowInfo,
+                            CefRefPtr<CefClient> client,
+                            const CefBrowserSettings& settings,
+                            const CefPoint& inspect_element_at) =0;
+
+  ///
+  // Explicitly close the developer tools window if one exists for this browser
+  // instance.
+  ///
+  /*--cef()--*/
+  virtual void CloseDevTools() =0;
+
+  ///
+  // Retrieve a snapshot of current navigation entries as values sent to the
+  // specified visitor. If |current_only| is true only the current navigation
+  // entry will be sent, otherwise all navigation entries will be sent.
+  ///
+  /*--cef()--*/
+  virtual void GetNavigationEntries(
+      CefRefPtr<CefNavigationEntryVisitor> visitor,
+      bool current_only) =0;
+
+  ///
+  // Set whether mouse cursor change is disabled.
+  ///
+  /*--cef()--*/
+  virtual void SetMouseCursorChangeDisabled(bool disabled) =0;
+
+  ///
+  // Returns true if mouse cursor change is disabled.
+  ///
+  /*--cef()--*/
+  virtual bool IsMouseCursorChangeDisabled() =0;
+
+  ///
+  // If a misspelled word is currently selected in an editable node calling
+  // this method will replace it with the specified |word|.
+  ///
+  /*--cef()--*/
+  virtual void ReplaceMisspelling(const CefString& word) =0;
+
+  ///
+  // Add the specified |word| to the spelling dictionary.
+  ///
+  /*--cef()--*/
+  virtual void AddWordToDictionary(const CefString& word) =0;
+
+  ///
+  // Returns true if window rendering is disabled.
+  ///
+  /*--cef()--*/
+  virtual bool IsWindowRenderingDisabled() =0;
+
+  ///
+  // Notify the browser that the widget has been resized. The browser will first
+  // call CefRenderHandler::GetViewRect to get the new size and then call
+  // CefRenderHandler::OnPaint asynchronously with the updated regions. This
+  // method is only used when window rendering is disabled.
+  ///
+  /*--cef()--*/
+  virtual void WasResized() =0;
+
+  ///
+  // Notify the browser that it has been hidden or shown. Layouting and
+  // CefRenderHandler::OnPaint notification will stop when the browser is
+  // hidden. This method is only used when window rendering is disabled.
+  ///
+  /*--cef()--*/
+  virtual void WasHidden(bool hidden) =0;
+
+  ///
+  // Send a notification to the browser that the screen info has changed. The
+  // browser will then call CefRenderHandler::GetScreenInfo to update the
+  // screen information with the new values. This simulates moving the webview
+  // window from one display to another, or changing the properties of the
+  // current display. This method is only used when window rendering is
+  // disabled.
+  ///
+  /*--cef()--*/
+  virtual void NotifyScreenInfoChanged() =0;
+
+  ///
+  // Invalidate the view. The browser will call CefRenderHandler::OnPaint
+  // asynchronously. This method is only used when window rendering is
+  // disabled.
+  ///
+  /*--cef()--*/
+  virtual void Invalidate(PaintElementType type) =0;
+
+  ///
+  // Send a key event to the browser.
+  ///
+  /*--cef()--*/
+  virtual void SendKeyEvent(const CefKeyEvent& event) =0;
+
+  ///
+  // Send a mouse click event to the browser. The |x| and |y| coordinates are
+  // relative to the upper-left corner of the view.
+  ///
+  /*--cef()--*/
+  virtual void SendMouseClickEvent(const CefMouseEvent& event,
+                                   MouseButtonType type,
+                                   bool mouseUp, int clickCount) =0;
+
+  ///
+  // Send a mouse move event to the browser. The |x| and |y| coordinates are
+  // relative to the upper-left corner of the view.
+  ///
+  /*--cef()--*/
+  virtual void SendMouseMoveEvent(const CefMouseEvent& event,
+                                  bool mouseLeave) =0;
+
+  ///
+  // Send a mouse wheel event to the browser. The |x| and |y| coordinates are
+  // relative to the upper-left corner of the view. The |deltaX| and |deltaY|
+  // values represent the movement delta in the X and Y directions respectively.
+  // In order to scroll inside select popups with window rendering disabled
+  // CefRenderHandler::GetScreenPoint should be implemented properly.
+  ///
+  /*--cef()--*/
+  virtual void SendMouseWheelEvent(const CefMouseEvent& event,
+                                   int deltaX, int deltaY) =0;
+
+  ///
+  // Send a focus event to the browser.
+  ///
+  /*--cef()--*/
+  virtual void SendFocusEvent(bool setFocus) =0;
+
+  ///
+  // Send a capture lost event to the browser.
+  ///
+  /*--cef()--*/
+  virtual void SendCaptureLostEvent() =0;
+
+  ///
+  // Notify the browser that the window hosting it is about to be moved or
+  // resized. This method is only used on Windows and Linux.
+  ///
+  /*--cef()--*/
+  virtual void NotifyMoveOrResizeStarted() =0;
+
+  ///
+  // Returns the maximum rate in frames per second (fps) that CefRenderHandler::
+  // OnPaint will be called for a windowless browser. The actual fps may be
+  // lower if the browser cannot generate frames at the requested rate. The
+  // minimum value is 1 and the maximum value is 60 (default 30). This method
+  // can only be called on the UI thread.
+  ///
+  /*--cef()--*/
+  virtual int GetWindowlessFrameRate() =0;
+
+  ///
+  // Set the maximum rate in frames per second (fps) that CefRenderHandler::
+  // OnPaint will be called for a windowless browser. The actual fps may be
+  // lower if the browser cannot generate frames at the requested rate. The
+  // minimum value is 1 and the maximum value is 60 (default 30). Can also be
+  // set at browser creation via CefBrowserSettings.windowless_frame_rate.
+  ///
+  /*--cef()--*/
+  virtual void SetWindowlessFrameRate(int frame_rate) =0;
+
+  ///
+  // Get the NSTextInputContext implementation for enabling IME on Mac when
+  // window rendering is disabled.
+  ///
+  /*--cef(default_retval=NULL)--*/
+  virtual CefTextInputContext GetNSTextInputContext() =0;
+
+  ///
+  // Handles a keyDown event prior to passing it through the NSTextInputClient
+  // machinery.
+  ///
+  /*--cef()--*/
+  virtual void HandleKeyEventBeforeTextInputClient(CefEventHandle keyEvent) =0;
+
+  ///
+  // Performs any additional actions after NSTextInputClient handles the event.
+  ///
+  /*--cef()--*/
+  virtual void HandleKeyEventAfterTextInputClient(CefEventHandle keyEvent) =0;
+
+  ///
+  // Call this method when the user drags the mouse into the web view (before
+  // calling DragTargetDragOver/DragTargetLeave/DragTargetDrop).
+  // |drag_data| should not contain file contents as this type of data is not
+  // allowed to be dragged into the web view. File contents can be removed using
+  // CefDragData::ResetFileContents (for example, if |drag_data| comes from
+  // CefRenderHandler::StartDragging).
+  // This method is only used when window rendering is disabled.
+  ///
+  /*--cef()--*/
+  virtual void DragTargetDragEnter(CefRefPtr<CefDragData> drag_data,
+                                  const CefMouseEvent& event,
+                                  DragOperationsMask allowed_ops) =0;
+
+  ///
+  // Call this method each time the mouse is moved across the web view during
+  // a drag operation (after calling DragTargetDragEnter and before calling
+  // DragTargetDragLeave/DragTargetDrop).
+  // This method is only used when window rendering is disabled.
+  ///
+  /*--cef()--*/
+  virtual void DragTargetDragOver(const CefMouseEvent& event,
+                                  DragOperationsMask allowed_ops) =0;
+
+  ///
+  // Call this method when the user drags the mouse out of the web view (after
+  // calling DragTargetDragEnter).
+  // This method is only used when window rendering is disabled.
+  ///
+  /*--cef()--*/
+  virtual void DragTargetDragLeave() =0;
+
+  ///
+  // Call this method when the user completes the drag operation by dropping
+  // the object onto the web view (after calling DragTargetDragEnter).
+  // The object being dropped is |drag_data|, given as an argument to
+  // the previous DragTargetDragEnter call.
+  // This method is only used when window rendering is disabled.
+  ///
+  /*--cef()--*/
+  virtual void DragTargetDrop(const CefMouseEvent& event) =0;
+
+  ///
+  // Call this method when the drag operation started by a
+  // CefRenderHandler::StartDragging call has ended either in a drop or
+  // by being cancelled. |x| and |y| are mouse coordinates relative to the
+  // upper-left corner of the view. If the web view is both the drag source
+  // and the drag target then all DragTarget* methods should be called before
+  // DragSource* mthods.
+  // This method is only used when window rendering is disabled.
+  ///
+  /*--cef()--*/
+  virtual void DragSourceEndedAt(int x, int y, DragOperationsMask op) =0;
+
+  ///
+  // Call this method when the drag operation started by a
+  // CefRenderHandler::StartDragging call has completed. This method may be
+  // called immediately without first calling DragSourceEndedAt to cancel a
+  // drag operation. If the web view is both the drag source and the drag
+  // target then all DragTarget* methods should be called before DragSource*
+  // mthods.
+  // This method is only used when window rendering is disabled.
+  ///
+  /*--cef()--*/
+  virtual void DragSourceSystemDragEnded() =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_BROWSER_H_
diff --git a/src/include/libcef_/cef_browser_process_handler.h b/src/include/libcef_/cef_browser_process_handler.h
new file mode 100644
index 0000000..185325f
--- /dev/null
+++ b/src/include/libcef_/cef_browser_process_handler.h
@@ -0,0 +1,92 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_BROWSER_PROCESS_HANDLER_H_
+#define CEF_INCLUDE_CEF_BROWSER_PROCESS_HANDLER_H_
+#pragma once
+
+#include"libcef/cef_base.h"
+#include"libcef/cef_command_line.h"
+#include"libcef/cef_print_handler.h"
+#include"libcef/cef_values.h"
+
+///
+// Class used to implement browser process callbacks. The methods of this class
+// will be called on the browser process main thread unless otherwise indicated.
+///
+/*--cef(source=client)--*/
+class CefBrowserProcessHandler : public virtual CefBase 
+{
+     public:
+      ///
+      // Called on the browser process UI thread immediately after the CEF context
+      // has been initialized.
+      ///
+      /*--cef()--*/
+      virtual void OnContextInitialized() {}
+
+      ///
+      // Called before a child process is launched. Will be called on the browser
+      // process UI thread when launching a render process and on the browser
+      // process IO thread when launching a GPU or plugin process. Provides an
+      // opportunity to modify the child process command line. Do not keep a
+      // reference to |command_line| outside of this method.
+      ///
+      /*--cef()--*/
+      virtual void OnBeforeChildProcessLaunch(CefRefPtr<CefCommandLine> command_line) {}
+
+      ///
+      // Called on the browser process IO thread after the main thread has been
+      // created for a new render process. Provides an opportunity to specify extra
+      // information that will be passed to
+      // CefRenderProcessHandler::OnRenderThreadCreated() in the render process. Do
+      // not keep a reference to |extra_info| outside of this method.
+      ///
+      /*--cef()--*/
+      virtual void OnRenderProcessThreadCreated(CefRefPtr<CefListValue> extra_info) {}
+
+      ///
+      // Return the handler for printing on Linux. If a print handler is not
+      // provided then printing will not be supported on the Linux platform.
+      ///
+      /*--cef()--*/
+      virtual CefRefPtr<CefPrintHandler> GetPrintHandler() 
+      {
+        return NULL;
+      }
+};
+
+#endif  // CEF_INCLUDE_CEF_BROWSER_PROCESS_HANDLER_H_
diff --git a/src/include/libcef_/cef_callback.h b/src/include/libcef_/cef_callback.h
new file mode 100644
index 0000000..24b75c7
--- /dev/null
+++ b/src/include/libcef_/cef_callback.h
@@ -0,0 +1,75 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_CALLBACK_H_
+#define CEF_INCLUDE_CEF_CALLBACK_H_
+#pragma once
+
+#include"libcef/cef_base.h"
+
+///
+// Generic callback interface used for asynchronous continuation.
+///
+/*--cef(source=library)--*/
+class CefCallback : public virtual CefBase {
+ public:
+  ///
+  // Continue processing.
+  ///
+  /*--cef(capi_name=cont)--*/
+  virtual void Continue() =0;
+
+  ///
+  // Cancel processing.
+  ///
+  /*--cef()--*/
+  virtual void Cancel() =0;
+};
+
+///
+// Generic callback interface used for asynchronous completion.
+///
+/*--cef(source=client)--*/
+class CefCompletionCallback : public virtual CefBase {
+ public:
+  ///
+  // Method that will be called once the task is complete.
+  ///
+  /*--cef()--*/
+  virtual void OnComplete() =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_CALLBACK_H_
diff --git a/src/include/libcef_/cef_client.h b/src/include/libcef_/cef_client.h
new file mode 100644
index 0000000..7242646
--- /dev/null
+++ b/src/include/libcef_/cef_client.h
@@ -0,0 +1,194 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_CLIENT_H_
+#define CEF_INCLUDE_CEF_CLIENT_H_
+#pragma once
+
+#include"libcef/cef_base.h"
+#include"libcef/cef_context_menu_handler.h"
+#include"libcef/cef_dialog_handler.h"
+#include"libcef/cef_display_handler.h"
+#include"libcef/cef_download_handler.h"
+#include"libcef/cef_drag_handler.h"
+#include"libcef/cef_find_handler.h"
+#include"libcef/cef_focus_handler.h"
+#include"libcef/cef_geolocation_handler.h"
+#include"libcef/cef_jsdialog_handler.h"
+#include"libcef/cef_keyboard_handler.h"
+#include"libcef/cef_life_span_handler.h"
+#include"libcef/cef_load_handler.h"
+#include"libcef/cef_process_message.h"
+#include"libcef/cef_render_handler.h"
+#include"libcef/cef_request_handler.h"
+
+///
+// Implement this interface to provide handler implementations.
+///
+/*--cef(source=client,no_debugct_check)--*/
+class CefClient : public virtual CefBase {
+ public:
+  ///
+  // Return the handler for context menus. If no handler is provided the default
+  // implementation will be used.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefContextMenuHandler> GetContextMenuHandler() {
+    return NULL;
+  }
+
+  ///
+  // Return the handler for dialogs. If no handler is provided the default
+  // implementation will be used.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefDialogHandler> GetDialogHandler() {
+    return NULL;
+  }
+
+  ///
+  // Return the handler for browser display state events.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefDisplayHandler> GetDisplayHandler() {
+    return NULL;
+  }
+
+  ///
+  // Return the handler for download events. If no handler is returned downloads
+  // will not be allowed.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefDownloadHandler> GetDownloadHandler() {
+    return NULL;
+  }
+
+  ///
+  // Return the handler for drag events.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefDragHandler> GetDragHandler() {
+    return NULL;
+  }
+
+  ///
+  // Return the handler for find result events.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefFindHandler> GetFindHandler() {
+    return NULL;
+  }
+
+  ///
+  // Return the handler for focus events.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefFocusHandler> GetFocusHandler() {
+    return NULL;
+  }
+
+  ///
+  // Return the handler for geolocation permissions requests. If no handler is
+  // provided geolocation access will be denied by default.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefGeolocationHandler> GetGeolocationHandler() {
+    return NULL;
+  }
+
+  ///
+  // Return the handler for JavaScript dialogs. If no handler is provided the
+  // default implementation will be used.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefJSDialogHandler> GetJSDialogHandler() {
+    return NULL;
+  }
+
+  ///
+  // Return the handler for keyboard events.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefKeyboardHandler> GetKeyboardHandler() {
+    return NULL;
+  }
+
+  ///
+  // Return the handler for browser life span events.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefLifeSpanHandler> GetLifeSpanHandler() {
+    return NULL;
+  }
+
+  ///
+  // Return the handler for browser load status events.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefLoadHandler> GetLoadHandler() {
+    return NULL;
+  }
+
+  ///
+  // Return the handler for off-screen rendering events.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefRenderHandler> GetRenderHandler() {
+    return NULL;
+  }
+
+  ///
+  // Return the handler for browser request events.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefRequestHandler> GetRequestHandler() {
+    return NULL;
+  }
+
+  ///
+  // Called when a new message is received from a different process. Return true
+  // if the message was handled or false otherwise. Do not keep a reference to
+  // or attempt to access the message outside of this callback.
+  ///
+  /*--cef()--*/
+  virtual bool OnProcessMessageReceived(CefRefPtr<CefBrowser> browser,
+                                        CefProcessId source_process,
+                                        CefRefPtr<CefProcessMessage> message) {
+    return false;
+  }
+};
+
+#endif  // CEF_INCLUDE_CEF_CLIENT_H_
diff --git a/src/include/libcef_/cef_command_line.h b/src/include/libcef_/cef_command_line.h
new file mode 100644
index 0000000..e7eb2c9
--- /dev/null
+++ b/src/include/libcef_/cef_command_line.h
@@ -0,0 +1,208 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_COMMAND_LINE_H_
+#define CEF_INCLUDE_CEF_COMMAND_LINE_H_
+#pragma once
+
+#include"libcef/cef_base.h"
+#include<map>
+#include<vector>
+
+///
+// Class used to create and/or parse command line arguments. Arguments with
+// '--', '-' and, on Windows, '/' prefixes are considered switches. Switches
+// will always precede any arguments without switch prefixes. Switches can
+// optionally have a value specified using the '=' delimiter (e.g.
+// "-switch=value"). An argument of "--" will terminate switch parsing with all
+// subsequent tokens, regardless of prefix, being interpreted as non-switch
+// arguments. Switch names are considered case-insensitive. This class can be
+// used before CefInitialize() is called.
+///
+/*--cef(source=library,no_debugct_check)--*/
+class CefCommandLine : public virtual CefBase {
+ public:
+  typedef std::vector<CefString> ArgumentList;
+  typedef std::map<CefString, CefString> SwitchMap;
+
+  ///
+  // Create a new CefCommandLine instance.
+  ///
+  /*--cef(api_hash_check)--*/
+  static CefRefPtr<CefCommandLine> CreateCommandLine();
+
+  ///
+  // Returns the singleton global CefCommandLine object. The returned object
+  // will be read-only.
+  ///
+  /*--cef(api_hash_check)--*/
+  static CefRefPtr<CefCommandLine> GetGlobalCommandLine();
+
+  ///
+  // Returns true if this object is valid. Do not call any other methods if this
+  // function returns false.
+  ///
+  /*--cef()--*/
+  virtual bool IsValid() =0;
+
+  ///
+  // Returns true if the values of this object are read-only. Some APIs may
+  // expose read-only objects.
+  ///
+  /*--cef()--*/
+  virtual bool IsReadOnly() =0;
+
+  ///
+  // Returns a writable copy of this object.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefCommandLine> Copy() =0;
+
+  ///
+  // Initialize the command line with the specified |argc| and |argv| values.
+  // The first argument must be the name of the program. This method is only
+  // supported on non-Windows platforms.
+  ///
+  /*--cef()--*/
+  virtual void InitFromArgv(int argc, const char* const* argv) =0;
+
+  ///
+  // Initialize the command line with the string returned by calling
+  // GetCommandLineW(). This method is only supported on Windows.
+  ///
+  /*--cef()--*/
+  virtual void InitFromString(const CefString& command_line) =0;
+
+  ///
+  // Reset the command-line switches and arguments but leave the program
+  // component unchanged.
+  ///
+  /*--cef()--*/
+  virtual void Reset() =0;
+
+  ///
+  // Retrieve the original command line string as a vector of strings.
+  // The argv array: { program, [(--|-|/)switch[=value]]*, [--], [argument]* }
+  ///
+  /*--cef()--*/
+  virtual void GetArgv(std::vector<CefString>& argv) =0;
+
+  ///
+  // Constructs and returns the represented command line string. Use this method
+  // cautiously because quoting behavior is unclear.
+  ///
+  /*--cef()--*/
+  virtual CefString GetCommandLineString() =0;
+
+  ///
+  // Get the program part of the command line string (the first item).
+  ///
+  /*--cef()--*/
+  virtual CefString GetProgram() =0;
+
+  ///
+  // Set the program part of the command line string (the first item).
+  ///
+  /*--cef()--*/
+  virtual void SetProgram(const CefString& program) =0;
+
+  ///
+  // Returns true if the command line has switches.
+  ///
+  /*--cef()--*/
+  virtual bool HasSwitches() =0;
+
+  ///
+  // Returns true if the command line contains the given switch.
+  ///
+  /*--cef()--*/
+  virtual bool HasSwitch(const CefString& name) =0;
+
+  ///
+  // Returns the value associated with the given switch. If the switch has no
+  // value or isn't present this method returns the empty string.
+  ///
+  /*--cef()--*/
+  virtual CefString GetSwitchValue(const CefString& name) =0;
+
+  ///
+  // Returns the map of switch names and values. If a switch has no value an
+  // empty string is returned.
+  ///
+  /*--cef()--*/
+  virtual void GetSwitches(SwitchMap& switches) =0;
+
+  ///
+  // Add a switch to the end of the command line. If the switch has no value
+  // pass an empty value string.
+  ///
+  /*--cef()--*/
+  virtual void AppendSwitch(const CefString& name) =0;
+
+  ///
+  // Add a switch with the specified value to the end of the command line.
+  ///
+  /*--cef()--*/
+  virtual void AppendSwitchWithValue(const CefString& name,
+                                     const CefString& value) =0;
+
+  ///
+  // True if there are remaining command line arguments.
+  ///
+  /*--cef()--*/
+  virtual bool HasArguments() =0;
+
+  ///
+  // Get the remaining command line arguments.
+  ///
+  /*--cef()--*/
+  virtual void GetArguments(ArgumentList& arguments) =0;
+
+  ///
+  // Add an argument to the end of the command line.
+  ///
+  /*--cef()--*/
+  virtual void AppendArgument(const CefString& argument) =0;
+
+  ///
+  // Insert a command before the current command.
+  // Common for debuggers, like "valgrind" or "gdb --args".
+  ///
+  /*--cef()--*/
+  virtual void PrependWrapper(const CefString& wrapper) =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_COMMAND_LINE_H_
diff --git a/src/include/libcef_/cef_context_menu_handler.h b/src/include/libcef_/cef_context_menu_handler.h
new file mode 100644
index 0000000..0d2e99a
--- /dev/null
+++ b/src/include/libcef_/cef_context_menu_handler.h
@@ -0,0 +1,285 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_CONTEXT_MENU_HANDLER_H_
+#define CEF_INCLUDE_CEF_CONTEXT_MENU_HANDLER_H_
+#pragma once
+
+#include"libcef/cef_base.h"
+#include"libcef/cef_browser.h"
+#include"libcef/cef_frame.h"
+#include"libcef/cef_menu_model.h"
+
+class CefContextMenuParams;
+
+
+///
+// Callback interface used for continuation of custom context menu display.
+///
+/*--cef(source=library)--*/
+class CefRunContextMenuCallback : public virtual CefBase {
+ public:
+  typedef cef_event_flags_t EventFlags;
+
+  ///
+  // Complete context menu display by selecting the specified |command_id| and
+  // |event_flags|.
+  ///
+  /*--cef(capi_name=cont)--*/
+  virtual void Continue(int command_id, EventFlags event_flags) =0;
+
+  ///
+  // Cancel context menu display.
+  ///
+  /*--cef()--*/
+  virtual void Cancel() =0;
+};
+
+
+///
+// Implement this interface to handle context menu events. The methods of this
+// class will be called on the UI thread.
+///
+/*--cef(source=client)--*/
+class CefContextMenuHandler : public virtual CefBase {
+ public:
+  typedef cef_event_flags_t EventFlags;
+
+  ///
+  // Called before a context menu is displayed. |params| provides information
+  // about the context menu state. |model| initially contains the default
+  // context menu. The |model| can be cleared to show no context menu or
+  // modified to show a custom menu. Do not keep references to |params| or
+  // |model| outside of this callback.
+  ///
+  /*--cef()--*/
+  virtual void OnBeforeContextMenu(CefRefPtr<CefBrowser> browser,
+                                   CefRefPtr<CefFrame> frame,
+                                   CefRefPtr<CefContextMenuParams> params,
+                                   CefRefPtr<CefMenuModel> model) {}
+
+  ///
+  // Called to allow custom display of the context menu. |params| provides
+  // information about the context menu state. |model| contains the context menu
+  // model resulting from OnBeforeContextMenu. For custom display return true
+  // and execute |callback| either synchronously or asynchronously with the
+  // selected command ID. For default display return false. Do not keep
+  // references to |params| or |model| outside of this callback.
+  ///
+  /*--cef()--*/
+  virtual bool RunContextMenu(CefRefPtr<CefBrowser> browser,
+                              CefRefPtr<CefFrame> frame,
+                              CefRefPtr<CefContextMenuParams> params,
+                              CefRefPtr<CefMenuModel> model,
+                              CefRefPtr<CefRunContextMenuCallback> callback) {
+    return false;
+  }
+
+  ///
+  // Called to execute a command selected from the context menu. Return true if
+  // the command was handled or false for the default implementation. See
+  // cef_menu_id_t for the command ids that have default implementations. All
+  // user-defined command ids should be between MENU_ID_USER_FIRST and
+  // MENU_ID_USER_LAST. |params| will have the same values as what was passed to
+  // OnBeforeContextMenu(). Do not keep a reference to |params| outside of this
+  // callback.
+  ///
+  /*--cef()--*/
+  virtual bool OnContextMenuCommand(CefRefPtr<CefBrowser> browser,
+                                    CefRefPtr<CefFrame> frame,
+                                    CefRefPtr<CefContextMenuParams> params,
+                                    int command_id,
+                                    EventFlags event_flags) { return false; }
+
+  ///
+  // Called when the context menu is dismissed irregardless of whether the menu
+  // was empty or a command was selected.
+  ///
+  /*--cef()--*/
+  virtual void OnContextMenuDismissed(CefRefPtr<CefBrowser> browser,
+                                      CefRefPtr<CefFrame> frame) {}
+};
+
+
+///
+// Provides information about the context menu state. The ethods of this class
+// can only be accessed on browser process the UI thread.
+///
+/*--cef(source=library)--*/
+class CefContextMenuParams : public virtual CefBase {
+ public:
+  typedef cef_context_menu_type_flags_t TypeFlags;
+  typedef cef_context_menu_media_type_t MediaType;
+  typedef cef_context_menu_media_state_flags_t MediaStateFlags;
+  typedef cef_context_menu_edit_state_flags_t EditStateFlags;
+
+  ///
+  // Returns the X coordinate of the mouse where the context menu was invoked.
+  // Coords are relative to the associated RenderView's origin.
+  ///
+  /*--cef()--*/
+  virtual int GetXCoord() =0;
+
+  ///
+  // Returns the Y coordinate of the mouse where the context menu was invoked.
+  // Coords are relative to the associated RenderView's origin.
+  ///
+  /*--cef()--*/
+  virtual int GetYCoord() =0;
+
+  ///
+  // Returns flags representing the type of node that the context menu was
+  // invoked on.
+  ///
+  /*--cef(default_retval=CM_TYPEFLAG_NONE)--*/
+  virtual TypeFlags GetTypeFlags() =0;
+
+  ///
+  // Returns the URL of the link, if any, that encloses the node that the
+  // context menu was invoked on.
+  ///
+  /*--cef()--*/
+  virtual CefString GetLinkUrl() =0;
+
+  ///
+  // Returns the link URL, if any, to be used ONLY for "copy link address". We
+  // don't validate this field in the frontend process.
+  ///
+  /*--cef()--*/
+  virtual CefString GetUnfilteredLinkUrl() =0;
+
+  ///
+  // Returns the source URL, if any, for the element that the context menu was
+  // invoked on. Example of elements with source URLs are img, audio, and video.
+  ///
+  /*--cef()--*/
+  virtual CefString GetSourceUrl() =0;
+
+  ///
+  // Returns true if the context menu was invoked on an image which has
+  // non-empty contents.
+  ///
+  /*--cef()--*/
+  virtual bool HasImageContents() =0;
+
+  ///
+  // Returns the URL of the top level page that the context menu was invoked on.
+  ///
+  /*--cef()--*/
+  virtual CefString GetPageUrl() =0;
+
+  ///
+  // Returns the URL of the subframe that the context menu was invoked on.
+  ///
+  /*--cef()--*/
+  virtual CefString GetFrameUrl() =0;
+
+  ///
+  // Returns the character encoding of the subframe that the context menu was
+  // invoked on.
+  ///
+  /*--cef()--*/
+  virtual CefString GetFrameCharset() =0;
+
+  ///
+  // Returns the type of context node that the context menu was invoked on.
+  ///
+  /*--cef(default_retval=CM_MEDIATYPE_NONE)--*/
+  virtual MediaType GetMediaType() =0;
+
+  ///
+  // Returns flags representing the actions supported by the media element, if
+  // any, that the context menu was invoked on.
+  ///
+  /*--cef(default_retval=CM_MEDIAFLAG_NONE)--*/
+  virtual MediaStateFlags GetMediaStateFlags() =0;
+
+  ///
+  // Returns the text of the selection, if any, that the context menu was
+  // invoked on.
+  ///
+  /*--cef()--*/
+  virtual CefString GetSelectionText() =0;
+
+  ///
+  // Returns the text of the misspelled word, if any, that the context menu was
+  // invoked on.
+  ///
+  /*--cef()--*/
+  virtual CefString GetMisspelledWord() =0;
+
+  ///
+  // Returns true if suggestions exist, false otherwise. Fills in |suggestions|
+  // from the spell check service for the misspelled word if there is one.
+  ///
+  /*--cef()--*/
+  virtual bool GetDictionarySuggestions(std::vector<CefString>& suggestions) =0;
+
+  ///
+  // Returns true if the context menu was invoked on an editable node.
+  ///
+  /*--cef()--*/
+  virtual bool IsEditable() =0;
+
+  ///
+  // Returns true if the context menu was invoked on an editable node where
+  // spell-check is enabled.
+  ///
+  /*--cef()--*/
+  virtual bool IsSpellCheckEnabled() =0;
+
+  ///
+  // Returns flags representing the actions supported by the editable node, if
+  // any, that the context menu was invoked on.
+  ///
+  /*--cef(default_retval=CM_EDITFLAG_NONE)--*/
+  virtual EditStateFlags GetEditStateFlags() =0;
+
+  ///
+  // Returns true if the context menu contains items specified by the renderer
+  // process (for example, plugin placeholder or pepper plugin menu items).
+  ///
+  /*--cef()--*/
+  virtual bool IsCustomMenu() =0;
+
+  ///
+  // Returns true if the context menu was invoked from a pepper plugin.
+  ///
+  /*--cef()--*/
+  virtual bool IsPepperMenu() =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_CONTEXT_MENU_HANDLER_H_
diff --git a/src/include/libcef_/cef_cookie.h b/src/include/libcef_/cef_cookie.h
new file mode 100644
index 0000000..9853996
--- /dev/null
+++ b/src/include/libcef_/cef_cookie.h
@@ -0,0 +1,220 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_COOKIE_H_
+#define CEF_INCLUDE_CEF_COOKIE_H_
+#pragma once
+
+#include"libcef/cef_base.h"
+#include"libcef/cef_callback.h"
+#include<vector>
+
+class CefCookieVisitor;
+class CefSetCookieCallback;
+class CefDeleteCookiesCallback;
+
+///
+// Class used for managing cookies. The methods of this class may be called on
+// any thread unless otherwise indicated.
+///
+/*--cef(source=library,no_debugct_check)--*/
+class CefCookieManager : public virtual CefBase {
+ public:
+  ///
+  // Returns the global cookie manager. By default data will be stored at
+  // CefSettings.cache_path if specified or in memory otherwise. If |callback|
+  // is non-NULL it will be executed asnychronously on the IO thread after the
+  // manager's storage has been initialized. Using this method is equivalent to
+  // calling CefRequestContext::GetGlobalContext()->GetDefaultCookieManager().
+  ///
+  /*--cef(optional_param=callback)--*/
+  static CefRefPtr<CefCookieManager> GetGlobalManager(
+      CefRefPtr<CefCompletionCallback> callback);
+
+  ///
+  // Creates a new cookie manager. If |path| is empty data will be stored in
+  // memory only. Otherwise, data will be stored at the specified |path|. To
+  // persist session cookies (cookies without an expiry date or validity
+  // interval) set |persist_session_cookies| to true. Session cookies are
+  // generally intended to be transient and most Web browsers do not persist
+  // them. If |callback| is non-NULL it will be executed asnychronously on the
+  // IO thread after the manager's storage has been initialized.
+  ///
+  /*--cef(optional_param=path,optional_param=callback)--*/
+  static CefRefPtr<CefCookieManager> CreateManager(
+      const CefString& path,
+      bool persist_session_cookies,
+      CefRefPtr<CefCompletionCallback> callback);
+
+  ///
+  // Set the schemes supported by this manager. The default schemes ("http",
+  // "https", "ws" and "wss") will always be supported. If |callback| is non-
+  // NULL it will be executed asnychronously on the IO thread after the change
+  // has been applied. Must be called before any cookies are accessed.
+  ///
+  /*--cef(optional_param=callback)--*/
+  virtual void SetSupportedSchemes(
+      const std::vector<CefString>& schemes,
+      CefRefPtr<CefCompletionCallback> callback) =0;
+
+  ///
+  // Visit all cookies on the IO thread. The returned cookies are ordered by
+  // longest path, then by earliest creation date. Returns false if cookies
+  // cannot be accessed.
+  ///
+  /*--cef()--*/
+  virtual bool VisitAllCookies(CefRefPtr<CefCookieVisitor> visitor) =0;
+
+  ///
+  // Visit a subset of cookies on the IO thread. The results are filtered by the
+  // given url scheme, host, domain and path. If |includeHttpOnly| is true
+  // HTTP-only cookies will also be included in the results. The returned
+  // cookies are ordered by longest path, then by earliest creation date.
+  // Returns false if cookies cannot be accessed.
+  ///
+  /*--cef()--*/
+  virtual bool VisitUrlCookies(const CefString& url,
+                               bool includeHttpOnly,
+                               CefRefPtr<CefCookieVisitor> visitor) =0;
+
+  ///
+  // Sets a cookie given a valid URL and explicit user-provided cookie
+  // attributes. This function expects each attribute to be well-formed. It will
+  // check for disallowed characters (e.g. the ';' character is disallowed
+  // within the cookie value attribute) and fail without setting the cookie if
+  // such characters are found. If |callback| is non-NULL it will be executed
+  // asnychronously on the IO thread after the cookie has been set. Returns
+  // false if an invalid URL is specified or if cookies cannot be accessed.
+  ///
+  /*--cef(optional_param=callback)--*/
+  virtual bool SetCookie(const CefString& url,
+                         const CefCookie& cookie,
+                         CefRefPtr<CefSetCookieCallback> callback) =0;
+
+  ///
+  // Delete all cookies that match the specified parameters. If both |url| and
+  // |cookie_name| values are specified all host and domain cookies matching
+  // both will be deleted. If only |url| is specified all host cookies (but not
+  // domain cookies) irrespective of path will be deleted. If |url| is empty all
+  // cookies for all hosts and domains will be deleted. If |callback| is
+  // non-NULL it will be executed asnychronously on the IO thread after the
+  // cookies have been deleted. Returns false if a non-empty invalid URL is
+  // specified or if cookies cannot be accessed. Cookies can alternately be
+  // deleted using the Visit*Cookies() methods.
+  ///
+  /*--cef(optional_param=url,optional_param=cookie_name,
+          optional_param=callback)--*/
+  virtual bool DeleteCookies(const CefString& url,
+                             const CefString& cookie_name,
+                             CefRefPtr<CefDeleteCookiesCallback> callback) =0;
+
+  ///
+  // Sets the directory path that will be used for storing cookie data. If
+  // |path| is empty data will be stored in memory only. Otherwise, data will be
+  // stored at the specified |path|. To persist session cookies (cookies without
+  // an expiry date or validity interval) set |persist_session_cookies| to true.
+  // Session cookies are generally intended to be transient and most Web
+  // browsers do not persist them. If |callback| is non-NULL it will be executed
+  // asnychronously on the IO thread after the manager's storage has been
+  // initialized. Returns false if cookies cannot be accessed.
+  ///
+  /*--cef(optional_param=path,optional_param=callback)--*/
+  virtual bool SetStoragePath(const CefString& path,
+                              bool persist_session_cookies,
+                              CefRefPtr<CefCompletionCallback> callback) =0;
+
+  ///
+  // Flush the backing store (if any) to disk. If |callback| is non-NULL it will
+  // be executed asnychronously on the IO thread after the flush is complete.
+  // Returns false if cookies cannot be accessed.
+  ///
+  /*--cef(optional_param=callback)--*/
+  virtual bool FlushStore(CefRefPtr<CefCompletionCallback> callback) =0;
+};
+
+
+///
+// Interface to implement for visiting cookie values. The methods of this class
+// will always be called on the IO thread.
+///
+/*--cef(source=client)--*/
+class CefCookieVisitor : public virtual CefBase {
+ public:
+  ///
+  // Method that will be called once for each cookie. |count| is the 0-based
+  // index for the current cookie. |total| is the total number of cookies.
+  // Set |deleteCookie| to true to delete the cookie currently being visited.
+  // Return false to stop visiting cookies. This method may never be called if
+  // no cookies are found.
+  ///
+  /*--cef()--*/
+  virtual bool Visit(const CefCookie& cookie, int count, int total,
+                     bool& deleteCookie) =0;
+};
+
+
+///
+// Interface to implement to be notified of asynchronous completion via
+// CefCookieManager::SetCookie().
+///
+/*--cef(source=client)--*/
+class CefSetCookieCallback : public virtual CefBase {
+ public:
+  ///
+  // Method that will be called upon completion. |success| will be true if the
+  // cookie was set successfully.
+  ///
+  /*--cef()--*/
+  virtual void OnComplete(bool success) =0;
+};
+
+
+///
+// Interface to implement to be notified of asynchronous completion via
+// CefCookieManager::DeleteCookies().
+///
+/*--cef(source=client)--*/
+class CefDeleteCookiesCallback : public virtual CefBase {
+ public:
+  ///
+  // Method that will be called upon completion. |num_deleted| will be the
+  // number of cookies that were deleted or -1 if unknown.
+  ///
+  /*--cef()--*/
+  virtual void OnComplete(int num_deleted) =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_COOKIE_H_
diff --git a/src/include/libcef_/cef_dialog_handler.h b/src/include/libcef_/cef_dialog_handler.h
new file mode 100644
index 0000000..b8d5a8e
--- /dev/null
+++ b/src/include/libcef_/cef_dialog_handler.h
@@ -0,0 +1,107 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_DIALOG_HANDLER_H_
+#define CEF_INCLUDE_CEF_DIALOG_HANDLER_H_
+#pragma once
+
+#include"libcef/cef_base.h"
+#include"libcef/cef_browser.h"
+
+///
+// Callback interface for asynchronous continuation of file dialog requests.
+///
+/*--cef(source=library)--*/
+class CefFileDialogCallback : public virtual CefBase {
+ public:
+  ///
+  // Continue the file selection. |selected_accept_filter| should be the 0-based
+  // index of the value selected from the accept filters array passed to
+  // CefDialogHandler::OnFileDialog. |file_paths| should be a single value or a
+  // list of values depending on the dialog mode. An empty |file_paths| value is
+  // treated the same as calling Cancel().
+  ///
+  /*--cef(capi_name=cont,index_param=selected_accept_filter,
+          optional_param=file_paths)--*/
+  virtual void Continue(int selected_accept_filter,
+                        const std::vector<CefString>& file_paths) =0;
+
+  ///
+  // Cancel the file selection.
+  ///
+  /*--cef()--*/
+  virtual void Cancel() =0;
+};
+
+
+///
+// Implement this interface to handle dialog events. The methods of this class
+// will be called on the browser process UI thread.
+///
+/*--cef(source=client)--*/
+class CefDialogHandler : public virtual CefBase {
+ public:
+  typedef cef_file_dialog_mode_t FileDialogMode;
+
+  ///
+  // Called to run a file chooser dialog. |mode| represents the type of dialog
+  // to display. |title| to the title to be used for the dialog and may be empty
+  // to show the default title ("Open" or "Save" depending on the mode).
+  // |default_file_path| is the path with optional directory and/or file name
+  // component that should be initially selected in the dialog. |accept_filters|
+  // are used to restrict the selectable file types and may any combination of
+  // (a) valid lower-cased MIME types (e.g. "text/*" or "image/*"),
+  // (b) individual file extensions (e.g. ".txt" or ".png"), or (c) combined
+  // description and file extension delimited using "|" and ";" (e.g.
+  // "Image Types|.png;.gif;.jpg"). |selected_accept_filter| is the 0-based
+  // index of the filter that should be selected by default. To display a custom
+  // dialog return true and execute |callback| either inline or at a later time.
+  // To display the default dialog return false.
+  ///
+  /*--cef(optional_param=title,optional_param=default_file_path,
+          optional_param=accept_filters,index_param=selected_accept_filter)--*/
+  virtual bool OnFileDialog(CefRefPtr<CefBrowser> browser,
+                            FileDialogMode mode,
+                            const CefString& title,
+                            const CefString& default_file_path,
+                            const std::vector<CefString>& accept_filters,
+                            int selected_accept_filter,
+                            CefRefPtr<CefFileDialogCallback> callback) {
+    return false;
+  }
+};
+
+#endif  // CEF_INCLUDE_CEF_DIALOG_HANDLER_H_
diff --git a/src/include/libcef_/cef_display_handler.h b/src/include/libcef_/cef_display_handler.h
new file mode 100644
index 0000000..e4470c1
--- /dev/null
+++ b/src/include/libcef_/cef_display_handler.h
@@ -0,0 +1,116 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_DISPLAY_HANDLER_H_
+#define CEF_INCLUDE_CEF_DISPLAY_HANDLER_H_
+#pragma once
+
+#include"libcef/cef_base.h"
+#include"libcef/cef_browser.h"
+#include"libcef/cef_frame.h"
+
+///
+// Implement this interface to handle events related to browser display state.
+// The methods of this class will be called on the UI thread.
+///
+/*--cef(source=client)--*/
+class CefDisplayHandler : public virtual CefBase {
+ public:
+  ///
+  // Called when a frame's address has changed.
+  ///
+  /*--cef()--*/
+  virtual void OnAddressChange(CefRefPtr<CefBrowser> browser,
+                               CefRefPtr<CefFrame> frame,
+                               const CefString& url) {}
+
+  ///
+  // Called when the page title changes.
+  ///
+  /*--cef(optional_param=title)--*/
+  virtual void OnTitleChange(CefRefPtr<CefBrowser> browser,
+                             const CefString& title) {}
+
+  ///
+  // Called when the page icon changes.
+  ///
+  /*--cef(optional_param=icon_urls)--*/
+  virtual void OnFaviconURLChange(CefRefPtr<CefBrowser> browser,
+                                  const std::vector<CefString>& icon_urls) {}
+
+  ///
+  // Called when web content in the page has toggled fullscreen mode. If
+  // |fullscreen| is true the content will automatically be sized to fill the
+  // browser content area. If |fullscreen| is false the content will
+  // automatically return to its original size and position. The client is
+  // responsible for resizing the browser if desired.
+  ///
+  /*--cef()--*/
+  virtual void OnFullscreenModeChange(CefRefPtr<CefBrowser> browser,
+                                      bool fullscreen) {}
+
+  ///
+  // Called when the browser is about to display a tooltip. |text| contains the
+  // text that will be displayed in the tooltip. To handle the display of the
+  // tooltip yourself return true. Otherwise, you can optionally modify |text|
+  // and then return false to allow the browser to display the tooltip.
+  // When window rendering is disabled the application is responsible for
+  // drawing tooltips and the return value is ignored.
+  ///
+  /*--cef(optional_param=text)--*/
+  virtual bool OnTooltip(CefRefPtr<CefBrowser> browser,
+                         CefString& text) { return false; }
+
+  ///
+  // Called when the browser receives a status message. |value| contains the
+  // text that will be displayed in the status message.
+  ///
+  /*--cef(optional_param=value)--*/
+  virtual void OnStatusMessage(CefRefPtr<CefBrowser> browser,
+                               const CefString& value) {}
+
+  ///
+  // Called to display a console message. Return true to stop the message from
+  // being output to the console.
+  ///
+  /*--cef(optional_param=message,optional_param=source)--*/
+  virtual bool OnConsoleMessage(CefRefPtr<CefBrowser> browser,
+                                const CefString& message,
+                                const CefString& source,
+                                int line) { return false; }
+};
+
+#endif  // CEF_INCLUDE_CEF_DISPLAY_HANDLER_H_
diff --git a/src/include/libcef_/cef_dom.h b/src/include/libcef_/cef_dom.h
new file mode 100644
index 0000000..6baaf18
--- /dev/null
+++ b/src/include/libcef_/cef_dom.h
@@ -0,0 +1,328 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_DOM_H_
+#define CEF_INCLUDE_CEF_DOM_H_
+#pragma once
+
+#include"libcef/cef_base.h"
+#include<map>
+
+class CefDOMDocument;
+class CefDOMNode;
+
+///
+// Interface to implement for visiting the DOM. The methods of this class will
+// be called on the render process main thread.
+///
+/*--cef(source=client)--*/
+class CefDOMVisitor : public virtual CefBase {
+ public:
+  ///
+  // Method executed for visiting the DOM. The document object passed to this
+  // method represents a snapshot of the DOM at the time this method is
+  // executed. DOM objects are only valid for the scope of this method. Do not
+  // keep references to or attempt to access any DOM objects outside the scope
+  // of this method.
+  ///
+  /*--cef()--*/
+  virtual void Visit(CefRefPtr<CefDOMDocument> document) =0;
+};
+
+
+///
+// Class used to represent a DOM document. The methods of this class should only
+// be called on the render process main thread thread.
+///
+/*--cef(source=library)--*/
+class CefDOMDocument : public virtual CefBase {
+ public:
+  typedef cef_dom_document_type_t Type;
+
+  ///
+  // Returns the document type.
+  ///
+  /*--cef(default_retval=DOM_DOCUMENT_TYPE_UNKNOWN)--*/
+  virtual Type GetType() =0;
+
+  ///
+  // Returns the root document node.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefDOMNode> GetDocument() =0;
+
+  ///
+  // Returns the BODY node of an HTML document.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefDOMNode> GetBody() =0;
+
+  ///
+  // Returns the HEAD node of an HTML document.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefDOMNode> GetHead() =0;
+
+  ///
+  // Returns the title of an HTML document.
+  ///
+  /*--cef()--*/
+  virtual CefString GetTitle() =0;
+
+  ///
+  // Returns the document element with the specified ID value.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefDOMNode> GetElementById(const CefString& id) =0;
+
+  ///
+  // Returns the node that currently has keyboard focus.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefDOMNode> GetFocusedNode() =0;
+
+  ///
+  // Returns true if a portion of the document is selected.
+  ///
+  /*--cef()--*/
+  virtual bool HasSelection() =0;
+
+  ///
+  // Returns the selection offset within the start node.
+  ///
+  /*--cef()--*/
+  virtual int GetSelectionStartOffset() =0;
+
+  ///
+  // Returns the selection offset within the end node.
+  ///
+  /*--cef()--*/
+  virtual int GetSelectionEndOffset() =0;
+
+  ///
+  // Returns the contents of this selection as markup.
+  ///
+  /*--cef()--*/
+  virtual CefString GetSelectionAsMarkup() =0;
+
+  ///
+  // Returns the contents of this selection as text.
+  ///
+  /*--cef()--*/
+  virtual CefString GetSelectionAsText() =0;
+
+  ///
+  // Returns the base URL for the document.
+  ///
+  /*--cef()--*/
+  virtual CefString GetBaseURL() =0;
+
+  ///
+  // Returns a complete URL based on the document base URL and the specified
+  // partial URL.
+  ///
+  /*--cef()--*/
+  virtual CefString GetCompleteURL(const CefString& partialURL) =0;
+};
+
+
+///
+// Class used to represent a DOM node. The methods of this class should only be
+// called on the render process main thread.
+///
+/*--cef(source=library)--*/
+class CefDOMNode : public virtual CefBase {
+ public:
+  typedef std::map<CefString, CefString> AttributeMap;
+  typedef cef_dom_node_type_t Type;
+
+  ///
+  // Returns the type for this node.
+  ///
+  /*--cef(default_retval=DOM_NODE_TYPE_UNSUPPORTED)--*/
+  virtual Type GetType() =0;
+
+  ///
+  // Returns true if this is a text node.
+  ///
+  /*--cef()--*/
+  virtual bool IsText() =0;
+
+  ///
+  // Returns true if this is an element node.
+  ///
+  /*--cef()--*/
+  virtual bool IsElement() =0;
+
+  ///
+  // Returns true if this is an editable node.
+  ///
+  /*--cef()--*/
+  virtual bool IsEditable() =0;
+
+  ///
+  // Returns true if this is a form control element node.
+  ///
+  /*--cef()--*/
+  virtual bool IsFormControlElement() =0;
+
+  ///
+  // Returns the type of this form control element node.
+  ///
+  /*--cef()--*/
+  virtual CefString GetFormControlElementType() =0;
+
+  ///
+  // Returns true if this object is pointing to the same handle as |that|
+  // object.
+  ///
+  /*--cef()--*/
+  virtual bool IsSame(CefRefPtr<CefDOMNode> that) =0;
+
+  ///
+  // Returns the name of this node.
+  ///
+  /*--cef()--*/
+  virtual CefString GetName() =0;
+
+  ///
+  // Returns the value of this node.
+  ///
+  /*--cef()--*/
+  virtual CefString GetValue() =0;
+
+  ///
+  // Set the value of this node. Returns true on success.
+  ///
+  /*--cef()--*/
+  virtual bool SetValue(const CefString& value) =0;
+
+  ///
+  // Returns the contents of this node as markup.
+  ///
+  /*--cef()--*/
+  virtual CefString GetAsMarkup() =0;
+
+  ///
+  // Returns the document associated with this node.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefDOMDocument> GetDocument() =0;
+
+  ///
+  // Returns the parent node.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefDOMNode> GetParent() =0;
+
+  ///
+  // Returns the previous sibling node.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefDOMNode> GetPreviousSibling() =0;
+
+  ///
+  // Returns the next sibling node.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefDOMNode> GetNextSibling() =0;
+
+  ///
+  // Returns true if this node has child nodes.
+  ///
+  /*--cef()--*/
+  virtual bool HasChildren() =0;
+
+  ///
+  // Return the first child node.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefDOMNode> GetFirstChild() =0;
+
+  ///
+  // Returns the last child node.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefDOMNode> GetLastChild() =0;
+
+  // The following methods are valid only for element nodes.
+
+  ///
+  // Returns the tag name of this element.
+  ///
+  /*--cef()--*/
+  virtual CefString GetElementTagName() =0;
+
+  ///
+  // Returns true if this element has attributes.
+  ///
+  /*--cef()--*/
+  virtual bool HasElementAttributes() =0;
+
+  ///
+  // Returns true if this element has an attribute named |attrName|.
+  ///
+  /*--cef()--*/
+  virtual bool HasElementAttribute(const CefString& attrName) =0;
+
+  ///
+  // Returns the element attribute named |attrName|.
+  ///
+  /*--cef()--*/
+  virtual CefString GetElementAttribute(const CefString& attrName) =0;
+
+  ///
+  // Returns a map of all element attributes.
+  ///
+  /*--cef()--*/
+  virtual void GetElementAttributes(AttributeMap& attrMap) =0;
+
+  ///
+  // Set the value for the element attribute named |attrName|. Returns true on
+  // success.
+  ///
+  /*--cef()--*/
+  virtual bool SetElementAttribute(const CefString& attrName,
+                                   const CefString& value) =0;
+
+  ///
+  // Returns the inner text of the element.
+  ///
+  /*--cef()--*/
+  virtual CefString GetElementInnerText() =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_DOM_H_
diff --git a/src/include/libcef_/cef_download_handler.h b/src/include/libcef_/cef_download_handler.h
new file mode 100644
index 0000000..f01277a
--- /dev/null
+++ b/src/include/libcef_/cef_download_handler.h
@@ -0,0 +1,124 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_DOWNLOAD_HANDLER_H_
+#define CEF_INCLUDE_CEF_DOWNLOAD_HANDLER_H_
+#pragma once
+
+#include"libcef/cef_base.h"
+#include"libcef/cef_browser.h"
+#include"libcef/cef_download_item.h"
+
+
+///
+// Callback interface used to asynchronously continue a download.
+///
+/*--cef(source=library)--*/
+class CefBeforeDownloadCallback : public virtual CefBase {
+ public:
+  ///
+  // Call to continue the download. Set |download_path| to the full file path
+  // for the download including the file name or leave blank to use the
+  // suggested name and the default temp directory. Set |show_dialog| to true
+  // if you do wish to show the default "Save As" dialog.
+  ///
+  /*--cef(capi_name=cont,optional_param=download_path)--*/
+  virtual void Continue(const CefString& download_path, bool show_dialog) =0;
+};
+
+
+///
+// Callback interface used to asynchronously cancel a download.
+///
+/*--cef(source=library)--*/
+class CefDownloadItemCallback : public virtual CefBase {
+ public:
+  ///
+  // Call to cancel the download.
+  ///
+  /*--cef()--*/
+  virtual void Cancel() =0;
+
+  ///
+  // Call to pause the download.
+  ///
+  /*--cef()--*/
+  virtual void Pause() =0;
+
+  ///
+  // Call to resume the download.
+  ///
+  /*--cef()--*/
+  virtual void Resume() =0;
+};
+
+
+///
+// Class used to handle file downloads. The methods of this class will called
+// on the browser process UI thread.
+///
+/*--cef(source=client)--*/
+class CefDownloadHandler : public virtual CefBase {
+ public:
+  ///
+  // Called before a download begins. |suggested_name| is the suggested name for
+  // the download file. By default the download will be canceled. Execute
+  // |callback| either asynchronously or in this method to continue the download
+  // if desired. Do not keep a reference to |download_item| outside of this
+  // method.
+  ///
+  /*--cef()--*/
+  virtual void OnBeforeDownload(
+      CefRefPtr<CefBrowser> browser,
+      CefRefPtr<CefDownloadItem> download_item,
+      const CefString& suggested_name,
+      CefRefPtr<CefBeforeDownloadCallback> callback) =0;
+
+  ///
+  // Called when a download's status or progress information has been updated.
+  // This may be called multiple times before and after OnBeforeDownload().
+  // Execute |callback| either asynchronously or in this method to cancel the
+  // download if desired. Do not keep a reference to |download_item| outside of
+  // this method.
+  ///
+  /*--cef()--*/
+  virtual void OnDownloadUpdated(
+      CefRefPtr<CefBrowser> browser,
+      CefRefPtr<CefDownloadItem> download_item,
+      CefRefPtr<CefDownloadItemCallback> callback) {}
+};
+
+#endif  // CEF_INCLUDE_CEF_DOWNLOAD_HANDLER_H_
diff --git a/src/include/libcef_/cef_download_item.h b/src/include/libcef_/cef_download_item.h
new file mode 100644
index 0000000..cc76929
--- /dev/null
+++ b/src/include/libcef_/cef_download_item.h
@@ -0,0 +1,154 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_DOWNLOAD_ITEM_H_
+#define CEF_INCLUDE_CEF_DOWNLOAD_ITEM_H_
+#pragma once
+
+#include"libcef/cef_base.h"
+
+///
+// Class used to represent a download item.
+///
+/*--cef(source=library)--*/
+class CefDownloadItem : public virtual CefBase {
+ public:
+  ///
+  // Returns true if this object is valid. Do not call any other methods if this
+  // function returns false.
+  ///
+  /*--cef()--*/
+  virtual bool IsValid() =0;
+
+  ///
+  // Returns true if the download is in progress.
+  ///
+  /*--cef()--*/
+  virtual bool IsInProgress() =0;
+
+  ///
+  // Returns true if the download is complete.
+  ///
+  /*--cef()--*/
+  virtual bool IsComplete() =0;
+
+  ///
+  // Returns true if the download has been canceled or interrupted.
+  ///
+  /*--cef()--*/
+  virtual bool IsCanceled() =0;
+
+  ///
+  // Returns a simple speed estimate in bytes/s.
+  ///
+  /*--cef()--*/
+  virtual int64 GetCurrentSpeed() =0;
+
+  ///
+  // Returns the rough percent complete or -1 if the receive total size is
+  // unknown.
+  ///
+  /*--cef()--*/
+  virtual int GetPercentComplete() =0;
+
+  ///
+  // Returns the total number of bytes.
+  ///
+  /*--cef()--*/
+  virtual int64 GetTotalBytes() =0;
+
+  ///
+  // Returns the number of received bytes.
+  ///
+  /*--cef()--*/
+  virtual int64 GetReceivedBytes() =0;
+
+  ///
+  // Returns the time that the download started.
+  ///
+  /*--cef()--*/
+  virtual CefTime GetStartTime() =0;
+
+  ///
+  // Returns the time that the download ended.
+  ///
+  /*--cef()--*/
+  virtual CefTime GetEndTime() =0;
+
+  ///
+  // Returns the full path to the downloaded or downloading file.
+  ///
+  /*--cef()--*/
+  virtual CefString GetFullPath() =0;
+
+  ///
+  // Returns the unique identifier for this download.
+  ///
+  /*--cef()--*/
+  virtual uint32 GetId() =0;
+
+  ///
+  // Returns the URL.
+  ///
+  /*--cef()--*/
+  virtual CefString GetURL() =0;
+
+  ///
+  // Returns the original URL before any redirections.
+  ///
+  /*--cef()--*/
+  virtual CefString GetOriginalUrl() =0;
+
+  ///
+  // Returns the suggested file name.
+  ///
+  /*--cef()--*/
+  virtual CefString GetSuggestedFileName() =0;
+
+  ///
+  // Returns the content disposition.
+  ///
+  /*--cef()--*/
+  virtual CefString GetContentDisposition() =0;
+
+  ///
+  // Returns the mime type.
+  ///
+  /*--cef()--*/
+  virtual CefString GetMimeType() =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_DOWNLOAD_ITEM_H_
diff --git a/src/include/libcef_/cef_drag_data.h b/src/include/libcef_/cef_drag_data.h
new file mode 100644
index 0000000..808c533
--- /dev/null
+++ b/src/include/libcef_/cef_drag_data.h
@@ -0,0 +1,198 @@
+// Copyright (c) 2013 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_DRAG_DATA_H_
+#define CEF_INCLUDE_CEF_DRAG_DATA_H_
+#pragma once
+
+#include"libcef/cef_base.h"
+#include"libcef/cef_stream.h"
+#include<vector>
+
+///
+// Class used to represent drag data. The methods of this class may be called
+// on any thread.
+///
+/*--cef(source=library)--*/
+class CefDragData : public virtual CefBase {
+ public:
+  ///
+  // Create a new CefDragData object.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefDragData> Create();
+
+  ///
+  // Returns a copy of the current object.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefDragData> Clone() =0;
+
+  ///
+  // Returns true if this object is read-only.
+  ///
+  /*--cef()--*/
+  virtual bool IsReadOnly() =0;
+
+  ///
+  // Returns true if the drag data is a link.
+  ///
+  /*--cef()--*/
+  virtual bool IsLink() =0;
+
+  ///
+  // Returns true if the drag data is a text or html fragment.
+  ///
+  /*--cef()--*/
+  virtual bool IsFragment() =0;
+
+  ///
+  // Returns true if the drag data is a file.
+  ///
+  /*--cef()--*/
+  virtual bool IsFile() =0;
+
+  ///
+  // Return the link URL that is being dragged.
+  ///
+  /*--cef()--*/
+  virtual CefString GetLinkURL() =0;
+
+  ///
+  // Return the title associated with the link being dragged.
+  ///
+  /*--cef()--*/
+  virtual CefString GetLinkTitle() =0;
+
+  ///
+  // Return the metadata, if any, associated with the link being dragged.
+  ///
+  /*--cef()--*/
+  virtual CefString GetLinkMetadata() =0;
+
+  ///
+  // Return the plain text fragment that is being dragged.
+  ///
+  /*--cef()--*/
+  virtual CefString GetFragmentText() =0;
+
+  ///
+  // Return the text/html fragment that is being dragged.
+  ///
+  /*--cef()--*/
+  virtual CefString GetFragmentHtml() =0;
+
+  ///
+  // Return the base URL that the fragment came from. This value is used for
+  // resolving relative URLs and may be empty.
+  ///
+  /*--cef()--*/
+  virtual CefString GetFragmentBaseURL() =0;
+
+  ///
+  // Return the name of the file being dragged out of the browser window.
+  ///
+  /*--cef()--*/
+  virtual CefString GetFileName() =0;
+
+  ///
+  // Write the contents of the file being dragged out of the web view into
+  // |writer|. Returns the number of bytes sent to |writer|. If |writer| is
+  // NULL this method will return the size of the file contents in bytes.
+  // Call GetFileName() to get a suggested name for the file.
+  ///
+  /*--cef(optional_param=writer)--*/
+  virtual size_t GetFileContents(CefRefPtr<CefStreamWriter> writer) =0;
+
+  ///
+  // Retrieve the list of file names that are being dragged into the browser
+  // window.
+  ///
+  /*--cef()--*/
+  virtual bool GetFileNames(std::vector<CefString>& names) =0;
+
+  ///
+  // Set the link URL that is being dragged.
+  ///
+  /*--cef(optional_param=url)--*/
+  virtual void SetLinkURL(const CefString& url) =0;
+
+  ///
+  // Set the title associated with the link being dragged.
+  ///
+  /*--cef(optional_param=title)--*/
+  virtual void SetLinkTitle(const CefString& title) =0;
+
+  ///
+  // Set the metadata associated with the link being dragged.
+  ///
+  /*--cef(optional_param=data)--*/
+  virtual void SetLinkMetadata(const CefString& data) =0;
+
+  ///
+  // Set the plain text fragment that is being dragged.
+  ///
+  /*--cef(optional_param=text)--*/
+  virtual void SetFragmentText(const CefString& text) =0;
+
+  ///
+  // Set the text/html fragment that is being dragged.
+  ///
+  /*--cef(optional_param=html)--*/
+  virtual void SetFragmentHtml(const CefString& html) =0;
+
+  ///
+  // Set the base URL that the fragment came from.
+  ///
+  /*--cef(optional_param=base_url)--*/
+  virtual void SetFragmentBaseURL(const CefString& base_url) =0;
+
+  ///
+  // Reset the file contents. You should do this before calling
+  // CefBrowserHost::DragTargetDragEnter as the web view does not allow us to
+  // drag in this kind of data.
+  ///
+  /*--cef()--*/
+  virtual void ResetFileContents() =0;
+
+  ///
+  // Add a file that is being dragged into the webview.
+  ///
+  /*--cef(optional_param=display_name)--*/
+  virtual void AddFile(const CefString& path, const CefString& display_name) =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_DRAG_DATA_H_
diff --git a/src/include/libcef_/cef_drag_handler.h b/src/include/libcef_/cef_drag_handler.h
new file mode 100644
index 0000000..2a631ea
--- /dev/null
+++ b/src/include/libcef_/cef_drag_handler.h
@@ -0,0 +1,78 @@
+// Copyright (c) 2013 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_DRAG_HANDLER_H_
+#define CEF_INCLUDE_CEF_DRAG_HANDLER_H_
+#pragma once
+
+#include"libcef/cef_base.h"
+#include"libcef/cef_drag_data.h"
+#include"libcef/cef_browser.h"
+
+///
+// Implement this interface to handle events related to dragging. The methods of
+// this class will be called on the UI thread.
+///
+/*--cef(source=client)--*/
+class CefDragHandler : public virtual CefBase {
+ public:
+  typedef cef_drag_operations_mask_t DragOperationsMask;
+
+  ///
+  // Called when an external drag event enters the browser window. |dragData|
+  // contains the drag event data and |mask| represents the type of drag
+  // operation. Return false for default drag handling behavior or true to
+  // cancel the drag event.
+  ///
+  /*--cef()--*/
+  virtual bool OnDragEnter(CefRefPtr<CefBrowser> browser,
+                           CefRefPtr<CefDragData> dragData,
+                           DragOperationsMask mask) { return false; }
+
+  ///
+  // Called whenever draggable regions for the browser window change. These can
+  // be specified using the '-webkit-app-region: drag/no-drag' CSS-property. If
+  // draggable regions are never defined in a document this method will also
+  // never be called. If the last draggable region is removed from a document
+  // this method will be called with an empty vector.
+  ///
+  /*--cef()--*/
+  virtual void OnDraggableRegionsChanged(
+      CefRefPtr<CefBrowser> browser,
+      const std::vector<CefDraggableRegion>& regions) {}
+};
+
+#endif  // CEF_INCLUDE_CEF_DRAG_HANDLER_H_
diff --git a/src/include/libcef_/cef_find_handler.h b/src/include/libcef_/cef_find_handler.h
new file mode 100644
index 0000000..c59e624
--- /dev/null
+++ b/src/include/libcef_/cef_find_handler.h
@@ -0,0 +1,68 @@
+// Copyright (c) 2015 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_FIND_HANDLER_H_
+#define CEF_INCLUDE_CEF_FIND_HANDLER_H_
+#pragma once
+
+#include"libcef/cef_base.h"
+#include"libcef/cef_browser.h"
+
+///
+// Implement this interface to handle events related to find results. The
+// methods of this class will be called on the UI thread.
+///
+/*--cef(source=client)--*/
+class CefFindHandler : public virtual CefBase {
+ public:
+  ///
+  // Called to report find results returned by CefBrowserHost::Find().
+  // |identifer| is the identifier passed to Find(), |count| is the number of
+  // matches currently identified, |selectionRect| is the location of where the
+  // match was found (in window coordinates), |activeMatchOrdinal| is the
+  // current position in the search results, and |finalUpdate| is true if this
+  // is the last find notification.
+  ///
+  /*--cef()--*/
+  virtual void OnFindResult(CefRefPtr<CefBrowser> browser,
+                            int identifier,
+                            int count,
+                            const CefRect& selectionRect,
+                            int activeMatchOrdinal,
+                            bool finalUpdate) {}
+};
+
+#endif  // CEF_INCLUDE_CEF_FIND_HANDLER_H_
diff --git a/src/include/libcef_/cef_focus_handler.h b/src/include/libcef_/cef_focus_handler.h
new file mode 100644
index 0000000..2f2e2bb
--- /dev/null
+++ b/src/include/libcef_/cef_focus_handler.h
@@ -0,0 +1,81 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_FOCUS_HANDLER_H_
+#define CEF_INCLUDE_CEF_FOCUS_HANDLER_H_
+#pragma once
+
+#include"libcef/cef_base.h"
+#include"libcef/cef_browser.h"
+#include"libcef/cef_dom.h"
+#include"libcef/cef_frame.h"
+
+///
+// Implement this interface to handle events related to focus. The methods of
+// this class will be called on the UI thread.
+///
+/*--cef(source=client)--*/
+class CefFocusHandler : public virtual CefBase {
+ public:
+  typedef cef_focus_source_t FocusSource;
+
+  ///
+  // Called when the browser component is about to loose focus. For instance, if
+  // focus was on the last HTML element and the user pressed the TAB key. |next|
+  // will be true if the browser is giving focus to the next component and false
+  // if the browser is giving focus to the previous component.
+  ///
+  /*--cef()--*/
+  virtual void OnTakeFocus(CefRefPtr<CefBrowser> browser,
+                           bool next) {}
+
+  ///
+  // Called when the browser component is requesting focus. |source| indicates
+  // where the focus request is originating from. Return false to allow the
+  // focus to be set or true to cancel setting the focus.
+  ///
+  /*--cef()--*/
+  virtual bool OnSetFocus(CefRefPtr<CefBrowser> browser,
+                          FocusSource source) { return false; }
+
+  ///
+  // Called when the browser component has received focus.
+  ///
+  /*--cef()--*/
+  virtual void OnGotFocus(CefRefPtr<CefBrowser> browser) {}
+};
+
+#endif  // CEF_INCLUDE_CEF_FOCUS_HANDLER_H_
diff --git a/src/include/libcef_/cef_frame.h b/src/include/libcef_/cef_frame.h
new file mode 100644
index 0000000..e0224f1
--- /dev/null
+++ b/src/include/libcef_/cef_frame.h
@@ -0,0 +1,225 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_FRAME_H_
+#define CEF_INCLUDE_CEF_FRAME_H_
+#pragma once
+
+#include"libcef/cef_base.h"
+#include"libcef/cef_dom.h"
+#include"libcef/cef_request.h"
+#include"libcef/cef_stream.h"
+#include"libcef/cef_string_visitor.h"
+
+class CefBrowser;
+class CefV8Context;
+
+///
+// Class used to represent a frame in the browser window. When used in the
+// browser process the methods of this class may be called on any thread unless
+// otherwise indicated in the comments. When used in the render process the
+// methods of this class may only be called on the main thread.
+///
+/*--cef(source=library)--*/
+class CefFrame : public virtual CefBase {
+ public:
+  ///
+  // True if this object is currently attached to a valid frame.
+  ///
+  /*--cef()--*/
+  virtual bool IsValid() =0;
+
+  ///
+  // Execute undo in this frame.
+  ///
+  /*--cef()--*/
+  virtual void Undo() =0;
+
+  ///
+  // Execute redo in this frame.
+  ///
+  /*--cef()--*/
+  virtual void Redo() =0;
+
+  ///
+  // Execute cut in this frame.
+  ///
+  /*--cef()--*/
+  virtual void Cut() =0;
+
+  ///
+  // Execute copy in this frame.
+  ///
+  /*--cef()--*/
+  virtual void Copy() =0;
+
+  ///
+  // Execute paste in this frame.
+  ///
+  /*--cef()--*/
+  virtual void Paste() =0;
+
+  ///
+  // Execute delete in this frame.
+  ///
+  /*--cef(capi_name=del)--*/
+  virtual void Delete() =0;
+
+  ///
+  // Execute select all in this frame.
+  ///
+  /*--cef()--*/
+  virtual void SelectAll() =0;
+
+  ///
+  // Save this frame's HTML source to a temporary file and open it in the
+  // default text viewing application. This method can only be called from the
+  // browser process.
+  ///
+  /*--cef()--*/
+  virtual void ViewSource() =0;
+
+  ///
+  // Retrieve this frame's HTML source as a string sent to the specified
+  // visitor.
+  ///
+  /*--cef()--*/
+  virtual void GetSource(CefRefPtr<CefStringVisitor> visitor) =0;
+
+  ///
+  // Retrieve this frame's display text as a string sent to the specified
+  // visitor.
+  ///
+  /*--cef()--*/
+  virtual void GetText(CefRefPtr<CefStringVisitor> visitor) =0;
+
+  ///
+  // Load the request represented by the |request| object.
+  ///
+  /*--cef()--*/
+  virtual void LoadRequest(CefRefPtr<CefRequest> request) =0;
+
+  ///
+  // Load the specified |url|.
+  ///
+  /*--cef()--*/
+  virtual void LoadURL(const CefString& url) =0;
+
+  ///
+  // Load the contents of |string_val| with the specified dummy |url|. |url|
+  // should have a standard scheme (for example, http scheme) or behaviors like
+  // link clicks and web security restrictions may not behave as expected.
+  ///
+  /*--cef()--*/
+  virtual void LoadString(const CefString& string_val,
+                          const CefString& url) =0;
+
+  ///
+  // Execute a string of JavaScript code in this frame. The |script_url|
+  // parameter is the URL where the script in question can be found, if any.
+  // The renderer may request this URL to show the developer the source of the
+  // error.  The |start_line| parameter is the base line number to use for error
+  // reporting.
+  ///
+  /*--cef(optional_param=script_url)--*/
+  virtual void ExecuteJavaScript(const CefString& code,
+                                 const CefString& script_url,
+                                 int start_line) =0;
+
+  ///
+  // Returns true if this is the main (top-level) frame.
+  ///
+  /*--cef()--*/
+  virtual bool IsMain() =0;
+
+  ///
+  // Returns true if this is the focused frame.
+  ///
+  /*--cef()--*/
+  virtual bool IsFocused() =0;
+
+  ///
+  // Returns the name for this frame. If the frame has an assigned name (for
+  // example, set via the iframe "name" attribute) then that value will be
+  // returned. Otherwise a unique name will be constructed based on the frame
+  // parent hierarchy. The main (top-level) frame will always have an empty name
+  // value.
+  ///
+  /*--cef()--*/
+  virtual CefString GetName() =0;
+
+  ///
+  // Returns the globally unique identifier for this frame or < 0 if the
+  // underlying frame does not yet exist.
+  ///
+  /*--cef()--*/
+  virtual int64 GetIdentifier() =0;
+
+  ///
+  // Returns the parent of this frame or NULL if this is the main (top-level)
+  // frame.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefFrame> GetParent() =0;
+
+  ///
+  // Returns the URL currently loaded in this frame.
+  ///
+  /*--cef()--*/
+  virtual CefString GetURL() =0;
+
+  ///
+  // Returns the browser that this frame belongs to.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefBrowser> GetBrowser() =0;
+
+  ///
+  // Get the V8 context associated with the frame. This method can only be
+  // called from the render process.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefV8Context> GetV8Context() =0;
+  
+  ///
+  // Visit the DOM document. This method can only be called from the render
+  // process.
+  ///
+  /*--cef()--*/
+  virtual void VisitDOM(CefRefPtr<CefDOMVisitor> visitor) =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_FRAME_H_
diff --git a/src/include/libcef_/cef_geolocation.h b/src/include/libcef_/cef_geolocation.h
new file mode 100644
index 0000000..745ed14
--- /dev/null
+++ b/src/include/libcef_/cef_geolocation.h
@@ -0,0 +1,66 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_GEOLOCATION_H_
+#define CEF_INCLUDE_CEF_GEOLOCATION_H_
+#pragma once
+
+#include"libcef/cef_base.h"
+
+///
+// Implement this interface to receive geolocation updates. The methods of this
+// class will be called on the browser process UI thread.
+///
+/*--cef(source=client)--*/
+class CefGetGeolocationCallback : public virtual CefBase {
+ public:
+  ///
+  // Called with the 'best available' location information or, if the location
+  // update failed, with error information.
+  ///
+  /*--cef()--*/
+  virtual void OnLocationUpdate(const CefGeoposition& position) =0;
+};
+
+///
+// Request a one-time geolocation update. This function bypasses any user
+// permission checks so should only be used by code that is allowed to access
+// location information.
+///
+/*--cef()--*/
+bool CefGetGeolocation(CefRefPtr<CefGetGeolocationCallback> callback);
+
+#endif  // CEF_INCLUDE_CEF_GEOLOCATION_H_
diff --git a/src/include/libcef_/cef_geolocation_handler.h b/src/include/libcef_/cef_geolocation_handler.h
new file mode 100644
index 0000000..2889906
--- /dev/null
+++ b/src/include/libcef_/cef_geolocation_handler.h
@@ -0,0 +1,95 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_GEOLOCATION_HANDLER_H_
+#define CEF_INCLUDE_CEF_GEOLOCATION_HANDLER_H_
+#pragma once
+
+#include"libcef/cef_base.h"
+#include"libcef/cef_browser.h"
+
+///
+// Callback interface used for asynchronous continuation of geolocation
+// permission requests.
+///
+/*--cef(source=library)--*/
+class CefGeolocationCallback : public virtual CefBase {
+ public:
+  ///
+  // Call to allow or deny geolocation access.
+  ///
+  /*--cef(capi_name=cont)--*/
+  virtual void Continue(bool allow) =0;
+};
+
+
+///
+// Implement this interface to handle events related to geolocation permission
+// requests. The methods of this class will be called on the browser process UI
+// thread.
+///
+/*--cef(source=client)--*/
+class CefGeolocationHandler : public virtual CefBase {
+ public:
+  ///
+  // Called when a page requests permission to access geolocation information.
+  // |requesting_url| is the URL requesting permission and |request_id| is the
+  // unique ID for the permission request. Return true and call
+  // CefGeolocationCallback::Continue() either in this method or at a later
+  // time to continue or cancel the request. Return false to cancel the request
+  // immediately.
+  ///
+  /*--cef()--*/
+  virtual bool OnRequestGeolocationPermission(
+      CefRefPtr<CefBrowser> browser,
+      const CefString& requesting_url,
+      int request_id,
+      CefRefPtr<CefGeolocationCallback> callback) {
+    return false;
+  }
+
+  ///
+  // Called when a geolocation access request is canceled. |request_id| is the
+  // unique ID for the permission request.
+  ///
+  /*--cef()--*/
+  virtual void OnCancelGeolocationPermission(
+      CefRefPtr<CefBrowser> browser,
+      int request_id) {
+  }
+};
+
+#endif  // CEF_INCLUDE_CEF_GEOLOCATION_HANDLER_H_
diff --git a/src/include/libcef_/cef_jsdialog_handler.h b/src/include/libcef_/cef_jsdialog_handler.h
new file mode 100644
index 0000000..27874ee
--- /dev/null
+++ b/src/include/libcef_/cef_jsdialog_handler.h
@@ -0,0 +1,131 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_JSDIALOG_HANDLER_H_
+#define CEF_INCLUDE_CEF_JSDIALOG_HANDLER_H_
+#pragma once
+
+#include"libcef/cef_base.h"
+#include"libcef/cef_browser.h"
+
+///
+// Callback interface used for asynchronous continuation of JavaScript dialog
+// requests.
+///
+/*--cef(source=library)--*/
+class CefJSDialogCallback : public virtual CefBase {
+ public:
+  ///
+  // Continue the JS dialog request. Set |success| to true if the OK button was
+  // pressed. The |user_input| value should be specified for prompt dialogs.
+  ///
+  /*--cef(capi_name=cont,optional_param=user_input)--*/
+  virtual void Continue(bool success,
+                        const CefString& user_input) =0;
+};
+
+
+///
+// Implement this interface to handle events related to JavaScript dialogs. The
+// methods of this class will be called on the UI thread.
+///
+/*--cef(source=client)--*/
+class CefJSDialogHandler : public virtual CefBase {
+ public:
+  typedef cef_jsdialog_type_t JSDialogType;
+
+  ///
+  // Called to run a JavaScript dialog. If |origin_url| and |accept_lang| are
+  // non-empty they can be passed to the CefFormatUrlForSecurityDisplay function
+  // to retrieve a secure and user-friendly display string. The
+  // |default_prompt_text| value will be specified for prompt dialogs only. Set
+  // |suppress_message| to true and return false to suppress the message
+  // (suppressing messages is preferable to immediately executing the callback
+  // as this is used to detect presumably malicious behavior like spamming alert
+  // messages in onbeforeunload). Set |suppress_message| to false and return
+  // false to use the default implementation (the default implementation will
+  // show one modal dialog at a time and suppress any additional dialog requests
+  // until the displayed dialog is dismissed). Return true if the application
+  // will use a custom dialog or if the callback has been executed immediately.
+  // Custom dialogs may be either modal or modeless. If a custom dialog is used
+  // the application must execute |callback| once the custom dialog is
+  // dismissed.
+  ///
+  /*--cef(optional_param=origin_url,optional_param=accept_lang,
+          optional_param=message_text,optional_param=default_prompt_text)--*/
+  virtual bool OnJSDialog(CefRefPtr<CefBrowser> browser,
+                          const CefString& origin_url,
+                          const CefString& accept_lang,
+                          JSDialogType dialog_type,
+                          const CefString& message_text,
+                          const CefString& default_prompt_text,
+                          CefRefPtr<CefJSDialogCallback> callback,
+                          bool& suppress_message) {
+    return false;
+  }
+
+  ///
+  // Called to run a dialog asking the user if they want to leave a page. Return
+  // false to use the default dialog implementation. Return true if the
+  // application will use a custom dialog or if the callback has been executed
+  // immediately. Custom dialogs may be either modal or modeless. If a custom
+  // dialog is used the application must execute |callback| once the custom
+  // dialog is dismissed.
+  ///
+  /*--cef(optional_param=message_text)--*/
+  virtual bool OnBeforeUnloadDialog(CefRefPtr<CefBrowser> browser,
+                                    const CefString& message_text,
+                                    bool is_reload,
+                                    CefRefPtr<CefJSDialogCallback> callback) {
+    return false;
+  }
+
+  ///
+  // Called to cancel any pending dialogs and reset any saved dialog state. Will
+  // be called due to events like page navigation irregardless of whether any
+  // dialogs are currently pending.
+  ///
+  /*--cef()--*/
+  virtual void OnResetDialogState(CefRefPtr<CefBrowser> browser) {}
+  
+  ///
+  // Called when the default implementation dialog is closed.
+  ///
+  /*--cef()--*/
+  virtual void OnDialogClosed(CefRefPtr<CefBrowser> browser) {}
+};
+
+#endif  // CEF_INCLUDE_CEF_JSDIALOG_HANDLER_H_
diff --git a/src/include/libcef_/cef_keyboard_handler.h b/src/include/libcef_/cef_keyboard_handler.h
new file mode 100644
index 0000000..5c4b2e5
--- /dev/null
+++ b/src/include/libcef_/cef_keyboard_handler.h
@@ -0,0 +1,76 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_KEYBOARD_HANDLER_H_
+#define CEF_INCLUDE_CEF_KEYBOARD_HANDLER_H_
+#pragma once
+
+#include"libcef/cef_base.h"
+#include"libcef/cef_browser.h"
+
+///
+// Implement this interface to handle events related to keyboard input. The
+// methods of this class will be called on the UI thread.
+///
+/*--cef(source=client)--*/
+class CefKeyboardHandler : public virtual CefBase {
+ public:
+  ///
+  // Called before a keyboard event is sent to the renderer. |event| contains
+  // information about the keyboard event. |os_event| is the operating system
+  // event message, if any. Return true if the event was handled or false
+  // otherwise. If the event will be handled in OnKeyEvent() as a keyboard
+  // shortcut set |is_keyboard_shortcut| to true and return false.
+  ///
+  /*--cef()--*/
+  virtual bool OnPreKeyEvent(CefRefPtr<CefBrowser> browser,
+                             const CefKeyEvent& event,
+                             CefEventHandle os_event,
+                             bool* is_keyboard_shortcut) { return false; }
+
+  ///
+  // Called after the renderer and JavaScript in the page has had a chance to
+  // handle the event. |event| contains information about the keyboard event.
+  // |os_event| is the operating system event message, if any. Return true if
+  // the keyboard event was handled or false otherwise.
+  ///
+  /*--cef()--*/
+  virtual bool OnKeyEvent(CefRefPtr<CefBrowser> browser,
+                          const CefKeyEvent& event,
+                          CefEventHandle os_event) { return false; }
+};
+
+#endif  // CEF_INCLUDE_CEF_KEYBOARD_HANDLER_H_
diff --git a/src/include/libcef_/cef_life_span_handler.h b/src/include/libcef_/cef_life_span_handler.h
new file mode 100644
index 0000000..eabc94d
--- /dev/null
+++ b/src/include/libcef_/cef_life_span_handler.h
@@ -0,0 +1,174 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_LIFE_SPAN_HANDLER_H_
+#define CEF_INCLUDE_CEF_LIFE_SPAN_HANDLER_H_
+#pragma once
+
+#include"libcef/cef_base.h"
+#include"libcef/cef_browser.h"
+
+class CefClient;
+
+///
+// Implement this interface to handle events related to browser life span. The
+// methods of this class will be called on the UI thread unless otherwise
+// indicated.
+///
+/*--cef(source=client)--*/
+class CefLifeSpanHandler : public virtual CefBase {
+ public:
+  typedef cef_window_open_disposition_t WindowOpenDisposition;
+
+  ///
+  // Called on the IO thread before a new popup browser is created. The
+  // |browser| and |frame| values represent the source of the popup request. The
+  // |target_url| and |target_frame_name| values indicate where the popup
+  // browser should navigate and may be empty if not specified with the request.
+  // The |target_disposition| value indicates where the user intended to open
+  // the popup (e.g. current tab, new tab, etc). The |user_gesture| value will
+  // be true if the popup was opened via explicit user gesture (e.g. clicking a
+  // link) or false if the popup opened automatically (e.g. via the
+  // DomContentLoaded event). The |popupFeatures| structure contains additional
+  // information about the requested popup window. To allow creation of the
+  // popup browser optionally modify |windowInfo|, |client|, |settings| and
+  // |no_javascript_access| and return false. To cancel creation of the popup
+  // browser return true. The |client| and |settings| values will default to the
+  // source browser's values. If the |no_javascript_access| value is set to
+  // false the new browser will not be scriptable and may not be hosted in the
+  // same renderer process as the source browser.
+  ///
+  /*--cef(optional_param=target_url,optional_param=target_frame_name)--*/
+  virtual bool OnBeforePopup(CefRefPtr<CefBrowser> browser,
+                             CefRefPtr<CefFrame> frame,
+                             const CefString& target_url,
+                             const CefString& target_frame_name,
+                             WindowOpenDisposition target_disposition,
+                             bool user_gesture,
+                             const CefPopupFeatures& popupFeatures,
+                             CefWindowInfo& windowInfo,
+                             CefRefPtr<CefClient>& client,
+                             CefBrowserSettings& settings,
+                             bool* no_javascript_access) {
+    return false;
+  }
+
+  ///
+  // Called after a new browser is created.
+  ///
+  /*--cef()--*/
+  virtual void OnAfterCreated(CefRefPtr<CefBrowser> browser) {}
+
+  ///
+  // Called when a modal window is about to display and the modal loop should
+  // begin running. Return false to use the default modal loop implementation or
+  // true to use a custom implementation.
+  ///
+  /*--cef()--*/
+  virtual bool RunModal(CefRefPtr<CefBrowser> browser) { return false; }
+
+  ///
+  // Called when a browser has recieved a request to close. This may result
+  // directly from a call to CefBrowserHost::CloseBrowser() or indirectly if the
+  // browser is a top-level OS window created by CEF and the user attempts to
+  // close the window. This method will be called after the JavaScript
+  // 'onunload' event has been fired. It will not be called for browsers after
+  // the associated OS window has been destroyed (for those browsers it is no
+  // longer possible to cancel the close).
+  //
+  // If CEF created an OS window for the browser returning false will send an OS
+  // close notification to the browser window's top-level owner (e.g. WM_CLOSE
+  // on Windows, performClose: on OS-X and "delete_event" on Linux). If no OS
+  // window exists (window rendering disabled) returning false will cause the
+  // browser object to be destroyed immediately. Return true if the browser is
+  // parented to another window and that other window needs to receive close
+  // notification via some non-standard technique.
+  //
+  // If an application provides its own top-level window it should handle OS
+  // close notifications by calling CefBrowserHost::CloseBrowser(false) instead
+  // of immediately closing (see the example below). This gives CEF an
+  // opportunity to process the 'onbeforeunload' event and optionally cancel the
+  // close before DoClose() is called.
+  //
+  // The CefLifeSpanHandler::OnBeforeClose() method will be called immediately
+  // before the browser object is destroyed. The application should only exit
+  // after OnBeforeClose() has been called for all existing browsers.
+  //
+  // If the browser represents a modal window and a custom modal loop
+  // implementation was provided in CefLifeSpanHandler::RunModal() this callback
+  // should be used to restore the opener window to a usable state.
+  //
+  // By way of example consider what should happen during window close when the
+  // browser is parented to an application-provided top-level OS window.
+  // 1.  User clicks the window close button which sends an OS close
+  //     notification (e.g. WM_CLOSE on Windows, performClose: on OS-X and
+  //     "delete_event" on Linux).
+  // 2.  Application's top-level window receives the close notification and:
+  //     A. Calls CefBrowserHost::CloseBrowser(false).
+  //     B. Cancels the window close.
+  // 3.  JavaScript 'onbeforeunload' handler executes and shows the close
+  //     confirmation dialog (which can be overridden via
+  //     CefJSDialogHandler::OnBeforeUnloadDialog()).
+  // 4.  User approves the close.
+  // 5.  JavaScript 'onunload' handler executes.
+  // 6.  Application's DoClose() handler is called. Application will:
+  //     A. Set a flag to indicate that the next close attempt will be allowed.
+  //     B. Return false.
+  // 7.  CEF sends an OS close notification.
+  // 8.  Application's top-level window receives the OS close notification and
+  //     allows the window to close based on the flag from #6B.
+  // 9.  Browser OS window is destroyed.
+  // 10. Application's CefLifeSpanHandler::OnBeforeClose() handler is called and
+  //     the browser object is destroyed.
+  // 11. Application exits by calling CefQuitMessageLoop() if no other browsers
+  //     exist.
+  ///
+  /*--cef()--*/
+  virtual bool DoClose(CefRefPtr<CefBrowser> browser) { return false; }
+
+  ///
+  // Called just before a browser is destroyed. Release all references to the
+  // browser object and do not attempt to execute any methods on the browser
+  // object after this callback returns. If this is a modal window and a custom
+  // modal loop implementation was provided in RunModal() this callback should
+  // be used to exit the custom modal loop. See DoClose() documentation for
+  // additional usage information.
+  ///
+  /*--cef()--*/
+  virtual void OnBeforeClose(CefRefPtr<CefBrowser> browser) {}
+};
+
+#endif  // CEF_INCLUDE_CEF_LIFE_SPAN_HANDLER_H_
diff --git a/src/include/libcef_/cef_load_handler.h b/src/include/libcef_/cef_load_handler.h
new file mode 100644
index 0000000..1342421
--- /dev/null
+++ b/src/include/libcef_/cef_load_handler.h
@@ -0,0 +1,109 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_LOAD_HANDLER_H_
+#define CEF_INCLUDE_CEF_LOAD_HANDLER_H_
+#pragma once
+
+#include"libcef/cef_base.h"
+#include"libcef/cef_browser.h"
+#include"libcef/cef_frame.h"
+
+///
+// Implement this interface to handle events related to browser load status. The
+// methods of this class will be called on the browser process UI thread or
+// render process main thread (TID_RENDERER).
+///
+/*--cef(source=client)--*/
+class CefLoadHandler : public virtual CefBase {
+ public:
+  typedef cef_errorcode_t ErrorCode;
+
+  ///
+  // Called when the loading state has changed. This callback will be executed
+  // twice -- once when loading is initiated either programmatically or by user
+  // action, and once when loading is terminated due to completion, cancellation
+  // of failure. It will be called before any calls to OnLoadStart and after all
+  // calls to OnLoadError and/or OnLoadEnd.
+  ///
+  /*--cef()--*/
+  virtual void OnLoadingStateChange(CefRefPtr<CefBrowser> browser,
+                                    bool isLoading,
+                                    bool canGoBack,
+                                    bool canGoForward) {}
+
+  ///
+  // Called when the browser begins loading a frame. The |frame| value will
+  // never be empty -- call the IsMain() method to check if this frame is the
+  // main frame. Multiple frames may be loading at the same time. Sub-frames may
+  // start or continue loading after the main frame load has ended. This method
+  // will always be called for all frames irrespective of whether the request
+  // completes successfully. For notification of overall browser load status use
+  // OnLoadingStateChange instead.
+  ///
+  /*--cef()--*/
+  virtual void OnLoadStart(CefRefPtr<CefBrowser> browser,
+                           CefRefPtr<CefFrame> frame) {}
+
+  ///
+  // Called when the browser is done loading a frame. The |frame| value will
+  // never be empty -- call the IsMain() method to check if this frame is the
+  // main frame. Multiple frames may be loading at the same time. Sub-frames may
+  // start or continue loading after the main frame load has ended. This method
+  // will always be called for all frames irrespective of whether the request
+  // completes successfully. For notification of overall browser load status use
+  // OnLoadingStateChange instead.
+  ///
+  /*--cef()--*/
+  virtual void OnLoadEnd(CefRefPtr<CefBrowser> browser,
+                         CefRefPtr<CefFrame> frame,
+                         int httpStatusCode) {}
+
+  ///
+  // Called when the resource load for a navigation fails or is canceled.
+  // |errorCode| is the error code number, |errorText| is the error text and
+  // |failedUrl| is the URL that failed to load. See net\base\net_error_list.h
+  // for complete descriptions of the error codes.
+  ///
+  /*--cef(optional_param=errorText)--*/
+  virtual void OnLoadError(CefRefPtr<CefBrowser> browser,
+                           CefRefPtr<CefFrame> frame,
+                           ErrorCode errorCode,
+                           const CefString& errorText,
+                           const CefString& failedUrl) {}
+};
+
+#endif  // CEF_INCLUDE_CEF_LOAD_HANDLER_H_
diff --git a/src/include/libcef_/cef_menu_model.h b/src/include/libcef_/cef_menu_model.h
new file mode 100644
index 0000000..55b013a
--- /dev/null
+++ b/src/include/libcef_/cef_menu_model.h
@@ -0,0 +1,402 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_MENU_MODEL_H_
+#define CEF_INCLUDE_CEF_MENU_MODEL_H_
+#pragma once
+
+#include"libcef/cef_base.h"
+
+///
+// Supports creation and modification of menus. See cef_menu_id_t for the
+// command ids that have default implementations. All user-defined command ids
+// should be between MENU_ID_USER_FIRST and MENU_ID_USER_LAST. The methods of
+// this class can only be accessed on the browser process the UI thread.
+///
+/*--cef(source=library)--*/
+class CefMenuModel : public virtual CefBase {
+ public:
+  typedef cef_menu_item_type_t MenuItemType;
+
+  ///
+  // Clears the menu. Returns true on success.
+  ///
+  /*--cef()--*/
+  virtual bool Clear() =0;
+
+  ///
+  // Returns the number of items in this menu.
+  ///
+  /*--cef()--*/
+  virtual int GetCount() =0;
+
+  ///
+  // Add a separator to the menu. Returns true on success.
+  ///
+  /*--cef()--*/
+  virtual bool AddSeparator() =0;
+
+  ///
+  // Add an item to the menu. Returns true on success.
+  ///
+  /*--cef()--*/
+  virtual bool AddItem(int command_id,
+                       const CefString& label) =0;
+
+  ///
+  // Add a check item to the menu. Returns true on success.
+  ///
+  /*--cef()--*/
+  virtual bool AddCheckItem(int command_id,
+                            const CefString& label) =0;
+  ///
+  // Add a radio item to the menu. Only a single item with the specified
+  // |group_id| can be checked at a time. Returns true on success.
+  ///
+  /*--cef()--*/
+  virtual bool AddRadioItem(int command_id,
+                            const CefString& label,
+                            int group_id) =0;
+
+  ///
+  // Add a sub-menu to the menu. The new sub-menu is returned.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefMenuModel> AddSubMenu(int command_id,
+                                             const CefString& label) =0;
+
+  ///
+  // Insert a separator in the menu at the specified |index|. Returns true on
+  // success.
+  ///
+  /*--cef()--*/
+  virtual bool InsertSeparatorAt(int index) =0;
+
+  ///
+  // Insert an item in the menu at the specified |index|. Returns true on
+  // success.
+  ///
+  /*--cef()--*/
+  virtual bool InsertItemAt(int index,
+                            int command_id,
+                            const CefString& label) =0;
+
+  ///
+  // Insert a check item in the menu at the specified |index|. Returns true on
+  // success.
+  ///
+  /*--cef()--*/
+  virtual bool InsertCheckItemAt(int index,
+                                 int command_id,
+                                 const CefString& label) =0;
+
+  ///
+  // Insert a radio item in the menu at the specified |index|. Only a single
+  // item with the specified |group_id| can be checked at a time. Returns true
+  // on success.
+  ///
+  /*--cef()--*/
+  virtual bool InsertRadioItemAt(int index,
+                                 int command_id,
+                                 const CefString& label,
+                                 int group_id) =0;
+
+  ///
+  // Insert a sub-menu in the menu at the specified |index|. The new sub-menu
+  // is returned.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefMenuModel> InsertSubMenuAt(int index,
+                                                  int command_id,
+                                                  const CefString& label) =0;
+
+  ///
+  // Removes the item with the specified |command_id|. Returns true on success.
+  ///
+  /*--cef()--*/
+  virtual bool Remove(int command_id) =0;
+
+  ///
+  // Removes the item at the specified |index|. Returns true on success.
+  ///
+  /*--cef()--*/
+  virtual bool RemoveAt(int index) =0;
+
+  ///
+  // Returns the index associated with the specified |command_id| or -1 if not
+  // found due to the command id not existing in the menu.
+  ///
+  /*--cef()--*/
+  virtual int GetIndexOf(int command_id) =0;
+
+  ///
+  // Returns the command id at the specified |index| or -1 if not found due to
+  // invalid range or the index being a separator.
+  ///
+  /*--cef()--*/
+  virtual int GetCommandIdAt(int index) =0;
+
+  ///
+  // Sets the command id at the specified |index|. Returns true on success.
+  ///
+  /*--cef()--*/
+  virtual bool SetCommandIdAt(int index, int command_id) =0;
+
+  ///
+  // Returns the label for the specified |command_id| or empty if not found.
+  ///
+  /*--cef()--*/
+  virtual CefString GetLabel(int command_id) =0;
+
+  ///
+  // Returns the label at the specified |index| or empty if not found due to
+  // invalid range or the index being a separator.
+  ///
+  /*--cef()--*/
+  virtual CefString GetLabelAt(int index) =0;
+
+  ///
+  // Sets the label for the specified |command_id|. Returns true on success.
+  ///
+  /*--cef()--*/
+  virtual bool SetLabel(int command_id, const CefString& label) =0;
+
+  ///
+  // Set the label at the specified |index|. Returns true on success.
+  ///
+  /*--cef()--*/
+  virtual bool SetLabelAt(int index, const CefString& label) =0;
+
+  ///
+  // Returns the item type for the specified |command_id|.
+  ///
+  /*--cef(default_retval=MENUITEMTYPE_NONE)--*/
+  virtual MenuItemType GetType(int command_id) =0;
+
+  ///
+  // Returns the item type at the specified |index|.
+  ///
+  /*--cef(default_retval=MENUITEMTYPE_NONE)--*/
+  virtual MenuItemType GetTypeAt(int index) =0;
+
+  ///
+  // Returns the group id for the specified |command_id| or -1 if invalid.
+  ///
+  /*--cef()--*/
+  virtual int GetGroupId(int command_id) =0;
+
+  ///
+  // Returns the group id at the specified |index| or -1 if invalid.
+  ///
+  /*--cef()--*/
+  virtual int GetGroupIdAt(int index) =0;
+
+  ///
+  // Sets the group id for the specified |command_id|. Returns true on success.
+  ///
+  /*--cef()--*/
+  virtual bool SetGroupId(int command_id, int group_id) =0;
+
+  ///
+  // Sets the group id at the specified |index|. Returns true on success.
+  ///
+  /*--cef()--*/
+  virtual bool SetGroupIdAt(int index, int group_id) =0;
+
+  ///
+  // Returns the submenu for the specified |command_id| or empty if invalid.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefMenuModel> GetSubMenu(int command_id) =0;
+
+  ///
+  // Returns the submenu at the specified |index| or empty if invalid.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefMenuModel> GetSubMenuAt(int index) =0;
+
+  ///
+  // Returns true if the specified |command_id| is visible.
+  ///
+  /*--cef()--*/
+  virtual bool IsVisible(int command_id) =0;
+
+  ///
+  // Returns true if the specified |index| is visible.
+  ///
+  /*--cef()--*/
+  virtual bool IsVisibleAt(int index) =0;
+
+  ///
+  // Change the visibility of the specified |command_id|. Returns true on
+  // success.
+  ///
+  /*--cef()--*/
+  virtual bool SetVisible(int command_id, bool visible) =0;
+
+  ///
+  // Change the visibility at the specified |index|. Returns true on success.
+  ///
+  /*--cef()--*/
+  virtual bool SetVisibleAt(int index, bool visible) =0;
+
+  ///
+  // Returns true if the specified |command_id| is enabled.
+  ///
+  /*--cef()--*/
+  virtual bool IsEnabled(int command_id) =0;
+
+  ///
+  // Returns true if the specified |index| is enabled.
+  ///
+  /*--cef()--*/
+  virtual bool IsEnabledAt(int index) =0;
+
+  ///
+  // Change the enabled status of the specified |command_id|. Returns true on
+  // success.
+  ///
+  /*--cef()--*/
+  virtual bool SetEnabled(int command_id, bool enabled) =0;
+
+  ///
+  // Change the enabled status at the specified |index|. Returns true on
+  // success.
+  ///
+  /*--cef()--*/
+  virtual bool SetEnabledAt(int index, bool enabled) =0;
+
+  ///
+  // Returns true if the specified |command_id| is checked. Only applies to
+  // check and radio items.
+  ///
+  /*--cef()--*/
+  virtual bool IsChecked(int command_id) =0;
+
+  ///
+  // Returns true if the specified |index| is checked. Only applies to check
+  // and radio items.
+  ///
+  /*--cef()--*/
+  virtual bool IsCheckedAt(int index) =0;
+
+  ///
+  // Check the specified |command_id|. Only applies to check and radio items.
+  // Returns true on success.
+  ///
+  /*--cef()--*/
+  virtual bool SetChecked(int command_id, bool checked) =0;
+
+  ///
+  // Check the specified |index|. Only applies to check and radio items. Returns
+  // true on success.
+  ///
+  /*--cef()--*/
+  virtual bool SetCheckedAt(int index, bool checked) =0;
+
+  ///
+  // Returns true if the specified |command_id| has a keyboard accelerator
+  // assigned.
+  ///
+  /*--cef()--*/
+  virtual bool HasAccelerator(int command_id) =0;
+
+  ///
+  // Returns true if the specified |index| has a keyboard accelerator assigned.
+  ///
+  /*--cef()--*/
+  virtual bool HasAcceleratorAt(int index) =0;
+
+  ///
+  // Set the keyboard accelerator for the specified |command_id|. |key_code| can
+  // be any virtual key or character value. Returns true on success.
+  ///
+  /*--cef()--*/
+  virtual bool SetAccelerator(int command_id,
+                              int key_code,
+                              bool shift_pressed,
+                              bool ctrl_pressed,
+                              bool alt_pressed) =0;
+
+  ///
+  // Set the keyboard accelerator at the specified |index|. |key_code| can be
+  // any virtual key or character value. Returns true on success.
+  ///
+  /*--cef()--*/
+  virtual bool SetAcceleratorAt(int index,
+                                int key_code,
+                                bool shift_pressed,
+                                bool ctrl_pressed,
+                                bool alt_pressed) =0;
+
+  ///
+  // Remove the keyboard accelerator for the specified |command_id|. Returns
+  // true on success.
+  ///
+  /*--cef()--*/
+  virtual bool RemoveAccelerator(int command_id) =0;
+
+  ///
+  // Remove the keyboard accelerator at the specified |index|. Returns true on
+  // success.
+  ///
+  /*--cef()--*/
+  virtual bool RemoveAcceleratorAt(int index) =0;
+
+  ///
+  // Retrieves the keyboard accelerator for the specified |command_id|. Returns
+  // true on success.
+  ///
+  /*--cef()--*/
+  virtual bool GetAccelerator(int command_id,
+                              int& key_code,
+                              bool& shift_pressed,
+                              bool& ctrl_pressed,
+                              bool& alt_pressed) =0;
+
+  ///
+  // Retrieves the keyboard accelerator for the specified |index|. Returns true
+  // on success.
+  ///
+  /*--cef()--*/
+  virtual bool GetAcceleratorAt(int index,
+                                int& key_code,
+                                bool& shift_pressed,
+                                bool& ctrl_pressed,
+                                bool& alt_pressed) =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_MENU_MODEL_H_
diff --git a/src/include/libcef_/cef_navigation_entry.h b/src/include/libcef_/cef_navigation_entry.h
new file mode 100644
index 0000000..8f803d7
--- /dev/null
+++ b/src/include/libcef_/cef_navigation_entry.h
@@ -0,0 +1,113 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_NAVIGATION_ENTRY_H_
+#define CEF_INCLUDE_CEF_NAVIGATION_ENTRY_H_
+#pragma once
+
+#include"libcef/cef_base.h"
+
+///
+// Class used to represent an entry in navigation history.
+///
+/*--cef(source=library)--*/
+class CefNavigationEntry : public virtual CefBase {
+ public:
+  typedef cef_transition_type_t TransitionType;
+
+  ///
+  // Returns true if this object is valid. Do not call any other methods if this
+  // function returns false.
+  ///
+  /*--cef()--*/
+  virtual bool IsValid() =0;
+
+  ///
+  // Returns the actual URL of the page. For some pages this may be data: URL or
+  // similar. Use GetDisplayURL() to return a display-friendly version.
+  ///
+  /*--cef()--*/
+  virtual CefString GetURL() =0;
+
+  ///
+  // Returns a display-friendly version of the URL.
+  ///
+  /*--cef()--*/
+  virtual CefString GetDisplayURL() =0;
+
+  ///
+  // Returns the original URL that was entered by the user before any redirects.
+  ///
+  /*--cef()--*/
+  virtual CefString GetOriginalURL() =0;
+
+  ///
+  // Returns the title set by the page. This value may be empty.
+  ///
+  /*--cef()--*/
+  virtual CefString GetTitle() =0;
+
+  ///
+  // Returns the transition type which indicates what the user did to move to
+  // this page from the previous page.
+  ///
+  /*--cef(default_retval=TT_EXPLICIT)--*/
+  virtual TransitionType GetTransitionType() =0;
+
+  ///
+  // Returns true if this navigation includes post data.
+  ///
+  /*--cef()--*/
+  virtual bool HasPostData() =0;
+
+  ///
+  // Returns the time for the last known successful navigation completion. A
+  // navigation may be completed more than once if the page is reloaded. May be
+  // 0 if the navigation has not yet completed.
+  ///
+  /*--cef()--*/
+  virtual CefTime GetCompletionTime() =0;
+
+  ///
+  // Returns the HTTP status code for the last known successful navigation
+  // response. May be 0 if the response has not yet been received or if the
+  // navigation has not yet completed.
+  ///
+  /*--cef()--*/
+  virtual int GetHttpStatusCode() =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_NAVIGATION_ENTRY_H_
diff --git a/src/include/libcef_/cef_origin_whitelist.h b/src/include/libcef_/cef_origin_whitelist.h
new file mode 100644
index 0000000..5f4b91a
--- /dev/null
+++ b/src/include/libcef_/cef_origin_whitelist.h
@@ -0,0 +1,103 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_ORIGIN_WHITELIST_H_
+#define CEF_INCLUDE_CEF_ORIGIN_WHITELIST_H_
+#pragma once
+
+#include"libcef/cef_base.h"
+
+
+///
+// Add an entry to the cross-origin access whitelist.
+//
+// The same-origin policy restricts how scripts hosted from different origins
+// (scheme + domain + port) can communicate. By default, scripts can only access
+// resources with the same origin. Scripts hosted on the HTTP and HTTPS schemes
+// (but no other schemes) can use the "Access-Control-Allow-Origin" header to
+// allow cross-origin requests. For example, https://source.example.com can make
+// XMLHttpRequest requests on http://target.example.com if the
+// http://target.example.com request returns an "Access-Control-Allow-Origin:
+// https://source.example.com" response header.
+//
+// Scripts in separate frames or iframes and hosted from the same protocol and
+// domain suffix can execute cross-origin JavaScript if both pages set the
+// document.domain value to the same domain suffix. For example,
+// scheme://foo.example.com and scheme://bar.example.com can communicate using
+// JavaScript if both domains set document.domain="example.com".
+//
+// This method is used to allow access to origins that would otherwise violate
+// the same-origin policy. Scripts hosted underneath the fully qualified
+// |source_origin| URL (like http://www.example.com) will be allowed access to
+// all resources hosted on the specified |target_protocol| and |target_domain|.
+// If |target_domain| is non-empty and |allow_target_subdomains| if false only
+// exact domain matches will be allowed. If |target_domain| contains a top-
+// level domain component (like "example.com") and |allow_target_subdomains| is
+// true sub-domain matches will be allowed. If |target_domain| is empty and
+// |allow_target_subdomains| if true all domains and IP addresses will be
+// allowed.
+//
+// This method cannot be used to bypass the restrictions on local or display
+// isolated schemes. See the comments on CefRegisterCustomScheme for more
+// information.
+//
+// This function may be called on any thread. Returns false if |source_origin|
+// is invalid or the whitelist cannot be accessed.
+///
+/*--cef(optional_param=target_domain)--*/
+bool CefAddCrossOriginWhitelistEntry(const CefString& source_origin,
+                                     const CefString& target_protocol,
+                                     const CefString& target_domain,
+                                     bool allow_target_subdomains);
+
+///
+// Remove an entry from the cross-origin access whitelist. Returns false if
+// |source_origin| is invalid or the whitelist cannot be accessed.
+///
+/*--cef(optional_param=target_domain)--*/
+bool CefRemoveCrossOriginWhitelistEntry(const CefString& source_origin,
+                                        const CefString& target_protocol,
+                                        const CefString& target_domain,
+                                        bool allow_target_subdomains);
+
+///
+// Remove all entries from the cross-origin access whitelist. Returns false if
+// the whitelist cannot be accessed.
+///
+/*--cef()--*/
+bool CefClearCrossOriginWhitelist();
+
+#endif  // CEF_INCLUDE_CEF_ORIGIN_WHITELIST_H_
diff --git a/src/include/libcef_/cef_pack_resources.h b/src/include/libcef_/cef_pack_resources.h
new file mode 100644
index 0000000..8f1e337
--- /dev/null
+++ b/src/include/libcef_/cef_pack_resources.h
@@ -0,0 +1,1646 @@
+// Copyright (c) 2018 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file is generated by the make_pack_header.py tool.
+//
+
+#ifndef CEF_INCLUDE_CEF_PACK_RESOURCES_H_
+#define CEF_INCLUDE_CEF_PACK_RESOURCES_H_
+#pragma once
+
+// ---------------------------------------------------------------------------
+// From blink_resources.h:
+
+#define IDR_UASTYLE_HTML_CSS 30370
+#define IDR_UASTYLE_QUIRKS_CSS 30371
+#define IDR_UASTYLE_VIEW_SOURCE_CSS 30372
+#define IDR_UASTYLE_THEME_CHROMIUM_ANDROID_CSS 30373
+#define IDR_UASTYLE_MEDIA_CONTROLS_ANDROID_CSS 30374
+#define IDR_UASTYLE_MEDIA_CONTROLS_ANDROID_NEW_CSS 30375
+#define IDR_UASTYLE_THEME_CHROMIUM_LINUX_CSS 30376
+#define IDR_UASTYLE_THEME_MAC_CSS 30377
+#define IDR_UASTYLE_THEME_INPUT_MULTIPLE_FIELDS_CSS 30378
+#define IDR_UASTYLE_THEME_WIN_CSS 30379
+#define IDR_UASTYLE_THEME_WIN_QUIRKS_CSS 30380
+#define IDR_UASTYLE_SVG_CSS 30381
+#define IDR_UASTYLE_MATHML_CSS 30382
+#define IDR_UASTYLE_MEDIA_CONTROLS_CSS 30383
+#define IDR_UASTYLE_MEDIA_CONTROLS_NEW_CSS 30384
+#define IDR_UASTYLE_FULLSCREEN_CSS 30385
+#define IDR_UASTYLE_XHTMLMP_CSS 30386
+#define IDR_UASTYLE_VIEWPORT_ANDROID_CSS 30387
+#define IDR_INSPECTOR_OVERLAY_PAGE_HTML 30388
+#define IDR_INSPECTOR_INJECTED_SCRIPT_SOURCE_JS 30389
+#define IDR_INSPECTOR_DEBUGGER_SCRIPT_SOURCE_JS 30390
+#define IDR_PRIVATE_SCRIPT_DOCUMENTEXECCOMMAND_JS 30391
+#define IDR_PRIVATE_SCRIPT_DOCUMENTXMLTREEVIEWER_CSS 30392
+#define IDR_PRIVATE_SCRIPT_DOCUMENTXMLTREEVIEWER_JS 30393
+#define IDR_PRIVATE_SCRIPT_HTMLMARQUEEELEMENT_JS 30394
+#define IDR_PRIVATE_SCRIPT_PRIVATESCRIPTRUNNER_JS 30395
+#define IDR_PICKER_COMMON_JS 30396
+#define IDR_PICKER_COMMON_CSS 30397
+#define IDR_CALENDAR_PICKER_CSS 30398
+#define IDR_CALENDAR_PICKER_JS 30399
+#define IDR_PICKER_BUTTON_CSS 30400
+#define IDR_SUGGESTION_PICKER_CSS 30401
+#define IDR_SUGGESTION_PICKER_JS 30402
+#define IDR_COLOR_SUGGESTION_PICKER_CSS 30403
+#define IDR_COLOR_SUGGESTION_PICKER_JS 30404
+#define IDR_LIST_PICKER_CSS 30405
+#define IDR_LIST_PICKER_JS 30406
+#define IDR_AUDIO_SPATIALIZATION_COMPOSITE 30407
+#define IDR_AUDIO_SPATIALIZATION_T000_P000 30408
+#define IDR_AUDIO_SPATIALIZATION_T000_P015 30409
+#define IDR_AUDIO_SPATIALIZATION_T000_P030 30410
+#define IDR_AUDIO_SPATIALIZATION_T000_P045 30411
+#define IDR_AUDIO_SPATIALIZATION_T000_P060 30412
+#define IDR_AUDIO_SPATIALIZATION_T000_P075 30413
+#define IDR_AUDIO_SPATIALIZATION_T000_P090 30414
+#define IDR_AUDIO_SPATIALIZATION_T000_P315 30415
+#define IDR_AUDIO_SPATIALIZATION_T000_P330 30416
+#define IDR_AUDIO_SPATIALIZATION_T000_P345 30417
+#define IDR_AUDIO_SPATIALIZATION_T015_P000 30418
+#define IDR_AUDIO_SPATIALIZATION_T015_P015 30419
+#define IDR_AUDIO_SPATIALIZATION_T015_P030 30420
+#define IDR_AUDIO_SPATIALIZATION_T015_P045 30421
+#define IDR_AUDIO_SPATIALIZATION_T015_P060 30422
+#define IDR_AUDIO_SPATIALIZATION_T015_P075 30423
+#define IDR_AUDIO_SPATIALIZATION_T015_P090 30424
+#define IDR_AUDIO_SPATIALIZATION_T015_P315 30425
+#define IDR_AUDIO_SPATIALIZATION_T015_P330 30426
+#define IDR_AUDIO_SPATIALIZATION_T015_P345 30427
+#define IDR_AUDIO_SPATIALIZATION_T030_P000 30428
+#define IDR_AUDIO_SPATIALIZATION_T030_P015 30429
+#define IDR_AUDIO_SPATIALIZATION_T030_P030 30430
+#define IDR_AUDIO_SPATIALIZATION_T030_P045 30431
+#define IDR_AUDIO_SPATIALIZATION_T030_P060 30432
+#define IDR_AUDIO_SPATIALIZATION_T030_P075 30433
+#define IDR_AUDIO_SPATIALIZATION_T030_P090 30434
+#define IDR_AUDIO_SPATIALIZATION_T030_P315 30435
+#define IDR_AUDIO_SPATIALIZATION_T030_P330 30436
+#define IDR_AUDIO_SPATIALIZATION_T030_P345 30437
+#define IDR_AUDIO_SPATIALIZATION_T045_P000 30438
+#define IDR_AUDIO_SPATIALIZATION_T045_P015 30439
+#define IDR_AUDIO_SPATIALIZATION_T045_P030 30440
+#define IDR_AUDIO_SPATIALIZATION_T045_P045 30441
+#define IDR_AUDIO_SPATIALIZATION_T045_P060 30442
+#define IDR_AUDIO_SPATIALIZATION_T045_P075 30443
+#define IDR_AUDIO_SPATIALIZATION_T045_P090 30444
+#define IDR_AUDIO_SPATIALIZATION_T045_P315 30445
+#define IDR_AUDIO_SPATIALIZATION_T045_P330 30446
+#define IDR_AUDIO_SPATIALIZATION_T045_P345 30447
+#define IDR_AUDIO_SPATIALIZATION_T060_P000 30448
+#define IDR_AUDIO_SPATIALIZATION_T060_P015 30449
+#define IDR_AUDIO_SPATIALIZATION_T060_P030 30450
+#define IDR_AUDIO_SPATIALIZATION_T060_P045 30451
+#define IDR_AUDIO_SPATIALIZATION_T060_P060 30452
+#define IDR_AUDIO_SPATIALIZATION_T060_P075 30453
+#define IDR_AUDIO_SPATIALIZATION_T060_P090 30454
+#define IDR_AUDIO_SPATIALIZATION_T060_P315 30455
+#define IDR_AUDIO_SPATIALIZATION_T060_P330 30456
+#define IDR_AUDIO_SPATIALIZATION_T060_P345 30457
+#define IDR_AUDIO_SPATIALIZATION_T075_P000 30458
+#define IDR_AUDIO_SPATIALIZATION_T075_P015 30459
+#define IDR_AUDIO_SPATIALIZATION_T075_P030 30460
+#define IDR_AUDIO_SPATIALIZATION_T075_P045 30461
+#define IDR_AUDIO_SPATIALIZATION_T075_P060 30462
+#define IDR_AUDIO_SPATIALIZATION_T075_P075 30463
+#define IDR_AUDIO_SPATIALIZATION_T075_P090 30464
+#define IDR_AUDIO_SPATIALIZATION_T075_P315 30465
+#define IDR_AUDIO_SPATIALIZATION_T075_P330 30466
+#define IDR_AUDIO_SPATIALIZATION_T075_P345 30467
+#define IDR_AUDIO_SPATIALIZATION_T090_P000 30468
+#define IDR_AUDIO_SPATIALIZATION_T090_P015 30469
+#define IDR_AUDIO_SPATIALIZATION_T090_P030 30470
+#define IDR_AUDIO_SPATIALIZATION_T090_P045 30471
+#define IDR_AUDIO_SPATIALIZATION_T090_P060 30472
+#define IDR_AUDIO_SPATIALIZATION_T090_P075 30473
+#define IDR_AUDIO_SPATIALIZATION_T090_P090 30474
+#define IDR_AUDIO_SPATIALIZATION_T090_P315 30475
+#define IDR_AUDIO_SPATIALIZATION_T090_P330 30476
+#define IDR_AUDIO_SPATIALIZATION_T090_P345 30477
+#define IDR_AUDIO_SPATIALIZATION_T105_P000 30478
+#define IDR_AUDIO_SPATIALIZATION_T105_P015 30479
+#define IDR_AUDIO_SPATIALIZATION_T105_P030 30480
+#define IDR_AUDIO_SPATIALIZATION_T105_P045 30481
+#define IDR_AUDIO_SPATIALIZATION_T105_P060 30482
+#define IDR_AUDIO_SPATIALIZATION_T105_P075 30483
+#define IDR_AUDIO_SPATIALIZATION_T105_P090 30484
+#define IDR_AUDIO_SPATIALIZATION_T105_P315 30485
+#define IDR_AUDIO_SPATIALIZATION_T105_P330 30486
+#define IDR_AUDIO_SPATIALIZATION_T105_P345 30487
+#define IDR_AUDIO_SPATIALIZATION_T120_P000 30488
+#define IDR_AUDIO_SPATIALIZATION_T120_P015 30489
+#define IDR_AUDIO_SPATIALIZATION_T120_P030 30490
+#define IDR_AUDIO_SPATIALIZATION_T120_P045 30491
+#define IDR_AUDIO_SPATIALIZATION_T120_P060 30492
+#define IDR_AUDIO_SPATIALIZATION_T120_P075 30493
+#define IDR_AUDIO_SPATIALIZATION_T120_P090 30494
+#define IDR_AUDIO_SPATIALIZATION_T120_P315 30495
+#define IDR_AUDIO_SPATIALIZATION_T120_P330 30496
+#define IDR_AUDIO_SPATIALIZATION_T120_P345 30497
+#define IDR_AUDIO_SPATIALIZATION_T135_P000 30498
+#define IDR_AUDIO_SPATIALIZATION_T135_P015 30499
+#define IDR_AUDIO_SPATIALIZATION_T135_P030 30500
+#define IDR_AUDIO_SPATIALIZATION_T135_P045 30501
+#define IDR_AUDIO_SPATIALIZATION_T135_P060 30502
+#define IDR_AUDIO_SPATIALIZATION_T135_P075 30503
+#define IDR_AUDIO_SPATIALIZATION_T135_P090 30504
+#define IDR_AUDIO_SPATIALIZATION_T135_P315 30505
+#define IDR_AUDIO_SPATIALIZATION_T135_P330 30506
+#define IDR_AUDIO_SPATIALIZATION_T135_P345 30507
+#define IDR_AUDIO_SPATIALIZATION_T150_P000 30508
+#define IDR_AUDIO_SPATIALIZATION_T150_P015 30509
+#define IDR_AUDIO_SPATIALIZATION_T150_P030 30510
+#define IDR_AUDIO_SPATIALIZATION_T150_P045 30511
+#define IDR_AUDIO_SPATIALIZATION_T150_P060 30512
+#define IDR_AUDIO_SPATIALIZATION_T150_P075 30513
+#define IDR_AUDIO_SPATIALIZATION_T150_P090 30514
+#define IDR_AUDIO_SPATIALIZATION_T150_P315 30515
+#define IDR_AUDIO_SPATIALIZATION_T150_P330 30516
+#define IDR_AUDIO_SPATIALIZATION_T150_P345 30517
+#define IDR_AUDIO_SPATIALIZATION_T165_P000 30518
+#define IDR_AUDIO_SPATIALIZATION_T165_P015 30519
+#define IDR_AUDIO_SPATIALIZATION_T165_P030 30520
+#define IDR_AUDIO_SPATIALIZATION_T165_P045 30521
+#define IDR_AUDIO_SPATIALIZATION_T165_P060 30522
+#define IDR_AUDIO_SPATIALIZATION_T165_P075 30523
+#define IDR_AUDIO_SPATIALIZATION_T165_P090 30524
+#define IDR_AUDIO_SPATIALIZATION_T165_P315 30525
+#define IDR_AUDIO_SPATIALIZATION_T165_P330 30526
+#define IDR_AUDIO_SPATIALIZATION_T165_P345 30527
+#define IDR_AUDIO_SPATIALIZATION_T180_P000 30528
+#define IDR_AUDIO_SPATIALIZATION_T180_P015 30529
+#define IDR_AUDIO_SPATIALIZATION_T180_P030 30530
+#define IDR_AUDIO_SPATIALIZATION_T180_P045 30531
+#define IDR_AUDIO_SPATIALIZATION_T180_P060 30532
+#define IDR_AUDIO_SPATIALIZATION_T180_P075 30533
+#define IDR_AUDIO_SPATIALIZATION_T180_P090 30534
+#define IDR_AUDIO_SPATIALIZATION_T180_P315 30535
+#define IDR_AUDIO_SPATIALIZATION_T180_P330 30536
+#define IDR_AUDIO_SPATIALIZATION_T180_P345 30537
+#define IDR_AUDIO_SPATIALIZATION_T195_P000 30538
+#define IDR_AUDIO_SPATIALIZATION_T195_P015 30539
+#define IDR_AUDIO_SPATIALIZATION_T195_P030 30540
+#define IDR_AUDIO_SPATIALIZATION_T195_P045 30541
+#define IDR_AUDIO_SPATIALIZATION_T195_P060 30542
+#define IDR_AUDIO_SPATIALIZATION_T195_P075 30543
+#define IDR_AUDIO_SPATIALIZATION_T195_P090 30544
+#define IDR_AUDIO_SPATIALIZATION_T195_P315 30545
+#define IDR_AUDIO_SPATIALIZATION_T195_P330 30546
+#define IDR_AUDIO_SPATIALIZATION_T195_P345 30547
+#define IDR_AUDIO_SPATIALIZATION_T210_P000 30548
+#define IDR_AUDIO_SPATIALIZATION_T210_P015 30549
+#define IDR_AUDIO_SPATIALIZATION_T210_P030 30550
+#define IDR_AUDIO_SPATIALIZATION_T210_P045 30551
+#define IDR_AUDIO_SPATIALIZATION_T210_P060 30552
+#define IDR_AUDIO_SPATIALIZATION_T210_P075 30553
+#define IDR_AUDIO_SPATIALIZATION_T210_P090 30554
+#define IDR_AUDIO_SPATIALIZATION_T210_P315 30555
+#define IDR_AUDIO_SPATIALIZATION_T210_P330 30556
+#define IDR_AUDIO_SPATIALIZATION_T210_P345 30557
+#define IDR_AUDIO_SPATIALIZATION_T225_P000 30558
+#define IDR_AUDIO_SPATIALIZATION_T225_P015 30559
+#define IDR_AUDIO_SPATIALIZATION_T225_P030 30560
+#define IDR_AUDIO_SPATIALIZATION_T225_P045 30561
+#define IDR_AUDIO_SPATIALIZATION_T225_P060 30562
+#define IDR_AUDIO_SPATIALIZATION_T225_P075 30563
+#define IDR_AUDIO_SPATIALIZATION_T225_P090 30564
+#define IDR_AUDIO_SPATIALIZATION_T225_P315 30565
+#define IDR_AUDIO_SPATIALIZATION_T225_P330 30566
+#define IDR_AUDIO_SPATIALIZATION_T225_P345 30567
+#define IDR_AUDIO_SPATIALIZATION_T240_P000 30568
+#define IDR_AUDIO_SPATIALIZATION_T240_P015 30569
+#define IDR_AUDIO_SPATIALIZATION_T240_P030 30570
+#define IDR_AUDIO_SPATIALIZATION_T240_P045 30571
+#define IDR_AUDIO_SPATIALIZATION_T240_P060 30572
+#define IDR_AUDIO_SPATIALIZATION_T240_P075 30573
+#define IDR_AUDIO_SPATIALIZATION_T240_P090 30574
+#define IDR_AUDIO_SPATIALIZATION_T240_P315 30575
+#define IDR_AUDIO_SPATIALIZATION_T240_P330 30576
+#define IDR_AUDIO_SPATIALIZATION_T240_P345 30577
+#define IDR_AUDIO_SPATIALIZATION_T255_P000 30578
+#define IDR_AUDIO_SPATIALIZATION_T255_P015 30579
+#define IDR_AUDIO_SPATIALIZATION_T255_P030 30580
+#define IDR_AUDIO_SPATIALIZATION_T255_P045 30581
+#define IDR_AUDIO_SPATIALIZATION_T255_P060 30582
+#define IDR_AUDIO_SPATIALIZATION_T255_P075 30583
+#define IDR_AUDIO_SPATIALIZATION_T255_P090 30584
+#define IDR_AUDIO_SPATIALIZATION_T255_P315 30585
+#define IDR_AUDIO_SPATIALIZATION_T255_P330 30586
+#define IDR_AUDIO_SPATIALIZATION_T255_P345 30587
+#define IDR_AUDIO_SPATIALIZATION_T270_P000 30588
+#define IDR_AUDIO_SPATIALIZATION_T270_P015 30589
+#define IDR_AUDIO_SPATIALIZATION_T270_P030 30590
+#define IDR_AUDIO_SPATIALIZATION_T270_P045 30591
+#define IDR_AUDIO_SPATIALIZATION_T270_P060 30592
+#define IDR_AUDIO_SPATIALIZATION_T270_P075 30593
+#define IDR_AUDIO_SPATIALIZATION_T270_P090 30594
+#define IDR_AUDIO_SPATIALIZATION_T270_P315 30595
+#define IDR_AUDIO_SPATIALIZATION_T270_P330 30596
+#define IDR_AUDIO_SPATIALIZATION_T270_P345 30597
+#define IDR_AUDIO_SPATIALIZATION_T285_P000 30598
+#define IDR_AUDIO_SPATIALIZATION_T285_P015 30599
+#define IDR_AUDIO_SPATIALIZATION_T285_P030 30600
+#define IDR_AUDIO_SPATIALIZATION_T285_P045 30601
+#define IDR_AUDIO_SPATIALIZATION_T285_P060 30602
+#define IDR_AUDIO_SPATIALIZATION_T285_P075 30603
+#define IDR_AUDIO_SPATIALIZATION_T285_P090 30604
+#define IDR_AUDIO_SPATIALIZATION_T285_P315 30605
+#define IDR_AUDIO_SPATIALIZATION_T285_P330 30606
+#define IDR_AUDIO_SPATIALIZATION_T285_P345 30607
+#define IDR_AUDIO_SPATIALIZATION_T300_P000 30608
+#define IDR_AUDIO_SPATIALIZATION_T300_P015 30609
+#define IDR_AUDIO_SPATIALIZATION_T300_P030 30610
+#define IDR_AUDIO_SPATIALIZATION_T300_P045 30611
+#define IDR_AUDIO_SPATIALIZATION_T300_P060 30612
+#define IDR_AUDIO_SPATIALIZATION_T300_P075 30613
+#define IDR_AUDIO_SPATIALIZATION_T300_P090 30614
+#define IDR_AUDIO_SPATIALIZATION_T300_P315 30615
+#define IDR_AUDIO_SPATIALIZATION_T300_P330 30616
+#define IDR_AUDIO_SPATIALIZATION_T300_P345 30617
+#define IDR_AUDIO_SPATIALIZATION_T315_P000 30618
+#define IDR_AUDIO_SPATIALIZATION_T315_P015 30619
+#define IDR_AUDIO_SPATIALIZATION_T315_P030 30620
+#define IDR_AUDIO_SPATIALIZATION_T315_P045 30621
+#define IDR_AUDIO_SPATIALIZATION_T315_P060 30622
+#define IDR_AUDIO_SPATIALIZATION_T315_P075 30623
+#define IDR_AUDIO_SPATIALIZATION_T315_P090 30624
+#define IDR_AUDIO_SPATIALIZATION_T315_P315 30625
+#define IDR_AUDIO_SPATIALIZATION_T315_P330 30626
+#define IDR_AUDIO_SPATIALIZATION_T315_P345 30627
+#define IDR_AUDIO_SPATIALIZATION_T330_P000 30628
+#define IDR_AUDIO_SPATIALIZATION_T330_P015 30629
+#define IDR_AUDIO_SPATIALIZATION_T330_P030 30630
+#define IDR_AUDIO_SPATIALIZATION_T330_P045 30631
+#define IDR_AUDIO_SPATIALIZATION_T330_P060 30632
+#define IDR_AUDIO_SPATIALIZATION_T330_P075 30633
+#define IDR_AUDIO_SPATIALIZATION_T330_P090 30634
+#define IDR_AUDIO_SPATIALIZATION_T330_P315 30635
+#define IDR_AUDIO_SPATIALIZATION_T330_P330 30636
+#define IDR_AUDIO_SPATIALIZATION_T330_P345 30637
+#define IDR_AUDIO_SPATIALIZATION_T345_P000 30638
+#define IDR_AUDIO_SPATIALIZATION_T345_P015 30639
+#define IDR_AUDIO_SPATIALIZATION_T345_P030 30640
+#define IDR_AUDIO_SPATIALIZATION_T345_P045 30641
+#define IDR_AUDIO_SPATIALIZATION_T345_P060 30642
+#define IDR_AUDIO_SPATIALIZATION_T345_P075 30643
+#define IDR_AUDIO_SPATIALIZATION_T345_P090 30644
+#define IDR_AUDIO_SPATIALIZATION_T345_P315 30645
+#define IDR_AUDIO_SPATIALIZATION_T345_P330 30646
+#define IDR_AUDIO_SPATIALIZATION_T345_P345 30647
+
+// ---------------------------------------------------------------------------
+// From cef_resources.h:
+
+#define IDR_CEF_DEVTOOLS_DISCOVERY_PAGE 27500
+#define IDR_CEF_LICENSE_TXT 27501
+#define IDR_CEF_VERSION_HTML 27502
+#define IDR_CEF_EXTENSION_API_FEATURES 27503
+#define IDR_PDF_MANIFEST 27504
+#define IDR_BLOCKED_PLUGIN_HTML 27505
+#define IDR_PLUGIN_POSTER_HTML 27506
+#define IDR_PLUGIN_DB_JSON 27507
+
+// ---------------------------------------------------------------------------
+// From component_extension_resources.h:
+
+#define IDR_BOOKMARK_MANAGER_MAIN 1450
+#define IDR_HOTWORD_AUDIO_VERIFICATION_MAIN 1451
+#define IDR_WALLPAPER_MANAGER_MAIN 1452
+#define IDR_FIRST_RUN_DIALOG_MAIN 1453
+#define IDR_NETWORK_SPEECH_SYNTHESIS_JS 1000
+#define IDR_BRAILLE_IME_JS 1001
+#define IDR_BRAILLE_IME_MAIN_JS 1002
+#define IDR_BOOKMARK_MANAGER_BOOKMARK_MANAGER_SEARCH 1003
+#define IDR_BOOKMARK_MANAGER_BOOKMARK_MANAGER_SEARCH_RTL 1004
+#define IDR_BOOKMARK_MANAGER_BOOKMARK_MAIN_JS 1005
+#define IDR_BOOKMARK_MANAGER_BOOKMARK_BMM_LIST_JS 1006
+#define IDR_BOOKMARK_MANAGER_BOOKMARK_BMM_TREE_JS 1007
+#define IDR_BOOKMARK_MANAGER_BOOKMARK_DND_JS 1008
+#define IDR_BOOKMARK_MANAGER_BOOKMARK_BMM_JS 1009
+#define IDR_GAIA_AUTH_MAIN 1010
+#define IDR_GAIA_AUTH_MAIN_JS 1011
+#define IDR_GAIA_AUTH_MAIN_CSS 1012
+#define IDR_GAIA_AUTH_OFFLINE 1013
+#define IDR_GAIA_AUTH_OFFLINE_JS 1014
+#define IDR_GAIA_AUTH_OFFLINE_CSS 1015
+#define IDR_GAIA_AUTH_SUCCESS 1016
+#define IDR_GAIA_AUTH_UTIL_JS 1017
+#define IDR_GAIA_AUTH_BACKGROUND_JS 1018
+#define IDR_GAIA_AUTH_SAML_INJECTED_JS 1019
+#define IDR_GAIA_AUTH_CHANNEL_JS 1020
+#define IDR_HANGOUT_SERVICES_BACKGROUND_HTML 1021
+#define IDR_HANGOUT_SERVICES_THUNK_JS 1022
+#define IDR_HOTWORD_AUDIO_VERIFICATION_BACKGROUND_JS 1023
+#define IDR_HOTWORD_AUDIO_VERIFICATION_MAIN_JS 1024
+#define IDR_HOTWORD_AUDIO_VERIFICATION_FLOW_JS 1025
+#define IDR_START_STEP_HTML 1026
+#define IDR_AUDIO_HISTORY_STEP_HTML 1027
+#define IDR_SPEECH_TRAINING_STEP_HTML 1028
+#define IDR_FINISHED_STEP_HTML 1029
+#define IDR_HOTWORD_AUDIO_VERIFICATION_STYLE_CSS 1030
+#define IDR_HOTWORD_AUDIO_VERIFICATION_IMAGE_CLOSE_1X 1031
+#define IDR_HOTWORD_AUDIO_VERIFICATION_IMAGE_CLOSE_2X 1032
+#define IDR_HOTWORD_AUDIO_VERIFICATION_IMAGE_INTRO_1X 1033
+#define IDR_HOTWORD_AUDIO_VERIFICATION_IMAGE_INTRO_2X 1034
+#define IDR_HOTWORD_AUDIO_VERIFICATION_IMAGE_HEADER_1X 1035
+#define IDR_HOTWORD_AUDIO_VERIFICATION_IMAGE_HEADER_2X 1036
+#define IDR_HOTWORD_AUDIO_VERIFICATION_IMAGE_CHECK_BLUE_1X 1037
+#define IDR_HOTWORD_AUDIO_VERIFICATION_IMAGE_CHECK_BLUE_2X 1038
+#define IDR_HOTWORD_AUDIO_VERIFICATION_IMAGE_CHECK_GRAY_1X 1039
+#define IDR_HOTWORD_AUDIO_VERIFICATION_IMAGE_CHECK_GRAY_2X 1040
+#define IDR_HOTWORD_AUDIO_VERIFICATION_IMAGE_LOADER_1X 1041
+#define IDR_HOTWORD_AUDIO_VERIFICATION_IMAGE_LOADER_2X 1042
+#define IDR_HOTWORD_AUDIO_VERIFICATION_IMAGE_ERROR_1X 1043
+#define IDR_HOTWORD_AUDIO_VERIFICATION_IMAGE_ERROR_2X 1044
+#define IDR_HOTWORD_AUDIO_VERIFICATION_IMAGE_ICON_16 1045
+#define IDR_HOTWORD_AUDIO_VERIFICATION_IMAGE_ICON_48 1046
+#define IDR_HOTWORD_AUDIO_VERIFICATION_IMAGE_ICON_128 1047
+#define IDR_HOTWORD_ALWAYS_ON_MANAGER_JS 1048
+#define IDR_HOTWORD_AUDIO_CLIENT_JS 1049
+#define IDR_HOTWORD_BASE_SESSION_MANAGER_JS 1050
+#define IDR_HOTWORD_CONSTANTS_JS 1051
+#define IDR_HOTWORD_KEEP_ALIVE_JS 1052
+#define IDR_HOTWORD_LAUNCHER_MANAGER_JS 1053
+#define IDR_HOTWORD_LOGGING_JS 1054
+#define IDR_HOTWORD_MANAGER_JS 1055
+#define IDR_HOTWORD_METRICS_JS 1056
+#define IDR_HOTWORD_NACL_MANAGER_JS 1057
+#define IDR_HOTWORD_PAGE_AUDIO_MANAGER_JS 1058
+#define IDR_HOTWORD_STATE_MANAGER_JS 1059
+#define IDR_HOTWORD_TRAINING_MANAGER_JS 1060
+#define IDR_FEEDBACK_DEFAULT_HTML 1061
+#define IDR_FEEDBACK_SYSINFO_HTML 1062
+#define IDR_FEEDBACK_EVENT_HANDLER_JS 1063
+#define IDR_FEEDBACK_FEEDBACK_JS 1064
+#define IDR_FEEDBACK_SYSINFO_JS 1065
+#define IDR_FEEDBACK_TAKE_SCREENSHOT_JS 1066
+#define IDR_FEEDBACK_TOPBAR_HANDLER_JS 1067
+#define IDR_FEEDBACK_FEEDBACK_CSS 1068
+#define IDR_FEEDBACK_ICON_32 1069
+#define IDR_FEEDBACK_ICON_64 1070
+#define IDR_GOOGLE_NOW_BACKGROUND_JS 1071
+#define IDR_GOOGLE_NOW_CARDS_JS 1072
+#define IDR_GOOGLE_NOW_UTILITY_JS 1073
+#define IDR_GOOGLE_NOW_ICON_16 1074
+#define IDR_GOOGLE_NOW_ICON_48 1075
+#define IDR_GOOGLE_NOW_ICON_128 1076
+#define IDR_IDENTITY_API_SCOPE_APPROVAL_BACKGROUND_JS 1077
+#define IDR_IDENTITY_API_SCOPE_APPROVAL_DIALOG_CSS 1078
+#define IDR_IDENTITY_API_SCOPE_APPROVAL_DIALOG 1079
+#define IDR_IDENTITY_API_SCOPE_APPROVAL_DIALOG_JS 1080
+#define IDR_WALLPAPER_MANAGER_CONSTANTS_JS 1081
+#define IDR_WALLPAPER_MANAGER_EVENT_JS 1082
+#define IDR_WALLPAPER_MANAGER_ICON_16 1083
+#define IDR_WALLPAPER_MANAGER_ICON_32 1084
+#define IDR_WALLPAPER_MANAGER_ICON_48 1085
+#define IDR_WALLPAPER_MANAGER_ICON_64 1086
+#define IDR_WALLPAPER_MANAGER_ICON_96 1087
+#define IDR_WALLPAPER_MANAGER_ICON_128 1088
+#define IDR_WALLPAPER_MANAGER_ICON_256 1089
+#define IDR_WALLPAPER_MANAGER_MAIN_JS 1090
+#define IDR_WALLPAPER_MANAGER_UTIL_JS 1091
+#define IDR_FIRST_RUN_DIALOG_BACKGROUND_JS 1092
+#define IDR_FIRST_RUN_DIALOG_MAIN_JS 1093
+#define IDR_FIRST_RUN_DIALOG_ICON_16 1094
+#define IDR_FIRST_RUN_DIALOG_ICON_32 1095
+#define IDR_FIRST_RUN_DIALOG_ICON_48 1096
+#define IDR_FIRST_RUN_DIALOG_ICON_64 1097
+#define IDR_FIRST_RUN_DIALOG_ICON_96 1098
+#define IDR_FIRST_RUN_DIALOG_ICON_128 1099
+#define IDR_FIRST_RUN_DIALOG_ICON_256 1100
+#define IDR_SETTINGS_APP_JS 1101
+#define IDR_PDF_INDEX_CSS 1102
+#define IDR_PDF_INDEX_HTML 1103
+#define IDR_PDF_MAIN_JS 1104
+#define IDR_PDF_PDF_JS 1105
+#define IDR_PDF_UI_MANAGER_JS 1106
+#define IDR_PDF_VIEWPORT_JS 1107
+#define IDR_PDF_OPEN_PDF_PARAMS_PARSER_JS 1108
+#define IDR_PDF_NAVIGATOR_JS 1109
+#define IDR_PDF_VIEWPORT_SCROLLER_JS 1110
+#define IDR_PDF_PDF_SCRIPTING_API_JS 1111
+#define IDR_PDF_ZOOM_MANAGER_JS 1112
+#define IDR_PDF_BROWSER_API_JS 1113
+#define IDR_PDF_CONTENT_SCRIPT_JS 1114
+#define IDR_PDF_SHARED_ICON_STYLE_CSS 1115
+#define IDR_PDF_VIEWER_BOOKMARK_CSS 1116
+#define IDR_PDF_VIEWER_BOOKMARK_HTML 1117
+#define IDR_PDF_VIEWER_BOOKMARK_JS 1118
+#define IDR_PDF_VIEWER_BOOKMARKS_CONTENT_HTML 1119
+#define IDR_PDF_VIEWER_BOOKMARKS_CONTENT_JS 1120
+#define IDR_PDF_VIEWER_ERROR_SCREEN_CSS 1121
+#define IDR_PDF_VIEWER_ERROR_SCREEN_HTML 1122
+#define IDR_PDF_VIEWER_ERROR_SCREEN_JS 1123
+#define IDR_PDF_VIEWER_PAGE_INDICATOR_CSS 1124
+#define IDR_PDF_VIEWER_PAGE_INDICATOR_HTML 1125
+#define IDR_PDF_VIEWER_PAGE_INDICATOR_JS 1126
+#define IDR_PDF_VIEWER_PAGE_SELECTOR_CSS 1127
+#define IDR_PDF_VIEWER_PAGE_SELECTOR_HTML 1128
+#define IDR_PDF_VIEWER_PAGE_SELECTOR_JS 1129
+#define IDR_PDF_VIEWER_PASSWORD_SCREEN_HTML 1130
+#define IDR_PDF_VIEWER_PASSWORD_SCREEN_JS 1131
+#define IDR_PDF_VIEWER_PDF_TOOLBAR_CSS 1132
+#define IDR_PDF_VIEWER_PDF_TOOLBAR_HTML 1133
+#define IDR_PDF_VIEWER_PDF_TOOLBAR_JS 1134
+#define IDR_PDF_VIEWER_TOOLBAR_DROPDOWN_CSS 1135
+#define IDR_PDF_VIEWER_TOOLBAR_DROPDOWN_HTML 1136
+#define IDR_PDF_VIEWER_TOOLBAR_DROPDOWN_JS 1137
+#define IDR_PDF_VIEWER_ZOOM_BUTTON_CSS 1138
+#define IDR_PDF_VIEWER_ZOOM_BUTTON_HTML 1139
+#define IDR_PDF_VIEWER_ZOOM_BUTTON_JS 1140
+#define IDR_PDF_VIEWER_ZOOM_SELECTOR_CSS 1141
+#define IDR_PDF_VIEWER_ZOOM_SELECTOR_HTML 1142
+#define IDR_PDF_VIEWER_ZOOM_SELECTOR_JS 1143
+#define IDR_CRYPTOTOKEN_UTIL_JS 1144
+#define IDR_CRYPTOTOKEN_B64_JS 1145
+#define IDR_CRYPTOTOKEN_CLOSEABLE_JS 1146
+#define IDR_CRYPTOTOKEN_COUNTDOWN_JS 1147
+#define IDR_CRYPTOTOKEN_COUNTDOWNTIMER_JS 1148
+#define IDR_CRYPTOTOKEN_SHA256_JS 1149
+#define IDR_CRYPTOTOKEN_TIMER_JS 1150
+#define IDR_CRYPTOTOKEN_HIDGNUBBYDEVICE_JS 1151
+#define IDR_CRYPTOTOKEN_USBGNUBBYDEVICE_JS 1152
+#define IDR_CRYPTOTOKEN_GNUBBIES_JS 1153
+#define IDR_CRYPTOTOKEN_GNUBBY_JS 1154
+#define IDR_CRYPTOTOKEN_GNUBBY_U2F_JS 1155
+#define IDR_CRYPTOTOKEN_GNUBBYCODETYPES_JS 1156
+#define IDR_CRYPTOTOKEN_GNUBBYFACTORY_JS 1157
+#define IDR_CRYPTOTOKEN_GNUBBYMSGTYPES_JS 1158
+#define IDR_CRYPTOTOKEN_USBGNUBBYFACTORY_JS 1159
+#define IDR_CRYPTOTOKEN_DEVICESTATUSCODES_JS 1160
+#define IDR_CRYPTOTOKEN_ENROLLER_JS 1161
+#define IDR_CRYPTOTOKEN_USBENROLLHANDLER_JS 1162
+#define IDR_CRYPTOTOKEN_REQUESTQUEUE_JS 1163
+#define IDR_CRYPTOTOKEN_SIGNER_JS 1164
+#define IDR_CRYPTOTOKEN_SINGLESIGNER_JS 1165
+#define IDR_CRYPTOTOKEN_MULTIPLESIGNER_JS 1166
+#define IDR_CRYPTOTOKEN_USBSIGNHANDLER_JS 1167
+#define IDR_CRYPTOTOKEN_WEBREQUEST_JS 1168
+#define IDR_CRYPTOTOKEN_APPID_JS 1169
+#define IDR_CRYPTOTOKEN_USBHELPER_JS 1170
+#define IDR_CRYPTOTOKEN_TEXTFETCHER_JS 1171
+#define IDR_CRYPTOTOKEN_REQUESTHELPER_JS 1172
+#define IDR_CRYPTOTOKEN_MESSAGETYPES_JS 1173
+#define IDR_CRYPTOTOKEN_INHERITS_JS 1174
+#define IDR_CRYPTOTOKEN_GNUBBYDEVICE_JS 1175
+#define IDR_CRYPTOTOKEN_GENERICHELPER_JS 1176
+#define IDR_CRYPTOTOKEN_FACTORYREGISTRY_JS 1177
+#define IDR_CRYPTOTOKEN_ERRORCODES_JS 1178
+#define IDR_CRYPTOTOKEN_DEVICEFACTORYREGISTRY_JS 1179
+#define IDR_CRYPTOTOKEN_ORIGINCHECK_JS 1180
+#define IDR_CRYPTOTOKEN_INDIVIDUALATTEST_JS 1181
+#define IDR_CRYPTOTOKEN_GOOGLECORPINDIVIDUALATTEST_JS 1182
+#define IDR_CRYPTOTOKEN_APPROVEDORIGINS_JS 1183
+#define IDR_CRYPTOTOKEN_WEBREQUESTSENDER_JS 1184
+#define IDR_CRYPTOTOKEN_WINDOW_TIMER_JS 1185
+#define IDR_CRYPTOTOKEN_WATCHDOG_JS 1186
+#define IDR_CRYPTOTOKEN_LOGGING_JS 1187
+#define IDR_CRYPTOTOKEN_CRYPTOTOKENAPPROVEDORIGIN_JS 1188
+#define IDR_CRYPTOTOKEN_CRYPTOTOKENORIGINCHECK_JS 1189
+#define IDR_CRYPTOTOKEN_CRYPTOTOKENBACKGROUND_JS 1190
+#define IDR_WHISPERNET_PROXY_BACKGROUND_HTML 1191
+#define IDR_WHISPERNET_PROXY_INIT_JS 1192
+#define IDR_WHISPERNET_PROXY_NACL_JS 1193
+#define IDR_WHISPERNET_PROXY_WRAPPER_JS 1194
+#define IDR_WHISPERNET_PROXY_WHISPERNET_PROXY_PROXY_NMF 1195
+#define IDR_WHISPERNET_PROXY_WHISPERNET_PROXY_PROXY_PEXE 1196
+
+// ---------------------------------------------------------------------------
+// From content_resources.h:
+
+#define IDR_ACCESSIBILITY_HTML 24150
+#define IDR_ACCESSIBILITY_CSS 24151
+#define IDR_ACCESSIBILITY_JS 24152
+#define IDR_APPCACHE_INTERNALS_HTML 24153
+#define IDR_APPCACHE_INTERNALS_JS 24154
+#define IDR_APPCACHE_INTERNALS_CSS 24155
+#define IDR_DEVTOOLS_PINCH_CURSOR_ICON 24156
+#define IDR_DEVTOOLS_PINCH_CURSOR_ICON_2X 24157
+#define IDR_DEVTOOLS_TOUCH_CURSOR_ICON 24158
+#define IDR_DEVTOOLS_TOUCH_CURSOR_ICON_2X 24159
+#define IDR_GPU_INTERNALS_HTML 24160
+#define IDR_GPU_INTERNALS_JS 24161
+#define IDR_INDEXED_DB_INTERNALS_HTML 24162
+#define IDR_INDEXED_DB_INTERNALS_JS 24163
+#define IDR_INDEXED_DB_INTERNALS_CSS 24164
+#define IDR_MEDIA_INTERNALS_HTML 24165
+#define IDR_MEDIA_INTERNALS_JS 24166
+#define IDR_NETWORK_ERROR_LISTING_HTML 24167
+#define IDR_NETWORK_ERROR_LISTING_JS 24168
+#define IDR_NETWORK_ERROR_LISTING_CSS 24169
+#define IDR_SERVICE_WORKER_INTERNALS_HTML 24170
+#define IDR_SERVICE_WORKER_INTERNALS_JS 24171
+#define IDR_SERVICE_WORKER_INTERNALS_CSS 24172
+#define IDR_WEBRTC_INTERNALS_HTML 24173
+#define IDR_WEBRTC_INTERNALS_JS 24174
+#define IDR_GPU_SANDBOX_PROFILE 24175
+#define IDR_COMMON_SANDBOX_PROFILE 24176
+#define IDR_PPAPI_SANDBOX_PROFILE 24177
+#define IDR_RENDERER_SANDBOX_PROFILE 24178
+#define IDR_UTILITY_SANDBOX_PROFILE 24179
+#define IDR_MOJO_BINDINGS_JS 24180
+#define IDR_MOJO_BUFFER_JS 24181
+#define IDR_MOJO_CODEC_JS 24182
+#define IDR_MOJO_CONNECTION_JS 24183
+#define IDR_MOJO_CONNECTOR_JS 24184
+#define IDR_MOJO_ROUTER_JS 24185
+#define IDR_MOJO_UNICODE_JS 24186
+#define IDR_MOJO_VALIDATOR_JS 24187
+
+// ---------------------------------------------------------------------------
+// From devtools_resources.h:
+
+#define INSPECTOR_CSS 21650
+#define INSPECTOR_HTML 21651
+#define INSPECTOR_JS 21652
+#define TOOLBOX_CSS 21653
+#define TOOLBOX_HTML 21654
+#define TOOLBOX_JS 21655
+#define ACCESSIBILITY_MODULE_JS 21656
+#define ANIMATION_MODULE_JS 21657
+#define AUDITS_MODULE_JS 21658
+#define COMPONENTS_LAZY_MODULE_JS 21659
+#define CONSOLE_MODULE_JS 21660
+#define DEVICES_MODULE_JS 21661
+#define DIFF_MODULE_JS 21662
+#define ELEMENTS_MODULE_JS 21663
+#define HEAP_SNAPSHOT_WORKER_MODULE_JS 21664
+#define LAYERS_MODULE_JS 21665
+#define NETWORK_MODULE_JS 21666
+#define PROFILER_MODULE_JS 21667
+#define PROMISES_MODULE_JS 21668
+#define RESOURCES_MODULE_JS 21669
+#define SECURITY_MODULE_JS 21670
+#define SCRIPT_FORMATTER_WORKER_MODULE_JS 21671
+#define SETTINGS_MODULE_JS 21672
+#define SNIPPETS_MODULE_JS 21673
+#define SOURCE_FRAME_MODULE_JS 21674
+#define SOURCES_MODULE_JS 21675
+#define TEMP_STORAGE_SHARED_WORKER_MODULE_JS 21676
+#define TIMELINE_MODULE_JS 21677
+#define UI_LAZY_MODULE_JS 21678
+#define DEVTOOLS_EXTENSION_API_JS 21679
+#define DEVTOOLS_JS 21680
+#define IMAGES_APPLICATIONCACHE_PNG 21681
+#define IMAGES_BREAKPOINT_PNG 21682
+#define IMAGES_BREAKPOINTCONDITIONAL_PNG 21683
+#define IMAGES_BREAKPOINTCONDITIONAL_2X_PNG 21684
+#define IMAGES_BREAKPOINT_2X_PNG 21685
+#define IMAGES_CHECKER_PNG 21686
+#define IMAGES_CHROMEDISABLEDSELECT_PNG 21687
+#define IMAGES_CHROMEDISABLEDSELECT_2X_PNG 21688
+#define IMAGES_CHROMELEFT_PNG 21689
+#define IMAGES_CHROMEMIDDLE_PNG 21690
+#define IMAGES_CHROMERIGHT_PNG 21691
+#define IMAGES_CHROMESELECT_PNG 21692
+#define IMAGES_CHROMESELECT_2X_PNG 21693
+#define IMAGES_COOKIE_PNG 21694
+#define IMAGES_DATABASE_PNG 21695
+#define IMAGES_DATABASETABLE_PNG 21696
+#define IMAGES_DELETEICON_PNG 21697
+#define IMAGES_DOMAIN_PNG 21698
+#define IMAGES_ERRORWAVE_PNG 21699
+#define IMAGES_ERRORWAVE_2X_PNG 21700
+#define IMAGES_FILESYSTEM_PNG 21701
+#define IMAGES_FORWARD_PNG 21702
+#define IMAGES_FRAME_PNG 21703
+#define IMAGES_GRAPHLABELCALLOUTLEFT_PNG 21704
+#define IMAGES_GRAPHLABELCALLOUTRIGHT_PNG 21705
+#define IMAGES_IC_INFO_BLACK_18DP_SVG 21706
+#define IMAGES_IC_WARNING_BLACK_18DP_SVG 21707
+#define IMAGES_INDEXEDDB_PNG 21708
+#define IMAGES_INDEXEDDBINDEX_PNG 21709
+#define IMAGES_INDEXEDDBOBJECTSTORE_PNG 21710
+#define IMAGES_LOCALSTORAGE_PNG 21711
+#define IMAGES_NAVIGATIONCONTROLS_PNG 21712
+#define IMAGES_NAVIGATIONCONTROLS_2X_PNG 21713
+#define IMAGES_NOTIFICATIONS_SVG 21714
+#define IMAGES_PANEADDBUTTONS_PNG 21715
+#define IMAGES_PANEFILTERBUTTONS_PNG 21716
+#define IMAGES_PANEREFRESHBUTTONS_PNG 21717
+#define IMAGES_POPOVERARROWS_PNG 21718
+#define IMAGES_PROFILEGROUPICON_PNG 21719
+#define IMAGES_PROFILEICON_PNG 21720
+#define IMAGES_PROFILESMALLICON_PNG 21721
+#define IMAGES_RADIODOT_PNG 21722
+#define IMAGES_RESIZEDIAGONAL_PNG 21723
+#define IMAGES_RESIZEDIAGONAL_2X_PNG 21724
+#define IMAGES_RESIZEHORIZONTAL_PNG 21725
+#define IMAGES_RESIZEHORIZONTAL_2X_PNG 21726
+#define IMAGES_RESIZEVERTICAL_PNG 21727
+#define IMAGES_RESIZEVERTICAL_2X_PNG 21728
+#define IMAGES_RESOURCECSSICON_PNG 21729
+#define IMAGES_RESOURCEDOCUMENTICON_PNG 21730
+#define IMAGES_RESOURCEDOCUMENTICONSMALL_PNG 21731
+#define IMAGES_RESOURCEJSICON_PNG 21732
+#define IMAGES_RESOURCEPLAINICON_PNG 21733
+#define IMAGES_RESOURCEPLAINICONSMALL_PNG 21734
+#define IMAGES_RESOURCESTIMEGRAPHICON_PNG 21735
+#define IMAGES_RESPONSIVEDESIGN_PNG 21736
+#define IMAGES_RESPONSIVEDESIGN_2X_PNG 21737
+#define IMAGES_SEARCHNEXT_PNG 21738
+#define IMAGES_SEARCHPREV_PNG 21739
+#define IMAGES_SECURITYPROPERTYINFO_SVG 21740
+#define IMAGES_SECURITYPROPERTYINSECURE_SVG 21741
+#define IMAGES_SECURITYPROPERTYSECURE_SVG 21742
+#define IMAGES_SECURITYPROPERTYUNKNOWN_SVG 21743
+#define IMAGES_SECURITYPROPERTYWARNING_SVG 21744
+#define IMAGES_SECURITYSTATEINSECURE_SVG 21745
+#define IMAGES_SECURITYSTATENEUTRAL_SVG 21746
+#define IMAGES_SECURITYSTATESECURE_SVG 21747
+#define IMAGES_SERVICEWORKER_SVG 21748
+#define IMAGES_SESSIONSTORAGE_PNG 21749
+#define IMAGES_SETTINGSLISTREMOVE_PNG 21750
+#define IMAGES_SETTINGSLISTREMOVE_2X_PNG 21751
+#define IMAGES_SPEECH_PNG 21752
+#define IMAGES_TOOLBARBUTTONGLYPHS_PNG 21753
+#define IMAGES_TOOLBARBUTTONGLYPHS_2X_PNG 21754
+#define IMAGES_TOOLBARITEMSELECTED_PNG 21755
+#define IMAGES_TOOLBARRESIZERHORIZONTAL_PNG 21756
+#define IMAGES_TOOLBARRESIZERVERTICAL_PNG 21757
+#define IMAGES_TOUCHCURSOR_PNG 21758
+#define IMAGES_TOUCHCURSOR_2X_PNG 21759
+#define IMAGES_TRANSFORMCONTROLS_PNG 21760
+#define IMAGES_TRANSFORMCONTROLS_2X_PNG 21761
+#define IMAGES_UPDATESERVICEWORKER_SVG 21762
+
+// ---------------------------------------------------------------------------
+// From extensions_browser_resources.h:
+
+#define IDR_APP_DEFAULT_ICON 25950
+#define IDR_EXTENSION_DEFAULT_ICON 25951
+#define IDR_EXTENSION_ACTION_PLAIN_BACKGROUND 25952
+#define IDR_EXTENSION_ICON_PLAIN_BACKGROUND 25953
+
+// ---------------------------------------------------------------------------
+// From extensions_renderer_resources.h:
+
+#define IDR_APP_VIEW_JS 26000
+#define IDR_ASYNC_WAITER_JS 26001
+#define IDR_BROWSER_TEST_ENVIRONMENT_SPECIFIC_BINDINGS_JS 26002
+#define IDR_DATA_RECEIVER_JS 26003
+#define IDR_DATA_SENDER_JS 26004
+#define IDR_DATA_STREAM_MOJOM_JS 26005
+#define IDR_DATA_STREAM_SERIALIZATION_MOJOM_JS 26006
+#define IDR_ENTRY_ID_MANAGER 26007
+#define IDR_EVENT_BINDINGS_JS 26008
+#define IDR_EXTENSION_OPTIONS_JS 26009
+#define IDR_EXTENSION_OPTIONS_ATTRIBUTES_JS 26010
+#define IDR_EXTENSION_OPTIONS_CONSTANTS_JS 26011
+#define IDR_EXTENSION_OPTIONS_EVENTS_JS 26012
+#define IDR_EXTENSION_VIEW_JS 26013
+#define IDR_EXTENSION_VIEW_API_METHODS_JS 26014
+#define IDR_EXTENSION_VIEW_ATTRIBUTES_JS 26015
+#define IDR_EXTENSION_VIEW_CONSTANTS_JS 26016
+#define IDR_EXTENSION_VIEW_EVENTS_JS 26017
+#define IDR_EXTENSION_VIEW_INTERNAL_CUSTOM_BINDINGS_JS 26018
+#define IDR_GUEST_VIEW_ATTRIBUTES_JS 26019
+#define IDR_GUEST_VIEW_CONTAINER_JS 26020
+#define IDR_GUEST_VIEW_DENY_JS 26021
+#define IDR_GUEST_VIEW_EVENTS_JS 26022
+#define IDR_GUEST_VIEW_IFRAME_CONTAINER_JS 26023
+#define IDR_GUEST_VIEW_IFRAME_JS 26024
+#define IDR_GUEST_VIEW_JS 26025
+#define IDR_IMAGE_UTIL_JS 26026
+#define IDR_JSON_SCHEMA_JS 26027
+#define IDR_KEEP_ALIVE_JS 26028
+#define IDR_KEEP_ALIVE_MOJOM_JS 26029
+#define IDR_LAST_ERROR_JS 26030
+#define IDR_MESSAGING_JS 26031
+#define IDR_MESSAGING_UTILS_JS 26032
+#define IDR_MIME_HANDLER_PRIVATE_CUSTOM_BINDINGS_JS 26033
+#define IDR_MIME_HANDLER_MOJOM_JS 26034
+#define IDR_SCHEMA_UTILS_JS 26035
+#define IDR_SEND_REQUEST_JS 26036
+#define IDR_SERIAL_CUSTOM_BINDINGS_JS 26037
+#define IDR_SERIAL_MOJOM_JS 26038
+#define IDR_SERIAL_SERIALIZATION_MOJOM_JS 26039
+#define IDR_SERIAL_SERVICE_JS 26040
+#define IDR_SET_ICON_JS 26041
+#define IDR_STASH_CLIENT_JS 26042
+#define IDR_STASH_MOJOM_JS 26043
+#define IDR_TEST_CUSTOM_BINDINGS_JS 26044
+#define IDR_UNCAUGHT_EXCEPTION_HANDLER_JS 26045
+#define IDR_UTILS_JS 26046
+#define IDR_WEB_VIEW_ACTION_REQUESTS_JS 26047
+#define IDR_WEB_VIEW_API_METHODS_JS 26048
+#define IDR_WEB_VIEW_ATTRIBUTES_JS 26049
+#define IDR_WEB_VIEW_CONSTANTS_JS 26050
+#define IDR_WEB_VIEW_EVENTS_JS 26051
+#define IDR_WEB_VIEW_IFRAME_JS 26052
+#define IDR_WEB_VIEW_INTERNAL_CUSTOM_BINDINGS_JS 26053
+#define IDR_WEB_VIEW_JS 26054
+#define IDR_APP_RUNTIME_CUSTOM_BINDINGS_JS 26055
+#define IDR_APP_WINDOW_CUSTOM_BINDINGS_JS 26056
+#define IDR_BINDING_JS 26057
+#define IDR_CONTEXT_MENUS_CUSTOM_BINDINGS_JS 26058
+#define IDR_CONTEXT_MENUS_HANDLERS_JS 26059
+#define IDR_DECLARATIVE_WEBREQUEST_CUSTOM_BINDINGS_JS 26060
+#define IDR_DISPLAY_SOURCE_CUSTOM_BINDINGS_JS 26061
+#define IDR_EXTENSION_CUSTOM_BINDINGS_JS 26062
+#define IDR_GREASEMONKEY_API_JS 26063
+#define IDR_I18N_CUSTOM_BINDINGS_JS 26064
+#define IDR_MOJO_PRIVATE_CUSTOM_BINDINGS_JS 26065
+#define IDR_PERMISSIONS_CUSTOM_BINDINGS_JS 26066
+#define IDR_PRINTER_PROVIDER_CUSTOM_BINDINGS_JS 26067
+#define IDR_RUNTIME_CUSTOM_BINDINGS_JS 26068
+#define IDR_SERVICE_WORKER_BINDINGS_JS 26069
+#define IDR_WEB_REQUEST_CUSTOM_BINDINGS_JS 26070
+#define IDR_WEB_REQUEST_INTERNAL_CUSTOM_BINDINGS_JS 26071
+#define IDR_WINDOW_CONTROLS_JS 26072
+#define IDR_WINDOW_CONTROLS_TEMPLATE_HTML 26073
+#define IDR_WEB_VIEW_REQUEST_CUSTOM_BINDINGS_JS 26074
+#define IDR_STORAGE_AREA_JS 26075
+#define IDR_PLATFORM_APP_CSS 26076
+#define IDR_PLATFORM_APP_JS 26077
+#define IDR_EXTENSION_FONTS_CSS 26078
+#define IDR_MEDIA_ROUTER_MOJOM_JS 26079
+#define IDR_MEDIA_ROUTER_BINDINGS_JS 26080
+#define IDR_EXTENSION_CSS 26100
+
+// ---------------------------------------------------------------------------
+// From extensions_resources.h:
+
+#define IDR_EXTENSION_API_FEATURES 25750
+#define IDR_EXTENSION_API_JSON_DECLARATIVE_WEBREQUEST 25751
+#define IDR_EXTENSION_API_JSON_WEB_VIEW_REQUEST 25752
+#define IDR_EXTENSION_MANIFEST_FEATURES 25753
+#define IDR_EXTENSION_PERMISSION_FEATURES 25754
+#define IDR_EXTENSION_BEHAVIOR_FEATURES 25755
+
+// ---------------------------------------------------------------------------
+// From net_resources.h:
+
+#define IDR_DIR_HEADER_HTML 4000
+
+// ---------------------------------------------------------------------------
+// From ui_resources.h:
+
+#define IDR_AURA_CURSOR_BIG_ALIAS 5500
+#define IDR_AURA_CURSOR_BIG_CELL 5501
+#define IDR_AURA_CURSOR_BIG_COL_RESIZE 5502
+#define IDR_AURA_CURSOR_BIG_CONTEXT_MENU 5503
+#define IDR_AURA_CURSOR_BIG_COPY 5504
+#define IDR_AURA_CURSOR_BIG_CROSSHAIR 5505
+#define IDR_AURA_CURSOR_BIG_EAST_RESIZE 5506
+#define IDR_AURA_CURSOR_BIG_EAST_WEST_RESIZE 5507
+#define IDR_AURA_CURSOR_BIG_HAND 5508
+#define IDR_AURA_CURSOR_BIG_HELP 5509
+#define IDR_AURA_CURSOR_BIG_IBEAM 5510
+#define IDR_AURA_CURSOR_BIG_MOVE 5511
+#define IDR_AURA_CURSOR_BIG_NORTH_EAST_RESIZE 5512
+#define IDR_AURA_CURSOR_BIG_NORTH_EAST_SOUTH_WEST_RESIZE 5513
+#define IDR_AURA_CURSOR_BIG_NORTH_RESIZE 5514
+#define IDR_AURA_CURSOR_BIG_NORTH_SOUTH_RESIZE 5515
+#define IDR_AURA_CURSOR_BIG_NORTH_WEST_RESIZE 5516
+#define IDR_AURA_CURSOR_BIG_NORTH_WEST_SOUTH_EAST_RESIZE 5517
+#define IDR_AURA_CURSOR_BIG_NO_DROP 5518
+#define IDR_AURA_CURSOR_BIG_PTR 5519
+#define IDR_AURA_CURSOR_BIG_ROW_RESIZE 5520
+#define IDR_AURA_CURSOR_BIG_SOUTH_EAST_RESIZE 5521
+#define IDR_AURA_CURSOR_BIG_SOUTH_RESIZE 5522
+#define IDR_AURA_CURSOR_BIG_SOUTH_WEST_RESIZE 5523
+#define IDR_AURA_CURSOR_BIG_WEST_RESIZE 5524
+#define IDR_AURA_CURSOR_BIG_XTERM_HORIZ 5525
+#define IDR_AURA_CURSOR_BIG_ZOOM_IN 5526
+#define IDR_AURA_CURSOR_BIG_ZOOM_OUT 5527
+#define IDR_AURA_CURSOR_BIG_GRAB 5528
+#define IDR_AURA_CURSOR_BIG_GRABBING 5529
+#define IDR_AURA_CURSOR_ALIAS 5530
+#define IDR_AURA_CURSOR_CELL 5531
+#define IDR_AURA_CURSOR_COL_RESIZE 5532
+#define IDR_AURA_CURSOR_CONTEXT_MENU 5533
+#define IDR_AURA_CURSOR_COPY 5534
+#define IDR_AURA_CURSOR_CROSSHAIR 5535
+#define IDR_AURA_CURSOR_EAST_RESIZE 5536
+#define IDR_AURA_CURSOR_EAST_WEST_RESIZE 5537
+#define IDR_AURA_CURSOR_HAND 5538
+#define IDR_AURA_CURSOR_HELP 5539
+#define IDR_AURA_CURSOR_IBEAM 5540
+#define IDR_AURA_CURSOR_MOVE 5541
+#define IDR_AURA_CURSOR_NORTH_EAST_RESIZE 5542
+#define IDR_AURA_CURSOR_NORTH_EAST_SOUTH_WEST_RESIZE 5543
+#define IDR_AURA_CURSOR_NORTH_RESIZE 5544
+#define IDR_AURA_CURSOR_NORTH_SOUTH_RESIZE 5545
+#define IDR_AURA_CURSOR_NORTH_WEST_RESIZE 5546
+#define IDR_AURA_CURSOR_NORTH_WEST_SOUTH_EAST_RESIZE 5547
+#define IDR_AURA_CURSOR_NO_DROP 5548
+#define IDR_AURA_CURSOR_PTR 5549
+#define IDR_AURA_CURSOR_ROW_RESIZE 5550
+#define IDR_AURA_CURSOR_SOUTH_EAST_RESIZE 5551
+#define IDR_AURA_CURSOR_SOUTH_RESIZE 5552
+#define IDR_AURA_CURSOR_SOUTH_WEST_RESIZE 5553
+#define IDR_AURA_CURSOR_THROBBER 5554
+#define IDR_AURA_CURSOR_WEST_RESIZE 5555
+#define IDR_AURA_CURSOR_XTERM_HORIZ 5556
+#define IDR_AURA_CURSOR_ZOOM_IN 5557
+#define IDR_AURA_CURSOR_ZOOM_OUT 5558
+#define IDR_AURA_CURSOR_GRAB 5559
+#define IDR_AURA_CURSOR_GRABBING 5560
+#define IDR_AURA_SHADOW_ACTIVE 5561
+#define IDR_AURA_SHADOW_INACTIVE 5562
+#define IDR_WINDOW_BUBBLE_SHADOW_SMALL 5563
+#define IDR_BACK_ARROW 5564
+#define IDR_FORWARD_ARROW 5565
+#define IDR_BROWSER_ACTION_BADGE_CENTER 5566
+#define IDR_BROWSER_ACTION_BADGE_LEFT 5567
+#define IDR_BROWSER_ACTION_BADGE_RIGHT 5568
+#define IDR_CLOSE_2 5569
+#define IDR_CLOSE_2_H 5570
+#define IDR_CLOSE_2_MASK 5571
+#define IDR_CLOSE_2_P 5572
+#define IDR_CLOSE_3_MASK 5573
+#define IDR_CLOSE_4_BUTTON 5574
+#define IDR_CLOSE_DIALOG 5575
+#define IDR_CLOSE_DIALOG_H 5576
+#define IDR_CLOSE_DIALOG_P 5577
+#define IDR_DISABLE 5578
+#define IDR_DISABLE_H 5579
+#define IDR_DISABLE_P 5580
+#define IDR_DEFAULT_FAVICON 5581
+#define IDR_DEFAULT_FAVICON_32 5582
+#define IDR_DEFAULT_FAVICON_64 5583
+#define IDR_EASY_UNLOCK_HARDLOCKED 5584
+#define IDR_EASY_UNLOCK_HARDLOCKED_HOVER 5585
+#define IDR_EASY_UNLOCK_HARDLOCKED_PRESSED 5586
+#define IDR_EASY_UNLOCK_LOCKED 5587
+#define IDR_EASY_UNLOCK_LOCKED_HOVER 5588
+#define IDR_EASY_UNLOCK_LOCKED_PRESSED 5589
+#define IDR_EASY_UNLOCK_LOCKED_TO_BE_ACTIVATED 5590
+#define IDR_EASY_UNLOCK_LOCKED_TO_BE_ACTIVATED_HOVER 5591
+#define IDR_EASY_UNLOCK_LOCKED_TO_BE_ACTIVATED_PRESSED 5592
+#define IDR_EASY_UNLOCK_LOCKED_WITH_PROXIMITY_HINT 5593
+#define IDR_EASY_UNLOCK_LOCKED_WITH_PROXIMITY_HINT_HOVER 5594
+#define IDR_EASY_UNLOCK_LOCKED_WITH_PROXIMITY_HINT_PRESSED 5595
+#define IDR_EASY_UNLOCK_SPINNER 5596
+#define IDR_EASY_UNLOCK_UNLOCKED 5597
+#define IDR_EASY_UNLOCK_UNLOCKED_HOVER 5598
+#define IDR_EASY_UNLOCK_UNLOCKED_PRESSED 5599
+#define IDR_FOLDER_CLOSED 5600
+#define IDR_FOLDER_CLOSED_RTL 5601
+#define IDR_MENU_CHECK_CHECKED 5602
+#define IDR_MENU_HIERARCHY_ARROW 5603
+#define IDR_MENU_DROPARROW 5604
+#define IDR_MESSAGE_CLOSE 5605
+#define IDR_NOTIFICATION_ARROW 5606
+#define IDR_NOTIFICATION_ARROW_HOVER 5607
+#define IDR_NOTIFICATION_ARROW_PRESSED 5608
+#define IDR_NOTIFICATION_ADVANCED_SETTINGS 5609
+#define IDR_NOTIFICATION_ADVANCED_SETTINGS_HOVER 5610
+#define IDR_NOTIFICATION_ADVANCED_SETTINGS_PRESSED 5611
+#define IDR_NOTIFICATION_CLEAR_ALL 5612
+#define IDR_NOTIFICATION_CLEAR_ALL_DISABLED 5613
+#define IDR_NOTIFICATION_CLEAR_ALL_HOVER 5614
+#define IDR_NOTIFICATION_CLEAR_ALL_PRESSED 5615
+#define IDR_NOTIFICATION_CLOSE 5616
+#define IDR_NOTIFICATION_CLOSE_HOVER 5617
+#define IDR_NOTIFICATION_CLOSE_PRESSED 5618
+#define IDR_NOTIFICATION_BUBBLE_CLOSE 5619
+#define IDR_NOTIFICATION_BUBBLE_CLOSE_HOVER 5620
+#define IDR_NOTIFICATION_BUBBLE_CLOSE_PRESSED 5621
+#define IDR_NOTIFICATION_DO_NOT_DISTURB 5622
+#define IDR_NOTIFICATION_DO_NOT_DISTURB_HOVER 5623
+#define IDR_NOTIFICATION_DO_NOT_DISTURB_PRESSED 5624
+#define IDR_NOTIFICATION_SETTINGS 5625
+#define IDR_NOTIFICATION_SETTINGS_BUTTON_ICON 5626
+#define IDR_NOTIFICATION_SETTINGS_BUTTON_ICON_HOVER 5627
+#define IDR_NOTIFICATION_SETTINGS_BUTTON_ICON_PRESSED 5628
+#define IDR_NOTIFICATION_SETTINGS_HOVER 5629
+#define IDR_NOTIFICATION_SETTINGS_PRESSED 5630
+#define IDR_NTP_DEFAULT_FAVICON 5631
+#define IDR_OOBE_ACTION_BOX_BUTTON_HOVER 5632
+#define IDR_OOBE_ACTION_BOX_BUTTON_NORMAL 5633
+#define IDR_OOBE_ACTION_BOX_BUTTON_PRESSED 5634
+#define IDR_PANEL_TOP_LEFT_CORNER 5635
+#define IDR_PANEL_TOP_RIGHT_CORNER 5636
+#define IDR_PANEL_BOTTOM_LEFT_CORNER 5637
+#define IDR_PANEL_BOTTOM_RIGHT_CORNER 5638
+#define IDR_TEXT_SELECTION_HANDLE_CENTER 5639
+#define IDR_TEXT_SELECTION_HANDLE_LEFT 5640
+#define IDR_TEXT_SELECTION_HANDLE_RIGHT 5641
+#define IDR_THROBBER 5642
+#define IDR_TOUCH_DRAG_TIP_COPY 5643
+#define IDR_TOUCH_DRAG_TIP_MOVE 5644
+#define IDR_TOUCH_DRAG_TIP_LINK 5645
+#define IDR_TOUCH_DRAG_TIP_NODROP 5646
+
+// ---------------------------------------------------------------------------
+// From views_resources.h:
+
+#define IDR_APP_TOP_CENTER 5800
+#define IDR_APP_TOP_LEFT 5801
+#define IDR_APP_TOP_RIGHT 5802
+#define IDR_BUBBLE_B 5803
+#define IDR_BUBBLE_BL 5804
+#define IDR_BUBBLE_BR 5805
+#define IDR_BUBBLE_B_ARROW 5806
+#define IDR_BUBBLE_L 5807
+#define IDR_BUBBLE_L_ARROW 5808
+#define IDR_BUBBLE_R 5809
+#define IDR_BUBBLE_R_ARROW 5810
+#define IDR_BUBBLE_T 5811
+#define IDR_BUBBLE_TL 5812
+#define IDR_BUBBLE_TR 5813
+#define IDR_BUBBLE_T_ARROW 5814
+#define IDR_BUTTON_DISABLED 5815
+#define IDR_BUTTON_FOCUSED_HOVER 5816
+#define IDR_BUTTON_FOCUSED_NORMAL 5817
+#define IDR_BUTTON_FOCUSED_PRESSED 5818
+#define IDR_BUTTON_HOVER 5819
+#define IDR_BUTTON_NORMAL 5820
+#define IDR_BUTTON_PRESSED 5821
+#define IDR_BLUE_BUTTON_DISABLED 5822
+#define IDR_BLUE_BUTTON_FOCUSED_HOVER 5823
+#define IDR_BLUE_BUTTON_FOCUSED_NORMAL 5824
+#define IDR_BLUE_BUTTON_FOCUSED_PRESSED 5825
+#define IDR_BLUE_BUTTON_HOVER 5826
+#define IDR_BLUE_BUTTON_NORMAL 5827
+#define IDR_BLUE_BUTTON_PRESSED 5828
+#define IDR_CHECKBOX 5829
+#define IDR_CHECKBOX_CHECKED 5830
+#define IDR_CHECKBOX_CHECKED_DISABLED 5831
+#define IDR_CHECKBOX_CHECKED_HOVER 5832
+#define IDR_CHECKBOX_CHECKED_PRESSED 5833
+#define IDR_CHECKBOX_DISABLED 5834
+#define IDR_CHECKBOX_FOCUSED 5835
+#define IDR_CHECKBOX_FOCUSED_CHECKED 5836
+#define IDR_CHECKBOX_FOCUSED_CHECKED_HOVER 5837
+#define IDR_CHECKBOX_FOCUSED_CHECKED_PRESSED 5838
+#define IDR_CHECKBOX_FOCUSED_HOVER 5839
+#define IDR_CHECKBOX_FOCUSED_PRESSED 5840
+#define IDR_CHECKBOX_HOVER 5841
+#define IDR_CHECKBOX_PRESSED 5842
+#define IDR_CLOSE 5843
+#define IDR_CLOSE_H 5844
+#define IDR_CLOSE_P 5845
+#define IDR_COMBOBOX_BUTTON_BOTTOM 5846
+#define IDR_COMBOBOX_BUTTON_H_BOTTOM 5847
+#define IDR_COMBOBOX_BUTTON_P_BOTTOM 5848
+#define IDR_COMBOBOX_BUTTON_BOTTOM_LEFT 5849
+#define IDR_COMBOBOX_BUTTON_H_BOTTOM_LEFT 5850
+#define IDR_COMBOBOX_BUTTON_P_BOTTOM_LEFT 5851
+#define IDR_COMBOBOX_BUTTON_BOTTOM_RIGHT 5852
+#define IDR_COMBOBOX_BUTTON_H_BOTTOM_RIGHT 5853
+#define IDR_COMBOBOX_BUTTON_P_BOTTOM_RIGHT 5854
+#define IDR_COMBOBOX_BUTTON_CENTER 5855
+#define IDR_COMBOBOX_BUTTON_H_CENTER 5856
+#define IDR_COMBOBOX_BUTTON_P_CENTER 5857
+#define IDR_COMBOBOX_BUTTON_LEFT 5858
+#define IDR_COMBOBOX_BUTTON_H_LEFT 5859
+#define IDR_COMBOBOX_BUTTON_P_LEFT 5860
+#define IDR_COMBOBOX_BUTTON_RIGHT 5861
+#define IDR_COMBOBOX_BUTTON_H_RIGHT 5862
+#define IDR_COMBOBOX_BUTTON_P_RIGHT 5863
+#define IDR_COMBOBOX_BUTTON_MENU_BOTTOM 5864
+#define IDR_COMBOBOX_BUTTON_H_MENU_BOTTOM 5865
+#define IDR_COMBOBOX_BUTTON_P_MENU_BOTTOM 5866
+#define IDR_COMBOBOX_BUTTON_MENU_CENTER 5867
+#define IDR_COMBOBOX_BUTTON_H_MENU_CENTER 5868
+#define IDR_COMBOBOX_BUTTON_P_MENU_CENTER 5869
+#define IDR_COMBOBOX_BUTTON_MENU_TOP 5870
+#define IDR_COMBOBOX_BUTTON_H_MENU_TOP 5871
+#define IDR_COMBOBOX_BUTTON_P_MENU_TOP 5872
+#define IDR_COMBOBOX_BUTTON_TOP 5873
+#define IDR_COMBOBOX_BUTTON_H_TOP 5874
+#define IDR_COMBOBOX_BUTTON_P_TOP 5875
+#define IDR_COMBOBOX_BUTTON_TOP_LEFT 5876
+#define IDR_COMBOBOX_BUTTON_H_TOP_LEFT 5877
+#define IDR_COMBOBOX_BUTTON_P_TOP_LEFT 5878
+#define IDR_COMBOBOX_BUTTON_TOP_RIGHT 5879
+#define IDR_COMBOBOX_BUTTON_H_TOP_RIGHT 5880
+#define IDR_COMBOBOX_BUTTON_P_TOP_RIGHT 5881
+#define IDR_COMBOBOX_BUTTON_F_BOTTOM 5882
+#define IDR_COMBOBOX_BUTTON_F_H_BOTTOM 5883
+#define IDR_COMBOBOX_BUTTON_F_P_BOTTOM 5884
+#define IDR_COMBOBOX_BUTTON_F_BOTTOM_LEFT 5885
+#define IDR_COMBOBOX_BUTTON_F_H_BOTTOM_LEFT 5886
+#define IDR_COMBOBOX_BUTTON_F_P_BOTTOM_LEFT 5887
+#define IDR_COMBOBOX_BUTTON_F_BOTTOM_RIGHT 5888
+#define IDR_COMBOBOX_BUTTON_F_H_BOTTOM_RIGHT 5889
+#define IDR_COMBOBOX_BUTTON_F_P_BOTTOM_RIGHT 5890
+#define IDR_COMBOBOX_BUTTON_F_CENTER 5891
+#define IDR_COMBOBOX_BUTTON_F_H_CENTER 5892
+#define IDR_COMBOBOX_BUTTON_F_P_CENTER 5893
+#define IDR_COMBOBOX_BUTTON_F_LEFT 5894
+#define IDR_COMBOBOX_BUTTON_F_H_LEFT 5895
+#define IDR_COMBOBOX_BUTTON_F_P_LEFT 5896
+#define IDR_COMBOBOX_BUTTON_F_RIGHT 5897
+#define IDR_COMBOBOX_BUTTON_F_H_RIGHT 5898
+#define IDR_COMBOBOX_BUTTON_F_P_RIGHT 5899
+#define IDR_COMBOBOX_BUTTON_F_MENU_BOTTOM 5900
+#define IDR_COMBOBOX_BUTTON_F_H_MENU_BOTTOM 5901
+#define IDR_COMBOBOX_BUTTON_F_P_MENU_BOTTOM 5902
+#define IDR_COMBOBOX_BUTTON_F_MENU_CENTER 5903
+#define IDR_COMBOBOX_BUTTON_F_H_MENU_CENTER 5904
+#define IDR_COMBOBOX_BUTTON_F_P_MENU_CENTER 5905
+#define IDR_COMBOBOX_BUTTON_F_MENU_TOP 5906
+#define IDR_COMBOBOX_BUTTON_F_H_MENU_TOP 5907
+#define IDR_COMBOBOX_BUTTON_F_P_MENU_TOP 5908
+#define IDR_COMBOBOX_BUTTON_F_TOP 5909
+#define IDR_COMBOBOX_BUTTON_F_H_TOP 5910
+#define IDR_COMBOBOX_BUTTON_F_P_TOP 5911
+#define IDR_COMBOBOX_BUTTON_F_TOP_LEFT 5912
+#define IDR_COMBOBOX_BUTTON_F_H_TOP_LEFT 5913
+#define IDR_COMBOBOX_BUTTON_F_P_TOP_LEFT 5914
+#define IDR_COMBOBOX_BUTTON_F_TOP_RIGHT 5915
+#define IDR_COMBOBOX_BUTTON_F_H_TOP_RIGHT 5916
+#define IDR_COMBOBOX_BUTTON_F_P_TOP_RIGHT 5917
+#define IDR_CONTENT_BOTTOM_CENTER 5918
+#define IDR_CONTENT_BOTTOM_LEFT_CORNER 5919
+#define IDR_CONTENT_BOTTOM_RIGHT_CORNER 5920
+#define IDR_CONTENT_LEFT_SIDE 5921
+#define IDR_CONTENT_RIGHT_SIDE 5922
+#define IDR_FOLDER_OPEN 5923
+#define IDR_FOLDER_OPEN_RTL 5924
+#define IDR_FRAME 5925
+#define IDR_FRAME_INACTIVE 5926
+#define IDR_MAXIMIZE 5927
+#define IDR_MAXIMIZE_H 5928
+#define IDR_MAXIMIZE_P 5929
+#define IDR_MENU_CHECK 5930
+#define IDR_MENU_RADIO_EMPTY 5931
+#define IDR_MENU_RADIO_SELECTED 5932
+#define IDR_SLIDER_ACTIVE_LEFT 5933
+#define IDR_SLIDER_ACTIVE_RIGHT 5934
+#define IDR_SLIDER_ACTIVE_CENTER 5935
+#define IDR_SLIDER_DISABLED_LEFT 5936
+#define IDR_SLIDER_DISABLED_RIGHT 5937
+#define IDR_SLIDER_DISABLED_CENTER 5938
+#define IDR_SLIDER_PRESSED_LEFT 5939
+#define IDR_SLIDER_PRESSED_RIGHT 5940
+#define IDR_SLIDER_PRESSED_CENTER 5941
+#define IDR_SLIDER_ACTIVE_THUMB 5942
+#define IDR_SLIDER_DISABLED_THUMB 5943
+#define IDR_MINIMIZE 5944
+#define IDR_MINIMIZE_H 5945
+#define IDR_MINIMIZE_P 5946
+#define IDR_RADIO 5947
+#define IDR_RADIO_CHECKED 5948
+#define IDR_RADIO_CHECKED_DISABLED 5949
+#define IDR_RADIO_CHECKED_HOVER 5950
+#define IDR_RADIO_CHECKED_PRESSED 5951
+#define IDR_RADIO_DISABLED 5952
+#define IDR_RADIO_FOCUSED 5953
+#define IDR_RADIO_FOCUSED_CHECKED 5954
+#define IDR_RADIO_FOCUSED_CHECKED_HOVER 5955
+#define IDR_RADIO_FOCUSED_CHECKED_PRESSED 5956
+#define IDR_RADIO_FOCUSED_HOVER 5957
+#define IDR_RADIO_FOCUSED_PRESSED 5958
+#define IDR_RADIO_HOVER 5959
+#define IDR_RADIO_PRESSED 5960
+#define IDR_RESTORE 5961
+#define IDR_RESTORE_H 5962
+#define IDR_RESTORE_P 5963
+#define IDR_TEXTBUTTON_HOVER_BOTTOM 5964
+#define IDR_TEXTBUTTON_HOVER_BOTTOM_LEFT 5965
+#define IDR_TEXTBUTTON_HOVER_BOTTOM_RIGHT 5966
+#define IDR_TEXTBUTTON_HOVER_CENTER 5967
+#define IDR_TEXTBUTTON_HOVER_LEFT 5968
+#define IDR_TEXTBUTTON_HOVER_RIGHT 5969
+#define IDR_TEXTBUTTON_HOVER_TOP 5970
+#define IDR_TEXTBUTTON_HOVER_TOP_LEFT 5971
+#define IDR_TEXTBUTTON_HOVER_TOP_RIGHT 5972
+#define IDR_TEXTBUTTON_PRESSED_BOTTOM 5973
+#define IDR_TEXTBUTTON_PRESSED_BOTTOM_LEFT 5974
+#define IDR_TEXTBUTTON_PRESSED_BOTTOM_RIGHT 5975
+#define IDR_TEXTBUTTON_PRESSED_CENTER 5976
+#define IDR_TEXTBUTTON_PRESSED_LEFT 5977
+#define IDR_TEXTBUTTON_PRESSED_RIGHT 5978
+#define IDR_TEXTBUTTON_PRESSED_TOP 5979
+#define IDR_TEXTBUTTON_PRESSED_TOP_LEFT 5980
+#define IDR_TEXTBUTTON_PRESSED_TOP_RIGHT 5981
+#define IDR_WINDOW_BOTTOM_CENTER 5982
+#define IDR_WINDOW_BOTTOM_LEFT_CORNER 5983
+#define IDR_WINDOW_BOTTOM_RIGHT_CORNER 5984
+#define IDR_WINDOW_LEFT_SIDE 5985
+#define IDR_WINDOW_RIGHT_SIDE 5986
+#define IDR_WINDOW_TOP_CENTER 5987
+#define IDR_WINDOW_TOP_LEFT_CORNER 5988
+#define IDR_WINDOW_TOP_RIGHT_CORNER 5989
+#define IDR_WINDOW_BUBBLE_SHADOW_BIG_BOTTOM 5990
+#define IDR_WINDOW_BUBBLE_SHADOW_BIG_BOTTOM_LEFT 5991
+#define IDR_WINDOW_BUBBLE_SHADOW_BIG_BOTTOM_RIGHT 5992
+#define IDR_WINDOW_BUBBLE_SHADOW_BIG_LEFT 5993
+#define IDR_WINDOW_BUBBLE_SHADOW_BIG_RIGHT 5994
+#define IDR_WINDOW_BUBBLE_SHADOW_BIG_TOP 5995
+#define IDR_WINDOW_BUBBLE_SHADOW_BIG_TOP_LEFT 5996
+#define IDR_WINDOW_BUBBLE_SHADOW_BIG_TOP_RIGHT 5997
+#define IDR_WINDOW_BUBBLE_SHADOW_SPIKE_BIG_BOTTOM 5998
+#define IDR_WINDOW_BUBBLE_SHADOW_SPIKE_BIG_LEFT 5999
+#define IDR_WINDOW_BUBBLE_SHADOW_SPIKE_BIG_RIGHT 6000
+#define IDR_WINDOW_BUBBLE_SHADOW_SPIKE_BIG_TOP 6001
+#define IDR_WINDOW_BUBBLE_SHADOW_SMALL_BOTTOM 6002
+#define IDR_WINDOW_BUBBLE_SHADOW_SMALL_BOTTOM_LEFT 6003
+#define IDR_WINDOW_BUBBLE_SHADOW_SMALL_BOTTOM_RIGHT 6004
+#define IDR_WINDOW_BUBBLE_SHADOW_SMALL_LEFT 6005
+#define IDR_WINDOW_BUBBLE_SHADOW_SMALL_RIGHT 6006
+#define IDR_WINDOW_BUBBLE_SHADOW_SMALL_TOP 6007
+#define IDR_WINDOW_BUBBLE_SHADOW_SMALL_TOP_LEFT 6008
+#define IDR_WINDOW_BUBBLE_SHADOW_SMALL_TOP_RIGHT 6009
+#define IDR_WINDOW_BUBBLE_SHADOW_SPIKE_SMALL_BOTTOM 6010
+#define IDR_WINDOW_BUBBLE_SHADOW_SPIKE_SMALL_LEFT 6011
+#define IDR_WINDOW_BUBBLE_SHADOW_SPIKE_SMALL_RIGHT 6012
+#define IDR_WINDOW_BUBBLE_SHADOW_SPIKE_SMALL_TOP 6013
+
+// ---------------------------------------------------------------------------
+// From webui_resources.h:
+
+#define IDR_WEBUI_I18N_TEMPLATE_JS 2000
+#define IDR_WEBUI_JSTEMPLATE_JS 2001
+#define IDR_WEBUI_ANALYTICS_JS 2002
+#define IDR_WEBUI_ROBOTO_ROBOTO_LIGHT_WOFF2 2003
+#define IDR_WEBUI_ROBOTO_ROBOTO_REGULAR_WOFF2 2004
+#define IDR_WEBUI_ROBOTO_ROBOTO_MEDIUM_WOFF2 2005
+#define IDR_WEBUI_IMAGES_APPS_BUTTON 2006
+#define IDR_WEBUI_IMAGES_APPS_BUTTON_PRESSED 2007
+#define IDR_WEBUI_IMAGES_APPS_BUTTON_HOVER 2008
+#define IDR_WEBUI_IMAGES_APPS_BUTTON_DISABLED 2009
+#define IDR_WEBUI_IMAGES_APPS_BUTTON_FOCUSED 2010
+#define IDR_WEBUI_IMAGES_APPS_BUTTON_FOCUSED_PRESSED 2011
+#define IDR_WEBUI_IMAGES_APPS_BUTTON_FOCUSED_HOVER 2012
+#define IDR_WEBUI_IMAGES_APPS_BLUE_BUTTON 2013
+#define IDR_WEBUI_IMAGES_APPS_BLUE_BUTTON_PRESSED 2014
+#define IDR_WEBUI_IMAGES_APPS_BLUE_BUTTON_HOVER 2015
+#define IDR_WEBUI_IMAGES_APPS_BLUE_BUTTON_DISABLED 2016
+#define IDR_WEBUI_IMAGES_APPS_BLUE_BUTTON_FOCUSED 2017
+#define IDR_WEBUI_IMAGES_APPS_BLUE_BUTTON_FOCUSED_PRESSED 2018
+#define IDR_WEBUI_IMAGES_APPS_BLUE_BUTTON_FOCUSED_HOVER 2019
+#define IDR_WEBUI_IMAGES_APPS_CHECKBOX 2020
+#define IDR_WEBUI_IMAGES_APPS_CHECKBOX_HOVER 2021
+#define IDR_WEBUI_IMAGES_APPS_CHECKBOX_PRESSED 2022
+#define IDR_WEBUI_IMAGES_APPS_CHECKBOX_FOCUSED 2023
+#define IDR_WEBUI_IMAGES_APPS_CHECKBOX_FOCUSED_HOVER 2024
+#define IDR_WEBUI_IMAGES_APPS_CHECKBOX_FOCUSED_PRESSED 2025
+#define IDR_WEBUI_IMAGES_APPS_CHECKBOX_INACTIVE 2026
+#define IDR_WEBUI_IMAGES_APPS_CHECKBOX_CHECKED 2027
+#define IDR_WEBUI_IMAGES_APPS_CHECKBOX_CHECKED_HOVER 2028
+#define IDR_WEBUI_IMAGES_APPS_CHECKBOX_CHECKED_PRESSED 2029
+#define IDR_WEBUI_IMAGES_APPS_CHECKBOX_FOCUSED_CHECKED 2030
+#define IDR_WEBUI_IMAGES_APPS_CHECKBOX_FOCUSED_CHECKED_HOVER 2031
+#define IDR_WEBUI_IMAGES_APPS_CHECKBOX_FOCUSED_CHECKED_PRESSED 2032
+#define IDR_WEBUI_IMAGES_APPS_CHECKBOX_CHECKED_INACTIVE 2033
+#define IDR_WEBUI_IMAGES_APPS_TOPBAR_BUTTON_CLOSE 2034
+#define IDR_WEBUI_IMAGES_APPS_TOPBAR_BUTTON_MAXIMIZE 2035
+#define IDR_WEBUI_IMAGES_APPS_TOPBAR_BUTTON_MINIMIZE 2036
+#define IDR_WEBUI_IMAGES_APPS_BUTTON_BUTTER_BAR_CLOSE 2037
+#define IDR_WEBUI_IMAGES_APPS_BUTTON_BUTTER_BAR_CLOSE_HOVER 2038
+#define IDR_WEBUI_IMAGES_APPS_BUTTON_BUTTER_BAR_CLOSE_PRESSED 2039
+#define IDR_WEBUI_IMAGES_APPS_BUTTON_2X 2040
+#define IDR_WEBUI_IMAGES_APPS_BUTTON_2X_PRESSED 2041
+#define IDR_WEBUI_IMAGES_APPS_BUTTON_2X_HOVER 2042
+#define IDR_WEBUI_IMAGES_APPS_BUTTON_2X_DISABLED 2043
+#define IDR_WEBUI_IMAGES_APPS_BUTTON_2X_FOCUSED 2044
+#define IDR_WEBUI_IMAGES_APPS_BUTTON_2X_FOCUSED_PRESSED 2045
+#define IDR_WEBUI_IMAGES_APPS_BUTTON_2X_FOCUSED_HOVER 2046
+#define IDR_WEBUI_IMAGES_APPS_BLUE_BUTTON_2X 2047
+#define IDR_WEBUI_IMAGES_APPS_BLUE_BUTTON_2X_PRESSED 2048
+#define IDR_WEBUI_IMAGES_APPS_BLUE_BUTTON_2X_HOVER 2049
+#define IDR_WEBUI_IMAGES_APPS_BLUE_BUTTON_2X_DISABLED 2050
+#define IDR_WEBUI_IMAGES_APPS_BLUE_BUTTON_2X_FOCUSED 2051
+#define IDR_WEBUI_IMAGES_APPS_BLUE_BUTTON_2X_FOCUSED_PRESSED 2052
+#define IDR_WEBUI_IMAGES_APPS_BLUE_BUTTON_2X_FOCUSED_HOVER 2053
+#define IDR_WEBUI_IMAGES_APPS_CHECKBOX_2X 2054
+#define IDR_WEBUI_IMAGES_APPS_CHECKBOX_2X_HOVER 2055
+#define IDR_WEBUI_IMAGES_APPS_CHECKBOX_2X_PRESSED 2056
+#define IDR_WEBUI_IMAGES_APPS_CHECKBOX_2X_FOCUSED 2057
+#define IDR_WEBUI_IMAGES_APPS_CHECKBOX_2X_FOCUSED_HOVER 2058
+#define IDR_WEBUI_IMAGES_APPS_CHECKBOX_2X_FOCUSED_PRESSED 2059
+#define IDR_WEBUI_IMAGES_APPS_CHECKBOX_INACTIVE_2X 2060
+#define IDR_WEBUI_IMAGES_APPS_CHECKBOX_CHECKED_2X 2061
+#define IDR_WEBUI_IMAGES_APPS_CHECKBOX_CHECKED_2X_HOVER 2062
+#define IDR_WEBUI_IMAGES_APPS_CHECKBOX_CHECKED_2X_PRESSED 2063
+#define IDR_WEBUI_IMAGES_APPS_CHECKBOX_FOCUSED_CHECKED_2X 2064
+#define IDR_WEBUI_IMAGES_APPS_CHECKBOX_FOCUSED_CHECKED_2X_HOVER 2065
+#define IDR_WEBUI_IMAGES_APPS_CHECKBOX_FOCUSED_CHECKED_2X_PRESSED 2066
+#define IDR_WEBUI_IMAGES_APPS_CHECKBOX_CHECKED_INACTIVE_2X 2067
+#define IDR_WEBUI_IMAGES_APPS_TOPBAR_BUTTON_2X_CLOSE 2068
+#define IDR_WEBUI_IMAGES_APPS_TOPBAR_BUTTON_2X_MAXIMIZE 2069
+#define IDR_WEBUI_IMAGES_APPS_TOPBAR_BUTTON_2X_MINIMIZE 2070
+#define IDR_WEBUI_IMAGES_APPS_BUTTON_BUTTER_BAR_CLOSE_2X 2071
+#define IDR_WEBUI_IMAGES_APPS_BUTTON_BUTTER_BAR_CLOSE_HOVER_2X 2072
+#define IDR_WEBUI_IMAGES_APPS_BUTTON_BUTTER_BAR_CLOSE_PRESSED_2X 2073
+#define IDR_WEBUI_IMAGES_CHECK 2074
+#define IDR_WEBUI_IMAGES_CHECKBOX_BLACK 2075
+#define IDR_WEBUI_IMAGES_CHECKBOX_WHITE 2076
+#define IDR_WEBUI_IMAGES_DISABLED_SELECT 2077
+#define IDR_WEBUI_IMAGES_ERROR 2078
+#define IDR_WEBUI_IMAGES_SELECT 2079
+#define IDR_WEBUI_IMAGES_THROBBER_MEDIUM 2080
+#define IDR_WEBUI_IMAGES_THROBBER_SMALL 2081
+#define IDR_WEBUI_IMAGES_TRASH 2082
+#define IDR_WEBUI_CR_ELEMENTS_NETWORK_BADGE_CDMA1XRTT 2083
+#define IDR_WEBUI_CR_ELEMENTS_NETWORK_BADGE_3G 2084
+#define IDR_WEBUI_CR_ELEMENTS_NETWORK_BADGE_4G 2085
+#define IDR_WEBUI_CR_ELEMENTS_NETWORK_BADGE_EDGE 2086
+#define IDR_WEBUI_CR_ELEMENTS_NETWORK_BADGE_EVDO 2087
+#define IDR_WEBUI_CR_ELEMENTS_NETWORK_BADGE_GPRS 2088
+#define IDR_WEBUI_CR_ELEMENTS_NETWORK_BADGE_HSPA 2089
+#define IDR_WEBUI_CR_ELEMENTS_NETWORK_BADGE_HSPA_PLUS 2090
+#define IDR_WEBUI_CR_ELEMENTS_NETWORK_BADGE_LTE 2091
+#define IDR_WEBUI_CR_ELEMENTS_NETWORK_BADGE_LTE_ADVANCED 2092
+#define IDR_WEBUI_CR_ELEMENTS_NETWORK_BADGE_ROAMING 2093
+#define IDR_WEBUI_CR_ELEMENTS_NETWORK_BADGE_SECURE 2094
+#define IDR_WEBUI_CR_ELEMENTS_NETWORK_ICON_ETHERNET 2095
+#define IDR_WEBUI_CR_ELEMENTS_NETWORK_ICON_MOBILE 2096
+#define IDR_WEBUI_CR_ELEMENTS_NETWORK_ICON_VPN 2097
+#define IDR_WEBUI_CR_ELEMENTS_NETWORK_ICON_WIFI 2098
+#define IDR_WEBUI_CSS_ACTION_LINK 2200
+#define IDR_WEBUI_CSS_ALERT_OVERLAY 2201
+#define IDR_WEBUI_CSS_APPS_COMMON 2202
+#define IDR_WEBUI_CSS_APPS_TOPBUTTON_BAR 2203
+#define IDR_WEBUI_CSS_BUBBLE 2204
+#define IDR_WEBUI_CSS_BUBBLE_BUTTON 2205
+#define IDR_WEBUI_CSS_BUTTER_BAR 2206
+#define IDR_WEBUI_CSS_CHROME 2207
+#define IDR_WEBUI_CSS_CONTROLLED_INDICATOR 2208
+#define IDR_WEBUI_CSS_DIALOGS 2209
+#define IDR_WEBUI_CSS_I18N_PROCESS 2210
+#define IDR_WEBUI_CSS_LIST 2211
+#define IDR_WEBUI_CSS_MENU 2212
+#define IDR_WEBUI_CSS_MENU_BUTTON 2213
+#define IDR_WEBUI_CSS_TEXT_DEFAULTS 2214
+#define IDR_WEBUI_CSS_TEXT_DEFAULTS_MD 2215
+#define IDR_WEBUI_CSS_OVERLAY 2216
+#define IDR_WEBUI_CSS_ROBOTO 2217
+#define IDR_WEBUI_CSS_SPINNER 2218
+#define IDR_WEBUI_CSS_TABLE 2219
+#define IDR_WEBUI_CSS_TABS 2220
+#define IDR_WEBUI_CSS_THROBBER 2221
+#define IDR_WEBUI_CSS_TRASH 2222
+#define IDR_WEBUI_CSS_TREE 2223
+#define IDR_WEBUI_CSS_WIDGETS 2224
+#define IDR_WEBUI_HTML_ACTION_LINK 2225
+#define IDR_WEBUI_HTML_ASSERT 2226
+#define IDR_WEBUI_HTML_CR 2227
+#define IDR_WEBUI_HTML_CR_EVENT_TARGET 2228
+#define IDR_WEBUI_HTML_CR_UI 2229
+#define IDR_WEBUI_HTML_CR_UI_ALERT_OVERLAY 2230
+#define IDR_WEBUI_HTML_CR_UI_COMMAND 2231
+#define IDR_WEBUI_HTML_CR_UI_CONTEXT_MENU_BUTTON 2232
+#define IDR_WEBUI_HTML_CR_UI_CONTEXT_MENU_HANDLER 2233
+#define IDR_WEBUI_HTML_CR_UI_FOCUS_GRID 2234
+#define IDR_WEBUI_HTML_CR_UI_FOCUS_MANAGER 2235
+#define IDR_WEBUI_HTML_CR_UI_FOCUS_OUTLINE_MANAGER 2236
+#define IDR_WEBUI_HTML_CR_UI_FOCUS_ROW 2237
+#define IDR_WEBUI_HTML_CR_UI_MENU 2238
+#define IDR_WEBUI_HTML_CR_UI_MENU_BUTTON 2239
+#define IDR_WEBUI_HTML_CR_UI_MENU_ITEM 2240
+#define IDR_WEBUI_HTML_CR_UI_OVERLAY 2241
+#define IDR_WEBUI_HTML_CR_UI_POSITION_UTIL 2242
+#define IDR_WEBUI_HTML_EVENT_TRACKER 2243
+#define IDR_WEBUI_HTML_I18N_TEMPLATE 2244
+#define IDR_WEBUI_HTML_LOAD_TIME_DATA 2245
+#define IDR_WEBUI_HTML_POLYMER_CONFIG 2246
+#define IDR_WEBUI_HTML_I18N_BEHAVIOR 2247
+#define IDR_WEBUI_HTML_UTIL 2248
+#define IDR_WEBUI_JS_ACTION_LINK 2249
+#define IDR_WEBUI_JS_ASSERT 2250
+#define IDR_WEBUI_JS_CR 2251
+#define IDR_WEBUI_JS_CR_EVENT_TARGET 2252
+#define IDR_WEBUI_JS_CR_LINK_CONTROLLER 2253
+#define IDR_WEBUI_JS_CR_UI 2254
+#define IDR_WEBUI_JS_CR_UI_ALERT_OVERLAY 2255
+#define IDR_WEBUI_JS_CR_UI_ARRAY_DATA_MODEL 2256
+#define IDR_WEBUI_JS_CR_UI_AUTOCOMPLETE_LIST 2257
+#define IDR_WEBUI_JS_CR_UI_BUBBLE 2258
+#define IDR_WEBUI_JS_CR_UI_BUBBLE_BUTTON 2259
+#define IDR_WEBUI_JS_CR_UI_CARD_SLIDER 2260
+#define IDR_WEBUI_JS_CR_UI_COMMAND 2261
+#define IDR_WEBUI_JS_CR_UI_CONTEXT_MENU_BUTTON 2262
+#define IDR_WEBUI_JS_CR_UI_CONTEXT_MENU_HANDLER 2263
+#define IDR_WEBUI_JS_CR_UI_CONTROLLED_INDICATOR 2264
+#define IDR_WEBUI_JS_CR_UI_DIALOGS 2265
+#define IDR_WEBUI_JS_CR_UI_DRAG_WRAPPER 2266
+#define IDR_WEBUI_JS_CR_UI_FOCUS_GRID 2267
+#define IDR_WEBUI_JS_CR_UI_FOCUS_MANAGER 2268
+#define IDR_WEBUI_JS_CR_UI_FOCUS_OUTLINE_MANAGER 2269
+#define IDR_WEBUI_JS_CR_UI_FOCUS_ROW 2270
+#define IDR_WEBUI_JS_CR_UI_LIST 2271
+#define IDR_WEBUI_JS_CR_UI_LIST_ITEM 2272
+#define IDR_WEBUI_JS_CR_UI_LIST_SELECTION_CONTROLLER 2273
+#define IDR_WEBUI_JS_CR_UI_LIST_SELECTION_MODEL 2274
+#define IDR_WEBUI_JS_CR_UI_LIST_SINGLE_SELECTION_MODEL 2275
+#define IDR_WEBUI_JS_CR_UI_MENU 2276
+#define IDR_WEBUI_JS_CR_UI_MENU_BUTTON 2277
+#define IDR_WEBUI_JS_CR_UI_MENU_ITEM 2278
+#define IDR_WEBUI_JS_CR_UI_NODE_UTILS 2279
+#define IDR_WEBUI_JS_CR_UI_OVERLAY 2280
+#define IDR_WEBUI_JS_CR_UI_PAGE_MANAGER_PAGE 2281
+#define IDR_WEBUI_JS_CR_UI_PAGE_MANAGER_PAGE_MANAGER 2282
+#define IDR_WEBUI_JS_CR_UI_POSITION_UTIL 2283
+#define IDR_WEBUI_JS_CR_UI_SPLITTER 2284
+#define IDR_WEBUI_JS_CR_UI_GRID 2285
+#define IDR_WEBUI_JS_CR_UI_REPEATING_BUTTON 2286
+#define IDR_WEBUI_JS_CR_UI_TABLE 2287
+#define IDR_WEBUI_JS_CR_UI_TABLE_COLUMN 2288
+#define IDR_WEBUI_JS_CR_UI_TABLE_COLUMN_MODEL 2289
+#define IDR_WEBUI_JS_CR_UI_TABLE_HEADER 2290
+#define IDR_WEBUI_JS_CR_UI_TABLE_LIST 2291
+#define IDR_WEBUI_JS_CR_UI_TABLE_SPLITTER 2292
+#define IDR_WEBUI_JS_CR_UI_TABS 2293
+#define IDR_WEBUI_JS_CR_UI_TREE 2294
+#define IDR_WEBUI_JS_CR_UI_TOUCH_HANDLER 2295
+#define IDR_WEBUI_JS_EVENT_TRACKER 2296
+#define IDR_WEBUI_JS_I18N_TEMPLATE_NO_PROCESS 2297
+#define IDR_WEBUI_JS_LOAD_TIME_DATA 2298
+#define IDR_WEBUI_JS_MEDIA_COMMON 2299
+#define IDR_WEBUI_JS_PARSE_HTML_SUBSET 2300
+#define IDR_WEBUI_JS_POLYMER_CONFIG 2301
+#define IDR_WEBUI_JS_I18N_BEHAVIOR 2302
+#define IDR_WEBUI_JS_UTIL 2303
+#define IDR_WEBUI_JS_WEBUI_RESOURCE_TEST 2304
+#define IDR_WEBUI_CSS_UI_ACCOUNT_TWEAKS 2305
+#define IDR_WEBUI_HTML_UI_ACCOUNT_TWEAKS 2306
+#define IDR_WEBUI_JS_UI_ACCOUNT_TWEAKS 2307
+#define IDR_CR_ELEMENTS_CR_DEMO_ELEMENT_CSS 2308
+#define IDR_CR_ELEMENTS_CR_DEMO_ELEMENT_HTML 2309
+#define IDR_CR_ELEMENTS_CR_DEMO_ELEMENT_JS 2310
+#define IDR_CR_ELEMENTS_CR_DEMO_CONFIG_JS 2311
+#define IDR_CR_ELEMENTS_CR_DEMO_PAGE_HTML 2312
+#define IDR_CR_ELEMENTS_CR_EVENTS_HTML 2313
+#define IDR_CR_ELEMENTS_CR_EVENTS_JS 2314
+#define IDR_CR_ELEMENTS_CR_EXPAND_BUTTON_CSS 2315
+#define IDR_CR_ELEMENTS_CR_EXPAND_BUTTON_HTML 2316
+#define IDR_CR_ELEMENTS_CR_EXPAND_BUTTON_JS 2317
+#define IDR_CR_ELEMENTS_CR_NETWORK_ICON_CSS 2318
+#define IDR_CR_ELEMENTS_CR_NETWORK_ICON_HTML 2319
+#define IDR_CR_ELEMENTS_CR_NETWORK_ICON_JS 2320
+#define IDR_CR_ELEMENTS_CR_NETWORK_LIST_CSS 2321
+#define IDR_CR_ELEMENTS_CR_NETWORK_LIST_HTML 2322
+#define IDR_CR_ELEMENTS_CR_NETWORK_LIST_JS 2323
+#define IDR_CR_ELEMENTS_CR_NETWORK_LIST_ITEM_CSS 2324
+#define IDR_CR_ELEMENTS_CR_NETWORK_LIST_ITEM_HTML 2325
+#define IDR_CR_ELEMENTS_CR_NETWORK_LIST_ITEM_JS 2326
+#define IDR_CR_ELEMENTS_CR_NETWORK_SELECT_CSS 2327
+#define IDR_CR_ELEMENTS_CR_NETWORK_SELECT_HTML 2328
+#define IDR_CR_ELEMENTS_CR_NETWORK_SELECT_JS 2329
+#define IDR_CR_ELEMENTS_CR_ONC_TYPES_HTML 2330
+#define IDR_CR_ELEMENTS_CR_ONC_TYPES_JS 2331
+#define IDR_CR_ELEMENTS_CR_POLICY_INDICATOR_CSS 2332
+#define IDR_CR_ELEMENTS_CR_POLICY_INDICATOR_BEHAVIOR_HTML 2333
+#define IDR_CR_ELEMENTS_CR_POLICY_INDICATOR_BEHAVIOR_JS 2334
+#define IDR_CR_ELEMENTS_CR_POLICY_NETWORK_BEHAVIOR_HTML 2335
+#define IDR_CR_ELEMENTS_CR_POLICY_NETWORK_BEHAVIOR_JS 2336
+#define IDR_CR_ELEMENTS_CR_POLICY_NETWORK_INDICATOR_JS 2337
+#define IDR_CR_ELEMENTS_CR_POLICY_NETWORK_INDICATOR_HTML 2338
+#define IDR_CR_ELEMENTS_CR_POLICY_PREF_BEHAVIOR_HTML 2339
+#define IDR_CR_ELEMENTS_CR_POLICY_PREF_BEHAVIOR_JS 2340
+#define IDR_CR_ELEMENTS_CR_POLICY_PREF_INDICATOR_JS 2341
+#define IDR_CR_ELEMENTS_CR_POLICY_PREF_INDICATOR_HTML 2342
+#define IDR_CR_ELEMENTS_CR_SEARCH_FIELD_CSS 2343
+#define IDR_CR_ELEMENTS_CR_SEARCH_FIELD_HTML 2344
+#define IDR_CR_ELEMENTS_CR_SEARCH_FIELD_JS 2345
+#define IDR_CR_ELEMENTS_SHARED_CSS 2346
+#define IDR_POLYMER_1_0_FONT_ROBOTO_ROBOTO_HTML 2347
+#define IDR_POLYMER_1_0_IRON_A11Y_KEYS_BEHAVIOR_IRON_A11Y_KEYS_BEHAVIOR_EXTRACTED_JS 2348
+#define IDR_POLYMER_1_0_IRON_A11Y_KEYS_BEHAVIOR_IRON_A11Y_KEYS_BEHAVIOR_HTML 2349
+#define IDR_POLYMER_1_0_IRON_A11Y_KEYS_IRON_A11Y_KEYS_EXTRACTED_JS 2350
+#define IDR_POLYMER_1_0_IRON_A11Y_KEYS_IRON_A11Y_KEYS_HTML 2351
+#define IDR_POLYMER_1_0_IRON_BEHAVIORS_IRON_BUTTON_STATE_EXTRACTED_JS 2352
+#define IDR_POLYMER_1_0_IRON_BEHAVIORS_IRON_BUTTON_STATE_HTML 2353
+#define IDR_POLYMER_1_0_IRON_BEHAVIORS_IRON_CONTROL_STATE_EXTRACTED_JS 2354
+#define IDR_POLYMER_1_0_IRON_BEHAVIORS_IRON_CONTROL_STATE_HTML 2355
+#define IDR_POLYMER_1_0_IRON_CHECKED_ELEMENT_BEHAVIOR_IRON_CHECKED_ELEMENT_BEHAVIOR_EXTRACTED_JS 2356
+#define IDR_POLYMER_1_0_IRON_CHECKED_ELEMENT_BEHAVIOR_IRON_CHECKED_ELEMENT_BEHAVIOR_HTML 2357
+#define IDR_POLYMER_1_0_IRON_COLLAPSE_IRON_COLLAPSE_EXTRACTED_JS 2358
+#define IDR_POLYMER_1_0_IRON_COLLAPSE_IRON_COLLAPSE_HTML 2359
+#define IDR_POLYMER_1_0_IRON_DROPDOWN_IRON_DROPDOWN_EXTRACTED_JS 2360
+#define IDR_POLYMER_1_0_IRON_DROPDOWN_IRON_DROPDOWN_SCROLL_MANAGER_EXTRACTED_JS 2361
+#define IDR_POLYMER_1_0_IRON_DROPDOWN_IRON_DROPDOWN_SCROLL_MANAGER_HTML 2362
+#define IDR_POLYMER_1_0_IRON_DROPDOWN_IRON_DROPDOWN_HTML 2363
+#define IDR_POLYMER_1_0_IRON_FIT_BEHAVIOR_IRON_FIT_BEHAVIOR_EXTRACTED_JS 2364
+#define IDR_POLYMER_1_0_IRON_FIT_BEHAVIOR_IRON_FIT_BEHAVIOR_HTML 2365
+#define IDR_POLYMER_1_0_IRON_FLEX_LAYOUT_CLASSES_IRON_FLEX_LAYOUT_HTML 2366
+#define IDR_POLYMER_1_0_IRON_FLEX_LAYOUT_CLASSES_IRON_SHADOW_FLEX_LAYOUT_HTML 2367
+#define IDR_POLYMER_1_0_IRON_FLEX_LAYOUT_IRON_FLEX_LAYOUT_HTML 2368
+#define IDR_POLYMER_1_0_IRON_FORM_ELEMENT_BEHAVIOR_IRON_FORM_ELEMENT_BEHAVIOR_EXTRACTED_JS 2369
+#define IDR_POLYMER_1_0_IRON_FORM_ELEMENT_BEHAVIOR_IRON_FORM_ELEMENT_BEHAVIOR_HTML 2370
+#define IDR_POLYMER_1_0_IRON_ICON_IRON_ICON_EXTRACTED_JS 2371
+#define IDR_POLYMER_1_0_IRON_ICON_IRON_ICON_HTML 2372
+#define IDR_POLYMER_1_0_IRON_ICONS_AV_ICONS_HTML 2373
+#define IDR_POLYMER_1_0_IRON_ICONS_COMMUNICATION_ICONS_HTML 2374
+#define IDR_POLYMER_1_0_IRON_ICONS_DEVICE_ICONS_HTML 2375
+#define IDR_POLYMER_1_0_IRON_ICONS_HARDWARE_ICONS_HTML 2376
+#define IDR_POLYMER_1_0_IRON_ICONS_IMAGE_ICONS_HTML 2377
+#define IDR_POLYMER_1_0_IRON_ICONS_IRON_ICONS_HTML 2378
+#define IDR_POLYMER_1_0_IRON_ICONS_NOTIFICATION_ICONS_HTML 2379
+#define IDR_POLYMER_1_0_IRON_ICONS_PLACES_ICONS_HTML 2380
+#define IDR_POLYMER_1_0_IRON_ICONS_SOCIAL_ICONS_HTML 2381
+#define IDR_POLYMER_1_0_IRON_ICONSET_SVG_IRON_ICONSET_SVG_EXTRACTED_JS 2382
+#define IDR_POLYMER_1_0_IRON_ICONSET_SVG_IRON_ICONSET_SVG_HTML 2383
+#define IDR_POLYMER_1_0_IRON_INPUT_IRON_INPUT_EXTRACTED_JS 2384
+#define IDR_POLYMER_1_0_IRON_INPUT_IRON_INPUT_HTML 2385
+#define IDR_POLYMER_1_0_IRON_LIST_IRON_LIST_EXTRACTED_JS 2386
+#define IDR_POLYMER_1_0_IRON_LIST_IRON_LIST_HTML 2387
+#define IDR_POLYMER_1_0_IRON_MEDIA_QUERY_IRON_MEDIA_QUERY_EXTRACTED_JS 2388
+#define IDR_POLYMER_1_0_IRON_MEDIA_QUERY_IRON_MEDIA_QUERY_HTML 2389
+#define IDR_POLYMER_1_0_IRON_MENU_BEHAVIOR_IRON_MENU_BEHAVIOR_EXTRACTED_JS 2390
+#define IDR_POLYMER_1_0_IRON_MENU_BEHAVIOR_IRON_MENU_BEHAVIOR_HTML 2391
+#define IDR_POLYMER_1_0_IRON_MENU_BEHAVIOR_IRON_MENUBAR_BEHAVIOR_EXTRACTED_JS 2392
+#define IDR_POLYMER_1_0_IRON_MENU_BEHAVIOR_IRON_MENUBAR_BEHAVIOR_HTML 2393
+#define IDR_POLYMER_1_0_IRON_META_IRON_META_EXTRACTED_JS 2394
+#define IDR_POLYMER_1_0_IRON_META_IRON_META_HTML 2395
+#define IDR_POLYMER_1_0_IRON_OVERLAY_BEHAVIOR_IRON_OVERLAY_BACKDROP_EXTRACTED_JS 2396
+#define IDR_POLYMER_1_0_IRON_OVERLAY_BEHAVIOR_IRON_OVERLAY_BACKDROP_HTML 2397
+#define IDR_POLYMER_1_0_IRON_OVERLAY_BEHAVIOR_IRON_OVERLAY_BEHAVIOR_EXTRACTED_JS 2398
+#define IDR_POLYMER_1_0_IRON_OVERLAY_BEHAVIOR_IRON_OVERLAY_BEHAVIOR_HTML 2399
+#define IDR_POLYMER_1_0_IRON_OVERLAY_BEHAVIOR_IRON_OVERLAY_MANAGER_EXTRACTED_JS 2400
+#define IDR_POLYMER_1_0_IRON_OVERLAY_BEHAVIOR_IRON_OVERLAY_MANAGER_HTML 2401
+#define IDR_POLYMER_1_0_IRON_PAGES_IRON_PAGES_EXTRACTED_JS 2402
+#define IDR_POLYMER_1_0_IRON_PAGES_IRON_PAGES_HTML 2403
+#define IDR_POLYMER_1_0_IRON_RANGE_BEHAVIOR_IRON_RANGE_BEHAVIOR_EXTRACTED_JS 2404
+#define IDR_POLYMER_1_0_IRON_RANGE_BEHAVIOR_IRON_RANGE_BEHAVIOR_HTML 2405
+#define IDR_POLYMER_1_0_IRON_RESIZABLE_BEHAVIOR_IRON_RESIZABLE_BEHAVIOR_EXTRACTED_JS 2406
+#define IDR_POLYMER_1_0_IRON_RESIZABLE_BEHAVIOR_IRON_RESIZABLE_BEHAVIOR_HTML 2407
+#define IDR_POLYMER_1_0_IRON_SELECTOR_IRON_MULTI_SELECTABLE_EXTRACTED_JS 2408
+#define IDR_POLYMER_1_0_IRON_SELECTOR_IRON_MULTI_SELECTABLE_HTML 2409
+#define IDR_POLYMER_1_0_IRON_SELECTOR_IRON_SELECTABLE_EXTRACTED_JS 2410
+#define IDR_POLYMER_1_0_IRON_SELECTOR_IRON_SELECTABLE_HTML 2411
+#define IDR_POLYMER_1_0_IRON_SELECTOR_IRON_SELECTION_EXTRACTED_JS 2412
+#define IDR_POLYMER_1_0_IRON_SELECTOR_IRON_SELECTION_HTML 2413
+#define IDR_POLYMER_1_0_IRON_SELECTOR_IRON_SELECTOR_EXTRACTED_JS 2414
+#define IDR_POLYMER_1_0_IRON_SELECTOR_IRON_SELECTOR_HTML 2415
+#define IDR_POLYMER_1_0_IRON_TEST_HELPERS_IRON_TEST_HELPERS_EXTRACTED_JS 2416
+#define IDR_POLYMER_1_0_IRON_TEST_HELPERS_IRON_TEST_HELPERS_HTML 2417
+#define IDR_POLYMER_1_0_IRON_TEST_HELPERS_MOCK_INTERACTIONS_HTML 2418
+#define IDR_POLYMER_1_0_IRON_TEST_HELPERS_MOCK_INTERACTIONS_JS 2419
+#define IDR_POLYMER_1_0_IRON_TEST_HELPERS_TEST_HELPERS_HTML 2420
+#define IDR_POLYMER_1_0_IRON_TEST_HELPERS_TEST_HELPERS_JS 2421
+#define IDR_POLYMER_1_0_IRON_VALIDATABLE_BEHAVIOR_IRON_VALIDATABLE_BEHAVIOR_EXTRACTED_JS 2422
+#define IDR_POLYMER_1_0_IRON_VALIDATABLE_BEHAVIOR_IRON_VALIDATABLE_BEHAVIOR_HTML 2423
+#define IDR_POLYMER_1_0_NEON_ANIMATION_ANIMATIONS_FADE_IN_ANIMATION_EXTRACTED_JS 2424
+#define IDR_POLYMER_1_0_NEON_ANIMATION_ANIMATIONS_FADE_IN_ANIMATION_HTML 2425
+#define IDR_POLYMER_1_0_NEON_ANIMATION_ANIMATIONS_FADE_OUT_ANIMATION_EXTRACTED_JS 2426
+#define IDR_POLYMER_1_0_NEON_ANIMATION_ANIMATIONS_FADE_OUT_ANIMATION_HTML 2427
+#define IDR_POLYMER_1_0_NEON_ANIMATION_ANIMATIONS_HERO_ANIMATION_EXTRACTED_JS 2428
+#define IDR_POLYMER_1_0_NEON_ANIMATION_ANIMATIONS_HERO_ANIMATION_HTML 2429
+#define IDR_POLYMER_1_0_NEON_ANIMATION_ANIMATIONS_OPAQUE_ANIMATION_EXTRACTED_JS 2430
+#define IDR_POLYMER_1_0_NEON_ANIMATION_ANIMATIONS_OPAQUE_ANIMATION_HTML 2431
+#define IDR_POLYMER_1_0_NEON_ANIMATION_ANIMATIONS_SLIDE_DOWN_ANIMATION_EXTRACTED_JS 2432
+#define IDR_POLYMER_1_0_NEON_ANIMATION_ANIMATIONS_SLIDE_DOWN_ANIMATION_HTML 2433
+#define IDR_POLYMER_1_0_NEON_ANIMATION_ANIMATIONS_SLIDE_FROM_LEFT_ANIMATION_EXTRACTED_JS 2434
+#define IDR_POLYMER_1_0_NEON_ANIMATION_ANIMATIONS_SLIDE_FROM_LEFT_ANIMATION_HTML 2435
+#define IDR_POLYMER_1_0_NEON_ANIMATION_ANIMATIONS_SLIDE_FROM_RIGHT_ANIMATION_EXTRACTED_JS 2436
+#define IDR_POLYMER_1_0_NEON_ANIMATION_ANIMATIONS_SLIDE_FROM_RIGHT_ANIMATION_HTML 2437
+#define IDR_POLYMER_1_0_NEON_ANIMATION_ANIMATIONS_SLIDE_LEFT_ANIMATION_EXTRACTED_JS 2438
+#define IDR_POLYMER_1_0_NEON_ANIMATION_ANIMATIONS_SLIDE_LEFT_ANIMATION_HTML 2439
+#define IDR_POLYMER_1_0_NEON_ANIMATION_ANIMATIONS_SLIDE_RIGHT_ANIMATION_EXTRACTED_JS 2440
+#define IDR_POLYMER_1_0_NEON_ANIMATION_ANIMATIONS_SLIDE_RIGHT_ANIMATION_HTML 2441
+#define IDR_POLYMER_1_0_NEON_ANIMATION_ANIMATIONS_SLIDE_UP_ANIMATION_EXTRACTED_JS 2442
+#define IDR_POLYMER_1_0_NEON_ANIMATION_ANIMATIONS_SLIDE_UP_ANIMATION_HTML 2443
+#define IDR_POLYMER_1_0_NEON_ANIMATION_ANIMATIONS_TRANSFORM_ANIMATION_EXTRACTED_JS 2444
+#define IDR_POLYMER_1_0_NEON_ANIMATION_ANIMATIONS_TRANSFORM_ANIMATION_HTML 2445
+#define IDR_POLYMER_1_0_NEON_ANIMATION_NEON_ANIMATABLE_BEHAVIOR_EXTRACTED_JS 2446
+#define IDR_POLYMER_1_0_NEON_ANIMATION_NEON_ANIMATABLE_BEHAVIOR_HTML 2447
+#define IDR_POLYMER_1_0_NEON_ANIMATION_NEON_ANIMATABLE_EXTRACTED_JS 2448
+#define IDR_POLYMER_1_0_NEON_ANIMATION_NEON_ANIMATABLE_HTML 2449
+#define IDR_POLYMER_1_0_NEON_ANIMATION_NEON_ANIMATED_PAGES_EXTRACTED_JS 2450
+#define IDR_POLYMER_1_0_NEON_ANIMATION_NEON_ANIMATED_PAGES_HTML 2451
+#define IDR_POLYMER_1_0_NEON_ANIMATION_NEON_ANIMATION_BEHAVIOR_EXTRACTED_JS 2452
+#define IDR_POLYMER_1_0_NEON_ANIMATION_NEON_ANIMATION_BEHAVIOR_HTML 2453
+#define IDR_POLYMER_1_0_NEON_ANIMATION_NEON_ANIMATION_RUNNER_BEHAVIOR_EXTRACTED_JS 2454
+#define IDR_POLYMER_1_0_NEON_ANIMATION_NEON_ANIMATION_RUNNER_BEHAVIOR_HTML 2455
+#define IDR_POLYMER_1_0_NEON_ANIMATION_NEON_SHARED_ELEMENT_ANIMATABLE_BEHAVIOR_EXTRACTED_JS 2456
+#define IDR_POLYMER_1_0_NEON_ANIMATION_NEON_SHARED_ELEMENT_ANIMATABLE_BEHAVIOR_HTML 2457
+#define IDR_POLYMER_1_0_NEON_ANIMATION_NEON_SHARED_ELEMENT_ANIMATION_BEHAVIOR_EXTRACTED_JS 2458
+#define IDR_POLYMER_1_0_NEON_ANIMATION_NEON_SHARED_ELEMENT_ANIMATION_BEHAVIOR_HTML 2459
+#define IDR_POLYMER_1_0_NEON_ANIMATION_WEB_ANIMATIONS_HTML 2460
+#define IDR_POLYMER_1_0_PAPER_BEHAVIORS_PAPER_BUTTON_BEHAVIOR_EXTRACTED_JS 2461
+#define IDR_POLYMER_1_0_PAPER_BEHAVIORS_PAPER_BUTTON_BEHAVIOR_HTML 2462
+#define IDR_POLYMER_1_0_PAPER_BEHAVIORS_PAPER_CHECKED_ELEMENT_BEHAVIOR_EXTRACTED_JS 2463
+#define IDR_POLYMER_1_0_PAPER_BEHAVIORS_PAPER_CHECKED_ELEMENT_BEHAVIOR_HTML 2464
+#define IDR_POLYMER_1_0_PAPER_BEHAVIORS_PAPER_INKY_FOCUS_BEHAVIOR_EXTRACTED_JS 2465
+#define IDR_POLYMER_1_0_PAPER_BEHAVIORS_PAPER_INKY_FOCUS_BEHAVIOR_HTML 2466
+#define IDR_POLYMER_1_0_PAPER_BEHAVIORS_PAPER_RIPPLE_BEHAVIOR_EXTRACTED_JS 2467
+#define IDR_POLYMER_1_0_PAPER_BEHAVIORS_PAPER_RIPPLE_BEHAVIOR_HTML 2468
+#define IDR_POLYMER_1_0_PAPER_BUTTON_PAPER_BUTTON_EXTRACTED_JS 2469
+#define IDR_POLYMER_1_0_PAPER_BUTTON_PAPER_BUTTON_HTML 2470
+#define IDR_POLYMER_1_0_PAPER_CARD_PAPER_CARD_EXTRACTED_JS 2471
+#define IDR_POLYMER_1_0_PAPER_CARD_PAPER_CARD_HTML 2472
+#define IDR_POLYMER_1_0_PAPER_CHECKBOX_PAPER_CHECKBOX_EXTRACTED_JS 2473
+#define IDR_POLYMER_1_0_PAPER_CHECKBOX_PAPER_CHECKBOX_HTML 2474
+#define IDR_POLYMER_1_0_PAPER_DIALOG_BEHAVIOR_PAPER_DIALOG_BEHAVIOR_EXTRACTED_JS 2475
+#define IDR_POLYMER_1_0_PAPER_DIALOG_BEHAVIOR_PAPER_DIALOG_BEHAVIOR_HTML 2476
+#define IDR_POLYMER_1_0_PAPER_DIALOG_BEHAVIOR_PAPER_DIALOG_COMMON_CSS 2477
+#define IDR_POLYMER_1_0_PAPER_DIALOG_BEHAVIOR_PAPER_DIALOG_SHARED_STYLES_HTML 2478
+#define IDR_POLYMER_1_0_PAPER_DIALOG_PAPER_DIALOG_EXTRACTED_JS 2479
+#define IDR_POLYMER_1_0_PAPER_DIALOG_PAPER_DIALOG_HTML 2480
+#define IDR_POLYMER_1_0_PAPER_DRAWER_PANEL_PAPER_DRAWER_PANEL_EXTRACTED_JS 2481
+#define IDR_POLYMER_1_0_PAPER_DRAWER_PANEL_PAPER_DRAWER_PANEL_HTML 2482
+#define IDR_POLYMER_1_0_PAPER_DROPDOWN_MENU_PAPER_DROPDOWN_MENU_EXTRACTED_JS 2483
+#define IDR_POLYMER_1_0_PAPER_DROPDOWN_MENU_PAPER_DROPDOWN_MENU_HTML 2484
+#define IDR_POLYMER_1_0_PAPER_FAB_PAPER_FAB_EXTRACTED_JS 2485
+#define IDR_POLYMER_1_0_PAPER_FAB_PAPER_FAB_HTML 2486
+#define IDR_POLYMER_1_0_PAPER_HEADER_PANEL_PAPER_HEADER_PANEL_EXTRACTED_JS 2487
+#define IDR_POLYMER_1_0_PAPER_HEADER_PANEL_PAPER_HEADER_PANEL_HTML 2488
+#define IDR_POLYMER_1_0_PAPER_ICON_BUTTON_PAPER_ICON_BUTTON_EXTRACTED_JS 2489
+#define IDR_POLYMER_1_0_PAPER_ICON_BUTTON_PAPER_ICON_BUTTON_HTML 2490
+#define IDR_POLYMER_1_0_PAPER_INPUT_PAPER_INPUT_ADDON_BEHAVIOR_EXTRACTED_JS 2491
+#define IDR_POLYMER_1_0_PAPER_INPUT_PAPER_INPUT_ADDON_BEHAVIOR_HTML 2492
+#define IDR_POLYMER_1_0_PAPER_INPUT_PAPER_INPUT_BEHAVIOR_EXTRACTED_JS 2493
+#define IDR_POLYMER_1_0_PAPER_INPUT_PAPER_INPUT_BEHAVIOR_HTML 2494
+#define IDR_POLYMER_1_0_PAPER_INPUT_PAPER_INPUT_CHAR_COUNTER_EXTRACTED_JS 2495
+#define IDR_POLYMER_1_0_PAPER_INPUT_PAPER_INPUT_CHAR_COUNTER_HTML 2496
+#define IDR_POLYMER_1_0_PAPER_INPUT_PAPER_INPUT_CONTAINER_EXTRACTED_JS 2497
+#define IDR_POLYMER_1_0_PAPER_INPUT_PAPER_INPUT_CONTAINER_HTML 2498
+#define IDR_POLYMER_1_0_PAPER_INPUT_PAPER_INPUT_ERROR_EXTRACTED_JS 2499
+#define IDR_POLYMER_1_0_PAPER_INPUT_PAPER_INPUT_ERROR_HTML 2500
+#define IDR_POLYMER_1_0_PAPER_INPUT_PAPER_INPUT_EXTRACTED_JS 2501
+#define IDR_POLYMER_1_0_PAPER_INPUT_PAPER_INPUT_HTML 2502
+#define IDR_POLYMER_1_0_PAPER_ITEM_PAPER_ICON_ITEM_EXTRACTED_JS 2503
+#define IDR_POLYMER_1_0_PAPER_ITEM_PAPER_ICON_ITEM_HTML 2504
+#define IDR_POLYMER_1_0_PAPER_ITEM_PAPER_ITEM_BEHAVIOR_EXTRACTED_JS 2505
+#define IDR_POLYMER_1_0_PAPER_ITEM_PAPER_ITEM_BEHAVIOR_HTML 2506
+#define IDR_POLYMER_1_0_PAPER_ITEM_PAPER_ITEM_BODY_EXTRACTED_JS 2507
+#define IDR_POLYMER_1_0_PAPER_ITEM_PAPER_ITEM_BODY_HTML 2508
+#define IDR_POLYMER_1_0_PAPER_ITEM_PAPER_ITEM_EXTRACTED_JS 2509
+#define IDR_POLYMER_1_0_PAPER_ITEM_PAPER_ITEM_SHARED_STYLES_HTML 2510
+#define IDR_POLYMER_1_0_PAPER_ITEM_PAPER_ITEM_HTML 2511
+#define IDR_POLYMER_1_0_PAPER_MATERIAL_PAPER_MATERIAL_EXTRACTED_JS 2512
+#define IDR_POLYMER_1_0_PAPER_MATERIAL_PAPER_MATERIAL_SHARED_STYLES_HTML 2513
+#define IDR_POLYMER_1_0_PAPER_MATERIAL_PAPER_MATERIAL_HTML 2514
+#define IDR_POLYMER_1_0_PAPER_MENU_BUTTON_PAPER_MENU_BUTTON_ANIMATIONS_EXTRACTED_JS 2515
+#define IDR_POLYMER_1_0_PAPER_MENU_BUTTON_PAPER_MENU_BUTTON_ANIMATIONS_HTML 2516
+#define IDR_POLYMER_1_0_PAPER_MENU_BUTTON_PAPER_MENU_BUTTON_EXTRACTED_JS 2517
+#define IDR_POLYMER_1_0_PAPER_MENU_BUTTON_PAPER_MENU_BUTTON_HTML 2518
+#define IDR_POLYMER_1_0_PAPER_MENU_PAPER_MENU_EXTRACTED_JS 2519
+#define IDR_POLYMER_1_0_PAPER_MENU_PAPER_MENU_SHARED_STYLES_HTML 2520
+#define IDR_POLYMER_1_0_PAPER_MENU_PAPER_MENU_HTML 2521
+#define IDR_POLYMER_1_0_PAPER_MENU_PAPER_SUBMENU_EXTRACTED_JS 2522
+#define IDR_POLYMER_1_0_PAPER_MENU_PAPER_SUBMENU_HTML 2523
+#define IDR_POLYMER_1_0_PAPER_PROGRESS_PAPER_PROGRESS_EXTRACTED_JS 2524
+#define IDR_POLYMER_1_0_PAPER_PROGRESS_PAPER_PROGRESS_HTML 2525
+#define IDR_POLYMER_1_0_PAPER_RADIO_BUTTON_PAPER_RADIO_BUTTON_EXTRACTED_JS 2526
+#define IDR_POLYMER_1_0_PAPER_RADIO_BUTTON_PAPER_RADIO_BUTTON_HTML 2527
+#define IDR_POLYMER_1_0_PAPER_RADIO_GROUP_PAPER_RADIO_GROUP_EXTRACTED_JS 2528
+#define IDR_POLYMER_1_0_PAPER_RADIO_GROUP_PAPER_RADIO_GROUP_HTML 2529
+#define IDR_POLYMER_1_0_PAPER_RIPPLE_PAPER_RIPPLE_EXTRACTED_JS 2530
+#define IDR_POLYMER_1_0_PAPER_RIPPLE_PAPER_RIPPLE_HTML 2531
+#define IDR_POLYMER_1_0_PAPER_SLIDER_PAPER_SLIDER_EXTRACTED_JS 2532
+#define IDR_POLYMER_1_0_PAPER_SLIDER_PAPER_SLIDER_HTML 2533
+#define IDR_POLYMER_1_0_PAPER_SPINNER_PAPER_SPINNER_BEHAVIOR_EXTRACTED_JS 2534
+#define IDR_POLYMER_1_0_PAPER_SPINNER_PAPER_SPINNER_BEHAVIOR_HTML 2535
+#define IDR_POLYMER_1_0_PAPER_SPINNER_PAPER_SPINNER_EXTRACTED_JS 2536
+#define IDR_POLYMER_1_0_PAPER_SPINNER_PAPER_SPINNER_LITE_EXTRACTED_JS 2537
+#define IDR_POLYMER_1_0_PAPER_SPINNER_PAPER_SPINNER_LITE_HTML 2538
+#define IDR_POLYMER_1_0_PAPER_SPINNER_PAPER_SPINNER_STYLES_HTML 2539
+#define IDR_POLYMER_1_0_PAPER_SPINNER_PAPER_SPINNER_HTML 2540
+#define IDR_POLYMER_1_0_PAPER_STYLES_CLASSES_SHADOW_LAYOUT_HTML 2541
+#define IDR_POLYMER_1_0_PAPER_STYLES_CLASSES_SHADOW_HTML 2542
+#define IDR_POLYMER_1_0_PAPER_STYLES_CLASSES_TYPOGRAPHY_HTML 2543
+#define IDR_POLYMER_1_0_PAPER_STYLES_COLOR_HTML 2544
+#define IDR_POLYMER_1_0_PAPER_STYLES_DEFAULT_THEME_HTML 2545
+#define IDR_POLYMER_1_0_PAPER_STYLES_PAPER_STYLES_CLASSES_HTML 2546
+#define IDR_POLYMER_1_0_PAPER_STYLES_PAPER_STYLES_HTML 2547
+#define IDR_POLYMER_1_0_PAPER_STYLES_SHADOW_HTML 2548
+#define IDR_POLYMER_1_0_PAPER_STYLES_TYPOGRAPHY_HTML 2549
+#define IDR_POLYMER_1_0_PAPER_TABS_PAPER_TAB_EXTRACTED_JS 2550
+#define IDR_POLYMER_1_0_PAPER_TABS_PAPER_TAB_HTML 2551
+#define IDR_POLYMER_1_0_PAPER_TABS_PAPER_TABS_EXTRACTED_JS 2552
+#define IDR_POLYMER_1_0_PAPER_TABS_PAPER_TABS_ICONS_HTML 2553
+#define IDR_POLYMER_1_0_PAPER_TABS_PAPER_TABS_HTML 2554
+#define IDR_POLYMER_1_0_PAPER_TOGGLE_BUTTON_PAPER_TOGGLE_BUTTON_EXTRACTED_JS 2555
+#define IDR_POLYMER_1_0_PAPER_TOGGLE_BUTTON_PAPER_TOGGLE_BUTTON_HTML 2556
+#define IDR_POLYMER_1_0_PAPER_TOOLBAR_PAPER_TOOLBAR_EXTRACTED_JS 2557
+#define IDR_POLYMER_1_0_PAPER_TOOLBAR_PAPER_TOOLBAR_HTML 2558
+#define IDR_POLYMER_1_0_PAPER_TOOLTIP_PAPER_TOOLTIP_EXTRACTED_JS 2559
+#define IDR_POLYMER_1_0_PAPER_TOOLTIP_PAPER_TOOLTIP_HTML 2560
+#define IDR_POLYMER_1_0_POLYMER_POLYMER_EXTRACTED_JS 2561
+#define IDR_POLYMER_1_0_POLYMER_POLYMER_MICRO_EXTRACTED_JS 2562
+#define IDR_POLYMER_1_0_POLYMER_POLYMER_MICRO_HTML 2563
+#define IDR_POLYMER_1_0_POLYMER_POLYMER_MINI_EXTRACTED_JS 2564
+#define IDR_POLYMER_1_0_POLYMER_POLYMER_MINI_HTML 2565
+#define IDR_POLYMER_1_0_POLYMER_POLYMER_HTML 2566
+#define IDR_POLYMER_1_0_WEB_ANIMATIONS_JS_WEB_ANIMATIONS_NEXT_LITE_MIN_JS 2567
+
+#endif  // CEF_INCLUDE_CEF_PACK_RESOURCES_H_
diff --git a/src/include/libcef_/cef_pack_strings.h b/src/include/libcef_/cef_pack_strings.h
new file mode 100644
index 0000000..892f900
--- /dev/null
+++ b/src/include/libcef_/cef_pack_strings.h
@@ -0,0 +1,1085 @@
+// Copyright (c) 2018 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file is generated by the make_pack_header.py tool.
+//
+
+#ifndef CEF_INCLUDE_CEF_PACK_STRINGS_H_
+#define CEF_INCLUDE_CEF_PACK_STRINGS_H_
+#pragma once
+
+// ---------------------------------------------------------------------------
+// From cef_strings.h:
+
+#define IDS_MENU_BACK 28000
+#define IDS_MENU_FORWARD 28001
+#define IDS_MENU_RELOAD 28002
+#define IDS_MENU_RELOAD_NOCACHE 28003
+#define IDS_MENU_STOPLOAD 28004
+#define IDS_MENU_UNDO 28005
+#define IDS_MENU_REDO 28006
+#define IDS_MENU_CUT 28007
+#define IDS_MENU_COPY 28008
+#define IDS_MENU_PASTE 28009
+#define IDS_MENU_DELETE 28010
+#define IDS_MENU_SELECT_ALL 28011
+#define IDS_MENU_FIND 28012
+#define IDS_MENU_PRINT 28013
+#define IDS_MENU_VIEW_SOURCE 28014
+#define IDS_APP_AUDIO_FILES 28015
+#define IDS_APP_IMAGE_FILES 28016
+#define IDS_APP_TEXT_FILES 28017
+#define IDS_APP_VIDEO_FILES 28018
+#define IDS_DEFAULT_PRINT_DOCUMENT_TITLE 28019
+#define IDS_PRINT_SPOOL_FAILED_TITLE_TEXT 28020
+#define IDS_PRINT_SPOOL_FAILED_ERROR_TEXT 28021
+#define IDS_PRINT_INVALID_PRINTER_SETTINGS 28022
+#define IDS_UTILITY_PROCESS_EMF_CONVERTOR_NAME 28023
+#define IDS_UTILITY_PROCESS_PROXY_RESOLVER_NAME 28024
+#define IDS_SPELLCHECK_DICTIONARY 28025
+#define IDS_CONTENT_CONTEXT_ADD_TO_DICTIONARY 28026
+#define IDS_CONTENT_CONTEXT_NO_SPELLING_SUGGESTIONS 28027
+#define IDS_UTILITY_PROCESS_FONT_CACHE_BUILDER_NAME 28028
+#define IDS_PLUGIN_HIDE 28029
+#define IDS_PLUGIN_NOT_SUPPORTED 28030
+#define IDS_PLUGIN_BLOCKED 28031
+#define IDS_PLUGIN_NOT_SUPPORTED_METRO 28032
+#define IDS_PLUGIN_OUTDATED 28033
+#define IDS_PLUGIN_NOT_AUTHORIZED 28034
+#define IDS_PLUGIN_BLOCKED_BY_POLICY 28035
+#define IDS_CONTENT_CONTEXT_PLUGIN_RUN 28036
+#define IDS_CONTENT_CONTEXT_PLUGIN_HIDE 28037
+#define IDS_ACCEPT_LANGUAGES 28038
+#define IDS_DEFAULT_ENCODING 28039
+#define IDS_USES_UNIVERSAL_DETECTOR 28040
+#define IDS_STATIC_ENCODING_LIST 28041
+#define IDS_ENCODING_DISPLAY_TEMPLATE 28042
+#define IDS_ENCODING_UNICODE 28043
+#define IDS_ENCODING_WESTERN 28044
+#define IDS_ENCODING_SIMP_CHINESE 28045
+#define IDS_ENCODING_TRAD_CHINESE 28046
+#define IDS_ENCODING_KOREAN 28047
+#define IDS_ENCODING_JAPANESE 28048
+#define IDS_ENCODING_THAI 28049
+#define IDS_ENCODING_CENTRAL_EUROPEAN 28050
+#define IDS_ENCODING_CYRILLIC 28051
+#define IDS_ENCODING_GREEK 28052
+#define IDS_ENCODING_BALTIC 28053
+#define IDS_ENCODING_SOUTH_EUROPEAN 28054
+#define IDS_ENCODING_NORDIC 28055
+#define IDS_ENCODING_CELTIC 28056
+#define IDS_ENCODING_ROMANIAN 28057
+#define IDS_ENCODING_TURKISH 28058
+#define IDS_ENCODING_ARABIC 28059
+#define IDS_ENCODING_HEBREW 28060
+#define IDS_ENCODING_VIETNAMESE 28061
+
+// ---------------------------------------------------------------------------
+// From components_strings.h:
+
+#define IDS_JAVASCRIPT_MESSAGEBOX_TITLE 29160
+#define IDS_JAVASCRIPT_MESSAGEBOX_TITLE_IFRAME 29161
+#define IDS_JAVASCRIPT_MESSAGEBOX_TITLE_NONSTANDARD_URL 29162
+#define IDS_JAVASCRIPT_MESSAGEBOX_TITLE_NONSTANDARD_URL_IFRAME 29163
+#define IDS_JAVASCRIPT_MESSAGEBOX_SUPPRESS_OPTION 29164
+#define IDS_BEFOREUNLOAD_MESSAGEBOX_TITLE 29165
+#define IDS_BEFOREUNLOAD_MESSAGEBOX_FOOTER 29166
+#define IDS_BEFOREUNLOAD_MESSAGEBOX_OK_BUTTON_LABEL 29167
+#define IDS_BEFOREUNLOAD_MESSAGEBOX_CANCEL_BUTTON_LABEL 29168
+#define IDS_BEFORERELOAD_MESSAGEBOX_TITLE 29169
+#define IDS_BEFORERELOAD_MESSAGEBOX_FOOTER 29170
+#define IDS_BEFORERELOAD_MESSAGEBOX_OK_BUTTON_LABEL 29171
+#define IDS_BEFORERELOAD_MESSAGEBOX_CANCEL_BUTTON_LABEL 29172
+#define IDS_AUTOFILL_CLEAR_FORM_MENU_ITEM 29173
+#define IDS_AUTOFILL_CLEAR_LOCAL_COPY_BUTTON 29174
+#define IDS_AUTOFILL_WARNING_FORM_DISABLED 29175
+#define IDS_AUTOFILL_WARNING_INSECURE_CONNECTION 29176
+#define IDS_AUTOFILL_DELETE_AUTOCOMPLETE_SUGGESTION_CONFIRMATION_BODY 29177
+#define IDS_AUTOFILL_DELETE_CREDIT_CARD_SUGGESTION_CONFIRMATION_BODY 29178
+#define IDS_AUTOFILL_DELETE_PROFILE_SUGGESTION_CONFIRMATION_BODY 29179
+#define IDS_AUTOFILL_CC_AMEX 29180
+#define IDS_AUTOFILL_CC_AMEX_SHORT 29181
+#define IDS_AUTOFILL_CC_DINERS 29182
+#define IDS_AUTOFILL_CC_DISCOVER 29183
+#define IDS_AUTOFILL_CC_JCB 29184
+#define IDS_AUTOFILL_CC_MASTERCARD 29185
+#define IDS_AUTOFILL_CC_UNION_PAY 29186
+#define IDS_AUTOFILL_CC_VISA 29187
+#define IDS_AUTOFILL_CC_GENERIC 29188
+#define IDS_AUTOFILL_ADDRESS_LINE_SEPARATOR 29189
+#define IDS_AUTOFILL_ADDRESS_SUMMARY_SEPARATOR 29190
+#define IDS_AUTOFILL_FIELD_LABEL_STATE 29191
+#define IDS_AUTOFILL_FIELD_LABEL_AREA 29192
+#define IDS_AUTOFILL_FIELD_LABEL_COUNTY 29193
+#define IDS_AUTOFILL_FIELD_LABEL_DEPARTMENT 29194
+#define IDS_AUTOFILL_FIELD_LABEL_DISTRICT 29195
+#define IDS_AUTOFILL_FIELD_LABEL_EMIRATE 29196
+#define IDS_AUTOFILL_FIELD_LABEL_ISLAND 29197
+#define IDS_AUTOFILL_FIELD_LABEL_PARISH 29198
+#define IDS_AUTOFILL_FIELD_LABEL_PREFECTURE 29199
+#define IDS_AUTOFILL_FIELD_LABEL_PROVINCE 29200
+#define IDS_AUTOFILL_FIELD_LABEL_ZIP_CODE 29201
+#define IDS_AUTOFILL_FIELD_LABEL_POSTAL_CODE 29202
+#define IDS_AUTOFILL_FIELD_LABEL_COUNTRY 29203
+#define IDS_AUTOFILL_SHOW_PREDICTIONS_TITLE 29204
+#define IDS_AUTOFILL_DIALOG_PRIVACY_POLICY_LINK 29205
+#define IDS_AUTOFILL_OPTIONS_POPUP 29206
+#define IDS_AUTOFILL_OPTIONS_CONTENT_DESCRIPTION 29207
+#define IDS_AUTOFILL_CREDIT_CARD_NOT_SUPPORTED_BY_WALLET 29208
+#define IDS_AUTOFILL_CREDIT_CARD_NOT_SUPPORTED_BY_WALLET_FOR_MERCHANT 29209
+#define IDS_AUTOFILL_SCAN_CREDIT_CARD 29211
+#define IDS_AUTOFILL_PASSWORD_FIELD_SUGGESTIONS_TITLE 29212
+#define IDS_AUTOFILL_SAVE_CARD_PROMPT_ACCEPT 29213
+#define IDS_AUTOFILL_SAVE_CARD_PROMPT_DENY 29214
+#define IDS_AUTOFILL_SAVE_CARD_PROMPT_TITLE_LOCAL 29215
+#define IDS_AUTOFILL_SAVE_CARD_PROMPT_TITLE_TO_CLOUD 29216
+#define IDS_AUTOFILL_SAVE_CARD_PROMPT_UPLOAD_EXPLANATION 29217
+#define IDS_AUTOFILL_CREDIT_CARD_EXPIRATION_DATE_ABBR 29218
+#define IDS_AUTOFILL_CARD_UNMASK_PROMPT_ERROR_TRY_AGAIN 29219
+#define IDS_AUTOFILL_CARD_UNMASK_PROMPT_ERROR_TRY_AGAIN_WITH_EXPIRATION 29220
+#define IDS_AUTOFILL_CARD_UNMASK_PROMPT_ERROR_PERMANENT 29221
+#define IDS_AUTOFILL_CARD_UNMASK_PROMPT_ERROR_NETWORK 29222
+#define IDS_AUTOFILL_CARD_UNMASK_PROMPT_TITLE 29223
+#define IDS_AUTOFILL_CARD_UNMASK_PROMPT_UPDATE_TITLE 29224
+#define IDS_AUTOFILL_CARD_UNMASK_PROMPT_INSTRUCTIONS 29225
+#define IDS_AUTOFILL_CARD_UNMASK_PROMPT_INSTRUCTIONS_AMEX 29226
+#define IDS_AUTOFILL_CARD_UNMASK_PROMPT_INSTRUCTIONS_EXPIRED 29227
+#define IDS_AUTOFILL_CARD_UNMASK_PROMPT_INSTRUCTIONS_EXPIRED_AMEX 29228
+#define IDS_AUTOFILL_CARD_UNMASK_PROMPT_STORAGE_CHECKBOX 29229
+#define IDS_AUTOFILL_CARD_UNMASK_PROMPT_STORAGE_TOOLTIP 29230
+#define IDS_AUTOFILL_CARD_UNMASK_CONFIRM_BUTTON 29231
+#define IDS_AUTOFILL_CARD_UNMASK_VERIFICATION_IN_PROGRESS 29232
+#define IDS_AUTOFILL_CARD_UNMASK_VERIFICATION_SUCCESS 29233
+#define IDS_AUTOFILL_CARD_UNMASK_INVALID_EXPIRATION_DATE 29234
+#define IDS_AUTOFILL_CARD_UNMASK_EXPIRATION_DATE_SEPARATOR 29235
+#define IDS_AUTOFILL_CARD_UNMASK_NEW_CARD_LINK 29236
+#define IDS_AUTOFILL_DIALOG_PLACEHOLDER_CVC 29237
+#define IDS_BOOKMARK_BAR_FOLDER_NAME 29238
+#define IDS_BOOKMARK_BAR_MOBILE_FOLDER_NAME 29240
+#define IDS_BOOKMARK_BAR_OTHER_FOLDER_NAME 29241
+#define IDS_BOOKMARK_BAR_MANAGED_FOLDER_DOMAIN_NAME 29242
+#define IDS_BOOKMARK_BAR_MANAGED_FOLDER_DEFAULT_NAME 29243
+#define IDS_BOOKMARK_BAR_SUPERVISED_FOLDER_DEFAULT_NAME 29244
+#define IDS_SYNC_TIME_NEVER 29245
+#define IDS_SYNC_TIME_JUST_NOW 29246
+#define IDS_SETTINGS_TITLE 29247
+#define IDS_SETTINGS_HIDE_ADVANCED_SETTINGS 29248
+#define IDS_SETTINGS_SHOW_ADVANCED_SETTINGS 29249
+#define IDS_NETWORK_PREDICTION_ENABLED_DESCRIPTION 29250
+#define IDS_OPTIONS_PROXIES_CONFIGURE_BUTTON 29251
+#define IDS_CRASH_TITLE 29252
+#define IDS_CRASH_CRASH_COUNT_BANNER_FORMAT 29253
+#define IDS_CRASH_CRASH_HEADER_FORMAT 29254
+#define IDS_CRASH_CRASH_TIME_FORMAT 29255
+#define IDS_CRASH_BUG_LINK_LABEL 29256
+#define IDS_CRASH_NO_CRASHES_MESSAGE 29257
+#define IDS_CRASH_DISABLED_HEADER 29258
+#define IDS_CRASH_UPLOAD_MESSAGE 29259
+#define IDS_DATA_REDUCTION_PROXY_TITLE 29260
+#define IDS_DATA_REDUCTION_PROXY_BACK_BUTTON 29261
+#define IDS_DATA_REDUCTION_PROXY_CONTINUE_BUTTON 29262
+#define IDS_DATA_REDUCTION_PROXY_CANNOT_PROXY_HEADING 29263
+#define IDS_DATA_REDUCTION_PROXY_CANNOT_PROXY_PRIMARY_PARAGRAPH 29264
+#define IDS_DATA_REDUCTION_PROXY_CANNOT_PROXY_SECONDARY_PARAGRAPH 29265
+#define IDS_HTTP_POST_WARNING_TITLE 29266
+#define IDS_HTTP_POST_WARNING 29267
+#define IDS_HTTP_POST_WARNING_RESEND 29268
+#define IDS_DOM_DISTILLER_JAVASCRIPT_DISABLED_CONTENT 29269
+#define IDS_DOM_DISTILLER_WEBUI_ENTRY_URL 29270
+#define IDS_DOM_DISTILLER_WEBUI_ENTRY_ADD 29271
+#define IDS_DOM_DISTILLER_WEBUI_ENTRY_ADD_FAILED 29272
+#define IDS_DOM_DISTILLER_WEBUI_VIEW_URL 29273
+#define IDS_DOM_DISTILLER_WEBUI_VIEW_URL_FAILED 29274
+#define IDS_DOM_DISTILLER_WEBUI_REFRESH 29275
+#define IDS_DOM_DISTILLER_WEBUI_FETCHING_ENTRIES 29276
+#define IDS_DOM_DISTILLER_VIEWER_CLOSE_READER_VIEW 29277
+#define IDS_DOM_DISTILLER_VIEWER_FAILED_TO_FIND_ARTICLE_TITLE 29278
+#define IDS_DOM_DISTILLER_VIEWER_FAILED_TO_FIND_ARTICLE_CONTENT 29279
+#define IDS_DOM_DISTILLER_VIEWER_LOADING_TITLE 29280
+#define IDS_DOM_DISTILLER_VIEWER_NO_DATA_CONTENT 29281
+#define IDS_DOM_DISTILLER_VIEWER_LOADING_STRING 29282
+#define IDS_DOM_DISTILLER_QUALITY_QUESTION 29283
+#define IDS_DOM_DISTILLER_QUALITY_ANSWER_YES 29284
+#define IDS_DOM_DISTILLER_QUALITY_ANSWER_NO 29285
+#define IDS_DOM_DISTILLER_WEBUI_TITLE 29286
+#define IDS_FLAGS_ENHANCED_BOOKMARKS_NAME 29287
+#define IDS_FLAGS_ENHANCED_BOOKMARKS_DESCRIPTION 29288
+#define IDS_ERRORPAGE_NET_BUTTON_DETAILS 29289
+#define IDS_ERRORPAGE_NET_BUTTON_HIDE_DETAILS 29290
+#define IDS_ERRORPAGES_BUTTON_MORE 29291
+#define IDS_ERRORPAGES_BUTTON_LESS 29292
+#define IDS_ERRORPAGES_BUTTON_RELOAD 29293
+#define IDS_ERRORPAGES_BUTTON_SHOW_SAVED_COPY 29294
+#define IDS_ERRORPAGES_BUTTON_SHOW_SAVED_COPY_HELP 29295
+#define IDS_ERRORPAGE_FUN_DISABLED 29299
+#define IDS_ERRORPAGES_BUTTON_DIAGNOSE 29300
+#define IDS_ERRORPAGES_SUGGESTION_VISIT_GOOGLE_CACHE 29302
+#define IDS_ERRORPAGES_SUGGESTION_CORRECTED_URL 29303
+#define IDS_ERRORPAGES_SUGGESTION_ALTERNATE_URL 29304
+#define IDS_ERRORPAGES_SUGGESTION_RELOAD_REPOST_HEADER 29305
+#define IDS_ERRORPAGES_SUGGESTION_RELOAD_REPOST_BODY 29306
+#define IDS_ERRORPAGES_SUGGESTION_DISABLE_EXTENSION_HEADER 29307
+#define IDS_ERRORPAGES_SUGGESTION_CHECK_CONNECTION_HEADER 29308
+#define IDS_ERRORPAGES_SUGGESTION_CHECK_CONNECTION_BODY 29309
+#define IDS_ERRORPAGES_SUGGESTION_DNS_CONFIG_HEADER 29310
+#define IDS_ERRORPAGES_SUGGESTION_DNS_CONFIG_BODY 29311
+#define IDS_ERRORPAGES_SUGGESTION_NETWORK_PREDICTION_HEADER 29312
+#define IDS_ERRORPAGES_SUGGESTION_FIREWALL_CONFIG_BODY 29313
+#define IDS_ERRORPAGES_SUGGESTION_PROXY_CONFIG_HEADER 29314
+#define IDS_ERRORPAGES_SUGGESTION_PROXY_CONFIG_BODY 29315
+#define IDS_ERRORPAGES_SUGGESTION_LEARNMORE_BODY 29317
+#define IDS_ERRORPAGES_SUGGESTION_VIEW_POLICIES_HEADER 29318
+#define IDS_ERRORPAGES_SUGGESTION_VIEW_POLICIES_BODY 29319
+#define IDS_ERRORPAGES_SUGGESTION_CONTACT_ADMINISTRATOR_BODY 29320
+#define IDS_ERRORPAGES_SUGGESTION_GOOGLE_SEARCH 29321
+#define IDS_ERRORPAGES_TITLE_NOT_AVAILABLE 29322
+#define IDS_ERRORPAGES_TITLE_ACCESS_DENIED 29323
+#define IDS_ERRORPAGES_TITLE_NOT_FOUND 29324
+#define IDS_ERRORPAGES_TITLE_LOAD_FAILED 29325
+#define IDS_ERRORPAGES_TITLE_BLOCKED 29326
+#define IDS_ERRORPAGES_HEADING_NOT_AVAILABLE 29327
+#define IDS_ERRORPAGES_HEADING_NETWORK_ACCESS_DENIED 29328
+#define IDS_ERRORPAGES_HEADING_INTERNET_DISCONNECTED 29329
+#define IDS_ERRORPAGES_HEADING_CACHE_READ_FAILURE 29330
+#define IDS_ERRORPAGES_HEADING_CONNECTION_INTERRUPTED 29331
+#define IDS_ERRORPAGES_HEADING_NOT_FOUND 29332
+#define IDS_ERRORPAGES_HEADING_FILE_NOT_FOUND 29333
+#define IDS_ERRORPAGES_HEADING_TOO_MANY_REDIRECTS 29334
+#define IDS_ERRORPAGES_HEADING_EMPTY_RESPONSE 29335
+#define IDS_ERRORPAGES_HEADING_BLOCKED 29336
+#define IDS_ERRORPAGES_SUMMARY_NOT_AVAILABLE 29337
+#define IDS_ERRORPAGES_SUMMARY_TIMED_OUT 29338
+#define IDS_ERRORPAGES_SUMMARY_CONNECTION_RESET 29339
+#define IDS_ERRORPAGES_SUMMARY_CONNECTION_CLOSED 29340
+#define IDS_ERRORPAGES_SUMMARY_CONNECTION_FAILED 29341
+#define IDS_ERRORPAGES_SUMMARY_NETWORK_CHANGED 29342
+#define IDS_ERRORPAGES_SUMMARY_CONNECTION_REFUSED 29343
+#define IDS_ERRORPAGES_SUMMARY_NAME_NOT_RESOLVED 29344
+#define IDS_ERRORPAGES_SUMMARY_DNS_DEFINITION 29345
+#define IDS_ERRORPAGES_SUMMARY_ICANN_NAME_COLLISION 29346
+#define IDS_ERRORPAGES_SUMMARY_ADDRESS_UNREACHABLE 29347
+#define IDS_ERRORPAGES_SUMMARY_FILE_ACCESS_DENIED 29348
+#define IDS_ERRORPAGES_SUMMARY_NETWORK_ACCESS_DENIED 29349
+#define IDS_ERRORPAGES_SUMMARY_PROXY_CONNECTION_FAILED 29350
+#define IDS_ERRORPAGES_SUMMARY_INTERNET_DISCONNECTED_INSTRUCTIONS_TEMPLATE 29352
+#define IDS_ERRORPAGES_SUMMARY_INTERNET_DISCONNECTED 29351
+#define IDS_ERRORPAGES_SUMMARY_INTERNET_DISCONNECTED_PLATFORM 29353
+#define IDS_ERRORPAGES_SUMMARY_INTERNET_DISCONNECTED_PLATFORM_VISTA 29354
+#define IDS_ERRORPAGES_SUMMARY_INTERNET_DISCONNECTED_PLATFORM_XP 29355
+#define IDS_ERRORPAGES_SUMMARY_CACHE_READ_FAILURE 29356
+#define IDS_ERRORPAGES_SUMMARY_NETWORK_IO_SUSPENDED 29357
+#define IDS_ERRORPAGES_SUMMARY_NOT_FOUND 29358
+#define IDS_ERRORPAGES_SUMMARY_FILE_NOT_FOUND 29359
+#define IDS_ERRORPAGES_SUMMARY_TOO_MANY_REDIRECTS 29360
+#define IDS_ERRORPAGES_SUMMARY_EMPTY_RESPONSE 29361
+#define IDS_ERRORPAGES_SUMMARY_INVALID_RESPONSE 29362
+#define IDS_ERRORPAGES_SUMMARY_DNS_PROBE_RUNNING 29363
+#define IDS_ERRORPAGES_DETAILS_TIMED_OUT 29364
+#define IDS_ERRORPAGES_DETAILS_CONNECTION_CLOSED 29365
+#define IDS_ERRORPAGES_DETAILS_CONNECTION_RESET 29366
+#define IDS_ERRORPAGES_DETAILS_CONNECTION_REFUSED 29367
+#define IDS_ERRORPAGES_DETAILS_CONNECTION_FAILED 29368
+#define IDS_ERRORPAGES_DETAILS_NETWORK_CHANGED 29369
+#define IDS_ERRORPAGES_DETAILS_NAME_NOT_RESOLVED 29370
+#define IDS_ERRORPAGES_DETAILS_ICANN_NAME_COLLISION 29371
+#define IDS_ERRORPAGES_DETAILS_ADDRESS_UNREACHABLE 29372
+#define IDS_ERRORPAGES_DETAILS_NETWORK_ACCESS_DENIED 29373
+#define IDS_ERRORPAGES_DETAILS_FILE_ACCESS_DENIED 29374
+#define IDS_ERRORPAGES_DETAILS_PROXY_CONNECTION_FAILED 29375
+#define IDS_ERRORPAGES_DETAILS_INTERNET_DISCONNECTED 29376
+#define IDS_ERRORPAGES_DETAILS_CACHE_READ_FAILURE 29377
+#define IDS_ERRORPAGES_DETAILS_NETWORK_IO_SUSPENDED 29378
+#define IDS_ERRORPAGES_DETAILS_FILE_NOT_FOUND 29379
+#define IDS_ERRORPAGES_DETAILS_TOO_MANY_REDIRECTS 29380
+#define IDS_ERRORPAGES_DETAILS_EMPTY_RESPONSE 29381
+#define IDS_ERRORPAGES_DETAILS_RESPONSE_HEADERS_MULTIPLE_CONTENT_LENGTH 29382
+#define IDS_ERRORPAGES_DETAILS_RESPONSE_HEADERS_MULTIPLE_CONTENT_DISPOSITION 29383
+#define IDS_ERRORPAGES_DETAILS_RESPONSE_HEADERS_MULTIPLE_LOCATION 29384
+#define IDS_ERRORPAGES_DETAILS_DNS_PROBE_RUNNING 29385
+#define IDS_ERRORPAGES_DETAILS_UNKNOWN 29386
+#define IDS_ERRORPAGES_HEADING_ACCESS_DENIED 29387
+#define IDS_ERRORPAGES_HEADING_FILE_ACCESS_DENIED 29388
+#define IDS_ERRORPAGES_SUMMARY_FORBIDDEN 29389
+#define IDS_ERRORPAGES_DETAILS_FORBIDDEN 29390
+#define IDS_ERRORPAGES_SUMMARY_GONE 29391
+#define IDS_ERRORPAGES_DETAILS_GONE 29392
+#define IDS_ERRORPAGES_HEADING_PAGE_NOT_WORKING 29393
+#define IDS_ERRORPAGES_DETAILS_INTERNAL_SERVER_ERROR 29394
+#define IDS_ERRORPAGES_SUMMARY_WEBSITE_CANNOT_HANDLE_REQUEST 29395
+#define IDS_ERRORPAGES_DETAILS_NOT_IMPLEMENTED 29396
+#define IDS_ERRORPAGES_DETAILS_BAD_GATEWAY 29397
+#define IDS_ERRORPAGES_SUMMARY_SERVICE_UNAVAILABLE 29398
+#define IDS_ERRORPAGES_DETAILS_SERVICE_UNAVAILABLE 29399
+#define IDS_ERRORPAGES_SUMMARY_GATEWAY_TIMEOUT 29400
+#define IDS_ERRORPAGES_DETAILS_GATEWAY_TIMEOUT 29401
+#define IDS_ERRORPAGES_SUMMARY_SSL_SECURITY_ERROR 29402
+#define IDS_ERRORPAGES_DETAILS_SSL_PROTOCOL_ERROR 29403
+#define IDS_ERRORPAGES_DETAILS_SSL_FALLBACK_BEYOND_MINIMUM_VERSION 29404
+#define IDS_ERRORPAGES_SUMMARY_SSL_VERSION_OR_CIPHER_MISMATCH 29405
+#define IDS_ERRORPAGES_DETAILS_SSL_VERSION_OR_CIPHER_MISMATCH 29406
+#define IDS_ERRORPAGES_SUGGESTION_UNSUPPORTED_CIPHER 29407
+#define IDS_ERRORPAGES_SUMMARY_PINNING_FAILURE_DETAILS 29408
+#define IDS_ERRORPAGES_HEADING_INSECURE_CONNECTION 29409
+#define IDS_ERRORPAGES_SUMMARY_BAD_SSL_CLIENT_AUTH_CERT 29410
+#define IDS_ERRORPAGES_DETAILS_BAD_SSL_CLIENT_AUTH_CERT 29411
+#define IDS_ERRORPAGES_DETAILS_TEMPORARILY_THROTTLED 29412
+#define IDS_ERRORPAGES_SUMMARY_TEMPORARY_BACKOFF 29413
+#define IDS_ERRORPAGES_DETAILS_TEMPORARY_BACKOFF 29414
+#define IDS_ERRORPAGES_SUMMARY_BLOCKED_BY_EXTENSION 29415
+#define IDS_ERRORPAGES_SUMMARY_BLOCKED_BY_ADMINISTRATOR 29416
+#define IDS_ERRORPAGES_DETAILS_BLOCKED_BY_EXTENSION 29417
+#define IDS_ERRORPAGES_DETAILS_BLOCKED_BY_ADMINISTRATOR 29418
+#define IDS_ERRORPAGES_DETAILS_BLOCKED_ENROLLMENT_CHECK_PENDING 29419
+#define IDS_ERRORPAGES_HTTP_POST_WARNING 29420
+#define IDS_FLAGS_UI_LONG_TITLE 29432
+#define IDS_FLAGS_UI_TABLE_TITLE 29433
+#define IDS_FLAGS_UI_WARNING_HEADER 29434
+#define IDS_FLAGS_UI_WARNING_TEXT 29435
+#define IDS_FLAGS_UI_PROMOTE_BETA_CHANNEL 29436
+#define IDS_FLAGS_UI_PROMOTE_DEV_CHANNEL 29437
+#define IDS_FLAGS_UI_DISABLE 29438
+#define IDS_FLAGS_UI_ENABLE 29439
+#define IDS_FLAGS_UI_RESET_ALL_BUTTON 29440
+#define IDS_FLAGS_UI_UNSUPPORTED_TABLE_TITLE 29441
+#define IDS_FLAGS_UI_NOT_AVAILABLE 29442
+#define IDS_FLAGS_UI_ENABLE_NACL_NAME 29443
+#define IDS_FLAGS_UI_RELAUNCH_BUTTON 29444
+#define IDS_GENERIC_EXPERIMENT_CHOICE_AUTOMATIC 29446
+#define IDS_GENERIC_EXPERIMENT_CHOICE_DEFAULT 29447
+#define IDS_GENERIC_EXPERIMENT_CHOICE_ENABLED 29448
+#define IDS_GENERIC_EXPERIMENT_CHOICE_DISABLED 29449
+#define IDS_HISTORY_ACTION_MENU_DESCRIPTION 29452
+#define IDS_HISTORY_BLOCKED_VISIT_TEXT 29453
+#define IDS_HISTORY_BROWSERESULTS 29454
+#define IDS_HISTORY_CONTINUED 29455
+#define IDS_HISTORY_DATE_WITH_RELATIVE_TIME 29456
+#define IDS_HISTORY_DELETE_PRIOR_VISITS_CONFIRM_BUTTON 29457
+#define IDS_HISTORY_DELETE_PRIOR_VISITS_WARNING 29458
+#define IDS_HISTORY_DELETE_PRIOR_VISITS_WARNING_NO_INCOGNITO 29459
+#define IDS_HISTORY_ENTRY_BOOKMARKED 29460
+#define IDS_HISTORY_ENTRY_SUMMARY 29461
+#define IDS_HISTORY_FILTER_ALLOW_ITEMS 29462
+#define IDS_HISTORY_FILTER_ALLOWED 29463
+#define IDS_HISTORY_FILTER_BLOCK_ITEMS 29464
+#define IDS_HISTORY_FILTER_BLOCKED 29465
+#define IDS_HISTORY_FOUND_SEARCH_RESULTS 29466
+#define IDS_HISTORY_GROUP_BY_DOMAIN_LABEL 29467
+#define IDS_HISTORY_HAS_SYNCED_RESULTS 29468
+#define IDS_HISTORY_IN_CONTENT_PACK 29469
+#define IDS_HISTORY_INTERVAL 29470
+#define IDS_HISTORY_LOADING 29471
+#define IDS_HISTORY_MORE_FROM_SITE 29472
+#define IDS_HISTORY_NEWER 29473
+#define IDS_HISTORY_NEWEST 29474
+#define IDS_HISTORY_NO_RESULTS 29475
+#define IDS_HISTORY_NO_SEARCH_RESULTS 29476
+#define IDS_HISTORY_NO_SYNCED_RESULTS 29477
+#define IDS_HISTORY_NUMBER_VISITS 29478
+#define IDS_HISTORY_OLDER 29479
+#define IDS_HISTORY_OPEN_CLEAR_BROWSING_DATA_DIALOG 29480
+#define IDS_HISTORY_OTHER_DEVICES_X_MORE 29481
+#define IDS_HISTORY_OTHER_SESSIONS_COLLAPSE_SESSION 29482
+#define IDS_HISTORY_OTHER_SESSIONS_EXPAND_SESSION 29483
+#define IDS_HISTORY_OTHER_SESSIONS_OPEN_ALL 29484
+#define IDS_HISTORY_RANGE_ALL_TIME 29485
+#define IDS_HISTORY_RANGE_LABEL 29486
+#define IDS_HISTORY_RANGE_MONTH 29487
+#define IDS_HISTORY_RANGE_NEXT 29488
+#define IDS_HISTORY_RANGE_PREVIOUS 29489
+#define IDS_HISTORY_RANGE_TODAY 29490
+#define IDS_HISTORY_RANGE_WEEK 29491
+#define IDS_HISTORY_REMOVE_BOOKMARK 29492
+#define IDS_HISTORY_REMOVE_PAGE 29493
+#define IDS_HISTORY_REMOVE_SELECTED_ITEMS 29494
+#define IDS_HISTORY_SEARCH_BUTTON 29495
+#define IDS_HISTORY_SEARCH_RESULT 29496
+#define IDS_HISTORY_SEARCH_RESULTS 29497
+#define IDS_HISTORY_SEARCHRESULTSFOR 29498
+#define IDS_HISTORY_TITLE 29499
+#define IDS_HISTORY_UNKNOWN_DEVICE 29500
+#define IDS_AUTOCOMPLETE_SEARCH_DESCRIPTION 29501
+#define IDS_KEYWORD_SEARCH 29502
+#define IDS_EXTENSION_KEYWORD_COMMAND 29503
+#define IDS_EMPTY_KEYWORD_VALUE 29504
+#define IDS_LINK_FROM_CLIPBOARD 29505
+#define IDS_PASSWORD_MANAGER_EMPTY_LOGIN 29506
+#define IDS_PASSWORD_MANAGER_SMART_LOCK 29507
+#define IDS_PDF_NEED_PASSWORD 29508
+#define IDS_PDF_PASSWORD_SUBMIT 29509
+#define IDS_PDF_PASSWORD_INVALID 29510
+#define IDS_PDF_PAGE_LOADING 29511
+#define IDS_PDF_PAGE_LOAD_FAILED 29512
+#define IDS_PDF_PAGE_RELOAD_BUTTON 29513
+#define IDS_PDF_BOOKMARKS 29514
+#define IDS_PDF_TOOLTIP_ROTATE_CW 29515
+#define IDS_PDF_TOOLTIP_DOWNLOAD 29516
+#define IDS_PDF_TOOLTIP_PRINT 29517
+#define IDS_PDF_TOOLTIP_FIT_PAGE 29518
+#define IDS_PDF_TOOLTIP_FIT_WIDTH 29519
+#define IDS_PDF_TOOLTIP_ZOOM_IN 29520
+#define IDS_PDF_TOOLTIP_ZOOM_OUT 29521
+#define IDS_PDF_LABEL_PAGE_NUMBER 29522
+#define IDS_POLICY_DM_STATUS_SUCCESS 29523
+#define IDS_POLICY_DM_STATUS_REQUEST_INVALID 29524
+#define IDS_POLICY_DM_STATUS_REQUEST_FAILED 29525
+#define IDS_POLICY_DM_STATUS_TEMPORARY_UNAVAILABLE 29526
+#define IDS_POLICY_DM_STATUS_HTTP_STATUS_ERROR 29527
+#define IDS_POLICY_DM_STATUS_RESPONSE_DECODING_ERROR 29528
+#define IDS_POLICY_DM_STATUS_SERVICE_MANAGEMENT_NOT_SUPPORTED 29529
+#define IDS_POLICY_DM_STATUS_SERVICE_DEVICE_NOT_FOUND 29530
+#define IDS_POLICY_DM_STATUS_SERVICE_MANAGEMENT_TOKEN_INVALID 29531
+#define IDS_POLICY_DM_STATUS_SERVICE_ACTIVATION_PENDING 29532
+#define IDS_POLICY_DM_STATUS_SERVICE_INVALID_SERIAL_NUMBER 29533
+#define IDS_POLICY_DM_STATUS_SERVICE_DEVICE_ID_CONFLICT 29534
+#define IDS_POLICY_DM_STATUS_SERVICE_MISSING_LICENSES 29535
+#define IDS_POLICY_DM_STATUS_SERVICE_DEPROVISIONED 29536
+#define IDS_POLICY_DM_STATUS_SERVICE_POLICY_NOT_FOUND 29537
+#define IDS_POLICY_DM_STATUS_UNKNOWN_ERROR 29538
+#define IDS_POLICY_DM_STATUS_SERVICE_DOMAIN_MISMATCH 29539
+#define IDS_POLICY_VALIDATION_OK 29540
+#define IDS_POLICY_VALIDATION_BAD_INITIAL_SIGNATURE 29541
+#define IDS_POLICY_VALIDATION_BAD_SIGNATURE 29542
+#define IDS_POLICY_VALIDATION_ERROR_CODE_PRESENT 29543
+#define IDS_POLICY_VALIDATION_PAYLOAD_PARSE_ERROR 29544
+#define IDS_POLICY_VALIDATION_WRONG_POLICY_TYPE 29545
+#define IDS_POLICY_VALIDATION_WRONG_SETTINGS_ENTITY_ID 29546
+#define IDS_POLICY_VALIDATION_BAD_TIMESTAMP 29547
+#define IDS_POLICY_VALIDATION_WRONG_TOKEN 29548
+#define IDS_POLICY_VALIDATION_BAD_USERNAME 29549
+#define IDS_POLICY_VALIDATION_POLICY_PARSE_ERROR 29550
+#define IDS_POLICY_VALIDATION_BAD_KEY_VERIFICATION_SIGNATURE 29551
+#define IDS_POLICY_VALIDATION_UNKNOWN_ERROR 29552
+#define IDS_POLICY_STORE_STATUS_OK 29553
+#define IDS_POLICY_STORE_STATUS_LOAD_ERROR 29554
+#define IDS_POLICY_STORE_STATUS_STORE_ERROR 29555
+#define IDS_POLICY_STORE_STATUS_PARSE_ERROR 29556
+#define IDS_POLICY_STORE_STATUS_SERIALIZE_ERROR 29557
+#define IDS_POLICY_STORE_STATUS_VALIDATION_ERROR 29558
+#define IDS_POLICY_STORE_STATUS_BAD_STATE 29559
+#define IDS_POLICY_STORE_STATUS_UNKNOWN_ERROR 29560
+#define IDS_POLICY_ASSOCIATION_STATE_ACTIVE 29561
+#define IDS_POLICY_ASSOCIATION_STATE_UNMANAGED 29562
+#define IDS_POLICY_ASSOCIATION_STATE_DEPROVISIONED 29563
+#define IDS_POLICY_TYPE_ERROR 29564
+#define IDS_POLICY_OUT_OF_RANGE_ERROR 29565
+#define IDS_POLICY_VALUE_FORMAT_ERROR 29566
+#define IDS_POLICY_DEFAULT_SEARCH_DISABLED 29567
+#define IDS_POLICY_NOT_SPECIFIED_ERROR 29568
+#define IDS_POLICY_SUBKEY_ERROR 29569
+#define IDS_POLICY_LIST_ENTRY_ERROR 29570
+#define IDS_POLICY_SCHEMA_VALIDATION_ERROR 29571
+#define IDS_POLICY_INVALID_SEARCH_URL_ERROR 29572
+#define IDS_POLICY_INVALID_PROXY_MODE_ERROR 29573
+#define IDS_POLICY_INVALID_UPDATE_URL_ERROR 29574
+#define IDS_POLICY_PROXY_MODE_DISABLED_ERROR 29575
+#define IDS_POLICY_PROXY_MODE_AUTO_DETECT_ERROR 29576
+#define IDS_POLICY_PROXY_MODE_PAC_URL_ERROR 29577
+#define IDS_POLICY_PROXY_MODE_FIXED_SERVERS_ERROR 29578
+#define IDS_POLICY_PROXY_MODE_SYSTEM_ERROR 29579
+#define IDS_POLICY_PROXY_BOTH_SPECIFIED_ERROR 29580
+#define IDS_POLICY_PROXY_NEITHER_SPECIFIED_ERROR 29581
+#define IDS_POLICY_OVERRIDDEN 29582
+#define IDS_POLICY_DEPRECATED 29583
+#define IDS_POLICY_VALUE_DEPRECATED 29584
+#define IDS_POLICY_LEVEL_ERROR 29589
+#define IDS_POLICY_OK 29590
+#define IDS_POLICY_UNSET 29591
+#define IDS_POLICY_UNKNOWN 29592
+#define IDS_POLICY_TITLE 29593
+#define IDS_POLICY_FILTER_PLACEHOLDER 29594
+#define IDS_POLICY_RELOAD_POLICIES 29595
+#define IDS_POLICY_STATUS 29596
+#define IDS_POLICY_STATUS_DEVICE 29597
+#define IDS_POLICY_STATUS_USER 29598
+#define IDS_POLICY_LABEL_DOMAIN 29599
+#define IDS_POLICY_LABEL_USERNAME 29600
+#define IDS_POLICY_LABEL_CLIENT_ID 29601
+#define IDS_POLICY_LABEL_ASSET_ID 29602
+#define IDS_POLICY_LABEL_LOCATION 29603
+#define IDS_POLICY_LABEL_DIRECTORY_API_ID 29604
+#define IDS_POLICY_LABEL_TIME_SINCE_LAST_REFRESH 29605
+#define IDS_POLICY_NOT_SPECIFIED 29606
+#define IDS_POLICY_NEVER_FETCHED 29607
+#define IDS_POLICY_LABEL_REFRESH_INTERVAL 29608
+#define IDS_POLICY_LABEL_STATUS 29609
+#define IDS_POLICY_SHOW_UNSET 29610
+#define IDS_POLICY_NO_POLICIES_SET 29611
+#define IDS_POLICY_HEADER_SCOPE 29612
+#define IDS_POLICY_HEADER_LEVEL 29613
+#define IDS_POLICY_HEADER_NAME 29614
+#define IDS_POLICY_HEADER_VALUE 29615
+#define IDS_POLICY_HEADER_STATUS 29616
+#define IDS_POLICY_HEADER_SOURCE 29617
+#define IDS_POLICY_SHOW_EXPANDED_VALUE 29618
+#define IDS_POLICY_HIDE_EXPANDED_VALUE 29619
+#define IDS_POLICY_SCOPE_USER 29620
+#define IDS_POLICY_SCOPE_DEVICE 29621
+#define IDS_POLICY_LEVEL_RECOMMENDED 29622
+#define IDS_POLICY_LEVEL_MANDATORY 29623
+#define IDS_POLICY_INVALID_BOOKMARK 29624
+#define IDS_POLICY_SOURCE_ENTERPRISE_DEFAULT 29625
+#define IDS_POLICY_SOURCE_CLOUD 29626
+#define IDS_POLICY_SOURCE_PLATFORM 29627
+#define IDS_POLICY_SOURCE_PUBLIC_SESSION_OVERRIDE 29628
+#define IDS_POLICY_RISK_TAG_FULL_ADMIN_ACCESS 29629
+#define IDS_POLICY_RISK_TAG_SYSTEM_SECURITY 29630
+#define IDS_POLICY_RISK_TAG_WEBSITE_SHARING 29631
+#define IDS_POLICY_RISK_TAG_ADMIN_SHARING 29632
+#define IDS_POLICY_RISK_TAG_FILTERING 29633
+#define IDS_POLICY_RISK_TAG_LOCAL_DATA_ACCESS 29634
+#define IDS_POLICY_RISK_TAG_GOOGLE_SHARING 29635
+#define IDS_SSL_OPEN_DETAILS_BUTTON 29636
+#define IDS_SSL_CLOSE_DETAILS_BUTTON 29637
+#define IDS_CLOCK_ERROR_TITLE 29638
+#define IDS_CLOCK_ERROR_AHEAD_HEADING 29639
+#define IDS_CLOCK_ERROR_BEHIND_HEADING 29640
+#define IDS_CLOCK_ERROR_UPDATE_DATE_AND_TIME 29641
+#define IDS_CLOCK_ERROR_PRIMARY_PARAGRAPH 29642
+#define IDS_CLOCK_ERROR_EXPLANATION 29643
+#define IDS_SAFE_BROWSING_PRIVACY_POLICY_URL 29644
+#define IDS_SSL_V2_TITLE 29645
+#define IDS_SSL_V2_HEADING 29646
+#define IDS_SSL_V2_PRIMARY_PARAGRAPH 29647
+#define IDS_SSL_NONOVERRIDABLE_MORE 29648
+#define IDS_SSL_NONOVERRIDABLE_INVALID 29649
+#define IDS_SSL_OVERRIDABLE_SAFETY_BUTTON 29650
+#define IDS_SSL_OVERRIDABLE_PROCEED_PARAGRAPH 29651
+#define IDS_SSL_RELOAD 29652
+#define IDS_SSL_NONOVERRIDABLE_PINNED 29653
+#define IDS_SSL_NONOVERRIDABLE_HSTS 29654
+#define IDS_SSL_NONOVERRIDABLE_REVOKED 29655
+#define IDS_CERT_ERROR_COMMON_NAME_INVALID_DETAILS 29656
+#define IDS_CERT_ERROR_COMMON_NAME_INVALID_DESCRIPTION 29657
+#define IDS_CERT_ERROR_EXPIRED_DETAILS 29658
+#define IDS_CERT_ERROR_EXPIRED_DESCRIPTION 29659
+#define IDS_CERT_ERROR_NOT_YET_VALID_DETAILS 29660
+#define IDS_CERT_ERROR_NOT_YET_VALID_DESCRIPTION 29661
+#define IDS_CERT_ERROR_NOT_VALID_AT_THIS_TIME_DETAILS 29662
+#define IDS_CERT_ERROR_NOT_VALID_AT_THIS_TIME_DESCRIPTION 29663
+#define IDS_CERT_ERROR_CHAIN_EXPIRED_DETAILS 29664
+#define IDS_CERT_ERROR_CHAIN_EXPIRED_DESCRIPTION 29665
+#define IDS_CERT_ERROR_AUTHORITY_INVALID_DESCRIPTION 29666
+#define IDS_CERT_ERROR_CONTAINS_ERRORS_DETAILS 29667
+#define IDS_CERT_ERROR_CONTAINS_ERRORS_DESCRIPTION 29668
+#define IDS_CERT_ERROR_UNABLE_TO_CHECK_REVOCATION_DETAILS 29669
+#define IDS_CERT_ERROR_UNABLE_TO_CHECK_REVOCATION_DESCRIPTION 29670
+#define IDS_CERT_ERROR_NO_REVOCATION_MECHANISM_DETAILS 29671
+#define IDS_CERT_ERROR_NO_REVOCATION_MECHANISM_DESCRIPTION 29672
+#define IDS_CERT_ERROR_REVOKED_CERT_DETAILS 29673
+#define IDS_CERT_ERROR_REVOKED_CERT_DESCRIPTION 29674
+#define IDS_CERT_ERROR_INVALID_CERT_DETAILS 29675
+#define IDS_CERT_ERROR_INVALID_CERT_DESCRIPTION 29676
+#define IDS_CERT_ERROR_WEAK_SIGNATURE_ALGORITHM_DETAILS 29677
+#define IDS_CERT_ERROR_WEAK_SIGNATURE_ALGORITHM_DESCRIPTION 29678
+#define IDS_CERT_ERROR_WEAK_KEY_DETAILS 29679
+#define IDS_CERT_ERROR_WEAK_KEY_DESCRIPTION 29680
+#define IDS_CERT_ERROR_NAME_CONSTRAINT_VIOLATION_DETAILS 29681
+#define IDS_CERT_ERROR_NAME_CONSTRAINT_VIOLATION_DESCRIPTION 29682
+#define IDS_CERT_ERROR_VALIDITY_TOO_LONG_DETAILS 29683
+#define IDS_CERT_ERROR_VALIDITY_TOO_LONG_DESCRIPTION 29684
+#define IDS_CERT_ERROR_UNKNOWN_ERROR_DETAILS 29685
+#define IDS_CERT_ERROR_UNKNOWN_ERROR_DESCRIPTION 29686
+#define IDS_CERT_ERROR_SUMMARY_PINNING_FAILURE_DETAILS 29687
+#define IDS_CERT_ERROR_SUMMARY_PINNING_FAILURE_DESCRIPTION 29688
+#define IDS_CERT_ERROR_AUTHORITY_INVALID_DETAILS 29689
+#define IDS_SYNC_BASIC_ENCRYPTION_DATA 29690
+#define IDS_SYNC_CONFIGURE_ENCRYPTION 29691
+#define IDS_SYNC_DATATYPE_AUTOFILL 29692
+#define IDS_SYNC_DATATYPE_BOOKMARKS 29693
+#define IDS_SYNC_DATATYPE_PASSWORDS 29694
+#define IDS_SYNC_DATATYPE_TABS 29695
+#define IDS_SYNC_DATATYPE_TYPED_URLS 29696
+#define IDS_SYNC_EMPTY_PASSPHRASE_ERROR 29697
+#define IDS_SYNC_ENCRYPTION_SECTION_TITLE 29698
+#define IDS_SYNC_ENTER_GOOGLE_PASSPHRASE_BODY 29699
+#define IDS_SYNC_FULL_ENCRYPTION_DATA 29700
+#define IDS_SYNC_LOGIN_INFO_OUT_OF_DATE 29701
+#define IDS_SYNC_LOGIN_SETTING_UP 29702
+#define IDS_SYNC_PASSPHRASE_LABEL 29703
+#define IDS_SYNC_PASSPHRASE_MISMATCH_ERROR 29704
+#define IDS_SYNC_SERVICE_UNAVAILABLE 29705
+#define IDS_SYNC_ENTER_PASSPHRASE_BODY_WITH_DATE 29706
+#define IDS_SYNC_ENTER_PASSPHRASE_BODY 29707
+#define IDS_TRANSLATE_INFOBAR_OPTIONS 29708
+#define IDS_TRANSLATE_INFOBAR_OPTIONS_NEVER_TRANSLATE_LANG 29709
+#define IDS_TRANSLATE_INFOBAR_OPTIONS_NEVER_TRANSLATE_SITE 29710
+#define IDS_TRANSLATE_INFOBAR_OPTIONS_ALWAYS 29711
+#define IDS_TRANSLATE_INFOBAR_OPTIONS_REPORT_ERROR 29712
+#define IDS_TRANSLATE_INFOBAR_OPTIONS_ABOUT 29713
+#define IDS_TRANSLATE_INFOBAR_BEFORE_MESSAGE 29714
+#define IDS_TRANSLATE_INFOBAR_ACCEPT 29717
+#define IDS_TRANSLATE_INFOBAR_DENY 29718
+#define IDS_TRANSLATE_INFOBAR_NEVER_TRANSLATE 29719
+#define IDS_TRANSLATE_INFOBAR_ALWAYS_TRANSLATE 29720
+#define IDS_TRANSLATE_INFOBAR_TRANSLATING_TO 29721
+#define IDS_TRANSLATE_INFOBAR_AFTER_MESSAGE 29722
+#define IDS_TRANSLATE_INFOBAR_AFTER_MESSAGE_AUTODETERMINED_SOURCE_LANGUAGE 29723
+#define IDS_TRANSLATE_INFOBAR_REVERT 29725
+#define IDS_TRANSLATE_INFOBAR_RETRY 29726
+#define IDS_TRANSLATE_INFOBAR_ERROR_CANT_CONNECT 29727
+#define IDS_TRANSLATE_INFOBAR_ERROR_CANT_TRANSLATE 29728
+#define IDS_TRANSLATE_INFOBAR_UNKNOWN_PAGE_LANGUAGE 29729
+#define IDS_TRANSLATE_INFOBAR_ERROR_SAME_LANGUAGE 29730
+#define IDS_TRANSLATE_INFOBAR_UNSUPPORTED_PAGE_LANGUAGE 29731
+#define IDS_BOOKMARK_BAR_UNDO 29733
+#define IDS_BOOKMARK_BAR_REDO 29734
+#define IDS_BOOKMARK_BAR_UNDO_ADD 29735
+#define IDS_BOOKMARK_BAR_REDO_ADD 29736
+#define IDS_BOOKMARK_BAR_UNDO_DELETE 29737
+#define IDS_BOOKMARK_BAR_REDO_DELETE 29738
+#define IDS_BOOKMARK_BAR_UNDO_EDIT 29739
+#define IDS_BOOKMARK_BAR_REDO_EDIT 29740
+#define IDS_BOOKMARK_BAR_UNDO_MOVE 29741
+#define IDS_BOOKMARK_BAR_REDO_MOVE 29742
+#define IDS_BOOKMARK_BAR_UNDO_REORDER 29743
+#define IDS_BOOKMARK_BAR_REDO_REORDER 29744
+#define IDS_VERSION_UI_TITLE 29745
+#define IDS_VERSION_UI_OFFICIAL 29746
+#define IDS_VERSION_UI_UNOFFICIAL 29747
+#define IDS_VERSION_UI_32BIT 29748
+#define IDS_VERSION_UI_64BIT 29749
+#define IDS_VERSION_UI_REVISION 29750
+#define IDS_VERSION_UI_OS 29751
+#define IDS_VERSION_UI_USER_AGENT 29752
+#define IDS_VERSION_UI_COMMAND_LINE 29753
+#define IDS_VERSION_UI_EXECUTABLE_PATH 29755
+#define IDS_VERSION_UI_PROFILE_PATH 29756
+#define IDS_VERSION_UI_PATH_NOTFOUND 29757
+#define IDS_VERSION_UI_VARIATIONS 29758
+#define IDS_CANCEL 29760
+#define IDS_CLOSE 29761
+#define IDS_DONE 29762
+#define IDS_LEARN_MORE 29763
+#define IDS_OK 29764
+#define IDS_PRINT 29765
+#define IDS_ACCNAME_BACK 29766
+#define IDS_ACCNAME_FORWARD 29767
+#define IDS_ACCNAME_CLOSE 29768
+#define IDS_ACCNAME_LOCATION 29769
+#define IDS_UTILITY_PROCESS_JSON_PARSER_NAME 29770
+
+// ---------------------------------------------------------------------------
+// From content_strings.h:
+
+#define IDS_DETAILS_WITHOUT_SUMMARY_LABEL 18900
+#define IDS_SEARCHABLE_INDEX_INTRO 18901
+#define IDS_FORM_CALENDAR_CLEAR 18902
+#define IDS_FORM_CALENDAR_TODAY 18903
+#define IDS_FORM_DATE_FORMAT_DAY_IN_MONTH 18904
+#define IDS_FORM_DATE_FORMAT_MONTH 18905
+#define IDS_FORM_DATE_FORMAT_YEAR 18906
+#define IDS_FORM_SUBMIT_LABEL 18907
+#define IDS_FORM_INPUT_ALT 18908
+#define IDS_FORM_RESET_LABEL 18909
+#define IDS_FORM_FILE_BUTTON_LABEL 18910
+#define IDS_FORM_MULTIPLE_FILES_BUTTON_LABEL 18911
+#define IDS_FORM_FILE_NO_FILE_LABEL 18912
+#define IDS_FORM_FILE_MULTIPLE_UPLOAD 18913
+#define IDS_FORM_OTHER_COLOR_LABEL 18914
+#define IDS_FORM_OTHER_DATE_LABEL 18915
+#define IDS_FORM_OTHER_MONTH_LABEL 18916
+#define IDS_FORM_OTHER_TIME_LABEL 18917
+#define IDS_FORM_OTHER_WEEK_LABEL 18918
+#define IDS_FORM_PLACEHOLDER_FOR_DAY_OF_MONTH_FIELD 18919
+#define IDS_FORM_PLACEHOLDER_FOR_MONTH_FIELD 18920
+#define IDS_FORM_PLACEHOLDER_FOR_YEAR_FIELD 18921
+#define IDS_FORM_SELECT_MENU_LIST_TEXT 18922
+#define IDS_FORM_THIS_MONTH_LABEL 18923
+#define IDS_FORM_THIS_WEEK_LABEL 18924
+#define IDS_FORM_WEEK_NUMBER_LABEL 18925
+#define IDS_RECENT_SEARCHES_NONE 18926
+#define IDS_RECENT_SEARCHES 18927
+#define IDS_RECENT_SEARCHES_CLEAR 18928
+#define IDS_AX_CALENDAR_SHOW_MONTH_SELECTOR 18929
+#define IDS_AX_CALENDAR_SHOW_NEXT_MONTH 18930
+#define IDS_AX_CALENDAR_SHOW_PREVIOUS_MONTH 18931
+#define IDS_AX_CALENDAR_WEEK_DESCRIPTION 18932
+#define IDS_AX_ROLE_ADDRESS 18933
+#define IDS_AX_ROLE_ARTICLE 18934
+#define IDS_AX_ROLE_BANNER 18935
+#define IDS_AX_ROLE_COMPLEMENTARY 18936
+#define IDS_AX_ROLE_CHECK_BOX 18937
+#define IDS_AX_ROLE_DESCRIPTION_DETAIL 18938
+#define IDS_AX_ROLE_DESCRIPTION_LIST 18939
+#define IDS_AX_ROLE_DESCRIPTION_TERM 18940
+#define IDS_AX_ROLE_FIGURE 18941
+#define IDS_AX_ROLE_FORM 18942
+#define IDS_AX_ROLE_HEADING 18946
+#define IDS_AX_ROLE_IMAGE_MAP 18947
+#define IDS_AX_ROLE_LINK 18948
+#define IDS_AX_ROLE_LIST_MARKER 18949
+#define IDS_AX_ROLE_MAIN_CONTENT 18950
+#define IDS_AX_ROLE_MARK 18951
+#define IDS_AX_ROLE_MATH 18952
+#define IDS_AX_ROLE_NAVIGATIONAL_LINK 18953
+#define IDS_AX_ROLE_REGION 18954
+#define IDS_AX_ROLE_SEARCH_BOX 18955
+#define IDS_AX_ROLE_STATUS 18956
+#define IDS_AX_ROLE_SWITCH 18957
+#define IDS_AX_ROLE_WEB_AREA 18958
+#define IDS_AX_BUTTON_ACTION_VERB 18959
+#define IDS_AX_RADIO_BUTTON_ACTION_VERB 18960
+#define IDS_AX_TEXT_FIELD_ACTION_VERB 18961
+#define IDS_AX_CHECKED_CHECK_BOX_ACTION_VERB 18962
+#define IDS_AX_UNCHECKED_CHECK_BOX_ACTION_VERB 18963
+#define IDS_AX_LINK_ACTION_VERB 18964
+#define IDS_AX_AM_PM_FIELD_TEXT 18965
+#define IDS_AX_DAY_OF_MONTH_FIELD_TEXT 18966
+#define IDS_AX_DATE_TIME_FIELD_EMPTY_VALUE_TEXT 18967
+#define IDS_AX_HOUR_FIELD_TEXT 18968
+#define IDS_AX_MEDIA_DEFAULT 18969
+#define IDS_AX_MEDIA_AUDIO_ELEMENT 18970
+#define IDS_AX_MEDIA_VIDEO_ELEMENT 18971
+#define IDS_AX_MEDIA_MUTE_BUTTON 18972
+#define IDS_AX_MEDIA_UNMUTE_BUTTON 18973
+#define IDS_AX_MEDIA_PLAY_BUTTON 18974
+#define IDS_AX_MEDIA_PAUSE_BUTTON 18975
+#define IDS_AX_MEDIA_SLIDER 18976
+#define IDS_AX_MEDIA_SLIDER_THUMB 18977
+#define IDS_AX_MEDIA_CURRENT_TIME_DISPLAY 18978
+#define IDS_AX_MEDIA_TIME_REMAINING_DISPLAY 18979
+#define IDS_AX_MEDIA_STATUS_DISPLAY 18980
+#define IDS_AX_MEDIA_ENTER_FULL_SCREEN_BUTTON 18981
+#define IDS_AX_MEDIA_EXIT_FULL_SCREEN_BUTTON 18982
+#define IDS_AX_MEDIA_SHOW_CLOSED_CAPTIONS_BUTTON 18983
+#define IDS_AX_MEDIA_HIDE_CLOSED_CAPTIONS_BUTTON 18984
+#define IDS_AX_MEDIA_CAST_OFF_BUTTON 18985
+#define IDS_AX_MEDIA_CAST_ON_BUTTON 18986
+#define IDS_AX_MEDIA_AUDIO_ELEMENT_HELP 18987
+#define IDS_AX_MEDIA_VIDEO_ELEMENT_HELP 18988
+#define IDS_AX_MEDIA_MUTE_BUTTON_HELP 18989
+#define IDS_AX_MEDIA_UNMUTE_BUTTON_HELP 18990
+#define IDS_AX_MEDIA_PLAY_BUTTON_HELP 18991
+#define IDS_AX_MEDIA_PAUSE_BUTTON_HELP 18992
+#define IDS_AX_MEDIA_AUDIO_SLIDER_HELP 18993
+#define IDS_AX_MEDIA_VIDEO_SLIDER_HELP 18994
+#define IDS_AX_MEDIA_SLIDER_THUMB_HELP 18995
+#define IDS_AX_MEDIA_CURRENT_TIME_DISPLAY_HELP 18996
+#define IDS_AX_MEDIA_TIME_REMAINING_DISPLAY_HELP 18997
+#define IDS_AX_MEDIA_STATUS_DISPLAY_HELP 18998
+#define IDS_AX_MEDIA_ENTER_FULL_SCREEN_BUTTON_HELP 18999
+#define IDS_AX_MEDIA_EXIT_FULL_SCREEN_BUTTON_HELP 19000
+#define IDS_AX_MEDIA_SHOW_CLOSED_CAPTIONS_BUTTON_HELP 19001
+#define IDS_AX_MEDIA_HIDE_CLOSED_CAPTIONS_BUTTON_HELP 19002
+#define IDS_AX_MEDIA_CAST_OFF_BUTTON_HELP 19003
+#define IDS_AX_MEDIA_CAST_ON_BUTTON_HELP 19004
+#define IDS_AX_MILLISECOND_FIELD_TEXT 19005
+#define IDS_AX_MINUTE_FIELD_TEXT 19006
+#define IDS_AX_MONTH_FIELD_TEXT 19007
+#define IDS_AX_SECOND_FIELD_TEXT 19008
+#define IDS_AX_WEEK_OF_YEAR_FIELD_TEXT 19009
+#define IDS_AX_YEAR_FIELD_TEXT 19010
+#define IDS_KEYGEN_HIGH_GRADE_KEY 19011
+#define IDS_KEYGEN_MED_GRADE_KEY 19012
+#define IDS_FORM_INPUT_WEEK_TEMPLATE 19013
+#define IDS_FORM_VALIDATION_VALUE_MISSING_MULTIPLE_FILE 19014
+#define IDS_FORM_VALIDATION_TYPE_MISMATCH 19015
+#define IDS_FORM_VALIDATION_TYPE_MISMATCH_EMAIL_EMPTY 19016
+#define IDS_FORM_VALIDATION_TYPE_MISMATCH_EMAIL_EMPTY_DOMAIN 19017
+#define IDS_FORM_VALIDATION_TYPE_MISMATCH_EMAIL_EMPTY_LOCAL 19018
+#define IDS_FORM_VALIDATION_TYPE_MISMATCH_EMAIL_INVALID_DOMAIN 19019
+#define IDS_FORM_VALIDATION_TYPE_MISMATCH_EMAIL_INVALID_DOTS 19020
+#define IDS_FORM_VALIDATION_TYPE_MISMATCH_EMAIL_INVALID_LOCAL 19021
+#define IDS_FORM_VALIDATION_TYPE_MISMATCH_EMAIL_NO_AT_SIGN 19022
+#define IDS_FORM_VALIDATION_TYPE_MISMATCH_MULTIPLE_EMAIL 19023
+#define IDS_FORM_VALIDATION_RANGE_UNDERFLOW 19024
+#define IDS_FORM_VALIDATION_RANGE_UNDERFLOW_DATETIME 19025
+#define IDS_FORM_VALIDATION_RANGE_OVERFLOW 19026
+#define IDS_FORM_VALIDATION_RANGE_OVERFLOW_DATETIME 19027
+#define IDS_FORM_VALIDATION_BAD_INPUT_DATETIME 19028
+#define IDS_FORM_VALIDATION_BAD_INPUT_NUMBER 19029
+#define IDS_FORM_VALIDATION_VALUE_MISSING 19030
+#define IDS_FORM_VALIDATION_VALUE_MISSING_CHECKBOX 19031
+#define IDS_FORM_VALIDATION_VALUE_MISSING_FILE 19032
+#define IDS_FORM_VALIDATION_VALUE_MISSING_RADIO 19033
+#define IDS_FORM_VALIDATION_VALUE_MISSING_SELECT 19034
+#define IDS_FORM_VALIDATION_TYPE_MISMATCH_EMAIL 19035
+#define IDS_FORM_VALIDATION_TYPE_MISMATCH_URL 19036
+#define IDS_FORM_VALIDATION_PATTERN_MISMATCH 19037
+#define IDS_FORM_VALIDATION_STEP_MISMATCH 19038
+#define IDS_FORM_VALIDATION_STEP_MISMATCH_CLOSE_TO_LIMIT 19039
+#define IDS_FORM_VALIDATION_TOO_LONG 19040
+#define IDS_FORM_VALIDATION_TOO_SHORT 19041
+#define IDS_PLUGIN_INITIALIZATION_ERROR 19042
+
+// ---------------------------------------------------------------------------
+// From extensions_strings.h:
+
+#define IDS_EXTENSION_CONTAINS_PRIVATE_KEY 26150
+#define IDS_EXTENSION_LOAD_ABOUT_PAGE_FAILED 26151
+#define IDS_EXTENSION_LOAD_BACKGROUND_SCRIPT_FAILED 26152
+#define IDS_EXTENSION_LOAD_BACKGROUND_PAGE_FAILED 26153
+#define IDS_EXTENSION_LOAD_ICON_FAILED 26154
+#define IDS_EXTENSION_LOAD_LAUNCHER_PAGE_FAILED 26155
+#define IDS_EXTENSION_LOAD_OPTIONS_PAGE_FAILED 26156
+#define IDS_EXTENSION_LOCALES_NO_DEFAULT_LOCALE_SPECIFIED 26157
+#define IDS_EXTENSION_MANIFEST_UNREADABLE 26158
+#define IDS_EXTENSION_MANIFEST_INVALID 26159
+#define IDS_EXTENSION_PACKAGE_DIRECTORY_ERROR 26160
+#define IDS_EXTENSION_PACKAGE_IMAGE_PATH_ERROR 26161
+#define IDS_EXTENSION_PACKAGE_IMAGE_ERROR 26162
+#define IDS_EXTENSION_PACKAGE_UNZIP_ERROR 26163
+#define IDS_LOAD_STATE_PARAMETER_EXTENSION 26164
+#define IDS_EXTENSION_PROMPT_WARNING_HOST_AND_SUBDOMAIN 26165
+#define IDS_EXTENSION_PROMPT_WARNING_HOST_AND_SUBDOMAIN_LIST 26166
+#define IDS_EXTENSION_CANT_INSTALL_POLICY_BLOCKED 26167
+#define IDS_EXTENSION_CANT_MODIFY_POLICY_REQUIRED 26168
+#define IDS_EXTENSION_CANT_UNINSTALL_POLICY_REQUIRED 26169
+#define IDS_EXTENSION_DISABLED_UPDATE_REQUIRED_BY_POLICY 26170
+#define IDS_DEVICE_NAME_WITH_PRODUCT_SERIAL 26171
+#define IDS_DEVICE_NAME_WITH_PRODUCT_UNKNOWN_VENDOR 26172
+#define IDS_DEVICE_NAME_WITH_PRODUCT_UNKNOWN_VENDOR_SERIAL 26173
+#define IDS_DEVICE_NAME_WITH_PRODUCT_VENDOR 26174
+#define IDS_DEVICE_NAME_WITH_PRODUCT_VENDOR_SERIAL 26175
+#define IDS_DEVICE_NAME_WITH_UNKNOWN_PRODUCT_UNKNOWN_VENDOR 26176
+#define IDS_DEVICE_NAME_WITH_UNKNOWN_PRODUCT_UNKNOWN_VENDOR_SERIAL 26177
+#define IDS_DEVICE_NAME_WITH_UNKNOWN_PRODUCT_VENDOR 26178
+#define IDS_DEVICE_NAME_WITH_UNKNOWN_PRODUCT_VENDOR_SERIAL 26179
+#define IDS_DEVICE_PERMISSIONS_PROMPT 26180
+#define IDS_EXTENSION_USB_DEVICE_PRODUCT_NAME_AND_VENDOR 26181
+#define IDS_HID_DEVICE_PERMISSIONS_PROMPT_TITLE 26182
+#define IDS_USB_DEVICE_PERMISSIONS_PROMPT_TITLE 26183
+#define IDS_EXTENSION_TASK_MANAGER_APPVIEW_TAG_PREFIX 26184
+#define IDS_EXTENSION_TASK_MANAGER_EXTENSIONOPTIONS_TAG_PREFIX 26185
+#define IDS_EXTENSION_TASK_MANAGER_EXTENSIONVIEW_TAG_PREFIX 26186
+#define IDS_EXTENSION_TASK_MANAGER_MIMEHANDLERVIEW_TAG_PREFIX 26187
+#define IDS_EXTENSION_TASK_MANAGER_WEBVIEW_TAG_PREFIX 26188
+#define IDS_EXTENSION_WARNINGS_NETWORK_DELAY 26189
+#define IDS_EXTENSION_WARNINGS_NETWORK_CONFLICT 26190
+#define IDS_EXTENSION_WARNINGS_REDIRECT_CONFLICT 26191
+#define IDS_EXTENSION_WARNINGS_REQUEST_HEADER_CONFLICT 26192
+#define IDS_EXTENSION_WARNINGS_RESPONSE_HEADER_CONFLICT 26193
+#define IDS_EXTENSION_WARNINGS_CREDENTIALS_CONFLICT 26194
+#define IDS_EXTENSION_WARNINGS_DOWNLOAD_FILENAME_CONFLICT 26195
+#define IDS_EXTENSION_WARNING_RELOAD_TOO_FREQUENT 26196
+#define IDS_EXTENSION_INSTALL_PROCESS_CRASHED 26197
+#define IDS_EXTENSION_PACKAGE_ERROR_CODE 26198
+#define IDS_EXTENSION_PACKAGE_ERROR_MESSAGE 26199
+#define IDS_EXTENSION_PACKAGE_INSTALL_ERROR 26200
+#define IDS_EXTENSION_UNPACK_FAILED 26201
+#define IDS_UTILITY_PROCESS_EXTENSION_UNPACKER_NAME 26202
+#define IDS_UTILITY_PROCESS_MANIFEST_PARSER_NAME 26203
+
+// ---------------------------------------------------------------------------
+// From platform_locale_settings.h:
+
+#define IDS_STANDARD_FONT_FAMILY 10500
+#define IDS_FIXED_FONT_FAMILY 10501
+#define IDS_FIXED_FONT_FAMILY_ALT_WIN 10502
+#define IDS_SERIF_FONT_FAMILY 10503
+#define IDS_SANS_SERIF_FONT_FAMILY 10504
+#define IDS_CURSIVE_FONT_FAMILY 10505
+#define IDS_FANTASY_FONT_FAMILY 10506
+#define IDS_PICTOGRAPH_FONT_FAMILY 10507
+#define IDS_STANDARD_FONT_FAMILY_CYRILLIC 10508
+#define IDS_FIXED_FONT_FAMILY_ARABIC 10509
+#define IDS_FIXED_FONT_FAMILY_CYRILLIC 10510
+#define IDS_SANS_SERIF_FONT_FAMILY_ARABIC 10511
+#define IDS_SERIF_FONT_FAMILY_CYRILLIC 10512
+#define IDS_SANS_SERIF_FONT_FAMILY_CYRILLIC 10513
+#define IDS_STANDARD_FONT_FAMILY_GREEK 10514
+#define IDS_FIXED_FONT_FAMILY_GREEK 10515
+#define IDS_SERIF_FONT_FAMILY_GREEK 10516
+#define IDS_SANS_SERIF_FONT_FAMILY_GREEK 10517
+#define IDS_STANDARD_FONT_FAMILY_JAPANESE 10518
+#define IDS_FIXED_FONT_FAMILY_JAPANESE 10519
+#define IDS_SERIF_FONT_FAMILY_JAPANESE 10520
+#define IDS_SANS_SERIF_FONT_FAMILY_JAPANESE 10521
+#define IDS_STANDARD_FONT_FAMILY_KOREAN 10522
+#define IDS_FIXED_FONT_FAMILY_KOREAN 10523
+#define IDS_SERIF_FONT_FAMILY_KOREAN 10524
+#define IDS_SANS_SERIF_FONT_FAMILY_KOREAN 10525
+#define IDS_CURSIVE_FONT_FAMILY_KOREAN 10526
+#define IDS_STANDARD_FONT_FAMILY_SIMPLIFIED_HAN 10527
+#define IDS_FIXED_FONT_FAMILY_SIMPLIFIED_HAN 10528
+#define IDS_SERIF_FONT_FAMILY_SIMPLIFIED_HAN 10529
+#define IDS_SANS_SERIF_FONT_FAMILY_SIMPLIFIED_HAN 10530
+#define IDS_STANDARD_FONT_FAMILY_TRADITIONAL_HAN 10531
+#define IDS_FIXED_FONT_FAMILY_TRADITIONAL_HAN 10532
+#define IDS_SERIF_FONT_FAMILY_TRADITIONAL_HAN 10533
+#define IDS_SANS_SERIF_FONT_FAMILY_TRADITIONAL_HAN 10534
+#define IDS_DEFAULT_FONT_SIZE 10535
+#define IDS_DEFAULT_FIXED_FONT_SIZE 10536
+#define IDS_MINIMUM_FONT_SIZE 10537
+#define IDS_MINIMUM_LOGICAL_FONT_SIZE 10538
+
+// ---------------------------------------------------------------------------
+// From ui_strings.h:
+
+#define IDS_TIME_SECS 11000
+#define IDS_TIME_LONG_SECS 11001
+#define IDS_TIME_LONG_SECS_2ND 11002
+#define IDS_TIME_MINS 11003
+#define IDS_TIME_LONG_MINS 11004
+#define IDS_TIME_LONG_MINS_1ST 11005
+#define IDS_TIME_LONG_MINS_2ND 11006
+#define IDS_TIME_HOURS 11007
+#define IDS_TIME_HOURS_1ST 11008
+#define IDS_TIME_HOURS_2ND 11009
+#define IDS_TIME_DAYS 11010
+#define IDS_TIME_DAYS_1ST 11011
+#define IDS_TIME_REMAINING_SECS 11012
+#define IDS_TIME_REMAINING_LONG_SECS 11013
+#define IDS_TIME_REMAINING_MINS 11014
+#define IDS_TIME_REMAINING_LONG_MINS 11015
+#define IDS_TIME_REMAINING_HOURS 11016
+#define IDS_TIME_REMAINING_DAYS 11017
+#define IDS_TIME_ELAPSED_SECS 11018
+#define IDS_TIME_ELAPSED_MINS 11019
+#define IDS_TIME_ELAPSED_HOURS 11020
+#define IDS_TIME_ELAPSED_DAYS 11021
+#define IDS_PAST_TIME_TODAY 11022
+#define IDS_PAST_TIME_YESTERDAY 11023
+#define IDS_APP_MENU_EMPTY_SUBMENU 11024
+#define IDS_APP_UNTITLED_SHORTCUT_FILE_NAME 11025
+#define IDS_APP_SAVEAS_ALL_FILES 11026
+#define IDS_APP_SAVEAS_EXTENSION_FORMAT 11027
+#define IDS_SELECT_UPLOAD_FOLDER_DIALOG_TITLE 11028
+#define IDS_SELECT_FOLDER_DIALOG_TITLE 11031
+#define IDS_SAVE_AS_DIALOG_TITLE 11032
+#define IDS_OPEN_FILE_DIALOG_TITLE 11033
+#define IDS_OPEN_FILES_DIALOG_TITLE 11034
+#define IDS_SAVEAS_ALL_FILES 11035
+#define IDS_SELECT_UPLOAD_FOLDER_DIALOG_UPLOAD_BUTTON 11036
+#define IDS_APP_ACCACTION_PRESS 11037
+#define IDS_APP_ACCNAME_CLOSE 11038
+#define IDS_APP_ACCNAME_MINIMIZE 11039
+#define IDS_APP_ACCNAME_MAXIMIZE 11040
+#define IDS_APP_ACCNAME_RESTORE 11041
+#define IDS_APP_SCROLLBAR_CXMENU_SCROLLHERE 11042
+#define IDS_APP_SCROLLBAR_CXMENU_SCROLLLEFTEDGE 11043
+#define IDS_APP_SCROLLBAR_CXMENU_SCROLLRIGHTEDGE 11044
+#define IDS_APP_SCROLLBAR_CXMENU_SCROLLHOME 11045
+#define IDS_APP_SCROLLBAR_CXMENU_SCROLLEND 11046
+#define IDS_APP_SCROLLBAR_CXMENU_SCROLLPAGEUP 11047
+#define IDS_APP_SCROLLBAR_CXMENU_SCROLLPAGEDOWN 11048
+#define IDS_APP_SCROLLBAR_CXMENU_SCROLLLEFT 11049
+#define IDS_APP_SCROLLBAR_CXMENU_SCROLLRIGHT 11050
+#define IDS_APP_SCROLLBAR_CXMENU_SCROLLUP 11051
+#define IDS_APP_SCROLLBAR_CXMENU_SCROLLDOWN 11052
+#define IDS_APP_UNDO 11053
+#define IDS_APP_CUT 11054
+#define IDS_APP_COPY 11055
+#define IDS_APP_PASTE 11056
+#define IDS_APP_DELETE 11057
+#define IDS_APP_SELECT_ALL 11058
+#define IDS_DELETE_BACKWARD 11059
+#define IDS_DELETE_FORWARD 11060
+#define IDS_DELETE_TO_BEGINNING_OF_LINE 11061
+#define IDS_DELETE_TO_END_OF_LINE 11062
+#define IDS_DELETE_WORD_BACKWARD 11063
+#define IDS_DELETE_WORD_FORWARD 11064
+#define IDS_MOVE_DOWN 11065
+#define IDS_MOVE_LEFT 11066
+#define IDS_MOVE_LEFT_AND_MODIFY_SELECTION 11067
+#define IDS_MOVE_RIGHT 11068
+#define IDS_MOVE_RIGHT_AND_MODIFY_SELECTION 11069
+#define IDS_MOVE_WORD_LEFT 11070
+#define IDS_MOVE_WORD_LEFT_AND_MODIFY_SELECTION 11071
+#define IDS_MOVE_WORD_RIGHT 11072
+#define IDS_MOVE_WORD_RIGHT_AND_MODIFY_SELECTION 11073
+#define IDS_MOVE_TO_BEGINNING_OF_LINE 11074
+#define IDS_MOVE_TO_BEGINNING_OF_LINE_AND_MODIFY_SELECTION 11075
+#define IDS_MOVE_TO_END_OF_LINE 11076
+#define IDS_MOVE_TO_END_OF_LINE_AND_MODIFY_SELECTION 11077
+#define IDS_MOVE_UP 11078
+#define IDS_APP_REDO 11079
+#define IDS_APP_OK 11080
+#define IDS_APP_CANCEL 11081
+#define IDS_APP_CLOSE 11082
+#define IDS_APP_ESC_KEY 11083
+#define IDS_APP_TAB_KEY 11084
+#define IDS_APP_INSERT_KEY 11085
+#define IDS_APP_HOME_KEY 11086
+#define IDS_APP_DELETE_KEY 11087
+#define IDS_APP_END_KEY 11088
+#define IDS_APP_PAGEUP_KEY 11089
+#define IDS_APP_PAGEDOWN_KEY 11090
+#define IDS_APP_LEFT_ARROW_KEY 11091
+#define IDS_APP_RIGHT_ARROW_KEY 11092
+#define IDS_APP_UP_ARROW_KEY 11093
+#define IDS_APP_DOWN_ARROW_KEY 11094
+#define IDS_APP_ENTER_KEY 11095
+#define IDS_APP_SPACE_KEY 11096
+#define IDS_APP_F1_KEY 11097
+#define IDS_APP_F11_KEY 11098
+#define IDS_APP_BACKSPACE_KEY 11099
+#define IDS_APP_COMMA_KEY 11100
+#define IDS_APP_PERIOD_KEY 11101
+#define IDS_APP_MEDIA_NEXT_TRACK_KEY 11102
+#define IDS_APP_MEDIA_PLAY_PAUSE_KEY 11103
+#define IDS_APP_MEDIA_PREV_TRACK_KEY 11104
+#define IDS_APP_MEDIA_STOP_KEY 11105
+#define IDS_APP_CONTROL_MODIFIER 11106
+#define IDS_APP_ALT_MODIFIER 11107
+#define IDS_APP_SHIFT_MODIFIER 11108
+#define IDS_APP_COMMAND_MODIFIER 11109
+#define IDS_APP_SEARCH_MODIFIER 11110
+#define IDS_APP_BYTES 11111
+#define IDS_APP_KIBIBYTES 11112
+#define IDS_APP_MEBIBYTES 11113
+#define IDS_APP_GIBIBYTES 11114
+#define IDS_APP_TEBIBYTES 11115
+#define IDS_APP_PEBIBYTES 11116
+#define IDS_APP_BYTES_PER_SECOND 11117
+#define IDS_APP_KIBIBYTES_PER_SECOND 11118
+#define IDS_APP_MEBIBYTES_PER_SECOND 11119
+#define IDS_APP_GIBIBYTES_PER_SECOND 11120
+#define IDS_APP_TEBIBYTES_PER_SECOND 11121
+#define IDS_APP_PEBIBYTES_PER_SECOND 11122
+#define IDS_MESSAGE_CENTER_ACCESSIBLE_NAME 11123
+#define IDS_MESSAGE_CENTER_NOTIFIER_DISABLE 11124
+#define IDS_MESSAGE_CENTER_FOOTER_TITLE 11125
+#define IDS_MESSAGE_CENTER_SETTINGS_BUTTON_LABEL 11126
+#define IDS_MESSAGE_CENTER_SETTINGS_DIALOG_DESCRIPTION 11128
+#define IDS_MESSAGE_CENTER_SETTINGS_DESCRIPTION_MULTIUSER 11129
+#define IDS_MESSAGE_CENTER_SETTINGS 11130
+#define IDS_MESSAGE_CENTER_CLEAR_ALL 11131
+#define IDS_MESSAGE_CENTER_QUIET_MODE_BUTTON_TOOLTIP 11132
+#define IDS_MESSAGE_CENTER_NO_MESSAGES 11133
+#define IDS_MESSAGE_CENTER_QUIET_MODE 11134
+#define IDS_MESSAGE_CENTER_QUIET_MODE_1HOUR 11135
+#define IDS_MESSAGE_CENTER_QUIET_MODE_1DAY 11136
+#define IDS_MESSAGE_CENTER_CLOSE_NOTIFICATION_BUTTON_ACCESSIBLE_NAME 11137
+#define IDS_MESSAGE_NOTIFICATION_SETTINGS_BUTTON_ACCESSIBLE_NAME 11138
+#define IDS_APP_LIST_HELP 11141
+#define IDS_APP_LIST_OPEN_SETTINGS 11142
+#define IDS_APP_LIST_OPEN_FEEDBACK 11143
+#define IDS_APP_LIST_BACK 11144
+#define IDS_APP_LIST_ALL_APPS 11145
+#define IDS_APP_LIST_FOLDER_NAME_PLACEHOLDER 11146
+#define IDS_APP_LIST_FOLDER_BUTTON_ACCESSIBILE_NAME 11147
+#define IDS_APP_LIST_FOLDER_OPEN_FOLDER_ACCESSIBILE_NAME 11148
+#define IDS_APP_LIST_FOLDER_CLOSE_FOLDER_ACCESSIBILE_NAME 11149
+#define IDS_APP_LIST_SPEECH_HINT_TEXT 11150
+#define IDS_APP_LIST_SPEECH_NETWORK_ERROR_HINT_TEXT 11151
+
+#endif  // CEF_INCLUDE_CEF_PACK_STRINGS_H_
diff --git a/src/include/libcef_/cef_parser.h b/src/include/libcef_/cef_parser.h
new file mode 100644
index 0000000..513bdff
--- /dev/null
+++ b/src/include/libcef_/cef_parser.h
@@ -0,0 +1,172 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_PARSER_H_
+#define CEF_INCLUDE_CEF_PARSER_H_
+#pragma once
+
+#include<vector>
+
+#include"libcef/cef_base.h"
+#include"libcef/cef_values.h"
+
+///
+// Parse the specified |url| into its component parts.
+// Returns false if the URL is empty or invalid.
+///
+/*--cef()--*/
+bool CefParseURL(const CefString& url,
+                 CefURLParts& parts);
+
+///
+// Creates a URL from the specified |parts|, which must contain a non-empty
+// spec or a non-empty host and path (at a minimum), but not both.
+// Returns false if |parts| isn't initialized as described.
+///
+/*--cef()--*/
+bool CefCreateURL(const CefURLParts& parts,
+                  CefString& url);
+
+///
+// This is a convenience function for formatting a URL in a concise and human-
+// friendly way to help users make security-related decisions (or in other
+// circumstances when people need to distinguish sites, origins, or otherwise-
+// simplified URLs from each other). Internationalized domain names (IDN) may be
+// presented in Unicode if |languages| accepts the Unicode representation. The
+// returned value will (a) omit the path for standard schemes, excepting file
+// and filesystem, and (b) omit the port if it is the default for the scheme. Do
+// not use this for URLs which will be parsed or sent to other applications.
+///
+/*--cef(optional_param=languages)--*/
+CefString CefFormatUrlForSecurityDisplay(const CefString& origin_url,
+                                         const CefString& languages);
+
+///
+// Returns the mime type for the specified file extension or an empty string if
+// unknown.
+///
+/*--cef()--*/
+CefString CefGetMimeType(const CefString& extension);
+
+///
+// Get the extensions associated with the given mime type. This should be passed
+// in lower case. There could be multiple extensions for a given mime type, like
+// "html,htm" for "text/html", or "txt,text,html,..." for "text/*". Any existing
+// elements in the provided vector will not be erased.
+///
+/*--cef()--*/
+void CefGetExtensionsForMimeType(const CefString& mime_type,
+                                 std::vector<CefString>& extensions);
+
+///
+// Encodes |data| as a base64 string.
+///
+/*--cef()--*/
+CefString CefBase64Encode(const void* data, size_t data_size);
+
+///
+// Decodes the base64 encoded string |data|. The returned value will be NULL if
+// the decoding fails.
+///
+/*--cef()--*/
+CefRefPtr<CefBinaryValue> CefBase64Decode(const CefString& data);
+
+///
+// Escapes characters in |text| which are unsuitable for use as a query
+// parameter value. Everything except alphanumerics and -_.!~*'() will be
+// converted to "%XX". If |use_plus| is true spaces will change to "+". The
+// result is basically the same as encodeURIComponent in Javacript.
+///
+/*--cef()--*/
+CefString CefURIEncode(const CefString& text, bool use_plus);
+
+///
+// Unescapes |text| and returns the result. Unescaping consists of looking for
+// the exact pattern "%XX" where each X is a hex digit and converting to the
+// character with the numerical value of those digits (e.g. "i%20=%203%3b"
+// unescapes to "i = 3;"). If |convert_to_utf8| is true this function will
+// attempt to interpret the initial decoded result as UTF-8. If the result is
+// convertable into UTF-8 it will be returned as converted. Otherwise the
+// initial decoded result will be returned.  The |unescape_rule| parameter
+// supports further customization the decoding process.
+///
+/*--cef()--*/
+CefString CefURIDecode(const CefString& text,
+                       bool convert_to_utf8,
+                       cef_uri_unescape_rule_t unescape_rule);
+
+///
+// Parses |string| which represents a CSS color value. If |strict| is true
+// strict parsing rules will be applied. Returns true on success or false on
+// error. If parsing succeeds |color| will be set to the color value otherwise
+// |color| will remain unchanged.
+///
+/*--cef()--*/
+bool CefParseCSSColor(const CefString& string,
+                      bool strict,
+                      cef_color_t& color);
+
+///
+// Parses the specified |json_string| and returns a dictionary or list
+// representation. If JSON parsing fails this method returns NULL.
+///
+/*--cef()--*/
+CefRefPtr<CefValue> CefParseJSON(const CefString& json_string,
+                                 cef_json_parser_options_t options);
+
+///
+// Parses the specified |json_string| and returns a dictionary or list
+// representation. If JSON parsing fails this method returns NULL and populates
+// |error_code_out| and |error_msg_out| with an error code and a formatted error
+// message respectively.
+///
+/*--cef()--*/
+CefRefPtr<CefValue> CefParseJSONAndReturnError(
+    const CefString& json_string,
+    cef_json_parser_options_t options,
+    cef_json_parser_error_t& error_code_out,
+    CefString& error_msg_out);
+
+///
+// Generates a JSON string from the specified root |node| which should be a
+// dictionary or list value. Returns an empty string on failure. This method
+// requires exclusive access to |node| including any underlying data.
+///
+/*--cef()--*/
+CefString CefWriteJSON(CefRefPtr<CefValue> node,
+                       cef_json_writer_options_t options);
+
+#endif  // CEF_INCLUDE_CEF_PARSER_H_
diff --git a/src/include/libcef_/cef_path_util.h b/src/include/libcef_/cef_path_util.h
new file mode 100644
index 0000000..287e330
--- /dev/null
+++ b/src/include/libcef_/cef_path_util.h
@@ -0,0 +1,52 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_PATH_UTIL_H_
+#define CEF_INCLUDE_CEF_PATH_UTIL_H_
+#pragma once
+
+#include"libcef/cef_base.h"
+
+typedef cef_path_key_t PathKey;
+
+///
+// Retrieve the path associated with the specified |key|. Returns true on
+// success. Can be called on any thread in the browser process.
+///
+/*--cef()--*/
+bool CefGetPath(PathKey key, CefString& path);
+
+#endif  // CEF_INCLUDE_CEF_PATH_UTIL_H_
diff --git a/src/include/libcef_/cef_print_handler.h b/src/include/libcef_/cef_print_handler.h
new file mode 100644
index 0000000..e983ae8
--- /dev/null
+++ b/src/include/libcef_/cef_print_handler.h
@@ -0,0 +1,138 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_PRINT_HANDLER_H_
+#define CEF_INCLUDE_CEF_PRINT_HANDLER_H_
+#pragma once
+
+#include"libcef/cef_base.h"
+#include"libcef/cef_browser.h"
+#include"libcef/cef_print_settings.h"
+
+///
+// Callback interface for asynchronous continuation of print dialog requests.
+///
+/*--cef(source=library)--*/
+class CefPrintDialogCallback : public virtual CefBase {
+ public:
+  ///
+  // Continue printing with the specified |settings|.
+  ///
+  /*--cef(capi_name=cont)--*/
+  virtual void Continue(CefRefPtr<CefPrintSettings> settings) =0;
+
+  ///
+  // Cancel the printing.
+  ///
+  /*--cef()--*/
+  virtual void Cancel() =0;
+};
+
+///
+// Callback interface for asynchronous continuation of print job requests.
+///
+/*--cef(source=library)--*/
+class CefPrintJobCallback : public virtual CefBase {
+ public:
+  ///
+  // Indicate completion of the print job.
+  ///
+  /*--cef(capi_name=cont)--*/
+  virtual void Continue() =0;
+};
+
+
+///
+// Implement this interface to handle printing on Linux. The methods of this
+// class will be called on the browser process UI thread.
+///
+/*--cef(source=client)--*/
+class CefPrintHandler : public virtual CefBase {
+ public:
+  ///
+  // Called when printing has started for the specified |browser|. This method
+  // will be called before the other OnPrint*() methods and irrespective of how
+  // printing was initiated (e.g. CefBrowserHost::Print(), JavaScript
+  // window.print() or PDF extension print button).
+  ///
+  /*--cef()--*/
+  virtual void OnPrintStart(CefRefPtr<CefBrowser> browser) =0;
+
+  ///
+  // Synchronize |settings| with client state. If |get_defaults| is true then
+  // populate |settings| with the default print settings. Do not keep a
+  // reference to |settings| outside of this callback.
+  ///
+  /*--cef()--*/
+  virtual void OnPrintSettings(CefRefPtr<CefPrintSettings> settings,
+                               bool get_defaults) =0;
+
+  ///
+  // Show the print dialog. Execute |callback| once the dialog is dismissed.
+  // Return true if the dialog will be displayed or false to cancel the
+  // printing immediately.
+  ///
+  /*--cef()--*/
+  virtual bool OnPrintDialog(bool has_selection,
+                             CefRefPtr<CefPrintDialogCallback> callback) =0;
+
+  ///
+  // Send the print job to the printer. Execute |callback| once the job is
+  // completed. Return true if the job will proceed or false to cancel the job
+  // immediately.
+  ///
+  /*--cef()--*/
+  virtual bool OnPrintJob(const CefString& document_name,
+                          const CefString& pdf_file_path,
+                          CefRefPtr<CefPrintJobCallback> callback) =0;
+
+  ///
+  // Reset client state related to printing.
+  ///
+  /*--cef()--*/
+  virtual void OnPrintReset() =0;
+
+  ///
+  // Return the PDF paper size in device units. Used in combination with
+  // CefBrowserHost::PrintToPDF().
+  ///
+  /*--cef()--*/
+  virtual CefSize GetPdfPaperSize(int device_units_per_inch) {
+    return CefSize();
+  }
+};
+
+#endif  // CEF_INCLUDE_CEF_PRINT_HANDLER_H_
diff --git a/src/include/libcef_/cef_print_settings.h b/src/include/libcef_/cef_print_settings.h
new file mode 100644
index 0000000..74524d5
--- /dev/null
+++ b/src/include/libcef_/cef_print_settings.h
@@ -0,0 +1,208 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_PRINT_SETTINGS_H_
+#define CEF_INCLUDE_CEF_PRINT_SETTINGS_H_
+#pragma once
+
+#include<vector>
+
+#include"libcef/cef_base.h"
+
+///
+// Class representing print settings.
+///
+/*--cef(source=library)--*/
+class CefPrintSettings : public virtual CefBase {
+ public:
+  typedef cef_color_model_t ColorModel;
+  typedef cef_duplex_mode_t DuplexMode;
+  typedef std::vector<CefPageRange> PageRangeList;
+
+  ///
+  // Create a new CefPrintSettings object.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefPrintSettings> Create();
+
+  ///
+  // Returns true if this object is valid. Do not call any other methods if this
+  // function returns false.
+  ///
+  /*--cef()--*/
+  virtual bool IsValid() =0;
+
+  ///
+  // Returns true if the values of this object are read-only. Some APIs may
+  // expose read-only objects.
+  ///
+  /*--cef()--*/
+  virtual bool IsReadOnly() =0;
+
+  ///
+  // Returns a writable copy of this object.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefPrintSettings> Copy() =0;
+
+  ///
+  // Set the page orientation.
+  ///
+  /*--cef()--*/
+  virtual void SetOrientation(bool landscape) =0;
+
+  ///
+  // Returns true if the orientation is landscape.
+  ///
+  /*--cef()--*/
+  virtual bool IsLandscape() =0;
+
+  ///
+  // Set the printer printable area in device units.
+  // Some platforms already provide flipped area. Set |landscape_needs_flip|
+  // to false on those platforms to avoid double flipping.
+  ///
+  /*--cef()--*/
+  virtual void SetPrinterPrintableArea(
+      const CefSize& physical_size_device_units,
+      const CefRect& printable_area_device_units,
+      bool landscape_needs_flip) =0;
+
+  ///
+  // Set the device name.
+  ///
+  /*--cef(optional_param=name)--*/
+  virtual void SetDeviceName(const CefString& name) =0;
+
+  ///
+  // Get the device name.
+  ///
+  /*--cef()--*/
+  virtual CefString GetDeviceName() =0;
+
+  ///
+  // Set the DPI (dots per inch).
+  ///
+  /*--cef()--*/
+  virtual void SetDPI(int dpi) =0;
+
+  ///
+  // Get the DPI (dots per inch).
+  ///
+  /*--cef()--*/
+  virtual int GetDPI() =0;
+
+  ///
+  // Set the page ranges.
+  ///
+  /*--cef()--*/
+  virtual void SetPageRanges(const PageRangeList& ranges) =0;
+
+  ///
+  // Returns the number of page ranges that currently exist.
+  ///
+  /*--cef()--*/
+  virtual size_t GetPageRangesCount() =0;
+
+  ///
+  // Retrieve the page ranges.
+  ///
+  /*--cef(count_func=ranges:GetPageRangesCount)--*/
+  virtual void GetPageRanges(PageRangeList& ranges) =0;
+
+  ///
+  // Set whether only the selection will be printed.
+  ///
+  /*--cef()--*/
+  virtual void SetSelectionOnly(bool selection_only) =0;
+
+  ///
+  // Returns true if only the selection will be printed.
+  ///
+  /*--cef()--*/
+  virtual bool IsSelectionOnly() =0;
+
+  ///
+  // Set whether pages will be collated.
+  ///
+  /*--cef()--*/
+  virtual void SetCollate(bool collate) =0;
+
+  ///
+  // Returns true if pages will be collated.
+  ///
+  /*--cef()--*/
+  virtual bool WillCollate() =0;
+
+  ///
+  // Set the color model.
+  ///
+  /*--cef()--*/
+  virtual void SetColorModel(ColorModel model) =0;
+
+  ///
+  // Get the color model.
+  ///
+  /*--cef(default_retval=COLOR_MODEL_UNKNOWN)--*/
+  virtual ColorModel GetColorModel() =0;
+
+  ///
+  // Set the number of copies.
+  ///
+  /*--cef()--*/
+  virtual void SetCopies(int copies) =0;
+
+  ///
+  // Get the number of copies.
+  ///
+  /*--cef()--*/
+  virtual int GetCopies() =0;
+
+  ///
+  // Set the duplex mode.
+  ///
+  /*--cef()--*/
+  virtual void SetDuplexMode(DuplexMode mode) =0;
+
+  ///
+  // Get the duplex mode.
+  ///
+  /*--cef(default_retval=DUPLEX_MODE_UNKNOWN)--*/
+  virtual DuplexMode GetDuplexMode() =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_PRINT_SETTINGS_H_
+
diff --git a/src/include/libcef_/cef_process_message.h b/src/include/libcef_/cef_process_message.h
new file mode 100644
index 0000000..76f1f01
--- /dev/null
+++ b/src/include/libcef_/cef_process_message.h
@@ -0,0 +1,91 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_MESSAGE_H_
+#define CEF_INCLUDE_CEF_MESSAGE_H_
+#pragma once
+
+#include"libcef/cef_base.h"
+#include"libcef/cef_values.h"
+
+typedef cef_process_id_t CefProcessId;
+
+///
+// Class representing a message. Can be used on any process and thread.
+///
+/*--cef(source=library)--*/
+class CefProcessMessage : public virtual CefBase {
+ public:
+  ///
+  // Create a new CefProcessMessage object with the specified name.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefProcessMessage> Create(const CefString& name);
+
+  ///
+  // Returns true if this object is valid. Do not call any other methods if this
+  // function returns false.
+  ///
+  /*--cef()--*/
+  virtual bool IsValid() =0;
+
+  ///
+  // Returns true if the values of this object are read-only. Some APIs may
+  // expose read-only objects.
+  ///
+  /*--cef()--*/
+  virtual bool IsReadOnly() =0;
+
+  ///
+  // Returns a writable copy of this object.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefProcessMessage> Copy() =0;
+
+  ///
+  // Returns the message name.
+  ///
+  /*--cef()--*/
+  virtual CefString GetName() =0;
+
+  ///
+  // Returns the list of arguments.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefListValue> GetArgumentList() =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_MESSAGE_H_
diff --git a/src/include/libcef_/cef_process_util.h b/src/include/libcef_/cef_process_util.h
new file mode 100644
index 0000000..289217e
--- /dev/null
+++ b/src/include/libcef_/cef_process_util.h
@@ -0,0 +1,57 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_PROCESS_UTIL_H_
+#define CEF_INCLUDE_CEF_PROCESS_UTIL_H_
+#pragma once
+
+#include"libcef/cef_base.h"
+#include"libcef/cef_command_line.h"
+
+///
+// Launches the process specified via |command_line|. Returns true upon
+// success. Must be called on the browser process TID_PROCESS_LAUNCHER thread.
+//
+// Unix-specific notes:
+// - All file descriptors open in the parent process will be closed in the
+//   child process except for stdin, stdout, and stderr.
+// - If the first argument on the command line does not contain a slash,
+//   PATH will be searched. (See man execvp.)
+///
+/*--cef()--*/
+bool CefLaunchProcess(CefRefPtr<CefCommandLine> command_line);
+
+#endif  // CEF_INCLUDE_CEF_PROCESS_UTIL_H_
diff --git a/src/include/libcef_/cef_render_handler.h b/src/include/libcef_/cef_render_handler.h
new file mode 100644
index 0000000..d9948c9
--- /dev/null
+++ b/src/include/libcef_/cef_render_handler.h
@@ -0,0 +1,180 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_RENDER_HANDLER_H_
+#define CEF_INCLUDE_CEF_RENDER_HANDLER_H_
+#pragma once
+
+#include"libcef/cef_base.h"
+#include"libcef/cef_browser.h"
+#include"libcef/cef_drag_data.h"
+#include<vector>
+
+///
+// Implement this interface to handle events when window rendering is disabled.
+// The methods of this class will be called on the UI thread.
+///
+/*--cef(source=client)--*/
+class CefRenderHandler : public virtual CefBase {
+ public:
+  typedef cef_cursor_type_t CursorType;
+  typedef cef_drag_operations_mask_t DragOperation;
+  typedef cef_drag_operations_mask_t DragOperationsMask;
+  typedef cef_paint_element_type_t PaintElementType;
+  typedef std::vector<CefRect> RectList;
+
+  ///
+  // Called to retrieve the root window rectangle in screen coordinates. Return
+  // true if the rectangle was provided.
+  ///
+  /*--cef()--*/
+  virtual bool GetRootScreenRect(CefRefPtr<CefBrowser> browser,
+                                 CefRect& rect) { return false; }
+
+  ///
+  // Called to retrieve the view rectangle which is relative to screen
+  // coordinates. Return true if the rectangle was provided.
+  ///
+  /*--cef()--*/
+  virtual bool GetViewRect(CefRefPtr<CefBrowser> browser, CefRect& rect) =0;
+
+  ///
+  // Called to retrieve the translation from view coordinates to actual screen
+  // coordinates. Return true if the screen coordinates were provided.
+  ///
+  /*--cef()--*/
+  virtual bool GetScreenPoint(CefRefPtr<CefBrowser> browser,
+                              int viewX,
+                              int viewY,
+                              int& screenX,
+                              int& screenY) { return false; }
+
+  ///
+  // Called to allow the client to fill in the CefScreenInfo object with
+  // appropriate values. Return true if the |screen_info| structure has been
+  // modified.
+  //
+  // If the screen info rectangle is left empty the rectangle from GetViewRect
+  // will be used. If the rectangle is still empty or invalid popups may not be
+  // drawn correctly.
+  ///
+  /*--cef()--*/
+  virtual bool GetScreenInfo(CefRefPtr<CefBrowser> browser,
+                             CefScreenInfo& screen_info) { return false; }
+
+  ///
+  // Called when the browser wants to show or hide the popup widget. The popup
+  // should be shown if |show| is true and hidden if |show| is false.
+  ///
+  /*--cef()--*/
+  virtual void OnPopupShow(CefRefPtr<CefBrowser> browser,
+                           bool show) {}
+
+  ///
+  // Called when the browser wants to move or resize the popup widget. |rect|
+  // contains the new location and size in view coordinates.
+  ///
+  /*--cef()--*/
+  virtual void OnPopupSize(CefRefPtr<CefBrowser> browser,
+                           const CefRect& rect) {}
+
+  ///
+  // Called when an element should be painted. Pixel values passed to this
+  // method are scaled relative to view coordinates based on the value of
+  // CefScreenInfo.device_scale_factor returned from GetScreenInfo. |type|
+  // indicates whether the element is the view or the popup widget. |buffer|
+  // contains the pixel data for the whole image. |dirtyRects| contains the set
+  // of rectangles in pixel coordinates that need to be repainted. |buffer| will
+  // be |width|*|height|*4 bytes in size and represents a BGRA image with an
+  // upper-left origin.
+  ///
+  /*--cef()--*/
+  virtual void OnPaint(CefRefPtr<CefBrowser> browser,
+                       PaintElementType type,
+                       const RectList& dirtyRects,
+                       const void* buffer,
+                       int width, int height) =0;
+
+  ///
+  // Called when the browser's cursor has changed. If |type| is CT_CUSTOM then
+  // |custom_cursor_info| will be populated with the custom cursor information.
+  ///
+  /*--cef()--*/
+  virtual void OnCursorChange(CefRefPtr<CefBrowser> browser,
+                              CefCursorHandle cursor,
+                              CursorType type,
+                              const CefCursorInfo& custom_cursor_info) {}
+
+  ///
+  // Called when the user starts dragging content in the web view. Contextual
+  // information about the dragged content is supplied by |drag_data|.
+  // (|x|, |y|) is the drag start location in screen coordinates.
+  // OS APIs that run a system message loop may be used within the
+  // StartDragging call.
+  //
+  // Return false to abort the drag operation. Don't call any of
+  // CefBrowserHost::DragSource*Ended* methods after returning false.
+  //
+  // Return true to handle the drag operation. Call
+  // CefBrowserHost::DragSourceEndedAt and DragSourceSystemDragEnded either
+  // synchronously or asynchronously to inform the web view that the drag
+  // operation has ended.
+  ///
+  /*--cef()--*/
+  virtual bool StartDragging(CefRefPtr<CefBrowser> browser,
+                             CefRefPtr<CefDragData> drag_data,
+                             DragOperationsMask allowed_ops,
+                             int x, int y) { return false; }
+
+  ///
+  // Called when the web view wants to update the mouse cursor during a
+  // drag & drop operation. |operation| describes the allowed operation
+  // (none, move, copy, link).
+  ///
+  /*--cef()--*/
+  virtual void UpdateDragCursor(CefRefPtr<CefBrowser> browser,
+                                DragOperation operation) {}
+
+  ///
+  // Called when the scroll offset has changed.
+  ///
+  /*--cef()--*/
+  virtual void OnScrollOffsetChanged(CefRefPtr<CefBrowser> browser,
+                                     double x,
+                                     double y) {}
+};
+
+#endif  // CEF_INCLUDE_CEF_RENDER_HANDLER_H_
diff --git a/src/include/libcef_/cef_render_process_handler.h b/src/include/libcef_/cef_render_process_handler.h
new file mode 100644
index 0000000..58c87e7
--- /dev/null
+++ b/src/include/libcef_/cef_render_process_handler.h
@@ -0,0 +1,168 @@
+// Copyright (c) 2013 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_RENDER_PROCESS_HANDLER_H_
+#define CEF_INCLUDE_CEF_RENDER_PROCESS_HANDLER_H_
+#pragma once
+
+#include"libcef/cef_base.h"
+#include"libcef/cef_browser.h"
+#include"libcef/cef_dom.h"
+#include"libcef/cef_frame.h"
+#include"libcef/cef_load_handler.h"
+#include"libcef/cef_process_message.h"
+#include"libcef/cef_v8.h"
+#include"libcef/cef_values.h"
+
+///
+// Class used to implement render process callbacks. The methods of this class
+// will be called on the render process main thread (TID_RENDERER) unless
+// otherwise indicated.
+///
+/*--cef(source=client)--*/
+class CefRenderProcessHandler : public virtual CefBase {
+ public:
+  typedef cef_navigation_type_t NavigationType;
+
+  ///
+  // Called after the render process main thread has been created. |extra_info|
+  // is a read-only value originating from
+  // CefBrowserProcessHandler::OnRenderProcessThreadCreated(). Do not keep a
+  // reference to |extra_info| outside of this method.
+  ///
+  /*--cef()--*/
+  virtual void OnRenderThreadCreated(CefRefPtr<CefListValue> extra_info) {}
+
+  ///
+  // Called after WebKit has been initialized.
+  ///
+  /*--cef()--*/
+  virtual void OnWebKitInitialized() {}
+
+  ///
+  // Called after a browser has been created. When browsing cross-origin a new
+  // browser will be created before the old browser with the same identifier is
+  // destroyed.
+  ///
+  /*--cef()--*/
+  virtual void OnBrowserCreated(CefRefPtr<CefBrowser> browser) {}
+
+  ///
+  // Called before a browser is destroyed.
+  ///
+  /*--cef()--*/
+  virtual void OnBrowserDestroyed(CefRefPtr<CefBrowser> browser) {}
+
+  ///
+  // Return the handler for browser load status events.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefLoadHandler> GetLoadHandler() {
+    return NULL;
+  }
+
+  ///
+  // Called before browser navigation. Return true to cancel the navigation or
+  // false to allow the navigation to proceed. The |request| object cannot be
+  // modified in this callback.
+  ///
+  /*--cef()--*/
+  virtual bool OnBeforeNavigation(CefRefPtr<CefBrowser> browser,
+                                  CefRefPtr<CefFrame> frame,
+                                  CefRefPtr<CefRequest> request,
+                                  NavigationType navigation_type,
+                                  bool is_redirect) { return false; }
+
+  ///
+  // Called immediately after the V8 context for a frame has been created. To
+  // retrieve the JavaScript 'window' object use the CefV8Context::GetGlobal()
+  // method. V8 handles can only be accessed from the thread on which they are
+  // created. A task runner for posting tasks on the associated thread can be
+  // retrieved via the CefV8Context::GetTaskRunner() method.
+  ///
+  /*--cef()--*/
+  virtual void OnContextCreated(CefRefPtr<CefBrowser> browser,
+                                CefRefPtr<CefFrame> frame,
+                                CefRefPtr<CefV8Context> context) {}
+
+  ///
+  // Called immediately before the V8 context for a frame is released. No
+  // references to the context should be kept after this method is called.
+  ///
+  /*--cef()--*/
+  virtual void OnContextReleased(CefRefPtr<CefBrowser> browser,
+                                 CefRefPtr<CefFrame> frame,
+                                 CefRefPtr<CefV8Context> context) {}
+
+  ///
+  // Called for global uncaught exceptions in a frame. Execution of this
+  // callback is disabled by default. To enable set
+  // CefSettings.uncaught_exception_stack_size > 0.
+  ///
+  /*--cef()--*/
+  virtual void OnUncaughtException(CefRefPtr<CefBrowser> browser,
+                                   CefRefPtr<CefFrame> frame,
+                                   CefRefPtr<CefV8Context> context,
+                                   CefRefPtr<CefV8Exception> exception,
+                                   CefRefPtr<CefV8StackTrace> stackTrace) {}
+
+  ///
+  // Called when a new node in the the browser gets focus. The |node| value may
+  // be empty if no specific node has gained focus. The node object passed to
+  // this method represents a snapshot of the DOM at the time this method is
+  // executed. DOM objects are only valid for the scope of this method. Do not
+  // keep references to or attempt to access any DOM objects outside the scope
+  // of this method.
+  ///
+  /*--cef(optional_param=frame,optional_param=node)--*/
+  virtual void OnFocusedNodeChanged(CefRefPtr<CefBrowser> browser,
+                                    CefRefPtr<CefFrame> frame,
+                                    CefRefPtr<CefDOMNode> node) {}
+
+  ///
+  // Called when a new message is received from a different process. Return true
+  // if the message was handled or false otherwise. Do not keep a reference to
+  // or attempt to access the message outside of this callback.
+  ///
+  /*--cef()--*/
+  virtual bool OnProcessMessageReceived(CefRefPtr<CefBrowser> browser,
+                                        CefProcessId source_process,
+                                        CefRefPtr<CefProcessMessage> message) {
+    return false;
+  }
+};
+
+#endif  // CEF_INCLUDE_CEF_RENDER_PROCESS_HANDLER_H_
diff --git a/src/include/libcef_/cef_request.h b/src/include/libcef_/cef_request.h
new file mode 100644
index 0000000..a705355
--- /dev/null
+++ b/src/include/libcef_/cef_request.h
@@ -0,0 +1,337 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_REQUEST_H_
+#define CEF_INCLUDE_CEF_REQUEST_H_
+#pragma once
+
+#include"libcef/cef_base.h"
+#include<map>
+#include<vector>
+
+class CefPostData;
+class CefPostDataElement;
+
+///
+// Class used to represent a web request. The methods of this class may be
+// called on any thread.
+///
+/*--cef(source=library,no_debugct_check)--*/
+class CefRequest : public virtual CefBase {
+ public:
+  typedef std::multimap<CefString, CefString> HeaderMap;
+  typedef cef_referrer_policy_t ReferrerPolicy;
+  typedef cef_resource_type_t ResourceType;
+  typedef cef_transition_type_t TransitionType;
+
+  ///
+  // Create a new CefRequest object.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefRequest> Create();
+
+  ///
+  // Returns true if this object is read-only.
+  ///
+  /*--cef()--*/
+  virtual bool IsReadOnly() =0;
+
+  ///
+  // Get the fully qualified URL.
+  ///
+  /*--cef()--*/
+  virtual CefString GetURL() =0;
+
+  ///
+  // Set the fully qualified URL.
+  ///
+  /*--cef()--*/
+  virtual void SetURL(const CefString& url) =0;
+
+  ///
+  // Get the request method type. The value will default to POST if post data
+  // is provided and GET otherwise.
+  ///
+  /*--cef()--*/
+  virtual CefString GetMethod() =0;
+
+  ///
+  // Set the request method type.
+  ///
+  /*--cef()--*/
+  virtual void SetMethod(const CefString& method) =0;
+
+  ///
+  // Set the referrer URL and policy. If non-empty the referrer URL must be
+  // fully qualified with an HTTP or HTTPS scheme component. Any username,
+  // password or ref component will be removed.
+  ///
+  /*--cef()--*/
+  virtual void SetReferrer(const CefString& referrer_url,
+                           ReferrerPolicy policy) =0;
+
+  ///
+  // Get the referrer URL.
+  ///
+  /*--cef()--*/
+  virtual CefString GetReferrerURL() =0;
+
+  ///
+  // Get the referrer policy.
+  ///
+  /*--cef(default_retval=REFERRER_POLICY_DEFAULT)--*/
+  virtual ReferrerPolicy GetReferrerPolicy() =0;
+
+  ///
+  // Get the post data.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefPostData> GetPostData() =0;
+
+  ///
+  // Set the post data.
+  ///
+  /*--cef()--*/
+  virtual void SetPostData(CefRefPtr<CefPostData> postData) =0;
+
+  ///
+  // Get the header values. Will not include the Referer value if any.
+  ///
+  /*--cef()--*/
+  virtual void GetHeaderMap(HeaderMap& headerMap) =0;
+
+  ///
+  // Set the header values. If a Referer value exists in the header map it will
+  // be removed and ignored.
+  ///
+  /*--cef()--*/
+  virtual void SetHeaderMap(const HeaderMap& headerMap) =0;
+
+  ///
+  // Set all values at one time.
+  ///
+  /*--cef(optional_param=postData)--*/
+  virtual void Set(const CefString& url,
+                   const CefString& method,
+                   CefRefPtr<CefPostData> postData,
+                   const HeaderMap& headerMap) =0;
+
+  ///
+  // Get the flags used in combination with CefURLRequest. See
+  // cef_urlrequest_flags_t for supported values.
+  ///
+  /*--cef(default_retval=UR_FLAG_NONE)--*/
+  virtual int GetFlags() =0;
+
+  ///
+  // Set the flags used in combination with CefURLRequest.  See
+  // cef_urlrequest_flags_t for supported values.
+  ///
+  /*--cef()--*/
+  virtual void SetFlags(int flags) =0;
+
+  ///
+  // Set the URL to the first party for cookies used in combination with
+  // CefURLRequest.
+  ///
+  /*--cef()--*/
+  virtual CefString GetFirstPartyForCookies() =0;
+
+  ///
+  // Get the URL to the first party for cookies used in combination with
+  // CefURLRequest.
+  ///
+  /*--cef()--*/
+  virtual void SetFirstPartyForCookies(const CefString& url) =0;
+
+  ///
+  // Get the resource type for this request. Only available in the browser
+  // process.
+  ///
+  /*--cef(default_retval=RT_SUB_RESOURCE)--*/
+  virtual ResourceType GetResourceType() =0;
+
+  ///
+  // Get the transition type for this request. Only available in the browser
+  // process and only applies to requests that represent a main frame or
+  // sub-frame navigation.
+  ///
+  /*--cef(default_retval=TT_EXPLICIT)--*/
+  virtual TransitionType GetTransitionType() =0;
+
+  ///
+  // Returns the globally unique identifier for this request or 0 if not
+  // specified. Can be used by CefRequestHandler implementations in the browser
+  // process to track a single request across multiple callbacks.
+  ///
+  /*--cef()--*/
+  virtual uint64 GetIdentifier() =0;
+};
+
+
+///
+// Class used to represent post data for a web request. The methods of this
+// class may be called on any thread.
+///
+/*--cef(source=library,no_debugct_check)--*/
+class CefPostData : public virtual CefBase {
+ public:
+  typedef std::vector<CefRefPtr<CefPostDataElement> > ElementVector;
+
+  ///
+  // Create a new CefPostData object.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefPostData> Create();
+
+  ///
+  // Returns true if this object is read-only.
+  ///
+  /*--cef()--*/
+  virtual bool IsReadOnly() =0;
+
+  ///
+  // Returns true if the underlying POST data includes elements that are not
+  // represented by this CefPostData object (for example, multi-part file upload
+  // data). Modifying CefPostData objects with excluded elements may result in
+  // the request failing.
+  ///
+  /*--cef()--*/
+  virtual bool HasExcludedElements() = 0;
+
+  ///
+  // Returns the number of existing post data elements.
+  ///
+  /*--cef()--*/
+  virtual size_t GetElementCount() =0;
+
+  ///
+  // Retrieve the post data elements.
+  ///
+  /*--cef(count_func=elements:GetElementCount)--*/
+  virtual void GetElements(ElementVector& elements) =0;
+
+  ///
+  // Remove the specified post data element.  Returns true if the removal
+  // succeeds.
+  ///
+  /*--cef()--*/
+  virtual bool RemoveElement(CefRefPtr<CefPostDataElement> element) =0;
+
+  ///
+  // Add the specified post data element.  Returns true if the add succeeds.
+  ///
+  /*--cef()--*/
+  virtual bool AddElement(CefRefPtr<CefPostDataElement> element) =0;
+
+  ///
+  // Remove all existing post data elements.
+  ///
+  /*--cef()--*/
+  virtual void RemoveElements() =0;
+};
+
+
+///
+// Class used to represent a single element in the request post data. The
+// methods of this class may be called on any thread.
+///
+/*--cef(source=library,no_debugct_check)--*/
+class CefPostDataElement : public virtual CefBase {
+ public:
+  ///
+  // Post data elements may represent either bytes or files.
+  ///
+  typedef cef_postdataelement_type_t Type;
+
+  ///
+  // Create a new CefPostDataElement object.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefPostDataElement> Create();
+
+  ///
+  // Returns true if this object is read-only.
+  ///
+  /*--cef()--*/
+  virtual bool IsReadOnly() =0;
+
+  ///
+  // Remove all contents from the post data element.
+  ///
+  /*--cef()--*/
+  virtual void SetToEmpty() =0;
+
+  ///
+  // The post data element will represent a file.
+  ///
+  /*--cef()--*/
+  virtual void SetToFile(const CefString& fileName) =0;
+
+  ///
+  // The post data element will represent bytes.  The bytes passed
+  // in will be copied.
+  ///
+  /*--cef()--*/
+  virtual void SetToBytes(size_t size, const void* bytes) =0;
+
+  ///
+  // Return the type of this post data element.
+  ///
+  /*--cef(default_retval=PDE_TYPE_EMPTY)--*/
+  virtual Type GetType() =0;
+
+  ///
+  // Return the file name.
+  ///
+  /*--cef()--*/
+  virtual CefString GetFile() =0;
+
+  ///
+  // Return the number of bytes.
+  ///
+  /*--cef()--*/
+  virtual size_t GetBytesCount() =0;
+
+  ///
+  // Read up to |size| bytes into |bytes| and return the number of bytes
+  // actually read.
+  ///
+  /*--cef()--*/
+  virtual size_t GetBytes(size_t size, void* bytes) =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_REQUEST_H_
diff --git a/src/include/libcef_/cef_request_context.h b/src/include/libcef_/cef_request_context.h
new file mode 100644
index 0000000..58c3af4
--- /dev/null
+++ b/src/include/libcef_/cef_request_context.h
@@ -0,0 +1,286 @@
+// Copyright (c) 2013 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_REQUEST_CONTEXT_H_
+#define CEF_INCLUDE_CEF_REQUEST_CONTEXT_H_
+#pragma once
+
+#include<vector>
+
+#include"libcef/cef_callback.h"
+#include"libcef/cef_cookie.h"
+#include"libcef/cef_request_context_handler.h"
+#include"libcef/cef_values.h"
+
+class CefSchemeHandlerFactory;
+
+
+///
+// Callback interface for CefRequestContext::ResolveHost.
+///
+/*--cef(source=client)--*/
+class CefResolveCallback : public virtual CefBase {
+ public:
+  ///
+  // Called after the ResolveHost request has completed. |result| will be the
+  // result code. |resolved_ips| will be the list of resolved IP addresses or
+  // empty if the resolution failed.
+  ///
+  /*--cef(optional_param=resolved_ips)--*/
+  virtual void OnResolveCompleted(
+      cef_errorcode_t result,
+      const std::vector<CefString>& resolved_ips) =0;
+};
+
+
+///
+// A request context provides request handling for a set of related browser
+// or URL request objects. A request context can be specified when creating a
+// new browser via the CefBrowserHost static factory methods or when creating a
+// new URL request via the CefURLRequest static factory methods. Browser objects
+// with different request contexts will never be hosted in the same render
+// process. Browser objects with the same request context may or may not be
+// hosted in the same render process depending on the process model. Browser
+// objects created indirectly via the JavaScript window.open function or
+// targeted links will share the same render process and the same request
+// context as the source browser. When running in single-process mode there is
+// only a single render process (the main process) and so all browsers created
+// in single-process mode will share the same request context. This will be the
+// first request context passed into a CefBrowserHost static factory method and
+// all other request context objects will be ignored.
+///
+/*--cef(source=library,no_debugct_check)--*/
+class CefRequestContext : public virtual CefBase {
+ public:
+  ///
+  // Returns the global context object.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefRequestContext> GetGlobalContext();
+
+  ///
+  // Creates a new context object with the specified |settings| and optional
+  // |handler|.
+  ///
+  /*--cef(optional_param=handler)--*/
+  static CefRefPtr<CefRequestContext> CreateContext(
+      const CefRequestContextSettings& settings,
+      CefRefPtr<CefRequestContextHandler> handler);
+
+  ///
+  // Creates a new context object that shares storage with |other| and uses an
+  // optional |handler|.
+  ///
+  /*--cef(capi_name=create_context_shared,optional_param=handler)--*/
+  static CefRefPtr<CefRequestContext> CreateContext(
+      CefRefPtr<CefRequestContext> other,
+      CefRefPtr<CefRequestContextHandler> handler);
+
+  ///
+  // Returns true if this object is pointing to the same context as |that|
+  // object.
+  ///
+  /*--cef()--*/
+  virtual bool IsSame(CefRefPtr<CefRequestContext> other) =0;
+
+  ///
+  // Returns true if this object is sharing the same storage as |that| object.
+  ///
+  /*--cef()--*/
+  virtual bool IsSharingWith(CefRefPtr<CefRequestContext> other) =0;
+
+  ///
+  // Returns true if this object is the global context. The global context is
+  // used by default when creating a browser or URL request with a NULL context
+  // argument.
+  ///
+  /*--cef()--*/
+  virtual bool IsGlobal() =0;
+
+  ///
+  // Returns the handler for this context if any.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefRequestContextHandler> GetHandler() =0;
+
+  ///
+  // Returns the cache path for this object. If empty an "incognito mode"
+  // in-memory cache is being used.
+  ///
+  /*--cef()--*/
+  virtual CefString GetCachePath() =0;
+
+  ///
+  // Returns the default cookie manager for this object. This will be the global
+  // cookie manager if this object is the global request context. Otherwise,
+  // this will be the default cookie manager used when this request context does
+  // not receive a value via CefRequestContextHandler::GetCookieManager(). If
+  // |callback| is non-NULL it will be executed asnychronously on the IO thread
+  // after the manager's storage has been initialized.
+  ///
+  /*--cef(optional_param=callback)--*/
+  virtual CefRefPtr<CefCookieManager> GetDefaultCookieManager(
+      CefRefPtr<CefCompletionCallback> callback) =0;
+
+  ///
+  // Register a scheme handler factory for the specified |scheme_name| and
+  // optional |domain_name|. An empty |domain_name| value for a standard scheme
+  // will cause the factory to match all domain names. The |domain_name| value
+  // will be ignored for non-standard schemes. If |scheme_name| is a built-in
+  // scheme and no handler is returned by |factory| then the built-in scheme
+  // handler factory will be called. If |scheme_name| is a custom scheme then
+  // you must also implement the CefApp::OnRegisterCustomSchemes() method in all
+  // processes. This function may be called multiple times to change or remove
+  // the factory that matches the specified |scheme_name| and optional
+  // |domain_name|. Returns false if an error occurs. This function may be
+  // called on any thread in the browser process.
+  ///
+  /*--cef(optional_param=domain_name,optional_param=factory)--*/
+  virtual bool RegisterSchemeHandlerFactory(
+      const CefString& scheme_name,
+      const CefString& domain_name,
+      CefRefPtr<CefSchemeHandlerFactory> factory) =0;
+
+  ///
+  // Clear all registered scheme handler factories. Returns false on error. This
+  // function may be called on any thread in the browser process.
+  ///
+  /*--cef()--*/
+  virtual bool ClearSchemeHandlerFactories() =0;
+
+  ///
+  // Tells all renderer processes associated with this context to throw away
+  // their plugin list cache. If |reload_pages| is true they will also reload
+  // all pages with plugins. CefRequestContextHandler::OnBeforePluginLoad may
+  // be called to rebuild the plugin list cache.
+  ///
+  /*--cef()--*/
+  virtual void PurgePluginListCache(bool reload_pages) =0;
+
+  ///
+  // Returns true if a preference with the specified |name| exists. This method
+  // must be called on the browser process UI thread.
+  ///
+  /*--cef()--*/
+  virtual bool HasPreference(const CefString& name) =0;
+
+  ///
+  // Returns the value for the preference with the specified |name|. Returns
+  // NULL if the preference does not exist. The returned object contains a copy
+  // of the underlying preference value and modifications to the returned object
+  // will not modify the underlying preference value. This method must be called
+  // on the browser process UI thread.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefValue> GetPreference(const CefString& name) =0;
+
+  ///
+  // Returns all preferences as a dictionary. If |include_defaults| is true then
+  // preferences currently at their default value will be included. The returned
+  // object contains a copy of the underlying preference values and
+  // modifications to the returned object will not modify the underlying
+  // preference values. This method must be called on the browser process UI
+  // thread.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefDictionaryValue> GetAllPreferences(
+      bool include_defaults) =0;
+
+  ///
+  // Returns true if the preference with the specified |name| can be modified
+  // using SetPreference. As one example preferences set via the command-line
+  // usually cannot be modified. This method must be called on the browser
+  // process UI thread.
+  ///
+  /*--cef()--*/
+  virtual bool CanSetPreference(const CefString& name) =0;
+
+  ///
+  // Set the |value| associated with preference |name|. Returns true if the
+  // value is set successfully and false otherwise. If |value| is NULL the
+  // preference will be restored to its default value. If setting the preference
+  // fails then |error| will be populated with a detailed description of the
+  // problem. This method must be called on the browser process UI thread.
+  ///
+  /*--cef(optional_param=value)--*/
+  virtual bool SetPreference(const CefString& name,
+                             CefRefPtr<CefValue> value,
+                             CefString& error) =0;
+
+  ///
+  // Clears all certificate exceptions that were added as part of handling
+  // CefRequestHandler::OnCertificateError(). If you call this it is
+  // recommended that you also call CloseAllConnections() or you risk not
+  // being prompted again for server certificates if you reconnect quickly.
+  // If |callback| is non-NULL it will be executed on the UI thread after
+  // completion.
+  ///
+  /*--cef(optional_param=callback)--*/
+  virtual void ClearCertificateExceptions(
+      CefRefPtr<CefCompletionCallback> callback) =0;
+
+  ///
+  // Clears all active and idle connections that Chromium currently has.
+  // This is only recommended if you have released all other CEF objects but
+  // don't yet want to call CefShutdown(). If |callback| is non-NULL it will be
+  // executed on the UI thread after completion.
+  ///
+  /*--cef(optional_param=callback)--*/
+  virtual void CloseAllConnections(
+      CefRefPtr<CefCompletionCallback> callback) =0;
+
+  ///
+  // Attempts to resolve |origin| to a list of associated IP addresses.
+  // |callback| will be executed on the UI thread after completion.
+  ///
+  /*--cef()--*/
+  virtual void ResolveHost(
+      const CefString& origin,
+      CefRefPtr<CefResolveCallback> callback) =0;
+
+  ///
+  // Attempts to resolve |origin| to a list of associated IP addresses using
+  // cached data. |resolved_ips| will be populated with the list of resolved IP
+  // addresses or empty if no cached data is available. Returns ERR_NONE on
+  // success. This method must be called on the browser process IO thread.
+  ///
+  /*--cef(default_retval=ERR_FAILED)--*/
+  virtual cef_errorcode_t ResolveHostCached(
+      const CefString& origin,
+      std::vector<CefString>& resolved_ips) =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_REQUEST_CONTEXT_H_
diff --git a/src/include/libcef_/cef_request_context_handler.h b/src/include/libcef_/cef_request_context_handler.h
new file mode 100644
index 0000000..07c9cb0
--- /dev/null
+++ b/src/include/libcef_/cef_request_context_handler.h
@@ -0,0 +1,90 @@
+// Copyright (c) 2013 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_REQUEST_CONTEXT_HANDLER_H_
+#define CEF_INCLUDE_CEF_REQUEST_CONTEXT_HANDLER_H_
+#pragma once
+
+#include"libcef/cef_base.h"
+#include"libcef/cef_cookie.h"
+#include"libcef/cef_web_plugin.h"
+
+///
+// Implement this interface to provide handler implementations. The handler
+// instance will not be released until all objects related to the context have
+// been destroyed.
+///
+/*--cef(source=client,no_debugct_check)--*/
+class CefRequestContextHandler : public virtual CefBase {
+ public:
+  typedef cef_plugin_policy_t PluginPolicy;
+
+  ///
+  // Called on the browser process IO thread to retrieve the cookie manager. If
+  // this method returns NULL the default cookie manager retrievable via
+  // CefRequestContext::GetDefaultCookieManager() will be used.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefCookieManager> GetCookieManager() { return NULL; }
+
+  ///
+  // Called on multiple browser process threads before a plugin instance is
+  // loaded. |mime_type| is the mime type of the plugin that will be loaded.
+  // |plugin_url| is the content URL that the plugin will load and may be empty.
+  // |top_origin_url| is the URL for the top-level frame that contains the
+  // plugin when loading a specific plugin instance or empty when building the
+  // initial list of enabled plugins for 'navigator.plugins' JavaScript state.
+  // |plugin_info| includes additional information about the plugin that will be
+  // loaded. |plugin_policy| is the recommended policy. Modify |plugin_policy|
+  // and return true to change the policy. Return false to use the recommended
+  // policy. The default plugin policy can be set at runtime using the
+  // `--plugin-policy=[allow|detect|block]` command-line flag. Decisions to mark
+  // a plugin as disabled by setting |plugin_policy| to PLUGIN_POLICY_DISABLED
+  // may be cached when |top_origin_url| is empty. To purge the plugin list
+  // cache and potentially trigger new calls to this method call
+  // CefRequestContext::PurgePluginListCache.
+  ///
+  /*--cef(optional_param=plugin_url,optional_param=top_origin_url)--*/
+  virtual bool OnBeforePluginLoad(const CefString& mime_type,
+                                  const CefString& plugin_url,
+                                  const CefString& top_origin_url,
+                                  CefRefPtr<CefWebPluginInfo> plugin_info,
+                                  PluginPolicy* plugin_policy) {
+    return false;
+  }
+};
+
+#endif  // CEF_INCLUDE_CEF_REQUEST_CONTEXT_HANDLER_H_
diff --git a/src/include/libcef_/cef_request_handler.h b/src/include/libcef_/cef_request_handler.h
new file mode 100644
index 0000000..7d84ec5
--- /dev/null
+++ b/src/include/libcef_/cef_request_handler.h
@@ -0,0 +1,308 @@
+// Copyright (c) 2011 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_REQUEST_HANDLER_H_
+#define CEF_INCLUDE_CEF_REQUEST_HANDLER_H_
+#pragma once
+
+#include"libcef/cef_auth_callback.h"
+#include"libcef/cef_base.h"
+#include"libcef/cef_browser.h"
+#include"libcef/cef_frame.h"
+#include"libcef/cef_resource_handler.h"
+#include"libcef/cef_response.h"
+#include"libcef/cef_response_filter.h"
+#include"libcef/cef_request.h"
+#include"libcef/cef_ssl_info.h"
+
+
+///
+// Callback interface used for asynchronous continuation of url requests.
+///
+/*--cef(source=library)--*/
+class CefRequestCallback : public virtual CefBase {
+ public:
+  ///
+  // Continue the url request. If |allow| is true the request will be continued.
+  // Otherwise, the request will be canceled.
+  ///
+  /*--cef(capi_name=cont)--*/
+  virtual void Continue(bool allow) =0;
+
+  ///
+  // Cancel the url request.
+  ///
+  /*--cef()--*/
+  virtual void Cancel() =0;
+};
+
+
+///
+// Implement this interface to handle events related to browser requests. The
+// methods of this class will be called on the thread indicated.
+///
+/*--cef(source=client)--*/
+class CefRequestHandler : public virtual CefBase {
+ public:
+  typedef cef_return_value_t ReturnValue;
+  typedef cef_termination_status_t TerminationStatus;
+  typedef cef_urlrequest_status_t URLRequestStatus;
+  typedef cef_window_open_disposition_t WindowOpenDisposition;
+
+  ///
+  // Called on the UI thread before browser navigation. Return true to cancel
+  // the navigation or false to allow the navigation to proceed. The |request|
+  // object cannot be modified in this callback.
+  // CefLoadHandler::OnLoadingStateChange will be called twice in all cases.
+  // If the navigation is allowed CefLoadHandler::OnLoadStart and
+  // CefLoadHandler::OnLoadEnd will be called. If the navigation is canceled
+  // CefLoadHandler::OnLoadError will be called with an |errorCode| value of
+  // ERR_ABORTED.
+  ///
+  /*--cef()--*/
+  virtual bool OnBeforeBrowse(CefRefPtr<CefBrowser> browser,
+                              CefRefPtr<CefFrame> frame,
+                              CefRefPtr<CefRequest> request,
+                              bool is_redirect) {
+    return false;
+  }
+
+  ///
+  // Called on the UI thread before OnBeforeBrowse in certain limited cases
+  // where navigating a new or different browser might be desirable. This
+  // includes user-initiated navigation that might open in a special way (e.g.
+  // links clicked via middle-click or ctrl + left-click) and certain types of
+  // cross-origin navigation initiated from the renderer process (e.g.
+  // navigating the top-level frame to/from a file URL). The |browser| and
+  // |frame| values represent the source of the navigation. The
+  // |target_disposition| value indicates where the user intended to navigate
+  // the browser based on standard Chromium behaviors (e.g. current tab,
+  // new tab, etc). The |user_gesture| value will be true if the browser
+  // navigated via explicit user gesture (e.g. clicking a link) or false if it
+  // navigated automatically (e.g. via the DomContentLoaded event). Return true
+  // to cancel the navigation or false to allow the navigation to proceed in the
+  // source browser's top-level frame.
+  ///
+  /*--cef()--*/
+  virtual bool OnOpenURLFromTab(CefRefPtr<CefBrowser> browser,
+                                CefRefPtr<CefFrame> frame,
+                                const CefString& target_url,
+                                WindowOpenDisposition target_disposition,
+                                bool user_gesture) {
+    return false;
+  }
+
+  ///
+  // Called on the IO thread before a resource request is loaded. The |request|
+  // object may be modified. Return RV_CONTINUE to continue the request
+  // immediately. Return RV_CONTINUE_ASYNC and call CefRequestCallback::
+  // Continue() at a later time to continue or cancel the request
+  // asynchronously. Return RV_CANCEL to cancel the request immediately.
+  // 
+  ///
+  /*--cef(default_retval=RV_CONTINUE)--*/
+  virtual ReturnValue OnBeforeResourceLoad(
+      CefRefPtr<CefBrowser> browser,
+      CefRefPtr<CefFrame> frame,
+      CefRefPtr<CefRequest> request,
+      CefRefPtr<CefRequestCallback> callback) {
+    return RV_CONTINUE;
+  }
+
+  ///
+  // Called on the IO thread before a resource is loaded. To allow the resource
+  // to load normally return NULL. To specify a handler for the resource return
+  // a CefResourceHandler object. The |request| object should not be modified in
+  // this callback.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefResourceHandler> GetResourceHandler(
+      CefRefPtr<CefBrowser> browser,
+      CefRefPtr<CefFrame> frame,
+      CefRefPtr<CefRequest> request) {
+    return NULL;
+  }
+
+  ///
+  // Called on the IO thread when a resource load is redirected. The |request|
+  // parameter will contain the old URL and other request-related information.
+  // The |new_url| parameter will contain the new URL and can be changed if
+  // desired. The |request| object cannot be modified in this callback.
+  ///
+  /*--cef()--*/
+  virtual void OnResourceRedirect(CefRefPtr<CefBrowser> browser,
+                                  CefRefPtr<CefFrame> frame,
+                                  CefRefPtr<CefRequest> request,
+                                  CefString& new_url) {}
+
+  ///
+  // Called on the IO thread when a resource response is received. To allow the
+  // resource to load normally return false. To redirect or retry the resource
+  // modify |request| (url, headers or post body) and return true. The
+  // |response| object cannot be modified in this callback.
+  ///
+  /*--cef()--*/
+  virtual bool OnResourceResponse(CefRefPtr<CefBrowser> browser,
+                                  CefRefPtr<CefFrame> frame,
+                                  CefRefPtr<CefRequest> request,
+                                  CefRefPtr<CefResponse> response) {
+    return false;
+  }
+
+  ///
+  // Called on the IO thread to optionally filter resource response content.
+  // |request| and |response| represent the request and response respectively
+  // and cannot be modified in this callback.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefResponseFilter> GetResourceResponseFilter(
+      CefRefPtr<CefBrowser> browser,
+      CefRefPtr<CefFrame> frame,
+      CefRefPtr<CefRequest> request,
+      CefRefPtr<CefResponse> response) {
+    return NULL;
+  }
+
+  ///
+  // Called on the IO thread when a resource load has completed. |request| and
+  // |response| represent the request and response respectively and cannot be
+  // modified in this callback. |status| indicates the load completion status.
+  // |received_content_length| is the number of response bytes actually read.
+  ///
+  /*--cef()--*/
+  virtual void OnResourceLoadComplete(CefRefPtr<CefBrowser> browser,
+                                      CefRefPtr<CefFrame> frame,
+                                      CefRefPtr<CefRequest> request,
+                                      CefRefPtr<CefResponse> response,
+                                      URLRequestStatus status,
+                                      int64 received_content_length) {}
+
+  ///
+  // Called on the IO thread when the browser needs credentials from the user.
+  // |isProxy| indicates whether the host is a proxy server. |host| contains the
+  // hostname and |port| contains the port number. |realm| is the realm of the
+  // challenge and may be empty. |scheme| is the authentication scheme used,
+  // such as "basic" or "digest", and will be empty if the source of the request
+  // is an FTP server. Return true to continue the request and call
+  // CefAuthCallback::Continue() either in this method or at a later time when
+  // the authentication information is available. Return false to cancel the
+  // request immediately.
+  ///
+  /*--cef(optional_param=realm,optional_param=scheme)--*/
+  virtual bool GetAuthCredentials(CefRefPtr<CefBrowser> browser,
+                                  CefRefPtr<CefFrame> frame,
+                                  bool isProxy,
+                                  const CefString& host,
+                                  int port,
+                                  const CefString& realm,
+                                  const CefString& scheme,
+                                  CefRefPtr<CefAuthCallback> callback) {
+    return false;
+  }
+
+  ///
+  // Called on the IO thread when JavaScript requests a specific storage quota
+  // size via the webkitStorageInfo.requestQuota function. |origin_url| is the
+  // origin of the page making the request. |new_size| is the requested quota
+  // size in bytes. Return true to continue the request and call
+  // CefRequestCallback::Continue() either in this method or at a later time to
+  // grant or deny the request. Return false to cancel the request immediately.
+  ///
+  /*--cef()--*/
+  virtual bool OnQuotaRequest(CefRefPtr<CefBrowser> browser,
+                              const CefString& origin_url,
+                              int64 new_size,
+                              CefRefPtr<CefRequestCallback> callback) {
+    return false;
+  }
+
+  ///
+  // Called on the UI thread to handle requests for URLs with an unknown
+  // protocol component. Set |allow_os_execution| to true to attempt execution
+  // via the registered OS protocol handler, if any.
+  // SECURITY WARNING: YOU SHOULD USE THIS METHOD TO ENFORCE RESTRICTIONS BASED
+  // ON SCHEME, HOST OR OTHER URL ANALYSIS BEFORE ALLOWING OS EXECUTION.
+  ///
+  /*--cef()--*/
+  virtual void OnProtocolExecution(CefRefPtr<CefBrowser> browser,
+                                   const CefString& url,
+                                   bool& allow_os_execution) {}
+
+  ///
+  // Called on the UI thread to handle requests for URLs with an invalid
+  // SSL certificate. Return true and call CefRequestCallback::Continue() either
+  // in this method or at a later time to continue or cancel the request. Return
+  // false to cancel the request immediately. If
+  // CefSettings.ignore_certificate_errors is set all invalid certificates will
+  // be accepted without calling this method.
+  ///
+  /*--cef()--*/
+  virtual bool OnCertificateError(
+      CefRefPtr<CefBrowser> browser,
+      cef_errorcode_t cert_error,
+      const CefString& request_url,
+      CefRefPtr<CefSSLInfo> ssl_info,
+      CefRefPtr<CefRequestCallback> callback) {
+    return false;
+  }
+
+  ///
+  // Called on the browser process UI thread when a plugin has crashed.
+  // |plugin_path| is the path of the plugin that crashed.
+  ///
+  /*--cef()--*/
+  virtual void OnPluginCrashed(CefRefPtr<CefBrowser> browser,
+                               const CefString& plugin_path) {}
+
+  ///
+  // Called on the browser process UI thread when the render view associated
+  // with |browser| is ready to receive/handle IPC messages in the render
+  // process.
+  ///
+  /*--cef()--*/
+  virtual void OnRenderViewReady(CefRefPtr<CefBrowser> browser) {}
+
+  ///
+  // Called on the browser process UI thread when the render process
+  // terminates unexpectedly. |status| indicates how the process
+  // terminated.
+  ///
+  /*--cef()--*/
+  virtual void OnRenderProcessTerminated(CefRefPtr<CefBrowser> browser,
+                                         TerminationStatus status) {}
+};
+
+#endif  // CEF_INCLUDE_CEF_REQUEST_HANDLER_H_
diff --git a/src/include/libcef_/cef_resource_bundle.h b/src/include/libcef_/cef_resource_bundle.h
new file mode 100644
index 0000000..45d28e5
--- /dev/null
+++ b/src/include/libcef_/cef_resource_bundle.h
@@ -0,0 +1,99 @@
+// Copyright (c) 2015 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_RESOURCE_BUNDLE_H_
+#define CEF_INCLUDE_CEF_RESOURCE_BUNDLE_H_
+#pragma once
+
+#include"libcef/cef_base.h"
+
+///
+// Class used for retrieving resources from the resource bundle (*.pak) files
+// loaded by CEF during startup or via the CefResourceBundleHandler returned
+// from CefApp::GetResourceBundleHandler. See CefSettings for additional options
+// related to resource bundle loading. The methods of this class may be called
+// on any thread unless otherwise indicated.
+///
+/*--cef(source=library,no_debugct_check)--*/
+class CefResourceBundle : public virtual CefBase {
+ public:
+  typedef cef_scale_factor_t ScaleFactor;
+
+  ///
+  // Returns the global resource bundle instance.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefResourceBundle> GetGlobal();
+
+  ///
+  // Returns the localized string for the specified |string_id| or an empty
+  // string if the value is not found. Include cef_pack_strings.h for a listing
+  // of valid string ID values.
+  ///
+  /*--cef()--*/
+  virtual CefString GetLocalizedString(int string_id) =0;
+
+  ///
+  // Retrieves the contents of the specified scale independent |resource_id|.
+  // If the value is found then |data| and |data_size| will be populated and
+  // this method will return true. If the value is not found then this method
+  // will return false. The returned |data| pointer will remain resident in
+  // memory and should not be freed. Include cef_pack_resources.h for a listing
+  // of valid resource ID values.
+  ///
+  /*--cef()--*/
+  virtual bool GetDataResource(int resource_id,
+                               void*& data,
+                               size_t& data_size) =0;
+
+  ///
+  // Retrieves the contents of the specified |resource_id| nearest the scale
+  // factor |scale_factor|. Use a |scale_factor| value of SCALE_FACTOR_NONE for
+  // scale independent resources or call GetDataResource instead. If the value
+  // is found then |data| and |data_size| will be populated and this method will
+  // return true. If the value is not found then this method will return false.
+  // The returned |data| pointer will remain resident in memory and should not
+  // be freed. Include cef_pack_resources.h for a listing of valid resource ID
+  // values.
+  ///
+  /*--cef()--*/
+  virtual bool GetDataResourceForScale(int resource_id,
+                                       ScaleFactor scale_factor,
+                                       void*& data,
+                                       size_t& data_size) =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_RESOURCE_BUNDLE_H_
diff --git a/src/include/libcef_/cef_resource_bundle_handler.h b/src/include/libcef_/cef_resource_bundle_handler.h
new file mode 100644
index 0000000..fbf2a3f
--- /dev/null
+++ b/src/include/libcef_/cef_resource_bundle_handler.h
@@ -0,0 +1,91 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_RESOURCE_BUNDLE_HANDLER_H_
+#define CEF_INCLUDE_CEF_RESOURCE_BUNDLE_HANDLER_H_
+#pragma once
+
+#include"libcef/cef_base.h"
+
+///
+// Class used to implement a custom resource bundle interface. See CefSettings
+// for additional options related to resource bundle loading. The methods of
+// this class may be called on multiple threads.
+///
+/*--cef(source=client)--*/
+class CefResourceBundleHandler : public virtual CefBase {
+ public:
+  typedef cef_scale_factor_t ScaleFactor;
+
+  ///
+  // Called to retrieve a localized translation for the specified |string_id|.
+  // To provide the translation set |string| to the translation string and
+  // return true. To use the default translation return false. Include
+  // cef_pack_strings.h for a listing of valid string ID values.
+  ///
+  /*--cef()--*/
+  virtual bool GetLocalizedString(int string_id,
+                                  CefString& string) =0;
+
+  ///
+  // Called to retrieve data for the specified scale independent |resource_id|.
+  // To provide the resource data set |data| and |data_size| to the data pointer
+  // and size respectively and return true. To use the default resource data
+  // return false. The resource data will not be copied and must remain resident
+  // in memory. Include cef_pack_resources.h for a listing of valid resource ID
+  // values.
+  ///
+  /*--cef()--*/
+  virtual bool GetDataResource(int resource_id,
+                               void*& data,
+                               size_t& data_size) =0;
+
+  ///
+  // Called to retrieve data for the specified |resource_id| nearest the scale
+  // factor |scale_factor|. To provide the resource data set |data| and
+  // |data_size| to the data pointer and size respectively and return true. To
+  // use the default resource data return false. The resource data will not be
+  // copied and must remain resident in memory. Include cef_pack_resources.h for
+  // a listing of valid resource ID values.
+  ///
+  /*--cef()--*/
+  virtual bool GetDataResourceForScale(int resource_id,
+                                       ScaleFactor scale_factor,
+                                       void*& data,
+                                       size_t& data_size) =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_RESOURCE_BUNDLE_HANDLER_H_
diff --git a/src/include/libcef_/cef_resource_handler.h b/src/include/libcef_/cef_resource_handler.h
new file mode 100644
index 0000000..340009c
--- /dev/null
+++ b/src/include/libcef_/cef_resource_handler.h
@@ -0,0 +1,116 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_RESOURCE_HANDLER_H_
+#define CEF_INCLUDE_CEF_RESOURCE_HANDLER_H_
+#pragma once
+
+#include"libcef/cef_base.h"
+#include"libcef/cef_browser.h"
+#include"libcef/cef_callback.h"
+#include"libcef/cef_cookie.h"
+#include"libcef/cef_request.h"
+#include"libcef/cef_response.h"
+
+///
+// Class used to implement a custom request handler interface. The methods of
+// this class will always be called on the IO thread.
+///
+/*--cef(source=client)--*/
+class CefResourceHandler : public virtual CefBase {
+ public:
+  ///
+  // Begin processing the request. To handle the request return true and call
+  // CefCallback::Continue() once the response header information is available
+  // (CefCallback::Continue() can also be called from inside this method if
+  // header information is available immediately). To cancel the request return
+  // false.
+  ///
+  /*--cef()--*/
+  virtual bool ProcessRequest(CefRefPtr<CefRequest> request,
+                              CefRefPtr<CefCallback> callback) =0;
+
+  ///
+  // Retrieve response header information. If the response length is not known
+  // set |response_length| to -1 and ReadResponse() will be called until it
+  // returns false. If the response length is known set |response_length|
+  // to a positive value and ReadResponse() will be called until it returns
+  // false or the specified number of bytes have been read. Use the |response|
+  // object to set the mime type, http status code and other optional header
+  // values. To redirect the request to a new URL set |redirectUrl| to the new
+  // URL.
+  ///
+  /*--cef()--*/
+  virtual void GetResponseHeaders(CefRefPtr<CefResponse> response,
+                                  int64& response_length,
+                                  CefString& redirectUrl) =0;
+
+  ///
+  // Read response data. If data is available immediately copy up to
+  // |bytes_to_read| bytes into |data_out|, set |bytes_read| to the number of
+  // bytes copied, and return true. To read the data at a later time set
+  // |bytes_read| to 0, return true and call CefCallback::Continue() when the
+  // data is available. To indicate response completion return false.
+  ///
+  /*--cef()--*/
+  virtual bool ReadResponse(void* data_out,
+                            int bytes_to_read,
+                            int& bytes_read,
+                            CefRefPtr<CefCallback> callback) =0;
+
+  ///
+  // Return true if the specified cookie can be sent with the request or false
+  // otherwise. If false is returned for any cookie then no cookies will be sent
+  // with the request.
+  ///
+  /*--cef()--*/
+  virtual bool CanGetCookie(const CefCookie& cookie) { return true; }
+
+  ///
+  // Return true if the specified cookie returned with the response can be set
+  // or false otherwise.
+  ///
+  /*--cef()--*/
+  virtual bool CanSetCookie(const CefCookie& cookie) { return true; }
+
+  ///
+  // Request processing has been canceled.
+  ///
+  /*--cef()--*/
+  virtual void Cancel() =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_RESOURCE_HANDLER_H_
diff --git a/src/include/libcef_/cef_response.h b/src/include/libcef_/cef_response.h
new file mode 100644
index 0000000..91f2eac
--- /dev/null
+++ b/src/include/libcef_/cef_response.h
@@ -0,0 +1,120 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_RESPONSE_H_
+#define CEF_INCLUDE_CEF_RESPONSE_H_
+#pragma once
+
+#include"libcef/cef_base.h"
+#include<map>
+
+///
+// Class used to represent a web response. The methods of this class may be
+// called on any thread.
+///
+/*--cef(source=library,no_debugct_check)--*/
+class CefResponse : public virtual CefBase {
+ public:
+  typedef std::multimap<CefString, CefString> HeaderMap;
+
+  ///
+  // Create a new CefResponse object.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefResponse> Create();
+
+  ///
+  // Returns true if this object is read-only.
+  ///
+  /*--cef()--*/
+  virtual bool IsReadOnly() =0;
+
+  ///
+  // Get the response status code.
+  ///
+  /*--cef()--*/
+  virtual int GetStatus() =0;
+
+  ///
+  // Set the response status code.
+  ///
+  /*--cef()--*/
+  virtual void SetStatus(int status) = 0;
+
+  ///
+  // Get the response status text.
+  ///
+  /*--cef()--*/
+  virtual CefString GetStatusText() =0;
+
+  ///
+  // Set the response status text.
+  ///
+  /*--cef()--*/
+  virtual void SetStatusText(const CefString& statusText) = 0;
+
+  ///
+  // Get the response mime type.
+  ///
+  /*--cef()--*/
+  virtual CefString GetMimeType() = 0;
+
+  ///
+  // Set the response mime type.
+  ///
+  /*--cef()--*/
+  virtual void SetMimeType(const CefString& mimeType) = 0;
+
+  ///
+  // Get the value for the specified response header field.
+  ///
+  /*--cef()--*/
+  virtual CefString GetHeader(const CefString& name) =0;
+
+  ///
+  // Get all response header fields.
+  ///
+  /*--cef()--*/
+  virtual void GetHeaderMap(HeaderMap& headerMap) =0;
+
+  ///
+  // Set all response header fields.
+  ///
+  /*--cef()--*/
+  virtual void SetHeaderMap(const HeaderMap& headerMap) =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_RESPONSE_H_
diff --git a/src/include/libcef_/cef_response_filter.h b/src/include/libcef_/cef_response_filter.h
new file mode 100644
index 0000000..a45c29a
--- /dev/null
+++ b/src/include/libcef_/cef_response_filter.h
@@ -0,0 +1,86 @@
+// Copyright (c) 2015 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_RESPONSE_FILTER_H_
+#define CEF_INCLUDE_CEF_RESPONSE_FILTER_H_
+#pragma once
+
+#include"libcef/cef_base.h"
+
+///
+// Implement this interface to filter resource response content. The methods of
+// this class will be called on the browser process IO thread.
+///
+/*--cef(source=client)--*/
+class CefResponseFilter : public virtual CefBase {
+ public:
+  typedef cef_response_filter_status_t FilterStatus;
+
+  ///
+  // Initialize the response filter. Will only be called a single time. The
+  // filter will not be installed if this method returns false.
+  ///
+  /*--cef()--*/
+  virtual bool InitFilter() =0;
+
+  ///
+  // Called to filter a chunk of data. |data_in| is the input buffer containing
+  // |data_in_size| bytes of pre-filter data (|data_in| will be NULL if
+  // |data_in_size| is zero). |data_out| is the output buffer that can accept up
+  // to |data_out_size| bytes of filtered output data. Set |data_in_read| to the
+  // number of bytes that were read from |data_in|. Set |data_out_written| to
+  // the number of bytes that were written into |data_out|. If some or all of
+  // the pre-filter data was read successfully but more data is needed in order
+  // to continue filtering (filtered output is pending) return
+  // RESPONSE_FILTER_NEED_MORE_DATA. If some or all of the pre-filter data was
+  // read successfully and all available filtered output has been written return
+  // RESPONSE_FILTER_DONE. If an error occurs during filtering return
+  // RESPONSE_FILTER_ERROR. This method will be called repeatedly until there is
+  // no more data to filter (resource response is complete), |data_in_read|
+  // matches |data_in_size| (all available pre-filter bytes have been read), and
+  // the method returns RESPONSE_FILTER_DONE or RESPONSE_FILTER_ERROR. Do not
+  // keep a reference to the buffers passed to this method.
+  ///
+  /*--cef(optional_param=data_in,default_retval=RESPONSE_FILTER_ERROR)--*/
+  virtual FilterStatus Filter(void* data_in,
+                              size_t data_in_size,
+                              size_t& data_in_read,
+                              void* data_out,
+                              size_t data_out_size,
+                              size_t& data_out_written) =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_RESPONSE_FILTER_H_
diff --git a/src/include/libcef_/cef_runnable.h b/src/include/libcef_/cef_runnable.h
new file mode 100644
index 0000000..13c93f4
--- /dev/null
+++ b/src/include/libcef_/cef_runnable.h
@@ -0,0 +1,333 @@
+// Copyright (c) 2013 Marshall A. Greenblatt. Portions Copyright (c)
+// 2006-2011 Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// The contents of this file are a modified extract of base/task.h
+
+#ifndef CEF_INCLUDE_CEF_RUNNABLE_H_
+#define CEF_INCLUDE_CEF_RUNNABLE_H_
+#pragma once
+
+#if defined(BUILDING_CEF_SHARED)
+// The implementation of cef_runnable.h depends on an obsolete version of
+// base/tuple.h that is implemented by cef_tuple.h for client applications but
+// is not compatible with the version used when building Chromium/CEF.
+#error This header cannot be used when building Chromium/CEF.
+#endif
+
+#include"libcef/base/cef_tuple.h"
+#include"libcef/cef_base.h"
+#include"libcef/cef_task.h"
+
+// CefRunnableMethodTraits -----------------------------------------------------
+//
+// This traits-class is used by CefRunnableMethod to manage the lifetime of the
+// callee object.  By default, it is assumed that the callee supports AddRef
+// and Release methods.  A particular class can specialize this template to
+// define other lifetime management.  For example, if the callee is known to
+// live longer than the CefRunnableMethod object, then a CefRunnableMethodTraits
+// struct could be defined with empty RetainCallee and ReleaseCallee methods.
+//
+// The DISABLE_RUNNABLE_METHOD_REFCOUNT macro is provided as a convenient way
+// for declaring a CefRunnableMethodTraits that disables refcounting.
+
+template <class T>
+struct CefRunnableMethodTraits {
+  CefRunnableMethodTraits() {
+  }
+
+  ~CefRunnableMethodTraits() {
+  }
+
+  void RetainCallee(T* obj) {
+#ifndef NDEBUG
+    // Catch NewCefRunnableMethod being called in an object's constructor.
+    // This isn't safe since the method can be invoked before the constructor
+    // completes, causing the object to be deleted.
+    obj->AddRef();
+    obj->Release();
+#endif
+    obj->AddRef();
+  }
+
+  void ReleaseCallee(T* obj) {
+    obj->Release();
+  }
+};
+
+// Convenience macro for declaring a CefRunnableMethodTraits that disables
+// refcounting of a class.  This is useful if you know that the callee
+// will outlive the CefRunnableMethod object and thus do not need the ref
+// counts.
+//
+// The invocation of DISABLE_RUNNABLE_METHOD_REFCOUNT should be done at the
+// global namespace scope.  Example:
+//
+//   namespace foo {
+//   class Bar {
+//     ...
+//   };
+//   }  // namespace foo
+//
+//   DISABLE_RUNNABLE_METHOD_REFCOUNT(foo::Bar);
+//
+// This is different from DISALLOW_COPY_AND_ASSIGN which is declared inside the
+// class.
+#define DISABLE_RUNNABLE_METHOD_REFCOUNT(TypeName) \
+  template <>                                      \
+  struct CefRunnableMethodTraits<TypeName> {          \
+    void RetainCallee(TypeName* manager) {}        \
+    void ReleaseCallee(TypeName* manager) {}       \
+  }
+
+// CefRunnableMethod and CefRunnableFunction ----------------------------------
+//
+// CefRunnable methods are a type of task that call a function on an object
+// when they are run. We implement both an object and a set of
+// NewCefRunnableMethod and NewCefRunnableFunction functions for convenience.
+// These functions are overloaded and will infer the template types,
+// simplifying calling code.
+//
+// The template definitions all use the following names:
+// T                - the class type of the object you're supplying
+//                    this is not needed for the Static version of the call
+// Method/Function  - the signature of a pointer to the method or function you
+//                    want to call
+// Param            - the parameter(s) to the method, possibly packed as a Tuple
+// A                - the first parameter (if any) to the method
+// B                - the second parameter (if any) to the method
+//
+// Put these all together and you get an object that can call a method whose
+// signature is:
+//   R T::MyFunction([A[, B]])
+//
+// Usage:
+// CefPostTask(TID_UI, NewCefRunnableMethod(object, &Object::method[, a[, b]])
+// CefPostTask(TID_UI, NewCefRunnableFunction(&function[, a[, b]])
+
+// CefRunnableMethod and NewCefRunnableMethod implementation ------------------
+
+template <class T, class Method, class Params>
+class CefRunnableMethod : public CefTask {
+ public:
+  CefRunnableMethod(T* obj, Method meth, const Params& params)
+      : obj_(obj), meth_(meth), params_(params) {
+    traits_.RetainCallee(obj_);
+  }
+
+  ~CefRunnableMethod() {
+    T* obj = obj_;
+    obj_ = NULL;
+    if (obj)
+      traits_.ReleaseCallee(obj);
+  }
+
+  void Execute() OVERRIDE {
+    if (obj_)
+      DispatchToMethod(obj_, meth_, params_);
+  }
+
+ private:
+  T* obj_;
+  Method meth_;
+  Params params_;
+  CefRunnableMethodTraits<T> traits_;
+
+  IMPLEMENT_REFCOUNTING(CefRunnableMethod);
+};
+
+template <class T, class Method>
+inline CefRefPtr<CefTask> NewCefRunnableMethod(T* object, Method method) {
+  return new CefRunnableMethod<T, Method, base::Tuple0>(
+      object, method, base::MakeTuple());
+}
+
+template <class T, class Method, class A>
+inline CefRefPtr<CefTask> NewCefRunnableMethod(T* object, Method method,
+                                               const A& a) {
+  return new CefRunnableMethod<T, Method, base::Tuple1<A> >(
+      object, method, base::MakeTuple(a));
+}
+
+template <class T, class Method, class A, class B>
+inline CefRefPtr<CefTask> NewCefRunnableMethod(T* object, Method method,
+                                               const A& a, const B& b) {
+  return new CefRunnableMethod<T, Method, base::Tuple2<A, B> >(
+      object, method, base::MakeTuple(a, b));
+}
+
+template <class T, class Method, class A, class B, class C>
+inline CefRefPtr<CefTask> NewCefRunnableMethod(T* object, Method method,
+                                               const A& a, const B& b,
+                                               const C& c) {
+  return new CefRunnableMethod<T, Method, base::Tuple3<A, B, C> >(
+      object, method, base::MakeTuple(a, b, c));
+}
+
+template <class T, class Method, class A, class B, class C, class D>
+inline CefRefPtr<CefTask> NewCefRunnableMethod(T* object, Method method,
+                                               const A& a, const B& b,
+                                               const C& c, const D& d) {
+  return new CefRunnableMethod<T, Method, base::Tuple4<A, B, C, D> >(
+      object, method, base::MakeTuple(a, b, c, d));
+}
+
+template <class T, class Method, class A, class B, class C, class D, class E>
+inline CefRefPtr<CefTask> NewCefRunnableMethod(T* object, Method method,
+                                               const A& a, const B& b,
+                                               const C& c, const D& d,
+                                               const E& e) {
+  return new CefRunnableMethod<T, Method, base::Tuple5<A, B, C, D, E> >(
+      object, method, base::MakeTuple(a, b, c, d, e));
+}
+
+template <class T, class Method, class A, class B, class C, class D, class E,
+          class F>
+inline CefRefPtr<CefTask> NewCefRunnableMethod(T* object, Method method,
+                                               const A& a, const B& b,
+                                               const C& c, const D& d,
+                                               const E& e, const F& f) {
+  return new CefRunnableMethod<T, Method, base::Tuple6<A, B, C, D, E, F> >(
+      object, method, base::MakeTuple(a, b, c, d, e, f));
+}
+
+template <class T, class Method, class A, class B, class C, class D, class E,
+          class F, class G>
+inline CefRefPtr<CefTask> NewCefRunnableMethod(T* object, Method method,
+                                               const A& a, const B& b,
+                                               const C& c, const D& d,
+                                               const E& e, const F& f,
+                                               const G& g) {
+  return new CefRunnableMethod<T, Method, base::Tuple7<A, B, C, D, E, F, G> >(
+      object, method, base::MakeTuple(a, b, c, d, e, f, g));
+}
+
+// CefRunnableFunction and NewCefRunnableFunction implementation --------------
+
+template <class Function, class Params>
+class CefRunnableFunction : public CefTask {
+ public:
+  CefRunnableFunction(Function function, const Params& params)
+      : function_(function), params_(params) {
+  }
+
+  ~CefRunnableFunction() {
+  }
+
+  void Execute() OVERRIDE {
+    if (function_)
+      DispatchToFunction(function_, params_);
+  }
+
+ private:
+  Function function_;
+  Params params_;
+
+  IMPLEMENT_REFCOUNTING(CefRunnableFunction);
+};
+
+template <class Function>
+inline CefRefPtr<CefTask> NewCefRunnableFunction(Function function) {
+  return new CefRunnableFunction<Function, base::Tuple0>(
+      function, base::MakeTuple());
+}
+
+template <class Function, class A>
+inline CefRefPtr<CefTask> NewCefRunnableFunction(Function function,
+                                                 const A& a) {
+  return new CefRunnableFunction<Function, base::Tuple1<A> >(
+      function, base::MakeTuple(a));
+}
+
+template <class Function, class A, class B>
+inline CefRefPtr<CefTask> NewCefRunnableFunction(Function function,
+                                                 const A& a, const B& b) {
+  return new CefRunnableFunction<Function, base::Tuple2<A, B> >(
+      function, base::MakeTuple(a, b));
+}
+
+template <class Function, class A, class B, class C>
+inline CefRefPtr<CefTask> NewCefRunnableFunction(Function function,
+                                                 const A& a, const B& b,
+                                                 const C& c) {
+  return new CefRunnableFunction<Function, base::Tuple3<A, B, C> >(
+      function, base::MakeTuple(a, b, c));
+}
+
+template <class Function, class A, class B, class C, class D>
+inline CefRefPtr<CefTask> NewCefRunnableFunction(Function function,
+                                                 const A& a, const B& b,
+                                                 const C& c, const D& d) {
+  return new CefRunnableFunction<Function, base::Tuple4<A, B, C, D> >(
+      function, base::MakeTuple(a, b, c, d));
+}
+
+template <class Function, class A, class B, class C, class D, class E>
+inline CefRefPtr<CefTask> NewCefRunnableFunction(Function function,
+                                                 const A& a, const B& b,
+                                                 const C& c, const D& d,
+                                                 const E& e) {
+  return new CefRunnableFunction<Function, base::Tuple5<A, B, C, D, E> >(
+      function, base::MakeTuple(a, b, c, d, e));
+}
+
+template <class Function, class A, class B, class C, class D, class E,
+          class F>
+inline CefRefPtr<CefTask> NewCefRunnableFunction(Function function,
+                                                 const A& a, const B& b,
+                                                 const C& c, const D& d,
+                                                 const E& e, const F& f) {
+  return new CefRunnableFunction<Function, base::Tuple6<A, B, C, D, E, F> >(
+      function, base::MakeTuple(a, b, c, d, e, f));
+}
+
+template <class Function, class A, class B, class C, class D, class E,
+          class F, class G>
+inline CefRefPtr<CefTask> NewCefRunnableFunction(Function function,
+                                                 const A& a, const B& b,
+                                                 const C& c, const D& d,
+                                                 const E& e, const F& f,
+                                                 const G& g) {
+  return new CefRunnableFunction<Function, base::Tuple7<A, B, C, D, E, F, G> >(
+      function, base::MakeTuple(a, b, c, d, e, f, g));
+}
+
+template <class Function, class A, class B, class C, class D, class E,
+          class F, class G, class H>
+inline CefRefPtr<CefTask> NewCefRunnableFunction(Function function,
+                                                 const A& a, const B& b,
+                                                 const C& c, const D& d,
+                                                 const E& e, const F& f,
+                                                 const G& g, const H& h) {
+  return new CefRunnableFunction<Function,
+                                 base::Tuple8<A, B, C, D, E, F, G, H> >(
+      function, base::MakeTuple(a, b, c, d, e, f, g, h));
+}
+
+#endif  // CEF_INCLUDE_CEF_RUNNABLE_H_
diff --git a/src/include/libcef_/cef_sandbox_win.h b/src/include/libcef_/cef_sandbox_win.h
new file mode 100644
index 0000000..b93c6ed
--- /dev/null
+++ b/src/include/libcef_/cef_sandbox_win.h
@@ -0,0 +1,92 @@
+// Copyright (c) 2013 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef CEF_INCLUDE_CEF_SANDBOX_WIN_H_
+#define CEF_INCLUDE_CEF_SANDBOX_WIN_H_
+#pragma once
+
+#include"libcef/cef_base.h"
+
+#if defined(OS_WIN)
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// The sandbox is used to restrict sub-processes (renderer, plugin, GPU, etc)
+// from directly accessing system resources. This helps to protect the user
+// from untrusted and potentially malicious Web content.
+// See http://www.chromium.org/developers/design-documents/sandbox for
+// complete details.
+//
+// To enable the sandbox on Windows the following requirements must be met:
+// 1. Use the same executable for the browser process and all sub-processes.
+// 2. Link the executable with the cef_sandbox static library.
+// 3. Call the cef_sandbox_info_create() function from within the executable
+//    (not from a separate DLL) and pass the resulting pointer into both the
+//    CefExecutProcess() and CefInitialize() functions via the
+//    |windows_sandbox_info| parameter.
+
+///
+// Create the sandbox information object for this process. It is safe to create
+// multiple of this object and to destroy the object immediately after passing
+// into the CefExecutProcess() and/or CefInitialize() functions.
+///
+void* cef_sandbox_info_create();
+
+///
+// Destroy the specified sandbox information object.
+///
+void cef_sandbox_info_destroy(void* sandbox_info);
+
+#ifdef __cplusplus
+}
+
+///
+// Manages the life span of a sandbox information object.
+///
+class CefScopedSandboxInfo {
+ public:
+  CefScopedSandboxInfo() {
+    sandbox_info_ = cef_sandbox_info_create();
+  }
+  ~CefScopedSandboxInfo() {
+    cef_sandbox_info_destroy(sandbox_info_);
+  }
+
+  void* sandbox_info() const { return sandbox_info_; }
+
+ private:
+  void* sandbox_info_;
+};
+#endif  // __cplusplus
+
+#endif  // defined(OS_WIN)
+
+#endif  // CEF_INCLUDE_CEF_SANDBOX_WIN_H_
diff --git a/src/include/libcef_/cef_scheme.h b/src/include/libcef_/cef_scheme.h
new file mode 100644
index 0000000..cfcc2cc
--- /dev/null
+++ b/src/include/libcef_/cef_scheme.h
@@ -0,0 +1,164 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_SCHEME_H_
+#define CEF_INCLUDE_CEF_SCHEME_H_
+#pragma once
+
+#include"libcef/cef_base.h"
+#include"libcef/cef_browser.h"
+#include"libcef/cef_frame.h"
+#include"libcef/cef_request.h"
+#include"libcef/cef_response.h"
+#include"libcef/cef_resource_handler.h"
+
+class CefSchemeHandlerFactory;
+
+
+///
+// Register a scheme handler factory with the global request context. An empty
+// |domain_name| value for a standard scheme will cause the factory to match all
+// domain names. The |domain_name| value will be ignored for non-standard
+// schemes. If |scheme_name| is a built-in scheme and no handler is returned by
+// |factory| then the built-in scheme handler factory will be called. If
+// |scheme_name| is a custom scheme then you must also implement the
+// CefApp::OnRegisterCustomSchemes() method in all processes. This function may
+// be called multiple times to change or remove the factory that matches the
+// specified |scheme_name| and optional |domain_name|. Returns false if an error
+// occurs. This function may be called on any thread in the browser process.
+// Using this function is equivalent to calling
+// CefRequestContext::GetGlobalContext()->RegisterSchemeHandlerFactory().
+///
+/*--cef(optional_param=domain_name,optional_param=factory)--*/
+bool CefRegisterSchemeHandlerFactory(
+    const CefString& scheme_name,
+    const CefString& domain_name,
+    CefRefPtr<CefSchemeHandlerFactory> factory);
+
+///
+// Clear all scheme handler factories registered with the global request
+// context. Returns false on error. This function may be called on any thread in
+// the browser process. Using this function is equivalent to calling
+// CefRequestContext::GetGlobalContext()->ClearSchemeHandlerFactories().
+///
+/*--cef()--*/
+bool CefClearSchemeHandlerFactories();
+
+
+///
+// Class that manages custom scheme registrations.
+///
+/*--cef(source=library)--*/
+class CefSchemeRegistrar : public virtual CefBase {
+ public:
+  ///
+  // Register a custom scheme. This method should not be called for the built-in
+  // HTTP, HTTPS, FILE, FTP, ABOUT and DATA schemes.
+  //
+  // If |is_standard| is true the scheme will be treated as a standard scheme.
+  // Standard schemes are subject to URL canonicalization and parsing rules as
+  // defined in the Common Internet Scheme Syntax RFC 1738 Section 3.1 available
+  // at http://www.ietf.org/rfc/rfc1738.txt
+  //
+  // In particular, the syntax for standard scheme URLs must be of the form:
+  // <pre>
+  //  [scheme]://[username]:[password]@[host]:[port]/[url-path]
+  // </pre>
+  // Standard scheme URLs must have a host component that is a fully qualified
+  // domain name as defined in Section 3.5 of RFC 1034 [13] and Section 2.1 of
+  // RFC 1123. These URLs will be canonicalized to "scheme://host/path" in the
+  // simplest case and "scheme://username:password@host:port/path" in the most
+  // explicit case. For example, "scheme:host/path" and "scheme:///host/path"
+  // will both be canonicalized to "scheme://host/path". The origin of a
+  // standard scheme URL is the combination of scheme, host and port (i.e.,
+  // "scheme://host:port" in the most explicit case).
+  //
+  // For non-standard scheme URLs only the "scheme:" component is parsed and
+  // canonicalized. The remainder of the URL will be passed to the handler
+  // as-is. For example, "scheme:///some%20text" will remain the same.
+  // Non-standard scheme URLs cannot be used as a target for form submission.
+  //
+  // If |is_local| is true the scheme will be treated as local (i.e., with the
+  // same security rules as those applied to "file" URLs). Normal pages cannot
+  // link to or access local URLs. Also, by default, local URLs can only perform
+  // XMLHttpRequest calls to the same URL (origin + path) that originated the
+  // request. To allow XMLHttpRequest calls from a local URL to other URLs with
+  // the same origin set the CefSettings.file_access_from_file_urls_allowed
+  // value to true. To allow XMLHttpRequest calls from a local URL to all
+  // origins set the CefSettings.universal_access_from_file_urls_allowed value
+  // to true.
+  //
+  // If |is_display_isolated| is true the scheme will be treated as display-
+  // isolated. This means that pages cannot display these URLs unless they are
+  // from the same scheme. For example, pages in another origin cannot create
+  // iframes or hyperlinks to URLs with this scheme.
+  //
+  // This function may be called on any thread. It should only be called once
+  // per unique |scheme_name| value. If |scheme_name| is already registered or
+  // if an error occurs this method will return false.
+  ///
+  /*--cef()--*/
+  virtual bool AddCustomScheme(const CefString& scheme_name,
+                               bool is_standard,
+                               bool is_local,
+                               bool is_display_isolated) =0;
+};
+
+
+///
+// Class that creates CefResourceHandler instances for handling scheme requests.
+// The methods of this class will always be called on the IO thread.
+///
+/*--cef(source=client)--*/
+class CefSchemeHandlerFactory : public virtual CefBase {
+ public:
+  ///
+  // Return a new resource handler instance to handle the request or an empty
+  // reference to allow default handling of the request. |browser| and |frame|
+  // will be the browser window and frame respectively that originated the
+  // request or NULL if the request did not originate from a browser window
+  // (for example, if the request came from CefURLRequest). The |request| object
+  // passed to this method will not contain cookie data.
+  ///
+  /*--cef(optional_param=browser,optional_param=frame)--*/
+  virtual CefRefPtr<CefResourceHandler> Create(
+      CefRefPtr<CefBrowser> browser,
+      CefRefPtr<CefFrame> frame,
+      const CefString& scheme_name,
+      CefRefPtr<CefRequest> request) =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_SCHEME_H_
diff --git a/src/include/libcef_/cef_ssl_info.h b/src/include/libcef_/cef_ssl_info.h
new file mode 100644
index 0000000..f7188ae
--- /dev/null
+++ b/src/include/libcef_/cef_ssl_info.h
@@ -0,0 +1,207 @@
+// Copyright (c) 2015 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_SSL_INFO_H_
+#define CEF_INCLUDE_CEF_SSL_INFO_H_
+#pragma once
+
+#include<vector>
+
+#include"libcef/cef_base.h"
+#include"libcef/cef_values.h"
+
+///
+// Class representing the issuer or subject field of an X.509 certificate.
+///
+/*--cef(source=library)--*/
+class CefSSLCertPrincipal : public virtual CefBase {
+ public:
+  ///
+  // Returns a name that can be used to represent the issuer.  It tries in this
+  // order: CN, O and OU and returns the first non-empty one found.
+  ///
+  /*--cef()--*/
+  virtual CefString GetDisplayName() =0;
+
+  ///
+  // Returns the common name.
+  ///
+  /*--cef()--*/
+  virtual CefString GetCommonName() =0;
+
+  ///
+  // Returns the locality name.
+  ///
+  /*--cef()--*/
+  virtual CefString GetLocalityName() =0;
+
+  ///
+  // Returns the state or province name.
+  ///
+  /*--cef()--*/
+  virtual CefString GetStateOrProvinceName() =0;
+
+  ///
+  // Returns the country name.
+  ///
+  /*--cef()--*/
+  virtual CefString GetCountryName() =0;
+
+  ///
+  // Retrieve the list of street addresses.
+  ///
+  /*--cef()--*/
+  virtual void GetStreetAddresses(std::vector<CefString>& addresses) =0;
+
+  ///
+  // Retrieve the list of organization names.
+  ///
+  /*--cef()--*/
+  virtual void GetOrganizationNames(std::vector<CefString>& names) =0;
+
+  ///
+  // Retrieve the list of organization unit names.
+  ///
+  /*--cef()--*/
+  virtual void GetOrganizationUnitNames(std::vector<CefString>& names) =0;
+
+  ///
+  // Retrieve the list of domain components.
+  ///
+  /*--cef()--*/
+  virtual void GetDomainComponents(std::vector<CefString>& components) =0;
+};
+
+///
+// Class representing SSL information.
+///
+/*--cef(source=library)--*/
+class CefSSLInfo : public virtual CefBase {
+ public:
+  typedef std::vector<CefRefPtr<CefBinaryValue> > IssuerChainBinaryList;
+
+  ///
+  // Returns a bitmask containing any and all problems verifying the server
+  // certificate.
+  ///
+  /*--cef(default_retval=CERT_STATUS_NONE)--*/
+  virtual cef_cert_status_t GetCertStatus() =0;
+
+  ///
+  // Returns true if the certificate status has any error, major or minor.
+  ///
+  /*--cef()--*/
+  virtual bool IsCertStatusError() =0;
+
+  ///
+  // Returns true if the certificate status represents only minor errors
+  // (e.g. failure to verify certificate revocation).
+  ///
+  /*--cef()--*/
+  virtual bool IsCertStatusMinorError() =0;
+
+  ///
+  // Returns the subject of the X.509 certificate. For HTTPS server
+  // certificates this represents the web server.  The common name of the
+  // subject should match the host name of the web server.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefSSLCertPrincipal> GetSubject() =0;
+
+  ///
+  // Returns the issuer of the X.509 certificate.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefSSLCertPrincipal> GetIssuer() =0;
+
+  ///
+  // Returns the DER encoded serial number for the X.509 certificate. The value
+  // possibly includes a leading 00 byte.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefBinaryValue> GetSerialNumber() =0;
+  
+  ///
+  // Returns the date before which the X.509 certificate is invalid.
+  // CefTime.GetTimeT() will return 0 if no date was specified.
+  ///
+  /*--cef()--*/
+  virtual CefTime GetValidStart() =0;
+
+  ///
+  // Returns the date after which the X.509 certificate is invalid.
+  // CefTime.GetTimeT() will return 0 if no date was specified.
+  ///
+  /*--cef()--*/
+  virtual CefTime GetValidExpiry() =0;
+
+  ///
+  // Returns the DER encoded data for the X.509 certificate.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefBinaryValue> GetDEREncoded() =0;
+
+  ///
+  // Returns the PEM encoded data for the X.509 certificate.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefBinaryValue> GetPEMEncoded() =0;
+
+  ///
+  // Returns the number of certificates in the issuer chain.
+  // If 0, the certificate is self-signed.
+  ///
+  /*--cef()--*/
+  virtual size_t GetIssuerChainSize() =0;
+
+  ///
+  // Returns the DER encoded data for the certificate issuer chain.
+  // If we failed to encode a certificate in the chain it is still
+  // present in the array but is an empty string.
+  ///
+  /*--cef(count_func=chain:GetIssuerChainSize)--*/
+  virtual void GetDEREncodedIssuerChain(IssuerChainBinaryList& chain) =0;
+
+  ///
+  // Returns the PEM encoded data for the certificate issuer chain.
+  // If we failed to encode a certificate in the chain it is still
+  // present in the array but is an empty string.
+  ///
+  /*--cef(count_func=chain:GetIssuerChainSize)--*/
+  virtual void GetPEMEncodedIssuerChain(IssuerChainBinaryList& chain) =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_SSL_INFO_H_
diff --git a/src/include/libcef_/cef_stream.h b/src/include/libcef_/cef_stream.h
new file mode 100644
index 0000000..bb1f33e
--- /dev/null
+++ b/src/include/libcef_/cef_stream.h
@@ -0,0 +1,242 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_STREAM_H_
+#define CEF_INCLUDE_CEF_STREAM_H_
+
+#include"libcef/cef_base.h"
+
+///
+// Interface the client can implement to provide a custom stream reader. The
+// methods of this class may be called on any thread.
+///
+/*--cef(source=client)--*/
+class CefReadHandler : public virtual CefBase {
+ public:
+  ///
+  // Read raw binary data.
+  ///
+  /*--cef()--*/
+  virtual size_t Read(void* ptr, size_t size, size_t n) =0;
+
+  ///
+  // Seek to the specified offset position. |whence| may be any one of
+  // SEEK_CUR, SEEK_END or SEEK_SET. Return zero on success and non-zero on
+  // failure.
+  ///
+  /*--cef()--*/
+  virtual int Seek(int64 offset, int whence) =0;
+
+  ///
+  // Return the current offset position.
+  ///
+  /*--cef()--*/
+  virtual int64 Tell() =0;
+
+  ///
+  // Return non-zero if at end of file.
+  ///
+  /*--cef()--*/
+  virtual int Eof() =0;
+
+  ///
+  // Return true if this handler performs work like accessing the file system
+  // which may block. Used as a hint for determining the thread to access the
+  // handler from.
+  ///
+  /*--cef()--*/
+  virtual bool MayBlock() =0;
+};
+
+
+///
+// Class used to read data from a stream. The methods of this class may be
+// called on any thread.
+///
+/*--cef(source=library)--*/
+class CefStreamReader : public virtual CefBase {
+ public:
+  ///
+  // Create a new CefStreamReader object from a file.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefStreamReader> CreateForFile(const CefString& fileName);
+  ///
+  // Create a new CefStreamReader object from data.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefStreamReader> CreateForData(void* data, size_t size);
+  ///
+  // Create a new CefStreamReader object from a custom handler.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefStreamReader> CreateForHandler(
+      CefRefPtr<CefReadHandler> handler);
+
+  ///
+  // Read raw binary data.
+  ///
+  /*--cef()--*/
+  virtual size_t Read(void* ptr, size_t size, size_t n) =0;
+
+  ///
+  // Seek to the specified offset position. |whence| may be any one of
+  // SEEK_CUR, SEEK_END or SEEK_SET. Returns zero on success and non-zero on
+  // failure.
+  ///
+  /*--cef()--*/
+  virtual int Seek(int64 offset, int whence) =0;
+
+  ///
+  // Return the current offset position.
+  ///
+  /*--cef()--*/
+  virtual int64 Tell() =0;
+
+  ///
+  // Return non-zero if at end of file.
+  ///
+  /*--cef()--*/
+  virtual int Eof() =0;
+
+  ///
+  // Returns true if this reader performs work like accessing the file system
+  // which may block. Used as a hint for determining the thread to access the
+  // reader from.
+  ///
+  /*--cef()--*/
+  virtual bool MayBlock() =0;
+};
+
+
+///
+// Interface the client can implement to provide a custom stream writer. The
+// methods of this class may be called on any thread.
+///
+/*--cef(source=client)--*/
+class CefWriteHandler : public virtual CefBase {
+ public:
+  ///
+  // Write raw binary data.
+  ///
+  /*--cef()--*/
+  virtual size_t Write(const void* ptr, size_t size, size_t n) =0;
+
+  ///
+  // Seek to the specified offset position. |whence| may be any one of
+  // SEEK_CUR, SEEK_END or SEEK_SET. Return zero on success and non-zero on
+  // failure.
+  ///
+  /*--cef()--*/
+  virtual int Seek(int64 offset, int whence) =0;
+
+  ///
+  // Return the current offset position.
+  ///
+  /*--cef()--*/
+  virtual int64 Tell() =0;
+
+  ///
+  // Flush the stream.
+  ///
+  /*--cef()--*/
+  virtual int Flush() =0;
+
+  ///
+  // Return true if this handler performs work like accessing the file system
+  // which may block. Used as a hint for determining the thread to access the
+  // handler from.
+  ///
+  /*--cef()--*/
+  virtual bool MayBlock() =0;
+};
+
+
+///
+// Class used to write data to a stream. The methods of this class may be called
+// on any thread.
+///
+/*--cef(source=library)--*/
+class CefStreamWriter : public virtual CefBase {
+ public:
+  ///
+  // Create a new CefStreamWriter object for a file.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefStreamWriter> CreateForFile(const CefString& fileName);
+  ///
+  // Create a new CefStreamWriter object for a custom handler.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefStreamWriter> CreateForHandler(
+      CefRefPtr<CefWriteHandler> handler);
+
+  ///
+  // Write raw binary data.
+  ///
+  /*--cef()--*/
+  virtual size_t Write(const void* ptr, size_t size, size_t n) =0;
+
+  ///
+  // Seek to the specified offset position. |whence| may be any one of
+  // SEEK_CUR, SEEK_END or SEEK_SET. Returns zero on success and non-zero on
+  // failure.
+  ///
+  /*--cef()--*/
+  virtual int Seek(int64 offset, int whence) =0;
+
+  ///
+  // Return the current offset position.
+  ///
+  /*--cef()--*/
+  virtual int64 Tell() =0;
+
+  ///
+  // Flush the stream.
+  ///
+  /*--cef()--*/
+  virtual int Flush() =0;
+
+  ///
+  // Returns true if this writer performs work like accessing the file system
+  // which may block. Used as a hint for determining the thread to access the
+  // writer from.
+  ///
+  /*--cef()--*/
+  virtual bool MayBlock() =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_STREAM_H_
diff --git a/src/include/libcef_/cef_string_visitor.h b/src/include/libcef_/cef_string_visitor.h
new file mode 100644
index 0000000..6003ab7
--- /dev/null
+++ b/src/include/libcef_/cef_string_visitor.h
@@ -0,0 +1,55 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_STRING_VISITOR_H_
+#define CEF_INCLUDE_CEF_STRING_VISITOR_H_
+
+#include"libcef/cef_base.h"
+
+///
+// Implement this interface to receive string values asynchronously.
+///
+/*--cef(source=client)--*/
+class CefStringVisitor : public virtual CefBase {
+ public:
+  ///
+  // Method that will be executed.
+  ///
+  /*--cef(optional_param=string)--*/
+  virtual void Visit(const CefString& string) =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_STRING_VISITOR_H_
diff --git a/src/include/libcef_/cef_task.h b/src/include/libcef_/cef_task.h
new file mode 100644
index 0000000..ee67b81
--- /dev/null
+++ b/src/include/libcef_/cef_task.h
@@ -0,0 +1,148 @@
+// Copyright (c) 2013 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_TASK_H_
+#define CEF_INCLUDE_CEF_TASK_H_
+
+#include"libcef/cef_base.h"
+
+typedef cef_thread_id_t CefThreadId;
+
+///
+// Implement this interface for asynchronous task execution. If the task is
+// posted successfully and if the associated message loop is still running then
+// the Execute() method will be called on the target thread. If the task fails
+// to post then the task object may be destroyed on the source thread instead of
+// the target thread. For this reason be cautious when performing work in the
+// task object destructor.
+///
+/*--cef(source=client)--*/
+class CefTask : public virtual CefBase {
+ public:
+  ///
+  // Method that will be executed on the target thread.
+  ///
+  /*--cef()--*/
+  virtual void Execute() =0;
+};
+
+///
+// Class that asynchronously executes tasks on the associated thread. It is safe
+// to call the methods of this class on any thread.
+//
+// CEF maintains multiple internal threads that are used for handling different
+// types of tasks in different processes. The cef_thread_id_t definitions in
+// cef_types.h list the common CEF threads. Task runners are also available for
+// other CEF threads as appropriate (for example, V8 WebWorker threads).
+///
+/*--cef(source=library)--*/
+class CefTaskRunner : public virtual CefBase {
+ public:
+  ///
+  // Returns the task runner for the current thread. Only CEF threads will have
+  // task runners. An empty reference will be returned if this method is called
+  // on an invalid thread.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefTaskRunner> GetForCurrentThread();
+
+  ///
+  // Returns the task runner for the specified CEF thread.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefTaskRunner> GetForThread(CefThreadId threadId);
+
+  ///
+  // Returns true if this object is pointing to the same task runner as |that|
+  // object.
+  ///
+  /*--cef()--*/
+  virtual bool IsSame(CefRefPtr<CefTaskRunner> that) =0;
+
+  ///
+  // Returns true if this task runner belongs to the current thread.
+  ///
+  /*--cef()--*/
+  virtual bool BelongsToCurrentThread() =0;
+
+  ///
+  // Returns true if this task runner is for the specified CEF thread.
+  ///
+  /*--cef()--*/
+  virtual bool BelongsToThread(CefThreadId threadId) =0;
+
+  ///
+  // Post a task for execution on the thread associated with this task runner.
+  // Execution will occur asynchronously.
+  ///
+  /*--cef()--*/
+  virtual bool PostTask(CefRefPtr<CefTask> task) =0;
+
+  ///
+  // Post a task for delayed execution on the thread associated with this task
+  // runner. Execution will occur asynchronously. Delayed tasks are not
+  // supported on V8 WebWorker threads and will be executed without the
+  // specified delay.
+  ///
+  /*--cef()--*/
+  virtual bool PostDelayedTask(CefRefPtr<CefTask> task, int64 delay_ms) =0;
+};
+
+
+///
+// Returns true if called on the specified thread. Equivalent to using
+// CefTaskRunner::GetForThread(threadId)->BelongsToCurrentThread().
+///
+/*--cef()--*/
+bool CefCurrentlyOn(CefThreadId threadId);
+
+///
+// Post a task for execution on the specified thread. Equivalent to
+// using CefTaskRunner::GetForThread(threadId)->PostTask(task).
+///
+/*--cef()--*/
+bool CefPostTask(CefThreadId threadId, CefRefPtr<CefTask> task);
+
+///
+// Post a task for delayed execution on the specified thread. Equivalent to
+// using CefTaskRunner::GetForThread(threadId)->PostDelayedTask(task, delay_ms).
+///
+/*--cef()--*/
+bool CefPostDelayedTask(CefThreadId threadId, CefRefPtr<CefTask> task,
+                        int64 delay_ms);
+
+
+#endif  // CEF_INCLUDE_CEF_TASK_H_
diff --git a/src/include/libcef_/cef_trace.h b/src/include/libcef_/cef_trace.h
new file mode 100644
index 0000000..87da351
--- /dev/null
+++ b/src/include/libcef_/cef_trace.h
@@ -0,0 +1,111 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. Portons copyright (c) 2012
+// Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+// See cef_trace_event.h for trace macros and additonal documentation.
+
+#ifndef CEF_INCLUDE_CEF_TRACE_H_
+#define CEF_INCLUDE_CEF_TRACE_H_
+#pragma once
+
+#include"libcef/cef_base.h"
+#include"libcef/cef_callback.h"
+
+///
+// Implement this interface to receive notification when tracing has completed.
+// The methods of this class will be called on the browser process UI thread.
+///
+/*--cef(source=client)--*/
+class CefEndTracingCallback : public virtual CefBase {
+ public:
+  ///
+  // Called after all processes have sent their trace data. |tracing_file| is
+  // the path at which tracing data was written. The client is responsible for
+  // deleting |tracing_file|.
+  ///
+  /*--cef()--*/
+  virtual void OnEndTracingComplete(const CefString& tracing_file) =0;
+};
+
+
+///
+// Start tracing events on all processes. Tracing is initialized asynchronously
+// and |callback| will be executed on the UI thread after initialization is
+// complete.
+//
+// If CefBeginTracing was called previously, or if a CefEndTracingAsync call is
+// pending, CefBeginTracing will fail and return false.
+//
+// |categories| is a comma-delimited list of category wildcards. A category can
+// have an optional '-' prefix to make it an excluded category. Having both
+// included and excluded categories in the same list is not supported.
+//
+// Example: "test_MyTest*"
+// Example: "test_MyTest*,test_OtherStuff"
+// Example: "-excluded_category1,-excluded_category2"
+//
+// This function must be called on the browser process UI thread.
+///
+/*--cef(optional_param=categories,optional_param=callback)--*/
+bool CefBeginTracing(const CefString& categories,
+                     CefRefPtr<CefCompletionCallback> callback);
+
+///
+// Stop tracing events on all processes.
+//
+// This function will fail and return false if a previous call to
+// CefEndTracingAsync is already pending or if CefBeginTracing was not called.
+//
+// |tracing_file| is the path at which tracing data will be written and
+// |callback| is the callback that will be executed once all processes have
+// sent their trace data. If |tracing_file| is empty a new temporary file path
+// will be used. If |callback| is empty no trace data will be written.
+//
+// This function must be called on the browser process UI thread.
+///
+/*--cef(optional_param=tracing_file,optional_param=callback)--*/
+bool CefEndTracing(const CefString& tracing_file,
+                   CefRefPtr<CefEndTracingCallback> callback);
+
+///
+// Returns the current system trace time or, if none is defined, the current
+// high-res time. Can be used by clients to synchronize with the time
+// information in trace events.
+///
+/*--cef()--*/
+int64 CefNowFromSystemTraceTime();
+
+#endif  // CEF_INCLUDE_CEF_TRACE_H_
diff --git a/src/include/libcef_/cef_urlrequest.h b/src/include/libcef_/cef_urlrequest.h
new file mode 100644
index 0000000..37a475d
--- /dev/null
+++ b/src/include/libcef_/cef_urlrequest.h
@@ -0,0 +1,188 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_URLREQUEST_H_
+#define CEF_INCLUDE_CEF_URLREQUEST_H_
+#pragma once
+
+#include"libcef/cef_auth_callback.h"
+#include"libcef/cef_base.h"
+#include"libcef/cef_request.h"
+#include"libcef/cef_request_context.h"
+#include"libcef/cef_response.h"
+
+class CefURLRequestClient;
+
+///
+// Class used to make a URL request. URL requests are not associated with a
+// browser instance so no CefClient callbacks will be executed. URL requests
+// can be created on any valid CEF thread in either the browser or render
+// process. Once created the methods of the URL request object must be accessed
+// on the same thread that created it.
+///
+/*--cef(source=library)--*/
+class CefURLRequest : public virtual CefBase {
+ public:
+  typedef cef_urlrequest_status_t Status;
+  typedef cef_errorcode_t ErrorCode;
+
+  ///
+  // Create a new URL request. Only GET, POST, HEAD, DELETE and PUT request
+  // methods are supported. Multiple post data elements are not supported and
+  // elements of type PDE_TYPE_FILE are only supported for requests originating
+  // from the browser process. Requests originating from the render process will
+  // receive the same handling as requests originating from Web content -- if
+  // the response contains Content-Disposition or Mime-Type header values that
+  // would not normally be rendered then the response may receive special
+  // handling inside the browser (for example, via the file download code path
+  // instead of the URL request code path). The |request| object will be marked
+  // as read-only after calling this method. In the browser process if
+  // |request_context| is empty the global request context will be used. In the
+  // render process |request_context| must be empty and the context associated
+  // with the current renderer process' browser will be used.
+  ///
+  /*--cef(optional_param=request_context)--*/
+  static CefRefPtr<CefURLRequest> Create(
+      CefRefPtr<CefRequest> request,
+      CefRefPtr<CefURLRequestClient> client,
+      CefRefPtr<CefRequestContext> request_context);
+
+  ///
+  // Returns the request object used to create this URL request. The returned
+  // object is read-only and should not be modified.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefRequest> GetRequest() =0;
+
+  ///
+  // Returns the client.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefURLRequestClient> GetClient() =0;
+
+  ///
+  // Returns the request status.
+  ///
+  /*--cef(default_retval=UR_UNKNOWN)--*/
+  virtual Status GetRequestStatus() =0;
+
+  ///
+  // Returns the request error if status is UR_CANCELED or UR_FAILED, or 0
+  // otherwise.
+  ///
+  /*--cef(default_retval=ERR_NONE)--*/
+  virtual ErrorCode GetRequestError() =0;
+
+  ///
+  // Returns the response, or NULL if no response information is available.
+  // Response information will only be available after the upload has completed.
+  // The returned object is read-only and should not be modified.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefResponse> GetResponse() =0;
+
+  ///
+  // Cancel the request.
+  ///
+  /*--cef()--*/
+  virtual void Cancel() =0;
+};
+
+///
+// Interface that should be implemented by the CefURLRequest client. The
+// methods of this class will be called on the same thread that created the
+// request unless otherwise documented.
+///
+/*--cef(source=client)--*/
+class CefURLRequestClient : public virtual CefBase {
+ public:
+  ///
+  // Notifies the client that the request has completed. Use the
+  // CefURLRequest::GetRequestStatus method to determine if the request was
+  // successful or not.
+  ///
+  /*--cef()--*/
+  virtual void OnRequestComplete(CefRefPtr<CefURLRequest> request) =0;
+
+  ///
+  // Notifies the client of upload progress. |current| denotes the number of
+  // bytes sent so far and |total| is the total size of uploading data (or -1 if
+  // chunked upload is enabled). This method will only be called if the
+  // UR_FLAG_REPORT_UPLOAD_PROGRESS flag is set on the request.
+  ///
+  /*--cef()--*/
+  virtual void OnUploadProgress(CefRefPtr<CefURLRequest> request,
+                                int64 current,
+                                int64 total) =0;
+
+  ///
+  // Notifies the client of download progress. |current| denotes the number of
+  // bytes received up to the call and |total| is the expected total size of the
+  // response (or -1 if not determined).
+  ///
+  /*--cef()--*/
+  virtual void OnDownloadProgress(CefRefPtr<CefURLRequest> request,
+                                  int64 current,
+                                  int64 total) =0;
+
+  ///
+  // Called when some part of the response is read. |data| contains the current
+  // bytes received since the last call. This method will not be called if the
+  // UR_FLAG_NO_DOWNLOAD_DATA flag is set on the request.
+  ///
+  /*--cef()--*/
+  virtual void OnDownloadData(CefRefPtr<CefURLRequest> request,
+                              const void* data,
+                              size_t data_length) =0;
+
+  ///
+  // Called on the IO thread when the browser needs credentials from the user.
+  // |isProxy| indicates whether the host is a proxy server. |host| contains the
+  // hostname and |port| contains the port number. Return true to continue the
+  // request and call CefAuthCallback::Continue() when the authentication
+  // information is available. Return false to cancel the request. This method
+  // will only be called for requests initiated from the browser process.
+  ///
+  /*--cef(optional_param=realm)--*/
+  virtual bool GetAuthCredentials(bool isProxy,
+                                  const CefString& host,
+                                  int port,
+                                  const CefString& realm,
+                                  const CefString& scheme,
+                                  CefRefPtr<CefAuthCallback> callback) =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_URLREQUEST_H_
diff --git a/src/include/libcef_/cef_v8.h b/src/include/libcef_/cef_v8.h
new file mode 100644
index 0000000..5712ed4
--- /dev/null
+++ b/src/include/libcef_/cef_v8.h
@@ -0,0 +1,879 @@
+// Copyright (c) 2013 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+
+#ifndef CEF_INCLUDE_CEF_V8_H_
+#define CEF_INCLUDE_CEF_V8_H_
+#pragma once
+
+#include"libcef/cef_base.h"
+#include"libcef/cef_browser.h"
+#include"libcef/cef_frame.h"
+#include"libcef/cef_task.h"
+#include<vector>
+
+class CefV8Exception;
+class CefV8Handler;
+class CefV8StackFrame;
+class CefV8Value;
+
+
+///
+// Register a new V8 extension with the specified JavaScript extension code and
+// handler. Functions implemented by the handler are prototyped using the
+// keyword 'native'. The calling of a native function is restricted to the scope
+// in which the prototype of the native function is defined. This function may
+// only be called on the render process main thread.
+//
+// Example JavaScript extension code:
+// <pre>
+//   // create the 'example' global object if it doesn't already exist.
+//   if (!example)
+//     example = {};
+//   // create the 'example.test' global object if it doesn't already exist.
+//   if (!example.test)
+//     example.test = {};
+//   (function() {
+//     // Define the function 'example.test.myfunction'.
+//     example.test.myfunction = function() {
+//       // Call CefV8Handler::Execute() with the function name 'MyFunction'
+//       // and no arguments.
+//       native function MyFunction();
+//       return MyFunction();
+//     };
+//     // Define the getter function for parameter 'example.test.myparam'.
+//     example.test.__defineGetter__('myparam', function() {
+//       // Call CefV8Handler::Execute() with the function name 'GetMyParam'
+//       // and no arguments.
+//       native function GetMyParam();
+//       return GetMyParam();
+//     });
+//     // Define the setter function for parameter 'example.test.myparam'.
+//     example.test.__defineSetter__('myparam', function(b) {
+//       // Call CefV8Handler::Execute() with the function name 'SetMyParam'
+//       // and a single argument.
+//       native function SetMyParam();
+//       if(b) SetMyParam(b);
+//     });
+//
+//     // Extension definitions can also contain normal JavaScript variables
+//     // and functions.
+//     var myint = 0;
+//     example.test.increment = function() {
+//       myint += 1;
+//       return myint;
+//     };
+//   })();
+// </pre>
+// Example usage in the page:
+// <pre>
+//   // Call the function.
+//   example.test.myfunction();
+//   // Set the parameter.
+//   example.test.myparam = value;
+//   // Get the parameter.
+//   value = example.test.myparam;
+//   // Call another function.
+//   example.test.increment();
+// </pre>
+///
+/*--cef(optional_param=handler)--*/
+bool CefRegisterExtension(const CefString& extension_name,
+                          const CefString& javascript_code,
+                          CefRefPtr<CefV8Handler> handler);
+
+
+///
+// Class representing a V8 context handle. V8 handles can only be accessed from
+// the thread on which they are created. Valid threads for creating a V8 handle
+// include the render process main thread (TID_RENDERER) and WebWorker threads.
+// A task runner for posting tasks on the associated thread can be retrieved via
+// the CefV8Context::GetTaskRunner() method.
+///
+/*--cef(source=library)--*/
+class CefV8Context : public virtual CefBase {
+ public:
+  ///
+  // Returns the current (top) context object in the V8 context stack.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefV8Context> GetCurrentContext();
+
+  ///
+  // Returns the entered (bottom) context object in the V8 context stack.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefV8Context> GetEnteredContext();
+
+  ///
+  // Returns true if V8 is currently inside a context.
+  ///
+  /*--cef()--*/
+  static bool InContext();
+
+  ///
+  // Returns the task runner associated with this context. V8 handles can only
+  // be accessed from the thread on which they are created. This method can be
+  // called on any render process thread.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefTaskRunner> GetTaskRunner() =0;
+
+  ///
+  // Returns true if the underlying handle is valid and it can be accessed on
+  // the current thread. Do not call any other methods if this method returns
+  // false.
+  ///
+  /*--cef()--*/
+  virtual bool IsValid() =0;
+
+  ///
+  // Returns the browser for this context. This method will return an empty
+  // reference for WebWorker contexts.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefBrowser> GetBrowser() =0;
+
+  ///
+  // Returns the frame for this context. This method will return an empty
+  // reference for WebWorker contexts.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefFrame> GetFrame() =0;
+
+  ///
+  // Returns the global object for this context. The context must be entered
+  // before calling this method.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefV8Value> GetGlobal() =0;
+
+  ///
+  // Enter this context. A context must be explicitly entered before creating a
+  // V8 Object, Array, Function or Date asynchronously. Exit() must be called
+  // the same number of times as Enter() before releasing this context. V8
+  // objects belong to the context in which they are created. Returns true if
+  // the scope was entered successfully.
+  ///
+  /*--cef()--*/
+  virtual bool Enter() =0;
+
+  ///
+  // Exit this context. Call this method only after calling Enter(). Returns
+  // true if the scope was exited successfully.
+  ///
+  /*--cef()--*/
+  virtual bool Exit() =0;
+
+  ///
+  // Returns true if this object is pointing to the same handle as |that|
+  // object.
+  ///
+  /*--cef()--*/
+  virtual bool IsSame(CefRefPtr<CefV8Context> that) =0;
+
+  ///
+  // Evaluates the specified JavaScript code using this context's global object.
+  // On success |retval| will be set to the return value, if any, and the
+  // function will return true. On failure |exception| will be set to the
+  // exception, if any, and the function will return false.
+  ///
+  /*--cef()--*/
+  virtual bool Eval(const CefString& code,
+                    CefRefPtr<CefV8Value>& retval,
+                    CefRefPtr<CefV8Exception>& exception) =0;
+};
+
+
+typedef std::vector<CefRefPtr<CefV8Value> > CefV8ValueList;
+
+///
+// Interface that should be implemented to handle V8 function calls. The methods
+// of this class will be called on the thread associated with the V8 function.
+///
+/*--cef(source=client)--*/
+class CefV8Handler : public virtual CefBase {
+ public:
+  ///
+  // Handle execution of the function identified by |name|. |object| is the
+  // receiver ('this' object) of the function. |arguments| is the list of
+  // arguments passed to the function. If execution succeeds set |retval| to the
+  // function return value. If execution fails set |exception| to the exception
+  // that will be thrown. Return true if execution was handled.
+  ///
+  /*--cef()--*/
+  virtual bool Execute(const CefString& name,
+                       CefRefPtr<CefV8Value> object,
+                       const CefV8ValueList& arguments,
+                       CefRefPtr<CefV8Value>& retval,
+                       CefString& exception) =0;
+};
+
+///
+// Interface that should be implemented to handle V8 accessor calls. Accessor
+// identifiers are registered by calling CefV8Value::SetValue(). The methods
+// of this class will be called on the thread associated with the V8 accessor.
+///
+/*--cef(source=client)--*/
+class CefV8Accessor : public virtual CefBase {
+ public:
+  ///
+  // Handle retrieval the accessor value identified by |name|. |object| is the
+  // receiver ('this' object) of the accessor. If retrieval succeeds set
+  // |retval| to the return value. If retrieval fails set |exception| to the
+  // exception that will be thrown. Return true if accessor retrieval was
+  // handled.
+  ///
+  /*--cef()--*/
+  virtual bool Get(const CefString& name,
+                   const CefRefPtr<CefV8Value> object,
+                   CefRefPtr<CefV8Value>& retval,
+                   CefString& exception) =0;
+
+  ///
+  // Handle assignment of the accessor value identified by |name|. |object| is
+  // the receiver ('this' object) of the accessor. |value| is the new value
+  // being assigned to the accessor. If assignment fails set |exception| to the
+  // exception that will be thrown. Return true if accessor assignment was
+  // handled.
+  ///
+  /*--cef()--*/
+  virtual bool Set(const CefString& name,
+                   const CefRefPtr<CefV8Value> object,
+                   const CefRefPtr<CefV8Value> value,
+                   CefString& exception) =0;
+};
+
+///
+// Class representing a V8 exception. The methods of this class may be called on
+// any render process thread.
+///
+/*--cef(source=library)--*/
+class CefV8Exception : public virtual CefBase {
+ public:
+  ///
+  // Returns the exception message.
+  ///
+  /*--cef()--*/
+  virtual CefString GetMessage() =0;
+
+  ///
+  // Returns the line of source code that the exception occurred within.
+  ///
+  /*--cef()--*/
+  virtual CefString GetSourceLine() =0;
+
+  ///
+  // Returns the resource name for the script from where the function causing
+  // the error originates.
+  ///
+  /*--cef()--*/
+  virtual CefString GetScriptResourceName() =0;
+
+  ///
+  // Returns the 1-based number of the line where the error occurred or 0 if the
+  // line number is unknown.
+  ///
+  /*--cef()--*/
+  virtual int GetLineNumber() =0;
+
+  ///
+  // Returns the index within the script of the first character where the error
+  // occurred.
+  ///
+  /*--cef()--*/
+  virtual int GetStartPosition() =0;
+
+  ///
+  // Returns the index within the script of the last character where the error
+  // occurred.
+  ///
+  /*--cef()--*/
+  virtual int GetEndPosition() =0;
+
+  ///
+  // Returns the index within the line of the first character where the error
+  // occurred.
+  ///
+  /*--cef()--*/
+  virtual int GetStartColumn() =0;
+
+  ///
+  // Returns the index within the line of the last character where the error
+  // occurred.
+  ///
+  /*--cef()--*/
+  virtual int GetEndColumn() =0;
+};
+
+///
+// Class representing a V8 value handle. V8 handles can only be accessed from
+// the thread on which they are created. Valid threads for creating a V8 handle
+// include the render process main thread (TID_RENDERER) and WebWorker threads.
+// A task runner for posting tasks on the associated thread can be retrieved via
+// the CefV8Context::GetTaskRunner() method.
+///
+/*--cef(source=library)--*/
+class CefV8Value : public virtual CefBase {
+ public:
+  typedef cef_v8_accesscontrol_t AccessControl;
+  typedef cef_v8_propertyattribute_t PropertyAttribute;
+
+  ///
+  // Create a new CefV8Value object of type undefined.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefV8Value> CreateUndefined();
+
+  ///
+  // Create a new CefV8Value object of type null.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefV8Value> CreateNull();
+
+  ///
+  // Create a new CefV8Value object of type bool.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefV8Value> CreateBool(bool value);
+
+  ///
+  // Create a new CefV8Value object of type int.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefV8Value> CreateInt(int32 value);
+
+  ///
+  // Create a new CefV8Value object of type unsigned int.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefV8Value> CreateUInt(uint32 value);
+
+  ///
+  // Create a new CefV8Value object of type double.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefV8Value> CreateDouble(double value);
+
+  ///
+  // Create a new CefV8Value object of type Date. This method should only be
+  // called from within the scope of a CefRenderProcessHandler, CefV8Handler or
+  // CefV8Accessor callback, or in combination with calling Enter() and Exit()
+  // on a stored CefV8Context reference.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefV8Value> CreateDate(const CefTime& date);
+
+  ///
+  // Create a new CefV8Value object of type string.
+  ///
+  /*--cef(optional_param=value)--*/
+  static CefRefPtr<CefV8Value> CreateString(const CefString& value);
+
+  ///
+  // Create a new CefV8Value object of type object with optional accessor. This
+  // method should only be called from within the scope of a
+  // CefRenderProcessHandler, CefV8Handler or CefV8Accessor callback, or in
+  // combination with calling Enter() and Exit() on a stored CefV8Context
+  // reference.
+  ///
+  /*--cef(optional_param=accessor)--*/
+  static CefRefPtr<CefV8Value> CreateObject(CefRefPtr<CefV8Accessor> accessor);
+
+  ///
+  // Create a new CefV8Value object of type array with the specified |length|.
+  // If |length| is negative the returned array will have length 0. This method
+  // should only be called from within the scope of a CefRenderProcessHandler,
+  // CefV8Handler or CefV8Accessor callback, or in combination with calling
+  // Enter() and Exit() on a stored CefV8Context reference.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefV8Value> CreateArray(int length);
+
+  ///
+  // Create a new CefV8Value object of type function. This method should only be
+  // called from within the scope of a CefRenderProcessHandler, CefV8Handler or
+  // CefV8Accessor callback, or in combination with calling Enter() and Exit()
+  // on a stored CefV8Context reference.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefV8Value> CreateFunction(const CefString& name,
+                                              CefRefPtr<CefV8Handler> handler);
+
+  ///
+  // Returns true if the underlying handle is valid and it can be accessed on
+  // the current thread. Do not call any other methods if this method returns
+  // false.
+  ///
+  /*--cef()--*/
+  virtual bool IsValid() =0;
+
+  ///
+  // True if the value type is undefined.
+  ///
+  /*--cef()--*/
+  virtual bool IsUndefined() =0;
+
+  ///
+  // True if the value type is null.
+  ///
+  /*--cef()--*/
+  virtual bool IsNull() =0;
+
+  ///
+  // True if the value type is bool.
+  ///
+  /*--cef()--*/
+  virtual bool IsBool() =0;
+
+  ///
+  // True if the value type is int.
+  ///
+  /*--cef()--*/
+  virtual bool IsInt() =0;
+
+  ///
+  // True if the value type is unsigned int.
+  ///
+  /*--cef()--*/
+  virtual bool IsUInt() =0;
+
+  ///
+  // True if the value type is double.
+  ///
+  /*--cef()--*/
+  virtual bool IsDouble() =0;
+
+  ///
+  // True if the value type is Date.
+  ///
+  /*--cef()--*/
+  virtual bool IsDate() =0;
+
+  ///
+  // True if the value type is string.
+  ///
+  /*--cef()--*/
+  virtual bool IsString() =0;
+
+  ///
+  // True if the value type is object.
+  ///
+  /*--cef()--*/
+  virtual bool IsObject() =0;
+
+  ///
+  // True if the value type is array.
+  ///
+  /*--cef()--*/
+  virtual bool IsArray() =0;
+
+  ///
+  // True if the value type is function.
+  ///
+  /*--cef()--*/
+  virtual bool IsFunction() =0;
+
+  ///
+  // Returns true if this object is pointing to the same handle as |that|
+  // object.
+  ///
+  /*--cef()--*/
+  virtual bool IsSame(CefRefPtr<CefV8Value> that) =0;
+
+  ///
+  // Return a bool value.  The underlying data will be converted to if
+  // necessary.
+  ///
+  /*--cef()--*/
+  virtual bool GetBoolValue() =0;
+
+  ///
+  // Return an int value.  The underlying data will be converted to if
+  // necessary.
+  ///
+  /*--cef()--*/
+  virtual int32 GetIntValue() =0;
+
+  ///
+  // Return an unisgned int value.  The underlying data will be converted to if
+  // necessary.
+  ///
+  /*--cef()--*/
+  virtual uint32 GetUIntValue() =0;
+
+  ///
+  // Return a double value.  The underlying data will be converted to if
+  // necessary.
+  ///
+  /*--cef()--*/
+  virtual double GetDoubleValue() =0;
+
+  ///
+  // Return a Date value.  The underlying data will be converted to if
+  // necessary.
+  ///
+  /*--cef()--*/
+  virtual CefTime GetDateValue() =0;
+
+  ///
+  // Return a string value.  The underlying data will be converted to if
+  // necessary.
+  ///
+  /*--cef()--*/
+  virtual CefString GetStringValue() =0;
+
+
+  // OBJECT METHODS - These methods are only available on objects. Arrays and
+  // functions are also objects. String- and integer-based keys can be used
+  // interchangably with the framework converting between them as necessary.
+
+  ///
+  // Returns true if this is a user created object.
+  ///
+  /*--cef()--*/
+  virtual bool IsUserCreated() =0;
+
+  ///
+  // Returns true if the last method call resulted in an exception. This
+  // attribute exists only in the scope of the current CEF value object.
+  ///
+  /*--cef()--*/
+  virtual bool HasException() =0;
+
+  ///
+  // Returns the exception resulting from the last method call. This attribute
+  // exists only in the scope of the current CEF value object.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefV8Exception> GetException() =0;
+
+  ///
+  // Clears the last exception and returns true on success.
+  ///
+  /*--cef()--*/
+  virtual bool ClearException() =0;
+
+  ///
+  // Returns true if this object will re-throw future exceptions. This attribute
+  // exists only in the scope of the current CEF value object.
+  ///
+  /*--cef()--*/
+  virtual bool WillRethrowExceptions() =0;
+
+  ///
+  // Set whether this object will re-throw future exceptions. By default
+  // exceptions are not re-thrown. If a exception is re-thrown the current
+  // context should not be accessed again until after the exception has been
+  // caught and not re-thrown. Returns true on success. This attribute exists
+  // only in the scope of the current CEF value object.
+  ///
+  /*--cef()--*/
+  virtual bool SetRethrowExceptions(bool rethrow) =0;
+
+  ///
+  // Returns true if the object has a value with the specified identifier.
+  ///
+  /*--cef(capi_name=has_value_bykey,optional_param=key)--*/
+  virtual bool HasValue(const CefString& key) =0;
+
+  ///
+  // Returns true if the object has a value with the specified identifier.
+  ///
+  /*--cef(capi_name=has_value_byindex,index_param=index)--*/
+  virtual bool HasValue(int index) =0;
+
+  ///
+  // Deletes the value with the specified identifier and returns true on
+  // success. Returns false if this method is called incorrectly or an exception
+  // is thrown. For read-only and don't-delete values this method will return
+  // true even though deletion failed.
+  ///
+  /*--cef(capi_name=delete_value_bykey,optional_param=key)--*/
+  virtual bool DeleteValue(const CefString& key) =0;
+
+  ///
+  // Deletes the value with the specified identifier and returns true on
+  // success. Returns false if this method is called incorrectly, deletion fails
+  // or an exception is thrown. For read-only and don't-delete values this
+  // method will return true even though deletion failed.
+  ///
+  /*--cef(capi_name=delete_value_byindex,index_param=index)--*/
+  virtual bool DeleteValue(int index) =0;
+
+  ///
+  // Returns the value with the specified identifier on success. Returns NULL
+  // if this method is called incorrectly or an exception is thrown.
+  ///
+  /*--cef(capi_name=get_value_bykey,optional_param=key)--*/
+  virtual CefRefPtr<CefV8Value> GetValue(const CefString& key) =0;
+
+  ///
+  // Returns the value with the specified identifier on success. Returns NULL
+  // if this method is called incorrectly or an exception is thrown.
+  ///
+  /*--cef(capi_name=get_value_byindex,index_param=index)--*/
+  virtual CefRefPtr<CefV8Value> GetValue(int index) =0;
+
+  ///
+  // Associates a value with the specified identifier and returns true on
+  // success. Returns false if this method is called incorrectly or an exception
+  // is thrown. For read-only values this method will return true even though
+  // assignment failed.
+  ///
+  /*--cef(capi_name=set_value_bykey,optional_param=key)--*/
+  virtual bool SetValue(const CefString& key, CefRefPtr<CefV8Value> value,
+                        PropertyAttribute attribute) =0;
+
+  ///
+  // Associates a value with the specified identifier and returns true on
+  // success. Returns false if this method is called incorrectly or an exception
+  // is thrown. For read-only values this method will return true even though
+  // assignment failed.
+  ///
+  /*--cef(capi_name=set_value_byindex,index_param=index)--*/
+  virtual bool SetValue(int index, CefRefPtr<CefV8Value> value) =0;
+
+  ///
+  // Registers an identifier and returns true on success. Access to the
+  // identifier will be forwarded to the CefV8Accessor instance passed to
+  // CefV8Value::CreateObject(). Returns false if this method is called
+  // incorrectly or an exception is thrown. For read-only values this method
+  // will return true even though assignment failed.
+  ///
+  /*--cef(capi_name=set_value_byaccessor,optional_param=key)--*/
+  virtual bool SetValue(const CefString& key, AccessControl settings,
+                        PropertyAttribute attribute) =0;
+
+  ///
+  // Read the keys for the object's values into the specified vector. Integer-
+  // based keys will also be returned as strings.
+  ///
+  /*--cef()--*/
+  virtual bool GetKeys(std::vector<CefString>& keys) =0;
+
+  ///
+  // Sets the user data for this object and returns true on success. Returns
+  // false if this method is called incorrectly. This method can only be called
+  // on user created objects.
+  ///
+  /*--cef(optional_param=user_data)--*/
+  virtual bool SetUserData(CefRefPtr<CefBase> user_data) =0;
+
+  ///
+  // Returns the user data, if any, assigned to this object.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefBase> GetUserData() =0;
+
+  ///
+  // Returns the amount of externally allocated memory registered for the
+  // object.
+  ///
+  /*--cef()--*/
+  virtual int GetExternallyAllocatedMemory() =0;
+
+  ///
+  // Adjusts the amount of registered external memory for the object. Used to
+  // give V8 an indication of the amount of externally allocated memory that is
+  // kept alive by JavaScript objects. V8 uses this information to decide when
+  // to perform global garbage collection. Each CefV8Value tracks the amount of
+  // external memory associated with it and automatically decreases the global
+  // total by the appropriate amount on its destruction. |change_in_bytes|
+  // specifies the number of bytes to adjust by. This method returns the number
+  // of bytes associated with the object after the adjustment. This method can
+  // only be called on user created objects.
+  ///
+  /*--cef()--*/
+  virtual int AdjustExternallyAllocatedMemory(int change_in_bytes) =0;
+
+
+  // ARRAY METHODS - These methods are only available on arrays.
+
+  ///
+  // Returns the number of elements in the array.
+  ///
+  /*--cef()--*/
+  virtual int GetArrayLength() =0;
+
+
+  // FUNCTION METHODS - These methods are only available on functions.
+
+  ///
+  // Returns the function name.
+  ///
+  /*--cef()--*/
+  virtual CefString GetFunctionName() =0;
+
+  ///
+  // Returns the function handler or NULL if not a CEF-created function.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefV8Handler> GetFunctionHandler() =0;
+
+  ///
+  // Execute the function using the current V8 context. This method should only
+  // be called from within the scope of a CefV8Handler or CefV8Accessor
+  // callback, or in combination with calling Enter() and Exit() on a stored
+  // CefV8Context reference. |object| is the receiver ('this' object) of the
+  // function. If |object| is empty the current context's global object will be
+  // used. |arguments| is the list of arguments that will be passed to the
+  // function. Returns the function return value on success. Returns NULL if
+  // this method is called incorrectly or an exception is thrown.
+  ///
+  /*--cef(optional_param=object)--*/
+  virtual CefRefPtr<CefV8Value> ExecuteFunction(
+      CefRefPtr<CefV8Value> object,
+      const CefV8ValueList& arguments) =0;
+
+  ///
+  // Execute the function using the specified V8 context. |object| is the
+  // receiver ('this' object) of the function. If |object| is empty the
+  // specified context's global object will be used. |arguments| is the list of
+  // arguments that will be passed to the function. Returns the function return
+  // value on success. Returns NULL if this method is called incorrectly or an
+  // exception is thrown.
+  ///
+  /*--cef(optional_param=object)--*/
+  virtual CefRefPtr<CefV8Value> ExecuteFunctionWithContext(
+      CefRefPtr<CefV8Context> context,
+      CefRefPtr<CefV8Value> object,
+      const CefV8ValueList& arguments) =0;
+};
+
+///
+// Class representing a V8 stack trace handle. V8 handles can only be accessed
+// from the thread on which they are created. Valid threads for creating a V8
+// handle include the render process main thread (TID_RENDERER) and WebWorker
+// threads. A task runner for posting tasks on the associated thread can be
+// retrieved via the CefV8Context::GetTaskRunner() method.
+///
+/*--cef(source=library)--*/
+class CefV8StackTrace : public virtual CefBase {
+ public:
+  ///
+  // Returns the stack trace for the currently active context. |frame_limit| is
+  // the maximum number of frames that will be captured.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefV8StackTrace> GetCurrent(int frame_limit);
+
+  ///
+  // Returns true if the underlying handle is valid and it can be accessed on
+  // the current thread. Do not call any other methods if this method returns
+  // false.
+  ///
+  /*--cef()--*/
+  virtual bool IsValid() =0;
+
+  ///
+  // Returns the number of stack frames.
+  ///
+  /*--cef()--*/
+  virtual int GetFrameCount() =0;
+
+  ///
+  // Returns the stack frame at the specified 0-based index.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefV8StackFrame> GetFrame(int index) =0;
+};
+
+///
+// Class representing a V8 stack frame handle. V8 handles can only be accessed
+// from the thread on which they are created. Valid threads for creating a V8
+// handle include the render process main thread (TID_RENDERER) and WebWorker
+// threads. A task runner for posting tasks on the associated thread can be
+// retrieved via the CefV8Context::GetTaskRunner() method.
+///
+/*--cef(source=library)--*/
+class CefV8StackFrame : public virtual CefBase {
+ public:
+  ///
+  // Returns true if the underlying handle is valid and it can be accessed on
+  // the current thread. Do not call any other methods if this method returns
+  // false.
+  ///
+  /*--cef()--*/
+  virtual bool IsValid() =0;
+
+  ///
+  // Returns the name of the resource script that contains the function.
+  ///
+  /*--cef()--*/
+  virtual CefString GetScriptName() =0;
+
+  ///
+  // Returns the name of the resource script that contains the function or the
+  // sourceURL value if the script name is undefined and its source ends with
+  // a "//@ sourceURL=..." string.
+  ///
+  /*--cef()--*/
+  virtual CefString GetScriptNameOrSourceURL() =0;
+
+  ///
+  // Returns the name of the function.
+  ///
+  /*--cef()--*/
+  virtual CefString GetFunctionName() =0;
+
+  ///
+  // Returns the 1-based line number for the function call or 0 if unknown.
+  ///
+  /*--cef()--*/
+  virtual int GetLineNumber() =0;
+
+  ///
+  // Returns the 1-based column offset on the line for the function call or 0 if
+  // unknown.
+  ///
+  /*--cef()--*/
+  virtual int GetColumn() =0;
+
+  ///
+  // Returns true if the function was compiled using eval().
+  ///
+  /*--cef()--*/
+  virtual bool IsEval() =0;
+
+  ///
+  // Returns true if the function was called as a constructor via "new".
+  ///
+  /*--cef()--*/
+  virtual bool IsConstructor() =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_V8_H_
diff --git a/src/include/libcef_/cef_values.h b/src/include/libcef_/cef_values.h
new file mode 100644
index 0000000..1c963d1
--- /dev/null
+++ b/src/include/libcef_/cef_values.h
@@ -0,0 +1,752 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_VALUES_H_
+#define CEF_INCLUDE_CEF_VALUES_H_
+#pragma once
+
+#include<vector>
+#include"libcef/cef_base.h"
+
+class CefBinaryValue;
+class CefDictionaryValue;
+class CefListValue;
+
+typedef cef_value_type_t CefValueType;
+
+///
+// Class that wraps other data value types. Complex types (binary, dictionary
+// and list) will be referenced but not owned by this object. Can be used on any
+// process and thread.
+///
+/*--cef(source=library)--*/
+class CefValue : public virtual CefBase {
+ public:
+  ///
+  // Creates a new object.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefValue> Create();
+
+  ///
+  // Returns true if the underlying data is valid. This will always be true for
+  // simple types. For complex types (binary, dictionary and list) the
+  // underlying data may become invalid if owned by another object (e.g. list or
+  // dictionary) and that other object is then modified or destroyed. This value
+  // object can be re-used by calling Set*() even if the underlying data is
+  // invalid.
+  ///
+  /*--cef()--*/
+  virtual bool IsValid() =0;
+
+  ///
+  // Returns true if the underlying data is owned by another object.
+  ///
+  /*--cef()--*/
+  virtual bool IsOwned() =0;
+
+  ///
+  // Returns true if the underlying data is read-only. Some APIs may expose
+  // read-only objects.
+  ///
+  /*--cef()--*/
+  virtual bool IsReadOnly() =0;
+
+  ///
+  // Returns true if this object and |that| object have the same underlying
+  // data. If true modifications to this object will also affect |that| object
+  // and vice-versa.
+  ///
+  /*--cef()--*/
+  virtual bool IsSame(CefRefPtr<CefValue> that) =0;
+
+  ///
+  // Returns true if this object and |that| object have an equivalent underlying
+  // value but are not necessarily the same object.
+  ///
+  /*--cef()--*/
+  virtual bool IsEqual(CefRefPtr<CefValue> that) =0;
+
+  ///
+  // Returns a copy of this object. The underlying data will also be copied.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefValue> Copy() =0;
+
+  ///
+  // Returns the underlying value type.
+  ///
+  /*--cef(default_retval=VTYPE_INVALID)--*/
+  virtual CefValueType GetType() =0;
+
+  ///
+  // Returns the underlying value as type bool.
+  ///
+  /*--cef()--*/
+  virtual bool GetBool() =0;
+
+  ///
+  // Returns the underlying value as type int.
+  ///
+  /*--cef()--*/
+  virtual int GetInt() =0;
+
+  ///
+  // Returns the underlying value as type double.
+  ///
+  /*--cef()--*/
+  virtual double GetDouble() =0;
+
+  ///
+  // Returns the underlying value as type string.
+  ///
+  /*--cef()--*/
+  virtual CefString GetString() =0;
+
+  ///
+  // Returns the underlying value as type binary. The returned reference may
+  // become invalid if the value is owned by another object or if ownership is
+  // transferred to another object in the future. To maintain a reference to
+  // the value after assigning ownership to a dictionary or list pass this
+  // object to the SetValue() method instead of passing the returned reference
+  // to SetBinary().
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefBinaryValue> GetBinary() =0;
+
+  ///
+  // Returns the underlying value as type dictionary. The returned reference may
+  // become invalid if the value is owned by another object or if ownership is
+  // transferred to another object in the future. To maintain a reference to
+  // the value after assigning ownership to a dictionary or list pass this
+  // object to the SetValue() method instead of passing the returned reference
+  // to SetDictionary().
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefDictionaryValue> GetDictionary() =0;
+
+  ///
+  // Returns the underlying value as type list. The returned reference may
+  // become invalid if the value is owned by another object or if ownership is
+  // transferred to another object in the future. To maintain a reference to
+  // the value after assigning ownership to a dictionary or list pass this
+  // object to the SetValue() method instead of passing the returned reference
+  // to SetList().
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefListValue> GetList() =0;
+
+  ///
+  // Sets the underlying value as type null. Returns true if the value was set
+  // successfully.
+  ///
+  /*--cef()--*/
+  virtual bool SetNull() =0;
+
+  ///
+  // Sets the underlying value as type bool. Returns true if the value was set
+  // successfully.
+  ///
+  /*--cef()--*/
+  virtual bool SetBool(bool value) =0;
+
+  ///
+  // Sets the underlying value as type int. Returns true if the value was set
+  // successfully.
+  ///
+  /*--cef()--*/
+  virtual bool SetInt(int value) =0;
+
+  ///
+  // Sets the underlying value as type double. Returns true if the value was set
+  // successfully.
+  ///
+  /*--cef()--*/
+  virtual bool SetDouble(double value) =0;
+
+  ///
+  // Sets the underlying value as type string. Returns true if the value was set
+  // successfully.
+  ///
+  /*--cef(optional_param=value)--*/
+  virtual bool SetString(const CefString& value) =0;
+
+  ///
+  // Sets the underlying value as type binary. Returns true if the value was set
+  // successfully. This object keeps a reference to |value| and ownership of the
+  // underlying data remains unchanged.
+  ///
+  /*--cef()--*/
+  virtual bool SetBinary(CefRefPtr<CefBinaryValue> value) =0;
+
+  ///
+  // Sets the underlying value as type dict. Returns true if the value was set
+  // successfully. This object keeps a reference to |value| and ownership of the
+  // underlying data remains unchanged.
+  ///
+  /*--cef()--*/
+  virtual bool SetDictionary(CefRefPtr<CefDictionaryValue> value) =0;
+
+  ///
+  // Sets the underlying value as type list. Returns true if the value was set
+  // successfully. This object keeps a reference to |value| and ownership of the
+  // underlying data remains unchanged.
+  ///
+  /*--cef()--*/
+  virtual bool SetList(CefRefPtr<CefListValue> value) =0;
+};
+
+
+///
+// Class representing a binary value. Can be used on any process and thread.
+///
+/*--cef(source=library)--*/
+class CefBinaryValue : public virtual CefBase {
+ public:
+  ///
+  // Creates a new object that is not owned by any other object. The specified
+  // |data| will be copied.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefBinaryValue> Create(const void* data,
+                                          size_t data_size);
+
+  ///
+  // Returns true if this object is valid. This object may become invalid if
+  // the underlying data is owned by another object (e.g. list or dictionary)
+  // and that other object is then modified or destroyed. Do not call any other
+  // methods if this method returns false.
+  ///
+  /*--cef()--*/
+  virtual bool IsValid() =0;
+
+  ///
+  // Returns true if this object is currently owned by another object.
+  ///
+  /*--cef()--*/
+  virtual bool IsOwned() =0;
+
+  ///
+  // Returns true if this object and |that| object have the same underlying
+  // data.
+  ///
+  /*--cef()--*/
+  virtual bool IsSame(CefRefPtr<CefBinaryValue> that) =0;
+
+  ///
+  // Returns true if this object and |that| object have an equivalent underlying
+  // value but are not necessarily the same object.
+  ///
+  /*--cef()--*/
+  virtual bool IsEqual(CefRefPtr<CefBinaryValue> that) =0;
+
+  ///
+  // Returns a copy of this object. The data in this object will also be copied.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefBinaryValue> Copy() =0;
+
+  ///
+  // Returns the data size.
+  ///
+  /*--cef()--*/
+  virtual size_t GetSize() =0;
+
+  ///
+  // Read up to |buffer_size| number of bytes into |buffer|. Reading begins at
+  // the specified byte |data_offset|. Returns the number of bytes read.
+  ///
+  /*--cef()--*/
+  virtual size_t GetData(void* buffer,
+                         size_t buffer_size,
+                         size_t data_offset) =0;
+};
+
+
+///
+// Class representing a dictionary value. Can be used on any process and thread.
+///
+/*--cef(source=library)--*/
+class CefDictionaryValue : public virtual CefBase {
+ public:
+  typedef std::vector<CefString> KeyList;
+
+  ///
+  // Creates a new object that is not owned by any other object.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefDictionaryValue> Create();
+
+  ///
+  // Returns true if this object is valid. This object may become invalid if
+  // the underlying data is owned by another object (e.g. list or dictionary)
+  // and that other object is then modified or destroyed. Do not call any other
+  // methods if this method returns false.
+  ///
+  /*--cef()--*/
+  virtual bool IsValid() =0;
+
+  ///
+  // Returns true if this object is currently owned by another object.
+  ///
+  /*--cef()--*/
+  virtual bool IsOwned() =0;
+
+  ///
+  // Returns true if the values of this object are read-only. Some APIs may
+  // expose read-only objects.
+  ///
+  /*--cef()--*/
+  virtual bool IsReadOnly() =0;
+
+  ///
+  // Returns true if this object and |that| object have the same underlying
+  // data. If true modifications to this object will also affect |that| object
+  // and vice-versa.
+  ///
+  /*--cef()--*/
+  virtual bool IsSame(CefRefPtr<CefDictionaryValue> that) =0;
+
+  ///
+  // Returns true if this object and |that| object have an equivalent underlying
+  // value but are not necessarily the same object.
+  ///
+  /*--cef()--*/
+  virtual bool IsEqual(CefRefPtr<CefDictionaryValue> that) =0;
+
+  ///
+  // Returns a writable copy of this object. If |exclude_empty_children| is true
+  // any empty dictionaries or lists will be excluded from the copy.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefDictionaryValue> Copy(bool exclude_empty_children) =0;
+
+  ///
+  // Returns the number of values.
+  ///
+  /*--cef()--*/
+  virtual size_t GetSize() =0;
+
+  ///
+  // Removes all values. Returns true on success.
+  ///
+  /*--cef()--*/
+  virtual bool Clear() =0;
+
+  ///
+  // Returns true if the current dictionary has a value for the given key.
+  ///
+  /*--cef()--*/
+  virtual bool HasKey(const CefString& key) =0;
+
+  ///
+  // Reads all keys for this dictionary into the specified vector.
+  ///
+  /*--cef()--*/
+  virtual bool GetKeys(KeyList& keys) =0;
+
+  ///
+  // Removes the value at the specified key. Returns true is the value was
+  // removed successfully.
+  ///
+  /*--cef()--*/
+  virtual bool Remove(const CefString& key) =0;
+
+  ///
+  // Returns the value type for the specified key.
+  ///
+  /*--cef(default_retval=VTYPE_INVALID)--*/
+  virtual CefValueType GetType(const CefString& key) =0;
+
+  ///
+  // Returns the value at the specified key. For simple types the returned
+  // value will copy existing data and modifications to the value will not
+  // modify this object. For complex types (binary, dictionary and list) the
+  // returned value will reference existing data and modifications to the value
+  // will modify this object.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefValue> GetValue(const CefString& key) =0;
+
+  ///
+  // Returns the value at the specified key as type bool.
+  ///
+  /*--cef()--*/
+  virtual bool GetBool(const CefString& key) =0;
+
+  ///
+  // Returns the value at the specified key as type int.
+  ///
+  /*--cef()--*/
+  virtual int GetInt(const CefString& key) =0;
+
+  ///
+  // Returns the value at the specified key as type double.
+  ///
+  /*--cef()--*/
+  virtual double GetDouble(const CefString& key) =0;
+
+  ///
+  // Returns the value at the specified key as type string.
+  ///
+  /*--cef()--*/
+  virtual CefString GetString(const CefString& key) =0;
+
+  ///
+  // Returns the value at the specified key as type binary. The returned
+  // value will reference existing data.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefBinaryValue> GetBinary(const CefString& key) =0;
+
+  ///
+  // Returns the value at the specified key as type dictionary. The returned
+  // value will reference existing data and modifications to the value will
+  // modify this object.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefDictionaryValue> GetDictionary(const CefString& key) =0;
+
+  ///
+  // Returns the value at the specified key as type list. The returned value
+  // will reference existing data and modifications to the value will modify
+  // this object.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefListValue> GetList(const CefString& key) =0;
+
+  ///
+  // Sets the value at the specified key. Returns true if the value was set
+  // successfully. If |value| represents simple data then the underlying data
+  // will be copied and modifications to |value| will not modify this object. If
+  // |value| represents complex data (binary, dictionary or list) then the
+  // underlying data will be referenced and modifications to |value| will modify
+  // this object.
+  ///
+  /*--cef()--*/
+  virtual bool SetValue(const CefString& key, CefRefPtr<CefValue> value) =0;
+
+  ///
+  // Sets the value at the specified key as type null. Returns true if the
+  // value was set successfully.
+  ///
+  /*--cef()--*/
+  virtual bool SetNull(const CefString& key) =0;
+
+  ///
+  // Sets the value at the specified key as type bool. Returns true if the
+  // value was set successfully.
+  ///
+  /*--cef()--*/
+  virtual bool SetBool(const CefString& key, bool value) =0;
+
+  ///
+  // Sets the value at the specified key as type int. Returns true if the
+  // value was set successfully.
+  ///
+  /*--cef()--*/
+  virtual bool SetInt(const CefString& key, int value) =0;
+
+  ///
+  // Sets the value at the specified key as type double. Returns true if the
+  // value was set successfully.
+  ///
+  /*--cef()--*/
+  virtual bool SetDouble(const CefString& key, double value) =0;
+
+  ///
+  // Sets the value at the specified key as type string. Returns true if the
+  // value was set successfully.
+  ///
+  /*--cef(optional_param=value)--*/
+  virtual bool SetString(const CefString& key, const CefString& value) =0;
+
+  ///
+  // Sets the value at the specified key as type binary. Returns true if the
+  // value was set successfully. If |value| is currently owned by another object
+  // then the value will be copied and the |value| reference will not change.
+  // Otherwise, ownership will be transferred to this object and the |value|
+  // reference will be invalidated.
+  ///
+  /*--cef()--*/
+  virtual bool SetBinary(const CefString& key,
+                         CefRefPtr<CefBinaryValue> value) =0;
+
+  ///
+  // Sets the value at the specified key as type dict. Returns true if the
+  // value was set successfully. If |value| is currently owned by another object
+  // then the value will be copied and the |value| reference will not change.
+  // Otherwise, ownership will be transferred to this object and the |value|
+  // reference will be invalidated.
+  ///
+  /*--cef()--*/
+  virtual bool SetDictionary(const CefString& key,
+                             CefRefPtr<CefDictionaryValue> value) =0;
+
+  ///
+  // Sets the value at the specified key as type list. Returns true if the
+  // value was set successfully. If |value| is currently owned by another object
+  // then the value will be copied and the |value| reference will not change.
+  // Otherwise, ownership will be transferred to this object and the |value|
+  // reference will be invalidated.
+  ///
+  /*--cef()--*/
+  virtual bool SetList(const CefString& key,
+                       CefRefPtr<CefListValue> value) =0;
+};
+
+
+///
+// Class representing a list value. Can be used on any process and thread.
+///
+/*--cef(source=library)--*/
+class CefListValue : public virtual CefBase {
+ public:
+  ///
+  // Creates a new object that is not owned by any other object.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefListValue> Create();
+
+  ///
+  // Returns true if this object is valid. This object may become invalid if
+  // the underlying data is owned by another object (e.g. list or dictionary)
+  // and that other object is then modified or destroyed. Do not call any other
+  // methods if this method returns false.
+  ///
+  /*--cef()--*/
+  virtual bool IsValid() =0;
+
+  ///
+  // Returns true if this object is currently owned by another object.
+  ///
+  /*--cef()--*/
+  virtual bool IsOwned() =0;
+
+  ///
+  // Returns true if the values of this object are read-only. Some APIs may
+  // expose read-only objects.
+  ///
+  /*--cef()--*/
+  virtual bool IsReadOnly() =0;
+
+  ///
+  // Returns true if this object and |that| object have the same underlying
+  // data. If true modifications to this object will also affect |that| object
+  // and vice-versa.
+  ///
+  /*--cef()--*/
+  virtual bool IsSame(CefRefPtr<CefListValue> that) =0;
+
+  ///
+  // Returns true if this object and |that| object have an equivalent underlying
+  // value but are not necessarily the same object.
+  ///
+  /*--cef()--*/
+  virtual bool IsEqual(CefRefPtr<CefListValue> that) =0;
+
+  ///
+  // Returns a writable copy of this object.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefListValue> Copy() =0;
+
+  ///
+  // Sets the number of values. If the number of values is expanded all
+  // new value slots will default to type null. Returns true on success.
+  ///
+  /*--cef()--*/
+  virtual bool SetSize(size_t size) =0;
+
+  ///
+  // Returns the number of values.
+  ///
+  /*--cef()--*/
+  virtual size_t GetSize() =0;
+
+  ///
+  // Removes all values. Returns true on success.
+  ///
+  /*--cef()--*/
+  virtual bool Clear() =0;
+
+  ///
+  // Removes the value at the specified index.
+  ///
+  /*--cef(index_param=index)--*/
+  virtual bool Remove(int index) =0;
+
+  ///
+  // Returns the value type at the specified index.
+  ///
+  /*--cef(default_retval=VTYPE_INVALID,index_param=index)--*/
+  virtual CefValueType GetType(int index) =0;
+
+  ///
+  // Returns the value at the specified index. For simple types the returned
+  // value will copy existing data and modifications to the value will not
+  // modify this object. For complex types (binary, dictionary and list) the
+  // returned value will reference existing data and modifications to the value
+  // will modify this object.
+  ///
+  /*--cef(index_param=index)--*/
+  virtual CefRefPtr<CefValue> GetValue(int index) =0;
+
+  ///
+  // Returns the value at the specified index as type bool.
+  ///
+  /*--cef(index_param=index)--*/
+  virtual bool GetBool(int index) =0;
+
+  ///
+  // Returns the value at the specified index as type int.
+  ///
+  /*--cef(index_param=index)--*/
+  virtual int GetInt(int index) =0;
+
+  ///
+  // Returns the value at the specified index as type double.
+  ///
+  /*--cef(index_param=index)--*/
+  virtual double GetDouble(int index) =0;
+
+  ///
+  // Returns the value at the specified index as type string.
+  ///
+  /*--cef(index_param=index)--*/
+  virtual CefString GetString(int index) =0;
+
+  ///
+  // Returns the value at the specified index as type binary. The returned
+  // value will reference existing data.
+  ///
+  /*--cef(index_param=index)--*/
+  virtual CefRefPtr<CefBinaryValue> GetBinary(int index) =0;
+
+  ///
+  // Returns the value at the specified index as type dictionary. The returned
+  // value will reference existing data and modifications to the value will
+  // modify this object.
+  ///
+  /*--cef(index_param=index)--*/
+  virtual CefRefPtr<CefDictionaryValue> GetDictionary(int index) =0;
+
+  ///
+  // Returns the value at the specified index as type list. The returned
+  // value will reference existing data and modifications to the value will
+  // modify this object.
+  ///
+  /*--cef(index_param=index)--*/
+  virtual CefRefPtr<CefListValue> GetList(int index) =0;
+
+  ///
+  // Sets the value at the specified index. Returns true if the value was set
+  // successfully. If |value| represents simple data then the underlying data
+  // will be copied and modifications to |value| will not modify this object. If
+  // |value| represents complex data (binary, dictionary or list) then the
+  // underlying data will be referenced and modifications to |value| will modify
+  // this object.
+  ///
+  /*--cef(index_param=index)--*/
+  virtual bool SetValue(int index, CefRefPtr<CefValue> value) =0;
+
+  ///
+  // Sets the value at the specified index as type null. Returns true if the
+  // value was set successfully.
+  ///
+  /*--cef(index_param=index)--*/
+  virtual bool SetNull(int index) =0;
+
+  ///
+  // Sets the value at the specified index as type bool. Returns true if the
+  // value was set successfully.
+  ///
+  /*--cef(index_param=index)--*/
+  virtual bool SetBool(int index, bool value) =0;
+
+  ///
+  // Sets the value at the specified index as type int. Returns true if the
+  // value was set successfully.
+  ///
+  /*--cef(index_param=index)--*/
+  virtual bool SetInt(int index, int value) =0;
+
+  ///
+  // Sets the value at the specified index as type double. Returns true if the
+  // value was set successfully.
+  ///
+  /*--cef(index_param=index)--*/
+  virtual bool SetDouble(int index, double value) =0;
+
+  ///
+  // Sets the value at the specified index as type string. Returns true if the
+  // value was set successfully.
+  ///
+  /*--cef(optional_param=value,index_param=index)--*/
+  virtual bool SetString(int index, const CefString& value) =0;
+
+  ///
+  // Sets the value at the specified index as type binary. Returns true if the
+  // value was set successfully. If |value| is currently owned by another object
+  // then the value will be copied and the |value| reference will not change.
+  // Otherwise, ownership will be transferred to this object and the |value|
+  // reference will be invalidated.
+  ///
+  /*--cef(index_param=index)--*/
+  virtual bool SetBinary(int index, CefRefPtr<CefBinaryValue> value) =0;
+
+  ///
+  // Sets the value at the specified index as type dict. Returns true if the
+  // value was set successfully. If |value| is currently owned by another object
+  // then the value will be copied and the |value| reference will not change.
+  // Otherwise, ownership will be transferred to this object and the |value|
+  // reference will be invalidated.
+  ///
+  /*--cef(index_param=index)--*/
+  virtual bool SetDictionary(int index, CefRefPtr<CefDictionaryValue> value) =0;
+
+  ///
+  // Sets the value at the specified index as type list. Returns true if the
+  // value was set successfully. If |value| is currently owned by another object
+  // then the value will be copied and the |value| reference will not change.
+  // Otherwise, ownership will be transferred to this object and the |value|
+  // reference will be invalidated.
+  ///
+  /*--cef(index_param=index)--*/
+  virtual bool SetList(int index, CefRefPtr<CefListValue> value) =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_VALUES_H_
diff --git a/src/include/libcef_/cef_version.h b/src/include/libcef_/cef_version.h
new file mode 100644
index 0000000..3f1d828
--- /dev/null
+++ b/src/include/libcef_/cef_version.h
@@ -0,0 +1,102 @@
+// Copyright (c) 2018 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file is generated by the make_version_header.py tool.
+//
+
+#ifndef CEF_INCLUDE_CEF_VERSION_H_
+#define CEF_INCLUDE_CEF_VERSION_H_
+
+#define CEF_VERSION "3.2623.1401.gb90a3be"
+#define CEF_VERSION_MAJOR 3
+#define CEF_COMMIT_NUMBER 1401
+#define CEF_COMMIT_HASH "b90a3be1860b0647e8a62c218ff7c054390365b1"
+#define COPYRIGHT_YEAR 2018
+
+#define CHROME_VERSION_MAJOR 49
+#define CHROME_VERSION_MINOR 0
+#define CHROME_VERSION_BUILD 2623
+#define CHROME_VERSION_PATCH 110
+
+#define DO_MAKE_STRING(p) #p
+#define MAKE_STRING(p) DO_MAKE_STRING(p)
+
+#ifndef APSTUDIO_HIDDEN_SYMBOLS
+
+#include"libcef/internal/cef_export.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// The API hash is created by analyzing CEF header files for C API type
+// definitions. The hash value will change when header files are modified
+// in a way that may cause binary incompatibility with other builds. The
+// universal hash value will change if any platform is affected whereas the
+// platform hash values will change only if that particular platform is
+// affected.
+#define CEF_API_HASH_UNIVERSAL "32c1d3523da124f2dea7b80b92c53c4d4a463c65"
+#if defined(OS_WIN)
+	#define CEF_API_HASH_PLATFORM "64b27477b82b44b51ce817522f744fca6768cbbb"
+#elif defined(OS_MACOSX)
+	#define CEF_API_HASH_PLATFORM "e3b9c36454ae5ae4fb3509e17fb6a7d2877c847d"
+#elif defined(OS_LINUX)
+	#define CEF_API_HASH_PLATFORM "87a195efc055fb9f39c84f5ce8199cc8766290e3"
+#endif
+
+// Returns CEF version information for the libcef library. The |entry|
+// parameter describes which version component will be returned:
+// 0 - CEF_VERSION_MAJOR
+// 1 - CEF_COMMIT_NUMBER
+// 2 - CHROME_VERSION_MAJOR
+// 3 - CHROME_VERSION_MINOR
+// 4 - CHROME_VERSION_BUILD
+// 5 - CHROME_VERSION_PATCH
+///
+CEF_EXPORT int cef_version_info(int entry);
+
+///
+// Returns CEF API hashes for the libcef library. The returned string is owned
+// by the library and should not be freed. The |entry| parameter describes which
+// hash value will be returned:
+// 0 - CEF_API_HASH_PLATFORM
+// 1 - CEF_API_HASH_UNIVERSAL
+// 2 - CEF_COMMIT_HASH
+///
+CEF_EXPORT const char* cef_api_hash(int entry);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // APSTUDIO_HIDDEN_SYMBOLS
+
+#endif  // CEF_INCLUDE_CEF_VERSION_H_
diff --git a/src/include/libcef_/cef_web_plugin.h b/src/include/libcef_/cef_web_plugin.h
new file mode 100644
index 0000000..545ef7b
--- /dev/null
+++ b/src/include/libcef_/cef_web_plugin.h
@@ -0,0 +1,179 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_WEB_PLUGIN_H_
+#define CEF_INCLUDE_CEF_WEB_PLUGIN_H_
+
+#include"libcef/cef_base.h"
+
+class CefBrowser;
+
+///
+// Information about a specific web plugin.
+///
+/*--cef(source=library)--*/
+class CefWebPluginInfo : public virtual CefBase {
+ public:
+  ///
+  // Returns the plugin name (i.e. Flash).
+  ///
+  /*--cef()--*/
+  virtual CefString GetName() =0;
+
+  ///
+  // Returns the plugin file path (DLL/bundle/library).
+  ///
+  /*--cef()--*/
+  virtual CefString GetPath() =0;
+
+  ///
+  // Returns the version of the plugin (may be OS-specific).
+  ///
+  /*--cef()--*/
+  virtual CefString GetVersion() =0;
+
+  ///
+  // Returns a description of the plugin from the version information.
+  ///
+  /*--cef()--*/
+  virtual CefString GetDescription() =0;
+};
+
+///
+// Interface to implement for visiting web plugin information. The methods of
+// this class will be called on the browser process UI thread.
+///
+/*--cef(source=client)--*/
+class CefWebPluginInfoVisitor : public virtual CefBase {
+ public:
+  ///
+  // Method that will be called once for each plugin. |count| is the 0-based
+  // index for the current plugin. |total| is the total number of plugins.
+  // Return false to stop visiting plugins. This method may never be called if
+  // no plugins are found.
+  ///
+  /*--cef()--*/
+  virtual bool Visit(CefRefPtr<CefWebPluginInfo> info, int count, int total) =0;
+};
+
+///
+// Visit web plugin information. Can be called on any thread in the browser
+// process.
+///
+/*--cef()--*/
+void CefVisitWebPluginInfo(CefRefPtr<CefWebPluginInfoVisitor> visitor);
+
+///
+// Cause the plugin list to refresh the next time it is accessed regardless
+// of whether it has already been loaded. Can be called on any thread in the
+// browser process.
+///
+/*--cef()--*/
+void CefRefreshWebPlugins();
+
+///
+// Add a plugin path (directory + file). This change may not take affect until
+// after CefRefreshWebPlugins() is called. Can be called on any thread in the
+// browser process.
+///
+/*--cef()--*/
+void CefAddWebPluginPath(const CefString& path);
+
+///
+// Add a plugin directory. This change may not take affect until after
+// CefRefreshWebPlugins() is called. Can be called on any thread in the browser
+// process.
+///
+/*--cef()--*/
+void CefAddWebPluginDirectory(const CefString& dir);
+
+///
+// Remove a plugin path (directory + file). This change may not take affect
+// until after CefRefreshWebPlugins() is called. Can be called on any thread in
+// the browser process.
+///
+/*--cef()--*/
+void CefRemoveWebPluginPath(const CefString& path);
+
+///
+// Unregister an internal plugin. This may be undone the next time
+// CefRefreshWebPlugins() is called. Can be called on any thread in the browser
+// process.
+///
+/*--cef()--*/
+void CefUnregisterInternalWebPlugin(const CefString& path);
+
+///
+// Force a plugin to shutdown. Can be called on any thread in the browser
+// process but will be executed on the IO thread.
+///
+/*--cef()--*/
+void CefForceWebPluginShutdown(const CefString& path);
+
+///
+// Register a plugin crash. Can be called on any thread in the browser process
+// but will be executed on the IO thread.
+///
+/*--cef()--*/
+void CefRegisterWebPluginCrash(const CefString& path);
+
+///
+// Interface to implement for receiving unstable plugin information. The methods
+// of this class will be called on the browser process IO thread.
+///
+/*--cef(source=client)--*/
+class CefWebPluginUnstableCallback : public virtual CefBase {
+ public:
+  ///
+  // Method that will be called for the requested plugin. |unstable| will be
+  // true if the plugin has reached the crash count threshold of 3 times in 120
+  // seconds.
+  ///
+  /*--cef()--*/
+  virtual void IsUnstable(const CefString& path,
+                          bool unstable) =0;
+};
+
+///
+// Query if a plugin is unstable. Can be called on any thread in the browser
+// process.
+///
+/*--cef()--*/
+void CefIsWebPluginUnstable(const CefString& path,
+                            CefRefPtr<CefWebPluginUnstableCallback> callback);
+
+
+#endif  // CEF_INCLUDE_CEF_WEB_PLUGIN_H_
diff --git a/src/include/libcef_/cef_xml_reader.h b/src/include/libcef_/cef_xml_reader.h
new file mode 100644
index 0000000..d379f95
--- /dev/null
+++ b/src/include/libcef_/cef_xml_reader.h
@@ -0,0 +1,268 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_XML_READER_H_
+#define CEF_INCLUDE_CEF_XML_READER_H_
+#pragma once
+
+#include"libcef/cef_base.h"
+#include"libcef/cef_stream.h"
+
+///
+// Class that supports the reading of XML data via the libxml streaming API.
+// The methods of this class should only be called on the thread that creates
+// the object.
+///
+/*--cef(source=library)--*/
+class CefXmlReader : public virtual CefBase {
+ public:
+  typedef cef_xml_encoding_type_t EncodingType;
+  typedef cef_xml_node_type_t NodeType;
+
+  ///
+  // Create a new CefXmlReader object. The returned object's methods can only
+  // be called from the thread that created the object.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefXmlReader> Create(CefRefPtr<CefStreamReader> stream,
+                                        EncodingType encodingType,
+                                        const CefString& URI);
+
+  ///
+  // Moves the cursor to the next node in the document. This method must be
+  // called at least once to set the current cursor position. Returns true if
+  // the cursor position was set successfully.
+  ///
+  /*--cef()--*/
+  virtual bool MoveToNextNode() =0;
+
+  ///
+  // Close the document. This should be called directly to ensure that cleanup
+  // occurs on the correct thread.
+  ///
+  /*--cef()--*/
+  virtual bool Close() =0;
+
+  ///
+  // Returns true if an error has been reported by the XML parser.
+  ///
+  /*--cef()--*/
+  virtual bool HasError() =0;
+
+  ///
+  // Returns the error string.
+  ///
+  /*--cef()--*/
+  virtual CefString GetError() =0;
+
+
+  // The below methods retrieve data for the node at the current cursor
+  // position.
+
+  ///
+  // Returns the node type.
+  ///
+  /*--cef(default_retval=XML_NODE_UNSUPPORTED)--*/
+  virtual NodeType GetType() =0;
+
+  ///
+  // Returns the node depth. Depth starts at 0 for the root node.
+  ///
+  /*--cef()--*/
+  virtual int GetDepth() =0;
+
+  ///
+  // Returns the local name. See
+  // http://www.w3.org/TR/REC-xml-names/#NT-LocalPart for additional details.
+  ///
+  /*--cef()--*/
+  virtual CefString GetLocalName() =0;
+
+  ///
+  // Returns the namespace prefix. See http://www.w3.org/TR/REC-xml-names/ for
+  // additional details.
+  ///
+  /*--cef()--*/
+  virtual CefString GetPrefix() =0;
+
+  ///
+  // Returns the qualified name, equal to (Prefix:)LocalName. See
+  // http://www.w3.org/TR/REC-xml-names/#ns-qualnames for additional details.
+  ///
+  /*--cef()--*/
+  virtual CefString GetQualifiedName() =0;
+
+  ///
+  // Returns the URI defining the namespace associated with the node. See
+  // http://www.w3.org/TR/REC-xml-names/ for additional details.
+  ///
+  /*--cef()--*/
+  virtual CefString GetNamespaceURI() =0;
+
+  ///
+  // Returns the base URI of the node. See http://www.w3.org/TR/xmlbase/ for
+  // additional details.
+  ///
+  /*--cef()--*/
+  virtual CefString GetBaseURI() =0;
+
+  ///
+  // Returns the xml:lang scope within which the node resides. See
+  // http://www.w3.org/TR/REC-xml/#sec-lang-tag for additional details.
+  ///
+  /*--cef()--*/
+  virtual CefString GetXmlLang() =0;
+
+  ///
+  // Returns true if the node represents an empty element. <a/> is considered
+  // empty but <a></a> is not.
+  ///
+  /*--cef()--*/
+  virtual bool IsEmptyElement() =0;
+
+  ///
+  // Returns true if the node has a text value.
+  ///
+  /*--cef()--*/
+  virtual bool HasValue() =0;
+
+  ///
+  // Returns the text value.
+  ///
+  /*--cef()--*/
+  virtual CefString GetValue() =0;
+
+  ///
+  // Returns true if the node has attributes.
+  ///
+  /*--cef()--*/
+  virtual bool HasAttributes() =0;
+
+  ///
+  // Returns the number of attributes.
+  ///
+  /*--cef()--*/
+  virtual size_t GetAttributeCount() =0;
+
+  ///
+  // Returns the value of the attribute at the specified 0-based index.
+  ///
+  /*--cef(capi_name=get_attribute_byindex,index_param=index)--*/
+  virtual CefString GetAttribute(int index) =0;
+
+  ///
+  // Returns the value of the attribute with the specified qualified name.
+  ///
+  /*--cef(capi_name=get_attribute_byqname)--*/
+  virtual CefString GetAttribute(const CefString& qualifiedName) =0;
+
+  ///
+  // Returns the value of the attribute with the specified local name and
+  // namespace URI.
+  ///
+  /*--cef(capi_name=get_attribute_bylname)--*/
+  virtual CefString GetAttribute(const CefString& localName,
+                                 const CefString& namespaceURI) =0;
+
+  ///
+  // Returns an XML representation of the current node's children.
+  ///
+  /*--cef()--*/
+  virtual CefString GetInnerXml() =0;
+
+  ///
+  // Returns an XML representation of the current node including its children.
+  ///
+  /*--cef()--*/
+  virtual CefString GetOuterXml() =0;
+
+  ///
+  // Returns the line number for the current node.
+  ///
+  /*--cef()--*/
+  virtual int GetLineNumber() =0;
+
+
+  // Attribute nodes are not traversed by default. The below methods can be
+  // used to move the cursor to an attribute node. MoveToCarryingElement() can
+  // be called afterwards to return the cursor to the carrying element. The
+  // depth of an attribute node will be 1 + the depth of the carrying element.
+
+  ///
+  // Moves the cursor to the attribute at the specified 0-based index. Returns
+  // true if the cursor position was set successfully.
+  ///
+  /*--cef(capi_name=move_to_attribute_byindex,index_param=index)--*/
+  virtual bool MoveToAttribute(int index) =0;
+
+  ///
+  // Moves the cursor to the attribute with the specified qualified name.
+  // Returns true if the cursor position was set successfully.
+  ///
+  /*--cef(capi_name=move_to_attribute_byqname)--*/
+  virtual bool MoveToAttribute(const CefString& qualifiedName) =0;
+
+  ///
+  // Moves the cursor to the attribute with the specified local name and
+  // namespace URI. Returns true if the cursor position was set successfully.
+  ///
+  /*--cef(capi_name=move_to_attribute_bylname)--*/
+  virtual bool MoveToAttribute(const CefString& localName,
+                               const CefString& namespaceURI) =0;
+
+  ///
+  // Moves the cursor to the first attribute in the current element. Returns
+  // true if the cursor position was set successfully.
+  ///
+  /*--cef()--*/
+  virtual bool MoveToFirstAttribute() =0;
+
+  ///
+  // Moves the cursor to the next attribute in the current element. Returns
+  // true if the cursor position was set successfully.
+  ///
+  /*--cef()--*/
+  virtual bool MoveToNextAttribute() =0;
+
+  ///
+  // Moves the cursor back to the carrying element. Returns true if the cursor
+  // position was set successfully.
+  ///
+  /*--cef()--*/
+  virtual bool MoveToCarryingElement() =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_XML_READER_H_
diff --git a/src/include/libcef_/cef_zip_reader.h b/src/include/libcef_/cef_zip_reader.h
new file mode 100644
index 0000000..35d4ce5
--- /dev/null
+++ b/src/include/libcef_/cef_zip_reader.h
@@ -0,0 +1,141 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_ZIP_READER_H_
+#define CEF_INCLUDE_CEF_ZIP_READER_H_
+
+#include"libcef/cef_base.h"
+#include"libcef/cef_stream.h"
+
+///
+// Class that supports the reading of zip archives via the zlib unzip API.
+// The methods of this class should only be called on the thread that creates
+// the object.
+///
+/*--cef(source=library)--*/
+class CefZipReader : public virtual CefBase {
+ public:
+  ///
+  // Create a new CefZipReader object. The returned object's methods can only
+  // be called from the thread that created the object.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefZipReader> Create(CefRefPtr<CefStreamReader> stream);
+
+  ///
+  // Moves the cursor to the first file in the archive. Returns true if the
+  // cursor position was set successfully.
+  ///
+  /*--cef()--*/
+  virtual bool MoveToFirstFile() =0;
+
+  ///
+  // Moves the cursor to the next file in the archive. Returns true if the
+  // cursor position was set successfully.
+  ///
+  /*--cef()--*/
+  virtual bool MoveToNextFile() =0;
+
+  ///
+  // Moves the cursor to the specified file in the archive. If |caseSensitive|
+  // is true then the search will be case sensitive. Returns true if the cursor
+  // position was set successfully.
+  ///
+  /*--cef()--*/
+  virtual bool MoveToFile(const CefString& fileName, bool caseSensitive) =0;
+
+  ///
+  // Closes the archive. This should be called directly to ensure that cleanup
+  // occurs on the correct thread.
+  ///
+  /*--cef()--*/
+  virtual bool Close() =0;
+
+
+  // The below methods act on the file at the current cursor position.
+
+  ///
+  // Returns the name of the file.
+  ///
+  /*--cef()--*/
+  virtual CefString GetFileName() =0;
+
+  ///
+  // Returns the uncompressed size of the file.
+  ///
+  /*--cef()--*/
+  virtual int64 GetFileSize() =0;
+
+  ///
+  // Returns the last modified timestamp for the file.
+  ///
+  /*--cef()--*/
+  virtual CefTime GetFileLastModified() =0;
+
+  ///
+  // Opens the file for reading of uncompressed data. A read password may
+  // optionally be specified.
+  ///
+  /*--cef(optional_param=password)--*/
+  virtual bool OpenFile(const CefString& password) =0;
+
+  ///
+  // Closes the file.
+  ///
+  /*--cef()--*/
+  virtual bool CloseFile() =0;
+
+  ///
+  // Read uncompressed file contents into the specified buffer. Returns < 0 if
+  // an error occurred, 0 if at the end of file, or the number of bytes read.
+  ///
+  /*--cef()--*/
+  virtual int ReadFile(void* buffer, size_t bufferSize) =0;
+
+  ///
+  // Returns the current offset in the uncompressed file contents.
+  ///
+  /*--cef()--*/
+  virtual int64 Tell() =0;
+
+  ///
+  // Returns true if at end of the file contents.
+  ///
+  /*--cef()--*/
+  virtual bool Eof() =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_ZIP_READER_H_
diff --git a/src/include/libcef_/internal/cef_export.h b/src/include/libcef_/internal/cef_export.h
new file mode 100644
index 0000000..4f9081b
--- /dev/null
+++ b/src/include/libcef_/internal/cef_export.h
@@ -0,0 +1,58 @@
+// Copyright (c) 2009 The Chromium Embedded Framework Authors. All rights
+// reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef CEF_INCLUDE_INTERNAL_CEF_EXPORT_H_
+#define CEF_INCLUDE_INTERNAL_CEF_EXPORT_H_
+#pragma once
+
+#include"libcef/base/cef_build.h"
+
+#if defined(COMPILER_MSVC)
+	#ifdef BUILDING_CEF_SHARED
+		#define CEF_EXPORT __declspec(dllexport)
+	#elif USING_CEF_SHARED
+		#define CEF_EXPORT __declspec(dllimport)
+	#else
+		#define CEF_EXPORT
+	#endif
+		#define CEF_CALLBACK __stdcall
+#elif defined(COMPILER_GCC)
+	#define CEF_EXPORT __attribute__ ((visibility("default")))
+	#define CEF_CALLBACK
+#endif  // COMPILER_GCC
+
+#ifdef __WATCOMC__
+    // Watcom usa exportações via pragma, mas podemos definir como vazio
+    #define CEF_EXPORT __declspec(dllexport)
+	#define CEF_EXPORT_WAT __cdecl
+    #define CEF_CALLBACK __stdcall
+#endif
+
+#endif  // CEF_INCLUDE_INTERNAL_CEF_EXPORT_H_
diff --git a/src/include/libcef_/internal/cef_logging_internal.h b/src/include/libcef_/internal/cef_logging_internal.h
new file mode 100644
index 0000000..bd89e6f
--- /dev/null
+++ b/src/include/libcef_/internal/cef_logging_internal.h
@@ -0,0 +1,66 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef CEF_INCLUDE_INTERNAL_CEF_LOGGING_INTERNAL_H_
+#define CEF_INCLUDE_INTERNAL_CEF_LOGGING_INTERNAL_H_
+#pragma once
+
+#include"libcef/internal/cef_export.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// See include/base/cef_logging.h for macros and intended usage.
+
+///
+// Gets the current log level.
+///
+CEF_EXPORT int cef_get_min_log_level();
+
+///
+// Gets the current vlog level for the given file (usually taken from
+// __FILE__). Note that |N| is the size *with* the null terminator.
+///
+CEF_EXPORT int cef_get_vlog_level(const char* file_start, size_t N);
+
+///
+// Add a log message. See the LogSeverity defines for supported |severity|
+// values.
+///
+CEF_EXPORT void cef_log(const char* file,
+                        int line,
+                        int severity,
+                        const char* message);
+
+#ifdef __cplusplus
+}
+#endif  // __cplusplus
+
+#endif  // CEF_INCLUDE_INTERNAL_CEF_LOGGING_INTERNAL_H_
diff --git a/src/include/libcef_/internal/cef_ptr.h b/src/include/libcef_/internal/cef_ptr.h
new file mode 100644
index 0000000..27bd810
--- /dev/null
+++ b/src/include/libcef_/internal/cef_ptr.h
@@ -0,0 +1,161 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+#ifndef CEF_INCLUDE_INTERNAL_CEF_PTR_H_
+#define CEF_INCLUDE_INTERNAL_CEF_PTR_H_
+#pragma once
+
+#include"libcef/base/cef_ref_counted.h"
+
+///
+// Smart pointer implementation that is an alias of scoped_refptr from
+// include/base/cef_ref_counted.h.
+// <p>
+// A smart pointer class for reference counted objects.  Use this class instead
+// of calling AddRef and Release manually on a reference counted object to
+// avoid common memory leaks caused by forgetting to Release an object
+// reference.  Sample usage:
+// <pre>
+//   class MyFoo : public CefBase {
+//    ...
+//   };
+//
+//   void some_function() {
+//     // The MyFoo object that |foo| represents starts with a single
+//     // reference.
+//     CefRefPtr&lt;MyFoo&gt; foo = new MyFoo();
+//     foo-&gt;Method(param);
+//     // |foo| is released when this function returns
+//   }
+//
+//   void some_other_function() {
+//     CefRefPtr&lt;MyFoo&gt; foo = new MyFoo();
+//     ...
+//     foo = NULL;  // explicitly releases |foo|
+//     ...
+//     if (foo)
+//       foo-&gt;Method(param);
+//   }
+// </pre>
+// The above examples show how CefRefPtr&lt;T&gt; acts like a pointer to T.
+// Given two CefRefPtr&lt;T&gt; classes, it is also possible to exchange
+// references between the two objects, like so:
+// <pre>
+//   {
+//     CefRefPtr&lt;MyFoo&gt; a = new MyFoo();
+//     CefRefPtr&lt;MyFoo&gt; b;
+//
+//     b.swap(a);
+//     // now, |b| references the MyFoo object, and |a| references NULL.
+//   }
+// </pre>
+// To make both |a| and |b| in the above example reference the same MyFoo
+// object, simply use the assignment operator:
+// <pre>
+//   {
+//     CefRefPtr&lt;MyFoo&gt; a = new MyFoo();
+//     CefRefPtr&lt;MyFoo&gt; b;
+//
+//     b = a;
+//     // now, |a| and |b| each own a reference to the same MyFoo object.
+//     // the reference count of the underlying MyFoo object will be 2.
+//   }
+// </pre>
+// Reference counted objects can also be passed as function parameters and
+// used as function return values:
+// <pre>
+//   void some_func_with_param(CefRefPtr&lt;MyFoo&gt; param) {
+//     // A reference is added to the MyFoo object that |param| represents
+//     // during the scope of some_func_with_param() and released when
+//     // some_func_with_param() goes out of scope.
+//   }
+//
+//   CefRefPtr&lt;MyFoo&gt; some_func_with_retval() {
+//     // The MyFoo object that |foox| represents starts with a single
+//     // reference.
+//     CefRefPtr&lt;MyFoo&gt; foox = new MyFoo();
+//
+//     // Creating the return value adds an additional reference.
+//     return foox;
+//
+//     // When some_func_with_retval() goes out of scope the original |foox|
+//     // reference is released.
+//   }
+//
+//   void and_another_function() {
+//     CefRefPtr&lt;MyFoo&gt; foo = new MyFoo();
+//
+//     // pass |foo| as a parameter.
+//     some_function(foo);
+//
+//     CefRefPtr&lt;MyFoo&gt; foo2 = some_func_with_retval();
+//     // Now, since we kept a reference to the some_func_with_retval() return
+//     // value, |foo2| is the only class pointing to the MyFoo object created
+//     in some_func_with_retval(), and it has a reference count of 1.
+//
+//     some_func_with_retval();
+//     // Now, since we didn't keep a reference to the some_func_with_retval()
+//     // return value, the MyFoo object created in some_func_with_retval()
+//     // will automatically be released.
+//   }
+// </pre>
+// And in standard containers:
+// <pre>
+//   {
+//      // Create a vector that holds MyFoo objects.
+//      std::vector&lt;CefRefPtr&lt;MyFoo&gt; &gt; MyFooVec;
+//
+//     // The MyFoo object that |foo| represents starts with a single
+//     // reference.
+//     CefRefPtr&lt;MyFoo&gt; foo = new MyFoo();
+//
+//     // When the MyFoo object is added to |MyFooVec| the reference count
+//     // is increased to 2.
+//     MyFooVec.push_back(foo);
+//   }
+// </pre>
+// </p>
+///
+template <class T>
+class CefRefPtr : public scoped_refptr<T> {
+ public:
+  typedef scoped_refptr<T> parent;
+
+  CefRefPtr() : parent() {}
+
+  CefRefPtr(T* p) : parent(p) {}
+
+  CefRefPtr(const scoped_refptr<T>& r) : parent(r) {}
+
+  template <typename U>
+  CefRefPtr(const scoped_refptr<U>& r) : parent(r) {}
+};
+
+#endif  // CEF_INCLUDE_INTERNAL_CEF_PTR_H_
diff --git a/src/include/libcef_/internal/cef_string.h b/src/include/libcef_/internal/cef_string.h
new file mode 100644
index 0000000..bcced03
--- /dev/null
+++ b/src/include/libcef_/internal/cef_string.h
@@ -0,0 +1,113 @@
+// Copyright (c) 2010 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef CEF_INCLUDE_INTERNAL_CEF_STRING_H_
+#define CEF_INCLUDE_INTERNAL_CEF_STRING_H_
+#pragma once
+
+// The CEF interface is built with one string type as the default. Comment out
+// all but one of the CEF_STRING_TYPE_* defines below to specify the default.
+// If you change the default you MUST recompile all of CEF.
+
+// Build with the UTF8 string type as default.
+// #define CEF_STRING_TYPE_UTF8 1
+
+// Build with the UTF16 string type as default.
+#define CEF_STRING_TYPE_UTF16 1
+
+// Build with the wide string type as default.
+// #define CEF_STRING_TYPE_WIDE 1
+
+
+#include"libcef/internal/cef_string_types.h"
+
+#ifdef __cplusplus
+	#include"libcef/internal/cef_string_wrappers.h"
+	#if defined(CEF_STRING_TYPE_UTF16)
+		typedef CefStringUTF16 CefString;
+	#elif defined(CEF_STRING_TYPE_UTF8)
+		typedef CefStringUTF8 CefString;
+	#elif defined(CEF_STRING_TYPE_WIDE)
+		typedef CefStringWide CefString;
+	#endif
+#endif  /* __cplusplus */
+
+#if defined(CEF_STRING_TYPE_UTF8)
+typedef char cef_char_t;
+typedef cef_string_utf8_t cef_string_t;
+typedef cef_string_userfree_utf8_t cef_string_userfree_t;
+#define cef_string_set cef_string_utf8_set
+#define cef_string_copy cef_string_utf8_copy
+#define cef_string_clear cef_string_utf8_clear
+#define cef_string_userfree_alloc cef_string_userfree_utf8_alloc
+#define cef_string_userfree_free cef_string_userfree_utf8_free
+#define cef_string_from_ascii cef_string_utf8_copy
+#define cef_string_to_utf8 cef_string_utf8_copy
+#define cef_string_from_utf8 cef_string_utf8_copy
+#define cef_string_to_utf16 cef_string_utf8_to_utf16
+#define cef_string_from_utf16 cef_string_utf16_to_utf8
+#define cef_string_to_wide cef_string_utf8_to_wide
+#define cef_string_from_wide cef_string_wide_to_utf8
+#elif defined(CEF_STRING_TYPE_UTF16)
+typedef char16 cef_char_t;
+typedef cef_string_userfree_utf16_t cef_string_userfree_t;
+typedef cef_string_utf16_t cef_string_t;
+#define cef_string_set cef_string_utf16_set
+#define cef_string_copy cef_string_utf16_copy
+#define cef_string_clear cef_string_utf16_clear
+#define cef_string_userfree_alloc cef_string_userfree_utf16_alloc
+#define cef_string_userfree_free cef_string_userfree_utf16_free
+#define cef_string_from_ascii cef_string_ascii_to_utf16
+#define cef_string_to_utf8 cef_string_utf16_to_utf8
+#define cef_string_from_utf8 cef_string_utf8_to_utf16
+#define cef_string_to_utf16 cef_string_utf16_copy
+#define cef_string_from_utf16 cef_string_utf16_copy
+#define cef_string_to_wide cef_string_utf16_to_wide
+#define cef_string_from_wide cef_string_wide_to_utf16
+#elif defined(CEF_STRING_TYPE_WIDE)
+typedef wchar_t cef_char_t;
+typedef cef_string_wide_t cef_string_t;
+typedef cef_string_userfree_wide_t cef_string_userfree_t;
+#define cef_string_set cef_string_wide_set
+#define cef_string_copy cef_string_wide_copy
+#define cef_string_clear cef_string_wide_clear
+#define cef_string_userfree_alloc cef_string_userfree_wide_alloc
+#define cef_string_userfree_free cef_string_userfree_wide_free
+#define cef_string_from_ascii cef_string_ascii_to_wide
+#define cef_string_to_utf8 cef_string_wide_to_utf8
+#define cef_string_from_utf8 cef_string_utf8_to_wide
+#define cef_string_to_utf16 cef_string_wide_to_utf16
+#define cef_string_from_utf16 cef_string_utf16_to_wide
+#define cef_string_to_wide cef_string_wide_copy
+#define cef_string_from_wide cef_string_wide_copy
+#else
+#error Please choose a string type.
+#endif
+
+#endif  // CEF_INCLUDE_INTERNAL_CEF_STRING_H_
diff --git a/src/include/libcef_/internal/cef_string_list.h b/src/include/libcef_/internal/cef_string_list.h
new file mode 100644
index 0000000..411177e
--- /dev/null
+++ b/src/include/libcef_/internal/cef_string_list.h
@@ -0,0 +1,88 @@
+// Copyright (c) 2009 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef CEF_INCLUDE_INTERNAL_CEF_STRING_LIST_H_
+#define CEF_INCLUDE_INTERNAL_CEF_STRING_LIST_H_
+#pragma once
+
+#include"libcef/internal/cef_export.h"
+#include"libcef/internal/cef_string.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///
+// CEF string maps are a set of key/value string pairs.
+///
+typedef void* cef_string_list_t;
+
+///
+// Allocate a new string map.
+///
+CEF_EXPORT cef_string_list_t cef_string_list_alloc();
+
+///
+// Return the number of elements in the string list.
+///
+CEF_EXPORT int cef_string_list_size(cef_string_list_t list);
+
+///
+// Retrieve the value at the specified zero-based string list index. Returns
+// true (1) if the value was successfully retrieved.
+///
+CEF_EXPORT int cef_string_list_value(cef_string_list_t list,
+                                     int index, cef_string_t* value);
+
+///
+// Append a new value at the end of the string list.
+///
+CEF_EXPORT void cef_string_list_append(cef_string_list_t list,
+                                       const cef_string_t* value);
+
+///
+// Clear the string list.
+///
+CEF_EXPORT void cef_string_list_clear(cef_string_list_t list);
+
+///
+// Free the string list.
+///
+CEF_EXPORT void cef_string_list_free(cef_string_list_t list);
+
+///
+// Creates a copy of an existing string list.
+///
+CEF_EXPORT cef_string_list_t cef_string_list_copy(cef_string_list_t list);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_INTERNAL_CEF_STRING_LIST_H_
diff --git a/src/include/libcef_/internal/cef_string_map.h b/src/include/libcef_/internal/cef_string_map.h
new file mode 100644
index 0000000..4719dc9
--- /dev/null
+++ b/src/include/libcef_/internal/cef_string_map.h
@@ -0,0 +1,97 @@
+// Copyright (c) 2009 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef CEF_INCLUDE_INTERNAL_CEF_STRING_MAP_H_
+#define CEF_INCLUDE_INTERNAL_CEF_STRING_MAP_H_
+#pragma once
+
+#include"libcef/internal/cef_export.h"
+#include"libcef/internal/cef_string.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///
+// CEF string maps are a set of key/value string pairs.
+///
+typedef void* cef_string_map_t;
+
+///
+// Allocate a new string map.
+///
+CEF_EXPORT cef_string_map_t cef_string_map_alloc();
+
+///
+// Return the number of elements in the string map.
+///
+CEF_EXPORT int cef_string_map_size(cef_string_map_t map);
+
+///
+// Return the value assigned to the specified key.
+///
+CEF_EXPORT int cef_string_map_find(cef_string_map_t map,
+                                   const cef_string_t* key,
+                                   cef_string_t* value);
+
+///
+// Return the key at the specified zero-based string map index.
+///
+CEF_EXPORT int cef_string_map_key(cef_string_map_t map, int index,
+                                  cef_string_t* key);
+
+///
+// Return the value at the specified zero-based string map index.
+///
+CEF_EXPORT int cef_string_map_value(cef_string_map_t map, int index,
+                                    cef_string_t* value);
+
+///
+// Append a new key/value pair at the end of the string map.
+///
+CEF_EXPORT int cef_string_map_append(cef_string_map_t map,
+                                     const cef_string_t* key,
+                                     const cef_string_t* value);
+
+///
+// Clear the string map.
+///
+CEF_EXPORT void cef_string_map_clear(cef_string_map_t map);
+
+///
+// Free the string map.
+///
+CEF_EXPORT void cef_string_map_free(cef_string_map_t map);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_INTERNAL_CEF_STRING_MAP_H_
diff --git a/src/include/libcef_/internal/cef_string_multimap.h b/src/include/libcef_/internal/cef_string_multimap.h
new file mode 100644
index 0000000..f68ccb4
--- /dev/null
+++ b/src/include/libcef_/internal/cef_string_multimap.h
@@ -0,0 +1,105 @@
+// Copyright (c) 2011 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef CEF_INCLUDE_INTERNAL_CEF_STRING_MULTIMAP_H_
+#define CEF_INCLUDE_INTERNAL_CEF_STRING_MULTIMAP_H_
+#pragma once
+
+#include"libcef/internal/cef_export.h"
+#include"libcef/internal/cef_string.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///
+// CEF string multimaps are a set of key/value string pairs.
+// More than one value can be assigned to a single key.
+///
+typedef void* cef_string_multimap_t;
+
+///
+// Allocate a new string multimap.
+///
+CEF_EXPORT cef_string_multimap_t cef_string_multimap_alloc();
+
+///
+// Return the number of elements in the string multimap.
+///
+CEF_EXPORT int cef_string_multimap_size(cef_string_multimap_t map);
+
+///
+// Return the number of values with the specified key.
+///
+CEF_EXPORT int cef_string_multimap_find_count(cef_string_multimap_t map,
+                                              const cef_string_t* key);
+
+///
+// Return the value_index-th value with the specified key.
+///
+CEF_EXPORT int cef_string_multimap_enumerate(cef_string_multimap_t map,
+                                             const cef_string_t* key,
+                                             int value_index,
+                                             cef_string_t* value);
+
+///
+// Return the key at the specified zero-based string multimap index.
+///
+CEF_EXPORT int cef_string_multimap_key(cef_string_multimap_t map, int index,
+                                       cef_string_t* key);
+
+///
+// Return the value at the specified zero-based string multimap index.
+///
+CEF_EXPORT int cef_string_multimap_value(cef_string_multimap_t map, int index,
+                                         cef_string_t* value);
+
+///
+// Append a new key/value pair at the end of the string multimap.
+///
+CEF_EXPORT int cef_string_multimap_append(cef_string_multimap_t map,
+                                          const cef_string_t* key,
+                                          const cef_string_t* value);
+
+///
+// Clear the string multimap.
+///
+CEF_EXPORT void cef_string_multimap_clear(cef_string_multimap_t map);
+
+///
+// Free the string multimap.
+///
+CEF_EXPORT void cef_string_multimap_free(cef_string_multimap_t map);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_INTERNAL_CEF_STRING_MULTIMAP_H_
diff --git a/src/include/libcef_/internal/cef_string_types.h b/src/include/libcef_/internal/cef_string_types.h
new file mode 100644
index 0000000..68c34af
--- /dev/null
+++ b/src/include/libcef_/internal/cef_string_types.h
@@ -0,0 +1,292 @@
+// Copyright (c) 2010 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef CEF_INCLUDE_INTERNAL_CEF_STRING_TYPES_H_
+#define CEF_INCLUDE_INTERNAL_CEF_STRING_TYPES_H_
+#pragma once
+
+// CEF provides functions for converting between UTF-8, -16 and -32 strings.
+// CEF string types are safe for reading from multiple threads but not for
+// modification. It is the user's responsibility to provide synchronization if
+// modifying CEF strings from multiple threads.
+
+#include<stddef.h>
+
+#include"libcef/base/cef_basictypes.h"
+#include"libcef/internal/cef_export.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// CEF string type definitions. Whomever allocates |str| is responsible for
+// providing an appropriate |dtor| implementation that will free the string in
+// the same memory space. When reusing an existing string structure make sure
+// to call |dtor| for the old value before assigning new |str| and |dtor|
+// values. Static strings will have a NULL |dtor| value. Using the below
+// functions if you want this managed for you.
+
+typedef struct _cef_string_wide_t 
+{
+  wchar_t* str;
+  size_t length;
+  void (*dtor)(wchar_t* str);
+} cef_string_wide_t;
+
+typedef struct _cef_string_utf8_t 
+{
+  char* str;
+  size_t length;
+  void (*dtor)(char* str);
+} cef_string_utf8_t;
+
+typedef struct _cef_string_utf16_t 
+{
+  char16* str;
+  size_t length;
+  void (*dtor)(char16* str);
+} cef_string_utf16_t;
+
+
+///
+// These functions set string values. If |copy| is true (1) the value will be
+// copied instead of referenced. It is up to the user to properly manage
+// the lifespan of references.
+///
+
+#ifdef __WATCOMC__
+  int CEF_EXPORT_WAT cef_string_wide_set(const wchar_t*     src, 
+                                     size_t             src_len,
+                                     cef_string_wide_t* output, 
+                                     int                copy);
+
+  int CEF_EXPORT_WAT cef_string_utf8_set(const char*          src, 
+                                      size_t              src_len,
+                                      cef_string_utf8_t*  output, 
+                                      int                 copy);
+
+  int CEF_EXPORT_WAT cef_string_utf16_set(const char16*       src, 
+                                      size_t              src_len,
+                                      cef_string_utf16_t* output, 
+                                      int                 copy);
+#else
+
+  CEF_EXPORT int cef_string_wide_set(const wchar_t*     src, 
+                                     size_t             src_len,
+                                     cef_string_wide_t* output, 
+                                     int                copy);
+
+  CEF_EXPORT int cef_string_utf8_set(const char*          src, 
+                                      size_t              src_len,
+                                      cef_string_utf8_t*  output, 
+                                      int                 copy);
+
+  CEF_EXPORT int cef_string_utf16_set(const char16*       src, 
+                                      size_t              src_len,
+                                      cef_string_utf16_t* output, 
+                                      int                 copy);
+#endif
+
+///
+// Convenience macros for copying values.
+///
+
+#define cef_string_wide_copy(src, src_len, output)  \
+    cef_string_wide_set(src, src_len, output, true)
+#define cef_string_utf8_copy(src, src_len, output)  \
+    cef_string_utf8_set(src, src_len, output, true)
+#define cef_string_utf16_copy(src, src_len, output)  \
+    cef_string_utf16_set(src, src_len, output, true)
+
+
+///
+// These functions clear string values. The structure itself is not freed.
+///
+
+#ifdef __WATCOMC__
+
+void CEF_EXPORT_WAT cef_string_wide_clear(cef_string_wide_t* str);
+void CEF_EXPORT_WAT cef_string_utf8_clear(cef_string_utf8_t* str);
+void CEF_EXPORT_WAT cef_string_utf16_clear(cef_string_utf16_t* str);
+
+#else
+
+CEF_EXPORT void cef_string_wide_clear(cef_string_wide_t* str);
+CEF_EXPORT void cef_string_utf8_clear(cef_string_utf8_t* str);
+CEF_EXPORT void cef_string_utf16_clear(cef_string_utf16_t* str);
+
+#endif 
+
+///
+// These functions compare two string values with the same results as strcmp().
+///
+
+#ifdef __WATCOMC__
+
+  int CEF_EXPORT_WAT cef_string_wide_cmp(const cef_string_wide_t* str1,
+                                   const cef_string_wide_t* str2);
+
+  int CEF_EXPORT_WAT cef_string_utf8_cmp(const cef_string_utf8_t* str1,
+                                     const cef_string_utf8_t* str2);
+
+  int CEF_EXPORT_WAT cef_string_utf16_cmp(const cef_string_utf16_t* str1,
+                                      const cef_string_utf16_t* str2);
+
+#else
+
+  CEF_EXPORT int cef_string_wide_cmp(const cef_string_wide_t* str1,
+                                     const cef_string_wide_t* str2);
+
+  CEF_EXPORT int cef_string_utf8_cmp(const cef_string_utf8_t* str1,
+                                     const cef_string_utf8_t* str2);
+
+  CEF_EXPORT int cef_string_utf16_cmp(const cef_string_utf16_t* str1,
+                                      const cef_string_utf16_t* str2);
+
+#endif 
+
+///
+// These functions convert between UTF-8, -16, and -32 strings. They are
+// potentially slow so unnecessary conversions should be avoided. The best
+// possible result will always be written to |output| with the boolean return
+// value indicating whether the conversion is 100% valid.
+///
+
+
+#ifdef __WATCOMC__
+
+ int CEF_EXPORT_WAT cef_string_wide_to_utf8(const wchar_t* src, size_t src_len,
+                                       cef_string_utf8_t* output);
+
+ int CEF_EXPORT_WAT cef_string_utf8_to_wide(const char* src, size_t src_len,
+                                       cef_string_wide_t* output);
+
+ int CEF_EXPORT_WAT cef_string_wide_to_utf16(const wchar_t* src, size_t src_len,
+                                        cef_string_utf16_t* output);
+
+ int CEF_EXPORT_WAT cef_string_utf16_to_wide(const char16* src, size_t src_len,
+                                        cef_string_wide_t* output);
+
+ int CEF_EXPORT_WAT cef_string_utf8_to_utf16(const char* src, size_t src_len,
+                                        cef_string_utf16_t* output);
+
+ int CEF_EXPORT_WAT cef_string_utf16_to_utf8(const char16* src, size_t src_len,
+                                        cef_string_utf8_t* output);
+
+#else
+
+CEF_EXPORT int cef_string_wide_to_utf8(const wchar_t* src, size_t src_len,
+                                       cef_string_utf8_t* output);
+
+CEF_EXPORT int cef_string_utf8_to_wide(const char* src, size_t src_len,
+                                       cef_string_wide_t* output);
+
+CEF_EXPORT int cef_string_wide_to_utf16(const wchar_t* src, size_t src_len,
+                                        cef_string_utf16_t* output);
+
+CEF_EXPORT int cef_string_utf16_to_wide(const char16* src, size_t src_len,
+                                        cef_string_wide_t* output);
+
+CEF_EXPORT int cef_string_utf8_to_utf16(const char* src, size_t src_len,
+                                        cef_string_utf16_t* output);
+
+CEF_EXPORT int cef_string_utf16_to_utf8(const char16* src, size_t src_len,
+                                        cef_string_utf8_t* output);
+
+#endif 
+
+///
+// These functions convert an ASCII string, typically a hardcoded constant, to a
+// Wide/UTF16 string. Use instead of the UTF8 conversion routines if you know
+// the string is ASCII.
+///
+
+#ifdef __WATCOMC__
+
+   int CEF_EXPORT_WAT cef_string_ascii_to_wide(const char* src, size_t src_len,
+                                        cef_string_wide_t* output);
+
+   int CEF_EXPORT_WAT cef_string_ascii_to_utf16(const char* src, size_t src_len,
+                                         cef_string_utf16_t* output);
+
+#else
+
+CEF_EXPORT int cef_string_ascii_to_wide(const char* src, size_t src_len,
+                                        cef_string_wide_t* output);
+CEF_EXPORT int cef_string_ascii_to_utf16(const char* src, size_t src_len,
+                                         cef_string_utf16_t* output);
+#endif 
+
+
+///
+// It is sometimes necessary for the system to allocate string structures with
+// the expectation that the user will free them. The userfree types act as a
+// hint that the user is responsible for freeing the structure.
+///
+
+typedef cef_string_wide_t* cef_string_userfree_wide_t;
+typedef cef_string_utf8_t* cef_string_userfree_utf8_t;
+typedef cef_string_utf16_t* cef_string_userfree_utf16_t;
+
+
+///
+// These functions allocate a new string structure. They must be freed by
+// calling the associated free function.
+///
+
+CEF_EXPORT cef_string_userfree_wide_t cef_string_userfree_wide_alloc();
+CEF_EXPORT cef_string_userfree_utf8_t cef_string_userfree_utf8_alloc();
+CEF_EXPORT cef_string_userfree_utf16_t cef_string_userfree_utf16_alloc();
+
+
+///
+// These functions free the string structure allocated by the associated
+// alloc function. Any string contents will first be cleared.
+///
+
+#ifdef __WATCOMC__
+
+ void CEF_EXPORT_WAT cef_string_userfree_wide_free(cef_string_userfree_wide_t str);
+ void CEF_EXPORT_WAT cef_string_userfree_utf8_free(cef_string_userfree_utf8_t str);
+ void CEF_EXPORT_WAT cef_string_userfree_utf16_free(cef_string_userfree_utf16_t str);
+
+
+#else
+
+CEF_EXPORT void cef_string_userfree_wide_free(cef_string_userfree_wide_t str);
+CEF_EXPORT void cef_string_userfree_utf8_free(cef_string_userfree_utf8_t str);
+CEF_EXPORT void cef_string_userfree_utf16_free(cef_string_userfree_utf16_t str);
+
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_INTERNAL_CEF_STRING_TYPES_H_
diff --git a/src/include/libcef_/internal/cef_string_wrappers.h b/src/include/libcef_/internal/cef_string_wrappers.h
new file mode 100644
index 0000000..603a85a
--- /dev/null
+++ b/src/include/libcef_/internal/cef_string_wrappers.h
@@ -0,0 +1,731 @@
+// Copyright (c) 2010 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef CEF_INCLUDE_INTERNAL_CEF_STRING_WRAPPERS_H_
+#define CEF_INCLUDE_INTERNAL_CEF_STRING_WRAPPERS_H_
+#pragma once
+
+#include<memory.h>
+#include<string>
+
+#include"libcef/base/cef_string16.h"
+#include"libcef/internal/cef_string_types.h"
+
+#if defined(BUILDING_CEF_SHARED)
+  #include"base/files/file_path.h"
+#endif
+
+///
+// Traits implementation for wide character strings.
+///
+struct CefStringTraitsWide 
+{
+  typedef wchar_t char_type;
+  typedef cef_string_wide_t struct_type;
+  typedef cef_string_userfree_wide_t userfree_struct_type;
+
+  static inline void clear(struct_type *s) { cef_string_wide_clear(s); }
+  static inline int set(const char_type* src, size_t src_size,
+                        struct_type* output, int copy) {
+    return cef_string_wide_set(src, src_size, output, copy);
+  }
+  static inline int compare(const struct_type* s1, const struct_type* s2) {
+    return cef_string_wide_cmp(s1, s2);
+  }
+  static inline userfree_struct_type userfree_alloc() {
+    return cef_string_userfree_wide_alloc();
+  }
+  static inline void userfree_free(userfree_struct_type ufs) {
+    return cef_string_userfree_wide_free(ufs);
+  }
+
+  // Conversion methods.
+  static inline bool from_ascii(const char* str, size_t len, struct_type *s) {
+    return cef_string_ascii_to_wide(str, len, s) ? true : false;
+  }
+  static inline std::string to_string(const struct_type *s) {
+    cef_string_utf8_t cstr;
+    memset(&cstr, 0, sizeof(cstr));
+    cef_string_wide_to_utf8(s->str, s->length, &cstr);
+    std::string str;
+    if (cstr.length > 0)
+      str = std::string(cstr.str, cstr.length);
+    cef_string_utf8_clear(&cstr);
+    return str;
+  }
+  static inline bool from_string(const std::string& str, struct_type *s) {
+    return cef_string_utf8_to_wide(str.c_str(), str.length(), s) ? true : false;
+  }
+  static inline std::wstring to_wstring(const struct_type *s) {
+    return std::wstring(s->str, s->length);
+  }
+  static inline bool from_wstring(const std::wstring& str, struct_type *s) {
+    return cef_string_wide_set(str.c_str(), str.length(), s, true) ?
+        true : false;
+  }
+#if defined(WCHAR_T_IS_UTF32)
+  static inline base::string16 to_string16(const struct_type *s) {
+    cef_string_utf16_t cstr;
+    memset(&cstr, 0, sizeof(cstr));
+    cef_string_wide_to_utf16(s->str, s->length, &cstr);
+    base::string16 str;
+    if (cstr.length > 0)
+      str = base::string16(cstr.str, cstr.length);
+    cef_string_utf16_clear(&cstr);
+    return str;
+  }
+  static inline bool from_string16(const base::string16& str,
+                                         struct_type *s) {
+    return cef_string_utf16_to_wide(str.c_str(), str.length(), s) ?
+        true : false;
+  }
+#else  // WCHAR_T_IS_UTF32
+  static inline base::string16 to_string16(const struct_type *s) {
+    return base::string16(s->str, s->length);
+  }
+  static inline bool from_string16(const base::string16& str, struct_type *s) {
+    return cef_string_wide_set(str.c_str(), str.length(), s, true) ?
+        true : false;
+  }
+#endif  // WCHAR_T_IS_UTF32
+};
+
+///
+// Traits implementation for utf8 character strings.
+///
+struct CefStringTraitsUTF8 {
+  typedef char char_type;
+  typedef cef_string_utf8_t struct_type;
+  typedef cef_string_userfree_utf8_t userfree_struct_type;
+
+  static inline void clear(struct_type *s) { cef_string_utf8_clear(s); }
+  static inline int set(const char_type* src, size_t src_size,
+                        struct_type* output, int copy) {
+    return cef_string_utf8_set(src, src_size, output, copy);
+  }
+  static inline int compare(const struct_type* s1, const struct_type* s2) {
+    return cef_string_utf8_cmp(s1, s2);
+  }
+  static inline userfree_struct_type userfree_alloc() {
+    return cef_string_userfree_utf8_alloc();
+  }
+  static inline void userfree_free(userfree_struct_type ufs) {
+    return cef_string_userfree_utf8_free(ufs);
+  }
+
+  // Conversion methods.
+  static inline bool from_ascii(const char* str, size_t len, struct_type* s) {
+    return cef_string_utf8_copy(str, len, s) ? true : false;
+  }
+  static inline std::string to_string(const struct_type* s) {
+    return std::string(s->str, s->length);
+  }
+  static inline bool from_string(const std::string& str, struct_type* s) {
+    return cef_string_utf8_copy(str.c_str(), str.length(), s) ? true : false;
+  }
+  static inline std::wstring to_wstring(const struct_type* s) {
+    cef_string_wide_t cstr;
+    memset(&cstr, 0, sizeof(cstr));
+    cef_string_utf8_to_wide(s->str, s->length, &cstr);
+    std::wstring str;
+    if (cstr.length > 0)
+      str = std::wstring(cstr.str, cstr.length);
+    cef_string_wide_clear(&cstr);
+    return str;
+  }
+  static inline bool from_wstring(const std::wstring& str, struct_type* s) {
+    return cef_string_wide_to_utf8(str.c_str(), str.length(), s) ? true : false;
+  }
+  static inline base::string16 to_string16(const struct_type* s) {
+    cef_string_utf16_t cstr;
+    memset(&cstr, 0, sizeof(cstr));
+    cef_string_utf8_to_utf16(s->str, s->length, &cstr);
+    base::string16 str;
+    if (cstr.length > 0)
+      str = base::string16(cstr.str, cstr.length);
+    cef_string_utf16_clear(&cstr);
+    return str;
+  }
+  static inline bool from_string16(const base::string16& str, struct_type* s) {
+    return cef_string_utf16_to_utf8(str.c_str(), str.length(), s) ?
+        true : false;
+  }
+};
+
+///
+// Traits implementation for utf16 character strings.
+///
+struct CefStringTraitsUTF16 {
+  typedef char16 char_type;
+  typedef cef_string_utf16_t struct_type;
+  typedef cef_string_userfree_utf16_t userfree_struct_type;
+
+  static inline void clear(struct_type *s) { cef_string_utf16_clear(s); }
+  static inline int set(const char_type* src, size_t src_size,
+                        struct_type* output, int copy) {
+    return cef_string_utf16_set(src, src_size, output, copy);
+  }
+  static inline int compare(const struct_type* s1, const struct_type* s2) {
+    return cef_string_utf16_cmp(s1, s2);
+  }
+  static inline userfree_struct_type userfree_alloc() {
+    return cef_string_userfree_utf16_alloc();
+  }
+  static inline void userfree_free(userfree_struct_type ufs) {
+    return cef_string_userfree_utf16_free(ufs);
+  }
+
+  // Conversion methods.
+  static inline bool from_ascii(const char* str, size_t len, struct_type* s) {
+    return cef_string_ascii_to_utf16(str, len, s) ? true : false;
+  }
+  static inline std::string to_string(const struct_type* s) {
+    cef_string_utf8_t cstr;
+    memset(&cstr, 0, sizeof(cstr));
+    cef_string_utf16_to_utf8(s->str, s->length, &cstr);
+    std::string str;
+    if (cstr.length > 0)
+      str = std::string(cstr.str, cstr.length);
+    cef_string_utf8_clear(&cstr);
+    return str;
+  }
+  static inline bool from_string(const std::string& str, struct_type* s) {
+    return cef_string_utf8_to_utf16(str.c_str(), str.length(), s) ?
+        true : false;
+  }
+#if defined(WCHAR_T_IS_UTF32)
+  static inline std::wstring to_wstring(const struct_type* s) {
+    cef_string_wide_t cstr;
+    memset(&cstr, 0, sizeof(cstr));
+    cef_string_utf16_to_wide(s->str, s->length, &cstr);
+    std::wstring str;
+    if (cstr.length > 0)
+      str = std::wstring(cstr.str, cstr.length);
+    cef_string_wide_clear(&cstr);
+    return str;
+  }
+  static inline bool from_wstring(const std::wstring& str, struct_type* s) {
+    return cef_string_wide_to_utf16(str.c_str(), str.length(), s) ?
+        true : false;
+  }
+#else  // WCHAR_T_IS_UTF32
+  static inline std::wstring to_wstring(const struct_type* s) {
+    return std::wstring(s->str, s->length);
+  }
+  static inline bool from_wstring(const std::wstring& str, struct_type* s) {
+    return cef_string_utf16_set(str.c_str(), str.length(), s, true) ?
+        true : false;
+  }
+#endif  // WCHAR_T_IS_UTF32
+  static inline base::string16 to_string16(const struct_type* s) {
+    return base::string16(s->str, s->length);
+  }
+  static inline bool from_string16(const base::string16& str, struct_type* s) {
+    return cef_string_utf16_set(str.c_str(), str.length(), s, true) ?
+        true : false;
+  }
+};
+
+///
+// CEF string classes can convert between all supported string types. For
+// example, the CefStringWide class uses wchar_t as the underlying character
+// type and provides two approaches for converting data to/from a UTF8 string
+// (std::string).
+// <p>
+// 1. Implicit conversion using the assignment operator overload.
+// <pre>
+//   CefStringWide aCefString;
+//   std::string aUTF8String;
+//   aCefString = aUTF8String; // Assign std::string to CefStringWide
+//   aUTF8String = aCefString; // Assign CefStringWide to std::string
+// </pre>
+// 2. Explicit conversion using the FromString/ToString methods.
+// <pre>
+//   CefStringWide aCefString;
+//   std::string aUTF8String;
+//   aCefString.FromString(aUTF8String); // Assign std::string to CefStringWide
+//   aUTF8String = aCefString.ToString(); // Assign CefStringWide to std::string
+// </pre>
+// Conversion will only occur if the assigned value is a different string type.
+// Assigning a std::string to a CefStringUTF8, for example, will copy the data
+// without performing a conversion.
+// </p>
+// CEF string classes are safe for reading from multiple threads but not for
+// modification. It is the user's responsibility to provide synchronization if
+// modifying CEF strings from multiple threads.
+///
+template <class traits>
+class CefStringBase {
+ public:
+  typedef typename traits::char_type char_type;
+  typedef typename traits::struct_type struct_type;
+  typedef typename traits::userfree_struct_type userfree_struct_type;
+
+  ///
+  // Default constructor.
+  ///
+  CefStringBase() : string_(NULL), owner_(false) {}
+
+  ///
+  // Create a new string from an existing string. Data will always be copied.
+  ///
+  CefStringBase(const CefStringBase& str)
+    : string_(NULL), owner_(false) {
+    FromString(str.c_str(), str.length(), true);
+  }
+
+  ///
+  // Create a new string from an existing std::string. Data will be always
+  // copied. Translation will occur if necessary based on the underlying string
+  // type.
+  ///
+  CefStringBase(const std::string& src)  // NOLINT(runtime/explicit)
+    : string_(NULL), owner_(false) {
+    FromString(src);
+  }
+  CefStringBase(const char* src)  // NOLINT(runtime/explicit)
+    : string_(NULL), owner_(false) {
+    if (src)
+      FromString(std::string(src));
+  }
+
+  ///
+  // Create a new string from an existing std::wstring. Data will be always
+  // copied. Translation will occur if necessary based on the underlying string
+  // type.
+  ///
+  CefStringBase(const std::wstring& src)  // NOLINT(runtime/explicit)
+    : string_(NULL), owner_(false) {
+    FromWString(src);
+  }
+  CefStringBase(const wchar_t* src)  // NOLINT(runtime/explicit)
+    : string_(NULL), owner_(false) {
+    if (src)
+      FromWString(std::wstring(src));
+  }
+
+#if defined(WCHAR_T_IS_UTF32)
+  ///
+  // Create a new string from an existing string16. Data will be always
+  // copied. Translation will occur if necessary based on the underlying string
+  // type.
+  ///
+  CefStringBase(const base::string16& src)  // NOLINT(runtime/explicit)
+    : string_(NULL), owner_(false) {
+    FromString16(src);
+  }
+  CefStringBase(const char16* src)  // NOLINT(runtime/explicit)
+    : string_(NULL), owner_(false) {
+    if (src)
+      FromString16(base::string16(src));
+  }
+#endif  // WCHAR_T_IS_UTF32
+
+  ///
+  // Create a new string from an existing character array. If |copy| is true
+  // this class will copy the data. Otherwise, this class will reference the
+  // existing data. Referenced data must exist for the lifetime of this class
+  // and will not be freed by this class.
+  ///
+  CefStringBase(const char_type* src, size_t src_len, bool copy)
+    : string_(NULL), owner_(false) {
+    if (src && src_len > 0)
+      FromString(src, src_len, copy);
+  }
+
+  ///
+  // Create a new string referencing an existing string structure without taking
+  // ownership. Referenced structures must exist for the lifetime of this class
+  // and will not be freed by this class.
+  ///
+  CefStringBase(const struct_type* src)  // NOLINT(runtime/explicit)
+    : string_(NULL), owner_(false) {
+    if (!src)
+      return;
+    // Reference the existing structure without taking ownership.
+    Attach(const_cast<struct_type*>(src), false);
+  }
+
+  virtual ~CefStringBase() { ClearAndFree(); }
+
+
+  // The following methods are named for compatibility with the standard library
+  // string template types.
+
+  ///
+  // Return a read-only pointer to the string data.
+  ///
+  const char_type* c_str() const { return (string_ ? string_->str : NULL); }
+
+  ///
+  // Return the length of the string data.
+  ///
+  size_t length() const { return (string_ ? string_->length : 0); }
+
+  ///
+  // Return the length of the string data.
+  ///
+  inline size_t size() const { return length(); }
+
+  ///
+  // Returns true if the string is empty.
+  ///
+  bool empty() const { return (string_ == NULL || string_->length == 0); }
+
+  ///
+  // Compare this string to the specified string.
+  ///
+  int compare(const CefStringBase& str) const {
+    if (empty() && str.empty())
+      return 0;
+    if (empty())
+      return -1;
+    if (str.empty())
+      return 1;
+    return traits::compare(string_, str.GetStruct());
+  }
+
+  ///
+  // Clear the string data.
+  ///
+  void clear() {
+    if (string_)
+      traits::clear(string_);
+  }
+
+  ///
+  // Swap this string's contents with the specified string.
+  ///
+  void swap(CefStringBase& str) {
+    struct_type* tmp_string = string_;
+    bool tmp_owner = owner_;
+    string_ = str.string_;
+    owner_ = str.owner_;
+    str.string_ = tmp_string;
+    str.owner_ = tmp_owner;
+  }
+
+
+  // The following methods are unique to CEF string template types.
+
+  ///
+  // Returns true if this class owns the underlying string structure.
+  ///
+  bool IsOwner() const { return owner_; }
+
+  ///
+  // Returns a read-only pointer to the underlying string structure. May return
+  // NULL if no structure is currently allocated.
+  ///
+  const struct_type* GetStruct() const { return string_; }
+
+  ///
+  // Returns a writable pointer to the underlying string structure. Will never
+  // return NULL.
+  ///
+  struct_type* GetWritableStruct() {
+    AllocIfNeeded();
+    return string_;
+  }
+
+  ///
+  // Clear the state of this class. The underlying string structure and data
+  // will be freed if this class owns the structure.
+  ///
+  void ClearAndFree() {
+    if (!string_)
+      return;
+    if (owner_) {
+      clear();
+      delete string_;
+    }
+    string_ = NULL;
+    owner_ = false;
+  }
+
+  ///
+  // Attach to the specified string structure. If |owner| is true this class
+  // will take ownership of the structure.
+  ///
+  void Attach(struct_type* str, bool owner) {
+    // Free the previous structure and data, if any.
+    ClearAndFree();
+
+    string_ = str;
+    owner_ = owner;
+  }
+
+  ///
+  // Take ownership of the specified userfree structure's string data. The
+  // userfree structure itself will be freed. Only use this method with userfree
+  // structures.
+  ///
+  void AttachToUserFree(userfree_struct_type str) {
+    // Free the previous structure and data, if any.
+    ClearAndFree();
+
+    if (!str)
+      return;
+
+    AllocIfNeeded();
+    owner_ = true;
+    memcpy(string_, str, sizeof(struct_type));
+
+    // Free the |str| structure but not the data.
+    memset(str, 0, sizeof(struct_type));
+    traits::userfree_free(str);
+  }
+
+  ///
+  // Detach from the underlying string structure. To avoid memory leaks only use
+  // this method if you already hold a pointer to the underlying string
+  // structure.
+  ///
+  void Detach() {
+    string_ = NULL;
+    owner_ = false;
+  }
+
+  ///
+  // Create a userfree structure and give it ownership of this class' string
+  // data. This class will be disassociated from the data. May return NULL if
+  // this string class currently contains no data.
+  ///
+  userfree_struct_type DetachToUserFree() {
+    if (empty())
+      return NULL;
+
+    userfree_struct_type str = traits::userfree_alloc();
+    memcpy(str, string_, sizeof(struct_type));
+
+    // Free this class' structure but not the data.
+    memset(string_, 0, sizeof(struct_type));
+    ClearAndFree();
+
+    return str;
+  }
+
+  ///
+  // Set this string's data to the specified character array. If |copy| is true
+  // this class will copy the data. Otherwise, this class will reference the
+  // existing data. Referenced data must exist for the lifetime of this class
+  // and will not be freed by this class.
+  ///
+  bool FromString(const char_type* src, size_t src_len, bool copy) {
+    if (src == NULL || src_len == 0) {
+      clear();
+      return true;
+    }
+    AllocIfNeeded();
+    return traits::set(src, src_len, string_, copy) ? true : false;
+  }
+
+  ///
+  // Set this string's data from an existing ASCII string. Data will be always
+  // copied. Translation will occur if necessary based on the underlying string
+  // type.
+  ///
+  bool FromASCII(const char* str) {
+    size_t len = str ? strlen(str) : 0;
+    if (len == 0) {
+      clear();
+      return true;
+    }
+    AllocIfNeeded();
+    return traits::from_ascii(str, len, string_);
+  }
+
+  ///
+  // Return this string's data as a std::string. Translation will occur if
+  // necessary based on the underlying string type.
+  ///
+  std::string ToString() const {
+    if (empty())
+      return std::string();
+    return traits::to_string(string_);
+  }
+
+  ///
+  // Set this string's data from an existing std::string. Data will be always
+  // copied. Translation will occur if necessary based on the underlying string
+  // type.
+  ///
+  bool FromString(const std::string& str) {
+    if (str.empty()) {
+      clear();
+      return true;
+    }
+    AllocIfNeeded();
+    return traits::from_string(str, string_);
+  }
+
+  ///
+  // Return this string's data as a std::wstring. Translation will occur if
+  // necessary based on the underlying string type.
+  ///
+  std::wstring ToWString() const {
+    if (empty())
+      return std::wstring();
+    return traits::to_wstring(string_);
+  }
+
+  ///
+  // Set this string's data from an existing std::wstring. Data will be always
+  // copied. Translation will occur if necessary based on the underlying string
+  // type.
+  ///
+  bool FromWString(const std::wstring& str) {
+    if (str.empty()) {
+      clear();
+      return true;
+    }
+    AllocIfNeeded();
+    return traits::from_wstring(str, string_);
+  }
+
+  ///
+  // Return this string's data as a string16. Translation will occur if
+  // necessary based on the underlying string type.
+  ///
+  base::string16 ToString16() const {
+    if (empty())
+      return base::string16();
+    return traits::to_string16(string_);
+  }
+
+  ///
+  // Set this string's data from an existing string16. Data will be always
+  // copied. Translation will occur if necessary based on the underlying string
+  // type.
+  ///
+  bool FromString16(const base::string16& str) {
+    if (str.empty()) {
+      clear();
+      return true;
+    }
+    AllocIfNeeded();
+    return traits::from_string16(str, string_);
+  }
+
+  ///
+  // Comparison operator overloads.
+  ///
+  bool operator<(const CefStringBase& str) const {
+    return (compare(str) < 0);
+  }
+  bool operator<=(const CefStringBase& str) const {
+    return (compare(str) <= 0);
+  }
+  bool operator>(const CefStringBase& str) const {
+    return (compare(str) > 0);
+  }
+  bool operator>=(const CefStringBase& str) const {
+    return (compare(str) >= 0);
+  }
+  bool operator==(const CefStringBase& str) const {
+    return (compare(str) == 0);
+  }
+  bool operator!=(const CefStringBase& str) const {
+    return (compare(str) != 0);
+  }
+
+  ///
+  // Assignment operator overloads.
+  ///
+  CefStringBase& operator=(const CefStringBase& str) {
+    FromString(str.c_str(), str.length(), true);
+    return *this;
+  }
+  operator std::string() const {
+    return ToString();
+  }
+  CefStringBase& operator=(const std::string& str) {
+    FromString(str);
+    return *this;
+  }
+  CefStringBase& operator=(const char* str) {
+    FromString(std::string(str));
+    return *this;
+  }
+  operator std::wstring() const {
+    return ToWString();
+  }
+  CefStringBase& operator=(const std::wstring& str) {
+    FromWString(str);
+    return *this;
+  }
+  CefStringBase& operator=(const wchar_t* str) {
+    FromWString(std::wstring(str));
+    return *this;
+  }
+#if defined(WCHAR_T_IS_UTF32)
+  operator base::string16() const {
+    return ToString16();
+  }
+  CefStringBase& operator=(const base::string16& str) {
+    FromString16(str);
+    return *this;
+  }
+  CefStringBase& operator=(const char16* str) {
+    FromString16(base::string16(str));
+    return *this;
+  }
+#endif  // WCHAR_T_IS_UTF32
+#if defined(BUILDING_CEF_SHARED)
+  // The base::FilePath constructor is marked as explicit so provide the
+  // conversion here for convenience.
+  operator base::FilePath() const {
+#if defined(OS_WIN)
+    return base::FilePath(ToWString());
+#else
+    return base::FilePath(ToString());
+#endif
+  }
+#endif  // BUILDING_CEF_SHARED
+
+ private:
+  // Allocate the string structure if it doesn't already exist.
+  void AllocIfNeeded() {
+    if (string_ == NULL) {
+      string_ = new struct_type;
+      memset(string_, 0, sizeof(struct_type));
+      owner_ = true;
+    }
+  }
+
+  struct_type* string_;
+  bool owner_;
+};
+
+
+typedef CefStringBase<CefStringTraitsWide> CefStringWide;
+typedef CefStringBase<CefStringTraitsUTF8> CefStringUTF8;
+typedef CefStringBase<CefStringTraitsUTF16> CefStringUTF16;
+
+#endif  // CEF_INCLUDE_INTERNAL_CEF_STRING_WRAPPERS_H_
diff --git a/src/include/libcef_/internal/cef_thread_internal.h b/src/include/libcef_/internal/cef_thread_internal.h
new file mode 100644
index 0000000..51f5d95
--- /dev/null
+++ b/src/include/libcef_/internal/cef_thread_internal.h
@@ -0,0 +1,74 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef CEF_INCLUDE_INTERNAL_CEF_THREAD_INTERNAL_H_
+#define CEF_INCLUDE_INTERNAL_CEF_THREAD_INTERNAL_H_
+#pragma once
+
+#if defined(OS_WIN)
+    #include<windows.h>
+#elif defined(OS_POSIX)
+    #include<pthread.h>
+    #include<unistd.h>
+#endif
+
+#include"libcef/internal/cef_export.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if defined(OS_WIN)
+typedef DWORD cef_platform_thread_id_t;
+#elif defined(OS_POSIX)
+typedef pid_t cef_platform_thread_id_t;
+#endif
+
+///
+// Returns the current platform thread ID.
+///
+CEF_EXPORT cef_platform_thread_id_t cef_get_current_platform_thread_id();
+
+#if defined(OS_WIN)
+typedef DWORD cef_platform_thread_handle_t;
+#elif defined(OS_POSIX)
+typedef pthread_t cef_platform_thread_handle_t;
+#endif
+
+///
+// Returns the current platform thread handle.
+///
+CEF_EXPORT cef_platform_thread_handle_t
+    cef_get_current_platform_thread_handle();
+
+#ifdef __cplusplus
+}
+#endif  // __cplusplus
+
+#endif  // CEF_INCLUDE_INTERNAL_CEF_THREAD_INTERNAL_H_
diff --git a/src/include/libcef_/internal/cef_time.h b/src/include/libcef_/internal/cef_time.h
new file mode 100644
index 0000000..baf28a8
--- /dev/null
+++ b/src/include/libcef_/internal/cef_time.h
@@ -0,0 +1,88 @@
+// Copyright (c) 2011 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef CEF_INCLUDE_INTERNAL_CEF_TIME_H_
+#define CEF_INCLUDE_INTERNAL_CEF_TIME_H_
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include"libcef/internal/cef_export.h"
+#include<time.h>
+
+///
+// Time information. Values should always be in UTC.
+///
+typedef struct _cef_time_t {
+  int year;          // Four digit year "2007"
+  int month;         // 1-based month (values 1 = January, etc.)
+  int day_of_week;   // 0-based day of week (0 = Sunday, etc.)
+  int day_of_month;  // 1-based day of month (1-31)
+  int hour;          // Hour within the current day (0-23)
+  int minute;        // Minute within the current hour (0-59)
+  int second;        // Second within the current minute (0-59 plus leap
+                     //   seconds which may take it up to 60).
+  int millisecond;   // Milliseconds within the current second (0-999)
+} cef_time_t;
+
+///
+// Converts cef_time_t to/from time_t. Returns true (1) on success and false (0)
+// on failure.
+///
+CEF_EXPORT int cef_time_to_timet(const cef_time_t* cef_time, time_t* time);
+CEF_EXPORT int cef_time_from_timet(time_t time, cef_time_t* cef_time);
+
+///
+// Converts cef_time_t to/from a double which is the number of seconds since
+// epoch (Jan 1, 1970). Webkit uses this format to represent time. A value of 0
+// means "not initialized". Returns true (1) on success and false (0) on
+// failure.
+///
+CEF_EXPORT int cef_time_to_doublet(const cef_time_t* cef_time, double* time);
+CEF_EXPORT int cef_time_from_doublet(double time, cef_time_t* cef_time);
+
+///
+// Retrieve the current system time.
+//
+CEF_EXPORT int cef_time_now(cef_time_t* cef_time);
+
+///
+// Retrieve the delta in milliseconds between two time values.
+//
+CEF_EXPORT int cef_time_delta(const cef_time_t* cef_time1,
+                              const cef_time_t* cef_time2,
+                              long long* delta);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_INTERNAL_CEF_TIME_H_
diff --git a/src/include/libcef_/internal/cef_trace_event_internal.h b/src/include/libcef_/internal/cef_trace_event_internal.h
new file mode 100644
index 0000000..098b4fa
--- /dev/null
+++ b/src/include/libcef_/internal/cef_trace_event_internal.h
@@ -0,0 +1,132 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef CEF_INCLUDE_INTERNAL_CEF_TRACE_EVENT_INTERNAL_H_
+#define CEF_INCLUDE_INTERNAL_CEF_TRACE_EVENT_INTERNAL_H_
+#pragma once
+
+#include"libcef/internal/cef_export.h"
+#include"libcef/internal/cef_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// See include/base/cef_trace_event.h for macros and intended usage.
+
+// Functions for tracing counters and functions; called from macros.
+// - |category| string must have application lifetime (static or literal). They
+//   may not include "(quotes) chars.
+// - |argX_name|, |argX_val|, |valueX_name|, |valeX_val| are optional parameters
+//   and represent pairs of name and values of arguments
+// - |copy| is used to avoid memory scoping issues with the |name| and
+//   |arg_name| parameters by copying them
+// - |id| is used to disambiguate counters with the same name, or match async
+//   trace events
+
+CEF_EXPORT void cef_trace_event_instant(const char* category,
+                                        const char* name,
+                                        const char* arg1_name,
+                                        uint64 arg1_val,
+                                        const char* arg2_name,
+                                        uint64 arg2_val,
+                                        int copy);
+
+CEF_EXPORT void cef_trace_event_begin(const char* category,
+                                      const char* name,
+                                      const char* arg1_name,
+                                      uint64 arg1_val,
+                                      const char* arg2_name,
+                                      uint64 arg2_val,
+                                      int copy);
+
+CEF_EXPORT void cef_trace_event_end(const char* category,
+                                    const char* name,
+                                    const char* arg1_name,
+                                    uint64 arg1_val,
+                                    const char* arg2_name,
+                                    uint64 arg2_val,
+                                    int copy);
+
+CEF_EXPORT void cef_trace_counter(const char* category,
+                                  const char* name,
+                                  const char* value1_name,
+                                  uint64 value1_val,
+                                  const char* value2_name,
+                                  uint64 value2_val,
+                                  int copy);
+
+CEF_EXPORT void cef_trace_counter_id(const char* category,
+                                     const char* name,
+                                     uint64 id,
+                                     const char* value1_name,
+                                     uint64 value1_val,
+                                     const char* value2_name,
+                                     uint64 value2_val,
+                                     int copy);
+
+CEF_EXPORT void cef_trace_event_async_begin(const char* category,
+                                            const char* name,
+                                            uint64 id,
+                                            const char* arg1_name,
+                                            uint64 arg1_val,
+                                            const char* arg2_name,
+                                            uint64 arg2_val,
+                                            int copy);
+
+CEF_EXPORT void cef_trace_event_async_step_into(const char* category,
+                                                const char* name,
+                                                uint64 id,
+                                                uint64 step,
+                                                const char* arg1_name,
+                                                uint64 arg1_val,
+                                                int copy);
+
+CEF_EXPORT void cef_trace_event_async_step_past(const char* category,
+                                                const char* name,
+                                                uint64 id,
+                                                uint64 step,
+                                                const char* arg1_name,
+                                                uint64 arg1_val,
+                                                int copy);
+
+CEF_EXPORT void cef_trace_event_async_end(const char* category,
+                                          const char* name,
+                                          uint64 id,
+                                          const char* arg1_name,
+                                          uint64 arg1_val,
+                                          const char* arg2_name,
+                                          uint64 arg2_val,
+                                          int copy);
+
+#ifdef __cplusplus
+}
+#endif  // __cplusplus
+
+#endif  // CEF_INCLUDE_INTERNAL_CEF_TRACE_EVENT_INTERNAL_H_
diff --git a/src/include/libcef_/internal/cef_types.h b/src/include/libcef_/internal/cef_types.h
new file mode 100644
index 0000000..6289442
--- /dev/null
+++ b/src/include/libcef_/internal/cef_types.h
@@ -0,0 +1,2419 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+#ifndef CEF_INCLUDE_INTERNAL_CEF_TYPES_H_
+#define CEF_INCLUDE_INTERNAL_CEF_TYPES_H_
+#pragma once
+
+#include"libcef/base/cef_basictypes.h"
+#include"libcef/internal/cef_string.h"
+#include"libcef/internal/cef_string_list.h"
+#include"libcef/internal/cef_time.h"
+
+// Bring in platform-specific definitions.
+#if defined(OS_WIN)
+    #include"libcef/internal/cef_types_win.h"
+#elif defined(OS_MACOSX)
+    #include "include/internal/cef_types_mac.h"
+#elif defined(OS_LINUX)
+    #include "include/internal/cef_types_linux.h"
+#endif
+
+// 32-bit ARGB color value, not premultiplied. The color components are always
+// in a known order. Equivalent to the SkColor type.
+typedef uint32              cef_color_t;
+
+// Return the alpha byte from a cef_color_t value.
+#define CefColorGetA(color)      (((color) >> 24) & 0xFF)
+// Return the red byte from a cef_color_t value.
+#define CefColorGetR(color)      (((color) >> 16) & 0xFF)
+// Return the green byte from a cef_color_t value.
+#define CefColorGetG(color)      (((color) >>  8) & 0xFF)
+// Return the blue byte from a cef_color_t value.
+#define CefColorGetB(color)      (((color) >>  0) & 0xFF)
+
+// Return an cef_color_t value with the specified byte component values.
+#define CefColorSetARGB(a, r, g, b) \
+    static_cast<cef_color_t>( \
+        (static_cast<unsigned>(a) << 24) | \
+        (static_cast<unsigned>(r) << 16) | \
+        (static_cast<unsigned>(g) << 8) | \
+        (static_cast<unsigned>(b) << 0))
+
+// Return an int64 value with the specified low and high int32 component values.
+#define CefInt64Set(int32_low, int32_high) \
+    static_cast<int64>((static_cast<uint32>(int32_low)) | \
+        (static_cast<int64>(static_cast<int32>(int32_high))) << 32)
+
+// Return the low int32 value from an int64 value.
+#define CefInt64GetLow(int64_val) static_cast<int32>(int64_val)
+// Return the high int32 value from an int64 value.
+#define CefInt64GetHigh(int64_val) \
+    static_cast<int32>((static_cast<int64>(int64_val) >> 32) & 0xFFFFFFFFL)
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///
+// Log severity levels.
+///
+typedef enum {
+  ///
+  // Default logging (currently INFO logging).
+  ///
+  LOGSEVERITY_DEFAULT,
+
+  ///
+  // Verbose logging.
+  ///
+  LOGSEVERITY_VERBOSE,
+
+  ///
+  // INFO logging.
+  ///
+  LOGSEVERITY_INFO,
+
+  ///
+  // WARNING logging.
+  ///
+  LOGSEVERITY_WARNING,
+
+  ///
+  // ERROR logging.
+  ///
+  LOGSEVERITY_ERROR,
+
+  ///
+  // Completely disable logging.
+  ///
+  LOGSEVERITY_DISABLE = 99
+} cef_log_severity_t;
+
+///
+// Represents the state of a setting.
+///
+typedef enum {
+  ///
+  // Use the default state for the setting.
+  ///
+  STATE_DEFAULT = 0,
+
+  ///
+  // Enable or allow the setting.
+  ///
+  STATE_ENABLED,
+
+  ///
+  // Disable or disallow the setting.
+  ///
+  STATE_DISABLED,
+} cef_state_t;
+
+///
+// Initialization settings. Specify NULL or 0 to get the recommended default
+// values. Many of these and other settings can also configured using command-
+// line switches.
+///
+typedef struct _cef_settings_t {
+  ///
+  // Size of this structure.
+  ///
+  size_t size;
+
+  ///
+  // Set to true (1) to use a single process for the browser and renderer. This
+  // run mode is not officially supported by Chromium and is less stable than
+  // the multi-process default. Also configurable using the "single-process"
+  // command-line switch.
+  ///
+  int single_process;
+
+  ///
+  // Set to true (1) to disable the sandbox for sub-processes. See
+  // cef_sandbox_win.h for requirements to enable the sandbox on Windows. Also
+  // configurable using the "no-sandbox" command-line switch.
+  ///
+  int no_sandbox;
+
+  ///
+  // The path to a separate executable that will be launched for sub-processes.
+  // By default the browser process executable is used. See the comments on
+  // CefExecuteProcess() for details. Also configurable using the
+  // "browser-subprocess-path" command-line switch.
+  ///
+  cef_string_t browser_subprocess_path;
+
+  ///
+  // Set to true (1) to have the browser process message loop run in a separate
+  // thread. If false (0) than the CefDoMessageLoopWork() function must be
+  // called from your application message loop. This option is only supported on
+  // Windows.
+  ///
+  int multi_threaded_message_loop;
+
+  ///
+  // Set to true (1) to enable windowless (off-screen) rendering support. Do not
+  // enable this value if the application does not use windowless rendering as
+  // it may reduce rendering performance on some systems.
+  ///
+  int windowless_rendering_enabled;
+
+  ///
+  // Set to true (1) to disable configuration of browser process features using
+  // standard CEF and Chromium command-line arguments. Configuration can still
+  // be specified using CEF data structures or via the
+  // CefApp::OnBeforeCommandLineProcessing() method.
+  ///
+  int command_line_args_disabled;
+
+  ///
+  // The location where cache data will be stored on disk. If empty then
+  // browsers will be created in "incognito mode" where in-memory caches are
+  // used for storage and no data is persisted to disk. HTML5 databases such as
+  // localStorage will only persist across sessions if a cache path is
+  // specified. Can be overridden for individual CefRequestContext instances via
+  // the CefRequestContextSettings.cache_path value.
+  ///
+  cef_string_t cache_path;
+
+  ///
+  // The location where user data such as spell checking dictionary files will
+  // be stored on disk. If empty then the default platform-specific user data
+  // directory will be used ("~/.cef_user_data" directory on Linux,
+  // "~/Library/Application Support/CEF/User Data" directory on Mac OS X,
+  // "Local Settings\Application Data\CEF\User Data" directory under the user
+  // profile directory on Windows).
+  ///
+  cef_string_t user_data_path;
+
+  ///
+  // To persist session cookies (cookies without an expiry date or validity
+  // interval) by default when using the global cookie manager set this value to
+  // true (1). Session cookies are generally intended to be transient and most
+  // Web browsers do not persist them. A |cache_path| value must also be
+  // specified to enable this feature. Also configurable using the
+  // "persist-session-cookies" command-line switch. Can be overridden for
+  // individual CefRequestContext instances via the
+  // CefRequestContextSettings.persist_session_cookies value.
+  ///
+  int persist_session_cookies;
+
+  ///
+  // To persist user preferences as a JSON file in the cache path directory set
+  // this value to true (1). A |cache_path| value must also be specified
+  // to enable this feature. Also configurable using the
+  // "persist-user-preferences" command-line switch. Can be overridden for
+  // individual CefRequestContext instances via the
+  // CefRequestContextSettings.persist_user_preferences value.
+  ///
+  int persist_user_preferences;
+
+  ///
+  // Value that will be returned as the User-Agent HTTP header. If empty the
+  // default User-Agent string will be used. Also configurable using the
+  // "user-agent" command-line switch.
+  ///
+  cef_string_t user_agent;
+
+  ///
+  // Value that will be inserted as the product portion of the default
+  // User-Agent string. If empty the Chromium product version will be used. If
+  // |userAgent| is specified this value will be ignored. Also configurable
+  // using the "product-version" command-line switch.
+  ///
+  cef_string_t product_version;
+
+  ///
+  // The locale string that will be passed to WebKit. If empty the default
+  // locale of "en-US" will be used. This value is ignored on Linux where locale
+  // is determined using environment variable parsing with the precedence order:
+  // LANGUAGE, LC_ALL, LC_MESSAGES and LANG. Also configurable using the "lang"
+  // command-line switch.
+  ///
+  cef_string_t locale;
+
+  ///
+  // The directory and file name to use for the debug log. If empty a default
+  // log file name and location will be used. On Windows and Linux a "debug.log"
+  // file will be written in the main executable directory. On Mac OS X a
+  // "~/Library/Logs/<app name>_debug.log" file will be written where <app name>
+  // is the name of the main app executable. Also configurable using the
+  // "log-file" command-line switch.
+  ///
+  cef_string_t log_file;
+
+  ///
+  // The log severity. Only messages of this severity level or higher will be
+  // logged. Also configurable using the "log-severity" command-line switch with
+  // a value of "verbose", "info", "warning", "error", "error-report" or
+  // "disable".
+  ///
+  cef_log_severity_t log_severity;
+
+  ///
+  // Custom flags that will be used when initializing the V8 JavaScript engine.
+  // The consequences of using custom flags may not be well tested. Also
+  // configurable using the "js-flags" command-line switch.
+  ///
+  cef_string_t javascript_flags;
+
+  ///
+  // The fully qualified path for the resources directory. If this value is
+  // empty the cef.pak and/or devtools_resources.pak files must be located in
+  // the module directory on Windows/Linux or the app bundle Resources directory
+  // on Mac OS X. Also configurable using the "resources-dir-path" command-line
+  // switch.
+  ///
+  cef_string_t resources_dir_path;
+
+  ///
+  // The fully qualified path for the locales directory. If this value is empty
+  // the locales directory must be located in the module directory. This value
+  // is ignored on Mac OS X where pack files are always loaded from the app
+  // bundle Resources directory. Also configurable using the "locales-dir-path"
+  // command-line switch.
+  ///
+  cef_string_t locales_dir_path;
+
+  ///
+  // Set to true (1) to disable loading of pack files for resources and locales.
+  // A resource bundle handler must be provided for the browser and render
+  // processes via CefApp::GetResourceBundleHandler() if loading of pack files
+  // is disabled. Also configurable using the "disable-pack-loading" command-
+  // line switch.
+  ///
+  int pack_loading_disabled;
+
+  ///
+  // Set to a value between 1024 and 65535 to enable remote debugging on the
+  // specified port. For example, if 8080 is specified the remote debugging URL
+  // will be http://localhost:8080. CEF can be remotely debugged from any CEF or
+  // Chrome browser window. Also configurable using the "remote-debugging-port"
+  // command-line switch.
+  ///
+  int remote_debugging_port;
+
+  ///
+  // The number of stack trace frames to capture for uncaught exceptions.
+  // Specify a positive value to enable the CefRenderProcessHandler::
+  // OnUncaughtException() callback. Specify 0 (default value) and
+  // OnUncaughtException() will not be called. Also configurable using the
+  // "uncaught-exception-stack-size" command-line switch.
+  ///
+  int uncaught_exception_stack_size;
+
+  ///
+  // By default CEF V8 references will be invalidated (the IsValid() method will
+  // return false) after the owning context has been released. This reduces the
+  // need for external record keeping and avoids crashes due to the use of V8
+  // references after the associated context has been released.
+  //
+  // CEF currently offers two context safety implementations with different
+  // performance characteristics. The default implementation (value of 0) uses a
+  // map of hash values and should provide better performance in situations with
+  // a small number contexts. The alternate implementation (value of 1) uses a
+  // hidden value attached to each context and should provide better performance
+  // in situations with a large number of contexts.
+  //
+  // If you need better performance in the creation of V8 references and you
+  // plan to manually track context lifespan you can disable context safety by
+  // specifying a value of -1.
+  //
+  // Also configurable using the "context-safety-implementation" command-line
+  // switch.
+  ///
+  int context_safety_implementation;
+
+  ///
+  // Set to true (1) to ignore errors related to invalid SSL certificates.
+  // Enabling this setting can lead to potential security vulnerabilities like
+  // "man in the middle" attacks. Applications that load content from the
+  // internet should not enable this setting. Also configurable using the
+  // "ignore-certificate-errors" command-line switch. Can be overridden for
+  // individual CefRequestContext instances via the
+  // CefRequestContextSettings.ignore_certificate_errors value.
+  ///
+  int ignore_certificate_errors;
+
+  ///
+  // Opaque background color used for accelerated content. By default the
+  // background color will be white. Only the RGB compontents of the specified
+  // value will be used. The alpha component must greater than 0 to enable use
+  // of the background color but will be otherwise ignored.
+  ///
+  cef_color_t background_color;
+
+  ///
+  // Comma delimited ordered list of language codes without any whitespace that
+  // will be used in the "Accept-Language" HTTP header. May be overridden on a
+  // per-browser basis using the CefBrowserSettings.accept_language_list value.
+  // If both values are empty then "en-US,en" will be used. Can be overridden
+  // for individual CefRequestContext instances via the
+  // CefRequestContextSettings.accept_language_list value.
+  ///
+  cef_string_t accept_language_list;
+} cef_settings_t;
+
+///
+// Request context initialization settings. Specify NULL or 0 to get the
+// recommended default values.
+///
+typedef struct _cef_request_context_settings_t {
+  ///
+  // Size of this structure.
+  ///
+  size_t size;
+
+  ///
+  // The location where cache data will be stored on disk. If empty then
+  // browsers will be created in "incognito mode" where in-memory caches are
+  // used for storage and no data is persisted to disk. HTML5 databases such as
+  // localStorage will only persist across sessions if a cache path is
+  // specified. To share the global browser cache and related configuration set
+  // this value to match the CefSettings.cache_path value.
+  ///
+  cef_string_t cache_path;
+
+  ///
+  // To persist session cookies (cookies without an expiry date or validity
+  // interval) by default when using the global cookie manager set this value to
+  // true (1). Session cookies are generally intended to be transient and most
+  // Web browsers do not persist them. Can be set globally using the
+  // CefSettings.persist_session_cookies value. This value will be ignored if
+  // |cache_path| is empty or if it matches the CefSettings.cache_path value.
+  ///
+  int persist_session_cookies;
+
+  ///
+  // To persist user preferences as a JSON file in the cache path directory set
+  // this value to true (1). Can be set globally using the
+  // CefSettings.persist_user_preferences value. This value will be ignored if
+  // |cache_path| is empty or if it matches the CefSettings.cache_path value.
+  ///
+  int persist_user_preferences;
+
+  ///
+  // Set to true (1) to ignore errors related to invalid SSL certificates.
+  // Enabling this setting can lead to potential security vulnerabilities like
+  // "man in the middle" attacks. Applications that load content from the
+  // internet should not enable this setting. Can be set globally using the
+  // CefSettings.ignore_certificate_errors value. This value will be ignored if
+  // |cache_path| matches the CefSettings.cache_path value.
+  ///
+  int ignore_certificate_errors;
+
+  ///
+  // Comma delimited ordered list of language codes without any whitespace that
+  // will be used in the "Accept-Language" HTTP header. Can be set globally
+  // using the CefSettings.accept_language_list value or overridden on a per-
+  // browser basis using the CefBrowserSettings.accept_language_list value. If
+  // all values are empty then "en-US,en" will be used. This value will be
+  // ignored if |cache_path| matches the CefSettings.cache_path value.
+  ///
+  cef_string_t accept_language_list;
+} cef_request_context_settings_t;
+
+///
+// Browser initialization settings. Specify NULL or 0 to get the recommended
+// default values. The consequences of using custom values may not be well
+// tested. Many of these and other settings can also configured using command-
+// line switches.
+///
+typedef struct _cef_browser_settings_t {
+  ///
+  // Size of this structure.
+  ///
+  size_t size;
+
+  ///
+  // The maximum rate in frames per second (fps) that CefRenderHandler::OnPaint
+  // will be called for a windowless browser. The actual fps may be lower if
+  // the browser cannot generate frames at the requested rate. The minimum
+  // value is 1 and the maximum value is 60 (default 30). This value can also be
+  // changed dynamically via CefBrowserHost::SetWindowlessFrameRate.
+  ///
+  int windowless_frame_rate;
+
+  // The below values map to WebPreferences settings.
+
+  ///
+  // Font settings.
+  ///
+  cef_string_t standard_font_family;
+  cef_string_t fixed_font_family;
+  cef_string_t serif_font_family;
+  cef_string_t sans_serif_font_family;
+  cef_string_t cursive_font_family;
+  cef_string_t fantasy_font_family;
+  int default_font_size;
+  int default_fixed_font_size;
+  int minimum_font_size;
+  int minimum_logical_font_size;
+
+  ///
+  // Default encoding for Web content. If empty "ISO-8859-1" will be used. Also
+  // configurable using the "default-encoding" command-line switch.
+  ///
+  cef_string_t default_encoding;
+
+  ///
+  // Controls the loading of fonts from remote sources. Also configurable using
+  // the "disable-remote-fonts" command-line switch.
+  ///
+  cef_state_t remote_fonts;
+
+  ///
+  // Controls whether JavaScript can be executed. Also configurable using the
+  // "disable-javascript" command-line switch.
+  ///
+  cef_state_t javascript;
+
+  ///
+  // Controls whether JavaScript can be used for opening windows. Also
+  // configurable using the "disable-javascript-open-windows" command-line
+  // switch.
+  ///
+  cef_state_t javascript_open_windows;
+
+  ///
+  // Controls whether JavaScript can be used to close windows that were not
+  // opened via JavaScript. JavaScript can still be used to close windows that
+  // were opened via JavaScript or that have no back/forward history. Also
+  // configurable using the "disable-javascript-close-windows" command-line
+  // switch.
+  ///
+  cef_state_t javascript_close_windows;
+
+  ///
+  // Controls whether JavaScript can access the clipboard. Also configurable
+  // using the "disable-javascript-access-clipboard" command-line switch.
+  ///
+  cef_state_t javascript_access_clipboard;
+
+  ///
+  // Controls whether DOM pasting is supported in the editor via
+  // execCommand("paste"). The |javascript_access_clipboard| setting must also
+  // be enabled. Also configurable using the "disable-javascript-dom-paste"
+  // command-line switch.
+  ///
+  cef_state_t javascript_dom_paste;
+
+  ///
+  // Controls whether the caret position will be drawn. Also configurable using
+  // the "enable-caret-browsing" command-line switch.
+  ///
+  cef_state_t caret_browsing;
+
+  ///
+  // Controls whether any plugins will be loaded. Also configurable using the
+  // "disable-plugins" command-line switch.
+  ///
+  cef_state_t plugins;
+
+  ///
+  // Controls whether file URLs will have access to all URLs. Also configurable
+  // using the "allow-universal-access-from-files" command-line switch.
+  ///
+  cef_state_t universal_access_from_file_urls;
+
+  ///
+  // Controls whether file URLs will have access to other file URLs. Also
+  // configurable using the "allow-access-from-files" command-line switch.
+  ///
+  cef_state_t file_access_from_file_urls;
+
+  ///
+  // Controls whether web security restrictions (same-origin policy) will be
+  // enforced. Disabling this setting is not recommend as it will allow risky
+  // security behavior such as cross-site scripting (XSS). Also configurable
+  // using the "disable-web-security" command-line switch.
+  ///
+  cef_state_t web_security;
+
+  ///
+  // Controls whether image URLs will be loaded from the network. A cached image
+  // will still be rendered if requested. Also configurable using the
+  // "disable-image-loading" command-line switch.
+  ///
+  cef_state_t image_loading;
+
+  ///
+  // Controls whether standalone images will be shrunk to fit the page. Also
+  // configurable using the "image-shrink-standalone-to-fit" command-line
+  // switch.
+  ///
+  cef_state_t image_shrink_standalone_to_fit;
+
+  ///
+  // Controls whether text areas can be resized. Also configurable using the
+  // "disable-text-area-resize" command-line switch.
+  ///
+  cef_state_t text_area_resize;
+
+  ///
+  // Controls whether the tab key can advance focus to links. Also configurable
+  // using the "disable-tab-to-links" command-line switch.
+  ///
+  cef_state_t tab_to_links;
+
+  ///
+  // Controls whether local storage can be used. Also configurable using the
+  // "disable-local-storage" command-line switch.
+  ///
+  cef_state_t local_storage;
+
+  ///
+  // Controls whether databases can be used. Also configurable using the
+  // "disable-databases" command-line switch.
+  ///
+  cef_state_t databases;
+
+  ///
+  // Controls whether the application cache can be used. Also configurable using
+  // the "disable-application-cache" command-line switch.
+  ///
+  cef_state_t application_cache;
+
+  ///
+  // Controls whether WebGL can be used. Note that WebGL requires hardware
+  // support and may not work on all systems even when enabled. Also
+  // configurable using the "disable-webgl" command-line switch.
+  ///
+  cef_state_t webgl;
+
+  ///
+  // Opaque background color used for the browser before a document is loaded
+  // and when no document color is specified. By default the background color
+  // will be the same as CefSettings.background_color. Only the RGB compontents
+  // of the specified value will be used. The alpha component must greater than
+  // 0 to enable use of the background color but will be otherwise ignored.
+  ///
+  cef_color_t background_color;
+
+  ///
+  // Comma delimited ordered list of language codes without any whitespace that
+  // will be used in the "Accept-Language" HTTP header. May be set globally
+  // using the CefBrowserSettings.accept_language_list value. If both values are
+  // empty then "en-US,en" will be used.
+  ///
+  cef_string_t accept_language_list;
+} cef_browser_settings_t;
+
+///
+// Return value types.
+///
+typedef enum {
+  ///
+  // Cancel immediately.
+  ///
+  RV_CANCEL = 0,
+
+  ///
+  // Continue immediately.
+  ///
+  RV_CONTINUE,
+
+  ///
+  // Continue asynchronously (usually via a callback).
+  ///
+  RV_CONTINUE_ASYNC,
+} cef_return_value_t;
+
+///
+// URL component parts.
+///
+typedef struct _cef_urlparts_t {
+  ///
+  // The complete URL specification.
+  ///
+  cef_string_t spec;
+
+  ///
+  // Scheme component not including the colon (e.g., "http").
+  ///
+  cef_string_t scheme;
+
+  ///
+  // User name component.
+  ///
+  cef_string_t username;
+
+  ///
+  // Password component.
+  ///
+  cef_string_t password;
+
+  ///
+  // Host component. This may be a hostname, an IPv4 address or an IPv6 literal
+  // surrounded by square brackets (e.g., "[2001:db8::1]").
+  ///
+  cef_string_t host;
+
+  ///
+  // Port number component.
+  ///
+  cef_string_t port;
+
+  ///
+  // Origin contains just the scheme, host, and port from a URL. Equivalent to
+  // clearing any username and password, replacing the path with a slash, and
+  // clearing everything after that. This value will be empty for non-standard
+  // URLs.
+  ///
+  cef_string_t origin;
+
+  ///
+  // Path component including the first slash following the host.
+  ///
+  cef_string_t path;
+
+  ///
+  // Query string component (i.e., everything following the '?').
+  ///
+  cef_string_t query;
+} cef_urlparts_t;
+
+///
+// Cookie information.
+///
+typedef struct _cef_cookie_t {
+  ///
+  // The cookie name.
+  ///
+  cef_string_t name;
+
+  ///
+  // The cookie value.
+  ///
+  cef_string_t value;
+
+  ///
+  // If |domain| is empty a host cookie will be created instead of a domain
+  // cookie. Domain cookies are stored with a leading "." and are visible to
+  // sub-domains whereas host cookies are not.
+  ///
+  cef_string_t domain;
+
+  ///
+  // If |path| is non-empty only URLs at or below the path will get the cookie
+  // value.
+  ///
+  cef_string_t path;
+
+  ///
+  // If |secure| is true the cookie will only be sent for HTTPS requests.
+  ///
+  int secure;
+
+  ///
+  // If |httponly| is true the cookie will only be sent for HTTP requests.
+  ///
+  int httponly;
+
+  ///
+  // The cookie creation date. This is automatically populated by the system on
+  // cookie creation.
+  ///
+  cef_time_t creation;
+
+  ///
+  // The cookie last access date. This is automatically populated by the system
+  // on access.
+  ///
+  cef_time_t last_access;
+
+  ///
+  // The cookie expiration date is only valid if |has_expires| is true.
+  ///
+  int has_expires;
+  cef_time_t expires;
+} cef_cookie_t;
+
+///
+// Process termination status values.
+///
+typedef enum {
+  ///
+  // Non-zero exit status.
+  ///
+  TS_ABNORMAL_TERMINATION,
+
+  ///
+  // SIGKILL or task manager kill.
+  ///
+  TS_PROCESS_WAS_KILLED,
+
+  ///
+  // Segmentation fault.
+  ///
+  TS_PROCESS_CRASHED,
+} cef_termination_status_t;
+
+///
+// Path key values.
+///
+typedef enum {
+  ///
+  // Current directory.
+  ///
+  PK_DIR_CURRENT,
+
+  ///
+  // Directory containing PK_FILE_EXE.
+  ///
+  PK_DIR_EXE,
+
+  ///
+  // Directory containing PK_FILE_MODULE.
+  ///
+  PK_DIR_MODULE,
+
+  ///
+  // Temporary directory.
+  ///
+  PK_DIR_TEMP,
+
+  ///
+  // Path and filename of the current executable.
+  ///
+  PK_FILE_EXE,
+
+  ///
+  // Path and filename of the module containing the CEF code (usually the libcef
+  // module).
+  ///
+  PK_FILE_MODULE,
+
+  ///
+  // "Local Settings\Application Data" directory under the user profile
+  // directory on Windows.
+  ///
+  PK_LOCAL_APP_DATA,
+
+  ///
+  // "Application Data" directory under the user profile directory on Windows
+  // and "~/Library/Application Support" directory on Mac OS X.
+  ///
+  PK_USER_DATA,
+} cef_path_key_t;
+
+///
+// Storage types.
+///
+typedef enum {
+  ST_LOCALSTORAGE = 0,
+  ST_SESSIONSTORAGE,
+} cef_storage_type_t;
+
+///
+// Supported error code values. See net\base\net_error_list.h for complete
+// descriptions of the error codes.
+///
+typedef enum {
+  ERR_NONE = 0,
+  ERR_FAILED = -2,
+  ERR_ABORTED = -3,
+  ERR_INVALID_ARGUMENT = -4,
+  ERR_INVALID_HANDLE = -5,
+  ERR_FILE_NOT_FOUND = -6,
+  ERR_TIMED_OUT = -7,
+  ERR_FILE_TOO_BIG = -8,
+  ERR_UNEXPECTED = -9,
+  ERR_ACCESS_DENIED = -10,
+  ERR_NOT_IMPLEMENTED = -11,
+  ERR_CONNECTION_CLOSED = -100,
+  ERR_CONNECTION_RESET = -101,
+  ERR_CONNECTION_REFUSED = -102,
+  ERR_CONNECTION_ABORTED = -103,
+  ERR_CONNECTION_FAILED = -104,
+  ERR_NAME_NOT_RESOLVED = -105,
+  ERR_INTERNET_DISCONNECTED = -106,
+  ERR_SSL_PROTOCOL_ERROR = -107,
+  ERR_ADDRESS_INVALID = -108,
+  ERR_ADDRESS_UNREACHABLE = -109,
+  ERR_SSL_CLIENT_AUTH_CERT_NEEDED = -110,
+  ERR_TUNNEL_CONNECTION_FAILED = -111,
+  ERR_NO_SSL_VERSIONS_ENABLED = -112,
+  ERR_SSL_VERSION_OR_CIPHER_MISMATCH = -113,
+  ERR_SSL_RENEGOTIATION_REQUESTED = -114,
+  ERR_CERT_COMMON_NAME_INVALID = -200,
+  ERR_CERT_BEGIN = ERR_CERT_COMMON_NAME_INVALID,
+  ERR_CERT_DATE_INVALID = -201,
+  ERR_CERT_AUTHORITY_INVALID = -202,
+  ERR_CERT_CONTAINS_ERRORS = -203,
+  ERR_CERT_NO_REVOCATION_MECHANISM = -204,
+  ERR_CERT_UNABLE_TO_CHECK_REVOCATION = -205,
+  ERR_CERT_REVOKED = -206,
+  ERR_CERT_INVALID = -207,
+  ERR_CERT_WEAK_SIGNATURE_ALGORITHM = -208,
+  // -209 is available: was ERR_CERT_NOT_IN_DNS.
+  ERR_CERT_NON_UNIQUE_NAME = -210,
+  ERR_CERT_WEAK_KEY = -211,
+  ERR_CERT_NAME_CONSTRAINT_VIOLATION = -212,
+  ERR_CERT_VALIDITY_TOO_LONG = -213,
+  ERR_CERT_END = ERR_CERT_VALIDITY_TOO_LONG,
+  ERR_INVALID_URL = -300,
+  ERR_DISALLOWED_URL_SCHEME = -301,
+  ERR_UNKNOWN_URL_SCHEME = -302,
+  ERR_TOO_MANY_REDIRECTS = -310,
+  ERR_UNSAFE_REDIRECT = -311,
+  ERR_UNSAFE_PORT = -312,
+  ERR_INVALID_RESPONSE = -320,
+  ERR_INVALID_CHUNKED_ENCODING = -321,
+  ERR_METHOD_NOT_SUPPORTED = -322,
+  ERR_UNEXPECTED_PROXY_AUTH = -323,
+  ERR_EMPTY_RESPONSE = -324,
+  ERR_RESPONSE_HEADERS_TOO_BIG = -325,
+  ERR_CACHE_MISS = -400,
+  ERR_INSECURE_RESPONSE = -501,
+} cef_errorcode_t;
+
+///
+// Supported certificate status code values. See net\cert\cert_status_flags.h
+// for more information. CERT_STATUS_NONE is new in CEF because we use an
+// enum while cert_status_flags.h uses a typedef and static const variables.
+///
+typedef enum {
+  CERT_STATUS_NONE = 0,
+  CERT_STATUS_COMMON_NAME_INVALID = 1 << 0,
+  CERT_STATUS_DATE_INVALID = 1 << 1,
+  CERT_STATUS_AUTHORITY_INVALID = 1 << 2,
+  // 1 << 3 is reserved for ERR_CERT_CONTAINS_ERRORS (not useful with WinHTTP).
+  CERT_STATUS_NO_REVOCATION_MECHANISM = 1 << 4,
+  CERT_STATUS_UNABLE_TO_CHECK_REVOCATION = 1 << 5,
+  CERT_STATUS_REVOKED = 1 << 6,
+  CERT_STATUS_INVALID = 1 << 7,
+  CERT_STATUS_WEAK_SIGNATURE_ALGORITHM = 1 << 8,
+  // 1 << 9 was used for CERT_STATUS_NOT_IN_DNS
+  CERT_STATUS_NON_UNIQUE_NAME = 1 << 10,
+  CERT_STATUS_WEAK_KEY = 1 << 11,
+  // 1 << 12 was used for CERT_STATUS_WEAK_DH_KEY
+  CERT_STATUS_PINNED_KEY_MISSING = 1 << 13,
+  CERT_STATUS_NAME_CONSTRAINT_VIOLATION = 1 << 14,
+  CERT_STATUS_VALIDITY_TOO_LONG = 1 << 15,
+
+  // Bits 16 to 31 are for non-error statuses.
+  CERT_STATUS_IS_EV = 1 << 16,
+  CERT_STATUS_REV_CHECKING_ENABLED = 1 << 17,
+  // Bit 18 was CERT_STATUS_IS_DNSSEC
+  CERT_STATUS_SHA1_SIGNATURE_PRESENT = 1 << 19,
+  CERT_STATUS_CT_COMPLIANCE_FAILED = 1 << 20,
+} cef_cert_status_t;
+
+///
+// The manner in which a link click should be opened.
+///
+typedef enum {
+  WOD_UNKNOWN,
+  WOD_SUPPRESS_OPEN,
+  WOD_CURRENT_TAB,
+  WOD_SINGLETON_TAB,
+  WOD_NEW_FOREGROUND_TAB,
+  WOD_NEW_BACKGROUND_TAB,
+  WOD_NEW_POPUP,
+  WOD_NEW_WINDOW,
+  WOD_SAVE_TO_DISK,
+  WOD_OFF_THE_RECORD,
+  WOD_IGNORE_ACTION
+} cef_window_open_disposition_t;
+
+///
+// "Verb" of a drag-and-drop operation as negotiated between the source and
+// destination. These constants match their equivalents in WebCore's
+// DragActions.h and should not be renumbered.
+///
+typedef enum {
+    DRAG_OPERATION_NONE    = 0,
+    DRAG_OPERATION_COPY    = 1,
+    DRAG_OPERATION_LINK    = 2,
+    DRAG_OPERATION_GENERIC = 4,
+    DRAG_OPERATION_PRIVATE = 8,
+    DRAG_OPERATION_MOVE    = 16,
+    DRAG_OPERATION_DELETE  = 32,
+    DRAG_OPERATION_EVERY   = UINT_MAX
+} cef_drag_operations_mask_t;
+
+///
+// V8 access control values.
+///
+typedef enum {
+  V8_ACCESS_CONTROL_DEFAULT               = 0,
+  V8_ACCESS_CONTROL_ALL_CAN_READ          = 1,
+  V8_ACCESS_CONTROL_ALL_CAN_WRITE         = 1 << 1,
+  V8_ACCESS_CONTROL_PROHIBITS_OVERWRITING = 1 << 2
+} cef_v8_accesscontrol_t;
+
+///
+// V8 property attribute values.
+///
+typedef enum {
+  V8_PROPERTY_ATTRIBUTE_NONE       = 0,       // Writeable, Enumerable,
+                                              //   Configurable
+  V8_PROPERTY_ATTRIBUTE_READONLY   = 1 << 0,  // Not writeable
+  V8_PROPERTY_ATTRIBUTE_DONTENUM   = 1 << 1,  // Not enumerable
+  V8_PROPERTY_ATTRIBUTE_DONTDELETE = 1 << 2   // Not configurable
+} cef_v8_propertyattribute_t;
+
+///
+// Post data elements may represent either bytes or files.
+///
+typedef enum {
+  PDE_TYPE_EMPTY  = 0,
+  PDE_TYPE_BYTES,
+  PDE_TYPE_FILE,
+} cef_postdataelement_type_t;
+
+///
+// Resource type for a request.
+///
+typedef enum {
+  ///
+  // Top level page.
+  ///
+  RT_MAIN_FRAME = 0,
+
+  ///
+  // Frame or iframe.
+  ///
+  RT_SUB_FRAME,
+
+  ///
+  // CSS stylesheet.
+  ///
+  RT_STYLESHEET,
+
+  ///
+  // External script.
+  ///
+  RT_SCRIPT,
+
+  ///
+  // Image (jpg/gif/png/etc).
+  ///
+  RT_IMAGE,
+
+  ///
+  // Font.
+  ///
+  RT_FONT_RESOURCE,
+
+  ///
+  // Some other subresource. This is the default type if the actual type is
+  // unknown.
+  ///
+  RT_SUB_RESOURCE,
+
+  ///
+  // Object (or embed) tag for a plugin, or a resource that a plugin requested.
+  ///
+  RT_OBJECT,
+
+  ///
+  // Media resource.
+  ///
+  RT_MEDIA,
+
+  ///
+  // Main resource of a dedicated worker.
+  ///
+  RT_WORKER,
+
+  ///
+  // Main resource of a shared worker.
+  ///
+  RT_SHARED_WORKER,
+
+  ///
+  // Explicitly requested prefetch.
+  ///
+  RT_PREFETCH,
+
+  ///
+  // Favicon.
+  ///
+  RT_FAVICON,
+
+  ///
+  // XMLHttpRequest.
+  ///
+  RT_XHR,
+
+  ///
+  // A request for a <ping>
+  ///
+  RT_PING,
+
+  ///
+  // Main resource of a service worker.
+  ///
+  RT_SERVICE_WORKER,
+
+  ///
+  // A report of Content Security Policy violations.
+  ///
+  RT_CSP_REPORT,
+
+  ///
+  // A resource that a plugin requested.
+  ///
+  RT_PLUGIN_RESOURCE,
+} cef_resource_type_t;
+
+///
+// Transition type for a request. Made up of one source value and 0 or more
+// qualifiers.
+///
+typedef enum {
+  ///
+  // Source is a link click or the JavaScript window.open function. This is
+  // also the default value for requests like sub-resource loads that are not
+  // navigations.
+  ///
+  TT_LINK = 0,
+
+  ///
+  // Source is some other "explicit" navigation action such as creating a new
+  // browser or using the LoadURL function. This is also the default value
+  // for navigations where the actual type is unknown.
+  ///
+  TT_EXPLICIT = 1,
+
+  ///
+  // Source is a subframe navigation. This is any content that is automatically
+  // loaded in a non-toplevel frame. For example, if a page consists of several
+  // frames containing ads, those ad URLs will have this transition type.
+  // The user may not even realize the content in these pages is a separate
+  // frame, so may not care about the URL.
+  ///
+  TT_AUTO_SUBFRAME = 3,
+
+  ///
+  // Source is a subframe navigation explicitly requested by the user that will
+  // generate new navigation entries in the back/forward list. These are
+  // probably more important than frames that were automatically loaded in
+  // the background because the user probably cares about the fact that this
+  // link was loaded.
+  ///
+  TT_MANUAL_SUBFRAME = 4,
+
+  ///
+  // Source is a form submission by the user. NOTE: In some situations
+  // submitting a form does not result in this transition type. This can happen
+  // if the form uses a script to submit the contents.
+  ///
+  TT_FORM_SUBMIT = 7,
+
+  ///
+  // Source is a "reload" of the page via the Reload function or by re-visiting
+  // the same URL. NOTE: This is distinct from the concept of whether a
+  // particular load uses "reload semantics" (i.e. bypasses cached data).
+  ///
+  TT_RELOAD = 8,
+
+  ///
+  // General mask defining the bits used for the source values.
+  ///
+  TT_SOURCE_MASK = 0xFF,
+
+  // Qualifiers.
+  // Any of the core values above can be augmented by one or more qualifiers.
+  // These qualifiers further define the transition.
+
+  ///
+  // Attempted to visit a URL but was blocked.
+  ///
+  TT_BLOCKED_FLAG = 0x00800000,
+
+  ///
+  // Used the Forward or Back function to navigate among browsing history.
+  ///
+  TT_FORWARD_BACK_FLAG = 0x01000000,
+
+  ///
+  // The beginning of a navigation chain.
+  ///
+  TT_CHAIN_START_FLAG = 0x10000000,
+
+  ///
+  // The last transition in a redirect chain.
+  ///
+  TT_CHAIN_END_FLAG = 0x20000000,
+
+  ///
+  // Redirects caused by JavaScript or a meta refresh tag on the page.
+  ///
+  TT_CLIENT_REDIRECT_FLAG = 0x40000000,
+
+  ///
+  // Redirects sent from the server by HTTP headers.
+  ///
+  TT_SERVER_REDIRECT_FLAG = 0x80000000,
+
+  ///
+  // Used to test whether a transition involves a redirect.
+  ///
+  TT_IS_REDIRECT_MASK = 0xC0000000,
+
+  ///
+  // General mask defining the bits used for the qualifiers.
+  ///
+  TT_QUALIFIER_MASK = 0xFFFFFF00,
+} cef_transition_type_t;
+
+///
+// Flags used to customize the behavior of CefURLRequest.
+///
+typedef enum {
+  ///
+  // Default behavior.
+  ///
+  UR_FLAG_NONE                      = 0,
+
+  ///
+  // If set the cache will be skipped when handling the request.
+  ///
+  UR_FLAG_SKIP_CACHE                = 1 << 0,
+
+  ///
+  // If set user name, password, and cookies may be sent with the request, and
+  // cookies may be saved from the response.
+  ///
+  UR_FLAG_ALLOW_CACHED_CREDENTIALS  = 1 << 1,
+
+  ///
+  // If set upload progress events will be generated when a request has a body.
+  ///
+  UR_FLAG_REPORT_UPLOAD_PROGRESS    = 1 << 3,
+
+  ///
+  // If set the CefURLRequestClient::OnDownloadData method will not be called.
+  ///
+  UR_FLAG_NO_DOWNLOAD_DATA          = 1 << 6,
+
+  ///
+  // If set 5XX redirect errors will be propagated to the observer instead of
+  // automatically re-tried. This currently only applies for requests
+  // originated in the browser process.
+  ///
+  UR_FLAG_NO_RETRY_ON_5XX           = 1 << 7,
+} cef_urlrequest_flags_t;
+
+///
+// Flags that represent CefURLRequest status.
+///
+typedef enum {
+  ///
+  // Unknown status.
+  ///
+  UR_UNKNOWN = 0,
+
+  ///
+  // Request succeeded.
+  ///
+  UR_SUCCESS,
+
+  ///
+  // An IO request is pending, and the caller will be informed when it is
+  // completed.
+  ///
+  UR_IO_PENDING,
+
+  ///
+  // Request was canceled programatically.
+  ///
+  UR_CANCELED,
+
+  ///
+  // Request failed for some reason.
+  ///
+  UR_FAILED,
+} cef_urlrequest_status_t;
+
+///
+// Structure representing a point.
+///
+typedef struct _cef_point_t {
+  int x;
+  int y;
+} cef_point_t;
+
+///
+// Structure representing a rectangle.
+///
+typedef struct _cef_rect_t {
+  int x;
+  int y;
+  int width;
+  int height;
+} cef_rect_t;
+
+///
+// Structure representing a size.
+///
+typedef struct _cef_size_t {
+  int width;
+  int height;
+} cef_size_t;
+
+///
+// Structure representing a draggable region.
+///
+typedef struct _cef_draggable_region_t {
+  ///
+  // Bounds of the region.
+  ///
+  cef_rect_t bounds;
+
+  ///
+  // True (1) this this region is draggable and false (0) otherwise.
+  ///
+  int draggable;
+} cef_draggable_region_t;
+
+///
+// Existing process IDs.
+///
+typedef enum {
+  ///
+  // Browser process.
+  ///
+  PID_BROWSER,
+  ///
+  // Renderer process.
+  ///
+  PID_RENDERER,
+} cef_process_id_t;
+
+///
+// Existing thread IDs.
+///
+typedef enum {
+// BROWSER PROCESS THREADS -- Only available in the browser process.
+
+  ///
+  // The main thread in the browser. This will be the same as the main
+  // application thread if CefInitialize() is called with a
+  // CefSettings.multi_threaded_message_loop value of false.
+  ///
+  TID_UI,
+
+  ///
+  // Used to interact with the database.
+  ///
+  TID_DB,
+
+  ///
+  // Used to interact with the file system.
+  ///
+  TID_FILE,
+
+  ///
+  // Used for file system operations that block user interactions.
+  // Responsiveness of this thread affects users.
+  ///
+  TID_FILE_USER_BLOCKING,
+
+  ///
+  // Used to launch and terminate browser processes.
+  ///
+  TID_PROCESS_LAUNCHER,
+
+  ///
+  // Used to handle slow HTTP cache operations.
+  ///
+  TID_CACHE,
+
+  ///
+  // Used to process IPC and network messages.
+  ///
+  TID_IO,
+
+// RENDER PROCESS THREADS -- Only available in the render process.
+
+  ///
+  // The main thread in the renderer. Used for all WebKit and V8 interaction.
+  ///
+  TID_RENDERER,
+} cef_thread_id_t;
+
+///
+// Supported value types.
+///
+typedef enum {
+  VTYPE_INVALID = 0,
+  VTYPE_NULL,
+  VTYPE_BOOL,
+  VTYPE_INT,
+  VTYPE_DOUBLE,
+  VTYPE_STRING,
+  VTYPE_BINARY,
+  VTYPE_DICTIONARY,
+  VTYPE_LIST,
+} cef_value_type_t;
+
+///
+// Supported JavaScript dialog types.
+///
+typedef enum {
+  JSDIALOGTYPE_ALERT = 0,
+  JSDIALOGTYPE_CONFIRM,
+  JSDIALOGTYPE_PROMPT,
+} cef_jsdialog_type_t;
+
+///
+// Screen information used when window rendering is disabled. This structure is
+// passed as a parameter to CefRenderHandler::GetScreenInfo and should be filled
+// in by the client.
+///
+typedef struct _cef_screen_info_t {
+  ///
+  // Device scale factor. Specifies the ratio between physical and logical
+  // pixels.
+  ///
+  float device_scale_factor;
+
+  ///
+  // The screen depth in bits per pixel.
+  ///
+  int depth;
+
+  ///
+  // The bits per color component. This assumes that the colors are balanced
+  // equally.
+  ///
+  int depth_per_component;
+
+  ///
+  // This can be true for black and white printers.
+  ///
+  int is_monochrome;
+
+  ///
+  // This is set from the rcMonitor member of MONITORINFOEX, to whit:
+  //   "A RECT structure that specifies the display monitor rectangle,
+  //   expressed in virtual-screen coordinates. Note that if the monitor
+  //   is not the primary display monitor, some of the rectangle's
+  //   coordinates may be negative values."
+  //
+  // The |rect| and |available_rect| properties are used to determine the
+  // available surface for rendering popup views.
+  ///
+  cef_rect_t rect;
+
+  ///
+  // This is set from the rcWork member of MONITORINFOEX, to whit:
+  //   "A RECT structure that specifies the work area rectangle of the
+  //   display monitor that can be used by applications, expressed in
+  //   virtual-screen coordinates. Windows uses this rectangle to
+  //   maximize an application on the monitor. The rest of the area in
+  //   rcMonitor contains system windows such as the task bar and side
+  //   bars. Note that if the monitor is not the primary display monitor,
+  //   some of the rectangle's coordinates may be negative values".
+  //
+  // The |rect| and |available_rect| properties are used to determine the
+  // available surface for rendering popup views.
+  ///
+  cef_rect_t available_rect;
+} cef_screen_info_t;
+
+///
+// Supported menu IDs. Non-English translations can be provided for the
+// IDS_MENU_* strings in CefResourceBundleHandler::GetLocalizedString().
+///
+typedef enum {
+  // Navigation.
+  MENU_ID_BACK                = 100,
+  MENU_ID_FORWARD             = 101,
+  MENU_ID_RELOAD              = 102,
+  MENU_ID_RELOAD_NOCACHE      = 103,
+  MENU_ID_STOPLOAD            = 104,
+
+  // Editing.
+  MENU_ID_UNDO                = 110,
+  MENU_ID_REDO                = 111,
+  MENU_ID_CUT                 = 112,
+  MENU_ID_COPY                = 113,
+  MENU_ID_PASTE               = 114,
+  MENU_ID_DELETE              = 115,
+  MENU_ID_SELECT_ALL          = 116,
+
+  // Miscellaneous.
+  MENU_ID_FIND                = 130,
+  MENU_ID_PRINT               = 131,
+  MENU_ID_VIEW_SOURCE         = 132,
+
+  // Spell checking word correction suggestions.
+  MENU_ID_SPELLCHECK_SUGGESTION_0        = 200,
+  MENU_ID_SPELLCHECK_SUGGESTION_1        = 201,
+  MENU_ID_SPELLCHECK_SUGGESTION_2        = 202,
+  MENU_ID_SPELLCHECK_SUGGESTION_3        = 203,
+  MENU_ID_SPELLCHECK_SUGGESTION_4        = 204,
+  MENU_ID_SPELLCHECK_SUGGESTION_LAST     = 204,
+  MENU_ID_NO_SPELLING_SUGGESTIONS        = 205,
+  MENU_ID_ADD_TO_DICTIONARY              = 206,
+
+  // Custom menu items originating from the renderer process. For example,
+  // plugin placeholder menu items or Flash menu items.
+  MENU_ID_CUSTOM_FIRST        = 220,
+  MENU_ID_CUSTOM_LAST         = 250,
+
+  // All user-defined menu IDs should come between MENU_ID_USER_FIRST and
+  // MENU_ID_USER_LAST to avoid overlapping the Chromium and CEF ID ranges
+  // defined in the tools/gritsettings/resource_ids file.
+  MENU_ID_USER_FIRST          = 26500,
+  MENU_ID_USER_LAST           = 28500,
+} cef_menu_id_t;
+
+///
+// Mouse button types.
+///
+typedef enum {
+  MBT_LEFT   = 0,
+  MBT_MIDDLE,
+  MBT_RIGHT,
+} cef_mouse_button_type_t;
+
+///
+// Structure representing mouse event information.
+///
+typedef struct _cef_mouse_event_t {
+  ///
+  // X coordinate relative to the left side of the view.
+  ///
+  int x;
+
+  ///
+  // Y coordinate relative to the top side of the view.
+  ///
+  int y;
+
+  ///
+  // Bit flags describing any pressed modifier keys. See
+  // cef_event_flags_t for values.
+  ///
+  uint32 modifiers;
+} cef_mouse_event_t;
+
+///
+// Paint element types.
+///
+typedef enum {
+  PET_VIEW  = 0,
+  PET_POPUP,
+} cef_paint_element_type_t;
+
+///
+// Supported event bit flags.
+///
+typedef enum {
+  EVENTFLAG_NONE                = 0,
+  EVENTFLAG_CAPS_LOCK_ON        = 1 << 0,
+  EVENTFLAG_SHIFT_DOWN          = 1 << 1,
+  EVENTFLAG_CONTROL_DOWN        = 1 << 2,
+  EVENTFLAG_ALT_DOWN            = 1 << 3,
+  EVENTFLAG_LEFT_MOUSE_BUTTON   = 1 << 4,
+  EVENTFLAG_MIDDLE_MOUSE_BUTTON = 1 << 5,
+  EVENTFLAG_RIGHT_MOUSE_BUTTON  = 1 << 6,
+  // Mac OS-X command key.
+  EVENTFLAG_COMMAND_DOWN        = 1 << 7,
+  EVENTFLAG_NUM_LOCK_ON         = 1 << 8,
+  EVENTFLAG_IS_KEY_PAD          = 1 << 9,
+  EVENTFLAG_IS_LEFT             = 1 << 10,
+  EVENTFLAG_IS_RIGHT            = 1 << 11,
+} cef_event_flags_t;
+
+///
+// Supported menu item types.
+///
+typedef enum {
+  MENUITEMTYPE_NONE,
+  MENUITEMTYPE_COMMAND,
+  MENUITEMTYPE_CHECK,
+  MENUITEMTYPE_RADIO,
+  MENUITEMTYPE_SEPARATOR,
+  MENUITEMTYPE_SUBMENU,
+} cef_menu_item_type_t;
+
+///
+// Supported context menu type flags.
+///
+typedef enum {
+  ///
+  // No node is selected.
+  ///
+  CM_TYPEFLAG_NONE        = 0,
+  ///
+  // The top page is selected.
+  ///
+  CM_TYPEFLAG_PAGE        = 1 << 0,
+  ///
+  // A subframe page is selected.
+  ///
+  CM_TYPEFLAG_FRAME       = 1 << 1,
+  ///
+  // A link is selected.
+  ///
+  CM_TYPEFLAG_LINK        = 1 << 2,
+  ///
+  // A media node is selected.
+  ///
+  CM_TYPEFLAG_MEDIA       = 1 << 3,
+  ///
+  // There is a textual or mixed selection that is selected.
+  ///
+  CM_TYPEFLAG_SELECTION   = 1 << 4,
+  ///
+  // An editable element is selected.
+  ///
+  CM_TYPEFLAG_EDITABLE    = 1 << 5,
+} cef_context_menu_type_flags_t;
+
+///
+// Supported context menu media types.
+///
+typedef enum {
+  ///
+  // No special node is in context.
+  ///
+  CM_MEDIATYPE_NONE,
+  ///
+  // An image node is selected.
+  ///
+  CM_MEDIATYPE_IMAGE,
+  ///
+  // A video node is selected.
+  ///
+  CM_MEDIATYPE_VIDEO,
+  ///
+  // An audio node is selected.
+  ///
+  CM_MEDIATYPE_AUDIO,
+  ///
+  // A file node is selected.
+  ///
+  CM_MEDIATYPE_FILE,
+  ///
+  // A plugin node is selected.
+  ///
+  CM_MEDIATYPE_PLUGIN,
+} cef_context_menu_media_type_t;
+
+///
+// Supported context menu media state bit flags.
+///
+typedef enum {
+  CM_MEDIAFLAG_NONE                  = 0,
+  CM_MEDIAFLAG_ERROR                 = 1 << 0,
+  CM_MEDIAFLAG_PAUSED                = 1 << 1,
+  CM_MEDIAFLAG_MUTED                 = 1 << 2,
+  CM_MEDIAFLAG_LOOP                  = 1 << 3,
+  CM_MEDIAFLAG_CAN_SAVE              = 1 << 4,
+  CM_MEDIAFLAG_HAS_AUDIO             = 1 << 5,
+  CM_MEDIAFLAG_HAS_VIDEO             = 1 << 6,
+  CM_MEDIAFLAG_CONTROL_ROOT_ELEMENT  = 1 << 7,
+  CM_MEDIAFLAG_CAN_PRINT             = 1 << 8,
+  CM_MEDIAFLAG_CAN_ROTATE            = 1 << 9,
+} cef_context_menu_media_state_flags_t;
+
+///
+// Supported context menu edit state bit flags.
+///
+typedef enum {
+  CM_EDITFLAG_NONE            = 0,
+  CM_EDITFLAG_CAN_UNDO        = 1 << 0,
+  CM_EDITFLAG_CAN_REDO        = 1 << 1,
+  CM_EDITFLAG_CAN_CUT         = 1 << 2,
+  CM_EDITFLAG_CAN_COPY        = 1 << 3,
+  CM_EDITFLAG_CAN_PASTE       = 1 << 4,
+  CM_EDITFLAG_CAN_DELETE      = 1 << 5,
+  CM_EDITFLAG_CAN_SELECT_ALL  = 1 << 6,
+  CM_EDITFLAG_CAN_TRANSLATE   = 1 << 7,
+} cef_context_menu_edit_state_flags_t;
+
+///
+// Key event types.
+///
+typedef enum {
+  ///
+  // Notification that a key transitioned from "up" to "down".
+  ///
+  KEYEVENT_RAWKEYDOWN = 0,
+
+  ///
+  // Notification that a key was pressed. This does not necessarily correspond
+  // to a character depending on the key and language. Use KEYEVENT_CHAR for
+  // character input.
+  ///
+  KEYEVENT_KEYDOWN,
+
+  ///
+  // Notification that a key was released.
+  ///
+  KEYEVENT_KEYUP,
+
+  ///
+  // Notification that a character was typed. Use this for text input. Key
+  // down events may generate 0, 1, or more than one character event depending
+  // on the key, locale, and operating system.
+  ///
+  KEYEVENT_CHAR
+} cef_key_event_type_t;
+
+///
+// Structure representing keyboard event information.
+///
+typedef struct _cef_key_event_t {
+  ///
+  // The type of keyboard event.
+  ///
+  cef_key_event_type_t type;
+
+  ///
+  // Bit flags describing any pressed modifier keys. See
+  // cef_event_flags_t for values.
+  ///
+  uint32 modifiers;
+
+  ///
+  // The Windows key code for the key event. This value is used by the DOM
+  // specification. Sometimes it comes directly from the event (i.e. on
+  // Windows) and sometimes it's determined using a mapping function. See
+  // WebCore/platform/chromium/KeyboardCodes.h for the list of values.
+  ///
+  int windows_key_code;
+
+  ///
+  // The actual key code genenerated by the platform.
+  ///
+  int native_key_code;
+
+  ///
+  // Indicates whether the event is considered a "system key" event (see
+  // http://msdn.microsoft.com/en-us/library/ms646286(VS.85).aspx for details).
+  // This value will always be false on non-Windows platforms.
+  ///
+  int is_system_key;
+
+  ///
+  // The character generated by the keystroke.
+  ///
+  char16 character;
+
+  ///
+  // Same as |character| but unmodified by any concurrently-held modifiers
+  // (except shift). This is useful for working out shortcut keys.
+  ///
+  char16 unmodified_character;
+
+  ///
+  // True if the focus is currently on an editable field on the page. This is
+  // useful for determining if standard key events should be intercepted.
+  ///
+  int focus_on_editable_field;
+} cef_key_event_t;
+
+///
+// Focus sources.
+///
+typedef enum {
+  ///
+  // The source is explicit navigation via the API (LoadURL(), etc).
+  ///
+  FOCUS_SOURCE_NAVIGATION = 0,
+  ///
+  // The source is a system-generated focus event.
+  ///
+  FOCUS_SOURCE_SYSTEM,
+} cef_focus_source_t;
+
+///
+// Navigation types.
+///
+typedef enum {
+  NAVIGATION_LINK_CLICKED = 0,
+  NAVIGATION_FORM_SUBMITTED,
+  NAVIGATION_BACK_FORWARD,
+  NAVIGATION_RELOAD,
+  NAVIGATION_FORM_RESUBMITTED,
+  NAVIGATION_OTHER,
+} cef_navigation_type_t;
+
+///
+// Supported XML encoding types. The parser supports ASCII, ISO-8859-1, and
+// UTF16 (LE and BE) by default. All other types must be translated to UTF8
+// before being passed to the parser. If a BOM is detected and the correct
+// decoder is available then that decoder will be used automatically.
+///
+typedef enum {
+  XML_ENCODING_NONE = 0,
+  XML_ENCODING_UTF8,
+  XML_ENCODING_UTF16LE,
+  XML_ENCODING_UTF16BE,
+  XML_ENCODING_ASCII,
+} cef_xml_encoding_type_t;
+
+///
+// XML node types.
+///
+typedef enum {
+  XML_NODE_UNSUPPORTED = 0,
+  XML_NODE_PROCESSING_INSTRUCTION,
+  XML_NODE_DOCUMENT_TYPE,
+  XML_NODE_ELEMENT_START,
+  XML_NODE_ELEMENT_END,
+  XML_NODE_ATTRIBUTE,
+  XML_NODE_TEXT,
+  XML_NODE_CDATA,
+  XML_NODE_ENTITY_REFERENCE,
+  XML_NODE_WHITESPACE,
+  XML_NODE_COMMENT,
+} cef_xml_node_type_t;
+
+///
+// Popup window features.
+///
+typedef struct _cef_popup_features_t {
+  int x;
+  int xSet;
+  int y;
+  int ySet;
+  int width;
+  int widthSet;
+  int height;
+  int heightSet;
+
+  int menuBarVisible;
+  int statusBarVisible;
+  int toolBarVisible;
+  int locationBarVisible;
+  int scrollbarsVisible;
+  int resizable;
+
+  int fullscreen;
+  int dialog;
+  cef_string_list_t additionalFeatures;
+} cef_popup_features_t;
+
+///
+// DOM document types.
+///
+typedef enum {
+  DOM_DOCUMENT_TYPE_UNKNOWN = 0,
+  DOM_DOCUMENT_TYPE_HTML,
+  DOM_DOCUMENT_TYPE_XHTML,
+  DOM_DOCUMENT_TYPE_PLUGIN,
+} cef_dom_document_type_t;
+
+///
+// DOM event category flags.
+///
+typedef enum {
+  DOM_EVENT_CATEGORY_UNKNOWN = 0x0,
+  DOM_EVENT_CATEGORY_UI = 0x1,
+  DOM_EVENT_CATEGORY_MOUSE = 0x2,
+  DOM_EVENT_CATEGORY_MUTATION = 0x4,
+  DOM_EVENT_CATEGORY_KEYBOARD = 0x8,
+  DOM_EVENT_CATEGORY_TEXT = 0x10,
+  DOM_EVENT_CATEGORY_COMPOSITION = 0x20,
+  DOM_EVENT_CATEGORY_DRAG = 0x40,
+  DOM_EVENT_CATEGORY_CLIPBOARD = 0x80,
+  DOM_EVENT_CATEGORY_MESSAGE = 0x100,
+  DOM_EVENT_CATEGORY_WHEEL = 0x200,
+  DOM_EVENT_CATEGORY_BEFORE_TEXT_INSERTED = 0x400,
+  DOM_EVENT_CATEGORY_OVERFLOW = 0x800,
+  DOM_EVENT_CATEGORY_PAGE_TRANSITION = 0x1000,
+  DOM_EVENT_CATEGORY_POPSTATE = 0x2000,
+  DOM_EVENT_CATEGORY_PROGRESS = 0x4000,
+  DOM_EVENT_CATEGORY_XMLHTTPREQUEST_PROGRESS = 0x8000,
+} cef_dom_event_category_t;
+
+///
+// DOM event processing phases.
+///
+typedef enum {
+  DOM_EVENT_PHASE_UNKNOWN = 0,
+  DOM_EVENT_PHASE_CAPTURING,
+  DOM_EVENT_PHASE_AT_TARGET,
+  DOM_EVENT_PHASE_BUBBLING,
+} cef_dom_event_phase_t;
+
+///
+// DOM node types.
+///
+typedef enum {
+  DOM_NODE_TYPE_UNSUPPORTED = 0,
+  DOM_NODE_TYPE_ELEMENT,
+  DOM_NODE_TYPE_ATTRIBUTE,
+  DOM_NODE_TYPE_TEXT,
+  DOM_NODE_TYPE_CDATA_SECTION,
+  DOM_NODE_TYPE_PROCESSING_INSTRUCTIONS,
+  DOM_NODE_TYPE_COMMENT,
+  DOM_NODE_TYPE_DOCUMENT,
+  DOM_NODE_TYPE_DOCUMENT_TYPE,
+  DOM_NODE_TYPE_DOCUMENT_FRAGMENT,
+} cef_dom_node_type_t;
+
+///
+// Supported file dialog modes.
+///
+typedef enum {
+  ///
+  // Requires that the file exists before allowing the user to pick it.
+  ///
+  FILE_DIALOG_OPEN = 0,
+
+  ///
+  // Like Open, but allows picking multiple files to open.
+  ///
+  FILE_DIALOG_OPEN_MULTIPLE,
+
+  ///
+  // Like Open, but selects a folder to open.
+  ///
+  FILE_DIALOG_OPEN_FOLDER,
+
+  ///
+  // Allows picking a nonexistent file, and prompts to overwrite if the file
+  // already exists.
+  ///
+  FILE_DIALOG_SAVE,
+
+  ///
+  // General mask defining the bits used for the type values.
+  ///
+  FILE_DIALOG_TYPE_MASK = 0xFF,
+
+  // Qualifiers.
+  // Any of the type values above can be augmented by one or more qualifiers.
+  // These qualifiers further define the dialog behavior.
+
+  ///
+  // Prompt to overwrite if the user selects an existing file with the Save
+  // dialog.
+  ///
+  FILE_DIALOG_OVERWRITEPROMPT_FLAG = 0x01000000,
+
+  ///
+  // Do not display read-only files.
+  ///
+  FILE_DIALOG_HIDEREADONLY_FLAG = 0x02000000,
+} cef_file_dialog_mode_t;
+
+///
+// Geoposition error codes.
+///
+typedef enum {
+  GEOPOSITON_ERROR_NONE = 0,
+  GEOPOSITON_ERROR_PERMISSION_DENIED,
+  GEOPOSITON_ERROR_POSITION_UNAVAILABLE,
+  GEOPOSITON_ERROR_TIMEOUT,
+} cef_geoposition_error_code_t;
+
+///
+// Structure representing geoposition information. The properties of this
+// structure correspond to those of the JavaScript Position object although
+// their types may differ.
+///
+typedef struct _cef_geoposition_t {
+  ///
+  // Latitude in decimal degrees north (WGS84 coordinate frame).
+  ///
+  double latitude;
+
+  ///
+  // Longitude in decimal degrees west (WGS84 coordinate frame).
+  ///
+  double longitude;
+
+  ///
+  // Altitude in meters (above WGS84 datum).
+  ///
+  double altitude;
+
+  ///
+  // Accuracy of horizontal position in meters.
+  ///
+  double accuracy;
+
+  ///
+  // Accuracy of altitude in meters.
+  ///
+  double altitude_accuracy;
+
+  ///
+  // Heading in decimal degrees clockwise from true north.
+  ///
+  double heading;
+
+  ///
+  // Horizontal component of device velocity in meters per second.
+  ///
+  double speed;
+
+  ///
+  // Time of position measurement in milliseconds since Epoch in UTC time. This
+  // is taken from the host computer's system clock.
+  ///
+  cef_time_t timestamp;
+
+  ///
+  // Error code, see enum above.
+  ///
+  cef_geoposition_error_code_t error_code;
+
+  ///
+  // Human-readable error message.
+  ///
+  cef_string_t error_message;
+} cef_geoposition_t;
+
+///
+// Print job color mode values.
+///
+typedef enum {
+  COLOR_MODEL_UNKNOWN,
+  COLOR_MODEL_GRAY,
+  COLOR_MODEL_COLOR,
+  COLOR_MODEL_CMYK,
+  COLOR_MODEL_CMY,
+  COLOR_MODEL_KCMY,
+  COLOR_MODEL_CMY_K,  // CMY_K represents CMY+K.
+  COLOR_MODEL_BLACK,
+  COLOR_MODEL_GRAYSCALE,
+  COLOR_MODEL_RGB,
+  COLOR_MODEL_RGB16,
+  COLOR_MODEL_RGBA,
+  COLOR_MODEL_COLORMODE_COLOR,  // Used in samsung printer ppds.
+  COLOR_MODEL_COLORMODE_MONOCHROME,  // Used in samsung printer ppds.
+  COLOR_MODEL_HP_COLOR_COLOR,  // Used in HP color printer ppds.
+  COLOR_MODEL_HP_COLOR_BLACK,  // Used in HP color printer ppds.
+  COLOR_MODEL_PRINTOUTMODE_NORMAL,  // Used in foomatic ppds.
+  COLOR_MODEL_PRINTOUTMODE_NORMAL_GRAY,  // Used in foomatic ppds.
+  COLOR_MODEL_PROCESSCOLORMODEL_CMYK,  // Used in canon printer ppds.
+  COLOR_MODEL_PROCESSCOLORMODEL_GREYSCALE,  // Used in canon printer ppds.
+  COLOR_MODEL_PROCESSCOLORMODEL_RGB,  // Used in canon printer ppds
+} cef_color_model_t;
+
+///
+// Print job duplex mode values.
+///
+typedef enum {
+  DUPLEX_MODE_UNKNOWN = -1,
+  DUPLEX_MODE_SIMPLEX,
+  DUPLEX_MODE_LONG_EDGE,
+  DUPLEX_MODE_SHORT_EDGE,
+} cef_duplex_mode_t;
+
+///
+// Structure representing a print job page range.
+///
+typedef struct _cef_page_range_t {
+  int from;
+  int to;
+} cef_page_range_t;
+
+///
+// Cursor type values.
+///
+typedef enum {
+  CT_POINTER = 0,
+  CT_CROSS,
+  CT_HAND,
+  CT_IBEAM,
+  CT_WAIT,
+  CT_HELP,
+  CT_EASTRESIZE,
+  CT_NORTHRESIZE,
+  CT_NORTHEASTRESIZE,
+  CT_NORTHWESTRESIZE,
+  CT_SOUTHRESIZE,
+  CT_SOUTHEASTRESIZE,
+  CT_SOUTHWESTRESIZE,
+  CT_WESTRESIZE,
+  CT_NORTHSOUTHRESIZE,
+  CT_EASTWESTRESIZE,
+  CT_NORTHEASTSOUTHWESTRESIZE,
+  CT_NORTHWESTSOUTHEASTRESIZE,
+  CT_COLUMNRESIZE,
+  CT_ROWRESIZE,
+  CT_MIDDLEPANNING,
+  CT_EASTPANNING,
+  CT_NORTHPANNING,
+  CT_NORTHEASTPANNING,
+  CT_NORTHWESTPANNING,
+  CT_SOUTHPANNING,
+  CT_SOUTHEASTPANNING,
+  CT_SOUTHWESTPANNING,
+  CT_WESTPANNING,
+  CT_MOVE,
+  CT_VERTICALTEXT,
+  CT_CELL,
+  CT_CONTEXTMENU,
+  CT_ALIAS,
+  CT_PROGRESS,
+  CT_NODROP,
+  CT_COPY,
+  CT_NONE,
+  CT_NOTALLOWED,
+  CT_ZOOMIN,
+  CT_ZOOMOUT,
+  CT_GRAB,
+  CT_GRABBING,
+  CT_CUSTOM,
+} cef_cursor_type_t;
+
+///
+// Structure representing cursor information. |buffer| will be
+// |size.width|*|size.height|*4 bytes in size and represents a BGRA image with
+// an upper-left origin.
+///
+typedef struct _cef_cursor_info_t {
+  cef_point_t hotspot;
+  float image_scale_factor;
+  void* buffer;
+  cef_size_t size;
+} cef_cursor_info_t;
+
+///
+// URI unescape rules passed to CefURIDecode().
+///
+typedef enum {
+  ///
+  // Don't unescape anything at all.
+  ///
+  UU_NONE = 0,
+
+  ///
+  // Don't unescape anything special, but all normal unescaping will happen.
+  // This is a placeholder and can't be combined with other flags (since it's
+  // just the absence of them). All other unescape rules imply "normal" in
+  // addition to their special meaning. Things like escaped letters, digits,
+  // and most symbols will get unescaped with this mode.
+  ///
+  UU_NORMAL = 1,
+
+  ///
+  // Convert %20 to spaces. In some places where we're showing URLs, we may
+  // want this. In places where the URL may be copied and pasted out, then
+  // you wouldn't want this since it might not be interpreted in one piece
+  // by other applications.
+  ///
+  UU_SPACES = 2,
+
+  ///
+  // Unescapes various characters that will change the meaning of URLs,
+  // including '%', '+', '&', '/', '#'. If we unescaped these characters, the
+  // resulting URL won't be the same as the source one. This flag is used when
+  // generating final output like filenames for URLs where we won't be
+  // interpreting as a URL and want to do as much unescaping as possible.
+  ///
+  UU_URL_SPECIAL_CHARS = 4,
+
+  ///
+  // Unescapes control characters such as %01. This INCLUDES NULLs. This is
+  // used for rare cases such as data: URL decoding where the result is binary
+  // data. This flag also unescapes BiDi control characters.
+  //
+  // DO NOT use CONTROL_CHARS if the URL is going to be displayed in the UI
+  // for security reasons.
+  ///
+  UU_CONTROL_CHARS = 8,
+
+  ///
+  // URL queries use "+" for space. This flag controls that replacement.
+  ///
+  UU_REPLACE_PLUS_WITH_SPACE = 16,
+} cef_uri_unescape_rule_t;
+
+///
+// Options that can be passed to CefParseJSON.
+///
+typedef enum {
+  ///
+  // Parses the input strictly according to RFC 4627. See comments in Chromium's
+  // base/json/json_reader.h file for known limitations/deviations from the RFC.
+  ///
+  JSON_PARSER_RFC = 0,
+
+  ///
+  // Allows commas to exist after the last element in structures.
+  ///
+  JSON_PARSER_ALLOW_TRAILING_COMMAS = 1 << 0,
+} cef_json_parser_options_t;
+
+///
+// Error codes that can be returned from CefParseJSONAndReturnError.
+///
+typedef enum {
+  JSON_NO_ERROR = 0,
+  JSON_INVALID_ESCAPE,
+  JSON_SYNTAX_ERROR,
+  JSON_UNEXPECTED_TOKEN,
+  JSON_TRAILING_COMMA,
+  JSON_TOO_MUCH_NESTING,
+  JSON_UNEXPECTED_DATA_AFTER_ROOT,
+  JSON_UNSUPPORTED_ENCODING,
+  JSON_UNQUOTED_DICTIONARY_KEY,
+  JSON_PARSE_ERROR_COUNT
+} cef_json_parser_error_t;
+
+///
+// Options that can be passed to CefWriteJSON.
+///
+typedef enum {
+  ///
+  // Default behavior.
+  ///
+  JSON_WRITER_DEFAULT = 0,
+
+  ///
+  // This option instructs the writer that if a Binary value is encountered,
+  // the value (and key if within a dictionary) will be omitted from the
+  // output, and success will be returned. Otherwise, if a binary value is
+  // encountered, failure will be returned.
+  ///
+  JSON_WRITER_OMIT_BINARY_VALUES = 1 << 0,
+
+  ///
+  // This option instructs the writer to write doubles that have no fractional
+  // part as a normal integer (i.e., without using exponential notation
+  // or appending a '.0') as long as the value is within the range of a
+  // 64-bit int.
+  ///
+  JSON_WRITER_OMIT_DOUBLE_TYPE_PRESERVATION = 1 << 1,
+
+  ///
+  // Return a slightly nicer formatted json string (pads with whitespace to
+  // help with readability).
+  ///
+  JSON_WRITER_PRETTY_PRINT = 1 << 2,
+} cef_json_writer_options_t;
+
+///
+// Margin type for PDF printing.
+///
+typedef enum {
+  ///
+  // Default margins.
+  ///
+  PDF_PRINT_MARGIN_DEFAULT,
+
+  ///
+  // No margins.
+  ///
+  PDF_PRINT_MARGIN_NONE,
+
+  ///
+  // Minimum margins.
+  ///
+  PDF_PRINT_MARGIN_MINIMUM,
+
+  ///
+  // Custom margins using the |margin_*| values from cef_pdf_print_settings_t.
+  ///
+  PDF_PRINT_MARGIN_CUSTOM,
+} cef_pdf_print_margin_type_t;
+
+///
+// Structure representing PDF print settings.
+///
+typedef struct _cef_pdf_print_settings_t {
+  ///
+  // Page title to display in the header. Only used if |header_footer_enabled|
+  // is set to true (1).
+  ///
+  cef_string_t header_footer_title;
+
+  ///
+  // URL to display in the footer. Only used if |header_footer_enabled| is set
+  // to true (1).
+  ///
+  cef_string_t header_footer_url;
+
+  ///
+  // Output page size in microns. If either of these values is less than or
+  // equal to zero then the default paper size (A4) will be used.
+  ///
+  int page_width;
+  int page_height;
+
+  ///
+  // Margins in millimeters. Only used if |margin_type| is set to
+  // PDF_PRINT_MARGIN_CUSTOM.
+  ///
+  double margin_top;
+  double margin_right;
+  double margin_bottom;
+  double margin_left;
+
+  ///
+  // Margin type.
+  ///
+  cef_pdf_print_margin_type_t margin_type;
+
+  ///
+  // Set to true (1) to print headers and footers or false (0) to not print
+  // headers and footers.
+  ///
+  int header_footer_enabled;
+
+  ///
+  // Set to true (1) to print the selection only or false (0) to print all.
+  ///
+  int selection_only;
+
+  ///
+  // Set to true (1) for landscape mode or false (0) for portrait mode.
+  ///
+  int landscape;
+
+  ///
+  // Set to true (1) to print background graphics or false (0) to not print
+  // background graphics.
+  ///
+  int backgrounds_enabled;
+
+} cef_pdf_print_settings_t;
+
+///
+// Supported UI scale factors for the platform. SCALE_FACTOR_NONE is used for
+// density independent resources such as string, html/js files or an image that
+// can be used for any scale factors (such as wallpapers).
+///
+typedef enum {
+  SCALE_FACTOR_NONE = 0,
+  SCALE_FACTOR_100P,
+  SCALE_FACTOR_125P,
+  SCALE_FACTOR_133P,
+  SCALE_FACTOR_140P,
+  SCALE_FACTOR_150P,
+  SCALE_FACTOR_180P,
+  SCALE_FACTOR_200P,
+  SCALE_FACTOR_250P,
+  SCALE_FACTOR_300P,
+} cef_scale_factor_t;
+
+///
+// Plugin policies supported by CefRequestContextHandler::OnBeforePluginLoad.
+///
+typedef enum {
+  ///
+  // Allow the content.
+  ///
+  PLUGIN_POLICY_ALLOW,
+
+  ///
+  // Allow important content and block unimportant content based on heuristics.
+  // The user can manually load blocked content.
+  ///
+  PLUGIN_POLICY_DETECT_IMPORTANT,
+
+  ///
+  // Block the content. The user can manually load blocked content.
+  ///
+  PLUGIN_POLICY_BLOCK,
+
+  ///
+  // Disable the content. The user cannot load disabled content.
+  ///
+  PLUGIN_POLICY_DISABLE,
+} cef_plugin_policy_t;
+
+///
+// Policy for how the Referrer HTTP header value will be sent during navigation.
+// If the `--no-referrers` command-line flag is specified then the policy value
+// will be ignored and the Referrer value will never be sent.
+///
+typedef enum {
+  ///
+  // Always send the complete Referrer value.
+  ///
+  REFERRER_POLICY_ALWAYS,
+
+  ///
+  // Use the default policy. This is REFERRER_POLICY_ORIGIN_WHEN_CROSS_ORIGIN
+  // when the `--reduced-referrer-granularity` command-line flag is specified
+  // and REFERRER_POLICY_NO_REFERRER_WHEN_DOWNGRADE otherwise.
+  //
+  ///
+  REFERRER_POLICY_DEFAULT,
+
+  ///
+  // When navigating from HTTPS to HTTP do not send the Referrer value.
+  // Otherwise, send the complete Referrer value.
+  ///
+  REFERRER_POLICY_NO_REFERRER_WHEN_DOWNGRADE,
+
+  ///
+  // Never send the Referrer value.
+  ///
+  REFERRER_POLICY_NEVER,
+
+  ///
+  // Only send the origin component of the Referrer value.
+  ///
+  REFERRER_POLICY_ORIGIN,
+
+  ///
+  // When navigating cross-origin only send the origin component of the Referrer
+  // value. Otherwise, send the complete Referrer value.
+  ///
+  REFERRER_POLICY_ORIGIN_WHEN_CROSS_ORIGIN,
+} cef_referrer_policy_t;
+
+///
+// Return values for CefResponseFilter::Filter().
+///
+typedef enum {
+  ///
+  // Some or all of the pre-filter data was read successfully but more data is
+  // needed in order to continue filtering (filtered output is pending).
+  ///
+  RESPONSE_FILTER_NEED_MORE_DATA,
+
+  ///
+  // Some or all of the pre-filter data was read successfully and all available
+  // filtered output has been written.
+  ///
+  RESPONSE_FILTER_DONE,
+
+  ///
+  // An error occurred during filtering.
+  ///
+  RESPONSE_FILTER_ERROR
+} cef_response_filter_status_t;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_INTERNAL_CEF_TYPES_H_
diff --git a/src/include/libcef_/internal/cef_types_win.h b/src/include/libcef_/internal/cef_types_win.h
new file mode 100644
index 0000000..2a0bd10
--- /dev/null
+++ b/src/include/libcef_/internal/cef_types_win.h
@@ -0,0 +1,109 @@
+// Copyright (c) 2009 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+#ifndef CEF_INCLUDE_INTERNAL_CEF_TYPES_WIN_H_
+#define CEF_INCLUDE_INTERNAL_CEF_TYPES_WIN_H_
+#pragma once
+
+#include"libcef/base/cef_build.h"
+
+#if defined(OS_WIN)
+#include<windows.h>
+#include"libcef/internal/cef_string.h"
+
+// Handle types.
+#define cef_cursor_handle_t HCURSOR
+#define cef_event_handle_t MSG*
+#define cef_window_handle_t HWND
+#define cef_text_input_context_t void*
+
+#define kNullCursorHandle NULL
+#define kNullEventHandle NULL
+#define kNullWindowHandle NULL
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///
+// Structure representing CefExecuteProcess arguments.
+///
+typedef struct _cef_main_args_t {
+  HINSTANCE instance;
+} cef_main_args_t;
+
+///
+// Structure representing window information.
+///
+typedef struct _cef_window_info_t {
+  // Standard parameters required by CreateWindowEx()
+  DWORD ex_style;
+  cef_string_t window_name;
+  DWORD style;
+  int x;
+  int y;
+  int width;
+  int height;
+  cef_window_handle_t parent_window;
+  HMENU menu;
+
+  ///
+  // Set to true (1) to create the browser using windowless (off-screen)
+  // rendering. No window will be created for the browser and all rendering will
+  // occur via the CefRenderHandler interface. The |parent_window| value will be
+  // used to identify monitor info and to act as the parent window for dialogs,
+  // context menus, etc. If |parent_window| is not provided then the main screen
+  // monitor will be used and some functionality that requires a parent window
+  // may not function correctly. In order to create windowless browsers the
+  // CefSettings.windowless_rendering_enabled value must be set to true.
+  ///
+  int windowless_rendering_enabled;
+
+  ///
+  // Set to true (1) to enable transparent painting in combination with
+  // windowless rendering. When this value is true a transparent background
+  // color will be used (RGBA=0x00000000). When this value is false the
+  // background will be white and opaque.
+  ///
+  int transparent_painting_enabled;
+
+  ///
+  // Handle for the new browser window. Only used with windowed rendering.
+  ///
+  cef_window_handle_t window;
+} cef_window_info_t;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // OS_WIN
+
+#endif  // CEF_INCLUDE_INTERNAL_CEF_TYPES_WIN_H_
diff --git a/src/include/libcef_/internal/cef_types_wrappers.h b/src/include/libcef_/internal/cef_types_wrappers.h
new file mode 100644
index 0000000..107e6b8
--- /dev/null
+++ b/src/include/libcef_/internal/cef_types_wrappers.h
@@ -0,0 +1,906 @@
+// Copyright (c) 2013 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef CEF_INCLUDE_INTERNAL_CEF_TYPES_WRAPPERS_H_
+#define CEF_INCLUDE_INTERNAL_CEF_TYPES_WRAPPERS_H_
+#pragma once
+
+#include"libcef/internal/cef_string.h"
+#include"libcef/internal/cef_string_list.h"
+#include"libcef/internal/cef_types.h"
+
+///
+// Template class that provides common functionality for CEF structure wrapping.
+///
+template <class traits>
+class CefStructBase : public traits::struct_type {
+ public:
+  typedef typename traits::struct_type struct_type;
+
+  CefStructBase() : attached_to_(NULL) {
+    Init();
+  }
+  virtual ~CefStructBase() {
+    // Only clear this object's data if it isn't currently attached to a
+    // structure.
+    if (!attached_to_)
+      Clear(this);
+  }
+
+  CefStructBase(const CefStructBase& r) {
+    Init();
+    *this = r;
+  }
+  CefStructBase(const struct_type& r) {  // NOLINT(runtime/explicit)
+    Init();
+    *this = r;
+  }
+
+  ///
+  // Clear this object's values.
+  ///
+  void Reset() {
+    Clear(this);
+    Init();
+  }
+
+  ///
+  // Attach to the source structure's existing values. DetachTo() can be called
+  // to insert the values back into the existing structure.
+  ///
+  void AttachTo(struct_type& source) {
+    // Only clear this object's data if it isn't currently attached to a
+    // structure.
+    if (!attached_to_)
+      Clear(this);
+
+    // This object is now attached to the new structure.
+    attached_to_ = &source;
+
+    // Transfer ownership of the values from the source structure.
+    memcpy(static_cast<struct_type*>(this), &source, sizeof(struct_type));
+  }
+
+  ///
+  // Relinquish ownership of values to the target structure.
+  ///
+  void DetachTo(struct_type& target) {
+    if (attached_to_ != &target) {
+      // Clear the target structure's values only if we are not currently
+      // attached to that structure.
+      Clear(&target);
+    }
+
+    // Transfer ownership of the values to the target structure.
+    memcpy(&target, static_cast<struct_type*>(this), sizeof(struct_type));
+
+    // Remove the references from this object.
+    Init();
+  }
+
+  ///
+  // Set this object's values. If |copy| is true the source structure's values
+  // will be copied instead of referenced.
+  ///
+  void Set(const struct_type& source, bool copy) {
+    traits::set(&source, this, copy);
+  }
+
+  CefStructBase& operator=(const CefStructBase& s) {
+    return operator=(static_cast<const struct_type&>(s));
+  }
+
+  CefStructBase& operator=(const struct_type& s) {
+    Set(s, true);
+    return *this;
+  }
+
+ protected:
+  void Init() {
+    memset(static_cast<struct_type*>(this), 0, sizeof(struct_type));
+    attached_to_ = NULL;
+    traits::init(this);
+  }
+
+  static void Clear(struct_type* s) { traits::clear(s); }
+
+  struct_type* attached_to_;
+};
+
+
+struct CefPointTraits {
+  typedef cef_point_t struct_type;
+
+  static inline void init(struct_type* s) {}
+  static inline void clear(struct_type* s) {}
+
+  static inline void set(const struct_type* src, struct_type* target,
+      bool copy) {
+    *target = *src;
+  }
+};
+
+///
+// Class representing a point.
+///
+class CefPoint : public CefStructBase<CefPointTraits> {
+ public:
+  typedef CefStructBase<CefPointTraits> parent;
+
+  CefPoint() : parent() {}
+  CefPoint(const cef_point_t& r) : parent(r) {}  // NOLINT(runtime/explicit)
+  CefPoint(const CefPoint& r) : parent(r) {}  // NOLINT(runtime/explicit)
+  CefPoint(int x, int y) : parent() {
+    Set(x, y);
+  }
+
+  bool IsEmpty() const { return x <= 0 && y <= 0; }
+  void Set(int x_val, int y_val) {
+    x = x_val, y = y_val;
+  }
+};
+
+inline bool operator==(const CefPoint& a, const CefPoint& b) {
+  return a.x == b.x && a.y == b.y;
+}
+
+inline bool operator!=(const CefPoint& a, const CefPoint& b) {
+  return !(a == b);
+}
+
+
+struct CefRectTraits {
+  typedef cef_rect_t struct_type;
+
+  static inline void init(struct_type* s) {}
+  static inline void clear(struct_type* s) {}
+
+  static inline void set(const struct_type* src, struct_type* target,
+      bool copy) {
+    *target = *src;
+  }
+};
+
+///
+// Class representing a rectangle.
+///
+class CefRect : public CefStructBase<CefRectTraits> {
+ public:
+  typedef CefStructBase<CefRectTraits> parent;
+
+  CefRect() : parent() {}
+  CefRect(const cef_rect_t& r) : parent(r) {}  // NOLINT(runtime/explicit)
+  CefRect(const CefRect& r) : parent(r) {}  // NOLINT(runtime/explicit)
+  CefRect(int x, int y, int width, int height) : parent() {
+    Set(x, y, width, height);
+  }
+
+  bool IsEmpty() const { return width <= 0 || height <= 0; }
+  void Set(int x_val, int y_val, int width_val, int height_val) {
+    x = x_val, y = y_val, width = width_val, height = height_val;
+  }
+};
+
+inline bool operator==(const CefRect& a, const CefRect& b) {
+  return a.x == b.x && a.y == b.y && a.width == b.width && a.height == b.height;
+}
+
+inline bool operator!=(const CefRect& a, const CefRect& b) {
+  return !(a == b);
+}
+
+
+struct CefSizeTraits {
+  typedef cef_size_t struct_type;
+
+  static inline void init(struct_type* s) {}
+  static inline void clear(struct_type* s) {}
+
+  static inline void set(const struct_type* src, struct_type* target,
+      bool copy) {
+    *target = *src;
+  }
+};
+
+///
+// Class representing a size.
+///
+class CefSize : public CefStructBase<CefSizeTraits> {
+ public:
+  typedef CefStructBase<CefSizeTraits> parent;
+
+  CefSize() : parent() {}
+  CefSize(const cef_size_t& r) : parent(r) {}  // NOLINT(runtime/explicit)
+  CefSize(const CefSize& r) : parent(r) {}  // NOLINT(runtime/explicit)
+  CefSize(int width, int height) : parent() {
+    Set(width, height);
+  }
+
+  bool IsEmpty() const { return width <= 0 || height <= 0; }
+  void Set(int width_val, int height_val) {
+    width = width_val, height = height_val;
+  }
+};
+
+inline bool operator==(const CefSize& a, const CefSize& b) {
+  return a.width == b.width && a.height == b.height;
+}
+
+inline bool operator!=(const CefSize& a, const CefSize& b) {
+  return !(a == b);
+}
+
+
+struct CefDraggableRegionTraits {
+  typedef cef_draggable_region_t struct_type;
+
+  static inline void init(struct_type* s) {}
+  static inline void clear(struct_type* s) {}
+
+  static inline void set(const struct_type* src, struct_type* target,
+      bool copy) {
+    *target = *src;
+  }
+};
+
+///
+// Class representing a draggable region.
+///
+class CefDraggableRegion : public CefStructBase<CefDraggableRegionTraits> {
+ public:
+  typedef CefStructBase<CefDraggableRegionTraits> parent;
+
+  CefDraggableRegion() : parent() {}
+  CefDraggableRegion(const cef_draggable_region_t& r)  // NOLINT(runtime/explicit)
+    : parent(r) {}
+  CefDraggableRegion(const CefDraggableRegion& r)  // NOLINT(runtime/explicit)
+    : parent(r) {}
+  CefDraggableRegion(const CefRect& bounds, bool draggable) : parent() {
+    Set(bounds, draggable);
+  }
+
+  void Set(const CefRect& bounds_val, bool draggable_val) {
+    bounds = bounds_val, draggable = draggable_val;
+  }
+};
+
+inline bool operator==(const CefDraggableRegion& a,
+    const CefDraggableRegion& b) {
+  return a.bounds == b.bounds && a.draggable == b.draggable;
+}
+
+inline bool operator!=(const CefDraggableRegion& a,
+    const CefDraggableRegion& b) {
+  return !(a == b);
+}
+
+
+struct CefScreenInfoTraits {
+  typedef cef_screen_info_t struct_type;
+
+  static inline void init(struct_type* s) {}
+
+  static inline void clear(struct_type* s) {}
+
+  static inline void set(const struct_type* src, struct_type* target,
+      bool copy) {
+    target->device_scale_factor = src->device_scale_factor;
+    target->depth = src->depth;
+    target->depth_per_component = src->depth_per_component;
+    target->is_monochrome = src->is_monochrome;
+    target->rect = src->rect;
+    target->available_rect = src->available_rect;
+  }
+};
+
+///
+// Class representing the virtual screen information for use when window
+// rendering is disabled.
+///
+class CefScreenInfo : public CefStructBase<CefScreenInfoTraits> {
+ public:
+  typedef CefStructBase<CefScreenInfoTraits> parent;
+
+  CefScreenInfo() : parent() {}
+  CefScreenInfo(const cef_screen_info_t& r) : parent(r) {}  // NOLINT(runtime/explicit)
+  CefScreenInfo(const CefScreenInfo& r) : parent(r) {}  // NOLINT(runtime/explicit)
+  CefScreenInfo(float device_scale_factor,
+                int depth,
+                int depth_per_component,
+                bool is_monochrome,
+                const CefRect& rect,
+                const CefRect& available_rect) : parent() {
+    Set(device_scale_factor, depth, depth_per_component,
+        is_monochrome, rect, available_rect);
+  }
+
+  void Set(float device_scale_factor_val,
+           int depth_val,
+           int depth_per_component_val,
+           bool is_monochrome_val,
+           const CefRect& rect_val,
+           const CefRect& available_rect_val) {
+    device_scale_factor = device_scale_factor_val;
+    depth = depth_val;
+    depth_per_component = depth_per_component_val;
+    is_monochrome = is_monochrome_val;
+    rect = rect_val;
+    available_rect = available_rect_val;
+  }
+};
+
+
+struct CefKeyEventTraits {
+  typedef cef_key_event_t struct_type;
+
+  static inline void init(struct_type* s) {}
+
+  static inline void clear(struct_type* s) {}
+
+  static inline void set(const struct_type* src, struct_type* target,
+      bool copy) {
+    target->type = src->type;
+    target->modifiers = src->modifiers;
+    target->windows_key_code = src->windows_key_code;
+    target->native_key_code = src->native_key_code;
+    target->is_system_key = src->is_system_key;
+    target->character = src->character;
+    target->unmodified_character = src->unmodified_character;
+    target->focus_on_editable_field = src->focus_on_editable_field;
+  }
+};
+
+///
+// Class representing a a keyboard event.
+///
+typedef CefStructBase<CefKeyEventTraits> CefKeyEvent;
+
+
+struct CefMouseEventTraits {
+  typedef cef_mouse_event_t struct_type;
+
+  static inline void init(struct_type* s) {}
+
+  static inline void clear(struct_type* s) {}
+
+  static inline void set(const struct_type* src, struct_type* target,
+      bool copy) {
+    target->x = src->x;
+    target->y = src->y;
+    target->modifiers = src->modifiers;
+  }
+};
+
+///
+// Class representing a mouse event.
+///
+typedef CefStructBase<CefMouseEventTraits> CefMouseEvent;
+
+
+struct CefPopupFeaturesTraits {
+  typedef cef_popup_features_t struct_type;
+
+  static inline void init(struct_type* s) {
+    s->menuBarVisible = true;
+    s->statusBarVisible = true;
+    s->toolBarVisible = true;
+    s->locationBarVisible = true;
+    s->scrollbarsVisible = true;
+    s->resizable = true;
+  }
+
+  static inline void clear(struct_type* s) {
+    if (s->additionalFeatures)
+      cef_string_list_free(s->additionalFeatures);
+  }
+
+  static inline void set(const struct_type* src, struct_type* target,
+      bool copy) {
+    if (target->additionalFeatures)
+      cef_string_list_free(target->additionalFeatures);
+    target->additionalFeatures = src->additionalFeatures ?
+        cef_string_list_copy(src->additionalFeatures) : NULL;
+
+    target->x = src->x;
+    target->xSet = src->xSet;
+    target->y = src->y;
+    target->ySet = src->ySet;
+    target->width = src->width;
+    target->widthSet = src->widthSet;
+    target->height = src->height;
+    target->heightSet = src->heightSet;
+    target->menuBarVisible = src->menuBarVisible;
+    target->statusBarVisible = src->statusBarVisible;
+    target->toolBarVisible = src->toolBarVisible;
+    target->locationBarVisible = src->locationBarVisible;
+    target->scrollbarsVisible = src->scrollbarsVisible;
+    target->resizable = src->resizable;
+    target->fullscreen = src->fullscreen;
+    target->dialog = src->dialog;
+  }
+};
+
+///
+// Class representing popup window features.
+///
+typedef CefStructBase<CefPopupFeaturesTraits> CefPopupFeatures;
+
+
+struct CefSettingsTraits {
+  typedef cef_settings_t struct_type;
+
+  static inline void init(struct_type* s) {
+    s->size = sizeof(struct_type);
+  }
+
+  static inline void clear(struct_type* s) {
+    cef_string_clear(&s->browser_subprocess_path);
+    cef_string_clear(&s->cache_path);
+    cef_string_clear(&s->user_data_path);
+    cef_string_clear(&s->user_agent);
+    cef_string_clear(&s->product_version);
+    cef_string_clear(&s->locale);
+    cef_string_clear(&s->log_file);
+    cef_string_clear(&s->javascript_flags);
+    cef_string_clear(&s->resources_dir_path);
+    cef_string_clear(&s->locales_dir_path);
+    cef_string_clear(&s->accept_language_list);
+  }
+
+  static inline void set(const struct_type* src, struct_type* target,
+      bool copy) {
+    target->single_process = src->single_process;
+    target->no_sandbox = src->no_sandbox;
+    cef_string_set(src->browser_subprocess_path.str,
+        src->browser_subprocess_path.length,
+        &target->browser_subprocess_path, copy);
+    target->multi_threaded_message_loop = src->multi_threaded_message_loop;
+    target->windowless_rendering_enabled = src->windowless_rendering_enabled;
+    target->command_line_args_disabled = src->command_line_args_disabled;
+
+    cef_string_set(src->cache_path.str, src->cache_path.length,
+        &target->cache_path, copy);
+    cef_string_set(src->user_data_path.str, src->user_data_path.length,
+        &target->user_data_path, copy);
+    target->persist_session_cookies = src->persist_session_cookies;
+    target->persist_user_preferences = src->persist_user_preferences;
+
+    cef_string_set(src->user_agent.str, src->user_agent.length,
+        &target->user_agent, copy);
+    cef_string_set(src->product_version.str, src->product_version.length,
+        &target->product_version, copy);
+    cef_string_set(src->locale.str, src->locale.length, &target->locale, copy);
+
+    cef_string_set(src->log_file.str, src->log_file.length, &target->log_file,
+        copy);
+    target->log_severity = src->log_severity;
+    cef_string_set(src->javascript_flags.str, src->javascript_flags.length,
+        &target->javascript_flags, copy);
+
+    cef_string_set(src->resources_dir_path.str, src->resources_dir_path.length,
+        &target->resources_dir_path, copy);
+    cef_string_set(src->locales_dir_path.str, src->locales_dir_path.length,
+        &target->locales_dir_path, copy);
+    target->pack_loading_disabled = src->pack_loading_disabled;
+    target->remote_debugging_port = src->remote_debugging_port;
+    target->uncaught_exception_stack_size = src->uncaught_exception_stack_size;
+    target->context_safety_implementation = src->context_safety_implementation;
+    target->ignore_certificate_errors = src->ignore_certificate_errors;
+    target->background_color = src->background_color;
+
+    cef_string_set(src->accept_language_list.str,
+        src->accept_language_list.length, &target->accept_language_list, copy);
+  }
+};
+
+///
+// Class representing initialization settings.
+///
+typedef CefStructBase<CefSettingsTraits> CefSettings;
+
+
+struct CefRequestContextSettingsTraits {
+  typedef cef_request_context_settings_t struct_type;
+
+  static inline void init(struct_type* s) {
+    s->size = sizeof(struct_type);
+  }
+
+  static inline void clear(struct_type* s) {
+    cef_string_clear(&s->cache_path);
+    cef_string_clear(&s->accept_language_list);
+  }
+
+  static inline void set(const struct_type* src, struct_type* target,
+      bool copy) {
+    cef_string_set(src->cache_path.str, src->cache_path.length,
+        &target->cache_path, copy);
+    target->persist_session_cookies = src->persist_session_cookies;
+    target->persist_user_preferences = src->persist_user_preferences;
+    target->ignore_certificate_errors = src->ignore_certificate_errors;
+    cef_string_set(src->accept_language_list.str,
+        src->accept_language_list.length, &target->accept_language_list, copy);
+  }
+};
+
+///
+// Class representing request context initialization settings.
+///
+typedef CefStructBase<CefRequestContextSettingsTraits>
+    CefRequestContextSettings;
+
+
+struct CefBrowserSettingsTraits {
+  typedef cef_browser_settings_t struct_type;
+
+  static inline void init(struct_type* s) {
+    s->size = sizeof(struct_type);
+  }
+
+  static inline void clear(struct_type* s) {
+    cef_string_clear(&s->standard_font_family);
+    cef_string_clear(&s->fixed_font_family);
+    cef_string_clear(&s->serif_font_family);
+    cef_string_clear(&s->sans_serif_font_family);
+    cef_string_clear(&s->cursive_font_family);
+    cef_string_clear(&s->fantasy_font_family);
+    cef_string_clear(&s->default_encoding);
+    cef_string_clear(&s->accept_language_list);
+  }
+
+  static inline void set(const struct_type* src, struct_type* target,
+      bool copy) {
+    target->windowless_frame_rate = src->windowless_frame_rate;
+
+    cef_string_set(src->standard_font_family.str,
+        src->standard_font_family.length, &target->standard_font_family, copy);
+    cef_string_set(src->fixed_font_family.str, src->fixed_font_family.length,
+        &target->fixed_font_family, copy);
+    cef_string_set(src->serif_font_family.str, src->serif_font_family.length,
+        &target->serif_font_family, copy);
+    cef_string_set(src->sans_serif_font_family.str,
+        src->sans_serif_font_family.length, &target->sans_serif_font_family,
+        copy);
+    cef_string_set(src->cursive_font_family.str,
+        src->cursive_font_family.length, &target->cursive_font_family, copy);
+    cef_string_set(src->fantasy_font_family.str,
+        src->fantasy_font_family.length, &target->fantasy_font_family, copy);
+
+    target->default_font_size = src->default_font_size;
+    target->default_fixed_font_size = src->default_fixed_font_size;
+    target->minimum_font_size = src->minimum_font_size;
+    target->minimum_logical_font_size = src->minimum_logical_font_size;
+
+    cef_string_set(src->default_encoding.str, src->default_encoding.length,
+        &target->default_encoding, copy);
+
+    target->remote_fonts = src->remote_fonts;
+    target->javascript = src->javascript;
+    target->javascript_open_windows = src->javascript_open_windows;
+    target->javascript_close_windows = src->javascript_close_windows;
+    target->javascript_access_clipboard = src->javascript_access_clipboard;
+    target->javascript_dom_paste = src->javascript_dom_paste;
+    target->caret_browsing = src->caret_browsing;
+    target->plugins = src->plugins;
+    target->universal_access_from_file_urls =
+        src->universal_access_from_file_urls;
+    target->file_access_from_file_urls = src->file_access_from_file_urls;
+    target->web_security = src->web_security;
+    target->image_loading = src->image_loading;
+    target->image_shrink_standalone_to_fit =
+        src->image_shrink_standalone_to_fit;
+    target->text_area_resize = src->text_area_resize;
+    target->tab_to_links = src->tab_to_links;
+    target->local_storage = src->local_storage;
+    target->databases= src->databases;
+    target->application_cache = src->application_cache;
+    target->webgl = src->webgl;
+
+    target->background_color = src->background_color;
+
+    cef_string_set(src->accept_language_list.str,
+        src->accept_language_list.length, &target->accept_language_list, copy);
+  }
+};
+
+///
+// Class representing browser initialization settings.
+///
+typedef CefStructBase<CefBrowserSettingsTraits> CefBrowserSettings;
+
+
+struct CefURLPartsTraits {
+  typedef cef_urlparts_t struct_type;
+
+  static inline void init(struct_type* s) {}
+
+  static inline void clear(struct_type* s) {
+    cef_string_clear(&s->spec);
+    cef_string_clear(&s->scheme);
+    cef_string_clear(&s->username);
+    cef_string_clear(&s->password);
+    cef_string_clear(&s->host);
+    cef_string_clear(&s->port);
+    cef_string_clear(&s->origin);
+    cef_string_clear(&s->path);
+    cef_string_clear(&s->query);
+  }
+
+  static inline void set(const struct_type* src, struct_type* target,
+      bool copy) {
+    cef_string_set(src->spec.str, src->spec.length, &target->spec, copy);
+    cef_string_set(src->scheme.str, src->scheme.length, &target->scheme, copy);
+    cef_string_set(src->username.str, src->username.length, &target->username,
+        copy);
+    cef_string_set(src->password.str, src->password.length, &target->password,
+        copy);
+    cef_string_set(src->host.str, src->host.length, &target->host, copy);
+    cef_string_set(src->port.str, src->port.length, &target->port, copy);
+    cef_string_set(src->origin.str, src->origin.length, &target->origin, copy);
+    cef_string_set(src->path.str, src->path.length, &target->path, copy);
+    cef_string_set(src->query.str, src->query.length, &target->query, copy);
+  }
+};
+
+///
+// Class representing a URL's component parts.
+///
+typedef CefStructBase<CefURLPartsTraits> CefURLParts;
+
+
+struct CefTimeTraits {
+  typedef cef_time_t struct_type;
+
+  static inline void init(struct_type* s) {}
+
+  static inline void clear(struct_type* s) {}
+
+  static inline void set(const struct_type* src, struct_type* target,
+      bool copy) {
+    *target = *src;
+  }
+};
+
+///
+// Class representing a time.
+///
+class CefTime : public CefStructBase<CefTimeTraits> {
+ public:
+  typedef CefStructBase<CefTimeTraits> parent;
+
+  CefTime() : parent() {}
+  CefTime(const cef_time_t& r) : parent(r) {}  // NOLINT(runtime/explicit)
+  CefTime(const CefTime& r) : parent(r) {}  // NOLINT(runtime/explicit)
+  explicit CefTime(time_t r) : parent() { SetTimeT(r); }
+  explicit CefTime(double r) : parent() { SetDoubleT(r); }
+
+  // Converts to/from time_t.
+  void SetTimeT(time_t r) {
+    cef_time_from_timet(r, this);
+  }
+  time_t GetTimeT() const {
+    time_t time = 0;
+    cef_time_to_timet(this, &time);
+    return time;
+  }
+
+  // Converts to/from a double which is the number of seconds since epoch
+  // (Jan 1, 1970). Webkit uses this format to represent time. A value of 0
+  // means "not initialized".
+  void SetDoubleT(double r) {
+    cef_time_from_doublet(r, this);
+  }
+  double GetDoubleT() const {
+    double time = 0;
+    cef_time_to_doublet(this, &time);
+    return time;
+  }
+
+  // Set this object to now.
+  void Now() {
+    cef_time_now(this);
+  }
+
+  // Return the delta between this object and |other| in milliseconds.
+  long long Delta(const CefTime& other) {
+    long long delta = 0;
+    cef_time_delta(this, &other, &delta);
+    return delta;
+  }
+};
+
+
+struct CefCookieTraits {
+  typedef cef_cookie_t struct_type;
+
+  static inline void init(struct_type* s) {}
+
+  static inline void clear(struct_type* s) {
+    cef_string_clear(&s->name);
+    cef_string_clear(&s->value);
+    cef_string_clear(&s->domain);
+    cef_string_clear(&s->path);
+  }
+
+  static inline void set(const struct_type* src, struct_type* target,
+      bool copy) {
+    cef_string_set(src->name.str, src->name.length, &target->name, copy);
+    cef_string_set(src->value.str, src->value.length, &target->value, copy);
+    cef_string_set(src->domain.str, src->domain.length, &target->domain, copy);
+    cef_string_set(src->path.str, src->path.length, &target->path, copy);
+    target->secure = src->secure;
+    target->httponly = src->httponly;
+    target->creation = src->creation;
+    target->last_access = src->last_access;
+    target->has_expires = src->has_expires;
+    target->expires = src->expires;
+  }
+};
+
+///
+// Class representing a cookie.
+///
+typedef CefStructBase<CefCookieTraits> CefCookie;
+
+
+struct CefGeopositionTraits {
+  typedef cef_geoposition_t struct_type;
+
+  static inline void init(struct_type* s) {}
+
+  static inline void clear(struct_type* s) {
+    cef_string_clear(&s->error_message);
+  }
+
+  static inline void set(const struct_type* src, struct_type* target,
+      bool copy) {
+    target->latitude = src->latitude;
+    target->longitude = src->longitude;
+    target->altitude = src->altitude;
+    target->accuracy = src->accuracy;
+    target->altitude_accuracy = src->altitude_accuracy;
+    target->heading = src->heading;
+    target->speed = src->speed;
+    target->timestamp = src->timestamp;
+    target->error_code = src->error_code;
+    cef_string_set(src->error_message.str, src->error_message.length,
+        &target->error_message, copy);
+  }
+};
+
+///
+// Class representing a geoposition.
+///
+typedef CefStructBase<CefGeopositionTraits> CefGeoposition;
+
+
+struct CefPageRangeTraits {
+  typedef cef_page_range_t struct_type;
+
+  static inline void init(struct_type* s) {}
+  static inline void clear(struct_type* s) {}
+
+  static inline void set(const struct_type* src, struct_type* target,
+      bool copy) {
+    *target = *src;
+  }
+};
+
+///
+// Class representing a print job page range.
+///
+class CefPageRange : public CefStructBase<CefPageRangeTraits> {
+ public:
+  typedef CefStructBase<CefPageRangeTraits> parent;
+
+  CefPageRange() : parent() {}
+  CefPageRange(const cef_page_range_t& r)  // NOLINT(runtime/explicit)
+      : parent(r) {}
+  CefPageRange(const CefPageRange& r)  // NOLINT(runtime/explicit)
+      : parent(r) {}
+  CefPageRange(int from, int to) : parent() {
+    Set(from, to);
+  }
+
+  void Set(int from_val, int to_val) {
+    from = from_val, to = to_val;
+  }
+};
+
+inline bool operator==(const CefPageRange& a, const CefPageRange& b) {
+  return a.from == b.from && a.to == b.to;
+}
+
+inline bool operator!=(const CefPageRange& a, const CefPageRange& b) {
+  return !(a == b);
+}
+
+
+struct CefCursorInfoTraits {
+  typedef cef_cursor_info_t struct_type;
+
+  static inline void init(struct_type* s) {}
+
+  static inline void clear(struct_type* s) {}
+
+  static inline void set(const struct_type* src, struct_type* target,
+      bool copy) {
+    target->hotspot = src->hotspot;
+    target->image_scale_factor = src->image_scale_factor;
+    target->buffer = src->buffer;
+    target->size = src->size;
+  }
+};
+
+///
+// Class representing cursor information.
+///
+typedef CefStructBase<CefCursorInfoTraits> CefCursorInfo;
+
+
+struct CefPdfPrintSettingsTraits {
+  typedef cef_pdf_print_settings_t struct_type;
+
+  static inline void init(struct_type* s) {}
+
+  static inline void clear(struct_type* s) {
+    cef_string_clear(&s->header_footer_title);
+    cef_string_clear(&s->header_footer_url);
+  }
+
+  static inline void set(const struct_type* src, struct_type* target,
+      bool copy) {
+
+    cef_string_set(src->header_footer_title.str,
+        src->header_footer_title.length, &target->header_footer_title, copy);
+    cef_string_set(src->header_footer_url.str, src->header_footer_url.length,
+        &target->header_footer_url, copy);
+
+    target->page_width = src->page_width;
+    target->page_height = src->page_height;
+
+    target->margin_top = src->margin_top;
+    target->margin_right = src->margin_right;
+    target->margin_bottom = src->margin_bottom;
+    target->margin_left = src->margin_left;
+    target->margin_type = src->margin_type;
+
+    target->header_footer_enabled = src->header_footer_enabled;
+    target->selection_only = src->selection_only;
+    target->landscape = src->landscape;
+    target->backgrounds_enabled = src->backgrounds_enabled;
+  }
+};
+
+///
+// Class representing PDF print settings
+///
+typedef CefStructBase<CefPdfPrintSettingsTraits> CefPdfPrintSettings;
+
+#endif  // CEF_INCLUDE_INTERNAL_CEF_TYPES_WRAPPERS_H_
diff --git a/src/include/libcef_/internal/cef_win.h b/src/include/libcef_/internal/cef_win.h
new file mode 100644
index 0000000..885b5bd
--- /dev/null
+++ b/src/include/libcef_/internal/cef_win.h
@@ -0,0 +1,156 @@
+// Copyright (c) 2008 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+#ifndef CEF_INCLUDE_INTERNAL_CEF_WIN_H_
+#define CEF_INCLUDE_INTERNAL_CEF_WIN_H_
+#pragma once
+
+#include"libcef/internal/cef_types_win.h"
+#include"libcef/internal/cef_types_wrappers.h"
+
+///
+// Handle types.
+///
+#define CefCursorHandle cef_cursor_handle_t
+#define CefEventHandle cef_event_handle_t
+#define CefWindowHandle cef_window_handle_t
+#define CefTextInputContext cef_text_input_context_t
+
+struct CefMainArgsTraits {
+  typedef cef_main_args_t struct_type;
+
+  static inline void init(struct_type* s) {}
+  static inline void clear(struct_type* s) {}
+
+  static inline void set(const struct_type* src, struct_type* target,
+      bool copy) {
+    target->instance = src->instance;
+  }
+};
+
+// Class representing CefExecuteProcess arguments.
+class CefMainArgs : public CefStructBase<CefMainArgsTraits> {
+ public:
+  typedef CefStructBase<CefMainArgsTraits> parent;
+
+  CefMainArgs() : parent() {}
+  explicit CefMainArgs(const cef_main_args_t& r) : parent(r) {}
+  explicit CefMainArgs(const CefMainArgs& r) : parent(r) {}
+  explicit CefMainArgs(HINSTANCE hInstance) : parent() {
+    instance = hInstance;
+  }
+};
+
+struct CefWindowInfoTraits {
+  typedef cef_window_info_t struct_type;
+
+  static inline void init(struct_type* s) {}
+
+  static inline void clear(struct_type* s) {
+    cef_string_clear(&s->window_name);
+  }
+
+  static inline void set(const struct_type* src, struct_type* target,
+      bool copy) {
+    target->ex_style = src->ex_style;
+    cef_string_set(src->window_name.str, src->window_name.length,
+        &target->window_name, copy);
+    target->style = src->style;
+    target->x = src->x;
+    target->y = src->y;
+    target->width = src->width;
+    target->height = src->height;
+    target->parent_window = src->parent_window;
+    target->menu = src->menu;
+    target->transparent_painting_enabled = src->transparent_painting_enabled;
+    target->windowless_rendering_enabled = src->windowless_rendering_enabled;
+    target->window = src->window;
+  }
+};
+
+///
+// Class representing window information.
+///
+class CefWindowInfo : public CefStructBase<CefWindowInfoTraits> {
+ public:
+  typedef CefStructBase<CefWindowInfoTraits> parent;
+
+  CefWindowInfo() : parent() {}
+  explicit CefWindowInfo(const cef_window_info_t& r) : parent(r) {}
+  explicit CefWindowInfo(const CefWindowInfo& r) : parent(r) {}
+
+  ///
+  // Create the browser as a child window.
+  ///
+  void SetAsChild(CefWindowHandle parent, RECT windowRect) {
+    style = WS_CHILD | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | WS_TABSTOP |
+            WS_VISIBLE;
+    parent_window = parent;
+    x = windowRect.left;
+    y = windowRect.top;
+    width = windowRect.right - windowRect.left;
+    height = windowRect.bottom - windowRect.top;
+  }
+
+  ///
+  // Create the browser as a popup window.
+  ///
+  void SetAsPopup(CefWindowHandle parent, const CefString& windowName) {
+    style = WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS |
+            WS_VISIBLE;
+    parent_window = parent;
+    x = CW_USEDEFAULT;
+    y = CW_USEDEFAULT;
+    width = CW_USEDEFAULT;
+    height = CW_USEDEFAULT;
+
+    cef_string_copy(windowName.c_str(), windowName.length(), &window_name);
+  }
+
+  ///
+  // Create the browser using windowless (off-screen) rendering. No window
+  // will be created for the browser and all rendering will occur via the
+  // CefRenderHandler interface. The |parent| value will be used to identify
+  // monitor info and to act as the parent window for dialogs, context menus,
+  // etc. If |parent| is not provided then the main screen monitor will be used
+  // and some functionality that requires a parent window may not function
+  // correctly. If |transparent| is true a transparent background color will be
+  // used (RGBA=0x00000000). If |transparent| is false the background will be
+  // white and opaque. In order to create windowless browsers the
+  // CefSettings.windowless_rendering_enabled value must be set to true.
+  ///
+  void SetAsWindowless(CefWindowHandle parent, bool transparent) {
+    windowless_rendering_enabled = TRUE;
+    parent_window = parent;
+    transparent_painting_enabled = transparent;
+  }
+};
+
+#endif  // CEF_INCLUDE_INTERNAL_CEF_WIN_H_
diff --git a/src/include/libcef_/wrapper/cef_byte_read_handler.h b/src/include/libcef_/wrapper/cef_byte_read_handler.h
new file mode 100644
index 0000000..0dd868c
--- /dev/null
+++ b/src/include/libcef_/wrapper/cef_byte_read_handler.h
@@ -0,0 +1,79 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file are only available to applications that link
+// against the libcef_dll_wrapper target.
+//
+
+#ifndef CEF_INCLUDE_WRAPPER_CEF_BYTE_READ_HANDLER_H_
+#define CEF_INCLUDE_WRAPPER_CEF_BYTE_READ_HANDLER_H_
+#pragma once
+
+#include"libcef/base/cef_lock.h"
+#include"libcef/base/cef_macros.h"
+#include"libcef/cef_base.h"
+#include"libcef/cef_stream.h"
+
+///
+// Thread safe implementation of the CefReadHandler class for reading an
+// in-memory array of bytes.
+///
+class CefByteReadHandler : public CefReadHandler {
+ public:
+  ///
+  // Create a new object for reading an array of bytes. An optional |source|
+  // reference can be kept to keep the underlying data source from being
+  // released while the reader exists.
+  ///
+  CefByteReadHandler(const unsigned char* bytes,
+                     size_t size,
+                     CefRefPtr<CefBase> source);
+
+  // CefReadHandler methods.
+  virtual size_t Read(void* ptr, size_t size, size_t n) OVERRIDE;
+  virtual int Seek(int64 offset, int whence) OVERRIDE;
+  virtual int64 Tell() OVERRIDE;
+  virtual int Eof() OVERRIDE;
+  virtual bool MayBlock() OVERRIDE { return false; }
+
+ private:
+  const unsigned char* bytes_;
+  int64 size_;
+  int64 offset_;
+  CefRefPtr<CefBase> source_;
+
+  base::Lock lock_;
+
+  IMPLEMENT_REFCOUNTING(CefByteReadHandler);
+  DISALLOW_COPY_AND_ASSIGN(CefByteReadHandler);
+};
+
+#endif  // CEF_INCLUDE_WRAPPER_CEF_BYTE_READ_HANDLER_H_
diff --git a/src/include/libcef_/wrapper/cef_closure_task.h b/src/include/libcef_/wrapper/cef_closure_task.h
new file mode 100644
index 0000000..42a64cf
--- /dev/null
+++ b/src/include/libcef_/wrapper/cef_closure_task.h
@@ -0,0 +1,101 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file are only available to applications that link
+// against the libcef_dll_wrapper target.
+//
+
+#ifndef CEF_INCLUDE_WRAPPER_CEF_CLOSURE_TASK_H_
+#define CEF_INCLUDE_WRAPPER_CEF_CLOSURE_TASK_H_
+#pragma once
+
+#include"libcef/base/cef_callback_forward.h"
+#include"libcef/base/cef_macros.h"
+#include"libcef/cef_task.h"
+
+///
+// Helpers for asynchronously executing a base::Closure (bound function or
+// method) on a CEF thread. Creation of base::Closures can be facilitated using
+// base::Bind. See include/base/cef_callback.h for complete usage instructions.
+//
+// TO use these helpers you should include this header and the header that
+// defines base::Bind.
+//
+// #include "include/base/cef_bind.h"
+// #include "include/wrapper/cef_closure_task.h"
+//
+// Example of executing a bound function:
+//
+// // Define a function.
+// void MyFunc(int arg) { /* do something with |arg| on the UI thread */ }
+//
+// // Post a task that will execute MyFunc on the UI thread and pass an |arg|
+// // value of 5.
+// CefPostTask(TID_UI, base::Bind(&MyFunc, 5));
+//
+// Example of executing a bound method:
+//
+// // Define a class.
+// class MyClass : public CefBase {
+//  public:
+//   MyClass() {}
+//   void MyMethod(int arg) { /* do something with |arg| on the UI thread */ }
+//  private:
+//   IMPLEMENT_REFCOUNTING(MyClass);
+// };
+//
+// // Create an instance of MyClass.
+// CefRefPtr<MyClass> instance = new MyClass();
+//
+// // Post a task that will execute MyClass::MyMethod on the UI thread and pass
+// // an |arg| value of 5. |instance| will be kept alive until after the task
+// // completes.
+// CefPostTask(TID_UI, base::Bind(&MyClass::MyMethod, instance, 5));
+///
+
+///
+// Create a CefTask that wraps a base::Closure. Can be used in combination with
+// CefTaskRunner.
+///
+CefRefPtr<CefTask> CefCreateClosureTask(const base::Closure& closure);
+
+///
+// Post a Closure for execution on the specified thread.
+///
+bool CefPostTask(CefThreadId threadId, const base::Closure& closure);
+
+///
+// Post a Closure for delayed execution on the specified thread.
+///
+bool CefPostDelayedTask(CefThreadId threadId, const base::Closure& closure,
+                        int64 delay_ms);
+
+#endif  // CEF_INCLUDE_WRAPPER_CEF_CLOSURE_TASK_H_
diff --git a/src/include/libcef_/wrapper/cef_helpers.h b/src/include/libcef_/wrapper/cef_helpers.h
new file mode 100644
index 0000000..9ad0e7f
--- /dev/null
+++ b/src/include/libcef_/wrapper/cef_helpers.h
@@ -0,0 +1,124 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file are only available to applications that link
+// against the libcef_dll_wrapper target.
+//
+
+#ifndef CEF_INCLUDE_WRAPPER_CEF_HELPERS_H_
+#define CEF_INCLUDE_WRAPPER_CEF_HELPERS_H_
+#pragma once
+
+#include<cstring>
+#include<string>
+#include<vector>
+
+#include"libcef/base/cef_bind.h"
+#include"libcef/base/cef_logging.h"
+#include"libcef/base/cef_macros.h"
+#include"libcef/cef_task.h"
+
+#define CEF_REQUIRE_UI_THREAD()       DCHECK(CefCurrentlyOn(TID_UI));
+#define CEF_REQUIRE_IO_THREAD()       DCHECK(CefCurrentlyOn(TID_IO));
+#define CEF_REQUIRE_FILE_THREAD()     DCHECK(CefCurrentlyOn(TID_FILE));
+#define CEF_REQUIRE_RENDERER_THREAD() DCHECK(CefCurrentlyOn(TID_RENDERER));
+
+
+// Use this struct in conjuction with refcounted types to ensure that an
+// object is deleted on the specified thread. For example:
+//
+// class Foo : public base::RefCountedThreadSafe<Foo, CefDeleteOnUIThread> {
+//  public:
+//   Foo();
+//   void DoSomething();
+//
+//  private:
+//   // Allow deletion via scoped_refptr only.
+//   friend struct CefDeleteOnThread<TID_UI>;
+//   friend class base::RefCountedThreadSafe<Foo, CefDeleteOnUIThread>;
+//
+//   virtual ~Foo() {}
+// };
+//
+// base::scoped_refptr<Foo> foo = new Foo();
+// foo->DoSomething();
+// foo = NULL;  // Deletion of |foo| will occur on the UI thread.
+//
+template<CefThreadId thread>
+struct CefDeleteOnThread {
+  template<typename T>
+  static void Destruct(const T* x) {
+    if (CefCurrentlyOn(thread)) {
+      delete x;
+    } else {
+      CefPostTask(thread,
+                  base::Bind(&CefDeleteOnThread<thread>::Destruct<T>, x));
+    }
+  }
+};
+
+struct CefDeleteOnUIThread : public CefDeleteOnThread<TID_UI> { };
+struct CefDeleteOnIOThread : public CefDeleteOnThread<TID_IO> { };
+struct CefDeleteOnFileThread : public CefDeleteOnThread<TID_FILE> { };
+struct CefDeleteOnRendererThread : public CefDeleteOnThread<TID_RENDERER> { };
+
+
+///
+// Helper class to manage a scoped copy of |argv|.
+///
+class CefScopedArgArray {
+ public:
+  CefScopedArgArray(int argc, char* argv[]) {
+    // argv should have (argc + 1) elements, the last one always being NULL.
+    array_ = new char*[argc + 1];
+    for (int i = 0; i < argc; ++i) {
+      values_.push_back(argv[i]);
+      array_[i] = const_cast<char*>(values_[i].c_str());
+    }
+    array_[argc] = NULL;
+  }
+  ~CefScopedArgArray() {
+    delete [] array_;
+  }
+
+  char** array() const { return array_; }
+
+ private:
+  char** array_;
+
+  // Keep values in a vector separate from |array_| because various users may
+  // modify |array_| and we still want to clean up memory properly.
+  std::vector<std::string> values_;
+  
+  DISALLOW_COPY_AND_ASSIGN(CefScopedArgArray);
+};
+
+#endif  // CEF_INCLUDE_WRAPPER_CEF_HELPERS_H_
diff --git a/src/include/libcef_/wrapper/cef_message_router.h b/src/include/libcef_/wrapper/cef_message_router.h
new file mode 100644
index 0000000..4872225
--- /dev/null
+++ b/src/include/libcef_/wrapper/cef_message_router.h
@@ -0,0 +1,428 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file are only available to applications that link
+// against the libcef_dll_wrapper target.
+//
+
+#ifndef CEF_INCLUDE_WRAPPER_CEF_MESSAGE_ROUTER_H_
+#define CEF_INCLUDE_WRAPPER_CEF_MESSAGE_ROUTER_H_
+#pragma once
+
+#include"libcef/base/cef_ref_counted.h"
+#include"libcef/cef_base.h"
+#include"libcef/cef_browser.h"
+#include"libcef/cef_process_message.h"
+#include"libcef/cef_v8.h"
+
+// The below classes implement support for routing aynchronous messages between
+// JavaScript running in the renderer process and C++ running in the browser
+// process. An application interacts with the router by passing it data from
+// standard CEF C++ callbacks (OnBeforeBrowse, OnProcessMessageRecieved,
+// OnContextCreated, etc). The renderer-side router supports generic JavaScript
+// callback registration and execution while the browser-side router supports
+// application-specific logic via one or more application-provided Handler
+// instances.
+//
+// The renderer-side router implementation exposes a query function and a cancel
+// function via the JavaScript 'window' object:
+//
+//    // Create and send a new query.
+//    var request_id = window.cefQuery({
+//        request: 'my_request',
+//        persistent: false,
+//        onSuccess: function(response) {},
+//        onFailure: function(error_code, error_message) {}
+//    });
+//
+//    // Optionally cancel the query.
+//    window.cefQueryCancel(request_id);
+//
+// When |window.cefQuery| is executed the request is sent asynchronously to one
+// or more C++ Handler objects registered in the browser process. Each C++
+// Handler can choose to either handle or ignore the query in the
+// Handler::OnQuery callback. If a Handler chooses to handle the query then it
+// should execute Callback::Success when a response is available or
+// Callback::Failure if an error occurs. This will result in asynchronous
+// execution of the associated JavaScript callback in the renderer process. Any
+// queries unhandled by C++ code in the browser process will be automatically
+// canceled and the associated JavaScript onFailure callback will be executed
+// with an error code of -1.
+//
+// Queries can be either persistent or non-persistent. If the query is
+// persistent than the callbacks will remain registered until one of the
+// following conditions are met:
+//
+// A. The query is canceled in JavaScript using the |window.cefQueryCancel|
+//    function.
+// B. The query is canceled in C++ code using the Callback::Failure function.
+// C. The context associated with the query is released due to browser
+//    destruction, navigation or renderer process termination.
+//
+// If the query is non-persistent then the registration will be removed after
+// the JavaScript callback is executed a single time. If a query is canceled for
+// a reason other than Callback::Failure being executed then the associated
+// Handler's OnQueryCanceled method will be called.
+//
+// Some possible usage patterns include:
+//
+// One-time Request. Use a non-persistent query to send a JavaScript request.
+//    The Handler evaluates the request and returns the response. The query is
+//    then discarded.
+//
+// Broadcast. Use a persistent query to register as a JavaScript broadcast
+//    receiver. The Handler keeps track of all registered Callbacks and executes
+//    them sequentially to deliver the broadcast message.
+//
+// Subscription. Use a persistent query to register as a JavaScript subscription
+//    receiver. The Handler initiates the subscription feed on the first request
+//    and delivers responses to all registered subscribers as they become
+//    available. The Handler cancels the subscription feed when there are no
+//    longer any registered JavaScript receivers.
+//
+// Message routing occurs on a per-browser and per-context basis. Consequently,
+// additional application logic can be applied by restricting which browser or
+// context instances are passed into the router. If you choose to use this
+// approach do so cautiously. In order for the router to function correctly any
+// browser or context instance passed into a single router callback must then
+// be passed into all router callbacks.
+//
+// There is generally no need to have multiple renderer-side routers unless you
+// wish to have multiple bindings with different JavaScript function names. It
+// can be useful to have multiple browser-side routers with different client-
+// provided Handler instances when implementing different behaviors on a per-
+// browser basis.
+//
+// This implementation places no formatting restrictions on payload content.
+// An application may choose to exchange anything from simple formatted
+// strings to serialized XML or JSON data.
+//
+//
+// EXAMPLE USAGE
+//
+// 1. Define the router configuration. You can optionally specify settings
+//    like the JavaScript function names. The configuration must be the same in
+//    both the browser and renderer processes. If using multiple routers in the
+//    same application make sure to specify unique function names for each
+//    router configuration.
+//
+//    // Example config object showing the default values.
+//    CefMessageRouterConfig config;
+//    config.js_query_function = "cefQuery";
+//    config.js_cancel_function = "cefQueryCancel";
+//
+// 2. Create an instance of CefMessageRouterBrowserSide in the browser process.
+//    You might choose to make it a member of your CefClient implementation,
+//    for example.
+//
+//    browser_side_router_ = CefMessageRouterBrowserSide::Create(config);
+//
+// 3. Register one or more Handlers. The Handler instances must either outlive
+//    the router or be removed from the router before they're deleted.
+//
+//    browser_side_router_->AddHandler(my_handler);
+//
+// 4. Call all required CefMessageRouterBrowserSide methods from other callbacks
+//    in your CefClient implementation (OnBeforeClose, etc). See the
+//    CefMessageRouterBrowserSide class documentation for the complete list of
+//    methods.
+//
+// 5. Create an instance of CefMessageRouterRendererSide in the renderer process.
+//    You might choose to make it a member of your CefApp implementation, for
+//    example.
+//
+//    renderer_side_router_ = CefMessageRouterRendererSide::Create(config);
+//
+// 6. Call all required CefMessageRouterRendererSide methods from other
+//    callbacks in your CefRenderProcessHandler implementation
+//    (OnContextCreated, etc). See the CefMessageRouterRendererSide class
+//    documentation for the complete list of methods.
+//
+// 7. Execute the query function from JavaScript code.
+//
+//    window.cefQuery({request: 'my_request',
+//                     persistent: false,
+//                     onSuccess: function(response) { print(response); },
+//                     onFailure: function(error_code, error_message) {} });
+//
+// 8. Handle the query in your Handler::OnQuery implementation and execute the
+//    appropriate callback either immediately or asynchronously.
+//
+//    void MyHandler::OnQuery(int64 query_id,
+//                            CefRefPtr<CefBrowser> browser,
+//                            CefRefPtr<CefFrame> frame,
+//                            const CefString& request,
+//                            bool persistent,
+//                            CefRefPtr<Callback> callback) {
+//      if (request == "my_request") {
+//        callback->Continue("my_response");
+//        return true;
+//      }
+//      return false;  // Not handled.
+//    }
+//
+// 9. Notice that the onSuccess callback is executed in JavaScript.
+
+///
+// Used to configure the query router. The same values must be passed to both
+// CefMessageRouterBrowserSide and CefMessageRouterRendererSide. If using multiple
+// router pairs make sure to choose values that do not conflict.
+///
+struct CefMessageRouterConfig {
+  CefMessageRouterConfig();
+
+  // Name of the JavaScript function that will be added to the 'window' object
+  // for sending a query. The default value is "cefQuery".
+  CefString js_query_function;
+
+  // Name of the JavaScript function that will be added to the 'window' object
+  // for canceling a pending query. The default value is "cefQueryCancel".
+  CefString js_cancel_function;
+};
+
+///
+// Implements the browser side of query routing. The methods of this class may
+// be called on any browser process thread unless otherwise indicated.
+///
+class CefMessageRouterBrowserSide :
+    public base::RefCountedThreadSafe<CefMessageRouterBrowserSide> {
+ public:
+  ///
+  // Callback associated with a single pending asynchronous query. Execute the
+  // Success or Failure method to send an asynchronous response to the
+  // associated JavaScript handler. It is a runtime error to destroy a Callback
+  // object associated with an uncanceled query without first executing one of
+  // the callback methods. The methods of this class may be called on any
+  // browser process thread.
+  ///
+  class Callback : public CefBase {
+   public:
+    ///
+    // Notify the associated JavaScript onSuccess callback that the query has
+    // completed successfully with the specified |response|.
+    ///
+    virtual void Success(const CefString& response) =0;
+
+    ///
+    // Notify the associated JavaScript onFailure callback that the query has
+    // failed with the specified |error_code| and |error_message|.
+    ///
+    virtual void Failure(int error_code, const CefString& error_message) =0;
+  };
+
+  ///
+  // Implement this interface to handle queries. All methods will be executed on
+  // the browser process UI thread.
+  ///
+  class Handler {
+   public:
+    typedef CefMessageRouterBrowserSide::Callback Callback;
+
+    ///
+    // Executed when a new query is received. |query_id| uniquely identifies the
+    // query for the life span of the router. Return true to handle the query
+    // or false to propagate the query to other registered handlers, if any. If
+    // no handlers return true from this method then the query will be
+    // automatically canceled with an error code of -1 delivered to the
+    // JavaScript onFailure callback. If this method returns true then a
+    // Callback method must be executed either in this method or asynchronously
+    // to complete the query.
+    ///
+    virtual bool OnQuery(CefRefPtr<CefBrowser> browser,
+                         CefRefPtr<CefFrame> frame,
+                         int64 query_id,
+                         const CefString& request,
+                         bool persistent,
+                         CefRefPtr<Callback> callback) {
+      return false;
+    }
+
+    ///
+    // Executed when a query has been canceled either explicitly using the
+    // JavaScript cancel function or implicitly due to browser destruction,
+    // navigation or renderer process termination. It will only be called for
+    // the single handler that returned true from OnQuery for the same
+    // |query_id|. No references to the associated Callback object should be
+    // kept after this method is called, nor should any Callback methods be
+    // executed.
+    ///
+    virtual void OnQueryCanceled(CefRefPtr<CefBrowser> browser,
+                                 CefRefPtr<CefFrame> frame,
+                                 int64 query_id) {}
+
+    virtual ~Handler() {}
+  };
+
+  ///
+  // Create a new router with the specified configuration.
+  ///
+  static CefRefPtr<CefMessageRouterBrowserSide> Create(
+      const CefMessageRouterConfig& config);
+
+  ///
+  // Add a new query handler. If |first| is true it will be added as the first
+  // handler, otherwise it will be added as the last handler. Returns true if
+  // the handler is added successfully or false if the handler has already been
+  // added. Must be called on the browser process UI thread. The Handler object
+  // must either outlive the router or be removed before deletion.
+  ///
+  virtual bool AddHandler(Handler* handler, bool first) =0;
+
+  ///
+  // Remove an existing query handler. Any pending queries associated with the
+  // handler will be canceled. Handler::OnQueryCanceled will be called and the
+  // associated JavaScript onFailure callback will be executed with an error
+  // code of -1. Returns true if the handler is removed successfully or false
+  // if the handler is not found. Must be called on the browser process UI
+  // thread.
+  ///
+  virtual bool RemoveHandler(Handler* handler) =0;
+
+  ///
+  // Cancel all pending queries associated with either |browser| or |handler|.
+  // If both |browser| and |handler| are NULL all pending queries will be
+  // canceled. Handler::OnQueryCanceled will be called and the associated
+  // JavaScript onFailure callback will be executed in all cases with an error
+  // code of -1.
+  ///
+  virtual void CancelPending(CefRefPtr<CefBrowser> browser,
+                             Handler* handler) =0;
+
+  ///
+  // Returns the number of queries currently pending for the specified |browser|
+  // and/or |handler|. Either or both values may be empty. Must be called on the
+  // browser process UI thread.
+  ///
+  virtual int GetPendingCount(CefRefPtr<CefBrowser> browser,
+                              Handler* handler) =0;
+
+
+  // The below methods should be called from other CEF handlers. They must be
+  // called exactly as documented for the router to function correctly.
+
+  ///
+  // Call from CefLifeSpanHandler::OnBeforeClose. Any pending queries associated
+  // with |browser| will be canceled and Handler::OnQueryCanceled will be called.
+  // No JavaScript callbacks will be executed since this indicates destruction
+  // of the browser.
+  ///
+  virtual void OnBeforeClose(CefRefPtr<CefBrowser> browser) =0;
+
+  ///
+  // Call from CefRequestHandler::OnRenderProcessTerminated. Any pending queries
+  // associated with |browser| will be canceled and Handler::OnQueryCanceled
+  // will be called. No JavaScript callbacks will be executed since this
+  // indicates destruction of the context.
+  ///
+  virtual void OnRenderProcessTerminated(CefRefPtr<CefBrowser> browser) =0;
+
+  ///
+  // Call from CefRequestHandler::OnBeforeBrowse only if the navigation is
+  // allowed to proceed. If |frame| is the main frame then any pending queries
+  // associated with |browser| will be canceled and Handler::OnQueryCanceled
+  // will be called. No JavaScript callbacks will be executed since this
+  // indicates destruction of the context.
+  ///
+  virtual void OnBeforeBrowse(CefRefPtr<CefBrowser> browser,
+                              CefRefPtr<CefFrame> frame) =0;
+
+  ///
+  // Call from CefClient::OnProcessMessageReceived. Returns true if the message
+  // is handled by this router or false otherwise.
+  ///
+  virtual bool OnProcessMessageReceived(
+      CefRefPtr<CefBrowser> browser,
+      CefProcessId source_process,
+      CefRefPtr<CefProcessMessage> message) =0;
+
+ protected:
+  // Protect against accidental deletion of this object.
+  friend class base::RefCountedThreadSafe<CefMessageRouterBrowserSide>;
+  virtual ~CefMessageRouterBrowserSide() {}
+};
+
+///
+// Implements the renderer side of query routing. The methods of this class must
+// be called on the render process main thread.
+///
+class CefMessageRouterRendererSide :
+    public base::RefCountedThreadSafe<CefMessageRouterRendererSide> {
+ public:
+  ///
+  // Create a new router with the specified configuration.
+  ///
+  static CefRefPtr<CefMessageRouterRendererSide> Create(
+      const CefMessageRouterConfig& config);
+
+  ///
+  // Returns the number of queries currently pending for the specified |browser|
+  // and/or |context|. Either or both values may be empty.
+  ///
+  virtual int GetPendingCount(CefRefPtr<CefBrowser> browser,
+                              CefRefPtr<CefV8Context> context) =0;
+
+
+  // The below methods should be called from other CEF handlers. They must be
+  // called exactly as documented for the router to function correctly.
+
+  ///
+  // Call from CefRenderProcessHandler::OnContextCreated. Registers the
+  // JavaScripts functions with the new context.
+  ///
+  virtual void OnContextCreated(CefRefPtr<CefBrowser> browser,
+                                CefRefPtr<CefFrame> frame,
+                                CefRefPtr<CefV8Context> context) =0;
+
+  ///
+  // Call from CefRenderProcessHandler::OnContextReleased. Any pending queries
+  // associated with the released context will be canceled and
+  // Handler::OnQueryCanceled will be called in the browser process.
+  ///
+  virtual void OnContextReleased(CefRefPtr<CefBrowser> browser,
+                                 CefRefPtr<CefFrame> frame,
+                                 CefRefPtr<CefV8Context> context) =0;
+  
+  ///
+  // Call from CefRenderProcessHandler::OnProcessMessageReceived. Returns true
+  // if the message is handled by this router or false otherwise.
+  ///
+  virtual bool OnProcessMessageReceived(
+      CefRefPtr<CefBrowser> browser,
+      CefProcessId source_process,
+      CefRefPtr<CefProcessMessage> message) =0;
+
+ protected:
+  // Protect against accidental deletion of this object.
+  friend class base::RefCountedThreadSafe<CefMessageRouterRendererSide>;
+  virtual ~CefMessageRouterRendererSide() {}
+};
+
+#endif  // CEF_INCLUDE_WRAPPER_CEF_MESSAGE_ROUTER_H_
diff --git a/src/include/libcef_/wrapper/cef_resource_manager.h b/src/include/libcef_/wrapper/cef_resource_manager.h
new file mode 100644
index 0000000..87cd1a0
--- /dev/null
+++ b/src/include/libcef_/wrapper/cef_resource_manager.h
@@ -0,0 +1,372 @@
+// Copyright (c) 2015 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file are only available to applications that link
+// against the libcef_dll_wrapper target.
+//
+
+#ifndef CEF_INCLUDE_WRAPPER_CEF_RESOURCE_MANAGER_H_
+#define CEF_INCLUDE_WRAPPER_CEF_RESOURCE_MANAGER_H_
+#pragma once
+
+#include<list>
+
+#include"libcef/base/cef_macros.h"
+#include"libcef/base/cef_ref_counted.h"
+#include"libcef/base/cef_weak_ptr.h"
+#include"libcef/cef_request_handler.h"
+#include"libcef/wrapper/cef_closure_task.h"
+#include"libcef/wrapper/cef_helpers.h"
+
+///
+// Class for managing multiple resource providers. For each resource request
+// providers will be called in order and have the option to (a) handle the
+// request by returning a CefResourceHandler, (b) pass the request to the next
+// provider in order, or (c) stop handling the request. See comments on the
+// Request object for additional usage information. The methods of this class
+// may be called on any browser process thread unless otherwise indicated.
+///
+class CefResourceManager :
+    public base::RefCountedThreadSafe<CefResourceManager, CefDeleteOnIOThread> {
+ public:
+  ///
+  // Provides an opportunity to modify |url| before it is passed to a provider.
+  // For example, the implementation could rewrite |url| to include a default
+  // file extension. |url| will be fully qualified and may contain query or
+  // fragment components.
+  ///
+  typedef base::Callback<std::string(
+      const std::string& /*url*/)> UrlFilter;
+
+  ///
+  // Used to resolve mime types for URLs, usually based on the file extension.
+  // |url| will be fully qualified and may contain query or fragment components.
+  ///
+  typedef base::Callback<std::string(
+      const std::string& /*url*/)> MimeTypeResolver;
+
+ private:
+  // Values that stay with a request as it moves between providers.
+  struct RequestParams {
+    std::string url_;
+    CefRefPtr<CefBrowser> browser_;
+    CefRefPtr<CefFrame> frame_;
+    CefRefPtr<CefRequest> request_;
+    UrlFilter url_filter_;
+    MimeTypeResolver mime_type_resolver_;
+  };
+
+  // Values that are associated with the pending request only.
+  struct RequestState;
+
+ public:
+  ///
+  // Object representing a request. Each request object is used for a single
+  // call to Provider::OnRequest and will become detached (meaning the callbacks
+  // will no longer trigger) after Request::Continue or Request::Stop is called.
+  // A request passed to Provider::OnRequestCanceled will already have been
+  // detached. The methods of this class may be called on any browser process
+  // thread. 
+  ///
+  class Request : public base::RefCountedThreadSafe<Request> {
+   public:
+    ///
+    // Returns the URL associated with this request. The returned value will be
+    // fully qualified but will not contain query or fragment components. It
+    // will already have been passed through the URL filter.
+    ///
+    std::string url() const { return params_.url_; }
+
+    ///
+    // Returns the CefBrowser associated with this request.
+    ///
+    CefRefPtr<CefBrowser> browser() const { return params_.browser_; }
+ 
+    ///
+    // Returns the CefFrame associated with this request.
+    ///
+    CefRefPtr<CefFrame> frame() const { return params_.frame_; }
+
+    ///
+    // Returns the CefRequest associated with this request.
+    ///
+    CefRefPtr<CefRequest> request() const { return params_.request_; }
+
+    ///
+    // Returns the current URL filter.
+    ///
+    const CefResourceManager::UrlFilter& url_filter() const {
+      return params_.url_filter_;
+    }
+
+    ///
+    // Returns the current mime type resolver.
+    ///
+    const CefResourceManager::MimeTypeResolver& mime_type_resolver() const {
+      return params_.mime_type_resolver_;
+    }
+
+    ///
+    // Continue handling the request. If |handler| is non-NULL then no
+    // additional providers will be called and the |handler| value will be
+    // returned via CefResourceManager::GetResourceHandler. If |handler| is NULL
+    // then the next provider in order, if any, will be called. If there are no
+    // additional providers then NULL will be returned via CefResourceManager::
+    // GetResourceHandler. 
+    ///
+    void Continue(CefRefPtr<CefResourceHandler> handler);
+
+    ///
+    // Stop handling the request. No additional providers will be called and
+    // NULL will be returned via CefResourceManager::GetResourceHandler.
+    ///
+    void Stop();
+
+  private:
+    // Only allow deletion via scoped_refptr.
+    friend class base::RefCountedThreadSafe<Request>;
+
+    friend class CefResourceManager;
+
+    // The below methods are called on the browser process IO thread.
+
+    explicit Request(scoped_ptr<RequestState> state);
+
+    scoped_ptr<RequestState> SendRequest();
+    bool HasState();
+
+    static void ContinueOnIOThread(scoped_ptr<RequestState> state,
+                                   CefRefPtr<CefResourceHandler> handler);
+    static void StopOnIOThread(scoped_ptr<RequestState> state);
+
+    // Will be non-NULL while the request is pending. Only accessed on the
+    // browser process IO thread.
+    scoped_ptr<RequestState> state_;
+
+    // Params that stay with this request object. Safe to access on any thread.
+    RequestParams params_;
+
+    DISALLOW_COPY_AND_ASSIGN(Request);
+  };
+
+  typedef std::list<scoped_refptr<Request> > RequestList;
+
+
+  ///
+  // Interface implemented by resource providers. A provider may be created on
+  // any thread but the methods will be called on, and the object will be
+  // destroyed on, the browser process IO thread.
+  ///
+  class Provider {
+   public:
+    ///
+    // Called to handle a request. If the provider knows immediately that it
+    // will not handle the request return false. Otherwise, return true and call
+    // Request::Continue or Request::Stop either in this method or
+    // asynchronously to indicate completion. See comments on Request for
+    // additional usage information.
+    ///
+    virtual bool OnRequest(scoped_refptr<Request> request) =0;
+
+    ///
+    // Called when a request has been canceled. It is still safe to dereference
+    // |request| but any calls to Request::Continue or Request::Stop will be
+    // ignored.
+    ///
+    virtual void OnRequestCanceled(scoped_refptr<Request> request) {}
+
+    virtual ~Provider() {}
+  };
+
+  CefResourceManager();
+
+  ///
+  // Add a provider that maps requests for |url| to |content|. |url| should be
+  // fully qualified but not include a query or fragment component. If
+  // |mime_type| is empty the MimeTypeResolver will be used. See comments on
+  // AddProvider for usage of the |order| and |identifier| parameters.
+  ///
+  void AddContentProvider(const std::string& url,
+                          const std::string& content,
+                          const std::string& mime_type,
+                          int order,
+                          const std::string& identifier);
+
+  ///
+  // Add a provider that maps requests that start with |url_path| to files under
+  // |directory_path|. |url_path| should include an origin and optional path
+  // component only. Files will be loaded when a matching URL is requested.
+  // See comments on AddProvider for usage of the |order| and |identifier|
+  // parameters.
+  ///
+  void AddDirectoryProvider(const std::string& url_path,
+                            const std::string& directory_path,
+                            int order,
+                            const std::string& identifier);
+                    
+  ///
+  // Add a provider that maps requests that start with |url_path| to files
+  // stored in the archive file at |archive_path|. |url_path| should include an
+  // origin and optional path component only. The archive file will be loaded
+  // when a matching URL is requested for the first time. See comments on
+  // AddProvider for usage of the |order| and |identifier| parameters.
+  ///
+  void AddArchiveProvider(const std::string& url_path,
+                          const std::string& archive_path,
+                          const std::string& password,
+                          int order,
+                          const std::string& identifier);
+
+  ///
+  // Add a provider. This object takes ownership of |provider|. Providers will
+  // be called in ascending order based on the |order| value. Multiple providers
+  // sharing the same |order| value will be called in the order that they were
+  // added. The |identifier| value, which does not need to be unique, can be
+  // used to remove the provider at a later time.
+  ///
+  void AddProvider(Provider* provider,
+                   int order,
+                   const std::string& identifier);
+
+  ///
+  // Remove all providers with the specified |identifier| value. If any removed
+  // providers have pending requests the Provider::OnRequestCancel method will
+  // be called. The removed providers may be deleted immediately or at a later
+  // time.
+  ///
+  void RemoveProviders(const std::string& identifier);
+
+  ///
+  // Remove all providers. If any removed providers have pending requests the
+  // Provider::OnRequestCancel method will be called. The removed providers may
+  // be deleted immediately or at a later time.
+  ///
+  void RemoveAllProviders();
+
+  ///
+  // Set the url filter. If not set the default no-op filter will be used.
+  // Changes to this value will not affect currently pending requests.
+  ///
+  void SetUrlFilter(const UrlFilter& filter);
+
+  ///
+  // Set the mime type resolver. If not set the default resolver will be used.
+  // Changes to this value will not affect currently pending requests.
+  ///
+  void SetMimeTypeResolver(const MimeTypeResolver& resolver);
+
+
+  // The below methods should be called from other CEF handlers. They must be
+  // called exactly as documented for the manager to function correctly.
+
+  ///
+  // Called from CefRequestHandler::OnBeforeResourceLoad on the browser process
+  // IO thread.
+  ///
+  cef_return_value_t OnBeforeResourceLoad(
+      CefRefPtr<CefBrowser> browser,
+      CefRefPtr<CefFrame> frame,
+      CefRefPtr<CefRequest> request,
+      CefRefPtr<CefRequestCallback> callback);
+
+  ///
+  // Called from CefRequestHandler::GetResourceHandler on the browser process
+  // IO thread.
+  ///
+  CefRefPtr<CefResourceHandler> GetResourceHandler(
+      CefRefPtr<CefBrowser> browser,
+      CefRefPtr<CefFrame> frame,
+      CefRefPtr<CefRequest> request);
+
+ private:
+  // Only allow deletion via scoped_refptr.
+  friend struct CefDeleteOnThread<TID_IO>;
+  friend class base::RefCountedThreadSafe<CefResourceManager,
+                                          CefDeleteOnIOThread>;
+
+  ~CefResourceManager();
+  
+  // Provider and associated information.
+  struct ProviderEntry;
+  typedef std::list<ProviderEntry*> ProviderEntryList;
+
+  // Values associated with the pending request only. Ownership will be passed
+  // between requests and the resource manager as request handling proceeds.
+  struct RequestState {
+    ~RequestState();
+
+    base::WeakPtr<CefResourceManager> manager_;
+
+    // Callback to execute once request handling is complete.
+    CefRefPtr<CefRequestCallback> callback_;
+
+    // Position of the currently associated ProviderEntry in the |providers_|
+    // list.
+    ProviderEntryList::iterator current_entry_pos_;
+
+    // Position of this request object in the currently associated
+    // ProviderEntry's |pending_requests_| list.
+    RequestList::iterator current_request_pos_;
+
+    // Params that will be copied to each request object.
+    RequestParams params_;
+  };
+
+  // Methods that manage request state between requests. Called on the browser
+  // process IO thread.
+  bool SendRequest(scoped_ptr<RequestState> state);
+  void ContinueRequest(scoped_ptr<RequestState> state,
+                       CefRefPtr<CefResourceHandler> handler);
+  void StopRequest(scoped_ptr<RequestState> state);
+  bool IncrementProvider(RequestState* state);
+  void DetachRequestFromProvider(RequestState* state);
+  void GetNextValidProvider(ProviderEntryList::iterator& iterator);
+  void DeleteProvider(ProviderEntryList::iterator& iterator, bool stop);
+
+  // The below members are only accessed on the browser process IO thread.
+
+  // List of providers including additional associated information.
+  ProviderEntryList providers_;
+
+  // Map of response ID to pending CefResourceHandler object.
+  typedef std::map<uint64, CefRefPtr<CefResourceHandler> > PendingHandlersMap;
+  PendingHandlersMap pending_handlers_;
+
+  UrlFilter url_filter_;
+  MimeTypeResolver mime_type_resolver_;
+
+  // Must be the last member. Created and accessed on the IO thread.
+  scoped_ptr<base::WeakPtrFactory<CefResourceManager> > weak_ptr_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(CefResourceManager);
+};
+
+#endif  // CEF_INCLUDE_WRAPPER_CEF_RESOURCE_MANAGER_H_
diff --git a/src/include/libcef_/wrapper/cef_stream_resource_handler.h b/src/include/libcef_/wrapper/cef_stream_resource_handler.h
new file mode 100644
index 0000000..824e468
--- /dev/null
+++ b/src/include/libcef_/wrapper/cef_stream_resource_handler.h
@@ -0,0 +1,104 @@
+// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file are only available to applications that link
+// against the libcef_dll_wrapper target.
+//
+
+#ifndef CEF_INCLUDE_WRAPPER_CEF_STREAM_RESOURCE_HANDLER_H_
+#define CEF_INCLUDE_WRAPPER_CEF_STREAM_RESOURCE_HANDLER_H_
+#pragma once
+
+#include"libcef/base/cef_macros.h"
+#include"libcef/base/cef_scoped_ptr.h"
+#include"libcef/cef_base.h"
+#include"libcef/cef_resource_handler.h"
+#include"libcef/cef_response.h"
+
+class CefStreamReader;
+
+///
+// Implementation of the CefResourceHandler class for reading from a CefStream.
+///
+class CefStreamResourceHandler : public CefResourceHandler {
+ public:
+  ///
+  // Create a new object with default response values.
+  ///
+  CefStreamResourceHandler(const CefString& mime_type,
+                           CefRefPtr<CefStreamReader> stream);
+  ///
+  // Create a new object with explicit response values.
+  ///
+  CefStreamResourceHandler(int status_code,
+                           const CefString& status_text,
+                           const CefString& mime_type,
+                           CefResponse::HeaderMap header_map,
+                           CefRefPtr<CefStreamReader> stream);
+
+  virtual ~CefStreamResourceHandler();
+
+  // CefResourceHandler methods.
+  virtual bool ProcessRequest(CefRefPtr<CefRequest> request,
+                              CefRefPtr<CefCallback> callback) OVERRIDE;
+  virtual void GetResponseHeaders(CefRefPtr<CefResponse> response,
+                                  int64& response_length,
+                                  CefString& redirectUrl) OVERRIDE;
+  virtual bool ReadResponse(void* data_out,
+                            int bytes_to_read,
+                            int& bytes_read,
+                            CefRefPtr<CefCallback> callback) OVERRIDE;
+  virtual void Cancel() OVERRIDE;
+
+ private:
+  void ReadOnFileThread(int bytes_to_read,
+                        CefRefPtr<CefCallback> callback);
+
+  const int status_code_;
+  const CefString status_text_;
+  const CefString mime_type_;
+  const CefResponse::HeaderMap header_map_;
+  const CefRefPtr<CefStreamReader> stream_;
+  bool read_on_file_thread_;
+
+  class Buffer;
+  scoped_ptr<Buffer> buffer_;
+#ifndef NDEBUG
+  // Used in debug builds to verify that |buffer_| isn't being accessed on
+  // multiple threads at the same time.
+  bool buffer_owned_by_file_thread_;
+#endif
+
+  IMPLEMENT_REFCOUNTING(CefStreamResourceHandler);
+  DISALLOW_COPY_AND_ASSIGN(CefStreamResourceHandler);
+};
+
+#endif  // CEF_INCLUDE_WRAPPER_CEF_STREAM_RESOURCE_HANDLER_H_
diff --git a/src/include/libcef_/wrapper/cef_xml_object.h b/src/include/libcef_/wrapper/cef_xml_object.h
new file mode 100644
index 0000000..57fa2a7
--- /dev/null
+++ b/src/include/libcef_/wrapper/cef_xml_object.h
@@ -0,0 +1,196 @@
+// Copyright (c) 2011 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file are only available to applications that link
+// against the libcef_dll_wrapper target.
+//
+
+#ifndef CEF_INCLUDE_WRAPPER_CEF_XML_OBJECT_H_
+#define CEF_INCLUDE_WRAPPER_CEF_XML_OBJECT_H_
+#pragma once
+
+#include<map>
+#include<vector>
+
+#include"libcef/base/cef_lock.h"
+#include"libcef/base/cef_macros.h"
+#include"libcef/base/cef_ref_counted.h"
+#include"libcef/cef_base.h"
+#include"libcef/cef_xml_reader.h"
+
+class CefStreamReader;
+
+///
+// Thread safe class for representing XML data as a structured object. This
+// class should not be used with large XML documents because all data will be
+// resident in memory at the same time. This implementation supports a
+// restricted set of XML features:
+// <pre>
+// (1) Processing instructions, whitespace and comments are ignored.
+// (2) Elements and attributes must always be referenced using the fully
+//     qualified name (ie, namespace:localname).
+// (3) Empty elements (<a/>) and elements with zero-length values (<a></a>)
+//     are considered the same.
+// (4) Element nodes are considered part of a value if:
+//     (a) The element node follows a non-element node at the same depth
+//         (see 5), or
+//     (b) The element node does not have a namespace and the parent node does.
+// (5) Mixed node types at the same depth are combined into a single element
+//     value as follows:
+//     (a) All node values are concatenated to form a single string value.
+//     (b) Entity reference nodes are resolved to the corresponding entity
+//         value.
+//     (c) Element nodes are represented by their outer XML string.
+// </pre>
+///
+class CefXmlObject : public base::RefCountedThreadSafe<CefXmlObject> {
+ public:
+  typedef std::vector<CefRefPtr<CefXmlObject> > ObjectVector;
+  typedef std::map<CefString, CefString > AttributeMap;
+
+  ///
+  // Create a new object with the specified name. An object name must always be
+  // at least one character long.
+  ///
+  explicit CefXmlObject(const CefString& name);
+
+  ///
+  // Load the contents of the specified XML stream into this object.  The
+  // existing children and attributes, if any, will first be cleared.
+  ///
+  bool Load(CefRefPtr<CefStreamReader> stream,
+            CefXmlReader::EncodingType encodingType,
+            const CefString& URI, CefString* loadError);
+
+  ///
+  // Set the name, children and attributes of this object to a duplicate of the
+  // specified object's contents. The existing children and attributes, if any,
+  // will first be cleared.
+  ///
+  void Set(CefRefPtr<CefXmlObject> object);
+
+  ///
+  // Append a duplicate of the children and attributes of the specified object
+  // to this object. If |overwriteAttributes| is true then any attributes in
+  // this object that also exist in the specified object will be overwritten
+  // with the new values. The name of this object is not changed.
+  ///
+  void Append(CefRefPtr<CefXmlObject> object, bool overwriteAttributes);
+
+  ///
+  // Return a new object with the same name, children and attributes as this
+  // object. The parent of the new object will be NULL.
+  ///
+  CefRefPtr<CefXmlObject> Duplicate();
+
+  ///
+  // Clears this object's children and attributes. The name and parenting of
+  // this object are not changed.
+  ///
+  void Clear();
+
+  ///
+  // Access the object's name. An object name must always be at least one
+  // character long.
+  ///
+  CefString GetName();
+  bool SetName(const CefString& name);
+
+  ///
+  // Access the object's parent. The parent can be NULL if this object has not
+  // been added as the child on another object.
+  ///
+  bool HasParent();
+  CefRefPtr<CefXmlObject> GetParent();
+
+  ///
+  // Access the object's value. An object cannot have a value if it also has
+  // children. Attempting to set the value while children exist will fail.
+  ///
+  bool HasValue();
+  CefString GetValue();
+  bool SetValue(const CefString& value);
+
+  ///
+  // Access the object's attributes. Attributes must have unique names.
+  ///
+  bool HasAttributes();
+  size_t GetAttributeCount();
+  bool HasAttribute(const CefString& name);
+  CefString GetAttributeValue(const CefString& name);
+  bool SetAttributeValue(const CefString& name, const CefString& value);
+  size_t GetAttributes(AttributeMap& attributes);
+  void ClearAttributes();
+
+  ///
+  // Access the object's children. Each object can only have one parent so
+  // attempting to add an object that already has a parent will fail. Removing a
+  // child will set the child's parent to NULL. Adding a child will set the
+  // child's parent to this object. This object's value, if any, will be cleared
+  // if a child is added.
+  ///
+  bool HasChildren();
+  size_t GetChildCount();
+  bool HasChild(CefRefPtr<CefXmlObject> child);
+  bool AddChild(CefRefPtr<CefXmlObject> child);
+  bool RemoveChild(CefRefPtr<CefXmlObject> child);
+  size_t GetChildren(ObjectVector& children);
+  void ClearChildren();
+
+  ///
+  // Find the first child with the specified name.
+  ///
+  CefRefPtr<CefXmlObject> FindChild(const CefString& name);
+
+  ///
+  // Find all children with the specified name.
+  ///
+  size_t FindChildren(const CefString& name, ObjectVector& children);
+
+ private:
+  // Protect against accidental deletion of this object.
+  friend class base::RefCountedThreadSafe<CefXmlObject>;
+  ~CefXmlObject();
+
+  void SetParent(CefXmlObject* parent);
+
+  CefString name_;
+  CefXmlObject* parent_;
+  CefString value_;
+  AttributeMap attributes_;
+  ObjectVector children_;
+
+  base::Lock lock_;
+
+  DISALLOW_COPY_AND_ASSIGN(CefXmlObject);
+};
+
+#endif  // CEF_INCLUDE_WRAPPER_CEF_XML_OBJECT_H_
diff --git a/src/include/libcef_/wrapper/cef_zip_archive.h b/src/include/libcef_/wrapper/cef_zip_archive.h
new file mode 100644
index 0000000..7d63c29
--- /dev/null
+++ b/src/include/libcef_/wrapper/cef_zip_archive.h
@@ -0,0 +1,143 @@
+// Copyright (c) 2011 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file are only available to applications that link
+// against the libcef_dll_wrapper target.
+//
+
+#ifndef CEF_INCLUDE_WRAPPER_CEF_ZIP_ARCHIVE_H_
+#define CEF_INCLUDE_WRAPPER_CEF_ZIP_ARCHIVE_H_
+#pragma once
+
+#include<map>
+
+#include"libcef/base/cef_lock.h"
+#include"libcef/base/cef_macros.h"
+#include"libcef/base/cef_ref_counted.h"
+#include"libcef/cef_base.h"
+
+class CefStreamReader;
+
+///
+// Thread-safe class for accessing zip archive file contents. This class should
+// not be used with large archive files because all data will be resident in
+// memory at the same time. This implementation supports a restricted set of zip
+// archive features:
+// (1) All file names are stored and compared in lower case.
+// (2) File ordering from the original zip archive is not maintained. This
+//     means that files from the same folder may not be located together in the
+//     file content map.
+///
+class CefZipArchive : public base::RefCountedThreadSafe<CefZipArchive> {
+ public:
+  ///
+  // Class representing a file in the archive. Accessing the file data from
+  // multiple threads is safe provided a reference to the File object is kept.
+  ///
+  class File : public CefBase {
+   public:
+    ///
+    // Returns the read-only data contained in the file.
+    ///
+    virtual const unsigned char* GetData() const =0;
+
+    ///
+    // Returns the size of the data in the file.
+    ///
+    virtual size_t GetDataSize() const =0;
+
+    ///
+    // Returns a CefStreamReader object for streaming the contents of the file.
+    ///
+    virtual CefRefPtr<CefStreamReader> GetStreamReader() const =0;
+  };
+
+  typedef std::map<CefString, CefRefPtr<File> > FileMap;
+
+  ///
+  // Create a new object.
+  ///
+  CefZipArchive();
+
+  ///
+  // Load the contents of the specified zip archive stream into this object.
+  // If the zip archive requires a password then provide it via |password|.
+  // If |overwriteExisting| is true then any files in this object that also
+  // exist in the specified archive will be replaced with the new files.
+  // Returns the number of files successfully loaded.
+  ///
+  size_t Load(CefRefPtr<CefStreamReader> stream,
+              const CefString& password,
+              bool overwriteExisting);
+
+  ///
+  // Clears the contents of this object.
+  ///
+  void Clear();
+
+  ///
+  // Returns the number of files in the archive.
+  ///
+  size_t GetFileCount() const;
+
+  ///
+  // Returns true if the specified file exists and has contents.
+  ///
+  bool HasFile(const CefString& fileName) const;
+
+  ///
+  // Returns the specified file.
+  ///
+  CefRefPtr<File> GetFile(const CefString& fileName) const;
+
+  ///
+  // Removes the specified file.
+  ///
+  bool RemoveFile(const CefString& fileName);
+
+  ///
+  // Returns the map of all files.
+  ///
+  size_t GetFiles(FileMap& map) const;
+
+ private:
+  // Protect against accidental deletion of this object.
+  friend class base::RefCountedThreadSafe<CefZipArchive>;
+  ~CefZipArchive();
+
+  FileMap contents_;
+
+  mutable base::Lock lock_;
+
+  DISALLOW_COPY_AND_ASSIGN(CefZipArchive);
+};
+
+#endif  // CEF_INCLUDE_WRAPPER_CEF_ZIP_ARCHIVE_H_
diff --git a/src/include/openssl/__DECC_INCLUDE_EPILOGUE.H b/src/include/openssl/__DECC_INCLUDE_EPILOGUE.H
new file mode 100644
index 0000000..d251d0a
--- /dev/null
+++ b/src/include/openssl/__DECC_INCLUDE_EPILOGUE.H
@@ -0,0 +1,22 @@
+/*
+ * Copyright 2016-2020 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+/*
+ * This file is only used by HP C/C++ on VMS, and is included automatically
+ * after each header file from this directory
+ */
+
+/*
+ * The C++ compiler doesn't understand these pragmas, even though it
+ * understands the corresponding command line qualifier.
+ */
+#ifndef __cplusplus
+/* restore state.  Must correspond to the save in __decc_include_prologue.h */
+# pragma names restore
+#endif
diff --git a/src/include/openssl/__DECC_INCLUDE_PROLOGUE.H b/src/include/openssl/__DECC_INCLUDE_PROLOGUE.H
new file mode 100644
index 0000000..91ac6b3
--- /dev/null
+++ b/src/include/openssl/__DECC_INCLUDE_PROLOGUE.H
@@ -0,0 +1,26 @@
+/*
+ * Copyright 2016-2020 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+/*
+ * This file is only used by HP C/C++ on VMS, and is included automatically
+ * after each header file from this directory
+ */
+
+/*
+ * The C++ compiler doesn't understand these pragmas, even though it
+ * understands the corresponding command line qualifier.
+ */
+#ifndef __cplusplus
+/* save state */
+# pragma names save
+/* have the compiler shorten symbols larger than 31 chars to 23 chars
+ * followed by a 8 hex char CRC
+ */
+# pragma names as_is,shortened
+#endif
diff --git a/src/include/openssl/aes.h b/src/include/openssl/aes.h
new file mode 100644
index 0000000..d0f9dfc
--- /dev/null
+++ b/src/include/openssl/aes.h
@@ -0,0 +1,111 @@
+/*
+ * Copyright 2002-2020 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_AES_H
+# define OPENSSL_AES_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_AES_H
+# endif
+
+# include <openssl/opensslconf.h>
+
+# include <stddef.h>
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+# define AES_BLOCK_SIZE 16
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+
+#  define AES_ENCRYPT     1
+#  define AES_DECRYPT     0
+
+#  define AES_MAXNR 14
+
+
+/* This should be a hidden type, but EVP requires that the size be known */
+struct aes_key_st {
+#  ifdef AES_LONG
+    unsigned long rd_key[4 * (AES_MAXNR + 1)];
+#  else
+    unsigned int rd_key[4 * (AES_MAXNR + 1)];
+#  endif
+    int rounds;
+};
+typedef struct aes_key_st AES_KEY;
+
+# endif
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 const char *AES_options(void);
+OSSL_DEPRECATEDIN_3_0
+int AES_set_encrypt_key(const unsigned char *userKey, const int bits,
+                        AES_KEY *key);
+OSSL_DEPRECATEDIN_3_0
+int AES_set_decrypt_key(const unsigned char *userKey, const int bits,
+                        AES_KEY *key);
+OSSL_DEPRECATEDIN_3_0
+void AES_encrypt(const unsigned char *in, unsigned char *out,
+                 const AES_KEY *key);
+OSSL_DEPRECATEDIN_3_0
+void AES_decrypt(const unsigned char *in, unsigned char *out,
+                 const AES_KEY *key);
+OSSL_DEPRECATEDIN_3_0
+void AES_ecb_encrypt(const unsigned char *in, unsigned char *out,
+                     const AES_KEY *key, const int enc);
+OSSL_DEPRECATEDIN_3_0
+void AES_cbc_encrypt(const unsigned char *in, unsigned char *out,
+                     size_t length, const AES_KEY *key,
+                     unsigned char *ivec, const int enc);
+OSSL_DEPRECATEDIN_3_0
+void AES_cfb128_encrypt(const unsigned char *in, unsigned char *out,
+                        size_t length, const AES_KEY *key,
+                        unsigned char *ivec, int *num, const int enc);
+OSSL_DEPRECATEDIN_3_0
+void AES_cfb1_encrypt(const unsigned char *in, unsigned char *out,
+                      size_t length, const AES_KEY *key,
+                      unsigned char *ivec, int *num, const int enc);
+OSSL_DEPRECATEDIN_3_0
+void AES_cfb8_encrypt(const unsigned char *in, unsigned char *out,
+                      size_t length, const AES_KEY *key,
+                      unsigned char *ivec, int *num, const int enc);
+OSSL_DEPRECATEDIN_3_0
+void AES_ofb128_encrypt(const unsigned char *in, unsigned char *out,
+                        size_t length, const AES_KEY *key,
+                        unsigned char *ivec, int *num);
+
+/* NB: the IV is _two_ blocks long */
+OSSL_DEPRECATEDIN_3_0
+void AES_ige_encrypt(const unsigned char *in, unsigned char *out,
+                     size_t length, const AES_KEY *key,
+                     unsigned char *ivec, const int enc);
+/* NB: the IV is _four_ blocks long */
+OSSL_DEPRECATEDIN_3_0
+void AES_bi_ige_encrypt(const unsigned char *in, unsigned char *out,
+                        size_t length, const AES_KEY *key, const AES_KEY *key2,
+                        const unsigned char *ivec, const int enc);
+OSSL_DEPRECATEDIN_3_0
+int AES_wrap_key(AES_KEY *key, const unsigned char *iv,
+                 unsigned char *out, const unsigned char *in,
+                 unsigned int inlen);
+OSSL_DEPRECATEDIN_3_0
+int AES_unwrap_key(AES_KEY *key, const unsigned char *iv,
+                   unsigned char *out, const unsigned char *in,
+                   unsigned int inlen);
+# endif
+
+
+# ifdef  __cplusplus
+}
+# endif
+
+#endif
diff --git a/src/include/openssl/applink.c b/src/include/openssl/applink.c
new file mode 100644
index 0000000..601d016
--- /dev/null
+++ b/src/include/openssl/applink.c
@@ -0,0 +1,153 @@
+/*
+ * Copyright 2004-2023 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#define APPLINK_STDIN   1
+#define APPLINK_STDOUT  2
+#define APPLINK_STDERR  3
+#define APPLINK_FPRINTF 4
+#define APPLINK_FGETS   5
+#define APPLINK_FREAD   6
+#define APPLINK_FWRITE  7
+#define APPLINK_FSETMOD 8
+#define APPLINK_FEOF    9
+#define APPLINK_FCLOSE  10      /* should not be used */
+
+#define APPLINK_FOPEN   11      /* solely for completeness */
+#define APPLINK_FSEEK   12
+#define APPLINK_FTELL   13
+#define APPLINK_FFLUSH  14
+#define APPLINK_FERROR  15
+#define APPLINK_CLEARERR 16
+#define APPLINK_FILENO  17      /* to be used with below */
+
+#define APPLINK_OPEN    18      /* formally can't be used, as flags can vary */
+#define APPLINK_READ    19
+#define APPLINK_WRITE   20
+#define APPLINK_LSEEK   21
+#define APPLINK_CLOSE   22
+#define APPLINK_MAX     22      /* always same as last macro */
+
+#ifndef APPMACROS_ONLY
+
+/*
+ * Normally, do not define APPLINK_NO_INCLUDES.  Define it if you are using
+ * symbol preprocessing and do not want the preprocessing to affect the
+ * following included header files.  You will need to put these
+ * include lines somewhere in the file that is including applink.c.
+ */
+# ifndef APPLINK_NO_INCLUDES
+#  include <stdio.h>
+#  include <io.h>
+#  include <fcntl.h>
+# endif
+
+# ifdef __BORLANDC__
+   /* _lseek in <io.h> is a function-like macro so we can't take its address */
+#  undef _lseek
+#  define _lseek lseek
+# endif
+
+static void *app_stdin(void)
+{
+    return stdin;
+}
+
+static void *app_stdout(void)
+{
+    return stdout;
+}
+
+static void *app_stderr(void)
+{
+    return stderr;
+}
+
+static int app_feof(FILE *fp)
+{
+    return feof(fp);
+}
+
+static int app_ferror(FILE *fp)
+{
+    return ferror(fp);
+}
+
+static void app_clearerr(FILE *fp)
+{
+    clearerr(fp);
+}
+
+static int app_fileno(FILE *fp)
+{
+    return _fileno(fp);
+}
+
+static int app_fsetmod(FILE *fp, char mod)
+{
+    return _setmode(_fileno(fp), mod == 'b' ? _O_BINARY : _O_TEXT);
+}
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+__declspec(dllexport)
+void **
+# if defined(__BORLANDC__)
+/*
+ * __stdcall appears to be the only way to get the name
+ * decoration right with Borland C. Otherwise it works
+ * purely incidentally, as we pass no parameters.
+ */
+__stdcall
+# else
+__cdecl
+# endif
+OPENSSL_Applink(void)
+{
+    static int once = 1;
+    static void *OPENSSL_ApplinkTable[APPLINK_MAX + 1] =
+        { (void *)APPLINK_MAX };
+
+    if (once) {
+        OPENSSL_ApplinkTable[APPLINK_STDIN] = app_stdin;
+        OPENSSL_ApplinkTable[APPLINK_STDOUT] = app_stdout;
+        OPENSSL_ApplinkTable[APPLINK_STDERR] = app_stderr;
+        OPENSSL_ApplinkTable[APPLINK_FPRINTF] = fprintf;
+        OPENSSL_ApplinkTable[APPLINK_FGETS] = fgets;
+        OPENSSL_ApplinkTable[APPLINK_FREAD] = fread;
+        OPENSSL_ApplinkTable[APPLINK_FWRITE] = fwrite;
+        OPENSSL_ApplinkTable[APPLINK_FSETMOD] = app_fsetmod;
+        OPENSSL_ApplinkTable[APPLINK_FEOF] = app_feof;
+        OPENSSL_ApplinkTable[APPLINK_FCLOSE] = fclose;
+
+        OPENSSL_ApplinkTable[APPLINK_FOPEN] = fopen;
+        OPENSSL_ApplinkTable[APPLINK_FSEEK] = fseek;
+        OPENSSL_ApplinkTable[APPLINK_FTELL] = ftell;
+        OPENSSL_ApplinkTable[APPLINK_FFLUSH] = fflush;
+        OPENSSL_ApplinkTable[APPLINK_FERROR] = app_ferror;
+        OPENSSL_ApplinkTable[APPLINK_CLEARERR] = app_clearerr;
+        OPENSSL_ApplinkTable[APPLINK_FILENO] = app_fileno;
+
+        OPENSSL_ApplinkTable[APPLINK_OPEN] = _open;
+        OPENSSL_ApplinkTable[APPLINK_READ] = _read;
+        OPENSSL_ApplinkTable[APPLINK_WRITE] = _write;
+        OPENSSL_ApplinkTable[APPLINK_LSEEK] = _lseek;
+        OPENSSL_ApplinkTable[APPLINK_CLOSE] = _close;
+
+        once = 0;
+    }
+
+    return OPENSSL_ApplinkTable;
+}
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/include/openssl/asn1.h b/src/include/openssl/asn1.h
new file mode 100644
index 0000000..0776856
--- /dev/null
+++ b/src/include/openssl/asn1.h
@@ -0,0 +1,1133 @@
+/*
+ * WARNING: do not edit!
+ * Generated by makefile from include\openssl\asn1.h.in
+ *
+ * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+
+
+#ifndef OPENSSL_ASN1_H
+# define OPENSSL_ASN1_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_ASN1_H
+# endif
+
+# ifndef OPENSSL_NO_STDIO
+#  include <stdio.h>
+# endif
+# include <time.h>
+# include <openssl/e_os2.h>
+# include <openssl/opensslconf.h>
+# include <openssl/bio.h>
+# include <openssl/safestack.h>
+# include <openssl/asn1err.h>
+# include <openssl/symhacks.h>
+
+# include <openssl/types.h>
+# include <openssl/bn.h>
+
+# ifdef OPENSSL_BUILD_SHLIBCRYPTO
+#  undef OPENSSL_EXTERN
+#  define OPENSSL_EXTERN OPENSSL_EXPORT
+# endif
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+# define V_ASN1_UNIVERSAL                0x00
+# define V_ASN1_APPLICATION              0x40
+# define V_ASN1_CONTEXT_SPECIFIC         0x80
+# define V_ASN1_PRIVATE                  0xc0
+
+# define V_ASN1_CONSTRUCTED              0x20
+# define V_ASN1_PRIMITIVE_TAG            0x1f
+# define V_ASN1_PRIMATIVE_TAG /*compat*/ V_ASN1_PRIMITIVE_TAG
+
+# define V_ASN1_APP_CHOOSE               -2/* let the recipient choose */
+# define V_ASN1_OTHER                    -3/* used in ASN1_TYPE */
+# define V_ASN1_ANY                      -4/* used in ASN1 template code */
+
+# define V_ASN1_UNDEF                    -1
+/* ASN.1 tag values */
+# define V_ASN1_EOC                      0
+# define V_ASN1_BOOLEAN                  1 /**/
+# define V_ASN1_INTEGER                  2
+# define V_ASN1_BIT_STRING               3
+# define V_ASN1_OCTET_STRING             4
+# define V_ASN1_NULL                     5
+# define V_ASN1_OBJECT                   6
+# define V_ASN1_OBJECT_DESCRIPTOR        7
+# define V_ASN1_EXTERNAL                 8
+# define V_ASN1_REAL                     9
+# define V_ASN1_ENUMERATED               10
+# define V_ASN1_UTF8STRING               12
+# define V_ASN1_SEQUENCE                 16
+# define V_ASN1_SET                      17
+# define V_ASN1_NUMERICSTRING            18 /**/
+# define V_ASN1_PRINTABLESTRING          19
+# define V_ASN1_T61STRING                20
+# define V_ASN1_TELETEXSTRING            20/* alias */
+# define V_ASN1_VIDEOTEXSTRING           21 /**/
+# define V_ASN1_IA5STRING                22
+# define V_ASN1_UTCTIME                  23
+# define V_ASN1_GENERALIZEDTIME          24 /**/
+# define V_ASN1_GRAPHICSTRING            25 /**/
+# define V_ASN1_ISO64STRING              26 /**/
+# define V_ASN1_VISIBLESTRING            26/* alias */
+# define V_ASN1_GENERALSTRING            27 /**/
+# define V_ASN1_UNIVERSALSTRING          28 /**/
+# define V_ASN1_BMPSTRING                30
+
+/*
+ * NB the constants below are used internally by ASN1_INTEGER
+ * and ASN1_ENUMERATED to indicate the sign. They are *not* on
+ * the wire tag values.
+ */
+
+# define V_ASN1_NEG                      0x100
+# define V_ASN1_NEG_INTEGER              (2 | V_ASN1_NEG)
+# define V_ASN1_NEG_ENUMERATED           (10 | V_ASN1_NEG)
+
+/* For use with d2i_ASN1_type_bytes() */
+# define B_ASN1_NUMERICSTRING    0x0001
+# define B_ASN1_PRINTABLESTRING  0x0002
+# define B_ASN1_T61STRING        0x0004
+# define B_ASN1_TELETEXSTRING    0x0004
+# define B_ASN1_VIDEOTEXSTRING   0x0008
+# define B_ASN1_IA5STRING        0x0010
+# define B_ASN1_GRAPHICSTRING    0x0020
+# define B_ASN1_ISO64STRING      0x0040
+# define B_ASN1_VISIBLESTRING    0x0040
+# define B_ASN1_GENERALSTRING    0x0080
+# define B_ASN1_UNIVERSALSTRING  0x0100
+# define B_ASN1_OCTET_STRING     0x0200
+# define B_ASN1_BIT_STRING       0x0400
+# define B_ASN1_BMPSTRING        0x0800
+# define B_ASN1_UNKNOWN          0x1000
+# define B_ASN1_UTF8STRING       0x2000
+# define B_ASN1_UTCTIME          0x4000
+# define B_ASN1_GENERALIZEDTIME  0x8000
+# define B_ASN1_SEQUENCE         0x10000
+/* For use with ASN1_mbstring_copy() */
+# define MBSTRING_FLAG           0x1000
+# define MBSTRING_UTF8           (MBSTRING_FLAG)
+# define MBSTRING_ASC            (MBSTRING_FLAG|1)
+# define MBSTRING_BMP            (MBSTRING_FLAG|2)
+# define MBSTRING_UNIV           (MBSTRING_FLAG|4)
+# define SMIME_OLDMIME           0x400
+# define SMIME_CRLFEOL           0x800
+# define SMIME_STREAM            0x1000
+
+/* Stacks for types not otherwise defined in this header */
+SKM_DEFINE_STACK_OF_INTERNAL(X509_ALGOR, X509_ALGOR, X509_ALGOR)
+#define sk_X509_ALGOR_num(sk) OPENSSL_sk_num(ossl_check_const_X509_ALGOR_sk_type(sk))
+#define sk_X509_ALGOR_value(sk, idx) ((X509_ALGOR *)OPENSSL_sk_value(ossl_check_const_X509_ALGOR_sk_type(sk), (idx)))
+#define sk_X509_ALGOR_new(cmp) ((STACK_OF(X509_ALGOR) *)OPENSSL_sk_new(ossl_check_X509_ALGOR_compfunc_type(cmp)))
+#define sk_X509_ALGOR_new_null() ((STACK_OF(X509_ALGOR) *)OPENSSL_sk_new_null())
+#define sk_X509_ALGOR_new_reserve(cmp, n) ((STACK_OF(X509_ALGOR) *)OPENSSL_sk_new_reserve(ossl_check_X509_ALGOR_compfunc_type(cmp), (n)))
+#define sk_X509_ALGOR_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_X509_ALGOR_sk_type(sk), (n))
+#define sk_X509_ALGOR_free(sk) OPENSSL_sk_free(ossl_check_X509_ALGOR_sk_type(sk))
+#define sk_X509_ALGOR_zero(sk) OPENSSL_sk_zero(ossl_check_X509_ALGOR_sk_type(sk))
+#define sk_X509_ALGOR_delete(sk, i) ((X509_ALGOR *)OPENSSL_sk_delete(ossl_check_X509_ALGOR_sk_type(sk), (i)))
+#define sk_X509_ALGOR_delete_ptr(sk, ptr) ((X509_ALGOR *)OPENSSL_sk_delete_ptr(ossl_check_X509_ALGOR_sk_type(sk), ossl_check_X509_ALGOR_type(ptr)))
+#define sk_X509_ALGOR_push(sk, ptr) OPENSSL_sk_push(ossl_check_X509_ALGOR_sk_type(sk), ossl_check_X509_ALGOR_type(ptr))
+#define sk_X509_ALGOR_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_X509_ALGOR_sk_type(sk), ossl_check_X509_ALGOR_type(ptr))
+#define sk_X509_ALGOR_pop(sk) ((X509_ALGOR *)OPENSSL_sk_pop(ossl_check_X509_ALGOR_sk_type(sk)))
+#define sk_X509_ALGOR_shift(sk) ((X509_ALGOR *)OPENSSL_sk_shift(ossl_check_X509_ALGOR_sk_type(sk)))
+#define sk_X509_ALGOR_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_ALGOR_sk_type(sk),ossl_check_X509_ALGOR_freefunc_type(freefunc))
+#define sk_X509_ALGOR_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_X509_ALGOR_sk_type(sk), ossl_check_X509_ALGOR_type(ptr), (idx))
+#define sk_X509_ALGOR_set(sk, idx, ptr) ((X509_ALGOR *)OPENSSL_sk_set(ossl_check_X509_ALGOR_sk_type(sk), (idx), ossl_check_X509_ALGOR_type(ptr)))
+#define sk_X509_ALGOR_find(sk, ptr) OPENSSL_sk_find(ossl_check_X509_ALGOR_sk_type(sk), ossl_check_X509_ALGOR_type(ptr))
+#define sk_X509_ALGOR_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_X509_ALGOR_sk_type(sk), ossl_check_X509_ALGOR_type(ptr))
+#define sk_X509_ALGOR_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_X509_ALGOR_sk_type(sk), ossl_check_X509_ALGOR_type(ptr), pnum)
+#define sk_X509_ALGOR_sort(sk) OPENSSL_sk_sort(ossl_check_X509_ALGOR_sk_type(sk))
+#define sk_X509_ALGOR_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_X509_ALGOR_sk_type(sk))
+#define sk_X509_ALGOR_dup(sk) ((STACK_OF(X509_ALGOR) *)OPENSSL_sk_dup(ossl_check_const_X509_ALGOR_sk_type(sk)))
+#define sk_X509_ALGOR_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_ALGOR) *)OPENSSL_sk_deep_copy(ossl_check_const_X509_ALGOR_sk_type(sk), ossl_check_X509_ALGOR_copyfunc_type(copyfunc), ossl_check_X509_ALGOR_freefunc_type(freefunc)))
+#define sk_X509_ALGOR_set_cmp_func(sk, cmp) ((sk_X509_ALGOR_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_X509_ALGOR_sk_type(sk), ossl_check_X509_ALGOR_compfunc_type(cmp)))
+
+
+
+# define ASN1_STRING_FLAG_BITS_LEFT 0x08 /* Set if 0x07 has bits left value */
+/*
+ * This indicates that the ASN1_STRING is not a real value but just a place
+ * holder for the location where indefinite length constructed data should be
+ * inserted in the memory buffer
+ */
+# define ASN1_STRING_FLAG_NDEF 0x010
+
+/*
+ * This flag is used by the CMS code to indicate that a string is not
+ * complete and is a place holder for content when it had all been accessed.
+ * The flag will be reset when content has been written to it.
+ */
+
+# define ASN1_STRING_FLAG_CONT 0x020
+/*
+ * This flag is used by ASN1 code to indicate an ASN1_STRING is an MSTRING
+ * type.
+ */
+# define ASN1_STRING_FLAG_MSTRING 0x040
+/* String is embedded and only content should be freed */
+# define ASN1_STRING_FLAG_EMBED 0x080
+/* String should be parsed in RFC 5280's time format */
+# define ASN1_STRING_FLAG_X509_TIME 0x100
+/* This is the base type that holds just about everything :-) */
+struct asn1_string_st {
+    int length;
+    int type;
+    unsigned char *data;
+    /*
+     * The value of the following field depends on the type being held.  It
+     * is mostly being used for BIT_STRING so if the input data has a
+     * non-zero 'unused bits' value, it will be handled correctly
+     */
+    long flags;
+};
+
+/*
+ * ASN1_ENCODING structure: this is used to save the received encoding of an
+ * ASN1 type. This is useful to get round problems with invalid encodings
+ * which can break signatures.
+ */
+
+typedef struct ASN1_ENCODING_st {
+    unsigned char *enc;         /* DER encoding */
+    long len;                   /* Length of encoding */
+    int modified;               /* set to 1 if 'enc' is invalid */
+} ASN1_ENCODING;
+
+/* Used with ASN1 LONG type: if a long is set to this it is omitted */
+# define ASN1_LONG_UNDEF 0x7fffffffL
+
+# define STABLE_FLAGS_MALLOC     0x01
+/*
+ * A zero passed to ASN1_STRING_TABLE_new_add for the flags is interpreted
+ * as "don't change" and STABLE_FLAGS_MALLOC is always set. By setting
+ * STABLE_FLAGS_MALLOC only we can clear the existing value. Use the alias
+ * STABLE_FLAGS_CLEAR to reflect this.
+ */
+# define STABLE_FLAGS_CLEAR      STABLE_FLAGS_MALLOC
+# define STABLE_NO_MASK          0x02
+# define DIRSTRING_TYPE  \
+ (B_ASN1_PRINTABLESTRING|B_ASN1_T61STRING|B_ASN1_BMPSTRING|B_ASN1_UTF8STRING)
+# define PKCS9STRING_TYPE (DIRSTRING_TYPE|B_ASN1_IA5STRING)
+
+struct asn1_string_table_st {
+    int nid;
+    long minsize;
+    long maxsize;
+    unsigned long mask;
+    unsigned long flags;
+};
+
+SKM_DEFINE_STACK_OF_INTERNAL(ASN1_STRING_TABLE, ASN1_STRING_TABLE, ASN1_STRING_TABLE)
+#define sk_ASN1_STRING_TABLE_num(sk) OPENSSL_sk_num(ossl_check_const_ASN1_STRING_TABLE_sk_type(sk))
+#define sk_ASN1_STRING_TABLE_value(sk, idx) ((ASN1_STRING_TABLE *)OPENSSL_sk_value(ossl_check_const_ASN1_STRING_TABLE_sk_type(sk), (idx)))
+#define sk_ASN1_STRING_TABLE_new(cmp) ((STACK_OF(ASN1_STRING_TABLE) *)OPENSSL_sk_new(ossl_check_ASN1_STRING_TABLE_compfunc_type(cmp)))
+#define sk_ASN1_STRING_TABLE_new_null() ((STACK_OF(ASN1_STRING_TABLE) *)OPENSSL_sk_new_null())
+#define sk_ASN1_STRING_TABLE_new_reserve(cmp, n) ((STACK_OF(ASN1_STRING_TABLE) *)OPENSSL_sk_new_reserve(ossl_check_ASN1_STRING_TABLE_compfunc_type(cmp), (n)))
+#define sk_ASN1_STRING_TABLE_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_ASN1_STRING_TABLE_sk_type(sk), (n))
+#define sk_ASN1_STRING_TABLE_free(sk) OPENSSL_sk_free(ossl_check_ASN1_STRING_TABLE_sk_type(sk))
+#define sk_ASN1_STRING_TABLE_zero(sk) OPENSSL_sk_zero(ossl_check_ASN1_STRING_TABLE_sk_type(sk))
+#define sk_ASN1_STRING_TABLE_delete(sk, i) ((ASN1_STRING_TABLE *)OPENSSL_sk_delete(ossl_check_ASN1_STRING_TABLE_sk_type(sk), (i)))
+#define sk_ASN1_STRING_TABLE_delete_ptr(sk, ptr) ((ASN1_STRING_TABLE *)OPENSSL_sk_delete_ptr(ossl_check_ASN1_STRING_TABLE_sk_type(sk), ossl_check_ASN1_STRING_TABLE_type(ptr)))
+#define sk_ASN1_STRING_TABLE_push(sk, ptr) OPENSSL_sk_push(ossl_check_ASN1_STRING_TABLE_sk_type(sk), ossl_check_ASN1_STRING_TABLE_type(ptr))
+#define sk_ASN1_STRING_TABLE_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_ASN1_STRING_TABLE_sk_type(sk), ossl_check_ASN1_STRING_TABLE_type(ptr))
+#define sk_ASN1_STRING_TABLE_pop(sk) ((ASN1_STRING_TABLE *)OPENSSL_sk_pop(ossl_check_ASN1_STRING_TABLE_sk_type(sk)))
+#define sk_ASN1_STRING_TABLE_shift(sk) ((ASN1_STRING_TABLE *)OPENSSL_sk_shift(ossl_check_ASN1_STRING_TABLE_sk_type(sk)))
+#define sk_ASN1_STRING_TABLE_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ASN1_STRING_TABLE_sk_type(sk),ossl_check_ASN1_STRING_TABLE_freefunc_type(freefunc))
+#define sk_ASN1_STRING_TABLE_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_ASN1_STRING_TABLE_sk_type(sk), ossl_check_ASN1_STRING_TABLE_type(ptr), (idx))
+#define sk_ASN1_STRING_TABLE_set(sk, idx, ptr) ((ASN1_STRING_TABLE *)OPENSSL_sk_set(ossl_check_ASN1_STRING_TABLE_sk_type(sk), (idx), ossl_check_ASN1_STRING_TABLE_type(ptr)))
+#define sk_ASN1_STRING_TABLE_find(sk, ptr) OPENSSL_sk_find(ossl_check_ASN1_STRING_TABLE_sk_type(sk), ossl_check_ASN1_STRING_TABLE_type(ptr))
+#define sk_ASN1_STRING_TABLE_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_ASN1_STRING_TABLE_sk_type(sk), ossl_check_ASN1_STRING_TABLE_type(ptr))
+#define sk_ASN1_STRING_TABLE_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_ASN1_STRING_TABLE_sk_type(sk), ossl_check_ASN1_STRING_TABLE_type(ptr), pnum)
+#define sk_ASN1_STRING_TABLE_sort(sk) OPENSSL_sk_sort(ossl_check_ASN1_STRING_TABLE_sk_type(sk))
+#define sk_ASN1_STRING_TABLE_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_ASN1_STRING_TABLE_sk_type(sk))
+#define sk_ASN1_STRING_TABLE_dup(sk) ((STACK_OF(ASN1_STRING_TABLE) *)OPENSSL_sk_dup(ossl_check_const_ASN1_STRING_TABLE_sk_type(sk)))
+#define sk_ASN1_STRING_TABLE_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ASN1_STRING_TABLE) *)OPENSSL_sk_deep_copy(ossl_check_const_ASN1_STRING_TABLE_sk_type(sk), ossl_check_ASN1_STRING_TABLE_copyfunc_type(copyfunc), ossl_check_ASN1_STRING_TABLE_freefunc_type(freefunc)))
+#define sk_ASN1_STRING_TABLE_set_cmp_func(sk, cmp) ((sk_ASN1_STRING_TABLE_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_ASN1_STRING_TABLE_sk_type(sk), ossl_check_ASN1_STRING_TABLE_compfunc_type(cmp)))
+
+
+/* size limits: this stuff is taken straight from RFC2459 */
+
+# define ub_name                         32768
+# define ub_common_name                  64
+# define ub_locality_name                128
+# define ub_state_name                   128
+# define ub_organization_name            64
+# define ub_organization_unit_name       64
+# define ub_title                        64
+# define ub_email_address                128
+
+/*
+ * Declarations for template structures: for full definitions see asn1t.h
+ */
+typedef struct ASN1_TEMPLATE_st ASN1_TEMPLATE;
+typedef struct ASN1_TLC_st ASN1_TLC;
+/* This is just an opaque pointer */
+typedef struct ASN1_VALUE_st ASN1_VALUE;
+
+/* Declare ASN1 functions: the implement macro in in asn1t.h */
+
+/*
+ * The mysterious 'extern' that's passed to some macros is innocuous,
+ * and is there to quiet pre-C99 compilers that may complain about empty
+ * arguments in macro calls.
+ */
+
+# define DECLARE_ASN1_FUNCTIONS_attr(attr, type)                            \
+    DECLARE_ASN1_FUNCTIONS_name_attr(attr, type, type)
+# define DECLARE_ASN1_FUNCTIONS(type)                                       \
+    DECLARE_ASN1_FUNCTIONS_attr(extern, type)
+
+# define DECLARE_ASN1_ALLOC_FUNCTIONS_attr(attr, type)                      \
+    DECLARE_ASN1_ALLOC_FUNCTIONS_name_attr(attr, type, type)
+# define DECLARE_ASN1_ALLOC_FUNCTIONS(type)                                 \
+    DECLARE_ASN1_ALLOC_FUNCTIONS_attr(extern, type)
+
+# define DECLARE_ASN1_FUNCTIONS_name_attr(attr, type, name)                 \
+    DECLARE_ASN1_ALLOC_FUNCTIONS_name_attr(attr, type, name)                \
+    DECLARE_ASN1_ENCODE_FUNCTIONS_name_attr(attr, type, name)
+# define DECLARE_ASN1_FUNCTIONS_name(type, name)                            \
+    DECLARE_ASN1_FUNCTIONS_name_attr(extern, type, name)
+
+# define DECLARE_ASN1_ENCODE_FUNCTIONS_attr(attr, type, itname, name)       \
+    DECLARE_ASN1_ENCODE_FUNCTIONS_only_attr(attr, type, name)               \
+    DECLARE_ASN1_ITEM_attr(attr, itname)
+# define DECLARE_ASN1_ENCODE_FUNCTIONS(type, itname, name)                  \
+    DECLARE_ASN1_ENCODE_FUNCTIONS_attr(extern, type, itname, name)
+
+# define DECLARE_ASN1_ENCODE_FUNCTIONS_name_attr(attr, type, name)          \
+    DECLARE_ASN1_ENCODE_FUNCTIONS_attr(attr, type, name, name)
+# define DECLARE_ASN1_ENCODE_FUNCTIONS_name(type, name) \
+    DECLARE_ASN1_ENCODE_FUNCTIONS_name_attr(extern, type, name)
+
+# define DECLARE_ASN1_ENCODE_FUNCTIONS_only_attr(attr, type, name)          \
+    attr type *d2i_##name(type **a, const unsigned char **in, long len);    \
+    attr int i2d_##name(const type *a, unsigned char **out);
+# define DECLARE_ASN1_ENCODE_FUNCTIONS_only(type, name)                     \
+    DECLARE_ASN1_ENCODE_FUNCTIONS_only_attr(extern, type, name)
+
+# define DECLARE_ASN1_NDEF_FUNCTION_attr(attr, name)                        \
+    attr int i2d_##name##_NDEF(const name *a, unsigned char **out);
+# define DECLARE_ASN1_NDEF_FUNCTION(name)                                   \
+    DECLARE_ASN1_NDEF_FUNCTION_attr(extern, name)
+
+# define DECLARE_ASN1_ALLOC_FUNCTIONS_name_attr(attr, type, name)           \
+    attr type *name##_new(void);                                            \
+    attr void name##_free(type *a);
+# define DECLARE_ASN1_ALLOC_FUNCTIONS_name(type, name)                      \
+    DECLARE_ASN1_ALLOC_FUNCTIONS_name_attr(extern, type, name)
+
+# define DECLARE_ASN1_DUP_FUNCTION_attr(attr, type)                         \
+    DECLARE_ASN1_DUP_FUNCTION_name_attr(attr, type, type)
+# define DECLARE_ASN1_DUP_FUNCTION(type)                                    \
+    DECLARE_ASN1_DUP_FUNCTION_attr(extern, type)
+
+# define DECLARE_ASN1_DUP_FUNCTION_name_attr(attr, type, name)              \
+    attr type *name##_dup(const type *a);
+# define DECLARE_ASN1_DUP_FUNCTION_name(type, name)                         \
+    DECLARE_ASN1_DUP_FUNCTION_name_attr(extern, type, name)
+
+# define DECLARE_ASN1_PRINT_FUNCTION_attr(attr, stname)                     \
+    DECLARE_ASN1_PRINT_FUNCTION_fname_attr(attr, stname, stname)
+# define DECLARE_ASN1_PRINT_FUNCTION(stname)                                \
+    DECLARE_ASN1_PRINT_FUNCTION_attr(extern, stname)
+
+# define DECLARE_ASN1_PRINT_FUNCTION_fname_attr(attr, stname, fname)        \
+    attr int fname##_print_ctx(BIO *out, const stname *x, int indent,       \
+                               const ASN1_PCTX *pctx);
+# define DECLARE_ASN1_PRINT_FUNCTION_fname(stname, fname)                   \
+    DECLARE_ASN1_PRINT_FUNCTION_fname_attr(extern, stname, fname)
+
+# define D2I_OF(type) type *(*)(type **,const unsigned char **,long)
+# define I2D_OF(type) int (*)(const type *,unsigned char **)
+
+# define CHECKED_D2I_OF(type, d2i) \
+    ((d2i_of_void*) (1 ? d2i : ((D2I_OF(type))0)))
+# define CHECKED_I2D_OF(type, i2d) \
+    ((i2d_of_void*) (1 ? i2d : ((I2D_OF(type))0)))
+# define CHECKED_NEW_OF(type, xnew) \
+    ((void *(*)(void)) (1 ? xnew : ((type *(*)(void))0)))
+# define CHECKED_PTR_OF(type, p) \
+    ((void*) (1 ? p : (type*)0))
+# define CHECKED_PPTR_OF(type, p) \
+    ((void**) (1 ? p : (type**)0))
+
+# define TYPEDEF_D2I_OF(type) typedef type *d2i_of_##type(type **,const unsigned char **,long)
+# define TYPEDEF_I2D_OF(type) typedef int i2d_of_##type(const type *,unsigned char **)
+# define TYPEDEF_D2I2D_OF(type) TYPEDEF_D2I_OF(type); TYPEDEF_I2D_OF(type)
+
+typedef void *d2i_of_void(void **, const unsigned char **, long);
+typedef int i2d_of_void(const void *, unsigned char **);
+
+/*-
+ * The following macros and typedefs allow an ASN1_ITEM
+ * to be embedded in a structure and referenced. Since
+ * the ASN1_ITEM pointers need to be globally accessible
+ * (possibly from shared libraries) they may exist in
+ * different forms. On platforms that support it the
+ * ASN1_ITEM structure itself will be globally exported.
+ * Other platforms will export a function that returns
+ * an ASN1_ITEM pointer.
+ *
+ * To handle both cases transparently the macros below
+ * should be used instead of hard coding an ASN1_ITEM
+ * pointer in a structure.
+ *
+ * The structure will look like this:
+ *
+ * typedef struct SOMETHING_st {
+ *      ...
+ *      ASN1_ITEM_EXP *iptr;
+ *      ...
+ * } SOMETHING;
+ *
+ * It would be initialised as e.g.:
+ *
+ * SOMETHING somevar = {...,ASN1_ITEM_ref(X509),...};
+ *
+ * and the actual pointer extracted with:
+ *
+ * const ASN1_ITEM *it = ASN1_ITEM_ptr(somevar.iptr);
+ *
+ * Finally an ASN1_ITEM pointer can be extracted from an
+ * appropriate reference with: ASN1_ITEM_rptr(X509). This
+ * would be used when a function takes an ASN1_ITEM * argument.
+ *
+ */
+
+
+/*
+ * Platforms that can't easily handle shared global variables are declared as
+ * functions returning ASN1_ITEM pointers.
+ */
+
+/* ASN1_ITEM pointer exported type */
+typedef const ASN1_ITEM *ASN1_ITEM_EXP (void);
+
+/* Macro to obtain ASN1_ITEM pointer from exported type */
+# define ASN1_ITEM_ptr(iptr) (iptr())
+
+/* Macro to include ASN1_ITEM pointer from base type */
+# define ASN1_ITEM_ref(iptr) (iptr##_it)
+
+# define ASN1_ITEM_rptr(ref) (ref##_it())
+
+# define DECLARE_ASN1_ITEM_attr(attr, name)                                 \
+    attr const ASN1_ITEM * name##_it(void);
+# define DECLARE_ASN1_ITEM(name)                                            \
+    DECLARE_ASN1_ITEM_attr(extern, name)
+
+/* Parameters used by ASN1_STRING_print_ex() */
+
+/*
+ * These determine which characters to escape: RFC2253 special characters,
+ * control characters and MSB set characters
+ */
+
+# define ASN1_STRFLGS_ESC_2253           1
+# define ASN1_STRFLGS_ESC_CTRL           2
+# define ASN1_STRFLGS_ESC_MSB            4
+
+/* Lower 8 bits are reserved as an output type specifier */
+# define ASN1_DTFLGS_TYPE_MASK    0x0FUL
+# define ASN1_DTFLGS_RFC822       0x00UL
+# define ASN1_DTFLGS_ISO8601      0x01UL
+
+/*
+ * This flag determines how we do escaping: normally RC2253 backslash only,
+ * set this to use backslash and quote.
+ */
+
+# define ASN1_STRFLGS_ESC_QUOTE          8
+
+/* These three flags are internal use only. */
+
+/* Character is a valid PrintableString character */
+# define CHARTYPE_PRINTABLESTRING        0x10
+/* Character needs escaping if it is the first character */
+# define CHARTYPE_FIRST_ESC_2253         0x20
+/* Character needs escaping if it is the last character */
+# define CHARTYPE_LAST_ESC_2253          0x40
+
+/*
+ * NB the internal flags are safely reused below by flags handled at the top
+ * level.
+ */
+
+/*
+ * If this is set we convert all character strings to UTF8 first
+ */
+
+# define ASN1_STRFLGS_UTF8_CONVERT       0x10
+
+/*
+ * If this is set we don't attempt to interpret content: just assume all
+ * strings are 1 byte per character. This will produce some pretty odd
+ * looking output!
+ */
+
+# define ASN1_STRFLGS_IGNORE_TYPE        0x20
+
+/* If this is set we include the string type in the output */
+# define ASN1_STRFLGS_SHOW_TYPE          0x40
+
+/*
+ * This determines which strings to display and which to 'dump' (hex dump of
+ * content octets or DER encoding). We can only dump non character strings or
+ * everything. If we don't dump 'unknown' they are interpreted as character
+ * strings with 1 octet per character and are subject to the usual escaping
+ * options.
+ */
+
+# define ASN1_STRFLGS_DUMP_ALL           0x80
+# define ASN1_STRFLGS_DUMP_UNKNOWN       0x100
+
+/*
+ * These determine what 'dumping' does, we can dump the content octets or the
+ * DER encoding: both use the RFC2253 #XXXXX notation.
+ */
+
+# define ASN1_STRFLGS_DUMP_DER           0x200
+
+/*
+ * This flag specifies that RC2254 escaping shall be performed.
+ */
+#define ASN1_STRFLGS_ESC_2254           0x400
+
+/*
+ * All the string flags consistent with RFC2253, escaping control characters
+ * isn't essential in RFC2253 but it is advisable anyway.
+ */
+
+# define ASN1_STRFLGS_RFC2253    (ASN1_STRFLGS_ESC_2253 | \
+                                ASN1_STRFLGS_ESC_CTRL | \
+                                ASN1_STRFLGS_ESC_MSB | \
+                                ASN1_STRFLGS_UTF8_CONVERT | \
+                                ASN1_STRFLGS_DUMP_UNKNOWN | \
+                                ASN1_STRFLGS_DUMP_DER)
+
+
+struct asn1_type_st {
+    int type;
+    union {
+        char *ptr;
+        ASN1_BOOLEAN boolean;
+        ASN1_STRING *asn1_string;
+        ASN1_OBJECT *object;
+        ASN1_INTEGER *integer;
+        ASN1_ENUMERATED *enumerated;
+        ASN1_BIT_STRING *bit_string;
+        ASN1_OCTET_STRING *octet_string;
+        ASN1_PRINTABLESTRING *printablestring;
+        ASN1_T61STRING *t61string;
+        ASN1_IA5STRING *ia5string;
+        ASN1_GENERALSTRING *generalstring;
+        ASN1_BMPSTRING *bmpstring;
+        ASN1_UNIVERSALSTRING *universalstring;
+        ASN1_UTCTIME *utctime;
+        ASN1_GENERALIZEDTIME *generalizedtime;
+        ASN1_VISIBLESTRING *visiblestring;
+        ASN1_UTF8STRING *utf8string;
+        /*
+         * set and sequence are left complete and still contain the set or
+         * sequence bytes
+         */
+        ASN1_STRING *set;
+        ASN1_STRING *sequence;
+        ASN1_VALUE *asn1_value;
+    } value;
+};
+
+SKM_DEFINE_STACK_OF_INTERNAL(ASN1_TYPE, ASN1_TYPE, ASN1_TYPE)
+#define sk_ASN1_TYPE_num(sk) OPENSSL_sk_num(ossl_check_const_ASN1_TYPE_sk_type(sk))
+#define sk_ASN1_TYPE_value(sk, idx) ((ASN1_TYPE *)OPENSSL_sk_value(ossl_check_const_ASN1_TYPE_sk_type(sk), (idx)))
+#define sk_ASN1_TYPE_new(cmp) ((STACK_OF(ASN1_TYPE) *)OPENSSL_sk_new(ossl_check_ASN1_TYPE_compfunc_type(cmp)))
+#define sk_ASN1_TYPE_new_null() ((STACK_OF(ASN1_TYPE) *)OPENSSL_sk_new_null())
+#define sk_ASN1_TYPE_new_reserve(cmp, n) ((STACK_OF(ASN1_TYPE) *)OPENSSL_sk_new_reserve(ossl_check_ASN1_TYPE_compfunc_type(cmp), (n)))
+#define sk_ASN1_TYPE_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_ASN1_TYPE_sk_type(sk), (n))
+#define sk_ASN1_TYPE_free(sk) OPENSSL_sk_free(ossl_check_ASN1_TYPE_sk_type(sk))
+#define sk_ASN1_TYPE_zero(sk) OPENSSL_sk_zero(ossl_check_ASN1_TYPE_sk_type(sk))
+#define sk_ASN1_TYPE_delete(sk, i) ((ASN1_TYPE *)OPENSSL_sk_delete(ossl_check_ASN1_TYPE_sk_type(sk), (i)))
+#define sk_ASN1_TYPE_delete_ptr(sk, ptr) ((ASN1_TYPE *)OPENSSL_sk_delete_ptr(ossl_check_ASN1_TYPE_sk_type(sk), ossl_check_ASN1_TYPE_type(ptr)))
+#define sk_ASN1_TYPE_push(sk, ptr) OPENSSL_sk_push(ossl_check_ASN1_TYPE_sk_type(sk), ossl_check_ASN1_TYPE_type(ptr))
+#define sk_ASN1_TYPE_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_ASN1_TYPE_sk_type(sk), ossl_check_ASN1_TYPE_type(ptr))
+#define sk_ASN1_TYPE_pop(sk) ((ASN1_TYPE *)OPENSSL_sk_pop(ossl_check_ASN1_TYPE_sk_type(sk)))
+#define sk_ASN1_TYPE_shift(sk) ((ASN1_TYPE *)OPENSSL_sk_shift(ossl_check_ASN1_TYPE_sk_type(sk)))
+#define sk_ASN1_TYPE_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ASN1_TYPE_sk_type(sk),ossl_check_ASN1_TYPE_freefunc_type(freefunc))
+#define sk_ASN1_TYPE_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_ASN1_TYPE_sk_type(sk), ossl_check_ASN1_TYPE_type(ptr), (idx))
+#define sk_ASN1_TYPE_set(sk, idx, ptr) ((ASN1_TYPE *)OPENSSL_sk_set(ossl_check_ASN1_TYPE_sk_type(sk), (idx), ossl_check_ASN1_TYPE_type(ptr)))
+#define sk_ASN1_TYPE_find(sk, ptr) OPENSSL_sk_find(ossl_check_ASN1_TYPE_sk_type(sk), ossl_check_ASN1_TYPE_type(ptr))
+#define sk_ASN1_TYPE_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_ASN1_TYPE_sk_type(sk), ossl_check_ASN1_TYPE_type(ptr))
+#define sk_ASN1_TYPE_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_ASN1_TYPE_sk_type(sk), ossl_check_ASN1_TYPE_type(ptr), pnum)
+#define sk_ASN1_TYPE_sort(sk) OPENSSL_sk_sort(ossl_check_ASN1_TYPE_sk_type(sk))
+#define sk_ASN1_TYPE_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_ASN1_TYPE_sk_type(sk))
+#define sk_ASN1_TYPE_dup(sk) ((STACK_OF(ASN1_TYPE) *)OPENSSL_sk_dup(ossl_check_const_ASN1_TYPE_sk_type(sk)))
+#define sk_ASN1_TYPE_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ASN1_TYPE) *)OPENSSL_sk_deep_copy(ossl_check_const_ASN1_TYPE_sk_type(sk), ossl_check_ASN1_TYPE_copyfunc_type(copyfunc), ossl_check_ASN1_TYPE_freefunc_type(freefunc)))
+#define sk_ASN1_TYPE_set_cmp_func(sk, cmp) ((sk_ASN1_TYPE_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_ASN1_TYPE_sk_type(sk), ossl_check_ASN1_TYPE_compfunc_type(cmp)))
+
+
+typedef STACK_OF(ASN1_TYPE) ASN1_SEQUENCE_ANY;
+
+DECLARE_ASN1_ENCODE_FUNCTIONS_name(ASN1_SEQUENCE_ANY, ASN1_SEQUENCE_ANY)
+DECLARE_ASN1_ENCODE_FUNCTIONS_name(ASN1_SEQUENCE_ANY, ASN1_SET_ANY)
+
+/* This is used to contain a list of bit names */
+typedef struct BIT_STRING_BITNAME_st {
+    int bitnum;
+    const char *lname;
+    const char *sname;
+} BIT_STRING_BITNAME;
+
+# define B_ASN1_TIME \
+                        B_ASN1_UTCTIME | \
+                        B_ASN1_GENERALIZEDTIME
+
+# define B_ASN1_PRINTABLE \
+                        B_ASN1_NUMERICSTRING| \
+                        B_ASN1_PRINTABLESTRING| \
+                        B_ASN1_T61STRING| \
+                        B_ASN1_IA5STRING| \
+                        B_ASN1_BIT_STRING| \
+                        B_ASN1_UNIVERSALSTRING|\
+                        B_ASN1_BMPSTRING|\
+                        B_ASN1_UTF8STRING|\
+                        B_ASN1_SEQUENCE|\
+                        B_ASN1_UNKNOWN
+
+# define B_ASN1_DIRECTORYSTRING \
+                        B_ASN1_PRINTABLESTRING| \
+                        B_ASN1_TELETEXSTRING|\
+                        B_ASN1_BMPSTRING|\
+                        B_ASN1_UNIVERSALSTRING|\
+                        B_ASN1_UTF8STRING
+
+# define B_ASN1_DISPLAYTEXT \
+                        B_ASN1_IA5STRING| \
+                        B_ASN1_VISIBLESTRING| \
+                        B_ASN1_BMPSTRING|\
+                        B_ASN1_UTF8STRING
+
+DECLARE_ASN1_ALLOC_FUNCTIONS_name(ASN1_TYPE, ASN1_TYPE)
+DECLARE_ASN1_ENCODE_FUNCTIONS(ASN1_TYPE, ASN1_ANY, ASN1_TYPE)
+
+int ASN1_TYPE_get(const ASN1_TYPE *a);
+void ASN1_TYPE_set(ASN1_TYPE *a, int type, void *value);
+int ASN1_TYPE_set1(ASN1_TYPE *a, int type, const void *value);
+int ASN1_TYPE_cmp(const ASN1_TYPE *a, const ASN1_TYPE *b);
+
+ASN1_TYPE *ASN1_TYPE_pack_sequence(const ASN1_ITEM *it, void *s, ASN1_TYPE **t);
+void *ASN1_TYPE_unpack_sequence(const ASN1_ITEM *it, const ASN1_TYPE *t);
+
+SKM_DEFINE_STACK_OF_INTERNAL(ASN1_OBJECT, ASN1_OBJECT, ASN1_OBJECT)
+#define sk_ASN1_OBJECT_num(sk) OPENSSL_sk_num(ossl_check_const_ASN1_OBJECT_sk_type(sk))
+#define sk_ASN1_OBJECT_value(sk, idx) ((ASN1_OBJECT *)OPENSSL_sk_value(ossl_check_const_ASN1_OBJECT_sk_type(sk), (idx)))
+#define sk_ASN1_OBJECT_new(cmp) ((STACK_OF(ASN1_OBJECT) *)OPENSSL_sk_new(ossl_check_ASN1_OBJECT_compfunc_type(cmp)))
+#define sk_ASN1_OBJECT_new_null() ((STACK_OF(ASN1_OBJECT) *)OPENSSL_sk_new_null())
+#define sk_ASN1_OBJECT_new_reserve(cmp, n) ((STACK_OF(ASN1_OBJECT) *)OPENSSL_sk_new_reserve(ossl_check_ASN1_OBJECT_compfunc_type(cmp), (n)))
+#define sk_ASN1_OBJECT_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_ASN1_OBJECT_sk_type(sk), (n))
+#define sk_ASN1_OBJECT_free(sk) OPENSSL_sk_free(ossl_check_ASN1_OBJECT_sk_type(sk))
+#define sk_ASN1_OBJECT_zero(sk) OPENSSL_sk_zero(ossl_check_ASN1_OBJECT_sk_type(sk))
+#define sk_ASN1_OBJECT_delete(sk, i) ((ASN1_OBJECT *)OPENSSL_sk_delete(ossl_check_ASN1_OBJECT_sk_type(sk), (i)))
+#define sk_ASN1_OBJECT_delete_ptr(sk, ptr) ((ASN1_OBJECT *)OPENSSL_sk_delete_ptr(ossl_check_ASN1_OBJECT_sk_type(sk), ossl_check_ASN1_OBJECT_type(ptr)))
+#define sk_ASN1_OBJECT_push(sk, ptr) OPENSSL_sk_push(ossl_check_ASN1_OBJECT_sk_type(sk), ossl_check_ASN1_OBJECT_type(ptr))
+#define sk_ASN1_OBJECT_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_ASN1_OBJECT_sk_type(sk), ossl_check_ASN1_OBJECT_type(ptr))
+#define sk_ASN1_OBJECT_pop(sk) ((ASN1_OBJECT *)OPENSSL_sk_pop(ossl_check_ASN1_OBJECT_sk_type(sk)))
+#define sk_ASN1_OBJECT_shift(sk) ((ASN1_OBJECT *)OPENSSL_sk_shift(ossl_check_ASN1_OBJECT_sk_type(sk)))
+#define sk_ASN1_OBJECT_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ASN1_OBJECT_sk_type(sk),ossl_check_ASN1_OBJECT_freefunc_type(freefunc))
+#define sk_ASN1_OBJECT_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_ASN1_OBJECT_sk_type(sk), ossl_check_ASN1_OBJECT_type(ptr), (idx))
+#define sk_ASN1_OBJECT_set(sk, idx, ptr) ((ASN1_OBJECT *)OPENSSL_sk_set(ossl_check_ASN1_OBJECT_sk_type(sk), (idx), ossl_check_ASN1_OBJECT_type(ptr)))
+#define sk_ASN1_OBJECT_find(sk, ptr) OPENSSL_sk_find(ossl_check_ASN1_OBJECT_sk_type(sk), ossl_check_ASN1_OBJECT_type(ptr))
+#define sk_ASN1_OBJECT_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_ASN1_OBJECT_sk_type(sk), ossl_check_ASN1_OBJECT_type(ptr))
+#define sk_ASN1_OBJECT_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_ASN1_OBJECT_sk_type(sk), ossl_check_ASN1_OBJECT_type(ptr), pnum)
+#define sk_ASN1_OBJECT_sort(sk) OPENSSL_sk_sort(ossl_check_ASN1_OBJECT_sk_type(sk))
+#define sk_ASN1_OBJECT_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_ASN1_OBJECT_sk_type(sk))
+#define sk_ASN1_OBJECT_dup(sk) ((STACK_OF(ASN1_OBJECT) *)OPENSSL_sk_dup(ossl_check_const_ASN1_OBJECT_sk_type(sk)))
+#define sk_ASN1_OBJECT_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ASN1_OBJECT) *)OPENSSL_sk_deep_copy(ossl_check_const_ASN1_OBJECT_sk_type(sk), ossl_check_ASN1_OBJECT_copyfunc_type(copyfunc), ossl_check_ASN1_OBJECT_freefunc_type(freefunc)))
+#define sk_ASN1_OBJECT_set_cmp_func(sk, cmp) ((sk_ASN1_OBJECT_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_ASN1_OBJECT_sk_type(sk), ossl_check_ASN1_OBJECT_compfunc_type(cmp)))
+
+
+DECLARE_ASN1_FUNCTIONS(ASN1_OBJECT)
+
+ASN1_STRING *ASN1_STRING_new(void);
+void ASN1_STRING_free(ASN1_STRING *a);
+void ASN1_STRING_clear_free(ASN1_STRING *a);
+int ASN1_STRING_copy(ASN1_STRING *dst, const ASN1_STRING *str);
+DECLARE_ASN1_DUP_FUNCTION(ASN1_STRING)
+ASN1_STRING *ASN1_STRING_type_new(int type);
+int ASN1_STRING_cmp(const ASN1_STRING *a, const ASN1_STRING *b);
+  /*
+   * Since this is used to store all sorts of things, via macros, for now,
+   * make its data void *
+   */
+int ASN1_STRING_set(ASN1_STRING *str, const void *data, int len);
+void ASN1_STRING_set0(ASN1_STRING *str, void *data, int len);
+int ASN1_STRING_length(const ASN1_STRING *x);
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 void ASN1_STRING_length_set(ASN1_STRING *x, int n);
+# endif
+int ASN1_STRING_type(const ASN1_STRING *x);
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+OSSL_DEPRECATEDIN_1_1_0 unsigned char *ASN1_STRING_data(ASN1_STRING *x);
+# endif
+const unsigned char *ASN1_STRING_get0_data(const ASN1_STRING *x);
+
+DECLARE_ASN1_FUNCTIONS(ASN1_BIT_STRING)
+int ASN1_BIT_STRING_set(ASN1_BIT_STRING *a, unsigned char *d, int length);
+int ASN1_BIT_STRING_set_bit(ASN1_BIT_STRING *a, int n, int value);
+int ASN1_BIT_STRING_get_bit(const ASN1_BIT_STRING *a, int n);
+int ASN1_BIT_STRING_check(const ASN1_BIT_STRING *a,
+                          const unsigned char *flags, int flags_len);
+
+int ASN1_BIT_STRING_name_print(BIO *out, ASN1_BIT_STRING *bs,
+                               BIT_STRING_BITNAME *tbl, int indent);
+int ASN1_BIT_STRING_num_asc(const char *name, BIT_STRING_BITNAME *tbl);
+int ASN1_BIT_STRING_set_asc(ASN1_BIT_STRING *bs, const char *name, int value,
+                            BIT_STRING_BITNAME *tbl);
+
+SKM_DEFINE_STACK_OF_INTERNAL(ASN1_INTEGER, ASN1_INTEGER, ASN1_INTEGER)
+#define sk_ASN1_INTEGER_num(sk) OPENSSL_sk_num(ossl_check_const_ASN1_INTEGER_sk_type(sk))
+#define sk_ASN1_INTEGER_value(sk, idx) ((ASN1_INTEGER *)OPENSSL_sk_value(ossl_check_const_ASN1_INTEGER_sk_type(sk), (idx)))
+#define sk_ASN1_INTEGER_new(cmp) ((STACK_OF(ASN1_INTEGER) *)OPENSSL_sk_new(ossl_check_ASN1_INTEGER_compfunc_type(cmp)))
+#define sk_ASN1_INTEGER_new_null() ((STACK_OF(ASN1_INTEGER) *)OPENSSL_sk_new_null())
+#define sk_ASN1_INTEGER_new_reserve(cmp, n) ((STACK_OF(ASN1_INTEGER) *)OPENSSL_sk_new_reserve(ossl_check_ASN1_INTEGER_compfunc_type(cmp), (n)))
+#define sk_ASN1_INTEGER_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_ASN1_INTEGER_sk_type(sk), (n))
+#define sk_ASN1_INTEGER_free(sk) OPENSSL_sk_free(ossl_check_ASN1_INTEGER_sk_type(sk))
+#define sk_ASN1_INTEGER_zero(sk) OPENSSL_sk_zero(ossl_check_ASN1_INTEGER_sk_type(sk))
+#define sk_ASN1_INTEGER_delete(sk, i) ((ASN1_INTEGER *)OPENSSL_sk_delete(ossl_check_ASN1_INTEGER_sk_type(sk), (i)))
+#define sk_ASN1_INTEGER_delete_ptr(sk, ptr) ((ASN1_INTEGER *)OPENSSL_sk_delete_ptr(ossl_check_ASN1_INTEGER_sk_type(sk), ossl_check_ASN1_INTEGER_type(ptr)))
+#define sk_ASN1_INTEGER_push(sk, ptr) OPENSSL_sk_push(ossl_check_ASN1_INTEGER_sk_type(sk), ossl_check_ASN1_INTEGER_type(ptr))
+#define sk_ASN1_INTEGER_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_ASN1_INTEGER_sk_type(sk), ossl_check_ASN1_INTEGER_type(ptr))
+#define sk_ASN1_INTEGER_pop(sk) ((ASN1_INTEGER *)OPENSSL_sk_pop(ossl_check_ASN1_INTEGER_sk_type(sk)))
+#define sk_ASN1_INTEGER_shift(sk) ((ASN1_INTEGER *)OPENSSL_sk_shift(ossl_check_ASN1_INTEGER_sk_type(sk)))
+#define sk_ASN1_INTEGER_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ASN1_INTEGER_sk_type(sk),ossl_check_ASN1_INTEGER_freefunc_type(freefunc))
+#define sk_ASN1_INTEGER_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_ASN1_INTEGER_sk_type(sk), ossl_check_ASN1_INTEGER_type(ptr), (idx))
+#define sk_ASN1_INTEGER_set(sk, idx, ptr) ((ASN1_INTEGER *)OPENSSL_sk_set(ossl_check_ASN1_INTEGER_sk_type(sk), (idx), ossl_check_ASN1_INTEGER_type(ptr)))
+#define sk_ASN1_INTEGER_find(sk, ptr) OPENSSL_sk_find(ossl_check_ASN1_INTEGER_sk_type(sk), ossl_check_ASN1_INTEGER_type(ptr))
+#define sk_ASN1_INTEGER_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_ASN1_INTEGER_sk_type(sk), ossl_check_ASN1_INTEGER_type(ptr))
+#define sk_ASN1_INTEGER_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_ASN1_INTEGER_sk_type(sk), ossl_check_ASN1_INTEGER_type(ptr), pnum)
+#define sk_ASN1_INTEGER_sort(sk) OPENSSL_sk_sort(ossl_check_ASN1_INTEGER_sk_type(sk))
+#define sk_ASN1_INTEGER_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_ASN1_INTEGER_sk_type(sk))
+#define sk_ASN1_INTEGER_dup(sk) ((STACK_OF(ASN1_INTEGER) *)OPENSSL_sk_dup(ossl_check_const_ASN1_INTEGER_sk_type(sk)))
+#define sk_ASN1_INTEGER_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ASN1_INTEGER) *)OPENSSL_sk_deep_copy(ossl_check_const_ASN1_INTEGER_sk_type(sk), ossl_check_ASN1_INTEGER_copyfunc_type(copyfunc), ossl_check_ASN1_INTEGER_freefunc_type(freefunc)))
+#define sk_ASN1_INTEGER_set_cmp_func(sk, cmp) ((sk_ASN1_INTEGER_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_ASN1_INTEGER_sk_type(sk), ossl_check_ASN1_INTEGER_compfunc_type(cmp)))
+
+
+
+DECLARE_ASN1_FUNCTIONS(ASN1_INTEGER)
+ASN1_INTEGER *d2i_ASN1_UINTEGER(ASN1_INTEGER **a, const unsigned char **pp,
+                                long length);
+DECLARE_ASN1_DUP_FUNCTION(ASN1_INTEGER)
+int ASN1_INTEGER_cmp(const ASN1_INTEGER *x, const ASN1_INTEGER *y);
+
+DECLARE_ASN1_FUNCTIONS(ASN1_ENUMERATED)
+
+int ASN1_UTCTIME_check(const ASN1_UTCTIME *a);
+ASN1_UTCTIME *ASN1_UTCTIME_set(ASN1_UTCTIME *s, time_t t);
+ASN1_UTCTIME *ASN1_UTCTIME_adj(ASN1_UTCTIME *s, time_t t,
+                               int offset_day, long offset_sec);
+int ASN1_UTCTIME_set_string(ASN1_UTCTIME *s, const char *str);
+int ASN1_UTCTIME_cmp_time_t(const ASN1_UTCTIME *s, time_t t);
+
+int ASN1_GENERALIZEDTIME_check(const ASN1_GENERALIZEDTIME *a);
+ASN1_GENERALIZEDTIME *ASN1_GENERALIZEDTIME_set(ASN1_GENERALIZEDTIME *s,
+                                               time_t t);
+ASN1_GENERALIZEDTIME *ASN1_GENERALIZEDTIME_adj(ASN1_GENERALIZEDTIME *s,
+                                               time_t t, int offset_day,
+                                               long offset_sec);
+int ASN1_GENERALIZEDTIME_set_string(ASN1_GENERALIZEDTIME *s, const char *str);
+
+int ASN1_TIME_diff(int *pday, int *psec,
+                   const ASN1_TIME *from, const ASN1_TIME *to);
+
+DECLARE_ASN1_FUNCTIONS(ASN1_OCTET_STRING)
+DECLARE_ASN1_DUP_FUNCTION(ASN1_OCTET_STRING)
+int ASN1_OCTET_STRING_cmp(const ASN1_OCTET_STRING *a,
+                          const ASN1_OCTET_STRING *b);
+int ASN1_OCTET_STRING_set(ASN1_OCTET_STRING *str, const unsigned char *data,
+                          int len);
+
+SKM_DEFINE_STACK_OF_INTERNAL(ASN1_UTF8STRING, ASN1_UTF8STRING, ASN1_UTF8STRING)
+#define sk_ASN1_UTF8STRING_num(sk) OPENSSL_sk_num(ossl_check_const_ASN1_UTF8STRING_sk_type(sk))
+#define sk_ASN1_UTF8STRING_value(sk, idx) ((ASN1_UTF8STRING *)OPENSSL_sk_value(ossl_check_const_ASN1_UTF8STRING_sk_type(sk), (idx)))
+#define sk_ASN1_UTF8STRING_new(cmp) ((STACK_OF(ASN1_UTF8STRING) *)OPENSSL_sk_new(ossl_check_ASN1_UTF8STRING_compfunc_type(cmp)))
+#define sk_ASN1_UTF8STRING_new_null() ((STACK_OF(ASN1_UTF8STRING) *)OPENSSL_sk_new_null())
+#define sk_ASN1_UTF8STRING_new_reserve(cmp, n) ((STACK_OF(ASN1_UTF8STRING) *)OPENSSL_sk_new_reserve(ossl_check_ASN1_UTF8STRING_compfunc_type(cmp), (n)))
+#define sk_ASN1_UTF8STRING_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_ASN1_UTF8STRING_sk_type(sk), (n))
+#define sk_ASN1_UTF8STRING_free(sk) OPENSSL_sk_free(ossl_check_ASN1_UTF8STRING_sk_type(sk))
+#define sk_ASN1_UTF8STRING_zero(sk) OPENSSL_sk_zero(ossl_check_ASN1_UTF8STRING_sk_type(sk))
+#define sk_ASN1_UTF8STRING_delete(sk, i) ((ASN1_UTF8STRING *)OPENSSL_sk_delete(ossl_check_ASN1_UTF8STRING_sk_type(sk), (i)))
+#define sk_ASN1_UTF8STRING_delete_ptr(sk, ptr) ((ASN1_UTF8STRING *)OPENSSL_sk_delete_ptr(ossl_check_ASN1_UTF8STRING_sk_type(sk), ossl_check_ASN1_UTF8STRING_type(ptr)))
+#define sk_ASN1_UTF8STRING_push(sk, ptr) OPENSSL_sk_push(ossl_check_ASN1_UTF8STRING_sk_type(sk), ossl_check_ASN1_UTF8STRING_type(ptr))
+#define sk_ASN1_UTF8STRING_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_ASN1_UTF8STRING_sk_type(sk), ossl_check_ASN1_UTF8STRING_type(ptr))
+#define sk_ASN1_UTF8STRING_pop(sk) ((ASN1_UTF8STRING *)OPENSSL_sk_pop(ossl_check_ASN1_UTF8STRING_sk_type(sk)))
+#define sk_ASN1_UTF8STRING_shift(sk) ((ASN1_UTF8STRING *)OPENSSL_sk_shift(ossl_check_ASN1_UTF8STRING_sk_type(sk)))
+#define sk_ASN1_UTF8STRING_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ASN1_UTF8STRING_sk_type(sk),ossl_check_ASN1_UTF8STRING_freefunc_type(freefunc))
+#define sk_ASN1_UTF8STRING_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_ASN1_UTF8STRING_sk_type(sk), ossl_check_ASN1_UTF8STRING_type(ptr), (idx))
+#define sk_ASN1_UTF8STRING_set(sk, idx, ptr) ((ASN1_UTF8STRING *)OPENSSL_sk_set(ossl_check_ASN1_UTF8STRING_sk_type(sk), (idx), ossl_check_ASN1_UTF8STRING_type(ptr)))
+#define sk_ASN1_UTF8STRING_find(sk, ptr) OPENSSL_sk_find(ossl_check_ASN1_UTF8STRING_sk_type(sk), ossl_check_ASN1_UTF8STRING_type(ptr))
+#define sk_ASN1_UTF8STRING_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_ASN1_UTF8STRING_sk_type(sk), ossl_check_ASN1_UTF8STRING_type(ptr))
+#define sk_ASN1_UTF8STRING_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_ASN1_UTF8STRING_sk_type(sk), ossl_check_ASN1_UTF8STRING_type(ptr), pnum)
+#define sk_ASN1_UTF8STRING_sort(sk) OPENSSL_sk_sort(ossl_check_ASN1_UTF8STRING_sk_type(sk))
+#define sk_ASN1_UTF8STRING_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_ASN1_UTF8STRING_sk_type(sk))
+#define sk_ASN1_UTF8STRING_dup(sk) ((STACK_OF(ASN1_UTF8STRING) *)OPENSSL_sk_dup(ossl_check_const_ASN1_UTF8STRING_sk_type(sk)))
+#define sk_ASN1_UTF8STRING_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ASN1_UTF8STRING) *)OPENSSL_sk_deep_copy(ossl_check_const_ASN1_UTF8STRING_sk_type(sk), ossl_check_ASN1_UTF8STRING_copyfunc_type(copyfunc), ossl_check_ASN1_UTF8STRING_freefunc_type(freefunc)))
+#define sk_ASN1_UTF8STRING_set_cmp_func(sk, cmp) ((sk_ASN1_UTF8STRING_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_ASN1_UTF8STRING_sk_type(sk), ossl_check_ASN1_UTF8STRING_compfunc_type(cmp)))
+
+
+DECLARE_ASN1_FUNCTIONS(ASN1_VISIBLESTRING)
+DECLARE_ASN1_FUNCTIONS(ASN1_UNIVERSALSTRING)
+DECLARE_ASN1_FUNCTIONS(ASN1_UTF8STRING)
+DECLARE_ASN1_FUNCTIONS(ASN1_NULL)
+DECLARE_ASN1_FUNCTIONS(ASN1_BMPSTRING)
+
+int UTF8_getc(const unsigned char *str, int len, unsigned long *val);
+int UTF8_putc(unsigned char *str, int len, unsigned long value);
+
+SKM_DEFINE_STACK_OF_INTERNAL(ASN1_GENERALSTRING, ASN1_GENERALSTRING, ASN1_GENERALSTRING)
+#define sk_ASN1_GENERALSTRING_num(sk) OPENSSL_sk_num(ossl_check_const_ASN1_GENERALSTRING_sk_type(sk))
+#define sk_ASN1_GENERALSTRING_value(sk, idx) ((ASN1_GENERALSTRING *)OPENSSL_sk_value(ossl_check_const_ASN1_GENERALSTRING_sk_type(sk), (idx)))
+#define sk_ASN1_GENERALSTRING_new(cmp) ((STACK_OF(ASN1_GENERALSTRING) *)OPENSSL_sk_new(ossl_check_ASN1_GENERALSTRING_compfunc_type(cmp)))
+#define sk_ASN1_GENERALSTRING_new_null() ((STACK_OF(ASN1_GENERALSTRING) *)OPENSSL_sk_new_null())
+#define sk_ASN1_GENERALSTRING_new_reserve(cmp, n) ((STACK_OF(ASN1_GENERALSTRING) *)OPENSSL_sk_new_reserve(ossl_check_ASN1_GENERALSTRING_compfunc_type(cmp), (n)))
+#define sk_ASN1_GENERALSTRING_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_ASN1_GENERALSTRING_sk_type(sk), (n))
+#define sk_ASN1_GENERALSTRING_free(sk) OPENSSL_sk_free(ossl_check_ASN1_GENERALSTRING_sk_type(sk))
+#define sk_ASN1_GENERALSTRING_zero(sk) OPENSSL_sk_zero(ossl_check_ASN1_GENERALSTRING_sk_type(sk))
+#define sk_ASN1_GENERALSTRING_delete(sk, i) ((ASN1_GENERALSTRING *)OPENSSL_sk_delete(ossl_check_ASN1_GENERALSTRING_sk_type(sk), (i)))
+#define sk_ASN1_GENERALSTRING_delete_ptr(sk, ptr) ((ASN1_GENERALSTRING *)OPENSSL_sk_delete_ptr(ossl_check_ASN1_GENERALSTRING_sk_type(sk), ossl_check_ASN1_GENERALSTRING_type(ptr)))
+#define sk_ASN1_GENERALSTRING_push(sk, ptr) OPENSSL_sk_push(ossl_check_ASN1_GENERALSTRING_sk_type(sk), ossl_check_ASN1_GENERALSTRING_type(ptr))
+#define sk_ASN1_GENERALSTRING_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_ASN1_GENERALSTRING_sk_type(sk), ossl_check_ASN1_GENERALSTRING_type(ptr))
+#define sk_ASN1_GENERALSTRING_pop(sk) ((ASN1_GENERALSTRING *)OPENSSL_sk_pop(ossl_check_ASN1_GENERALSTRING_sk_type(sk)))
+#define sk_ASN1_GENERALSTRING_shift(sk) ((ASN1_GENERALSTRING *)OPENSSL_sk_shift(ossl_check_ASN1_GENERALSTRING_sk_type(sk)))
+#define sk_ASN1_GENERALSTRING_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ASN1_GENERALSTRING_sk_type(sk),ossl_check_ASN1_GENERALSTRING_freefunc_type(freefunc))
+#define sk_ASN1_GENERALSTRING_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_ASN1_GENERALSTRING_sk_type(sk), ossl_check_ASN1_GENERALSTRING_type(ptr), (idx))
+#define sk_ASN1_GENERALSTRING_set(sk, idx, ptr) ((ASN1_GENERALSTRING *)OPENSSL_sk_set(ossl_check_ASN1_GENERALSTRING_sk_type(sk), (idx), ossl_check_ASN1_GENERALSTRING_type(ptr)))
+#define sk_ASN1_GENERALSTRING_find(sk, ptr) OPENSSL_sk_find(ossl_check_ASN1_GENERALSTRING_sk_type(sk), ossl_check_ASN1_GENERALSTRING_type(ptr))
+#define sk_ASN1_GENERALSTRING_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_ASN1_GENERALSTRING_sk_type(sk), ossl_check_ASN1_GENERALSTRING_type(ptr))
+#define sk_ASN1_GENERALSTRING_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_ASN1_GENERALSTRING_sk_type(sk), ossl_check_ASN1_GENERALSTRING_type(ptr), pnum)
+#define sk_ASN1_GENERALSTRING_sort(sk) OPENSSL_sk_sort(ossl_check_ASN1_GENERALSTRING_sk_type(sk))
+#define sk_ASN1_GENERALSTRING_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_ASN1_GENERALSTRING_sk_type(sk))
+#define sk_ASN1_GENERALSTRING_dup(sk) ((STACK_OF(ASN1_GENERALSTRING) *)OPENSSL_sk_dup(ossl_check_const_ASN1_GENERALSTRING_sk_type(sk)))
+#define sk_ASN1_GENERALSTRING_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ASN1_GENERALSTRING) *)OPENSSL_sk_deep_copy(ossl_check_const_ASN1_GENERALSTRING_sk_type(sk), ossl_check_ASN1_GENERALSTRING_copyfunc_type(copyfunc), ossl_check_ASN1_GENERALSTRING_freefunc_type(freefunc)))
+#define sk_ASN1_GENERALSTRING_set_cmp_func(sk, cmp) ((sk_ASN1_GENERALSTRING_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_ASN1_GENERALSTRING_sk_type(sk), ossl_check_ASN1_GENERALSTRING_compfunc_type(cmp)))
+
+
+DECLARE_ASN1_FUNCTIONS_name(ASN1_STRING, ASN1_PRINTABLE)
+
+DECLARE_ASN1_FUNCTIONS_name(ASN1_STRING, DIRECTORYSTRING)
+DECLARE_ASN1_FUNCTIONS_name(ASN1_STRING, DISPLAYTEXT)
+DECLARE_ASN1_FUNCTIONS(ASN1_PRINTABLESTRING)
+DECLARE_ASN1_FUNCTIONS(ASN1_T61STRING)
+DECLARE_ASN1_FUNCTIONS(ASN1_IA5STRING)
+DECLARE_ASN1_FUNCTIONS(ASN1_GENERALSTRING)
+DECLARE_ASN1_FUNCTIONS(ASN1_UTCTIME)
+DECLARE_ASN1_FUNCTIONS(ASN1_GENERALIZEDTIME)
+DECLARE_ASN1_FUNCTIONS(ASN1_TIME)
+
+DECLARE_ASN1_DUP_FUNCTION(ASN1_TIME)
+DECLARE_ASN1_DUP_FUNCTION(ASN1_UTCTIME)
+DECLARE_ASN1_DUP_FUNCTION(ASN1_GENERALIZEDTIME)
+
+DECLARE_ASN1_ITEM(ASN1_OCTET_STRING_NDEF)
+
+ASN1_TIME *ASN1_TIME_set(ASN1_TIME *s, time_t t);
+ASN1_TIME *ASN1_TIME_adj(ASN1_TIME *s, time_t t,
+                         int offset_day, long offset_sec);
+int ASN1_TIME_check(const ASN1_TIME *t);
+ASN1_GENERALIZEDTIME *ASN1_TIME_to_generalizedtime(const ASN1_TIME *t,
+                                                   ASN1_GENERALIZEDTIME **out);
+int ASN1_TIME_set_string(ASN1_TIME *s, const char *str);
+int ASN1_TIME_set_string_X509(ASN1_TIME *s, const char *str);
+int ASN1_TIME_to_tm(const ASN1_TIME *s, struct tm *tm);
+int ASN1_TIME_normalize(ASN1_TIME *s);
+int ASN1_TIME_cmp_time_t(const ASN1_TIME *s, time_t t);
+int ASN1_TIME_compare(const ASN1_TIME *a, const ASN1_TIME *b);
+
+int i2a_ASN1_INTEGER(BIO *bp, const ASN1_INTEGER *a);
+int a2i_ASN1_INTEGER(BIO *bp, ASN1_INTEGER *bs, char *buf, int size);
+int i2a_ASN1_ENUMERATED(BIO *bp, const ASN1_ENUMERATED *a);
+int a2i_ASN1_ENUMERATED(BIO *bp, ASN1_ENUMERATED *bs, char *buf, int size);
+int i2a_ASN1_OBJECT(BIO *bp, const ASN1_OBJECT *a);
+int a2i_ASN1_STRING(BIO *bp, ASN1_STRING *bs, char *buf, int size);
+int i2a_ASN1_STRING(BIO *bp, const ASN1_STRING *a, int type);
+int i2t_ASN1_OBJECT(char *buf, int buf_len, const ASN1_OBJECT *a);
+
+int a2d_ASN1_OBJECT(unsigned char *out, int olen, const char *buf, int num);
+ASN1_OBJECT *ASN1_OBJECT_create(int nid, unsigned char *data, int len,
+                                const char *sn, const char *ln);
+
+int ASN1_INTEGER_get_int64(int64_t *pr, const ASN1_INTEGER *a);
+int ASN1_INTEGER_set_int64(ASN1_INTEGER *a, int64_t r);
+int ASN1_INTEGER_get_uint64(uint64_t *pr, const ASN1_INTEGER *a);
+int ASN1_INTEGER_set_uint64(ASN1_INTEGER *a, uint64_t r);
+
+int ASN1_INTEGER_set(ASN1_INTEGER *a, long v);
+long ASN1_INTEGER_get(const ASN1_INTEGER *a);
+ASN1_INTEGER *BN_to_ASN1_INTEGER(const BIGNUM *bn, ASN1_INTEGER *ai);
+BIGNUM *ASN1_INTEGER_to_BN(const ASN1_INTEGER *ai, BIGNUM *bn);
+
+int ASN1_ENUMERATED_get_int64(int64_t *pr, const ASN1_ENUMERATED *a);
+int ASN1_ENUMERATED_set_int64(ASN1_ENUMERATED *a, int64_t r);
+
+
+int ASN1_ENUMERATED_set(ASN1_ENUMERATED *a, long v);
+long ASN1_ENUMERATED_get(const ASN1_ENUMERATED *a);
+ASN1_ENUMERATED *BN_to_ASN1_ENUMERATED(const BIGNUM *bn, ASN1_ENUMERATED *ai);
+BIGNUM *ASN1_ENUMERATED_to_BN(const ASN1_ENUMERATED *ai, BIGNUM *bn);
+
+/* General */
+/* given a string, return the correct type, max is the maximum length */
+int ASN1_PRINTABLE_type(const unsigned char *s, int max);
+
+unsigned long ASN1_tag2bit(int tag);
+
+/* SPECIALS */
+int ASN1_get_object(const unsigned char **pp, long *plength, int *ptag,
+                    int *pclass, long omax);
+int ASN1_check_infinite_end(unsigned char **p, long len);
+int ASN1_const_check_infinite_end(const unsigned char **p, long len);
+void ASN1_put_object(unsigned char **pp, int constructed, int length,
+                     int tag, int xclass);
+int ASN1_put_eoc(unsigned char **pp);
+int ASN1_object_size(int constructed, int length, int tag);
+
+/* Used to implement other functions */
+void *ASN1_dup(i2d_of_void *i2d, d2i_of_void *d2i, const void *x);
+
+# define ASN1_dup_of(type,i2d,d2i,x) \
+    ((type*)ASN1_dup(CHECKED_I2D_OF(type, i2d), \
+                     CHECKED_D2I_OF(type, d2i), \
+                     CHECKED_PTR_OF(const type, x)))
+
+void *ASN1_item_dup(const ASN1_ITEM *it, const void *x);
+int ASN1_item_sign_ex(const ASN1_ITEM *it, X509_ALGOR *algor1,
+                      X509_ALGOR *algor2, ASN1_BIT_STRING *signature,
+                      const void *data, const ASN1_OCTET_STRING *id,
+                      EVP_PKEY *pkey, const EVP_MD *md, OSSL_LIB_CTX *libctx,
+                      const char *propq);
+int ASN1_item_verify_ex(const ASN1_ITEM *it, const X509_ALGOR *alg,
+                        const ASN1_BIT_STRING *signature, const void *data,
+                        const ASN1_OCTET_STRING *id, EVP_PKEY *pkey,
+                        OSSL_LIB_CTX *libctx, const char *propq);
+
+/* ASN1 alloc/free macros for when a type is only used internally */
+
+# define M_ASN1_new_of(type) (type *)ASN1_item_new(ASN1_ITEM_rptr(type))
+# define M_ASN1_free_of(x, type) \
+                ASN1_item_free(CHECKED_PTR_OF(type, x), ASN1_ITEM_rptr(type))
+
+# ifndef OPENSSL_NO_STDIO
+void *ASN1_d2i_fp(void *(*xnew) (void), d2i_of_void *d2i, FILE *in, void **x);
+
+#  define ASN1_d2i_fp_of(type,xnew,d2i,in,x) \
+    ((type*)ASN1_d2i_fp(CHECKED_NEW_OF(type, xnew), \
+                        CHECKED_D2I_OF(type, d2i), \
+                        in, \
+                        CHECKED_PPTR_OF(type, x)))
+
+void *ASN1_item_d2i_fp_ex(const ASN1_ITEM *it, FILE *in, void *x,
+                          OSSL_LIB_CTX *libctx, const char *propq);
+void *ASN1_item_d2i_fp(const ASN1_ITEM *it, FILE *in, void *x);
+int ASN1_i2d_fp(i2d_of_void *i2d, FILE *out, const void *x);
+
+#  define ASN1_i2d_fp_of(type,i2d,out,x) \
+    (ASN1_i2d_fp(CHECKED_I2D_OF(type, i2d), \
+                 out, \
+                 CHECKED_PTR_OF(const type, x)))
+
+int ASN1_item_i2d_fp(const ASN1_ITEM *it, FILE *out, const void *x);
+int ASN1_STRING_print_ex_fp(FILE *fp, const ASN1_STRING *str, unsigned long flags);
+# endif
+
+int ASN1_STRING_to_UTF8(unsigned char **out, const ASN1_STRING *in);
+
+void *ASN1_d2i_bio(void *(*xnew) (void), d2i_of_void *d2i, BIO *in, void **x);
+
+#  define ASN1_d2i_bio_of(type,xnew,d2i,in,x) \
+    ((type*)ASN1_d2i_bio( CHECKED_NEW_OF(type, xnew), \
+                          CHECKED_D2I_OF(type, d2i), \
+                          in, \
+                          CHECKED_PPTR_OF(type, x)))
+
+void *ASN1_item_d2i_bio_ex(const ASN1_ITEM *it, BIO *in, void *pval,
+                           OSSL_LIB_CTX *libctx, const char *propq);
+void *ASN1_item_d2i_bio(const ASN1_ITEM *it, BIO *in, void *pval);
+int ASN1_i2d_bio(i2d_of_void *i2d, BIO *out, const void *x);
+
+#  define ASN1_i2d_bio_of(type,i2d,out,x) \
+    (ASN1_i2d_bio(CHECKED_I2D_OF(type, i2d), \
+                  out, \
+                  CHECKED_PTR_OF(const type, x)))
+
+int ASN1_item_i2d_bio(const ASN1_ITEM *it, BIO *out, const void *x);
+BIO *ASN1_item_i2d_mem_bio(const ASN1_ITEM *it, const ASN1_VALUE *val);
+int ASN1_UTCTIME_print(BIO *fp, const ASN1_UTCTIME *a);
+int ASN1_GENERALIZEDTIME_print(BIO *fp, const ASN1_GENERALIZEDTIME *a);
+int ASN1_TIME_print(BIO *bp, const ASN1_TIME *tm);
+int ASN1_TIME_print_ex(BIO *bp, const ASN1_TIME *tm, unsigned long flags);
+int ASN1_STRING_print(BIO *bp, const ASN1_STRING *v);
+int ASN1_STRING_print_ex(BIO *out, const ASN1_STRING *str, unsigned long flags);
+int ASN1_buf_print(BIO *bp, const unsigned char *buf, size_t buflen, int off);
+int ASN1_bn_print(BIO *bp, const char *number, const BIGNUM *num,
+                  unsigned char *buf, int off);
+int ASN1_parse(BIO *bp, const unsigned char *pp, long len, int indent);
+int ASN1_parse_dump(BIO *bp, const unsigned char *pp, long len, int indent,
+                    int dump);
+const char *ASN1_tag2str(int tag);
+
+/* Used to load and write Netscape format cert */
+
+int ASN1_UNIVERSALSTRING_to_string(ASN1_UNIVERSALSTRING *s);
+
+int ASN1_TYPE_set_octetstring(ASN1_TYPE *a, unsigned char *data, int len);
+int ASN1_TYPE_get_octetstring(const ASN1_TYPE *a, unsigned char *data, int max_len);
+int ASN1_TYPE_set_int_octetstring(ASN1_TYPE *a, long num,
+                                  unsigned char *data, int len);
+int ASN1_TYPE_get_int_octetstring(const ASN1_TYPE *a, long *num,
+                                  unsigned char *data, int max_len);
+
+void *ASN1_item_unpack(const ASN1_STRING *oct, const ASN1_ITEM *it);
+void *ASN1_item_unpack_ex(const ASN1_STRING *oct, const ASN1_ITEM *it,
+                          OSSL_LIB_CTX *libctx, const char *propq);
+
+ASN1_STRING *ASN1_item_pack(void *obj, const ASN1_ITEM *it,
+                            ASN1_OCTET_STRING **oct);
+
+void ASN1_STRING_set_default_mask(unsigned long mask);
+int ASN1_STRING_set_default_mask_asc(const char *p);
+unsigned long ASN1_STRING_get_default_mask(void);
+int ASN1_mbstring_copy(ASN1_STRING **out, const unsigned char *in, int len,
+                       int inform, unsigned long mask);
+int ASN1_mbstring_ncopy(ASN1_STRING **out, const unsigned char *in, int len,
+                        int inform, unsigned long mask,
+                        long minsize, long maxsize);
+
+ASN1_STRING *ASN1_STRING_set_by_NID(ASN1_STRING **out,
+                                    const unsigned char *in, int inlen,
+                                    int inform, int nid);
+ASN1_STRING_TABLE *ASN1_STRING_TABLE_get(int nid);
+int ASN1_STRING_TABLE_add(int, long, long, unsigned long, unsigned long);
+void ASN1_STRING_TABLE_cleanup(void);
+
+/* ASN1 template functions */
+
+/* Old API compatible functions */
+ASN1_VALUE *ASN1_item_new(const ASN1_ITEM *it);
+ASN1_VALUE *ASN1_item_new_ex(const ASN1_ITEM *it, OSSL_LIB_CTX *libctx,
+                             const char *propq);
+void ASN1_item_free(ASN1_VALUE *val, const ASN1_ITEM *it);
+ASN1_VALUE *ASN1_item_d2i_ex(ASN1_VALUE **val, const unsigned char **in,
+                             long len, const ASN1_ITEM *it,
+                             OSSL_LIB_CTX *libctx, const char *propq);
+ASN1_VALUE *ASN1_item_d2i(ASN1_VALUE **val, const unsigned char **in,
+                          long len, const ASN1_ITEM *it);
+int ASN1_item_i2d(const ASN1_VALUE *val, unsigned char **out, const ASN1_ITEM *it);
+int ASN1_item_ndef_i2d(const ASN1_VALUE *val, unsigned char **out,
+                       const ASN1_ITEM *it);
+
+void ASN1_add_oid_module(void);
+void ASN1_add_stable_module(void);
+
+ASN1_TYPE *ASN1_generate_nconf(const char *str, CONF *nconf);
+ASN1_TYPE *ASN1_generate_v3(const char *str, X509V3_CTX *cnf);
+int ASN1_str2mask(const char *str, unsigned long *pmask);
+
+/* ASN1 Print flags */
+
+/* Indicate missing OPTIONAL fields */
+# define ASN1_PCTX_FLAGS_SHOW_ABSENT             0x001
+/* Mark start and end of SEQUENCE */
+# define ASN1_PCTX_FLAGS_SHOW_SEQUENCE           0x002
+/* Mark start and end of SEQUENCE/SET OF */
+# define ASN1_PCTX_FLAGS_SHOW_SSOF               0x004
+/* Show the ASN1 type of primitives */
+# define ASN1_PCTX_FLAGS_SHOW_TYPE               0x008
+/* Don't show ASN1 type of ANY */
+# define ASN1_PCTX_FLAGS_NO_ANY_TYPE             0x010
+/* Don't show ASN1 type of MSTRINGs */
+# define ASN1_PCTX_FLAGS_NO_MSTRING_TYPE         0x020
+/* Don't show field names in SEQUENCE */
+# define ASN1_PCTX_FLAGS_NO_FIELD_NAME           0x040
+/* Show structure names of each SEQUENCE field */
+# define ASN1_PCTX_FLAGS_SHOW_FIELD_STRUCT_NAME  0x080
+/* Don't show structure name even at top level */
+# define ASN1_PCTX_FLAGS_NO_STRUCT_NAME          0x100
+
+int ASN1_item_print(BIO *out, const ASN1_VALUE *ifld, int indent,
+                    const ASN1_ITEM *it, const ASN1_PCTX *pctx);
+ASN1_PCTX *ASN1_PCTX_new(void);
+void ASN1_PCTX_free(ASN1_PCTX *p);
+unsigned long ASN1_PCTX_get_flags(const ASN1_PCTX *p);
+void ASN1_PCTX_set_flags(ASN1_PCTX *p, unsigned long flags);
+unsigned long ASN1_PCTX_get_nm_flags(const ASN1_PCTX *p);
+void ASN1_PCTX_set_nm_flags(ASN1_PCTX *p, unsigned long flags);
+unsigned long ASN1_PCTX_get_cert_flags(const ASN1_PCTX *p);
+void ASN1_PCTX_set_cert_flags(ASN1_PCTX *p, unsigned long flags);
+unsigned long ASN1_PCTX_get_oid_flags(const ASN1_PCTX *p);
+void ASN1_PCTX_set_oid_flags(ASN1_PCTX *p, unsigned long flags);
+unsigned long ASN1_PCTX_get_str_flags(const ASN1_PCTX *p);
+void ASN1_PCTX_set_str_flags(ASN1_PCTX *p, unsigned long flags);
+
+ASN1_SCTX *ASN1_SCTX_new(int (*scan_cb) (ASN1_SCTX *ctx));
+void ASN1_SCTX_free(ASN1_SCTX *p);
+const ASN1_ITEM *ASN1_SCTX_get_item(ASN1_SCTX *p);
+const ASN1_TEMPLATE *ASN1_SCTX_get_template(ASN1_SCTX *p);
+unsigned long ASN1_SCTX_get_flags(ASN1_SCTX *p);
+void ASN1_SCTX_set_app_data(ASN1_SCTX *p, void *data);
+void *ASN1_SCTX_get_app_data(ASN1_SCTX *p);
+
+const BIO_METHOD *BIO_f_asn1(void);
+
+/* cannot constify val because of CMS_stream() */
+BIO *BIO_new_NDEF(BIO *out, ASN1_VALUE *val, const ASN1_ITEM *it);
+
+int i2d_ASN1_bio_stream(BIO *out, ASN1_VALUE *val, BIO *in, int flags,
+                        const ASN1_ITEM *it);
+int PEM_write_bio_ASN1_stream(BIO *out, ASN1_VALUE *val, BIO *in, int flags,
+                              const char *hdr, const ASN1_ITEM *it);
+/* cannot constify val because of CMS_dataFinal() */
+int SMIME_write_ASN1(BIO *bio, ASN1_VALUE *val, BIO *data, int flags,
+                     int ctype_nid, int econt_nid,
+                     STACK_OF(X509_ALGOR) *mdalgs, const ASN1_ITEM *it);
+int SMIME_write_ASN1_ex(BIO *bio, ASN1_VALUE *val, BIO *data, int flags,
+                        int ctype_nid, int econt_nid,
+                        STACK_OF(X509_ALGOR) *mdalgs, const ASN1_ITEM *it,
+                        OSSL_LIB_CTX *libctx, const char *propq);
+ASN1_VALUE *SMIME_read_ASN1(BIO *bio, BIO **bcont, const ASN1_ITEM *it);
+ASN1_VALUE *SMIME_read_ASN1_ex(BIO *bio, int flags, BIO **bcont,
+                               const ASN1_ITEM *it, ASN1_VALUE **x,
+                               OSSL_LIB_CTX *libctx, const char *propq);
+int SMIME_crlf_copy(BIO *in, BIO *out, int flags);
+int SMIME_text(BIO *in, BIO *out);
+
+const ASN1_ITEM *ASN1_ITEM_lookup(const char *name);
+const ASN1_ITEM *ASN1_ITEM_get(size_t i);
+
+/* Legacy compatibility */
+# define DECLARE_ASN1_FUNCTIONS_fname(type, itname, name) \
+         DECLARE_ASN1_ALLOC_FUNCTIONS_name(type, name) \
+         DECLARE_ASN1_ENCODE_FUNCTIONS(type, itname, name)
+# define DECLARE_ASN1_FUNCTIONS_const(type) DECLARE_ASN1_FUNCTIONS(type)
+# define DECLARE_ASN1_ENCODE_FUNCTIONS_const(type, name) \
+         DECLARE_ASN1_ENCODE_FUNCTIONS(type, name)
+# define I2D_OF_const(type) I2D_OF(type)
+# define ASN1_dup_of_const(type,i2d,d2i,x) ASN1_dup_of(type,i2d,d2i,x)
+# define ASN1_i2d_fp_of_const(type,i2d,out,x) ASN1_i2d_fp_of(type,i2d,out,x)
+# define ASN1_i2d_bio_of_const(type,i2d,out,x) ASN1_i2d_bio_of(type,i2d,out,x)
+
+# ifdef  __cplusplus
+}
+# endif
+#endif
diff --git a/src/include/openssl/asn1_mac.h b/src/include/openssl/asn1_mac.h
new file mode 100644
index 0000000..fdcb983
--- /dev/null
+++ b/src/include/openssl/asn1_mac.h
@@ -0,0 +1,10 @@
+/*
+ * Copyright 2015-2016 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#error "This file is obsolete; please update your software."
diff --git a/src/include/openssl/asn1err.h b/src/include/openssl/asn1err.h
new file mode 100644
index 0000000..8fd85ed
--- /dev/null
+++ b/src/include/openssl/asn1err.h
@@ -0,0 +1,142 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2024 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_ASN1ERR_H
+# define OPENSSL_ASN1ERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+
+/*
+ * ASN1 reason codes.
+ */
+# define ASN1_R_ADDING_OBJECT                             171
+# define ASN1_R_ASN1_PARSE_ERROR                          203
+# define ASN1_R_ASN1_SIG_PARSE_ERROR                      204
+# define ASN1_R_AUX_ERROR                                 100
+# define ASN1_R_BAD_OBJECT_HEADER                         102
+# define ASN1_R_BAD_TEMPLATE                              230
+# define ASN1_R_BMPSTRING_IS_WRONG_LENGTH                 214
+# define ASN1_R_BN_LIB                                    105
+# define ASN1_R_BOOLEAN_IS_WRONG_LENGTH                   106
+# define ASN1_R_BUFFER_TOO_SMALL                          107
+# define ASN1_R_CIPHER_HAS_NO_OBJECT_IDENTIFIER           108
+# define ASN1_R_CONTEXT_NOT_INITIALISED                   217
+# define ASN1_R_DATA_IS_WRONG                             109
+# define ASN1_R_DECODE_ERROR                              110
+# define ASN1_R_DEPTH_EXCEEDED                            174
+# define ASN1_R_DIGEST_AND_KEY_TYPE_NOT_SUPPORTED         198
+# define ASN1_R_ENCODE_ERROR                              112
+# define ASN1_R_ERROR_GETTING_TIME                        173
+# define ASN1_R_ERROR_LOADING_SECTION                     172
+# define ASN1_R_ERROR_SETTING_CIPHER_PARAMS               114
+# define ASN1_R_EXPECTING_AN_INTEGER                      115
+# define ASN1_R_EXPECTING_AN_OBJECT                       116
+# define ASN1_R_EXPLICIT_LENGTH_MISMATCH                  119
+# define ASN1_R_EXPLICIT_TAG_NOT_CONSTRUCTED              120
+# define ASN1_R_FIELD_MISSING                             121
+# define ASN1_R_FIRST_NUM_TOO_LARGE                       122
+# define ASN1_R_GENERALIZEDTIME_IS_TOO_SHORT              232
+# define ASN1_R_HEADER_TOO_LONG                           123
+# define ASN1_R_ILLEGAL_BITSTRING_FORMAT                  175
+# define ASN1_R_ILLEGAL_BOOLEAN                           176
+# define ASN1_R_ILLEGAL_CHARACTERS                        124
+# define ASN1_R_ILLEGAL_FORMAT                            177
+# define ASN1_R_ILLEGAL_HEX                               178
+# define ASN1_R_ILLEGAL_IMPLICIT_TAG                      179
+# define ASN1_R_ILLEGAL_INTEGER                           180
+# define ASN1_R_ILLEGAL_NEGATIVE_VALUE                    226
+# define ASN1_R_ILLEGAL_NESTED_TAGGING                    181
+# define ASN1_R_ILLEGAL_NULL                              125
+# define ASN1_R_ILLEGAL_NULL_VALUE                        182
+# define ASN1_R_ILLEGAL_OBJECT                            183
+# define ASN1_R_ILLEGAL_OPTIONAL_ANY                      126
+# define ASN1_R_ILLEGAL_OPTIONS_ON_ITEM_TEMPLATE          170
+# define ASN1_R_ILLEGAL_PADDING                           221
+# define ASN1_R_ILLEGAL_TAGGED_ANY                        127
+# define ASN1_R_ILLEGAL_TIME_VALUE                        184
+# define ASN1_R_ILLEGAL_ZERO_CONTENT                      222
+# define ASN1_R_INTEGER_NOT_ASCII_FORMAT                  185
+# define ASN1_R_INTEGER_TOO_LARGE_FOR_LONG                128
+# define ASN1_R_INVALID_BIT_STRING_BITS_LEFT              220
+# define ASN1_R_INVALID_BMPSTRING_LENGTH                  129
+# define ASN1_R_INVALID_DIGIT                             130
+# define ASN1_R_INVALID_MIME_TYPE                         205
+# define ASN1_R_INVALID_MODIFIER                          186
+# define ASN1_R_INVALID_NUMBER                            187
+# define ASN1_R_INVALID_OBJECT_ENCODING                   216
+# define ASN1_R_INVALID_SCRYPT_PARAMETERS                 227
+# define ASN1_R_INVALID_SEPARATOR                         131
+# define ASN1_R_INVALID_STRING_TABLE_VALUE                218
+# define ASN1_R_INVALID_UNIVERSALSTRING_LENGTH            133
+# define ASN1_R_INVALID_UTF8STRING                        134
+# define ASN1_R_INVALID_VALUE                             219
+# define ASN1_R_LENGTH_TOO_LONG                           231
+# define ASN1_R_LIST_ERROR                                188
+# define ASN1_R_MIME_NO_CONTENT_TYPE                      206
+# define ASN1_R_MIME_PARSE_ERROR                          207
+# define ASN1_R_MIME_SIG_PARSE_ERROR                      208
+# define ASN1_R_MISSING_EOC                               137
+# define ASN1_R_MISSING_SECOND_NUMBER                     138
+# define ASN1_R_MISSING_VALUE                             189
+# define ASN1_R_MSTRING_NOT_UNIVERSAL                     139
+# define ASN1_R_MSTRING_WRONG_TAG                         140
+# define ASN1_R_NESTED_ASN1_STRING                        197
+# define ASN1_R_NESTED_TOO_DEEP                           201
+# define ASN1_R_NON_HEX_CHARACTERS                        141
+# define ASN1_R_NOT_ASCII_FORMAT                          190
+# define ASN1_R_NOT_ENOUGH_DATA                           142
+# define ASN1_R_NO_CONTENT_TYPE                           209
+# define ASN1_R_NO_MATCHING_CHOICE_TYPE                   143
+# define ASN1_R_NO_MULTIPART_BODY_FAILURE                 210
+# define ASN1_R_NO_MULTIPART_BOUNDARY                     211
+# define ASN1_R_NO_SIG_CONTENT_TYPE                       212
+# define ASN1_R_NULL_IS_WRONG_LENGTH                      144
+# define ASN1_R_OBJECT_NOT_ASCII_FORMAT                   191
+# define ASN1_R_ODD_NUMBER_OF_CHARS                       145
+# define ASN1_R_SECOND_NUMBER_TOO_LARGE                   147
+# define ASN1_R_SEQUENCE_LENGTH_MISMATCH                  148
+# define ASN1_R_SEQUENCE_NOT_CONSTRUCTED                  149
+# define ASN1_R_SEQUENCE_OR_SET_NEEDS_CONFIG              192
+# define ASN1_R_SHORT_LINE                                150
+# define ASN1_R_SIG_INVALID_MIME_TYPE                     213
+# define ASN1_R_STREAMING_NOT_SUPPORTED                   202
+# define ASN1_R_STRING_TOO_LONG                           151
+# define ASN1_R_STRING_TOO_SHORT                          152
+# define ASN1_R_THE_ASN1_OBJECT_IDENTIFIER_IS_NOT_KNOWN_FOR_THIS_MD 154
+# define ASN1_R_TIME_NOT_ASCII_FORMAT                     193
+# define ASN1_R_TOO_LARGE                                 223
+# define ASN1_R_TOO_LONG                                  155
+# define ASN1_R_TOO_SMALL                                 224
+# define ASN1_R_TYPE_NOT_CONSTRUCTED                      156
+# define ASN1_R_TYPE_NOT_PRIMITIVE                        195
+# define ASN1_R_UNEXPECTED_EOC                            159
+# define ASN1_R_UNIVERSALSTRING_IS_WRONG_LENGTH           215
+# define ASN1_R_UNKNOWN_DIGEST                            229
+# define ASN1_R_UNKNOWN_FORMAT                            160
+# define ASN1_R_UNKNOWN_MESSAGE_DIGEST_ALGORITHM          161
+# define ASN1_R_UNKNOWN_OBJECT_TYPE                       162
+# define ASN1_R_UNKNOWN_PUBLIC_KEY_TYPE                   163
+# define ASN1_R_UNKNOWN_SIGNATURE_ALGORITHM               199
+# define ASN1_R_UNKNOWN_TAG                               194
+# define ASN1_R_UNSUPPORTED_ANY_DEFINED_BY_TYPE           164
+# define ASN1_R_UNSUPPORTED_CIPHER                        228
+# define ASN1_R_UNSUPPORTED_PUBLIC_KEY_TYPE               167
+# define ASN1_R_UNSUPPORTED_TYPE                          196
+# define ASN1_R_UTCTIME_IS_TOO_SHORT                      233
+# define ASN1_R_WRONG_INTEGER_TYPE                        225
+# define ASN1_R_WRONG_PUBLIC_KEY_TYPE                     200
+# define ASN1_R_WRONG_TAG                                 168
+
+#endif
diff --git a/src/include/openssl/asn1t.h b/src/include/openssl/asn1t.h
new file mode 100644
index 0000000..a725c53
--- /dev/null
+++ b/src/include/openssl/asn1t.h
@@ -0,0 +1,946 @@
+/*
+ * WARNING: do not edit!
+ * Generated by makefile from include\openssl\asn1t.h.in
+ *
+ * Copyright 2000-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+
+
+#ifndef OPENSSL_ASN1T_H
+# define OPENSSL_ASN1T_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_ASN1T_H
+# endif
+
+# include <stddef.h>
+# include <openssl/e_os2.h>
+# include <openssl/asn1.h>
+
+# ifdef OPENSSL_BUILD_SHLIBCRYPTO
+#  undef OPENSSL_EXTERN
+#  define OPENSSL_EXTERN OPENSSL_EXPORT
+# endif
+
+/* ASN1 template defines, structures and functions */
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+/*-
+ * These are the possible values for the itype field of the
+ * ASN1_ITEM structure and determine how it is interpreted.
+ *
+ * For PRIMITIVE types the underlying type
+ * determines the behaviour if items is NULL.
+ *
+ * Otherwise templates must contain a single
+ * template and the type is treated in the
+ * same way as the type specified in the template.
+ *
+ * For SEQUENCE types the templates field points
+ * to the members, the size field is the
+ * structure size.
+ *
+ * For CHOICE types the templates field points
+ * to each possible member (typically a union)
+ * and the 'size' field is the offset of the
+ * selector.
+ *
+ * The 'funcs' field is used for application-specific
+ * data and functions.
+ *
+ * The EXTERN type uses a new style d2i/i2d.
+ * The new style should be used where possible
+ * because it avoids things like the d2i IMPLICIT
+ * hack.
+ *
+ * MSTRING is a multiple string type, it is used
+ * for a CHOICE of character strings where the
+ * actual strings all occupy an ASN1_STRING
+ * structure. In this case the 'utype' field
+ * has a special meaning, it is used as a mask
+ * of acceptable types using the B_ASN1 constants.
+ *
+ * NDEF_SEQUENCE is the same as SEQUENCE except
+ * that it will use indefinite length constructed
+ * encoding if requested.
+ *
+ */
+
+# define ASN1_ITYPE_PRIMITIVE            0x0
+# define ASN1_ITYPE_SEQUENCE             0x1
+# define ASN1_ITYPE_CHOICE               0x2
+/* unused value                          0x3 */
+# define ASN1_ITYPE_EXTERN               0x4
+# define ASN1_ITYPE_MSTRING              0x5
+# define ASN1_ITYPE_NDEF_SEQUENCE        0x6
+
+/* Macro to obtain ASN1_ADB pointer from a type (only used internally) */
+# define ASN1_ADB_ptr(iptr) ((const ASN1_ADB *)((iptr)()))
+
+/* Macros for start and end of ASN1_ITEM definition */
+
+# define ASN1_ITEM_start(itname) \
+        const ASN1_ITEM * itname##_it(void) \
+        { \
+                static const ASN1_ITEM local_it = {
+
+# define static_ASN1_ITEM_start(itname) \
+        static ASN1_ITEM_start(itname)
+
+# define ASN1_ITEM_end(itname) \
+                }; \
+        return &local_it; \
+        }
+
+/* Macros to aid ASN1 template writing */
+
+# define ASN1_ITEM_TEMPLATE(tname) \
+        static const ASN1_TEMPLATE tname##_item_tt
+
+# define ASN1_ITEM_TEMPLATE_END(tname) \
+        ;\
+        ASN1_ITEM_start(tname) \
+                ASN1_ITYPE_PRIMITIVE,\
+                -1,\
+                &tname##_item_tt,\
+                0,\
+                NULL,\
+                0,\
+                #tname \
+        ASN1_ITEM_end(tname)
+# define static_ASN1_ITEM_TEMPLATE_END(tname) \
+        ;\
+        static_ASN1_ITEM_start(tname) \
+                ASN1_ITYPE_PRIMITIVE,\
+                -1,\
+                &tname##_item_tt,\
+                0,\
+                NULL,\
+                0,\
+                #tname \
+        ASN1_ITEM_end(tname)
+
+/* This is a ASN1 type which just embeds a template */
+
+/*-
+ * This pair helps declare a SEQUENCE. We can do:
+ *
+ *      ASN1_SEQUENCE(stname) = {
+ *              ... SEQUENCE components ...
+ *      } ASN1_SEQUENCE_END(stname)
+ *
+ *      This will produce an ASN1_ITEM called stname_it
+ *      for a structure called stname.
+ *
+ *      If you want the same structure but a different
+ *      name then use:
+ *
+ *      ASN1_SEQUENCE(itname) = {
+ *              ... SEQUENCE components ...
+ *      } ASN1_SEQUENCE_END_name(stname, itname)
+ *
+ *      This will create an item called itname_it using
+ *      a structure called stname.
+ */
+
+# define ASN1_SEQUENCE(tname) \
+        static const ASN1_TEMPLATE tname##_seq_tt[]
+
+# define ASN1_SEQUENCE_END(stname) ASN1_SEQUENCE_END_name(stname, stname)
+
+# define static_ASN1_SEQUENCE_END(stname) static_ASN1_SEQUENCE_END_name(stname, stname)
+
+# define ASN1_SEQUENCE_END_name(stname, tname) \
+        ;\
+        ASN1_ITEM_start(tname) \
+                ASN1_ITYPE_SEQUENCE,\
+                V_ASN1_SEQUENCE,\
+                tname##_seq_tt,\
+                sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\
+                NULL,\
+                sizeof(stname),\
+                #tname \
+        ASN1_ITEM_end(tname)
+
+# define static_ASN1_SEQUENCE_END_name(stname, tname) \
+        ;\
+        static_ASN1_ITEM_start(tname) \
+                ASN1_ITYPE_SEQUENCE,\
+                V_ASN1_SEQUENCE,\
+                tname##_seq_tt,\
+                sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\
+                NULL,\
+                sizeof(stname),\
+                #stname \
+        ASN1_ITEM_end(tname)
+
+# define ASN1_NDEF_SEQUENCE(tname) \
+        ASN1_SEQUENCE(tname)
+
+# define ASN1_NDEF_SEQUENCE_cb(tname, cb) \
+        ASN1_SEQUENCE_cb(tname, cb)
+
+# define ASN1_SEQUENCE_cb(tname, cb) \
+        static const ASN1_AUX tname##_aux = {NULL, 0, 0, 0, cb, 0, NULL}; \
+        ASN1_SEQUENCE(tname)
+
+# define ASN1_SEQUENCE_const_cb(tname, const_cb) \
+        static const ASN1_AUX tname##_aux = \
+            {NULL, ASN1_AFLG_CONST_CB, 0, 0, NULL, 0, const_cb}; \
+        ASN1_SEQUENCE(tname)
+
+# define ASN1_SEQUENCE_cb_const_cb(tname, cb, const_cb) \
+        static const ASN1_AUX tname##_aux = \
+            {NULL, ASN1_AFLG_CONST_CB, 0, 0, cb, 0, const_cb}; \
+        ASN1_SEQUENCE(tname)
+
+# define ASN1_SEQUENCE_ref(tname, cb) \
+        static const ASN1_AUX tname##_aux = {NULL, ASN1_AFLG_REFCOUNT, offsetof(tname, references), offsetof(tname, lock), cb, 0, NULL}; \
+        ASN1_SEQUENCE(tname)
+
+# define ASN1_SEQUENCE_enc(tname, enc, cb) \
+        static const ASN1_AUX tname##_aux = {NULL, ASN1_AFLG_ENCODING, 0, 0, cb, offsetof(tname, enc), NULL}; \
+        ASN1_SEQUENCE(tname)
+
+# define ASN1_NDEF_SEQUENCE_END(tname) \
+        ;\
+        ASN1_ITEM_start(tname) \
+                ASN1_ITYPE_NDEF_SEQUENCE,\
+                V_ASN1_SEQUENCE,\
+                tname##_seq_tt,\
+                sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\
+                NULL,\
+                sizeof(tname),\
+                #tname \
+        ASN1_ITEM_end(tname)
+# define static_ASN1_NDEF_SEQUENCE_END(tname) \
+        ;\
+        static_ASN1_ITEM_start(tname) \
+                ASN1_ITYPE_NDEF_SEQUENCE,\
+                V_ASN1_SEQUENCE,\
+                tname##_seq_tt,\
+                sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\
+                NULL,\
+                sizeof(tname),\
+                #tname \
+        ASN1_ITEM_end(tname)
+
+
+# define ASN1_SEQUENCE_END_enc(stname, tname) ASN1_SEQUENCE_END_ref(stname, tname)
+
+# define ASN1_SEQUENCE_END_cb(stname, tname) ASN1_SEQUENCE_END_ref(stname, tname)
+# define static_ASN1_SEQUENCE_END_cb(stname, tname) static_ASN1_SEQUENCE_END_ref(stname, tname)
+
+# define ASN1_SEQUENCE_END_ref(stname, tname) \
+        ;\
+        ASN1_ITEM_start(tname) \
+                ASN1_ITYPE_SEQUENCE,\
+                V_ASN1_SEQUENCE,\
+                tname##_seq_tt,\
+                sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\
+                &tname##_aux,\
+                sizeof(stname),\
+                #tname \
+        ASN1_ITEM_end(tname)
+# define static_ASN1_SEQUENCE_END_ref(stname, tname) \
+        ;\
+        static_ASN1_ITEM_start(tname) \
+                ASN1_ITYPE_SEQUENCE,\
+                V_ASN1_SEQUENCE,\
+                tname##_seq_tt,\
+                sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\
+                &tname##_aux,\
+                sizeof(stname),\
+                #stname \
+        ASN1_ITEM_end(tname)
+
+# define ASN1_NDEF_SEQUENCE_END_cb(stname, tname) \
+        ;\
+        ASN1_ITEM_start(tname) \
+                ASN1_ITYPE_NDEF_SEQUENCE,\
+                V_ASN1_SEQUENCE,\
+                tname##_seq_tt,\
+                sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\
+                &tname##_aux,\
+                sizeof(stname),\
+                #stname \
+        ASN1_ITEM_end(tname)
+
+/*-
+ * This pair helps declare a CHOICE type. We can do:
+ *
+ *      ASN1_CHOICE(chname) = {
+ *              ... CHOICE options ...
+ *      ASN1_CHOICE_END(chname)
+ *
+ *      This will produce an ASN1_ITEM called chname_it
+ *      for a structure called chname. The structure
+ *      definition must look like this:
+ *      typedef struct {
+ *              int type;
+ *              union {
+ *                      ASN1_SOMETHING *opt1;
+ *                      ASN1_SOMEOTHER *opt2;
+ *              } value;
+ *      } chname;
+ *
+ *      the name of the selector must be 'type'.
+ *      to use an alternative selector name use the
+ *      ASN1_CHOICE_END_selector() version.
+ */
+
+# define ASN1_CHOICE(tname) \
+        static const ASN1_TEMPLATE tname##_ch_tt[]
+
+# define ASN1_CHOICE_cb(tname, cb) \
+        static const ASN1_AUX tname##_aux = {NULL, 0, 0, 0, cb, 0, NULL}; \
+        ASN1_CHOICE(tname)
+
+# define ASN1_CHOICE_END(stname) ASN1_CHOICE_END_name(stname, stname)
+
+# define static_ASN1_CHOICE_END(stname) static_ASN1_CHOICE_END_name(stname, stname)
+
+# define ASN1_CHOICE_END_name(stname, tname) ASN1_CHOICE_END_selector(stname, tname, type)
+
+# define static_ASN1_CHOICE_END_name(stname, tname) static_ASN1_CHOICE_END_selector(stname, tname, type)
+
+# define ASN1_CHOICE_END_selector(stname, tname, selname) \
+        ;\
+        ASN1_ITEM_start(tname) \
+                ASN1_ITYPE_CHOICE,\
+                offsetof(stname,selname) ,\
+                tname##_ch_tt,\
+                sizeof(tname##_ch_tt) / sizeof(ASN1_TEMPLATE),\
+                NULL,\
+                sizeof(stname),\
+                #stname \
+        ASN1_ITEM_end(tname)
+
+# define static_ASN1_CHOICE_END_selector(stname, tname, selname) \
+        ;\
+        static_ASN1_ITEM_start(tname) \
+                ASN1_ITYPE_CHOICE,\
+                offsetof(stname,selname) ,\
+                tname##_ch_tt,\
+                sizeof(tname##_ch_tt) / sizeof(ASN1_TEMPLATE),\
+                NULL,\
+                sizeof(stname),\
+                #stname \
+        ASN1_ITEM_end(tname)
+
+# define ASN1_CHOICE_END_cb(stname, tname, selname) \
+        ;\
+        ASN1_ITEM_start(tname) \
+                ASN1_ITYPE_CHOICE,\
+                offsetof(stname,selname) ,\
+                tname##_ch_tt,\
+                sizeof(tname##_ch_tt) / sizeof(ASN1_TEMPLATE),\
+                &tname##_aux,\
+                sizeof(stname),\
+                #stname \
+        ASN1_ITEM_end(tname)
+
+/* This helps with the template wrapper form of ASN1_ITEM */
+
+# define ASN1_EX_TEMPLATE_TYPE(flags, tag, name, type) { \
+        (flags), (tag), 0,\
+        #name, ASN1_ITEM_ref(type) }
+
+/* These help with SEQUENCE or CHOICE components */
+
+/* used to declare other types */
+
+# define ASN1_EX_TYPE(flags, tag, stname, field, type) { \
+        (flags), (tag), offsetof(stname, field),\
+        #field, ASN1_ITEM_ref(type) }
+
+/* implicit and explicit helper macros */
+
+# define ASN1_IMP_EX(stname, field, type, tag, ex) \
+         ASN1_EX_TYPE(ASN1_TFLG_IMPLICIT | (ex), tag, stname, field, type)
+
+# define ASN1_EXP_EX(stname, field, type, tag, ex) \
+         ASN1_EX_TYPE(ASN1_TFLG_EXPLICIT | (ex), tag, stname, field, type)
+
+/* Any defined by macros: the field used is in the table itself */
+
+# define ASN1_ADB_OBJECT(tblname) { ASN1_TFLG_ADB_OID, -1, 0, #tblname, tblname##_adb }
+# define ASN1_ADB_INTEGER(tblname) { ASN1_TFLG_ADB_INT, -1, 0, #tblname, tblname##_adb }
+
+/* Plain simple type */
+# define ASN1_SIMPLE(stname, field, type) ASN1_EX_TYPE(0,0, stname, field, type)
+/* Embedded simple type */
+# define ASN1_EMBED(stname, field, type) ASN1_EX_TYPE(ASN1_TFLG_EMBED,0, stname, field, type)
+
+/* OPTIONAL simple type */
+# define ASN1_OPT(stname, field, type) ASN1_EX_TYPE(ASN1_TFLG_OPTIONAL, 0, stname, field, type)
+# define ASN1_OPT_EMBED(stname, field, type) ASN1_EX_TYPE(ASN1_TFLG_OPTIONAL|ASN1_TFLG_EMBED, 0, stname, field, type)
+
+/* IMPLICIT tagged simple type */
+# define ASN1_IMP(stname, field, type, tag) ASN1_IMP_EX(stname, field, type, tag, 0)
+# define ASN1_IMP_EMBED(stname, field, type, tag) ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_EMBED)
+
+/* IMPLICIT tagged OPTIONAL simple type */
+# define ASN1_IMP_OPT(stname, field, type, tag) ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL)
+# define ASN1_IMP_OPT_EMBED(stname, field, type, tag) ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL|ASN1_TFLG_EMBED)
+
+/* Same as above but EXPLICIT */
+
+# define ASN1_EXP(stname, field, type, tag) ASN1_EXP_EX(stname, field, type, tag, 0)
+# define ASN1_EXP_EMBED(stname, field, type, tag) ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_EMBED)
+# define ASN1_EXP_OPT(stname, field, type, tag) ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL)
+# define ASN1_EXP_OPT_EMBED(stname, field, type, tag) ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL|ASN1_TFLG_EMBED)
+
+/* SEQUENCE OF type */
+# define ASN1_SEQUENCE_OF(stname, field, type) \
+                ASN1_EX_TYPE(ASN1_TFLG_SEQUENCE_OF, 0, stname, field, type)
+
+/* OPTIONAL SEQUENCE OF */
+# define ASN1_SEQUENCE_OF_OPT(stname, field, type) \
+                ASN1_EX_TYPE(ASN1_TFLG_SEQUENCE_OF|ASN1_TFLG_OPTIONAL, 0, stname, field, type)
+
+/* Same as above but for SET OF */
+
+# define ASN1_SET_OF(stname, field, type) \
+                ASN1_EX_TYPE(ASN1_TFLG_SET_OF, 0, stname, field, type)
+
+# define ASN1_SET_OF_OPT(stname, field, type) \
+                ASN1_EX_TYPE(ASN1_TFLG_SET_OF|ASN1_TFLG_OPTIONAL, 0, stname, field, type)
+
+/* Finally compound types of SEQUENCE, SET, IMPLICIT, EXPLICIT and OPTIONAL */
+
+# define ASN1_IMP_SET_OF(stname, field, type, tag) \
+                        ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF)
+
+# define ASN1_EXP_SET_OF(stname, field, type, tag) \
+                        ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF)
+
+# define ASN1_IMP_SET_OF_OPT(stname, field, type, tag) \
+                        ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF|ASN1_TFLG_OPTIONAL)
+
+# define ASN1_EXP_SET_OF_OPT(stname, field, type, tag) \
+                        ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF|ASN1_TFLG_OPTIONAL)
+
+# define ASN1_IMP_SEQUENCE_OF(stname, field, type, tag) \
+                        ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF)
+
+# define ASN1_IMP_SEQUENCE_OF_OPT(stname, field, type, tag) \
+                        ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF|ASN1_TFLG_OPTIONAL)
+
+# define ASN1_EXP_SEQUENCE_OF(stname, field, type, tag) \
+                        ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF)
+
+# define ASN1_EXP_SEQUENCE_OF_OPT(stname, field, type, tag) \
+                        ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF|ASN1_TFLG_OPTIONAL)
+
+/* EXPLICIT using indefinite length constructed form */
+# define ASN1_NDEF_EXP(stname, field, type, tag) \
+                        ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_NDEF)
+
+/* EXPLICIT OPTIONAL using indefinite length constructed form */
+# define ASN1_NDEF_EXP_OPT(stname, field, type, tag) \
+                        ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL|ASN1_TFLG_NDEF)
+
+/* Macros for the ASN1_ADB structure */
+
+# define ASN1_ADB(name) \
+        static const ASN1_ADB_TABLE name##_adbtbl[]
+
+# define ASN1_ADB_END(name, flags, field, adb_cb, def, none) \
+        ;\
+        static const ASN1_ITEM *name##_adb(void) \
+        { \
+        static const ASN1_ADB internal_adb = \
+                {\
+                flags,\
+                offsetof(name, field),\
+                adb_cb,\
+                name##_adbtbl,\
+                sizeof(name##_adbtbl) / sizeof(ASN1_ADB_TABLE),\
+                def,\
+                none\
+                }; \
+                return (const ASN1_ITEM *) &internal_adb; \
+        } \
+        void dummy_function(void)
+
+# define ADB_ENTRY(val, template) {val, template}
+
+# define ASN1_ADB_TEMPLATE(name) \
+        static const ASN1_TEMPLATE name##_tt
+
+/*
+ * This is the ASN1 template structure that defines a wrapper round the
+ * actual type. It determines the actual position of the field in the value
+ * structure, various flags such as OPTIONAL and the field name.
+ */
+
+struct ASN1_TEMPLATE_st {
+    unsigned long flags;        /* Various flags */
+    long tag;                   /* tag, not used if no tagging */
+    unsigned long offset;       /* Offset of this field in structure */
+    const char *field_name;     /* Field name */
+    ASN1_ITEM_EXP *item;        /* Relevant ASN1_ITEM or ASN1_ADB */
+};
+
+/* Macro to extract ASN1_ITEM and ASN1_ADB pointer from ASN1_TEMPLATE */
+
+# define ASN1_TEMPLATE_item(t) (t->item_ptr)
+# define ASN1_TEMPLATE_adb(t) (t->item_ptr)
+
+typedef struct ASN1_ADB_TABLE_st ASN1_ADB_TABLE;
+typedef struct ASN1_ADB_st ASN1_ADB;
+
+struct ASN1_ADB_st {
+    unsigned long flags;        /* Various flags */
+    unsigned long offset;       /* Offset of selector field */
+    int (*adb_cb)(long *psel);  /* Application callback */
+    const ASN1_ADB_TABLE *tbl;  /* Table of possible types */
+    long tblcount;              /* Number of entries in tbl */
+    const ASN1_TEMPLATE *default_tt; /* Type to use if no match */
+    const ASN1_TEMPLATE *null_tt; /* Type to use if selector is NULL */
+};
+
+struct ASN1_ADB_TABLE_st {
+    long value;                 /* NID for an object or value for an int */
+    const ASN1_TEMPLATE tt;     /* item for this value */
+};
+
+/* template flags */
+
+/* Field is optional */
+# define ASN1_TFLG_OPTIONAL      (0x1)
+
+/* Field is a SET OF */
+# define ASN1_TFLG_SET_OF        (0x1 << 1)
+
+/* Field is a SEQUENCE OF */
+# define ASN1_TFLG_SEQUENCE_OF   (0x2 << 1)
+
+/*
+ * Special case: this refers to a SET OF that will be sorted into DER order
+ * when encoded *and* the corresponding STACK will be modified to match the
+ * new order.
+ */
+# define ASN1_TFLG_SET_ORDER     (0x3 << 1)
+
+/* Mask for SET OF or SEQUENCE OF */
+# define ASN1_TFLG_SK_MASK       (0x3 << 1)
+
+/*
+ * These flags mean the tag should be taken from the tag field. If EXPLICIT
+ * then the underlying type is used for the inner tag.
+ */
+
+/* IMPLICIT tagging */
+# define ASN1_TFLG_IMPTAG        (0x1 << 3)
+
+/* EXPLICIT tagging, inner tag from underlying type */
+# define ASN1_TFLG_EXPTAG        (0x2 << 3)
+
+# define ASN1_TFLG_TAG_MASK      (0x3 << 3)
+
+/* context specific IMPLICIT */
+# define ASN1_TFLG_IMPLICIT      (ASN1_TFLG_IMPTAG|ASN1_TFLG_CONTEXT)
+
+/* context specific EXPLICIT */
+# define ASN1_TFLG_EXPLICIT      (ASN1_TFLG_EXPTAG|ASN1_TFLG_CONTEXT)
+
+/*
+ * If tagging is in force these determine the type of tag to use. Otherwise
+ * the tag is determined by the underlying type. These values reflect the
+ * actual octet format.
+ */
+
+/* Universal tag */
+# define ASN1_TFLG_UNIVERSAL     (0x0<<6)
+/* Application tag */
+# define ASN1_TFLG_APPLICATION   (0x1<<6)
+/* Context specific tag */
+# define ASN1_TFLG_CONTEXT       (0x2<<6)
+/* Private tag */
+# define ASN1_TFLG_PRIVATE       (0x3<<6)
+
+# define ASN1_TFLG_TAG_CLASS     (0x3<<6)
+
+/*
+ * These are for ANY DEFINED BY type. In this case the 'item' field points to
+ * an ASN1_ADB structure which contains a table of values to decode the
+ * relevant type
+ */
+
+# define ASN1_TFLG_ADB_MASK      (0x3<<8)
+
+# define ASN1_TFLG_ADB_OID       (0x1<<8)
+
+# define ASN1_TFLG_ADB_INT       (0x1<<9)
+
+/*
+ * This flag when present in a SEQUENCE OF, SET OF or EXPLICIT causes
+ * indefinite length constructed encoding to be used if required.
+ */
+
+# define ASN1_TFLG_NDEF          (0x1<<11)
+
+/* Field is embedded and not a pointer */
+# define ASN1_TFLG_EMBED         (0x1 << 12)
+
+/* This is the actual ASN1 item itself */
+
+struct ASN1_ITEM_st {
+    char itype;                 /* The item type, primitive, SEQUENCE, CHOICE
+                                 * or extern */
+    long utype;                 /* underlying type */
+    const ASN1_TEMPLATE *templates; /* If SEQUENCE or CHOICE this contains
+                                     * the contents */
+    long tcount;                /* Number of templates if SEQUENCE or CHOICE */
+    const void *funcs;          /* further data and type-specific functions */
+    /* funcs can be ASN1_PRIMITIVE_FUNCS*, ASN1_EXTERN_FUNCS*, or ASN1_AUX* */
+    long size;                  /* Structure size (usually) */
+    const char *sname;          /* Structure name */
+};
+
+/*
+ * Cache for ASN1 tag and length, so we don't keep re-reading it for things
+ * like CHOICE
+ */
+
+struct ASN1_TLC_st {
+    char valid;                 /* Values below are valid */
+    int ret;                    /* return value */
+    long plen;                  /* length */
+    int ptag;                   /* class value */
+    int pclass;                 /* class value */
+    int hdrlen;                 /* header length */
+};
+
+/* Typedefs for ASN1 function pointers */
+typedef int ASN1_ex_d2i(ASN1_VALUE **pval, const unsigned char **in, long len,
+                        const ASN1_ITEM *it, int tag, int aclass, char opt,
+                        ASN1_TLC *ctx);
+
+typedef int ASN1_ex_d2i_ex(ASN1_VALUE **pval, const unsigned char **in, long len,
+                           const ASN1_ITEM *it, int tag, int aclass, char opt,
+                           ASN1_TLC *ctx, OSSL_LIB_CTX *libctx,
+                           const char *propq);
+typedef int ASN1_ex_i2d(const ASN1_VALUE **pval, unsigned char **out,
+                        const ASN1_ITEM *it, int tag, int aclass);
+typedef int ASN1_ex_new_func(ASN1_VALUE **pval, const ASN1_ITEM *it);
+typedef int ASN1_ex_new_ex_func(ASN1_VALUE **pval, const ASN1_ITEM *it,
+                                OSSL_LIB_CTX *libctx, const char *propq);
+typedef void ASN1_ex_free_func(ASN1_VALUE **pval, const ASN1_ITEM *it);
+
+typedef int ASN1_ex_print_func(BIO *out, const ASN1_VALUE **pval,
+                               int indent, const char *fname,
+                               const ASN1_PCTX *pctx);
+
+typedef int ASN1_primitive_i2c(const ASN1_VALUE **pval, unsigned char *cont,
+                               int *putype, const ASN1_ITEM *it);
+typedef int ASN1_primitive_c2i(ASN1_VALUE **pval, const unsigned char *cont,
+                               int len, int utype, char *free_cont,
+                               const ASN1_ITEM *it);
+typedef int ASN1_primitive_print(BIO *out, const ASN1_VALUE **pval,
+                                 const ASN1_ITEM *it, int indent,
+                                 const ASN1_PCTX *pctx);
+
+typedef struct ASN1_EXTERN_FUNCS_st {
+    void *app_data;
+    ASN1_ex_new_func *asn1_ex_new;
+    ASN1_ex_free_func *asn1_ex_free;
+    ASN1_ex_free_func *asn1_ex_clear;
+    ASN1_ex_d2i *asn1_ex_d2i;
+    ASN1_ex_i2d *asn1_ex_i2d;
+    ASN1_ex_print_func *asn1_ex_print;
+    ASN1_ex_new_ex_func *asn1_ex_new_ex;
+    ASN1_ex_d2i_ex *asn1_ex_d2i_ex;
+} ASN1_EXTERN_FUNCS;
+
+typedef struct ASN1_PRIMITIVE_FUNCS_st {
+    void *app_data;
+    unsigned long flags;
+    ASN1_ex_new_func *prim_new;
+    ASN1_ex_free_func *prim_free;
+    ASN1_ex_free_func *prim_clear;
+    ASN1_primitive_c2i *prim_c2i;
+    ASN1_primitive_i2c *prim_i2c;
+    ASN1_primitive_print *prim_print;
+} ASN1_PRIMITIVE_FUNCS;
+
+/*
+ * This is the ASN1_AUX structure: it handles various miscellaneous
+ * requirements. For example the use of reference counts and an informational
+ * callback. The "informational callback" is called at various points during
+ * the ASN1 encoding and decoding. It can be used to provide minor
+ * customisation of the structures used. This is most useful where the
+ * supplied routines *almost* do the right thing but need some extra help at
+ * a few points. If the callback returns zero then it is assumed a fatal
+ * error has occurred and the main operation should be abandoned. If major
+ * changes in the default behaviour are required then an external type is
+ * more appropriate.
+ * For the operations ASN1_OP_I2D_PRE, ASN1_OP_I2D_POST, ASN1_OP_PRINT_PRE, and
+ * ASN1_OP_PRINT_POST, meanwhile a variant of the callback with const parameter
+ * 'in' is provided to make clear statically that its input is not modified. If
+ * and only if this variant is in use the flag ASN1_AFLG_CONST_CB must be set.
+ */
+
+typedef int ASN1_aux_cb(int operation, ASN1_VALUE **in, const ASN1_ITEM *it,
+                        void *exarg);
+typedef int ASN1_aux_const_cb(int operation, const ASN1_VALUE **in,
+                              const ASN1_ITEM *it, void *exarg);
+
+typedef struct ASN1_AUX_st {
+    void *app_data;
+    int flags;
+    int ref_offset;             /* Offset of reference value */
+    int ref_lock;               /* Offset of lock value */
+    ASN1_aux_cb *asn1_cb;
+    int enc_offset;             /* Offset of ASN1_ENCODING structure */
+    ASN1_aux_const_cb *asn1_const_cb; /* for ASN1_OP_I2D_ and ASN1_OP_PRINT_ */
+} ASN1_AUX;
+
+/* For print related callbacks exarg points to this structure */
+typedef struct ASN1_PRINT_ARG_st {
+    BIO *out;
+    int indent;
+    const ASN1_PCTX *pctx;
+} ASN1_PRINT_ARG;
+
+/* For streaming related callbacks exarg points to this structure */
+typedef struct ASN1_STREAM_ARG_st {
+    /* BIO to stream through */
+    BIO *out;
+    /* BIO with filters appended */
+    BIO *ndef_bio;
+    /* Streaming I/O boundary */
+    unsigned char **boundary;
+} ASN1_STREAM_ARG;
+
+/* Flags in ASN1_AUX */
+
+/* Use a reference count */
+# define ASN1_AFLG_REFCOUNT      1
+/* Save the encoding of structure (useful for signatures) */
+# define ASN1_AFLG_ENCODING      2
+/* The Sequence length is invalid */
+# define ASN1_AFLG_BROKEN        4
+/* Use the new asn1_const_cb */
+# define ASN1_AFLG_CONST_CB      8
+
+/* operation values for asn1_cb */
+
+# define ASN1_OP_NEW_PRE         0
+# define ASN1_OP_NEW_POST        1
+# define ASN1_OP_FREE_PRE        2
+# define ASN1_OP_FREE_POST       3
+# define ASN1_OP_D2I_PRE         4
+# define ASN1_OP_D2I_POST        5
+# define ASN1_OP_I2D_PRE         6
+# define ASN1_OP_I2D_POST        7
+# define ASN1_OP_PRINT_PRE       8
+# define ASN1_OP_PRINT_POST      9
+# define ASN1_OP_STREAM_PRE      10
+# define ASN1_OP_STREAM_POST     11
+# define ASN1_OP_DETACHED_PRE    12
+# define ASN1_OP_DETACHED_POST   13
+# define ASN1_OP_DUP_PRE         14
+# define ASN1_OP_DUP_POST        15
+# define ASN1_OP_GET0_LIBCTX     16
+# define ASN1_OP_GET0_PROPQ      17
+
+/* Macro to implement a primitive type */
+# define IMPLEMENT_ASN1_TYPE(stname) IMPLEMENT_ASN1_TYPE_ex(stname, stname, 0)
+# define IMPLEMENT_ASN1_TYPE_ex(itname, vname, ex) \
+                                ASN1_ITEM_start(itname) \
+                                        ASN1_ITYPE_PRIMITIVE, V_##vname, NULL, 0, NULL, ex, #itname \
+                                ASN1_ITEM_end(itname)
+
+/* Macro to implement a multi string type */
+# define IMPLEMENT_ASN1_MSTRING(itname, mask) \
+                                ASN1_ITEM_start(itname) \
+                                        ASN1_ITYPE_MSTRING, mask, NULL, 0, NULL, sizeof(ASN1_STRING), #itname \
+                                ASN1_ITEM_end(itname)
+
+# define IMPLEMENT_EXTERN_ASN1(sname, tag, fptrs) \
+        ASN1_ITEM_start(sname) \
+                ASN1_ITYPE_EXTERN, \
+                tag, \
+                NULL, \
+                0, \
+                &fptrs, \
+                0, \
+                #sname \
+        ASN1_ITEM_end(sname)
+
+/* Macro to implement standard functions in terms of ASN1_ITEM structures */
+
+# define IMPLEMENT_ASN1_FUNCTIONS(stname) IMPLEMENT_ASN1_FUNCTIONS_fname(stname, stname, stname)
+
+# define IMPLEMENT_ASN1_FUNCTIONS_name(stname, itname) IMPLEMENT_ASN1_FUNCTIONS_fname(stname, itname, itname)
+
+# define IMPLEMENT_ASN1_FUNCTIONS_ENCODE_name(stname, itname) \
+                        IMPLEMENT_ASN1_FUNCTIONS_ENCODE_fname(stname, itname, itname)
+
+# define IMPLEMENT_STATIC_ASN1_ALLOC_FUNCTIONS(stname) \
+                IMPLEMENT_ASN1_ALLOC_FUNCTIONS_pfname(static, stname, stname, stname)
+
+# define IMPLEMENT_ASN1_ALLOC_FUNCTIONS(stname) \
+                IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, stname, stname)
+
+# define IMPLEMENT_ASN1_ALLOC_FUNCTIONS_pfname(pre, stname, itname, fname) \
+        pre stname *fname##_new(void) \
+        { \
+                return (stname *)ASN1_item_new(ASN1_ITEM_rptr(itname)); \
+        } \
+        pre void fname##_free(stname *a) \
+        { \
+                ASN1_item_free((ASN1_VALUE *)a, ASN1_ITEM_rptr(itname)); \
+        }
+
+# define IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, itname, fname) \
+        stname *fname##_new(void) \
+        { \
+                return (stname *)ASN1_item_new(ASN1_ITEM_rptr(itname)); \
+        } \
+        void fname##_free(stname *a) \
+        { \
+                ASN1_item_free((ASN1_VALUE *)a, ASN1_ITEM_rptr(itname)); \
+        }
+
+# define IMPLEMENT_ASN1_FUNCTIONS_fname(stname, itname, fname) \
+        IMPLEMENT_ASN1_ENCODE_FUNCTIONS_fname(stname, itname, fname) \
+        IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, itname, fname)
+
+# define IMPLEMENT_ASN1_ENCODE_FUNCTIONS_fname(stname, itname, fname) \
+        stname *d2i_##fname(stname **a, const unsigned char **in, long len) \
+        { \
+                return (stname *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, ASN1_ITEM_rptr(itname));\
+        } \
+        int i2d_##fname(const stname *a, unsigned char **out) \
+        { \
+                return ASN1_item_i2d((const ASN1_VALUE *)a, out, ASN1_ITEM_rptr(itname));\
+        }
+
+# define IMPLEMENT_ASN1_NDEF_FUNCTION(stname) \
+        int i2d_##stname##_NDEF(const stname *a, unsigned char **out) \
+        { \
+                return ASN1_item_ndef_i2d((const ASN1_VALUE *)a, out, ASN1_ITEM_rptr(stname));\
+        }
+
+# define IMPLEMENT_STATIC_ASN1_ENCODE_FUNCTIONS(stname) \
+        static stname *d2i_##stname(stname **a, \
+                                   const unsigned char **in, long len) \
+        { \
+                return (stname *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, \
+                                               ASN1_ITEM_rptr(stname)); \
+        } \
+        static int i2d_##stname(const stname *a, unsigned char **out) \
+        { \
+                return ASN1_item_i2d((const ASN1_VALUE *)a, out, \
+                                     ASN1_ITEM_rptr(stname)); \
+        }
+
+# define IMPLEMENT_ASN1_DUP_FUNCTION(stname) \
+        stname * stname##_dup(const stname *x) \
+        { \
+        return ASN1_item_dup(ASN1_ITEM_rptr(stname), x); \
+        }
+
+# define IMPLEMENT_ASN1_PRINT_FUNCTION(stname) \
+        IMPLEMENT_ASN1_PRINT_FUNCTION_fname(stname, stname, stname)
+
+# define IMPLEMENT_ASN1_PRINT_FUNCTION_fname(stname, itname, fname) \
+        int fname##_print_ctx(BIO *out, const stname *x, int indent, \
+                                                const ASN1_PCTX *pctx) \
+        { \
+                return ASN1_item_print(out, (const ASN1_VALUE *)x, indent, \
+                        ASN1_ITEM_rptr(itname), pctx); \
+        }
+
+/* external definitions for primitive types */
+
+DECLARE_ASN1_ITEM(ASN1_BOOLEAN)
+DECLARE_ASN1_ITEM(ASN1_TBOOLEAN)
+DECLARE_ASN1_ITEM(ASN1_FBOOLEAN)
+DECLARE_ASN1_ITEM(ASN1_SEQUENCE)
+DECLARE_ASN1_ITEM(CBIGNUM)
+DECLARE_ASN1_ITEM(BIGNUM)
+DECLARE_ASN1_ITEM(INT32)
+DECLARE_ASN1_ITEM(ZINT32)
+DECLARE_ASN1_ITEM(UINT32)
+DECLARE_ASN1_ITEM(ZUINT32)
+DECLARE_ASN1_ITEM(INT64)
+DECLARE_ASN1_ITEM(ZINT64)
+DECLARE_ASN1_ITEM(UINT64)
+DECLARE_ASN1_ITEM(ZUINT64)
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+/*
+ * LONG and ZLONG are strongly discouraged for use as stored data, as the
+ * underlying C type (long) differs in size depending on the architecture.
+ * They are designed with 32-bit longs in mind.
+ */
+DECLARE_ASN1_ITEM(LONG)
+DECLARE_ASN1_ITEM(ZLONG)
+# endif
+
+SKM_DEFINE_STACK_OF_INTERNAL(ASN1_VALUE, ASN1_VALUE, ASN1_VALUE)
+#define sk_ASN1_VALUE_num(sk) OPENSSL_sk_num(ossl_check_const_ASN1_VALUE_sk_type(sk))
+#define sk_ASN1_VALUE_value(sk, idx) ((ASN1_VALUE *)OPENSSL_sk_value(ossl_check_const_ASN1_VALUE_sk_type(sk), (idx)))
+#define sk_ASN1_VALUE_new(cmp) ((STACK_OF(ASN1_VALUE) *)OPENSSL_sk_new(ossl_check_ASN1_VALUE_compfunc_type(cmp)))
+#define sk_ASN1_VALUE_new_null() ((STACK_OF(ASN1_VALUE) *)OPENSSL_sk_new_null())
+#define sk_ASN1_VALUE_new_reserve(cmp, n) ((STACK_OF(ASN1_VALUE) *)OPENSSL_sk_new_reserve(ossl_check_ASN1_VALUE_compfunc_type(cmp), (n)))
+#define sk_ASN1_VALUE_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_ASN1_VALUE_sk_type(sk), (n))
+#define sk_ASN1_VALUE_free(sk) OPENSSL_sk_free(ossl_check_ASN1_VALUE_sk_type(sk))
+#define sk_ASN1_VALUE_zero(sk) OPENSSL_sk_zero(ossl_check_ASN1_VALUE_sk_type(sk))
+#define sk_ASN1_VALUE_delete(sk, i) ((ASN1_VALUE *)OPENSSL_sk_delete(ossl_check_ASN1_VALUE_sk_type(sk), (i)))
+#define sk_ASN1_VALUE_delete_ptr(sk, ptr) ((ASN1_VALUE *)OPENSSL_sk_delete_ptr(ossl_check_ASN1_VALUE_sk_type(sk), ossl_check_ASN1_VALUE_type(ptr)))
+#define sk_ASN1_VALUE_push(sk, ptr) OPENSSL_sk_push(ossl_check_ASN1_VALUE_sk_type(sk), ossl_check_ASN1_VALUE_type(ptr))
+#define sk_ASN1_VALUE_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_ASN1_VALUE_sk_type(sk), ossl_check_ASN1_VALUE_type(ptr))
+#define sk_ASN1_VALUE_pop(sk) ((ASN1_VALUE *)OPENSSL_sk_pop(ossl_check_ASN1_VALUE_sk_type(sk)))
+#define sk_ASN1_VALUE_shift(sk) ((ASN1_VALUE *)OPENSSL_sk_shift(ossl_check_ASN1_VALUE_sk_type(sk)))
+#define sk_ASN1_VALUE_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ASN1_VALUE_sk_type(sk),ossl_check_ASN1_VALUE_freefunc_type(freefunc))
+#define sk_ASN1_VALUE_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_ASN1_VALUE_sk_type(sk), ossl_check_ASN1_VALUE_type(ptr), (idx))
+#define sk_ASN1_VALUE_set(sk, idx, ptr) ((ASN1_VALUE *)OPENSSL_sk_set(ossl_check_ASN1_VALUE_sk_type(sk), (idx), ossl_check_ASN1_VALUE_type(ptr)))
+#define sk_ASN1_VALUE_find(sk, ptr) OPENSSL_sk_find(ossl_check_ASN1_VALUE_sk_type(sk), ossl_check_ASN1_VALUE_type(ptr))
+#define sk_ASN1_VALUE_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_ASN1_VALUE_sk_type(sk), ossl_check_ASN1_VALUE_type(ptr))
+#define sk_ASN1_VALUE_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_ASN1_VALUE_sk_type(sk), ossl_check_ASN1_VALUE_type(ptr), pnum)
+#define sk_ASN1_VALUE_sort(sk) OPENSSL_sk_sort(ossl_check_ASN1_VALUE_sk_type(sk))
+#define sk_ASN1_VALUE_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_ASN1_VALUE_sk_type(sk))
+#define sk_ASN1_VALUE_dup(sk) ((STACK_OF(ASN1_VALUE) *)OPENSSL_sk_dup(ossl_check_const_ASN1_VALUE_sk_type(sk)))
+#define sk_ASN1_VALUE_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ASN1_VALUE) *)OPENSSL_sk_deep_copy(ossl_check_const_ASN1_VALUE_sk_type(sk), ossl_check_ASN1_VALUE_copyfunc_type(copyfunc), ossl_check_ASN1_VALUE_freefunc_type(freefunc)))
+#define sk_ASN1_VALUE_set_cmp_func(sk, cmp) ((sk_ASN1_VALUE_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_ASN1_VALUE_sk_type(sk), ossl_check_ASN1_VALUE_compfunc_type(cmp)))
+
+
+
+/* Functions used internally by the ASN1 code */
+
+int ASN1_item_ex_new(ASN1_VALUE **pval, const ASN1_ITEM *it);
+void ASN1_item_ex_free(ASN1_VALUE **pval, const ASN1_ITEM *it);
+
+int ASN1_item_ex_d2i(ASN1_VALUE **pval, const unsigned char **in, long len,
+                     const ASN1_ITEM *it, int tag, int aclass, char opt,
+                     ASN1_TLC *ctx);
+
+int ASN1_item_ex_i2d(const ASN1_VALUE **pval, unsigned char **out,
+                     const ASN1_ITEM *it, int tag, int aclass);
+
+/* Legacy compatibility */
+# define IMPLEMENT_ASN1_FUNCTIONS_const(name) IMPLEMENT_ASN1_FUNCTIONS(name)
+# define IMPLEMENT_ASN1_ENCODE_FUNCTIONS_const_fname(stname, itname, fname) \
+         IMPLEMENT_ASN1_ENCODE_FUNCTIONS_fname(stname, itname, fname)
+
+#ifdef  __cplusplus
+}
+#endif
+#endif
diff --git a/src/include/openssl/async.h b/src/include/openssl/async.h
new file mode 100644
index 0000000..826ffb9
--- /dev/null
+++ b/src/include/openssl/async.h
@@ -0,0 +1,104 @@
+/*
+ * Copyright 2015-2022 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#include <stdlib.h>
+
+#ifndef OPENSSL_ASYNC_H
+# define OPENSSL_ASYNC_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_ASYNC_H
+# endif
+
+#if defined(_WIN32)
+# if defined(BASETYPES) || defined(_WINDEF_H)
+/* application has to include <windows.h> to use this */
+#define OSSL_ASYNC_FD       HANDLE
+#define OSSL_BAD_ASYNC_FD   INVALID_HANDLE_VALUE
+# endif
+#else
+#define OSSL_ASYNC_FD       int
+#define OSSL_BAD_ASYNC_FD   -1
+#endif
+# include <openssl/asyncerr.h>
+
+
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+typedef struct async_job_st ASYNC_JOB;
+typedef struct async_wait_ctx_st ASYNC_WAIT_CTX;
+typedef int (*ASYNC_callback_fn)(void *arg);
+
+#define ASYNC_ERR      0
+#define ASYNC_NO_JOBS  1
+#define ASYNC_PAUSE    2
+#define ASYNC_FINISH   3
+
+#define ASYNC_STATUS_UNSUPPORTED    0
+#define ASYNC_STATUS_ERR            1
+#define ASYNC_STATUS_OK             2
+#define ASYNC_STATUS_EAGAIN         3
+
+int ASYNC_init_thread(size_t max_size, size_t init_size);
+void ASYNC_cleanup_thread(void);
+
+#ifdef OSSL_ASYNC_FD
+ASYNC_WAIT_CTX *ASYNC_WAIT_CTX_new(void);
+void ASYNC_WAIT_CTX_free(ASYNC_WAIT_CTX *ctx);
+int ASYNC_WAIT_CTX_set_wait_fd(ASYNC_WAIT_CTX *ctx, const void *key,
+                               OSSL_ASYNC_FD fd,
+                               void *custom_data,
+                               void (*cleanup)(ASYNC_WAIT_CTX *, const void *,
+                                               OSSL_ASYNC_FD, void *));
+int ASYNC_WAIT_CTX_get_fd(ASYNC_WAIT_CTX *ctx, const void *key,
+                        OSSL_ASYNC_FD *fd, void **custom_data);
+int ASYNC_WAIT_CTX_get_all_fds(ASYNC_WAIT_CTX *ctx, OSSL_ASYNC_FD *fd,
+                               size_t *numfds);
+int ASYNC_WAIT_CTX_get_callback(ASYNC_WAIT_CTX *ctx,
+                                ASYNC_callback_fn *callback,
+                                void **callback_arg);
+int ASYNC_WAIT_CTX_set_callback(ASYNC_WAIT_CTX *ctx,
+                                ASYNC_callback_fn callback,
+                                void *callback_arg);
+int ASYNC_WAIT_CTX_set_status(ASYNC_WAIT_CTX *ctx, int status);
+int ASYNC_WAIT_CTX_get_status(ASYNC_WAIT_CTX *ctx);
+int ASYNC_WAIT_CTX_get_changed_fds(ASYNC_WAIT_CTX *ctx, OSSL_ASYNC_FD *addfd,
+                                   size_t *numaddfds, OSSL_ASYNC_FD *delfd,
+                                   size_t *numdelfds);
+int ASYNC_WAIT_CTX_clear_fd(ASYNC_WAIT_CTX *ctx, const void *key);
+#endif
+
+int ASYNC_is_capable(void);
+
+typedef void *(*ASYNC_stack_alloc_fn)(size_t *num);
+typedef void (*ASYNC_stack_free_fn)(void *addr);
+
+int ASYNC_set_mem_functions(ASYNC_stack_alloc_fn alloc_fn,
+                            ASYNC_stack_free_fn free_fn);
+void ASYNC_get_mem_functions(ASYNC_stack_alloc_fn *alloc_fn,
+                             ASYNC_stack_free_fn *free_fn);
+
+int ASYNC_start_job(ASYNC_JOB **job, ASYNC_WAIT_CTX *ctx, int *ret,
+                    int (*func)(void *), void *args, size_t size);
+int ASYNC_pause_job(void);
+
+ASYNC_JOB *ASYNC_get_current_job(void);
+ASYNC_WAIT_CTX *ASYNC_get_wait_ctx(ASYNC_JOB *job);
+void ASYNC_block_pause(void);
+void ASYNC_unblock_pause(void);
+
+
+# ifdef  __cplusplus
+}
+# endif
+#endif
diff --git a/src/include/openssl/asyncerr.h b/src/include/openssl/asyncerr.h
new file mode 100644
index 0000000..c093f7b
--- /dev/null
+++ b/src/include/openssl/asyncerr.h
@@ -0,0 +1,29 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_ASYNCERR_H
+# define OPENSSL_ASYNCERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+
+/*
+ * ASYNC reason codes.
+ */
+# define ASYNC_R_FAILED_TO_SET_POOL                       101
+# define ASYNC_R_FAILED_TO_SWAP_CONTEXT                   102
+# define ASYNC_R_INIT_FAILED                              105
+# define ASYNC_R_INVALID_POOL_SIZE                        103
+
+#endif
diff --git a/src/include/openssl/bio.h b/src/include/openssl/bio.h
new file mode 100644
index 0000000..c932025
--- /dev/null
+++ b/src/include/openssl/bio.h
@@ -0,0 +1,1015 @@
+/*
+ * WARNING: do not edit!
+ * Generated by makefile from include\openssl\bio.h.in
+ *
+ * Copyright 1995-2024 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+
+#ifndef OPENSSL_BIO_H
+# define OPENSSL_BIO_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_BIO_H
+# endif
+
+# include <openssl/e_os2.h>
+
+# ifndef OPENSSL_NO_STDIO
+#  include <stdio.h>
+# endif
+# include <stdarg.h>
+
+# include <openssl/crypto.h>
+# include <openssl/bioerr.h>
+# include <openssl/core.h>
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+/* There are the classes of BIOs */
+# define BIO_TYPE_DESCRIPTOR     0x0100 /* socket, fd, connect or accept */
+# define BIO_TYPE_FILTER         0x0200
+# define BIO_TYPE_SOURCE_SINK    0x0400
+
+/* These are the 'types' of BIOs */
+# define BIO_TYPE_NONE             0
+# define BIO_TYPE_MEM            ( 1|BIO_TYPE_SOURCE_SINK)
+# define BIO_TYPE_FILE           ( 2|BIO_TYPE_SOURCE_SINK)
+
+# define BIO_TYPE_FD             ( 4|BIO_TYPE_SOURCE_SINK|BIO_TYPE_DESCRIPTOR)
+# define BIO_TYPE_SOCKET         ( 5|BIO_TYPE_SOURCE_SINK|BIO_TYPE_DESCRIPTOR)
+# define BIO_TYPE_NULL           ( 6|BIO_TYPE_SOURCE_SINK)
+# define BIO_TYPE_SSL            ( 7|BIO_TYPE_FILTER)
+# define BIO_TYPE_MD             ( 8|BIO_TYPE_FILTER)
+# define BIO_TYPE_BUFFER         ( 9|BIO_TYPE_FILTER)
+# define BIO_TYPE_CIPHER         (10|BIO_TYPE_FILTER)
+# define BIO_TYPE_BASE64         (11|BIO_TYPE_FILTER)
+# define BIO_TYPE_CONNECT        (12|BIO_TYPE_SOURCE_SINK|BIO_TYPE_DESCRIPTOR)
+# define BIO_TYPE_ACCEPT         (13|BIO_TYPE_SOURCE_SINK|BIO_TYPE_DESCRIPTOR)
+
+# define BIO_TYPE_NBIO_TEST      (16|BIO_TYPE_FILTER)/* server proxy BIO */
+# define BIO_TYPE_NULL_FILTER    (17|BIO_TYPE_FILTER)
+# define BIO_TYPE_BIO            (19|BIO_TYPE_SOURCE_SINK)/* half a BIO pair */
+# define BIO_TYPE_LINEBUFFER     (20|BIO_TYPE_FILTER)
+# define BIO_TYPE_DGRAM          (21|BIO_TYPE_SOURCE_SINK|BIO_TYPE_DESCRIPTOR)
+# define BIO_TYPE_ASN1           (22|BIO_TYPE_FILTER)
+# define BIO_TYPE_COMP           (23|BIO_TYPE_FILTER)
+# ifndef OPENSSL_NO_SCTP
+#  define BIO_TYPE_DGRAM_SCTP    (24|BIO_TYPE_SOURCE_SINK|BIO_TYPE_DESCRIPTOR)
+# endif
+# define BIO_TYPE_CORE_TO_PROV   (25|BIO_TYPE_SOURCE_SINK)
+# define BIO_TYPE_DGRAM_PAIR     (26|BIO_TYPE_SOURCE_SINK)
+# define BIO_TYPE_DGRAM_MEM      (27|BIO_TYPE_SOURCE_SINK)
+
+/* Custom type starting index returned by BIO_get_new_index() */
+#define BIO_TYPE_START           128
+/* Custom type maximum index that can be returned by BIO_get_new_index() */
+#define BIO_TYPE_MASK            0xFF
+
+/*
+ * BIO_FILENAME_READ|BIO_CLOSE to open or close on free.
+ * BIO_set_fp(in,stdin,BIO_NOCLOSE);
+ */
+# define BIO_NOCLOSE             0x00
+# define BIO_CLOSE               0x01
+
+/*
+ * These are used in the following macros and are passed to BIO_ctrl()
+ */
+# define BIO_CTRL_RESET          1/* opt - rewind/zero etc */
+# define BIO_CTRL_EOF            2/* opt - are we at the eof */
+# define BIO_CTRL_INFO           3/* opt - extra tit-bits */
+# define BIO_CTRL_SET            4/* man - set the 'IO' type */
+# define BIO_CTRL_GET            5/* man - get the 'IO' type */
+# define BIO_CTRL_PUSH           6/* opt - internal, used to signify change */
+# define BIO_CTRL_POP            7/* opt - internal, used to signify change */
+# define BIO_CTRL_GET_CLOSE      8/* man - set the 'close' on free */
+# define BIO_CTRL_SET_CLOSE      9/* man - set the 'close' on free */
+# define BIO_CTRL_PENDING        10/* opt - is their more data buffered */
+# define BIO_CTRL_FLUSH          11/* opt - 'flush' buffered output */
+# define BIO_CTRL_DUP            12/* man - extra stuff for 'duped' BIO */
+# define BIO_CTRL_WPENDING       13/* opt - number of bytes still to write */
+# define BIO_CTRL_SET_CALLBACK   14/* opt - set callback function */
+# define BIO_CTRL_GET_CALLBACK   15/* opt - set callback function */
+
+# define BIO_CTRL_PEEK           29/* BIO_f_buffer special */
+# define BIO_CTRL_SET_FILENAME   30/* BIO_s_file special */
+
+/* dgram BIO stuff */
+# define BIO_CTRL_DGRAM_CONNECT       31/* BIO dgram special */
+# define BIO_CTRL_DGRAM_SET_CONNECTED 32/* allow for an externally connected
+                                         * socket to be passed in */
+# define BIO_CTRL_DGRAM_SET_RECV_TIMEOUT 33/* setsockopt, essentially */
+# define BIO_CTRL_DGRAM_GET_RECV_TIMEOUT 34/* getsockopt, essentially */
+# define BIO_CTRL_DGRAM_SET_SEND_TIMEOUT 35/* setsockopt, essentially */
+# define BIO_CTRL_DGRAM_GET_SEND_TIMEOUT 36/* getsockopt, essentially */
+
+# define BIO_CTRL_DGRAM_GET_RECV_TIMER_EXP 37/* flag whether the last */
+# define BIO_CTRL_DGRAM_GET_SEND_TIMER_EXP 38/* I/O operation timed out */
+
+/* #ifdef IP_MTU_DISCOVER */
+# define BIO_CTRL_DGRAM_MTU_DISCOVER       39/* set DF bit on egress packets */
+/* #endif */
+
+# define BIO_CTRL_DGRAM_QUERY_MTU          40/* as kernel for current MTU */
+# define BIO_CTRL_DGRAM_GET_FALLBACK_MTU   47
+# define BIO_CTRL_DGRAM_GET_MTU            41/* get cached value for MTU */
+# define BIO_CTRL_DGRAM_SET_MTU            42/* set cached value for MTU.
+                                              * want to use this if asking
+                                              * the kernel fails */
+
+# define BIO_CTRL_DGRAM_MTU_EXCEEDED       43/* check whether the MTU was
+                                              * exceed in the previous write
+                                              * operation */
+
+# define BIO_CTRL_DGRAM_GET_PEER           46
+# define BIO_CTRL_DGRAM_SET_PEER           44/* Destination for the data */
+
+# define BIO_CTRL_DGRAM_SET_NEXT_TIMEOUT   45/* Next DTLS handshake timeout
+                                              * to adjust socket timeouts */
+# define BIO_CTRL_DGRAM_SET_DONT_FRAG      48
+
+# define BIO_CTRL_DGRAM_GET_MTU_OVERHEAD   49
+
+/* Deliberately outside of OPENSSL_NO_SCTP - used in bss_dgram.c */
+#  define BIO_CTRL_DGRAM_SCTP_SET_IN_HANDSHAKE    50
+# ifndef OPENSSL_NO_SCTP
+/* SCTP stuff */
+#  define BIO_CTRL_DGRAM_SCTP_ADD_AUTH_KEY                51
+#  define BIO_CTRL_DGRAM_SCTP_NEXT_AUTH_KEY               52
+#  define BIO_CTRL_DGRAM_SCTP_AUTH_CCS_RCVD               53
+#  define BIO_CTRL_DGRAM_SCTP_GET_SNDINFO         60
+#  define BIO_CTRL_DGRAM_SCTP_SET_SNDINFO         61
+#  define BIO_CTRL_DGRAM_SCTP_GET_RCVINFO         62
+#  define BIO_CTRL_DGRAM_SCTP_SET_RCVINFO         63
+#  define BIO_CTRL_DGRAM_SCTP_GET_PRINFO                  64
+#  define BIO_CTRL_DGRAM_SCTP_SET_PRINFO                  65
+#  define BIO_CTRL_DGRAM_SCTP_SAVE_SHUTDOWN               70
+# endif
+
+# define BIO_CTRL_DGRAM_SET_PEEK_MODE      71
+
+/*
+ * internal BIO:
+ * # define BIO_CTRL_SET_KTLS_SEND                 72
+ * # define BIO_CTRL_SET_KTLS_SEND_CTRL_MSG        74
+ * # define BIO_CTRL_CLEAR_KTLS_CTRL_MSG           75
+ */
+
+# define BIO_CTRL_GET_KTLS_SEND                 73
+# define BIO_CTRL_GET_KTLS_RECV                 76
+
+# define BIO_CTRL_DGRAM_SCTP_WAIT_FOR_DRY       77
+# define BIO_CTRL_DGRAM_SCTP_MSG_WAITING        78
+
+/* BIO_f_prefix controls */
+# define BIO_CTRL_SET_PREFIX                    79
+# define BIO_CTRL_SET_INDENT                    80
+# define BIO_CTRL_GET_INDENT                    81
+
+# define BIO_CTRL_DGRAM_GET_LOCAL_ADDR_CAP      82
+# define BIO_CTRL_DGRAM_GET_LOCAL_ADDR_ENABLE   83
+# define BIO_CTRL_DGRAM_SET_LOCAL_ADDR_ENABLE   84
+# define BIO_CTRL_DGRAM_GET_EFFECTIVE_CAPS      85
+# define BIO_CTRL_DGRAM_GET_CAPS                86
+# define BIO_CTRL_DGRAM_SET_CAPS                87
+# define BIO_CTRL_DGRAM_GET_NO_TRUNC            88
+# define BIO_CTRL_DGRAM_SET_NO_TRUNC            89
+
+/*
+ * internal BIO:
+ * # define BIO_CTRL_SET_KTLS_TX_ZEROCOPY_SENDFILE 90
+ */
+
+# define BIO_CTRL_GET_RPOLL_DESCRIPTOR          91
+# define BIO_CTRL_GET_WPOLL_DESCRIPTOR          92
+# define BIO_CTRL_DGRAM_DETECT_PEER_ADDR        93
+
+# define BIO_DGRAM_CAP_NONE                 0U
+# define BIO_DGRAM_CAP_HANDLES_SRC_ADDR     (1U << 0)
+# define BIO_DGRAM_CAP_HANDLES_DST_ADDR     (1U << 1)
+# define BIO_DGRAM_CAP_PROVIDES_SRC_ADDR    (1U << 2)
+# define BIO_DGRAM_CAP_PROVIDES_DST_ADDR    (1U << 3)
+
+# ifndef OPENSSL_NO_KTLS
+#  define BIO_get_ktls_send(b)         \
+     (BIO_ctrl(b, BIO_CTRL_GET_KTLS_SEND, 0, NULL) > 0)
+#  define BIO_get_ktls_recv(b)         \
+     (BIO_ctrl(b, BIO_CTRL_GET_KTLS_RECV, 0, NULL) > 0)
+# else
+#  define BIO_get_ktls_send(b)  (0)
+#  define BIO_get_ktls_recv(b)  (0)
+# endif
+
+/* modifiers */
+# define BIO_FP_READ             0x02
+# define BIO_FP_WRITE            0x04
+# define BIO_FP_APPEND           0x08
+# define BIO_FP_TEXT             0x10
+
+# define BIO_FLAGS_READ          0x01
+# define BIO_FLAGS_WRITE         0x02
+# define BIO_FLAGS_IO_SPECIAL    0x04
+# define BIO_FLAGS_RWS (BIO_FLAGS_READ|BIO_FLAGS_WRITE|BIO_FLAGS_IO_SPECIAL)
+# define BIO_FLAGS_SHOULD_RETRY  0x08
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+/* This #define was replaced by an internal constant and should not be used. */
+#  define BIO_FLAGS_UPLINK       0
+# endif
+
+# define BIO_FLAGS_BASE64_NO_NL  0x100
+
+/*
+ * This is used with memory BIOs:
+ * BIO_FLAGS_MEM_RDONLY means we shouldn't free up or change the data in any way;
+ * BIO_FLAGS_NONCLEAR_RST means we shouldn't clear data on reset.
+ */
+# define BIO_FLAGS_MEM_RDONLY    0x200
+# define BIO_FLAGS_NONCLEAR_RST  0x400
+# define BIO_FLAGS_IN_EOF        0x800
+
+/* the BIO FLAGS values 0x1000 to 0x8000 are reserved for internal KTLS flags */
+
+typedef union bio_addr_st BIO_ADDR;
+typedef struct bio_addrinfo_st BIO_ADDRINFO;
+
+int BIO_get_new_index(void);
+void BIO_set_flags(BIO *b, int flags);
+int BIO_test_flags(const BIO *b, int flags);
+void BIO_clear_flags(BIO *b, int flags);
+
+# define BIO_get_flags(b) BIO_test_flags(b, ~(0x0))
+# define BIO_set_retry_special(b) \
+                BIO_set_flags(b, (BIO_FLAGS_IO_SPECIAL|BIO_FLAGS_SHOULD_RETRY))
+# define BIO_set_retry_read(b) \
+                BIO_set_flags(b, (BIO_FLAGS_READ|BIO_FLAGS_SHOULD_RETRY))
+# define BIO_set_retry_write(b) \
+                BIO_set_flags(b, (BIO_FLAGS_WRITE|BIO_FLAGS_SHOULD_RETRY))
+
+/* These are normally used internally in BIOs */
+# define BIO_clear_retry_flags(b) \
+                BIO_clear_flags(b, (BIO_FLAGS_RWS|BIO_FLAGS_SHOULD_RETRY))
+# define BIO_get_retry_flags(b) \
+                BIO_test_flags(b, (BIO_FLAGS_RWS|BIO_FLAGS_SHOULD_RETRY))
+
+/* These should be used by the application to tell why we should retry */
+# define BIO_should_read(a)              BIO_test_flags(a, BIO_FLAGS_READ)
+# define BIO_should_write(a)             BIO_test_flags(a, BIO_FLAGS_WRITE)
+# define BIO_should_io_special(a)        BIO_test_flags(a, BIO_FLAGS_IO_SPECIAL)
+# define BIO_retry_type(a)               BIO_test_flags(a, BIO_FLAGS_RWS)
+# define BIO_should_retry(a)             BIO_test_flags(a, BIO_FLAGS_SHOULD_RETRY)
+
+/*
+ * The next three are used in conjunction with the BIO_should_io_special()
+ * condition.  After this returns true, BIO *BIO_get_retry_BIO(BIO *bio, int
+ * *reason); will walk the BIO stack and return the 'reason' for the special
+ * and the offending BIO. Given a BIO, BIO_get_retry_reason(bio) will return
+ * the code.
+ */
+/*
+ * Returned from the SSL bio when the certificate retrieval code had an error
+ */
+# define BIO_RR_SSL_X509_LOOKUP          0x01
+/* Returned from the connect BIO when a connect would have blocked */
+# define BIO_RR_CONNECT                  0x02
+/* Returned from the accept BIO when an accept would have blocked */
+# define BIO_RR_ACCEPT                   0x03
+
+/* These are passed by the BIO callback */
+# define BIO_CB_FREE        0x01
+# define BIO_CB_READ        0x02
+# define BIO_CB_WRITE       0x03
+# define BIO_CB_PUTS        0x04
+# define BIO_CB_GETS        0x05
+# define BIO_CB_CTRL        0x06
+# define BIO_CB_RECVMMSG    0x07
+# define BIO_CB_SENDMMSG    0x08
+
+/*
+ * The callback is called before and after the underling operation, The
+ * BIO_CB_RETURN flag indicates if it is after the call
+ */
+# define BIO_CB_RETURN   0x80
+# define BIO_CB_return(a) ((a)|BIO_CB_RETURN)
+# define BIO_cb_pre(a)   (!((a)&BIO_CB_RETURN))
+# define BIO_cb_post(a)  ((a)&BIO_CB_RETURN)
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+typedef long (*BIO_callback_fn)(BIO *b, int oper, const char *argp, int argi,
+                                long argl, long ret);
+OSSL_DEPRECATEDIN_3_0 BIO_callback_fn BIO_get_callback(const BIO *b);
+OSSL_DEPRECATEDIN_3_0 void BIO_set_callback(BIO *b, BIO_callback_fn callback);
+OSSL_DEPRECATEDIN_3_0 long BIO_debug_callback(BIO *bio, int cmd,
+                                               const char *argp, int argi,
+                                               long argl, long ret);
+# endif
+
+typedef long (*BIO_callback_fn_ex)(BIO *b, int oper, const char *argp,
+                                   size_t len, int argi,
+                                   long argl, int ret, size_t *processed);
+BIO_callback_fn_ex BIO_get_callback_ex(const BIO *b);
+void BIO_set_callback_ex(BIO *b, BIO_callback_fn_ex callback);
+long BIO_debug_callback_ex(BIO *bio, int oper, const char *argp, size_t len,
+                           int argi, long argl, int ret, size_t *processed);
+
+char *BIO_get_callback_arg(const BIO *b);
+void BIO_set_callback_arg(BIO *b, char *arg);
+
+typedef struct bio_method_st BIO_METHOD;
+
+const char *BIO_method_name(const BIO *b);
+int BIO_method_type(const BIO *b);
+
+typedef int BIO_info_cb(BIO *, int, int);
+typedef BIO_info_cb bio_info_cb;  /* backward compatibility */
+
+SKM_DEFINE_STACK_OF_INTERNAL(BIO, BIO, BIO)
+#define sk_BIO_num(sk) OPENSSL_sk_num(ossl_check_const_BIO_sk_type(sk))
+#define sk_BIO_value(sk, idx) ((BIO *)OPENSSL_sk_value(ossl_check_const_BIO_sk_type(sk), (idx)))
+#define sk_BIO_new(cmp) ((STACK_OF(BIO) *)OPENSSL_sk_new(ossl_check_BIO_compfunc_type(cmp)))
+#define sk_BIO_new_null() ((STACK_OF(BIO) *)OPENSSL_sk_new_null())
+#define sk_BIO_new_reserve(cmp, n) ((STACK_OF(BIO) *)OPENSSL_sk_new_reserve(ossl_check_BIO_compfunc_type(cmp), (n)))
+#define sk_BIO_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_BIO_sk_type(sk), (n))
+#define sk_BIO_free(sk) OPENSSL_sk_free(ossl_check_BIO_sk_type(sk))
+#define sk_BIO_zero(sk) OPENSSL_sk_zero(ossl_check_BIO_sk_type(sk))
+#define sk_BIO_delete(sk, i) ((BIO *)OPENSSL_sk_delete(ossl_check_BIO_sk_type(sk), (i)))
+#define sk_BIO_delete_ptr(sk, ptr) ((BIO *)OPENSSL_sk_delete_ptr(ossl_check_BIO_sk_type(sk), ossl_check_BIO_type(ptr)))
+#define sk_BIO_push(sk, ptr) OPENSSL_sk_push(ossl_check_BIO_sk_type(sk), ossl_check_BIO_type(ptr))
+#define sk_BIO_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_BIO_sk_type(sk), ossl_check_BIO_type(ptr))
+#define sk_BIO_pop(sk) ((BIO *)OPENSSL_sk_pop(ossl_check_BIO_sk_type(sk)))
+#define sk_BIO_shift(sk) ((BIO *)OPENSSL_sk_shift(ossl_check_BIO_sk_type(sk)))
+#define sk_BIO_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_BIO_sk_type(sk),ossl_check_BIO_freefunc_type(freefunc))
+#define sk_BIO_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_BIO_sk_type(sk), ossl_check_BIO_type(ptr), (idx))
+#define sk_BIO_set(sk, idx, ptr) ((BIO *)OPENSSL_sk_set(ossl_check_BIO_sk_type(sk), (idx), ossl_check_BIO_type(ptr)))
+#define sk_BIO_find(sk, ptr) OPENSSL_sk_find(ossl_check_BIO_sk_type(sk), ossl_check_BIO_type(ptr))
+#define sk_BIO_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_BIO_sk_type(sk), ossl_check_BIO_type(ptr))
+#define sk_BIO_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_BIO_sk_type(sk), ossl_check_BIO_type(ptr), pnum)
+#define sk_BIO_sort(sk) OPENSSL_sk_sort(ossl_check_BIO_sk_type(sk))
+#define sk_BIO_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_BIO_sk_type(sk))
+#define sk_BIO_dup(sk) ((STACK_OF(BIO) *)OPENSSL_sk_dup(ossl_check_const_BIO_sk_type(sk)))
+#define sk_BIO_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(BIO) *)OPENSSL_sk_deep_copy(ossl_check_const_BIO_sk_type(sk), ossl_check_BIO_copyfunc_type(copyfunc), ossl_check_BIO_freefunc_type(freefunc)))
+#define sk_BIO_set_cmp_func(sk, cmp) ((sk_BIO_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_BIO_sk_type(sk), ossl_check_BIO_compfunc_type(cmp)))
+
+
+
+/* Prefix and suffix callback in ASN1 BIO */
+typedef int asn1_ps_func (BIO *b, unsigned char **pbuf, int *plen,
+                          void *parg);
+
+typedef void (*BIO_dgram_sctp_notification_handler_fn) (BIO *b,
+                                                        void *context,
+                                                        void *buf);
+# ifndef OPENSSL_NO_SCTP
+/* SCTP parameter structs */
+struct bio_dgram_sctp_sndinfo {
+    uint16_t snd_sid;
+    uint16_t snd_flags;
+    uint32_t snd_ppid;
+    uint32_t snd_context;
+};
+
+struct bio_dgram_sctp_rcvinfo {
+    uint16_t rcv_sid;
+    uint16_t rcv_ssn;
+    uint16_t rcv_flags;
+    uint32_t rcv_ppid;
+    uint32_t rcv_tsn;
+    uint32_t rcv_cumtsn;
+    uint32_t rcv_context;
+};
+
+struct bio_dgram_sctp_prinfo {
+    uint16_t pr_policy;
+    uint32_t pr_value;
+};
+# endif
+
+/* BIO_sendmmsg/BIO_recvmmsg-related definitions */
+typedef struct bio_msg_st {
+    void *data;
+    size_t data_len;
+    BIO_ADDR *peer, *local;
+    uint64_t flags;
+} BIO_MSG;
+
+typedef struct bio_mmsg_cb_args_st {
+    BIO_MSG    *msg;
+    size_t      stride, num_msg;
+    uint64_t    flags;
+    size_t     *msgs_processed;
+} BIO_MMSG_CB_ARGS;
+
+#define BIO_POLL_DESCRIPTOR_TYPE_NONE       0
+#define BIO_POLL_DESCRIPTOR_TYPE_SOCK_FD    1
+#define BIO_POLL_DESCRIPTOR_TYPE_SSL        2
+#define BIO_POLL_DESCRIPTOR_CUSTOM_START    8192
+
+typedef struct bio_poll_descriptor_st {
+    uint32_t type;
+    union {
+        int         fd;
+        void        *custom;
+        uintptr_t   custom_ui;
+        SSL         *ssl;
+    } value;
+} BIO_POLL_DESCRIPTOR;
+
+/*
+ * #define BIO_CONN_get_param_hostname BIO_ctrl
+ */
+
+# define BIO_C_SET_CONNECT                       100
+# define BIO_C_DO_STATE_MACHINE                  101
+# define BIO_C_SET_NBIO                          102
+/* # define BIO_C_SET_PROXY_PARAM                   103 */
+# define BIO_C_SET_FD                            104
+# define BIO_C_GET_FD                            105
+# define BIO_C_SET_FILE_PTR                      106
+# define BIO_C_GET_FILE_PTR                      107
+# define BIO_C_SET_FILENAME                      108
+# define BIO_C_SET_SSL                           109
+# define BIO_C_GET_SSL                           110
+# define BIO_C_SET_MD                            111
+# define BIO_C_GET_MD                            112
+# define BIO_C_GET_CIPHER_STATUS                 113
+# define BIO_C_SET_BUF_MEM                       114
+# define BIO_C_GET_BUF_MEM_PTR                   115
+# define BIO_C_GET_BUFF_NUM_LINES                116
+# define BIO_C_SET_BUFF_SIZE                     117
+# define BIO_C_SET_ACCEPT                        118
+# define BIO_C_SSL_MODE                          119
+# define BIO_C_GET_MD_CTX                        120
+/* # define BIO_C_GET_PROXY_PARAM                   121 */
+# define BIO_C_SET_BUFF_READ_DATA                122/* data to read first */
+# define BIO_C_GET_CONNECT                       123
+# define BIO_C_GET_ACCEPT                        124
+# define BIO_C_SET_SSL_RENEGOTIATE_BYTES         125
+# define BIO_C_GET_SSL_NUM_RENEGOTIATES          126
+# define BIO_C_SET_SSL_RENEGOTIATE_TIMEOUT       127
+# define BIO_C_FILE_SEEK                         128
+# define BIO_C_GET_CIPHER_CTX                    129
+# define BIO_C_SET_BUF_MEM_EOF_RETURN            130/* return end of input
+                                                     * value */
+# define BIO_C_SET_BIND_MODE                     131
+# define BIO_C_GET_BIND_MODE                     132
+# define BIO_C_FILE_TELL                         133
+# define BIO_C_GET_SOCKS                         134
+# define BIO_C_SET_SOCKS                         135
+
+# define BIO_C_SET_WRITE_BUF_SIZE                136/* for BIO_s_bio */
+# define BIO_C_GET_WRITE_BUF_SIZE                137
+# define BIO_C_MAKE_BIO_PAIR                     138
+# define BIO_C_DESTROY_BIO_PAIR                  139
+# define BIO_C_GET_WRITE_GUARANTEE               140
+# define BIO_C_GET_READ_REQUEST                  141
+# define BIO_C_SHUTDOWN_WR                       142
+# define BIO_C_NREAD0                            143
+# define BIO_C_NREAD                             144
+# define BIO_C_NWRITE0                           145
+# define BIO_C_NWRITE                            146
+# define BIO_C_RESET_READ_REQUEST                147
+# define BIO_C_SET_MD_CTX                        148
+
+# define BIO_C_SET_PREFIX                        149
+# define BIO_C_GET_PREFIX                        150
+# define BIO_C_SET_SUFFIX                        151
+# define BIO_C_GET_SUFFIX                        152
+
+# define BIO_C_SET_EX_ARG                        153
+# define BIO_C_GET_EX_ARG                        154
+
+# define BIO_C_SET_CONNECT_MODE                  155
+
+# define BIO_C_SET_TFO                           156 /* like BIO_C_SET_NBIO */
+
+# define BIO_C_SET_SOCK_TYPE                     157
+# define BIO_C_GET_SOCK_TYPE                     158
+# define BIO_C_GET_DGRAM_BIO                     159
+
+# define BIO_set_app_data(s,arg)         BIO_set_ex_data(s,0,arg)
+# define BIO_get_app_data(s)             BIO_get_ex_data(s,0)
+
+# define BIO_set_nbio(b,n)               BIO_ctrl(b,BIO_C_SET_NBIO,(n),NULL)
+# define BIO_set_tfo(b,n)                BIO_ctrl(b,BIO_C_SET_TFO,(n),NULL)
+
+# ifndef OPENSSL_NO_SOCK
+/* IP families we support, for BIO_s_connect() and BIO_s_accept() */
+/* Note: the underlying operating system may not support some of them */
+#  define BIO_FAMILY_IPV4                         4
+#  define BIO_FAMILY_IPV6                         6
+#  define BIO_FAMILY_IPANY                        256
+
+/* BIO_s_connect() */
+#  define BIO_set_conn_hostname(b,name) BIO_ctrl(b,BIO_C_SET_CONNECT,0, \
+                                                 (char *)(name))
+#  define BIO_set_conn_port(b,port)     BIO_ctrl(b,BIO_C_SET_CONNECT,1, \
+                                                 (char *)(port))
+#  define BIO_set_conn_address(b,addr)  BIO_ctrl(b,BIO_C_SET_CONNECT,2, \
+                                                 (char *)(addr))
+#  define BIO_set_conn_ip_family(b,f)   BIO_int_ctrl(b,BIO_C_SET_CONNECT,3,f)
+#  define BIO_get_conn_hostname(b)      ((const char *)BIO_ptr_ctrl(b,BIO_C_GET_CONNECT,0))
+#  define BIO_get_conn_port(b)          ((const char *)BIO_ptr_ctrl(b,BIO_C_GET_CONNECT,1))
+#  define BIO_get_conn_address(b)       ((const BIO_ADDR *)BIO_ptr_ctrl(b,BIO_C_GET_CONNECT,2))
+#  define BIO_get_conn_ip_family(b)     BIO_ctrl(b,BIO_C_GET_CONNECT,3,NULL)
+#  define BIO_get_conn_mode(b)          BIO_ctrl(b,BIO_C_GET_CONNECT,4,NULL)
+#  define BIO_set_conn_mode(b,n)        BIO_ctrl(b,BIO_C_SET_CONNECT_MODE,(n),NULL)
+#  define BIO_set_sock_type(b,t)        BIO_ctrl(b,BIO_C_SET_SOCK_TYPE,(t),NULL)
+#  define BIO_get_sock_type(b)          BIO_ctrl(b,BIO_C_GET_SOCK_TYPE,0,NULL)
+#  define BIO_get0_dgram_bio(b, p)      BIO_ctrl(b,BIO_C_GET_DGRAM_BIO,0,(void *)(BIO **)(p))
+
+/* BIO_s_accept() */
+#  define BIO_set_accept_name(b,name)   BIO_ctrl(b,BIO_C_SET_ACCEPT,0, \
+                                                 (char *)(name))
+#  define BIO_set_accept_port(b,port)   BIO_ctrl(b,BIO_C_SET_ACCEPT,1, \
+                                                 (char *)(port))
+#  define BIO_get_accept_name(b)        ((const char *)BIO_ptr_ctrl(b,BIO_C_GET_ACCEPT,0))
+#  define BIO_get_accept_port(b)        ((const char *)BIO_ptr_ctrl(b,BIO_C_GET_ACCEPT,1))
+#  define BIO_get_peer_name(b)          ((const char *)BIO_ptr_ctrl(b,BIO_C_GET_ACCEPT,2))
+#  define BIO_get_peer_port(b)          ((const char *)BIO_ptr_ctrl(b,BIO_C_GET_ACCEPT,3))
+/* #define BIO_set_nbio(b,n)    BIO_ctrl(b,BIO_C_SET_NBIO,(n),NULL) */
+#  define BIO_set_nbio_accept(b,n)      BIO_ctrl(b,BIO_C_SET_ACCEPT,2,(n)?(void *)"a":NULL)
+#  define BIO_set_accept_bios(b,bio)    BIO_ctrl(b,BIO_C_SET_ACCEPT,3, \
+                                                 (char *)(bio))
+#  define BIO_set_accept_ip_family(b,f) BIO_int_ctrl(b,BIO_C_SET_ACCEPT,4,f)
+#  define BIO_get_accept_ip_family(b)   BIO_ctrl(b,BIO_C_GET_ACCEPT,4,NULL)
+#  define BIO_set_tfo_accept(b,n)       BIO_ctrl(b,BIO_C_SET_ACCEPT,5,(n)?(void *)"a":NULL)
+
+/* Aliases kept for backward compatibility */
+#  define BIO_BIND_NORMAL                 0
+#  define BIO_BIND_REUSEADDR              BIO_SOCK_REUSEADDR
+#  define BIO_BIND_REUSEADDR_IF_UNUSED    BIO_SOCK_REUSEADDR
+#  define BIO_set_bind_mode(b,mode) BIO_ctrl(b,BIO_C_SET_BIND_MODE,mode,NULL)
+#  define BIO_get_bind_mode(b)    BIO_ctrl(b,BIO_C_GET_BIND_MODE,0,NULL)
+# endif /* OPENSSL_NO_SOCK */
+
+# define BIO_do_connect(b)       BIO_do_handshake(b)
+# define BIO_do_accept(b)        BIO_do_handshake(b)
+
+# define BIO_do_handshake(b)     BIO_ctrl(b,BIO_C_DO_STATE_MACHINE,0,NULL)
+
+/* BIO_s_datagram(), BIO_s_fd(), BIO_s_socket(), BIO_s_accept() and BIO_s_connect() */
+# define BIO_set_fd(b,fd,c)      BIO_int_ctrl(b,BIO_C_SET_FD,c,fd)
+# define BIO_get_fd(b,c)         BIO_ctrl(b,BIO_C_GET_FD,0,(char *)(c))
+
+/* BIO_s_file() */
+# define BIO_set_fp(b,fp,c)      BIO_ctrl(b,BIO_C_SET_FILE_PTR,c,(char *)(fp))
+# define BIO_get_fp(b,fpp)       BIO_ctrl(b,BIO_C_GET_FILE_PTR,0,(char *)(fpp))
+
+/* BIO_s_fd() and BIO_s_file() */
+# define BIO_seek(b,ofs) (int)BIO_ctrl(b,BIO_C_FILE_SEEK,ofs,NULL)
+# define BIO_tell(b)     (int)BIO_ctrl(b,BIO_C_FILE_TELL,0,NULL)
+
+/*
+ * name is cast to lose const, but might be better to route through a
+ * function so we can do it safely
+ */
+# ifdef CONST_STRICT
+/*
+ * If you are wondering why this isn't defined, its because CONST_STRICT is
+ * purely a compile-time kludge to allow const to be checked.
+ */
+int BIO_read_filename(BIO *b, const char *name);
+# else
+#  define BIO_read_filename(b,name) (int)BIO_ctrl(b,BIO_C_SET_FILENAME, \
+                BIO_CLOSE|BIO_FP_READ,(char *)(name))
+# endif
+# define BIO_write_filename(b,name) (int)BIO_ctrl(b,BIO_C_SET_FILENAME, \
+                BIO_CLOSE|BIO_FP_WRITE,name)
+# define BIO_append_filename(b,name) (int)BIO_ctrl(b,BIO_C_SET_FILENAME, \
+                BIO_CLOSE|BIO_FP_APPEND,name)
+# define BIO_rw_filename(b,name) (int)BIO_ctrl(b,BIO_C_SET_FILENAME, \
+                BIO_CLOSE|BIO_FP_READ|BIO_FP_WRITE,name)
+
+/*
+ * WARNING WARNING, this ups the reference count on the read bio of the SSL
+ * structure.  This is because the ssl read BIO is now pointed to by the
+ * next_bio field in the bio.  So when you free the BIO, make sure you are
+ * doing a BIO_free_all() to catch the underlying BIO.
+ */
+# define BIO_set_ssl(b,ssl,c)    BIO_ctrl(b,BIO_C_SET_SSL,c,(char *)(ssl))
+# define BIO_get_ssl(b,sslp)     BIO_ctrl(b,BIO_C_GET_SSL,0,(char *)(sslp))
+# define BIO_set_ssl_mode(b,client)      BIO_ctrl(b,BIO_C_SSL_MODE,client,NULL)
+# define BIO_set_ssl_renegotiate_bytes(b,num) \
+        BIO_ctrl(b,BIO_C_SET_SSL_RENEGOTIATE_BYTES,num,NULL)
+# define BIO_get_num_renegotiates(b) \
+        BIO_ctrl(b,BIO_C_GET_SSL_NUM_RENEGOTIATES,0,NULL)
+# define BIO_set_ssl_renegotiate_timeout(b,seconds) \
+        BIO_ctrl(b,BIO_C_SET_SSL_RENEGOTIATE_TIMEOUT,seconds,NULL)
+
+/* defined in evp.h */
+/* #define BIO_set_md(b,md)     BIO_ctrl(b,BIO_C_SET_MD,1,(char *)(md)) */
+
+# define BIO_get_mem_data(b,pp)  BIO_ctrl(b,BIO_CTRL_INFO,0,(char *)(pp))
+# define BIO_set_mem_buf(b,bm,c) BIO_ctrl(b,BIO_C_SET_BUF_MEM,c,(char *)(bm))
+# define BIO_get_mem_ptr(b,pp)   BIO_ctrl(b,BIO_C_GET_BUF_MEM_PTR,0, \
+                                          (char *)(pp))
+# define BIO_set_mem_eof_return(b,v) \
+                                BIO_ctrl(b,BIO_C_SET_BUF_MEM_EOF_RETURN,v,NULL)
+
+/* For the BIO_f_buffer() type */
+# define BIO_get_buffer_num_lines(b)     BIO_ctrl(b,BIO_C_GET_BUFF_NUM_LINES,0,NULL)
+# define BIO_set_buffer_size(b,size)     BIO_ctrl(b,BIO_C_SET_BUFF_SIZE,size,NULL)
+# define BIO_set_read_buffer_size(b,size) BIO_int_ctrl(b,BIO_C_SET_BUFF_SIZE,size,0)
+# define BIO_set_write_buffer_size(b,size) BIO_int_ctrl(b,BIO_C_SET_BUFF_SIZE,size,1)
+# define BIO_set_buffer_read_data(b,buf,num) BIO_ctrl(b,BIO_C_SET_BUFF_READ_DATA,num,buf)
+
+/* Don't use the next one unless you know what you are doing :-) */
+# define BIO_dup_state(b,ret)    BIO_ctrl(b,BIO_CTRL_DUP,0,(char *)(ret))
+
+# define BIO_reset(b)            (int)BIO_ctrl(b,BIO_CTRL_RESET,0,NULL)
+# define BIO_eof(b)              (int)BIO_ctrl(b,BIO_CTRL_EOF,0,NULL)
+# define BIO_set_close(b,c)      (int)BIO_ctrl(b,BIO_CTRL_SET_CLOSE,(c),NULL)
+# define BIO_get_close(b)        (int)BIO_ctrl(b,BIO_CTRL_GET_CLOSE,0,NULL)
+# define BIO_pending(b)          (int)BIO_ctrl(b,BIO_CTRL_PENDING,0,NULL)
+# define BIO_wpending(b)         (int)BIO_ctrl(b,BIO_CTRL_WPENDING,0,NULL)
+/* ...pending macros have inappropriate return type */
+size_t BIO_ctrl_pending(BIO *b);
+size_t BIO_ctrl_wpending(BIO *b);
+# define BIO_flush(b)            (int)BIO_ctrl(b,BIO_CTRL_FLUSH,0,NULL)
+# define BIO_get_info_callback(b,cbp) (int)BIO_ctrl(b,BIO_CTRL_GET_CALLBACK,0, \
+                                                   cbp)
+# define BIO_set_info_callback(b,cb) (int)BIO_callback_ctrl(b,BIO_CTRL_SET_CALLBACK,cb)
+
+/* For the BIO_f_buffer() type */
+# define BIO_buffer_get_num_lines(b) BIO_ctrl(b,BIO_CTRL_GET,0,NULL)
+# define BIO_buffer_peek(b,s,l) BIO_ctrl(b,BIO_CTRL_PEEK,(l),(s))
+
+/* For BIO_s_bio() */
+# define BIO_set_write_buf_size(b,size) (int)BIO_ctrl(b,BIO_C_SET_WRITE_BUF_SIZE,size,NULL)
+# define BIO_get_write_buf_size(b,size) (size_t)BIO_ctrl(b,BIO_C_GET_WRITE_BUF_SIZE,size,NULL)
+# define BIO_make_bio_pair(b1,b2)   (int)BIO_ctrl(b1,BIO_C_MAKE_BIO_PAIR,0,b2)
+# define BIO_destroy_bio_pair(b)    (int)BIO_ctrl(b,BIO_C_DESTROY_BIO_PAIR,0,NULL)
+# define BIO_shutdown_wr(b) (int)BIO_ctrl(b, BIO_C_SHUTDOWN_WR, 0, NULL)
+/* macros with inappropriate type -- but ...pending macros use int too: */
+# define BIO_get_write_guarantee(b) (int)BIO_ctrl(b,BIO_C_GET_WRITE_GUARANTEE,0,NULL)
+# define BIO_get_read_request(b)    (int)BIO_ctrl(b,BIO_C_GET_READ_REQUEST,0,NULL)
+size_t BIO_ctrl_get_write_guarantee(BIO *b);
+size_t BIO_ctrl_get_read_request(BIO *b);
+int BIO_ctrl_reset_read_request(BIO *b);
+
+/* ctrl macros for dgram */
+# define BIO_ctrl_dgram_connect(b,peer)  \
+                     (int)BIO_ctrl(b,BIO_CTRL_DGRAM_CONNECT,0, (char *)(peer))
+# define BIO_ctrl_set_connected(b,peer) \
+         (int)BIO_ctrl(b, BIO_CTRL_DGRAM_SET_CONNECTED, 0, (char *)(peer))
+# define BIO_dgram_recv_timedout(b) \
+         (int)BIO_ctrl(b, BIO_CTRL_DGRAM_GET_RECV_TIMER_EXP, 0, NULL)
+# define BIO_dgram_send_timedout(b) \
+         (int)BIO_ctrl(b, BIO_CTRL_DGRAM_GET_SEND_TIMER_EXP, 0, NULL)
+# define BIO_dgram_get_peer(b,peer) \
+         (int)BIO_ctrl(b, BIO_CTRL_DGRAM_GET_PEER, 0, (char *)(peer))
+# define BIO_dgram_set_peer(b,peer) \
+         (int)BIO_ctrl(b, BIO_CTRL_DGRAM_SET_PEER, 0, (char *)(peer))
+# define BIO_dgram_detect_peer_addr(b,peer) \
+         (int)BIO_ctrl(b, BIO_CTRL_DGRAM_DETECT_PEER_ADDR, 0, (char *)(peer))
+# define BIO_dgram_get_mtu_overhead(b) \
+         (unsigned int)BIO_ctrl((b), BIO_CTRL_DGRAM_GET_MTU_OVERHEAD, 0, NULL)
+# define BIO_dgram_get_local_addr_cap(b) \
+         (int)BIO_ctrl((b), BIO_CTRL_DGRAM_GET_LOCAL_ADDR_CAP, 0, NULL)
+# define BIO_dgram_get_local_addr_enable(b, penable) \
+         (int)BIO_ctrl((b), BIO_CTRL_DGRAM_GET_LOCAL_ADDR_ENABLE, 0, (char *)(penable))
+# define BIO_dgram_set_local_addr_enable(b, enable) \
+         (int)BIO_ctrl((b), BIO_CTRL_DGRAM_SET_LOCAL_ADDR_ENABLE, (enable), NULL)
+# define BIO_dgram_get_effective_caps(b) \
+         (uint32_t)BIO_ctrl((b), BIO_CTRL_DGRAM_GET_EFFECTIVE_CAPS, 0, NULL)
+# define BIO_dgram_get_caps(b) \
+         (uint32_t)BIO_ctrl((b), BIO_CTRL_DGRAM_GET_CAPS, 0, NULL)
+# define BIO_dgram_set_caps(b, caps) \
+         (int)BIO_ctrl((b), BIO_CTRL_DGRAM_SET_CAPS, (long)(caps), NULL)
+# define BIO_dgram_get_no_trunc(b) \
+         (unsigned int)BIO_ctrl((b), BIO_CTRL_DGRAM_GET_NO_TRUNC, 0, NULL)
+# define BIO_dgram_set_no_trunc(b, enable) \
+         (int)BIO_ctrl((b), BIO_CTRL_DGRAM_SET_NO_TRUNC, (enable), NULL)
+# define BIO_dgram_get_mtu(b) \
+         (unsigned int)BIO_ctrl((b), BIO_CTRL_DGRAM_GET_MTU, 0, NULL)
+# define BIO_dgram_set_mtu(b, mtu) \
+         (int)BIO_ctrl((b), BIO_CTRL_DGRAM_SET_MTU, (mtu), NULL)
+
+/* ctrl macros for BIO_f_prefix */
+# define BIO_set_prefix(b,p) BIO_ctrl((b), BIO_CTRL_SET_PREFIX, 0, (void *)(p))
+# define BIO_set_indent(b,i) BIO_ctrl((b), BIO_CTRL_SET_INDENT, (i), NULL)
+# define BIO_get_indent(b) BIO_ctrl((b), BIO_CTRL_GET_INDENT, 0, NULL)
+
+#define BIO_get_ex_new_index(l, p, newf, dupf, freef) \
+    CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_BIO, l, p, newf, dupf, freef)
+int BIO_set_ex_data(BIO *bio, int idx, void *data);
+void *BIO_get_ex_data(const BIO *bio, int idx);
+uint64_t BIO_number_read(BIO *bio);
+uint64_t BIO_number_written(BIO *bio);
+
+/* For BIO_f_asn1() */
+int BIO_asn1_set_prefix(BIO *b, asn1_ps_func *prefix,
+                        asn1_ps_func *prefix_free);
+int BIO_asn1_get_prefix(BIO *b, asn1_ps_func **pprefix,
+                        asn1_ps_func **pprefix_free);
+int BIO_asn1_set_suffix(BIO *b, asn1_ps_func *suffix,
+                        asn1_ps_func *suffix_free);
+int BIO_asn1_get_suffix(BIO *b, asn1_ps_func **psuffix,
+                        asn1_ps_func **psuffix_free);
+
+const BIO_METHOD *BIO_s_file(void);
+BIO *BIO_new_file(const char *filename, const char *mode);
+BIO *BIO_new_from_core_bio(OSSL_LIB_CTX *libctx, OSSL_CORE_BIO *corebio);
+# ifndef OPENSSL_NO_STDIO
+BIO *BIO_new_fp(FILE *stream, int close_flag);
+# endif
+BIO *BIO_new_ex(OSSL_LIB_CTX *libctx, const BIO_METHOD *method);
+BIO *BIO_new(const BIO_METHOD *type);
+int BIO_free(BIO *a);
+void BIO_set_data(BIO *a, void *ptr);
+void *BIO_get_data(BIO *a);
+void BIO_set_init(BIO *a, int init);
+int BIO_get_init(BIO *a);
+void BIO_set_shutdown(BIO *a, int shut);
+int BIO_get_shutdown(BIO *a);
+void BIO_vfree(BIO *a);
+int BIO_up_ref(BIO *a);
+int BIO_read(BIO *b, void *data, int dlen);
+int BIO_read_ex(BIO *b, void *data, size_t dlen, size_t *readbytes);
+__owur int BIO_recvmmsg(BIO *b, BIO_MSG *msg,
+                        size_t stride, size_t num_msg, uint64_t flags,
+                        size_t *msgs_processed);
+int BIO_gets(BIO *bp, char *buf, int size);
+int BIO_get_line(BIO *bio, char *buf, int size);
+int BIO_write(BIO *b, const void *data, int dlen);
+int BIO_write_ex(BIO *b, const void *data, size_t dlen, size_t *written);
+__owur int BIO_sendmmsg(BIO *b, BIO_MSG *msg,
+                        size_t stride, size_t num_msg, uint64_t flags,
+                        size_t *msgs_processed);
+__owur int BIO_get_rpoll_descriptor(BIO *b, BIO_POLL_DESCRIPTOR *desc);
+__owur int BIO_get_wpoll_descriptor(BIO *b, BIO_POLL_DESCRIPTOR *desc);
+int BIO_puts(BIO *bp, const char *buf);
+int BIO_indent(BIO *b, int indent, int max);
+long BIO_ctrl(BIO *bp, int cmd, long larg, void *parg);
+long BIO_callback_ctrl(BIO *b, int cmd, BIO_info_cb *fp);
+void *BIO_ptr_ctrl(BIO *bp, int cmd, long larg);
+long BIO_int_ctrl(BIO *bp, int cmd, long larg, int iarg);
+BIO *BIO_push(BIO *b, BIO *append);
+BIO *BIO_pop(BIO *b);
+void BIO_free_all(BIO *a);
+BIO *BIO_find_type(BIO *b, int bio_type);
+BIO *BIO_next(BIO *b);
+void BIO_set_next(BIO *b, BIO *next);
+BIO *BIO_get_retry_BIO(BIO *bio, int *reason);
+int BIO_get_retry_reason(BIO *bio);
+void BIO_set_retry_reason(BIO *bio, int reason);
+BIO *BIO_dup_chain(BIO *in);
+
+int BIO_nread0(BIO *bio, char **buf);
+int BIO_nread(BIO *bio, char **buf, int num);
+int BIO_nwrite0(BIO *bio, char **buf);
+int BIO_nwrite(BIO *bio, char **buf, int num);
+
+const BIO_METHOD *BIO_s_mem(void);
+# ifndef OPENSSL_NO_DGRAM
+const BIO_METHOD *BIO_s_dgram_mem(void);
+# endif
+const BIO_METHOD *BIO_s_secmem(void);
+BIO *BIO_new_mem_buf(const void *buf, int len);
+# ifndef OPENSSL_NO_SOCK
+const BIO_METHOD *BIO_s_socket(void);
+const BIO_METHOD *BIO_s_connect(void);
+const BIO_METHOD *BIO_s_accept(void);
+# endif
+const BIO_METHOD *BIO_s_fd(void);
+const BIO_METHOD *BIO_s_log(void);
+const BIO_METHOD *BIO_s_bio(void);
+const BIO_METHOD *BIO_s_null(void);
+const BIO_METHOD *BIO_f_null(void);
+const BIO_METHOD *BIO_f_buffer(void);
+const BIO_METHOD *BIO_f_readbuffer(void);
+const BIO_METHOD *BIO_f_linebuffer(void);
+const BIO_METHOD *BIO_f_nbio_test(void);
+const BIO_METHOD *BIO_f_prefix(void);
+const BIO_METHOD *BIO_s_core(void);
+# ifndef OPENSSL_NO_DGRAM
+const BIO_METHOD *BIO_s_dgram_pair(void);
+const BIO_METHOD *BIO_s_datagram(void);
+int BIO_dgram_non_fatal_error(int error);
+BIO *BIO_new_dgram(int fd, int close_flag);
+#  ifndef OPENSSL_NO_SCTP
+const BIO_METHOD *BIO_s_datagram_sctp(void);
+BIO *BIO_new_dgram_sctp(int fd, int close_flag);
+int BIO_dgram_is_sctp(BIO *bio);
+int BIO_dgram_sctp_notification_cb(BIO *b,
+                BIO_dgram_sctp_notification_handler_fn handle_notifications,
+                void *context);
+int BIO_dgram_sctp_wait_for_dry(BIO *b);
+int BIO_dgram_sctp_msg_waiting(BIO *b);
+#  endif
+# endif
+
+# ifndef OPENSSL_NO_SOCK
+int BIO_sock_should_retry(int i);
+int BIO_sock_non_fatal_error(int error);
+int BIO_err_is_non_fatal(unsigned int errcode);
+int BIO_socket_wait(int fd, int for_read, time_t max_time);
+# endif
+int BIO_wait(BIO *bio, time_t max_time, unsigned int nap_milliseconds);
+int BIO_do_connect_retry(BIO *bio, int timeout, int nap_milliseconds);
+
+int BIO_fd_should_retry(int i);
+int BIO_fd_non_fatal_error(int error);
+int BIO_dump_cb(int (*cb) (const void *data, size_t len, void *u),
+                void *u, const void *s, int len);
+int BIO_dump_indent_cb(int (*cb) (const void *data, size_t len, void *u),
+                       void *u, const void *s, int len, int indent);
+int BIO_dump(BIO *b, const void *bytes, int len);
+int BIO_dump_indent(BIO *b, const void *bytes, int len, int indent);
+# ifndef OPENSSL_NO_STDIO
+int BIO_dump_fp(FILE *fp, const void *s, int len);
+int BIO_dump_indent_fp(FILE *fp, const void *s, int len, int indent);
+# endif
+int BIO_hex_string(BIO *out, int indent, int width, const void *data,
+                   int datalen);
+
+# ifndef OPENSSL_NO_SOCK
+BIO_ADDR *BIO_ADDR_new(void);
+int BIO_ADDR_copy(BIO_ADDR *dst, const BIO_ADDR *src);
+BIO_ADDR *BIO_ADDR_dup(const BIO_ADDR *ap);
+int BIO_ADDR_rawmake(BIO_ADDR *ap, int family,
+                     const void *where, size_t wherelen, unsigned short port);
+void BIO_ADDR_free(BIO_ADDR *);
+void BIO_ADDR_clear(BIO_ADDR *ap);
+int BIO_ADDR_family(const BIO_ADDR *ap);
+int BIO_ADDR_rawaddress(const BIO_ADDR *ap, void *p, size_t *l);
+unsigned short BIO_ADDR_rawport(const BIO_ADDR *ap);
+char *BIO_ADDR_hostname_string(const BIO_ADDR *ap, int numeric);
+char *BIO_ADDR_service_string(const BIO_ADDR *ap, int numeric);
+char *BIO_ADDR_path_string(const BIO_ADDR *ap);
+
+const BIO_ADDRINFO *BIO_ADDRINFO_next(const BIO_ADDRINFO *bai);
+int BIO_ADDRINFO_family(const BIO_ADDRINFO *bai);
+int BIO_ADDRINFO_socktype(const BIO_ADDRINFO *bai);
+int BIO_ADDRINFO_protocol(const BIO_ADDRINFO *bai);
+const BIO_ADDR *BIO_ADDRINFO_address(const BIO_ADDRINFO *bai);
+void BIO_ADDRINFO_free(BIO_ADDRINFO *bai);
+
+enum BIO_hostserv_priorities {
+    BIO_PARSE_PRIO_HOST, BIO_PARSE_PRIO_SERV
+};
+int BIO_parse_hostserv(const char *hostserv, char **host, char **service,
+                       enum BIO_hostserv_priorities hostserv_prio);
+enum BIO_lookup_type {
+    BIO_LOOKUP_CLIENT, BIO_LOOKUP_SERVER
+};
+int BIO_lookup(const char *host, const char *service,
+               enum BIO_lookup_type lookup_type,
+               int family, int socktype, BIO_ADDRINFO **res);
+int BIO_lookup_ex(const char *host, const char *service,
+                  int lookup_type, int family, int socktype, int protocol,
+                  BIO_ADDRINFO **res);
+int BIO_sock_error(int sock);
+int BIO_socket_ioctl(int fd, long type, void *arg);
+int BIO_socket_nbio(int fd, int mode);
+int BIO_sock_init(void);
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#  define BIO_sock_cleanup() while(0) continue
+# endif
+int BIO_set_tcp_ndelay(int sock, int turn_on);
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+OSSL_DEPRECATEDIN_1_1_0 struct hostent *BIO_gethostbyname(const char *name);
+OSSL_DEPRECATEDIN_1_1_0 int BIO_get_port(const char *str, unsigned short *port_ptr);
+OSSL_DEPRECATEDIN_1_1_0 int BIO_get_host_ip(const char *str, unsigned char *ip);
+OSSL_DEPRECATEDIN_1_1_0 int BIO_get_accept_socket(char *host_port, int mode);
+OSSL_DEPRECATEDIN_1_1_0 int BIO_accept(int sock, char **ip_port);
+# endif
+
+union BIO_sock_info_u {
+    BIO_ADDR *addr;
+};
+enum BIO_sock_info_type {
+    BIO_SOCK_INFO_ADDRESS
+};
+int BIO_sock_info(int sock,
+                  enum BIO_sock_info_type type, union BIO_sock_info_u *info);
+
+#  define BIO_SOCK_REUSEADDR    0x01
+#  define BIO_SOCK_V6_ONLY      0x02
+#  define BIO_SOCK_KEEPALIVE    0x04
+#  define BIO_SOCK_NONBLOCK     0x08
+#  define BIO_SOCK_NODELAY      0x10
+#  define BIO_SOCK_TFO          0x20
+
+int BIO_socket(int domain, int socktype, int protocol, int options);
+int BIO_connect(int sock, const BIO_ADDR *addr, int options);
+int BIO_bind(int sock, const BIO_ADDR *addr, int options);
+int BIO_listen(int sock, const BIO_ADDR *addr, int options);
+int BIO_accept_ex(int accept_sock, BIO_ADDR *addr, int options);
+int BIO_closesocket(int sock);
+
+BIO *BIO_new_socket(int sock, int close_flag);
+BIO *BIO_new_connect(const char *host_port);
+BIO *BIO_new_accept(const char *host_port);
+# endif /* OPENSSL_NO_SOCK*/
+
+BIO *BIO_new_fd(int fd, int close_flag);
+
+int BIO_new_bio_pair(BIO **bio1, size_t writebuf1,
+                     BIO **bio2, size_t writebuf2);
+# ifndef OPENSSL_NO_DGRAM
+int BIO_new_bio_dgram_pair(BIO **bio1, size_t writebuf1,
+                           BIO **bio2, size_t writebuf2);
+# endif
+
+/*
+ * If successful, returns 1 and in *bio1, *bio2 two BIO pair endpoints.
+ * Otherwise returns 0 and sets *bio1 and *bio2 to NULL. Size 0 uses default
+ * value.
+ */
+
+void BIO_copy_next_retry(BIO *b);
+
+/*
+ * long BIO_ghbn_ctrl(int cmd,int iarg,char *parg);
+ */
+
+# define ossl_bio__attr__(x)
+# if defined(__GNUC__) && defined(__STDC_VERSION__) \
+    && !defined(__MINGW32__) && !defined(__MINGW64__) \
+    && !defined(__APPLE__)
+    /*
+     * Because we support the 'z' modifier, which made its appearance in C99,
+     * we can't use __attribute__ with pre C99 dialects.
+     */
+#  if __STDC_VERSION__ >= 199901L
+#   undef ossl_bio__attr__
+#   define ossl_bio__attr__ __attribute__
+#   if __GNUC__*10 + __GNUC_MINOR__ >= 44
+#    define ossl_bio__printf__ __gnu_printf__
+#   else
+#    define ossl_bio__printf__ __printf__
+#   endif
+#  endif
+# endif
+int BIO_printf(BIO *bio, const char *format, ...)
+ossl_bio__attr__((__format__(ossl_bio__printf__, 2, 3)));
+int BIO_vprintf(BIO *bio, const char *format, va_list args)
+ossl_bio__attr__((__format__(ossl_bio__printf__, 2, 0)));
+int BIO_snprintf(char *buf, size_t n, const char *format, ...)
+ossl_bio__attr__((__format__(ossl_bio__printf__, 3, 4)));
+int BIO_vsnprintf(char *buf, size_t n, const char *format, va_list args)
+ossl_bio__attr__((__format__(ossl_bio__printf__, 3, 0)));
+# undef ossl_bio__attr__
+# undef ossl_bio__printf__
+
+
+BIO_METHOD *BIO_meth_new(int type, const char *name);
+void BIO_meth_free(BIO_METHOD *biom);
+int (*BIO_meth_get_write(const BIO_METHOD *biom)) (BIO *, const char *, int);
+int (*BIO_meth_get_write_ex(const BIO_METHOD *biom)) (BIO *, const char *, size_t,
+                                                size_t *);
+int BIO_meth_set_write(BIO_METHOD *biom,
+                       int (*write) (BIO *, const char *, int));
+int BIO_meth_set_write_ex(BIO_METHOD *biom,
+                       int (*bwrite) (BIO *, const char *, size_t, size_t *));
+int BIO_meth_set_sendmmsg(BIO_METHOD *biom,
+                          int (*f) (BIO *, BIO_MSG *, size_t, size_t,
+                                    uint64_t, size_t *));
+int (*BIO_meth_get_sendmmsg(const BIO_METHOD *biom))(BIO *, BIO_MSG *,
+                                                     size_t, size_t,
+                                                     uint64_t, size_t *);
+int (*BIO_meth_get_read(const BIO_METHOD *biom)) (BIO *, char *, int);
+int (*BIO_meth_get_read_ex(const BIO_METHOD *biom)) (BIO *, char *, size_t, size_t *);
+int BIO_meth_set_read(BIO_METHOD *biom,
+                      int (*read) (BIO *, char *, int));
+int BIO_meth_set_read_ex(BIO_METHOD *biom,
+                         int (*bread) (BIO *, char *, size_t, size_t *));
+int BIO_meth_set_recvmmsg(BIO_METHOD *biom,
+                          int (*f) (BIO *, BIO_MSG *, size_t, size_t,
+                                    uint64_t, size_t *));
+int (*BIO_meth_get_recvmmsg(const BIO_METHOD *biom))(BIO *, BIO_MSG *,
+                                                     size_t, size_t,
+                                                     uint64_t, size_t *);
+int (*BIO_meth_get_puts(const BIO_METHOD *biom)) (BIO *, const char *);
+int BIO_meth_set_puts(BIO_METHOD *biom,
+                      int (*puts) (BIO *, const char *));
+int (*BIO_meth_get_gets(const BIO_METHOD *biom)) (BIO *, char *, int);
+int BIO_meth_set_gets(BIO_METHOD *biom,
+                      int (*ossl_gets) (BIO *, char *, int));
+long (*BIO_meth_get_ctrl(const BIO_METHOD *biom)) (BIO *, int, long, void *);
+int BIO_meth_set_ctrl(BIO_METHOD *biom,
+                      long (*ctrl) (BIO *, int, long, void *));
+int (*BIO_meth_get_create(const BIO_METHOD *bion)) (BIO *);
+int BIO_meth_set_create(BIO_METHOD *biom, int (*create) (BIO *));
+int (*BIO_meth_get_destroy(const BIO_METHOD *biom)) (BIO *);
+int BIO_meth_set_destroy(BIO_METHOD *biom, int (*destroy) (BIO *));
+long (*BIO_meth_get_callback_ctrl(const BIO_METHOD *biom))
+                                 (BIO *, int, BIO_info_cb *);
+int BIO_meth_set_callback_ctrl(BIO_METHOD *biom,
+                               long (*callback_ctrl) (BIO *, int,
+                                                      BIO_info_cb *));
+
+# ifdef  __cplusplus
+}
+# endif
+#endif
diff --git a/src/include/openssl/bioerr.h b/src/include/openssl/bioerr.h
new file mode 100644
index 0000000..e4fdb64
--- /dev/null
+++ b/src/include/openssl/bioerr.h
@@ -0,0 +1,72 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2022 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_BIOERR_H
+# define OPENSSL_BIOERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+
+/*
+ * BIO reason codes.
+ */
+# define BIO_R_ACCEPT_ERROR                               100
+# define BIO_R_ADDRINFO_ADDR_IS_NOT_AF_INET               141
+# define BIO_R_AMBIGUOUS_HOST_OR_SERVICE                  129
+# define BIO_R_BAD_FOPEN_MODE                             101
+# define BIO_R_BROKEN_PIPE                                124
+# define BIO_R_CONNECT_ERROR                              103
+# define BIO_R_CONNECT_TIMEOUT                            147
+# define BIO_R_GETHOSTBYNAME_ADDR_IS_NOT_AF_INET          107
+# define BIO_R_GETSOCKNAME_ERROR                          132
+# define BIO_R_GETSOCKNAME_TRUNCATED_ADDRESS              133
+# define BIO_R_GETTING_SOCKTYPE                           134
+# define BIO_R_INVALID_ARGUMENT                           125
+# define BIO_R_INVALID_SOCKET                             135
+# define BIO_R_IN_USE                                     123
+# define BIO_R_LENGTH_TOO_LONG                            102
+# define BIO_R_LISTEN_V6_ONLY                             136
+# define BIO_R_LOCAL_ADDR_NOT_AVAILABLE                   111
+# define BIO_R_LOOKUP_RETURNED_NOTHING                    142
+# define BIO_R_MALFORMED_HOST_OR_SERVICE                  130
+# define BIO_R_NBIO_CONNECT_ERROR                         110
+# define BIO_R_NON_FATAL                                  112
+# define BIO_R_NO_ACCEPT_ADDR_OR_SERVICE_SPECIFIED        143
+# define BIO_R_NO_HOSTNAME_OR_SERVICE_SPECIFIED           144
+# define BIO_R_NO_PORT_DEFINED                            113
+# define BIO_R_NO_SUCH_FILE                               128
+# define BIO_R_NULL_PARAMETER                             115 /* unused */
+# define BIO_R_TFO_DISABLED                               106
+# define BIO_R_TFO_NO_KERNEL_SUPPORT                      108
+# define BIO_R_TRANSFER_ERROR                             104
+# define BIO_R_TRANSFER_TIMEOUT                           105
+# define BIO_R_UNABLE_TO_BIND_SOCKET                      117
+# define BIO_R_UNABLE_TO_CREATE_SOCKET                    118
+# define BIO_R_UNABLE_TO_KEEPALIVE                        137
+# define BIO_R_UNABLE_TO_LISTEN_SOCKET                    119
+# define BIO_R_UNABLE_TO_NODELAY                          138
+# define BIO_R_UNABLE_TO_REUSEADDR                        139
+# define BIO_R_UNABLE_TO_TFO                              109
+# define BIO_R_UNAVAILABLE_IP_FAMILY                      145
+# define BIO_R_UNINITIALIZED                              120
+# define BIO_R_UNKNOWN_INFO_TYPE                          140
+# define BIO_R_UNSUPPORTED_IP_FAMILY                      146
+# define BIO_R_UNSUPPORTED_METHOD                         121
+# define BIO_R_UNSUPPORTED_PROTOCOL_FAMILY                131
+# define BIO_R_WRITE_TO_READ_ONLY_BIO                     126
+# define BIO_R_WSASTARTUP                                 122
+# define BIO_R_PORT_MISMATCH                              150
+# define BIO_R_PEER_ADDR_NOT_AVAILABLE                    151
+
+#endif
diff --git a/src/include/openssl/blowfish.h b/src/include/openssl/blowfish.h
new file mode 100644
index 0000000..667d642
--- /dev/null
+++ b/src/include/openssl/blowfish.h
@@ -0,0 +1,78 @@
+/*
+ * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_BLOWFISH_H
+# define OPENSSL_BLOWFISH_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_BLOWFISH_H
+# endif
+
+# include <openssl/opensslconf.h>
+
+# ifndef OPENSSL_NO_BF
+# include <openssl/e_os2.h>
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+# define BF_BLOCK        8
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+
+#  define BF_ENCRYPT      1
+#  define BF_DECRYPT      0
+
+/*-
+ * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+ * ! BF_LONG has to be at least 32 bits wide.                     !
+ * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+ */
+#  define BF_LONG unsigned int
+
+#  define BF_ROUNDS       16
+
+typedef struct bf_key_st {
+    BF_LONG P[BF_ROUNDS + 2];
+    BF_LONG S[4 * 256];
+} BF_KEY;
+
+# endif /* OPENSSL_NO_DEPRECATED_3_0 */
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 void BF_set_key(BF_KEY *key, int len,
+                                      const unsigned char *data);
+OSSL_DEPRECATEDIN_3_0 void BF_encrypt(BF_LONG *data, const BF_KEY *key);
+OSSL_DEPRECATEDIN_3_0 void BF_decrypt(BF_LONG *data, const BF_KEY *key);
+OSSL_DEPRECATEDIN_3_0 void BF_ecb_encrypt(const unsigned char *in,
+                                          unsigned char *out, const BF_KEY *key,
+                                          int enc);
+OSSL_DEPRECATEDIN_3_0 void BF_cbc_encrypt(const unsigned char *in,
+                                          unsigned char *out, long length,
+                                          const BF_KEY *schedule,
+                                          unsigned char *ivec, int enc);
+OSSL_DEPRECATEDIN_3_0 void BF_cfb64_encrypt(const unsigned char *in,
+                                            unsigned char *out,
+                                            long length, const BF_KEY *schedule,
+                                            unsigned char *ivec, int *num,
+                                            int enc);
+OSSL_DEPRECATEDIN_3_0 void BF_ofb64_encrypt(const unsigned char *in,
+                                            unsigned char *out,
+                                            long length, const BF_KEY *schedule,
+                                            unsigned char *ivec, int *num);
+OSSL_DEPRECATEDIN_3_0 const char *BF_options(void);
+# endif
+
+# ifdef  __cplusplus
+}
+# endif
+# endif
+
+#endif
diff --git a/src/include/openssl/bn.h b/src/include/openssl/bn.h
new file mode 100644
index 0000000..ea706dc
--- /dev/null
+++ b/src/include/openssl/bn.h
@@ -0,0 +1,590 @@
+/*
+ * Copyright 1995-2022 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_BN_H
+# define OPENSSL_BN_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_BN_H
+# endif
+
+# include <openssl/e_os2.h>
+# ifndef OPENSSL_NO_STDIO
+#  include <stdio.h>
+# endif
+# include <openssl/opensslconf.h>
+# include <openssl/types.h>
+# include <openssl/crypto.h>
+# include <openssl/bnerr.h>
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+/*
+ * 64-bit processor with LP64 ABI
+ */
+# ifdef SIXTY_FOUR_BIT_LONG
+#  define BN_ULONG        unsigned long
+#  define BN_BYTES        8
+# endif
+
+/*
+ * 64-bit processor other than LP64 ABI
+ */
+# ifdef SIXTY_FOUR_BIT
+#  define BN_ULONG        unsigned long long
+#  define BN_BYTES        8
+# endif
+
+# ifdef THIRTY_TWO_BIT
+#  define BN_ULONG        unsigned int
+#  define BN_BYTES        4
+# endif
+
+# define BN_BITS2       (BN_BYTES * 8)
+# define BN_BITS        (BN_BITS2 * 2)
+# define BN_TBIT        ((BN_ULONG)1 << (BN_BITS2 - 1))
+
+# define BN_FLG_MALLOCED         0x01
+# define BN_FLG_STATIC_DATA      0x02
+
+/*
+ * avoid leaking exponent information through timing,
+ * BN_mod_exp_mont() will call BN_mod_exp_mont_consttime,
+ * BN_div() will call BN_div_no_branch,
+ * BN_mod_inverse() will call bn_mod_inverse_no_branch.
+ */
+# define BN_FLG_CONSTTIME        0x04
+# define BN_FLG_SECURE           0x08
+
+# ifndef OPENSSL_NO_DEPRECATED_0_9_8
+/* deprecated name for the flag */
+#  define BN_FLG_EXP_CONSTTIME BN_FLG_CONSTTIME
+#  define BN_FLG_FREE            0x8000 /* used for debugging */
+# endif
+
+void BN_set_flags(BIGNUM *b, int n);
+int BN_get_flags(const BIGNUM *b, int n);
+
+/* Values for |top| in BN_rand() */
+#define BN_RAND_TOP_ANY    -1
+#define BN_RAND_TOP_ONE     0
+#define BN_RAND_TOP_TWO     1
+
+/* Values for |bottom| in BN_rand() */
+#define BN_RAND_BOTTOM_ANY  0
+#define BN_RAND_BOTTOM_ODD  1
+
+/*
+ * get a clone of a BIGNUM with changed flags, for *temporary* use only (the
+ * two BIGNUMs cannot be used in parallel!). Also only for *read only* use. The
+ * value |dest| should be a newly allocated BIGNUM obtained via BN_new() that
+ * has not been otherwise initialised or used.
+ */
+void BN_with_flags(BIGNUM *dest, const BIGNUM *b, int flags);
+
+/* Wrapper function to make using BN_GENCB easier */
+int BN_GENCB_call(BN_GENCB *cb, int a, int b);
+
+BN_GENCB *BN_GENCB_new(void);
+void BN_GENCB_free(BN_GENCB *cb);
+
+/* Populate a BN_GENCB structure with an "old"-style callback */
+void BN_GENCB_set_old(BN_GENCB *gencb, void (*callback) (int, int, void *),
+                      void *cb_arg);
+
+/* Populate a BN_GENCB structure with a "new"-style callback */
+void BN_GENCB_set(BN_GENCB *gencb, int (*callback) (int, int, BN_GENCB *),
+                  void *cb_arg);
+
+void *BN_GENCB_get_arg(BN_GENCB *cb);
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define BN_prime_checks 0      /* default: select number of iterations based
+                                  * on the size of the number */
+
+/*
+ * BN_prime_checks_for_size() returns the number of Miller-Rabin iterations
+ * that will be done for checking that a random number is probably prime. The
+ * error rate for accepting a composite number as prime depends on the size of
+ * the prime |b|. The error rates used are for calculating an RSA key with 2 primes,
+ * and so the level is what you would expect for a key of double the size of the
+ * prime.
+ *
+ * This table is generated using the algorithm of FIPS PUB 186-4
+ * Digital Signature Standard (DSS), section F.1, page 117.
+ * (https://dx.doi.org/10.6028/NIST.FIPS.186-4)
+ *
+ * The following magma script was used to generate the output:
+ * securitybits:=125;
+ * k:=1024;
+ * for t:=1 to 65 do
+ *   for M:=3 to Floor(2*Sqrt(k-1)-1) do
+ *     S:=0;
+ *     // Sum over m
+ *     for m:=3 to M do
+ *       s:=0;
+ *       // Sum over j
+ *       for j:=2 to m do
+ *         s+:=(RealField(32)!2)^-(j+(k-1)/j);
+ *       end for;
+ *       S+:=2^(m-(m-1)*t)*s;
+ *     end for;
+ *     A:=2^(k-2-M*t);
+ *     B:=8*(Pi(RealField(32))^2-6)/3*2^(k-2)*S;
+ *     pkt:=2.00743*Log(2)*k*2^-k*(A+B);
+ *     seclevel:=Floor(-Log(2,pkt));
+ *     if seclevel ge securitybits then
+ *       printf "k: %5o, security: %o bits  (t: %o, M: %o)\n",k,seclevel,t,M;
+ *       break;
+ *     end if;
+ *   end for;
+ *   if seclevel ge securitybits then break; end if;
+ * end for;
+ *
+ * It can be run online at:
+ * http://magma.maths.usyd.edu.au/calc
+ *
+ * And will output:
+ * k:  1024, security: 129 bits  (t: 6, M: 23)
+ *
+ * k is the number of bits of the prime, securitybits is the level we want to
+ * reach.
+ *
+ * prime length | RSA key size | # MR tests | security level
+ * -------------+--------------|------------+---------------
+ *  (b) >= 6394 |     >= 12788 |          3 |        256 bit
+ *  (b) >= 3747 |     >=  7494 |          3 |        192 bit
+ *  (b) >= 1345 |     >=  2690 |          4 |        128 bit
+ *  (b) >= 1080 |     >=  2160 |          5 |        128 bit
+ *  (b) >=  852 |     >=  1704 |          5 |        112 bit
+ *  (b) >=  476 |     >=   952 |          5 |         80 bit
+ *  (b) >=  400 |     >=   800 |          6 |         80 bit
+ *  (b) >=  347 |     >=   694 |          7 |         80 bit
+ *  (b) >=  308 |     >=   616 |          8 |         80 bit
+ *  (b) >=   55 |     >=   110 |         27 |         64 bit
+ *  (b) >=    6 |     >=    12 |         34 |         64 bit
+ */
+
+#  define BN_prime_checks_for_size(b) ((b) >= 3747 ?  3 : \
+                                      (b) >=  1345 ?  4 : \
+                                      (b) >=  476 ?  5 : \
+                                      (b) >=  400 ?  6 : \
+                                      (b) >=  347 ?  7 : \
+                                      (b) >=  308 ?  8 : \
+                                      (b) >=  55  ? 27 : \
+                                      /* b >= 6 */ 34)
+# endif
+
+# define BN_num_bytes(a) ((BN_num_bits(a)+7)/8)
+
+int BN_abs_is_word(const BIGNUM *a, const BN_ULONG w);
+int BN_is_zero(const BIGNUM *a);
+int BN_is_one(const BIGNUM *a);
+int BN_is_word(const BIGNUM *a, const BN_ULONG w);
+int BN_is_odd(const BIGNUM *a);
+
+# define BN_one(a)       (BN_set_word((a),1))
+
+void BN_zero_ex(BIGNUM *a);
+
+# if OPENSSL_API_LEVEL > 908
+#  define BN_zero(a)      BN_zero_ex(a)
+# else
+#  define BN_zero(a)      (BN_set_word((a),0))
+# endif
+
+const BIGNUM *BN_value_one(void);
+char *BN_options(void);
+BN_CTX *BN_CTX_new_ex(OSSL_LIB_CTX *ctx);
+BN_CTX *BN_CTX_new(void);
+BN_CTX *BN_CTX_secure_new_ex(OSSL_LIB_CTX *ctx);
+BN_CTX *BN_CTX_secure_new(void);
+void BN_CTX_free(BN_CTX *c);
+void BN_CTX_start(BN_CTX *ctx);
+BIGNUM *BN_CTX_get(BN_CTX *ctx);
+void BN_CTX_end(BN_CTX *ctx);
+int BN_rand_ex(BIGNUM *rnd, int bits, int top, int bottom,
+               unsigned int strength, BN_CTX *ctx);
+int BN_rand(BIGNUM *rnd, int bits, int top, int bottom);
+int BN_priv_rand_ex(BIGNUM *rnd, int bits, int top, int bottom,
+                    unsigned int strength, BN_CTX *ctx);
+int BN_priv_rand(BIGNUM *rnd, int bits, int top, int bottom);
+int BN_rand_range_ex(BIGNUM *r, const BIGNUM *range, unsigned int strength,
+                     BN_CTX *ctx);
+int BN_rand_range(BIGNUM *rnd, const BIGNUM *range);
+int BN_priv_rand_range_ex(BIGNUM *r, const BIGNUM *range,
+                          unsigned int strength, BN_CTX *ctx);
+int BN_priv_rand_range(BIGNUM *rnd, const BIGNUM *range);
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+int BN_pseudo_rand(BIGNUM *rnd, int bits, int top, int bottom);
+OSSL_DEPRECATEDIN_3_0
+int BN_pseudo_rand_range(BIGNUM *rnd, const BIGNUM *range);
+# endif
+int BN_num_bits(const BIGNUM *a);
+int BN_num_bits_word(BN_ULONG l);
+int BN_security_bits(int L, int N);
+BIGNUM *BN_new(void);
+BIGNUM *BN_secure_new(void);
+void BN_clear_free(BIGNUM *a);
+BIGNUM *BN_copy(BIGNUM *a, const BIGNUM *b);
+void BN_swap(BIGNUM *a, BIGNUM *b);
+BIGNUM *BN_bin2bn(const unsigned char *s, int len, BIGNUM *ret);
+BIGNUM *BN_signed_bin2bn(const unsigned char *s, int len, BIGNUM *ret);
+int BN_bn2bin(const BIGNUM *a, unsigned char *to);
+int BN_bn2binpad(const BIGNUM *a, unsigned char *to, int tolen);
+int BN_signed_bn2bin(const BIGNUM *a, unsigned char *to, int tolen);
+BIGNUM *BN_lebin2bn(const unsigned char *s, int len, BIGNUM *ret);
+BIGNUM *BN_signed_lebin2bn(const unsigned char *s, int len, BIGNUM *ret);
+int BN_bn2lebinpad(const BIGNUM *a, unsigned char *to, int tolen);
+int BN_signed_bn2lebin(const BIGNUM *a, unsigned char *to, int tolen);
+BIGNUM *BN_native2bn(const unsigned char *s, int len, BIGNUM *ret);
+BIGNUM *BN_signed_native2bn(const unsigned char *s, int len, BIGNUM *ret);
+int BN_bn2nativepad(const BIGNUM *a, unsigned char *to, int tolen);
+int BN_signed_bn2native(const BIGNUM *a, unsigned char *to, int tolen);
+BIGNUM *BN_mpi2bn(const unsigned char *s, int len, BIGNUM *ret);
+int BN_bn2mpi(const BIGNUM *a, unsigned char *to);
+int BN_sub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
+int BN_usub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
+int BN_uadd(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
+int BN_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
+int BN_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx);
+int BN_sqr(BIGNUM *r, const BIGNUM *a, BN_CTX *ctx);
+/** BN_set_negative sets sign of a BIGNUM
+ * \param  b  pointer to the BIGNUM object
+ * \param  n  0 if the BIGNUM b should be positive and a value != 0 otherwise
+ */
+void BN_set_negative(BIGNUM *b, int n);
+/** BN_is_negative returns 1 if the BIGNUM is negative
+ * \param  b  pointer to the BIGNUM object
+ * \return 1 if a < 0 and 0 otherwise
+ */
+int BN_is_negative(const BIGNUM *b);
+
+int BN_div(BIGNUM *dv, BIGNUM *rem, const BIGNUM *m, const BIGNUM *d,
+           BN_CTX *ctx);
+# define BN_mod(rem,m,d,ctx) BN_div(NULL,(rem),(m),(d),(ctx))
+int BN_nnmod(BIGNUM *r, const BIGNUM *m, const BIGNUM *d, BN_CTX *ctx);
+int BN_mod_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m,
+               BN_CTX *ctx);
+int BN_mod_add_quick(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
+                     const BIGNUM *m);
+int BN_mod_sub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m,
+               BN_CTX *ctx);
+int BN_mod_sub_quick(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
+                     const BIGNUM *m);
+int BN_mod_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m,
+               BN_CTX *ctx);
+int BN_mod_sqr(BIGNUM *r, const BIGNUM *a, const BIGNUM *m, BN_CTX *ctx);
+int BN_mod_lshift1(BIGNUM *r, const BIGNUM *a, const BIGNUM *m, BN_CTX *ctx);
+int BN_mod_lshift1_quick(BIGNUM *r, const BIGNUM *a, const BIGNUM *m);
+int BN_mod_lshift(BIGNUM *r, const BIGNUM *a, int n, const BIGNUM *m,
+                  BN_CTX *ctx);
+int BN_mod_lshift_quick(BIGNUM *r, const BIGNUM *a, int n, const BIGNUM *m);
+
+BN_ULONG BN_mod_word(const BIGNUM *a, BN_ULONG w);
+BN_ULONG BN_div_word(BIGNUM *a, BN_ULONG w);
+int BN_mul_word(BIGNUM *a, BN_ULONG w);
+int BN_add_word(BIGNUM *a, BN_ULONG w);
+int BN_sub_word(BIGNUM *a, BN_ULONG w);
+int BN_set_word(BIGNUM *a, BN_ULONG w);
+BN_ULONG BN_get_word(const BIGNUM *a);
+
+int BN_cmp(const BIGNUM *a, const BIGNUM *b);
+void BN_free(BIGNUM *a);
+int BN_is_bit_set(const BIGNUM *a, int n);
+int BN_lshift(BIGNUM *r, const BIGNUM *a, int n);
+int BN_lshift1(BIGNUM *r, const BIGNUM *a);
+int BN_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
+
+int BN_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
+               const BIGNUM *m, BN_CTX *ctx);
+int BN_mod_exp_mont(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
+                    const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx);
+int BN_mod_exp_mont_consttime(BIGNUM *rr, const BIGNUM *a, const BIGNUM *p,
+                              const BIGNUM *m, BN_CTX *ctx,
+                              BN_MONT_CTX *in_mont);
+int BN_mod_exp_mont_word(BIGNUM *r, BN_ULONG a, const BIGNUM *p,
+                         const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx);
+int BN_mod_exp2_mont(BIGNUM *r, const BIGNUM *a1, const BIGNUM *p1,
+                     const BIGNUM *a2, const BIGNUM *p2, const BIGNUM *m,
+                     BN_CTX *ctx, BN_MONT_CTX *m_ctx);
+int BN_mod_exp_simple(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
+                      const BIGNUM *m, BN_CTX *ctx);
+int BN_mod_exp_mont_consttime_x2(BIGNUM *rr1, const BIGNUM *a1, const BIGNUM *p1,
+                                 const BIGNUM *m1, BN_MONT_CTX *in_mont1,
+                                 BIGNUM *rr2, const BIGNUM *a2, const BIGNUM *p2,
+                                 const BIGNUM *m2, BN_MONT_CTX *in_mont2,
+                                 BN_CTX *ctx);
+
+int BN_mask_bits(BIGNUM *a, int n);
+# ifndef OPENSSL_NO_STDIO
+int BN_print_fp(FILE *fp, const BIGNUM *a);
+# endif
+int BN_print(BIO *bio, const BIGNUM *a);
+int BN_reciprocal(BIGNUM *r, const BIGNUM *m, int len, BN_CTX *ctx);
+int BN_rshift(BIGNUM *r, const BIGNUM *a, int n);
+int BN_rshift1(BIGNUM *r, const BIGNUM *a);
+void BN_clear(BIGNUM *a);
+BIGNUM *BN_dup(const BIGNUM *a);
+int BN_ucmp(const BIGNUM *a, const BIGNUM *b);
+int BN_set_bit(BIGNUM *a, int n);
+int BN_clear_bit(BIGNUM *a, int n);
+char *BN_bn2hex(const BIGNUM *a);
+char *BN_bn2dec(const BIGNUM *a);
+int BN_hex2bn(BIGNUM **a, const char *str);
+int BN_dec2bn(BIGNUM **a, const char *str);
+int BN_asc2bn(BIGNUM **a, const char *str);
+int BN_gcd(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx);
+int BN_kronecker(const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx); /* returns
+                                                                  * -2 for
+                                                                  * error */
+int BN_are_coprime(BIGNUM *a, const BIGNUM *b, BN_CTX *ctx);
+BIGNUM *BN_mod_inverse(BIGNUM *ret,
+                       const BIGNUM *a, const BIGNUM *n, BN_CTX *ctx);
+BIGNUM *BN_mod_sqrt(BIGNUM *ret,
+                    const BIGNUM *a, const BIGNUM *n, BN_CTX *ctx);
+
+void BN_consttime_swap(BN_ULONG swap, BIGNUM *a, BIGNUM *b, int nwords);
+
+/* Deprecated versions */
+# ifndef OPENSSL_NO_DEPRECATED_0_9_8
+OSSL_DEPRECATEDIN_0_9_8
+BIGNUM *BN_generate_prime(BIGNUM *ret, int bits, int safe,
+                          const BIGNUM *add, const BIGNUM *rem,
+                          void (*callback) (int, int, void *),
+                          void *cb_arg);
+OSSL_DEPRECATEDIN_0_9_8
+int BN_is_prime(const BIGNUM *p, int nchecks,
+                void (*callback) (int, int, void *),
+                BN_CTX *ctx, void *cb_arg);
+OSSL_DEPRECATEDIN_0_9_8
+int BN_is_prime_fasttest(const BIGNUM *p, int nchecks,
+                         void (*callback) (int, int, void *),
+                         BN_CTX *ctx, void *cb_arg,
+                         int do_trial_division);
+# endif
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+int BN_is_prime_ex(const BIGNUM *p, int nchecks, BN_CTX *ctx, BN_GENCB *cb);
+OSSL_DEPRECATEDIN_3_0
+int BN_is_prime_fasttest_ex(const BIGNUM *p, int nchecks, BN_CTX *ctx,
+                            int do_trial_division, BN_GENCB *cb);
+# endif
+/* Newer versions */
+int BN_generate_prime_ex2(BIGNUM *ret, int bits, int safe,
+                          const BIGNUM *add, const BIGNUM *rem, BN_GENCB *cb,
+                          BN_CTX *ctx);
+int BN_generate_prime_ex(BIGNUM *ret, int bits, int safe, const BIGNUM *add,
+                         const BIGNUM *rem, BN_GENCB *cb);
+int BN_check_prime(const BIGNUM *p, BN_CTX *ctx, BN_GENCB *cb);
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+int BN_X931_generate_Xpq(BIGNUM *Xp, BIGNUM *Xq, int nbits, BN_CTX *ctx);
+
+OSSL_DEPRECATEDIN_3_0
+int BN_X931_derive_prime_ex(BIGNUM *p, BIGNUM *p1, BIGNUM *p2,
+                            const BIGNUM *Xp, const BIGNUM *Xp1,
+                            const BIGNUM *Xp2, const BIGNUM *e, BN_CTX *ctx,
+                            BN_GENCB *cb);
+OSSL_DEPRECATEDIN_3_0
+int BN_X931_generate_prime_ex(BIGNUM *p, BIGNUM *p1, BIGNUM *p2, BIGNUM *Xp1,
+                              BIGNUM *Xp2, const BIGNUM *Xp, const BIGNUM *e,
+                              BN_CTX *ctx, BN_GENCB *cb);
+# endif
+
+BN_MONT_CTX *BN_MONT_CTX_new(void);
+int BN_mod_mul_montgomery(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
+                          BN_MONT_CTX *mont, BN_CTX *ctx);
+int BN_to_montgomery(BIGNUM *r, const BIGNUM *a, BN_MONT_CTX *mont,
+                     BN_CTX *ctx);
+int BN_from_montgomery(BIGNUM *r, const BIGNUM *a, BN_MONT_CTX *mont,
+                       BN_CTX *ctx);
+void BN_MONT_CTX_free(BN_MONT_CTX *mont);
+int BN_MONT_CTX_set(BN_MONT_CTX *mont, const BIGNUM *mod, BN_CTX *ctx);
+BN_MONT_CTX *BN_MONT_CTX_copy(BN_MONT_CTX *to, BN_MONT_CTX *from);
+BN_MONT_CTX *BN_MONT_CTX_set_locked(BN_MONT_CTX **pmont, CRYPTO_RWLOCK *lock,
+                                    const BIGNUM *mod, BN_CTX *ctx);
+
+/* BN_BLINDING flags */
+# define BN_BLINDING_NO_UPDATE   0x00000001
+# define BN_BLINDING_NO_RECREATE 0x00000002
+
+BN_BLINDING *BN_BLINDING_new(const BIGNUM *A, const BIGNUM *Ai, BIGNUM *mod);
+void BN_BLINDING_free(BN_BLINDING *b);
+int BN_BLINDING_update(BN_BLINDING *b, BN_CTX *ctx);
+int BN_BLINDING_convert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx);
+int BN_BLINDING_invert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx);
+int BN_BLINDING_convert_ex(BIGNUM *n, BIGNUM *r, BN_BLINDING *b, BN_CTX *);
+int BN_BLINDING_invert_ex(BIGNUM *n, const BIGNUM *r, BN_BLINDING *b,
+                          BN_CTX *);
+
+int BN_BLINDING_is_current_thread(BN_BLINDING *b);
+void BN_BLINDING_set_current_thread(BN_BLINDING *b);
+int BN_BLINDING_lock(BN_BLINDING *b);
+int BN_BLINDING_unlock(BN_BLINDING *b);
+
+unsigned long BN_BLINDING_get_flags(const BN_BLINDING *);
+void BN_BLINDING_set_flags(BN_BLINDING *, unsigned long);
+BN_BLINDING *BN_BLINDING_create_param(BN_BLINDING *b,
+                                      const BIGNUM *e, BIGNUM *m, BN_CTX *ctx,
+                                      int (*bn_mod_exp) (BIGNUM *r,
+                                                         const BIGNUM *a,
+                                                         const BIGNUM *p,
+                                                         const BIGNUM *m,
+                                                         BN_CTX *ctx,
+                                                         BN_MONT_CTX *m_ctx),
+                                      BN_MONT_CTX *m_ctx);
+# ifndef OPENSSL_NO_DEPRECATED_0_9_8
+OSSL_DEPRECATEDIN_0_9_8
+void BN_set_params(int mul, int high, int low, int mont);
+OSSL_DEPRECATEDIN_0_9_8
+int BN_get_params(int which); /* 0, mul, 1 high, 2 low, 3 mont */
+# endif
+
+BN_RECP_CTX *BN_RECP_CTX_new(void);
+void BN_RECP_CTX_free(BN_RECP_CTX *recp);
+int BN_RECP_CTX_set(BN_RECP_CTX *recp, const BIGNUM *rdiv, BN_CTX *ctx);
+int BN_mod_mul_reciprocal(BIGNUM *r, const BIGNUM *x, const BIGNUM *y,
+                          BN_RECP_CTX *recp, BN_CTX *ctx);
+int BN_mod_exp_recp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
+                    const BIGNUM *m, BN_CTX *ctx);
+int BN_div_recp(BIGNUM *dv, BIGNUM *rem, const BIGNUM *m,
+                BN_RECP_CTX *recp, BN_CTX *ctx);
+
+# ifndef OPENSSL_NO_EC2M
+
+/*
+ * Functions for arithmetic over binary polynomials represented by BIGNUMs.
+ * The BIGNUM::neg property of BIGNUMs representing binary polynomials is
+ * ignored. Note that input arguments are not const so that their bit arrays
+ * can be expanded to the appropriate size if needed.
+ */
+
+/*
+ * r = a + b
+ */
+int BN_GF2m_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
+#  define BN_GF2m_sub(r, a, b) BN_GF2m_add(r, a, b)
+/*
+ * r=a mod p
+ */
+int BN_GF2m_mod(BIGNUM *r, const BIGNUM *a, const BIGNUM *p);
+/* r = (a * b) mod p */
+int BN_GF2m_mod_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
+                    const BIGNUM *p, BN_CTX *ctx);
+/* r = (a * a) mod p */
+int BN_GF2m_mod_sqr(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
+/* r = (1 / b) mod p */
+int BN_GF2m_mod_inv(BIGNUM *r, const BIGNUM *b, const BIGNUM *p, BN_CTX *ctx);
+/* r = (a / b) mod p */
+int BN_GF2m_mod_div(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
+                    const BIGNUM *p, BN_CTX *ctx);
+/* r = (a ^ b) mod p */
+int BN_GF2m_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
+                    const BIGNUM *p, BN_CTX *ctx);
+/* r = sqrt(a) mod p */
+int BN_GF2m_mod_sqrt(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
+                     BN_CTX *ctx);
+/* r^2 + r = a mod p */
+int BN_GF2m_mod_solve_quad(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
+                           BN_CTX *ctx);
+#  define BN_GF2m_cmp(a, b) BN_ucmp((a), (b))
+/*-
+ * Some functions allow for representation of the irreducible polynomials
+ * as an unsigned int[], say p.  The irreducible f(t) is then of the form:
+ *     t^p[0] + t^p[1] + ... + t^p[k]
+ * where m = p[0] > p[1] > ... > p[k] = 0.
+ */
+/* r = a mod p */
+int BN_GF2m_mod_arr(BIGNUM *r, const BIGNUM *a, const int p[]);
+/* r = (a * b) mod p */
+int BN_GF2m_mod_mul_arr(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
+                        const int p[], BN_CTX *ctx);
+/* r = (a * a) mod p */
+int BN_GF2m_mod_sqr_arr(BIGNUM *r, const BIGNUM *a, const int p[],
+                        BN_CTX *ctx);
+/* r = (1 / b) mod p */
+int BN_GF2m_mod_inv_arr(BIGNUM *r, const BIGNUM *b, const int p[],
+                        BN_CTX *ctx);
+/* r = (a / b) mod p */
+int BN_GF2m_mod_div_arr(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
+                        const int p[], BN_CTX *ctx);
+/* r = (a ^ b) mod p */
+int BN_GF2m_mod_exp_arr(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
+                        const int p[], BN_CTX *ctx);
+/* r = sqrt(a) mod p */
+int BN_GF2m_mod_sqrt_arr(BIGNUM *r, const BIGNUM *a,
+                         const int p[], BN_CTX *ctx);
+/* r^2 + r = a mod p */
+int BN_GF2m_mod_solve_quad_arr(BIGNUM *r, const BIGNUM *a,
+                               const int p[], BN_CTX *ctx);
+int BN_GF2m_poly2arr(const BIGNUM *a, int p[], int max);
+int BN_GF2m_arr2poly(const int p[], BIGNUM *a);
+
+# endif
+
+/*
+ * faster mod functions for the 'NIST primes' 0 <= a < p^2
+ */
+int BN_nist_mod_192(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
+int BN_nist_mod_224(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
+int BN_nist_mod_256(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
+int BN_nist_mod_384(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
+int BN_nist_mod_521(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
+
+const BIGNUM *BN_get0_nist_prime_192(void);
+const BIGNUM *BN_get0_nist_prime_224(void);
+const BIGNUM *BN_get0_nist_prime_256(void);
+const BIGNUM *BN_get0_nist_prime_384(void);
+const BIGNUM *BN_get0_nist_prime_521(void);
+
+int (*BN_nist_mod_func(const BIGNUM *p)) (BIGNUM *r, const BIGNUM *a,
+                                          const BIGNUM *field, BN_CTX *ctx);
+
+int BN_generate_dsa_nonce(BIGNUM *out, const BIGNUM *range,
+                          const BIGNUM *priv, const unsigned char *message,
+                          size_t message_len, BN_CTX *ctx);
+
+/* Primes from RFC 2409 */
+BIGNUM *BN_get_rfc2409_prime_768(BIGNUM *bn);
+BIGNUM *BN_get_rfc2409_prime_1024(BIGNUM *bn);
+
+/* Primes from RFC 3526 */
+BIGNUM *BN_get_rfc3526_prime_1536(BIGNUM *bn);
+BIGNUM *BN_get_rfc3526_prime_2048(BIGNUM *bn);
+BIGNUM *BN_get_rfc3526_prime_3072(BIGNUM *bn);
+BIGNUM *BN_get_rfc3526_prime_4096(BIGNUM *bn);
+BIGNUM *BN_get_rfc3526_prime_6144(BIGNUM *bn);
+BIGNUM *BN_get_rfc3526_prime_8192(BIGNUM *bn);
+
+#  ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#   define get_rfc2409_prime_768 BN_get_rfc2409_prime_768
+#   define get_rfc2409_prime_1024 BN_get_rfc2409_prime_1024
+#   define get_rfc3526_prime_1536 BN_get_rfc3526_prime_1536
+#   define get_rfc3526_prime_2048 BN_get_rfc3526_prime_2048
+#   define get_rfc3526_prime_3072 BN_get_rfc3526_prime_3072
+#   define get_rfc3526_prime_4096 BN_get_rfc3526_prime_4096
+#   define get_rfc3526_prime_6144 BN_get_rfc3526_prime_6144
+#   define get_rfc3526_prime_8192 BN_get_rfc3526_prime_8192
+#  endif
+
+int BN_bntest_rand(BIGNUM *rnd, int bits, int top, int bottom);
+
+
+# ifdef  __cplusplus
+}
+# endif
+#endif
diff --git a/src/include/openssl/bnerr.h b/src/include/openssl/bnerr.h
new file mode 100644
index 0000000..7c3f6ef
--- /dev/null
+++ b/src/include/openssl/bnerr.h
@@ -0,0 +1,47 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2022 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_BNERR_H
+# define OPENSSL_BNERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+
+/*
+ * BN reason codes.
+ */
+# define BN_R_ARG2_LT_ARG3                                100
+# define BN_R_BAD_RECIPROCAL                              101
+# define BN_R_BIGNUM_TOO_LONG                             114
+# define BN_R_BITS_TOO_SMALL                              118
+# define BN_R_CALLED_WITH_EVEN_MODULUS                    102
+# define BN_R_DIV_BY_ZERO                                 103
+# define BN_R_ENCODING_ERROR                              104
+# define BN_R_EXPAND_ON_STATIC_BIGNUM_DATA                105
+# define BN_R_INPUT_NOT_REDUCED                           110
+# define BN_R_INVALID_LENGTH                              106
+# define BN_R_INVALID_RANGE                               115
+# define BN_R_INVALID_SHIFT                               119
+# define BN_R_NOT_A_SQUARE                                111
+# define BN_R_NOT_INITIALIZED                             107
+# define BN_R_NO_INVERSE                                  108
+# define BN_R_NO_PRIME_CANDIDATE                          121
+# define BN_R_NO_SOLUTION                                 116
+# define BN_R_NO_SUITABLE_DIGEST                          120
+# define BN_R_PRIVATE_KEY_TOO_LARGE                       117
+# define BN_R_P_IS_NOT_PRIME                              112
+# define BN_R_TOO_MANY_ITERATIONS                         113
+# define BN_R_TOO_MANY_TEMPORARY_VARIABLES                109
+
+#endif
diff --git a/src/include/openssl/buffer.h b/src/include/openssl/buffer.h
new file mode 100644
index 0000000..5773b98
--- /dev/null
+++ b/src/include/openssl/buffer.h
@@ -0,0 +1,62 @@
+/*
+ * Copyright 1995-2018 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_BUFFER_H
+# define OPENSSL_BUFFER_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_BUFFER_H
+# endif
+
+# include <openssl/types.h>
+# ifndef OPENSSL_CRYPTO_H
+#  include <openssl/crypto.h>
+# endif
+# include <openssl/buffererr.h>
+
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+# include <stddef.h>
+# include <sys/types.h>
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define BUF_strdup(s) OPENSSL_strdup(s)
+#  define BUF_strndup(s, size) OPENSSL_strndup(s, size)
+#  define BUF_memdup(data, size) OPENSSL_memdup(data, size)
+#  define BUF_strlcpy(dst, src, size)  OPENSSL_strlcpy(dst, src, size)
+#  define BUF_strlcat(dst, src, size) OPENSSL_strlcat(dst, src, size)
+#  define BUF_strnlen(str, maxlen) OPENSSL_strnlen(str, maxlen)
+# endif
+
+struct buf_mem_st {
+    size_t length;              /* current number of bytes */
+    char *data;
+    size_t max;                 /* size of buffer */
+    unsigned long flags;
+};
+
+# define BUF_MEM_FLAG_SECURE  0x01
+
+BUF_MEM *BUF_MEM_new(void);
+BUF_MEM *BUF_MEM_new_ex(unsigned long flags);
+void BUF_MEM_free(BUF_MEM *a);
+size_t BUF_MEM_grow(BUF_MEM *str, size_t len);
+size_t BUF_MEM_grow_clean(BUF_MEM *str, size_t len);
+void BUF_reverse(unsigned char *out, const unsigned char *in, size_t siz);
+
+
+# ifdef  __cplusplus
+}
+# endif
+#endif
diff --git a/src/include/openssl/buffererr.h b/src/include/openssl/buffererr.h
new file mode 100644
index 0000000..d18b1f8
--- /dev/null
+++ b/src/include/openssl/buffererr.h
@@ -0,0 +1,25 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_BUFFERERR_H
+# define OPENSSL_BUFFERERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+
+/*
+ * BUF reason codes.
+ */
+
+#endif
diff --git a/src/include/openssl/camellia.h b/src/include/openssl/camellia.h
new file mode 100644
index 0000000..88c2279
--- /dev/null
+++ b/src/include/openssl/camellia.h
@@ -0,0 +1,117 @@
+/*
+ * Copyright 2006-2020 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_CAMELLIA_H
+# define OPENSSL_CAMELLIA_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_CAMELLIA_H
+# endif
+
+# include <openssl/opensslconf.h>
+
+# ifndef OPENSSL_NO_CAMELLIA
+# include <stddef.h>
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+# define CAMELLIA_BLOCK_SIZE 16
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+
+#  define CAMELLIA_ENCRYPT        1
+#  define CAMELLIA_DECRYPT        0
+
+/*
+ * Because array size can't be a const in C, the following two are macros.
+ * Both sizes are in bytes.
+ */
+
+/* This should be a hidden type, but EVP requires that the size be known */
+
+#  define CAMELLIA_TABLE_BYTE_LEN 272
+#  define CAMELLIA_TABLE_WORD_LEN (CAMELLIA_TABLE_BYTE_LEN / 4)
+
+typedef unsigned int KEY_TABLE_TYPE[CAMELLIA_TABLE_WORD_LEN]; /* to match
+                                                               * with WORD */
+
+struct camellia_key_st {
+    union {
+        double d;               /* ensures 64-bit align */
+        KEY_TABLE_TYPE rd_key;
+    } u;
+    int grand_rounds;
+};
+typedef struct camellia_key_st CAMELLIA_KEY;
+
+# endif /* OPENSSL_NO_DEPRECATED_3_0 */
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int Camellia_set_key(const unsigned char *userKey,
+                                           const int bits,
+                                           CAMELLIA_KEY *key);
+OSSL_DEPRECATEDIN_3_0 void Camellia_encrypt(const unsigned char *in,
+                                            unsigned char *out,
+                                            const CAMELLIA_KEY *key);
+OSSL_DEPRECATEDIN_3_0 void Camellia_decrypt(const unsigned char *in,
+                                            unsigned char *out,
+                                            const CAMELLIA_KEY *key);
+OSSL_DEPRECATEDIN_3_0 void Camellia_ecb_encrypt(const unsigned char *in,
+                                                unsigned char *out,
+                                                const CAMELLIA_KEY *key,
+                                                const int enc);
+OSSL_DEPRECATEDIN_3_0 void Camellia_cbc_encrypt(const unsigned char *in,
+                                                unsigned char *out,
+                                                size_t length,
+                                                const CAMELLIA_KEY *key,
+                                                unsigned char *ivec,
+                                                const int enc);
+OSSL_DEPRECATEDIN_3_0 void Camellia_cfb128_encrypt(const unsigned char *in,
+                                                   unsigned char *out,
+                                                   size_t length,
+                                                   const CAMELLIA_KEY *key,
+                                                   unsigned char *ivec,
+                                                   int *num,
+                                                   const int enc);
+OSSL_DEPRECATEDIN_3_0 void Camellia_cfb1_encrypt(const unsigned char *in,
+                                                 unsigned char *out,
+                                                 size_t length,
+                                                 const CAMELLIA_KEY *key,
+                                                 unsigned char *ivec,
+                                                 int *num,
+                                                 const int enc);
+OSSL_DEPRECATEDIN_3_0 void Camellia_cfb8_encrypt(const unsigned char *in,
+                                                 unsigned char *out,
+                                                 size_t length,
+                                                 const CAMELLIA_KEY *key,
+                                                 unsigned char *ivec,
+                                                 int *num,
+                                                 const int enc);
+OSSL_DEPRECATEDIN_3_0 void Camellia_ofb128_encrypt(const unsigned char *in,
+                                                   unsigned char *out,
+                                                   size_t length,
+                                                   const CAMELLIA_KEY *key,
+                                                   unsigned char *ivec,
+                                                   int *num);
+OSSL_DEPRECATEDIN_3_0
+void Camellia_ctr128_encrypt(const unsigned char *in, unsigned char *out,
+                             size_t length, const CAMELLIA_KEY *key,
+                             unsigned char ivec[CAMELLIA_BLOCK_SIZE],
+                             unsigned char ecount_buf[CAMELLIA_BLOCK_SIZE],
+                             unsigned int *num);
+# endif
+
+# ifdef  __cplusplus
+}
+# endif
+# endif
+
+#endif
diff --git a/src/include/openssl/cast.h b/src/include/openssl/cast.h
new file mode 100644
index 0000000..0bf217b
--- /dev/null
+++ b/src/include/openssl/cast.h
@@ -0,0 +1,71 @@
+/*
+ * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_CAST_H
+# define OPENSSL_CAST_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_CAST_H
+# endif
+
+# include <openssl/opensslconf.h>
+
+# ifndef OPENSSL_NO_CAST
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+# define CAST_BLOCK      8
+# define CAST_KEY_LENGTH 16
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+
+#  define CAST_ENCRYPT    1
+#  define CAST_DECRYPT    0
+
+#  define CAST_LONG unsigned int
+
+typedef struct cast_key_st {
+    CAST_LONG data[32];
+    int short_key;              /* Use reduced rounds for short key */
+} CAST_KEY;
+
+# endif /* OPENSSL_NO_DEPRECATED_3_0 */
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+void CAST_set_key(CAST_KEY *key, int len, const unsigned char *data);
+OSSL_DEPRECATEDIN_3_0
+void CAST_ecb_encrypt(const unsigned char *in, unsigned char *out,
+                      const CAST_KEY *key, int enc);
+OSSL_DEPRECATEDIN_3_0
+void CAST_encrypt(CAST_LONG *data, const CAST_KEY *key);
+OSSL_DEPRECATEDIN_3_0
+void CAST_decrypt(CAST_LONG *data, const CAST_KEY *key);
+OSSL_DEPRECATEDIN_3_0
+void CAST_cbc_encrypt(const unsigned char *in, unsigned char *out,
+                      long length, const CAST_KEY *ks, unsigned char *iv,
+                      int enc);
+OSSL_DEPRECATEDIN_3_0
+void CAST_cfb64_encrypt(const unsigned char *in, unsigned char *out,
+                        long length, const CAST_KEY *schedule,
+                        unsigned char *ivec, int *num, int enc);
+OSSL_DEPRECATEDIN_3_0
+void CAST_ofb64_encrypt(const unsigned char *in, unsigned char *out,
+                        long length, const CAST_KEY *schedule,
+                        unsigned char *ivec, int *num);
+# endif
+
+# ifdef  __cplusplus
+}
+# endif
+# endif
+
+#endif
diff --git a/src/include/openssl/cmac.h b/src/include/openssl/cmac.h
new file mode 100644
index 0000000..f508618
--- /dev/null
+++ b/src/include/openssl/cmac.h
@@ -0,0 +1,52 @@
+/*
+ * Copyright 2010-2020 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_CMAC_H
+# define OPENSSL_CMAC_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_CMAC_H
+# endif
+
+# ifndef OPENSSL_NO_CMAC
+
+#  ifdef __cplusplus
+extern "C" {
+#  endif
+
+#  include <openssl/evp.h>
+
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+/* Opaque */
+typedef struct CMAC_CTX_st CMAC_CTX;
+#  endif
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 CMAC_CTX *CMAC_CTX_new(void);
+OSSL_DEPRECATEDIN_3_0 void CMAC_CTX_cleanup(CMAC_CTX *ctx);
+OSSL_DEPRECATEDIN_3_0 void CMAC_CTX_free(CMAC_CTX *ctx);
+OSSL_DEPRECATEDIN_3_0 EVP_CIPHER_CTX *CMAC_CTX_get0_cipher_ctx(CMAC_CTX *ctx);
+OSSL_DEPRECATEDIN_3_0 int CMAC_CTX_copy(CMAC_CTX *out, const CMAC_CTX *in);
+OSSL_DEPRECATEDIN_3_0 int CMAC_Init(CMAC_CTX *ctx,
+                                    const void *key, size_t keylen,
+                                    const EVP_CIPHER *cipher, ENGINE *impl);
+OSSL_DEPRECATEDIN_3_0 int CMAC_Update(CMAC_CTX *ctx,
+                                      const void *data, size_t dlen);
+OSSL_DEPRECATEDIN_3_0 int CMAC_Final(CMAC_CTX *ctx,
+                                     unsigned char *out, size_t *poutlen);
+OSSL_DEPRECATEDIN_3_0 int CMAC_resume(CMAC_CTX *ctx);
+#  endif
+
+#  ifdef  __cplusplus
+}
+#  endif
+
+# endif
+#endif
diff --git a/src/include/openssl/cmp.h b/src/include/openssl/cmp.h
new file mode 100644
index 0000000..a5a808d
--- /dev/null
+++ b/src/include/openssl/cmp.h
@@ -0,0 +1,648 @@
+/*
+ * WARNING: do not edit!
+ * Generated by makefile from include\openssl\cmp.h.in
+ *
+ * Copyright 2007-2024 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright Nokia 2007-2019
+ * Copyright Siemens AG 2015-2019
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+
+
+#ifndef OPENSSL_CMP_H
+# define OPENSSL_CMP_H
+
+# include <openssl/opensslconf.h>
+# ifndef OPENSSL_NO_CMP
+
+#  include <openssl/crmf.h>
+#  include <openssl/cmperr.h>
+#  include <openssl/cmp_util.h>
+#  include <openssl/http.h>
+
+/* explicit #includes not strictly needed since implied by the above: */
+#  include <openssl/types.h>
+#  include <openssl/safestack.h>
+#  include <openssl/x509.h>
+#  include <openssl/x509v3.h>
+
+#  ifdef __cplusplus
+extern "C" {
+#  endif
+
+#  define OSSL_CMP_PVNO_2 2
+#  define OSSL_CMP_PVNO_3 3
+#  define OSSL_CMP_PVNO OSSL_CMP_PVNO_2 /* v2 is the default */
+
+/*-
+ *   PKIFailureInfo ::= BIT STRING {
+ *   -- since we can fail in more than one way!
+ *   -- More codes may be added in the future if/when required.
+ *       badAlg              (0),
+ *       -- unrecognized or unsupported Algorithm Identifier
+ *       badMessageCheck     (1),
+ *       -- integrity check failed (e.g., signature did not verify)
+ *       badRequest          (2),
+ *       -- transaction not permitted or supported
+ *       badTime             (3),
+ *       -- messageTime was not sufficiently close to the system time,
+ *       -- as defined by local policy
+ *       badCertId           (4),
+ *       -- no certificate could be found matching the provided criteria
+ *       badDataFormat       (5),
+ *       -- the data submitted has the wrong format
+ *       wrongAuthority      (6),
+ *       -- the authority indicated in the request is different from the
+ *       -- one creating the response token
+ *       incorrectData       (7),
+ *       -- the requester's data is incorrect (for notary services)
+ *       missingTimeStamp    (8),
+ *       -- when the timestamp is missing but should be there
+ *       -- (by policy)
+ *       badPOP              (9),
+ *       -- the proof-of-possession failed
+ *       certRevoked         (10),
+ *          -- the certificate has already been revoked
+ *       certConfirmed       (11),
+ *          -- the certificate has already been confirmed
+ *       wrongIntegrity      (12),
+ *          -- invalid integrity, password based instead of signature or
+ *          -- vice versa
+ *       badRecipientNonce   (13),
+ *          -- invalid recipient nonce, either missing or wrong value
+ *       timeNotAvailable    (14),
+ *          -- the TSA's time source is not available
+ *       unacceptedPolicy    (15),
+ *          -- the requested TSA policy is not supported by the TSA.
+ *       unacceptedExtension (16),
+ *          -- the requested extension is not supported by the TSA.
+ *       addInfoNotAvailable (17),
+ *          -- the additional information requested could not be
+ *          -- understood or is not available
+ *       badSenderNonce      (18),
+ *          -- invalid sender nonce, either missing or wrong size
+ *       badCertTemplate     (19),
+ *          -- invalid cert. template or missing mandatory information
+ *       signerNotTrusted    (20),
+ *          -- signer of the message unknown or not trusted
+ *       transactionIdInUse  (21),
+ *          -- the transaction identifier is already in use
+ *       unsupportedVersion  (22),
+ *          -- the version of the message is not supported
+ *       notAuthorized       (23),
+ *          -- the sender was not authorized to make the preceding
+ *          -- request or perform the preceding action
+ *       systemUnavail       (24),
+ *       -- the request cannot be handled due to system unavailability
+ *       systemFailure       (25),
+ *       -- the request cannot be handled due to system failure
+ *       duplicateCertReq    (26)
+ *       -- certificate cannot be issued because a duplicate
+ *       -- certificate already exists
+ *   }
+ */
+#  define OSSL_CMP_PKIFAILUREINFO_badAlg 0
+#  define OSSL_CMP_PKIFAILUREINFO_badMessageCheck 1
+#  define OSSL_CMP_PKIFAILUREINFO_badRequest 2
+#  define OSSL_CMP_PKIFAILUREINFO_badTime 3
+#  define OSSL_CMP_PKIFAILUREINFO_badCertId 4
+#  define OSSL_CMP_PKIFAILUREINFO_badDataFormat 5
+#  define OSSL_CMP_PKIFAILUREINFO_wrongAuthority 6
+#  define OSSL_CMP_PKIFAILUREINFO_incorrectData 7
+#  define OSSL_CMP_PKIFAILUREINFO_missingTimeStamp 8
+#  define OSSL_CMP_PKIFAILUREINFO_badPOP 9
+#  define OSSL_CMP_PKIFAILUREINFO_certRevoked 10
+#  define OSSL_CMP_PKIFAILUREINFO_certConfirmed 11
+#  define OSSL_CMP_PKIFAILUREINFO_wrongIntegrity 12
+#  define OSSL_CMP_PKIFAILUREINFO_badRecipientNonce 13
+#  define OSSL_CMP_PKIFAILUREINFO_timeNotAvailable 14
+#  define OSSL_CMP_PKIFAILUREINFO_unacceptedPolicy 15
+#  define OSSL_CMP_PKIFAILUREINFO_unacceptedExtension 16
+#  define OSSL_CMP_PKIFAILUREINFO_addInfoNotAvailable 17
+#  define OSSL_CMP_PKIFAILUREINFO_badSenderNonce 18
+#  define OSSL_CMP_PKIFAILUREINFO_badCertTemplate 19
+#  define OSSL_CMP_PKIFAILUREINFO_signerNotTrusted 20
+#  define OSSL_CMP_PKIFAILUREINFO_transactionIdInUse 21
+#  define OSSL_CMP_PKIFAILUREINFO_unsupportedVersion 22
+#  define OSSL_CMP_PKIFAILUREINFO_notAuthorized 23
+#  define OSSL_CMP_PKIFAILUREINFO_systemUnavail 24
+#  define OSSL_CMP_PKIFAILUREINFO_systemFailure 25
+#  define OSSL_CMP_PKIFAILUREINFO_duplicateCertReq 26
+#  define OSSL_CMP_PKIFAILUREINFO_MAX 26
+#  define OSSL_CMP_PKIFAILUREINFO_MAX_BIT_PATTERN \
+    ((1 << (OSSL_CMP_PKIFAILUREINFO_MAX + 1)) - 1)
+#  if OSSL_CMP_PKIFAILUREINFO_MAX_BIT_PATTERN > INT_MAX
+#   error CMP_PKIFAILUREINFO_MAX bit pattern does not fit in type int
+#  endif
+typedef ASN1_BIT_STRING OSSL_CMP_PKIFAILUREINFO;
+
+#  define OSSL_CMP_CTX_FAILINFO_badAlg (1 << 0)
+#  define OSSL_CMP_CTX_FAILINFO_badMessageCheck (1 << 1)
+#  define OSSL_CMP_CTX_FAILINFO_badRequest (1 << 2)
+#  define OSSL_CMP_CTX_FAILINFO_badTime (1 << 3)
+#  define OSSL_CMP_CTX_FAILINFO_badCertId (1 << 4)
+#  define OSSL_CMP_CTX_FAILINFO_badDataFormat (1 << 5)
+#  define OSSL_CMP_CTX_FAILINFO_wrongAuthority (1 << 6)
+#  define OSSL_CMP_CTX_FAILINFO_incorrectData (1 << 7)
+#  define OSSL_CMP_CTX_FAILINFO_missingTimeStamp (1 << 8)
+#  define OSSL_CMP_CTX_FAILINFO_badPOP (1 << 9)
+#  define OSSL_CMP_CTX_FAILINFO_certRevoked (1 << 10)
+#  define OSSL_CMP_CTX_FAILINFO_certConfirmed (1 << 11)
+#  define OSSL_CMP_CTX_FAILINFO_wrongIntegrity (1 << 12)
+#  define OSSL_CMP_CTX_FAILINFO_badRecipientNonce (1 << 13)
+#  define OSSL_CMP_CTX_FAILINFO_timeNotAvailable (1 << 14)
+#  define OSSL_CMP_CTX_FAILINFO_unacceptedPolicy (1 << 15)
+#  define OSSL_CMP_CTX_FAILINFO_unacceptedExtension (1 << 16)
+#  define OSSL_CMP_CTX_FAILINFO_addInfoNotAvailable (1 << 17)
+#  define OSSL_CMP_CTX_FAILINFO_badSenderNonce (1 << 18)
+#  define OSSL_CMP_CTX_FAILINFO_badCertTemplate (1 << 19)
+#  define OSSL_CMP_CTX_FAILINFO_signerNotTrusted (1 << 20)
+#  define OSSL_CMP_CTX_FAILINFO_transactionIdInUse (1 << 21)
+#  define OSSL_CMP_CTX_FAILINFO_unsupportedVersion (1 << 22)
+#  define OSSL_CMP_CTX_FAILINFO_notAuthorized (1 << 23)
+#  define OSSL_CMP_CTX_FAILINFO_systemUnavail (1 << 24)
+#  define OSSL_CMP_CTX_FAILINFO_systemFailure (1 << 25)
+#  define OSSL_CMP_CTX_FAILINFO_duplicateCertReq (1 << 26)
+
+/*-
+ *   PKIStatus ::= INTEGER {
+ *       accepted                (0),
+ *       -- you got exactly what you asked for
+ *       grantedWithMods        (1),
+ *       -- you got something like what you asked for; the
+ *       -- requester is responsible for ascertaining the differences
+ *       rejection              (2),
+ *       -- you don't get it, more information elsewhere in the message
+ *       waiting                (3),
+ *       -- the request body part has not yet been processed; expect to
+ *       -- hear more later (note: proper handling of this status
+ *       -- response MAY use the polling req/rep PKIMessages specified
+ *       -- in Section 5.3.22; alternatively, polling in the underlying
+ *       -- transport layer MAY have some utility in this regard)
+ *       revocationWarning      (4),
+ *       -- this message contains a warning that a revocation is
+ *       -- imminent
+ *       revocationNotification (5),
+ *       -- notification that a revocation has occurred
+ *       keyUpdateWarning       (6)
+ *       -- update already done for the oldCertId specified in
+ *       -- CertReqMsg
+ *   }
+ */
+#  define OSSL_CMP_PKISTATUS_request                -3
+#  define OSSL_CMP_PKISTATUS_trans                  -2
+#  define OSSL_CMP_PKISTATUS_unspecified            -1
+#  define OSSL_CMP_PKISTATUS_accepted               0
+#  define OSSL_CMP_PKISTATUS_grantedWithMods        1
+#  define OSSL_CMP_PKISTATUS_rejection              2
+#  define OSSL_CMP_PKISTATUS_waiting                3
+#  define OSSL_CMP_PKISTATUS_revocationWarning      4
+#  define OSSL_CMP_PKISTATUS_revocationNotification 5
+#  define OSSL_CMP_PKISTATUS_keyUpdateWarning       6
+typedef ASN1_INTEGER OSSL_CMP_PKISTATUS;
+
+DECLARE_ASN1_ITEM(OSSL_CMP_PKISTATUS)
+
+#  define OSSL_CMP_CERTORENCCERT_CERTIFICATE 0
+#  define OSSL_CMP_CERTORENCCERT_ENCRYPTEDCERT 1
+
+/* data type declarations */
+typedef struct ossl_cmp_ctx_st OSSL_CMP_CTX;
+typedef struct ossl_cmp_pkiheader_st OSSL_CMP_PKIHEADER;
+DECLARE_ASN1_FUNCTIONS(OSSL_CMP_PKIHEADER)
+typedef struct ossl_cmp_msg_st OSSL_CMP_MSG;
+DECLARE_ASN1_DUP_FUNCTION(OSSL_CMP_MSG)
+DECLARE_ASN1_ENCODE_FUNCTIONS(OSSL_CMP_MSG, OSSL_CMP_MSG, OSSL_CMP_MSG)
+typedef struct ossl_cmp_certstatus_st OSSL_CMP_CERTSTATUS;
+SKM_DEFINE_STACK_OF_INTERNAL(OSSL_CMP_CERTSTATUS, OSSL_CMP_CERTSTATUS, OSSL_CMP_CERTSTATUS)
+#define sk_OSSL_CMP_CERTSTATUS_num(sk) OPENSSL_sk_num(ossl_check_const_OSSL_CMP_CERTSTATUS_sk_type(sk))
+#define sk_OSSL_CMP_CERTSTATUS_value(sk, idx) ((OSSL_CMP_CERTSTATUS *)OPENSSL_sk_value(ossl_check_const_OSSL_CMP_CERTSTATUS_sk_type(sk), (idx)))
+#define sk_OSSL_CMP_CERTSTATUS_new(cmp) ((STACK_OF(OSSL_CMP_CERTSTATUS) *)OPENSSL_sk_new(ossl_check_OSSL_CMP_CERTSTATUS_compfunc_type(cmp)))
+#define sk_OSSL_CMP_CERTSTATUS_new_null() ((STACK_OF(OSSL_CMP_CERTSTATUS) *)OPENSSL_sk_new_null())
+#define sk_OSSL_CMP_CERTSTATUS_new_reserve(cmp, n) ((STACK_OF(OSSL_CMP_CERTSTATUS) *)OPENSSL_sk_new_reserve(ossl_check_OSSL_CMP_CERTSTATUS_compfunc_type(cmp), (n)))
+#define sk_OSSL_CMP_CERTSTATUS_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk), (n))
+#define sk_OSSL_CMP_CERTSTATUS_free(sk) OPENSSL_sk_free(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk))
+#define sk_OSSL_CMP_CERTSTATUS_zero(sk) OPENSSL_sk_zero(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk))
+#define sk_OSSL_CMP_CERTSTATUS_delete(sk, i) ((OSSL_CMP_CERTSTATUS *)OPENSSL_sk_delete(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk), (i)))
+#define sk_OSSL_CMP_CERTSTATUS_delete_ptr(sk, ptr) ((OSSL_CMP_CERTSTATUS *)OPENSSL_sk_delete_ptr(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk), ossl_check_OSSL_CMP_CERTSTATUS_type(ptr)))
+#define sk_OSSL_CMP_CERTSTATUS_push(sk, ptr) OPENSSL_sk_push(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk), ossl_check_OSSL_CMP_CERTSTATUS_type(ptr))
+#define sk_OSSL_CMP_CERTSTATUS_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk), ossl_check_OSSL_CMP_CERTSTATUS_type(ptr))
+#define sk_OSSL_CMP_CERTSTATUS_pop(sk) ((OSSL_CMP_CERTSTATUS *)OPENSSL_sk_pop(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk)))
+#define sk_OSSL_CMP_CERTSTATUS_shift(sk) ((OSSL_CMP_CERTSTATUS *)OPENSSL_sk_shift(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk)))
+#define sk_OSSL_CMP_CERTSTATUS_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk),ossl_check_OSSL_CMP_CERTSTATUS_freefunc_type(freefunc))
+#define sk_OSSL_CMP_CERTSTATUS_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk), ossl_check_OSSL_CMP_CERTSTATUS_type(ptr), (idx))
+#define sk_OSSL_CMP_CERTSTATUS_set(sk, idx, ptr) ((OSSL_CMP_CERTSTATUS *)OPENSSL_sk_set(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk), (idx), ossl_check_OSSL_CMP_CERTSTATUS_type(ptr)))
+#define sk_OSSL_CMP_CERTSTATUS_find(sk, ptr) OPENSSL_sk_find(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk), ossl_check_OSSL_CMP_CERTSTATUS_type(ptr))
+#define sk_OSSL_CMP_CERTSTATUS_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk), ossl_check_OSSL_CMP_CERTSTATUS_type(ptr))
+#define sk_OSSL_CMP_CERTSTATUS_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk), ossl_check_OSSL_CMP_CERTSTATUS_type(ptr), pnum)
+#define sk_OSSL_CMP_CERTSTATUS_sort(sk) OPENSSL_sk_sort(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk))
+#define sk_OSSL_CMP_CERTSTATUS_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OSSL_CMP_CERTSTATUS_sk_type(sk))
+#define sk_OSSL_CMP_CERTSTATUS_dup(sk) ((STACK_OF(OSSL_CMP_CERTSTATUS) *)OPENSSL_sk_dup(ossl_check_const_OSSL_CMP_CERTSTATUS_sk_type(sk)))
+#define sk_OSSL_CMP_CERTSTATUS_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OSSL_CMP_CERTSTATUS) *)OPENSSL_sk_deep_copy(ossl_check_const_OSSL_CMP_CERTSTATUS_sk_type(sk), ossl_check_OSSL_CMP_CERTSTATUS_copyfunc_type(copyfunc), ossl_check_OSSL_CMP_CERTSTATUS_freefunc_type(freefunc)))
+#define sk_OSSL_CMP_CERTSTATUS_set_cmp_func(sk, cmp) ((sk_OSSL_CMP_CERTSTATUS_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk), ossl_check_OSSL_CMP_CERTSTATUS_compfunc_type(cmp)))
+
+typedef struct ossl_cmp_itav_st OSSL_CMP_ITAV;
+DECLARE_ASN1_DUP_FUNCTION(OSSL_CMP_ITAV)
+SKM_DEFINE_STACK_OF_INTERNAL(OSSL_CMP_ITAV, OSSL_CMP_ITAV, OSSL_CMP_ITAV)
+#define sk_OSSL_CMP_ITAV_num(sk) OPENSSL_sk_num(ossl_check_const_OSSL_CMP_ITAV_sk_type(sk))
+#define sk_OSSL_CMP_ITAV_value(sk, idx) ((OSSL_CMP_ITAV *)OPENSSL_sk_value(ossl_check_const_OSSL_CMP_ITAV_sk_type(sk), (idx)))
+#define sk_OSSL_CMP_ITAV_new(cmp) ((STACK_OF(OSSL_CMP_ITAV) *)OPENSSL_sk_new(ossl_check_OSSL_CMP_ITAV_compfunc_type(cmp)))
+#define sk_OSSL_CMP_ITAV_new_null() ((STACK_OF(OSSL_CMP_ITAV) *)OPENSSL_sk_new_null())
+#define sk_OSSL_CMP_ITAV_new_reserve(cmp, n) ((STACK_OF(OSSL_CMP_ITAV) *)OPENSSL_sk_new_reserve(ossl_check_OSSL_CMP_ITAV_compfunc_type(cmp), (n)))
+#define sk_OSSL_CMP_ITAV_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OSSL_CMP_ITAV_sk_type(sk), (n))
+#define sk_OSSL_CMP_ITAV_free(sk) OPENSSL_sk_free(ossl_check_OSSL_CMP_ITAV_sk_type(sk))
+#define sk_OSSL_CMP_ITAV_zero(sk) OPENSSL_sk_zero(ossl_check_OSSL_CMP_ITAV_sk_type(sk))
+#define sk_OSSL_CMP_ITAV_delete(sk, i) ((OSSL_CMP_ITAV *)OPENSSL_sk_delete(ossl_check_OSSL_CMP_ITAV_sk_type(sk), (i)))
+#define sk_OSSL_CMP_ITAV_delete_ptr(sk, ptr) ((OSSL_CMP_ITAV *)OPENSSL_sk_delete_ptr(ossl_check_OSSL_CMP_ITAV_sk_type(sk), ossl_check_OSSL_CMP_ITAV_type(ptr)))
+#define sk_OSSL_CMP_ITAV_push(sk, ptr) OPENSSL_sk_push(ossl_check_OSSL_CMP_ITAV_sk_type(sk), ossl_check_OSSL_CMP_ITAV_type(ptr))
+#define sk_OSSL_CMP_ITAV_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_OSSL_CMP_ITAV_sk_type(sk), ossl_check_OSSL_CMP_ITAV_type(ptr))
+#define sk_OSSL_CMP_ITAV_pop(sk) ((OSSL_CMP_ITAV *)OPENSSL_sk_pop(ossl_check_OSSL_CMP_ITAV_sk_type(sk)))
+#define sk_OSSL_CMP_ITAV_shift(sk) ((OSSL_CMP_ITAV *)OPENSSL_sk_shift(ossl_check_OSSL_CMP_ITAV_sk_type(sk)))
+#define sk_OSSL_CMP_ITAV_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OSSL_CMP_ITAV_sk_type(sk),ossl_check_OSSL_CMP_ITAV_freefunc_type(freefunc))
+#define sk_OSSL_CMP_ITAV_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_OSSL_CMP_ITAV_sk_type(sk), ossl_check_OSSL_CMP_ITAV_type(ptr), (idx))
+#define sk_OSSL_CMP_ITAV_set(sk, idx, ptr) ((OSSL_CMP_ITAV *)OPENSSL_sk_set(ossl_check_OSSL_CMP_ITAV_sk_type(sk), (idx), ossl_check_OSSL_CMP_ITAV_type(ptr)))
+#define sk_OSSL_CMP_ITAV_find(sk, ptr) OPENSSL_sk_find(ossl_check_OSSL_CMP_ITAV_sk_type(sk), ossl_check_OSSL_CMP_ITAV_type(ptr))
+#define sk_OSSL_CMP_ITAV_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_OSSL_CMP_ITAV_sk_type(sk), ossl_check_OSSL_CMP_ITAV_type(ptr))
+#define sk_OSSL_CMP_ITAV_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OSSL_CMP_ITAV_sk_type(sk), ossl_check_OSSL_CMP_ITAV_type(ptr), pnum)
+#define sk_OSSL_CMP_ITAV_sort(sk) OPENSSL_sk_sort(ossl_check_OSSL_CMP_ITAV_sk_type(sk))
+#define sk_OSSL_CMP_ITAV_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OSSL_CMP_ITAV_sk_type(sk))
+#define sk_OSSL_CMP_ITAV_dup(sk) ((STACK_OF(OSSL_CMP_ITAV) *)OPENSSL_sk_dup(ossl_check_const_OSSL_CMP_ITAV_sk_type(sk)))
+#define sk_OSSL_CMP_ITAV_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OSSL_CMP_ITAV) *)OPENSSL_sk_deep_copy(ossl_check_const_OSSL_CMP_ITAV_sk_type(sk), ossl_check_OSSL_CMP_ITAV_copyfunc_type(copyfunc), ossl_check_OSSL_CMP_ITAV_freefunc_type(freefunc)))
+#define sk_OSSL_CMP_ITAV_set_cmp_func(sk, cmp) ((sk_OSSL_CMP_ITAV_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OSSL_CMP_ITAV_sk_type(sk), ossl_check_OSSL_CMP_ITAV_compfunc_type(cmp)))
+
+typedef struct ossl_cmp_revrepcontent_st OSSL_CMP_REVREPCONTENT;
+typedef struct ossl_cmp_pkisi_st OSSL_CMP_PKISI;
+DECLARE_ASN1_FUNCTIONS(OSSL_CMP_PKISI)
+DECLARE_ASN1_DUP_FUNCTION(OSSL_CMP_PKISI)
+SKM_DEFINE_STACK_OF_INTERNAL(OSSL_CMP_PKISI, OSSL_CMP_PKISI, OSSL_CMP_PKISI)
+#define sk_OSSL_CMP_PKISI_num(sk) OPENSSL_sk_num(ossl_check_const_OSSL_CMP_PKISI_sk_type(sk))
+#define sk_OSSL_CMP_PKISI_value(sk, idx) ((OSSL_CMP_PKISI *)OPENSSL_sk_value(ossl_check_const_OSSL_CMP_PKISI_sk_type(sk), (idx)))
+#define sk_OSSL_CMP_PKISI_new(cmp) ((STACK_OF(OSSL_CMP_PKISI) *)OPENSSL_sk_new(ossl_check_OSSL_CMP_PKISI_compfunc_type(cmp)))
+#define sk_OSSL_CMP_PKISI_new_null() ((STACK_OF(OSSL_CMP_PKISI) *)OPENSSL_sk_new_null())
+#define sk_OSSL_CMP_PKISI_new_reserve(cmp, n) ((STACK_OF(OSSL_CMP_PKISI) *)OPENSSL_sk_new_reserve(ossl_check_OSSL_CMP_PKISI_compfunc_type(cmp), (n)))
+#define sk_OSSL_CMP_PKISI_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OSSL_CMP_PKISI_sk_type(sk), (n))
+#define sk_OSSL_CMP_PKISI_free(sk) OPENSSL_sk_free(ossl_check_OSSL_CMP_PKISI_sk_type(sk))
+#define sk_OSSL_CMP_PKISI_zero(sk) OPENSSL_sk_zero(ossl_check_OSSL_CMP_PKISI_sk_type(sk))
+#define sk_OSSL_CMP_PKISI_delete(sk, i) ((OSSL_CMP_PKISI *)OPENSSL_sk_delete(ossl_check_OSSL_CMP_PKISI_sk_type(sk), (i)))
+#define sk_OSSL_CMP_PKISI_delete_ptr(sk, ptr) ((OSSL_CMP_PKISI *)OPENSSL_sk_delete_ptr(ossl_check_OSSL_CMP_PKISI_sk_type(sk), ossl_check_OSSL_CMP_PKISI_type(ptr)))
+#define sk_OSSL_CMP_PKISI_push(sk, ptr) OPENSSL_sk_push(ossl_check_OSSL_CMP_PKISI_sk_type(sk), ossl_check_OSSL_CMP_PKISI_type(ptr))
+#define sk_OSSL_CMP_PKISI_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_OSSL_CMP_PKISI_sk_type(sk), ossl_check_OSSL_CMP_PKISI_type(ptr))
+#define sk_OSSL_CMP_PKISI_pop(sk) ((OSSL_CMP_PKISI *)OPENSSL_sk_pop(ossl_check_OSSL_CMP_PKISI_sk_type(sk)))
+#define sk_OSSL_CMP_PKISI_shift(sk) ((OSSL_CMP_PKISI *)OPENSSL_sk_shift(ossl_check_OSSL_CMP_PKISI_sk_type(sk)))
+#define sk_OSSL_CMP_PKISI_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OSSL_CMP_PKISI_sk_type(sk),ossl_check_OSSL_CMP_PKISI_freefunc_type(freefunc))
+#define sk_OSSL_CMP_PKISI_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_OSSL_CMP_PKISI_sk_type(sk), ossl_check_OSSL_CMP_PKISI_type(ptr), (idx))
+#define sk_OSSL_CMP_PKISI_set(sk, idx, ptr) ((OSSL_CMP_PKISI *)OPENSSL_sk_set(ossl_check_OSSL_CMP_PKISI_sk_type(sk), (idx), ossl_check_OSSL_CMP_PKISI_type(ptr)))
+#define sk_OSSL_CMP_PKISI_find(sk, ptr) OPENSSL_sk_find(ossl_check_OSSL_CMP_PKISI_sk_type(sk), ossl_check_OSSL_CMP_PKISI_type(ptr))
+#define sk_OSSL_CMP_PKISI_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_OSSL_CMP_PKISI_sk_type(sk), ossl_check_OSSL_CMP_PKISI_type(ptr))
+#define sk_OSSL_CMP_PKISI_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OSSL_CMP_PKISI_sk_type(sk), ossl_check_OSSL_CMP_PKISI_type(ptr), pnum)
+#define sk_OSSL_CMP_PKISI_sort(sk) OPENSSL_sk_sort(ossl_check_OSSL_CMP_PKISI_sk_type(sk))
+#define sk_OSSL_CMP_PKISI_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OSSL_CMP_PKISI_sk_type(sk))
+#define sk_OSSL_CMP_PKISI_dup(sk) ((STACK_OF(OSSL_CMP_PKISI) *)OPENSSL_sk_dup(ossl_check_const_OSSL_CMP_PKISI_sk_type(sk)))
+#define sk_OSSL_CMP_PKISI_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OSSL_CMP_PKISI) *)OPENSSL_sk_deep_copy(ossl_check_const_OSSL_CMP_PKISI_sk_type(sk), ossl_check_OSSL_CMP_PKISI_copyfunc_type(copyfunc), ossl_check_OSSL_CMP_PKISI_freefunc_type(freefunc)))
+#define sk_OSSL_CMP_PKISI_set_cmp_func(sk, cmp) ((sk_OSSL_CMP_PKISI_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OSSL_CMP_PKISI_sk_type(sk), ossl_check_OSSL_CMP_PKISI_compfunc_type(cmp)))
+
+typedef struct ossl_cmp_certrepmessage_st OSSL_CMP_CERTREPMESSAGE;
+SKM_DEFINE_STACK_OF_INTERNAL(OSSL_CMP_CERTREPMESSAGE, OSSL_CMP_CERTREPMESSAGE, OSSL_CMP_CERTREPMESSAGE)
+#define sk_OSSL_CMP_CERTREPMESSAGE_num(sk) OPENSSL_sk_num(ossl_check_const_OSSL_CMP_CERTREPMESSAGE_sk_type(sk))
+#define sk_OSSL_CMP_CERTREPMESSAGE_value(sk, idx) ((OSSL_CMP_CERTREPMESSAGE *)OPENSSL_sk_value(ossl_check_const_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), (idx)))
+#define sk_OSSL_CMP_CERTREPMESSAGE_new(cmp) ((STACK_OF(OSSL_CMP_CERTREPMESSAGE) *)OPENSSL_sk_new(ossl_check_OSSL_CMP_CERTREPMESSAGE_compfunc_type(cmp)))
+#define sk_OSSL_CMP_CERTREPMESSAGE_new_null() ((STACK_OF(OSSL_CMP_CERTREPMESSAGE) *)OPENSSL_sk_new_null())
+#define sk_OSSL_CMP_CERTREPMESSAGE_new_reserve(cmp, n) ((STACK_OF(OSSL_CMP_CERTREPMESSAGE) *)OPENSSL_sk_new_reserve(ossl_check_OSSL_CMP_CERTREPMESSAGE_compfunc_type(cmp), (n)))
+#define sk_OSSL_CMP_CERTREPMESSAGE_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), (n))
+#define sk_OSSL_CMP_CERTREPMESSAGE_free(sk) OPENSSL_sk_free(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk))
+#define sk_OSSL_CMP_CERTREPMESSAGE_zero(sk) OPENSSL_sk_zero(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk))
+#define sk_OSSL_CMP_CERTREPMESSAGE_delete(sk, i) ((OSSL_CMP_CERTREPMESSAGE *)OPENSSL_sk_delete(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), (i)))
+#define sk_OSSL_CMP_CERTREPMESSAGE_delete_ptr(sk, ptr) ((OSSL_CMP_CERTREPMESSAGE *)OPENSSL_sk_delete_ptr(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), ossl_check_OSSL_CMP_CERTREPMESSAGE_type(ptr)))
+#define sk_OSSL_CMP_CERTREPMESSAGE_push(sk, ptr) OPENSSL_sk_push(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), ossl_check_OSSL_CMP_CERTREPMESSAGE_type(ptr))
+#define sk_OSSL_CMP_CERTREPMESSAGE_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), ossl_check_OSSL_CMP_CERTREPMESSAGE_type(ptr))
+#define sk_OSSL_CMP_CERTREPMESSAGE_pop(sk) ((OSSL_CMP_CERTREPMESSAGE *)OPENSSL_sk_pop(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk)))
+#define sk_OSSL_CMP_CERTREPMESSAGE_shift(sk) ((OSSL_CMP_CERTREPMESSAGE *)OPENSSL_sk_shift(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk)))
+#define sk_OSSL_CMP_CERTREPMESSAGE_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk),ossl_check_OSSL_CMP_CERTREPMESSAGE_freefunc_type(freefunc))
+#define sk_OSSL_CMP_CERTREPMESSAGE_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), ossl_check_OSSL_CMP_CERTREPMESSAGE_type(ptr), (idx))
+#define sk_OSSL_CMP_CERTREPMESSAGE_set(sk, idx, ptr) ((OSSL_CMP_CERTREPMESSAGE *)OPENSSL_sk_set(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), (idx), ossl_check_OSSL_CMP_CERTREPMESSAGE_type(ptr)))
+#define sk_OSSL_CMP_CERTREPMESSAGE_find(sk, ptr) OPENSSL_sk_find(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), ossl_check_OSSL_CMP_CERTREPMESSAGE_type(ptr))
+#define sk_OSSL_CMP_CERTREPMESSAGE_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), ossl_check_OSSL_CMP_CERTREPMESSAGE_type(ptr))
+#define sk_OSSL_CMP_CERTREPMESSAGE_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), ossl_check_OSSL_CMP_CERTREPMESSAGE_type(ptr), pnum)
+#define sk_OSSL_CMP_CERTREPMESSAGE_sort(sk) OPENSSL_sk_sort(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk))
+#define sk_OSSL_CMP_CERTREPMESSAGE_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OSSL_CMP_CERTREPMESSAGE_sk_type(sk))
+#define sk_OSSL_CMP_CERTREPMESSAGE_dup(sk) ((STACK_OF(OSSL_CMP_CERTREPMESSAGE) *)OPENSSL_sk_dup(ossl_check_const_OSSL_CMP_CERTREPMESSAGE_sk_type(sk)))
+#define sk_OSSL_CMP_CERTREPMESSAGE_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OSSL_CMP_CERTREPMESSAGE) *)OPENSSL_sk_deep_copy(ossl_check_const_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), ossl_check_OSSL_CMP_CERTREPMESSAGE_copyfunc_type(copyfunc), ossl_check_OSSL_CMP_CERTREPMESSAGE_freefunc_type(freefunc)))
+#define sk_OSSL_CMP_CERTREPMESSAGE_set_cmp_func(sk, cmp) ((sk_OSSL_CMP_CERTREPMESSAGE_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), ossl_check_OSSL_CMP_CERTREPMESSAGE_compfunc_type(cmp)))
+
+typedef struct ossl_cmp_pollrep_st OSSL_CMP_POLLREP;
+typedef STACK_OF(OSSL_CMP_POLLREP) OSSL_CMP_POLLREPCONTENT;
+typedef struct ossl_cmp_certresponse_st OSSL_CMP_CERTRESPONSE;
+SKM_DEFINE_STACK_OF_INTERNAL(OSSL_CMP_CERTRESPONSE, OSSL_CMP_CERTRESPONSE, OSSL_CMP_CERTRESPONSE)
+#define sk_OSSL_CMP_CERTRESPONSE_num(sk) OPENSSL_sk_num(ossl_check_const_OSSL_CMP_CERTRESPONSE_sk_type(sk))
+#define sk_OSSL_CMP_CERTRESPONSE_value(sk, idx) ((OSSL_CMP_CERTRESPONSE *)OPENSSL_sk_value(ossl_check_const_OSSL_CMP_CERTRESPONSE_sk_type(sk), (idx)))
+#define sk_OSSL_CMP_CERTRESPONSE_new(cmp) ((STACK_OF(OSSL_CMP_CERTRESPONSE) *)OPENSSL_sk_new(ossl_check_OSSL_CMP_CERTRESPONSE_compfunc_type(cmp)))
+#define sk_OSSL_CMP_CERTRESPONSE_new_null() ((STACK_OF(OSSL_CMP_CERTRESPONSE) *)OPENSSL_sk_new_null())
+#define sk_OSSL_CMP_CERTRESPONSE_new_reserve(cmp, n) ((STACK_OF(OSSL_CMP_CERTRESPONSE) *)OPENSSL_sk_new_reserve(ossl_check_OSSL_CMP_CERTRESPONSE_compfunc_type(cmp), (n)))
+#define sk_OSSL_CMP_CERTRESPONSE_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk), (n))
+#define sk_OSSL_CMP_CERTRESPONSE_free(sk) OPENSSL_sk_free(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk))
+#define sk_OSSL_CMP_CERTRESPONSE_zero(sk) OPENSSL_sk_zero(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk))
+#define sk_OSSL_CMP_CERTRESPONSE_delete(sk, i) ((OSSL_CMP_CERTRESPONSE *)OPENSSL_sk_delete(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk), (i)))
+#define sk_OSSL_CMP_CERTRESPONSE_delete_ptr(sk, ptr) ((OSSL_CMP_CERTRESPONSE *)OPENSSL_sk_delete_ptr(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk), ossl_check_OSSL_CMP_CERTRESPONSE_type(ptr)))
+#define sk_OSSL_CMP_CERTRESPONSE_push(sk, ptr) OPENSSL_sk_push(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk), ossl_check_OSSL_CMP_CERTRESPONSE_type(ptr))
+#define sk_OSSL_CMP_CERTRESPONSE_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk), ossl_check_OSSL_CMP_CERTRESPONSE_type(ptr))
+#define sk_OSSL_CMP_CERTRESPONSE_pop(sk) ((OSSL_CMP_CERTRESPONSE *)OPENSSL_sk_pop(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk)))
+#define sk_OSSL_CMP_CERTRESPONSE_shift(sk) ((OSSL_CMP_CERTRESPONSE *)OPENSSL_sk_shift(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk)))
+#define sk_OSSL_CMP_CERTRESPONSE_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk),ossl_check_OSSL_CMP_CERTRESPONSE_freefunc_type(freefunc))
+#define sk_OSSL_CMP_CERTRESPONSE_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk), ossl_check_OSSL_CMP_CERTRESPONSE_type(ptr), (idx))
+#define sk_OSSL_CMP_CERTRESPONSE_set(sk, idx, ptr) ((OSSL_CMP_CERTRESPONSE *)OPENSSL_sk_set(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk), (idx), ossl_check_OSSL_CMP_CERTRESPONSE_type(ptr)))
+#define sk_OSSL_CMP_CERTRESPONSE_find(sk, ptr) OPENSSL_sk_find(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk), ossl_check_OSSL_CMP_CERTRESPONSE_type(ptr))
+#define sk_OSSL_CMP_CERTRESPONSE_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk), ossl_check_OSSL_CMP_CERTRESPONSE_type(ptr))
+#define sk_OSSL_CMP_CERTRESPONSE_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk), ossl_check_OSSL_CMP_CERTRESPONSE_type(ptr), pnum)
+#define sk_OSSL_CMP_CERTRESPONSE_sort(sk) OPENSSL_sk_sort(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk))
+#define sk_OSSL_CMP_CERTRESPONSE_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OSSL_CMP_CERTRESPONSE_sk_type(sk))
+#define sk_OSSL_CMP_CERTRESPONSE_dup(sk) ((STACK_OF(OSSL_CMP_CERTRESPONSE) *)OPENSSL_sk_dup(ossl_check_const_OSSL_CMP_CERTRESPONSE_sk_type(sk)))
+#define sk_OSSL_CMP_CERTRESPONSE_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OSSL_CMP_CERTRESPONSE) *)OPENSSL_sk_deep_copy(ossl_check_const_OSSL_CMP_CERTRESPONSE_sk_type(sk), ossl_check_OSSL_CMP_CERTRESPONSE_copyfunc_type(copyfunc), ossl_check_OSSL_CMP_CERTRESPONSE_freefunc_type(freefunc)))
+#define sk_OSSL_CMP_CERTRESPONSE_set_cmp_func(sk, cmp) ((sk_OSSL_CMP_CERTRESPONSE_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk), ossl_check_OSSL_CMP_CERTRESPONSE_compfunc_type(cmp)))
+
+typedef STACK_OF(ASN1_UTF8STRING) OSSL_CMP_PKIFREETEXT;
+
+/*
+ * function DECLARATIONS
+ */
+
+/* from cmp_asn.c */
+OSSL_CMP_ITAV *OSSL_CMP_ITAV_create(ASN1_OBJECT *type, ASN1_TYPE *value);
+void OSSL_CMP_ITAV_set0(OSSL_CMP_ITAV *itav, ASN1_OBJECT *type,
+                        ASN1_TYPE *value);
+ASN1_OBJECT *OSSL_CMP_ITAV_get0_type(const OSSL_CMP_ITAV *itav);
+ASN1_TYPE *OSSL_CMP_ITAV_get0_value(const OSSL_CMP_ITAV *itav);
+int OSSL_CMP_ITAV_push0_stack_item(STACK_OF(OSSL_CMP_ITAV) **itav_sk_p,
+                                   OSSL_CMP_ITAV *itav);
+void OSSL_CMP_ITAV_free(OSSL_CMP_ITAV *itav);
+
+OSSL_CMP_ITAV *OSSL_CMP_ITAV_new0_certProfile(STACK_OF(ASN1_UTF8STRING)
+                                              *certProfile);
+int OSSL_CMP_ITAV_get0_certProfile(const OSSL_CMP_ITAV *itav,
+                                   STACK_OF(ASN1_UTF8STRING) **out);
+OSSL_CMP_ITAV *OSSL_CMP_ITAV_new_caCerts(const STACK_OF(X509) *caCerts);
+int OSSL_CMP_ITAV_get0_caCerts(const OSSL_CMP_ITAV *itav, STACK_OF(X509) **out);
+
+OSSL_CMP_ITAV *OSSL_CMP_ITAV_new_rootCaCert(const X509 *rootCaCert);
+int OSSL_CMP_ITAV_get0_rootCaCert(const OSSL_CMP_ITAV *itav, X509 **out);
+OSSL_CMP_ITAV *OSSL_CMP_ITAV_new_rootCaKeyUpdate(const X509 *newWithNew,
+                                                 const X509 *newWithOld,
+                                                 const X509 *oldWithNew);
+int OSSL_CMP_ITAV_get0_rootCaKeyUpdate(const OSSL_CMP_ITAV *itav,
+                                       X509 **newWithNew,
+                                       X509 **newWithOld,
+                                       X509 **oldWithNew);
+
+void OSSL_CMP_MSG_free(OSSL_CMP_MSG *msg);
+
+/* from cmp_ctx.c */
+OSSL_CMP_CTX *OSSL_CMP_CTX_new(OSSL_LIB_CTX *libctx, const char *propq);
+void OSSL_CMP_CTX_free(OSSL_CMP_CTX *ctx);
+int OSSL_CMP_CTX_reinit(OSSL_CMP_CTX *ctx);
+OSSL_LIB_CTX *OSSL_CMP_CTX_get0_libctx(const OSSL_CMP_CTX *ctx);
+const char *OSSL_CMP_CTX_get0_propq(const OSSL_CMP_CTX *ctx);
+/* CMP general options: */
+#  define OSSL_CMP_OPT_LOG_VERBOSITY 0
+/* CMP transfer options: */
+#  define OSSL_CMP_OPT_KEEP_ALIVE    10
+#  define OSSL_CMP_OPT_MSG_TIMEOUT   11
+#  define OSSL_CMP_OPT_TOTAL_TIMEOUT 12
+#  define OSSL_CMP_OPT_USE_TLS       13
+/* CMP request options: */
+#  define OSSL_CMP_OPT_VALIDITY_DAYS 20
+#  define OSSL_CMP_OPT_SUBJECTALTNAME_NODEFAULT 21
+#  define OSSL_CMP_OPT_SUBJECTALTNAME_CRITICAL 22
+#  define OSSL_CMP_OPT_POLICIES_CRITICAL 23
+#  define OSSL_CMP_OPT_POPO_METHOD 24
+#  define OSSL_CMP_OPT_IMPLICIT_CONFIRM 25
+#  define OSSL_CMP_OPT_DISABLE_CONFIRM 26
+#  define OSSL_CMP_OPT_REVOCATION_REASON 27
+/* CMP protection options: */
+#  define OSSL_CMP_OPT_UNPROTECTED_SEND 30
+#  define OSSL_CMP_OPT_UNPROTECTED_ERRORS 31
+#  define OSSL_CMP_OPT_OWF_ALGNID 32
+#  define OSSL_CMP_OPT_MAC_ALGNID 33
+#  define OSSL_CMP_OPT_DIGEST_ALGNID 34
+#  define OSSL_CMP_OPT_IGNORE_KEYUSAGE 35
+#  define OSSL_CMP_OPT_PERMIT_TA_IN_EXTRACERTS_FOR_IR 36
+#  define OSSL_CMP_OPT_NO_CACHE_EXTRACERTS 37
+int OSSL_CMP_CTX_set_option(OSSL_CMP_CTX *ctx, int opt, int val);
+int OSSL_CMP_CTX_get_option(const OSSL_CMP_CTX *ctx, int opt);
+/* CMP-specific callback for logging and outputting the error queue: */
+int OSSL_CMP_CTX_set_log_cb(OSSL_CMP_CTX *ctx, OSSL_CMP_log_cb_t cb);
+#  define OSSL_CMP_CTX_set_log_verbosity(ctx, level) \
+    OSSL_CMP_CTX_set_option(ctx, OSSL_CMP_OPT_LOG_VERBOSITY, level)
+void OSSL_CMP_CTX_print_errors(const OSSL_CMP_CTX *ctx);
+/* message transfer: */
+int OSSL_CMP_CTX_set1_serverPath(OSSL_CMP_CTX *ctx, const char *path);
+int OSSL_CMP_CTX_set1_server(OSSL_CMP_CTX *ctx, const char *address);
+int OSSL_CMP_CTX_set_serverPort(OSSL_CMP_CTX *ctx, int port);
+int OSSL_CMP_CTX_set1_proxy(OSSL_CMP_CTX *ctx, const char *name);
+int OSSL_CMP_CTX_set1_no_proxy(OSSL_CMP_CTX *ctx, const char *names);
+#   ifndef OPENSSL_NO_HTTP
+int OSSL_CMP_CTX_set_http_cb(OSSL_CMP_CTX *ctx, OSSL_HTTP_bio_cb_t cb);
+int OSSL_CMP_CTX_set_http_cb_arg(OSSL_CMP_CTX *ctx, void *arg);
+void *OSSL_CMP_CTX_get_http_cb_arg(const OSSL_CMP_CTX *ctx);
+#   endif
+typedef OSSL_CMP_MSG *(*OSSL_CMP_transfer_cb_t) (OSSL_CMP_CTX *ctx,
+                                                 const OSSL_CMP_MSG *req);
+int OSSL_CMP_CTX_set_transfer_cb(OSSL_CMP_CTX *ctx, OSSL_CMP_transfer_cb_t cb);
+int OSSL_CMP_CTX_set_transfer_cb_arg(OSSL_CMP_CTX *ctx, void *arg);
+void *OSSL_CMP_CTX_get_transfer_cb_arg(const OSSL_CMP_CTX *ctx);
+/* server authentication: */
+int OSSL_CMP_CTX_set1_srvCert(OSSL_CMP_CTX *ctx, X509 *cert);
+int OSSL_CMP_CTX_set1_expected_sender(OSSL_CMP_CTX *ctx, const X509_NAME *name);
+int OSSL_CMP_CTX_set0_trustedStore(OSSL_CMP_CTX *ctx, X509_STORE *store);
+#  define OSSL_CMP_CTX_set0_trusted OSSL_CMP_CTX_set0_trustedStore
+X509_STORE *OSSL_CMP_CTX_get0_trustedStore(const OSSL_CMP_CTX *ctx);
+#  define OSSL_CMP_CTX_get0_trusted OSSL_CMP_CTX_get0_trustedStore
+int OSSL_CMP_CTX_set1_untrusted(OSSL_CMP_CTX *ctx, STACK_OF(X509) *certs);
+STACK_OF(X509) *OSSL_CMP_CTX_get0_untrusted(const OSSL_CMP_CTX *ctx);
+/* client authentication: */
+int OSSL_CMP_CTX_set1_cert(OSSL_CMP_CTX *ctx, X509 *cert);
+int OSSL_CMP_CTX_build_cert_chain(OSSL_CMP_CTX *ctx, X509_STORE *own_trusted,
+                                  STACK_OF(X509) *candidates);
+int OSSL_CMP_CTX_set1_pkey(OSSL_CMP_CTX *ctx, EVP_PKEY *pkey);
+int OSSL_CMP_CTX_set1_referenceValue(OSSL_CMP_CTX *ctx,
+                                     const unsigned char *ref, int len);
+int OSSL_CMP_CTX_set1_secretValue(OSSL_CMP_CTX *ctx,
+                                  const unsigned char *sec, int len);
+/* CMP message header and extra certificates: */
+int OSSL_CMP_CTX_set1_recipient(OSSL_CMP_CTX *ctx, const X509_NAME *name);
+int OSSL_CMP_CTX_push0_geninfo_ITAV(OSSL_CMP_CTX *ctx, OSSL_CMP_ITAV *itav);
+int OSSL_CMP_CTX_reset_geninfo_ITAVs(OSSL_CMP_CTX *ctx);
+STACK_OF(OSSL_CMP_ITAV)
+    *OSSL_CMP_CTX_get0_geninfo_ITAVs(const OSSL_CMP_CTX *ctx);
+int OSSL_CMP_CTX_set1_extraCertsOut(OSSL_CMP_CTX *ctx,
+                                    STACK_OF(X509) *extraCertsOut);
+/* certificate template: */
+int OSSL_CMP_CTX_set0_newPkey(OSSL_CMP_CTX *ctx, int priv, EVP_PKEY *pkey);
+EVP_PKEY *OSSL_CMP_CTX_get0_newPkey(const OSSL_CMP_CTX *ctx, int priv);
+int OSSL_CMP_CTX_set1_issuer(OSSL_CMP_CTX *ctx, const X509_NAME *name);
+int OSSL_CMP_CTX_set1_serialNumber(OSSL_CMP_CTX *ctx, const ASN1_INTEGER *sn);
+int OSSL_CMP_CTX_set1_subjectName(OSSL_CMP_CTX *ctx, const X509_NAME *name);
+int OSSL_CMP_CTX_push1_subjectAltName(OSSL_CMP_CTX *ctx,
+                                      const GENERAL_NAME *name);
+int OSSL_CMP_CTX_set0_reqExtensions(OSSL_CMP_CTX *ctx, X509_EXTENSIONS *exts);
+int OSSL_CMP_CTX_reqExtensions_have_SAN(OSSL_CMP_CTX *ctx);
+int OSSL_CMP_CTX_push0_policy(OSSL_CMP_CTX *ctx, POLICYINFO *pinfo);
+int OSSL_CMP_CTX_set1_oldCert(OSSL_CMP_CTX *ctx, X509 *cert);
+int OSSL_CMP_CTX_set1_p10CSR(OSSL_CMP_CTX *ctx, const X509_REQ *csr);
+/* misc body contents: */
+int OSSL_CMP_CTX_push0_genm_ITAV(OSSL_CMP_CTX *ctx, OSSL_CMP_ITAV *itav);
+/* certificate confirmation: */
+typedef int (*OSSL_CMP_certConf_cb_t) (OSSL_CMP_CTX *ctx, X509 *cert,
+                                       int fail_info, const char **txt);
+int OSSL_CMP_certConf_cb(OSSL_CMP_CTX *ctx, X509 *cert, int fail_info,
+                         const char **text);
+int OSSL_CMP_CTX_set_certConf_cb(OSSL_CMP_CTX *ctx, OSSL_CMP_certConf_cb_t cb);
+int OSSL_CMP_CTX_set_certConf_cb_arg(OSSL_CMP_CTX *ctx, void *arg);
+void *OSSL_CMP_CTX_get_certConf_cb_arg(const OSSL_CMP_CTX *ctx);
+/* result fetching: */
+int OSSL_CMP_CTX_get_status(const OSSL_CMP_CTX *ctx);
+OSSL_CMP_PKIFREETEXT *OSSL_CMP_CTX_get0_statusString(const OSSL_CMP_CTX *ctx);
+int OSSL_CMP_CTX_get_failInfoCode(const OSSL_CMP_CTX *ctx);
+#  define OSSL_CMP_PKISI_BUFLEN 1024
+X509 *OSSL_CMP_CTX_get0_validatedSrvCert(const OSSL_CMP_CTX *ctx);
+X509 *OSSL_CMP_CTX_get0_newCert(const OSSL_CMP_CTX *ctx);
+STACK_OF(X509) *OSSL_CMP_CTX_get1_newChain(const OSSL_CMP_CTX *ctx);
+STACK_OF(X509) *OSSL_CMP_CTX_get1_caPubs(const OSSL_CMP_CTX *ctx);
+STACK_OF(X509) *OSSL_CMP_CTX_get1_extraCertsIn(const OSSL_CMP_CTX *ctx);
+int OSSL_CMP_CTX_set1_transactionID(OSSL_CMP_CTX *ctx,
+                                    const ASN1_OCTET_STRING *id);
+int OSSL_CMP_CTX_set1_senderNonce(OSSL_CMP_CTX *ctx,
+                                  const ASN1_OCTET_STRING *nonce);
+
+/* from cmp_status.c */
+char *OSSL_CMP_CTX_snprint_PKIStatus(const OSSL_CMP_CTX *ctx, char *buf,
+                                     size_t bufsize);
+char *OSSL_CMP_snprint_PKIStatusInfo(const OSSL_CMP_PKISI *statusInfo,
+                                     char *buf, size_t bufsize);
+OSSL_CMP_PKISI *
+OSSL_CMP_STATUSINFO_new(int status, int fail_info, const char *text);
+
+/* from cmp_hdr.c */
+ASN1_OCTET_STRING *OSSL_CMP_HDR_get0_transactionID(const
+                                                   OSSL_CMP_PKIHEADER *hdr);
+ASN1_OCTET_STRING *OSSL_CMP_HDR_get0_recipNonce(const OSSL_CMP_PKIHEADER *hdr);
+STACK_OF(OSSL_CMP_ITAV)
+    *OSSL_CMP_HDR_get0_geninfo_ITAVs(const OSSL_CMP_PKIHEADER *hdr);
+
+/* from cmp_msg.c */
+OSSL_CMP_PKIHEADER *OSSL_CMP_MSG_get0_header(const OSSL_CMP_MSG *msg);
+int OSSL_CMP_MSG_get_bodytype(const OSSL_CMP_MSG *msg);
+X509_PUBKEY *OSSL_CMP_MSG_get0_certreq_publickey(const OSSL_CMP_MSG *msg);
+int OSSL_CMP_MSG_update_transactionID(OSSL_CMP_CTX *ctx, OSSL_CMP_MSG *msg);
+int OSSL_CMP_MSG_update_recipNonce(OSSL_CMP_CTX *ctx, OSSL_CMP_MSG *msg);
+OSSL_CRMF_MSG *OSSL_CMP_CTX_setup_CRM(OSSL_CMP_CTX *ctx, int for_KUR, int rid);
+OSSL_CMP_MSG *OSSL_CMP_MSG_read(const char *file, OSSL_LIB_CTX *libctx,
+                                const char *propq);
+int OSSL_CMP_MSG_write(const char *file, const OSSL_CMP_MSG *msg);
+OSSL_CMP_MSG *d2i_OSSL_CMP_MSG_bio(BIO *bio, OSSL_CMP_MSG **msg);
+int i2d_OSSL_CMP_MSG_bio(BIO *bio, const OSSL_CMP_MSG *msg);
+
+/* from cmp_vfy.c */
+int OSSL_CMP_validate_msg(OSSL_CMP_CTX *ctx, const OSSL_CMP_MSG *msg);
+int OSSL_CMP_validate_cert_path(const OSSL_CMP_CTX *ctx,
+                                X509_STORE *trusted_store, X509 *cert);
+
+/* from cmp_http.c */
+#   ifndef OPENSSL_NO_HTTP
+OSSL_CMP_MSG *OSSL_CMP_MSG_http_perform(OSSL_CMP_CTX *ctx,
+                                        const OSSL_CMP_MSG *req);
+#   endif
+
+/* from cmp_server.c */
+typedef struct ossl_cmp_srv_ctx_st OSSL_CMP_SRV_CTX;
+OSSL_CMP_MSG *OSSL_CMP_SRV_process_request(OSSL_CMP_SRV_CTX *srv_ctx,
+                                           const OSSL_CMP_MSG *req);
+OSSL_CMP_MSG * OSSL_CMP_CTX_server_perform(OSSL_CMP_CTX *client_ctx,
+                                           const OSSL_CMP_MSG *req);
+OSSL_CMP_SRV_CTX *OSSL_CMP_SRV_CTX_new(OSSL_LIB_CTX *libctx, const char *propq);
+void OSSL_CMP_SRV_CTX_free(OSSL_CMP_SRV_CTX *srv_ctx);
+typedef OSSL_CMP_PKISI *(*OSSL_CMP_SRV_cert_request_cb_t)
+    (OSSL_CMP_SRV_CTX *srv_ctx, const OSSL_CMP_MSG *req, int certReqId,
+     const OSSL_CRMF_MSG *crm, const X509_REQ *p10cr,
+     X509 **certOut, STACK_OF(X509) **chainOut, STACK_OF(X509) **caPubs);
+typedef OSSL_CMP_PKISI *(*OSSL_CMP_SRV_rr_cb_t)(OSSL_CMP_SRV_CTX *srv_ctx,
+                                                const OSSL_CMP_MSG *req,
+                                                const X509_NAME *issuer,
+                                                const ASN1_INTEGER *serial);
+typedef int (*OSSL_CMP_SRV_genm_cb_t)(OSSL_CMP_SRV_CTX *srv_ctx,
+                                      const OSSL_CMP_MSG *req,
+                                      const STACK_OF(OSSL_CMP_ITAV) *in,
+                                      STACK_OF(OSSL_CMP_ITAV) **out);
+typedef void (*OSSL_CMP_SRV_error_cb_t)(OSSL_CMP_SRV_CTX *srv_ctx,
+                                        const OSSL_CMP_MSG *req,
+                                        const OSSL_CMP_PKISI *statusInfo,
+                                        const ASN1_INTEGER *errorCode,
+                                        const OSSL_CMP_PKIFREETEXT *errDetails);
+typedef int (*OSSL_CMP_SRV_certConf_cb_t)(OSSL_CMP_SRV_CTX *srv_ctx,
+                                          const OSSL_CMP_MSG *req,
+                                          int certReqId,
+                                          const ASN1_OCTET_STRING *certHash,
+                                          const OSSL_CMP_PKISI *si);
+typedef int (*OSSL_CMP_SRV_pollReq_cb_t)(OSSL_CMP_SRV_CTX *srv_ctx,
+                                         const OSSL_CMP_MSG *req, int certReqId,
+                                         OSSL_CMP_MSG **certReq,
+                                         int64_t *check_after);
+int OSSL_CMP_SRV_CTX_init(OSSL_CMP_SRV_CTX *srv_ctx, void *custom_ctx,
+                          OSSL_CMP_SRV_cert_request_cb_t process_cert_request,
+                          OSSL_CMP_SRV_rr_cb_t process_rr,
+                          OSSL_CMP_SRV_genm_cb_t process_genm,
+                          OSSL_CMP_SRV_error_cb_t process_error,
+                          OSSL_CMP_SRV_certConf_cb_t process_certConf,
+                          OSSL_CMP_SRV_pollReq_cb_t process_pollReq);
+typedef int (*OSSL_CMP_SRV_delayed_delivery_cb_t)(OSSL_CMP_SRV_CTX *srv_ctx,
+                                                  const OSSL_CMP_MSG *req);
+typedef int (*OSSL_CMP_SRV_clean_transaction_cb_t)(OSSL_CMP_SRV_CTX *srv_ctx,
+                                                   const ASN1_OCTET_STRING *id);
+int OSSL_CMP_SRV_CTX_init_trans(OSSL_CMP_SRV_CTX *srv_ctx,
+                                OSSL_CMP_SRV_delayed_delivery_cb_t delay,
+                                OSSL_CMP_SRV_clean_transaction_cb_t clean);
+OSSL_CMP_CTX *OSSL_CMP_SRV_CTX_get0_cmp_ctx(const OSSL_CMP_SRV_CTX *srv_ctx);
+void *OSSL_CMP_SRV_CTX_get0_custom_ctx(const OSSL_CMP_SRV_CTX *srv_ctx);
+int OSSL_CMP_SRV_CTX_set_send_unprotected_errors(OSSL_CMP_SRV_CTX *srv_ctx,
+                                                 int val);
+int OSSL_CMP_SRV_CTX_set_accept_unprotected(OSSL_CMP_SRV_CTX *srv_ctx, int val);
+int OSSL_CMP_SRV_CTX_set_accept_raverified(OSSL_CMP_SRV_CTX *srv_ctx, int val);
+int OSSL_CMP_SRV_CTX_set_grant_implicit_confirm(OSSL_CMP_SRV_CTX *srv_ctx,
+                                                int val);
+
+/* from cmp_client.c */
+X509 *OSSL_CMP_exec_certreq(OSSL_CMP_CTX *ctx, int req_type,
+                            const OSSL_CRMF_MSG *crm);
+#  define OSSL_CMP_IR    0
+#  define OSSL_CMP_CR    2
+#  define OSSL_CMP_P10CR 4
+#  define OSSL_CMP_KUR   7
+#  define OSSL_CMP_GENM  21
+#  define OSSL_CMP_ERROR 23
+#  define OSSL_CMP_exec_IR_ses(ctx) \
+    OSSL_CMP_exec_certreq(ctx, OSSL_CMP_IR, NULL)
+#  define OSSL_CMP_exec_CR_ses(ctx) \
+    OSSL_CMP_exec_certreq(ctx, OSSL_CMP_CR, NULL)
+#  define OSSL_CMP_exec_P10CR_ses(ctx) \
+    OSSL_CMP_exec_certreq(ctx, OSSL_CMP_P10CR, NULL)
+#  define OSSL_CMP_exec_KUR_ses(ctx) \
+    OSSL_CMP_exec_certreq(ctx, OSSL_CMP_KUR, NULL)
+int OSSL_CMP_try_certreq(OSSL_CMP_CTX *ctx, int req_type,
+                         const OSSL_CRMF_MSG *crm, int *checkAfter);
+int OSSL_CMP_exec_RR_ses(OSSL_CMP_CTX *ctx);
+STACK_OF(OSSL_CMP_ITAV) *OSSL_CMP_exec_GENM_ses(OSSL_CMP_CTX *ctx);
+
+/* from cmp_genm.c */
+int OSSL_CMP_get1_caCerts(OSSL_CMP_CTX *ctx, STACK_OF(X509) **out);
+int OSSL_CMP_get1_rootCaKeyUpdate(OSSL_CMP_CTX *ctx,
+                                  const X509 *oldWithOld, X509 **newWithNew,
+                                  X509 **newWithOld, X509 **oldWithNew);
+
+#  ifdef  __cplusplus
+}
+#  endif
+# endif /* !defined(OPENSSL_NO_CMP) */
+#endif /* !defined(OPENSSL_CMP_H) */
diff --git a/src/include/openssl/cmp_util.h b/src/include/openssl/cmp_util.h
new file mode 100644
index 0000000..9a16892
--- /dev/null
+++ b/src/include/openssl/cmp_util.h
@@ -0,0 +1,56 @@
+/*
+ * Copyright 2007-2021 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright Nokia 2007-2019
+ * Copyright Siemens AG 2015-2019
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_CMP_UTIL_H
+# define OPENSSL_CMP_UTIL_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# ifndef OPENSSL_NO_CMP
+
+#  include <openssl/macros.h>
+#  include <openssl/trace.h>
+
+#  ifdef __cplusplus
+extern "C" {
+#  endif
+
+int  OSSL_CMP_log_open(void);
+void OSSL_CMP_log_close(void);
+#  define OSSL_CMP_LOG_PREFIX "CMP "
+
+/*
+ * generalized logging/error callback mirroring the severity levels of syslog.h
+ */
+typedef int OSSL_CMP_severity;
+#  define OSSL_CMP_LOG_EMERG   0
+#  define OSSL_CMP_LOG_ALERT   1
+#  define OSSL_CMP_LOG_CRIT    2
+#  define OSSL_CMP_LOG_ERR     3
+#  define OSSL_CMP_LOG_WARNING 4
+#  define OSSL_CMP_LOG_NOTICE  5
+#  define OSSL_CMP_LOG_INFO    6
+#  define OSSL_CMP_LOG_DEBUG   7
+#  define OSSL_CMP_LOG_TRACE   8
+#  define OSSL_CMP_LOG_MAX     OSSL_CMP_LOG_TRACE
+typedef int (*OSSL_CMP_log_cb_t)(const char *func, const char *file, int line,
+                                 OSSL_CMP_severity level, const char *msg);
+
+int OSSL_CMP_print_to_bio(BIO *bio, const char *component, const char *file,
+                          int line, OSSL_CMP_severity level, const char *msg);
+/* use of the logging callback for outputting error queue */
+void OSSL_CMP_print_errors_cb(OSSL_CMP_log_cb_t log_fn);
+
+#  ifdef  __cplusplus
+}
+#  endif
+# endif /* !defined(OPENSSL_NO_CMP) */
+#endif /* !defined(OPENSSL_CMP_UTIL_H) */
diff --git a/src/include/openssl/cmperr.h b/src/include/openssl/cmperr.h
new file mode 100644
index 0000000..0d876e5
--- /dev/null
+++ b/src/include/openssl/cmperr.h
@@ -0,0 +1,125 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2024 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_CMPERR_H
+# define OPENSSL_CMPERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+# ifndef OPENSSL_NO_CMP
+
+
+/*
+ * CMP reason codes.
+ */
+#  define CMP_R_ALGORITHM_NOT_SUPPORTED                    139
+#  define CMP_R_BAD_CHECKAFTER_IN_POLLREP                  167
+#  define CMP_R_BAD_REQUEST_ID                             108
+#  define CMP_R_CERTHASH_UNMATCHED                         156
+#  define CMP_R_CERTID_NOT_FOUND                           109
+#  define CMP_R_CERTIFICATE_NOT_ACCEPTED                   169
+#  define CMP_R_CERTIFICATE_NOT_FOUND                      112
+#  define CMP_R_CERTREQMSG_NOT_FOUND                       157
+#  define CMP_R_CERTRESPONSE_NOT_FOUND                     113
+#  define CMP_R_CERT_AND_KEY_DO_NOT_MATCH                  114
+#  define CMP_R_CHECKAFTER_OUT_OF_RANGE                    181
+#  define CMP_R_ENCOUNTERED_KEYUPDATEWARNING               176
+#  define CMP_R_ENCOUNTERED_WAITING                        162
+#  define CMP_R_ERROR_CALCULATING_PROTECTION               115
+#  define CMP_R_ERROR_CREATING_CERTCONF                    116
+#  define CMP_R_ERROR_CREATING_CERTREP                     117
+#  define CMP_R_ERROR_CREATING_CERTREQ                     163
+#  define CMP_R_ERROR_CREATING_ERROR                       118
+#  define CMP_R_ERROR_CREATING_GENM                        119
+#  define CMP_R_ERROR_CREATING_GENP                        120
+#  define CMP_R_ERROR_CREATING_PKICONF                     122
+#  define CMP_R_ERROR_CREATING_POLLREP                     123
+#  define CMP_R_ERROR_CREATING_POLLREQ                     124
+#  define CMP_R_ERROR_CREATING_RP                          125
+#  define CMP_R_ERROR_CREATING_RR                          126
+#  define CMP_R_ERROR_PARSING_PKISTATUS                    107
+#  define CMP_R_ERROR_PROCESSING_MESSAGE                   158
+#  define CMP_R_ERROR_PROTECTING_MESSAGE                   127
+#  define CMP_R_ERROR_SETTING_CERTHASH                     128
+#  define CMP_R_ERROR_UNEXPECTED_CERTCONF                  160
+#  define CMP_R_ERROR_VALIDATING_PROTECTION                140
+#  define CMP_R_ERROR_VALIDATING_SIGNATURE                 171
+#  define CMP_R_EXPECTED_POLLREQ                           104
+#  define CMP_R_FAILED_BUILDING_OWN_CHAIN                  164
+#  define CMP_R_FAILED_EXTRACTING_PUBKEY                   141
+#  define CMP_R_FAILURE_OBTAINING_RANDOM                   110
+#  define CMP_R_FAIL_INFO_OUT_OF_RANGE                     129
+#  define CMP_R_GETTING_GENP                               192
+#  define CMP_R_INVALID_ARGS                               100
+#  define CMP_R_INVALID_GENP                               193
+#  define CMP_R_INVALID_OPTION                             174
+#  define CMP_R_INVALID_ROOTCAKEYUPDATE                    195
+#  define CMP_R_MISSING_CERTID                             165
+#  define CMP_R_MISSING_KEY_INPUT_FOR_CREATING_PROTECTION  130
+#  define CMP_R_MISSING_KEY_USAGE_DIGITALSIGNATURE         142
+#  define CMP_R_MISSING_P10CSR                             121
+#  define CMP_R_MISSING_PBM_SECRET                         166
+#  define CMP_R_MISSING_PRIVATE_KEY                        131
+#  define CMP_R_MISSING_PRIVATE_KEY_FOR_POPO               190
+#  define CMP_R_MISSING_PROTECTION                         143
+#  define CMP_R_MISSING_PUBLIC_KEY                         183
+#  define CMP_R_MISSING_REFERENCE_CERT                     168
+#  define CMP_R_MISSING_SECRET                             178
+#  define CMP_R_MISSING_SENDER_IDENTIFICATION              111
+#  define CMP_R_MISSING_TRUST_ANCHOR                       179
+#  define CMP_R_MISSING_TRUST_STORE                        144
+#  define CMP_R_MULTIPLE_REQUESTS_NOT_SUPPORTED            161
+#  define CMP_R_MULTIPLE_RESPONSES_NOT_SUPPORTED           170
+#  define CMP_R_MULTIPLE_SAN_SOURCES                       102
+#  define CMP_R_NO_STDIO                                   194
+#  define CMP_R_NO_SUITABLE_SENDER_CERT                    145
+#  define CMP_R_NULL_ARGUMENT                              103
+#  define CMP_R_PKIBODY_ERROR                              146
+#  define CMP_R_PKISTATUSINFO_NOT_FOUND                    132
+#  define CMP_R_POLLING_FAILED                             172
+#  define CMP_R_POTENTIALLY_INVALID_CERTIFICATE            147
+#  define CMP_R_RECEIVED_ERROR                             180
+#  define CMP_R_RECIPNONCE_UNMATCHED                       148
+#  define CMP_R_REQUEST_NOT_ACCEPTED                       149
+#  define CMP_R_REQUEST_REJECTED_BY_SERVER                 182
+#  define CMP_R_SENDER_GENERALNAME_TYPE_NOT_SUPPORTED      150
+#  define CMP_R_SRVCERT_DOES_NOT_VALIDATE_MSG              151
+#  define CMP_R_TOTAL_TIMEOUT                              184
+#  define CMP_R_TRANSACTIONID_UNMATCHED                    152
+#  define CMP_R_TRANSFER_ERROR                             159
+#  define CMP_R_UNCLEAN_CTX                                191
+#  define CMP_R_UNEXPECTED_CERTPROFILE                     196
+#  define CMP_R_UNEXPECTED_PKIBODY                         133
+#  define CMP_R_UNEXPECTED_PKISTATUS                       185
+#  define CMP_R_UNEXPECTED_POLLREQ                         105
+#  define CMP_R_UNEXPECTED_PVNO                            153
+#  define CMP_R_UNEXPECTED_SENDER                          106
+#  define CMP_R_UNKNOWN_ALGORITHM_ID                       134
+#  define CMP_R_UNKNOWN_CERT_TYPE                          135
+#  define CMP_R_UNKNOWN_PKISTATUS                          186
+#  define CMP_R_UNSUPPORTED_ALGORITHM                      136
+#  define CMP_R_UNSUPPORTED_KEY_TYPE                       137
+#  define CMP_R_UNSUPPORTED_PKIBODY                        101
+#  define CMP_R_UNSUPPORTED_PROTECTION_ALG_DHBASEDMAC      154
+#  define CMP_R_VALUE_TOO_LARGE                            175
+#  define CMP_R_VALUE_TOO_SMALL                            177
+#  define CMP_R_WRONG_ALGORITHM_OID                        138
+#  define CMP_R_WRONG_CERTID                               189
+#  define CMP_R_WRONG_CERTID_IN_RP                         187
+#  define CMP_R_WRONG_PBM_VALUE                            155
+#  define CMP_R_WRONG_RP_COMPONENT_COUNT                   188
+#  define CMP_R_WRONG_SERIAL_IN_RP                         173
+
+# endif
+#endif
diff --git a/src/include/openssl/cms.h b/src/include/openssl/cms.h
new file mode 100644
index 0000000..a91c1f5
--- /dev/null
+++ b/src/include/openssl/cms.h
@@ -0,0 +1,508 @@
+/*
+ * WARNING: do not edit!
+ * Generated by makefile from include\openssl\cms.h.in
+ *
+ * Copyright 2008-2022 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+
+
+#ifndef OPENSSL_CMS_H
+# define OPENSSL_CMS_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_CMS_H
+# endif
+
+# include <openssl/opensslconf.h>
+
+# ifndef OPENSSL_NO_CMS
+# include <openssl/x509.h>
+# include <openssl/x509v3.h>
+# include <openssl/cmserr.h>
+# ifdef __cplusplus
+extern "C" {
+# endif
+
+typedef struct CMS_EnvelopedData_st CMS_EnvelopedData;
+typedef struct CMS_ContentInfo_st CMS_ContentInfo;
+typedef struct CMS_SignerInfo_st CMS_SignerInfo;
+typedef struct CMS_SignedData_st CMS_SignedData;
+typedef struct CMS_CertificateChoices CMS_CertificateChoices;
+typedef struct CMS_RevocationInfoChoice_st CMS_RevocationInfoChoice;
+typedef struct CMS_RecipientInfo_st CMS_RecipientInfo;
+typedef struct CMS_ReceiptRequest_st CMS_ReceiptRequest;
+typedef struct CMS_Receipt_st CMS_Receipt;
+typedef struct CMS_RecipientEncryptedKey_st CMS_RecipientEncryptedKey;
+typedef struct CMS_OtherKeyAttribute_st CMS_OtherKeyAttribute;
+
+SKM_DEFINE_STACK_OF_INTERNAL(CMS_SignerInfo, CMS_SignerInfo, CMS_SignerInfo)
+#define sk_CMS_SignerInfo_num(sk) OPENSSL_sk_num(ossl_check_const_CMS_SignerInfo_sk_type(sk))
+#define sk_CMS_SignerInfo_value(sk, idx) ((CMS_SignerInfo *)OPENSSL_sk_value(ossl_check_const_CMS_SignerInfo_sk_type(sk), (idx)))
+#define sk_CMS_SignerInfo_new(cmp) ((STACK_OF(CMS_SignerInfo) *)OPENSSL_sk_new(ossl_check_CMS_SignerInfo_compfunc_type(cmp)))
+#define sk_CMS_SignerInfo_new_null() ((STACK_OF(CMS_SignerInfo) *)OPENSSL_sk_new_null())
+#define sk_CMS_SignerInfo_new_reserve(cmp, n) ((STACK_OF(CMS_SignerInfo) *)OPENSSL_sk_new_reserve(ossl_check_CMS_SignerInfo_compfunc_type(cmp), (n)))
+#define sk_CMS_SignerInfo_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_CMS_SignerInfo_sk_type(sk), (n))
+#define sk_CMS_SignerInfo_free(sk) OPENSSL_sk_free(ossl_check_CMS_SignerInfo_sk_type(sk))
+#define sk_CMS_SignerInfo_zero(sk) OPENSSL_sk_zero(ossl_check_CMS_SignerInfo_sk_type(sk))
+#define sk_CMS_SignerInfo_delete(sk, i) ((CMS_SignerInfo *)OPENSSL_sk_delete(ossl_check_CMS_SignerInfo_sk_type(sk), (i)))
+#define sk_CMS_SignerInfo_delete_ptr(sk, ptr) ((CMS_SignerInfo *)OPENSSL_sk_delete_ptr(ossl_check_CMS_SignerInfo_sk_type(sk), ossl_check_CMS_SignerInfo_type(ptr)))
+#define sk_CMS_SignerInfo_push(sk, ptr) OPENSSL_sk_push(ossl_check_CMS_SignerInfo_sk_type(sk), ossl_check_CMS_SignerInfo_type(ptr))
+#define sk_CMS_SignerInfo_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_CMS_SignerInfo_sk_type(sk), ossl_check_CMS_SignerInfo_type(ptr))
+#define sk_CMS_SignerInfo_pop(sk) ((CMS_SignerInfo *)OPENSSL_sk_pop(ossl_check_CMS_SignerInfo_sk_type(sk)))
+#define sk_CMS_SignerInfo_shift(sk) ((CMS_SignerInfo *)OPENSSL_sk_shift(ossl_check_CMS_SignerInfo_sk_type(sk)))
+#define sk_CMS_SignerInfo_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_CMS_SignerInfo_sk_type(sk),ossl_check_CMS_SignerInfo_freefunc_type(freefunc))
+#define sk_CMS_SignerInfo_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_CMS_SignerInfo_sk_type(sk), ossl_check_CMS_SignerInfo_type(ptr), (idx))
+#define sk_CMS_SignerInfo_set(sk, idx, ptr) ((CMS_SignerInfo *)OPENSSL_sk_set(ossl_check_CMS_SignerInfo_sk_type(sk), (idx), ossl_check_CMS_SignerInfo_type(ptr)))
+#define sk_CMS_SignerInfo_find(sk, ptr) OPENSSL_sk_find(ossl_check_CMS_SignerInfo_sk_type(sk), ossl_check_CMS_SignerInfo_type(ptr))
+#define sk_CMS_SignerInfo_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_CMS_SignerInfo_sk_type(sk), ossl_check_CMS_SignerInfo_type(ptr))
+#define sk_CMS_SignerInfo_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_CMS_SignerInfo_sk_type(sk), ossl_check_CMS_SignerInfo_type(ptr), pnum)
+#define sk_CMS_SignerInfo_sort(sk) OPENSSL_sk_sort(ossl_check_CMS_SignerInfo_sk_type(sk))
+#define sk_CMS_SignerInfo_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_CMS_SignerInfo_sk_type(sk))
+#define sk_CMS_SignerInfo_dup(sk) ((STACK_OF(CMS_SignerInfo) *)OPENSSL_sk_dup(ossl_check_const_CMS_SignerInfo_sk_type(sk)))
+#define sk_CMS_SignerInfo_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(CMS_SignerInfo) *)OPENSSL_sk_deep_copy(ossl_check_const_CMS_SignerInfo_sk_type(sk), ossl_check_CMS_SignerInfo_copyfunc_type(copyfunc), ossl_check_CMS_SignerInfo_freefunc_type(freefunc)))
+#define sk_CMS_SignerInfo_set_cmp_func(sk, cmp) ((sk_CMS_SignerInfo_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_CMS_SignerInfo_sk_type(sk), ossl_check_CMS_SignerInfo_compfunc_type(cmp)))
+SKM_DEFINE_STACK_OF_INTERNAL(CMS_RecipientEncryptedKey, CMS_RecipientEncryptedKey, CMS_RecipientEncryptedKey)
+#define sk_CMS_RecipientEncryptedKey_num(sk) OPENSSL_sk_num(ossl_check_const_CMS_RecipientEncryptedKey_sk_type(sk))
+#define sk_CMS_RecipientEncryptedKey_value(sk, idx) ((CMS_RecipientEncryptedKey *)OPENSSL_sk_value(ossl_check_const_CMS_RecipientEncryptedKey_sk_type(sk), (idx)))
+#define sk_CMS_RecipientEncryptedKey_new(cmp) ((STACK_OF(CMS_RecipientEncryptedKey) *)OPENSSL_sk_new(ossl_check_CMS_RecipientEncryptedKey_compfunc_type(cmp)))
+#define sk_CMS_RecipientEncryptedKey_new_null() ((STACK_OF(CMS_RecipientEncryptedKey) *)OPENSSL_sk_new_null())
+#define sk_CMS_RecipientEncryptedKey_new_reserve(cmp, n) ((STACK_OF(CMS_RecipientEncryptedKey) *)OPENSSL_sk_new_reserve(ossl_check_CMS_RecipientEncryptedKey_compfunc_type(cmp), (n)))
+#define sk_CMS_RecipientEncryptedKey_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk), (n))
+#define sk_CMS_RecipientEncryptedKey_free(sk) OPENSSL_sk_free(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk))
+#define sk_CMS_RecipientEncryptedKey_zero(sk) OPENSSL_sk_zero(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk))
+#define sk_CMS_RecipientEncryptedKey_delete(sk, i) ((CMS_RecipientEncryptedKey *)OPENSSL_sk_delete(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk), (i)))
+#define sk_CMS_RecipientEncryptedKey_delete_ptr(sk, ptr) ((CMS_RecipientEncryptedKey *)OPENSSL_sk_delete_ptr(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk), ossl_check_CMS_RecipientEncryptedKey_type(ptr)))
+#define sk_CMS_RecipientEncryptedKey_push(sk, ptr) OPENSSL_sk_push(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk), ossl_check_CMS_RecipientEncryptedKey_type(ptr))
+#define sk_CMS_RecipientEncryptedKey_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk), ossl_check_CMS_RecipientEncryptedKey_type(ptr))
+#define sk_CMS_RecipientEncryptedKey_pop(sk) ((CMS_RecipientEncryptedKey *)OPENSSL_sk_pop(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk)))
+#define sk_CMS_RecipientEncryptedKey_shift(sk) ((CMS_RecipientEncryptedKey *)OPENSSL_sk_shift(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk)))
+#define sk_CMS_RecipientEncryptedKey_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk),ossl_check_CMS_RecipientEncryptedKey_freefunc_type(freefunc))
+#define sk_CMS_RecipientEncryptedKey_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk), ossl_check_CMS_RecipientEncryptedKey_type(ptr), (idx))
+#define sk_CMS_RecipientEncryptedKey_set(sk, idx, ptr) ((CMS_RecipientEncryptedKey *)OPENSSL_sk_set(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk), (idx), ossl_check_CMS_RecipientEncryptedKey_type(ptr)))
+#define sk_CMS_RecipientEncryptedKey_find(sk, ptr) OPENSSL_sk_find(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk), ossl_check_CMS_RecipientEncryptedKey_type(ptr))
+#define sk_CMS_RecipientEncryptedKey_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk), ossl_check_CMS_RecipientEncryptedKey_type(ptr))
+#define sk_CMS_RecipientEncryptedKey_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk), ossl_check_CMS_RecipientEncryptedKey_type(ptr), pnum)
+#define sk_CMS_RecipientEncryptedKey_sort(sk) OPENSSL_sk_sort(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk))
+#define sk_CMS_RecipientEncryptedKey_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_CMS_RecipientEncryptedKey_sk_type(sk))
+#define sk_CMS_RecipientEncryptedKey_dup(sk) ((STACK_OF(CMS_RecipientEncryptedKey) *)OPENSSL_sk_dup(ossl_check_const_CMS_RecipientEncryptedKey_sk_type(sk)))
+#define sk_CMS_RecipientEncryptedKey_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(CMS_RecipientEncryptedKey) *)OPENSSL_sk_deep_copy(ossl_check_const_CMS_RecipientEncryptedKey_sk_type(sk), ossl_check_CMS_RecipientEncryptedKey_copyfunc_type(copyfunc), ossl_check_CMS_RecipientEncryptedKey_freefunc_type(freefunc)))
+#define sk_CMS_RecipientEncryptedKey_set_cmp_func(sk, cmp) ((sk_CMS_RecipientEncryptedKey_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk), ossl_check_CMS_RecipientEncryptedKey_compfunc_type(cmp)))
+SKM_DEFINE_STACK_OF_INTERNAL(CMS_RecipientInfo, CMS_RecipientInfo, CMS_RecipientInfo)
+#define sk_CMS_RecipientInfo_num(sk) OPENSSL_sk_num(ossl_check_const_CMS_RecipientInfo_sk_type(sk))
+#define sk_CMS_RecipientInfo_value(sk, idx) ((CMS_RecipientInfo *)OPENSSL_sk_value(ossl_check_const_CMS_RecipientInfo_sk_type(sk), (idx)))
+#define sk_CMS_RecipientInfo_new(cmp) ((STACK_OF(CMS_RecipientInfo) *)OPENSSL_sk_new(ossl_check_CMS_RecipientInfo_compfunc_type(cmp)))
+#define sk_CMS_RecipientInfo_new_null() ((STACK_OF(CMS_RecipientInfo) *)OPENSSL_sk_new_null())
+#define sk_CMS_RecipientInfo_new_reserve(cmp, n) ((STACK_OF(CMS_RecipientInfo) *)OPENSSL_sk_new_reserve(ossl_check_CMS_RecipientInfo_compfunc_type(cmp), (n)))
+#define sk_CMS_RecipientInfo_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_CMS_RecipientInfo_sk_type(sk), (n))
+#define sk_CMS_RecipientInfo_free(sk) OPENSSL_sk_free(ossl_check_CMS_RecipientInfo_sk_type(sk))
+#define sk_CMS_RecipientInfo_zero(sk) OPENSSL_sk_zero(ossl_check_CMS_RecipientInfo_sk_type(sk))
+#define sk_CMS_RecipientInfo_delete(sk, i) ((CMS_RecipientInfo *)OPENSSL_sk_delete(ossl_check_CMS_RecipientInfo_sk_type(sk), (i)))
+#define sk_CMS_RecipientInfo_delete_ptr(sk, ptr) ((CMS_RecipientInfo *)OPENSSL_sk_delete_ptr(ossl_check_CMS_RecipientInfo_sk_type(sk), ossl_check_CMS_RecipientInfo_type(ptr)))
+#define sk_CMS_RecipientInfo_push(sk, ptr) OPENSSL_sk_push(ossl_check_CMS_RecipientInfo_sk_type(sk), ossl_check_CMS_RecipientInfo_type(ptr))
+#define sk_CMS_RecipientInfo_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_CMS_RecipientInfo_sk_type(sk), ossl_check_CMS_RecipientInfo_type(ptr))
+#define sk_CMS_RecipientInfo_pop(sk) ((CMS_RecipientInfo *)OPENSSL_sk_pop(ossl_check_CMS_RecipientInfo_sk_type(sk)))
+#define sk_CMS_RecipientInfo_shift(sk) ((CMS_RecipientInfo *)OPENSSL_sk_shift(ossl_check_CMS_RecipientInfo_sk_type(sk)))
+#define sk_CMS_RecipientInfo_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_CMS_RecipientInfo_sk_type(sk),ossl_check_CMS_RecipientInfo_freefunc_type(freefunc))
+#define sk_CMS_RecipientInfo_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_CMS_RecipientInfo_sk_type(sk), ossl_check_CMS_RecipientInfo_type(ptr), (idx))
+#define sk_CMS_RecipientInfo_set(sk, idx, ptr) ((CMS_RecipientInfo *)OPENSSL_sk_set(ossl_check_CMS_RecipientInfo_sk_type(sk), (idx), ossl_check_CMS_RecipientInfo_type(ptr)))
+#define sk_CMS_RecipientInfo_find(sk, ptr) OPENSSL_sk_find(ossl_check_CMS_RecipientInfo_sk_type(sk), ossl_check_CMS_RecipientInfo_type(ptr))
+#define sk_CMS_RecipientInfo_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_CMS_RecipientInfo_sk_type(sk), ossl_check_CMS_RecipientInfo_type(ptr))
+#define sk_CMS_RecipientInfo_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_CMS_RecipientInfo_sk_type(sk), ossl_check_CMS_RecipientInfo_type(ptr), pnum)
+#define sk_CMS_RecipientInfo_sort(sk) OPENSSL_sk_sort(ossl_check_CMS_RecipientInfo_sk_type(sk))
+#define sk_CMS_RecipientInfo_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_CMS_RecipientInfo_sk_type(sk))
+#define sk_CMS_RecipientInfo_dup(sk) ((STACK_OF(CMS_RecipientInfo) *)OPENSSL_sk_dup(ossl_check_const_CMS_RecipientInfo_sk_type(sk)))
+#define sk_CMS_RecipientInfo_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(CMS_RecipientInfo) *)OPENSSL_sk_deep_copy(ossl_check_const_CMS_RecipientInfo_sk_type(sk), ossl_check_CMS_RecipientInfo_copyfunc_type(copyfunc), ossl_check_CMS_RecipientInfo_freefunc_type(freefunc)))
+#define sk_CMS_RecipientInfo_set_cmp_func(sk, cmp) ((sk_CMS_RecipientInfo_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_CMS_RecipientInfo_sk_type(sk), ossl_check_CMS_RecipientInfo_compfunc_type(cmp)))
+SKM_DEFINE_STACK_OF_INTERNAL(CMS_RevocationInfoChoice, CMS_RevocationInfoChoice, CMS_RevocationInfoChoice)
+#define sk_CMS_RevocationInfoChoice_num(sk) OPENSSL_sk_num(ossl_check_const_CMS_RevocationInfoChoice_sk_type(sk))
+#define sk_CMS_RevocationInfoChoice_value(sk, idx) ((CMS_RevocationInfoChoice *)OPENSSL_sk_value(ossl_check_const_CMS_RevocationInfoChoice_sk_type(sk), (idx)))
+#define sk_CMS_RevocationInfoChoice_new(cmp) ((STACK_OF(CMS_RevocationInfoChoice) *)OPENSSL_sk_new(ossl_check_CMS_RevocationInfoChoice_compfunc_type(cmp)))
+#define sk_CMS_RevocationInfoChoice_new_null() ((STACK_OF(CMS_RevocationInfoChoice) *)OPENSSL_sk_new_null())
+#define sk_CMS_RevocationInfoChoice_new_reserve(cmp, n) ((STACK_OF(CMS_RevocationInfoChoice) *)OPENSSL_sk_new_reserve(ossl_check_CMS_RevocationInfoChoice_compfunc_type(cmp), (n)))
+#define sk_CMS_RevocationInfoChoice_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_CMS_RevocationInfoChoice_sk_type(sk), (n))
+#define sk_CMS_RevocationInfoChoice_free(sk) OPENSSL_sk_free(ossl_check_CMS_RevocationInfoChoice_sk_type(sk))
+#define sk_CMS_RevocationInfoChoice_zero(sk) OPENSSL_sk_zero(ossl_check_CMS_RevocationInfoChoice_sk_type(sk))
+#define sk_CMS_RevocationInfoChoice_delete(sk, i) ((CMS_RevocationInfoChoice *)OPENSSL_sk_delete(ossl_check_CMS_RevocationInfoChoice_sk_type(sk), (i)))
+#define sk_CMS_RevocationInfoChoice_delete_ptr(sk, ptr) ((CMS_RevocationInfoChoice *)OPENSSL_sk_delete_ptr(ossl_check_CMS_RevocationInfoChoice_sk_type(sk), ossl_check_CMS_RevocationInfoChoice_type(ptr)))
+#define sk_CMS_RevocationInfoChoice_push(sk, ptr) OPENSSL_sk_push(ossl_check_CMS_RevocationInfoChoice_sk_type(sk), ossl_check_CMS_RevocationInfoChoice_type(ptr))
+#define sk_CMS_RevocationInfoChoice_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_CMS_RevocationInfoChoice_sk_type(sk), ossl_check_CMS_RevocationInfoChoice_type(ptr))
+#define sk_CMS_RevocationInfoChoice_pop(sk) ((CMS_RevocationInfoChoice *)OPENSSL_sk_pop(ossl_check_CMS_RevocationInfoChoice_sk_type(sk)))
+#define sk_CMS_RevocationInfoChoice_shift(sk) ((CMS_RevocationInfoChoice *)OPENSSL_sk_shift(ossl_check_CMS_RevocationInfoChoice_sk_type(sk)))
+#define sk_CMS_RevocationInfoChoice_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_CMS_RevocationInfoChoice_sk_type(sk),ossl_check_CMS_RevocationInfoChoice_freefunc_type(freefunc))
+#define sk_CMS_RevocationInfoChoice_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_CMS_RevocationInfoChoice_sk_type(sk), ossl_check_CMS_RevocationInfoChoice_type(ptr), (idx))
+#define sk_CMS_RevocationInfoChoice_set(sk, idx, ptr) ((CMS_RevocationInfoChoice *)OPENSSL_sk_set(ossl_check_CMS_RevocationInfoChoice_sk_type(sk), (idx), ossl_check_CMS_RevocationInfoChoice_type(ptr)))
+#define sk_CMS_RevocationInfoChoice_find(sk, ptr) OPENSSL_sk_find(ossl_check_CMS_RevocationInfoChoice_sk_type(sk), ossl_check_CMS_RevocationInfoChoice_type(ptr))
+#define sk_CMS_RevocationInfoChoice_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_CMS_RevocationInfoChoice_sk_type(sk), ossl_check_CMS_RevocationInfoChoice_type(ptr))
+#define sk_CMS_RevocationInfoChoice_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_CMS_RevocationInfoChoice_sk_type(sk), ossl_check_CMS_RevocationInfoChoice_type(ptr), pnum)
+#define sk_CMS_RevocationInfoChoice_sort(sk) OPENSSL_sk_sort(ossl_check_CMS_RevocationInfoChoice_sk_type(sk))
+#define sk_CMS_RevocationInfoChoice_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_CMS_RevocationInfoChoice_sk_type(sk))
+#define sk_CMS_RevocationInfoChoice_dup(sk) ((STACK_OF(CMS_RevocationInfoChoice) *)OPENSSL_sk_dup(ossl_check_const_CMS_RevocationInfoChoice_sk_type(sk)))
+#define sk_CMS_RevocationInfoChoice_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(CMS_RevocationInfoChoice) *)OPENSSL_sk_deep_copy(ossl_check_const_CMS_RevocationInfoChoice_sk_type(sk), ossl_check_CMS_RevocationInfoChoice_copyfunc_type(copyfunc), ossl_check_CMS_RevocationInfoChoice_freefunc_type(freefunc)))
+#define sk_CMS_RevocationInfoChoice_set_cmp_func(sk, cmp) ((sk_CMS_RevocationInfoChoice_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_CMS_RevocationInfoChoice_sk_type(sk), ossl_check_CMS_RevocationInfoChoice_compfunc_type(cmp)))
+
+
+DECLARE_ASN1_ITEM(CMS_EnvelopedData)
+DECLARE_ASN1_ALLOC_FUNCTIONS(CMS_SignedData)
+DECLARE_ASN1_FUNCTIONS(CMS_ContentInfo)
+DECLARE_ASN1_FUNCTIONS(CMS_ReceiptRequest)
+DECLARE_ASN1_PRINT_FUNCTION(CMS_ContentInfo)
+
+CMS_ContentInfo *CMS_ContentInfo_new_ex(OSSL_LIB_CTX *libctx, const char *propq);
+
+# define CMS_SIGNERINFO_ISSUER_SERIAL    0
+# define CMS_SIGNERINFO_KEYIDENTIFIER    1
+
+# define CMS_RECIPINFO_NONE              -1
+# define CMS_RECIPINFO_TRANS             0
+# define CMS_RECIPINFO_AGREE             1
+# define CMS_RECIPINFO_KEK               2
+# define CMS_RECIPINFO_PASS              3
+# define CMS_RECIPINFO_OTHER             4
+
+/* S/MIME related flags */
+
+# define CMS_TEXT                        0x1
+# define CMS_NOCERTS                     0x2
+# define CMS_NO_CONTENT_VERIFY           0x4
+# define CMS_NO_ATTR_VERIFY              0x8
+# define CMS_NOSIGS                      \
+                        (CMS_NO_CONTENT_VERIFY|CMS_NO_ATTR_VERIFY)
+# define CMS_NOINTERN                    0x10
+# define CMS_NO_SIGNER_CERT_VERIFY       0x20
+# define CMS_NOVERIFY                    0x20
+# define CMS_DETACHED                    0x40
+# define CMS_BINARY                      0x80
+# define CMS_NOATTR                      0x100
+# define CMS_NOSMIMECAP                  0x200
+# define CMS_NOOLDMIMETYPE               0x400
+# define CMS_CRLFEOL                     0x800
+# define CMS_STREAM                      0x1000
+# define CMS_NOCRL                       0x2000
+# define CMS_PARTIAL                     0x4000
+# define CMS_REUSE_DIGEST                0x8000
+# define CMS_USE_KEYID                   0x10000
+# define CMS_DEBUG_DECRYPT               0x20000
+# define CMS_KEY_PARAM                   0x40000
+# define CMS_ASCIICRLF                   0x80000
+# define CMS_CADES                       0x100000
+# define CMS_USE_ORIGINATOR_KEYID        0x200000
+
+const ASN1_OBJECT *CMS_get0_type(const CMS_ContentInfo *cms);
+
+BIO *CMS_dataInit(CMS_ContentInfo *cms, BIO *icont);
+int CMS_dataFinal(CMS_ContentInfo *cms, BIO *bio);
+
+ASN1_OCTET_STRING **CMS_get0_content(CMS_ContentInfo *cms);
+int CMS_is_detached(CMS_ContentInfo *cms);
+int CMS_set_detached(CMS_ContentInfo *cms, int detached);
+
+# ifdef OPENSSL_PEM_H
+DECLARE_PEM_rw(CMS, CMS_ContentInfo)
+# endif
+int CMS_stream(unsigned char ***boundary, CMS_ContentInfo *cms);
+CMS_ContentInfo *d2i_CMS_bio(BIO *bp, CMS_ContentInfo **cms);
+int i2d_CMS_bio(BIO *bp, CMS_ContentInfo *cms);
+
+BIO *BIO_new_CMS(BIO *out, CMS_ContentInfo *cms);
+int i2d_CMS_bio_stream(BIO *out, CMS_ContentInfo *cms, BIO *in, int flags);
+int PEM_write_bio_CMS_stream(BIO *out, CMS_ContentInfo *cms, BIO *in,
+                             int flags);
+CMS_ContentInfo *SMIME_read_CMS(BIO *bio, BIO **bcont);
+CMS_ContentInfo *SMIME_read_CMS_ex(BIO *bio, int flags, BIO **bcont, CMS_ContentInfo **ci);
+int SMIME_write_CMS(BIO *bio, CMS_ContentInfo *cms, BIO *data, int flags);
+
+int CMS_final(CMS_ContentInfo *cms, BIO *data, BIO *dcont,
+              unsigned int flags);
+int CMS_final_digest(CMS_ContentInfo *cms,
+                     const unsigned char *md, unsigned int mdlen, BIO *dcont,
+                     unsigned int flags);
+
+CMS_ContentInfo *CMS_sign(X509 *signcert, EVP_PKEY *pkey,
+                          STACK_OF(X509) *certs, BIO *data,
+                          unsigned int flags);
+CMS_ContentInfo *CMS_sign_ex(X509 *signcert, EVP_PKEY *pkey,
+                             STACK_OF(X509) *certs, BIO *data,
+                             unsigned int flags, OSSL_LIB_CTX *libctx,
+                             const char *propq);
+
+CMS_ContentInfo *CMS_sign_receipt(CMS_SignerInfo *si,
+                                  X509 *signcert, EVP_PKEY *pkey,
+                                  STACK_OF(X509) *certs, unsigned int flags);
+
+int CMS_data(CMS_ContentInfo *cms, BIO *out, unsigned int flags);
+CMS_ContentInfo *CMS_data_create(BIO *in, unsigned int flags);
+CMS_ContentInfo *CMS_data_create_ex(BIO *in, unsigned int flags,
+                                    OSSL_LIB_CTX *libctx, const char *propq);
+
+int CMS_digest_verify(CMS_ContentInfo *cms, BIO *dcont, BIO *out,
+                      unsigned int flags);
+CMS_ContentInfo *CMS_digest_create(BIO *in, const EVP_MD *md,
+                                   unsigned int flags);
+CMS_ContentInfo *CMS_digest_create_ex(BIO *in, const EVP_MD *md,
+                                      unsigned int flags, OSSL_LIB_CTX *libctx,
+                                      const char *propq);
+
+int CMS_EncryptedData_decrypt(CMS_ContentInfo *cms,
+                              const unsigned char *key, size_t keylen,
+                              BIO *dcont, BIO *out, unsigned int flags);
+CMS_ContentInfo *CMS_EncryptedData_encrypt(BIO *in, const EVP_CIPHER *cipher,
+                                           const unsigned char *key,
+                                           size_t keylen, unsigned int flags);
+CMS_ContentInfo *CMS_EncryptedData_encrypt_ex(BIO *in, const EVP_CIPHER *cipher,
+                                              const unsigned char *key,
+                                              size_t keylen, unsigned int flags,
+                                              OSSL_LIB_CTX *libctx,
+                                              const char *propq);
+
+int CMS_EncryptedData_set1_key(CMS_ContentInfo *cms, const EVP_CIPHER *ciph,
+                               const unsigned char *key, size_t keylen);
+
+int CMS_verify(CMS_ContentInfo *cms, STACK_OF(X509) *certs,
+               X509_STORE *store, BIO *dcont, BIO *out, unsigned int flags);
+
+int CMS_verify_receipt(CMS_ContentInfo *rcms, CMS_ContentInfo *ocms,
+                       STACK_OF(X509) *certs,
+                       X509_STORE *store, unsigned int flags);
+
+STACK_OF(X509) *CMS_get0_signers(CMS_ContentInfo *cms);
+
+CMS_ContentInfo *CMS_encrypt(STACK_OF(X509) *certs, BIO *in,
+                             const EVP_CIPHER *cipher, unsigned int flags);
+CMS_ContentInfo *CMS_encrypt_ex(STACK_OF(X509) *certs, BIO *in,
+                                const EVP_CIPHER *cipher, unsigned int flags,
+                                OSSL_LIB_CTX *libctx, const char *propq);
+
+int CMS_decrypt(CMS_ContentInfo *cms, EVP_PKEY *pkey, X509 *cert,
+                BIO *dcont, BIO *out, unsigned int flags);
+
+int CMS_decrypt_set1_pkey(CMS_ContentInfo *cms, EVP_PKEY *pk, X509 *cert);
+int CMS_decrypt_set1_pkey_and_peer(CMS_ContentInfo *cms, EVP_PKEY *pk,
+                                   X509 *cert, X509 *peer);
+int CMS_decrypt_set1_key(CMS_ContentInfo *cms,
+                         unsigned char *key, size_t keylen,
+                         const unsigned char *id, size_t idlen);
+int CMS_decrypt_set1_password(CMS_ContentInfo *cms,
+                              unsigned char *pass, ossl_ssize_t passlen);
+
+STACK_OF(CMS_RecipientInfo) *CMS_get0_RecipientInfos(CMS_ContentInfo *cms);
+int CMS_RecipientInfo_type(CMS_RecipientInfo *ri);
+EVP_PKEY_CTX *CMS_RecipientInfo_get0_pkey_ctx(CMS_RecipientInfo *ri);
+CMS_ContentInfo *CMS_AuthEnvelopedData_create(const EVP_CIPHER *cipher);
+CMS_ContentInfo *
+CMS_AuthEnvelopedData_create_ex(const EVP_CIPHER *cipher, OSSL_LIB_CTX *libctx,
+                                const char *propq);
+CMS_ContentInfo *CMS_EnvelopedData_create(const EVP_CIPHER *cipher);
+CMS_ContentInfo *CMS_EnvelopedData_create_ex(const EVP_CIPHER *cipher,
+                                             OSSL_LIB_CTX *libctx,
+                                             const char *propq);
+BIO *CMS_EnvelopedData_decrypt(CMS_EnvelopedData *env, BIO *detached_data,
+                               EVP_PKEY *pkey, X509 *cert,
+                               ASN1_OCTET_STRING *secret, unsigned int flags,
+                               OSSL_LIB_CTX *libctx, const char *propq);
+
+CMS_RecipientInfo *CMS_add1_recipient_cert(CMS_ContentInfo *cms,
+                                           X509 *recip, unsigned int flags);
+CMS_RecipientInfo *CMS_add1_recipient(CMS_ContentInfo *cms, X509 *recip,
+     EVP_PKEY *originatorPrivKey, X509 * originator, unsigned int flags);
+int CMS_RecipientInfo_set0_pkey(CMS_RecipientInfo *ri, EVP_PKEY *pkey);
+int CMS_RecipientInfo_ktri_cert_cmp(CMS_RecipientInfo *ri, X509 *cert);
+int CMS_RecipientInfo_ktri_get0_algs(CMS_RecipientInfo *ri,
+                                     EVP_PKEY **pk, X509 **recip,
+                                     X509_ALGOR **palg);
+int CMS_RecipientInfo_ktri_get0_signer_id(CMS_RecipientInfo *ri,
+                                          ASN1_OCTET_STRING **keyid,
+                                          X509_NAME **issuer,
+                                          ASN1_INTEGER **sno);
+
+CMS_RecipientInfo *CMS_add0_recipient_key(CMS_ContentInfo *cms, int nid,
+                                          unsigned char *key, size_t keylen,
+                                          unsigned char *id, size_t idlen,
+                                          ASN1_GENERALIZEDTIME *date,
+                                          ASN1_OBJECT *otherTypeId,
+                                          ASN1_TYPE *otherType);
+
+int CMS_RecipientInfo_kekri_get0_id(CMS_RecipientInfo *ri,
+                                    X509_ALGOR **palg,
+                                    ASN1_OCTET_STRING **pid,
+                                    ASN1_GENERALIZEDTIME **pdate,
+                                    ASN1_OBJECT **potherid,
+                                    ASN1_TYPE **pothertype);
+
+int CMS_RecipientInfo_set0_key(CMS_RecipientInfo *ri,
+                               unsigned char *key, size_t keylen);
+
+int CMS_RecipientInfo_kekri_id_cmp(CMS_RecipientInfo *ri,
+                                   const unsigned char *id, size_t idlen);
+
+int CMS_RecipientInfo_set0_password(CMS_RecipientInfo *ri,
+                                    unsigned char *pass,
+                                    ossl_ssize_t passlen);
+
+CMS_RecipientInfo *CMS_add0_recipient_password(CMS_ContentInfo *cms,
+                                               int iter, int wrap_nid,
+                                               int pbe_nid,
+                                               unsigned char *pass,
+                                               ossl_ssize_t passlen,
+                                               const EVP_CIPHER *kekciph);
+
+int CMS_RecipientInfo_decrypt(CMS_ContentInfo *cms, CMS_RecipientInfo *ri);
+int CMS_RecipientInfo_encrypt(const CMS_ContentInfo *cms, CMS_RecipientInfo *ri);
+
+int CMS_uncompress(CMS_ContentInfo *cms, BIO *dcont, BIO *out,
+                   unsigned int flags);
+CMS_ContentInfo *CMS_compress(BIO *in, int comp_nid, unsigned int flags);
+
+int CMS_set1_eContentType(CMS_ContentInfo *cms, const ASN1_OBJECT *oid);
+const ASN1_OBJECT *CMS_get0_eContentType(CMS_ContentInfo *cms);
+
+CMS_CertificateChoices *CMS_add0_CertificateChoices(CMS_ContentInfo *cms);
+int CMS_add0_cert(CMS_ContentInfo *cms, X509 *cert);
+int CMS_add1_cert(CMS_ContentInfo *cms, X509 *cert);
+STACK_OF(X509) *CMS_get1_certs(CMS_ContentInfo *cms);
+
+CMS_RevocationInfoChoice *CMS_add0_RevocationInfoChoice(CMS_ContentInfo *cms);
+int CMS_add0_crl(CMS_ContentInfo *cms, X509_CRL *crl);
+int CMS_add1_crl(CMS_ContentInfo *cms, X509_CRL *crl);
+STACK_OF(X509_CRL) *CMS_get1_crls(CMS_ContentInfo *cms);
+
+int CMS_SignedData_init(CMS_ContentInfo *cms);
+CMS_SignerInfo *CMS_add1_signer(CMS_ContentInfo *cms,
+                                X509 *signer, EVP_PKEY *pk, const EVP_MD *md,
+                                unsigned int flags);
+EVP_PKEY_CTX *CMS_SignerInfo_get0_pkey_ctx(CMS_SignerInfo *si);
+EVP_MD_CTX *CMS_SignerInfo_get0_md_ctx(CMS_SignerInfo *si);
+STACK_OF(CMS_SignerInfo) *CMS_get0_SignerInfos(CMS_ContentInfo *cms);
+
+void CMS_SignerInfo_set1_signer_cert(CMS_SignerInfo *si, X509 *signer);
+int CMS_SignerInfo_get0_signer_id(CMS_SignerInfo *si,
+                                  ASN1_OCTET_STRING **keyid,
+                                  X509_NAME **issuer, ASN1_INTEGER **sno);
+int CMS_SignerInfo_cert_cmp(CMS_SignerInfo *si, X509 *cert);
+int CMS_set1_signers_certs(CMS_ContentInfo *cms, STACK_OF(X509) *certs,
+                           unsigned int flags);
+void CMS_SignerInfo_get0_algs(CMS_SignerInfo *si, EVP_PKEY **pk,
+                              X509 **signer, X509_ALGOR **pdig,
+                              X509_ALGOR **psig);
+ASN1_OCTET_STRING *CMS_SignerInfo_get0_signature(CMS_SignerInfo *si);
+int CMS_SignerInfo_sign(CMS_SignerInfo *si);
+int CMS_SignerInfo_verify(CMS_SignerInfo *si);
+int CMS_SignerInfo_verify_content(CMS_SignerInfo *si, BIO *chain);
+BIO *CMS_SignedData_verify(CMS_SignedData *sd, BIO *detached_data,
+                           STACK_OF(X509) *scerts, X509_STORE *store,
+                           STACK_OF(X509) *extra, STACK_OF(X509_CRL) *crls,
+                           unsigned int flags,
+                           OSSL_LIB_CTX *libctx, const char *propq);
+
+int CMS_add_smimecap(CMS_SignerInfo *si, STACK_OF(X509_ALGOR) *algs);
+int CMS_add_simple_smimecap(STACK_OF(X509_ALGOR) **algs,
+                            int algnid, int keysize);
+int CMS_add_standard_smimecap(STACK_OF(X509_ALGOR) **smcap);
+
+int CMS_signed_get_attr_count(const CMS_SignerInfo *si);
+int CMS_signed_get_attr_by_NID(const CMS_SignerInfo *si, int nid,
+                               int lastpos);
+int CMS_signed_get_attr_by_OBJ(const CMS_SignerInfo *si, const ASN1_OBJECT *obj,
+                               int lastpos);
+X509_ATTRIBUTE *CMS_signed_get_attr(const CMS_SignerInfo *si, int loc);
+X509_ATTRIBUTE *CMS_signed_delete_attr(CMS_SignerInfo *si, int loc);
+int CMS_signed_add1_attr(CMS_SignerInfo *si, X509_ATTRIBUTE *attr);
+int CMS_signed_add1_attr_by_OBJ(CMS_SignerInfo *si,
+                                const ASN1_OBJECT *obj, int type,
+                                const void *bytes, int len);
+int CMS_signed_add1_attr_by_NID(CMS_SignerInfo *si,
+                                int nid, int type,
+                                const void *bytes, int len);
+int CMS_signed_add1_attr_by_txt(CMS_SignerInfo *si,
+                                const char *attrname, int type,
+                                const void *bytes, int len);
+void *CMS_signed_get0_data_by_OBJ(const CMS_SignerInfo *si,
+                                  const ASN1_OBJECT *oid,
+                                  int lastpos, int type);
+
+int CMS_unsigned_get_attr_count(const CMS_SignerInfo *si);
+int CMS_unsigned_get_attr_by_NID(const CMS_SignerInfo *si, int nid,
+                                 int lastpos);
+int CMS_unsigned_get_attr_by_OBJ(const CMS_SignerInfo *si,
+                                 const ASN1_OBJECT *obj, int lastpos);
+X509_ATTRIBUTE *CMS_unsigned_get_attr(const CMS_SignerInfo *si, int loc);
+X509_ATTRIBUTE *CMS_unsigned_delete_attr(CMS_SignerInfo *si, int loc);
+int CMS_unsigned_add1_attr(CMS_SignerInfo *si, X509_ATTRIBUTE *attr);
+int CMS_unsigned_add1_attr_by_OBJ(CMS_SignerInfo *si,
+                                  const ASN1_OBJECT *obj, int type,
+                                  const void *bytes, int len);
+int CMS_unsigned_add1_attr_by_NID(CMS_SignerInfo *si,
+                                  int nid, int type,
+                                  const void *bytes, int len);
+int CMS_unsigned_add1_attr_by_txt(CMS_SignerInfo *si,
+                                  const char *attrname, int type,
+                                  const void *bytes, int len);
+void *CMS_unsigned_get0_data_by_OBJ(CMS_SignerInfo *si, ASN1_OBJECT *oid,
+                                    int lastpos, int type);
+
+int CMS_get1_ReceiptRequest(CMS_SignerInfo *si, CMS_ReceiptRequest **prr);
+CMS_ReceiptRequest *CMS_ReceiptRequest_create0(
+    unsigned char *id, int idlen, int allorfirst,
+    STACK_OF(GENERAL_NAMES) *receiptList,
+    STACK_OF(GENERAL_NAMES) *receiptsTo);
+CMS_ReceiptRequest *CMS_ReceiptRequest_create0_ex(
+    unsigned char *id, int idlen, int allorfirst,
+    STACK_OF(GENERAL_NAMES) *receiptList,
+    STACK_OF(GENERAL_NAMES) *receiptsTo,
+    OSSL_LIB_CTX *libctx);
+
+int CMS_add1_ReceiptRequest(CMS_SignerInfo *si, CMS_ReceiptRequest *rr);
+void CMS_ReceiptRequest_get0_values(CMS_ReceiptRequest *rr,
+                                    ASN1_STRING **pcid,
+                                    int *pallorfirst,
+                                    STACK_OF(GENERAL_NAMES) **plist,
+                                    STACK_OF(GENERAL_NAMES) **prto);
+int CMS_RecipientInfo_kari_get0_alg(CMS_RecipientInfo *ri,
+                                    X509_ALGOR **palg,
+                                    ASN1_OCTET_STRING **pukm);
+STACK_OF(CMS_RecipientEncryptedKey)
+*CMS_RecipientInfo_kari_get0_reks(CMS_RecipientInfo *ri);
+
+int CMS_RecipientInfo_kari_get0_orig_id(CMS_RecipientInfo *ri,
+                                        X509_ALGOR **pubalg,
+                                        ASN1_BIT_STRING **pubkey,
+                                        ASN1_OCTET_STRING **keyid,
+                                        X509_NAME **issuer,
+                                        ASN1_INTEGER **sno);
+
+int CMS_RecipientInfo_kari_orig_id_cmp(CMS_RecipientInfo *ri, X509 *cert);
+
+int CMS_RecipientEncryptedKey_get0_id(CMS_RecipientEncryptedKey *rek,
+                                      ASN1_OCTET_STRING **keyid,
+                                      ASN1_GENERALIZEDTIME **tm,
+                                      CMS_OtherKeyAttribute **other,
+                                      X509_NAME **issuer, ASN1_INTEGER **sno);
+int CMS_RecipientEncryptedKey_cert_cmp(CMS_RecipientEncryptedKey *rek,
+                                       X509 *cert);
+int CMS_RecipientInfo_kari_set0_pkey(CMS_RecipientInfo *ri, EVP_PKEY *pk);
+int CMS_RecipientInfo_kari_set0_pkey_and_peer(CMS_RecipientInfo *ri, EVP_PKEY *pk, X509 *peer);
+EVP_CIPHER_CTX *CMS_RecipientInfo_kari_get0_ctx(CMS_RecipientInfo *ri);
+int CMS_RecipientInfo_kari_decrypt(CMS_ContentInfo *cms,
+                                   CMS_RecipientInfo *ri,
+                                   CMS_RecipientEncryptedKey *rek);
+
+int CMS_SharedInfo_encode(unsigned char **pder, X509_ALGOR *kekalg,
+                          ASN1_OCTET_STRING *ukm, int keylen);
+
+/* Backward compatibility for spelling errors. */
+# define CMS_R_UNKNOWN_DIGEST_ALGORITM CMS_R_UNKNOWN_DIGEST_ALGORITHM
+# define CMS_R_UNSUPPORTED_RECPIENTINFO_TYPE \
+    CMS_R_UNSUPPORTED_RECIPIENTINFO_TYPE
+
+#  ifdef  __cplusplus
+}
+#  endif
+# endif
+#endif
diff --git a/src/include/openssl/cmserr.h b/src/include/openssl/cmserr.h
new file mode 100644
index 0000000..887035b
--- /dev/null
+++ b/src/include/openssl/cmserr.h
@@ -0,0 +1,125 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_CMSERR_H
+# define OPENSSL_CMSERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+# ifndef OPENSSL_NO_CMS
+
+
+/*
+ * CMS reason codes.
+ */
+#  define CMS_R_ADD_SIGNER_ERROR                           99
+#  define CMS_R_ATTRIBUTE_ERROR                            161
+#  define CMS_R_CERTIFICATE_ALREADY_PRESENT                175
+#  define CMS_R_CERTIFICATE_HAS_NO_KEYID                   160
+#  define CMS_R_CERTIFICATE_VERIFY_ERROR                   100
+#  define CMS_R_CIPHER_AEAD_SET_TAG_ERROR                  184
+#  define CMS_R_CIPHER_GET_TAG                             185
+#  define CMS_R_CIPHER_INITIALISATION_ERROR                101
+#  define CMS_R_CIPHER_PARAMETER_INITIALISATION_ERROR      102
+#  define CMS_R_CMS_DATAFINAL_ERROR                        103
+#  define CMS_R_CMS_LIB                                    104
+#  define CMS_R_CONTENTIDENTIFIER_MISMATCH                 170
+#  define CMS_R_CONTENT_NOT_FOUND                          105
+#  define CMS_R_CONTENT_TYPE_MISMATCH                      171
+#  define CMS_R_CONTENT_TYPE_NOT_COMPRESSED_DATA           106
+#  define CMS_R_CONTENT_TYPE_NOT_ENVELOPED_DATA            107
+#  define CMS_R_CONTENT_TYPE_NOT_SIGNED_DATA               108
+#  define CMS_R_CONTENT_VERIFY_ERROR                       109
+#  define CMS_R_CTRL_ERROR                                 110
+#  define CMS_R_CTRL_FAILURE                               111
+#  define CMS_R_DECODE_ERROR                               187
+#  define CMS_R_DECRYPT_ERROR                              112
+#  define CMS_R_ERROR_GETTING_PUBLIC_KEY                   113
+#  define CMS_R_ERROR_READING_MESSAGEDIGEST_ATTRIBUTE      114
+#  define CMS_R_ERROR_SETTING_KEY                          115
+#  define CMS_R_ERROR_SETTING_RECIPIENTINFO                116
+#  define CMS_R_ESS_SIGNING_CERTID_MISMATCH_ERROR          183
+#  define CMS_R_INVALID_ENCRYPTED_KEY_LENGTH               117
+#  define CMS_R_INVALID_KEY_ENCRYPTION_PARAMETER           176
+#  define CMS_R_INVALID_KEY_LENGTH                         118
+#  define CMS_R_INVALID_LABEL                              190
+#  define CMS_R_INVALID_OAEP_PARAMETERS                    191
+#  define CMS_R_KDF_PARAMETER_ERROR                        186
+#  define CMS_R_MD_BIO_INIT_ERROR                          119
+#  define CMS_R_MESSAGEDIGEST_ATTRIBUTE_WRONG_LENGTH       120
+#  define CMS_R_MESSAGEDIGEST_WRONG_LENGTH                 121
+#  define CMS_R_MSGSIGDIGEST_ERROR                         172
+#  define CMS_R_MSGSIGDIGEST_VERIFICATION_FAILURE          162
+#  define CMS_R_MSGSIGDIGEST_WRONG_LENGTH                  163
+#  define CMS_R_NEED_ONE_SIGNER                            164
+#  define CMS_R_NOT_A_SIGNED_RECEIPT                       165
+#  define CMS_R_NOT_ENCRYPTED_DATA                         122
+#  define CMS_R_NOT_KEK                                    123
+#  define CMS_R_NOT_KEY_AGREEMENT                          181
+#  define CMS_R_NOT_KEY_TRANSPORT                          124
+#  define CMS_R_NOT_PWRI                                   177
+#  define CMS_R_NOT_SUPPORTED_FOR_THIS_KEY_TYPE            125
+#  define CMS_R_NO_CIPHER                                  126
+#  define CMS_R_NO_CONTENT                                 127
+#  define CMS_R_NO_CONTENT_TYPE                            173
+#  define CMS_R_NO_DEFAULT_DIGEST                          128
+#  define CMS_R_NO_DIGEST_SET                              129
+#  define CMS_R_NO_KEY                                     130
+#  define CMS_R_NO_KEY_OR_CERT                             174
+#  define CMS_R_NO_MATCHING_DIGEST                         131
+#  define CMS_R_NO_MATCHING_RECIPIENT                      132
+#  define CMS_R_NO_MATCHING_SIGNATURE                      166
+#  define CMS_R_NO_MSGSIGDIGEST                            167
+#  define CMS_R_NO_PASSWORD                                178
+#  define CMS_R_NO_PRIVATE_KEY                             133
+#  define CMS_R_NO_PUBLIC_KEY                              134
+#  define CMS_R_NO_RECEIPT_REQUEST                         168
+#  define CMS_R_NO_SIGNERS                                 135
+#  define CMS_R_OPERATION_UNSUPPORTED                      182
+#  define CMS_R_PEER_KEY_ERROR                             188
+#  define CMS_R_PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE     136
+#  define CMS_R_RECEIPT_DECODE_ERROR                       169
+#  define CMS_R_RECIPIENT_ERROR                            137
+#  define CMS_R_SHARED_INFO_ERROR                          189
+#  define CMS_R_SIGNER_CERTIFICATE_NOT_FOUND               138
+#  define CMS_R_SIGNFINAL_ERROR                            139
+#  define CMS_R_SMIME_TEXT_ERROR                           140
+#  define CMS_R_STORE_INIT_ERROR                           141
+#  define CMS_R_TYPE_NOT_COMPRESSED_DATA                   142
+#  define CMS_R_TYPE_NOT_DATA                              143
+#  define CMS_R_TYPE_NOT_DIGESTED_DATA                     144
+#  define CMS_R_TYPE_NOT_ENCRYPTED_DATA                    145
+#  define CMS_R_TYPE_NOT_ENVELOPED_DATA                    146
+#  define CMS_R_UNABLE_TO_FINALIZE_CONTEXT                 147
+#  define CMS_R_UNKNOWN_CIPHER                             148
+#  define CMS_R_UNKNOWN_DIGEST_ALGORITHM                   149
+#  define CMS_R_UNKNOWN_ID                                 150
+#  define CMS_R_UNSUPPORTED_COMPRESSION_ALGORITHM          151
+#  define CMS_R_UNSUPPORTED_CONTENT_ENCRYPTION_ALGORITHM   194
+#  define CMS_R_UNSUPPORTED_CONTENT_TYPE                   152
+#  define CMS_R_UNSUPPORTED_ENCRYPTION_TYPE                192
+#  define CMS_R_UNSUPPORTED_KEK_ALGORITHM                  153
+#  define CMS_R_UNSUPPORTED_KEY_ENCRYPTION_ALGORITHM       179
+#  define CMS_R_UNSUPPORTED_LABEL_SOURCE                   193
+#  define CMS_R_UNSUPPORTED_RECIPIENTINFO_TYPE             155
+#  define CMS_R_UNSUPPORTED_RECIPIENT_TYPE                 154
+#  define CMS_R_UNSUPPORTED_SIGNATURE_ALGORITHM            195
+#  define CMS_R_UNSUPPORTED_TYPE                           156
+#  define CMS_R_UNWRAP_ERROR                               157
+#  define CMS_R_UNWRAP_FAILURE                             180
+#  define CMS_R_VERIFICATION_FAILURE                       158
+#  define CMS_R_WRAP_ERROR                                 159
+
+# endif
+#endif
diff --git a/src/include/openssl/comp.h b/src/include/openssl/comp.h
new file mode 100644
index 0000000..f81ba0f
--- /dev/null
+++ b/src/include/openssl/comp.h
@@ -0,0 +1,64 @@
+/*
+ * Copyright 2015-2018 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_COMP_H
+# define OPENSSL_COMP_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_COMP_H
+# endif
+
+# include <openssl/opensslconf.h>
+
+# ifndef OPENSSL_NO_COMP
+# include <openssl/crypto.h>
+# include <openssl/comperr.h>
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+
+
+COMP_CTX *COMP_CTX_new(COMP_METHOD *meth);
+const COMP_METHOD *COMP_CTX_get_method(const COMP_CTX *ctx);
+int COMP_CTX_get_type(const COMP_CTX* comp);
+int COMP_get_type(const COMP_METHOD *meth);
+const char *COMP_get_name(const COMP_METHOD *meth);
+void COMP_CTX_free(COMP_CTX *ctx);
+
+int COMP_compress_block(COMP_CTX *ctx, unsigned char *out, int olen,
+                        unsigned char *in, int ilen);
+int COMP_expand_block(COMP_CTX *ctx, unsigned char *out, int olen,
+                      unsigned char *in, int ilen);
+
+COMP_METHOD *COMP_zlib(void);
+COMP_METHOD *COMP_zlib_oneshot(void);
+COMP_METHOD *COMP_brotli(void);
+COMP_METHOD *COMP_brotli_oneshot(void);
+COMP_METHOD *COMP_zstd(void);
+COMP_METHOD *COMP_zstd_oneshot(void);
+
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+# define COMP_zlib_cleanup() while(0) continue
+#endif
+
+# ifdef OPENSSL_BIO_H
+const BIO_METHOD *BIO_f_zlib(void);
+const BIO_METHOD *BIO_f_brotli(void);
+const BIO_METHOD *BIO_f_zstd(void);
+# endif
+
+
+#  ifdef  __cplusplus
+}
+#  endif
+# endif
+#endif
diff --git a/src/include/openssl/comperr.h b/src/include/openssl/comperr.h
new file mode 100644
index 0000000..1948d37
--- /dev/null
+++ b/src/include/openssl/comperr.h
@@ -0,0 +1,38 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_COMPERR_H
+# define OPENSSL_COMPERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+# ifndef OPENSSL_NO_COMP
+
+
+/*
+ * COMP reason codes.
+ */
+#  define COMP_R_BROTLI_DECODE_ERROR                       102
+#  define COMP_R_BROTLI_ENCODE_ERROR                       103
+#  define COMP_R_BROTLI_NOT_SUPPORTED                      104
+#  define COMP_R_ZLIB_DEFLATE_ERROR                        99
+#  define COMP_R_ZLIB_INFLATE_ERROR                        100
+#  define COMP_R_ZLIB_NOT_SUPPORTED                        101
+#  define COMP_R_ZSTD_COMPRESS_ERROR                       105
+#  define COMP_R_ZSTD_DECODE_ERROR                         106
+#  define COMP_R_ZSTD_DECOMPRESS_ERROR                     107
+#  define COMP_R_ZSTD_NOT_SUPPORTED                        108
+
+# endif
+#endif
diff --git a/src/include/openssl/conf.h b/src/include/openssl/conf.h
new file mode 100644
index 0000000..4e06dec
--- /dev/null
+++ b/src/include/openssl/conf.h
@@ -0,0 +1,214 @@
+/*
+ * WARNING: do not edit!
+ * Generated by makefile from include\openssl\conf.h.in
+ *
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+
+
+#ifndef  OPENSSL_CONF_H
+# define OPENSSL_CONF_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_CONF_H
+# endif
+
+# include <openssl/bio.h>
+# include <openssl/lhash.h>
+# include <openssl/safestack.h>
+# include <openssl/e_os2.h>
+# include <openssl/types.h>
+# include <openssl/conferr.h>
+# ifndef OPENSSL_NO_STDIO
+#  include <stdio.h>
+# endif
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+    char *section;
+    char *name;
+    char *value;
+} CONF_VALUE;
+
+SKM_DEFINE_STACK_OF_INTERNAL(CONF_VALUE, CONF_VALUE, CONF_VALUE)
+#define sk_CONF_VALUE_num(sk) OPENSSL_sk_num(ossl_check_const_CONF_VALUE_sk_type(sk))
+#define sk_CONF_VALUE_value(sk, idx) ((CONF_VALUE *)OPENSSL_sk_value(ossl_check_const_CONF_VALUE_sk_type(sk), (idx)))
+#define sk_CONF_VALUE_new(cmp) ((STACK_OF(CONF_VALUE) *)OPENSSL_sk_new(ossl_check_CONF_VALUE_compfunc_type(cmp)))
+#define sk_CONF_VALUE_new_null() ((STACK_OF(CONF_VALUE) *)OPENSSL_sk_new_null())
+#define sk_CONF_VALUE_new_reserve(cmp, n) ((STACK_OF(CONF_VALUE) *)OPENSSL_sk_new_reserve(ossl_check_CONF_VALUE_compfunc_type(cmp), (n)))
+#define sk_CONF_VALUE_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_CONF_VALUE_sk_type(sk), (n))
+#define sk_CONF_VALUE_free(sk) OPENSSL_sk_free(ossl_check_CONF_VALUE_sk_type(sk))
+#define sk_CONF_VALUE_zero(sk) OPENSSL_sk_zero(ossl_check_CONF_VALUE_sk_type(sk))
+#define sk_CONF_VALUE_delete(sk, i) ((CONF_VALUE *)OPENSSL_sk_delete(ossl_check_CONF_VALUE_sk_type(sk), (i)))
+#define sk_CONF_VALUE_delete_ptr(sk, ptr) ((CONF_VALUE *)OPENSSL_sk_delete_ptr(ossl_check_CONF_VALUE_sk_type(sk), ossl_check_CONF_VALUE_type(ptr)))
+#define sk_CONF_VALUE_push(sk, ptr) OPENSSL_sk_push(ossl_check_CONF_VALUE_sk_type(sk), ossl_check_CONF_VALUE_type(ptr))
+#define sk_CONF_VALUE_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_CONF_VALUE_sk_type(sk), ossl_check_CONF_VALUE_type(ptr))
+#define sk_CONF_VALUE_pop(sk) ((CONF_VALUE *)OPENSSL_sk_pop(ossl_check_CONF_VALUE_sk_type(sk)))
+#define sk_CONF_VALUE_shift(sk) ((CONF_VALUE *)OPENSSL_sk_shift(ossl_check_CONF_VALUE_sk_type(sk)))
+#define sk_CONF_VALUE_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_CONF_VALUE_sk_type(sk),ossl_check_CONF_VALUE_freefunc_type(freefunc))
+#define sk_CONF_VALUE_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_CONF_VALUE_sk_type(sk), ossl_check_CONF_VALUE_type(ptr), (idx))
+#define sk_CONF_VALUE_set(sk, idx, ptr) ((CONF_VALUE *)OPENSSL_sk_set(ossl_check_CONF_VALUE_sk_type(sk), (idx), ossl_check_CONF_VALUE_type(ptr)))
+#define sk_CONF_VALUE_find(sk, ptr) OPENSSL_sk_find(ossl_check_CONF_VALUE_sk_type(sk), ossl_check_CONF_VALUE_type(ptr))
+#define sk_CONF_VALUE_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_CONF_VALUE_sk_type(sk), ossl_check_CONF_VALUE_type(ptr))
+#define sk_CONF_VALUE_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_CONF_VALUE_sk_type(sk), ossl_check_CONF_VALUE_type(ptr), pnum)
+#define sk_CONF_VALUE_sort(sk) OPENSSL_sk_sort(ossl_check_CONF_VALUE_sk_type(sk))
+#define sk_CONF_VALUE_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_CONF_VALUE_sk_type(sk))
+#define sk_CONF_VALUE_dup(sk) ((STACK_OF(CONF_VALUE) *)OPENSSL_sk_dup(ossl_check_const_CONF_VALUE_sk_type(sk)))
+#define sk_CONF_VALUE_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(CONF_VALUE) *)OPENSSL_sk_deep_copy(ossl_check_const_CONF_VALUE_sk_type(sk), ossl_check_CONF_VALUE_copyfunc_type(copyfunc), ossl_check_CONF_VALUE_freefunc_type(freefunc)))
+#define sk_CONF_VALUE_set_cmp_func(sk, cmp) ((sk_CONF_VALUE_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_CONF_VALUE_sk_type(sk), ossl_check_CONF_VALUE_compfunc_type(cmp)))
+DEFINE_LHASH_OF_INTERNAL(CONF_VALUE);
+#define lh_CONF_VALUE_new(hfn, cmp) ((LHASH_OF(CONF_VALUE) *)OPENSSL_LH_set_thunks(OPENSSL_LH_new(ossl_check_CONF_VALUE_lh_hashfunc_type(hfn), ossl_check_CONF_VALUE_lh_compfunc_type(cmp)), lh_CONF_VALUE_hash_thunk, lh_CONF_VALUE_comp_thunk, lh_CONF_VALUE_doall_thunk, lh_CONF_VALUE_doall_arg_thunk))
+#define lh_CONF_VALUE_free(lh) OPENSSL_LH_free(ossl_check_CONF_VALUE_lh_type(lh))
+#define lh_CONF_VALUE_flush(lh) OPENSSL_LH_flush(ossl_check_CONF_VALUE_lh_type(lh))
+#define lh_CONF_VALUE_insert(lh, ptr) ((CONF_VALUE *)OPENSSL_LH_insert(ossl_check_CONF_VALUE_lh_type(lh), ossl_check_CONF_VALUE_lh_plain_type(ptr)))
+#define lh_CONF_VALUE_delete(lh, ptr) ((CONF_VALUE *)OPENSSL_LH_delete(ossl_check_CONF_VALUE_lh_type(lh), ossl_check_const_CONF_VALUE_lh_plain_type(ptr)))
+#define lh_CONF_VALUE_retrieve(lh, ptr) ((CONF_VALUE *)OPENSSL_LH_retrieve(ossl_check_CONF_VALUE_lh_type(lh), ossl_check_const_CONF_VALUE_lh_plain_type(ptr)))
+#define lh_CONF_VALUE_error(lh) OPENSSL_LH_error(ossl_check_CONF_VALUE_lh_type(lh))
+#define lh_CONF_VALUE_num_items(lh) OPENSSL_LH_num_items(ossl_check_CONF_VALUE_lh_type(lh))
+#define lh_CONF_VALUE_node_stats_bio(lh, out) OPENSSL_LH_node_stats_bio(ossl_check_const_CONF_VALUE_lh_type(lh), out)
+#define lh_CONF_VALUE_node_usage_stats_bio(lh, out) OPENSSL_LH_node_usage_stats_bio(ossl_check_const_CONF_VALUE_lh_type(lh), out)
+#define lh_CONF_VALUE_stats_bio(lh, out) OPENSSL_LH_stats_bio(ossl_check_const_CONF_VALUE_lh_type(lh), out)
+#define lh_CONF_VALUE_get_down_load(lh) OPENSSL_LH_get_down_load(ossl_check_CONF_VALUE_lh_type(lh))
+#define lh_CONF_VALUE_set_down_load(lh, dl) OPENSSL_LH_set_down_load(ossl_check_CONF_VALUE_lh_type(lh), dl)
+#define lh_CONF_VALUE_doall(lh, dfn) OPENSSL_LH_doall(ossl_check_CONF_VALUE_lh_type(lh), ossl_check_CONF_VALUE_lh_doallfunc_type(dfn))
+
+
+struct conf_st;
+struct conf_method_st;
+typedef struct conf_method_st CONF_METHOD;
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  include <openssl/conftypes.h>
+# endif
+
+/* Module definitions */
+typedef struct conf_imodule_st CONF_IMODULE;
+typedef struct conf_module_st CONF_MODULE;
+
+STACK_OF(CONF_MODULE);
+STACK_OF(CONF_IMODULE);
+
+/* DSO module function typedefs */
+typedef int conf_init_func (CONF_IMODULE *md, const CONF *cnf);
+typedef void conf_finish_func (CONF_IMODULE *md);
+
+# define CONF_MFLAGS_IGNORE_ERRORS       0x1
+# define CONF_MFLAGS_IGNORE_RETURN_CODES 0x2
+# define CONF_MFLAGS_SILENT              0x4
+# define CONF_MFLAGS_NO_DSO              0x8
+# define CONF_MFLAGS_IGNORE_MISSING_FILE 0x10
+# define CONF_MFLAGS_DEFAULT_SECTION     0x20
+
+int CONF_set_default_method(CONF_METHOD *meth);
+void CONF_set_nconf(CONF *conf, LHASH_OF(CONF_VALUE) *hash);
+LHASH_OF(CONF_VALUE) *CONF_load(LHASH_OF(CONF_VALUE) *conf, const char *file,
+                                long *eline);
+# ifndef OPENSSL_NO_STDIO
+LHASH_OF(CONF_VALUE) *CONF_load_fp(LHASH_OF(CONF_VALUE) *conf, FILE *fp,
+                                   long *eline);
+# endif
+LHASH_OF(CONF_VALUE) *CONF_load_bio(LHASH_OF(CONF_VALUE) *conf, BIO *bp,
+                                    long *eline);
+STACK_OF(CONF_VALUE) *CONF_get_section(LHASH_OF(CONF_VALUE) *conf,
+                                       const char *section);
+char *CONF_get_string(LHASH_OF(CONF_VALUE) *conf, const char *group,
+                      const char *name);
+long CONF_get_number(LHASH_OF(CONF_VALUE) *conf, const char *group,
+                     const char *name);
+void CONF_free(LHASH_OF(CONF_VALUE) *conf);
+#ifndef OPENSSL_NO_STDIO
+int CONF_dump_fp(LHASH_OF(CONF_VALUE) *conf, FILE *out);
+#endif
+int CONF_dump_bio(LHASH_OF(CONF_VALUE) *conf, BIO *out);
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+OSSL_DEPRECATEDIN_1_1_0 void OPENSSL_config(const char *config_name);
+#endif
+
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+# define OPENSSL_no_config() \
+    OPENSSL_init_crypto(OPENSSL_INIT_NO_LOAD_CONFIG, NULL)
+#endif
+
+/*
+ * New conf code.  The semantics are different from the functions above. If
+ * that wasn't the case, the above functions would have been replaced
+ */
+
+CONF *NCONF_new_ex(OSSL_LIB_CTX *libctx, CONF_METHOD *meth);
+OSSL_LIB_CTX *NCONF_get0_libctx(const CONF *conf);
+CONF *NCONF_new(CONF_METHOD *meth);
+CONF_METHOD *NCONF_default(void);
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 CONF_METHOD *NCONF_WIN32(void);
+#endif
+void NCONF_free(CONF *conf);
+void NCONF_free_data(CONF *conf);
+
+int NCONF_load(CONF *conf, const char *file, long *eline);
+# ifndef OPENSSL_NO_STDIO
+int NCONF_load_fp(CONF *conf, FILE *fp, long *eline);
+# endif
+int NCONF_load_bio(CONF *conf, BIO *bp, long *eline);
+STACK_OF(OPENSSL_CSTRING) *NCONF_get_section_names(const CONF *conf);
+STACK_OF(CONF_VALUE) *NCONF_get_section(const CONF *conf,
+                                        const char *section);
+char *NCONF_get_string(const CONF *conf, const char *group, const char *name);
+int NCONF_get_number_e(const CONF *conf, const char *group, const char *name,
+                       long *result);
+#ifndef OPENSSL_NO_STDIO
+int NCONF_dump_fp(const CONF *conf, FILE *out);
+#endif
+int NCONF_dump_bio(const CONF *conf, BIO *out);
+
+#define NCONF_get_number(c,g,n,r) NCONF_get_number_e(c,g,n,r)
+
+/* Module functions */
+
+int CONF_modules_load(const CONF *cnf, const char *appname,
+                      unsigned long flags);
+int CONF_modules_load_file_ex(OSSL_LIB_CTX *libctx, const char *filename,
+                              const char *appname, unsigned long flags);
+int CONF_modules_load_file(const char *filename, const char *appname,
+                           unsigned long flags);
+void CONF_modules_unload(int all);
+void CONF_modules_finish(void);
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+# define CONF_modules_free() while(0) continue
+#endif
+int CONF_module_add(const char *name, conf_init_func *ifunc,
+                    conf_finish_func *ffunc);
+
+const char *CONF_imodule_get_name(const CONF_IMODULE *md);
+const char *CONF_imodule_get_value(const CONF_IMODULE *md);
+void *CONF_imodule_get_usr_data(const CONF_IMODULE *md);
+void CONF_imodule_set_usr_data(CONF_IMODULE *md, void *usr_data);
+CONF_MODULE *CONF_imodule_get_module(const CONF_IMODULE *md);
+unsigned long CONF_imodule_get_flags(const CONF_IMODULE *md);
+void CONF_imodule_set_flags(CONF_IMODULE *md, unsigned long flags);
+void *CONF_module_get_usr_data(CONF_MODULE *pmod);
+void CONF_module_set_usr_data(CONF_MODULE *pmod, void *usr_data);
+
+char *CONF_get1_default_config_file(void);
+
+int CONF_parse_list(const char *list, int sep, int nospc,
+                    int (*list_cb) (const char *elem, int len, void *usr),
+                    void *arg);
+
+void OPENSSL_load_builtin_modules(void);
+
+
+# ifdef  __cplusplus
+}
+# endif
+#endif
diff --git a/src/include/openssl/conf_api.h b/src/include/openssl/conf_api.h
new file mode 100644
index 0000000..ed67d57
--- /dev/null
+++ b/src/include/openssl/conf_api.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef  OPENSSL_CONF_API_H
+# define OPENSSL_CONF_API_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_CONF_API_H
+# endif
+
+# include <openssl/lhash.h>
+# include <openssl/conf.h>
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+/* Up until OpenSSL 0.9.5a, this was new_section */
+CONF_VALUE *_CONF_new_section(CONF *conf, const char *section);
+/* Up until OpenSSL 0.9.5a, this was get_section */
+CONF_VALUE *_CONF_get_section(const CONF *conf, const char *section);
+/* Up until OpenSSL 0.9.5a, this was CONF_get_section */
+STACK_OF(CONF_VALUE) *_CONF_get_section_values(const CONF *conf,
+                                               const char *section);
+
+int _CONF_add_string(CONF *conf, CONF_VALUE *section, CONF_VALUE *value);
+char *_CONF_get_string(const CONF *conf, const char *section,
+                       const char *name);
+long _CONF_get_number(const CONF *conf, const char *section,
+                      const char *name);
+
+int _CONF_new_data(CONF *conf);
+void _CONF_free_data(CONF *conf);
+
+#ifdef  __cplusplus
+}
+#endif
+#endif
diff --git a/src/include/openssl/conferr.h b/src/include/openssl/conferr.h
new file mode 100644
index 0000000..a8798e7
--- /dev/null
+++ b/src/include/openssl/conferr.h
@@ -0,0 +1,52 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_CONFERR_H
+# define OPENSSL_CONFERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+
+/*
+ * CONF reason codes.
+ */
+# define CONF_R_ERROR_LOADING_DSO                         110
+# define CONF_R_INVALID_PRAGMA                            122
+# define CONF_R_LIST_CANNOT_BE_NULL                       115
+# define CONF_R_MANDATORY_BRACES_IN_VARIABLE_EXPANSION    123
+# define CONF_R_MISSING_CLOSE_SQUARE_BRACKET              100
+# define CONF_R_MISSING_EQUAL_SIGN                        101
+# define CONF_R_MISSING_INIT_FUNCTION                     112
+# define CONF_R_MODULE_INITIALIZATION_ERROR               109
+# define CONF_R_NO_CLOSE_BRACE                            102
+# define CONF_R_NO_CONF                                   105
+# define CONF_R_NO_CONF_OR_ENVIRONMENT_VARIABLE           106
+# define CONF_R_NO_SECTION                                107
+# define CONF_R_NO_SUCH_FILE                              114
+# define CONF_R_NO_VALUE                                  108
+# define CONF_R_NUMBER_TOO_LARGE                          121
+# define CONF_R_OPENSSL_CONF_REFERENCES_MISSING_SECTION   124
+# define CONF_R_RECURSIVE_DIRECTORY_INCLUDE               111
+# define CONF_R_RECURSIVE_SECTION_REFERENCE               126
+# define CONF_R_RELATIVE_PATH                             125
+# define CONF_R_SSL_COMMAND_SECTION_EMPTY                 117
+# define CONF_R_SSL_COMMAND_SECTION_NOT_FOUND             118
+# define CONF_R_SSL_SECTION_EMPTY                         119
+# define CONF_R_SSL_SECTION_NOT_FOUND                     120
+# define CONF_R_UNABLE_TO_CREATE_NEW_SECTION              103
+# define CONF_R_UNKNOWN_MODULE_NAME                       113
+# define CONF_R_VARIABLE_EXPANSION_TOO_LONG               116
+# define CONF_R_VARIABLE_HAS_NO_VALUE                     104
+
+#endif
diff --git a/src/include/openssl/configuration.h b/src/include/openssl/configuration.h
new file mode 100644
index 0000000..8b19f49
--- /dev/null
+++ b/src/include/openssl/configuration.h
@@ -0,0 +1,161 @@
+/*
+ * WARNING: do not edit!
+ * Generated by configdata.pm from Configurations\common0.tmpl, Configurations\windows-makefile.tmpl
+ * via makefile.in
+ *
+ * Copyright 2016-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_CONFIGURATION_H
+# define OPENSSL_CONFIGURATION_H
+# pragma once
+
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+# ifdef OPENSSL_ALGORITHM_DEFINES
+#  error OPENSSL_ALGORITHM_DEFINES no longer supported
+# endif
+
+/*
+ * OpenSSL was configured with the following options:
+ */
+
+# ifndef OPENSSL_SYS_WIN32
+#  define OPENSSL_SYS_WIN32 1
+# endif
+# define OPENSSL_CONFIGURED_API 30300
+# ifndef OPENSSL_RAND_SEED_OS
+#  define OPENSSL_RAND_SEED_OS
+# endif
+# ifndef OPENSSL_THREADS
+#  define OPENSSL_THREADS
+# endif
+# ifndef OPENSSL_NO_ACVP_TESTS
+#  define OPENSSL_NO_ACVP_TESTS
+# endif
+# ifndef OPENSSL_NO_AFALGENG
+#  define OPENSSL_NO_AFALGENG
+# endif
+# ifndef OPENSSL_NO_ASAN
+#  define OPENSSL_NO_ASAN
+# endif
+# ifndef OPENSSL_NO_BROTLI
+#  define OPENSSL_NO_BROTLI
+# endif
+# ifndef OPENSSL_NO_BROTLI_DYNAMIC
+#  define OPENSSL_NO_BROTLI_DYNAMIC
+# endif
+# ifndef OPENSSL_NO_CRYPTO_MDEBUG
+#  define OPENSSL_NO_CRYPTO_MDEBUG
+# endif
+# ifndef OPENSSL_NO_CRYPTO_MDEBUG_BACKTRACE
+#  define OPENSSL_NO_CRYPTO_MDEBUG_BACKTRACE
+# endif
+# ifndef OPENSSL_NO_DEVCRYPTOENG
+#  define OPENSSL_NO_DEVCRYPTOENG
+# endif
+# ifndef OPENSSL_NO_EC_NISTP_64_GCC_128
+#  define OPENSSL_NO_EC_NISTP_64_GCC_128
+# endif
+# ifndef OPENSSL_NO_EGD
+#  define OPENSSL_NO_EGD
+# endif
+# ifndef OPENSSL_NO_EXTERNAL_TESTS
+#  define OPENSSL_NO_EXTERNAL_TESTS
+# endif
+# ifndef OPENSSL_NO_FIPS_SECURITYCHECKS
+#  define OPENSSL_NO_FIPS_SECURITYCHECKS
+# endif
+# ifndef OPENSSL_NO_FUZZ_AFL
+#  define OPENSSL_NO_FUZZ_AFL
+# endif
+# ifndef OPENSSL_NO_FUZZ_LIBFUZZER
+#  define OPENSSL_NO_FUZZ_LIBFUZZER
+# endif
+# ifndef OPENSSL_NO_KTLS
+#  define OPENSSL_NO_KTLS
+# endif
+# ifndef OPENSSL_NO_MD2
+#  define OPENSSL_NO_MD2
+# endif
+# ifndef OPENSSL_NO_MSAN
+#  define OPENSSL_NO_MSAN
+# endif
+# ifndef OPENSSL_NO_RC5
+#  define OPENSSL_NO_RC5
+# endif
+# ifndef OPENSSL_NO_SCTP
+#  define OPENSSL_NO_SCTP
+# endif
+# ifndef OPENSSL_NO_SSL3
+#  define OPENSSL_NO_SSL3
+# endif
+# ifndef OPENSSL_NO_SSL3_METHOD
+#  define OPENSSL_NO_SSL3_METHOD
+# endif
+# ifndef OPENSSL_NO_TFO
+#  define OPENSSL_NO_TFO
+# endif
+# ifndef OPENSSL_NO_TRACE
+#  define OPENSSL_NO_TRACE
+# endif
+# ifndef OPENSSL_NO_UBSAN
+#  define OPENSSL_NO_UBSAN
+# endif
+# ifndef OPENSSL_NO_UNIT_TEST
+#  define OPENSSL_NO_UNIT_TEST
+# endif
+# ifndef OPENSSL_NO_WEAK_SSL_CIPHERS
+#  define OPENSSL_NO_WEAK_SSL_CIPHERS
+# endif
+# ifndef OPENSSL_NO_ZLIB
+#  define OPENSSL_NO_ZLIB
+# endif
+# ifndef OPENSSL_NO_ZLIB_DYNAMIC
+#  define OPENSSL_NO_ZLIB_DYNAMIC
+# endif
+# ifndef OPENSSL_NO_ZSTD
+#  define OPENSSL_NO_ZSTD
+# endif
+# ifndef OPENSSL_NO_ZSTD_DYNAMIC
+#  define OPENSSL_NO_ZSTD_DYNAMIC
+# endif
+# ifndef OPENSSL_NO_STATIC_ENGINE
+#  define OPENSSL_NO_STATIC_ENGINE
+# endif
+
+
+/* Generate 80386 code? */
+# undef I386_ONLY
+
+/*
+ * The following are cipher-specific, but are part of the public API.
+ */
+# if !defined(OPENSSL_SYS_UEFI)
+#  define BN_LLONG
+/* Only one for the following should be defined */
+#  undef SIXTY_FOUR_BIT_LONG
+#  undef SIXTY_FOUR_BIT
+#  define THIRTY_TWO_BIT
+# endif
+
+# define RC4_INT unsigned int
+
+# if defined(OPENSSL_NO_COMP) || (defined(OPENSSL_NO_BROTLI) && defined(OPENSSL_NO_ZSTD) && defined(OPENSSL_NO_ZLIB))
+#  define OPENSSL_NO_COMP_ALG
+# else
+#  undef  OPENSSL_NO_COMP_ALG
+# endif
+
+# ifdef  __cplusplus
+}
+# endif
+
+#endif                          /* OPENSSL_CONFIGURATION_H */
diff --git a/src/include/openssl/conftypes.h b/src/include/openssl/conftypes.h
new file mode 100644
index 0000000..17cefaa
--- /dev/null
+++ b/src/include/openssl/conftypes.h
@@ -0,0 +1,44 @@
+/*
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef  OPENSSL_CONFTYPES_H
+# define OPENSSL_CONFTYPES_H
+# pragma once
+
+#ifndef  OPENSSL_CONF_H
+# include <openssl/conf.h>
+#endif
+
+/*
+ * The contents of this file are deprecated and will be made opaque
+ */
+struct conf_method_st {
+    const char *name;
+    CONF *(*create) (CONF_METHOD *meth);
+    int (*init) (CONF *conf);
+    int (*destroy) (CONF *conf);
+    int (*destroy_data) (CONF *conf);
+    int (*load_bio) (CONF *conf, BIO *bp, long *eline);
+    int (*dump) (const CONF *conf, BIO *bp);
+    int (*is_number) (const CONF *conf, char c);
+    int (*to_int) (const CONF *conf, char c);
+    int (*load) (CONF *conf, const char *name, long *eline);
+};
+
+struct conf_st {
+    CONF_METHOD *meth;
+    void *meth_data;
+    LHASH_OF(CONF_VALUE) *data;
+    int flag_dollarid;
+    int flag_abspath;
+    char *includedir;
+    OSSL_LIB_CTX *libctx;
+};
+
+#endif
diff --git a/src/include/openssl/core.h b/src/include/openssl/core.h
new file mode 100644
index 0000000..18c1991
--- /dev/null
+++ b/src/include/openssl/core.h
@@ -0,0 +1,236 @@
+/*
+ * Copyright 2019-2023 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_CORE_H
+# define OPENSSL_CORE_H
+# pragma once
+
+# include <stddef.h>
+# include <openssl/types.h>
+
+# ifdef __cplusplus
+extern "C" {
+# endif
+
+/*-
+ * Base types
+ * ----------
+ *
+ * These are the types that the OpenSSL core and providers have in common
+ * to communicate data between them.
+ */
+
+/* Opaque handles to be used with core upcall functions from providers */
+typedef struct ossl_core_handle_st OSSL_CORE_HANDLE;
+typedef struct openssl_core_ctx_st OPENSSL_CORE_CTX;
+typedef struct ossl_core_bio_st OSSL_CORE_BIO;
+
+/*
+ * Dispatch table element.  function_id numbers and the functions are defined
+ * in core_dispatch.h, see macros with 'OSSL_CORE_MAKE_FUNC' in their names.
+ *
+ * An array of these is always terminated by function_id == 0
+ */
+struct ossl_dispatch_st {
+    int function_id;
+    void (*function)(void);
+};
+
+# define OSSL_DISPATCH_END \
+    { 0, NULL }
+
+/*
+ * Other items, essentially an int<->pointer map element.
+ *
+ * We make this type distinct from OSSL_DISPATCH to ensure that dispatch
+ * tables remain tables with function pointers only.
+ *
+ * This is used whenever we need to pass things like a table of error reason
+ * codes <-> reason string maps, ...
+ *
+ * Usage determines which field works as key if any, rather than field order.
+ *
+ * An array of these is always terminated by id == 0 && ptr == NULL
+ */
+struct ossl_item_st {
+    unsigned int id;
+    void *ptr;
+};
+
+/*
+ * Type to tie together algorithm names, property definition string and
+ * the algorithm implementation in the form of a dispatch table.
+ *
+ * An array of these is always terminated by algorithm_names == NULL
+ */
+struct ossl_algorithm_st {
+    const char *algorithm_names;     /* key */
+    const char *property_definition; /* key */
+    const OSSL_DISPATCH *implementation;
+    const char *algorithm_description;
+};
+
+/*
+ * Type to pass object data in a uniform way, without exposing the object
+ * structure.
+ *
+ * An array of these is always terminated by key == NULL
+ */
+struct ossl_param_st {
+    const char *key;             /* the name of the parameter */
+    unsigned int data_type;      /* declare what kind of content is in buffer */
+    void *data;                  /* value being passed in or out */
+    size_t data_size;            /* data size */
+    size_t return_size;          /* returned content size */
+};
+
+/* Currently supported OSSL_PARAM data types */
+/*
+ * OSSL_PARAM_INTEGER and OSSL_PARAM_UNSIGNED_INTEGER
+ * are arbitrary length and therefore require an arbitrarily sized buffer,
+ * since they may be used to pass numbers larger than what is natively
+ * available.
+ *
+ * The number must be buffered in native form, i.e. MSB first on B_ENDIAN
+ * systems and LSB first on L_ENDIAN systems.  This means that arbitrary
+ * native integers can be stored in the buffer, just make sure that the
+ * buffer size is correct and the buffer itself is properly aligned (for
+ * example by having the buffer field point at a C integer).
+ */
+# define OSSL_PARAM_INTEGER              1
+# define OSSL_PARAM_UNSIGNED_INTEGER     2
+/*-
+ * OSSL_PARAM_REAL
+ * is a C binary floating point values in native form and alignment.
+ */
+# define OSSL_PARAM_REAL                 3
+/*-
+ * OSSL_PARAM_UTF8_STRING
+ * is a printable string.  It is expected to be printed as it is.
+ */
+# define OSSL_PARAM_UTF8_STRING          4
+/*-
+ * OSSL_PARAM_OCTET_STRING
+ * is a string of bytes with no further specification.  It is expected to be
+ * printed as a hexdump.
+ */
+# define OSSL_PARAM_OCTET_STRING         5
+/*-
+ * OSSL_PARAM_UTF8_PTR
+ * is a pointer to a printable string.  It is expected to be printed as it is.
+ *
+ * The difference between this and OSSL_PARAM_UTF8_STRING is that only pointers
+ * are manipulated for this type.
+ *
+ * This is more relevant for parameter requests, where the responding
+ * function doesn't need to copy the data to the provided buffer, but
+ * sets the provided buffer to point at the actual data instead.
+ *
+ * WARNING!  Using these is FRAGILE, as it assumes that the actual
+ * data and its location are constant.
+ *
+ * EXTRA WARNING!  If you are not completely sure you most likely want
+ * to use the OSSL_PARAM_UTF8_STRING type.
+ */
+# define OSSL_PARAM_UTF8_PTR             6
+/*-
+ * OSSL_PARAM_OCTET_PTR
+ * is a pointer to a string of bytes with no further specification.  It is
+ * expected to be printed as a hexdump.
+ *
+ * The difference between this and OSSL_PARAM_OCTET_STRING is that only pointers
+ * are manipulated for this type.
+ *
+ * This is more relevant for parameter requests, where the responding
+ * function doesn't need to copy the data to the provided buffer, but
+ * sets the provided buffer to point at the actual data instead.
+ *
+ * WARNING!  Using these is FRAGILE, as it assumes that the actual
+ * data and its location are constant.
+ *
+ * EXTRA WARNING!  If you are not completely sure you most likely want
+ * to use the OSSL_PARAM_OCTET_STRING type.
+ */
+# define OSSL_PARAM_OCTET_PTR            7
+
+/*
+ * Typedef for the thread stop handling callback. Used both internally and by
+ * providers.
+ *
+ * Providers may register for notifications about threads stopping by
+ * registering a callback to hear about such events. Providers register the
+ * callback using the OSSL_FUNC_CORE_THREAD_START function in the |in| dispatch
+ * table passed to OSSL_provider_init(). The arg passed back to a provider will
+ * be the provider side context object.
+ */
+typedef void (*OSSL_thread_stop_handler_fn)(void *arg);
+
+
+/*-
+ * Provider entry point
+ * --------------------
+ *
+ * This function is expected to be present in any dynamically loadable
+ * provider module.  By definition, if this function doesn't exist in a
+ * module, that module is not an OpenSSL provider module.
+ */
+/*-
+ * |handle|     pointer to opaque type OSSL_CORE_HANDLE.  This can be used
+ *              together with some functions passed via |in| to query data.
+ * |in|         is the array of functions that the Core passes to the provider.
+ * |out|        will be the array of base functions that the provider passes
+ *              back to the Core.
+ * |provctx|    a provider side context object, optionally created if the
+ *              provider needs it.  This value is passed to other provider
+ *              functions, notably other context constructors.
+ */
+typedef int (OSSL_provider_init_fn)(const OSSL_CORE_HANDLE *handle,
+                                    const OSSL_DISPATCH *in,
+                                    const OSSL_DISPATCH **out,
+                                    void **provctx);
+# ifdef __VMS
+#  pragma names save
+#  pragma names uppercase,truncated
+# endif
+OPENSSL_EXPORT OSSL_provider_init_fn OSSL_provider_init;
+# ifdef __VMS
+#  pragma names restore
+# endif
+
+/*
+ * Generic callback function signature.
+ *
+ * The expectation is that any provider function that wants to offer
+ * a callback / hook can do so by taking an argument with this type,
+ * as well as a pointer to caller-specific data.  When calling the
+ * callback, the provider function can populate an OSSL_PARAM array
+ * with data of its choice and pass that in the callback call, along
+ * with the caller data argument.
+ *
+ * libcrypto may use the OSSL_PARAM array to create arguments for an
+ * application callback it knows about.
+ */
+typedef int (OSSL_CALLBACK)(const OSSL_PARAM params[], void *arg);
+typedef int (OSSL_INOUT_CALLBACK)(const OSSL_PARAM in_params[],
+                                  OSSL_PARAM out_params[], void *arg);
+/*
+ * Passphrase callback function signature
+ *
+ * This is similar to the generic callback function above, but adds a
+ * result parameter.
+ */
+typedef int (OSSL_PASSPHRASE_CALLBACK)(char *pass, size_t pass_size,
+                                       size_t *pass_len,
+                                       const OSSL_PARAM params[], void *arg);
+
+# ifdef __cplusplus
+}
+# endif
+
+#endif
diff --git a/src/include/openssl/core_dispatch.h b/src/include/openssl/core_dispatch.h
new file mode 100644
index 0000000..a5bc2cf
--- /dev/null
+++ b/src/include/openssl/core_dispatch.h
@@ -0,0 +1,988 @@
+/*
+ * Copyright 2019-2023 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_CORE_NUMBERS_H
+# define OPENSSL_CORE_NUMBERS_H
+# pragma once
+
+# include <stdarg.h>
+# include <openssl/core.h>
+
+# ifdef __cplusplus
+extern "C" {
+# endif
+
+/*-
+ * Identities
+ * ----------
+ *
+ * All series start with 1, to allow 0 to be an array terminator.
+ * For any FUNC identity, we also provide a function signature typedef
+ * and a static inline function to extract a function pointer from a
+ * OSSL_DISPATCH element in a type safe manner.
+ *
+ * Names:
+ * for any function base name 'foo' (uppercase form 'FOO'), we will have
+ * the following:
+ * - a macro for the identity with the name OSSL_FUNC_'FOO' or derivatives
+ *   thereof (to be specified further down)
+ * - a function signature typedef with the name OSSL_FUNC_'foo'_fn
+ * - a function pointer extractor function with the name OSSL_FUNC_'foo'
+ */
+
+/*
+ * Helper macro to create the function signature typedef and the extractor
+ * |type| is the return-type of the function, |name| is the name of the
+ * function to fetch, and |args| is a parenthesized list of parameters
+ * for the function (that is, it is |name|'s function signature).
+ * Note: This is considered a "reserved" internal macro. Applications should
+ * not use this or assume its existence.
+ */
+#define OSSL_CORE_MAKE_FUNC(type,name,args)                             \
+    typedef type (OSSL_FUNC_##name##_fn)args;                           \
+    static ossl_unused ossl_inline \
+    OSSL_FUNC_##name##_fn *OSSL_FUNC_##name(const OSSL_DISPATCH *opf)   \
+    {                                                                   \
+        return (OSSL_FUNC_##name##_fn *)opf->function;                  \
+    }
+
+/*
+ * Core function identities, for the two OSSL_DISPATCH tables being passed
+ * in the OSSL_provider_init call.
+ *
+ * 0 serves as a marker for the end of the OSSL_DISPATCH array, and must
+ * therefore NEVER be used as a function identity.
+ */
+/* Functions provided by the Core to the provider, reserved numbers 1-1023 */
+# define OSSL_FUNC_CORE_GETTABLE_PARAMS        1
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *,
+                    core_gettable_params,(const OSSL_CORE_HANDLE *prov))
+# define OSSL_FUNC_CORE_GET_PARAMS             2
+OSSL_CORE_MAKE_FUNC(int,core_get_params,(const OSSL_CORE_HANDLE *prov,
+                                         OSSL_PARAM params[]))
+# define OSSL_FUNC_CORE_THREAD_START           3
+OSSL_CORE_MAKE_FUNC(int,core_thread_start,(const OSSL_CORE_HANDLE *prov,
+                                           OSSL_thread_stop_handler_fn handfn,
+                                           void *arg))
+# define OSSL_FUNC_CORE_GET_LIBCTX             4
+OSSL_CORE_MAKE_FUNC(OPENSSL_CORE_CTX *,core_get_libctx,
+                    (const OSSL_CORE_HANDLE *prov))
+# define OSSL_FUNC_CORE_NEW_ERROR              5
+OSSL_CORE_MAKE_FUNC(void,core_new_error,(const OSSL_CORE_HANDLE *prov))
+# define OSSL_FUNC_CORE_SET_ERROR_DEBUG        6
+OSSL_CORE_MAKE_FUNC(void,core_set_error_debug,
+                    (const OSSL_CORE_HANDLE *prov,
+                     const char *file, int line, const char *func))
+# define OSSL_FUNC_CORE_VSET_ERROR             7
+OSSL_CORE_MAKE_FUNC(void,core_vset_error,
+                    (const OSSL_CORE_HANDLE *prov,
+                     uint32_t reason, const char *fmt, va_list args))
+# define OSSL_FUNC_CORE_SET_ERROR_MARK         8
+OSSL_CORE_MAKE_FUNC(int, core_set_error_mark, (const OSSL_CORE_HANDLE *prov))
+# define OSSL_FUNC_CORE_CLEAR_LAST_ERROR_MARK  9
+OSSL_CORE_MAKE_FUNC(int, core_clear_last_error_mark,
+                    (const OSSL_CORE_HANDLE *prov))
+# define OSSL_FUNC_CORE_POP_ERROR_TO_MARK     10
+OSSL_CORE_MAKE_FUNC(int, core_pop_error_to_mark, (const OSSL_CORE_HANDLE *prov))
+
+
+/* Functions to access the OBJ database */
+
+#define OSSL_FUNC_CORE_OBJ_ADD_SIGID          11
+#define OSSL_FUNC_CORE_OBJ_CREATE             12
+
+OSSL_CORE_MAKE_FUNC(int, core_obj_add_sigid,
+                    (const OSSL_CORE_HANDLE *prov, const char  *sign_name,
+                     const char *digest_name, const char *pkey_name))
+OSSL_CORE_MAKE_FUNC(int, core_obj_create,
+                    (const OSSL_CORE_HANDLE *prov, const char *oid,
+                     const char *sn, const char *ln))
+
+/* Memory allocation, freeing, clearing. */
+#define OSSL_FUNC_CRYPTO_MALLOC               20
+OSSL_CORE_MAKE_FUNC(void *,
+        CRYPTO_malloc, (size_t num, const char *file, int line))
+#define OSSL_FUNC_CRYPTO_ZALLOC               21
+OSSL_CORE_MAKE_FUNC(void *,
+        CRYPTO_zalloc, (size_t num, const char *file, int line))
+#define OSSL_FUNC_CRYPTO_FREE                 22
+OSSL_CORE_MAKE_FUNC(void,
+        CRYPTO_free, (void *ptr, const char *file, int line))
+#define OSSL_FUNC_CRYPTO_CLEAR_FREE           23
+OSSL_CORE_MAKE_FUNC(void,
+        CRYPTO_clear_free, (void *ptr, size_t num, const char *file, int line))
+#define OSSL_FUNC_CRYPTO_REALLOC              24
+OSSL_CORE_MAKE_FUNC(void *,
+        CRYPTO_realloc, (void *addr, size_t num, const char *file, int line))
+#define OSSL_FUNC_CRYPTO_CLEAR_REALLOC        25
+OSSL_CORE_MAKE_FUNC(void *,
+        CRYPTO_clear_realloc, (void *addr, size_t old_num, size_t num,
+                               const char *file, int line))
+#define OSSL_FUNC_CRYPTO_SECURE_MALLOC        26
+OSSL_CORE_MAKE_FUNC(void *,
+        CRYPTO_secure_malloc, (size_t num, const char *file, int line))
+#define OSSL_FUNC_CRYPTO_SECURE_ZALLOC        27
+OSSL_CORE_MAKE_FUNC(void *,
+        CRYPTO_secure_zalloc, (size_t num, const char *file, int line))
+#define OSSL_FUNC_CRYPTO_SECURE_FREE          28
+OSSL_CORE_MAKE_FUNC(void,
+        CRYPTO_secure_free, (void *ptr, const char *file, int line))
+#define OSSL_FUNC_CRYPTO_SECURE_CLEAR_FREE    29
+OSSL_CORE_MAKE_FUNC(void,
+        CRYPTO_secure_clear_free, (void *ptr, size_t num, const char *file,
+                                   int line))
+#define OSSL_FUNC_CRYPTO_SECURE_ALLOCATED     30
+OSSL_CORE_MAKE_FUNC(int,
+        CRYPTO_secure_allocated, (const void *ptr))
+#define OSSL_FUNC_OPENSSL_CLEANSE             31
+OSSL_CORE_MAKE_FUNC(void,
+        OPENSSL_cleanse, (void *ptr, size_t len))
+
+/* Bio functions provided by the core */
+#define OSSL_FUNC_BIO_NEW_FILE                40
+#define OSSL_FUNC_BIO_NEW_MEMBUF              41
+#define OSSL_FUNC_BIO_READ_EX                 42
+#define OSSL_FUNC_BIO_WRITE_EX                43
+#define OSSL_FUNC_BIO_UP_REF                  44
+#define OSSL_FUNC_BIO_FREE                    45
+#define OSSL_FUNC_BIO_VPRINTF                 46
+#define OSSL_FUNC_BIO_VSNPRINTF               47
+#define OSSL_FUNC_BIO_PUTS                    48
+#define OSSL_FUNC_BIO_GETS                    49
+#define OSSL_FUNC_BIO_CTRL                    50
+
+
+OSSL_CORE_MAKE_FUNC(OSSL_CORE_BIO *, BIO_new_file, (const char *filename,
+                                                    const char *mode))
+OSSL_CORE_MAKE_FUNC(OSSL_CORE_BIO *, BIO_new_membuf, (const void *buf, int len))
+OSSL_CORE_MAKE_FUNC(int, BIO_read_ex, (OSSL_CORE_BIO *bio, void *data,
+                                       size_t data_len, size_t *bytes_read))
+OSSL_CORE_MAKE_FUNC(int, BIO_write_ex, (OSSL_CORE_BIO *bio, const void *data,
+                                        size_t data_len, size_t *written))
+OSSL_CORE_MAKE_FUNC(int, BIO_gets, (OSSL_CORE_BIO *bio, char *buf, int size))
+OSSL_CORE_MAKE_FUNC(int, BIO_puts, (OSSL_CORE_BIO *bio, const char *str))
+OSSL_CORE_MAKE_FUNC(int, BIO_up_ref, (OSSL_CORE_BIO *bio))
+OSSL_CORE_MAKE_FUNC(int, BIO_free, (OSSL_CORE_BIO *bio))
+OSSL_CORE_MAKE_FUNC(int, BIO_vprintf, (OSSL_CORE_BIO *bio, const char *format,
+                                       va_list args))
+OSSL_CORE_MAKE_FUNC(int, BIO_vsnprintf,
+                   (char *buf, size_t n, const char *fmt, va_list args))
+OSSL_CORE_MAKE_FUNC(int, BIO_ctrl, (OSSL_CORE_BIO *bio,
+                                    int cmd, long num, void *ptr))
+
+/* New seeding functions prototypes with the 101-104 series */
+#define OSSL_FUNC_CLEANUP_USER_ENTROPY        96
+#define OSSL_FUNC_CLEANUP_USER_NONCE          97
+#define OSSL_FUNC_GET_USER_ENTROPY            98
+#define OSSL_FUNC_GET_USER_NONCE              99
+
+#define OSSL_FUNC_SELF_TEST_CB               100
+OSSL_CORE_MAKE_FUNC(void, self_test_cb, (OPENSSL_CORE_CTX *ctx, OSSL_CALLBACK **cb,
+                                         void **cbarg))
+
+/* Functions to get seed material from the operating system */
+#define OSSL_FUNC_GET_ENTROPY                101
+#define OSSL_FUNC_CLEANUP_ENTROPY            102
+#define OSSL_FUNC_GET_NONCE                  103
+#define OSSL_FUNC_CLEANUP_NONCE              104
+OSSL_CORE_MAKE_FUNC(size_t, get_entropy, (const OSSL_CORE_HANDLE *handle,
+                                          unsigned char **pout, int entropy,
+                                          size_t min_len, size_t max_len))
+OSSL_CORE_MAKE_FUNC(size_t, get_user_entropy, (const OSSL_CORE_HANDLE *handle,
+                                               unsigned char **pout, int entropy,
+                                               size_t min_len, size_t max_len))
+OSSL_CORE_MAKE_FUNC(void, cleanup_entropy, (const OSSL_CORE_HANDLE *handle,
+                                            unsigned char *buf, size_t len))
+OSSL_CORE_MAKE_FUNC(void, cleanup_user_entropy, (const OSSL_CORE_HANDLE *handle,
+                                                 unsigned char *buf, size_t len))
+OSSL_CORE_MAKE_FUNC(size_t, get_nonce, (const OSSL_CORE_HANDLE *handle,
+                                        unsigned char **pout, size_t min_len,
+                                        size_t max_len, const void *salt,
+                                        size_t salt_len))
+OSSL_CORE_MAKE_FUNC(size_t, get_user_nonce, (const OSSL_CORE_HANDLE *handle,
+                                             unsigned char **pout, size_t min_len,
+                                             size_t max_len, const void *salt,
+                                             size_t salt_len))
+OSSL_CORE_MAKE_FUNC(void, cleanup_nonce, (const OSSL_CORE_HANDLE *handle,
+                                          unsigned char *buf, size_t len))
+OSSL_CORE_MAKE_FUNC(void, cleanup_user_nonce, (const OSSL_CORE_HANDLE *handle,
+                                               unsigned char *buf, size_t len))
+
+/* Functions to access the core's providers */
+#define OSSL_FUNC_PROVIDER_REGISTER_CHILD_CB   105
+#define OSSL_FUNC_PROVIDER_DEREGISTER_CHILD_CB 106
+#define OSSL_FUNC_PROVIDER_NAME                107
+#define OSSL_FUNC_PROVIDER_GET0_PROVIDER_CTX   108
+#define OSSL_FUNC_PROVIDER_GET0_DISPATCH       109
+#define OSSL_FUNC_PROVIDER_UP_REF              110
+#define OSSL_FUNC_PROVIDER_FREE                111
+
+OSSL_CORE_MAKE_FUNC(int, provider_register_child_cb,
+                    (const OSSL_CORE_HANDLE *handle,
+                     int (*create_cb)(const OSSL_CORE_HANDLE *provider, void *cbdata),
+                     int (*remove_cb)(const OSSL_CORE_HANDLE *provider, void *cbdata),
+                     int (*global_props_cb)(const char *props, void *cbdata),
+                     void *cbdata))
+OSSL_CORE_MAKE_FUNC(void, provider_deregister_child_cb,
+                    (const OSSL_CORE_HANDLE *handle))
+OSSL_CORE_MAKE_FUNC(const char *, provider_name,
+                    (const OSSL_CORE_HANDLE *prov))
+OSSL_CORE_MAKE_FUNC(void *, provider_get0_provider_ctx,
+                    (const OSSL_CORE_HANDLE *prov))
+OSSL_CORE_MAKE_FUNC(const OSSL_DISPATCH *, provider_get0_dispatch,
+                    (const OSSL_CORE_HANDLE *prov))
+OSSL_CORE_MAKE_FUNC(int, provider_up_ref,
+                    (const OSSL_CORE_HANDLE *prov, int activate))
+OSSL_CORE_MAKE_FUNC(int, provider_free,
+                    (const OSSL_CORE_HANDLE *prov, int deactivate))
+
+/* Functions provided by the provider to the Core, reserved numbers 1024-1535 */
+# define OSSL_FUNC_PROVIDER_TEARDOWN           1024
+OSSL_CORE_MAKE_FUNC(void,provider_teardown,(void *provctx))
+# define OSSL_FUNC_PROVIDER_GETTABLE_PARAMS    1025
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *,
+                    provider_gettable_params,(void *provctx))
+# define OSSL_FUNC_PROVIDER_GET_PARAMS         1026
+OSSL_CORE_MAKE_FUNC(int,provider_get_params,(void *provctx,
+                                             OSSL_PARAM params[]))
+# define OSSL_FUNC_PROVIDER_QUERY_OPERATION    1027
+OSSL_CORE_MAKE_FUNC(const OSSL_ALGORITHM *,provider_query_operation,
+                    (void *provctx, int operation_id, int *no_store))
+# define OSSL_FUNC_PROVIDER_UNQUERY_OPERATION  1028
+OSSL_CORE_MAKE_FUNC(void, provider_unquery_operation,
+                    (void *provctx, int operation_id, const OSSL_ALGORITHM *))
+# define OSSL_FUNC_PROVIDER_GET_REASON_STRINGS 1029
+OSSL_CORE_MAKE_FUNC(const OSSL_ITEM *,provider_get_reason_strings,
+                    (void *provctx))
+# define OSSL_FUNC_PROVIDER_GET_CAPABILITIES   1030
+OSSL_CORE_MAKE_FUNC(int, provider_get_capabilities, (void *provctx,
+                    const char *capability, OSSL_CALLBACK *cb, void *arg))
+# define OSSL_FUNC_PROVIDER_SELF_TEST          1031
+OSSL_CORE_MAKE_FUNC(int, provider_self_test, (void *provctx))
+
+/* Operations */
+
+# define OSSL_OP_DIGEST                              1
+# define OSSL_OP_CIPHER                              2   /* Symmetric Ciphers */
+# define OSSL_OP_MAC                                 3
+# define OSSL_OP_KDF                                 4
+# define OSSL_OP_RAND                                5
+# define OSSL_OP_KEYMGMT                            10
+# define OSSL_OP_KEYEXCH                            11
+# define OSSL_OP_SIGNATURE                          12
+# define OSSL_OP_ASYM_CIPHER                        13
+# define OSSL_OP_KEM                                14
+/* New section for non-EVP operations */
+# define OSSL_OP_ENCODER                            20
+# define OSSL_OP_DECODER                            21
+# define OSSL_OP_STORE                              22
+/* Highest known operation number */
+# define OSSL_OP__HIGHEST                           22
+
+/* Digests */
+
+# define OSSL_FUNC_DIGEST_NEWCTX                     1
+# define OSSL_FUNC_DIGEST_INIT                       2
+# define OSSL_FUNC_DIGEST_UPDATE                     3
+# define OSSL_FUNC_DIGEST_FINAL                      4
+# define OSSL_FUNC_DIGEST_DIGEST                     5
+# define OSSL_FUNC_DIGEST_FREECTX                    6
+# define OSSL_FUNC_DIGEST_DUPCTX                     7
+# define OSSL_FUNC_DIGEST_GET_PARAMS                 8
+# define OSSL_FUNC_DIGEST_SET_CTX_PARAMS             9
+# define OSSL_FUNC_DIGEST_GET_CTX_PARAMS            10
+# define OSSL_FUNC_DIGEST_GETTABLE_PARAMS           11
+# define OSSL_FUNC_DIGEST_SETTABLE_CTX_PARAMS       12
+# define OSSL_FUNC_DIGEST_GETTABLE_CTX_PARAMS       13
+# define OSSL_FUNC_DIGEST_SQUEEZE                   14
+
+OSSL_CORE_MAKE_FUNC(void *, digest_newctx, (void *provctx))
+OSSL_CORE_MAKE_FUNC(int, digest_init, (void *dctx, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, digest_update,
+                    (void *dctx, const unsigned char *in, size_t inl))
+OSSL_CORE_MAKE_FUNC(int, digest_final,
+                    (void *dctx,
+                     unsigned char *out, size_t *outl, size_t outsz))
+OSSL_CORE_MAKE_FUNC(int, digest_squeeze,
+                    (void *dctx,
+                     unsigned char *out, size_t *outl, size_t outsz))
+OSSL_CORE_MAKE_FUNC(int, digest_digest,
+                    (void *provctx, const unsigned char *in, size_t inl,
+                     unsigned char *out, size_t *outl, size_t outsz))
+
+OSSL_CORE_MAKE_FUNC(void, digest_freectx, (void *dctx))
+OSSL_CORE_MAKE_FUNC(void *, digest_dupctx, (void *dctx))
+
+OSSL_CORE_MAKE_FUNC(int, digest_get_params, (OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, digest_set_ctx_params,
+                    (void *vctx, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, digest_get_ctx_params,
+                    (void *vctx, OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, digest_gettable_params,
+                    (void *provctx))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, digest_settable_ctx_params,
+                    (void *dctx, void *provctx))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, digest_gettable_ctx_params,
+                    (void *dctx, void *provctx))
+
+/* Symmetric Ciphers */
+
+# define OSSL_FUNC_CIPHER_NEWCTX                     1
+# define OSSL_FUNC_CIPHER_ENCRYPT_INIT               2
+# define OSSL_FUNC_CIPHER_DECRYPT_INIT               3
+# define OSSL_FUNC_CIPHER_UPDATE                     4
+# define OSSL_FUNC_CIPHER_FINAL                      5
+# define OSSL_FUNC_CIPHER_CIPHER                     6
+# define OSSL_FUNC_CIPHER_FREECTX                    7
+# define OSSL_FUNC_CIPHER_DUPCTX                     8
+# define OSSL_FUNC_CIPHER_GET_PARAMS                 9
+# define OSSL_FUNC_CIPHER_GET_CTX_PARAMS            10
+# define OSSL_FUNC_CIPHER_SET_CTX_PARAMS            11
+# define OSSL_FUNC_CIPHER_GETTABLE_PARAMS           12
+# define OSSL_FUNC_CIPHER_GETTABLE_CTX_PARAMS       13
+# define OSSL_FUNC_CIPHER_SETTABLE_CTX_PARAMS       14
+
+OSSL_CORE_MAKE_FUNC(void *, cipher_newctx, (void *provctx))
+OSSL_CORE_MAKE_FUNC(int, cipher_encrypt_init, (void *cctx,
+                                                  const unsigned char *key,
+                                                  size_t keylen,
+                                                  const unsigned char *iv,
+                                                  size_t ivlen,
+                                                  const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, cipher_decrypt_init, (void *cctx,
+                                                  const unsigned char *key,
+                                                  size_t keylen,
+                                                  const unsigned char *iv,
+                                                  size_t ivlen,
+                                                  const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, cipher_update,
+                    (void *cctx,
+                     unsigned char *out, size_t *outl, size_t outsize,
+                     const unsigned char *in, size_t inl))
+OSSL_CORE_MAKE_FUNC(int, cipher_final,
+                    (void *cctx,
+                     unsigned char *out, size_t *outl, size_t outsize))
+OSSL_CORE_MAKE_FUNC(int, cipher_cipher,
+                    (void *cctx,
+                     unsigned char *out, size_t *outl, size_t outsize,
+                     const unsigned char *in, size_t inl))
+OSSL_CORE_MAKE_FUNC(void, cipher_freectx, (void *cctx))
+OSSL_CORE_MAKE_FUNC(void *, cipher_dupctx, (void *cctx))
+OSSL_CORE_MAKE_FUNC(int, cipher_get_params, (OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, cipher_get_ctx_params, (void *cctx,
+                                                    OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, cipher_set_ctx_params, (void *cctx,
+                                                    const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, cipher_gettable_params,
+                    (void *provctx))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, cipher_settable_ctx_params,
+                    (void *cctx, void *provctx))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, cipher_gettable_ctx_params,
+                    (void *cctx, void *provctx))
+
+/* MACs */
+
+# define OSSL_FUNC_MAC_NEWCTX                        1
+# define OSSL_FUNC_MAC_DUPCTX                        2
+# define OSSL_FUNC_MAC_FREECTX                       3
+# define OSSL_FUNC_MAC_INIT                          4
+# define OSSL_FUNC_MAC_UPDATE                        5
+# define OSSL_FUNC_MAC_FINAL                         6
+# define OSSL_FUNC_MAC_GET_PARAMS                    7
+# define OSSL_FUNC_MAC_GET_CTX_PARAMS                8
+# define OSSL_FUNC_MAC_SET_CTX_PARAMS                9
+# define OSSL_FUNC_MAC_GETTABLE_PARAMS              10
+# define OSSL_FUNC_MAC_GETTABLE_CTX_PARAMS          11
+# define OSSL_FUNC_MAC_SETTABLE_CTX_PARAMS          12
+
+OSSL_CORE_MAKE_FUNC(void *, mac_newctx, (void *provctx))
+OSSL_CORE_MAKE_FUNC(void *, mac_dupctx, (void *src))
+OSSL_CORE_MAKE_FUNC(void, mac_freectx, (void *mctx))
+OSSL_CORE_MAKE_FUNC(int, mac_init, (void *mctx, const unsigned char *key,
+                                    size_t keylen, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, mac_update,
+                    (void *mctx, const unsigned char *in, size_t inl))
+OSSL_CORE_MAKE_FUNC(int, mac_final,
+                    (void *mctx,
+                     unsigned char *out, size_t *outl, size_t outsize))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, mac_gettable_params, (void *provctx))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, mac_gettable_ctx_params,
+                    (void *mctx, void *provctx))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, mac_settable_ctx_params,
+                    (void *mctx, void *provctx))
+OSSL_CORE_MAKE_FUNC(int, mac_get_params, (OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, mac_get_ctx_params,
+                    (void *mctx, OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, mac_set_ctx_params,
+                    (void *mctx, const OSSL_PARAM params[]))
+
+/* KDFs and PRFs */
+
+# define OSSL_FUNC_KDF_NEWCTX                        1
+# define OSSL_FUNC_KDF_DUPCTX                        2
+# define OSSL_FUNC_KDF_FREECTX                       3
+# define OSSL_FUNC_KDF_RESET                         4
+# define OSSL_FUNC_KDF_DERIVE                        5
+# define OSSL_FUNC_KDF_GETTABLE_PARAMS               6
+# define OSSL_FUNC_KDF_GETTABLE_CTX_PARAMS           7
+# define OSSL_FUNC_KDF_SETTABLE_CTX_PARAMS           8
+# define OSSL_FUNC_KDF_GET_PARAMS                    9
+# define OSSL_FUNC_KDF_GET_CTX_PARAMS               10
+# define OSSL_FUNC_KDF_SET_CTX_PARAMS               11
+
+OSSL_CORE_MAKE_FUNC(void *, kdf_newctx, (void *provctx))
+OSSL_CORE_MAKE_FUNC(void *, kdf_dupctx, (void *src))
+OSSL_CORE_MAKE_FUNC(void, kdf_freectx, (void *kctx))
+OSSL_CORE_MAKE_FUNC(void, kdf_reset, (void *kctx))
+OSSL_CORE_MAKE_FUNC(int, kdf_derive, (void *kctx, unsigned char *key,
+                                      size_t keylen, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, kdf_gettable_params, (void *provctx))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, kdf_gettable_ctx_params,
+                    (void *kctx, void *provctx))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, kdf_settable_ctx_params,
+                    (void *kctx, void *provctx))
+OSSL_CORE_MAKE_FUNC(int, kdf_get_params, (OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, kdf_get_ctx_params,
+                    (void *kctx, OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, kdf_set_ctx_params,
+                    (void *kctx, const OSSL_PARAM params[]))
+
+/* RAND */
+
+# define OSSL_FUNC_RAND_NEWCTX                        1
+# define OSSL_FUNC_RAND_FREECTX                       2
+# define OSSL_FUNC_RAND_INSTANTIATE                   3
+# define OSSL_FUNC_RAND_UNINSTANTIATE                 4
+# define OSSL_FUNC_RAND_GENERATE                      5
+# define OSSL_FUNC_RAND_RESEED                        6
+# define OSSL_FUNC_RAND_NONCE                         7
+# define OSSL_FUNC_RAND_ENABLE_LOCKING                8
+# define OSSL_FUNC_RAND_LOCK                          9
+# define OSSL_FUNC_RAND_UNLOCK                       10
+# define OSSL_FUNC_RAND_GETTABLE_PARAMS              11
+# define OSSL_FUNC_RAND_GETTABLE_CTX_PARAMS          12
+# define OSSL_FUNC_RAND_SETTABLE_CTX_PARAMS          13
+# define OSSL_FUNC_RAND_GET_PARAMS                   14
+# define OSSL_FUNC_RAND_GET_CTX_PARAMS               15
+# define OSSL_FUNC_RAND_SET_CTX_PARAMS               16
+# define OSSL_FUNC_RAND_VERIFY_ZEROIZATION           17
+# define OSSL_FUNC_RAND_GET_SEED                     18
+# define OSSL_FUNC_RAND_CLEAR_SEED                   19
+
+OSSL_CORE_MAKE_FUNC(void *,rand_newctx,
+                    (void *provctx, void *parent,
+                    const OSSL_DISPATCH *parent_calls))
+OSSL_CORE_MAKE_FUNC(void,rand_freectx, (void *vctx))
+OSSL_CORE_MAKE_FUNC(int,rand_instantiate,
+                    (void *vdrbg, unsigned int strength,
+                     int prediction_resistance,
+                     const unsigned char *pstr, size_t pstr_len,
+                     const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int,rand_uninstantiate, (void *vdrbg))
+OSSL_CORE_MAKE_FUNC(int,rand_generate,
+                    (void *vctx, unsigned char *out, size_t outlen,
+                     unsigned int strength, int prediction_resistance,
+                     const unsigned char *addin, size_t addin_len))
+OSSL_CORE_MAKE_FUNC(int,rand_reseed,
+                    (void *vctx, int prediction_resistance,
+                     const unsigned char *ent, size_t ent_len,
+                     const unsigned char *addin, size_t addin_len))
+OSSL_CORE_MAKE_FUNC(size_t,rand_nonce,
+                    (void *vctx, unsigned char *out, unsigned int strength,
+                     size_t min_noncelen, size_t max_noncelen))
+OSSL_CORE_MAKE_FUNC(int,rand_enable_locking, (void *vctx))
+OSSL_CORE_MAKE_FUNC(int,rand_lock, (void *vctx))
+OSSL_CORE_MAKE_FUNC(void,rand_unlock, (void *vctx))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *,rand_gettable_params, (void *provctx))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *,rand_gettable_ctx_params,
+                    (void *vctx, void *provctx))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *,rand_settable_ctx_params,
+                    (void *vctx, void *provctx))
+OSSL_CORE_MAKE_FUNC(int,rand_get_params, (OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int,rand_get_ctx_params,
+                    (void *vctx, OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int,rand_set_ctx_params,
+                    (void *vctx, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(void,rand_set_callbacks,
+                    (void *vctx, OSSL_INOUT_CALLBACK *get_entropy,
+                     OSSL_CALLBACK *cleanup_entropy,
+                     OSSL_INOUT_CALLBACK *get_nonce,
+                     OSSL_CALLBACK *cleanup_nonce, void *arg))
+OSSL_CORE_MAKE_FUNC(int,rand_verify_zeroization,
+                    (void *vctx))
+OSSL_CORE_MAKE_FUNC(size_t,rand_get_seed,
+                    (void *vctx, unsigned char **buffer,
+                     int entropy, size_t min_len, size_t max_len,
+                     int prediction_resistance,
+                     const unsigned char *adin, size_t adin_len))
+OSSL_CORE_MAKE_FUNC(void,rand_clear_seed,
+                    (void *vctx, unsigned char *buffer, size_t b_len))
+
+/*-
+ * Key management
+ *
+ * The Key Management takes care of provider side key objects, and includes
+ * all current functionality to create them, destroy them, set parameters
+ * and key material, etc, essentially everything that manipulates the keys
+ * themselves and their parameters.
+ *
+ * The key objects are commonly referred to as |keydata|, and it MUST be able
+ * to contain parameters if the key has any, the public key and the private
+ * key.  All parts are optional, but their presence determines what can be
+ * done with the key object in terms of encryption, signature, and so on.
+ * The assumption from libcrypto is that the key object contains any of the
+ * following data combinations:
+ *
+ * - parameters only
+ * - public key only
+ * - public key + private key
+ * - parameters + public key
+ * - parameters + public key + private key
+ *
+ * What "parameters", "public key" and "private key" means in detail is left
+ * to the implementation.  In the case of DH and DSA, they would typically
+ * include domain parameters, while for certain variants of RSA, they would
+ * typically include PSS or OAEP parameters.
+ *
+ * Key objects are created with OSSL_FUNC_keymgmt_new() and destroyed with
+ * OSSL_FUNC_keymgmt_free().  Key objects can have data filled in with
+ * OSSL_FUNC_keymgmt_import().
+ *
+ * Three functions are made available to check what selection of data is
+ * present in a key object: OSSL_FUNC_keymgmt_has_parameters(),
+ * OSSL_FUNC_keymgmt_has_public_key(), and OSSL_FUNC_keymgmt_has_private_key(),
+ */
+
+/* Key data subset selection - individual bits */
+# define OSSL_KEYMGMT_SELECT_PRIVATE_KEY            0x01
+# define OSSL_KEYMGMT_SELECT_PUBLIC_KEY             0x02
+# define OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS      0x04
+# define OSSL_KEYMGMT_SELECT_OTHER_PARAMETERS       0x80
+
+/* Key data subset selection - combinations */
+# define OSSL_KEYMGMT_SELECT_ALL_PARAMETERS     \
+    ( OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS     \
+      | OSSL_KEYMGMT_SELECT_OTHER_PARAMETERS)
+# define OSSL_KEYMGMT_SELECT_KEYPAIR            \
+    ( OSSL_KEYMGMT_SELECT_PRIVATE_KEY | OSSL_KEYMGMT_SELECT_PUBLIC_KEY )
+# define OSSL_KEYMGMT_SELECT_ALL                \
+    ( OSSL_KEYMGMT_SELECT_KEYPAIR | OSSL_KEYMGMT_SELECT_ALL_PARAMETERS )
+
+# define OSSL_KEYMGMT_VALIDATE_FULL_CHECK              0
+# define OSSL_KEYMGMT_VALIDATE_QUICK_CHECK             1
+
+/* Basic key object creation */
+# define OSSL_FUNC_KEYMGMT_NEW                         1
+OSSL_CORE_MAKE_FUNC(void *, keymgmt_new, (void *provctx))
+
+/* Generation, a more complex constructor */
+# define OSSL_FUNC_KEYMGMT_GEN_INIT                    2
+# define OSSL_FUNC_KEYMGMT_GEN_SET_TEMPLATE            3
+# define OSSL_FUNC_KEYMGMT_GEN_SET_PARAMS              4
+# define OSSL_FUNC_KEYMGMT_GEN_SETTABLE_PARAMS         5
+# define OSSL_FUNC_KEYMGMT_GEN                         6
+# define OSSL_FUNC_KEYMGMT_GEN_CLEANUP                 7
+OSSL_CORE_MAKE_FUNC(void *, keymgmt_gen_init,
+                    (void *provctx, int selection, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, keymgmt_gen_set_template,
+                    (void *genctx, void *templ))
+OSSL_CORE_MAKE_FUNC(int, keymgmt_gen_set_params,
+                    (void *genctx, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *,
+                    keymgmt_gen_settable_params,
+                    (void *genctx, void *provctx))
+OSSL_CORE_MAKE_FUNC(void *, keymgmt_gen,
+                    (void *genctx, OSSL_CALLBACK *cb, void *cbarg))
+OSSL_CORE_MAKE_FUNC(void, keymgmt_gen_cleanup, (void *genctx))
+
+/* Key loading by object reference */
+# define OSSL_FUNC_KEYMGMT_LOAD                        8
+OSSL_CORE_MAKE_FUNC(void *, keymgmt_load,
+                    (const void *reference, size_t reference_sz))
+
+/* Basic key object destruction */
+# define OSSL_FUNC_KEYMGMT_FREE                       10
+OSSL_CORE_MAKE_FUNC(void, keymgmt_free, (void *keydata))
+
+/* Key object information, with discovery */
+#define OSSL_FUNC_KEYMGMT_GET_PARAMS                  11
+#define OSSL_FUNC_KEYMGMT_GETTABLE_PARAMS             12
+OSSL_CORE_MAKE_FUNC(int, keymgmt_get_params,
+                    (void *keydata, OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, keymgmt_gettable_params,
+                    (void *provctx))
+
+#define OSSL_FUNC_KEYMGMT_SET_PARAMS                  13
+#define OSSL_FUNC_KEYMGMT_SETTABLE_PARAMS             14
+OSSL_CORE_MAKE_FUNC(int, keymgmt_set_params,
+                    (void *keydata, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, keymgmt_settable_params,
+                    (void *provctx))
+
+/* Key checks - discovery of supported operations */
+# define OSSL_FUNC_KEYMGMT_QUERY_OPERATION_NAME       20
+OSSL_CORE_MAKE_FUNC(const char *, keymgmt_query_operation_name,
+                    (int operation_id))
+
+/* Key checks - key data content checks */
+# define OSSL_FUNC_KEYMGMT_HAS                        21
+OSSL_CORE_MAKE_FUNC(int, keymgmt_has, (const void *keydata, int selection))
+
+/* Key checks - validation */
+# define OSSL_FUNC_KEYMGMT_VALIDATE                   22
+OSSL_CORE_MAKE_FUNC(int, keymgmt_validate, (const void *keydata, int selection,
+                                            int checktype))
+
+/* Key checks - matching */
+# define OSSL_FUNC_KEYMGMT_MATCH                      23
+OSSL_CORE_MAKE_FUNC(int, keymgmt_match,
+                    (const void *keydata1, const void *keydata2,
+                     int selection))
+
+/* Import and export functions, with discovery */
+# define OSSL_FUNC_KEYMGMT_IMPORT                     40
+# define OSSL_FUNC_KEYMGMT_IMPORT_TYPES               41
+# define OSSL_FUNC_KEYMGMT_EXPORT                     42
+# define OSSL_FUNC_KEYMGMT_EXPORT_TYPES               43
+OSSL_CORE_MAKE_FUNC(int, keymgmt_import,
+                    (void *keydata, int selection, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, keymgmt_import_types,
+                    (int selection))
+OSSL_CORE_MAKE_FUNC(int, keymgmt_export,
+                    (void *keydata, int selection,
+                     OSSL_CALLBACK *param_cb, void *cbarg))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, keymgmt_export_types,
+                    (int selection))
+
+/* Dup function, constructor */
+# define OSSL_FUNC_KEYMGMT_DUP                        44
+OSSL_CORE_MAKE_FUNC(void *, keymgmt_dup,
+                    (const void *keydata_from, int selection))
+
+/* Extended import and export functions */
+# define OSSL_FUNC_KEYMGMT_IMPORT_TYPES_EX            45
+# define OSSL_FUNC_KEYMGMT_EXPORT_TYPES_EX            46
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, keymgmt_import_types_ex,
+                    (void *provctx, int selection))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, keymgmt_export_types_ex,
+                    (void *provctx, int selection))
+
+/* Key Exchange */
+
+# define OSSL_FUNC_KEYEXCH_NEWCTX                      1
+# define OSSL_FUNC_KEYEXCH_INIT                        2
+# define OSSL_FUNC_KEYEXCH_DERIVE                      3
+# define OSSL_FUNC_KEYEXCH_SET_PEER                    4
+# define OSSL_FUNC_KEYEXCH_FREECTX                     5
+# define OSSL_FUNC_KEYEXCH_DUPCTX                      6
+# define OSSL_FUNC_KEYEXCH_SET_CTX_PARAMS              7
+# define OSSL_FUNC_KEYEXCH_SETTABLE_CTX_PARAMS         8
+# define OSSL_FUNC_KEYEXCH_GET_CTX_PARAMS              9
+# define OSSL_FUNC_KEYEXCH_GETTABLE_CTX_PARAMS        10
+
+OSSL_CORE_MAKE_FUNC(void *, keyexch_newctx, (void *provctx))
+OSSL_CORE_MAKE_FUNC(int, keyexch_init, (void *ctx, void *provkey,
+                                        const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, keyexch_derive, (void *ctx,  unsigned char *secret,
+                                             size_t *secretlen, size_t outlen))
+OSSL_CORE_MAKE_FUNC(int, keyexch_set_peer, (void *ctx, void *provkey))
+OSSL_CORE_MAKE_FUNC(void, keyexch_freectx, (void *ctx))
+OSSL_CORE_MAKE_FUNC(void *, keyexch_dupctx, (void *ctx))
+OSSL_CORE_MAKE_FUNC(int, keyexch_set_ctx_params, (void *ctx,
+                                                     const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, keyexch_settable_ctx_params,
+                    (void *ctx, void *provctx))
+OSSL_CORE_MAKE_FUNC(int, keyexch_get_ctx_params, (void *ctx,
+                                                     OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, keyexch_gettable_ctx_params,
+                    (void *ctx, void *provctx))
+
+/* Signature */
+
+# define OSSL_FUNC_SIGNATURE_NEWCTX                  1
+# define OSSL_FUNC_SIGNATURE_SIGN_INIT               2
+# define OSSL_FUNC_SIGNATURE_SIGN                    3
+# define OSSL_FUNC_SIGNATURE_VERIFY_INIT             4
+# define OSSL_FUNC_SIGNATURE_VERIFY                  5
+# define OSSL_FUNC_SIGNATURE_VERIFY_RECOVER_INIT     6
+# define OSSL_FUNC_SIGNATURE_VERIFY_RECOVER          7
+# define OSSL_FUNC_SIGNATURE_DIGEST_SIGN_INIT        8
+# define OSSL_FUNC_SIGNATURE_DIGEST_SIGN_UPDATE      9
+# define OSSL_FUNC_SIGNATURE_DIGEST_SIGN_FINAL      10
+# define OSSL_FUNC_SIGNATURE_DIGEST_SIGN            11
+# define OSSL_FUNC_SIGNATURE_DIGEST_VERIFY_INIT     12
+# define OSSL_FUNC_SIGNATURE_DIGEST_VERIFY_UPDATE   13
+# define OSSL_FUNC_SIGNATURE_DIGEST_VERIFY_FINAL    14
+# define OSSL_FUNC_SIGNATURE_DIGEST_VERIFY          15
+# define OSSL_FUNC_SIGNATURE_FREECTX                16
+# define OSSL_FUNC_SIGNATURE_DUPCTX                 17
+# define OSSL_FUNC_SIGNATURE_GET_CTX_PARAMS         18
+# define OSSL_FUNC_SIGNATURE_GETTABLE_CTX_PARAMS    19
+# define OSSL_FUNC_SIGNATURE_SET_CTX_PARAMS         20
+# define OSSL_FUNC_SIGNATURE_SETTABLE_CTX_PARAMS    21
+# define OSSL_FUNC_SIGNATURE_GET_CTX_MD_PARAMS      22
+# define OSSL_FUNC_SIGNATURE_GETTABLE_CTX_MD_PARAMS 23
+# define OSSL_FUNC_SIGNATURE_SET_CTX_MD_PARAMS      24
+# define OSSL_FUNC_SIGNATURE_SETTABLE_CTX_MD_PARAMS 25
+
+OSSL_CORE_MAKE_FUNC(void *, signature_newctx, (void *provctx,
+                                                  const char *propq))
+OSSL_CORE_MAKE_FUNC(int, signature_sign_init, (void *ctx, void *provkey,
+                                               const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, signature_sign, (void *ctx,  unsigned char *sig,
+                                             size_t *siglen, size_t sigsize,
+                                             const unsigned char *tbs,
+                                             size_t tbslen))
+OSSL_CORE_MAKE_FUNC(int, signature_verify_init, (void *ctx, void *provkey,
+                                                 const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, signature_verify, (void *ctx,
+                                               const unsigned char *sig,
+                                               size_t siglen,
+                                               const unsigned char *tbs,
+                                               size_t tbslen))
+OSSL_CORE_MAKE_FUNC(int, signature_verify_recover_init,
+                    (void *ctx, void *provkey, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, signature_verify_recover,
+                    (void *ctx, unsigned char *rout, size_t *routlen,
+                     size_t routsize, const unsigned char *sig, size_t siglen))
+OSSL_CORE_MAKE_FUNC(int, signature_digest_sign_init,
+                    (void *ctx, const char *mdname, void *provkey,
+                     const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, signature_digest_sign_update,
+                    (void *ctx, const unsigned char *data, size_t datalen))
+OSSL_CORE_MAKE_FUNC(int, signature_digest_sign_final,
+                    (void *ctx, unsigned char *sig, size_t *siglen,
+                     size_t sigsize))
+OSSL_CORE_MAKE_FUNC(int, signature_digest_sign,
+                    (void *ctx, unsigned char *sigret, size_t *siglen,
+                     size_t sigsize, const unsigned char *tbs, size_t tbslen))
+OSSL_CORE_MAKE_FUNC(int, signature_digest_verify_init,
+                    (void *ctx, const char *mdname, void *provkey,
+                     const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, signature_digest_verify_update,
+                    (void *ctx, const unsigned char *data, size_t datalen))
+OSSL_CORE_MAKE_FUNC(int, signature_digest_verify_final,
+                    (void *ctx, const unsigned char *sig, size_t siglen))
+OSSL_CORE_MAKE_FUNC(int, signature_digest_verify,
+                    (void *ctx, const unsigned char *sig, size_t siglen,
+                     const unsigned char *tbs, size_t tbslen))
+OSSL_CORE_MAKE_FUNC(void, signature_freectx, (void *ctx))
+OSSL_CORE_MAKE_FUNC(void *, signature_dupctx, (void *ctx))
+OSSL_CORE_MAKE_FUNC(int, signature_get_ctx_params,
+                    (void *ctx, OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, signature_gettable_ctx_params,
+                    (void *ctx, void *provctx))
+OSSL_CORE_MAKE_FUNC(int, signature_set_ctx_params,
+                    (void *ctx, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, signature_settable_ctx_params,
+                    (void *ctx, void *provctx))
+OSSL_CORE_MAKE_FUNC(int, signature_get_ctx_md_params,
+                    (void *ctx, OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, signature_gettable_ctx_md_params,
+                    (void *ctx))
+OSSL_CORE_MAKE_FUNC(int, signature_set_ctx_md_params,
+                    (void *ctx, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, signature_settable_ctx_md_params,
+                    (void *ctx))
+
+
+/* Asymmetric Ciphers */
+
+# define OSSL_FUNC_ASYM_CIPHER_NEWCTX                  1
+# define OSSL_FUNC_ASYM_CIPHER_ENCRYPT_INIT            2
+# define OSSL_FUNC_ASYM_CIPHER_ENCRYPT                 3
+# define OSSL_FUNC_ASYM_CIPHER_DECRYPT_INIT            4
+# define OSSL_FUNC_ASYM_CIPHER_DECRYPT                 5
+# define OSSL_FUNC_ASYM_CIPHER_FREECTX                 6
+# define OSSL_FUNC_ASYM_CIPHER_DUPCTX                  7
+# define OSSL_FUNC_ASYM_CIPHER_GET_CTX_PARAMS          8
+# define OSSL_FUNC_ASYM_CIPHER_GETTABLE_CTX_PARAMS     9
+# define OSSL_FUNC_ASYM_CIPHER_SET_CTX_PARAMS         10
+# define OSSL_FUNC_ASYM_CIPHER_SETTABLE_CTX_PARAMS    11
+
+OSSL_CORE_MAKE_FUNC(void *, asym_cipher_newctx, (void *provctx))
+OSSL_CORE_MAKE_FUNC(int, asym_cipher_encrypt_init, (void *ctx, void *provkey,
+                                                    const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, asym_cipher_encrypt, (void *ctx, unsigned char *out,
+                                                  size_t *outlen,
+                                                  size_t outsize,
+                                                  const unsigned char *in,
+                                                  size_t inlen))
+OSSL_CORE_MAKE_FUNC(int, asym_cipher_decrypt_init, (void *ctx, void *provkey,
+                                                    const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, asym_cipher_decrypt, (void *ctx, unsigned char *out,
+                                                  size_t *outlen,
+                                                  size_t outsize,
+                                                  const unsigned char *in,
+                                                  size_t inlen))
+OSSL_CORE_MAKE_FUNC(void, asym_cipher_freectx, (void *ctx))
+OSSL_CORE_MAKE_FUNC(void *, asym_cipher_dupctx, (void *ctx))
+OSSL_CORE_MAKE_FUNC(int, asym_cipher_get_ctx_params,
+                    (void *ctx, OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, asym_cipher_gettable_ctx_params,
+                    (void *ctx, void *provctx))
+OSSL_CORE_MAKE_FUNC(int, asym_cipher_set_ctx_params,
+                    (void *ctx, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, asym_cipher_settable_ctx_params,
+                    (void *ctx, void *provctx))
+
+/* Asymmetric Key encapsulation */
+# define OSSL_FUNC_KEM_NEWCTX                  1
+# define OSSL_FUNC_KEM_ENCAPSULATE_INIT        2
+# define OSSL_FUNC_KEM_ENCAPSULATE             3
+# define OSSL_FUNC_KEM_DECAPSULATE_INIT        4
+# define OSSL_FUNC_KEM_DECAPSULATE             5
+# define OSSL_FUNC_KEM_FREECTX                 6
+# define OSSL_FUNC_KEM_DUPCTX                  7
+# define OSSL_FUNC_KEM_GET_CTX_PARAMS          8
+# define OSSL_FUNC_KEM_GETTABLE_CTX_PARAMS     9
+# define OSSL_FUNC_KEM_SET_CTX_PARAMS         10
+# define OSSL_FUNC_KEM_SETTABLE_CTX_PARAMS    11
+# define OSSL_FUNC_KEM_AUTH_ENCAPSULATE_INIT  12
+# define OSSL_FUNC_KEM_AUTH_DECAPSULATE_INIT  13
+
+OSSL_CORE_MAKE_FUNC(void *, kem_newctx, (void *provctx))
+OSSL_CORE_MAKE_FUNC(int, kem_encapsulate_init, (void *ctx, void *provkey,
+                                                const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, kem_auth_encapsulate_init, (void *ctx, void *provkey,
+                                                     void *authprivkey,
+                                                     const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, kem_encapsulate, (void *ctx,
+                                           unsigned char *out, size_t *outlen,
+                                           unsigned char *secret,
+                                           size_t *secretlen))
+OSSL_CORE_MAKE_FUNC(int, kem_decapsulate_init, (void *ctx, void *provkey,
+                                                const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, kem_auth_decapsulate_init, (void *ctx, void *provkey,
+                                                     void *authpubkey,
+                                                     const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, kem_decapsulate, (void *ctx,
+                                           unsigned char *out, size_t *outlen,
+                                           const unsigned char *in, size_t inlen))
+OSSL_CORE_MAKE_FUNC(void, kem_freectx, (void *ctx))
+OSSL_CORE_MAKE_FUNC(void *, kem_dupctx, (void *ctx))
+OSSL_CORE_MAKE_FUNC(int, kem_get_ctx_params, (void *ctx, OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, kem_gettable_ctx_params,
+                    (void *ctx, void *provctx))
+OSSL_CORE_MAKE_FUNC(int, kem_set_ctx_params,
+                    (void *ctx, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, kem_settable_ctx_params,
+                    (void *ctx, void *provctx))
+
+/* Encoders and decoders */
+# define OSSL_FUNC_ENCODER_NEWCTX                      1
+# define OSSL_FUNC_ENCODER_FREECTX                     2
+# define OSSL_FUNC_ENCODER_GET_PARAMS                  3
+# define OSSL_FUNC_ENCODER_GETTABLE_PARAMS             4
+# define OSSL_FUNC_ENCODER_SET_CTX_PARAMS              5
+# define OSSL_FUNC_ENCODER_SETTABLE_CTX_PARAMS         6
+# define OSSL_FUNC_ENCODER_DOES_SELECTION             10
+# define OSSL_FUNC_ENCODER_ENCODE                     11
+# define OSSL_FUNC_ENCODER_IMPORT_OBJECT              20
+# define OSSL_FUNC_ENCODER_FREE_OBJECT                21
+OSSL_CORE_MAKE_FUNC(void *, encoder_newctx, (void *provctx))
+OSSL_CORE_MAKE_FUNC(void, encoder_freectx, (void *ctx))
+OSSL_CORE_MAKE_FUNC(int, encoder_get_params, (OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, encoder_gettable_params,
+                    (void *provctx))
+OSSL_CORE_MAKE_FUNC(int, encoder_set_ctx_params,
+                    (void *ctx, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, encoder_settable_ctx_params,
+                    (void *provctx))
+
+OSSL_CORE_MAKE_FUNC(int, encoder_does_selection,
+                    (void *provctx, int selection))
+OSSL_CORE_MAKE_FUNC(int, encoder_encode,
+                    (void *ctx, OSSL_CORE_BIO *out,
+                     const void *obj_raw, const OSSL_PARAM obj_abstract[],
+                     int selection,
+                     OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg))
+
+OSSL_CORE_MAKE_FUNC(void *, encoder_import_object,
+                    (void *ctx, int selection, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(void, encoder_free_object, (void *obj))
+
+# define OSSL_FUNC_DECODER_NEWCTX                      1
+# define OSSL_FUNC_DECODER_FREECTX                     2
+# define OSSL_FUNC_DECODER_GET_PARAMS                  3
+# define OSSL_FUNC_DECODER_GETTABLE_PARAMS             4
+# define OSSL_FUNC_DECODER_SET_CTX_PARAMS              5
+# define OSSL_FUNC_DECODER_SETTABLE_CTX_PARAMS         6
+# define OSSL_FUNC_DECODER_DOES_SELECTION             10
+# define OSSL_FUNC_DECODER_DECODE                     11
+# define OSSL_FUNC_DECODER_EXPORT_OBJECT              20
+OSSL_CORE_MAKE_FUNC(void *, decoder_newctx, (void *provctx))
+OSSL_CORE_MAKE_FUNC(void, decoder_freectx, (void *ctx))
+OSSL_CORE_MAKE_FUNC(int, decoder_get_params, (OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, decoder_gettable_params,
+                    (void *provctx))
+OSSL_CORE_MAKE_FUNC(int, decoder_set_ctx_params,
+                    (void *ctx, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, decoder_settable_ctx_params,
+                    (void *provctx))
+
+OSSL_CORE_MAKE_FUNC(int, decoder_does_selection,
+                    (void *provctx, int selection))
+OSSL_CORE_MAKE_FUNC(int, decoder_decode,
+                    (void *ctx, OSSL_CORE_BIO *in, int selection,
+                     OSSL_CALLBACK *data_cb, void *data_cbarg,
+                     OSSL_PASSPHRASE_CALLBACK *pw_cb, void *pw_cbarg))
+OSSL_CORE_MAKE_FUNC(int, decoder_export_object,
+                    (void *ctx, const void *objref, size_t objref_sz,
+                     OSSL_CALLBACK *export_cb, void *export_cbarg))
+
+/*-
+ * Store
+ *
+ * Objects are scanned by using the 'open', 'load', 'eof' and 'close'
+ * functions, which implement an OSSL_STORE loader.
+ *
+ * store_load() works in a way that's very similar to the decoders, in
+ * that they pass an abstract object through a callback, either as a DER
+ * octet string or as an object reference, which libcrypto will have to
+ * deal with.
+ */
+
+#define OSSL_FUNC_STORE_OPEN                        1
+#define OSSL_FUNC_STORE_ATTACH                      2
+#define OSSL_FUNC_STORE_SETTABLE_CTX_PARAMS         3
+#define OSSL_FUNC_STORE_SET_CTX_PARAMS              4
+#define OSSL_FUNC_STORE_LOAD                        5
+#define OSSL_FUNC_STORE_EOF                         6
+#define OSSL_FUNC_STORE_CLOSE                       7
+#define OSSL_FUNC_STORE_EXPORT_OBJECT               8
+#define OSSL_FUNC_STORE_DELETE                      9
+#define OSSL_FUNC_STORE_OPEN_EX                     10
+OSSL_CORE_MAKE_FUNC(void *, store_open, (void *provctx, const char *uri))
+OSSL_CORE_MAKE_FUNC(void *, store_attach, (void *provctx, OSSL_CORE_BIO *in))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, store_settable_ctx_params,
+                    (void *provctx))
+OSSL_CORE_MAKE_FUNC(int, store_set_ctx_params,
+                    (void *loaderctx, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, store_load,
+                    (void *loaderctx,
+                     OSSL_CALLBACK *object_cb, void *object_cbarg,
+                     OSSL_PASSPHRASE_CALLBACK *pw_cb, void *pw_cbarg))
+OSSL_CORE_MAKE_FUNC(int, store_eof, (void *loaderctx))
+OSSL_CORE_MAKE_FUNC(int, store_close, (void *loaderctx))
+OSSL_CORE_MAKE_FUNC(int, store_export_object,
+                    (void *loaderctx, const void *objref, size_t objref_sz,
+                     OSSL_CALLBACK *export_cb, void *export_cbarg))
+OSSL_CORE_MAKE_FUNC(int, store_delete,
+                    (void *provctx, const char *uri, const OSSL_PARAM params[],
+                     OSSL_PASSPHRASE_CALLBACK *pw_cb, void *pw_cbarg))
+OSSL_CORE_MAKE_FUNC(void *, store_open_ex,
+                    (void *provctx, const char *uri, const OSSL_PARAM params[],
+                     OSSL_PASSPHRASE_CALLBACK *pw_cb, void *pw_cbarg))
+
+# ifdef __cplusplus
+}
+# endif
+
+#endif
diff --git a/src/include/openssl/core_names.h b/src/include/openssl/core_names.h
new file mode 100644
index 0000000..35008eb
--- /dev/null
+++ b/src/include/openssl/core_names.h
@@ -0,0 +1,476 @@
+/*
+ * WARNING: do not edit!
+ * Generated by makefile from include\openssl\core_names.h.in
+ *
+ * Copyright 2019-2023 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+
+#ifndef OPENSSL_CORE_NAMES_H
+# define OPENSSL_CORE_NAMES_H
+# pragma once
+
+# ifdef __cplusplus
+extern "C" {
+# endif
+
+/* OSSL_CIPHER_PARAM_CTS_MODE Values */
+# define OSSL_CIPHER_CTS_MODE_CS1 "CS1"
+# define OSSL_CIPHER_CTS_MODE_CS2 "CS2"
+# define OSSL_CIPHER_CTS_MODE_CS3 "CS3"
+
+/* Known CIPHER names (not a complete list) */
+# define OSSL_CIPHER_NAME_AES_128_GCM_SIV      "AES-128-GCM-SIV"
+# define OSSL_CIPHER_NAME_AES_192_GCM_SIV      "AES-192-GCM-SIV"
+# define OSSL_CIPHER_NAME_AES_256_GCM_SIV      "AES-256-GCM-SIV"
+
+/* Known DIGEST names (not a complete list) */
+# define OSSL_DIGEST_NAME_MD5            "MD5"
+# define OSSL_DIGEST_NAME_MD5_SHA1       "MD5-SHA1"
+# define OSSL_DIGEST_NAME_SHA1           "SHA1"
+# define OSSL_DIGEST_NAME_SHA2_224       "SHA2-224"
+# define OSSL_DIGEST_NAME_SHA2_256       "SHA2-256"
+# define OSSL_DIGEST_NAME_SHA2_256_192   "SHA2-256/192"
+# define OSSL_DIGEST_NAME_SHA2_384       "SHA2-384"
+# define OSSL_DIGEST_NAME_SHA2_512       "SHA2-512"
+# define OSSL_DIGEST_NAME_SHA2_512_224   "SHA2-512/224"
+# define OSSL_DIGEST_NAME_SHA2_512_256   "SHA2-512/256"
+# define OSSL_DIGEST_NAME_MD2            "MD2"
+# define OSSL_DIGEST_NAME_MD4            "MD4"
+# define OSSL_DIGEST_NAME_MDC2           "MDC2"
+# define OSSL_DIGEST_NAME_RIPEMD160      "RIPEMD160"
+# define OSSL_DIGEST_NAME_SHA3_224       "SHA3-224"
+# define OSSL_DIGEST_NAME_SHA3_256       "SHA3-256"
+# define OSSL_DIGEST_NAME_SHA3_384       "SHA3-384"
+# define OSSL_DIGEST_NAME_SHA3_512       "SHA3-512"
+# define OSSL_DIGEST_NAME_KECCAK_KMAC128 "KECCAK-KMAC-128"
+# define OSSL_DIGEST_NAME_KECCAK_KMAC256 "KECCAK-KMAC-256"
+# define OSSL_DIGEST_NAME_SM3            "SM3"
+
+/* Known MAC names */
+# define OSSL_MAC_NAME_BLAKE2BMAC    "BLAKE2BMAC"
+# define OSSL_MAC_NAME_BLAKE2SMAC    "BLAKE2SMAC"
+# define OSSL_MAC_NAME_CMAC          "CMAC"
+# define OSSL_MAC_NAME_GMAC          "GMAC"
+# define OSSL_MAC_NAME_HMAC          "HMAC"
+# define OSSL_MAC_NAME_KMAC128       "KMAC128"
+# define OSSL_MAC_NAME_KMAC256       "KMAC256"
+# define OSSL_MAC_NAME_POLY1305      "POLY1305"
+# define OSSL_MAC_NAME_SIPHASH       "SIPHASH"
+
+/* Known KDF names */
+# define OSSL_KDF_NAME_HKDF           "HKDF"
+# define OSSL_KDF_NAME_TLS1_3_KDF     "TLS13-KDF"
+# define OSSL_KDF_NAME_PBKDF1         "PBKDF1"
+# define OSSL_KDF_NAME_PBKDF2         "PBKDF2"
+# define OSSL_KDF_NAME_SCRYPT         "SCRYPT"
+# define OSSL_KDF_NAME_SSHKDF         "SSHKDF"
+# define OSSL_KDF_NAME_SSKDF          "SSKDF"
+# define OSSL_KDF_NAME_TLS1_PRF       "TLS1-PRF"
+# define OSSL_KDF_NAME_X942KDF_ASN1   "X942KDF-ASN1"
+# define OSSL_KDF_NAME_X942KDF_CONCAT "X942KDF-CONCAT"
+# define OSSL_KDF_NAME_X963KDF        "X963KDF"
+# define OSSL_KDF_NAME_KBKDF          "KBKDF"
+# define OSSL_KDF_NAME_KRB5KDF        "KRB5KDF"
+# define OSSL_KDF_NAME_HMACDRBGKDF    "HMAC-DRBG-KDF"
+
+/* RSA padding modes */
+# define OSSL_PKEY_RSA_PAD_MODE_NONE    "none"
+# define OSSL_PKEY_RSA_PAD_MODE_PKCSV15 "pkcs1"
+# define OSSL_PKEY_RSA_PAD_MODE_OAEP    "oaep"
+# define OSSL_PKEY_RSA_PAD_MODE_X931    "x931"
+# define OSSL_PKEY_RSA_PAD_MODE_PSS     "pss"
+
+/* RSA pss padding salt length */
+# define OSSL_PKEY_RSA_PSS_SALT_LEN_DIGEST "digest"
+# define OSSL_PKEY_RSA_PSS_SALT_LEN_MAX    "max"
+# define OSSL_PKEY_RSA_PSS_SALT_LEN_AUTO   "auto"
+# define OSSL_PKEY_RSA_PSS_SALT_LEN_AUTO_DIGEST_MAX "auto-digestmax"
+
+/* OSSL_PKEY_PARAM_EC_ENCODING values */
+# define OSSL_PKEY_EC_ENCODING_EXPLICIT  "explicit"
+# define OSSL_PKEY_EC_ENCODING_GROUP     "named_curve"
+
+# define OSSL_PKEY_EC_POINT_CONVERSION_FORMAT_UNCOMPRESSED "uncompressed"
+# define OSSL_PKEY_EC_POINT_CONVERSION_FORMAT_COMPRESSED   "compressed"
+# define OSSL_PKEY_EC_POINT_CONVERSION_FORMAT_HYBRID       "hybrid"
+
+# define OSSL_PKEY_EC_GROUP_CHECK_DEFAULT     "default"
+# define OSSL_PKEY_EC_GROUP_CHECK_NAMED       "named"
+# define OSSL_PKEY_EC_GROUP_CHECK_NAMED_NIST  "named-nist"
+
+/* OSSL_KEM_PARAM_OPERATION values */
+#define OSSL_KEM_PARAM_OPERATION_RSASVE     "RSASVE"
+#define OSSL_KEM_PARAM_OPERATION_DHKEM      "DHKEM"
+
+/* Parameter name definitions - generated by util/perl/OpenSSL/paramnames.pm */
+# define OSSL_ALG_PARAM_CIPHER "cipher"
+# define OSSL_ALG_PARAM_DIGEST "digest"
+# define OSSL_ALG_PARAM_ENGINE "engine"
+# define OSSL_ALG_PARAM_MAC "mac"
+# define OSSL_ALG_PARAM_PROPERTIES "properties"
+# define OSSL_ASYM_CIPHER_PARAM_DIGEST OSSL_PKEY_PARAM_DIGEST
+# define OSSL_ASYM_CIPHER_PARAM_ENGINE OSSL_PKEY_PARAM_ENGINE
+# define OSSL_ASYM_CIPHER_PARAM_IMPLICIT_REJECTION "implicit-rejection"
+# define OSSL_ASYM_CIPHER_PARAM_MGF1_DIGEST OSSL_PKEY_PARAM_MGF1_DIGEST
+# define OSSL_ASYM_CIPHER_PARAM_MGF1_DIGEST_PROPS OSSL_PKEY_PARAM_MGF1_PROPERTIES
+# define OSSL_ASYM_CIPHER_PARAM_OAEP_DIGEST OSSL_ALG_PARAM_DIGEST
+# define OSSL_ASYM_CIPHER_PARAM_OAEP_DIGEST_PROPS "digest-props"
+# define OSSL_ASYM_CIPHER_PARAM_OAEP_LABEL "oaep-label"
+# define OSSL_ASYM_CIPHER_PARAM_PAD_MODE OSSL_PKEY_PARAM_PAD_MODE
+# define OSSL_ASYM_CIPHER_PARAM_PROPERTIES OSSL_PKEY_PARAM_PROPERTIES
+# define OSSL_ASYM_CIPHER_PARAM_TLS_CLIENT_VERSION "tls-client-version"
+# define OSSL_ASYM_CIPHER_PARAM_TLS_NEGOTIATED_VERSION "tls-negotiated-version"
+# define OSSL_CAPABILITY_TLS_GROUP_ALG "tls-group-alg"
+# define OSSL_CAPABILITY_TLS_GROUP_ID "tls-group-id"
+# define OSSL_CAPABILITY_TLS_GROUP_IS_KEM "tls-group-is-kem"
+# define OSSL_CAPABILITY_TLS_GROUP_MAX_DTLS "tls-max-dtls"
+# define OSSL_CAPABILITY_TLS_GROUP_MAX_TLS "tls-max-tls"
+# define OSSL_CAPABILITY_TLS_GROUP_MIN_DTLS "tls-min-dtls"
+# define OSSL_CAPABILITY_TLS_GROUP_MIN_TLS "tls-min-tls"
+# define OSSL_CAPABILITY_TLS_GROUP_NAME "tls-group-name"
+# define OSSL_CAPABILITY_TLS_GROUP_NAME_INTERNAL "tls-group-name-internal"
+# define OSSL_CAPABILITY_TLS_GROUP_SECURITY_BITS "tls-group-sec-bits"
+# define OSSL_CAPABILITY_TLS_SIGALG_CODE_POINT "tls-sigalg-code-point"
+# define OSSL_CAPABILITY_TLS_SIGALG_HASH_NAME "tls-sigalg-hash-name"
+# define OSSL_CAPABILITY_TLS_SIGALG_HASH_OID "tls-sigalg-hash-oid"
+# define OSSL_CAPABILITY_TLS_SIGALG_IANA_NAME "tls-sigalg-iana-name"
+# define OSSL_CAPABILITY_TLS_SIGALG_KEYTYPE "tls-sigalg-keytype"
+# define OSSL_CAPABILITY_TLS_SIGALG_KEYTYPE_OID "tls-sigalg-keytype-oid"
+# define OSSL_CAPABILITY_TLS_SIGALG_MAX_TLS "tls-max-tls"
+# define OSSL_CAPABILITY_TLS_SIGALG_MIN_TLS "tls-min-tls"
+# define OSSL_CAPABILITY_TLS_SIGALG_NAME "tls-sigalg-name"
+# define OSSL_CAPABILITY_TLS_SIGALG_OID "tls-sigalg-oid"
+# define OSSL_CAPABILITY_TLS_SIGALG_SECURITY_BITS "tls-sigalg-sec-bits"
+# define OSSL_CAPABILITY_TLS_SIGALG_SIG_NAME "tls-sigalg-sig-name"
+# define OSSL_CAPABILITY_TLS_SIGALG_SIG_OID "tls-sigalg-sig-oid"
+# define OSSL_CIPHER_PARAM_AEAD "aead"
+# define OSSL_CIPHER_PARAM_AEAD_IVLEN OSSL_CIPHER_PARAM_IVLEN
+# define OSSL_CIPHER_PARAM_AEAD_MAC_KEY "mackey"
+# define OSSL_CIPHER_PARAM_AEAD_TAG "tag"
+# define OSSL_CIPHER_PARAM_AEAD_TAGLEN "taglen"
+# define OSSL_CIPHER_PARAM_AEAD_TLS1_AAD "tlsaad"
+# define OSSL_CIPHER_PARAM_AEAD_TLS1_AAD_PAD "tlsaadpad"
+# define OSSL_CIPHER_PARAM_AEAD_TLS1_GET_IV_GEN "tlsivgen"
+# define OSSL_CIPHER_PARAM_AEAD_TLS1_IV_FIXED "tlsivfixed"
+# define OSSL_CIPHER_PARAM_AEAD_TLS1_SET_IV_INV "tlsivinv"
+# define OSSL_CIPHER_PARAM_ALGORITHM_ID_PARAMS "alg_id_param"
+# define OSSL_CIPHER_PARAM_BLOCK_SIZE "blocksize"
+# define OSSL_CIPHER_PARAM_CTS "cts"
+# define OSSL_CIPHER_PARAM_CTS_MODE "cts_mode"
+# define OSSL_CIPHER_PARAM_CUSTOM_IV "custom-iv"
+# define OSSL_CIPHER_PARAM_HAS_RAND_KEY "has-randkey"
+# define OSSL_CIPHER_PARAM_IV "iv"
+# define OSSL_CIPHER_PARAM_IVLEN "ivlen"
+# define OSSL_CIPHER_PARAM_KEYLEN "keylen"
+# define OSSL_CIPHER_PARAM_MODE "mode"
+# define OSSL_CIPHER_PARAM_NUM "num"
+# define OSSL_CIPHER_PARAM_PADDING "padding"
+# define OSSL_CIPHER_PARAM_RANDOM_KEY "randkey"
+# define OSSL_CIPHER_PARAM_RC2_KEYBITS "keybits"
+# define OSSL_CIPHER_PARAM_ROUNDS "rounds"
+# define OSSL_CIPHER_PARAM_SPEED "speed"
+# define OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK "tls-multi"
+# define OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_AAD "tls1multi_aad"
+# define OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_AAD_PACKLEN "tls1multi_aadpacklen"
+# define OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC "tls1multi_enc"
+# define OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC_IN "tls1multi_encin"
+# define OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC_LEN "tls1multi_enclen"
+# define OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_INTERLEAVE "tls1multi_interleave"
+# define OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_MAX_BUFSIZE "tls1multi_maxbufsz"
+# define OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_MAX_SEND_FRAGMENT "tls1multi_maxsndfrag"
+# define OSSL_CIPHER_PARAM_TLS_MAC "tls-mac"
+# define OSSL_CIPHER_PARAM_TLS_MAC_SIZE "tls-mac-size"
+# define OSSL_CIPHER_PARAM_TLS_VERSION "tls-version"
+# define OSSL_CIPHER_PARAM_UPDATED_IV "updated-iv"
+# define OSSL_CIPHER_PARAM_USE_BITS "use-bits"
+# define OSSL_CIPHER_PARAM_XTS_STANDARD "xts_standard"
+# define OSSL_DECODER_PARAM_PROPERTIES OSSL_ALG_PARAM_PROPERTIES
+# define OSSL_DIGEST_PARAM_ALGID_ABSENT "algid-absent"
+# define OSSL_DIGEST_PARAM_BLOCK_SIZE "blocksize"
+# define OSSL_DIGEST_PARAM_MICALG "micalg"
+# define OSSL_DIGEST_PARAM_PAD_TYPE "pad-type"
+# define OSSL_DIGEST_PARAM_SIZE "size"
+# define OSSL_DIGEST_PARAM_SSL3_MS "ssl3-ms"
+# define OSSL_DIGEST_PARAM_XOF "xof"
+# define OSSL_DIGEST_PARAM_XOFLEN "xoflen"
+# define OSSL_DRBG_PARAM_CIPHER OSSL_ALG_PARAM_CIPHER
+# define OSSL_DRBG_PARAM_DIGEST OSSL_ALG_PARAM_DIGEST
+# define OSSL_DRBG_PARAM_ENTROPY_REQUIRED "entropy_required"
+# define OSSL_DRBG_PARAM_MAC OSSL_ALG_PARAM_MAC
+# define OSSL_DRBG_PARAM_MAX_ADINLEN "max_adinlen"
+# define OSSL_DRBG_PARAM_MAX_ENTROPYLEN "max_entropylen"
+# define OSSL_DRBG_PARAM_MAX_LENGTH "maxium_length"
+# define OSSL_DRBG_PARAM_MAX_NONCELEN "max_noncelen"
+# define OSSL_DRBG_PARAM_MAX_PERSLEN "max_perslen"
+# define OSSL_DRBG_PARAM_MIN_ENTROPYLEN "min_entropylen"
+# define OSSL_DRBG_PARAM_MIN_LENGTH "minium_length"
+# define OSSL_DRBG_PARAM_MIN_NONCELEN "min_noncelen"
+# define OSSL_DRBG_PARAM_PREDICTION_RESISTANCE "prediction_resistance"
+# define OSSL_DRBG_PARAM_PROPERTIES OSSL_ALG_PARAM_PROPERTIES
+# define OSSL_DRBG_PARAM_RANDOM_DATA "random_data"
+# define OSSL_DRBG_PARAM_RESEED_COUNTER "reseed_counter"
+# define OSSL_DRBG_PARAM_RESEED_REQUESTS "reseed_requests"
+# define OSSL_DRBG_PARAM_RESEED_TIME "reseed_time"
+# define OSSL_DRBG_PARAM_RESEED_TIME_INTERVAL "reseed_time_interval"
+# define OSSL_DRBG_PARAM_SIZE "size"
+# define OSSL_DRBG_PARAM_USE_DF "use_derivation_function"
+# define OSSL_ENCODER_PARAM_CIPHER OSSL_ALG_PARAM_CIPHER
+# define OSSL_ENCODER_PARAM_ENCRYPT_LEVEL "encrypt-level"
+# define OSSL_ENCODER_PARAM_PROPERTIES OSSL_ALG_PARAM_PROPERTIES
+# define OSSL_ENCODER_PARAM_SAVE_PARAMETERS "save-parameters"
+# define OSSL_EXCHANGE_PARAM_EC_ECDH_COFACTOR_MODE "ecdh-cofactor-mode"
+# define OSSL_EXCHANGE_PARAM_KDF_DIGEST "kdf-digest"
+# define OSSL_EXCHANGE_PARAM_KDF_DIGEST_PROPS "kdf-digest-props"
+# define OSSL_EXCHANGE_PARAM_KDF_OUTLEN "kdf-outlen"
+# define OSSL_EXCHANGE_PARAM_KDF_TYPE "kdf-type"
+# define OSSL_EXCHANGE_PARAM_KDF_UKM "kdf-ukm"
+# define OSSL_EXCHANGE_PARAM_PAD "pad"
+# define OSSL_GEN_PARAM_ITERATION "iteration"
+# define OSSL_GEN_PARAM_POTENTIAL "potential"
+# define OSSL_KDF_PARAM_ARGON2_AD "ad"
+# define OSSL_KDF_PARAM_ARGON2_LANES "lanes"
+# define OSSL_KDF_PARAM_ARGON2_MEMCOST "memcost"
+# define OSSL_KDF_PARAM_ARGON2_VERSION "version"
+# define OSSL_KDF_PARAM_CEK_ALG "cekalg"
+# define OSSL_KDF_PARAM_CIPHER OSSL_ALG_PARAM_CIPHER
+# define OSSL_KDF_PARAM_CONSTANT "constant"
+# define OSSL_KDF_PARAM_DATA "data"
+# define OSSL_KDF_PARAM_DIGEST OSSL_ALG_PARAM_DIGEST
+# define OSSL_KDF_PARAM_EARLY_CLEAN "early_clean"
+# define OSSL_KDF_PARAM_HMACDRBG_ENTROPY "entropy"
+# define OSSL_KDF_PARAM_HMACDRBG_NONCE "nonce"
+# define OSSL_KDF_PARAM_INFO "info"
+# define OSSL_KDF_PARAM_ITER "iter"
+# define OSSL_KDF_PARAM_KBKDF_R "r"
+# define OSSL_KDF_PARAM_KBKDF_USE_L "use-l"
+# define OSSL_KDF_PARAM_KBKDF_USE_SEPARATOR "use-separator"
+# define OSSL_KDF_PARAM_KEY "key"
+# define OSSL_KDF_PARAM_LABEL "label"
+# define OSSL_KDF_PARAM_MAC OSSL_ALG_PARAM_MAC
+# define OSSL_KDF_PARAM_MAC_SIZE "maclen"
+# define OSSL_KDF_PARAM_MODE "mode"
+# define OSSL_KDF_PARAM_PASSWORD "pass"
+# define OSSL_KDF_PARAM_PKCS12_ID "id"
+# define OSSL_KDF_PARAM_PKCS5 "pkcs5"
+# define OSSL_KDF_PARAM_PREFIX "prefix"
+# define OSSL_KDF_PARAM_PROPERTIES OSSL_ALG_PARAM_PROPERTIES
+# define OSSL_KDF_PARAM_SALT "salt"
+# define OSSL_KDF_PARAM_SCRYPT_MAXMEM "maxmem_bytes"
+# define OSSL_KDF_PARAM_SCRYPT_N "n"
+# define OSSL_KDF_PARAM_SCRYPT_P "p"
+# define OSSL_KDF_PARAM_SCRYPT_R "r"
+# define OSSL_KDF_PARAM_SECRET "secret"
+# define OSSL_KDF_PARAM_SEED "seed"
+# define OSSL_KDF_PARAM_SIZE "size"
+# define OSSL_KDF_PARAM_SSHKDF_SESSION_ID "session_id"
+# define OSSL_KDF_PARAM_SSHKDF_TYPE "type"
+# define OSSL_KDF_PARAM_SSHKDF_XCGHASH "xcghash"
+# define OSSL_KDF_PARAM_THREADS "threads"
+# define OSSL_KDF_PARAM_UKM "ukm"
+# define OSSL_KDF_PARAM_X942_ACVPINFO "acvp-info"
+# define OSSL_KDF_PARAM_X942_PARTYUINFO "partyu-info"
+# define OSSL_KDF_PARAM_X942_PARTYVINFO "partyv-info"
+# define OSSL_KDF_PARAM_X942_SUPP_PRIVINFO "supp-privinfo"
+# define OSSL_KDF_PARAM_X942_SUPP_PUBINFO "supp-pubinfo"
+# define OSSL_KDF_PARAM_X942_USE_KEYBITS "use-keybits"
+# define OSSL_KEM_PARAM_IKME "ikme"
+# define OSSL_KEM_PARAM_OPERATION "operation"
+# define OSSL_LIBSSL_RECORD_LAYER_PARAM_BLOCK_PADDING "block_padding"
+# define OSSL_LIBSSL_RECORD_LAYER_PARAM_MAX_EARLY_DATA "max_early_data"
+# define OSSL_LIBSSL_RECORD_LAYER_PARAM_MAX_FRAG_LEN "max_frag_len"
+# define OSSL_LIBSSL_RECORD_LAYER_PARAM_MODE "mode"
+# define OSSL_LIBSSL_RECORD_LAYER_PARAM_OPTIONS "options"
+# define OSSL_LIBSSL_RECORD_LAYER_PARAM_READ_AHEAD "read_ahead"
+# define OSSL_LIBSSL_RECORD_LAYER_PARAM_STREAM_MAC "stream_mac"
+# define OSSL_LIBSSL_RECORD_LAYER_PARAM_TLSTREE "tlstree"
+# define OSSL_LIBSSL_RECORD_LAYER_PARAM_USE_ETM "use_etm"
+# define OSSL_LIBSSL_RECORD_LAYER_READ_BUFFER_LEN "read_buffer_len"
+# define OSSL_MAC_PARAM_BLOCK_SIZE "block-size"
+# define OSSL_MAC_PARAM_CIPHER OSSL_ALG_PARAM_CIPHER
+# define OSSL_MAC_PARAM_CUSTOM "custom"
+# define OSSL_MAC_PARAM_C_ROUNDS "c-rounds"
+# define OSSL_MAC_PARAM_DIGEST OSSL_ALG_PARAM_DIGEST
+# define OSSL_MAC_PARAM_DIGEST_NOINIT "digest-noinit"
+# define OSSL_MAC_PARAM_DIGEST_ONESHOT "digest-oneshot"
+# define OSSL_MAC_PARAM_D_ROUNDS "d-rounds"
+# define OSSL_MAC_PARAM_IV "iv"
+# define OSSL_MAC_PARAM_KEY "key"
+# define OSSL_MAC_PARAM_PROPERTIES OSSL_ALG_PARAM_PROPERTIES
+# define OSSL_MAC_PARAM_SALT "salt"
+# define OSSL_MAC_PARAM_SIZE "size"
+# define OSSL_MAC_PARAM_TLS_DATA_SIZE "tls-data-size"
+# define OSSL_MAC_PARAM_XOF "xof"
+# define OSSL_OBJECT_PARAM_DATA "data"
+# define OSSL_OBJECT_PARAM_DATA_STRUCTURE "data-structure"
+# define OSSL_OBJECT_PARAM_DATA_TYPE "data-type"
+# define OSSL_OBJECT_PARAM_DESC "desc"
+# define OSSL_OBJECT_PARAM_REFERENCE "reference"
+# define OSSL_OBJECT_PARAM_TYPE "type"
+# define OSSL_PASSPHRASE_PARAM_INFO "info"
+# define OSSL_PKEY_PARAM_BITS "bits"
+# define OSSL_PKEY_PARAM_CIPHER OSSL_ALG_PARAM_CIPHER
+# define OSSL_PKEY_PARAM_DEFAULT_DIGEST "default-digest"
+# define OSSL_PKEY_PARAM_DHKEM_IKM "dhkem-ikm"
+# define OSSL_PKEY_PARAM_DH_GENERATOR "safeprime-generator"
+# define OSSL_PKEY_PARAM_DH_PRIV_LEN "priv_len"
+# define OSSL_PKEY_PARAM_DIGEST OSSL_ALG_PARAM_DIGEST
+# define OSSL_PKEY_PARAM_DIGEST_SIZE "digest-size"
+# define OSSL_PKEY_PARAM_DIST_ID "distid"
+# define OSSL_PKEY_PARAM_EC_A "a"
+# define OSSL_PKEY_PARAM_EC_B "b"
+# define OSSL_PKEY_PARAM_EC_CHAR2_M "m"
+# define OSSL_PKEY_PARAM_EC_CHAR2_PP_K1 "k1"
+# define OSSL_PKEY_PARAM_EC_CHAR2_PP_K2 "k2"
+# define OSSL_PKEY_PARAM_EC_CHAR2_PP_K3 "k3"
+# define OSSL_PKEY_PARAM_EC_CHAR2_TP_BASIS "tp"
+# define OSSL_PKEY_PARAM_EC_CHAR2_TYPE "basis-type"
+# define OSSL_PKEY_PARAM_EC_COFACTOR "cofactor"
+# define OSSL_PKEY_PARAM_EC_DECODED_FROM_EXPLICIT_PARAMS "decoded-from-explicit"
+# define OSSL_PKEY_PARAM_EC_ENCODING "encoding"
+# define OSSL_PKEY_PARAM_EC_FIELD_TYPE "field-type"
+# define OSSL_PKEY_PARAM_EC_GENERATOR "generator"
+# define OSSL_PKEY_PARAM_EC_GROUP_CHECK_TYPE "group-check"
+# define OSSL_PKEY_PARAM_EC_INCLUDE_PUBLIC "include-public"
+# define OSSL_PKEY_PARAM_EC_ORDER "order"
+# define OSSL_PKEY_PARAM_EC_P "p"
+# define OSSL_PKEY_PARAM_EC_POINT_CONVERSION_FORMAT "point-format"
+# define OSSL_PKEY_PARAM_EC_PUB_X "qx"
+# define OSSL_PKEY_PARAM_EC_PUB_Y "qy"
+# define OSSL_PKEY_PARAM_EC_SEED "seed"
+# define OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY "encoded-pub-key"
+# define OSSL_PKEY_PARAM_ENGINE OSSL_ALG_PARAM_ENGINE
+# define OSSL_PKEY_PARAM_FFC_COFACTOR "j"
+# define OSSL_PKEY_PARAM_FFC_DIGEST OSSL_PKEY_PARAM_DIGEST
+# define OSSL_PKEY_PARAM_FFC_DIGEST_PROPS OSSL_PKEY_PARAM_PROPERTIES
+# define OSSL_PKEY_PARAM_FFC_G "g"
+# define OSSL_PKEY_PARAM_FFC_GINDEX "gindex"
+# define OSSL_PKEY_PARAM_FFC_H "hindex"
+# define OSSL_PKEY_PARAM_FFC_P "p"
+# define OSSL_PKEY_PARAM_FFC_PBITS "pbits"
+# define OSSL_PKEY_PARAM_FFC_PCOUNTER "pcounter"
+# define OSSL_PKEY_PARAM_FFC_Q "q"
+# define OSSL_PKEY_PARAM_FFC_QBITS "qbits"
+# define OSSL_PKEY_PARAM_FFC_SEED "seed"
+# define OSSL_PKEY_PARAM_FFC_TYPE "type"
+# define OSSL_PKEY_PARAM_FFC_VALIDATE_G "validate-g"
+# define OSSL_PKEY_PARAM_FFC_VALIDATE_LEGACY "validate-legacy"
+# define OSSL_PKEY_PARAM_FFC_VALIDATE_PQ "validate-pq"
+# define OSSL_PKEY_PARAM_GROUP_NAME "group"
+# define OSSL_PKEY_PARAM_IMPLICIT_REJECTION "implicit-rejection"
+# define OSSL_PKEY_PARAM_MANDATORY_DIGEST "mandatory-digest"
+# define OSSL_PKEY_PARAM_MASKGENFUNC "mgf"
+# define OSSL_PKEY_PARAM_MAX_SIZE "max-size"
+# define OSSL_PKEY_PARAM_MGF1_DIGEST "mgf1-digest"
+# define OSSL_PKEY_PARAM_MGF1_PROPERTIES "mgf1-properties"
+# define OSSL_PKEY_PARAM_PAD_MODE "pad-mode"
+# define OSSL_PKEY_PARAM_PRIV_KEY "priv"
+# define OSSL_PKEY_PARAM_PROPERTIES OSSL_ALG_PARAM_PROPERTIES
+# define OSSL_PKEY_PARAM_PUB_KEY "pub"
+# define OSSL_PKEY_PARAM_RSA_BITS OSSL_PKEY_PARAM_BITS
+# define OSSL_PKEY_PARAM_RSA_COEFFICIENT "rsa-coefficient"
+# define OSSL_PKEY_PARAM_RSA_COEFFICIENT1 "rsa-coefficient1"
+# define OSSL_PKEY_PARAM_RSA_COEFFICIENT2 "rsa-coefficient2"
+# define OSSL_PKEY_PARAM_RSA_COEFFICIENT3 "rsa-coefficient3"
+# define OSSL_PKEY_PARAM_RSA_COEFFICIENT4 "rsa-coefficient4"
+# define OSSL_PKEY_PARAM_RSA_COEFFICIENT5 "rsa-coefficient5"
+# define OSSL_PKEY_PARAM_RSA_COEFFICIENT6 "rsa-coefficient6"
+# define OSSL_PKEY_PARAM_RSA_COEFFICIENT7 "rsa-coefficient7"
+# define OSSL_PKEY_PARAM_RSA_COEFFICIENT8 "rsa-coefficient8"
+# define OSSL_PKEY_PARAM_RSA_COEFFICIENT9 "rsa-coefficient9"
+# define OSSL_PKEY_PARAM_RSA_D "d"
+# define OSSL_PKEY_PARAM_RSA_DERIVE_FROM_PQ "rsa-derive-from-pq"
+# define OSSL_PKEY_PARAM_RSA_DIGEST OSSL_PKEY_PARAM_DIGEST
+# define OSSL_PKEY_PARAM_RSA_DIGEST_PROPS OSSL_PKEY_PARAM_PROPERTIES
+# define OSSL_PKEY_PARAM_RSA_E "e"
+# define OSSL_PKEY_PARAM_RSA_EXPONENT "rsa-exponent"
+# define OSSL_PKEY_PARAM_RSA_EXPONENT1 "rsa-exponent1"
+# define OSSL_PKEY_PARAM_RSA_EXPONENT10 "rsa-exponent10"
+# define OSSL_PKEY_PARAM_RSA_EXPONENT2 "rsa-exponent2"
+# define OSSL_PKEY_PARAM_RSA_EXPONENT3 "rsa-exponent3"
+# define OSSL_PKEY_PARAM_RSA_EXPONENT4 "rsa-exponent4"
+# define OSSL_PKEY_PARAM_RSA_EXPONENT5 "rsa-exponent5"
+# define OSSL_PKEY_PARAM_RSA_EXPONENT6 "rsa-exponent6"
+# define OSSL_PKEY_PARAM_RSA_EXPONENT7 "rsa-exponent7"
+# define OSSL_PKEY_PARAM_RSA_EXPONENT8 "rsa-exponent8"
+# define OSSL_PKEY_PARAM_RSA_EXPONENT9 "rsa-exponent9"
+# define OSSL_PKEY_PARAM_RSA_FACTOR "rsa-factor"
+# define OSSL_PKEY_PARAM_RSA_FACTOR1 "rsa-factor1"
+# define OSSL_PKEY_PARAM_RSA_FACTOR10 "rsa-factor10"
+# define OSSL_PKEY_PARAM_RSA_FACTOR2 "rsa-factor2"
+# define OSSL_PKEY_PARAM_RSA_FACTOR3 "rsa-factor3"
+# define OSSL_PKEY_PARAM_RSA_FACTOR4 "rsa-factor4"
+# define OSSL_PKEY_PARAM_RSA_FACTOR5 "rsa-factor5"
+# define OSSL_PKEY_PARAM_RSA_FACTOR6 "rsa-factor6"
+# define OSSL_PKEY_PARAM_RSA_FACTOR7 "rsa-factor7"
+# define OSSL_PKEY_PARAM_RSA_FACTOR8 "rsa-factor8"
+# define OSSL_PKEY_PARAM_RSA_FACTOR9 "rsa-factor9"
+# define OSSL_PKEY_PARAM_RSA_MASKGENFUNC OSSL_PKEY_PARAM_MASKGENFUNC
+# define OSSL_PKEY_PARAM_RSA_MGF1_DIGEST OSSL_PKEY_PARAM_MGF1_DIGEST
+# define OSSL_PKEY_PARAM_RSA_N "n"
+# define OSSL_PKEY_PARAM_RSA_PRIMES "primes"
+# define OSSL_PKEY_PARAM_RSA_PSS_SALTLEN "saltlen"
+# define OSSL_PKEY_PARAM_RSA_TEST_P1 "p1"
+# define OSSL_PKEY_PARAM_RSA_TEST_P2 "p2"
+# define OSSL_PKEY_PARAM_RSA_TEST_Q1 "q1"
+# define OSSL_PKEY_PARAM_RSA_TEST_Q2 "q2"
+# define OSSL_PKEY_PARAM_RSA_TEST_XP "xp"
+# define OSSL_PKEY_PARAM_RSA_TEST_XP1 "xp1"
+# define OSSL_PKEY_PARAM_RSA_TEST_XP2 "xp2"
+# define OSSL_PKEY_PARAM_RSA_TEST_XQ "xq"
+# define OSSL_PKEY_PARAM_RSA_TEST_XQ1 "xq1"
+# define OSSL_PKEY_PARAM_RSA_TEST_XQ2 "xq2"
+# define OSSL_PKEY_PARAM_SECURITY_BITS "security-bits"
+# define OSSL_PKEY_PARAM_USE_COFACTOR_ECDH OSSL_PKEY_PARAM_USE_COFACTOR_FLAG
+# define OSSL_PKEY_PARAM_USE_COFACTOR_FLAG "use-cofactor-flag"
+# define OSSL_PROV_PARAM_BUILDINFO "buildinfo"
+# define OSSL_PROV_PARAM_CORE_MODULE_FILENAME "module-filename"
+# define OSSL_PROV_PARAM_CORE_PROV_NAME "provider-name"
+# define OSSL_PROV_PARAM_CORE_VERSION "openssl-version"
+# define OSSL_PROV_PARAM_DRBG_TRUNC_DIGEST "drbg-no-trunc-md"
+# define OSSL_PROV_PARAM_NAME "name"
+# define OSSL_PROV_PARAM_SECURITY_CHECKS "security-checks"
+# define OSSL_PROV_PARAM_SELF_TEST_DESC "st-desc"
+# define OSSL_PROV_PARAM_SELF_TEST_PHASE "st-phase"
+# define OSSL_PROV_PARAM_SELF_TEST_TYPE "st-type"
+# define OSSL_PROV_PARAM_STATUS "status"
+# define OSSL_PROV_PARAM_TLS1_PRF_EMS_CHECK "tls1-prf-ems-check"
+# define OSSL_PROV_PARAM_VERSION "version"
+# define OSSL_RAND_PARAM_GENERATE "generate"
+# define OSSL_RAND_PARAM_MAX_REQUEST "max_request"
+# define OSSL_RAND_PARAM_STATE "state"
+# define OSSL_RAND_PARAM_STRENGTH "strength"
+# define OSSL_RAND_PARAM_TEST_ENTROPY "test_entropy"
+# define OSSL_RAND_PARAM_TEST_NONCE "test_nonce"
+# define OSSL_SIGNATURE_PARAM_ALGORITHM_ID "algorithm-id"
+# define OSSL_SIGNATURE_PARAM_CONTEXT_STRING "context-string"
+# define OSSL_SIGNATURE_PARAM_DIGEST OSSL_PKEY_PARAM_DIGEST
+# define OSSL_SIGNATURE_PARAM_DIGEST_SIZE OSSL_PKEY_PARAM_DIGEST_SIZE
+# define OSSL_SIGNATURE_PARAM_INSTANCE "instance"
+# define OSSL_SIGNATURE_PARAM_KAT "kat"
+# define OSSL_SIGNATURE_PARAM_MGF1_DIGEST OSSL_PKEY_PARAM_MGF1_DIGEST
+# define OSSL_SIGNATURE_PARAM_MGF1_PROPERTIES OSSL_PKEY_PARAM_MGF1_PROPERTIES
+# define OSSL_SIGNATURE_PARAM_NONCE_TYPE "nonce-type"
+# define OSSL_SIGNATURE_PARAM_PAD_MODE OSSL_PKEY_PARAM_PAD_MODE
+# define OSSL_SIGNATURE_PARAM_PROPERTIES OSSL_PKEY_PARAM_PROPERTIES
+# define OSSL_SIGNATURE_PARAM_PSS_SALTLEN "saltlen"
+# define OSSL_STORE_PARAM_ALIAS "alias"
+# define OSSL_STORE_PARAM_DIGEST "digest"
+# define OSSL_STORE_PARAM_EXPECT "expect"
+# define OSSL_STORE_PARAM_FINGERPRINT "fingerprint"
+# define OSSL_STORE_PARAM_INPUT_TYPE "input-type"
+# define OSSL_STORE_PARAM_ISSUER "name"
+# define OSSL_STORE_PARAM_PROPERTIES "properties"
+# define OSSL_STORE_PARAM_SERIAL "serial"
+# define OSSL_STORE_PARAM_SUBJECT "subject"
+
+# ifdef __cplusplus
+}
+# endif
+
+#endif
diff --git a/src/include/openssl/core_object.h b/src/include/openssl/core_object.h
new file mode 100644
index 0000000..62ccf39
--- /dev/null
+++ b/src/include/openssl/core_object.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2020-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_CORE_OBJECT_H
+# define OPENSSL_CORE_OBJECT_H
+# pragma once
+
+# ifdef __cplusplus
+extern "C" {
+# endif
+
+/*-
+ * Known object types
+ *
+ * These numbers are used as values for the OSSL_PARAM parameter
+ * OSSL_OBJECT_PARAM_TYPE.
+ *
+ * For most of these types, there's a corresponding libcrypto object type.
+ * The corresponding type is indicated with a comment after the number.
+ */
+# define OSSL_OBJECT_UNKNOWN            0
+# define OSSL_OBJECT_NAME               1 /* char * */
+# define OSSL_OBJECT_PKEY               2 /* EVP_PKEY * */
+# define OSSL_OBJECT_CERT               3 /* X509 * */
+# define OSSL_OBJECT_CRL                4 /* X509_CRL * */
+
+/*
+ * The rest of the associated OSSL_PARAM elements is described in core_names.h
+ */
+
+# ifdef __cplusplus
+}
+# endif
+
+#endif
diff --git a/src/include/openssl/crmf.h b/src/include/openssl/crmf.h
new file mode 100644
index 0000000..aaf8829
--- /dev/null
+++ b/src/include/openssl/crmf.h
@@ -0,0 +1,229 @@
+/*-
+ * WARNING: do not edit!
+ * Generated by makefile from include\openssl\crmf.h.in
+ *
+ * Copyright 2007-2023 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright Nokia 2007-2019
+ * Copyright Siemens AG 2015-2019
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ *
+ * CRMF (RFC 4211) implementation by M. Peylo, M. Viljanen, and D. von Oheimb.
+ */
+
+
+
+#ifndef OPENSSL_CRMF_H
+# define OPENSSL_CRMF_H
+
+# include <openssl/opensslconf.h>
+
+# ifndef OPENSSL_NO_CRMF
+#  include <openssl/opensslv.h>
+#  include <openssl/safestack.h>
+#  include <openssl/crmferr.h>
+#  include <openssl/x509v3.h> /* for GENERAL_NAME etc. */
+
+/* explicit #includes not strictly needed since implied by the above: */
+#  include <openssl/types.h>
+#  include <openssl/x509.h>
+
+#  ifdef __cplusplus
+extern "C" {
+#  endif
+
+#  define OSSL_CRMF_POPOPRIVKEY_THISMESSAGE          0
+#  define OSSL_CRMF_POPOPRIVKEY_SUBSEQUENTMESSAGE    1
+#  define OSSL_CRMF_POPOPRIVKEY_DHMAC                2
+#  define OSSL_CRMF_POPOPRIVKEY_AGREEMAC             3
+#  define OSSL_CRMF_POPOPRIVKEY_ENCRYPTEDKEY         4
+
+#  define OSSL_CRMF_SUBSEQUENTMESSAGE_ENCRCERT       0
+#  define OSSL_CRMF_SUBSEQUENTMESSAGE_CHALLENGERESP  1
+typedef struct ossl_crmf_encryptedvalue_st OSSL_CRMF_ENCRYPTEDVALUE;
+
+DECLARE_ASN1_FUNCTIONS(OSSL_CRMF_ENCRYPTEDVALUE)
+typedef struct ossl_crmf_msg_st OSSL_CRMF_MSG;
+DECLARE_ASN1_FUNCTIONS(OSSL_CRMF_MSG)
+DECLARE_ASN1_DUP_FUNCTION(OSSL_CRMF_MSG)
+SKM_DEFINE_STACK_OF_INTERNAL(OSSL_CRMF_MSG, OSSL_CRMF_MSG, OSSL_CRMF_MSG)
+#define sk_OSSL_CRMF_MSG_num(sk) OPENSSL_sk_num(ossl_check_const_OSSL_CRMF_MSG_sk_type(sk))
+#define sk_OSSL_CRMF_MSG_value(sk, idx) ((OSSL_CRMF_MSG *)OPENSSL_sk_value(ossl_check_const_OSSL_CRMF_MSG_sk_type(sk), (idx)))
+#define sk_OSSL_CRMF_MSG_new(cmp) ((STACK_OF(OSSL_CRMF_MSG) *)OPENSSL_sk_new(ossl_check_OSSL_CRMF_MSG_compfunc_type(cmp)))
+#define sk_OSSL_CRMF_MSG_new_null() ((STACK_OF(OSSL_CRMF_MSG) *)OPENSSL_sk_new_null())
+#define sk_OSSL_CRMF_MSG_new_reserve(cmp, n) ((STACK_OF(OSSL_CRMF_MSG) *)OPENSSL_sk_new_reserve(ossl_check_OSSL_CRMF_MSG_compfunc_type(cmp), (n)))
+#define sk_OSSL_CRMF_MSG_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OSSL_CRMF_MSG_sk_type(sk), (n))
+#define sk_OSSL_CRMF_MSG_free(sk) OPENSSL_sk_free(ossl_check_OSSL_CRMF_MSG_sk_type(sk))
+#define sk_OSSL_CRMF_MSG_zero(sk) OPENSSL_sk_zero(ossl_check_OSSL_CRMF_MSG_sk_type(sk))
+#define sk_OSSL_CRMF_MSG_delete(sk, i) ((OSSL_CRMF_MSG *)OPENSSL_sk_delete(ossl_check_OSSL_CRMF_MSG_sk_type(sk), (i)))
+#define sk_OSSL_CRMF_MSG_delete_ptr(sk, ptr) ((OSSL_CRMF_MSG *)OPENSSL_sk_delete_ptr(ossl_check_OSSL_CRMF_MSG_sk_type(sk), ossl_check_OSSL_CRMF_MSG_type(ptr)))
+#define sk_OSSL_CRMF_MSG_push(sk, ptr) OPENSSL_sk_push(ossl_check_OSSL_CRMF_MSG_sk_type(sk), ossl_check_OSSL_CRMF_MSG_type(ptr))
+#define sk_OSSL_CRMF_MSG_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_OSSL_CRMF_MSG_sk_type(sk), ossl_check_OSSL_CRMF_MSG_type(ptr))
+#define sk_OSSL_CRMF_MSG_pop(sk) ((OSSL_CRMF_MSG *)OPENSSL_sk_pop(ossl_check_OSSL_CRMF_MSG_sk_type(sk)))
+#define sk_OSSL_CRMF_MSG_shift(sk) ((OSSL_CRMF_MSG *)OPENSSL_sk_shift(ossl_check_OSSL_CRMF_MSG_sk_type(sk)))
+#define sk_OSSL_CRMF_MSG_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OSSL_CRMF_MSG_sk_type(sk),ossl_check_OSSL_CRMF_MSG_freefunc_type(freefunc))
+#define sk_OSSL_CRMF_MSG_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_OSSL_CRMF_MSG_sk_type(sk), ossl_check_OSSL_CRMF_MSG_type(ptr), (idx))
+#define sk_OSSL_CRMF_MSG_set(sk, idx, ptr) ((OSSL_CRMF_MSG *)OPENSSL_sk_set(ossl_check_OSSL_CRMF_MSG_sk_type(sk), (idx), ossl_check_OSSL_CRMF_MSG_type(ptr)))
+#define sk_OSSL_CRMF_MSG_find(sk, ptr) OPENSSL_sk_find(ossl_check_OSSL_CRMF_MSG_sk_type(sk), ossl_check_OSSL_CRMF_MSG_type(ptr))
+#define sk_OSSL_CRMF_MSG_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_OSSL_CRMF_MSG_sk_type(sk), ossl_check_OSSL_CRMF_MSG_type(ptr))
+#define sk_OSSL_CRMF_MSG_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OSSL_CRMF_MSG_sk_type(sk), ossl_check_OSSL_CRMF_MSG_type(ptr), pnum)
+#define sk_OSSL_CRMF_MSG_sort(sk) OPENSSL_sk_sort(ossl_check_OSSL_CRMF_MSG_sk_type(sk))
+#define sk_OSSL_CRMF_MSG_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OSSL_CRMF_MSG_sk_type(sk))
+#define sk_OSSL_CRMF_MSG_dup(sk) ((STACK_OF(OSSL_CRMF_MSG) *)OPENSSL_sk_dup(ossl_check_const_OSSL_CRMF_MSG_sk_type(sk)))
+#define sk_OSSL_CRMF_MSG_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OSSL_CRMF_MSG) *)OPENSSL_sk_deep_copy(ossl_check_const_OSSL_CRMF_MSG_sk_type(sk), ossl_check_OSSL_CRMF_MSG_copyfunc_type(copyfunc), ossl_check_OSSL_CRMF_MSG_freefunc_type(freefunc)))
+#define sk_OSSL_CRMF_MSG_set_cmp_func(sk, cmp) ((sk_OSSL_CRMF_MSG_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OSSL_CRMF_MSG_sk_type(sk), ossl_check_OSSL_CRMF_MSG_compfunc_type(cmp)))
+
+typedef struct ossl_crmf_attributetypeandvalue_st OSSL_CRMF_ATTRIBUTETYPEANDVALUE;
+typedef struct ossl_crmf_pbmparameter_st OSSL_CRMF_PBMPARAMETER;
+DECLARE_ASN1_FUNCTIONS(OSSL_CRMF_PBMPARAMETER)
+typedef struct ossl_crmf_poposigningkey_st OSSL_CRMF_POPOSIGNINGKEY;
+typedef struct ossl_crmf_certrequest_st OSSL_CRMF_CERTREQUEST;
+typedef struct ossl_crmf_certid_st OSSL_CRMF_CERTID;
+DECLARE_ASN1_FUNCTIONS(OSSL_CRMF_CERTID)
+DECLARE_ASN1_DUP_FUNCTION(OSSL_CRMF_CERTID)
+SKM_DEFINE_STACK_OF_INTERNAL(OSSL_CRMF_CERTID, OSSL_CRMF_CERTID, OSSL_CRMF_CERTID)
+#define sk_OSSL_CRMF_CERTID_num(sk) OPENSSL_sk_num(ossl_check_const_OSSL_CRMF_CERTID_sk_type(sk))
+#define sk_OSSL_CRMF_CERTID_value(sk, idx) ((OSSL_CRMF_CERTID *)OPENSSL_sk_value(ossl_check_const_OSSL_CRMF_CERTID_sk_type(sk), (idx)))
+#define sk_OSSL_CRMF_CERTID_new(cmp) ((STACK_OF(OSSL_CRMF_CERTID) *)OPENSSL_sk_new(ossl_check_OSSL_CRMF_CERTID_compfunc_type(cmp)))
+#define sk_OSSL_CRMF_CERTID_new_null() ((STACK_OF(OSSL_CRMF_CERTID) *)OPENSSL_sk_new_null())
+#define sk_OSSL_CRMF_CERTID_new_reserve(cmp, n) ((STACK_OF(OSSL_CRMF_CERTID) *)OPENSSL_sk_new_reserve(ossl_check_OSSL_CRMF_CERTID_compfunc_type(cmp), (n)))
+#define sk_OSSL_CRMF_CERTID_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OSSL_CRMF_CERTID_sk_type(sk), (n))
+#define sk_OSSL_CRMF_CERTID_free(sk) OPENSSL_sk_free(ossl_check_OSSL_CRMF_CERTID_sk_type(sk))
+#define sk_OSSL_CRMF_CERTID_zero(sk) OPENSSL_sk_zero(ossl_check_OSSL_CRMF_CERTID_sk_type(sk))
+#define sk_OSSL_CRMF_CERTID_delete(sk, i) ((OSSL_CRMF_CERTID *)OPENSSL_sk_delete(ossl_check_OSSL_CRMF_CERTID_sk_type(sk), (i)))
+#define sk_OSSL_CRMF_CERTID_delete_ptr(sk, ptr) ((OSSL_CRMF_CERTID *)OPENSSL_sk_delete_ptr(ossl_check_OSSL_CRMF_CERTID_sk_type(sk), ossl_check_OSSL_CRMF_CERTID_type(ptr)))
+#define sk_OSSL_CRMF_CERTID_push(sk, ptr) OPENSSL_sk_push(ossl_check_OSSL_CRMF_CERTID_sk_type(sk), ossl_check_OSSL_CRMF_CERTID_type(ptr))
+#define sk_OSSL_CRMF_CERTID_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_OSSL_CRMF_CERTID_sk_type(sk), ossl_check_OSSL_CRMF_CERTID_type(ptr))
+#define sk_OSSL_CRMF_CERTID_pop(sk) ((OSSL_CRMF_CERTID *)OPENSSL_sk_pop(ossl_check_OSSL_CRMF_CERTID_sk_type(sk)))
+#define sk_OSSL_CRMF_CERTID_shift(sk) ((OSSL_CRMF_CERTID *)OPENSSL_sk_shift(ossl_check_OSSL_CRMF_CERTID_sk_type(sk)))
+#define sk_OSSL_CRMF_CERTID_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OSSL_CRMF_CERTID_sk_type(sk),ossl_check_OSSL_CRMF_CERTID_freefunc_type(freefunc))
+#define sk_OSSL_CRMF_CERTID_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_OSSL_CRMF_CERTID_sk_type(sk), ossl_check_OSSL_CRMF_CERTID_type(ptr), (idx))
+#define sk_OSSL_CRMF_CERTID_set(sk, idx, ptr) ((OSSL_CRMF_CERTID *)OPENSSL_sk_set(ossl_check_OSSL_CRMF_CERTID_sk_type(sk), (idx), ossl_check_OSSL_CRMF_CERTID_type(ptr)))
+#define sk_OSSL_CRMF_CERTID_find(sk, ptr) OPENSSL_sk_find(ossl_check_OSSL_CRMF_CERTID_sk_type(sk), ossl_check_OSSL_CRMF_CERTID_type(ptr))
+#define sk_OSSL_CRMF_CERTID_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_OSSL_CRMF_CERTID_sk_type(sk), ossl_check_OSSL_CRMF_CERTID_type(ptr))
+#define sk_OSSL_CRMF_CERTID_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OSSL_CRMF_CERTID_sk_type(sk), ossl_check_OSSL_CRMF_CERTID_type(ptr), pnum)
+#define sk_OSSL_CRMF_CERTID_sort(sk) OPENSSL_sk_sort(ossl_check_OSSL_CRMF_CERTID_sk_type(sk))
+#define sk_OSSL_CRMF_CERTID_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OSSL_CRMF_CERTID_sk_type(sk))
+#define sk_OSSL_CRMF_CERTID_dup(sk) ((STACK_OF(OSSL_CRMF_CERTID) *)OPENSSL_sk_dup(ossl_check_const_OSSL_CRMF_CERTID_sk_type(sk)))
+#define sk_OSSL_CRMF_CERTID_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OSSL_CRMF_CERTID) *)OPENSSL_sk_deep_copy(ossl_check_const_OSSL_CRMF_CERTID_sk_type(sk), ossl_check_OSSL_CRMF_CERTID_copyfunc_type(copyfunc), ossl_check_OSSL_CRMF_CERTID_freefunc_type(freefunc)))
+#define sk_OSSL_CRMF_CERTID_set_cmp_func(sk, cmp) ((sk_OSSL_CRMF_CERTID_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OSSL_CRMF_CERTID_sk_type(sk), ossl_check_OSSL_CRMF_CERTID_compfunc_type(cmp)))
+
+
+typedef struct ossl_crmf_pkipublicationinfo_st OSSL_CRMF_PKIPUBLICATIONINFO;
+DECLARE_ASN1_FUNCTIONS(OSSL_CRMF_PKIPUBLICATIONINFO)
+typedef struct ossl_crmf_singlepubinfo_st OSSL_CRMF_SINGLEPUBINFO;
+DECLARE_ASN1_FUNCTIONS(OSSL_CRMF_SINGLEPUBINFO)
+typedef struct ossl_crmf_certtemplate_st OSSL_CRMF_CERTTEMPLATE;
+DECLARE_ASN1_FUNCTIONS(OSSL_CRMF_CERTTEMPLATE)
+typedef STACK_OF(OSSL_CRMF_MSG) OSSL_CRMF_MSGS;
+DECLARE_ASN1_FUNCTIONS(OSSL_CRMF_MSGS)
+
+typedef struct ossl_crmf_optionalvalidity_st OSSL_CRMF_OPTIONALVALIDITY;
+
+/* crmf_pbm.c */
+OSSL_CRMF_PBMPARAMETER *OSSL_CRMF_pbmp_new(OSSL_LIB_CTX *libctx, size_t slen,
+                                           int owfnid, size_t itercnt,
+                                           int macnid);
+int OSSL_CRMF_pbm_new(OSSL_LIB_CTX *libctx, const char *propq,
+                      const OSSL_CRMF_PBMPARAMETER *pbmp,
+                      const unsigned char *msg, size_t msglen,
+                      const unsigned char *sec, size_t seclen,
+                      unsigned char **mac, size_t *maclen);
+
+/* crmf_lib.c */
+int OSSL_CRMF_MSG_set1_regCtrl_regToken(OSSL_CRMF_MSG *msg,
+                                        const ASN1_UTF8STRING *tok);
+ASN1_UTF8STRING
+*OSSL_CRMF_MSG_get0_regCtrl_regToken(const OSSL_CRMF_MSG *msg);
+int OSSL_CRMF_MSG_set1_regCtrl_authenticator(OSSL_CRMF_MSG *msg,
+                                             const ASN1_UTF8STRING *auth);
+ASN1_UTF8STRING
+*OSSL_CRMF_MSG_get0_regCtrl_authenticator(const OSSL_CRMF_MSG *msg);
+int
+OSSL_CRMF_MSG_PKIPublicationInfo_push0_SinglePubInfo(OSSL_CRMF_PKIPUBLICATIONINFO *pi,
+                                                     OSSL_CRMF_SINGLEPUBINFO *spi);
+#  define OSSL_CRMF_PUB_METHOD_DONTCARE 0
+#  define OSSL_CRMF_PUB_METHOD_X500     1
+#  define OSSL_CRMF_PUB_METHOD_WEB      2
+#  define OSSL_CRMF_PUB_METHOD_LDAP     3
+int OSSL_CRMF_MSG_set0_SinglePubInfo(OSSL_CRMF_SINGLEPUBINFO *spi,
+                                     int method, GENERAL_NAME *nm);
+#  define OSSL_CRMF_PUB_ACTION_DONTPUBLISH   0
+#  define OSSL_CRMF_PUB_ACTION_PLEASEPUBLISH 1
+int OSSL_CRMF_MSG_set_PKIPublicationInfo_action(OSSL_CRMF_PKIPUBLICATIONINFO *pi,
+                                                int action);
+int OSSL_CRMF_MSG_set1_regCtrl_pkiPublicationInfo(OSSL_CRMF_MSG *msg,
+                                                  const OSSL_CRMF_PKIPUBLICATIONINFO *pi);
+OSSL_CRMF_PKIPUBLICATIONINFO
+*OSSL_CRMF_MSG_get0_regCtrl_pkiPublicationInfo(const OSSL_CRMF_MSG *msg);
+int OSSL_CRMF_MSG_set1_regCtrl_protocolEncrKey(OSSL_CRMF_MSG *msg,
+                                               const X509_PUBKEY *pubkey);
+X509_PUBKEY
+*OSSL_CRMF_MSG_get0_regCtrl_protocolEncrKey(const OSSL_CRMF_MSG *msg);
+int OSSL_CRMF_MSG_set1_regCtrl_oldCertID(OSSL_CRMF_MSG *msg,
+                                         const OSSL_CRMF_CERTID *cid);
+OSSL_CRMF_CERTID
+*OSSL_CRMF_MSG_get0_regCtrl_oldCertID(const OSSL_CRMF_MSG *msg);
+OSSL_CRMF_CERTID *OSSL_CRMF_CERTID_gen(const X509_NAME *issuer,
+                                       const ASN1_INTEGER *serial);
+
+int OSSL_CRMF_MSG_set1_regInfo_utf8Pairs(OSSL_CRMF_MSG *msg,
+                                         const ASN1_UTF8STRING *utf8pairs);
+ASN1_UTF8STRING
+*OSSL_CRMF_MSG_get0_regInfo_utf8Pairs(const OSSL_CRMF_MSG *msg);
+int OSSL_CRMF_MSG_set1_regInfo_certReq(OSSL_CRMF_MSG *msg,
+                                       const OSSL_CRMF_CERTREQUEST *cr);
+OSSL_CRMF_CERTREQUEST
+*OSSL_CRMF_MSG_get0_regInfo_certReq(const OSSL_CRMF_MSG *msg);
+
+int OSSL_CRMF_MSG_set0_validity(OSSL_CRMF_MSG *crm,
+                                ASN1_TIME *notBefore, ASN1_TIME *notAfter);
+int OSSL_CRMF_MSG_set_certReqId(OSSL_CRMF_MSG *crm, int rid);
+int OSSL_CRMF_MSG_get_certReqId(const OSSL_CRMF_MSG *crm);
+int OSSL_CRMF_MSG_set0_extensions(OSSL_CRMF_MSG *crm, X509_EXTENSIONS *exts);
+
+int OSSL_CRMF_MSG_push0_extension(OSSL_CRMF_MSG *crm, X509_EXTENSION *ext);
+#  define OSSL_CRMF_POPO_NONE       -1
+#  define OSSL_CRMF_POPO_RAVERIFIED 0
+#  define OSSL_CRMF_POPO_SIGNATURE  1
+#  define OSSL_CRMF_POPO_KEYENC     2
+#  define OSSL_CRMF_POPO_KEYAGREE   3
+int OSSL_CRMF_MSG_create_popo(int meth, OSSL_CRMF_MSG *crm,
+                              EVP_PKEY *pkey, const EVP_MD *digest,
+                              OSSL_LIB_CTX *libctx, const char *propq);
+int OSSL_CRMF_MSGS_verify_popo(const OSSL_CRMF_MSGS *reqs,
+                               int rid, int acceptRAVerified,
+                               OSSL_LIB_CTX *libctx, const char *propq);
+OSSL_CRMF_CERTTEMPLATE *OSSL_CRMF_MSG_get0_tmpl(const OSSL_CRMF_MSG *crm);
+X509_PUBKEY
+*OSSL_CRMF_CERTTEMPLATE_get0_publicKey(const OSSL_CRMF_CERTTEMPLATE *tmpl);
+const X509_NAME
+*OSSL_CRMF_CERTTEMPLATE_get0_subject(const OSSL_CRMF_CERTTEMPLATE *tmpl);
+const X509_NAME
+*OSSL_CRMF_CERTTEMPLATE_get0_issuer(const OSSL_CRMF_CERTTEMPLATE *tmpl);
+const ASN1_INTEGER
+*OSSL_CRMF_CERTTEMPLATE_get0_serialNumber(const OSSL_CRMF_CERTTEMPLATE *tmpl);
+X509_EXTENSIONS
+*OSSL_CRMF_CERTTEMPLATE_get0_extensions(const OSSL_CRMF_CERTTEMPLATE *tmpl);
+const X509_NAME
+*OSSL_CRMF_CERTID_get0_issuer(const OSSL_CRMF_CERTID *cid);
+const ASN1_INTEGER
+*OSSL_CRMF_CERTID_get0_serialNumber(const OSSL_CRMF_CERTID *cid);
+int OSSL_CRMF_CERTTEMPLATE_fill(OSSL_CRMF_CERTTEMPLATE *tmpl,
+                                EVP_PKEY *pubkey,
+                                const X509_NAME *subject,
+                                const X509_NAME *issuer,
+                                const ASN1_INTEGER *serial);
+X509
+*OSSL_CRMF_ENCRYPTEDVALUE_get1_encCert(const OSSL_CRMF_ENCRYPTEDVALUE *ecert,
+                                       OSSL_LIB_CTX *libctx, const char *propq,
+                                       EVP_PKEY *pkey);
+
+#  ifdef __cplusplus
+}
+#  endif
+# endif /* !defined(OPENSSL_NO_CRMF) */
+#endif /* !defined(OPENSSL_CRMF_H) */
diff --git a/src/include/openssl/crmferr.h b/src/include/openssl/crmferr.h
new file mode 100644
index 0000000..b242b92
--- /dev/null
+++ b/src/include/openssl/crmferr.h
@@ -0,0 +1,50 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_CRMFERR_H
+# define OPENSSL_CRMFERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+# ifndef OPENSSL_NO_CRMF
+
+
+/*
+ * CRMF reason codes.
+ */
+#  define CRMF_R_BAD_PBM_ITERATIONCOUNT                    100
+#  define CRMF_R_CRMFERROR                                 102
+#  define CRMF_R_ERROR                                     103
+#  define CRMF_R_ERROR_DECODING_CERTIFICATE                104
+#  define CRMF_R_ERROR_DECRYPTING_CERTIFICATE              105
+#  define CRMF_R_ERROR_DECRYPTING_SYMMETRIC_KEY            106
+#  define CRMF_R_FAILURE_OBTAINING_RANDOM                  107
+#  define CRMF_R_ITERATIONCOUNT_BELOW_100                  108
+#  define CRMF_R_MALFORMED_IV                              101
+#  define CRMF_R_NULL_ARGUMENT                             109
+#  define CRMF_R_POPOSKINPUT_NOT_SUPPORTED                 113
+#  define CRMF_R_POPO_INCONSISTENT_PUBLIC_KEY              117
+#  define CRMF_R_POPO_MISSING                              121
+#  define CRMF_R_POPO_MISSING_PUBLIC_KEY                   118
+#  define CRMF_R_POPO_MISSING_SUBJECT                      119
+#  define CRMF_R_POPO_RAVERIFIED_NOT_ACCEPTED              120
+#  define CRMF_R_SETTING_MAC_ALGOR_FAILURE                 110
+#  define CRMF_R_SETTING_OWF_ALGOR_FAILURE                 111
+#  define CRMF_R_UNSUPPORTED_ALGORITHM                     112
+#  define CRMF_R_UNSUPPORTED_CIPHER                        114
+#  define CRMF_R_UNSUPPORTED_METHOD_FOR_CREATING_POPO      115
+#  define CRMF_R_UNSUPPORTED_POPO_METHOD                   116
+
+# endif
+#endif
diff --git a/src/include/openssl/crypto.h b/src/include/openssl/crypto.h
new file mode 100644
index 0000000..b062437
--- /dev/null
+++ b/src/include/openssl/crypto.h
@@ -0,0 +1,561 @@
+/*
+ * WARNING: do not edit!
+ * Generated by makefile from include\openssl\crypto.h.in
+ *
+ * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+
+
+#ifndef OPENSSL_CRYPTO_H
+# define OPENSSL_CRYPTO_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_CRYPTO_H
+# endif
+
+# include <stdlib.h>
+# include <time.h>
+
+# include <openssl/e_os2.h>
+
+# ifndef OPENSSL_NO_STDIO
+#  include <stdio.h>
+# endif
+
+# include <openssl/safestack.h>
+# include <openssl/opensslv.h>
+# include <openssl/types.h>
+# include <openssl/opensslconf.h>
+# include <openssl/cryptoerr.h>
+# include <openssl/core.h>
+
+# ifdef CHARSET_EBCDIC
+#  include <openssl/ebcdic.h>
+# endif
+
+/*
+ * Resolve problems on some operating systems with symbol names that clash
+ * one way or another
+ */
+# include <openssl/symhacks.h>
+
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#  include <openssl/opensslv.h>
+# endif
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#  define SSLeay                  OpenSSL_version_num
+#  define SSLeay_version          OpenSSL_version
+#  define SSLEAY_VERSION_NUMBER   OPENSSL_VERSION_NUMBER
+#  define SSLEAY_VERSION          OPENSSL_VERSION
+#  define SSLEAY_CFLAGS           OPENSSL_CFLAGS
+#  define SSLEAY_BUILT_ON         OPENSSL_BUILT_ON
+#  define SSLEAY_PLATFORM         OPENSSL_PLATFORM
+#  define SSLEAY_DIR              OPENSSL_DIR
+
+/*
+ * Old type for allocating dynamic locks. No longer used. Use the new thread
+ * API instead.
+ */
+typedef struct {
+    int dummy;
+} CRYPTO_dynlock;
+
+# endif /* OPENSSL_NO_DEPRECATED_1_1_0 */
+
+typedef void CRYPTO_RWLOCK;
+
+CRYPTO_RWLOCK *CRYPTO_THREAD_lock_new(void);
+__owur int CRYPTO_THREAD_read_lock(CRYPTO_RWLOCK *lock);
+__owur int CRYPTO_THREAD_write_lock(CRYPTO_RWLOCK *lock);
+int CRYPTO_THREAD_unlock(CRYPTO_RWLOCK *lock);
+void CRYPTO_THREAD_lock_free(CRYPTO_RWLOCK *lock);
+
+int CRYPTO_atomic_add(int *val, int amount, int *ret, CRYPTO_RWLOCK *lock);
+int CRYPTO_atomic_or(uint64_t *val, uint64_t op, uint64_t *ret,
+                     CRYPTO_RWLOCK *lock);
+int CRYPTO_atomic_load(uint64_t *val, uint64_t *ret, CRYPTO_RWLOCK *lock);
+int CRYPTO_atomic_load_int(int *val, int *ret, CRYPTO_RWLOCK *lock);
+
+/* No longer needed, so this is a no-op */
+#define OPENSSL_malloc_init() while(0) continue
+
+# define OPENSSL_malloc(num) \
+        CRYPTO_malloc(num, OPENSSL_FILE, OPENSSL_LINE)
+# define OPENSSL_zalloc(num) \
+        CRYPTO_zalloc(num, OPENSSL_FILE, OPENSSL_LINE)
+# define OPENSSL_realloc(addr, num) \
+        CRYPTO_realloc(addr, num, OPENSSL_FILE, OPENSSL_LINE)
+# define OPENSSL_clear_realloc(addr, old_num, num) \
+        CRYPTO_clear_realloc(addr, old_num, num, OPENSSL_FILE, OPENSSL_LINE)
+# define OPENSSL_clear_free(addr, num) \
+        CRYPTO_clear_free(addr, num, OPENSSL_FILE, OPENSSL_LINE)
+# define OPENSSL_free(addr) \
+        CRYPTO_free(addr, OPENSSL_FILE, OPENSSL_LINE)
+# define OPENSSL_memdup(str, s) \
+        CRYPTO_memdup((str), s, OPENSSL_FILE, OPENSSL_LINE)
+# define OPENSSL_strdup(str) \
+        CRYPTO_strdup(str, OPENSSL_FILE, OPENSSL_LINE)
+# define OPENSSL_strndup(str, n) \
+        CRYPTO_strndup(str, n, OPENSSL_FILE, OPENSSL_LINE)
+# define OPENSSL_secure_malloc(num) \
+        CRYPTO_secure_malloc(num, OPENSSL_FILE, OPENSSL_LINE)
+# define OPENSSL_secure_zalloc(num) \
+        CRYPTO_secure_zalloc(num, OPENSSL_FILE, OPENSSL_LINE)
+# define OPENSSL_secure_free(addr) \
+        CRYPTO_secure_free(addr, OPENSSL_FILE, OPENSSL_LINE)
+# define OPENSSL_secure_clear_free(addr, num) \
+        CRYPTO_secure_clear_free(addr, num, OPENSSL_FILE, OPENSSL_LINE)
+# define OPENSSL_secure_actual_size(ptr) \
+        CRYPTO_secure_actual_size(ptr)
+
+size_t OPENSSL_strlcpy(char *dst, const char *src, size_t siz);
+size_t OPENSSL_strlcat(char *dst, const char *src, size_t siz);
+size_t OPENSSL_strnlen(const char *str, size_t maxlen);
+int OPENSSL_buf2hexstr_ex(char *str, size_t str_n, size_t *strlength,
+                          const unsigned char *buf, size_t buflen,
+                          const char sep);
+char *OPENSSL_buf2hexstr(const unsigned char *buf, long buflen);
+int OPENSSL_hexstr2buf_ex(unsigned char *buf, size_t buf_n, size_t *buflen,
+                          const char *str, const char sep);
+unsigned char *OPENSSL_hexstr2buf(const char *str, long *buflen);
+int OPENSSL_hexchar2int(unsigned char c);
+int OPENSSL_strcasecmp(const char *s1, const char *s2);
+int OPENSSL_strncasecmp(const char *s1, const char *s2, size_t n);
+
+# define OPENSSL_MALLOC_MAX_NELEMS(type)  (((1U<<(sizeof(int)*8-1))-1)/sizeof(type))
+
+/*
+ * These functions return the values of OPENSSL_VERSION_MAJOR,
+ * OPENSSL_VERSION_MINOR, OPENSSL_VERSION_PATCH, OPENSSL_VERSION_PRE_RELEASE
+ * and OPENSSL_VERSION_BUILD_METADATA, respectively.
+ */
+unsigned int OPENSSL_version_major(void);
+unsigned int OPENSSL_version_minor(void);
+unsigned int OPENSSL_version_patch(void);
+const char *OPENSSL_version_pre_release(void);
+const char *OPENSSL_version_build_metadata(void);
+
+unsigned long OpenSSL_version_num(void);
+const char *OpenSSL_version(int type);
+# define OPENSSL_VERSION                0
+# define OPENSSL_CFLAGS                 1
+# define OPENSSL_BUILT_ON               2
+# define OPENSSL_PLATFORM               3
+# define OPENSSL_DIR                    4
+# define OPENSSL_ENGINES_DIR            5
+# define OPENSSL_VERSION_STRING         6
+# define OPENSSL_FULL_VERSION_STRING    7
+# define OPENSSL_MODULES_DIR            8
+# define OPENSSL_CPU_INFO               9
+
+const char *OPENSSL_info(int type);
+/*
+ * The series starts at 1001 to avoid confusion with the OpenSSL_version
+ * types.
+ */
+# define OPENSSL_INFO_CONFIG_DIR                1001
+# define OPENSSL_INFO_ENGINES_DIR               1002
+# define OPENSSL_INFO_MODULES_DIR               1003
+# define OPENSSL_INFO_DSO_EXTENSION             1004
+# define OPENSSL_INFO_DIR_FILENAME_SEPARATOR    1005
+# define OPENSSL_INFO_LIST_SEPARATOR            1006
+# define OPENSSL_INFO_SEED_SOURCE               1007
+# define OPENSSL_INFO_CPU_SETTINGS              1008
+
+int OPENSSL_issetugid(void);
+
+struct crypto_ex_data_st {
+    OSSL_LIB_CTX *ctx;
+    STACK_OF(void) *sk;
+};
+
+SKM_DEFINE_STACK_OF_INTERNAL(void, void, void)
+#define sk_void_num(sk) OPENSSL_sk_num(ossl_check_const_void_sk_type(sk))
+#define sk_void_value(sk, idx) ((void *)OPENSSL_sk_value(ossl_check_const_void_sk_type(sk), (idx)))
+#define sk_void_new(cmp) ((STACK_OF(void) *)OPENSSL_sk_new(ossl_check_void_compfunc_type(cmp)))
+#define sk_void_new_null() ((STACK_OF(void) *)OPENSSL_sk_new_null())
+#define sk_void_new_reserve(cmp, n) ((STACK_OF(void) *)OPENSSL_sk_new_reserve(ossl_check_void_compfunc_type(cmp), (n)))
+#define sk_void_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_void_sk_type(sk), (n))
+#define sk_void_free(sk) OPENSSL_sk_free(ossl_check_void_sk_type(sk))
+#define sk_void_zero(sk) OPENSSL_sk_zero(ossl_check_void_sk_type(sk))
+#define sk_void_delete(sk, i) ((void *)OPENSSL_sk_delete(ossl_check_void_sk_type(sk), (i)))
+#define sk_void_delete_ptr(sk, ptr) ((void *)OPENSSL_sk_delete_ptr(ossl_check_void_sk_type(sk), ossl_check_void_type(ptr)))
+#define sk_void_push(sk, ptr) OPENSSL_sk_push(ossl_check_void_sk_type(sk), ossl_check_void_type(ptr))
+#define sk_void_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_void_sk_type(sk), ossl_check_void_type(ptr))
+#define sk_void_pop(sk) ((void *)OPENSSL_sk_pop(ossl_check_void_sk_type(sk)))
+#define sk_void_shift(sk) ((void *)OPENSSL_sk_shift(ossl_check_void_sk_type(sk)))
+#define sk_void_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_void_sk_type(sk),ossl_check_void_freefunc_type(freefunc))
+#define sk_void_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_void_sk_type(sk), ossl_check_void_type(ptr), (idx))
+#define sk_void_set(sk, idx, ptr) ((void *)OPENSSL_sk_set(ossl_check_void_sk_type(sk), (idx), ossl_check_void_type(ptr)))
+#define sk_void_find(sk, ptr) OPENSSL_sk_find(ossl_check_void_sk_type(sk), ossl_check_void_type(ptr))
+#define sk_void_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_void_sk_type(sk), ossl_check_void_type(ptr))
+#define sk_void_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_void_sk_type(sk), ossl_check_void_type(ptr), pnum)
+#define sk_void_sort(sk) OPENSSL_sk_sort(ossl_check_void_sk_type(sk))
+#define sk_void_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_void_sk_type(sk))
+#define sk_void_dup(sk) ((STACK_OF(void) *)OPENSSL_sk_dup(ossl_check_const_void_sk_type(sk)))
+#define sk_void_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(void) *)OPENSSL_sk_deep_copy(ossl_check_const_void_sk_type(sk), ossl_check_void_copyfunc_type(copyfunc), ossl_check_void_freefunc_type(freefunc)))
+#define sk_void_set_cmp_func(sk, cmp) ((sk_void_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_void_sk_type(sk), ossl_check_void_compfunc_type(cmp)))
+
+
+
+/*
+ * Per class, we have a STACK of function pointers.
+ */
+# define CRYPTO_EX_INDEX_SSL              0
+# define CRYPTO_EX_INDEX_SSL_CTX          1
+# define CRYPTO_EX_INDEX_SSL_SESSION      2
+# define CRYPTO_EX_INDEX_X509             3
+# define CRYPTO_EX_INDEX_X509_STORE       4
+# define CRYPTO_EX_INDEX_X509_STORE_CTX   5
+# define CRYPTO_EX_INDEX_DH               6
+# define CRYPTO_EX_INDEX_DSA              7
+# define CRYPTO_EX_INDEX_EC_KEY           8
+# define CRYPTO_EX_INDEX_RSA              9
+# define CRYPTO_EX_INDEX_ENGINE          10
+# define CRYPTO_EX_INDEX_UI              11
+# define CRYPTO_EX_INDEX_BIO             12
+# define CRYPTO_EX_INDEX_APP             13
+# define CRYPTO_EX_INDEX_UI_METHOD       14
+# define CRYPTO_EX_INDEX_RAND_DRBG       15
+# define CRYPTO_EX_INDEX_DRBG            CRYPTO_EX_INDEX_RAND_DRBG
+# define CRYPTO_EX_INDEX_OSSL_LIB_CTX    16
+# define CRYPTO_EX_INDEX_EVP_PKEY        17
+# define CRYPTO_EX_INDEX__COUNT          18
+
+typedef void CRYPTO_EX_new (void *parent, void *ptr, CRYPTO_EX_DATA *ad,
+                           int idx, long argl, void *argp);
+typedef void CRYPTO_EX_free (void *parent, void *ptr, CRYPTO_EX_DATA *ad,
+                             int idx, long argl, void *argp);
+typedef int CRYPTO_EX_dup (CRYPTO_EX_DATA *to, const CRYPTO_EX_DATA *from,
+                           void **from_d, int idx, long argl, void *argp);
+__owur int CRYPTO_get_ex_new_index(int class_index, long argl, void *argp,
+                                   CRYPTO_EX_new *new_func,
+                                   CRYPTO_EX_dup *dup_func,
+                                   CRYPTO_EX_free *free_func);
+/* No longer use an index. */
+int CRYPTO_free_ex_index(int class_index, int idx);
+
+/*
+ * Initialise/duplicate/free CRYPTO_EX_DATA variables corresponding to a
+ * given class (invokes whatever per-class callbacks are applicable)
+ */
+int CRYPTO_new_ex_data(int class_index, void *obj, CRYPTO_EX_DATA *ad);
+int CRYPTO_dup_ex_data(int class_index, CRYPTO_EX_DATA *to,
+                       const CRYPTO_EX_DATA *from);
+
+void CRYPTO_free_ex_data(int class_index, void *obj, CRYPTO_EX_DATA *ad);
+
+/* Allocate a single item in the CRYPTO_EX_DATA variable */
+int CRYPTO_alloc_ex_data(int class_index, void *obj, CRYPTO_EX_DATA *ad,
+                         int idx);
+
+/*
+ * Get/set data in a CRYPTO_EX_DATA variable corresponding to a particular
+ * index (relative to the class type involved)
+ */
+int CRYPTO_set_ex_data(CRYPTO_EX_DATA *ad, int idx, void *val);
+void *CRYPTO_get_ex_data(const CRYPTO_EX_DATA *ad, int idx);
+
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+/*
+ * This function cleans up all "ex_data" state. It mustn't be called under
+ * potential race-conditions.
+ */
+# define CRYPTO_cleanup_all_ex_data() while(0) continue
+
+/*
+ * The old locking functions have been removed completely without compatibility
+ * macros. This is because the old functions either could not properly report
+ * errors, or the returned error values were not clearly documented.
+ * Replacing the locking functions with no-ops would cause race condition
+ * issues in the affected applications. It is far better for them to fail at
+ * compile time.
+ * On the other hand, the locking callbacks are no longer used.  Consequently,
+ * the callback management functions can be safely replaced with no-op macros.
+ */
+#  define CRYPTO_num_locks()            (1)
+#  define CRYPTO_set_locking_callback(func)
+#  define CRYPTO_get_locking_callback()         (NULL)
+#  define CRYPTO_set_add_lock_callback(func)
+#  define CRYPTO_get_add_lock_callback()        (NULL)
+
+/*
+ * These defines where used in combination with the old locking callbacks,
+ * they are not called anymore, but old code that's not called might still
+ * use them.
+ */
+#  define CRYPTO_LOCK             1
+#  define CRYPTO_UNLOCK           2
+#  define CRYPTO_READ             4
+#  define CRYPTO_WRITE            8
+
+/* This structure is no longer used */
+typedef struct crypto_threadid_st {
+    int dummy;
+} CRYPTO_THREADID;
+/* Only use CRYPTO_THREADID_set_[numeric|pointer]() within callbacks */
+#  define CRYPTO_THREADID_set_numeric(id, val)
+#  define CRYPTO_THREADID_set_pointer(id, ptr)
+#  define CRYPTO_THREADID_set_callback(threadid_func)   (0)
+#  define CRYPTO_THREADID_get_callback()                (NULL)
+#  define CRYPTO_THREADID_current(id)
+#  define CRYPTO_THREADID_cmp(a, b)                     (-1)
+#  define CRYPTO_THREADID_cpy(dest, src)
+#  define CRYPTO_THREADID_hash(id)                      (0UL)
+
+#  ifndef OPENSSL_NO_DEPRECATED_1_0_0
+#   define CRYPTO_set_id_callback(func)
+#   define CRYPTO_get_id_callback()                     (NULL)
+#   define CRYPTO_thread_id()                           (0UL)
+#  endif /* OPENSSL_NO_DEPRECATED_1_0_0 */
+
+#  define CRYPTO_set_dynlock_create_callback(dyn_create_function)
+#  define CRYPTO_set_dynlock_lock_callback(dyn_lock_function)
+#  define CRYPTO_set_dynlock_destroy_callback(dyn_destroy_function)
+#  define CRYPTO_get_dynlock_create_callback()          (NULL)
+#  define CRYPTO_get_dynlock_lock_callback()            (NULL)
+#  define CRYPTO_get_dynlock_destroy_callback()         (NULL)
+# endif /* OPENSSL_NO_DEPRECATED_1_1_0 */
+
+typedef void *(*CRYPTO_malloc_fn)(size_t num, const char *file, int line);
+typedef void *(*CRYPTO_realloc_fn)(void *addr, size_t num, const char *file,
+                                   int line);
+typedef void (*CRYPTO_free_fn)(void *addr, const char *file, int line);
+int CRYPTO_set_mem_functions(CRYPTO_malloc_fn malloc_fn,
+                             CRYPTO_realloc_fn realloc_fn,
+                             CRYPTO_free_fn free_fn);
+void CRYPTO_get_mem_functions(CRYPTO_malloc_fn *malloc_fn,
+                              CRYPTO_realloc_fn *realloc_fn,
+                              CRYPTO_free_fn *free_fn);
+
+OSSL_CRYPTO_ALLOC void *CRYPTO_malloc(size_t num, const char *file, int line);
+OSSL_CRYPTO_ALLOC void *CRYPTO_zalloc(size_t num, const char *file, int line);
+OSSL_CRYPTO_ALLOC void *CRYPTO_memdup(const void *str, size_t siz, const char *file, int line);
+OSSL_CRYPTO_ALLOC char *CRYPTO_strdup(const char *str, const char *file, int line);
+OSSL_CRYPTO_ALLOC char *CRYPTO_strndup(const char *str, size_t s, const char *file, int line);
+void CRYPTO_free(void *ptr, const char *file, int line);
+void CRYPTO_clear_free(void *ptr, size_t num, const char *file, int line);
+void *CRYPTO_realloc(void *addr, size_t num, const char *file, int line);
+void *CRYPTO_clear_realloc(void *addr, size_t old_num, size_t num,
+                           const char *file, int line);
+
+int CRYPTO_secure_malloc_init(size_t sz, size_t minsize);
+int CRYPTO_secure_malloc_done(void);
+OSSL_CRYPTO_ALLOC void *CRYPTO_secure_malloc(size_t num, const char *file, int line);
+OSSL_CRYPTO_ALLOC void *CRYPTO_secure_zalloc(size_t num, const char *file, int line);
+void CRYPTO_secure_free(void *ptr, const char *file, int line);
+void CRYPTO_secure_clear_free(void *ptr, size_t num,
+                              const char *file, int line);
+int CRYPTO_secure_allocated(const void *ptr);
+int CRYPTO_secure_malloc_initialized(void);
+size_t CRYPTO_secure_actual_size(void *ptr);
+size_t CRYPTO_secure_used(void);
+
+void OPENSSL_cleanse(void *ptr, size_t len);
+
+# ifndef OPENSSL_NO_CRYPTO_MDEBUG
+/*
+ * The following can be used to detect memory leaks in the library. If
+ * used, it turns on malloc checking
+ */
+# define CRYPTO_MEM_CHECK_OFF     0x0   /* Control only */
+# define CRYPTO_MEM_CHECK_ON      0x1   /* Control and mode bit */
+# define CRYPTO_MEM_CHECK_ENABLE  0x2   /* Control and mode bit */
+# define CRYPTO_MEM_CHECK_DISABLE 0x3   /* Control only */
+
+void CRYPTO_get_alloc_counts(int *mcount, int *rcount, int *fcount);
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+#    define OPENSSL_mem_debug_push(info) \
+         CRYPTO_mem_debug_push(info, OPENSSL_FILE, OPENSSL_LINE)
+#    define OPENSSL_mem_debug_pop() \
+         CRYPTO_mem_debug_pop()
+#  endif
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int CRYPTO_set_mem_debug(int flag);
+OSSL_DEPRECATEDIN_3_0 int CRYPTO_mem_ctrl(int mode);
+OSSL_DEPRECATEDIN_3_0 int CRYPTO_mem_debug_push(const char *info,
+                                                const char *file, int line);
+OSSL_DEPRECATEDIN_3_0 int CRYPTO_mem_debug_pop(void);
+OSSL_DEPRECATEDIN_3_0 void CRYPTO_mem_debug_malloc(void *addr, size_t num,
+                                                   int flag,
+                                                   const char *file, int line);
+OSSL_DEPRECATEDIN_3_0 void CRYPTO_mem_debug_realloc(void *addr1, void *addr2,
+                                                    size_t num, int flag,
+                                                    const char *file, int line);
+OSSL_DEPRECATEDIN_3_0 void CRYPTO_mem_debug_free(void *addr, int flag,
+                                                 const char *file, int line);
+OSSL_DEPRECATEDIN_3_0
+int CRYPTO_mem_leaks_cb(int (*cb)(const char *str, size_t len, void *u),
+                        void *u);
+#  endif
+#  ifndef OPENSSL_NO_STDIO
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int CRYPTO_mem_leaks_fp(FILE *);
+#  endif
+#  endif
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int CRYPTO_mem_leaks(BIO *bio);
+# endif
+# endif /* OPENSSL_NO_CRYPTO_MDEBUG */
+
+/* die if we have to */
+ossl_noreturn void OPENSSL_die(const char *assertion, const char *file, int line);
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#  define OpenSSLDie(f,l,a) OPENSSL_die((a),(f),(l))
+# endif
+# define OPENSSL_assert(e) \
+    (void)((e) ? 0 : (OPENSSL_die("assertion failed: " #e, OPENSSL_FILE, OPENSSL_LINE), 1))
+
+int OPENSSL_isservice(void);
+
+void OPENSSL_init(void);
+# ifdef OPENSSL_SYS_UNIX
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 void OPENSSL_fork_prepare(void);
+OSSL_DEPRECATEDIN_3_0 void OPENSSL_fork_parent(void);
+OSSL_DEPRECATEDIN_3_0 void OPENSSL_fork_child(void);
+#  endif
+# endif
+
+struct tm *OPENSSL_gmtime(const time_t *timer, struct tm *result);
+int OPENSSL_gmtime_adj(struct tm *tm, int offset_day, long offset_sec);
+int OPENSSL_gmtime_diff(int *pday, int *psec,
+                        const struct tm *from, const struct tm *to);
+
+/*
+ * CRYPTO_memcmp returns zero iff the |len| bytes at |a| and |b| are equal.
+ * It takes an amount of time dependent on |len|, but independent of the
+ * contents of |a| and |b|. Unlike memcmp, it cannot be used to put elements
+ * into a defined order as the return value when a != b is undefined, other
+ * than to be non-zero.
+ */
+int CRYPTO_memcmp(const void * in_a, const void * in_b, size_t len);
+
+/* Standard initialisation options */
+# define OPENSSL_INIT_NO_LOAD_CRYPTO_STRINGS 0x00000001L
+# define OPENSSL_INIT_LOAD_CRYPTO_STRINGS    0x00000002L
+# define OPENSSL_INIT_ADD_ALL_CIPHERS        0x00000004L
+# define OPENSSL_INIT_ADD_ALL_DIGESTS        0x00000008L
+# define OPENSSL_INIT_NO_ADD_ALL_CIPHERS     0x00000010L
+# define OPENSSL_INIT_NO_ADD_ALL_DIGESTS     0x00000020L
+# define OPENSSL_INIT_LOAD_CONFIG            0x00000040L
+# define OPENSSL_INIT_NO_LOAD_CONFIG         0x00000080L
+# define OPENSSL_INIT_ASYNC                  0x00000100L
+# define OPENSSL_INIT_ENGINE_RDRAND          0x00000200L
+# define OPENSSL_INIT_ENGINE_DYNAMIC         0x00000400L
+# define OPENSSL_INIT_ENGINE_OPENSSL         0x00000800L
+# define OPENSSL_INIT_ENGINE_CRYPTODEV       0x00001000L
+# define OPENSSL_INIT_ENGINE_CAPI            0x00002000L
+# define OPENSSL_INIT_ENGINE_PADLOCK         0x00004000L
+# define OPENSSL_INIT_ENGINE_AFALG           0x00008000L
+/* FREE:                                     0x00010000L */
+# define OPENSSL_INIT_ATFORK                 0x00020000L
+/* OPENSSL_INIT_BASE_ONLY                    0x00040000L */
+# define OPENSSL_INIT_NO_ATEXIT              0x00080000L
+/* OPENSSL_INIT flag range 0x03f00000 reserved for OPENSSL_init_ssl() */
+/* FREE: 0x04000000L */
+/* FREE: 0x08000000L */
+/* FREE: 0x10000000L */
+/* FREE: 0x20000000L */
+/* FREE: 0x40000000L */
+/* FREE: 0x80000000L */
+/* Max OPENSSL_INIT flag value is 0x80000000 */
+
+/* openssl and dasync not counted as builtin */
+# define OPENSSL_INIT_ENGINE_ALL_BUILTIN \
+    (OPENSSL_INIT_ENGINE_RDRAND | OPENSSL_INIT_ENGINE_DYNAMIC \
+    | OPENSSL_INIT_ENGINE_CRYPTODEV | OPENSSL_INIT_ENGINE_CAPI | \
+    OPENSSL_INIT_ENGINE_PADLOCK)
+
+/* Library initialisation functions */
+void OPENSSL_cleanup(void);
+int OPENSSL_init_crypto(uint64_t opts, const OPENSSL_INIT_SETTINGS *settings);
+int OPENSSL_atexit(void (*handler)(void));
+void OPENSSL_thread_stop(void);
+void OPENSSL_thread_stop_ex(OSSL_LIB_CTX *ctx);
+
+/* Low-level control of initialization */
+OPENSSL_INIT_SETTINGS *OPENSSL_INIT_new(void);
+# ifndef OPENSSL_NO_STDIO
+int OPENSSL_INIT_set_config_filename(OPENSSL_INIT_SETTINGS *settings,
+                                     const char *config_filename);
+void OPENSSL_INIT_set_config_file_flags(OPENSSL_INIT_SETTINGS *settings,
+                                        unsigned long flags);
+int OPENSSL_INIT_set_config_appname(OPENSSL_INIT_SETTINGS *settings,
+                                    const char *config_appname);
+# endif
+void OPENSSL_INIT_free(OPENSSL_INIT_SETTINGS *settings);
+
+# if defined(OPENSSL_THREADS) && !defined(CRYPTO_TDEBUG)
+#  if defined(_WIN32)
+#   if defined(BASETYPES) || defined(_WINDEF_H)
+/* application has to include <windows.h> in order to use this */
+typedef DWORD CRYPTO_THREAD_LOCAL;
+typedef DWORD CRYPTO_THREAD_ID;
+
+typedef LONG CRYPTO_ONCE;
+#    define CRYPTO_ONCE_STATIC_INIT 0
+#   endif
+#  else
+#   if defined(__TANDEM) && defined(_SPT_MODEL_)
+#    define  SPT_THREAD_SIGNAL 1
+#    define  SPT_THREAD_AWARE 1
+#    include <spthread.h>
+#   else
+#    include <pthread.h>
+#   endif
+typedef pthread_once_t CRYPTO_ONCE;
+typedef pthread_key_t CRYPTO_THREAD_LOCAL;
+typedef pthread_t CRYPTO_THREAD_ID;
+
+#   define CRYPTO_ONCE_STATIC_INIT PTHREAD_ONCE_INIT
+#  endif
+# endif
+
+# if !defined(CRYPTO_ONCE_STATIC_INIT)
+typedef unsigned int CRYPTO_ONCE;
+typedef unsigned int CRYPTO_THREAD_LOCAL;
+typedef unsigned int CRYPTO_THREAD_ID;
+#  define CRYPTO_ONCE_STATIC_INIT 0
+# endif
+
+int CRYPTO_THREAD_run_once(CRYPTO_ONCE *once, void (*init)(void));
+
+int CRYPTO_THREAD_init_local(CRYPTO_THREAD_LOCAL *key, void (*cleanup)(void *));
+void *CRYPTO_THREAD_get_local(CRYPTO_THREAD_LOCAL *key);
+int CRYPTO_THREAD_set_local(CRYPTO_THREAD_LOCAL *key, void *val);
+int CRYPTO_THREAD_cleanup_local(CRYPTO_THREAD_LOCAL *key);
+
+CRYPTO_THREAD_ID CRYPTO_THREAD_get_current_id(void);
+int CRYPTO_THREAD_compare_id(CRYPTO_THREAD_ID a, CRYPTO_THREAD_ID b);
+
+OSSL_LIB_CTX *OSSL_LIB_CTX_new(void);
+OSSL_LIB_CTX *OSSL_LIB_CTX_new_from_dispatch(const OSSL_CORE_HANDLE *handle,
+                                             const OSSL_DISPATCH *in);
+OSSL_LIB_CTX *OSSL_LIB_CTX_new_child(const OSSL_CORE_HANDLE *handle,
+                                     const OSSL_DISPATCH *in);
+int OSSL_LIB_CTX_load_config(OSSL_LIB_CTX *ctx, const char *config_file);
+void OSSL_LIB_CTX_free(OSSL_LIB_CTX *);
+OSSL_LIB_CTX *OSSL_LIB_CTX_get0_global_default(void);
+OSSL_LIB_CTX *OSSL_LIB_CTX_set0_default(OSSL_LIB_CTX *libctx);
+
+void OSSL_sleep(uint64_t millis);
+
+# ifdef  __cplusplus
+}
+# endif
+#endif
diff --git a/src/include/openssl/cryptoerr.h b/src/include/openssl/cryptoerr.h
new file mode 100644
index 0000000..e84b12d
--- /dev/null
+++ b/src/include/openssl/cryptoerr.h
@@ -0,0 +1,55 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2022 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_CRYPTOERR_H
+# define OPENSSL_CRYPTOERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+
+/*
+ * CRYPTO reason codes.
+ */
+# define CRYPTO_R_BAD_ALGORITHM_NAME                      117
+# define CRYPTO_R_CONFLICTING_NAMES                       118
+# define CRYPTO_R_HEX_STRING_TOO_SHORT                    121
+# define CRYPTO_R_ILLEGAL_HEX_DIGIT                       102
+# define CRYPTO_R_INSUFFICIENT_DATA_SPACE                 106
+# define CRYPTO_R_INSUFFICIENT_PARAM_SIZE                 107
+# define CRYPTO_R_INSUFFICIENT_SECURE_DATA_SPACE          108
+# define CRYPTO_R_INTEGER_OVERFLOW                        127
+# define CRYPTO_R_INVALID_NEGATIVE_VALUE                  122
+# define CRYPTO_R_INVALID_NULL_ARGUMENT                   109
+# define CRYPTO_R_INVALID_OSSL_PARAM_TYPE                 110
+# define CRYPTO_R_NO_PARAMS_TO_MERGE                      131
+# define CRYPTO_R_NO_SPACE_FOR_TERMINATING_NULL           128
+# define CRYPTO_R_ODD_NUMBER_OF_DIGITS                    103
+# define CRYPTO_R_PARAM_CANNOT_BE_REPRESENTED_EXACTLY     123
+# define CRYPTO_R_PARAM_NOT_INTEGER_TYPE                  124
+# define CRYPTO_R_PARAM_OF_INCOMPATIBLE_TYPE              129
+# define CRYPTO_R_PARAM_UNSIGNED_INTEGER_NEGATIVE_VALUE_UNSUPPORTED 125
+# define CRYPTO_R_PARAM_UNSUPPORTED_FLOATING_POINT_FORMAT 130
+# define CRYPTO_R_PARAM_VALUE_TOO_LARGE_FOR_DESTINATION   126
+# define CRYPTO_R_PROVIDER_ALREADY_EXISTS                 104
+# define CRYPTO_R_PROVIDER_SECTION_ERROR                  105
+# define CRYPTO_R_RANDOM_SECTION_ERROR                    119
+# define CRYPTO_R_SECURE_MALLOC_FAILURE                   111
+# define CRYPTO_R_STRING_TOO_LONG                         112
+# define CRYPTO_R_TOO_MANY_BYTES                          113
+# define CRYPTO_R_TOO_MANY_RECORDS                        114
+# define CRYPTO_R_TOO_SMALL_BUFFER                        116
+# define CRYPTO_R_UNKNOWN_NAME_IN_RANDOM_SECTION          120
+# define CRYPTO_R_ZERO_LENGTH_NUMBER                      115
+
+#endif
diff --git a/src/include/openssl/cryptoerr_legacy.h b/src/include/openssl/cryptoerr_legacy.h
new file mode 100644
index 0000000..ccab33a
--- /dev/null
+++ b/src/include/openssl/cryptoerr_legacy.h
@@ -0,0 +1,1466 @@
+/*
+ * Copyright 2020-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+/*
+ * This header file preserves symbols from pre-3.0 OpenSSL.
+ * It should never be included directly, as it's already included
+ * by the public {lib}err.h headers, and since it will go away some
+ * time in the future.
+ */
+
+#ifndef OPENSSL_CRYPTOERR_LEGACY_H
+# define OPENSSL_CRYPTOERR_LEGACY_H
+# pragma once
+
+# include <openssl/macros.h>
+# include <openssl/symhacks.h>
+
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int ERR_load_ASN1_strings(void);
+OSSL_DEPRECATEDIN_3_0 int ERR_load_ASYNC_strings(void);
+OSSL_DEPRECATEDIN_3_0 int ERR_load_BIO_strings(void);
+OSSL_DEPRECATEDIN_3_0 int ERR_load_BN_strings(void);
+OSSL_DEPRECATEDIN_3_0 int ERR_load_BUF_strings(void);
+#  ifndef OPENSSL_NO_CMS
+OSSL_DEPRECATEDIN_3_0 int ERR_load_CMS_strings(void);
+#  endif
+#  ifndef OPENSSL_NO_COMP
+OSSL_DEPRECATEDIN_3_0 int ERR_load_COMP_strings(void);
+#  endif
+OSSL_DEPRECATEDIN_3_0 int ERR_load_CONF_strings(void);
+OSSL_DEPRECATEDIN_3_0 int ERR_load_CRYPTO_strings(void);
+#  ifndef OPENSSL_NO_CT
+OSSL_DEPRECATEDIN_3_0 int ERR_load_CT_strings(void);
+#  endif
+#  ifndef OPENSSL_NO_DH
+OSSL_DEPRECATEDIN_3_0 int ERR_load_DH_strings(void);
+#  endif
+#  ifndef OPENSSL_NO_DSA
+OSSL_DEPRECATEDIN_3_0 int ERR_load_DSA_strings(void);
+#  endif
+#  ifndef OPENSSL_NO_EC
+OSSL_DEPRECATEDIN_3_0 int ERR_load_EC_strings(void);
+#  endif
+#  ifndef OPENSSL_NO_ENGINE
+OSSL_DEPRECATEDIN_3_0 int ERR_load_ENGINE_strings(void);
+#  endif
+OSSL_DEPRECATEDIN_3_0 int ERR_load_ERR_strings(void);
+OSSL_DEPRECATEDIN_3_0 int ERR_load_EVP_strings(void);
+OSSL_DEPRECATEDIN_3_0 int ERR_load_KDF_strings(void);
+OSSL_DEPRECATEDIN_3_0 int ERR_load_OBJ_strings(void);
+#  ifndef OPENSSL_NO_OCSP
+OSSL_DEPRECATEDIN_3_0 int ERR_load_OCSP_strings(void);
+#  endif
+OSSL_DEPRECATEDIN_3_0 int ERR_load_PEM_strings(void);
+OSSL_DEPRECATEDIN_3_0 int ERR_load_PKCS12_strings(void);
+OSSL_DEPRECATEDIN_3_0 int ERR_load_PKCS7_strings(void);
+OSSL_DEPRECATEDIN_3_0 int ERR_load_RAND_strings(void);
+OSSL_DEPRECATEDIN_3_0 int ERR_load_RSA_strings(void);
+OSSL_DEPRECATEDIN_3_0 int ERR_load_OSSL_STORE_strings(void);
+#  ifndef OPENSSL_NO_TS
+OSSL_DEPRECATEDIN_3_0 int ERR_load_TS_strings(void);
+#  endif
+OSSL_DEPRECATEDIN_3_0 int ERR_load_UI_strings(void);
+OSSL_DEPRECATEDIN_3_0 int ERR_load_X509_strings(void);
+OSSL_DEPRECATEDIN_3_0 int ERR_load_X509V3_strings(void);
+
+/* Collected _F_ macros from OpenSSL 1.1.1 */
+
+/*
+ * ASN1 function codes.
+ */
+#  define ASN1_F_A2D_ASN1_OBJECT                           0
+#  define ASN1_F_A2I_ASN1_INTEGER                          0
+#  define ASN1_F_A2I_ASN1_STRING                           0
+#  define ASN1_F_APPEND_EXP                                0
+#  define ASN1_F_ASN1_BIO_INIT                             0
+#  define ASN1_F_ASN1_BIT_STRING_SET_BIT                   0
+#  define ASN1_F_ASN1_CB                                   0
+#  define ASN1_F_ASN1_CHECK_TLEN                           0
+#  define ASN1_F_ASN1_COLLECT                              0
+#  define ASN1_F_ASN1_D2I_EX_PRIMITIVE                     0
+#  define ASN1_F_ASN1_D2I_FP                               0
+#  define ASN1_F_ASN1_D2I_READ_BIO                         0
+#  define ASN1_F_ASN1_DIGEST                               0
+#  define ASN1_F_ASN1_DO_ADB                               0
+#  define ASN1_F_ASN1_DO_LOCK                              0
+#  define ASN1_F_ASN1_DUP                                  0
+#  define ASN1_F_ASN1_ENC_SAVE                             0
+#  define ASN1_F_ASN1_EX_C2I                               0
+#  define ASN1_F_ASN1_FIND_END                             0
+#  define ASN1_F_ASN1_GENERALIZEDTIME_ADJ                  0
+#  define ASN1_F_ASN1_GENERATE_V3                          0
+#  define ASN1_F_ASN1_GET_INT64                            0
+#  define ASN1_F_ASN1_GET_OBJECT                           0
+#  define ASN1_F_ASN1_GET_UINT64                           0
+#  define ASN1_F_ASN1_I2D_BIO                              0
+#  define ASN1_F_ASN1_I2D_FP                               0
+#  define ASN1_F_ASN1_ITEM_D2I_FP                          0
+#  define ASN1_F_ASN1_ITEM_DUP                             0
+#  define ASN1_F_ASN1_ITEM_EMBED_D2I                       0
+#  define ASN1_F_ASN1_ITEM_EMBED_NEW                       0
+#  define ASN1_F_ASN1_ITEM_FLAGS_I2D                       0
+#  define ASN1_F_ASN1_ITEM_I2D_BIO                         0
+#  define ASN1_F_ASN1_ITEM_I2D_FP                          0
+#  define ASN1_F_ASN1_ITEM_PACK                            0
+#  define ASN1_F_ASN1_ITEM_SIGN                            0
+#  define ASN1_F_ASN1_ITEM_SIGN_CTX                        0
+#  define ASN1_F_ASN1_ITEM_UNPACK                          0
+#  define ASN1_F_ASN1_ITEM_VERIFY                          0
+#  define ASN1_F_ASN1_MBSTRING_NCOPY                       0
+#  define ASN1_F_ASN1_OBJECT_NEW                           0
+#  define ASN1_F_ASN1_OUTPUT_DATA                          0
+#  define ASN1_F_ASN1_PCTX_NEW                             0
+#  define ASN1_F_ASN1_PRIMITIVE_NEW                        0
+#  define ASN1_F_ASN1_SCTX_NEW                             0
+#  define ASN1_F_ASN1_SIGN                                 0
+#  define ASN1_F_ASN1_STR2TYPE                             0
+#  define ASN1_F_ASN1_STRING_GET_INT64                     0
+#  define ASN1_F_ASN1_STRING_GET_UINT64                    0
+#  define ASN1_F_ASN1_STRING_SET                           0
+#  define ASN1_F_ASN1_STRING_TABLE_ADD                     0
+#  define ASN1_F_ASN1_STRING_TO_BN                         0
+#  define ASN1_F_ASN1_STRING_TYPE_NEW                      0
+#  define ASN1_F_ASN1_TEMPLATE_EX_D2I                      0
+#  define ASN1_F_ASN1_TEMPLATE_NEW                         0
+#  define ASN1_F_ASN1_TEMPLATE_NOEXP_D2I                   0
+#  define ASN1_F_ASN1_TIME_ADJ                             0
+#  define ASN1_F_ASN1_TYPE_GET_INT_OCTETSTRING             0
+#  define ASN1_F_ASN1_TYPE_GET_OCTETSTRING                 0
+#  define ASN1_F_ASN1_UTCTIME_ADJ                          0
+#  define ASN1_F_ASN1_VERIFY                               0
+#  define ASN1_F_B64_READ_ASN1                             0
+#  define ASN1_F_B64_WRITE_ASN1                            0
+#  define ASN1_F_BIO_NEW_NDEF                              0
+#  define ASN1_F_BITSTR_CB                                 0
+#  define ASN1_F_BN_TO_ASN1_STRING                         0
+#  define ASN1_F_C2I_ASN1_BIT_STRING                       0
+#  define ASN1_F_C2I_ASN1_INTEGER                          0
+#  define ASN1_F_C2I_ASN1_OBJECT                           0
+#  define ASN1_F_C2I_IBUF                                  0
+#  define ASN1_F_C2I_UINT64_INT                            0
+#  define ASN1_F_COLLECT_DATA                              0
+#  define ASN1_F_D2I_ASN1_OBJECT                           0
+#  define ASN1_F_D2I_ASN1_UINTEGER                         0
+#  define ASN1_F_D2I_AUTOPRIVATEKEY                        0
+#  define ASN1_F_D2I_PRIVATEKEY                            0
+#  define ASN1_F_D2I_PUBLICKEY                             0
+#  define ASN1_F_DO_BUF                                    0
+#  define ASN1_F_DO_CREATE                                 0
+#  define ASN1_F_DO_DUMP                                   0
+#  define ASN1_F_DO_TCREATE                                0
+#  define ASN1_F_I2A_ASN1_OBJECT                           0
+#  define ASN1_F_I2D_ASN1_BIO_STREAM                       0
+#  define ASN1_F_I2D_ASN1_OBJECT                           0
+#  define ASN1_F_I2D_DSA_PUBKEY                            0
+#  define ASN1_F_I2D_EC_PUBKEY                             0
+#  define ASN1_F_I2D_PRIVATEKEY                            0
+#  define ASN1_F_I2D_PUBLICKEY                             0
+#  define ASN1_F_I2D_RSA_PUBKEY                            0
+#  define ASN1_F_LONG_C2I                                  0
+#  define ASN1_F_NDEF_PREFIX                               0
+#  define ASN1_F_NDEF_SUFFIX                               0
+#  define ASN1_F_OID_MODULE_INIT                           0
+#  define ASN1_F_PARSE_TAGGING                             0
+#  define ASN1_F_PKCS5_PBE2_SET_IV                         0
+#  define ASN1_F_PKCS5_PBE2_SET_SCRYPT                     0
+#  define ASN1_F_PKCS5_PBE_SET                             0
+#  define ASN1_F_PKCS5_PBE_SET0_ALGOR                      0
+#  define ASN1_F_PKCS5_PBKDF2_SET                          0
+#  define ASN1_F_PKCS5_SCRYPT_SET                          0
+#  define ASN1_F_SMIME_READ_ASN1                           0
+#  define ASN1_F_SMIME_TEXT                                0
+#  define ASN1_F_STABLE_GET                                0
+#  define ASN1_F_STBL_MODULE_INIT                          0
+#  define ASN1_F_UINT32_C2I                                0
+#  define ASN1_F_UINT32_NEW                                0
+#  define ASN1_F_UINT64_C2I                                0
+#  define ASN1_F_UINT64_NEW                                0
+#  define ASN1_F_X509_CRL_ADD0_REVOKED                     0
+#  define ASN1_F_X509_INFO_NEW                             0
+#  define ASN1_F_X509_NAME_ENCODE                          0
+#  define ASN1_F_X509_NAME_EX_D2I                          0
+#  define ASN1_F_X509_NAME_EX_NEW                          0
+#  define ASN1_F_X509_PKEY_NEW                             0
+
+/*
+ * ASYNC function codes.
+ */
+#  define ASYNC_F_ASYNC_CTX_NEW                            0
+#  define ASYNC_F_ASYNC_INIT_THREAD                        0
+#  define ASYNC_F_ASYNC_JOB_NEW                            0
+#  define ASYNC_F_ASYNC_PAUSE_JOB                          0
+#  define ASYNC_F_ASYNC_START_FUNC                         0
+#  define ASYNC_F_ASYNC_START_JOB                          0
+#  define ASYNC_F_ASYNC_WAIT_CTX_SET_WAIT_FD               0
+
+/*
+ * BIO function codes.
+ */
+#  define BIO_F_ACPT_STATE                                 0
+#  define BIO_F_ADDRINFO_WRAP                              0
+#  define BIO_F_ADDR_STRINGS                               0
+#  define BIO_F_BIO_ACCEPT                                 0
+#  define BIO_F_BIO_ACCEPT_EX                              0
+#  define BIO_F_BIO_ACCEPT_NEW                             0
+#  define BIO_F_BIO_ADDR_NEW                               0
+#  define BIO_F_BIO_BIND                                   0
+#  define BIO_F_BIO_CALLBACK_CTRL                          0
+#  define BIO_F_BIO_CONNECT                                0
+#  define BIO_F_BIO_CONNECT_NEW                            0
+#  define BIO_F_BIO_CTRL                                   0
+#  define BIO_F_BIO_GETS                                   0
+#  define BIO_F_BIO_GET_HOST_IP                            0
+#  define BIO_F_BIO_GET_NEW_INDEX                          0
+#  define BIO_F_BIO_GET_PORT                               0
+#  define BIO_F_BIO_LISTEN                                 0
+#  define BIO_F_BIO_LOOKUP                                 0
+#  define BIO_F_BIO_LOOKUP_EX                              0
+#  define BIO_F_BIO_MAKE_PAIR                              0
+#  define BIO_F_BIO_METH_NEW                               0
+#  define BIO_F_BIO_NEW                                    0
+#  define BIO_F_BIO_NEW_DGRAM_SCTP                         0
+#  define BIO_F_BIO_NEW_FILE                               0
+#  define BIO_F_BIO_NEW_MEM_BUF                            0
+#  define BIO_F_BIO_NREAD                                  0
+#  define BIO_F_BIO_NREAD0                                 0
+#  define BIO_F_BIO_NWRITE                                 0
+#  define BIO_F_BIO_NWRITE0                                0
+#  define BIO_F_BIO_PARSE_HOSTSERV                         0
+#  define BIO_F_BIO_PUTS                                   0
+#  define BIO_F_BIO_READ                                   0
+#  define BIO_F_BIO_READ_EX                                0
+#  define BIO_F_BIO_READ_INTERN                            0
+#  define BIO_F_BIO_SOCKET                                 0
+#  define BIO_F_BIO_SOCKET_NBIO                            0
+#  define BIO_F_BIO_SOCK_INFO                              0
+#  define BIO_F_BIO_SOCK_INIT                              0
+#  define BIO_F_BIO_WRITE                                  0
+#  define BIO_F_BIO_WRITE_EX                               0
+#  define BIO_F_BIO_WRITE_INTERN                           0
+#  define BIO_F_BUFFER_CTRL                                0
+#  define BIO_F_CONN_CTRL                                  0
+#  define BIO_F_CONN_STATE                                 0
+#  define BIO_F_DGRAM_SCTP_NEW                             0
+#  define BIO_F_DGRAM_SCTP_READ                            0
+#  define BIO_F_DGRAM_SCTP_WRITE                           0
+#  define BIO_F_DOAPR_OUTCH                                0
+#  define BIO_F_FILE_CTRL                                  0
+#  define BIO_F_FILE_READ                                  0
+#  define BIO_F_LINEBUFFER_CTRL                            0
+#  define BIO_F_LINEBUFFER_NEW                             0
+#  define BIO_F_MEM_WRITE                                  0
+#  define BIO_F_NBIOF_NEW                                  0
+#  define BIO_F_SLG_WRITE                                  0
+#  define BIO_F_SSL_NEW                                    0
+
+/*
+ * BN function codes.
+ */
+#  define BN_F_BNRAND                                      0
+#  define BN_F_BNRAND_RANGE                                0
+#  define BN_F_BN_BLINDING_CONVERT_EX                      0
+#  define BN_F_BN_BLINDING_CREATE_PARAM                    0
+#  define BN_F_BN_BLINDING_INVERT_EX                       0
+#  define BN_F_BN_BLINDING_NEW                             0
+#  define BN_F_BN_BLINDING_UPDATE                          0
+#  define BN_F_BN_BN2DEC                                   0
+#  define BN_F_BN_BN2HEX                                   0
+#  define BN_F_BN_COMPUTE_WNAF                             0
+#  define BN_F_BN_CTX_GET                                  0
+#  define BN_F_BN_CTX_NEW                                  0
+#  define BN_F_BN_CTX_START                                0
+#  define BN_F_BN_DIV                                      0
+#  define BN_F_BN_DIV_RECP                                 0
+#  define BN_F_BN_EXP                                      0
+#  define BN_F_BN_EXPAND_INTERNAL                          0
+#  define BN_F_BN_GENCB_NEW                                0
+#  define BN_F_BN_GENERATE_DSA_NONCE                       0
+#  define BN_F_BN_GENERATE_PRIME_EX                        0
+#  define BN_F_BN_GF2M_MOD                                 0
+#  define BN_F_BN_GF2M_MOD_EXP                             0
+#  define BN_F_BN_GF2M_MOD_MUL                             0
+#  define BN_F_BN_GF2M_MOD_SOLVE_QUAD                      0
+#  define BN_F_BN_GF2M_MOD_SOLVE_QUAD_ARR                  0
+#  define BN_F_BN_GF2M_MOD_SQR                             0
+#  define BN_F_BN_GF2M_MOD_SQRT                            0
+#  define BN_F_BN_LSHIFT                                   0
+#  define BN_F_BN_MOD_EXP2_MONT                            0
+#  define BN_F_BN_MOD_EXP_MONT                             0
+#  define BN_F_BN_MOD_EXP_MONT_CONSTTIME                   0
+#  define BN_F_BN_MOD_EXP_MONT_WORD                        0
+#  define BN_F_BN_MOD_EXP_RECP                             0
+#  define BN_F_BN_MOD_EXP_SIMPLE                           0
+#  define BN_F_BN_MOD_INVERSE                              0
+#  define BN_F_BN_MOD_INVERSE_NO_BRANCH                    0
+#  define BN_F_BN_MOD_LSHIFT_QUICK                         0
+#  define BN_F_BN_MOD_SQRT                                 0
+#  define BN_F_BN_MONT_CTX_NEW                             0
+#  define BN_F_BN_MPI2BN                                   0
+#  define BN_F_BN_NEW                                      0
+#  define BN_F_BN_POOL_GET                                 0
+#  define BN_F_BN_RAND                                     0
+#  define BN_F_BN_RAND_RANGE                               0
+#  define BN_F_BN_RECP_CTX_NEW                             0
+#  define BN_F_BN_RSHIFT                                   0
+#  define BN_F_BN_SET_WORDS                                0
+#  define BN_F_BN_STACK_PUSH                               0
+#  define BN_F_BN_USUB                                     0
+
+/*
+ * BUF function codes.
+ */
+#  define BUF_F_BUF_MEM_GROW                               0
+#  define BUF_F_BUF_MEM_GROW_CLEAN                         0
+#  define BUF_F_BUF_MEM_NEW                                0
+
+#  ifndef OPENSSL_NO_CMS
+/*
+ * CMS function codes.
+ */
+#   define CMS_F_CHECK_CONTENT                              0
+#   define CMS_F_CMS_ADD0_CERT                              0
+#   define CMS_F_CMS_ADD0_RECIPIENT_KEY                     0
+#   define CMS_F_CMS_ADD0_RECIPIENT_PASSWORD                0
+#   define CMS_F_CMS_ADD1_RECEIPTREQUEST                    0
+#   define CMS_F_CMS_ADD1_RECIPIENT_CERT                    0
+#   define CMS_F_CMS_ADD1_SIGNER                            0
+#   define CMS_F_CMS_ADD1_SIGNINGTIME                       0
+#   define CMS_F_CMS_COMPRESS                               0
+#   define CMS_F_CMS_COMPRESSEDDATA_CREATE                  0
+#   define CMS_F_CMS_COMPRESSEDDATA_INIT_BIO                0
+#   define CMS_F_CMS_COPY_CONTENT                           0
+#   define CMS_F_CMS_COPY_MESSAGEDIGEST                     0
+#   define CMS_F_CMS_DATA                                   0
+#   define CMS_F_CMS_DATAFINAL                              0
+#   define CMS_F_CMS_DATAINIT                               0
+#   define CMS_F_CMS_DECRYPT                                0
+#   define CMS_F_CMS_DECRYPT_SET1_KEY                       0
+#   define CMS_F_CMS_DECRYPT_SET1_PASSWORD                  0
+#   define CMS_F_CMS_DECRYPT_SET1_PKEY                      0
+#   define CMS_F_CMS_DIGESTALGORITHM_FIND_CTX               0
+#   define CMS_F_CMS_DIGESTALGORITHM_INIT_BIO               0
+#   define CMS_F_CMS_DIGESTEDDATA_DO_FINAL                  0
+#   define CMS_F_CMS_DIGEST_VERIFY                          0
+#   define CMS_F_CMS_ENCODE_RECEIPT                         0
+#   define CMS_F_CMS_ENCRYPT                                0
+#   define CMS_F_CMS_ENCRYPTEDCONTENT_INIT                  0
+#   define CMS_F_CMS_ENCRYPTEDCONTENT_INIT_BIO              0
+#   define CMS_F_CMS_ENCRYPTEDDATA_DECRYPT                  0
+#   define CMS_F_CMS_ENCRYPTEDDATA_ENCRYPT                  0
+#   define CMS_F_CMS_ENCRYPTEDDATA_SET1_KEY                 0
+#   define CMS_F_CMS_ENVELOPEDDATA_CREATE                   0
+#   define CMS_F_CMS_ENVELOPEDDATA_INIT_BIO                 0
+#   define CMS_F_CMS_ENVELOPED_DATA_INIT                    0
+#   define CMS_F_CMS_ENV_ASN1_CTRL                          0
+#   define CMS_F_CMS_FINAL                                  0
+#   define CMS_F_CMS_GET0_CERTIFICATE_CHOICES               0
+#   define CMS_F_CMS_GET0_CONTENT                           0
+#   define CMS_F_CMS_GET0_ECONTENT_TYPE                     0
+#   define CMS_F_CMS_GET0_ENVELOPED                         0
+#   define CMS_F_CMS_GET0_REVOCATION_CHOICES                0
+#   define CMS_F_CMS_GET0_SIGNED                            0
+#   define CMS_F_CMS_MSGSIGDIGEST_ADD1                      0
+#   define CMS_F_CMS_RECEIPTREQUEST_CREATE0                 0
+#   define CMS_F_CMS_RECEIPT_VERIFY                         0
+#   define CMS_F_CMS_RECIPIENTINFO_DECRYPT                  0
+#   define CMS_F_CMS_RECIPIENTINFO_ENCRYPT                  0
+#   define CMS_F_CMS_RECIPIENTINFO_KARI_ENCRYPT             0
+#   define CMS_F_CMS_RECIPIENTINFO_KARI_GET0_ALG            0
+#   define CMS_F_CMS_RECIPIENTINFO_KARI_GET0_ORIG_ID        0
+#   define CMS_F_CMS_RECIPIENTINFO_KARI_GET0_REKS           0
+#   define CMS_F_CMS_RECIPIENTINFO_KARI_ORIG_ID_CMP         0
+#   define CMS_F_CMS_RECIPIENTINFO_KEKRI_DECRYPT            0
+#   define CMS_F_CMS_RECIPIENTINFO_KEKRI_ENCRYPT            0
+#   define CMS_F_CMS_RECIPIENTINFO_KEKRI_GET0_ID            0
+#   define CMS_F_CMS_RECIPIENTINFO_KEKRI_ID_CMP             0
+#   define CMS_F_CMS_RECIPIENTINFO_KTRI_CERT_CMP            0
+#   define CMS_F_CMS_RECIPIENTINFO_KTRI_DECRYPT             0
+#   define CMS_F_CMS_RECIPIENTINFO_KTRI_ENCRYPT             0
+#   define CMS_F_CMS_RECIPIENTINFO_KTRI_GET0_ALGS           0
+#   define CMS_F_CMS_RECIPIENTINFO_KTRI_GET0_SIGNER_ID      0
+#   define CMS_F_CMS_RECIPIENTINFO_PWRI_CRYPT               0
+#   define CMS_F_CMS_RECIPIENTINFO_SET0_KEY                 0
+#   define CMS_F_CMS_RECIPIENTINFO_SET0_PASSWORD            0
+#   define CMS_F_CMS_RECIPIENTINFO_SET0_PKEY                0
+#   define CMS_F_CMS_SD_ASN1_CTRL                           0
+#   define CMS_F_CMS_SET1_IAS                               0
+#   define CMS_F_CMS_SET1_KEYID                             0
+#   define CMS_F_CMS_SET1_SIGNERIDENTIFIER                  0
+#   define CMS_F_CMS_SET_DETACHED                           0
+#   define CMS_F_CMS_SIGN                                   0
+#   define CMS_F_CMS_SIGNED_DATA_INIT                       0
+#   define CMS_F_CMS_SIGNERINFO_CONTENT_SIGN                0
+#   define CMS_F_CMS_SIGNERINFO_SIGN                        0
+#   define CMS_F_CMS_SIGNERINFO_VERIFY                      0
+#   define CMS_F_CMS_SIGNERINFO_VERIFY_CERT                 0
+#   define CMS_F_CMS_SIGNERINFO_VERIFY_CONTENT              0
+#   define CMS_F_CMS_SIGN_RECEIPT                           0
+#   define CMS_F_CMS_SI_CHECK_ATTRIBUTES                    0
+#   define CMS_F_CMS_STREAM                                 0
+#   define CMS_F_CMS_UNCOMPRESS                             0
+#   define CMS_F_CMS_VERIFY                                 0
+#   define CMS_F_KEK_UNWRAP_KEY                             0
+#  endif
+
+#  ifndef OPENSSL_NO_COMP
+/*
+ * COMP function codes.
+ */
+#   define COMP_F_BIO_ZLIB_FLUSH                            0
+#   define COMP_F_BIO_ZLIB_NEW                              0
+#   define COMP_F_BIO_ZLIB_READ                             0
+#   define COMP_F_BIO_ZLIB_WRITE                            0
+#   define COMP_F_COMP_CTX_NEW                              0
+#  endif
+
+/*
+ * CONF function codes.
+ */
+#  define CONF_F_CONF_DUMP_FP                              0
+#  define CONF_F_CONF_LOAD                                 0
+#  define CONF_F_CONF_LOAD_FP                              0
+#  define CONF_F_CONF_PARSE_LIST                           0
+#  define CONF_F_DEF_LOAD                                  0
+#  define CONF_F_DEF_LOAD_BIO                              0
+#  define CONF_F_GET_NEXT_FILE                             0
+#  define CONF_F_MODULE_ADD                                0
+#  define CONF_F_MODULE_INIT                               0
+#  define CONF_F_MODULE_LOAD_DSO                           0
+#  define CONF_F_MODULE_RUN                                0
+#  define CONF_F_NCONF_DUMP_BIO                            0
+#  define CONF_F_NCONF_DUMP_FP                             0
+#  define CONF_F_NCONF_GET_NUMBER_E                        0
+#  define CONF_F_NCONF_GET_SECTION                         0
+#  define CONF_F_NCONF_GET_STRING                          0
+#  define CONF_F_NCONF_LOAD                                0
+#  define CONF_F_NCONF_LOAD_BIO                            0
+#  define CONF_F_NCONF_LOAD_FP                             0
+#  define CONF_F_NCONF_NEW                                 0
+#  define CONF_F_PROCESS_INCLUDE                           0
+#  define CONF_F_SSL_MODULE_INIT                           0
+#  define CONF_F_STR_COPY                                  0
+
+/*
+ * CRYPTO function codes.
+ */
+#  define CRYPTO_F_CMAC_CTX_NEW                            0
+#  define CRYPTO_F_CRYPTO_DUP_EX_DATA                      0
+#  define CRYPTO_F_CRYPTO_FREE_EX_DATA                     0
+#  define CRYPTO_F_CRYPTO_GET_EX_NEW_INDEX                 0
+#  define CRYPTO_F_CRYPTO_MEMDUP                           0
+#  define CRYPTO_F_CRYPTO_NEW_EX_DATA                      0
+#  define CRYPTO_F_CRYPTO_OCB128_COPY_CTX                  0
+#  define CRYPTO_F_CRYPTO_OCB128_INIT                      0
+#  define CRYPTO_F_CRYPTO_SET_EX_DATA                      0
+#  define CRYPTO_F_GET_AND_LOCK                            0
+#  define CRYPTO_F_OPENSSL_ATEXIT                          0
+#  define CRYPTO_F_OPENSSL_BUF2HEXSTR                      0
+#  define CRYPTO_F_OPENSSL_FOPEN                           0
+#  define CRYPTO_F_OPENSSL_HEXSTR2BUF                      0
+#  define CRYPTO_F_OPENSSL_INIT_CRYPTO                     0
+#  define CRYPTO_F_OPENSSL_LH_NEW                          0
+#  define CRYPTO_F_OPENSSL_SK_DEEP_COPY                    0
+#  define CRYPTO_F_OPENSSL_SK_DUP                          0
+#  define CRYPTO_F_PKEY_HMAC_INIT                          0
+#  define CRYPTO_F_PKEY_POLY1305_INIT                      0
+#  define CRYPTO_F_PKEY_SIPHASH_INIT                       0
+#  define CRYPTO_F_SK_RESERVE                              0
+
+#  ifndef OPENSSL_NO_CT
+/*
+ * CT function codes.
+ */
+#   define CT_F_CTLOG_NEW                                   0
+#   define CT_F_CTLOG_NEW_FROM_BASE64                       0
+#   define CT_F_CTLOG_NEW_FROM_CONF                         0
+#   define CT_F_CTLOG_STORE_LOAD_CTX_NEW                    0
+#   define CT_F_CTLOG_STORE_LOAD_FILE                       0
+#   define CT_F_CTLOG_STORE_LOAD_LOG                        0
+#   define CT_F_CTLOG_STORE_NEW                             0
+#   define CT_F_CT_BASE64_DECODE                            0
+#   define CT_F_CT_POLICY_EVAL_CTX_NEW                      0
+#   define CT_F_CT_V1_LOG_ID_FROM_PKEY                      0
+#   define CT_F_I2O_SCT                                     0
+#   define CT_F_I2O_SCT_LIST                                0
+#   define CT_F_I2O_SCT_SIGNATURE                           0
+#   define CT_F_O2I_SCT                                     0
+#   define CT_F_O2I_SCT_LIST                                0
+#   define CT_F_O2I_SCT_SIGNATURE                           0
+#   define CT_F_SCT_CTX_NEW                                 0
+#   define CT_F_SCT_CTX_VERIFY                              0
+#   define CT_F_SCT_NEW                                     0
+#   define CT_F_SCT_NEW_FROM_BASE64                         0
+#   define CT_F_SCT_SET0_LOG_ID                             0
+#   define CT_F_SCT_SET1_EXTENSIONS                         0
+#   define CT_F_SCT_SET1_LOG_ID                             0
+#   define CT_F_SCT_SET1_SIGNATURE                          0
+#   define CT_F_SCT_SET_LOG_ENTRY_TYPE                      0
+#   define CT_F_SCT_SET_SIGNATURE_NID                       0
+#   define CT_F_SCT_SET_VERSION                             0
+#  endif
+
+#  ifndef OPENSSL_NO_DH
+/*
+ * DH function codes.
+ */
+#   define DH_F_COMPUTE_KEY                                 0
+#   define DH_F_DHPARAMS_PRINT_FP                           0
+#   define DH_F_DH_BUILTIN_GENPARAMS                        0
+#   define DH_F_DH_CHECK_EX                                 0
+#   define DH_F_DH_CHECK_PARAMS_EX                          0
+#   define DH_F_DH_CHECK_PUB_KEY_EX                         0
+#   define DH_F_DH_CMS_DECRYPT                              0
+#   define DH_F_DH_CMS_SET_PEERKEY                          0
+#   define DH_F_DH_CMS_SET_SHARED_INFO                      0
+#   define DH_F_DH_METH_DUP                                 0
+#   define DH_F_DH_METH_NEW                                 0
+#   define DH_F_DH_METH_SET1_NAME                           0
+#   define DH_F_DH_NEW_BY_NID                               0
+#   define DH_F_DH_NEW_METHOD                               0
+#   define DH_F_DH_PARAM_DECODE                             0
+#   define DH_F_DH_PKEY_PUBLIC_CHECK                        0
+#   define DH_F_DH_PRIV_DECODE                              0
+#   define DH_F_DH_PRIV_ENCODE                              0
+#   define DH_F_DH_PUB_DECODE                               0
+#   define DH_F_DH_PUB_ENCODE                               0
+#   define DH_F_DO_DH_PRINT                                 0
+#   define DH_F_GENERATE_KEY                                0
+#   define DH_F_PKEY_DH_CTRL_STR                            0
+#   define DH_F_PKEY_DH_DERIVE                              0
+#   define DH_F_PKEY_DH_INIT                                0
+#   define DH_F_PKEY_DH_KEYGEN                              0
+#  endif
+
+#  ifndef OPENSSL_NO_DSA
+/*
+ * DSA function codes.
+ */
+#   define DSA_F_DSAPARAMS_PRINT                            0
+#   define DSA_F_DSAPARAMS_PRINT_FP                         0
+#   define DSA_F_DSA_BUILTIN_PARAMGEN                       0
+#   define DSA_F_DSA_BUILTIN_PARAMGEN2                      0
+#   define DSA_F_DSA_DO_SIGN                                0
+#   define DSA_F_DSA_DO_VERIFY                              0
+#   define DSA_F_DSA_METH_DUP                               0
+#   define DSA_F_DSA_METH_NEW                               0
+#   define DSA_F_DSA_METH_SET1_NAME                         0
+#   define DSA_F_DSA_NEW_METHOD                             0
+#   define DSA_F_DSA_PARAM_DECODE                           0
+#   define DSA_F_DSA_PRINT_FP                               0
+#   define DSA_F_DSA_PRIV_DECODE                            0
+#   define DSA_F_DSA_PRIV_ENCODE                            0
+#   define DSA_F_DSA_PUB_DECODE                             0
+#   define DSA_F_DSA_PUB_ENCODE                             0
+#   define DSA_F_DSA_SIGN                                   0
+#   define DSA_F_DSA_SIGN_SETUP                             0
+#   define DSA_F_DSA_SIG_NEW                                0
+#   define DSA_F_OLD_DSA_PRIV_DECODE                        0
+#   define DSA_F_PKEY_DSA_CTRL                              0
+#   define DSA_F_PKEY_DSA_CTRL_STR                          0
+#   define DSA_F_PKEY_DSA_KEYGEN                            0
+#  endif
+
+#  ifndef OPENSSL_NO_EC
+/*
+ * EC function codes.
+ */
+#   define EC_F_BN_TO_FELEM                                 0
+#   define EC_F_D2I_ECPARAMETERS                            0
+#   define EC_F_D2I_ECPKPARAMETERS                          0
+#   define EC_F_D2I_ECPRIVATEKEY                            0
+#   define EC_F_DO_EC_KEY_PRINT                             0
+#   define EC_F_ECDH_CMS_DECRYPT                            0
+#   define EC_F_ECDH_CMS_SET_SHARED_INFO                    0
+#   define EC_F_ECDH_COMPUTE_KEY                            0
+#   define EC_F_ECDH_SIMPLE_COMPUTE_KEY                     0
+#   define EC_F_ECDSA_DO_SIGN_EX                            0
+#   define EC_F_ECDSA_DO_VERIFY                             0
+#   define EC_F_ECDSA_SIGN_EX                               0
+#   define EC_F_ECDSA_SIGN_SETUP                            0
+#   define EC_F_ECDSA_SIG_NEW                               0
+#   define EC_F_ECDSA_VERIFY                                0
+#   define EC_F_ECD_ITEM_VERIFY                             0
+#   define EC_F_ECKEY_PARAM2TYPE                            0
+#   define EC_F_ECKEY_PARAM_DECODE                          0
+#   define EC_F_ECKEY_PRIV_DECODE                           0
+#   define EC_F_ECKEY_PRIV_ENCODE                           0
+#   define EC_F_ECKEY_PUB_DECODE                            0
+#   define EC_F_ECKEY_PUB_ENCODE                            0
+#   define EC_F_ECKEY_TYPE2PARAM                            0
+#   define EC_F_ECPARAMETERS_PRINT                          0
+#   define EC_F_ECPARAMETERS_PRINT_FP                       0
+#   define EC_F_ECPKPARAMETERS_PRINT                        0
+#   define EC_F_ECPKPARAMETERS_PRINT_FP                     0
+#   define EC_F_ECP_NISTZ256_GET_AFFINE                     0
+#   define EC_F_ECP_NISTZ256_INV_MOD_ORD                    0
+#   define EC_F_ECP_NISTZ256_MULT_PRECOMPUTE                0
+#   define EC_F_ECP_NISTZ256_POINTS_MUL                     0
+#   define EC_F_ECP_NISTZ256_PRE_COMP_NEW                   0
+#   define EC_F_ECP_NISTZ256_WINDOWED_MUL                   0
+#   define EC_F_ECX_KEY_OP                                  0
+#   define EC_F_ECX_PRIV_ENCODE                             0
+#   define EC_F_ECX_PUB_ENCODE                              0
+#   define EC_F_EC_ASN1_GROUP2CURVE                         0
+#   define EC_F_EC_ASN1_GROUP2FIELDID                       0
+#   define EC_F_EC_GF2M_MONTGOMERY_POINT_MULTIPLY           0
+#   define EC_F_EC_GF2M_SIMPLE_FIELD_INV                    0
+#   define EC_F_EC_GF2M_SIMPLE_GROUP_CHECK_DISCRIMINANT     0
+#   define EC_F_EC_GF2M_SIMPLE_GROUP_SET_CURVE              0
+#   define EC_F_EC_GF2M_SIMPLE_LADDER_POST                  0
+#   define EC_F_EC_GF2M_SIMPLE_LADDER_PRE                   0
+#   define EC_F_EC_GF2M_SIMPLE_OCT2POINT                    0
+#   define EC_F_EC_GF2M_SIMPLE_POINT2OCT                    0
+#   define EC_F_EC_GF2M_SIMPLE_POINTS_MUL                   0
+#   define EC_F_EC_GF2M_SIMPLE_POINT_GET_AFFINE_COORDINATES 0
+#   define EC_F_EC_GF2M_SIMPLE_POINT_SET_AFFINE_COORDINATES 0
+#   define EC_F_EC_GF2M_SIMPLE_SET_COMPRESSED_COORDINATES   0
+#   define EC_F_EC_GFP_MONT_FIELD_DECODE                    0
+#   define EC_F_EC_GFP_MONT_FIELD_ENCODE                    0
+#   define EC_F_EC_GFP_MONT_FIELD_INV                       0
+#   define EC_F_EC_GFP_MONT_FIELD_MUL                       0
+#   define EC_F_EC_GFP_MONT_FIELD_SET_TO_ONE                0
+#   define EC_F_EC_GFP_MONT_FIELD_SQR                       0
+#   define EC_F_EC_GFP_MONT_GROUP_SET_CURVE                 0
+#   define EC_F_EC_GFP_NISTP224_GROUP_SET_CURVE             0
+#   define EC_F_EC_GFP_NISTP224_POINTS_MUL                  0
+#   define EC_F_EC_GFP_NISTP224_POINT_GET_AFFINE_COORDINATES 0
+#   define EC_F_EC_GFP_NISTP256_GROUP_SET_CURVE             0
+#   define EC_F_EC_GFP_NISTP256_POINTS_MUL                  0
+#   define EC_F_EC_GFP_NISTP256_POINT_GET_AFFINE_COORDINATES 0
+#   define EC_F_EC_GFP_NISTP521_GROUP_SET_CURVE             0
+#   define EC_F_EC_GFP_NISTP521_POINTS_MUL                  0
+#   define EC_F_EC_GFP_NISTP521_POINT_GET_AFFINE_COORDINATES 0
+#   define EC_F_EC_GFP_NIST_FIELD_MUL                       0
+#   define EC_F_EC_GFP_NIST_FIELD_SQR                       0
+#   define EC_F_EC_GFP_NIST_GROUP_SET_CURVE                 0
+#   define EC_F_EC_GFP_SIMPLE_BLIND_COORDINATES             0
+#   define EC_F_EC_GFP_SIMPLE_FIELD_INV                     0
+#   define EC_F_EC_GFP_SIMPLE_GROUP_CHECK_DISCRIMINANT      0
+#   define EC_F_EC_GFP_SIMPLE_GROUP_SET_CURVE               0
+#   define EC_F_EC_GFP_SIMPLE_MAKE_AFFINE                   0
+#   define EC_F_EC_GFP_SIMPLE_OCT2POINT                     0
+#   define EC_F_EC_GFP_SIMPLE_POINT2OCT                     0
+#   define EC_F_EC_GFP_SIMPLE_POINTS_MAKE_AFFINE            0
+#   define EC_F_EC_GFP_SIMPLE_POINT_GET_AFFINE_COORDINATES  0
+#   define EC_F_EC_GFP_SIMPLE_POINT_SET_AFFINE_COORDINATES  0
+#   define EC_F_EC_GFP_SIMPLE_SET_COMPRESSED_COORDINATES    0
+#   define EC_F_EC_GROUP_CHECK                              0
+#   define EC_F_EC_GROUP_CHECK_DISCRIMINANT                 0
+#   define EC_F_EC_GROUP_COPY                               0
+#   define EC_F_EC_GROUP_GET_CURVE                          0
+#   define EC_F_EC_GROUP_GET_CURVE_GF2M                     0
+#   define EC_F_EC_GROUP_GET_CURVE_GFP                      0
+#   define EC_F_EC_GROUP_GET_DEGREE                         0
+#   define EC_F_EC_GROUP_GET_ECPARAMETERS                   0
+#   define EC_F_EC_GROUP_GET_ECPKPARAMETERS                 0
+#   define EC_F_EC_GROUP_GET_PENTANOMIAL_BASIS              0
+#   define EC_F_EC_GROUP_GET_TRINOMIAL_BASIS                0
+#   define EC_F_EC_GROUP_NEW                                0
+#   define EC_F_EC_GROUP_NEW_BY_CURVE_NAME                  0
+#   define EC_F_EC_GROUP_NEW_FROM_DATA                      0
+#   define EC_F_EC_GROUP_NEW_FROM_ECPARAMETERS              0
+#   define EC_F_EC_GROUP_NEW_FROM_ECPKPARAMETERS            0
+#   define EC_F_EC_GROUP_SET_CURVE                          0
+#   define EC_F_EC_GROUP_SET_CURVE_GF2M                     0
+#   define EC_F_EC_GROUP_SET_CURVE_GFP                      0
+#   define EC_F_EC_GROUP_SET_GENERATOR                      0
+#   define EC_F_EC_GROUP_SET_SEED                           0
+#   define EC_F_EC_KEY_CHECK_KEY                            0
+#   define EC_F_EC_KEY_COPY                                 0
+#   define EC_F_EC_KEY_GENERATE_KEY                         0
+#   define EC_F_EC_KEY_NEW                                  0
+#   define EC_F_EC_KEY_NEW_METHOD                           0
+#   define EC_F_EC_KEY_OCT2PRIV                             0
+#   define EC_F_EC_KEY_PRINT                                0
+#   define EC_F_EC_KEY_PRINT_FP                             0
+#   define EC_F_EC_KEY_PRIV2BUF                             0
+#   define EC_F_EC_KEY_PRIV2OCT                             0
+#   define EC_F_EC_KEY_SET_PUBLIC_KEY_AFFINE_COORDINATES    0
+#   define EC_F_EC_KEY_SIMPLE_CHECK_KEY                     0
+#   define EC_F_EC_KEY_SIMPLE_OCT2PRIV                      0
+#   define EC_F_EC_KEY_SIMPLE_PRIV2OCT                      0
+#   define EC_F_EC_PKEY_CHECK                               0
+#   define EC_F_EC_PKEY_PARAM_CHECK                         0
+#   define EC_F_EC_POINTS_MAKE_AFFINE                       0
+#   define EC_F_EC_POINTS_MUL                               0
+#   define EC_F_EC_POINT_ADD                                0
+#   define EC_F_EC_POINT_BN2POINT                           0
+#   define EC_F_EC_POINT_CMP                                0
+#   define EC_F_EC_POINT_COPY                               0
+#   define EC_F_EC_POINT_DBL                                0
+#   define EC_F_EC_POINT_GET_AFFINE_COORDINATES             0
+#   define EC_F_EC_POINT_GET_AFFINE_COORDINATES_GF2M        0
+#   define EC_F_EC_POINT_GET_AFFINE_COORDINATES_GFP         0
+#   define EC_F_EC_POINT_GET_JPROJECTIVE_COORDINATES_GFP    0
+#   define EC_F_EC_POINT_INVERT                             0
+#   define EC_F_EC_POINT_IS_AT_INFINITY                     0
+#   define EC_F_EC_POINT_IS_ON_CURVE                        0
+#   define EC_F_EC_POINT_MAKE_AFFINE                        0
+#   define EC_F_EC_POINT_NEW                                0
+#   define EC_F_EC_POINT_OCT2POINT                          0
+#   define EC_F_EC_POINT_POINT2BUF                          0
+#   define EC_F_EC_POINT_POINT2OCT                          0
+#   define EC_F_EC_POINT_SET_AFFINE_COORDINATES             0
+#   define EC_F_EC_POINT_SET_AFFINE_COORDINATES_GF2M        0
+#   define EC_F_EC_POINT_SET_AFFINE_COORDINATES_GFP         0
+#   define EC_F_EC_POINT_SET_COMPRESSED_COORDINATES         0
+#   define EC_F_EC_POINT_SET_COMPRESSED_COORDINATES_GF2M    0
+#   define EC_F_EC_POINT_SET_COMPRESSED_COORDINATES_GFP     0
+#   define EC_F_EC_POINT_SET_JPROJECTIVE_COORDINATES_GFP    0
+#   define EC_F_EC_POINT_SET_TO_INFINITY                    0
+#   define EC_F_EC_PRE_COMP_NEW                             0
+#   define EC_F_EC_SCALAR_MUL_LADDER                        0
+#   define EC_F_EC_WNAF_MUL                                 0
+#   define EC_F_EC_WNAF_PRECOMPUTE_MULT                     0
+#   define EC_F_I2D_ECPARAMETERS                            0
+#   define EC_F_I2D_ECPKPARAMETERS                          0
+#   define EC_F_I2D_ECPRIVATEKEY                            0
+#   define EC_F_I2O_ECPUBLICKEY                             0
+#   define EC_F_NISTP224_PRE_COMP_NEW                       0
+#   define EC_F_NISTP256_PRE_COMP_NEW                       0
+#   define EC_F_NISTP521_PRE_COMP_NEW                       0
+#   define EC_F_O2I_ECPUBLICKEY                             0
+#   define EC_F_OLD_EC_PRIV_DECODE                          0
+#   define EC_F_OSSL_ECDH_COMPUTE_KEY                       0
+#   define EC_F_OSSL_ECDSA_SIGN_SIG                         0
+#   define EC_F_OSSL_ECDSA_VERIFY_SIG                       0
+#   define EC_F_PKEY_ECD_CTRL                               0
+#   define EC_F_PKEY_ECD_DIGESTSIGN                         0
+#   define EC_F_PKEY_ECD_DIGESTSIGN25519                    0
+#   define EC_F_PKEY_ECD_DIGESTSIGN448                      0
+#   define EC_F_PKEY_ECX_DERIVE                             0
+#   define EC_F_PKEY_EC_CTRL                                0
+#   define EC_F_PKEY_EC_CTRL_STR                            0
+#   define EC_F_PKEY_EC_DERIVE                              0
+#   define EC_F_PKEY_EC_INIT                                0
+#   define EC_F_PKEY_EC_KDF_DERIVE                          0
+#   define EC_F_PKEY_EC_KEYGEN                              0
+#   define EC_F_PKEY_EC_PARAMGEN                            0
+#   define EC_F_PKEY_EC_SIGN                                0
+#   define EC_F_VALIDATE_ECX_DERIVE                         0
+#  endif
+
+#  ifndef OPENSSL_NO_ENGINE
+/*
+ * ENGINE function codes.
+ */
+#   define ENGINE_F_DIGEST_UPDATE                           0
+#   define ENGINE_F_DYNAMIC_CTRL                            0
+#   define ENGINE_F_DYNAMIC_GET_DATA_CTX                    0
+#   define ENGINE_F_DYNAMIC_LOAD                            0
+#   define ENGINE_F_DYNAMIC_SET_DATA_CTX                    0
+#   define ENGINE_F_ENGINE_ADD                              0
+#   define ENGINE_F_ENGINE_BY_ID                            0
+#   define ENGINE_F_ENGINE_CMD_IS_EXECUTABLE                0
+#   define ENGINE_F_ENGINE_CTRL                             0
+#   define ENGINE_F_ENGINE_CTRL_CMD                         0
+#   define ENGINE_F_ENGINE_CTRL_CMD_STRING                  0
+#   define ENGINE_F_ENGINE_FINISH                           0
+#   define ENGINE_F_ENGINE_GET_CIPHER                       0
+#   define ENGINE_F_ENGINE_GET_DIGEST                       0
+#   define ENGINE_F_ENGINE_GET_FIRST                        0
+#   define ENGINE_F_ENGINE_GET_LAST                         0
+#   define ENGINE_F_ENGINE_GET_NEXT                         0
+#   define ENGINE_F_ENGINE_GET_PKEY_ASN1_METH               0
+#   define ENGINE_F_ENGINE_GET_PKEY_METH                    0
+#   define ENGINE_F_ENGINE_GET_PREV                         0
+#   define ENGINE_F_ENGINE_INIT                             0
+#   define ENGINE_F_ENGINE_LIST_ADD                         0
+#   define ENGINE_F_ENGINE_LIST_REMOVE                      0
+#   define ENGINE_F_ENGINE_LOAD_PRIVATE_KEY                 0
+#   define ENGINE_F_ENGINE_LOAD_PUBLIC_KEY                  0
+#   define ENGINE_F_ENGINE_LOAD_SSL_CLIENT_CERT             0
+#   define ENGINE_F_ENGINE_NEW                              0
+#   define ENGINE_F_ENGINE_PKEY_ASN1_FIND_STR               0
+#   define ENGINE_F_ENGINE_REMOVE                           0
+#   define ENGINE_F_ENGINE_SET_DEFAULT_STRING               0
+#   define ENGINE_F_ENGINE_SET_ID                           0
+#   define ENGINE_F_ENGINE_SET_NAME                         0
+#   define ENGINE_F_ENGINE_TABLE_REGISTER                   0
+#   define ENGINE_F_ENGINE_UNLOCKED_FINISH                  0
+#   define ENGINE_F_ENGINE_UP_REF                           0
+#   define ENGINE_F_INT_CLEANUP_ITEM                        0
+#   define ENGINE_F_INT_CTRL_HELPER                         0
+#   define ENGINE_F_INT_ENGINE_CONFIGURE                    0
+#   define ENGINE_F_INT_ENGINE_MODULE_INIT                  0
+#   define ENGINE_F_OSSL_HMAC_INIT                          0
+#  endif
+
+/*
+ * EVP function codes.
+ */
+#  define EVP_F_AESNI_INIT_KEY                             0
+#  define EVP_F_AESNI_XTS_INIT_KEY                         0
+#  define EVP_F_AES_GCM_CTRL                               0
+#  define EVP_F_AES_INIT_KEY                               0
+#  define EVP_F_AES_OCB_CIPHER                             0
+#  define EVP_F_AES_T4_INIT_KEY                            0
+#  define EVP_F_AES_T4_XTS_INIT_KEY                        0
+#  define EVP_F_AES_WRAP_CIPHER                            0
+#  define EVP_F_AES_XTS_INIT_KEY                           0
+#  define EVP_F_ALG_MODULE_INIT                            0
+#  define EVP_F_ARIA_CCM_INIT_KEY                          0
+#  define EVP_F_ARIA_GCM_CTRL                              0
+#  define EVP_F_ARIA_GCM_INIT_KEY                          0
+#  define EVP_F_ARIA_INIT_KEY                              0
+#  define EVP_F_B64_NEW                                    0
+#  define EVP_F_CAMELLIA_INIT_KEY                          0
+#  define EVP_F_CHACHA20_POLY1305_CTRL                     0
+#  define EVP_F_CMLL_T4_INIT_KEY                           0
+#  define EVP_F_DES_EDE3_WRAP_CIPHER                       0
+#  define EVP_F_DO_SIGVER_INIT                             0
+#  define EVP_F_ENC_NEW                                    0
+#  define EVP_F_EVP_CIPHERINIT_EX                          0
+#  define EVP_F_EVP_CIPHER_ASN1_TO_PARAM                   0
+#  define EVP_F_EVP_CIPHER_CTX_COPY                        0
+#  define EVP_F_EVP_CIPHER_CTX_CTRL                        0
+#  define EVP_F_EVP_CIPHER_CTX_SET_KEY_LENGTH              0
+#  define EVP_F_EVP_CIPHER_PARAM_TO_ASN1                   0
+#  define EVP_F_EVP_DECRYPTFINAL_EX                        0
+#  define EVP_F_EVP_DECRYPTUPDATE                          0
+#  define EVP_F_EVP_DIGESTFINALXOF                         0
+#  define EVP_F_EVP_DIGESTINIT_EX                          0
+#  define EVP_F_EVP_ENCRYPTDECRYPTUPDATE                   0
+#  define EVP_F_EVP_ENCRYPTFINAL_EX                        0
+#  define EVP_F_EVP_ENCRYPTUPDATE                          0
+#  define EVP_F_EVP_MD_CTX_COPY_EX                         0
+#  define EVP_F_EVP_MD_SIZE                                0
+#  define EVP_F_EVP_OPENINIT                               0
+#  define EVP_F_EVP_PBE_ALG_ADD                            0
+#  define EVP_F_EVP_PBE_ALG_ADD_TYPE                       0
+#  define EVP_F_EVP_PBE_CIPHERINIT                         0
+#  define EVP_F_EVP_PBE_SCRYPT                             0
+#  define EVP_F_EVP_PKCS82PKEY                             0
+#  define EVP_F_EVP_PKEY2PKCS8                             0
+#  define EVP_F_EVP_PKEY_ASN1_ADD0                         0
+#  define EVP_F_EVP_PKEY_CHECK                             0
+#  define EVP_F_EVP_PKEY_COPY_PARAMETERS                   0
+#  define EVP_F_EVP_PKEY_CTX_CTRL                          0
+#  define EVP_F_EVP_PKEY_CTX_CTRL_STR                      0
+#  define EVP_F_EVP_PKEY_CTX_DUP                           0
+#  define EVP_F_EVP_PKEY_CTX_MD                            0
+#  define EVP_F_EVP_PKEY_DECRYPT                           0
+#  define EVP_F_EVP_PKEY_DECRYPT_INIT                      0
+#  define EVP_F_EVP_PKEY_DECRYPT_OLD                       0
+#  define EVP_F_EVP_PKEY_DERIVE                            0
+#  define EVP_F_EVP_PKEY_DERIVE_INIT                       0
+#  define EVP_F_EVP_PKEY_DERIVE_SET_PEER                   0
+#  define EVP_F_EVP_PKEY_ENCRYPT                           0
+#  define EVP_F_EVP_PKEY_ENCRYPT_INIT                      0
+#  define EVP_F_EVP_PKEY_ENCRYPT_OLD                       0
+#  define EVP_F_EVP_PKEY_GET0_DH                           0
+#  define EVP_F_EVP_PKEY_GET0_DSA                          0
+#  define EVP_F_EVP_PKEY_GET0_EC_KEY                       0
+#  define EVP_F_EVP_PKEY_GET0_HMAC                         0
+#  define EVP_F_EVP_PKEY_GET0_POLY1305                     0
+#  define EVP_F_EVP_PKEY_GET0_RSA                          0
+#  define EVP_F_EVP_PKEY_GET0_SIPHASH                      0
+#  define EVP_F_EVP_PKEY_GET_RAW_PRIVATE_KEY               0
+#  define EVP_F_EVP_PKEY_GET_RAW_PUBLIC_KEY                0
+#  define EVP_F_EVP_PKEY_KEYGEN                            0
+#  define EVP_F_EVP_PKEY_KEYGEN_INIT                       0
+#  define EVP_F_EVP_PKEY_METH_ADD0                         0
+#  define EVP_F_EVP_PKEY_METH_NEW                          0
+#  define EVP_F_EVP_PKEY_NEW                               0
+#  define EVP_F_EVP_PKEY_NEW_CMAC_KEY                      0
+#  define EVP_F_EVP_PKEY_NEW_RAW_PRIVATE_KEY               0
+#  define EVP_F_EVP_PKEY_NEW_RAW_PUBLIC_KEY                0
+#  define EVP_F_EVP_PKEY_PARAMGEN                          0
+#  define EVP_F_EVP_PKEY_PARAMGEN_INIT                     0
+#  define EVP_F_EVP_PKEY_PARAM_CHECK                       0
+#  define EVP_F_EVP_PKEY_PUBLIC_CHECK                      0
+#  define EVP_F_EVP_PKEY_SET1_ENGINE                       0
+#  define EVP_F_EVP_PKEY_SET_ALIAS_TYPE                    0
+#  define EVP_F_EVP_PKEY_SIGN                              0
+#  define EVP_F_EVP_PKEY_SIGN_INIT                         0
+#  define EVP_F_EVP_PKEY_VERIFY                            0
+#  define EVP_F_EVP_PKEY_VERIFY_INIT                       0
+#  define EVP_F_EVP_PKEY_VERIFY_RECOVER                    0
+#  define EVP_F_EVP_PKEY_VERIFY_RECOVER_INIT               0
+#  define EVP_F_EVP_SIGNFINAL                              0
+#  define EVP_F_EVP_VERIFYFINAL                            0
+#  define EVP_F_INT_CTX_NEW                                0
+#  define EVP_F_OK_NEW                                     0
+#  define EVP_F_PKCS5_PBE_KEYIVGEN                         0
+#  define EVP_F_PKCS5_V2_PBE_KEYIVGEN                      0
+#  define EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN                   0
+#  define EVP_F_PKCS5_V2_SCRYPT_KEYIVGEN                   0
+#  define EVP_F_PKEY_SET_TYPE                              0
+#  define EVP_F_RC2_MAGIC_TO_METH                          0
+#  define EVP_F_RC5_CTRL                                   0
+#  define EVP_F_R_32_12_16_INIT_KEY                        0
+#  define EVP_F_S390X_AES_GCM_CTRL                         0
+#  define EVP_F_UPDATE                                     0
+
+/*
+ * KDF function codes.
+ */
+#  define KDF_F_PKEY_HKDF_CTRL_STR                         0
+#  define KDF_F_PKEY_HKDF_DERIVE                           0
+#  define KDF_F_PKEY_HKDF_INIT                             0
+#  define KDF_F_PKEY_SCRYPT_CTRL_STR                       0
+#  define KDF_F_PKEY_SCRYPT_CTRL_UINT64                    0
+#  define KDF_F_PKEY_SCRYPT_DERIVE                         0
+#  define KDF_F_PKEY_SCRYPT_INIT                           0
+#  define KDF_F_PKEY_SCRYPT_SET_MEMBUF                     0
+#  define KDF_F_PKEY_TLS1_PRF_CTRL_STR                     0
+#  define KDF_F_PKEY_TLS1_PRF_DERIVE                       0
+#  define KDF_F_PKEY_TLS1_PRF_INIT                         0
+#  define KDF_F_TLS1_PRF_ALG                               0
+
+/*
+ * KDF reason codes.
+ */
+#  define KDF_R_INVALID_DIGEST                             0
+#  define KDF_R_MISSING_ITERATION_COUNT                    0
+#  define KDF_R_MISSING_KEY                                0
+#  define KDF_R_MISSING_MESSAGE_DIGEST                     0
+#  define KDF_R_MISSING_PARAMETER                          0
+#  define KDF_R_MISSING_PASS                               0
+#  define KDF_R_MISSING_SALT                               0
+#  define KDF_R_MISSING_SECRET                             0
+#  define KDF_R_MISSING_SEED                               0
+#  define KDF_R_UNKNOWN_PARAMETER_TYPE                     0
+#  define KDF_R_VALUE_ERROR                                0
+#  define KDF_R_VALUE_MISSING                              0
+
+/*
+ * OBJ function codes.
+ */
+#  define OBJ_F_OBJ_ADD_OBJECT                             0
+#  define OBJ_F_OBJ_ADD_SIGID                              0
+#  define OBJ_F_OBJ_CREATE                                 0
+#  define OBJ_F_OBJ_DUP                                    0
+#  define OBJ_F_OBJ_NAME_NEW_INDEX                         0
+#  define OBJ_F_OBJ_NID2LN                                 0
+#  define OBJ_F_OBJ_NID2OBJ                                0
+#  define OBJ_F_OBJ_NID2SN                                 0
+#  define OBJ_F_OBJ_TXT2OBJ                                0
+
+#  ifndef OPENSSL_NO_OCSP
+/*
+ * OCSP function codes.
+ */
+#   define OCSP_F_D2I_OCSP_NONCE                            0
+#   define OCSP_F_OCSP_BASIC_ADD1_STATUS                    0
+#   define OCSP_F_OCSP_BASIC_SIGN                           0
+#   define OCSP_F_OCSP_BASIC_SIGN_CTX                       0
+#   define OCSP_F_OCSP_BASIC_VERIFY                         0
+#   define OCSP_F_OCSP_CERT_ID_NEW                          0
+#   define OCSP_F_OCSP_CHECK_DELEGATED                      0
+#   define OCSP_F_OCSP_CHECK_IDS                            0
+#   define OCSP_F_OCSP_CHECK_ISSUER                         0
+#   define OCSP_F_OCSP_CHECK_VALIDITY                       0
+#   define OCSP_F_OCSP_MATCH_ISSUERID                       0
+#   define OCSP_F_OCSP_PARSE_URL                            0
+#   define OCSP_F_OCSP_REQUEST_SIGN                         0
+#   define OCSP_F_OCSP_REQUEST_VERIFY                       0
+#   define OCSP_F_OCSP_RESPONSE_GET1_BASIC                  0
+#   define OCSP_F_PARSE_HTTP_LINE1                          0
+#  endif
+
+/*
+ * PEM function codes.
+ */
+#  define PEM_F_B2I_DSS                                    0
+#  define PEM_F_B2I_PVK_BIO                                0
+#  define PEM_F_B2I_RSA                                    0
+#  define PEM_F_CHECK_BITLEN_DSA                           0
+#  define PEM_F_CHECK_BITLEN_RSA                           0
+#  define PEM_F_D2I_PKCS8PRIVATEKEY_BIO                    0
+#  define PEM_F_D2I_PKCS8PRIVATEKEY_FP                     0
+#  define PEM_F_DO_B2I                                     0
+#  define PEM_F_DO_B2I_BIO                                 0
+#  define PEM_F_DO_BLOB_HEADER                             0
+#  define PEM_F_DO_I2B                                     0
+#  define PEM_F_DO_PK8PKEY                                 0
+#  define PEM_F_DO_PK8PKEY_FP                              0
+#  define PEM_F_DO_PVK_BODY                                0
+#  define PEM_F_DO_PVK_HEADER                              0
+#  define PEM_F_GET_HEADER_AND_DATA                        0
+#  define PEM_F_GET_NAME                                   0
+#  define PEM_F_I2B_PVK                                    0
+#  define PEM_F_I2B_PVK_BIO                                0
+#  define PEM_F_LOAD_IV                                    0
+#  define PEM_F_PEM_ASN1_READ                              0
+#  define PEM_F_PEM_ASN1_READ_BIO                          0
+#  define PEM_F_PEM_ASN1_WRITE                             0
+#  define PEM_F_PEM_ASN1_WRITE_BIO                         0
+#  define PEM_F_PEM_DEF_CALLBACK                           0
+#  define PEM_F_PEM_DO_HEADER                              0
+#  define PEM_F_PEM_GET_EVP_CIPHER_INFO                    0
+#  define PEM_F_PEM_READ                                   0
+#  define PEM_F_PEM_READ_BIO                               0
+#  define PEM_F_PEM_READ_BIO_DHPARAMS                      0
+#  define PEM_F_PEM_READ_BIO_EX                            0
+#  define PEM_F_PEM_READ_BIO_PARAMETERS                    0
+#  define PEM_F_PEM_READ_BIO_PRIVATEKEY                    0
+#  define PEM_F_PEM_READ_DHPARAMS                          0
+#  define PEM_F_PEM_READ_PRIVATEKEY                        0
+#  define PEM_F_PEM_SIGNFINAL                              0
+#  define PEM_F_PEM_WRITE                                  0
+#  define PEM_F_PEM_WRITE_BIO                              0
+#  define PEM_F_PEM_WRITE_BIO_PRIVATEKEY_TRADITIONAL       0
+#  define PEM_F_PEM_WRITE_PRIVATEKEY                       0
+#  define PEM_F_PEM_X509_INFO_READ                         0
+#  define PEM_F_PEM_X509_INFO_READ_BIO                     0
+#  define PEM_F_PEM_X509_INFO_WRITE_BIO                    0
+
+/*
+ * PKCS12 function codes.
+ */
+#  define PKCS12_F_OPENSSL_ASC2UNI                         0
+#  define PKCS12_F_OPENSSL_UNI2ASC                         0
+#  define PKCS12_F_OPENSSL_UNI2UTF8                        0
+#  define PKCS12_F_OPENSSL_UTF82UNI                        0
+#  define PKCS12_F_PKCS12_CREATE                           0
+#  define PKCS12_F_PKCS12_GEN_MAC                          0
+#  define PKCS12_F_PKCS12_INIT                             0
+#  define PKCS12_F_PKCS12_ITEM_DECRYPT_D2I                 0
+#  define PKCS12_F_PKCS12_ITEM_I2D_ENCRYPT                 0
+#  define PKCS12_F_PKCS12_ITEM_PACK_SAFEBAG                0
+#  define PKCS12_F_PKCS12_KEY_GEN_ASC                      0
+#  define PKCS12_F_PKCS12_KEY_GEN_UNI                      0
+#  define PKCS12_F_PKCS12_KEY_GEN_UTF8                     0
+#  define PKCS12_F_PKCS12_NEWPASS                          0
+#  define PKCS12_F_PKCS12_PACK_P7DATA                      0
+#  define PKCS12_F_PKCS12_PACK_P7ENCDATA                   0
+#  define PKCS12_F_PKCS12_PARSE                            0
+#  define PKCS12_F_PKCS12_PBE_CRYPT                        0
+#  define PKCS12_F_PKCS12_PBE_KEYIVGEN                     0
+#  define PKCS12_F_PKCS12_SAFEBAG_CREATE0_P8INF            0
+#  define PKCS12_F_PKCS12_SAFEBAG_CREATE0_PKCS8            0
+#  define PKCS12_F_PKCS12_SAFEBAG_CREATE_PKCS8_ENCRYPT     0
+#  define PKCS12_F_PKCS12_SETUP_MAC                        0
+#  define PKCS12_F_PKCS12_SET_MAC                          0
+#  define PKCS12_F_PKCS12_UNPACK_AUTHSAFES                 0
+#  define PKCS12_F_PKCS12_UNPACK_P7DATA                    0
+#  define PKCS12_F_PKCS12_VERIFY_MAC                       0
+#  define PKCS12_F_PKCS8_ENCRYPT                           0
+#  define PKCS12_F_PKCS8_SET0_PBE                          0
+
+/*
+ * PKCS7 function codes.
+ */
+#  define PKCS7_F_DO_PKCS7_SIGNED_ATTRIB                   0
+#  define PKCS7_F_PKCS7_ADD0_ATTRIB_SIGNING_TIME           0
+#  define PKCS7_F_PKCS7_ADD_ATTRIB_SMIMECAP                0
+#  define PKCS7_F_PKCS7_ADD_CERTIFICATE                    0
+#  define PKCS7_F_PKCS7_ADD_CRL                            0
+#  define PKCS7_F_PKCS7_ADD_RECIPIENT_INFO                 0
+#  define PKCS7_F_PKCS7_ADD_SIGNATURE                      0
+#  define PKCS7_F_PKCS7_ADD_SIGNER                         0
+#  define PKCS7_F_PKCS7_BIO_ADD_DIGEST                     0
+#  define PKCS7_F_PKCS7_COPY_EXISTING_DIGEST               0
+#  define PKCS7_F_PKCS7_CTRL                               0
+#  define PKCS7_F_PKCS7_DATADECODE                         0
+#  define PKCS7_F_PKCS7_DATAFINAL                          0
+#  define PKCS7_F_PKCS7_DATAINIT                           0
+#  define PKCS7_F_PKCS7_DATAVERIFY                         0
+#  define PKCS7_F_PKCS7_DECRYPT                            0
+#  define PKCS7_F_PKCS7_DECRYPT_RINFO                      0
+#  define PKCS7_F_PKCS7_ENCODE_RINFO                       0
+#  define PKCS7_F_PKCS7_ENCRYPT                            0
+#  define PKCS7_F_PKCS7_FINAL                              0
+#  define PKCS7_F_PKCS7_FIND_DIGEST                        0
+#  define PKCS7_F_PKCS7_GET0_SIGNERS                       0
+#  define PKCS7_F_PKCS7_RECIP_INFO_SET                     0
+#  define PKCS7_F_PKCS7_SET_CIPHER                         0
+#  define PKCS7_F_PKCS7_SET_CONTENT                        0
+#  define PKCS7_F_PKCS7_SET_DIGEST                         0
+#  define PKCS7_F_PKCS7_SET_TYPE                           0
+#  define PKCS7_F_PKCS7_SIGN                               0
+#  define PKCS7_F_PKCS7_SIGNATUREVERIFY                    0
+#  define PKCS7_F_PKCS7_SIGNER_INFO_SET                    0
+#  define PKCS7_F_PKCS7_SIGNER_INFO_SIGN                   0
+#  define PKCS7_F_PKCS7_SIGN_ADD_SIGNER                    0
+#  define PKCS7_F_PKCS7_SIMPLE_SMIMECAP                    0
+#  define PKCS7_F_PKCS7_VERIFY                             0
+
+/*
+ * RAND function codes.
+ */
+#  define RAND_F_DATA_COLLECT_METHOD                       0
+#  define RAND_F_DRBG_BYTES                                0
+#  define RAND_F_DRBG_GET_ENTROPY                          0
+#  define RAND_F_DRBG_SETUP                                0
+#  define RAND_F_GET_ENTROPY                               0
+#  define RAND_F_RAND_BYTES                                0
+#  define RAND_F_RAND_DRBG_ENABLE_LOCKING                  0
+#  define RAND_F_RAND_DRBG_GENERATE                        0
+#  define RAND_F_RAND_DRBG_GET_ENTROPY                     0
+#  define RAND_F_RAND_DRBG_GET_NONCE                       0
+#  define RAND_F_RAND_DRBG_INSTANTIATE                     0
+#  define RAND_F_RAND_DRBG_NEW                             0
+#  define RAND_F_RAND_DRBG_RESEED                          0
+#  define RAND_F_RAND_DRBG_RESTART                         0
+#  define RAND_F_RAND_DRBG_SET                             0
+#  define RAND_F_RAND_DRBG_SET_DEFAULTS                    0
+#  define RAND_F_RAND_DRBG_UNINSTANTIATE                   0
+#  define RAND_F_RAND_LOAD_FILE                            0
+#  define RAND_F_RAND_POOL_ACQUIRE_ENTROPY                 0
+#  define RAND_F_RAND_POOL_ADD                             0
+#  define RAND_F_RAND_POOL_ADD_BEGIN                       0
+#  define RAND_F_RAND_POOL_ADD_END                         0
+#  define RAND_F_RAND_POOL_ATTACH                          0
+#  define RAND_F_RAND_POOL_BYTES_NEEDED                    0
+#  define RAND_F_RAND_POOL_GROW                            0
+#  define RAND_F_RAND_POOL_NEW                             0
+#  define RAND_F_RAND_PSEUDO_BYTES                         0
+#  define RAND_F_RAND_WRITE_FILE                           0
+
+/*
+ * RSA function codes.
+ */
+#  define RSA_F_CHECK_PADDING_MD                           0
+#  define RSA_F_ENCODE_PKCS1                               0
+#  define RSA_F_INT_RSA_VERIFY                             0
+#  define RSA_F_OLD_RSA_PRIV_DECODE                        0
+#  define RSA_F_PKEY_PSS_INIT                              0
+#  define RSA_F_PKEY_RSA_CTRL                              0
+#  define RSA_F_PKEY_RSA_CTRL_STR                          0
+#  define RSA_F_PKEY_RSA_SIGN                              0
+#  define RSA_F_PKEY_RSA_VERIFY                            0
+#  define RSA_F_PKEY_RSA_VERIFYRECOVER                     0
+#  define RSA_F_RSA_ALGOR_TO_MD                            0
+#  define RSA_F_RSA_BUILTIN_KEYGEN                         0
+#  define RSA_F_RSA_CHECK_KEY                              0
+#  define RSA_F_RSA_CHECK_KEY_EX                           0
+#  define RSA_F_RSA_CMS_DECRYPT                            0
+#  define RSA_F_RSA_CMS_VERIFY                             0
+#  define RSA_F_RSA_ITEM_VERIFY                            0
+#  define RSA_F_RSA_METH_DUP                               0
+#  define RSA_F_RSA_METH_NEW                               0
+#  define RSA_F_RSA_METH_SET1_NAME                         0
+#  define RSA_F_RSA_MGF1_TO_MD                             0
+#  define RSA_F_RSA_MULTIP_INFO_NEW                        0
+#  define RSA_F_RSA_NEW_METHOD                             0
+#  define RSA_F_RSA_NULL                                   0
+#  define RSA_F_RSA_NULL_PRIVATE_DECRYPT                   0
+#  define RSA_F_RSA_NULL_PRIVATE_ENCRYPT                   0
+#  define RSA_F_RSA_NULL_PUBLIC_DECRYPT                    0
+#  define RSA_F_RSA_NULL_PUBLIC_ENCRYPT                    0
+#  define RSA_F_RSA_OSSL_PRIVATE_DECRYPT                   0
+#  define RSA_F_RSA_OSSL_PRIVATE_ENCRYPT                   0
+#  define RSA_F_RSA_OSSL_PUBLIC_DECRYPT                    0
+#  define RSA_F_RSA_OSSL_PUBLIC_ENCRYPT                    0
+#  define RSA_F_RSA_PADDING_ADD_NONE                       0
+#  define RSA_F_RSA_PADDING_ADD_PKCS1_OAEP                 0
+#  define RSA_F_RSA_PADDING_ADD_PKCS1_OAEP_MGF1            0
+#  define RSA_F_RSA_PADDING_ADD_PKCS1_PSS                  0
+#  define RSA_F_RSA_PADDING_ADD_PKCS1_PSS_MGF1             0
+#  define RSA_F_RSA_PADDING_ADD_PKCS1_TYPE_1               0
+#  define RSA_F_RSA_PADDING_ADD_PKCS1_TYPE_2               0
+#  define RSA_F_RSA_PADDING_ADD_SSLV23                     0
+#  define RSA_F_RSA_PADDING_ADD_X931                       0
+#  define RSA_F_RSA_PADDING_CHECK_NONE                     0
+#  define RSA_F_RSA_PADDING_CHECK_PKCS1_OAEP               0
+#  define RSA_F_RSA_PADDING_CHECK_PKCS1_OAEP_MGF1          0
+#  define RSA_F_RSA_PADDING_CHECK_PKCS1_TYPE_1             0
+#  define RSA_F_RSA_PADDING_CHECK_PKCS1_TYPE_2             0
+#  define RSA_F_RSA_PADDING_CHECK_SSLV23                   0
+#  define RSA_F_RSA_PADDING_CHECK_X931                     0
+#  define RSA_F_RSA_PARAM_DECODE                           0
+#  define RSA_F_RSA_PRINT                                  0
+#  define RSA_F_RSA_PRINT_FP                               0
+#  define RSA_F_RSA_PRIV_DECODE                            0
+#  define RSA_F_RSA_PRIV_ENCODE                            0
+#  define RSA_F_RSA_PSS_GET_PARAM                          0
+#  define RSA_F_RSA_PSS_TO_CTX                             0
+#  define RSA_F_RSA_PUB_DECODE                             0
+#  define RSA_F_RSA_SETUP_BLINDING                         0
+#  define RSA_F_RSA_SIGN                                   0
+#  define RSA_F_RSA_SIGN_ASN1_OCTET_STRING                 0
+#  define RSA_F_RSA_VERIFY                                 0
+#  define RSA_F_RSA_VERIFY_ASN1_OCTET_STRING               0
+#  define RSA_F_RSA_VERIFY_PKCS1_PSS_MGF1                  0
+#  define RSA_F_SETUP_TBUF                                 0
+
+/*
+ * OSSL_STORE function codes.
+ */
+#  define OSSL_STORE_F_FILE_CTRL                           0
+#  define OSSL_STORE_F_FILE_FIND                           0
+#  define OSSL_STORE_F_FILE_GET_PASS                       0
+#  define OSSL_STORE_F_FILE_LOAD                           0
+#  define OSSL_STORE_F_FILE_LOAD_TRY_DECODE                0
+#  define OSSL_STORE_F_FILE_NAME_TO_URI                    0
+#  define OSSL_STORE_F_FILE_OPEN                           0
+#  define OSSL_STORE_F_OSSL_STORE_ATTACH_PEM_BIO           0
+#  define OSSL_STORE_F_OSSL_STORE_EXPECT                   0
+#  define OSSL_STORE_F_OSSL_STORE_FILE_ATTACH_PEM_BIO_INT  0
+#  define OSSL_STORE_F_OSSL_STORE_FIND                     0
+#  define OSSL_STORE_F_OSSL_STORE_GET0_LOADER_INT          0
+#  define OSSL_STORE_F_OSSL_STORE_INFO_GET1_CERT           0
+#  define OSSL_STORE_F_OSSL_STORE_INFO_GET1_CRL            0
+#  define OSSL_STORE_F_OSSL_STORE_INFO_GET1_NAME           0
+#  define OSSL_STORE_F_OSSL_STORE_INFO_GET1_NAME_DESCRIPTION 0
+#  define OSSL_STORE_F_OSSL_STORE_INFO_GET1_PARAMS         0
+#  define OSSL_STORE_F_OSSL_STORE_INFO_GET1_PKEY           0
+#  define OSSL_STORE_F_OSSL_STORE_INFO_NEW_CERT            0
+#  define OSSL_STORE_F_OSSL_STORE_INFO_NEW_CRL             0
+#  define OSSL_STORE_F_OSSL_STORE_INFO_NEW_EMBEDDED        0
+#  define OSSL_STORE_F_OSSL_STORE_INFO_NEW_NAME            0
+#  define OSSL_STORE_F_OSSL_STORE_INFO_NEW_PARAMS          0
+#  define OSSL_STORE_F_OSSL_STORE_INFO_NEW_PKEY            0
+#  define OSSL_STORE_F_OSSL_STORE_INFO_SET0_NAME_DESCRIPTION 0
+#  define OSSL_STORE_F_OSSL_STORE_INIT_ONCE                0
+#  define OSSL_STORE_F_OSSL_STORE_LOADER_NEW               0
+#  define OSSL_STORE_F_OSSL_STORE_OPEN                     0
+#  define OSSL_STORE_F_OSSL_STORE_OPEN_INT                 0
+#  define OSSL_STORE_F_OSSL_STORE_REGISTER_LOADER_INT      0
+#  define OSSL_STORE_F_OSSL_STORE_SEARCH_BY_ALIAS          0
+#  define OSSL_STORE_F_OSSL_STORE_SEARCH_BY_ISSUER_SERIAL  0
+#  define OSSL_STORE_F_OSSL_STORE_SEARCH_BY_KEY_FINGERPRINT 0
+#  define OSSL_STORE_F_OSSL_STORE_SEARCH_BY_NAME           0
+#  define OSSL_STORE_F_OSSL_STORE_UNREGISTER_LOADER_INT    0
+#  define OSSL_STORE_F_TRY_DECODE_PARAMS                   0
+#  define OSSL_STORE_F_TRY_DECODE_PKCS12                   0
+#  define OSSL_STORE_F_TRY_DECODE_PKCS8ENCRYPTED           0
+
+#  ifndef OPENSSL_NO_TS
+/*
+ * TS function codes.
+ */
+#   define TS_F_DEF_SERIAL_CB                               0
+#   define TS_F_DEF_TIME_CB                                 0
+#   define TS_F_ESS_ADD_SIGNING_CERT                        0
+#   define TS_F_ESS_ADD_SIGNING_CERT_V2                     0
+#   define TS_F_ESS_CERT_ID_NEW_INIT                        0
+#   define TS_F_ESS_CERT_ID_V2_NEW_INIT                     0
+#   define TS_F_ESS_SIGNING_CERT_NEW_INIT                   0
+#   define TS_F_ESS_SIGNING_CERT_V2_NEW_INIT                0
+#   define TS_F_INT_TS_RESP_VERIFY_TOKEN                    0
+#   define TS_F_PKCS7_TO_TS_TST_INFO                        0
+#   define TS_F_TS_ACCURACY_SET_MICROS                      0
+#   define TS_F_TS_ACCURACY_SET_MILLIS                      0
+#   define TS_F_TS_ACCURACY_SET_SECONDS                     0
+#   define TS_F_TS_CHECK_IMPRINTS                           0
+#   define TS_F_TS_CHECK_NONCES                             0
+#   define TS_F_TS_CHECK_POLICY                             0
+#   define TS_F_TS_CHECK_SIGNING_CERTS                      0
+#   define TS_F_TS_CHECK_STATUS_INFO                        0
+#   define TS_F_TS_COMPUTE_IMPRINT                          0
+#   define TS_F_TS_CONF_INVALID                             0
+#   define TS_F_TS_CONF_LOAD_CERT                           0
+#   define TS_F_TS_CONF_LOAD_CERTS                          0
+#   define TS_F_TS_CONF_LOAD_KEY                            0
+#   define TS_F_TS_CONF_LOOKUP_FAIL                         0
+#   define TS_F_TS_CONF_SET_DEFAULT_ENGINE                  0
+#   define TS_F_TS_GET_STATUS_TEXT                          0
+#   define TS_F_TS_MSG_IMPRINT_SET_ALGO                     0
+#   define TS_F_TS_REQ_SET_MSG_IMPRINT                      0
+#   define TS_F_TS_REQ_SET_NONCE                            0
+#   define TS_F_TS_REQ_SET_POLICY_ID                        0
+#   define TS_F_TS_RESP_CREATE_RESPONSE                     0
+#   define TS_F_TS_RESP_CREATE_TST_INFO                     0
+#   define TS_F_TS_RESP_CTX_ADD_FAILURE_INFO                0
+#   define TS_F_TS_RESP_CTX_ADD_MD                          0
+#   define TS_F_TS_RESP_CTX_ADD_POLICY                      0
+#   define TS_F_TS_RESP_CTX_NEW                             0
+#   define TS_F_TS_RESP_CTX_SET_ACCURACY                    0
+#   define TS_F_TS_RESP_CTX_SET_CERTS                       0
+#   define TS_F_TS_RESP_CTX_SET_DEF_POLICY                  0
+#   define TS_F_TS_RESP_CTX_SET_SIGNER_CERT                 0
+#   define TS_F_TS_RESP_CTX_SET_STATUS_INFO                 0
+#   define TS_F_TS_RESP_GET_POLICY                          0
+#   define TS_F_TS_RESP_SET_GENTIME_WITH_PRECISION          0
+#   define TS_F_TS_RESP_SET_STATUS_INFO                     0
+#   define TS_F_TS_RESP_SET_TST_INFO                        0
+#   define TS_F_TS_RESP_SIGN                                0
+#   define TS_F_TS_RESP_VERIFY_SIGNATURE                    0
+#   define TS_F_TS_TST_INFO_SET_ACCURACY                    0
+#   define TS_F_TS_TST_INFO_SET_MSG_IMPRINT                 0
+#   define TS_F_TS_TST_INFO_SET_NONCE                       0
+#   define TS_F_TS_TST_INFO_SET_POLICY_ID                   0
+#   define TS_F_TS_TST_INFO_SET_SERIAL                      0
+#   define TS_F_TS_TST_INFO_SET_TIME                        0
+#   define TS_F_TS_TST_INFO_SET_TSA                         0
+#   define TS_F_TS_VERIFY                                   0
+#   define TS_F_TS_VERIFY_CERT                              0
+#   define TS_F_TS_VERIFY_CTX_NEW                           0
+#  endif
+
+/*
+ * UI function codes.
+ */
+#  define UI_F_CLOSE_CONSOLE                               0
+#  define UI_F_ECHO_CONSOLE                                0
+#  define UI_F_GENERAL_ALLOCATE_BOOLEAN                    0
+#  define UI_F_GENERAL_ALLOCATE_PROMPT                     0
+#  define UI_F_NOECHO_CONSOLE                              0
+#  define UI_F_OPEN_CONSOLE                                0
+#  define UI_F_UI_CONSTRUCT_PROMPT                         0
+#  define UI_F_UI_CREATE_METHOD                            0
+#  define UI_F_UI_CTRL                                     0
+#  define UI_F_UI_DUP_ERROR_STRING                         0
+#  define UI_F_UI_DUP_INFO_STRING                          0
+#  define UI_F_UI_DUP_INPUT_BOOLEAN                        0
+#  define UI_F_UI_DUP_INPUT_STRING                         0
+#  define UI_F_UI_DUP_USER_DATA                            0
+#  define UI_F_UI_DUP_VERIFY_STRING                        0
+#  define UI_F_UI_GET0_RESULT                              0
+#  define UI_F_UI_GET_RESULT_LENGTH                        0
+#  define UI_F_UI_NEW_METHOD                               0
+#  define UI_F_UI_PROCESS                                  0
+#  define UI_F_UI_SET_RESULT                               0
+#  define UI_F_UI_SET_RESULT_EX                            0
+
+/*
+ * X509 function codes.
+ */
+#  define X509_F_ADD_CERT_DIR                              0
+#  define X509_F_BUILD_CHAIN                               0
+#  define X509_F_BY_FILE_CTRL                              0
+#  define X509_F_CHECK_NAME_CONSTRAINTS                    0
+#  define X509_F_CHECK_POLICY                              0
+#  define X509_F_DANE_I2D                                  0
+#  define X509_F_DIR_CTRL                                  0
+#  define X509_F_GET_CERT_BY_SUBJECT                       0
+#  define X509_F_I2D_X509_AUX                              0
+#  define X509_F_LOOKUP_CERTS_SK                           0
+#  define X509_F_NETSCAPE_SPKI_B64_DECODE                  0
+#  define X509_F_NETSCAPE_SPKI_B64_ENCODE                  0
+#  define X509_F_NEW_DIR                                   0
+#  define X509_F_X509AT_ADD1_ATTR                          0
+#  define X509_F_X509V3_ADD_EXT                            0
+#  define X509_F_X509_ATTRIBUTE_CREATE_BY_NID              0
+#  define X509_F_X509_ATTRIBUTE_CREATE_BY_OBJ              0
+#  define X509_F_X509_ATTRIBUTE_CREATE_BY_TXT              0
+#  define X509_F_X509_ATTRIBUTE_GET0_DATA                  0
+#  define X509_F_X509_ATTRIBUTE_SET1_DATA                  0
+#  define X509_F_X509_CHECK_PRIVATE_KEY                    0
+#  define X509_F_X509_CRL_DIFF                             0
+#  define X509_F_X509_CRL_METHOD_NEW                       0
+#  define X509_F_X509_CRL_PRINT_FP                         0
+#  define X509_F_X509_EXTENSION_CREATE_BY_NID              0
+#  define X509_F_X509_EXTENSION_CREATE_BY_OBJ              0
+#  define X509_F_X509_GET_PUBKEY_PARAMETERS                0
+#  define X509_F_X509_LOAD_CERT_CRL_FILE                   0
+#  define X509_F_X509_LOAD_CERT_FILE                       0
+#  define X509_F_X509_LOAD_CRL_FILE                        0
+#  define X509_F_X509_LOOKUP_METH_NEW                      0
+#  define X509_F_X509_LOOKUP_NEW                           0
+#  define X509_F_X509_NAME_ADD_ENTRY                       0
+#  define X509_F_X509_NAME_CANON                           0
+#  define X509_F_X509_NAME_ENTRY_CREATE_BY_NID             0
+#  define X509_F_X509_NAME_ENTRY_CREATE_BY_TXT             0
+#  define X509_F_X509_NAME_ENTRY_SET_OBJECT                0
+#  define X509_F_X509_NAME_ONELINE                         0
+#  define X509_F_X509_NAME_PRINT                           0
+#  define X509_F_X509_OBJECT_NEW                           0
+#  define X509_F_X509_PRINT_EX_FP                          0
+#  define X509_F_X509_PUBKEY_DECODE                        0
+#  define X509_F_X509_PUBKEY_GET                           0
+#  define X509_F_X509_PUBKEY_GET0                          0
+#  define X509_F_X509_PUBKEY_SET                           0
+#  define X509_F_X509_REQ_CHECK_PRIVATE_KEY                0
+#  define X509_F_X509_REQ_PRINT_EX                         0
+#  define X509_F_X509_REQ_PRINT_FP                         0
+#  define X509_F_X509_REQ_TO_X509                          0
+#  define X509_F_X509_STORE_ADD_CERT                       0
+#  define X509_F_X509_STORE_ADD_CRL                        0
+#  define X509_F_X509_STORE_ADD_LOOKUP                     0
+#  define X509_F_X509_STORE_CTX_GET1_ISSUER                0
+#  define X509_F_X509_STORE_CTX_INIT                       0
+#  define X509_F_X509_STORE_CTX_NEW                        0
+#  define X509_F_X509_STORE_CTX_PURPOSE_INHERIT            0
+#  define X509_F_X509_STORE_NEW                            0
+#  define X509_F_X509_TO_X509_REQ                          0
+#  define X509_F_X509_TRUST_ADD                            0
+#  define X509_F_X509_TRUST_SET                            0
+#  define X509_F_X509_VERIFY_CERT                          0
+#  define X509_F_X509_VERIFY_PARAM_NEW                     0
+
+/*
+ * X509V3 function codes.
+ */
+#  define X509V3_F_A2I_GENERAL_NAME                        0
+#  define X509V3_F_ADDR_VALIDATE_PATH_INTERNAL             0
+#  define X509V3_F_ASIDENTIFIERCHOICE_CANONIZE             0
+#  define X509V3_F_ASIDENTIFIERCHOICE_IS_CANONICAL         0
+#  define X509V3_F_BIGNUM_TO_STRING                        0
+#  define X509V3_F_COPY_EMAIL                              0
+#  define X509V3_F_COPY_ISSUER                             0
+#  define X509V3_F_DO_DIRNAME                              0
+#  define X509V3_F_DO_EXT_I2D                              0
+#  define X509V3_F_DO_EXT_NCONF                            0
+#  define X509V3_F_GNAMES_FROM_SECTNAME                    0
+#  define X509V3_F_I2S_ASN1_ENUMERATED                     0
+#  define X509V3_F_I2S_ASN1_IA5STRING                      0
+#  define X509V3_F_I2S_ASN1_INTEGER                        0
+#  define X509V3_F_I2V_AUTHORITY_INFO_ACCESS               0
+#  define X509V3_F_LEVEL_ADD_NODE                          0
+#  define X509V3_F_NOTICE_SECTION                          0
+#  define X509V3_F_NREF_NOS                                0
+#  define X509V3_F_POLICY_CACHE_CREATE                     0
+#  define X509V3_F_POLICY_CACHE_NEW                        0
+#  define X509V3_F_POLICY_DATA_NEW                         0
+#  define X509V3_F_POLICY_SECTION                          0
+#  define X509V3_F_PROCESS_PCI_VALUE                       0
+#  define X509V3_F_R2I_CERTPOL                             0
+#  define X509V3_F_R2I_PCI                                 0
+#  define X509V3_F_S2I_ASN1_IA5STRING                      0
+#  define X509V3_F_S2I_ASN1_INTEGER                        0
+#  define X509V3_F_S2I_ASN1_OCTET_STRING                   0
+#  define X509V3_F_S2I_SKEY_ID                             0
+#  define X509V3_F_SET_DIST_POINT_NAME                     0
+#  define X509V3_F_SXNET_ADD_ID_ASC                        0
+#  define X509V3_F_SXNET_ADD_ID_INTEGER                    0
+#  define X509V3_F_SXNET_ADD_ID_ULONG                      0
+#  define X509V3_F_SXNET_GET_ID_ASC                        0
+#  define X509V3_F_SXNET_GET_ID_ULONG                      0
+#  define X509V3_F_TREE_INIT                               0
+#  define X509V3_F_V2I_ASIDENTIFIERS                       0
+#  define X509V3_F_V2I_ASN1_BIT_STRING                     0
+#  define X509V3_F_V2I_AUTHORITY_INFO_ACCESS               0
+#  define X509V3_F_V2I_AUTHORITY_KEYID                     0
+#  define X509V3_F_V2I_BASIC_CONSTRAINTS                   0
+#  define X509V3_F_V2I_CRLD                                0
+#  define X509V3_F_V2I_EXTENDED_KEY_USAGE                  0
+#  define X509V3_F_V2I_GENERAL_NAMES                       0
+#  define X509V3_F_V2I_GENERAL_NAME_EX                     0
+#  define X509V3_F_V2I_IDP                                 0
+#  define X509V3_F_V2I_IPADDRBLOCKS                        0
+#  define X509V3_F_V2I_ISSUER_ALT                          0
+#  define X509V3_F_V2I_NAME_CONSTRAINTS                    0
+#  define X509V3_F_V2I_POLICY_CONSTRAINTS                  0
+#  define X509V3_F_V2I_POLICY_MAPPINGS                     0
+#  define X509V3_F_V2I_SUBJECT_ALT                         0
+#  define X509V3_F_V2I_TLS_FEATURE                         0
+#  define X509V3_F_V3_GENERIC_EXTENSION                    0
+#  define X509V3_F_X509V3_ADD1_I2D                         0
+#  define X509V3_F_X509V3_ADD_VALUE                        0
+#  define X509V3_F_X509V3_EXT_ADD                          0
+#  define X509V3_F_X509V3_EXT_ADD_ALIAS                    0
+#  define X509V3_F_X509V3_EXT_I2D                          0
+#  define X509V3_F_X509V3_EXT_NCONF                        0
+#  define X509V3_F_X509V3_GET_SECTION                      0
+#  define X509V3_F_X509V3_GET_STRING                       0
+#  define X509V3_F_X509V3_GET_VALUE_BOOL                   0
+#  define X509V3_F_X509V3_PARSE_LIST                       0
+#  define X509V3_F_X509_PURPOSE_ADD                        0
+#  define X509V3_F_X509_PURPOSE_SET                        0
+
+/*
+ * Compatibility defines.
+ */
+# define EVP_R_OPERATON_NOT_INITIALIZED    EVP_R_OPERATION_NOT_INITIALIZED
+
+# endif
+
+# ifdef  __cplusplus
+}
+# endif
+#endif
diff --git a/src/include/openssl/ct.h b/src/include/openssl/ct.h
new file mode 100644
index 0000000..22c1514
--- /dev/null
+++ b/src/include/openssl/ct.h
@@ -0,0 +1,573 @@
+/*
+ * WARNING: do not edit!
+ * Generated by makefile from include\openssl\ct.h.in
+ *
+ * Copyright 2016-2020 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+
+
+#ifndef OPENSSL_CT_H
+# define OPENSSL_CT_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_CT_H
+# endif
+
+# include <openssl/opensslconf.h>
+
+# ifndef OPENSSL_NO_CT
+# include <openssl/types.h>
+# include <openssl/safestack.h>
+# include <openssl/x509.h>
+# include <openssl/cterr.h>
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+
+/* Minimum RSA key size, from RFC6962 */
+# define SCT_MIN_RSA_BITS 2048
+
+/* All hashes are SHA256 in v1 of Certificate Transparency */
+# define CT_V1_HASHLEN SHA256_DIGEST_LENGTH
+
+SKM_DEFINE_STACK_OF_INTERNAL(SCT, SCT, SCT)
+#define sk_SCT_num(sk) OPENSSL_sk_num(ossl_check_const_SCT_sk_type(sk))
+#define sk_SCT_value(sk, idx) ((SCT *)OPENSSL_sk_value(ossl_check_const_SCT_sk_type(sk), (idx)))
+#define sk_SCT_new(cmp) ((STACK_OF(SCT) *)OPENSSL_sk_new(ossl_check_SCT_compfunc_type(cmp)))
+#define sk_SCT_new_null() ((STACK_OF(SCT) *)OPENSSL_sk_new_null())
+#define sk_SCT_new_reserve(cmp, n) ((STACK_OF(SCT) *)OPENSSL_sk_new_reserve(ossl_check_SCT_compfunc_type(cmp), (n)))
+#define sk_SCT_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_SCT_sk_type(sk), (n))
+#define sk_SCT_free(sk) OPENSSL_sk_free(ossl_check_SCT_sk_type(sk))
+#define sk_SCT_zero(sk) OPENSSL_sk_zero(ossl_check_SCT_sk_type(sk))
+#define sk_SCT_delete(sk, i) ((SCT *)OPENSSL_sk_delete(ossl_check_SCT_sk_type(sk), (i)))
+#define sk_SCT_delete_ptr(sk, ptr) ((SCT *)OPENSSL_sk_delete_ptr(ossl_check_SCT_sk_type(sk), ossl_check_SCT_type(ptr)))
+#define sk_SCT_push(sk, ptr) OPENSSL_sk_push(ossl_check_SCT_sk_type(sk), ossl_check_SCT_type(ptr))
+#define sk_SCT_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_SCT_sk_type(sk), ossl_check_SCT_type(ptr))
+#define sk_SCT_pop(sk) ((SCT *)OPENSSL_sk_pop(ossl_check_SCT_sk_type(sk)))
+#define sk_SCT_shift(sk) ((SCT *)OPENSSL_sk_shift(ossl_check_SCT_sk_type(sk)))
+#define sk_SCT_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_SCT_sk_type(sk),ossl_check_SCT_freefunc_type(freefunc))
+#define sk_SCT_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_SCT_sk_type(sk), ossl_check_SCT_type(ptr), (idx))
+#define sk_SCT_set(sk, idx, ptr) ((SCT *)OPENSSL_sk_set(ossl_check_SCT_sk_type(sk), (idx), ossl_check_SCT_type(ptr)))
+#define sk_SCT_find(sk, ptr) OPENSSL_sk_find(ossl_check_SCT_sk_type(sk), ossl_check_SCT_type(ptr))
+#define sk_SCT_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_SCT_sk_type(sk), ossl_check_SCT_type(ptr))
+#define sk_SCT_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_SCT_sk_type(sk), ossl_check_SCT_type(ptr), pnum)
+#define sk_SCT_sort(sk) OPENSSL_sk_sort(ossl_check_SCT_sk_type(sk))
+#define sk_SCT_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_SCT_sk_type(sk))
+#define sk_SCT_dup(sk) ((STACK_OF(SCT) *)OPENSSL_sk_dup(ossl_check_const_SCT_sk_type(sk)))
+#define sk_SCT_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(SCT) *)OPENSSL_sk_deep_copy(ossl_check_const_SCT_sk_type(sk), ossl_check_SCT_copyfunc_type(copyfunc), ossl_check_SCT_freefunc_type(freefunc)))
+#define sk_SCT_set_cmp_func(sk, cmp) ((sk_SCT_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_SCT_sk_type(sk), ossl_check_SCT_compfunc_type(cmp)))
+SKM_DEFINE_STACK_OF_INTERNAL(CTLOG, CTLOG, CTLOG)
+#define sk_CTLOG_num(sk) OPENSSL_sk_num(ossl_check_const_CTLOG_sk_type(sk))
+#define sk_CTLOG_value(sk, idx) ((CTLOG *)OPENSSL_sk_value(ossl_check_const_CTLOG_sk_type(sk), (idx)))
+#define sk_CTLOG_new(cmp) ((STACK_OF(CTLOG) *)OPENSSL_sk_new(ossl_check_CTLOG_compfunc_type(cmp)))
+#define sk_CTLOG_new_null() ((STACK_OF(CTLOG) *)OPENSSL_sk_new_null())
+#define sk_CTLOG_new_reserve(cmp, n) ((STACK_OF(CTLOG) *)OPENSSL_sk_new_reserve(ossl_check_CTLOG_compfunc_type(cmp), (n)))
+#define sk_CTLOG_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_CTLOG_sk_type(sk), (n))
+#define sk_CTLOG_free(sk) OPENSSL_sk_free(ossl_check_CTLOG_sk_type(sk))
+#define sk_CTLOG_zero(sk) OPENSSL_sk_zero(ossl_check_CTLOG_sk_type(sk))
+#define sk_CTLOG_delete(sk, i) ((CTLOG *)OPENSSL_sk_delete(ossl_check_CTLOG_sk_type(sk), (i)))
+#define sk_CTLOG_delete_ptr(sk, ptr) ((CTLOG *)OPENSSL_sk_delete_ptr(ossl_check_CTLOG_sk_type(sk), ossl_check_CTLOG_type(ptr)))
+#define sk_CTLOG_push(sk, ptr) OPENSSL_sk_push(ossl_check_CTLOG_sk_type(sk), ossl_check_CTLOG_type(ptr))
+#define sk_CTLOG_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_CTLOG_sk_type(sk), ossl_check_CTLOG_type(ptr))
+#define sk_CTLOG_pop(sk) ((CTLOG *)OPENSSL_sk_pop(ossl_check_CTLOG_sk_type(sk)))
+#define sk_CTLOG_shift(sk) ((CTLOG *)OPENSSL_sk_shift(ossl_check_CTLOG_sk_type(sk)))
+#define sk_CTLOG_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_CTLOG_sk_type(sk),ossl_check_CTLOG_freefunc_type(freefunc))
+#define sk_CTLOG_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_CTLOG_sk_type(sk), ossl_check_CTLOG_type(ptr), (idx))
+#define sk_CTLOG_set(sk, idx, ptr) ((CTLOG *)OPENSSL_sk_set(ossl_check_CTLOG_sk_type(sk), (idx), ossl_check_CTLOG_type(ptr)))
+#define sk_CTLOG_find(sk, ptr) OPENSSL_sk_find(ossl_check_CTLOG_sk_type(sk), ossl_check_CTLOG_type(ptr))
+#define sk_CTLOG_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_CTLOG_sk_type(sk), ossl_check_CTLOG_type(ptr))
+#define sk_CTLOG_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_CTLOG_sk_type(sk), ossl_check_CTLOG_type(ptr), pnum)
+#define sk_CTLOG_sort(sk) OPENSSL_sk_sort(ossl_check_CTLOG_sk_type(sk))
+#define sk_CTLOG_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_CTLOG_sk_type(sk))
+#define sk_CTLOG_dup(sk) ((STACK_OF(CTLOG) *)OPENSSL_sk_dup(ossl_check_const_CTLOG_sk_type(sk)))
+#define sk_CTLOG_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(CTLOG) *)OPENSSL_sk_deep_copy(ossl_check_const_CTLOG_sk_type(sk), ossl_check_CTLOG_copyfunc_type(copyfunc), ossl_check_CTLOG_freefunc_type(freefunc)))
+#define sk_CTLOG_set_cmp_func(sk, cmp) ((sk_CTLOG_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_CTLOG_sk_type(sk), ossl_check_CTLOG_compfunc_type(cmp)))
+
+
+
+typedef enum {
+    CT_LOG_ENTRY_TYPE_NOT_SET = -1,
+    CT_LOG_ENTRY_TYPE_X509 = 0,
+    CT_LOG_ENTRY_TYPE_PRECERT = 1
+} ct_log_entry_type_t;
+
+typedef enum {
+    SCT_VERSION_NOT_SET = -1,
+    SCT_VERSION_V1 = 0
+} sct_version_t;
+
+typedef enum {
+    SCT_SOURCE_UNKNOWN,
+    SCT_SOURCE_TLS_EXTENSION,
+    SCT_SOURCE_X509V3_EXTENSION,
+    SCT_SOURCE_OCSP_STAPLED_RESPONSE
+} sct_source_t;
+
+typedef enum {
+    SCT_VALIDATION_STATUS_NOT_SET,
+    SCT_VALIDATION_STATUS_UNKNOWN_LOG,
+    SCT_VALIDATION_STATUS_VALID,
+    SCT_VALIDATION_STATUS_INVALID,
+    SCT_VALIDATION_STATUS_UNVERIFIED,
+    SCT_VALIDATION_STATUS_UNKNOWN_VERSION
+} sct_validation_status_t;
+
+/******************************************
+ * CT policy evaluation context functions *
+ ******************************************/
+
+/*
+ * Creates a new, empty policy evaluation context associated with the given
+ * library context and property query string.
+ * The caller is responsible for calling CT_POLICY_EVAL_CTX_free when finished
+ * with the CT_POLICY_EVAL_CTX.
+ */
+CT_POLICY_EVAL_CTX *CT_POLICY_EVAL_CTX_new_ex(OSSL_LIB_CTX *libctx,
+                                              const char *propq);
+
+/*
+ * The same as CT_POLICY_EVAL_CTX_new_ex() but the default library
+ * context and property query string is used.
+ */
+CT_POLICY_EVAL_CTX *CT_POLICY_EVAL_CTX_new(void);
+
+/* Deletes a policy evaluation context and anything it owns. */
+void CT_POLICY_EVAL_CTX_free(CT_POLICY_EVAL_CTX *ctx);
+
+/* Gets the peer certificate that the SCTs are for */
+X509* CT_POLICY_EVAL_CTX_get0_cert(const CT_POLICY_EVAL_CTX *ctx);
+
+/*
+ * Sets the certificate associated with the received SCTs.
+ * Increments the reference count of cert.
+ * Returns 1 on success, 0 otherwise.
+ */
+int CT_POLICY_EVAL_CTX_set1_cert(CT_POLICY_EVAL_CTX *ctx, X509 *cert);
+
+/* Gets the issuer of the aforementioned certificate */
+X509* CT_POLICY_EVAL_CTX_get0_issuer(const CT_POLICY_EVAL_CTX *ctx);
+
+/*
+ * Sets the issuer of the certificate associated with the received SCTs.
+ * Increments the reference count of issuer.
+ * Returns 1 on success, 0 otherwise.
+ */
+int CT_POLICY_EVAL_CTX_set1_issuer(CT_POLICY_EVAL_CTX *ctx, X509 *issuer);
+
+/* Gets the CT logs that are trusted sources of SCTs */
+const CTLOG_STORE *CT_POLICY_EVAL_CTX_get0_log_store(const CT_POLICY_EVAL_CTX *ctx);
+
+/* Sets the log store that is in use. It must outlive the CT_POLICY_EVAL_CTX. */
+void CT_POLICY_EVAL_CTX_set_shared_CTLOG_STORE(CT_POLICY_EVAL_CTX *ctx,
+                                               CTLOG_STORE *log_store);
+
+/*
+ * Gets the time, in milliseconds since the Unix epoch, that will be used as the
+ * current time when checking whether an SCT was issued in the future.
+ * Such SCTs will fail validation, as required by RFC6962.
+ */
+uint64_t CT_POLICY_EVAL_CTX_get_time(const CT_POLICY_EVAL_CTX *ctx);
+
+/*
+ * Sets the time to evaluate SCTs against, in milliseconds since the Unix epoch.
+ * If an SCT's timestamp is after this time, it will be interpreted as having
+ * been issued in the future. RFC6962 states that "TLS clients MUST reject SCTs
+ * whose timestamp is in the future", so an SCT will not validate in this case.
+ */
+void CT_POLICY_EVAL_CTX_set_time(CT_POLICY_EVAL_CTX *ctx, uint64_t time_in_ms);
+
+/*****************
+ * SCT functions *
+ *****************/
+
+/*
+ * Creates a new, blank SCT.
+ * The caller is responsible for calling SCT_free when finished with the SCT.
+ */
+SCT *SCT_new(void);
+
+/*
+ * Creates a new SCT from some base64-encoded strings.
+ * The caller is responsible for calling SCT_free when finished with the SCT.
+ */
+SCT *SCT_new_from_base64(unsigned char version,
+                         const char *logid_base64,
+                         ct_log_entry_type_t entry_type,
+                         uint64_t timestamp,
+                         const char *extensions_base64,
+                         const char *signature_base64);
+
+/*
+ * Frees the SCT and the underlying data structures.
+ */
+void SCT_free(SCT *sct);
+
+/*
+ * Free a stack of SCTs, and the underlying SCTs themselves.
+ * Intended to be compatible with X509V3_EXT_FREE.
+ */
+void SCT_LIST_free(STACK_OF(SCT) *a);
+
+/*
+ * Returns the version of the SCT.
+ */
+sct_version_t SCT_get_version(const SCT *sct);
+
+/*
+ * Set the version of an SCT.
+ * Returns 1 on success, 0 if the version is unrecognized.
+ */
+__owur int SCT_set_version(SCT *sct, sct_version_t version);
+
+/*
+ * Returns the log entry type of the SCT.
+ */
+ct_log_entry_type_t SCT_get_log_entry_type(const SCT *sct);
+
+/*
+ * Set the log entry type of an SCT.
+ * Returns 1 on success, 0 otherwise.
+ */
+__owur int SCT_set_log_entry_type(SCT *sct, ct_log_entry_type_t entry_type);
+
+/*
+ * Gets the ID of the log that an SCT came from.
+ * Ownership of the log ID remains with the SCT.
+ * Returns the length of the log ID.
+ */
+size_t SCT_get0_log_id(const SCT *sct, unsigned char **log_id);
+
+/*
+ * Set the log ID of an SCT to point directly to the *log_id specified.
+ * The SCT takes ownership of the specified pointer.
+ * Returns 1 on success, 0 otherwise.
+ */
+__owur int SCT_set0_log_id(SCT *sct, unsigned char *log_id, size_t log_id_len);
+
+/*
+ * Set the log ID of an SCT.
+ * This makes a copy of the log_id.
+ * Returns 1 on success, 0 otherwise.
+ */
+__owur int SCT_set1_log_id(SCT *sct, const unsigned char *log_id,
+                           size_t log_id_len);
+
+/*
+ * Returns the timestamp for the SCT (epoch time in milliseconds).
+ */
+uint64_t SCT_get_timestamp(const SCT *sct);
+
+/*
+ * Set the timestamp of an SCT (epoch time in milliseconds).
+ */
+void SCT_set_timestamp(SCT *sct, uint64_t timestamp);
+
+/*
+ * Return the NID for the signature used by the SCT.
+ * For CT v1, this will be either NID_sha256WithRSAEncryption or
+ * NID_ecdsa_with_SHA256 (or NID_undef if incorrect/unset).
+ */
+int SCT_get_signature_nid(const SCT *sct);
+
+/*
+ * Set the signature type of an SCT
+ * For CT v1, this should be either NID_sha256WithRSAEncryption or
+ * NID_ecdsa_with_SHA256.
+ * Returns 1 on success, 0 otherwise.
+ */
+__owur int SCT_set_signature_nid(SCT *sct, int nid);
+
+/*
+ * Set *ext to point to the extension data for the SCT. ext must not be NULL.
+ * The SCT retains ownership of this pointer.
+ * Returns length of the data pointed to.
+ */
+size_t SCT_get0_extensions(const SCT *sct, unsigned char **ext);
+
+/*
+ * Set the extensions of an SCT to point directly to the *ext specified.
+ * The SCT takes ownership of the specified pointer.
+ */
+void SCT_set0_extensions(SCT *sct, unsigned char *ext, size_t ext_len);
+
+/*
+ * Set the extensions of an SCT.
+ * This takes a copy of the ext.
+ * Returns 1 on success, 0 otherwise.
+ */
+__owur int SCT_set1_extensions(SCT *sct, const unsigned char *ext,
+                               size_t ext_len);
+
+/*
+ * Set *sig to point to the signature for the SCT. sig must not be NULL.
+ * The SCT retains ownership of this pointer.
+ * Returns length of the data pointed to.
+ */
+size_t SCT_get0_signature(const SCT *sct, unsigned char **sig);
+
+/*
+ * Set the signature of an SCT to point directly to the *sig specified.
+ * The SCT takes ownership of the specified pointer.
+ */
+void SCT_set0_signature(SCT *sct, unsigned char *sig, size_t sig_len);
+
+/*
+ * Set the signature of an SCT to be a copy of the *sig specified.
+ * Returns 1 on success, 0 otherwise.
+ */
+__owur int SCT_set1_signature(SCT *sct, const unsigned char *sig,
+                              size_t sig_len);
+
+/*
+ * The origin of this SCT, e.g. TLS extension, OCSP response, etc.
+ */
+sct_source_t SCT_get_source(const SCT *sct);
+
+/*
+ * Set the origin of this SCT, e.g. TLS extension, OCSP response, etc.
+ * Returns 1 on success, 0 otherwise.
+ */
+__owur int SCT_set_source(SCT *sct, sct_source_t source);
+
+/*
+ * Returns a text string describing the validation status of |sct|.
+ */
+const char *SCT_validation_status_string(const SCT *sct);
+
+/*
+ * Pretty-prints an |sct| to |out|.
+ * It will be indented by the number of spaces specified by |indent|.
+ * If |logs| is not NULL, it will be used to lookup the CT log that the SCT came
+ * from, so that the log name can be printed.
+ */
+void SCT_print(const SCT *sct, BIO *out, int indent, const CTLOG_STORE *logs);
+
+/*
+ * Pretty-prints an |sct_list| to |out|.
+ * It will be indented by the number of spaces specified by |indent|.
+ * SCTs will be delimited by |separator|.
+ * If |logs| is not NULL, it will be used to lookup the CT log that each SCT
+ * came from, so that the log names can be printed.
+ */
+void SCT_LIST_print(const STACK_OF(SCT) *sct_list, BIO *out, int indent,
+                    const char *separator, const CTLOG_STORE *logs);
+
+/*
+ * Gets the last result of validating this SCT.
+ * If it has not been validated yet, returns SCT_VALIDATION_STATUS_NOT_SET.
+ */
+sct_validation_status_t SCT_get_validation_status(const SCT *sct);
+
+/*
+ * Validates the given SCT with the provided context.
+ * Sets the "validation_status" field of the SCT.
+ * Returns 1 if the SCT is valid and the signature verifies.
+ * Returns 0 if the SCT is invalid or could not be verified.
+ * Returns -1 if an error occurs.
+ */
+__owur int SCT_validate(SCT *sct, const CT_POLICY_EVAL_CTX *ctx);
+
+/*
+ * Validates the given list of SCTs with the provided context.
+ * Sets the "validation_status" field of each SCT.
+ * Returns 1 if there are no invalid SCTs and all signatures verify.
+ * Returns 0 if at least one SCT is invalid or could not be verified.
+ * Returns a negative integer if an error occurs.
+ */
+__owur int SCT_LIST_validate(const STACK_OF(SCT) *scts,
+                             CT_POLICY_EVAL_CTX *ctx);
+
+
+/*********************************
+ * SCT parsing and serialization *
+ *********************************/
+
+/*
+ * Serialize (to TLS format) a stack of SCTs and return the length.
+ * "a" must not be NULL.
+ * If "pp" is NULL, just return the length of what would have been serialized.
+ * If "pp" is not NULL and "*pp" is null, function will allocate a new pointer
+ * for data that caller is responsible for freeing (only if function returns
+ * successfully).
+ * If "pp" is NULL and "*pp" is not NULL, caller is responsible for ensuring
+ * that "*pp" is large enough to accept all of the serialized data.
+ * Returns < 0 on error, >= 0 indicating bytes written (or would have been)
+ * on success.
+ */
+__owur int i2o_SCT_LIST(const STACK_OF(SCT) *a, unsigned char **pp);
+
+/*
+ * Convert TLS format SCT list to a stack of SCTs.
+ * If "a" or "*a" is NULL, a new stack will be created that the caller is
+ * responsible for freeing (by calling SCT_LIST_free).
+ * "**pp" and "*pp" must not be NULL.
+ * Upon success, "*pp" will point to after the last bytes read, and a stack
+ * will be returned.
+ * Upon failure, a NULL pointer will be returned, and the position of "*pp" is
+ * not defined.
+ */
+STACK_OF(SCT) *o2i_SCT_LIST(STACK_OF(SCT) **a, const unsigned char **pp,
+                            size_t len);
+
+/*
+ * Serialize (to DER format) a stack of SCTs and return the length.
+ * "a" must not be NULL.
+ * If "pp" is NULL, just returns the length of what would have been serialized.
+ * If "pp" is not NULL and "*pp" is null, function will allocate a new pointer
+ * for data that caller is responsible for freeing (only if function returns
+ * successfully).
+ * If "pp" is NULL and "*pp" is not NULL, caller is responsible for ensuring
+ * that "*pp" is large enough to accept all of the serialized data.
+ * Returns < 0 on error, >= 0 indicating bytes written (or would have been)
+ * on success.
+ */
+__owur int i2d_SCT_LIST(const STACK_OF(SCT) *a, unsigned char **pp);
+
+/*
+ * Parses an SCT list in DER format and returns it.
+ * If "a" or "*a" is NULL, a new stack will be created that the caller is
+ * responsible for freeing (by calling SCT_LIST_free).
+ * "**pp" and "*pp" must not be NULL.
+ * Upon success, "*pp" will point to after the last bytes read, and a stack
+ * will be returned.
+ * Upon failure, a NULL pointer will be returned, and the position of "*pp" is
+ * not defined.
+ */
+STACK_OF(SCT) *d2i_SCT_LIST(STACK_OF(SCT) **a, const unsigned char **pp,
+                            long len);
+
+/*
+ * Serialize (to TLS format) an |sct| and write it to |out|.
+ * If |out| is null, no SCT will be output but the length will still be returned.
+ * If |out| points to a null pointer, a string will be allocated to hold the
+ * TLS-format SCT. It is the responsibility of the caller to free it.
+ * If |out| points to an allocated string, the TLS-format SCT will be written
+ * to it.
+ * The length of the SCT in TLS format will be returned.
+ */
+__owur int i2o_SCT(const SCT *sct, unsigned char **out);
+
+/*
+ * Parses an SCT in TLS format and returns it.
+ * If |psct| is not null, it will end up pointing to the parsed SCT. If it
+ * already points to a non-null pointer, the pointer will be free'd.
+ * |in| should be a pointer to a string containing the TLS-format SCT.
+ * |in| will be advanced to the end of the SCT if parsing succeeds.
+ * |len| should be the length of the SCT in |in|.
+ * Returns NULL if an error occurs.
+ * If the SCT is an unsupported version, only the SCT's 'sct' and 'sct_len'
+ * fields will be populated (with |in| and |len| respectively).
+ */
+SCT *o2i_SCT(SCT **psct, const unsigned char **in, size_t len);
+
+/********************
+ * CT log functions *
+ ********************/
+
+/*
+ * Creates a new CT log instance with the given |public_key| and |name| and
+ * associates it with the give library context |libctx| and property query
+ * string |propq|.
+ * Takes ownership of |public_key| but copies |name|.
+ * Returns NULL if malloc fails or if |public_key| cannot be converted to DER.
+ * Should be deleted by the caller using CTLOG_free when no longer needed.
+ */
+CTLOG *CTLOG_new_ex(EVP_PKEY *public_key, const char *name, OSSL_LIB_CTX *libctx,
+                    const char *propq);
+
+/*
+ * The same as CTLOG_new_ex except that the default library context and
+ * property query string are used.
+ */
+CTLOG *CTLOG_new(EVP_PKEY *public_key, const char *name);
+
+/*
+ * Creates a new CTLOG instance with the base64-encoded SubjectPublicKeyInfo DER
+ * in |pkey_base64| and associated with the given library context |libctx| and
+ * property query string |propq|. The |name| is a string to help users identify
+ * this log.
+ * Returns 1 on success, 0 on failure.
+ * Should be deleted by the caller using CTLOG_free when no longer needed.
+ */
+int CTLOG_new_from_base64_ex(CTLOG **ct_log, const char *pkey_base64,
+                             const char *name, OSSL_LIB_CTX *libctx,
+                             const char *propq);
+
+/*
+ * The same as CTLOG_new_from_base64_ex() except that the default
+ * library context and property query string are used.
+ * Returns 1 on success, 0 on failure.
+ */
+int CTLOG_new_from_base64(CTLOG ** ct_log,
+                          const char *pkey_base64, const char *name);
+
+/*
+ * Deletes a CT log instance and its fields.
+ */
+void CTLOG_free(CTLOG *log);
+
+/* Gets the name of the CT log */
+const char *CTLOG_get0_name(const CTLOG *log);
+/* Gets the ID of the CT log */
+void CTLOG_get0_log_id(const CTLOG *log, const uint8_t **log_id,
+                       size_t *log_id_len);
+/* Gets the public key of the CT log */
+EVP_PKEY *CTLOG_get0_public_key(const CTLOG *log);
+
+/**************************
+ * CT log store functions *
+ **************************/
+
+/*
+ * Creates a new CT log store and associates it with the given libctx and
+ * property query string.
+ * Should be deleted by the caller using CTLOG_STORE_free when no longer needed.
+ */
+CTLOG_STORE *CTLOG_STORE_new_ex(OSSL_LIB_CTX *libctx, const char *propq);
+
+/*
+ * Same as CTLOG_STORE_new_ex except that the default libctx and
+ * property query string are used.
+ * Should be deleted by the caller using CTLOG_STORE_free when no longer needed.
+ */
+CTLOG_STORE *CTLOG_STORE_new(void);
+
+/*
+ * Deletes a CT log store and all of the CT log instances held within.
+ */
+void CTLOG_STORE_free(CTLOG_STORE *store);
+
+/*
+ * Finds a CT log in the store based on its log ID.
+ * Returns the CT log, or NULL if no match is found.
+ */
+const CTLOG *CTLOG_STORE_get0_log_by_id(const CTLOG_STORE *store,
+                                        const uint8_t *log_id,
+                                        size_t log_id_len);
+
+/*
+ * Loads a CT log list into a |store| from a |file|.
+ * Returns 1 if loading is successful, or 0 otherwise.
+ */
+__owur int CTLOG_STORE_load_file(CTLOG_STORE *store, const char *file);
+
+/*
+ * Loads the default CT log list into a |store|.
+ * Returns 1 if loading is successful, or 0 otherwise.
+ */
+__owur int CTLOG_STORE_load_default_file(CTLOG_STORE *store);
+
+#  ifdef  __cplusplus
+}
+#  endif
+# endif
+#endif
diff --git a/src/include/openssl/cterr.h b/src/include/openssl/cterr.h
new file mode 100644
index 0000000..935d32d
--- /dev/null
+++ b/src/include/openssl/cterr.h
@@ -0,0 +1,45 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_CTERR_H
+# define OPENSSL_CTERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+# ifndef OPENSSL_NO_CT
+
+
+/*
+ * CT reason codes.
+ */
+#  define CT_R_BASE64_DECODE_ERROR                         108
+#  define CT_R_INVALID_LOG_ID_LENGTH                       100
+#  define CT_R_LOG_CONF_INVALID                            109
+#  define CT_R_LOG_CONF_INVALID_KEY                        110
+#  define CT_R_LOG_CONF_MISSING_DESCRIPTION                111
+#  define CT_R_LOG_CONF_MISSING_KEY                        112
+#  define CT_R_LOG_KEY_INVALID                             113
+#  define CT_R_SCT_FUTURE_TIMESTAMP                        116
+#  define CT_R_SCT_INVALID                                 104
+#  define CT_R_SCT_INVALID_SIGNATURE                       107
+#  define CT_R_SCT_LIST_INVALID                            105
+#  define CT_R_SCT_LOG_ID_MISMATCH                         114
+#  define CT_R_SCT_NOT_SET                                 106
+#  define CT_R_SCT_UNSUPPORTED_VERSION                     115
+#  define CT_R_UNRECOGNIZED_SIGNATURE_NID                  101
+#  define CT_R_UNSUPPORTED_ENTRY_TYPE                      102
+#  define CT_R_UNSUPPORTED_VERSION                         103
+
+# endif
+#endif
diff --git a/src/include/openssl/decoder.h b/src/include/openssl/decoder.h
new file mode 100644
index 0000000..d4ee2cf
--- /dev/null
+++ b/src/include/openssl/decoder.h
@@ -0,0 +1,133 @@
+/*
+ * Copyright 2020-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_DECODER_H
+# define OPENSSL_DECODER_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+
+# ifndef OPENSSL_NO_STDIO
+#  include <stdio.h>
+# endif
+# include <stdarg.h>
+# include <stddef.h>
+# include <openssl/decodererr.h>
+# include <openssl/types.h>
+# include <openssl/core.h>
+
+# ifdef __cplusplus
+extern "C" {
+# endif
+
+OSSL_DECODER *OSSL_DECODER_fetch(OSSL_LIB_CTX *libctx, const char *name,
+                                 const char *properties);
+int OSSL_DECODER_up_ref(OSSL_DECODER *encoder);
+void OSSL_DECODER_free(OSSL_DECODER *encoder);
+
+const OSSL_PROVIDER *OSSL_DECODER_get0_provider(const OSSL_DECODER *encoder);
+const char *OSSL_DECODER_get0_properties(const OSSL_DECODER *encoder);
+const char *OSSL_DECODER_get0_name(const OSSL_DECODER *decoder);
+const char *OSSL_DECODER_get0_description(const OSSL_DECODER *decoder);
+int OSSL_DECODER_is_a(const OSSL_DECODER *encoder, const char *name);
+
+void OSSL_DECODER_do_all_provided(OSSL_LIB_CTX *libctx,
+                                  void (*fn)(OSSL_DECODER *encoder, void *arg),
+                                  void *arg);
+int OSSL_DECODER_names_do_all(const OSSL_DECODER *encoder,
+                              void (*fn)(const char *name, void *data),
+                              void *data);
+const OSSL_PARAM *OSSL_DECODER_gettable_params(OSSL_DECODER *decoder);
+int OSSL_DECODER_get_params(OSSL_DECODER *decoder, OSSL_PARAM params[]);
+
+const OSSL_PARAM *OSSL_DECODER_settable_ctx_params(OSSL_DECODER *encoder);
+OSSL_DECODER_CTX *OSSL_DECODER_CTX_new(void);
+int OSSL_DECODER_CTX_set_params(OSSL_DECODER_CTX *ctx,
+                                const OSSL_PARAM params[]);
+void OSSL_DECODER_CTX_free(OSSL_DECODER_CTX *ctx);
+
+/* Utilities that help set specific parameters */
+int OSSL_DECODER_CTX_set_passphrase(OSSL_DECODER_CTX *ctx,
+                                    const unsigned char *kstr, size_t klen);
+int OSSL_DECODER_CTX_set_pem_password_cb(OSSL_DECODER_CTX *ctx,
+                                         pem_password_cb *cb, void *cbarg);
+int OSSL_DECODER_CTX_set_passphrase_cb(OSSL_DECODER_CTX *ctx,
+                                       OSSL_PASSPHRASE_CALLBACK *cb,
+                                       void *cbarg);
+int OSSL_DECODER_CTX_set_passphrase_ui(OSSL_DECODER_CTX *ctx,
+                                       const UI_METHOD *ui_method,
+                                       void *ui_data);
+
+/*
+ * Utilities to read the object to decode, with the result sent to cb.
+ * These will discover all provided methods
+ */
+
+int OSSL_DECODER_CTX_set_selection(OSSL_DECODER_CTX *ctx, int selection);
+int OSSL_DECODER_CTX_set_input_type(OSSL_DECODER_CTX *ctx,
+                                    const char *input_type);
+int OSSL_DECODER_CTX_set_input_structure(OSSL_DECODER_CTX *ctx,
+                                         const char *input_structure);
+int OSSL_DECODER_CTX_add_decoder(OSSL_DECODER_CTX *ctx, OSSL_DECODER *decoder);
+int OSSL_DECODER_CTX_add_extra(OSSL_DECODER_CTX *ctx,
+                               OSSL_LIB_CTX *libctx, const char *propq);
+int OSSL_DECODER_CTX_get_num_decoders(OSSL_DECODER_CTX *ctx);
+
+typedef struct ossl_decoder_instance_st OSSL_DECODER_INSTANCE;
+OSSL_DECODER *
+OSSL_DECODER_INSTANCE_get_decoder(OSSL_DECODER_INSTANCE *decoder_inst);
+void *
+OSSL_DECODER_INSTANCE_get_decoder_ctx(OSSL_DECODER_INSTANCE *decoder_inst);
+const char *
+OSSL_DECODER_INSTANCE_get_input_type(OSSL_DECODER_INSTANCE *decoder_inst);
+const char *
+OSSL_DECODER_INSTANCE_get_input_structure(OSSL_DECODER_INSTANCE *decoder_inst,
+                                          int *was_set);
+
+typedef int OSSL_DECODER_CONSTRUCT(OSSL_DECODER_INSTANCE *decoder_inst,
+                                   const OSSL_PARAM *params,
+                                   void *construct_data);
+typedef void OSSL_DECODER_CLEANUP(void *construct_data);
+
+int OSSL_DECODER_CTX_set_construct(OSSL_DECODER_CTX *ctx,
+                                   OSSL_DECODER_CONSTRUCT *construct);
+int OSSL_DECODER_CTX_set_construct_data(OSSL_DECODER_CTX *ctx,
+                                        void *construct_data);
+int OSSL_DECODER_CTX_set_cleanup(OSSL_DECODER_CTX *ctx,
+                                 OSSL_DECODER_CLEANUP *cleanup);
+OSSL_DECODER_CONSTRUCT *OSSL_DECODER_CTX_get_construct(OSSL_DECODER_CTX *ctx);
+void *OSSL_DECODER_CTX_get_construct_data(OSSL_DECODER_CTX *ctx);
+OSSL_DECODER_CLEANUP *OSSL_DECODER_CTX_get_cleanup(OSSL_DECODER_CTX *ctx);
+
+int OSSL_DECODER_export(OSSL_DECODER_INSTANCE *decoder_inst,
+                        void *reference, size_t reference_sz,
+                        OSSL_CALLBACK *export_cb, void *export_cbarg);
+
+int OSSL_DECODER_from_bio(OSSL_DECODER_CTX *ctx, BIO *in);
+#ifndef OPENSSL_NO_STDIO
+int OSSL_DECODER_from_fp(OSSL_DECODER_CTX *ctx, FILE *in);
+#endif
+int OSSL_DECODER_from_data(OSSL_DECODER_CTX *ctx, const unsigned char **pdata,
+                           size_t *pdata_len);
+
+/*
+ * Create the OSSL_DECODER_CTX with an associated type.  This will perform
+ * an implicit OSSL_DECODER_fetch(), suitable for the object of that type.
+ */
+OSSL_DECODER_CTX *
+OSSL_DECODER_CTX_new_for_pkey(EVP_PKEY **pkey,
+                              const char *input_type,
+                              const char *input_struct,
+                              const char *keytype, int selection,
+                              OSSL_LIB_CTX *libctx, const char *propquery);
+
+# ifdef __cplusplus
+}
+# endif
+#endif
diff --git a/src/include/openssl/decodererr.h b/src/include/openssl/decodererr.h
new file mode 100644
index 0000000..4212a38
--- /dev/null
+++ b/src/include/openssl/decodererr.h
@@ -0,0 +1,28 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_DECODERERR_H
+# define OPENSSL_DECODERERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+
+/*
+ * OSSL_DECODER reason codes.
+ */
+# define OSSL_DECODER_R_COULD_NOT_DECODE_OBJECT           101
+# define OSSL_DECODER_R_DECODER_NOT_FOUND                 102
+# define OSSL_DECODER_R_MISSING_GET_PARAMS                100
+
+#endif
diff --git a/src/include/openssl/des.h b/src/include/openssl/des.h
new file mode 100644
index 0000000..09798a6
--- /dev/null
+++ b/src/include/openssl/des.h
@@ -0,0 +1,211 @@
+/*
+ * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_DES_H
+# define OPENSSL_DES_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_DES_H
+# endif
+
+# include <openssl/opensslconf.h>
+
+# ifndef OPENSSL_NO_DES
+#  ifdef  __cplusplus
+extern "C" {
+#  endif
+#  include <openssl/e_os2.h>
+
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+typedef unsigned int DES_LONG;
+
+#   ifdef OPENSSL_BUILD_SHLIBCRYPTO
+#    undef OPENSSL_EXTERN
+#    define OPENSSL_EXTERN OPENSSL_EXPORT
+#   endif
+
+typedef unsigned char DES_cblock[8];
+typedef /* const */ unsigned char const_DES_cblock[8];
+/*
+ * With "const", gcc 2.8.1 on Solaris thinks that DES_cblock * and
+ * const_DES_cblock * are incompatible pointer types.
+ */
+
+typedef struct DES_ks {
+    union {
+        DES_cblock cblock;
+        /*
+         * make sure things are correct size on machines with 8 byte longs
+         */
+        DES_LONG deslong[2];
+    } ks[16];
+} DES_key_schedule;
+
+#   define DES_KEY_SZ      (sizeof(DES_cblock))
+#   define DES_SCHEDULE_SZ (sizeof(DES_key_schedule))
+
+#   define DES_ENCRYPT     1
+#   define DES_DECRYPT     0
+
+#   define DES_CBC_MODE    0
+#   define DES_PCBC_MODE   1
+
+#   define DES_ecb2_encrypt(i,o,k1,k2,e) \
+        DES_ecb3_encrypt((i),(o),(k1),(k2),(k1),(e))
+
+#   define DES_ede2_cbc_encrypt(i,o,l,k1,k2,iv,e) \
+        DES_ede3_cbc_encrypt((i),(o),(l),(k1),(k2),(k1),(iv),(e))
+
+#   define DES_ede2_cfb64_encrypt(i,o,l,k1,k2,iv,n,e) \
+        DES_ede3_cfb64_encrypt((i),(o),(l),(k1),(k2),(k1),(iv),(n),(e))
+
+#   define DES_ede2_ofb64_encrypt(i,o,l,k1,k2,iv,n) \
+        DES_ede3_ofb64_encrypt((i),(o),(l),(k1),(k2),(k1),(iv),(n))
+
+#   define DES_fixup_key_parity DES_set_odd_parity
+#  endif
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 const char *DES_options(void);
+OSSL_DEPRECATEDIN_3_0
+void DES_ecb3_encrypt(const_DES_cblock *input, DES_cblock *output,
+                      DES_key_schedule *ks1, DES_key_schedule *ks2,
+                      DES_key_schedule *ks3, int enc);
+OSSL_DEPRECATEDIN_3_0
+DES_LONG DES_cbc_cksum(const unsigned char *input, DES_cblock *output,
+                       long length, DES_key_schedule *schedule,
+                       const_DES_cblock *ivec);
+#  endif
+/* DES_cbc_encrypt does not update the IV!  Use DES_ncbc_encrypt instead. */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+void DES_cbc_encrypt(const unsigned char *input, unsigned char *output,
+                     long length, DES_key_schedule *schedule, DES_cblock *ivec,
+                     int enc);
+OSSL_DEPRECATEDIN_3_0
+void DES_ncbc_encrypt(const unsigned char *input, unsigned char *output,
+                      long length, DES_key_schedule *schedule, DES_cblock *ivec,
+                      int enc);
+OSSL_DEPRECATEDIN_3_0
+void DES_xcbc_encrypt(const unsigned char *input, unsigned char *output,
+                      long length, DES_key_schedule *schedule, DES_cblock *ivec,
+                      const_DES_cblock *inw, const_DES_cblock *outw, int enc);
+OSSL_DEPRECATEDIN_3_0
+void DES_cfb_encrypt(const unsigned char *in, unsigned char *out, int numbits,
+                     long length, DES_key_schedule *schedule, DES_cblock *ivec,
+                     int enc);
+OSSL_DEPRECATEDIN_3_0
+void DES_ecb_encrypt(const_DES_cblock *input, DES_cblock *output,
+                     DES_key_schedule *ks, int enc);
+#  endif
+
+/*
+ * This is the DES encryption function that gets called by just about every
+ * other DES routine in the library.  You should not use this function except
+ * to implement 'modes' of DES.  I say this because the functions that call
+ * this routine do the conversion from 'char *' to long, and this needs to be
+ * done to make sure 'non-aligned' memory access do not occur.  The
+ * characters are loaded 'little endian'. Data is a pointer to 2 unsigned
+ * long's and ks is the DES_key_schedule to use.  enc, is non zero specifies
+ * encryption, zero if decryption.
+ */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+void DES_encrypt1(DES_LONG *data, DES_key_schedule *ks, int enc);
+#  endif
+
+/*
+ * This functions is the same as DES_encrypt1() except that the DES initial
+ * permutation (IP) and final permutation (FP) have been left out.  As for
+ * DES_encrypt1(), you should not use this function. It is used by the
+ * routines in the library that implement triple DES. IP() DES_encrypt2()
+ * DES_encrypt2() DES_encrypt2() FP() is the same as DES_encrypt1()
+ * DES_encrypt1() DES_encrypt1() except faster :-).
+ */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+void DES_encrypt2(DES_LONG *data, DES_key_schedule *ks, int enc);
+OSSL_DEPRECATEDIN_3_0
+void DES_encrypt3(DES_LONG *data, DES_key_schedule *ks1, DES_key_schedule *ks2,
+                  DES_key_schedule *ks3);
+OSSL_DEPRECATEDIN_3_0
+void DES_decrypt3(DES_LONG *data, DES_key_schedule *ks1, DES_key_schedule *ks2,
+                  DES_key_schedule *ks3);
+OSSL_DEPRECATEDIN_3_0
+void DES_ede3_cbc_encrypt(const unsigned char *input, unsigned char *output,
+                          long length, DES_key_schedule *ks1,
+                          DES_key_schedule *ks2, DES_key_schedule *ks3,
+                          DES_cblock *ivec, int enc);
+OSSL_DEPRECATEDIN_3_0
+void DES_ede3_cfb64_encrypt(const unsigned char *in, unsigned char *out,
+                            long length, DES_key_schedule *ks1,
+                            DES_key_schedule *ks2, DES_key_schedule *ks3,
+                            DES_cblock *ivec, int *num, int enc);
+OSSL_DEPRECATEDIN_3_0
+void DES_ede3_cfb_encrypt(const unsigned char *in, unsigned char *out,
+                          int numbits, long length, DES_key_schedule *ks1,
+                          DES_key_schedule *ks2, DES_key_schedule *ks3,
+                          DES_cblock *ivec, int enc);
+OSSL_DEPRECATEDIN_3_0
+void DES_ede3_ofb64_encrypt(const unsigned char *in, unsigned char *out,
+                            long length, DES_key_schedule *ks1,
+                            DES_key_schedule *ks2, DES_key_schedule *ks3,
+                            DES_cblock *ivec, int *num);
+OSSL_DEPRECATEDIN_3_0
+char *DES_fcrypt(const char *buf, const char *salt, char *ret);
+OSSL_DEPRECATEDIN_3_0
+char *DES_crypt(const char *buf, const char *salt);
+OSSL_DEPRECATEDIN_3_0
+void DES_ofb_encrypt(const unsigned char *in, unsigned char *out, int numbits,
+                     long length, DES_key_schedule *schedule, DES_cblock *ivec);
+OSSL_DEPRECATEDIN_3_0
+void DES_pcbc_encrypt(const unsigned char *input, unsigned char *output,
+                      long length, DES_key_schedule *schedule,
+                      DES_cblock *ivec, int enc);
+OSSL_DEPRECATEDIN_3_0
+DES_LONG DES_quad_cksum(const unsigned char *input, DES_cblock output[],
+                        long length, int out_count, DES_cblock *seed);
+OSSL_DEPRECATEDIN_3_0 int DES_random_key(DES_cblock *ret);
+OSSL_DEPRECATEDIN_3_0 void DES_set_odd_parity(DES_cblock *key);
+OSSL_DEPRECATEDIN_3_0 int DES_check_key_parity(const_DES_cblock *key);
+OSSL_DEPRECATEDIN_3_0 int DES_is_weak_key(const_DES_cblock *key);
+#  endif
+/*
+ * DES_set_key (= set_key = DES_key_sched = key_sched) calls
+ * DES_set_key_checked
+ */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+int DES_set_key(const_DES_cblock *key, DES_key_schedule *schedule);
+OSSL_DEPRECATEDIN_3_0
+int DES_key_sched(const_DES_cblock *key, DES_key_schedule *schedule);
+OSSL_DEPRECATEDIN_3_0
+int DES_set_key_checked(const_DES_cblock *key, DES_key_schedule *schedule);
+OSSL_DEPRECATEDIN_3_0
+void DES_set_key_unchecked(const_DES_cblock *key, DES_key_schedule *schedule);
+OSSL_DEPRECATEDIN_3_0 void DES_string_to_key(const char *str, DES_cblock *key);
+OSSL_DEPRECATEDIN_3_0
+void DES_string_to_2keys(const char *str, DES_cblock *key1, DES_cblock *key2);
+OSSL_DEPRECATEDIN_3_0
+void DES_cfb64_encrypt(const unsigned char *in, unsigned char *out,
+                       long length, DES_key_schedule *schedule,
+                       DES_cblock *ivec, int *num, int enc);
+OSSL_DEPRECATEDIN_3_0
+void DES_ofb64_encrypt(const unsigned char *in, unsigned char *out,
+                       long length, DES_key_schedule *schedule,
+                       DES_cblock *ivec, int *num);
+#  endif
+
+#  ifdef  __cplusplus
+}
+#  endif
+# endif
+
+#endif
diff --git a/src/include/openssl/dh.h b/src/include/openssl/dh.h
new file mode 100644
index 0000000..9702492
--- /dev/null
+++ b/src/include/openssl/dh.h
@@ -0,0 +1,339 @@
+/*
+ * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_DH_H
+# define OPENSSL_DH_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_DH_H
+# endif
+
+# include <openssl/opensslconf.h>
+# include <openssl/types.h>
+
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+#include <stdlib.h>
+
+/*
+ * DH parameter generation types used by EVP_PKEY_CTX_set_dh_paramgen_type()
+ * Note that additions/changes to this set of values requires corresponding
+ * adjustments to range checks in dh_gen()
+ */
+# define DH_PARAMGEN_TYPE_GENERATOR     0   /* Use a safe prime generator */
+# define DH_PARAMGEN_TYPE_FIPS_186_2    1   /* Use FIPS186-2 standard */
+# define DH_PARAMGEN_TYPE_FIPS_186_4    2   /* Use FIPS186-4 standard */
+# define DH_PARAMGEN_TYPE_GROUP         3   /* Use a named safe prime group */
+
+int EVP_PKEY_CTX_set_dh_paramgen_type(EVP_PKEY_CTX *ctx, int typ);
+int EVP_PKEY_CTX_set_dh_paramgen_gindex(EVP_PKEY_CTX *ctx, int gindex);
+int EVP_PKEY_CTX_set_dh_paramgen_seed(EVP_PKEY_CTX *ctx,
+                                      const unsigned char *seed,
+                                      size_t seedlen);
+int EVP_PKEY_CTX_set_dh_paramgen_prime_len(EVP_PKEY_CTX *ctx, int pbits);
+int EVP_PKEY_CTX_set_dh_paramgen_subprime_len(EVP_PKEY_CTX *ctx, int qlen);
+int EVP_PKEY_CTX_set_dh_paramgen_generator(EVP_PKEY_CTX *ctx, int gen);
+int EVP_PKEY_CTX_set_dh_nid(EVP_PKEY_CTX *ctx, int nid);
+int EVP_PKEY_CTX_set_dh_rfc5114(EVP_PKEY_CTX *ctx, int gen);
+int EVP_PKEY_CTX_set_dhx_rfc5114(EVP_PKEY_CTX *ctx, int gen);
+int EVP_PKEY_CTX_set_dh_pad(EVP_PKEY_CTX *ctx, int pad);
+
+int EVP_PKEY_CTX_set_dh_kdf_type(EVP_PKEY_CTX *ctx, int kdf);
+int EVP_PKEY_CTX_get_dh_kdf_type(EVP_PKEY_CTX *ctx);
+int EVP_PKEY_CTX_set0_dh_kdf_oid(EVP_PKEY_CTX *ctx, ASN1_OBJECT *oid);
+int EVP_PKEY_CTX_get0_dh_kdf_oid(EVP_PKEY_CTX *ctx, ASN1_OBJECT **oid);
+int EVP_PKEY_CTX_set_dh_kdf_md(EVP_PKEY_CTX *ctx, const EVP_MD *md);
+int EVP_PKEY_CTX_get_dh_kdf_md(EVP_PKEY_CTX *ctx, const EVP_MD **md);
+int EVP_PKEY_CTX_set_dh_kdf_outlen(EVP_PKEY_CTX *ctx, int len);
+int EVP_PKEY_CTX_get_dh_kdf_outlen(EVP_PKEY_CTX *ctx, int *len);
+int EVP_PKEY_CTX_set0_dh_kdf_ukm(EVP_PKEY_CTX *ctx, unsigned char *ukm, int len);
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+int EVP_PKEY_CTX_get0_dh_kdf_ukm(EVP_PKEY_CTX *ctx, unsigned char **ukm);
+#endif
+
+# define EVP_PKEY_CTRL_DH_PARAMGEN_PRIME_LEN     (EVP_PKEY_ALG_CTRL + 1)
+# define EVP_PKEY_CTRL_DH_PARAMGEN_GENERATOR     (EVP_PKEY_ALG_CTRL + 2)
+# define EVP_PKEY_CTRL_DH_RFC5114                (EVP_PKEY_ALG_CTRL + 3)
+# define EVP_PKEY_CTRL_DH_PARAMGEN_SUBPRIME_LEN  (EVP_PKEY_ALG_CTRL + 4)
+# define EVP_PKEY_CTRL_DH_PARAMGEN_TYPE          (EVP_PKEY_ALG_CTRL + 5)
+# define EVP_PKEY_CTRL_DH_KDF_TYPE               (EVP_PKEY_ALG_CTRL + 6)
+# define EVP_PKEY_CTRL_DH_KDF_MD                 (EVP_PKEY_ALG_CTRL + 7)
+# define EVP_PKEY_CTRL_GET_DH_KDF_MD             (EVP_PKEY_ALG_CTRL + 8)
+# define EVP_PKEY_CTRL_DH_KDF_OUTLEN             (EVP_PKEY_ALG_CTRL + 9)
+# define EVP_PKEY_CTRL_GET_DH_KDF_OUTLEN         (EVP_PKEY_ALG_CTRL + 10)
+# define EVP_PKEY_CTRL_DH_KDF_UKM                (EVP_PKEY_ALG_CTRL + 11)
+# define EVP_PKEY_CTRL_GET_DH_KDF_UKM            (EVP_PKEY_ALG_CTRL + 12)
+# define EVP_PKEY_CTRL_DH_KDF_OID                (EVP_PKEY_ALG_CTRL + 13)
+# define EVP_PKEY_CTRL_GET_DH_KDF_OID            (EVP_PKEY_ALG_CTRL + 14)
+# define EVP_PKEY_CTRL_DH_NID                    (EVP_PKEY_ALG_CTRL + 15)
+# define EVP_PKEY_CTRL_DH_PAD                    (EVP_PKEY_ALG_CTRL + 16)
+
+/* KDF types */
+# define EVP_PKEY_DH_KDF_NONE                            1
+# define EVP_PKEY_DH_KDF_X9_42                           2
+
+# ifndef OPENSSL_NO_STDIO
+#  include <stdio.h>
+# endif
+# ifndef OPENSSL_NO_DH
+#  include <openssl/e_os2.h>
+#  include <openssl/bio.h>
+#  include <openssl/asn1.h>
+#  ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#   include <openssl/bn.h>
+#  endif
+#  include <openssl/dherr.h>
+
+#  ifndef OPENSSL_DH_MAX_MODULUS_BITS
+#   define OPENSSL_DH_MAX_MODULUS_BITS        10000
+#  endif
+
+#  ifndef OPENSSL_DH_CHECK_MAX_MODULUS_BITS
+#   define OPENSSL_DH_CHECK_MAX_MODULUS_BITS  32768
+#  endif
+
+#  define OPENSSL_DH_FIPS_MIN_MODULUS_BITS 1024
+
+#  define DH_FLAG_CACHE_MONT_P     0x01
+
+#  define DH_FLAG_TYPE_MASK             0xF000
+#  define DH_FLAG_TYPE_DH               0x0000
+#  define DH_FLAG_TYPE_DHX              0x1000
+
+#  ifndef OPENSSL_NO_DEPRECATED_1_1_0
+/*
+ * Does nothing. Previously this switched off constant time behaviour.
+ */
+#   define DH_FLAG_NO_EXP_CONSTTIME 0x00
+#  endif
+
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+/*
+ * If this flag is set the DH method is FIPS compliant and can be used in
+ * FIPS mode. This is set in the validated module method. If an application
+ * sets this flag in its own methods it is its responsibility to ensure the
+ * result is compliant.
+ */
+
+#   define DH_FLAG_FIPS_METHOD                     0x0400
+
+/*
+ * If this flag is set the operations normally disabled in FIPS mode are
+ * permitted it is then the applications responsibility to ensure that the
+ * usage is compliant.
+ */
+
+#   define DH_FLAG_NON_FIPS_ALLOW                  0x0400
+#  endif
+
+/* Already defined in ossl_typ.h */
+/* typedef struct dh_st DH; */
+/* typedef struct dh_method DH_METHOD; */
+
+DECLARE_ASN1_ITEM(DHparams)
+
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+#   define DH_GENERATOR_2          2
+#   define DH_GENERATOR_3          3
+#   define DH_GENERATOR_5          5
+
+/* DH_check error codes, some of them shared with DH_check_pub_key */
+/*
+ * NB: These values must align with the equivalently named macros in
+ * internal/ffc.h.
+ */
+#   define DH_CHECK_P_NOT_PRIME            0x01
+#   define DH_CHECK_P_NOT_SAFE_PRIME       0x02
+#   define DH_UNABLE_TO_CHECK_GENERATOR    0x04
+#   define DH_NOT_SUITABLE_GENERATOR       0x08
+#   define DH_CHECK_Q_NOT_PRIME            0x10
+#   define DH_CHECK_INVALID_Q_VALUE        0x20 /* +DH_check_pub_key */
+#   define DH_CHECK_INVALID_J_VALUE        0x40
+#   define DH_MODULUS_TOO_SMALL            0x80
+#   define DH_MODULUS_TOO_LARGE            0x100 /* +DH_check_pub_key */
+
+/* DH_check_pub_key error codes */
+#   define DH_CHECK_PUBKEY_TOO_SMALL       0x01
+#   define DH_CHECK_PUBKEY_TOO_LARGE       0x02
+#   define DH_CHECK_PUBKEY_INVALID         0x04
+
+/*
+ * primes p where (p-1)/2 is prime too are called "safe"; we define this for
+ * backward compatibility:
+ */
+#   define DH_CHECK_P_NOT_STRONG_PRIME     DH_CHECK_P_NOT_SAFE_PRIME
+
+#   define d2i_DHparams_fp(fp, x) \
+        (DH *)ASN1_d2i_fp((char *(*)())DH_new, \
+                          (char *(*)())d2i_DHparams, \
+                          (fp), \
+                          (unsigned char **)(x))
+#   define i2d_DHparams_fp(fp, x) \
+        ASN1_i2d_fp(i2d_DHparams,(fp), (unsigned char *)(x))
+#   define d2i_DHparams_bio(bp, x) \
+        ASN1_d2i_bio_of(DH, DH_new, d2i_DHparams, bp, x)
+#   define i2d_DHparams_bio(bp, x) \
+        ASN1_i2d_bio_of(DH, i2d_DHparams, bp, x)
+
+#   define d2i_DHxparams_fp(fp,x) \
+        (DH *)ASN1_d2i_fp((char *(*)())DH_new, \
+                          (char *(*)())d2i_DHxparams, \
+                          (fp), \
+                          (unsigned char **)(x))
+#   define i2d_DHxparams_fp(fp, x) \
+        ASN1_i2d_fp(i2d_DHxparams,(fp), (unsigned char *)(x))
+#   define d2i_DHxparams_bio(bp, x) \
+        ASN1_d2i_bio_of(DH, DH_new, d2i_DHxparams, bp, x)
+#   define i2d_DHxparams_bio(bp, x) \
+        ASN1_i2d_bio_of(DH, i2d_DHxparams, bp, x)
+
+DECLARE_ASN1_DUP_FUNCTION_name_attr(OSSL_DEPRECATEDIN_3_0, DH, DHparams)
+
+OSSL_DEPRECATEDIN_3_0 const DH_METHOD *DH_OpenSSL(void);
+
+OSSL_DEPRECATEDIN_3_0 void DH_set_default_method(const DH_METHOD *meth);
+OSSL_DEPRECATEDIN_3_0 const DH_METHOD *DH_get_default_method(void);
+OSSL_DEPRECATEDIN_3_0 int DH_set_method(DH *dh, const DH_METHOD *meth);
+OSSL_DEPRECATEDIN_3_0 DH *DH_new_method(ENGINE *engine);
+
+OSSL_DEPRECATEDIN_3_0 DH *DH_new(void);
+OSSL_DEPRECATEDIN_3_0 void DH_free(DH *dh);
+OSSL_DEPRECATEDIN_3_0 int DH_up_ref(DH *dh);
+OSSL_DEPRECATEDIN_3_0 int DH_bits(const DH *dh);
+OSSL_DEPRECATEDIN_3_0 int DH_size(const DH *dh);
+OSSL_DEPRECATEDIN_3_0 int DH_security_bits(const DH *dh);
+
+#   define DH_get_ex_new_index(l, p, newf, dupf, freef) \
+        CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_DH, l, p, newf, dupf, freef)
+
+OSSL_DEPRECATEDIN_3_0 int DH_set_ex_data(DH *d, int idx, void *arg);
+OSSL_DEPRECATEDIN_3_0 void *DH_get_ex_data(const DH *d, int idx);
+
+OSSL_DEPRECATEDIN_3_0 int DH_generate_parameters_ex(DH *dh, int prime_len,
+                                                    int generator,
+                                                    BN_GENCB *cb);
+
+OSSL_DEPRECATEDIN_3_0 int DH_check_params_ex(const DH *dh);
+OSSL_DEPRECATEDIN_3_0 int DH_check_ex(const DH *dh);
+OSSL_DEPRECATEDIN_3_0 int DH_check_pub_key_ex(const DH *dh, const BIGNUM *pub_key);
+OSSL_DEPRECATEDIN_3_0 int DH_check_params(const DH *dh, int *ret);
+OSSL_DEPRECATEDIN_3_0 int DH_check(const DH *dh, int *codes);
+OSSL_DEPRECATEDIN_3_0 int DH_check_pub_key(const DH *dh, const BIGNUM *pub_key,
+                                           int *codes);
+OSSL_DEPRECATEDIN_3_0 int DH_generate_key(DH *dh);
+OSSL_DEPRECATEDIN_3_0 int DH_compute_key(unsigned char *key,
+                                         const BIGNUM *pub_key, DH *dh);
+OSSL_DEPRECATEDIN_3_0 int DH_compute_key_padded(unsigned char *key,
+                                                const BIGNUM *pub_key, DH *dh);
+
+DECLARE_ASN1_ENCODE_FUNCTIONS_only_attr(OSSL_DEPRECATEDIN_3_0, DH, DHparams)
+DECLARE_ASN1_ENCODE_FUNCTIONS_only_attr(OSSL_DEPRECATEDIN_3_0, DH, DHxparams)
+
+#   ifndef OPENSSL_NO_STDIO
+OSSL_DEPRECATEDIN_3_0 int DHparams_print_fp(FILE *fp, const DH *x);
+#   endif
+OSSL_DEPRECATEDIN_3_0 int DHparams_print(BIO *bp, const DH *x);
+
+/* RFC 5114 parameters */
+OSSL_DEPRECATEDIN_3_0 DH *DH_get_1024_160(void);
+OSSL_DEPRECATEDIN_3_0 DH *DH_get_2048_224(void);
+OSSL_DEPRECATEDIN_3_0 DH *DH_get_2048_256(void);
+
+/* Named parameters, currently RFC7919 and RFC3526 */
+OSSL_DEPRECATEDIN_3_0 DH *DH_new_by_nid(int nid);
+OSSL_DEPRECATEDIN_3_0 int DH_get_nid(const DH *dh);
+
+/* RFC2631 KDF */
+OSSL_DEPRECATEDIN_3_0 int DH_KDF_X9_42(unsigned char *out, size_t outlen,
+                                       const unsigned char *Z, size_t Zlen,
+                                       ASN1_OBJECT *key_oid,
+                                       const unsigned char *ukm,
+                                       size_t ukmlen, const EVP_MD *md);
+
+OSSL_DEPRECATEDIN_3_0 void DH_get0_pqg(const DH *dh, const BIGNUM **p,
+                                       const BIGNUM **q, const BIGNUM **g);
+OSSL_DEPRECATEDIN_3_0 int DH_set0_pqg(DH *dh, BIGNUM *p, BIGNUM *q, BIGNUM *g);
+OSSL_DEPRECATEDIN_3_0 void DH_get0_key(const DH *dh, const BIGNUM **pub_key,
+                                       const BIGNUM **priv_key);
+OSSL_DEPRECATEDIN_3_0 int DH_set0_key(DH *dh, BIGNUM *pub_key, BIGNUM *priv_key);
+OSSL_DEPRECATEDIN_3_0 const BIGNUM *DH_get0_p(const DH *dh);
+OSSL_DEPRECATEDIN_3_0 const BIGNUM *DH_get0_q(const DH *dh);
+OSSL_DEPRECATEDIN_3_0 const BIGNUM *DH_get0_g(const DH *dh);
+OSSL_DEPRECATEDIN_3_0 const BIGNUM *DH_get0_priv_key(const DH *dh);
+OSSL_DEPRECATEDIN_3_0 const BIGNUM *DH_get0_pub_key(const DH *dh);
+OSSL_DEPRECATEDIN_3_0 void DH_clear_flags(DH *dh, int flags);
+OSSL_DEPRECATEDIN_3_0 int DH_test_flags(const DH *dh, int flags);
+OSSL_DEPRECATEDIN_3_0 void DH_set_flags(DH *dh, int flags);
+OSSL_DEPRECATEDIN_3_0 ENGINE *DH_get0_engine(DH *d);
+OSSL_DEPRECATEDIN_3_0 long DH_get_length(const DH *dh);
+OSSL_DEPRECATEDIN_3_0 int DH_set_length(DH *dh, long length);
+
+OSSL_DEPRECATEDIN_3_0 DH_METHOD *DH_meth_new(const char *name, int flags);
+OSSL_DEPRECATEDIN_3_0 void DH_meth_free(DH_METHOD *dhm);
+OSSL_DEPRECATEDIN_3_0 DH_METHOD *DH_meth_dup(const DH_METHOD *dhm);
+OSSL_DEPRECATEDIN_3_0 const char *DH_meth_get0_name(const DH_METHOD *dhm);
+OSSL_DEPRECATEDIN_3_0 int DH_meth_set1_name(DH_METHOD *dhm, const char *name);
+OSSL_DEPRECATEDIN_3_0 int DH_meth_get_flags(const DH_METHOD *dhm);
+OSSL_DEPRECATEDIN_3_0 int DH_meth_set_flags(DH_METHOD *dhm, int flags);
+OSSL_DEPRECATEDIN_3_0 void *DH_meth_get0_app_data(const DH_METHOD *dhm);
+OSSL_DEPRECATEDIN_3_0 int DH_meth_set0_app_data(DH_METHOD *dhm, void *app_data);
+OSSL_DEPRECATEDIN_3_0 int (*DH_meth_get_generate_key(const DH_METHOD *dhm)) (DH *);
+OSSL_DEPRECATEDIN_3_0 int DH_meth_set_generate_key(DH_METHOD *dhm,
+                                                   int (*generate_key) (DH *));
+OSSL_DEPRECATEDIN_3_0 int (*DH_meth_get_compute_key(const DH_METHOD *dhm))
+                                                   (unsigned char *key,
+                                                    const BIGNUM *pub_key,
+                                                    DH *dh);
+OSSL_DEPRECATEDIN_3_0 int DH_meth_set_compute_key(DH_METHOD *dhm,
+                                                  int (*compute_key)
+                                                  (unsigned char *key,
+                                                   const BIGNUM *pub_key,
+                                                   DH *dh));
+OSSL_DEPRECATEDIN_3_0 int (*DH_meth_get_bn_mod_exp(const DH_METHOD *dhm))
+                                                   (const DH *, BIGNUM *,
+                                                    const BIGNUM *,
+                                                    const BIGNUM *,
+                                                    const BIGNUM *, BN_CTX *,
+                                                    BN_MONT_CTX *);
+OSSL_DEPRECATEDIN_3_0 int DH_meth_set_bn_mod_exp(DH_METHOD *dhm,
+                                                 int (*bn_mod_exp)
+                                                 (const DH *, BIGNUM *,
+                                                  const BIGNUM *, const BIGNUM *,
+                                                  const BIGNUM *, BN_CTX *,
+                                                  BN_MONT_CTX *));
+OSSL_DEPRECATEDIN_3_0 int (*DH_meth_get_init(const DH_METHOD *dhm))(DH *);
+OSSL_DEPRECATEDIN_3_0 int DH_meth_set_init(DH_METHOD *dhm, int (*init)(DH *));
+OSSL_DEPRECATEDIN_3_0 int (*DH_meth_get_finish(const DH_METHOD *dhm)) (DH *);
+OSSL_DEPRECATEDIN_3_0 int DH_meth_set_finish(DH_METHOD *dhm, int (*finish) (DH *));
+OSSL_DEPRECATEDIN_3_0 int (*DH_meth_get_generate_params(const DH_METHOD *dhm))
+                                                        (DH *, int, int,
+                                                         BN_GENCB *);
+OSSL_DEPRECATEDIN_3_0 int DH_meth_set_generate_params(DH_METHOD *dhm,
+                                                      int (*generate_params)
+                                                      (DH *, int, int,
+                                                       BN_GENCB *));
+#  endif /* OPENSSL_NO_DEPRECATED_3_0 */
+
+#  ifndef OPENSSL_NO_DEPRECATED_0_9_8
+OSSL_DEPRECATEDIN_0_9_8 DH *DH_generate_parameters(int prime_len, int generator,
+                                                   void (*callback) (int, int,
+                                                                void *),
+                                                   void *cb_arg);
+#  endif
+
+# endif
+# ifdef  __cplusplus
+}
+# endif
+#endif
diff --git a/src/include/openssl/dherr.h b/src/include/openssl/dherr.h
new file mode 100644
index 0000000..2997d7d
--- /dev/null
+++ b/src/include/openssl/dherr.h
@@ -0,0 +1,59 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_DHERR_H
+# define OPENSSL_DHERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+# ifndef OPENSSL_NO_DH
+
+
+/*
+ * DH reason codes.
+ */
+#  define DH_R_BAD_FFC_PARAMETERS                          127
+#  define DH_R_BAD_GENERATOR                               101
+#  define DH_R_BN_DECODE_ERROR                             109
+#  define DH_R_BN_ERROR                                    106
+#  define DH_R_CHECK_INVALID_J_VALUE                       115
+#  define DH_R_CHECK_INVALID_Q_VALUE                       116
+#  define DH_R_CHECK_PUBKEY_INVALID                        122
+#  define DH_R_CHECK_PUBKEY_TOO_LARGE                      123
+#  define DH_R_CHECK_PUBKEY_TOO_SMALL                      124
+#  define DH_R_CHECK_P_NOT_PRIME                           117
+#  define DH_R_CHECK_P_NOT_SAFE_PRIME                      118
+#  define DH_R_CHECK_Q_NOT_PRIME                           119
+#  define DH_R_DECODE_ERROR                                104
+#  define DH_R_INVALID_PARAMETER_NAME                      110
+#  define DH_R_INVALID_PARAMETER_NID                       114
+#  define DH_R_INVALID_PUBKEY                              102
+#  define DH_R_INVALID_SECRET                              128
+#  define DH_R_INVALID_SIZE                                129
+#  define DH_R_KDF_PARAMETER_ERROR                         112
+#  define DH_R_KEYS_NOT_SET                                108
+#  define DH_R_MISSING_PUBKEY                              125
+#  define DH_R_MODULUS_TOO_LARGE                           103
+#  define DH_R_MODULUS_TOO_SMALL                           126
+#  define DH_R_NOT_SUITABLE_GENERATOR                      120
+#  define DH_R_NO_PARAMETERS_SET                           107
+#  define DH_R_NO_PRIVATE_VALUE                            100
+#  define DH_R_PARAMETER_ENCODING_ERROR                    105
+#  define DH_R_PEER_KEY_ERROR                              111
+#  define DH_R_Q_TOO_LARGE                                 130
+#  define DH_R_SHARED_INFO_ERROR                           113
+#  define DH_R_UNABLE_TO_CHECK_GENERATOR                   121
+
+# endif
+#endif
diff --git a/src/include/openssl/dsa.h b/src/include/openssl/dsa.h
new file mode 100644
index 0000000..109878e
--- /dev/null
+++ b/src/include/openssl/dsa.h
@@ -0,0 +1,280 @@
+/*
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_DSA_H
+# define OPENSSL_DSA_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_DSA_H
+# endif
+
+# include <openssl/opensslconf.h>
+# include <openssl/types.h>
+
+# include <stdlib.h>
+
+# ifndef OPENSSL_NO_DSA
+#  include <openssl/e_os2.h>
+#  include <openssl/asn1.h>
+#  include <openssl/bio.h>
+#  include <openssl/crypto.h>
+#  include <openssl/bn.h>
+#  ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#   include <openssl/dh.h>
+#  endif
+#  include <openssl/dsaerr.h>
+#  ifndef OPENSSL_NO_STDIO
+#   include <stdio.h>
+#  endif
+# endif
+
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+int EVP_PKEY_CTX_set_dsa_paramgen_bits(EVP_PKEY_CTX *ctx, int nbits);
+int EVP_PKEY_CTX_set_dsa_paramgen_q_bits(EVP_PKEY_CTX *ctx, int qbits);
+int EVP_PKEY_CTX_set_dsa_paramgen_md_props(EVP_PKEY_CTX *ctx,
+                                           const char *md_name,
+                                           const char *md_properties);
+int EVP_PKEY_CTX_set_dsa_paramgen_gindex(EVP_PKEY_CTX *ctx, int gindex);
+int EVP_PKEY_CTX_set_dsa_paramgen_type(EVP_PKEY_CTX *ctx, const char *name);
+int EVP_PKEY_CTX_set_dsa_paramgen_seed(EVP_PKEY_CTX *ctx,
+                                       const unsigned char *seed,
+                                       size_t seedlen);
+int EVP_PKEY_CTX_set_dsa_paramgen_md(EVP_PKEY_CTX *ctx, const EVP_MD *md);
+
+# define EVP_PKEY_CTRL_DSA_PARAMGEN_BITS         (EVP_PKEY_ALG_CTRL + 1)
+# define EVP_PKEY_CTRL_DSA_PARAMGEN_Q_BITS       (EVP_PKEY_ALG_CTRL + 2)
+# define EVP_PKEY_CTRL_DSA_PARAMGEN_MD           (EVP_PKEY_ALG_CTRL + 3)
+
+# ifndef OPENSSL_NO_DSA
+#  ifndef OPENSSL_DSA_MAX_MODULUS_BITS
+#   define OPENSSL_DSA_MAX_MODULUS_BITS   10000
+#  endif
+
+#  define OPENSSL_DSA_FIPS_MIN_MODULUS_BITS 1024
+
+typedef struct DSA_SIG_st DSA_SIG;
+DSA_SIG *DSA_SIG_new(void);
+void DSA_SIG_free(DSA_SIG *a);
+DECLARE_ASN1_ENCODE_FUNCTIONS_only(DSA_SIG, DSA_SIG)
+void DSA_SIG_get0(const DSA_SIG *sig, const BIGNUM **pr, const BIGNUM **ps);
+int DSA_SIG_set0(DSA_SIG *sig, BIGNUM *r, BIGNUM *s);
+
+
+#  ifndef OPENSSL_NO_DEPRECATED_1_1_0
+/*
+ * Does nothing. Previously this switched off constant time behaviour.
+ */
+#   define DSA_FLAG_NO_EXP_CONSTTIME       0x00
+#  endif
+
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+#   define DSA_FLAG_CACHE_MONT_P   0x01
+
+/*
+ * If this flag is set the DSA method is FIPS compliant and can be used in
+ * FIPS mode. This is set in the validated module method. If an application
+ * sets this flag in its own methods it is its responsibility to ensure the
+ * result is compliant.
+ */
+
+#   define DSA_FLAG_FIPS_METHOD                    0x0400
+
+/*
+ * If this flag is set the operations normally disabled in FIPS mode are
+ * permitted it is then the applications responsibility to ensure that the
+ * usage is compliant.
+ */
+
+#   define DSA_FLAG_NON_FIPS_ALLOW                 0x0400
+#   define DSA_FLAG_FIPS_CHECKED                   0x0800
+
+/* Already defined in ossl_typ.h */
+/* typedef struct dsa_st DSA; */
+/* typedef struct dsa_method DSA_METHOD; */
+
+#   define d2i_DSAparams_fp(fp, x) \
+        (DSA *)ASN1_d2i_fp((char *(*)())DSA_new, \
+                           (char *(*)())d2i_DSAparams, (fp), \
+                           (unsigned char **)(x))
+#   define i2d_DSAparams_fp(fp, x) \
+        ASN1_i2d_fp(i2d_DSAparams, (fp), (unsigned char *)(x))
+#   define d2i_DSAparams_bio(bp, x) \
+        ASN1_d2i_bio_of(DSA, DSA_new, d2i_DSAparams, bp, x)
+#   define i2d_DSAparams_bio(bp, x) \
+        ASN1_i2d_bio_of(DSA, i2d_DSAparams, bp, x)
+
+DECLARE_ASN1_DUP_FUNCTION_name_attr(OSSL_DEPRECATEDIN_3_0, DSA, DSAparams)
+OSSL_DEPRECATEDIN_3_0 DSA_SIG *DSA_do_sign(const unsigned char *dgst, int dlen,
+                                           DSA *dsa);
+OSSL_DEPRECATEDIN_3_0 int DSA_do_verify(const unsigned char *dgst, int dgst_len,
+                                        DSA_SIG *sig, DSA *dsa);
+
+OSSL_DEPRECATEDIN_3_0 const DSA_METHOD *DSA_OpenSSL(void);
+
+OSSL_DEPRECATEDIN_3_0 void DSA_set_default_method(const DSA_METHOD *);
+OSSL_DEPRECATEDIN_3_0 const DSA_METHOD *DSA_get_default_method(void);
+OSSL_DEPRECATEDIN_3_0 int DSA_set_method(DSA *dsa, const DSA_METHOD *);
+OSSL_DEPRECATEDIN_3_0 const DSA_METHOD *DSA_get_method(DSA *d);
+
+OSSL_DEPRECATEDIN_3_0 DSA *DSA_new(void);
+OSSL_DEPRECATEDIN_3_0 DSA *DSA_new_method(ENGINE *engine);
+OSSL_DEPRECATEDIN_3_0 void DSA_free(DSA *r);
+/* "up" the DSA object's reference count */
+OSSL_DEPRECATEDIN_3_0 int DSA_up_ref(DSA *r);
+OSSL_DEPRECATEDIN_3_0 int DSA_size(const DSA *);
+OSSL_DEPRECATEDIN_3_0 int DSA_bits(const DSA *d);
+OSSL_DEPRECATEDIN_3_0 int DSA_security_bits(const DSA *d);
+        /* next 4 return -1 on error */
+OSSL_DEPRECATEDIN_3_0 int DSA_sign_setup(DSA *dsa, BN_CTX *ctx_in,
+                                         BIGNUM **kinvp, BIGNUM **rp);
+OSSL_DEPRECATEDIN_3_0 int DSA_sign(int type, const unsigned char *dgst,
+                                   int dlen, unsigned char *sig,
+                                   unsigned int *siglen, DSA *dsa);
+OSSL_DEPRECATEDIN_3_0 int DSA_verify(int type, const unsigned char *dgst,
+                                     int dgst_len, const unsigned char *sigbuf,
+                                     int siglen, DSA *dsa);
+
+#   define DSA_get_ex_new_index(l, p, newf, dupf, freef) \
+        CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_DSA, l, p, newf, dupf, freef)
+OSSL_DEPRECATEDIN_3_0 int DSA_set_ex_data(DSA *d, int idx, void *arg);
+OSSL_DEPRECATEDIN_3_0 void *DSA_get_ex_data(const DSA *d, int idx);
+
+DECLARE_ASN1_ENCODE_FUNCTIONS_only_attr(OSSL_DEPRECATEDIN_3_0,
+                                        DSA, DSAPublicKey)
+DECLARE_ASN1_ENCODE_FUNCTIONS_only_attr(OSSL_DEPRECATEDIN_3_0,
+                                        DSA, DSAPrivateKey)
+DECLARE_ASN1_ENCODE_FUNCTIONS_only_attr(OSSL_DEPRECATEDIN_3_0,
+                                        DSA, DSAparams)
+#  endif
+
+#  ifndef OPENSSL_NO_DEPRECATED_0_9_8
+/* Deprecated version */
+OSSL_DEPRECATEDIN_0_9_8
+DSA *DSA_generate_parameters(int bits, unsigned char *seed, int seed_len,
+                             int *counter_ret, unsigned long *h_ret,
+                             void (*callback) (int, int, void *),
+                             void *cb_arg);
+#  endif
+
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+/* New version */
+OSSL_DEPRECATEDIN_3_0 int DSA_generate_parameters_ex(DSA *dsa, int bits,
+                                                     const unsigned char *seed,
+                                                     int seed_len,
+                                                     int *counter_ret,
+                                                     unsigned long *h_ret,
+                                                     BN_GENCB *cb);
+
+OSSL_DEPRECATEDIN_3_0 int DSA_generate_key(DSA *a);
+
+OSSL_DEPRECATEDIN_3_0 int DSAparams_print(BIO *bp, const DSA *x);
+OSSL_DEPRECATEDIN_3_0 int DSA_print(BIO *bp, const DSA *x, int off);
+#   ifndef OPENSSL_NO_STDIO
+OSSL_DEPRECATEDIN_3_0 int DSAparams_print_fp(FILE *fp, const DSA *x);
+OSSL_DEPRECATEDIN_3_0 int DSA_print_fp(FILE *bp, const DSA *x, int off);
+#   endif
+
+#   define DSS_prime_checks 64
+/*
+ * Primality test according to FIPS PUB 186-4, Appendix C.3. Since we only
+ * have one value here we set the number of checks to 64 which is the 128 bit
+ * security level that is the highest level and valid for creating a 3072 bit
+ * DSA key.
+ */
+#   define DSA_is_prime(n, callback, cb_arg) \
+            BN_is_prime(n, DSS_prime_checks, callback, NULL, cb_arg)
+
+#   ifndef OPENSSL_NO_DH
+/*
+ * Convert DSA structure (key or just parameters) into DH structure (be
+ * careful to avoid small subgroup attacks when using this!)
+ */
+OSSL_DEPRECATEDIN_3_0 DH *DSA_dup_DH(const DSA *r);
+#   endif
+
+OSSL_DEPRECATEDIN_3_0 void DSA_get0_pqg(const DSA *d, const BIGNUM **p,
+                                        const BIGNUM **q, const BIGNUM **g);
+OSSL_DEPRECATEDIN_3_0 int DSA_set0_pqg(DSA *d, BIGNUM *p, BIGNUM *q, BIGNUM *g);
+OSSL_DEPRECATEDIN_3_0 void DSA_get0_key(const DSA *d, const BIGNUM **pub_key,
+                                        const BIGNUM **priv_key);
+OSSL_DEPRECATEDIN_3_0 int DSA_set0_key(DSA *d, BIGNUM *pub_key,
+                                       BIGNUM *priv_key);
+OSSL_DEPRECATEDIN_3_0 const BIGNUM *DSA_get0_p(const DSA *d);
+OSSL_DEPRECATEDIN_3_0 const BIGNUM *DSA_get0_q(const DSA *d);
+OSSL_DEPRECATEDIN_3_0 const BIGNUM *DSA_get0_g(const DSA *d);
+OSSL_DEPRECATEDIN_3_0 const BIGNUM *DSA_get0_pub_key(const DSA *d);
+OSSL_DEPRECATEDIN_3_0 const BIGNUM *DSA_get0_priv_key(const DSA *d);
+OSSL_DEPRECATEDIN_3_0 void DSA_clear_flags(DSA *d, int flags);
+OSSL_DEPRECATEDIN_3_0 int DSA_test_flags(const DSA *d, int flags);
+OSSL_DEPRECATEDIN_3_0 void DSA_set_flags(DSA *d, int flags);
+OSSL_DEPRECATEDIN_3_0 ENGINE *DSA_get0_engine(DSA *d);
+
+OSSL_DEPRECATEDIN_3_0 DSA_METHOD *DSA_meth_new(const char *name, int flags);
+OSSL_DEPRECATEDIN_3_0 void DSA_meth_free(DSA_METHOD *dsam);
+OSSL_DEPRECATEDIN_3_0 DSA_METHOD *DSA_meth_dup(const DSA_METHOD *dsam);
+OSSL_DEPRECATEDIN_3_0 const char *DSA_meth_get0_name(const DSA_METHOD *dsam);
+OSSL_DEPRECATEDIN_3_0 int DSA_meth_set1_name(DSA_METHOD *dsam,
+                                             const char *name);
+OSSL_DEPRECATEDIN_3_0 int DSA_meth_get_flags(const DSA_METHOD *dsam);
+OSSL_DEPRECATEDIN_3_0 int DSA_meth_set_flags(DSA_METHOD *dsam, int flags);
+OSSL_DEPRECATEDIN_3_0 void *DSA_meth_get0_app_data(const DSA_METHOD *dsam);
+OSSL_DEPRECATEDIN_3_0 int DSA_meth_set0_app_data(DSA_METHOD *dsam,
+                                                 void *app_data);
+OSSL_DEPRECATEDIN_3_0 DSA_SIG *(*DSA_meth_get_sign(const DSA_METHOD *dsam))
+        (const unsigned char *, int, DSA *);
+OSSL_DEPRECATEDIN_3_0 int DSA_meth_set_sign(DSA_METHOD *dsam,
+                       DSA_SIG *(*sign) (const unsigned char *, int, DSA *));
+OSSL_DEPRECATEDIN_3_0 int (*DSA_meth_get_sign_setup(const DSA_METHOD *dsam))
+        (DSA *, BN_CTX *, BIGNUM **, BIGNUM **);
+OSSL_DEPRECATEDIN_3_0 int DSA_meth_set_sign_setup(DSA_METHOD *dsam,
+        int (*sign_setup) (DSA *, BN_CTX *, BIGNUM **, BIGNUM **));
+OSSL_DEPRECATEDIN_3_0 int (*DSA_meth_get_verify(const DSA_METHOD *dsam))
+        (const unsigned char *, int, DSA_SIG *, DSA *);
+OSSL_DEPRECATEDIN_3_0 int DSA_meth_set_verify(DSA_METHOD *dsam,
+    int (*verify) (const unsigned char *, int, DSA_SIG *, DSA *));
+OSSL_DEPRECATEDIN_3_0 int (*DSA_meth_get_mod_exp(const DSA_METHOD *dsam))
+        (DSA *, BIGNUM *, const BIGNUM *, const BIGNUM *, const BIGNUM *,
+         const BIGNUM *, const BIGNUM *, BN_CTX *, BN_MONT_CTX *);
+OSSL_DEPRECATEDIN_3_0 int DSA_meth_set_mod_exp(DSA_METHOD *dsam,
+    int (*mod_exp) (DSA *, BIGNUM *, const BIGNUM *, const BIGNUM *,
+                    const BIGNUM *, const BIGNUM *, const BIGNUM *, BN_CTX *,
+                    BN_MONT_CTX *));
+OSSL_DEPRECATEDIN_3_0 int (*DSA_meth_get_bn_mod_exp(const DSA_METHOD *dsam))
+    (DSA *, BIGNUM *, const BIGNUM *, const BIGNUM *, const BIGNUM *,
+     BN_CTX *, BN_MONT_CTX *);
+OSSL_DEPRECATEDIN_3_0 int DSA_meth_set_bn_mod_exp(DSA_METHOD *dsam,
+    int (*bn_mod_exp) (DSA *, BIGNUM *, const BIGNUM *, const BIGNUM *,
+                       const BIGNUM *, BN_CTX *, BN_MONT_CTX *));
+OSSL_DEPRECATEDIN_3_0 int (*DSA_meth_get_init(const DSA_METHOD *dsam))(DSA *);
+OSSL_DEPRECATEDIN_3_0 int DSA_meth_set_init(DSA_METHOD *dsam,
+                                            int (*init)(DSA *));
+OSSL_DEPRECATEDIN_3_0 int (*DSA_meth_get_finish(const DSA_METHOD *dsam))(DSA *);
+OSSL_DEPRECATEDIN_3_0 int DSA_meth_set_finish(DSA_METHOD *dsam,
+                                              int (*finish)(DSA *));
+OSSL_DEPRECATEDIN_3_0 int (*DSA_meth_get_paramgen(const DSA_METHOD *dsam))
+        (DSA *, int, const unsigned char *, int, int *, unsigned long *,
+         BN_GENCB *);
+OSSL_DEPRECATEDIN_3_0 int DSA_meth_set_paramgen(DSA_METHOD *dsam,
+        int (*paramgen) (DSA *, int, const unsigned char *, int, int *,
+                         unsigned long *, BN_GENCB *));
+OSSL_DEPRECATEDIN_3_0 int (*DSA_meth_get_keygen(const DSA_METHOD *dsam))(DSA *);
+OSSL_DEPRECATEDIN_3_0 int DSA_meth_set_keygen(DSA_METHOD *dsam,
+                                              int (*keygen) (DSA *));
+
+#  endif
+# endif
+# ifdef  __cplusplus
+}
+# endif
+#endif
diff --git a/src/include/openssl/dsaerr.h b/src/include/openssl/dsaerr.h
new file mode 100644
index 0000000..26ada57
--- /dev/null
+++ b/src/include/openssl/dsaerr.h
@@ -0,0 +1,44 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_DSAERR_H
+# define OPENSSL_DSAERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+# ifndef OPENSSL_NO_DSA
+
+
+/*
+ * DSA reason codes.
+ */
+#  define DSA_R_BAD_FFC_PARAMETERS                         114
+#  define DSA_R_BAD_Q_VALUE                                102
+#  define DSA_R_BN_DECODE_ERROR                            108
+#  define DSA_R_BN_ERROR                                   109
+#  define DSA_R_DECODE_ERROR                               104
+#  define DSA_R_INVALID_DIGEST_TYPE                        106
+#  define DSA_R_INVALID_PARAMETERS                         112
+#  define DSA_R_MISSING_PARAMETERS                         101
+#  define DSA_R_MISSING_PRIVATE_KEY                        111
+#  define DSA_R_MODULUS_TOO_LARGE                          103
+#  define DSA_R_NO_PARAMETERS_SET                          107
+#  define DSA_R_PARAMETER_ENCODING_ERROR                   105
+#  define DSA_R_P_NOT_PRIME                                115
+#  define DSA_R_Q_NOT_PRIME                                113
+#  define DSA_R_SEED_LEN_SMALL                             110
+#  define DSA_R_TOO_MANY_RETRIES                           116
+
+# endif
+#endif
diff --git a/src/include/openssl/dtls1.h b/src/include/openssl/dtls1.h
new file mode 100644
index 0000000..5dc6b54
--- /dev/null
+++ b/src/include/openssl/dtls1.h
@@ -0,0 +1,57 @@
+/*
+ * Copyright 2005-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_DTLS1_H
+# define OPENSSL_DTLS1_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_DTLS1_H
+# endif
+
+# include <openssl/prov_ssl.h>
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+#include <openssl/opensslconf.h>
+
+/* DTLS*_VERSION constants are defined in prov_ssl.h */
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define DTLS_MIN_VERSION                DTLS1_VERSION
+#  define DTLS_MAX_VERSION                DTLS1_2_VERSION
+# endif
+# define DTLS1_VERSION_MAJOR             0xFE
+
+/* Special value for method supporting multiple versions */
+# define DTLS_ANY_VERSION                0x1FFFF
+
+/* lengths of messages */
+
+# define DTLS1_COOKIE_LENGTH                     255
+
+# define DTLS1_RT_HEADER_LENGTH                  13
+
+# define DTLS1_HM_HEADER_LENGTH                  12
+
+# define DTLS1_HM_BAD_FRAGMENT                   -2
+# define DTLS1_HM_FRAGMENT_RETRY                 -3
+
+# define DTLS1_CCS_HEADER_LENGTH                  1
+
+# define DTLS1_AL_HEADER_LENGTH                   2
+
+# define DTLS1_TMO_ALERT_COUNT                     12
+
+#ifdef  __cplusplus
+}
+#endif
+#endif
diff --git a/src/include/openssl/e_os2.h b/src/include/openssl/e_os2.h
new file mode 100644
index 0000000..f1e1795
--- /dev/null
+++ b/src/include/openssl/e_os2.h
@@ -0,0 +1,309 @@
+/*
+ * Copyright 1995-2024 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_E_OS2_H
+# define OPENSSL_E_OS2_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_E_OS2_H
+# endif
+
+# include <openssl/opensslconf.h>
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+/******************************************************************************
+ * Detect operating systems.  This probably needs completing.
+ * The result is that at least one OPENSSL_SYS_os macro should be defined.
+ * However, if none is defined, Unix is assumed.
+ **/
+
+# define OPENSSL_SYS_UNIX
+
+/* --------------------- Microsoft operating systems ---------------------- */
+
+/*
+ * Note that MSDOS actually denotes 32-bit environments running on top of
+ * MS-DOS, such as DJGPP one.
+ */
+# if defined(OPENSSL_SYS_MSDOS)
+#  undef OPENSSL_SYS_UNIX
+# endif
+
+/*
+ * For 32 bit environment, there seems to be the CygWin environment and then
+ * all the others that try to do the same thing Microsoft does...
+ */
+/*
+ * UEFI lives here because it might be built with a Microsoft toolchain and
+ * we need to avoid the false positive match on Windows.
+ */
+# if defined(OPENSSL_SYS_UEFI)
+#  undef OPENSSL_SYS_UNIX
+# elif defined(OPENSSL_SYS_UWIN)
+#  undef OPENSSL_SYS_UNIX
+#  define OPENSSL_SYS_WIN32_UWIN
+# else
+#  if defined(__CYGWIN__) || defined(OPENSSL_SYS_CYGWIN)
+#   define OPENSSL_SYS_WIN32_CYGWIN
+#  else
+#   if defined(_WIN32) || defined(OPENSSL_SYS_WIN32)
+#    undef OPENSSL_SYS_UNIX
+#    if !defined(OPENSSL_SYS_WIN32)
+#     define OPENSSL_SYS_WIN32
+#    endif
+#   endif
+#   if defined(_WIN64) || defined(OPENSSL_SYS_WIN64)
+#    undef OPENSSL_SYS_UNIX
+#    if !defined(OPENSSL_SYS_WIN64)
+#     define OPENSSL_SYS_WIN64
+#    endif
+#   endif
+#   if defined(OPENSSL_SYS_WINNT)
+#    undef OPENSSL_SYS_UNIX
+#   endif
+#   if defined(OPENSSL_SYS_WINCE)
+#    undef OPENSSL_SYS_UNIX
+#   endif
+#  endif
+# endif
+
+/* Anything that tries to look like Microsoft is "Windows" */
+# if defined(OPENSSL_SYS_WIN32) || defined(OPENSSL_SYS_WIN64) || defined(OPENSSL_SYS_WINNT) || defined(OPENSSL_SYS_WINCE)
+#  undef OPENSSL_SYS_UNIX
+#  define OPENSSL_SYS_WINDOWS
+#  ifndef OPENSSL_SYS_MSDOS
+#   define OPENSSL_SYS_MSDOS
+#  endif
+# endif
+
+/*
+ * DLL settings.  This part is a bit tough, because it's up to the
+ * application implementer how he or she will link the application, so it
+ * requires some macro to be used.
+ */
+# ifdef OPENSSL_SYS_WINDOWS
+#  ifndef OPENSSL_OPT_WINDLL
+#   if defined(_WINDLL)         /* This is used when building OpenSSL to
+                                 * indicate that DLL linkage should be used */
+#    define OPENSSL_OPT_WINDLL
+#   endif
+#  endif
+# endif
+
+/* ------------------------------- OpenVMS -------------------------------- */
+# if defined(__VMS) || defined(VMS)
+#  if !defined(OPENSSL_SYS_VMS)
+#   undef OPENSSL_SYS_UNIX
+#   define OPENSSL_SYS_VMS
+#  endif
+#  if defined(__DECC)
+#   define OPENSSL_SYS_VMS_DECC
+#  elif defined(__DECCXX)
+#   define OPENSSL_SYS_VMS_DECC
+#   define OPENSSL_SYS_VMS_DECCXX
+#  else
+#   define OPENSSL_SYS_VMS_NODECC
+#  endif
+# endif
+
+/* -------------------------------- Unix ---------------------------------- */
+# ifdef OPENSSL_SYS_UNIX
+#  if defined(linux) || defined(__linux__) && !defined(OPENSSL_SYS_LINUX)
+#   define OPENSSL_SYS_LINUX
+#  endif
+#  if defined(_AIX) && !defined(OPENSSL_SYS_AIX)
+#   define OPENSSL_SYS_AIX
+#  endif
+# endif
+
+/* -------------------------------- VOS ----------------------------------- */
+# if defined(__VOS__) && !defined(OPENSSL_SYS_VOS)
+#  define OPENSSL_SYS_VOS
+#  ifdef __HPPA__
+#   define OPENSSL_SYS_VOS_HPPA
+#  endif
+#  ifdef __IA32__
+#   define OPENSSL_SYS_VOS_IA32
+#  endif
+# endif
+
+/* ---------------------------- HP NonStop -------------------------------- */
+# ifdef __TANDEM
+#  ifdef _STRING
+#   include <strings.h>
+#  endif
+# define OPENSSL_USE_BUILD_DATE
+# if defined(OPENSSL_THREADS) && defined(_SPT_MODEL_)
+#  define  SPT_THREAD_SIGNAL 1
+#  define  SPT_THREAD_AWARE 1
+#  include <spthread.h>
+# elif defined(OPENSSL_THREADS) && defined(_PUT_MODEL_)
+#  include <pthread.h>
+# endif
+# endif
+
+/**
+ * That's it for OS-specific stuff
+ *****************************************************************************/
+
+/*-
+ * OPENSSL_EXTERN is normally used to declare a symbol with possible extra
+ * attributes to handle its presence in a shared library.
+ * OPENSSL_EXPORT is used to define a symbol with extra possible attributes
+ * to make it visible in a shared library.
+ * Care needs to be taken when a header file is used both to declare and
+ * define symbols.  Basically, for any library that exports some global
+ * variables, the following code must be present in the header file that
+ * declares them, before OPENSSL_EXTERN is used:
+ *
+ * #ifdef SOME_BUILD_FLAG_MACRO
+ * # undef OPENSSL_EXTERN
+ * # define OPENSSL_EXTERN OPENSSL_EXPORT
+ * #endif
+ *
+ * The default is to have OPENSSL_EXPORT and OPENSSL_EXTERN
+ * have some generally sensible values.
+ */
+
+# if defined(OPENSSL_SYS_WINDOWS) && defined(OPENSSL_OPT_WINDLL)
+#  define OPENSSL_EXPORT extern __declspec(dllexport)
+#  define OPENSSL_EXTERN extern __declspec(dllimport)
+# else
+#  define OPENSSL_EXPORT extern
+#  define OPENSSL_EXTERN extern
+# endif
+
+# ifdef _WIN32
+#  ifdef _WIN64
+#   define ossl_ssize_t __int64
+#   define OSSL_SSIZE_MAX _I64_MAX
+#  else
+#   define ossl_ssize_t int
+#   define OSSL_SSIZE_MAX INT_MAX
+#  endif
+# endif
+
+# if defined(OPENSSL_SYS_UEFI) && !defined(ossl_ssize_t)
+#  define ossl_ssize_t INTN
+#  define OSSL_SSIZE_MAX MAX_INTN
+# endif
+
+# ifndef ossl_ssize_t
+#  define ossl_ssize_t ssize_t
+#  if defined(SSIZE_MAX)
+#   define OSSL_SSIZE_MAX SSIZE_MAX
+#  elif defined(_POSIX_SSIZE_MAX)
+#   define OSSL_SSIZE_MAX _POSIX_SSIZE_MAX
+#  else
+#   define OSSL_SSIZE_MAX ((ssize_t)(SIZE_MAX>>1))
+#  endif
+# endif
+
+# if defined(UNUSEDRESULT_DEBUG)
+#  define __owur __attribute__((__warn_unused_result__))
+# else
+#  define __owur
+# endif
+
+/* Standard integer types */
+# define OPENSSL_NO_INTTYPES_H
+# define OPENSSL_NO_STDINT_H
+# if defined(OPENSSL_SYS_UEFI)
+typedef INT8 int8_t;
+typedef UINT8 uint8_t;
+typedef INT16 int16_t;
+typedef UINT16 uint16_t;
+typedef INT32 int32_t;
+typedef UINT32 uint32_t;
+typedef INT64 int64_t;
+typedef UINT64 uint64_t;
+typedef UINTN uintptr_t;
+# elif (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || \
+     defined(__osf__) || defined(__sgi) || defined(__hpux) || \
+     defined(OPENSSL_SYS_VMS) || defined (__OpenBSD__)
+#  include <inttypes.h>
+#  undef OPENSSL_NO_INTTYPES_H
+/* Because the specs say that inttypes.h includes stdint.h if present */
+#  undef OPENSSL_NO_STDINT_H
+# elif defined(_MSC_VER) && _MSC_VER<1600
+/*
+ * minimally required typdefs for systems not supporting inttypes.h or
+ * stdint.h: currently just older VC++
+ */
+typedef signed char int8_t;
+typedef unsigned char uint8_t;
+typedef short int16_t;
+typedef unsigned short uint16_t;
+typedef int int32_t;
+typedef unsigned int uint32_t;
+typedef __int64 int64_t;
+typedef unsigned __int64 uint64_t;
+# elif defined(OPENSSL_SYS_TANDEM)
+#  include <stdint.h>
+#  include <sys/types.h>
+# else
+#  include <stdint.h>
+#  undef OPENSSL_NO_STDINT_H
+# endif
+# if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L && \
+    defined(INTMAX_MAX) && defined(UINTMAX_MAX)
+typedef intmax_t ossl_intmax_t;
+typedef uintmax_t ossl_uintmax_t;
+# else
+/* Fall back to the largest we know we require and can handle */
+typedef int64_t ossl_intmax_t;
+typedef uint64_t ossl_uintmax_t;
+# endif
+
+/* ossl_inline: portable inline definition usable in public headers */
+# if !defined(inline) && !defined(__cplusplus)
+#  if defined(__STDC_VERSION__) && __STDC_VERSION__>=199901L
+   /* just use inline */
+#   define ossl_inline inline
+#  elif defined(__GNUC__) && __GNUC__>=2
+#   define ossl_inline __inline__
+#  elif defined(_MSC_VER)
+  /*
+   * Visual Studio: inline is available in C++ only, however
+   * __inline is available for C, see
+   * http://msdn.microsoft.com/en-us/library/z8y1yy88.aspx
+   */
+#   define ossl_inline __inline
+#  else
+#   define ossl_inline
+#  endif
+# else
+#  define ossl_inline inline
+# endif
+
+# if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L && \
+     !defined(__cplusplus) 
+#  define ossl_noreturn _Noreturn
+# elif defined(__GNUC__) && __GNUC__ >= 2
+#  define ossl_noreturn __attribute__((noreturn))
+# else
+#  define ossl_noreturn
+# endif
+
+/* ossl_unused: portable unused attribute for use in public headers */
+# if defined(__GNUC__)
+#  define ossl_unused __attribute__((unused))
+# else
+#  define ossl_unused
+# endif
+
+#ifdef  __cplusplus
+}
+#endif
+#endif
diff --git a/src/include/openssl/e_ostime.h b/src/include/openssl/e_ostime.h
new file mode 100644
index 0000000..0e17487
--- /dev/null
+++ b/src/include/openssl/e_ostime.h
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2023 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_E_OSTIME_H
+# define OPENSSL_E_OSTIME_H
+# pragma once
+
+# include <openssl/macros.h>
+# include <openssl/opensslconf.h>
+# include <openssl/e_os2.h>
+
+/*
+ * This header guarantees that 'struct timeval' will be available. It includes
+ * the minimum headers needed to facilitate this. This may still be a
+ * substantial set of headers on some platforms (e.g. <winsock2.h> on Win32).
+ */
+
+# if defined(OPENSSL_SYS_WINDOWS)
+#  if !defined(_WINSOCKAPI_)
+    /*
+     * winsock2.h defines _WINSOCK2API_ and both winsock2.h and winsock.h define
+     * _WINSOCKAPI_. Both of these provide struct timeval. Don't include
+     * winsock2.h if either header has been included to avoid breakage with
+     * applications that prefer to use <winsock.h> over <winsock2.h>.
+     */
+#   include <winsock2.h>
+#  endif
+# else
+#  include <sys/time.h>
+# endif
+
+#endif
diff --git a/src/include/openssl/ebcdic.h b/src/include/openssl/ebcdic.h
new file mode 100644
index 0000000..e0ae1aa
--- /dev/null
+++ b/src/include/openssl/ebcdic.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright 1999-2016 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_EBCDIC_H
+# define OPENSSL_EBCDIC_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_EBCDIC_H
+# endif
+
+# include <stdlib.h>
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+/* Avoid name clashes with other applications */
+# define os_toascii   _openssl_os_toascii
+# define os_toebcdic  _openssl_os_toebcdic
+# define ebcdic2ascii _openssl_ebcdic2ascii
+# define ascii2ebcdic _openssl_ascii2ebcdic
+
+extern const unsigned char os_toascii[256];
+extern const unsigned char os_toebcdic[256];
+void *ebcdic2ascii(void *dest, const void *srce, size_t count);
+void *ascii2ebcdic(void *dest, const void *srce, size_t count);
+
+#ifdef  __cplusplus
+}
+#endif
+#endif
diff --git a/src/include/openssl/ec.h b/src/include/openssl/ec.h
new file mode 100644
index 0000000..e1cbe98
--- /dev/null
+++ b/src/include/openssl/ec.h
@@ -0,0 +1,1588 @@
+/*
+ * Copyright 2002-2023 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_EC_H
+# define OPENSSL_EC_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_EC_H
+# endif
+
+# include <openssl/opensslconf.h>
+# include <openssl/types.h>
+
+# include <string.h>
+
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+/* Values for EVP_PKEY_CTX_set_ec_param_enc() */
+# define OPENSSL_EC_EXPLICIT_CURVE  0x000
+# define OPENSSL_EC_NAMED_CURVE     0x001
+
+int EVP_PKEY_CTX_set_ec_paramgen_curve_nid(EVP_PKEY_CTX *ctx, int nid);
+int EVP_PKEY_CTX_set_ec_param_enc(EVP_PKEY_CTX *ctx, int param_enc);
+int EVP_PKEY_CTX_set_ecdh_cofactor_mode(EVP_PKEY_CTX *ctx, int cofactor_mode);
+int EVP_PKEY_CTX_get_ecdh_cofactor_mode(EVP_PKEY_CTX *ctx);
+
+int EVP_PKEY_CTX_set_ecdh_kdf_type(EVP_PKEY_CTX *ctx, int kdf);
+int EVP_PKEY_CTX_get_ecdh_kdf_type(EVP_PKEY_CTX *ctx);
+
+int EVP_PKEY_CTX_set_ecdh_kdf_md(EVP_PKEY_CTX *ctx, const EVP_MD *md);
+int EVP_PKEY_CTX_get_ecdh_kdf_md(EVP_PKEY_CTX *ctx, const EVP_MD **md);
+
+int EVP_PKEY_CTX_set_ecdh_kdf_outlen(EVP_PKEY_CTX *ctx, int len);
+int EVP_PKEY_CTX_get_ecdh_kdf_outlen(EVP_PKEY_CTX *ctx, int *len);
+
+int EVP_PKEY_CTX_set0_ecdh_kdf_ukm(EVP_PKEY_CTX *ctx, unsigned char *ukm,
+                                   int len);
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+int EVP_PKEY_CTX_get0_ecdh_kdf_ukm(EVP_PKEY_CTX *ctx, unsigned char **ukm);
+# endif
+
+# define EVP_PKEY_CTRL_EC_PARAMGEN_CURVE_NID    (EVP_PKEY_ALG_CTRL + 1)
+# define EVP_PKEY_CTRL_EC_PARAM_ENC             (EVP_PKEY_ALG_CTRL + 2)
+# define EVP_PKEY_CTRL_EC_ECDH_COFACTOR         (EVP_PKEY_ALG_CTRL + 3)
+# define EVP_PKEY_CTRL_EC_KDF_TYPE              (EVP_PKEY_ALG_CTRL + 4)
+# define EVP_PKEY_CTRL_EC_KDF_MD                (EVP_PKEY_ALG_CTRL + 5)
+# define EVP_PKEY_CTRL_GET_EC_KDF_MD            (EVP_PKEY_ALG_CTRL + 6)
+# define EVP_PKEY_CTRL_EC_KDF_OUTLEN            (EVP_PKEY_ALG_CTRL + 7)
+# define EVP_PKEY_CTRL_GET_EC_KDF_OUTLEN        (EVP_PKEY_ALG_CTRL + 8)
+# define EVP_PKEY_CTRL_EC_KDF_UKM               (EVP_PKEY_ALG_CTRL + 9)
+# define EVP_PKEY_CTRL_GET_EC_KDF_UKM           (EVP_PKEY_ALG_CTRL + 10)
+
+/* KDF types */
+# define EVP_PKEY_ECDH_KDF_NONE                      1
+# define EVP_PKEY_ECDH_KDF_X9_63                     2
+/*
+ * The old name for EVP_PKEY_ECDH_KDF_X9_63
+ *  The ECDH KDF specification has been mistakenly attributed to ANSI X9.62,
+ *  it is actually specified in ANSI X9.63.
+ *  This identifier is retained for backwards compatibility
+ */
+# define EVP_PKEY_ECDH_KDF_X9_62   EVP_PKEY_ECDH_KDF_X9_63
+
+/** Enum for the point conversion form as defined in X9.62 (ECDSA)
+ *  for the encoding of a elliptic curve point (x,y) */
+typedef enum {
+        /** the point is encoded as z||x, where the octet z specifies
+         *  which solution of the quadratic equation y is  */
+    POINT_CONVERSION_COMPRESSED = 2,
+        /** the point is encoded as z||x||y, where z is the octet 0x04  */
+    POINT_CONVERSION_UNCOMPRESSED = 4,
+        /** the point is encoded as z||x||y, where the octet z specifies
+         *  which solution of the quadratic equation y is  */
+    POINT_CONVERSION_HYBRID = 6
+} point_conversion_form_t;
+
+const char *OSSL_EC_curve_nid2name(int nid);
+
+# ifndef OPENSSL_NO_STDIO
+#  include <stdio.h>
+# endif
+# ifndef OPENSSL_NO_EC
+#  include <openssl/asn1.h>
+#  include <openssl/symhacks.h>
+#  ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#   include <openssl/bn.h>
+#  endif
+#  include <openssl/ecerr.h>
+
+#  ifndef OPENSSL_ECC_MAX_FIELD_BITS
+#   define OPENSSL_ECC_MAX_FIELD_BITS 661
+#  endif
+
+#  include <openssl/params.h>
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+typedef struct ec_method_st EC_METHOD;
+#  endif
+typedef struct ec_group_st EC_GROUP;
+typedef struct ec_point_st EC_POINT;
+typedef struct ecpk_parameters_st ECPKPARAMETERS;
+typedef struct ec_parameters_st ECPARAMETERS;
+
+/********************************************************************/
+/*               EC_METHODs for curves over GF(p)                   */
+/********************************************************************/
+
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+/** Returns the basic GFp ec methods which provides the basis for the
+ *  optimized methods.
+ *  \return  EC_METHOD object
+ */
+OSSL_DEPRECATEDIN_3_0 const EC_METHOD *EC_GFp_simple_method(void);
+
+/** Returns GFp methods using montgomery multiplication.
+ *  \return  EC_METHOD object
+ */
+OSSL_DEPRECATEDIN_3_0 const EC_METHOD *EC_GFp_mont_method(void);
+
+/** Returns GFp methods using optimized methods for NIST recommended curves
+ *  \return  EC_METHOD object
+ */
+OSSL_DEPRECATEDIN_3_0 const EC_METHOD *EC_GFp_nist_method(void);
+
+#   ifndef OPENSSL_NO_EC_NISTP_64_GCC_128
+/** Returns 64-bit optimized methods for nistp224
+ *  \return  EC_METHOD object
+ */
+OSSL_DEPRECATEDIN_3_0 const EC_METHOD *EC_GFp_nistp224_method(void);
+
+/** Returns 64-bit optimized methods for nistp256
+ *  \return  EC_METHOD object
+ */
+OSSL_DEPRECATEDIN_3_0 const EC_METHOD *EC_GFp_nistp256_method(void);
+
+/** Returns 64-bit optimized methods for nistp521
+ *  \return  EC_METHOD object
+ */
+OSSL_DEPRECATEDIN_3_0 const EC_METHOD *EC_GFp_nistp521_method(void);
+#   endif /* OPENSSL_NO_EC_NISTP_64_GCC_128 */
+
+#   ifndef OPENSSL_NO_EC2M
+/********************************************************************/
+/*           EC_METHOD for curves over GF(2^m)                      */
+/********************************************************************/
+
+/** Returns the basic GF2m ec method
+ *  \return  EC_METHOD object
+ */
+OSSL_DEPRECATEDIN_3_0 const EC_METHOD *EC_GF2m_simple_method(void);
+
+#   endif
+
+/********************************************************************/
+/*                   EC_GROUP functions                             */
+/********************************************************************/
+
+/**
+ *  Creates a new EC_GROUP object
+ *  \param   meth   EC_METHOD to use
+ *  \return  newly created EC_GROUP object or NULL in case of an error.
+ */
+OSSL_DEPRECATEDIN_3_0 EC_GROUP *EC_GROUP_new(const EC_METHOD *meth);
+
+/** Clears and frees a EC_GROUP object
+ *  \param  group  EC_GROUP object to be cleared and freed.
+ */
+OSSL_DEPRECATEDIN_3_0 void EC_GROUP_clear_free(EC_GROUP *group);
+
+/** Returns the EC_METHOD of the EC_GROUP object.
+ *  \param  group  EC_GROUP object
+ *  \return EC_METHOD used in this EC_GROUP object.
+ */
+OSSL_DEPRECATEDIN_3_0 const EC_METHOD *EC_GROUP_method_of(const EC_GROUP *group);
+
+/** Returns the field type of the EC_METHOD.
+ *  \param  meth  EC_METHOD object
+ *  \return NID of the underlying field type OID.
+ */
+OSSL_DEPRECATEDIN_3_0 int EC_METHOD_get_field_type(const EC_METHOD *meth);
+#  endif /* OPENSSL_NO_DEPRECATED_3_0 */
+
+/** Frees a EC_GROUP object
+ *  \param  group  EC_GROUP object to be freed.
+ */
+void EC_GROUP_free(EC_GROUP *group);
+
+/** Copies EC_GROUP objects. Note: both EC_GROUPs must use the same EC_METHOD.
+ *  \param  dst  destination EC_GROUP object
+ *  \param  src  source EC_GROUP object
+ *  \return 1 on success and 0 if an error occurred.
+ */
+int EC_GROUP_copy(EC_GROUP *dst, const EC_GROUP *src);
+
+/** Creates a new EC_GROUP object and copies the content
+ *  form src to the newly created EC_KEY object
+ *  \param  src  source EC_GROUP object
+ *  \return newly created EC_GROUP object or NULL in case of an error.
+ */
+EC_GROUP *EC_GROUP_dup(const EC_GROUP *src);
+
+/** Sets the generator and its order/cofactor of a EC_GROUP object.
+ *  \param  group      EC_GROUP object
+ *  \param  generator  EC_POINT object with the generator.
+ *  \param  order      the order of the group generated by the generator.
+ *  \param  cofactor   the index of the sub-group generated by the generator
+ *                     in the group of all points on the elliptic curve.
+ *  \return 1 on success and 0 if an error occurred
+ */
+int EC_GROUP_set_generator(EC_GROUP *group, const EC_POINT *generator,
+                           const BIGNUM *order, const BIGNUM *cofactor);
+
+/** Returns the generator of a EC_GROUP object.
+ *  \param  group  EC_GROUP object
+ *  \return the currently used generator (possibly NULL).
+ */
+const EC_POINT *EC_GROUP_get0_generator(const EC_GROUP *group);
+
+/** Returns the montgomery data for order(Generator)
+ *  \param  group  EC_GROUP object
+ *  \return the currently used montgomery data (possibly NULL).
+*/
+BN_MONT_CTX *EC_GROUP_get_mont_data(const EC_GROUP *group);
+
+/** Gets the order of a EC_GROUP
+ *  \param  group  EC_GROUP object
+ *  \param  order  BIGNUM to which the order is copied
+ *  \param  ctx    unused
+ *  \return 1 on success and 0 if an error occurred
+ */
+int EC_GROUP_get_order(const EC_GROUP *group, BIGNUM *order, BN_CTX *ctx);
+
+/** Gets the order of an EC_GROUP
+ *  \param  group  EC_GROUP object
+ *  \return the group order
+ */
+const BIGNUM *EC_GROUP_get0_order(const EC_GROUP *group);
+
+/** Gets the number of bits of the order of an EC_GROUP
+ *  \param  group  EC_GROUP object
+ *  \return number of bits of group order.
+ */
+int EC_GROUP_order_bits(const EC_GROUP *group);
+
+/** Gets the cofactor of a EC_GROUP
+ *  \param  group     EC_GROUP object
+ *  \param  cofactor  BIGNUM to which the cofactor is copied
+ *  \param  ctx       unused
+ *  \return 1 on success and 0 if an error occurred
+ */
+int EC_GROUP_get_cofactor(const EC_GROUP *group, BIGNUM *cofactor,
+                          BN_CTX *ctx);
+
+/** Gets the cofactor of an EC_GROUP
+ *  \param  group  EC_GROUP object
+ *  \return the group cofactor
+ */
+const BIGNUM *EC_GROUP_get0_cofactor(const EC_GROUP *group);
+
+/** Sets the name of a EC_GROUP object
+ *  \param  group  EC_GROUP object
+ *  \param  nid    NID of the curve name OID
+ */
+void EC_GROUP_set_curve_name(EC_GROUP *group, int nid);
+
+/** Returns the curve name of a EC_GROUP object
+ *  \param  group  EC_GROUP object
+ *  \return NID of the curve name OID or 0 if not set.
+ */
+int EC_GROUP_get_curve_name(const EC_GROUP *group);
+
+/** Gets the field of an EC_GROUP
+ *  \param  group  EC_GROUP object
+ *  \return the group field
+ */
+const BIGNUM *EC_GROUP_get0_field(const EC_GROUP *group);
+
+/** Returns the field type of the EC_GROUP.
+ *  \param  group  EC_GROUP object
+ *  \return NID of the underlying field type OID.
+ */
+int EC_GROUP_get_field_type(const EC_GROUP *group);
+
+void EC_GROUP_set_asn1_flag(EC_GROUP *group, int flag);
+int EC_GROUP_get_asn1_flag(const EC_GROUP *group);
+
+void EC_GROUP_set_point_conversion_form(EC_GROUP *group,
+                                        point_conversion_form_t form);
+point_conversion_form_t EC_GROUP_get_point_conversion_form(const EC_GROUP *);
+
+unsigned char *EC_GROUP_get0_seed(const EC_GROUP *x);
+size_t EC_GROUP_get_seed_len(const EC_GROUP *);
+size_t EC_GROUP_set_seed(EC_GROUP *, const unsigned char *, size_t len);
+
+/** Sets the parameters of an ec curve defined by y^2 = x^3 + a*x + b (for GFp)
+ *  or y^2 + x*y = x^3 + a*x^2 + b (for GF2m)
+ *  \param  group  EC_GROUP object
+ *  \param  p      BIGNUM with the prime number (GFp) or the polynomial
+ *                 defining the underlying field (GF2m)
+ *  \param  a      BIGNUM with parameter a of the equation
+ *  \param  b      BIGNUM with parameter b of the equation
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 on success and 0 if an error occurred
+ */
+int EC_GROUP_set_curve(EC_GROUP *group, const BIGNUM *p, const BIGNUM *a,
+                       const BIGNUM *b, BN_CTX *ctx);
+
+/** Gets the parameters of the ec curve defined by y^2 = x^3 + a*x + b (for GFp)
+ *  or y^2 + x*y = x^3 + a*x^2 + b (for GF2m)
+ *  \param  group  EC_GROUP object
+ *  \param  p      BIGNUM with the prime number (GFp) or the polynomial
+ *                 defining the underlying field (GF2m)
+ *  \param  a      BIGNUM for parameter a of the equation
+ *  \param  b      BIGNUM for parameter b of the equation
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 on success and 0 if an error occurred
+ */
+int EC_GROUP_get_curve(const EC_GROUP *group, BIGNUM *p, BIGNUM *a, BIGNUM *b,
+                       BN_CTX *ctx);
+
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+/** Sets the parameters of an ec curve. Synonym for EC_GROUP_set_curve
+ *  \param  group  EC_GROUP object
+ *  \param  p      BIGNUM with the prime number (GFp) or the polynomial
+ *                 defining the underlying field (GF2m)
+ *  \param  a      BIGNUM with parameter a of the equation
+ *  \param  b      BIGNUM with parameter b of the equation
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 on success and 0 if an error occurred
+ */
+OSSL_DEPRECATEDIN_3_0 int EC_GROUP_set_curve_GFp(EC_GROUP *group,
+                                                 const BIGNUM *p,
+                                                 const BIGNUM *a,
+                                                 const BIGNUM *b,
+                                                 BN_CTX *ctx);
+
+/** Gets the parameters of an ec curve. Synonym for EC_GROUP_get_curve
+ *  \param  group  EC_GROUP object
+ *  \param  p      BIGNUM with the prime number (GFp) or the polynomial
+ *                 defining the underlying field (GF2m)
+ *  \param  a      BIGNUM for parameter a of the equation
+ *  \param  b      BIGNUM for parameter b of the equation
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 on success and 0 if an error occurred
+ */
+OSSL_DEPRECATEDIN_3_0 int EC_GROUP_get_curve_GFp(const EC_GROUP *group,
+                                                 BIGNUM *p,
+                                                 BIGNUM *a, BIGNUM *b,
+                                                 BN_CTX *ctx);
+
+#   ifndef OPENSSL_NO_EC2M
+/** Sets the parameter of an ec curve. Synonym for EC_GROUP_set_curve
+ *  \param  group  EC_GROUP object
+ *  \param  p      BIGNUM with the prime number (GFp) or the polynomial
+ *                 defining the underlying field (GF2m)
+ *  \param  a      BIGNUM with parameter a of the equation
+ *  \param  b      BIGNUM with parameter b of the equation
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 on success and 0 if an error occurred
+ */
+OSSL_DEPRECATEDIN_3_0 int EC_GROUP_set_curve_GF2m(EC_GROUP *group,
+                                                  const BIGNUM *p,
+                                                  const BIGNUM *a,
+                                                  const BIGNUM *b,
+                                                  BN_CTX *ctx);
+
+/** Gets the parameters of an ec curve. Synonym for EC_GROUP_get_curve
+ *  \param  group  EC_GROUP object
+ *  \param  p      BIGNUM with the prime number (GFp) or the polynomial
+ *                 defining the underlying field (GF2m)
+ *  \param  a      BIGNUM for parameter a of the equation
+ *  \param  b      BIGNUM for parameter b of the equation
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 on success and 0 if an error occurred
+ */
+OSSL_DEPRECATEDIN_3_0 int EC_GROUP_get_curve_GF2m(const EC_GROUP *group,
+                                                  BIGNUM *p,
+                                                  BIGNUM *a, BIGNUM *b,
+                                                  BN_CTX *ctx);
+#   endif /* OPENSSL_NO_EC2M */
+#  endif /* OPENSSL_NO_DEPRECATED_3_0 */
+
+/** Returns the number of bits needed to represent a field element
+ *  \param  group  EC_GROUP object
+ *  \return number of bits needed to represent a field element
+ */
+int EC_GROUP_get_degree(const EC_GROUP *group);
+
+/** Checks whether the parameter in the EC_GROUP define a valid ec group
+ *  \param  group  EC_GROUP object
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 if group is a valid ec group and 0 otherwise
+ */
+int EC_GROUP_check(const EC_GROUP *group, BN_CTX *ctx);
+
+/** Checks whether the discriminant of the elliptic curve is zero or not
+ *  \param  group  EC_GROUP object
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 if the discriminant is not zero and 0 otherwise
+ */
+int EC_GROUP_check_discriminant(const EC_GROUP *group, BN_CTX *ctx);
+
+/** Compares two EC_GROUP objects
+ *  \param  a    first EC_GROUP object
+ *  \param  b    second EC_GROUP object
+ *  \param  ctx  BN_CTX object (optional)
+ *  \return 0 if the groups are equal, 1 if not, or -1 on error
+ */
+int EC_GROUP_cmp(const EC_GROUP *a, const EC_GROUP *b, BN_CTX *ctx);
+
+/*
+ * EC_GROUP_new_GF*() calls EC_GROUP_new() and EC_GROUP_set_GF*() after
+ * choosing an appropriate EC_METHOD
+ */
+
+/** Creates a new EC_GROUP object with the specified parameters defined
+ *  over GFp (defined by the equation y^2 = x^3 + a*x + b)
+ *  \param  p    BIGNUM with the prime number
+ *  \param  a    BIGNUM with the parameter a of the equation
+ *  \param  b    BIGNUM with the parameter b of the equation
+ *  \param  ctx  BN_CTX object (optional)
+ *  \return newly created EC_GROUP object with the specified parameters
+ */
+EC_GROUP *EC_GROUP_new_curve_GFp(const BIGNUM *p, const BIGNUM *a,
+                                 const BIGNUM *b, BN_CTX *ctx);
+#  ifndef OPENSSL_NO_EC2M
+/** Creates a new EC_GROUP object with the specified parameters defined
+ *  over GF2m (defined by the equation y^2 + x*y = x^3 + a*x^2 + b)
+ *  \param  p    BIGNUM with the polynomial defining the underlying field
+ *  \param  a    BIGNUM with the parameter a of the equation
+ *  \param  b    BIGNUM with the parameter b of the equation
+ *  \param  ctx  BN_CTX object (optional)
+ *  \return newly created EC_GROUP object with the specified parameters
+ */
+EC_GROUP *EC_GROUP_new_curve_GF2m(const BIGNUM *p, const BIGNUM *a,
+                                  const BIGNUM *b, BN_CTX *ctx);
+#  endif
+
+/**
+ * Creates a EC_GROUP object with a curve specified by parameters.
+ * The parameters may be explicit or a named curve,
+ *  \param  params A list of parameters describing the group.
+ *  \param  libctx The associated library context or NULL for the default
+ *                 context
+ *  \param  propq  A property query string
+ *  \return newly created EC_GROUP object with specified parameters or NULL
+ *          if an error occurred
+ */
+EC_GROUP *EC_GROUP_new_from_params(const OSSL_PARAM params[],
+                                   OSSL_LIB_CTX *libctx, const char *propq);
+
+/**
+ * Creates an OSSL_PARAM array with the parameters describing the given
+ * EC_GROUP.
+ * The resulting parameters may contain an explicit or a named curve depending
+ * on the EC_GROUP.
+ *  \param  group  pointer to the EC_GROUP object
+ *  \param  libctx The associated library context or NULL for the default
+ *                 context
+ *  \param  propq  A property query string
+ *  \param  bnctx  BN_CTX object (optional)
+ *  \return newly created OSSL_PARAM array with the parameters
+ *          describing the given EC_GROUP or NULL if an error occurred
+ */
+OSSL_PARAM *EC_GROUP_to_params(const EC_GROUP *group, OSSL_LIB_CTX *libctx,
+                               const char *propq, BN_CTX *bnctx);
+
+/**
+ * Creates a EC_GROUP object with a curve specified by a NID
+ *  \param  libctx The associated library context or NULL for the default
+ *                 context
+ *  \param  propq  A property query string
+ *  \param  nid    NID of the OID of the curve name
+ *  \return newly created EC_GROUP object with specified curve or NULL
+ *          if an error occurred
+ */
+EC_GROUP *EC_GROUP_new_by_curve_name_ex(OSSL_LIB_CTX *libctx, const char *propq,
+                                        int nid);
+
+/**
+ * Creates a EC_GROUP object with a curve specified by a NID. Same as
+ * EC_GROUP_new_by_curve_name_ex but the libctx and propq are always
+ * NULL.
+ *  \param  nid    NID of the OID of the curve name
+ *  \return newly created EC_GROUP object with specified curve or NULL
+ *          if an error occurred
+ */
+EC_GROUP *EC_GROUP_new_by_curve_name(int nid);
+
+/** Creates a new EC_GROUP object from an ECPARAMETERS object
+ *  \param  params  pointer to the ECPARAMETERS object
+ *  \return newly created EC_GROUP object with specified curve or NULL
+ *          if an error occurred
+ */
+EC_GROUP *EC_GROUP_new_from_ecparameters(const ECPARAMETERS *params);
+
+/** Creates an ECPARAMETERS object for the given EC_GROUP object.
+ *  \param  group   pointer to the EC_GROUP object
+ *  \param  params  pointer to an existing ECPARAMETERS object or NULL
+ *  \return pointer to the new ECPARAMETERS object or NULL
+ *          if an error occurred.
+ */
+ECPARAMETERS *EC_GROUP_get_ecparameters(const EC_GROUP *group,
+                                        ECPARAMETERS *params);
+
+/** Creates a new EC_GROUP object from an ECPKPARAMETERS object
+ *  \param  params  pointer to an existing ECPKPARAMETERS object, or NULL
+ *  \return newly created EC_GROUP object with specified curve, or NULL
+ *          if an error occurred
+ */
+EC_GROUP *EC_GROUP_new_from_ecpkparameters(const ECPKPARAMETERS *params);
+
+/** Creates an ECPKPARAMETERS object for the given EC_GROUP object.
+ *  \param  group   pointer to the EC_GROUP object
+ *  \param  params  pointer to an existing ECPKPARAMETERS object or NULL
+ *  \return pointer to the new ECPKPARAMETERS object or NULL
+ *          if an error occurred.
+ */
+ECPKPARAMETERS *EC_GROUP_get_ecpkparameters(const EC_GROUP *group,
+                                            ECPKPARAMETERS *params);
+
+/********************************************************************/
+/*               handling of internal curves                        */
+/********************************************************************/
+
+typedef struct {
+    int nid;
+    const char *comment;
+} EC_builtin_curve;
+
+/*
+ * EC_builtin_curves(EC_builtin_curve *r, size_t size) returns number of all
+ * available curves or zero if a error occurred. In case r is not zero,
+ * nitems EC_builtin_curve structures are filled with the data of the first
+ * nitems internal groups
+ */
+size_t EC_get_builtin_curves(EC_builtin_curve *r, size_t nitems);
+
+const char *EC_curve_nid2nist(int nid);
+int EC_curve_nist2nid(const char *name);
+int EC_GROUP_check_named_curve(const EC_GROUP *group, int nist_only,
+                               BN_CTX *ctx);
+
+/********************************************************************/
+/*                    EC_POINT functions                            */
+/********************************************************************/
+
+/** Creates a new EC_POINT object for the specified EC_GROUP
+ *  \param  group  EC_GROUP the underlying EC_GROUP object
+ *  \return newly created EC_POINT object or NULL if an error occurred
+ */
+EC_POINT *EC_POINT_new(const EC_GROUP *group);
+
+/** Frees a EC_POINT object
+ *  \param  point  EC_POINT object to be freed
+ */
+void EC_POINT_free(EC_POINT *point);
+
+/** Clears and frees a EC_POINT object
+ *  \param  point  EC_POINT object to be cleared and freed
+ */
+void EC_POINT_clear_free(EC_POINT *point);
+
+/** Copies EC_POINT object
+ *  \param  dst  destination EC_POINT object
+ *  \param  src  source EC_POINT object
+ *  \return 1 on success and 0 if an error occurred
+ */
+int EC_POINT_copy(EC_POINT *dst, const EC_POINT *src);
+
+/** Creates a new EC_POINT object and copies the content of the supplied
+ *  EC_POINT
+ *  \param  src    source EC_POINT object
+ *  \param  group  underlying the EC_GROUP object
+ *  \return newly created EC_POINT object or NULL if an error occurred
+ */
+EC_POINT *EC_POINT_dup(const EC_POINT *src, const EC_GROUP *group);
+
+/** Sets a point to infinity (neutral element)
+ *  \param  group  underlying EC_GROUP object
+ *  \param  point  EC_POINT to set to infinity
+ *  \return 1 on success and 0 if an error occurred
+ */
+int EC_POINT_set_to_infinity(const EC_GROUP *group, EC_POINT *point);
+
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+/** Returns the EC_METHOD used in EC_POINT object
+ *  \param  point  EC_POINT object
+ *  \return the EC_METHOD used
+ */
+OSSL_DEPRECATEDIN_3_0 const EC_METHOD *EC_POINT_method_of(const EC_POINT *point);
+
+/** Sets the jacobian projective coordinates of a EC_POINT over GFp
+ *  \param  group  underlying EC_GROUP object
+ *  \param  p      EC_POINT object
+ *  \param  x      BIGNUM with the x-coordinate
+ *  \param  y      BIGNUM with the y-coordinate
+ *  \param  z      BIGNUM with the z-coordinate
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 on success and 0 if an error occurred
+ */
+OSSL_DEPRECATEDIN_3_0 int EC_POINT_set_Jprojective_coordinates_GFp
+                      (const EC_GROUP *group, EC_POINT *p,
+                       const BIGNUM *x, const BIGNUM *y, const BIGNUM *z,
+                       BN_CTX *ctx);
+
+/** Gets the jacobian projective coordinates of a EC_POINT over GFp
+ *  \param  group  underlying EC_GROUP object
+ *  \param  p      EC_POINT object
+ *  \param  x      BIGNUM for the x-coordinate
+ *  \param  y      BIGNUM for the y-coordinate
+ *  \param  z      BIGNUM for the z-coordinate
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 on success and 0 if an error occurred
+ */
+OSSL_DEPRECATEDIN_3_0 int EC_POINT_get_Jprojective_coordinates_GFp
+                      (const EC_GROUP *group, const EC_POINT *p,
+                       BIGNUM *x, BIGNUM *y, BIGNUM *z, BN_CTX *ctx);
+#  endif /* OPENSSL_NO_DEPRECATED_3_0 */
+
+/** Sets the affine coordinates of an EC_POINT
+ *  \param  group  underlying EC_GROUP object
+ *  \param  p      EC_POINT object
+ *  \param  x      BIGNUM with the x-coordinate
+ *  \param  y      BIGNUM with the y-coordinate
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 on success and 0 if an error occurred
+ */
+int EC_POINT_set_affine_coordinates(const EC_GROUP *group, EC_POINT *p,
+                                    const BIGNUM *x, const BIGNUM *y,
+                                    BN_CTX *ctx);
+
+/** Gets the affine coordinates of an EC_POINT.
+ *  \param  group  underlying EC_GROUP object
+ *  \param  p      EC_POINT object
+ *  \param  x      BIGNUM for the x-coordinate
+ *  \param  y      BIGNUM for the y-coordinate
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 on success and 0 if an error occurred
+ */
+int EC_POINT_get_affine_coordinates(const EC_GROUP *group, const EC_POINT *p,
+                                    BIGNUM *x, BIGNUM *y, BN_CTX *ctx);
+
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+/** Sets the affine coordinates of an EC_POINT. A synonym of
+ *  EC_POINT_set_affine_coordinates
+ *  \param  group  underlying EC_GROUP object
+ *  \param  p      EC_POINT object
+ *  \param  x      BIGNUM with the x-coordinate
+ *  \param  y      BIGNUM with the y-coordinate
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 on success and 0 if an error occurred
+ */
+OSSL_DEPRECATEDIN_3_0 int EC_POINT_set_affine_coordinates_GFp
+                      (const EC_GROUP *group, EC_POINT *p,
+                       const BIGNUM *x, const BIGNUM *y, BN_CTX *ctx);
+
+/** Gets the affine coordinates of an EC_POINT. A synonym of
+ *  EC_POINT_get_affine_coordinates
+ *  \param  group  underlying EC_GROUP object
+ *  \param  p      EC_POINT object
+ *  \param  x      BIGNUM for the x-coordinate
+ *  \param  y      BIGNUM for the y-coordinate
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 on success and 0 if an error occurred
+ */
+OSSL_DEPRECATEDIN_3_0 int EC_POINT_get_affine_coordinates_GFp
+                      (const EC_GROUP *group, const EC_POINT *p,
+                       BIGNUM *x, BIGNUM *y, BN_CTX *ctx);
+#  endif /* OPENSSL_NO_DEPRECATED_3_0 */
+
+/** Sets the x9.62 compressed coordinates of a EC_POINT
+ *  \param  group  underlying EC_GROUP object
+ *  \param  p      EC_POINT object
+ *  \param  x      BIGNUM with x-coordinate
+ *  \param  y_bit  integer with the y-Bit (either 0 or 1)
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 on success and 0 if an error occurred
+ */
+int EC_POINT_set_compressed_coordinates(const EC_GROUP *group, EC_POINT *p,
+                                        const BIGNUM *x, int y_bit,
+                                        BN_CTX *ctx);
+
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+/** Sets the x9.62 compressed coordinates of a EC_POINT. A synonym of
+ *  EC_POINT_set_compressed_coordinates
+ *  \param  group  underlying EC_GROUP object
+ *  \param  p      EC_POINT object
+ *  \param  x      BIGNUM with x-coordinate
+ *  \param  y_bit  integer with the y-Bit (either 0 or 1)
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 on success and 0 if an error occurred
+ */
+OSSL_DEPRECATEDIN_3_0 int EC_POINT_set_compressed_coordinates_GFp
+                      (const EC_GROUP *group, EC_POINT *p,
+                       const BIGNUM *x, int y_bit, BN_CTX *ctx);
+#   ifndef OPENSSL_NO_EC2M
+/** Sets the affine coordinates of an EC_POINT. A synonym of
+ *  EC_POINT_set_affine_coordinates
+ *  \param  group  underlying EC_GROUP object
+ *  \param  p      EC_POINT object
+ *  \param  x      BIGNUM with the x-coordinate
+ *  \param  y      BIGNUM with the y-coordinate
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 on success and 0 if an error occurred
+ */
+OSSL_DEPRECATEDIN_3_0 int EC_POINT_set_affine_coordinates_GF2m
+                      (const EC_GROUP *group, EC_POINT *p,
+                       const BIGNUM *x, const BIGNUM *y, BN_CTX *ctx);
+
+/** Gets the affine coordinates of an EC_POINT. A synonym of
+ *  EC_POINT_get_affine_coordinates
+ *  \param  group  underlying EC_GROUP object
+ *  \param  p      EC_POINT object
+ *  \param  x      BIGNUM for the x-coordinate
+ *  \param  y      BIGNUM for the y-coordinate
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 on success and 0 if an error occurred
+ */
+OSSL_DEPRECATEDIN_3_0 int EC_POINT_get_affine_coordinates_GF2m
+                      (const EC_GROUP *group, const EC_POINT *p,
+                       BIGNUM *x, BIGNUM *y, BN_CTX *ctx);
+
+/** Sets the x9.62 compressed coordinates of a EC_POINT. A synonym of
+ *  EC_POINT_set_compressed_coordinates
+ *  \param  group  underlying EC_GROUP object
+ *  \param  p      EC_POINT object
+ *  \param  x      BIGNUM with x-coordinate
+ *  \param  y_bit  integer with the y-Bit (either 0 or 1)
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 on success and 0 if an error occurred
+ */
+OSSL_DEPRECATEDIN_3_0 int EC_POINT_set_compressed_coordinates_GF2m
+                      (const EC_GROUP *group, EC_POINT *p,
+                       const BIGNUM *x, int y_bit, BN_CTX *ctx);
+#   endif
+#  endif /* OPENSSL_NO_DEPRECATED_3_0 */
+
+/** Encodes a EC_POINT object to a octet string
+ *  \param  group  underlying EC_GROUP object
+ *  \param  p      EC_POINT object
+ *  \param  form   point conversion form
+ *  \param  buf    memory buffer for the result. If NULL the function returns
+ *                 required buffer size.
+ *  \param  len    length of the memory buffer
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return the length of the encoded octet string or 0 if an error occurred
+ */
+size_t EC_POINT_point2oct(const EC_GROUP *group, const EC_POINT *p,
+                          point_conversion_form_t form,
+                          unsigned char *buf, size_t len, BN_CTX *ctx);
+
+/** Decodes a EC_POINT from a octet string
+ *  \param  group  underlying EC_GROUP object
+ *  \param  p      EC_POINT object
+ *  \param  buf    memory buffer with the encoded ec point
+ *  \param  len    length of the encoded ec point
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 on success and 0 if an error occurred
+ */
+int EC_POINT_oct2point(const EC_GROUP *group, EC_POINT *p,
+                       const unsigned char *buf, size_t len, BN_CTX *ctx);
+
+/** Encodes an EC_POINT object to an allocated octet string
+ *  \param  group  underlying EC_GROUP object
+ *  \param  point  EC_POINT object
+ *  \param  form   point conversion form
+ *  \param  pbuf   returns pointer to allocated buffer
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return the length of the encoded octet string or 0 if an error occurred
+ */
+size_t EC_POINT_point2buf(const EC_GROUP *group, const EC_POINT *point,
+                          point_conversion_form_t form,
+                          unsigned char **pbuf, BN_CTX *ctx);
+
+/* other interfaces to point2oct/oct2point: */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 BIGNUM *EC_POINT_point2bn(const EC_GROUP *,
+                                                const EC_POINT *,
+                                                point_conversion_form_t form,
+                                                BIGNUM *, BN_CTX *);
+OSSL_DEPRECATEDIN_3_0 EC_POINT *EC_POINT_bn2point(const EC_GROUP *,
+                                                  const BIGNUM *,
+                                                  EC_POINT *, BN_CTX *);
+#  endif /* OPENSSL_NO_DEPRECATED_3_0 */
+
+char *EC_POINT_point2hex(const EC_GROUP *, const EC_POINT *,
+                         point_conversion_form_t form, BN_CTX *);
+EC_POINT *EC_POINT_hex2point(const EC_GROUP *, const char *,
+                             EC_POINT *, BN_CTX *);
+
+/********************************************************************/
+/*         functions for doing EC_POINT arithmetic                  */
+/********************************************************************/
+
+/** Computes the sum of two EC_POINT
+ *  \param  group  underlying EC_GROUP object
+ *  \param  r      EC_POINT object for the result (r = a + b)
+ *  \param  a      EC_POINT object with the first summand
+ *  \param  b      EC_POINT object with the second summand
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 on success and 0 if an error occurred
+ */
+int EC_POINT_add(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a,
+                 const EC_POINT *b, BN_CTX *ctx);
+
+/** Computes the double of a EC_POINT
+ *  \param  group  underlying EC_GROUP object
+ *  \param  r      EC_POINT object for the result (r = 2 * a)
+ *  \param  a      EC_POINT object
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 on success and 0 if an error occurred
+ */
+int EC_POINT_dbl(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a,
+                 BN_CTX *ctx);
+
+/** Computes the inverse of a EC_POINT
+ *  \param  group  underlying EC_GROUP object
+ *  \param  a      EC_POINT object to be inverted (it's used for the result as well)
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 on success and 0 if an error occurred
+ */
+int EC_POINT_invert(const EC_GROUP *group, EC_POINT *a, BN_CTX *ctx);
+
+/** Checks whether the point is the neutral element of the group
+ *  \param  group  the underlying EC_GROUP object
+ *  \param  p      EC_POINT object
+ *  \return 1 if the point is the neutral element and 0 otherwise
+ */
+int EC_POINT_is_at_infinity(const EC_GROUP *group, const EC_POINT *p);
+
+/** Checks whether the point is on the curve
+ *  \param  group  underlying EC_GROUP object
+ *  \param  point  EC_POINT object to check
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 if the point is on the curve, 0 if not, or -1 on error
+ */
+int EC_POINT_is_on_curve(const EC_GROUP *group, const EC_POINT *point,
+                         BN_CTX *ctx);
+
+/** Compares two EC_POINTs
+ *  \param  group  underlying EC_GROUP object
+ *  \param  a      first EC_POINT object
+ *  \param  b      second EC_POINT object
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 if the points are not equal, 0 if they are, or -1 on error
+ */
+int EC_POINT_cmp(const EC_GROUP *group, const EC_POINT *a, const EC_POINT *b,
+                 BN_CTX *ctx);
+
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int EC_POINT_make_affine(const EC_GROUP *group,
+                                               EC_POINT *point, BN_CTX *ctx);
+OSSL_DEPRECATEDIN_3_0 int EC_POINTs_make_affine(const EC_GROUP *group, size_t num,
+                                                EC_POINT *points[], BN_CTX *ctx);
+
+/** Computes r = generator * n + sum_{i=0}^{num-1} p[i] * m[i]
+ *  \param  group  underlying EC_GROUP object
+ *  \param  r      EC_POINT object for the result
+ *  \param  n      BIGNUM with the multiplier for the group generator (optional)
+ *  \param  num    number further summands
+ *  \param  p      array of size num of EC_POINT objects
+ *  \param  m      array of size num of BIGNUM objects
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 on success and 0 if an error occurred
+ */
+OSSL_DEPRECATEDIN_3_0 int EC_POINTs_mul(const EC_GROUP *group, EC_POINT *r,
+                                        const BIGNUM *n, size_t num,
+                                        const EC_POINT *p[], const BIGNUM *m[],
+                                        BN_CTX *ctx);
+#  endif /* OPENSSL_NO_DEPRECATED_3_0 */
+
+/** Computes r = generator * n + q * m
+ *  \param  group  underlying EC_GROUP object
+ *  \param  r      EC_POINT object for the result
+ *  \param  n      BIGNUM with the multiplier for the group generator (optional)
+ *  \param  q      EC_POINT object with the first factor of the second summand
+ *  \param  m      BIGNUM with the second factor of the second summand
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 on success and 0 if an error occurred
+ */
+int EC_POINT_mul(const EC_GROUP *group, EC_POINT *r, const BIGNUM *n,
+                 const EC_POINT *q, const BIGNUM *m, BN_CTX *ctx);
+
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+/** Stores multiples of generator for faster point multiplication
+ *  \param  group  EC_GROUP object
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 on success and 0 if an error occurred
+ */
+OSSL_DEPRECATEDIN_3_0 int EC_GROUP_precompute_mult(EC_GROUP *group, BN_CTX *ctx);
+
+/** Reports whether a precomputation has been done
+ *  \param  group  EC_GROUP object
+ *  \return 1 if a pre-computation has been done and 0 otherwise
+ */
+OSSL_DEPRECATEDIN_3_0 int EC_GROUP_have_precompute_mult(const EC_GROUP *group);
+#  endif /* OPENSSL_NO_DEPRECATED_3_0 */
+
+/********************************************************************/
+/*                       ASN1 stuff                                 */
+/********************************************************************/
+
+DECLARE_ASN1_ITEM(ECPKPARAMETERS)
+DECLARE_ASN1_ALLOC_FUNCTIONS(ECPKPARAMETERS)
+DECLARE_ASN1_ITEM(ECPARAMETERS)
+DECLARE_ASN1_ALLOC_FUNCTIONS(ECPARAMETERS)
+
+/*
+ * EC_GROUP_get_basis_type() returns the NID of the basis type used to
+ * represent the field elements
+ */
+int EC_GROUP_get_basis_type(const EC_GROUP *);
+#  ifndef OPENSSL_NO_EC2M
+int EC_GROUP_get_trinomial_basis(const EC_GROUP *, unsigned int *k);
+int EC_GROUP_get_pentanomial_basis(const EC_GROUP *, unsigned int *k1,
+                                   unsigned int *k2, unsigned int *k3);
+#  endif
+
+EC_GROUP *d2i_ECPKParameters(EC_GROUP **, const unsigned char **in, long len);
+int i2d_ECPKParameters(const EC_GROUP *, unsigned char **out);
+
+#  define d2i_ECPKParameters_bio(bp,x) \
+    ASN1_d2i_bio_of(EC_GROUP, NULL, d2i_ECPKParameters, bp, x)
+#  define i2d_ECPKParameters_bio(bp,x) \
+    ASN1_i2d_bio_of(EC_GROUP, i2d_ECPKParameters, bp, x)
+#  define d2i_ECPKParameters_fp(fp,x) \
+    (EC_GROUP *)ASN1_d2i_fp(NULL, (d2i_of_void *)d2i_ECPKParameters, (fp), \
+                            (void **)(x))
+#  define i2d_ECPKParameters_fp(fp,x) \
+    ASN1_i2d_fp((i2d_of_void *)i2d_ECPKParameters, (fp), (void *)(x))
+
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int ECPKParameters_print(BIO *bp, const EC_GROUP *x,
+                                               int off);
+#   ifndef OPENSSL_NO_STDIO
+OSSL_DEPRECATEDIN_3_0 int ECPKParameters_print_fp(FILE *fp, const EC_GROUP *x,
+                                                  int off);
+#   endif
+#  endif /* OPENSSL_NO_DEPRECATED_3_0 */
+
+/********************************************************************/
+/*                      EC_KEY functions                            */
+/********************************************************************/
+
+/* some values for the encoding_flag */
+#  define EC_PKEY_NO_PARAMETERS   0x001
+#  define EC_PKEY_NO_PUBKEY       0x002
+
+/* some values for the flags field */
+#  define EC_FLAG_SM2_RANGE              0x0004
+#  define EC_FLAG_COFACTOR_ECDH          0x1000
+#  define EC_FLAG_CHECK_NAMED_GROUP      0x2000
+#  define EC_FLAG_CHECK_NAMED_GROUP_NIST 0x4000
+#  define EC_FLAG_CHECK_NAMED_GROUP_MASK \
+    (EC_FLAG_CHECK_NAMED_GROUP | EC_FLAG_CHECK_NAMED_GROUP_NIST)
+
+/* Deprecated flags -  it was using 0x01..0x02 */
+#  define EC_FLAG_NON_FIPS_ALLOW         0x0000
+#  define EC_FLAG_FIPS_CHECKED           0x0000
+
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+/**
+ *  Creates a new EC_KEY object.
+ *  \param  ctx  The library context for to use for this EC_KEY. May be NULL in
+ *               which case the default library context is used.
+ *  \return EC_KEY object or NULL if an error occurred.
+ */
+OSSL_DEPRECATEDIN_3_0 EC_KEY *EC_KEY_new_ex(OSSL_LIB_CTX *ctx, const char *propq);
+
+/**
+ *  Creates a new EC_KEY object. Same as calling EC_KEY_new_ex with a
+ *  NULL library context
+ *  \return EC_KEY object or NULL if an error occurred.
+ */
+OSSL_DEPRECATEDIN_3_0 EC_KEY *EC_KEY_new(void);
+
+OSSL_DEPRECATEDIN_3_0 int EC_KEY_get_flags(const EC_KEY *key);
+
+OSSL_DEPRECATEDIN_3_0 void EC_KEY_set_flags(EC_KEY *key, int flags);
+
+OSSL_DEPRECATEDIN_3_0 void EC_KEY_clear_flags(EC_KEY *key, int flags);
+
+OSSL_DEPRECATEDIN_3_0 int EC_KEY_decoded_from_explicit_params(const EC_KEY *key);
+
+/**
+ *  Creates a new EC_KEY object using a named curve as underlying
+ *  EC_GROUP object.
+ *  \param  ctx   The library context for to use for this EC_KEY. May be NULL in
+ *                which case the default library context is used.
+ *  \param  propq Any property query string
+ *  \param  nid   NID of the named curve.
+ *  \return EC_KEY object or NULL if an error occurred.
+ */
+OSSL_DEPRECATEDIN_3_0 EC_KEY *EC_KEY_new_by_curve_name_ex(OSSL_LIB_CTX *ctx,
+                                                          const char *propq,
+                                                          int nid);
+
+/**
+ *  Creates a new EC_KEY object using a named curve as underlying
+ *  EC_GROUP object. Same as calling EC_KEY_new_by_curve_name_ex with a NULL
+ *  library context and property query string.
+ *  \param  nid  NID of the named curve.
+ *  \return EC_KEY object or NULL if an error occurred.
+ */
+OSSL_DEPRECATEDIN_3_0 EC_KEY *EC_KEY_new_by_curve_name(int nid);
+
+/** Frees a EC_KEY object.
+ *  \param  key  EC_KEY object to be freed.
+ */
+OSSL_DEPRECATEDIN_3_0 void EC_KEY_free(EC_KEY *key);
+
+/** Copies a EC_KEY object.
+ *  \param  dst  destination EC_KEY object
+ *  \param  src  src EC_KEY object
+ *  \return dst or NULL if an error occurred.
+ */
+OSSL_DEPRECATEDIN_3_0 EC_KEY *EC_KEY_copy(EC_KEY *dst, const EC_KEY *src);
+
+/** Creates a new EC_KEY object and copies the content from src to it.
+ *  \param  src  the source EC_KEY object
+ *  \return newly created EC_KEY object or NULL if an error occurred.
+ */
+OSSL_DEPRECATEDIN_3_0 EC_KEY *EC_KEY_dup(const EC_KEY *src);
+
+/** Increases the internal reference count of a EC_KEY object.
+ *  \param  key  EC_KEY object
+ *  \return 1 on success and 0 if an error occurred.
+ */
+OSSL_DEPRECATEDIN_3_0 int EC_KEY_up_ref(EC_KEY *key);
+
+/** Returns the ENGINE object of a EC_KEY object
+ *  \param  eckey  EC_KEY object
+ *  \return the ENGINE object (possibly NULL).
+ */
+OSSL_DEPRECATEDIN_3_0 ENGINE *EC_KEY_get0_engine(const EC_KEY *eckey);
+
+/** Returns the EC_GROUP object of a EC_KEY object
+ *  \param  key  EC_KEY object
+ *  \return the EC_GROUP object (possibly NULL).
+ */
+OSSL_DEPRECATEDIN_3_0 const EC_GROUP *EC_KEY_get0_group(const EC_KEY *key);
+
+/** Sets the EC_GROUP of a EC_KEY object.
+ *  \param  key    EC_KEY object
+ *  \param  group  EC_GROUP to use in the EC_KEY object (note: the EC_KEY
+ *                 object will use an own copy of the EC_GROUP).
+ *  \return 1 on success and 0 if an error occurred.
+ */
+OSSL_DEPRECATEDIN_3_0 int EC_KEY_set_group(EC_KEY *key, const EC_GROUP *group);
+
+/** Returns the private key of a EC_KEY object.
+ *  \param  key  EC_KEY object
+ *  \return a BIGNUM with the private key (possibly NULL).
+ */
+OSSL_DEPRECATEDIN_3_0 const BIGNUM *EC_KEY_get0_private_key(const EC_KEY *key);
+
+/** Sets the private key of a EC_KEY object.
+ *  \param  key  EC_KEY object
+ *  \param  prv  BIGNUM with the private key (note: the EC_KEY object
+ *               will use an own copy of the BIGNUM).
+ *  \return 1 on success and 0 if an error occurred.
+ */
+OSSL_DEPRECATEDIN_3_0 int EC_KEY_set_private_key(EC_KEY *key, const BIGNUM *prv);
+
+/** Returns the public key of a EC_KEY object.
+ *  \param  key  the EC_KEY object
+ *  \return a EC_POINT object with the public key (possibly NULL)
+ */
+OSSL_DEPRECATEDIN_3_0 const EC_POINT *EC_KEY_get0_public_key(const EC_KEY *key);
+
+/** Sets the public key of a EC_KEY object.
+ *  \param  key  EC_KEY object
+ *  \param  pub  EC_POINT object with the public key (note: the EC_KEY object
+ *               will use an own copy of the EC_POINT object).
+ *  \return 1 on success and 0 if an error occurred.
+ */
+OSSL_DEPRECATEDIN_3_0 int EC_KEY_set_public_key(EC_KEY *key, const EC_POINT *pub);
+
+OSSL_DEPRECATEDIN_3_0 unsigned EC_KEY_get_enc_flags(const EC_KEY *key);
+OSSL_DEPRECATEDIN_3_0 void EC_KEY_set_enc_flags(EC_KEY *eckey, unsigned int flags);
+OSSL_DEPRECATEDIN_3_0 point_conversion_form_t EC_KEY_get_conv_form(const EC_KEY *key);
+OSSL_DEPRECATEDIN_3_0 void EC_KEY_set_conv_form(EC_KEY *eckey,
+                                                point_conversion_form_t cform);
+#  endif /*OPENSSL_NO_DEPRECATED_3_0 */
+
+#  define EC_KEY_get_ex_new_index(l, p, newf, dupf, freef) \
+    CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_EC_KEY, l, p, newf, dupf, freef)
+
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int EC_KEY_set_ex_data(EC_KEY *key, int idx, void *arg);
+OSSL_DEPRECATEDIN_3_0 void *EC_KEY_get_ex_data(const EC_KEY *key, int idx);
+
+/* wrapper functions for the underlying EC_GROUP object */
+OSSL_DEPRECATEDIN_3_0 void EC_KEY_set_asn1_flag(EC_KEY *eckey, int asn1_flag);
+
+/** Creates a table of pre-computed multiples of the generator to
+ *  accelerate further EC_KEY operations.
+ *  \param  key  EC_KEY object
+ *  \param  ctx  BN_CTX object (optional)
+ *  \return 1 on success and 0 if an error occurred.
+ */
+OSSL_DEPRECATEDIN_3_0 int EC_KEY_precompute_mult(EC_KEY *key, BN_CTX *ctx);
+
+/** Creates a new ec private (and optional a new public) key.
+ *  \param  key  EC_KEY object
+ *  \return 1 on success and 0 if an error occurred.
+ */
+OSSL_DEPRECATEDIN_3_0 int EC_KEY_generate_key(EC_KEY *key);
+
+/** Verifies that a private and/or public key is valid.
+ *  \param  key  the EC_KEY object
+ *  \return 1 on success and 0 otherwise.
+ */
+OSSL_DEPRECATEDIN_3_0 int EC_KEY_check_key(const EC_KEY *key);
+
+/** Indicates if an EC_KEY can be used for signing.
+ *  \param  eckey  the EC_KEY object
+ *  \return 1 if can sign and 0 otherwise.
+ */
+OSSL_DEPRECATEDIN_3_0 int EC_KEY_can_sign(const EC_KEY *eckey);
+
+/** Sets a public key from affine coordinates performing
+ *  necessary NIST PKV tests.
+ *  \param  key  the EC_KEY object
+ *  \param  x    public key x coordinate
+ *  \param  y    public key y coordinate
+ *  \return 1 on success and 0 otherwise.
+ */
+OSSL_DEPRECATEDIN_3_0 int EC_KEY_set_public_key_affine_coordinates(EC_KEY *key,
+                                                                   BIGNUM *x,
+                                                                   BIGNUM *y);
+
+/** Encodes an EC_KEY public key to an allocated octet string
+ *  \param  key    key to encode
+ *  \param  form   point conversion form
+ *  \param  pbuf   returns pointer to allocated buffer
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return the length of the encoded octet string or 0 if an error occurred
+ */
+OSSL_DEPRECATEDIN_3_0 size_t EC_KEY_key2buf(const EC_KEY *key,
+                                            point_conversion_form_t form,
+                                            unsigned char **pbuf, BN_CTX *ctx);
+
+/** Decodes a EC_KEY public key from a octet string
+ *  \param  key    key to decode
+ *  \param  buf    memory buffer with the encoded ec point
+ *  \param  len    length of the encoded ec point
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 on success and 0 if an error occurred
+ */
+
+OSSL_DEPRECATEDIN_3_0 int EC_KEY_oct2key(EC_KEY *key, const unsigned char *buf,
+                                         size_t len, BN_CTX *ctx);
+
+/** Decodes an EC_KEY private key from an octet string
+ *  \param  key    key to decode
+ *  \param  buf    memory buffer with the encoded private key
+ *  \param  len    length of the encoded key
+ *  \return 1 on success and 0 if an error occurred
+ */
+
+OSSL_DEPRECATEDIN_3_0 int EC_KEY_oct2priv(EC_KEY *key, const unsigned char *buf,
+                                          size_t len);
+
+/** Encodes a EC_KEY private key to an octet string
+ *  \param  key    key to encode
+ *  \param  buf    memory buffer for the result. If NULL the function returns
+ *                 required buffer size.
+ *  \param  len    length of the memory buffer
+ *  \return the length of the encoded octet string or 0 if an error occurred
+ */
+
+OSSL_DEPRECATEDIN_3_0 size_t EC_KEY_priv2oct(const EC_KEY *key,
+                                             unsigned char *buf, size_t len);
+
+/** Encodes an EC_KEY private key to an allocated octet string
+ *  \param  eckey  key to encode
+ *  \param  pbuf   returns pointer to allocated buffer
+ *  \return the length of the encoded octet string or 0 if an error occurred
+ */
+OSSL_DEPRECATEDIN_3_0 size_t EC_KEY_priv2buf(const EC_KEY *eckey,
+                                             unsigned char **pbuf);
+
+/********************************************************************/
+/*        de- and encoding functions for SEC1 ECPrivateKey          */
+/********************************************************************/
+
+/** Decodes a private key from a memory buffer.
+ *  \param  key  a pointer to a EC_KEY object which should be used (or NULL)
+ *  \param  in   pointer to memory with the DER encoded private key
+ *  \param  len  length of the DER encoded private key
+ *  \return the decoded private key or NULL if an error occurred.
+ */
+OSSL_DEPRECATEDIN_3_0 EC_KEY *d2i_ECPrivateKey(EC_KEY **key,
+                                               const unsigned char **in,
+                                               long len);
+
+/** Encodes a private key object and stores the result in a buffer.
+ *  \param  key  the EC_KEY object to encode
+ *  \param  out  the buffer for the result (if NULL the function returns number
+ *               of bytes needed).
+ *  \return 1 on success and 0 if an error occurred.
+ */
+OSSL_DEPRECATEDIN_3_0 int i2d_ECPrivateKey(const EC_KEY *key,
+                                           unsigned char **out);
+
+/********************************************************************/
+/*        de- and encoding functions for EC parameters              */
+/********************************************************************/
+
+/** Decodes ec parameter from a memory buffer.
+ *  \param  key  a pointer to a EC_KEY object which should be used (or NULL)
+ *  \param  in   pointer to memory with the DER encoded ec parameters
+ *  \param  len  length of the DER encoded ec parameters
+ *  \return a EC_KEY object with the decoded parameters or NULL if an error
+ *          occurred.
+ */
+OSSL_DEPRECATEDIN_3_0 EC_KEY *d2i_ECParameters(EC_KEY **key,
+                                               const unsigned char **in,
+                                               long len);
+
+/** Encodes ec parameter and stores the result in a buffer.
+ *  \param  key  the EC_KEY object with ec parameters to encode
+ *  \param  out  the buffer for the result (if NULL the function returns number
+ *               of bytes needed).
+ *  \return 1 on success and 0 if an error occurred.
+ */
+OSSL_DEPRECATEDIN_3_0 int i2d_ECParameters(const EC_KEY *key,
+                                           unsigned char **out);
+
+/********************************************************************/
+/*         de- and encoding functions for EC public key             */
+/*         (octet string, not DER -- hence 'o2i' and 'i2o')         */
+/********************************************************************/
+
+/** Decodes an ec public key from a octet string.
+ *  \param  key  a pointer to a EC_KEY object which should be used
+ *  \param  in   memory buffer with the encoded public key
+ *  \param  len  length of the encoded public key
+ *  \return EC_KEY object with decoded public key or NULL if an error
+ *          occurred.
+ */
+OSSL_DEPRECATEDIN_3_0 EC_KEY *o2i_ECPublicKey(EC_KEY **key,
+                                              const unsigned char **in, long len);
+
+/** Encodes an ec public key in an octet string.
+ *  \param  key  the EC_KEY object with the public key
+ *  \param  out  the buffer for the result (if NULL the function returns number
+ *               of bytes needed).
+ *  \return 1 on success and 0 if an error occurred
+ */
+OSSL_DEPRECATEDIN_3_0 int i2o_ECPublicKey(const EC_KEY *key, unsigned char **out);
+
+/** Prints out the ec parameters on human readable form.
+ *  \param  bp   BIO object to which the information is printed
+ *  \param  key  EC_KEY object
+ *  \return 1 on success and 0 if an error occurred
+ */
+OSSL_DEPRECATEDIN_3_0 int ECParameters_print(BIO *bp, const EC_KEY *key);
+
+/** Prints out the contents of a EC_KEY object
+ *  \param  bp   BIO object to which the information is printed
+ *  \param  key  EC_KEY object
+ *  \param  off  line offset
+ *  \return 1 on success and 0 if an error occurred
+ */
+OSSL_DEPRECATEDIN_3_0 int EC_KEY_print(BIO *bp, const EC_KEY *key, int off);
+
+#   ifndef OPENSSL_NO_STDIO
+/** Prints out the ec parameters on human readable form.
+ *  \param  fp   file descriptor to which the information is printed
+ *  \param  key  EC_KEY object
+ *  \return 1 on success and 0 if an error occurred
+ */
+OSSL_DEPRECATEDIN_3_0 int ECParameters_print_fp(FILE *fp, const EC_KEY *key);
+
+/** Prints out the contents of a EC_KEY object
+ *  \param  fp   file descriptor to which the information is printed
+ *  \param  key  EC_KEY object
+ *  \param  off  line offset
+ *  \return 1 on success and 0 if an error occurred
+ */
+OSSL_DEPRECATEDIN_3_0 int EC_KEY_print_fp(FILE *fp, const EC_KEY *key, int off);
+#   endif /* OPENSSL_NO_STDIO */
+
+OSSL_DEPRECATEDIN_3_0 const EC_KEY_METHOD *EC_KEY_OpenSSL(void);
+OSSL_DEPRECATEDIN_3_0 const EC_KEY_METHOD *EC_KEY_get_default_method(void);
+OSSL_DEPRECATEDIN_3_0 void EC_KEY_set_default_method(const EC_KEY_METHOD *meth);
+OSSL_DEPRECATEDIN_3_0 const EC_KEY_METHOD *EC_KEY_get_method(const EC_KEY *key);
+OSSL_DEPRECATEDIN_3_0 int EC_KEY_set_method(EC_KEY *key, const EC_KEY_METHOD *meth);
+OSSL_DEPRECATEDIN_3_0 EC_KEY *EC_KEY_new_method(ENGINE *engine);
+
+/** The old name for ecdh_KDF_X9_63
+ *  The ECDH KDF specification has been mistakenly attributed to ANSI X9.62,
+ *  it is actually specified in ANSI X9.63.
+ *  This identifier is retained for backwards compatibility
+ */
+OSSL_DEPRECATEDIN_3_0 int ECDH_KDF_X9_62(unsigned char *out, size_t outlen,
+                                         const unsigned char *Z, size_t Zlen,
+                                         const unsigned char *sinfo,
+                                         size_t sinfolen, const EVP_MD *md);
+
+OSSL_DEPRECATEDIN_3_0 int ECDH_compute_key(void *out, size_t outlen,
+                                           const EC_POINT *pub_key,
+                                           const EC_KEY *ecdh,
+                                           void *(*KDF)(const void *in,
+                                                        size_t inlen, void *out,
+                                                        size_t *outlen));
+#  endif /* OPENSSL_NO_DEPRECATED_3_0 */
+
+typedef struct ECDSA_SIG_st ECDSA_SIG;
+
+/** Allocates and initialize a ECDSA_SIG structure
+ *  \return pointer to a ECDSA_SIG structure or NULL if an error occurred
+ */
+ECDSA_SIG *ECDSA_SIG_new(void);
+
+/** frees a ECDSA_SIG structure
+ *  \param  sig  pointer to the ECDSA_SIG structure
+ */
+void ECDSA_SIG_free(ECDSA_SIG *sig);
+
+/** i2d_ECDSA_SIG encodes content of ECDSA_SIG (note: this function modifies *pp
+ *  (*pp += length of the DER encoded signature)).
+ *  \param  sig  pointer to the ECDSA_SIG object
+ *  \param  pp   pointer to a unsigned char pointer for the output or NULL
+ *  \return the length of the DER encoded ECDSA_SIG object or a negative value
+ *          on error
+ */
+DECLARE_ASN1_ENCODE_FUNCTIONS_only(ECDSA_SIG, ECDSA_SIG)
+
+/** d2i_ECDSA_SIG decodes an ECDSA signature (note: this function modifies *pp
+ *  (*pp += len)).
+ *  \param  sig  pointer to ECDSA_SIG pointer (may be NULL)
+ *  \param  pp   memory buffer with the DER encoded signature
+ *  \param  len  length of the buffer
+ *  \return pointer to the decoded ECDSA_SIG structure (or NULL)
+ */
+
+/** Accessor for r and s fields of ECDSA_SIG
+ *  \param  sig  pointer to ECDSA_SIG structure
+ *  \param  pr   pointer to BIGNUM pointer for r (may be NULL)
+ *  \param  ps   pointer to BIGNUM pointer for s (may be NULL)
+ */
+void ECDSA_SIG_get0(const ECDSA_SIG *sig, const BIGNUM **pr, const BIGNUM **ps);
+
+/** Accessor for r field of ECDSA_SIG
+ *  \param  sig  pointer to ECDSA_SIG structure
+ */
+const BIGNUM *ECDSA_SIG_get0_r(const ECDSA_SIG *sig);
+
+/** Accessor for s field of ECDSA_SIG
+ *  \param  sig  pointer to ECDSA_SIG structure
+ */
+const BIGNUM *ECDSA_SIG_get0_s(const ECDSA_SIG *sig);
+
+/** Setter for r and s fields of ECDSA_SIG
+ *  \param  sig  pointer to ECDSA_SIG structure
+ *  \param  r    pointer to BIGNUM for r
+ *  \param  s    pointer to BIGNUM for s
+ */
+int ECDSA_SIG_set0(ECDSA_SIG *sig, BIGNUM *r, BIGNUM *s);
+
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+/** Computes the ECDSA signature of the given hash value using
+ *  the supplied private key and returns the created signature.
+ *  \param  dgst      pointer to the hash value
+ *  \param  dgst_len  length of the hash value
+ *  \param  eckey     EC_KEY object containing a private EC key
+ *  \return pointer to a ECDSA_SIG structure or NULL if an error occurred
+ */
+OSSL_DEPRECATEDIN_3_0 ECDSA_SIG *ECDSA_do_sign(const unsigned char *dgst,
+                                               int dgst_len, EC_KEY *eckey);
+
+/** Computes ECDSA signature of a given hash value using the supplied
+ *  private key (note: sig must point to ECDSA_size(eckey) bytes of memory).
+ *  \param  dgst     pointer to the hash value to sign
+ *  \param  dgstlen  length of the hash value
+ *  \param  kinv     BIGNUM with a pre-computed inverse k (optional)
+ *  \param  rp       BIGNUM with a pre-computed rp value (optional),
+ *                   see ECDSA_sign_setup
+ *  \param  eckey    EC_KEY object containing a private EC key
+ *  \return pointer to a ECDSA_SIG structure or NULL if an error occurred
+ */
+OSSL_DEPRECATEDIN_3_0 ECDSA_SIG *ECDSA_do_sign_ex(const unsigned char *dgst,
+                                                  int dgstlen, const BIGNUM *kinv,
+                                                  const BIGNUM *rp, EC_KEY *eckey);
+
+/** Verifies that the supplied signature is a valid ECDSA
+ *  signature of the supplied hash value using the supplied public key.
+ *  \param  dgst      pointer to the hash value
+ *  \param  dgst_len  length of the hash value
+ *  \param  sig       ECDSA_SIG structure
+ *  \param  eckey     EC_KEY object containing a public EC key
+ *  \return 1 if the signature is valid, 0 if the signature is invalid
+ *          and -1 on error
+ */
+OSSL_DEPRECATEDIN_3_0 int ECDSA_do_verify(const unsigned char *dgst, int dgst_len,
+                                          const ECDSA_SIG *sig, EC_KEY *eckey);
+
+/** Precompute parts of the signing operation
+ *  \param  eckey  EC_KEY object containing a private EC key
+ *  \param  ctx    BN_CTX object (optional)
+ *  \param  kinv   BIGNUM pointer for the inverse of k
+ *  \param  rp     BIGNUM pointer for x coordinate of k * generator
+ *  \return 1 on success and 0 otherwise
+ */
+OSSL_DEPRECATEDIN_3_0 int ECDSA_sign_setup(EC_KEY *eckey, BN_CTX *ctx,
+                                           BIGNUM **kinv, BIGNUM **rp);
+
+/** Computes ECDSA signature of a given hash value using the supplied
+ *  private key (note: sig must point to ECDSA_size(eckey) bytes of memory).
+ *  \param  type     this parameter is ignored
+ *  \param  dgst     pointer to the hash value to sign
+ *  \param  dgstlen  length of the hash value
+ *  \param  sig      memory for the DER encoded created signature
+ *  \param  siglen   pointer to the length of the returned signature
+ *  \param  eckey    EC_KEY object containing a private EC key
+ *  \return 1 on success and 0 otherwise
+ */
+OSSL_DEPRECATEDIN_3_0 int ECDSA_sign(int type, const unsigned char *dgst,
+                                     int dgstlen, unsigned char *sig,
+                                     unsigned int *siglen, EC_KEY *eckey);
+
+/** Computes ECDSA signature of a given hash value using the supplied
+ *  private key (note: sig must point to ECDSA_size(eckey) bytes of memory).
+ *  \param  type     this parameter is ignored
+ *  \param  dgst     pointer to the hash value to sign
+ *  \param  dgstlen  length of the hash value
+ *  \param  sig      buffer to hold the DER encoded signature
+ *  \param  siglen   pointer to the length of the returned signature
+ *  \param  kinv     BIGNUM with a pre-computed inverse k (optional)
+ *  \param  rp       BIGNUM with a pre-computed rp value (optional),
+ *                   see ECDSA_sign_setup
+ *  \param  eckey    EC_KEY object containing a private EC key
+ *  \return 1 on success and 0 otherwise
+ */
+OSSL_DEPRECATEDIN_3_0 int ECDSA_sign_ex(int type, const unsigned char *dgst,
+                                        int dgstlen, unsigned char *sig,
+                                        unsigned int *siglen, const BIGNUM *kinv,
+                                        const BIGNUM *rp, EC_KEY *eckey);
+
+/** Verifies that the given signature is valid ECDSA signature
+ *  of the supplied hash value using the specified public key.
+ *  \param  type     this parameter is ignored
+ *  \param  dgst     pointer to the hash value
+ *  \param  dgstlen  length of the hash value
+ *  \param  sig      pointer to the DER encoded signature
+ *  \param  siglen   length of the DER encoded signature
+ *  \param  eckey    EC_KEY object containing a public EC key
+ *  \return 1 if the signature is valid, 0 if the signature is invalid
+ *          and -1 on error
+ */
+OSSL_DEPRECATEDIN_3_0 int ECDSA_verify(int type, const unsigned char *dgst,
+                                       int dgstlen, const unsigned char *sig,
+                                       int siglen, EC_KEY *eckey);
+
+/** Returns the maximum length of the DER encoded signature
+ *  \param  eckey  EC_KEY object
+ *  \return numbers of bytes required for the DER encoded signature
+ */
+OSSL_DEPRECATEDIN_3_0 int ECDSA_size(const EC_KEY *eckey);
+
+/********************************************************************/
+/*  EC_KEY_METHOD constructors, destructors, writers and accessors  */
+/********************************************************************/
+
+OSSL_DEPRECATEDIN_3_0 EC_KEY_METHOD *EC_KEY_METHOD_new(const EC_KEY_METHOD *meth);
+OSSL_DEPRECATEDIN_3_0 void EC_KEY_METHOD_free(EC_KEY_METHOD *meth);
+OSSL_DEPRECATEDIN_3_0 void EC_KEY_METHOD_set_init
+                      (EC_KEY_METHOD *meth,
+                       int (*init)(EC_KEY *key),
+                       void (*finish)(EC_KEY *key),
+                       int (*copy)(EC_KEY *dest, const EC_KEY *src),
+                       int (*set_group)(EC_KEY *key, const EC_GROUP *grp),
+                       int (*set_private)(EC_KEY *key, const BIGNUM *priv_key),
+                       int (*set_public)(EC_KEY *key, const EC_POINT *pub_key));
+
+OSSL_DEPRECATEDIN_3_0 void EC_KEY_METHOD_set_keygen(EC_KEY_METHOD *meth,
+                                                    int (*keygen)(EC_KEY *key));
+
+OSSL_DEPRECATEDIN_3_0 void EC_KEY_METHOD_set_compute_key
+                      (EC_KEY_METHOD *meth,
+                       int (*ckey)(unsigned char **psec, size_t *pseclen,
+                                   const EC_POINT *pub_key, const EC_KEY *ecdh));
+
+OSSL_DEPRECATEDIN_3_0 void EC_KEY_METHOD_set_sign
+                      (EC_KEY_METHOD *meth,
+                       int (*sign)(int type, const unsigned char *dgst,
+                                   int dlen, unsigned char *sig,
+                                   unsigned int *siglen,
+                                   const BIGNUM *kinv, const BIGNUM *r,
+                                   EC_KEY *eckey),
+                       int (*sign_setup)(EC_KEY *eckey, BN_CTX *ctx_in,
+                                         BIGNUM **kinvp, BIGNUM **rp),
+                       ECDSA_SIG *(*sign_sig)(const unsigned char *dgst,
+                                              int dgst_len,
+                                              const BIGNUM *in_kinv,
+                                              const BIGNUM *in_r,
+                                              EC_KEY *eckey));
+
+OSSL_DEPRECATEDIN_3_0 void EC_KEY_METHOD_set_verify
+                      (EC_KEY_METHOD *meth,
+                       int (*verify)(int type, const unsigned
+                                     char *dgst, int dgst_len,
+                                     const unsigned char *sigbuf,
+                                     int sig_len, EC_KEY *eckey),
+                       int (*verify_sig)(const unsigned char *dgst,
+                                         int dgst_len, const ECDSA_SIG *sig,
+                                         EC_KEY *eckey));
+
+OSSL_DEPRECATEDIN_3_0 void EC_KEY_METHOD_get_init
+                      (const EC_KEY_METHOD *meth,
+                       int (**pinit)(EC_KEY *key),
+                       void (**pfinish)(EC_KEY *key),
+                       int (**pcopy)(EC_KEY *dest, const EC_KEY *src),
+                       int (**pset_group)(EC_KEY *key, const EC_GROUP *grp),
+                       int (**pset_private)(EC_KEY *key, const BIGNUM *priv_key),
+                       int (**pset_public)(EC_KEY *key, const EC_POINT *pub_key));
+
+OSSL_DEPRECATEDIN_3_0 void EC_KEY_METHOD_get_keygen
+                      (const EC_KEY_METHOD *meth, int (**pkeygen)(EC_KEY *key));
+
+OSSL_DEPRECATEDIN_3_0 void EC_KEY_METHOD_get_compute_key
+                      (const EC_KEY_METHOD *meth,
+                       int (**pck)(unsigned char **psec,
+                       size_t *pseclen,
+                       const EC_POINT *pub_key,
+                       const EC_KEY *ecdh));
+
+OSSL_DEPRECATEDIN_3_0 void EC_KEY_METHOD_get_sign
+                      (const EC_KEY_METHOD *meth,
+                       int (**psign)(int type, const unsigned char *dgst,
+                                     int dlen, unsigned char *sig,
+                                     unsigned int *siglen,
+                                     const BIGNUM *kinv, const BIGNUM *r,
+                                     EC_KEY *eckey),
+                       int (**psign_setup)(EC_KEY *eckey, BN_CTX *ctx_in,
+                                           BIGNUM **kinvp, BIGNUM **rp),
+                       ECDSA_SIG *(**psign_sig)(const unsigned char *dgst,
+                                                int dgst_len,
+                                                const BIGNUM *in_kinv,
+                                                const BIGNUM *in_r,
+                                                EC_KEY *eckey));
+
+OSSL_DEPRECATEDIN_3_0 void EC_KEY_METHOD_get_verify
+                      (const EC_KEY_METHOD *meth,
+                       int (**pverify)(int type, const unsigned
+                                       char *dgst, int dgst_len,
+                                       const unsigned char *sigbuf,
+                                       int sig_len, EC_KEY *eckey),
+                       int (**pverify_sig)(const unsigned char *dgst,
+                                           int dgst_len,
+                                           const ECDSA_SIG *sig,
+                                           EC_KEY *eckey));
+#  endif /* OPENSSL_NO_DEPRECATED_3_0 */
+
+#  define EVP_EC_gen(curve) \
+    EVP_PKEY_Q_keygen(NULL, NULL, "EC", (char *)(strstr(curve, "")))
+    /* strstr is used to enable type checking for the variadic string arg */
+#  define ECParameters_dup(x) ASN1_dup_of(EC_KEY, i2d_ECParameters, \
+                                          d2i_ECParameters, x)
+
+#  ifndef __cplusplus
+#   if defined(__SUNPRO_C)
+#    if __SUNPRO_C >= 0x520
+#     pragma error_messages (default,E_ARRAY_OF_INCOMPLETE_NONAME,E_ARRAY_OF_INCOMPLETE)
+#    endif
+#   endif
+#  endif
+
+# endif
+# ifdef  __cplusplus
+}
+# endif
+#endif
diff --git a/src/include/openssl/ecdh.h b/src/include/openssl/ecdh.h
new file mode 100644
index 0000000..56bd4cc
--- /dev/null
+++ b/src/include/openssl/ecdh.h
@@ -0,0 +1,10 @@
+/*
+ * Copyright 2002-2016 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#include <openssl/ec.h>
diff --git a/src/include/openssl/ecdsa.h b/src/include/openssl/ecdsa.h
new file mode 100644
index 0000000..56bd4cc
--- /dev/null
+++ b/src/include/openssl/ecdsa.h
@@ -0,0 +1,10 @@
+/*
+ * Copyright 2002-2016 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#include <openssl/ec.h>
diff --git a/src/include/openssl/ecerr.h b/src/include/openssl/ecerr.h
new file mode 100644
index 0000000..f15f91f
--- /dev/null
+++ b/src/include/openssl/ecerr.h
@@ -0,0 +1,104 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_ECERR_H
+# define OPENSSL_ECERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+# ifndef OPENSSL_NO_EC
+
+
+/*
+ * EC reason codes.
+ */
+#  define EC_R_ASN1_ERROR                                  115
+#  define EC_R_BAD_SIGNATURE                               156
+#  define EC_R_BIGNUM_OUT_OF_RANGE                         144
+#  define EC_R_BUFFER_TOO_SMALL                            100
+#  define EC_R_CANNOT_INVERT                               165
+#  define EC_R_COORDINATES_OUT_OF_RANGE                    146
+#  define EC_R_CURVE_DOES_NOT_SUPPORT_ECDH                 160
+#  define EC_R_CURVE_DOES_NOT_SUPPORT_ECDSA                170
+#  define EC_R_CURVE_DOES_NOT_SUPPORT_SIGNING              159
+#  define EC_R_DECODE_ERROR                                142
+#  define EC_R_DISCRIMINANT_IS_ZERO                        118
+#  define EC_R_EC_GROUP_NEW_BY_NAME_FAILURE                119
+#  define EC_R_EXPLICIT_PARAMS_NOT_SUPPORTED               127
+#  define EC_R_FAILED_MAKING_PUBLIC_KEY                    166
+#  define EC_R_FIELD_TOO_LARGE                             143
+#  define EC_R_GF2M_NOT_SUPPORTED                          147
+#  define EC_R_GROUP2PKPARAMETERS_FAILURE                  120
+#  define EC_R_I2D_ECPKPARAMETERS_FAILURE                  121
+#  define EC_R_INCOMPATIBLE_OBJECTS                        101
+#  define EC_R_INVALID_A                                   168
+#  define EC_R_INVALID_ARGUMENT                            112
+#  define EC_R_INVALID_B                                   169
+#  define EC_R_INVALID_COFACTOR                            171
+#  define EC_R_INVALID_COMPRESSED_POINT                    110
+#  define EC_R_INVALID_COMPRESSION_BIT                     109
+#  define EC_R_INVALID_CURVE                               141
+#  define EC_R_INVALID_DIGEST                              151
+#  define EC_R_INVALID_DIGEST_TYPE                         138
+#  define EC_R_INVALID_ENCODING                            102
+#  define EC_R_INVALID_FIELD                               103
+#  define EC_R_INVALID_FORM                                104
+#  define EC_R_INVALID_GENERATOR                           173
+#  define EC_R_INVALID_GROUP_ORDER                         122
+#  define EC_R_INVALID_KEY                                 116
+#  define EC_R_INVALID_LENGTH                              117
+#  define EC_R_INVALID_NAMED_GROUP_CONVERSION              174
+#  define EC_R_INVALID_OUTPUT_LENGTH                       161
+#  define EC_R_INVALID_P                                   172
+#  define EC_R_INVALID_PEER_KEY                            133
+#  define EC_R_INVALID_PENTANOMIAL_BASIS                   132
+#  define EC_R_INVALID_PRIVATE_KEY                         123
+#  define EC_R_INVALID_SEED                                175
+#  define EC_R_INVALID_TRINOMIAL_BASIS                     137
+#  define EC_R_KDF_PARAMETER_ERROR                         148
+#  define EC_R_KEYS_NOT_SET                                140
+#  define EC_R_LADDER_POST_FAILURE                         136
+#  define EC_R_LADDER_PRE_FAILURE                          153
+#  define EC_R_LADDER_STEP_FAILURE                         162
+#  define EC_R_MISSING_OID                                 167
+#  define EC_R_MISSING_PARAMETERS                          124
+#  define EC_R_MISSING_PRIVATE_KEY                         125
+#  define EC_R_NEED_NEW_SETUP_VALUES                       157
+#  define EC_R_NOT_A_NIST_PRIME                            135
+#  define EC_R_NOT_IMPLEMENTED                             126
+#  define EC_R_NOT_INITIALIZED                             111
+#  define EC_R_NO_PARAMETERS_SET                           139
+#  define EC_R_NO_PRIVATE_VALUE                            154
+#  define EC_R_OPERATION_NOT_SUPPORTED                     152
+#  define EC_R_PASSED_NULL_PARAMETER                       134
+#  define EC_R_PEER_KEY_ERROR                              149
+#  define EC_R_POINT_ARITHMETIC_FAILURE                    155
+#  define EC_R_POINT_AT_INFINITY                           106
+#  define EC_R_POINT_COORDINATES_BLIND_FAILURE             163
+#  define EC_R_POINT_IS_NOT_ON_CURVE                       107
+#  define EC_R_RANDOM_NUMBER_GENERATION_FAILED             158
+#  define EC_R_SHARED_INFO_ERROR                           150
+#  define EC_R_SLOT_FULL                                   108
+#  define EC_R_TOO_MANY_RETRIES                            176
+#  define EC_R_UNDEFINED_GENERATOR                         113
+#  define EC_R_UNDEFINED_ORDER                             128
+#  define EC_R_UNKNOWN_COFACTOR                            164
+#  define EC_R_UNKNOWN_GROUP                               129
+#  define EC_R_UNKNOWN_ORDER                               114
+#  define EC_R_UNSUPPORTED_FIELD                           131
+#  define EC_R_WRONG_CURVE_PARAMETERS                      145
+#  define EC_R_WRONG_ORDER                                 130
+
+# endif
+#endif
diff --git a/src/include/openssl/encoder.h b/src/include/openssl/encoder.h
new file mode 100644
index 0000000..c37a6f1
--- /dev/null
+++ b/src/include/openssl/encoder.h
@@ -0,0 +1,124 @@
+/*
+ * Copyright 2019-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_ENCODER_H
+# define OPENSSL_ENCODER_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+
+# ifndef OPENSSL_NO_STDIO
+#  include <stdio.h>
+# endif
+# include <stdarg.h>
+# include <stddef.h>
+# include <openssl/encodererr.h>
+# include <openssl/types.h>
+# include <openssl/core.h>
+
+# ifdef __cplusplus
+extern "C" {
+# endif
+
+OSSL_ENCODER *OSSL_ENCODER_fetch(OSSL_LIB_CTX *libctx, const char *name,
+                                 const char *properties);
+int OSSL_ENCODER_up_ref(OSSL_ENCODER *encoder);
+void OSSL_ENCODER_free(OSSL_ENCODER *encoder);
+
+const OSSL_PROVIDER *OSSL_ENCODER_get0_provider(const OSSL_ENCODER *encoder);
+const char *OSSL_ENCODER_get0_properties(const OSSL_ENCODER *encoder);
+const char *OSSL_ENCODER_get0_name(const OSSL_ENCODER *kdf);
+const char *OSSL_ENCODER_get0_description(const OSSL_ENCODER *kdf);
+int OSSL_ENCODER_is_a(const OSSL_ENCODER *encoder, const char *name);
+
+void OSSL_ENCODER_do_all_provided(OSSL_LIB_CTX *libctx,
+                                  void (*fn)(OSSL_ENCODER *encoder, void *arg),
+                                  void *arg);
+int OSSL_ENCODER_names_do_all(const OSSL_ENCODER *encoder,
+                              void (*fn)(const char *name, void *data),
+                              void *data);
+const OSSL_PARAM *OSSL_ENCODER_gettable_params(OSSL_ENCODER *encoder);
+int OSSL_ENCODER_get_params(OSSL_ENCODER *encoder, OSSL_PARAM params[]);
+
+const OSSL_PARAM *OSSL_ENCODER_settable_ctx_params(OSSL_ENCODER *encoder);
+OSSL_ENCODER_CTX *OSSL_ENCODER_CTX_new(void);
+int OSSL_ENCODER_CTX_set_params(OSSL_ENCODER_CTX *ctx,
+                                const OSSL_PARAM params[]);
+void OSSL_ENCODER_CTX_free(OSSL_ENCODER_CTX *ctx);
+
+/* Utilities that help set specific parameters */
+int OSSL_ENCODER_CTX_set_passphrase(OSSL_ENCODER_CTX *ctx,
+                                    const unsigned char *kstr, size_t klen);
+int OSSL_ENCODER_CTX_set_pem_password_cb(OSSL_ENCODER_CTX *ctx,
+                                         pem_password_cb *cb, void *cbarg);
+int OSSL_ENCODER_CTX_set_passphrase_cb(OSSL_ENCODER_CTX *ctx,
+                                       OSSL_PASSPHRASE_CALLBACK *cb,
+                                       void *cbarg);
+int OSSL_ENCODER_CTX_set_passphrase_ui(OSSL_ENCODER_CTX *ctx,
+                                       const UI_METHOD *ui_method,
+                                       void *ui_data);
+int OSSL_ENCODER_CTX_set_cipher(OSSL_ENCODER_CTX *ctx,
+                                const char *cipher_name,
+                                const char *propquery);
+int OSSL_ENCODER_CTX_set_selection(OSSL_ENCODER_CTX *ctx, int selection);
+int OSSL_ENCODER_CTX_set_output_type(OSSL_ENCODER_CTX *ctx,
+                                     const char *output_type);
+int OSSL_ENCODER_CTX_set_output_structure(OSSL_ENCODER_CTX *ctx,
+                                          const char *output_structure);
+
+/* Utilities to add encoders */
+int OSSL_ENCODER_CTX_add_encoder(OSSL_ENCODER_CTX *ctx, OSSL_ENCODER *encoder);
+int OSSL_ENCODER_CTX_add_extra(OSSL_ENCODER_CTX *ctx,
+                               OSSL_LIB_CTX *libctx, const char *propq);
+int OSSL_ENCODER_CTX_get_num_encoders(OSSL_ENCODER_CTX *ctx);
+
+typedef struct ossl_encoder_instance_st OSSL_ENCODER_INSTANCE;
+OSSL_ENCODER *
+OSSL_ENCODER_INSTANCE_get_encoder(OSSL_ENCODER_INSTANCE *encoder_inst);
+void *
+OSSL_ENCODER_INSTANCE_get_encoder_ctx(OSSL_ENCODER_INSTANCE *encoder_inst);
+const char *
+OSSL_ENCODER_INSTANCE_get_output_type(OSSL_ENCODER_INSTANCE *encoder_inst);
+const char *
+OSSL_ENCODER_INSTANCE_get_output_structure(OSSL_ENCODER_INSTANCE *encoder_inst);
+
+typedef const void *OSSL_ENCODER_CONSTRUCT(OSSL_ENCODER_INSTANCE *encoder_inst,
+                                           void *construct_data);
+typedef void OSSL_ENCODER_CLEANUP(void *construct_data);
+
+int OSSL_ENCODER_CTX_set_construct(OSSL_ENCODER_CTX *ctx,
+                                   OSSL_ENCODER_CONSTRUCT *construct);
+int OSSL_ENCODER_CTX_set_construct_data(OSSL_ENCODER_CTX *ctx,
+                                        void *construct_data);
+int OSSL_ENCODER_CTX_set_cleanup(OSSL_ENCODER_CTX *ctx,
+                                 OSSL_ENCODER_CLEANUP *cleanup);
+
+/* Utilities to output the object to encode */
+int OSSL_ENCODER_to_bio(OSSL_ENCODER_CTX *ctx, BIO *out);
+#ifndef OPENSSL_NO_STDIO
+int OSSL_ENCODER_to_fp(OSSL_ENCODER_CTX *ctx, FILE *fp);
+#endif
+int OSSL_ENCODER_to_data(OSSL_ENCODER_CTX *ctx, unsigned char **pdata,
+                         size_t *pdata_len);
+
+/*
+ * Create the OSSL_ENCODER_CTX with an associated type.  This will perform
+ * an implicit OSSL_ENCODER_fetch(), suitable for the object of that type.
+ * This is more useful than calling OSSL_ENCODER_CTX_new().
+ */
+OSSL_ENCODER_CTX *OSSL_ENCODER_CTX_new_for_pkey(const EVP_PKEY *pkey,
+                                                int selection,
+                                                const char *output_type,
+                                                const char *output_struct,
+                                                const char *propquery);
+
+# ifdef __cplusplus
+}
+# endif
+#endif
diff --git a/src/include/openssl/encodererr.h b/src/include/openssl/encodererr.h
new file mode 100644
index 0000000..5e318b1
--- /dev/null
+++ b/src/include/openssl/encodererr.h
@@ -0,0 +1,28 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_ENCODERERR_H
+# define OPENSSL_ENCODERERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+
+/*
+ * OSSL_ENCODER reason codes.
+ */
+# define OSSL_ENCODER_R_ENCODER_NOT_FOUND                 101
+# define OSSL_ENCODER_R_INCORRECT_PROPERTY_QUERY          100
+# define OSSL_ENCODER_R_MISSING_GET_PARAMS                102
+
+#endif
diff --git a/src/include/openssl/engine.h b/src/include/openssl/engine.h
new file mode 100644
index 0000000..2fbc82c
--- /dev/null
+++ b/src/include/openssl/engine.h
@@ -0,0 +1,833 @@
+/*
+ * Copyright 2000-2022 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_ENGINE_H
+# define OPENSSL_ENGINE_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_ENGINE_H
+# endif
+
+# include <openssl/opensslconf.h>
+
+# ifndef OPENSSL_NO_ENGINE
+#  ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#   include <openssl/bn.h>
+#   include <openssl/rsa.h>
+#   include <openssl/dsa.h>
+#   include <openssl/dh.h>
+#   include <openssl/ec.h>
+#   include <openssl/rand.h>
+#   include <openssl/ui.h>
+#   include <openssl/err.h>
+#  endif
+#  include <openssl/types.h>
+#  include <openssl/symhacks.h>
+#  include <openssl/x509.h>
+#  include <openssl/engineerr.h>
+#  ifdef  __cplusplus
+extern "C" {
+#  endif
+
+/*
+ * These flags are used to control combinations of algorithm (methods) by
+ * bitwise "OR"ing.
+ */
+#  define ENGINE_METHOD_RSA               (unsigned int)0x0001
+#  define ENGINE_METHOD_DSA               (unsigned int)0x0002
+#  define ENGINE_METHOD_DH                (unsigned int)0x0004
+#  define ENGINE_METHOD_RAND              (unsigned int)0x0008
+#  define ENGINE_METHOD_CIPHERS           (unsigned int)0x0040
+#  define ENGINE_METHOD_DIGESTS           (unsigned int)0x0080
+#  define ENGINE_METHOD_PKEY_METHS        (unsigned int)0x0200
+#  define ENGINE_METHOD_PKEY_ASN1_METHS   (unsigned int)0x0400
+#  define ENGINE_METHOD_EC                (unsigned int)0x0800
+/* Obvious all-or-nothing cases. */
+#  define ENGINE_METHOD_ALL               (unsigned int)0xFFFF
+#  define ENGINE_METHOD_NONE              (unsigned int)0x0000
+
+/*
+ * This(ese) flag(s) controls behaviour of the ENGINE_TABLE mechanism used
+ * internally to control registration of ENGINE implementations, and can be
+ * set by ENGINE_set_table_flags(). The "NOINIT" flag prevents attempts to
+ * initialise registered ENGINEs if they are not already initialised.
+ */
+#  define ENGINE_TABLE_FLAG_NOINIT        (unsigned int)0x0001
+
+/* ENGINE flags that can be set by ENGINE_set_flags(). */
+/* Not used */
+/* #define ENGINE_FLAGS_MALLOCED        0x0001 */
+
+/*
+ * This flag is for ENGINEs that wish to handle the various 'CMD'-related
+ * control commands on their own. Without this flag, ENGINE_ctrl() handles
+ * these control commands on behalf of the ENGINE using their "cmd_defns"
+ * data.
+ */
+#  define ENGINE_FLAGS_MANUAL_CMD_CTRL    (int)0x0002
+
+/*
+ * This flag is for ENGINEs who return new duplicate structures when found
+ * via "ENGINE_by_id()". When an ENGINE must store state (eg. if
+ * ENGINE_ctrl() commands are called in sequence as part of some stateful
+ * process like key-generation setup and execution), it can set this flag -
+ * then each attempt to obtain the ENGINE will result in it being copied into
+ * a new structure. Normally, ENGINEs don't declare this flag so
+ * ENGINE_by_id() just increments the existing ENGINE's structural reference
+ * count.
+ */
+#  define ENGINE_FLAGS_BY_ID_COPY         (int)0x0004
+
+/*
+ * This flag if for an ENGINE that does not want its methods registered as
+ * part of ENGINE_register_all_complete() for example if the methods are not
+ * usable as default methods.
+ */
+
+#  define ENGINE_FLAGS_NO_REGISTER_ALL    (int)0x0008
+
+/*
+ * ENGINEs can support their own command types, and these flags are used in
+ * ENGINE_CTRL_GET_CMD_FLAGS to indicate to the caller what kind of input
+ * each command expects. Currently only numeric and string input is
+ * supported. If a control command supports none of the _NUMERIC, _STRING, or
+ * _NO_INPUT options, then it is regarded as an "internal" control command -
+ * and not for use in config setting situations. As such, they're not
+ * available to the ENGINE_ctrl_cmd_string() function, only raw ENGINE_ctrl()
+ * access. Changes to this list of 'command types' should be reflected
+ * carefully in ENGINE_cmd_is_executable() and ENGINE_ctrl_cmd_string().
+ */
+
+/* accepts a 'long' input value (3rd parameter to ENGINE_ctrl) */
+#  define ENGINE_CMD_FLAG_NUMERIC         (unsigned int)0x0001
+/*
+ * accepts string input (cast from 'void*' to 'const char *', 4th parameter
+ * to ENGINE_ctrl)
+ */
+#  define ENGINE_CMD_FLAG_STRING          (unsigned int)0x0002
+/*
+ * Indicates that the control command takes *no* input. Ie. the control
+ * command is unparameterised.
+ */
+#  define ENGINE_CMD_FLAG_NO_INPUT        (unsigned int)0x0004
+/*
+ * Indicates that the control command is internal. This control command won't
+ * be shown in any output, and is only usable through the ENGINE_ctrl_cmd()
+ * function.
+ */
+#  define ENGINE_CMD_FLAG_INTERNAL        (unsigned int)0x0008
+
+/*
+ * NB: These 3 control commands are deprecated and should not be used.
+ * ENGINEs relying on these commands should compile conditional support for
+ * compatibility (eg. if these symbols are defined) but should also migrate
+ * the same functionality to their own ENGINE-specific control functions that
+ * can be "discovered" by calling applications. The fact these control
+ * commands wouldn't be "executable" (ie. usable by text-based config)
+ * doesn't change the fact that application code can find and use them
+ * without requiring per-ENGINE hacking.
+ */
+
+/*
+ * These flags are used to tell the ctrl function what should be done. All
+ * command numbers are shared between all engines, even if some don't make
+ * sense to some engines.  In such a case, they do nothing but return the
+ * error ENGINE_R_CTRL_COMMAND_NOT_IMPLEMENTED.
+ */
+#  define ENGINE_CTRL_SET_LOGSTREAM               1
+#  define ENGINE_CTRL_SET_PASSWORD_CALLBACK       2
+#  define ENGINE_CTRL_HUP                         3/* Close and reinitialise
+                                                   * any handles/connections
+                                                   * etc. */
+#  define ENGINE_CTRL_SET_USER_INTERFACE          4/* Alternative to callback */
+#  define ENGINE_CTRL_SET_CALLBACK_DATA           5/* User-specific data, used
+                                                   * when calling the password
+                                                   * callback and the user
+                                                   * interface */
+#  define ENGINE_CTRL_LOAD_CONFIGURATION          6/* Load a configuration,
+                                                   * given a string that
+                                                   * represents a file name
+                                                   * or so */
+#  define ENGINE_CTRL_LOAD_SECTION                7/* Load data from a given
+                                                   * section in the already
+                                                   * loaded configuration */
+
+/*
+ * These control commands allow an application to deal with an arbitrary
+ * engine in a dynamic way. Warn: Negative return values indicate errors FOR
+ * THESE COMMANDS because zero is used to indicate 'end-of-list'. Other
+ * commands, including ENGINE-specific command types, return zero for an
+ * error. An ENGINE can choose to implement these ctrl functions, and can
+ * internally manage things however it chooses - it does so by setting the
+ * ENGINE_FLAGS_MANUAL_CMD_CTRL flag (using ENGINE_set_flags()). Otherwise
+ * the ENGINE_ctrl() code handles this on the ENGINE's behalf using the
+ * cmd_defns data (set using ENGINE_set_cmd_defns()). This means an ENGINE's
+ * ctrl() handler need only implement its own commands - the above "meta"
+ * commands will be taken care of.
+ */
+
+/*
+ * Returns non-zero if the supplied ENGINE has a ctrl() handler. If "not",
+ * then all the remaining control commands will return failure, so it is
+ * worth checking this first if the caller is trying to "discover" the
+ * engine's capabilities and doesn't want errors generated unnecessarily.
+ */
+#  define ENGINE_CTRL_HAS_CTRL_FUNCTION           10
+/*
+ * Returns a positive command number for the first command supported by the
+ * engine. Returns zero if no ctrl commands are supported.
+ */
+#  define ENGINE_CTRL_GET_FIRST_CMD_TYPE          11
+/*
+ * The 'long' argument specifies a command implemented by the engine, and the
+ * return value is the next command supported, or zero if there are no more.
+ */
+#  define ENGINE_CTRL_GET_NEXT_CMD_TYPE           12
+/*
+ * The 'void*' argument is a command name (cast from 'const char *'), and the
+ * return value is the command that corresponds to it.
+ */
+#  define ENGINE_CTRL_GET_CMD_FROM_NAME           13
+/*
+ * The next two allow a command to be converted into its corresponding string
+ * form. In each case, the 'long' argument supplies the command. In the
+ * NAME_LEN case, the return value is the length of the command name (not
+ * counting a trailing EOL). In the NAME case, the 'void*' argument must be a
+ * string buffer large enough, and it will be populated with the name of the
+ * command (WITH a trailing EOL).
+ */
+#  define ENGINE_CTRL_GET_NAME_LEN_FROM_CMD       14
+#  define ENGINE_CTRL_GET_NAME_FROM_CMD           15
+/* The next two are similar but give a "short description" of a command. */
+#  define ENGINE_CTRL_GET_DESC_LEN_FROM_CMD       16
+#  define ENGINE_CTRL_GET_DESC_FROM_CMD           17
+/*
+ * With this command, the return value is the OR'd combination of
+ * ENGINE_CMD_FLAG_*** values that indicate what kind of input a given
+ * engine-specific ctrl command expects.
+ */
+#  define ENGINE_CTRL_GET_CMD_FLAGS               18
+
+/*
+ * ENGINE implementations should start the numbering of their own control
+ * commands from this value. (ie. ENGINE_CMD_BASE, ENGINE_CMD_BASE + 1, etc).
+ */
+#  define ENGINE_CMD_BASE                         200
+
+/*
+ * NB: These 2 nCipher "chil" control commands are deprecated, and their
+ * functionality is now available through ENGINE-specific control commands
+ * (exposed through the above-mentioned 'CMD'-handling). Code using these 2
+ * commands should be migrated to the more general command handling before
+ * these are removed.
+ */
+
+/* Flags specific to the nCipher "chil" engine */
+#  define ENGINE_CTRL_CHIL_SET_FORKCHECK          100
+         /*
+          * Depending on the value of the (long)i argument, this sets or
+          * unsets the SimpleForkCheck flag in the CHIL API to enable or
+          * disable checking and workarounds for applications that fork().
+          */
+#  define ENGINE_CTRL_CHIL_NO_LOCKING             101
+         /*
+          * This prevents the initialisation function from providing mutex
+          * callbacks to the nCipher library.
+          */
+
+/*
+ * If an ENGINE supports its own specific control commands and wishes the
+ * framework to handle the above 'ENGINE_CMD_***'-manipulation commands on
+ * its behalf, it should supply a null-terminated array of ENGINE_CMD_DEFN
+ * entries to ENGINE_set_cmd_defns(). It should also implement a ctrl()
+ * handler that supports the stated commands (ie. the "cmd_num" entries as
+ * described by the array). NB: The array must be ordered in increasing order
+ * of cmd_num. "null-terminated" means that the last ENGINE_CMD_DEFN element
+ * has cmd_num set to zero and/or cmd_name set to NULL.
+ */
+typedef struct ENGINE_CMD_DEFN_st {
+    unsigned int cmd_num;       /* The command number */
+    const char *cmd_name;       /* The command name itself */
+    const char *cmd_desc;       /* A short description of the command */
+    unsigned int cmd_flags;     /* The input the command expects */
+} ENGINE_CMD_DEFN;
+
+/* Generic function pointer */
+typedef int (*ENGINE_GEN_FUNC_PTR) (void);
+/* Generic function pointer taking no arguments */
+typedef int (*ENGINE_GEN_INT_FUNC_PTR) (ENGINE *);
+/* Specific control function pointer */
+typedef int (*ENGINE_CTRL_FUNC_PTR) (ENGINE *, int, long, void *,
+                                     void (*f) (void));
+/* Generic load_key function pointer */
+typedef EVP_PKEY *(*ENGINE_LOAD_KEY_PTR)(ENGINE *, const char *,
+                                         UI_METHOD *ui_method,
+                                         void *callback_data);
+typedef int (*ENGINE_SSL_CLIENT_CERT_PTR) (ENGINE *, SSL *ssl,
+                                           STACK_OF(X509_NAME) *ca_dn,
+                                           X509 **pcert, EVP_PKEY **pkey,
+                                           STACK_OF(X509) **pother,
+                                           UI_METHOD *ui_method,
+                                           void *callback_data);
+/*-
+ * These callback types are for an ENGINE's handler for cipher and digest logic.
+ * These handlers have these prototypes;
+ *   int foo(ENGINE *e, const EVP_CIPHER **cipher, const int **nids, int nid);
+ *   int foo(ENGINE *e, const EVP_MD **digest, const int **nids, int nid);
+ * Looking at how to implement these handlers in the case of cipher support, if
+ * the framework wants the EVP_CIPHER for 'nid', it will call;
+ *   foo(e, &p_evp_cipher, NULL, nid);    (return zero for failure)
+ * If the framework wants a list of supported 'nid's, it will call;
+ *   foo(e, NULL, &p_nids, 0); (returns number of 'nids' or -1 for error)
+ */
+/*
+ * Returns to a pointer to the array of supported cipher 'nid's. If the
+ * second parameter is non-NULL it is set to the size of the returned array.
+ */
+typedef int (*ENGINE_CIPHERS_PTR) (ENGINE *, const EVP_CIPHER **,
+                                   const int **, int);
+typedef int (*ENGINE_DIGESTS_PTR) (ENGINE *, const EVP_MD **, const int **,
+                                   int);
+typedef int (*ENGINE_PKEY_METHS_PTR) (ENGINE *, EVP_PKEY_METHOD **,
+                                      const int **, int);
+typedef int (*ENGINE_PKEY_ASN1_METHS_PTR) (ENGINE *, EVP_PKEY_ASN1_METHOD **,
+                                           const int **, int);
+/*
+ * STRUCTURE functions ... all of these functions deal with pointers to
+ * ENGINE structures where the pointers have a "structural reference". This
+ * means that their reference is to allowed access to the structure but it
+ * does not imply that the structure is functional. To simply increment or
+ * decrement the structural reference count, use ENGINE_by_id and
+ * ENGINE_free. NB: This is not required when iterating using ENGINE_get_next
+ * as it will automatically decrement the structural reference count of the
+ * "current" ENGINE and increment the structural reference count of the
+ * ENGINE it returns (unless it is NULL).
+ */
+
+/* Get the first/last "ENGINE" type available. */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 ENGINE *ENGINE_get_first(void);
+OSSL_DEPRECATEDIN_3_0 ENGINE *ENGINE_get_last(void);
+#  endif
+/* Iterate to the next/previous "ENGINE" type (NULL = end of the list). */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 ENGINE *ENGINE_get_next(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 ENGINE *ENGINE_get_prev(ENGINE *e);
+#  endif
+/* Add another "ENGINE" type into the array. */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int ENGINE_add(ENGINE *e);
+#  endif
+/* Remove an existing "ENGINE" type from the array. */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int ENGINE_remove(ENGINE *e);
+#  endif
+/* Retrieve an engine from the list by its unique "id" value. */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 ENGINE *ENGINE_by_id(const char *id);
+#  endif
+
+#  ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#   define ENGINE_load_openssl() \
+        OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_OPENSSL, NULL)
+#   define ENGINE_load_dynamic() \
+        OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_DYNAMIC, NULL)
+#   ifndef OPENSSL_NO_STATIC_ENGINE
+#    define ENGINE_load_padlock() \
+        OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_PADLOCK, NULL)
+#    define ENGINE_load_capi() \
+        OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_CAPI, NULL)
+#    define ENGINE_load_afalg() \
+        OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_AFALG, NULL)
+#   endif
+#   define ENGINE_load_cryptodev() \
+        OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_CRYPTODEV, NULL)
+#   define ENGINE_load_rdrand() \
+        OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_RDRAND, NULL)
+#  endif
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 void ENGINE_load_builtin_engines(void);
+#  endif
+
+/*
+ * Get and set global flags (ENGINE_TABLE_FLAG_***) for the implementation
+ * "registry" handling.
+ */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 unsigned int ENGINE_get_table_flags(void);
+OSSL_DEPRECATEDIN_3_0 void ENGINE_set_table_flags(unsigned int flags);
+#  endif
+
+/*- Manage registration of ENGINEs per "table". For each type, there are 3
+ * functions;
+ *   ENGINE_register_***(e) - registers the implementation from 'e' (if it has one)
+ *   ENGINE_unregister_***(e) - unregister the implementation from 'e'
+ *   ENGINE_register_all_***() - call ENGINE_register_***() for each 'e' in the list
+ * Cleanup is automatically registered from each table when required.
+ */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int ENGINE_register_RSA(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 void ENGINE_unregister_RSA(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 void ENGINE_register_all_RSA(void);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_register_DSA(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 void ENGINE_unregister_DSA(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 void ENGINE_register_all_DSA(void);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_register_EC(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 void ENGINE_unregister_EC(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 void ENGINE_register_all_EC(void);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_register_DH(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 void ENGINE_unregister_DH(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 void ENGINE_register_all_DH(void);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_register_RAND(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 void ENGINE_unregister_RAND(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 void ENGINE_register_all_RAND(void);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_register_ciphers(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 void ENGINE_unregister_ciphers(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 void ENGINE_register_all_ciphers(void);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_register_digests(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 void ENGINE_unregister_digests(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 void ENGINE_register_all_digests(void);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_register_pkey_meths(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 void ENGINE_unregister_pkey_meths(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 void ENGINE_register_all_pkey_meths(void);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_register_pkey_asn1_meths(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 void ENGINE_unregister_pkey_asn1_meths(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 void ENGINE_register_all_pkey_asn1_meths(void);
+#  endif
+
+/*
+ * These functions register all support from the above categories. Note, use
+ * of these functions can result in static linkage of code your application
+ * may not need. If you only need a subset of functionality, consider using
+ * more selective initialisation.
+ */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int ENGINE_register_complete(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_register_all_complete(void);
+#  endif
+
+/*
+ * Send parameterised control commands to the engine. The possibilities to
+ * send down an integer, a pointer to data or a function pointer are
+ * provided. Any of the parameters may or may not be NULL, depending on the
+ * command number. In actuality, this function only requires a structural
+ * (rather than functional) reference to an engine, but many control commands
+ * may require the engine be functional. The caller should be aware of trying
+ * commands that require an operational ENGINE, and only use functional
+ * references in such situations.
+ */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int ENGINE_ctrl(ENGINE *e, int cmd, long i, void *p,
+                                      void (*f) (void));
+#  endif
+
+/*
+ * This function tests if an ENGINE-specific command is usable as a
+ * "setting". Eg. in an application's config file that gets processed through
+ * ENGINE_ctrl_cmd_string(). If this returns zero, it is not available to
+ * ENGINE_ctrl_cmd_string(), only ENGINE_ctrl().
+ */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int ENGINE_cmd_is_executable(ENGINE *e, int cmd);
+#  endif
+
+/*
+ * This function works like ENGINE_ctrl() with the exception of taking a
+ * command name instead of a command number, and can handle optional
+ * commands. See the comment on ENGINE_ctrl_cmd_string() for an explanation
+ * on how to use the cmd_name and cmd_optional.
+ */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int ENGINE_ctrl_cmd(ENGINE *e, const char *cmd_name,
+                                          long i, void *p, void (*f) (void),
+                                          int cmd_optional);
+#  endif
+
+/*
+ * This function passes a command-name and argument to an ENGINE. The
+ * cmd_name is converted to a command number and the control command is
+ * called using 'arg' as an argument (unless the ENGINE doesn't support such
+ * a command, in which case no control command is called). The command is
+ * checked for input flags, and if necessary the argument will be converted
+ * to a numeric value. If cmd_optional is non-zero, then if the ENGINE
+ * doesn't support the given cmd_name the return value will be success
+ * anyway. This function is intended for applications to use so that users
+ * (or config files) can supply engine-specific config data to the ENGINE at
+ * run-time to control behaviour of specific engines. As such, it shouldn't
+ * be used for calling ENGINE_ctrl() functions that return data, deal with
+ * binary data, or that are otherwise supposed to be used directly through
+ * ENGINE_ctrl() in application code. Any "return" data from an ENGINE_ctrl()
+ * operation in this function will be lost - the return value is interpreted
+ * as failure if the return value is zero, success otherwise, and this
+ * function returns a boolean value as a result. In other words, vendors of
+ * 'ENGINE'-enabled devices should write ENGINE implementations with
+ * parameterisations that work in this scheme, so that compliant ENGINE-based
+ * applications can work consistently with the same configuration for the
+ * same ENGINE-enabled devices, across applications.
+ */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+int ENGINE_ctrl_cmd_string(ENGINE *e, const char *cmd_name, const char *arg,
+                           int cmd_optional);
+#  endif
+
+/*
+ * These functions are useful for manufacturing new ENGINE structures. They
+ * don't address reference counting at all - one uses them to populate an
+ * ENGINE structure with personalised implementations of things prior to
+ * using it directly or adding it to the builtin ENGINE list in OpenSSL.
+ * These are also here so that the ENGINE structure doesn't have to be
+ * exposed and break binary compatibility!
+ */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 ENGINE *ENGINE_new(void);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_free(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_up_ref(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_set_id(ENGINE *e, const char *id);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_set_name(ENGINE *e, const char *name);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_set_RSA(ENGINE *e, const RSA_METHOD *rsa_meth);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_set_DSA(ENGINE *e, const DSA_METHOD *dsa_meth);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_set_EC(ENGINE *e, const EC_KEY_METHOD *ecdsa_meth);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_set_DH(ENGINE *e, const DH_METHOD *dh_meth);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_set_RAND(ENGINE *e, const RAND_METHOD *rand_meth);
+OSSL_DEPRECATEDIN_3_0
+int ENGINE_set_destroy_function(ENGINE *e,ENGINE_GEN_INT_FUNC_PTR destroy_f);
+OSSL_DEPRECATEDIN_3_0
+int ENGINE_set_init_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR init_f);
+OSSL_DEPRECATEDIN_3_0
+int ENGINE_set_finish_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR finish_f);
+OSSL_DEPRECATEDIN_3_0
+int ENGINE_set_ctrl_function(ENGINE *e, ENGINE_CTRL_FUNC_PTR ctrl_f);
+OSSL_DEPRECATEDIN_3_0
+int ENGINE_set_load_privkey_function(ENGINE *e, ENGINE_LOAD_KEY_PTR loadpriv_f);
+OSSL_DEPRECATEDIN_3_0
+int ENGINE_set_load_pubkey_function(ENGINE *e, ENGINE_LOAD_KEY_PTR loadpub_f);
+OSSL_DEPRECATEDIN_3_0
+int ENGINE_set_load_ssl_client_cert_function(ENGINE *e,
+                                             ENGINE_SSL_CLIENT_CERT_PTR loadssl_f);
+OSSL_DEPRECATEDIN_3_0
+int ENGINE_set_ciphers(ENGINE *e, ENGINE_CIPHERS_PTR f);
+OSSL_DEPRECATEDIN_3_0
+int ENGINE_set_digests(ENGINE *e, ENGINE_DIGESTS_PTR f);
+OSSL_DEPRECATEDIN_3_0
+int ENGINE_set_pkey_meths(ENGINE *e, ENGINE_PKEY_METHS_PTR f);
+OSSL_DEPRECATEDIN_3_0
+int ENGINE_set_pkey_asn1_meths(ENGINE *e, ENGINE_PKEY_ASN1_METHS_PTR f);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_set_flags(ENGINE *e, int flags);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_set_cmd_defns(ENGINE *e,
+                                               const ENGINE_CMD_DEFN *defns);
+#  endif
+/* These functions allow control over any per-structure ENGINE data. */
+#  define ENGINE_get_ex_new_index(l, p, newf, dupf, freef) \
+    CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_ENGINE, l, p, newf, dupf, freef)
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int ENGINE_set_ex_data(ENGINE *e, int idx, void *arg);
+OSSL_DEPRECATEDIN_3_0 void *ENGINE_get_ex_data(const ENGINE *e, int idx);
+# endif
+
+#  ifndef OPENSSL_NO_DEPRECATED_1_1_0
+/*
+ * This function previously cleaned up anything that needs it. Auto-deinit will
+ * now take care of it so it is no longer required to call this function.
+ */
+#   define ENGINE_cleanup() while(0) continue
+#  endif
+
+/*
+ * These return values from within the ENGINE structure. These can be useful
+ * with functional references as well as structural references - it depends
+ * which you obtained. Using the result for functional purposes if you only
+ * obtained a structural reference may be problematic!
+ */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 const char *ENGINE_get_id(const ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 const char *ENGINE_get_name(const ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 const RSA_METHOD *ENGINE_get_RSA(const ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 const DSA_METHOD *ENGINE_get_DSA(const ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 const EC_KEY_METHOD *ENGINE_get_EC(const ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 const DH_METHOD *ENGINE_get_DH(const ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 const RAND_METHOD *ENGINE_get_RAND(const ENGINE *e);
+OSSL_DEPRECATEDIN_3_0
+ENGINE_GEN_INT_FUNC_PTR ENGINE_get_destroy_function(const ENGINE *e);
+OSSL_DEPRECATEDIN_3_0
+ENGINE_GEN_INT_FUNC_PTR ENGINE_get_init_function(const ENGINE *e);
+OSSL_DEPRECATEDIN_3_0
+ENGINE_GEN_INT_FUNC_PTR ENGINE_get_finish_function(const ENGINE *e);
+OSSL_DEPRECATEDIN_3_0
+ENGINE_CTRL_FUNC_PTR ENGINE_get_ctrl_function(const ENGINE *e);
+OSSL_DEPRECATEDIN_3_0
+ENGINE_LOAD_KEY_PTR ENGINE_get_load_privkey_function(const ENGINE *e);
+OSSL_DEPRECATEDIN_3_0
+ENGINE_LOAD_KEY_PTR ENGINE_get_load_pubkey_function(const ENGINE *e);
+OSSL_DEPRECATEDIN_3_0
+ENGINE_SSL_CLIENT_CERT_PTR ENGINE_get_ssl_client_cert_function(const ENGINE *e);
+OSSL_DEPRECATEDIN_3_0
+ENGINE_CIPHERS_PTR ENGINE_get_ciphers(const ENGINE *e);
+OSSL_DEPRECATEDIN_3_0
+ENGINE_DIGESTS_PTR ENGINE_get_digests(const ENGINE *e);
+OSSL_DEPRECATEDIN_3_0
+ENGINE_PKEY_METHS_PTR ENGINE_get_pkey_meths(const ENGINE *e);
+OSSL_DEPRECATEDIN_3_0
+ENGINE_PKEY_ASN1_METHS_PTR ENGINE_get_pkey_asn1_meths(const ENGINE *e);
+OSSL_DEPRECATEDIN_3_0
+const EVP_CIPHER *ENGINE_get_cipher(ENGINE *e, int nid);
+OSSL_DEPRECATEDIN_3_0
+const EVP_MD *ENGINE_get_digest(ENGINE *e, int nid);
+OSSL_DEPRECATEDIN_3_0
+const EVP_PKEY_METHOD *ENGINE_get_pkey_meth(ENGINE *e, int nid);
+OSSL_DEPRECATEDIN_3_0
+const EVP_PKEY_ASN1_METHOD *ENGINE_get_pkey_asn1_meth(ENGINE *e, int nid);
+OSSL_DEPRECATEDIN_3_0
+const EVP_PKEY_ASN1_METHOD *ENGINE_get_pkey_asn1_meth_str(ENGINE *e,
+                                                          const char *str,
+                                                          int len);
+OSSL_DEPRECATEDIN_3_0
+const EVP_PKEY_ASN1_METHOD *ENGINE_pkey_asn1_find_str(ENGINE **pe,
+                                                      const char *str, int len);
+OSSL_DEPRECATEDIN_3_0
+const ENGINE_CMD_DEFN *ENGINE_get_cmd_defns(const ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_get_flags(const ENGINE *e);
+#  endif
+
+/*
+ * FUNCTIONAL functions. These functions deal with ENGINE structures that
+ * have (or will) be initialised for use. Broadly speaking, the structural
+ * functions are useful for iterating the list of available engine types,
+ * creating new engine types, and other "list" operations. These functions
+ * actually deal with ENGINEs that are to be used. As such these functions
+ * can fail (if applicable) when particular engines are unavailable - eg. if
+ * a hardware accelerator is not attached or not functioning correctly. Each
+ * ENGINE has 2 reference counts; structural and functional. Every time a
+ * functional reference is obtained or released, a corresponding structural
+ * reference is automatically obtained or released too.
+ */
+
+/*
+ * Initialise an engine type for use (or up its reference count if it's
+ * already in use). This will fail if the engine is not currently operational
+ * and cannot initialise.
+ */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int ENGINE_init(ENGINE *e);
+#  endif
+/*
+ * Free a functional reference to an engine type. This does not require a
+ * corresponding call to ENGINE_free as it also releases a structural
+ * reference.
+ */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int ENGINE_finish(ENGINE *e);
+#  endif
+
+/*
+ * The following functions handle keys that are stored in some secondary
+ * location, handled by the engine.  The storage may be on a card or
+ * whatever.
+ */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+EVP_PKEY *ENGINE_load_private_key(ENGINE *e, const char *key_id,
+                                  UI_METHOD *ui_method, void *callback_data);
+OSSL_DEPRECATEDIN_3_0
+EVP_PKEY *ENGINE_load_public_key(ENGINE *e, const char *key_id,
+                                 UI_METHOD *ui_method, void *callback_data);
+OSSL_DEPRECATEDIN_3_0
+int ENGINE_load_ssl_client_cert(ENGINE *e, SSL *s, STACK_OF(X509_NAME) *ca_dn,
+                                X509 **pcert, EVP_PKEY **ppkey,
+                                STACK_OF(X509) **pother,
+                                UI_METHOD *ui_method, void *callback_data);
+#  endif
+
+/*
+ * This returns a pointer for the current ENGINE structure that is (by
+ * default) performing any RSA operations. The value returned is an
+ * incremented reference, so it should be free'd (ENGINE_finish) before it is
+ * discarded.
+ */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 ENGINE *ENGINE_get_default_RSA(void);
+#  endif
+/* Same for the other "methods" */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 ENGINE *ENGINE_get_default_DSA(void);
+OSSL_DEPRECATEDIN_3_0 ENGINE *ENGINE_get_default_EC(void);
+OSSL_DEPRECATEDIN_3_0 ENGINE *ENGINE_get_default_DH(void);
+OSSL_DEPRECATEDIN_3_0 ENGINE *ENGINE_get_default_RAND(void);
+#  endif
+/*
+ * These functions can be used to get a functional reference to perform
+ * ciphering or digesting corresponding to "nid".
+ */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 ENGINE *ENGINE_get_cipher_engine(int nid);
+OSSL_DEPRECATEDIN_3_0 ENGINE *ENGINE_get_digest_engine(int nid);
+OSSL_DEPRECATEDIN_3_0 ENGINE *ENGINE_get_pkey_meth_engine(int nid);
+OSSL_DEPRECATEDIN_3_0 ENGINE *ENGINE_get_pkey_asn1_meth_engine(int nid);
+#  endif
+
+/*
+ * This sets a new default ENGINE structure for performing RSA operations. If
+ * the result is non-zero (success) then the ENGINE structure will have had
+ * its reference count up'd so the caller should still free their own
+ * reference 'e'.
+ */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int ENGINE_set_default_RSA(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_set_default_string(ENGINE *e,
+                                                    const char *def_list);
+#  endif
+/* Same for the other "methods" */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int ENGINE_set_default_DSA(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_set_default_EC(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_set_default_DH(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_set_default_RAND(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_set_default_ciphers(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_set_default_digests(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_set_default_pkey_meths(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_set_default_pkey_asn1_meths(ENGINE *e);
+#  endif
+
+/*
+ * The combination "set" - the flags are bitwise "OR"d from the
+ * ENGINE_METHOD_*** defines above. As with the "ENGINE_register_complete()"
+ * function, this function can result in unnecessary static linkage. If your
+ * application requires only specific functionality, consider using more
+ * selective functions.
+ */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int ENGINE_set_default(ENGINE *e, unsigned int flags);
+OSSL_DEPRECATEDIN_3_0 void ENGINE_add_conf_module(void);
+#  endif
+
+/* Deprecated functions ... */
+/* int ENGINE_clear_defaults(void); */
+
+/**************************/
+/* DYNAMIC ENGINE SUPPORT */
+/**************************/
+
+/* Binary/behaviour compatibility levels */
+#  define OSSL_DYNAMIC_VERSION            (unsigned long)0x00030000
+/*
+ * Binary versions older than this are too old for us (whether we're a loader
+ * or a loadee)
+ */
+#  define OSSL_DYNAMIC_OLDEST             (unsigned long)0x00030000
+
+/*
+ * When compiling an ENGINE entirely as an external shared library, loadable
+ * by the "dynamic" ENGINE, these types are needed. The 'dynamic_fns'
+ * structure type provides the calling application's (or library's) error
+ * functionality and memory management function pointers to the loaded
+ * library. These should be used/set in the loaded library code so that the
+ * loading application's 'state' will be used/changed in all operations. The
+ * 'static_state' pointer allows the loaded library to know if it shares the
+ * same static data as the calling application (or library), and thus whether
+ * these callbacks need to be set or not.
+ */
+typedef void *(*dyn_MEM_malloc_fn) (size_t, const char *, int);
+typedef void *(*dyn_MEM_realloc_fn) (void *, size_t, const char *, int);
+typedef void (*dyn_MEM_free_fn) (void *, const char *, int);
+typedef struct st_dynamic_MEM_fns {
+    dyn_MEM_malloc_fn malloc_fn;
+    dyn_MEM_realloc_fn realloc_fn;
+    dyn_MEM_free_fn free_fn;
+} dynamic_MEM_fns;
+/*
+ * FIXME: Perhaps the memory and locking code (crypto.h) should declare and
+ * use these types so we (and any other dependent code) can simplify a bit??
+ */
+/* The top-level structure */
+typedef struct st_dynamic_fns {
+    void *static_state;
+    dynamic_MEM_fns mem_fns;
+} dynamic_fns;
+
+/*
+ * The version checking function should be of this prototype. NB: The
+ * ossl_version value passed in is the OSSL_DYNAMIC_VERSION of the loading
+ * code. If this function returns zero, it indicates a (potential) version
+ * incompatibility and the loaded library doesn't believe it can proceed.
+ * Otherwise, the returned value is the (latest) version supported by the
+ * loading library. The loader may still decide that the loaded code's
+ * version is unsatisfactory and could veto the load. The function is
+ * expected to be implemented with the symbol name "v_check", and a default
+ * implementation can be fully instantiated with
+ * IMPLEMENT_DYNAMIC_CHECK_FN().
+ */
+typedef unsigned long (*dynamic_v_check_fn) (unsigned long ossl_version);
+#  define IMPLEMENT_DYNAMIC_CHECK_FN() \
+        OPENSSL_EXPORT unsigned long v_check(unsigned long v); \
+        OPENSSL_EXPORT unsigned long v_check(unsigned long v) { \
+                if (v >= OSSL_DYNAMIC_OLDEST) return OSSL_DYNAMIC_VERSION; \
+                return 0; }
+
+/*
+ * This function is passed the ENGINE structure to initialise with its own
+ * function and command settings. It should not adjust the structural or
+ * functional reference counts. If this function returns zero, (a) the load
+ * will be aborted, (b) the previous ENGINE state will be memcpy'd back onto
+ * the structure, and (c) the shared library will be unloaded. So
+ * implementations should do their own internal cleanup in failure
+ * circumstances otherwise they could leak. The 'id' parameter, if non-NULL,
+ * represents the ENGINE id that the loader is looking for. If this is NULL,
+ * the shared library can choose to return failure or to initialise a
+ * 'default' ENGINE. If non-NULL, the shared library must initialise only an
+ * ENGINE matching the passed 'id'. The function is expected to be
+ * implemented with the symbol name "bind_engine". A standard implementation
+ * can be instantiated with IMPLEMENT_DYNAMIC_BIND_FN(fn) where the parameter
+ * 'fn' is a callback function that populates the ENGINE structure and
+ * returns an int value (zero for failure). 'fn' should have prototype;
+ * [static] int fn(ENGINE *e, const char *id);
+ */
+typedef int (*dynamic_bind_engine) (ENGINE *e, const char *id,
+                                    const dynamic_fns *fns);
+#  define IMPLEMENT_DYNAMIC_BIND_FN(fn) \
+        OPENSSL_EXPORT \
+        int bind_engine(ENGINE *e, const char *id, const dynamic_fns *fns); \
+        OPENSSL_EXPORT \
+        int bind_engine(ENGINE *e, const char *id, const dynamic_fns *fns) { \
+            if (ENGINE_get_static_state() == fns->static_state) goto skip_cbs; \
+            CRYPTO_set_mem_functions(fns->mem_fns.malloc_fn, \
+                                     fns->mem_fns.realloc_fn, \
+                                     fns->mem_fns.free_fn); \
+            OPENSSL_init_crypto(OPENSSL_INIT_NO_ATEXIT, NULL); \
+        skip_cbs: \
+            if (!fn(e, id)) return 0; \
+            return 1; }
+
+/*
+ * If the loading application (or library) and the loaded ENGINE library
+ * share the same static data (eg. they're both dynamically linked to the
+ * same libcrypto.so) we need a way to avoid trying to set system callbacks -
+ * this would fail, and for the same reason that it's unnecessary to try. If
+ * the loaded ENGINE has (or gets from through the loader) its own copy of
+ * the libcrypto static data, we will need to set the callbacks. The easiest
+ * way to detect this is to have a function that returns a pointer to some
+ * static data and let the loading application and loaded ENGINE compare
+ * their respective values.
+ */
+void *ENGINE_get_static_state(void);
+
+#  if defined(__OpenBSD__) || defined(__FreeBSD__) || defined(__DragonFly__)
+#   ifndef OPENSSL_NO_DEPRECATED_1_1_0
+OSSL_DEPRECATEDIN_1_1_0 void ENGINE_setup_bsd_cryptodev(void);
+#   endif
+#  endif
+
+
+#  ifdef  __cplusplus
+}
+#  endif
+# endif /* OPENSSL_NO_ENGINE */
+#endif  /* OPENSSL_ENGINE_H */
diff --git a/src/include/openssl/engineerr.h b/src/include/openssl/engineerr.h
new file mode 100644
index 0000000..d439b68
--- /dev/null
+++ b/src/include/openssl/engineerr.h
@@ -0,0 +1,63 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_ENGINEERR_H
+# define OPENSSL_ENGINEERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+# ifndef OPENSSL_NO_ENGINE
+
+
+/*
+ * ENGINE reason codes.
+ */
+#  define ENGINE_R_ALREADY_LOADED                          100
+#  define ENGINE_R_ARGUMENT_IS_NOT_A_NUMBER                133
+#  define ENGINE_R_CMD_NOT_EXECUTABLE                      134
+#  define ENGINE_R_COMMAND_TAKES_INPUT                     135
+#  define ENGINE_R_COMMAND_TAKES_NO_INPUT                  136
+#  define ENGINE_R_CONFLICTING_ENGINE_ID                   103
+#  define ENGINE_R_CTRL_COMMAND_NOT_IMPLEMENTED            119
+#  define ENGINE_R_DSO_FAILURE                             104
+#  define ENGINE_R_DSO_NOT_FOUND                           132
+#  define ENGINE_R_ENGINES_SECTION_ERROR                   148
+#  define ENGINE_R_ENGINE_CONFIGURATION_ERROR              102
+#  define ENGINE_R_ENGINE_IS_NOT_IN_LIST                   105
+#  define ENGINE_R_ENGINE_SECTION_ERROR                    149
+#  define ENGINE_R_FAILED_LOADING_PRIVATE_KEY              128
+#  define ENGINE_R_FAILED_LOADING_PUBLIC_KEY               129
+#  define ENGINE_R_FINISH_FAILED                           106
+#  define ENGINE_R_ID_OR_NAME_MISSING                      108
+#  define ENGINE_R_INIT_FAILED                             109
+#  define ENGINE_R_INTERNAL_LIST_ERROR                     110
+#  define ENGINE_R_INVALID_ARGUMENT                        143
+#  define ENGINE_R_INVALID_CMD_NAME                        137
+#  define ENGINE_R_INVALID_CMD_NUMBER                      138
+#  define ENGINE_R_INVALID_INIT_VALUE                      151
+#  define ENGINE_R_INVALID_STRING                          150
+#  define ENGINE_R_NOT_INITIALISED                         117
+#  define ENGINE_R_NOT_LOADED                              112
+#  define ENGINE_R_NO_CONTROL_FUNCTION                     120
+#  define ENGINE_R_NO_INDEX                                144
+#  define ENGINE_R_NO_LOAD_FUNCTION                        125
+#  define ENGINE_R_NO_REFERENCE                            130
+#  define ENGINE_R_NO_SUCH_ENGINE                          116
+#  define ENGINE_R_UNIMPLEMENTED_CIPHER                    146
+#  define ENGINE_R_UNIMPLEMENTED_DIGEST                    147
+#  define ENGINE_R_UNIMPLEMENTED_PUBLIC_KEY_METHOD         101
+#  define ENGINE_R_VERSION_INCOMPATIBILITY                 145
+
+# endif
+#endif
diff --git a/src/include/openssl/err.h b/src/include/openssl/err.h
new file mode 100644
index 0000000..daca18e
--- /dev/null
+++ b/src/include/openssl/err.h
@@ -0,0 +1,512 @@
+/*
+ * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+
+
+#ifndef OPENSSL_ERR_H
+# define OPENSSL_ERR_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_ERR_H
+# endif
+
+# include <openssl/e_os2.h>
+
+# ifndef OPENSSL_NO_STDIO
+#  include <stdio.h>
+#  include <stdlib.h>
+# endif
+
+# include <openssl/types.h>
+# include <openssl/bio.h>
+# include <openssl/lhash.h>
+# include <openssl/cryptoerr_legacy.h>
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  ifndef OPENSSL_NO_FILENAMES
+#   define ERR_PUT_error(l,f,r,fn,ln)      ERR_put_error(l,f,r,fn,ln)
+#  else
+#   define ERR_PUT_error(l,f,r,fn,ln)      ERR_put_error(l,f,r,NULL,0)
+#  endif
+# endif
+
+# include <limits.h>
+# include <errno.h>
+
+# define ERR_TXT_MALLOCED        0x01
+# define ERR_TXT_STRING          0x02
+
+# if !defined(OPENSSL_NO_DEPRECATED_3_0) || defined(OSSL_FORCE_ERR_STATE)
+#  define ERR_FLAG_MARK           0x01
+#  define ERR_FLAG_CLEAR          0x02
+
+#  define ERR_NUM_ERRORS  16
+struct err_state_st {
+    int err_flags[ERR_NUM_ERRORS];
+    int err_marks[ERR_NUM_ERRORS];
+    unsigned long err_buffer[ERR_NUM_ERRORS];
+    char *err_data[ERR_NUM_ERRORS];
+    size_t err_data_size[ERR_NUM_ERRORS];
+    int err_data_flags[ERR_NUM_ERRORS];
+    char *err_file[ERR_NUM_ERRORS];
+    int err_line[ERR_NUM_ERRORS];
+    char *err_func[ERR_NUM_ERRORS];
+    int top, bottom;
+};
+# endif
+
+/* library */
+# define ERR_LIB_NONE            1
+# define ERR_LIB_SYS             2
+# define ERR_LIB_BN              3
+# define ERR_LIB_RSA             4
+# define ERR_LIB_DH              5
+# define ERR_LIB_EVP             6
+# define ERR_LIB_BUF             7
+# define ERR_LIB_OBJ             8
+# define ERR_LIB_PEM             9
+# define ERR_LIB_DSA             10
+# define ERR_LIB_X509            11
+/* #define ERR_LIB_METH         12 */
+# define ERR_LIB_ASN1            13
+# define ERR_LIB_CONF            14
+# define ERR_LIB_CRYPTO          15
+# define ERR_LIB_EC              16
+# define ERR_LIB_SSL             20
+/* #define ERR_LIB_SSL23        21 */
+/* #define ERR_LIB_SSL2         22 */
+/* #define ERR_LIB_SSL3         23 */
+/* #define ERR_LIB_RSAREF       30 */
+/* #define ERR_LIB_PROXY        31 */
+# define ERR_LIB_BIO             32
+# define ERR_LIB_PKCS7           33
+# define ERR_LIB_X509V3          34
+# define ERR_LIB_PKCS12          35
+# define ERR_LIB_RAND            36
+# define ERR_LIB_DSO             37
+# define ERR_LIB_ENGINE          38
+# define ERR_LIB_OCSP            39
+# define ERR_LIB_UI              40
+# define ERR_LIB_COMP            41
+# define ERR_LIB_ECDSA           42
+# define ERR_LIB_ECDH            43
+# define ERR_LIB_OSSL_STORE      44
+# define ERR_LIB_FIPS            45
+# define ERR_LIB_CMS             46
+# define ERR_LIB_TS              47
+# define ERR_LIB_HMAC            48
+/* # define ERR_LIB_JPAKE       49 */
+# define ERR_LIB_CT              50
+# define ERR_LIB_ASYNC           51
+# define ERR_LIB_KDF             52
+# define ERR_LIB_SM2             53
+# define ERR_LIB_ESS             54
+# define ERR_LIB_PROP            55
+# define ERR_LIB_CRMF            56
+# define ERR_LIB_PROV            57
+# define ERR_LIB_CMP             58
+# define ERR_LIB_OSSL_ENCODER    59
+# define ERR_LIB_OSSL_DECODER    60
+# define ERR_LIB_HTTP            61
+
+# define ERR_LIB_USER            128
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define ASN1err(f, r) ERR_raise_data(ERR_LIB_ASN1, (r), NULL)
+#  define ASYNCerr(f, r) ERR_raise_data(ERR_LIB_ASYNC, (r), NULL)
+#  define BIOerr(f, r) ERR_raise_data(ERR_LIB_BIO, (r), NULL)
+#  define BNerr(f, r)  ERR_raise_data(ERR_LIB_BN, (r), NULL)
+#  define BUFerr(f, r) ERR_raise_data(ERR_LIB_BUF, (r), NULL)
+#  define CMPerr(f, r) ERR_raise_data(ERR_LIB_CMP, (r), NULL)
+#  define CMSerr(f, r) ERR_raise_data(ERR_LIB_CMS, (r), NULL)
+#  define COMPerr(f, r) ERR_raise_data(ERR_LIB_COMP, (r), NULL)
+#  define CONFerr(f, r) ERR_raise_data(ERR_LIB_CONF, (r), NULL)
+#  define CRMFerr(f, r) ERR_raise_data(ERR_LIB_CRMF, (r), NULL)
+#  define CRYPTOerr(f, r) ERR_raise_data(ERR_LIB_CRYPTO, (r), NULL)
+#  define CTerr(f, r) ERR_raise_data(ERR_LIB_CT, (r), NULL)
+#  define DHerr(f, r)  ERR_raise_data(ERR_LIB_DH, (r), NULL)
+#  define DSAerr(f, r) ERR_raise_data(ERR_LIB_DSA, (r), NULL)
+#  define DSOerr(f, r) ERR_raise_data(ERR_LIB_DSO, (r), NULL)
+#  define ECDHerr(f, r) ERR_raise_data(ERR_LIB_ECDH, (r), NULL)
+#  define ECDSAerr(f, r) ERR_raise_data(ERR_LIB_ECDSA, (r), NULL)
+#  define ECerr(f, r)  ERR_raise_data(ERR_LIB_EC, (r), NULL)
+#  define ENGINEerr(f, r) ERR_raise_data(ERR_LIB_ENGINE, (r), NULL)
+#  define ESSerr(f, r) ERR_raise_data(ERR_LIB_ESS, (r), NULL)
+#  define EVPerr(f, r) ERR_raise_data(ERR_LIB_EVP, (r), NULL)
+#  define FIPSerr(f, r) ERR_raise_data(ERR_LIB_FIPS, (r), NULL)
+#  define HMACerr(f, r) ERR_raise_data(ERR_LIB_HMAC, (r), NULL)
+#  define HTTPerr(f, r) ERR_raise_data(ERR_LIB_HTTP, (r), NULL)
+#  define KDFerr(f, r) ERR_raise_data(ERR_LIB_KDF, (r), NULL)
+#  define OBJerr(f, r) ERR_raise_data(ERR_LIB_OBJ, (r), NULL)
+#  define OCSPerr(f, r) ERR_raise_data(ERR_LIB_OCSP, (r), NULL)
+#  define OSSL_STOREerr(f, r) ERR_raise_data(ERR_LIB_OSSL_STORE, (r), NULL)
+#  define PEMerr(f, r) ERR_raise_data(ERR_LIB_PEM, (r), NULL)
+#  define PKCS12err(f, r) ERR_raise_data(ERR_LIB_PKCS12, (r), NULL)
+#  define PKCS7err(f, r) ERR_raise_data(ERR_LIB_PKCS7, (r), NULL)
+#  define PROPerr(f, r) ERR_raise_data(ERR_LIB_PROP, (r), NULL)
+#  define PROVerr(f, r) ERR_raise_data(ERR_LIB_PROV, (r), NULL)
+#  define RANDerr(f, r) ERR_raise_data(ERR_LIB_RAND, (r), NULL)
+#  define RSAerr(f, r) ERR_raise_data(ERR_LIB_RSA, (r), NULL)
+#  define KDFerr(f, r) ERR_raise_data(ERR_LIB_KDF, (r), NULL)
+#  define SM2err(f, r) ERR_raise_data(ERR_LIB_SM2, (r), NULL)
+#  define SSLerr(f, r) ERR_raise_data(ERR_LIB_SSL, (r), NULL)
+#  define SYSerr(f, r) ERR_raise_data(ERR_LIB_SYS, (r), NULL)
+#  define TSerr(f, r) ERR_raise_data(ERR_LIB_TS, (r), NULL)
+#  define UIerr(f, r) ERR_raise_data(ERR_LIB_UI, (r), NULL)
+#  define X509V3err(f, r) ERR_raise_data(ERR_LIB_X509V3, (r), NULL)
+#  define X509err(f, r) ERR_raise_data(ERR_LIB_X509, (r), NULL)
+# endif
+
+/*-
+ * The error code packs differently depending on if it records a system
+ * error or an OpenSSL error.
+ *
+ * A system error packs like this (we follow POSIX and only allow positive
+ * numbers that fit in an |int|):
+ *
+ * +-+-------------------------------------------------------------+
+ * |1|                     system error number                     |
+ * +-+-------------------------------------------------------------+
+ *
+ * An OpenSSL error packs like this:
+ *
+ * <---------------------------- 32 bits -------------------------->
+ *    <--- 8 bits ---><------------------ 23 bits ----------------->
+ * +-+---------------+---------------------------------------------+
+ * |0|    library    |                    reason                   |
+ * +-+---------------+---------------------------------------------+
+ *
+ * A few of the reason bits are reserved as flags with special meaning:
+ *
+ *                    <5 bits-<>--------- 19 bits ----------------->
+ *                   +-------+-+-----------------------------------+
+ *                   | rflags| |          reason                   |
+ *                   +-------+-+-----------------------------------+
+ *                            ^
+ *                            |
+ *                           ERR_RFLAG_FATAL = ERR_R_FATAL
+ *
+ * The reason flags are part of the overall reason code for practical
+ * reasons, as they provide an easy way to place different types of
+ * reason codes in different numeric ranges.
+ *
+ * The currently known reason flags are:
+ *
+ * ERR_RFLAG_FATAL      Flags that the reason code is considered fatal.
+ *                      For backward compatibility reasons, this flag
+ *                      is also the code for ERR_R_FATAL (that reason
+ *                      code served the dual purpose of flag and reason
+ *                      code in one in pre-3.0 OpenSSL).
+ * ERR_RFLAG_COMMON     Flags that the reason code is common to all
+ *                      libraries.  All ERR_R_ macros must use this flag,
+ *                      and no other _R_ macro is allowed to use it.
+ */
+
+/* Macros to help decode recorded system errors */
+# define ERR_SYSTEM_FLAG                ((unsigned int)INT_MAX + 1)
+# define ERR_SYSTEM_MASK                ((unsigned int)INT_MAX)
+
+/*
+ * Macros to help decode recorded OpenSSL errors
+ * As expressed above, RFLAGS and REASON overlap by one bit to allow
+ * ERR_R_FATAL to use ERR_RFLAG_FATAL as its reason code.
+ */
+# define ERR_LIB_OFFSET                 23L
+# define ERR_LIB_MASK                   0xFF
+# define ERR_RFLAGS_OFFSET              18L
+# define ERR_RFLAGS_MASK                0x1F
+# define ERR_REASON_MASK                0X7FFFFF
+
+/*
+ * Reason flags are defined pre-shifted to easily combine with the reason
+ * number.
+ */
+# define ERR_RFLAG_FATAL                (0x1 << ERR_RFLAGS_OFFSET)
+# define ERR_RFLAG_COMMON               (0x2 << ERR_RFLAGS_OFFSET)
+
+# define ERR_SYSTEM_ERROR(errcode)      (((errcode) & ERR_SYSTEM_FLAG) != 0)
+
+static ossl_unused ossl_inline int ERR_GET_LIB(unsigned long errcode)
+{
+    if (ERR_SYSTEM_ERROR(errcode))
+        return ERR_LIB_SYS;
+    return (errcode >> ERR_LIB_OFFSET) & ERR_LIB_MASK;
+}
+
+static ossl_unused ossl_inline int ERR_GET_RFLAGS(unsigned long errcode)
+{
+    if (ERR_SYSTEM_ERROR(errcode))
+        return 0;
+    return errcode & (ERR_RFLAGS_MASK << ERR_RFLAGS_OFFSET);
+}
+
+static ossl_unused ossl_inline int ERR_GET_REASON(unsigned long errcode)
+{
+    if (ERR_SYSTEM_ERROR(errcode))
+        return errcode & ERR_SYSTEM_MASK;
+    return errcode & ERR_REASON_MASK;
+}
+
+static ossl_unused ossl_inline int ERR_FATAL_ERROR(unsigned long errcode)
+{
+    return (ERR_GET_RFLAGS(errcode) & ERR_RFLAG_FATAL) != 0;
+}
+
+static ossl_unused ossl_inline int ERR_COMMON_ERROR(unsigned long errcode)
+{
+    return (ERR_GET_RFLAGS(errcode) & ERR_RFLAG_COMMON) != 0;
+}
+
+/*
+ * ERR_PACK is a helper macro to properly pack OpenSSL error codes and may
+ * only be used for that purpose.  System errors are packed internally.
+ * ERR_PACK takes reason flags and reason code combined in |reason|.
+ * ERR_PACK ignores |func|, that parameter is just legacy from pre-3.0 OpenSSL.
+ */
+# define ERR_PACK(lib,func,reason)                                      \
+    ( (((unsigned long)(lib)    & ERR_LIB_MASK   ) << ERR_LIB_OFFSET) | \
+      (((unsigned long)(reason) & ERR_REASON_MASK)) )
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define SYS_F_FOPEN             0
+#  define SYS_F_CONNECT           0
+#  define SYS_F_GETSERVBYNAME     0
+#  define SYS_F_SOCKET            0
+#  define SYS_F_IOCTLSOCKET       0
+#  define SYS_F_BIND              0
+#  define SYS_F_LISTEN            0
+#  define SYS_F_ACCEPT            0
+#  define SYS_F_WSASTARTUP        0
+#  define SYS_F_OPENDIR           0
+#  define SYS_F_FREAD             0
+#  define SYS_F_GETADDRINFO       0
+#  define SYS_F_GETNAMEINFO       0
+#  define SYS_F_SETSOCKOPT        0
+#  define SYS_F_GETSOCKOPT        0
+#  define SYS_F_GETSOCKNAME       0
+#  define SYS_F_GETHOSTBYNAME     0
+#  define SYS_F_FFLUSH            0
+#  define SYS_F_OPEN              0
+#  define SYS_F_CLOSE             0
+#  define SYS_F_IOCTL             0
+#  define SYS_F_STAT              0
+#  define SYS_F_FCNTL             0
+#  define SYS_F_FSTAT             0
+#  define SYS_F_SENDFILE          0
+# endif
+
+/*
+ * All ERR_R_ codes must be combined with ERR_RFLAG_COMMON.
+ */
+
+/* "we came from here" global reason codes, range 1..255 */
+# define ERR_R_SYS_LIB          (ERR_LIB_SYS/* 2 */ | ERR_RFLAG_COMMON)
+# define ERR_R_BN_LIB           (ERR_LIB_BN/* 3 */ | ERR_RFLAG_COMMON)
+# define ERR_R_RSA_LIB          (ERR_LIB_RSA/* 4 */ | ERR_RFLAG_COMMON)
+# define ERR_R_DH_LIB           (ERR_LIB_DH/* 5 */ | ERR_RFLAG_COMMON)
+# define ERR_R_EVP_LIB          (ERR_LIB_EVP/* 6 */ | ERR_RFLAG_COMMON)
+# define ERR_R_BUF_LIB          (ERR_LIB_BUF/* 7 */ | ERR_RFLAG_COMMON)
+# define ERR_R_OBJ_LIB          (ERR_LIB_OBJ/* 8 */ | ERR_RFLAG_COMMON)
+# define ERR_R_PEM_LIB          (ERR_LIB_PEM/* 9 */ | ERR_RFLAG_COMMON)
+# define ERR_R_DSA_LIB          (ERR_LIB_DSA/* 10 */ | ERR_RFLAG_COMMON)
+# define ERR_R_X509_LIB         (ERR_LIB_X509/* 11 */ | ERR_RFLAG_COMMON)
+# define ERR_R_ASN1_LIB         (ERR_LIB_ASN1/* 13 */ | ERR_RFLAG_COMMON)
+# define ERR_R_CONF_LIB         (ERR_LIB_CONF/* 14 */ | ERR_RFLAG_COMMON)
+# define ERR_R_CRYPTO_LIB       (ERR_LIB_CRYPTO/* 15 */ | ERR_RFLAG_COMMON)
+# define ERR_R_EC_LIB           (ERR_LIB_EC/* 16 */ | ERR_RFLAG_COMMON)
+# define ERR_R_SSL_LIB          (ERR_LIB_SSL/* 20 */ | ERR_RFLAG_COMMON)
+# define ERR_R_BIO_LIB          (ERR_LIB_BIO/* 32 */ | ERR_RFLAG_COMMON)
+# define ERR_R_PKCS7_LIB        (ERR_LIB_PKCS7/* 33 */ | ERR_RFLAG_COMMON)
+# define ERR_R_X509V3_LIB       (ERR_LIB_X509V3/* 34 */ | ERR_RFLAG_COMMON)
+# define ERR_R_PKCS12_LIB       (ERR_LIB_PKCS12/* 35 */ | ERR_RFLAG_COMMON)
+# define ERR_R_RAND_LIB         (ERR_LIB_RAND/* 36 */ | ERR_RFLAG_COMMON)
+# define ERR_R_DSO_LIB          (ERR_LIB_DSO/* 37 */ | ERR_RFLAG_COMMON)
+# define ERR_R_ENGINE_LIB       (ERR_LIB_ENGINE/* 38 */ | ERR_RFLAG_COMMON)
+# define ERR_R_UI_LIB           (ERR_LIB_UI/* 40 */ | ERR_RFLAG_COMMON)
+# define ERR_R_ECDSA_LIB        (ERR_LIB_ECDSA/* 42 */ | ERR_RFLAG_COMMON)
+# define ERR_R_OSSL_STORE_LIB   (ERR_LIB_OSSL_STORE/* 44 */ | ERR_RFLAG_COMMON)
+# define ERR_R_CMS_LIB          (ERR_LIB_CMS/* 46 */ | ERR_RFLAG_COMMON)
+# define ERR_R_TS_LIB           (ERR_LIB_TS/* 47 */ | ERR_RFLAG_COMMON)
+# define ERR_R_CT_LIB           (ERR_LIB_CT/* 50 */ | ERR_RFLAG_COMMON)
+# define ERR_R_PROV_LIB         (ERR_LIB_PROV/* 57 */ | ERR_RFLAG_COMMON)
+# define ERR_R_ESS_LIB          (ERR_LIB_ESS/* 54 */ | ERR_RFLAG_COMMON)
+# define ERR_R_CMP_LIB          (ERR_LIB_CMP/* 58 */ | ERR_RFLAG_COMMON)
+# define ERR_R_OSSL_ENCODER_LIB (ERR_LIB_OSSL_ENCODER/* 59 */ | ERR_RFLAG_COMMON)
+# define ERR_R_OSSL_DECODER_LIB (ERR_LIB_OSSL_DECODER/* 60 */ | ERR_RFLAG_COMMON)
+
+/* Other common error codes, range 256..2^ERR_RFLAGS_OFFSET-1 */
+# define ERR_R_FATAL                             (ERR_RFLAG_FATAL|ERR_RFLAG_COMMON)
+# define ERR_R_MALLOC_FAILURE                    (256|ERR_R_FATAL)
+# define ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED       (257|ERR_R_FATAL)
+# define ERR_R_PASSED_NULL_PARAMETER             (258|ERR_R_FATAL)
+# define ERR_R_INTERNAL_ERROR                    (259|ERR_R_FATAL)
+# define ERR_R_DISABLED                          (260|ERR_R_FATAL)
+# define ERR_R_INIT_FAIL                         (261|ERR_R_FATAL)
+# define ERR_R_PASSED_INVALID_ARGUMENT           (262|ERR_RFLAG_COMMON)
+# define ERR_R_OPERATION_FAIL                    (263|ERR_R_FATAL)
+# define ERR_R_INVALID_PROVIDER_FUNCTIONS        (264|ERR_R_FATAL)
+# define ERR_R_INTERRUPTED_OR_CANCELLED          (265|ERR_RFLAG_COMMON)
+# define ERR_R_NESTED_ASN1_ERROR                 (266|ERR_RFLAG_COMMON)
+# define ERR_R_MISSING_ASN1_EOS                  (267|ERR_RFLAG_COMMON)
+# define ERR_R_UNSUPPORTED                       (268|ERR_RFLAG_COMMON)
+# define ERR_R_FETCH_FAILED                      (269|ERR_RFLAG_COMMON)
+# define ERR_R_INVALID_PROPERTY_DEFINITION       (270|ERR_RFLAG_COMMON)
+# define ERR_R_UNABLE_TO_GET_READ_LOCK           (271|ERR_R_FATAL)
+# define ERR_R_UNABLE_TO_GET_WRITE_LOCK          (272|ERR_R_FATAL)
+
+typedef struct ERR_string_data_st {
+    unsigned long error;
+    const char *string;
+} ERR_STRING_DATA;
+
+DEFINE_LHASH_OF_INTERNAL(ERR_STRING_DATA);
+#define lh_ERR_STRING_DATA_new(hfn, cmp) ((LHASH_OF(ERR_STRING_DATA) *)OPENSSL_LH_set_thunks(OPENSSL_LH_new(ossl_check_ERR_STRING_DATA_lh_hashfunc_type(hfn), ossl_check_ERR_STRING_DATA_lh_compfunc_type(cmp)), lh_ERR_STRING_DATA_hash_thunk, lh_ERR_STRING_DATA_comp_thunk, lh_ERR_STRING_DATA_doall_thunk, lh_ERR_STRING_DATA_doall_arg_thunk))
+#define lh_ERR_STRING_DATA_free(lh) OPENSSL_LH_free(ossl_check_ERR_STRING_DATA_lh_type(lh))
+#define lh_ERR_STRING_DATA_flush(lh) OPENSSL_LH_flush(ossl_check_ERR_STRING_DATA_lh_type(lh))
+#define lh_ERR_STRING_DATA_insert(lh, ptr) ((ERR_STRING_DATA *)OPENSSL_LH_insert(ossl_check_ERR_STRING_DATA_lh_type(lh), ossl_check_ERR_STRING_DATA_lh_plain_type(ptr)))
+#define lh_ERR_STRING_DATA_delete(lh, ptr) ((ERR_STRING_DATA *)OPENSSL_LH_delete(ossl_check_ERR_STRING_DATA_lh_type(lh), ossl_check_const_ERR_STRING_DATA_lh_plain_type(ptr)))
+#define lh_ERR_STRING_DATA_retrieve(lh, ptr) ((ERR_STRING_DATA *)OPENSSL_LH_retrieve(ossl_check_ERR_STRING_DATA_lh_type(lh), ossl_check_const_ERR_STRING_DATA_lh_plain_type(ptr)))
+#define lh_ERR_STRING_DATA_error(lh) OPENSSL_LH_error(ossl_check_ERR_STRING_DATA_lh_type(lh))
+#define lh_ERR_STRING_DATA_num_items(lh) OPENSSL_LH_num_items(ossl_check_ERR_STRING_DATA_lh_type(lh))
+#define lh_ERR_STRING_DATA_node_stats_bio(lh, out) OPENSSL_LH_node_stats_bio(ossl_check_const_ERR_STRING_DATA_lh_type(lh), out)
+#define lh_ERR_STRING_DATA_node_usage_stats_bio(lh, out) OPENSSL_LH_node_usage_stats_bio(ossl_check_const_ERR_STRING_DATA_lh_type(lh), out)
+#define lh_ERR_STRING_DATA_stats_bio(lh, out) OPENSSL_LH_stats_bio(ossl_check_const_ERR_STRING_DATA_lh_type(lh), out)
+#define lh_ERR_STRING_DATA_get_down_load(lh) OPENSSL_LH_get_down_load(ossl_check_ERR_STRING_DATA_lh_type(lh))
+#define lh_ERR_STRING_DATA_set_down_load(lh, dl) OPENSSL_LH_set_down_load(ossl_check_ERR_STRING_DATA_lh_type(lh), dl)
+#define lh_ERR_STRING_DATA_doall(lh, dfn) OPENSSL_LH_doall(ossl_check_ERR_STRING_DATA_lh_type(lh), ossl_check_ERR_STRING_DATA_lh_doallfunc_type(dfn))
+
+
+/* 12 lines and some on an 80 column terminal */
+#define ERR_MAX_DATA_SIZE       1024
+
+/* Building blocks */
+void ERR_new(void);
+void ERR_set_debug(const char *file, int line, const char *func);
+void ERR_set_error(int lib, int reason, const char *fmt, ...);
+void ERR_vset_error(int lib, int reason, const char *fmt, va_list args);
+
+/* Main error raising functions */
+# define ERR_raise(lib, reason) ERR_raise_data((lib),(reason),NULL)
+# define ERR_raise_data                                         \
+    (ERR_new(),                                                 \
+     ERR_set_debug(OPENSSL_FILE,OPENSSL_LINE,OPENSSL_FUNC),     \
+     ERR_set_error)
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+/* Backward compatibility */
+#  define ERR_put_error(lib, func, reason, file, line)          \
+    (ERR_new(),                                                 \
+     ERR_set_debug((file), (line), OPENSSL_FUNC),               \
+     ERR_set_error((lib), (reason), NULL))
+# endif
+
+void ERR_set_error_data(char *data, int flags);
+
+unsigned long ERR_get_error(void);
+unsigned long ERR_get_error_all(const char **file, int *line,
+                                const char **func,
+                                const char **data, int *flags);
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+unsigned long ERR_get_error_line(const char **file, int *line);
+OSSL_DEPRECATEDIN_3_0
+unsigned long ERR_get_error_line_data(const char **file, int *line,
+                                      const char **data, int *flags);
+#endif
+unsigned long ERR_peek_error(void);
+unsigned long ERR_peek_error_line(const char **file, int *line);
+unsigned long ERR_peek_error_func(const char **func);
+unsigned long ERR_peek_error_data(const char **data, int *flags);
+unsigned long ERR_peek_error_all(const char **file, int *line,
+                                 const char **func,
+                                 const char **data, int *flags);
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+unsigned long ERR_peek_error_line_data(const char **file, int *line,
+                                       const char **data, int *flags);
+# endif
+unsigned long ERR_peek_last_error(void);
+unsigned long ERR_peek_last_error_line(const char **file, int *line);
+unsigned long ERR_peek_last_error_func(const char **func);
+unsigned long ERR_peek_last_error_data(const char **data, int *flags);
+unsigned long ERR_peek_last_error_all(const char **file, int *line,
+                                      const char **func,
+                                      const char **data, int *flags);
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+unsigned long ERR_peek_last_error_line_data(const char **file, int *line,
+                                            const char **data, int *flags);
+# endif
+
+void ERR_clear_error(void);
+
+char *ERR_error_string(unsigned long e, char *buf);
+void ERR_error_string_n(unsigned long e, char *buf, size_t len);
+const char *ERR_lib_error_string(unsigned long e);
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 const char *ERR_func_error_string(unsigned long e);
+# endif
+const char *ERR_reason_error_string(unsigned long e);
+
+void ERR_print_errors_cb(int (*cb) (const char *str, size_t len, void *u),
+                         void *u);
+# ifndef OPENSSL_NO_STDIO
+void ERR_print_errors_fp(FILE *fp);
+# endif
+void ERR_print_errors(BIO *bp);
+
+void ERR_add_error_data(int num, ...);
+void ERR_add_error_vdata(int num, va_list args);
+void ERR_add_error_txt(const char *sepr, const char *txt);
+void ERR_add_error_mem_bio(const char *sep, BIO *bio);
+
+int ERR_load_strings(int lib, ERR_STRING_DATA *str);
+int ERR_load_strings_const(const ERR_STRING_DATA *str);
+int ERR_unload_strings(int lib, ERR_STRING_DATA *str);
+
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+# define ERR_load_crypto_strings() \
+    OPENSSL_init_crypto(OPENSSL_INIT_LOAD_CRYPTO_STRINGS, NULL)
+# define ERR_free_strings() while(0) continue
+#endif
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+OSSL_DEPRECATEDIN_1_1_0 void ERR_remove_thread_state(void *);
+#endif
+#ifndef OPENSSL_NO_DEPRECATED_1_0_0
+OSSL_DEPRECATEDIN_1_0_0 void ERR_remove_state(unsigned long pid);
+#endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 ERR_STATE *ERR_get_state(void);
+#endif
+
+int ERR_get_next_error_library(void);
+
+int ERR_set_mark(void);
+int ERR_pop_to_mark(void);
+int ERR_clear_last_mark(void);
+int ERR_count_to_mark(void);
+int ERR_pop(void);
+
+ERR_STATE *OSSL_ERR_STATE_new(void);
+void OSSL_ERR_STATE_save(ERR_STATE *es);
+void OSSL_ERR_STATE_save_to_mark(ERR_STATE *es);
+void OSSL_ERR_STATE_restore(const ERR_STATE *es);
+void OSSL_ERR_STATE_free(ERR_STATE *es);
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/include/openssl/ess.h b/src/include/openssl/ess.h
new file mode 100644
index 0000000..dad596a
--- /dev/null
+++ b/src/include/openssl/ess.h
@@ -0,0 +1,128 @@
+/*
+ * WARNING: do not edit!
+ * Generated by makefile from include\openssl\ess.h.in
+ *
+ * Copyright 2019-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+
+
+#ifndef OPENSSL_ESS_H
+# define OPENSSL_ESS_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+
+# include <openssl/safestack.h>
+# include <openssl/x509.h>
+# include <openssl/esserr.h>
+
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+
+typedef struct ESS_issuer_serial ESS_ISSUER_SERIAL;
+typedef struct ESS_cert_id ESS_CERT_ID;
+typedef struct ESS_signing_cert ESS_SIGNING_CERT;
+
+SKM_DEFINE_STACK_OF_INTERNAL(ESS_CERT_ID, ESS_CERT_ID, ESS_CERT_ID)
+#define sk_ESS_CERT_ID_num(sk) OPENSSL_sk_num(ossl_check_const_ESS_CERT_ID_sk_type(sk))
+#define sk_ESS_CERT_ID_value(sk, idx) ((ESS_CERT_ID *)OPENSSL_sk_value(ossl_check_const_ESS_CERT_ID_sk_type(sk), (idx)))
+#define sk_ESS_CERT_ID_new(cmp) ((STACK_OF(ESS_CERT_ID) *)OPENSSL_sk_new(ossl_check_ESS_CERT_ID_compfunc_type(cmp)))
+#define sk_ESS_CERT_ID_new_null() ((STACK_OF(ESS_CERT_ID) *)OPENSSL_sk_new_null())
+#define sk_ESS_CERT_ID_new_reserve(cmp, n) ((STACK_OF(ESS_CERT_ID) *)OPENSSL_sk_new_reserve(ossl_check_ESS_CERT_ID_compfunc_type(cmp), (n)))
+#define sk_ESS_CERT_ID_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_ESS_CERT_ID_sk_type(sk), (n))
+#define sk_ESS_CERT_ID_free(sk) OPENSSL_sk_free(ossl_check_ESS_CERT_ID_sk_type(sk))
+#define sk_ESS_CERT_ID_zero(sk) OPENSSL_sk_zero(ossl_check_ESS_CERT_ID_sk_type(sk))
+#define sk_ESS_CERT_ID_delete(sk, i) ((ESS_CERT_ID *)OPENSSL_sk_delete(ossl_check_ESS_CERT_ID_sk_type(sk), (i)))
+#define sk_ESS_CERT_ID_delete_ptr(sk, ptr) ((ESS_CERT_ID *)OPENSSL_sk_delete_ptr(ossl_check_ESS_CERT_ID_sk_type(sk), ossl_check_ESS_CERT_ID_type(ptr)))
+#define sk_ESS_CERT_ID_push(sk, ptr) OPENSSL_sk_push(ossl_check_ESS_CERT_ID_sk_type(sk), ossl_check_ESS_CERT_ID_type(ptr))
+#define sk_ESS_CERT_ID_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_ESS_CERT_ID_sk_type(sk), ossl_check_ESS_CERT_ID_type(ptr))
+#define sk_ESS_CERT_ID_pop(sk) ((ESS_CERT_ID *)OPENSSL_sk_pop(ossl_check_ESS_CERT_ID_sk_type(sk)))
+#define sk_ESS_CERT_ID_shift(sk) ((ESS_CERT_ID *)OPENSSL_sk_shift(ossl_check_ESS_CERT_ID_sk_type(sk)))
+#define sk_ESS_CERT_ID_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ESS_CERT_ID_sk_type(sk),ossl_check_ESS_CERT_ID_freefunc_type(freefunc))
+#define sk_ESS_CERT_ID_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_ESS_CERT_ID_sk_type(sk), ossl_check_ESS_CERT_ID_type(ptr), (idx))
+#define sk_ESS_CERT_ID_set(sk, idx, ptr) ((ESS_CERT_ID *)OPENSSL_sk_set(ossl_check_ESS_CERT_ID_sk_type(sk), (idx), ossl_check_ESS_CERT_ID_type(ptr)))
+#define sk_ESS_CERT_ID_find(sk, ptr) OPENSSL_sk_find(ossl_check_ESS_CERT_ID_sk_type(sk), ossl_check_ESS_CERT_ID_type(ptr))
+#define sk_ESS_CERT_ID_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_ESS_CERT_ID_sk_type(sk), ossl_check_ESS_CERT_ID_type(ptr))
+#define sk_ESS_CERT_ID_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_ESS_CERT_ID_sk_type(sk), ossl_check_ESS_CERT_ID_type(ptr), pnum)
+#define sk_ESS_CERT_ID_sort(sk) OPENSSL_sk_sort(ossl_check_ESS_CERT_ID_sk_type(sk))
+#define sk_ESS_CERT_ID_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_ESS_CERT_ID_sk_type(sk))
+#define sk_ESS_CERT_ID_dup(sk) ((STACK_OF(ESS_CERT_ID) *)OPENSSL_sk_dup(ossl_check_const_ESS_CERT_ID_sk_type(sk)))
+#define sk_ESS_CERT_ID_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ESS_CERT_ID) *)OPENSSL_sk_deep_copy(ossl_check_const_ESS_CERT_ID_sk_type(sk), ossl_check_ESS_CERT_ID_copyfunc_type(copyfunc), ossl_check_ESS_CERT_ID_freefunc_type(freefunc)))
+#define sk_ESS_CERT_ID_set_cmp_func(sk, cmp) ((sk_ESS_CERT_ID_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_ESS_CERT_ID_sk_type(sk), ossl_check_ESS_CERT_ID_compfunc_type(cmp)))
+
+
+
+typedef struct ESS_signing_cert_v2_st ESS_SIGNING_CERT_V2;
+typedef struct ESS_cert_id_v2_st ESS_CERT_ID_V2;
+
+SKM_DEFINE_STACK_OF_INTERNAL(ESS_CERT_ID_V2, ESS_CERT_ID_V2, ESS_CERT_ID_V2)
+#define sk_ESS_CERT_ID_V2_num(sk) OPENSSL_sk_num(ossl_check_const_ESS_CERT_ID_V2_sk_type(sk))
+#define sk_ESS_CERT_ID_V2_value(sk, idx) ((ESS_CERT_ID_V2 *)OPENSSL_sk_value(ossl_check_const_ESS_CERT_ID_V2_sk_type(sk), (idx)))
+#define sk_ESS_CERT_ID_V2_new(cmp) ((STACK_OF(ESS_CERT_ID_V2) *)OPENSSL_sk_new(ossl_check_ESS_CERT_ID_V2_compfunc_type(cmp)))
+#define sk_ESS_CERT_ID_V2_new_null() ((STACK_OF(ESS_CERT_ID_V2) *)OPENSSL_sk_new_null())
+#define sk_ESS_CERT_ID_V2_new_reserve(cmp, n) ((STACK_OF(ESS_CERT_ID_V2) *)OPENSSL_sk_new_reserve(ossl_check_ESS_CERT_ID_V2_compfunc_type(cmp), (n)))
+#define sk_ESS_CERT_ID_V2_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_ESS_CERT_ID_V2_sk_type(sk), (n))
+#define sk_ESS_CERT_ID_V2_free(sk) OPENSSL_sk_free(ossl_check_ESS_CERT_ID_V2_sk_type(sk))
+#define sk_ESS_CERT_ID_V2_zero(sk) OPENSSL_sk_zero(ossl_check_ESS_CERT_ID_V2_sk_type(sk))
+#define sk_ESS_CERT_ID_V2_delete(sk, i) ((ESS_CERT_ID_V2 *)OPENSSL_sk_delete(ossl_check_ESS_CERT_ID_V2_sk_type(sk), (i)))
+#define sk_ESS_CERT_ID_V2_delete_ptr(sk, ptr) ((ESS_CERT_ID_V2 *)OPENSSL_sk_delete_ptr(ossl_check_ESS_CERT_ID_V2_sk_type(sk), ossl_check_ESS_CERT_ID_V2_type(ptr)))
+#define sk_ESS_CERT_ID_V2_push(sk, ptr) OPENSSL_sk_push(ossl_check_ESS_CERT_ID_V2_sk_type(sk), ossl_check_ESS_CERT_ID_V2_type(ptr))
+#define sk_ESS_CERT_ID_V2_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_ESS_CERT_ID_V2_sk_type(sk), ossl_check_ESS_CERT_ID_V2_type(ptr))
+#define sk_ESS_CERT_ID_V2_pop(sk) ((ESS_CERT_ID_V2 *)OPENSSL_sk_pop(ossl_check_ESS_CERT_ID_V2_sk_type(sk)))
+#define sk_ESS_CERT_ID_V2_shift(sk) ((ESS_CERT_ID_V2 *)OPENSSL_sk_shift(ossl_check_ESS_CERT_ID_V2_sk_type(sk)))
+#define sk_ESS_CERT_ID_V2_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ESS_CERT_ID_V2_sk_type(sk),ossl_check_ESS_CERT_ID_V2_freefunc_type(freefunc))
+#define sk_ESS_CERT_ID_V2_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_ESS_CERT_ID_V2_sk_type(sk), ossl_check_ESS_CERT_ID_V2_type(ptr), (idx))
+#define sk_ESS_CERT_ID_V2_set(sk, idx, ptr) ((ESS_CERT_ID_V2 *)OPENSSL_sk_set(ossl_check_ESS_CERT_ID_V2_sk_type(sk), (idx), ossl_check_ESS_CERT_ID_V2_type(ptr)))
+#define sk_ESS_CERT_ID_V2_find(sk, ptr) OPENSSL_sk_find(ossl_check_ESS_CERT_ID_V2_sk_type(sk), ossl_check_ESS_CERT_ID_V2_type(ptr))
+#define sk_ESS_CERT_ID_V2_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_ESS_CERT_ID_V2_sk_type(sk), ossl_check_ESS_CERT_ID_V2_type(ptr))
+#define sk_ESS_CERT_ID_V2_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_ESS_CERT_ID_V2_sk_type(sk), ossl_check_ESS_CERT_ID_V2_type(ptr), pnum)
+#define sk_ESS_CERT_ID_V2_sort(sk) OPENSSL_sk_sort(ossl_check_ESS_CERT_ID_V2_sk_type(sk))
+#define sk_ESS_CERT_ID_V2_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_ESS_CERT_ID_V2_sk_type(sk))
+#define sk_ESS_CERT_ID_V2_dup(sk) ((STACK_OF(ESS_CERT_ID_V2) *)OPENSSL_sk_dup(ossl_check_const_ESS_CERT_ID_V2_sk_type(sk)))
+#define sk_ESS_CERT_ID_V2_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ESS_CERT_ID_V2) *)OPENSSL_sk_deep_copy(ossl_check_const_ESS_CERT_ID_V2_sk_type(sk), ossl_check_ESS_CERT_ID_V2_copyfunc_type(copyfunc), ossl_check_ESS_CERT_ID_V2_freefunc_type(freefunc)))
+#define sk_ESS_CERT_ID_V2_set_cmp_func(sk, cmp) ((sk_ESS_CERT_ID_V2_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_ESS_CERT_ID_V2_sk_type(sk), ossl_check_ESS_CERT_ID_V2_compfunc_type(cmp)))
+
+
+DECLARE_ASN1_ALLOC_FUNCTIONS(ESS_ISSUER_SERIAL)
+DECLARE_ASN1_ENCODE_FUNCTIONS_only(ESS_ISSUER_SERIAL, ESS_ISSUER_SERIAL)
+DECLARE_ASN1_DUP_FUNCTION(ESS_ISSUER_SERIAL)
+
+DECLARE_ASN1_ALLOC_FUNCTIONS(ESS_CERT_ID)
+DECLARE_ASN1_ENCODE_FUNCTIONS_only(ESS_CERT_ID, ESS_CERT_ID)
+DECLARE_ASN1_DUP_FUNCTION(ESS_CERT_ID)
+
+DECLARE_ASN1_FUNCTIONS(ESS_SIGNING_CERT)
+DECLARE_ASN1_DUP_FUNCTION(ESS_SIGNING_CERT)
+
+DECLARE_ASN1_ALLOC_FUNCTIONS(ESS_CERT_ID_V2)
+DECLARE_ASN1_ENCODE_FUNCTIONS_only(ESS_CERT_ID_V2, ESS_CERT_ID_V2)
+DECLARE_ASN1_DUP_FUNCTION(ESS_CERT_ID_V2)
+
+DECLARE_ASN1_FUNCTIONS(ESS_SIGNING_CERT_V2)
+DECLARE_ASN1_DUP_FUNCTION(ESS_SIGNING_CERT_V2)
+
+ESS_SIGNING_CERT *OSSL_ESS_signing_cert_new_init(const X509 *signcert,
+                                                 const STACK_OF(X509) *certs,
+                                                 int set_issuer_serial);
+ESS_SIGNING_CERT_V2 *OSSL_ESS_signing_cert_v2_new_init(const EVP_MD *hash_alg,
+                                                       const X509 *signcert,
+                                                       const
+                                                       STACK_OF(X509) *certs,
+                                                       int set_issuer_serial);
+int OSSL_ESS_check_signing_certs(const ESS_SIGNING_CERT *ss,
+                                 const ESS_SIGNING_CERT_V2 *ssv2,
+                                 const STACK_OF(X509) *chain,
+                                 int require_signing_cert);
+
+# ifdef  __cplusplus
+}
+# endif
+#endif
diff --git a/src/include/openssl/esserr.h b/src/include/openssl/esserr.h
new file mode 100644
index 0000000..165ce7c
--- /dev/null
+++ b/src/include/openssl/esserr.h
@@ -0,0 +1,32 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_ESSERR_H
+# define OPENSSL_ESSERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+/*
+ * ESS reason codes.
+ */
+# define ESS_R_EMPTY_ESS_CERT_ID_LIST                     107
+# define ESS_R_ESS_CERT_DIGEST_ERROR                      103
+# define ESS_R_ESS_CERT_ID_NOT_FOUND                      104
+# define ESS_R_ESS_CERT_ID_WRONG_ORDER                    105
+# define ESS_R_ESS_DIGEST_ALG_UNKNOWN                     106
+# define ESS_R_ESS_SIGNING_CERTIFICATE_ERROR              102
+# define ESS_R_ESS_SIGNING_CERT_ADD_ERROR                 100
+# define ESS_R_ESS_SIGNING_CERT_V2_ADD_ERROR              101
+# define ESS_R_MISSING_SIGNING_CERTIFICATE_ATTRIBUTE      108
+
+#endif
diff --git a/src/include/openssl/evp.h b/src/include/openssl/evp.h
new file mode 100644
index 0000000..f70b9d7
--- /dev/null
+++ b/src/include/openssl/evp.h
@@ -0,0 +1,2183 @@
+/*
+ * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_EVP_H
+# define OPENSSL_EVP_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_ENVELOPE_H
+# endif
+
+# include <stdarg.h>
+
+# ifndef OPENSSL_NO_STDIO
+#  include <stdio.h>
+# endif
+
+# include <openssl/opensslconf.h>
+# include <openssl/types.h>
+# include <openssl/core.h>
+# include <openssl/core_dispatch.h>
+# include <openssl/symhacks.h>
+# include <openssl/bio.h>
+# include <openssl/evperr.h>
+# include <openssl/params.h>
+
+# define EVP_MAX_MD_SIZE                 64/* longest known is SHA512 */
+# define EVP_MAX_KEY_LENGTH              64
+# define EVP_MAX_IV_LENGTH               16
+# define EVP_MAX_BLOCK_LENGTH            32
+# define EVP_MAX_AEAD_TAG_LENGTH         16
+
+# define PKCS5_SALT_LEN                  8
+/* Default PKCS#5 iteration count */
+# define PKCS5_DEFAULT_ITER              2048
+
+# include <openssl/objects.h>
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define EVP_PK_RSA      0x0001
+#  define EVP_PK_DSA      0x0002
+#  define EVP_PK_DH       0x0004
+#  define EVP_PK_EC       0x0008
+#  define EVP_PKT_SIGN    0x0010
+#  define EVP_PKT_ENC     0x0020
+#  define EVP_PKT_EXCH    0x0040
+#  define EVP_PKS_RSA     0x0100
+#  define EVP_PKS_DSA     0x0200
+#  define EVP_PKS_EC      0x0400
+# endif
+
+# define EVP_PKEY_NONE   NID_undef
+# define EVP_PKEY_RSA    NID_rsaEncryption
+# define EVP_PKEY_RSA2   NID_rsa
+# define EVP_PKEY_RSA_PSS NID_rsassaPss
+# define EVP_PKEY_DSA    NID_dsa
+# define EVP_PKEY_DSA1   NID_dsa_2
+# define EVP_PKEY_DSA2   NID_dsaWithSHA
+# define EVP_PKEY_DSA3   NID_dsaWithSHA1
+# define EVP_PKEY_DSA4   NID_dsaWithSHA1_2
+# define EVP_PKEY_DH     NID_dhKeyAgreement
+# define EVP_PKEY_DHX    NID_dhpublicnumber
+# define EVP_PKEY_EC     NID_X9_62_id_ecPublicKey
+# define EVP_PKEY_SM2    NID_sm2
+# define EVP_PKEY_HMAC   NID_hmac
+# define EVP_PKEY_CMAC   NID_cmac
+# define EVP_PKEY_SCRYPT NID_id_scrypt
+# define EVP_PKEY_TLS1_PRF NID_tls1_prf
+# define EVP_PKEY_HKDF   NID_hkdf
+# define EVP_PKEY_POLY1305 NID_poly1305
+# define EVP_PKEY_SIPHASH NID_siphash
+# define EVP_PKEY_X25519 NID_X25519
+# define EVP_PKEY_ED25519 NID_ED25519
+# define EVP_PKEY_X448 NID_X448
+# define EVP_PKEY_ED448 NID_ED448
+/* Special indicator that the object is uniquely provider side */
+# define EVP_PKEY_KEYMGMT -1
+
+/* Easy to use macros for EVP_PKEY related selections */
+# define EVP_PKEY_KEY_PARAMETERS                                            \
+    ( OSSL_KEYMGMT_SELECT_ALL_PARAMETERS )
+# define EVP_PKEY_PRIVATE_KEY                                               \
+    ( EVP_PKEY_KEY_PARAMETERS | OSSL_KEYMGMT_SELECT_PRIVATE_KEY )
+# define EVP_PKEY_PUBLIC_KEY                                                \
+    ( EVP_PKEY_KEY_PARAMETERS | OSSL_KEYMGMT_SELECT_PUBLIC_KEY )
+# define EVP_PKEY_KEYPAIR                                                   \
+    ( EVP_PKEY_PUBLIC_KEY | OSSL_KEYMGMT_SELECT_PRIVATE_KEY )
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+int EVP_set_default_properties(OSSL_LIB_CTX *libctx, const char *propq);
+int EVP_default_properties_is_fips_enabled(OSSL_LIB_CTX *libctx);
+int EVP_default_properties_enable_fips(OSSL_LIB_CTX *libctx, int enable);
+
+# define EVP_PKEY_MO_SIGN        0x0001
+# define EVP_PKEY_MO_VERIFY      0x0002
+# define EVP_PKEY_MO_ENCRYPT     0x0004
+# define EVP_PKEY_MO_DECRYPT     0x0008
+
+# ifndef EVP_MD
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 EVP_MD *EVP_MD_meth_new(int md_type, int pkey_type);
+OSSL_DEPRECATEDIN_3_0 EVP_MD *EVP_MD_meth_dup(const EVP_MD *md);
+OSSL_DEPRECATEDIN_3_0 void EVP_MD_meth_free(EVP_MD *md);
+OSSL_DEPRECATEDIN_3_0
+int EVP_MD_meth_set_input_blocksize(EVP_MD *md, int blocksize);
+OSSL_DEPRECATEDIN_3_0
+int EVP_MD_meth_set_result_size(EVP_MD *md, int resultsize);
+OSSL_DEPRECATEDIN_3_0
+int EVP_MD_meth_set_app_datasize(EVP_MD *md, int datasize);
+OSSL_DEPRECATEDIN_3_0
+int EVP_MD_meth_set_flags(EVP_MD *md, unsigned long flags);
+OSSL_DEPRECATEDIN_3_0
+int EVP_MD_meth_set_init(EVP_MD *md, int (*init)(EVP_MD_CTX *ctx));
+OSSL_DEPRECATEDIN_3_0
+int EVP_MD_meth_set_update(EVP_MD *md, int (*update)(EVP_MD_CTX *ctx,
+                                                     const void *data,
+                                                     size_t count));
+OSSL_DEPRECATEDIN_3_0
+int EVP_MD_meth_set_final(EVP_MD *md, int (*final)(EVP_MD_CTX *ctx,
+                                                   unsigned char *md));
+OSSL_DEPRECATEDIN_3_0
+int EVP_MD_meth_set_copy(EVP_MD *md, int (*copy)(EVP_MD_CTX *to,
+                                                 const EVP_MD_CTX *from));
+OSSL_DEPRECATEDIN_3_0
+int EVP_MD_meth_set_cleanup(EVP_MD *md, int (*cleanup)(EVP_MD_CTX *ctx));
+OSSL_DEPRECATEDIN_3_0
+int EVP_MD_meth_set_ctrl(EVP_MD *md, int (*ctrl)(EVP_MD_CTX *ctx, int cmd,
+                                                 int p1, void *p2));
+OSSL_DEPRECATEDIN_3_0 int EVP_MD_meth_get_input_blocksize(const EVP_MD *md);
+OSSL_DEPRECATEDIN_3_0 int EVP_MD_meth_get_result_size(const EVP_MD *md);
+OSSL_DEPRECATEDIN_3_0 int EVP_MD_meth_get_app_datasize(const EVP_MD *md);
+OSSL_DEPRECATEDIN_3_0 unsigned long EVP_MD_meth_get_flags(const EVP_MD *md);
+OSSL_DEPRECATEDIN_3_0
+int (*EVP_MD_meth_get_init(const EVP_MD *md))(EVP_MD_CTX *ctx);
+OSSL_DEPRECATEDIN_3_0
+int (*EVP_MD_meth_get_update(const EVP_MD *md))(EVP_MD_CTX *ctx,
+                                                const void *data, size_t count);
+OSSL_DEPRECATEDIN_3_0
+int (*EVP_MD_meth_get_final(const EVP_MD *md))(EVP_MD_CTX *ctx,
+                                               unsigned char *md);
+OSSL_DEPRECATEDIN_3_0
+int (*EVP_MD_meth_get_copy(const EVP_MD *md))(EVP_MD_CTX *to,
+                                              const EVP_MD_CTX *from);
+OSSL_DEPRECATEDIN_3_0
+int (*EVP_MD_meth_get_cleanup(const EVP_MD *md))(EVP_MD_CTX *ctx);
+OSSL_DEPRECATEDIN_3_0
+int (*EVP_MD_meth_get_ctrl(const EVP_MD *md))(EVP_MD_CTX *ctx, int cmd,
+                                              int p1, void *p2);
+#  endif
+/* digest can only handle a single block */
+#  define EVP_MD_FLAG_ONESHOT     0x0001
+
+/* digest is extensible-output function, XOF */
+#  define EVP_MD_FLAG_XOF         0x0002
+
+/* DigestAlgorithmIdentifier flags... */
+
+#  define EVP_MD_FLAG_DIGALGID_MASK               0x0018
+
+/* NULL or absent parameter accepted. Use NULL */
+
+#  define EVP_MD_FLAG_DIGALGID_NULL               0x0000
+
+/* NULL or absent parameter accepted. Use NULL for PKCS#1 otherwise absent */
+
+#  define EVP_MD_FLAG_DIGALGID_ABSENT             0x0008
+
+/* Custom handling via ctrl */
+
+#  define EVP_MD_FLAG_DIGALGID_CUSTOM             0x0018
+
+/* Note if suitable for use in FIPS mode */
+#  define EVP_MD_FLAG_FIPS        0x0400
+
+/* Digest ctrls */
+
+#  define EVP_MD_CTRL_DIGALGID                    0x1
+#  define EVP_MD_CTRL_MICALG                      0x2
+#  define EVP_MD_CTRL_XOF_LEN                     0x3
+#  define EVP_MD_CTRL_TLSTREE                     0x4
+
+/* Minimum Algorithm specific ctrl value */
+
+#  define EVP_MD_CTRL_ALG_CTRL                    0x1000
+
+# endif                         /* !EVP_MD */
+
+/* values for EVP_MD_CTX flags */
+
+# define EVP_MD_CTX_FLAG_ONESHOT         0x0001/* digest update will be
+                                                * called once only */
+# define EVP_MD_CTX_FLAG_CLEANED         0x0002/* context has already been
+                                                * cleaned */
+# define EVP_MD_CTX_FLAG_REUSE           0x0004/* Don't free up ctx->md_data
+                                                * in EVP_MD_CTX_reset */
+/*
+ * FIPS and pad options are ignored in 1.0.0, definitions are here so we
+ * don't accidentally reuse the values for other purposes.
+ */
+
+/* This flag has no effect from openssl-3.0 onwards */
+# define EVP_MD_CTX_FLAG_NON_FIPS_ALLOW  0x0008
+
+/*
+ * The following PAD options are also currently ignored in 1.0.0, digest
+ * parameters are handled through EVP_DigestSign*() and EVP_DigestVerify*()
+ * instead.
+ */
+# define EVP_MD_CTX_FLAG_PAD_MASK        0xF0/* RSA mode to use */
+# define EVP_MD_CTX_FLAG_PAD_PKCS1       0x00/* PKCS#1 v1.5 mode */
+# define EVP_MD_CTX_FLAG_PAD_X931        0x10/* X9.31 mode */
+# define EVP_MD_CTX_FLAG_PAD_PSS         0x20/* PSS mode */
+
+# define EVP_MD_CTX_FLAG_NO_INIT         0x0100/* Don't initialize md_data */
+/*
+ * Some functions such as EVP_DigestSign only finalise copies of internal
+ * contexts so additional data can be included after the finalisation call.
+ * This is inefficient if this functionality is not required: it is disabled
+ * if the following flag is set.
+ */
+# define EVP_MD_CTX_FLAG_FINALISE        0x0200
+/* NOTE: 0x0400 and 0x0800 are reserved for internal usage */
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+EVP_CIPHER *EVP_CIPHER_meth_new(int cipher_type, int block_size, int key_len);
+OSSL_DEPRECATEDIN_3_0
+EVP_CIPHER *EVP_CIPHER_meth_dup(const EVP_CIPHER *cipher);
+OSSL_DEPRECATEDIN_3_0
+void EVP_CIPHER_meth_free(EVP_CIPHER *cipher);
+OSSL_DEPRECATEDIN_3_0
+int EVP_CIPHER_meth_set_iv_length(EVP_CIPHER *cipher, int iv_len);
+OSSL_DEPRECATEDIN_3_0
+int EVP_CIPHER_meth_set_flags(EVP_CIPHER *cipher, unsigned long flags);
+OSSL_DEPRECATEDIN_3_0
+int EVP_CIPHER_meth_set_impl_ctx_size(EVP_CIPHER *cipher, int ctx_size);
+OSSL_DEPRECATEDIN_3_0
+int EVP_CIPHER_meth_set_init(EVP_CIPHER *cipher,
+                             int (*init) (EVP_CIPHER_CTX *ctx,
+                                          const unsigned char *key,
+                                          const unsigned char *iv,
+                                          int enc));
+OSSL_DEPRECATEDIN_3_0
+int EVP_CIPHER_meth_set_do_cipher(EVP_CIPHER *cipher,
+                                  int (*do_cipher) (EVP_CIPHER_CTX *ctx,
+                                                    unsigned char *out,
+                                                    const unsigned char *in,
+                                                    size_t inl));
+OSSL_DEPRECATEDIN_3_0
+int EVP_CIPHER_meth_set_cleanup(EVP_CIPHER *cipher,
+                                int (*cleanup) (EVP_CIPHER_CTX *));
+OSSL_DEPRECATEDIN_3_0
+int EVP_CIPHER_meth_set_set_asn1_params(EVP_CIPHER *cipher,
+                                        int (*set_asn1_parameters) (EVP_CIPHER_CTX *,
+                                                                    ASN1_TYPE *));
+OSSL_DEPRECATEDIN_3_0
+int EVP_CIPHER_meth_set_get_asn1_params(EVP_CIPHER *cipher,
+                                        int (*get_asn1_parameters) (EVP_CIPHER_CTX *,
+                                                                    ASN1_TYPE *));
+OSSL_DEPRECATEDIN_3_0
+int EVP_CIPHER_meth_set_ctrl(EVP_CIPHER *cipher,
+                             int (*ctrl) (EVP_CIPHER_CTX *, int type,
+                                          int arg, void *ptr));
+OSSL_DEPRECATEDIN_3_0 int
+(*EVP_CIPHER_meth_get_init(const EVP_CIPHER *cipher))(EVP_CIPHER_CTX *ctx,
+                                                      const unsigned char *key,
+                                                      const unsigned char *iv,
+                                                      int enc);
+OSSL_DEPRECATEDIN_3_0 int
+(*EVP_CIPHER_meth_get_do_cipher(const EVP_CIPHER *cipher))(EVP_CIPHER_CTX *ctx,
+                                                           unsigned char *out,
+                                                           const unsigned char *in,
+                                                           size_t inl);
+OSSL_DEPRECATEDIN_3_0 int
+(*EVP_CIPHER_meth_get_cleanup(const EVP_CIPHER *cipher))(EVP_CIPHER_CTX *);
+OSSL_DEPRECATEDIN_3_0 int
+(*EVP_CIPHER_meth_get_set_asn1_params(const EVP_CIPHER *cipher))(EVP_CIPHER_CTX *,
+                                                                 ASN1_TYPE *);
+OSSL_DEPRECATEDIN_3_0 int
+(*EVP_CIPHER_meth_get_get_asn1_params(const EVP_CIPHER *cipher))(EVP_CIPHER_CTX *,
+                                                                 ASN1_TYPE *);
+OSSL_DEPRECATEDIN_3_0 int
+(*EVP_CIPHER_meth_get_ctrl(const EVP_CIPHER *cipher))(EVP_CIPHER_CTX *, int type,
+                                                      int arg, void *ptr);
+# endif
+
+/* Values for cipher flags */
+
+/* Modes for ciphers */
+
+# define         EVP_CIPH_STREAM_CIPHER          0x0
+# define         EVP_CIPH_ECB_MODE               0x1
+# define         EVP_CIPH_CBC_MODE               0x2
+# define         EVP_CIPH_CFB_MODE               0x3
+# define         EVP_CIPH_OFB_MODE               0x4
+# define         EVP_CIPH_CTR_MODE               0x5
+# define         EVP_CIPH_GCM_MODE               0x6
+# define         EVP_CIPH_CCM_MODE               0x7
+# define         EVP_CIPH_XTS_MODE               0x10001
+# define         EVP_CIPH_WRAP_MODE              0x10002
+# define         EVP_CIPH_OCB_MODE               0x10003
+# define         EVP_CIPH_SIV_MODE               0x10004
+# define         EVP_CIPH_GCM_SIV_MODE           0x10005
+# define         EVP_CIPH_MODE                   0xF0007
+/* Set if variable length cipher */
+# define         EVP_CIPH_VARIABLE_LENGTH        0x8
+/* Set if the iv handling should be done by the cipher itself */
+# define         EVP_CIPH_CUSTOM_IV              0x10
+/* Set if the cipher's init() function should be called if key is NULL */
+# define         EVP_CIPH_ALWAYS_CALL_INIT       0x20
+/* Call ctrl() to init cipher parameters */
+# define         EVP_CIPH_CTRL_INIT              0x40
+/* Don't use standard key length function */
+# define         EVP_CIPH_CUSTOM_KEY_LENGTH      0x80
+/* Don't use standard block padding */
+# define         EVP_CIPH_NO_PADDING             0x100
+/* cipher handles random key generation */
+# define         EVP_CIPH_RAND_KEY               0x200
+/* cipher has its own additional copying logic */
+# define         EVP_CIPH_CUSTOM_COPY            0x400
+/* Don't use standard iv length function */
+# define         EVP_CIPH_CUSTOM_IV_LENGTH       0x800
+/* Legacy and no longer relevant: Allow use default ASN1 get/set iv */
+# define         EVP_CIPH_FLAG_DEFAULT_ASN1      0
+/* Free:                                         0x1000 */
+/* Buffer length in bits not bytes: CFB1 mode only */
+# define         EVP_CIPH_FLAG_LENGTH_BITS       0x2000
+/* Deprecated FIPS flag: was 0x4000 */
+# define         EVP_CIPH_FLAG_FIPS              0
+/* Deprecated FIPS flag: was 0x8000 */
+# define         EVP_CIPH_FLAG_NON_FIPS_ALLOW    0
+
+/*
+ * Cipher handles any and all padding logic as well as finalisation.
+ */
+# define         EVP_CIPH_FLAG_CTS               0x4000
+# define         EVP_CIPH_FLAG_CUSTOM_CIPHER     0x100000
+# define         EVP_CIPH_FLAG_AEAD_CIPHER       0x200000
+# define         EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK 0x400000
+/* Cipher can handle pipeline operations */
+# define         EVP_CIPH_FLAG_PIPELINE          0X800000
+/* For provider implementations that handle  ASN1 get/set param themselves */
+# define         EVP_CIPH_FLAG_CUSTOM_ASN1       0x1000000
+/* For ciphers generating unprotected CMS attributes */
+# define         EVP_CIPH_FLAG_CIPHER_WITH_MAC   0x2000000
+/* For supplementary wrap cipher support */
+# define         EVP_CIPH_FLAG_GET_WRAP_CIPHER   0x4000000
+# define         EVP_CIPH_FLAG_INVERSE_CIPHER    0x8000000
+
+/*
+ * Cipher context flag to indicate we can handle wrap mode: if allowed in
+ * older applications it could overflow buffers.
+ */
+
+# define         EVP_CIPHER_CTX_FLAG_WRAP_ALLOW  0x1
+
+/* ctrl() values */
+
+# define         EVP_CTRL_INIT                   0x0
+# define         EVP_CTRL_SET_KEY_LENGTH         0x1
+# define         EVP_CTRL_GET_RC2_KEY_BITS       0x2
+# define         EVP_CTRL_SET_RC2_KEY_BITS       0x3
+# define         EVP_CTRL_GET_RC5_ROUNDS         0x4
+# define         EVP_CTRL_SET_RC5_ROUNDS         0x5
+# define         EVP_CTRL_RAND_KEY               0x6
+# define         EVP_CTRL_PBE_PRF_NID            0x7
+# define         EVP_CTRL_COPY                   0x8
+# define         EVP_CTRL_AEAD_SET_IVLEN         0x9
+# define         EVP_CTRL_AEAD_GET_TAG           0x10
+# define         EVP_CTRL_AEAD_SET_TAG           0x11
+# define         EVP_CTRL_AEAD_SET_IV_FIXED      0x12
+# define         EVP_CTRL_GCM_SET_IVLEN          EVP_CTRL_AEAD_SET_IVLEN
+# define         EVP_CTRL_GCM_GET_TAG            EVP_CTRL_AEAD_GET_TAG
+# define         EVP_CTRL_GCM_SET_TAG            EVP_CTRL_AEAD_SET_TAG
+# define         EVP_CTRL_GCM_SET_IV_FIXED       EVP_CTRL_AEAD_SET_IV_FIXED
+# define         EVP_CTRL_GCM_IV_GEN             0x13
+# define         EVP_CTRL_CCM_SET_IVLEN          EVP_CTRL_AEAD_SET_IVLEN
+# define         EVP_CTRL_CCM_GET_TAG            EVP_CTRL_AEAD_GET_TAG
+# define         EVP_CTRL_CCM_SET_TAG            EVP_CTRL_AEAD_SET_TAG
+# define         EVP_CTRL_CCM_SET_IV_FIXED       EVP_CTRL_AEAD_SET_IV_FIXED
+# define         EVP_CTRL_CCM_SET_L              0x14
+# define         EVP_CTRL_CCM_SET_MSGLEN         0x15
+/*
+ * AEAD cipher deduces payload length and returns number of bytes required to
+ * store MAC and eventual padding. Subsequent call to EVP_Cipher even
+ * appends/verifies MAC.
+ */
+# define         EVP_CTRL_AEAD_TLS1_AAD          0x16
+/* Used by composite AEAD ciphers, no-op in GCM, CCM... */
+# define         EVP_CTRL_AEAD_SET_MAC_KEY       0x17
+/* Set the GCM invocation field, decrypt only */
+# define         EVP_CTRL_GCM_SET_IV_INV         0x18
+
+# define         EVP_CTRL_TLS1_1_MULTIBLOCK_AAD  0x19
+# define         EVP_CTRL_TLS1_1_MULTIBLOCK_ENCRYPT      0x1a
+# define         EVP_CTRL_TLS1_1_MULTIBLOCK_DECRYPT      0x1b
+# define         EVP_CTRL_TLS1_1_MULTIBLOCK_MAX_BUFSIZE  0x1c
+
+# define         EVP_CTRL_SSL3_MASTER_SECRET             0x1d
+
+/* EVP_CTRL_SET_SBOX takes the char * specifying S-boxes */
+# define         EVP_CTRL_SET_SBOX                       0x1e
+/*
+ * EVP_CTRL_SBOX_USED takes a 'size_t' and 'char *', pointing at a
+ * pre-allocated buffer with specified size
+ */
+# define         EVP_CTRL_SBOX_USED                      0x1f
+/* EVP_CTRL_KEY_MESH takes 'size_t' number of bytes to mesh the key after,
+ * 0 switches meshing off
+ */
+# define         EVP_CTRL_KEY_MESH                       0x20
+/* EVP_CTRL_BLOCK_PADDING_MODE takes the padding mode */
+# define         EVP_CTRL_BLOCK_PADDING_MODE             0x21
+
+/* Set the output buffers to use for a pipelined operation */
+# define         EVP_CTRL_SET_PIPELINE_OUTPUT_BUFS       0x22
+/* Set the input buffers to use for a pipelined operation */
+# define         EVP_CTRL_SET_PIPELINE_INPUT_BUFS        0x23
+/* Set the input buffer lengths to use for a pipelined operation */
+# define         EVP_CTRL_SET_PIPELINE_INPUT_LENS        0x24
+/* Get the IV length used by the cipher */
+# define         EVP_CTRL_GET_IVLEN                      0x25
+/* 0x26 is unused */
+/* Tell the cipher it's doing a speed test (SIV disallows multiple ops) */
+# define         EVP_CTRL_SET_SPEED                      0x27
+/* Get the unprotectedAttrs from cipher ctx */
+# define         EVP_CTRL_PROCESS_UNPROTECTED            0x28
+/* Get the supplementary wrap cipher */
+#define          EVP_CTRL_GET_WRAP_CIPHER                0x29
+/* TLSTREE key diversification */
+#define          EVP_CTRL_TLSTREE                        0x2A
+
+/* Padding modes */
+#define EVP_PADDING_PKCS7       1
+#define EVP_PADDING_ISO7816_4   2
+#define EVP_PADDING_ANSI923     3
+#define EVP_PADDING_ISO10126    4
+#define EVP_PADDING_ZERO        5
+
+/* RFC 5246 defines additional data to be 13 bytes in length */
+# define         EVP_AEAD_TLS1_AAD_LEN           13
+
+typedef struct {
+    unsigned char *out;
+    const unsigned char *inp;
+    size_t len;
+    unsigned int interleave;
+} EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM;
+
+/* GCM TLS constants */
+/* Length of fixed part of IV derived from PRF */
+# define EVP_GCM_TLS_FIXED_IV_LEN                        4
+/* Length of explicit part of IV part of TLS records */
+# define EVP_GCM_TLS_EXPLICIT_IV_LEN                     8
+/* Length of tag for TLS */
+# define EVP_GCM_TLS_TAG_LEN                             16
+
+/* CCM TLS constants */
+/* Length of fixed part of IV derived from PRF */
+# define EVP_CCM_TLS_FIXED_IV_LEN                        4
+/* Length of explicit part of IV part of TLS records */
+# define EVP_CCM_TLS_EXPLICIT_IV_LEN                     8
+/* Total length of CCM IV length for TLS */
+# define EVP_CCM_TLS_IV_LEN                              12
+/* Length of tag for TLS */
+# define EVP_CCM_TLS_TAG_LEN                             16
+/* Length of CCM8 tag for TLS */
+# define EVP_CCM8_TLS_TAG_LEN                            8
+
+/* Length of tag for TLS */
+# define EVP_CHACHAPOLY_TLS_TAG_LEN                      16
+
+typedef struct evp_cipher_info_st {
+    const EVP_CIPHER *cipher;
+    unsigned char iv[EVP_MAX_IV_LENGTH];
+} EVP_CIPHER_INFO;
+
+
+/* Password based encryption function */
+typedef int (EVP_PBE_KEYGEN) (EVP_CIPHER_CTX *ctx, const char *pass,
+                              int passlen, ASN1_TYPE *param,
+                              const EVP_CIPHER *cipher, const EVP_MD *md,
+                              int en_de);
+
+typedef int (EVP_PBE_KEYGEN_EX) (EVP_CIPHER_CTX *ctx, const char *pass,
+                                 int passlen, ASN1_TYPE *param,
+                                 const EVP_CIPHER *cipher, const EVP_MD *md,
+                                 int en_de, OSSL_LIB_CTX *libctx, const char *propq);
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define EVP_PKEY_assign_RSA(pkey,rsa) EVP_PKEY_assign((pkey),EVP_PKEY_RSA,\
+                                                         (rsa))
+# endif
+
+# ifndef OPENSSL_NO_DSA
+#  define EVP_PKEY_assign_DSA(pkey,dsa) EVP_PKEY_assign((pkey),EVP_PKEY_DSA,\
+                                        (dsa))
+# endif
+
+# if !defined(OPENSSL_NO_DH) && !defined(OPENSSL_NO_DEPRECATED_3_0)
+#  define EVP_PKEY_assign_DH(pkey,dh) EVP_PKEY_assign((pkey),EVP_PKEY_DH,(dh))
+# endif
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  ifndef OPENSSL_NO_EC
+#   define EVP_PKEY_assign_EC_KEY(pkey,eckey) \
+        EVP_PKEY_assign((pkey), EVP_PKEY_EC, (eckey))
+#  endif
+# endif
+# ifndef OPENSSL_NO_SIPHASH
+#  define EVP_PKEY_assign_SIPHASH(pkey,shkey) EVP_PKEY_assign((pkey),\
+                                        EVP_PKEY_SIPHASH,(shkey))
+# endif
+
+# ifndef OPENSSL_NO_POLY1305
+#  define EVP_PKEY_assign_POLY1305(pkey,polykey) EVP_PKEY_assign((pkey),\
+                                        EVP_PKEY_POLY1305,(polykey))
+# endif
+
+/* Add some extra combinations */
+# define EVP_get_digestbynid(a) EVP_get_digestbyname(OBJ_nid2sn(a))
+# define EVP_get_digestbyobj(a) EVP_get_digestbynid(OBJ_obj2nid(a))
+# define EVP_get_cipherbynid(a) EVP_get_cipherbyname(OBJ_nid2sn(a))
+# define EVP_get_cipherbyobj(a) EVP_get_cipherbynid(OBJ_obj2nid(a))
+
+int EVP_MD_get_type(const EVP_MD *md);
+# define EVP_MD_type EVP_MD_get_type
+# define EVP_MD_nid EVP_MD_get_type
+const char *EVP_MD_get0_name(const EVP_MD *md);
+# define EVP_MD_name EVP_MD_get0_name
+const char *EVP_MD_get0_description(const EVP_MD *md);
+int EVP_MD_is_a(const EVP_MD *md, const char *name);
+int EVP_MD_names_do_all(const EVP_MD *md,
+                        void (*fn)(const char *name, void *data),
+                        void *data);
+const OSSL_PROVIDER *EVP_MD_get0_provider(const EVP_MD *md);
+int EVP_MD_get_pkey_type(const EVP_MD *md);
+# define EVP_MD_pkey_type EVP_MD_get_pkey_type
+int EVP_MD_get_size(const EVP_MD *md);
+# define EVP_MD_size EVP_MD_get_size
+int EVP_MD_get_block_size(const EVP_MD *md);
+# define EVP_MD_block_size EVP_MD_get_block_size
+unsigned long EVP_MD_get_flags(const EVP_MD *md);
+# define EVP_MD_flags EVP_MD_get_flags
+
+const EVP_MD *EVP_MD_CTX_get0_md(const EVP_MD_CTX *ctx);
+EVP_MD *EVP_MD_CTX_get1_md(EVP_MD_CTX *ctx);
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+const EVP_MD *EVP_MD_CTX_md(const EVP_MD_CTX *ctx);
+OSSL_DEPRECATEDIN_3_0
+int (*EVP_MD_CTX_update_fn(EVP_MD_CTX *ctx))(EVP_MD_CTX *ctx,
+                                             const void *data, size_t count);
+OSSL_DEPRECATEDIN_3_0
+void EVP_MD_CTX_set_update_fn(EVP_MD_CTX *ctx,
+                              int (*update) (EVP_MD_CTX *ctx,
+                                             const void *data, size_t count));
+# endif
+# define EVP_MD_CTX_get0_name(e)       EVP_MD_get0_name(EVP_MD_CTX_get0_md(e))
+# define EVP_MD_CTX_get_size(e)        EVP_MD_get_size(EVP_MD_CTX_get0_md(e))
+# define EVP_MD_CTX_size               EVP_MD_CTX_get_size
+# define EVP_MD_CTX_get_block_size(e)  EVP_MD_get_block_size(EVP_MD_CTX_get0_md(e))
+# define EVP_MD_CTX_block_size EVP_MD_CTX_get_block_size
+# define EVP_MD_CTX_get_type(e)            EVP_MD_get_type(EVP_MD_CTX_get0_md(e))
+# define EVP_MD_CTX_type EVP_MD_CTX_get_type
+EVP_PKEY_CTX *EVP_MD_CTX_get_pkey_ctx(const EVP_MD_CTX *ctx);
+# define EVP_MD_CTX_pkey_ctx EVP_MD_CTX_get_pkey_ctx
+void EVP_MD_CTX_set_pkey_ctx(EVP_MD_CTX *ctx, EVP_PKEY_CTX *pctx);
+void *EVP_MD_CTX_get0_md_data(const EVP_MD_CTX *ctx);
+# define EVP_MD_CTX_md_data EVP_MD_CTX_get0_md_data
+
+int EVP_CIPHER_get_nid(const EVP_CIPHER *cipher);
+# define EVP_CIPHER_nid EVP_CIPHER_get_nid
+const char *EVP_CIPHER_get0_name(const EVP_CIPHER *cipher);
+# define EVP_CIPHER_name EVP_CIPHER_get0_name
+const char *EVP_CIPHER_get0_description(const EVP_CIPHER *cipher);
+int EVP_CIPHER_is_a(const EVP_CIPHER *cipher, const char *name);
+int EVP_CIPHER_names_do_all(const EVP_CIPHER *cipher,
+                            void (*fn)(const char *name, void *data),
+                            void *data);
+const OSSL_PROVIDER *EVP_CIPHER_get0_provider(const EVP_CIPHER *cipher);
+int EVP_CIPHER_get_block_size(const EVP_CIPHER *cipher);
+# define EVP_CIPHER_block_size EVP_CIPHER_get_block_size
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+int EVP_CIPHER_impl_ctx_size(const EVP_CIPHER *cipher);
+# endif
+int EVP_CIPHER_get_key_length(const EVP_CIPHER *cipher);
+# define EVP_CIPHER_key_length EVP_CIPHER_get_key_length
+int EVP_CIPHER_get_iv_length(const EVP_CIPHER *cipher);
+# define EVP_CIPHER_iv_length EVP_CIPHER_get_iv_length
+unsigned long EVP_CIPHER_get_flags(const EVP_CIPHER *cipher);
+# define EVP_CIPHER_flags EVP_CIPHER_get_flags
+int EVP_CIPHER_get_mode(const EVP_CIPHER *cipher);
+# define EVP_CIPHER_mode EVP_CIPHER_get_mode
+int EVP_CIPHER_get_type(const EVP_CIPHER *cipher);
+# define EVP_CIPHER_type EVP_CIPHER_get_type
+EVP_CIPHER *EVP_CIPHER_fetch(OSSL_LIB_CTX *ctx, const char *algorithm,
+                             const char *properties);
+int EVP_CIPHER_up_ref(EVP_CIPHER *cipher);
+void EVP_CIPHER_free(EVP_CIPHER *cipher);
+
+const EVP_CIPHER *EVP_CIPHER_CTX_get0_cipher(const EVP_CIPHER_CTX *ctx);
+EVP_CIPHER *EVP_CIPHER_CTX_get1_cipher(EVP_CIPHER_CTX *ctx);
+int EVP_CIPHER_CTX_is_encrypting(const EVP_CIPHER_CTX *ctx);
+# define EVP_CIPHER_CTX_encrypting EVP_CIPHER_CTX_is_encrypting
+int EVP_CIPHER_CTX_get_nid(const EVP_CIPHER_CTX *ctx);
+# define EVP_CIPHER_CTX_nid EVP_CIPHER_CTX_get_nid
+int EVP_CIPHER_CTX_get_block_size(const EVP_CIPHER_CTX *ctx);
+# define EVP_CIPHER_CTX_block_size EVP_CIPHER_CTX_get_block_size
+int EVP_CIPHER_CTX_get_key_length(const EVP_CIPHER_CTX *ctx);
+# define EVP_CIPHER_CTX_key_length EVP_CIPHER_CTX_get_key_length
+int EVP_CIPHER_CTX_get_iv_length(const EVP_CIPHER_CTX *ctx);
+# define EVP_CIPHER_CTX_iv_length EVP_CIPHER_CTX_get_iv_length
+int EVP_CIPHER_CTX_get_tag_length(const EVP_CIPHER_CTX *ctx);
+# define EVP_CIPHER_CTX_tag_length EVP_CIPHER_CTX_get_tag_length
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+const EVP_CIPHER *EVP_CIPHER_CTX_cipher(const EVP_CIPHER_CTX *ctx);
+OSSL_DEPRECATEDIN_3_0 const unsigned char *EVP_CIPHER_CTX_iv(const EVP_CIPHER_CTX *ctx);
+OSSL_DEPRECATEDIN_3_0 const unsigned char *EVP_CIPHER_CTX_original_iv(const EVP_CIPHER_CTX *ctx);
+OSSL_DEPRECATEDIN_3_0 unsigned char *EVP_CIPHER_CTX_iv_noconst(EVP_CIPHER_CTX *ctx);
+# endif
+int EVP_CIPHER_CTX_get_updated_iv(EVP_CIPHER_CTX *ctx, void *buf, size_t len);
+int EVP_CIPHER_CTX_get_original_iv(EVP_CIPHER_CTX *ctx, void *buf, size_t len);
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+unsigned char *EVP_CIPHER_CTX_buf_noconst(EVP_CIPHER_CTX *ctx);
+# endif
+int EVP_CIPHER_CTX_get_num(const EVP_CIPHER_CTX *ctx);
+# define EVP_CIPHER_CTX_num EVP_CIPHER_CTX_get_num
+int EVP_CIPHER_CTX_set_num(EVP_CIPHER_CTX *ctx, int num);
+EVP_CIPHER_CTX *EVP_CIPHER_CTX_dup(const EVP_CIPHER_CTX *in);
+int EVP_CIPHER_CTX_copy(EVP_CIPHER_CTX *out, const EVP_CIPHER_CTX *in);
+void *EVP_CIPHER_CTX_get_app_data(const EVP_CIPHER_CTX *ctx);
+void EVP_CIPHER_CTX_set_app_data(EVP_CIPHER_CTX *ctx, void *data);
+void *EVP_CIPHER_CTX_get_cipher_data(const EVP_CIPHER_CTX *ctx);
+void *EVP_CIPHER_CTX_set_cipher_data(EVP_CIPHER_CTX *ctx, void *cipher_data);
+# define EVP_CIPHER_CTX_get0_name(c) EVP_CIPHER_get0_name(EVP_CIPHER_CTX_get0_cipher(c))
+# define EVP_CIPHER_CTX_get_type(c)  EVP_CIPHER_get_type(EVP_CIPHER_CTX_get0_cipher(c))
+# define EVP_CIPHER_CTX_type         EVP_CIPHER_CTX_get_type
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#  define EVP_CIPHER_CTX_flags(c)    EVP_CIPHER_get_flags(EVP_CIPHER_CTX_get0_cipher(c))
+# endif
+# define EVP_CIPHER_CTX_get_mode(c)  EVP_CIPHER_get_mode(EVP_CIPHER_CTX_get0_cipher(c))
+# define EVP_CIPHER_CTX_mode         EVP_CIPHER_CTX_get_mode
+
+# define EVP_ENCODE_LENGTH(l)    ((((l)+2)/3*4)+((l)/48+1)*2+80)
+# define EVP_DECODE_LENGTH(l)    (((l)+3)/4*3+80)
+
+# define EVP_SignInit_ex(a,b,c)          EVP_DigestInit_ex(a,b,c)
+# define EVP_SignInit(a,b)               EVP_DigestInit(a,b)
+# define EVP_SignUpdate(a,b,c)           EVP_DigestUpdate(a,b,c)
+# define EVP_VerifyInit_ex(a,b,c)        EVP_DigestInit_ex(a,b,c)
+# define EVP_VerifyInit(a,b)             EVP_DigestInit(a,b)
+# define EVP_VerifyUpdate(a,b,c)         EVP_DigestUpdate(a,b,c)
+# define EVP_OpenUpdate(a,b,c,d,e)       EVP_DecryptUpdate(a,b,c,d,e)
+# define EVP_SealUpdate(a,b,c,d,e)       EVP_EncryptUpdate(a,b,c,d,e)
+
+# ifdef CONST_STRICT
+void BIO_set_md(BIO *, const EVP_MD *md);
+# else
+#  define BIO_set_md(b,md)          BIO_ctrl(b,BIO_C_SET_MD,0,(void *)(md))
+# endif
+# define BIO_get_md(b,mdp)          BIO_ctrl(b,BIO_C_GET_MD,0,(mdp))
+# define BIO_get_md_ctx(b,mdcp)     BIO_ctrl(b,BIO_C_GET_MD_CTX,0,(mdcp))
+# define BIO_set_md_ctx(b,mdcp)     BIO_ctrl(b,BIO_C_SET_MD_CTX,0,(mdcp))
+# define BIO_get_cipher_status(b)   BIO_ctrl(b,BIO_C_GET_CIPHER_STATUS,0,NULL)
+# define BIO_get_cipher_ctx(b,c_pp) BIO_ctrl(b,BIO_C_GET_CIPHER_CTX,0,(c_pp))
+
+__owur int EVP_Cipher(EVP_CIPHER_CTX *c,
+                          unsigned char *out,
+                          const unsigned char *in, unsigned int inl);
+
+# define EVP_add_cipher_alias(n,alias) \
+        OBJ_NAME_add((alias),OBJ_NAME_TYPE_CIPHER_METH|OBJ_NAME_ALIAS,(n))
+# define EVP_add_digest_alias(n,alias) \
+        OBJ_NAME_add((alias),OBJ_NAME_TYPE_MD_METH|OBJ_NAME_ALIAS,(n))
+# define EVP_delete_cipher_alias(alias) \
+        OBJ_NAME_remove(alias,OBJ_NAME_TYPE_CIPHER_METH|OBJ_NAME_ALIAS);
+# define EVP_delete_digest_alias(alias) \
+        OBJ_NAME_remove(alias,OBJ_NAME_TYPE_MD_METH|OBJ_NAME_ALIAS);
+
+int EVP_MD_get_params(const EVP_MD *digest, OSSL_PARAM params[]);
+int EVP_MD_CTX_set_params(EVP_MD_CTX *ctx, const OSSL_PARAM params[]);
+int EVP_MD_CTX_get_params(EVP_MD_CTX *ctx, OSSL_PARAM params[]);
+const OSSL_PARAM *EVP_MD_gettable_params(const EVP_MD *digest);
+const OSSL_PARAM *EVP_MD_settable_ctx_params(const EVP_MD *md);
+const OSSL_PARAM *EVP_MD_gettable_ctx_params(const EVP_MD *md);
+const OSSL_PARAM *EVP_MD_CTX_settable_params(EVP_MD_CTX *ctx);
+const OSSL_PARAM *EVP_MD_CTX_gettable_params(EVP_MD_CTX *ctx);
+int EVP_MD_CTX_ctrl(EVP_MD_CTX *ctx, int cmd, int p1, void *p2);
+EVP_MD_CTX *EVP_MD_CTX_new(void);
+int EVP_MD_CTX_reset(EVP_MD_CTX *ctx);
+void EVP_MD_CTX_free(EVP_MD_CTX *ctx);
+# define EVP_MD_CTX_create()     EVP_MD_CTX_new()
+# define EVP_MD_CTX_init(ctx)    EVP_MD_CTX_reset((ctx))
+# define EVP_MD_CTX_destroy(ctx) EVP_MD_CTX_free((ctx))
+__owur EVP_MD_CTX *EVP_MD_CTX_dup(const EVP_MD_CTX *in);
+__owur int EVP_MD_CTX_copy_ex(EVP_MD_CTX *out, const EVP_MD_CTX *in);
+void EVP_MD_CTX_set_flags(EVP_MD_CTX *ctx, int flags);
+void EVP_MD_CTX_clear_flags(EVP_MD_CTX *ctx, int flags);
+int EVP_MD_CTX_test_flags(const EVP_MD_CTX *ctx, int flags);
+__owur int EVP_DigestInit_ex2(EVP_MD_CTX *ctx, const EVP_MD *type,
+                              const OSSL_PARAM params[]);
+__owur int EVP_DigestInit_ex(EVP_MD_CTX *ctx, const EVP_MD *type,
+                                 ENGINE *impl);
+__owur int EVP_DigestUpdate(EVP_MD_CTX *ctx, const void *d,
+                                size_t cnt);
+__owur int EVP_DigestFinal_ex(EVP_MD_CTX *ctx, unsigned char *md,
+                                  unsigned int *s);
+__owur int EVP_Digest(const void *data, size_t count,
+                          unsigned char *md, unsigned int *size,
+                          const EVP_MD *type, ENGINE *impl);
+__owur int EVP_Q_digest(OSSL_LIB_CTX *libctx, const char *name,
+                        const char *propq, const void *data, size_t datalen,
+                        unsigned char *md, size_t *mdlen);
+
+__owur int EVP_MD_CTX_copy(EVP_MD_CTX *out, const EVP_MD_CTX *in);
+__owur int EVP_DigestInit(EVP_MD_CTX *ctx, const EVP_MD *type);
+__owur int EVP_DigestFinal(EVP_MD_CTX *ctx, unsigned char *md,
+                           unsigned int *s);
+__owur int EVP_DigestFinalXOF(EVP_MD_CTX *ctx, unsigned char *out,
+                              size_t outlen);
+__owur int EVP_DigestSqueeze(EVP_MD_CTX *ctx, unsigned char *out,
+                             size_t outlen);
+
+__owur EVP_MD *EVP_MD_fetch(OSSL_LIB_CTX *ctx, const char *algorithm,
+                            const char *properties);
+
+int EVP_MD_up_ref(EVP_MD *md);
+void EVP_MD_free(EVP_MD *md);
+
+int EVP_read_pw_string(char *buf, int length, const char *prompt, int verify);
+int EVP_read_pw_string_min(char *buf, int minlen, int maxlen,
+                           const char *prompt, int verify);
+void EVP_set_pw_prompt(const char *prompt);
+char *EVP_get_pw_prompt(void);
+
+__owur int EVP_BytesToKey(const EVP_CIPHER *type, const EVP_MD *md,
+                          const unsigned char *salt,
+                          const unsigned char *data, int datal, int count,
+                          unsigned char *key, unsigned char *iv);
+
+void EVP_CIPHER_CTX_set_flags(EVP_CIPHER_CTX *ctx, int flags);
+void EVP_CIPHER_CTX_clear_flags(EVP_CIPHER_CTX *ctx, int flags);
+int EVP_CIPHER_CTX_test_flags(const EVP_CIPHER_CTX *ctx, int flags);
+
+__owur int EVP_EncryptInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
+                           const unsigned char *key, const unsigned char *iv);
+__owur int EVP_EncryptInit_ex(EVP_CIPHER_CTX *ctx,
+                                  const EVP_CIPHER *cipher, ENGINE *impl,
+                                  const unsigned char *key,
+                                  const unsigned char *iv);
+__owur int EVP_EncryptInit_ex2(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
+                               const unsigned char *key,
+                               const unsigned char *iv,
+                               const OSSL_PARAM params[]);
+__owur int EVP_EncryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out,
+                                 int *outl, const unsigned char *in, int inl);
+__owur int EVP_EncryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out,
+                                   int *outl);
+__owur int EVP_EncryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *out,
+                                int *outl);
+
+__owur int EVP_DecryptInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
+                           const unsigned char *key, const unsigned char *iv);
+__owur int EVP_DecryptInit_ex(EVP_CIPHER_CTX *ctx,
+                                  const EVP_CIPHER *cipher, ENGINE *impl,
+                                  const unsigned char *key,
+                                  const unsigned char *iv);
+__owur int EVP_DecryptInit_ex2(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
+                               const unsigned char *key,
+                               const unsigned char *iv,
+                               const OSSL_PARAM params[]);
+__owur int EVP_DecryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out,
+                                 int *outl, const unsigned char *in, int inl);
+__owur int EVP_DecryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *outm,
+                            int *outl);
+__owur int EVP_DecryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *outm,
+                                   int *outl);
+
+__owur int EVP_CipherInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
+                          const unsigned char *key, const unsigned char *iv,
+                          int enc);
+__owur int EVP_CipherInit_ex(EVP_CIPHER_CTX *ctx,
+                                 const EVP_CIPHER *cipher, ENGINE *impl,
+                                 const unsigned char *key,
+                                 const unsigned char *iv, int enc);
+__owur int EVP_CipherInit_ex2(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
+                              const unsigned char *key, const unsigned char *iv,
+                              int enc, const OSSL_PARAM params[]);
+__owur int EVP_CipherUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out,
+                            int *outl, const unsigned char *in, int inl);
+__owur int EVP_CipherFinal(EVP_CIPHER_CTX *ctx, unsigned char *outm,
+                           int *outl);
+__owur int EVP_CipherFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *outm,
+                              int *outl);
+
+__owur int EVP_SignFinal(EVP_MD_CTX *ctx, unsigned char *md, unsigned int *s,
+                         EVP_PKEY *pkey);
+__owur int EVP_SignFinal_ex(EVP_MD_CTX *ctx, unsigned char *md, unsigned int *s,
+                            EVP_PKEY *pkey, OSSL_LIB_CTX *libctx,
+                            const char *propq);
+
+__owur int EVP_DigestSign(EVP_MD_CTX *ctx, unsigned char *sigret,
+                          size_t *siglen, const unsigned char *tbs,
+                          size_t tbslen);
+
+__owur int EVP_VerifyFinal(EVP_MD_CTX *ctx, const unsigned char *sigbuf,
+                           unsigned int siglen, EVP_PKEY *pkey);
+__owur int EVP_VerifyFinal_ex(EVP_MD_CTX *ctx, const unsigned char *sigbuf,
+                              unsigned int siglen, EVP_PKEY *pkey,
+                              OSSL_LIB_CTX *libctx, const char *propq);
+
+__owur int EVP_DigestVerify(EVP_MD_CTX *ctx, const unsigned char *sigret,
+                            size_t siglen, const unsigned char *tbs,
+                            size_t tbslen);
+
+__owur int EVP_DigestSignInit_ex(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx,
+                          const char *mdname, OSSL_LIB_CTX *libctx,
+                          const char *props, EVP_PKEY *pkey,
+                          const OSSL_PARAM params[]);
+__owur int EVP_DigestSignInit(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx,
+                                  const EVP_MD *type, ENGINE *e,
+                                  EVP_PKEY *pkey);
+__owur int EVP_DigestSignUpdate(EVP_MD_CTX *ctx, const void *data, size_t dsize);
+__owur int EVP_DigestSignFinal(EVP_MD_CTX *ctx, unsigned char *sigret,
+                               size_t *siglen);
+
+__owur int EVP_DigestVerifyInit_ex(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx,
+                            const char *mdname, OSSL_LIB_CTX *libctx,
+                            const char *props, EVP_PKEY *pkey,
+                            const OSSL_PARAM params[]);
+__owur int EVP_DigestVerifyInit(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx,
+                                const EVP_MD *type, ENGINE *e,
+                                EVP_PKEY *pkey);
+int EVP_DigestVerifyUpdate(EVP_MD_CTX *ctx, const void *data, size_t dsize);
+__owur int EVP_DigestVerifyFinal(EVP_MD_CTX *ctx, const unsigned char *sig,
+                                 size_t siglen);
+
+__owur int EVP_OpenInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *type,
+                        const unsigned char *ek, int ekl,
+                        const unsigned char *iv, EVP_PKEY *priv);
+__owur int EVP_OpenFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl);
+
+__owur int EVP_SealInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *type,
+                        unsigned char **ek, int *ekl, unsigned char *iv,
+                        EVP_PKEY **pubk, int npubk);
+__owur int EVP_SealFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl);
+
+EVP_ENCODE_CTX *EVP_ENCODE_CTX_new(void);
+void EVP_ENCODE_CTX_free(EVP_ENCODE_CTX *ctx);
+int EVP_ENCODE_CTX_copy(EVP_ENCODE_CTX *dctx, const EVP_ENCODE_CTX *sctx);
+int EVP_ENCODE_CTX_num(EVP_ENCODE_CTX *ctx);
+void EVP_EncodeInit(EVP_ENCODE_CTX *ctx);
+int EVP_EncodeUpdate(EVP_ENCODE_CTX *ctx, unsigned char *out, int *outl,
+                     const unsigned char *in, int inl);
+void EVP_EncodeFinal(EVP_ENCODE_CTX *ctx, unsigned char *out, int *outl);
+int EVP_EncodeBlock(unsigned char *t, const unsigned char *f, int n);
+
+void EVP_DecodeInit(EVP_ENCODE_CTX *ctx);
+int EVP_DecodeUpdate(EVP_ENCODE_CTX *ctx, unsigned char *out, int *outl,
+                     const unsigned char *in, int inl);
+int EVP_DecodeFinal(EVP_ENCODE_CTX *ctx, unsigned
+                    char *out, int *outl);
+int EVP_DecodeBlock(unsigned char *t, const unsigned char *f, int n);
+
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#  define EVP_CIPHER_CTX_init(c)      EVP_CIPHER_CTX_reset(c)
+#  define EVP_CIPHER_CTX_cleanup(c)   EVP_CIPHER_CTX_reset(c)
+# endif
+EVP_CIPHER_CTX *EVP_CIPHER_CTX_new(void);
+int EVP_CIPHER_CTX_reset(EVP_CIPHER_CTX *c);
+void EVP_CIPHER_CTX_free(EVP_CIPHER_CTX *c);
+int EVP_CIPHER_CTX_set_key_length(EVP_CIPHER_CTX *x, int keylen);
+int EVP_CIPHER_CTX_set_padding(EVP_CIPHER_CTX *c, int pad);
+int EVP_CIPHER_CTX_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr);
+int EVP_CIPHER_CTX_rand_key(EVP_CIPHER_CTX *ctx, unsigned char *key);
+int EVP_CIPHER_get_params(EVP_CIPHER *cipher, OSSL_PARAM params[]);
+int EVP_CIPHER_CTX_set_params(EVP_CIPHER_CTX *ctx, const OSSL_PARAM params[]);
+int EVP_CIPHER_CTX_get_params(EVP_CIPHER_CTX *ctx, OSSL_PARAM params[]);
+const OSSL_PARAM *EVP_CIPHER_gettable_params(const EVP_CIPHER *cipher);
+const OSSL_PARAM *EVP_CIPHER_settable_ctx_params(const EVP_CIPHER *cipher);
+const OSSL_PARAM *EVP_CIPHER_gettable_ctx_params(const EVP_CIPHER *cipher);
+const OSSL_PARAM *EVP_CIPHER_CTX_settable_params(EVP_CIPHER_CTX *ctx);
+const OSSL_PARAM *EVP_CIPHER_CTX_gettable_params(EVP_CIPHER_CTX *ctx);
+
+const BIO_METHOD *BIO_f_md(void);
+const BIO_METHOD *BIO_f_base64(void);
+const BIO_METHOD *BIO_f_cipher(void);
+const BIO_METHOD *BIO_f_reliable(void);
+__owur int BIO_set_cipher(BIO *b, const EVP_CIPHER *c, const unsigned char *k,
+                          const unsigned char *i, int enc);
+
+const EVP_MD *EVP_md_null(void);
+# ifndef OPENSSL_NO_MD2
+const EVP_MD *EVP_md2(void);
+# endif
+# ifndef OPENSSL_NO_MD4
+const EVP_MD *EVP_md4(void);
+# endif
+# ifndef OPENSSL_NO_MD5
+const EVP_MD *EVP_md5(void);
+const EVP_MD *EVP_md5_sha1(void);
+# endif
+# ifndef OPENSSL_NO_BLAKE2
+const EVP_MD *EVP_blake2b512(void);
+const EVP_MD *EVP_blake2s256(void);
+# endif
+const EVP_MD *EVP_sha1(void);
+const EVP_MD *EVP_sha224(void);
+const EVP_MD *EVP_sha256(void);
+const EVP_MD *EVP_sha384(void);
+const EVP_MD *EVP_sha512(void);
+const EVP_MD *EVP_sha512_224(void);
+const EVP_MD *EVP_sha512_256(void);
+const EVP_MD *EVP_sha3_224(void);
+const EVP_MD *EVP_sha3_256(void);
+const EVP_MD *EVP_sha3_384(void);
+const EVP_MD *EVP_sha3_512(void);
+const EVP_MD *EVP_shake128(void);
+const EVP_MD *EVP_shake256(void);
+
+# ifndef OPENSSL_NO_MDC2
+const EVP_MD *EVP_mdc2(void);
+# endif
+# ifndef OPENSSL_NO_RMD160
+const EVP_MD *EVP_ripemd160(void);
+# endif
+# ifndef OPENSSL_NO_WHIRLPOOL
+const EVP_MD *EVP_whirlpool(void);
+# endif
+# ifndef OPENSSL_NO_SM3
+const EVP_MD *EVP_sm3(void);
+# endif
+const EVP_CIPHER *EVP_enc_null(void); /* does nothing :-) */
+# ifndef OPENSSL_NO_DES
+const EVP_CIPHER *EVP_des_ecb(void);
+const EVP_CIPHER *EVP_des_ede(void);
+const EVP_CIPHER *EVP_des_ede3(void);
+const EVP_CIPHER *EVP_des_ede_ecb(void);
+const EVP_CIPHER *EVP_des_ede3_ecb(void);
+const EVP_CIPHER *EVP_des_cfb64(void);
+#  define EVP_des_cfb EVP_des_cfb64
+const EVP_CIPHER *EVP_des_cfb1(void);
+const EVP_CIPHER *EVP_des_cfb8(void);
+const EVP_CIPHER *EVP_des_ede_cfb64(void);
+#  define EVP_des_ede_cfb EVP_des_ede_cfb64
+const EVP_CIPHER *EVP_des_ede3_cfb64(void);
+#  define EVP_des_ede3_cfb EVP_des_ede3_cfb64
+const EVP_CIPHER *EVP_des_ede3_cfb1(void);
+const EVP_CIPHER *EVP_des_ede3_cfb8(void);
+const EVP_CIPHER *EVP_des_ofb(void);
+const EVP_CIPHER *EVP_des_ede_ofb(void);
+const EVP_CIPHER *EVP_des_ede3_ofb(void);
+const EVP_CIPHER *EVP_des_cbc(void);
+const EVP_CIPHER *EVP_des_ede_cbc(void);
+const EVP_CIPHER *EVP_des_ede3_cbc(void);
+const EVP_CIPHER *EVP_desx_cbc(void);
+const EVP_CIPHER *EVP_des_ede3_wrap(void);
+/*
+ * This should now be supported through the dev_crypto ENGINE. But also, why
+ * are rc4 and md5 declarations made here inside a "NO_DES" precompiler
+ * branch?
+ */
+# endif
+# ifndef OPENSSL_NO_RC4
+const EVP_CIPHER *EVP_rc4(void);
+const EVP_CIPHER *EVP_rc4_40(void);
+#  ifndef OPENSSL_NO_MD5
+const EVP_CIPHER *EVP_rc4_hmac_md5(void);
+#  endif
+# endif
+# ifndef OPENSSL_NO_IDEA
+const EVP_CIPHER *EVP_idea_ecb(void);
+const EVP_CIPHER *EVP_idea_cfb64(void);
+#  define EVP_idea_cfb EVP_idea_cfb64
+const EVP_CIPHER *EVP_idea_ofb(void);
+const EVP_CIPHER *EVP_idea_cbc(void);
+# endif
+# ifndef OPENSSL_NO_RC2
+const EVP_CIPHER *EVP_rc2_ecb(void);
+const EVP_CIPHER *EVP_rc2_cbc(void);
+const EVP_CIPHER *EVP_rc2_40_cbc(void);
+const EVP_CIPHER *EVP_rc2_64_cbc(void);
+const EVP_CIPHER *EVP_rc2_cfb64(void);
+#  define EVP_rc2_cfb EVP_rc2_cfb64
+const EVP_CIPHER *EVP_rc2_ofb(void);
+# endif
+# ifndef OPENSSL_NO_BF
+const EVP_CIPHER *EVP_bf_ecb(void);
+const EVP_CIPHER *EVP_bf_cbc(void);
+const EVP_CIPHER *EVP_bf_cfb64(void);
+#  define EVP_bf_cfb EVP_bf_cfb64
+const EVP_CIPHER *EVP_bf_ofb(void);
+# endif
+# ifndef OPENSSL_NO_CAST
+const EVP_CIPHER *EVP_cast5_ecb(void);
+const EVP_CIPHER *EVP_cast5_cbc(void);
+const EVP_CIPHER *EVP_cast5_cfb64(void);
+#  define EVP_cast5_cfb EVP_cast5_cfb64
+const EVP_CIPHER *EVP_cast5_ofb(void);
+# endif
+# ifndef OPENSSL_NO_RC5
+const EVP_CIPHER *EVP_rc5_32_12_16_cbc(void);
+const EVP_CIPHER *EVP_rc5_32_12_16_ecb(void);
+const EVP_CIPHER *EVP_rc5_32_12_16_cfb64(void);
+#  define EVP_rc5_32_12_16_cfb EVP_rc5_32_12_16_cfb64
+const EVP_CIPHER *EVP_rc5_32_12_16_ofb(void);
+# endif
+const EVP_CIPHER *EVP_aes_128_ecb(void);
+const EVP_CIPHER *EVP_aes_128_cbc(void);
+const EVP_CIPHER *EVP_aes_128_cfb1(void);
+const EVP_CIPHER *EVP_aes_128_cfb8(void);
+const EVP_CIPHER *EVP_aes_128_cfb128(void);
+# define EVP_aes_128_cfb EVP_aes_128_cfb128
+const EVP_CIPHER *EVP_aes_128_ofb(void);
+const EVP_CIPHER *EVP_aes_128_ctr(void);
+const EVP_CIPHER *EVP_aes_128_ccm(void);
+const EVP_CIPHER *EVP_aes_128_gcm(void);
+const EVP_CIPHER *EVP_aes_128_xts(void);
+const EVP_CIPHER *EVP_aes_128_wrap(void);
+const EVP_CIPHER *EVP_aes_128_wrap_pad(void);
+# ifndef OPENSSL_NO_OCB
+const EVP_CIPHER *EVP_aes_128_ocb(void);
+# endif
+const EVP_CIPHER *EVP_aes_192_ecb(void);
+const EVP_CIPHER *EVP_aes_192_cbc(void);
+const EVP_CIPHER *EVP_aes_192_cfb1(void);
+const EVP_CIPHER *EVP_aes_192_cfb8(void);
+const EVP_CIPHER *EVP_aes_192_cfb128(void);
+# define EVP_aes_192_cfb EVP_aes_192_cfb128
+const EVP_CIPHER *EVP_aes_192_ofb(void);
+const EVP_CIPHER *EVP_aes_192_ctr(void);
+const EVP_CIPHER *EVP_aes_192_ccm(void);
+const EVP_CIPHER *EVP_aes_192_gcm(void);
+const EVP_CIPHER *EVP_aes_192_wrap(void);
+const EVP_CIPHER *EVP_aes_192_wrap_pad(void);
+# ifndef OPENSSL_NO_OCB
+const EVP_CIPHER *EVP_aes_192_ocb(void);
+# endif
+const EVP_CIPHER *EVP_aes_256_ecb(void);
+const EVP_CIPHER *EVP_aes_256_cbc(void);
+const EVP_CIPHER *EVP_aes_256_cfb1(void);
+const EVP_CIPHER *EVP_aes_256_cfb8(void);
+const EVP_CIPHER *EVP_aes_256_cfb128(void);
+# define EVP_aes_256_cfb EVP_aes_256_cfb128
+const EVP_CIPHER *EVP_aes_256_ofb(void);
+const EVP_CIPHER *EVP_aes_256_ctr(void);
+const EVP_CIPHER *EVP_aes_256_ccm(void);
+const EVP_CIPHER *EVP_aes_256_gcm(void);
+const EVP_CIPHER *EVP_aes_256_xts(void);
+const EVP_CIPHER *EVP_aes_256_wrap(void);
+const EVP_CIPHER *EVP_aes_256_wrap_pad(void);
+# ifndef OPENSSL_NO_OCB
+const EVP_CIPHER *EVP_aes_256_ocb(void);
+# endif
+const EVP_CIPHER *EVP_aes_128_cbc_hmac_sha1(void);
+const EVP_CIPHER *EVP_aes_256_cbc_hmac_sha1(void);
+const EVP_CIPHER *EVP_aes_128_cbc_hmac_sha256(void);
+const EVP_CIPHER *EVP_aes_256_cbc_hmac_sha256(void);
+# ifndef OPENSSL_NO_ARIA
+const EVP_CIPHER *EVP_aria_128_ecb(void);
+const EVP_CIPHER *EVP_aria_128_cbc(void);
+const EVP_CIPHER *EVP_aria_128_cfb1(void);
+const EVP_CIPHER *EVP_aria_128_cfb8(void);
+const EVP_CIPHER *EVP_aria_128_cfb128(void);
+#  define EVP_aria_128_cfb EVP_aria_128_cfb128
+const EVP_CIPHER *EVP_aria_128_ctr(void);
+const EVP_CIPHER *EVP_aria_128_ofb(void);
+const EVP_CIPHER *EVP_aria_128_gcm(void);
+const EVP_CIPHER *EVP_aria_128_ccm(void);
+const EVP_CIPHER *EVP_aria_192_ecb(void);
+const EVP_CIPHER *EVP_aria_192_cbc(void);
+const EVP_CIPHER *EVP_aria_192_cfb1(void);
+const EVP_CIPHER *EVP_aria_192_cfb8(void);
+const EVP_CIPHER *EVP_aria_192_cfb128(void);
+#  define EVP_aria_192_cfb EVP_aria_192_cfb128
+const EVP_CIPHER *EVP_aria_192_ctr(void);
+const EVP_CIPHER *EVP_aria_192_ofb(void);
+const EVP_CIPHER *EVP_aria_192_gcm(void);
+const EVP_CIPHER *EVP_aria_192_ccm(void);
+const EVP_CIPHER *EVP_aria_256_ecb(void);
+const EVP_CIPHER *EVP_aria_256_cbc(void);
+const EVP_CIPHER *EVP_aria_256_cfb1(void);
+const EVP_CIPHER *EVP_aria_256_cfb8(void);
+const EVP_CIPHER *EVP_aria_256_cfb128(void);
+#  define EVP_aria_256_cfb EVP_aria_256_cfb128
+const EVP_CIPHER *EVP_aria_256_ctr(void);
+const EVP_CIPHER *EVP_aria_256_ofb(void);
+const EVP_CIPHER *EVP_aria_256_gcm(void);
+const EVP_CIPHER *EVP_aria_256_ccm(void);
+# endif
+# ifndef OPENSSL_NO_CAMELLIA
+const EVP_CIPHER *EVP_camellia_128_ecb(void);
+const EVP_CIPHER *EVP_camellia_128_cbc(void);
+const EVP_CIPHER *EVP_camellia_128_cfb1(void);
+const EVP_CIPHER *EVP_camellia_128_cfb8(void);
+const EVP_CIPHER *EVP_camellia_128_cfb128(void);
+#  define EVP_camellia_128_cfb EVP_camellia_128_cfb128
+const EVP_CIPHER *EVP_camellia_128_ofb(void);
+const EVP_CIPHER *EVP_camellia_128_ctr(void);
+const EVP_CIPHER *EVP_camellia_192_ecb(void);
+const EVP_CIPHER *EVP_camellia_192_cbc(void);
+const EVP_CIPHER *EVP_camellia_192_cfb1(void);
+const EVP_CIPHER *EVP_camellia_192_cfb8(void);
+const EVP_CIPHER *EVP_camellia_192_cfb128(void);
+#  define EVP_camellia_192_cfb EVP_camellia_192_cfb128
+const EVP_CIPHER *EVP_camellia_192_ofb(void);
+const EVP_CIPHER *EVP_camellia_192_ctr(void);
+const EVP_CIPHER *EVP_camellia_256_ecb(void);
+const EVP_CIPHER *EVP_camellia_256_cbc(void);
+const EVP_CIPHER *EVP_camellia_256_cfb1(void);
+const EVP_CIPHER *EVP_camellia_256_cfb8(void);
+const EVP_CIPHER *EVP_camellia_256_cfb128(void);
+#  define EVP_camellia_256_cfb EVP_camellia_256_cfb128
+const EVP_CIPHER *EVP_camellia_256_ofb(void);
+const EVP_CIPHER *EVP_camellia_256_ctr(void);
+# endif
+# ifndef OPENSSL_NO_CHACHA
+const EVP_CIPHER *EVP_chacha20(void);
+#  ifndef OPENSSL_NO_POLY1305
+const EVP_CIPHER *EVP_chacha20_poly1305(void);
+#  endif
+# endif
+
+# ifndef OPENSSL_NO_SEED
+const EVP_CIPHER *EVP_seed_ecb(void);
+const EVP_CIPHER *EVP_seed_cbc(void);
+const EVP_CIPHER *EVP_seed_cfb128(void);
+#  define EVP_seed_cfb EVP_seed_cfb128
+const EVP_CIPHER *EVP_seed_ofb(void);
+# endif
+
+# ifndef OPENSSL_NO_SM4
+const EVP_CIPHER *EVP_sm4_ecb(void);
+const EVP_CIPHER *EVP_sm4_cbc(void);
+const EVP_CIPHER *EVP_sm4_cfb128(void);
+#  define EVP_sm4_cfb EVP_sm4_cfb128
+const EVP_CIPHER *EVP_sm4_ofb(void);
+const EVP_CIPHER *EVP_sm4_ctr(void);
+# endif
+
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#  define OPENSSL_add_all_algorithms_conf() \
+    OPENSSL_init_crypto(OPENSSL_INIT_ADD_ALL_CIPHERS \
+                        | OPENSSL_INIT_ADD_ALL_DIGESTS \
+                        | OPENSSL_INIT_LOAD_CONFIG, NULL)
+#  define OPENSSL_add_all_algorithms_noconf() \
+    OPENSSL_init_crypto(OPENSSL_INIT_ADD_ALL_CIPHERS \
+                        | OPENSSL_INIT_ADD_ALL_DIGESTS, NULL)
+
+#  ifdef OPENSSL_LOAD_CONF
+#   define OpenSSL_add_all_algorithms() OPENSSL_add_all_algorithms_conf()
+#  else
+#   define OpenSSL_add_all_algorithms() OPENSSL_add_all_algorithms_noconf()
+#  endif
+
+#  define OpenSSL_add_all_ciphers() \
+    OPENSSL_init_crypto(OPENSSL_INIT_ADD_ALL_CIPHERS, NULL)
+#  define OpenSSL_add_all_digests() \
+    OPENSSL_init_crypto(OPENSSL_INIT_ADD_ALL_DIGESTS, NULL)
+
+#  define EVP_cleanup() while(0) continue
+# endif
+
+int EVP_add_cipher(const EVP_CIPHER *cipher);
+int EVP_add_digest(const EVP_MD *digest);
+
+const EVP_CIPHER *EVP_get_cipherbyname(const char *name);
+const EVP_MD *EVP_get_digestbyname(const char *name);
+
+void EVP_CIPHER_do_all(void (*fn) (const EVP_CIPHER *ciph,
+                                   const char *from, const char *to, void *x),
+                       void *arg);
+void EVP_CIPHER_do_all_sorted(void (*fn)
+                               (const EVP_CIPHER *ciph, const char *from,
+                                const char *to, void *x), void *arg);
+void EVP_CIPHER_do_all_provided(OSSL_LIB_CTX *libctx,
+                                void (*fn)(EVP_CIPHER *cipher, void *arg),
+                                void *arg);
+
+void EVP_MD_do_all(void (*fn) (const EVP_MD *ciph,
+                               const char *from, const char *to, void *x),
+                   void *arg);
+void EVP_MD_do_all_sorted(void (*fn)
+                           (const EVP_MD *ciph, const char *from,
+                            const char *to, void *x), void *arg);
+void EVP_MD_do_all_provided(OSSL_LIB_CTX *libctx,
+                            void (*fn)(EVP_MD *md, void *arg),
+                            void *arg);
+
+/* MAC stuff */
+
+EVP_MAC *EVP_MAC_fetch(OSSL_LIB_CTX *libctx, const char *algorithm,
+                       const char *properties);
+int EVP_MAC_up_ref(EVP_MAC *mac);
+void EVP_MAC_free(EVP_MAC *mac);
+const char *EVP_MAC_get0_name(const EVP_MAC *mac);
+const char *EVP_MAC_get0_description(const EVP_MAC *mac);
+int EVP_MAC_is_a(const EVP_MAC *mac, const char *name);
+const OSSL_PROVIDER *EVP_MAC_get0_provider(const EVP_MAC *mac);
+int EVP_MAC_get_params(EVP_MAC *mac, OSSL_PARAM params[]);
+
+EVP_MAC_CTX *EVP_MAC_CTX_new(EVP_MAC *mac);
+void EVP_MAC_CTX_free(EVP_MAC_CTX *ctx);
+EVP_MAC_CTX *EVP_MAC_CTX_dup(const EVP_MAC_CTX *src);
+EVP_MAC *EVP_MAC_CTX_get0_mac(EVP_MAC_CTX *ctx);
+int EVP_MAC_CTX_get_params(EVP_MAC_CTX *ctx, OSSL_PARAM params[]);
+int EVP_MAC_CTX_set_params(EVP_MAC_CTX *ctx, const OSSL_PARAM params[]);
+
+size_t EVP_MAC_CTX_get_mac_size(EVP_MAC_CTX *ctx);
+size_t EVP_MAC_CTX_get_block_size(EVP_MAC_CTX *ctx);
+unsigned char *EVP_Q_mac(OSSL_LIB_CTX *libctx, const char *name, const char *propq,
+                         const char *subalg, const OSSL_PARAM *params,
+                         const void *key, size_t keylen,
+                         const unsigned char *data, size_t datalen,
+                         unsigned char *out, size_t outsize, size_t *outlen);
+int EVP_MAC_init(EVP_MAC_CTX *ctx, const unsigned char *key, size_t keylen,
+                 const OSSL_PARAM params[]);
+int EVP_MAC_update(EVP_MAC_CTX *ctx, const unsigned char *data, size_t datalen);
+int EVP_MAC_final(EVP_MAC_CTX *ctx,
+                  unsigned char *out, size_t *outl, size_t outsize);
+int EVP_MAC_finalXOF(EVP_MAC_CTX *ctx, unsigned char *out, size_t outsize);
+const OSSL_PARAM *EVP_MAC_gettable_params(const EVP_MAC *mac);
+const OSSL_PARAM *EVP_MAC_gettable_ctx_params(const EVP_MAC *mac);
+const OSSL_PARAM *EVP_MAC_settable_ctx_params(const EVP_MAC *mac);
+const OSSL_PARAM *EVP_MAC_CTX_gettable_params(EVP_MAC_CTX *ctx);
+const OSSL_PARAM *EVP_MAC_CTX_settable_params(EVP_MAC_CTX *ctx);
+
+void EVP_MAC_do_all_provided(OSSL_LIB_CTX *libctx,
+                             void (*fn)(EVP_MAC *mac, void *arg),
+                             void *arg);
+int EVP_MAC_names_do_all(const EVP_MAC *mac,
+                         void (*fn)(const char *name, void *data),
+                         void *data);
+
+/* RAND stuff */
+EVP_RAND *EVP_RAND_fetch(OSSL_LIB_CTX *libctx, const char *algorithm,
+                         const char *properties);
+int EVP_RAND_up_ref(EVP_RAND *rand);
+void EVP_RAND_free(EVP_RAND *rand);
+const char *EVP_RAND_get0_name(const EVP_RAND *rand);
+const char *EVP_RAND_get0_description(const EVP_RAND *md);
+int EVP_RAND_is_a(const EVP_RAND *rand, const char *name);
+const OSSL_PROVIDER *EVP_RAND_get0_provider(const EVP_RAND *rand);
+int EVP_RAND_get_params(EVP_RAND *rand, OSSL_PARAM params[]);
+
+EVP_RAND_CTX *EVP_RAND_CTX_new(EVP_RAND *rand, EVP_RAND_CTX *parent);
+int EVP_RAND_CTX_up_ref(EVP_RAND_CTX *ctx);
+void EVP_RAND_CTX_free(EVP_RAND_CTX *ctx);
+EVP_RAND *EVP_RAND_CTX_get0_rand(EVP_RAND_CTX *ctx);
+int EVP_RAND_CTX_get_params(EVP_RAND_CTX *ctx, OSSL_PARAM params[]);
+int EVP_RAND_CTX_set_params(EVP_RAND_CTX *ctx, const OSSL_PARAM params[]);
+const OSSL_PARAM *EVP_RAND_gettable_params(const EVP_RAND *rand);
+const OSSL_PARAM *EVP_RAND_gettable_ctx_params(const EVP_RAND *rand);
+const OSSL_PARAM *EVP_RAND_settable_ctx_params(const EVP_RAND *rand);
+const OSSL_PARAM *EVP_RAND_CTX_gettable_params(EVP_RAND_CTX *ctx);
+const OSSL_PARAM *EVP_RAND_CTX_settable_params(EVP_RAND_CTX *ctx);
+
+void EVP_RAND_do_all_provided(OSSL_LIB_CTX *libctx,
+                              void (*fn)(EVP_RAND *rand, void *arg),
+                              void *arg);
+int EVP_RAND_names_do_all(const EVP_RAND *rand,
+                          void (*fn)(const char *name, void *data),
+                          void *data);
+
+__owur int EVP_RAND_instantiate(EVP_RAND_CTX *ctx, unsigned int strength,
+                                int prediction_resistance,
+                                const unsigned char *pstr, size_t pstr_len,
+                                const OSSL_PARAM params[]);
+int EVP_RAND_uninstantiate(EVP_RAND_CTX *ctx);
+__owur int EVP_RAND_generate(EVP_RAND_CTX *ctx, unsigned char *out,
+                             size_t outlen, unsigned int strength,
+                             int prediction_resistance,
+                             const unsigned char *addin, size_t addin_len);
+int EVP_RAND_reseed(EVP_RAND_CTX *ctx, int prediction_resistance,
+                    const unsigned char *ent, size_t ent_len,
+                    const unsigned char *addin, size_t addin_len);
+__owur int EVP_RAND_nonce(EVP_RAND_CTX *ctx, unsigned char *out, size_t outlen);
+__owur int EVP_RAND_enable_locking(EVP_RAND_CTX *ctx);
+
+int EVP_RAND_verify_zeroization(EVP_RAND_CTX *ctx);
+unsigned int EVP_RAND_get_strength(EVP_RAND_CTX *ctx);
+int EVP_RAND_get_state(EVP_RAND_CTX *ctx);
+
+# define EVP_RAND_STATE_UNINITIALISED    0
+# define EVP_RAND_STATE_READY            1
+# define EVP_RAND_STATE_ERROR            2
+
+/* PKEY stuff */
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int EVP_PKEY_decrypt_old(unsigned char *dec_key,
+                                          const unsigned char *enc_key,
+                                          int enc_key_len,
+                                          EVP_PKEY *private_key);
+OSSL_DEPRECATEDIN_3_0 int EVP_PKEY_encrypt_old(unsigned char *enc_key,
+                                          const unsigned char *key,
+                                          int key_len, EVP_PKEY *pub_key);
+# endif
+int EVP_PKEY_is_a(const EVP_PKEY *pkey, const char *name);
+int EVP_PKEY_type_names_do_all(const EVP_PKEY *pkey,
+                               void (*fn)(const char *name, void *data),
+                               void *data);
+int EVP_PKEY_type(int type);
+int EVP_PKEY_get_id(const EVP_PKEY *pkey);
+# define EVP_PKEY_id EVP_PKEY_get_id
+int EVP_PKEY_get_base_id(const EVP_PKEY *pkey);
+# define EVP_PKEY_base_id EVP_PKEY_get_base_id
+int EVP_PKEY_get_bits(const EVP_PKEY *pkey);
+# define EVP_PKEY_bits EVP_PKEY_get_bits
+int EVP_PKEY_get_security_bits(const EVP_PKEY *pkey);
+# define EVP_PKEY_security_bits EVP_PKEY_get_security_bits
+int EVP_PKEY_get_size(const EVP_PKEY *pkey);
+# define EVP_PKEY_size EVP_PKEY_get_size
+int EVP_PKEY_can_sign(const EVP_PKEY *pkey);
+int EVP_PKEY_set_type(EVP_PKEY *pkey, int type);
+int EVP_PKEY_set_type_str(EVP_PKEY *pkey, const char *str, int len);
+int EVP_PKEY_set_type_by_keymgmt(EVP_PKEY *pkey, EVP_KEYMGMT *keymgmt);
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  ifndef OPENSSL_NO_ENGINE
+OSSL_DEPRECATEDIN_3_0
+int EVP_PKEY_set1_engine(EVP_PKEY *pkey, ENGINE *e);
+OSSL_DEPRECATEDIN_3_0
+ENGINE *EVP_PKEY_get0_engine(const EVP_PKEY *pkey);
+#  endif
+OSSL_DEPRECATEDIN_3_0
+int EVP_PKEY_assign(EVP_PKEY *pkey, int type, void *key);
+OSSL_DEPRECATEDIN_3_0
+void *EVP_PKEY_get0(const EVP_PKEY *pkey);
+OSSL_DEPRECATEDIN_3_0
+const unsigned char *EVP_PKEY_get0_hmac(const EVP_PKEY *pkey, size_t *len);
+#  ifndef OPENSSL_NO_POLY1305
+OSSL_DEPRECATEDIN_3_0
+const unsigned char *EVP_PKEY_get0_poly1305(const EVP_PKEY *pkey, size_t *len);
+#  endif
+#  ifndef OPENSSL_NO_SIPHASH
+OSSL_DEPRECATEDIN_3_0
+const unsigned char *EVP_PKEY_get0_siphash(const EVP_PKEY *pkey, size_t *len);
+#  endif
+
+struct rsa_st;
+OSSL_DEPRECATEDIN_3_0
+int EVP_PKEY_set1_RSA(EVP_PKEY *pkey, struct rsa_st *key);
+OSSL_DEPRECATEDIN_3_0
+const struct rsa_st *EVP_PKEY_get0_RSA(const EVP_PKEY *pkey);
+OSSL_DEPRECATEDIN_3_0
+struct rsa_st *EVP_PKEY_get1_RSA(EVP_PKEY *pkey);
+
+#  ifndef OPENSSL_NO_DSA
+struct dsa_st;
+OSSL_DEPRECATEDIN_3_0
+int EVP_PKEY_set1_DSA(EVP_PKEY *pkey, struct dsa_st *key);
+OSSL_DEPRECATEDIN_3_0
+const struct dsa_st *EVP_PKEY_get0_DSA(const EVP_PKEY *pkey);
+OSSL_DEPRECATEDIN_3_0
+struct dsa_st *EVP_PKEY_get1_DSA(EVP_PKEY *pkey);
+#  endif
+
+#  ifndef OPENSSL_NO_DH
+struct dh_st;
+OSSL_DEPRECATEDIN_3_0 int EVP_PKEY_set1_DH(EVP_PKEY *pkey, struct dh_st *key);
+OSSL_DEPRECATEDIN_3_0 const struct dh_st *EVP_PKEY_get0_DH(const EVP_PKEY *pkey);
+OSSL_DEPRECATEDIN_3_0 struct dh_st *EVP_PKEY_get1_DH(EVP_PKEY *pkey);
+#  endif
+
+#  ifndef OPENSSL_NO_EC
+struct ec_key_st;
+OSSL_DEPRECATEDIN_3_0
+int EVP_PKEY_set1_EC_KEY(EVP_PKEY *pkey, struct ec_key_st *key);
+OSSL_DEPRECATEDIN_3_0
+const struct ec_key_st *EVP_PKEY_get0_EC_KEY(const EVP_PKEY *pkey);
+OSSL_DEPRECATEDIN_3_0
+struct ec_key_st *EVP_PKEY_get1_EC_KEY(EVP_PKEY *pkey);
+#  endif
+# endif /* OPENSSL_NO_DEPRECATED_3_0 */
+
+EVP_PKEY *EVP_PKEY_new(void);
+int EVP_PKEY_up_ref(EVP_PKEY *pkey);
+EVP_PKEY *EVP_PKEY_dup(EVP_PKEY *pkey);
+void EVP_PKEY_free(EVP_PKEY *pkey);
+const char *EVP_PKEY_get0_description(const EVP_PKEY *pkey);
+const OSSL_PROVIDER *EVP_PKEY_get0_provider(const EVP_PKEY *key);
+
+EVP_PKEY *d2i_PublicKey(int type, EVP_PKEY **a, const unsigned char **pp,
+                        long length);
+int i2d_PublicKey(const EVP_PKEY *a, unsigned char **pp);
+
+
+EVP_PKEY *d2i_PrivateKey_ex(int type, EVP_PKEY **a, const unsigned char **pp,
+                            long length, OSSL_LIB_CTX *libctx,
+                            const char *propq);
+EVP_PKEY *d2i_PrivateKey(int type, EVP_PKEY **a, const unsigned char **pp,
+                         long length);
+EVP_PKEY *d2i_AutoPrivateKey_ex(EVP_PKEY **a, const unsigned char **pp,
+                                long length, OSSL_LIB_CTX *libctx,
+                                const char *propq);
+EVP_PKEY *d2i_AutoPrivateKey(EVP_PKEY **a, const unsigned char **pp,
+                             long length);
+int i2d_PrivateKey(const EVP_PKEY *a, unsigned char **pp);
+
+int i2d_KeyParams(const EVP_PKEY *a, unsigned char **pp);
+EVP_PKEY *d2i_KeyParams(int type, EVP_PKEY **a, const unsigned char **pp,
+                        long length);
+int i2d_KeyParams_bio(BIO *bp, const EVP_PKEY *pkey);
+EVP_PKEY *d2i_KeyParams_bio(int type, EVP_PKEY **a, BIO *in);
+
+int EVP_PKEY_copy_parameters(EVP_PKEY *to, const EVP_PKEY *from);
+int EVP_PKEY_missing_parameters(const EVP_PKEY *pkey);
+int EVP_PKEY_save_parameters(EVP_PKEY *pkey, int mode);
+int EVP_PKEY_parameters_eq(const EVP_PKEY *a, const EVP_PKEY *b);
+int EVP_PKEY_eq(const EVP_PKEY *a, const EVP_PKEY *b);
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+int EVP_PKEY_cmp_parameters(const EVP_PKEY *a, const EVP_PKEY *b);
+OSSL_DEPRECATEDIN_3_0
+int EVP_PKEY_cmp(const EVP_PKEY *a, const EVP_PKEY *b);
+# endif
+
+int EVP_PKEY_print_public(BIO *out, const EVP_PKEY *pkey,
+                          int indent, ASN1_PCTX *pctx);
+int EVP_PKEY_print_private(BIO *out, const EVP_PKEY *pkey,
+                           int indent, ASN1_PCTX *pctx);
+int EVP_PKEY_print_params(BIO *out, const EVP_PKEY *pkey,
+                          int indent, ASN1_PCTX *pctx);
+# ifndef OPENSSL_NO_STDIO
+int EVP_PKEY_print_public_fp(FILE *fp, const EVP_PKEY *pkey,
+                             int indent, ASN1_PCTX *pctx);
+int EVP_PKEY_print_private_fp(FILE *fp, const EVP_PKEY *pkey,
+                              int indent, ASN1_PCTX *pctx);
+int EVP_PKEY_print_params_fp(FILE *fp, const EVP_PKEY *pkey,
+                             int indent, ASN1_PCTX *pctx);
+# endif
+
+int EVP_PKEY_get_default_digest_nid(EVP_PKEY *pkey, int *pnid);
+int EVP_PKEY_get_default_digest_name(EVP_PKEY *pkey,
+                                     char *mdname, size_t mdname_sz);
+int EVP_PKEY_digestsign_supports_digest(EVP_PKEY *pkey, OSSL_LIB_CTX *libctx,
+                                        const char *name, const char *propq);
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+/*
+ * For backwards compatibility. Use EVP_PKEY_set1_encoded_public_key in
+ * preference
+ */
+#  define EVP_PKEY_set1_tls_encodedpoint(pkey, pt, ptlen) \
+          EVP_PKEY_set1_encoded_public_key((pkey), (pt), (ptlen))
+# endif
+
+int EVP_PKEY_set1_encoded_public_key(EVP_PKEY *pkey,
+                                     const unsigned char *pub, size_t publen);
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+/*
+ * For backwards compatibility. Use EVP_PKEY_get1_encoded_public_key in
+ * preference
+ */
+#  define EVP_PKEY_get1_tls_encodedpoint(pkey, ppt) \
+          EVP_PKEY_get1_encoded_public_key((pkey), (ppt))
+# endif
+
+size_t EVP_PKEY_get1_encoded_public_key(EVP_PKEY *pkey, unsigned char **ppub);
+
+/* calls methods */
+int EVP_CIPHER_param_to_asn1(EVP_CIPHER_CTX *c, ASN1_TYPE *type);
+int EVP_CIPHER_asn1_to_param(EVP_CIPHER_CTX *c, ASN1_TYPE *type);
+
+/* These are used by EVP_CIPHER methods */
+int EVP_CIPHER_set_asn1_iv(EVP_CIPHER_CTX *c, ASN1_TYPE *type);
+int EVP_CIPHER_get_asn1_iv(EVP_CIPHER_CTX *c, ASN1_TYPE *type);
+
+/* PKCS5 password based encryption */
+int PKCS5_PBE_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass, int passlen,
+                       ASN1_TYPE *param, const EVP_CIPHER *cipher,
+                       const EVP_MD *md, int en_de);
+int PKCS5_PBE_keyivgen_ex(EVP_CIPHER_CTX *cctx, const char *pass, int passlen,
+                          ASN1_TYPE *param, const EVP_CIPHER *cipher,
+                          const EVP_MD *md, int en_de, OSSL_LIB_CTX *libctx,
+                          const char *propq);
+int PKCS5_PBKDF2_HMAC_SHA1(const char *pass, int passlen,
+                           const unsigned char *salt, int saltlen, int iter,
+                           int keylen, unsigned char *out);
+int PKCS5_PBKDF2_HMAC(const char *pass, int passlen,
+                      const unsigned char *salt, int saltlen, int iter,
+                      const EVP_MD *digest, int keylen, unsigned char *out);
+int PKCS5_v2_PBE_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass, int passlen,
+                          ASN1_TYPE *param, const EVP_CIPHER *cipher,
+                          const EVP_MD *md, int en_de);
+int PKCS5_v2_PBE_keyivgen_ex(EVP_CIPHER_CTX *ctx, const char *pass, int passlen,
+                             ASN1_TYPE *param, const EVP_CIPHER *cipher,
+                             const EVP_MD *md, int en_de,
+                             OSSL_LIB_CTX *libctx, const char *propq);
+
+#ifndef OPENSSL_NO_SCRYPT
+int EVP_PBE_scrypt(const char *pass, size_t passlen,
+                   const unsigned char *salt, size_t saltlen,
+                   uint64_t N, uint64_t r, uint64_t p, uint64_t maxmem,
+                   unsigned char *key, size_t keylen);
+int EVP_PBE_scrypt_ex(const char *pass, size_t passlen,
+                      const unsigned char *salt, size_t saltlen,
+                      uint64_t N, uint64_t r, uint64_t p, uint64_t maxmem,
+                      unsigned char *key, size_t keylen,
+                      OSSL_LIB_CTX *ctx, const char *propq);
+
+int PKCS5_v2_scrypt_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass,
+                             int passlen, ASN1_TYPE *param,
+                             const EVP_CIPHER *c, const EVP_MD *md, int en_de);
+int PKCS5_v2_scrypt_keyivgen_ex(EVP_CIPHER_CTX *ctx, const char *pass,
+                                int passlen, ASN1_TYPE *param,
+                                const EVP_CIPHER *c, const EVP_MD *md, int en_de,
+                                OSSL_LIB_CTX *libctx, const char *propq);
+#endif
+
+void PKCS5_PBE_add(void);
+
+int EVP_PBE_CipherInit(ASN1_OBJECT *pbe_obj, const char *pass, int passlen,
+                       ASN1_TYPE *param, EVP_CIPHER_CTX *ctx, int en_de);
+
+int EVP_PBE_CipherInit_ex(ASN1_OBJECT *pbe_obj, const char *pass, int passlen,
+                          ASN1_TYPE *param, EVP_CIPHER_CTX *ctx, int en_de,
+                          OSSL_LIB_CTX *libctx, const char *propq);
+
+/* PBE type */
+
+/* Can appear as the outermost AlgorithmIdentifier */
+# define EVP_PBE_TYPE_OUTER      0x0
+/* Is an PRF type OID */
+# define EVP_PBE_TYPE_PRF        0x1
+/* Is a PKCS#5 v2.0 KDF */
+# define EVP_PBE_TYPE_KDF        0x2
+
+int EVP_PBE_alg_add_type(int pbe_type, int pbe_nid, int cipher_nid,
+                         int md_nid, EVP_PBE_KEYGEN *keygen);
+int EVP_PBE_alg_add(int nid, const EVP_CIPHER *cipher, const EVP_MD *md,
+                    EVP_PBE_KEYGEN *keygen);
+int EVP_PBE_find(int type, int pbe_nid, int *pcnid, int *pmnid,
+                 EVP_PBE_KEYGEN **pkeygen);
+int EVP_PBE_find_ex(int type, int pbe_nid, int *pcnid, int *pmnid,
+                    EVP_PBE_KEYGEN **pkeygen, EVP_PBE_KEYGEN_EX **pkeygen_ex);
+void EVP_PBE_cleanup(void);
+int EVP_PBE_get(int *ptype, int *ppbe_nid, size_t num);
+
+# define ASN1_PKEY_ALIAS         0x1
+# define ASN1_PKEY_DYNAMIC       0x2
+# define ASN1_PKEY_SIGPARAM_NULL 0x4
+
+# define ASN1_PKEY_CTRL_PKCS7_SIGN       0x1
+# define ASN1_PKEY_CTRL_PKCS7_ENCRYPT    0x2
+# define ASN1_PKEY_CTRL_DEFAULT_MD_NID   0x3
+# define ASN1_PKEY_CTRL_CMS_SIGN         0x5
+# define ASN1_PKEY_CTRL_CMS_ENVELOPE     0x7
+# define ASN1_PKEY_CTRL_CMS_RI_TYPE      0x8
+
+# define ASN1_PKEY_CTRL_SET1_TLS_ENCPT   0x9
+# define ASN1_PKEY_CTRL_GET1_TLS_ENCPT   0xa
+# define ASN1_PKEY_CTRL_CMS_IS_RI_TYPE_SUPPORTED 0xb
+
+int EVP_PKEY_asn1_get_count(void);
+const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_get0(int idx);
+const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_find(ENGINE **pe, int type);
+const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_find_str(ENGINE **pe,
+                                                   const char *str, int len);
+int EVP_PKEY_asn1_add0(const EVP_PKEY_ASN1_METHOD *ameth);
+int EVP_PKEY_asn1_add_alias(int to, int from);
+int EVP_PKEY_asn1_get0_info(int *ppkey_id, int *pkey_base_id,
+                            int *ppkey_flags, const char **pinfo,
+                            const char **ppem_str,
+                            const EVP_PKEY_ASN1_METHOD *ameth);
+
+const EVP_PKEY_ASN1_METHOD *EVP_PKEY_get0_asn1(const EVP_PKEY *pkey);
+EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_new(int id, int flags,
+                                        const char *pem_str,
+                                        const char *info);
+void EVP_PKEY_asn1_copy(EVP_PKEY_ASN1_METHOD *dst,
+                        const EVP_PKEY_ASN1_METHOD *src);
+void EVP_PKEY_asn1_free(EVP_PKEY_ASN1_METHOD *ameth);
+void EVP_PKEY_asn1_set_public(EVP_PKEY_ASN1_METHOD *ameth,
+                              int (*pub_decode) (EVP_PKEY *pk,
+                                                 const X509_PUBKEY *pub),
+                              int (*pub_encode) (X509_PUBKEY *pub,
+                                                 const EVP_PKEY *pk),
+                              int (*pub_cmp) (const EVP_PKEY *a,
+                                              const EVP_PKEY *b),
+                              int (*pub_print) (BIO *out,
+                                                const EVP_PKEY *pkey,
+                                                int indent, ASN1_PCTX *pctx),
+                              int (*pkey_size) (const EVP_PKEY *pk),
+                              int (*pkey_bits) (const EVP_PKEY *pk));
+void EVP_PKEY_asn1_set_private(EVP_PKEY_ASN1_METHOD *ameth,
+                               int (*priv_decode) (EVP_PKEY *pk,
+                                                   const PKCS8_PRIV_KEY_INFO
+                                                   *p8inf),
+                               int (*priv_encode) (PKCS8_PRIV_KEY_INFO *p8,
+                                                   const EVP_PKEY *pk),
+                               int (*priv_print) (BIO *out,
+                                                  const EVP_PKEY *pkey,
+                                                  int indent,
+                                                  ASN1_PCTX *pctx));
+void EVP_PKEY_asn1_set_param(EVP_PKEY_ASN1_METHOD *ameth,
+                             int (*param_decode) (EVP_PKEY *pkey,
+                                                  const unsigned char **pder,
+                                                  int derlen),
+                             int (*param_encode) (const EVP_PKEY *pkey,
+                                                  unsigned char **pder),
+                             int (*param_missing) (const EVP_PKEY *pk),
+                             int (*param_copy) (EVP_PKEY *to,
+                                                const EVP_PKEY *from),
+                             int (*param_cmp) (const EVP_PKEY *a,
+                                               const EVP_PKEY *b),
+                             int (*param_print) (BIO *out,
+                                                 const EVP_PKEY *pkey,
+                                                 int indent,
+                                                 ASN1_PCTX *pctx));
+
+void EVP_PKEY_asn1_set_free(EVP_PKEY_ASN1_METHOD *ameth,
+                            void (*pkey_free) (EVP_PKEY *pkey));
+void EVP_PKEY_asn1_set_ctrl(EVP_PKEY_ASN1_METHOD *ameth,
+                            int (*pkey_ctrl) (EVP_PKEY *pkey, int op,
+                                              long arg1, void *arg2));
+void EVP_PKEY_asn1_set_item(EVP_PKEY_ASN1_METHOD *ameth,
+                            int (*item_verify) (EVP_MD_CTX *ctx,
+                                                const ASN1_ITEM *it,
+                                                const void *data,
+                                                const X509_ALGOR *a,
+                                                const ASN1_BIT_STRING *sig,
+                                                EVP_PKEY *pkey),
+                            int (*item_sign) (EVP_MD_CTX *ctx,
+                                              const ASN1_ITEM *it,
+                                              const void *data,
+                                              X509_ALGOR *alg1,
+                                              X509_ALGOR *alg2,
+                                              ASN1_BIT_STRING *sig));
+
+void EVP_PKEY_asn1_set_siginf(EVP_PKEY_ASN1_METHOD *ameth,
+                              int (*siginf_set) (X509_SIG_INFO *siginf,
+                                                 const X509_ALGOR *alg,
+                                                 const ASN1_STRING *sig));
+
+void EVP_PKEY_asn1_set_check(EVP_PKEY_ASN1_METHOD *ameth,
+                             int (*pkey_check) (const EVP_PKEY *pk));
+
+void EVP_PKEY_asn1_set_public_check(EVP_PKEY_ASN1_METHOD *ameth,
+                                    int (*pkey_pub_check) (const EVP_PKEY *pk));
+
+void EVP_PKEY_asn1_set_param_check(EVP_PKEY_ASN1_METHOD *ameth,
+                                   int (*pkey_param_check) (const EVP_PKEY *pk));
+
+void EVP_PKEY_asn1_set_set_priv_key(EVP_PKEY_ASN1_METHOD *ameth,
+                                    int (*set_priv_key) (EVP_PKEY *pk,
+                                                         const unsigned char
+                                                            *priv,
+                                                         size_t len));
+void EVP_PKEY_asn1_set_set_pub_key(EVP_PKEY_ASN1_METHOD *ameth,
+                                   int (*set_pub_key) (EVP_PKEY *pk,
+                                                       const unsigned char *pub,
+                                                       size_t len));
+void EVP_PKEY_asn1_set_get_priv_key(EVP_PKEY_ASN1_METHOD *ameth,
+                                    int (*get_priv_key) (const EVP_PKEY *pk,
+                                                         unsigned char *priv,
+                                                         size_t *len));
+void EVP_PKEY_asn1_set_get_pub_key(EVP_PKEY_ASN1_METHOD *ameth,
+                                   int (*get_pub_key) (const EVP_PKEY *pk,
+                                                       unsigned char *pub,
+                                                       size_t *len));
+
+void EVP_PKEY_asn1_set_security_bits(EVP_PKEY_ASN1_METHOD *ameth,
+                                     int (*pkey_security_bits) (const EVP_PKEY
+                                                                *pk));
+
+int EVP_PKEY_CTX_get_signature_md(EVP_PKEY_CTX *ctx, const EVP_MD **md);
+int EVP_PKEY_CTX_set_signature_md(EVP_PKEY_CTX *ctx, const EVP_MD *md);
+
+int EVP_PKEY_CTX_set1_id(EVP_PKEY_CTX *ctx, const void *id, int len);
+int EVP_PKEY_CTX_get1_id(EVP_PKEY_CTX *ctx, void *id);
+int EVP_PKEY_CTX_get1_id_len(EVP_PKEY_CTX *ctx, size_t *id_len);
+
+int EVP_PKEY_CTX_set_kem_op(EVP_PKEY_CTX *ctx, const char *op);
+
+const char *EVP_PKEY_get0_type_name(const EVP_PKEY *key);
+
+# define EVP_PKEY_OP_UNDEFINED           0
+# define EVP_PKEY_OP_PARAMGEN            (1<<1)
+# define EVP_PKEY_OP_KEYGEN              (1<<2)
+# define EVP_PKEY_OP_FROMDATA            (1<<3)
+# define EVP_PKEY_OP_SIGN                (1<<4)
+# define EVP_PKEY_OP_VERIFY              (1<<5)
+# define EVP_PKEY_OP_VERIFYRECOVER       (1<<6)
+# define EVP_PKEY_OP_SIGNCTX             (1<<7)
+# define EVP_PKEY_OP_VERIFYCTX           (1<<8)
+# define EVP_PKEY_OP_ENCRYPT             (1<<9)
+# define EVP_PKEY_OP_DECRYPT             (1<<10)
+# define EVP_PKEY_OP_DERIVE              (1<<11)
+# define EVP_PKEY_OP_ENCAPSULATE         (1<<12)
+# define EVP_PKEY_OP_DECAPSULATE         (1<<13)
+
+# define EVP_PKEY_OP_TYPE_SIG    \
+        (EVP_PKEY_OP_SIGN | EVP_PKEY_OP_VERIFY | EVP_PKEY_OP_VERIFYRECOVER \
+                | EVP_PKEY_OP_SIGNCTX | EVP_PKEY_OP_VERIFYCTX)
+
+# define EVP_PKEY_OP_TYPE_CRYPT \
+        (EVP_PKEY_OP_ENCRYPT | EVP_PKEY_OP_DECRYPT)
+
+# define EVP_PKEY_OP_TYPE_NOGEN \
+        (EVP_PKEY_OP_TYPE_SIG | EVP_PKEY_OP_TYPE_CRYPT | EVP_PKEY_OP_DERIVE)
+
+# define EVP_PKEY_OP_TYPE_GEN \
+        (EVP_PKEY_OP_PARAMGEN | EVP_PKEY_OP_KEYGEN)
+
+
+int EVP_PKEY_CTX_set_mac_key(EVP_PKEY_CTX *ctx, const unsigned char *key,
+                             int keylen);
+
+# define EVP_PKEY_CTRL_MD                1
+# define EVP_PKEY_CTRL_PEER_KEY          2
+# define EVP_PKEY_CTRL_SET_MAC_KEY       6
+# define EVP_PKEY_CTRL_DIGESTINIT        7
+/* Used by GOST key encryption in TLS */
+# define EVP_PKEY_CTRL_SET_IV            8
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define EVP_PKEY_CTRL_PKCS7_ENCRYPT     3
+#  define EVP_PKEY_CTRL_PKCS7_DECRYPT     4
+#  define EVP_PKEY_CTRL_PKCS7_SIGN        5
+#  define EVP_PKEY_CTRL_CMS_ENCRYPT       9
+#  define EVP_PKEY_CTRL_CMS_DECRYPT       10
+#  define EVP_PKEY_CTRL_CMS_SIGN          11
+# endif
+# define EVP_PKEY_CTRL_CIPHER            12
+# define EVP_PKEY_CTRL_GET_MD            13
+# define EVP_PKEY_CTRL_SET_DIGEST_SIZE   14
+# define EVP_PKEY_CTRL_SET1_ID           15
+# define EVP_PKEY_CTRL_GET1_ID           16
+# define EVP_PKEY_CTRL_GET1_ID_LEN       17
+
+# define EVP_PKEY_ALG_CTRL               0x1000
+
+# define EVP_PKEY_FLAG_AUTOARGLEN        2
+/*
+ * Method handles all operations: don't assume any digest related defaults.
+ */
+# define EVP_PKEY_FLAG_SIGCTX_CUSTOM     4
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 const EVP_PKEY_METHOD *EVP_PKEY_meth_find(int type);
+OSSL_DEPRECATEDIN_3_0 EVP_PKEY_METHOD *EVP_PKEY_meth_new(int id, int flags);
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get0_info(int *ppkey_id, int *pflags,
+                                              const EVP_PKEY_METHOD *meth);
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_copy(EVP_PKEY_METHOD *dst,
+                                         const EVP_PKEY_METHOD *src);
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_free(EVP_PKEY_METHOD *pmeth);
+OSSL_DEPRECATEDIN_3_0 int EVP_PKEY_meth_add0(const EVP_PKEY_METHOD *pmeth);
+OSSL_DEPRECATEDIN_3_0 int EVP_PKEY_meth_remove(const EVP_PKEY_METHOD *pmeth);
+OSSL_DEPRECATEDIN_3_0 size_t EVP_PKEY_meth_get_count(void);
+OSSL_DEPRECATEDIN_3_0 const EVP_PKEY_METHOD *EVP_PKEY_meth_get0(size_t idx);
+# endif
+
+EVP_KEYMGMT *EVP_KEYMGMT_fetch(OSSL_LIB_CTX *ctx, const char *algorithm,
+                               const char *properties);
+int EVP_KEYMGMT_up_ref(EVP_KEYMGMT *keymgmt);
+void EVP_KEYMGMT_free(EVP_KEYMGMT *keymgmt);
+const OSSL_PROVIDER *EVP_KEYMGMT_get0_provider(const EVP_KEYMGMT *keymgmt);
+const char *EVP_KEYMGMT_get0_name(const EVP_KEYMGMT *keymgmt);
+const char *EVP_KEYMGMT_get0_description(const EVP_KEYMGMT *keymgmt);
+int EVP_KEYMGMT_is_a(const EVP_KEYMGMT *keymgmt, const char *name);
+void EVP_KEYMGMT_do_all_provided(OSSL_LIB_CTX *libctx,
+                                 void (*fn)(EVP_KEYMGMT *keymgmt, void *arg),
+                                 void *arg);
+int EVP_KEYMGMT_names_do_all(const EVP_KEYMGMT *keymgmt,
+                             void (*fn)(const char *name, void *data),
+                             void *data);
+const OSSL_PARAM *EVP_KEYMGMT_gettable_params(const EVP_KEYMGMT *keymgmt);
+const OSSL_PARAM *EVP_KEYMGMT_settable_params(const EVP_KEYMGMT *keymgmt);
+const OSSL_PARAM *EVP_KEYMGMT_gen_settable_params(const EVP_KEYMGMT *keymgmt);
+
+EVP_PKEY_CTX *EVP_PKEY_CTX_new(EVP_PKEY *pkey, ENGINE *e);
+EVP_PKEY_CTX *EVP_PKEY_CTX_new_id(int id, ENGINE *e);
+EVP_PKEY_CTX *EVP_PKEY_CTX_new_from_name(OSSL_LIB_CTX *libctx,
+                                         const char *name,
+                                         const char *propquery);
+EVP_PKEY_CTX *EVP_PKEY_CTX_new_from_pkey(OSSL_LIB_CTX *libctx,
+                                         EVP_PKEY *pkey, const char *propquery);
+EVP_PKEY_CTX *EVP_PKEY_CTX_dup(const EVP_PKEY_CTX *ctx);
+void EVP_PKEY_CTX_free(EVP_PKEY_CTX *ctx);
+int EVP_PKEY_CTX_is_a(EVP_PKEY_CTX *ctx, const char *keytype);
+
+int EVP_PKEY_CTX_get_params(EVP_PKEY_CTX *ctx, OSSL_PARAM *params);
+const OSSL_PARAM *EVP_PKEY_CTX_gettable_params(const EVP_PKEY_CTX *ctx);
+int EVP_PKEY_CTX_set_params(EVP_PKEY_CTX *ctx, const OSSL_PARAM *params);
+const OSSL_PARAM *EVP_PKEY_CTX_settable_params(const EVP_PKEY_CTX *ctx);
+int EVP_PKEY_CTX_ctrl(EVP_PKEY_CTX *ctx, int keytype, int optype,
+                      int cmd, int p1, void *p2);
+int EVP_PKEY_CTX_ctrl_str(EVP_PKEY_CTX *ctx, const char *type,
+                          const char *value);
+int EVP_PKEY_CTX_ctrl_uint64(EVP_PKEY_CTX *ctx, int keytype, int optype,
+                             int cmd, uint64_t value);
+
+int EVP_PKEY_CTX_str2ctrl(EVP_PKEY_CTX *ctx, int cmd, const char *str);
+int EVP_PKEY_CTX_hex2ctrl(EVP_PKEY_CTX *ctx, int cmd, const char *hex);
+
+int EVP_PKEY_CTX_md(EVP_PKEY_CTX *ctx, int optype, int cmd, const char *md);
+
+int EVP_PKEY_CTX_get_operation(EVP_PKEY_CTX *ctx);
+void EVP_PKEY_CTX_set0_keygen_info(EVP_PKEY_CTX *ctx, int *dat, int datlen);
+
+EVP_PKEY *EVP_PKEY_new_mac_key(int type, ENGINE *e,
+                               const unsigned char *key, int keylen);
+EVP_PKEY *EVP_PKEY_new_raw_private_key_ex(OSSL_LIB_CTX *libctx,
+                                          const char *keytype,
+                                          const char *propq,
+                                          const unsigned char *priv, size_t len);
+EVP_PKEY *EVP_PKEY_new_raw_private_key(int type, ENGINE *e,
+                                       const unsigned char *priv,
+                                       size_t len);
+EVP_PKEY *EVP_PKEY_new_raw_public_key_ex(OSSL_LIB_CTX *libctx,
+                                         const char *keytype, const char *propq,
+                                         const unsigned char *pub, size_t len);
+EVP_PKEY *EVP_PKEY_new_raw_public_key(int type, ENGINE *e,
+                                      const unsigned char *pub,
+                                      size_t len);
+int EVP_PKEY_get_raw_private_key(const EVP_PKEY *pkey, unsigned char *priv,
+                                 size_t *len);
+int EVP_PKEY_get_raw_public_key(const EVP_PKEY *pkey, unsigned char *pub,
+                                size_t *len);
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+EVP_PKEY *EVP_PKEY_new_CMAC_key(ENGINE *e, const unsigned char *priv,
+                                size_t len, const EVP_CIPHER *cipher);
+# endif
+
+void EVP_PKEY_CTX_set_data(EVP_PKEY_CTX *ctx, void *data);
+void *EVP_PKEY_CTX_get_data(const EVP_PKEY_CTX *ctx);
+EVP_PKEY *EVP_PKEY_CTX_get0_pkey(EVP_PKEY_CTX *ctx);
+
+EVP_PKEY *EVP_PKEY_CTX_get0_peerkey(EVP_PKEY_CTX *ctx);
+
+void EVP_PKEY_CTX_set_app_data(EVP_PKEY_CTX *ctx, void *data);
+void *EVP_PKEY_CTX_get_app_data(EVP_PKEY_CTX *ctx);
+
+void EVP_SIGNATURE_free(EVP_SIGNATURE *signature);
+int EVP_SIGNATURE_up_ref(EVP_SIGNATURE *signature);
+OSSL_PROVIDER *EVP_SIGNATURE_get0_provider(const EVP_SIGNATURE *signature);
+EVP_SIGNATURE *EVP_SIGNATURE_fetch(OSSL_LIB_CTX *ctx, const char *algorithm,
+                                   const char *properties);
+int EVP_SIGNATURE_is_a(const EVP_SIGNATURE *signature, const char *name);
+const char *EVP_SIGNATURE_get0_name(const EVP_SIGNATURE *signature);
+const char *EVP_SIGNATURE_get0_description(const EVP_SIGNATURE *signature);
+void EVP_SIGNATURE_do_all_provided(OSSL_LIB_CTX *libctx,
+                                   void (*fn)(EVP_SIGNATURE *signature,
+                                              void *data),
+                                   void *data);
+int EVP_SIGNATURE_names_do_all(const EVP_SIGNATURE *signature,
+                               void (*fn)(const char *name, void *data),
+                               void *data);
+const OSSL_PARAM *EVP_SIGNATURE_gettable_ctx_params(const EVP_SIGNATURE *sig);
+const OSSL_PARAM *EVP_SIGNATURE_settable_ctx_params(const EVP_SIGNATURE *sig);
+
+void EVP_ASYM_CIPHER_free(EVP_ASYM_CIPHER *cipher);
+int EVP_ASYM_CIPHER_up_ref(EVP_ASYM_CIPHER *cipher);
+OSSL_PROVIDER *EVP_ASYM_CIPHER_get0_provider(const EVP_ASYM_CIPHER *cipher);
+EVP_ASYM_CIPHER *EVP_ASYM_CIPHER_fetch(OSSL_LIB_CTX *ctx, const char *algorithm,
+                                       const char *properties);
+int EVP_ASYM_CIPHER_is_a(const EVP_ASYM_CIPHER *cipher, const char *name);
+const char *EVP_ASYM_CIPHER_get0_name(const EVP_ASYM_CIPHER *cipher);
+const char *EVP_ASYM_CIPHER_get0_description(const EVP_ASYM_CIPHER *cipher);
+void EVP_ASYM_CIPHER_do_all_provided(OSSL_LIB_CTX *libctx,
+                                     void (*fn)(EVP_ASYM_CIPHER *cipher,
+                                                void *arg),
+                                     void *arg);
+int EVP_ASYM_CIPHER_names_do_all(const EVP_ASYM_CIPHER *cipher,
+                                 void (*fn)(const char *name, void *data),
+                                 void *data);
+const OSSL_PARAM *EVP_ASYM_CIPHER_gettable_ctx_params(const EVP_ASYM_CIPHER *ciph);
+const OSSL_PARAM *EVP_ASYM_CIPHER_settable_ctx_params(const EVP_ASYM_CIPHER *ciph);
+
+void EVP_KEM_free(EVP_KEM *wrap);
+int EVP_KEM_up_ref(EVP_KEM *wrap);
+OSSL_PROVIDER *EVP_KEM_get0_provider(const EVP_KEM *wrap);
+EVP_KEM *EVP_KEM_fetch(OSSL_LIB_CTX *ctx, const char *algorithm,
+                       const char *properties);
+int EVP_KEM_is_a(const EVP_KEM *wrap, const char *name);
+const char *EVP_KEM_get0_name(const EVP_KEM *wrap);
+const char *EVP_KEM_get0_description(const EVP_KEM *wrap);
+void EVP_KEM_do_all_provided(OSSL_LIB_CTX *libctx,
+                             void (*fn)(EVP_KEM *wrap, void *arg), void *arg);
+int EVP_KEM_names_do_all(const EVP_KEM *wrap,
+                         void (*fn)(const char *name, void *data), void *data);
+const OSSL_PARAM *EVP_KEM_gettable_ctx_params(const EVP_KEM *kem);
+const OSSL_PARAM *EVP_KEM_settable_ctx_params(const EVP_KEM *kem);
+
+int EVP_PKEY_sign_init(EVP_PKEY_CTX *ctx);
+int EVP_PKEY_sign_init_ex(EVP_PKEY_CTX *ctx, const OSSL_PARAM params[]);
+int EVP_PKEY_sign(EVP_PKEY_CTX *ctx,
+                  unsigned char *sig, size_t *siglen,
+                  const unsigned char *tbs, size_t tbslen);
+int EVP_PKEY_verify_init(EVP_PKEY_CTX *ctx);
+int EVP_PKEY_verify_init_ex(EVP_PKEY_CTX *ctx, const OSSL_PARAM params[]);
+int EVP_PKEY_verify(EVP_PKEY_CTX *ctx,
+                    const unsigned char *sig, size_t siglen,
+                    const unsigned char *tbs, size_t tbslen);
+int EVP_PKEY_verify_recover_init(EVP_PKEY_CTX *ctx);
+int EVP_PKEY_verify_recover_init_ex(EVP_PKEY_CTX *ctx,
+                                    const OSSL_PARAM params[]);
+int EVP_PKEY_verify_recover(EVP_PKEY_CTX *ctx,
+                            unsigned char *rout, size_t *routlen,
+                            const unsigned char *sig, size_t siglen);
+int EVP_PKEY_encrypt_init(EVP_PKEY_CTX *ctx);
+int EVP_PKEY_encrypt_init_ex(EVP_PKEY_CTX *ctx, const OSSL_PARAM params[]);
+int EVP_PKEY_encrypt(EVP_PKEY_CTX *ctx,
+                     unsigned char *out, size_t *outlen,
+                     const unsigned char *in, size_t inlen);
+int EVP_PKEY_decrypt_init(EVP_PKEY_CTX *ctx);
+int EVP_PKEY_decrypt_init_ex(EVP_PKEY_CTX *ctx, const OSSL_PARAM params[]);
+int EVP_PKEY_decrypt(EVP_PKEY_CTX *ctx,
+                     unsigned char *out, size_t *outlen,
+                     const unsigned char *in, size_t inlen);
+
+int EVP_PKEY_derive_init(EVP_PKEY_CTX *ctx);
+int EVP_PKEY_derive_init_ex(EVP_PKEY_CTX *ctx, const OSSL_PARAM params[]);
+int EVP_PKEY_derive_set_peer_ex(EVP_PKEY_CTX *ctx, EVP_PKEY *peer,
+                                int validate_peer);
+int EVP_PKEY_derive_set_peer(EVP_PKEY_CTX *ctx, EVP_PKEY *peer);
+int EVP_PKEY_derive(EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen);
+
+int EVP_PKEY_encapsulate_init(EVP_PKEY_CTX *ctx, const OSSL_PARAM params[]);
+int EVP_PKEY_auth_encapsulate_init(EVP_PKEY_CTX *ctx, EVP_PKEY *authpriv,
+                                   const OSSL_PARAM params[]);
+int EVP_PKEY_encapsulate(EVP_PKEY_CTX *ctx,
+                         unsigned char *wrappedkey, size_t *wrappedkeylen,
+                         unsigned char *genkey, size_t *genkeylen);
+int EVP_PKEY_decapsulate_init(EVP_PKEY_CTX *ctx, const OSSL_PARAM params[]);
+int EVP_PKEY_auth_decapsulate_init(EVP_PKEY_CTX *ctx, EVP_PKEY *authpub,
+                                   const OSSL_PARAM params[]);
+int EVP_PKEY_decapsulate(EVP_PKEY_CTX *ctx,
+                         unsigned char *unwrapped, size_t *unwrappedlen,
+                         const unsigned char *wrapped, size_t wrappedlen);
+typedef int EVP_PKEY_gen_cb(EVP_PKEY_CTX *ctx);
+
+int EVP_PKEY_fromdata_init(EVP_PKEY_CTX *ctx);
+int EVP_PKEY_fromdata(EVP_PKEY_CTX *ctx, EVP_PKEY **ppkey, int selection,
+                      OSSL_PARAM param[]);
+const OSSL_PARAM *EVP_PKEY_fromdata_settable(EVP_PKEY_CTX *ctx, int selection);
+
+int EVP_PKEY_todata(const EVP_PKEY *pkey, int selection, OSSL_PARAM **params);
+int EVP_PKEY_export(const EVP_PKEY *pkey, int selection,
+                    OSSL_CALLBACK *export_cb, void *export_cbarg);
+
+const OSSL_PARAM *EVP_PKEY_gettable_params(const EVP_PKEY *pkey);
+int EVP_PKEY_get_params(const EVP_PKEY *pkey, OSSL_PARAM params[]);
+int EVP_PKEY_get_int_param(const EVP_PKEY *pkey, const char *key_name,
+                           int *out);
+int EVP_PKEY_get_size_t_param(const EVP_PKEY *pkey, const char *key_name,
+                              size_t *out);
+int EVP_PKEY_get_bn_param(const EVP_PKEY *pkey, const char *key_name,
+                          BIGNUM **bn);
+int EVP_PKEY_get_utf8_string_param(const EVP_PKEY *pkey, const char *key_name,
+                                    char *str, size_t max_buf_sz, size_t *out_sz);
+int EVP_PKEY_get_octet_string_param(const EVP_PKEY *pkey, const char *key_name,
+                                    unsigned char *buf, size_t max_buf_sz,
+                                    size_t *out_sz);
+
+const OSSL_PARAM *EVP_PKEY_settable_params(const EVP_PKEY *pkey);
+int EVP_PKEY_set_params(EVP_PKEY *pkey, OSSL_PARAM params[]);
+int EVP_PKEY_set_int_param(EVP_PKEY *pkey, const char *key_name, int in);
+int EVP_PKEY_set_size_t_param(EVP_PKEY *pkey, const char *key_name, size_t in);
+int EVP_PKEY_set_bn_param(EVP_PKEY *pkey, const char *key_name,
+                          const BIGNUM *bn);
+int EVP_PKEY_set_utf8_string_param(EVP_PKEY *pkey, const char *key_name,
+                                   const char *str);
+int EVP_PKEY_set_octet_string_param(EVP_PKEY *pkey, const char *key_name,
+                                    const unsigned char *buf, size_t bsize);
+
+int EVP_PKEY_get_ec_point_conv_form(const EVP_PKEY *pkey);
+int EVP_PKEY_get_field_type(const EVP_PKEY *pkey);
+
+EVP_PKEY *EVP_PKEY_Q_keygen(OSSL_LIB_CTX *libctx, const char *propq,
+                            const char *type, ...);
+int EVP_PKEY_paramgen_init(EVP_PKEY_CTX *ctx);
+int EVP_PKEY_paramgen(EVP_PKEY_CTX *ctx, EVP_PKEY **ppkey);
+int EVP_PKEY_keygen_init(EVP_PKEY_CTX *ctx);
+int EVP_PKEY_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY **ppkey);
+int EVP_PKEY_generate(EVP_PKEY_CTX *ctx, EVP_PKEY **ppkey);
+int EVP_PKEY_check(EVP_PKEY_CTX *ctx);
+int EVP_PKEY_public_check(EVP_PKEY_CTX *ctx);
+int EVP_PKEY_public_check_quick(EVP_PKEY_CTX *ctx);
+int EVP_PKEY_param_check(EVP_PKEY_CTX *ctx);
+int EVP_PKEY_param_check_quick(EVP_PKEY_CTX *ctx);
+int EVP_PKEY_private_check(EVP_PKEY_CTX *ctx);
+int EVP_PKEY_pairwise_check(EVP_PKEY_CTX *ctx);
+
+# define EVP_PKEY_get_ex_new_index(l, p, newf, dupf, freef) \
+    CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_EVP_PKEY, l, p, newf, dupf, freef)
+int EVP_PKEY_set_ex_data(EVP_PKEY *key, int idx, void *arg);
+void *EVP_PKEY_get_ex_data(const EVP_PKEY *key, int idx);
+
+void EVP_PKEY_CTX_set_cb(EVP_PKEY_CTX *ctx, EVP_PKEY_gen_cb *cb);
+EVP_PKEY_gen_cb *EVP_PKEY_CTX_get_cb(EVP_PKEY_CTX *ctx);
+
+int EVP_PKEY_CTX_get_keygen_info(EVP_PKEY_CTX *ctx, int idx);
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_init(EVP_PKEY_METHOD *pmeth,
+                                             int (*init) (EVP_PKEY_CTX *ctx));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_copy
+    (EVP_PKEY_METHOD *pmeth, int (*copy) (EVP_PKEY_CTX *dst,
+                                          const EVP_PKEY_CTX *src));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_cleanup
+    (EVP_PKEY_METHOD *pmeth, void (*cleanup) (EVP_PKEY_CTX *ctx));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_paramgen
+    (EVP_PKEY_METHOD *pmeth, int (*paramgen_init) (EVP_PKEY_CTX *ctx),
+     int (*paramgen) (EVP_PKEY_CTX *ctx, EVP_PKEY *pkey));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_keygen
+    (EVP_PKEY_METHOD *pmeth, int (*keygen_init) (EVP_PKEY_CTX *ctx),
+     int (*keygen) (EVP_PKEY_CTX *ctx, EVP_PKEY *pkey));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_sign
+    (EVP_PKEY_METHOD *pmeth, int (*sign_init) (EVP_PKEY_CTX *ctx),
+     int (*sign) (EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
+                  const unsigned char *tbs, size_t tbslen));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_verify
+    (EVP_PKEY_METHOD *pmeth, int (*verify_init) (EVP_PKEY_CTX *ctx),
+     int (*verify) (EVP_PKEY_CTX *ctx, const unsigned char *sig, size_t siglen,
+                    const unsigned char *tbs, size_t tbslen));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_verify_recover
+    (EVP_PKEY_METHOD *pmeth, int (*verify_recover_init) (EVP_PKEY_CTX *ctx),
+     int (*verify_recover) (EVP_PKEY_CTX *ctx, unsigned char *sig,
+                            size_t *siglen, const unsigned char *tbs,
+                            size_t tbslen));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_signctx
+    (EVP_PKEY_METHOD *pmeth, int (*signctx_init) (EVP_PKEY_CTX *ctx,
+                                                  EVP_MD_CTX *mctx),
+     int (*signctx) (EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
+                     EVP_MD_CTX *mctx));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_verifyctx
+    (EVP_PKEY_METHOD *pmeth, int (*verifyctx_init) (EVP_PKEY_CTX *ctx,
+                                                    EVP_MD_CTX *mctx),
+     int (*verifyctx) (EVP_PKEY_CTX *ctx, const unsigned char *sig, int siglen,
+                       EVP_MD_CTX *mctx));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_encrypt
+    (EVP_PKEY_METHOD *pmeth, int (*encrypt_init) (EVP_PKEY_CTX *ctx),
+     int (*encryptfn) (EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen,
+                       const unsigned char *in, size_t inlen));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_decrypt
+    (EVP_PKEY_METHOD *pmeth, int (*decrypt_init) (EVP_PKEY_CTX *ctx),
+     int (*decrypt) (EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen,
+                     const unsigned char *in, size_t inlen));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_derive
+    (EVP_PKEY_METHOD *pmeth, int (*derive_init) (EVP_PKEY_CTX *ctx),
+     int (*derive) (EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_ctrl
+    (EVP_PKEY_METHOD *pmeth, int (*ctrl) (EVP_PKEY_CTX *ctx, int type, int p1,
+                                          void *p2),
+     int (*ctrl_str) (EVP_PKEY_CTX *ctx, const char *type, const char *value));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_digestsign
+    (EVP_PKEY_METHOD *pmeth,
+     int (*digestsign) (EVP_MD_CTX *ctx, unsigned char *sig, size_t *siglen,
+                        const unsigned char *tbs, size_t tbslen));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_digestverify
+    (EVP_PKEY_METHOD *pmeth,
+     int (*digestverify) (EVP_MD_CTX *ctx, const unsigned char *sig,
+                          size_t siglen, const unsigned char *tbs,
+                          size_t tbslen));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_check
+    (EVP_PKEY_METHOD *pmeth, int (*check) (EVP_PKEY *pkey));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_public_check
+    (EVP_PKEY_METHOD *pmeth, int (*check) (EVP_PKEY *pkey));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_param_check
+    (EVP_PKEY_METHOD *pmeth, int (*check) (EVP_PKEY *pkey));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_digest_custom
+    (EVP_PKEY_METHOD *pmeth, int (*digest_custom) (EVP_PKEY_CTX *ctx,
+                                                   EVP_MD_CTX *mctx));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_init
+    (const EVP_PKEY_METHOD *pmeth, int (**pinit) (EVP_PKEY_CTX *ctx));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_copy
+    (const EVP_PKEY_METHOD *pmeth, int (**pcopy) (EVP_PKEY_CTX *dst,
+                                                  const EVP_PKEY_CTX *src));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_cleanup
+    (const EVP_PKEY_METHOD *pmeth, void (**pcleanup) (EVP_PKEY_CTX *ctx));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_paramgen
+    (const EVP_PKEY_METHOD *pmeth, int (**pparamgen_init) (EVP_PKEY_CTX *ctx),
+     int (**pparamgen) (EVP_PKEY_CTX *ctx, EVP_PKEY *pkey));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_keygen
+    (const EVP_PKEY_METHOD *pmeth, int (**pkeygen_init) (EVP_PKEY_CTX *ctx),
+     int (**pkeygen) (EVP_PKEY_CTX *ctx, EVP_PKEY *pkey));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_sign
+    (const EVP_PKEY_METHOD *pmeth, int (**psign_init) (EVP_PKEY_CTX *ctx),
+     int (**psign) (EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
+                    const unsigned char *tbs, size_t tbslen));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_verify
+    (const EVP_PKEY_METHOD *pmeth, int (**pverify_init) (EVP_PKEY_CTX *ctx),
+     int (**pverify) (EVP_PKEY_CTX *ctx, const unsigned char *sig,
+                      size_t siglen, const unsigned char *tbs, size_t tbslen));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_verify_recover
+    (const EVP_PKEY_METHOD *pmeth,
+     int (**pverify_recover_init) (EVP_PKEY_CTX *ctx),
+     int (**pverify_recover) (EVP_PKEY_CTX *ctx, unsigned char *sig,
+                              size_t *siglen, const unsigned char *tbs,
+                              size_t tbslen));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_signctx
+    (const EVP_PKEY_METHOD *pmeth,
+     int (**psignctx_init) (EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx),
+     int (**psignctx) (EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
+                       EVP_MD_CTX *mctx));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_verifyctx
+    (const EVP_PKEY_METHOD *pmeth,
+     int (**pverifyctx_init) (EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx),
+     int (**pverifyctx) (EVP_PKEY_CTX *ctx, const unsigned char *sig,
+                          int siglen, EVP_MD_CTX *mctx));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_encrypt
+    (const EVP_PKEY_METHOD *pmeth, int (**pencrypt_init) (EVP_PKEY_CTX *ctx),
+     int (**pencryptfn) (EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen,
+                         const unsigned char *in, size_t inlen));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_decrypt
+    (const EVP_PKEY_METHOD *pmeth, int (**pdecrypt_init) (EVP_PKEY_CTX *ctx),
+     int (**pdecrypt) (EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen,
+                       const unsigned char *in, size_t inlen));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_derive
+    (const EVP_PKEY_METHOD *pmeth, int (**pderive_init) (EVP_PKEY_CTX *ctx),
+     int (**pderive) (EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_ctrl
+    (const EVP_PKEY_METHOD *pmeth,
+     int (**pctrl) (EVP_PKEY_CTX *ctx, int type, int p1, void *p2),
+     int (**pctrl_str) (EVP_PKEY_CTX *ctx, const char *type,
+                        const char *value));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_digestsign
+    (const EVP_PKEY_METHOD *pmeth,
+     int (**digestsign) (EVP_MD_CTX *ctx, unsigned char *sig, size_t *siglen,
+                         const unsigned char *tbs, size_t tbslen));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_digestverify
+    (const EVP_PKEY_METHOD *pmeth,
+     int (**digestverify) (EVP_MD_CTX *ctx, const unsigned char *sig,
+                           size_t siglen, const unsigned char *tbs,
+                           size_t tbslen));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_check
+    (const EVP_PKEY_METHOD *pmeth, int (**pcheck) (EVP_PKEY *pkey));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_public_check
+    (const EVP_PKEY_METHOD *pmeth, int (**pcheck) (EVP_PKEY *pkey));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_param_check
+    (const EVP_PKEY_METHOD *pmeth, int (**pcheck) (EVP_PKEY *pkey));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_digest_custom
+    (const EVP_PKEY_METHOD *pmeth,
+     int (**pdigest_custom) (EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx));
+# endif
+
+void EVP_KEYEXCH_free(EVP_KEYEXCH *exchange);
+int EVP_KEYEXCH_up_ref(EVP_KEYEXCH *exchange);
+EVP_KEYEXCH *EVP_KEYEXCH_fetch(OSSL_LIB_CTX *ctx, const char *algorithm,
+                               const char *properties);
+OSSL_PROVIDER *EVP_KEYEXCH_get0_provider(const EVP_KEYEXCH *exchange);
+int EVP_KEYEXCH_is_a(const EVP_KEYEXCH *keyexch, const char *name);
+const char *EVP_KEYEXCH_get0_name(const EVP_KEYEXCH *keyexch);
+const char *EVP_KEYEXCH_get0_description(const EVP_KEYEXCH *keyexch);
+void EVP_KEYEXCH_do_all_provided(OSSL_LIB_CTX *libctx,
+                                 void (*fn)(EVP_KEYEXCH *keyexch, void *data),
+                                 void *data);
+int EVP_KEYEXCH_names_do_all(const EVP_KEYEXCH *keyexch,
+                             void (*fn)(const char *name, void *data),
+                             void *data);
+const OSSL_PARAM *EVP_KEYEXCH_gettable_ctx_params(const EVP_KEYEXCH *keyexch);
+const OSSL_PARAM *EVP_KEYEXCH_settable_ctx_params(const EVP_KEYEXCH *keyexch);
+
+void EVP_add_alg_module(void);
+
+int EVP_PKEY_CTX_set_group_name(EVP_PKEY_CTX *ctx, const char *name);
+int EVP_PKEY_CTX_get_group_name(EVP_PKEY_CTX *ctx, char *name, size_t namelen);
+int EVP_PKEY_get_group_name(const EVP_PKEY *pkey, char *name, size_t name_sz,
+                            size_t *gname_len);
+
+OSSL_LIB_CTX *EVP_PKEY_CTX_get0_libctx(EVP_PKEY_CTX *ctx);
+const char *EVP_PKEY_CTX_get0_propq(const EVP_PKEY_CTX *ctx);
+const OSSL_PROVIDER *EVP_PKEY_CTX_get0_provider(const EVP_PKEY_CTX *ctx);
+
+# ifdef  __cplusplus
+}
+# endif
+#endif
diff --git a/src/include/openssl/evperr.h b/src/include/openssl/evperr.h
new file mode 100644
index 0000000..11f3faa
--- /dev/null
+++ b/src/include/openssl/evperr.h
@@ -0,0 +1,137 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_EVPERR_H
+# define OPENSSL_EVPERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+
+/*
+ * EVP reason codes.
+ */
+# define EVP_R_AES_KEY_SETUP_FAILED                       143
+# define EVP_R_ARIA_KEY_SETUP_FAILED                      176
+# define EVP_R_BAD_ALGORITHM_NAME                         200
+# define EVP_R_BAD_DECRYPT                                100
+# define EVP_R_BAD_KEY_LENGTH                             195
+# define EVP_R_BUFFER_TOO_SMALL                           155
+# define EVP_R_CACHE_CONSTANTS_FAILED                     225
+# define EVP_R_CAMELLIA_KEY_SETUP_FAILED                  157
+# define EVP_R_CANNOT_GET_PARAMETERS                      197
+# define EVP_R_CANNOT_SET_PARAMETERS                      198
+# define EVP_R_CIPHER_NOT_GCM_MODE                        184
+# define EVP_R_CIPHER_PARAMETER_ERROR                     122
+# define EVP_R_COMMAND_NOT_SUPPORTED                      147
+# define EVP_R_CONFLICTING_ALGORITHM_NAME                 201
+# define EVP_R_COPY_ERROR                                 173
+# define EVP_R_CTRL_NOT_IMPLEMENTED                       132
+# define EVP_R_CTRL_OPERATION_NOT_IMPLEMENTED             133
+# define EVP_R_DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH          138
+# define EVP_R_DECODE_ERROR                               114
+# define EVP_R_DEFAULT_QUERY_PARSE_ERROR                  210
+# define EVP_R_DIFFERENT_KEY_TYPES                        101
+# define EVP_R_DIFFERENT_PARAMETERS                       153
+# define EVP_R_ERROR_LOADING_SECTION                      165
+# define EVP_R_EXPECTING_AN_HMAC_KEY                      174
+# define EVP_R_EXPECTING_AN_RSA_KEY                       127
+# define EVP_R_EXPECTING_A_DH_KEY                         128
+# define EVP_R_EXPECTING_A_DSA_KEY                        129
+# define EVP_R_EXPECTING_A_ECX_KEY                        219
+# define EVP_R_EXPECTING_A_EC_KEY                         142
+# define EVP_R_EXPECTING_A_POLY1305_KEY                   164
+# define EVP_R_EXPECTING_A_SIPHASH_KEY                    175
+# define EVP_R_FINAL_ERROR                                188
+# define EVP_R_GENERATE_ERROR                             214
+# define EVP_R_GET_RAW_KEY_FAILED                         182
+# define EVP_R_ILLEGAL_SCRYPT_PARAMETERS                  171
+# define EVP_R_INACCESSIBLE_DOMAIN_PARAMETERS             204
+# define EVP_R_INACCESSIBLE_KEY                           203
+# define EVP_R_INITIALIZATION_ERROR                       134
+# define EVP_R_INPUT_NOT_INITIALIZED                      111
+# define EVP_R_INVALID_CUSTOM_LENGTH                      185
+# define EVP_R_INVALID_DIGEST                             152
+# define EVP_R_INVALID_IV_LENGTH                          194
+# define EVP_R_INVALID_KEY                                163
+# define EVP_R_INVALID_KEY_LENGTH                         130
+# define EVP_R_INVALID_LENGTH                             221
+# define EVP_R_INVALID_NULL_ALGORITHM                     218
+# define EVP_R_INVALID_OPERATION                          148
+# define EVP_R_INVALID_PROVIDER_FUNCTIONS                 193
+# define EVP_R_INVALID_SALT_LENGTH                        186
+# define EVP_R_INVALID_SECRET_LENGTH                      223
+# define EVP_R_INVALID_SEED_LENGTH                        220
+# define EVP_R_INVALID_VALUE                              222
+# define EVP_R_KEYMGMT_EXPORT_FAILURE                     205
+# define EVP_R_KEY_SETUP_FAILED                           180
+# define EVP_R_LOCKING_NOT_SUPPORTED                      213
+# define EVP_R_MEMORY_LIMIT_EXCEEDED                      172
+# define EVP_R_MESSAGE_DIGEST_IS_NULL                     159
+# define EVP_R_METHOD_NOT_SUPPORTED                       144
+# define EVP_R_MISSING_PARAMETERS                         103
+# define EVP_R_NOT_ABLE_TO_COPY_CTX                       190
+# define EVP_R_NOT_XOF_OR_INVALID_LENGTH                  178
+# define EVP_R_NO_CIPHER_SET                              131
+# define EVP_R_NO_DEFAULT_DIGEST                          158
+# define EVP_R_NO_DIGEST_SET                              139
+# define EVP_R_NO_IMPORT_FUNCTION                         206
+# define EVP_R_NO_KEYMGMT_AVAILABLE                       199
+# define EVP_R_NO_KEYMGMT_PRESENT                         196
+# define EVP_R_NO_KEY_SET                                 154
+# define EVP_R_NO_OPERATION_SET                           149
+# define EVP_R_NULL_MAC_PKEY_CTX                          208
+# define EVP_R_ONLY_ONESHOT_SUPPORTED                     177
+# define EVP_R_OPERATION_NOT_INITIALIZED                  151
+# define EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE   150
+# define EVP_R_OUTPUT_WOULD_OVERFLOW                      202
+# define EVP_R_PARAMETER_TOO_LARGE                        187
+# define EVP_R_PARTIALLY_OVERLAPPING                      162
+# define EVP_R_PBKDF2_ERROR                               181
+# define EVP_R_PKEY_APPLICATION_ASN1_METHOD_ALREADY_REGISTERED 179
+# define EVP_R_PRIVATE_KEY_DECODE_ERROR                   145
+# define EVP_R_PRIVATE_KEY_ENCODE_ERROR                   146
+# define EVP_R_PUBLIC_KEY_NOT_RSA                         106
+# define EVP_R_SETTING_XOF_FAILED                         227
+# define EVP_R_SET_DEFAULT_PROPERTY_FAILURE               209
+# define EVP_R_TOO_MANY_RECORDS                           183
+# define EVP_R_UNABLE_TO_ENABLE_LOCKING                   212
+# define EVP_R_UNABLE_TO_GET_MAXIMUM_REQUEST_SIZE         215
+# define EVP_R_UNABLE_TO_GET_RANDOM_STRENGTH              216
+# define EVP_R_UNABLE_TO_LOCK_CONTEXT                     211
+# define EVP_R_UNABLE_TO_SET_CALLBACKS                    217
+# define EVP_R_UNKNOWN_BITS                               166
+# define EVP_R_UNKNOWN_CIPHER                             160
+# define EVP_R_UNKNOWN_DIGEST                             161
+# define EVP_R_UNKNOWN_KEY_TYPE                           207
+# define EVP_R_UNKNOWN_MAX_SIZE                           167
+# define EVP_R_UNKNOWN_OPTION                             169
+# define EVP_R_UNKNOWN_PBE_ALGORITHM                      121
+# define EVP_R_UNKNOWN_SECURITY_BITS                      168
+# define EVP_R_UNSUPPORTED_ALGORITHM                      156
+# define EVP_R_UNSUPPORTED_CIPHER                         107
+# define EVP_R_UNSUPPORTED_KEYLENGTH                      123
+# define EVP_R_UNSUPPORTED_KEY_DERIVATION_FUNCTION        124
+# define EVP_R_UNSUPPORTED_KEY_SIZE                       108
+# define EVP_R_UNSUPPORTED_KEY_TYPE                       224
+# define EVP_R_UNSUPPORTED_NUMBER_OF_ROUNDS               135
+# define EVP_R_UNSUPPORTED_PRF                            125
+# define EVP_R_UNSUPPORTED_PRIVATE_KEY_ALGORITHM          118
+# define EVP_R_UNSUPPORTED_SALT_TYPE                      126
+# define EVP_R_UPDATE_ERROR                               189
+# define EVP_R_WRAP_MODE_NOT_ALLOWED                      170
+# define EVP_R_WRONG_FINAL_BLOCK_LENGTH                   109
+# define EVP_R_XTS_DATA_UNIT_IS_TOO_LARGE                 191
+# define EVP_R_XTS_DUPLICATED_KEYS                        192
+
+#endif
diff --git a/src/include/openssl/fips_names.h b/src/include/openssl/fips_names.h
new file mode 100644
index 0000000..5c77f6d
--- /dev/null
+++ b/src/include/openssl/fips_names.h
@@ -0,0 +1,77 @@
+/*
+ * Copyright 2019-2023 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_FIPS_NAMES_H
+# define OPENSSL_FIPS_NAMES_H
+# pragma once
+
+# ifdef __cplusplus
+extern "C" {
+# endif
+
+/*
+ * Parameter names that the FIPS Provider defines
+ */
+
+/*
+ * The calculated MAC of the module file (Used for FIPS Self Testing)
+ * Type: OSSL_PARAM_UTF8_STRING
+ */
+# define OSSL_PROV_FIPS_PARAM_MODULE_MAC      "module-mac"
+/*
+ * A version number for the fips install process (Used for FIPS Self Testing)
+ * Type: OSSL_PARAM_UTF8_STRING
+ */
+# define OSSL_PROV_FIPS_PARAM_INSTALL_VERSION "install-version"
+/*
+ * The calculated MAC of the install status indicator (Used for FIPS Self Testing)
+ * Type: OSSL_PARAM_UTF8_STRING
+ */
+# define OSSL_PROV_FIPS_PARAM_INSTALL_MAC     "install-mac"
+/*
+ * The install status indicator (Used for FIPS Self Testing)
+ * Type: OSSL_PARAM_UTF8_STRING
+ */
+# define OSSL_PROV_FIPS_PARAM_INSTALL_STATUS  "install-status"
+
+/*
+ * A boolean that determines if the FIPS conditional test errors result in
+ * the module entering an error state.
+ * Type: OSSL_PARAM_UTF8_STRING
+ */
+# define OSSL_PROV_FIPS_PARAM_CONDITIONAL_ERRORS "conditional-errors"
+
+/*
+ * A boolean that determines if the runtime FIPS security checks are performed.
+ * This is enabled by default.
+ * Type: OSSL_PARAM_UTF8_STRING
+ */
+# define OSSL_PROV_FIPS_PARAM_SECURITY_CHECKS "security-checks"
+
+/*
+ * A boolean that determines if the runtime FIPS check for TLS1_PRF EMS is performed.
+ * This is disabled by default.
+ * Type: OSSL_PARAM_UTF8_STRING
+ */
+# define OSSL_PROV_FIPS_PARAM_TLS1_PRF_EMS_CHECK "tls1-prf-ems-check"
+
+/*
+ * A boolean that determines if truncated digests can be used with Hash and HMAC
+ * DRBGs.  FIPS 140-3 IG D.R disallows such use for efficiency rather than
+ * security reasons.
+ * This is disabled by default.
+ * Type: OSSL_PARAM_UTF8_STRING
+ */
+# define OSSL_PROV_FIPS_PARAM_DRBG_TRUNC_DIGEST  "drbg-no-trunc-md"
+
+# ifdef __cplusplus
+}
+# endif
+
+#endif /* OPENSSL_FIPS_NAMES_H */
diff --git a/src/include/openssl/fipskey.h b/src/include/openssl/fipskey.h
new file mode 100644
index 0000000..ccc1d2f
--- /dev/null
+++ b/src/include/openssl/fipskey.h
@@ -0,0 +1,36 @@
+/*
+ * WARNING: do not edit!
+ * Generated by makefile from include\openssl\fipskey.h.in
+ *
+ * Copyright 2020-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_FIPSKEY_H
+# define OPENSSL_FIPSKEY_H
+# pragma once
+
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+/*
+ * The FIPS validation HMAC key, usable as an array initializer.
+ */
+#define FIPS_KEY_ELEMENTS \
+    0xf4, 0x55, 0x66, 0x50, 0xac, 0x31, 0xd3, 0x54, 0x61, 0x61, 0x0b, 0xac, 0x4e, 0xd8, 0x1b, 0x1a, 0x18, 0x1b, 0x2d, 0x8a, 0x43, 0xea, 0x28, 0x54, 0xcb, 0xae, 0x22, 0xca, 0x74, 0x56, 0x08, 0x13
+
+/*
+ * The FIPS validation key, as a string.
+ */
+#define FIPS_KEY_STRING "f4556650ac31d35461610bac4ed81b1a181b2d8a43ea2854cbae22ca74560813"
+
+# ifdef  __cplusplus
+}
+# endif
+
+#endif
diff --git a/src/include/openssl/hmac.h b/src/include/openssl/hmac.h
new file mode 100644
index 0000000..f9e1bff
--- /dev/null
+++ b/src/include/openssl/hmac.h
@@ -0,0 +1,62 @@
+/*
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_HMAC_H
+# define OPENSSL_HMAC_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_HMAC_H
+# endif
+
+# include <openssl/opensslconf.h>
+
+# include <openssl/evp.h>
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HMAC_MAX_MD_CBLOCK      200    /* Deprecated */
+# endif
+
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 size_t HMAC_size(const HMAC_CTX *e);
+OSSL_DEPRECATEDIN_3_0 HMAC_CTX *HMAC_CTX_new(void);
+OSSL_DEPRECATEDIN_3_0 int HMAC_CTX_reset(HMAC_CTX *ctx);
+OSSL_DEPRECATEDIN_3_0 void HMAC_CTX_free(HMAC_CTX *ctx);
+# endif
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+OSSL_DEPRECATEDIN_1_1_0 __owur int HMAC_Init(HMAC_CTX *ctx,
+                                             const void *key, int len,
+                                             const EVP_MD *md);
+# endif
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int HMAC_Init_ex(HMAC_CTX *ctx, const void *key, int len,
+                                       const EVP_MD *md, ENGINE *impl);
+OSSL_DEPRECATEDIN_3_0 int HMAC_Update(HMAC_CTX *ctx, const unsigned char *data,
+                                      size_t len);
+OSSL_DEPRECATEDIN_3_0 int HMAC_Final(HMAC_CTX *ctx, unsigned char *md,
+                                     unsigned int *len);
+OSSL_DEPRECATEDIN_3_0 __owur int HMAC_CTX_copy(HMAC_CTX *dctx, HMAC_CTX *sctx);
+OSSL_DEPRECATEDIN_3_0 void HMAC_CTX_set_flags(HMAC_CTX *ctx, unsigned long flags);
+OSSL_DEPRECATEDIN_3_0 const EVP_MD *HMAC_CTX_get_md(const HMAC_CTX *ctx);
+# endif
+
+unsigned char *HMAC(const EVP_MD *evp_md, const void *key, int key_len,
+                    const unsigned char *data, size_t data_len,
+                    unsigned char *md, unsigned int *md_len);
+
+# ifdef  __cplusplus
+}
+# endif
+
+#endif
diff --git a/src/include/openssl/hpke.h b/src/include/openssl/hpke.h
new file mode 100644
index 0000000..482acd2
--- /dev/null
+++ b/src/include/openssl/hpke.h
@@ -0,0 +1,169 @@
+/*
+ * Copyright 2022-2024 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+/* APIs and data structures for HPKE (RFC9180)  */
+#ifndef OSSL_HPKE_H
+# define OSSL_HPKE_H
+# pragma once
+
+# include <openssl/types.h>
+
+/* HPKE modes */
+# define OSSL_HPKE_MODE_BASE              0 /* Base mode  */
+# define OSSL_HPKE_MODE_PSK               1 /* Pre-shared key mode */
+# define OSSL_HPKE_MODE_AUTH              2 /* Authenticated mode */
+# define OSSL_HPKE_MODE_PSKAUTH           3 /* PSK+authenticated mode */
+
+/*
+ * Max for ikm, psk, pskid, info and exporter contexts.
+ * RFC9180, section 7.2.1 RECOMMENDS 64 octets but we have test vectors from
+ * Appendix A.6.1 with a 66 octet IKM so we'll allow that.
+ */
+# define OSSL_HPKE_MAX_PARMLEN        66
+# define OSSL_HPKE_MIN_PSKLEN         32
+# define OSSL_HPKE_MAX_INFOLEN        1024
+
+/*
+ * The (16bit) HPKE algorithm ID IANA codepoints
+ * If/when new IANA codepoints are added there are tables in
+ * crypto/hpke/hpke_util.c that must also be updated.
+ */
+# define OSSL_HPKE_KEM_ID_RESERVED         0x0000 /* not used */
+# define OSSL_HPKE_KEM_ID_P256             0x0010 /* NIST P-256 */
+# define OSSL_HPKE_KEM_ID_P384             0x0011 /* NIST P-384 */
+# define OSSL_HPKE_KEM_ID_P521             0x0012 /* NIST P-521 */
+# define OSSL_HPKE_KEM_ID_X25519           0x0020 /* Curve25519 */
+# define OSSL_HPKE_KEM_ID_X448             0x0021 /* Curve448 */
+
+# define OSSL_HPKE_KDF_ID_RESERVED         0x0000 /* not used */
+# define OSSL_HPKE_KDF_ID_HKDF_SHA256      0x0001 /* HKDF-SHA256 */
+# define OSSL_HPKE_KDF_ID_HKDF_SHA384      0x0002 /* HKDF-SHA384 */
+# define OSSL_HPKE_KDF_ID_HKDF_SHA512      0x0003 /* HKDF-SHA512 */
+
+# define OSSL_HPKE_AEAD_ID_RESERVED        0x0000 /* not used */
+# define OSSL_HPKE_AEAD_ID_AES_GCM_128     0x0001 /* AES-GCM-128 */
+# define OSSL_HPKE_AEAD_ID_AES_GCM_256     0x0002 /* AES-GCM-256 */
+# define OSSL_HPKE_AEAD_ID_CHACHA_POLY1305 0x0003 /* Chacha20-Poly1305 */
+# define OSSL_HPKE_AEAD_ID_EXPORTONLY      0xFFFF /* export-only fake ID */
+
+/* strings for suite components */
+# define OSSL_HPKE_KEMSTR_P256        "P-256"              /* KEM id 0x10 */
+# define OSSL_HPKE_KEMSTR_P384        "P-384"              /* KEM id 0x11 */
+# define OSSL_HPKE_KEMSTR_P521        "P-521"              /* KEM id 0x12 */
+# define OSSL_HPKE_KEMSTR_X25519      "X25519"             /* KEM id 0x20 */
+# define OSSL_HPKE_KEMSTR_X448        "X448"               /* KEM id 0x21 */
+# define OSSL_HPKE_KDFSTR_256         "hkdf-sha256"        /* KDF id 1 */
+# define OSSL_HPKE_KDFSTR_384         "hkdf-sha384"        /* KDF id 2 */
+# define OSSL_HPKE_KDFSTR_512         "hkdf-sha512"        /* KDF id 3 */
+# define OSSL_HPKE_AEADSTR_AES128GCM  "aes-128-gcm"        /* AEAD id 1 */
+# define OSSL_HPKE_AEADSTR_AES256GCM  "aes-256-gcm"        /* AEAD id 2 */
+# define OSSL_HPKE_AEADSTR_CP         "chacha20-poly1305"  /* AEAD id 3 */
+# define OSSL_HPKE_AEADSTR_EXP        "exporter"           /* AEAD id 0xff */
+
+/*
+ * Roles for use in creating an OSSL_HPKE_CTX, most
+ * important use of this is to control nonce reuse.
+ */
+# define OSSL_HPKE_ROLE_SENDER 0
+# define OSSL_HPKE_ROLE_RECEIVER 1
+
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+typedef struct {
+    uint16_t    kem_id; /* Key Encapsulation Method id */
+    uint16_t    kdf_id; /* Key Derivation Function id */
+    uint16_t    aead_id; /* AEAD alg id */
+} OSSL_HPKE_SUITE;
+
+/**
+ * Suite constants, use this like:
+ *          OSSL_HPKE_SUITE myvar = OSSL_HPKE_SUITE_DEFAULT;
+ */
+# ifndef OPENSSL_NO_ECX
+#  define OSSL_HPKE_SUITE_DEFAULT \
+    {\
+        OSSL_HPKE_KEM_ID_X25519, \
+        OSSL_HPKE_KDF_ID_HKDF_SHA256, \
+        OSSL_HPKE_AEAD_ID_AES_GCM_128 \
+    }
+# else
+#  define OSSL_HPKE_SUITE_DEFAULT \
+    {\
+        OSSL_HPKE_KEM_ID_P256, \
+        OSSL_HPKE_KDF_ID_HKDF_SHA256, \
+        OSSL_HPKE_AEAD_ID_AES_GCM_128 \
+    }
+#endif
+
+typedef struct ossl_hpke_ctx_st OSSL_HPKE_CTX;
+
+OSSL_HPKE_CTX *OSSL_HPKE_CTX_new(int mode, OSSL_HPKE_SUITE suite, int role,
+                                 OSSL_LIB_CTX *libctx, const char *propq);
+void OSSL_HPKE_CTX_free(OSSL_HPKE_CTX *ctx);
+
+int OSSL_HPKE_encap(OSSL_HPKE_CTX *ctx,
+                    unsigned char *enc, size_t *enclen,
+                    const unsigned char *pub, size_t publen,
+                    const unsigned char *info, size_t infolen);
+int OSSL_HPKE_seal(OSSL_HPKE_CTX *ctx,
+                   unsigned char *ct, size_t *ctlen,
+                   const unsigned char *aad, size_t aadlen,
+                   const unsigned char *pt, size_t ptlen);
+
+int OSSL_HPKE_keygen(OSSL_HPKE_SUITE suite,
+                     unsigned char *pub, size_t *publen, EVP_PKEY **priv,
+                     const unsigned char *ikm, size_t ikmlen,
+                     OSSL_LIB_CTX *libctx, const char *propq);
+int OSSL_HPKE_decap(OSSL_HPKE_CTX *ctx,
+                    const unsigned char *enc, size_t enclen,
+                    EVP_PKEY *recippriv,
+                    const unsigned char *info, size_t infolen);
+int OSSL_HPKE_open(OSSL_HPKE_CTX *ctx,
+                   unsigned char *pt, size_t *ptlen,
+                   const unsigned char *aad, size_t aadlen,
+                   const unsigned char *ct, size_t ctlen);
+
+int OSSL_HPKE_export(OSSL_HPKE_CTX *ctx,
+                     unsigned char *secret,
+                     size_t secretlen,
+                     const unsigned char *label,
+                     size_t labellen);
+
+int OSSL_HPKE_CTX_set1_authpriv(OSSL_HPKE_CTX *ctx, EVP_PKEY *priv);
+int OSSL_HPKE_CTX_set1_authpub(OSSL_HPKE_CTX *ctx,
+                               const unsigned char *pub,
+                               size_t publen);
+int OSSL_HPKE_CTX_set1_psk(OSSL_HPKE_CTX *ctx,
+                           const char *pskid,
+                           const unsigned char *psk, size_t psklen);
+
+int OSSL_HPKE_CTX_set1_ikme(OSSL_HPKE_CTX *ctx,
+                            const unsigned char *ikme, size_t ikmelen);
+
+int OSSL_HPKE_CTX_set_seq(OSSL_HPKE_CTX *ctx, uint64_t seq);
+int OSSL_HPKE_CTX_get_seq(OSSL_HPKE_CTX *ctx, uint64_t *seq);
+
+int OSSL_HPKE_suite_check(OSSL_HPKE_SUITE suite);
+int OSSL_HPKE_get_grease_value(const OSSL_HPKE_SUITE *suite_in,
+                               OSSL_HPKE_SUITE *suite,
+                               unsigned char *enc, size_t *enclen,
+                               unsigned char *ct, size_t ctlen,
+                               OSSL_LIB_CTX *libctx, const char *propq);
+int OSSL_HPKE_str2suite(const char *str, OSSL_HPKE_SUITE *suite);
+size_t OSSL_HPKE_get_ciphertext_size(OSSL_HPKE_SUITE suite, size_t clearlen);
+size_t OSSL_HPKE_get_public_encap_size(OSSL_HPKE_SUITE suite);
+size_t OSSL_HPKE_get_recommended_ikmelen(OSSL_HPKE_SUITE suite);
+
+# ifdef  __cplusplus
+}
+# endif
+
+#endif
diff --git a/src/include/openssl/http.h b/src/include/openssl/http.h
new file mode 100644
index 0000000..8f4e9da
--- /dev/null
+++ b/src/include/openssl/http.h
@@ -0,0 +1,117 @@
+/*
+ * Copyright 2000-2024 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright Siemens AG 2018-2020
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_HTTP_H
+# define OPENSSL_HTTP_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+
+# include <openssl/bio.h>
+# include <openssl/asn1.h>
+# include <openssl/conf.h>
+
+
+# ifdef __cplusplus
+extern "C" {
+# endif
+
+# define OSSL_HTTP_NAME "http"
+# define OSSL_HTTPS_NAME "https"
+# define OSSL_HTTP_PREFIX OSSL_HTTP_NAME"://"
+# define OSSL_HTTPS_PREFIX OSSL_HTTPS_NAME"://"
+# define OSSL_HTTP_PORT "80"
+# define OSSL_HTTPS_PORT "443"
+# define OPENSSL_NO_PROXY "NO_PROXY"
+# define OPENSSL_HTTP_PROXY "HTTP_PROXY"
+# define OPENSSL_HTTPS_PROXY "HTTPS_PROXY"
+
+# ifndef OPENSSL_NO_HTTP
+
+#define OSSL_HTTP_DEFAULT_MAX_LINE_LEN (4 * 1024)
+#define OSSL_HTTP_DEFAULT_MAX_RESP_LEN (100 * 1024)
+#define OSSL_HTTP_DEFAULT_MAX_RESP_HDR_LINES 256
+
+
+/* Low-level HTTP API */
+OSSL_HTTP_REQ_CTX *OSSL_HTTP_REQ_CTX_new(BIO *wbio, BIO *rbio, int buf_size);
+void OSSL_HTTP_REQ_CTX_free(OSSL_HTTP_REQ_CTX *rctx);
+int OSSL_HTTP_REQ_CTX_set_request_line(OSSL_HTTP_REQ_CTX *rctx, int method_POST,
+                                       const char *server, const char *port,
+                                       const char *path);
+int OSSL_HTTP_REQ_CTX_add1_header(OSSL_HTTP_REQ_CTX *rctx,
+                                  const char *name, const char *value);
+int OSSL_HTTP_REQ_CTX_set_expected(OSSL_HTTP_REQ_CTX *rctx,
+                                   const char *content_type, int asn1,
+                                   int timeout, int keep_alive);
+int OSSL_HTTP_REQ_CTX_set1_req(OSSL_HTTP_REQ_CTX *rctx, const char *content_type,
+                               const ASN1_ITEM *it, const ASN1_VALUE *req);
+int OSSL_HTTP_REQ_CTX_nbio(OSSL_HTTP_REQ_CTX *rctx);
+int OSSL_HTTP_REQ_CTX_nbio_d2i(OSSL_HTTP_REQ_CTX *rctx,
+                               ASN1_VALUE **pval, const ASN1_ITEM *it);
+BIO *OSSL_HTTP_REQ_CTX_exchange(OSSL_HTTP_REQ_CTX *rctx);
+BIO *OSSL_HTTP_REQ_CTX_get0_mem_bio(const OSSL_HTTP_REQ_CTX *rctx);
+size_t OSSL_HTTP_REQ_CTX_get_resp_len(const OSSL_HTTP_REQ_CTX *rctx);
+void OSSL_HTTP_REQ_CTX_set_max_response_length(OSSL_HTTP_REQ_CTX *rctx,
+                                               unsigned long len);
+int OSSL_HTTP_is_alive(const OSSL_HTTP_REQ_CTX *rctx);
+
+/* High-level HTTP API */
+typedef BIO *(*OSSL_HTTP_bio_cb_t)(BIO *bio, void *arg, int connect, int detail);
+OSSL_HTTP_REQ_CTX *OSSL_HTTP_open(const char *server, const char *port,
+                                  const char *proxy, const char *no_proxy,
+                                  int use_ssl, BIO *bio, BIO *rbio,
+                                  OSSL_HTTP_bio_cb_t bio_update_fn, void *arg,
+                                  int buf_size, int overall_timeout);
+int OSSL_HTTP_proxy_connect(BIO *bio, const char *server, const char *port,
+                            const char *proxyuser, const char *proxypass,
+                            int timeout, BIO *bio_err, const char *prog);
+int OSSL_HTTP_set1_request(OSSL_HTTP_REQ_CTX *rctx, const char *path,
+                           const STACK_OF(CONF_VALUE) *headers,
+                           const char *content_type, BIO *req,
+                           const char *expected_content_type, int expect_asn1,
+                           size_t max_resp_len, int timeout, int keep_alive);
+BIO *OSSL_HTTP_exchange(OSSL_HTTP_REQ_CTX *rctx, char **redirection_url);
+BIO *OSSL_HTTP_get(const char *url, const char *proxy, const char *no_proxy,
+                   BIO *bio, BIO *rbio,
+                   OSSL_HTTP_bio_cb_t bio_update_fn, void *arg,
+                   int buf_size, const STACK_OF(CONF_VALUE) *headers,
+                   const char *expected_content_type, int expect_asn1,
+                   size_t max_resp_len, int timeout);
+BIO *OSSL_HTTP_transfer(OSSL_HTTP_REQ_CTX **prctx,
+                        const char *server, const char *port,
+                        const char *path, int use_ssl,
+                        const char *proxy, const char *no_proxy,
+                        BIO *bio, BIO *rbio,
+                        OSSL_HTTP_bio_cb_t bio_update_fn, void *arg,
+                        int buf_size, const STACK_OF(CONF_VALUE) *headers,
+                        const char *content_type, BIO *req,
+                        const char *expected_content_type, int expect_asn1,
+                        size_t max_resp_len, int timeout, int keep_alive);
+int OSSL_HTTP_close(OSSL_HTTP_REQ_CTX *rctx, int ok);
+
+/* Auxiliary functions */
+int OSSL_parse_url(const char *url, char **pscheme, char **puser, char **phost,
+                   char **pport, int *pport_num,
+                   char **ppath, char **pquery, char **pfrag);
+int OSSL_HTTP_parse_url(const char *url, int *pssl, char **puser, char **phost,
+                        char **pport, int *pport_num,
+                        char **ppath, char **pquery, char **pfrag);
+const char *OSSL_HTTP_adapt_proxy(const char *proxy, const char *no_proxy,
+                                  const char *server, int use_ssl);
+
+void OSSL_HTTP_REQ_CTX_set_max_response_hdr_lines(OSSL_HTTP_REQ_CTX *rctx,
+                                                  size_t count);
+
+# endif /* !defined(OPENSSL_NO_HTTP) */
+# ifdef  __cplusplus
+}
+# endif
+#endif /* !defined(OPENSSL_HTTP_H) */
diff --git a/src/include/openssl/httperr.h b/src/include/openssl/httperr.h
new file mode 100644
index 0000000..ae7f00c
--- /dev/null
+++ b/src/include/openssl/httperr.h
@@ -0,0 +1,56 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2024 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_HTTPERR_H
+# define OPENSSL_HTTPERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+
+/*
+ * HTTP reason codes.
+ */
+# define HTTP_R_ASN1_LEN_EXCEEDS_MAX_RESP_LEN             108
+# define HTTP_R_CONNECT_FAILURE                           100
+# define HTTP_R_ERROR_PARSING_ASN1_LENGTH                 109
+# define HTTP_R_ERROR_PARSING_CONTENT_LENGTH              119
+# define HTTP_R_ERROR_PARSING_URL                         101
+# define HTTP_R_ERROR_RECEIVING                           103
+# define HTTP_R_ERROR_SENDING                             102
+# define HTTP_R_FAILED_READING_DATA                       128
+# define HTTP_R_HEADER_PARSE_ERROR                        126
+# define HTTP_R_INCONSISTENT_CONTENT_LENGTH               120
+# define HTTP_R_INVALID_PORT_NUMBER                       123
+# define HTTP_R_INVALID_URL_PATH                          125
+# define HTTP_R_INVALID_URL_SCHEME                        124
+# define HTTP_R_MAX_RESP_LEN_EXCEEDED                     117
+# define HTTP_R_MISSING_ASN1_ENCODING                     110
+# define HTTP_R_MISSING_CONTENT_TYPE                      121
+# define HTTP_R_MISSING_REDIRECT_LOCATION                 111
+# define HTTP_R_RECEIVED_ERROR                            105
+# define HTTP_R_RECEIVED_WRONG_HTTP_VERSION               106
+# define HTTP_R_REDIRECTION_FROM_HTTPS_TO_HTTP            112
+# define HTTP_R_REDIRECTION_NOT_ENABLED                   116
+# define HTTP_R_RESPONSE_LINE_TOO_LONG                    113
+# define HTTP_R_RESPONSE_PARSE_ERROR                      104
+# define HTTP_R_RESPONSE_TOO_MANY_HDRLINES                130
+# define HTTP_R_RETRY_TIMEOUT                             129
+# define HTTP_R_SERVER_CANCELED_CONNECTION                127
+# define HTTP_R_SOCK_NOT_SUPPORTED                        122
+# define HTTP_R_STATUS_CODE_UNSUPPORTED                   114
+# define HTTP_R_TLS_NOT_ENABLED                           107
+# define HTTP_R_TOO_MANY_REDIRECTIONS                     115
+# define HTTP_R_UNEXPECTED_CONTENT_TYPE                   118
+
+#endif
diff --git a/src/include/openssl/idea.h b/src/include/openssl/idea.h
new file mode 100644
index 0000000..1f9bb3b
--- /dev/null
+++ b/src/include/openssl/idea.h
@@ -0,0 +1,82 @@
+/*
+ * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_IDEA_H
+# define OPENSSL_IDEA_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_IDEA_H
+# endif
+
+# include <openssl/opensslconf.h>
+
+# ifndef OPENSSL_NO_IDEA
+#  ifdef  __cplusplus
+extern "C" {
+#  endif
+
+#  define IDEA_BLOCK      8
+#  define IDEA_KEY_LENGTH 16
+
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+
+typedef unsigned int IDEA_INT;
+
+#   define IDEA_ENCRYPT    1
+#   define IDEA_DECRYPT    0
+
+typedef struct idea_key_st {
+    IDEA_INT data[9][6];
+} IDEA_KEY_SCHEDULE;
+#endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 const char *IDEA_options(void);
+OSSL_DEPRECATEDIN_3_0 void IDEA_ecb_encrypt(const unsigned char *in,
+                                            unsigned char *out,
+                                            IDEA_KEY_SCHEDULE *ks);
+OSSL_DEPRECATEDIN_3_0 void IDEA_set_encrypt_key(const unsigned char *key,
+                                                IDEA_KEY_SCHEDULE *ks);
+OSSL_DEPRECATEDIN_3_0 void IDEA_set_decrypt_key(IDEA_KEY_SCHEDULE *ek,
+                                                IDEA_KEY_SCHEDULE *dk);
+OSSL_DEPRECATEDIN_3_0 void IDEA_cbc_encrypt(const unsigned char *in,
+                                            unsigned char *out, long length,
+                                            IDEA_KEY_SCHEDULE *ks,
+                                            unsigned char *iv, int enc);
+OSSL_DEPRECATEDIN_3_0 void IDEA_cfb64_encrypt(const unsigned char *in,
+                                              unsigned char *out, long length,
+                                              IDEA_KEY_SCHEDULE *ks,
+                                              unsigned char *iv, int *num,
+                                              int enc);
+OSSL_DEPRECATEDIN_3_0 void IDEA_ofb64_encrypt(const unsigned char *in,
+                                              unsigned char *out, long length,
+                                              IDEA_KEY_SCHEDULE *ks,
+                                              unsigned char *iv, int *num);
+OSSL_DEPRECATEDIN_3_0 void IDEA_encrypt(unsigned long *in,
+                                        IDEA_KEY_SCHEDULE *ks);
+#endif
+
+#  ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#   define idea_options          IDEA_options
+#   define idea_ecb_encrypt      IDEA_ecb_encrypt
+#   define idea_set_encrypt_key  IDEA_set_encrypt_key
+#   define idea_set_decrypt_key  IDEA_set_decrypt_key
+#   define idea_cbc_encrypt      IDEA_cbc_encrypt
+#   define idea_cfb64_encrypt    IDEA_cfb64_encrypt
+#   define idea_ofb64_encrypt    IDEA_ofb64_encrypt
+#   define idea_encrypt          IDEA_encrypt
+#  endif
+
+#  ifdef  __cplusplus
+}
+#  endif
+# endif
+
+#endif
diff --git a/src/include/openssl/kdf.h b/src/include/openssl/kdf.h
new file mode 100644
index 0000000..0983230
--- /dev/null
+++ b/src/include/openssl/kdf.h
@@ -0,0 +1,138 @@
+/*
+ * Copyright 2016-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_KDF_H
+# define OPENSSL_KDF_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_KDF_H
+# endif
+
+# include <stdarg.h>
+# include <stddef.h>
+# include <openssl/types.h>
+# include <openssl/core.h>
+
+# ifdef __cplusplus
+extern "C" {
+# endif
+
+int EVP_KDF_up_ref(EVP_KDF *kdf);
+void EVP_KDF_free(EVP_KDF *kdf);
+EVP_KDF *EVP_KDF_fetch(OSSL_LIB_CTX *libctx, const char *algorithm,
+                       const char *properties);
+
+EVP_KDF_CTX *EVP_KDF_CTX_new(EVP_KDF *kdf);
+void EVP_KDF_CTX_free(EVP_KDF_CTX *ctx);
+EVP_KDF_CTX *EVP_KDF_CTX_dup(const EVP_KDF_CTX *src);
+const char *EVP_KDF_get0_description(const EVP_KDF *kdf);
+int EVP_KDF_is_a(const EVP_KDF *kdf, const char *name);
+const char *EVP_KDF_get0_name(const EVP_KDF *kdf);
+const OSSL_PROVIDER *EVP_KDF_get0_provider(const EVP_KDF *kdf);
+const EVP_KDF *EVP_KDF_CTX_kdf(EVP_KDF_CTX *ctx);
+
+void EVP_KDF_CTX_reset(EVP_KDF_CTX *ctx);
+size_t EVP_KDF_CTX_get_kdf_size(EVP_KDF_CTX *ctx);
+int EVP_KDF_derive(EVP_KDF_CTX *ctx, unsigned char *key, size_t keylen,
+                   const OSSL_PARAM params[]);
+int EVP_KDF_get_params(EVP_KDF *kdf, OSSL_PARAM params[]);
+int EVP_KDF_CTX_get_params(EVP_KDF_CTX *ctx, OSSL_PARAM params[]);
+int EVP_KDF_CTX_set_params(EVP_KDF_CTX *ctx, const OSSL_PARAM params[]);
+const OSSL_PARAM *EVP_KDF_gettable_params(const EVP_KDF *kdf);
+const OSSL_PARAM *EVP_KDF_gettable_ctx_params(const EVP_KDF *kdf);
+const OSSL_PARAM *EVP_KDF_settable_ctx_params(const EVP_KDF *kdf);
+const OSSL_PARAM *EVP_KDF_CTX_gettable_params(EVP_KDF_CTX *ctx);
+const OSSL_PARAM *EVP_KDF_CTX_settable_params(EVP_KDF_CTX *ctx);
+
+void EVP_KDF_do_all_provided(OSSL_LIB_CTX *libctx,
+                             void (*fn)(EVP_KDF *kdf, void *arg),
+                             void *arg);
+int EVP_KDF_names_do_all(const EVP_KDF *kdf,
+                         void (*fn)(const char *name, void *data),
+                         void *data);
+
+# define EVP_KDF_HKDF_MODE_EXTRACT_AND_EXPAND  0
+# define EVP_KDF_HKDF_MODE_EXTRACT_ONLY        1
+# define EVP_KDF_HKDF_MODE_EXPAND_ONLY         2
+
+#define EVP_KDF_SSHKDF_TYPE_INITIAL_IV_CLI_TO_SRV     65
+#define EVP_KDF_SSHKDF_TYPE_INITIAL_IV_SRV_TO_CLI     66
+#define EVP_KDF_SSHKDF_TYPE_ENCRYPTION_KEY_CLI_TO_SRV 67
+#define EVP_KDF_SSHKDF_TYPE_ENCRYPTION_KEY_SRV_TO_CLI 68
+#define EVP_KDF_SSHKDF_TYPE_INTEGRITY_KEY_CLI_TO_SRV  69
+#define EVP_KDF_SSHKDF_TYPE_INTEGRITY_KEY_SRV_TO_CLI  70
+
+/**** The legacy PKEY-based KDF API follows. ****/
+
+# define EVP_PKEY_CTRL_TLS_MD                   (EVP_PKEY_ALG_CTRL)
+# define EVP_PKEY_CTRL_TLS_SECRET               (EVP_PKEY_ALG_CTRL + 1)
+# define EVP_PKEY_CTRL_TLS_SEED                 (EVP_PKEY_ALG_CTRL + 2)
+# define EVP_PKEY_CTRL_HKDF_MD                  (EVP_PKEY_ALG_CTRL + 3)
+# define EVP_PKEY_CTRL_HKDF_SALT                (EVP_PKEY_ALG_CTRL + 4)
+# define EVP_PKEY_CTRL_HKDF_KEY                 (EVP_PKEY_ALG_CTRL + 5)
+# define EVP_PKEY_CTRL_HKDF_INFO                (EVP_PKEY_ALG_CTRL + 6)
+# define EVP_PKEY_CTRL_HKDF_MODE                (EVP_PKEY_ALG_CTRL + 7)
+# define EVP_PKEY_CTRL_PASS                     (EVP_PKEY_ALG_CTRL + 8)
+# define EVP_PKEY_CTRL_SCRYPT_SALT              (EVP_PKEY_ALG_CTRL + 9)
+# define EVP_PKEY_CTRL_SCRYPT_N                 (EVP_PKEY_ALG_CTRL + 10)
+# define EVP_PKEY_CTRL_SCRYPT_R                 (EVP_PKEY_ALG_CTRL + 11)
+# define EVP_PKEY_CTRL_SCRYPT_P                 (EVP_PKEY_ALG_CTRL + 12)
+# define EVP_PKEY_CTRL_SCRYPT_MAXMEM_BYTES      (EVP_PKEY_ALG_CTRL + 13)
+
+# define EVP_PKEY_HKDEF_MODE_EXTRACT_AND_EXPAND \
+            EVP_KDF_HKDF_MODE_EXTRACT_AND_EXPAND
+# define EVP_PKEY_HKDEF_MODE_EXTRACT_ONLY       \
+            EVP_KDF_HKDF_MODE_EXTRACT_ONLY
+# define EVP_PKEY_HKDEF_MODE_EXPAND_ONLY        \
+            EVP_KDF_HKDF_MODE_EXPAND_ONLY
+
+int EVP_PKEY_CTX_set_tls1_prf_md(EVP_PKEY_CTX *ctx, const EVP_MD *md);
+
+int EVP_PKEY_CTX_set1_tls1_prf_secret(EVP_PKEY_CTX *pctx,
+                                      const unsigned char *sec, int seclen);
+
+int EVP_PKEY_CTX_add1_tls1_prf_seed(EVP_PKEY_CTX *pctx,
+                                    const unsigned char *seed, int seedlen);
+
+int EVP_PKEY_CTX_set_hkdf_md(EVP_PKEY_CTX *ctx, const EVP_MD *md);
+
+int EVP_PKEY_CTX_set1_hkdf_salt(EVP_PKEY_CTX *ctx,
+                                const unsigned char *salt, int saltlen);
+
+int EVP_PKEY_CTX_set1_hkdf_key(EVP_PKEY_CTX *ctx,
+                               const unsigned char *key, int keylen);
+
+int EVP_PKEY_CTX_add1_hkdf_info(EVP_PKEY_CTX *ctx,
+                                const unsigned char *info, int infolen);
+
+int EVP_PKEY_CTX_set_hkdf_mode(EVP_PKEY_CTX *ctx, int mode);
+# define EVP_PKEY_CTX_hkdf_mode EVP_PKEY_CTX_set_hkdf_mode
+
+int EVP_PKEY_CTX_set1_pbe_pass(EVP_PKEY_CTX *ctx, const char *pass,
+                               int passlen);
+
+int EVP_PKEY_CTX_set1_scrypt_salt(EVP_PKEY_CTX *ctx,
+                                  const unsigned char *salt, int saltlen);
+
+int EVP_PKEY_CTX_set_scrypt_N(EVP_PKEY_CTX *ctx, uint64_t n);
+
+int EVP_PKEY_CTX_set_scrypt_r(EVP_PKEY_CTX *ctx, uint64_t r);
+
+int EVP_PKEY_CTX_set_scrypt_p(EVP_PKEY_CTX *ctx, uint64_t p);
+
+int EVP_PKEY_CTX_set_scrypt_maxmem_bytes(EVP_PKEY_CTX *ctx,
+                                         uint64_t maxmem_bytes);
+
+
+# ifdef __cplusplus
+}
+# endif
+#endif
diff --git a/src/include/openssl/kdferr.h b/src/include/openssl/kdferr.h
new file mode 100644
index 0000000..963d766
--- /dev/null
+++ b/src/include/openssl/kdferr.h
@@ -0,0 +1,16 @@
+/*
+ * Copyright 2020-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_KDFERR_H
+# define OPENSSL_KDFERR_H
+# pragma once
+
+#include <openssl/cryptoerr_legacy.h>
+
+#endif /* !defined(OPENSSL_KDFERR_H) */
diff --git a/src/include/openssl/lhash.h b/src/include/openssl/lhash.h
new file mode 100644
index 0000000..62c55b2
--- /dev/null
+++ b/src/include/openssl/lhash.h
@@ -0,0 +1,398 @@
+/*
+ * Copyright 1995-2024 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+
+
+/*
+ * Header for dynamic hash table routines Author - Eric Young
+ */
+
+#ifndef OPENSSL_LHASH_H
+# define OPENSSL_LHASH_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_LHASH_H
+# endif
+
+# include <openssl/e_os2.h>
+# include <openssl/bio.h>
+# ifndef OPENSSL_NO_STDIO
+#  include <stdio.h>
+# endif
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+typedef struct lhash_node_st OPENSSL_LH_NODE;
+typedef int (*OPENSSL_LH_COMPFUNC) (const void *, const void *);
+typedef int (*OPENSSL_LH_COMPFUNCTHUNK) (const void *, const void *, OPENSSL_LH_COMPFUNC cfn);
+typedef unsigned long (*OPENSSL_LH_HASHFUNC) (const void *);
+typedef unsigned long (*OPENSSL_LH_HASHFUNCTHUNK) (const void *, OPENSSL_LH_HASHFUNC hfn);
+typedef void (*OPENSSL_LH_DOALL_FUNC) (void *);
+typedef void (*OPENSSL_LH_DOALL_FUNC_THUNK) (void *, OPENSSL_LH_DOALL_FUNC doall);
+typedef void (*OPENSSL_LH_DOALL_FUNCARG) (void *, void *);
+typedef void (*OPENSSL_LH_DOALL_FUNCARG_THUNK) (void *, void *, OPENSSL_LH_DOALL_FUNCARG doall);
+typedef struct lhash_st OPENSSL_LHASH;
+
+/*
+ * Macros for declaring and implementing type-safe wrappers for LHASH
+ * callbacks. This way, callbacks can be provided to LHASH structures without
+ * function pointer casting and the macro-defined callbacks provide
+ * per-variable casting before deferring to the underlying type-specific
+ * callbacks. NB: It is possible to place a "static" in front of both the
+ * DECLARE and IMPLEMENT macros if the functions are strictly internal.
+ */
+
+/* First: "hash" functions */
+# define DECLARE_LHASH_HASH_FN(name, o_type) \
+        unsigned long name##_LHASH_HASH(const void *);
+# define IMPLEMENT_LHASH_HASH_FN(name, o_type) \
+        unsigned long name##_LHASH_HASH(const void *arg) { \
+                const o_type *a = arg; \
+                return name##_hash(a); }
+# define LHASH_HASH_FN(name) name##_LHASH_HASH
+
+/* Second: "compare" functions */
+# define DECLARE_LHASH_COMP_FN(name, o_type) \
+        int name##_LHASH_COMP(const void *, const void *);
+# define IMPLEMENT_LHASH_COMP_FN(name, o_type) \
+        int name##_LHASH_COMP(const void *arg1, const void *arg2) { \
+                const o_type *a = arg1;             \
+                const o_type *b = arg2; \
+                return name##_cmp(a,b); }
+# define LHASH_COMP_FN(name) name##_LHASH_COMP
+
+/* Fourth: "doall_arg" functions */
+# define DECLARE_LHASH_DOALL_ARG_FN(name, o_type, a_type) \
+        void name##_LHASH_DOALL_ARG(void *, void *);
+# define IMPLEMENT_LHASH_DOALL_ARG_FN(name, o_type, a_type) \
+        void name##_LHASH_DOALL_ARG(void *arg1, void *arg2) { \
+                o_type *a = arg1; \
+                a_type *b = arg2; \
+                name##_doall_arg(a, b); }
+# define LHASH_DOALL_ARG_FN(name) name##_LHASH_DOALL_ARG
+
+
+# define LH_LOAD_MULT    256
+
+int OPENSSL_LH_error(OPENSSL_LHASH *lh);
+OPENSSL_LHASH *OPENSSL_LH_new(OPENSSL_LH_HASHFUNC h, OPENSSL_LH_COMPFUNC c);
+OPENSSL_LHASH *OPENSSL_LH_set_thunks(OPENSSL_LHASH *lh,
+                                     OPENSSL_LH_HASHFUNCTHUNK hw,
+                                     OPENSSL_LH_COMPFUNCTHUNK cw,
+                                     OPENSSL_LH_DOALL_FUNC_THUNK daw,
+                                     OPENSSL_LH_DOALL_FUNCARG_THUNK daaw);
+void OPENSSL_LH_free(OPENSSL_LHASH *lh);
+void OPENSSL_LH_flush(OPENSSL_LHASH *lh);
+void *OPENSSL_LH_insert(OPENSSL_LHASH *lh, void *data);
+void *OPENSSL_LH_delete(OPENSSL_LHASH *lh, const void *data);
+void *OPENSSL_LH_retrieve(OPENSSL_LHASH *lh, const void *data);
+void OPENSSL_LH_doall(OPENSSL_LHASH *lh, OPENSSL_LH_DOALL_FUNC func);
+void OPENSSL_LH_doall_arg(OPENSSL_LHASH *lh,
+                          OPENSSL_LH_DOALL_FUNCARG func, void *arg);
+void OPENSSL_LH_doall_arg_thunk(OPENSSL_LHASH *lh,
+                          OPENSSL_LH_DOALL_FUNCARG_THUNK daaw,
+                          OPENSSL_LH_DOALL_FUNCARG fn, void *arg);
+
+unsigned long OPENSSL_LH_strhash(const char *c);
+unsigned long OPENSSL_LH_num_items(const OPENSSL_LHASH *lh);
+unsigned long OPENSSL_LH_get_down_load(const OPENSSL_LHASH *lh);
+void OPENSSL_LH_set_down_load(OPENSSL_LHASH *lh, unsigned long down_load);
+
+# ifndef OPENSSL_NO_STDIO
+#  ifndef OPENSSL_NO_DEPRECATED_3_1
+OSSL_DEPRECATEDIN_3_1 void OPENSSL_LH_stats(const OPENSSL_LHASH *lh, FILE *fp);
+OSSL_DEPRECATEDIN_3_1 void OPENSSL_LH_node_stats(const OPENSSL_LHASH *lh, FILE *fp);
+OSSL_DEPRECATEDIN_3_1 void OPENSSL_LH_node_usage_stats(const OPENSSL_LHASH *lh, FILE *fp);
+#  endif
+# endif
+# ifndef OPENSSL_NO_DEPRECATED_3_1
+OSSL_DEPRECATEDIN_3_1 void OPENSSL_LH_stats_bio(const OPENSSL_LHASH *lh, BIO *out);
+OSSL_DEPRECATEDIN_3_1 void OPENSSL_LH_node_stats_bio(const OPENSSL_LHASH *lh, BIO *out);
+OSSL_DEPRECATEDIN_3_1 void OPENSSL_LH_node_usage_stats_bio(const OPENSSL_LHASH *lh, BIO *out);
+# endif
+
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#  define _LHASH OPENSSL_LHASH
+#  define LHASH_NODE OPENSSL_LH_NODE
+#  define lh_error OPENSSL_LH_error
+#  define lh_new OPENSSL_LH_new
+#  define lh_free OPENSSL_LH_free
+#  define lh_insert OPENSSL_LH_insert
+#  define lh_delete OPENSSL_LH_delete
+#  define lh_retrieve OPENSSL_LH_retrieve
+#  define lh_doall OPENSSL_LH_doall
+#  define lh_doall_arg OPENSSL_LH_doall_arg
+#  define lh_strhash OPENSSL_LH_strhash
+#  define lh_num_items OPENSSL_LH_num_items
+#  ifndef OPENSSL_NO_STDIO
+#   define lh_stats OPENSSL_LH_stats
+#   define lh_node_stats OPENSSL_LH_node_stats
+#   define lh_node_usage_stats OPENSSL_LH_node_usage_stats
+#  endif
+#  define lh_stats_bio OPENSSL_LH_stats_bio
+#  define lh_node_stats_bio OPENSSL_LH_node_stats_bio
+#  define lh_node_usage_stats_bio OPENSSL_LH_node_usage_stats_bio
+# endif
+
+/* Type checking... */
+
+# define LHASH_OF(type) struct lhash_st_##type
+
+/* Helper macro for internal use */
+# define DEFINE_LHASH_OF_INTERNAL(type) \
+    LHASH_OF(type) { \
+        union lh_##type##_dummy { void* d1; unsigned long d2; int d3; } dummy; \
+    }; \
+    typedef int (*lh_##type##_compfunc)(const type *a, const type *b); \
+    typedef unsigned long (*lh_##type##_hashfunc)(const type *a); \
+    typedef void (*lh_##type##_doallfunc)(type *a); \
+    static ossl_inline unsigned long lh_##type##_hash_thunk(const void *data, OPENSSL_LH_HASHFUNC hfn) \
+    { \
+        unsigned long (*hfn_conv)(const type *) = (unsigned long (*)(const type *))hfn; \
+        return hfn_conv((const type *)data); \
+    } \
+    static ossl_inline int lh_##type##_comp_thunk(const void *da, const void *db, OPENSSL_LH_COMPFUNC cfn) \
+    { \
+        int (*cfn_conv)(const type *, const type *) = (int (*)(const type *, const type *))cfn; \
+        return cfn_conv((const type *)da, (const type *)db); \
+    } \
+    static ossl_inline void lh_##type##_doall_thunk(void *node, OPENSSL_LH_DOALL_FUNC doall) \
+    { \
+        void (*doall_conv)(type *) = (void (*)(type *))doall; \
+        doall_conv((type *)node); \
+    } \
+    static ossl_inline void lh_##type##_doall_arg_thunk(void *node, void *arg, OPENSSL_LH_DOALL_FUNCARG doall) \
+    { \
+        void (*doall_conv)(type *, void *) = (void (*)(type *, void *))doall; \
+        doall_conv((type *)node, arg); \
+    } \
+    static ossl_unused ossl_inline type *\
+    ossl_check_##type##_lh_plain_type(type *ptr) \
+    { \
+        return ptr; \
+    } \
+    static ossl_unused ossl_inline const type * \
+    ossl_check_const_##type##_lh_plain_type(const type *ptr) \
+    { \
+        return ptr; \
+    } \
+    static ossl_unused ossl_inline const OPENSSL_LHASH * \
+    ossl_check_const_##type##_lh_type(const LHASH_OF(type) *lh) \
+    { \
+        return (const OPENSSL_LHASH *)lh; \
+    } \
+    static ossl_unused ossl_inline OPENSSL_LHASH * \
+    ossl_check_##type##_lh_type(LHASH_OF(type) *lh) \
+    { \
+        return (OPENSSL_LHASH *)lh; \
+    } \
+    static ossl_unused ossl_inline OPENSSL_LH_COMPFUNC \
+    ossl_check_##type##_lh_compfunc_type(lh_##type##_compfunc cmp) \
+    { \
+        return (OPENSSL_LH_COMPFUNC)cmp; \
+    } \
+    static ossl_unused ossl_inline OPENSSL_LH_HASHFUNC \
+    ossl_check_##type##_lh_hashfunc_type(lh_##type##_hashfunc hfn) \
+    { \
+        return (OPENSSL_LH_HASHFUNC)hfn; \
+    } \
+    static ossl_unused ossl_inline OPENSSL_LH_DOALL_FUNC \
+    ossl_check_##type##_lh_doallfunc_type(lh_##type##_doallfunc dfn) \
+    { \
+        return (OPENSSL_LH_DOALL_FUNC)dfn; \
+    } \
+    LHASH_OF(type)
+
+# ifndef OPENSSL_NO_DEPRECATED_3_1
+#  define DEFINE_LHASH_OF_DEPRECATED(type) \
+    static ossl_unused ossl_inline void \
+    lh_##type##_node_stats_bio(const LHASH_OF(type) *lh, BIO *out) \
+    { \
+        OPENSSL_LH_node_stats_bio((const OPENSSL_LHASH *)lh, out); \
+    } \
+    static ossl_unused ossl_inline void \
+    lh_##type##_node_usage_stats_bio(const LHASH_OF(type) *lh, BIO *out) \
+    { \
+        OPENSSL_LH_node_usage_stats_bio((const OPENSSL_LHASH *)lh, out); \
+    } \
+    static ossl_unused ossl_inline void \
+    lh_##type##_stats_bio(const LHASH_OF(type) *lh, BIO *out) \
+    { \
+        OPENSSL_LH_stats_bio((const OPENSSL_LHASH *)lh, out); \
+    }
+# else
+#  define DEFINE_LHASH_OF_DEPRECATED(type)
+# endif
+
+# define DEFINE_LHASH_OF_EX(type) \
+    LHASH_OF(type) { \
+        union lh_##type##_dummy { void* d1; unsigned long d2; int d3; } dummy; \
+    }; \
+    static unsigned long \
+    lh_##type##_hfn_thunk(const void *data, OPENSSL_LH_HASHFUNC hfn) \
+    { \
+        unsigned long (*hfn_conv)(const type *) = (unsigned long (*)(const type *))hfn; \
+        return hfn_conv((const type *)data); \
+    } \
+    static int lh_##type##_cfn_thunk(const void *da, const void *db, OPENSSL_LH_COMPFUNC cfn) \
+    { \
+        int (*cfn_conv)(const type *, const type *) = (int (*)(const type *, const type *))cfn; \
+        return cfn_conv((const type *)da, (const type *)db); \
+    } \
+    static ossl_unused ossl_inline void \
+    lh_##type##_free(LHASH_OF(type) *lh) \
+    { \
+        OPENSSL_LH_free((OPENSSL_LHASH *)lh); \
+    } \
+    static ossl_unused ossl_inline void \
+    lh_##type##_flush(LHASH_OF(type) *lh) \
+    { \
+        OPENSSL_LH_flush((OPENSSL_LHASH *)lh); \
+    } \
+    static ossl_unused ossl_inline type * \
+    lh_##type##_insert(LHASH_OF(type) *lh, type *d) \
+    { \
+        return (type *)OPENSSL_LH_insert((OPENSSL_LHASH *)lh, d); \
+    } \
+    static ossl_unused ossl_inline type * \
+    lh_##type##_delete(LHASH_OF(type) *lh, const type *d) \
+    { \
+        return (type *)OPENSSL_LH_delete((OPENSSL_LHASH *)lh, d); \
+    } \
+    static ossl_unused ossl_inline type * \
+    lh_##type##_retrieve(LHASH_OF(type) *lh, const type *d) \
+    { \
+        return (type *)OPENSSL_LH_retrieve((OPENSSL_LHASH *)lh, d); \
+    } \
+    static ossl_unused ossl_inline int \
+    lh_##type##_error(LHASH_OF(type) *lh) \
+    { \
+        return OPENSSL_LH_error((OPENSSL_LHASH *)lh); \
+    } \
+    static ossl_unused ossl_inline unsigned long \
+    lh_##type##_num_items(LHASH_OF(type) *lh) \
+    { \
+        return OPENSSL_LH_num_items((OPENSSL_LHASH *)lh); \
+    } \
+    static ossl_unused ossl_inline unsigned long \
+    lh_##type##_get_down_load(LHASH_OF(type) *lh) \
+    { \
+        return OPENSSL_LH_get_down_load((OPENSSL_LHASH *)lh); \
+    } \
+    static ossl_unused ossl_inline void \
+    lh_##type##_set_down_load(LHASH_OF(type) *lh, unsigned long dl) \
+    { \
+        OPENSSL_LH_set_down_load((OPENSSL_LHASH *)lh, dl); \
+    } \
+    static ossl_unused ossl_inline void \
+    lh_##type##_doall_thunk(void *node, OPENSSL_LH_DOALL_FUNC doall) \
+    { \
+        void (*doall_conv)(type *) = (void (*)(type *))doall; \
+        doall_conv((type *)node); \
+    } \
+    static ossl_unused ossl_inline void \
+    lh_##type##_doall_arg_thunk(void *node, void *arg, OPENSSL_LH_DOALL_FUNCARG doall) \
+    { \
+        void (*doall_conv)(type *, void *) = (void (*)(type *, void *))doall; \
+        doall_conv((type *)node, arg); \
+    } \
+    static ossl_unused ossl_inline void \
+    lh_##type##_doall(LHASH_OF(type) *lh, void (*doall)(type *)) \
+    { \
+        OPENSSL_LH_doall((OPENSSL_LHASH *)lh, (OPENSSL_LH_DOALL_FUNC)doall); \
+    } \
+    static ossl_unused ossl_inline LHASH_OF(type) * \
+    lh_##type##_new(unsigned long (*hfn)(const type *), \
+                    int (*cfn)(const type *, const type *)) \
+    { \
+        return (LHASH_OF(type) *)OPENSSL_LH_set_thunks(OPENSSL_LH_new((OPENSSL_LH_HASHFUNC)hfn, (OPENSSL_LH_COMPFUNC)cfn), \
+                                lh_##type##_hfn_thunk, lh_##type##_cfn_thunk, \
+                                lh_##type##_doall_thunk, \
+                                lh_##type##_doall_arg_thunk); \
+    } \
+    static ossl_unused ossl_inline void \
+    lh_##type##_doall_arg(LHASH_OF(type) *lh, \
+                          void (*doallarg)(type *, void *), void *arg) \
+    { \
+        OPENSSL_LH_doall_arg((OPENSSL_LHASH *)lh, \
+                             (OPENSSL_LH_DOALL_FUNCARG)doallarg, arg); \
+    } \
+    LHASH_OF(type)
+
+# define DEFINE_LHASH_OF(type) \
+    DEFINE_LHASH_OF_EX(type); \
+    DEFINE_LHASH_OF_DEPRECATED(type) \
+    LHASH_OF(type)
+
+#define IMPLEMENT_LHASH_DOALL_ARG_CONST(type, argtype) \
+    int_implement_lhash_doall(type, argtype, const type)
+
+#define IMPLEMENT_LHASH_DOALL_ARG(type, argtype) \
+    int_implement_lhash_doall(type, argtype, type)
+
+#define int_implement_lhash_doall(type, argtype, cbargtype) \
+    static ossl_unused ossl_inline void \
+    lh_##type##_doall_##argtype##_thunk(void *node, void *arg, OPENSSL_LH_DOALL_FUNCARG fn) \
+    { \
+        void (*fn_conv)(cbargtype *, argtype *) = (void (*)(cbargtype *, argtype *))fn; \
+        fn_conv((cbargtype *)node, (argtype *)arg); \
+    } \
+    static ossl_unused ossl_inline void \
+        lh_##type##_doall_##argtype(LHASH_OF(type) *lh, \
+                                   void (*fn)(cbargtype *, argtype *), \
+                                   argtype *arg) \
+    { \
+        OPENSSL_LH_doall_arg_thunk((OPENSSL_LHASH *)lh, \
+                             lh_##type##_doall_##argtype##_thunk, \
+                             (OPENSSL_LH_DOALL_FUNCARG)fn, \
+                             (void *)arg); \
+    } \
+    LHASH_OF(type)
+
+DEFINE_LHASH_OF_INTERNAL(OPENSSL_STRING);
+#define lh_OPENSSL_STRING_new(hfn, cmp) ((LHASH_OF(OPENSSL_STRING) *)OPENSSL_LH_set_thunks(OPENSSL_LH_new(ossl_check_OPENSSL_STRING_lh_hashfunc_type(hfn), ossl_check_OPENSSL_STRING_lh_compfunc_type(cmp)), lh_OPENSSL_STRING_hash_thunk, lh_OPENSSL_STRING_comp_thunk, lh_OPENSSL_STRING_doall_thunk, lh_OPENSSL_STRING_doall_arg_thunk))
+#define lh_OPENSSL_STRING_free(lh) OPENSSL_LH_free(ossl_check_OPENSSL_STRING_lh_type(lh))
+#define lh_OPENSSL_STRING_flush(lh) OPENSSL_LH_flush(ossl_check_OPENSSL_STRING_lh_type(lh))
+#define lh_OPENSSL_STRING_insert(lh, ptr) ((OPENSSL_STRING *)OPENSSL_LH_insert(ossl_check_OPENSSL_STRING_lh_type(lh), ossl_check_OPENSSL_STRING_lh_plain_type(ptr)))
+#define lh_OPENSSL_STRING_delete(lh, ptr) ((OPENSSL_STRING *)OPENSSL_LH_delete(ossl_check_OPENSSL_STRING_lh_type(lh), ossl_check_const_OPENSSL_STRING_lh_plain_type(ptr)))
+#define lh_OPENSSL_STRING_retrieve(lh, ptr) ((OPENSSL_STRING *)OPENSSL_LH_retrieve(ossl_check_OPENSSL_STRING_lh_type(lh), ossl_check_const_OPENSSL_STRING_lh_plain_type(ptr)))
+#define lh_OPENSSL_STRING_error(lh) OPENSSL_LH_error(ossl_check_OPENSSL_STRING_lh_type(lh))
+#define lh_OPENSSL_STRING_num_items(lh) OPENSSL_LH_num_items(ossl_check_OPENSSL_STRING_lh_type(lh))
+#define lh_OPENSSL_STRING_node_stats_bio(lh, out) OPENSSL_LH_node_stats_bio(ossl_check_const_OPENSSL_STRING_lh_type(lh), out)
+#define lh_OPENSSL_STRING_node_usage_stats_bio(lh, out) OPENSSL_LH_node_usage_stats_bio(ossl_check_const_OPENSSL_STRING_lh_type(lh), out)
+#define lh_OPENSSL_STRING_stats_bio(lh, out) OPENSSL_LH_stats_bio(ossl_check_const_OPENSSL_STRING_lh_type(lh), out)
+#define lh_OPENSSL_STRING_get_down_load(lh) OPENSSL_LH_get_down_load(ossl_check_OPENSSL_STRING_lh_type(lh))
+#define lh_OPENSSL_STRING_set_down_load(lh, dl) OPENSSL_LH_set_down_load(ossl_check_OPENSSL_STRING_lh_type(lh), dl)
+#define lh_OPENSSL_STRING_doall(lh, dfn) OPENSSL_LH_doall(ossl_check_OPENSSL_STRING_lh_type(lh), ossl_check_OPENSSL_STRING_lh_doallfunc_type(dfn))
+DEFINE_LHASH_OF_INTERNAL(OPENSSL_CSTRING);
+#define lh_OPENSSL_CSTRING_new(hfn, cmp) ((LHASH_OF(OPENSSL_CSTRING) *)OPENSSL_LH_set_thunks(OPENSSL_LH_new(ossl_check_OPENSSL_CSTRING_lh_hashfunc_type(hfn), ossl_check_OPENSSL_CSTRING_lh_compfunc_type(cmp)), lh_OPENSSL_CSTRING_hash_thunk, lh_OPENSSL_CSTRING_comp_thunk, lh_OPENSSL_CSTRING_doall_thunk, lh_OPENSSL_CSTRING_doall_arg_thunk))
+#define lh_OPENSSL_CSTRING_free(lh) OPENSSL_LH_free(ossl_check_OPENSSL_CSTRING_lh_type(lh))
+#define lh_OPENSSL_CSTRING_flush(lh) OPENSSL_LH_flush(ossl_check_OPENSSL_CSTRING_lh_type(lh))
+#define lh_OPENSSL_CSTRING_insert(lh, ptr) ((OPENSSL_CSTRING *)OPENSSL_LH_insert(ossl_check_OPENSSL_CSTRING_lh_type(lh), ossl_check_OPENSSL_CSTRING_lh_plain_type(ptr)))
+#define lh_OPENSSL_CSTRING_delete(lh, ptr) ((OPENSSL_CSTRING *)OPENSSL_LH_delete(ossl_check_OPENSSL_CSTRING_lh_type(lh), ossl_check_const_OPENSSL_CSTRING_lh_plain_type(ptr)))
+#define lh_OPENSSL_CSTRING_retrieve(lh, ptr) ((OPENSSL_CSTRING *)OPENSSL_LH_retrieve(ossl_check_OPENSSL_CSTRING_lh_type(lh), ossl_check_const_OPENSSL_CSTRING_lh_plain_type(ptr)))
+#define lh_OPENSSL_CSTRING_error(lh) OPENSSL_LH_error(ossl_check_OPENSSL_CSTRING_lh_type(lh))
+#define lh_OPENSSL_CSTRING_num_items(lh) OPENSSL_LH_num_items(ossl_check_OPENSSL_CSTRING_lh_type(lh))
+#define lh_OPENSSL_CSTRING_node_stats_bio(lh, out) OPENSSL_LH_node_stats_bio(ossl_check_const_OPENSSL_CSTRING_lh_type(lh), out)
+#define lh_OPENSSL_CSTRING_node_usage_stats_bio(lh, out) OPENSSL_LH_node_usage_stats_bio(ossl_check_const_OPENSSL_CSTRING_lh_type(lh), out)
+#define lh_OPENSSL_CSTRING_stats_bio(lh, out) OPENSSL_LH_stats_bio(ossl_check_const_OPENSSL_CSTRING_lh_type(lh), out)
+#define lh_OPENSSL_CSTRING_get_down_load(lh) OPENSSL_LH_get_down_load(ossl_check_OPENSSL_CSTRING_lh_type(lh))
+#define lh_OPENSSL_CSTRING_set_down_load(lh, dl) OPENSSL_LH_set_down_load(ossl_check_OPENSSL_CSTRING_lh_type(lh), dl)
+#define lh_OPENSSL_CSTRING_doall(lh, dfn) OPENSSL_LH_doall(ossl_check_OPENSSL_CSTRING_lh_type(lh), ossl_check_OPENSSL_CSTRING_lh_doallfunc_type(dfn))
+
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/include/openssl/macros.h b/src/include/openssl/macros.h
new file mode 100644
index 0000000..e9ef938
--- /dev/null
+++ b/src/include/openssl/macros.h
@@ -0,0 +1,326 @@
+/*
+ * Copyright 2019-2023 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_MACROS_H
+# define OPENSSL_MACROS_H
+# pragma once
+
+#include <openssl/opensslconf.h>
+#include <openssl/opensslv.h>
+
+
+/* Helper macros for CPP string composition */
+# define OPENSSL_MSTR_HELPER(x) #x
+# define OPENSSL_MSTR(x) OPENSSL_MSTR_HELPER(x)
+
+/*
+ * Sometimes OPENSSL_NO_xxx ends up with an empty file and some compilers
+ * don't like that.  This will hopefully silence them.
+ */
+# define NON_EMPTY_TRANSLATION_UNIT static void *dummy = &dummy;
+
+/*
+ * Generic deprecation macro
+ *
+ * If OPENSSL_SUPPRESS_DEPRECATED is defined, then OSSL_DEPRECATED and
+ * OSSL_DEPRECATED_FOR become no-ops
+ */
+# ifndef OSSL_DEPRECATED
+#  undef OSSL_DEPRECATED_FOR
+#  ifndef OPENSSL_SUPPRESS_DEPRECATED
+#   if defined(_MSC_VER)
+     /*
+      * MSVC supports __declspec(deprecated) since MSVC 2003 (13.10),
+      * and __declspec(deprecated(message)) since MSVC 2005 (14.00)
+      */
+#    if _MSC_VER >= 1400
+#     define OSSL_DEPRECATED(since) \
+          __declspec(deprecated("Since OpenSSL " # since))
+#     define OSSL_DEPRECATED_FOR(since, message) \
+          __declspec(deprecated("Since OpenSSL " # since ";" message))
+#    elif _MSC_VER >= 1310
+#     define OSSL_DEPRECATED(since) __declspec(deprecated)
+#     define OSSL_DEPRECATED_FOR(since, message) __declspec(deprecated)
+#    endif
+#   elif defined(__GNUC__)
+     /*
+      * According to GCC documentation, deprecations with message appeared in
+      * GCC 4.5.0
+      */
+#    if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5)
+#     define OSSL_DEPRECATED(since) \
+          __attribute__((deprecated("Since OpenSSL " # since)))
+#     define OSSL_DEPRECATED_FOR(since, message) \
+          __attribute__((deprecated("Since OpenSSL " # since ";" message)))
+#    elif __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ > 0)
+#     define OSSL_DEPRECATED(since) __attribute__((deprecated))
+#     define OSSL_DEPRECATED_FOR(since, message) __attribute__((deprecated))
+#    endif
+#   elif defined(__SUNPRO_C)
+#    if (__SUNPRO_C >= 0x5130)
+#     define OSSL_DEPRECATED(since) __attribute__ ((deprecated))
+#     define OSSL_DEPRECATED_FOR(since, message) __attribute__ ((deprecated))
+#    endif
+#   endif
+#  endif
+# endif
+
+/*
+ * Still not defined?  Then define no-op macros. This means these macros
+ * are unsuitable for use in a typedef.
+ */
+# ifndef OSSL_DEPRECATED
+#  define OSSL_DEPRECATED(since)                extern
+#  define OSSL_DEPRECATED_FOR(since, message)   extern
+# endif
+
+/*
+ * Applications should use -DOPENSSL_API_COMPAT=<version> to suppress the
+ * declarations of functions deprecated in or before <version>.  If this is
+ * undefined, the value of the macro OPENSSL_CONFIGURED_API (defined in
+ * <openssl/opensslconf.h>) is the default.
+ *
+ * For any version number up until version 1.1.x, <version> is expected to be
+ * the calculated version number 0xMNNFFPPSL.
+ * For version numbers 3.0 and on, <version> is expected to be a computation
+ * of the major and minor numbers in decimal using this formula:
+ *
+ *     MAJOR * 10000 + MINOR * 100
+ *
+ * So version 3.0 becomes 30000, version 3.2 becomes 30200, etc.
+ */
+
+/*
+ * We use the OPENSSL_API_COMPAT value to define API level macros.  These
+ * macros are used to enable or disable features at that API version boundary.
+ */
+
+# ifdef OPENSSL_API_LEVEL
+#  error "OPENSSL_API_LEVEL must not be defined by application"
+# endif
+
+/*
+ * We figure out what API level was intended by simple numeric comparison.
+ * The lowest old style number we recognise is 0x00908000L, so we take some
+ * safety margin and assume that anything below 0x00900000L is a new style
+ * number.  This allows new versions up to and including v943.71.83.
+ */
+# ifdef OPENSSL_API_COMPAT
+#  if OPENSSL_API_COMPAT < 0x900000L
+#   define OPENSSL_API_LEVEL (OPENSSL_API_COMPAT)
+#  else
+#   define OPENSSL_API_LEVEL                            \
+           (((OPENSSL_API_COMPAT >> 28) & 0xF) * 10000  \
+            + ((OPENSSL_API_COMPAT >> 20) & 0xFF) * 100 \
+            + ((OPENSSL_API_COMPAT >> 12) & 0xFF))
+#  endif
+# endif
+
+/*
+ * If OPENSSL_API_COMPAT wasn't given, we use default numbers to set
+ * the API compatibility level.
+ */
+# ifndef OPENSSL_API_LEVEL
+#  if OPENSSL_CONFIGURED_API > 0
+#   define OPENSSL_API_LEVEL (OPENSSL_CONFIGURED_API)
+#  else
+#   define OPENSSL_API_LEVEL \
+           (OPENSSL_VERSION_MAJOR * 10000 + OPENSSL_VERSION_MINOR * 100)
+#  endif
+# endif
+
+# if OPENSSL_API_LEVEL > OPENSSL_CONFIGURED_API
+#  error "The requested API level higher than the configured API compatibility level"
+# endif
+
+/*
+ * Check of sane values.
+ */
+/* Can't go higher than the current version. */
+# if OPENSSL_API_LEVEL > (OPENSSL_VERSION_MAJOR * 10000 + OPENSSL_VERSION_MINOR * 100)
+#  error "OPENSSL_API_COMPAT expresses an impossible API compatibility level"
+# endif
+/* OpenSSL will have no version 2.y.z */
+# if OPENSSL_API_LEVEL < 30000 && OPENSSL_API_LEVEL >= 20000
+#  error "OPENSSL_API_COMPAT expresses an impossible API compatibility level"
+# endif
+/* Below 0.9.8 is unacceptably low */
+# if OPENSSL_API_LEVEL < 908
+#  error "OPENSSL_API_COMPAT expresses an impossible API compatibility level"
+# endif
+
+/*
+ * Define macros for deprecation and simulated removal purposes.
+ *
+ * The macros OSSL_DEPRECATEDIN_{major}_{minor} are always defined for
+ * all OpenSSL versions we care for.  They can be used as attributes
+ * in function declarations where appropriate.
+ *
+ * The macros OPENSSL_NO_DEPRECATED_{major}_{minor} are defined for
+ * all OpenSSL versions up to or equal to the version given with
+ * OPENSSL_API_COMPAT.  They are used as guards around anything that's
+ * deprecated up to that version, as an effect of the developer option
+ * 'no-deprecated'.
+ */
+
+# undef OPENSSL_NO_DEPRECATED_3_1
+# undef OPENSSL_NO_DEPRECATED_3_0
+# undef OPENSSL_NO_DEPRECATED_1_1_1
+# undef OPENSSL_NO_DEPRECATED_1_1_0
+# undef OPENSSL_NO_DEPRECATED_1_0_2
+# undef OPENSSL_NO_DEPRECATED_1_0_1
+# undef OPENSSL_NO_DEPRECATED_1_0_0
+# undef OPENSSL_NO_DEPRECATED_0_9_8
+
+# if OPENSSL_API_LEVEL >= 30100
+#  ifndef OPENSSL_NO_DEPRECATED
+#   define OSSL_DEPRECATEDIN_3_1                OSSL_DEPRECATED(3.1)
+#   define OSSL_DEPRECATEDIN_3_1_FOR(msg)       OSSL_DEPRECATED_FOR(3.1, msg)
+#  else
+#   define OPENSSL_NO_DEPRECATED_3_1
+#  endif
+# else
+#  define OSSL_DEPRECATEDIN_3_1
+#  define OSSL_DEPRECATEDIN_3_1_FOR(msg)
+# endif
+# if OPENSSL_API_LEVEL >= 30000
+#  ifndef OPENSSL_NO_DEPRECATED
+#   define OSSL_DEPRECATEDIN_3_0                OSSL_DEPRECATED(3.0)
+#   define OSSL_DEPRECATEDIN_3_0_FOR(msg)       OSSL_DEPRECATED_FOR(3.0, msg)
+#  else
+#   define OPENSSL_NO_DEPRECATED_3_0
+#  endif
+# else
+#  define OSSL_DEPRECATEDIN_3_0
+#  define OSSL_DEPRECATEDIN_3_0_FOR(msg)
+# endif
+# if OPENSSL_API_LEVEL >= 10101
+#  ifndef OPENSSL_NO_DEPRECATED
+#   define OSSL_DEPRECATEDIN_1_1_1              OSSL_DEPRECATED(1.1.1)
+#   define OSSL_DEPRECATEDIN_1_1_1_FOR(msg)     OSSL_DEPRECATED_FOR(1.1.1, msg)
+#  else
+#   define OPENSSL_NO_DEPRECATED_1_1_1
+#  endif
+# else
+#  define OSSL_DEPRECATEDIN_1_1_1
+#  define OSSL_DEPRECATEDIN_1_1_1_FOR(msg)
+# endif
+# if OPENSSL_API_LEVEL >= 10100
+#  ifndef OPENSSL_NO_DEPRECATED
+#   define OSSL_DEPRECATEDIN_1_1_0              OSSL_DEPRECATED(1.1.0)
+#   define OSSL_DEPRECATEDIN_1_1_0_FOR(msg)     OSSL_DEPRECATED_FOR(1.1.0, msg)
+#  else
+#   define OPENSSL_NO_DEPRECATED_1_1_0
+#  endif
+# else
+#  define OSSL_DEPRECATEDIN_1_1_0
+#  define OSSL_DEPRECATEDIN_1_1_0_FOR(msg)
+# endif
+# if OPENSSL_API_LEVEL >= 10002
+#  ifndef OPENSSL_NO_DEPRECATED
+#   define OSSL_DEPRECATEDIN_1_0_2              OSSL_DEPRECATED(1.0.2)
+#   define OSSL_DEPRECATEDIN_1_0_2_FOR(msg)     OSSL_DEPRECATED_FOR(1.0.2, msg)
+#  else
+#   define OPENSSL_NO_DEPRECATED_1_0_2
+#  endif
+# else
+#  define OSSL_DEPRECATEDIN_1_0_2
+#  define OSSL_DEPRECATEDIN_1_0_2_FOR(msg)
+# endif
+# if OPENSSL_API_LEVEL >= 10001
+#  ifndef OPENSSL_NO_DEPRECATED
+#   define OSSL_DEPRECATEDIN_1_0_1              OSSL_DEPRECATED(1.0.1)
+#   define OSSL_DEPRECATEDIN_1_0_1_FOR(msg)     OSSL_DEPRECATED_FOR(1.0.1, msg)
+#  else
+#   define OPENSSL_NO_DEPRECATED_1_0_1
+#  endif
+# else
+#  define OSSL_DEPRECATEDIN_1_0_1
+#  define OSSL_DEPRECATEDIN_1_0_1_FOR(msg)
+# endif
+# if OPENSSL_API_LEVEL >= 10000
+#  ifndef OPENSSL_NO_DEPRECATED
+#   define OSSL_DEPRECATEDIN_1_0_0              OSSL_DEPRECATED(1.0.0)
+#   define OSSL_DEPRECATEDIN_1_0_0_FOR(msg)     OSSL_DEPRECATED_FOR(1.0.0, msg)
+#  else
+#   define OPENSSL_NO_DEPRECATED_1_0_0
+#  endif
+# else
+#  define OSSL_DEPRECATEDIN_1_0_0
+#  define OSSL_DEPRECATEDIN_1_0_0_FOR(msg)
+# endif
+# if OPENSSL_API_LEVEL >= 908
+#  ifndef OPENSSL_NO_DEPRECATED
+#   define OSSL_DEPRECATEDIN_0_9_8              OSSL_DEPRECATED(0.9.8)
+#   define OSSL_DEPRECATEDIN_0_9_8_FOR(msg)     OSSL_DEPRECATED_FOR(0.9.8, msg)
+#  else
+#   define OPENSSL_NO_DEPRECATED_0_9_8
+#  endif
+# else
+#  define OSSL_DEPRECATEDIN_0_9_8
+#  define OSSL_DEPRECATEDIN_0_9_8_FOR(msg)
+# endif
+
+/*
+ * Make our own variants of __FILE__ and __LINE__, depending on configuration
+ */
+
+# ifndef OPENSSL_FILE
+#  ifdef OPENSSL_NO_FILENAMES
+#   define OPENSSL_FILE ""
+#   define OPENSSL_LINE 0
+#  else
+#   define OPENSSL_FILE __FILE__
+#   define OPENSSL_LINE __LINE__
+#  endif
+# endif
+
+/*
+ * __func__ was standardized in C99, so for any compiler that claims
+ * to implement that language level or newer, we assume we can safely
+ * use that symbol.
+ *
+ * GNU C also provides __FUNCTION__ since version 2, which predates
+ * C99.  We can, however, only use this if __STDC_VERSION__ exists,
+ * as it's otherwise not allowed according to ISO C standards (C90).
+ * (compiling with GNU C's -pedantic tells us so)
+ *
+ * If none of the above applies, we check if the compiler is MSVC,
+ * and use __FUNCTION__ if that's the case.
+ */
+# ifndef OPENSSL_FUNC
+#  if defined(__STDC_VERSION__)
+#   if __STDC_VERSION__ >= 199901L
+#    define OPENSSL_FUNC __func__
+#   elif defined(__GNUC__) && __GNUC__ >= 2
+#    define OPENSSL_FUNC __FUNCTION__
+#   endif
+#  elif defined(_MSC_VER)
+#    define OPENSSL_FUNC __FUNCTION__
+#  endif
+/*
+ * If all these possibilities are exhausted, we give up and use a
+ * static string.
+ */
+#  ifndef OPENSSL_FUNC
+#   define OPENSSL_FUNC "(unknown function)"
+#  endif
+# endif
+
+# ifndef OSSL_CRYPTO_ALLOC
+#  if defined(__GNUC__)
+#   define OSSL_CRYPTO_ALLOC __attribute__((__malloc__))
+#  elif defined(_MSC_VER)
+#   define OSSL_CRYPTO_ALLOC __declspec(restrict)
+#  else
+#   define OSSL_CRYPTO_ALLOC
+#  endif
+# endif
+
+#endif  /* OPENSSL_MACROS_H */
diff --git a/src/include/openssl/md2.h b/src/include/openssl/md2.h
new file mode 100644
index 0000000..5d4cb77
--- /dev/null
+++ b/src/include/openssl/md2.h
@@ -0,0 +1,56 @@
+/*
+ * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_MD2_H
+# define OPENSSL_MD2_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_MD2_H
+# endif
+
+# include <openssl/opensslconf.h>
+
+# ifndef OPENSSL_NO_MD2
+#  include <stddef.h>
+#  ifdef  __cplusplus
+extern "C" {
+#  endif
+
+#  define MD2_DIGEST_LENGTH       16
+
+#  if !defined(OPENSSL_NO_DEPRECATED_3_0)
+
+typedef unsigned char MD2_INT;
+
+#   define MD2_BLOCK               16
+
+typedef struct MD2state_st {
+    unsigned int num;
+    unsigned char data[MD2_BLOCK];
+    MD2_INT cksm[MD2_BLOCK];
+    MD2_INT state[MD2_BLOCK];
+} MD2_CTX;
+#  endif
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 const char *MD2_options(void);
+OSSL_DEPRECATEDIN_3_0 int MD2_Init(MD2_CTX *c);
+OSSL_DEPRECATEDIN_3_0 int MD2_Update(MD2_CTX *c, const unsigned char *data,
+                                     size_t len);
+OSSL_DEPRECATEDIN_3_0 int MD2_Final(unsigned char *md, MD2_CTX *c);
+OSSL_DEPRECATEDIN_3_0 unsigned char *MD2(const unsigned char *d, size_t n,
+                                         unsigned char *md);
+#  endif
+
+#  ifdef  __cplusplus
+}
+#  endif
+# endif
+#endif
diff --git a/src/include/openssl/md4.h b/src/include/openssl/md4.h
new file mode 100644
index 0000000..6c150a6
--- /dev/null
+++ b/src/include/openssl/md4.h
@@ -0,0 +1,63 @@
+/*
+ * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_MD4_H
+# define OPENSSL_MD4_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_MD4_H
+# endif
+
+# include <openssl/opensslconf.h>
+
+# ifndef OPENSSL_NO_MD4
+#  include <openssl/e_os2.h>
+#  include <stddef.h>
+#  ifdef  __cplusplus
+extern "C" {
+#   endif
+
+#  define MD4_DIGEST_LENGTH 16
+
+#  if !defined(OPENSSL_NO_DEPRECATED_3_0)
+
+/*-
+ * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+ * ! MD4_LONG has to be at least 32 bits wide.                     !
+ * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+ */
+#   define MD4_LONG unsigned int
+
+#   define MD4_CBLOCK      64
+#   define MD4_LBLOCK      (MD4_CBLOCK/4)
+
+typedef struct MD4state_st {
+    MD4_LONG A, B, C, D;
+    MD4_LONG Nl, Nh;
+    MD4_LONG data[MD4_LBLOCK];
+    unsigned int num;
+} MD4_CTX;
+#  endif
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int MD4_Init(MD4_CTX *c);
+OSSL_DEPRECATEDIN_3_0 int MD4_Update(MD4_CTX *c, const void *data, size_t len);
+OSSL_DEPRECATEDIN_3_0 int MD4_Final(unsigned char *md, MD4_CTX *c);
+OSSL_DEPRECATEDIN_3_0 unsigned char *MD4(const unsigned char *d, size_t n,
+                                         unsigned char *md);
+OSSL_DEPRECATEDIN_3_0 void MD4_Transform(MD4_CTX *c, const unsigned char *b);
+#  endif
+
+#  ifdef  __cplusplus
+}
+#  endif
+# endif
+
+#endif
diff --git a/src/include/openssl/md5.h b/src/include/openssl/md5.h
new file mode 100644
index 0000000..77a5773
--- /dev/null
+++ b/src/include/openssl/md5.h
@@ -0,0 +1,62 @@
+/*
+ * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_MD5_H
+# define OPENSSL_MD5_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_MD5_H
+# endif
+
+# include <openssl/opensslconf.h>
+
+# ifndef OPENSSL_NO_MD5
+#  include <openssl/e_os2.h>
+#  include <stddef.h>
+#  ifdef  __cplusplus
+extern "C" {
+#  endif
+
+#  define MD5_DIGEST_LENGTH 16
+
+#  if !defined(OPENSSL_NO_DEPRECATED_3_0)
+/*
+ * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+ * ! MD5_LONG has to be at least 32 bits wide.                     !
+ * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+ */
+#   define MD5_LONG unsigned int
+
+#   define MD5_CBLOCK      64
+#   define MD5_LBLOCK      (MD5_CBLOCK/4)
+
+typedef struct MD5state_st {
+    MD5_LONG A, B, C, D;
+    MD5_LONG Nl, Nh;
+    MD5_LONG data[MD5_LBLOCK];
+    unsigned int num;
+} MD5_CTX;
+#  endif
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int MD5_Init(MD5_CTX *c);
+OSSL_DEPRECATEDIN_3_0 int MD5_Update(MD5_CTX *c, const void *data, size_t len);
+OSSL_DEPRECATEDIN_3_0 int MD5_Final(unsigned char *md, MD5_CTX *c);
+OSSL_DEPRECATEDIN_3_0 unsigned char *MD5(const unsigned char *d, size_t n,
+                                         unsigned char *md);
+OSSL_DEPRECATEDIN_3_0 void MD5_Transform(MD5_CTX *c, const unsigned char *b);
+#  endif
+
+#  ifdef  __cplusplus
+}
+#  endif
+# endif
+
+#endif
diff --git a/src/include/openssl/mdc2.h b/src/include/openssl/mdc2.h
new file mode 100644
index 0000000..5a7ee28
--- /dev/null
+++ b/src/include/openssl/mdc2.h
@@ -0,0 +1,55 @@
+/*
+ * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_MDC2_H
+# define OPENSSL_MDC2_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_MDC2_H
+# endif
+
+# include <openssl/opensslconf.h>
+
+# ifndef OPENSSL_NO_MDC2
+#  include <stdlib.h>
+#  include <openssl/des.h>
+#  ifdef  __cplusplus
+extern "C" {
+#  endif
+
+#  define MDC2_DIGEST_LENGTH      16
+
+#  if !defined(OPENSSL_NO_DEPRECATED_3_0)
+
+#   define MDC2_BLOCK              8
+
+typedef struct mdc2_ctx_st {
+    unsigned int num;
+    unsigned char data[MDC2_BLOCK];
+    DES_cblock h, hh;
+    unsigned int pad_type;   /* either 1 or 2, default 1 */
+} MDC2_CTX;
+#  endif
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int MDC2_Init(MDC2_CTX *c);
+OSSL_DEPRECATEDIN_3_0 int MDC2_Update(MDC2_CTX *c, const unsigned char *data,
+                                      size_t len);
+OSSL_DEPRECATEDIN_3_0 int MDC2_Final(unsigned char *md, MDC2_CTX *c);
+OSSL_DEPRECATEDIN_3_0 unsigned char *MDC2(const unsigned char *d, size_t n,
+                                          unsigned char *md);
+#  endif
+
+#  ifdef  __cplusplus
+}
+#  endif
+# endif
+
+#endif
diff --git a/src/include/openssl/modes.h b/src/include/openssl/modes.h
new file mode 100644
index 0000000..e190799
--- /dev/null
+++ b/src/include/openssl/modes.h
@@ -0,0 +1,219 @@
+/*
+ * Copyright 2008-2016 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_MODES_H
+# define OPENSSL_MODES_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_MODES_H
+# endif
+
+# include <stddef.h>
+# include <openssl/types.h>
+
+# ifdef  __cplusplus
+extern "C" {
+# endif
+typedef void (*block128_f) (const unsigned char in[16],
+                            unsigned char out[16], const void *key);
+
+typedef void (*cbc128_f) (const unsigned char *in, unsigned char *out,
+                          size_t len, const void *key,
+                          unsigned char ivec[16], int enc);
+
+typedef void (*ecb128_f) (const unsigned char *in, unsigned char *out,
+                          size_t len, const void *key,
+                          int enc);
+
+typedef void (*ctr128_f) (const unsigned char *in, unsigned char *out,
+                          size_t blocks, const void *key,
+                          const unsigned char ivec[16]);
+
+typedef void (*ccm128_f) (const unsigned char *in, unsigned char *out,
+                          size_t blocks, const void *key,
+                          const unsigned char ivec[16],
+                          unsigned char cmac[16]);
+
+void CRYPTO_cbc128_encrypt(const unsigned char *in, unsigned char *out,
+                           size_t len, const void *key,
+                           unsigned char ivec[16], block128_f block);
+void CRYPTO_cbc128_decrypt(const unsigned char *in, unsigned char *out,
+                           size_t len, const void *key,
+                           unsigned char ivec[16], block128_f block);
+
+void CRYPTO_ctr128_encrypt(const unsigned char *in, unsigned char *out,
+                           size_t len, const void *key,
+                           unsigned char ivec[16],
+                           unsigned char ecount_buf[16], unsigned int *num,
+                           block128_f block);
+
+void CRYPTO_ctr128_encrypt_ctr32(const unsigned char *in, unsigned char *out,
+                                 size_t len, const void *key,
+                                 unsigned char ivec[16],
+                                 unsigned char ecount_buf[16],
+                                 unsigned int *num, ctr128_f ctr);
+
+void CRYPTO_ofb128_encrypt(const unsigned char *in, unsigned char *out,
+                           size_t len, const void *key,
+                           unsigned char ivec[16], int *num,
+                           block128_f block);
+
+void CRYPTO_cfb128_encrypt(const unsigned char *in, unsigned char *out,
+                           size_t len, const void *key,
+                           unsigned char ivec[16], int *num,
+                           int enc, block128_f block);
+void CRYPTO_cfb128_8_encrypt(const unsigned char *in, unsigned char *out,
+                             size_t length, const void *key,
+                             unsigned char ivec[16], int *num,
+                             int enc, block128_f block);
+void CRYPTO_cfb128_1_encrypt(const unsigned char *in, unsigned char *out,
+                             size_t bits, const void *key,
+                             unsigned char ivec[16], int *num,
+                             int enc, block128_f block);
+
+size_t CRYPTO_cts128_encrypt_block(const unsigned char *in,
+                                   unsigned char *out, size_t len,
+                                   const void *key, unsigned char ivec[16],
+                                   block128_f block);
+size_t CRYPTO_cts128_encrypt(const unsigned char *in, unsigned char *out,
+                             size_t len, const void *key,
+                             unsigned char ivec[16], cbc128_f cbc);
+size_t CRYPTO_cts128_decrypt_block(const unsigned char *in,
+                                   unsigned char *out, size_t len,
+                                   const void *key, unsigned char ivec[16],
+                                   block128_f block);
+size_t CRYPTO_cts128_decrypt(const unsigned char *in, unsigned char *out,
+                             size_t len, const void *key,
+                             unsigned char ivec[16], cbc128_f cbc);
+
+size_t CRYPTO_nistcts128_encrypt_block(const unsigned char *in,
+                                       unsigned char *out, size_t len,
+                                       const void *key,
+                                       unsigned char ivec[16],
+                                       block128_f block);
+size_t CRYPTO_nistcts128_encrypt(const unsigned char *in, unsigned char *out,
+                                 size_t len, const void *key,
+                                 unsigned char ivec[16], cbc128_f cbc);
+size_t CRYPTO_nistcts128_decrypt_block(const unsigned char *in,
+                                       unsigned char *out, size_t len,
+                                       const void *key,
+                                       unsigned char ivec[16],
+                                       block128_f block);
+size_t CRYPTO_nistcts128_decrypt(const unsigned char *in, unsigned char *out,
+                                 size_t len, const void *key,
+                                 unsigned char ivec[16], cbc128_f cbc);
+
+typedef struct gcm128_context GCM128_CONTEXT;
+
+GCM128_CONTEXT *CRYPTO_gcm128_new(void *key, block128_f block);
+void CRYPTO_gcm128_init(GCM128_CONTEXT *ctx, void *key, block128_f block);
+void CRYPTO_gcm128_setiv(GCM128_CONTEXT *ctx, const unsigned char *iv,
+                         size_t len);
+int CRYPTO_gcm128_aad(GCM128_CONTEXT *ctx, const unsigned char *aad,
+                      size_t len);
+int CRYPTO_gcm128_encrypt(GCM128_CONTEXT *ctx,
+                          const unsigned char *in, unsigned char *out,
+                          size_t len);
+int CRYPTO_gcm128_decrypt(GCM128_CONTEXT *ctx,
+                          const unsigned char *in, unsigned char *out,
+                          size_t len);
+int CRYPTO_gcm128_encrypt_ctr32(GCM128_CONTEXT *ctx,
+                                const unsigned char *in, unsigned char *out,
+                                size_t len, ctr128_f stream);
+int CRYPTO_gcm128_decrypt_ctr32(GCM128_CONTEXT *ctx,
+                                const unsigned char *in, unsigned char *out,
+                                size_t len, ctr128_f stream);
+int CRYPTO_gcm128_finish(GCM128_CONTEXT *ctx, const unsigned char *tag,
+                         size_t len);
+void CRYPTO_gcm128_tag(GCM128_CONTEXT *ctx, unsigned char *tag, size_t len);
+void CRYPTO_gcm128_release(GCM128_CONTEXT *ctx);
+
+typedef struct ccm128_context CCM128_CONTEXT;
+
+void CRYPTO_ccm128_init(CCM128_CONTEXT *ctx,
+                        unsigned int M, unsigned int L, void *key,
+                        block128_f block);
+int CRYPTO_ccm128_setiv(CCM128_CONTEXT *ctx, const unsigned char *nonce,
+                        size_t nlen, size_t mlen);
+void CRYPTO_ccm128_aad(CCM128_CONTEXT *ctx, const unsigned char *aad,
+                       size_t alen);
+int CRYPTO_ccm128_encrypt(CCM128_CONTEXT *ctx, const unsigned char *inp,
+                          unsigned char *out, size_t len);
+int CRYPTO_ccm128_decrypt(CCM128_CONTEXT *ctx, const unsigned char *inp,
+                          unsigned char *out, size_t len);
+int CRYPTO_ccm128_encrypt_ccm64(CCM128_CONTEXT *ctx, const unsigned char *inp,
+                                unsigned char *out, size_t len,
+                                ccm128_f stream);
+int CRYPTO_ccm128_decrypt_ccm64(CCM128_CONTEXT *ctx, const unsigned char *inp,
+                                unsigned char *out, size_t len,
+                                ccm128_f stream);
+size_t CRYPTO_ccm128_tag(CCM128_CONTEXT *ctx, unsigned char *tag, size_t len);
+
+typedef struct xts128_context XTS128_CONTEXT;
+
+int CRYPTO_xts128_encrypt(const XTS128_CONTEXT *ctx,
+                          const unsigned char iv[16],
+                          const unsigned char *inp, unsigned char *out,
+                          size_t len, int enc);
+
+size_t CRYPTO_128_wrap(void *key, const unsigned char *iv,
+                       unsigned char *out,
+                       const unsigned char *in, size_t inlen,
+                       block128_f block);
+
+size_t CRYPTO_128_unwrap(void *key, const unsigned char *iv,
+                         unsigned char *out,
+                         const unsigned char *in, size_t inlen,
+                         block128_f block);
+size_t CRYPTO_128_wrap_pad(void *key, const unsigned char *icv,
+                           unsigned char *out, const unsigned char *in,
+                           size_t inlen, block128_f block);
+size_t CRYPTO_128_unwrap_pad(void *key, const unsigned char *icv,
+                             unsigned char *out, const unsigned char *in,
+                             size_t inlen, block128_f block);
+
+# ifndef OPENSSL_NO_OCB
+typedef struct ocb128_context OCB128_CONTEXT;
+
+typedef void (*ocb128_f) (const unsigned char *in, unsigned char *out,
+                          size_t blocks, const void *key,
+                          size_t start_block_num,
+                          unsigned char offset_i[16],
+                          const unsigned char L_[][16],
+                          unsigned char checksum[16]);
+
+OCB128_CONTEXT *CRYPTO_ocb128_new(void *keyenc, void *keydec,
+                                  block128_f encrypt, block128_f decrypt,
+                                  ocb128_f stream);
+int CRYPTO_ocb128_init(OCB128_CONTEXT *ctx, void *keyenc, void *keydec,
+                       block128_f encrypt, block128_f decrypt,
+                       ocb128_f stream);
+int CRYPTO_ocb128_copy_ctx(OCB128_CONTEXT *dest, OCB128_CONTEXT *src,
+                           void *keyenc, void *keydec);
+int CRYPTO_ocb128_setiv(OCB128_CONTEXT *ctx, const unsigned char *iv,
+                        size_t len, size_t taglen);
+int CRYPTO_ocb128_aad(OCB128_CONTEXT *ctx, const unsigned char *aad,
+                      size_t len);
+int CRYPTO_ocb128_encrypt(OCB128_CONTEXT *ctx, const unsigned char *in,
+                          unsigned char *out, size_t len);
+int CRYPTO_ocb128_decrypt(OCB128_CONTEXT *ctx, const unsigned char *in,
+                          unsigned char *out, size_t len);
+int CRYPTO_ocb128_finish(OCB128_CONTEXT *ctx, const unsigned char *tag,
+                         size_t len);
+int CRYPTO_ocb128_tag(OCB128_CONTEXT *ctx, unsigned char *tag, size_t len);
+void CRYPTO_ocb128_cleanup(OCB128_CONTEXT *ctx);
+# endif                          /* OPENSSL_NO_OCB */
+
+# ifdef  __cplusplus
+}
+# endif
+
+#endif
diff --git a/src/include/openssl/obj_mac.h b/src/include/openssl/obj_mac.h
new file mode 100644
index 0000000..1b7d924
--- /dev/null
+++ b/src/include/openssl/obj_mac.h
@@ -0,0 +1,5806 @@
+/*
+ * WARNING: do not edit!
+ * Generated by crypto/objects/objects.pl
+ *
+ * Copyright 2000-2024 The OpenSSL Project Authors. All Rights Reserved.
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_OBJ_MAC_H
+# define OPENSSL_OBJ_MAC_H
+# pragma once
+
+#define SN_undef                        "UNDEF"
+#define LN_undef                        "undefined"
+#define NID_undef                       0
+#define OBJ_undef                       0L
+
+#define SN_itu_t                "ITU-T"
+#define LN_itu_t                "itu-t"
+#define NID_itu_t               645
+#define OBJ_itu_t               0L
+
+#define NID_ccitt               404
+#define OBJ_ccitt               OBJ_itu_t
+
+#define SN_iso          "ISO"
+#define LN_iso          "iso"
+#define NID_iso         181
+#define OBJ_iso         1L
+
+#define SN_joint_iso_itu_t              "JOINT-ISO-ITU-T"
+#define LN_joint_iso_itu_t              "joint-iso-itu-t"
+#define NID_joint_iso_itu_t             646
+#define OBJ_joint_iso_itu_t             2L
+
+#define NID_joint_iso_ccitt             393
+#define OBJ_joint_iso_ccitt             OBJ_joint_iso_itu_t
+
+#define SN_member_body          "member-body"
+#define LN_member_body          "ISO Member Body"
+#define NID_member_body         182
+#define OBJ_member_body         OBJ_iso,2L
+
+#define SN_identified_organization              "identified-organization"
+#define NID_identified_organization             676
+#define OBJ_identified_organization             OBJ_iso,3L
+
+#define SN_gmac         "GMAC"
+#define LN_gmac         "gmac"
+#define NID_gmac                1195
+#define OBJ_gmac                OBJ_iso,0L,9797L,3L,4L
+
+#define SN_hmac_md5             "HMAC-MD5"
+#define LN_hmac_md5             "hmac-md5"
+#define NID_hmac_md5            780
+#define OBJ_hmac_md5            OBJ_identified_organization,6L,1L,5L,5L,8L,1L,1L
+
+#define SN_hmac_sha1            "HMAC-SHA1"
+#define LN_hmac_sha1            "hmac-sha1"
+#define NID_hmac_sha1           781
+#define OBJ_hmac_sha1           OBJ_identified_organization,6L,1L,5L,5L,8L,1L,2L
+
+#define SN_x509ExtAdmission             "x509ExtAdmission"
+#define LN_x509ExtAdmission             "Professional Information or basis for Admission"
+#define NID_x509ExtAdmission            1093
+#define OBJ_x509ExtAdmission            OBJ_identified_organization,36L,8L,3L,3L
+
+#define SN_certicom_arc         "certicom-arc"
+#define NID_certicom_arc                677
+#define OBJ_certicom_arc                OBJ_identified_organization,132L
+
+#define SN_ieee         "ieee"
+#define NID_ieee                1170
+#define OBJ_ieee                OBJ_identified_organization,111L
+
+#define SN_ieee_siswg           "ieee-siswg"
+#define LN_ieee_siswg           "IEEE Security in Storage Working Group"
+#define NID_ieee_siswg          1171
+#define OBJ_ieee_siswg          OBJ_ieee,2L,1619L
+
+#define SN_international_organizations          "international-organizations"
+#define LN_international_organizations          "International Organizations"
+#define NID_international_organizations         647
+#define OBJ_international_organizations         OBJ_joint_iso_itu_t,23L
+
+#define SN_wap          "wap"
+#define NID_wap         678
+#define OBJ_wap         OBJ_international_organizations,43L
+
+#define SN_wap_wsg              "wap-wsg"
+#define NID_wap_wsg             679
+#define OBJ_wap_wsg             OBJ_wap,1L
+
+#define SN_selected_attribute_types             "selected-attribute-types"
+#define LN_selected_attribute_types             "Selected Attribute Types"
+#define NID_selected_attribute_types            394
+#define OBJ_selected_attribute_types            OBJ_joint_iso_itu_t,5L,1L,5L
+
+#define SN_clearance            "clearance"
+#define NID_clearance           395
+#define OBJ_clearance           OBJ_selected_attribute_types,55L
+
+#define SN_ISO_US               "ISO-US"
+#define LN_ISO_US               "ISO US Member Body"
+#define NID_ISO_US              183
+#define OBJ_ISO_US              OBJ_member_body,840L
+
+#define SN_X9_57                "X9-57"
+#define LN_X9_57                "X9.57"
+#define NID_X9_57               184
+#define OBJ_X9_57               OBJ_ISO_US,10040L
+
+#define SN_X9cm         "X9cm"
+#define LN_X9cm         "X9.57 CM ?"
+#define NID_X9cm                185
+#define OBJ_X9cm                OBJ_X9_57,4L
+
+#define SN_ISO_CN               "ISO-CN"
+#define LN_ISO_CN               "ISO CN Member Body"
+#define NID_ISO_CN              1140
+#define OBJ_ISO_CN              OBJ_member_body,156L
+
+#define SN_oscca                "oscca"
+#define NID_oscca               1141
+#define OBJ_oscca               OBJ_ISO_CN,10197L
+
+#define SN_sm_scheme            "sm-scheme"
+#define NID_sm_scheme           1142
+#define OBJ_sm_scheme           OBJ_oscca,1L
+
+#define SN_dsa          "DSA"
+#define LN_dsa          "dsaEncryption"
+#define NID_dsa         116
+#define OBJ_dsa         OBJ_X9cm,1L
+
+#define SN_dsaWithSHA1          "DSA-SHA1"
+#define LN_dsaWithSHA1          "dsaWithSHA1"
+#define NID_dsaWithSHA1         113
+#define OBJ_dsaWithSHA1         OBJ_X9cm,3L
+
+#define SN_ansi_X9_62           "ansi-X9-62"
+#define LN_ansi_X9_62           "ANSI X9.62"
+#define NID_ansi_X9_62          405
+#define OBJ_ansi_X9_62          OBJ_ISO_US,10045L
+
+#define OBJ_X9_62_id_fieldType          OBJ_ansi_X9_62,1L
+
+#define SN_X9_62_prime_field            "prime-field"
+#define NID_X9_62_prime_field           406
+#define OBJ_X9_62_prime_field           OBJ_X9_62_id_fieldType,1L
+
+#define SN_X9_62_characteristic_two_field               "characteristic-two-field"
+#define NID_X9_62_characteristic_two_field              407
+#define OBJ_X9_62_characteristic_two_field              OBJ_X9_62_id_fieldType,2L
+
+#define SN_X9_62_id_characteristic_two_basis            "id-characteristic-two-basis"
+#define NID_X9_62_id_characteristic_two_basis           680
+#define OBJ_X9_62_id_characteristic_two_basis           OBJ_X9_62_characteristic_two_field,3L
+
+#define SN_X9_62_onBasis                "onBasis"
+#define NID_X9_62_onBasis               681
+#define OBJ_X9_62_onBasis               OBJ_X9_62_id_characteristic_two_basis,1L
+
+#define SN_X9_62_tpBasis                "tpBasis"
+#define NID_X9_62_tpBasis               682
+#define OBJ_X9_62_tpBasis               OBJ_X9_62_id_characteristic_two_basis,2L
+
+#define SN_X9_62_ppBasis                "ppBasis"
+#define NID_X9_62_ppBasis               683
+#define OBJ_X9_62_ppBasis               OBJ_X9_62_id_characteristic_two_basis,3L
+
+#define OBJ_X9_62_id_publicKeyType              OBJ_ansi_X9_62,2L
+
+#define SN_X9_62_id_ecPublicKey         "id-ecPublicKey"
+#define NID_X9_62_id_ecPublicKey                408
+#define OBJ_X9_62_id_ecPublicKey                OBJ_X9_62_id_publicKeyType,1L
+
+#define OBJ_X9_62_ellipticCurve         OBJ_ansi_X9_62,3L
+
+#define OBJ_X9_62_c_TwoCurve            OBJ_X9_62_ellipticCurve,0L
+
+#define SN_X9_62_c2pnb163v1             "c2pnb163v1"
+#define NID_X9_62_c2pnb163v1            684
+#define OBJ_X9_62_c2pnb163v1            OBJ_X9_62_c_TwoCurve,1L
+
+#define SN_X9_62_c2pnb163v2             "c2pnb163v2"
+#define NID_X9_62_c2pnb163v2            685
+#define OBJ_X9_62_c2pnb163v2            OBJ_X9_62_c_TwoCurve,2L
+
+#define SN_X9_62_c2pnb163v3             "c2pnb163v3"
+#define NID_X9_62_c2pnb163v3            686
+#define OBJ_X9_62_c2pnb163v3            OBJ_X9_62_c_TwoCurve,3L
+
+#define SN_X9_62_c2pnb176v1             "c2pnb176v1"
+#define NID_X9_62_c2pnb176v1            687
+#define OBJ_X9_62_c2pnb176v1            OBJ_X9_62_c_TwoCurve,4L
+
+#define SN_X9_62_c2tnb191v1             "c2tnb191v1"
+#define NID_X9_62_c2tnb191v1            688
+#define OBJ_X9_62_c2tnb191v1            OBJ_X9_62_c_TwoCurve,5L
+
+#define SN_X9_62_c2tnb191v2             "c2tnb191v2"
+#define NID_X9_62_c2tnb191v2            689
+#define OBJ_X9_62_c2tnb191v2            OBJ_X9_62_c_TwoCurve,6L
+
+#define SN_X9_62_c2tnb191v3             "c2tnb191v3"
+#define NID_X9_62_c2tnb191v3            690
+#define OBJ_X9_62_c2tnb191v3            OBJ_X9_62_c_TwoCurve,7L
+
+#define SN_X9_62_c2onb191v4             "c2onb191v4"
+#define NID_X9_62_c2onb191v4            691
+#define OBJ_X9_62_c2onb191v4            OBJ_X9_62_c_TwoCurve,8L
+
+#define SN_X9_62_c2onb191v5             "c2onb191v5"
+#define NID_X9_62_c2onb191v5            692
+#define OBJ_X9_62_c2onb191v5            OBJ_X9_62_c_TwoCurve,9L
+
+#define SN_X9_62_c2pnb208w1             "c2pnb208w1"
+#define NID_X9_62_c2pnb208w1            693
+#define OBJ_X9_62_c2pnb208w1            OBJ_X9_62_c_TwoCurve,10L
+
+#define SN_X9_62_c2tnb239v1             "c2tnb239v1"
+#define NID_X9_62_c2tnb239v1            694
+#define OBJ_X9_62_c2tnb239v1            OBJ_X9_62_c_TwoCurve,11L
+
+#define SN_X9_62_c2tnb239v2             "c2tnb239v2"
+#define NID_X9_62_c2tnb239v2            695
+#define OBJ_X9_62_c2tnb239v2            OBJ_X9_62_c_TwoCurve,12L
+
+#define SN_X9_62_c2tnb239v3             "c2tnb239v3"
+#define NID_X9_62_c2tnb239v3            696
+#define OBJ_X9_62_c2tnb239v3            OBJ_X9_62_c_TwoCurve,13L
+
+#define SN_X9_62_c2onb239v4             "c2onb239v4"
+#define NID_X9_62_c2onb239v4            697
+#define OBJ_X9_62_c2onb239v4            OBJ_X9_62_c_TwoCurve,14L
+
+#define SN_X9_62_c2onb239v5             "c2onb239v5"
+#define NID_X9_62_c2onb239v5            698
+#define OBJ_X9_62_c2onb239v5            OBJ_X9_62_c_TwoCurve,15L
+
+#define SN_X9_62_c2pnb272w1             "c2pnb272w1"
+#define NID_X9_62_c2pnb272w1            699
+#define OBJ_X9_62_c2pnb272w1            OBJ_X9_62_c_TwoCurve,16L
+
+#define SN_X9_62_c2pnb304w1             "c2pnb304w1"
+#define NID_X9_62_c2pnb304w1            700
+#define OBJ_X9_62_c2pnb304w1            OBJ_X9_62_c_TwoCurve,17L
+
+#define SN_X9_62_c2tnb359v1             "c2tnb359v1"
+#define NID_X9_62_c2tnb359v1            701
+#define OBJ_X9_62_c2tnb359v1            OBJ_X9_62_c_TwoCurve,18L
+
+#define SN_X9_62_c2pnb368w1             "c2pnb368w1"
+#define NID_X9_62_c2pnb368w1            702
+#define OBJ_X9_62_c2pnb368w1            OBJ_X9_62_c_TwoCurve,19L
+
+#define SN_X9_62_c2tnb431r1             "c2tnb431r1"
+#define NID_X9_62_c2tnb431r1            703
+#define OBJ_X9_62_c2tnb431r1            OBJ_X9_62_c_TwoCurve,20L
+
+#define OBJ_X9_62_primeCurve            OBJ_X9_62_ellipticCurve,1L
+
+#define SN_X9_62_prime192v1             "prime192v1"
+#define NID_X9_62_prime192v1            409
+#define OBJ_X9_62_prime192v1            OBJ_X9_62_primeCurve,1L
+
+#define SN_X9_62_prime192v2             "prime192v2"
+#define NID_X9_62_prime192v2            410
+#define OBJ_X9_62_prime192v2            OBJ_X9_62_primeCurve,2L
+
+#define SN_X9_62_prime192v3             "prime192v3"
+#define NID_X9_62_prime192v3            411
+#define OBJ_X9_62_prime192v3            OBJ_X9_62_primeCurve,3L
+
+#define SN_X9_62_prime239v1             "prime239v1"
+#define NID_X9_62_prime239v1            412
+#define OBJ_X9_62_prime239v1            OBJ_X9_62_primeCurve,4L
+
+#define SN_X9_62_prime239v2             "prime239v2"
+#define NID_X9_62_prime239v2            413
+#define OBJ_X9_62_prime239v2            OBJ_X9_62_primeCurve,5L
+
+#define SN_X9_62_prime239v3             "prime239v3"
+#define NID_X9_62_prime239v3            414
+#define OBJ_X9_62_prime239v3            OBJ_X9_62_primeCurve,6L
+
+#define SN_X9_62_prime256v1             "prime256v1"
+#define NID_X9_62_prime256v1            415
+#define OBJ_X9_62_prime256v1            OBJ_X9_62_primeCurve,7L
+
+#define OBJ_X9_62_id_ecSigType          OBJ_ansi_X9_62,4L
+
+#define SN_ecdsa_with_SHA1              "ecdsa-with-SHA1"
+#define NID_ecdsa_with_SHA1             416
+#define OBJ_ecdsa_with_SHA1             OBJ_X9_62_id_ecSigType,1L
+
+#define SN_ecdsa_with_Recommended               "ecdsa-with-Recommended"
+#define NID_ecdsa_with_Recommended              791
+#define OBJ_ecdsa_with_Recommended              OBJ_X9_62_id_ecSigType,2L
+
+#define SN_ecdsa_with_Specified         "ecdsa-with-Specified"
+#define NID_ecdsa_with_Specified                792
+#define OBJ_ecdsa_with_Specified                OBJ_X9_62_id_ecSigType,3L
+
+#define SN_ecdsa_with_SHA224            "ecdsa-with-SHA224"
+#define NID_ecdsa_with_SHA224           793
+#define OBJ_ecdsa_with_SHA224           OBJ_ecdsa_with_Specified,1L
+
+#define SN_ecdsa_with_SHA256            "ecdsa-with-SHA256"
+#define NID_ecdsa_with_SHA256           794
+#define OBJ_ecdsa_with_SHA256           OBJ_ecdsa_with_Specified,2L
+
+#define SN_ecdsa_with_SHA384            "ecdsa-with-SHA384"
+#define NID_ecdsa_with_SHA384           795
+#define OBJ_ecdsa_with_SHA384           OBJ_ecdsa_with_Specified,3L
+
+#define SN_ecdsa_with_SHA512            "ecdsa-with-SHA512"
+#define NID_ecdsa_with_SHA512           796
+#define OBJ_ecdsa_with_SHA512           OBJ_ecdsa_with_Specified,4L
+
+#define OBJ_secg_ellipticCurve          OBJ_certicom_arc,0L
+
+#define SN_secp112r1            "secp112r1"
+#define NID_secp112r1           704
+#define OBJ_secp112r1           OBJ_secg_ellipticCurve,6L
+
+#define SN_secp112r2            "secp112r2"
+#define NID_secp112r2           705
+#define OBJ_secp112r2           OBJ_secg_ellipticCurve,7L
+
+#define SN_secp128r1            "secp128r1"
+#define NID_secp128r1           706
+#define OBJ_secp128r1           OBJ_secg_ellipticCurve,28L
+
+#define SN_secp128r2            "secp128r2"
+#define NID_secp128r2           707
+#define OBJ_secp128r2           OBJ_secg_ellipticCurve,29L
+
+#define SN_secp160k1            "secp160k1"
+#define NID_secp160k1           708
+#define OBJ_secp160k1           OBJ_secg_ellipticCurve,9L
+
+#define SN_secp160r1            "secp160r1"
+#define NID_secp160r1           709
+#define OBJ_secp160r1           OBJ_secg_ellipticCurve,8L
+
+#define SN_secp160r2            "secp160r2"
+#define NID_secp160r2           710
+#define OBJ_secp160r2           OBJ_secg_ellipticCurve,30L
+
+#define SN_secp192k1            "secp192k1"
+#define NID_secp192k1           711
+#define OBJ_secp192k1           OBJ_secg_ellipticCurve,31L
+
+#define SN_secp224k1            "secp224k1"
+#define NID_secp224k1           712
+#define OBJ_secp224k1           OBJ_secg_ellipticCurve,32L
+
+#define SN_secp224r1            "secp224r1"
+#define NID_secp224r1           713
+#define OBJ_secp224r1           OBJ_secg_ellipticCurve,33L
+
+#define SN_secp256k1            "secp256k1"
+#define NID_secp256k1           714
+#define OBJ_secp256k1           OBJ_secg_ellipticCurve,10L
+
+#define SN_secp384r1            "secp384r1"
+#define NID_secp384r1           715
+#define OBJ_secp384r1           OBJ_secg_ellipticCurve,34L
+
+#define SN_secp521r1            "secp521r1"
+#define NID_secp521r1           716
+#define OBJ_secp521r1           OBJ_secg_ellipticCurve,35L
+
+#define SN_sect113r1            "sect113r1"
+#define NID_sect113r1           717
+#define OBJ_sect113r1           OBJ_secg_ellipticCurve,4L
+
+#define SN_sect113r2            "sect113r2"
+#define NID_sect113r2           718
+#define OBJ_sect113r2           OBJ_secg_ellipticCurve,5L
+
+#define SN_sect131r1            "sect131r1"
+#define NID_sect131r1           719
+#define OBJ_sect131r1           OBJ_secg_ellipticCurve,22L
+
+#define SN_sect131r2            "sect131r2"
+#define NID_sect131r2           720
+#define OBJ_sect131r2           OBJ_secg_ellipticCurve,23L
+
+#define SN_sect163k1            "sect163k1"
+#define NID_sect163k1           721
+#define OBJ_sect163k1           OBJ_secg_ellipticCurve,1L
+
+#define SN_sect163r1            "sect163r1"
+#define NID_sect163r1           722
+#define OBJ_sect163r1           OBJ_secg_ellipticCurve,2L
+
+#define SN_sect163r2            "sect163r2"
+#define NID_sect163r2           723
+#define OBJ_sect163r2           OBJ_secg_ellipticCurve,15L
+
+#define SN_sect193r1            "sect193r1"
+#define NID_sect193r1           724
+#define OBJ_sect193r1           OBJ_secg_ellipticCurve,24L
+
+#define SN_sect193r2            "sect193r2"
+#define NID_sect193r2           725
+#define OBJ_sect193r2           OBJ_secg_ellipticCurve,25L
+
+#define SN_sect233k1            "sect233k1"
+#define NID_sect233k1           726
+#define OBJ_sect233k1           OBJ_secg_ellipticCurve,26L
+
+#define SN_sect233r1            "sect233r1"
+#define NID_sect233r1           727
+#define OBJ_sect233r1           OBJ_secg_ellipticCurve,27L
+
+#define SN_sect239k1            "sect239k1"
+#define NID_sect239k1           728
+#define OBJ_sect239k1           OBJ_secg_ellipticCurve,3L
+
+#define SN_sect283k1            "sect283k1"
+#define NID_sect283k1           729
+#define OBJ_sect283k1           OBJ_secg_ellipticCurve,16L
+
+#define SN_sect283r1            "sect283r1"
+#define NID_sect283r1           730
+#define OBJ_sect283r1           OBJ_secg_ellipticCurve,17L
+
+#define SN_sect409k1            "sect409k1"
+#define NID_sect409k1           731
+#define OBJ_sect409k1           OBJ_secg_ellipticCurve,36L
+
+#define SN_sect409r1            "sect409r1"
+#define NID_sect409r1           732
+#define OBJ_sect409r1           OBJ_secg_ellipticCurve,37L
+
+#define SN_sect571k1            "sect571k1"
+#define NID_sect571k1           733
+#define OBJ_sect571k1           OBJ_secg_ellipticCurve,38L
+
+#define SN_sect571r1            "sect571r1"
+#define NID_sect571r1           734
+#define OBJ_sect571r1           OBJ_secg_ellipticCurve,39L
+
+#define OBJ_wap_wsg_idm_ecid            OBJ_wap_wsg,4L
+
+#define SN_wap_wsg_idm_ecid_wtls1               "wap-wsg-idm-ecid-wtls1"
+#define NID_wap_wsg_idm_ecid_wtls1              735
+#define OBJ_wap_wsg_idm_ecid_wtls1              OBJ_wap_wsg_idm_ecid,1L
+
+#define SN_wap_wsg_idm_ecid_wtls3               "wap-wsg-idm-ecid-wtls3"
+#define NID_wap_wsg_idm_ecid_wtls3              736
+#define OBJ_wap_wsg_idm_ecid_wtls3              OBJ_wap_wsg_idm_ecid,3L
+
+#define SN_wap_wsg_idm_ecid_wtls4               "wap-wsg-idm-ecid-wtls4"
+#define NID_wap_wsg_idm_ecid_wtls4              737
+#define OBJ_wap_wsg_idm_ecid_wtls4              OBJ_wap_wsg_idm_ecid,4L
+
+#define SN_wap_wsg_idm_ecid_wtls5               "wap-wsg-idm-ecid-wtls5"
+#define NID_wap_wsg_idm_ecid_wtls5              738
+#define OBJ_wap_wsg_idm_ecid_wtls5              OBJ_wap_wsg_idm_ecid,5L
+
+#define SN_wap_wsg_idm_ecid_wtls6               "wap-wsg-idm-ecid-wtls6"
+#define NID_wap_wsg_idm_ecid_wtls6              739
+#define OBJ_wap_wsg_idm_ecid_wtls6              OBJ_wap_wsg_idm_ecid,6L
+
+#define SN_wap_wsg_idm_ecid_wtls7               "wap-wsg-idm-ecid-wtls7"
+#define NID_wap_wsg_idm_ecid_wtls7              740
+#define OBJ_wap_wsg_idm_ecid_wtls7              OBJ_wap_wsg_idm_ecid,7L
+
+#define SN_wap_wsg_idm_ecid_wtls8               "wap-wsg-idm-ecid-wtls8"
+#define NID_wap_wsg_idm_ecid_wtls8              741
+#define OBJ_wap_wsg_idm_ecid_wtls8              OBJ_wap_wsg_idm_ecid,8L
+
+#define SN_wap_wsg_idm_ecid_wtls9               "wap-wsg-idm-ecid-wtls9"
+#define NID_wap_wsg_idm_ecid_wtls9              742
+#define OBJ_wap_wsg_idm_ecid_wtls9              OBJ_wap_wsg_idm_ecid,9L
+
+#define SN_wap_wsg_idm_ecid_wtls10              "wap-wsg-idm-ecid-wtls10"
+#define NID_wap_wsg_idm_ecid_wtls10             743
+#define OBJ_wap_wsg_idm_ecid_wtls10             OBJ_wap_wsg_idm_ecid,10L
+
+#define SN_wap_wsg_idm_ecid_wtls11              "wap-wsg-idm-ecid-wtls11"
+#define NID_wap_wsg_idm_ecid_wtls11             744
+#define OBJ_wap_wsg_idm_ecid_wtls11             OBJ_wap_wsg_idm_ecid,11L
+
+#define SN_wap_wsg_idm_ecid_wtls12              "wap-wsg-idm-ecid-wtls12"
+#define NID_wap_wsg_idm_ecid_wtls12             745
+#define OBJ_wap_wsg_idm_ecid_wtls12             OBJ_wap_wsg_idm_ecid,12L
+
+#define SN_cast5_cbc            "CAST5-CBC"
+#define LN_cast5_cbc            "cast5-cbc"
+#define NID_cast5_cbc           108
+#define OBJ_cast5_cbc           OBJ_ISO_US,113533L,7L,66L,10L
+
+#define SN_cast5_ecb            "CAST5-ECB"
+#define LN_cast5_ecb            "cast5-ecb"
+#define NID_cast5_ecb           109
+
+#define SN_cast5_cfb64          "CAST5-CFB"
+#define LN_cast5_cfb64          "cast5-cfb"
+#define NID_cast5_cfb64         110
+
+#define SN_cast5_ofb64          "CAST5-OFB"
+#define LN_cast5_ofb64          "cast5-ofb"
+#define NID_cast5_ofb64         111
+
+#define LN_pbeWithMD5AndCast5_CBC               "pbeWithMD5AndCast5CBC"
+#define NID_pbeWithMD5AndCast5_CBC              112
+#define OBJ_pbeWithMD5AndCast5_CBC              OBJ_ISO_US,113533L,7L,66L,12L
+
+#define SN_id_PasswordBasedMAC          "id-PasswordBasedMAC"
+#define LN_id_PasswordBasedMAC          "password based MAC"
+#define NID_id_PasswordBasedMAC         782
+#define OBJ_id_PasswordBasedMAC         OBJ_ISO_US,113533L,7L,66L,13L
+
+#define SN_id_DHBasedMac                "id-DHBasedMac"
+#define LN_id_DHBasedMac                "Diffie-Hellman based MAC"
+#define NID_id_DHBasedMac               783
+#define OBJ_id_DHBasedMac               OBJ_ISO_US,113533L,7L,66L,30L
+
+#define SN_rsadsi               "rsadsi"
+#define LN_rsadsi               "RSA Data Security, Inc."
+#define NID_rsadsi              1
+#define OBJ_rsadsi              OBJ_ISO_US,113549L
+
+#define SN_pkcs         "pkcs"
+#define LN_pkcs         "RSA Data Security, Inc. PKCS"
+#define NID_pkcs                2
+#define OBJ_pkcs                OBJ_rsadsi,1L
+
+#define SN_pkcs1                "pkcs1"
+#define NID_pkcs1               186
+#define OBJ_pkcs1               OBJ_pkcs,1L
+
+#define LN_rsaEncryption                "rsaEncryption"
+#define NID_rsaEncryption               6
+#define OBJ_rsaEncryption               OBJ_pkcs1,1L
+
+#define SN_md2WithRSAEncryption         "RSA-MD2"
+#define LN_md2WithRSAEncryption         "md2WithRSAEncryption"
+#define NID_md2WithRSAEncryption                7
+#define OBJ_md2WithRSAEncryption                OBJ_pkcs1,2L
+
+#define SN_md4WithRSAEncryption         "RSA-MD4"
+#define LN_md4WithRSAEncryption         "md4WithRSAEncryption"
+#define NID_md4WithRSAEncryption                396
+#define OBJ_md4WithRSAEncryption                OBJ_pkcs1,3L
+
+#define SN_md5WithRSAEncryption         "RSA-MD5"
+#define LN_md5WithRSAEncryption         "md5WithRSAEncryption"
+#define NID_md5WithRSAEncryption                8
+#define OBJ_md5WithRSAEncryption                OBJ_pkcs1,4L
+
+#define SN_sha1WithRSAEncryption                "RSA-SHA1"
+#define LN_sha1WithRSAEncryption                "sha1WithRSAEncryption"
+#define NID_sha1WithRSAEncryption               65
+#define OBJ_sha1WithRSAEncryption               OBJ_pkcs1,5L
+
+#define SN_rsaesOaep            "RSAES-OAEP"
+#define LN_rsaesOaep            "rsaesOaep"
+#define NID_rsaesOaep           919
+#define OBJ_rsaesOaep           OBJ_pkcs1,7L
+
+#define SN_mgf1         "MGF1"
+#define LN_mgf1         "mgf1"
+#define NID_mgf1                911
+#define OBJ_mgf1                OBJ_pkcs1,8L
+
+#define SN_pSpecified           "PSPECIFIED"
+#define LN_pSpecified           "pSpecified"
+#define NID_pSpecified          935
+#define OBJ_pSpecified          OBJ_pkcs1,9L
+
+#define SN_rsassaPss            "RSASSA-PSS"
+#define LN_rsassaPss            "rsassaPss"
+#define NID_rsassaPss           912
+#define OBJ_rsassaPss           OBJ_pkcs1,10L
+
+#define SN_sha256WithRSAEncryption              "RSA-SHA256"
+#define LN_sha256WithRSAEncryption              "sha256WithRSAEncryption"
+#define NID_sha256WithRSAEncryption             668
+#define OBJ_sha256WithRSAEncryption             OBJ_pkcs1,11L
+
+#define SN_sha384WithRSAEncryption              "RSA-SHA384"
+#define LN_sha384WithRSAEncryption              "sha384WithRSAEncryption"
+#define NID_sha384WithRSAEncryption             669
+#define OBJ_sha384WithRSAEncryption             OBJ_pkcs1,12L
+
+#define SN_sha512WithRSAEncryption              "RSA-SHA512"
+#define LN_sha512WithRSAEncryption              "sha512WithRSAEncryption"
+#define NID_sha512WithRSAEncryption             670
+#define OBJ_sha512WithRSAEncryption             OBJ_pkcs1,13L
+
+#define SN_sha224WithRSAEncryption              "RSA-SHA224"
+#define LN_sha224WithRSAEncryption              "sha224WithRSAEncryption"
+#define NID_sha224WithRSAEncryption             671
+#define OBJ_sha224WithRSAEncryption             OBJ_pkcs1,14L
+
+#define SN_sha512_224WithRSAEncryption          "RSA-SHA512/224"
+#define LN_sha512_224WithRSAEncryption          "sha512-224WithRSAEncryption"
+#define NID_sha512_224WithRSAEncryption         1145
+#define OBJ_sha512_224WithRSAEncryption         OBJ_pkcs1,15L
+
+#define SN_sha512_256WithRSAEncryption          "RSA-SHA512/256"
+#define LN_sha512_256WithRSAEncryption          "sha512-256WithRSAEncryption"
+#define NID_sha512_256WithRSAEncryption         1146
+#define OBJ_sha512_256WithRSAEncryption         OBJ_pkcs1,16L
+
+#define SN_pkcs3                "pkcs3"
+#define NID_pkcs3               27
+#define OBJ_pkcs3               OBJ_pkcs,3L
+
+#define LN_dhKeyAgreement               "dhKeyAgreement"
+#define NID_dhKeyAgreement              28
+#define OBJ_dhKeyAgreement              OBJ_pkcs3,1L
+
+#define SN_pkcs5                "pkcs5"
+#define NID_pkcs5               187
+#define OBJ_pkcs5               OBJ_pkcs,5L
+
+#define SN_pbeWithMD2AndDES_CBC         "PBE-MD2-DES"
+#define LN_pbeWithMD2AndDES_CBC         "pbeWithMD2AndDES-CBC"
+#define NID_pbeWithMD2AndDES_CBC                9
+#define OBJ_pbeWithMD2AndDES_CBC                OBJ_pkcs5,1L
+
+#define SN_pbeWithMD5AndDES_CBC         "PBE-MD5-DES"
+#define LN_pbeWithMD5AndDES_CBC         "pbeWithMD5AndDES-CBC"
+#define NID_pbeWithMD5AndDES_CBC                10
+#define OBJ_pbeWithMD5AndDES_CBC                OBJ_pkcs5,3L
+
+#define SN_pbeWithMD2AndRC2_CBC         "PBE-MD2-RC2-64"
+#define LN_pbeWithMD2AndRC2_CBC         "pbeWithMD2AndRC2-CBC"
+#define NID_pbeWithMD2AndRC2_CBC                168
+#define OBJ_pbeWithMD2AndRC2_CBC                OBJ_pkcs5,4L
+
+#define SN_pbeWithMD5AndRC2_CBC         "PBE-MD5-RC2-64"
+#define LN_pbeWithMD5AndRC2_CBC         "pbeWithMD5AndRC2-CBC"
+#define NID_pbeWithMD5AndRC2_CBC                169
+#define OBJ_pbeWithMD5AndRC2_CBC                OBJ_pkcs5,6L
+
+#define SN_pbeWithSHA1AndDES_CBC                "PBE-SHA1-DES"
+#define LN_pbeWithSHA1AndDES_CBC                "pbeWithSHA1AndDES-CBC"
+#define NID_pbeWithSHA1AndDES_CBC               170
+#define OBJ_pbeWithSHA1AndDES_CBC               OBJ_pkcs5,10L
+
+#define SN_pbeWithSHA1AndRC2_CBC                "PBE-SHA1-RC2-64"
+#define LN_pbeWithSHA1AndRC2_CBC                "pbeWithSHA1AndRC2-CBC"
+#define NID_pbeWithSHA1AndRC2_CBC               68
+#define OBJ_pbeWithSHA1AndRC2_CBC               OBJ_pkcs5,11L
+
+#define LN_id_pbkdf2            "PBKDF2"
+#define NID_id_pbkdf2           69
+#define OBJ_id_pbkdf2           OBJ_pkcs5,12L
+
+#define LN_pbes2                "PBES2"
+#define NID_pbes2               161
+#define OBJ_pbes2               OBJ_pkcs5,13L
+
+#define LN_pbmac1               "PBMAC1"
+#define NID_pbmac1              162
+#define OBJ_pbmac1              OBJ_pkcs5,14L
+
+#define SN_pkcs7                "pkcs7"
+#define NID_pkcs7               20
+#define OBJ_pkcs7               OBJ_pkcs,7L
+
+#define LN_pkcs7_data           "pkcs7-data"
+#define NID_pkcs7_data          21
+#define OBJ_pkcs7_data          OBJ_pkcs7,1L
+
+#define LN_pkcs7_signed         "pkcs7-signedData"
+#define NID_pkcs7_signed                22
+#define OBJ_pkcs7_signed                OBJ_pkcs7,2L
+
+#define LN_pkcs7_enveloped              "pkcs7-envelopedData"
+#define NID_pkcs7_enveloped             23
+#define OBJ_pkcs7_enveloped             OBJ_pkcs7,3L
+
+#define LN_pkcs7_signedAndEnveloped             "pkcs7-signedAndEnvelopedData"
+#define NID_pkcs7_signedAndEnveloped            24
+#define OBJ_pkcs7_signedAndEnveloped            OBJ_pkcs7,4L
+
+#define LN_pkcs7_digest         "pkcs7-digestData"
+#define NID_pkcs7_digest                25
+#define OBJ_pkcs7_digest                OBJ_pkcs7,5L
+
+#define LN_pkcs7_encrypted              "pkcs7-encryptedData"
+#define NID_pkcs7_encrypted             26
+#define OBJ_pkcs7_encrypted             OBJ_pkcs7,6L
+
+#define SN_pkcs9                "pkcs9"
+#define NID_pkcs9               47
+#define OBJ_pkcs9               OBJ_pkcs,9L
+
+#define LN_pkcs9_emailAddress           "emailAddress"
+#define NID_pkcs9_emailAddress          48
+#define OBJ_pkcs9_emailAddress          OBJ_pkcs9,1L
+
+#define LN_pkcs9_unstructuredName               "unstructuredName"
+#define NID_pkcs9_unstructuredName              49
+#define OBJ_pkcs9_unstructuredName              OBJ_pkcs9,2L
+
+#define LN_pkcs9_contentType            "contentType"
+#define NID_pkcs9_contentType           50
+#define OBJ_pkcs9_contentType           OBJ_pkcs9,3L
+
+#define LN_pkcs9_messageDigest          "messageDigest"
+#define NID_pkcs9_messageDigest         51
+#define OBJ_pkcs9_messageDigest         OBJ_pkcs9,4L
+
+#define LN_pkcs9_signingTime            "signingTime"
+#define NID_pkcs9_signingTime           52
+#define OBJ_pkcs9_signingTime           OBJ_pkcs9,5L
+
+#define LN_pkcs9_countersignature               "countersignature"
+#define NID_pkcs9_countersignature              53
+#define OBJ_pkcs9_countersignature              OBJ_pkcs9,6L
+
+#define LN_pkcs9_challengePassword              "challengePassword"
+#define NID_pkcs9_challengePassword             54
+#define OBJ_pkcs9_challengePassword             OBJ_pkcs9,7L
+
+#define LN_pkcs9_unstructuredAddress            "unstructuredAddress"
+#define NID_pkcs9_unstructuredAddress           55
+#define OBJ_pkcs9_unstructuredAddress           OBJ_pkcs9,8L
+
+#define LN_pkcs9_extCertAttributes              "extendedCertificateAttributes"
+#define NID_pkcs9_extCertAttributes             56
+#define OBJ_pkcs9_extCertAttributes             OBJ_pkcs9,9L
+
+#define SN_ext_req              "extReq"
+#define LN_ext_req              "Extension Request"
+#define NID_ext_req             172
+#define OBJ_ext_req             OBJ_pkcs9,14L
+
+#define SN_SMIMECapabilities            "SMIME-CAPS"
+#define LN_SMIMECapabilities            "S/MIME Capabilities"
+#define NID_SMIMECapabilities           167
+#define OBJ_SMIMECapabilities           OBJ_pkcs9,15L
+
+#define SN_SMIME                "SMIME"
+#define LN_SMIME                "S/MIME"
+#define NID_SMIME               188
+#define OBJ_SMIME               OBJ_pkcs9,16L
+
+#define SN_id_smime_mod         "id-smime-mod"
+#define NID_id_smime_mod                189
+#define OBJ_id_smime_mod                OBJ_SMIME,0L
+
+#define SN_id_smime_ct          "id-smime-ct"
+#define NID_id_smime_ct         190
+#define OBJ_id_smime_ct         OBJ_SMIME,1L
+
+#define SN_id_smime_aa          "id-smime-aa"
+#define NID_id_smime_aa         191
+#define OBJ_id_smime_aa         OBJ_SMIME,2L
+
+#define SN_id_smime_alg         "id-smime-alg"
+#define NID_id_smime_alg                192
+#define OBJ_id_smime_alg                OBJ_SMIME,3L
+
+#define SN_id_smime_cd          "id-smime-cd"
+#define NID_id_smime_cd         193
+#define OBJ_id_smime_cd         OBJ_SMIME,4L
+
+#define SN_id_smime_spq         "id-smime-spq"
+#define NID_id_smime_spq                194
+#define OBJ_id_smime_spq                OBJ_SMIME,5L
+
+#define SN_id_smime_cti         "id-smime-cti"
+#define NID_id_smime_cti                195
+#define OBJ_id_smime_cti                OBJ_SMIME,6L
+
+#define SN_id_smime_mod_cms             "id-smime-mod-cms"
+#define NID_id_smime_mod_cms            196
+#define OBJ_id_smime_mod_cms            OBJ_id_smime_mod,1L
+
+#define SN_id_smime_mod_ess             "id-smime-mod-ess"
+#define NID_id_smime_mod_ess            197
+#define OBJ_id_smime_mod_ess            OBJ_id_smime_mod,2L
+
+#define SN_id_smime_mod_oid             "id-smime-mod-oid"
+#define NID_id_smime_mod_oid            198
+#define OBJ_id_smime_mod_oid            OBJ_id_smime_mod,3L
+
+#define SN_id_smime_mod_msg_v3          "id-smime-mod-msg-v3"
+#define NID_id_smime_mod_msg_v3         199
+#define OBJ_id_smime_mod_msg_v3         OBJ_id_smime_mod,4L
+
+#define SN_id_smime_mod_ets_eSignature_88               "id-smime-mod-ets-eSignature-88"
+#define NID_id_smime_mod_ets_eSignature_88              200
+#define OBJ_id_smime_mod_ets_eSignature_88              OBJ_id_smime_mod,5L
+
+#define SN_id_smime_mod_ets_eSignature_97               "id-smime-mod-ets-eSignature-97"
+#define NID_id_smime_mod_ets_eSignature_97              201
+#define OBJ_id_smime_mod_ets_eSignature_97              OBJ_id_smime_mod,6L
+
+#define SN_id_smime_mod_ets_eSigPolicy_88               "id-smime-mod-ets-eSigPolicy-88"
+#define NID_id_smime_mod_ets_eSigPolicy_88              202
+#define OBJ_id_smime_mod_ets_eSigPolicy_88              OBJ_id_smime_mod,7L
+
+#define SN_id_smime_mod_ets_eSigPolicy_97               "id-smime-mod-ets-eSigPolicy-97"
+#define NID_id_smime_mod_ets_eSigPolicy_97              203
+#define OBJ_id_smime_mod_ets_eSigPolicy_97              OBJ_id_smime_mod,8L
+
+#define SN_id_smime_ct_receipt          "id-smime-ct-receipt"
+#define NID_id_smime_ct_receipt         204
+#define OBJ_id_smime_ct_receipt         OBJ_id_smime_ct,1L
+
+#define SN_id_smime_ct_authData         "id-smime-ct-authData"
+#define NID_id_smime_ct_authData                205
+#define OBJ_id_smime_ct_authData                OBJ_id_smime_ct,2L
+
+#define SN_id_smime_ct_publishCert              "id-smime-ct-publishCert"
+#define NID_id_smime_ct_publishCert             206
+#define OBJ_id_smime_ct_publishCert             OBJ_id_smime_ct,3L
+
+#define SN_id_smime_ct_TSTInfo          "id-smime-ct-TSTInfo"
+#define NID_id_smime_ct_TSTInfo         207
+#define OBJ_id_smime_ct_TSTInfo         OBJ_id_smime_ct,4L
+
+#define SN_id_smime_ct_TDTInfo          "id-smime-ct-TDTInfo"
+#define NID_id_smime_ct_TDTInfo         208
+#define OBJ_id_smime_ct_TDTInfo         OBJ_id_smime_ct,5L
+
+#define SN_id_smime_ct_contentInfo              "id-smime-ct-contentInfo"
+#define NID_id_smime_ct_contentInfo             209
+#define OBJ_id_smime_ct_contentInfo             OBJ_id_smime_ct,6L
+
+#define SN_id_smime_ct_DVCSRequestData          "id-smime-ct-DVCSRequestData"
+#define NID_id_smime_ct_DVCSRequestData         210
+#define OBJ_id_smime_ct_DVCSRequestData         OBJ_id_smime_ct,7L
+
+#define SN_id_smime_ct_DVCSResponseData         "id-smime-ct-DVCSResponseData"
+#define NID_id_smime_ct_DVCSResponseData                211
+#define OBJ_id_smime_ct_DVCSResponseData                OBJ_id_smime_ct,8L
+
+#define SN_id_smime_ct_compressedData           "id-smime-ct-compressedData"
+#define NID_id_smime_ct_compressedData          786
+#define OBJ_id_smime_ct_compressedData          OBJ_id_smime_ct,9L
+
+#define SN_id_smime_ct_contentCollection                "id-smime-ct-contentCollection"
+#define NID_id_smime_ct_contentCollection               1058
+#define OBJ_id_smime_ct_contentCollection               OBJ_id_smime_ct,19L
+
+#define SN_id_smime_ct_authEnvelopedData                "id-smime-ct-authEnvelopedData"
+#define NID_id_smime_ct_authEnvelopedData               1059
+#define OBJ_id_smime_ct_authEnvelopedData               OBJ_id_smime_ct,23L
+
+#define SN_id_ct_routeOriginAuthz               "id-ct-routeOriginAuthz"
+#define NID_id_ct_routeOriginAuthz              1234
+#define OBJ_id_ct_routeOriginAuthz              OBJ_id_smime_ct,24L
+
+#define SN_id_ct_rpkiManifest           "id-ct-rpkiManifest"
+#define NID_id_ct_rpkiManifest          1235
+#define OBJ_id_ct_rpkiManifest          OBJ_id_smime_ct,26L
+
+#define SN_id_ct_asciiTextWithCRLF              "id-ct-asciiTextWithCRLF"
+#define NID_id_ct_asciiTextWithCRLF             787
+#define OBJ_id_ct_asciiTextWithCRLF             OBJ_id_smime_ct,27L
+
+#define SN_id_ct_xml            "id-ct-xml"
+#define NID_id_ct_xml           1060
+#define OBJ_id_ct_xml           OBJ_id_smime_ct,28L
+
+#define SN_id_ct_rpkiGhostbusters               "id-ct-rpkiGhostbusters"
+#define NID_id_ct_rpkiGhostbusters              1236
+#define OBJ_id_ct_rpkiGhostbusters              OBJ_id_smime_ct,35L
+
+#define SN_id_ct_resourceTaggedAttest           "id-ct-resourceTaggedAttest"
+#define NID_id_ct_resourceTaggedAttest          1237
+#define OBJ_id_ct_resourceTaggedAttest          OBJ_id_smime_ct,36L
+
+#define SN_id_ct_geofeedCSVwithCRLF             "id-ct-geofeedCSVwithCRLF"
+#define NID_id_ct_geofeedCSVwithCRLF            1246
+#define OBJ_id_ct_geofeedCSVwithCRLF            OBJ_id_smime_ct,47L
+
+#define SN_id_ct_signedChecklist                "id-ct-signedChecklist"
+#define NID_id_ct_signedChecklist               1247
+#define OBJ_id_ct_signedChecklist               OBJ_id_smime_ct,48L
+
+#define SN_id_ct_ASPA           "id-ct-ASPA"
+#define NID_id_ct_ASPA          1250
+#define OBJ_id_ct_ASPA          OBJ_id_smime_ct,49L
+
+#define SN_id_ct_signedTAL              "id-ct-signedTAL"
+#define NID_id_ct_signedTAL             1284
+#define OBJ_id_ct_signedTAL             OBJ_id_smime_ct,50L
+
+#define SN_id_ct_rpkiSignedPrefixList           "id-ct-rpkiSignedPrefixList"
+#define NID_id_ct_rpkiSignedPrefixList          1320
+#define OBJ_id_ct_rpkiSignedPrefixList          OBJ_id_smime_ct,51L
+
+#define SN_id_smime_aa_receiptRequest           "id-smime-aa-receiptRequest"
+#define NID_id_smime_aa_receiptRequest          212
+#define OBJ_id_smime_aa_receiptRequest          OBJ_id_smime_aa,1L
+
+#define SN_id_smime_aa_securityLabel            "id-smime-aa-securityLabel"
+#define NID_id_smime_aa_securityLabel           213
+#define OBJ_id_smime_aa_securityLabel           OBJ_id_smime_aa,2L
+
+#define SN_id_smime_aa_mlExpandHistory          "id-smime-aa-mlExpandHistory"
+#define NID_id_smime_aa_mlExpandHistory         214
+#define OBJ_id_smime_aa_mlExpandHistory         OBJ_id_smime_aa,3L
+
+#define SN_id_smime_aa_contentHint              "id-smime-aa-contentHint"
+#define NID_id_smime_aa_contentHint             215
+#define OBJ_id_smime_aa_contentHint             OBJ_id_smime_aa,4L
+
+#define SN_id_smime_aa_msgSigDigest             "id-smime-aa-msgSigDigest"
+#define NID_id_smime_aa_msgSigDigest            216
+#define OBJ_id_smime_aa_msgSigDigest            OBJ_id_smime_aa,5L
+
+#define SN_id_smime_aa_encapContentType         "id-smime-aa-encapContentType"
+#define NID_id_smime_aa_encapContentType                217
+#define OBJ_id_smime_aa_encapContentType                OBJ_id_smime_aa,6L
+
+#define SN_id_smime_aa_contentIdentifier                "id-smime-aa-contentIdentifier"
+#define NID_id_smime_aa_contentIdentifier               218
+#define OBJ_id_smime_aa_contentIdentifier               OBJ_id_smime_aa,7L
+
+#define SN_id_smime_aa_macValue         "id-smime-aa-macValue"
+#define NID_id_smime_aa_macValue                219
+#define OBJ_id_smime_aa_macValue                OBJ_id_smime_aa,8L
+
+#define SN_id_smime_aa_equivalentLabels         "id-smime-aa-equivalentLabels"
+#define NID_id_smime_aa_equivalentLabels                220
+#define OBJ_id_smime_aa_equivalentLabels                OBJ_id_smime_aa,9L
+
+#define SN_id_smime_aa_contentReference         "id-smime-aa-contentReference"
+#define NID_id_smime_aa_contentReference                221
+#define OBJ_id_smime_aa_contentReference                OBJ_id_smime_aa,10L
+
+#define SN_id_smime_aa_encrypKeyPref            "id-smime-aa-encrypKeyPref"
+#define NID_id_smime_aa_encrypKeyPref           222
+#define OBJ_id_smime_aa_encrypKeyPref           OBJ_id_smime_aa,11L
+
+#define SN_id_smime_aa_signingCertificate               "id-smime-aa-signingCertificate"
+#define NID_id_smime_aa_signingCertificate              223
+#define OBJ_id_smime_aa_signingCertificate              OBJ_id_smime_aa,12L
+
+#define SN_id_smime_aa_smimeEncryptCerts                "id-smime-aa-smimeEncryptCerts"
+#define NID_id_smime_aa_smimeEncryptCerts               224
+#define OBJ_id_smime_aa_smimeEncryptCerts               OBJ_id_smime_aa,13L
+
+#define SN_id_smime_aa_timeStampToken           "id-smime-aa-timeStampToken"
+#define NID_id_smime_aa_timeStampToken          225
+#define OBJ_id_smime_aa_timeStampToken          OBJ_id_smime_aa,14L
+
+#define SN_id_smime_aa_ets_sigPolicyId          "id-smime-aa-ets-sigPolicyId"
+#define NID_id_smime_aa_ets_sigPolicyId         226
+#define OBJ_id_smime_aa_ets_sigPolicyId         OBJ_id_smime_aa,15L
+
+#define SN_id_smime_aa_ets_commitmentType               "id-smime-aa-ets-commitmentType"
+#define NID_id_smime_aa_ets_commitmentType              227
+#define OBJ_id_smime_aa_ets_commitmentType              OBJ_id_smime_aa,16L
+
+#define SN_id_smime_aa_ets_signerLocation               "id-smime-aa-ets-signerLocation"
+#define NID_id_smime_aa_ets_signerLocation              228
+#define OBJ_id_smime_aa_ets_signerLocation              OBJ_id_smime_aa,17L
+
+#define SN_id_smime_aa_ets_signerAttr           "id-smime-aa-ets-signerAttr"
+#define NID_id_smime_aa_ets_signerAttr          229
+#define OBJ_id_smime_aa_ets_signerAttr          OBJ_id_smime_aa,18L
+
+#define SN_id_smime_aa_ets_otherSigCert         "id-smime-aa-ets-otherSigCert"
+#define NID_id_smime_aa_ets_otherSigCert                230
+#define OBJ_id_smime_aa_ets_otherSigCert                OBJ_id_smime_aa,19L
+
+#define SN_id_smime_aa_ets_contentTimestamp             "id-smime-aa-ets-contentTimestamp"
+#define NID_id_smime_aa_ets_contentTimestamp            231
+#define OBJ_id_smime_aa_ets_contentTimestamp            OBJ_id_smime_aa,20L
+
+#define SN_id_smime_aa_ets_CertificateRefs              "id-smime-aa-ets-CertificateRefs"
+#define NID_id_smime_aa_ets_CertificateRefs             232
+#define OBJ_id_smime_aa_ets_CertificateRefs             OBJ_id_smime_aa,21L
+
+#define SN_id_smime_aa_ets_RevocationRefs               "id-smime-aa-ets-RevocationRefs"
+#define NID_id_smime_aa_ets_RevocationRefs              233
+#define OBJ_id_smime_aa_ets_RevocationRefs              OBJ_id_smime_aa,22L
+
+#define SN_id_smime_aa_ets_certValues           "id-smime-aa-ets-certValues"
+#define NID_id_smime_aa_ets_certValues          234
+#define OBJ_id_smime_aa_ets_certValues          OBJ_id_smime_aa,23L
+
+#define SN_id_smime_aa_ets_revocationValues             "id-smime-aa-ets-revocationValues"
+#define NID_id_smime_aa_ets_revocationValues            235
+#define OBJ_id_smime_aa_ets_revocationValues            OBJ_id_smime_aa,24L
+
+#define SN_id_smime_aa_ets_escTimeStamp         "id-smime-aa-ets-escTimeStamp"
+#define NID_id_smime_aa_ets_escTimeStamp                236
+#define OBJ_id_smime_aa_ets_escTimeStamp                OBJ_id_smime_aa,25L
+
+#define SN_id_smime_aa_ets_certCRLTimestamp             "id-smime-aa-ets-certCRLTimestamp"
+#define NID_id_smime_aa_ets_certCRLTimestamp            237
+#define OBJ_id_smime_aa_ets_certCRLTimestamp            OBJ_id_smime_aa,26L
+
+#define SN_id_smime_aa_ets_archiveTimeStamp             "id-smime-aa-ets-archiveTimeStamp"
+#define NID_id_smime_aa_ets_archiveTimeStamp            238
+#define OBJ_id_smime_aa_ets_archiveTimeStamp            OBJ_id_smime_aa,27L
+
+#define SN_id_smime_aa_signatureType            "id-smime-aa-signatureType"
+#define NID_id_smime_aa_signatureType           239
+#define OBJ_id_smime_aa_signatureType           OBJ_id_smime_aa,28L
+
+#define SN_id_smime_aa_dvcs_dvc         "id-smime-aa-dvcs-dvc"
+#define NID_id_smime_aa_dvcs_dvc                240
+#define OBJ_id_smime_aa_dvcs_dvc                OBJ_id_smime_aa,29L
+
+#define SN_id_aa_ets_attrCertificateRefs                "id-aa-ets-attrCertificateRefs"
+#define NID_id_aa_ets_attrCertificateRefs               1261
+#define OBJ_id_aa_ets_attrCertificateRefs               OBJ_id_smime_aa,44L
+
+#define SN_id_aa_ets_attrRevocationRefs         "id-aa-ets-attrRevocationRefs"
+#define NID_id_aa_ets_attrRevocationRefs                1262
+#define OBJ_id_aa_ets_attrRevocationRefs                OBJ_id_smime_aa,45L
+
+#define SN_id_smime_aa_signingCertificateV2             "id-smime-aa-signingCertificateV2"
+#define NID_id_smime_aa_signingCertificateV2            1086
+#define OBJ_id_smime_aa_signingCertificateV2            OBJ_id_smime_aa,47L
+
+#define SN_id_aa_ets_archiveTimestampV2         "id-aa-ets-archiveTimestampV2"
+#define NID_id_aa_ets_archiveTimestampV2                1280
+#define OBJ_id_aa_ets_archiveTimestampV2                OBJ_id_smime_aa,48L
+
+#define SN_id_smime_alg_ESDHwith3DES            "id-smime-alg-ESDHwith3DES"
+#define NID_id_smime_alg_ESDHwith3DES           241
+#define OBJ_id_smime_alg_ESDHwith3DES           OBJ_id_smime_alg,1L
+
+#define SN_id_smime_alg_ESDHwithRC2             "id-smime-alg-ESDHwithRC2"
+#define NID_id_smime_alg_ESDHwithRC2            242
+#define OBJ_id_smime_alg_ESDHwithRC2            OBJ_id_smime_alg,2L
+
+#define SN_id_smime_alg_3DESwrap                "id-smime-alg-3DESwrap"
+#define NID_id_smime_alg_3DESwrap               243
+#define OBJ_id_smime_alg_3DESwrap               OBJ_id_smime_alg,3L
+
+#define SN_id_smime_alg_RC2wrap         "id-smime-alg-RC2wrap"
+#define NID_id_smime_alg_RC2wrap                244
+#define OBJ_id_smime_alg_RC2wrap                OBJ_id_smime_alg,4L
+
+#define SN_id_smime_alg_ESDH            "id-smime-alg-ESDH"
+#define NID_id_smime_alg_ESDH           245
+#define OBJ_id_smime_alg_ESDH           OBJ_id_smime_alg,5L
+
+#define SN_id_smime_alg_CMS3DESwrap             "id-smime-alg-CMS3DESwrap"
+#define NID_id_smime_alg_CMS3DESwrap            246
+#define OBJ_id_smime_alg_CMS3DESwrap            OBJ_id_smime_alg,6L
+
+#define SN_id_smime_alg_CMSRC2wrap              "id-smime-alg-CMSRC2wrap"
+#define NID_id_smime_alg_CMSRC2wrap             247
+#define OBJ_id_smime_alg_CMSRC2wrap             OBJ_id_smime_alg,7L
+
+#define SN_id_alg_PWRI_KEK              "id-alg-PWRI-KEK"
+#define NID_id_alg_PWRI_KEK             893
+#define OBJ_id_alg_PWRI_KEK             OBJ_id_smime_alg,9L
+
+#define SN_id_smime_cd_ldap             "id-smime-cd-ldap"
+#define NID_id_smime_cd_ldap            248
+#define OBJ_id_smime_cd_ldap            OBJ_id_smime_cd,1L
+
+#define SN_id_smime_spq_ets_sqt_uri             "id-smime-spq-ets-sqt-uri"
+#define NID_id_smime_spq_ets_sqt_uri            249
+#define OBJ_id_smime_spq_ets_sqt_uri            OBJ_id_smime_spq,1L
+
+#define SN_id_smime_spq_ets_sqt_unotice         "id-smime-spq-ets-sqt-unotice"
+#define NID_id_smime_spq_ets_sqt_unotice                250
+#define OBJ_id_smime_spq_ets_sqt_unotice                OBJ_id_smime_spq,2L
+
+#define SN_id_smime_cti_ets_proofOfOrigin               "id-smime-cti-ets-proofOfOrigin"
+#define NID_id_smime_cti_ets_proofOfOrigin              251
+#define OBJ_id_smime_cti_ets_proofOfOrigin              OBJ_id_smime_cti,1L
+
+#define SN_id_smime_cti_ets_proofOfReceipt              "id-smime-cti-ets-proofOfReceipt"
+#define NID_id_smime_cti_ets_proofOfReceipt             252
+#define OBJ_id_smime_cti_ets_proofOfReceipt             OBJ_id_smime_cti,2L
+
+#define SN_id_smime_cti_ets_proofOfDelivery             "id-smime-cti-ets-proofOfDelivery"
+#define NID_id_smime_cti_ets_proofOfDelivery            253
+#define OBJ_id_smime_cti_ets_proofOfDelivery            OBJ_id_smime_cti,3L
+
+#define SN_id_smime_cti_ets_proofOfSender               "id-smime-cti-ets-proofOfSender"
+#define NID_id_smime_cti_ets_proofOfSender              254
+#define OBJ_id_smime_cti_ets_proofOfSender              OBJ_id_smime_cti,4L
+
+#define SN_id_smime_cti_ets_proofOfApproval             "id-smime-cti-ets-proofOfApproval"
+#define NID_id_smime_cti_ets_proofOfApproval            255
+#define OBJ_id_smime_cti_ets_proofOfApproval            OBJ_id_smime_cti,5L
+
+#define SN_id_smime_cti_ets_proofOfCreation             "id-smime-cti-ets-proofOfCreation"
+#define NID_id_smime_cti_ets_proofOfCreation            256
+#define OBJ_id_smime_cti_ets_proofOfCreation            OBJ_id_smime_cti,6L
+
+#define LN_friendlyName         "friendlyName"
+#define NID_friendlyName                156
+#define OBJ_friendlyName                OBJ_pkcs9,20L
+
+#define LN_localKeyID           "localKeyID"
+#define NID_localKeyID          157
+#define OBJ_localKeyID          OBJ_pkcs9,21L
+
+#define OBJ_ms_corp             1L,3L,6L,1L,4L,1L,311L
+
+#define SN_ms_csp_name          "CSPName"
+#define LN_ms_csp_name          "Microsoft CSP Name"
+#define NID_ms_csp_name         417
+#define OBJ_ms_csp_name         OBJ_ms_corp,17L,1L
+
+#define SN_LocalKeySet          "LocalKeySet"
+#define LN_LocalKeySet          "Microsoft Local Key set"
+#define NID_LocalKeySet         856
+#define OBJ_LocalKeySet         OBJ_ms_corp,17L,2L
+
+#define OBJ_certTypes           OBJ_pkcs9,22L
+
+#define LN_x509Certificate              "x509Certificate"
+#define NID_x509Certificate             158
+#define OBJ_x509Certificate             OBJ_certTypes,1L
+
+#define LN_sdsiCertificate              "sdsiCertificate"
+#define NID_sdsiCertificate             159
+#define OBJ_sdsiCertificate             OBJ_certTypes,2L
+
+#define OBJ_crlTypes            OBJ_pkcs9,23L
+
+#define LN_x509Crl              "x509Crl"
+#define NID_x509Crl             160
+#define OBJ_x509Crl             OBJ_crlTypes,1L
+
+#define SN_id_aa_CMSAlgorithmProtection         "id-aa-CMSAlgorithmProtection"
+#define NID_id_aa_CMSAlgorithmProtection                1263
+#define OBJ_id_aa_CMSAlgorithmProtection                OBJ_pkcs9,52L
+
+#define OBJ_pkcs12              OBJ_pkcs,12L
+
+#define OBJ_pkcs12_pbeids               OBJ_pkcs12,1L
+
+#define SN_pbe_WithSHA1And128BitRC4             "PBE-SHA1-RC4-128"
+#define LN_pbe_WithSHA1And128BitRC4             "pbeWithSHA1And128BitRC4"
+#define NID_pbe_WithSHA1And128BitRC4            144
+#define OBJ_pbe_WithSHA1And128BitRC4            OBJ_pkcs12_pbeids,1L
+
+#define SN_pbe_WithSHA1And40BitRC4              "PBE-SHA1-RC4-40"
+#define LN_pbe_WithSHA1And40BitRC4              "pbeWithSHA1And40BitRC4"
+#define NID_pbe_WithSHA1And40BitRC4             145
+#define OBJ_pbe_WithSHA1And40BitRC4             OBJ_pkcs12_pbeids,2L
+
+#define SN_pbe_WithSHA1And3_Key_TripleDES_CBC           "PBE-SHA1-3DES"
+#define LN_pbe_WithSHA1And3_Key_TripleDES_CBC           "pbeWithSHA1And3-KeyTripleDES-CBC"
+#define NID_pbe_WithSHA1And3_Key_TripleDES_CBC          146
+#define OBJ_pbe_WithSHA1And3_Key_TripleDES_CBC          OBJ_pkcs12_pbeids,3L
+
+#define SN_pbe_WithSHA1And2_Key_TripleDES_CBC           "PBE-SHA1-2DES"
+#define LN_pbe_WithSHA1And2_Key_TripleDES_CBC           "pbeWithSHA1And2-KeyTripleDES-CBC"
+#define NID_pbe_WithSHA1And2_Key_TripleDES_CBC          147
+#define OBJ_pbe_WithSHA1And2_Key_TripleDES_CBC          OBJ_pkcs12_pbeids,4L
+
+#define SN_pbe_WithSHA1And128BitRC2_CBC         "PBE-SHA1-RC2-128"
+#define LN_pbe_WithSHA1And128BitRC2_CBC         "pbeWithSHA1And128BitRC2-CBC"
+#define NID_pbe_WithSHA1And128BitRC2_CBC                148
+#define OBJ_pbe_WithSHA1And128BitRC2_CBC                OBJ_pkcs12_pbeids,5L
+
+#define SN_pbe_WithSHA1And40BitRC2_CBC          "PBE-SHA1-RC2-40"
+#define LN_pbe_WithSHA1And40BitRC2_CBC          "pbeWithSHA1And40BitRC2-CBC"
+#define NID_pbe_WithSHA1And40BitRC2_CBC         149
+#define OBJ_pbe_WithSHA1And40BitRC2_CBC         OBJ_pkcs12_pbeids,6L
+
+#define OBJ_pkcs12_Version1             OBJ_pkcs12,10L
+
+#define OBJ_pkcs12_BagIds               OBJ_pkcs12_Version1,1L
+
+#define LN_keyBag               "keyBag"
+#define NID_keyBag              150
+#define OBJ_keyBag              OBJ_pkcs12_BagIds,1L
+
+#define LN_pkcs8ShroudedKeyBag          "pkcs8ShroudedKeyBag"
+#define NID_pkcs8ShroudedKeyBag         151
+#define OBJ_pkcs8ShroudedKeyBag         OBJ_pkcs12_BagIds,2L
+
+#define LN_certBag              "certBag"
+#define NID_certBag             152
+#define OBJ_certBag             OBJ_pkcs12_BagIds,3L
+
+#define LN_crlBag               "crlBag"
+#define NID_crlBag              153
+#define OBJ_crlBag              OBJ_pkcs12_BagIds,4L
+
+#define LN_secretBag            "secretBag"
+#define NID_secretBag           154
+#define OBJ_secretBag           OBJ_pkcs12_BagIds,5L
+
+#define LN_safeContentsBag              "safeContentsBag"
+#define NID_safeContentsBag             155
+#define OBJ_safeContentsBag             OBJ_pkcs12_BagIds,6L
+
+#define SN_md2          "MD2"
+#define LN_md2          "md2"
+#define NID_md2         3
+#define OBJ_md2         OBJ_rsadsi,2L,2L
+
+#define SN_md4          "MD4"
+#define LN_md4          "md4"
+#define NID_md4         257
+#define OBJ_md4         OBJ_rsadsi,2L,4L
+
+#define SN_md5          "MD5"
+#define LN_md5          "md5"
+#define NID_md5         4
+#define OBJ_md5         OBJ_rsadsi,2L,5L
+
+#define SN_md5_sha1             "MD5-SHA1"
+#define LN_md5_sha1             "md5-sha1"
+#define NID_md5_sha1            114
+
+#define LN_hmacWithMD5          "hmacWithMD5"
+#define NID_hmacWithMD5         797
+#define OBJ_hmacWithMD5         OBJ_rsadsi,2L,6L
+
+#define LN_hmacWithSHA1         "hmacWithSHA1"
+#define NID_hmacWithSHA1                163
+#define OBJ_hmacWithSHA1                OBJ_rsadsi,2L,7L
+
+#define SN_sm2          "SM2"
+#define LN_sm2          "sm2"
+#define NID_sm2         1172
+#define OBJ_sm2         OBJ_sm_scheme,301L
+
+#define SN_sm3          "SM3"
+#define LN_sm3          "sm3"
+#define NID_sm3         1143
+#define OBJ_sm3         OBJ_sm_scheme,401L
+
+#define SN_sm3WithRSAEncryption         "RSA-SM3"
+#define LN_sm3WithRSAEncryption         "sm3WithRSAEncryption"
+#define NID_sm3WithRSAEncryption                1144
+#define OBJ_sm3WithRSAEncryption                OBJ_sm_scheme,504L
+
+#define SN_SM2_with_SM3         "SM2-SM3"
+#define LN_SM2_with_SM3         "SM2-with-SM3"
+#define NID_SM2_with_SM3                1204
+#define OBJ_SM2_with_SM3                OBJ_sm_scheme,501L
+
+#define LN_hmacWithSM3          "hmacWithSM3"
+#define NID_hmacWithSM3         1281
+#define OBJ_hmacWithSM3         OBJ_sm3,3L,1L
+
+#define LN_hmacWithSHA224               "hmacWithSHA224"
+#define NID_hmacWithSHA224              798
+#define OBJ_hmacWithSHA224              OBJ_rsadsi,2L,8L
+
+#define LN_hmacWithSHA256               "hmacWithSHA256"
+#define NID_hmacWithSHA256              799
+#define OBJ_hmacWithSHA256              OBJ_rsadsi,2L,9L
+
+#define LN_hmacWithSHA384               "hmacWithSHA384"
+#define NID_hmacWithSHA384              800
+#define OBJ_hmacWithSHA384              OBJ_rsadsi,2L,10L
+
+#define LN_hmacWithSHA512               "hmacWithSHA512"
+#define NID_hmacWithSHA512              801
+#define OBJ_hmacWithSHA512              OBJ_rsadsi,2L,11L
+
+#define LN_hmacWithSHA512_224           "hmacWithSHA512-224"
+#define NID_hmacWithSHA512_224          1193
+#define OBJ_hmacWithSHA512_224          OBJ_rsadsi,2L,12L
+
+#define LN_hmacWithSHA512_256           "hmacWithSHA512-256"
+#define NID_hmacWithSHA512_256          1194
+#define OBJ_hmacWithSHA512_256          OBJ_rsadsi,2L,13L
+
+#define SN_rc2_cbc              "RC2-CBC"
+#define LN_rc2_cbc              "rc2-cbc"
+#define NID_rc2_cbc             37
+#define OBJ_rc2_cbc             OBJ_rsadsi,3L,2L
+
+#define SN_rc2_ecb              "RC2-ECB"
+#define LN_rc2_ecb              "rc2-ecb"
+#define NID_rc2_ecb             38
+
+#define SN_rc2_cfb64            "RC2-CFB"
+#define LN_rc2_cfb64            "rc2-cfb"
+#define NID_rc2_cfb64           39
+
+#define SN_rc2_ofb64            "RC2-OFB"
+#define LN_rc2_ofb64            "rc2-ofb"
+#define NID_rc2_ofb64           40
+
+#define SN_rc2_40_cbc           "RC2-40-CBC"
+#define LN_rc2_40_cbc           "rc2-40-cbc"
+#define NID_rc2_40_cbc          98
+
+#define SN_rc2_64_cbc           "RC2-64-CBC"
+#define LN_rc2_64_cbc           "rc2-64-cbc"
+#define NID_rc2_64_cbc          166
+
+#define SN_rc4          "RC4"
+#define LN_rc4          "rc4"
+#define NID_rc4         5
+#define OBJ_rc4         OBJ_rsadsi,3L,4L
+
+#define SN_rc4_40               "RC4-40"
+#define LN_rc4_40               "rc4-40"
+#define NID_rc4_40              97
+
+#define SN_des_ede3_cbc         "DES-EDE3-CBC"
+#define LN_des_ede3_cbc         "des-ede3-cbc"
+#define NID_des_ede3_cbc                44
+#define OBJ_des_ede3_cbc                OBJ_rsadsi,3L,7L
+
+#define SN_rc5_cbc              "RC5-CBC"
+#define LN_rc5_cbc              "rc5-cbc"
+#define NID_rc5_cbc             120
+#define OBJ_rc5_cbc             OBJ_rsadsi,3L,8L
+
+#define SN_rc5_ecb              "RC5-ECB"
+#define LN_rc5_ecb              "rc5-ecb"
+#define NID_rc5_ecb             121
+
+#define SN_rc5_cfb64            "RC5-CFB"
+#define LN_rc5_cfb64            "rc5-cfb"
+#define NID_rc5_cfb64           122
+
+#define SN_rc5_ofb64            "RC5-OFB"
+#define LN_rc5_ofb64            "rc5-ofb"
+#define NID_rc5_ofb64           123
+
+#define SN_ms_ext_req           "msExtReq"
+#define LN_ms_ext_req           "Microsoft Extension Request"
+#define NID_ms_ext_req          171
+#define OBJ_ms_ext_req          OBJ_ms_corp,2L,1L,14L
+
+#define SN_ms_code_ind          "msCodeInd"
+#define LN_ms_code_ind          "Microsoft Individual Code Signing"
+#define NID_ms_code_ind         134
+#define OBJ_ms_code_ind         OBJ_ms_corp,2L,1L,21L
+
+#define SN_ms_code_com          "msCodeCom"
+#define LN_ms_code_com          "Microsoft Commercial Code Signing"
+#define NID_ms_code_com         135
+#define OBJ_ms_code_com         OBJ_ms_corp,2L,1L,22L
+
+#define SN_ms_ctl_sign          "msCTLSign"
+#define LN_ms_ctl_sign          "Microsoft Trust List Signing"
+#define NID_ms_ctl_sign         136
+#define OBJ_ms_ctl_sign         OBJ_ms_corp,10L,3L,1L
+
+#define SN_ms_sgc               "msSGC"
+#define LN_ms_sgc               "Microsoft Server Gated Crypto"
+#define NID_ms_sgc              137
+#define OBJ_ms_sgc              OBJ_ms_corp,10L,3L,3L
+
+#define SN_ms_efs               "msEFS"
+#define LN_ms_efs               "Microsoft Encrypted File System"
+#define NID_ms_efs              138
+#define OBJ_ms_efs              OBJ_ms_corp,10L,3L,4L
+
+#define SN_ms_smartcard_login           "msSmartcardLogin"
+#define LN_ms_smartcard_login           "Microsoft Smartcard Login"
+#define NID_ms_smartcard_login          648
+#define OBJ_ms_smartcard_login          OBJ_ms_corp,20L,2L,2L
+
+#define SN_ms_upn               "msUPN"
+#define LN_ms_upn               "Microsoft User Principal Name"
+#define NID_ms_upn              649
+#define OBJ_ms_upn              OBJ_ms_corp,20L,2L,3L
+
+#define SN_ms_ntds_sec_ext              "ms-ntds-sec-ext"
+#define LN_ms_ntds_sec_ext              "Microsoft NTDS CA Extension"
+#define NID_ms_ntds_sec_ext             1292
+#define OBJ_ms_ntds_sec_ext             OBJ_ms_corp,25L,2L
+
+#define SN_ms_ntds_obj_sid              "ms-ntds-obj-sid"
+#define LN_ms_ntds_obj_sid              "Microsoft NTDS AD objectSid"
+#define NID_ms_ntds_obj_sid             1291
+#define OBJ_ms_ntds_obj_sid             OBJ_ms_corp,25L,2L,1L
+
+#define SN_ms_cert_templ                "ms-cert-templ"
+#define LN_ms_cert_templ                "Microsoft certificate template"
+#define NID_ms_cert_templ               1293
+#define OBJ_ms_cert_templ               OBJ_ms_corp,21L,7L
+
+#define SN_ms_app_policies              "ms-app-policies"
+#define LN_ms_app_policies              "Microsoft Application Policies Extension"
+#define NID_ms_app_policies             1294
+#define OBJ_ms_app_policies             OBJ_ms_corp,21L,10L
+
+#define SN_idea_cbc             "IDEA-CBC"
+#define LN_idea_cbc             "idea-cbc"
+#define NID_idea_cbc            34
+#define OBJ_idea_cbc            1L,3L,6L,1L,4L,1L,188L,7L,1L,1L,2L
+
+#define SN_idea_ecb             "IDEA-ECB"
+#define LN_idea_ecb             "idea-ecb"
+#define NID_idea_ecb            36
+
+#define SN_idea_cfb64           "IDEA-CFB"
+#define LN_idea_cfb64           "idea-cfb"
+#define NID_idea_cfb64          35
+
+#define SN_idea_ofb64           "IDEA-OFB"
+#define LN_idea_ofb64           "idea-ofb"
+#define NID_idea_ofb64          46
+
+#define SN_bf_cbc               "BF-CBC"
+#define LN_bf_cbc               "bf-cbc"
+#define NID_bf_cbc              91
+#define OBJ_bf_cbc              1L,3L,6L,1L,4L,1L,3029L,1L,2L
+
+#define SN_bf_ecb               "BF-ECB"
+#define LN_bf_ecb               "bf-ecb"
+#define NID_bf_ecb              92
+
+#define SN_bf_cfb64             "BF-CFB"
+#define LN_bf_cfb64             "bf-cfb"
+#define NID_bf_cfb64            93
+
+#define SN_bf_ofb64             "BF-OFB"
+#define LN_bf_ofb64             "bf-ofb"
+#define NID_bf_ofb64            94
+
+#define SN_id_pkix              "PKIX"
+#define NID_id_pkix             127
+#define OBJ_id_pkix             1L,3L,6L,1L,5L,5L,7L
+
+#define SN_id_pkix_mod          "id-pkix-mod"
+#define NID_id_pkix_mod         258
+#define OBJ_id_pkix_mod         OBJ_id_pkix,0L
+
+#define SN_id_pe                "id-pe"
+#define NID_id_pe               175
+#define OBJ_id_pe               OBJ_id_pkix,1L
+
+#define SN_id_qt                "id-qt"
+#define NID_id_qt               259
+#define OBJ_id_qt               OBJ_id_pkix,2L
+
+#define SN_id_kp                "id-kp"
+#define NID_id_kp               128
+#define OBJ_id_kp               OBJ_id_pkix,3L
+
+#define SN_id_it                "id-it"
+#define NID_id_it               260
+#define OBJ_id_it               OBJ_id_pkix,4L
+
+#define SN_id_pkip              "id-pkip"
+#define NID_id_pkip             261
+#define OBJ_id_pkip             OBJ_id_pkix,5L
+
+#define SN_id_alg               "id-alg"
+#define NID_id_alg              262
+#define OBJ_id_alg              OBJ_id_pkix,6L
+
+#define SN_id_cmc               "id-cmc"
+#define NID_id_cmc              263
+#define OBJ_id_cmc              OBJ_id_pkix,7L
+
+#define SN_id_on                "id-on"
+#define NID_id_on               264
+#define OBJ_id_on               OBJ_id_pkix,8L
+
+#define SN_id_pda               "id-pda"
+#define NID_id_pda              265
+#define OBJ_id_pda              OBJ_id_pkix,9L
+
+#define SN_id_aca               "id-aca"
+#define NID_id_aca              266
+#define OBJ_id_aca              OBJ_id_pkix,10L
+
+#define SN_id_qcs               "id-qcs"
+#define NID_id_qcs              267
+#define OBJ_id_qcs              OBJ_id_pkix,11L
+
+#define SN_id_cp                "id-cp"
+#define NID_id_cp               1238
+#define OBJ_id_cp               OBJ_id_pkix,14L
+
+#define SN_id_cct               "id-cct"
+#define NID_id_cct              268
+#define OBJ_id_cct              OBJ_id_pkix,12L
+
+#define SN_id_ppl               "id-ppl"
+#define NID_id_ppl              662
+#define OBJ_id_ppl              OBJ_id_pkix,21L
+
+#define SN_id_ad                "id-ad"
+#define NID_id_ad               176
+#define OBJ_id_ad               OBJ_id_pkix,48L
+
+#define SN_id_pkix1_explicit_88         "id-pkix1-explicit-88"
+#define NID_id_pkix1_explicit_88                269
+#define OBJ_id_pkix1_explicit_88                OBJ_id_pkix_mod,1L
+
+#define SN_id_pkix1_implicit_88         "id-pkix1-implicit-88"
+#define NID_id_pkix1_implicit_88                270
+#define OBJ_id_pkix1_implicit_88                OBJ_id_pkix_mod,2L
+
+#define SN_id_pkix1_explicit_93         "id-pkix1-explicit-93"
+#define NID_id_pkix1_explicit_93                271
+#define OBJ_id_pkix1_explicit_93                OBJ_id_pkix_mod,3L
+
+#define SN_id_pkix1_implicit_93         "id-pkix1-implicit-93"
+#define NID_id_pkix1_implicit_93                272
+#define OBJ_id_pkix1_implicit_93                OBJ_id_pkix_mod,4L
+
+#define SN_id_mod_crmf          "id-mod-crmf"
+#define NID_id_mod_crmf         273
+#define OBJ_id_mod_crmf         OBJ_id_pkix_mod,5L
+
+#define SN_id_mod_cmc           "id-mod-cmc"
+#define NID_id_mod_cmc          274
+#define OBJ_id_mod_cmc          OBJ_id_pkix_mod,6L
+
+#define SN_id_mod_kea_profile_88                "id-mod-kea-profile-88"
+#define NID_id_mod_kea_profile_88               275
+#define OBJ_id_mod_kea_profile_88               OBJ_id_pkix_mod,7L
+
+#define SN_id_mod_kea_profile_93                "id-mod-kea-profile-93"
+#define NID_id_mod_kea_profile_93               276
+#define OBJ_id_mod_kea_profile_93               OBJ_id_pkix_mod,8L
+
+#define SN_id_mod_cmp           "id-mod-cmp"
+#define NID_id_mod_cmp          277
+#define OBJ_id_mod_cmp          OBJ_id_pkix_mod,9L
+
+#define SN_id_mod_qualified_cert_88             "id-mod-qualified-cert-88"
+#define NID_id_mod_qualified_cert_88            278
+#define OBJ_id_mod_qualified_cert_88            OBJ_id_pkix_mod,10L
+
+#define SN_id_mod_qualified_cert_93             "id-mod-qualified-cert-93"
+#define NID_id_mod_qualified_cert_93            279
+#define OBJ_id_mod_qualified_cert_93            OBJ_id_pkix_mod,11L
+
+#define SN_id_mod_attribute_cert                "id-mod-attribute-cert"
+#define NID_id_mod_attribute_cert               280
+#define OBJ_id_mod_attribute_cert               OBJ_id_pkix_mod,12L
+
+#define SN_id_mod_timestamp_protocol            "id-mod-timestamp-protocol"
+#define NID_id_mod_timestamp_protocol           281
+#define OBJ_id_mod_timestamp_protocol           OBJ_id_pkix_mod,13L
+
+#define SN_id_mod_ocsp          "id-mod-ocsp"
+#define NID_id_mod_ocsp         282
+#define OBJ_id_mod_ocsp         OBJ_id_pkix_mod,14L
+
+#define SN_id_mod_dvcs          "id-mod-dvcs"
+#define NID_id_mod_dvcs         283
+#define OBJ_id_mod_dvcs         OBJ_id_pkix_mod,15L
+
+#define SN_id_mod_cmp2000               "id-mod-cmp2000"
+#define NID_id_mod_cmp2000              284
+#define OBJ_id_mod_cmp2000              OBJ_id_pkix_mod,16L
+
+#define SN_id_mod_cmp2000_02            "id-mod-cmp2000-02"
+#define NID_id_mod_cmp2000_02           1251
+#define OBJ_id_mod_cmp2000_02           OBJ_id_pkix_mod,50L
+
+#define SN_id_mod_cmp2021_88            "id-mod-cmp2021-88"
+#define NID_id_mod_cmp2021_88           1252
+#define OBJ_id_mod_cmp2021_88           OBJ_id_pkix_mod,99L
+
+#define SN_id_mod_cmp2021_02            "id-mod-cmp2021-02"
+#define NID_id_mod_cmp2021_02           1253
+#define OBJ_id_mod_cmp2021_02           OBJ_id_pkix_mod,100L
+
+#define SN_info_access          "authorityInfoAccess"
+#define LN_info_access          "Authority Information Access"
+#define NID_info_access         177
+#define OBJ_info_access         OBJ_id_pe,1L
+
+#define SN_biometricInfo                "biometricInfo"
+#define LN_biometricInfo                "Biometric Info"
+#define NID_biometricInfo               285
+#define OBJ_biometricInfo               OBJ_id_pe,2L
+
+#define SN_qcStatements         "qcStatements"
+#define NID_qcStatements                286
+#define OBJ_qcStatements                OBJ_id_pe,3L
+
+#define SN_ac_auditEntity               "ac-auditEntity"
+#define NID_ac_auditEntity              287
+#define OBJ_ac_auditEntity              OBJ_id_pe,4L
+
+#define SN_ac_targeting         "ac-targeting"
+#define NID_ac_targeting                288
+#define OBJ_ac_targeting                OBJ_id_pe,5L
+
+#define SN_aaControls           "aaControls"
+#define NID_aaControls          289
+#define OBJ_aaControls          OBJ_id_pe,6L
+
+#define SN_sbgp_ipAddrBlock             "sbgp-ipAddrBlock"
+#define NID_sbgp_ipAddrBlock            290
+#define OBJ_sbgp_ipAddrBlock            OBJ_id_pe,7L
+
+#define SN_sbgp_autonomousSysNum                "sbgp-autonomousSysNum"
+#define NID_sbgp_autonomousSysNum               291
+#define OBJ_sbgp_autonomousSysNum               OBJ_id_pe,8L
+
+#define SN_sbgp_routerIdentifier                "sbgp-routerIdentifier"
+#define NID_sbgp_routerIdentifier               292
+#define OBJ_sbgp_routerIdentifier               OBJ_id_pe,9L
+
+#define SN_ac_proxying          "ac-proxying"
+#define NID_ac_proxying         397
+#define OBJ_ac_proxying         OBJ_id_pe,10L
+
+#define SN_sinfo_access         "subjectInfoAccess"
+#define LN_sinfo_access         "Subject Information Access"
+#define NID_sinfo_access                398
+#define OBJ_sinfo_access                OBJ_id_pe,11L
+
+#define SN_proxyCertInfo                "proxyCertInfo"
+#define LN_proxyCertInfo                "Proxy Certificate Information"
+#define NID_proxyCertInfo               663
+#define OBJ_proxyCertInfo               OBJ_id_pe,14L
+
+#define SN_tlsfeature           "tlsfeature"
+#define LN_tlsfeature           "TLS Feature"
+#define NID_tlsfeature          1020
+#define OBJ_tlsfeature          OBJ_id_pe,24L
+
+#define SN_sbgp_ipAddrBlockv2           "sbgp-ipAddrBlockv2"
+#define NID_sbgp_ipAddrBlockv2          1239
+#define OBJ_sbgp_ipAddrBlockv2          OBJ_id_pe,28L
+
+#define SN_sbgp_autonomousSysNumv2              "sbgp-autonomousSysNumv2"
+#define NID_sbgp_autonomousSysNumv2             1240
+#define OBJ_sbgp_autonomousSysNumv2             OBJ_id_pe,29L
+
+#define SN_id_qt_cps            "id-qt-cps"
+#define LN_id_qt_cps            "Policy Qualifier CPS"
+#define NID_id_qt_cps           164
+#define OBJ_id_qt_cps           OBJ_id_qt,1L
+
+#define SN_id_qt_unotice                "id-qt-unotice"
+#define LN_id_qt_unotice                "Policy Qualifier User Notice"
+#define NID_id_qt_unotice               165
+#define OBJ_id_qt_unotice               OBJ_id_qt,2L
+
+#define SN_textNotice           "textNotice"
+#define NID_textNotice          293
+#define OBJ_textNotice          OBJ_id_qt,3L
+
+#define SN_server_auth          "serverAuth"
+#define LN_server_auth          "TLS Web Server Authentication"
+#define NID_server_auth         129
+#define OBJ_server_auth         OBJ_id_kp,1L
+
+#define SN_client_auth          "clientAuth"
+#define LN_client_auth          "TLS Web Client Authentication"
+#define NID_client_auth         130
+#define OBJ_client_auth         OBJ_id_kp,2L
+
+#define SN_code_sign            "codeSigning"
+#define LN_code_sign            "Code Signing"
+#define NID_code_sign           131
+#define OBJ_code_sign           OBJ_id_kp,3L
+
+#define SN_email_protect                "emailProtection"
+#define LN_email_protect                "E-mail Protection"
+#define NID_email_protect               132
+#define OBJ_email_protect               OBJ_id_kp,4L
+
+#define SN_ipsecEndSystem               "ipsecEndSystem"
+#define LN_ipsecEndSystem               "IPSec End System"
+#define NID_ipsecEndSystem              294
+#define OBJ_ipsecEndSystem              OBJ_id_kp,5L
+
+#define SN_ipsecTunnel          "ipsecTunnel"
+#define LN_ipsecTunnel          "IPSec Tunnel"
+#define NID_ipsecTunnel         295
+#define OBJ_ipsecTunnel         OBJ_id_kp,6L
+
+#define SN_ipsecUser            "ipsecUser"
+#define LN_ipsecUser            "IPSec User"
+#define NID_ipsecUser           296
+#define OBJ_ipsecUser           OBJ_id_kp,7L
+
+#define SN_time_stamp           "timeStamping"
+#define LN_time_stamp           "Time Stamping"
+#define NID_time_stamp          133
+#define OBJ_time_stamp          OBJ_id_kp,8L
+
+#define SN_OCSP_sign            "OCSPSigning"
+#define LN_OCSP_sign            "OCSP Signing"
+#define NID_OCSP_sign           180
+#define OBJ_OCSP_sign           OBJ_id_kp,9L
+
+#define SN_dvcs         "DVCS"
+#define LN_dvcs         "dvcs"
+#define NID_dvcs                297
+#define OBJ_dvcs                OBJ_id_kp,10L
+
+#define SN_ipsec_IKE            "ipsecIKE"
+#define LN_ipsec_IKE            "ipsec Internet Key Exchange"
+#define NID_ipsec_IKE           1022
+#define OBJ_ipsec_IKE           OBJ_id_kp,17L
+
+#define SN_capwapAC             "capwapAC"
+#define LN_capwapAC             "Ctrl/provision WAP Access"
+#define NID_capwapAC            1023
+#define OBJ_capwapAC            OBJ_id_kp,18L
+
+#define SN_capwapWTP            "capwapWTP"
+#define LN_capwapWTP            "Ctrl/Provision WAP Termination"
+#define NID_capwapWTP           1024
+#define OBJ_capwapWTP           OBJ_id_kp,19L
+
+#define SN_sshClient            "secureShellClient"
+#define LN_sshClient            "SSH Client"
+#define NID_sshClient           1025
+#define OBJ_sshClient           OBJ_id_kp,21L
+
+#define SN_sshServer            "secureShellServer"
+#define LN_sshServer            "SSH Server"
+#define NID_sshServer           1026
+#define OBJ_sshServer           OBJ_id_kp,22L
+
+#define SN_sendRouter           "sendRouter"
+#define LN_sendRouter           "Send Router"
+#define NID_sendRouter          1027
+#define OBJ_sendRouter          OBJ_id_kp,23L
+
+#define SN_sendProxiedRouter            "sendProxiedRouter"
+#define LN_sendProxiedRouter            "Send Proxied Router"
+#define NID_sendProxiedRouter           1028
+#define OBJ_sendProxiedRouter           OBJ_id_kp,24L
+
+#define SN_sendOwner            "sendOwner"
+#define LN_sendOwner            "Send Owner"
+#define NID_sendOwner           1029
+#define OBJ_sendOwner           OBJ_id_kp,25L
+
+#define SN_sendProxiedOwner             "sendProxiedOwner"
+#define LN_sendProxiedOwner             "Send Proxied Owner"
+#define NID_sendProxiedOwner            1030
+#define OBJ_sendProxiedOwner            OBJ_id_kp,26L
+
+#define SN_cmcCA                "cmcCA"
+#define LN_cmcCA                "CMC Certificate Authority"
+#define NID_cmcCA               1131
+#define OBJ_cmcCA               OBJ_id_kp,27L
+
+#define SN_cmcRA                "cmcRA"
+#define LN_cmcRA                "CMC Registration Authority"
+#define NID_cmcRA               1132
+#define OBJ_cmcRA               OBJ_id_kp,28L
+
+#define SN_cmcArchive           "cmcArchive"
+#define LN_cmcArchive           "CMC Archive Server"
+#define NID_cmcArchive          1219
+#define OBJ_cmcArchive          OBJ_id_kp,29L
+
+#define SN_id_kp_bgpsec_router          "id-kp-bgpsec-router"
+#define LN_id_kp_bgpsec_router          "BGPsec Router"
+#define NID_id_kp_bgpsec_router         1220
+#define OBJ_id_kp_bgpsec_router         OBJ_id_kp,30L
+
+#define SN_id_kp_BrandIndicatorforMessageIdentification         "id-kp-BrandIndicatorforMessageIdentification"
+#define LN_id_kp_BrandIndicatorforMessageIdentification         "Brand Indicator for Message Identification"
+#define NID_id_kp_BrandIndicatorforMessageIdentification                1221
+#define OBJ_id_kp_BrandIndicatorforMessageIdentification                OBJ_id_kp,31L
+
+#define SN_cmKGA                "cmKGA"
+#define LN_cmKGA                "Certificate Management Key Generation Authority"
+#define NID_cmKGA               1222
+#define OBJ_cmKGA               OBJ_id_kp,32L
+
+#define SN_id_it_caProtEncCert          "id-it-caProtEncCert"
+#define NID_id_it_caProtEncCert         298
+#define OBJ_id_it_caProtEncCert         OBJ_id_it,1L
+
+#define SN_id_it_signKeyPairTypes               "id-it-signKeyPairTypes"
+#define NID_id_it_signKeyPairTypes              299
+#define OBJ_id_it_signKeyPairTypes              OBJ_id_it,2L
+
+#define SN_id_it_encKeyPairTypes                "id-it-encKeyPairTypes"
+#define NID_id_it_encKeyPairTypes               300
+#define OBJ_id_it_encKeyPairTypes               OBJ_id_it,3L
+
+#define SN_id_it_preferredSymmAlg               "id-it-preferredSymmAlg"
+#define NID_id_it_preferredSymmAlg              301
+#define OBJ_id_it_preferredSymmAlg              OBJ_id_it,4L
+
+#define SN_id_it_caKeyUpdateInfo                "id-it-caKeyUpdateInfo"
+#define NID_id_it_caKeyUpdateInfo               302
+#define OBJ_id_it_caKeyUpdateInfo               OBJ_id_it,5L
+
+#define SN_id_it_currentCRL             "id-it-currentCRL"
+#define NID_id_it_currentCRL            303
+#define OBJ_id_it_currentCRL            OBJ_id_it,6L
+
+#define SN_id_it_unsupportedOIDs                "id-it-unsupportedOIDs"
+#define NID_id_it_unsupportedOIDs               304
+#define OBJ_id_it_unsupportedOIDs               OBJ_id_it,7L
+
+#define SN_id_it_subscriptionRequest            "id-it-subscriptionRequest"
+#define NID_id_it_subscriptionRequest           305
+#define OBJ_id_it_subscriptionRequest           OBJ_id_it,8L
+
+#define SN_id_it_subscriptionResponse           "id-it-subscriptionResponse"
+#define NID_id_it_subscriptionResponse          306
+#define OBJ_id_it_subscriptionResponse          OBJ_id_it,9L
+
+#define SN_id_it_keyPairParamReq                "id-it-keyPairParamReq"
+#define NID_id_it_keyPairParamReq               307
+#define OBJ_id_it_keyPairParamReq               OBJ_id_it,10L
+
+#define SN_id_it_keyPairParamRep                "id-it-keyPairParamRep"
+#define NID_id_it_keyPairParamRep               308
+#define OBJ_id_it_keyPairParamRep               OBJ_id_it,11L
+
+#define SN_id_it_revPassphrase          "id-it-revPassphrase"
+#define NID_id_it_revPassphrase         309
+#define OBJ_id_it_revPassphrase         OBJ_id_it,12L
+
+#define SN_id_it_implicitConfirm                "id-it-implicitConfirm"
+#define NID_id_it_implicitConfirm               310
+#define OBJ_id_it_implicitConfirm               OBJ_id_it,13L
+
+#define SN_id_it_confirmWaitTime                "id-it-confirmWaitTime"
+#define NID_id_it_confirmWaitTime               311
+#define OBJ_id_it_confirmWaitTime               OBJ_id_it,14L
+
+#define SN_id_it_origPKIMessage         "id-it-origPKIMessage"
+#define NID_id_it_origPKIMessage                312
+#define OBJ_id_it_origPKIMessage                OBJ_id_it,15L
+
+#define SN_id_it_suppLangTags           "id-it-suppLangTags"
+#define NID_id_it_suppLangTags          784
+#define OBJ_id_it_suppLangTags          OBJ_id_it,16L
+
+#define SN_id_it_caCerts                "id-it-caCerts"
+#define NID_id_it_caCerts               1223
+#define OBJ_id_it_caCerts               OBJ_id_it,17L
+
+#define SN_id_it_rootCaKeyUpdate                "id-it-rootCaKeyUpdate"
+#define NID_id_it_rootCaKeyUpdate               1224
+#define OBJ_id_it_rootCaKeyUpdate               OBJ_id_it,18L
+
+#define SN_id_it_certReqTemplate                "id-it-certReqTemplate"
+#define NID_id_it_certReqTemplate               1225
+#define OBJ_id_it_certReqTemplate               OBJ_id_it,19L
+
+#define SN_id_it_rootCaCert             "id-it-rootCaCert"
+#define NID_id_it_rootCaCert            1254
+#define OBJ_id_it_rootCaCert            OBJ_id_it,20L
+
+#define SN_id_it_certProfile            "id-it-certProfile"
+#define NID_id_it_certProfile           1255
+#define OBJ_id_it_certProfile           OBJ_id_it,21L
+
+#define SN_id_it_crlStatusList          "id-it-crlStatusList"
+#define NID_id_it_crlStatusList         1256
+#define OBJ_id_it_crlStatusList         OBJ_id_it,22L
+
+#define SN_id_it_crls           "id-it-crls"
+#define NID_id_it_crls          1257
+#define OBJ_id_it_crls          OBJ_id_it,23L
+
+#define SN_id_regCtrl           "id-regCtrl"
+#define NID_id_regCtrl          313
+#define OBJ_id_regCtrl          OBJ_id_pkip,1L
+
+#define SN_id_regInfo           "id-regInfo"
+#define NID_id_regInfo          314
+#define OBJ_id_regInfo          OBJ_id_pkip,2L
+
+#define SN_id_regCtrl_regToken          "id-regCtrl-regToken"
+#define NID_id_regCtrl_regToken         315
+#define OBJ_id_regCtrl_regToken         OBJ_id_regCtrl,1L
+
+#define SN_id_regCtrl_authenticator             "id-regCtrl-authenticator"
+#define NID_id_regCtrl_authenticator            316
+#define OBJ_id_regCtrl_authenticator            OBJ_id_regCtrl,2L
+
+#define SN_id_regCtrl_pkiPublicationInfo                "id-regCtrl-pkiPublicationInfo"
+#define NID_id_regCtrl_pkiPublicationInfo               317
+#define OBJ_id_regCtrl_pkiPublicationInfo               OBJ_id_regCtrl,3L
+
+#define SN_id_regCtrl_pkiArchiveOptions         "id-regCtrl-pkiArchiveOptions"
+#define NID_id_regCtrl_pkiArchiveOptions                318
+#define OBJ_id_regCtrl_pkiArchiveOptions                OBJ_id_regCtrl,4L
+
+#define SN_id_regCtrl_oldCertID         "id-regCtrl-oldCertID"
+#define NID_id_regCtrl_oldCertID                319
+#define OBJ_id_regCtrl_oldCertID                OBJ_id_regCtrl,5L
+
+#define SN_id_regCtrl_protocolEncrKey           "id-regCtrl-protocolEncrKey"
+#define NID_id_regCtrl_protocolEncrKey          320
+#define OBJ_id_regCtrl_protocolEncrKey          OBJ_id_regCtrl,6L
+
+#define SN_id_regCtrl_altCertTemplate           "id-regCtrl-altCertTemplate"
+#define NID_id_regCtrl_altCertTemplate          1258
+#define OBJ_id_regCtrl_altCertTemplate          OBJ_id_regCtrl,7L
+
+#define SN_id_regCtrl_algId             "id-regCtrl-algId"
+#define NID_id_regCtrl_algId            1259
+#define OBJ_id_regCtrl_algId            OBJ_id_regCtrl,11L
+
+#define SN_id_regCtrl_rsaKeyLen         "id-regCtrl-rsaKeyLen"
+#define NID_id_regCtrl_rsaKeyLen                1260
+#define OBJ_id_regCtrl_rsaKeyLen                OBJ_id_regCtrl,12L
+
+#define SN_id_regInfo_utf8Pairs         "id-regInfo-utf8Pairs"
+#define NID_id_regInfo_utf8Pairs                321
+#define OBJ_id_regInfo_utf8Pairs                OBJ_id_regInfo,1L
+
+#define SN_id_regInfo_certReq           "id-regInfo-certReq"
+#define NID_id_regInfo_certReq          322
+#define OBJ_id_regInfo_certReq          OBJ_id_regInfo,2L
+
+#define SN_id_alg_des40         "id-alg-des40"
+#define NID_id_alg_des40                323
+#define OBJ_id_alg_des40                OBJ_id_alg,1L
+
+#define SN_id_alg_noSignature           "id-alg-noSignature"
+#define NID_id_alg_noSignature          324
+#define OBJ_id_alg_noSignature          OBJ_id_alg,2L
+
+#define SN_id_alg_dh_sig_hmac_sha1              "id-alg-dh-sig-hmac-sha1"
+#define NID_id_alg_dh_sig_hmac_sha1             325
+#define OBJ_id_alg_dh_sig_hmac_sha1             OBJ_id_alg,3L
+
+#define SN_id_alg_dh_pop                "id-alg-dh-pop"
+#define NID_id_alg_dh_pop               326
+#define OBJ_id_alg_dh_pop               OBJ_id_alg,4L
+
+#define SN_id_cmc_statusInfo            "id-cmc-statusInfo"
+#define NID_id_cmc_statusInfo           327
+#define OBJ_id_cmc_statusInfo           OBJ_id_cmc,1L
+
+#define SN_id_cmc_identification                "id-cmc-identification"
+#define NID_id_cmc_identification               328
+#define OBJ_id_cmc_identification               OBJ_id_cmc,2L
+
+#define SN_id_cmc_identityProof         "id-cmc-identityProof"
+#define NID_id_cmc_identityProof                329
+#define OBJ_id_cmc_identityProof                OBJ_id_cmc,3L
+
+#define SN_id_cmc_dataReturn            "id-cmc-dataReturn"
+#define NID_id_cmc_dataReturn           330
+#define OBJ_id_cmc_dataReturn           OBJ_id_cmc,4L
+
+#define SN_id_cmc_transactionId         "id-cmc-transactionId"
+#define NID_id_cmc_transactionId                331
+#define OBJ_id_cmc_transactionId                OBJ_id_cmc,5L
+
+#define SN_id_cmc_senderNonce           "id-cmc-senderNonce"
+#define NID_id_cmc_senderNonce          332
+#define OBJ_id_cmc_senderNonce          OBJ_id_cmc,6L
+
+#define SN_id_cmc_recipientNonce                "id-cmc-recipientNonce"
+#define NID_id_cmc_recipientNonce               333
+#define OBJ_id_cmc_recipientNonce               OBJ_id_cmc,7L
+
+#define SN_id_cmc_addExtensions         "id-cmc-addExtensions"
+#define NID_id_cmc_addExtensions                334
+#define OBJ_id_cmc_addExtensions                OBJ_id_cmc,8L
+
+#define SN_id_cmc_encryptedPOP          "id-cmc-encryptedPOP"
+#define NID_id_cmc_encryptedPOP         335
+#define OBJ_id_cmc_encryptedPOP         OBJ_id_cmc,9L
+
+#define SN_id_cmc_decryptedPOP          "id-cmc-decryptedPOP"
+#define NID_id_cmc_decryptedPOP         336
+#define OBJ_id_cmc_decryptedPOP         OBJ_id_cmc,10L
+
+#define SN_id_cmc_lraPOPWitness         "id-cmc-lraPOPWitness"
+#define NID_id_cmc_lraPOPWitness                337
+#define OBJ_id_cmc_lraPOPWitness                OBJ_id_cmc,11L
+
+#define SN_id_cmc_getCert               "id-cmc-getCert"
+#define NID_id_cmc_getCert              338
+#define OBJ_id_cmc_getCert              OBJ_id_cmc,15L
+
+#define SN_id_cmc_getCRL                "id-cmc-getCRL"
+#define NID_id_cmc_getCRL               339
+#define OBJ_id_cmc_getCRL               OBJ_id_cmc,16L
+
+#define SN_id_cmc_revokeRequest         "id-cmc-revokeRequest"
+#define NID_id_cmc_revokeRequest                340
+#define OBJ_id_cmc_revokeRequest                OBJ_id_cmc,17L
+
+#define SN_id_cmc_regInfo               "id-cmc-regInfo"
+#define NID_id_cmc_regInfo              341
+#define OBJ_id_cmc_regInfo              OBJ_id_cmc,18L
+
+#define SN_id_cmc_responseInfo          "id-cmc-responseInfo"
+#define NID_id_cmc_responseInfo         342
+#define OBJ_id_cmc_responseInfo         OBJ_id_cmc,19L
+
+#define SN_id_cmc_queryPending          "id-cmc-queryPending"
+#define NID_id_cmc_queryPending         343
+#define OBJ_id_cmc_queryPending         OBJ_id_cmc,21L
+
+#define SN_id_cmc_popLinkRandom         "id-cmc-popLinkRandom"
+#define NID_id_cmc_popLinkRandom                344
+#define OBJ_id_cmc_popLinkRandom                OBJ_id_cmc,22L
+
+#define SN_id_cmc_popLinkWitness                "id-cmc-popLinkWitness"
+#define NID_id_cmc_popLinkWitness               345
+#define OBJ_id_cmc_popLinkWitness               OBJ_id_cmc,23L
+
+#define SN_id_cmc_confirmCertAcceptance         "id-cmc-confirmCertAcceptance"
+#define NID_id_cmc_confirmCertAcceptance                346
+#define OBJ_id_cmc_confirmCertAcceptance                OBJ_id_cmc,24L
+
+#define SN_id_on_personalData           "id-on-personalData"
+#define NID_id_on_personalData          347
+#define OBJ_id_on_personalData          OBJ_id_on,1L
+
+#define SN_id_on_permanentIdentifier            "id-on-permanentIdentifier"
+#define LN_id_on_permanentIdentifier            "Permanent Identifier"
+#define NID_id_on_permanentIdentifier           858
+#define OBJ_id_on_permanentIdentifier           OBJ_id_on,3L
+
+#define SN_XmppAddr             "id-on-xmppAddr"
+#define LN_XmppAddr             "XmppAddr"
+#define NID_XmppAddr            1209
+#define OBJ_XmppAddr            OBJ_id_on,5L
+
+#define SN_SRVName              "id-on-dnsSRV"
+#define LN_SRVName              "SRVName"
+#define NID_SRVName             1210
+#define OBJ_SRVName             OBJ_id_on,7L
+
+#define SN_NAIRealm             "id-on-NAIRealm"
+#define LN_NAIRealm             "NAIRealm"
+#define NID_NAIRealm            1211
+#define OBJ_NAIRealm            OBJ_id_on,8L
+
+#define SN_id_on_SmtpUTF8Mailbox                "id-on-SmtpUTF8Mailbox"
+#define LN_id_on_SmtpUTF8Mailbox                "Smtp UTF8 Mailbox"
+#define NID_id_on_SmtpUTF8Mailbox               1208
+#define OBJ_id_on_SmtpUTF8Mailbox               OBJ_id_on,9L
+
+#define SN_id_pda_dateOfBirth           "id-pda-dateOfBirth"
+#define NID_id_pda_dateOfBirth          348
+#define OBJ_id_pda_dateOfBirth          OBJ_id_pda,1L
+
+#define SN_id_pda_placeOfBirth          "id-pda-placeOfBirth"
+#define NID_id_pda_placeOfBirth         349
+#define OBJ_id_pda_placeOfBirth         OBJ_id_pda,2L
+
+#define SN_id_pda_gender                "id-pda-gender"
+#define NID_id_pda_gender               351
+#define OBJ_id_pda_gender               OBJ_id_pda,3L
+
+#define SN_id_pda_countryOfCitizenship          "id-pda-countryOfCitizenship"
+#define NID_id_pda_countryOfCitizenship         352
+#define OBJ_id_pda_countryOfCitizenship         OBJ_id_pda,4L
+
+#define SN_id_pda_countryOfResidence            "id-pda-countryOfResidence"
+#define NID_id_pda_countryOfResidence           353
+#define OBJ_id_pda_countryOfResidence           OBJ_id_pda,5L
+
+#define SN_id_aca_authenticationInfo            "id-aca-authenticationInfo"
+#define NID_id_aca_authenticationInfo           354
+#define OBJ_id_aca_authenticationInfo           OBJ_id_aca,1L
+
+#define SN_id_aca_accessIdentity                "id-aca-accessIdentity"
+#define NID_id_aca_accessIdentity               355
+#define OBJ_id_aca_accessIdentity               OBJ_id_aca,2L
+
+#define SN_id_aca_chargingIdentity              "id-aca-chargingIdentity"
+#define NID_id_aca_chargingIdentity             356
+#define OBJ_id_aca_chargingIdentity             OBJ_id_aca,3L
+
+#define SN_id_aca_group         "id-aca-group"
+#define NID_id_aca_group                357
+#define OBJ_id_aca_group                OBJ_id_aca,4L
+
+#define SN_id_aca_role          "id-aca-role"
+#define NID_id_aca_role         358
+#define OBJ_id_aca_role         OBJ_id_aca,5L
+
+#define SN_id_aca_encAttrs              "id-aca-encAttrs"
+#define NID_id_aca_encAttrs             399
+#define OBJ_id_aca_encAttrs             OBJ_id_aca,6L
+
+#define SN_id_qcs_pkixQCSyntax_v1               "id-qcs-pkixQCSyntax-v1"
+#define NID_id_qcs_pkixQCSyntax_v1              359
+#define OBJ_id_qcs_pkixQCSyntax_v1              OBJ_id_qcs,1L
+
+#define SN_ipAddr_asNumber              "ipAddr-asNumber"
+#define NID_ipAddr_asNumber             1241
+#define OBJ_ipAddr_asNumber             OBJ_id_cp,2L
+
+#define SN_ipAddr_asNumberv2            "ipAddr-asNumberv2"
+#define NID_ipAddr_asNumberv2           1242
+#define OBJ_ipAddr_asNumberv2           OBJ_id_cp,3L
+
+#define SN_id_cct_crs           "id-cct-crs"
+#define NID_id_cct_crs          360
+#define OBJ_id_cct_crs          OBJ_id_cct,1L
+
+#define SN_id_cct_PKIData               "id-cct-PKIData"
+#define NID_id_cct_PKIData              361
+#define OBJ_id_cct_PKIData              OBJ_id_cct,2L
+
+#define SN_id_cct_PKIResponse           "id-cct-PKIResponse"
+#define NID_id_cct_PKIResponse          362
+#define OBJ_id_cct_PKIResponse          OBJ_id_cct,3L
+
+#define SN_id_ppl_anyLanguage           "id-ppl-anyLanguage"
+#define LN_id_ppl_anyLanguage           "Any language"
+#define NID_id_ppl_anyLanguage          664
+#define OBJ_id_ppl_anyLanguage          OBJ_id_ppl,0L
+
+#define SN_id_ppl_inheritAll            "id-ppl-inheritAll"
+#define LN_id_ppl_inheritAll            "Inherit all"
+#define NID_id_ppl_inheritAll           665
+#define OBJ_id_ppl_inheritAll           OBJ_id_ppl,1L
+
+#define SN_Independent          "id-ppl-independent"
+#define LN_Independent          "Independent"
+#define NID_Independent         667
+#define OBJ_Independent         OBJ_id_ppl,2L
+
+#define SN_ad_OCSP              "OCSP"
+#define LN_ad_OCSP              "OCSP"
+#define NID_ad_OCSP             178
+#define OBJ_ad_OCSP             OBJ_id_ad,1L
+
+#define SN_ad_ca_issuers                "caIssuers"
+#define LN_ad_ca_issuers                "CA Issuers"
+#define NID_ad_ca_issuers               179
+#define OBJ_ad_ca_issuers               OBJ_id_ad,2L
+
+#define SN_ad_timeStamping              "ad_timestamping"
+#define LN_ad_timeStamping              "AD Time Stamping"
+#define NID_ad_timeStamping             363
+#define OBJ_ad_timeStamping             OBJ_id_ad,3L
+
+#define SN_ad_dvcs              "AD_DVCS"
+#define LN_ad_dvcs              "ad dvcs"
+#define NID_ad_dvcs             364
+#define OBJ_ad_dvcs             OBJ_id_ad,4L
+
+#define SN_caRepository         "caRepository"
+#define LN_caRepository         "CA Repository"
+#define NID_caRepository                785
+#define OBJ_caRepository                OBJ_id_ad,5L
+
+#define SN_rpkiManifest         "rpkiManifest"
+#define LN_rpkiManifest         "RPKI Manifest"
+#define NID_rpkiManifest                1243
+#define OBJ_rpkiManifest                OBJ_id_ad,10L
+
+#define SN_signedObject         "signedObject"
+#define LN_signedObject         "Signed Object"
+#define NID_signedObject                1244
+#define OBJ_signedObject                OBJ_id_ad,11L
+
+#define SN_rpkiNotify           "rpkiNotify"
+#define LN_rpkiNotify           "RPKI Notify"
+#define NID_rpkiNotify          1245
+#define OBJ_rpkiNotify          OBJ_id_ad,13L
+
+#define OBJ_id_pkix_OCSP                OBJ_ad_OCSP
+
+#define SN_id_pkix_OCSP_basic           "basicOCSPResponse"
+#define LN_id_pkix_OCSP_basic           "Basic OCSP Response"
+#define NID_id_pkix_OCSP_basic          365
+#define OBJ_id_pkix_OCSP_basic          OBJ_id_pkix_OCSP,1L
+
+#define SN_id_pkix_OCSP_Nonce           "Nonce"
+#define LN_id_pkix_OCSP_Nonce           "OCSP Nonce"
+#define NID_id_pkix_OCSP_Nonce          366
+#define OBJ_id_pkix_OCSP_Nonce          OBJ_id_pkix_OCSP,2L
+
+#define SN_id_pkix_OCSP_CrlID           "CrlID"
+#define LN_id_pkix_OCSP_CrlID           "OCSP CRL ID"
+#define NID_id_pkix_OCSP_CrlID          367
+#define OBJ_id_pkix_OCSP_CrlID          OBJ_id_pkix_OCSP,3L
+
+#define SN_id_pkix_OCSP_acceptableResponses             "acceptableResponses"
+#define LN_id_pkix_OCSP_acceptableResponses             "Acceptable OCSP Responses"
+#define NID_id_pkix_OCSP_acceptableResponses            368
+#define OBJ_id_pkix_OCSP_acceptableResponses            OBJ_id_pkix_OCSP,4L
+
+#define SN_id_pkix_OCSP_noCheck         "noCheck"
+#define LN_id_pkix_OCSP_noCheck         "OCSP No Check"
+#define NID_id_pkix_OCSP_noCheck                369
+#define OBJ_id_pkix_OCSP_noCheck                OBJ_id_pkix_OCSP,5L
+
+#define SN_id_pkix_OCSP_archiveCutoff           "archiveCutoff"
+#define LN_id_pkix_OCSP_archiveCutoff           "OCSP Archive Cutoff"
+#define NID_id_pkix_OCSP_archiveCutoff          370
+#define OBJ_id_pkix_OCSP_archiveCutoff          OBJ_id_pkix_OCSP,6L
+
+#define SN_id_pkix_OCSP_serviceLocator          "serviceLocator"
+#define LN_id_pkix_OCSP_serviceLocator          "OCSP Service Locator"
+#define NID_id_pkix_OCSP_serviceLocator         371
+#define OBJ_id_pkix_OCSP_serviceLocator         OBJ_id_pkix_OCSP,7L
+
+#define SN_id_pkix_OCSP_extendedStatus          "extendedStatus"
+#define LN_id_pkix_OCSP_extendedStatus          "Extended OCSP Status"
+#define NID_id_pkix_OCSP_extendedStatus         372
+#define OBJ_id_pkix_OCSP_extendedStatus         OBJ_id_pkix_OCSP,8L
+
+#define SN_id_pkix_OCSP_valid           "valid"
+#define NID_id_pkix_OCSP_valid          373
+#define OBJ_id_pkix_OCSP_valid          OBJ_id_pkix_OCSP,9L
+
+#define SN_id_pkix_OCSP_path            "path"
+#define NID_id_pkix_OCSP_path           374
+#define OBJ_id_pkix_OCSP_path           OBJ_id_pkix_OCSP,10L
+
+#define SN_id_pkix_OCSP_trustRoot               "trustRoot"
+#define LN_id_pkix_OCSP_trustRoot               "Trust Root"
+#define NID_id_pkix_OCSP_trustRoot              375
+#define OBJ_id_pkix_OCSP_trustRoot              OBJ_id_pkix_OCSP,11L
+
+#define SN_algorithm            "algorithm"
+#define LN_algorithm            "algorithm"
+#define NID_algorithm           376
+#define OBJ_algorithm           1L,3L,14L,3L,2L
+
+#define SN_md5WithRSA           "RSA-NP-MD5"
+#define LN_md5WithRSA           "md5WithRSA"
+#define NID_md5WithRSA          104
+#define OBJ_md5WithRSA          OBJ_algorithm,3L
+
+#define SN_des_ecb              "DES-ECB"
+#define LN_des_ecb              "des-ecb"
+#define NID_des_ecb             29
+#define OBJ_des_ecb             OBJ_algorithm,6L
+
+#define SN_des_cbc              "DES-CBC"
+#define LN_des_cbc              "des-cbc"
+#define NID_des_cbc             31
+#define OBJ_des_cbc             OBJ_algorithm,7L
+
+#define SN_des_ofb64            "DES-OFB"
+#define LN_des_ofb64            "des-ofb"
+#define NID_des_ofb64           45
+#define OBJ_des_ofb64           OBJ_algorithm,8L
+
+#define SN_des_cfb64            "DES-CFB"
+#define LN_des_cfb64            "des-cfb"
+#define NID_des_cfb64           30
+#define OBJ_des_cfb64           OBJ_algorithm,9L
+
+#define SN_rsaSignature         "rsaSignature"
+#define NID_rsaSignature                377
+#define OBJ_rsaSignature                OBJ_algorithm,11L
+
+#define SN_dsa_2                "DSA-old"
+#define LN_dsa_2                "dsaEncryption-old"
+#define NID_dsa_2               67
+#define OBJ_dsa_2               OBJ_algorithm,12L
+
+#define SN_dsaWithSHA           "DSA-SHA"
+#define LN_dsaWithSHA           "dsaWithSHA"
+#define NID_dsaWithSHA          66
+#define OBJ_dsaWithSHA          OBJ_algorithm,13L
+
+#define SN_shaWithRSAEncryption         "RSA-SHA"
+#define LN_shaWithRSAEncryption         "shaWithRSAEncryption"
+#define NID_shaWithRSAEncryption                42
+#define OBJ_shaWithRSAEncryption                OBJ_algorithm,15L
+
+#define SN_des_ede_ecb          "DES-EDE"
+#define LN_des_ede_ecb          "des-ede"
+#define NID_des_ede_ecb         32
+#define OBJ_des_ede_ecb         OBJ_algorithm,17L
+
+#define SN_des_ede3_ecb         "DES-EDE3"
+#define LN_des_ede3_ecb         "des-ede3"
+#define NID_des_ede3_ecb                33
+
+#define SN_des_ede_cbc          "DES-EDE-CBC"
+#define LN_des_ede_cbc          "des-ede-cbc"
+#define NID_des_ede_cbc         43
+
+#define SN_des_ede_cfb64                "DES-EDE-CFB"
+#define LN_des_ede_cfb64                "des-ede-cfb"
+#define NID_des_ede_cfb64               60
+
+#define SN_des_ede3_cfb64               "DES-EDE3-CFB"
+#define LN_des_ede3_cfb64               "des-ede3-cfb"
+#define NID_des_ede3_cfb64              61
+
+#define SN_des_ede_ofb64                "DES-EDE-OFB"
+#define LN_des_ede_ofb64                "des-ede-ofb"
+#define NID_des_ede_ofb64               62
+
+#define SN_des_ede3_ofb64               "DES-EDE3-OFB"
+#define LN_des_ede3_ofb64               "des-ede3-ofb"
+#define NID_des_ede3_ofb64              63
+
+#define SN_desx_cbc             "DESX-CBC"
+#define LN_desx_cbc             "desx-cbc"
+#define NID_desx_cbc            80
+
+#define SN_sha          "SHA"
+#define LN_sha          "sha"
+#define NID_sha         41
+#define OBJ_sha         OBJ_algorithm,18L
+
+#define SN_sha1         "SHA1"
+#define LN_sha1         "sha1"
+#define NID_sha1                64
+#define OBJ_sha1                OBJ_algorithm,26L
+
+#define SN_dsaWithSHA1_2                "DSA-SHA1-old"
+#define LN_dsaWithSHA1_2                "dsaWithSHA1-old"
+#define NID_dsaWithSHA1_2               70
+#define OBJ_dsaWithSHA1_2               OBJ_algorithm,27L
+
+#define SN_sha1WithRSA          "RSA-SHA1-2"
+#define LN_sha1WithRSA          "sha1WithRSA"
+#define NID_sha1WithRSA         115
+#define OBJ_sha1WithRSA         OBJ_algorithm,29L
+
+#define SN_ripemd160            "RIPEMD160"
+#define LN_ripemd160            "ripemd160"
+#define NID_ripemd160           117
+#define OBJ_ripemd160           1L,3L,36L,3L,2L,1L
+
+#define SN_ripemd160WithRSA             "RSA-RIPEMD160"
+#define LN_ripemd160WithRSA             "ripemd160WithRSA"
+#define NID_ripemd160WithRSA            119
+#define OBJ_ripemd160WithRSA            1L,3L,36L,3L,3L,1L,2L
+
+#define SN_blake2bmac           "BLAKE2BMAC"
+#define LN_blake2bmac           "blake2bmac"
+#define NID_blake2bmac          1201
+#define OBJ_blake2bmac          1L,3L,6L,1L,4L,1L,1722L,12L,2L,1L
+
+#define SN_blake2smac           "BLAKE2SMAC"
+#define LN_blake2smac           "blake2smac"
+#define NID_blake2smac          1202
+#define OBJ_blake2smac          1L,3L,6L,1L,4L,1L,1722L,12L,2L,2L
+
+#define SN_blake2b512           "BLAKE2b512"
+#define LN_blake2b512           "blake2b512"
+#define NID_blake2b512          1056
+#define OBJ_blake2b512          OBJ_blake2bmac,16L
+
+#define SN_blake2s256           "BLAKE2s256"
+#define LN_blake2s256           "blake2s256"
+#define NID_blake2s256          1057
+#define OBJ_blake2s256          OBJ_blake2smac,8L
+
+#define SN_sxnet                "SXNetID"
+#define LN_sxnet                "Strong Extranet ID"
+#define NID_sxnet               143
+#define OBJ_sxnet               1L,3L,101L,1L,4L,1L
+
+#define SN_X500         "X500"
+#define LN_X500         "directory services (X.500)"
+#define NID_X500                11
+#define OBJ_X500                2L,5L
+
+#define SN_X509         "X509"
+#define NID_X509                12
+#define OBJ_X509                OBJ_X500,4L
+
+#define SN_commonName           "CN"
+#define LN_commonName           "commonName"
+#define NID_commonName          13
+#define OBJ_commonName          OBJ_X509,3L
+
+#define SN_surname              "SN"
+#define LN_surname              "surname"
+#define NID_surname             100
+#define OBJ_surname             OBJ_X509,4L
+
+#define LN_serialNumber         "serialNumber"
+#define NID_serialNumber                105
+#define OBJ_serialNumber                OBJ_X509,5L
+
+#define SN_countryName          "C"
+#define LN_countryName          "countryName"
+#define NID_countryName         14
+#define OBJ_countryName         OBJ_X509,6L
+
+#define SN_localityName         "L"
+#define LN_localityName         "localityName"
+#define NID_localityName                15
+#define OBJ_localityName                OBJ_X509,7L
+
+#define SN_stateOrProvinceName          "ST"
+#define LN_stateOrProvinceName          "stateOrProvinceName"
+#define NID_stateOrProvinceName         16
+#define OBJ_stateOrProvinceName         OBJ_X509,8L
+
+#define SN_streetAddress                "street"
+#define LN_streetAddress                "streetAddress"
+#define NID_streetAddress               660
+#define OBJ_streetAddress               OBJ_X509,9L
+
+#define SN_organizationName             "O"
+#define LN_organizationName             "organizationName"
+#define NID_organizationName            17
+#define OBJ_organizationName            OBJ_X509,10L
+
+#define SN_organizationalUnitName               "OU"
+#define LN_organizationalUnitName               "organizationalUnitName"
+#define NID_organizationalUnitName              18
+#define OBJ_organizationalUnitName              OBJ_X509,11L
+
+#define SN_title                "title"
+#define LN_title                "title"
+#define NID_title               106
+#define OBJ_title               OBJ_X509,12L
+
+#define LN_description          "description"
+#define NID_description         107
+#define OBJ_description         OBJ_X509,13L
+
+#define LN_searchGuide          "searchGuide"
+#define NID_searchGuide         859
+#define OBJ_searchGuide         OBJ_X509,14L
+
+#define LN_businessCategory             "businessCategory"
+#define NID_businessCategory            860
+#define OBJ_businessCategory            OBJ_X509,15L
+
+#define LN_postalAddress                "postalAddress"
+#define NID_postalAddress               861
+#define OBJ_postalAddress               OBJ_X509,16L
+
+#define LN_postalCode           "postalCode"
+#define NID_postalCode          661
+#define OBJ_postalCode          OBJ_X509,17L
+
+#define LN_postOfficeBox                "postOfficeBox"
+#define NID_postOfficeBox               862
+#define OBJ_postOfficeBox               OBJ_X509,18L
+
+#define LN_physicalDeliveryOfficeName           "physicalDeliveryOfficeName"
+#define NID_physicalDeliveryOfficeName          863
+#define OBJ_physicalDeliveryOfficeName          OBJ_X509,19L
+
+#define LN_telephoneNumber              "telephoneNumber"
+#define NID_telephoneNumber             864
+#define OBJ_telephoneNumber             OBJ_X509,20L
+
+#define LN_telexNumber          "telexNumber"
+#define NID_telexNumber         865
+#define OBJ_telexNumber         OBJ_X509,21L
+
+#define LN_teletexTerminalIdentifier            "teletexTerminalIdentifier"
+#define NID_teletexTerminalIdentifier           866
+#define OBJ_teletexTerminalIdentifier           OBJ_X509,22L
+
+#define LN_facsimileTelephoneNumber             "facsimileTelephoneNumber"
+#define NID_facsimileTelephoneNumber            867
+#define OBJ_facsimileTelephoneNumber            OBJ_X509,23L
+
+#define LN_x121Address          "x121Address"
+#define NID_x121Address         868
+#define OBJ_x121Address         OBJ_X509,24L
+
+#define LN_internationaliSDNNumber              "internationaliSDNNumber"
+#define NID_internationaliSDNNumber             869
+#define OBJ_internationaliSDNNumber             OBJ_X509,25L
+
+#define LN_registeredAddress            "registeredAddress"
+#define NID_registeredAddress           870
+#define OBJ_registeredAddress           OBJ_X509,26L
+
+#define LN_destinationIndicator         "destinationIndicator"
+#define NID_destinationIndicator                871
+#define OBJ_destinationIndicator                OBJ_X509,27L
+
+#define LN_preferredDeliveryMethod              "preferredDeliveryMethod"
+#define NID_preferredDeliveryMethod             872
+#define OBJ_preferredDeliveryMethod             OBJ_X509,28L
+
+#define LN_presentationAddress          "presentationAddress"
+#define NID_presentationAddress         873
+#define OBJ_presentationAddress         OBJ_X509,29L
+
+#define LN_supportedApplicationContext          "supportedApplicationContext"
+#define NID_supportedApplicationContext         874
+#define OBJ_supportedApplicationContext         OBJ_X509,30L
+
+#define SN_member               "member"
+#define NID_member              875
+#define OBJ_member              OBJ_X509,31L
+
+#define SN_owner                "owner"
+#define NID_owner               876
+#define OBJ_owner               OBJ_X509,32L
+
+#define LN_roleOccupant         "roleOccupant"
+#define NID_roleOccupant                877
+#define OBJ_roleOccupant                OBJ_X509,33L
+
+#define SN_seeAlso              "seeAlso"
+#define NID_seeAlso             878
+#define OBJ_seeAlso             OBJ_X509,34L
+
+#define LN_userPassword         "userPassword"
+#define NID_userPassword                879
+#define OBJ_userPassword                OBJ_X509,35L
+
+#define LN_userCertificate              "userCertificate"
+#define NID_userCertificate             880
+#define OBJ_userCertificate             OBJ_X509,36L
+
+#define LN_cACertificate                "cACertificate"
+#define NID_cACertificate               881
+#define OBJ_cACertificate               OBJ_X509,37L
+
+#define LN_authorityRevocationList              "authorityRevocationList"
+#define NID_authorityRevocationList             882
+#define OBJ_authorityRevocationList             OBJ_X509,38L
+
+#define LN_certificateRevocationList            "certificateRevocationList"
+#define NID_certificateRevocationList           883
+#define OBJ_certificateRevocationList           OBJ_X509,39L
+
+#define LN_crossCertificatePair         "crossCertificatePair"
+#define NID_crossCertificatePair                884
+#define OBJ_crossCertificatePair                OBJ_X509,40L
+
+#define SN_name         "name"
+#define LN_name         "name"
+#define NID_name                173
+#define OBJ_name                OBJ_X509,41L
+
+#define SN_givenName            "GN"
+#define LN_givenName            "givenName"
+#define NID_givenName           99
+#define OBJ_givenName           OBJ_X509,42L
+
+#define SN_initials             "initials"
+#define LN_initials             "initials"
+#define NID_initials            101
+#define OBJ_initials            OBJ_X509,43L
+
+#define LN_generationQualifier          "generationQualifier"
+#define NID_generationQualifier         509
+#define OBJ_generationQualifier         OBJ_X509,44L
+
+#define LN_x500UniqueIdentifier         "x500UniqueIdentifier"
+#define NID_x500UniqueIdentifier                503
+#define OBJ_x500UniqueIdentifier                OBJ_X509,45L
+
+#define SN_dnQualifier          "dnQualifier"
+#define LN_dnQualifier          "dnQualifier"
+#define NID_dnQualifier         174
+#define OBJ_dnQualifier         OBJ_X509,46L
+
+#define LN_enhancedSearchGuide          "enhancedSearchGuide"
+#define NID_enhancedSearchGuide         885
+#define OBJ_enhancedSearchGuide         OBJ_X509,47L
+
+#define LN_protocolInformation          "protocolInformation"
+#define NID_protocolInformation         886
+#define OBJ_protocolInformation         OBJ_X509,48L
+
+#define LN_distinguishedName            "distinguishedName"
+#define NID_distinguishedName           887
+#define OBJ_distinguishedName           OBJ_X509,49L
+
+#define LN_uniqueMember         "uniqueMember"
+#define NID_uniqueMember                888
+#define OBJ_uniqueMember                OBJ_X509,50L
+
+#define LN_houseIdentifier              "houseIdentifier"
+#define NID_houseIdentifier             889
+#define OBJ_houseIdentifier             OBJ_X509,51L
+
+#define LN_supportedAlgorithms          "supportedAlgorithms"
+#define NID_supportedAlgorithms         890
+#define OBJ_supportedAlgorithms         OBJ_X509,52L
+
+#define LN_deltaRevocationList          "deltaRevocationList"
+#define NID_deltaRevocationList         891
+#define OBJ_deltaRevocationList         OBJ_X509,53L
+
+#define SN_dmdName              "dmdName"
+#define NID_dmdName             892
+#define OBJ_dmdName             OBJ_X509,54L
+
+#define LN_pseudonym            "pseudonym"
+#define NID_pseudonym           510
+#define OBJ_pseudonym           OBJ_X509,65L
+
+#define SN_role         "role"
+#define LN_role         "role"
+#define NID_role                400
+#define OBJ_role                OBJ_X509,72L
+
+#define LN_organizationIdentifier               "organizationIdentifier"
+#define NID_organizationIdentifier              1089
+#define OBJ_organizationIdentifier              OBJ_X509,97L
+
+#define SN_countryCode3c                "c3"
+#define LN_countryCode3c                "countryCode3c"
+#define NID_countryCode3c               1090
+#define OBJ_countryCode3c               OBJ_X509,98L
+
+#define SN_countryCode3n                "n3"
+#define LN_countryCode3n                "countryCode3n"
+#define NID_countryCode3n               1091
+#define OBJ_countryCode3n               OBJ_X509,99L
+
+#define LN_dnsName              "dnsName"
+#define NID_dnsName             1092
+#define OBJ_dnsName             OBJ_X509,100L
+
+#define SN_X500algorithms               "X500algorithms"
+#define LN_X500algorithms               "directory services - algorithms"
+#define NID_X500algorithms              378
+#define OBJ_X500algorithms              OBJ_X500,8L
+
+#define SN_rsa          "RSA"
+#define LN_rsa          "rsa"
+#define NID_rsa         19
+#define OBJ_rsa         OBJ_X500algorithms,1L,1L
+
+#define SN_mdc2WithRSA          "RSA-MDC2"
+#define LN_mdc2WithRSA          "mdc2WithRSA"
+#define NID_mdc2WithRSA         96
+#define OBJ_mdc2WithRSA         OBJ_X500algorithms,3L,100L
+
+#define SN_mdc2         "MDC2"
+#define LN_mdc2         "mdc2"
+#define NID_mdc2                95
+#define OBJ_mdc2                OBJ_X500algorithms,3L,101L
+
+#define SN_id_ce                "id-ce"
+#define NID_id_ce               81
+#define OBJ_id_ce               OBJ_X500,29L
+
+#define SN_subject_directory_attributes         "subjectDirectoryAttributes"
+#define LN_subject_directory_attributes         "X509v3 Subject Directory Attributes"
+#define NID_subject_directory_attributes                769
+#define OBJ_subject_directory_attributes                OBJ_id_ce,9L
+
+#define SN_subject_key_identifier               "subjectKeyIdentifier"
+#define LN_subject_key_identifier               "X509v3 Subject Key Identifier"
+#define NID_subject_key_identifier              82
+#define OBJ_subject_key_identifier              OBJ_id_ce,14L
+
+#define SN_key_usage            "keyUsage"
+#define LN_key_usage            "X509v3 Key Usage"
+#define NID_key_usage           83
+#define OBJ_key_usage           OBJ_id_ce,15L
+
+#define SN_private_key_usage_period             "privateKeyUsagePeriod"
+#define LN_private_key_usage_period             "X509v3 Private Key Usage Period"
+#define NID_private_key_usage_period            84
+#define OBJ_private_key_usage_period            OBJ_id_ce,16L
+
+#define SN_subject_alt_name             "subjectAltName"
+#define LN_subject_alt_name             "X509v3 Subject Alternative Name"
+#define NID_subject_alt_name            85
+#define OBJ_subject_alt_name            OBJ_id_ce,17L
+
+#define SN_issuer_alt_name              "issuerAltName"
+#define LN_issuer_alt_name              "X509v3 Issuer Alternative Name"
+#define NID_issuer_alt_name             86
+#define OBJ_issuer_alt_name             OBJ_id_ce,18L
+
+#define SN_basic_constraints            "basicConstraints"
+#define LN_basic_constraints            "X509v3 Basic Constraints"
+#define NID_basic_constraints           87
+#define OBJ_basic_constraints           OBJ_id_ce,19L
+
+#define SN_crl_number           "crlNumber"
+#define LN_crl_number           "X509v3 CRL Number"
+#define NID_crl_number          88
+#define OBJ_crl_number          OBJ_id_ce,20L
+
+#define SN_crl_reason           "CRLReason"
+#define LN_crl_reason           "X509v3 CRL Reason Code"
+#define NID_crl_reason          141
+#define OBJ_crl_reason          OBJ_id_ce,21L
+
+#define SN_invalidity_date              "invalidityDate"
+#define LN_invalidity_date              "Invalidity Date"
+#define NID_invalidity_date             142
+#define OBJ_invalidity_date             OBJ_id_ce,24L
+
+#define SN_delta_crl            "deltaCRL"
+#define LN_delta_crl            "X509v3 Delta CRL Indicator"
+#define NID_delta_crl           140
+#define OBJ_delta_crl           OBJ_id_ce,27L
+
+#define SN_issuing_distribution_point           "issuingDistributionPoint"
+#define LN_issuing_distribution_point           "X509v3 Issuing Distribution Point"
+#define NID_issuing_distribution_point          770
+#define OBJ_issuing_distribution_point          OBJ_id_ce,28L
+
+#define SN_certificate_issuer           "certificateIssuer"
+#define LN_certificate_issuer           "X509v3 Certificate Issuer"
+#define NID_certificate_issuer          771
+#define OBJ_certificate_issuer          OBJ_id_ce,29L
+
+#define SN_name_constraints             "nameConstraints"
+#define LN_name_constraints             "X509v3 Name Constraints"
+#define NID_name_constraints            666
+#define OBJ_name_constraints            OBJ_id_ce,30L
+
+#define SN_crl_distribution_points              "crlDistributionPoints"
+#define LN_crl_distribution_points              "X509v3 CRL Distribution Points"
+#define NID_crl_distribution_points             103
+#define OBJ_crl_distribution_points             OBJ_id_ce,31L
+
+#define SN_certificate_policies         "certificatePolicies"
+#define LN_certificate_policies         "X509v3 Certificate Policies"
+#define NID_certificate_policies                89
+#define OBJ_certificate_policies                OBJ_id_ce,32L
+
+#define SN_any_policy           "anyPolicy"
+#define LN_any_policy           "X509v3 Any Policy"
+#define NID_any_policy          746
+#define OBJ_any_policy          OBJ_certificate_policies,0L
+
+#define SN_policy_mappings              "policyMappings"
+#define LN_policy_mappings              "X509v3 Policy Mappings"
+#define NID_policy_mappings             747
+#define OBJ_policy_mappings             OBJ_id_ce,33L
+
+#define SN_authority_key_identifier             "authorityKeyIdentifier"
+#define LN_authority_key_identifier             "X509v3 Authority Key Identifier"
+#define NID_authority_key_identifier            90
+#define OBJ_authority_key_identifier            OBJ_id_ce,35L
+
+#define SN_policy_constraints           "policyConstraints"
+#define LN_policy_constraints           "X509v3 Policy Constraints"
+#define NID_policy_constraints          401
+#define OBJ_policy_constraints          OBJ_id_ce,36L
+
+#define SN_ext_key_usage                "extendedKeyUsage"
+#define LN_ext_key_usage                "X509v3 Extended Key Usage"
+#define NID_ext_key_usage               126
+#define OBJ_ext_key_usage               OBJ_id_ce,37L
+
+#define SN_authority_attribute_identifier               "authorityAttributeIdentifier"
+#define LN_authority_attribute_identifier               "X509v3 Authority Attribute Identifier"
+#define NID_authority_attribute_identifier              1295
+#define OBJ_authority_attribute_identifier              OBJ_id_ce,38L
+
+#define SN_role_spec_cert_identifier            "roleSpecCertIdentifier"
+#define LN_role_spec_cert_identifier            "X509v3 Role Specification Certificate Identifier"
+#define NID_role_spec_cert_identifier           1296
+#define OBJ_role_spec_cert_identifier           OBJ_id_ce,39L
+
+#define SN_basic_att_constraints                "basicAttConstraints"
+#define LN_basic_att_constraints                "X509v3 Basic Attribute Certificate Constraints"
+#define NID_basic_att_constraints               1297
+#define OBJ_basic_att_constraints               OBJ_id_ce,41L
+
+#define SN_delegated_name_constraints           "delegatedNameConstraints"
+#define LN_delegated_name_constraints           "X509v3 Delegated Name Constraints"
+#define NID_delegated_name_constraints          1298
+#define OBJ_delegated_name_constraints          OBJ_id_ce,42L
+
+#define SN_time_specification           "timeSpecification"
+#define LN_time_specification           "X509v3 Time Specification"
+#define NID_time_specification          1299
+#define OBJ_time_specification          OBJ_id_ce,43L
+
+#define SN_freshest_crl         "freshestCRL"
+#define LN_freshest_crl         "X509v3 Freshest CRL"
+#define NID_freshest_crl                857
+#define OBJ_freshest_crl                OBJ_id_ce,46L
+
+#define SN_attribute_descriptor         "attributeDescriptor"
+#define LN_attribute_descriptor         "X509v3 Attribute Descriptor"
+#define NID_attribute_descriptor                1300
+#define OBJ_attribute_descriptor                OBJ_id_ce,48L
+
+#define SN_user_notice          "userNotice"
+#define LN_user_notice          "X509v3 User Notice"
+#define NID_user_notice         1301
+#define OBJ_user_notice         OBJ_id_ce,49L
+
+#define SN_soa_identifier               "sOAIdentifier"
+#define LN_soa_identifier               "X509v3 Source of Authority Identifier"
+#define NID_soa_identifier              1302
+#define OBJ_soa_identifier              OBJ_id_ce,50L
+
+#define SN_acceptable_cert_policies             "acceptableCertPolicies"
+#define LN_acceptable_cert_policies             "X509v3 Acceptable Certification Policies"
+#define NID_acceptable_cert_policies            1303
+#define OBJ_acceptable_cert_policies            OBJ_id_ce,52L
+
+#define SN_inhibit_any_policy           "inhibitAnyPolicy"
+#define LN_inhibit_any_policy           "X509v3 Inhibit Any Policy"
+#define NID_inhibit_any_policy          748
+#define OBJ_inhibit_any_policy          OBJ_id_ce,54L
+
+#define SN_target_information           "targetInformation"
+#define LN_target_information           "X509v3 AC Targeting"
+#define NID_target_information          402
+#define OBJ_target_information          OBJ_id_ce,55L
+
+#define SN_no_rev_avail         "noRevAvail"
+#define LN_no_rev_avail         "X509v3 No Revocation Available"
+#define NID_no_rev_avail                403
+#define OBJ_no_rev_avail                OBJ_id_ce,56L
+
+#define SN_acceptable_privilege_policies                "acceptablePrivPolicies"
+#define LN_acceptable_privilege_policies                "X509v3 Acceptable Privilege Policies"
+#define NID_acceptable_privilege_policies               1304
+#define OBJ_acceptable_privilege_policies               OBJ_id_ce,57L
+
+#define SN_indirect_issuer              "indirectIssuer"
+#define LN_indirect_issuer              "X509v3 Indirect Issuer"
+#define NID_indirect_issuer             1305
+#define OBJ_indirect_issuer             OBJ_id_ce,61L
+
+#define SN_no_assertion         "noAssertion"
+#define LN_no_assertion         "X509v3 No Assertion"
+#define NID_no_assertion                1306
+#define OBJ_no_assertion                OBJ_id_ce,62L
+
+#define SN_id_aa_issuing_distribution_point             "aAissuingDistributionPoint"
+#define LN_id_aa_issuing_distribution_point             "X509v3 Attribute Authority Issuing Distribution Point"
+#define NID_id_aa_issuing_distribution_point            1307
+#define OBJ_id_aa_issuing_distribution_point            OBJ_id_ce,63L
+
+#define SN_issued_on_behalf_of          "issuedOnBehalfOf"
+#define LN_issued_on_behalf_of          "X509v3 Issued On Behalf Of"
+#define NID_issued_on_behalf_of         1308
+#define OBJ_issued_on_behalf_of         OBJ_id_ce,64L
+
+#define SN_single_use           "singleUse"
+#define LN_single_use           "X509v3 Single Use"
+#define NID_single_use          1309
+#define OBJ_single_use          OBJ_id_ce,65L
+
+#define SN_group_ac             "groupAC"
+#define LN_group_ac             "X509v3 Group Attribute Certificate"
+#define NID_group_ac            1310
+#define OBJ_group_ac            OBJ_id_ce,66L
+
+#define SN_allowed_attribute_assignments                "allowedAttributeAssignments"
+#define LN_allowed_attribute_assignments                "X509v3 Allowed Attribute Assignments"
+#define NID_allowed_attribute_assignments               1311
+#define OBJ_allowed_attribute_assignments               OBJ_id_ce,67L
+
+#define SN_attribute_mappings           "attributeMappings"
+#define LN_attribute_mappings           "X509v3 Attribute Mappings"
+#define NID_attribute_mappings          1312
+#define OBJ_attribute_mappings          OBJ_id_ce,68L
+
+#define SN_holder_name_constraints              "holderNameConstraints"
+#define LN_holder_name_constraints              "X509v3 Holder Name Constraints"
+#define NID_holder_name_constraints             1313
+#define OBJ_holder_name_constraints             OBJ_id_ce,69L
+
+#define SN_authorization_validation             "authorizationValidation"
+#define LN_authorization_validation             "X509v3 Authorization Validation"
+#define NID_authorization_validation            1314
+#define OBJ_authorization_validation            OBJ_id_ce,70L
+
+#define SN_prot_restrict                "protRestrict"
+#define LN_prot_restrict                "X509v3 Protocol Restriction"
+#define NID_prot_restrict               1315
+#define OBJ_prot_restrict               OBJ_id_ce,71L
+
+#define SN_subject_alt_public_key_info          "subjectAltPublicKeyInfo"
+#define LN_subject_alt_public_key_info          "X509v3 Subject Alternative Public Key Info"
+#define NID_subject_alt_public_key_info         1316
+#define OBJ_subject_alt_public_key_info         OBJ_id_ce,72L
+
+#define SN_alt_signature_algorithm              "altSignatureAlgorithm"
+#define LN_alt_signature_algorithm              "X509v3 Alternative Signature Algorithm"
+#define NID_alt_signature_algorithm             1317
+#define OBJ_alt_signature_algorithm             OBJ_id_ce,73L
+
+#define SN_alt_signature_value          "altSignatureValue"
+#define LN_alt_signature_value          "X509v3 Alternative Signature Value"
+#define NID_alt_signature_value         1318
+#define OBJ_alt_signature_value         OBJ_id_ce,74L
+
+#define SN_associated_information               "associatedInformation"
+#define LN_associated_information               "X509v3 Associated Information"
+#define NID_associated_information              1319
+#define OBJ_associated_information              OBJ_id_ce,75L
+
+#define SN_anyExtendedKeyUsage          "anyExtendedKeyUsage"
+#define LN_anyExtendedKeyUsage          "Any Extended Key Usage"
+#define NID_anyExtendedKeyUsage         910
+#define OBJ_anyExtendedKeyUsage         OBJ_ext_key_usage,0L
+
+#define SN_netscape             "Netscape"
+#define LN_netscape             "Netscape Communications Corp."
+#define NID_netscape            57
+#define OBJ_netscape            2L,16L,840L,1L,113730L
+
+#define SN_netscape_cert_extension              "nsCertExt"
+#define LN_netscape_cert_extension              "Netscape Certificate Extension"
+#define NID_netscape_cert_extension             58
+#define OBJ_netscape_cert_extension             OBJ_netscape,1L
+
+#define SN_netscape_data_type           "nsDataType"
+#define LN_netscape_data_type           "Netscape Data Type"
+#define NID_netscape_data_type          59
+#define OBJ_netscape_data_type          OBJ_netscape,2L
+
+#define SN_netscape_cert_type           "nsCertType"
+#define LN_netscape_cert_type           "Netscape Cert Type"
+#define NID_netscape_cert_type          71
+#define OBJ_netscape_cert_type          OBJ_netscape_cert_extension,1L
+
+#define SN_netscape_base_url            "nsBaseUrl"
+#define LN_netscape_base_url            "Netscape Base Url"
+#define NID_netscape_base_url           72
+#define OBJ_netscape_base_url           OBJ_netscape_cert_extension,2L
+
+#define SN_netscape_revocation_url              "nsRevocationUrl"
+#define LN_netscape_revocation_url              "Netscape Revocation Url"
+#define NID_netscape_revocation_url             73
+#define OBJ_netscape_revocation_url             OBJ_netscape_cert_extension,3L
+
+#define SN_netscape_ca_revocation_url           "nsCaRevocationUrl"
+#define LN_netscape_ca_revocation_url           "Netscape CA Revocation Url"
+#define NID_netscape_ca_revocation_url          74
+#define OBJ_netscape_ca_revocation_url          OBJ_netscape_cert_extension,4L
+
+#define SN_netscape_renewal_url         "nsRenewalUrl"
+#define LN_netscape_renewal_url         "Netscape Renewal Url"
+#define NID_netscape_renewal_url                75
+#define OBJ_netscape_renewal_url                OBJ_netscape_cert_extension,7L
+
+#define SN_netscape_ca_policy_url               "nsCaPolicyUrl"
+#define LN_netscape_ca_policy_url               "Netscape CA Policy Url"
+#define NID_netscape_ca_policy_url              76
+#define OBJ_netscape_ca_policy_url              OBJ_netscape_cert_extension,8L
+
+#define SN_netscape_ssl_server_name             "nsSslServerName"
+#define LN_netscape_ssl_server_name             "Netscape SSL Server Name"
+#define NID_netscape_ssl_server_name            77
+#define OBJ_netscape_ssl_server_name            OBJ_netscape_cert_extension,12L
+
+#define SN_netscape_comment             "nsComment"
+#define LN_netscape_comment             "Netscape Comment"
+#define NID_netscape_comment            78
+#define OBJ_netscape_comment            OBJ_netscape_cert_extension,13L
+
+#define SN_netscape_cert_sequence               "nsCertSequence"
+#define LN_netscape_cert_sequence               "Netscape Certificate Sequence"
+#define NID_netscape_cert_sequence              79
+#define OBJ_netscape_cert_sequence              OBJ_netscape_data_type,5L
+
+#define SN_ns_sgc               "nsSGC"
+#define LN_ns_sgc               "Netscape Server Gated Crypto"
+#define NID_ns_sgc              139
+#define OBJ_ns_sgc              OBJ_netscape,4L,1L
+
+#define SN_org          "ORG"
+#define LN_org          "org"
+#define NID_org         379
+#define OBJ_org         OBJ_iso,3L
+
+#define SN_dod          "DOD"
+#define LN_dod          "dod"
+#define NID_dod         380
+#define OBJ_dod         OBJ_org,6L
+
+#define SN_iana         "IANA"
+#define LN_iana         "iana"
+#define NID_iana                381
+#define OBJ_iana                OBJ_dod,1L
+
+#define OBJ_internet            OBJ_iana
+
+#define SN_Directory            "directory"
+#define LN_Directory            "Directory"
+#define NID_Directory           382
+#define OBJ_Directory           OBJ_internet,1L
+
+#define SN_Management           "mgmt"
+#define LN_Management           "Management"
+#define NID_Management          383
+#define OBJ_Management          OBJ_internet,2L
+
+#define SN_Experimental         "experimental"
+#define LN_Experimental         "Experimental"
+#define NID_Experimental                384
+#define OBJ_Experimental                OBJ_internet,3L
+
+#define SN_Private              "private"
+#define LN_Private              "Private"
+#define NID_Private             385
+#define OBJ_Private             OBJ_internet,4L
+
+#define SN_Security             "security"
+#define LN_Security             "Security"
+#define NID_Security            386
+#define OBJ_Security            OBJ_internet,5L
+
+#define SN_SNMPv2               "snmpv2"
+#define LN_SNMPv2               "SNMPv2"
+#define NID_SNMPv2              387
+#define OBJ_SNMPv2              OBJ_internet,6L
+
+#define LN_Mail         "Mail"
+#define NID_Mail                388
+#define OBJ_Mail                OBJ_internet,7L
+
+#define SN_Enterprises          "enterprises"
+#define LN_Enterprises          "Enterprises"
+#define NID_Enterprises         389
+#define OBJ_Enterprises         OBJ_Private,1L
+
+#define SN_dcObject             "dcobject"
+#define LN_dcObject             "dcObject"
+#define NID_dcObject            390
+#define OBJ_dcObject            OBJ_Enterprises,1466L,344L
+
+#define SN_mime_mhs             "mime-mhs"
+#define LN_mime_mhs             "MIME MHS"
+#define NID_mime_mhs            504
+#define OBJ_mime_mhs            OBJ_Mail,1L
+
+#define SN_mime_mhs_headings            "mime-mhs-headings"
+#define LN_mime_mhs_headings            "mime-mhs-headings"
+#define NID_mime_mhs_headings           505
+#define OBJ_mime_mhs_headings           OBJ_mime_mhs,1L
+
+#define SN_mime_mhs_bodies              "mime-mhs-bodies"
+#define LN_mime_mhs_bodies              "mime-mhs-bodies"
+#define NID_mime_mhs_bodies             506
+#define OBJ_mime_mhs_bodies             OBJ_mime_mhs,2L
+
+#define SN_id_hex_partial_message               "id-hex-partial-message"
+#define LN_id_hex_partial_message               "id-hex-partial-message"
+#define NID_id_hex_partial_message              507
+#define OBJ_id_hex_partial_message              OBJ_mime_mhs_headings,1L
+
+#define SN_id_hex_multipart_message             "id-hex-multipart-message"
+#define LN_id_hex_multipart_message             "id-hex-multipart-message"
+#define NID_id_hex_multipart_message            508
+#define OBJ_id_hex_multipart_message            OBJ_mime_mhs_headings,2L
+
+#define SN_zlib_compression             "ZLIB"
+#define LN_zlib_compression             "zlib compression"
+#define NID_zlib_compression            125
+#define OBJ_zlib_compression            OBJ_id_smime_alg,8L
+
+#define OBJ_csor                2L,16L,840L,1L,101L,3L
+
+#define OBJ_nistAlgorithms              OBJ_csor,4L
+
+#define OBJ_aes         OBJ_nistAlgorithms,1L
+
+#define SN_aes_128_ecb          "AES-128-ECB"
+#define LN_aes_128_ecb          "aes-128-ecb"
+#define NID_aes_128_ecb         418
+#define OBJ_aes_128_ecb         OBJ_aes,1L
+
+#define SN_aes_128_cbc          "AES-128-CBC"
+#define LN_aes_128_cbc          "aes-128-cbc"
+#define NID_aes_128_cbc         419
+#define OBJ_aes_128_cbc         OBJ_aes,2L
+
+#define SN_aes_128_ofb128               "AES-128-OFB"
+#define LN_aes_128_ofb128               "aes-128-ofb"
+#define NID_aes_128_ofb128              420
+#define OBJ_aes_128_ofb128              OBJ_aes,3L
+
+#define SN_aes_128_cfb128               "AES-128-CFB"
+#define LN_aes_128_cfb128               "aes-128-cfb"
+#define NID_aes_128_cfb128              421
+#define OBJ_aes_128_cfb128              OBJ_aes,4L
+
+#define SN_id_aes128_wrap               "id-aes128-wrap"
+#define NID_id_aes128_wrap              788
+#define OBJ_id_aes128_wrap              OBJ_aes,5L
+
+#define SN_aes_128_gcm          "id-aes128-GCM"
+#define LN_aes_128_gcm          "aes-128-gcm"
+#define NID_aes_128_gcm         895
+#define OBJ_aes_128_gcm         OBJ_aes,6L
+
+#define SN_aes_128_ccm          "id-aes128-CCM"
+#define LN_aes_128_ccm          "aes-128-ccm"
+#define NID_aes_128_ccm         896
+#define OBJ_aes_128_ccm         OBJ_aes,7L
+
+#define SN_id_aes128_wrap_pad           "id-aes128-wrap-pad"
+#define NID_id_aes128_wrap_pad          897
+#define OBJ_id_aes128_wrap_pad          OBJ_aes,8L
+
+#define SN_aes_192_ecb          "AES-192-ECB"
+#define LN_aes_192_ecb          "aes-192-ecb"
+#define NID_aes_192_ecb         422
+#define OBJ_aes_192_ecb         OBJ_aes,21L
+
+#define SN_aes_192_cbc          "AES-192-CBC"
+#define LN_aes_192_cbc          "aes-192-cbc"
+#define NID_aes_192_cbc         423
+#define OBJ_aes_192_cbc         OBJ_aes,22L
+
+#define SN_aes_192_ofb128               "AES-192-OFB"
+#define LN_aes_192_ofb128               "aes-192-ofb"
+#define NID_aes_192_ofb128              424
+#define OBJ_aes_192_ofb128              OBJ_aes,23L
+
+#define SN_aes_192_cfb128               "AES-192-CFB"
+#define LN_aes_192_cfb128               "aes-192-cfb"
+#define NID_aes_192_cfb128              425
+#define OBJ_aes_192_cfb128              OBJ_aes,24L
+
+#define SN_id_aes192_wrap               "id-aes192-wrap"
+#define NID_id_aes192_wrap              789
+#define OBJ_id_aes192_wrap              OBJ_aes,25L
+
+#define SN_aes_192_gcm          "id-aes192-GCM"
+#define LN_aes_192_gcm          "aes-192-gcm"
+#define NID_aes_192_gcm         898
+#define OBJ_aes_192_gcm         OBJ_aes,26L
+
+#define SN_aes_192_ccm          "id-aes192-CCM"
+#define LN_aes_192_ccm          "aes-192-ccm"
+#define NID_aes_192_ccm         899
+#define OBJ_aes_192_ccm         OBJ_aes,27L
+
+#define SN_id_aes192_wrap_pad           "id-aes192-wrap-pad"
+#define NID_id_aes192_wrap_pad          900
+#define OBJ_id_aes192_wrap_pad          OBJ_aes,28L
+
+#define SN_aes_256_ecb          "AES-256-ECB"
+#define LN_aes_256_ecb          "aes-256-ecb"
+#define NID_aes_256_ecb         426
+#define OBJ_aes_256_ecb         OBJ_aes,41L
+
+#define SN_aes_256_cbc          "AES-256-CBC"
+#define LN_aes_256_cbc          "aes-256-cbc"
+#define NID_aes_256_cbc         427
+#define OBJ_aes_256_cbc         OBJ_aes,42L
+
+#define SN_aes_256_ofb128               "AES-256-OFB"
+#define LN_aes_256_ofb128               "aes-256-ofb"
+#define NID_aes_256_ofb128              428
+#define OBJ_aes_256_ofb128              OBJ_aes,43L
+
+#define SN_aes_256_cfb128               "AES-256-CFB"
+#define LN_aes_256_cfb128               "aes-256-cfb"
+#define NID_aes_256_cfb128              429
+#define OBJ_aes_256_cfb128              OBJ_aes,44L
+
+#define SN_id_aes256_wrap               "id-aes256-wrap"
+#define NID_id_aes256_wrap              790
+#define OBJ_id_aes256_wrap              OBJ_aes,45L
+
+#define SN_aes_256_gcm          "id-aes256-GCM"
+#define LN_aes_256_gcm          "aes-256-gcm"
+#define NID_aes_256_gcm         901
+#define OBJ_aes_256_gcm         OBJ_aes,46L
+
+#define SN_aes_256_ccm          "id-aes256-CCM"
+#define LN_aes_256_ccm          "aes-256-ccm"
+#define NID_aes_256_ccm         902
+#define OBJ_aes_256_ccm         OBJ_aes,47L
+
+#define SN_id_aes256_wrap_pad           "id-aes256-wrap-pad"
+#define NID_id_aes256_wrap_pad          903
+#define OBJ_id_aes256_wrap_pad          OBJ_aes,48L
+
+#define SN_aes_128_xts          "AES-128-XTS"
+#define LN_aes_128_xts          "aes-128-xts"
+#define NID_aes_128_xts         913
+#define OBJ_aes_128_xts         OBJ_ieee_siswg,0L,1L,1L
+
+#define SN_aes_256_xts          "AES-256-XTS"
+#define LN_aes_256_xts          "aes-256-xts"
+#define NID_aes_256_xts         914
+#define OBJ_aes_256_xts         OBJ_ieee_siswg,0L,1L,2L
+
+#define SN_aes_128_cfb1         "AES-128-CFB1"
+#define LN_aes_128_cfb1         "aes-128-cfb1"
+#define NID_aes_128_cfb1                650
+
+#define SN_aes_192_cfb1         "AES-192-CFB1"
+#define LN_aes_192_cfb1         "aes-192-cfb1"
+#define NID_aes_192_cfb1                651
+
+#define SN_aes_256_cfb1         "AES-256-CFB1"
+#define LN_aes_256_cfb1         "aes-256-cfb1"
+#define NID_aes_256_cfb1                652
+
+#define SN_aes_128_cfb8         "AES-128-CFB8"
+#define LN_aes_128_cfb8         "aes-128-cfb8"
+#define NID_aes_128_cfb8                653
+
+#define SN_aes_192_cfb8         "AES-192-CFB8"
+#define LN_aes_192_cfb8         "aes-192-cfb8"
+#define NID_aes_192_cfb8                654
+
+#define SN_aes_256_cfb8         "AES-256-CFB8"
+#define LN_aes_256_cfb8         "aes-256-cfb8"
+#define NID_aes_256_cfb8                655
+
+#define SN_aes_128_ctr          "AES-128-CTR"
+#define LN_aes_128_ctr          "aes-128-ctr"
+#define NID_aes_128_ctr         904
+
+#define SN_aes_192_ctr          "AES-192-CTR"
+#define LN_aes_192_ctr          "aes-192-ctr"
+#define NID_aes_192_ctr         905
+
+#define SN_aes_256_ctr          "AES-256-CTR"
+#define LN_aes_256_ctr          "aes-256-ctr"
+#define NID_aes_256_ctr         906
+
+#define SN_aes_128_ocb          "AES-128-OCB"
+#define LN_aes_128_ocb          "aes-128-ocb"
+#define NID_aes_128_ocb         958
+
+#define SN_aes_192_ocb          "AES-192-OCB"
+#define LN_aes_192_ocb          "aes-192-ocb"
+#define NID_aes_192_ocb         959
+
+#define SN_aes_256_ocb          "AES-256-OCB"
+#define LN_aes_256_ocb          "aes-256-ocb"
+#define NID_aes_256_ocb         960
+
+#define SN_des_cfb1             "DES-CFB1"
+#define LN_des_cfb1             "des-cfb1"
+#define NID_des_cfb1            656
+
+#define SN_des_cfb8             "DES-CFB8"
+#define LN_des_cfb8             "des-cfb8"
+#define NID_des_cfb8            657
+
+#define SN_des_ede3_cfb1                "DES-EDE3-CFB1"
+#define LN_des_ede3_cfb1                "des-ede3-cfb1"
+#define NID_des_ede3_cfb1               658
+
+#define SN_des_ede3_cfb8                "DES-EDE3-CFB8"
+#define LN_des_ede3_cfb8                "des-ede3-cfb8"
+#define NID_des_ede3_cfb8               659
+
+#define OBJ_nist_hashalgs               OBJ_nistAlgorithms,2L
+
+#define SN_sha256               "SHA256"
+#define LN_sha256               "sha256"
+#define NID_sha256              672
+#define OBJ_sha256              OBJ_nist_hashalgs,1L
+
+#define SN_sha384               "SHA384"
+#define LN_sha384               "sha384"
+#define NID_sha384              673
+#define OBJ_sha384              OBJ_nist_hashalgs,2L
+
+#define SN_sha512               "SHA512"
+#define LN_sha512               "sha512"
+#define NID_sha512              674
+#define OBJ_sha512              OBJ_nist_hashalgs,3L
+
+#define SN_sha224               "SHA224"
+#define LN_sha224               "sha224"
+#define NID_sha224              675
+#define OBJ_sha224              OBJ_nist_hashalgs,4L
+
+#define SN_sha512_224           "SHA512-224"
+#define LN_sha512_224           "sha512-224"
+#define NID_sha512_224          1094
+#define OBJ_sha512_224          OBJ_nist_hashalgs,5L
+
+#define SN_sha512_256           "SHA512-256"
+#define LN_sha512_256           "sha512-256"
+#define NID_sha512_256          1095
+#define OBJ_sha512_256          OBJ_nist_hashalgs,6L
+
+#define SN_sha3_224             "SHA3-224"
+#define LN_sha3_224             "sha3-224"
+#define NID_sha3_224            1096
+#define OBJ_sha3_224            OBJ_nist_hashalgs,7L
+
+#define SN_sha3_256             "SHA3-256"
+#define LN_sha3_256             "sha3-256"
+#define NID_sha3_256            1097
+#define OBJ_sha3_256            OBJ_nist_hashalgs,8L
+
+#define SN_sha3_384             "SHA3-384"
+#define LN_sha3_384             "sha3-384"
+#define NID_sha3_384            1098
+#define OBJ_sha3_384            OBJ_nist_hashalgs,9L
+
+#define SN_sha3_512             "SHA3-512"
+#define LN_sha3_512             "sha3-512"
+#define NID_sha3_512            1099
+#define OBJ_sha3_512            OBJ_nist_hashalgs,10L
+
+#define SN_shake128             "SHAKE128"
+#define LN_shake128             "shake128"
+#define NID_shake128            1100
+#define OBJ_shake128            OBJ_nist_hashalgs,11L
+
+#define SN_shake256             "SHAKE256"
+#define LN_shake256             "shake256"
+#define NID_shake256            1101
+#define OBJ_shake256            OBJ_nist_hashalgs,12L
+
+#define SN_hmac_sha3_224                "id-hmacWithSHA3-224"
+#define LN_hmac_sha3_224                "hmac-sha3-224"
+#define NID_hmac_sha3_224               1102
+#define OBJ_hmac_sha3_224               OBJ_nist_hashalgs,13L
+
+#define SN_hmac_sha3_256                "id-hmacWithSHA3-256"
+#define LN_hmac_sha3_256                "hmac-sha3-256"
+#define NID_hmac_sha3_256               1103
+#define OBJ_hmac_sha3_256               OBJ_nist_hashalgs,14L
+
+#define SN_hmac_sha3_384                "id-hmacWithSHA3-384"
+#define LN_hmac_sha3_384                "hmac-sha3-384"
+#define NID_hmac_sha3_384               1104
+#define OBJ_hmac_sha3_384               OBJ_nist_hashalgs,15L
+
+#define SN_hmac_sha3_512                "id-hmacWithSHA3-512"
+#define LN_hmac_sha3_512                "hmac-sha3-512"
+#define NID_hmac_sha3_512               1105
+#define OBJ_hmac_sha3_512               OBJ_nist_hashalgs,16L
+
+#define SN_kmac128              "KMAC128"
+#define LN_kmac128              "kmac128"
+#define NID_kmac128             1196
+#define OBJ_kmac128             OBJ_nist_hashalgs,19L
+
+#define SN_kmac256              "KMAC256"
+#define LN_kmac256              "kmac256"
+#define NID_kmac256             1197
+#define OBJ_kmac256             OBJ_nist_hashalgs,20L
+
+#define OBJ_dsa_with_sha2               OBJ_nistAlgorithms,3L
+
+#define SN_dsa_with_SHA224              "dsa_with_SHA224"
+#define NID_dsa_with_SHA224             802
+#define OBJ_dsa_with_SHA224             OBJ_dsa_with_sha2,1L
+
+#define SN_dsa_with_SHA256              "dsa_with_SHA256"
+#define NID_dsa_with_SHA256             803
+#define OBJ_dsa_with_SHA256             OBJ_dsa_with_sha2,2L
+
+#define OBJ_sigAlgs             OBJ_nistAlgorithms,3L
+
+#define SN_dsa_with_SHA384              "id-dsa-with-sha384"
+#define LN_dsa_with_SHA384              "dsa_with_SHA384"
+#define NID_dsa_with_SHA384             1106
+#define OBJ_dsa_with_SHA384             OBJ_sigAlgs,3L
+
+#define SN_dsa_with_SHA512              "id-dsa-with-sha512"
+#define LN_dsa_with_SHA512              "dsa_with_SHA512"
+#define NID_dsa_with_SHA512             1107
+#define OBJ_dsa_with_SHA512             OBJ_sigAlgs,4L
+
+#define SN_dsa_with_SHA3_224            "id-dsa-with-sha3-224"
+#define LN_dsa_with_SHA3_224            "dsa_with_SHA3-224"
+#define NID_dsa_with_SHA3_224           1108
+#define OBJ_dsa_with_SHA3_224           OBJ_sigAlgs,5L
+
+#define SN_dsa_with_SHA3_256            "id-dsa-with-sha3-256"
+#define LN_dsa_with_SHA3_256            "dsa_with_SHA3-256"
+#define NID_dsa_with_SHA3_256           1109
+#define OBJ_dsa_with_SHA3_256           OBJ_sigAlgs,6L
+
+#define SN_dsa_with_SHA3_384            "id-dsa-with-sha3-384"
+#define LN_dsa_with_SHA3_384            "dsa_with_SHA3-384"
+#define NID_dsa_with_SHA3_384           1110
+#define OBJ_dsa_with_SHA3_384           OBJ_sigAlgs,7L
+
+#define SN_dsa_with_SHA3_512            "id-dsa-with-sha3-512"
+#define LN_dsa_with_SHA3_512            "dsa_with_SHA3-512"
+#define NID_dsa_with_SHA3_512           1111
+#define OBJ_dsa_with_SHA3_512           OBJ_sigAlgs,8L
+
+#define SN_ecdsa_with_SHA3_224          "id-ecdsa-with-sha3-224"
+#define LN_ecdsa_with_SHA3_224          "ecdsa_with_SHA3-224"
+#define NID_ecdsa_with_SHA3_224         1112
+#define OBJ_ecdsa_with_SHA3_224         OBJ_sigAlgs,9L
+
+#define SN_ecdsa_with_SHA3_256          "id-ecdsa-with-sha3-256"
+#define LN_ecdsa_with_SHA3_256          "ecdsa_with_SHA3-256"
+#define NID_ecdsa_with_SHA3_256         1113
+#define OBJ_ecdsa_with_SHA3_256         OBJ_sigAlgs,10L
+
+#define SN_ecdsa_with_SHA3_384          "id-ecdsa-with-sha3-384"
+#define LN_ecdsa_with_SHA3_384          "ecdsa_with_SHA3-384"
+#define NID_ecdsa_with_SHA3_384         1114
+#define OBJ_ecdsa_with_SHA3_384         OBJ_sigAlgs,11L
+
+#define SN_ecdsa_with_SHA3_512          "id-ecdsa-with-sha3-512"
+#define LN_ecdsa_with_SHA3_512          "ecdsa_with_SHA3-512"
+#define NID_ecdsa_with_SHA3_512         1115
+#define OBJ_ecdsa_with_SHA3_512         OBJ_sigAlgs,12L
+
+#define SN_RSA_SHA3_224         "id-rsassa-pkcs1-v1_5-with-sha3-224"
+#define LN_RSA_SHA3_224         "RSA-SHA3-224"
+#define NID_RSA_SHA3_224                1116
+#define OBJ_RSA_SHA3_224                OBJ_sigAlgs,13L
+
+#define SN_RSA_SHA3_256         "id-rsassa-pkcs1-v1_5-with-sha3-256"
+#define LN_RSA_SHA3_256         "RSA-SHA3-256"
+#define NID_RSA_SHA3_256                1117
+#define OBJ_RSA_SHA3_256                OBJ_sigAlgs,14L
+
+#define SN_RSA_SHA3_384         "id-rsassa-pkcs1-v1_5-with-sha3-384"
+#define LN_RSA_SHA3_384         "RSA-SHA3-384"
+#define NID_RSA_SHA3_384                1118
+#define OBJ_RSA_SHA3_384                OBJ_sigAlgs,15L
+
+#define SN_RSA_SHA3_512         "id-rsassa-pkcs1-v1_5-with-sha3-512"
+#define LN_RSA_SHA3_512         "RSA-SHA3-512"
+#define NID_RSA_SHA3_512                1119
+#define OBJ_RSA_SHA3_512                OBJ_sigAlgs,16L
+
+#define SN_hold_instruction_code                "holdInstructionCode"
+#define LN_hold_instruction_code                "Hold Instruction Code"
+#define NID_hold_instruction_code               430
+#define OBJ_hold_instruction_code               OBJ_id_ce,23L
+
+#define OBJ_holdInstruction             OBJ_X9_57,2L
+
+#define SN_hold_instruction_none                "holdInstructionNone"
+#define LN_hold_instruction_none                "Hold Instruction None"
+#define NID_hold_instruction_none               431
+#define OBJ_hold_instruction_none               OBJ_holdInstruction,1L
+
+#define SN_hold_instruction_call_issuer         "holdInstructionCallIssuer"
+#define LN_hold_instruction_call_issuer         "Hold Instruction Call Issuer"
+#define NID_hold_instruction_call_issuer                432
+#define OBJ_hold_instruction_call_issuer                OBJ_holdInstruction,2L
+
+#define SN_hold_instruction_reject              "holdInstructionReject"
+#define LN_hold_instruction_reject              "Hold Instruction Reject"
+#define NID_hold_instruction_reject             433
+#define OBJ_hold_instruction_reject             OBJ_holdInstruction,3L
+
+#define SN_itu_t_identified_organization                "itu-t-identified-organization"
+#define NID_itu_t_identified_organization               1264
+#define OBJ_itu_t_identified_organization               OBJ_itu_t,4L
+
+#define SN_etsi         "etsi"
+#define NID_etsi                1265
+#define OBJ_etsi                OBJ_itu_t_identified_organization,0L
+
+#define SN_electronic_signature_standard                "electronic-signature-standard"
+#define NID_electronic_signature_standard               1266
+#define OBJ_electronic_signature_standard               OBJ_etsi,1733L
+
+#define SN_ess_attributes               "ess-attributes"
+#define NID_ess_attributes              1267
+#define OBJ_ess_attributes              OBJ_electronic_signature_standard,2L
+
+#define SN_id_aa_ets_mimeType           "id-aa-ets-mimeType"
+#define NID_id_aa_ets_mimeType          1268
+#define OBJ_id_aa_ets_mimeType          OBJ_ess_attributes,1L
+
+#define SN_id_aa_ets_longTermValidation         "id-aa-ets-longTermValidation"
+#define NID_id_aa_ets_longTermValidation                1269
+#define OBJ_id_aa_ets_longTermValidation                OBJ_ess_attributes,2L
+
+#define SN_id_aa_ets_SignaturePolicyDocument            "id-aa-ets-SignaturePolicyDocument"
+#define NID_id_aa_ets_SignaturePolicyDocument           1270
+#define OBJ_id_aa_ets_SignaturePolicyDocument           OBJ_ess_attributes,3L
+
+#define SN_id_aa_ets_archiveTimestampV3         "id-aa-ets-archiveTimestampV3"
+#define NID_id_aa_ets_archiveTimestampV3                1271
+#define OBJ_id_aa_ets_archiveTimestampV3                OBJ_ess_attributes,4L
+
+#define SN_id_aa_ATSHashIndex           "id-aa-ATSHashIndex"
+#define NID_id_aa_ATSHashIndex          1272
+#define OBJ_id_aa_ATSHashIndex          OBJ_ess_attributes,5L
+
+#define SN_cades                "cades"
+#define NID_cades               1273
+#define OBJ_cades               OBJ_etsi,19122L
+
+#define SN_cades_attributes             "cades-attributes"
+#define NID_cades_attributes            1274
+#define OBJ_cades_attributes            OBJ_cades,1L
+
+#define SN_id_aa_ets_signerAttrV2               "id-aa-ets-signerAttrV2"
+#define NID_id_aa_ets_signerAttrV2              1275
+#define OBJ_id_aa_ets_signerAttrV2              OBJ_cades_attributes,1L
+
+#define SN_id_aa_ets_sigPolicyStore             "id-aa-ets-sigPolicyStore"
+#define NID_id_aa_ets_sigPolicyStore            1276
+#define OBJ_id_aa_ets_sigPolicyStore            OBJ_cades_attributes,3L
+
+#define SN_id_aa_ATSHashIndex_v2                "id-aa-ATSHashIndex-v2"
+#define NID_id_aa_ATSHashIndex_v2               1277
+#define OBJ_id_aa_ATSHashIndex_v2               OBJ_cades_attributes,4L
+
+#define SN_id_aa_ATSHashIndex_v3                "id-aa-ATSHashIndex-v3"
+#define NID_id_aa_ATSHashIndex_v3               1278
+#define OBJ_id_aa_ATSHashIndex_v3               OBJ_cades_attributes,5L
+
+#define SN_signedAssertion              "signedAssertion"
+#define NID_signedAssertion             1279
+#define OBJ_signedAssertion             OBJ_cades_attributes,6L
+
+#define SN_data         "data"
+#define NID_data                434
+#define OBJ_data                OBJ_itu_t,9L
+
+#define SN_pss          "pss"
+#define NID_pss         435
+#define OBJ_pss         OBJ_data,2342L
+
+#define SN_ucl          "ucl"
+#define NID_ucl         436
+#define OBJ_ucl         OBJ_pss,19200300L
+
+#define SN_pilot                "pilot"
+#define NID_pilot               437
+#define OBJ_pilot               OBJ_ucl,100L
+
+#define LN_pilotAttributeType           "pilotAttributeType"
+#define NID_pilotAttributeType          438
+#define OBJ_pilotAttributeType          OBJ_pilot,1L
+
+#define LN_pilotAttributeSyntax         "pilotAttributeSyntax"
+#define NID_pilotAttributeSyntax                439
+#define OBJ_pilotAttributeSyntax                OBJ_pilot,3L
+
+#define LN_pilotObjectClass             "pilotObjectClass"
+#define NID_pilotObjectClass            440
+#define OBJ_pilotObjectClass            OBJ_pilot,4L
+
+#define LN_pilotGroups          "pilotGroups"
+#define NID_pilotGroups         441
+#define OBJ_pilotGroups         OBJ_pilot,10L
+
+#define LN_iA5StringSyntax              "iA5StringSyntax"
+#define NID_iA5StringSyntax             442
+#define OBJ_iA5StringSyntax             OBJ_pilotAttributeSyntax,4L
+
+#define LN_caseIgnoreIA5StringSyntax            "caseIgnoreIA5StringSyntax"
+#define NID_caseIgnoreIA5StringSyntax           443
+#define OBJ_caseIgnoreIA5StringSyntax           OBJ_pilotAttributeSyntax,5L
+
+#define LN_pilotObject          "pilotObject"
+#define NID_pilotObject         444
+#define OBJ_pilotObject         OBJ_pilotObjectClass,3L
+
+#define LN_pilotPerson          "pilotPerson"
+#define NID_pilotPerson         445
+#define OBJ_pilotPerson         OBJ_pilotObjectClass,4L
+
+#define SN_account              "account"
+#define NID_account             446
+#define OBJ_account             OBJ_pilotObjectClass,5L
+
+#define SN_document             "document"
+#define NID_document            447
+#define OBJ_document            OBJ_pilotObjectClass,6L
+
+#define SN_room         "room"
+#define NID_room                448
+#define OBJ_room                OBJ_pilotObjectClass,7L
+
+#define LN_documentSeries               "documentSeries"
+#define NID_documentSeries              449
+#define OBJ_documentSeries              OBJ_pilotObjectClass,9L
+
+#define SN_Domain               "domain"
+#define LN_Domain               "Domain"
+#define NID_Domain              392
+#define OBJ_Domain              OBJ_pilotObjectClass,13L
+
+#define LN_rFC822localPart              "rFC822localPart"
+#define NID_rFC822localPart             450
+#define OBJ_rFC822localPart             OBJ_pilotObjectClass,14L
+
+#define LN_dNSDomain            "dNSDomain"
+#define NID_dNSDomain           451
+#define OBJ_dNSDomain           OBJ_pilotObjectClass,15L
+
+#define LN_domainRelatedObject          "domainRelatedObject"
+#define NID_domainRelatedObject         452
+#define OBJ_domainRelatedObject         OBJ_pilotObjectClass,17L
+
+#define LN_friendlyCountry              "friendlyCountry"
+#define NID_friendlyCountry             453
+#define OBJ_friendlyCountry             OBJ_pilotObjectClass,18L
+
+#define LN_simpleSecurityObject         "simpleSecurityObject"
+#define NID_simpleSecurityObject                454
+#define OBJ_simpleSecurityObject                OBJ_pilotObjectClass,19L
+
+#define LN_pilotOrganization            "pilotOrganization"
+#define NID_pilotOrganization           455
+#define OBJ_pilotOrganization           OBJ_pilotObjectClass,20L
+
+#define LN_pilotDSA             "pilotDSA"
+#define NID_pilotDSA            456
+#define OBJ_pilotDSA            OBJ_pilotObjectClass,21L
+
+#define LN_qualityLabelledData          "qualityLabelledData"
+#define NID_qualityLabelledData         457
+#define OBJ_qualityLabelledData         OBJ_pilotObjectClass,22L
+
+#define SN_userId               "UID"
+#define LN_userId               "userId"
+#define NID_userId              458
+#define OBJ_userId              OBJ_pilotAttributeType,1L
+
+#define LN_textEncodedORAddress         "textEncodedORAddress"
+#define NID_textEncodedORAddress                459
+#define OBJ_textEncodedORAddress                OBJ_pilotAttributeType,2L
+
+#define SN_rfc822Mailbox                "mail"
+#define LN_rfc822Mailbox                "rfc822Mailbox"
+#define NID_rfc822Mailbox               460
+#define OBJ_rfc822Mailbox               OBJ_pilotAttributeType,3L
+
+#define SN_info         "info"
+#define NID_info                461
+#define OBJ_info                OBJ_pilotAttributeType,4L
+
+#define LN_favouriteDrink               "favouriteDrink"
+#define NID_favouriteDrink              462
+#define OBJ_favouriteDrink              OBJ_pilotAttributeType,5L
+
+#define LN_roomNumber           "roomNumber"
+#define NID_roomNumber          463
+#define OBJ_roomNumber          OBJ_pilotAttributeType,6L
+
+#define SN_photo                "photo"
+#define NID_photo               464
+#define OBJ_photo               OBJ_pilotAttributeType,7L
+
+#define LN_userClass            "userClass"
+#define NID_userClass           465
+#define OBJ_userClass           OBJ_pilotAttributeType,8L
+
+#define SN_host         "host"
+#define NID_host                466
+#define OBJ_host                OBJ_pilotAttributeType,9L
+
+#define SN_manager              "manager"
+#define NID_manager             467
+#define OBJ_manager             OBJ_pilotAttributeType,10L
+
+#define LN_documentIdentifier           "documentIdentifier"
+#define NID_documentIdentifier          468
+#define OBJ_documentIdentifier          OBJ_pilotAttributeType,11L
+
+#define LN_documentTitle                "documentTitle"
+#define NID_documentTitle               469
+#define OBJ_documentTitle               OBJ_pilotAttributeType,12L
+
+#define LN_documentVersion              "documentVersion"
+#define NID_documentVersion             470
+#define OBJ_documentVersion             OBJ_pilotAttributeType,13L
+
+#define LN_documentAuthor               "documentAuthor"
+#define NID_documentAuthor              471
+#define OBJ_documentAuthor              OBJ_pilotAttributeType,14L
+
+#define LN_documentLocation             "documentLocation"
+#define NID_documentLocation            472
+#define OBJ_documentLocation            OBJ_pilotAttributeType,15L
+
+#define LN_homeTelephoneNumber          "homeTelephoneNumber"
+#define NID_homeTelephoneNumber         473
+#define OBJ_homeTelephoneNumber         OBJ_pilotAttributeType,20L
+
+#define SN_secretary            "secretary"
+#define NID_secretary           474
+#define OBJ_secretary           OBJ_pilotAttributeType,21L
+
+#define LN_otherMailbox         "otherMailbox"
+#define NID_otherMailbox                475
+#define OBJ_otherMailbox                OBJ_pilotAttributeType,22L
+
+#define LN_lastModifiedTime             "lastModifiedTime"
+#define NID_lastModifiedTime            476
+#define OBJ_lastModifiedTime            OBJ_pilotAttributeType,23L
+
+#define LN_lastModifiedBy               "lastModifiedBy"
+#define NID_lastModifiedBy              477
+#define OBJ_lastModifiedBy              OBJ_pilotAttributeType,24L
+
+#define SN_domainComponent              "DC"
+#define LN_domainComponent              "domainComponent"
+#define NID_domainComponent             391
+#define OBJ_domainComponent             OBJ_pilotAttributeType,25L
+
+#define LN_aRecord              "aRecord"
+#define NID_aRecord             478
+#define OBJ_aRecord             OBJ_pilotAttributeType,26L
+
+#define LN_pilotAttributeType27         "pilotAttributeType27"
+#define NID_pilotAttributeType27                479
+#define OBJ_pilotAttributeType27                OBJ_pilotAttributeType,27L
+
+#define LN_mXRecord             "mXRecord"
+#define NID_mXRecord            480
+#define OBJ_mXRecord            OBJ_pilotAttributeType,28L
+
+#define LN_nSRecord             "nSRecord"
+#define NID_nSRecord            481
+#define OBJ_nSRecord            OBJ_pilotAttributeType,29L
+
+#define LN_sOARecord            "sOARecord"
+#define NID_sOARecord           482
+#define OBJ_sOARecord           OBJ_pilotAttributeType,30L
+
+#define LN_cNAMERecord          "cNAMERecord"
+#define NID_cNAMERecord         483
+#define OBJ_cNAMERecord         OBJ_pilotAttributeType,31L
+
+#define LN_associatedDomain             "associatedDomain"
+#define NID_associatedDomain            484
+#define OBJ_associatedDomain            OBJ_pilotAttributeType,37L
+
+#define LN_associatedName               "associatedName"
+#define NID_associatedName              485
+#define OBJ_associatedName              OBJ_pilotAttributeType,38L
+
+#define LN_homePostalAddress            "homePostalAddress"
+#define NID_homePostalAddress           486
+#define OBJ_homePostalAddress           OBJ_pilotAttributeType,39L
+
+#define LN_personalTitle                "personalTitle"
+#define NID_personalTitle               487
+#define OBJ_personalTitle               OBJ_pilotAttributeType,40L
+
+#define LN_mobileTelephoneNumber                "mobileTelephoneNumber"
+#define NID_mobileTelephoneNumber               488
+#define OBJ_mobileTelephoneNumber               OBJ_pilotAttributeType,41L
+
+#define LN_pagerTelephoneNumber         "pagerTelephoneNumber"
+#define NID_pagerTelephoneNumber                489
+#define OBJ_pagerTelephoneNumber                OBJ_pilotAttributeType,42L
+
+#define LN_friendlyCountryName          "friendlyCountryName"
+#define NID_friendlyCountryName         490
+#define OBJ_friendlyCountryName         OBJ_pilotAttributeType,43L
+
+#define SN_uniqueIdentifier             "uid"
+#define LN_uniqueIdentifier             "uniqueIdentifier"
+#define NID_uniqueIdentifier            102
+#define OBJ_uniqueIdentifier            OBJ_pilotAttributeType,44L
+
+#define LN_organizationalStatus         "organizationalStatus"
+#define NID_organizationalStatus                491
+#define OBJ_organizationalStatus                OBJ_pilotAttributeType,45L
+
+#define LN_janetMailbox         "janetMailbox"
+#define NID_janetMailbox                492
+#define OBJ_janetMailbox                OBJ_pilotAttributeType,46L
+
+#define LN_mailPreferenceOption         "mailPreferenceOption"
+#define NID_mailPreferenceOption                493
+#define OBJ_mailPreferenceOption                OBJ_pilotAttributeType,47L
+
+#define LN_buildingName         "buildingName"
+#define NID_buildingName                494
+#define OBJ_buildingName                OBJ_pilotAttributeType,48L
+
+#define LN_dSAQuality           "dSAQuality"
+#define NID_dSAQuality          495
+#define OBJ_dSAQuality          OBJ_pilotAttributeType,49L
+
+#define LN_singleLevelQuality           "singleLevelQuality"
+#define NID_singleLevelQuality          496
+#define OBJ_singleLevelQuality          OBJ_pilotAttributeType,50L
+
+#define LN_subtreeMinimumQuality                "subtreeMinimumQuality"
+#define NID_subtreeMinimumQuality               497
+#define OBJ_subtreeMinimumQuality               OBJ_pilotAttributeType,51L
+
+#define LN_subtreeMaximumQuality                "subtreeMaximumQuality"
+#define NID_subtreeMaximumQuality               498
+#define OBJ_subtreeMaximumQuality               OBJ_pilotAttributeType,52L
+
+#define LN_personalSignature            "personalSignature"
+#define NID_personalSignature           499
+#define OBJ_personalSignature           OBJ_pilotAttributeType,53L
+
+#define LN_dITRedirect          "dITRedirect"
+#define NID_dITRedirect         500
+#define OBJ_dITRedirect         OBJ_pilotAttributeType,54L
+
+#define SN_audio                "audio"
+#define NID_audio               501
+#define OBJ_audio               OBJ_pilotAttributeType,55L
+
+#define LN_documentPublisher            "documentPublisher"
+#define NID_documentPublisher           502
+#define OBJ_documentPublisher           OBJ_pilotAttributeType,56L
+
+#define SN_id_set               "id-set"
+#define LN_id_set               "Secure Electronic Transactions"
+#define NID_id_set              512
+#define OBJ_id_set              OBJ_international_organizations,42L
+
+#define SN_set_ctype            "set-ctype"
+#define LN_set_ctype            "content types"
+#define NID_set_ctype           513
+#define OBJ_set_ctype           OBJ_id_set,0L
+
+#define SN_set_msgExt           "set-msgExt"
+#define LN_set_msgExt           "message extensions"
+#define NID_set_msgExt          514
+#define OBJ_set_msgExt          OBJ_id_set,1L
+
+#define SN_set_attr             "set-attr"
+#define NID_set_attr            515
+#define OBJ_set_attr            OBJ_id_set,3L
+
+#define SN_set_policy           "set-policy"
+#define NID_set_policy          516
+#define OBJ_set_policy          OBJ_id_set,5L
+
+#define SN_set_certExt          "set-certExt"
+#define LN_set_certExt          "certificate extensions"
+#define NID_set_certExt         517
+#define OBJ_set_certExt         OBJ_id_set,7L
+
+#define SN_set_brand            "set-brand"
+#define NID_set_brand           518
+#define OBJ_set_brand           OBJ_id_set,8L
+
+#define SN_setct_PANData                "setct-PANData"
+#define NID_setct_PANData               519
+#define OBJ_setct_PANData               OBJ_set_ctype,0L
+
+#define SN_setct_PANToken               "setct-PANToken"
+#define NID_setct_PANToken              520
+#define OBJ_setct_PANToken              OBJ_set_ctype,1L
+
+#define SN_setct_PANOnly                "setct-PANOnly"
+#define NID_setct_PANOnly               521
+#define OBJ_setct_PANOnly               OBJ_set_ctype,2L
+
+#define SN_setct_OIData         "setct-OIData"
+#define NID_setct_OIData                522
+#define OBJ_setct_OIData                OBJ_set_ctype,3L
+
+#define SN_setct_PI             "setct-PI"
+#define NID_setct_PI            523
+#define OBJ_setct_PI            OBJ_set_ctype,4L
+
+#define SN_setct_PIData         "setct-PIData"
+#define NID_setct_PIData                524
+#define OBJ_setct_PIData                OBJ_set_ctype,5L
+
+#define SN_setct_PIDataUnsigned         "setct-PIDataUnsigned"
+#define NID_setct_PIDataUnsigned                525
+#define OBJ_setct_PIDataUnsigned                OBJ_set_ctype,6L
+
+#define SN_setct_HODInput               "setct-HODInput"
+#define NID_setct_HODInput              526
+#define OBJ_setct_HODInput              OBJ_set_ctype,7L
+
+#define SN_setct_AuthResBaggage         "setct-AuthResBaggage"
+#define NID_setct_AuthResBaggage                527
+#define OBJ_setct_AuthResBaggage                OBJ_set_ctype,8L
+
+#define SN_setct_AuthRevReqBaggage              "setct-AuthRevReqBaggage"
+#define NID_setct_AuthRevReqBaggage             528
+#define OBJ_setct_AuthRevReqBaggage             OBJ_set_ctype,9L
+
+#define SN_setct_AuthRevResBaggage              "setct-AuthRevResBaggage"
+#define NID_setct_AuthRevResBaggage             529
+#define OBJ_setct_AuthRevResBaggage             OBJ_set_ctype,10L
+
+#define SN_setct_CapTokenSeq            "setct-CapTokenSeq"
+#define NID_setct_CapTokenSeq           530
+#define OBJ_setct_CapTokenSeq           OBJ_set_ctype,11L
+
+#define SN_setct_PInitResData           "setct-PInitResData"
+#define NID_setct_PInitResData          531
+#define OBJ_setct_PInitResData          OBJ_set_ctype,12L
+
+#define SN_setct_PI_TBS         "setct-PI-TBS"
+#define NID_setct_PI_TBS                532
+#define OBJ_setct_PI_TBS                OBJ_set_ctype,13L
+
+#define SN_setct_PResData               "setct-PResData"
+#define NID_setct_PResData              533
+#define OBJ_setct_PResData              OBJ_set_ctype,14L
+
+#define SN_setct_AuthReqTBS             "setct-AuthReqTBS"
+#define NID_setct_AuthReqTBS            534
+#define OBJ_setct_AuthReqTBS            OBJ_set_ctype,16L
+
+#define SN_setct_AuthResTBS             "setct-AuthResTBS"
+#define NID_setct_AuthResTBS            535
+#define OBJ_setct_AuthResTBS            OBJ_set_ctype,17L
+
+#define SN_setct_AuthResTBSX            "setct-AuthResTBSX"
+#define NID_setct_AuthResTBSX           536
+#define OBJ_setct_AuthResTBSX           OBJ_set_ctype,18L
+
+#define SN_setct_AuthTokenTBS           "setct-AuthTokenTBS"
+#define NID_setct_AuthTokenTBS          537
+#define OBJ_setct_AuthTokenTBS          OBJ_set_ctype,19L
+
+#define SN_setct_CapTokenData           "setct-CapTokenData"
+#define NID_setct_CapTokenData          538
+#define OBJ_setct_CapTokenData          OBJ_set_ctype,20L
+
+#define SN_setct_CapTokenTBS            "setct-CapTokenTBS"
+#define NID_setct_CapTokenTBS           539
+#define OBJ_setct_CapTokenTBS           OBJ_set_ctype,21L
+
+#define SN_setct_AcqCardCodeMsg         "setct-AcqCardCodeMsg"
+#define NID_setct_AcqCardCodeMsg                540
+#define OBJ_setct_AcqCardCodeMsg                OBJ_set_ctype,22L
+
+#define SN_setct_AuthRevReqTBS          "setct-AuthRevReqTBS"
+#define NID_setct_AuthRevReqTBS         541
+#define OBJ_setct_AuthRevReqTBS         OBJ_set_ctype,23L
+
+#define SN_setct_AuthRevResData         "setct-AuthRevResData"
+#define NID_setct_AuthRevResData                542
+#define OBJ_setct_AuthRevResData                OBJ_set_ctype,24L
+
+#define SN_setct_AuthRevResTBS          "setct-AuthRevResTBS"
+#define NID_setct_AuthRevResTBS         543
+#define OBJ_setct_AuthRevResTBS         OBJ_set_ctype,25L
+
+#define SN_setct_CapReqTBS              "setct-CapReqTBS"
+#define NID_setct_CapReqTBS             544
+#define OBJ_setct_CapReqTBS             OBJ_set_ctype,26L
+
+#define SN_setct_CapReqTBSX             "setct-CapReqTBSX"
+#define NID_setct_CapReqTBSX            545
+#define OBJ_setct_CapReqTBSX            OBJ_set_ctype,27L
+
+#define SN_setct_CapResData             "setct-CapResData"
+#define NID_setct_CapResData            546
+#define OBJ_setct_CapResData            OBJ_set_ctype,28L
+
+#define SN_setct_CapRevReqTBS           "setct-CapRevReqTBS"
+#define NID_setct_CapRevReqTBS          547
+#define OBJ_setct_CapRevReqTBS          OBJ_set_ctype,29L
+
+#define SN_setct_CapRevReqTBSX          "setct-CapRevReqTBSX"
+#define NID_setct_CapRevReqTBSX         548
+#define OBJ_setct_CapRevReqTBSX         OBJ_set_ctype,30L
+
+#define SN_setct_CapRevResData          "setct-CapRevResData"
+#define NID_setct_CapRevResData         549
+#define OBJ_setct_CapRevResData         OBJ_set_ctype,31L
+
+#define SN_setct_CredReqTBS             "setct-CredReqTBS"
+#define NID_setct_CredReqTBS            550
+#define OBJ_setct_CredReqTBS            OBJ_set_ctype,32L
+
+#define SN_setct_CredReqTBSX            "setct-CredReqTBSX"
+#define NID_setct_CredReqTBSX           551
+#define OBJ_setct_CredReqTBSX           OBJ_set_ctype,33L
+
+#define SN_setct_CredResData            "setct-CredResData"
+#define NID_setct_CredResData           552
+#define OBJ_setct_CredResData           OBJ_set_ctype,34L
+
+#define SN_setct_CredRevReqTBS          "setct-CredRevReqTBS"
+#define NID_setct_CredRevReqTBS         553
+#define OBJ_setct_CredRevReqTBS         OBJ_set_ctype,35L
+
+#define SN_setct_CredRevReqTBSX         "setct-CredRevReqTBSX"
+#define NID_setct_CredRevReqTBSX                554
+#define OBJ_setct_CredRevReqTBSX                OBJ_set_ctype,36L
+
+#define SN_setct_CredRevResData         "setct-CredRevResData"
+#define NID_setct_CredRevResData                555
+#define OBJ_setct_CredRevResData                OBJ_set_ctype,37L
+
+#define SN_setct_PCertReqData           "setct-PCertReqData"
+#define NID_setct_PCertReqData          556
+#define OBJ_setct_PCertReqData          OBJ_set_ctype,38L
+
+#define SN_setct_PCertResTBS            "setct-PCertResTBS"
+#define NID_setct_PCertResTBS           557
+#define OBJ_setct_PCertResTBS           OBJ_set_ctype,39L
+
+#define SN_setct_BatchAdminReqData              "setct-BatchAdminReqData"
+#define NID_setct_BatchAdminReqData             558
+#define OBJ_setct_BatchAdminReqData             OBJ_set_ctype,40L
+
+#define SN_setct_BatchAdminResData              "setct-BatchAdminResData"
+#define NID_setct_BatchAdminResData             559
+#define OBJ_setct_BatchAdminResData             OBJ_set_ctype,41L
+
+#define SN_setct_CardCInitResTBS                "setct-CardCInitResTBS"
+#define NID_setct_CardCInitResTBS               560
+#define OBJ_setct_CardCInitResTBS               OBJ_set_ctype,42L
+
+#define SN_setct_MeAqCInitResTBS                "setct-MeAqCInitResTBS"
+#define NID_setct_MeAqCInitResTBS               561
+#define OBJ_setct_MeAqCInitResTBS               OBJ_set_ctype,43L
+
+#define SN_setct_RegFormResTBS          "setct-RegFormResTBS"
+#define NID_setct_RegFormResTBS         562
+#define OBJ_setct_RegFormResTBS         OBJ_set_ctype,44L
+
+#define SN_setct_CertReqData            "setct-CertReqData"
+#define NID_setct_CertReqData           563
+#define OBJ_setct_CertReqData           OBJ_set_ctype,45L
+
+#define SN_setct_CertReqTBS             "setct-CertReqTBS"
+#define NID_setct_CertReqTBS            564
+#define OBJ_setct_CertReqTBS            OBJ_set_ctype,46L
+
+#define SN_setct_CertResData            "setct-CertResData"
+#define NID_setct_CertResData           565
+#define OBJ_setct_CertResData           OBJ_set_ctype,47L
+
+#define SN_setct_CertInqReqTBS          "setct-CertInqReqTBS"
+#define NID_setct_CertInqReqTBS         566
+#define OBJ_setct_CertInqReqTBS         OBJ_set_ctype,48L
+
+#define SN_setct_ErrorTBS               "setct-ErrorTBS"
+#define NID_setct_ErrorTBS              567
+#define OBJ_setct_ErrorTBS              OBJ_set_ctype,49L
+
+#define SN_setct_PIDualSignedTBE                "setct-PIDualSignedTBE"
+#define NID_setct_PIDualSignedTBE               568
+#define OBJ_setct_PIDualSignedTBE               OBJ_set_ctype,50L
+
+#define SN_setct_PIUnsignedTBE          "setct-PIUnsignedTBE"
+#define NID_setct_PIUnsignedTBE         569
+#define OBJ_setct_PIUnsignedTBE         OBJ_set_ctype,51L
+
+#define SN_setct_AuthReqTBE             "setct-AuthReqTBE"
+#define NID_setct_AuthReqTBE            570
+#define OBJ_setct_AuthReqTBE            OBJ_set_ctype,52L
+
+#define SN_setct_AuthResTBE             "setct-AuthResTBE"
+#define NID_setct_AuthResTBE            571
+#define OBJ_setct_AuthResTBE            OBJ_set_ctype,53L
+
+#define SN_setct_AuthResTBEX            "setct-AuthResTBEX"
+#define NID_setct_AuthResTBEX           572
+#define OBJ_setct_AuthResTBEX           OBJ_set_ctype,54L
+
+#define SN_setct_AuthTokenTBE           "setct-AuthTokenTBE"
+#define NID_setct_AuthTokenTBE          573
+#define OBJ_setct_AuthTokenTBE          OBJ_set_ctype,55L
+
+#define SN_setct_CapTokenTBE            "setct-CapTokenTBE"
+#define NID_setct_CapTokenTBE           574
+#define OBJ_setct_CapTokenTBE           OBJ_set_ctype,56L
+
+#define SN_setct_CapTokenTBEX           "setct-CapTokenTBEX"
+#define NID_setct_CapTokenTBEX          575
+#define OBJ_setct_CapTokenTBEX          OBJ_set_ctype,57L
+
+#define SN_setct_AcqCardCodeMsgTBE              "setct-AcqCardCodeMsgTBE"
+#define NID_setct_AcqCardCodeMsgTBE             576
+#define OBJ_setct_AcqCardCodeMsgTBE             OBJ_set_ctype,58L
+
+#define SN_setct_AuthRevReqTBE          "setct-AuthRevReqTBE"
+#define NID_setct_AuthRevReqTBE         577
+#define OBJ_setct_AuthRevReqTBE         OBJ_set_ctype,59L
+
+#define SN_setct_AuthRevResTBE          "setct-AuthRevResTBE"
+#define NID_setct_AuthRevResTBE         578
+#define OBJ_setct_AuthRevResTBE         OBJ_set_ctype,60L
+
+#define SN_setct_AuthRevResTBEB         "setct-AuthRevResTBEB"
+#define NID_setct_AuthRevResTBEB                579
+#define OBJ_setct_AuthRevResTBEB                OBJ_set_ctype,61L
+
+#define SN_setct_CapReqTBE              "setct-CapReqTBE"
+#define NID_setct_CapReqTBE             580
+#define OBJ_setct_CapReqTBE             OBJ_set_ctype,62L
+
+#define SN_setct_CapReqTBEX             "setct-CapReqTBEX"
+#define NID_setct_CapReqTBEX            581
+#define OBJ_setct_CapReqTBEX            OBJ_set_ctype,63L
+
+#define SN_setct_CapResTBE              "setct-CapResTBE"
+#define NID_setct_CapResTBE             582
+#define OBJ_setct_CapResTBE             OBJ_set_ctype,64L
+
+#define SN_setct_CapRevReqTBE           "setct-CapRevReqTBE"
+#define NID_setct_CapRevReqTBE          583
+#define OBJ_setct_CapRevReqTBE          OBJ_set_ctype,65L
+
+#define SN_setct_CapRevReqTBEX          "setct-CapRevReqTBEX"
+#define NID_setct_CapRevReqTBEX         584
+#define OBJ_setct_CapRevReqTBEX         OBJ_set_ctype,66L
+
+#define SN_setct_CapRevResTBE           "setct-CapRevResTBE"
+#define NID_setct_CapRevResTBE          585
+#define OBJ_setct_CapRevResTBE          OBJ_set_ctype,67L
+
+#define SN_setct_CredReqTBE             "setct-CredReqTBE"
+#define NID_setct_CredReqTBE            586
+#define OBJ_setct_CredReqTBE            OBJ_set_ctype,68L
+
+#define SN_setct_CredReqTBEX            "setct-CredReqTBEX"
+#define NID_setct_CredReqTBEX           587
+#define OBJ_setct_CredReqTBEX           OBJ_set_ctype,69L
+
+#define SN_setct_CredResTBE             "setct-CredResTBE"
+#define NID_setct_CredResTBE            588
+#define OBJ_setct_CredResTBE            OBJ_set_ctype,70L
+
+#define SN_setct_CredRevReqTBE          "setct-CredRevReqTBE"
+#define NID_setct_CredRevReqTBE         589
+#define OBJ_setct_CredRevReqTBE         OBJ_set_ctype,71L
+
+#define SN_setct_CredRevReqTBEX         "setct-CredRevReqTBEX"
+#define NID_setct_CredRevReqTBEX                590
+#define OBJ_setct_CredRevReqTBEX                OBJ_set_ctype,72L
+
+#define SN_setct_CredRevResTBE          "setct-CredRevResTBE"
+#define NID_setct_CredRevResTBE         591
+#define OBJ_setct_CredRevResTBE         OBJ_set_ctype,73L
+
+#define SN_setct_BatchAdminReqTBE               "setct-BatchAdminReqTBE"
+#define NID_setct_BatchAdminReqTBE              592
+#define OBJ_setct_BatchAdminReqTBE              OBJ_set_ctype,74L
+
+#define SN_setct_BatchAdminResTBE               "setct-BatchAdminResTBE"
+#define NID_setct_BatchAdminResTBE              593
+#define OBJ_setct_BatchAdminResTBE              OBJ_set_ctype,75L
+
+#define SN_setct_RegFormReqTBE          "setct-RegFormReqTBE"
+#define NID_setct_RegFormReqTBE         594
+#define OBJ_setct_RegFormReqTBE         OBJ_set_ctype,76L
+
+#define SN_setct_CertReqTBE             "setct-CertReqTBE"
+#define NID_setct_CertReqTBE            595
+#define OBJ_setct_CertReqTBE            OBJ_set_ctype,77L
+
+#define SN_setct_CertReqTBEX            "setct-CertReqTBEX"
+#define NID_setct_CertReqTBEX           596
+#define OBJ_setct_CertReqTBEX           OBJ_set_ctype,78L
+
+#define SN_setct_CertResTBE             "setct-CertResTBE"
+#define NID_setct_CertResTBE            597
+#define OBJ_setct_CertResTBE            OBJ_set_ctype,79L
+
+#define SN_setct_CRLNotificationTBS             "setct-CRLNotificationTBS"
+#define NID_setct_CRLNotificationTBS            598
+#define OBJ_setct_CRLNotificationTBS            OBJ_set_ctype,80L
+
+#define SN_setct_CRLNotificationResTBS          "setct-CRLNotificationResTBS"
+#define NID_setct_CRLNotificationResTBS         599
+#define OBJ_setct_CRLNotificationResTBS         OBJ_set_ctype,81L
+
+#define SN_setct_BCIDistributionTBS             "setct-BCIDistributionTBS"
+#define NID_setct_BCIDistributionTBS            600
+#define OBJ_setct_BCIDistributionTBS            OBJ_set_ctype,82L
+
+#define SN_setext_genCrypt              "setext-genCrypt"
+#define LN_setext_genCrypt              "generic cryptogram"
+#define NID_setext_genCrypt             601
+#define OBJ_setext_genCrypt             OBJ_set_msgExt,1L
+
+#define SN_setext_miAuth                "setext-miAuth"
+#define LN_setext_miAuth                "merchant initiated auth"
+#define NID_setext_miAuth               602
+#define OBJ_setext_miAuth               OBJ_set_msgExt,3L
+
+#define SN_setext_pinSecure             "setext-pinSecure"
+#define NID_setext_pinSecure            603
+#define OBJ_setext_pinSecure            OBJ_set_msgExt,4L
+
+#define SN_setext_pinAny                "setext-pinAny"
+#define NID_setext_pinAny               604
+#define OBJ_setext_pinAny               OBJ_set_msgExt,5L
+
+#define SN_setext_track2                "setext-track2"
+#define NID_setext_track2               605
+#define OBJ_setext_track2               OBJ_set_msgExt,7L
+
+#define SN_setext_cv            "setext-cv"
+#define LN_setext_cv            "additional verification"
+#define NID_setext_cv           606
+#define OBJ_setext_cv           OBJ_set_msgExt,8L
+
+#define SN_set_policy_root              "set-policy-root"
+#define NID_set_policy_root             607
+#define OBJ_set_policy_root             OBJ_set_policy,0L
+
+#define SN_setCext_hashedRoot           "setCext-hashedRoot"
+#define NID_setCext_hashedRoot          608
+#define OBJ_setCext_hashedRoot          OBJ_set_certExt,0L
+
+#define SN_setCext_certType             "setCext-certType"
+#define NID_setCext_certType            609
+#define OBJ_setCext_certType            OBJ_set_certExt,1L
+
+#define SN_setCext_merchData            "setCext-merchData"
+#define NID_setCext_merchData           610
+#define OBJ_setCext_merchData           OBJ_set_certExt,2L
+
+#define SN_setCext_cCertRequired                "setCext-cCertRequired"
+#define NID_setCext_cCertRequired               611
+#define OBJ_setCext_cCertRequired               OBJ_set_certExt,3L
+
+#define SN_setCext_tunneling            "setCext-tunneling"
+#define NID_setCext_tunneling           612
+#define OBJ_setCext_tunneling           OBJ_set_certExt,4L
+
+#define SN_setCext_setExt               "setCext-setExt"
+#define NID_setCext_setExt              613
+#define OBJ_setCext_setExt              OBJ_set_certExt,5L
+
+#define SN_setCext_setQualf             "setCext-setQualf"
+#define NID_setCext_setQualf            614
+#define OBJ_setCext_setQualf            OBJ_set_certExt,6L
+
+#define SN_setCext_PGWYcapabilities             "setCext-PGWYcapabilities"
+#define NID_setCext_PGWYcapabilities            615
+#define OBJ_setCext_PGWYcapabilities            OBJ_set_certExt,7L
+
+#define SN_setCext_TokenIdentifier              "setCext-TokenIdentifier"
+#define NID_setCext_TokenIdentifier             616
+#define OBJ_setCext_TokenIdentifier             OBJ_set_certExt,8L
+
+#define SN_setCext_Track2Data           "setCext-Track2Data"
+#define NID_setCext_Track2Data          617
+#define OBJ_setCext_Track2Data          OBJ_set_certExt,9L
+
+#define SN_setCext_TokenType            "setCext-TokenType"
+#define NID_setCext_TokenType           618
+#define OBJ_setCext_TokenType           OBJ_set_certExt,10L
+
+#define SN_setCext_IssuerCapabilities           "setCext-IssuerCapabilities"
+#define NID_setCext_IssuerCapabilities          619
+#define OBJ_setCext_IssuerCapabilities          OBJ_set_certExt,11L
+
+#define SN_setAttr_Cert         "setAttr-Cert"
+#define NID_setAttr_Cert                620
+#define OBJ_setAttr_Cert                OBJ_set_attr,0L
+
+#define SN_setAttr_PGWYcap              "setAttr-PGWYcap"
+#define LN_setAttr_PGWYcap              "payment gateway capabilities"
+#define NID_setAttr_PGWYcap             621
+#define OBJ_setAttr_PGWYcap             OBJ_set_attr,1L
+
+#define SN_setAttr_TokenType            "setAttr-TokenType"
+#define NID_setAttr_TokenType           622
+#define OBJ_setAttr_TokenType           OBJ_set_attr,2L
+
+#define SN_setAttr_IssCap               "setAttr-IssCap"
+#define LN_setAttr_IssCap               "issuer capabilities"
+#define NID_setAttr_IssCap              623
+#define OBJ_setAttr_IssCap              OBJ_set_attr,3L
+
+#define SN_set_rootKeyThumb             "set-rootKeyThumb"
+#define NID_set_rootKeyThumb            624
+#define OBJ_set_rootKeyThumb            OBJ_setAttr_Cert,0L
+
+#define SN_set_addPolicy                "set-addPolicy"
+#define NID_set_addPolicy               625
+#define OBJ_set_addPolicy               OBJ_setAttr_Cert,1L
+
+#define SN_setAttr_Token_EMV            "setAttr-Token-EMV"
+#define NID_setAttr_Token_EMV           626
+#define OBJ_setAttr_Token_EMV           OBJ_setAttr_TokenType,1L
+
+#define SN_setAttr_Token_B0Prime                "setAttr-Token-B0Prime"
+#define NID_setAttr_Token_B0Prime               627
+#define OBJ_setAttr_Token_B0Prime               OBJ_setAttr_TokenType,2L
+
+#define SN_setAttr_IssCap_CVM           "setAttr-IssCap-CVM"
+#define NID_setAttr_IssCap_CVM          628
+#define OBJ_setAttr_IssCap_CVM          OBJ_setAttr_IssCap,3L
+
+#define SN_setAttr_IssCap_T2            "setAttr-IssCap-T2"
+#define NID_setAttr_IssCap_T2           629
+#define OBJ_setAttr_IssCap_T2           OBJ_setAttr_IssCap,4L
+
+#define SN_setAttr_IssCap_Sig           "setAttr-IssCap-Sig"
+#define NID_setAttr_IssCap_Sig          630
+#define OBJ_setAttr_IssCap_Sig          OBJ_setAttr_IssCap,5L
+
+#define SN_setAttr_GenCryptgrm          "setAttr-GenCryptgrm"
+#define LN_setAttr_GenCryptgrm          "generate cryptogram"
+#define NID_setAttr_GenCryptgrm         631
+#define OBJ_setAttr_GenCryptgrm         OBJ_setAttr_IssCap_CVM,1L
+
+#define SN_setAttr_T2Enc                "setAttr-T2Enc"
+#define LN_setAttr_T2Enc                "encrypted track 2"
+#define NID_setAttr_T2Enc               632
+#define OBJ_setAttr_T2Enc               OBJ_setAttr_IssCap_T2,1L
+
+#define SN_setAttr_T2cleartxt           "setAttr-T2cleartxt"
+#define LN_setAttr_T2cleartxt           "cleartext track 2"
+#define NID_setAttr_T2cleartxt          633
+#define OBJ_setAttr_T2cleartxt          OBJ_setAttr_IssCap_T2,2L
+
+#define SN_setAttr_TokICCsig            "setAttr-TokICCsig"
+#define LN_setAttr_TokICCsig            "ICC or token signature"
+#define NID_setAttr_TokICCsig           634
+#define OBJ_setAttr_TokICCsig           OBJ_setAttr_IssCap_Sig,1L
+
+#define SN_setAttr_SecDevSig            "setAttr-SecDevSig"
+#define LN_setAttr_SecDevSig            "secure device signature"
+#define NID_setAttr_SecDevSig           635
+#define OBJ_setAttr_SecDevSig           OBJ_setAttr_IssCap_Sig,2L
+
+#define SN_set_brand_IATA_ATA           "set-brand-IATA-ATA"
+#define NID_set_brand_IATA_ATA          636
+#define OBJ_set_brand_IATA_ATA          OBJ_set_brand,1L
+
+#define SN_set_brand_Diners             "set-brand-Diners"
+#define NID_set_brand_Diners            637
+#define OBJ_set_brand_Diners            OBJ_set_brand,30L
+
+#define SN_set_brand_AmericanExpress            "set-brand-AmericanExpress"
+#define NID_set_brand_AmericanExpress           638
+#define OBJ_set_brand_AmericanExpress           OBJ_set_brand,34L
+
+#define SN_set_brand_JCB                "set-brand-JCB"
+#define NID_set_brand_JCB               639
+#define OBJ_set_brand_JCB               OBJ_set_brand,35L
+
+#define SN_set_brand_Visa               "set-brand-Visa"
+#define NID_set_brand_Visa              640
+#define OBJ_set_brand_Visa              OBJ_set_brand,4L
+
+#define SN_set_brand_MasterCard         "set-brand-MasterCard"
+#define NID_set_brand_MasterCard                641
+#define OBJ_set_brand_MasterCard                OBJ_set_brand,5L
+
+#define SN_set_brand_Novus              "set-brand-Novus"
+#define NID_set_brand_Novus             642
+#define OBJ_set_brand_Novus             OBJ_set_brand,6011L
+
+#define SN_des_cdmf             "DES-CDMF"
+#define LN_des_cdmf             "des-cdmf"
+#define NID_des_cdmf            643
+#define OBJ_des_cdmf            OBJ_rsadsi,3L,10L
+
+#define SN_rsaOAEPEncryptionSET         "rsaOAEPEncryptionSET"
+#define NID_rsaOAEPEncryptionSET                644
+#define OBJ_rsaOAEPEncryptionSET                OBJ_rsadsi,1L,1L,6L
+
+#define SN_ipsec3               "Oakley-EC2N-3"
+#define LN_ipsec3               "ipsec3"
+#define NID_ipsec3              749
+
+#define SN_ipsec4               "Oakley-EC2N-4"
+#define LN_ipsec4               "ipsec4"
+#define NID_ipsec4              750
+
+#define SN_whirlpool            "whirlpool"
+#define NID_whirlpool           804
+#define OBJ_whirlpool           OBJ_iso,0L,10118L,3L,0L,55L
+
+#define SN_cryptopro            "cryptopro"
+#define NID_cryptopro           805
+#define OBJ_cryptopro           OBJ_member_body,643L,2L,2L
+
+#define SN_cryptocom            "cryptocom"
+#define NID_cryptocom           806
+#define OBJ_cryptocom           OBJ_member_body,643L,2L,9L
+
+#define SN_id_tc26              "id-tc26"
+#define NID_id_tc26             974
+#define OBJ_id_tc26             OBJ_member_body,643L,7L,1L
+
+#define SN_id_GostR3411_94_with_GostR3410_2001          "id-GostR3411-94-with-GostR3410-2001"
+#define LN_id_GostR3411_94_with_GostR3410_2001          "GOST R 34.11-94 with GOST R 34.10-2001"
+#define NID_id_GostR3411_94_with_GostR3410_2001         807
+#define OBJ_id_GostR3411_94_with_GostR3410_2001         OBJ_cryptopro,3L
+
+#define SN_id_GostR3411_94_with_GostR3410_94            "id-GostR3411-94-with-GostR3410-94"
+#define LN_id_GostR3411_94_with_GostR3410_94            "GOST R 34.11-94 with GOST R 34.10-94"
+#define NID_id_GostR3411_94_with_GostR3410_94           808
+#define OBJ_id_GostR3411_94_with_GostR3410_94           OBJ_cryptopro,4L
+
+#define SN_id_GostR3411_94              "md_gost94"
+#define LN_id_GostR3411_94              "GOST R 34.11-94"
+#define NID_id_GostR3411_94             809
+#define OBJ_id_GostR3411_94             OBJ_cryptopro,9L
+
+#define SN_id_HMACGostR3411_94          "id-HMACGostR3411-94"
+#define LN_id_HMACGostR3411_94          "HMAC GOST 34.11-94"
+#define NID_id_HMACGostR3411_94         810
+#define OBJ_id_HMACGostR3411_94         OBJ_cryptopro,10L
+
+#define SN_id_GostR3410_2001            "gost2001"
+#define LN_id_GostR3410_2001            "GOST R 34.10-2001"
+#define NID_id_GostR3410_2001           811
+#define OBJ_id_GostR3410_2001           OBJ_cryptopro,19L
+
+#define SN_id_GostR3410_94              "gost94"
+#define LN_id_GostR3410_94              "GOST R 34.10-94"
+#define NID_id_GostR3410_94             812
+#define OBJ_id_GostR3410_94             OBJ_cryptopro,20L
+
+#define SN_id_Gost28147_89              "gost89"
+#define LN_id_Gost28147_89              "GOST 28147-89"
+#define NID_id_Gost28147_89             813
+#define OBJ_id_Gost28147_89             OBJ_cryptopro,21L
+
+#define SN_gost89_cnt           "gost89-cnt"
+#define NID_gost89_cnt          814
+
+#define SN_gost89_cnt_12                "gost89-cnt-12"
+#define NID_gost89_cnt_12               975
+
+#define SN_gost89_cbc           "gost89-cbc"
+#define NID_gost89_cbc          1009
+
+#define SN_gost89_ecb           "gost89-ecb"
+#define NID_gost89_ecb          1010
+
+#define SN_gost89_ctr           "gost89-ctr"
+#define NID_gost89_ctr          1011
+
+#define SN_id_Gost28147_89_MAC          "gost-mac"
+#define LN_id_Gost28147_89_MAC          "GOST 28147-89 MAC"
+#define NID_id_Gost28147_89_MAC         815
+#define OBJ_id_Gost28147_89_MAC         OBJ_cryptopro,22L
+
+#define SN_gost_mac_12          "gost-mac-12"
+#define NID_gost_mac_12         976
+
+#define SN_id_GostR3411_94_prf          "prf-gostr3411-94"
+#define LN_id_GostR3411_94_prf          "GOST R 34.11-94 PRF"
+#define NID_id_GostR3411_94_prf         816
+#define OBJ_id_GostR3411_94_prf         OBJ_cryptopro,23L
+
+#define SN_id_GostR3410_2001DH          "id-GostR3410-2001DH"
+#define LN_id_GostR3410_2001DH          "GOST R 34.10-2001 DH"
+#define NID_id_GostR3410_2001DH         817
+#define OBJ_id_GostR3410_2001DH         OBJ_cryptopro,98L
+
+#define SN_id_GostR3410_94DH            "id-GostR3410-94DH"
+#define LN_id_GostR3410_94DH            "GOST R 34.10-94 DH"
+#define NID_id_GostR3410_94DH           818
+#define OBJ_id_GostR3410_94DH           OBJ_cryptopro,99L
+
+#define SN_id_Gost28147_89_CryptoPro_KeyMeshing         "id-Gost28147-89-CryptoPro-KeyMeshing"
+#define NID_id_Gost28147_89_CryptoPro_KeyMeshing                819
+#define OBJ_id_Gost28147_89_CryptoPro_KeyMeshing                OBJ_cryptopro,14L,1L
+
+#define SN_id_Gost28147_89_None_KeyMeshing              "id-Gost28147-89-None-KeyMeshing"
+#define NID_id_Gost28147_89_None_KeyMeshing             820
+#define OBJ_id_Gost28147_89_None_KeyMeshing             OBJ_cryptopro,14L,0L
+
+#define SN_id_GostR3411_94_TestParamSet         "id-GostR3411-94-TestParamSet"
+#define NID_id_GostR3411_94_TestParamSet                821
+#define OBJ_id_GostR3411_94_TestParamSet                OBJ_cryptopro,30L,0L
+
+#define SN_id_GostR3411_94_CryptoProParamSet            "id-GostR3411-94-CryptoProParamSet"
+#define NID_id_GostR3411_94_CryptoProParamSet           822
+#define OBJ_id_GostR3411_94_CryptoProParamSet           OBJ_cryptopro,30L,1L
+
+#define SN_id_Gost28147_89_TestParamSet         "id-Gost28147-89-TestParamSet"
+#define NID_id_Gost28147_89_TestParamSet                823
+#define OBJ_id_Gost28147_89_TestParamSet                OBJ_cryptopro,31L,0L
+
+#define SN_id_Gost28147_89_CryptoPro_A_ParamSet         "id-Gost28147-89-CryptoPro-A-ParamSet"
+#define NID_id_Gost28147_89_CryptoPro_A_ParamSet                824
+#define OBJ_id_Gost28147_89_CryptoPro_A_ParamSet                OBJ_cryptopro,31L,1L
+
+#define SN_id_Gost28147_89_CryptoPro_B_ParamSet         "id-Gost28147-89-CryptoPro-B-ParamSet"
+#define NID_id_Gost28147_89_CryptoPro_B_ParamSet                825
+#define OBJ_id_Gost28147_89_CryptoPro_B_ParamSet                OBJ_cryptopro,31L,2L
+
+#define SN_id_Gost28147_89_CryptoPro_C_ParamSet         "id-Gost28147-89-CryptoPro-C-ParamSet"
+#define NID_id_Gost28147_89_CryptoPro_C_ParamSet                826
+#define OBJ_id_Gost28147_89_CryptoPro_C_ParamSet                OBJ_cryptopro,31L,3L
+
+#define SN_id_Gost28147_89_CryptoPro_D_ParamSet         "id-Gost28147-89-CryptoPro-D-ParamSet"
+#define NID_id_Gost28147_89_CryptoPro_D_ParamSet                827
+#define OBJ_id_Gost28147_89_CryptoPro_D_ParamSet                OBJ_cryptopro,31L,4L
+
+#define SN_id_Gost28147_89_CryptoPro_Oscar_1_1_ParamSet         "id-Gost28147-89-CryptoPro-Oscar-1-1-ParamSet"
+#define NID_id_Gost28147_89_CryptoPro_Oscar_1_1_ParamSet                828
+#define OBJ_id_Gost28147_89_CryptoPro_Oscar_1_1_ParamSet                OBJ_cryptopro,31L,5L
+
+#define SN_id_Gost28147_89_CryptoPro_Oscar_1_0_ParamSet         "id-Gost28147-89-CryptoPro-Oscar-1-0-ParamSet"
+#define NID_id_Gost28147_89_CryptoPro_Oscar_1_0_ParamSet                829
+#define OBJ_id_Gost28147_89_CryptoPro_Oscar_1_0_ParamSet                OBJ_cryptopro,31L,6L
+
+#define SN_id_Gost28147_89_CryptoPro_RIC_1_ParamSet             "id-Gost28147-89-CryptoPro-RIC-1-ParamSet"
+#define NID_id_Gost28147_89_CryptoPro_RIC_1_ParamSet            830
+#define OBJ_id_Gost28147_89_CryptoPro_RIC_1_ParamSet            OBJ_cryptopro,31L,7L
+
+#define SN_id_GostR3410_94_TestParamSet         "id-GostR3410-94-TestParamSet"
+#define NID_id_GostR3410_94_TestParamSet                831
+#define OBJ_id_GostR3410_94_TestParamSet                OBJ_cryptopro,32L,0L
+
+#define SN_id_GostR3410_94_CryptoPro_A_ParamSet         "id-GostR3410-94-CryptoPro-A-ParamSet"
+#define NID_id_GostR3410_94_CryptoPro_A_ParamSet                832
+#define OBJ_id_GostR3410_94_CryptoPro_A_ParamSet                OBJ_cryptopro,32L,2L
+
+#define SN_id_GostR3410_94_CryptoPro_B_ParamSet         "id-GostR3410-94-CryptoPro-B-ParamSet"
+#define NID_id_GostR3410_94_CryptoPro_B_ParamSet                833
+#define OBJ_id_GostR3410_94_CryptoPro_B_ParamSet                OBJ_cryptopro,32L,3L
+
+#define SN_id_GostR3410_94_CryptoPro_C_ParamSet         "id-GostR3410-94-CryptoPro-C-ParamSet"
+#define NID_id_GostR3410_94_CryptoPro_C_ParamSet                834
+#define OBJ_id_GostR3410_94_CryptoPro_C_ParamSet                OBJ_cryptopro,32L,4L
+
+#define SN_id_GostR3410_94_CryptoPro_D_ParamSet         "id-GostR3410-94-CryptoPro-D-ParamSet"
+#define NID_id_GostR3410_94_CryptoPro_D_ParamSet                835
+#define OBJ_id_GostR3410_94_CryptoPro_D_ParamSet                OBJ_cryptopro,32L,5L
+
+#define SN_id_GostR3410_94_CryptoPro_XchA_ParamSet              "id-GostR3410-94-CryptoPro-XchA-ParamSet"
+#define NID_id_GostR3410_94_CryptoPro_XchA_ParamSet             836
+#define OBJ_id_GostR3410_94_CryptoPro_XchA_ParamSet             OBJ_cryptopro,33L,1L
+
+#define SN_id_GostR3410_94_CryptoPro_XchB_ParamSet              "id-GostR3410-94-CryptoPro-XchB-ParamSet"
+#define NID_id_GostR3410_94_CryptoPro_XchB_ParamSet             837
+#define OBJ_id_GostR3410_94_CryptoPro_XchB_ParamSet             OBJ_cryptopro,33L,2L
+
+#define SN_id_GostR3410_94_CryptoPro_XchC_ParamSet              "id-GostR3410-94-CryptoPro-XchC-ParamSet"
+#define NID_id_GostR3410_94_CryptoPro_XchC_ParamSet             838
+#define OBJ_id_GostR3410_94_CryptoPro_XchC_ParamSet             OBJ_cryptopro,33L,3L
+
+#define SN_id_GostR3410_2001_TestParamSet               "id-GostR3410-2001-TestParamSet"
+#define NID_id_GostR3410_2001_TestParamSet              839
+#define OBJ_id_GostR3410_2001_TestParamSet              OBJ_cryptopro,35L,0L
+
+#define SN_id_GostR3410_2001_CryptoPro_A_ParamSet               "id-GostR3410-2001-CryptoPro-A-ParamSet"
+#define NID_id_GostR3410_2001_CryptoPro_A_ParamSet              840
+#define OBJ_id_GostR3410_2001_CryptoPro_A_ParamSet              OBJ_cryptopro,35L,1L
+
+#define SN_id_GostR3410_2001_CryptoPro_B_ParamSet               "id-GostR3410-2001-CryptoPro-B-ParamSet"
+#define NID_id_GostR3410_2001_CryptoPro_B_ParamSet              841
+#define OBJ_id_GostR3410_2001_CryptoPro_B_ParamSet              OBJ_cryptopro,35L,2L
+
+#define SN_id_GostR3410_2001_CryptoPro_C_ParamSet               "id-GostR3410-2001-CryptoPro-C-ParamSet"
+#define NID_id_GostR3410_2001_CryptoPro_C_ParamSet              842
+#define OBJ_id_GostR3410_2001_CryptoPro_C_ParamSet              OBJ_cryptopro,35L,3L
+
+#define SN_id_GostR3410_2001_CryptoPro_XchA_ParamSet            "id-GostR3410-2001-CryptoPro-XchA-ParamSet"
+#define NID_id_GostR3410_2001_CryptoPro_XchA_ParamSet           843
+#define OBJ_id_GostR3410_2001_CryptoPro_XchA_ParamSet           OBJ_cryptopro,36L,0L
+
+#define SN_id_GostR3410_2001_CryptoPro_XchB_ParamSet            "id-GostR3410-2001-CryptoPro-XchB-ParamSet"
+#define NID_id_GostR3410_2001_CryptoPro_XchB_ParamSet           844
+#define OBJ_id_GostR3410_2001_CryptoPro_XchB_ParamSet           OBJ_cryptopro,36L,1L
+
+#define SN_id_GostR3410_94_a            "id-GostR3410-94-a"
+#define NID_id_GostR3410_94_a           845
+#define OBJ_id_GostR3410_94_a           OBJ_id_GostR3410_94,1L
+
+#define SN_id_GostR3410_94_aBis         "id-GostR3410-94-aBis"
+#define NID_id_GostR3410_94_aBis                846
+#define OBJ_id_GostR3410_94_aBis                OBJ_id_GostR3410_94,2L
+
+#define SN_id_GostR3410_94_b            "id-GostR3410-94-b"
+#define NID_id_GostR3410_94_b           847
+#define OBJ_id_GostR3410_94_b           OBJ_id_GostR3410_94,3L
+
+#define SN_id_GostR3410_94_bBis         "id-GostR3410-94-bBis"
+#define NID_id_GostR3410_94_bBis                848
+#define OBJ_id_GostR3410_94_bBis                OBJ_id_GostR3410_94,4L
+
+#define SN_id_Gost28147_89_cc           "id-Gost28147-89-cc"
+#define LN_id_Gost28147_89_cc           "GOST 28147-89 Cryptocom ParamSet"
+#define NID_id_Gost28147_89_cc          849
+#define OBJ_id_Gost28147_89_cc          OBJ_cryptocom,1L,6L,1L
+
+#define SN_id_GostR3410_94_cc           "gost94cc"
+#define LN_id_GostR3410_94_cc           "GOST 34.10-94 Cryptocom"
+#define NID_id_GostR3410_94_cc          850
+#define OBJ_id_GostR3410_94_cc          OBJ_cryptocom,1L,5L,3L
+
+#define SN_id_GostR3410_2001_cc         "gost2001cc"
+#define LN_id_GostR3410_2001_cc         "GOST 34.10-2001 Cryptocom"
+#define NID_id_GostR3410_2001_cc                851
+#define OBJ_id_GostR3410_2001_cc                OBJ_cryptocom,1L,5L,4L
+
+#define SN_id_GostR3411_94_with_GostR3410_94_cc         "id-GostR3411-94-with-GostR3410-94-cc"
+#define LN_id_GostR3411_94_with_GostR3410_94_cc         "GOST R 34.11-94 with GOST R 34.10-94 Cryptocom"
+#define NID_id_GostR3411_94_with_GostR3410_94_cc                852
+#define OBJ_id_GostR3411_94_with_GostR3410_94_cc                OBJ_cryptocom,1L,3L,3L
+
+#define SN_id_GostR3411_94_with_GostR3410_2001_cc               "id-GostR3411-94-with-GostR3410-2001-cc"
+#define LN_id_GostR3411_94_with_GostR3410_2001_cc               "GOST R 34.11-94 with GOST R 34.10-2001 Cryptocom"
+#define NID_id_GostR3411_94_with_GostR3410_2001_cc              853
+#define OBJ_id_GostR3411_94_with_GostR3410_2001_cc              OBJ_cryptocom,1L,3L,4L
+
+#define SN_id_GostR3410_2001_ParamSet_cc                "id-GostR3410-2001-ParamSet-cc"
+#define LN_id_GostR3410_2001_ParamSet_cc                "GOST R 3410-2001 Parameter Set Cryptocom"
+#define NID_id_GostR3410_2001_ParamSet_cc               854
+#define OBJ_id_GostR3410_2001_ParamSet_cc               OBJ_cryptocom,1L,8L,1L
+
+#define SN_id_tc26_algorithms           "id-tc26-algorithms"
+#define NID_id_tc26_algorithms          977
+#define OBJ_id_tc26_algorithms          OBJ_id_tc26,1L
+
+#define SN_id_tc26_sign         "id-tc26-sign"
+#define NID_id_tc26_sign                978
+#define OBJ_id_tc26_sign                OBJ_id_tc26_algorithms,1L
+
+#define SN_id_GostR3410_2012_256                "gost2012_256"
+#define LN_id_GostR3410_2012_256                "GOST R 34.10-2012 with 256 bit modulus"
+#define NID_id_GostR3410_2012_256               979
+#define OBJ_id_GostR3410_2012_256               OBJ_id_tc26_sign,1L
+
+#define SN_id_GostR3410_2012_512                "gost2012_512"
+#define LN_id_GostR3410_2012_512                "GOST R 34.10-2012 with 512 bit modulus"
+#define NID_id_GostR3410_2012_512               980
+#define OBJ_id_GostR3410_2012_512               OBJ_id_tc26_sign,2L
+
+#define SN_id_tc26_digest               "id-tc26-digest"
+#define NID_id_tc26_digest              981
+#define OBJ_id_tc26_digest              OBJ_id_tc26_algorithms,2L
+
+#define SN_id_GostR3411_2012_256                "md_gost12_256"
+#define LN_id_GostR3411_2012_256                "GOST R 34.11-2012 with 256 bit hash"
+#define NID_id_GostR3411_2012_256               982
+#define OBJ_id_GostR3411_2012_256               OBJ_id_tc26_digest,2L
+
+#define SN_id_GostR3411_2012_512                "md_gost12_512"
+#define LN_id_GostR3411_2012_512                "GOST R 34.11-2012 with 512 bit hash"
+#define NID_id_GostR3411_2012_512               983
+#define OBJ_id_GostR3411_2012_512               OBJ_id_tc26_digest,3L
+
+#define SN_id_tc26_signwithdigest               "id-tc26-signwithdigest"
+#define NID_id_tc26_signwithdigest              984
+#define OBJ_id_tc26_signwithdigest              OBJ_id_tc26_algorithms,3L
+
+#define SN_id_tc26_signwithdigest_gost3410_2012_256             "id-tc26-signwithdigest-gost3410-2012-256"
+#define LN_id_tc26_signwithdigest_gost3410_2012_256             "GOST R 34.10-2012 with GOST R 34.11-2012 (256 bit)"
+#define NID_id_tc26_signwithdigest_gost3410_2012_256            985
+#define OBJ_id_tc26_signwithdigest_gost3410_2012_256            OBJ_id_tc26_signwithdigest,2L
+
+#define SN_id_tc26_signwithdigest_gost3410_2012_512             "id-tc26-signwithdigest-gost3410-2012-512"
+#define LN_id_tc26_signwithdigest_gost3410_2012_512             "GOST R 34.10-2012 with GOST R 34.11-2012 (512 bit)"
+#define NID_id_tc26_signwithdigest_gost3410_2012_512            986
+#define OBJ_id_tc26_signwithdigest_gost3410_2012_512            OBJ_id_tc26_signwithdigest,3L
+
+#define SN_id_tc26_mac          "id-tc26-mac"
+#define NID_id_tc26_mac         987
+#define OBJ_id_tc26_mac         OBJ_id_tc26_algorithms,4L
+
+#define SN_id_tc26_hmac_gost_3411_2012_256              "id-tc26-hmac-gost-3411-2012-256"
+#define LN_id_tc26_hmac_gost_3411_2012_256              "HMAC GOST 34.11-2012 256 bit"
+#define NID_id_tc26_hmac_gost_3411_2012_256             988
+#define OBJ_id_tc26_hmac_gost_3411_2012_256             OBJ_id_tc26_mac,1L
+
+#define SN_id_tc26_hmac_gost_3411_2012_512              "id-tc26-hmac-gost-3411-2012-512"
+#define LN_id_tc26_hmac_gost_3411_2012_512              "HMAC GOST 34.11-2012 512 bit"
+#define NID_id_tc26_hmac_gost_3411_2012_512             989
+#define OBJ_id_tc26_hmac_gost_3411_2012_512             OBJ_id_tc26_mac,2L
+
+#define SN_id_tc26_cipher               "id-tc26-cipher"
+#define NID_id_tc26_cipher              990
+#define OBJ_id_tc26_cipher              OBJ_id_tc26_algorithms,5L
+
+#define SN_id_tc26_cipher_gostr3412_2015_magma          "id-tc26-cipher-gostr3412-2015-magma"
+#define NID_id_tc26_cipher_gostr3412_2015_magma         1173
+#define OBJ_id_tc26_cipher_gostr3412_2015_magma         OBJ_id_tc26_cipher,1L
+
+#define SN_magma_ctr_acpkm              "magma-ctr-acpkm"
+#define NID_magma_ctr_acpkm             1174
+#define OBJ_magma_ctr_acpkm             OBJ_id_tc26_cipher_gostr3412_2015_magma,1L
+
+#define SN_magma_ctr_acpkm_omac         "magma-ctr-acpkm-omac"
+#define NID_magma_ctr_acpkm_omac                1175
+#define OBJ_magma_ctr_acpkm_omac                OBJ_id_tc26_cipher_gostr3412_2015_magma,2L
+
+#define SN_id_tc26_cipher_gostr3412_2015_kuznyechik             "id-tc26-cipher-gostr3412-2015-kuznyechik"
+#define NID_id_tc26_cipher_gostr3412_2015_kuznyechik            1176
+#define OBJ_id_tc26_cipher_gostr3412_2015_kuznyechik            OBJ_id_tc26_cipher,2L
+
+#define SN_kuznyechik_ctr_acpkm         "kuznyechik-ctr-acpkm"
+#define NID_kuznyechik_ctr_acpkm                1177
+#define OBJ_kuznyechik_ctr_acpkm                OBJ_id_tc26_cipher_gostr3412_2015_kuznyechik,1L
+
+#define SN_kuznyechik_ctr_acpkm_omac            "kuznyechik-ctr-acpkm-omac"
+#define NID_kuznyechik_ctr_acpkm_omac           1178
+#define OBJ_kuznyechik_ctr_acpkm_omac           OBJ_id_tc26_cipher_gostr3412_2015_kuznyechik,2L
+
+#define SN_id_tc26_agreement            "id-tc26-agreement"
+#define NID_id_tc26_agreement           991
+#define OBJ_id_tc26_agreement           OBJ_id_tc26_algorithms,6L
+
+#define SN_id_tc26_agreement_gost_3410_2012_256         "id-tc26-agreement-gost-3410-2012-256"
+#define NID_id_tc26_agreement_gost_3410_2012_256                992
+#define OBJ_id_tc26_agreement_gost_3410_2012_256                OBJ_id_tc26_agreement,1L
+
+#define SN_id_tc26_agreement_gost_3410_2012_512         "id-tc26-agreement-gost-3410-2012-512"
+#define NID_id_tc26_agreement_gost_3410_2012_512                993
+#define OBJ_id_tc26_agreement_gost_3410_2012_512                OBJ_id_tc26_agreement,2L
+
+#define SN_id_tc26_wrap         "id-tc26-wrap"
+#define NID_id_tc26_wrap                1179
+#define OBJ_id_tc26_wrap                OBJ_id_tc26_algorithms,7L
+
+#define SN_id_tc26_wrap_gostr3412_2015_magma            "id-tc26-wrap-gostr3412-2015-magma"
+#define NID_id_tc26_wrap_gostr3412_2015_magma           1180
+#define OBJ_id_tc26_wrap_gostr3412_2015_magma           OBJ_id_tc26_wrap,1L
+
+#define SN_magma_kexp15         "magma-kexp15"
+#define NID_magma_kexp15                1181
+#define OBJ_magma_kexp15                OBJ_id_tc26_wrap_gostr3412_2015_magma,1L
+
+#define SN_id_tc26_wrap_gostr3412_2015_kuznyechik               "id-tc26-wrap-gostr3412-2015-kuznyechik"
+#define NID_id_tc26_wrap_gostr3412_2015_kuznyechik              1182
+#define OBJ_id_tc26_wrap_gostr3412_2015_kuznyechik              OBJ_id_tc26_wrap,2L
+
+#define SN_kuznyechik_kexp15            "kuznyechik-kexp15"
+#define NID_kuznyechik_kexp15           1183
+#define OBJ_kuznyechik_kexp15           OBJ_id_tc26_wrap_gostr3412_2015_kuznyechik,1L
+
+#define SN_id_tc26_constants            "id-tc26-constants"
+#define NID_id_tc26_constants           994
+#define OBJ_id_tc26_constants           OBJ_id_tc26,2L
+
+#define SN_id_tc26_sign_constants               "id-tc26-sign-constants"
+#define NID_id_tc26_sign_constants              995
+#define OBJ_id_tc26_sign_constants              OBJ_id_tc26_constants,1L
+
+#define SN_id_tc26_gost_3410_2012_256_constants         "id-tc26-gost-3410-2012-256-constants"
+#define NID_id_tc26_gost_3410_2012_256_constants                1147
+#define OBJ_id_tc26_gost_3410_2012_256_constants                OBJ_id_tc26_sign_constants,1L
+
+#define SN_id_tc26_gost_3410_2012_256_paramSetA         "id-tc26-gost-3410-2012-256-paramSetA"
+#define LN_id_tc26_gost_3410_2012_256_paramSetA         "GOST R 34.10-2012 (256 bit) ParamSet A"
+#define NID_id_tc26_gost_3410_2012_256_paramSetA                1148
+#define OBJ_id_tc26_gost_3410_2012_256_paramSetA                OBJ_id_tc26_gost_3410_2012_256_constants,1L
+
+#define SN_id_tc26_gost_3410_2012_256_paramSetB         "id-tc26-gost-3410-2012-256-paramSetB"
+#define LN_id_tc26_gost_3410_2012_256_paramSetB         "GOST R 34.10-2012 (256 bit) ParamSet B"
+#define NID_id_tc26_gost_3410_2012_256_paramSetB                1184
+#define OBJ_id_tc26_gost_3410_2012_256_paramSetB                OBJ_id_tc26_gost_3410_2012_256_constants,2L
+
+#define SN_id_tc26_gost_3410_2012_256_paramSetC         "id-tc26-gost-3410-2012-256-paramSetC"
+#define LN_id_tc26_gost_3410_2012_256_paramSetC         "GOST R 34.10-2012 (256 bit) ParamSet C"
+#define NID_id_tc26_gost_3410_2012_256_paramSetC                1185
+#define OBJ_id_tc26_gost_3410_2012_256_paramSetC                OBJ_id_tc26_gost_3410_2012_256_constants,3L
+
+#define SN_id_tc26_gost_3410_2012_256_paramSetD         "id-tc26-gost-3410-2012-256-paramSetD"
+#define LN_id_tc26_gost_3410_2012_256_paramSetD         "GOST R 34.10-2012 (256 bit) ParamSet D"
+#define NID_id_tc26_gost_3410_2012_256_paramSetD                1186
+#define OBJ_id_tc26_gost_3410_2012_256_paramSetD                OBJ_id_tc26_gost_3410_2012_256_constants,4L
+
+#define SN_id_tc26_gost_3410_2012_512_constants         "id-tc26-gost-3410-2012-512-constants"
+#define NID_id_tc26_gost_3410_2012_512_constants                996
+#define OBJ_id_tc26_gost_3410_2012_512_constants                OBJ_id_tc26_sign_constants,2L
+
+#define SN_id_tc26_gost_3410_2012_512_paramSetTest              "id-tc26-gost-3410-2012-512-paramSetTest"
+#define LN_id_tc26_gost_3410_2012_512_paramSetTest              "GOST R 34.10-2012 (512 bit) testing parameter set"
+#define NID_id_tc26_gost_3410_2012_512_paramSetTest             997
+#define OBJ_id_tc26_gost_3410_2012_512_paramSetTest             OBJ_id_tc26_gost_3410_2012_512_constants,0L
+
+#define SN_id_tc26_gost_3410_2012_512_paramSetA         "id-tc26-gost-3410-2012-512-paramSetA"
+#define LN_id_tc26_gost_3410_2012_512_paramSetA         "GOST R 34.10-2012 (512 bit) ParamSet A"
+#define NID_id_tc26_gost_3410_2012_512_paramSetA                998
+#define OBJ_id_tc26_gost_3410_2012_512_paramSetA                OBJ_id_tc26_gost_3410_2012_512_constants,1L
+
+#define SN_id_tc26_gost_3410_2012_512_paramSetB         "id-tc26-gost-3410-2012-512-paramSetB"
+#define LN_id_tc26_gost_3410_2012_512_paramSetB         "GOST R 34.10-2012 (512 bit) ParamSet B"
+#define NID_id_tc26_gost_3410_2012_512_paramSetB                999
+#define OBJ_id_tc26_gost_3410_2012_512_paramSetB                OBJ_id_tc26_gost_3410_2012_512_constants,2L
+
+#define SN_id_tc26_gost_3410_2012_512_paramSetC         "id-tc26-gost-3410-2012-512-paramSetC"
+#define LN_id_tc26_gost_3410_2012_512_paramSetC         "GOST R 34.10-2012 (512 bit) ParamSet C"
+#define NID_id_tc26_gost_3410_2012_512_paramSetC                1149
+#define OBJ_id_tc26_gost_3410_2012_512_paramSetC                OBJ_id_tc26_gost_3410_2012_512_constants,3L
+
+#define SN_id_tc26_digest_constants             "id-tc26-digest-constants"
+#define NID_id_tc26_digest_constants            1000
+#define OBJ_id_tc26_digest_constants            OBJ_id_tc26_constants,2L
+
+#define SN_id_tc26_cipher_constants             "id-tc26-cipher-constants"
+#define NID_id_tc26_cipher_constants            1001
+#define OBJ_id_tc26_cipher_constants            OBJ_id_tc26_constants,5L
+
+#define SN_id_tc26_gost_28147_constants         "id-tc26-gost-28147-constants"
+#define NID_id_tc26_gost_28147_constants                1002
+#define OBJ_id_tc26_gost_28147_constants                OBJ_id_tc26_cipher_constants,1L
+
+#define SN_id_tc26_gost_28147_param_Z           "id-tc26-gost-28147-param-Z"
+#define LN_id_tc26_gost_28147_param_Z           "GOST 28147-89 TC26 parameter set"
+#define NID_id_tc26_gost_28147_param_Z          1003
+#define OBJ_id_tc26_gost_28147_param_Z          OBJ_id_tc26_gost_28147_constants,1L
+
+#define SN_INN          "INN"
+#define LN_INN          "INN"
+#define NID_INN         1004
+#define OBJ_INN         OBJ_member_body,643L,3L,131L,1L,1L
+
+#define SN_OGRN         "OGRN"
+#define LN_OGRN         "OGRN"
+#define NID_OGRN                1005
+#define OBJ_OGRN                OBJ_member_body,643L,100L,1L
+
+#define SN_SNILS                "SNILS"
+#define LN_SNILS                "SNILS"
+#define NID_SNILS               1006
+#define OBJ_SNILS               OBJ_member_body,643L,100L,3L
+
+#define SN_OGRNIP               "OGRNIP"
+#define LN_OGRNIP               "OGRNIP"
+#define NID_OGRNIP              1226
+#define OBJ_OGRNIP              OBJ_member_body,643L,100L,5L
+
+#define SN_subjectSignTool              "subjectSignTool"
+#define LN_subjectSignTool              "Signing Tool of Subject"
+#define NID_subjectSignTool             1007
+#define OBJ_subjectSignTool             OBJ_member_body,643L,100L,111L
+
+#define SN_issuerSignTool               "issuerSignTool"
+#define LN_issuerSignTool               "Signing Tool of Issuer"
+#define NID_issuerSignTool              1008
+#define OBJ_issuerSignTool              OBJ_member_body,643L,100L,112L
+
+#define SN_classSignTool                "classSignTool"
+#define LN_classSignTool                "Class of Signing Tool"
+#define NID_classSignTool               1227
+#define OBJ_classSignTool               OBJ_member_body,643L,100L,113L
+
+#define SN_classSignToolKC1             "classSignToolKC1"
+#define LN_classSignToolKC1             "Class of Signing Tool KC1"
+#define NID_classSignToolKC1            1228
+#define OBJ_classSignToolKC1            OBJ_member_body,643L,100L,113L,1L
+
+#define SN_classSignToolKC2             "classSignToolKC2"
+#define LN_classSignToolKC2             "Class of Signing Tool KC2"
+#define NID_classSignToolKC2            1229
+#define OBJ_classSignToolKC2            OBJ_member_body,643L,100L,113L,2L
+
+#define SN_classSignToolKC3             "classSignToolKC3"
+#define LN_classSignToolKC3             "Class of Signing Tool KC3"
+#define NID_classSignToolKC3            1230
+#define OBJ_classSignToolKC3            OBJ_member_body,643L,100L,113L,3L
+
+#define SN_classSignToolKB1             "classSignToolKB1"
+#define LN_classSignToolKB1             "Class of Signing Tool KB1"
+#define NID_classSignToolKB1            1231
+#define OBJ_classSignToolKB1            OBJ_member_body,643L,100L,113L,4L
+
+#define SN_classSignToolKB2             "classSignToolKB2"
+#define LN_classSignToolKB2             "Class of Signing Tool KB2"
+#define NID_classSignToolKB2            1232
+#define OBJ_classSignToolKB2            OBJ_member_body,643L,100L,113L,5L
+
+#define SN_classSignToolKA1             "classSignToolKA1"
+#define LN_classSignToolKA1             "Class of Signing Tool KA1"
+#define NID_classSignToolKA1            1233
+#define OBJ_classSignToolKA1            OBJ_member_body,643L,100L,113L,6L
+
+#define SN_kuznyechik_ecb               "kuznyechik-ecb"
+#define NID_kuznyechik_ecb              1012
+
+#define SN_kuznyechik_ctr               "kuznyechik-ctr"
+#define NID_kuznyechik_ctr              1013
+
+#define SN_kuznyechik_ofb               "kuznyechik-ofb"
+#define NID_kuznyechik_ofb              1014
+
+#define SN_kuznyechik_cbc               "kuznyechik-cbc"
+#define NID_kuznyechik_cbc              1015
+
+#define SN_kuznyechik_cfb               "kuznyechik-cfb"
+#define NID_kuznyechik_cfb              1016
+
+#define SN_kuznyechik_mac               "kuznyechik-mac"
+#define NID_kuznyechik_mac              1017
+
+#define SN_magma_ecb            "magma-ecb"
+#define NID_magma_ecb           1187
+
+#define SN_magma_ctr            "magma-ctr"
+#define NID_magma_ctr           1188
+
+#define SN_magma_ofb            "magma-ofb"
+#define NID_magma_ofb           1189
+
+#define SN_magma_cbc            "magma-cbc"
+#define NID_magma_cbc           1190
+
+#define SN_magma_cfb            "magma-cfb"
+#define NID_magma_cfb           1191
+
+#define SN_magma_mac            "magma-mac"
+#define NID_magma_mac           1192
+
+#define SN_camellia_128_cbc             "CAMELLIA-128-CBC"
+#define LN_camellia_128_cbc             "camellia-128-cbc"
+#define NID_camellia_128_cbc            751
+#define OBJ_camellia_128_cbc            1L,2L,392L,200011L,61L,1L,1L,1L,2L
+
+#define SN_camellia_192_cbc             "CAMELLIA-192-CBC"
+#define LN_camellia_192_cbc             "camellia-192-cbc"
+#define NID_camellia_192_cbc            752
+#define OBJ_camellia_192_cbc            1L,2L,392L,200011L,61L,1L,1L,1L,3L
+
+#define SN_camellia_256_cbc             "CAMELLIA-256-CBC"
+#define LN_camellia_256_cbc             "camellia-256-cbc"
+#define NID_camellia_256_cbc            753
+#define OBJ_camellia_256_cbc            1L,2L,392L,200011L,61L,1L,1L,1L,4L
+
+#define SN_id_camellia128_wrap          "id-camellia128-wrap"
+#define NID_id_camellia128_wrap         907
+#define OBJ_id_camellia128_wrap         1L,2L,392L,200011L,61L,1L,1L,3L,2L
+
+#define SN_id_camellia192_wrap          "id-camellia192-wrap"
+#define NID_id_camellia192_wrap         908
+#define OBJ_id_camellia192_wrap         1L,2L,392L,200011L,61L,1L,1L,3L,3L
+
+#define SN_id_camellia256_wrap          "id-camellia256-wrap"
+#define NID_id_camellia256_wrap         909
+#define OBJ_id_camellia256_wrap         1L,2L,392L,200011L,61L,1L,1L,3L,4L
+
+#define OBJ_ntt_ds              0L,3L,4401L,5L
+
+#define OBJ_camellia            OBJ_ntt_ds,3L,1L,9L
+
+#define SN_camellia_128_ecb             "CAMELLIA-128-ECB"
+#define LN_camellia_128_ecb             "camellia-128-ecb"
+#define NID_camellia_128_ecb            754
+#define OBJ_camellia_128_ecb            OBJ_camellia,1L
+
+#define SN_camellia_128_ofb128          "CAMELLIA-128-OFB"
+#define LN_camellia_128_ofb128          "camellia-128-ofb"
+#define NID_camellia_128_ofb128         766
+#define OBJ_camellia_128_ofb128         OBJ_camellia,3L
+
+#define SN_camellia_128_cfb128          "CAMELLIA-128-CFB"
+#define LN_camellia_128_cfb128          "camellia-128-cfb"
+#define NID_camellia_128_cfb128         757
+#define OBJ_camellia_128_cfb128         OBJ_camellia,4L
+
+#define SN_camellia_128_gcm             "CAMELLIA-128-GCM"
+#define LN_camellia_128_gcm             "camellia-128-gcm"
+#define NID_camellia_128_gcm            961
+#define OBJ_camellia_128_gcm            OBJ_camellia,6L
+
+#define SN_camellia_128_ccm             "CAMELLIA-128-CCM"
+#define LN_camellia_128_ccm             "camellia-128-ccm"
+#define NID_camellia_128_ccm            962
+#define OBJ_camellia_128_ccm            OBJ_camellia,7L
+
+#define SN_camellia_128_ctr             "CAMELLIA-128-CTR"
+#define LN_camellia_128_ctr             "camellia-128-ctr"
+#define NID_camellia_128_ctr            963
+#define OBJ_camellia_128_ctr            OBJ_camellia,9L
+
+#define SN_camellia_128_cmac            "CAMELLIA-128-CMAC"
+#define LN_camellia_128_cmac            "camellia-128-cmac"
+#define NID_camellia_128_cmac           964
+#define OBJ_camellia_128_cmac           OBJ_camellia,10L
+
+#define SN_camellia_192_ecb             "CAMELLIA-192-ECB"
+#define LN_camellia_192_ecb             "camellia-192-ecb"
+#define NID_camellia_192_ecb            755
+#define OBJ_camellia_192_ecb            OBJ_camellia,21L
+
+#define SN_camellia_192_ofb128          "CAMELLIA-192-OFB"
+#define LN_camellia_192_ofb128          "camellia-192-ofb"
+#define NID_camellia_192_ofb128         767
+#define OBJ_camellia_192_ofb128         OBJ_camellia,23L
+
+#define SN_camellia_192_cfb128          "CAMELLIA-192-CFB"
+#define LN_camellia_192_cfb128          "camellia-192-cfb"
+#define NID_camellia_192_cfb128         758
+#define OBJ_camellia_192_cfb128         OBJ_camellia,24L
+
+#define SN_camellia_192_gcm             "CAMELLIA-192-GCM"
+#define LN_camellia_192_gcm             "camellia-192-gcm"
+#define NID_camellia_192_gcm            965
+#define OBJ_camellia_192_gcm            OBJ_camellia,26L
+
+#define SN_camellia_192_ccm             "CAMELLIA-192-CCM"
+#define LN_camellia_192_ccm             "camellia-192-ccm"
+#define NID_camellia_192_ccm            966
+#define OBJ_camellia_192_ccm            OBJ_camellia,27L
+
+#define SN_camellia_192_ctr             "CAMELLIA-192-CTR"
+#define LN_camellia_192_ctr             "camellia-192-ctr"
+#define NID_camellia_192_ctr            967
+#define OBJ_camellia_192_ctr            OBJ_camellia,29L
+
+#define SN_camellia_192_cmac            "CAMELLIA-192-CMAC"
+#define LN_camellia_192_cmac            "camellia-192-cmac"
+#define NID_camellia_192_cmac           968
+#define OBJ_camellia_192_cmac           OBJ_camellia,30L
+
+#define SN_camellia_256_ecb             "CAMELLIA-256-ECB"
+#define LN_camellia_256_ecb             "camellia-256-ecb"
+#define NID_camellia_256_ecb            756
+#define OBJ_camellia_256_ecb            OBJ_camellia,41L
+
+#define SN_camellia_256_ofb128          "CAMELLIA-256-OFB"
+#define LN_camellia_256_ofb128          "camellia-256-ofb"
+#define NID_camellia_256_ofb128         768
+#define OBJ_camellia_256_ofb128         OBJ_camellia,43L
+
+#define SN_camellia_256_cfb128          "CAMELLIA-256-CFB"
+#define LN_camellia_256_cfb128          "camellia-256-cfb"
+#define NID_camellia_256_cfb128         759
+#define OBJ_camellia_256_cfb128         OBJ_camellia,44L
+
+#define SN_camellia_256_gcm             "CAMELLIA-256-GCM"
+#define LN_camellia_256_gcm             "camellia-256-gcm"
+#define NID_camellia_256_gcm            969
+#define OBJ_camellia_256_gcm            OBJ_camellia,46L
+
+#define SN_camellia_256_ccm             "CAMELLIA-256-CCM"
+#define LN_camellia_256_ccm             "camellia-256-ccm"
+#define NID_camellia_256_ccm            970
+#define OBJ_camellia_256_ccm            OBJ_camellia,47L
+
+#define SN_camellia_256_ctr             "CAMELLIA-256-CTR"
+#define LN_camellia_256_ctr             "camellia-256-ctr"
+#define NID_camellia_256_ctr            971
+#define OBJ_camellia_256_ctr            OBJ_camellia,49L
+
+#define SN_camellia_256_cmac            "CAMELLIA-256-CMAC"
+#define LN_camellia_256_cmac            "camellia-256-cmac"
+#define NID_camellia_256_cmac           972
+#define OBJ_camellia_256_cmac           OBJ_camellia,50L
+
+#define SN_camellia_128_cfb1            "CAMELLIA-128-CFB1"
+#define LN_camellia_128_cfb1            "camellia-128-cfb1"
+#define NID_camellia_128_cfb1           760
+
+#define SN_camellia_192_cfb1            "CAMELLIA-192-CFB1"
+#define LN_camellia_192_cfb1            "camellia-192-cfb1"
+#define NID_camellia_192_cfb1           761
+
+#define SN_camellia_256_cfb1            "CAMELLIA-256-CFB1"
+#define LN_camellia_256_cfb1            "camellia-256-cfb1"
+#define NID_camellia_256_cfb1           762
+
+#define SN_camellia_128_cfb8            "CAMELLIA-128-CFB8"
+#define LN_camellia_128_cfb8            "camellia-128-cfb8"
+#define NID_camellia_128_cfb8           763
+
+#define SN_camellia_192_cfb8            "CAMELLIA-192-CFB8"
+#define LN_camellia_192_cfb8            "camellia-192-cfb8"
+#define NID_camellia_192_cfb8           764
+
+#define SN_camellia_256_cfb8            "CAMELLIA-256-CFB8"
+#define LN_camellia_256_cfb8            "camellia-256-cfb8"
+#define NID_camellia_256_cfb8           765
+
+#define OBJ_aria                1L,2L,410L,200046L,1L,1L
+
+#define SN_aria_128_ecb         "ARIA-128-ECB"
+#define LN_aria_128_ecb         "aria-128-ecb"
+#define NID_aria_128_ecb                1065
+#define OBJ_aria_128_ecb                OBJ_aria,1L
+
+#define SN_aria_128_cbc         "ARIA-128-CBC"
+#define LN_aria_128_cbc         "aria-128-cbc"
+#define NID_aria_128_cbc                1066
+#define OBJ_aria_128_cbc                OBJ_aria,2L
+
+#define SN_aria_128_cfb128              "ARIA-128-CFB"
+#define LN_aria_128_cfb128              "aria-128-cfb"
+#define NID_aria_128_cfb128             1067
+#define OBJ_aria_128_cfb128             OBJ_aria,3L
+
+#define SN_aria_128_ofb128              "ARIA-128-OFB"
+#define LN_aria_128_ofb128              "aria-128-ofb"
+#define NID_aria_128_ofb128             1068
+#define OBJ_aria_128_ofb128             OBJ_aria,4L
+
+#define SN_aria_128_ctr         "ARIA-128-CTR"
+#define LN_aria_128_ctr         "aria-128-ctr"
+#define NID_aria_128_ctr                1069
+#define OBJ_aria_128_ctr                OBJ_aria,5L
+
+#define SN_aria_192_ecb         "ARIA-192-ECB"
+#define LN_aria_192_ecb         "aria-192-ecb"
+#define NID_aria_192_ecb                1070
+#define OBJ_aria_192_ecb                OBJ_aria,6L
+
+#define SN_aria_192_cbc         "ARIA-192-CBC"
+#define LN_aria_192_cbc         "aria-192-cbc"
+#define NID_aria_192_cbc                1071
+#define OBJ_aria_192_cbc                OBJ_aria,7L
+
+#define SN_aria_192_cfb128              "ARIA-192-CFB"
+#define LN_aria_192_cfb128              "aria-192-cfb"
+#define NID_aria_192_cfb128             1072
+#define OBJ_aria_192_cfb128             OBJ_aria,8L
+
+#define SN_aria_192_ofb128              "ARIA-192-OFB"
+#define LN_aria_192_ofb128              "aria-192-ofb"
+#define NID_aria_192_ofb128             1073
+#define OBJ_aria_192_ofb128             OBJ_aria,9L
+
+#define SN_aria_192_ctr         "ARIA-192-CTR"
+#define LN_aria_192_ctr         "aria-192-ctr"
+#define NID_aria_192_ctr                1074
+#define OBJ_aria_192_ctr                OBJ_aria,10L
+
+#define SN_aria_256_ecb         "ARIA-256-ECB"
+#define LN_aria_256_ecb         "aria-256-ecb"
+#define NID_aria_256_ecb                1075
+#define OBJ_aria_256_ecb                OBJ_aria,11L
+
+#define SN_aria_256_cbc         "ARIA-256-CBC"
+#define LN_aria_256_cbc         "aria-256-cbc"
+#define NID_aria_256_cbc                1076
+#define OBJ_aria_256_cbc                OBJ_aria,12L
+
+#define SN_aria_256_cfb128              "ARIA-256-CFB"
+#define LN_aria_256_cfb128              "aria-256-cfb"
+#define NID_aria_256_cfb128             1077
+#define OBJ_aria_256_cfb128             OBJ_aria,13L
+
+#define SN_aria_256_ofb128              "ARIA-256-OFB"
+#define LN_aria_256_ofb128              "aria-256-ofb"
+#define NID_aria_256_ofb128             1078
+#define OBJ_aria_256_ofb128             OBJ_aria,14L
+
+#define SN_aria_256_ctr         "ARIA-256-CTR"
+#define LN_aria_256_ctr         "aria-256-ctr"
+#define NID_aria_256_ctr                1079
+#define OBJ_aria_256_ctr                OBJ_aria,15L
+
+#define SN_aria_128_cfb1                "ARIA-128-CFB1"
+#define LN_aria_128_cfb1                "aria-128-cfb1"
+#define NID_aria_128_cfb1               1080
+
+#define SN_aria_192_cfb1                "ARIA-192-CFB1"
+#define LN_aria_192_cfb1                "aria-192-cfb1"
+#define NID_aria_192_cfb1               1081
+
+#define SN_aria_256_cfb1                "ARIA-256-CFB1"
+#define LN_aria_256_cfb1                "aria-256-cfb1"
+#define NID_aria_256_cfb1               1082
+
+#define SN_aria_128_cfb8                "ARIA-128-CFB8"
+#define LN_aria_128_cfb8                "aria-128-cfb8"
+#define NID_aria_128_cfb8               1083
+
+#define SN_aria_192_cfb8                "ARIA-192-CFB8"
+#define LN_aria_192_cfb8                "aria-192-cfb8"
+#define NID_aria_192_cfb8               1084
+
+#define SN_aria_256_cfb8                "ARIA-256-CFB8"
+#define LN_aria_256_cfb8                "aria-256-cfb8"
+#define NID_aria_256_cfb8               1085
+
+#define SN_aria_128_ccm         "ARIA-128-CCM"
+#define LN_aria_128_ccm         "aria-128-ccm"
+#define NID_aria_128_ccm                1120
+#define OBJ_aria_128_ccm                OBJ_aria,37L
+
+#define SN_aria_192_ccm         "ARIA-192-CCM"
+#define LN_aria_192_ccm         "aria-192-ccm"
+#define NID_aria_192_ccm                1121
+#define OBJ_aria_192_ccm                OBJ_aria,38L
+
+#define SN_aria_256_ccm         "ARIA-256-CCM"
+#define LN_aria_256_ccm         "aria-256-ccm"
+#define NID_aria_256_ccm                1122
+#define OBJ_aria_256_ccm                OBJ_aria,39L
+
+#define SN_aria_128_gcm         "ARIA-128-GCM"
+#define LN_aria_128_gcm         "aria-128-gcm"
+#define NID_aria_128_gcm                1123
+#define OBJ_aria_128_gcm                OBJ_aria,34L
+
+#define SN_aria_192_gcm         "ARIA-192-GCM"
+#define LN_aria_192_gcm         "aria-192-gcm"
+#define NID_aria_192_gcm                1124
+#define OBJ_aria_192_gcm                OBJ_aria,35L
+
+#define SN_aria_256_gcm         "ARIA-256-GCM"
+#define LN_aria_256_gcm         "aria-256-gcm"
+#define NID_aria_256_gcm                1125
+#define OBJ_aria_256_gcm                OBJ_aria,36L
+
+#define SN_kisa         "KISA"
+#define LN_kisa         "kisa"
+#define NID_kisa                773
+#define OBJ_kisa                OBJ_member_body,410L,200004L
+
+#define SN_seed_ecb             "SEED-ECB"
+#define LN_seed_ecb             "seed-ecb"
+#define NID_seed_ecb            776
+#define OBJ_seed_ecb            OBJ_kisa,1L,3L
+
+#define SN_seed_cbc             "SEED-CBC"
+#define LN_seed_cbc             "seed-cbc"
+#define NID_seed_cbc            777
+#define OBJ_seed_cbc            OBJ_kisa,1L,4L
+
+#define SN_seed_cfb128          "SEED-CFB"
+#define LN_seed_cfb128          "seed-cfb"
+#define NID_seed_cfb128         779
+#define OBJ_seed_cfb128         OBJ_kisa,1L,5L
+
+#define SN_seed_ofb128          "SEED-OFB"
+#define LN_seed_ofb128          "seed-ofb"
+#define NID_seed_ofb128         778
+#define OBJ_seed_ofb128         OBJ_kisa,1L,6L
+
+#define SN_sm4_ecb              "SM4-ECB"
+#define LN_sm4_ecb              "sm4-ecb"
+#define NID_sm4_ecb             1133
+#define OBJ_sm4_ecb             OBJ_sm_scheme,104L,1L
+
+#define SN_sm4_cbc              "SM4-CBC"
+#define LN_sm4_cbc              "sm4-cbc"
+#define NID_sm4_cbc             1134
+#define OBJ_sm4_cbc             OBJ_sm_scheme,104L,2L
+
+#define SN_sm4_ofb128           "SM4-OFB"
+#define LN_sm4_ofb128           "sm4-ofb"
+#define NID_sm4_ofb128          1135
+#define OBJ_sm4_ofb128          OBJ_sm_scheme,104L,3L
+
+#define SN_sm4_cfb128           "SM4-CFB"
+#define LN_sm4_cfb128           "sm4-cfb"
+#define NID_sm4_cfb128          1137
+#define OBJ_sm4_cfb128          OBJ_sm_scheme,104L,4L
+
+#define SN_sm4_cfb1             "SM4-CFB1"
+#define LN_sm4_cfb1             "sm4-cfb1"
+#define NID_sm4_cfb1            1136
+#define OBJ_sm4_cfb1            OBJ_sm_scheme,104L,5L
+
+#define SN_sm4_cfb8             "SM4-CFB8"
+#define LN_sm4_cfb8             "sm4-cfb8"
+#define NID_sm4_cfb8            1138
+#define OBJ_sm4_cfb8            OBJ_sm_scheme,104L,6L
+
+#define SN_sm4_ctr              "SM4-CTR"
+#define LN_sm4_ctr              "sm4-ctr"
+#define NID_sm4_ctr             1139
+#define OBJ_sm4_ctr             OBJ_sm_scheme,104L,7L
+
+#define SN_sm4_gcm              "SM4-GCM"
+#define LN_sm4_gcm              "sm4-gcm"
+#define NID_sm4_gcm             1248
+#define OBJ_sm4_gcm             OBJ_sm_scheme,104L,8L
+
+#define SN_sm4_ccm              "SM4-CCM"
+#define LN_sm4_ccm              "sm4-ccm"
+#define NID_sm4_ccm             1249
+#define OBJ_sm4_ccm             OBJ_sm_scheme,104L,9L
+
+#define SN_sm4_xts              "SM4-XTS"
+#define LN_sm4_xts              "sm4-xts"
+#define NID_sm4_xts             1290
+#define OBJ_sm4_xts             OBJ_sm_scheme,104L,10L
+
+#define SN_hmac         "HMAC"
+#define LN_hmac         "hmac"
+#define NID_hmac                855
+
+#define SN_cmac         "CMAC"
+#define LN_cmac         "cmac"
+#define NID_cmac                894
+
+#define SN_rc4_hmac_md5         "RC4-HMAC-MD5"
+#define LN_rc4_hmac_md5         "rc4-hmac-md5"
+#define NID_rc4_hmac_md5                915
+
+#define SN_aes_128_cbc_hmac_sha1                "AES-128-CBC-HMAC-SHA1"
+#define LN_aes_128_cbc_hmac_sha1                "aes-128-cbc-hmac-sha1"
+#define NID_aes_128_cbc_hmac_sha1               916
+
+#define SN_aes_192_cbc_hmac_sha1                "AES-192-CBC-HMAC-SHA1"
+#define LN_aes_192_cbc_hmac_sha1                "aes-192-cbc-hmac-sha1"
+#define NID_aes_192_cbc_hmac_sha1               917
+
+#define SN_aes_256_cbc_hmac_sha1                "AES-256-CBC-HMAC-SHA1"
+#define LN_aes_256_cbc_hmac_sha1                "aes-256-cbc-hmac-sha1"
+#define NID_aes_256_cbc_hmac_sha1               918
+
+#define SN_aes_128_cbc_hmac_sha256              "AES-128-CBC-HMAC-SHA256"
+#define LN_aes_128_cbc_hmac_sha256              "aes-128-cbc-hmac-sha256"
+#define NID_aes_128_cbc_hmac_sha256             948
+
+#define SN_aes_192_cbc_hmac_sha256              "AES-192-CBC-HMAC-SHA256"
+#define LN_aes_192_cbc_hmac_sha256              "aes-192-cbc-hmac-sha256"
+#define NID_aes_192_cbc_hmac_sha256             949
+
+#define SN_aes_256_cbc_hmac_sha256              "AES-256-CBC-HMAC-SHA256"
+#define LN_aes_256_cbc_hmac_sha256              "aes-256-cbc-hmac-sha256"
+#define NID_aes_256_cbc_hmac_sha256             950
+
+#define SN_chacha20_poly1305            "ChaCha20-Poly1305"
+#define LN_chacha20_poly1305            "chacha20-poly1305"
+#define NID_chacha20_poly1305           1018
+
+#define SN_chacha20             "ChaCha20"
+#define LN_chacha20             "chacha20"
+#define NID_chacha20            1019
+
+#define SN_dhpublicnumber               "dhpublicnumber"
+#define LN_dhpublicnumber               "X9.42 DH"
+#define NID_dhpublicnumber              920
+#define OBJ_dhpublicnumber              OBJ_ISO_US,10046L,2L,1L
+
+#define SN_brainpoolP160r1              "brainpoolP160r1"
+#define NID_brainpoolP160r1             921
+#define OBJ_brainpoolP160r1             1L,3L,36L,3L,3L,2L,8L,1L,1L,1L
+
+#define SN_brainpoolP160t1              "brainpoolP160t1"
+#define NID_brainpoolP160t1             922
+#define OBJ_brainpoolP160t1             1L,3L,36L,3L,3L,2L,8L,1L,1L,2L
+
+#define SN_brainpoolP192r1              "brainpoolP192r1"
+#define NID_brainpoolP192r1             923
+#define OBJ_brainpoolP192r1             1L,3L,36L,3L,3L,2L,8L,1L,1L,3L
+
+#define SN_brainpoolP192t1              "brainpoolP192t1"
+#define NID_brainpoolP192t1             924
+#define OBJ_brainpoolP192t1             1L,3L,36L,3L,3L,2L,8L,1L,1L,4L
+
+#define SN_brainpoolP224r1              "brainpoolP224r1"
+#define NID_brainpoolP224r1             925
+#define OBJ_brainpoolP224r1             1L,3L,36L,3L,3L,2L,8L,1L,1L,5L
+
+#define SN_brainpoolP224t1              "brainpoolP224t1"
+#define NID_brainpoolP224t1             926
+#define OBJ_brainpoolP224t1             1L,3L,36L,3L,3L,2L,8L,1L,1L,6L
+
+#define SN_brainpoolP256r1              "brainpoolP256r1"
+#define NID_brainpoolP256r1             927
+#define OBJ_brainpoolP256r1             1L,3L,36L,3L,3L,2L,8L,1L,1L,7L
+
+#define SN_brainpoolP256r1tls13         "brainpoolP256r1tls13"
+#define NID_brainpoolP256r1tls13                1285
+
+#define SN_brainpoolP256t1              "brainpoolP256t1"
+#define NID_brainpoolP256t1             928
+#define OBJ_brainpoolP256t1             1L,3L,36L,3L,3L,2L,8L,1L,1L,8L
+
+#define SN_brainpoolP320r1              "brainpoolP320r1"
+#define NID_brainpoolP320r1             929
+#define OBJ_brainpoolP320r1             1L,3L,36L,3L,3L,2L,8L,1L,1L,9L
+
+#define SN_brainpoolP320t1              "brainpoolP320t1"
+#define NID_brainpoolP320t1             930
+#define OBJ_brainpoolP320t1             1L,3L,36L,3L,3L,2L,8L,1L,1L,10L
+
+#define SN_brainpoolP384r1              "brainpoolP384r1"
+#define NID_brainpoolP384r1             931
+#define OBJ_brainpoolP384r1             1L,3L,36L,3L,3L,2L,8L,1L,1L,11L
+
+#define SN_brainpoolP384r1tls13         "brainpoolP384r1tls13"
+#define NID_brainpoolP384r1tls13                1286
+
+#define SN_brainpoolP384t1              "brainpoolP384t1"
+#define NID_brainpoolP384t1             932
+#define OBJ_brainpoolP384t1             1L,3L,36L,3L,3L,2L,8L,1L,1L,12L
+
+#define SN_brainpoolP512r1              "brainpoolP512r1"
+#define NID_brainpoolP512r1             933
+#define OBJ_brainpoolP512r1             1L,3L,36L,3L,3L,2L,8L,1L,1L,13L
+
+#define SN_brainpoolP512r1tls13         "brainpoolP512r1tls13"
+#define NID_brainpoolP512r1tls13                1287
+
+#define SN_brainpoolP512t1              "brainpoolP512t1"
+#define NID_brainpoolP512t1             934
+#define OBJ_brainpoolP512t1             1L,3L,36L,3L,3L,2L,8L,1L,1L,14L
+
+#define OBJ_x9_63_scheme                1L,3L,133L,16L,840L,63L,0L
+
+#define OBJ_secg_scheme         OBJ_certicom_arc,1L
+
+#define SN_dhSinglePass_stdDH_sha1kdf_scheme            "dhSinglePass-stdDH-sha1kdf-scheme"
+#define NID_dhSinglePass_stdDH_sha1kdf_scheme           936
+#define OBJ_dhSinglePass_stdDH_sha1kdf_scheme           OBJ_x9_63_scheme,2L
+
+#define SN_dhSinglePass_stdDH_sha224kdf_scheme          "dhSinglePass-stdDH-sha224kdf-scheme"
+#define NID_dhSinglePass_stdDH_sha224kdf_scheme         937
+#define OBJ_dhSinglePass_stdDH_sha224kdf_scheme         OBJ_secg_scheme,11L,0L
+
+#define SN_dhSinglePass_stdDH_sha256kdf_scheme          "dhSinglePass-stdDH-sha256kdf-scheme"
+#define NID_dhSinglePass_stdDH_sha256kdf_scheme         938
+#define OBJ_dhSinglePass_stdDH_sha256kdf_scheme         OBJ_secg_scheme,11L,1L
+
+#define SN_dhSinglePass_stdDH_sha384kdf_scheme          "dhSinglePass-stdDH-sha384kdf-scheme"
+#define NID_dhSinglePass_stdDH_sha384kdf_scheme         939
+#define OBJ_dhSinglePass_stdDH_sha384kdf_scheme         OBJ_secg_scheme,11L,2L
+
+#define SN_dhSinglePass_stdDH_sha512kdf_scheme          "dhSinglePass-stdDH-sha512kdf-scheme"
+#define NID_dhSinglePass_stdDH_sha512kdf_scheme         940
+#define OBJ_dhSinglePass_stdDH_sha512kdf_scheme         OBJ_secg_scheme,11L,3L
+
+#define SN_dhSinglePass_cofactorDH_sha1kdf_scheme               "dhSinglePass-cofactorDH-sha1kdf-scheme"
+#define NID_dhSinglePass_cofactorDH_sha1kdf_scheme              941
+#define OBJ_dhSinglePass_cofactorDH_sha1kdf_scheme              OBJ_x9_63_scheme,3L
+
+#define SN_dhSinglePass_cofactorDH_sha224kdf_scheme             "dhSinglePass-cofactorDH-sha224kdf-scheme"
+#define NID_dhSinglePass_cofactorDH_sha224kdf_scheme            942
+#define OBJ_dhSinglePass_cofactorDH_sha224kdf_scheme            OBJ_secg_scheme,14L,0L
+
+#define SN_dhSinglePass_cofactorDH_sha256kdf_scheme             "dhSinglePass-cofactorDH-sha256kdf-scheme"
+#define NID_dhSinglePass_cofactorDH_sha256kdf_scheme            943
+#define OBJ_dhSinglePass_cofactorDH_sha256kdf_scheme            OBJ_secg_scheme,14L,1L
+
+#define SN_dhSinglePass_cofactorDH_sha384kdf_scheme             "dhSinglePass-cofactorDH-sha384kdf-scheme"
+#define NID_dhSinglePass_cofactorDH_sha384kdf_scheme            944
+#define OBJ_dhSinglePass_cofactorDH_sha384kdf_scheme            OBJ_secg_scheme,14L,2L
+
+#define SN_dhSinglePass_cofactorDH_sha512kdf_scheme             "dhSinglePass-cofactorDH-sha512kdf-scheme"
+#define NID_dhSinglePass_cofactorDH_sha512kdf_scheme            945
+#define OBJ_dhSinglePass_cofactorDH_sha512kdf_scheme            OBJ_secg_scheme,14L,3L
+
+#define SN_dh_std_kdf           "dh-std-kdf"
+#define NID_dh_std_kdf          946
+
+#define SN_dh_cofactor_kdf              "dh-cofactor-kdf"
+#define NID_dh_cofactor_kdf             947
+
+#define SN_ct_precert_scts              "ct_precert_scts"
+#define LN_ct_precert_scts              "CT Precertificate SCTs"
+#define NID_ct_precert_scts             951
+#define OBJ_ct_precert_scts             1L,3L,6L,1L,4L,1L,11129L,2L,4L,2L
+
+#define SN_ct_precert_poison            "ct_precert_poison"
+#define LN_ct_precert_poison            "CT Precertificate Poison"
+#define NID_ct_precert_poison           952
+#define OBJ_ct_precert_poison           1L,3L,6L,1L,4L,1L,11129L,2L,4L,3L
+
+#define SN_ct_precert_signer            "ct_precert_signer"
+#define LN_ct_precert_signer            "CT Precertificate Signer"
+#define NID_ct_precert_signer           953
+#define OBJ_ct_precert_signer           1L,3L,6L,1L,4L,1L,11129L,2L,4L,4L
+
+#define SN_ct_cert_scts         "ct_cert_scts"
+#define LN_ct_cert_scts         "CT Certificate SCTs"
+#define NID_ct_cert_scts                954
+#define OBJ_ct_cert_scts                1L,3L,6L,1L,4L,1L,11129L,2L,4L,5L
+
+#define SN_jurisdictionLocalityName             "jurisdictionL"
+#define LN_jurisdictionLocalityName             "jurisdictionLocalityName"
+#define NID_jurisdictionLocalityName            955
+#define OBJ_jurisdictionLocalityName            OBJ_ms_corp,60L,2L,1L,1L
+
+#define SN_jurisdictionStateOrProvinceName              "jurisdictionST"
+#define LN_jurisdictionStateOrProvinceName              "jurisdictionStateOrProvinceName"
+#define NID_jurisdictionStateOrProvinceName             956
+#define OBJ_jurisdictionStateOrProvinceName             OBJ_ms_corp,60L,2L,1L,2L
+
+#define SN_jurisdictionCountryName              "jurisdictionC"
+#define LN_jurisdictionCountryName              "jurisdictionCountryName"
+#define NID_jurisdictionCountryName             957
+#define OBJ_jurisdictionCountryName             OBJ_ms_corp,60L,2L,1L,3L
+
+#define SN_id_scrypt            "id-scrypt"
+#define LN_id_scrypt            "scrypt"
+#define NID_id_scrypt           973
+#define OBJ_id_scrypt           1L,3L,6L,1L,4L,1L,11591L,4L,11L
+
+#define SN_tls1_prf             "TLS1-PRF"
+#define LN_tls1_prf             "tls1-prf"
+#define NID_tls1_prf            1021
+
+#define SN_hkdf         "HKDF"
+#define LN_hkdf         "hkdf"
+#define NID_hkdf                1036
+
+#define SN_sshkdf               "SSHKDF"
+#define LN_sshkdf               "sshkdf"
+#define NID_sshkdf              1203
+
+#define SN_sskdf                "SSKDF"
+#define LN_sskdf                "sskdf"
+#define NID_sskdf               1205
+
+#define SN_x942kdf              "X942KDF"
+#define LN_x942kdf              "x942kdf"
+#define NID_x942kdf             1207
+
+#define SN_x963kdf              "X963KDF"
+#define LN_x963kdf              "x963kdf"
+#define NID_x963kdf             1206
+
+#define SN_id_pkinit            "id-pkinit"
+#define NID_id_pkinit           1031
+#define OBJ_id_pkinit           1L,3L,6L,1L,5L,2L,3L
+
+#define SN_pkInitClientAuth             "pkInitClientAuth"
+#define LN_pkInitClientAuth             "PKINIT Client Auth"
+#define NID_pkInitClientAuth            1032
+#define OBJ_pkInitClientAuth            OBJ_id_pkinit,4L
+
+#define SN_pkInitKDC            "pkInitKDC"
+#define LN_pkInitKDC            "Signing KDC Response"
+#define NID_pkInitKDC           1033
+#define OBJ_pkInitKDC           OBJ_id_pkinit,5L
+
+#define SN_X25519               "X25519"
+#define NID_X25519              1034
+#define OBJ_X25519              1L,3L,101L,110L
+
+#define SN_X448         "X448"
+#define NID_X448                1035
+#define OBJ_X448                1L,3L,101L,111L
+
+#define SN_ED25519              "ED25519"
+#define NID_ED25519             1087
+#define OBJ_ED25519             1L,3L,101L,112L
+
+#define SN_ED448                "ED448"
+#define NID_ED448               1088
+#define OBJ_ED448               1L,3L,101L,113L
+
+#define SN_kx_rsa               "KxRSA"
+#define LN_kx_rsa               "kx-rsa"
+#define NID_kx_rsa              1037
+
+#define SN_kx_ecdhe             "KxECDHE"
+#define LN_kx_ecdhe             "kx-ecdhe"
+#define NID_kx_ecdhe            1038
+
+#define SN_kx_dhe               "KxDHE"
+#define LN_kx_dhe               "kx-dhe"
+#define NID_kx_dhe              1039
+
+#define SN_kx_ecdhe_psk         "KxECDHE-PSK"
+#define LN_kx_ecdhe_psk         "kx-ecdhe-psk"
+#define NID_kx_ecdhe_psk                1040
+
+#define SN_kx_dhe_psk           "KxDHE-PSK"
+#define LN_kx_dhe_psk           "kx-dhe-psk"
+#define NID_kx_dhe_psk          1041
+
+#define SN_kx_rsa_psk           "KxRSA_PSK"
+#define LN_kx_rsa_psk           "kx-rsa-psk"
+#define NID_kx_rsa_psk          1042
+
+#define SN_kx_psk               "KxPSK"
+#define LN_kx_psk               "kx-psk"
+#define NID_kx_psk              1043
+
+#define SN_kx_srp               "KxSRP"
+#define LN_kx_srp               "kx-srp"
+#define NID_kx_srp              1044
+
+#define SN_kx_gost              "KxGOST"
+#define LN_kx_gost              "kx-gost"
+#define NID_kx_gost             1045
+
+#define SN_kx_gost18            "KxGOST18"
+#define LN_kx_gost18            "kx-gost18"
+#define NID_kx_gost18           1218
+
+#define SN_kx_any               "KxANY"
+#define LN_kx_any               "kx-any"
+#define NID_kx_any              1063
+
+#define SN_auth_rsa             "AuthRSA"
+#define LN_auth_rsa             "auth-rsa"
+#define NID_auth_rsa            1046
+
+#define SN_auth_ecdsa           "AuthECDSA"
+#define LN_auth_ecdsa           "auth-ecdsa"
+#define NID_auth_ecdsa          1047
+
+#define SN_auth_psk             "AuthPSK"
+#define LN_auth_psk             "auth-psk"
+#define NID_auth_psk            1048
+
+#define SN_auth_dss             "AuthDSS"
+#define LN_auth_dss             "auth-dss"
+#define NID_auth_dss            1049
+
+#define SN_auth_gost01          "AuthGOST01"
+#define LN_auth_gost01          "auth-gost01"
+#define NID_auth_gost01         1050
+
+#define SN_auth_gost12          "AuthGOST12"
+#define LN_auth_gost12          "auth-gost12"
+#define NID_auth_gost12         1051
+
+#define SN_auth_srp             "AuthSRP"
+#define LN_auth_srp             "auth-srp"
+#define NID_auth_srp            1052
+
+#define SN_auth_null            "AuthNULL"
+#define LN_auth_null            "auth-null"
+#define NID_auth_null           1053
+
+#define SN_auth_any             "AuthANY"
+#define LN_auth_any             "auth-any"
+#define NID_auth_any            1064
+
+#define SN_poly1305             "Poly1305"
+#define LN_poly1305             "poly1305"
+#define NID_poly1305            1061
+
+#define SN_siphash              "SipHash"
+#define LN_siphash              "siphash"
+#define NID_siphash             1062
+
+#define SN_ffdhe2048            "ffdhe2048"
+#define NID_ffdhe2048           1126
+
+#define SN_ffdhe3072            "ffdhe3072"
+#define NID_ffdhe3072           1127
+
+#define SN_ffdhe4096            "ffdhe4096"
+#define NID_ffdhe4096           1128
+
+#define SN_ffdhe6144            "ffdhe6144"
+#define NID_ffdhe6144           1129
+
+#define SN_ffdhe8192            "ffdhe8192"
+#define NID_ffdhe8192           1130
+
+#define SN_modp_1536            "modp_1536"
+#define NID_modp_1536           1212
+
+#define SN_modp_2048            "modp_2048"
+#define NID_modp_2048           1213
+
+#define SN_modp_3072            "modp_3072"
+#define NID_modp_3072           1214
+
+#define SN_modp_4096            "modp_4096"
+#define NID_modp_4096           1215
+
+#define SN_modp_6144            "modp_6144"
+#define NID_modp_6144           1216
+
+#define SN_modp_8192            "modp_8192"
+#define NID_modp_8192           1217
+
+#define SN_ISO_UA               "ISO-UA"
+#define NID_ISO_UA              1150
+#define OBJ_ISO_UA              OBJ_member_body,804L
+
+#define SN_ua_pki               "ua-pki"
+#define NID_ua_pki              1151
+#define OBJ_ua_pki              OBJ_ISO_UA,2L,1L,1L,1L
+
+#define SN_dstu28147            "dstu28147"
+#define LN_dstu28147            "DSTU Gost 28147-2009"
+#define NID_dstu28147           1152
+#define OBJ_dstu28147           OBJ_ua_pki,1L,1L,1L
+
+#define SN_dstu28147_ofb                "dstu28147-ofb"
+#define LN_dstu28147_ofb                "DSTU Gost 28147-2009 OFB mode"
+#define NID_dstu28147_ofb               1153
+#define OBJ_dstu28147_ofb               OBJ_dstu28147,2L
+
+#define SN_dstu28147_cfb                "dstu28147-cfb"
+#define LN_dstu28147_cfb                "DSTU Gost 28147-2009 CFB mode"
+#define NID_dstu28147_cfb               1154
+#define OBJ_dstu28147_cfb               OBJ_dstu28147,3L
+
+#define SN_dstu28147_wrap               "dstu28147-wrap"
+#define LN_dstu28147_wrap               "DSTU Gost 28147-2009 key wrap"
+#define NID_dstu28147_wrap              1155
+#define OBJ_dstu28147_wrap              OBJ_dstu28147,5L
+
+#define SN_hmacWithDstu34311            "hmacWithDstu34311"
+#define LN_hmacWithDstu34311            "HMAC DSTU Gost 34311-95"
+#define NID_hmacWithDstu34311           1156
+#define OBJ_hmacWithDstu34311           OBJ_ua_pki,1L,1L,2L
+
+#define SN_dstu34311            "dstu34311"
+#define LN_dstu34311            "DSTU Gost 34311-95"
+#define NID_dstu34311           1157
+#define OBJ_dstu34311           OBJ_ua_pki,1L,2L,1L
+
+#define SN_dstu4145le           "dstu4145le"
+#define LN_dstu4145le           "DSTU 4145-2002 little endian"
+#define NID_dstu4145le          1158
+#define OBJ_dstu4145le          OBJ_ua_pki,1L,3L,1L,1L
+
+#define SN_dstu4145be           "dstu4145be"
+#define LN_dstu4145be           "DSTU 4145-2002 big endian"
+#define NID_dstu4145be          1159
+#define OBJ_dstu4145be          OBJ_dstu4145le,1L,1L
+
+#define SN_uacurve0             "uacurve0"
+#define LN_uacurve0             "DSTU curve 0"
+#define NID_uacurve0            1160
+#define OBJ_uacurve0            OBJ_dstu4145le,2L,0L
+
+#define SN_uacurve1             "uacurve1"
+#define LN_uacurve1             "DSTU curve 1"
+#define NID_uacurve1            1161
+#define OBJ_uacurve1            OBJ_dstu4145le,2L,1L
+
+#define SN_uacurve2             "uacurve2"
+#define LN_uacurve2             "DSTU curve 2"
+#define NID_uacurve2            1162
+#define OBJ_uacurve2            OBJ_dstu4145le,2L,2L
+
+#define SN_uacurve3             "uacurve3"
+#define LN_uacurve3             "DSTU curve 3"
+#define NID_uacurve3            1163
+#define OBJ_uacurve3            OBJ_dstu4145le,2L,3L
+
+#define SN_uacurve4             "uacurve4"
+#define LN_uacurve4             "DSTU curve 4"
+#define NID_uacurve4            1164
+#define OBJ_uacurve4            OBJ_dstu4145le,2L,4L
+
+#define SN_uacurve5             "uacurve5"
+#define LN_uacurve5             "DSTU curve 5"
+#define NID_uacurve5            1165
+#define OBJ_uacurve5            OBJ_dstu4145le,2L,5L
+
+#define SN_uacurve6             "uacurve6"
+#define LN_uacurve6             "DSTU curve 6"
+#define NID_uacurve6            1166
+#define OBJ_uacurve6            OBJ_dstu4145le,2L,6L
+
+#define SN_uacurve7             "uacurve7"
+#define LN_uacurve7             "DSTU curve 7"
+#define NID_uacurve7            1167
+#define OBJ_uacurve7            OBJ_dstu4145le,2L,7L
+
+#define SN_uacurve8             "uacurve8"
+#define LN_uacurve8             "DSTU curve 8"
+#define NID_uacurve8            1168
+#define OBJ_uacurve8            OBJ_dstu4145le,2L,8L
+
+#define SN_uacurve9             "uacurve9"
+#define LN_uacurve9             "DSTU curve 9"
+#define NID_uacurve9            1169
+#define OBJ_uacurve9            OBJ_dstu4145le,2L,9L
+
+#define SN_aes_128_siv          "AES-128-SIV"
+#define LN_aes_128_siv          "aes-128-siv"
+#define NID_aes_128_siv         1198
+
+#define SN_aes_192_siv          "AES-192-SIV"
+#define LN_aes_192_siv          "aes-192-siv"
+#define NID_aes_192_siv         1199
+
+#define SN_aes_256_siv          "AES-256-SIV"
+#define LN_aes_256_siv          "aes-256-siv"
+#define NID_aes_256_siv         1200
+
+#define SN_oracle               "oracle-organization"
+#define LN_oracle               "Oracle organization"
+#define NID_oracle              1282
+#define OBJ_oracle              OBJ_joint_iso_itu_t,16L,840L,1L,113894L
+
+#define SN_oracle_jdk_trustedkeyusage           "oracle-jdk-trustedkeyusage"
+#define LN_oracle_jdk_trustedkeyusage           "Trusted key usage (Oracle)"
+#define NID_oracle_jdk_trustedkeyusage          1283
+#define OBJ_oracle_jdk_trustedkeyusage          OBJ_oracle,746875L,1L,1L
+
+#define SN_brotli               "brotli"
+#define LN_brotli               "Brotli compression"
+#define NID_brotli              1288
+
+#define SN_zstd         "zstd"
+#define LN_zstd         "Zstandard compression"
+#define NID_zstd                1289
+
+#endif /* OPENSSL_OBJ_MAC_H */
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+
+#define SN_id_tc26_cipher_gostr3412_2015_magma_ctracpkm                 SN_magma_ctr_acpkm
+#define NID_id_tc26_cipher_gostr3412_2015_magma_ctracpkm                NID_magma_ctr_acpkm
+#define OBJ_id_tc26_cipher_gostr3412_2015_magma_ctracpkm                OBJ_magma_ctr_acpkm
+
+#define SN_id_tc26_cipher_gostr3412_2015_magma_ctracpkm_omac            SN_magma_ctr_acpkm_omac
+#define NID_id_tc26_cipher_gostr3412_2015_magma_ctracpkm_omac           NID_magma_ctr_acpkm_omac
+#define OBJ_id_tc26_cipher_gostr3412_2015_magma_ctracpkm_omac           OBJ_magma_ctr_acpkm_omac
+
+#define SN_id_tc26_cipher_gostr3412_2015_kuznyechik_ctracpkm            SN_kuznyechik_ctr_acpkm
+#define NID_id_tc26_cipher_gostr3412_2015_kuznyechik_ctracpkm           NID_kuznyechik_ctr_acpkm
+#define OBJ_id_tc26_cipher_gostr3412_2015_kuznyechik_ctracpkm           OBJ_kuznyechik_ctr_acpkm
+
+#define SN_id_tc26_cipher_gostr3412_2015_kuznyechik_ctracpkm_omac               SN_kuznyechik_ctr_acpkm_omac
+#define NID_id_tc26_cipher_gostr3412_2015_kuznyechik_ctracpkm_omac              NID_kuznyechik_ctr_acpkm_omac
+#define OBJ_id_tc26_cipher_gostr3412_2015_kuznyechik_ctracpkm_omac              OBJ_kuznyechik_ctr_acpkm_omac
+
+#define SN_id_tc26_wrap_gostr3412_2015_magma_kexp15             SN_magma_kexp15
+#define NID_id_tc26_wrap_gostr3412_2015_magma_kexp15            NID_magma_kexp15
+#define OBJ_id_tc26_wrap_gostr3412_2015_magma_kexp15            OBJ_magma_kexp15
+
+#define SN_id_tc26_wrap_gostr3412_2015_kuznyechik_kexp15                SN_kuznyechik_kexp15
+#define NID_id_tc26_wrap_gostr3412_2015_kuznyechik_kexp15               NID_kuznyechik_kexp15
+#define OBJ_id_tc26_wrap_gostr3412_2015_kuznyechik_kexp15               OBJ_kuznyechik_kexp15
+
+#define SN_grasshopper_ecb              SN_kuznyechik_ecb
+#define NID_grasshopper_ecb             NID_kuznyechik_ecb
+
+#define SN_grasshopper_ctr              SN_kuznyechik_ctr
+#define NID_grasshopper_ctr             NID_kuznyechik_ctr
+
+#define SN_grasshopper_ofb              SN_kuznyechik_ofb
+#define NID_grasshopper_ofb             NID_kuznyechik_ofb
+
+#define SN_grasshopper_cbc              SN_kuznyechik_cbc
+#define NID_grasshopper_cbc             NID_kuznyechik_cbc
+
+#define SN_grasshopper_cfb              SN_kuznyechik_cfb
+#define NID_grasshopper_cfb             NID_kuznyechik_cfb
+
+#define SN_grasshopper_mac              SN_kuznyechik_mac
+#define NID_grasshopper_mac             NID_kuznyechik_mac
+
+#endif  /* OPENSSL_NO_DEPRECATED_3_0 */
diff --git a/src/include/openssl/objects.h b/src/include/openssl/objects.h
new file mode 100644
index 0000000..9ea91c2
--- /dev/null
+++ b/src/include/openssl/objects.h
@@ -0,0 +1,183 @@
+/*
+ * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_OBJECTS_H
+# define OPENSSL_OBJECTS_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_OBJECTS_H
+# endif
+
+# include <openssl/obj_mac.h>
+# include <openssl/bio.h>
+# include <openssl/asn1.h>
+# include <openssl/objectserr.h>
+
+# define OBJ_NAME_TYPE_UNDEF             0x00
+# define OBJ_NAME_TYPE_MD_METH           0x01
+# define OBJ_NAME_TYPE_CIPHER_METH       0x02
+# define OBJ_NAME_TYPE_PKEY_METH         0x03
+# define OBJ_NAME_TYPE_COMP_METH         0x04
+# define OBJ_NAME_TYPE_MAC_METH          0x05
+# define OBJ_NAME_TYPE_KDF_METH          0x06
+# define OBJ_NAME_TYPE_NUM               0x07
+
+# define OBJ_NAME_ALIAS                  0x8000
+
+# define OBJ_BSEARCH_VALUE_ON_NOMATCH            0x01
+# define OBJ_BSEARCH_FIRST_VALUE_ON_MATCH        0x02
+
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+typedef struct obj_name_st {
+    int type;
+    int alias;
+    const char *name;
+    const char *data;
+} OBJ_NAME;
+
+# define         OBJ_create_and_add_object(a,b,c) OBJ_create(a,b,c)
+
+int OBJ_NAME_init(void);
+int OBJ_NAME_new_index(unsigned long (*hash_func) (const char *),
+                       int (*cmp_func) (const char *, const char *),
+                       void (*free_func) (const char *, int, const char *));
+const char *OBJ_NAME_get(const char *name, int type);
+int OBJ_NAME_add(const char *name, int type, const char *data);
+int OBJ_NAME_remove(const char *name, int type);
+void OBJ_NAME_cleanup(int type); /* -1 for everything */
+void OBJ_NAME_do_all(int type, void (*fn) (const OBJ_NAME *, void *arg),
+                     void *arg);
+void OBJ_NAME_do_all_sorted(int type,
+                            void (*fn) (const OBJ_NAME *, void *arg),
+                            void *arg);
+
+DECLARE_ASN1_DUP_FUNCTION_name(ASN1_OBJECT, OBJ)
+ASN1_OBJECT *OBJ_nid2obj(int n);
+const char *OBJ_nid2ln(int n);
+const char *OBJ_nid2sn(int n);
+int OBJ_obj2nid(const ASN1_OBJECT *o);
+ASN1_OBJECT *OBJ_txt2obj(const char *s, int no_name);
+int OBJ_obj2txt(char *buf, int buf_len, const ASN1_OBJECT *a, int no_name);
+int OBJ_txt2nid(const char *s);
+int OBJ_ln2nid(const char *s);
+int OBJ_sn2nid(const char *s);
+int OBJ_cmp(const ASN1_OBJECT *a, const ASN1_OBJECT *b);
+const void *OBJ_bsearch_(const void *key, const void *base, int num, int size,
+                         int (*cmp) (const void *, const void *));
+const void *OBJ_bsearch_ex_(const void *key, const void *base, int num,
+                            int size,
+                            int (*cmp) (const void *, const void *),
+                            int flags);
+
+# define _DECLARE_OBJ_BSEARCH_CMP_FN(scope, type1, type2, nm)    \
+  static int nm##_cmp_BSEARCH_CMP_FN(const void *, const void *); \
+  static int nm##_cmp(type1 const *, type2 const *); \
+  scope type2 * OBJ_bsearch_##nm(type1 *key, type2 const *base, int num)
+
+# define DECLARE_OBJ_BSEARCH_CMP_FN(type1, type2, cmp)   \
+  _DECLARE_OBJ_BSEARCH_CMP_FN(static, type1, type2, cmp)
+# define DECLARE_OBJ_BSEARCH_GLOBAL_CMP_FN(type1, type2, nm)     \
+  type2 * OBJ_bsearch_##nm(type1 *key, type2 const *base, int num)
+
+/*-
+ * Unsolved problem: if a type is actually a pointer type, like
+ * nid_triple is, then its impossible to get a const where you need
+ * it. Consider:
+ *
+ * typedef int nid_triple[3];
+ * const void *a_;
+ * const nid_triple const *a = a_;
+ *
+ * The assignment discards a const because what you really want is:
+ *
+ * const int const * const *a = a_;
+ *
+ * But if you do that, you lose the fact that a is an array of 3 ints,
+ * which breaks comparison functions.
+ *
+ * Thus we end up having to cast, sadly, or unpack the
+ * declarations. Or, as I finally did in this case, declare nid_triple
+ * to be a struct, which it should have been in the first place.
+ *
+ * Ben, August 2008.
+ *
+ * Also, strictly speaking not all types need be const, but handling
+ * the non-constness means a lot of complication, and in practice
+ * comparison routines do always not touch their arguments.
+ */
+
+# define IMPLEMENT_OBJ_BSEARCH_CMP_FN(type1, type2, nm)  \
+  static int nm##_cmp_BSEARCH_CMP_FN(const void *a_, const void *b_)    \
+      { \
+      type1 const *a = a_; \
+      type2 const *b = b_; \
+      return nm##_cmp(a,b); \
+      } \
+  static type2 *OBJ_bsearch_##nm(type1 *key, type2 const *base, int num) \
+      { \
+      return (type2 *)OBJ_bsearch_(key, base, num, sizeof(type2), \
+                                        nm##_cmp_BSEARCH_CMP_FN); \
+      } \
+      extern void dummy_prototype(void)
+
+# define IMPLEMENT_OBJ_BSEARCH_GLOBAL_CMP_FN(type1, type2, nm)   \
+  static int nm##_cmp_BSEARCH_CMP_FN(const void *a_, const void *b_)    \
+      { \
+      type1 const *a = a_; \
+      type2 const *b = b_; \
+      return nm##_cmp(a,b); \
+      } \
+  type2 *OBJ_bsearch_##nm(type1 *key, type2 const *base, int num) \
+      { \
+      return (type2 *)OBJ_bsearch_(key, base, num, sizeof(type2), \
+                                        nm##_cmp_BSEARCH_CMP_FN); \
+      } \
+      extern void dummy_prototype(void)
+
+# define OBJ_bsearch(type1,key,type2,base,num,cmp)                              \
+  ((type2 *)OBJ_bsearch_(CHECKED_PTR_OF(type1,key),CHECKED_PTR_OF(type2,base), \
+                         num,sizeof(type2),                             \
+                         ((void)CHECKED_PTR_OF(type1,cmp##_type_1),     \
+                          (void)CHECKED_PTR_OF(type2,cmp##_type_2),     \
+                          cmp##_BSEARCH_CMP_FN)))
+
+# define OBJ_bsearch_ex(type1,key,type2,base,num,cmp,flags)                      \
+  ((type2 *)OBJ_bsearch_ex_(CHECKED_PTR_OF(type1,key),CHECKED_PTR_OF(type2,base), \
+                         num,sizeof(type2),                             \
+                         ((void)CHECKED_PTR_OF(type1,cmp##_type_1),     \
+                          (void)type_2=CHECKED_PTR_OF(type2,cmp##_type_2), \
+                          cmp##_BSEARCH_CMP_FN)),flags)
+
+int OBJ_new_nid(int num);
+int OBJ_add_object(const ASN1_OBJECT *obj);
+int OBJ_create(const char *oid, const char *sn, const char *ln);
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+# define OBJ_cleanup() while(0) continue
+#endif
+int OBJ_create_objects(BIO *in);
+
+size_t OBJ_length(const ASN1_OBJECT *obj);
+const unsigned char *OBJ_get0_data(const ASN1_OBJECT *obj);
+
+int OBJ_find_sigid_algs(int signid, int *pdig_nid, int *ppkey_nid);
+int OBJ_find_sigid_by_algs(int *psignid, int dig_nid, int pkey_nid);
+int OBJ_add_sigid(int signid, int dig_id, int pkey_id);
+void OBJ_sigid_free(void);
+
+
+# ifdef  __cplusplus
+}
+# endif
+#endif
diff --git a/src/include/openssl/objectserr.h b/src/include/openssl/objectserr.h
new file mode 100644
index 0000000..585217f
--- /dev/null
+++ b/src/include/openssl/objectserr.h
@@ -0,0 +1,28 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_OBJECTSERR_H
+# define OPENSSL_OBJECTSERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+
+/*
+ * OBJ reason codes.
+ */
+# define OBJ_R_OID_EXISTS                                 102
+# define OBJ_R_UNKNOWN_NID                                101
+# define OBJ_R_UNKNOWN_OBJECT_NAME                        103
+
+#endif
diff --git a/src/include/openssl/ocsp.h b/src/include/openssl/ocsp.h
new file mode 100644
index 0000000..5688381
--- /dev/null
+++ b/src/include/openssl/ocsp.h
@@ -0,0 +1,483 @@
+/*
+ * WARNING: do not edit!
+ * Generated by makefile from include\openssl\ocsp.h.in
+ *
+ * Copyright 2000-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+
+
+#ifndef OPENSSL_OCSP_H
+# define OPENSSL_OCSP_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_OCSP_H
+# endif
+
+# include <openssl/opensslconf.h>
+# include <openssl/http.h>
+# include <openssl/asn1.h>
+
+/*
+ * These definitions are outside the OPENSSL_NO_OCSP guard because although for
+ * historical reasons they have OCSP_* names, they can actually be used
+ * independently of OCSP. E.g. see RFC5280
+ */
+/*-
+ *   CRLReason ::= ENUMERATED {
+ *        unspecified             (0),
+ *        keyCompromise           (1),
+ *        cACompromise            (2),
+ *        affiliationChanged      (3),
+ *        superseded              (4),
+ *        cessationOfOperation    (5),
+ *        certificateHold         (6),
+ *        -- value 7 is not used
+ *        removeFromCRL           (8),
+ *        privilegeWithdrawn      (9),
+ *        aACompromise           (10) }
+ */
+# define OCSP_REVOKED_STATUS_NOSTATUS                -1
+# define OCSP_REVOKED_STATUS_UNSPECIFIED             0
+# define OCSP_REVOKED_STATUS_KEYCOMPROMISE           1
+# define OCSP_REVOKED_STATUS_CACOMPROMISE            2
+# define OCSP_REVOKED_STATUS_AFFILIATIONCHANGED      3
+# define OCSP_REVOKED_STATUS_SUPERSEDED              4
+# define OCSP_REVOKED_STATUS_CESSATIONOFOPERATION    5
+# define OCSP_REVOKED_STATUS_CERTIFICATEHOLD         6
+# define OCSP_REVOKED_STATUS_REMOVEFROMCRL           8
+# define OCSP_REVOKED_STATUS_PRIVILEGEWITHDRAWN      9
+# define OCSP_REVOKED_STATUS_AACOMPROMISE            10
+
+
+# ifndef OPENSSL_NO_OCSP
+
+#  include <openssl/x509.h>
+#  include <openssl/x509v3.h>
+#  include <openssl/safestack.h>
+#  include <openssl/ocsperr.h>
+
+#  ifdef __cplusplus
+extern "C" {
+#  endif
+
+/* Various flags and values */
+
+#  define OCSP_DEFAULT_NONCE_LENGTH       16
+
+#  define OCSP_NOCERTS                    0x1
+#  define OCSP_NOINTERN                   0x2
+#  define OCSP_NOSIGS                     0x4
+#  define OCSP_NOCHAIN                    0x8
+#  define OCSP_NOVERIFY                   0x10
+#  define OCSP_NOEXPLICIT                 0x20
+#  define OCSP_NOCASIGN                   0x40
+#  define OCSP_NODELEGATED                0x80
+#  define OCSP_NOCHECKS                   0x100
+#  define OCSP_TRUSTOTHER                 0x200
+#  define OCSP_RESPID_KEY                 0x400
+#  define OCSP_NOTIME                     0x800
+#  define OCSP_PARTIAL_CHAIN              0x1000
+
+typedef struct ocsp_cert_id_st OCSP_CERTID;
+typedef struct ocsp_one_request_st OCSP_ONEREQ;
+typedef struct ocsp_req_info_st OCSP_REQINFO;
+typedef struct ocsp_signature_st OCSP_SIGNATURE;
+typedef struct ocsp_request_st OCSP_REQUEST;
+
+SKM_DEFINE_STACK_OF_INTERNAL(OCSP_CERTID, OCSP_CERTID, OCSP_CERTID)
+#define sk_OCSP_CERTID_num(sk) OPENSSL_sk_num(ossl_check_const_OCSP_CERTID_sk_type(sk))
+#define sk_OCSP_CERTID_value(sk, idx) ((OCSP_CERTID *)OPENSSL_sk_value(ossl_check_const_OCSP_CERTID_sk_type(sk), (idx)))
+#define sk_OCSP_CERTID_new(cmp) ((STACK_OF(OCSP_CERTID) *)OPENSSL_sk_new(ossl_check_OCSP_CERTID_compfunc_type(cmp)))
+#define sk_OCSP_CERTID_new_null() ((STACK_OF(OCSP_CERTID) *)OPENSSL_sk_new_null())
+#define sk_OCSP_CERTID_new_reserve(cmp, n) ((STACK_OF(OCSP_CERTID) *)OPENSSL_sk_new_reserve(ossl_check_OCSP_CERTID_compfunc_type(cmp), (n)))
+#define sk_OCSP_CERTID_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OCSP_CERTID_sk_type(sk), (n))
+#define sk_OCSP_CERTID_free(sk) OPENSSL_sk_free(ossl_check_OCSP_CERTID_sk_type(sk))
+#define sk_OCSP_CERTID_zero(sk) OPENSSL_sk_zero(ossl_check_OCSP_CERTID_sk_type(sk))
+#define sk_OCSP_CERTID_delete(sk, i) ((OCSP_CERTID *)OPENSSL_sk_delete(ossl_check_OCSP_CERTID_sk_type(sk), (i)))
+#define sk_OCSP_CERTID_delete_ptr(sk, ptr) ((OCSP_CERTID *)OPENSSL_sk_delete_ptr(ossl_check_OCSP_CERTID_sk_type(sk), ossl_check_OCSP_CERTID_type(ptr)))
+#define sk_OCSP_CERTID_push(sk, ptr) OPENSSL_sk_push(ossl_check_OCSP_CERTID_sk_type(sk), ossl_check_OCSP_CERTID_type(ptr))
+#define sk_OCSP_CERTID_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_OCSP_CERTID_sk_type(sk), ossl_check_OCSP_CERTID_type(ptr))
+#define sk_OCSP_CERTID_pop(sk) ((OCSP_CERTID *)OPENSSL_sk_pop(ossl_check_OCSP_CERTID_sk_type(sk)))
+#define sk_OCSP_CERTID_shift(sk) ((OCSP_CERTID *)OPENSSL_sk_shift(ossl_check_OCSP_CERTID_sk_type(sk)))
+#define sk_OCSP_CERTID_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OCSP_CERTID_sk_type(sk),ossl_check_OCSP_CERTID_freefunc_type(freefunc))
+#define sk_OCSP_CERTID_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_OCSP_CERTID_sk_type(sk), ossl_check_OCSP_CERTID_type(ptr), (idx))
+#define sk_OCSP_CERTID_set(sk, idx, ptr) ((OCSP_CERTID *)OPENSSL_sk_set(ossl_check_OCSP_CERTID_sk_type(sk), (idx), ossl_check_OCSP_CERTID_type(ptr)))
+#define sk_OCSP_CERTID_find(sk, ptr) OPENSSL_sk_find(ossl_check_OCSP_CERTID_sk_type(sk), ossl_check_OCSP_CERTID_type(ptr))
+#define sk_OCSP_CERTID_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_OCSP_CERTID_sk_type(sk), ossl_check_OCSP_CERTID_type(ptr))
+#define sk_OCSP_CERTID_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OCSP_CERTID_sk_type(sk), ossl_check_OCSP_CERTID_type(ptr), pnum)
+#define sk_OCSP_CERTID_sort(sk) OPENSSL_sk_sort(ossl_check_OCSP_CERTID_sk_type(sk))
+#define sk_OCSP_CERTID_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OCSP_CERTID_sk_type(sk))
+#define sk_OCSP_CERTID_dup(sk) ((STACK_OF(OCSP_CERTID) *)OPENSSL_sk_dup(ossl_check_const_OCSP_CERTID_sk_type(sk)))
+#define sk_OCSP_CERTID_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OCSP_CERTID) *)OPENSSL_sk_deep_copy(ossl_check_const_OCSP_CERTID_sk_type(sk), ossl_check_OCSP_CERTID_copyfunc_type(copyfunc), ossl_check_OCSP_CERTID_freefunc_type(freefunc)))
+#define sk_OCSP_CERTID_set_cmp_func(sk, cmp) ((sk_OCSP_CERTID_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OCSP_CERTID_sk_type(sk), ossl_check_OCSP_CERTID_compfunc_type(cmp)))
+SKM_DEFINE_STACK_OF_INTERNAL(OCSP_ONEREQ, OCSP_ONEREQ, OCSP_ONEREQ)
+#define sk_OCSP_ONEREQ_num(sk) OPENSSL_sk_num(ossl_check_const_OCSP_ONEREQ_sk_type(sk))
+#define sk_OCSP_ONEREQ_value(sk, idx) ((OCSP_ONEREQ *)OPENSSL_sk_value(ossl_check_const_OCSP_ONEREQ_sk_type(sk), (idx)))
+#define sk_OCSP_ONEREQ_new(cmp) ((STACK_OF(OCSP_ONEREQ) *)OPENSSL_sk_new(ossl_check_OCSP_ONEREQ_compfunc_type(cmp)))
+#define sk_OCSP_ONEREQ_new_null() ((STACK_OF(OCSP_ONEREQ) *)OPENSSL_sk_new_null())
+#define sk_OCSP_ONEREQ_new_reserve(cmp, n) ((STACK_OF(OCSP_ONEREQ) *)OPENSSL_sk_new_reserve(ossl_check_OCSP_ONEREQ_compfunc_type(cmp), (n)))
+#define sk_OCSP_ONEREQ_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OCSP_ONEREQ_sk_type(sk), (n))
+#define sk_OCSP_ONEREQ_free(sk) OPENSSL_sk_free(ossl_check_OCSP_ONEREQ_sk_type(sk))
+#define sk_OCSP_ONEREQ_zero(sk) OPENSSL_sk_zero(ossl_check_OCSP_ONEREQ_sk_type(sk))
+#define sk_OCSP_ONEREQ_delete(sk, i) ((OCSP_ONEREQ *)OPENSSL_sk_delete(ossl_check_OCSP_ONEREQ_sk_type(sk), (i)))
+#define sk_OCSP_ONEREQ_delete_ptr(sk, ptr) ((OCSP_ONEREQ *)OPENSSL_sk_delete_ptr(ossl_check_OCSP_ONEREQ_sk_type(sk), ossl_check_OCSP_ONEREQ_type(ptr)))
+#define sk_OCSP_ONEREQ_push(sk, ptr) OPENSSL_sk_push(ossl_check_OCSP_ONEREQ_sk_type(sk), ossl_check_OCSP_ONEREQ_type(ptr))
+#define sk_OCSP_ONEREQ_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_OCSP_ONEREQ_sk_type(sk), ossl_check_OCSP_ONEREQ_type(ptr))
+#define sk_OCSP_ONEREQ_pop(sk) ((OCSP_ONEREQ *)OPENSSL_sk_pop(ossl_check_OCSP_ONEREQ_sk_type(sk)))
+#define sk_OCSP_ONEREQ_shift(sk) ((OCSP_ONEREQ *)OPENSSL_sk_shift(ossl_check_OCSP_ONEREQ_sk_type(sk)))
+#define sk_OCSP_ONEREQ_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OCSP_ONEREQ_sk_type(sk),ossl_check_OCSP_ONEREQ_freefunc_type(freefunc))
+#define sk_OCSP_ONEREQ_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_OCSP_ONEREQ_sk_type(sk), ossl_check_OCSP_ONEREQ_type(ptr), (idx))
+#define sk_OCSP_ONEREQ_set(sk, idx, ptr) ((OCSP_ONEREQ *)OPENSSL_sk_set(ossl_check_OCSP_ONEREQ_sk_type(sk), (idx), ossl_check_OCSP_ONEREQ_type(ptr)))
+#define sk_OCSP_ONEREQ_find(sk, ptr) OPENSSL_sk_find(ossl_check_OCSP_ONEREQ_sk_type(sk), ossl_check_OCSP_ONEREQ_type(ptr))
+#define sk_OCSP_ONEREQ_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_OCSP_ONEREQ_sk_type(sk), ossl_check_OCSP_ONEREQ_type(ptr))
+#define sk_OCSP_ONEREQ_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OCSP_ONEREQ_sk_type(sk), ossl_check_OCSP_ONEREQ_type(ptr), pnum)
+#define sk_OCSP_ONEREQ_sort(sk) OPENSSL_sk_sort(ossl_check_OCSP_ONEREQ_sk_type(sk))
+#define sk_OCSP_ONEREQ_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OCSP_ONEREQ_sk_type(sk))
+#define sk_OCSP_ONEREQ_dup(sk) ((STACK_OF(OCSP_ONEREQ) *)OPENSSL_sk_dup(ossl_check_const_OCSP_ONEREQ_sk_type(sk)))
+#define sk_OCSP_ONEREQ_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OCSP_ONEREQ) *)OPENSSL_sk_deep_copy(ossl_check_const_OCSP_ONEREQ_sk_type(sk), ossl_check_OCSP_ONEREQ_copyfunc_type(copyfunc), ossl_check_OCSP_ONEREQ_freefunc_type(freefunc)))
+#define sk_OCSP_ONEREQ_set_cmp_func(sk, cmp) ((sk_OCSP_ONEREQ_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OCSP_ONEREQ_sk_type(sk), ossl_check_OCSP_ONEREQ_compfunc_type(cmp)))
+
+
+#  define OCSP_RESPONSE_STATUS_SUCCESSFUL           0
+#  define OCSP_RESPONSE_STATUS_MALFORMEDREQUEST     1
+#  define OCSP_RESPONSE_STATUS_INTERNALERROR        2
+#  define OCSP_RESPONSE_STATUS_TRYLATER             3
+#  define OCSP_RESPONSE_STATUS_SIGREQUIRED          5
+#  define OCSP_RESPONSE_STATUS_UNAUTHORIZED         6
+
+typedef struct ocsp_resp_bytes_st OCSP_RESPBYTES;
+
+#  define V_OCSP_RESPID_NAME 0
+#  define V_OCSP_RESPID_KEY  1
+
+SKM_DEFINE_STACK_OF_INTERNAL(OCSP_RESPID, OCSP_RESPID, OCSP_RESPID)
+#define sk_OCSP_RESPID_num(sk) OPENSSL_sk_num(ossl_check_const_OCSP_RESPID_sk_type(sk))
+#define sk_OCSP_RESPID_value(sk, idx) ((OCSP_RESPID *)OPENSSL_sk_value(ossl_check_const_OCSP_RESPID_sk_type(sk), (idx)))
+#define sk_OCSP_RESPID_new(cmp) ((STACK_OF(OCSP_RESPID) *)OPENSSL_sk_new(ossl_check_OCSP_RESPID_compfunc_type(cmp)))
+#define sk_OCSP_RESPID_new_null() ((STACK_OF(OCSP_RESPID) *)OPENSSL_sk_new_null())
+#define sk_OCSP_RESPID_new_reserve(cmp, n) ((STACK_OF(OCSP_RESPID) *)OPENSSL_sk_new_reserve(ossl_check_OCSP_RESPID_compfunc_type(cmp), (n)))
+#define sk_OCSP_RESPID_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OCSP_RESPID_sk_type(sk), (n))
+#define sk_OCSP_RESPID_free(sk) OPENSSL_sk_free(ossl_check_OCSP_RESPID_sk_type(sk))
+#define sk_OCSP_RESPID_zero(sk) OPENSSL_sk_zero(ossl_check_OCSP_RESPID_sk_type(sk))
+#define sk_OCSP_RESPID_delete(sk, i) ((OCSP_RESPID *)OPENSSL_sk_delete(ossl_check_OCSP_RESPID_sk_type(sk), (i)))
+#define sk_OCSP_RESPID_delete_ptr(sk, ptr) ((OCSP_RESPID *)OPENSSL_sk_delete_ptr(ossl_check_OCSP_RESPID_sk_type(sk), ossl_check_OCSP_RESPID_type(ptr)))
+#define sk_OCSP_RESPID_push(sk, ptr) OPENSSL_sk_push(ossl_check_OCSP_RESPID_sk_type(sk), ossl_check_OCSP_RESPID_type(ptr))
+#define sk_OCSP_RESPID_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_OCSP_RESPID_sk_type(sk), ossl_check_OCSP_RESPID_type(ptr))
+#define sk_OCSP_RESPID_pop(sk) ((OCSP_RESPID *)OPENSSL_sk_pop(ossl_check_OCSP_RESPID_sk_type(sk)))
+#define sk_OCSP_RESPID_shift(sk) ((OCSP_RESPID *)OPENSSL_sk_shift(ossl_check_OCSP_RESPID_sk_type(sk)))
+#define sk_OCSP_RESPID_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OCSP_RESPID_sk_type(sk),ossl_check_OCSP_RESPID_freefunc_type(freefunc))
+#define sk_OCSP_RESPID_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_OCSP_RESPID_sk_type(sk), ossl_check_OCSP_RESPID_type(ptr), (idx))
+#define sk_OCSP_RESPID_set(sk, idx, ptr) ((OCSP_RESPID *)OPENSSL_sk_set(ossl_check_OCSP_RESPID_sk_type(sk), (idx), ossl_check_OCSP_RESPID_type(ptr)))
+#define sk_OCSP_RESPID_find(sk, ptr) OPENSSL_sk_find(ossl_check_OCSP_RESPID_sk_type(sk), ossl_check_OCSP_RESPID_type(ptr))
+#define sk_OCSP_RESPID_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_OCSP_RESPID_sk_type(sk), ossl_check_OCSP_RESPID_type(ptr))
+#define sk_OCSP_RESPID_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OCSP_RESPID_sk_type(sk), ossl_check_OCSP_RESPID_type(ptr), pnum)
+#define sk_OCSP_RESPID_sort(sk) OPENSSL_sk_sort(ossl_check_OCSP_RESPID_sk_type(sk))
+#define sk_OCSP_RESPID_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OCSP_RESPID_sk_type(sk))
+#define sk_OCSP_RESPID_dup(sk) ((STACK_OF(OCSP_RESPID) *)OPENSSL_sk_dup(ossl_check_const_OCSP_RESPID_sk_type(sk)))
+#define sk_OCSP_RESPID_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OCSP_RESPID) *)OPENSSL_sk_deep_copy(ossl_check_const_OCSP_RESPID_sk_type(sk), ossl_check_OCSP_RESPID_copyfunc_type(copyfunc), ossl_check_OCSP_RESPID_freefunc_type(freefunc)))
+#define sk_OCSP_RESPID_set_cmp_func(sk, cmp) ((sk_OCSP_RESPID_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OCSP_RESPID_sk_type(sk), ossl_check_OCSP_RESPID_compfunc_type(cmp)))
+
+
+typedef struct ocsp_revoked_info_st OCSP_REVOKEDINFO;
+
+#  define V_OCSP_CERTSTATUS_GOOD    0
+#  define V_OCSP_CERTSTATUS_REVOKED 1
+#  define V_OCSP_CERTSTATUS_UNKNOWN 2
+
+typedef struct ocsp_cert_status_st OCSP_CERTSTATUS;
+typedef struct ocsp_single_response_st OCSP_SINGLERESP;
+
+SKM_DEFINE_STACK_OF_INTERNAL(OCSP_SINGLERESP, OCSP_SINGLERESP, OCSP_SINGLERESP)
+#define sk_OCSP_SINGLERESP_num(sk) OPENSSL_sk_num(ossl_check_const_OCSP_SINGLERESP_sk_type(sk))
+#define sk_OCSP_SINGLERESP_value(sk, idx) ((OCSP_SINGLERESP *)OPENSSL_sk_value(ossl_check_const_OCSP_SINGLERESP_sk_type(sk), (idx)))
+#define sk_OCSP_SINGLERESP_new(cmp) ((STACK_OF(OCSP_SINGLERESP) *)OPENSSL_sk_new(ossl_check_OCSP_SINGLERESP_compfunc_type(cmp)))
+#define sk_OCSP_SINGLERESP_new_null() ((STACK_OF(OCSP_SINGLERESP) *)OPENSSL_sk_new_null())
+#define sk_OCSP_SINGLERESP_new_reserve(cmp, n) ((STACK_OF(OCSP_SINGLERESP) *)OPENSSL_sk_new_reserve(ossl_check_OCSP_SINGLERESP_compfunc_type(cmp), (n)))
+#define sk_OCSP_SINGLERESP_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OCSP_SINGLERESP_sk_type(sk), (n))
+#define sk_OCSP_SINGLERESP_free(sk) OPENSSL_sk_free(ossl_check_OCSP_SINGLERESP_sk_type(sk))
+#define sk_OCSP_SINGLERESP_zero(sk) OPENSSL_sk_zero(ossl_check_OCSP_SINGLERESP_sk_type(sk))
+#define sk_OCSP_SINGLERESP_delete(sk, i) ((OCSP_SINGLERESP *)OPENSSL_sk_delete(ossl_check_OCSP_SINGLERESP_sk_type(sk), (i)))
+#define sk_OCSP_SINGLERESP_delete_ptr(sk, ptr) ((OCSP_SINGLERESP *)OPENSSL_sk_delete_ptr(ossl_check_OCSP_SINGLERESP_sk_type(sk), ossl_check_OCSP_SINGLERESP_type(ptr)))
+#define sk_OCSP_SINGLERESP_push(sk, ptr) OPENSSL_sk_push(ossl_check_OCSP_SINGLERESP_sk_type(sk), ossl_check_OCSP_SINGLERESP_type(ptr))
+#define sk_OCSP_SINGLERESP_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_OCSP_SINGLERESP_sk_type(sk), ossl_check_OCSP_SINGLERESP_type(ptr))
+#define sk_OCSP_SINGLERESP_pop(sk) ((OCSP_SINGLERESP *)OPENSSL_sk_pop(ossl_check_OCSP_SINGLERESP_sk_type(sk)))
+#define sk_OCSP_SINGLERESP_shift(sk) ((OCSP_SINGLERESP *)OPENSSL_sk_shift(ossl_check_OCSP_SINGLERESP_sk_type(sk)))
+#define sk_OCSP_SINGLERESP_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OCSP_SINGLERESP_sk_type(sk),ossl_check_OCSP_SINGLERESP_freefunc_type(freefunc))
+#define sk_OCSP_SINGLERESP_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_OCSP_SINGLERESP_sk_type(sk), ossl_check_OCSP_SINGLERESP_type(ptr), (idx))
+#define sk_OCSP_SINGLERESP_set(sk, idx, ptr) ((OCSP_SINGLERESP *)OPENSSL_sk_set(ossl_check_OCSP_SINGLERESP_sk_type(sk), (idx), ossl_check_OCSP_SINGLERESP_type(ptr)))
+#define sk_OCSP_SINGLERESP_find(sk, ptr) OPENSSL_sk_find(ossl_check_OCSP_SINGLERESP_sk_type(sk), ossl_check_OCSP_SINGLERESP_type(ptr))
+#define sk_OCSP_SINGLERESP_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_OCSP_SINGLERESP_sk_type(sk), ossl_check_OCSP_SINGLERESP_type(ptr))
+#define sk_OCSP_SINGLERESP_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OCSP_SINGLERESP_sk_type(sk), ossl_check_OCSP_SINGLERESP_type(ptr), pnum)
+#define sk_OCSP_SINGLERESP_sort(sk) OPENSSL_sk_sort(ossl_check_OCSP_SINGLERESP_sk_type(sk))
+#define sk_OCSP_SINGLERESP_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OCSP_SINGLERESP_sk_type(sk))
+#define sk_OCSP_SINGLERESP_dup(sk) ((STACK_OF(OCSP_SINGLERESP) *)OPENSSL_sk_dup(ossl_check_const_OCSP_SINGLERESP_sk_type(sk)))
+#define sk_OCSP_SINGLERESP_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OCSP_SINGLERESP) *)OPENSSL_sk_deep_copy(ossl_check_const_OCSP_SINGLERESP_sk_type(sk), ossl_check_OCSP_SINGLERESP_copyfunc_type(copyfunc), ossl_check_OCSP_SINGLERESP_freefunc_type(freefunc)))
+#define sk_OCSP_SINGLERESP_set_cmp_func(sk, cmp) ((sk_OCSP_SINGLERESP_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OCSP_SINGLERESP_sk_type(sk), ossl_check_OCSP_SINGLERESP_compfunc_type(cmp)))
+
+
+typedef struct ocsp_response_data_st OCSP_RESPDATA;
+
+typedef struct ocsp_basic_response_st OCSP_BASICRESP;
+
+typedef struct ocsp_crl_id_st OCSP_CRLID;
+typedef struct ocsp_service_locator_st OCSP_SERVICELOC;
+
+#  define PEM_STRING_OCSP_REQUEST "OCSP REQUEST"
+#  define PEM_STRING_OCSP_RESPONSE "OCSP RESPONSE"
+
+#  define d2i_OCSP_REQUEST_bio(bp,p) ASN1_d2i_bio_of(OCSP_REQUEST,OCSP_REQUEST_new,d2i_OCSP_REQUEST,bp,p)
+
+#  define d2i_OCSP_RESPONSE_bio(bp,p) ASN1_d2i_bio_of(OCSP_RESPONSE,OCSP_RESPONSE_new,d2i_OCSP_RESPONSE,bp,p)
+
+#  define PEM_read_bio_OCSP_REQUEST(bp,x,cb) (OCSP_REQUEST *)PEM_ASN1_read_bio( \
+     (char *(*)())d2i_OCSP_REQUEST,PEM_STRING_OCSP_REQUEST, \
+     bp,(char **)(x),cb,NULL)
+
+#  define PEM_read_bio_OCSP_RESPONSE(bp,x,cb) (OCSP_RESPONSE *)PEM_ASN1_read_bio(\
+     (char *(*)())d2i_OCSP_RESPONSE,PEM_STRING_OCSP_RESPONSE, \
+     bp,(char **)(x),cb,NULL)
+
+#  define PEM_write_bio_OCSP_REQUEST(bp,o) \
+    PEM_ASN1_write_bio((int (*)())i2d_OCSP_REQUEST,PEM_STRING_OCSP_REQUEST,\
+                        bp,(char *)(o), NULL,NULL,0,NULL,NULL)
+
+#  define PEM_write_bio_OCSP_RESPONSE(bp,o) \
+    PEM_ASN1_write_bio((int (*)())i2d_OCSP_RESPONSE,PEM_STRING_OCSP_RESPONSE,\
+                        bp,(char *)(o), NULL,NULL,0,NULL,NULL)
+
+#  define i2d_OCSP_RESPONSE_bio(bp,o) ASN1_i2d_bio_of(OCSP_RESPONSE,i2d_OCSP_RESPONSE,bp,o)
+
+#  define i2d_OCSP_REQUEST_bio(bp,o) ASN1_i2d_bio_of(OCSP_REQUEST,i2d_OCSP_REQUEST,bp,o)
+
+#  define ASN1_BIT_STRING_digest(data,type,md,len) \
+        ASN1_item_digest(ASN1_ITEM_rptr(ASN1_BIT_STRING),type,data,md,len)
+
+#  define OCSP_CERTSTATUS_dup(cs)\
+                (OCSP_CERTSTATUS*)ASN1_dup((i2d_of_void *)i2d_OCSP_CERTSTATUS,\
+                (d2i_of_void *)d2i_OCSP_CERTSTATUS,(char *)(cs))
+
+DECLARE_ASN1_DUP_FUNCTION(OCSP_CERTID)
+
+OSSL_HTTP_REQ_CTX *OCSP_sendreq_new(BIO *io, const char *path,
+                                    const OCSP_REQUEST *req, int buf_size);
+OCSP_RESPONSE *OCSP_sendreq_bio(BIO *b, const char *path, OCSP_REQUEST *req);
+
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+typedef OSSL_HTTP_REQ_CTX OCSP_REQ_CTX;
+#   define OCSP_REQ_CTX_new(io, buf_size) \
+        OSSL_HTTP_REQ_CTX_new(io, io, buf_size)
+#   define OCSP_REQ_CTX_free OSSL_HTTP_REQ_CTX_free
+#   define OCSP_REQ_CTX_http(rctx, op, path) \
+        (OSSL_HTTP_REQ_CTX_set_expected(rctx, NULL, 1 /* asn1 */, 0, 0) && \
+         OSSL_HTTP_REQ_CTX_set_request_line(rctx, strcmp(op, "POST") == 0, \
+                                            NULL, NULL, path))
+#   define OCSP_REQ_CTX_add1_header OSSL_HTTP_REQ_CTX_add1_header
+#   define OCSP_REQ_CTX_i2d(r, it, req) \
+        OSSL_HTTP_REQ_CTX_set1_req(r, "application/ocsp-request", it, req)
+#   define OCSP_REQ_CTX_set1_req(r, req) \
+        OCSP_REQ_CTX_i2d(r, ASN1_ITEM_rptr(OCSP_REQUEST), (ASN1_VALUE *)(req))
+#   define OCSP_REQ_CTX_nbio OSSL_HTTP_REQ_CTX_nbio
+#   define OCSP_REQ_CTX_nbio_d2i OSSL_HTTP_REQ_CTX_nbio_d2i
+#   define OCSP_sendreq_nbio(p, r) \
+        OSSL_HTTP_REQ_CTX_nbio_d2i(r, (ASN1_VALUE **)(p), \
+                                   ASN1_ITEM_rptr(OCSP_RESPONSE))
+#   define OCSP_REQ_CTX_get0_mem_bio OSSL_HTTP_REQ_CTX_get0_mem_bio
+#   define OCSP_set_max_response_length OSSL_HTTP_REQ_CTX_set_max_response_length
+#  endif
+
+OCSP_CERTID *OCSP_cert_to_id(const EVP_MD *dgst, const X509 *subject,
+                             const X509 *issuer);
+
+OCSP_CERTID *OCSP_cert_id_new(const EVP_MD *dgst,
+                              const X509_NAME *issuerName,
+                              const ASN1_BIT_STRING *issuerKey,
+                              const ASN1_INTEGER *serialNumber);
+
+OCSP_ONEREQ *OCSP_request_add0_id(OCSP_REQUEST *req, OCSP_CERTID *cid);
+
+int OCSP_request_add1_nonce(OCSP_REQUEST *req, unsigned char *val, int len);
+int OCSP_basic_add1_nonce(OCSP_BASICRESP *resp, unsigned char *val, int len);
+int OCSP_check_nonce(OCSP_REQUEST *req, OCSP_BASICRESP *bs);
+int OCSP_copy_nonce(OCSP_BASICRESP *resp, OCSP_REQUEST *req);
+
+int OCSP_request_set1_name(OCSP_REQUEST *req, const X509_NAME *nm);
+int OCSP_request_add1_cert(OCSP_REQUEST *req, X509 *cert);
+
+int OCSP_request_sign(OCSP_REQUEST *req,
+                      X509 *signer,
+                      EVP_PKEY *key,
+                      const EVP_MD *dgst,
+                      STACK_OF(X509) *certs, unsigned long flags);
+
+int OCSP_response_status(OCSP_RESPONSE *resp);
+OCSP_BASICRESP *OCSP_response_get1_basic(OCSP_RESPONSE *resp);
+
+const ASN1_OCTET_STRING *OCSP_resp_get0_signature(const OCSP_BASICRESP *bs);
+const X509_ALGOR *OCSP_resp_get0_tbs_sigalg(const OCSP_BASICRESP *bs);
+const OCSP_RESPDATA *OCSP_resp_get0_respdata(const OCSP_BASICRESP *bs);
+int OCSP_resp_get0_signer(OCSP_BASICRESP *bs, X509 **signer,
+                          STACK_OF(X509) *extra_certs);
+
+int OCSP_resp_count(OCSP_BASICRESP *bs);
+OCSP_SINGLERESP *OCSP_resp_get0(OCSP_BASICRESP *bs, int idx);
+const ASN1_GENERALIZEDTIME *OCSP_resp_get0_produced_at(const OCSP_BASICRESP* bs);
+const STACK_OF(X509) *OCSP_resp_get0_certs(const OCSP_BASICRESP *bs);
+int OCSP_resp_get0_id(const OCSP_BASICRESP *bs,
+                      const ASN1_OCTET_STRING **pid,
+                      const X509_NAME **pname);
+int OCSP_resp_get1_id(const OCSP_BASICRESP *bs,
+                      ASN1_OCTET_STRING **pid,
+                      X509_NAME **pname);
+
+int OCSP_resp_find(OCSP_BASICRESP *bs, OCSP_CERTID *id, int last);
+int OCSP_single_get0_status(OCSP_SINGLERESP *single, int *reason,
+                            ASN1_GENERALIZEDTIME **revtime,
+                            ASN1_GENERALIZEDTIME **thisupd,
+                            ASN1_GENERALIZEDTIME **nextupd);
+int OCSP_resp_find_status(OCSP_BASICRESP *bs, OCSP_CERTID *id, int *status,
+                          int *reason,
+                          ASN1_GENERALIZEDTIME **revtime,
+                          ASN1_GENERALIZEDTIME **thisupd,
+                          ASN1_GENERALIZEDTIME **nextupd);
+int OCSP_check_validity(ASN1_GENERALIZEDTIME *thisupd,
+                        ASN1_GENERALIZEDTIME *nextupd, long sec, long maxsec);
+
+int OCSP_request_verify(OCSP_REQUEST *req, STACK_OF(X509) *certs,
+                        X509_STORE *store, unsigned long flags);
+
+#  define OCSP_parse_url(url, host, port, path, ssl) \
+    OSSL_HTTP_parse_url(url, ssl, NULL, host, port, NULL, path, NULL, NULL)
+
+int OCSP_id_issuer_cmp(const OCSP_CERTID *a, const OCSP_CERTID *b);
+int OCSP_id_cmp(const OCSP_CERTID *a, const OCSP_CERTID *b);
+
+int OCSP_request_onereq_count(OCSP_REQUEST *req);
+OCSP_ONEREQ *OCSP_request_onereq_get0(OCSP_REQUEST *req, int i);
+OCSP_CERTID *OCSP_onereq_get0_id(OCSP_ONEREQ *one);
+int OCSP_id_get0_info(ASN1_OCTET_STRING **piNameHash, ASN1_OBJECT **pmd,
+                      ASN1_OCTET_STRING **pikeyHash,
+                      ASN1_INTEGER **pserial, OCSP_CERTID *cid);
+int OCSP_request_is_signed(OCSP_REQUEST *req);
+OCSP_RESPONSE *OCSP_response_create(int status, OCSP_BASICRESP *bs);
+OCSP_SINGLERESP *OCSP_basic_add1_status(OCSP_BASICRESP *rsp,
+                                        OCSP_CERTID *cid,
+                                        int status, int reason,
+                                        ASN1_TIME *revtime,
+                                        ASN1_TIME *thisupd,
+                                        ASN1_TIME *nextupd);
+int OCSP_basic_add1_cert(OCSP_BASICRESP *resp, X509 *cert);
+int OCSP_basic_sign(OCSP_BASICRESP *brsp,
+                    X509 *signer, EVP_PKEY *key, const EVP_MD *dgst,
+                    STACK_OF(X509) *certs, unsigned long flags);
+int OCSP_basic_sign_ctx(OCSP_BASICRESP *brsp,
+                        X509 *signer, EVP_MD_CTX *ctx,
+                        STACK_OF(X509) *certs, unsigned long flags);
+int OCSP_RESPID_set_by_name(OCSP_RESPID *respid, X509 *cert);
+int OCSP_RESPID_set_by_key_ex(OCSP_RESPID *respid, X509 *cert,
+                              OSSL_LIB_CTX *libctx, const char *propq);
+int OCSP_RESPID_set_by_key(OCSP_RESPID *respid, X509 *cert);
+int OCSP_RESPID_match_ex(OCSP_RESPID *respid, X509 *cert, OSSL_LIB_CTX *libctx,
+                         const char *propq);
+int OCSP_RESPID_match(OCSP_RESPID *respid, X509 *cert);
+
+X509_EXTENSION *OCSP_crlID_new(const char *url, long *n, char *tim);
+
+X509_EXTENSION *OCSP_accept_responses_new(char **oids);
+
+X509_EXTENSION *OCSP_archive_cutoff_new(char *tim);
+
+X509_EXTENSION *OCSP_url_svcloc_new(const X509_NAME *issuer, const char **urls);
+
+int OCSP_REQUEST_get_ext_count(OCSP_REQUEST *x);
+int OCSP_REQUEST_get_ext_by_NID(OCSP_REQUEST *x, int nid, int lastpos);
+int OCSP_REQUEST_get_ext_by_OBJ(OCSP_REQUEST *x, const ASN1_OBJECT *obj,
+                                int lastpos);
+int OCSP_REQUEST_get_ext_by_critical(OCSP_REQUEST *x, int crit, int lastpos);
+X509_EXTENSION *OCSP_REQUEST_get_ext(OCSP_REQUEST *x, int loc);
+X509_EXTENSION *OCSP_REQUEST_delete_ext(OCSP_REQUEST *x, int loc);
+void *OCSP_REQUEST_get1_ext_d2i(OCSP_REQUEST *x, int nid, int *crit,
+                                int *idx);
+int OCSP_REQUEST_add1_ext_i2d(OCSP_REQUEST *x, int nid, void *value, int crit,
+                              unsigned long flags);
+int OCSP_REQUEST_add_ext(OCSP_REQUEST *x, X509_EXTENSION *ex, int loc);
+
+int OCSP_ONEREQ_get_ext_count(OCSP_ONEREQ *x);
+int OCSP_ONEREQ_get_ext_by_NID(OCSP_ONEREQ *x, int nid, int lastpos);
+int OCSP_ONEREQ_get_ext_by_OBJ(OCSP_ONEREQ *x, const ASN1_OBJECT *obj, int lastpos);
+int OCSP_ONEREQ_get_ext_by_critical(OCSP_ONEREQ *x, int crit, int lastpos);
+X509_EXTENSION *OCSP_ONEREQ_get_ext(OCSP_ONEREQ *x, int loc);
+X509_EXTENSION *OCSP_ONEREQ_delete_ext(OCSP_ONEREQ *x, int loc);
+void *OCSP_ONEREQ_get1_ext_d2i(OCSP_ONEREQ *x, int nid, int *crit, int *idx);
+int OCSP_ONEREQ_add1_ext_i2d(OCSP_ONEREQ *x, int nid, void *value, int crit,
+                             unsigned long flags);
+int OCSP_ONEREQ_add_ext(OCSP_ONEREQ *x, X509_EXTENSION *ex, int loc);
+
+int OCSP_BASICRESP_get_ext_count(OCSP_BASICRESP *x);
+int OCSP_BASICRESP_get_ext_by_NID(OCSP_BASICRESP *x, int nid, int lastpos);
+int OCSP_BASICRESP_get_ext_by_OBJ(OCSP_BASICRESP *x, const ASN1_OBJECT *obj,
+                                  int lastpos);
+int OCSP_BASICRESP_get_ext_by_critical(OCSP_BASICRESP *x, int crit,
+                                       int lastpos);
+X509_EXTENSION *OCSP_BASICRESP_get_ext(OCSP_BASICRESP *x, int loc);
+X509_EXTENSION *OCSP_BASICRESP_delete_ext(OCSP_BASICRESP *x, int loc);
+void *OCSP_BASICRESP_get1_ext_d2i(OCSP_BASICRESP *x, int nid, int *crit,
+                                  int *idx);
+int OCSP_BASICRESP_add1_ext_i2d(OCSP_BASICRESP *x, int nid, void *value,
+                                int crit, unsigned long flags);
+int OCSP_BASICRESP_add_ext(OCSP_BASICRESP *x, X509_EXTENSION *ex, int loc);
+
+int OCSP_SINGLERESP_get_ext_count(OCSP_SINGLERESP *x);
+int OCSP_SINGLERESP_get_ext_by_NID(OCSP_SINGLERESP *x, int nid, int lastpos);
+int OCSP_SINGLERESP_get_ext_by_OBJ(OCSP_SINGLERESP *x, const ASN1_OBJECT *obj,
+                                   int lastpos);
+int OCSP_SINGLERESP_get_ext_by_critical(OCSP_SINGLERESP *x, int crit,
+                                        int lastpos);
+X509_EXTENSION *OCSP_SINGLERESP_get_ext(OCSP_SINGLERESP *x, int loc);
+X509_EXTENSION *OCSP_SINGLERESP_delete_ext(OCSP_SINGLERESP *x, int loc);
+void *OCSP_SINGLERESP_get1_ext_d2i(OCSP_SINGLERESP *x, int nid, int *crit,
+                                   int *idx);
+int OCSP_SINGLERESP_add1_ext_i2d(OCSP_SINGLERESP *x, int nid, void *value,
+                                 int crit, unsigned long flags);
+int OCSP_SINGLERESP_add_ext(OCSP_SINGLERESP *x, X509_EXTENSION *ex, int loc);
+const OCSP_CERTID *OCSP_SINGLERESP_get0_id(const OCSP_SINGLERESP *x);
+
+DECLARE_ASN1_FUNCTIONS(OCSP_SINGLERESP)
+DECLARE_ASN1_FUNCTIONS(OCSP_CERTSTATUS)
+DECLARE_ASN1_FUNCTIONS(OCSP_REVOKEDINFO)
+DECLARE_ASN1_FUNCTIONS(OCSP_BASICRESP)
+DECLARE_ASN1_FUNCTIONS(OCSP_RESPDATA)
+DECLARE_ASN1_FUNCTIONS(OCSP_RESPID)
+DECLARE_ASN1_FUNCTIONS(OCSP_RESPONSE)
+DECLARE_ASN1_FUNCTIONS(OCSP_RESPBYTES)
+DECLARE_ASN1_FUNCTIONS(OCSP_ONEREQ)
+DECLARE_ASN1_FUNCTIONS(OCSP_CERTID)
+DECLARE_ASN1_FUNCTIONS(OCSP_REQUEST)
+DECLARE_ASN1_FUNCTIONS(OCSP_SIGNATURE)
+DECLARE_ASN1_FUNCTIONS(OCSP_REQINFO)
+DECLARE_ASN1_FUNCTIONS(OCSP_CRLID)
+DECLARE_ASN1_FUNCTIONS(OCSP_SERVICELOC)
+
+const char *OCSP_response_status_str(long s);
+const char *OCSP_cert_status_str(long s);
+const char *OCSP_crl_reason_str(long s);
+
+int OCSP_REQUEST_print(BIO *bp, OCSP_REQUEST *a, unsigned long flags);
+int OCSP_RESPONSE_print(BIO *bp, OCSP_RESPONSE *o, unsigned long flags);
+
+int OCSP_basic_verify(OCSP_BASICRESP *bs, STACK_OF(X509) *certs,
+                      X509_STORE *st, unsigned long flags);
+
+
+#  ifdef  __cplusplus
+}
+#  endif
+# endif /* !defined(OPENSSL_NO_OCSP) */
+#endif
diff --git a/src/include/openssl/ocsperr.h b/src/include/openssl/ocsperr.h
new file mode 100644
index 0000000..46a0523
--- /dev/null
+++ b/src/include/openssl/ocsperr.h
@@ -0,0 +1,53 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_OCSPERR_H
+# define OPENSSL_OCSPERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+# ifndef OPENSSL_NO_OCSP
+
+
+/*
+ * OCSP reason codes.
+ */
+#  define OCSP_R_CERTIFICATE_VERIFY_ERROR                  101
+#  define OCSP_R_DIGEST_ERR                                102
+#  define OCSP_R_DIGEST_NAME_ERR                           106
+#  define OCSP_R_DIGEST_SIZE_ERR                           107
+#  define OCSP_R_ERROR_IN_NEXTUPDATE_FIELD                 122
+#  define OCSP_R_ERROR_IN_THISUPDATE_FIELD                 123
+#  define OCSP_R_MISSING_OCSPSIGNING_USAGE                 103
+#  define OCSP_R_NEXTUPDATE_BEFORE_THISUPDATE              124
+#  define OCSP_R_NOT_BASIC_RESPONSE                        104
+#  define OCSP_R_NO_CERTIFICATES_IN_CHAIN                  105
+#  define OCSP_R_NO_RESPONSE_DATA                          108
+#  define OCSP_R_NO_REVOKED_TIME                           109
+#  define OCSP_R_NO_SIGNER_KEY                             130
+#  define OCSP_R_PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE    110
+#  define OCSP_R_REQUEST_NOT_SIGNED                        128
+#  define OCSP_R_RESPONSE_CONTAINS_NO_REVOCATION_DATA      111
+#  define OCSP_R_ROOT_CA_NOT_TRUSTED                       112
+#  define OCSP_R_SIGNATURE_FAILURE                         117
+#  define OCSP_R_SIGNER_CERTIFICATE_NOT_FOUND              118
+#  define OCSP_R_STATUS_EXPIRED                            125
+#  define OCSP_R_STATUS_NOT_YET_VALID                      126
+#  define OCSP_R_STATUS_TOO_OLD                            127
+#  define OCSP_R_UNKNOWN_MESSAGE_DIGEST                    119
+#  define OCSP_R_UNKNOWN_NID                               120
+#  define OCSP_R_UNSUPPORTED_REQUESTORNAME_TYPE            129
+
+# endif
+#endif
diff --git a/src/include/openssl/opensslconf.h b/src/include/openssl/opensslconf.h
new file mode 100644
index 0000000..1e83371
--- /dev/null
+++ b/src/include/openssl/opensslconf.h
@@ -0,0 +1,17 @@
+/*
+ * Copyright 2019-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_OPENSSLCONF_H
+# define OPENSSL_OPENSSLCONF_H
+# pragma once
+
+# include <openssl/configuration.h>
+# include <openssl/macros.h>
+
+#endif  /* OPENSSL_OPENSSLCONF_H */
diff --git a/src/include/openssl/opensslv.h b/src/include/openssl/opensslv.h
new file mode 100644
index 0000000..d26c4c2
--- /dev/null
+++ b/src/include/openssl/opensslv.h
@@ -0,0 +1,114 @@
+/*
+ * WARNING: do not edit!
+ * Generated by makefile from include\openssl\opensslv.h.in
+ *
+ * Copyright 1999-2020 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_OPENSSLV_H
+# define OPENSSL_OPENSSLV_H
+# pragma once
+
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+/*
+ * SECTION 1: VERSION DATA.  These will change for each release
+ */
+
+/*
+ * Base version macros
+ *
+ * These macros express version number MAJOR.MINOR.PATCH exactly
+ */
+# define OPENSSL_VERSION_MAJOR  3
+# define OPENSSL_VERSION_MINOR  3
+# define OPENSSL_VERSION_PATCH  2
+
+/*
+ * Additional version information
+ *
+ * These are also part of the new version scheme, but aren't part
+ * of the version number itself.
+ */
+
+/* Could be: #define OPENSSL_VERSION_PRE_RELEASE "-alpha.1" */
+# define OPENSSL_VERSION_PRE_RELEASE ""
+/* Could be: #define OPENSSL_VERSION_BUILD_METADATA "+fips" */
+/* Could be: #define OPENSSL_VERSION_BUILD_METADATA "+vendor.1" */
+# define OPENSSL_VERSION_BUILD_METADATA ""
+
+/*
+ * Note: The OpenSSL Project will never define OPENSSL_VERSION_BUILD_METADATA
+ * to be anything but the empty string.  Its use is entirely reserved for
+ * others
+ */
+
+/*
+ * Shared library version
+ *
+ * This is strictly to express ABI version, which may or may not
+ * be related to the API version expressed with the macros above.
+ * This is defined in free form.
+ */
+# define OPENSSL_SHLIB_VERSION 3
+
+/*
+ * SECTION 2: USEFUL MACROS
+ */
+
+/* For checking general API compatibility when preprocessing */
+# define OPENSSL_VERSION_PREREQ(maj,min)                                \
+    ((OPENSSL_VERSION_MAJOR << 16) + OPENSSL_VERSION_MINOR >= ((maj) << 16) + (min))
+
+/*
+ * Macros to get the version in easily digested string form, both the short
+ * "MAJOR.MINOR.PATCH" variant (where MAJOR, MINOR and PATCH are replaced
+ * with the values from the corresponding OPENSSL_VERSION_ macros) and the
+ * longer variant with OPENSSL_VERSION_PRE_RELEASE_STR and
+ * OPENSSL_VERSION_BUILD_METADATA_STR appended.
+ */
+# define OPENSSL_VERSION_STR "3.3.2"
+# define OPENSSL_FULL_VERSION_STR "3.3.2"
+
+/*
+ * SECTION 3: ADDITIONAL METADATA
+ *
+ * These strings are defined separately to allow them to be parsable.
+ */
+# define OPENSSL_RELEASE_DATE "3 Sep 2024"
+
+/*
+ * SECTION 4: BACKWARD COMPATIBILITY
+ */
+
+# define OPENSSL_VERSION_TEXT "OpenSSL 3.3.2 3 Sep 2024"
+
+/* Synthesize OPENSSL_VERSION_NUMBER with the layout 0xMNN00PPSL */
+# ifdef OPENSSL_VERSION_PRE_RELEASE
+#  define _OPENSSL_VERSION_PRE_RELEASE 0x0L
+# else
+#  define _OPENSSL_VERSION_PRE_RELEASE 0xfL
+# endif
+# define OPENSSL_VERSION_NUMBER          \
+    ( (OPENSSL_VERSION_MAJOR<<28)        \
+      |(OPENSSL_VERSION_MINOR<<20)       \
+      |(OPENSSL_VERSION_PATCH<<4)        \
+      |_OPENSSL_VERSION_PRE_RELEASE )
+
+# ifdef  __cplusplus
+}
+# endif
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_OPENSSLV_H
+# endif
+
+#endif                          /* OPENSSL_OPENSSLV_H */
diff --git a/src/include/openssl/ossl_typ.h b/src/include/openssl/ossl_typ.h
new file mode 100644
index 0000000..82a5898
--- /dev/null
+++ b/src/include/openssl/ossl_typ.h
@@ -0,0 +1,16 @@
+/*
+ * Copyright 2019 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+/*
+ * The original <openssl/ossl_typ.h> was renamed to <openssl/types.h>
+ *
+ * This header file only exists for compatibility reasons with older
+ * applications which #include <openssl/ossl_typ.h>.
+ */
+# include <openssl/types.h>
diff --git a/src/include/openssl/param_build.h b/src/include/openssl/param_build.h
new file mode 100644
index 0000000..f29fdb2
--- /dev/null
+++ b/src/include/openssl/param_build.h
@@ -0,0 +1,63 @@
+/*
+ * Copyright 2019-2021 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright (c) 2019, Oracle and/or its affiliates.  All rights reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_PARAM_BUILD_H
+# define OPENSSL_PARAM_BUILD_H
+# pragma once
+
+# include <openssl/params.h>
+# include <openssl/types.h>
+
+# ifdef __cplusplus
+extern "C" {
+# endif
+
+OSSL_PARAM_BLD *OSSL_PARAM_BLD_new(void);
+OSSL_PARAM *OSSL_PARAM_BLD_to_param(OSSL_PARAM_BLD *bld);
+void OSSL_PARAM_BLD_free(OSSL_PARAM_BLD *bld);
+
+int OSSL_PARAM_BLD_push_int(OSSL_PARAM_BLD *bld, const char *key, int val);
+int OSSL_PARAM_BLD_push_uint(OSSL_PARAM_BLD *bld, const char *key,
+                             unsigned int val);
+int OSSL_PARAM_BLD_push_long(OSSL_PARAM_BLD *bld, const char *key,
+                             long int val);
+int OSSL_PARAM_BLD_push_ulong(OSSL_PARAM_BLD *bld, const char *key,
+                              unsigned long int val);
+int OSSL_PARAM_BLD_push_int32(OSSL_PARAM_BLD *bld, const char *key,
+                              int32_t val);
+int OSSL_PARAM_BLD_push_uint32(OSSL_PARAM_BLD *bld, const char *key,
+                               uint32_t val);
+int OSSL_PARAM_BLD_push_int64(OSSL_PARAM_BLD *bld, const char *key,
+                              int64_t val);
+int OSSL_PARAM_BLD_push_uint64(OSSL_PARAM_BLD *bld, const char *key,
+                               uint64_t val);
+int OSSL_PARAM_BLD_push_size_t(OSSL_PARAM_BLD *bld, const char *key,
+                               size_t val);
+int OSSL_PARAM_BLD_push_time_t(OSSL_PARAM_BLD *bld, const char *key,
+                               time_t val);
+int OSSL_PARAM_BLD_push_double(OSSL_PARAM_BLD *bld, const char *key,
+                               double val);
+int OSSL_PARAM_BLD_push_BN(OSSL_PARAM_BLD *bld, const char *key,
+                           const BIGNUM *bn);
+int OSSL_PARAM_BLD_push_BN_pad(OSSL_PARAM_BLD *bld, const char *key,
+                               const BIGNUM *bn, size_t sz);
+int OSSL_PARAM_BLD_push_utf8_string(OSSL_PARAM_BLD *bld, const char *key,
+                                    const char *buf, size_t bsize);
+int OSSL_PARAM_BLD_push_utf8_ptr(OSSL_PARAM_BLD *bld, const char *key,
+                                 char *buf, size_t bsize);
+int OSSL_PARAM_BLD_push_octet_string(OSSL_PARAM_BLD *bld, const char *key,
+                                     const void *buf, size_t bsize);
+int OSSL_PARAM_BLD_push_octet_ptr(OSSL_PARAM_BLD *bld, const char *key,
+                                  void *buf, size_t bsize);
+
+# ifdef __cplusplus
+}
+# endif
+#endif  /* OPENSSL_PARAM_BUILD_H */
diff --git a/src/include/openssl/params.h b/src/include/openssl/params.h
new file mode 100644
index 0000000..d75eab0
--- /dev/null
+++ b/src/include/openssl/params.h
@@ -0,0 +1,160 @@
+/*
+ * Copyright 2019-2021 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright (c) 2019, Oracle and/or its affiliates.  All rights reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_PARAMS_H
+# define OPENSSL_PARAMS_H
+# pragma once
+
+# include <openssl/core.h>
+# include <openssl/bn.h>
+
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+# define OSSL_PARAM_UNMODIFIED ((size_t)-1)
+
+# define OSSL_PARAM_END \
+    { NULL, 0, NULL, 0, 0 }
+
+# define OSSL_PARAM_DEFN(key, type, addr, sz)    \
+    { (key), (type), (addr), (sz), OSSL_PARAM_UNMODIFIED }
+
+/* Basic parameter types without return sizes */
+# define OSSL_PARAM_int(key, addr) \
+    OSSL_PARAM_DEFN((key), OSSL_PARAM_INTEGER, (addr), sizeof(int))
+# define OSSL_PARAM_uint(key, addr) \
+    OSSL_PARAM_DEFN((key), OSSL_PARAM_UNSIGNED_INTEGER, (addr), \
+                    sizeof(unsigned int))
+# define OSSL_PARAM_long(key, addr) \
+    OSSL_PARAM_DEFN((key), OSSL_PARAM_INTEGER, (addr), sizeof(long int))
+# define OSSL_PARAM_ulong(key, addr) \
+    OSSL_PARAM_DEFN((key), OSSL_PARAM_UNSIGNED_INTEGER, (addr), \
+                    sizeof(unsigned long int))
+# define OSSL_PARAM_int32(key, addr) \
+    OSSL_PARAM_DEFN((key), OSSL_PARAM_INTEGER, (addr), sizeof(int32_t))
+# define OSSL_PARAM_uint32(key, addr) \
+    OSSL_PARAM_DEFN((key), OSSL_PARAM_UNSIGNED_INTEGER, (addr), \
+                    sizeof(uint32_t))
+# define OSSL_PARAM_int64(key, addr) \
+    OSSL_PARAM_DEFN((key), OSSL_PARAM_INTEGER, (addr), sizeof(int64_t))
+# define OSSL_PARAM_uint64(key, addr) \
+    OSSL_PARAM_DEFN((key), OSSL_PARAM_UNSIGNED_INTEGER, (addr), \
+                    sizeof(uint64_t))
+# define OSSL_PARAM_size_t(key, addr) \
+    OSSL_PARAM_DEFN((key), OSSL_PARAM_UNSIGNED_INTEGER, (addr), sizeof(size_t))
+# define OSSL_PARAM_time_t(key, addr) \
+    OSSL_PARAM_DEFN((key), OSSL_PARAM_INTEGER, (addr), sizeof(time_t))
+# define OSSL_PARAM_double(key, addr) \
+    OSSL_PARAM_DEFN((key), OSSL_PARAM_REAL, (addr), sizeof(double))
+
+# define OSSL_PARAM_BN(key, bn, sz) \
+    OSSL_PARAM_DEFN((key), OSSL_PARAM_UNSIGNED_INTEGER, (bn), (sz))
+# define OSSL_PARAM_utf8_string(key, addr, sz) \
+    OSSL_PARAM_DEFN((key), OSSL_PARAM_UTF8_STRING, (addr), sz)
+# define OSSL_PARAM_octet_string(key, addr, sz) \
+    OSSL_PARAM_DEFN((key), OSSL_PARAM_OCTET_STRING, (addr), sz)
+
+# define OSSL_PARAM_utf8_ptr(key, addr, sz) \
+    OSSL_PARAM_DEFN((key), OSSL_PARAM_UTF8_PTR, (addr), sz)
+# define OSSL_PARAM_octet_ptr(key, addr, sz) \
+    OSSL_PARAM_DEFN((key), OSSL_PARAM_OCTET_PTR, (addr), sz)
+
+/* Search an OSSL_PARAM array for a matching name */
+OSSL_PARAM *OSSL_PARAM_locate(OSSL_PARAM *p, const char *key);
+const OSSL_PARAM *OSSL_PARAM_locate_const(const OSSL_PARAM *p, const char *key);
+
+/* Basic parameter type run-time construction */
+OSSL_PARAM OSSL_PARAM_construct_int(const char *key, int *buf);
+OSSL_PARAM OSSL_PARAM_construct_uint(const char *key, unsigned int *buf);
+OSSL_PARAM OSSL_PARAM_construct_long(const char *key, long int *buf);
+OSSL_PARAM OSSL_PARAM_construct_ulong(const char *key, unsigned long int *buf);
+OSSL_PARAM OSSL_PARAM_construct_int32(const char *key, int32_t *buf);
+OSSL_PARAM OSSL_PARAM_construct_uint32(const char *key, uint32_t *buf);
+OSSL_PARAM OSSL_PARAM_construct_int64(const char *key, int64_t *buf);
+OSSL_PARAM OSSL_PARAM_construct_uint64(const char *key, uint64_t *buf);
+OSSL_PARAM OSSL_PARAM_construct_size_t(const char *key, size_t *buf);
+OSSL_PARAM OSSL_PARAM_construct_time_t(const char *key, time_t *buf);
+OSSL_PARAM OSSL_PARAM_construct_BN(const char *key, unsigned char *buf,
+                                   size_t bsize);
+OSSL_PARAM OSSL_PARAM_construct_double(const char *key, double *buf);
+OSSL_PARAM OSSL_PARAM_construct_utf8_string(const char *key, char *buf,
+                                            size_t bsize);
+OSSL_PARAM OSSL_PARAM_construct_utf8_ptr(const char *key, char **buf,
+                                         size_t bsize);
+OSSL_PARAM OSSL_PARAM_construct_octet_string(const char *key, void *buf,
+                                             size_t bsize);
+OSSL_PARAM OSSL_PARAM_construct_octet_ptr(const char *key, void **buf,
+                                          size_t bsize);
+OSSL_PARAM OSSL_PARAM_construct_end(void);
+
+int OSSL_PARAM_allocate_from_text(OSSL_PARAM *to,
+                                  const OSSL_PARAM *paramdefs,
+                                  const char *key, const char *value,
+                                  size_t value_n, int *found);
+
+int OSSL_PARAM_get_int(const OSSL_PARAM *p, int *val);
+int OSSL_PARAM_get_uint(const OSSL_PARAM *p, unsigned int *val);
+int OSSL_PARAM_get_long(const OSSL_PARAM *p, long int *val);
+int OSSL_PARAM_get_ulong(const OSSL_PARAM *p, unsigned long int *val);
+int OSSL_PARAM_get_int32(const OSSL_PARAM *p, int32_t *val);
+int OSSL_PARAM_get_uint32(const OSSL_PARAM *p, uint32_t *val);
+int OSSL_PARAM_get_int64(const OSSL_PARAM *p, int64_t *val);
+int OSSL_PARAM_get_uint64(const OSSL_PARAM *p, uint64_t *val);
+int OSSL_PARAM_get_size_t(const OSSL_PARAM *p, size_t *val);
+int OSSL_PARAM_get_time_t(const OSSL_PARAM *p, time_t *val);
+
+int OSSL_PARAM_set_int(OSSL_PARAM *p, int val);
+int OSSL_PARAM_set_uint(OSSL_PARAM *p, unsigned int val);
+int OSSL_PARAM_set_long(OSSL_PARAM *p, long int val);
+int OSSL_PARAM_set_ulong(OSSL_PARAM *p, unsigned long int val);
+int OSSL_PARAM_set_int32(OSSL_PARAM *p, int32_t val);
+int OSSL_PARAM_set_uint32(OSSL_PARAM *p, uint32_t val);
+int OSSL_PARAM_set_int64(OSSL_PARAM *p, int64_t val);
+int OSSL_PARAM_set_uint64(OSSL_PARAM *p, uint64_t val);
+int OSSL_PARAM_set_size_t(OSSL_PARAM *p, size_t val);
+int OSSL_PARAM_set_time_t(OSSL_PARAM *p, time_t val);
+
+int OSSL_PARAM_get_double(const OSSL_PARAM *p, double *val);
+int OSSL_PARAM_set_double(OSSL_PARAM *p, double val);
+
+int OSSL_PARAM_get_BN(const OSSL_PARAM *p, BIGNUM **val);
+int OSSL_PARAM_set_BN(OSSL_PARAM *p, const BIGNUM *val);
+
+int OSSL_PARAM_get_utf8_string(const OSSL_PARAM *p, char **val, size_t max_len);
+int OSSL_PARAM_set_utf8_string(OSSL_PARAM *p, const char *val);
+
+int OSSL_PARAM_get_octet_string(const OSSL_PARAM *p, void **val, size_t max_len,
+                                size_t *used_len);
+int OSSL_PARAM_set_octet_string(OSSL_PARAM *p, const void *val, size_t len);
+
+int OSSL_PARAM_get_utf8_ptr(const OSSL_PARAM *p, const char **val);
+int OSSL_PARAM_set_utf8_ptr(OSSL_PARAM *p, const char *val);
+
+int OSSL_PARAM_get_octet_ptr(const OSSL_PARAM *p, const void **val,
+                             size_t *used_len);
+int OSSL_PARAM_set_octet_ptr(OSSL_PARAM *p, const void *val,
+                             size_t used_len);
+
+int OSSL_PARAM_get_utf8_string_ptr(const OSSL_PARAM *p, const char **val);
+int OSSL_PARAM_get_octet_string_ptr(const OSSL_PARAM *p, const void **val,
+                                    size_t *used_len);
+
+int OSSL_PARAM_modified(const OSSL_PARAM *p);
+void OSSL_PARAM_set_all_unmodified(OSSL_PARAM *p);
+
+OSSL_PARAM *OSSL_PARAM_dup(const OSSL_PARAM *p);
+OSSL_PARAM *OSSL_PARAM_merge(const OSSL_PARAM *p1, const OSSL_PARAM *p2);
+void OSSL_PARAM_free(OSSL_PARAM *p);
+
+# ifdef  __cplusplus
+}
+# endif
+#endif
diff --git a/src/include/openssl/pem.h b/src/include/openssl/pem.h
new file mode 100644
index 0000000..0446c77
--- /dev/null
+++ b/src/include/openssl/pem.h
@@ -0,0 +1,542 @@
+/*
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_PEM_H
+# define OPENSSL_PEM_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_PEM_H
+# endif
+
+# include <openssl/e_os2.h>
+# include <openssl/bio.h>
+# include <openssl/safestack.h>
+# include <openssl/evp.h>
+# include <openssl/x509.h>
+# include <openssl/pemerr.h>
+# ifndef OPENSSL_NO_STDIO
+#  include <stdio.h>
+# endif
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+# define PEM_BUFSIZE             1024
+
+# define PEM_STRING_X509_OLD     "X509 CERTIFICATE"
+# define PEM_STRING_X509         "CERTIFICATE"
+# define PEM_STRING_X509_TRUSTED "TRUSTED CERTIFICATE"
+# define PEM_STRING_X509_REQ_OLD "NEW CERTIFICATE REQUEST"
+# define PEM_STRING_X509_REQ     "CERTIFICATE REQUEST"
+# define PEM_STRING_X509_CRL     "X509 CRL"
+# define PEM_STRING_EVP_PKEY     "ANY PRIVATE KEY"
+# define PEM_STRING_PUBLIC       "PUBLIC KEY"
+# define PEM_STRING_RSA          "RSA PRIVATE KEY"
+# define PEM_STRING_RSA_PUBLIC   "RSA PUBLIC KEY"
+# define PEM_STRING_DSA          "DSA PRIVATE KEY"
+# define PEM_STRING_DSA_PUBLIC   "DSA PUBLIC KEY"
+# define PEM_STRING_PKCS7        "PKCS7"
+# define PEM_STRING_PKCS7_SIGNED "PKCS #7 SIGNED DATA"
+# define PEM_STRING_PKCS8        "ENCRYPTED PRIVATE KEY"
+# define PEM_STRING_PKCS8INF     "PRIVATE KEY"
+# define PEM_STRING_DHPARAMS     "DH PARAMETERS"
+# define PEM_STRING_DHXPARAMS    "X9.42 DH PARAMETERS"
+# define PEM_STRING_SSL_SESSION  "SSL SESSION PARAMETERS"
+# define PEM_STRING_DSAPARAMS    "DSA PARAMETERS"
+# define PEM_STRING_ECDSA_PUBLIC "ECDSA PUBLIC KEY"
+# define PEM_STRING_ECPARAMETERS "EC PARAMETERS"
+# define PEM_STRING_ECPRIVATEKEY "EC PRIVATE KEY"
+# define PEM_STRING_PARAMETERS   "PARAMETERS"
+# define PEM_STRING_CMS          "CMS"
+# define PEM_STRING_SM2PARAMETERS "SM2 PARAMETERS"
+
+# define PEM_TYPE_ENCRYPTED      10
+# define PEM_TYPE_MIC_ONLY       20
+# define PEM_TYPE_MIC_CLEAR      30
+# define PEM_TYPE_CLEAR          40
+
+/*
+ * These macros make the PEM_read/PEM_write functions easier to maintain and
+ * write. Now they are all implemented with either: IMPLEMENT_PEM_rw(...) or
+ * IMPLEMENT_PEM_rw_cb(...)
+ */
+
+# define PEM_read_cb_fnsig(name, type, INTYPE, readname)                \
+    type *PEM_##readname##_##name(INTYPE *out, type **x,                \
+                                 pem_password_cb *cb, void *u)
+# define PEM_read_cb_ex_fnsig(name, type, INTYPE, readname)             \
+    type *PEM_##readname##_##name##_ex(INTYPE *out, type **x,           \
+                                       pem_password_cb *cb, void *u,    \
+                                       OSSL_LIB_CTX *libctx,            \
+                                       const char *propq)
+
+# define PEM_write_fnsig(name, type, OUTTYPE, writename)                \
+    int PEM_##writename##_##name(OUTTYPE *out, const type *x)
+# define PEM_write_cb_fnsig(name, type, OUTTYPE, writename)             \
+    int PEM_##writename##_##name(OUTTYPE *out, const type *x,           \
+                                 const EVP_CIPHER *enc,                 \
+                                 const unsigned char *kstr, int klen,   \
+                                 pem_password_cb *cb, void *u)
+# define PEM_write_ex_fnsig(name, type, OUTTYPE, writename)             \
+    int PEM_##writename##_##name##_ex(OUTTYPE *out, const type *x,      \
+                                      OSSL_LIB_CTX *libctx,             \
+                                      const char *propq)
+# define PEM_write_cb_ex_fnsig(name, type, OUTTYPE, writename)          \
+    int PEM_##writename##_##name##_ex(OUTTYPE *out, const type *x,      \
+                                      const EVP_CIPHER *enc,            \
+                                      const unsigned char *kstr, int klen, \
+                                      pem_password_cb *cb, void *u,     \
+                                      OSSL_LIB_CTX *libctx,             \
+                                      const char *propq)
+
+# ifdef OPENSSL_NO_STDIO
+
+#  define IMPLEMENT_PEM_read_fp(name, type, str, asn1) /**/
+#  define IMPLEMENT_PEM_write_fp(name, type, str, asn1) /**/
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+#   define IMPLEMENT_PEM_write_fp_const(name, type, str, asn1) /**/
+#  endif
+#  define IMPLEMENT_PEM_write_cb_fp(name, type, str, asn1) /**/
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+#   define IMPLEMENT_PEM_write_cb_fp_const(name, type, str, asn1) /**/
+#  endif
+# else
+
+#  define IMPLEMENT_PEM_read_fp(name, type, str, asn1)                  \
+    type *PEM_read_##name(FILE *fp, type **x, pem_password_cb *cb, void *u) \
+    {                                                                   \
+        return PEM_ASN1_read((d2i_of_void *)d2i_##asn1, str, fp,        \
+                             (void **)x, cb, u);                        \
+    }
+
+#  define IMPLEMENT_PEM_write_fp(name, type, str, asn1)                 \
+    PEM_write_fnsig(name, type, FILE, write)                            \
+    {                                                                   \
+        return PEM_ASN1_write((i2d_of_void *)i2d_##asn1, str, out,      \
+                              x, NULL, NULL, 0, NULL, NULL);            \
+    }
+
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+#   define IMPLEMENT_PEM_write_fp_const(name, type, str, asn1)  \
+    IMPLEMENT_PEM_write_fp(name, type, str, asn1)
+#  endif
+
+#  define IMPLEMENT_PEM_write_cb_fp(name, type, str, asn1)              \
+    PEM_write_cb_fnsig(name, type, FILE, write)                         \
+    {                                                                   \
+        return PEM_ASN1_write((i2d_of_void *)i2d_##asn1, str, out,      \
+                              x, enc, kstr, klen, cb, u);               \
+    }
+
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+#   define IMPLEMENT_PEM_write_cb_fp_const(name, type, str, asn1)       \
+    IMPLEMENT_PEM_write_cb_fp(name, type, str, asn1)
+#  endif
+# endif
+
+# define IMPLEMENT_PEM_read_bio(name, type, str, asn1)                  \
+    type *PEM_read_bio_##name(BIO *bp, type **x,                        \
+                              pem_password_cb *cb, void *u)             \
+    {                                                                   \
+        return PEM_ASN1_read_bio((d2i_of_void *)d2i_##asn1, str, bp,    \
+                                 (void **)x, cb, u);                    \
+    }
+
+# define IMPLEMENT_PEM_write_bio(name, type, str, asn1)                 \
+    PEM_write_fnsig(name, type, BIO, write_bio)                         \
+    {                                                                   \
+        return PEM_ASN1_write_bio((i2d_of_void *)i2d_##asn1, str, out,  \
+                                  x, NULL,NULL,0,NULL,NULL);            \
+    }
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define IMPLEMENT_PEM_write_bio_const(name, type, str, asn1)   \
+    IMPLEMENT_PEM_write_bio(name, type, str, asn1)
+# endif
+
+# define IMPLEMENT_PEM_write_cb_bio(name, type, str, asn1)              \
+    PEM_write_cb_fnsig(name, type, BIO, write_bio)                      \
+    {                                                                   \
+        return PEM_ASN1_write_bio((i2d_of_void *)i2d_##asn1, str, out,  \
+                                  x, enc, kstr, klen, cb, u);           \
+    }
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define IMPLEMENT_PEM_write_cb_bio_const(name, type, str, asn1)  \
+    IMPLEMENT_PEM_write_cb_bio(name, type, str, asn1)
+# endif
+
+# define IMPLEMENT_PEM_write(name, type, str, asn1) \
+        IMPLEMENT_PEM_write_bio(name, type, str, asn1) \
+        IMPLEMENT_PEM_write_fp(name, type, str, asn1)
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define IMPLEMENT_PEM_write_const(name, type, str, asn1) \
+        IMPLEMENT_PEM_write_bio_const(name, type, str, asn1) \
+        IMPLEMENT_PEM_write_fp_const(name, type, str, asn1)
+# endif
+
+# define IMPLEMENT_PEM_write_cb(name, type, str, asn1) \
+        IMPLEMENT_PEM_write_cb_bio(name, type, str, asn1) \
+        IMPLEMENT_PEM_write_cb_fp(name, type, str, asn1)
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define IMPLEMENT_PEM_write_cb_const(name, type, str, asn1) \
+        IMPLEMENT_PEM_write_cb_bio_const(name, type, str, asn1) \
+        IMPLEMENT_PEM_write_cb_fp_const(name, type, str, asn1)
+# endif
+
+# define IMPLEMENT_PEM_read(name, type, str, asn1) \
+        IMPLEMENT_PEM_read_bio(name, type, str, asn1) \
+        IMPLEMENT_PEM_read_fp(name, type, str, asn1)
+
+# define IMPLEMENT_PEM_rw(name, type, str, asn1) \
+        IMPLEMENT_PEM_read(name, type, str, asn1) \
+        IMPLEMENT_PEM_write(name, type, str, asn1)
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define IMPLEMENT_PEM_rw_const(name, type, str, asn1) \
+        IMPLEMENT_PEM_read(name, type, str, asn1) \
+        IMPLEMENT_PEM_write_const(name, type, str, asn1)
+# endif
+
+# define IMPLEMENT_PEM_rw_cb(name, type, str, asn1) \
+        IMPLEMENT_PEM_read(name, type, str, asn1) \
+        IMPLEMENT_PEM_write_cb(name, type, str, asn1)
+
+/* These are the same except they are for the declarations */
+
+/*
+ * The mysterious 'extern' that's passed to some macros is innocuous,
+ * and is there to quiet pre-C99 compilers that may complain about empty
+ * arguments in macro calls.
+ */
+# if defined(OPENSSL_NO_STDIO)
+
+#  define DECLARE_PEM_read_fp_attr(attr, name, type) /**/
+#  define DECLARE_PEM_read_fp_ex_attr(attr, name, type) /**/
+#  define DECLARE_PEM_write_fp_attr(attr, name, type) /**/
+#  define DECLARE_PEM_write_fp_ex_attr(attr, name, type) /**/
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+#   define DECLARE_PEM_write_fp_const_attr(attr, name, type) /**/
+#  endif
+#  define DECLARE_PEM_write_cb_fp_attr(attr, name, type) /**/
+#  define DECLARE_PEM_write_cb_fp_ex_attr(attr, name, type) /**/
+
+# else
+
+#  define DECLARE_PEM_read_fp_attr(attr, name, type)                        \
+    attr PEM_read_cb_fnsig(name, type, FILE, read);
+#  define DECLARE_PEM_read_fp_ex_attr(attr, name, type)                     \
+    attr PEM_read_cb_fnsig(name, type, FILE, read);                         \
+    attr PEM_read_cb_ex_fnsig(name, type, FILE, read);
+
+#  define DECLARE_PEM_write_fp_attr(attr, name, type)                       \
+    attr PEM_write_fnsig(name, type, FILE, write);
+#  define DECLARE_PEM_write_fp_ex_attr(attr, name, type)                    \
+    attr PEM_write_fnsig(name, type, FILE, write);                          \
+    attr PEM_write_ex_fnsig(name, type, FILE, write);
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+#   define DECLARE_PEM_write_fp_const_attr(attr, name, type)                \
+    attr PEM_write_fnsig(name, type, FILE, write);
+#  endif
+#  define DECLARE_PEM_write_cb_fp_attr(attr, name, type)                    \
+    attr PEM_write_cb_fnsig(name, type, FILE, write);
+#  define DECLARE_PEM_write_cb_fp_ex_attr(attr, name, type)                 \
+    attr PEM_write_cb_fnsig(name, type, FILE, write);                       \
+    attr PEM_write_cb_ex_fnsig(name, type, FILE, write);
+
+# endif
+
+# define DECLARE_PEM_read_fp(name, type)                                    \
+    DECLARE_PEM_read_fp_attr(extern, name, type)
+# define DECLARE_PEM_write_fp(name, type)                                   \
+    DECLARE_PEM_write_fp_attr(extern, name, type)
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#   define DECLARE_PEM_write_fp_const(name, type)                           \
+    DECLARE_PEM_write_fp_const_attr(extern, name, type)
+# endif
+# define DECLARE_PEM_write_cb_fp(name, type)                                \
+    DECLARE_PEM_write_cb_fp_attr(extern, name, type)
+
+#  define DECLARE_PEM_read_bio_attr(attr, name, type)                       \
+    attr PEM_read_cb_fnsig(name, type, BIO, read_bio);
+#  define DECLARE_PEM_read_bio_ex_attr(attr, name, type)                    \
+    attr PEM_read_cb_fnsig(name, type, BIO, read_bio);                      \
+    attr PEM_read_cb_ex_fnsig(name, type, BIO, read_bio);
+# define DECLARE_PEM_read_bio(name, type)                                   \
+    DECLARE_PEM_read_bio_attr(extern, name, type)
+# define DECLARE_PEM_read_bio_ex(name, type)                                \
+    DECLARE_PEM_read_bio_ex_attr(extern, name, type)
+
+# define DECLARE_PEM_write_bio_attr(attr, name, type)                       \
+    attr PEM_write_fnsig(name, type, BIO, write_bio);
+# define DECLARE_PEM_write_bio_ex_attr(attr, name, type)                    \
+    attr PEM_write_fnsig(name, type, BIO, write_bio);                       \
+    attr PEM_write_ex_fnsig(name, type, BIO, write_bio);
+# define DECLARE_PEM_write_bio(name, type)                                  \
+    DECLARE_PEM_write_bio_attr(extern, name, type)
+# define DECLARE_PEM_write_bio_ex(name, type)                               \
+    DECLARE_PEM_write_bio_ex_attr(extern, name, type)
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define DECLARE_PEM_write_bio_const_attr(attr, name, type)                \
+    attr PEM_write_fnsig(name, type, BIO, write_bio);
+#  define DECLARE_PEM_write_bio_const(name, type)      \
+    DECLARE_PEM_write_bio_const_attr(extern, name, type)
+# endif
+
+# define DECLARE_PEM_write_cb_bio_attr(attr, name, type)                    \
+    attr PEM_write_cb_fnsig(name, type, BIO, write_bio);
+# define DECLARE_PEM_write_cb_bio_ex_attr(attr, name, type)                 \
+    attr PEM_write_cb_fnsig(name, type, BIO, write_bio);                    \
+    attr PEM_write_cb_ex_fnsig(name, type, BIO, write_bio);
+# define DECLARE_PEM_write_cb_bio(name, type)                               \
+    DECLARE_PEM_write_cb_bio_attr(extern, name, type)
+# define DECLARE_PEM_write_cb_ex_bio(name, type)                            \
+    DECLARE_PEM_write_cb_bio_ex_attr(extern, name, type)
+
+# define DECLARE_PEM_write_attr(attr, name, type)                           \
+    DECLARE_PEM_write_bio_attr(attr, name, type)                            \
+    DECLARE_PEM_write_fp_attr(attr, name, type)
+# define DECLARE_PEM_write_ex_attr(attr, name, type)                        \
+    DECLARE_PEM_write_bio_ex_attr(attr, name, type)                         \
+    DECLARE_PEM_write_fp_ex_attr(attr, name, type)
+# define DECLARE_PEM_write(name, type) \
+    DECLARE_PEM_write_attr(extern, name, type)
+# define DECLARE_PEM_write_ex(name, type) \
+    DECLARE_PEM_write_ex_attr(extern, name, type)
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define DECLARE_PEM_write_const_attr(attr, name, type)                    \
+    DECLARE_PEM_write_bio_const_attr(attr, name, type)                      \
+    DECLARE_PEM_write_fp_const_attr(attr, name, type)
+#  define DECLARE_PEM_write_const(name, type)                               \
+    DECLARE_PEM_write_const_attr(extern, name, type)
+# endif
+# define DECLARE_PEM_write_cb_attr(attr, name, type)                        \
+    DECLARE_PEM_write_cb_bio_attr(attr, name, type)                         \
+    DECLARE_PEM_write_cb_fp_attr(attr, name, type)
+# define DECLARE_PEM_write_cb_ex_attr(attr, name, type)                     \
+    DECLARE_PEM_write_cb_bio_ex_attr(attr, name, type)                      \
+    DECLARE_PEM_write_cb_fp_ex_attr(attr, name, type)
+# define DECLARE_PEM_write_cb(name, type)                                   \
+    DECLARE_PEM_write_cb_attr(extern, name, type)
+# define DECLARE_PEM_write_cb_ex(name, type)                                \
+    DECLARE_PEM_write_cb_ex_attr(extern, name, type)
+# define DECLARE_PEM_read_attr(attr, name, type)                            \
+    DECLARE_PEM_read_bio_attr(attr, name, type)                             \
+    DECLARE_PEM_read_fp_attr(attr, name, type)
+# define DECLARE_PEM_read_ex_attr(attr, name, type)                         \
+    DECLARE_PEM_read_bio_ex_attr(attr, name, type)                          \
+    DECLARE_PEM_read_fp_ex_attr(attr, name, type)
+# define DECLARE_PEM_read(name, type)                                       \
+    DECLARE_PEM_read_attr(extern, name, type)
+# define DECLARE_PEM_read_ex(name, type)                                    \
+    DECLARE_PEM_read_ex_attr(extern, name, type)
+# define DECLARE_PEM_rw_attr(attr, name, type)                              \
+    DECLARE_PEM_read_attr(attr, name, type)                                 \
+    DECLARE_PEM_write_attr(attr, name, type)
+# define DECLARE_PEM_rw_ex_attr(attr, name, type)                           \
+    DECLARE_PEM_read_ex_attr(attr, name, type)                              \
+    DECLARE_PEM_write_ex_attr(attr, name, type)
+# define DECLARE_PEM_rw(name, type) \
+    DECLARE_PEM_rw_attr(extern, name, type)
+# define DECLARE_PEM_rw_ex(name, type) \
+    DECLARE_PEM_rw_ex_attr(extern, name, type)
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define DECLARE_PEM_rw_const_attr(attr, name, type)                       \
+    DECLARE_PEM_read_attr(attr, name, type)                                 \
+    DECLARE_PEM_write_const_attr(attr, name, type)
+#  define DECLARE_PEM_rw_const(name, type) \
+    DECLARE_PEM_rw_const_attr(extern, name, type)
+# endif
+# define DECLARE_PEM_rw_cb_attr(attr, name, type)                           \
+    DECLARE_PEM_read_attr(attr, name, type)                                 \
+    DECLARE_PEM_write_cb_attr(attr, name, type)
+# define DECLARE_PEM_rw_cb_ex_attr(attr, name, type)                        \
+    DECLARE_PEM_read_ex_attr(attr, name, type)                              \
+    DECLARE_PEM_write_cb_ex_attr(attr, name, type)
+# define DECLARE_PEM_rw_cb(name, type) \
+    DECLARE_PEM_rw_cb_attr(extern, name, type)
+# define DECLARE_PEM_rw_cb_ex(name, type) \
+    DECLARE_PEM_rw_cb_ex_attr(extern, name, type)
+
+int PEM_get_EVP_CIPHER_INFO(char *header, EVP_CIPHER_INFO *cipher);
+int PEM_do_header(EVP_CIPHER_INFO *cipher, unsigned char *data, long *len,
+                  pem_password_cb *callback, void *u);
+
+int PEM_read_bio(BIO *bp, char **name, char **header,
+                 unsigned char **data, long *len);
+#   define PEM_FLAG_SECURE             0x1
+#   define PEM_FLAG_EAY_COMPATIBLE     0x2
+#   define PEM_FLAG_ONLY_B64           0x4
+int PEM_read_bio_ex(BIO *bp, char **name, char **header,
+                    unsigned char **data, long *len, unsigned int flags);
+int PEM_bytes_read_bio_secmem(unsigned char **pdata, long *plen, char **pnm,
+                              const char *name, BIO *bp, pem_password_cb *cb,
+                              void *u);
+int PEM_write_bio(BIO *bp, const char *name, const char *hdr,
+                  const unsigned char *data, long len);
+int PEM_bytes_read_bio(unsigned char **pdata, long *plen, char **pnm,
+                       const char *name, BIO *bp, pem_password_cb *cb,
+                       void *u);
+void *PEM_ASN1_read_bio(d2i_of_void *d2i, const char *name, BIO *bp, void **x,
+                        pem_password_cb *cb, void *u);
+int PEM_ASN1_write_bio(i2d_of_void *i2d, const char *name, BIO *bp,
+                       const void *x, const EVP_CIPHER *enc,
+                       const unsigned char *kstr, int klen,
+                       pem_password_cb *cb, void *u);
+
+STACK_OF(X509_INFO) *PEM_X509_INFO_read_bio(BIO *bp, STACK_OF(X509_INFO) *sk,
+                                            pem_password_cb *cb, void *u);
+STACK_OF(X509_INFO)
+*PEM_X509_INFO_read_bio_ex(BIO *bp, STACK_OF(X509_INFO) *sk,
+                           pem_password_cb *cb, void *u, OSSL_LIB_CTX *libctx,
+                           const char *propq);
+
+int PEM_X509_INFO_write_bio(BIO *bp, const X509_INFO *xi, EVP_CIPHER *enc,
+                            const unsigned char *kstr, int klen,
+                            pem_password_cb *cd, void *u);
+
+#ifndef OPENSSL_NO_STDIO
+int PEM_read(FILE *fp, char **name, char **header,
+             unsigned char **data, long *len);
+int PEM_write(FILE *fp, const char *name, const char *hdr,
+              const unsigned char *data, long len);
+void *PEM_ASN1_read(d2i_of_void *d2i, const char *name, FILE *fp, void **x,
+                    pem_password_cb *cb, void *u);
+int PEM_ASN1_write(i2d_of_void *i2d, const char *name, FILE *fp,
+                   const void *x, const EVP_CIPHER *enc,
+                   const unsigned char *kstr, int klen,
+                   pem_password_cb *callback, void *u);
+STACK_OF(X509_INFO) *PEM_X509_INFO_read(FILE *fp, STACK_OF(X509_INFO) *sk,
+                                        pem_password_cb *cb, void *u);
+STACK_OF(X509_INFO)
+*PEM_X509_INFO_read_ex(FILE *fp, STACK_OF(X509_INFO) *sk, pem_password_cb *cb,
+                       void *u, OSSL_LIB_CTX *libctx, const char *propq);
+#endif
+
+int PEM_SignInit(EVP_MD_CTX *ctx, EVP_MD *type);
+int PEM_SignUpdate(EVP_MD_CTX *ctx, const unsigned char *d, unsigned int cnt);
+int PEM_SignFinal(EVP_MD_CTX *ctx, unsigned char *sigret,
+                  unsigned int *siglen, EVP_PKEY *pkey);
+
+/* The default pem_password_cb that's used internally */
+int PEM_def_callback(char *buf, int num, int rwflag, void *userdata);
+void PEM_proc_type(char *buf, int type);
+void PEM_dek_info(char *buf, const char *type, int len, const char *str);
+
+# include <openssl/symhacks.h>
+
+DECLARE_PEM_rw(X509, X509)
+DECLARE_PEM_rw(X509_AUX, X509)
+DECLARE_PEM_rw(X509_REQ, X509_REQ)
+DECLARE_PEM_write(X509_REQ_NEW, X509_REQ)
+DECLARE_PEM_rw(X509_CRL, X509_CRL)
+DECLARE_PEM_rw(X509_PUBKEY, X509_PUBKEY)
+DECLARE_PEM_rw(PKCS7, PKCS7)
+DECLARE_PEM_rw(NETSCAPE_CERT_SEQUENCE, NETSCAPE_CERT_SEQUENCE)
+DECLARE_PEM_rw(PKCS8, X509_SIG)
+DECLARE_PEM_rw(PKCS8_PRIV_KEY_INFO, PKCS8_PRIV_KEY_INFO)
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+DECLARE_PEM_rw_cb_attr(OSSL_DEPRECATEDIN_3_0, RSAPrivateKey, RSA)
+DECLARE_PEM_rw_attr(OSSL_DEPRECATEDIN_3_0, RSAPublicKey, RSA)
+DECLARE_PEM_rw_attr(OSSL_DEPRECATEDIN_3_0, RSA_PUBKEY, RSA)
+# endif
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  ifndef OPENSSL_NO_DSA
+DECLARE_PEM_rw_cb_attr(OSSL_DEPRECATEDIN_3_0, DSAPrivateKey, DSA)
+DECLARE_PEM_rw_attr(OSSL_DEPRECATEDIN_3_0, DSA_PUBKEY, DSA)
+DECLARE_PEM_rw_attr(OSSL_DEPRECATEDIN_3_0, DSAparams, DSA)
+#  endif
+# endif
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  ifndef OPENSSL_NO_EC
+DECLARE_PEM_rw_attr(OSSL_DEPRECATEDIN_3_0, ECPKParameters, EC_GROUP)
+DECLARE_PEM_rw_cb_attr(OSSL_DEPRECATEDIN_3_0, ECPrivateKey, EC_KEY)
+DECLARE_PEM_rw_attr(OSSL_DEPRECATEDIN_3_0, EC_PUBKEY, EC_KEY)
+#  endif
+# endif
+
+# ifndef OPENSSL_NO_DH
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+DECLARE_PEM_rw_attr(OSSL_DEPRECATEDIN_3_0, DHparams, DH)
+DECLARE_PEM_write_attr(OSSL_DEPRECATEDIN_3_0, DHxparams, DH)
+#  endif
+# endif
+DECLARE_PEM_rw_cb_ex(PrivateKey, EVP_PKEY)
+DECLARE_PEM_rw_ex(PUBKEY, EVP_PKEY)
+
+int PEM_write_bio_PrivateKey_traditional(BIO *bp, const EVP_PKEY *x,
+                                         const EVP_CIPHER *enc,
+                                         const unsigned char *kstr, int klen,
+                                         pem_password_cb *cb, void *u);
+
+/* Why do these take a signed char *kstr? */
+int PEM_write_bio_PKCS8PrivateKey_nid(BIO *bp, const EVP_PKEY *x, int nid,
+                                      const char *kstr, int klen,
+                                      pem_password_cb *cb, void *u);
+int PEM_write_bio_PKCS8PrivateKey(BIO *, const EVP_PKEY *, const EVP_CIPHER *,
+                                  const char *kstr, int klen,
+                                  pem_password_cb *cb, void *u);
+int i2d_PKCS8PrivateKey_bio(BIO *bp, const EVP_PKEY *x, const EVP_CIPHER *enc,
+                            const char *kstr, int klen,
+                            pem_password_cb *cb, void *u);
+int i2d_PKCS8PrivateKey_nid_bio(BIO *bp, const EVP_PKEY *x, int nid,
+                                const char *kstr, int klen,
+                                pem_password_cb *cb, void *u);
+EVP_PKEY *d2i_PKCS8PrivateKey_bio(BIO *bp, EVP_PKEY **x, pem_password_cb *cb,
+                                  void *u);
+
+# ifndef OPENSSL_NO_STDIO
+int i2d_PKCS8PrivateKey_fp(FILE *fp, const EVP_PKEY *x, const EVP_CIPHER *enc,
+                           const char *kstr, int klen,
+                           pem_password_cb *cb, void *u);
+int i2d_PKCS8PrivateKey_nid_fp(FILE *fp, const EVP_PKEY *x, int nid,
+                               const char *kstr, int klen,
+                               pem_password_cb *cb, void *u);
+int PEM_write_PKCS8PrivateKey_nid(FILE *fp, const EVP_PKEY *x, int nid,
+                                  const char *kstr, int klen,
+                                  pem_password_cb *cb, void *u);
+
+EVP_PKEY *d2i_PKCS8PrivateKey_fp(FILE *fp, EVP_PKEY **x, pem_password_cb *cb,
+                                 void *u);
+
+int PEM_write_PKCS8PrivateKey(FILE *fp, const EVP_PKEY *x, const EVP_CIPHER *enc,
+                              const char *kstr, int klen,
+                              pem_password_cb *cd, void *u);
+# endif
+EVP_PKEY *PEM_read_bio_Parameters_ex(BIO *bp, EVP_PKEY **x,
+                                     OSSL_LIB_CTX *libctx, const char *propq);
+EVP_PKEY *PEM_read_bio_Parameters(BIO *bp, EVP_PKEY **x);
+int PEM_write_bio_Parameters(BIO *bp, const EVP_PKEY *x);
+
+EVP_PKEY *b2i_PrivateKey(const unsigned char **in, long length);
+EVP_PKEY *b2i_PublicKey(const unsigned char **in, long length);
+EVP_PKEY *b2i_PrivateKey_bio(BIO *in);
+EVP_PKEY *b2i_PublicKey_bio(BIO *in);
+int i2b_PrivateKey_bio(BIO *out, const EVP_PKEY *pk);
+int i2b_PublicKey_bio(BIO *out, const EVP_PKEY *pk);
+EVP_PKEY *b2i_PVK_bio(BIO *in, pem_password_cb *cb, void *u);
+EVP_PKEY *b2i_PVK_bio_ex(BIO *in, pem_password_cb *cb, void *u,
+                         OSSL_LIB_CTX *libctx, const char *propq);
+int i2b_PVK_bio(BIO *out, const EVP_PKEY *pk, int enclevel,
+                pem_password_cb *cb, void *u);
+int i2b_PVK_bio_ex(BIO *out, const EVP_PKEY *pk, int enclevel,
+                   pem_password_cb *cb, void *u,
+                   OSSL_LIB_CTX *libctx, const char *propq);
+
+# ifdef  __cplusplus
+}
+# endif
+#endif
diff --git a/src/include/openssl/pem2.h b/src/include/openssl/pem2.h
new file mode 100644
index 0000000..a8a5325
--- /dev/null
+++ b/src/include/openssl/pem2.h
@@ -0,0 +1,19 @@
+/*
+ * Copyright 1999-2018 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_PEM2_H
+# define OPENSSL_PEM2_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_PEM2_H
+# endif
+# include <openssl/pemerr.h>
+#endif
diff --git a/src/include/openssl/pemerr.h b/src/include/openssl/pemerr.h
new file mode 100644
index 0000000..18f6d9e
--- /dev/null
+++ b/src/include/openssl/pemerr.h
@@ -0,0 +1,58 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_PEMERR_H
+# define OPENSSL_PEMERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+
+/*
+ * PEM reason codes.
+ */
+# define PEM_R_BAD_BASE64_DECODE                          100
+# define PEM_R_BAD_DECRYPT                                101
+# define PEM_R_BAD_END_LINE                               102
+# define PEM_R_BAD_IV_CHARS                               103
+# define PEM_R_BAD_MAGIC_NUMBER                           116
+# define PEM_R_BAD_PASSWORD_READ                          104
+# define PEM_R_BAD_VERSION_NUMBER                         117
+# define PEM_R_BIO_WRITE_FAILURE                          118
+# define PEM_R_CIPHER_IS_NULL                             127
+# define PEM_R_ERROR_CONVERTING_PRIVATE_KEY               115
+# define PEM_R_EXPECTING_DSS_KEY_BLOB                     131
+# define PEM_R_EXPECTING_PRIVATE_KEY_BLOB                 119
+# define PEM_R_EXPECTING_PUBLIC_KEY_BLOB                  120
+# define PEM_R_EXPECTING_RSA_KEY_BLOB                     132
+# define PEM_R_HEADER_TOO_LONG                            128
+# define PEM_R_INCONSISTENT_HEADER                        121
+# define PEM_R_KEYBLOB_HEADER_PARSE_ERROR                 122
+# define PEM_R_KEYBLOB_TOO_SHORT                          123
+# define PEM_R_MISSING_DEK_IV                             129
+# define PEM_R_NOT_DEK_INFO                               105
+# define PEM_R_NOT_ENCRYPTED                              106
+# define PEM_R_NOT_PROC_TYPE                              107
+# define PEM_R_NO_START_LINE                              108
+# define PEM_R_PROBLEMS_GETTING_PASSWORD                  109
+# define PEM_R_PVK_DATA_TOO_SHORT                         124
+# define PEM_R_PVK_TOO_SHORT                              125
+# define PEM_R_READ_KEY                                   111
+# define PEM_R_SHORT_HEADER                               112
+# define PEM_R_UNEXPECTED_DEK_IV                          130
+# define PEM_R_UNSUPPORTED_CIPHER                         113
+# define PEM_R_UNSUPPORTED_ENCRYPTION                     114
+# define PEM_R_UNSUPPORTED_KEY_COMPONENTS                 126
+# define PEM_R_UNSUPPORTED_PUBLIC_KEY_TYPE                110
+
+#endif
diff --git a/src/include/openssl/pkcs12.h b/src/include/openssl/pkcs12.h
new file mode 100644
index 0000000..ebb2e74
--- /dev/null
+++ b/src/include/openssl/pkcs12.h
@@ -0,0 +1,363 @@
+/*
+ * WARNING: do not edit!
+ * Generated by makefile from include\openssl\pkcs12.h.in
+ *
+ * Copyright 1999-2023 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+
+
+#ifndef OPENSSL_PKCS12_H
+# define OPENSSL_PKCS12_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_PKCS12_H
+# endif
+
+# include <openssl/bio.h>
+# include <openssl/core.h>
+# include <openssl/x509.h>
+# include <openssl/pkcs12err.h>
+# ifndef OPENSSL_NO_STDIO
+#  include <stdio.h>
+# endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+# define PKCS12_KEY_ID   1
+# define PKCS12_IV_ID    2
+# define PKCS12_MAC_ID   3
+
+/* Default iteration count */
+# ifndef PKCS12_DEFAULT_ITER
+#  define PKCS12_DEFAULT_ITER     PKCS5_DEFAULT_ITER
+# endif
+
+# define PKCS12_MAC_KEY_LENGTH 20
+
+/* The macro is expected to be used only internally. Kept for backwards compatibility. */
+# define PKCS12_SALT_LEN 8
+
+/* It's not clear if these are actually needed... */
+# define PKCS12_key_gen PKCS12_key_gen_utf8
+# define PKCS12_add_friendlyname PKCS12_add_friendlyname_utf8
+
+/* MS key usage constants */
+
+# define KEY_EX  0x10
+# define KEY_SIG 0x80
+
+typedef struct PKCS12_MAC_DATA_st PKCS12_MAC_DATA;
+
+typedef struct PKCS12_st PKCS12;
+
+typedef struct PKCS12_SAFEBAG_st PKCS12_SAFEBAG;
+
+SKM_DEFINE_STACK_OF_INTERNAL(PKCS12_SAFEBAG, PKCS12_SAFEBAG, PKCS12_SAFEBAG)
+#define sk_PKCS12_SAFEBAG_num(sk) OPENSSL_sk_num(ossl_check_const_PKCS12_SAFEBAG_sk_type(sk))
+#define sk_PKCS12_SAFEBAG_value(sk, idx) ((PKCS12_SAFEBAG *)OPENSSL_sk_value(ossl_check_const_PKCS12_SAFEBAG_sk_type(sk), (idx)))
+#define sk_PKCS12_SAFEBAG_new(cmp) ((STACK_OF(PKCS12_SAFEBAG) *)OPENSSL_sk_new(ossl_check_PKCS12_SAFEBAG_compfunc_type(cmp)))
+#define sk_PKCS12_SAFEBAG_new_null() ((STACK_OF(PKCS12_SAFEBAG) *)OPENSSL_sk_new_null())
+#define sk_PKCS12_SAFEBAG_new_reserve(cmp, n) ((STACK_OF(PKCS12_SAFEBAG) *)OPENSSL_sk_new_reserve(ossl_check_PKCS12_SAFEBAG_compfunc_type(cmp), (n)))
+#define sk_PKCS12_SAFEBAG_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_PKCS12_SAFEBAG_sk_type(sk), (n))
+#define sk_PKCS12_SAFEBAG_free(sk) OPENSSL_sk_free(ossl_check_PKCS12_SAFEBAG_sk_type(sk))
+#define sk_PKCS12_SAFEBAG_zero(sk) OPENSSL_sk_zero(ossl_check_PKCS12_SAFEBAG_sk_type(sk))
+#define sk_PKCS12_SAFEBAG_delete(sk, i) ((PKCS12_SAFEBAG *)OPENSSL_sk_delete(ossl_check_PKCS12_SAFEBAG_sk_type(sk), (i)))
+#define sk_PKCS12_SAFEBAG_delete_ptr(sk, ptr) ((PKCS12_SAFEBAG *)OPENSSL_sk_delete_ptr(ossl_check_PKCS12_SAFEBAG_sk_type(sk), ossl_check_PKCS12_SAFEBAG_type(ptr)))
+#define sk_PKCS12_SAFEBAG_push(sk, ptr) OPENSSL_sk_push(ossl_check_PKCS12_SAFEBAG_sk_type(sk), ossl_check_PKCS12_SAFEBAG_type(ptr))
+#define sk_PKCS12_SAFEBAG_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_PKCS12_SAFEBAG_sk_type(sk), ossl_check_PKCS12_SAFEBAG_type(ptr))
+#define sk_PKCS12_SAFEBAG_pop(sk) ((PKCS12_SAFEBAG *)OPENSSL_sk_pop(ossl_check_PKCS12_SAFEBAG_sk_type(sk)))
+#define sk_PKCS12_SAFEBAG_shift(sk) ((PKCS12_SAFEBAG *)OPENSSL_sk_shift(ossl_check_PKCS12_SAFEBAG_sk_type(sk)))
+#define sk_PKCS12_SAFEBAG_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_PKCS12_SAFEBAG_sk_type(sk),ossl_check_PKCS12_SAFEBAG_freefunc_type(freefunc))
+#define sk_PKCS12_SAFEBAG_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_PKCS12_SAFEBAG_sk_type(sk), ossl_check_PKCS12_SAFEBAG_type(ptr), (idx))
+#define sk_PKCS12_SAFEBAG_set(sk, idx, ptr) ((PKCS12_SAFEBAG *)OPENSSL_sk_set(ossl_check_PKCS12_SAFEBAG_sk_type(sk), (idx), ossl_check_PKCS12_SAFEBAG_type(ptr)))
+#define sk_PKCS12_SAFEBAG_find(sk, ptr) OPENSSL_sk_find(ossl_check_PKCS12_SAFEBAG_sk_type(sk), ossl_check_PKCS12_SAFEBAG_type(ptr))
+#define sk_PKCS12_SAFEBAG_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_PKCS12_SAFEBAG_sk_type(sk), ossl_check_PKCS12_SAFEBAG_type(ptr))
+#define sk_PKCS12_SAFEBAG_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_PKCS12_SAFEBAG_sk_type(sk), ossl_check_PKCS12_SAFEBAG_type(ptr), pnum)
+#define sk_PKCS12_SAFEBAG_sort(sk) OPENSSL_sk_sort(ossl_check_PKCS12_SAFEBAG_sk_type(sk))
+#define sk_PKCS12_SAFEBAG_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_PKCS12_SAFEBAG_sk_type(sk))
+#define sk_PKCS12_SAFEBAG_dup(sk) ((STACK_OF(PKCS12_SAFEBAG) *)OPENSSL_sk_dup(ossl_check_const_PKCS12_SAFEBAG_sk_type(sk)))
+#define sk_PKCS12_SAFEBAG_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(PKCS12_SAFEBAG) *)OPENSSL_sk_deep_copy(ossl_check_const_PKCS12_SAFEBAG_sk_type(sk), ossl_check_PKCS12_SAFEBAG_copyfunc_type(copyfunc), ossl_check_PKCS12_SAFEBAG_freefunc_type(freefunc)))
+#define sk_PKCS12_SAFEBAG_set_cmp_func(sk, cmp) ((sk_PKCS12_SAFEBAG_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_PKCS12_SAFEBAG_sk_type(sk), ossl_check_PKCS12_SAFEBAG_compfunc_type(cmp)))
+
+
+typedef struct pkcs12_bag_st PKCS12_BAGS;
+
+# define PKCS12_ERROR    0
+# define PKCS12_OK       1
+
+/* Compatibility macros */
+
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+
+# define M_PKCS12_bag_type PKCS12_bag_type
+# define M_PKCS12_cert_bag_type PKCS12_cert_bag_type
+# define M_PKCS12_crl_bag_type PKCS12_cert_bag_type
+
+# define PKCS12_certbag2x509 PKCS12_SAFEBAG_get1_cert
+# define PKCS12_certbag2scrl PKCS12_SAFEBAG_get1_crl
+# define PKCS12_bag_type PKCS12_SAFEBAG_get_nid
+# define PKCS12_cert_bag_type PKCS12_SAFEBAG_get_bag_nid
+# define PKCS12_x5092certbag PKCS12_SAFEBAG_create_cert
+# define PKCS12_x509crl2certbag PKCS12_SAFEBAG_create_crl
+# define PKCS12_MAKE_KEYBAG PKCS12_SAFEBAG_create0_p8inf
+# define PKCS12_MAKE_SHKEYBAG PKCS12_SAFEBAG_create_pkcs8_encrypt
+
+#endif
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+OSSL_DEPRECATEDIN_1_1_0 ASN1_TYPE *PKCS12_get_attr(const PKCS12_SAFEBAG *bag,
+                                                   int attr_nid);
+#endif
+
+ASN1_TYPE *PKCS8_get_attr(PKCS8_PRIV_KEY_INFO *p8, int attr_nid);
+int PKCS12_mac_present(const PKCS12 *p12);
+void PKCS12_get0_mac(const ASN1_OCTET_STRING **pmac,
+                     const X509_ALGOR **pmacalg,
+                     const ASN1_OCTET_STRING **psalt,
+                     const ASN1_INTEGER **piter,
+                     const PKCS12 *p12);
+
+const ASN1_TYPE *PKCS12_SAFEBAG_get0_attr(const PKCS12_SAFEBAG *bag,
+                                          int attr_nid);
+const ASN1_OBJECT *PKCS12_SAFEBAG_get0_type(const PKCS12_SAFEBAG *bag);
+int PKCS12_SAFEBAG_get_nid(const PKCS12_SAFEBAG *bag);
+int PKCS12_SAFEBAG_get_bag_nid(const PKCS12_SAFEBAG *bag);
+const ASN1_TYPE *PKCS12_SAFEBAG_get0_bag_obj(const PKCS12_SAFEBAG *bag);
+const ASN1_OBJECT *PKCS12_SAFEBAG_get0_bag_type(const PKCS12_SAFEBAG *bag);
+
+X509 *PKCS12_SAFEBAG_get1_cert_ex(const PKCS12_SAFEBAG *bag, OSSL_LIB_CTX *libctx, const char *propq);
+X509 *PKCS12_SAFEBAG_get1_cert(const PKCS12_SAFEBAG *bag);
+X509_CRL *PKCS12_SAFEBAG_get1_crl_ex(const PKCS12_SAFEBAG *bag, OSSL_LIB_CTX *libctx, const char *propq);
+X509_CRL *PKCS12_SAFEBAG_get1_crl(const PKCS12_SAFEBAG *bag);
+const STACK_OF(PKCS12_SAFEBAG) *
+PKCS12_SAFEBAG_get0_safes(const PKCS12_SAFEBAG *bag);
+const PKCS8_PRIV_KEY_INFO *PKCS12_SAFEBAG_get0_p8inf(const PKCS12_SAFEBAG *bag);
+const X509_SIG *PKCS12_SAFEBAG_get0_pkcs8(const PKCS12_SAFEBAG *bag);
+
+PKCS12_SAFEBAG *PKCS12_SAFEBAG_create_cert(X509 *x509);
+PKCS12_SAFEBAG *PKCS12_SAFEBAG_create_crl(X509_CRL *crl);
+PKCS12_SAFEBAG *PKCS12_SAFEBAG_create_secret(int type, int vtype, const unsigned char *value, int len);
+PKCS12_SAFEBAG *PKCS12_SAFEBAG_create0_p8inf(PKCS8_PRIV_KEY_INFO *p8);
+PKCS12_SAFEBAG *PKCS12_SAFEBAG_create0_pkcs8(X509_SIG *p8);
+PKCS12_SAFEBAG *PKCS12_SAFEBAG_create_pkcs8_encrypt(int pbe_nid,
+                                                    const char *pass,
+                                                    int passlen,
+                                                    unsigned char *salt,
+                                                    int saltlen, int iter,
+                                                    PKCS8_PRIV_KEY_INFO *p8inf);
+PKCS12_SAFEBAG *PKCS12_SAFEBAG_create_pkcs8_encrypt_ex(int pbe_nid,
+                                                       const char *pass,
+                                                       int passlen,
+                                                       unsigned char *salt,
+                                                       int saltlen, int iter,
+                                                       PKCS8_PRIV_KEY_INFO *p8inf,
+                                                       OSSL_LIB_CTX *ctx,
+                                                       const char *propq);
+
+PKCS12_SAFEBAG *PKCS12_item_pack_safebag(void *obj, const ASN1_ITEM *it,
+                                         int nid1, int nid2);
+PKCS8_PRIV_KEY_INFO *PKCS8_decrypt(const X509_SIG *p8, const char *pass,
+                                   int passlen);
+PKCS8_PRIV_KEY_INFO *PKCS8_decrypt_ex(const X509_SIG *p8, const char *pass,
+                                      int passlen, OSSL_LIB_CTX *ctx,
+                                      const char *propq);
+PKCS8_PRIV_KEY_INFO *PKCS12_decrypt_skey(const PKCS12_SAFEBAG *bag,
+                                         const char *pass, int passlen);
+PKCS8_PRIV_KEY_INFO *PKCS12_decrypt_skey_ex(const PKCS12_SAFEBAG *bag,
+                                            const char *pass, int passlen,
+                                            OSSL_LIB_CTX *ctx,
+                                            const char *propq);
+X509_SIG *PKCS8_encrypt(int pbe_nid, const EVP_CIPHER *cipher,
+                        const char *pass, int passlen, unsigned char *salt,
+                        int saltlen, int iter, PKCS8_PRIV_KEY_INFO *p8);
+X509_SIG *PKCS8_encrypt_ex(int pbe_nid, const EVP_CIPHER *cipher,
+                           const char *pass, int passlen, unsigned char *salt,
+                           int saltlen, int iter, PKCS8_PRIV_KEY_INFO *p8,
+                           OSSL_LIB_CTX *ctx, const char *propq);
+X509_SIG *PKCS8_set0_pbe(const char *pass, int passlen,
+                        PKCS8_PRIV_KEY_INFO *p8inf, X509_ALGOR *pbe);
+X509_SIG *PKCS8_set0_pbe_ex(const char *pass, int passlen,
+                            PKCS8_PRIV_KEY_INFO *p8inf, X509_ALGOR *pbe,
+                            OSSL_LIB_CTX *ctx, const char *propq);
+PKCS7 *PKCS12_pack_p7data(STACK_OF(PKCS12_SAFEBAG) *sk);
+STACK_OF(PKCS12_SAFEBAG) *PKCS12_unpack_p7data(PKCS7 *p7);
+PKCS7 *PKCS12_pack_p7encdata(int pbe_nid, const char *pass, int passlen,
+                             unsigned char *salt, int saltlen, int iter,
+                             STACK_OF(PKCS12_SAFEBAG) *bags);
+PKCS7 *PKCS12_pack_p7encdata_ex(int pbe_nid, const char *pass, int passlen,
+                                unsigned char *salt, int saltlen, int iter,
+                                STACK_OF(PKCS12_SAFEBAG) *bags,
+                                OSSL_LIB_CTX *ctx, const char *propq);
+
+STACK_OF(PKCS12_SAFEBAG) *PKCS12_unpack_p7encdata(PKCS7 *p7, const char *pass,
+                                                  int passlen);
+
+int PKCS12_pack_authsafes(PKCS12 *p12, STACK_OF(PKCS7) *safes);
+STACK_OF(PKCS7) *PKCS12_unpack_authsafes(const PKCS12 *p12);
+
+int PKCS12_add_localkeyid(PKCS12_SAFEBAG *bag, unsigned char *name,
+                          int namelen);
+int PKCS12_add_friendlyname_asc(PKCS12_SAFEBAG *bag, const char *name,
+                                int namelen);
+int PKCS12_add_friendlyname_utf8(PKCS12_SAFEBAG *bag, const char *name,
+                                 int namelen);
+int PKCS12_add_CSPName_asc(PKCS12_SAFEBAG *bag, const char *name,
+                           int namelen);
+int PKCS12_add_friendlyname_uni(PKCS12_SAFEBAG *bag,
+                                const unsigned char *name, int namelen);
+int PKCS12_add1_attr_by_NID(PKCS12_SAFEBAG *bag, int nid, int type,
+                            const unsigned char *bytes, int len);
+int PKCS12_add1_attr_by_txt(PKCS12_SAFEBAG *bag, const char *attrname, int type,
+                            const unsigned char *bytes, int len);
+int PKCS8_add_keyusage(PKCS8_PRIV_KEY_INFO *p8, int usage);
+ASN1_TYPE *PKCS12_get_attr_gen(const STACK_OF(X509_ATTRIBUTE) *attrs,
+                               int attr_nid);
+char *PKCS12_get_friendlyname(PKCS12_SAFEBAG *bag);
+const STACK_OF(X509_ATTRIBUTE) *
+PKCS12_SAFEBAG_get0_attrs(const PKCS12_SAFEBAG *bag);
+void PKCS12_SAFEBAG_set0_attrs(PKCS12_SAFEBAG *bag, STACK_OF(X509_ATTRIBUTE) *attrs);
+unsigned char *PKCS12_pbe_crypt(const X509_ALGOR *algor,
+                                const char *pass, int passlen,
+                                const unsigned char *in, int inlen,
+                                unsigned char **data, int *datalen,
+                                int en_de);
+unsigned char *PKCS12_pbe_crypt_ex(const X509_ALGOR *algor,
+                                   const char *pass, int passlen,
+                                   const unsigned char *in, int inlen,
+                                   unsigned char **data, int *datalen,
+                                   int en_de, OSSL_LIB_CTX *libctx,
+                                   const char *propq);
+void *PKCS12_item_decrypt_d2i(const X509_ALGOR *algor, const ASN1_ITEM *it,
+                              const char *pass, int passlen,
+                              const ASN1_OCTET_STRING *oct, int zbuf);
+void *PKCS12_item_decrypt_d2i_ex(const X509_ALGOR *algor, const ASN1_ITEM *it,
+                                 const char *pass, int passlen,
+                                 const ASN1_OCTET_STRING *oct, int zbuf,
+                                 OSSL_LIB_CTX *libctx, 
+                                 const char *propq);
+ASN1_OCTET_STRING *PKCS12_item_i2d_encrypt(X509_ALGOR *algor,
+                                           const ASN1_ITEM *it,
+                                           const char *pass, int passlen,
+                                           void *obj, int zbuf);
+ASN1_OCTET_STRING *PKCS12_item_i2d_encrypt_ex(X509_ALGOR *algor,
+                                              const ASN1_ITEM *it,
+                                              const char *pass, int passlen,
+                                              void *obj, int zbuf,
+                                              OSSL_LIB_CTX *ctx,
+                                              const char *propq);
+PKCS12 *PKCS12_init(int mode);
+PKCS12 *PKCS12_init_ex(int mode, OSSL_LIB_CTX *ctx, const char *propq);
+
+int PKCS12_key_gen_asc(const char *pass, int passlen, unsigned char *salt,
+                       int saltlen, int id, int iter, int n,
+                       unsigned char *out, const EVP_MD *md_type);
+int PKCS12_key_gen_asc_ex(const char *pass, int passlen, unsigned char *salt,
+                          int saltlen, int id, int iter, int n,
+                          unsigned char *out, const EVP_MD *md_type,
+                          OSSL_LIB_CTX *ctx, const char *propq);
+int PKCS12_key_gen_uni(unsigned char *pass, int passlen, unsigned char *salt,
+                       int saltlen, int id, int iter, int n,
+                       unsigned char *out, const EVP_MD *md_type);
+int PKCS12_key_gen_uni_ex(unsigned char *pass, int passlen, unsigned char *salt,
+                          int saltlen, int id, int iter, int n,
+                          unsigned char *out, const EVP_MD *md_type,
+                          OSSL_LIB_CTX *ctx, const char *propq);
+int PKCS12_key_gen_utf8(const char *pass, int passlen, unsigned char *salt,
+                        int saltlen, int id, int iter, int n,
+                        unsigned char *out, const EVP_MD *md_type);
+int PKCS12_key_gen_utf8_ex(const char *pass, int passlen, unsigned char *salt,
+                           int saltlen, int id, int iter, int n,
+                           unsigned char *out, const EVP_MD *md_type,
+                           OSSL_LIB_CTX *ctx, const char *propq);
+
+int PKCS12_PBE_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass, int passlen,
+                        ASN1_TYPE *param, const EVP_CIPHER *cipher,
+                        const EVP_MD *md_type, int en_de);
+int PKCS12_PBE_keyivgen_ex(EVP_CIPHER_CTX *ctx, const char *pass, int passlen,
+                           ASN1_TYPE *param, const EVP_CIPHER *cipher,
+                           const EVP_MD *md_type, int en_de,
+                           OSSL_LIB_CTX *libctx, const char *propq);
+int PKCS12_gen_mac(PKCS12 *p12, const char *pass, int passlen,
+                   unsigned char *mac, unsigned int *maclen);
+int PKCS12_verify_mac(PKCS12 *p12, const char *pass, int passlen);
+int PKCS12_set_mac(PKCS12 *p12, const char *pass, int passlen,
+                   unsigned char *salt, int saltlen, int iter,
+                   const EVP_MD *md_type);
+int PKCS12_setup_mac(PKCS12 *p12, int iter, unsigned char *salt,
+                     int saltlen, const EVP_MD *md_type);
+unsigned char *OPENSSL_asc2uni(const char *asc, int asclen,
+                               unsigned char **uni, int *unilen);
+char *OPENSSL_uni2asc(const unsigned char *uni, int unilen);
+unsigned char *OPENSSL_utf82uni(const char *asc, int asclen,
+                                unsigned char **uni, int *unilen);
+char *OPENSSL_uni2utf8(const unsigned char *uni, int unilen);
+
+DECLARE_ASN1_FUNCTIONS(PKCS12)
+DECLARE_ASN1_FUNCTIONS(PKCS12_MAC_DATA)
+DECLARE_ASN1_FUNCTIONS(PKCS12_SAFEBAG)
+DECLARE_ASN1_FUNCTIONS(PKCS12_BAGS)
+
+DECLARE_ASN1_ITEM(PKCS12_SAFEBAGS)
+DECLARE_ASN1_ITEM(PKCS12_AUTHSAFES)
+
+void PKCS12_PBE_add(void);
+int PKCS12_parse(PKCS12 *p12, const char *pass, EVP_PKEY **pkey, X509 **cert,
+                 STACK_OF(X509) **ca);
+typedef int PKCS12_create_cb(PKCS12_SAFEBAG *bag, void *cbarg);
+PKCS12 *PKCS12_create(const char *pass, const char *name, EVP_PKEY *pkey,
+                      X509 *cert, STACK_OF(X509) *ca, int nid_key, int nid_cert,
+                      int iter, int mac_iter, int keytype);
+PKCS12 *PKCS12_create_ex(const char *pass, const char *name, EVP_PKEY *pkey,
+                         X509 *cert, STACK_OF(X509) *ca, int nid_key, int nid_cert,
+                         int iter, int mac_iter, int keytype,
+                         OSSL_LIB_CTX *ctx, const char *propq);
+PKCS12 *PKCS12_create_ex2(const char *pass, const char *name, EVP_PKEY *pkey,
+                          X509 *cert, STACK_OF(X509) *ca, int nid_key, int nid_cert,
+                          int iter, int mac_iter, int keytype,
+                          OSSL_LIB_CTX *ctx, const char *propq,
+                          PKCS12_create_cb *cb, void *cbarg);
+
+PKCS12_SAFEBAG *PKCS12_add_cert(STACK_OF(PKCS12_SAFEBAG) **pbags, X509 *cert);
+PKCS12_SAFEBAG *PKCS12_add_key(STACK_OF(PKCS12_SAFEBAG) **pbags,
+                               EVP_PKEY *key, int key_usage, int iter,
+                               int key_nid, const char *pass);
+PKCS12_SAFEBAG *PKCS12_add_key_ex(STACK_OF(PKCS12_SAFEBAG) **pbags,
+                                  EVP_PKEY *key, int key_usage, int iter,
+                                  int key_nid, const char *pass,
+                                  OSSL_LIB_CTX *ctx, const char *propq);
+
+PKCS12_SAFEBAG *PKCS12_add_secret(STACK_OF(PKCS12_SAFEBAG) **pbags,
+                                  int nid_type, const unsigned char *value, int len);
+int PKCS12_add_safe(STACK_OF(PKCS7) **psafes, STACK_OF(PKCS12_SAFEBAG) *bags,
+                    int safe_nid, int iter, const char *pass);
+int PKCS12_add_safe_ex(STACK_OF(PKCS7) **psafes, STACK_OF(PKCS12_SAFEBAG) *bags,
+                       int safe_nid, int iter, const char *pass,
+                       OSSL_LIB_CTX *ctx, const char *propq);
+
+PKCS12 *PKCS12_add_safes(STACK_OF(PKCS7) *safes, int p7_nid);
+PKCS12 *PKCS12_add_safes_ex(STACK_OF(PKCS7) *safes, int p7_nid,
+                            OSSL_LIB_CTX *ctx, const char *propq);
+
+int i2d_PKCS12_bio(BIO *bp, const PKCS12 *p12);
+# ifndef OPENSSL_NO_STDIO
+int i2d_PKCS12_fp(FILE *fp, const PKCS12 *p12);
+# endif
+PKCS12 *d2i_PKCS12_bio(BIO *bp, PKCS12 **p12);
+# ifndef OPENSSL_NO_STDIO
+PKCS12 *d2i_PKCS12_fp(FILE *fp, PKCS12 **p12);
+# endif
+int PKCS12_newpass(PKCS12 *p12, const char *oldpass, const char *newpass);
+
+# ifdef  __cplusplus
+}
+# endif
+#endif
diff --git a/src/include/openssl/pkcs12err.h b/src/include/openssl/pkcs12err.h
new file mode 100644
index 0000000..abce373
--- /dev/null
+++ b/src/include/openssl/pkcs12err.h
@@ -0,0 +1,46 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2022 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_PKCS12ERR_H
+# define OPENSSL_PKCS12ERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+
+/*
+ * PKCS12 reason codes.
+ */
+# define PKCS12_R_CALLBACK_FAILED                         115
+# define PKCS12_R_CANT_PACK_STRUCTURE                     100
+# define PKCS12_R_CONTENT_TYPE_NOT_DATA                   121
+# define PKCS12_R_DECODE_ERROR                            101
+# define PKCS12_R_ENCODE_ERROR                            102
+# define PKCS12_R_ENCRYPT_ERROR                           103
+# define PKCS12_R_ERROR_SETTING_ENCRYPTED_DATA_TYPE       120
+# define PKCS12_R_INVALID_NULL_ARGUMENT                   104
+# define PKCS12_R_INVALID_NULL_PKCS12_POINTER             105
+# define PKCS12_R_INVALID_TYPE                            112
+# define PKCS12_R_IV_GEN_ERROR                            106
+# define PKCS12_R_KEY_GEN_ERROR                           107
+# define PKCS12_R_MAC_ABSENT                              108
+# define PKCS12_R_MAC_GENERATION_ERROR                    109
+# define PKCS12_R_MAC_SETUP_ERROR                         110
+# define PKCS12_R_MAC_STRING_SET_ERROR                    111
+# define PKCS12_R_MAC_VERIFY_FAILURE                      113
+# define PKCS12_R_PARSE_ERROR                             114
+# define PKCS12_R_PKCS12_CIPHERFINAL_ERROR                116
+# define PKCS12_R_UNKNOWN_DIGEST_ALGORITHM                118
+# define PKCS12_R_UNSUPPORTED_PKCS12_MODE                 119
+
+#endif
diff --git a/src/include/openssl/pkcs7.h b/src/include/openssl/pkcs7.h
new file mode 100644
index 0000000..03633b1
--- /dev/null
+++ b/src/include/openssl/pkcs7.h
@@ -0,0 +1,430 @@
+/*
+ * WARNING: do not edit!
+ * Generated by makefile from include\openssl\pkcs7.h.in
+ *
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+
+
+#ifndef OPENSSL_PKCS7_H
+# define OPENSSL_PKCS7_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_PKCS7_H
+# endif
+
+# include <openssl/asn1.h>
+# include <openssl/bio.h>
+# include <openssl/e_os2.h>
+
+# include <openssl/symhacks.h>
+# include <openssl/types.h>
+# include <openssl/pkcs7err.h>
+# ifndef OPENSSL_NO_STDIO
+#  include <stdio.h>
+# endif
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+
+/*-
+Encryption_ID           DES-CBC
+Digest_ID               MD5
+Digest_Encryption_ID    rsaEncryption
+Key_Encryption_ID       rsaEncryption
+*/
+
+typedef struct PKCS7_CTX_st {
+    OSSL_LIB_CTX *libctx;
+    char *propq;
+} PKCS7_CTX;
+
+typedef struct pkcs7_issuer_and_serial_st {
+    X509_NAME *issuer;
+    ASN1_INTEGER *serial;
+} PKCS7_ISSUER_AND_SERIAL;
+
+typedef struct pkcs7_signer_info_st {
+    ASN1_INTEGER *version;      /* version 1 */
+    PKCS7_ISSUER_AND_SERIAL *issuer_and_serial;
+    X509_ALGOR *digest_alg;
+    STACK_OF(X509_ATTRIBUTE) *auth_attr; /* [ 0 ] */
+    X509_ALGOR *digest_enc_alg; /* confusing name, actually used for signing */
+    ASN1_OCTET_STRING *enc_digest; /* confusing name, actually signature */
+    STACK_OF(X509_ATTRIBUTE) *unauth_attr; /* [ 1 ] */
+    /* The private key to sign with */
+    EVP_PKEY *pkey;
+    const PKCS7_CTX *ctx;
+} PKCS7_SIGNER_INFO;
+SKM_DEFINE_STACK_OF_INTERNAL(PKCS7_SIGNER_INFO, PKCS7_SIGNER_INFO, PKCS7_SIGNER_INFO)
+#define sk_PKCS7_SIGNER_INFO_num(sk) OPENSSL_sk_num(ossl_check_const_PKCS7_SIGNER_INFO_sk_type(sk))
+#define sk_PKCS7_SIGNER_INFO_value(sk, idx) ((PKCS7_SIGNER_INFO *)OPENSSL_sk_value(ossl_check_const_PKCS7_SIGNER_INFO_sk_type(sk), (idx)))
+#define sk_PKCS7_SIGNER_INFO_new(cmp) ((STACK_OF(PKCS7_SIGNER_INFO) *)OPENSSL_sk_new(ossl_check_PKCS7_SIGNER_INFO_compfunc_type(cmp)))
+#define sk_PKCS7_SIGNER_INFO_new_null() ((STACK_OF(PKCS7_SIGNER_INFO) *)OPENSSL_sk_new_null())
+#define sk_PKCS7_SIGNER_INFO_new_reserve(cmp, n) ((STACK_OF(PKCS7_SIGNER_INFO) *)OPENSSL_sk_new_reserve(ossl_check_PKCS7_SIGNER_INFO_compfunc_type(cmp), (n)))
+#define sk_PKCS7_SIGNER_INFO_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk), (n))
+#define sk_PKCS7_SIGNER_INFO_free(sk) OPENSSL_sk_free(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk))
+#define sk_PKCS7_SIGNER_INFO_zero(sk) OPENSSL_sk_zero(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk))
+#define sk_PKCS7_SIGNER_INFO_delete(sk, i) ((PKCS7_SIGNER_INFO *)OPENSSL_sk_delete(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk), (i)))
+#define sk_PKCS7_SIGNER_INFO_delete_ptr(sk, ptr) ((PKCS7_SIGNER_INFO *)OPENSSL_sk_delete_ptr(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk), ossl_check_PKCS7_SIGNER_INFO_type(ptr)))
+#define sk_PKCS7_SIGNER_INFO_push(sk, ptr) OPENSSL_sk_push(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk), ossl_check_PKCS7_SIGNER_INFO_type(ptr))
+#define sk_PKCS7_SIGNER_INFO_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk), ossl_check_PKCS7_SIGNER_INFO_type(ptr))
+#define sk_PKCS7_SIGNER_INFO_pop(sk) ((PKCS7_SIGNER_INFO *)OPENSSL_sk_pop(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk)))
+#define sk_PKCS7_SIGNER_INFO_shift(sk) ((PKCS7_SIGNER_INFO *)OPENSSL_sk_shift(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk)))
+#define sk_PKCS7_SIGNER_INFO_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk),ossl_check_PKCS7_SIGNER_INFO_freefunc_type(freefunc))
+#define sk_PKCS7_SIGNER_INFO_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk), ossl_check_PKCS7_SIGNER_INFO_type(ptr), (idx))
+#define sk_PKCS7_SIGNER_INFO_set(sk, idx, ptr) ((PKCS7_SIGNER_INFO *)OPENSSL_sk_set(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk), (idx), ossl_check_PKCS7_SIGNER_INFO_type(ptr)))
+#define sk_PKCS7_SIGNER_INFO_find(sk, ptr) OPENSSL_sk_find(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk), ossl_check_PKCS7_SIGNER_INFO_type(ptr))
+#define sk_PKCS7_SIGNER_INFO_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk), ossl_check_PKCS7_SIGNER_INFO_type(ptr))
+#define sk_PKCS7_SIGNER_INFO_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk), ossl_check_PKCS7_SIGNER_INFO_type(ptr), pnum)
+#define sk_PKCS7_SIGNER_INFO_sort(sk) OPENSSL_sk_sort(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk))
+#define sk_PKCS7_SIGNER_INFO_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_PKCS7_SIGNER_INFO_sk_type(sk))
+#define sk_PKCS7_SIGNER_INFO_dup(sk) ((STACK_OF(PKCS7_SIGNER_INFO) *)OPENSSL_sk_dup(ossl_check_const_PKCS7_SIGNER_INFO_sk_type(sk)))
+#define sk_PKCS7_SIGNER_INFO_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(PKCS7_SIGNER_INFO) *)OPENSSL_sk_deep_copy(ossl_check_const_PKCS7_SIGNER_INFO_sk_type(sk), ossl_check_PKCS7_SIGNER_INFO_copyfunc_type(copyfunc), ossl_check_PKCS7_SIGNER_INFO_freefunc_type(freefunc)))
+#define sk_PKCS7_SIGNER_INFO_set_cmp_func(sk, cmp) ((sk_PKCS7_SIGNER_INFO_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk), ossl_check_PKCS7_SIGNER_INFO_compfunc_type(cmp)))
+
+
+typedef struct pkcs7_recip_info_st {
+    ASN1_INTEGER *version;      /* version 0 */
+    PKCS7_ISSUER_AND_SERIAL *issuer_and_serial;
+    X509_ALGOR *key_enc_algor;
+    ASN1_OCTET_STRING *enc_key;
+    X509 *cert;                 /* get the pub-key from this */
+    const PKCS7_CTX *ctx;
+} PKCS7_RECIP_INFO;
+SKM_DEFINE_STACK_OF_INTERNAL(PKCS7_RECIP_INFO, PKCS7_RECIP_INFO, PKCS7_RECIP_INFO)
+#define sk_PKCS7_RECIP_INFO_num(sk) OPENSSL_sk_num(ossl_check_const_PKCS7_RECIP_INFO_sk_type(sk))
+#define sk_PKCS7_RECIP_INFO_value(sk, idx) ((PKCS7_RECIP_INFO *)OPENSSL_sk_value(ossl_check_const_PKCS7_RECIP_INFO_sk_type(sk), (idx)))
+#define sk_PKCS7_RECIP_INFO_new(cmp) ((STACK_OF(PKCS7_RECIP_INFO) *)OPENSSL_sk_new(ossl_check_PKCS7_RECIP_INFO_compfunc_type(cmp)))
+#define sk_PKCS7_RECIP_INFO_new_null() ((STACK_OF(PKCS7_RECIP_INFO) *)OPENSSL_sk_new_null())
+#define sk_PKCS7_RECIP_INFO_new_reserve(cmp, n) ((STACK_OF(PKCS7_RECIP_INFO) *)OPENSSL_sk_new_reserve(ossl_check_PKCS7_RECIP_INFO_compfunc_type(cmp), (n)))
+#define sk_PKCS7_RECIP_INFO_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_PKCS7_RECIP_INFO_sk_type(sk), (n))
+#define sk_PKCS7_RECIP_INFO_free(sk) OPENSSL_sk_free(ossl_check_PKCS7_RECIP_INFO_sk_type(sk))
+#define sk_PKCS7_RECIP_INFO_zero(sk) OPENSSL_sk_zero(ossl_check_PKCS7_RECIP_INFO_sk_type(sk))
+#define sk_PKCS7_RECIP_INFO_delete(sk, i) ((PKCS7_RECIP_INFO *)OPENSSL_sk_delete(ossl_check_PKCS7_RECIP_INFO_sk_type(sk), (i)))
+#define sk_PKCS7_RECIP_INFO_delete_ptr(sk, ptr) ((PKCS7_RECIP_INFO *)OPENSSL_sk_delete_ptr(ossl_check_PKCS7_RECIP_INFO_sk_type(sk), ossl_check_PKCS7_RECIP_INFO_type(ptr)))
+#define sk_PKCS7_RECIP_INFO_push(sk, ptr) OPENSSL_sk_push(ossl_check_PKCS7_RECIP_INFO_sk_type(sk), ossl_check_PKCS7_RECIP_INFO_type(ptr))
+#define sk_PKCS7_RECIP_INFO_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_PKCS7_RECIP_INFO_sk_type(sk), ossl_check_PKCS7_RECIP_INFO_type(ptr))
+#define sk_PKCS7_RECIP_INFO_pop(sk) ((PKCS7_RECIP_INFO *)OPENSSL_sk_pop(ossl_check_PKCS7_RECIP_INFO_sk_type(sk)))
+#define sk_PKCS7_RECIP_INFO_shift(sk) ((PKCS7_RECIP_INFO *)OPENSSL_sk_shift(ossl_check_PKCS7_RECIP_INFO_sk_type(sk)))
+#define sk_PKCS7_RECIP_INFO_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_PKCS7_RECIP_INFO_sk_type(sk),ossl_check_PKCS7_RECIP_INFO_freefunc_type(freefunc))
+#define sk_PKCS7_RECIP_INFO_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_PKCS7_RECIP_INFO_sk_type(sk), ossl_check_PKCS7_RECIP_INFO_type(ptr), (idx))
+#define sk_PKCS7_RECIP_INFO_set(sk, idx, ptr) ((PKCS7_RECIP_INFO *)OPENSSL_sk_set(ossl_check_PKCS7_RECIP_INFO_sk_type(sk), (idx), ossl_check_PKCS7_RECIP_INFO_type(ptr)))
+#define sk_PKCS7_RECIP_INFO_find(sk, ptr) OPENSSL_sk_find(ossl_check_PKCS7_RECIP_INFO_sk_type(sk), ossl_check_PKCS7_RECIP_INFO_type(ptr))
+#define sk_PKCS7_RECIP_INFO_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_PKCS7_RECIP_INFO_sk_type(sk), ossl_check_PKCS7_RECIP_INFO_type(ptr))
+#define sk_PKCS7_RECIP_INFO_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_PKCS7_RECIP_INFO_sk_type(sk), ossl_check_PKCS7_RECIP_INFO_type(ptr), pnum)
+#define sk_PKCS7_RECIP_INFO_sort(sk) OPENSSL_sk_sort(ossl_check_PKCS7_RECIP_INFO_sk_type(sk))
+#define sk_PKCS7_RECIP_INFO_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_PKCS7_RECIP_INFO_sk_type(sk))
+#define sk_PKCS7_RECIP_INFO_dup(sk) ((STACK_OF(PKCS7_RECIP_INFO) *)OPENSSL_sk_dup(ossl_check_const_PKCS7_RECIP_INFO_sk_type(sk)))
+#define sk_PKCS7_RECIP_INFO_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(PKCS7_RECIP_INFO) *)OPENSSL_sk_deep_copy(ossl_check_const_PKCS7_RECIP_INFO_sk_type(sk), ossl_check_PKCS7_RECIP_INFO_copyfunc_type(copyfunc), ossl_check_PKCS7_RECIP_INFO_freefunc_type(freefunc)))
+#define sk_PKCS7_RECIP_INFO_set_cmp_func(sk, cmp) ((sk_PKCS7_RECIP_INFO_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_PKCS7_RECIP_INFO_sk_type(sk), ossl_check_PKCS7_RECIP_INFO_compfunc_type(cmp)))
+
+
+
+typedef struct pkcs7_signed_st {
+    ASN1_INTEGER *version;      /* version 1 */
+    STACK_OF(X509_ALGOR) *md_algs; /* md used */
+    STACK_OF(X509) *cert;       /* [ 0 ] */ /* name should be 'certificates' */
+    STACK_OF(X509_CRL) *crl;    /* [ 1 ] */ /* name should be 'crls' */
+    STACK_OF(PKCS7_SIGNER_INFO) *signer_info;
+    struct pkcs7_st *contents;
+} PKCS7_SIGNED;
+/*
+ * The above structure is very very similar to PKCS7_SIGN_ENVELOPE. How about
+ * merging the two
+ */
+
+typedef struct pkcs7_enc_content_st {
+    ASN1_OBJECT *content_type;
+    X509_ALGOR *algorithm;
+    ASN1_OCTET_STRING *enc_data; /* [ 0 ] */
+    const EVP_CIPHER *cipher;
+    const PKCS7_CTX *ctx;
+} PKCS7_ENC_CONTENT;
+
+typedef struct pkcs7_enveloped_st {
+    ASN1_INTEGER *version;      /* version 0 */
+    STACK_OF(PKCS7_RECIP_INFO) *recipientinfo;
+    PKCS7_ENC_CONTENT *enc_data;
+} PKCS7_ENVELOPE;
+
+typedef struct pkcs7_signedandenveloped_st {
+    ASN1_INTEGER *version;      /* version 1 */
+    STACK_OF(X509_ALGOR) *md_algs; /* md used */
+    STACK_OF(X509) *cert;       /* [ 0 ] */ /* name should be 'certificates' */
+    STACK_OF(X509_CRL) *crl;    /* [ 1 ] */ /* name should be 'crls' */
+    STACK_OF(PKCS7_SIGNER_INFO) *signer_info;
+    PKCS7_ENC_CONTENT *enc_data;
+    STACK_OF(PKCS7_RECIP_INFO) *recipientinfo;
+} PKCS7_SIGN_ENVELOPE;
+
+typedef struct pkcs7_digest_st {
+    ASN1_INTEGER *version;      /* version 0 */
+    X509_ALGOR *md;             /* md used */
+    struct pkcs7_st *contents;
+    ASN1_OCTET_STRING *digest;
+} PKCS7_DIGEST;
+
+typedef struct pkcs7_encrypted_st {
+    ASN1_INTEGER *version;      /* version 0 */
+    PKCS7_ENC_CONTENT *enc_data;
+} PKCS7_ENCRYPT;
+
+typedef struct pkcs7_st {
+    /*
+     * The following is non NULL if it contains ASN1 encoding of this
+     * structure
+     */
+    unsigned char *asn1;
+    long length;
+# define PKCS7_S_HEADER  0
+# define PKCS7_S_BODY    1
+# define PKCS7_S_TAIL    2
+    int state;                  /* used during processing */
+    int detached;
+    ASN1_OBJECT *type;
+    /* content as defined by the type */
+    /*
+     * all encryption/message digests are applied to the 'contents', leaving
+     * out the 'type' field.
+     */
+    union {
+        char *ptr;
+        /* NID_pkcs7_data */
+        ASN1_OCTET_STRING *data;
+        /* NID_pkcs7_signed */
+        PKCS7_SIGNED *sign; /* field name 'signed' would clash with C keyword */
+        /* NID_pkcs7_enveloped */
+        PKCS7_ENVELOPE *enveloped;
+        /* NID_pkcs7_signedAndEnveloped */
+        PKCS7_SIGN_ENVELOPE *signed_and_enveloped;
+        /* NID_pkcs7_digest */
+        PKCS7_DIGEST *digest;
+        /* NID_pkcs7_encrypted */
+        PKCS7_ENCRYPT *encrypted;
+        /* Anything else */
+        ASN1_TYPE *other;
+    } d;
+    PKCS7_CTX ctx;
+} PKCS7;
+SKM_DEFINE_STACK_OF_INTERNAL(PKCS7, PKCS7, PKCS7)
+#define sk_PKCS7_num(sk) OPENSSL_sk_num(ossl_check_const_PKCS7_sk_type(sk))
+#define sk_PKCS7_value(sk, idx) ((PKCS7 *)OPENSSL_sk_value(ossl_check_const_PKCS7_sk_type(sk), (idx)))
+#define sk_PKCS7_new(cmp) ((STACK_OF(PKCS7) *)OPENSSL_sk_new(ossl_check_PKCS7_compfunc_type(cmp)))
+#define sk_PKCS7_new_null() ((STACK_OF(PKCS7) *)OPENSSL_sk_new_null())
+#define sk_PKCS7_new_reserve(cmp, n) ((STACK_OF(PKCS7) *)OPENSSL_sk_new_reserve(ossl_check_PKCS7_compfunc_type(cmp), (n)))
+#define sk_PKCS7_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_PKCS7_sk_type(sk), (n))
+#define sk_PKCS7_free(sk) OPENSSL_sk_free(ossl_check_PKCS7_sk_type(sk))
+#define sk_PKCS7_zero(sk) OPENSSL_sk_zero(ossl_check_PKCS7_sk_type(sk))
+#define sk_PKCS7_delete(sk, i) ((PKCS7 *)OPENSSL_sk_delete(ossl_check_PKCS7_sk_type(sk), (i)))
+#define sk_PKCS7_delete_ptr(sk, ptr) ((PKCS7 *)OPENSSL_sk_delete_ptr(ossl_check_PKCS7_sk_type(sk), ossl_check_PKCS7_type(ptr)))
+#define sk_PKCS7_push(sk, ptr) OPENSSL_sk_push(ossl_check_PKCS7_sk_type(sk), ossl_check_PKCS7_type(ptr))
+#define sk_PKCS7_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_PKCS7_sk_type(sk), ossl_check_PKCS7_type(ptr))
+#define sk_PKCS7_pop(sk) ((PKCS7 *)OPENSSL_sk_pop(ossl_check_PKCS7_sk_type(sk)))
+#define sk_PKCS7_shift(sk) ((PKCS7 *)OPENSSL_sk_shift(ossl_check_PKCS7_sk_type(sk)))
+#define sk_PKCS7_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_PKCS7_sk_type(sk),ossl_check_PKCS7_freefunc_type(freefunc))
+#define sk_PKCS7_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_PKCS7_sk_type(sk), ossl_check_PKCS7_type(ptr), (idx))
+#define sk_PKCS7_set(sk, idx, ptr) ((PKCS7 *)OPENSSL_sk_set(ossl_check_PKCS7_sk_type(sk), (idx), ossl_check_PKCS7_type(ptr)))
+#define sk_PKCS7_find(sk, ptr) OPENSSL_sk_find(ossl_check_PKCS7_sk_type(sk), ossl_check_PKCS7_type(ptr))
+#define sk_PKCS7_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_PKCS7_sk_type(sk), ossl_check_PKCS7_type(ptr))
+#define sk_PKCS7_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_PKCS7_sk_type(sk), ossl_check_PKCS7_type(ptr), pnum)
+#define sk_PKCS7_sort(sk) OPENSSL_sk_sort(ossl_check_PKCS7_sk_type(sk))
+#define sk_PKCS7_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_PKCS7_sk_type(sk))
+#define sk_PKCS7_dup(sk) ((STACK_OF(PKCS7) *)OPENSSL_sk_dup(ossl_check_const_PKCS7_sk_type(sk)))
+#define sk_PKCS7_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(PKCS7) *)OPENSSL_sk_deep_copy(ossl_check_const_PKCS7_sk_type(sk), ossl_check_PKCS7_copyfunc_type(copyfunc), ossl_check_PKCS7_freefunc_type(freefunc)))
+#define sk_PKCS7_set_cmp_func(sk, cmp) ((sk_PKCS7_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_PKCS7_sk_type(sk), ossl_check_PKCS7_compfunc_type(cmp)))
+
+
+
+# define PKCS7_OP_SET_DETACHED_SIGNATURE 1
+# define PKCS7_OP_GET_DETACHED_SIGNATURE 2
+
+# define PKCS7_get_signed_attributes(si) ((si)->auth_attr)
+# define PKCS7_get_attributes(si)        ((si)->unauth_attr)
+
+# define PKCS7_type_is_signed(a) (OBJ_obj2nid((a)->type) == NID_pkcs7_signed)
+# define PKCS7_type_is_encrypted(a) (OBJ_obj2nid((a)->type) == NID_pkcs7_encrypted)
+# define PKCS7_type_is_enveloped(a) (OBJ_obj2nid((a)->type) == NID_pkcs7_enveloped)
+# define PKCS7_type_is_signedAndEnveloped(a) \
+                (OBJ_obj2nid((a)->type) == NID_pkcs7_signedAndEnveloped)
+# define PKCS7_type_is_data(a)   (OBJ_obj2nid((a)->type) == NID_pkcs7_data)
+# define PKCS7_type_is_digest(a)   (OBJ_obj2nid((a)->type) == NID_pkcs7_digest)
+
+# define PKCS7_set_detached(p,v) \
+                PKCS7_ctrl(p,PKCS7_OP_SET_DETACHED_SIGNATURE,v,NULL)
+# define PKCS7_get_detached(p) \
+                PKCS7_ctrl(p,PKCS7_OP_GET_DETACHED_SIGNATURE,0,NULL)
+
+# define PKCS7_is_detached(p7) (PKCS7_type_is_signed(p7) && PKCS7_get_detached(p7))
+
+/* S/MIME related flags */
+
+# define PKCS7_TEXT              0x1
+# define PKCS7_NOCERTS           0x2
+# define PKCS7_NOSIGS            0x4
+# define PKCS7_NOCHAIN           0x8
+# define PKCS7_NOINTERN          0x10
+# define PKCS7_NOVERIFY          0x20
+# define PKCS7_DETACHED          0x40
+# define PKCS7_BINARY            0x80
+# define PKCS7_NOATTR            0x100
+# define PKCS7_NOSMIMECAP        0x200
+# define PKCS7_NOOLDMIMETYPE     0x400
+# define PKCS7_CRLFEOL           0x800
+# define PKCS7_STREAM            0x1000
+# define PKCS7_NOCRL             0x2000
+# define PKCS7_PARTIAL           0x4000
+# define PKCS7_REUSE_DIGEST      0x8000
+# define PKCS7_NO_DUAL_CONTENT   0x10000
+
+/* Flags: for compatibility with older code */
+
+# define SMIME_TEXT      PKCS7_TEXT
+# define SMIME_NOCERTS   PKCS7_NOCERTS
+# define SMIME_NOSIGS    PKCS7_NOSIGS
+# define SMIME_NOCHAIN   PKCS7_NOCHAIN
+# define SMIME_NOINTERN  PKCS7_NOINTERN
+# define SMIME_NOVERIFY  PKCS7_NOVERIFY
+# define SMIME_DETACHED  PKCS7_DETACHED
+# define SMIME_BINARY    PKCS7_BINARY
+# define SMIME_NOATTR    PKCS7_NOATTR
+
+/* CRLF ASCII canonicalisation */
+# define SMIME_ASCIICRLF         0x80000
+
+DECLARE_ASN1_FUNCTIONS(PKCS7_ISSUER_AND_SERIAL)
+
+int PKCS7_ISSUER_AND_SERIAL_digest(PKCS7_ISSUER_AND_SERIAL *data,
+                                   const EVP_MD *type, unsigned char *md,
+                                   unsigned int *len);
+# ifndef OPENSSL_NO_STDIO
+PKCS7 *d2i_PKCS7_fp(FILE *fp, PKCS7 **p7);
+int i2d_PKCS7_fp(FILE *fp, const PKCS7 *p7);
+# endif
+DECLARE_ASN1_DUP_FUNCTION(PKCS7)
+PKCS7 *d2i_PKCS7_bio(BIO *bp, PKCS7 **p7);
+int i2d_PKCS7_bio(BIO *bp, const PKCS7 *p7);
+int i2d_PKCS7_bio_stream(BIO *out, PKCS7 *p7, BIO *in, int flags);
+int PEM_write_bio_PKCS7_stream(BIO *out, PKCS7 *p7, BIO *in, int flags);
+
+DECLARE_ASN1_FUNCTIONS(PKCS7_SIGNER_INFO)
+DECLARE_ASN1_FUNCTIONS(PKCS7_RECIP_INFO)
+DECLARE_ASN1_FUNCTIONS(PKCS7_SIGNED)
+DECLARE_ASN1_FUNCTIONS(PKCS7_ENC_CONTENT)
+DECLARE_ASN1_FUNCTIONS(PKCS7_ENVELOPE)
+DECLARE_ASN1_FUNCTIONS(PKCS7_SIGN_ENVELOPE)
+DECLARE_ASN1_FUNCTIONS(PKCS7_DIGEST)
+DECLARE_ASN1_FUNCTIONS(PKCS7_ENCRYPT)
+DECLARE_ASN1_FUNCTIONS(PKCS7)
+PKCS7 *PKCS7_new_ex(OSSL_LIB_CTX *libctx, const char *propq);
+
+DECLARE_ASN1_ITEM(PKCS7_ATTR_SIGN)
+DECLARE_ASN1_ITEM(PKCS7_ATTR_VERIFY)
+
+DECLARE_ASN1_NDEF_FUNCTION(PKCS7)
+DECLARE_ASN1_PRINT_FUNCTION(PKCS7)
+
+long PKCS7_ctrl(PKCS7 *p7, int cmd, long larg, char *parg);
+
+int PKCS7_type_is_other(PKCS7 *p7);
+int PKCS7_set_type(PKCS7 *p7, int type);
+int PKCS7_set0_type_other(PKCS7 *p7, int type, ASN1_TYPE *other);
+int PKCS7_set_content(PKCS7 *p7, PKCS7 *p7_data);
+int PKCS7_SIGNER_INFO_set(PKCS7_SIGNER_INFO *p7i, X509 *x509, EVP_PKEY *pkey,
+                          const EVP_MD *dgst);
+int PKCS7_SIGNER_INFO_sign(PKCS7_SIGNER_INFO *si);
+int PKCS7_add_signer(PKCS7 *p7, PKCS7_SIGNER_INFO *p7i);
+int PKCS7_add_certificate(PKCS7 *p7, X509 *cert);
+int PKCS7_add_crl(PKCS7 *p7, X509_CRL *crl);
+int PKCS7_content_new(PKCS7 *p7, int nid);
+int PKCS7_dataVerify(X509_STORE *cert_store, X509_STORE_CTX *ctx,
+                     BIO *bio, PKCS7 *p7, PKCS7_SIGNER_INFO *si);
+int PKCS7_signatureVerify(BIO *bio, PKCS7 *p7, PKCS7_SIGNER_INFO *si,
+                          X509 *signer);
+
+BIO *PKCS7_dataInit(PKCS7 *p7, BIO *bio);
+int PKCS7_dataFinal(PKCS7 *p7, BIO *bio);
+BIO *PKCS7_dataDecode(PKCS7 *p7, EVP_PKEY *pkey, BIO *in_bio, X509 *pcert);
+
+PKCS7_SIGNER_INFO *PKCS7_add_signature(PKCS7 *p7, X509 *x509,
+                                       EVP_PKEY *pkey, const EVP_MD *dgst);
+X509 *PKCS7_cert_from_signer_info(PKCS7 *p7, PKCS7_SIGNER_INFO *si);
+int PKCS7_set_digest(PKCS7 *p7, const EVP_MD *md);
+STACK_OF(PKCS7_SIGNER_INFO) *PKCS7_get_signer_info(PKCS7 *p7);
+
+PKCS7_RECIP_INFO *PKCS7_add_recipient(PKCS7 *p7, X509 *x509);
+void PKCS7_SIGNER_INFO_get0_algs(PKCS7_SIGNER_INFO *si, EVP_PKEY **pk,
+                                 X509_ALGOR **pdig, X509_ALGOR **psig);
+void PKCS7_RECIP_INFO_get0_alg(PKCS7_RECIP_INFO *ri, X509_ALGOR **penc);
+int PKCS7_add_recipient_info(PKCS7 *p7, PKCS7_RECIP_INFO *ri);
+int PKCS7_RECIP_INFO_set(PKCS7_RECIP_INFO *p7i, X509 *x509);
+int PKCS7_set_cipher(PKCS7 *p7, const EVP_CIPHER *cipher);
+int PKCS7_stream(unsigned char ***boundary, PKCS7 *p7);
+
+PKCS7_ISSUER_AND_SERIAL *PKCS7_get_issuer_and_serial(PKCS7 *p7, int idx);
+ASN1_OCTET_STRING *PKCS7_get_octet_string(PKCS7 *p7);
+ASN1_OCTET_STRING *PKCS7_digest_from_attributes(STACK_OF(X509_ATTRIBUTE) *sk);
+int PKCS7_add_signed_attribute(PKCS7_SIGNER_INFO *p7si, int nid, int type,
+                               void *data);
+int PKCS7_add_attribute(PKCS7_SIGNER_INFO *p7si, int nid, int atrtype,
+                        void *value);
+ASN1_TYPE *PKCS7_get_attribute(const PKCS7_SIGNER_INFO *si, int nid);
+ASN1_TYPE *PKCS7_get_signed_attribute(const PKCS7_SIGNER_INFO *si, int nid);
+int PKCS7_set_signed_attributes(PKCS7_SIGNER_INFO *p7si,
+                                STACK_OF(X509_ATTRIBUTE) *sk);
+int PKCS7_set_attributes(PKCS7_SIGNER_INFO *p7si,
+                         STACK_OF(X509_ATTRIBUTE) *sk);
+
+PKCS7 *PKCS7_sign(X509 *signcert, EVP_PKEY *pkey, STACK_OF(X509) *certs,
+                  BIO *data, int flags);
+PKCS7 *PKCS7_sign_ex(X509 *signcert, EVP_PKEY *pkey, STACK_OF(X509) *certs,
+                     BIO *data, int flags, OSSL_LIB_CTX *libctx,
+                     const char *propq);
+
+PKCS7_SIGNER_INFO *PKCS7_sign_add_signer(PKCS7 *p7,
+                                         X509 *signcert, EVP_PKEY *pkey,
+                                         const EVP_MD *md, int flags);
+
+int PKCS7_final(PKCS7 *p7, BIO *data, int flags);
+int PKCS7_verify(PKCS7 *p7, STACK_OF(X509) *certs, X509_STORE *store,
+                 BIO *indata, BIO *out, int flags);
+STACK_OF(X509) *PKCS7_get0_signers(PKCS7 *p7, STACK_OF(X509) *certs,
+                                   int flags);
+PKCS7 *PKCS7_encrypt(STACK_OF(X509) *certs, BIO *in, const EVP_CIPHER *cipher,
+                     int flags);
+PKCS7 *PKCS7_encrypt_ex(STACK_OF(X509) *certs, BIO *in,
+                        const EVP_CIPHER *cipher, int flags,
+                        OSSL_LIB_CTX *libctx, const char *propq);
+int PKCS7_decrypt(PKCS7 *p7, EVP_PKEY *pkey, X509 *cert, BIO *data,
+                  int flags);
+
+int PKCS7_add_attrib_smimecap(PKCS7_SIGNER_INFO *si,
+                              STACK_OF(X509_ALGOR) *cap);
+STACK_OF(X509_ALGOR) *PKCS7_get_smimecap(PKCS7_SIGNER_INFO *si);
+int PKCS7_simple_smimecap(STACK_OF(X509_ALGOR) *sk, int nid, int arg);
+
+int PKCS7_add_attrib_content_type(PKCS7_SIGNER_INFO *si, ASN1_OBJECT *coid);
+int PKCS7_add0_attrib_signing_time(PKCS7_SIGNER_INFO *si, ASN1_TIME *t);
+int PKCS7_add1_attrib_digest(PKCS7_SIGNER_INFO *si,
+                             const unsigned char *md, int mdlen);
+
+int SMIME_write_PKCS7(BIO *bio, PKCS7 *p7, BIO *data, int flags);
+PKCS7 *SMIME_read_PKCS7_ex(BIO *bio, BIO **bcont, PKCS7 **p7);
+PKCS7 *SMIME_read_PKCS7(BIO *bio, BIO **bcont);
+
+BIO *BIO_new_PKCS7(BIO *out, PKCS7 *p7);
+
+# ifdef  __cplusplus
+}
+# endif
+#endif
diff --git a/src/include/openssl/pkcs7err.h b/src/include/openssl/pkcs7err.h
new file mode 100644
index 0000000..ceb1a50
--- /dev/null
+++ b/src/include/openssl/pkcs7err.h
@@ -0,0 +1,63 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_PKCS7ERR_H
+# define OPENSSL_PKCS7ERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+
+/*
+ * PKCS7 reason codes.
+ */
+# define PKCS7_R_CERTIFICATE_VERIFY_ERROR                 117
+# define PKCS7_R_CIPHER_HAS_NO_OBJECT_IDENTIFIER          144
+# define PKCS7_R_CIPHER_NOT_INITIALIZED                   116
+# define PKCS7_R_CONTENT_AND_DATA_PRESENT                 118
+# define PKCS7_R_CTRL_ERROR                               152
+# define PKCS7_R_DECRYPT_ERROR                            119
+# define PKCS7_R_DIGEST_FAILURE                           101
+# define PKCS7_R_ENCRYPTION_CTRL_FAILURE                  149
+# define PKCS7_R_ENCRYPTION_NOT_SUPPORTED_FOR_THIS_KEY_TYPE 150
+# define PKCS7_R_ERROR_ADDING_RECIPIENT                   120
+# define PKCS7_R_ERROR_SETTING_CIPHER                     121
+# define PKCS7_R_INVALID_NULL_POINTER                     143
+# define PKCS7_R_INVALID_SIGNED_DATA_TYPE                 155
+# define PKCS7_R_NO_CONTENT                               122
+# define PKCS7_R_NO_DEFAULT_DIGEST                        151
+# define PKCS7_R_NO_MATCHING_DIGEST_TYPE_FOUND            154
+# define PKCS7_R_NO_RECIPIENT_MATCHES_CERTIFICATE         115
+# define PKCS7_R_NO_SIGNATURES_ON_DATA                    123
+# define PKCS7_R_NO_SIGNERS                               142
+# define PKCS7_R_OPERATION_NOT_SUPPORTED_ON_THIS_TYPE     104
+# define PKCS7_R_PKCS7_ADD_SIGNATURE_ERROR                124
+# define PKCS7_R_PKCS7_ADD_SIGNER_ERROR                   153
+# define PKCS7_R_PKCS7_DATASIGN                           145
+# define PKCS7_R_PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE   127
+# define PKCS7_R_SIGNATURE_FAILURE                        105
+# define PKCS7_R_SIGNER_CERTIFICATE_NOT_FOUND             128
+# define PKCS7_R_SIGNING_CTRL_FAILURE                     147
+# define PKCS7_R_SIGNING_NOT_SUPPORTED_FOR_THIS_KEY_TYPE  148
+# define PKCS7_R_SMIME_TEXT_ERROR                         129
+# define PKCS7_R_UNABLE_TO_FIND_CERTIFICATE               106
+# define PKCS7_R_UNABLE_TO_FIND_MEM_BIO                   107
+# define PKCS7_R_UNABLE_TO_FIND_MESSAGE_DIGEST            108
+# define PKCS7_R_UNKNOWN_DIGEST_TYPE                      109
+# define PKCS7_R_UNKNOWN_OPERATION                        110
+# define PKCS7_R_UNSUPPORTED_CIPHER_TYPE                  111
+# define PKCS7_R_UNSUPPORTED_CONTENT_TYPE                 112
+# define PKCS7_R_WRONG_CONTENT_TYPE                       113
+# define PKCS7_R_WRONG_PKCS7_TYPE                         114
+
+#endif
diff --git a/src/include/openssl/prov_ssl.h b/src/include/openssl/prov_ssl.h
new file mode 100644
index 0000000..76d01e1
--- /dev/null
+++ b/src/include/openssl/prov_ssl.h
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2021-2023 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_PROV_SSL_H
+# define OPENSSL_PROV_SSL_H
+# pragma once
+
+# ifdef __cplusplus
+extern "C" {
+# endif
+
+/* SSL/TLS related defines useful to providers */
+
+# define SSL_MAX_MASTER_KEY_LENGTH 48
+
+/* SSL/TLS uses a 2 byte unsigned version number */
+# define SSL3_VERSION                    0x0300
+# define TLS1_VERSION                    0x0301
+# define TLS1_1_VERSION                  0x0302
+# define TLS1_2_VERSION                  0x0303
+# define TLS1_3_VERSION                  0x0304
+# define DTLS1_VERSION                   0xFEFF
+# define DTLS1_2_VERSION                 0xFEFD
+# define DTLS1_BAD_VER                   0x0100
+
+/* QUIC uses a 4 byte unsigned version number */
+# define OSSL_QUIC1_VERSION              0x0000001
+
+# ifdef __cplusplus
+}
+# endif
+#endif /* OPENSSL_PROV_SSL_H */
diff --git a/src/include/openssl/proverr.h b/src/include/openssl/proverr.h
new file mode 100644
index 0000000..d9ef568
--- /dev/null
+++ b/src/include/openssl/proverr.h
@@ -0,0 +1,153 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_PROVERR_H
+# define OPENSSL_PROVERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+
+/*
+ * PROV reason codes.
+ */
+# define PROV_R_ADDITIONAL_INPUT_TOO_LONG                 184
+# define PROV_R_ALGORITHM_MISMATCH                        173
+# define PROV_R_ALREADY_INSTANTIATED                      185
+# define PROV_R_BAD_DECRYPT                               100
+# define PROV_R_BAD_ENCODING                              141
+# define PROV_R_BAD_LENGTH                                142
+# define PROV_R_BAD_TLS_CLIENT_VERSION                    161
+# define PROV_R_BN_ERROR                                  160
+# define PROV_R_CIPHER_OPERATION_FAILED                   102
+# define PROV_R_DERIVATION_FUNCTION_INIT_FAILED           205
+# define PROV_R_DIGEST_NOT_ALLOWED                        174
+# define PROV_R_EMS_NOT_ENABLED                           233
+# define PROV_R_ENTROPY_SOURCE_STRENGTH_TOO_WEAK          186
+# define PROV_R_ERROR_INSTANTIATING_DRBG                  188
+# define PROV_R_ERROR_RETRIEVING_ENTROPY                  189
+# define PROV_R_ERROR_RETRIEVING_NONCE                    190
+# define PROV_R_FAILED_DURING_DERIVATION                  164
+# define PROV_R_FAILED_TO_CREATE_LOCK                     180
+# define PROV_R_FAILED_TO_DECRYPT                         162
+# define PROV_R_FAILED_TO_GENERATE_KEY                    121
+# define PROV_R_FAILED_TO_GET_PARAMETER                   103
+# define PROV_R_FAILED_TO_SET_PARAMETER                   104
+# define PROV_R_FAILED_TO_SIGN                            175
+# define PROV_R_FIPS_MODULE_CONDITIONAL_ERROR             227
+# define PROV_R_FIPS_MODULE_ENTERING_ERROR_STATE          224
+# define PROV_R_FIPS_MODULE_IN_ERROR_STATE                225
+# define PROV_R_GENERATE_ERROR                            191
+# define PROV_R_ILLEGAL_OR_UNSUPPORTED_PADDING_MODE       165
+# define PROV_R_INDICATOR_INTEGRITY_FAILURE               210
+# define PROV_R_INSUFFICIENT_DRBG_STRENGTH                181
+# define PROV_R_INVALID_AAD                               108
+# define PROV_R_INVALID_AEAD                              231
+# define PROV_R_INVALID_CONFIG_DATA                       211
+# define PROV_R_INVALID_CONSTANT_LENGTH                   157
+# define PROV_R_INVALID_CURVE                             176
+# define PROV_R_INVALID_CUSTOM_LENGTH                     111
+# define PROV_R_INVALID_DATA                              115
+# define PROV_R_INVALID_DIGEST                            122
+# define PROV_R_INVALID_DIGEST_LENGTH                     166
+# define PROV_R_INVALID_DIGEST_SIZE                       218
+# define PROV_R_INVALID_INPUT_LENGTH                      230
+# define PROV_R_INVALID_ITERATION_COUNT                   123
+# define PROV_R_INVALID_IV_LENGTH                         109
+# define PROV_R_INVALID_KDF                               232
+# define PROV_R_INVALID_KEY                               158
+# define PROV_R_INVALID_KEY_LENGTH                        105
+# define PROV_R_INVALID_MAC                               151
+# define PROV_R_INVALID_MEMORY_SIZE                       235
+# define PROV_R_INVALID_MGF1_MD                           167
+# define PROV_R_INVALID_MODE                              125
+# define PROV_R_INVALID_OUTPUT_LENGTH                     217
+# define PROV_R_INVALID_PADDING_MODE                      168
+# define PROV_R_INVALID_PUBINFO                           198
+# define PROV_R_INVALID_SALT_LENGTH                       112
+# define PROV_R_INVALID_SEED_LENGTH                       154
+# define PROV_R_INVALID_SIGNATURE_SIZE                    179
+# define PROV_R_INVALID_STATE                             212
+# define PROV_R_INVALID_TAG                               110
+# define PROV_R_INVALID_TAG_LENGTH                        118
+# define PROV_R_INVALID_THREAD_POOL_SIZE                  234
+# define PROV_R_INVALID_UKM_LENGTH                        200
+# define PROV_R_INVALID_X931_DIGEST                       170
+# define PROV_R_IN_ERROR_STATE                            192
+# define PROV_R_KEY_SETUP_FAILED                          101
+# define PROV_R_KEY_SIZE_TOO_SMALL                        171
+# define PROV_R_LENGTH_TOO_LARGE                          202
+# define PROV_R_MISMATCHING_DOMAIN_PARAMETERS             203
+# define PROV_R_MISSING_CEK_ALG                           144
+# define PROV_R_MISSING_CIPHER                            155
+# define PROV_R_MISSING_CONFIG_DATA                       213
+# define PROV_R_MISSING_CONSTANT                          156
+# define PROV_R_MISSING_KEY                               128
+# define PROV_R_MISSING_MAC                               150
+# define PROV_R_MISSING_MESSAGE_DIGEST                    129
+# define PROV_R_MISSING_OID                               209
+# define PROV_R_MISSING_PASS                              130
+# define PROV_R_MISSING_SALT                              131
+# define PROV_R_MISSING_SECRET                            132
+# define PROV_R_MISSING_SEED                              140
+# define PROV_R_MISSING_SESSION_ID                        133
+# define PROV_R_MISSING_TYPE                              134
+# define PROV_R_MISSING_XCGHASH                           135
+# define PROV_R_MODULE_INTEGRITY_FAILURE                  214
+# define PROV_R_NOT_A_PRIVATE_KEY                         221
+# define PROV_R_NOT_A_PUBLIC_KEY                          220
+# define PROV_R_NOT_INSTANTIATED                          193
+# define PROV_R_NOT_PARAMETERS                            226
+# define PROV_R_NOT_SUPPORTED                             136
+# define PROV_R_NOT_XOF_OR_INVALID_LENGTH                 113
+# define PROV_R_NO_KEY_SET                                114
+# define PROV_R_NO_PARAMETERS_SET                         177
+# define PROV_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE  178
+# define PROV_R_OUTPUT_BUFFER_TOO_SMALL                   106
+# define PROV_R_PARENT_CANNOT_GENERATE_RANDOM_NUMBERS     228
+# define PROV_R_PARENT_CANNOT_SUPPLY_ENTROPY_SEED         187
+# define PROV_R_PARENT_LOCKING_NOT_ENABLED                182
+# define PROV_R_PARENT_STRENGTH_TOO_WEAK                  194
+# define PROV_R_PATH_MUST_BE_ABSOLUTE                     219
+# define PROV_R_PERSONALISATION_STRING_TOO_LONG           195
+# define PROV_R_PSS_SALTLEN_TOO_SMALL                     172
+# define PROV_R_REQUEST_TOO_LARGE_FOR_DRBG                196
+# define PROV_R_REQUIRE_CTR_MODE_CIPHER                   206
+# define PROV_R_RESEED_ERROR                              197
+# define PROV_R_SEARCH_ONLY_SUPPORTED_FOR_DIRECTORIES     222
+# define PROV_R_SEED_SOURCES_MUST_NOT_HAVE_A_PARENT       229
+# define PROV_R_SELF_TEST_KAT_FAILURE                     215
+# define PROV_R_SELF_TEST_POST_FAILURE                    216
+# define PROV_R_TAG_NOT_NEEDED                            120
+# define PROV_R_TAG_NOT_SET                               119
+# define PROV_R_TOO_MANY_RECORDS                          126
+# define PROV_R_UNABLE_TO_FIND_CIPHERS                    207
+# define PROV_R_UNABLE_TO_GET_PARENT_STRENGTH             199
+# define PROV_R_UNABLE_TO_GET_PASSPHRASE                  159
+# define PROV_R_UNABLE_TO_INITIALISE_CIPHERS              208
+# define PROV_R_UNABLE_TO_LOAD_SHA256                     147
+# define PROV_R_UNABLE_TO_LOCK_PARENT                     201
+# define PROV_R_UNABLE_TO_RESEED                          204
+# define PROV_R_UNSUPPORTED_CEK_ALG                       145
+# define PROV_R_UNSUPPORTED_KEY_SIZE                      153
+# define PROV_R_UNSUPPORTED_MAC_TYPE                      137
+# define PROV_R_UNSUPPORTED_NUMBER_OF_ROUNDS              152
+# define PROV_R_URI_AUTHORITY_UNSUPPORTED                 223
+# define PROV_R_VALUE_ERROR                               138
+# define PROV_R_WRONG_FINAL_BLOCK_LENGTH                  107
+# define PROV_R_WRONG_OUTPUT_BUFFER_SIZE                  139
+# define PROV_R_XOF_DIGESTS_NOT_ALLOWED                   183
+# define PROV_R_XTS_DATA_UNIT_IS_TOO_LARGE                148
+# define PROV_R_XTS_DUPLICATED_KEYS                       149
+
+#endif
diff --git a/src/include/openssl/provider.h b/src/include/openssl/provider.h
new file mode 100644
index 0000000..24ec082
--- /dev/null
+++ b/src/include/openssl/provider.h
@@ -0,0 +1,66 @@
+/*
+ * Copyright 2019-2023 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_PROVIDER_H
+# define OPENSSL_PROVIDER_H
+# pragma once
+
+# include <openssl/core.h>
+
+# ifdef __cplusplus
+extern "C" {
+# endif
+
+/* Set and Get a library context search path */
+int OSSL_PROVIDER_set_default_search_path(OSSL_LIB_CTX *, const char *path);
+const char *OSSL_PROVIDER_get0_default_search_path(OSSL_LIB_CTX *libctx);
+
+/* Load and unload a provider */
+OSSL_PROVIDER *OSSL_PROVIDER_load(OSSL_LIB_CTX *, const char *name);
+OSSL_PROVIDER *OSSL_PROVIDER_load_ex(OSSL_LIB_CTX *, const char *name,
+                                     OSSL_PARAM *params);
+OSSL_PROVIDER *OSSL_PROVIDER_try_load(OSSL_LIB_CTX *, const char *name,
+                                      int retain_fallbacks);
+OSSL_PROVIDER *OSSL_PROVIDER_try_load_ex(OSSL_LIB_CTX *, const char *name,
+                                         OSSL_PARAM *params,
+                                         int retain_fallbacks);
+int OSSL_PROVIDER_unload(OSSL_PROVIDER *prov);
+int OSSL_PROVIDER_available(OSSL_LIB_CTX *, const char *name);
+int OSSL_PROVIDER_do_all(OSSL_LIB_CTX *ctx,
+                         int (*cb)(OSSL_PROVIDER *provider, void *cbdata),
+                         void *cbdata);
+
+const OSSL_PARAM *OSSL_PROVIDER_gettable_params(const OSSL_PROVIDER *prov);
+int OSSL_PROVIDER_get_params(const OSSL_PROVIDER *prov, OSSL_PARAM params[]);
+int OSSL_PROVIDER_self_test(const OSSL_PROVIDER *prov);
+int OSSL_PROVIDER_get_capabilities(const OSSL_PROVIDER *prov,
+                                   const char *capability,
+                                   OSSL_CALLBACK *cb,
+                                   void *arg);
+
+const OSSL_ALGORITHM *OSSL_PROVIDER_query_operation(const OSSL_PROVIDER *prov,
+                                                    int operation_id,
+                                                    int *no_cache);
+void OSSL_PROVIDER_unquery_operation(const OSSL_PROVIDER *prov,
+                                     int operation_id, const OSSL_ALGORITHM *algs);
+void *OSSL_PROVIDER_get0_provider_ctx(const OSSL_PROVIDER *prov);
+const OSSL_DISPATCH *OSSL_PROVIDER_get0_dispatch(const OSSL_PROVIDER *prov);
+
+/* Add a built in providers */
+int OSSL_PROVIDER_add_builtin(OSSL_LIB_CTX *, const char *name,
+                              OSSL_provider_init_fn *init_fn);
+
+/* Information */
+const char *OSSL_PROVIDER_get0_name(const OSSL_PROVIDER *prov);
+
+# ifdef __cplusplus
+}
+# endif
+
+#endif
diff --git a/src/include/openssl/quic.h b/src/include/openssl/quic.h
new file mode 100644
index 0000000..3dc2f5e
--- /dev/null
+++ b/src/include/openssl/quic.h
@@ -0,0 +1,70 @@
+/*
+ * Copyright 2022-2024 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_QUIC_H
+# define OPENSSL_QUIC_H
+# pragma once
+
+# include <openssl/macros.h>
+# include <openssl/ssl.h>
+
+# ifndef OPENSSL_NO_QUIC
+
+#  ifdef __cplusplus
+extern "C" {
+#  endif
+
+/*
+ * Method used for non-thread-assisted QUIC client operation.
+ */
+__owur const SSL_METHOD *OSSL_QUIC_client_method(void);
+
+/*
+ * Method used for thread-assisted QUIC client operation.
+ */
+__owur const SSL_METHOD *OSSL_QUIC_client_thread_method(void);
+
+/*
+ * QUIC transport error codes (RFC 9000 s. 20.1)
+ */
+#  define OSSL_QUIC_ERR_NO_ERROR                  0x00
+#  define OSSL_QUIC_ERR_INTERNAL_ERROR            0x01
+#  define OSSL_QUIC_ERR_CONNECTION_REFUSED        0x02
+#  define OSSL_QUIC_ERR_FLOW_CONTROL_ERROR        0x03
+#  define OSSL_QUIC_ERR_STREAM_LIMIT_ERROR        0x04
+#  define OSSL_QUIC_ERR_STREAM_STATE_ERROR        0x05
+#  define OSSL_QUIC_ERR_FINAL_SIZE_ERROR          0x06
+#  define OSSL_QUIC_ERR_FRAME_ENCODING_ERROR      0x07
+#  define OSSL_QUIC_ERR_TRANSPORT_PARAMETER_ERROR 0x08
+#  define OSSL_QUIC_ERR_CONNECTION_ID_LIMIT_ERROR 0x09
+#  define OSSL_QUIC_ERR_PROTOCOL_VIOLATION        0x0A
+#  define OSSL_QUIC_ERR_INVALID_TOKEN             0x0B
+#  define OSSL_QUIC_ERR_APPLICATION_ERROR         0x0C
+#  define OSSL_QUIC_ERR_CRYPTO_BUFFER_EXCEEDED    0x0D
+#  define OSSL_QUIC_ERR_KEY_UPDATE_ERROR          0x0E
+#  define OSSL_QUIC_ERR_AEAD_LIMIT_REACHED        0x0F
+#  define OSSL_QUIC_ERR_NO_VIABLE_PATH            0x10
+
+/* Inclusive range for handshake-specific errors. */
+#  define OSSL_QUIC_ERR_CRYPTO_ERR_BEGIN          0x0100
+#  define OSSL_QUIC_ERR_CRYPTO_ERR_END            0x01FF
+
+#  define OSSL_QUIC_ERR_CRYPTO_ERR(X) \
+    (OSSL_QUIC_ERR_CRYPTO_ERR_BEGIN + (X))
+
+/* Local errors. */
+#  define OSSL_QUIC_LOCAL_ERR_IDLE_TIMEOUT        \
+    ((uint64_t)0xFFFFFFFFFFFFFFFFULL)
+
+#  ifdef __cplusplus
+}
+#  endif
+
+# endif /* OPENSSL_NO_QUIC */
+#endif
diff --git a/src/include/openssl/rand.h b/src/include/openssl/rand.h
new file mode 100644
index 0000000..1fa1129
--- /dev/null
+++ b/src/include/openssl/rand.h
@@ -0,0 +1,125 @@
+/*
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_RAND_H
+# define OPENSSL_RAND_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_RAND_H
+# endif
+
+# include <stdlib.h>
+# include <openssl/types.h>
+# include <openssl/e_os2.h>
+# include <openssl/randerr.h>
+# include <openssl/evp.h>
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Default security strength (in the sense of [NIST SP 800-90Ar1])
+ *
+ * NIST SP 800-90Ar1 supports the strength of the DRBG being smaller than that
+ * of the cipher by collecting less entropy. The current DRBG implementation
+ * does not take RAND_DRBG_STRENGTH into account and sets the strength of the
+ * DRBG to that of the cipher.
+ */
+# define RAND_DRBG_STRENGTH             256
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+struct rand_meth_st {
+    int (*seed) (const void *buf, int num);
+    int (*bytes) (unsigned char *buf, int num);
+    void (*cleanup) (void);
+    int (*add) (const void *buf, int num, double randomness);
+    int (*pseudorand) (unsigned char *buf, int num);
+    int (*status) (void);
+};
+
+OSSL_DEPRECATEDIN_3_0 int RAND_set_rand_method(const RAND_METHOD *meth);
+OSSL_DEPRECATEDIN_3_0 const RAND_METHOD *RAND_get_rand_method(void);
+#  ifndef OPENSSL_NO_ENGINE
+OSSL_DEPRECATEDIN_3_0 int RAND_set_rand_engine(ENGINE *engine);
+#  endif
+
+OSSL_DEPRECATEDIN_3_0 RAND_METHOD *RAND_OpenSSL(void);
+# endif /* OPENSSL_NO_DEPRECATED_3_0 */
+
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#   define RAND_cleanup() while(0) continue
+# endif
+int RAND_bytes(unsigned char *buf, int num);
+int RAND_priv_bytes(unsigned char *buf, int num);
+
+/*
+ * Equivalent of RAND_priv_bytes() but additionally taking an OSSL_LIB_CTX and
+ * a strength.
+ */
+int RAND_priv_bytes_ex(OSSL_LIB_CTX *ctx, unsigned char *buf, size_t num,
+                       unsigned int strength);
+
+/*
+ * Equivalent of RAND_bytes() but additionally taking an OSSL_LIB_CTX and
+ * a strength.
+ */
+int RAND_bytes_ex(OSSL_LIB_CTX *ctx, unsigned char *buf, size_t num,
+                  unsigned int strength);
+
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+OSSL_DEPRECATEDIN_1_1_0 int RAND_pseudo_bytes(unsigned char *buf, int num);
+# endif
+
+EVP_RAND_CTX *RAND_get0_primary(OSSL_LIB_CTX *ctx);
+EVP_RAND_CTX *RAND_get0_public(OSSL_LIB_CTX *ctx);
+EVP_RAND_CTX *RAND_get0_private(OSSL_LIB_CTX *ctx);
+int RAND_set0_public(OSSL_LIB_CTX *ctx, EVP_RAND_CTX *rand);
+int RAND_set0_private(OSSL_LIB_CTX *ctx, EVP_RAND_CTX *rand);
+
+int RAND_set_DRBG_type(OSSL_LIB_CTX *ctx, const char *drbg, const char *propq,
+                       const char *cipher, const char *digest);
+int RAND_set_seed_source_type(OSSL_LIB_CTX *ctx, const char *seed,
+                              const char *propq);
+
+void RAND_seed(const void *buf, int num);
+void RAND_keep_random_devices_open(int keep);
+
+# if defined(__ANDROID__) && defined(__NDK_FPABI__)
+__NDK_FPABI__   /* __attribute__((pcs("aapcs"))) on ARM */
+# endif
+void RAND_add(const void *buf, int num, double randomness);
+int RAND_load_file(const char *file, long max_bytes);
+int RAND_write_file(const char *file);
+const char *RAND_file_name(char *file, size_t num);
+int RAND_status(void);
+
+# ifndef OPENSSL_NO_EGD
+int RAND_query_egd_bytes(const char *path, unsigned char *buf, int bytes);
+int RAND_egd(const char *path);
+int RAND_egd_bytes(const char *path, int bytes);
+# endif
+
+int RAND_poll(void);
+
+# if defined(_WIN32) && (defined(BASETYPES) || defined(_WINDEF_H))
+/* application has to include <windows.h> in order to use these */
+#  ifndef OPENSSL_NO_DEPRECATED_1_1_0
+OSSL_DEPRECATEDIN_1_1_0 void RAND_screen(void);
+OSSL_DEPRECATEDIN_1_1_0 int RAND_event(UINT, WPARAM, LPARAM);
+#  endif
+# endif
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/include/openssl/randerr.h b/src/include/openssl/randerr.h
new file mode 100644
index 0000000..0488037
--- /dev/null
+++ b/src/include/openssl/randerr.h
@@ -0,0 +1,69 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_RANDERR_H
+# define OPENSSL_RANDERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+
+/*
+ * RAND reason codes.
+ */
+# define RAND_R_ADDITIONAL_INPUT_TOO_LONG                 102
+# define RAND_R_ALREADY_INSTANTIATED                      103
+# define RAND_R_ARGUMENT_OUT_OF_RANGE                     105
+# define RAND_R_CANNOT_OPEN_FILE                          121
+# define RAND_R_DRBG_ALREADY_INITIALIZED                  129
+# define RAND_R_DRBG_NOT_INITIALISED                      104
+# define RAND_R_ENTROPY_INPUT_TOO_LONG                    106
+# define RAND_R_ENTROPY_OUT_OF_RANGE                      124
+# define RAND_R_ERROR_ENTROPY_POOL_WAS_IGNORED            127
+# define RAND_R_ERROR_INITIALISING_DRBG                   107
+# define RAND_R_ERROR_INSTANTIATING_DRBG                  108
+# define RAND_R_ERROR_RETRIEVING_ADDITIONAL_INPUT         109
+# define RAND_R_ERROR_RETRIEVING_ENTROPY                  110
+# define RAND_R_ERROR_RETRIEVING_NONCE                    111
+# define RAND_R_FAILED_TO_CREATE_LOCK                     126
+# define RAND_R_FUNC_NOT_IMPLEMENTED                      101
+# define RAND_R_FWRITE_ERROR                              123
+# define RAND_R_GENERATE_ERROR                            112
+# define RAND_R_INSUFFICIENT_DRBG_STRENGTH                139
+# define RAND_R_INTERNAL_ERROR                            113
+# define RAND_R_INVALID_PROPERTY_QUERY                    137
+# define RAND_R_IN_ERROR_STATE                            114
+# define RAND_R_NOT_A_REGULAR_FILE                        122
+# define RAND_R_NOT_INSTANTIATED                          115
+# define RAND_R_NO_DRBG_IMPLEMENTATION_SELECTED           128
+# define RAND_R_PARENT_LOCKING_NOT_ENABLED                130
+# define RAND_R_PARENT_STRENGTH_TOO_WEAK                  131
+# define RAND_R_PERSONALISATION_STRING_TOO_LONG           116
+# define RAND_R_PREDICTION_RESISTANCE_NOT_SUPPORTED       133
+# define RAND_R_PRNG_NOT_SEEDED                           100
+# define RAND_R_RANDOM_POOL_OVERFLOW                      125
+# define RAND_R_RANDOM_POOL_UNDERFLOW                     134
+# define RAND_R_REQUEST_TOO_LARGE_FOR_DRBG                117
+# define RAND_R_RESEED_ERROR                              118
+# define RAND_R_SELFTEST_FAILURE                          119
+# define RAND_R_TOO_LITTLE_NONCE_REQUESTED                135
+# define RAND_R_TOO_MUCH_NONCE_REQUESTED                  136
+# define RAND_R_UNABLE_TO_CREATE_DRBG                     143
+# define RAND_R_UNABLE_TO_FETCH_DRBG                      144
+# define RAND_R_UNABLE_TO_GET_PARENT_RESEED_PROP_COUNTER  141
+# define RAND_R_UNABLE_TO_GET_PARENT_STRENGTH             138
+# define RAND_R_UNABLE_TO_LOCK_PARENT                     140
+# define RAND_R_UNSUPPORTED_DRBG_FLAGS                    132
+# define RAND_R_UNSUPPORTED_DRBG_TYPE                     120
+
+#endif
diff --git a/src/include/openssl/rc2.h b/src/include/openssl/rc2.h
new file mode 100644
index 0000000..ff633fd
--- /dev/null
+++ b/src/include/openssl/rc2.h
@@ -0,0 +1,68 @@
+/*
+ * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_RC2_H
+# define OPENSSL_RC2_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_RC2_H
+# endif
+
+# include <openssl/opensslconf.h>
+
+# ifndef OPENSSL_NO_RC2
+#  ifdef  __cplusplus
+extern "C" {
+#  endif
+
+#  define RC2_BLOCK       8
+#  define RC2_KEY_LENGTH  16
+
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+typedef unsigned int RC2_INT;
+
+#   define RC2_ENCRYPT     1
+#   define RC2_DECRYPT     0
+
+typedef struct rc2_key_st {
+    RC2_INT data[64];
+} RC2_KEY;
+#  endif
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 void RC2_set_key(RC2_KEY *key, int len,
+                                       const unsigned char *data, int bits);
+OSSL_DEPRECATEDIN_3_0 void RC2_ecb_encrypt(const unsigned char *in,
+                                           unsigned char *out, RC2_KEY *key,
+                                           int enc);
+OSSL_DEPRECATEDIN_3_0 void RC2_encrypt(unsigned long *data, RC2_KEY *key);
+OSSL_DEPRECATEDIN_3_0 void RC2_decrypt(unsigned long *data, RC2_KEY *key);
+OSSL_DEPRECATEDIN_3_0 void RC2_cbc_encrypt(const unsigned char *in,
+                                           unsigned char *out, long length,
+                                           RC2_KEY *ks, unsigned char *iv,
+                                           int enc);
+OSSL_DEPRECATEDIN_3_0 void RC2_cfb64_encrypt(const unsigned char *in,
+                                             unsigned char *out, long length,
+                                             RC2_KEY *schedule,
+                                             unsigned char *ivec,
+                                             int *num, int enc);
+OSSL_DEPRECATEDIN_3_0 void RC2_ofb64_encrypt(const unsigned char *in,
+                                             unsigned char *out, long length,
+                                             RC2_KEY *schedule,
+                                             unsigned char *ivec,
+                                             int *num);
+#  endif
+
+#  ifdef  __cplusplus
+}
+#  endif
+# endif
+
+#endif
diff --git a/src/include/openssl/rc4.h b/src/include/openssl/rc4.h
new file mode 100644
index 0000000..600b288
--- /dev/null
+++ b/src/include/openssl/rc4.h
@@ -0,0 +1,47 @@
+/*
+ * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_RC4_H
+# define OPENSSL_RC4_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_RC4_H
+# endif
+
+# include <openssl/opensslconf.h>
+
+# ifndef OPENSSL_NO_RC4
+#  include <stddef.h>
+#  ifdef  __cplusplus
+extern "C" {
+#  endif
+
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+typedef struct rc4_key_st {
+    RC4_INT x, y;
+    RC4_INT data[256];
+} RC4_KEY;
+#  endif
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 const char *RC4_options(void);
+OSSL_DEPRECATEDIN_3_0 void RC4_set_key(RC4_KEY *key, int len,
+                                       const unsigned char *data);
+OSSL_DEPRECATEDIN_3_0 void RC4(RC4_KEY *key, size_t len,
+                               const unsigned char *indata,
+                               unsigned char *outdata);
+#  endif
+
+#  ifdef  __cplusplus
+}
+#  endif
+# endif
+
+#endif
diff --git a/src/include/openssl/rc5.h b/src/include/openssl/rc5.h
new file mode 100644
index 0000000..de83352
--- /dev/null
+++ b/src/include/openssl/rc5.h
@@ -0,0 +1,79 @@
+/*
+ * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_RC5_H
+# define OPENSSL_RC5_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_RC5_H
+# endif
+
+# include <openssl/opensslconf.h>
+
+# ifndef OPENSSL_NO_RC5
+#  ifdef  __cplusplus
+extern "C" {
+#  endif
+
+#  define RC5_32_BLOCK            8
+#  define RC5_32_KEY_LENGTH       16/* This is a default, max is 255 */
+
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+#   define RC5_ENCRYPT     1
+#   define RC5_DECRYPT     0
+
+#   define RC5_32_INT unsigned int
+
+/*
+ * This are the only values supported.  Tweak the code if you want more The
+ * most supported modes will be RC5-32/12/16 RC5-32/16/8
+ */
+#   define RC5_8_ROUNDS    8
+#   define RC5_12_ROUNDS   12
+#   define RC5_16_ROUNDS   16
+
+typedef struct rc5_key_st {
+    /* Number of rounds */
+    int rounds;
+    RC5_32_INT data[2 * (RC5_16_ROUNDS + 1)];
+} RC5_32_KEY;
+#  endif
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int RC5_32_set_key(RC5_32_KEY *key, int len,
+                                         const unsigned char *data,
+                                         int rounds);
+OSSL_DEPRECATEDIN_3_0 void RC5_32_ecb_encrypt(const unsigned char *in,
+                                              unsigned char *out,
+                                              RC5_32_KEY *key,
+                                              int enc);
+OSSL_DEPRECATEDIN_3_0 void RC5_32_encrypt(unsigned long *data, RC5_32_KEY *key);
+OSSL_DEPRECATEDIN_3_0 void RC5_32_decrypt(unsigned long *data, RC5_32_KEY *key);
+OSSL_DEPRECATEDIN_3_0 void RC5_32_cbc_encrypt(const unsigned char *in,
+                                              unsigned char *out, long length,
+                                              RC5_32_KEY *ks, unsigned char *iv,
+                                              int enc);
+OSSL_DEPRECATEDIN_3_0 void RC5_32_cfb64_encrypt(const unsigned char *in,
+                                                unsigned char *out, long length,
+                                                RC5_32_KEY *schedule,
+                                                unsigned char *ivec, int *num,
+                                                int enc);
+OSSL_DEPRECATEDIN_3_0 void RC5_32_ofb64_encrypt(const unsigned char *in,
+                                                unsigned char *out, long length,
+                                                RC5_32_KEY *schedule,
+                                                unsigned char *ivec, int *num);
+#  endif
+
+#  ifdef  __cplusplus
+}
+#  endif
+# endif
+
+#endif
diff --git a/src/include/openssl/ripemd.h b/src/include/openssl/ripemd.h
new file mode 100644
index 0000000..900ee31
--- /dev/null
+++ b/src/include/openssl/ripemd.h
@@ -0,0 +1,59 @@
+/*
+ * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_RIPEMD_H
+# define OPENSSL_RIPEMD_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_RIPEMD_H
+# endif
+
+# include <openssl/opensslconf.h>
+
+# ifndef OPENSSL_NO_RMD160
+#  include <openssl/e_os2.h>
+#  include <stddef.h>
+
+#  define RIPEMD160_DIGEST_LENGTH 20
+
+#  ifdef  __cplusplus
+extern "C" {
+#  endif
+#  if !defined(OPENSSL_NO_DEPRECATED_3_0)
+
+#   define RIPEMD160_LONG unsigned int
+
+#   define RIPEMD160_CBLOCK        64
+#   define RIPEMD160_LBLOCK        (RIPEMD160_CBLOCK/4)
+
+typedef struct RIPEMD160state_st {
+    RIPEMD160_LONG A, B, C, D, E;
+    RIPEMD160_LONG Nl, Nh;
+    RIPEMD160_LONG data[RIPEMD160_LBLOCK];
+    unsigned int num;
+} RIPEMD160_CTX;
+#  endif
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int RIPEMD160_Init(RIPEMD160_CTX *c);
+OSSL_DEPRECATEDIN_3_0 int RIPEMD160_Update(RIPEMD160_CTX *c, const void *data,
+                                           size_t len);
+OSSL_DEPRECATEDIN_3_0 int RIPEMD160_Final(unsigned char *md, RIPEMD160_CTX *c);
+OSSL_DEPRECATEDIN_3_0 unsigned char *RIPEMD160(const unsigned char *d, size_t n,
+                                               unsigned char *md);
+OSSL_DEPRECATEDIN_3_0 void RIPEMD160_Transform(RIPEMD160_CTX *c,
+                                               const unsigned char *b);
+#  endif
+
+#  ifdef  __cplusplus
+}
+#  endif
+# endif
+#endif
diff --git a/src/include/openssl/rsa.h b/src/include/openssl/rsa.h
new file mode 100644
index 0000000..167427d
--- /dev/null
+++ b/src/include/openssl/rsa.h
@@ -0,0 +1,615 @@
+/*
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_RSA_H
+# define OPENSSL_RSA_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_RSA_H
+# endif
+
+# include <openssl/opensslconf.h>
+
+# include <openssl/asn1.h>
+# include <openssl/bio.h>
+# include <openssl/crypto.h>
+# include <openssl/types.h>
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#  include <openssl/bn.h>
+# endif
+# include <openssl/rsaerr.h>
+# include <openssl/safestack.h>
+# ifndef OPENSSL_NO_STDIO
+#  include <stdio.h>
+# endif
+
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+# ifndef OPENSSL_RSA_MAX_MODULUS_BITS
+#  define OPENSSL_RSA_MAX_MODULUS_BITS   16384
+# endif
+
+# define RSA_3   0x3L
+# define RSA_F4  0x10001L
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+/* The types RSA and RSA_METHOD are defined in ossl_typ.h */
+
+#  define OPENSSL_RSA_FIPS_MIN_MODULUS_BITS 2048
+
+#  ifndef OPENSSL_RSA_SMALL_MODULUS_BITS
+#   define OPENSSL_RSA_SMALL_MODULUS_BITS 3072
+#  endif
+
+/* exponent limit enforced for "large" modulus only */
+#  ifndef OPENSSL_RSA_MAX_PUBEXP_BITS
+#   define OPENSSL_RSA_MAX_PUBEXP_BITS    64
+#  endif
+/* based on RFC 8017 appendix A.1.2 */
+#  define RSA_ASN1_VERSION_DEFAULT        0
+#  define RSA_ASN1_VERSION_MULTI          1
+
+#  define RSA_DEFAULT_PRIME_NUM           2
+
+#  define RSA_METHOD_FLAG_NO_CHECK        0x0001
+#  define RSA_FLAG_CACHE_PUBLIC           0x0002
+#  define RSA_FLAG_CACHE_PRIVATE          0x0004
+#  define RSA_FLAG_BLINDING               0x0008
+#  define RSA_FLAG_THREAD_SAFE            0x0010
+/*
+ * This flag means the private key operations will be handled by rsa_mod_exp
+ * and that they do not depend on the private key components being present:
+ * for example a key stored in external hardware. Without this flag
+ * bn_mod_exp gets called when private key components are absent.
+ */
+#  define RSA_FLAG_EXT_PKEY               0x0020
+
+/*
+ * new with 0.9.6j and 0.9.7b; the built-in
+ * RSA implementation now uses blinding by
+ * default (ignoring RSA_FLAG_BLINDING),
+ * but other engines might not need it
+ */
+#  define RSA_FLAG_NO_BLINDING            0x0080
+# endif /* OPENSSL_NO_DEPRECATED_3_0 */
+/*
+ * Does nothing. Previously this switched off constant time behaviour.
+ */
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#  define RSA_FLAG_NO_CONSTTIME           0x0000
+# endif
+/* deprecated name for the flag*/
+/*
+ * new with 0.9.7h; the built-in RSA
+ * implementation now uses constant time
+ * modular exponentiation for secret exponents
+ * by default. This flag causes the
+ * faster variable sliding window method to
+ * be used for all exponents.
+ */
+# ifndef OPENSSL_NO_DEPRECATED_0_9_8
+#  define RSA_FLAG_NO_EXP_CONSTTIME RSA_FLAG_NO_CONSTTIME
+# endif
+
+/*-
+ * New with 3.0: use part of the flags to denote exact type of RSA key,
+ * some of which are limited to specific signature and encryption schemes.
+ * These different types share the same RSA structure, but indicate the
+ * use of certain fields in that structure.
+ * Currently known are:
+ * RSA          - this is the "normal" unlimited RSA structure (typenum 0)
+ * RSASSA-PSS   - indicates that the PSS parameters are used.
+ * RSAES-OAEP   - no specific field used for the moment, but OAEP padding
+ *                is expected.  (currently unused)
+ *
+ * 4 bits allow for 16 types
+ */
+# define RSA_FLAG_TYPE_MASK            0xF000
+# define RSA_FLAG_TYPE_RSA             0x0000
+# define RSA_FLAG_TYPE_RSASSAPSS       0x1000
+# define RSA_FLAG_TYPE_RSAESOAEP       0x2000
+
+int EVP_PKEY_CTX_set_rsa_padding(EVP_PKEY_CTX *ctx, int pad_mode);
+int EVP_PKEY_CTX_get_rsa_padding(EVP_PKEY_CTX *ctx, int *pad_mode);
+
+int EVP_PKEY_CTX_set_rsa_pss_saltlen(EVP_PKEY_CTX *ctx, int saltlen);
+int EVP_PKEY_CTX_get_rsa_pss_saltlen(EVP_PKEY_CTX *ctx, int *saltlen);
+
+int EVP_PKEY_CTX_set_rsa_keygen_bits(EVP_PKEY_CTX *ctx, int bits);
+int EVP_PKEY_CTX_set1_rsa_keygen_pubexp(EVP_PKEY_CTX *ctx, BIGNUM *pubexp);
+int EVP_PKEY_CTX_set_rsa_keygen_primes(EVP_PKEY_CTX *ctx, int primes);
+int EVP_PKEY_CTX_set_rsa_pss_keygen_saltlen(EVP_PKEY_CTX *ctx, int saltlen);
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+int EVP_PKEY_CTX_set_rsa_keygen_pubexp(EVP_PKEY_CTX *ctx, BIGNUM *pubexp);
+# endif
+
+/* Salt length matches digest */
+# define RSA_PSS_SALTLEN_DIGEST -1
+/* Verify only: auto detect salt length */
+# define RSA_PSS_SALTLEN_AUTO   -2
+/* Set salt length to maximum possible */
+# define RSA_PSS_SALTLEN_MAX    -3
+/* Auto-detect on verify, set salt length to min(maximum possible, digest
+ * length) on sign */
+# define RSA_PSS_SALTLEN_AUTO_DIGEST_MAX  -4
+/* Old compatible max salt length for sign only */
+# define RSA_PSS_SALTLEN_MAX_SIGN    -2
+
+int EVP_PKEY_CTX_set_rsa_mgf1_md(EVP_PKEY_CTX *ctx, const EVP_MD *md);
+int EVP_PKEY_CTX_set_rsa_mgf1_md_name(EVP_PKEY_CTX *ctx, const char *mdname,
+                                      const char *mdprops);
+int EVP_PKEY_CTX_get_rsa_mgf1_md(EVP_PKEY_CTX *ctx, const EVP_MD **md);
+int EVP_PKEY_CTX_get_rsa_mgf1_md_name(EVP_PKEY_CTX *ctx, char *name,
+                                      size_t namelen);
+int EVP_PKEY_CTX_set_rsa_pss_keygen_mgf1_md(EVP_PKEY_CTX *ctx, const EVP_MD *md);
+int EVP_PKEY_CTX_set_rsa_pss_keygen_mgf1_md_name(EVP_PKEY_CTX *ctx,
+                                                 const char *mdname);
+
+int EVP_PKEY_CTX_set_rsa_pss_keygen_md(EVP_PKEY_CTX *ctx, const EVP_MD *md);
+int EVP_PKEY_CTX_set_rsa_pss_keygen_md_name(EVP_PKEY_CTX *ctx,
+                                            const char *mdname,
+                                            const char *mdprops);
+
+int EVP_PKEY_CTX_set_rsa_oaep_md(EVP_PKEY_CTX *ctx, const EVP_MD *md);
+int EVP_PKEY_CTX_set_rsa_oaep_md_name(EVP_PKEY_CTX *ctx, const char *mdname,
+                                      const char *mdprops);
+int EVP_PKEY_CTX_get_rsa_oaep_md(EVP_PKEY_CTX *ctx, const EVP_MD **md);
+int EVP_PKEY_CTX_get_rsa_oaep_md_name(EVP_PKEY_CTX *ctx, char *name,
+                                      size_t namelen);
+int EVP_PKEY_CTX_set0_rsa_oaep_label(EVP_PKEY_CTX *ctx, void *label, int llen);
+int EVP_PKEY_CTX_get0_rsa_oaep_label(EVP_PKEY_CTX *ctx, unsigned char **label);
+
+# define EVP_PKEY_CTRL_RSA_PADDING       (EVP_PKEY_ALG_CTRL + 1)
+# define EVP_PKEY_CTRL_RSA_PSS_SALTLEN   (EVP_PKEY_ALG_CTRL + 2)
+
+# define EVP_PKEY_CTRL_RSA_KEYGEN_BITS   (EVP_PKEY_ALG_CTRL + 3)
+# define EVP_PKEY_CTRL_RSA_KEYGEN_PUBEXP (EVP_PKEY_ALG_CTRL + 4)
+# define EVP_PKEY_CTRL_RSA_MGF1_MD       (EVP_PKEY_ALG_CTRL + 5)
+
+# define EVP_PKEY_CTRL_GET_RSA_PADDING           (EVP_PKEY_ALG_CTRL + 6)
+# define EVP_PKEY_CTRL_GET_RSA_PSS_SALTLEN       (EVP_PKEY_ALG_CTRL + 7)
+# define EVP_PKEY_CTRL_GET_RSA_MGF1_MD           (EVP_PKEY_ALG_CTRL + 8)
+
+# define EVP_PKEY_CTRL_RSA_OAEP_MD       (EVP_PKEY_ALG_CTRL + 9)
+# define EVP_PKEY_CTRL_RSA_OAEP_LABEL    (EVP_PKEY_ALG_CTRL + 10)
+
+# define EVP_PKEY_CTRL_GET_RSA_OAEP_MD   (EVP_PKEY_ALG_CTRL + 11)
+# define EVP_PKEY_CTRL_GET_RSA_OAEP_LABEL (EVP_PKEY_ALG_CTRL + 12)
+
+# define EVP_PKEY_CTRL_RSA_KEYGEN_PRIMES  (EVP_PKEY_ALG_CTRL + 13)
+
+# define EVP_PKEY_CTRL_RSA_IMPLICIT_REJECTION (EVP_PKEY_ALG_CTRL + 14)
+
+# define RSA_PKCS1_PADDING          1
+# define RSA_NO_PADDING             3
+# define RSA_PKCS1_OAEP_PADDING     4
+# define RSA_X931_PADDING           5
+
+/* EVP_PKEY_ only */
+# define RSA_PKCS1_PSS_PADDING      6
+# define RSA_PKCS1_WITH_TLS_PADDING 7
+
+/* internal RSA_ only */
+# define RSA_PKCS1_NO_IMPLICIT_REJECT_PADDING 8
+
+# define RSA_PKCS1_PADDING_SIZE    11
+
+# define RSA_set_app_data(s,arg)         RSA_set_ex_data(s,0,arg)
+# define RSA_get_app_data(s)             RSA_get_ex_data(s,0)
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 RSA *RSA_new(void);
+OSSL_DEPRECATEDIN_3_0 RSA *RSA_new_method(ENGINE *engine);
+OSSL_DEPRECATEDIN_3_0 int RSA_bits(const RSA *rsa);
+OSSL_DEPRECATEDIN_3_0 int RSA_size(const RSA *rsa);
+OSSL_DEPRECATEDIN_3_0 int RSA_security_bits(const RSA *rsa);
+
+OSSL_DEPRECATEDIN_3_0 int RSA_set0_key(RSA *r, BIGNUM *n, BIGNUM *e, BIGNUM *d);
+OSSL_DEPRECATEDIN_3_0 int RSA_set0_factors(RSA *r, BIGNUM *p, BIGNUM *q);
+OSSL_DEPRECATEDIN_3_0 int RSA_set0_crt_params(RSA *r,
+                                              BIGNUM *dmp1, BIGNUM *dmq1,
+                                              BIGNUM *iqmp);
+OSSL_DEPRECATEDIN_3_0 int RSA_set0_multi_prime_params(RSA *r,
+                                                      BIGNUM *primes[],
+                                                      BIGNUM *exps[],
+                                                      BIGNUM *coeffs[],
+                                                      int pnum);
+OSSL_DEPRECATEDIN_3_0 void RSA_get0_key(const RSA *r,
+                                        const BIGNUM **n, const BIGNUM **e,
+                                        const BIGNUM **d);
+OSSL_DEPRECATEDIN_3_0 void RSA_get0_factors(const RSA *r,
+                                            const BIGNUM **p, const BIGNUM **q);
+OSSL_DEPRECATEDIN_3_0 int RSA_get_multi_prime_extra_count(const RSA *r);
+OSSL_DEPRECATEDIN_3_0 int RSA_get0_multi_prime_factors(const RSA *r,
+                                                       const BIGNUM *primes[]);
+OSSL_DEPRECATEDIN_3_0 void RSA_get0_crt_params(const RSA *r,
+                                               const BIGNUM **dmp1,
+                                               const BIGNUM **dmq1,
+                                               const BIGNUM **iqmp);
+OSSL_DEPRECATEDIN_3_0
+int RSA_get0_multi_prime_crt_params(const RSA *r, const BIGNUM *exps[],
+                                    const BIGNUM *coeffs[]);
+OSSL_DEPRECATEDIN_3_0 const BIGNUM *RSA_get0_n(const RSA *d);
+OSSL_DEPRECATEDIN_3_0 const BIGNUM *RSA_get0_e(const RSA *d);
+OSSL_DEPRECATEDIN_3_0 const BIGNUM *RSA_get0_d(const RSA *d);
+OSSL_DEPRECATEDIN_3_0 const BIGNUM *RSA_get0_p(const RSA *d);
+OSSL_DEPRECATEDIN_3_0 const BIGNUM *RSA_get0_q(const RSA *d);
+OSSL_DEPRECATEDIN_3_0 const BIGNUM *RSA_get0_dmp1(const RSA *r);
+OSSL_DEPRECATEDIN_3_0 const BIGNUM *RSA_get0_dmq1(const RSA *r);
+OSSL_DEPRECATEDIN_3_0 const BIGNUM *RSA_get0_iqmp(const RSA *r);
+OSSL_DEPRECATEDIN_3_0 const RSA_PSS_PARAMS *RSA_get0_pss_params(const RSA *r);
+OSSL_DEPRECATEDIN_3_0 void RSA_clear_flags(RSA *r, int flags);
+OSSL_DEPRECATEDIN_3_0 int RSA_test_flags(const RSA *r, int flags);
+OSSL_DEPRECATEDIN_3_0 void RSA_set_flags(RSA *r, int flags);
+OSSL_DEPRECATEDIN_3_0 int RSA_get_version(RSA *r);
+OSSL_DEPRECATEDIN_3_0 ENGINE *RSA_get0_engine(const RSA *r);
+# endif  /* !OPENSSL_NO_DEPRECATED_3_0 */
+
+# define EVP_RSA_gen(bits) \
+    EVP_PKEY_Q_keygen(NULL, NULL, "RSA", (size_t)(0 + (bits)))
+
+/* Deprecated version */
+# ifndef OPENSSL_NO_DEPRECATED_0_9_8
+OSSL_DEPRECATEDIN_0_9_8 RSA *RSA_generate_key(int bits, unsigned long e, void
+                                              (*callback) (int, int, void *),
+                                              void *cb_arg);
+# endif
+
+/* New version */
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int RSA_generate_key_ex(RSA *rsa, int bits, BIGNUM *e,
+                                              BN_GENCB *cb);
+/* Multi-prime version */
+OSSL_DEPRECATEDIN_3_0 int RSA_generate_multi_prime_key(RSA *rsa, int bits,
+                                                       int primes, BIGNUM *e,
+                                                       BN_GENCB *cb);
+
+OSSL_DEPRECATEDIN_3_0
+int RSA_X931_derive_ex(RSA *rsa, BIGNUM *p1, BIGNUM *p2,
+                       BIGNUM *q1, BIGNUM *q2,
+                       const BIGNUM *Xp1, const BIGNUM *Xp2,
+                       const BIGNUM *Xp, const BIGNUM *Xq1,
+                       const BIGNUM *Xq2, const BIGNUM *Xq,
+                       const BIGNUM *e, BN_GENCB *cb);
+OSSL_DEPRECATEDIN_3_0 int RSA_X931_generate_key_ex(RSA *rsa, int bits,
+                                                   const BIGNUM *e,
+                                                   BN_GENCB *cb);
+
+OSSL_DEPRECATEDIN_3_0 int RSA_check_key(const RSA *);
+OSSL_DEPRECATEDIN_3_0 int RSA_check_key_ex(const RSA *, BN_GENCB *cb);
+        /* next 4 return -1 on error */
+OSSL_DEPRECATEDIN_3_0
+int RSA_public_encrypt(int flen, const unsigned char *from, unsigned char *to,
+                       RSA *rsa, int padding);
+OSSL_DEPRECATEDIN_3_0
+int RSA_private_encrypt(int flen, const unsigned char *from, unsigned char *to,
+                        RSA *rsa, int padding);
+OSSL_DEPRECATEDIN_3_0
+int RSA_public_decrypt(int flen, const unsigned char *from, unsigned char *to,
+                       RSA *rsa, int padding);
+OSSL_DEPRECATEDIN_3_0
+int RSA_private_decrypt(int flen, const unsigned char *from, unsigned char *to,
+                        RSA *rsa, int padding);
+OSSL_DEPRECATEDIN_3_0 void RSA_free(RSA *r);
+/* "up" the RSA object's reference count */
+OSSL_DEPRECATEDIN_3_0 int RSA_up_ref(RSA *r);
+OSSL_DEPRECATEDIN_3_0 int RSA_flags(const RSA *r);
+
+OSSL_DEPRECATEDIN_3_0 void RSA_set_default_method(const RSA_METHOD *meth);
+OSSL_DEPRECATEDIN_3_0 const RSA_METHOD *RSA_get_default_method(void);
+OSSL_DEPRECATEDIN_3_0 const RSA_METHOD *RSA_null_method(void);
+OSSL_DEPRECATEDIN_3_0 const RSA_METHOD *RSA_get_method(const RSA *rsa);
+OSSL_DEPRECATEDIN_3_0 int RSA_set_method(RSA *rsa, const RSA_METHOD *meth);
+
+/* these are the actual RSA functions */
+OSSL_DEPRECATEDIN_3_0 const RSA_METHOD *RSA_PKCS1_OpenSSL(void);
+
+DECLARE_ASN1_ENCODE_FUNCTIONS_name_attr(OSSL_DEPRECATEDIN_3_0,
+                                        RSA, RSAPublicKey)
+DECLARE_ASN1_ENCODE_FUNCTIONS_name_attr(OSSL_DEPRECATEDIN_3_0,
+                                        RSA, RSAPrivateKey)
+# endif  /* !OPENSSL_NO_DEPRECATED_3_0 */
+
+int RSA_pkey_ctx_ctrl(EVP_PKEY_CTX *ctx, int optype, int cmd, int p1, void *p2);
+
+struct rsa_pss_params_st {
+    X509_ALGOR *hashAlgorithm;
+    X509_ALGOR *maskGenAlgorithm;
+    ASN1_INTEGER *saltLength;
+    ASN1_INTEGER *trailerField;
+    /* Decoded hash algorithm from maskGenAlgorithm */
+    X509_ALGOR *maskHash;
+};
+
+DECLARE_ASN1_FUNCTIONS(RSA_PSS_PARAMS)
+DECLARE_ASN1_DUP_FUNCTION(RSA_PSS_PARAMS)
+
+typedef struct rsa_oaep_params_st {
+    X509_ALGOR *hashFunc;
+    X509_ALGOR *maskGenFunc;
+    X509_ALGOR *pSourceFunc;
+    /* Decoded hash algorithm from maskGenFunc */
+    X509_ALGOR *maskHash;
+} RSA_OAEP_PARAMS;
+
+DECLARE_ASN1_FUNCTIONS(RSA_OAEP_PARAMS)
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  ifndef OPENSSL_NO_STDIO
+OSSL_DEPRECATEDIN_3_0 int RSA_print_fp(FILE *fp, const RSA *r, int offset);
+#  endif
+
+OSSL_DEPRECATEDIN_3_0 int RSA_print(BIO *bp, const RSA *r, int offset);
+
+/*
+ * The following 2 functions sign and verify a X509_SIG ASN1 object inside
+ * PKCS#1 padded RSA encryption
+ */
+OSSL_DEPRECATEDIN_3_0 int RSA_sign(int type, const unsigned char *m,
+                                   unsigned int m_length, unsigned char *sigret,
+                                   unsigned int *siglen, RSA *rsa);
+OSSL_DEPRECATEDIN_3_0 int RSA_verify(int type, const unsigned char *m,
+                                     unsigned int m_length,
+                                     const unsigned char *sigbuf,
+                                     unsigned int siglen, RSA *rsa);
+
+/*
+ * The following 2 function sign and verify a ASN1_OCTET_STRING object inside
+ * PKCS#1 padded RSA encryption
+ */
+OSSL_DEPRECATEDIN_3_0
+int RSA_sign_ASN1_OCTET_STRING(int type,
+                               const unsigned char *m, unsigned int m_length,
+                               unsigned char *sigret, unsigned int *siglen,
+                               RSA *rsa);
+OSSL_DEPRECATEDIN_3_0
+int RSA_verify_ASN1_OCTET_STRING(int type,
+                                 const unsigned char *m, unsigned int m_length,
+                                 unsigned char *sigbuf, unsigned int siglen,
+                                 RSA *rsa);
+
+OSSL_DEPRECATEDIN_3_0 int RSA_blinding_on(RSA *rsa, BN_CTX *ctx);
+OSSL_DEPRECATEDIN_3_0 void RSA_blinding_off(RSA *rsa);
+OSSL_DEPRECATEDIN_3_0 BN_BLINDING *RSA_setup_blinding(RSA *rsa, BN_CTX *ctx);
+
+OSSL_DEPRECATEDIN_3_0
+int RSA_padding_add_PKCS1_type_1(unsigned char *to, int tlen,
+                                 const unsigned char *f, int fl);
+OSSL_DEPRECATEDIN_3_0
+int RSA_padding_check_PKCS1_type_1(unsigned char *to, int tlen,
+                                   const unsigned char *f, int fl,
+                                   int rsa_len);
+OSSL_DEPRECATEDIN_3_0
+int RSA_padding_add_PKCS1_type_2(unsigned char *to, int tlen,
+                                 const unsigned char *f, int fl);
+OSSL_DEPRECATEDIN_3_0
+int RSA_padding_check_PKCS1_type_2(unsigned char *to, int tlen,
+                                   const unsigned char *f, int fl,
+                                   int rsa_len);
+OSSL_DEPRECATEDIN_3_0 int PKCS1_MGF1(unsigned char *mask, long len,
+                                     const unsigned char *seed, long seedlen,
+                                     const EVP_MD *dgst);
+OSSL_DEPRECATEDIN_3_0
+int RSA_padding_add_PKCS1_OAEP(unsigned char *to, int tlen,
+                               const unsigned char *f, int fl,
+                               const unsigned char *p, int pl);
+OSSL_DEPRECATEDIN_3_0
+int RSA_padding_check_PKCS1_OAEP(unsigned char *to, int tlen,
+                                 const unsigned char *f, int fl, int rsa_len,
+                                 const unsigned char *p, int pl);
+OSSL_DEPRECATEDIN_3_0
+int RSA_padding_add_PKCS1_OAEP_mgf1(unsigned char *to, int tlen,
+                                    const unsigned char *from, int flen,
+                                    const unsigned char *param, int plen,
+                                    const EVP_MD *md, const EVP_MD *mgf1md);
+OSSL_DEPRECATEDIN_3_0
+int RSA_padding_check_PKCS1_OAEP_mgf1(unsigned char *to, int tlen,
+                                      const unsigned char *from, int flen,
+                                      int num,
+                                      const unsigned char *param, int plen,
+                                      const EVP_MD *md, const EVP_MD *mgf1md);
+OSSL_DEPRECATEDIN_3_0 int RSA_padding_add_none(unsigned char *to, int tlen,
+                                               const unsigned char *f, int fl);
+OSSL_DEPRECATEDIN_3_0 int RSA_padding_check_none(unsigned char *to, int tlen,
+                                                 const unsigned char *f, int fl,
+                                                 int rsa_len);
+OSSL_DEPRECATEDIN_3_0 int RSA_padding_add_X931(unsigned char *to, int tlen,
+                                               const unsigned char *f, int fl);
+OSSL_DEPRECATEDIN_3_0 int RSA_padding_check_X931(unsigned char *to, int tlen,
+                                                 const unsigned char *f, int fl,
+                                                 int rsa_len);
+OSSL_DEPRECATEDIN_3_0 int RSA_X931_hash_id(int nid);
+
+OSSL_DEPRECATEDIN_3_0
+int RSA_verify_PKCS1_PSS(RSA *rsa, const unsigned char *mHash,
+                         const EVP_MD *Hash, const unsigned char *EM,
+                         int sLen);
+OSSL_DEPRECATEDIN_3_0
+int RSA_padding_add_PKCS1_PSS(RSA *rsa, unsigned char *EM,
+                              const unsigned char *mHash, const EVP_MD *Hash,
+                              int sLen);
+
+OSSL_DEPRECATEDIN_3_0
+int RSA_verify_PKCS1_PSS_mgf1(RSA *rsa, const unsigned char *mHash,
+                              const EVP_MD *Hash, const EVP_MD *mgf1Hash,
+                              const unsigned char *EM, int sLen);
+
+OSSL_DEPRECATEDIN_3_0
+int RSA_padding_add_PKCS1_PSS_mgf1(RSA *rsa, unsigned char *EM,
+                                   const unsigned char *mHash,
+                                   const EVP_MD *Hash, const EVP_MD *mgf1Hash,
+                                   int sLen);
+
+# define RSA_get_ex_new_index(l, p, newf, dupf, freef) \
+    CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_RSA, l, p, newf, dupf, freef)
+OSSL_DEPRECATEDIN_3_0 int RSA_set_ex_data(RSA *r, int idx, void *arg);
+OSSL_DEPRECATEDIN_3_0 void *RSA_get_ex_data(const RSA *r, int idx);
+
+DECLARE_ASN1_DUP_FUNCTION_name_attr(OSSL_DEPRECATEDIN_3_0, RSA, RSAPublicKey)
+DECLARE_ASN1_DUP_FUNCTION_name_attr(OSSL_DEPRECATEDIN_3_0, RSA, RSAPrivateKey)
+
+/*
+ * If this flag is set the RSA method is FIPS compliant and can be used in
+ * FIPS mode. This is set in the validated module method. If an application
+ * sets this flag in its own methods it is its responsibility to ensure the
+ * result is compliant.
+ */
+
+#  define RSA_FLAG_FIPS_METHOD                    0x0400
+
+/*
+ * If this flag is set the operations normally disabled in FIPS mode are
+ * permitted it is then the applications responsibility to ensure that the
+ * usage is compliant.
+ */
+
+#  define RSA_FLAG_NON_FIPS_ALLOW                 0x0400
+/*
+ * Application has decided PRNG is good enough to generate a key: don't
+ * check.
+ */
+#  define RSA_FLAG_CHECKED                        0x0800
+
+OSSL_DEPRECATEDIN_3_0 RSA_METHOD *RSA_meth_new(const char *name, int flags);
+OSSL_DEPRECATEDIN_3_0 void RSA_meth_free(RSA_METHOD *meth);
+OSSL_DEPRECATEDIN_3_0 RSA_METHOD *RSA_meth_dup(const RSA_METHOD *meth);
+OSSL_DEPRECATEDIN_3_0 const char *RSA_meth_get0_name(const RSA_METHOD *meth);
+OSSL_DEPRECATEDIN_3_0 int RSA_meth_set1_name(RSA_METHOD *meth,
+                                             const char *name);
+OSSL_DEPRECATEDIN_3_0 int RSA_meth_get_flags(const RSA_METHOD *meth);
+OSSL_DEPRECATEDIN_3_0 int RSA_meth_set_flags(RSA_METHOD *meth, int flags);
+OSSL_DEPRECATEDIN_3_0 void *RSA_meth_get0_app_data(const RSA_METHOD *meth);
+OSSL_DEPRECATEDIN_3_0 int RSA_meth_set0_app_data(RSA_METHOD *meth,
+                                                 void *app_data);
+OSSL_DEPRECATEDIN_3_0
+int (*RSA_meth_get_pub_enc(const RSA_METHOD *meth)) (int flen,
+                                                     const unsigned char *from,
+                                                     unsigned char *to,
+                                                     RSA *rsa, int padding);
+OSSL_DEPRECATEDIN_3_0
+int RSA_meth_set_pub_enc(RSA_METHOD *rsa,
+                         int (*pub_enc) (int flen, const unsigned char *from,
+                                         unsigned char *to, RSA *rsa,
+                                         int padding));
+OSSL_DEPRECATEDIN_3_0
+int (*RSA_meth_get_pub_dec(const RSA_METHOD *meth)) (int flen,
+                                                     const unsigned char *from,
+                                                     unsigned char *to,
+                                                     RSA *rsa, int padding);
+OSSL_DEPRECATEDIN_3_0
+int RSA_meth_set_pub_dec(RSA_METHOD *rsa,
+                         int (*pub_dec) (int flen, const unsigned char *from,
+                                         unsigned char *to, RSA *rsa,
+                                         int padding));
+OSSL_DEPRECATEDIN_3_0
+int (*RSA_meth_get_priv_enc(const RSA_METHOD *meth)) (int flen,
+                                                      const unsigned char *from,
+                                                      unsigned char *to,
+                                                      RSA *rsa, int padding);
+OSSL_DEPRECATEDIN_3_0
+int RSA_meth_set_priv_enc(RSA_METHOD *rsa,
+                          int (*priv_enc) (int flen, const unsigned char *from,
+                                           unsigned char *to, RSA *rsa,
+                                           int padding));
+OSSL_DEPRECATEDIN_3_0
+int (*RSA_meth_get_priv_dec(const RSA_METHOD *meth)) (int flen,
+                                                      const unsigned char *from,
+                                                      unsigned char *to,
+                                                      RSA *rsa, int padding);
+OSSL_DEPRECATEDIN_3_0
+int RSA_meth_set_priv_dec(RSA_METHOD *rsa,
+                          int (*priv_dec) (int flen, const unsigned char *from,
+                                           unsigned char *to, RSA *rsa,
+                                           int padding));
+OSSL_DEPRECATEDIN_3_0
+int (*RSA_meth_get_mod_exp(const RSA_METHOD *meth)) (BIGNUM *r0,
+                                                     const BIGNUM *i,
+                                                     RSA *rsa, BN_CTX *ctx);
+OSSL_DEPRECATEDIN_3_0
+int RSA_meth_set_mod_exp(RSA_METHOD *rsa,
+                         int (*mod_exp) (BIGNUM *r0, const BIGNUM *i, RSA *rsa,
+                                         BN_CTX *ctx));
+OSSL_DEPRECATEDIN_3_0
+int (*RSA_meth_get_bn_mod_exp(const RSA_METHOD *meth)) (BIGNUM *r,
+                                                        const BIGNUM *a,
+                                                        const BIGNUM *p,
+                                                        const BIGNUM *m,
+                                                        BN_CTX *ctx,
+                                                        BN_MONT_CTX *m_ctx);
+OSSL_DEPRECATEDIN_3_0
+int RSA_meth_set_bn_mod_exp(RSA_METHOD *rsa,
+                            int (*bn_mod_exp) (BIGNUM *r,
+                                               const BIGNUM *a,
+                                               const BIGNUM *p,
+                                               const BIGNUM *m,
+                                               BN_CTX *ctx,
+                                               BN_MONT_CTX *m_ctx));
+OSSL_DEPRECATEDIN_3_0
+int (*RSA_meth_get_init(const RSA_METHOD *meth)) (RSA *rsa);
+OSSL_DEPRECATEDIN_3_0
+int RSA_meth_set_init(RSA_METHOD *rsa, int (*init) (RSA *rsa));
+OSSL_DEPRECATEDIN_3_0
+int (*RSA_meth_get_finish(const RSA_METHOD *meth)) (RSA *rsa);
+OSSL_DEPRECATEDIN_3_0
+int RSA_meth_set_finish(RSA_METHOD *rsa, int (*finish) (RSA *rsa));
+OSSL_DEPRECATEDIN_3_0
+int (*RSA_meth_get_sign(const RSA_METHOD *meth)) (int type,
+                                                  const unsigned char *m,
+                                                  unsigned int m_length,
+                                                  unsigned char *sigret,
+                                                  unsigned int *siglen,
+                                                  const RSA *rsa);
+OSSL_DEPRECATEDIN_3_0
+int RSA_meth_set_sign(RSA_METHOD *rsa,
+                      int (*sign) (int type, const unsigned char *m,
+                                   unsigned int m_length,
+                                   unsigned char *sigret, unsigned int *siglen,
+                                   const RSA *rsa));
+OSSL_DEPRECATEDIN_3_0
+int (*RSA_meth_get_verify(const RSA_METHOD *meth)) (int dtype,
+                                                    const unsigned char *m,
+                                                    unsigned int m_length,
+                                                    const unsigned char *sigbuf,
+                                                    unsigned int siglen,
+                                                    const RSA *rsa);
+OSSL_DEPRECATEDIN_3_0
+int RSA_meth_set_verify(RSA_METHOD *rsa,
+                        int (*verify) (int dtype, const unsigned char *m,
+                                       unsigned int m_length,
+                                       const unsigned char *sigbuf,
+                                       unsigned int siglen, const RSA *rsa));
+OSSL_DEPRECATEDIN_3_0
+int (*RSA_meth_get_keygen(const RSA_METHOD *meth)) (RSA *rsa, int bits,
+                                                    BIGNUM *e, BN_GENCB *cb);
+OSSL_DEPRECATEDIN_3_0
+int RSA_meth_set_keygen(RSA_METHOD *rsa,
+                        int (*keygen) (RSA *rsa, int bits, BIGNUM *e,
+                                       BN_GENCB *cb));
+OSSL_DEPRECATEDIN_3_0
+int (*RSA_meth_get_multi_prime_keygen(const RSA_METHOD *meth)) (RSA *rsa,
+                                                                int bits,
+                                                                int primes,
+                                                                BIGNUM *e,
+                                                                BN_GENCB *cb);
+OSSL_DEPRECATEDIN_3_0
+int RSA_meth_set_multi_prime_keygen(RSA_METHOD *meth,
+                                    int (*keygen) (RSA *rsa, int bits,
+                                                   int primes, BIGNUM *e,
+                                                   BN_GENCB *cb));
+#endif  /* !OPENSSL_NO_DEPRECATED_3_0 */
+
+# ifdef  __cplusplus
+}
+# endif
+#endif
diff --git a/src/include/openssl/rsaerr.h b/src/include/openssl/rsaerr.h
new file mode 100644
index 0000000..c58463c
--- /dev/null
+++ b/src/include/openssl/rsaerr.h
@@ -0,0 +1,107 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_RSAERR_H
+# define OPENSSL_RSAERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+
+/*
+ * RSA reason codes.
+ */
+# define RSA_R_ALGORITHM_MISMATCH                         100
+# define RSA_R_BAD_E_VALUE                                101
+# define RSA_R_BAD_FIXED_HEADER_DECRYPT                   102
+# define RSA_R_BAD_PAD_BYTE_COUNT                         103
+# define RSA_R_BAD_SIGNATURE                              104
+# define RSA_R_BLOCK_TYPE_IS_NOT_01                       106
+# define RSA_R_BLOCK_TYPE_IS_NOT_02                       107
+# define RSA_R_DATA_GREATER_THAN_MOD_LEN                  108
+# define RSA_R_DATA_TOO_LARGE                             109
+# define RSA_R_DATA_TOO_LARGE_FOR_KEY_SIZE                110
+# define RSA_R_DATA_TOO_LARGE_FOR_MODULUS                 132
+# define RSA_R_DATA_TOO_SMALL                             111
+# define RSA_R_DATA_TOO_SMALL_FOR_KEY_SIZE                122
+# define RSA_R_DIGEST_DOES_NOT_MATCH                      158
+# define RSA_R_DIGEST_NOT_ALLOWED                         145
+# define RSA_R_DIGEST_TOO_BIG_FOR_RSA_KEY                 112
+# define RSA_R_DMP1_NOT_CONGRUENT_TO_D                    124
+# define RSA_R_DMQ1_NOT_CONGRUENT_TO_D                    125
+# define RSA_R_D_E_NOT_CONGRUENT_TO_1                     123
+# define RSA_R_FIRST_OCTET_INVALID                        133
+# define RSA_R_ILLEGAL_OR_UNSUPPORTED_PADDING_MODE        144
+# define RSA_R_INVALID_DIGEST                             157
+# define RSA_R_INVALID_DIGEST_LENGTH                      143
+# define RSA_R_INVALID_HEADER                             137
+# define RSA_R_INVALID_KEYPAIR                            171
+# define RSA_R_INVALID_KEY_LENGTH                         173
+# define RSA_R_INVALID_LABEL                              160
+# define RSA_R_INVALID_LENGTH                             181
+# define RSA_R_INVALID_MESSAGE_LENGTH                     131
+# define RSA_R_INVALID_MGF1_MD                            156
+# define RSA_R_INVALID_MODULUS                            174
+# define RSA_R_INVALID_MULTI_PRIME_KEY                    167
+# define RSA_R_INVALID_OAEP_PARAMETERS                    161
+# define RSA_R_INVALID_PADDING                            138
+# define RSA_R_INVALID_PADDING_MODE                       141
+# define RSA_R_INVALID_PSS_PARAMETERS                     149
+# define RSA_R_INVALID_PSS_SALTLEN                        146
+# define RSA_R_INVALID_REQUEST                            175
+# define RSA_R_INVALID_SALT_LENGTH                        150
+# define RSA_R_INVALID_STRENGTH                           176
+# define RSA_R_INVALID_TRAILER                            139
+# define RSA_R_INVALID_X931_DIGEST                        142
+# define RSA_R_IQMP_NOT_INVERSE_OF_Q                      126
+# define RSA_R_KEY_PRIME_NUM_INVALID                      165
+# define RSA_R_KEY_SIZE_TOO_SMALL                         120
+# define RSA_R_LAST_OCTET_INVALID                         134
+# define RSA_R_MGF1_DIGEST_NOT_ALLOWED                    152
+# define RSA_R_MISSING_PRIVATE_KEY                        179
+# define RSA_R_MODULUS_TOO_LARGE                          105
+# define RSA_R_MP_COEFFICIENT_NOT_INVERSE_OF_R            168
+# define RSA_R_MP_EXPONENT_NOT_CONGRUENT_TO_D             169
+# define RSA_R_MP_R_NOT_PRIME                             170
+# define RSA_R_NO_PUBLIC_EXPONENT                         140
+# define RSA_R_NULL_BEFORE_BLOCK_MISSING                  113
+# define RSA_R_N_DOES_NOT_EQUAL_PRODUCT_OF_PRIMES         172
+# define RSA_R_N_DOES_NOT_EQUAL_P_Q                       127
+# define RSA_R_OAEP_DECODING_ERROR                        121
+# define RSA_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE   148
+# define RSA_R_PADDING_CHECK_FAILED                       114
+# define RSA_R_PAIRWISE_TEST_FAILURE                      177
+# define RSA_R_PKCS_DECODING_ERROR                        159
+# define RSA_R_PSS_SALTLEN_TOO_SMALL                      164
+# define RSA_R_PUB_EXPONENT_OUT_OF_RANGE                  178
+# define RSA_R_P_NOT_PRIME                                128
+# define RSA_R_Q_NOT_PRIME                                129
+# define RSA_R_RANDOMNESS_SOURCE_STRENGTH_INSUFFICIENT    180
+# define RSA_R_RSA_OPERATIONS_NOT_SUPPORTED               130
+# define RSA_R_SLEN_CHECK_FAILED                          136
+# define RSA_R_SLEN_RECOVERY_FAILED                       135
+# define RSA_R_SSLV3_ROLLBACK_ATTACK                      115
+# define RSA_R_THE_ASN1_OBJECT_IDENTIFIER_IS_NOT_KNOWN_FOR_THIS_MD 116
+# define RSA_R_UNKNOWN_ALGORITHM_TYPE                     117
+# define RSA_R_UNKNOWN_DIGEST                             166
+# define RSA_R_UNKNOWN_MASK_DIGEST                        151
+# define RSA_R_UNKNOWN_PADDING_TYPE                       118
+# define RSA_R_UNSUPPORTED_ENCRYPTION_TYPE                162
+# define RSA_R_UNSUPPORTED_LABEL_SOURCE                   163
+# define RSA_R_UNSUPPORTED_MASK_ALGORITHM                 153
+# define RSA_R_UNSUPPORTED_MASK_PARAMETER                 154
+# define RSA_R_UNSUPPORTED_SIGNATURE_TYPE                 155
+# define RSA_R_VALUE_MISSING                              147
+# define RSA_R_WRONG_SIGNATURE_LENGTH                     119
+
+#endif
diff --git a/src/include/openssl/safestack.h b/src/include/openssl/safestack.h
new file mode 100644
index 0000000..159ccf2
--- /dev/null
+++ b/src/include/openssl/safestack.h
@@ -0,0 +1,297 @@
+/*
+ * WARNING: do not edit!
+ * Generated by makefile from include\openssl\safestack.h.in
+ *
+ * Copyright 1999-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+
+
+#ifndef OPENSSL_SAFESTACK_H
+# define OPENSSL_SAFESTACK_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_SAFESTACK_H
+# endif
+
+# include <openssl/stack.h>
+# include <openssl/e_os2.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+# define STACK_OF(type) struct stack_st_##type
+
+/* Helper macro for internal use */
+# define SKM_DEFINE_STACK_OF_INTERNAL(t1, t2, t3) \
+    STACK_OF(t1); \
+    typedef int (*sk_##t1##_compfunc)(const t3 * const *a, const t3 *const *b); \
+    typedef void (*sk_##t1##_freefunc)(t3 *a); \
+    typedef t3 * (*sk_##t1##_copyfunc)(const t3 *a); \
+    static ossl_unused ossl_inline t2 *ossl_check_##t1##_type(t2 *ptr) \
+    { \
+        return ptr; \
+    } \
+    static ossl_unused ossl_inline const OPENSSL_STACK *ossl_check_const_##t1##_sk_type(const STACK_OF(t1) *sk) \
+    { \
+        return (const OPENSSL_STACK *)sk; \
+    } \
+    static ossl_unused ossl_inline OPENSSL_STACK *ossl_check_##t1##_sk_type(STACK_OF(t1) *sk) \
+    { \
+        return (OPENSSL_STACK *)sk; \
+    } \
+    static ossl_unused ossl_inline OPENSSL_sk_compfunc ossl_check_##t1##_compfunc_type(sk_##t1##_compfunc cmp) \
+    { \
+        return (OPENSSL_sk_compfunc)cmp; \
+    } \
+    static ossl_unused ossl_inline OPENSSL_sk_copyfunc ossl_check_##t1##_copyfunc_type(sk_##t1##_copyfunc cpy) \
+    { \
+        return (OPENSSL_sk_copyfunc)cpy; \
+    } \
+    static ossl_unused ossl_inline OPENSSL_sk_freefunc ossl_check_##t1##_freefunc_type(sk_##t1##_freefunc fr) \
+    { \
+        return (OPENSSL_sk_freefunc)fr; \
+    }
+
+# define SKM_DEFINE_STACK_OF(t1, t2, t3) \
+    STACK_OF(t1); \
+    typedef int (*sk_##t1##_compfunc)(const t3 * const *a, const t3 *const *b); \
+    typedef void (*sk_##t1##_freefunc)(t3 *a); \
+    typedef t3 * (*sk_##t1##_copyfunc)(const t3 *a); \
+    static ossl_unused ossl_inline int sk_##t1##_num(const STACK_OF(t1) *sk) \
+    { \
+        return OPENSSL_sk_num((const OPENSSL_STACK *)sk); \
+    } \
+    static ossl_unused ossl_inline t2 *sk_##t1##_value(const STACK_OF(t1) *sk, int idx) \
+    { \
+        return (t2 *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); \
+    } \
+    static ossl_unused ossl_inline STACK_OF(t1) *sk_##t1##_new(sk_##t1##_compfunc compare) \
+    { \
+        return (STACK_OF(t1) *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); \
+    } \
+    static ossl_unused ossl_inline STACK_OF(t1) *sk_##t1##_new_null(void) \
+    { \
+        return (STACK_OF(t1) *)OPENSSL_sk_new_null(); \
+    } \
+    static ossl_unused ossl_inline STACK_OF(t1) *sk_##t1##_new_reserve(sk_##t1##_compfunc compare, int n) \
+    { \
+        return (STACK_OF(t1) *)OPENSSL_sk_new_reserve((OPENSSL_sk_compfunc)compare, n); \
+    } \
+    static ossl_unused ossl_inline int sk_##t1##_reserve(STACK_OF(t1) *sk, int n) \
+    { \
+        return OPENSSL_sk_reserve((OPENSSL_STACK *)sk, n); \
+    } \
+    static ossl_unused ossl_inline void sk_##t1##_free(STACK_OF(t1) *sk) \
+    { \
+        OPENSSL_sk_free((OPENSSL_STACK *)sk); \
+    } \
+    static ossl_unused ossl_inline void sk_##t1##_zero(STACK_OF(t1) *sk) \
+    { \
+        OPENSSL_sk_zero((OPENSSL_STACK *)sk); \
+    } \
+    static ossl_unused ossl_inline t2 *sk_##t1##_delete(STACK_OF(t1) *sk, int i) \
+    { \
+        return (t2 *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); \
+    } \
+    static ossl_unused ossl_inline t2 *sk_##t1##_delete_ptr(STACK_OF(t1) *sk, t2 *ptr) \
+    { \
+        return (t2 *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, \
+                                           (const void *)ptr); \
+    } \
+    static ossl_unused ossl_inline int sk_##t1##_push(STACK_OF(t1) *sk, t2 *ptr) \
+    { \
+        return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); \
+    } \
+    static ossl_unused ossl_inline int sk_##t1##_unshift(STACK_OF(t1) *sk, t2 *ptr) \
+    { \
+        return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); \
+    } \
+    static ossl_unused ossl_inline t2 *sk_##t1##_pop(STACK_OF(t1) *sk) \
+    { \
+        return (t2 *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); \
+    } \
+    static ossl_unused ossl_inline t2 *sk_##t1##_shift(STACK_OF(t1) *sk) \
+    { \
+        return (t2 *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); \
+    } \
+    static ossl_unused ossl_inline void sk_##t1##_pop_free(STACK_OF(t1) *sk, sk_##t1##_freefunc freefunc) \
+    { \
+        OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); \
+    } \
+    static ossl_unused ossl_inline int sk_##t1##_insert(STACK_OF(t1) *sk, t2 *ptr, int idx) \
+    { \
+        return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); \
+    } \
+    static ossl_unused ossl_inline t2 *sk_##t1##_set(STACK_OF(t1) *sk, int idx, t2 *ptr) \
+    { \
+        return (t2 *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); \
+    } \
+    static ossl_unused ossl_inline int sk_##t1##_find(STACK_OF(t1) *sk, t2 *ptr) \
+    { \
+        return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); \
+    } \
+    static ossl_unused ossl_inline int sk_##t1##_find_ex(STACK_OF(t1) *sk, t2 *ptr) \
+    { \
+        return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); \
+    } \
+    static ossl_unused ossl_inline int sk_##t1##_find_all(STACK_OF(t1) *sk, t2 *ptr, int *pnum) \
+    { \
+        return OPENSSL_sk_find_all((OPENSSL_STACK *)sk, (const void *)ptr, pnum); \
+    } \
+    static ossl_unused ossl_inline void sk_##t1##_sort(STACK_OF(t1) *sk) \
+    { \
+        OPENSSL_sk_sort((OPENSSL_STACK *)sk); \
+    } \
+    static ossl_unused ossl_inline int sk_##t1##_is_sorted(const STACK_OF(t1) *sk) \
+    { \
+        return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); \
+    } \
+    static ossl_unused ossl_inline STACK_OF(t1) * sk_##t1##_dup(const STACK_OF(t1) *sk) \
+    { \
+        return (STACK_OF(t1) *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); \
+    } \
+    static ossl_unused ossl_inline STACK_OF(t1) *sk_##t1##_deep_copy(const STACK_OF(t1) *sk, \
+                                                    sk_##t1##_copyfunc copyfunc, \
+                                                    sk_##t1##_freefunc freefunc) \
+    { \
+        return (STACK_OF(t1) *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, \
+                                            (OPENSSL_sk_copyfunc)copyfunc, \
+                                            (OPENSSL_sk_freefunc)freefunc); \
+    } \
+    static ossl_unused ossl_inline sk_##t1##_compfunc sk_##t1##_set_cmp_func(STACK_OF(t1) *sk, sk_##t1##_compfunc compare) \
+    { \
+        return (sk_##t1##_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); \
+    }
+
+# define DEFINE_STACK_OF(t) SKM_DEFINE_STACK_OF(t, t, t)
+# define DEFINE_STACK_OF_CONST(t) SKM_DEFINE_STACK_OF(t, const t, t)
+# define DEFINE_SPECIAL_STACK_OF(t1, t2) SKM_DEFINE_STACK_OF(t1, t2, t2)
+# define DEFINE_SPECIAL_STACK_OF_CONST(t1, t2) \
+            SKM_DEFINE_STACK_OF(t1, const t2, t2)
+
+/*-
+ * Strings are special: normally an lhash entry will point to a single
+ * (somewhat) mutable object. In the case of strings:
+ *
+ * a) Instead of a single char, there is an array of chars, NUL-terminated.
+ * b) The string may have be immutable.
+ *
+ * So, they need their own declarations. Especially important for
+ * type-checking tools, such as Deputy.
+ *
+ * In practice, however, it appears to be hard to have a const
+ * string. For now, I'm settling for dealing with the fact it is a
+ * string at all.
+ */
+typedef char *OPENSSL_STRING;
+typedef const char *OPENSSL_CSTRING;
+
+/*-
+ * Confusingly, LHASH_OF(STRING) deals with char ** throughout, but
+ * STACK_OF(STRING) is really more like STACK_OF(char), only, as mentioned
+ * above, instead of a single char each entry is a NUL-terminated array of
+ * chars. So, we have to implement STRING specially for STACK_OF. This is
+ * dealt with in the autogenerated macros below.
+ */
+SKM_DEFINE_STACK_OF_INTERNAL(OPENSSL_STRING, char, char)
+#define sk_OPENSSL_STRING_num(sk) OPENSSL_sk_num(ossl_check_const_OPENSSL_STRING_sk_type(sk))
+#define sk_OPENSSL_STRING_value(sk, idx) ((char *)OPENSSL_sk_value(ossl_check_const_OPENSSL_STRING_sk_type(sk), (idx)))
+#define sk_OPENSSL_STRING_new(cmp) ((STACK_OF(OPENSSL_STRING) *)OPENSSL_sk_new(ossl_check_OPENSSL_STRING_compfunc_type(cmp)))
+#define sk_OPENSSL_STRING_new_null() ((STACK_OF(OPENSSL_STRING) *)OPENSSL_sk_new_null())
+#define sk_OPENSSL_STRING_new_reserve(cmp, n) ((STACK_OF(OPENSSL_STRING) *)OPENSSL_sk_new_reserve(ossl_check_OPENSSL_STRING_compfunc_type(cmp), (n)))
+#define sk_OPENSSL_STRING_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OPENSSL_STRING_sk_type(sk), (n))
+#define sk_OPENSSL_STRING_free(sk) OPENSSL_sk_free(ossl_check_OPENSSL_STRING_sk_type(sk))
+#define sk_OPENSSL_STRING_zero(sk) OPENSSL_sk_zero(ossl_check_OPENSSL_STRING_sk_type(sk))
+#define sk_OPENSSL_STRING_delete(sk, i) ((char *)OPENSSL_sk_delete(ossl_check_OPENSSL_STRING_sk_type(sk), (i)))
+#define sk_OPENSSL_STRING_delete_ptr(sk, ptr) ((char *)OPENSSL_sk_delete_ptr(ossl_check_OPENSSL_STRING_sk_type(sk), ossl_check_OPENSSL_STRING_type(ptr)))
+#define sk_OPENSSL_STRING_push(sk, ptr) OPENSSL_sk_push(ossl_check_OPENSSL_STRING_sk_type(sk), ossl_check_OPENSSL_STRING_type(ptr))
+#define sk_OPENSSL_STRING_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_OPENSSL_STRING_sk_type(sk), ossl_check_OPENSSL_STRING_type(ptr))
+#define sk_OPENSSL_STRING_pop(sk) ((char *)OPENSSL_sk_pop(ossl_check_OPENSSL_STRING_sk_type(sk)))
+#define sk_OPENSSL_STRING_shift(sk) ((char *)OPENSSL_sk_shift(ossl_check_OPENSSL_STRING_sk_type(sk)))
+#define sk_OPENSSL_STRING_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OPENSSL_STRING_sk_type(sk),ossl_check_OPENSSL_STRING_freefunc_type(freefunc))
+#define sk_OPENSSL_STRING_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_OPENSSL_STRING_sk_type(sk), ossl_check_OPENSSL_STRING_type(ptr), (idx))
+#define sk_OPENSSL_STRING_set(sk, idx, ptr) ((char *)OPENSSL_sk_set(ossl_check_OPENSSL_STRING_sk_type(sk), (idx), ossl_check_OPENSSL_STRING_type(ptr)))
+#define sk_OPENSSL_STRING_find(sk, ptr) OPENSSL_sk_find(ossl_check_OPENSSL_STRING_sk_type(sk), ossl_check_OPENSSL_STRING_type(ptr))
+#define sk_OPENSSL_STRING_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_OPENSSL_STRING_sk_type(sk), ossl_check_OPENSSL_STRING_type(ptr))
+#define sk_OPENSSL_STRING_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OPENSSL_STRING_sk_type(sk), ossl_check_OPENSSL_STRING_type(ptr), pnum)
+#define sk_OPENSSL_STRING_sort(sk) OPENSSL_sk_sort(ossl_check_OPENSSL_STRING_sk_type(sk))
+#define sk_OPENSSL_STRING_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OPENSSL_STRING_sk_type(sk))
+#define sk_OPENSSL_STRING_dup(sk) ((STACK_OF(OPENSSL_STRING) *)OPENSSL_sk_dup(ossl_check_const_OPENSSL_STRING_sk_type(sk)))
+#define sk_OPENSSL_STRING_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OPENSSL_STRING) *)OPENSSL_sk_deep_copy(ossl_check_const_OPENSSL_STRING_sk_type(sk), ossl_check_OPENSSL_STRING_copyfunc_type(copyfunc), ossl_check_OPENSSL_STRING_freefunc_type(freefunc)))
+#define sk_OPENSSL_STRING_set_cmp_func(sk, cmp) ((sk_OPENSSL_STRING_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OPENSSL_STRING_sk_type(sk), ossl_check_OPENSSL_STRING_compfunc_type(cmp)))
+SKM_DEFINE_STACK_OF_INTERNAL(OPENSSL_CSTRING, const char, char)
+#define sk_OPENSSL_CSTRING_num(sk) OPENSSL_sk_num(ossl_check_const_OPENSSL_CSTRING_sk_type(sk))
+#define sk_OPENSSL_CSTRING_value(sk, idx) ((const char *)OPENSSL_sk_value(ossl_check_const_OPENSSL_CSTRING_sk_type(sk), (idx)))
+#define sk_OPENSSL_CSTRING_new(cmp) ((STACK_OF(OPENSSL_CSTRING) *)OPENSSL_sk_new(ossl_check_OPENSSL_CSTRING_compfunc_type(cmp)))
+#define sk_OPENSSL_CSTRING_new_null() ((STACK_OF(OPENSSL_CSTRING) *)OPENSSL_sk_new_null())
+#define sk_OPENSSL_CSTRING_new_reserve(cmp, n) ((STACK_OF(OPENSSL_CSTRING) *)OPENSSL_sk_new_reserve(ossl_check_OPENSSL_CSTRING_compfunc_type(cmp), (n)))
+#define sk_OPENSSL_CSTRING_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OPENSSL_CSTRING_sk_type(sk), (n))
+#define sk_OPENSSL_CSTRING_free(sk) OPENSSL_sk_free(ossl_check_OPENSSL_CSTRING_sk_type(sk))
+#define sk_OPENSSL_CSTRING_zero(sk) OPENSSL_sk_zero(ossl_check_OPENSSL_CSTRING_sk_type(sk))
+#define sk_OPENSSL_CSTRING_delete(sk, i) ((const char *)OPENSSL_sk_delete(ossl_check_OPENSSL_CSTRING_sk_type(sk), (i)))
+#define sk_OPENSSL_CSTRING_delete_ptr(sk, ptr) ((const char *)OPENSSL_sk_delete_ptr(ossl_check_OPENSSL_CSTRING_sk_type(sk), ossl_check_OPENSSL_CSTRING_type(ptr)))
+#define sk_OPENSSL_CSTRING_push(sk, ptr) OPENSSL_sk_push(ossl_check_OPENSSL_CSTRING_sk_type(sk), ossl_check_OPENSSL_CSTRING_type(ptr))
+#define sk_OPENSSL_CSTRING_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_OPENSSL_CSTRING_sk_type(sk), ossl_check_OPENSSL_CSTRING_type(ptr))
+#define sk_OPENSSL_CSTRING_pop(sk) ((const char *)OPENSSL_sk_pop(ossl_check_OPENSSL_CSTRING_sk_type(sk)))
+#define sk_OPENSSL_CSTRING_shift(sk) ((const char *)OPENSSL_sk_shift(ossl_check_OPENSSL_CSTRING_sk_type(sk)))
+#define sk_OPENSSL_CSTRING_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OPENSSL_CSTRING_sk_type(sk),ossl_check_OPENSSL_CSTRING_freefunc_type(freefunc))
+#define sk_OPENSSL_CSTRING_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_OPENSSL_CSTRING_sk_type(sk), ossl_check_OPENSSL_CSTRING_type(ptr), (idx))
+#define sk_OPENSSL_CSTRING_set(sk, idx, ptr) ((const char *)OPENSSL_sk_set(ossl_check_OPENSSL_CSTRING_sk_type(sk), (idx), ossl_check_OPENSSL_CSTRING_type(ptr)))
+#define sk_OPENSSL_CSTRING_find(sk, ptr) OPENSSL_sk_find(ossl_check_OPENSSL_CSTRING_sk_type(sk), ossl_check_OPENSSL_CSTRING_type(ptr))
+#define sk_OPENSSL_CSTRING_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_OPENSSL_CSTRING_sk_type(sk), ossl_check_OPENSSL_CSTRING_type(ptr))
+#define sk_OPENSSL_CSTRING_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OPENSSL_CSTRING_sk_type(sk), ossl_check_OPENSSL_CSTRING_type(ptr), pnum)
+#define sk_OPENSSL_CSTRING_sort(sk) OPENSSL_sk_sort(ossl_check_OPENSSL_CSTRING_sk_type(sk))
+#define sk_OPENSSL_CSTRING_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OPENSSL_CSTRING_sk_type(sk))
+#define sk_OPENSSL_CSTRING_dup(sk) ((STACK_OF(OPENSSL_CSTRING) *)OPENSSL_sk_dup(ossl_check_const_OPENSSL_CSTRING_sk_type(sk)))
+#define sk_OPENSSL_CSTRING_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OPENSSL_CSTRING) *)OPENSSL_sk_deep_copy(ossl_check_const_OPENSSL_CSTRING_sk_type(sk), ossl_check_OPENSSL_CSTRING_copyfunc_type(copyfunc), ossl_check_OPENSSL_CSTRING_freefunc_type(freefunc)))
+#define sk_OPENSSL_CSTRING_set_cmp_func(sk, cmp) ((sk_OPENSSL_CSTRING_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OPENSSL_CSTRING_sk_type(sk), ossl_check_OPENSSL_CSTRING_compfunc_type(cmp)))
+
+
+#if !defined(OPENSSL_NO_DEPRECATED_3_0)
+/*
+ * This is not used by OpenSSL.  A block of bytes,  NOT nul-terminated.
+ * These should also be distinguished from "normal" stacks.
+ */
+typedef void *OPENSSL_BLOCK;
+SKM_DEFINE_STACK_OF_INTERNAL(OPENSSL_BLOCK, void, void)
+#define sk_OPENSSL_BLOCK_num(sk) OPENSSL_sk_num(ossl_check_const_OPENSSL_BLOCK_sk_type(sk))
+#define sk_OPENSSL_BLOCK_value(sk, idx) ((void *)OPENSSL_sk_value(ossl_check_const_OPENSSL_BLOCK_sk_type(sk), (idx)))
+#define sk_OPENSSL_BLOCK_new(cmp) ((STACK_OF(OPENSSL_BLOCK) *)OPENSSL_sk_new(ossl_check_OPENSSL_BLOCK_compfunc_type(cmp)))
+#define sk_OPENSSL_BLOCK_new_null() ((STACK_OF(OPENSSL_BLOCK) *)OPENSSL_sk_new_null())
+#define sk_OPENSSL_BLOCK_new_reserve(cmp, n) ((STACK_OF(OPENSSL_BLOCK) *)OPENSSL_sk_new_reserve(ossl_check_OPENSSL_BLOCK_compfunc_type(cmp), (n)))
+#define sk_OPENSSL_BLOCK_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OPENSSL_BLOCK_sk_type(sk), (n))
+#define sk_OPENSSL_BLOCK_free(sk) OPENSSL_sk_free(ossl_check_OPENSSL_BLOCK_sk_type(sk))
+#define sk_OPENSSL_BLOCK_zero(sk) OPENSSL_sk_zero(ossl_check_OPENSSL_BLOCK_sk_type(sk))
+#define sk_OPENSSL_BLOCK_delete(sk, i) ((void *)OPENSSL_sk_delete(ossl_check_OPENSSL_BLOCK_sk_type(sk), (i)))
+#define sk_OPENSSL_BLOCK_delete_ptr(sk, ptr) ((void *)OPENSSL_sk_delete_ptr(ossl_check_OPENSSL_BLOCK_sk_type(sk), ossl_check_OPENSSL_BLOCK_type(ptr)))
+#define sk_OPENSSL_BLOCK_push(sk, ptr) OPENSSL_sk_push(ossl_check_OPENSSL_BLOCK_sk_type(sk), ossl_check_OPENSSL_BLOCK_type(ptr))
+#define sk_OPENSSL_BLOCK_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_OPENSSL_BLOCK_sk_type(sk), ossl_check_OPENSSL_BLOCK_type(ptr))
+#define sk_OPENSSL_BLOCK_pop(sk) ((void *)OPENSSL_sk_pop(ossl_check_OPENSSL_BLOCK_sk_type(sk)))
+#define sk_OPENSSL_BLOCK_shift(sk) ((void *)OPENSSL_sk_shift(ossl_check_OPENSSL_BLOCK_sk_type(sk)))
+#define sk_OPENSSL_BLOCK_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OPENSSL_BLOCK_sk_type(sk),ossl_check_OPENSSL_BLOCK_freefunc_type(freefunc))
+#define sk_OPENSSL_BLOCK_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_OPENSSL_BLOCK_sk_type(sk), ossl_check_OPENSSL_BLOCK_type(ptr), (idx))
+#define sk_OPENSSL_BLOCK_set(sk, idx, ptr) ((void *)OPENSSL_sk_set(ossl_check_OPENSSL_BLOCK_sk_type(sk), (idx), ossl_check_OPENSSL_BLOCK_type(ptr)))
+#define sk_OPENSSL_BLOCK_find(sk, ptr) OPENSSL_sk_find(ossl_check_OPENSSL_BLOCK_sk_type(sk), ossl_check_OPENSSL_BLOCK_type(ptr))
+#define sk_OPENSSL_BLOCK_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_OPENSSL_BLOCK_sk_type(sk), ossl_check_OPENSSL_BLOCK_type(ptr))
+#define sk_OPENSSL_BLOCK_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OPENSSL_BLOCK_sk_type(sk), ossl_check_OPENSSL_BLOCK_type(ptr), pnum)
+#define sk_OPENSSL_BLOCK_sort(sk) OPENSSL_sk_sort(ossl_check_OPENSSL_BLOCK_sk_type(sk))
+#define sk_OPENSSL_BLOCK_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OPENSSL_BLOCK_sk_type(sk))
+#define sk_OPENSSL_BLOCK_dup(sk) ((STACK_OF(OPENSSL_BLOCK) *)OPENSSL_sk_dup(ossl_check_const_OPENSSL_BLOCK_sk_type(sk)))
+#define sk_OPENSSL_BLOCK_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OPENSSL_BLOCK) *)OPENSSL_sk_deep_copy(ossl_check_const_OPENSSL_BLOCK_sk_type(sk), ossl_check_OPENSSL_BLOCK_copyfunc_type(copyfunc), ossl_check_OPENSSL_BLOCK_freefunc_type(freefunc)))
+#define sk_OPENSSL_BLOCK_set_cmp_func(sk, cmp) ((sk_OPENSSL_BLOCK_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OPENSSL_BLOCK_sk_type(sk), ossl_check_OPENSSL_BLOCK_compfunc_type(cmp)))
+
+#endif
+
+# ifdef  __cplusplus
+}
+# endif
+#endif
diff --git a/src/include/openssl/seed.h b/src/include/openssl/seed.h
new file mode 100644
index 0000000..edb218a
--- /dev/null
+++ b/src/include/openssl/seed.h
@@ -0,0 +1,113 @@
+/*
+ * Copyright 2007-2020 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+/*
+ * Copyright (c) 2007 KISA(Korea Information Security Agency). All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Neither the name of author nor the names of its contributors may
+ *    be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#ifndef OPENSSL_SEED_H
+# define OPENSSL_SEED_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_SEED_H
+# endif
+
+# include <openssl/opensslconf.h>
+
+# ifndef OPENSSL_NO_SEED
+#  include <openssl/e_os2.h>
+#  include <openssl/crypto.h>
+#  include <sys/types.h>
+
+#  ifdef  __cplusplus
+extern "C" {
+#  endif
+
+#  define SEED_BLOCK_SIZE 16
+#  define SEED_KEY_LENGTH 16
+
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+/* look whether we need 'long' to get 32 bits */
+#   ifdef AES_LONG
+#    ifndef SEED_LONG
+#     define SEED_LONG 1
+#    endif
+#   endif
+
+
+typedef struct seed_key_st {
+#   ifdef SEED_LONG
+    unsigned long data[32];
+#   else
+    unsigned int data[32];
+#   endif
+} SEED_KEY_SCHEDULE;
+#  endif /* OPENSSL_NO_DEPRECATED_3_0 */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+void SEED_set_key(const unsigned char rawkey[SEED_KEY_LENGTH],
+                  SEED_KEY_SCHEDULE *ks);
+OSSL_DEPRECATEDIN_3_0
+void SEED_encrypt(const unsigned char s[SEED_BLOCK_SIZE],
+                  unsigned char d[SEED_BLOCK_SIZE],
+                  const SEED_KEY_SCHEDULE *ks);
+OSSL_DEPRECATEDIN_3_0
+void SEED_decrypt(const unsigned char s[SEED_BLOCK_SIZE],
+                  unsigned char d[SEED_BLOCK_SIZE],
+                  const SEED_KEY_SCHEDULE *ks);
+OSSL_DEPRECATEDIN_3_0
+void SEED_ecb_encrypt(const unsigned char *in,
+                      unsigned char *out,
+                      const SEED_KEY_SCHEDULE *ks, int enc);
+OSSL_DEPRECATEDIN_3_0
+void SEED_cbc_encrypt(const unsigned char *in, unsigned char *out, size_t len,
+                      const SEED_KEY_SCHEDULE *ks,
+                      unsigned char ivec[SEED_BLOCK_SIZE],
+                      int enc);
+OSSL_DEPRECATEDIN_3_0
+void SEED_cfb128_encrypt(const unsigned char *in, unsigned char *out,
+                         size_t len, const SEED_KEY_SCHEDULE *ks,
+                         unsigned char ivec[SEED_BLOCK_SIZE],
+                         int *num, int enc);
+OSSL_DEPRECATEDIN_3_0
+void SEED_ofb128_encrypt(const unsigned char *in, unsigned char *out,
+                         size_t len, const SEED_KEY_SCHEDULE *ks,
+                         unsigned char ivec[SEED_BLOCK_SIZE],
+                         int *num);
+#  endif
+
+#  ifdef  __cplusplus
+}
+#  endif
+# endif
+
+#endif
diff --git a/src/include/openssl/self_test.h b/src/include/openssl/self_test.h
new file mode 100644
index 0000000..1782204
--- /dev/null
+++ b/src/include/openssl/self_test.h
@@ -0,0 +1,96 @@
+/*
+ * Copyright 2019-2024 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_SELF_TEST_H
+# define OPENSSL_SELF_TEST_H
+# pragma once
+
+# include <openssl/core.h> /* OSSL_CALLBACK */
+
+# ifdef __cplusplus
+extern "C" {
+# endif
+
+/* The test event phases */
+# define OSSL_SELF_TEST_PHASE_NONE     "None"
+# define OSSL_SELF_TEST_PHASE_START    "Start"
+# define OSSL_SELF_TEST_PHASE_CORRUPT  "Corrupt"
+# define OSSL_SELF_TEST_PHASE_PASS     "Pass"
+# define OSSL_SELF_TEST_PHASE_FAIL     "Fail"
+
+/* Test event categories */
+# define OSSL_SELF_TEST_TYPE_NONE               "None"
+# define OSSL_SELF_TEST_TYPE_MODULE_INTEGRITY   "Module_Integrity"
+# define OSSL_SELF_TEST_TYPE_INSTALL_INTEGRITY  "Install_Integrity"
+# define OSSL_SELF_TEST_TYPE_CRNG               "Continuous_RNG_Test"
+# define OSSL_SELF_TEST_TYPE_PCT                "Conditional_PCT"
+# define OSSL_SELF_TEST_TYPE_PCT_KAT            "Conditional_KAT"
+# define OSSL_SELF_TEST_TYPE_KAT_INTEGRITY      "KAT_Integrity"
+# define OSSL_SELF_TEST_TYPE_KAT_CIPHER         "KAT_Cipher"
+# define OSSL_SELF_TEST_TYPE_KAT_ASYM_CIPHER    "KAT_AsymmetricCipher"
+# define OSSL_SELF_TEST_TYPE_KAT_DIGEST         "KAT_Digest"
+# define OSSL_SELF_TEST_TYPE_KAT_SIGNATURE      "KAT_Signature"
+# define OSSL_SELF_TEST_TYPE_PCT_SIGNATURE      "PCT_Signature"
+# define OSSL_SELF_TEST_TYPE_KAT_KDF            "KAT_KDF"
+# define OSSL_SELF_TEST_TYPE_KAT_KA             "KAT_KA"
+# define OSSL_SELF_TEST_TYPE_DRBG               "DRBG"
+
+/* Test event sub categories */
+# define OSSL_SELF_TEST_DESC_NONE           "None"
+# define OSSL_SELF_TEST_DESC_INTEGRITY_HMAC "HMAC"
+# define OSSL_SELF_TEST_DESC_PCT_RSA_PKCS1  "RSA"
+# define OSSL_SELF_TEST_DESC_PCT_ECDSA      "ECDSA"
+# define OSSL_SELF_TEST_DESC_PCT_EDDSA      "EDDSA"
+# define OSSL_SELF_TEST_DESC_PCT_DSA        "DSA"
+# define OSSL_SELF_TEST_DESC_CIPHER_AES_GCM "AES_GCM"
+# define OSSL_SELF_TEST_DESC_CIPHER_AES_ECB "AES_ECB_Decrypt"
+# define OSSL_SELF_TEST_DESC_CIPHER_TDES    "TDES"
+# define OSSL_SELF_TEST_DESC_ASYM_RSA_ENC   "RSA_Encrypt"
+# define OSSL_SELF_TEST_DESC_ASYM_RSA_DEC   "RSA_Decrypt"
+# define OSSL_SELF_TEST_DESC_MD_SHA1        "SHA1"
+# define OSSL_SELF_TEST_DESC_MD_SHA2        "SHA2"
+# define OSSL_SELF_TEST_DESC_MD_SHA3        "SHA3"
+# define OSSL_SELF_TEST_DESC_SIGN_DSA       "DSA"
+# define OSSL_SELF_TEST_DESC_SIGN_RSA       "RSA"
+# define OSSL_SELF_TEST_DESC_SIGN_ECDSA     "ECDSA"
+# define OSSL_SELF_TEST_DESC_DRBG_CTR       "CTR"
+# define OSSL_SELF_TEST_DESC_DRBG_HASH      "HASH"
+# define OSSL_SELF_TEST_DESC_DRBG_HMAC      "HMAC"
+# define OSSL_SELF_TEST_DESC_KA_DH          "DH"
+# define OSSL_SELF_TEST_DESC_KA_ECDH        "ECDH"
+# define OSSL_SELF_TEST_DESC_KDF_HKDF       "HKDF"
+# define OSSL_SELF_TEST_DESC_KDF_SSKDF      "SSKDF"
+# define OSSL_SELF_TEST_DESC_KDF_X963KDF    "X963KDF"
+# define OSSL_SELF_TEST_DESC_KDF_X942KDF    "X942KDF"
+# define OSSL_SELF_TEST_DESC_KDF_PBKDF2     "PBKDF2"
+# define OSSL_SELF_TEST_DESC_KDF_SSHKDF     "SSHKDF"
+# define OSSL_SELF_TEST_DESC_KDF_TLS12_PRF  "TLS12_PRF"
+# define OSSL_SELF_TEST_DESC_KDF_KBKDF      "KBKDF"
+# define OSSL_SELF_TEST_DESC_KDF_KBKDF_KMAC "KBKDF_KMAC"
+# define OSSL_SELF_TEST_DESC_KDF_TLS13_EXTRACT  "TLS13_KDF_EXTRACT"
+# define OSSL_SELF_TEST_DESC_KDF_TLS13_EXPAND   "TLS13_KDF_EXPAND"
+# define OSSL_SELF_TEST_DESC_RNG            "RNG"
+
+void OSSL_SELF_TEST_set_callback(OSSL_LIB_CTX *libctx, OSSL_CALLBACK *cb,
+                                 void *cbarg);
+void OSSL_SELF_TEST_get_callback(OSSL_LIB_CTX *libctx, OSSL_CALLBACK **cb,
+                                 void **cbarg);
+
+OSSL_SELF_TEST *OSSL_SELF_TEST_new(OSSL_CALLBACK *cb, void *cbarg);
+void OSSL_SELF_TEST_free(OSSL_SELF_TEST *st);
+
+void OSSL_SELF_TEST_onbegin(OSSL_SELF_TEST *st, const char *type,
+                            const char *desc);
+int OSSL_SELF_TEST_oncorrupt_byte(OSSL_SELF_TEST *st, unsigned char *bytes);
+void OSSL_SELF_TEST_onend(OSSL_SELF_TEST *st, int ret);
+
+# ifdef __cplusplus
+}
+# endif
+#endif /* OPENSSL_SELF_TEST_H */
diff --git a/src/include/openssl/sha.h b/src/include/openssl/sha.h
new file mode 100644
index 0000000..163a7d5
--- /dev/null
+++ b/src/include/openssl/sha.h
@@ -0,0 +1,139 @@
+/*
+ * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_SHA_H
+# define OPENSSL_SHA_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_SHA_H
+# endif
+
+# include <openssl/e_os2.h>
+# include <stddef.h>
+
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+# define SHA_DIGEST_LENGTH 20
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+/*-
+ * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+ * ! SHA_LONG has to be at least 32 bits wide.                    !
+ * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+ */
+#  define SHA_LONG unsigned int
+
+#  define SHA_LBLOCK      16
+#  define SHA_CBLOCK      (SHA_LBLOCK*4)/* SHA treats input data as a
+                                         * contiguous array of 32 bit wide
+                                         * big-endian values. */
+#  define SHA_LAST_BLOCK  (SHA_CBLOCK-8)
+
+typedef struct SHAstate_st {
+    SHA_LONG h0, h1, h2, h3, h4;
+    SHA_LONG Nl, Nh;
+    SHA_LONG data[SHA_LBLOCK];
+    unsigned int num;
+} SHA_CTX;
+
+OSSL_DEPRECATEDIN_3_0 int SHA1_Init(SHA_CTX *c);
+OSSL_DEPRECATEDIN_3_0 int SHA1_Update(SHA_CTX *c, const void *data, size_t len);
+OSSL_DEPRECATEDIN_3_0 int SHA1_Final(unsigned char *md, SHA_CTX *c);
+OSSL_DEPRECATEDIN_3_0 void SHA1_Transform(SHA_CTX *c, const unsigned char *data);
+# endif
+
+unsigned char *SHA1(const unsigned char *d, size_t n, unsigned char *md);
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define SHA256_CBLOCK   (SHA_LBLOCK*4)/* SHA-256 treats input data as a
+                                        * contiguous array of 32 bit wide
+                                        * big-endian values. */
+
+typedef struct SHA256state_st {
+    SHA_LONG h[8];
+    SHA_LONG Nl, Nh;
+    SHA_LONG data[SHA_LBLOCK];
+    unsigned int num, md_len;
+} SHA256_CTX;
+
+OSSL_DEPRECATEDIN_3_0 int SHA224_Init(SHA256_CTX *c);
+OSSL_DEPRECATEDIN_3_0 int SHA224_Update(SHA256_CTX *c,
+                                        const void *data, size_t len);
+OSSL_DEPRECATEDIN_3_0 int SHA224_Final(unsigned char *md, SHA256_CTX *c);
+OSSL_DEPRECATEDIN_3_0 int SHA256_Init(SHA256_CTX *c);
+OSSL_DEPRECATEDIN_3_0 int SHA256_Update(SHA256_CTX *c,
+                                        const void *data, size_t len);
+OSSL_DEPRECATEDIN_3_0 int SHA256_Final(unsigned char *md, SHA256_CTX *c);
+OSSL_DEPRECATEDIN_3_0 void SHA256_Transform(SHA256_CTX *c,
+                                            const unsigned char *data);
+# endif
+
+unsigned char *SHA224(const unsigned char *d, size_t n, unsigned char *md);
+unsigned char *SHA256(const unsigned char *d, size_t n, unsigned char *md);
+
+# define SHA256_192_DIGEST_LENGTH 24
+# define SHA224_DIGEST_LENGTH    28
+# define SHA256_DIGEST_LENGTH    32
+# define SHA384_DIGEST_LENGTH    48
+# define SHA512_DIGEST_LENGTH    64
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+/*
+ * Unlike 32-bit digest algorithms, SHA-512 *relies* on SHA_LONG64
+ * being exactly 64-bit wide. See Implementation Notes in sha512.c
+ * for further details.
+ */
+/*
+ * SHA-512 treats input data as a
+ * contiguous array of 64 bit
+ * wide big-endian values.
+ */
+#  define 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
+
+typedef struct SHA512state_st {
+    SHA_LONG64 h[8];
+    SHA_LONG64 Nl, Nh;
+    union {
+        SHA_LONG64 d[SHA_LBLOCK];
+        unsigned char p[SHA512_CBLOCK];
+    } u;
+    unsigned int num, md_len;
+} SHA512_CTX;
+
+OSSL_DEPRECATEDIN_3_0 int SHA384_Init(SHA512_CTX *c);
+OSSL_DEPRECATEDIN_3_0 int SHA384_Update(SHA512_CTX *c,
+                                        const void *data, size_t len);
+OSSL_DEPRECATEDIN_3_0 int SHA384_Final(unsigned char *md, SHA512_CTX *c);
+OSSL_DEPRECATEDIN_3_0 int SHA512_Init(SHA512_CTX *c);
+OSSL_DEPRECATEDIN_3_0 int SHA512_Update(SHA512_CTX *c,
+                                        const void *data, size_t len);
+OSSL_DEPRECATEDIN_3_0 int SHA512_Final(unsigned char *md, SHA512_CTX *c);
+OSSL_DEPRECATEDIN_3_0 void SHA512_Transform(SHA512_CTX *c,
+                                            const unsigned char *data);
+# endif
+
+unsigned char *SHA384(const unsigned char *d, size_t n, unsigned char *md);
+unsigned char *SHA512(const unsigned char *d, size_t n, unsigned char *md);
+
+# ifdef  __cplusplus
+}
+# endif
+
+#endif
diff --git a/src/include/openssl/srp.h b/src/include/openssl/srp.h
new file mode 100644
index 0000000..a86fa5d
--- /dev/null
+++ b/src/include/openssl/srp.h
@@ -0,0 +1,285 @@
+/*
+ * WARNING: do not edit!
+ * Generated by makefile from include\openssl\srp.h.in
+ *
+ * Copyright 2004-2021 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright (c) 2004, EdelKey Project. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ *
+ * Originally written by Christophe Renou and Peter Sylvester,
+ * for the EdelKey project.
+ */
+
+
+
+#ifndef OPENSSL_SRP_H
+# define OPENSSL_SRP_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_SRP_H
+# endif
+
+#include <openssl/opensslconf.h>
+
+#ifndef OPENSSL_NO_SRP
+# include <stdio.h>
+# include <string.h>
+# include <openssl/safestack.h>
+# include <openssl/bn.h>
+# include <openssl/crypto.h>
+
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+
+typedef struct SRP_gN_cache_st {
+    char *b64_bn;
+    BIGNUM *bn;
+} SRP_gN_cache;
+SKM_DEFINE_STACK_OF_INTERNAL(SRP_gN_cache, SRP_gN_cache, SRP_gN_cache)
+#define sk_SRP_gN_cache_num(sk) OPENSSL_sk_num(ossl_check_const_SRP_gN_cache_sk_type(sk))
+#define sk_SRP_gN_cache_value(sk, idx) ((SRP_gN_cache *)OPENSSL_sk_value(ossl_check_const_SRP_gN_cache_sk_type(sk), (idx)))
+#define sk_SRP_gN_cache_new(cmp) ((STACK_OF(SRP_gN_cache) *)OPENSSL_sk_new(ossl_check_SRP_gN_cache_compfunc_type(cmp)))
+#define sk_SRP_gN_cache_new_null() ((STACK_OF(SRP_gN_cache) *)OPENSSL_sk_new_null())
+#define sk_SRP_gN_cache_new_reserve(cmp, n) ((STACK_OF(SRP_gN_cache) *)OPENSSL_sk_new_reserve(ossl_check_SRP_gN_cache_compfunc_type(cmp), (n)))
+#define sk_SRP_gN_cache_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_SRP_gN_cache_sk_type(sk), (n))
+#define sk_SRP_gN_cache_free(sk) OPENSSL_sk_free(ossl_check_SRP_gN_cache_sk_type(sk))
+#define sk_SRP_gN_cache_zero(sk) OPENSSL_sk_zero(ossl_check_SRP_gN_cache_sk_type(sk))
+#define sk_SRP_gN_cache_delete(sk, i) ((SRP_gN_cache *)OPENSSL_sk_delete(ossl_check_SRP_gN_cache_sk_type(sk), (i)))
+#define sk_SRP_gN_cache_delete_ptr(sk, ptr) ((SRP_gN_cache *)OPENSSL_sk_delete_ptr(ossl_check_SRP_gN_cache_sk_type(sk), ossl_check_SRP_gN_cache_type(ptr)))
+#define sk_SRP_gN_cache_push(sk, ptr) OPENSSL_sk_push(ossl_check_SRP_gN_cache_sk_type(sk), ossl_check_SRP_gN_cache_type(ptr))
+#define sk_SRP_gN_cache_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_SRP_gN_cache_sk_type(sk), ossl_check_SRP_gN_cache_type(ptr))
+#define sk_SRP_gN_cache_pop(sk) ((SRP_gN_cache *)OPENSSL_sk_pop(ossl_check_SRP_gN_cache_sk_type(sk)))
+#define sk_SRP_gN_cache_shift(sk) ((SRP_gN_cache *)OPENSSL_sk_shift(ossl_check_SRP_gN_cache_sk_type(sk)))
+#define sk_SRP_gN_cache_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_SRP_gN_cache_sk_type(sk),ossl_check_SRP_gN_cache_freefunc_type(freefunc))
+#define sk_SRP_gN_cache_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_SRP_gN_cache_sk_type(sk), ossl_check_SRP_gN_cache_type(ptr), (idx))
+#define sk_SRP_gN_cache_set(sk, idx, ptr) ((SRP_gN_cache *)OPENSSL_sk_set(ossl_check_SRP_gN_cache_sk_type(sk), (idx), ossl_check_SRP_gN_cache_type(ptr)))
+#define sk_SRP_gN_cache_find(sk, ptr) OPENSSL_sk_find(ossl_check_SRP_gN_cache_sk_type(sk), ossl_check_SRP_gN_cache_type(ptr))
+#define sk_SRP_gN_cache_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_SRP_gN_cache_sk_type(sk), ossl_check_SRP_gN_cache_type(ptr))
+#define sk_SRP_gN_cache_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_SRP_gN_cache_sk_type(sk), ossl_check_SRP_gN_cache_type(ptr), pnum)
+#define sk_SRP_gN_cache_sort(sk) OPENSSL_sk_sort(ossl_check_SRP_gN_cache_sk_type(sk))
+#define sk_SRP_gN_cache_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_SRP_gN_cache_sk_type(sk))
+#define sk_SRP_gN_cache_dup(sk) ((STACK_OF(SRP_gN_cache) *)OPENSSL_sk_dup(ossl_check_const_SRP_gN_cache_sk_type(sk)))
+#define sk_SRP_gN_cache_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(SRP_gN_cache) *)OPENSSL_sk_deep_copy(ossl_check_const_SRP_gN_cache_sk_type(sk), ossl_check_SRP_gN_cache_copyfunc_type(copyfunc), ossl_check_SRP_gN_cache_freefunc_type(freefunc)))
+#define sk_SRP_gN_cache_set_cmp_func(sk, cmp) ((sk_SRP_gN_cache_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_SRP_gN_cache_sk_type(sk), ossl_check_SRP_gN_cache_compfunc_type(cmp)))
+
+
+
+typedef struct SRP_user_pwd_st {
+    /* Owned by us. */
+    char *id;
+    BIGNUM *s;
+    BIGNUM *v;
+    /* Not owned by us. */
+    const BIGNUM *g;
+    const BIGNUM *N;
+    /* Owned by us. */
+    char *info;
+} SRP_user_pwd;
+SKM_DEFINE_STACK_OF_INTERNAL(SRP_user_pwd, SRP_user_pwd, SRP_user_pwd)
+#define sk_SRP_user_pwd_num(sk) OPENSSL_sk_num(ossl_check_const_SRP_user_pwd_sk_type(sk))
+#define sk_SRP_user_pwd_value(sk, idx) ((SRP_user_pwd *)OPENSSL_sk_value(ossl_check_const_SRP_user_pwd_sk_type(sk), (idx)))
+#define sk_SRP_user_pwd_new(cmp) ((STACK_OF(SRP_user_pwd) *)OPENSSL_sk_new(ossl_check_SRP_user_pwd_compfunc_type(cmp)))
+#define sk_SRP_user_pwd_new_null() ((STACK_OF(SRP_user_pwd) *)OPENSSL_sk_new_null())
+#define sk_SRP_user_pwd_new_reserve(cmp, n) ((STACK_OF(SRP_user_pwd) *)OPENSSL_sk_new_reserve(ossl_check_SRP_user_pwd_compfunc_type(cmp), (n)))
+#define sk_SRP_user_pwd_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_SRP_user_pwd_sk_type(sk), (n))
+#define sk_SRP_user_pwd_free(sk) OPENSSL_sk_free(ossl_check_SRP_user_pwd_sk_type(sk))
+#define sk_SRP_user_pwd_zero(sk) OPENSSL_sk_zero(ossl_check_SRP_user_pwd_sk_type(sk))
+#define sk_SRP_user_pwd_delete(sk, i) ((SRP_user_pwd *)OPENSSL_sk_delete(ossl_check_SRP_user_pwd_sk_type(sk), (i)))
+#define sk_SRP_user_pwd_delete_ptr(sk, ptr) ((SRP_user_pwd *)OPENSSL_sk_delete_ptr(ossl_check_SRP_user_pwd_sk_type(sk), ossl_check_SRP_user_pwd_type(ptr)))
+#define sk_SRP_user_pwd_push(sk, ptr) OPENSSL_sk_push(ossl_check_SRP_user_pwd_sk_type(sk), ossl_check_SRP_user_pwd_type(ptr))
+#define sk_SRP_user_pwd_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_SRP_user_pwd_sk_type(sk), ossl_check_SRP_user_pwd_type(ptr))
+#define sk_SRP_user_pwd_pop(sk) ((SRP_user_pwd *)OPENSSL_sk_pop(ossl_check_SRP_user_pwd_sk_type(sk)))
+#define sk_SRP_user_pwd_shift(sk) ((SRP_user_pwd *)OPENSSL_sk_shift(ossl_check_SRP_user_pwd_sk_type(sk)))
+#define sk_SRP_user_pwd_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_SRP_user_pwd_sk_type(sk),ossl_check_SRP_user_pwd_freefunc_type(freefunc))
+#define sk_SRP_user_pwd_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_SRP_user_pwd_sk_type(sk), ossl_check_SRP_user_pwd_type(ptr), (idx))
+#define sk_SRP_user_pwd_set(sk, idx, ptr) ((SRP_user_pwd *)OPENSSL_sk_set(ossl_check_SRP_user_pwd_sk_type(sk), (idx), ossl_check_SRP_user_pwd_type(ptr)))
+#define sk_SRP_user_pwd_find(sk, ptr) OPENSSL_sk_find(ossl_check_SRP_user_pwd_sk_type(sk), ossl_check_SRP_user_pwd_type(ptr))
+#define sk_SRP_user_pwd_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_SRP_user_pwd_sk_type(sk), ossl_check_SRP_user_pwd_type(ptr))
+#define sk_SRP_user_pwd_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_SRP_user_pwd_sk_type(sk), ossl_check_SRP_user_pwd_type(ptr), pnum)
+#define sk_SRP_user_pwd_sort(sk) OPENSSL_sk_sort(ossl_check_SRP_user_pwd_sk_type(sk))
+#define sk_SRP_user_pwd_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_SRP_user_pwd_sk_type(sk))
+#define sk_SRP_user_pwd_dup(sk) ((STACK_OF(SRP_user_pwd) *)OPENSSL_sk_dup(ossl_check_const_SRP_user_pwd_sk_type(sk)))
+#define sk_SRP_user_pwd_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(SRP_user_pwd) *)OPENSSL_sk_deep_copy(ossl_check_const_SRP_user_pwd_sk_type(sk), ossl_check_SRP_user_pwd_copyfunc_type(copyfunc), ossl_check_SRP_user_pwd_freefunc_type(freefunc)))
+#define sk_SRP_user_pwd_set_cmp_func(sk, cmp) ((sk_SRP_user_pwd_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_SRP_user_pwd_sk_type(sk), ossl_check_SRP_user_pwd_compfunc_type(cmp)))
+
+
+OSSL_DEPRECATEDIN_3_0
+SRP_user_pwd *SRP_user_pwd_new(void);
+OSSL_DEPRECATEDIN_3_0
+void SRP_user_pwd_free(SRP_user_pwd *user_pwd);
+
+OSSL_DEPRECATEDIN_3_0
+void SRP_user_pwd_set_gN(SRP_user_pwd *user_pwd, const BIGNUM *g,
+                         const BIGNUM *N);
+OSSL_DEPRECATEDIN_3_0
+int SRP_user_pwd_set1_ids(SRP_user_pwd *user_pwd, const char *id,
+                          const char *info);
+OSSL_DEPRECATEDIN_3_0
+int SRP_user_pwd_set0_sv(SRP_user_pwd *user_pwd, BIGNUM *s, BIGNUM *v);
+
+typedef struct SRP_VBASE_st {
+    STACK_OF(SRP_user_pwd) *users_pwd;
+    STACK_OF(SRP_gN_cache) *gN_cache;
+/* to simulate a user */
+    char *seed_key;
+    const BIGNUM *default_g;
+    const BIGNUM *default_N;
+} SRP_VBASE;
+
+/*
+ * Internal structure storing N and g pair
+ */
+typedef struct SRP_gN_st {
+    char *id;
+    const BIGNUM *g;
+    const BIGNUM *N;
+} SRP_gN;
+SKM_DEFINE_STACK_OF_INTERNAL(SRP_gN, SRP_gN, SRP_gN)
+#define sk_SRP_gN_num(sk) OPENSSL_sk_num(ossl_check_const_SRP_gN_sk_type(sk))
+#define sk_SRP_gN_value(sk, idx) ((SRP_gN *)OPENSSL_sk_value(ossl_check_const_SRP_gN_sk_type(sk), (idx)))
+#define sk_SRP_gN_new(cmp) ((STACK_OF(SRP_gN) *)OPENSSL_sk_new(ossl_check_SRP_gN_compfunc_type(cmp)))
+#define sk_SRP_gN_new_null() ((STACK_OF(SRP_gN) *)OPENSSL_sk_new_null())
+#define sk_SRP_gN_new_reserve(cmp, n) ((STACK_OF(SRP_gN) *)OPENSSL_sk_new_reserve(ossl_check_SRP_gN_compfunc_type(cmp), (n)))
+#define sk_SRP_gN_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_SRP_gN_sk_type(sk), (n))
+#define sk_SRP_gN_free(sk) OPENSSL_sk_free(ossl_check_SRP_gN_sk_type(sk))
+#define sk_SRP_gN_zero(sk) OPENSSL_sk_zero(ossl_check_SRP_gN_sk_type(sk))
+#define sk_SRP_gN_delete(sk, i) ((SRP_gN *)OPENSSL_sk_delete(ossl_check_SRP_gN_sk_type(sk), (i)))
+#define sk_SRP_gN_delete_ptr(sk, ptr) ((SRP_gN *)OPENSSL_sk_delete_ptr(ossl_check_SRP_gN_sk_type(sk), ossl_check_SRP_gN_type(ptr)))
+#define sk_SRP_gN_push(sk, ptr) OPENSSL_sk_push(ossl_check_SRP_gN_sk_type(sk), ossl_check_SRP_gN_type(ptr))
+#define sk_SRP_gN_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_SRP_gN_sk_type(sk), ossl_check_SRP_gN_type(ptr))
+#define sk_SRP_gN_pop(sk) ((SRP_gN *)OPENSSL_sk_pop(ossl_check_SRP_gN_sk_type(sk)))
+#define sk_SRP_gN_shift(sk) ((SRP_gN *)OPENSSL_sk_shift(ossl_check_SRP_gN_sk_type(sk)))
+#define sk_SRP_gN_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_SRP_gN_sk_type(sk),ossl_check_SRP_gN_freefunc_type(freefunc))
+#define sk_SRP_gN_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_SRP_gN_sk_type(sk), ossl_check_SRP_gN_type(ptr), (idx))
+#define sk_SRP_gN_set(sk, idx, ptr) ((SRP_gN *)OPENSSL_sk_set(ossl_check_SRP_gN_sk_type(sk), (idx), ossl_check_SRP_gN_type(ptr)))
+#define sk_SRP_gN_find(sk, ptr) OPENSSL_sk_find(ossl_check_SRP_gN_sk_type(sk), ossl_check_SRP_gN_type(ptr))
+#define sk_SRP_gN_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_SRP_gN_sk_type(sk), ossl_check_SRP_gN_type(ptr))
+#define sk_SRP_gN_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_SRP_gN_sk_type(sk), ossl_check_SRP_gN_type(ptr), pnum)
+#define sk_SRP_gN_sort(sk) OPENSSL_sk_sort(ossl_check_SRP_gN_sk_type(sk))
+#define sk_SRP_gN_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_SRP_gN_sk_type(sk))
+#define sk_SRP_gN_dup(sk) ((STACK_OF(SRP_gN) *)OPENSSL_sk_dup(ossl_check_const_SRP_gN_sk_type(sk)))
+#define sk_SRP_gN_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(SRP_gN) *)OPENSSL_sk_deep_copy(ossl_check_const_SRP_gN_sk_type(sk), ossl_check_SRP_gN_copyfunc_type(copyfunc), ossl_check_SRP_gN_freefunc_type(freefunc)))
+#define sk_SRP_gN_set_cmp_func(sk, cmp) ((sk_SRP_gN_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_SRP_gN_sk_type(sk), ossl_check_SRP_gN_compfunc_type(cmp)))
+
+
+
+OSSL_DEPRECATEDIN_3_0
+SRP_VBASE *SRP_VBASE_new(char *seed_key);
+OSSL_DEPRECATEDIN_3_0
+void SRP_VBASE_free(SRP_VBASE *vb);
+OSSL_DEPRECATEDIN_3_0
+int SRP_VBASE_init(SRP_VBASE *vb, char *verifier_file);
+
+OSSL_DEPRECATEDIN_3_0
+int SRP_VBASE_add0_user(SRP_VBASE *vb, SRP_user_pwd *user_pwd);
+
+/* NOTE: unlike in SRP_VBASE_get_by_user, caller owns the returned pointer.*/
+OSSL_DEPRECATEDIN_3_0
+SRP_user_pwd *SRP_VBASE_get1_by_user(SRP_VBASE *vb, char *username);
+
+OSSL_DEPRECATEDIN_3_0
+char *SRP_create_verifier_ex(const char *user, const char *pass, char **salt,
+                             char **verifier, const char *N, const char *g,
+                             OSSL_LIB_CTX *libctx, const char *propq);
+OSSL_DEPRECATEDIN_3_0
+char *SRP_create_verifier(const char *user, const char *pass, char **salt,
+                          char **verifier, const char *N, const char *g);
+OSSL_DEPRECATEDIN_3_0
+int SRP_create_verifier_BN_ex(const char *user, const char *pass, BIGNUM **salt,
+                              BIGNUM **verifier, const BIGNUM *N,
+                              const BIGNUM *g, OSSL_LIB_CTX *libctx,
+                              const char *propq);
+OSSL_DEPRECATEDIN_3_0
+int SRP_create_verifier_BN(const char *user, const char *pass, BIGNUM **salt,
+                           BIGNUM **verifier, const BIGNUM *N,
+                           const BIGNUM *g);
+
+#  define SRP_NO_ERROR 0
+#  define SRP_ERR_VBASE_INCOMPLETE_FILE 1
+#  define SRP_ERR_VBASE_BN_LIB 2
+#  define SRP_ERR_OPEN_FILE 3
+#  define SRP_ERR_MEMORY 4
+
+#  define DB_srptype      0
+#  define DB_srpverifier  1
+#  define DB_srpsalt      2
+#  define DB_srpid        3
+#  define DB_srpgN        4
+#  define DB_srpinfo      5
+#  undef  DB_NUMBER
+#  define DB_NUMBER       6
+
+#  define DB_SRP_INDEX    'I'
+#  define DB_SRP_VALID    'V'
+#  define DB_SRP_REVOKED  'R'
+#  define DB_SRP_MODIF    'v'
+
+/* see srp.c */
+OSSL_DEPRECATEDIN_3_0
+char *SRP_check_known_gN_param(const BIGNUM *g, const BIGNUM *N);
+OSSL_DEPRECATEDIN_3_0
+SRP_gN *SRP_get_default_gN(const char *id);
+
+/* server side .... */
+OSSL_DEPRECATEDIN_3_0
+BIGNUM *SRP_Calc_server_key(const BIGNUM *A, const BIGNUM *v, const BIGNUM *u,
+                            const BIGNUM *b, const BIGNUM *N);
+OSSL_DEPRECATEDIN_3_0
+BIGNUM *SRP_Calc_B_ex(const BIGNUM *b, const BIGNUM *N, const BIGNUM *g,
+                      const BIGNUM *v, OSSL_LIB_CTX *libctx, const char *propq);
+OSSL_DEPRECATEDIN_3_0
+BIGNUM *SRP_Calc_B(const BIGNUM *b, const BIGNUM *N, const BIGNUM *g,
+                   const BIGNUM *v);
+
+OSSL_DEPRECATEDIN_3_0
+int SRP_Verify_A_mod_N(const BIGNUM *A, const BIGNUM *N);
+OSSL_DEPRECATEDIN_3_0
+BIGNUM *SRP_Calc_u_ex(const BIGNUM *A, const BIGNUM *B, const BIGNUM *N,
+                      OSSL_LIB_CTX *libctx, const char *propq);
+OSSL_DEPRECATEDIN_3_0
+BIGNUM *SRP_Calc_u(const BIGNUM *A, const BIGNUM *B, const BIGNUM *N);
+
+/* client side .... */
+
+OSSL_DEPRECATEDIN_3_0
+BIGNUM *SRP_Calc_x_ex(const BIGNUM *s, const char *user, const char *pass,
+                      OSSL_LIB_CTX *libctx, const char *propq);
+OSSL_DEPRECATEDIN_3_0
+BIGNUM *SRP_Calc_x(const BIGNUM *s, const char *user, const char *pass);
+OSSL_DEPRECATEDIN_3_0
+BIGNUM *SRP_Calc_A(const BIGNUM *a, const BIGNUM *N, const BIGNUM *g);
+OSSL_DEPRECATEDIN_3_0
+BIGNUM *SRP_Calc_client_key_ex(const BIGNUM *N, const BIGNUM *B, const BIGNUM *g,
+                            const BIGNUM *x, const BIGNUM *a, const BIGNUM *u,
+                            OSSL_LIB_CTX *libctx, const char *propq);
+OSSL_DEPRECATEDIN_3_0
+BIGNUM *SRP_Calc_client_key(const BIGNUM *N, const BIGNUM *B, const BIGNUM *g,
+                            const BIGNUM *x, const BIGNUM *a, const BIGNUM *u);
+OSSL_DEPRECATEDIN_3_0
+int SRP_Verify_B_mod_N(const BIGNUM *B, const BIGNUM *N);
+
+#  define SRP_MINIMAL_N 1024
+
+# endif /* OPENSSL_NO_DEPRECATED_3_0 */
+
+/* This method ignores the configured seed and fails for an unknown user. */
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+OSSL_DEPRECATEDIN_1_1_0
+SRP_user_pwd *SRP_VBASE_get_by_user(SRP_VBASE *vb, char *username);
+# endif
+
+# ifdef  __cplusplus
+}
+# endif
+# endif
+
+#endif
diff --git a/src/include/openssl/srtp.h b/src/include/openssl/srtp.h
new file mode 100644
index 0000000..2c2c334
--- /dev/null
+++ b/src/include/openssl/srtp.h
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2011-2016 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+/*
+ * DTLS code by Eric Rescorla <ekr@rtfm.com>
+ *
+ * Copyright (C) 2006, Network Resonance, Inc. Copyright (C) 2011, RTFM, Inc.
+ */
+
+#ifndef OPENSSL_SRTP_H
+# define OPENSSL_SRTP_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_D1_SRTP_H
+# endif
+
+# include <openssl/ssl.h>
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+# define SRTP_AES128_CM_SHA1_80                     0x0001
+# define SRTP_AES128_CM_SHA1_32                     0x0002
+# define SRTP_AES128_F8_SHA1_80                     0x0003
+# define SRTP_AES128_F8_SHA1_32                     0x0004
+# define SRTP_NULL_SHA1_80                          0x0005
+# define SRTP_NULL_SHA1_32                          0x0006
+
+/* AEAD SRTP protection profiles from RFC 7714 */
+# define SRTP_AEAD_AES_128_GCM                      0x0007
+# define SRTP_AEAD_AES_256_GCM                      0x0008
+
+/* DOUBLE AEAD SRTP protection profiles from RFC 8723 */
+# define SRTP_DOUBLE_AEAD_AES_128_GCM_AEAD_AES_128_GCM   0x0009
+# define SRTP_DOUBLE_AEAD_AES_256_GCM_AEAD_AES_256_GCM   0x000A
+
+/* ARIA SRTP protection profiles from RFC 8269 */
+# define SRTP_ARIA_128_CTR_HMAC_SHA1_80             0x000B
+# define SRTP_ARIA_128_CTR_HMAC_SHA1_32             0x000C
+# define SRTP_ARIA_256_CTR_HMAC_SHA1_80             0x000D
+# define SRTP_ARIA_256_CTR_HMAC_SHA1_32             0x000E
+# define SRTP_AEAD_ARIA_128_GCM                     0x000F
+# define SRTP_AEAD_ARIA_256_GCM                     0x0010
+
+# ifndef OPENSSL_NO_SRTP
+
+__owur int SSL_CTX_set_tlsext_use_srtp(SSL_CTX *ctx, const char *profiles);
+__owur int SSL_set_tlsext_use_srtp(SSL *ssl, const char *profiles);
+
+__owur STACK_OF(SRTP_PROTECTION_PROFILE) *SSL_get_srtp_profiles(SSL *ssl);
+__owur SRTP_PROTECTION_PROFILE *SSL_get_selected_srtp_profile(SSL *s);
+
+# endif
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/include/openssl/ssl.h b/src/include/openssl/ssl.h
new file mode 100644
index 0000000..288c8cf
--- /dev/null
+++ b/src/include/openssl/ssl.h
@@ -0,0 +1,2894 @@
+/*
+ * WARNING: do not edit!
+ * Generated by makefile from include\openssl\ssl.h.in
+ *
+ * Copyright 1995-2024 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved
+ * Copyright 2005 Nokia. All rights reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+
+
+#ifndef OPENSSL_SSL_H
+# define OPENSSL_SSL_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_SSL_H
+# endif
+
+# include <openssl/e_os2.h>
+# include <openssl/e_ostime.h>
+# include <openssl/opensslconf.h>
+# include <openssl/comp.h>
+# include <openssl/bio.h>
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#  include <openssl/x509.h>
+#  include <openssl/crypto.h>
+#  include <openssl/buffer.h>
+# endif
+# include <openssl/lhash.h>
+# include <openssl/pem.h>
+# include <openssl/hmac.h>
+# include <openssl/async.h>
+
+# include <openssl/safestack.h>
+# include <openssl/symhacks.h>
+# include <openssl/ct.h>
+# include <openssl/sslerr.h>
+# include <openssl/prov_ssl.h>
+# ifndef OPENSSL_NO_STDIO
+#  include <stdio.h>
+# endif
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+/* OpenSSL version number for ASN.1 encoding of the session information */
+/*-
+ * Version 0 - initial version
+ * Version 1 - added the optional peer certificate
+ */
+# define SSL_SESSION_ASN1_VERSION 0x0001
+
+# define SSL_MAX_SSL_SESSION_ID_LENGTH           32
+# define SSL_MAX_SID_CTX_LENGTH                  32
+
+# define SSL_MIN_RSA_MODULUS_LENGTH_IN_BYTES     (512/8)
+# define SSL_MAX_KEY_ARG_LENGTH                  8
+/* SSL_MAX_MASTER_KEY_LENGTH is defined in prov_ssl.h */
+
+/* The maximum number of encrypt/decrypt pipelines we can support */
+# define SSL_MAX_PIPELINES  32
+
+/* text strings for the ciphers */
+
+/* These are used to specify which ciphers to use and not to use */
+
+# define SSL_TXT_LOW             "LOW"
+# define SSL_TXT_MEDIUM          "MEDIUM"
+# define SSL_TXT_HIGH            "HIGH"
+# define SSL_TXT_FIPS            "FIPS"
+
+# define SSL_TXT_aNULL           "aNULL"
+# define SSL_TXT_eNULL           "eNULL"
+# define SSL_TXT_NULL            "NULL"
+
+# define SSL_TXT_kRSA            "kRSA"
+# define SSL_TXT_kDHr            "kDHr"/* this cipher class has been removed */
+# define SSL_TXT_kDHd            "kDHd"/* this cipher class has been removed */
+# define SSL_TXT_kDH             "kDH"/* this cipher class has been removed */
+# define SSL_TXT_kEDH            "kEDH"/* alias for kDHE */
+# define SSL_TXT_kDHE            "kDHE"
+# define SSL_TXT_kECDHr          "kECDHr"/* this cipher class has been removed */
+# define SSL_TXT_kECDHe          "kECDHe"/* this cipher class has been removed */
+# define SSL_TXT_kECDH           "kECDH"/* this cipher class has been removed */
+# define SSL_TXT_kEECDH          "kEECDH"/* alias for kECDHE */
+# define SSL_TXT_kECDHE          "kECDHE"
+# define SSL_TXT_kPSK            "kPSK"
+# define SSL_TXT_kRSAPSK         "kRSAPSK"
+# define SSL_TXT_kECDHEPSK       "kECDHEPSK"
+# define SSL_TXT_kDHEPSK         "kDHEPSK"
+# define SSL_TXT_kGOST           "kGOST"
+# define SSL_TXT_kGOST18         "kGOST18"
+# define SSL_TXT_kSRP            "kSRP"
+
+# define SSL_TXT_aRSA            "aRSA"
+# define SSL_TXT_aDSS            "aDSS"
+# define SSL_TXT_aDH             "aDH"/* this cipher class has been removed */
+# define SSL_TXT_aECDH           "aECDH"/* this cipher class has been removed */
+# define SSL_TXT_aECDSA          "aECDSA"
+# define SSL_TXT_aPSK            "aPSK"
+# define SSL_TXT_aGOST94         "aGOST94"
+# define SSL_TXT_aGOST01         "aGOST01"
+# define SSL_TXT_aGOST12         "aGOST12"
+# define SSL_TXT_aGOST           "aGOST"
+# define SSL_TXT_aSRP            "aSRP"
+
+# define SSL_TXT_DSS             "DSS"
+# define SSL_TXT_DH              "DH"
+# define SSL_TXT_DHE             "DHE"/* same as "kDHE:-ADH" */
+# define SSL_TXT_EDH             "EDH"/* alias for DHE */
+# define SSL_TXT_ADH             "ADH"
+# define SSL_TXT_RSA             "RSA"
+# define SSL_TXT_ECDH            "ECDH"
+# define SSL_TXT_EECDH           "EECDH"/* alias for ECDHE" */
+# define SSL_TXT_ECDHE           "ECDHE"/* same as "kECDHE:-AECDH" */
+# define SSL_TXT_AECDH           "AECDH"
+# define SSL_TXT_ECDSA           "ECDSA"
+# define SSL_TXT_PSK             "PSK"
+# define SSL_TXT_SRP             "SRP"
+
+# define SSL_TXT_DES             "DES"
+# define SSL_TXT_3DES            "3DES"
+# define SSL_TXT_RC4             "RC4"
+# define SSL_TXT_RC2             "RC2"
+# define SSL_TXT_IDEA            "IDEA"
+# define SSL_TXT_SEED            "SEED"
+# define SSL_TXT_AES128          "AES128"
+# define SSL_TXT_AES256          "AES256"
+# define SSL_TXT_AES             "AES"
+# define SSL_TXT_AES_GCM         "AESGCM"
+# define SSL_TXT_AES_CCM         "AESCCM"
+# define SSL_TXT_AES_CCM_8       "AESCCM8"
+# define SSL_TXT_CAMELLIA128     "CAMELLIA128"
+# define SSL_TXT_CAMELLIA256     "CAMELLIA256"
+# define SSL_TXT_CAMELLIA        "CAMELLIA"
+# define SSL_TXT_CHACHA20        "CHACHA20"
+# define SSL_TXT_GOST            "GOST89"
+# define SSL_TXT_ARIA            "ARIA"
+# define SSL_TXT_ARIA_GCM        "ARIAGCM"
+# define SSL_TXT_ARIA128         "ARIA128"
+# define SSL_TXT_ARIA256         "ARIA256"
+# define SSL_TXT_GOST2012_GOST8912_GOST8912 "GOST2012-GOST8912-GOST8912"
+# define SSL_TXT_CBC             "CBC"
+
+# define SSL_TXT_MD5             "MD5"
+# define SSL_TXT_SHA1            "SHA1"
+# define SSL_TXT_SHA             "SHA"/* same as "SHA1" */
+# define SSL_TXT_GOST94          "GOST94"
+# define SSL_TXT_GOST89MAC       "GOST89MAC"
+# define SSL_TXT_GOST12          "GOST12"
+# define SSL_TXT_GOST89MAC12     "GOST89MAC12"
+# define SSL_TXT_SHA256          "SHA256"
+# define SSL_TXT_SHA384          "SHA384"
+
+# define SSL_TXT_SSLV3           "SSLv3"
+# define SSL_TXT_TLSV1           "TLSv1"
+# define SSL_TXT_TLSV1_1         "TLSv1.1"
+# define SSL_TXT_TLSV1_2         "TLSv1.2"
+
+# define SSL_TXT_ALL             "ALL"
+
+/*-
+ * COMPLEMENTOF* definitions. These identifiers are used to (de-select)
+ * ciphers normally not being used.
+ * Example: "RC4" will activate all ciphers using RC4 including ciphers
+ * without authentication, which would normally disabled by DEFAULT (due
+ * the "!ADH" being part of default). Therefore "RC4:!COMPLEMENTOFDEFAULT"
+ * will make sure that it is also disabled in the specific selection.
+ * COMPLEMENTOF* identifiers are portable between version, as adjustments
+ * to the default cipher setup will also be included here.
+ *
+ * COMPLEMENTOFDEFAULT does not experience the same special treatment that
+ * DEFAULT gets, as only selection is being done and no sorting as needed
+ * for DEFAULT.
+ */
+# define SSL_TXT_CMPALL          "COMPLEMENTOFALL"
+# define SSL_TXT_CMPDEF          "COMPLEMENTOFDEFAULT"
+
+/*
+ * The following cipher list is used by default. It also is substituted when
+ * an application-defined cipher list string starts with 'DEFAULT'.
+ * This applies to ciphersuites for TLSv1.2 and below.
+ * DEPRECATED IN 3.0.0, in favor of OSSL_default_cipher_list()
+ * Update both macro and function simultaneously
+ */
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define SSL_DEFAULT_CIPHER_LIST "ALL:!COMPLEMENTOFDEFAULT:!eNULL"
+/*
+ * This is the default set of TLSv1.3 ciphersuites
+ * DEPRECATED IN 3.0.0, in favor of OSSL_default_ciphersuites()
+ * Update both macro and function simultaneously
+ */
+#  define TLS_DEFAULT_CIPHERSUITES "TLS_AES_256_GCM_SHA384:" \
+                                   "TLS_CHACHA20_POLY1305_SHA256:" \
+                                   "TLS_AES_128_GCM_SHA256"
+# endif
+/*
+ * As of OpenSSL 1.0.0, ssl_create_cipher_list() in ssl/ssl_ciph.c always
+ * starts with a reasonable order, and all we have to do for DEFAULT is
+ * throwing out anonymous and unencrypted ciphersuites! (The latter are not
+ * actually enabled by ALL, but "ALL:RSA" would enable some of them.)
+ */
+
+/* Used in SSL_set_shutdown()/SSL_get_shutdown(); */
+# define SSL_SENT_SHUTDOWN       1
+# define SSL_RECEIVED_SHUTDOWN   2
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+# define SSL_FILETYPE_ASN1       X509_FILETYPE_ASN1
+# define SSL_FILETYPE_PEM        X509_FILETYPE_PEM
+
+/*
+ * This is needed to stop compilers complaining about the 'struct ssl_st *'
+ * function parameters used to prototype callbacks in SSL_CTX.
+ */
+typedef struct ssl_st *ssl_crock_st;
+typedef struct tls_session_ticket_ext_st TLS_SESSION_TICKET_EXT;
+typedef struct ssl_method_st SSL_METHOD;
+typedef struct ssl_cipher_st SSL_CIPHER;
+typedef struct ssl_session_st SSL_SESSION;
+typedef struct tls_sigalgs_st TLS_SIGALGS;
+typedef struct ssl_conf_ctx_st SSL_CONF_CTX;
+typedef struct ssl_comp_st SSL_COMP;
+
+STACK_OF(SSL_CIPHER);
+STACK_OF(SSL_COMP);
+
+/* SRTP protection profiles for use with the use_srtp extension (RFC 5764)*/
+typedef struct srtp_protection_profile_st {
+    const char *name;
+    unsigned long id;
+} SRTP_PROTECTION_PROFILE;
+SKM_DEFINE_STACK_OF_INTERNAL(SRTP_PROTECTION_PROFILE, SRTP_PROTECTION_PROFILE, SRTP_PROTECTION_PROFILE)
+#define sk_SRTP_PROTECTION_PROFILE_num(sk) OPENSSL_sk_num(ossl_check_const_SRTP_PROTECTION_PROFILE_sk_type(sk))
+#define sk_SRTP_PROTECTION_PROFILE_value(sk, idx) ((SRTP_PROTECTION_PROFILE *)OPENSSL_sk_value(ossl_check_const_SRTP_PROTECTION_PROFILE_sk_type(sk), (idx)))
+#define sk_SRTP_PROTECTION_PROFILE_new(cmp) ((STACK_OF(SRTP_PROTECTION_PROFILE) *)OPENSSL_sk_new(ossl_check_SRTP_PROTECTION_PROFILE_compfunc_type(cmp)))
+#define sk_SRTP_PROTECTION_PROFILE_new_null() ((STACK_OF(SRTP_PROTECTION_PROFILE) *)OPENSSL_sk_new_null())
+#define sk_SRTP_PROTECTION_PROFILE_new_reserve(cmp, n) ((STACK_OF(SRTP_PROTECTION_PROFILE) *)OPENSSL_sk_new_reserve(ossl_check_SRTP_PROTECTION_PROFILE_compfunc_type(cmp), (n)))
+#define sk_SRTP_PROTECTION_PROFILE_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk), (n))
+#define sk_SRTP_PROTECTION_PROFILE_free(sk) OPENSSL_sk_free(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk))
+#define sk_SRTP_PROTECTION_PROFILE_zero(sk) OPENSSL_sk_zero(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk))
+#define sk_SRTP_PROTECTION_PROFILE_delete(sk, i) ((SRTP_PROTECTION_PROFILE *)OPENSSL_sk_delete(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk), (i)))
+#define sk_SRTP_PROTECTION_PROFILE_delete_ptr(sk, ptr) ((SRTP_PROTECTION_PROFILE *)OPENSSL_sk_delete_ptr(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk), ossl_check_SRTP_PROTECTION_PROFILE_type(ptr)))
+#define sk_SRTP_PROTECTION_PROFILE_push(sk, ptr) OPENSSL_sk_push(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk), ossl_check_SRTP_PROTECTION_PROFILE_type(ptr))
+#define sk_SRTP_PROTECTION_PROFILE_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk), ossl_check_SRTP_PROTECTION_PROFILE_type(ptr))
+#define sk_SRTP_PROTECTION_PROFILE_pop(sk) ((SRTP_PROTECTION_PROFILE *)OPENSSL_sk_pop(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk)))
+#define sk_SRTP_PROTECTION_PROFILE_shift(sk) ((SRTP_PROTECTION_PROFILE *)OPENSSL_sk_shift(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk)))
+#define sk_SRTP_PROTECTION_PROFILE_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk),ossl_check_SRTP_PROTECTION_PROFILE_freefunc_type(freefunc))
+#define sk_SRTP_PROTECTION_PROFILE_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk), ossl_check_SRTP_PROTECTION_PROFILE_type(ptr), (idx))
+#define sk_SRTP_PROTECTION_PROFILE_set(sk, idx, ptr) ((SRTP_PROTECTION_PROFILE *)OPENSSL_sk_set(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk), (idx), ossl_check_SRTP_PROTECTION_PROFILE_type(ptr)))
+#define sk_SRTP_PROTECTION_PROFILE_find(sk, ptr) OPENSSL_sk_find(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk), ossl_check_SRTP_PROTECTION_PROFILE_type(ptr))
+#define sk_SRTP_PROTECTION_PROFILE_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk), ossl_check_SRTP_PROTECTION_PROFILE_type(ptr))
+#define sk_SRTP_PROTECTION_PROFILE_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk), ossl_check_SRTP_PROTECTION_PROFILE_type(ptr), pnum)
+#define sk_SRTP_PROTECTION_PROFILE_sort(sk) OPENSSL_sk_sort(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk))
+#define sk_SRTP_PROTECTION_PROFILE_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_SRTP_PROTECTION_PROFILE_sk_type(sk))
+#define sk_SRTP_PROTECTION_PROFILE_dup(sk) ((STACK_OF(SRTP_PROTECTION_PROFILE) *)OPENSSL_sk_dup(ossl_check_const_SRTP_PROTECTION_PROFILE_sk_type(sk)))
+#define sk_SRTP_PROTECTION_PROFILE_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(SRTP_PROTECTION_PROFILE) *)OPENSSL_sk_deep_copy(ossl_check_const_SRTP_PROTECTION_PROFILE_sk_type(sk), ossl_check_SRTP_PROTECTION_PROFILE_copyfunc_type(copyfunc), ossl_check_SRTP_PROTECTION_PROFILE_freefunc_type(freefunc)))
+#define sk_SRTP_PROTECTION_PROFILE_set_cmp_func(sk, cmp) ((sk_SRTP_PROTECTION_PROFILE_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk), ossl_check_SRTP_PROTECTION_PROFILE_compfunc_type(cmp)))
+
+
+
+typedef int (*tls_session_ticket_ext_cb_fn)(SSL *s, const unsigned char *data,
+                                            int len, void *arg);
+typedef int (*tls_session_secret_cb_fn)(SSL *s, void *secret, int *secret_len,
+                                        STACK_OF(SSL_CIPHER) *peer_ciphers,
+                                        const SSL_CIPHER **cipher, void *arg);
+
+/* Extension context codes */
+/* This extension is only allowed in TLS */
+#define SSL_EXT_TLS_ONLY                        0x00001
+/* This extension is only allowed in DTLS */
+#define SSL_EXT_DTLS_ONLY                       0x00002
+/* Some extensions may be allowed in DTLS but we don't implement them for it */
+#define SSL_EXT_TLS_IMPLEMENTATION_ONLY         0x00004
+/* Most extensions are not defined for SSLv3 but EXT_TYPE_renegotiate is */
+#define SSL_EXT_SSL3_ALLOWED                    0x00008
+/* Extension is only defined for TLS1.2 and below */
+#define SSL_EXT_TLS1_2_AND_BELOW_ONLY           0x00010
+/* Extension is only defined for TLS1.3 and above */
+#define SSL_EXT_TLS1_3_ONLY                     0x00020
+/* Ignore this extension during parsing if we are resuming */
+#define SSL_EXT_IGNORE_ON_RESUMPTION            0x00040
+#define SSL_EXT_CLIENT_HELLO                    0x00080
+/* Really means TLS1.2 or below */
+#define SSL_EXT_TLS1_2_SERVER_HELLO             0x00100
+#define SSL_EXT_TLS1_3_SERVER_HELLO             0x00200
+#define SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS     0x00400
+#define SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST      0x00800
+#define SSL_EXT_TLS1_3_CERTIFICATE              0x01000
+#define SSL_EXT_TLS1_3_NEW_SESSION_TICKET       0x02000
+#define SSL_EXT_TLS1_3_CERTIFICATE_REQUEST      0x04000
+#define SSL_EXT_TLS1_3_CERTIFICATE_COMPRESSION  0x08000
+/* When sending a raw public key in a certificate message */
+#define SSL_EXT_TLS1_3_RAW_PUBLIC_KEY           0x10000
+
+/* Typedefs for handling custom extensions */
+
+typedef int (*custom_ext_add_cb)(SSL *s, unsigned int ext_type,
+                                 const unsigned char **out, size_t *outlen,
+                                 int *al, void *add_arg);
+
+typedef void (*custom_ext_free_cb)(SSL *s, unsigned int ext_type,
+                                   const unsigned char *out, void *add_arg);
+
+typedef int (*custom_ext_parse_cb)(SSL *s, unsigned int ext_type,
+                                   const unsigned char *in, size_t inlen,
+                                   int *al, void *parse_arg);
+
+
+typedef int (*SSL_custom_ext_add_cb_ex)(SSL *s, unsigned int ext_type,
+                                        unsigned int context,
+                                        const unsigned char **out,
+                                        size_t *outlen, X509 *x,
+                                        size_t chainidx,
+                                        int *al, void *add_arg);
+
+typedef void (*SSL_custom_ext_free_cb_ex)(SSL *s, unsigned int ext_type,
+                                          unsigned int context,
+                                          const unsigned char *out,
+                                          void *add_arg);
+
+typedef int (*SSL_custom_ext_parse_cb_ex)(SSL *s, unsigned int ext_type,
+                                          unsigned int context,
+                                          const unsigned char *in,
+                                          size_t inlen, X509 *x,
+                                          size_t chainidx,
+                                          int *al, void *parse_arg);
+
+/* Typedef for verification callback */
+typedef int (*SSL_verify_cb)(int preverify_ok, X509_STORE_CTX *x509_ctx);
+
+/* Typedef for SSL async callback */
+typedef int (*SSL_async_callback_fn)(SSL *s, void *arg);
+
+#define SSL_OP_BIT(n)  ((uint64_t)1 << (uint64_t)n)
+
+/*
+ * SSL/TLS connection options.
+ */
+    /* Disable Extended master secret */
+# define SSL_OP_NO_EXTENDED_MASTER_SECRET                SSL_OP_BIT(0)
+    /* Cleanse plaintext copies of data delivered to the application */
+# define SSL_OP_CLEANSE_PLAINTEXT                        SSL_OP_BIT(1)
+    /* Allow initial connection to servers that don't support RI */
+# define SSL_OP_LEGACY_SERVER_CONNECT                    SSL_OP_BIT(2)
+    /* Enable support for Kernel TLS */
+# define SSL_OP_ENABLE_KTLS                              SSL_OP_BIT(3)
+# define SSL_OP_TLSEXT_PADDING                           SSL_OP_BIT(4)
+# define SSL_OP_SAFARI_ECDHE_ECDSA_BUG                   SSL_OP_BIT(6)
+# define SSL_OP_IGNORE_UNEXPECTED_EOF                    SSL_OP_BIT(7)
+# define SSL_OP_ALLOW_CLIENT_RENEGOTIATION               SSL_OP_BIT(8)
+# define SSL_OP_DISABLE_TLSEXT_CA_NAMES                  SSL_OP_BIT(9)
+    /* In TLSv1.3 allow a non-(ec)dhe based kex_mode */
+# define SSL_OP_ALLOW_NO_DHE_KEX                         SSL_OP_BIT(10)
+    /*
+     * Disable SSL 3.0/TLS 1.0 CBC vulnerability workaround that was added
+     * in OpenSSL 0.9.6d.  Usually (depending on the application protocol)
+     * the workaround is not needed.  Unfortunately some broken SSL/TLS
+     * implementations cannot handle it at all, which is why we include it
+     * in SSL_OP_ALL. Added in 0.9.6e
+     */
+# define SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS              SSL_OP_BIT(11)
+    /* DTLS options */
+# define SSL_OP_NO_QUERY_MTU                             SSL_OP_BIT(12)
+    /* Turn on Cookie Exchange (on relevant for servers) */
+# define SSL_OP_COOKIE_EXCHANGE                          SSL_OP_BIT(13)
+    /* Don't use RFC4507 ticket extension */
+# define SSL_OP_NO_TICKET                                SSL_OP_BIT(14)
+# ifndef OPENSSL_NO_DTLS1_METHOD
+    /*
+     * Use Cisco's version identifier of DTLS_BAD_VER
+     * (only with deprecated DTLSv1_client_method())
+     */
+#  define SSL_OP_CISCO_ANYCONNECT                        SSL_OP_BIT(15)
+# endif
+    /* As server, disallow session resumption on renegotiation */
+# define SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION   SSL_OP_BIT(16)
+    /* Don't use compression even if supported */
+# define SSL_OP_NO_COMPRESSION                           SSL_OP_BIT(17)
+    /* Permit unsafe legacy renegotiation */
+# define SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION        SSL_OP_BIT(18)
+    /* Disable encrypt-then-mac */
+# define SSL_OP_NO_ENCRYPT_THEN_MAC                      SSL_OP_BIT(19)
+    /*
+     * Enable TLSv1.3 Compatibility mode. This is on by default. A future
+     * version of OpenSSL may have this disabled by default.
+     */
+# define SSL_OP_ENABLE_MIDDLEBOX_COMPAT                  SSL_OP_BIT(20)
+    /*
+     * Prioritize Chacha20Poly1305 when client does.
+     * Modifies SSL_OP_CIPHER_SERVER_PREFERENCE
+     */
+# define SSL_OP_PRIORITIZE_CHACHA                        SSL_OP_BIT(21)
+    /*
+     * Set on servers to choose the cipher according to server's preferences.
+     */
+# define SSL_OP_CIPHER_SERVER_PREFERENCE                 SSL_OP_BIT(22)
+    /*
+     * If set, a server will allow a client to issue a SSLv3.0 version
+     * number as latest version supported in the premaster secret, even when
+     * TLSv1.0 (version 3.1) was announced in the client hello. Normally
+     * this is forbidden to prevent version rollback attacks.
+     */
+# define SSL_OP_TLS_ROLLBACK_BUG                         SSL_OP_BIT(23)
+    /*
+     * Switches off automatic TLSv1.3 anti-replay protection for early data.
+     * This is a server-side option only (no effect on the client).
+     */
+# define SSL_OP_NO_ANTI_REPLAY                           SSL_OP_BIT(24)
+# define SSL_OP_NO_SSLv3                                 SSL_OP_BIT(25)
+# define SSL_OP_NO_TLSv1                                 SSL_OP_BIT(26)
+# define SSL_OP_NO_TLSv1_2                               SSL_OP_BIT(27)
+# define SSL_OP_NO_TLSv1_1                               SSL_OP_BIT(28)
+# define SSL_OP_NO_TLSv1_3                               SSL_OP_BIT(29)
+# define SSL_OP_NO_DTLSv1                                SSL_OP_BIT(26)
+# define SSL_OP_NO_DTLSv1_2                              SSL_OP_BIT(27)
+    /* Disallow all renegotiation */
+# define SSL_OP_NO_RENEGOTIATION                         SSL_OP_BIT(30)
+    /*
+     * Make server add server-hello extension from early version of
+     * cryptopro draft, when GOST ciphersuite is negotiated. Required for
+     * interoperability with CryptoPro CSP 3.x
+     */
+# define SSL_OP_CRYPTOPRO_TLSEXT_BUG                     SSL_OP_BIT(31)
+/*
+ * Disable RFC8879 certificate compression
+ * SSL_OP_NO_TX_CERTIFICATE_COMPRESSION: don't send compressed certificates,
+ *     and ignore the extension when received.
+ * SSL_OP_NO_RX_CERTIFICATE_COMPRESSION: don't send the extension, and
+ *     subsequently indicating that receiving is not supported
+ */
+# define SSL_OP_NO_TX_CERTIFICATE_COMPRESSION            SSL_OP_BIT(32)
+# define SSL_OP_NO_RX_CERTIFICATE_COMPRESSION            SSL_OP_BIT(33)
+    /* Enable KTLS TX zerocopy on Linux */
+# define SSL_OP_ENABLE_KTLS_TX_ZEROCOPY_SENDFILE         SSL_OP_BIT(34)
+
+#define SSL_OP_PREFER_NO_DHE_KEX                         SSL_OP_BIT(35)
+
+/*
+ * Option "collections."
+ */
+# define SSL_OP_NO_SSL_MASK \
+        ( SSL_OP_NO_SSLv3 | SSL_OP_NO_TLSv1 | SSL_OP_NO_TLSv1_1 \
+          | SSL_OP_NO_TLSv1_2 | SSL_OP_NO_TLSv1_3 )
+# define SSL_OP_NO_DTLS_MASK \
+        ( SSL_OP_NO_DTLSv1 | SSL_OP_NO_DTLSv1_2 )
+
+/* Various bug workarounds that should be rather harmless. */
+# define SSL_OP_ALL \
+        ( SSL_OP_CRYPTOPRO_TLSEXT_BUG | SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS \
+          | SSL_OP_TLSEXT_PADDING | SSL_OP_SAFARI_ECDHE_ECDSA_BUG )
+
+/*
+ * OBSOLETE OPTIONS retained for compatibility
+ */
+
+# define SSL_OP_MICROSOFT_SESS_ID_BUG                    0x0
+# define SSL_OP_NETSCAPE_CHALLENGE_BUG                   0x0
+# define SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG         0x0
+# define SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG              0x0
+# define SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER               0x0
+# define SSL_OP_MSIE_SSLV2_RSA_PADDING                   0x0
+# define SSL_OP_SSLEAY_080_CLIENT_DH_BUG                 0x0
+# define SSL_OP_TLS_D5_BUG                               0x0
+# define SSL_OP_TLS_BLOCK_PADDING_BUG                    0x0
+# define SSL_OP_SINGLE_ECDH_USE                          0x0
+# define SSL_OP_SINGLE_DH_USE                            0x0
+# define SSL_OP_EPHEMERAL_RSA                            0x0
+# define SSL_OP_NO_SSLv2                                 0x0
+# define SSL_OP_PKCS1_CHECK_1                            0x0
+# define SSL_OP_PKCS1_CHECK_2                            0x0
+# define SSL_OP_NETSCAPE_CA_DN_BUG                       0x0
+# define SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG          0x0
+
+/*
+ * Allow SSL_write(..., n) to return r with 0 < r < n (i.e. report success
+ * when just a single record has been written):
+ */
+# define SSL_MODE_ENABLE_PARTIAL_WRITE       0x00000001U
+/*
+ * Make it possible to retry SSL_write() with changed buffer location (buffer
+ * contents must stay the same!); this is not the default to avoid the
+ * misconception that non-blocking SSL_write() behaves like non-blocking
+ * write():
+ */
+# define SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER 0x00000002U
+/*
+ * Never bother the application with retries if the transport is blocking:
+ */
+# define SSL_MODE_AUTO_RETRY 0x00000004U
+/* Don't attempt to automatically build certificate chain */
+# define SSL_MODE_NO_AUTO_CHAIN 0x00000008U
+/*
+ * Save RAM by releasing read and write buffers when they're empty. (SSL3 and
+ * TLS only.) Released buffers are freed.
+ */
+# define SSL_MODE_RELEASE_BUFFERS 0x00000010U
+/*
+ * Send the current time in the Random fields of the ClientHello and
+ * ServerHello records for compatibility with hypothetical implementations
+ * that require it.
+ */
+# define SSL_MODE_SEND_CLIENTHELLO_TIME 0x00000020U
+# define SSL_MODE_SEND_SERVERHELLO_TIME 0x00000040U
+/*
+ * Send TLS_FALLBACK_SCSV in the ClientHello. To be set only by applications
+ * that reconnect with a downgraded protocol version; see
+ * draft-ietf-tls-downgrade-scsv-00 for details. DO NOT ENABLE THIS if your
+ * application attempts a normal handshake. Only use this in explicit
+ * fallback retries, following the guidance in
+ * draft-ietf-tls-downgrade-scsv-00.
+ */
+# define SSL_MODE_SEND_FALLBACK_SCSV 0x00000080U
+/*
+ * Support Asynchronous operation
+ */
+# define SSL_MODE_ASYNC 0x00000100U
+
+/*
+ * When using DTLS/SCTP, include the terminating zero in the label
+ * used for computing the endpoint-pair shared secret. Required for
+ * interoperability with implementations having this bug like these
+ * older version of OpenSSL:
+ * - OpenSSL 1.0.0 series
+ * - OpenSSL 1.0.1 series
+ * - OpenSSL 1.0.2 series
+ * - OpenSSL 1.1.0 series
+ * - OpenSSL 1.1.1 and 1.1.1a
+ */
+# define SSL_MODE_DTLS_SCTP_LABEL_LENGTH_BUG 0x00000400U
+
+/* Cert related flags */
+/*
+ * Many implementations ignore some aspects of the TLS standards such as
+ * enforcing certificate chain algorithms. When this is set we enforce them.
+ */
+# define SSL_CERT_FLAG_TLS_STRICT                0x00000001U
+
+/* Suite B modes, takes same values as certificate verify flags */
+# define SSL_CERT_FLAG_SUITEB_128_LOS_ONLY       0x10000
+/* Suite B 192 bit only mode */
+# define SSL_CERT_FLAG_SUITEB_192_LOS            0x20000
+/* Suite B 128 bit mode allowing 192 bit algorithms */
+# define SSL_CERT_FLAG_SUITEB_128_LOS            0x30000
+
+/* Perform all sorts of protocol violations for testing purposes */
+# define SSL_CERT_FLAG_BROKEN_PROTOCOL           0x10000000
+
+/* Flags for building certificate chains */
+/* Treat any existing certificates as untrusted CAs */
+# define SSL_BUILD_CHAIN_FLAG_UNTRUSTED          0x1
+/* Don't include root CA in chain */
+# define SSL_BUILD_CHAIN_FLAG_NO_ROOT            0x2
+/* Just check certificates already there */
+# define SSL_BUILD_CHAIN_FLAG_CHECK              0x4
+/* Ignore verification errors */
+# define SSL_BUILD_CHAIN_FLAG_IGNORE_ERROR       0x8
+/* Clear verification errors from queue */
+# define SSL_BUILD_CHAIN_FLAG_CLEAR_ERROR        0x10
+
+/* Flags returned by SSL_check_chain */
+/* Certificate can be used with this session */
+# define CERT_PKEY_VALID         0x1
+/* Certificate can also be used for signing */
+# define CERT_PKEY_SIGN          0x2
+/* EE certificate signing algorithm OK */
+# define CERT_PKEY_EE_SIGNATURE  0x10
+/* CA signature algorithms OK */
+# define CERT_PKEY_CA_SIGNATURE  0x20
+/* EE certificate parameters OK */
+# define CERT_PKEY_EE_PARAM      0x40
+/* CA certificate parameters OK */
+# define CERT_PKEY_CA_PARAM      0x80
+/* Signing explicitly allowed as opposed to SHA1 fallback */
+# define CERT_PKEY_EXPLICIT_SIGN 0x100
+/* Client CA issuer names match (always set for server cert) */
+# define CERT_PKEY_ISSUER_NAME   0x200
+/* Cert type matches client types (always set for server cert) */
+# define CERT_PKEY_CERT_TYPE     0x400
+/* Cert chain suitable to Suite B */
+# define CERT_PKEY_SUITEB        0x800
+/* Cert pkey valid for raw public key use */
+# define CERT_PKEY_RPK           0x1000
+
+# define SSL_CONF_FLAG_CMDLINE           0x1
+# define SSL_CONF_FLAG_FILE              0x2
+# define SSL_CONF_FLAG_CLIENT            0x4
+# define SSL_CONF_FLAG_SERVER            0x8
+# define SSL_CONF_FLAG_SHOW_ERRORS       0x10
+# define SSL_CONF_FLAG_CERTIFICATE       0x20
+# define SSL_CONF_FLAG_REQUIRE_PRIVATE   0x40
+/* Configuration value types */
+# define SSL_CONF_TYPE_UNKNOWN           0x0
+# define SSL_CONF_TYPE_STRING            0x1
+# define SSL_CONF_TYPE_FILE              0x2
+# define SSL_CONF_TYPE_DIR               0x3
+# define SSL_CONF_TYPE_NONE              0x4
+# define SSL_CONF_TYPE_STORE             0x5
+
+/* Maximum length of the application-controlled segment of a a TLSv1.3 cookie */
+# define SSL_COOKIE_LENGTH                       4096
+
+/*
+ * Note: SSL[_CTX]_set_{options,mode} use |= op on the previous value, they
+ * cannot be used to clear bits.
+ */
+
+uint64_t SSL_CTX_get_options(const SSL_CTX *ctx);
+uint64_t SSL_get_options(const SSL *s);
+uint64_t SSL_CTX_clear_options(SSL_CTX *ctx, uint64_t op);
+uint64_t SSL_clear_options(SSL *s, uint64_t op);
+uint64_t SSL_CTX_set_options(SSL_CTX *ctx, uint64_t op);
+uint64_t SSL_set_options(SSL *s, uint64_t op);
+
+# define SSL_CTX_set_mode(ctx,op) \
+        SSL_CTX_ctrl((ctx),SSL_CTRL_MODE,(op),NULL)
+# define SSL_CTX_clear_mode(ctx,op) \
+        SSL_CTX_ctrl((ctx),SSL_CTRL_CLEAR_MODE,(op),NULL)
+# define SSL_CTX_get_mode(ctx) \
+        SSL_CTX_ctrl((ctx),SSL_CTRL_MODE,0,NULL)
+# define SSL_clear_mode(ssl,op) \
+        SSL_ctrl((ssl),SSL_CTRL_CLEAR_MODE,(op),NULL)
+# define SSL_set_mode(ssl,op) \
+        SSL_ctrl((ssl),SSL_CTRL_MODE,(op),NULL)
+# define SSL_get_mode(ssl) \
+        SSL_ctrl((ssl),SSL_CTRL_MODE,0,NULL)
+# define SSL_set_mtu(ssl, mtu) \
+        SSL_ctrl((ssl),SSL_CTRL_SET_MTU,(mtu),NULL)
+# define DTLS_set_link_mtu(ssl, mtu) \
+        SSL_ctrl((ssl),DTLS_CTRL_SET_LINK_MTU,(mtu),NULL)
+# define DTLS_get_link_min_mtu(ssl) \
+        SSL_ctrl((ssl),DTLS_CTRL_GET_LINK_MIN_MTU,0,NULL)
+
+# define SSL_get_secure_renegotiation_support(ssl) \
+        SSL_ctrl((ssl), SSL_CTRL_GET_RI_SUPPORT, 0, NULL)
+
+# define SSL_CTX_set_cert_flags(ctx,op) \
+        SSL_CTX_ctrl((ctx),SSL_CTRL_CERT_FLAGS,(op),NULL)
+# define SSL_set_cert_flags(s,op) \
+        SSL_ctrl((s),SSL_CTRL_CERT_FLAGS,(op),NULL)
+# define SSL_CTX_clear_cert_flags(ctx,op) \
+        SSL_CTX_ctrl((ctx),SSL_CTRL_CLEAR_CERT_FLAGS,(op),NULL)
+# define SSL_clear_cert_flags(s,op) \
+        SSL_ctrl((s),SSL_CTRL_CLEAR_CERT_FLAGS,(op),NULL)
+
+void SSL_CTX_set_msg_callback(SSL_CTX *ctx,
+                              void (*cb) (int write_p, int version,
+                                          int content_type, const void *buf,
+                                          size_t len, SSL *ssl, void *arg));
+void SSL_set_msg_callback(SSL *ssl,
+                          void (*cb) (int write_p, int version,
+                                      int content_type, const void *buf,
+                                      size_t len, SSL *ssl, void *arg));
+# define SSL_CTX_set_msg_callback_arg(ctx, arg) SSL_CTX_ctrl((ctx), SSL_CTRL_SET_MSG_CALLBACK_ARG, 0, (arg))
+# define SSL_set_msg_callback_arg(ssl, arg) SSL_ctrl((ssl), SSL_CTRL_SET_MSG_CALLBACK_ARG, 0, (arg))
+
+# define SSL_get_extms_support(s) \
+        SSL_ctrl((s),SSL_CTRL_GET_EXTMS_SUPPORT,0,NULL)
+
+# ifndef OPENSSL_NO_SRP
+/* see tls_srp.c */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 __owur int SSL_SRP_CTX_init(SSL *s);
+OSSL_DEPRECATEDIN_3_0 __owur int SSL_CTX_SRP_CTX_init(SSL_CTX *ctx);
+OSSL_DEPRECATEDIN_3_0 int SSL_SRP_CTX_free(SSL *ctx);
+OSSL_DEPRECATEDIN_3_0 int SSL_CTX_SRP_CTX_free(SSL_CTX *ctx);
+OSSL_DEPRECATEDIN_3_0 __owur int SSL_srp_server_param_with_username(SSL *s,
+                                                                    int *ad);
+OSSL_DEPRECATEDIN_3_0 __owur int SRP_Calc_A_param(SSL *s);
+#  endif
+# endif
+
+/* 100k max cert list */
+# define SSL_MAX_CERT_LIST_DEFAULT (1024*100)
+
+# define SSL_SESSION_CACHE_MAX_SIZE_DEFAULT      (1024*20)
+
+/*
+ * This callback type is used inside SSL_CTX, SSL, and in the functions that
+ * set them. It is used to override the generation of SSL/TLS session IDs in
+ * a server. Return value should be zero on an error, non-zero to proceed.
+ * Also, callbacks should themselves check if the id they generate is unique
+ * otherwise the SSL handshake will fail with an error - callbacks can do
+ * this using the 'ssl' value they're passed by;
+ * SSL_has_matching_session_id(ssl, id, *id_len) The length value passed in
+ * is set at the maximum size the session ID can be. In SSLv3/TLSv1 it is 32
+ * bytes. The callback can alter this length to be less if desired. It is
+ * also an error for the callback to set the size to zero.
+ */
+typedef int (*GEN_SESSION_CB) (SSL *ssl, unsigned char *id,
+                               unsigned int *id_len);
+
+# define SSL_SESS_CACHE_OFF                      0x0000
+# define SSL_SESS_CACHE_CLIENT                   0x0001
+# define SSL_SESS_CACHE_SERVER                   0x0002
+# define SSL_SESS_CACHE_BOTH     (SSL_SESS_CACHE_CLIENT|SSL_SESS_CACHE_SERVER)
+# define SSL_SESS_CACHE_NO_AUTO_CLEAR            0x0080
+/* enough comments already ... see SSL_CTX_set_session_cache_mode(3) */
+# define SSL_SESS_CACHE_NO_INTERNAL_LOOKUP       0x0100
+# define SSL_SESS_CACHE_NO_INTERNAL_STORE        0x0200
+# define SSL_SESS_CACHE_NO_INTERNAL \
+        (SSL_SESS_CACHE_NO_INTERNAL_LOOKUP|SSL_SESS_CACHE_NO_INTERNAL_STORE)
+# define SSL_SESS_CACHE_UPDATE_TIME              0x0400
+
+LHASH_OF(SSL_SESSION) *SSL_CTX_sessions(SSL_CTX *ctx);
+# define SSL_CTX_sess_number(ctx) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_NUMBER,0,NULL)
+# define SSL_CTX_sess_connect(ctx) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_CONNECT,0,NULL)
+# define SSL_CTX_sess_connect_good(ctx) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_CONNECT_GOOD,0,NULL)
+# define SSL_CTX_sess_connect_renegotiate(ctx) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_CONNECT_RENEGOTIATE,0,NULL)
+# define SSL_CTX_sess_accept(ctx) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_ACCEPT,0,NULL)
+# define SSL_CTX_sess_accept_renegotiate(ctx) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_ACCEPT_RENEGOTIATE,0,NULL)
+# define SSL_CTX_sess_accept_good(ctx) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_ACCEPT_GOOD,0,NULL)
+# define SSL_CTX_sess_hits(ctx) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_HIT,0,NULL)
+# define SSL_CTX_sess_cb_hits(ctx) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_CB_HIT,0,NULL)
+# define SSL_CTX_sess_misses(ctx) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_MISSES,0,NULL)
+# define SSL_CTX_sess_timeouts(ctx) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_TIMEOUTS,0,NULL)
+# define SSL_CTX_sess_cache_full(ctx) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_CACHE_FULL,0,NULL)
+
+void SSL_CTX_sess_set_new_cb(SSL_CTX *ctx,
+                             int (*new_session_cb) (struct ssl_st *ssl,
+                                                    SSL_SESSION *sess));
+int (*SSL_CTX_sess_get_new_cb(SSL_CTX *ctx)) (struct ssl_st *ssl,
+                                              SSL_SESSION *sess);
+void SSL_CTX_sess_set_remove_cb(SSL_CTX *ctx,
+                                void (*remove_session_cb) (struct ssl_ctx_st
+                                                           *ctx,
+                                                           SSL_SESSION *sess));
+void (*SSL_CTX_sess_get_remove_cb(SSL_CTX *ctx)) (struct ssl_ctx_st *ctx,
+                                                  SSL_SESSION *sess);
+void SSL_CTX_sess_set_get_cb(SSL_CTX *ctx,
+                             SSL_SESSION *(*get_session_cb) (struct ssl_st
+                                                             *ssl,
+                                                             const unsigned char
+                                                             *data, int len,
+                                                             int *copy));
+SSL_SESSION *(*SSL_CTX_sess_get_get_cb(SSL_CTX *ctx)) (struct ssl_st *ssl,
+                                                       const unsigned char *data,
+                                                       int len, int *copy);
+void SSL_CTX_set_info_callback(SSL_CTX *ctx,
+                               void (*cb) (const SSL *ssl, int type, int val));
+void (*SSL_CTX_get_info_callback(SSL_CTX *ctx)) (const SSL *ssl, int type,
+                                                 int val);
+void SSL_CTX_set_client_cert_cb(SSL_CTX *ctx,
+                                int (*client_cert_cb) (SSL *ssl, X509 **x509,
+                                                       EVP_PKEY **pkey));
+int (*SSL_CTX_get_client_cert_cb(SSL_CTX *ctx)) (SSL *ssl, X509 **x509,
+                                                 EVP_PKEY **pkey);
+# ifndef OPENSSL_NO_ENGINE
+__owur int SSL_CTX_set_client_cert_engine(SSL_CTX *ctx, ENGINE *e);
+# endif
+void SSL_CTX_set_cookie_generate_cb(SSL_CTX *ctx,
+                                    int (*app_gen_cookie_cb) (SSL *ssl,
+                                                              unsigned char
+                                                              *cookie,
+                                                              unsigned int
+                                                              *cookie_len));
+void SSL_CTX_set_cookie_verify_cb(SSL_CTX *ctx,
+                                  int (*app_verify_cookie_cb) (SSL *ssl,
+                                                               const unsigned
+                                                               char *cookie,
+                                                               unsigned int
+                                                               cookie_len));
+
+void SSL_CTX_set_stateless_cookie_generate_cb(
+    SSL_CTX *ctx,
+    int (*gen_stateless_cookie_cb) (SSL *ssl,
+                                    unsigned char *cookie,
+                                    size_t *cookie_len));
+void SSL_CTX_set_stateless_cookie_verify_cb(
+    SSL_CTX *ctx,
+    int (*verify_stateless_cookie_cb) (SSL *ssl,
+                                       const unsigned char *cookie,
+                                       size_t cookie_len));
+# ifndef OPENSSL_NO_NEXTPROTONEG
+
+typedef int (*SSL_CTX_npn_advertised_cb_func)(SSL *ssl,
+                                              const unsigned char **out,
+                                              unsigned int *outlen,
+                                              void *arg);
+void SSL_CTX_set_next_protos_advertised_cb(SSL_CTX *s,
+                                           SSL_CTX_npn_advertised_cb_func cb,
+                                           void *arg);
+#  define SSL_CTX_set_npn_advertised_cb SSL_CTX_set_next_protos_advertised_cb
+
+typedef int (*SSL_CTX_npn_select_cb_func)(SSL *s,
+                                          unsigned char **out,
+                                          unsigned char *outlen,
+                                          const unsigned char *in,
+                                          unsigned int inlen,
+                                          void *arg);
+void SSL_CTX_set_next_proto_select_cb(SSL_CTX *s,
+                                      SSL_CTX_npn_select_cb_func cb,
+                                      void *arg);
+#  define SSL_CTX_set_npn_select_cb SSL_CTX_set_next_proto_select_cb
+
+void SSL_get0_next_proto_negotiated(const SSL *s, const unsigned char **data,
+                                    unsigned *len);
+#  define SSL_get0_npn_negotiated SSL_get0_next_proto_negotiated
+# endif
+
+__owur int SSL_select_next_proto(unsigned char **out, unsigned char *outlen,
+                                 const unsigned char *in, unsigned int inlen,
+                                 const unsigned char *client,
+                                 unsigned int client_len);
+
+# define OPENSSL_NPN_UNSUPPORTED 0
+# define OPENSSL_NPN_NEGOTIATED  1
+# define OPENSSL_NPN_NO_OVERLAP  2
+
+__owur int SSL_CTX_set_alpn_protos(SSL_CTX *ctx, const unsigned char *protos,
+                                   unsigned int protos_len);
+__owur int SSL_set_alpn_protos(SSL *ssl, const unsigned char *protos,
+                               unsigned int protos_len);
+typedef int (*SSL_CTX_alpn_select_cb_func)(SSL *ssl,
+                                           const unsigned char **out,
+                                           unsigned char *outlen,
+                                           const unsigned char *in,
+                                           unsigned int inlen,
+                                           void *arg);
+void SSL_CTX_set_alpn_select_cb(SSL_CTX *ctx,
+                                SSL_CTX_alpn_select_cb_func cb,
+                                void *arg);
+void SSL_get0_alpn_selected(const SSL *ssl, const unsigned char **data,
+                            unsigned int *len);
+
+# ifndef OPENSSL_NO_PSK
+/*
+ * the maximum length of the buffer given to callbacks containing the
+ * resulting identity/psk
+ */
+#  define PSK_MAX_IDENTITY_LEN 256
+#  define PSK_MAX_PSK_LEN 512
+typedef unsigned int (*SSL_psk_client_cb_func)(SSL *ssl,
+                                               const char *hint,
+                                               char *identity,
+                                               unsigned int max_identity_len,
+                                               unsigned char *psk,
+                                               unsigned int max_psk_len);
+void SSL_CTX_set_psk_client_callback(SSL_CTX *ctx, SSL_psk_client_cb_func cb);
+void SSL_set_psk_client_callback(SSL *ssl, SSL_psk_client_cb_func cb);
+
+typedef unsigned int (*SSL_psk_server_cb_func)(SSL *ssl,
+                                               const char *identity,
+                                               unsigned char *psk,
+                                               unsigned int max_psk_len);
+void SSL_CTX_set_psk_server_callback(SSL_CTX *ctx, SSL_psk_server_cb_func cb);
+void SSL_set_psk_server_callback(SSL *ssl, SSL_psk_server_cb_func cb);
+
+__owur int SSL_CTX_use_psk_identity_hint(SSL_CTX *ctx, const char *identity_hint);
+__owur int SSL_use_psk_identity_hint(SSL *s, const char *identity_hint);
+const char *SSL_get_psk_identity_hint(const SSL *s);
+const char *SSL_get_psk_identity(const SSL *s);
+# endif
+
+typedef int (*SSL_psk_find_session_cb_func)(SSL *ssl,
+                                            const unsigned char *identity,
+                                            size_t identity_len,
+                                            SSL_SESSION **sess);
+typedef int (*SSL_psk_use_session_cb_func)(SSL *ssl, const EVP_MD *md,
+                                           const unsigned char **id,
+                                           size_t *idlen,
+                                           SSL_SESSION **sess);
+
+void SSL_set_psk_find_session_callback(SSL *s, SSL_psk_find_session_cb_func cb);
+void SSL_CTX_set_psk_find_session_callback(SSL_CTX *ctx,
+                                           SSL_psk_find_session_cb_func cb);
+void SSL_set_psk_use_session_callback(SSL *s, SSL_psk_use_session_cb_func cb);
+void SSL_CTX_set_psk_use_session_callback(SSL_CTX *ctx,
+                                          SSL_psk_use_session_cb_func cb);
+
+/* Register callbacks to handle custom TLS Extensions for client or server. */
+
+__owur int SSL_CTX_has_client_custom_ext(const SSL_CTX *ctx,
+                                         unsigned int ext_type);
+
+__owur int SSL_CTX_add_client_custom_ext(SSL_CTX *ctx,
+                                         unsigned int ext_type,
+                                         custom_ext_add_cb add_cb,
+                                         custom_ext_free_cb free_cb,
+                                         void *add_arg,
+                                         custom_ext_parse_cb parse_cb,
+                                         void *parse_arg);
+
+__owur int SSL_CTX_add_server_custom_ext(SSL_CTX *ctx,
+                                         unsigned int ext_type,
+                                         custom_ext_add_cb add_cb,
+                                         custom_ext_free_cb free_cb,
+                                         void *add_arg,
+                                         custom_ext_parse_cb parse_cb,
+                                         void *parse_arg);
+
+__owur int SSL_CTX_add_custom_ext(SSL_CTX *ctx, unsigned int ext_type,
+                                  unsigned int context,
+                                  SSL_custom_ext_add_cb_ex add_cb,
+                                  SSL_custom_ext_free_cb_ex free_cb,
+                                  void *add_arg,
+                                  SSL_custom_ext_parse_cb_ex parse_cb,
+                                  void *parse_arg);
+
+__owur int SSL_extension_supported(unsigned int ext_type);
+
+# define SSL_NOTHING            1
+# define SSL_WRITING            2
+# define SSL_READING            3
+# define SSL_X509_LOOKUP        4
+# define SSL_ASYNC_PAUSED       5
+# define SSL_ASYNC_NO_JOBS      6
+# define SSL_CLIENT_HELLO_CB    7
+# define SSL_RETRY_VERIFY       8
+
+/* These will only be used when doing non-blocking IO */
+# define SSL_want_nothing(s)         (SSL_want(s) == SSL_NOTHING)
+# define SSL_want_read(s)            (SSL_want(s) == SSL_READING)
+# define SSL_want_write(s)           (SSL_want(s) == SSL_WRITING)
+# define SSL_want_x509_lookup(s)     (SSL_want(s) == SSL_X509_LOOKUP)
+# define SSL_want_retry_verify(s)    (SSL_want(s) == SSL_RETRY_VERIFY)
+# define SSL_want_async(s)           (SSL_want(s) == SSL_ASYNC_PAUSED)
+# define SSL_want_async_job(s)       (SSL_want(s) == SSL_ASYNC_NO_JOBS)
+# define SSL_want_client_hello_cb(s) (SSL_want(s) == SSL_CLIENT_HELLO_CB)
+
+# define SSL_MAC_FLAG_READ_MAC_STREAM 1
+# define SSL_MAC_FLAG_WRITE_MAC_STREAM 2
+# define SSL_MAC_FLAG_READ_MAC_TLSTREE 4
+# define SSL_MAC_FLAG_WRITE_MAC_TLSTREE 8
+
+/*
+ * A callback for logging out TLS key material. This callback should log out
+ * |line| followed by a newline.
+ */
+typedef void (*SSL_CTX_keylog_cb_func)(const SSL *ssl, const char *line);
+
+/*
+ * SSL_CTX_set_keylog_callback configures a callback to log key material. This
+ * is intended for debugging use with tools like Wireshark. The cb function
+ * should log line followed by a newline.
+ */
+void SSL_CTX_set_keylog_callback(SSL_CTX *ctx, SSL_CTX_keylog_cb_func cb);
+
+/*
+ * SSL_CTX_get_keylog_callback returns the callback configured by
+ * SSL_CTX_set_keylog_callback.
+ */
+SSL_CTX_keylog_cb_func SSL_CTX_get_keylog_callback(const SSL_CTX *ctx);
+
+int SSL_CTX_set_max_early_data(SSL_CTX *ctx, uint32_t max_early_data);
+uint32_t SSL_CTX_get_max_early_data(const SSL_CTX *ctx);
+int SSL_set_max_early_data(SSL *s, uint32_t max_early_data);
+uint32_t SSL_get_max_early_data(const SSL *s);
+int SSL_CTX_set_recv_max_early_data(SSL_CTX *ctx, uint32_t recv_max_early_data);
+uint32_t SSL_CTX_get_recv_max_early_data(const SSL_CTX *ctx);
+int SSL_set_recv_max_early_data(SSL *s, uint32_t recv_max_early_data);
+uint32_t SSL_get_recv_max_early_data(const SSL *s);
+
+#ifdef __cplusplus
+}
+#endif
+
+# include <openssl/ssl2.h>
+# include <openssl/ssl3.h>
+# include <openssl/tls1.h>      /* This is mostly sslv3 with a few tweaks */
+# include <openssl/dtls1.h>     /* Datagram TLS */
+# include <openssl/srtp.h>      /* Support for the use_srtp extension */
+# include <openssl/quic.h>
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+/*
+ * These need to be after the above set of includes due to a compiler bug
+ * in VisualStudio 2015
+ */
+SKM_DEFINE_STACK_OF_INTERNAL(SSL_CIPHER, const SSL_CIPHER, SSL_CIPHER)
+#define sk_SSL_CIPHER_num(sk) OPENSSL_sk_num(ossl_check_const_SSL_CIPHER_sk_type(sk))
+#define sk_SSL_CIPHER_value(sk, idx) ((const SSL_CIPHER *)OPENSSL_sk_value(ossl_check_const_SSL_CIPHER_sk_type(sk), (idx)))
+#define sk_SSL_CIPHER_new(cmp) ((STACK_OF(SSL_CIPHER) *)OPENSSL_sk_new(ossl_check_SSL_CIPHER_compfunc_type(cmp)))
+#define sk_SSL_CIPHER_new_null() ((STACK_OF(SSL_CIPHER) *)OPENSSL_sk_new_null())
+#define sk_SSL_CIPHER_new_reserve(cmp, n) ((STACK_OF(SSL_CIPHER) *)OPENSSL_sk_new_reserve(ossl_check_SSL_CIPHER_compfunc_type(cmp), (n)))
+#define sk_SSL_CIPHER_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_SSL_CIPHER_sk_type(sk), (n))
+#define sk_SSL_CIPHER_free(sk) OPENSSL_sk_free(ossl_check_SSL_CIPHER_sk_type(sk))
+#define sk_SSL_CIPHER_zero(sk) OPENSSL_sk_zero(ossl_check_SSL_CIPHER_sk_type(sk))
+#define sk_SSL_CIPHER_delete(sk, i) ((const SSL_CIPHER *)OPENSSL_sk_delete(ossl_check_SSL_CIPHER_sk_type(sk), (i)))
+#define sk_SSL_CIPHER_delete_ptr(sk, ptr) ((const SSL_CIPHER *)OPENSSL_sk_delete_ptr(ossl_check_SSL_CIPHER_sk_type(sk), ossl_check_SSL_CIPHER_type(ptr)))
+#define sk_SSL_CIPHER_push(sk, ptr) OPENSSL_sk_push(ossl_check_SSL_CIPHER_sk_type(sk), ossl_check_SSL_CIPHER_type(ptr))
+#define sk_SSL_CIPHER_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_SSL_CIPHER_sk_type(sk), ossl_check_SSL_CIPHER_type(ptr))
+#define sk_SSL_CIPHER_pop(sk) ((const SSL_CIPHER *)OPENSSL_sk_pop(ossl_check_SSL_CIPHER_sk_type(sk)))
+#define sk_SSL_CIPHER_shift(sk) ((const SSL_CIPHER *)OPENSSL_sk_shift(ossl_check_SSL_CIPHER_sk_type(sk)))
+#define sk_SSL_CIPHER_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_SSL_CIPHER_sk_type(sk),ossl_check_SSL_CIPHER_freefunc_type(freefunc))
+#define sk_SSL_CIPHER_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_SSL_CIPHER_sk_type(sk), ossl_check_SSL_CIPHER_type(ptr), (idx))
+#define sk_SSL_CIPHER_set(sk, idx, ptr) ((const SSL_CIPHER *)OPENSSL_sk_set(ossl_check_SSL_CIPHER_sk_type(sk), (idx), ossl_check_SSL_CIPHER_type(ptr)))
+#define sk_SSL_CIPHER_find(sk, ptr) OPENSSL_sk_find(ossl_check_SSL_CIPHER_sk_type(sk), ossl_check_SSL_CIPHER_type(ptr))
+#define sk_SSL_CIPHER_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_SSL_CIPHER_sk_type(sk), ossl_check_SSL_CIPHER_type(ptr))
+#define sk_SSL_CIPHER_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_SSL_CIPHER_sk_type(sk), ossl_check_SSL_CIPHER_type(ptr), pnum)
+#define sk_SSL_CIPHER_sort(sk) OPENSSL_sk_sort(ossl_check_SSL_CIPHER_sk_type(sk))
+#define sk_SSL_CIPHER_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_SSL_CIPHER_sk_type(sk))
+#define sk_SSL_CIPHER_dup(sk) ((STACK_OF(SSL_CIPHER) *)OPENSSL_sk_dup(ossl_check_const_SSL_CIPHER_sk_type(sk)))
+#define sk_SSL_CIPHER_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(SSL_CIPHER) *)OPENSSL_sk_deep_copy(ossl_check_const_SSL_CIPHER_sk_type(sk), ossl_check_SSL_CIPHER_copyfunc_type(copyfunc), ossl_check_SSL_CIPHER_freefunc_type(freefunc)))
+#define sk_SSL_CIPHER_set_cmp_func(sk, cmp) ((sk_SSL_CIPHER_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_SSL_CIPHER_sk_type(sk), ossl_check_SSL_CIPHER_compfunc_type(cmp)))
+SKM_DEFINE_STACK_OF_INTERNAL(SSL_COMP, SSL_COMP, SSL_COMP)
+#define sk_SSL_COMP_num(sk) OPENSSL_sk_num(ossl_check_const_SSL_COMP_sk_type(sk))
+#define sk_SSL_COMP_value(sk, idx) ((SSL_COMP *)OPENSSL_sk_value(ossl_check_const_SSL_COMP_sk_type(sk), (idx)))
+#define sk_SSL_COMP_new(cmp) ((STACK_OF(SSL_COMP) *)OPENSSL_sk_new(ossl_check_SSL_COMP_compfunc_type(cmp)))
+#define sk_SSL_COMP_new_null() ((STACK_OF(SSL_COMP) *)OPENSSL_sk_new_null())
+#define sk_SSL_COMP_new_reserve(cmp, n) ((STACK_OF(SSL_COMP) *)OPENSSL_sk_new_reserve(ossl_check_SSL_COMP_compfunc_type(cmp), (n)))
+#define sk_SSL_COMP_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_SSL_COMP_sk_type(sk), (n))
+#define sk_SSL_COMP_free(sk) OPENSSL_sk_free(ossl_check_SSL_COMP_sk_type(sk))
+#define sk_SSL_COMP_zero(sk) OPENSSL_sk_zero(ossl_check_SSL_COMP_sk_type(sk))
+#define sk_SSL_COMP_delete(sk, i) ((SSL_COMP *)OPENSSL_sk_delete(ossl_check_SSL_COMP_sk_type(sk), (i)))
+#define sk_SSL_COMP_delete_ptr(sk, ptr) ((SSL_COMP *)OPENSSL_sk_delete_ptr(ossl_check_SSL_COMP_sk_type(sk), ossl_check_SSL_COMP_type(ptr)))
+#define sk_SSL_COMP_push(sk, ptr) OPENSSL_sk_push(ossl_check_SSL_COMP_sk_type(sk), ossl_check_SSL_COMP_type(ptr))
+#define sk_SSL_COMP_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_SSL_COMP_sk_type(sk), ossl_check_SSL_COMP_type(ptr))
+#define sk_SSL_COMP_pop(sk) ((SSL_COMP *)OPENSSL_sk_pop(ossl_check_SSL_COMP_sk_type(sk)))
+#define sk_SSL_COMP_shift(sk) ((SSL_COMP *)OPENSSL_sk_shift(ossl_check_SSL_COMP_sk_type(sk)))
+#define sk_SSL_COMP_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_SSL_COMP_sk_type(sk),ossl_check_SSL_COMP_freefunc_type(freefunc))
+#define sk_SSL_COMP_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_SSL_COMP_sk_type(sk), ossl_check_SSL_COMP_type(ptr), (idx))
+#define sk_SSL_COMP_set(sk, idx, ptr) ((SSL_COMP *)OPENSSL_sk_set(ossl_check_SSL_COMP_sk_type(sk), (idx), ossl_check_SSL_COMP_type(ptr)))
+#define sk_SSL_COMP_find(sk, ptr) OPENSSL_sk_find(ossl_check_SSL_COMP_sk_type(sk), ossl_check_SSL_COMP_type(ptr))
+#define sk_SSL_COMP_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_SSL_COMP_sk_type(sk), ossl_check_SSL_COMP_type(ptr))
+#define sk_SSL_COMP_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_SSL_COMP_sk_type(sk), ossl_check_SSL_COMP_type(ptr), pnum)
+#define sk_SSL_COMP_sort(sk) OPENSSL_sk_sort(ossl_check_SSL_COMP_sk_type(sk))
+#define sk_SSL_COMP_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_SSL_COMP_sk_type(sk))
+#define sk_SSL_COMP_dup(sk) ((STACK_OF(SSL_COMP) *)OPENSSL_sk_dup(ossl_check_const_SSL_COMP_sk_type(sk)))
+#define sk_SSL_COMP_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(SSL_COMP) *)OPENSSL_sk_deep_copy(ossl_check_const_SSL_COMP_sk_type(sk), ossl_check_SSL_COMP_copyfunc_type(copyfunc), ossl_check_SSL_COMP_freefunc_type(freefunc)))
+#define sk_SSL_COMP_set_cmp_func(sk, cmp) ((sk_SSL_COMP_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_SSL_COMP_sk_type(sk), ossl_check_SSL_COMP_compfunc_type(cmp)))
+
+
+/* compatibility */
+# define SSL_set_app_data(s,arg)         (SSL_set_ex_data(s,0,(char *)(arg)))
+# define SSL_get_app_data(s)             (SSL_get_ex_data(s,0))
+# define SSL_SESSION_set_app_data(s,a)   (SSL_SESSION_set_ex_data(s,0, \
+                                                                  (char *)(a)))
+# define SSL_SESSION_get_app_data(s)     (SSL_SESSION_get_ex_data(s,0))
+# define SSL_CTX_get_app_data(ctx)       (SSL_CTX_get_ex_data(ctx,0))
+# define SSL_CTX_set_app_data(ctx,arg)   (SSL_CTX_set_ex_data(ctx,0, \
+                                                              (char *)(arg)))
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+OSSL_DEPRECATEDIN_1_1_0 void SSL_set_debug(SSL *s, int debug);
+# endif
+
+/* TLSv1.3 KeyUpdate message types */
+/* -1 used so that this is an invalid value for the on-the-wire protocol */
+#define SSL_KEY_UPDATE_NONE             -1
+/* Values as defined for the on-the-wire protocol */
+#define SSL_KEY_UPDATE_NOT_REQUESTED     0
+#define SSL_KEY_UPDATE_REQUESTED         1
+
+/*
+ * The valid handshake states (one for each type message sent and one for each
+ * type of message received). There are also two "special" states:
+ * TLS = TLS or DTLS state
+ * DTLS = DTLS specific state
+ * CR/SR = Client Read/Server Read
+ * CW/SW = Client Write/Server Write
+ *
+ * The "special" states are:
+ * TLS_ST_BEFORE = No handshake has been initiated yet
+ * TLS_ST_OK = A handshake has been successfully completed
+ */
+typedef enum {
+    TLS_ST_BEFORE,
+    TLS_ST_OK,
+    DTLS_ST_CR_HELLO_VERIFY_REQUEST,
+    TLS_ST_CR_SRVR_HELLO,
+    TLS_ST_CR_CERT,
+    TLS_ST_CR_COMP_CERT,
+    TLS_ST_CR_CERT_STATUS,
+    TLS_ST_CR_KEY_EXCH,
+    TLS_ST_CR_CERT_REQ,
+    TLS_ST_CR_SRVR_DONE,
+    TLS_ST_CR_SESSION_TICKET,
+    TLS_ST_CR_CHANGE,
+    TLS_ST_CR_FINISHED,
+    TLS_ST_CW_CLNT_HELLO,
+    TLS_ST_CW_CERT,
+    TLS_ST_CW_COMP_CERT,
+    TLS_ST_CW_KEY_EXCH,
+    TLS_ST_CW_CERT_VRFY,
+    TLS_ST_CW_CHANGE,
+    TLS_ST_CW_NEXT_PROTO,
+    TLS_ST_CW_FINISHED,
+    TLS_ST_SW_HELLO_REQ,
+    TLS_ST_SR_CLNT_HELLO,
+    DTLS_ST_SW_HELLO_VERIFY_REQUEST,
+    TLS_ST_SW_SRVR_HELLO,
+    TLS_ST_SW_CERT,
+    TLS_ST_SW_COMP_CERT,
+    TLS_ST_SW_KEY_EXCH,
+    TLS_ST_SW_CERT_REQ,
+    TLS_ST_SW_SRVR_DONE,
+    TLS_ST_SR_CERT,
+    TLS_ST_SR_COMP_CERT,
+    TLS_ST_SR_KEY_EXCH,
+    TLS_ST_SR_CERT_VRFY,
+    TLS_ST_SR_NEXT_PROTO,
+    TLS_ST_SR_CHANGE,
+    TLS_ST_SR_FINISHED,
+    TLS_ST_SW_SESSION_TICKET,
+    TLS_ST_SW_CERT_STATUS,
+    TLS_ST_SW_CHANGE,
+    TLS_ST_SW_FINISHED,
+    TLS_ST_SW_ENCRYPTED_EXTENSIONS,
+    TLS_ST_CR_ENCRYPTED_EXTENSIONS,
+    TLS_ST_CR_CERT_VRFY,
+    TLS_ST_SW_CERT_VRFY,
+    TLS_ST_CR_HELLO_REQ,
+    TLS_ST_SW_KEY_UPDATE,
+    TLS_ST_CW_KEY_UPDATE,
+    TLS_ST_SR_KEY_UPDATE,
+    TLS_ST_CR_KEY_UPDATE,
+    TLS_ST_EARLY_DATA,
+    TLS_ST_PENDING_EARLY_DATA_END,
+    TLS_ST_CW_END_OF_EARLY_DATA,
+    TLS_ST_SR_END_OF_EARLY_DATA
+} OSSL_HANDSHAKE_STATE;
+
+/*
+ * Most of the following state values are no longer used and are defined to be
+ * the closest equivalent value in the current state machine code. Not all
+ * defines have an equivalent and are set to a dummy value (-1). SSL_ST_CONNECT
+ * and SSL_ST_ACCEPT are still in use in the definition of SSL_CB_ACCEPT_LOOP,
+ * SSL_CB_ACCEPT_EXIT, SSL_CB_CONNECT_LOOP and SSL_CB_CONNECT_EXIT.
+ */
+
+# define SSL_ST_CONNECT                  0x1000
+# define SSL_ST_ACCEPT                   0x2000
+
+# define SSL_ST_MASK                     0x0FFF
+
+# define SSL_CB_LOOP                     0x01
+# define SSL_CB_EXIT                     0x02
+# define SSL_CB_READ                     0x04
+# define SSL_CB_WRITE                    0x08
+# define SSL_CB_ALERT                    0x4000/* used in callback */
+# define SSL_CB_READ_ALERT               (SSL_CB_ALERT|SSL_CB_READ)
+# define SSL_CB_WRITE_ALERT              (SSL_CB_ALERT|SSL_CB_WRITE)
+# define SSL_CB_ACCEPT_LOOP              (SSL_ST_ACCEPT|SSL_CB_LOOP)
+# define SSL_CB_ACCEPT_EXIT              (SSL_ST_ACCEPT|SSL_CB_EXIT)
+# define SSL_CB_CONNECT_LOOP             (SSL_ST_CONNECT|SSL_CB_LOOP)
+# define SSL_CB_CONNECT_EXIT             (SSL_ST_CONNECT|SSL_CB_EXIT)
+# define SSL_CB_HANDSHAKE_START          0x10
+# define SSL_CB_HANDSHAKE_DONE           0x20
+
+/* Is the SSL_connection established? */
+# define SSL_in_connect_init(a)          (SSL_in_init(a) && !SSL_is_server(a))
+# define SSL_in_accept_init(a)           (SSL_in_init(a) && SSL_is_server(a))
+int SSL_in_init(const SSL *s);
+int SSL_in_before(const SSL *s);
+int SSL_is_init_finished(const SSL *s);
+
+/*
+ * The following 3 states are kept in ssl->rlayer.rstate when reads fail, you
+ * should not need these
+ */
+# define SSL_ST_READ_HEADER                      0xF0
+# define SSL_ST_READ_BODY                        0xF1
+# define SSL_ST_READ_DONE                        0xF2
+
+/*-
+ * Obtain latest Finished message
+ *   -- that we sent (SSL_get_finished)
+ *   -- that we expected from peer (SSL_get_peer_finished).
+ * Returns length (0 == no Finished so far), copies up to 'count' bytes.
+ */
+size_t SSL_get_finished(const SSL *s, void *buf, size_t count);
+size_t SSL_get_peer_finished(const SSL *s, void *buf, size_t count);
+
+/*
+ * use either SSL_VERIFY_NONE or SSL_VERIFY_PEER, the last 3 options are
+ * 'ored' with SSL_VERIFY_PEER if they are desired
+ */
+# define SSL_VERIFY_NONE                 0x00
+# define SSL_VERIFY_PEER                 0x01
+# define SSL_VERIFY_FAIL_IF_NO_PEER_CERT 0x02
+# define SSL_VERIFY_CLIENT_ONCE          0x04
+# define SSL_VERIFY_POST_HANDSHAKE       0x08
+
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#  define OpenSSL_add_ssl_algorithms()   SSL_library_init()
+#  define SSLeay_add_ssl_algorithms()    SSL_library_init()
+# endif
+
+/* More backward compatibility */
+# define SSL_get_cipher(s) \
+                SSL_CIPHER_get_name(SSL_get_current_cipher(s))
+# define SSL_get_cipher_bits(s,np) \
+                SSL_CIPHER_get_bits(SSL_get_current_cipher(s),np)
+# define SSL_get_cipher_version(s) \
+                SSL_CIPHER_get_version(SSL_get_current_cipher(s))
+# define SSL_get_cipher_name(s) \
+                SSL_CIPHER_get_name(SSL_get_current_cipher(s))
+# define SSL_get_time(a)         SSL_SESSION_get_time(a)
+# define SSL_set_time(a,b)       SSL_SESSION_set_time((a),(b))
+# define SSL_get_timeout(a)      SSL_SESSION_get_timeout(a)
+# define SSL_set_timeout(a,b)    SSL_SESSION_set_timeout((a),(b))
+
+# define d2i_SSL_SESSION_bio(bp,s_id) ASN1_d2i_bio_of(SSL_SESSION,SSL_SESSION_new,d2i_SSL_SESSION,bp,s_id)
+# define i2d_SSL_SESSION_bio(bp,s_id) ASN1_i2d_bio_of(SSL_SESSION,i2d_SSL_SESSION,bp,s_id)
+
+DECLARE_PEM_rw(SSL_SESSION, SSL_SESSION)
+# define SSL_AD_REASON_OFFSET            1000/* offset to get SSL_R_... value
+                                              * from SSL_AD_... */
+/* These alert types are for SSLv3 and TLSv1 */
+# define SSL_AD_CLOSE_NOTIFY             SSL3_AD_CLOSE_NOTIFY
+/* fatal */
+# define SSL_AD_UNEXPECTED_MESSAGE       SSL3_AD_UNEXPECTED_MESSAGE
+/* fatal */
+# define SSL_AD_BAD_RECORD_MAC           SSL3_AD_BAD_RECORD_MAC
+# define SSL_AD_DECRYPTION_FAILED        TLS1_AD_DECRYPTION_FAILED
+# define SSL_AD_RECORD_OVERFLOW          TLS1_AD_RECORD_OVERFLOW
+/* fatal */
+# define SSL_AD_DECOMPRESSION_FAILURE    SSL3_AD_DECOMPRESSION_FAILURE
+/* fatal */
+# define SSL_AD_HANDSHAKE_FAILURE        SSL3_AD_HANDSHAKE_FAILURE
+/* Not for TLS */
+# define SSL_AD_NO_CERTIFICATE           SSL3_AD_NO_CERTIFICATE
+# define SSL_AD_BAD_CERTIFICATE          SSL3_AD_BAD_CERTIFICATE
+# define SSL_AD_UNSUPPORTED_CERTIFICATE  SSL3_AD_UNSUPPORTED_CERTIFICATE
+# define SSL_AD_CERTIFICATE_REVOKED      SSL3_AD_CERTIFICATE_REVOKED
+# define SSL_AD_CERTIFICATE_EXPIRED      SSL3_AD_CERTIFICATE_EXPIRED
+# define SSL_AD_CERTIFICATE_UNKNOWN      SSL3_AD_CERTIFICATE_UNKNOWN
+/* fatal */
+# define SSL_AD_ILLEGAL_PARAMETER        SSL3_AD_ILLEGAL_PARAMETER
+/* fatal */
+# define SSL_AD_UNKNOWN_CA               TLS1_AD_UNKNOWN_CA
+/* fatal */
+# define SSL_AD_ACCESS_DENIED            TLS1_AD_ACCESS_DENIED
+/* fatal */
+# define SSL_AD_DECODE_ERROR             TLS1_AD_DECODE_ERROR
+# define SSL_AD_DECRYPT_ERROR            TLS1_AD_DECRYPT_ERROR
+/* fatal */
+# define SSL_AD_EXPORT_RESTRICTION       TLS1_AD_EXPORT_RESTRICTION
+/* fatal */
+# define SSL_AD_PROTOCOL_VERSION         TLS1_AD_PROTOCOL_VERSION
+/* fatal */
+# define SSL_AD_INSUFFICIENT_SECURITY    TLS1_AD_INSUFFICIENT_SECURITY
+/* fatal */
+# define SSL_AD_INTERNAL_ERROR           TLS1_AD_INTERNAL_ERROR
+# define SSL_AD_USER_CANCELLED           TLS1_AD_USER_CANCELLED
+# define SSL_AD_NO_RENEGOTIATION         TLS1_AD_NO_RENEGOTIATION
+# define SSL_AD_MISSING_EXTENSION        TLS13_AD_MISSING_EXTENSION
+# define SSL_AD_CERTIFICATE_REQUIRED     TLS13_AD_CERTIFICATE_REQUIRED
+# define SSL_AD_UNSUPPORTED_EXTENSION    TLS1_AD_UNSUPPORTED_EXTENSION
+# define SSL_AD_CERTIFICATE_UNOBTAINABLE TLS1_AD_CERTIFICATE_UNOBTAINABLE
+# define SSL_AD_UNRECOGNIZED_NAME        TLS1_AD_UNRECOGNIZED_NAME
+# define SSL_AD_BAD_CERTIFICATE_STATUS_RESPONSE TLS1_AD_BAD_CERTIFICATE_STATUS_RESPONSE
+# define SSL_AD_BAD_CERTIFICATE_HASH_VALUE TLS1_AD_BAD_CERTIFICATE_HASH_VALUE
+/* fatal */
+# define SSL_AD_UNKNOWN_PSK_IDENTITY     TLS1_AD_UNKNOWN_PSK_IDENTITY
+/* fatal */
+# define SSL_AD_INAPPROPRIATE_FALLBACK   TLS1_AD_INAPPROPRIATE_FALLBACK
+# define SSL_AD_NO_APPLICATION_PROTOCOL  TLS1_AD_NO_APPLICATION_PROTOCOL
+# define SSL_ERROR_NONE                  0
+# define SSL_ERROR_SSL                   1
+# define SSL_ERROR_WANT_READ             2
+# define SSL_ERROR_WANT_WRITE            3
+# define SSL_ERROR_WANT_X509_LOOKUP      4
+# define SSL_ERROR_SYSCALL               5/* look at error stack/return
+                                           * value/errno */
+# define SSL_ERROR_ZERO_RETURN           6
+# define SSL_ERROR_WANT_CONNECT          7
+# define SSL_ERROR_WANT_ACCEPT           8
+# define SSL_ERROR_WANT_ASYNC            9
+# define SSL_ERROR_WANT_ASYNC_JOB       10
+# define SSL_ERROR_WANT_CLIENT_HELLO_CB 11
+# define SSL_ERROR_WANT_RETRY_VERIFY    12
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define SSL_CTRL_SET_TMP_DH                    3
+#  define SSL_CTRL_SET_TMP_ECDH                  4
+#  define SSL_CTRL_SET_TMP_DH_CB                 6
+# endif
+
+# define SSL_CTRL_GET_CLIENT_CERT_REQUEST        9
+# define SSL_CTRL_GET_NUM_RENEGOTIATIONS         10
+# define SSL_CTRL_CLEAR_NUM_RENEGOTIATIONS       11
+# define SSL_CTRL_GET_TOTAL_RENEGOTIATIONS       12
+# define SSL_CTRL_GET_FLAGS                      13
+# define SSL_CTRL_EXTRA_CHAIN_CERT               14
+# define SSL_CTRL_SET_MSG_CALLBACK               15
+# define SSL_CTRL_SET_MSG_CALLBACK_ARG           16
+/* only applies to datagram connections */
+# define SSL_CTRL_SET_MTU                17
+/* Stats */
+# define SSL_CTRL_SESS_NUMBER                    20
+# define SSL_CTRL_SESS_CONNECT                   21
+# define SSL_CTRL_SESS_CONNECT_GOOD              22
+# define SSL_CTRL_SESS_CONNECT_RENEGOTIATE       23
+# define SSL_CTRL_SESS_ACCEPT                    24
+# define SSL_CTRL_SESS_ACCEPT_GOOD               25
+# define SSL_CTRL_SESS_ACCEPT_RENEGOTIATE        26
+# define SSL_CTRL_SESS_HIT                       27
+# define SSL_CTRL_SESS_CB_HIT                    28
+# define SSL_CTRL_SESS_MISSES                    29
+# define SSL_CTRL_SESS_TIMEOUTS                  30
+# define SSL_CTRL_SESS_CACHE_FULL                31
+# define SSL_CTRL_MODE                           33
+# define SSL_CTRL_GET_READ_AHEAD                 40
+# define SSL_CTRL_SET_READ_AHEAD                 41
+# define SSL_CTRL_SET_SESS_CACHE_SIZE            42
+# define SSL_CTRL_GET_SESS_CACHE_SIZE            43
+# define SSL_CTRL_SET_SESS_CACHE_MODE            44
+# define SSL_CTRL_GET_SESS_CACHE_MODE            45
+# define SSL_CTRL_GET_MAX_CERT_LIST              50
+# define SSL_CTRL_SET_MAX_CERT_LIST              51
+# define SSL_CTRL_SET_MAX_SEND_FRAGMENT          52
+/* see tls1.h for macros based on these */
+# define SSL_CTRL_SET_TLSEXT_SERVERNAME_CB       53
+# define SSL_CTRL_SET_TLSEXT_SERVERNAME_ARG      54
+# define SSL_CTRL_SET_TLSEXT_HOSTNAME            55
+# define SSL_CTRL_SET_TLSEXT_DEBUG_CB            56
+# define SSL_CTRL_SET_TLSEXT_DEBUG_ARG           57
+# define SSL_CTRL_GET_TLSEXT_TICKET_KEYS         58
+# define SSL_CTRL_SET_TLSEXT_TICKET_KEYS         59
+/*# define SSL_CTRL_SET_TLSEXT_OPAQUE_PRF_INPUT    60 */
+/*# define SSL_CTRL_SET_TLSEXT_OPAQUE_PRF_INPUT_CB 61 */
+/*# define SSL_CTRL_SET_TLSEXT_OPAQUE_PRF_INPUT_CB_ARG 62 */
+# define SSL_CTRL_SET_TLSEXT_STATUS_REQ_CB       63
+# define SSL_CTRL_SET_TLSEXT_STATUS_REQ_CB_ARG   64
+# define SSL_CTRL_SET_TLSEXT_STATUS_REQ_TYPE     65
+# define SSL_CTRL_GET_TLSEXT_STATUS_REQ_EXTS     66
+# define SSL_CTRL_SET_TLSEXT_STATUS_REQ_EXTS     67
+# define SSL_CTRL_GET_TLSEXT_STATUS_REQ_IDS      68
+# define SSL_CTRL_SET_TLSEXT_STATUS_REQ_IDS      69
+# define SSL_CTRL_GET_TLSEXT_STATUS_REQ_OCSP_RESP        70
+# define SSL_CTRL_SET_TLSEXT_STATUS_REQ_OCSP_RESP        71
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define SSL_CTRL_SET_TLSEXT_TICKET_KEY_CB      72
+# endif
+# define SSL_CTRL_SET_TLS_EXT_SRP_USERNAME_CB    75
+# define SSL_CTRL_SET_SRP_VERIFY_PARAM_CB                76
+# define SSL_CTRL_SET_SRP_GIVE_CLIENT_PWD_CB             77
+# define SSL_CTRL_SET_SRP_ARG            78
+# define SSL_CTRL_SET_TLS_EXT_SRP_USERNAME               79
+# define SSL_CTRL_SET_TLS_EXT_SRP_STRENGTH               80
+# define SSL_CTRL_SET_TLS_EXT_SRP_PASSWORD               81
+# define DTLS_CTRL_GET_TIMEOUT           73
+# define DTLS_CTRL_HANDLE_TIMEOUT        74
+# define SSL_CTRL_GET_RI_SUPPORT                 76
+# define SSL_CTRL_CLEAR_MODE                     78
+# define SSL_CTRL_SET_NOT_RESUMABLE_SESS_CB      79
+# define SSL_CTRL_GET_EXTRA_CHAIN_CERTS          82
+# define SSL_CTRL_CLEAR_EXTRA_CHAIN_CERTS        83
+# define SSL_CTRL_CHAIN                          88
+# define SSL_CTRL_CHAIN_CERT                     89
+# define SSL_CTRL_GET_GROUPS                     90
+# define SSL_CTRL_SET_GROUPS                     91
+# define SSL_CTRL_SET_GROUPS_LIST                92
+# define SSL_CTRL_GET_SHARED_GROUP               93
+# define SSL_CTRL_SET_SIGALGS                    97
+# define SSL_CTRL_SET_SIGALGS_LIST               98
+# define SSL_CTRL_CERT_FLAGS                     99
+# define SSL_CTRL_CLEAR_CERT_FLAGS               100
+# define SSL_CTRL_SET_CLIENT_SIGALGS             101
+# define SSL_CTRL_SET_CLIENT_SIGALGS_LIST        102
+# define SSL_CTRL_GET_CLIENT_CERT_TYPES          103
+# define SSL_CTRL_SET_CLIENT_CERT_TYPES          104
+# define SSL_CTRL_BUILD_CERT_CHAIN               105
+# define SSL_CTRL_SET_VERIFY_CERT_STORE          106
+# define SSL_CTRL_SET_CHAIN_CERT_STORE           107
+# define SSL_CTRL_GET_PEER_SIGNATURE_NID         108
+# define SSL_CTRL_GET_PEER_TMP_KEY               109
+# define SSL_CTRL_GET_RAW_CIPHERLIST             110
+# define SSL_CTRL_GET_EC_POINT_FORMATS           111
+# define SSL_CTRL_GET_CHAIN_CERTS                115
+# define SSL_CTRL_SELECT_CURRENT_CERT            116
+# define SSL_CTRL_SET_CURRENT_CERT               117
+# define SSL_CTRL_SET_DH_AUTO                    118
+# define DTLS_CTRL_SET_LINK_MTU                  120
+# define DTLS_CTRL_GET_LINK_MIN_MTU              121
+# define SSL_CTRL_GET_EXTMS_SUPPORT              122
+# define SSL_CTRL_SET_MIN_PROTO_VERSION          123
+# define SSL_CTRL_SET_MAX_PROTO_VERSION          124
+# define SSL_CTRL_SET_SPLIT_SEND_FRAGMENT        125
+# define SSL_CTRL_SET_MAX_PIPELINES              126
+# define SSL_CTRL_GET_TLSEXT_STATUS_REQ_TYPE     127
+# define SSL_CTRL_GET_TLSEXT_STATUS_REQ_CB       128
+# define SSL_CTRL_GET_TLSEXT_STATUS_REQ_CB_ARG   129
+# define SSL_CTRL_GET_MIN_PROTO_VERSION          130
+# define SSL_CTRL_GET_MAX_PROTO_VERSION          131
+# define SSL_CTRL_GET_SIGNATURE_NID              132
+# define SSL_CTRL_GET_TMP_KEY                    133
+# define SSL_CTRL_GET_NEGOTIATED_GROUP           134
+# define SSL_CTRL_GET_IANA_GROUPS                135
+# define SSL_CTRL_SET_RETRY_VERIFY               136
+# define SSL_CTRL_GET_VERIFY_CERT_STORE          137
+# define SSL_CTRL_GET_CHAIN_CERT_STORE           138
+# define SSL_CERT_SET_FIRST                      1
+# define SSL_CERT_SET_NEXT                       2
+# define SSL_CERT_SET_SERVER                     3
+# define DTLSv1_get_timeout(ssl, arg) \
+        SSL_ctrl(ssl,DTLS_CTRL_GET_TIMEOUT,0, (void *)(arg))
+# define DTLSv1_handle_timeout(ssl) \
+        SSL_ctrl(ssl,DTLS_CTRL_HANDLE_TIMEOUT,0, NULL)
+# define SSL_num_renegotiations(ssl) \
+        SSL_ctrl((ssl),SSL_CTRL_GET_NUM_RENEGOTIATIONS,0,NULL)
+# define SSL_clear_num_renegotiations(ssl) \
+        SSL_ctrl((ssl),SSL_CTRL_CLEAR_NUM_RENEGOTIATIONS,0,NULL)
+# define SSL_total_renegotiations(ssl) \
+        SSL_ctrl((ssl),SSL_CTRL_GET_TOTAL_RENEGOTIATIONS,0,NULL)
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define SSL_CTX_set_tmp_dh(ctx,dh) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_TMP_DH,0,(char *)(dh))
+# endif
+# define SSL_CTX_set_dh_auto(ctx, onoff) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_DH_AUTO,onoff,NULL)
+# define SSL_set_dh_auto(s, onoff) \
+        SSL_ctrl(s,SSL_CTRL_SET_DH_AUTO,onoff,NULL)
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define SSL_set_tmp_dh(ssl,dh) \
+        SSL_ctrl(ssl,SSL_CTRL_SET_TMP_DH,0,(char *)(dh))
+# endif
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define SSL_CTX_set_tmp_ecdh(ctx,ecdh) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_TMP_ECDH,0,(char *)(ecdh))
+#  define SSL_set_tmp_ecdh(ssl,ecdh) \
+        SSL_ctrl(ssl,SSL_CTRL_SET_TMP_ECDH,0,(char *)(ecdh))
+# endif
+# define SSL_CTX_add_extra_chain_cert(ctx,x509) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_EXTRA_CHAIN_CERT,0,(char *)(x509))
+# define SSL_CTX_get_extra_chain_certs(ctx,px509) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_GET_EXTRA_CHAIN_CERTS,0,px509)
+# define SSL_CTX_get_extra_chain_certs_only(ctx,px509) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_GET_EXTRA_CHAIN_CERTS,1,px509)
+# define SSL_CTX_clear_extra_chain_certs(ctx) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_CLEAR_EXTRA_CHAIN_CERTS,0,NULL)
+# define SSL_CTX_set0_chain(ctx,sk) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_CHAIN,0,(char *)(sk))
+# define SSL_CTX_set1_chain(ctx,sk) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_CHAIN,1,(char *)(sk))
+# define SSL_CTX_add0_chain_cert(ctx,x509) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_CHAIN_CERT,0,(char *)(x509))
+# define SSL_CTX_add1_chain_cert(ctx,x509) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_CHAIN_CERT,1,(char *)(x509))
+# define SSL_CTX_get0_chain_certs(ctx,px509) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_GET_CHAIN_CERTS,0,px509)
+# define SSL_CTX_clear_chain_certs(ctx) \
+        SSL_CTX_set0_chain(ctx,NULL)
+# define SSL_CTX_build_cert_chain(ctx, flags) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_BUILD_CERT_CHAIN, flags, NULL)
+# define SSL_CTX_select_current_cert(ctx,x509) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SELECT_CURRENT_CERT,0,(char *)(x509))
+# define SSL_CTX_set_current_cert(ctx, op) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_CURRENT_CERT, op, NULL)
+# define SSL_CTX_set0_verify_cert_store(ctx,st) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_VERIFY_CERT_STORE,0,(char *)(st))
+# define SSL_CTX_set1_verify_cert_store(ctx,st) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_VERIFY_CERT_STORE,1,(char *)(st))
+# define SSL_CTX_get0_verify_cert_store(ctx,st) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_GET_VERIFY_CERT_STORE,0,(char *)(st))
+# define SSL_CTX_set0_chain_cert_store(ctx,st) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_CHAIN_CERT_STORE,0,(char *)(st))
+# define SSL_CTX_set1_chain_cert_store(ctx,st) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_CHAIN_CERT_STORE,1,(char *)(st))
+# define SSL_CTX_get0_chain_cert_store(ctx,st) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_GET_CHAIN_CERT_STORE,0,(char *)(st))
+# define SSL_set0_chain(s,sk) \
+        SSL_ctrl(s,SSL_CTRL_CHAIN,0,(char *)(sk))
+# define SSL_set1_chain(s,sk) \
+        SSL_ctrl(s,SSL_CTRL_CHAIN,1,(char *)(sk))
+# define SSL_add0_chain_cert(s,x509) \
+        SSL_ctrl(s,SSL_CTRL_CHAIN_CERT,0,(char *)(x509))
+# define SSL_add1_chain_cert(s,x509) \
+        SSL_ctrl(s,SSL_CTRL_CHAIN_CERT,1,(char *)(x509))
+# define SSL_get0_chain_certs(s,px509) \
+        SSL_ctrl(s,SSL_CTRL_GET_CHAIN_CERTS,0,px509)
+# define SSL_clear_chain_certs(s) \
+        SSL_set0_chain(s,NULL)
+# define SSL_build_cert_chain(s, flags) \
+        SSL_ctrl(s,SSL_CTRL_BUILD_CERT_CHAIN, flags, NULL)
+# define SSL_select_current_cert(s,x509) \
+        SSL_ctrl(s,SSL_CTRL_SELECT_CURRENT_CERT,0,(char *)(x509))
+# define SSL_set_current_cert(s,op) \
+        SSL_ctrl(s,SSL_CTRL_SET_CURRENT_CERT, op, NULL)
+# define SSL_set0_verify_cert_store(s,st) \
+        SSL_ctrl(s,SSL_CTRL_SET_VERIFY_CERT_STORE,0,(char *)(st))
+# define SSL_set1_verify_cert_store(s,st) \
+        SSL_ctrl(s,SSL_CTRL_SET_VERIFY_CERT_STORE,1,(char *)(st))
+#define SSL_get0_verify_cert_store(s,st) \
+        SSL_ctrl(s,SSL_CTRL_GET_VERIFY_CERT_STORE,0,(char *)(st))
+# define SSL_set0_chain_cert_store(s,st) \
+        SSL_ctrl(s,SSL_CTRL_SET_CHAIN_CERT_STORE,0,(char *)(st))
+# define SSL_set1_chain_cert_store(s,st) \
+        SSL_ctrl(s,SSL_CTRL_SET_CHAIN_CERT_STORE,1,(char *)(st))
+#define SSL_get0_chain_cert_store(s,st) \
+        SSL_ctrl(s,SSL_CTRL_GET_CHAIN_CERT_STORE,0,(char *)(st))
+
+# define SSL_get1_groups(s, glist) \
+        SSL_ctrl(s,SSL_CTRL_GET_GROUPS,0,(int*)(glist))
+# define SSL_get0_iana_groups(s, plst) \
+        SSL_ctrl(s,SSL_CTRL_GET_IANA_GROUPS,0,(uint16_t **)(plst))
+# define SSL_CTX_set1_groups(ctx, glist, glistlen) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_GROUPS,glistlen,(int *)(glist))
+# define SSL_CTX_set1_groups_list(ctx, s) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_GROUPS_LIST,0,(char *)(s))
+# define SSL_set1_groups(s, glist, glistlen) \
+        SSL_ctrl(s,SSL_CTRL_SET_GROUPS,glistlen,(char *)(glist))
+# define SSL_set1_groups_list(s, str) \
+        SSL_ctrl(s,SSL_CTRL_SET_GROUPS_LIST,0,(char *)(str))
+# define SSL_get_shared_group(s, n) \
+        SSL_ctrl(s,SSL_CTRL_GET_SHARED_GROUP,n,NULL)
+# define SSL_get_negotiated_group(s) \
+        SSL_ctrl(s,SSL_CTRL_GET_NEGOTIATED_GROUP,0,NULL)
+# define SSL_CTX_set1_sigalgs(ctx, slist, slistlen) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_SIGALGS,slistlen,(int *)(slist))
+# define SSL_CTX_set1_sigalgs_list(ctx, s) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_SIGALGS_LIST,0,(char *)(s))
+# define SSL_set1_sigalgs(s, slist, slistlen) \
+        SSL_ctrl(s,SSL_CTRL_SET_SIGALGS,slistlen,(int *)(slist))
+# define SSL_set1_sigalgs_list(s, str) \
+        SSL_ctrl(s,SSL_CTRL_SET_SIGALGS_LIST,0,(char *)(str))
+# define SSL_CTX_set1_client_sigalgs(ctx, slist, slistlen) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_CLIENT_SIGALGS,slistlen,(int *)(slist))
+# define SSL_CTX_set1_client_sigalgs_list(ctx, s) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_CLIENT_SIGALGS_LIST,0,(char *)(s))
+# define SSL_set1_client_sigalgs(s, slist, slistlen) \
+        SSL_ctrl(s,SSL_CTRL_SET_CLIENT_SIGALGS,slistlen,(int *)(slist))
+# define SSL_set1_client_sigalgs_list(s, str) \
+        SSL_ctrl(s,SSL_CTRL_SET_CLIENT_SIGALGS_LIST,0,(char *)(str))
+# define SSL_get0_certificate_types(s, clist) \
+        SSL_ctrl(s, SSL_CTRL_GET_CLIENT_CERT_TYPES, 0, (char *)(clist))
+# define SSL_CTX_set1_client_certificate_types(ctx, clist, clistlen) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_CLIENT_CERT_TYPES,clistlen, \
+                     (char *)(clist))
+# define SSL_set1_client_certificate_types(s, clist, clistlen) \
+        SSL_ctrl(s,SSL_CTRL_SET_CLIENT_CERT_TYPES,clistlen,(char *)(clist))
+# define SSL_get_signature_nid(s, pn) \
+        SSL_ctrl(s,SSL_CTRL_GET_SIGNATURE_NID,0,pn)
+# define SSL_get_peer_signature_nid(s, pn) \
+        SSL_ctrl(s,SSL_CTRL_GET_PEER_SIGNATURE_NID,0,pn)
+# define SSL_get_peer_tmp_key(s, pk) \
+        SSL_ctrl(s,SSL_CTRL_GET_PEER_TMP_KEY,0,pk)
+# define SSL_get_tmp_key(s, pk) \
+        SSL_ctrl(s,SSL_CTRL_GET_TMP_KEY,0,pk)
+# define SSL_get0_raw_cipherlist(s, plst) \
+        SSL_ctrl(s,SSL_CTRL_GET_RAW_CIPHERLIST,0,plst)
+# define SSL_get0_ec_point_formats(s, plst) \
+        SSL_ctrl(s,SSL_CTRL_GET_EC_POINT_FORMATS,0,plst)
+# define SSL_CTX_set_min_proto_version(ctx, version) \
+        SSL_CTX_ctrl(ctx, SSL_CTRL_SET_MIN_PROTO_VERSION, version, NULL)
+# define SSL_CTX_set_max_proto_version(ctx, version) \
+        SSL_CTX_ctrl(ctx, SSL_CTRL_SET_MAX_PROTO_VERSION, version, NULL)
+# define SSL_CTX_get_min_proto_version(ctx) \
+        SSL_CTX_ctrl(ctx, SSL_CTRL_GET_MIN_PROTO_VERSION, 0, NULL)
+# define SSL_CTX_get_max_proto_version(ctx) \
+        SSL_CTX_ctrl(ctx, SSL_CTRL_GET_MAX_PROTO_VERSION, 0, NULL)
+# define SSL_set_min_proto_version(s, version) \
+        SSL_ctrl(s, SSL_CTRL_SET_MIN_PROTO_VERSION, version, NULL)
+# define SSL_set_max_proto_version(s, version) \
+        SSL_ctrl(s, SSL_CTRL_SET_MAX_PROTO_VERSION, version, NULL)
+# define SSL_get_min_proto_version(s) \
+        SSL_ctrl(s, SSL_CTRL_GET_MIN_PROTO_VERSION, 0, NULL)
+# define SSL_get_max_proto_version(s) \
+        SSL_ctrl(s, SSL_CTRL_GET_MAX_PROTO_VERSION, 0, NULL)
+
+const char *SSL_get0_group_name(SSL *s);
+const char *SSL_group_to_name(SSL *s, int id);
+
+/* Backwards compatibility, original 1.1.0 names */
+# define SSL_CTRL_GET_SERVER_TMP_KEY \
+         SSL_CTRL_GET_PEER_TMP_KEY
+# define SSL_get_server_tmp_key(s, pk) \
+         SSL_get_peer_tmp_key(s, pk)
+
+int SSL_set0_tmp_dh_pkey(SSL *s, EVP_PKEY *dhpkey);
+int SSL_CTX_set0_tmp_dh_pkey(SSL_CTX *ctx, EVP_PKEY *dhpkey);
+
+/*
+ * The following symbol names are old and obsolete. They are kept
+ * for compatibility reasons only and should not be used anymore.
+ */
+# define SSL_CTRL_GET_CURVES           SSL_CTRL_GET_GROUPS
+# define SSL_CTRL_SET_CURVES           SSL_CTRL_SET_GROUPS
+# define SSL_CTRL_SET_CURVES_LIST      SSL_CTRL_SET_GROUPS_LIST
+# define SSL_CTRL_GET_SHARED_CURVE     SSL_CTRL_GET_SHARED_GROUP
+
+# define SSL_get1_curves               SSL_get1_groups
+# define SSL_CTX_set1_curves           SSL_CTX_set1_groups
+# define SSL_CTX_set1_curves_list      SSL_CTX_set1_groups_list
+# define SSL_set1_curves               SSL_set1_groups
+# define SSL_set1_curves_list          SSL_set1_groups_list
+# define SSL_get_shared_curve          SSL_get_shared_group
+
+
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+/* Provide some compatibility macros for removed functionality. */
+#  define SSL_CTX_need_tmp_RSA(ctx)                0
+#  define SSL_CTX_set_tmp_rsa(ctx,rsa)             1
+#  define SSL_need_tmp_RSA(ssl)                    0
+#  define SSL_set_tmp_rsa(ssl,rsa)                 1
+#  define SSL_CTX_set_ecdh_auto(dummy, onoff)      ((onoff) != 0)
+#  define SSL_set_ecdh_auto(dummy, onoff)          ((onoff) != 0)
+/*
+ * We "pretend" to call the callback to avoid warnings about unused static
+ * functions.
+ */
+#  define SSL_CTX_set_tmp_rsa_callback(ctx, cb)    while(0) (cb)(NULL, 0, 0)
+#  define SSL_set_tmp_rsa_callback(ssl, cb)        while(0) (cb)(NULL, 0, 0)
+# endif
+__owur const BIO_METHOD *BIO_f_ssl(void);
+__owur BIO *BIO_new_ssl(SSL_CTX *ctx, int client);
+__owur BIO *BIO_new_ssl_connect(SSL_CTX *ctx);
+__owur BIO *BIO_new_buffer_ssl_connect(SSL_CTX *ctx);
+__owur int BIO_ssl_copy_session_id(BIO *to, BIO *from);
+void BIO_ssl_shutdown(BIO *ssl_bio);
+
+__owur int SSL_CTX_set_cipher_list(SSL_CTX *, const char *str);
+__owur SSL_CTX *SSL_CTX_new(const SSL_METHOD *meth);
+__owur SSL_CTX *SSL_CTX_new_ex(OSSL_LIB_CTX *libctx, const char *propq,
+                               const SSL_METHOD *meth);
+int SSL_CTX_up_ref(SSL_CTX *ctx);
+void SSL_CTX_free(SSL_CTX *);
+__owur long SSL_CTX_set_timeout(SSL_CTX *ctx, long t);
+__owur long SSL_CTX_get_timeout(const SSL_CTX *ctx);
+__owur X509_STORE *SSL_CTX_get_cert_store(const SSL_CTX *);
+void SSL_CTX_set_cert_store(SSL_CTX *, X509_STORE *);
+void SSL_CTX_set1_cert_store(SSL_CTX *, X509_STORE *);
+__owur int SSL_want(const SSL *s);
+__owur int SSL_clear(SSL *s);
+
+void SSL_CTX_flush_sessions(SSL_CTX *ctx, long tm);
+
+__owur const SSL_CIPHER *SSL_get_current_cipher(const SSL *s);
+__owur const SSL_CIPHER *SSL_get_pending_cipher(const SSL *s);
+__owur int SSL_CIPHER_get_bits(const SSL_CIPHER *c, int *alg_bits);
+__owur const char *SSL_CIPHER_get_version(const SSL_CIPHER *c);
+__owur const char *SSL_CIPHER_get_name(const SSL_CIPHER *c);
+__owur const char *SSL_CIPHER_standard_name(const SSL_CIPHER *c);
+__owur const char *OPENSSL_cipher_name(const char *rfc_name);
+__owur uint32_t SSL_CIPHER_get_id(const SSL_CIPHER *c);
+__owur uint16_t SSL_CIPHER_get_protocol_id(const SSL_CIPHER *c);
+__owur int SSL_CIPHER_get_kx_nid(const SSL_CIPHER *c);
+__owur int SSL_CIPHER_get_auth_nid(const SSL_CIPHER *c);
+__owur const EVP_MD *SSL_CIPHER_get_handshake_digest(const SSL_CIPHER *c);
+__owur int SSL_CIPHER_is_aead(const SSL_CIPHER *c);
+
+__owur int SSL_get_fd(const SSL *s);
+__owur int SSL_get_rfd(const SSL *s);
+__owur int SSL_get_wfd(const SSL *s);
+__owur const char *SSL_get_cipher_list(const SSL *s, int n);
+__owur char *SSL_get_shared_ciphers(const SSL *s, char *buf, int size);
+__owur int SSL_get_read_ahead(const SSL *s);
+__owur int SSL_pending(const SSL *s);
+__owur int SSL_has_pending(const SSL *s);
+# ifndef OPENSSL_NO_SOCK
+__owur int SSL_set_fd(SSL *s, int fd);
+__owur int SSL_set_rfd(SSL *s, int fd);
+__owur int SSL_set_wfd(SSL *s, int fd);
+# endif
+void SSL_set0_rbio(SSL *s, BIO *rbio);
+void SSL_set0_wbio(SSL *s, BIO *wbio);
+void SSL_set_bio(SSL *s, BIO *rbio, BIO *wbio);
+__owur BIO *SSL_get_rbio(const SSL *s);
+__owur BIO *SSL_get_wbio(const SSL *s);
+__owur int SSL_set_cipher_list(SSL *s, const char *str);
+__owur int SSL_CTX_set_ciphersuites(SSL_CTX *ctx, const char *str);
+__owur int SSL_set_ciphersuites(SSL *s, const char *str);
+void SSL_set_read_ahead(SSL *s, int yes);
+__owur int SSL_get_verify_mode(const SSL *s);
+__owur int SSL_get_verify_depth(const SSL *s);
+__owur SSL_verify_cb SSL_get_verify_callback(const SSL *s);
+void SSL_set_verify(SSL *s, int mode, SSL_verify_cb callback);
+void SSL_set_verify_depth(SSL *s, int depth);
+void SSL_set_cert_cb(SSL *s, int (*cb) (SSL *ssl, void *arg), void *arg);
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 __owur int SSL_use_RSAPrivateKey(SSL *ssl, RSA *rsa);
+OSSL_DEPRECATEDIN_3_0
+__owur int SSL_use_RSAPrivateKey_ASN1(SSL *ssl,
+                                      const unsigned char *d, long len);
+# endif
+__owur int SSL_use_PrivateKey(SSL *ssl, EVP_PKEY *pkey);
+__owur int SSL_use_PrivateKey_ASN1(int pk, SSL *ssl, const unsigned char *d,
+                                   long len);
+__owur int SSL_use_certificate(SSL *ssl, X509 *x);
+__owur int SSL_use_certificate_ASN1(SSL *ssl, const unsigned char *d, int len);
+__owur int SSL_use_cert_and_key(SSL *ssl, X509 *x509, EVP_PKEY *privatekey,
+                                STACK_OF(X509) *chain, int override);
+
+
+/* serverinfo file format versions */
+# define SSL_SERVERINFOV1   1
+# define SSL_SERVERINFOV2   2
+
+/* Set serverinfo data for the current active cert. */
+__owur int SSL_CTX_use_serverinfo(SSL_CTX *ctx, const unsigned char *serverinfo,
+                                  size_t serverinfo_length);
+__owur int SSL_CTX_use_serverinfo_ex(SSL_CTX *ctx, unsigned int version,
+                                     const unsigned char *serverinfo,
+                                     size_t serverinfo_length);
+__owur int SSL_CTX_use_serverinfo_file(SSL_CTX *ctx, const char *file);
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+__owur int SSL_use_RSAPrivateKey_file(SSL *ssl, const char *file, int type);
+#endif
+
+__owur int SSL_use_PrivateKey_file(SSL *ssl, const char *file, int type);
+__owur int SSL_use_certificate_file(SSL *ssl, const char *file, int type);
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+__owur int SSL_CTX_use_RSAPrivateKey_file(SSL_CTX *ctx, const char *file,
+                                          int type);
+#endif
+__owur int SSL_CTX_use_PrivateKey_file(SSL_CTX *ctx, const char *file,
+                                       int type);
+__owur int SSL_CTX_use_certificate_file(SSL_CTX *ctx, const char *file,
+                                        int type);
+/* PEM type */
+__owur int SSL_CTX_use_certificate_chain_file(SSL_CTX *ctx, const char *file);
+__owur int SSL_use_certificate_chain_file(SSL *ssl, const char *file);
+__owur STACK_OF(X509_NAME) *SSL_load_client_CA_file(const char *file);
+__owur STACK_OF(X509_NAME)
+*SSL_load_client_CA_file_ex(const char *file, OSSL_LIB_CTX *libctx,
+                            const char *propq);
+__owur int SSL_add_file_cert_subjects_to_stack(STACK_OF(X509_NAME) *stackCAs,
+                                               const char *file);
+int SSL_add_dir_cert_subjects_to_stack(STACK_OF(X509_NAME) *stackCAs,
+                                       const char *dir);
+int SSL_add_store_cert_subjects_to_stack(STACK_OF(X509_NAME) *stackCAs,
+                                       const char *uri);
+
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#  define SSL_load_error_strings() \
+    OPENSSL_init_ssl(OPENSSL_INIT_LOAD_SSL_STRINGS \
+                     | OPENSSL_INIT_LOAD_CRYPTO_STRINGS, NULL)
+# endif
+
+__owur const char *SSL_state_string(const SSL *s);
+__owur const char *SSL_rstate_string(const SSL *s);
+__owur const char *SSL_state_string_long(const SSL *s);
+__owur const char *SSL_rstate_string_long(const SSL *s);
+__owur long SSL_SESSION_get_time(const SSL_SESSION *s);
+__owur long SSL_SESSION_set_time(SSL_SESSION *s, long t);
+__owur long SSL_SESSION_get_timeout(const SSL_SESSION *s);
+__owur long SSL_SESSION_set_timeout(SSL_SESSION *s, long t);
+__owur int SSL_SESSION_get_protocol_version(const SSL_SESSION *s);
+__owur int SSL_SESSION_set_protocol_version(SSL_SESSION *s, int version);
+
+__owur time_t SSL_SESSION_get_time_ex(const SSL_SESSION *s);
+__owur time_t SSL_SESSION_set_time_ex(SSL_SESSION *s, time_t t);
+
+__owur const char *SSL_SESSION_get0_hostname(const SSL_SESSION *s);
+__owur int SSL_SESSION_set1_hostname(SSL_SESSION *s, const char *hostname);
+void SSL_SESSION_get0_alpn_selected(const SSL_SESSION *s,
+                                    const unsigned char **alpn,
+                                    size_t *len);
+__owur int SSL_SESSION_set1_alpn_selected(SSL_SESSION *s,
+                                          const unsigned char *alpn,
+                                          size_t len);
+__owur const SSL_CIPHER *SSL_SESSION_get0_cipher(const SSL_SESSION *s);
+__owur int SSL_SESSION_set_cipher(SSL_SESSION *s, const SSL_CIPHER *cipher);
+__owur int SSL_SESSION_has_ticket(const SSL_SESSION *s);
+__owur unsigned long SSL_SESSION_get_ticket_lifetime_hint(const SSL_SESSION *s);
+void SSL_SESSION_get0_ticket(const SSL_SESSION *s, const unsigned char **tick,
+                             size_t *len);
+__owur uint32_t SSL_SESSION_get_max_early_data(const SSL_SESSION *s);
+__owur int SSL_SESSION_set_max_early_data(SSL_SESSION *s,
+                                          uint32_t max_early_data);
+__owur int SSL_copy_session_id(SSL *to, const SSL *from);
+__owur X509 *SSL_SESSION_get0_peer(SSL_SESSION *s);
+__owur int SSL_SESSION_set1_id_context(SSL_SESSION *s,
+                                       const unsigned char *sid_ctx,
+                                       unsigned int sid_ctx_len);
+__owur int SSL_SESSION_set1_id(SSL_SESSION *s, const unsigned char *sid,
+                               unsigned int sid_len);
+__owur int SSL_SESSION_is_resumable(const SSL_SESSION *s);
+
+__owur SSL_SESSION *SSL_SESSION_new(void);
+__owur SSL_SESSION *SSL_SESSION_dup(const SSL_SESSION *src);
+const unsigned char *SSL_SESSION_get_id(const SSL_SESSION *s,
+                                        unsigned int *len);
+const unsigned char *SSL_SESSION_get0_id_context(const SSL_SESSION *s,
+                                                 unsigned int *len);
+__owur unsigned int SSL_SESSION_get_compress_id(const SSL_SESSION *s);
+# ifndef OPENSSL_NO_STDIO
+int SSL_SESSION_print_fp(FILE *fp, const SSL_SESSION *ses);
+# endif
+int SSL_SESSION_print(BIO *fp, const SSL_SESSION *ses);
+int SSL_SESSION_print_keylog(BIO *bp, const SSL_SESSION *x);
+int SSL_SESSION_up_ref(SSL_SESSION *ses);
+void SSL_SESSION_free(SSL_SESSION *ses);
+__owur int i2d_SSL_SESSION(const SSL_SESSION *in, unsigned char **pp);
+__owur int SSL_set_session(SSL *to, SSL_SESSION *session);
+int SSL_CTX_add_session(SSL_CTX *ctx, SSL_SESSION *session);
+int SSL_CTX_remove_session(SSL_CTX *ctx, SSL_SESSION *session);
+__owur int SSL_CTX_set_generate_session_id(SSL_CTX *ctx, GEN_SESSION_CB cb);
+__owur int SSL_set_generate_session_id(SSL *s, GEN_SESSION_CB cb);
+__owur int SSL_has_matching_session_id(const SSL *s,
+                                       const unsigned char *id,
+                                       unsigned int id_len);
+SSL_SESSION *d2i_SSL_SESSION(SSL_SESSION **a, const unsigned char **pp,
+                             long length);
+SSL_SESSION *d2i_SSL_SESSION_ex(SSL_SESSION **a, const unsigned char **pp,
+                                long length, OSSL_LIB_CTX *libctx,
+                                const char *propq);
+
+# ifdef OPENSSL_X509_H
+__owur X509 *SSL_get0_peer_certificate(const SSL *s);
+__owur X509 *SSL_get1_peer_certificate(const SSL *s);
+/* Deprecated in 3.0.0 */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+#   define SSL_get_peer_certificate SSL_get1_peer_certificate
+#  endif
+# endif
+
+__owur STACK_OF(X509) *SSL_get_peer_cert_chain(const SSL *s);
+
+__owur int SSL_CTX_get_verify_mode(const SSL_CTX *ctx);
+__owur int SSL_CTX_get_verify_depth(const SSL_CTX *ctx);
+__owur SSL_verify_cb SSL_CTX_get_verify_callback(const SSL_CTX *ctx);
+void SSL_CTX_set_verify(SSL_CTX *ctx, int mode, SSL_verify_cb callback);
+void SSL_CTX_set_verify_depth(SSL_CTX *ctx, int depth);
+void SSL_CTX_set_cert_verify_callback(SSL_CTX *ctx,
+                                      int (*cb) (X509_STORE_CTX *, void *),
+                                      void *arg);
+void SSL_CTX_set_cert_cb(SSL_CTX *c, int (*cb) (SSL *ssl, void *arg),
+                         void *arg);
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+__owur int SSL_CTX_use_RSAPrivateKey(SSL_CTX *ctx, RSA *rsa);
+OSSL_DEPRECATEDIN_3_0
+__owur int SSL_CTX_use_RSAPrivateKey_ASN1(SSL_CTX *ctx, const unsigned char *d,
+                                          long len);
+# endif
+__owur int SSL_CTX_use_PrivateKey(SSL_CTX *ctx, EVP_PKEY *pkey);
+__owur int SSL_CTX_use_PrivateKey_ASN1(int pk, SSL_CTX *ctx,
+                                       const unsigned char *d, long len);
+__owur int SSL_CTX_use_certificate(SSL_CTX *ctx, X509 *x);
+__owur int SSL_CTX_use_certificate_ASN1(SSL_CTX *ctx, int len,
+                                        const unsigned char *d);
+__owur int SSL_CTX_use_cert_and_key(SSL_CTX *ctx, X509 *x509, EVP_PKEY *privatekey,
+                                    STACK_OF(X509) *chain, int override);
+
+void SSL_CTX_set_default_passwd_cb(SSL_CTX *ctx, pem_password_cb *cb);
+void SSL_CTX_set_default_passwd_cb_userdata(SSL_CTX *ctx, void *u);
+pem_password_cb *SSL_CTX_get_default_passwd_cb(SSL_CTX *ctx);
+void *SSL_CTX_get_default_passwd_cb_userdata(SSL_CTX *ctx);
+void SSL_set_default_passwd_cb(SSL *s, pem_password_cb *cb);
+void SSL_set_default_passwd_cb_userdata(SSL *s, void *u);
+pem_password_cb *SSL_get_default_passwd_cb(SSL *s);
+void *SSL_get_default_passwd_cb_userdata(SSL *s);
+
+__owur int SSL_CTX_check_private_key(const SSL_CTX *ctx);
+__owur int SSL_check_private_key(const SSL *ctx);
+
+__owur int SSL_CTX_set_session_id_context(SSL_CTX *ctx,
+                                          const unsigned char *sid_ctx,
+                                          unsigned int sid_ctx_len);
+
+SSL *SSL_new(SSL_CTX *ctx);
+int SSL_up_ref(SSL *s);
+int SSL_is_dtls(const SSL *s);
+int SSL_is_tls(const SSL *s);
+int SSL_is_quic(const SSL *s);
+__owur int SSL_set_session_id_context(SSL *ssl, const unsigned char *sid_ctx,
+                                      unsigned int sid_ctx_len);
+
+__owur int SSL_CTX_set_purpose(SSL_CTX *ctx, int purpose);
+__owur int SSL_set_purpose(SSL *ssl, int purpose);
+__owur int SSL_CTX_set_trust(SSL_CTX *ctx, int trust);
+__owur int SSL_set_trust(SSL *ssl, int trust);
+
+__owur int SSL_set1_host(SSL *s, const char *hostname);
+__owur int SSL_add1_host(SSL *s, const char *hostname);
+__owur const char *SSL_get0_peername(SSL *s);
+void SSL_set_hostflags(SSL *s, unsigned int flags);
+
+__owur int SSL_CTX_dane_enable(SSL_CTX *ctx);
+__owur int SSL_CTX_dane_mtype_set(SSL_CTX *ctx, const EVP_MD *md,
+                                  uint8_t mtype, uint8_t ord);
+__owur int SSL_dane_enable(SSL *s, const char *basedomain);
+__owur int SSL_dane_tlsa_add(SSL *s, uint8_t usage, uint8_t selector,
+                             uint8_t mtype, const unsigned char *data, size_t dlen);
+__owur int SSL_get0_dane_authority(SSL *s, X509 **mcert, EVP_PKEY **mspki);
+__owur int SSL_get0_dane_tlsa(SSL *s, uint8_t *usage, uint8_t *selector,
+                              uint8_t *mtype, const unsigned char **data,
+                              size_t *dlen);
+/*
+ * Bridge opacity barrier between libcrypt and libssl, also needed to support
+ * offline testing in test/danetest.c
+ */
+SSL_DANE *SSL_get0_dane(SSL *ssl);
+/*
+ * DANE flags
+ */
+unsigned long SSL_CTX_dane_set_flags(SSL_CTX *ctx, unsigned long flags);
+unsigned long SSL_CTX_dane_clear_flags(SSL_CTX *ctx, unsigned long flags);
+unsigned long SSL_dane_set_flags(SSL *ssl, unsigned long flags);
+unsigned long SSL_dane_clear_flags(SSL *ssl, unsigned long flags);
+
+__owur int SSL_CTX_set1_param(SSL_CTX *ctx, X509_VERIFY_PARAM *vpm);
+__owur int SSL_set1_param(SSL *ssl, X509_VERIFY_PARAM *vpm);
+
+__owur X509_VERIFY_PARAM *SSL_CTX_get0_param(SSL_CTX *ctx);
+__owur X509_VERIFY_PARAM *SSL_get0_param(SSL *ssl);
+
+# ifndef OPENSSL_NO_SRP
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int SSL_CTX_set_srp_username(SSL_CTX *ctx, char *name);
+OSSL_DEPRECATEDIN_3_0 int SSL_CTX_set_srp_password(SSL_CTX *ctx, char *password);
+OSSL_DEPRECATEDIN_3_0 int SSL_CTX_set_srp_strength(SSL_CTX *ctx, int strength);
+OSSL_DEPRECATEDIN_3_0
+int SSL_CTX_set_srp_client_pwd_callback(SSL_CTX *ctx,
+                                        char *(*cb) (SSL *, void *));
+OSSL_DEPRECATEDIN_3_0
+int SSL_CTX_set_srp_verify_param_callback(SSL_CTX *ctx,
+                                          int (*cb) (SSL *, void *));
+OSSL_DEPRECATEDIN_3_0
+int SSL_CTX_set_srp_username_callback(SSL_CTX *ctx,
+                                      int (*cb) (SSL *, int *, void *));
+OSSL_DEPRECATEDIN_3_0 int SSL_CTX_set_srp_cb_arg(SSL_CTX *ctx, void *arg);
+
+OSSL_DEPRECATEDIN_3_0
+int SSL_set_srp_server_param(SSL *s, const BIGNUM *N, const BIGNUM *g,
+                             BIGNUM *sa, BIGNUM *v, char *info);
+OSSL_DEPRECATEDIN_3_0
+int SSL_set_srp_server_param_pw(SSL *s, const char *user, const char *pass,
+                                const char *grp);
+
+OSSL_DEPRECATEDIN_3_0 __owur BIGNUM *SSL_get_srp_g(SSL *s);
+OSSL_DEPRECATEDIN_3_0 __owur BIGNUM *SSL_get_srp_N(SSL *s);
+
+OSSL_DEPRECATEDIN_3_0 __owur char *SSL_get_srp_username(SSL *s);
+OSSL_DEPRECATEDIN_3_0 __owur char *SSL_get_srp_userinfo(SSL *s);
+#  endif
+# endif
+
+/*
+ * ClientHello callback and helpers.
+ */
+
+# define SSL_CLIENT_HELLO_SUCCESS 1
+# define SSL_CLIENT_HELLO_ERROR   0
+# define SSL_CLIENT_HELLO_RETRY   (-1)
+
+typedef int (*SSL_client_hello_cb_fn) (SSL *s, int *al, void *arg);
+void SSL_CTX_set_client_hello_cb(SSL_CTX *c, SSL_client_hello_cb_fn cb,
+                                 void *arg);
+int SSL_client_hello_isv2(SSL *s);
+unsigned int SSL_client_hello_get0_legacy_version(SSL *s);
+size_t SSL_client_hello_get0_random(SSL *s, const unsigned char **out);
+size_t SSL_client_hello_get0_session_id(SSL *s, const unsigned char **out);
+size_t SSL_client_hello_get0_ciphers(SSL *s, const unsigned char **out);
+size_t SSL_client_hello_get0_compression_methods(SSL *s,
+                                                 const unsigned char **out);
+int SSL_client_hello_get1_extensions_present(SSL *s, int **out, size_t *outlen);
+int SSL_client_hello_get_extension_order(SSL *s, uint16_t *exts,
+                                         size_t *num_exts);
+int SSL_client_hello_get0_ext(SSL *s, unsigned int type,
+                              const unsigned char **out, size_t *outlen);
+
+void SSL_certs_clear(SSL *s);
+void SSL_free(SSL *ssl);
+# ifdef OSSL_ASYNC_FD
+/*
+ * Windows application developer has to include windows.h to use these.
+ */
+__owur int SSL_waiting_for_async(SSL *s);
+__owur int SSL_get_all_async_fds(SSL *s, OSSL_ASYNC_FD *fds, size_t *numfds);
+__owur int SSL_get_changed_async_fds(SSL *s, OSSL_ASYNC_FD *addfd,
+                                     size_t *numaddfds, OSSL_ASYNC_FD *delfd,
+                                     size_t *numdelfds);
+__owur int SSL_CTX_set_async_callback(SSL_CTX *ctx, SSL_async_callback_fn callback);
+__owur int SSL_CTX_set_async_callback_arg(SSL_CTX *ctx, void *arg);
+__owur int SSL_set_async_callback(SSL *s, SSL_async_callback_fn callback);
+__owur int SSL_set_async_callback_arg(SSL *s, void *arg);
+__owur int SSL_get_async_status(SSL *s, int *status);
+
+# endif
+__owur int SSL_accept(SSL *ssl);
+__owur int SSL_stateless(SSL *s);
+__owur int SSL_connect(SSL *ssl);
+__owur int SSL_read(SSL *ssl, void *buf, int num);
+__owur int SSL_read_ex(SSL *ssl, void *buf, size_t num, size_t *readbytes);
+
+# define SSL_READ_EARLY_DATA_ERROR   0
+# define SSL_READ_EARLY_DATA_SUCCESS 1
+# define SSL_READ_EARLY_DATA_FINISH  2
+
+__owur int SSL_read_early_data(SSL *s, void *buf, size_t num,
+                               size_t *readbytes);
+__owur int SSL_peek(SSL *ssl, void *buf, int num);
+__owur int SSL_peek_ex(SSL *ssl, void *buf, size_t num, size_t *readbytes);
+__owur ossl_ssize_t SSL_sendfile(SSL *s, int fd, off_t offset, size_t size,
+                                 int flags);
+__owur int SSL_write(SSL *ssl, const void *buf, int num);
+__owur int SSL_write_ex(SSL *s, const void *buf, size_t num, size_t *written);
+__owur int SSL_write_early_data(SSL *s, const void *buf, size_t num,
+                                size_t *written);
+long SSL_ctrl(SSL *ssl, int cmd, long larg, void *parg);
+long SSL_callback_ctrl(SSL *, int, void (*)(void));
+long SSL_CTX_ctrl(SSL_CTX *ctx, int cmd, long larg, void *parg);
+long SSL_CTX_callback_ctrl(SSL_CTX *, int, void (*)(void));
+
+# define SSL_WRITE_FLAG_CONCLUDE    (1U << 0)
+
+__owur int SSL_write_ex2(SSL *s, const void *buf, size_t num,
+                         uint64_t flags,
+                         size_t *written);
+
+# define SSL_EARLY_DATA_NOT_SENT    0
+# define SSL_EARLY_DATA_REJECTED    1
+# define SSL_EARLY_DATA_ACCEPTED    2
+
+__owur int SSL_get_early_data_status(const SSL *s);
+
+__owur int SSL_get_error(const SSL *s, int ret_code);
+__owur const char *SSL_get_version(const SSL *s);
+__owur int SSL_get_handshake_rtt(const SSL *s, uint64_t *rtt);
+
+/* This sets the 'default' SSL version that SSL_new() will create */
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+__owur int SSL_CTX_set_ssl_version(SSL_CTX *ctx, const SSL_METHOD *meth);
+# endif
+
+# ifndef OPENSSL_NO_SSL3_METHOD
+#  ifndef OPENSSL_NO_DEPRECATED_1_1_0
+OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD *SSLv3_method(void); /* SSLv3 */
+OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD *SSLv3_server_method(void);
+OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD *SSLv3_client_method(void);
+#  endif
+# endif
+
+#define SSLv23_method           TLS_method
+#define SSLv23_server_method    TLS_server_method
+#define SSLv23_client_method    TLS_client_method
+
+/* Negotiate highest available SSL/TLS version */
+__owur const SSL_METHOD *TLS_method(void);
+__owur const SSL_METHOD *TLS_server_method(void);
+__owur const SSL_METHOD *TLS_client_method(void);
+
+# ifndef OPENSSL_NO_TLS1_METHOD
+#  ifndef OPENSSL_NO_DEPRECATED_1_1_0
+OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD *TLSv1_method(void); /* TLSv1.0 */
+OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD *TLSv1_server_method(void);
+OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD *TLSv1_client_method(void);
+#  endif
+# endif
+
+# ifndef OPENSSL_NO_TLS1_1_METHOD
+#  ifndef OPENSSL_NO_DEPRECATED_1_1_0
+OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD *TLSv1_1_method(void); /* TLSv1.1 */
+OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD *TLSv1_1_server_method(void);
+OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD *TLSv1_1_client_method(void);
+#  endif
+# endif
+
+# ifndef OPENSSL_NO_TLS1_2_METHOD
+#  ifndef OPENSSL_NO_DEPRECATED_1_1_0
+OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD *TLSv1_2_method(void); /* TLSv1.2 */
+OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD *TLSv1_2_server_method(void);
+OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD *TLSv1_2_client_method(void);
+#  endif
+# endif
+
+# ifndef OPENSSL_NO_DTLS1_METHOD
+#  ifndef OPENSSL_NO_DEPRECATED_1_1_0
+OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD *DTLSv1_method(void); /* DTLSv1.0 */
+OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD *DTLSv1_server_method(void);
+OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD *DTLSv1_client_method(void);
+#  endif
+# endif
+
+# ifndef OPENSSL_NO_DTLS1_2_METHOD
+/* DTLSv1.2 */
+#  ifndef OPENSSL_NO_DEPRECATED_1_1_0
+OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD *DTLSv1_2_method(void);
+OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD *DTLSv1_2_server_method(void);
+OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD *DTLSv1_2_client_method(void);
+#  endif
+# endif
+
+__owur const SSL_METHOD *DTLS_method(void); /* DTLS 1.0 and 1.2 */
+__owur const SSL_METHOD *DTLS_server_method(void); /* DTLS 1.0 and 1.2 */
+__owur const SSL_METHOD *DTLS_client_method(void); /* DTLS 1.0 and 1.2 */
+
+__owur size_t DTLS_get_data_mtu(const SSL *s);
+
+__owur STACK_OF(SSL_CIPHER) *SSL_get_ciphers(const SSL *s);
+__owur STACK_OF(SSL_CIPHER) *SSL_CTX_get_ciphers(const SSL_CTX *ctx);
+__owur STACK_OF(SSL_CIPHER) *SSL_get_client_ciphers(const SSL *s);
+__owur STACK_OF(SSL_CIPHER) *SSL_get1_supported_ciphers(SSL *s);
+
+__owur int SSL_do_handshake(SSL *s);
+int SSL_key_update(SSL *s, int updatetype);
+int SSL_get_key_update_type(const SSL *s);
+int SSL_renegotiate(SSL *s);
+int SSL_renegotiate_abbreviated(SSL *s);
+__owur int SSL_renegotiate_pending(const SSL *s);
+int SSL_new_session_ticket(SSL *s);
+int SSL_shutdown(SSL *s);
+__owur int SSL_verify_client_post_handshake(SSL *s);
+void SSL_CTX_set_post_handshake_auth(SSL_CTX *ctx, int val);
+void SSL_set_post_handshake_auth(SSL *s, int val);
+
+__owur const SSL_METHOD *SSL_CTX_get_ssl_method(const SSL_CTX *ctx);
+__owur const SSL_METHOD *SSL_get_ssl_method(const SSL *s);
+__owur int SSL_set_ssl_method(SSL *s, const SSL_METHOD *method);
+__owur const char *SSL_alert_type_string_long(int value);
+__owur const char *SSL_alert_type_string(int value);
+__owur const char *SSL_alert_desc_string_long(int value);
+__owur const char *SSL_alert_desc_string(int value);
+
+void SSL_set0_CA_list(SSL *s, STACK_OF(X509_NAME) *name_list);
+void SSL_CTX_set0_CA_list(SSL_CTX *ctx, STACK_OF(X509_NAME) *name_list);
+__owur const STACK_OF(X509_NAME) *SSL_get0_CA_list(const SSL *s);
+__owur const STACK_OF(X509_NAME) *SSL_CTX_get0_CA_list(const SSL_CTX *ctx);
+__owur int SSL_add1_to_CA_list(SSL *ssl, const X509 *x);
+__owur int SSL_CTX_add1_to_CA_list(SSL_CTX *ctx, const X509 *x);
+__owur const STACK_OF(X509_NAME) *SSL_get0_peer_CA_list(const SSL *s);
+
+void SSL_set_client_CA_list(SSL *s, STACK_OF(X509_NAME) *name_list);
+void SSL_CTX_set_client_CA_list(SSL_CTX *ctx, STACK_OF(X509_NAME) *name_list);
+__owur STACK_OF(X509_NAME) *SSL_get_client_CA_list(const SSL *s);
+__owur STACK_OF(X509_NAME) *SSL_CTX_get_client_CA_list(const SSL_CTX *s);
+__owur int SSL_add_client_CA(SSL *ssl, X509 *x);
+__owur int SSL_CTX_add_client_CA(SSL_CTX *ctx, X509 *x);
+
+void SSL_set_connect_state(SSL *s);
+void SSL_set_accept_state(SSL *s);
+
+__owur long SSL_get_default_timeout(const SSL *s);
+
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#  define SSL_library_init() OPENSSL_init_ssl(0, NULL)
+# endif
+
+__owur char *SSL_CIPHER_description(const SSL_CIPHER *, char *buf, int size);
+__owur STACK_OF(X509_NAME) *SSL_dup_CA_list(const STACK_OF(X509_NAME) *sk);
+
+__owur SSL *SSL_dup(SSL *ssl);
+
+__owur X509 *SSL_get_certificate(const SSL *ssl);
+/*
+ * EVP_PKEY
+ */
+struct evp_pkey_st *SSL_get_privatekey(const SSL *ssl);
+
+__owur X509 *SSL_CTX_get0_certificate(const SSL_CTX *ctx);
+__owur EVP_PKEY *SSL_CTX_get0_privatekey(const SSL_CTX *ctx);
+
+void SSL_CTX_set_quiet_shutdown(SSL_CTX *ctx, int mode);
+__owur int SSL_CTX_get_quiet_shutdown(const SSL_CTX *ctx);
+void SSL_set_quiet_shutdown(SSL *ssl, int mode);
+__owur int SSL_get_quiet_shutdown(const SSL *ssl);
+void SSL_set_shutdown(SSL *ssl, int mode);
+__owur int SSL_get_shutdown(const SSL *ssl);
+__owur int SSL_version(const SSL *ssl);
+__owur int SSL_client_version(const SSL *s);
+__owur int SSL_CTX_set_default_verify_paths(SSL_CTX *ctx);
+__owur int SSL_CTX_set_default_verify_dir(SSL_CTX *ctx);
+__owur int SSL_CTX_set_default_verify_file(SSL_CTX *ctx);
+__owur int SSL_CTX_set_default_verify_store(SSL_CTX *ctx);
+__owur int SSL_CTX_load_verify_file(SSL_CTX *ctx, const char *CAfile);
+__owur int SSL_CTX_load_verify_dir(SSL_CTX *ctx, const char *CApath);
+__owur int SSL_CTX_load_verify_store(SSL_CTX *ctx, const char *CAstore);
+__owur int SSL_CTX_load_verify_locations(SSL_CTX *ctx,
+                                                        const char *CAfile,
+                                                        const char *CApath);
+# define SSL_get0_session SSL_get_session/* just peek at pointer */
+__owur SSL_SESSION *SSL_get_session(const SSL *ssl);
+__owur SSL_SESSION *SSL_get1_session(SSL *ssl); /* obtain a reference count */
+__owur SSL_CTX *SSL_get_SSL_CTX(const SSL *ssl);
+SSL_CTX *SSL_set_SSL_CTX(SSL *ssl, SSL_CTX *ctx);
+void SSL_set_info_callback(SSL *ssl,
+                           void (*cb) (const SSL *ssl, int type, int val));
+void (*SSL_get_info_callback(const SSL *ssl)) (const SSL *ssl, int type,
+                                               int val);
+__owur OSSL_HANDSHAKE_STATE SSL_get_state(const SSL *ssl);
+
+void SSL_set_verify_result(SSL *ssl, long v);
+__owur long SSL_get_verify_result(const SSL *ssl);
+__owur STACK_OF(X509) *SSL_get0_verified_chain(const SSL *s);
+
+__owur size_t SSL_get_client_random(const SSL *ssl, unsigned char *out,
+                                    size_t outlen);
+__owur size_t SSL_get_server_random(const SSL *ssl, unsigned char *out,
+                                    size_t outlen);
+__owur size_t SSL_SESSION_get_master_key(const SSL_SESSION *sess,
+                                         unsigned char *out, size_t outlen);
+__owur int SSL_SESSION_set1_master_key(SSL_SESSION *sess,
+                                       const unsigned char *in, size_t len);
+uint8_t SSL_SESSION_get_max_fragment_length(const SSL_SESSION *sess);
+
+#define SSL_get_ex_new_index(l, p, newf, dupf, freef) \
+    CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_SSL, l, p, newf, dupf, freef)
+__owur int SSL_set_ex_data(SSL *ssl, int idx, void *data);
+void *SSL_get_ex_data(const SSL *ssl, int idx);
+#define SSL_SESSION_get_ex_new_index(l, p, newf, dupf, freef) \
+    CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_SSL_SESSION, l, p, newf, dupf, freef)
+__owur int SSL_SESSION_set_ex_data(SSL_SESSION *ss, int idx, void *data);
+void *SSL_SESSION_get_ex_data(const SSL_SESSION *ss, int idx);
+#define SSL_CTX_get_ex_new_index(l, p, newf, dupf, freef) \
+    CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_SSL_CTX, l, p, newf, dupf, freef)
+__owur int SSL_CTX_set_ex_data(SSL_CTX *ssl, int idx, void *data);
+void *SSL_CTX_get_ex_data(const SSL_CTX *ssl, int idx);
+
+__owur int SSL_get_ex_data_X509_STORE_CTX_idx(void);
+
+# define SSL_CTX_sess_set_cache_size(ctx,t) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_SESS_CACHE_SIZE,t,NULL)
+# define SSL_CTX_sess_get_cache_size(ctx) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_GET_SESS_CACHE_SIZE,0,NULL)
+# define SSL_CTX_set_session_cache_mode(ctx,m) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_SESS_CACHE_MODE,m,NULL)
+# define SSL_CTX_get_session_cache_mode(ctx) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_GET_SESS_CACHE_MODE,0,NULL)
+
+# define SSL_CTX_get_default_read_ahead(ctx) SSL_CTX_get_read_ahead(ctx)
+# define SSL_CTX_set_default_read_ahead(ctx,m) SSL_CTX_set_read_ahead(ctx,m)
+# define SSL_CTX_get_read_ahead(ctx) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_GET_READ_AHEAD,0,NULL)
+# define SSL_CTX_set_read_ahead(ctx,m) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_READ_AHEAD,m,NULL)
+# define SSL_CTX_get_max_cert_list(ctx) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_GET_MAX_CERT_LIST,0,NULL)
+# define SSL_CTX_set_max_cert_list(ctx,m) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_MAX_CERT_LIST,m,NULL)
+# define SSL_get_max_cert_list(ssl) \
+        SSL_ctrl(ssl,SSL_CTRL_GET_MAX_CERT_LIST,0,NULL)
+# define SSL_set_max_cert_list(ssl,m) \
+        SSL_ctrl(ssl,SSL_CTRL_SET_MAX_CERT_LIST,m,NULL)
+
+# define SSL_CTX_set_max_send_fragment(ctx,m) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_MAX_SEND_FRAGMENT,m,NULL)
+# define SSL_set_max_send_fragment(ssl,m) \
+        SSL_ctrl(ssl,SSL_CTRL_SET_MAX_SEND_FRAGMENT,m,NULL)
+# define SSL_CTX_set_split_send_fragment(ctx,m) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_SPLIT_SEND_FRAGMENT,m,NULL)
+# define SSL_set_split_send_fragment(ssl,m) \
+        SSL_ctrl(ssl,SSL_CTRL_SET_SPLIT_SEND_FRAGMENT,m,NULL)
+# define SSL_CTX_set_max_pipelines(ctx,m) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_MAX_PIPELINES,m,NULL)
+# define SSL_set_max_pipelines(ssl,m) \
+        SSL_ctrl(ssl,SSL_CTRL_SET_MAX_PIPELINES,m,NULL)
+# define SSL_set_retry_verify(ssl) \
+        (SSL_ctrl(ssl,SSL_CTRL_SET_RETRY_VERIFY,0,NULL) > 0)
+
+void SSL_CTX_set_default_read_buffer_len(SSL_CTX *ctx, size_t len);
+void SSL_set_default_read_buffer_len(SSL *s, size_t len);
+
+# ifndef OPENSSL_NO_DH
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+/* NB: the |keylength| is only applicable when is_export is true */
+OSSL_DEPRECATEDIN_3_0
+void SSL_CTX_set_tmp_dh_callback(SSL_CTX *ctx,
+                                 DH *(*dh) (SSL *ssl, int is_export,
+                                            int keylength));
+OSSL_DEPRECATEDIN_3_0
+void SSL_set_tmp_dh_callback(SSL *ssl,
+                             DH *(*dh) (SSL *ssl, int is_export,
+                                        int keylength));
+#  endif
+# endif
+
+__owur const COMP_METHOD *SSL_get_current_compression(const SSL *s);
+__owur const COMP_METHOD *SSL_get_current_expansion(const SSL *s);
+__owur const char *SSL_COMP_get_name(const COMP_METHOD *comp);
+__owur const char *SSL_COMP_get0_name(const SSL_COMP *comp);
+__owur int SSL_COMP_get_id(const SSL_COMP *comp);
+STACK_OF(SSL_COMP) *SSL_COMP_get_compression_methods(void);
+__owur STACK_OF(SSL_COMP) *SSL_COMP_set0_compression_methods(STACK_OF(SSL_COMP)
+                                                             *meths);
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#  define SSL_COMP_free_compression_methods() while(0) continue
+# endif
+__owur int SSL_COMP_add_compression_method(int id, COMP_METHOD *cm);
+
+const SSL_CIPHER *SSL_CIPHER_find(SSL *ssl, const unsigned char *ptr);
+int SSL_CIPHER_get_cipher_nid(const SSL_CIPHER *c);
+int SSL_CIPHER_get_digest_nid(const SSL_CIPHER *c);
+int SSL_bytes_to_cipher_list(SSL *s, const unsigned char *bytes, size_t len,
+                             int isv2format, STACK_OF(SSL_CIPHER) **sk,
+                             STACK_OF(SSL_CIPHER) **scsvs);
+
+/* TLS extensions functions */
+__owur int SSL_set_session_ticket_ext(SSL *s, void *ext_data, int ext_len);
+
+__owur int SSL_set_session_ticket_ext_cb(SSL *s,
+                                         tls_session_ticket_ext_cb_fn cb,
+                                         void *arg);
+
+/* Pre-shared secret session resumption functions */
+__owur int SSL_set_session_secret_cb(SSL *s,
+                                     tls_session_secret_cb_fn session_secret_cb,
+                                     void *arg);
+
+void SSL_CTX_set_not_resumable_session_callback(SSL_CTX *ctx,
+                                                int (*cb) (SSL *ssl,
+                                                           int
+                                                           is_forward_secure));
+
+void SSL_set_not_resumable_session_callback(SSL *ssl,
+                                            int (*cb) (SSL *ssl,
+                                                       int is_forward_secure));
+
+void SSL_CTX_set_record_padding_callback(SSL_CTX *ctx,
+                                         size_t (*cb) (SSL *ssl, int type,
+                                                       size_t len, void *arg));
+void SSL_CTX_set_record_padding_callback_arg(SSL_CTX *ctx, void *arg);
+void *SSL_CTX_get_record_padding_callback_arg(const SSL_CTX *ctx);
+int SSL_CTX_set_block_padding(SSL_CTX *ctx, size_t block_size);
+
+int SSL_set_record_padding_callback(SSL *ssl,
+                                    size_t (*cb) (SSL *ssl, int type,
+                                                  size_t len, void *arg));
+void SSL_set_record_padding_callback_arg(SSL *ssl, void *arg);
+void *SSL_get_record_padding_callback_arg(const SSL *ssl);
+int SSL_set_block_padding(SSL *ssl, size_t block_size);
+
+int SSL_set_num_tickets(SSL *s, size_t num_tickets);
+size_t SSL_get_num_tickets(const SSL *s);
+int SSL_CTX_set_num_tickets(SSL_CTX *ctx, size_t num_tickets);
+size_t SSL_CTX_get_num_tickets(const SSL_CTX *ctx);
+
+/* QUIC support */
+int SSL_handle_events(SSL *s);
+__owur int SSL_get_event_timeout(SSL *s, struct timeval *tv, int *is_infinite);
+__owur int SSL_get_rpoll_descriptor(SSL *s, BIO_POLL_DESCRIPTOR *desc);
+__owur int SSL_get_wpoll_descriptor(SSL *s, BIO_POLL_DESCRIPTOR *desc);
+__owur int SSL_net_read_desired(SSL *s);
+__owur int SSL_net_write_desired(SSL *s);
+__owur int SSL_set_blocking_mode(SSL *s, int blocking);
+__owur int SSL_get_blocking_mode(SSL *s);
+__owur int SSL_set1_initial_peer_addr(SSL *s, const BIO_ADDR *peer_addr);
+__owur SSL *SSL_get0_connection(SSL *s);
+__owur int SSL_is_connection(SSL *s);
+
+#define SSL_STREAM_TYPE_NONE        0
+#define SSL_STREAM_TYPE_READ        (1U << 0)
+#define SSL_STREAM_TYPE_WRITE       (1U << 1)
+#define SSL_STREAM_TYPE_BIDI        (SSL_STREAM_TYPE_READ | SSL_STREAM_TYPE_WRITE)
+__owur int SSL_get_stream_type(SSL *s);
+
+__owur uint64_t SSL_get_stream_id(SSL *s);
+__owur int SSL_is_stream_local(SSL *s);
+
+#define SSL_DEFAULT_STREAM_MODE_NONE        0
+#define SSL_DEFAULT_STREAM_MODE_AUTO_BIDI   1
+#define SSL_DEFAULT_STREAM_MODE_AUTO_UNI    2
+__owur int SSL_set_default_stream_mode(SSL *s, uint32_t mode);
+
+#define SSL_STREAM_FLAG_UNI         (1U << 0)
+#define SSL_STREAM_FLAG_NO_BLOCK    (1U << 1)
+#define SSL_STREAM_FLAG_ADVANCE     (1U << 2)
+__owur SSL *SSL_new_stream(SSL *s, uint64_t flags);
+
+#define SSL_INCOMING_STREAM_POLICY_AUTO      0
+#define SSL_INCOMING_STREAM_POLICY_ACCEPT    1
+#define SSL_INCOMING_STREAM_POLICY_REJECT    2
+__owur int SSL_set_incoming_stream_policy(SSL *s, int policy, uint64_t aec);
+
+#define SSL_ACCEPT_STREAM_NO_BLOCK      (1U << 0)
+__owur SSL *SSL_accept_stream(SSL *s, uint64_t flags);
+__owur size_t SSL_get_accept_stream_queue_len(SSL *s);
+
+# ifndef OPENSSL_NO_QUIC
+__owur int SSL_inject_net_dgram(SSL *s, const unsigned char *buf,
+                                size_t buf_len,
+                                const BIO_ADDR *peer,
+                                const BIO_ADDR *local);
+# endif
+
+typedef struct ssl_shutdown_ex_args_st {
+    uint64_t    quic_error_code;
+    const char  *quic_reason;
+} SSL_SHUTDOWN_EX_ARGS;
+
+#define SSL_SHUTDOWN_FLAG_RAPID             (1U << 0)
+#define SSL_SHUTDOWN_FLAG_NO_STREAM_FLUSH   (1U << 1)
+#define SSL_SHUTDOWN_FLAG_NO_BLOCK          (1U << 2)
+#define SSL_SHUTDOWN_FLAG_WAIT_PEER         (1U << 3)
+
+__owur int SSL_shutdown_ex(SSL *ssl, uint64_t flags,
+                           const SSL_SHUTDOWN_EX_ARGS *args,
+                           size_t args_len);
+
+__owur int SSL_stream_conclude(SSL *ssl, uint64_t flags);
+
+typedef struct ssl_stream_reset_args_st {
+    uint64_t quic_error_code;
+} SSL_STREAM_RESET_ARGS;
+
+__owur int SSL_stream_reset(SSL *ssl,
+                            const SSL_STREAM_RESET_ARGS *args,
+                            size_t args_len);
+
+#define SSL_STREAM_STATE_NONE           0
+#define SSL_STREAM_STATE_OK             1
+#define SSL_STREAM_STATE_WRONG_DIR      2
+#define SSL_STREAM_STATE_FINISHED       3
+#define SSL_STREAM_STATE_RESET_LOCAL    4
+#define SSL_STREAM_STATE_RESET_REMOTE   5
+#define SSL_STREAM_STATE_CONN_CLOSED    6
+__owur int SSL_get_stream_read_state(SSL *ssl);
+__owur int SSL_get_stream_write_state(SSL *ssl);
+
+__owur int SSL_get_stream_read_error_code(SSL *ssl, uint64_t *app_error_code);
+__owur int SSL_get_stream_write_error_code(SSL *ssl, uint64_t *app_error_code);
+
+#define SSL_CONN_CLOSE_FLAG_LOCAL       (1U << 0)
+#define SSL_CONN_CLOSE_FLAG_TRANSPORT   (1U << 1)
+
+typedef struct ssl_conn_close_info_st {
+    uint64_t    error_code, frame_type;
+    const char  *reason;
+    size_t      reason_len;
+    uint32_t    flags;
+} SSL_CONN_CLOSE_INFO;
+
+__owur int SSL_get_conn_close_info(SSL *ssl,
+                                   SSL_CONN_CLOSE_INFO *info,
+                                   size_t info_len);
+
+# define SSL_VALUE_CLASS_GENERIC                0
+# define SSL_VALUE_CLASS_FEATURE_REQUEST        1
+# define SSL_VALUE_CLASS_FEATURE_PEER_REQUEST   2
+# define SSL_VALUE_CLASS_FEATURE_NEGOTIATED     3
+
+# define SSL_VALUE_NONE                             0
+# define SSL_VALUE_QUIC_STREAM_BIDI_LOCAL_AVAIL     1
+# define SSL_VALUE_QUIC_STREAM_BIDI_REMOTE_AVAIL    2
+# define SSL_VALUE_QUIC_STREAM_UNI_LOCAL_AVAIL      3
+# define SSL_VALUE_QUIC_STREAM_UNI_REMOTE_AVAIL     4
+# define SSL_VALUE_QUIC_IDLE_TIMEOUT                5
+# define SSL_VALUE_EVENT_HANDLING_MODE              6
+# define SSL_VALUE_STREAM_WRITE_BUF_SIZE            7
+# define SSL_VALUE_STREAM_WRITE_BUF_USED            8
+# define SSL_VALUE_STREAM_WRITE_BUF_AVAIL           9
+
+# define SSL_VALUE_EVENT_HANDLING_MODE_INHERIT      0
+# define SSL_VALUE_EVENT_HANDLING_MODE_IMPLICIT     1
+# define SSL_VALUE_EVENT_HANDLING_MODE_EXPLICIT     2
+
+int SSL_get_value_uint(SSL *s, uint32_t class_, uint32_t id, uint64_t *v);
+int SSL_set_value_uint(SSL *s, uint32_t class_, uint32_t id, uint64_t v);
+
+# define SSL_get_generic_value_uint(ssl, id, v) \
+    SSL_get_value_uint((ssl), SSL_VALUE_CLASS_GENERIC, (id), (v))
+# define SSL_set_generic_value_uint(ssl, id, v) \
+    SSL_set_value_uint((ssl), SSL_VALUE_CLASS_GENERIC, (id), (v))
+# define SSL_get_feature_request_uint(ssl, id, v) \
+    SSL_get_value_uint((ssl), SSL_VALUE_CLASS_FEATURE_REQUEST, (id), (v))
+# define SSL_set_feature_request_uint(ssl, id, v) \
+    SSL_set_value_uint((ssl), SSL_VALUE_CLASS_FEATURE_REQUEST, (id), (v))
+# define SSL_get_feature_peer_request_uint(ssl, id, v) \
+    SSL_get_value_uint((ssl), SSL_VALUE_CLASS_FEATURE_PEER_REQUEST, (id), (v))
+# define SSL_get_feature_negotiated_uint(ssl, id, v) \
+    SSL_get_value_uint((ssl), SSL_VALUE_CLASS_FEATURE_NEGOTIATED, (id), (v))
+
+# define SSL_get_quic_stream_bidi_local_avail(ssl, value) \
+    SSL_get_generic_value_uint((ssl), SSL_VALUE_QUIC_STREAM_BIDI_LOCAL_AVAIL, \
+                               (value))
+# define SSL_get_quic_stream_bidi_remote_avail(ssl, value) \
+    SSL_get_generic_value_uint((ssl), SSL_VALUE_QUIC_STREAM_BIDI_REMOTE_AVAIL, \
+                               (value))
+# define SSL_get_quic_stream_uni_local_avail(ssl, value) \
+    SSL_get_generic_value_uint((ssl), SSL_VALUE_QUIC_STREAM_UNI_LOCAL_AVAIL, \
+                               (value))
+# define SSL_get_quic_stream_uni_remote_avail(ssl, value) \
+    SSL_get_generic_value_uint((ssl), SSL_VALUE_QUIC_STREAM_UNI_REMOTE_AVAIL, \
+                               (value))
+
+# define SSL_get_event_handling_mode(ssl, value) \
+    SSL_get_generic_value_uint((ssl), SSL_VALUE_EVENT_HANDLING_MODE, \
+                               (value))
+# define SSL_set_event_handling_mode(ssl, value) \
+    SSL_set_generic_value_uint((ssl), SSL_VALUE_EVENT_HANDLING_MODE, \
+                               (value))
+
+# define SSL_get_stream_write_buf_size(ssl, value) \
+    SSL_get_generic_value_uint((ssl), SSL_VALUE_STREAM_WRITE_BUF_SIZE, \
+                               (value))
+# define SSL_get_stream_write_buf_used(ssl, value) \
+    SSL_get_generic_value_uint((ssl), SSL_VALUE_STREAM_WRITE_BUF_USED, \
+                               (value))
+# define SSL_get_stream_write_buf_avail(ssl, value) \
+    SSL_get_generic_value_uint((ssl), SSL_VALUE_STREAM_WRITE_BUF_AVAIL, \
+                               (value))
+
+# define SSL_POLL_EVENT_NONE        0
+
+# define SSL_POLL_EVENT_F           (1U <<  0) /* F   (Failure) */
+# define SSL_POLL_EVENT_EL          (1U <<  1) /* EL  (Exception on Listener) */
+# define SSL_POLL_EVENT_EC          (1U <<  2) /* EC  (Exception on Conn) */
+# define SSL_POLL_EVENT_ECD         (1U <<  3) /* ECD (Exception on Conn Drained) */
+# define SSL_POLL_EVENT_ER          (1U <<  4) /* ER  (Exception on Read) */
+# define SSL_POLL_EVENT_EW          (1U <<  5) /* EW  (Exception on Write) */
+# define SSL_POLL_EVENT_R           (1U <<  6) /* R   (Readable) */
+# define SSL_POLL_EVENT_W           (1U <<  7) /* W   (Writable) */
+# define SSL_POLL_EVENT_IC          (1U <<  8) /* IC  (Incoming Connection) */
+# define SSL_POLL_EVENT_ISB         (1U <<  9) /* ISB (Incoming Stream: Bidi) */
+# define SSL_POLL_EVENT_ISU         (1U << 10) /* ISU (Incoming Stream: Uni) */
+# define SSL_POLL_EVENT_OSB         (1U << 11) /* OSB (Outgoing Stream: Bidi) */
+# define SSL_POLL_EVENT_OSU         (1U << 12) /* OSU (Outgoing Stream: Uni) */
+
+# define SSL_POLL_EVENT_RW          (SSL_POLL_EVENT_R | SSL_POLL_EVENT_W)
+# define SSL_POLL_EVENT_RE          (SSL_POLL_EVENT_R | SSL_POLL_EVENT_ER)
+# define SSL_POLL_EVENT_WE          (SSL_POLL_EVENT_W | SSL_POLL_EVENT_EW)
+# define SSL_POLL_EVENT_RWE         (SSL_POLL_EVENT_RE | SSL_POLL_EVENT_WE)
+# define SSL_POLL_EVENT_E           (SSL_POLL_EVENT_EL | SSL_POLL_EVENT_EC \
+                                     | SSL_POLL_EVENT_ER | SSL_POLL_EVENT_EW)
+# define SSL_POLL_EVENT_IS          (SSL_POLL_EVENT_ISB | SSL_POLL_EVENT_ISU)
+# define SSL_POLL_EVENT_ISE         (SSL_POLL_EVENT_IS | SSL_POLL_EVENT_EC)
+# define SSL_POLL_EVENT_I           (SSL_POLL_EVENT_IS | SSL_POLL_EVENT_IC)
+# define SSL_POLL_EVENT_OS          (SSL_POLL_EVENT_OSB | SSL_POLL_EVENT_OSU)
+# define SSL_POLL_EVENT_OSE         (SSL_POLL_EVENT_OS | SSL_POLL_EVENT_EC)
+
+typedef struct ssl_poll_item_st {
+    BIO_POLL_DESCRIPTOR desc;
+    uint64_t            events, revents;
+} SSL_POLL_ITEM;
+
+# define SSL_POLL_FLAG_NO_HANDLE_EVENTS  (1U << 0)
+
+__owur int SSL_poll(SSL_POLL_ITEM *items,
+                    size_t num_items,
+                    size_t stride,
+                    const struct timeval *timeout,
+                    uint64_t flags,
+                    size_t *result_count);
+
+static ossl_inline ossl_unused BIO_POLL_DESCRIPTOR
+SSL_as_poll_descriptor(SSL *s)
+{
+    BIO_POLL_DESCRIPTOR d;
+
+    d.type      = BIO_POLL_DESCRIPTOR_TYPE_SSL;
+    d.value.ssl = s;
+    return d;
+}
+
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#  define SSL_cache_hit(s) SSL_session_reused(s)
+# endif
+
+__owur int SSL_session_reused(const SSL *s);
+__owur int SSL_is_server(const SSL *s);
+
+__owur __owur SSL_CONF_CTX *SSL_CONF_CTX_new(void);
+int SSL_CONF_CTX_finish(SSL_CONF_CTX *cctx);
+void SSL_CONF_CTX_free(SSL_CONF_CTX *cctx);
+unsigned int SSL_CONF_CTX_set_flags(SSL_CONF_CTX *cctx, unsigned int flags);
+__owur unsigned int SSL_CONF_CTX_clear_flags(SSL_CONF_CTX *cctx,
+                                             unsigned int flags);
+__owur int SSL_CONF_CTX_set1_prefix(SSL_CONF_CTX *cctx, const char *pre);
+
+void SSL_CONF_CTX_set_ssl(SSL_CONF_CTX *cctx, SSL *ssl);
+void SSL_CONF_CTX_set_ssl_ctx(SSL_CONF_CTX *cctx, SSL_CTX *ctx);
+
+__owur int SSL_CONF_cmd(SSL_CONF_CTX *cctx, const char *cmd, const char *value);
+__owur int SSL_CONF_cmd_argv(SSL_CONF_CTX *cctx, int *pargc, char ***pargv);
+__owur int SSL_CONF_cmd_value_type(SSL_CONF_CTX *cctx, const char *cmd);
+
+void SSL_add_ssl_module(void);
+int SSL_config(SSL *s, const char *name);
+int SSL_CTX_config(SSL_CTX *ctx, const char *name);
+
+# ifndef OPENSSL_NO_SSL_TRACE
+void SSL_trace(int write_p, int version, int content_type,
+               const void *buf, size_t len, SSL *ssl, void *arg);
+# endif
+
+# ifndef OPENSSL_NO_SOCK
+int DTLSv1_listen(SSL *s, BIO_ADDR *client);
+# endif
+
+# ifndef OPENSSL_NO_CT
+
+/*
+ * A callback for verifying that the received SCTs are sufficient.
+ * Expected to return 1 if they are sufficient, otherwise 0.
+ * May return a negative integer if an error occurs.
+ * A connection should be aborted if the SCTs are deemed insufficient.
+ */
+typedef int (*ssl_ct_validation_cb)(const CT_POLICY_EVAL_CTX *ctx,
+                                    const STACK_OF(SCT) *scts, void *arg);
+
+/*
+ * Sets a |callback| that is invoked upon receipt of ServerHelloDone to validate
+ * the received SCTs.
+ * If the callback returns a non-positive result, the connection is terminated.
+ * Call this function before beginning a handshake.
+ * If a NULL |callback| is provided, SCT validation is disabled.
+ * |arg| is arbitrary userdata that will be passed to the callback whenever it
+ * is invoked. Ownership of |arg| remains with the caller.
+ *
+ * NOTE: A side-effect of setting a CT callback is that an OCSP stapled response
+ *       will be requested.
+ */
+int SSL_set_ct_validation_callback(SSL *s, ssl_ct_validation_cb callback,
+                                   void *arg);
+int SSL_CTX_set_ct_validation_callback(SSL_CTX *ctx,
+                                       ssl_ct_validation_cb callback,
+                                       void *arg);
+#define SSL_disable_ct(s) \
+        ((void) SSL_set_validation_callback((s), NULL, NULL))
+#define SSL_CTX_disable_ct(ctx) \
+        ((void) SSL_CTX_set_validation_callback((ctx), NULL, NULL))
+
+/*
+ * The validation type enumerates the available behaviours of the built-in SSL
+ * CT validation callback selected via SSL_enable_ct() and SSL_CTX_enable_ct().
+ * The underlying callback is a static function in libssl.
+ */
+enum {
+    SSL_CT_VALIDATION_PERMISSIVE = 0,
+    SSL_CT_VALIDATION_STRICT
+};
+
+/*
+ * Enable CT by setting up a callback that implements one of the built-in
+ * validation variants.  The SSL_CT_VALIDATION_PERMISSIVE variant always
+ * continues the handshake, the application can make appropriate decisions at
+ * handshake completion.  The SSL_CT_VALIDATION_STRICT variant requires at
+ * least one valid SCT, or else handshake termination will be requested.  The
+ * handshake may continue anyway if SSL_VERIFY_NONE is in effect.
+ */
+int SSL_enable_ct(SSL *s, int validation_mode);
+int SSL_CTX_enable_ct(SSL_CTX *ctx, int validation_mode);
+
+/*
+ * Report whether a non-NULL callback is enabled.
+ */
+int SSL_ct_is_enabled(const SSL *s);
+int SSL_CTX_ct_is_enabled(const SSL_CTX *ctx);
+
+/* Gets the SCTs received from a connection */
+const STACK_OF(SCT) *SSL_get0_peer_scts(SSL *s);
+
+/*
+ * Loads the CT log list from the default location.
+ * If a CTLOG_STORE has previously been set using SSL_CTX_set_ctlog_store,
+ * the log information loaded from this file will be appended to the
+ * CTLOG_STORE.
+ * Returns 1 on success, 0 otherwise.
+ */
+int SSL_CTX_set_default_ctlog_list_file(SSL_CTX *ctx);
+
+/*
+ * Loads the CT log list from the specified file path.
+ * If a CTLOG_STORE has previously been set using SSL_CTX_set_ctlog_store,
+ * the log information loaded from this file will be appended to the
+ * CTLOG_STORE.
+ * Returns 1 on success, 0 otherwise.
+ */
+int SSL_CTX_set_ctlog_list_file(SSL_CTX *ctx, const char *path);
+
+/*
+ * Sets the CT log list used by all SSL connections created from this SSL_CTX.
+ * Ownership of the CTLOG_STORE is transferred to the SSL_CTX.
+ */
+void SSL_CTX_set0_ctlog_store(SSL_CTX *ctx, CTLOG_STORE *logs);
+
+/*
+ * Gets the CT log list used by all SSL connections created from this SSL_CTX.
+ * This will be NULL unless one of the following functions has been called:
+ * - SSL_CTX_set_default_ctlog_list_file
+ * - SSL_CTX_set_ctlog_list_file
+ * - SSL_CTX_set_ctlog_store
+ */
+const CTLOG_STORE *SSL_CTX_get0_ctlog_store(const SSL_CTX *ctx);
+
+# endif /* OPENSSL_NO_CT */
+
+/* What the "other" parameter contains in security callback */
+/* Mask for type */
+# define SSL_SECOP_OTHER_TYPE    0xffff0000
+# define SSL_SECOP_OTHER_NONE    0
+# define SSL_SECOP_OTHER_CIPHER  (1 << 16)
+# define SSL_SECOP_OTHER_CURVE   (2 << 16)
+# define SSL_SECOP_OTHER_DH      (3 << 16)
+# define SSL_SECOP_OTHER_PKEY    (4 << 16)
+# define SSL_SECOP_OTHER_SIGALG  (5 << 16)
+# define SSL_SECOP_OTHER_CERT    (6 << 16)
+
+/* Indicated operation refers to peer key or certificate */
+# define SSL_SECOP_PEER          0x1000
+
+/* Values for "op" parameter in security callback */
+
+/* Called to filter ciphers */
+/* Ciphers client supports */
+# define SSL_SECOP_CIPHER_SUPPORTED      (1 | SSL_SECOP_OTHER_CIPHER)
+/* Cipher shared by client/server */
+# define SSL_SECOP_CIPHER_SHARED         (2 | SSL_SECOP_OTHER_CIPHER)
+/* Sanity check of cipher server selects */
+# define SSL_SECOP_CIPHER_CHECK          (3 | SSL_SECOP_OTHER_CIPHER)
+/* Curves supported by client */
+# define SSL_SECOP_CURVE_SUPPORTED       (4 | SSL_SECOP_OTHER_CURVE)
+/* Curves shared by client/server */
+# define SSL_SECOP_CURVE_SHARED          (5 | SSL_SECOP_OTHER_CURVE)
+/* Sanity check of curve server selects */
+# define SSL_SECOP_CURVE_CHECK           (6 | SSL_SECOP_OTHER_CURVE)
+/* Temporary DH key */
+# define SSL_SECOP_TMP_DH                (7 | SSL_SECOP_OTHER_PKEY)
+/* SSL/TLS version */
+# define SSL_SECOP_VERSION               (9 | SSL_SECOP_OTHER_NONE)
+/* Session tickets */
+# define SSL_SECOP_TICKET                (10 | SSL_SECOP_OTHER_NONE)
+/* Supported signature algorithms sent to peer */
+# define SSL_SECOP_SIGALG_SUPPORTED      (11 | SSL_SECOP_OTHER_SIGALG)
+/* Shared signature algorithm */
+# define SSL_SECOP_SIGALG_SHARED         (12 | SSL_SECOP_OTHER_SIGALG)
+/* Sanity check signature algorithm allowed */
+# define SSL_SECOP_SIGALG_CHECK          (13 | SSL_SECOP_OTHER_SIGALG)
+/* Used to get mask of supported public key signature algorithms */
+# define SSL_SECOP_SIGALG_MASK           (14 | SSL_SECOP_OTHER_SIGALG)
+/* Use to see if compression is allowed */
+# define SSL_SECOP_COMPRESSION           (15 | SSL_SECOP_OTHER_NONE)
+/* EE key in certificate */
+# define SSL_SECOP_EE_KEY                (16 | SSL_SECOP_OTHER_CERT)
+/* CA key in certificate */
+# define SSL_SECOP_CA_KEY                (17 | SSL_SECOP_OTHER_CERT)
+/* CA digest algorithm in certificate */
+# define SSL_SECOP_CA_MD                 (18 | SSL_SECOP_OTHER_CERT)
+/* Peer EE key in certificate */
+# define SSL_SECOP_PEER_EE_KEY           (SSL_SECOP_EE_KEY | SSL_SECOP_PEER)
+/* Peer CA key in certificate */
+# define SSL_SECOP_PEER_CA_KEY           (SSL_SECOP_CA_KEY | SSL_SECOP_PEER)
+/* Peer CA digest algorithm in certificate */
+# define SSL_SECOP_PEER_CA_MD            (SSL_SECOP_CA_MD | SSL_SECOP_PEER)
+
+void SSL_set_security_level(SSL *s, int level);
+__owur int SSL_get_security_level(const SSL *s);
+void SSL_set_security_callback(SSL *s,
+                               int (*cb) (const SSL *s, const SSL_CTX *ctx,
+                                          int op, int bits, int nid,
+                                          void *other, void *ex));
+int (*SSL_get_security_callback(const SSL *s)) (const SSL *s,
+                                                const SSL_CTX *ctx, int op,
+                                                int bits, int nid, void *other,
+                                                void *ex);
+void SSL_set0_security_ex_data(SSL *s, void *ex);
+__owur void *SSL_get0_security_ex_data(const SSL *s);
+
+void SSL_CTX_set_security_level(SSL_CTX *ctx, int level);
+__owur int SSL_CTX_get_security_level(const SSL_CTX *ctx);
+void SSL_CTX_set_security_callback(SSL_CTX *ctx,
+                                   int (*cb) (const SSL *s, const SSL_CTX *ctx,
+                                              int op, int bits, int nid,
+                                              void *other, void *ex));
+int (*SSL_CTX_get_security_callback(const SSL_CTX *ctx)) (const SSL *s,
+                                                          const SSL_CTX *ctx,
+                                                          int op, int bits,
+                                                          int nid,
+                                                          void *other,
+                                                          void *ex);
+void SSL_CTX_set0_security_ex_data(SSL_CTX *ctx, void *ex);
+__owur void *SSL_CTX_get0_security_ex_data(const SSL_CTX *ctx);
+
+/* OPENSSL_INIT flag 0x010000 reserved for internal use */
+# define OPENSSL_INIT_NO_LOAD_SSL_STRINGS    0x00100000L
+# define OPENSSL_INIT_LOAD_SSL_STRINGS       0x00200000L
+
+# define OPENSSL_INIT_SSL_DEFAULT \
+        (OPENSSL_INIT_LOAD_SSL_STRINGS | OPENSSL_INIT_LOAD_CRYPTO_STRINGS)
+
+int OPENSSL_init_ssl(uint64_t opts, const OPENSSL_INIT_SETTINGS *settings);
+
+# ifndef OPENSSL_NO_UNIT_TEST
+__owur const struct openssl_ssl_test_functions *SSL_test_functions(void);
+# endif
+
+__owur int SSL_free_buffers(SSL *ssl);
+__owur int SSL_alloc_buffers(SSL *ssl);
+
+/* Status codes passed to the decrypt session ticket callback. Some of these
+ * are for internal use only and are never passed to the callback. */
+typedef int SSL_TICKET_STATUS;
+
+/* Support for ticket appdata */
+/* fatal error, malloc failure */
+# define SSL_TICKET_FATAL_ERR_MALLOC 0
+/* fatal error, either from parsing or decrypting the ticket */
+# define SSL_TICKET_FATAL_ERR_OTHER  1
+/* No ticket present */
+# define SSL_TICKET_NONE             2
+/* Empty ticket present */
+# define SSL_TICKET_EMPTY            3
+/* the ticket couldn't be decrypted */
+# define SSL_TICKET_NO_DECRYPT       4
+/* a ticket was successfully decrypted */
+# define SSL_TICKET_SUCCESS          5
+/* same as above but the ticket needs to be renewed */
+# define SSL_TICKET_SUCCESS_RENEW    6
+
+/* Return codes for the decrypt session ticket callback */
+typedef int SSL_TICKET_RETURN;
+
+/* An error occurred */
+#define SSL_TICKET_RETURN_ABORT             0
+/* Do not use the ticket, do not send a renewed ticket to the client */
+#define SSL_TICKET_RETURN_IGNORE            1
+/* Do not use the ticket, send a renewed ticket to the client */
+#define SSL_TICKET_RETURN_IGNORE_RENEW      2
+/* Use the ticket, do not send a renewed ticket to the client */
+#define SSL_TICKET_RETURN_USE               3
+/* Use the ticket, send a renewed ticket to the client */
+#define SSL_TICKET_RETURN_USE_RENEW         4
+
+typedef int (*SSL_CTX_generate_session_ticket_fn)(SSL *s, void *arg);
+typedef SSL_TICKET_RETURN (*SSL_CTX_decrypt_session_ticket_fn)(SSL *s, SSL_SESSION *ss,
+                                                               const unsigned char *keyname,
+                                                               size_t keyname_length,
+                                                               SSL_TICKET_STATUS status,
+                                                               void *arg);
+int SSL_CTX_set_session_ticket_cb(SSL_CTX *ctx,
+                                  SSL_CTX_generate_session_ticket_fn gen_cb,
+                                  SSL_CTX_decrypt_session_ticket_fn dec_cb,
+                                  void *arg);
+int SSL_SESSION_set1_ticket_appdata(SSL_SESSION *ss, const void *data, size_t len);
+int SSL_SESSION_get0_ticket_appdata(SSL_SESSION *ss, void **data, size_t *len);
+
+typedef unsigned int (*DTLS_timer_cb)(SSL *s, unsigned int timer_us);
+
+void DTLS_set_timer_cb(SSL *s, DTLS_timer_cb cb);
+
+
+typedef int (*SSL_allow_early_data_cb_fn)(SSL *s, void *arg);
+void SSL_CTX_set_allow_early_data_cb(SSL_CTX *ctx,
+                                     SSL_allow_early_data_cb_fn cb,
+                                     void *arg);
+void SSL_set_allow_early_data_cb(SSL *s,
+                                 SSL_allow_early_data_cb_fn cb,
+                                 void *arg);
+
+/* store the default cipher strings inside the library */
+const char *OSSL_default_cipher_list(void);
+const char *OSSL_default_ciphersuites(void);
+
+/* RFC8879 Certificate compression APIs */
+
+int SSL_CTX_compress_certs(SSL_CTX *ctx, int alg);
+int SSL_compress_certs(SSL *ssl, int alg);
+
+int SSL_CTX_set1_cert_comp_preference(SSL_CTX *ctx, int *algs, size_t len);
+int SSL_set1_cert_comp_preference(SSL *ssl, int *algs, size_t len);
+
+int SSL_CTX_set1_compressed_cert(SSL_CTX *ctx, int algorithm, unsigned char *comp_data,
+                                size_t comp_length, size_t orig_length);
+int SSL_set1_compressed_cert(SSL *ssl, int algorithm, unsigned char *comp_data,
+                            size_t comp_length, size_t orig_length);
+size_t SSL_CTX_get1_compressed_cert(SSL_CTX *ctx, int alg, unsigned char **data, size_t *orig_len);
+size_t SSL_get1_compressed_cert(SSL *ssl, int alg, unsigned char **data, size_t *orig_len);
+
+__owur int SSL_add_expected_rpk(SSL *s, EVP_PKEY *rpk);
+__owur EVP_PKEY *SSL_get0_peer_rpk(const SSL *s);
+__owur EVP_PKEY *SSL_SESSION_get0_peer_rpk(SSL_SESSION *s);
+__owur int SSL_get_negotiated_client_cert_type(const SSL *s);
+__owur int SSL_get_negotiated_server_cert_type(const SSL *s);
+
+__owur int SSL_set1_client_cert_type(SSL *s, const unsigned char *val, size_t len);
+__owur int SSL_set1_server_cert_type(SSL *s, const unsigned char *val, size_t len);
+__owur int SSL_CTX_set1_client_cert_type(SSL_CTX *ctx, const unsigned char *val, size_t len);
+__owur int SSL_CTX_set1_server_cert_type(SSL_CTX *ctx, const unsigned char *val, size_t len);
+__owur int SSL_get0_client_cert_type(const SSL *s, unsigned char **t, size_t *len);
+__owur int SSL_get0_server_cert_type(const SSL *s, unsigned char **t, size_t *len);
+__owur int SSL_CTX_get0_client_cert_type(const SSL_CTX *ctx, unsigned char **t, size_t *len);
+__owur int SSL_CTX_get0_server_cert_type(const SSL_CTX *s, unsigned char **t, size_t *len);
+
+# ifdef  __cplusplus
+}
+# endif
+#endif
diff --git a/src/include/openssl/ssl2.h b/src/include/openssl/ssl2.h
new file mode 100644
index 0000000..428ead0
--- /dev/null
+++ b/src/include/openssl/ssl2.h
@@ -0,0 +1,30 @@
+/*
+ * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_SSL2_H
+# define OPENSSL_SSL2_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_SSL2_H
+# endif
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+# define SSL2_VERSION            0x0002
+
+# define SSL2_MT_CLIENT_HELLO            1
+
+#ifdef  __cplusplus
+}
+#endif
+#endif
diff --git a/src/include/openssl/ssl3.h b/src/include/openssl/ssl3.h
new file mode 100644
index 0000000..4f076c6
--- /dev/null
+++ b/src/include/openssl/ssl3.h
@@ -0,0 +1,357 @@
+/*
+ * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_SSL3_H
+# define OPENSSL_SSL3_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_SSL3_H
+# endif
+
+# include <openssl/comp.h>
+# include <openssl/buffer.h>
+# include <openssl/evp.h>
+# include <openssl/ssl.h>
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Signalling cipher suite value from RFC 5746
+ * (TLS_EMPTY_RENEGOTIATION_INFO_SCSV)
+ */
+# define SSL3_CK_SCSV                            0x030000FF
+
+/*
+ * Signalling cipher suite value from draft-ietf-tls-downgrade-scsv-00
+ * (TLS_FALLBACK_SCSV)
+ */
+# define SSL3_CK_FALLBACK_SCSV                   0x03005600
+
+# define SSL3_CK_RSA_NULL_MD5                    0x03000001
+# define SSL3_CK_RSA_NULL_SHA                    0x03000002
+# define SSL3_CK_RSA_RC4_40_MD5                  0x03000003
+# define SSL3_CK_RSA_RC4_128_MD5                 0x03000004
+# define SSL3_CK_RSA_RC4_128_SHA                 0x03000005
+# define SSL3_CK_RSA_RC2_40_MD5                  0x03000006
+# define SSL3_CK_RSA_IDEA_128_SHA                0x03000007
+# define SSL3_CK_RSA_DES_40_CBC_SHA              0x03000008
+# define SSL3_CK_RSA_DES_64_CBC_SHA              0x03000009
+# define SSL3_CK_RSA_DES_192_CBC3_SHA            0x0300000A
+
+# define SSL3_CK_DH_DSS_DES_40_CBC_SHA           0x0300000B
+# define SSL3_CK_DH_DSS_DES_64_CBC_SHA           0x0300000C
+# define SSL3_CK_DH_DSS_DES_192_CBC3_SHA         0x0300000D
+# define SSL3_CK_DH_RSA_DES_40_CBC_SHA           0x0300000E
+# define SSL3_CK_DH_RSA_DES_64_CBC_SHA           0x0300000F
+# define SSL3_CK_DH_RSA_DES_192_CBC3_SHA         0x03000010
+
+# define SSL3_CK_DHE_DSS_DES_40_CBC_SHA          0x03000011
+# define SSL3_CK_EDH_DSS_DES_40_CBC_SHA          SSL3_CK_DHE_DSS_DES_40_CBC_SHA
+# define SSL3_CK_DHE_DSS_DES_64_CBC_SHA          0x03000012
+# define SSL3_CK_EDH_DSS_DES_64_CBC_SHA          SSL3_CK_DHE_DSS_DES_64_CBC_SHA
+# define SSL3_CK_DHE_DSS_DES_192_CBC3_SHA        0x03000013
+# define SSL3_CK_EDH_DSS_DES_192_CBC3_SHA        SSL3_CK_DHE_DSS_DES_192_CBC3_SHA
+# define SSL3_CK_DHE_RSA_DES_40_CBC_SHA          0x03000014
+# define SSL3_CK_EDH_RSA_DES_40_CBC_SHA          SSL3_CK_DHE_RSA_DES_40_CBC_SHA
+# define SSL3_CK_DHE_RSA_DES_64_CBC_SHA          0x03000015
+# define SSL3_CK_EDH_RSA_DES_64_CBC_SHA          SSL3_CK_DHE_RSA_DES_64_CBC_SHA
+# define SSL3_CK_DHE_RSA_DES_192_CBC3_SHA        0x03000016
+# define SSL3_CK_EDH_RSA_DES_192_CBC3_SHA        SSL3_CK_DHE_RSA_DES_192_CBC3_SHA
+
+# define SSL3_CK_ADH_RC4_40_MD5                  0x03000017
+# define SSL3_CK_ADH_RC4_128_MD5                 0x03000018
+# define SSL3_CK_ADH_DES_40_CBC_SHA              0x03000019
+# define SSL3_CK_ADH_DES_64_CBC_SHA              0x0300001A
+# define SSL3_CK_ADH_DES_192_CBC_SHA             0x0300001B
+
+/* a bundle of RFC standard cipher names, generated from ssl3_ciphers[] */
+# define SSL3_RFC_RSA_NULL_MD5                   "TLS_RSA_WITH_NULL_MD5"
+# define SSL3_RFC_RSA_NULL_SHA                   "TLS_RSA_WITH_NULL_SHA"
+# define SSL3_RFC_RSA_DES_192_CBC3_SHA           "TLS_RSA_WITH_3DES_EDE_CBC_SHA"
+# define SSL3_RFC_DHE_DSS_DES_192_CBC3_SHA       "TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHA"
+# define SSL3_RFC_DHE_RSA_DES_192_CBC3_SHA       "TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA"
+# define SSL3_RFC_ADH_DES_192_CBC_SHA            "TLS_DH_anon_WITH_3DES_EDE_CBC_SHA"
+# define SSL3_RFC_RSA_IDEA_128_SHA               "TLS_RSA_WITH_IDEA_CBC_SHA"
+# define SSL3_RFC_RSA_RC4_128_MD5                "TLS_RSA_WITH_RC4_128_MD5"
+# define SSL3_RFC_RSA_RC4_128_SHA                "TLS_RSA_WITH_RC4_128_SHA"
+# define SSL3_RFC_ADH_RC4_128_MD5                "TLS_DH_anon_WITH_RC4_128_MD5"
+
+# define SSL3_TXT_RSA_NULL_MD5                   "NULL-MD5"
+# define SSL3_TXT_RSA_NULL_SHA                   "NULL-SHA"
+# define SSL3_TXT_RSA_RC4_40_MD5                 "EXP-RC4-MD5"
+# define SSL3_TXT_RSA_RC4_128_MD5                "RC4-MD5"
+# define SSL3_TXT_RSA_RC4_128_SHA                "RC4-SHA"
+# define SSL3_TXT_RSA_RC2_40_MD5                 "EXP-RC2-CBC-MD5"
+# define SSL3_TXT_RSA_IDEA_128_SHA               "IDEA-CBC-SHA"
+# define SSL3_TXT_RSA_DES_40_CBC_SHA             "EXP-DES-CBC-SHA"
+# define SSL3_TXT_RSA_DES_64_CBC_SHA             "DES-CBC-SHA"
+# define SSL3_TXT_RSA_DES_192_CBC3_SHA           "DES-CBC3-SHA"
+
+# define SSL3_TXT_DH_DSS_DES_40_CBC_SHA          "EXP-DH-DSS-DES-CBC-SHA"
+# define SSL3_TXT_DH_DSS_DES_64_CBC_SHA          "DH-DSS-DES-CBC-SHA"
+# define SSL3_TXT_DH_DSS_DES_192_CBC3_SHA        "DH-DSS-DES-CBC3-SHA"
+# define SSL3_TXT_DH_RSA_DES_40_CBC_SHA          "EXP-DH-RSA-DES-CBC-SHA"
+# define SSL3_TXT_DH_RSA_DES_64_CBC_SHA          "DH-RSA-DES-CBC-SHA"
+# define SSL3_TXT_DH_RSA_DES_192_CBC3_SHA        "DH-RSA-DES-CBC3-SHA"
+
+# define SSL3_TXT_DHE_DSS_DES_40_CBC_SHA         "EXP-DHE-DSS-DES-CBC-SHA"
+# define SSL3_TXT_DHE_DSS_DES_64_CBC_SHA         "DHE-DSS-DES-CBC-SHA"
+# define SSL3_TXT_DHE_DSS_DES_192_CBC3_SHA       "DHE-DSS-DES-CBC3-SHA"
+# define SSL3_TXT_DHE_RSA_DES_40_CBC_SHA         "EXP-DHE-RSA-DES-CBC-SHA"
+# define SSL3_TXT_DHE_RSA_DES_64_CBC_SHA         "DHE-RSA-DES-CBC-SHA"
+# define SSL3_TXT_DHE_RSA_DES_192_CBC3_SHA       "DHE-RSA-DES-CBC3-SHA"
+
+/*
+ * This next block of six "EDH" labels is for backward compatibility with
+ * older versions of OpenSSL.  New code should use the six "DHE" labels above
+ * instead:
+ */
+# define SSL3_TXT_EDH_DSS_DES_40_CBC_SHA         "EXP-EDH-DSS-DES-CBC-SHA"
+# define SSL3_TXT_EDH_DSS_DES_64_CBC_SHA         "EDH-DSS-DES-CBC-SHA"
+# define SSL3_TXT_EDH_DSS_DES_192_CBC3_SHA       "EDH-DSS-DES-CBC3-SHA"
+# define SSL3_TXT_EDH_RSA_DES_40_CBC_SHA         "EXP-EDH-RSA-DES-CBC-SHA"
+# define SSL3_TXT_EDH_RSA_DES_64_CBC_SHA         "EDH-RSA-DES-CBC-SHA"
+# define SSL3_TXT_EDH_RSA_DES_192_CBC3_SHA       "EDH-RSA-DES-CBC3-SHA"
+
+# define SSL3_TXT_ADH_RC4_40_MD5                 "EXP-ADH-RC4-MD5"
+# define SSL3_TXT_ADH_RC4_128_MD5                "ADH-RC4-MD5"
+# define SSL3_TXT_ADH_DES_40_CBC_SHA             "EXP-ADH-DES-CBC-SHA"
+# define SSL3_TXT_ADH_DES_64_CBC_SHA             "ADH-DES-CBC-SHA"
+# define SSL3_TXT_ADH_DES_192_CBC_SHA            "ADH-DES-CBC3-SHA"
+
+# define SSL3_SSL_SESSION_ID_LENGTH              32
+# define SSL3_MAX_SSL_SESSION_ID_LENGTH          32
+
+# define SSL3_MASTER_SECRET_SIZE                 48
+# define SSL3_RANDOM_SIZE                        32
+# define SSL3_SESSION_ID_SIZE                    32
+# define SSL3_RT_HEADER_LENGTH                   5
+
+# define SSL3_HM_HEADER_LENGTH                  4
+
+# ifndef SSL3_ALIGN_PAYLOAD
+ /*
+  * Some will argue that this increases memory footprint, but it's not
+  * actually true. Point is that malloc has to return at least 64-bit aligned
+  * pointers, meaning that allocating 5 bytes wastes 3 bytes in either case.
+  * Suggested pre-gaping simply moves these wasted bytes from the end of
+  * allocated region to its front, but makes data payload aligned, which
+  * improves performance:-)
+  */
+#  define SSL3_ALIGN_PAYLOAD                     8
+# else
+#  if (SSL3_ALIGN_PAYLOAD&(SSL3_ALIGN_PAYLOAD-1))!=0
+#   error "insane SSL3_ALIGN_PAYLOAD"
+#   undef SSL3_ALIGN_PAYLOAD
+#  endif
+# endif
+
+/*
+ * This is the maximum MAC (digest) size used by the SSL library. Currently
+ * maximum of 20 is used by SHA1, but we reserve for future extension for
+ * 512-bit hashes.
+ */
+
+# define SSL3_RT_MAX_MD_SIZE                     64
+
+/*
+ * Maximum block size used in all ciphersuites. Currently 16 for AES.
+ */
+
+# define SSL_RT_MAX_CIPHER_BLOCK_SIZE            16
+
+# define SSL3_RT_MAX_EXTRA                       (16384)
+
+/* Maximum plaintext length: defined by SSL/TLS standards */
+# define SSL3_RT_MAX_PLAIN_LENGTH                16384
+/* Maximum compression overhead: defined by SSL/TLS standards */
+# define SSL3_RT_MAX_COMPRESSED_OVERHEAD         1024
+
+/*
+ * The standards give a maximum encryption overhead of 1024 bytes. In
+ * practice the value is lower than this. The overhead is the maximum number
+ * of padding bytes (256) plus the mac size.
+ */
+# define SSL3_RT_MAX_ENCRYPTED_OVERHEAD        (256 + SSL3_RT_MAX_MD_SIZE)
+# define SSL3_RT_MAX_TLS13_ENCRYPTED_OVERHEAD  256
+
+/*
+ * OpenSSL currently only uses a padding length of at most one block so the
+ * send overhead is smaller.
+ */
+
+# define SSL3_RT_SEND_MAX_ENCRYPTED_OVERHEAD \
+                        (SSL_RT_MAX_CIPHER_BLOCK_SIZE + SSL3_RT_MAX_MD_SIZE)
+
+/* If compression isn't used don't include the compression overhead */
+
+# ifdef OPENSSL_NO_COMP
+#  define SSL3_RT_MAX_COMPRESSED_LENGTH           SSL3_RT_MAX_PLAIN_LENGTH
+# else
+#  define SSL3_RT_MAX_COMPRESSED_LENGTH   \
+            (SSL3_RT_MAX_PLAIN_LENGTH+SSL3_RT_MAX_COMPRESSED_OVERHEAD)
+# endif
+# define SSL3_RT_MAX_ENCRYPTED_LENGTH    \
+            (SSL3_RT_MAX_ENCRYPTED_OVERHEAD+SSL3_RT_MAX_COMPRESSED_LENGTH)
+# define SSL3_RT_MAX_TLS13_ENCRYPTED_LENGTH \
+            (SSL3_RT_MAX_PLAIN_LENGTH + SSL3_RT_MAX_TLS13_ENCRYPTED_OVERHEAD)
+# define SSL3_RT_MAX_PACKET_SIZE         \
+            (SSL3_RT_MAX_ENCRYPTED_LENGTH+SSL3_RT_HEADER_LENGTH)
+
+# define SSL3_MD_CLIENT_FINISHED_CONST   "\x43\x4C\x4E\x54"
+# define SSL3_MD_SERVER_FINISHED_CONST   "\x53\x52\x56\x52"
+
+/* SSL3_VERSION is defined in prov_ssl.h */
+# define SSL3_VERSION_MAJOR              0x03
+# define SSL3_VERSION_MINOR              0x00
+
+# define SSL3_RT_CHANGE_CIPHER_SPEC      20
+# define SSL3_RT_ALERT                   21
+# define SSL3_RT_HANDSHAKE               22
+# define SSL3_RT_APPLICATION_DATA        23
+
+/* Pseudo content types to indicate additional parameters */
+# define TLS1_RT_CRYPTO                  0x1000
+# define TLS1_RT_CRYPTO_PREMASTER        (TLS1_RT_CRYPTO | 0x1)
+# define TLS1_RT_CRYPTO_CLIENT_RANDOM    (TLS1_RT_CRYPTO | 0x2)
+# define TLS1_RT_CRYPTO_SERVER_RANDOM    (TLS1_RT_CRYPTO | 0x3)
+# define TLS1_RT_CRYPTO_MASTER           (TLS1_RT_CRYPTO | 0x4)
+
+# define TLS1_RT_CRYPTO_READ             0x0000
+# define TLS1_RT_CRYPTO_WRITE            0x0100
+# define TLS1_RT_CRYPTO_MAC              (TLS1_RT_CRYPTO | 0x5)
+# define TLS1_RT_CRYPTO_KEY              (TLS1_RT_CRYPTO | 0x6)
+# define TLS1_RT_CRYPTO_IV               (TLS1_RT_CRYPTO | 0x7)
+# define TLS1_RT_CRYPTO_FIXED_IV         (TLS1_RT_CRYPTO | 0x8)
+
+/* Pseudo content types for SSL/TLS header info */
+# define SSL3_RT_HEADER                  0x100
+# define SSL3_RT_INNER_CONTENT_TYPE      0x101
+
+/* Pseudo content types for QUIC */
+# define SSL3_RT_QUIC_DATAGRAM            0x200
+# define SSL3_RT_QUIC_PACKET              0x201
+# define SSL3_RT_QUIC_FRAME_FULL          0x202
+# define SSL3_RT_QUIC_FRAME_HEADER        0x203
+# define SSL3_RT_QUIC_FRAME_PADDING       0x204
+
+# define SSL3_AL_WARNING                 1
+# define SSL3_AL_FATAL                   2
+
+# define SSL3_AD_CLOSE_NOTIFY             0
+# define SSL3_AD_UNEXPECTED_MESSAGE      10/* fatal */
+# define SSL3_AD_BAD_RECORD_MAC          20/* fatal */
+# define SSL3_AD_DECOMPRESSION_FAILURE   30/* fatal */
+# define SSL3_AD_HANDSHAKE_FAILURE       40/* fatal */
+# define SSL3_AD_NO_CERTIFICATE          41
+# define SSL3_AD_BAD_CERTIFICATE         42
+# define SSL3_AD_UNSUPPORTED_CERTIFICATE 43
+# define SSL3_AD_CERTIFICATE_REVOKED     44
+# define SSL3_AD_CERTIFICATE_EXPIRED     45
+# define SSL3_AD_CERTIFICATE_UNKNOWN     46
+# define SSL3_AD_ILLEGAL_PARAMETER       47/* fatal */
+
+# define TLS1_HB_REQUEST         1
+# define TLS1_HB_RESPONSE        2
+
+
+# define SSL3_CT_RSA_SIGN                        1
+# define SSL3_CT_DSS_SIGN                        2
+# define SSL3_CT_RSA_FIXED_DH                    3
+# define SSL3_CT_DSS_FIXED_DH                    4
+# define SSL3_CT_RSA_EPHEMERAL_DH                5
+# define SSL3_CT_DSS_EPHEMERAL_DH                6
+# define SSL3_CT_FORTEZZA_DMS                    20
+/*
+ * SSL3_CT_NUMBER is used to size arrays and it must be large enough to
+ * contain all of the cert types defined for *either* SSLv3 and TLSv1.
+ */
+# define SSL3_CT_NUMBER                  12
+
+# if defined(TLS_CT_NUMBER)
+#  if TLS_CT_NUMBER != SSL3_CT_NUMBER
+#    error "SSL/TLS CT_NUMBER values do not match"
+#  endif
+# endif
+
+/* No longer used as of OpenSSL 1.1.1 */
+# define SSL3_FLAGS_NO_RENEGOTIATE_CIPHERS       0x0001
+
+/* Removed from OpenSSL 1.1.0 */
+# define TLS1_FLAGS_TLS_PADDING_BUG              0x0
+
+# define TLS1_FLAGS_SKIP_CERT_VERIFY             0x0010
+
+/* Set if we encrypt then mac instead of usual mac then encrypt */
+# define TLS1_FLAGS_ENCRYPT_THEN_MAC_READ        0x0100
+# define TLS1_FLAGS_ENCRYPT_THEN_MAC             TLS1_FLAGS_ENCRYPT_THEN_MAC_READ
+
+/* Set if extended master secret extension received from peer */
+# define TLS1_FLAGS_RECEIVED_EXTMS               0x0200
+
+# define TLS1_FLAGS_ENCRYPT_THEN_MAC_WRITE       0x0400
+
+# define TLS1_FLAGS_STATELESS                    0x0800
+
+/* Set if extended master secret extension required on renegotiation */
+# define TLS1_FLAGS_REQUIRED_EXTMS               0x1000
+
+/* 0x2000 is reserved for TLS1_FLAGS_QUIC (internal) */
+
+# define SSL3_MT_HELLO_REQUEST                   0
+# define SSL3_MT_CLIENT_HELLO                    1
+# define SSL3_MT_SERVER_HELLO                    2
+# define SSL3_MT_NEWSESSION_TICKET               4
+# define SSL3_MT_END_OF_EARLY_DATA               5
+# define SSL3_MT_ENCRYPTED_EXTENSIONS            8
+# define SSL3_MT_CERTIFICATE                     11
+# define SSL3_MT_SERVER_KEY_EXCHANGE             12
+# define SSL3_MT_CERTIFICATE_REQUEST             13
+# define SSL3_MT_SERVER_DONE                     14
+# define SSL3_MT_CERTIFICATE_VERIFY              15
+# define SSL3_MT_CLIENT_KEY_EXCHANGE             16
+# define SSL3_MT_FINISHED                        20
+# define SSL3_MT_CERTIFICATE_URL                 21
+# define SSL3_MT_CERTIFICATE_STATUS              22
+# define SSL3_MT_SUPPLEMENTAL_DATA               23
+# define SSL3_MT_KEY_UPDATE                      24
+# define SSL3_MT_COMPRESSED_CERTIFICATE          25
+# ifndef OPENSSL_NO_NEXTPROTONEG
+#  define SSL3_MT_NEXT_PROTO                     67
+# endif
+# define SSL3_MT_MESSAGE_HASH                    254
+# define DTLS1_MT_HELLO_VERIFY_REQUEST           3
+
+/* Dummy message type for handling CCS like a normal handshake message */
+# define SSL3_MT_CHANGE_CIPHER_SPEC              0x0101
+
+# define SSL3_MT_CCS                             1
+
+/* These are used when changing over to a new cipher */
+# define SSL3_CC_READ            0x001
+# define SSL3_CC_WRITE           0x002
+# define SSL3_CC_CLIENT          0x010
+# define SSL3_CC_SERVER          0x020
+# define SSL3_CC_EARLY           0x040
+# define SSL3_CC_HANDSHAKE       0x080
+# define SSL3_CC_APPLICATION     0x100
+# define SSL3_CHANGE_CIPHER_CLIENT_WRITE (SSL3_CC_CLIENT|SSL3_CC_WRITE)
+# define SSL3_CHANGE_CIPHER_SERVER_READ  (SSL3_CC_SERVER|SSL3_CC_READ)
+# define SSL3_CHANGE_CIPHER_CLIENT_READ  (SSL3_CC_CLIENT|SSL3_CC_READ)
+# define SSL3_CHANGE_CIPHER_SERVER_WRITE (SSL3_CC_SERVER|SSL3_CC_WRITE)
+
+#ifdef  __cplusplus
+}
+#endif
+#endif
diff --git a/src/include/openssl/sslerr.h b/src/include/openssl/sslerr.h
new file mode 100644
index 0000000..ec35df6
--- /dev/null
+++ b/src/include/openssl/sslerr.h
@@ -0,0 +1,377 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2024 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_SSLERR_H
+# define OPENSSL_SSLERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/sslerr_legacy.h>
+
+
+
+/*
+ * SSL reason codes.
+ */
+# define SSL_R_APPLICATION_DATA_AFTER_CLOSE_NOTIFY        291
+# define SSL_R_APP_DATA_IN_HANDSHAKE                      100
+# define SSL_R_ATTEMPT_TO_REUSE_SESSION_IN_DIFFERENT_CONTEXT 272
+# define SSL_R_AT_LEAST_TLS_1_2_NEEDED_IN_SUITEB_MODE     158
+# define SSL_R_BAD_CERTIFICATE                            348
+# define SSL_R_BAD_CHANGE_CIPHER_SPEC                     103
+# define SSL_R_BAD_CIPHER                                 186
+# define SSL_R_BAD_COMPRESSION_ALGORITHM                  326
+# define SSL_R_BAD_DATA                                   390
+# define SSL_R_BAD_DATA_RETURNED_BY_CALLBACK              106
+# define SSL_R_BAD_DECOMPRESSION                          107
+# define SSL_R_BAD_DH_VALUE                               102
+# define SSL_R_BAD_DIGEST_LENGTH                          111
+# define SSL_R_BAD_EARLY_DATA                             233
+# define SSL_R_BAD_ECC_CERT                               304
+# define SSL_R_BAD_ECPOINT                                306
+# define SSL_R_BAD_EXTENSION                              110
+# define SSL_R_BAD_HANDSHAKE_LENGTH                       332
+# define SSL_R_BAD_HANDSHAKE_STATE                        236
+# define SSL_R_BAD_HELLO_REQUEST                          105
+# define SSL_R_BAD_HRR_VERSION                            263
+# define SSL_R_BAD_KEY_SHARE                              108
+# define SSL_R_BAD_KEY_UPDATE                             122
+# define SSL_R_BAD_LEGACY_VERSION                         292
+# define SSL_R_BAD_LENGTH                                 271
+# define SSL_R_BAD_PACKET                                 240
+# define SSL_R_BAD_PACKET_LENGTH                          115
+# define SSL_R_BAD_PROTOCOL_VERSION_NUMBER                116
+# define SSL_R_BAD_PSK                                    219
+# define SSL_R_BAD_PSK_IDENTITY                           114
+# define SSL_R_BAD_RECORD_TYPE                            443
+# define SSL_R_BAD_RSA_ENCRYPT                            119
+# define SSL_R_BAD_SIGNATURE                              123
+# define SSL_R_BAD_SRP_A_LENGTH                           347
+# define SSL_R_BAD_SRP_PARAMETERS                         371
+# define SSL_R_BAD_SRTP_MKI_VALUE                         352
+# define SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST           353
+# define SSL_R_BAD_SSL_FILETYPE                           124
+# define SSL_R_BAD_VALUE                                  384
+# define SSL_R_BAD_WRITE_RETRY                            127
+# define SSL_R_BINDER_DOES_NOT_VERIFY                     253
+# define SSL_R_BIO_NOT_SET                                128
+# define SSL_R_BLOCK_CIPHER_PAD_IS_WRONG                  129
+# define SSL_R_BN_LIB                                     130
+# define SSL_R_CALLBACK_FAILED                            234
+# define SSL_R_CANNOT_CHANGE_CIPHER                       109
+# define SSL_R_CANNOT_GET_GROUP_NAME                      299
+# define SSL_R_CA_DN_LENGTH_MISMATCH                      131
+# define SSL_R_CA_KEY_TOO_SMALL                           397
+# define SSL_R_CA_MD_TOO_WEAK                             398
+# define SSL_R_CCS_RECEIVED_EARLY                         133
+# define SSL_R_CERTIFICATE_VERIFY_FAILED                  134
+# define SSL_R_CERT_CB_ERROR                              377
+# define SSL_R_CERT_LENGTH_MISMATCH                       135
+# define SSL_R_CIPHERSUITE_DIGEST_HAS_CHANGED             218
+# define SSL_R_CIPHER_CODE_WRONG_LENGTH                   137
+# define SSL_R_CLIENTHELLO_TLSEXT                         226
+# define SSL_R_COMPRESSED_LENGTH_TOO_LONG                 140
+# define SSL_R_COMPRESSION_DISABLED                       343
+# define SSL_R_COMPRESSION_FAILURE                        141
+# define SSL_R_COMPRESSION_ID_NOT_WITHIN_PRIVATE_RANGE    307
+# define SSL_R_COMPRESSION_LIBRARY_ERROR                  142
+# define SSL_R_CONNECTION_TYPE_NOT_SET                    144
+# define SSL_R_CONN_USE_ONLY                              356
+# define SSL_R_CONTEXT_NOT_DANE_ENABLED                   167
+# define SSL_R_COOKIE_GEN_CALLBACK_FAILURE                400
+# define SSL_R_COOKIE_MISMATCH                            308
+# define SSL_R_COPY_PARAMETERS_FAILED                     296
+# define SSL_R_CUSTOM_EXT_HANDLER_ALREADY_INSTALLED       206
+# define SSL_R_DANE_ALREADY_ENABLED                       172
+# define SSL_R_DANE_CANNOT_OVERRIDE_MTYPE_FULL            173
+# define SSL_R_DANE_NOT_ENABLED                           175
+# define SSL_R_DANE_TLSA_BAD_CERTIFICATE                  180
+# define SSL_R_DANE_TLSA_BAD_CERTIFICATE_USAGE            184
+# define SSL_R_DANE_TLSA_BAD_DATA_LENGTH                  189
+# define SSL_R_DANE_TLSA_BAD_DIGEST_LENGTH                192
+# define SSL_R_DANE_TLSA_BAD_MATCHING_TYPE                200
+# define SSL_R_DANE_TLSA_BAD_PUBLIC_KEY                   201
+# define SSL_R_DANE_TLSA_BAD_SELECTOR                     202
+# define SSL_R_DANE_TLSA_NULL_DATA                        203
+# define SSL_R_DATA_BETWEEN_CCS_AND_FINISHED              145
+# define SSL_R_DATA_LENGTH_TOO_LONG                       146
+# define SSL_R_DECRYPTION_FAILED                          147
+# define SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC        281
+# define SSL_R_DH_KEY_TOO_SMALL                           394
+# define SSL_R_DH_PUBLIC_VALUE_LENGTH_IS_WRONG            148
+# define SSL_R_DIGEST_CHECK_FAILED                        149
+# define SSL_R_DTLS_MESSAGE_TOO_BIG                       334
+# define SSL_R_DUPLICATE_COMPRESSION_ID                   309
+# define SSL_R_ECC_CERT_NOT_FOR_SIGNING                   318
+# define SSL_R_ECDH_REQUIRED_FOR_SUITEB_MODE              374
+# define SSL_R_EE_KEY_TOO_SMALL                           399
+# define SSL_R_EMPTY_RAW_PUBLIC_KEY                       349
+# define SSL_R_EMPTY_SRTP_PROTECTION_PROFILE_LIST         354
+# define SSL_R_ENCRYPTED_LENGTH_TOO_LONG                  150
+# define SSL_R_ERROR_IN_RECEIVED_CIPHER_LIST              151
+# define SSL_R_ERROR_SETTING_TLSA_BASE_DOMAIN             204
+# define SSL_R_EXCEEDS_MAX_FRAGMENT_SIZE                  194
+# define SSL_R_EXCESSIVE_MESSAGE_SIZE                     152
+# define SSL_R_EXTENSION_NOT_RECEIVED                     279
+# define SSL_R_EXTRA_DATA_IN_MESSAGE                      153
+# define SSL_R_EXT_LENGTH_MISMATCH                        163
+# define SSL_R_FAILED_TO_GET_PARAMETER                    316
+# define SSL_R_FAILED_TO_INIT_ASYNC                       405
+# define SSL_R_FEATURE_NEGOTIATION_NOT_COMPLETE           417
+# define SSL_R_FEATURE_NOT_RENEGOTIABLE                   413
+# define SSL_R_FRAGMENTED_CLIENT_HELLO                    401
+# define SSL_R_GOT_A_FIN_BEFORE_A_CCS                     154
+# define SSL_R_HTTPS_PROXY_REQUEST                        155
+# define SSL_R_HTTP_REQUEST                               156
+# define SSL_R_ILLEGAL_POINT_COMPRESSION                  162
+# define SSL_R_ILLEGAL_SUITEB_DIGEST                      380
+# define SSL_R_INAPPROPRIATE_FALLBACK                     373
+# define SSL_R_INCONSISTENT_COMPRESSION                   340
+# define SSL_R_INCONSISTENT_EARLY_DATA_ALPN               222
+# define SSL_R_INCONSISTENT_EARLY_DATA_SNI                231
+# define SSL_R_INCONSISTENT_EXTMS                         104
+# define SSL_R_INSUFFICIENT_SECURITY                      241
+# define SSL_R_INVALID_ALERT                              205
+# define SSL_R_INVALID_CCS_MESSAGE                        260
+# define SSL_R_INVALID_CERTIFICATE_OR_ALG                 238
+# define SSL_R_INVALID_COMMAND                            280
+# define SSL_R_INVALID_COMPRESSION_ALGORITHM              341
+# define SSL_R_INVALID_CONFIG                             283
+# define SSL_R_INVALID_CONFIGURATION_NAME                 113
+# define SSL_R_INVALID_CONTEXT                            282
+# define SSL_R_INVALID_CT_VALIDATION_TYPE                 212
+# define SSL_R_INVALID_KEY_UPDATE_TYPE                    120
+# define SSL_R_INVALID_MAX_EARLY_DATA                     174
+# define SSL_R_INVALID_NULL_CMD_NAME                      385
+# define SSL_R_INVALID_RAW_PUBLIC_KEY                     350
+# define SSL_R_INVALID_RECORD                             317
+# define SSL_R_INVALID_SEQUENCE_NUMBER                    402
+# define SSL_R_INVALID_SERVERINFO_DATA                    388
+# define SSL_R_INVALID_SESSION_ID                         999
+# define SSL_R_INVALID_SRP_USERNAME                       357
+# define SSL_R_INVALID_STATUS_RESPONSE                    328
+# define SSL_R_INVALID_TICKET_KEYS_LENGTH                 325
+# define SSL_R_LEGACY_SIGALG_DISALLOWED_OR_UNSUPPORTED    333
+# define SSL_R_LENGTH_MISMATCH                            159
+# define SSL_R_LENGTH_TOO_LONG                            404
+# define SSL_R_LENGTH_TOO_SHORT                           160
+# define SSL_R_LIBRARY_BUG                                274
+# define SSL_R_LIBRARY_HAS_NO_CIPHERS                     161
+# define SSL_R_MAXIMUM_ENCRYPTED_PKTS_REACHED             395
+# define SSL_R_MISSING_DSA_SIGNING_CERT                   165
+# define SSL_R_MISSING_ECDSA_SIGNING_CERT                 381
+# define SSL_R_MISSING_FATAL                              256
+# define SSL_R_MISSING_PARAMETERS                         290
+# define SSL_R_MISSING_PSK_KEX_MODES_EXTENSION            310
+# define SSL_R_MISSING_RSA_CERTIFICATE                    168
+# define SSL_R_MISSING_RSA_ENCRYPTING_CERT                169
+# define SSL_R_MISSING_RSA_SIGNING_CERT                   170
+# define SSL_R_MISSING_SIGALGS_EXTENSION                  112
+# define SSL_R_MISSING_SIGNING_CERT                       221
+# define SSL_R_MISSING_SRP_PARAM                          358
+# define SSL_R_MISSING_SUPPORTED_GROUPS_EXTENSION         209
+# define SSL_R_MISSING_TMP_DH_KEY                         171
+# define SSL_R_MISSING_TMP_ECDH_KEY                       311
+# define SSL_R_MIXED_HANDSHAKE_AND_NON_HANDSHAKE_DATA     293
+# define SSL_R_NOT_ON_RECORD_BOUNDARY                     182
+# define SSL_R_NOT_REPLACING_CERTIFICATE                  289
+# define SSL_R_NOT_SERVER                                 284
+# define SSL_R_NO_APPLICATION_PROTOCOL                    235
+# define SSL_R_NO_CERTIFICATES_RETURNED                   176
+# define SSL_R_NO_CERTIFICATE_ASSIGNED                    177
+# define SSL_R_NO_CERTIFICATE_SET                         179
+# define SSL_R_NO_CHANGE_FOLLOWING_HRR                    214
+# define SSL_R_NO_CIPHERS_AVAILABLE                       181
+# define SSL_R_NO_CIPHERS_SPECIFIED                       183
+# define SSL_R_NO_CIPHER_MATCH                            185
+# define SSL_R_NO_CLIENT_CERT_METHOD                      331
+# define SSL_R_NO_COMPRESSION_SPECIFIED                   187
+# define SSL_R_NO_COOKIE_CALLBACK_SET                     287
+# define SSL_R_NO_GOST_CERTIFICATE_SENT_BY_PEER           330
+# define SSL_R_NO_METHOD_SPECIFIED                        188
+# define SSL_R_NO_PEM_EXTENSIONS                          389
+# define SSL_R_NO_PRIVATE_KEY_ASSIGNED                    190
+# define SSL_R_NO_PROTOCOLS_AVAILABLE                     191
+# define SSL_R_NO_RENEGOTIATION                           339
+# define SSL_R_NO_REQUIRED_DIGEST                         324
+# define SSL_R_NO_SHARED_CIPHER                           193
+# define SSL_R_NO_SHARED_GROUPS                           410
+# define SSL_R_NO_SHARED_SIGNATURE_ALGORITHMS             376
+# define SSL_R_NO_SRTP_PROFILES                           359
+# define SSL_R_NO_STREAM                                  355
+# define SSL_R_NO_SUITABLE_DIGEST_ALGORITHM               297
+# define SSL_R_NO_SUITABLE_GROUPS                         295
+# define SSL_R_NO_SUITABLE_KEY_SHARE                      101
+# define SSL_R_NO_SUITABLE_RECORD_LAYER                   322
+# define SSL_R_NO_SUITABLE_SIGNATURE_ALGORITHM            118
+# define SSL_R_NO_VALID_SCTS                              216
+# define SSL_R_NO_VERIFY_COOKIE_CALLBACK                  403
+# define SSL_R_NULL_SSL_CTX                               195
+# define SSL_R_NULL_SSL_METHOD_PASSED                     196
+# define SSL_R_OCSP_CALLBACK_FAILURE                      305
+# define SSL_R_OLD_SESSION_CIPHER_NOT_RETURNED            197
+# define SSL_R_OLD_SESSION_COMPRESSION_ALGORITHM_NOT_RETURNED 344
+# define SSL_R_OVERFLOW_ERROR                             237
+# define SSL_R_PACKET_LENGTH_TOO_LONG                     198
+# define SSL_R_PARSE_TLSEXT                               227
+# define SSL_R_PATH_TOO_LONG                              270
+# define SSL_R_PEER_DID_NOT_RETURN_A_CERTIFICATE          199
+# define SSL_R_PEM_NAME_BAD_PREFIX                        391
+# define SSL_R_PEM_NAME_TOO_SHORT                         392
+# define SSL_R_PIPELINE_FAILURE                           406
+# define SSL_R_POLL_REQUEST_NOT_SUPPORTED                 418
+# define SSL_R_POST_HANDSHAKE_AUTH_ENCODING_ERR           278
+# define SSL_R_PRIVATE_KEY_MISMATCH                       288
+# define SSL_R_PROTOCOL_IS_SHUTDOWN                       207
+# define SSL_R_PSK_IDENTITY_NOT_FOUND                     223
+# define SSL_R_PSK_NO_CLIENT_CB                           224
+# define SSL_R_PSK_NO_SERVER_CB                           225
+# define SSL_R_QUIC_HANDSHAKE_LAYER_ERROR                 393
+# define SSL_R_QUIC_NETWORK_ERROR                         387
+# define SSL_R_QUIC_PROTOCOL_ERROR                        382
+# define SSL_R_READ_BIO_NOT_SET                           211
+# define SSL_R_READ_TIMEOUT_EXPIRED                       312
+# define SSL_R_RECORDS_NOT_RELEASED                       321
+# define SSL_R_RECORD_LAYER_FAILURE                       313
+# define SSL_R_RECORD_LENGTH_MISMATCH                     213
+# define SSL_R_RECORD_TOO_SMALL                           298
+# define SSL_R_REMOTE_PEER_ADDRESS_NOT_SET                346
+# define SSL_R_RENEGOTIATE_EXT_TOO_LONG                   335
+# define SSL_R_RENEGOTIATION_ENCODING_ERR                 336
+# define SSL_R_RENEGOTIATION_MISMATCH                     337
+# define SSL_R_REQUEST_PENDING                            285
+# define SSL_R_REQUEST_SENT                               286
+# define SSL_R_REQUIRED_CIPHER_MISSING                    215
+# define SSL_R_REQUIRED_COMPRESSION_ALGORITHM_MISSING     342
+# define SSL_R_SCSV_RECEIVED_WHEN_RENEGOTIATING           345
+# define SSL_R_SCT_VERIFICATION_FAILED                    208
+# define SSL_R_SEQUENCE_CTR_WRAPPED                       327
+# define SSL_R_SERVERHELLO_TLSEXT                         275
+# define SSL_R_SESSION_ID_CONTEXT_UNINITIALIZED           277
+# define SSL_R_SHUTDOWN_WHILE_IN_INIT                     407
+# define SSL_R_SIGNATURE_ALGORITHMS_ERROR                 360
+# define SSL_R_SIGNATURE_FOR_NON_SIGNING_CERTIFICATE      220
+# define SSL_R_SRP_A_CALC                                 361
+# define SSL_R_SRTP_COULD_NOT_ALLOCATE_PROFILES           362
+# define SSL_R_SRTP_PROTECTION_PROFILE_LIST_TOO_LONG      363
+# define SSL_R_SRTP_UNKNOWN_PROTECTION_PROFILE            364
+# define SSL_R_SSL3_EXT_INVALID_MAX_FRAGMENT_LENGTH       232
+# define SSL_R_SSL3_EXT_INVALID_SERVERNAME                319
+# define SSL_R_SSL3_EXT_INVALID_SERVERNAME_TYPE           320
+# define SSL_R_SSL3_SESSION_ID_TOO_LONG                   300
+# define SSL_R_SSLV3_ALERT_BAD_CERTIFICATE                1042
+# define SSL_R_SSLV3_ALERT_BAD_RECORD_MAC                 1020
+# define SSL_R_SSLV3_ALERT_CERTIFICATE_EXPIRED            1045
+# define SSL_R_SSLV3_ALERT_CERTIFICATE_REVOKED            1044
+# define SSL_R_SSLV3_ALERT_CERTIFICATE_UNKNOWN            1046
+# define SSL_R_SSLV3_ALERT_DECOMPRESSION_FAILURE          1030
+# define SSL_R_SSLV3_ALERT_HANDSHAKE_FAILURE              1040
+# define SSL_R_SSLV3_ALERT_ILLEGAL_PARAMETER              1047
+# define SSL_R_SSLV3_ALERT_NO_CERTIFICATE                 1041
+# define SSL_R_SSLV3_ALERT_UNEXPECTED_MESSAGE             1010
+# define SSL_R_SSLV3_ALERT_UNSUPPORTED_CERTIFICATE        1043
+# define SSL_R_SSL_COMMAND_SECTION_EMPTY                  117
+# define SSL_R_SSL_COMMAND_SECTION_NOT_FOUND              125
+# define SSL_R_SSL_CTX_HAS_NO_DEFAULT_SSL_VERSION         228
+# define SSL_R_SSL_HANDSHAKE_FAILURE                      229
+# define SSL_R_SSL_LIBRARY_HAS_NO_CIPHERS                 230
+# define SSL_R_SSL_NEGATIVE_LENGTH                        372
+# define SSL_R_SSL_SECTION_EMPTY                          126
+# define SSL_R_SSL_SECTION_NOT_FOUND                      136
+# define SSL_R_SSL_SESSION_ID_CALLBACK_FAILED             301
+# define SSL_R_SSL_SESSION_ID_CONFLICT                    302
+# define SSL_R_SSL_SESSION_ID_CONTEXT_TOO_LONG            273
+# define SSL_R_SSL_SESSION_ID_HAS_BAD_LENGTH              303
+# define SSL_R_SSL_SESSION_ID_TOO_LONG                    408
+# define SSL_R_SSL_SESSION_VERSION_MISMATCH               210
+# define SSL_R_STILL_IN_INIT                              121
+# define SSL_R_STREAM_COUNT_LIMITED                       411
+# define SSL_R_STREAM_FINISHED                            365
+# define SSL_R_STREAM_RECV_ONLY                           366
+# define SSL_R_STREAM_RESET                               375
+# define SSL_R_STREAM_SEND_ONLY                           379
+# define SSL_R_TLSV13_ALERT_CERTIFICATE_REQUIRED          1116
+# define SSL_R_TLSV13_ALERT_MISSING_EXTENSION             1109
+# define SSL_R_TLSV1_ALERT_ACCESS_DENIED                  1049
+# define SSL_R_TLSV1_ALERT_DECODE_ERROR                   1050
+# define SSL_R_TLSV1_ALERT_DECRYPTION_FAILED              1021
+# define SSL_R_TLSV1_ALERT_DECRYPT_ERROR                  1051
+# define SSL_R_TLSV1_ALERT_EXPORT_RESTRICTION             1060
+# define SSL_R_TLSV1_ALERT_INAPPROPRIATE_FALLBACK         1086
+# define SSL_R_TLSV1_ALERT_INSUFFICIENT_SECURITY          1071
+# define SSL_R_TLSV1_ALERT_INTERNAL_ERROR                 1080
+# define SSL_R_TLSV1_ALERT_NO_APPLICATION_PROTOCOL        1120
+# define SSL_R_TLSV1_ALERT_NO_RENEGOTIATION               1100
+# define SSL_R_TLSV1_ALERT_PROTOCOL_VERSION               1070
+# define SSL_R_TLSV1_ALERT_RECORD_OVERFLOW                1022
+# define SSL_R_TLSV1_ALERT_UNKNOWN_CA                     1048
+# define SSL_R_TLSV1_ALERT_UNKNOWN_PSK_IDENTITY           1115
+# define SSL_R_TLSV1_ALERT_USER_CANCELLED                 1090
+# define SSL_R_TLSV1_BAD_CERTIFICATE_HASH_VALUE           1114
+# define SSL_R_TLSV1_BAD_CERTIFICATE_STATUS_RESPONSE      1113
+# define SSL_R_TLSV1_CERTIFICATE_UNOBTAINABLE             1111
+# define SSL_R_TLSV1_UNRECOGNIZED_NAME                    1112
+# define SSL_R_TLSV1_UNSUPPORTED_EXTENSION                1110
+# define SSL_R_TLS_ILLEGAL_EXPORTER_LABEL                 367
+# define SSL_R_TLS_INVALID_ECPOINTFORMAT_LIST             157
+# define SSL_R_TOO_MANY_KEY_UPDATES                       132
+# define SSL_R_TOO_MANY_WARN_ALERTS                       409
+# define SSL_R_TOO_MUCH_EARLY_DATA                        164
+# define SSL_R_UNABLE_TO_FIND_ECDH_PARAMETERS             314
+# define SSL_R_UNABLE_TO_FIND_PUBLIC_KEY_PARAMETERS       239
+# define SSL_R_UNABLE_TO_LOAD_SSL3_MD5_ROUTINES           242
+# define SSL_R_UNABLE_TO_LOAD_SSL3_SHA1_ROUTINES          243
+# define SSL_R_UNEXPECTED_CCS_MESSAGE                     262
+# define SSL_R_UNEXPECTED_END_OF_EARLY_DATA               178
+# define SSL_R_UNEXPECTED_EOF_WHILE_READING               294
+# define SSL_R_UNEXPECTED_MESSAGE                         244
+# define SSL_R_UNEXPECTED_RECORD                          245
+# define SSL_R_UNINITIALIZED                              276
+# define SSL_R_UNKNOWN_ALERT_TYPE                         246
+# define SSL_R_UNKNOWN_CERTIFICATE_TYPE                   247
+# define SSL_R_UNKNOWN_CIPHER_RETURNED                    248
+# define SSL_R_UNKNOWN_CIPHER_TYPE                        249
+# define SSL_R_UNKNOWN_CMD_NAME                           386
+# define SSL_R_UNKNOWN_COMMAND                            139
+# define SSL_R_UNKNOWN_DIGEST                             368
+# define SSL_R_UNKNOWN_KEY_EXCHANGE_TYPE                  250
+# define SSL_R_UNKNOWN_MANDATORY_PARAMETER                323
+# define SSL_R_UNKNOWN_PKEY_TYPE                          251
+# define SSL_R_UNKNOWN_PROTOCOL                           252
+# define SSL_R_UNKNOWN_SSL_VERSION                        254
+# define SSL_R_UNKNOWN_STATE                              255
+# define SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED       338
+# define SSL_R_UNSOLICITED_EXTENSION                      217
+# define SSL_R_UNSUPPORTED_COMPRESSION_ALGORITHM          257
+# define SSL_R_UNSUPPORTED_CONFIG_VALUE                   414
+# define SSL_R_UNSUPPORTED_CONFIG_VALUE_CLASS             415
+# define SSL_R_UNSUPPORTED_CONFIG_VALUE_OP                416
+# define SSL_R_UNSUPPORTED_ELLIPTIC_CURVE                 315
+# define SSL_R_UNSUPPORTED_PROTOCOL                       258
+# define SSL_R_UNSUPPORTED_SSL_VERSION                    259
+# define SSL_R_UNSUPPORTED_STATUS_TYPE                    329
+# define SSL_R_UNSUPPORTED_WRITE_FLAG                     412
+# define SSL_R_USE_SRTP_NOT_NEGOTIATED                    369
+# define SSL_R_VERSION_TOO_HIGH                           166
+# define SSL_R_VERSION_TOO_LOW                            396
+# define SSL_R_WRONG_CERTIFICATE_TYPE                     383
+# define SSL_R_WRONG_CIPHER_RETURNED                      261
+# define SSL_R_WRONG_CURVE                                378
+# define SSL_R_WRONG_RPK_TYPE                             351
+# define SSL_R_WRONG_SIGNATURE_LENGTH                     264
+# define SSL_R_WRONG_SIGNATURE_SIZE                       265
+# define SSL_R_WRONG_SIGNATURE_TYPE                       370
+# define SSL_R_WRONG_SSL_VERSION                          266
+# define SSL_R_WRONG_VERSION_NUMBER                       267
+# define SSL_R_X509_LIB                                   268
+# define SSL_R_X509_VERIFICATION_SETUP_PROBLEMS           269
+
+#endif
diff --git a/src/include/openssl/sslerr_legacy.h b/src/include/openssl/sslerr_legacy.h
new file mode 100644
index 0000000..4c35367
--- /dev/null
+++ b/src/include/openssl/sslerr_legacy.h
@@ -0,0 +1,467 @@
+/*
+ * Copyright 2020-2024 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+/*
+ * This header file preserves symbols from pre-3.0 OpenSSL.
+ * It should never be included directly, as it's already included
+ * by the public sslerr.h headers, and since it will go away some
+ * time in the future.
+ */
+
+#ifndef OPENSSL_SSLERR_LEGACY_H
+# define OPENSSL_SSLERR_LEGACY_H
+# pragma once
+
+# include <openssl/macros.h>
+# include <openssl/symhacks.h>
+
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int ERR_load_SSL_strings(void);
+
+/* Collected _F_ macros from OpenSSL 1.1.1 */
+
+/*
+ * SSL function codes.
+ */
+#  define SSL_F_ADD_CLIENT_KEY_SHARE_EXT                   0
+#  define SSL_F_ADD_KEY_SHARE                              0
+#  define SSL_F_BYTES_TO_CIPHER_LIST                       0
+#  define SSL_F_CHECK_SUITEB_CIPHER_LIST                   0
+#  define SSL_F_CIPHERSUITE_CB                             0
+#  define SSL_F_CONSTRUCT_CA_NAMES                         0
+#  define SSL_F_CONSTRUCT_KEY_EXCHANGE_TBS                 0
+#  define SSL_F_CONSTRUCT_STATEFUL_TICKET                  0
+#  define SSL_F_CONSTRUCT_STATELESS_TICKET                 0
+#  define SSL_F_CREATE_SYNTHETIC_MESSAGE_HASH              0
+#  define SSL_F_CREATE_TICKET_PREQUEL                      0
+#  define SSL_F_CT_MOVE_SCTS                               0
+#  define SSL_F_CT_STRICT                                  0
+#  define SSL_F_CUSTOM_EXT_ADD                             0
+#  define SSL_F_CUSTOM_EXT_PARSE                           0
+#  define SSL_F_D2I_SSL_SESSION                            0
+#  define SSL_F_DANE_CTX_ENABLE                            0
+#  define SSL_F_DANE_MTYPE_SET                             0
+#  define SSL_F_DANE_TLSA_ADD                              0
+#  define SSL_F_DERIVE_SECRET_KEY_AND_IV                   0
+#  define SSL_F_DO_DTLS1_WRITE                             0
+#  define SSL_F_DO_SSL3_WRITE                              0
+#  define SSL_F_DTLS1_BUFFER_RECORD                        0
+#  define SSL_F_DTLS1_CHECK_TIMEOUT_NUM                    0
+#  define SSL_F_DTLS1_HEARTBEAT                            0
+#  define SSL_F_DTLS1_HM_FRAGMENT_NEW                      0
+#  define SSL_F_DTLS1_PREPROCESS_FRAGMENT                  0
+#  define SSL_F_DTLS1_PROCESS_BUFFERED_RECORDS             0
+#  define SSL_F_DTLS1_PROCESS_RECORD                       0
+#  define SSL_F_DTLS1_READ_BYTES                           0
+#  define SSL_F_DTLS1_READ_FAILED                          0
+#  define SSL_F_DTLS1_RETRANSMIT_MESSAGE                   0
+#  define SSL_F_DTLS1_WRITE_APP_DATA_BYTES                 0
+#  define SSL_F_DTLS1_WRITE_BYTES                          0
+#  define SSL_F_DTLSV1_LISTEN                              0
+#  define SSL_F_DTLS_CONSTRUCT_CHANGE_CIPHER_SPEC          0
+#  define SSL_F_DTLS_CONSTRUCT_HELLO_VERIFY_REQUEST        0
+#  define SSL_F_DTLS_GET_REASSEMBLED_MESSAGE               0
+#  define SSL_F_DTLS_PROCESS_HELLO_VERIFY                  0
+#  define SSL_F_DTLS_RECORD_LAYER_NEW                      0
+#  define SSL_F_DTLS_WAIT_FOR_DRY                          0
+#  define SSL_F_EARLY_DATA_COUNT_OK                        0
+#  define SSL_F_FINAL_EARLY_DATA                           0
+#  define SSL_F_FINAL_EC_PT_FORMATS                        0
+#  define SSL_F_FINAL_EMS                                  0
+#  define SSL_F_FINAL_KEY_SHARE                            0
+#  define SSL_F_FINAL_MAXFRAGMENTLEN                       0
+#  define SSL_F_FINAL_RENEGOTIATE                          0
+#  define SSL_F_FINAL_SERVER_NAME                          0
+#  define SSL_F_FINAL_SIG_ALGS                             0
+#  define SSL_F_GET_CERT_VERIFY_TBS_DATA                   0
+#  define SSL_F_NSS_KEYLOG_INT                             0
+#  define SSL_F_OPENSSL_INIT_SSL                           0
+#  define SSL_F_OSSL_STATEM_CLIENT13_READ_TRANSITION       0
+#  define SSL_F_OSSL_STATEM_CLIENT13_WRITE_TRANSITION      0
+#  define SSL_F_OSSL_STATEM_CLIENT_CONSTRUCT_MESSAGE       0
+#  define SSL_F_OSSL_STATEM_CLIENT_POST_PROCESS_MESSAGE    0
+#  define SSL_F_OSSL_STATEM_CLIENT_PROCESS_MESSAGE         0
+#  define SSL_F_OSSL_STATEM_CLIENT_READ_TRANSITION         0
+#  define SSL_F_OSSL_STATEM_CLIENT_WRITE_TRANSITION        0
+#  define SSL_F_OSSL_STATEM_SERVER13_READ_TRANSITION       0
+#  define SSL_F_OSSL_STATEM_SERVER13_WRITE_TRANSITION      0
+#  define SSL_F_OSSL_STATEM_SERVER_CONSTRUCT_MESSAGE       0
+#  define SSL_F_OSSL_STATEM_SERVER_POST_PROCESS_MESSAGE    0
+#  define SSL_F_OSSL_STATEM_SERVER_POST_WORK               0
+#  define SSL_F_OSSL_STATEM_SERVER_PRE_WORK                0
+#  define SSL_F_OSSL_STATEM_SERVER_PROCESS_MESSAGE         0
+#  define SSL_F_OSSL_STATEM_SERVER_READ_TRANSITION         0
+#  define SSL_F_OSSL_STATEM_SERVER_WRITE_TRANSITION        0
+#  define SSL_F_PARSE_CA_NAMES                             0
+#  define SSL_F_PITEM_NEW                                  0
+#  define SSL_F_PQUEUE_NEW                                 0
+#  define SSL_F_PROCESS_KEY_SHARE_EXT                      0
+#  define SSL_F_READ_STATE_MACHINE                         0
+#  define SSL_F_SET_CLIENT_CIPHERSUITE                     0
+#  define SSL_F_SRP_GENERATE_CLIENT_MASTER_SECRET          0
+#  define SSL_F_SRP_GENERATE_SERVER_MASTER_SECRET          0
+#  define SSL_F_SRP_VERIFY_SERVER_PARAM                    0
+#  define SSL_F_SSL3_CHANGE_CIPHER_STATE                   0
+#  define SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM              0
+#  define SSL_F_SSL3_CTRL                                  0
+#  define SSL_F_SSL3_CTX_CTRL                              0
+#  define SSL_F_SSL3_DIGEST_CACHED_RECORDS                 0
+#  define SSL_F_SSL3_DO_CHANGE_CIPHER_SPEC                 0
+#  define SSL_F_SSL3_ENC                                   0
+#  define SSL_F_SSL3_FINAL_FINISH_MAC                      0
+#  define SSL_F_SSL3_FINISH_MAC                            0
+#  define SSL_F_SSL3_GENERATE_KEY_BLOCK                    0
+#  define SSL_F_SSL3_GENERATE_MASTER_SECRET                0
+#  define SSL_F_SSL3_GET_RECORD                            0
+#  define SSL_F_SSL3_INIT_FINISHED_MAC                     0
+#  define SSL_F_SSL3_OUTPUT_CERT_CHAIN                     0
+#  define SSL_F_SSL3_READ_BYTES                            0
+#  define SSL_F_SSL3_READ_N                                0
+#  define SSL_F_SSL3_SETUP_KEY_BLOCK                       0
+#  define SSL_F_SSL3_SETUP_READ_BUFFER                     0
+#  define SSL_F_SSL3_SETUP_WRITE_BUFFER                    0
+#  define SSL_F_SSL3_WRITE_BYTES                           0
+#  define SSL_F_SSL3_WRITE_PENDING                         0
+#  define SSL_F_SSL_ADD_CERT_CHAIN                         0
+#  define SSL_F_SSL_ADD_CERT_TO_BUF                        0
+#  define SSL_F_SSL_ADD_CERT_TO_WPACKET                    0
+#  define SSL_F_SSL_ADD_CLIENTHELLO_RENEGOTIATE_EXT        0
+#  define SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT                 0
+#  define SSL_F_SSL_ADD_CLIENTHELLO_USE_SRTP_EXT           0
+#  define SSL_F_SSL_ADD_DIR_CERT_SUBJECTS_TO_STACK         0
+#  define SSL_F_SSL_ADD_FILE_CERT_SUBJECTS_TO_STACK        0
+#  define SSL_F_SSL_ADD_SERVERHELLO_RENEGOTIATE_EXT        0
+#  define SSL_F_SSL_ADD_SERVERHELLO_TLSEXT                 0
+#  define SSL_F_SSL_ADD_SERVERHELLO_USE_SRTP_EXT           0
+#  define SSL_F_SSL_BUILD_CERT_CHAIN                       0
+#  define SSL_F_SSL_BYTES_TO_CIPHER_LIST                   0
+#  define SSL_F_SSL_CACHE_CIPHERLIST                       0
+#  define SSL_F_SSL_CERT_ADD0_CHAIN_CERT                   0
+#  define SSL_F_SSL_CERT_DUP                               0
+#  define SSL_F_SSL_CERT_NEW                               0
+#  define SSL_F_SSL_CERT_SET0_CHAIN                        0
+#  define SSL_F_SSL_CHECK_PRIVATE_KEY                      0
+#  define SSL_F_SSL_CHECK_SERVERHELLO_TLSEXT               0
+#  define SSL_F_SSL_CHECK_SRP_EXT_CLIENTHELLO              0
+#  define SSL_F_SSL_CHECK_SRVR_ECC_CERT_AND_ALG            0
+#  define SSL_F_SSL_CHOOSE_CLIENT_VERSION                  0
+#  define SSL_F_SSL_CIPHER_DESCRIPTION                     0
+#  define SSL_F_SSL_CIPHER_LIST_TO_BYTES                   0
+#  define SSL_F_SSL_CIPHER_PROCESS_RULESTR                 0
+#  define SSL_F_SSL_CIPHER_STRENGTH_SORT                   0
+#  define SSL_F_SSL_CLEAR                                  0
+#  define SSL_F_SSL_CLIENT_HELLO_GET1_EXTENSIONS_PRESENT   0
+#  define SSL_F_SSL_COMP_ADD_COMPRESSION_METHOD            0
+#  define SSL_F_SSL_CONF_CMD                               0
+#  define SSL_F_SSL_CREATE_CIPHER_LIST                     0
+#  define SSL_F_SSL_CTRL                                   0
+#  define SSL_F_SSL_CTX_CHECK_PRIVATE_KEY                  0
+#  define SSL_F_SSL_CTX_ENABLE_CT                          0
+#  define SSL_F_SSL_CTX_MAKE_PROFILES                      0
+#  define SSL_F_SSL_CTX_NEW                                0
+#  define SSL_F_SSL_CTX_SET_ALPN_PROTOS                    0
+#  define SSL_F_SSL_CTX_SET_CIPHER_LIST                    0
+#  define SSL_F_SSL_CTX_SET_CLIENT_CERT_ENGINE             0
+#  define SSL_F_SSL_CTX_SET_CT_VALIDATION_CALLBACK         0
+#  define SSL_F_SSL_CTX_SET_SESSION_ID_CONTEXT             0
+#  define SSL_F_SSL_CTX_SET_SSL_VERSION                    0
+#  define SSL_F_SSL_CTX_SET_TLSEXT_MAX_FRAGMENT_LENGTH     0
+#  define SSL_F_SSL_CTX_USE_CERTIFICATE                    0
+#  define SSL_F_SSL_CTX_USE_CERTIFICATE_ASN1               0
+#  define SSL_F_SSL_CTX_USE_CERTIFICATE_FILE               0
+#  define SSL_F_SSL_CTX_USE_PRIVATEKEY                     0
+#  define SSL_F_SSL_CTX_USE_PRIVATEKEY_ASN1                0
+#  define SSL_F_SSL_CTX_USE_PRIVATEKEY_FILE                0
+#  define SSL_F_SSL_CTX_USE_PSK_IDENTITY_HINT              0
+#  define SSL_F_SSL_CTX_USE_RSAPRIVATEKEY                  0
+#  define SSL_F_SSL_CTX_USE_RSAPRIVATEKEY_ASN1             0
+#  define SSL_F_SSL_CTX_USE_RSAPRIVATEKEY_FILE             0
+#  define SSL_F_SSL_CTX_USE_SERVERINFO                     0
+#  define SSL_F_SSL_CTX_USE_SERVERINFO_EX                  0
+#  define SSL_F_SSL_CTX_USE_SERVERINFO_FILE                0
+#  define SSL_F_SSL_DANE_DUP                               0
+#  define SSL_F_SSL_DANE_ENABLE                            0
+#  define SSL_F_SSL_DERIVE                                 0
+#  define SSL_F_SSL_DO_CONFIG                              0
+#  define SSL_F_SSL_DO_HANDSHAKE                           0
+#  define SSL_F_SSL_DUP_CA_LIST                            0
+#  define SSL_F_SSL_ENABLE_CT                              0
+#  define SSL_F_SSL_GENERATE_PKEY_GROUP                    0
+#  define SSL_F_SSL_GENERATE_SESSION_ID                    0
+#  define SSL_F_SSL_GET_NEW_SESSION                        0
+#  define SSL_F_SSL_GET_PREV_SESSION                       0
+#  define SSL_F_SSL_GET_SERVER_CERT_INDEX                  0
+#  define SSL_F_SSL_GET_SIGN_PKEY                          0
+#  define SSL_F_SSL_HANDSHAKE_HASH                         0
+#  define SSL_F_SSL_INIT_WBIO_BUFFER                       0
+#  define SSL_F_SSL_KEY_UPDATE                             0
+#  define SSL_F_SSL_LOAD_CLIENT_CA_FILE                    0
+#  define SSL_F_SSL_LOG_MASTER_SECRET                      0
+#  define SSL_F_SSL_LOG_RSA_CLIENT_KEY_EXCHANGE            0
+#  define SSL_F_SSL_MODULE_INIT                            0
+#  define SSL_F_SSL_NEW                                    0
+#  define SSL_F_SSL_NEXT_PROTO_VALIDATE                    0
+#  define SSL_F_SSL_PARSE_CLIENTHELLO_RENEGOTIATE_EXT      0
+#  define SSL_F_SSL_PARSE_CLIENTHELLO_TLSEXT               0
+#  define SSL_F_SSL_PARSE_CLIENTHELLO_USE_SRTP_EXT         0
+#  define SSL_F_SSL_PARSE_SERVERHELLO_RENEGOTIATE_EXT      0
+#  define SSL_F_SSL_PARSE_SERVERHELLO_TLSEXT               0
+#  define SSL_F_SSL_PARSE_SERVERHELLO_USE_SRTP_EXT         0
+#  define SSL_F_SSL_PEEK                                   0
+#  define SSL_F_SSL_PEEK_EX                                0
+#  define SSL_F_SSL_PEEK_INTERNAL                          0
+#  define SSL_F_SSL_READ                                   0
+#  define SSL_F_SSL_READ_EARLY_DATA                        0
+#  define SSL_F_SSL_READ_EX                                0
+#  define SSL_F_SSL_READ_INTERNAL                          0
+#  define SSL_F_SSL_RENEGOTIATE                            0
+#  define SSL_F_SSL_RENEGOTIATE_ABBREVIATED                0
+#  define SSL_F_SSL_SCAN_CLIENTHELLO_TLSEXT                0
+#  define SSL_F_SSL_SCAN_SERVERHELLO_TLSEXT                0
+#  define SSL_F_SSL_SESSION_DUP                            0
+#  define SSL_F_SSL_SESSION_NEW                            0
+#  define SSL_F_SSL_SESSION_PRINT_FP                       0
+#  define SSL_F_SSL_SESSION_SET1_ID                        0
+#  define SSL_F_SSL_SESSION_SET1_ID_CONTEXT                0
+#  define SSL_F_SSL_SET_ALPN_PROTOS                        0
+#  define SSL_F_SSL_SET_CERT                               0
+#  define SSL_F_SSL_SET_CERT_AND_KEY                       0
+#  define SSL_F_SSL_SET_CIPHER_LIST                        0
+#  define SSL_F_SSL_SET_CT_VALIDATION_CALLBACK             0
+#  define SSL_F_SSL_SET_FD                                 0
+#  define SSL_F_SSL_SET_PKEY                               0
+#  define SSL_F_SSL_SET_RFD                                0
+#  define SSL_F_SSL_SET_SESSION                            0
+#  define SSL_F_SSL_SET_SESSION_ID_CONTEXT                 0
+#  define SSL_F_SSL_SET_SESSION_TICKET_EXT                 0
+#  define SSL_F_SSL_SET_TLSEXT_MAX_FRAGMENT_LENGTH         0
+#  define SSL_F_SSL_SET_WFD                                0
+#  define SSL_F_SSL_SHUTDOWN                               0
+#  define SSL_F_SSL_SRP_CTX_INIT                           0
+#  define SSL_F_SSL_START_ASYNC_JOB                        0
+#  define SSL_F_SSL_UNDEFINED_FUNCTION                     0
+#  define SSL_F_SSL_UNDEFINED_VOID_FUNCTION                0
+#  define SSL_F_SSL_USE_CERTIFICATE                        0
+#  define SSL_F_SSL_USE_CERTIFICATE_ASN1                   0
+#  define SSL_F_SSL_USE_CERTIFICATE_FILE                   0
+#  define SSL_F_SSL_USE_PRIVATEKEY                         0
+#  define SSL_F_SSL_USE_PRIVATEKEY_ASN1                    0
+#  define SSL_F_SSL_USE_PRIVATEKEY_FILE                    0
+#  define SSL_F_SSL_USE_PSK_IDENTITY_HINT                  0
+#  define SSL_F_SSL_USE_RSAPRIVATEKEY                      0
+#  define SSL_F_SSL_USE_RSAPRIVATEKEY_ASN1                 0
+#  define SSL_F_SSL_USE_RSAPRIVATEKEY_FILE                 0
+#  define SSL_F_SSL_VALIDATE_CT                            0
+#  define SSL_F_SSL_VERIFY_CERT_CHAIN                      0
+#  define SSL_F_SSL_VERIFY_CLIENT_POST_HANDSHAKE           0
+#  define SSL_F_SSL_WRITE                                  0
+#  define SSL_F_SSL_WRITE_EARLY_DATA                       0
+#  define SSL_F_SSL_WRITE_EARLY_FINISH                     0
+#  define SSL_F_SSL_WRITE_EX                               0
+#  define SSL_F_SSL_WRITE_INTERNAL                         0
+#  define SSL_F_STATE_MACHINE                              0
+#  define SSL_F_TLS12_CHECK_PEER_SIGALG                    0
+#  define SSL_F_TLS12_COPY_SIGALGS                         0
+#  define SSL_F_TLS13_CHANGE_CIPHER_STATE                  0
+#  define SSL_F_TLS13_ENC                                  0
+#  define SSL_F_TLS13_FINAL_FINISH_MAC                     0
+#  define SSL_F_TLS13_GENERATE_SECRET                      0
+#  define SSL_F_TLS13_HKDF_EXPAND                          0
+#  define SSL_F_TLS13_RESTORE_HANDSHAKE_DIGEST_FOR_PHA     0
+#  define SSL_F_TLS13_SAVE_HANDSHAKE_DIGEST_FOR_PHA        0
+#  define SSL_F_TLS13_SETUP_KEY_BLOCK                      0
+#  define SSL_F_TLS1_CHANGE_CIPHER_STATE                   0
+#  define SSL_F_TLS1_CHECK_DUPLICATE_EXTENSIONS            0
+#  define SSL_F_TLS1_ENC                                   0
+#  define SSL_F_TLS1_EXPORT_KEYING_MATERIAL                0
+#  define SSL_F_TLS1_GET_CURVELIST                         0
+#  define SSL_F_TLS1_PRF                                   0
+#  define SSL_F_TLS1_SAVE_U16                              0
+#  define SSL_F_TLS1_SETUP_KEY_BLOCK                       0
+#  define SSL_F_TLS1_SET_GROUPS                            0
+#  define SSL_F_TLS1_SET_RAW_SIGALGS                       0
+#  define SSL_F_TLS1_SET_SERVER_SIGALGS                    0
+#  define SSL_F_TLS1_SET_SHARED_SIGALGS                    0
+#  define SSL_F_TLS1_SET_SIGALGS                           0
+#  define SSL_F_TLS_CHOOSE_SIGALG                          0
+#  define SSL_F_TLS_CLIENT_KEY_EXCHANGE_POST_WORK          0
+#  define SSL_F_TLS_COLLECT_EXTENSIONS                     0
+#  define SSL_F_TLS_CONSTRUCT_CERTIFICATE_AUTHORITIES      0
+#  define SSL_F_TLS_CONSTRUCT_CERTIFICATE_REQUEST          0
+#  define SSL_F_TLS_CONSTRUCT_CERT_STATUS                  0
+#  define SSL_F_TLS_CONSTRUCT_CERT_STATUS_BODY             0
+#  define SSL_F_TLS_CONSTRUCT_CERT_VERIFY                  0
+#  define SSL_F_TLS_CONSTRUCT_CHANGE_CIPHER_SPEC           0
+#  define SSL_F_TLS_CONSTRUCT_CKE_DHE                      0
+#  define SSL_F_TLS_CONSTRUCT_CKE_ECDHE                    0
+#  define SSL_F_TLS_CONSTRUCT_CKE_GOST                     0
+#  define SSL_F_TLS_CONSTRUCT_CKE_PSK_PREAMBLE             0
+#  define SSL_F_TLS_CONSTRUCT_CKE_RSA                      0
+#  define SSL_F_TLS_CONSTRUCT_CKE_SRP                      0
+#  define SSL_F_TLS_CONSTRUCT_CLIENT_CERTIFICATE           0
+#  define SSL_F_TLS_CONSTRUCT_CLIENT_HELLO                 0
+#  define SSL_F_TLS_CONSTRUCT_CLIENT_KEY_EXCHANGE          0
+#  define SSL_F_TLS_CONSTRUCT_CLIENT_VERIFY                0
+#  define SSL_F_TLS_CONSTRUCT_CTOS_ALPN                    0
+#  define SSL_F_TLS_CONSTRUCT_CTOS_CERTIFICATE             0
+#  define SSL_F_TLS_CONSTRUCT_CTOS_COOKIE                  0
+#  define SSL_F_TLS_CONSTRUCT_CTOS_EARLY_DATA              0
+#  define SSL_F_TLS_CONSTRUCT_CTOS_EC_PT_FORMATS           0
+#  define SSL_F_TLS_CONSTRUCT_CTOS_EMS                     0
+#  define SSL_F_TLS_CONSTRUCT_CTOS_ETM                     0
+#  define SSL_F_TLS_CONSTRUCT_CTOS_HELLO                   0
+#  define SSL_F_TLS_CONSTRUCT_CTOS_KEY_EXCHANGE            0
+#  define SSL_F_TLS_CONSTRUCT_CTOS_KEY_SHARE               0
+#  define SSL_F_TLS_CONSTRUCT_CTOS_MAXFRAGMENTLEN          0
+#  define SSL_F_TLS_CONSTRUCT_CTOS_NPN                     0
+#  define SSL_F_TLS_CONSTRUCT_CTOS_PADDING                 0
+#  define SSL_F_TLS_CONSTRUCT_CTOS_POST_HANDSHAKE_AUTH     0
+#  define SSL_F_TLS_CONSTRUCT_CTOS_PSK                     0
+#  define SSL_F_TLS_CONSTRUCT_CTOS_PSK_KEX_MODES           0
+#  define SSL_F_TLS_CONSTRUCT_CTOS_RENEGOTIATE             0
+#  define SSL_F_TLS_CONSTRUCT_CTOS_SCT                     0
+#  define SSL_F_TLS_CONSTRUCT_CTOS_SERVER_NAME             0
+#  define SSL_F_TLS_CONSTRUCT_CTOS_SESSION_TICKET          0
+#  define SSL_F_TLS_CONSTRUCT_CTOS_SIG_ALGS                0
+#  define SSL_F_TLS_CONSTRUCT_CTOS_SRP                     0
+#  define SSL_F_TLS_CONSTRUCT_CTOS_STATUS_REQUEST          0
+#  define SSL_F_TLS_CONSTRUCT_CTOS_SUPPORTED_GROUPS        0
+#  define SSL_F_TLS_CONSTRUCT_CTOS_SUPPORTED_VERSIONS      0
+#  define SSL_F_TLS_CONSTRUCT_CTOS_USE_SRTP                0
+#  define SSL_F_TLS_CONSTRUCT_CTOS_VERIFY                  0
+#  define SSL_F_TLS_CONSTRUCT_ENCRYPTED_EXTENSIONS         0
+#  define SSL_F_TLS_CONSTRUCT_END_OF_EARLY_DATA            0
+#  define SSL_F_TLS_CONSTRUCT_EXTENSIONS                   0
+#  define SSL_F_TLS_CONSTRUCT_FINISHED                     0
+#  define SSL_F_TLS_CONSTRUCT_HELLO_REQUEST                0
+#  define SSL_F_TLS_CONSTRUCT_HELLO_RETRY_REQUEST          0
+#  define SSL_F_TLS_CONSTRUCT_KEY_UPDATE                   0
+#  define SSL_F_TLS_CONSTRUCT_NEW_SESSION_TICKET           0
+#  define SSL_F_TLS_CONSTRUCT_NEXT_PROTO                   0
+#  define SSL_F_TLS_CONSTRUCT_SERVER_CERTIFICATE           0
+#  define SSL_F_TLS_CONSTRUCT_SERVER_HELLO                 0
+#  define SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE          0
+#  define SSL_F_TLS_CONSTRUCT_STOC_ALPN                    0
+#  define SSL_F_TLS_CONSTRUCT_STOC_CERTIFICATE             0
+#  define SSL_F_TLS_CONSTRUCT_STOC_COOKIE                  0
+#  define SSL_F_TLS_CONSTRUCT_STOC_CRYPTOPRO_BUG           0
+#  define SSL_F_TLS_CONSTRUCT_STOC_DONE                    0
+#  define SSL_F_TLS_CONSTRUCT_STOC_EARLY_DATA              0
+#  define SSL_F_TLS_CONSTRUCT_STOC_EARLY_DATA_INFO         0
+#  define SSL_F_TLS_CONSTRUCT_STOC_EC_PT_FORMATS           0
+#  define SSL_F_TLS_CONSTRUCT_STOC_EMS                     0
+#  define SSL_F_TLS_CONSTRUCT_STOC_ETM                     0
+#  define SSL_F_TLS_CONSTRUCT_STOC_HELLO                   0
+#  define SSL_F_TLS_CONSTRUCT_STOC_KEY_EXCHANGE            0
+#  define SSL_F_TLS_CONSTRUCT_STOC_KEY_SHARE               0
+#  define SSL_F_TLS_CONSTRUCT_STOC_MAXFRAGMENTLEN          0
+#  define SSL_F_TLS_CONSTRUCT_STOC_NEXT_PROTO_NEG          0
+#  define SSL_F_TLS_CONSTRUCT_STOC_PSK                     0
+#  define SSL_F_TLS_CONSTRUCT_STOC_RENEGOTIATE             0
+#  define SSL_F_TLS_CONSTRUCT_STOC_SERVER_NAME             0
+#  define SSL_F_TLS_CONSTRUCT_STOC_SESSION_TICKET          0
+#  define SSL_F_TLS_CONSTRUCT_STOC_STATUS_REQUEST          0
+#  define SSL_F_TLS_CONSTRUCT_STOC_SUPPORTED_GROUPS        0
+#  define SSL_F_TLS_CONSTRUCT_STOC_SUPPORTED_VERSIONS      0
+#  define SSL_F_TLS_CONSTRUCT_STOC_USE_SRTP                0
+#  define SSL_F_TLS_EARLY_POST_PROCESS_CLIENT_HELLO        0
+#  define SSL_F_TLS_FINISH_HANDSHAKE                       0
+#  define SSL_F_TLS_GET_MESSAGE_BODY                       0
+#  define SSL_F_TLS_GET_MESSAGE_HEADER                     0
+#  define SSL_F_TLS_HANDLE_ALPN                            0
+#  define SSL_F_TLS_HANDLE_STATUS_REQUEST                  0
+#  define SSL_F_TLS_PARSE_CERTIFICATE_AUTHORITIES          0
+#  define SSL_F_TLS_PARSE_CLIENTHELLO_TLSEXT               0
+#  define SSL_F_TLS_PARSE_CTOS_ALPN                        0
+#  define SSL_F_TLS_PARSE_CTOS_COOKIE                      0
+#  define SSL_F_TLS_PARSE_CTOS_EARLY_DATA                  0
+#  define SSL_F_TLS_PARSE_CTOS_EC_PT_FORMATS               0
+#  define SSL_F_TLS_PARSE_CTOS_EMS                         0
+#  define SSL_F_TLS_PARSE_CTOS_KEY_SHARE                   0
+#  define SSL_F_TLS_PARSE_CTOS_MAXFRAGMENTLEN              0
+#  define SSL_F_TLS_PARSE_CTOS_POST_HANDSHAKE_AUTH         0
+#  define SSL_F_TLS_PARSE_CTOS_PSK                         0
+#  define SSL_F_TLS_PARSE_CTOS_PSK_KEX_MODES               0
+#  define SSL_F_TLS_PARSE_CTOS_RENEGOTIATE                 0
+#  define SSL_F_TLS_PARSE_CTOS_SERVER_NAME                 0
+#  define SSL_F_TLS_PARSE_CTOS_SESSION_TICKET              0
+#  define SSL_F_TLS_PARSE_CTOS_SIG_ALGS                    0
+#  define SSL_F_TLS_PARSE_CTOS_SIG_ALGS_CERT               0
+#  define SSL_F_TLS_PARSE_CTOS_SRP                         0
+#  define SSL_F_TLS_PARSE_CTOS_STATUS_REQUEST              0
+#  define SSL_F_TLS_PARSE_CTOS_SUPPORTED_GROUPS            0
+#  define SSL_F_TLS_PARSE_CTOS_USE_SRTP                    0
+#  define SSL_F_TLS_PARSE_STOC_ALPN                        0
+#  define SSL_F_TLS_PARSE_STOC_COOKIE                      0
+#  define SSL_F_TLS_PARSE_STOC_EARLY_DATA                  0
+#  define SSL_F_TLS_PARSE_STOC_EARLY_DATA_INFO             0
+#  define SSL_F_TLS_PARSE_STOC_EC_PT_FORMATS               0
+#  define SSL_F_TLS_PARSE_STOC_KEY_SHARE                   0
+#  define SSL_F_TLS_PARSE_STOC_MAXFRAGMENTLEN              0
+#  define SSL_F_TLS_PARSE_STOC_NPN                         0
+#  define SSL_F_TLS_PARSE_STOC_PSK                         0
+#  define SSL_F_TLS_PARSE_STOC_RENEGOTIATE                 0
+#  define SSL_F_TLS_PARSE_STOC_SCT                         0
+#  define SSL_F_TLS_PARSE_STOC_SERVER_NAME                 0
+#  define SSL_F_TLS_PARSE_STOC_SESSION_TICKET              0
+#  define SSL_F_TLS_PARSE_STOC_STATUS_REQUEST              0
+#  define SSL_F_TLS_PARSE_STOC_SUPPORTED_VERSIONS          0
+#  define SSL_F_TLS_PARSE_STOC_USE_SRTP                    0
+#  define SSL_F_TLS_POST_PROCESS_CLIENT_HELLO              0
+#  define SSL_F_TLS_POST_PROCESS_CLIENT_KEY_EXCHANGE       0
+#  define SSL_F_TLS_PREPARE_CLIENT_CERTIFICATE             0
+#  define SSL_F_TLS_PROCESS_AS_HELLO_RETRY_REQUEST         0
+#  define SSL_F_TLS_PROCESS_CERTIFICATE_REQUEST            0
+#  define SSL_F_TLS_PROCESS_CERT_STATUS                    0
+#  define SSL_F_TLS_PROCESS_CERT_STATUS_BODY               0
+#  define SSL_F_TLS_PROCESS_CERT_VERIFY                    0
+#  define SSL_F_TLS_PROCESS_CHANGE_CIPHER_SPEC             0
+#  define SSL_F_TLS_PROCESS_CKE_DHE                        0
+#  define SSL_F_TLS_PROCESS_CKE_ECDHE                      0
+#  define SSL_F_TLS_PROCESS_CKE_GOST                       0
+#  define SSL_F_TLS_PROCESS_CKE_PSK_PREAMBLE               0
+#  define SSL_F_TLS_PROCESS_CKE_RSA                        0
+#  define SSL_F_TLS_PROCESS_CKE_SRP                        0
+#  define SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE             0
+#  define SSL_F_TLS_PROCESS_CLIENT_HELLO                   0
+#  define SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE            0
+#  define SSL_F_TLS_PROCESS_ENCRYPTED_EXTENSIONS           0
+#  define SSL_F_TLS_PROCESS_END_OF_EARLY_DATA              0
+#  define SSL_F_TLS_PROCESS_FINISHED                       0
+#  define SSL_F_TLS_PROCESS_HELLO_REQ                      0
+#  define SSL_F_TLS_PROCESS_HELLO_RETRY_REQUEST            0
+#  define SSL_F_TLS_PROCESS_INITIAL_SERVER_FLIGHT          0
+#  define SSL_F_TLS_PROCESS_KEY_EXCHANGE                   0
+#  define SSL_F_TLS_PROCESS_KEY_UPDATE                     0
+#  define SSL_F_TLS_PROCESS_NEW_SESSION_TICKET             0
+#  define SSL_F_TLS_PROCESS_NEXT_PROTO                     0
+#  define SSL_F_TLS_PROCESS_SERVER_CERTIFICATE             0
+#  define SSL_F_TLS_PROCESS_SERVER_DONE                    0
+#  define SSL_F_TLS_PROCESS_SERVER_HELLO                   0
+#  define SSL_F_TLS_PROCESS_SKE_DHE                        0
+#  define SSL_F_TLS_PROCESS_SKE_ECDHE                      0
+#  define SSL_F_TLS_PROCESS_SKE_PSK_PREAMBLE               0
+#  define SSL_F_TLS_PROCESS_SKE_SRP                        0
+#  define SSL_F_TLS_PSK_DO_BINDER                          0
+#  define SSL_F_TLS_SCAN_CLIENTHELLO_TLSEXT                0
+#  define SSL_F_TLS_SETUP_HANDSHAKE                        0
+#  define SSL_F_USE_CERTIFICATE_CHAIN_FILE                 0
+#  define SSL_F_WPACKET_INTERN_INIT_LEN                    0
+#  define SSL_F_WPACKET_START_SUB_PACKET_LEN__             0
+#  define SSL_F_WRITE_STATE_MACHINE                        0
+# endif
+
+# ifdef  __cplusplus
+}
+# endif
+#endif
diff --git a/src/include/openssl/stack.h b/src/include/openssl/stack.h
new file mode 100644
index 0000000..f0c5c54
--- /dev/null
+++ b/src/include/openssl/stack.h
@@ -0,0 +1,90 @@
+/*
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_STACK_H
+# define OPENSSL_STACK_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_STACK_H
+# endif
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+typedef struct stack_st OPENSSL_STACK; /* Use STACK_OF(...) instead */
+
+typedef int (*OPENSSL_sk_compfunc)(const void *, const void *);
+typedef void (*OPENSSL_sk_freefunc)(void *);
+typedef void *(*OPENSSL_sk_copyfunc)(const void *);
+
+int OPENSSL_sk_num(const OPENSSL_STACK *);
+void *OPENSSL_sk_value(const OPENSSL_STACK *, int);
+
+void *OPENSSL_sk_set(OPENSSL_STACK *st, int i, const void *data);
+
+OPENSSL_STACK *OPENSSL_sk_new(OPENSSL_sk_compfunc cmp);
+OPENSSL_STACK *OPENSSL_sk_new_null(void);
+OPENSSL_STACK *OPENSSL_sk_new_reserve(OPENSSL_sk_compfunc c, int n);
+int OPENSSL_sk_reserve(OPENSSL_STACK *st, int n);
+void OPENSSL_sk_free(OPENSSL_STACK *);
+void OPENSSL_sk_pop_free(OPENSSL_STACK *st, void (*func) (void *));
+OPENSSL_STACK *OPENSSL_sk_deep_copy(const OPENSSL_STACK *,
+                                    OPENSSL_sk_copyfunc c,
+                                    OPENSSL_sk_freefunc f);
+int OPENSSL_sk_insert(OPENSSL_STACK *sk, const void *data, int where);
+void *OPENSSL_sk_delete(OPENSSL_STACK *st, int loc);
+void *OPENSSL_sk_delete_ptr(OPENSSL_STACK *st, const void *p);
+int OPENSSL_sk_find(OPENSSL_STACK *st, const void *data);
+int OPENSSL_sk_find_ex(OPENSSL_STACK *st, const void *data);
+int OPENSSL_sk_find_all(OPENSSL_STACK *st, const void *data, int *pnum);
+int OPENSSL_sk_push(OPENSSL_STACK *st, const void *data);
+int OPENSSL_sk_unshift(OPENSSL_STACK *st, const void *data);
+void *OPENSSL_sk_shift(OPENSSL_STACK *st);
+void *OPENSSL_sk_pop(OPENSSL_STACK *st);
+void OPENSSL_sk_zero(OPENSSL_STACK *st);
+OPENSSL_sk_compfunc OPENSSL_sk_set_cmp_func(OPENSSL_STACK *sk,
+                                            OPENSSL_sk_compfunc cmp);
+OPENSSL_STACK *OPENSSL_sk_dup(const OPENSSL_STACK *st);
+void OPENSSL_sk_sort(OPENSSL_STACK *st);
+int OPENSSL_sk_is_sorted(const OPENSSL_STACK *st);
+
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#  define _STACK OPENSSL_STACK
+#  define sk_num OPENSSL_sk_num
+#  define sk_value OPENSSL_sk_value
+#  define sk_set OPENSSL_sk_set
+#  define sk_new OPENSSL_sk_new
+#  define sk_new_null OPENSSL_sk_new_null
+#  define sk_free OPENSSL_sk_free
+#  define sk_pop_free OPENSSL_sk_pop_free
+#  define sk_deep_copy OPENSSL_sk_deep_copy
+#  define sk_insert OPENSSL_sk_insert
+#  define sk_delete OPENSSL_sk_delete
+#  define sk_delete_ptr OPENSSL_sk_delete_ptr
+#  define sk_find OPENSSL_sk_find
+#  define sk_find_ex OPENSSL_sk_find_ex
+#  define sk_push OPENSSL_sk_push
+#  define sk_unshift OPENSSL_sk_unshift
+#  define sk_shift OPENSSL_sk_shift
+#  define sk_pop OPENSSL_sk_pop
+#  define sk_zero OPENSSL_sk_zero
+#  define sk_set_cmp_func OPENSSL_sk_set_cmp_func
+#  define sk_dup OPENSSL_sk_dup
+#  define sk_sort OPENSSL_sk_sort
+#  define sk_is_sorted OPENSSL_sk_is_sorted
+# endif
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/include/openssl/store.h b/src/include/openssl/store.h
new file mode 100644
index 0000000..e6ea3cf
--- /dev/null
+++ b/src/include/openssl/store.h
@@ -0,0 +1,377 @@
+/*
+ * Copyright 2016-2023 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_STORE_H
+# define OPENSSL_STORE_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_OSSL_STORE_H
+# endif
+
+# include <stdarg.h>
+# include <openssl/types.h>
+# include <openssl/pem.h>
+# include <openssl/storeerr.h>
+
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+/*-
+ *  The main OSSL_STORE functions.
+ *  ------------------------------
+ *
+ *  These allow applications to open a channel to a resource with supported
+ *  data (keys, certs, crls, ...), read the data a piece at a time and decide
+ *  what to do with it, and finally close.
+ */
+
+typedef struct ossl_store_ctx_st OSSL_STORE_CTX;
+
+/*
+ * Typedef for the OSSL_STORE_INFO post processing callback.  This can be used
+ * to massage the given OSSL_STORE_INFO, or to drop it entirely (by returning
+ * NULL).
+ */
+typedef OSSL_STORE_INFO *(*OSSL_STORE_post_process_info_fn)(OSSL_STORE_INFO *,
+                                                            void *);
+
+/*
+ * Open a channel given a URI.  The given UI method will be used any time the
+ * loader needs extra input, for example when a password or pin is needed, and
+ * will be passed the same user data every time it's needed in this context.
+ *
+ * Returns a context reference which represents the channel to communicate
+ * through.
+ */
+OSSL_STORE_CTX *
+OSSL_STORE_open(const char *uri, const UI_METHOD *ui_method, void *ui_data,
+                OSSL_STORE_post_process_info_fn post_process,
+                void *post_process_data);
+OSSL_STORE_CTX *
+OSSL_STORE_open_ex(const char *uri, OSSL_LIB_CTX *libctx, const char *propq,
+                   const UI_METHOD *ui_method, void *ui_data,
+                   const OSSL_PARAM params[],
+                   OSSL_STORE_post_process_info_fn post_process,
+                   void *post_process_data);
+
+/*
+ * Control / fine tune the OSSL_STORE channel.  |cmd| determines what is to be
+ * done, and depends on the underlying loader (use OSSL_STORE_get0_scheme to
+ * determine which loader is used), except for common commands (see below).
+ * Each command takes different arguments.
+ */
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int OSSL_STORE_ctrl(OSSL_STORE_CTX *ctx, int cmd,
+                                          ... /* args */);
+OSSL_DEPRECATEDIN_3_0 int OSSL_STORE_vctrl(OSSL_STORE_CTX *ctx, int cmd,
+                                           va_list args);
+# endif
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+
+/*
+ * Common ctrl commands that different loaders may choose to support.
+ */
+/* int on = 0 or 1; STORE_ctrl(ctx, STORE_C_USE_SECMEM, &on); */
+# define OSSL_STORE_C_USE_SECMEM      1
+/* Where custom commands start */
+# define OSSL_STORE_C_CUSTOM_START    100
+
+# endif
+
+/*
+ * Read one data item (a key, a cert, a CRL) that is supported by the OSSL_STORE
+ * functionality, given a context.
+ * Returns a OSSL_STORE_INFO pointer, from which OpenSSL typed data can be
+ * extracted with OSSL_STORE_INFO_get0_PKEY(), OSSL_STORE_INFO_get0_CERT(), ...
+ * NULL is returned on error, which may include that the data found at the URI
+ * can't be figured out for certain or is ambiguous.
+ */
+OSSL_STORE_INFO *OSSL_STORE_load(OSSL_STORE_CTX *ctx);
+
+/*
+ * Deletes the object in the store by URI.
+ * Returns 1 on success, 0 otherwise.
+ */
+int OSSL_STORE_delete(const char *uri, OSSL_LIB_CTX *libctx, const char *propq,
+                      const UI_METHOD *ui_method, void *ui_data,
+                      const OSSL_PARAM params[]);
+
+/*
+ * Check if end of data (end of file) is reached
+ * Returns 1 on end, 0 otherwise.
+ */
+int OSSL_STORE_eof(OSSL_STORE_CTX *ctx);
+
+/*
+ * Check if an error occurred
+ * Returns 1 if it did, 0 otherwise.
+ */
+int OSSL_STORE_error(OSSL_STORE_CTX *ctx);
+
+/*
+ * Close the channel
+ * Returns 1 on success, 0 on error.
+ */
+int OSSL_STORE_close(OSSL_STORE_CTX *ctx);
+
+/*
+ * Attach to a BIO.  This works like OSSL_STORE_open() except it takes a
+ * BIO instead of a uri, along with a scheme to use when reading.
+ * The given UI method will be used any time the loader needs extra input,
+ * for example when a password or pin is needed, and will be passed the
+ * same user data every time it's needed in this context.
+ *
+ * Returns a context reference which represents the channel to communicate
+ * through.
+ *
+ * Note that this function is considered unsafe, all depending on what the
+ * BIO actually reads.
+ */
+OSSL_STORE_CTX *OSSL_STORE_attach(BIO *bio, const char *scheme,
+                                  OSSL_LIB_CTX *libctx, const char *propq,
+                                  const UI_METHOD *ui_method, void *ui_data,
+                                  const OSSL_PARAM params[],
+                                  OSSL_STORE_post_process_info_fn post_process,
+                                  void *post_process_data);
+
+/*-
+ *  Extracting OpenSSL types from and creating new OSSL_STORE_INFOs
+ *  ---------------------------------------------------------------
+ */
+
+/*
+ * Types of data that can be ossl_stored in a OSSL_STORE_INFO.
+ * OSSL_STORE_INFO_NAME is typically found when getting a listing of
+ * available "files" / "tokens" / what have you.
+ */
+# define OSSL_STORE_INFO_NAME           1   /* char * */
+# define OSSL_STORE_INFO_PARAMS         2   /* EVP_PKEY * */
+# define OSSL_STORE_INFO_PUBKEY         3   /* EVP_PKEY * */
+# define OSSL_STORE_INFO_PKEY           4   /* EVP_PKEY * */
+# define OSSL_STORE_INFO_CERT           5   /* X509 * */
+# define OSSL_STORE_INFO_CRL            6   /* X509_CRL * */
+
+/*
+ * Functions to generate OSSL_STORE_INFOs, one function for each type we
+ * support having in them, as well as a generic constructor.
+ *
+ * In all cases, ownership of the object is transferred to the OSSL_STORE_INFO
+ * and will therefore be freed when the OSSL_STORE_INFO is freed.
+ */
+OSSL_STORE_INFO *OSSL_STORE_INFO_new(int type, void *data);
+OSSL_STORE_INFO *OSSL_STORE_INFO_new_NAME(char *name);
+int OSSL_STORE_INFO_set0_NAME_description(OSSL_STORE_INFO *info, char *desc);
+OSSL_STORE_INFO *OSSL_STORE_INFO_new_PARAMS(EVP_PKEY *params);
+OSSL_STORE_INFO *OSSL_STORE_INFO_new_PUBKEY(EVP_PKEY *pubkey);
+OSSL_STORE_INFO *OSSL_STORE_INFO_new_PKEY(EVP_PKEY *pkey);
+OSSL_STORE_INFO *OSSL_STORE_INFO_new_CERT(X509 *x509);
+OSSL_STORE_INFO *OSSL_STORE_INFO_new_CRL(X509_CRL *crl);
+
+/*
+ * Functions to try to extract data from a OSSL_STORE_INFO.
+ */
+int OSSL_STORE_INFO_get_type(const OSSL_STORE_INFO *info);
+void *OSSL_STORE_INFO_get0_data(int type, const OSSL_STORE_INFO *info);
+const char *OSSL_STORE_INFO_get0_NAME(const OSSL_STORE_INFO *info);
+char *OSSL_STORE_INFO_get1_NAME(const OSSL_STORE_INFO *info);
+const char *OSSL_STORE_INFO_get0_NAME_description(const OSSL_STORE_INFO *info);
+char *OSSL_STORE_INFO_get1_NAME_description(const OSSL_STORE_INFO *info);
+EVP_PKEY *OSSL_STORE_INFO_get0_PARAMS(const OSSL_STORE_INFO *info);
+EVP_PKEY *OSSL_STORE_INFO_get1_PARAMS(const OSSL_STORE_INFO *info);
+EVP_PKEY *OSSL_STORE_INFO_get0_PUBKEY(const OSSL_STORE_INFO *info);
+EVP_PKEY *OSSL_STORE_INFO_get1_PUBKEY(const OSSL_STORE_INFO *info);
+EVP_PKEY *OSSL_STORE_INFO_get0_PKEY(const OSSL_STORE_INFO *info);
+EVP_PKEY *OSSL_STORE_INFO_get1_PKEY(const OSSL_STORE_INFO *info);
+X509 *OSSL_STORE_INFO_get0_CERT(const OSSL_STORE_INFO *info);
+X509 *OSSL_STORE_INFO_get1_CERT(const OSSL_STORE_INFO *info);
+X509_CRL *OSSL_STORE_INFO_get0_CRL(const OSSL_STORE_INFO *info);
+X509_CRL *OSSL_STORE_INFO_get1_CRL(const OSSL_STORE_INFO *info);
+
+const char *OSSL_STORE_INFO_type_string(int type);
+
+/*
+ * Free the OSSL_STORE_INFO
+ */
+void OSSL_STORE_INFO_free(OSSL_STORE_INFO *info);
+
+
+/*-
+ *  Functions to construct a search URI from a base URI and search criteria
+ *  -----------------------------------------------------------------------
+ */
+
+/* OSSL_STORE search types */
+# define OSSL_STORE_SEARCH_BY_NAME              1 /* subject in certs, issuer in CRLs */
+# define OSSL_STORE_SEARCH_BY_ISSUER_SERIAL     2
+# define OSSL_STORE_SEARCH_BY_KEY_FINGERPRINT   3
+# define OSSL_STORE_SEARCH_BY_ALIAS             4
+
+/* To check what search types the scheme handler supports */
+int OSSL_STORE_supports_search(OSSL_STORE_CTX *ctx, int search_type);
+
+/* Search term constructors */
+/*
+ * The input is considered to be owned by the caller, and must therefore
+ * remain present throughout the lifetime of the returned OSSL_STORE_SEARCH
+ */
+OSSL_STORE_SEARCH *OSSL_STORE_SEARCH_by_name(X509_NAME *name);
+OSSL_STORE_SEARCH *OSSL_STORE_SEARCH_by_issuer_serial(X509_NAME *name,
+                                                      const ASN1_INTEGER
+                                                      *serial);
+OSSL_STORE_SEARCH *OSSL_STORE_SEARCH_by_key_fingerprint(const EVP_MD *digest,
+                                                        const unsigned char
+                                                        *bytes, size_t len);
+OSSL_STORE_SEARCH *OSSL_STORE_SEARCH_by_alias(const char *alias);
+
+/* Search term destructor */
+void OSSL_STORE_SEARCH_free(OSSL_STORE_SEARCH *search);
+
+/* Search term accessors */
+int OSSL_STORE_SEARCH_get_type(const OSSL_STORE_SEARCH *criterion);
+X509_NAME *OSSL_STORE_SEARCH_get0_name(const OSSL_STORE_SEARCH *criterion);
+const ASN1_INTEGER *OSSL_STORE_SEARCH_get0_serial(const OSSL_STORE_SEARCH
+                                                  *criterion);
+const unsigned char *OSSL_STORE_SEARCH_get0_bytes(const OSSL_STORE_SEARCH
+                                                  *criterion, size_t *length);
+const char *OSSL_STORE_SEARCH_get0_string(const OSSL_STORE_SEARCH *criterion);
+const EVP_MD *OSSL_STORE_SEARCH_get0_digest(const OSSL_STORE_SEARCH *criterion);
+
+/*
+ * Add search criterion and expected return type (which can be unspecified)
+ * to the loading channel.  This MUST happen before the first OSSL_STORE_load().
+ */
+int OSSL_STORE_expect(OSSL_STORE_CTX *ctx, int expected_type);
+int OSSL_STORE_find(OSSL_STORE_CTX *ctx, const OSSL_STORE_SEARCH *search);
+
+
+/*-
+ *  Function to fetch a loader and extract data from it
+ *  ---------------------------------------------------
+ */
+
+typedef struct ossl_store_loader_st OSSL_STORE_LOADER;
+
+OSSL_STORE_LOADER *OSSL_STORE_LOADER_fetch(OSSL_LIB_CTX *libctx,
+                                           const char *scheme,
+                                           const char *properties);
+int OSSL_STORE_LOADER_up_ref(OSSL_STORE_LOADER *loader);
+void OSSL_STORE_LOADER_free(OSSL_STORE_LOADER *loader);
+const OSSL_PROVIDER *OSSL_STORE_LOADER_get0_provider(const OSSL_STORE_LOADER *
+                                                loader);
+const char *OSSL_STORE_LOADER_get0_properties(const OSSL_STORE_LOADER *loader);
+const char *OSSL_STORE_LOADER_get0_description(const OSSL_STORE_LOADER *loader);
+int OSSL_STORE_LOADER_is_a(const OSSL_STORE_LOADER *loader,
+                           const char *scheme);
+void OSSL_STORE_LOADER_do_all_provided(OSSL_LIB_CTX *libctx,
+                                       void (*fn)(OSSL_STORE_LOADER *loader,
+                                                  void *arg),
+                                       void *arg);
+int OSSL_STORE_LOADER_names_do_all(const OSSL_STORE_LOADER *loader,
+                                   void (*fn)(const char *name, void *data),
+                                   void *data);
+
+/*-
+ *  Function to register a loader for the given URI scheme.
+ *  -------------------------------------------------------
+ *
+ *  The loader receives all the main components of an URI except for the
+ *  scheme.
+ */
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+
+/* struct ossl_store_loader_ctx_st is defined differently by each loader */
+typedef struct ossl_store_loader_ctx_st OSSL_STORE_LOADER_CTX;
+typedef OSSL_STORE_LOADER_CTX *(*OSSL_STORE_open_fn)
+    (const OSSL_STORE_LOADER *loader, const char *uri,
+     const UI_METHOD *ui_method, void *ui_data);
+typedef OSSL_STORE_LOADER_CTX *(*OSSL_STORE_open_ex_fn)
+    (const OSSL_STORE_LOADER *loader,
+     const char *uri, OSSL_LIB_CTX *libctx, const char *propq,
+     const UI_METHOD *ui_method, void *ui_data);
+
+typedef OSSL_STORE_LOADER_CTX *(*OSSL_STORE_attach_fn)
+    (const OSSL_STORE_LOADER *loader, BIO *bio,
+     OSSL_LIB_CTX *libctx, const char *propq,
+     const UI_METHOD *ui_method, void *ui_data);
+typedef int (*OSSL_STORE_ctrl_fn)
+    (OSSL_STORE_LOADER_CTX *ctx, int cmd, va_list args);
+typedef int (*OSSL_STORE_expect_fn)
+    (OSSL_STORE_LOADER_CTX *ctx, int expected);
+typedef int (*OSSL_STORE_find_fn)
+    (OSSL_STORE_LOADER_CTX *ctx, const OSSL_STORE_SEARCH *criteria);
+typedef OSSL_STORE_INFO *(*OSSL_STORE_load_fn)
+    (OSSL_STORE_LOADER_CTX *ctx, const UI_METHOD *ui_method, void *ui_data);
+typedef int (*OSSL_STORE_eof_fn)(OSSL_STORE_LOADER_CTX *ctx);
+typedef int (*OSSL_STORE_error_fn)(OSSL_STORE_LOADER_CTX *ctx);
+typedef int (*OSSL_STORE_close_fn)(OSSL_STORE_LOADER_CTX *ctx);
+
+# endif
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+OSSL_STORE_LOADER *OSSL_STORE_LOADER_new(ENGINE *e, const char *scheme);
+OSSL_DEPRECATEDIN_3_0
+int OSSL_STORE_LOADER_set_open(OSSL_STORE_LOADER *loader,
+                               OSSL_STORE_open_fn open_function);
+OSSL_DEPRECATEDIN_3_0
+int OSSL_STORE_LOADER_set_open_ex(OSSL_STORE_LOADER *loader,
+                                  OSSL_STORE_open_ex_fn open_ex_function);
+OSSL_DEPRECATEDIN_3_0
+int OSSL_STORE_LOADER_set_attach(OSSL_STORE_LOADER *loader,
+                                 OSSL_STORE_attach_fn attach_function);
+OSSL_DEPRECATEDIN_3_0
+int OSSL_STORE_LOADER_set_ctrl(OSSL_STORE_LOADER *loader,
+                               OSSL_STORE_ctrl_fn ctrl_function);
+OSSL_DEPRECATEDIN_3_0
+int OSSL_STORE_LOADER_set_expect(OSSL_STORE_LOADER *loader,
+                                 OSSL_STORE_expect_fn expect_function);
+OSSL_DEPRECATEDIN_3_0
+int OSSL_STORE_LOADER_set_find(OSSL_STORE_LOADER *loader,
+                               OSSL_STORE_find_fn find_function);
+OSSL_DEPRECATEDIN_3_0
+int OSSL_STORE_LOADER_set_load(OSSL_STORE_LOADER *loader,
+                               OSSL_STORE_load_fn load_function);
+OSSL_DEPRECATEDIN_3_0
+int OSSL_STORE_LOADER_set_eof(OSSL_STORE_LOADER *loader,
+                              OSSL_STORE_eof_fn eof_function);
+OSSL_DEPRECATEDIN_3_0
+int OSSL_STORE_LOADER_set_error(OSSL_STORE_LOADER *loader,
+                                OSSL_STORE_error_fn error_function);
+OSSL_DEPRECATEDIN_3_0
+int OSSL_STORE_LOADER_set_close(OSSL_STORE_LOADER *loader,
+                                OSSL_STORE_close_fn close_function);
+OSSL_DEPRECATEDIN_3_0
+const ENGINE *OSSL_STORE_LOADER_get0_engine(const OSSL_STORE_LOADER *loader);
+OSSL_DEPRECATEDIN_3_0
+const char *OSSL_STORE_LOADER_get0_scheme(const OSSL_STORE_LOADER *loader);
+OSSL_DEPRECATEDIN_3_0
+int OSSL_STORE_register_loader(OSSL_STORE_LOADER *loader);
+OSSL_DEPRECATEDIN_3_0
+OSSL_STORE_LOADER *OSSL_STORE_unregister_loader(const char *scheme);
+# endif
+
+/*-
+ *  Functions to list STORE loaders
+ *  -------------------------------
+ */
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+int OSSL_STORE_do_all_loaders(void (*do_function)(const OSSL_STORE_LOADER *loader,
+                                                  void *do_arg),
+                              void *do_arg);
+# endif
+
+# ifdef  __cplusplus
+}
+# endif
+#endif
diff --git a/src/include/openssl/storeerr.h b/src/include/openssl/storeerr.h
new file mode 100644
index 0000000..00529c8
--- /dev/null
+++ b/src/include/openssl/storeerr.h
@@ -0,0 +1,49 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_STOREERR_H
+# define OPENSSL_STOREERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+
+/*
+ * OSSL_STORE reason codes.
+ */
+# define OSSL_STORE_R_AMBIGUOUS_CONTENT_TYPE              107
+# define OSSL_STORE_R_BAD_PASSWORD_READ                   115
+# define OSSL_STORE_R_ERROR_VERIFYING_PKCS12_MAC          113
+# define OSSL_STORE_R_FINGERPRINT_SIZE_DOES_NOT_MATCH_DIGEST 121
+# define OSSL_STORE_R_INVALID_SCHEME                      106
+# define OSSL_STORE_R_IS_NOT_A                            112
+# define OSSL_STORE_R_LOADER_INCOMPLETE                   116
+# define OSSL_STORE_R_LOADING_STARTED                     117
+# define OSSL_STORE_R_NOT_A_CERTIFICATE                   100
+# define OSSL_STORE_R_NOT_A_CRL                           101
+# define OSSL_STORE_R_NOT_A_NAME                          103
+# define OSSL_STORE_R_NOT_A_PRIVATE_KEY                   102
+# define OSSL_STORE_R_NOT_A_PUBLIC_KEY                    122
+# define OSSL_STORE_R_NOT_PARAMETERS                      104
+# define OSSL_STORE_R_NO_LOADERS_FOUND                    123
+# define OSSL_STORE_R_PASSPHRASE_CALLBACK_ERROR           114
+# define OSSL_STORE_R_PATH_MUST_BE_ABSOLUTE               108
+# define OSSL_STORE_R_SEARCH_ONLY_SUPPORTED_FOR_DIRECTORIES 119
+# define OSSL_STORE_R_UI_PROCESS_INTERRUPTED_OR_CANCELLED 109
+# define OSSL_STORE_R_UNREGISTERED_SCHEME                 105
+# define OSSL_STORE_R_UNSUPPORTED_CONTENT_TYPE            110
+# define OSSL_STORE_R_UNSUPPORTED_OPERATION               118
+# define OSSL_STORE_R_UNSUPPORTED_SEARCH_TYPE             120
+# define OSSL_STORE_R_URI_AUTHORITY_UNSUPPORTED           111
+
+#endif
diff --git a/src/include/openssl/symhacks.h b/src/include/openssl/symhacks.h
new file mode 100644
index 0000000..816f8f9
--- /dev/null
+++ b/src/include/openssl/symhacks.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright 1999-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_SYMHACKS_H
+# define OPENSSL_SYMHACKS_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_SYMHACKS_H
+# endif
+
+# include <openssl/e_os2.h>
+
+/* Case insensitive linking causes problems.... */
+# if defined(OPENSSL_SYS_VMS)
+#  undef ERR_load_CRYPTO_strings
+#  define ERR_load_CRYPTO_strings                 ERR_load_CRYPTOlib_strings
+#  undef OCSP_crlID_new
+#  define OCSP_crlID_new                          OCSP_crlID2_new
+
+#  undef d2i_ECPARAMETERS
+#  define d2i_ECPARAMETERS                        d2i_UC_ECPARAMETERS
+#  undef i2d_ECPARAMETERS
+#  define i2d_ECPARAMETERS                        i2d_UC_ECPARAMETERS
+#  undef d2i_ECPKPARAMETERS
+#  define d2i_ECPKPARAMETERS                      d2i_UC_ECPKPARAMETERS
+#  undef i2d_ECPKPARAMETERS
+#  define i2d_ECPKPARAMETERS                      i2d_UC_ECPKPARAMETERS
+
+# endif
+
+#endif                          /* ! defined HEADER_VMS_IDHACKS_H */
diff --git a/src/include/openssl/thread.h b/src/include/openssl/thread.h
new file mode 100644
index 0000000..3926ce5
--- /dev/null
+++ b/src/include/openssl/thread.h
@@ -0,0 +1,31 @@
+/*
+ * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_THREAD_H
+# define OPENSSL_THREAD_H
+
+# define OSSL_THREAD_SUPPORT_FLAG_THREAD_POOL (1U<<0)
+# define OSSL_THREAD_SUPPORT_FLAG_DEFAULT_SPAWN (1U<<1)
+
+# include <openssl/types.h>
+
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+uint32_t OSSL_get_thread_support_flags(void);
+int OSSL_set_max_threads(OSSL_LIB_CTX *ctx, uint64_t max_threads);
+uint64_t OSSL_get_max_threads(OSSL_LIB_CTX *ctx);
+
+# ifdef  __cplusplus
+}
+# endif
+
+#endif /* OPENSSL_THREAD_H */
diff --git a/src/include/openssl/tls1.h b/src/include/openssl/tls1.h
new file mode 100644
index 0000000..5329338
--- /dev/null
+++ b/src/include/openssl/tls1.h
@@ -0,0 +1,1212 @@
+/*
+ * Copyright 1995-2024 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved
+ * Copyright 2005 Nokia. All rights reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_TLS1_H
+# define OPENSSL_TLS1_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_TLS1_H
+# endif
+
+# include <openssl/buffer.h>
+# include <openssl/x509.h>
+# include <openssl/prov_ssl.h>
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+/* Default security level if not overridden at config time */
+# ifndef OPENSSL_TLS_SECURITY_LEVEL
+#  define OPENSSL_TLS_SECURITY_LEVEL 2
+# endif
+
+/* TLS*_VERSION constants are defined in prov_ssl.h */
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define TLS_MAX_VERSION                TLS1_3_VERSION
+# endif
+
+/* Special value for method supporting multiple versions */
+# define TLS_ANY_VERSION                 0x10000
+
+# define TLS1_VERSION_MAJOR              0x03
+# define TLS1_VERSION_MINOR              0x01
+
+# define TLS1_1_VERSION_MAJOR            0x03
+# define TLS1_1_VERSION_MINOR            0x02
+
+# define TLS1_2_VERSION_MAJOR            0x03
+# define TLS1_2_VERSION_MINOR            0x03
+
+# define TLS1_get_version(s) \
+        ((SSL_version(s) >> 8) == TLS1_VERSION_MAJOR ? SSL_version(s) : 0)
+
+# define TLS1_get_client_version(s) \
+        ((SSL_client_version(s) >> 8) == TLS1_VERSION_MAJOR ? SSL_client_version(s) : 0)
+
+# define TLS1_AD_DECRYPTION_FAILED       21
+# define TLS1_AD_RECORD_OVERFLOW         22
+# define TLS1_AD_UNKNOWN_CA              48/* fatal */
+# define TLS1_AD_ACCESS_DENIED           49/* fatal */
+# define TLS1_AD_DECODE_ERROR            50/* fatal */
+# define TLS1_AD_DECRYPT_ERROR           51
+# define TLS1_AD_EXPORT_RESTRICTION      60/* fatal */
+# define TLS1_AD_PROTOCOL_VERSION        70/* fatal */
+# define TLS1_AD_INSUFFICIENT_SECURITY   71/* fatal */
+# define TLS1_AD_INTERNAL_ERROR          80/* fatal */
+# define TLS1_AD_INAPPROPRIATE_FALLBACK  86/* fatal */
+# define TLS1_AD_USER_CANCELLED          90
+# define TLS1_AD_NO_RENEGOTIATION        100
+/* TLSv1.3 alerts */
+# define TLS13_AD_MISSING_EXTENSION      109 /* fatal */
+# define TLS13_AD_CERTIFICATE_REQUIRED   116 /* fatal */
+/* codes 110-114 are from RFC3546 */
+# define TLS1_AD_UNSUPPORTED_EXTENSION   110
+# define TLS1_AD_CERTIFICATE_UNOBTAINABLE 111
+# define TLS1_AD_UNRECOGNIZED_NAME       112
+# define TLS1_AD_BAD_CERTIFICATE_STATUS_RESPONSE 113
+# define TLS1_AD_BAD_CERTIFICATE_HASH_VALUE 114
+# define TLS1_AD_UNKNOWN_PSK_IDENTITY    115/* fatal */
+# define TLS1_AD_NO_APPLICATION_PROTOCOL 120 /* fatal */
+
+/* ExtensionType values from RFC3546 / RFC4366 / RFC6066 */
+# define TLSEXT_TYPE_server_name                 0
+# define TLSEXT_TYPE_max_fragment_length         1
+# define TLSEXT_TYPE_client_certificate_url      2
+# define TLSEXT_TYPE_trusted_ca_keys             3
+# define TLSEXT_TYPE_truncated_hmac              4
+# define TLSEXT_TYPE_status_request              5
+/* ExtensionType values from RFC4681 */
+# define TLSEXT_TYPE_user_mapping                6
+/* ExtensionType values from RFC5878 */
+# define TLSEXT_TYPE_client_authz                7
+# define TLSEXT_TYPE_server_authz                8
+/* ExtensionType values from RFC6091 */
+# define TLSEXT_TYPE_cert_type           9
+
+/* ExtensionType values from RFC4492 */
+/*
+ * Prior to TLSv1.3 the supported_groups extension was known as
+ * elliptic_curves
+ */
+# define TLSEXT_TYPE_supported_groups            10
+# define TLSEXT_TYPE_elliptic_curves             TLSEXT_TYPE_supported_groups
+# define TLSEXT_TYPE_ec_point_formats            11
+
+
+/* ExtensionType value from RFC5054 */
+# define TLSEXT_TYPE_srp                         12
+
+/* ExtensionType values from RFC5246 */
+# define TLSEXT_TYPE_signature_algorithms        13
+
+/* ExtensionType value from RFC5764 */
+# define TLSEXT_TYPE_use_srtp    14
+
+/* ExtensionType value from RFC7301 */
+# define TLSEXT_TYPE_application_layer_protocol_negotiation 16
+
+/*
+ * Extension type for Certificate Transparency
+ * https://tools.ietf.org/html/rfc6962#section-3.3.1
+ */
+# define TLSEXT_TYPE_signed_certificate_timestamp    18
+
+/*
+ * Extension type for Raw Public Keys
+ * https://tools.ietf.org/html/rfc7250
+ * https://www.iana.org/assignments/tls-extensiontype-values/tls-extensiontype-values.xhtml
+ */
+# define TLSEXT_TYPE_client_cert_type   19
+# define TLSEXT_TYPE_server_cert_type   20
+
+/*
+ * ExtensionType value for TLS padding extension.
+ * http://tools.ietf.org/html/draft-agl-tls-padding
+ */
+# define TLSEXT_TYPE_padding     21
+
+/* ExtensionType value from RFC7366 */
+# define TLSEXT_TYPE_encrypt_then_mac    22
+
+/* ExtensionType value from RFC7627 */
+# define TLSEXT_TYPE_extended_master_secret      23
+
+/* ExtensionType value from RFC8879 */
+# define TLSEXT_TYPE_compress_certificate        27
+
+/* ExtensionType value from RFC4507 */
+# define TLSEXT_TYPE_session_ticket              35
+
+/* As defined for TLS1.3 */
+# define TLSEXT_TYPE_psk                         41
+# define TLSEXT_TYPE_early_data                  42
+# define TLSEXT_TYPE_supported_versions          43
+# define TLSEXT_TYPE_cookie                      44
+# define TLSEXT_TYPE_psk_kex_modes               45
+# define TLSEXT_TYPE_certificate_authorities     47
+# define TLSEXT_TYPE_post_handshake_auth         49
+# define TLSEXT_TYPE_signature_algorithms_cert   50
+# define TLSEXT_TYPE_key_share                   51
+# define TLSEXT_TYPE_quic_transport_parameters   57
+
+/* Temporary extension type */
+# define TLSEXT_TYPE_renegotiate                 0xff01
+
+# ifndef OPENSSL_NO_NEXTPROTONEG
+/* This is not an IANA defined extension number */
+#  define TLSEXT_TYPE_next_proto_neg              13172
+# endif
+
+/* NameType value from RFC3546 */
+# define TLSEXT_NAMETYPE_host_name 0
+/* status request value from RFC3546 */
+# define TLSEXT_STATUSTYPE_ocsp 1
+
+/* ECPointFormat values from RFC4492 */
+# define TLSEXT_ECPOINTFORMAT_first                      0
+# define TLSEXT_ECPOINTFORMAT_uncompressed               0
+# define TLSEXT_ECPOINTFORMAT_ansiX962_compressed_prime  1
+# define TLSEXT_ECPOINTFORMAT_ansiX962_compressed_char2  2
+# define TLSEXT_ECPOINTFORMAT_last                       2
+
+/* Signature and hash algorithms from RFC5246 */
+# define TLSEXT_signature_anonymous                      0
+# define TLSEXT_signature_rsa                            1
+# define TLSEXT_signature_dsa                            2
+# define TLSEXT_signature_ecdsa                          3
+# define TLSEXT_signature_gostr34102001                  237
+# define TLSEXT_signature_gostr34102012_256              238
+# define TLSEXT_signature_gostr34102012_512              239
+
+/* Total number of different signature algorithms */
+# define TLSEXT_signature_num                            7
+
+# define TLSEXT_hash_none                                0
+# define TLSEXT_hash_md5                                 1
+# define TLSEXT_hash_sha1                                2
+# define TLSEXT_hash_sha224                              3
+# define TLSEXT_hash_sha256                              4
+# define TLSEXT_hash_sha384                              5
+# define TLSEXT_hash_sha512                              6
+# define TLSEXT_hash_gostr3411                           237
+# define TLSEXT_hash_gostr34112012_256                   238
+# define TLSEXT_hash_gostr34112012_512                   239
+
+/* Total number of different digest algorithms */
+
+# define TLSEXT_hash_num                                 10
+
+/* Possible compression values from RFC8879 */
+/* Not defined in RFC8879, but used internally for no-compression */
+# define TLSEXT_comp_cert_none                            0
+# define TLSEXT_comp_cert_zlib                            1
+# define TLSEXT_comp_cert_brotli                          2
+# define TLSEXT_comp_cert_zstd                            3
+/* one more than the number of defined values - used as size of 0-terminated array */
+# define TLSEXT_comp_cert_limit                           4
+
+/* Flag set for unrecognised algorithms */
+# define TLSEXT_nid_unknown                              0x1000000
+
+/* ECC curves */
+
+# define TLSEXT_curve_P_256                              23
+# define TLSEXT_curve_P_384                              24
+
+/* OpenSSL value to disable maximum fragment length extension */
+# define TLSEXT_max_fragment_length_DISABLED    0
+/* Allowed values for max fragment length extension */
+# define TLSEXT_max_fragment_length_512         1
+# define TLSEXT_max_fragment_length_1024        2
+# define TLSEXT_max_fragment_length_2048        3
+# define TLSEXT_max_fragment_length_4096        4
+/* OpenSSL value for unset maximum fragment length extension */
+# define TLSEXT_max_fragment_length_UNSPECIFIED 255
+
+/*
+ * TLS Certificate Type (for RFC7250)
+ * https://www.iana.org/assignments/tls-extensiontype-values/tls-extensiontype-values.xhtml#tls-extensiontype-values-3
+ */
+# define TLSEXT_cert_type_x509         0
+# define TLSEXT_cert_type_pgp          1 /* recognized, but not supported */
+# define TLSEXT_cert_type_rpk          2
+# define TLSEXT_cert_type_1609dot2     3 /* recognized, but not supported */
+
+int SSL_CTX_set_tlsext_max_fragment_length(SSL_CTX *ctx, uint8_t mode);
+int SSL_set_tlsext_max_fragment_length(SSL *ssl, uint8_t mode);
+
+# define TLSEXT_MAXLEN_host_name 255
+
+__owur const char *SSL_get_servername(const SSL *s, const int type);
+__owur int SSL_get_servername_type(const SSL *s);
+/*
+ * SSL_export_keying_material exports a value derived from the master secret,
+ * as specified in RFC 5705. It writes |olen| bytes to |out| given a label and
+ * optional context. (Since a zero length context is allowed, the |use_context|
+ * flag controls whether a context is included.) It returns 1 on success and
+ * 0 or -1 otherwise.
+ */
+__owur int SSL_export_keying_material(SSL *s, unsigned char *out, size_t olen,
+                                      const char *label, size_t llen,
+                                      const unsigned char *context,
+                                      size_t contextlen, int use_context);
+
+/*
+ * SSL_export_keying_material_early exports a value derived from the
+ * early exporter master secret, as specified in
+ * https://tools.ietf.org/html/draft-ietf-tls-tls13-23. It writes
+ * |olen| bytes to |out| given a label and optional context. It
+ * returns 1 on success and 0 otherwise.
+ */
+__owur int SSL_export_keying_material_early(SSL *s, unsigned char *out,
+                                            size_t olen, const char *label,
+                                            size_t llen,
+                                            const unsigned char *context,
+                                            size_t contextlen);
+
+int SSL_get_peer_signature_type_nid(const SSL *s, int *pnid);
+int SSL_get_signature_type_nid(const SSL *s, int *pnid);
+
+int SSL_get_sigalgs(SSL *s, int idx,
+                    int *psign, int *phash, int *psignandhash,
+                    unsigned char *rsig, unsigned char *rhash);
+
+int SSL_get_shared_sigalgs(SSL *s, int idx,
+                           int *psign, int *phash, int *psignandhash,
+                           unsigned char *rsig, unsigned char *rhash);
+
+__owur int SSL_check_chain(SSL *s, X509 *x, EVP_PKEY *pk, STACK_OF(X509) *chain);
+
+# define SSL_set_tlsext_host_name(s,name) \
+        SSL_ctrl(s,SSL_CTRL_SET_TLSEXT_HOSTNAME,TLSEXT_NAMETYPE_host_name,\
+                (void *)name)
+
+# define SSL_set_tlsext_debug_callback(ssl, cb) \
+        SSL_callback_ctrl(ssl,SSL_CTRL_SET_TLSEXT_DEBUG_CB,\
+                (void (*)(void))cb)
+
+# define SSL_set_tlsext_debug_arg(ssl, arg) \
+        SSL_ctrl(ssl,SSL_CTRL_SET_TLSEXT_DEBUG_ARG,0,arg)
+
+# define SSL_get_tlsext_status_type(ssl) \
+        SSL_ctrl(ssl,SSL_CTRL_GET_TLSEXT_STATUS_REQ_TYPE,0,NULL)
+
+# define SSL_set_tlsext_status_type(ssl, type) \
+        SSL_ctrl(ssl,SSL_CTRL_SET_TLSEXT_STATUS_REQ_TYPE,type,NULL)
+
+# define SSL_get_tlsext_status_exts(ssl, arg) \
+        SSL_ctrl(ssl,SSL_CTRL_GET_TLSEXT_STATUS_REQ_EXTS,0,arg)
+
+# define SSL_set_tlsext_status_exts(ssl, arg) \
+        SSL_ctrl(ssl,SSL_CTRL_SET_TLSEXT_STATUS_REQ_EXTS,0,arg)
+
+# define SSL_get_tlsext_status_ids(ssl, arg) \
+        SSL_ctrl(ssl,SSL_CTRL_GET_TLSEXT_STATUS_REQ_IDS,0,arg)
+
+# define SSL_set_tlsext_status_ids(ssl, arg) \
+        SSL_ctrl(ssl,SSL_CTRL_SET_TLSEXT_STATUS_REQ_IDS,0,arg)
+
+# define SSL_get_tlsext_status_ocsp_resp(ssl, arg) \
+        SSL_ctrl(ssl,SSL_CTRL_GET_TLSEXT_STATUS_REQ_OCSP_RESP,0,arg)
+
+# define SSL_set_tlsext_status_ocsp_resp(ssl, arg, arglen) \
+        SSL_ctrl(ssl,SSL_CTRL_SET_TLSEXT_STATUS_REQ_OCSP_RESP,arglen,arg)
+
+# define SSL_CTX_set_tlsext_servername_callback(ctx, cb) \
+        SSL_CTX_callback_ctrl(ctx,SSL_CTRL_SET_TLSEXT_SERVERNAME_CB,\
+                (void (*)(void))cb)
+
+# define SSL_TLSEXT_ERR_OK 0
+# define SSL_TLSEXT_ERR_ALERT_WARNING 1
+# define SSL_TLSEXT_ERR_ALERT_FATAL 2
+# define SSL_TLSEXT_ERR_NOACK 3
+
+# define SSL_CTX_set_tlsext_servername_arg(ctx, arg) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_TLSEXT_SERVERNAME_ARG,0,arg)
+
+# define SSL_CTX_get_tlsext_ticket_keys(ctx, keys, keylen) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_GET_TLSEXT_TICKET_KEYS,keylen,keys)
+# define SSL_CTX_set_tlsext_ticket_keys(ctx, keys, keylen) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_TLSEXT_TICKET_KEYS,keylen,keys)
+
+# define SSL_CTX_get_tlsext_status_cb(ssl, cb) \
+        SSL_CTX_ctrl(ssl,SSL_CTRL_GET_TLSEXT_STATUS_REQ_CB,0,(void *)cb)
+# define SSL_CTX_set_tlsext_status_cb(ssl, cb) \
+        SSL_CTX_callback_ctrl(ssl,SSL_CTRL_SET_TLSEXT_STATUS_REQ_CB,\
+                (void (*)(void))cb)
+
+# define SSL_CTX_get_tlsext_status_arg(ssl, arg) \
+        SSL_CTX_ctrl(ssl,SSL_CTRL_GET_TLSEXT_STATUS_REQ_CB_ARG,0,arg)
+# define SSL_CTX_set_tlsext_status_arg(ssl, arg) \
+        SSL_CTX_ctrl(ssl,SSL_CTRL_SET_TLSEXT_STATUS_REQ_CB_ARG,0,arg)
+
+# define SSL_CTX_set_tlsext_status_type(ssl, type) \
+        SSL_CTX_ctrl(ssl,SSL_CTRL_SET_TLSEXT_STATUS_REQ_TYPE,type,NULL)
+
+# define SSL_CTX_get_tlsext_status_type(ssl) \
+        SSL_CTX_ctrl(ssl,SSL_CTRL_GET_TLSEXT_STATUS_REQ_TYPE,0,NULL)
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define SSL_CTX_set_tlsext_ticket_key_cb(ssl, cb) \
+        SSL_CTX_callback_ctrl(ssl,SSL_CTRL_SET_TLSEXT_TICKET_KEY_CB,\
+                (void (*)(void))cb)
+# endif
+int SSL_CTX_set_tlsext_ticket_key_evp_cb
+    (SSL_CTX *ctx, int (*fp)(SSL *, unsigned char *, unsigned char *,
+                             EVP_CIPHER_CTX *, EVP_MAC_CTX *, int));
+
+/* PSK ciphersuites from 4279 */
+# define TLS1_CK_PSK_WITH_RC4_128_SHA                    0x0300008A
+# define TLS1_CK_PSK_WITH_3DES_EDE_CBC_SHA               0x0300008B
+# define TLS1_CK_PSK_WITH_AES_128_CBC_SHA                0x0300008C
+# define TLS1_CK_PSK_WITH_AES_256_CBC_SHA                0x0300008D
+# define TLS1_CK_DHE_PSK_WITH_RC4_128_SHA                0x0300008E
+# define TLS1_CK_DHE_PSK_WITH_3DES_EDE_CBC_SHA           0x0300008F
+# define TLS1_CK_DHE_PSK_WITH_AES_128_CBC_SHA            0x03000090
+# define TLS1_CK_DHE_PSK_WITH_AES_256_CBC_SHA            0x03000091
+# define TLS1_CK_RSA_PSK_WITH_RC4_128_SHA                0x03000092
+# define TLS1_CK_RSA_PSK_WITH_3DES_EDE_CBC_SHA           0x03000093
+# define TLS1_CK_RSA_PSK_WITH_AES_128_CBC_SHA            0x03000094
+# define TLS1_CK_RSA_PSK_WITH_AES_256_CBC_SHA            0x03000095
+
+/* PSK ciphersuites from 5487 */
+# define TLS1_CK_PSK_WITH_AES_128_GCM_SHA256             0x030000A8
+# define TLS1_CK_PSK_WITH_AES_256_GCM_SHA384             0x030000A9
+# define TLS1_CK_DHE_PSK_WITH_AES_128_GCM_SHA256         0x030000AA
+# define TLS1_CK_DHE_PSK_WITH_AES_256_GCM_SHA384         0x030000AB
+# define TLS1_CK_RSA_PSK_WITH_AES_128_GCM_SHA256         0x030000AC
+# define TLS1_CK_RSA_PSK_WITH_AES_256_GCM_SHA384         0x030000AD
+# define TLS1_CK_PSK_WITH_AES_128_CBC_SHA256             0x030000AE
+# define TLS1_CK_PSK_WITH_AES_256_CBC_SHA384             0x030000AF
+# define TLS1_CK_PSK_WITH_NULL_SHA256                    0x030000B0
+# define TLS1_CK_PSK_WITH_NULL_SHA384                    0x030000B1
+# define TLS1_CK_DHE_PSK_WITH_AES_128_CBC_SHA256         0x030000B2
+# define TLS1_CK_DHE_PSK_WITH_AES_256_CBC_SHA384         0x030000B3
+# define TLS1_CK_DHE_PSK_WITH_NULL_SHA256                0x030000B4
+# define TLS1_CK_DHE_PSK_WITH_NULL_SHA384                0x030000B5
+# define TLS1_CK_RSA_PSK_WITH_AES_128_CBC_SHA256         0x030000B6
+# define TLS1_CK_RSA_PSK_WITH_AES_256_CBC_SHA384         0x030000B7
+# define TLS1_CK_RSA_PSK_WITH_NULL_SHA256                0x030000B8
+# define TLS1_CK_RSA_PSK_WITH_NULL_SHA384                0x030000B9
+
+/* NULL PSK ciphersuites from RFC4785 */
+# define TLS1_CK_PSK_WITH_NULL_SHA                       0x0300002C
+# define TLS1_CK_DHE_PSK_WITH_NULL_SHA                   0x0300002D
+# define TLS1_CK_RSA_PSK_WITH_NULL_SHA                   0x0300002E
+
+/* AES ciphersuites from RFC3268 */
+# define TLS1_CK_RSA_WITH_AES_128_SHA                    0x0300002F
+# define TLS1_CK_DH_DSS_WITH_AES_128_SHA                 0x03000030
+# define TLS1_CK_DH_RSA_WITH_AES_128_SHA                 0x03000031
+# define TLS1_CK_DHE_DSS_WITH_AES_128_SHA                0x03000032
+# define TLS1_CK_DHE_RSA_WITH_AES_128_SHA                0x03000033
+# define TLS1_CK_ADH_WITH_AES_128_SHA                    0x03000034
+# define TLS1_CK_RSA_WITH_AES_256_SHA                    0x03000035
+# define TLS1_CK_DH_DSS_WITH_AES_256_SHA                 0x03000036
+# define TLS1_CK_DH_RSA_WITH_AES_256_SHA                 0x03000037
+# define TLS1_CK_DHE_DSS_WITH_AES_256_SHA                0x03000038
+# define TLS1_CK_DHE_RSA_WITH_AES_256_SHA                0x03000039
+# define TLS1_CK_ADH_WITH_AES_256_SHA                    0x0300003A
+
+/* TLS v1.2 ciphersuites */
+# define TLS1_CK_RSA_WITH_NULL_SHA256                    0x0300003B
+# define TLS1_CK_RSA_WITH_AES_128_SHA256                 0x0300003C
+# define TLS1_CK_RSA_WITH_AES_256_SHA256                 0x0300003D
+# define TLS1_CK_DH_DSS_WITH_AES_128_SHA256              0x0300003E
+# define TLS1_CK_DH_RSA_WITH_AES_128_SHA256              0x0300003F
+# define TLS1_CK_DHE_DSS_WITH_AES_128_SHA256             0x03000040
+
+/* Camellia ciphersuites from RFC4132 */
+# define TLS1_CK_RSA_WITH_CAMELLIA_128_CBC_SHA           0x03000041
+# define TLS1_CK_DH_DSS_WITH_CAMELLIA_128_CBC_SHA        0x03000042
+# define TLS1_CK_DH_RSA_WITH_CAMELLIA_128_CBC_SHA        0x03000043
+# define TLS1_CK_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA       0x03000044
+# define TLS1_CK_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA       0x03000045
+# define TLS1_CK_ADH_WITH_CAMELLIA_128_CBC_SHA           0x03000046
+
+/* TLS v1.2 ciphersuites */
+# define TLS1_CK_DHE_RSA_WITH_AES_128_SHA256             0x03000067
+# define TLS1_CK_DH_DSS_WITH_AES_256_SHA256              0x03000068
+# define TLS1_CK_DH_RSA_WITH_AES_256_SHA256              0x03000069
+# define TLS1_CK_DHE_DSS_WITH_AES_256_SHA256             0x0300006A
+# define TLS1_CK_DHE_RSA_WITH_AES_256_SHA256             0x0300006B
+# define TLS1_CK_ADH_WITH_AES_128_SHA256                 0x0300006C
+# define TLS1_CK_ADH_WITH_AES_256_SHA256                 0x0300006D
+
+/* Camellia ciphersuites from RFC4132 */
+# define TLS1_CK_RSA_WITH_CAMELLIA_256_CBC_SHA           0x03000084
+# define TLS1_CK_DH_DSS_WITH_CAMELLIA_256_CBC_SHA        0x03000085
+# define TLS1_CK_DH_RSA_WITH_CAMELLIA_256_CBC_SHA        0x03000086
+# define TLS1_CK_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA       0x03000087
+# define TLS1_CK_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA       0x03000088
+# define TLS1_CK_ADH_WITH_CAMELLIA_256_CBC_SHA           0x03000089
+
+/* SEED ciphersuites from RFC4162 */
+# define TLS1_CK_RSA_WITH_SEED_SHA                       0x03000096
+# define TLS1_CK_DH_DSS_WITH_SEED_SHA                    0x03000097
+# define TLS1_CK_DH_RSA_WITH_SEED_SHA                    0x03000098
+# define TLS1_CK_DHE_DSS_WITH_SEED_SHA                   0x03000099
+# define TLS1_CK_DHE_RSA_WITH_SEED_SHA                   0x0300009A
+# define TLS1_CK_ADH_WITH_SEED_SHA                       0x0300009B
+
+/* TLS v1.2 GCM ciphersuites from RFC5288 */
+# define TLS1_CK_RSA_WITH_AES_128_GCM_SHA256             0x0300009C
+# define TLS1_CK_RSA_WITH_AES_256_GCM_SHA384             0x0300009D
+# define TLS1_CK_DHE_RSA_WITH_AES_128_GCM_SHA256         0x0300009E
+# define TLS1_CK_DHE_RSA_WITH_AES_256_GCM_SHA384         0x0300009F
+# define TLS1_CK_DH_RSA_WITH_AES_128_GCM_SHA256          0x030000A0
+# define TLS1_CK_DH_RSA_WITH_AES_256_GCM_SHA384          0x030000A1
+# define TLS1_CK_DHE_DSS_WITH_AES_128_GCM_SHA256         0x030000A2
+# define TLS1_CK_DHE_DSS_WITH_AES_256_GCM_SHA384         0x030000A3
+# define TLS1_CK_DH_DSS_WITH_AES_128_GCM_SHA256          0x030000A4
+# define TLS1_CK_DH_DSS_WITH_AES_256_GCM_SHA384          0x030000A5
+# define TLS1_CK_ADH_WITH_AES_128_GCM_SHA256             0x030000A6
+# define TLS1_CK_ADH_WITH_AES_256_GCM_SHA384             0x030000A7
+
+/* CCM ciphersuites from RFC6655 */
+# define TLS1_CK_RSA_WITH_AES_128_CCM                    0x0300C09C
+# define TLS1_CK_RSA_WITH_AES_256_CCM                    0x0300C09D
+# define TLS1_CK_DHE_RSA_WITH_AES_128_CCM                0x0300C09E
+# define TLS1_CK_DHE_RSA_WITH_AES_256_CCM                0x0300C09F
+# define TLS1_CK_RSA_WITH_AES_128_CCM_8                  0x0300C0A0
+# define TLS1_CK_RSA_WITH_AES_256_CCM_8                  0x0300C0A1
+# define TLS1_CK_DHE_RSA_WITH_AES_128_CCM_8              0x0300C0A2
+# define TLS1_CK_DHE_RSA_WITH_AES_256_CCM_8              0x0300C0A3
+# define TLS1_CK_PSK_WITH_AES_128_CCM                    0x0300C0A4
+# define TLS1_CK_PSK_WITH_AES_256_CCM                    0x0300C0A5
+# define TLS1_CK_DHE_PSK_WITH_AES_128_CCM                0x0300C0A6
+# define TLS1_CK_DHE_PSK_WITH_AES_256_CCM                0x0300C0A7
+# define TLS1_CK_PSK_WITH_AES_128_CCM_8                  0x0300C0A8
+# define TLS1_CK_PSK_WITH_AES_256_CCM_8                  0x0300C0A9
+# define TLS1_CK_DHE_PSK_WITH_AES_128_CCM_8              0x0300C0AA
+# define TLS1_CK_DHE_PSK_WITH_AES_256_CCM_8              0x0300C0AB
+
+/* CCM ciphersuites from RFC7251 */
+# define TLS1_CK_ECDHE_ECDSA_WITH_AES_128_CCM            0x0300C0AC
+# define TLS1_CK_ECDHE_ECDSA_WITH_AES_256_CCM            0x0300C0AD
+# define TLS1_CK_ECDHE_ECDSA_WITH_AES_128_CCM_8          0x0300C0AE
+# define TLS1_CK_ECDHE_ECDSA_WITH_AES_256_CCM_8          0x0300C0AF
+
+/* TLS 1.2 Camellia SHA-256 ciphersuites from RFC5932 */
+# define TLS1_CK_RSA_WITH_CAMELLIA_128_CBC_SHA256                0x030000BA
+# define TLS1_CK_DH_DSS_WITH_CAMELLIA_128_CBC_SHA256             0x030000BB
+# define TLS1_CK_DH_RSA_WITH_CAMELLIA_128_CBC_SHA256             0x030000BC
+# define TLS1_CK_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256            0x030000BD
+# define TLS1_CK_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256            0x030000BE
+# define TLS1_CK_ADH_WITH_CAMELLIA_128_CBC_SHA256                0x030000BF
+
+# define TLS1_CK_RSA_WITH_CAMELLIA_256_CBC_SHA256                0x030000C0
+# define TLS1_CK_DH_DSS_WITH_CAMELLIA_256_CBC_SHA256             0x030000C1
+# define TLS1_CK_DH_RSA_WITH_CAMELLIA_256_CBC_SHA256             0x030000C2
+# define TLS1_CK_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256            0x030000C3
+# define TLS1_CK_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256            0x030000C4
+# define TLS1_CK_ADH_WITH_CAMELLIA_256_CBC_SHA256                0x030000C5
+
+/* ECC ciphersuites from RFC4492 */
+# define TLS1_CK_ECDH_ECDSA_WITH_NULL_SHA                0x0300C001
+# define TLS1_CK_ECDH_ECDSA_WITH_RC4_128_SHA             0x0300C002
+# define TLS1_CK_ECDH_ECDSA_WITH_DES_192_CBC3_SHA        0x0300C003
+# define TLS1_CK_ECDH_ECDSA_WITH_AES_128_CBC_SHA         0x0300C004
+# define TLS1_CK_ECDH_ECDSA_WITH_AES_256_CBC_SHA         0x0300C005
+
+# define TLS1_CK_ECDHE_ECDSA_WITH_NULL_SHA               0x0300C006
+# define TLS1_CK_ECDHE_ECDSA_WITH_RC4_128_SHA            0x0300C007
+# define TLS1_CK_ECDHE_ECDSA_WITH_DES_192_CBC3_SHA       0x0300C008
+# define TLS1_CK_ECDHE_ECDSA_WITH_AES_128_CBC_SHA        0x0300C009
+# define TLS1_CK_ECDHE_ECDSA_WITH_AES_256_CBC_SHA        0x0300C00A
+
+# define TLS1_CK_ECDH_RSA_WITH_NULL_SHA                  0x0300C00B
+# define TLS1_CK_ECDH_RSA_WITH_RC4_128_SHA               0x0300C00C
+# define TLS1_CK_ECDH_RSA_WITH_DES_192_CBC3_SHA          0x0300C00D
+# define TLS1_CK_ECDH_RSA_WITH_AES_128_CBC_SHA           0x0300C00E
+# define TLS1_CK_ECDH_RSA_WITH_AES_256_CBC_SHA           0x0300C00F
+
+# define TLS1_CK_ECDHE_RSA_WITH_NULL_SHA                 0x0300C010
+# define TLS1_CK_ECDHE_RSA_WITH_RC4_128_SHA              0x0300C011
+# define TLS1_CK_ECDHE_RSA_WITH_DES_192_CBC3_SHA         0x0300C012
+# define TLS1_CK_ECDHE_RSA_WITH_AES_128_CBC_SHA          0x0300C013
+# define TLS1_CK_ECDHE_RSA_WITH_AES_256_CBC_SHA          0x0300C014
+
+# define TLS1_CK_ECDH_anon_WITH_NULL_SHA                 0x0300C015
+# define TLS1_CK_ECDH_anon_WITH_RC4_128_SHA              0x0300C016
+# define TLS1_CK_ECDH_anon_WITH_DES_192_CBC3_SHA         0x0300C017
+# define TLS1_CK_ECDH_anon_WITH_AES_128_CBC_SHA          0x0300C018
+# define TLS1_CK_ECDH_anon_WITH_AES_256_CBC_SHA          0x0300C019
+
+/* SRP ciphersuites from RFC 5054 */
+# define TLS1_CK_SRP_SHA_WITH_3DES_EDE_CBC_SHA           0x0300C01A
+# define TLS1_CK_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA       0x0300C01B
+# define TLS1_CK_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA       0x0300C01C
+# define TLS1_CK_SRP_SHA_WITH_AES_128_CBC_SHA            0x0300C01D
+# define TLS1_CK_SRP_SHA_RSA_WITH_AES_128_CBC_SHA        0x0300C01E
+# define TLS1_CK_SRP_SHA_DSS_WITH_AES_128_CBC_SHA        0x0300C01F
+# define TLS1_CK_SRP_SHA_WITH_AES_256_CBC_SHA            0x0300C020
+# define TLS1_CK_SRP_SHA_RSA_WITH_AES_256_CBC_SHA        0x0300C021
+# define TLS1_CK_SRP_SHA_DSS_WITH_AES_256_CBC_SHA        0x0300C022
+
+/* ECDH HMAC based ciphersuites from RFC5289 */
+# define TLS1_CK_ECDHE_ECDSA_WITH_AES_128_SHA256         0x0300C023
+# define TLS1_CK_ECDHE_ECDSA_WITH_AES_256_SHA384         0x0300C024
+# define TLS1_CK_ECDH_ECDSA_WITH_AES_128_SHA256          0x0300C025
+# define TLS1_CK_ECDH_ECDSA_WITH_AES_256_SHA384          0x0300C026
+# define TLS1_CK_ECDHE_RSA_WITH_AES_128_SHA256           0x0300C027
+# define TLS1_CK_ECDHE_RSA_WITH_AES_256_SHA384           0x0300C028
+# define TLS1_CK_ECDH_RSA_WITH_AES_128_SHA256            0x0300C029
+# define TLS1_CK_ECDH_RSA_WITH_AES_256_SHA384            0x0300C02A
+
+/* ECDH GCM based ciphersuites from RFC5289 */
+# define TLS1_CK_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256     0x0300C02B
+# define TLS1_CK_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384     0x0300C02C
+# define TLS1_CK_ECDH_ECDSA_WITH_AES_128_GCM_SHA256      0x0300C02D
+# define TLS1_CK_ECDH_ECDSA_WITH_AES_256_GCM_SHA384      0x0300C02E
+# define TLS1_CK_ECDHE_RSA_WITH_AES_128_GCM_SHA256       0x0300C02F
+# define TLS1_CK_ECDHE_RSA_WITH_AES_256_GCM_SHA384       0x0300C030
+# define TLS1_CK_ECDH_RSA_WITH_AES_128_GCM_SHA256        0x0300C031
+# define TLS1_CK_ECDH_RSA_WITH_AES_256_GCM_SHA384        0x0300C032
+
+/* ECDHE PSK ciphersuites from RFC5489 */
+# define TLS1_CK_ECDHE_PSK_WITH_RC4_128_SHA              0x0300C033
+# define TLS1_CK_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA         0x0300C034
+# define TLS1_CK_ECDHE_PSK_WITH_AES_128_CBC_SHA          0x0300C035
+# define TLS1_CK_ECDHE_PSK_WITH_AES_256_CBC_SHA          0x0300C036
+
+# define TLS1_CK_ECDHE_PSK_WITH_AES_128_CBC_SHA256       0x0300C037
+# define TLS1_CK_ECDHE_PSK_WITH_AES_256_CBC_SHA384       0x0300C038
+
+/* NULL PSK ciphersuites from RFC4785 */
+# define TLS1_CK_ECDHE_PSK_WITH_NULL_SHA                 0x0300C039
+# define TLS1_CK_ECDHE_PSK_WITH_NULL_SHA256              0x0300C03A
+# define TLS1_CK_ECDHE_PSK_WITH_NULL_SHA384              0x0300C03B
+
+/* Camellia-CBC ciphersuites from RFC6367 */
+# define TLS1_CK_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256 0x0300C072
+# define TLS1_CK_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384 0x0300C073
+# define TLS1_CK_ECDH_ECDSA_WITH_CAMELLIA_128_CBC_SHA256  0x0300C074
+# define TLS1_CK_ECDH_ECDSA_WITH_CAMELLIA_256_CBC_SHA384  0x0300C075
+# define TLS1_CK_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256   0x0300C076
+# define TLS1_CK_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384   0x0300C077
+# define TLS1_CK_ECDH_RSA_WITH_CAMELLIA_128_CBC_SHA256    0x0300C078
+# define TLS1_CK_ECDH_RSA_WITH_CAMELLIA_256_CBC_SHA384    0x0300C079
+
+# define TLS1_CK_PSK_WITH_CAMELLIA_128_CBC_SHA256         0x0300C094
+# define TLS1_CK_PSK_WITH_CAMELLIA_256_CBC_SHA384         0x0300C095
+# define TLS1_CK_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256     0x0300C096
+# define TLS1_CK_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384     0x0300C097
+# define TLS1_CK_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256     0x0300C098
+# define TLS1_CK_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384     0x0300C099
+# define TLS1_CK_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256   0x0300C09A
+# define TLS1_CK_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384   0x0300C09B
+
+/* draft-ietf-tls-chacha20-poly1305-03 */
+# define TLS1_CK_ECDHE_RSA_WITH_CHACHA20_POLY1305         0x0300CCA8
+# define TLS1_CK_ECDHE_ECDSA_WITH_CHACHA20_POLY1305       0x0300CCA9
+# define TLS1_CK_DHE_RSA_WITH_CHACHA20_POLY1305           0x0300CCAA
+# define TLS1_CK_PSK_WITH_CHACHA20_POLY1305               0x0300CCAB
+# define TLS1_CK_ECDHE_PSK_WITH_CHACHA20_POLY1305         0x0300CCAC
+# define TLS1_CK_DHE_PSK_WITH_CHACHA20_POLY1305           0x0300CCAD
+# define TLS1_CK_RSA_PSK_WITH_CHACHA20_POLY1305           0x0300CCAE
+
+/* TLS v1.3 ciphersuites */
+# define TLS1_3_CK_AES_128_GCM_SHA256                     0x03001301
+# define TLS1_3_CK_AES_256_GCM_SHA384                     0x03001302
+# define TLS1_3_CK_CHACHA20_POLY1305_SHA256               0x03001303
+# define TLS1_3_CK_AES_128_CCM_SHA256                     0x03001304
+# define TLS1_3_CK_AES_128_CCM_8_SHA256                   0x03001305
+
+/* Aria ciphersuites from RFC6209 */
+# define TLS1_CK_RSA_WITH_ARIA_128_GCM_SHA256             0x0300C050
+# define TLS1_CK_RSA_WITH_ARIA_256_GCM_SHA384             0x0300C051
+# define TLS1_CK_DHE_RSA_WITH_ARIA_128_GCM_SHA256         0x0300C052
+# define TLS1_CK_DHE_RSA_WITH_ARIA_256_GCM_SHA384         0x0300C053
+# define TLS1_CK_DH_RSA_WITH_ARIA_128_GCM_SHA256          0x0300C054
+# define TLS1_CK_DH_RSA_WITH_ARIA_256_GCM_SHA384          0x0300C055
+# define TLS1_CK_DHE_DSS_WITH_ARIA_128_GCM_SHA256         0x0300C056
+# define TLS1_CK_DHE_DSS_WITH_ARIA_256_GCM_SHA384         0x0300C057
+# define TLS1_CK_DH_DSS_WITH_ARIA_128_GCM_SHA256          0x0300C058
+# define TLS1_CK_DH_DSS_WITH_ARIA_256_GCM_SHA384          0x0300C059
+# define TLS1_CK_DH_anon_WITH_ARIA_128_GCM_SHA256         0x0300C05A
+# define TLS1_CK_DH_anon_WITH_ARIA_256_GCM_SHA384         0x0300C05B
+# define TLS1_CK_ECDHE_ECDSA_WITH_ARIA_128_GCM_SHA256     0x0300C05C
+# define TLS1_CK_ECDHE_ECDSA_WITH_ARIA_256_GCM_SHA384     0x0300C05D
+# define TLS1_CK_ECDH_ECDSA_WITH_ARIA_128_GCM_SHA256      0x0300C05E
+# define TLS1_CK_ECDH_ECDSA_WITH_ARIA_256_GCM_SHA384      0x0300C05F
+# define TLS1_CK_ECDHE_RSA_WITH_ARIA_128_GCM_SHA256       0x0300C060
+# define TLS1_CK_ECDHE_RSA_WITH_ARIA_256_GCM_SHA384       0x0300C061
+# define TLS1_CK_ECDH_RSA_WITH_ARIA_128_GCM_SHA256        0x0300C062
+# define TLS1_CK_ECDH_RSA_WITH_ARIA_256_GCM_SHA384        0x0300C063
+# define TLS1_CK_PSK_WITH_ARIA_128_GCM_SHA256             0x0300C06A
+# define TLS1_CK_PSK_WITH_ARIA_256_GCM_SHA384             0x0300C06B
+# define TLS1_CK_DHE_PSK_WITH_ARIA_128_GCM_SHA256         0x0300C06C
+# define TLS1_CK_DHE_PSK_WITH_ARIA_256_GCM_SHA384         0x0300C06D
+# define TLS1_CK_RSA_PSK_WITH_ARIA_128_GCM_SHA256         0x0300C06E
+# define TLS1_CK_RSA_PSK_WITH_ARIA_256_GCM_SHA384         0x0300C06F
+
+/* a bundle of RFC standard cipher names, generated from ssl3_ciphers[] */
+# define TLS1_RFC_RSA_WITH_AES_128_SHA                   "TLS_RSA_WITH_AES_128_CBC_SHA"
+# define TLS1_RFC_DHE_DSS_WITH_AES_128_SHA               "TLS_DHE_DSS_WITH_AES_128_CBC_SHA"
+# define TLS1_RFC_DHE_RSA_WITH_AES_128_SHA               "TLS_DHE_RSA_WITH_AES_128_CBC_SHA"
+# define TLS1_RFC_ADH_WITH_AES_128_SHA                   "TLS_DH_anon_WITH_AES_128_CBC_SHA"
+# define TLS1_RFC_RSA_WITH_AES_256_SHA                   "TLS_RSA_WITH_AES_256_CBC_SHA"
+# define TLS1_RFC_DHE_DSS_WITH_AES_256_SHA               "TLS_DHE_DSS_WITH_AES_256_CBC_SHA"
+# define TLS1_RFC_DHE_RSA_WITH_AES_256_SHA               "TLS_DHE_RSA_WITH_AES_256_CBC_SHA"
+# define TLS1_RFC_ADH_WITH_AES_256_SHA                   "TLS_DH_anon_WITH_AES_256_CBC_SHA"
+# define TLS1_RFC_RSA_WITH_NULL_SHA256                   "TLS_RSA_WITH_NULL_SHA256"
+# define TLS1_RFC_RSA_WITH_AES_128_SHA256                "TLS_RSA_WITH_AES_128_CBC_SHA256"
+# define TLS1_RFC_RSA_WITH_AES_256_SHA256                "TLS_RSA_WITH_AES_256_CBC_SHA256"
+# define TLS1_RFC_DHE_DSS_WITH_AES_128_SHA256            "TLS_DHE_DSS_WITH_AES_128_CBC_SHA256"
+# define TLS1_RFC_DHE_RSA_WITH_AES_128_SHA256            "TLS_DHE_RSA_WITH_AES_128_CBC_SHA256"
+# define TLS1_RFC_DHE_DSS_WITH_AES_256_SHA256            "TLS_DHE_DSS_WITH_AES_256_CBC_SHA256"
+# define TLS1_RFC_DHE_RSA_WITH_AES_256_SHA256            "TLS_DHE_RSA_WITH_AES_256_CBC_SHA256"
+# define TLS1_RFC_ADH_WITH_AES_128_SHA256                "TLS_DH_anon_WITH_AES_128_CBC_SHA256"
+# define TLS1_RFC_ADH_WITH_AES_256_SHA256                "TLS_DH_anon_WITH_AES_256_CBC_SHA256"
+# define TLS1_RFC_RSA_WITH_AES_128_GCM_SHA256            "TLS_RSA_WITH_AES_128_GCM_SHA256"
+# define TLS1_RFC_RSA_WITH_AES_256_GCM_SHA384            "TLS_RSA_WITH_AES_256_GCM_SHA384"
+# define TLS1_RFC_DHE_RSA_WITH_AES_128_GCM_SHA256        "TLS_DHE_RSA_WITH_AES_128_GCM_SHA256"
+# define TLS1_RFC_DHE_RSA_WITH_AES_256_GCM_SHA384        "TLS_DHE_RSA_WITH_AES_256_GCM_SHA384"
+# define TLS1_RFC_DHE_DSS_WITH_AES_128_GCM_SHA256        "TLS_DHE_DSS_WITH_AES_128_GCM_SHA256"
+# define TLS1_RFC_DHE_DSS_WITH_AES_256_GCM_SHA384        "TLS_DHE_DSS_WITH_AES_256_GCM_SHA384"
+# define TLS1_RFC_ADH_WITH_AES_128_GCM_SHA256            "TLS_DH_anon_WITH_AES_128_GCM_SHA256"
+# define TLS1_RFC_ADH_WITH_AES_256_GCM_SHA384            "TLS_DH_anon_WITH_AES_256_GCM_SHA384"
+# define TLS1_RFC_RSA_WITH_AES_128_CCM                   "TLS_RSA_WITH_AES_128_CCM"
+# define TLS1_RFC_RSA_WITH_AES_256_CCM                   "TLS_RSA_WITH_AES_256_CCM"
+# define TLS1_RFC_DHE_RSA_WITH_AES_128_CCM               "TLS_DHE_RSA_WITH_AES_128_CCM"
+# define TLS1_RFC_DHE_RSA_WITH_AES_256_CCM               "TLS_DHE_RSA_WITH_AES_256_CCM"
+# define TLS1_RFC_RSA_WITH_AES_128_CCM_8                 "TLS_RSA_WITH_AES_128_CCM_8"
+# define TLS1_RFC_RSA_WITH_AES_256_CCM_8                 "TLS_RSA_WITH_AES_256_CCM_8"
+# define TLS1_RFC_DHE_RSA_WITH_AES_128_CCM_8             "TLS_DHE_RSA_WITH_AES_128_CCM_8"
+# define TLS1_RFC_DHE_RSA_WITH_AES_256_CCM_8             "TLS_DHE_RSA_WITH_AES_256_CCM_8"
+# define TLS1_RFC_PSK_WITH_AES_128_CCM                   "TLS_PSK_WITH_AES_128_CCM"
+# define TLS1_RFC_PSK_WITH_AES_256_CCM                   "TLS_PSK_WITH_AES_256_CCM"
+# define TLS1_RFC_DHE_PSK_WITH_AES_128_CCM               "TLS_DHE_PSK_WITH_AES_128_CCM"
+# define TLS1_RFC_DHE_PSK_WITH_AES_256_CCM               "TLS_DHE_PSK_WITH_AES_256_CCM"
+# define TLS1_RFC_PSK_WITH_AES_128_CCM_8                 "TLS_PSK_WITH_AES_128_CCM_8"
+# define TLS1_RFC_PSK_WITH_AES_256_CCM_8                 "TLS_PSK_WITH_AES_256_CCM_8"
+# define TLS1_RFC_DHE_PSK_WITH_AES_128_CCM_8             "TLS_PSK_DHE_WITH_AES_128_CCM_8"
+# define TLS1_RFC_DHE_PSK_WITH_AES_256_CCM_8             "TLS_PSK_DHE_WITH_AES_256_CCM_8"
+# define TLS1_RFC_ECDHE_ECDSA_WITH_AES_128_CCM           "TLS_ECDHE_ECDSA_WITH_AES_128_CCM"
+# define TLS1_RFC_ECDHE_ECDSA_WITH_AES_256_CCM           "TLS_ECDHE_ECDSA_WITH_AES_256_CCM"
+# define TLS1_RFC_ECDHE_ECDSA_WITH_AES_128_CCM_8         "TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8"
+# define TLS1_RFC_ECDHE_ECDSA_WITH_AES_256_CCM_8         "TLS_ECDHE_ECDSA_WITH_AES_256_CCM_8"
+# define TLS1_3_RFC_AES_128_GCM_SHA256                   "TLS_AES_128_GCM_SHA256"
+# define TLS1_3_RFC_AES_256_GCM_SHA384                   "TLS_AES_256_GCM_SHA384"
+# define TLS1_3_RFC_CHACHA20_POLY1305_SHA256             "TLS_CHACHA20_POLY1305_SHA256"
+# define TLS1_3_RFC_AES_128_CCM_SHA256                   "TLS_AES_128_CCM_SHA256"
+# define TLS1_3_RFC_AES_128_CCM_8_SHA256                 "TLS_AES_128_CCM_8_SHA256"
+# define TLS1_RFC_ECDHE_ECDSA_WITH_NULL_SHA              "TLS_ECDHE_ECDSA_WITH_NULL_SHA"
+# define TLS1_RFC_ECDHE_ECDSA_WITH_DES_192_CBC3_SHA      "TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA"
+# define TLS1_RFC_ECDHE_ECDSA_WITH_AES_128_CBC_SHA       "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA"
+# define TLS1_RFC_ECDHE_ECDSA_WITH_AES_256_CBC_SHA       "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA"
+# define TLS1_RFC_ECDHE_RSA_WITH_NULL_SHA                "TLS_ECDHE_RSA_WITH_NULL_SHA"
+# define TLS1_RFC_ECDHE_RSA_WITH_DES_192_CBC3_SHA        "TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA"
+# define TLS1_RFC_ECDHE_RSA_WITH_AES_128_CBC_SHA         "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA"
+# define TLS1_RFC_ECDHE_RSA_WITH_AES_256_CBC_SHA         "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA"
+# define TLS1_RFC_ECDH_anon_WITH_NULL_SHA                "TLS_ECDH_anon_WITH_NULL_SHA"
+# define TLS1_RFC_ECDH_anon_WITH_DES_192_CBC3_SHA        "TLS_ECDH_anon_WITH_3DES_EDE_CBC_SHA"
+# define TLS1_RFC_ECDH_anon_WITH_AES_128_CBC_SHA         "TLS_ECDH_anon_WITH_AES_128_CBC_SHA"
+# define TLS1_RFC_ECDH_anon_WITH_AES_256_CBC_SHA         "TLS_ECDH_anon_WITH_AES_256_CBC_SHA"
+# define TLS1_RFC_ECDHE_ECDSA_WITH_AES_128_SHA256        "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256"
+# define TLS1_RFC_ECDHE_ECDSA_WITH_AES_256_SHA384        "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384"
+# define TLS1_RFC_ECDHE_RSA_WITH_AES_128_SHA256          "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256"
+# define TLS1_RFC_ECDHE_RSA_WITH_AES_256_SHA384          "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384"
+# define TLS1_RFC_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256    "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256"
+# define TLS1_RFC_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384    "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384"
+# define TLS1_RFC_ECDHE_RSA_WITH_AES_128_GCM_SHA256      "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256"
+# define TLS1_RFC_ECDHE_RSA_WITH_AES_256_GCM_SHA384      "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384"
+# define TLS1_RFC_PSK_WITH_NULL_SHA                      "TLS_PSK_WITH_NULL_SHA"
+# define TLS1_RFC_DHE_PSK_WITH_NULL_SHA                  "TLS_DHE_PSK_WITH_NULL_SHA"
+# define TLS1_RFC_RSA_PSK_WITH_NULL_SHA                  "TLS_RSA_PSK_WITH_NULL_SHA"
+# define TLS1_RFC_PSK_WITH_3DES_EDE_CBC_SHA              "TLS_PSK_WITH_3DES_EDE_CBC_SHA"
+# define TLS1_RFC_PSK_WITH_AES_128_CBC_SHA               "TLS_PSK_WITH_AES_128_CBC_SHA"
+# define TLS1_RFC_PSK_WITH_AES_256_CBC_SHA               "TLS_PSK_WITH_AES_256_CBC_SHA"
+# define TLS1_RFC_DHE_PSK_WITH_3DES_EDE_CBC_SHA          "TLS_DHE_PSK_WITH_3DES_EDE_CBC_SHA"
+# define TLS1_RFC_DHE_PSK_WITH_AES_128_CBC_SHA           "TLS_DHE_PSK_WITH_AES_128_CBC_SHA"
+# define TLS1_RFC_DHE_PSK_WITH_AES_256_CBC_SHA           "TLS_DHE_PSK_WITH_AES_256_CBC_SHA"
+# define TLS1_RFC_RSA_PSK_WITH_3DES_EDE_CBC_SHA          "TLS_RSA_PSK_WITH_3DES_EDE_CBC_SHA"
+# define TLS1_RFC_RSA_PSK_WITH_AES_128_CBC_SHA           "TLS_RSA_PSK_WITH_AES_128_CBC_SHA"
+# define TLS1_RFC_RSA_PSK_WITH_AES_256_CBC_SHA           "TLS_RSA_PSK_WITH_AES_256_CBC_SHA"
+# define TLS1_RFC_PSK_WITH_AES_128_GCM_SHA256            "TLS_PSK_WITH_AES_128_GCM_SHA256"
+# define TLS1_RFC_PSK_WITH_AES_256_GCM_SHA384            "TLS_PSK_WITH_AES_256_GCM_SHA384"
+# define TLS1_RFC_DHE_PSK_WITH_AES_128_GCM_SHA256        "TLS_DHE_PSK_WITH_AES_128_GCM_SHA256"
+# define TLS1_RFC_DHE_PSK_WITH_AES_256_GCM_SHA384        "TLS_DHE_PSK_WITH_AES_256_GCM_SHA384"
+# define TLS1_RFC_RSA_PSK_WITH_AES_128_GCM_SHA256        "TLS_RSA_PSK_WITH_AES_128_GCM_SHA256"
+# define TLS1_RFC_RSA_PSK_WITH_AES_256_GCM_SHA384        "TLS_RSA_PSK_WITH_AES_256_GCM_SHA384"
+# define TLS1_RFC_PSK_WITH_AES_128_CBC_SHA256            "TLS_PSK_WITH_AES_128_CBC_SHA256"
+# define TLS1_RFC_PSK_WITH_AES_256_CBC_SHA384            "TLS_PSK_WITH_AES_256_CBC_SHA384"
+# define TLS1_RFC_PSK_WITH_NULL_SHA256                   "TLS_PSK_WITH_NULL_SHA256"
+# define TLS1_RFC_PSK_WITH_NULL_SHA384                   "TLS_PSK_WITH_NULL_SHA384"
+# define TLS1_RFC_DHE_PSK_WITH_AES_128_CBC_SHA256        "TLS_DHE_PSK_WITH_AES_128_CBC_SHA256"
+# define TLS1_RFC_DHE_PSK_WITH_AES_256_CBC_SHA384        "TLS_DHE_PSK_WITH_AES_256_CBC_SHA384"
+# define TLS1_RFC_DHE_PSK_WITH_NULL_SHA256               "TLS_DHE_PSK_WITH_NULL_SHA256"
+# define TLS1_RFC_DHE_PSK_WITH_NULL_SHA384               "TLS_DHE_PSK_WITH_NULL_SHA384"
+# define TLS1_RFC_RSA_PSK_WITH_AES_128_CBC_SHA256        "TLS_RSA_PSK_WITH_AES_128_CBC_SHA256"
+# define TLS1_RFC_RSA_PSK_WITH_AES_256_CBC_SHA384        "TLS_RSA_PSK_WITH_AES_256_CBC_SHA384"
+# define TLS1_RFC_RSA_PSK_WITH_NULL_SHA256               "TLS_RSA_PSK_WITH_NULL_SHA256"
+# define TLS1_RFC_RSA_PSK_WITH_NULL_SHA384               "TLS_RSA_PSK_WITH_NULL_SHA384"
+# define TLS1_RFC_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA        "TLS_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA"
+# define TLS1_RFC_ECDHE_PSK_WITH_AES_128_CBC_SHA         "TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA"
+# define TLS1_RFC_ECDHE_PSK_WITH_AES_256_CBC_SHA         "TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA"
+# define TLS1_RFC_ECDHE_PSK_WITH_AES_128_CBC_SHA256      "TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256"
+# define TLS1_RFC_ECDHE_PSK_WITH_AES_256_CBC_SHA384      "TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384"
+# define TLS1_RFC_ECDHE_PSK_WITH_NULL_SHA                "TLS_ECDHE_PSK_WITH_NULL_SHA"
+# define TLS1_RFC_ECDHE_PSK_WITH_NULL_SHA256             "TLS_ECDHE_PSK_WITH_NULL_SHA256"
+# define TLS1_RFC_ECDHE_PSK_WITH_NULL_SHA384             "TLS_ECDHE_PSK_WITH_NULL_SHA384"
+# define TLS1_RFC_SRP_SHA_WITH_3DES_EDE_CBC_SHA          "TLS_SRP_SHA_WITH_3DES_EDE_CBC_SHA"
+# define TLS1_RFC_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA      "TLS_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA"
+# define TLS1_RFC_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA      "TLS_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA"
+# define TLS1_RFC_SRP_SHA_WITH_AES_128_CBC_SHA           "TLS_SRP_SHA_WITH_AES_128_CBC_SHA"
+# define TLS1_RFC_SRP_SHA_RSA_WITH_AES_128_CBC_SHA       "TLS_SRP_SHA_RSA_WITH_AES_128_CBC_SHA"
+# define TLS1_RFC_SRP_SHA_DSS_WITH_AES_128_CBC_SHA       "TLS_SRP_SHA_DSS_WITH_AES_128_CBC_SHA"
+# define TLS1_RFC_SRP_SHA_WITH_AES_256_CBC_SHA           "TLS_SRP_SHA_WITH_AES_256_CBC_SHA"
+# define TLS1_RFC_SRP_SHA_RSA_WITH_AES_256_CBC_SHA       "TLS_SRP_SHA_RSA_WITH_AES_256_CBC_SHA"
+# define TLS1_RFC_SRP_SHA_DSS_WITH_AES_256_CBC_SHA       "TLS_SRP_SHA_DSS_WITH_AES_256_CBC_SHA"
+# define TLS1_RFC_DHE_RSA_WITH_CHACHA20_POLY1305         "TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256"
+# define TLS1_RFC_ECDHE_RSA_WITH_CHACHA20_POLY1305       "TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256"
+# define TLS1_RFC_ECDHE_ECDSA_WITH_CHACHA20_POLY1305     "TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256"
+# define TLS1_RFC_PSK_WITH_CHACHA20_POLY1305             "TLS_PSK_WITH_CHACHA20_POLY1305_SHA256"
+# define TLS1_RFC_ECDHE_PSK_WITH_CHACHA20_POLY1305       "TLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256"
+# define TLS1_RFC_DHE_PSK_WITH_CHACHA20_POLY1305         "TLS_DHE_PSK_WITH_CHACHA20_POLY1305_SHA256"
+# define TLS1_RFC_RSA_PSK_WITH_CHACHA20_POLY1305         "TLS_RSA_PSK_WITH_CHACHA20_POLY1305_SHA256"
+# define TLS1_RFC_RSA_WITH_CAMELLIA_128_CBC_SHA256       "TLS_RSA_WITH_CAMELLIA_128_CBC_SHA256"
+# define TLS1_RFC_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256   "TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256"
+# define TLS1_RFC_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256   "TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256"
+# define TLS1_RFC_ADH_WITH_CAMELLIA_128_CBC_SHA256       "TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA256"
+# define TLS1_RFC_RSA_WITH_CAMELLIA_256_CBC_SHA256       "TLS_RSA_WITH_CAMELLIA_256_CBC_SHA256"
+# define TLS1_RFC_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256   "TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256"
+# define TLS1_RFC_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256   "TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256"
+# define TLS1_RFC_ADH_WITH_CAMELLIA_256_CBC_SHA256       "TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA256"
+# define TLS1_RFC_RSA_WITH_CAMELLIA_256_CBC_SHA          "TLS_RSA_WITH_CAMELLIA_256_CBC_SHA"
+# define TLS1_RFC_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA      "TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA"
+# define TLS1_RFC_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA      "TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA"
+# define TLS1_RFC_ADH_WITH_CAMELLIA_256_CBC_SHA          "TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA"
+# define TLS1_RFC_RSA_WITH_CAMELLIA_128_CBC_SHA          "TLS_RSA_WITH_CAMELLIA_128_CBC_SHA"
+# define TLS1_RFC_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA      "TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA"
+# define TLS1_RFC_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA      "TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA"
+# define TLS1_RFC_ADH_WITH_CAMELLIA_128_CBC_SHA          "TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA"
+# define TLS1_RFC_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256 "TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256"
+# define TLS1_RFC_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384 "TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384"
+# define TLS1_RFC_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256 "TLS_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256"
+# define TLS1_RFC_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384 "TLS_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384"
+# define TLS1_RFC_PSK_WITH_CAMELLIA_128_CBC_SHA256       "TLS_PSK_WITH_CAMELLIA_128_CBC_SHA256"
+# define TLS1_RFC_PSK_WITH_CAMELLIA_256_CBC_SHA384       "TLS_PSK_WITH_CAMELLIA_256_CBC_SHA384"
+# define TLS1_RFC_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256   "TLS_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256"
+# define TLS1_RFC_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384   "TLS_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384"
+# define TLS1_RFC_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256   "TLS_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256"
+# define TLS1_RFC_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384   "TLS_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384"
+# define TLS1_RFC_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256 "TLS_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256"
+# define TLS1_RFC_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384 "TLS_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384"
+# define TLS1_RFC_RSA_WITH_SEED_SHA                      "TLS_RSA_WITH_SEED_CBC_SHA"
+# define TLS1_RFC_DHE_DSS_WITH_SEED_SHA                  "TLS_DHE_DSS_WITH_SEED_CBC_SHA"
+# define TLS1_RFC_DHE_RSA_WITH_SEED_SHA                  "TLS_DHE_RSA_WITH_SEED_CBC_SHA"
+# define TLS1_RFC_ADH_WITH_SEED_SHA                      "TLS_DH_anon_WITH_SEED_CBC_SHA"
+# define TLS1_RFC_ECDHE_PSK_WITH_RC4_128_SHA             "TLS_ECDHE_PSK_WITH_RC4_128_SHA"
+# define TLS1_RFC_ECDH_anon_WITH_RC4_128_SHA             "TLS_ECDH_anon_WITH_RC4_128_SHA"
+# define TLS1_RFC_ECDHE_ECDSA_WITH_RC4_128_SHA           "TLS_ECDHE_ECDSA_WITH_RC4_128_SHA"
+# define TLS1_RFC_ECDHE_RSA_WITH_RC4_128_SHA             "TLS_ECDHE_RSA_WITH_RC4_128_SHA"
+# define TLS1_RFC_PSK_WITH_RC4_128_SHA                   "TLS_PSK_WITH_RC4_128_SHA"
+# define TLS1_RFC_RSA_PSK_WITH_RC4_128_SHA               "TLS_RSA_PSK_WITH_RC4_128_SHA"
+# define TLS1_RFC_DHE_PSK_WITH_RC4_128_SHA               "TLS_DHE_PSK_WITH_RC4_128_SHA"
+# define TLS1_RFC_RSA_WITH_ARIA_128_GCM_SHA256           "TLS_RSA_WITH_ARIA_128_GCM_SHA256"
+# define TLS1_RFC_RSA_WITH_ARIA_256_GCM_SHA384           "TLS_RSA_WITH_ARIA_256_GCM_SHA384"
+# define TLS1_RFC_DHE_RSA_WITH_ARIA_128_GCM_SHA256       "TLS_DHE_RSA_WITH_ARIA_128_GCM_SHA256"
+# define TLS1_RFC_DHE_RSA_WITH_ARIA_256_GCM_SHA384       "TLS_DHE_RSA_WITH_ARIA_256_GCM_SHA384"
+# define TLS1_RFC_DH_RSA_WITH_ARIA_128_GCM_SHA256        "TLS_DH_RSA_WITH_ARIA_128_GCM_SHA256"
+# define TLS1_RFC_DH_RSA_WITH_ARIA_256_GCM_SHA384        "TLS_DH_RSA_WITH_ARIA_256_GCM_SHA384"
+# define TLS1_RFC_DHE_DSS_WITH_ARIA_128_GCM_SHA256       "TLS_DHE_DSS_WITH_ARIA_128_GCM_SHA256"
+# define TLS1_RFC_DHE_DSS_WITH_ARIA_256_GCM_SHA384       "TLS_DHE_DSS_WITH_ARIA_256_GCM_SHA384"
+# define TLS1_RFC_DH_DSS_WITH_ARIA_128_GCM_SHA256        "TLS_DH_DSS_WITH_ARIA_128_GCM_SHA256"
+# define TLS1_RFC_DH_DSS_WITH_ARIA_256_GCM_SHA384        "TLS_DH_DSS_WITH_ARIA_256_GCM_SHA384"
+# define TLS1_RFC_DH_anon_WITH_ARIA_128_GCM_SHA256       "TLS_DH_anon_WITH_ARIA_128_GCM_SHA256"
+# define TLS1_RFC_DH_anon_WITH_ARIA_256_GCM_SHA384       "TLS_DH_anon_WITH_ARIA_256_GCM_SHA384"
+# define TLS1_RFC_ECDHE_ECDSA_WITH_ARIA_128_GCM_SHA256   "TLS_ECDHE_ECDSA_WITH_ARIA_128_GCM_SHA256"
+# define TLS1_RFC_ECDHE_ECDSA_WITH_ARIA_256_GCM_SHA384   "TLS_ECDHE_ECDSA_WITH_ARIA_256_GCM_SHA384"
+# define TLS1_RFC_ECDH_ECDSA_WITH_ARIA_128_GCM_SHA256    "TLS_ECDH_ECDSA_WITH_ARIA_128_GCM_SHA256"
+# define TLS1_RFC_ECDH_ECDSA_WITH_ARIA_256_GCM_SHA384    "TLS_ECDH_ECDSA_WITH_ARIA_256_GCM_SHA384"
+# define TLS1_RFC_ECDHE_RSA_WITH_ARIA_128_GCM_SHA256     "TLS_ECDHE_RSA_WITH_ARIA_128_GCM_SHA256"
+# define TLS1_RFC_ECDHE_RSA_WITH_ARIA_256_GCM_SHA384     "TLS_ECDHE_RSA_WITH_ARIA_256_GCM_SHA384"
+# define TLS1_RFC_ECDH_RSA_WITH_ARIA_128_GCM_SHA256      "TLS_ECDH_RSA_WITH_ARIA_128_GCM_SHA256"
+# define TLS1_RFC_ECDH_RSA_WITH_ARIA_256_GCM_SHA384      "TLS_ECDH_RSA_WITH_ARIA_256_GCM_SHA384"
+# define TLS1_RFC_PSK_WITH_ARIA_128_GCM_SHA256           "TLS_PSK_WITH_ARIA_128_GCM_SHA256"
+# define TLS1_RFC_PSK_WITH_ARIA_256_GCM_SHA384           "TLS_PSK_WITH_ARIA_256_GCM_SHA384"
+# define TLS1_RFC_DHE_PSK_WITH_ARIA_128_GCM_SHA256       "TLS_DHE_PSK_WITH_ARIA_128_GCM_SHA256"
+# define TLS1_RFC_DHE_PSK_WITH_ARIA_256_GCM_SHA384       "TLS_DHE_PSK_WITH_ARIA_256_GCM_SHA384"
+# define TLS1_RFC_RSA_PSK_WITH_ARIA_128_GCM_SHA256       "TLS_RSA_PSK_WITH_ARIA_128_GCM_SHA256"
+# define TLS1_RFC_RSA_PSK_WITH_ARIA_256_GCM_SHA384       "TLS_RSA_PSK_WITH_ARIA_256_GCM_SHA384"
+
+
+/*
+ * XXX Backward compatibility alert: Older versions of OpenSSL gave some DHE
+ * ciphers names with "EDH" instead of "DHE".  Going forward, we should be
+ * using DHE everywhere, though we may indefinitely maintain aliases for
+ * users or configurations that used "EDH"
+ */
+# define TLS1_TXT_DHE_DSS_WITH_RC4_128_SHA               "DHE-DSS-RC4-SHA"
+
+# define TLS1_TXT_PSK_WITH_NULL_SHA                      "PSK-NULL-SHA"
+# define TLS1_TXT_DHE_PSK_WITH_NULL_SHA                  "DHE-PSK-NULL-SHA"
+# define TLS1_TXT_RSA_PSK_WITH_NULL_SHA                  "RSA-PSK-NULL-SHA"
+
+/* AES ciphersuites from RFC3268 */
+# define TLS1_TXT_RSA_WITH_AES_128_SHA                   "AES128-SHA"
+# define TLS1_TXT_DH_DSS_WITH_AES_128_SHA                "DH-DSS-AES128-SHA"
+# define TLS1_TXT_DH_RSA_WITH_AES_128_SHA                "DH-RSA-AES128-SHA"
+# define TLS1_TXT_DHE_DSS_WITH_AES_128_SHA               "DHE-DSS-AES128-SHA"
+# define TLS1_TXT_DHE_RSA_WITH_AES_128_SHA               "DHE-RSA-AES128-SHA"
+# define TLS1_TXT_ADH_WITH_AES_128_SHA                   "ADH-AES128-SHA"
+
+# define TLS1_TXT_RSA_WITH_AES_256_SHA                   "AES256-SHA"
+# define TLS1_TXT_DH_DSS_WITH_AES_256_SHA                "DH-DSS-AES256-SHA"
+# define TLS1_TXT_DH_RSA_WITH_AES_256_SHA                "DH-RSA-AES256-SHA"
+# define TLS1_TXT_DHE_DSS_WITH_AES_256_SHA               "DHE-DSS-AES256-SHA"
+# define TLS1_TXT_DHE_RSA_WITH_AES_256_SHA               "DHE-RSA-AES256-SHA"
+# define TLS1_TXT_ADH_WITH_AES_256_SHA                   "ADH-AES256-SHA"
+
+/* ECC ciphersuites from RFC4492 */
+# define TLS1_TXT_ECDH_ECDSA_WITH_NULL_SHA               "ECDH-ECDSA-NULL-SHA"
+# define TLS1_TXT_ECDH_ECDSA_WITH_RC4_128_SHA            "ECDH-ECDSA-RC4-SHA"
+# define TLS1_TXT_ECDH_ECDSA_WITH_DES_192_CBC3_SHA       "ECDH-ECDSA-DES-CBC3-SHA"
+# define TLS1_TXT_ECDH_ECDSA_WITH_AES_128_CBC_SHA        "ECDH-ECDSA-AES128-SHA"
+# define TLS1_TXT_ECDH_ECDSA_WITH_AES_256_CBC_SHA        "ECDH-ECDSA-AES256-SHA"
+
+# define TLS1_TXT_ECDHE_ECDSA_WITH_NULL_SHA              "ECDHE-ECDSA-NULL-SHA"
+# define TLS1_TXT_ECDHE_ECDSA_WITH_RC4_128_SHA           "ECDHE-ECDSA-RC4-SHA"
+# define TLS1_TXT_ECDHE_ECDSA_WITH_DES_192_CBC3_SHA      "ECDHE-ECDSA-DES-CBC3-SHA"
+# define TLS1_TXT_ECDHE_ECDSA_WITH_AES_128_CBC_SHA       "ECDHE-ECDSA-AES128-SHA"
+# define TLS1_TXT_ECDHE_ECDSA_WITH_AES_256_CBC_SHA       "ECDHE-ECDSA-AES256-SHA"
+
+# define TLS1_TXT_ECDH_RSA_WITH_NULL_SHA                 "ECDH-RSA-NULL-SHA"
+# define TLS1_TXT_ECDH_RSA_WITH_RC4_128_SHA              "ECDH-RSA-RC4-SHA"
+# define TLS1_TXT_ECDH_RSA_WITH_DES_192_CBC3_SHA         "ECDH-RSA-DES-CBC3-SHA"
+# define TLS1_TXT_ECDH_RSA_WITH_AES_128_CBC_SHA          "ECDH-RSA-AES128-SHA"
+# define TLS1_TXT_ECDH_RSA_WITH_AES_256_CBC_SHA          "ECDH-RSA-AES256-SHA"
+
+# define TLS1_TXT_ECDHE_RSA_WITH_NULL_SHA                "ECDHE-RSA-NULL-SHA"
+# define TLS1_TXT_ECDHE_RSA_WITH_RC4_128_SHA             "ECDHE-RSA-RC4-SHA"
+# define TLS1_TXT_ECDHE_RSA_WITH_DES_192_CBC3_SHA        "ECDHE-RSA-DES-CBC3-SHA"
+# define TLS1_TXT_ECDHE_RSA_WITH_AES_128_CBC_SHA         "ECDHE-RSA-AES128-SHA"
+# define TLS1_TXT_ECDHE_RSA_WITH_AES_256_CBC_SHA         "ECDHE-RSA-AES256-SHA"
+
+# define TLS1_TXT_ECDH_anon_WITH_NULL_SHA                "AECDH-NULL-SHA"
+# define TLS1_TXT_ECDH_anon_WITH_RC4_128_SHA             "AECDH-RC4-SHA"
+# define TLS1_TXT_ECDH_anon_WITH_DES_192_CBC3_SHA        "AECDH-DES-CBC3-SHA"
+# define TLS1_TXT_ECDH_anon_WITH_AES_128_CBC_SHA         "AECDH-AES128-SHA"
+# define TLS1_TXT_ECDH_anon_WITH_AES_256_CBC_SHA         "AECDH-AES256-SHA"
+
+/* PSK ciphersuites from RFC 4279 */
+# define TLS1_TXT_PSK_WITH_RC4_128_SHA                   "PSK-RC4-SHA"
+# define TLS1_TXT_PSK_WITH_3DES_EDE_CBC_SHA              "PSK-3DES-EDE-CBC-SHA"
+# define TLS1_TXT_PSK_WITH_AES_128_CBC_SHA               "PSK-AES128-CBC-SHA"
+# define TLS1_TXT_PSK_WITH_AES_256_CBC_SHA               "PSK-AES256-CBC-SHA"
+
+# define TLS1_TXT_DHE_PSK_WITH_RC4_128_SHA               "DHE-PSK-RC4-SHA"
+# define TLS1_TXT_DHE_PSK_WITH_3DES_EDE_CBC_SHA          "DHE-PSK-3DES-EDE-CBC-SHA"
+# define TLS1_TXT_DHE_PSK_WITH_AES_128_CBC_SHA           "DHE-PSK-AES128-CBC-SHA"
+# define TLS1_TXT_DHE_PSK_WITH_AES_256_CBC_SHA           "DHE-PSK-AES256-CBC-SHA"
+# define TLS1_TXT_RSA_PSK_WITH_RC4_128_SHA               "RSA-PSK-RC4-SHA"
+# define TLS1_TXT_RSA_PSK_WITH_3DES_EDE_CBC_SHA          "RSA-PSK-3DES-EDE-CBC-SHA"
+# define TLS1_TXT_RSA_PSK_WITH_AES_128_CBC_SHA           "RSA-PSK-AES128-CBC-SHA"
+# define TLS1_TXT_RSA_PSK_WITH_AES_256_CBC_SHA           "RSA-PSK-AES256-CBC-SHA"
+
+/* PSK ciphersuites from RFC 5487 */
+# define TLS1_TXT_PSK_WITH_AES_128_GCM_SHA256            "PSK-AES128-GCM-SHA256"
+# define TLS1_TXT_PSK_WITH_AES_256_GCM_SHA384            "PSK-AES256-GCM-SHA384"
+# define TLS1_TXT_DHE_PSK_WITH_AES_128_GCM_SHA256        "DHE-PSK-AES128-GCM-SHA256"
+# define TLS1_TXT_DHE_PSK_WITH_AES_256_GCM_SHA384        "DHE-PSK-AES256-GCM-SHA384"
+# define TLS1_TXT_RSA_PSK_WITH_AES_128_GCM_SHA256        "RSA-PSK-AES128-GCM-SHA256"
+# define TLS1_TXT_RSA_PSK_WITH_AES_256_GCM_SHA384        "RSA-PSK-AES256-GCM-SHA384"
+
+# define TLS1_TXT_PSK_WITH_AES_128_CBC_SHA256            "PSK-AES128-CBC-SHA256"
+# define TLS1_TXT_PSK_WITH_AES_256_CBC_SHA384            "PSK-AES256-CBC-SHA384"
+# define TLS1_TXT_PSK_WITH_NULL_SHA256                   "PSK-NULL-SHA256"
+# define TLS1_TXT_PSK_WITH_NULL_SHA384                   "PSK-NULL-SHA384"
+
+# define TLS1_TXT_DHE_PSK_WITH_AES_128_CBC_SHA256        "DHE-PSK-AES128-CBC-SHA256"
+# define TLS1_TXT_DHE_PSK_WITH_AES_256_CBC_SHA384        "DHE-PSK-AES256-CBC-SHA384"
+# define TLS1_TXT_DHE_PSK_WITH_NULL_SHA256               "DHE-PSK-NULL-SHA256"
+# define TLS1_TXT_DHE_PSK_WITH_NULL_SHA384               "DHE-PSK-NULL-SHA384"
+
+# define TLS1_TXT_RSA_PSK_WITH_AES_128_CBC_SHA256        "RSA-PSK-AES128-CBC-SHA256"
+# define TLS1_TXT_RSA_PSK_WITH_AES_256_CBC_SHA384        "RSA-PSK-AES256-CBC-SHA384"
+# define TLS1_TXT_RSA_PSK_WITH_NULL_SHA256               "RSA-PSK-NULL-SHA256"
+# define TLS1_TXT_RSA_PSK_WITH_NULL_SHA384               "RSA-PSK-NULL-SHA384"
+
+/* SRP ciphersuite from RFC 5054 */
+# define TLS1_TXT_SRP_SHA_WITH_3DES_EDE_CBC_SHA          "SRP-3DES-EDE-CBC-SHA"
+# define TLS1_TXT_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA      "SRP-RSA-3DES-EDE-CBC-SHA"
+# define TLS1_TXT_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA      "SRP-DSS-3DES-EDE-CBC-SHA"
+# define TLS1_TXT_SRP_SHA_WITH_AES_128_CBC_SHA           "SRP-AES-128-CBC-SHA"
+# define TLS1_TXT_SRP_SHA_RSA_WITH_AES_128_CBC_SHA       "SRP-RSA-AES-128-CBC-SHA"
+# define TLS1_TXT_SRP_SHA_DSS_WITH_AES_128_CBC_SHA       "SRP-DSS-AES-128-CBC-SHA"
+# define TLS1_TXT_SRP_SHA_WITH_AES_256_CBC_SHA           "SRP-AES-256-CBC-SHA"
+# define TLS1_TXT_SRP_SHA_RSA_WITH_AES_256_CBC_SHA       "SRP-RSA-AES-256-CBC-SHA"
+# define TLS1_TXT_SRP_SHA_DSS_WITH_AES_256_CBC_SHA       "SRP-DSS-AES-256-CBC-SHA"
+
+/* Camellia ciphersuites from RFC4132 */
+# define TLS1_TXT_RSA_WITH_CAMELLIA_128_CBC_SHA          "CAMELLIA128-SHA"
+# define TLS1_TXT_DH_DSS_WITH_CAMELLIA_128_CBC_SHA       "DH-DSS-CAMELLIA128-SHA"
+# define TLS1_TXT_DH_RSA_WITH_CAMELLIA_128_CBC_SHA       "DH-RSA-CAMELLIA128-SHA"
+# define TLS1_TXT_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA      "DHE-DSS-CAMELLIA128-SHA"
+# define TLS1_TXT_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA      "DHE-RSA-CAMELLIA128-SHA"
+# define TLS1_TXT_ADH_WITH_CAMELLIA_128_CBC_SHA          "ADH-CAMELLIA128-SHA"
+
+# define TLS1_TXT_RSA_WITH_CAMELLIA_256_CBC_SHA          "CAMELLIA256-SHA"
+# define TLS1_TXT_DH_DSS_WITH_CAMELLIA_256_CBC_SHA       "DH-DSS-CAMELLIA256-SHA"
+# define TLS1_TXT_DH_RSA_WITH_CAMELLIA_256_CBC_SHA       "DH-RSA-CAMELLIA256-SHA"
+# define TLS1_TXT_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA      "DHE-DSS-CAMELLIA256-SHA"
+# define TLS1_TXT_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA      "DHE-RSA-CAMELLIA256-SHA"
+# define TLS1_TXT_ADH_WITH_CAMELLIA_256_CBC_SHA          "ADH-CAMELLIA256-SHA"
+
+/* TLS 1.2 Camellia SHA-256 ciphersuites from RFC5932 */
+# define TLS1_TXT_RSA_WITH_CAMELLIA_128_CBC_SHA256               "CAMELLIA128-SHA256"
+# define TLS1_TXT_DH_DSS_WITH_CAMELLIA_128_CBC_SHA256            "DH-DSS-CAMELLIA128-SHA256"
+# define TLS1_TXT_DH_RSA_WITH_CAMELLIA_128_CBC_SHA256            "DH-RSA-CAMELLIA128-SHA256"
+# define TLS1_TXT_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256           "DHE-DSS-CAMELLIA128-SHA256"
+# define TLS1_TXT_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256           "DHE-RSA-CAMELLIA128-SHA256"
+# define TLS1_TXT_ADH_WITH_CAMELLIA_128_CBC_SHA256               "ADH-CAMELLIA128-SHA256"
+
+# define TLS1_TXT_RSA_WITH_CAMELLIA_256_CBC_SHA256               "CAMELLIA256-SHA256"
+# define TLS1_TXT_DH_DSS_WITH_CAMELLIA_256_CBC_SHA256            "DH-DSS-CAMELLIA256-SHA256"
+# define TLS1_TXT_DH_RSA_WITH_CAMELLIA_256_CBC_SHA256            "DH-RSA-CAMELLIA256-SHA256"
+# define TLS1_TXT_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256           "DHE-DSS-CAMELLIA256-SHA256"
+# define TLS1_TXT_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256           "DHE-RSA-CAMELLIA256-SHA256"
+# define TLS1_TXT_ADH_WITH_CAMELLIA_256_CBC_SHA256               "ADH-CAMELLIA256-SHA256"
+
+# define TLS1_TXT_PSK_WITH_CAMELLIA_128_CBC_SHA256               "PSK-CAMELLIA128-SHA256"
+# define TLS1_TXT_PSK_WITH_CAMELLIA_256_CBC_SHA384               "PSK-CAMELLIA256-SHA384"
+# define TLS1_TXT_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256           "DHE-PSK-CAMELLIA128-SHA256"
+# define TLS1_TXT_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384           "DHE-PSK-CAMELLIA256-SHA384"
+# define TLS1_TXT_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256           "RSA-PSK-CAMELLIA128-SHA256"
+# define TLS1_TXT_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384           "RSA-PSK-CAMELLIA256-SHA384"
+# define TLS1_TXT_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256         "ECDHE-PSK-CAMELLIA128-SHA256"
+# define TLS1_TXT_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384         "ECDHE-PSK-CAMELLIA256-SHA384"
+
+/* SEED ciphersuites from RFC4162 */
+# define TLS1_TXT_RSA_WITH_SEED_SHA                      "SEED-SHA"
+# define TLS1_TXT_DH_DSS_WITH_SEED_SHA                   "DH-DSS-SEED-SHA"
+# define TLS1_TXT_DH_RSA_WITH_SEED_SHA                   "DH-RSA-SEED-SHA"
+# define TLS1_TXT_DHE_DSS_WITH_SEED_SHA                  "DHE-DSS-SEED-SHA"
+# define TLS1_TXT_DHE_RSA_WITH_SEED_SHA                  "DHE-RSA-SEED-SHA"
+# define TLS1_TXT_ADH_WITH_SEED_SHA                      "ADH-SEED-SHA"
+
+/* TLS v1.2 ciphersuites */
+# define TLS1_TXT_RSA_WITH_NULL_SHA256                   "NULL-SHA256"
+# define TLS1_TXT_RSA_WITH_AES_128_SHA256                "AES128-SHA256"
+# define TLS1_TXT_RSA_WITH_AES_256_SHA256                "AES256-SHA256"
+# define TLS1_TXT_DH_DSS_WITH_AES_128_SHA256             "DH-DSS-AES128-SHA256"
+# define TLS1_TXT_DH_RSA_WITH_AES_128_SHA256             "DH-RSA-AES128-SHA256"
+# define TLS1_TXT_DHE_DSS_WITH_AES_128_SHA256            "DHE-DSS-AES128-SHA256"
+# define TLS1_TXT_DHE_RSA_WITH_AES_128_SHA256            "DHE-RSA-AES128-SHA256"
+# define TLS1_TXT_DH_DSS_WITH_AES_256_SHA256             "DH-DSS-AES256-SHA256"
+# define TLS1_TXT_DH_RSA_WITH_AES_256_SHA256             "DH-RSA-AES256-SHA256"
+# define TLS1_TXT_DHE_DSS_WITH_AES_256_SHA256            "DHE-DSS-AES256-SHA256"
+# define TLS1_TXT_DHE_RSA_WITH_AES_256_SHA256            "DHE-RSA-AES256-SHA256"
+# define TLS1_TXT_ADH_WITH_AES_128_SHA256                "ADH-AES128-SHA256"
+# define TLS1_TXT_ADH_WITH_AES_256_SHA256                "ADH-AES256-SHA256"
+
+/* TLS v1.2 GCM ciphersuites from RFC5288 */
+# define TLS1_TXT_RSA_WITH_AES_128_GCM_SHA256            "AES128-GCM-SHA256"
+# define TLS1_TXT_RSA_WITH_AES_256_GCM_SHA384            "AES256-GCM-SHA384"
+# define TLS1_TXT_DHE_RSA_WITH_AES_128_GCM_SHA256        "DHE-RSA-AES128-GCM-SHA256"
+# define TLS1_TXT_DHE_RSA_WITH_AES_256_GCM_SHA384        "DHE-RSA-AES256-GCM-SHA384"
+# define TLS1_TXT_DH_RSA_WITH_AES_128_GCM_SHA256         "DH-RSA-AES128-GCM-SHA256"
+# define TLS1_TXT_DH_RSA_WITH_AES_256_GCM_SHA384         "DH-RSA-AES256-GCM-SHA384"
+# define TLS1_TXT_DHE_DSS_WITH_AES_128_GCM_SHA256        "DHE-DSS-AES128-GCM-SHA256"
+# define TLS1_TXT_DHE_DSS_WITH_AES_256_GCM_SHA384        "DHE-DSS-AES256-GCM-SHA384"
+# define TLS1_TXT_DH_DSS_WITH_AES_128_GCM_SHA256         "DH-DSS-AES128-GCM-SHA256"
+# define TLS1_TXT_DH_DSS_WITH_AES_256_GCM_SHA384         "DH-DSS-AES256-GCM-SHA384"
+# define TLS1_TXT_ADH_WITH_AES_128_GCM_SHA256            "ADH-AES128-GCM-SHA256"
+# define TLS1_TXT_ADH_WITH_AES_256_GCM_SHA384            "ADH-AES256-GCM-SHA384"
+
+/* CCM ciphersuites from RFC6655 */
+# define TLS1_TXT_RSA_WITH_AES_128_CCM                   "AES128-CCM"
+# define TLS1_TXT_RSA_WITH_AES_256_CCM                   "AES256-CCM"
+# define TLS1_TXT_DHE_RSA_WITH_AES_128_CCM               "DHE-RSA-AES128-CCM"
+# define TLS1_TXT_DHE_RSA_WITH_AES_256_CCM               "DHE-RSA-AES256-CCM"
+
+# define TLS1_TXT_RSA_WITH_AES_128_CCM_8                 "AES128-CCM8"
+# define TLS1_TXT_RSA_WITH_AES_256_CCM_8                 "AES256-CCM8"
+# define TLS1_TXT_DHE_RSA_WITH_AES_128_CCM_8             "DHE-RSA-AES128-CCM8"
+# define TLS1_TXT_DHE_RSA_WITH_AES_256_CCM_8             "DHE-RSA-AES256-CCM8"
+
+# define TLS1_TXT_PSK_WITH_AES_128_CCM                   "PSK-AES128-CCM"
+# define TLS1_TXT_PSK_WITH_AES_256_CCM                   "PSK-AES256-CCM"
+# define TLS1_TXT_DHE_PSK_WITH_AES_128_CCM               "DHE-PSK-AES128-CCM"
+# define TLS1_TXT_DHE_PSK_WITH_AES_256_CCM               "DHE-PSK-AES256-CCM"
+
+# define TLS1_TXT_PSK_WITH_AES_128_CCM_8                 "PSK-AES128-CCM8"
+# define TLS1_TXT_PSK_WITH_AES_256_CCM_8                 "PSK-AES256-CCM8"
+# define TLS1_TXT_DHE_PSK_WITH_AES_128_CCM_8             "DHE-PSK-AES128-CCM8"
+# define TLS1_TXT_DHE_PSK_WITH_AES_256_CCM_8             "DHE-PSK-AES256-CCM8"
+
+/* CCM ciphersuites from RFC7251 */
+# define TLS1_TXT_ECDHE_ECDSA_WITH_AES_128_CCM       "ECDHE-ECDSA-AES128-CCM"
+# define TLS1_TXT_ECDHE_ECDSA_WITH_AES_256_CCM       "ECDHE-ECDSA-AES256-CCM"
+# define TLS1_TXT_ECDHE_ECDSA_WITH_AES_128_CCM_8     "ECDHE-ECDSA-AES128-CCM8"
+# define TLS1_TXT_ECDHE_ECDSA_WITH_AES_256_CCM_8     "ECDHE-ECDSA-AES256-CCM8"
+
+/* ECDH HMAC based ciphersuites from RFC5289 */
+# define TLS1_TXT_ECDHE_ECDSA_WITH_AES_128_SHA256    "ECDHE-ECDSA-AES128-SHA256"
+# define TLS1_TXT_ECDHE_ECDSA_WITH_AES_256_SHA384    "ECDHE-ECDSA-AES256-SHA384"
+# define TLS1_TXT_ECDH_ECDSA_WITH_AES_128_SHA256     "ECDH-ECDSA-AES128-SHA256"
+# define TLS1_TXT_ECDH_ECDSA_WITH_AES_256_SHA384     "ECDH-ECDSA-AES256-SHA384"
+# define TLS1_TXT_ECDHE_RSA_WITH_AES_128_SHA256      "ECDHE-RSA-AES128-SHA256"
+# define TLS1_TXT_ECDHE_RSA_WITH_AES_256_SHA384      "ECDHE-RSA-AES256-SHA384"
+# define TLS1_TXT_ECDH_RSA_WITH_AES_128_SHA256       "ECDH-RSA-AES128-SHA256"
+# define TLS1_TXT_ECDH_RSA_WITH_AES_256_SHA384       "ECDH-RSA-AES256-SHA384"
+
+/* ECDH GCM based ciphersuites from RFC5289 */
+# define TLS1_TXT_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256    "ECDHE-ECDSA-AES128-GCM-SHA256"
+# define TLS1_TXT_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384    "ECDHE-ECDSA-AES256-GCM-SHA384"
+# define TLS1_TXT_ECDH_ECDSA_WITH_AES_128_GCM_SHA256     "ECDH-ECDSA-AES128-GCM-SHA256"
+# define TLS1_TXT_ECDH_ECDSA_WITH_AES_256_GCM_SHA384     "ECDH-ECDSA-AES256-GCM-SHA384"
+# define TLS1_TXT_ECDHE_RSA_WITH_AES_128_GCM_SHA256      "ECDHE-RSA-AES128-GCM-SHA256"
+# define TLS1_TXT_ECDHE_RSA_WITH_AES_256_GCM_SHA384      "ECDHE-RSA-AES256-GCM-SHA384"
+# define TLS1_TXT_ECDH_RSA_WITH_AES_128_GCM_SHA256       "ECDH-RSA-AES128-GCM-SHA256"
+# define TLS1_TXT_ECDH_RSA_WITH_AES_256_GCM_SHA384       "ECDH-RSA-AES256-GCM-SHA384"
+
+/* TLS v1.2 PSK GCM ciphersuites from RFC5487 */
+# define TLS1_TXT_PSK_WITH_AES_128_GCM_SHA256            "PSK-AES128-GCM-SHA256"
+# define TLS1_TXT_PSK_WITH_AES_256_GCM_SHA384            "PSK-AES256-GCM-SHA384"
+
+/* ECDHE PSK ciphersuites from RFC 5489 */
+# define TLS1_TXT_ECDHE_PSK_WITH_RC4_128_SHA               "ECDHE-PSK-RC4-SHA"
+# define TLS1_TXT_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA          "ECDHE-PSK-3DES-EDE-CBC-SHA"
+# define TLS1_TXT_ECDHE_PSK_WITH_AES_128_CBC_SHA           "ECDHE-PSK-AES128-CBC-SHA"
+# define TLS1_TXT_ECDHE_PSK_WITH_AES_256_CBC_SHA           "ECDHE-PSK-AES256-CBC-SHA"
+
+# define TLS1_TXT_ECDHE_PSK_WITH_AES_128_CBC_SHA256        "ECDHE-PSK-AES128-CBC-SHA256"
+# define TLS1_TXT_ECDHE_PSK_WITH_AES_256_CBC_SHA384        "ECDHE-PSK-AES256-CBC-SHA384"
+
+# define TLS1_TXT_ECDHE_PSK_WITH_NULL_SHA                  "ECDHE-PSK-NULL-SHA"
+# define TLS1_TXT_ECDHE_PSK_WITH_NULL_SHA256               "ECDHE-PSK-NULL-SHA256"
+# define TLS1_TXT_ECDHE_PSK_WITH_NULL_SHA384               "ECDHE-PSK-NULL-SHA384"
+
+/* Camellia-CBC ciphersuites from RFC6367 */
+# define TLS1_TXT_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256 "ECDHE-ECDSA-CAMELLIA128-SHA256"
+# define TLS1_TXT_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384 "ECDHE-ECDSA-CAMELLIA256-SHA384"
+# define TLS1_TXT_ECDH_ECDSA_WITH_CAMELLIA_128_CBC_SHA256  "ECDH-ECDSA-CAMELLIA128-SHA256"
+# define TLS1_TXT_ECDH_ECDSA_WITH_CAMELLIA_256_CBC_SHA384  "ECDH-ECDSA-CAMELLIA256-SHA384"
+# define TLS1_TXT_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256   "ECDHE-RSA-CAMELLIA128-SHA256"
+# define TLS1_TXT_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384   "ECDHE-RSA-CAMELLIA256-SHA384"
+# define TLS1_TXT_ECDH_RSA_WITH_CAMELLIA_128_CBC_SHA256    "ECDH-RSA-CAMELLIA128-SHA256"
+# define TLS1_TXT_ECDH_RSA_WITH_CAMELLIA_256_CBC_SHA384    "ECDH-RSA-CAMELLIA256-SHA384"
+
+/* draft-ietf-tls-chacha20-poly1305-03 */
+# define TLS1_TXT_ECDHE_RSA_WITH_CHACHA20_POLY1305         "ECDHE-RSA-CHACHA20-POLY1305"
+# define TLS1_TXT_ECDHE_ECDSA_WITH_CHACHA20_POLY1305       "ECDHE-ECDSA-CHACHA20-POLY1305"
+# define TLS1_TXT_DHE_RSA_WITH_CHACHA20_POLY1305           "DHE-RSA-CHACHA20-POLY1305"
+# define TLS1_TXT_PSK_WITH_CHACHA20_POLY1305               "PSK-CHACHA20-POLY1305"
+# define TLS1_TXT_ECDHE_PSK_WITH_CHACHA20_POLY1305         "ECDHE-PSK-CHACHA20-POLY1305"
+# define TLS1_TXT_DHE_PSK_WITH_CHACHA20_POLY1305           "DHE-PSK-CHACHA20-POLY1305"
+# define TLS1_TXT_RSA_PSK_WITH_CHACHA20_POLY1305           "RSA-PSK-CHACHA20-POLY1305"
+
+/* Aria ciphersuites from RFC6209 */
+# define TLS1_TXT_RSA_WITH_ARIA_128_GCM_SHA256             "ARIA128-GCM-SHA256"
+# define TLS1_TXT_RSA_WITH_ARIA_256_GCM_SHA384             "ARIA256-GCM-SHA384"
+# define TLS1_TXT_DHE_RSA_WITH_ARIA_128_GCM_SHA256         "DHE-RSA-ARIA128-GCM-SHA256"
+# define TLS1_TXT_DHE_RSA_WITH_ARIA_256_GCM_SHA384         "DHE-RSA-ARIA256-GCM-SHA384"
+# define TLS1_TXT_DH_RSA_WITH_ARIA_128_GCM_SHA256          "DH-RSA-ARIA128-GCM-SHA256"
+# define TLS1_TXT_DH_RSA_WITH_ARIA_256_GCM_SHA384          "DH-RSA-ARIA256-GCM-SHA384"
+# define TLS1_TXT_DHE_DSS_WITH_ARIA_128_GCM_SHA256         "DHE-DSS-ARIA128-GCM-SHA256"
+# define TLS1_TXT_DHE_DSS_WITH_ARIA_256_GCM_SHA384         "DHE-DSS-ARIA256-GCM-SHA384"
+# define TLS1_TXT_DH_DSS_WITH_ARIA_128_GCM_SHA256          "DH-DSS-ARIA128-GCM-SHA256"
+# define TLS1_TXT_DH_DSS_WITH_ARIA_256_GCM_SHA384          "DH-DSS-ARIA256-GCM-SHA384"
+# define TLS1_TXT_DH_anon_WITH_ARIA_128_GCM_SHA256         "ADH-ARIA128-GCM-SHA256"
+# define TLS1_TXT_DH_anon_WITH_ARIA_256_GCM_SHA384         "ADH-ARIA256-GCM-SHA384"
+# define TLS1_TXT_ECDHE_ECDSA_WITH_ARIA_128_GCM_SHA256     "ECDHE-ECDSA-ARIA128-GCM-SHA256"
+# define TLS1_TXT_ECDHE_ECDSA_WITH_ARIA_256_GCM_SHA384     "ECDHE-ECDSA-ARIA256-GCM-SHA384"
+# define TLS1_TXT_ECDH_ECDSA_WITH_ARIA_128_GCM_SHA256      "ECDH-ECDSA-ARIA128-GCM-SHA256"
+# define TLS1_TXT_ECDH_ECDSA_WITH_ARIA_256_GCM_SHA384      "ECDH-ECDSA-ARIA256-GCM-SHA384"
+# define TLS1_TXT_ECDHE_RSA_WITH_ARIA_128_GCM_SHA256       "ECDHE-ARIA128-GCM-SHA256"
+# define TLS1_TXT_ECDHE_RSA_WITH_ARIA_256_GCM_SHA384       "ECDHE-ARIA256-GCM-SHA384"
+# define TLS1_TXT_ECDH_RSA_WITH_ARIA_128_GCM_SHA256        "ECDH-ARIA128-GCM-SHA256"
+# define TLS1_TXT_ECDH_RSA_WITH_ARIA_256_GCM_SHA384        "ECDH-ARIA256-GCM-SHA384"
+# define TLS1_TXT_PSK_WITH_ARIA_128_GCM_SHA256             "PSK-ARIA128-GCM-SHA256"
+# define TLS1_TXT_PSK_WITH_ARIA_256_GCM_SHA384             "PSK-ARIA256-GCM-SHA384"
+# define TLS1_TXT_DHE_PSK_WITH_ARIA_128_GCM_SHA256         "DHE-PSK-ARIA128-GCM-SHA256"
+# define TLS1_TXT_DHE_PSK_WITH_ARIA_256_GCM_SHA384         "DHE-PSK-ARIA256-GCM-SHA384"
+# define TLS1_TXT_RSA_PSK_WITH_ARIA_128_GCM_SHA256         "RSA-PSK-ARIA128-GCM-SHA256"
+# define TLS1_TXT_RSA_PSK_WITH_ARIA_256_GCM_SHA384         "RSA-PSK-ARIA256-GCM-SHA384"
+
+# define TLS_CT_RSA_SIGN                 1
+# define TLS_CT_DSS_SIGN                 2
+# define TLS_CT_RSA_FIXED_DH             3
+# define TLS_CT_DSS_FIXED_DH             4
+# define TLS_CT_ECDSA_SIGN               64
+# define TLS_CT_RSA_FIXED_ECDH           65
+# define TLS_CT_ECDSA_FIXED_ECDH         66
+# define TLS_CT_GOST01_SIGN              22
+# define TLS_CT_GOST12_IANA_SIGN         67
+# define TLS_CT_GOST12_IANA_512_SIGN     68
+# define TLS_CT_GOST12_LEGACY_SIGN       238
+# define TLS_CT_GOST12_LEGACY_512_SIGN   239
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define TLS_CT_GOST12_SIGN TLS_CT_GOST12_LEGACY_SIGN
+#  define TLS_CT_GOST12_512_SIGN TLS_CT_GOST12_LEGACY_512_SIGN
+# endif
+
+/*
+ * when correcting this number, correct also SSL3_CT_NUMBER in ssl3.h (see
+ * comment there)
+ */
+# define TLS_CT_NUMBER                   12
+
+# if defined(SSL3_CT_NUMBER)
+#  if TLS_CT_NUMBER != SSL3_CT_NUMBER
+#    error "SSL/TLS CT_NUMBER values do not match"
+#  endif
+# endif
+
+# define TLS1_FINISH_MAC_LENGTH          12
+
+# define TLS_MD_MAX_CONST_SIZE                     22
+
+/* ASCII: "client finished", in hex for EBCDIC compatibility */
+# define TLS_MD_CLIENT_FINISH_CONST                "\x63\x6c\x69\x65\x6e\x74\x20\x66\x69\x6e\x69\x73\x68\x65\x64"
+# define TLS_MD_CLIENT_FINISH_CONST_SIZE           15
+/* ASCII: "server finished", in hex for EBCDIC compatibility */
+# define TLS_MD_SERVER_FINISH_CONST                "\x73\x65\x72\x76\x65\x72\x20\x66\x69\x6e\x69\x73\x68\x65\x64"
+# define TLS_MD_SERVER_FINISH_CONST_SIZE           15
+/* ASCII: "server write key", in hex for EBCDIC compatibility */
+# define TLS_MD_SERVER_WRITE_KEY_CONST             "\x73\x65\x72\x76\x65\x72\x20\x77\x72\x69\x74\x65\x20\x6b\x65\x79"
+# define TLS_MD_SERVER_WRITE_KEY_CONST_SIZE        16
+/* ASCII: "key expansion", in hex for EBCDIC compatibility */
+# define TLS_MD_KEY_EXPANSION_CONST                "\x6b\x65\x79\x20\x65\x78\x70\x61\x6e\x73\x69\x6f\x6e"
+# define TLS_MD_KEY_EXPANSION_CONST_SIZE           13
+/* ASCII: "client write key", in hex for EBCDIC compatibility */
+# define TLS_MD_CLIENT_WRITE_KEY_CONST             "\x63\x6c\x69\x65\x6e\x74\x20\x77\x72\x69\x74\x65\x20\x6b\x65\x79"
+# define TLS_MD_CLIENT_WRITE_KEY_CONST_SIZE        16
+/* ASCII: "server write key", in hex for EBCDIC compatibility */
+# define TLS_MD_SERVER_WRITE_KEY_CONST             "\x73\x65\x72\x76\x65\x72\x20\x77\x72\x69\x74\x65\x20\x6b\x65\x79"
+# define TLS_MD_SERVER_WRITE_KEY_CONST_SIZE        16
+/* ASCII: "IV block", in hex for EBCDIC compatibility */
+# define TLS_MD_IV_BLOCK_CONST                     "\x49\x56\x20\x62\x6c\x6f\x63\x6b"
+# define TLS_MD_IV_BLOCK_CONST_SIZE                8
+/* ASCII: "master secret", in hex for EBCDIC compatibility */
+# define TLS_MD_MASTER_SECRET_CONST                "\x6d\x61\x73\x74\x65\x72\x20\x73\x65\x63\x72\x65\x74"
+# define TLS_MD_MASTER_SECRET_CONST_SIZE           13
+/* ASCII: "extended master secret", in hex for EBCDIC compatibility */
+# define TLS_MD_EXTENDED_MASTER_SECRET_CONST       "\x65\x78\x74\x65\x6e\x64\x65\x64\x20\x6d\x61\x73\x74\x65\x72\x20\x73\x65\x63\x72\x65\x74"
+# define TLS_MD_EXTENDED_MASTER_SECRET_CONST_SIZE  22
+
+/* TLS Session Ticket extension struct */
+struct tls_session_ticket_ext_st {
+    unsigned short length;
+    void *data;
+};
+
+#ifdef  __cplusplus
+}
+#endif
+#endif
diff --git a/src/include/openssl/trace.h b/src/include/openssl/trace.h
new file mode 100644
index 0000000..9a5b56e
--- /dev/null
+++ b/src/include/openssl/trace.h
@@ -0,0 +1,320 @@
+/*
+ * Copyright 2019-2023 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_TRACE_H
+# define OPENSSL_TRACE_H
+# pragma once
+
+# include <stdarg.h>
+
+# include <openssl/bio.h>
+
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+/*
+ * TRACE CATEGORIES
+ */
+
+/*
+ * The trace messages of the OpenSSL libraries are organized into different
+ * categories. For every trace category, the application can register a separate
+ * tracer callback. When a callback is registered, a so called trace channel is
+ * created for this category. This channel consists essentially of an internal
+ * BIO which sends all trace output it receives to the registered application
+ * callback.
+ *
+ * The ALL category can be used as a fallback category to register a single
+ * channel which receives the output from all categories. However, if the
+ * application intends to print the trace channel name in the line prefix,
+ * it is better to register channels for all categories separately.
+ * (This is how the openssl application does it.)
+ */
+# define OSSL_TRACE_CATEGORY_ALL                 0 /* The fallback */
+# define OSSL_TRACE_CATEGORY_TRACE               1
+# define OSSL_TRACE_CATEGORY_INIT                2
+# define OSSL_TRACE_CATEGORY_TLS                 3
+# define OSSL_TRACE_CATEGORY_TLS_CIPHER          4
+# define OSSL_TRACE_CATEGORY_CONF                5
+# define OSSL_TRACE_CATEGORY_ENGINE_TABLE        6
+# define OSSL_TRACE_CATEGORY_ENGINE_REF_COUNT    7
+# define OSSL_TRACE_CATEGORY_PKCS5V2             8
+# define OSSL_TRACE_CATEGORY_PKCS12_KEYGEN       9
+# define OSSL_TRACE_CATEGORY_PKCS12_DECRYPT     10
+# define OSSL_TRACE_CATEGORY_X509V3_POLICY      11
+# define OSSL_TRACE_CATEGORY_BN_CTX             12
+# define OSSL_TRACE_CATEGORY_CMP                13
+# define OSSL_TRACE_CATEGORY_STORE              14
+# define OSSL_TRACE_CATEGORY_DECODER            15
+# define OSSL_TRACE_CATEGORY_ENCODER            16
+# define OSSL_TRACE_CATEGORY_REF_COUNT          17
+# define OSSL_TRACE_CATEGORY_HTTP               18
+/* Count of available categories. */
+# define OSSL_TRACE_CATEGORY_NUM                19
+/* KEEP THIS LIST IN SYNC with trace_categories[] in crypto/trace.c */
+
+/* Returns the trace category number for the given |name| */
+int OSSL_trace_get_category_num(const char *name);
+
+/* Returns the trace category name for the given |num| */
+const char *OSSL_trace_get_category_name(int num);
+
+/*
+ * TRACE CONSUMERS
+ */
+
+/*
+ * Enables tracing for the given |category| by providing a BIO sink
+ * as |channel|. If a null pointer is passed as |channel|, an existing
+ * trace channel is removed and tracing for the category is disabled.
+ *
+ * Returns 1 on success and 0 on failure
+ */
+int OSSL_trace_set_channel(int category, BIO* channel);
+
+/*
+ * Attach a prefix and a suffix to the given |category|, to be printed at the
+ * beginning and at the end of each trace output group, i.e. when
+ * OSSL_trace_begin() and OSSL_trace_end() are called.
+ * If a null pointer is passed as argument, the existing prefix or suffix is
+ * removed.
+ *
+ * They return 1 on success and 0 on failure
+ */
+int OSSL_trace_set_prefix(int category, const char *prefix);
+int OSSL_trace_set_suffix(int category, const char *suffix);
+
+/*
+ * OSSL_trace_cb is the type tracing callback provided by the application.
+ * It MUST return the number of bytes written, or 0 on error (in other words,
+ * it can never write zero bytes).
+ *
+ * The |buffer| will always contain text, which may consist of several lines.
+ * The |data| argument points to whatever data was provided by the application
+ * when registering the tracer function.
+ *
+ * The |category| number is given, as well as a |cmd| number, described below.
+ */
+typedef size_t (*OSSL_trace_cb)(const char *buffer, size_t count,
+                                int category, int cmd, void *data);
+/*
+ * Possible |cmd| numbers.
+ */
+# define OSSL_TRACE_CTRL_BEGIN  0
+# define OSSL_TRACE_CTRL_WRITE  1
+# define OSSL_TRACE_CTRL_END    2
+
+/*
+ * Enables tracing for the given |category| by creating an internal
+ * trace channel which sends the output to the given |callback|.
+ * If a null pointer is passed as callback, an existing trace channel
+ * is removed and tracing for the category is disabled.
+ *
+ * NOTE: OSSL_trace_set_channel() and OSSL_trace_set_callback() are mutually
+ *       exclusive.
+ *
+ * Returns 1 on success and 0 on failure
+ */
+int OSSL_trace_set_callback(int category, OSSL_trace_cb callback, void *data);
+
+/*
+ * TRACE PRODUCERS
+ */
+
+/*
+ * Returns 1 if tracing for the specified category is enabled, otherwise 0
+ */
+int OSSL_trace_enabled(int category);
+
+/*
+ * Wrap a group of tracing output calls.  OSSL_trace_begin() locks tracing and
+ * returns the trace channel associated with the given category, or NULL if no
+ * channel is associated with the category.  OSSL_trace_end() unlocks tracing.
+ *
+ * Usage:
+ *
+ *    BIO *out;
+ *    if ((out = OSSL_trace_begin(category)) != NULL) {
+ *        ...
+ *        BIO_fprintf(out, ...);
+ *        ...
+ *        OSSL_trace_end(category, out);
+ *    }
+ *
+ * See also the convenience macros OSSL_TRACE_BEGIN and OSSL_TRACE_END below.
+ */
+BIO *OSSL_trace_begin(int category);
+void OSSL_trace_end(int category, BIO *channel);
+
+/*
+ * OSSL_TRACE* Convenience Macros
+ */
+
+/*
+ * When the tracing feature is disabled, these macros are defined to
+ * produce dead code, which a good compiler should eliminate.
+ */
+
+/*
+ * OSSL_TRACE_BEGIN, OSSL_TRACE_END - Define a Trace Group
+ *
+ * These two macros can be used to create a block which is executed only
+ * if the corresponding trace category is enabled. Inside this block, a
+ * local variable named |trc_out| is defined, which points to the channel
+ * associated with the given trace category.
+ *
+ * Usage: (using 'TLS' as an example category)
+ *
+ *     OSSL_TRACE_BEGIN(TLS) {
+ *
+ *         BIO_fprintf(trc_out, ... );
+ *
+ *     } OSSL_TRACE_END(TLS);
+ *
+ *
+ * This expands to the following code
+ *
+ *     do {
+ *         BIO *trc_out = OSSL_trace_begin(OSSL_TRACE_CATEGORY_TLS);
+ *         if (trc_out != NULL) {
+ *             ...
+ *             BIO_fprintf(trc_out, ...);
+ *         }
+ *         OSSL_trace_end(OSSL_TRACE_CATEGORY_TLS, trc_out);
+ *     } while (0);
+ *
+ * The use of the inner '{...}' group and the trailing ';' is enforced
+ * by the definition of the macros in order to make the code look as much
+ * like C code as possible.
+ *
+ * Before returning from inside the trace block, it is necessary to
+ * call OSSL_TRACE_CANCEL(category).
+ */
+
+# if !defined OPENSSL_NO_TRACE && !defined FIPS_MODULE
+
+#  define OSSL_TRACE_BEGIN(category) \
+    do { \
+        BIO *trc_out = OSSL_trace_begin(OSSL_TRACE_CATEGORY_##category); \
+ \
+        if (trc_out != NULL)
+
+#  define OSSL_TRACE_END(category) \
+        OSSL_trace_end(OSSL_TRACE_CATEGORY_##category, trc_out); \
+    } while (0)
+
+#  define OSSL_TRACE_CANCEL(category) \
+        OSSL_trace_end(OSSL_TRACE_CATEGORY_##category, trc_out) \
+
+# else
+
+#  define OSSL_TRACE_BEGIN(category)           \
+    do {                                        \
+        BIO *trc_out = NULL;                    \
+        if (0)
+
+#  define OSSL_TRACE_END(category)             \
+    } while(0)
+
+#  define OSSL_TRACE_CANCEL(category)          \
+    ((void)0)
+
+# endif
+
+/*
+ * OSSL_TRACE_ENABLED() - Check whether tracing is enabled for |category|
+ *
+ * Usage:
+ *
+ *     if (OSSL_TRACE_ENABLED(TLS)) {
+ *         ...
+ *     }
+ */
+# if !defined OPENSSL_NO_TRACE && !defined FIPS_MODULE
+
+#  define OSSL_TRACE_ENABLED(category) \
+    OSSL_trace_enabled(OSSL_TRACE_CATEGORY_##category)
+
+# else
+
+#  define OSSL_TRACE_ENABLED(category) (0)
+
+# endif
+
+/*
+ * OSSL_TRACE*() - OneShot Trace Macros
+ *
+ * These macros are intended to produce a simple printf-style trace output.
+ * Unfortunately, C90 macros don't support variable arguments, so the
+ * "vararg" OSSL_TRACEV() macro has a rather weird usage pattern:
+ *
+ *    OSSL_TRACEV(category, (trc_out, "format string", ...args...));
+ *
+ * Where 'channel' is the literal symbol of this name, not a variable.
+ * For that reason, it is currently not intended to be used directly,
+ * but only as helper macro for the other oneshot trace macros
+ * OSSL_TRACE(), OSSL_TRACE1(), OSSL_TRACE2(), ...
+ *
+ * Usage:
+ *
+ *    OSSL_TRACE(INIT, "Hello world!\n");
+ *    OSSL_TRACE1(TLS, "The answer is %d\n", 42);
+ *    OSSL_TRACE2(TLS, "The ultimate question to answer %d is '%s'\n",
+ *                42, "What do you get when you multiply six by nine?");
+ */
+
+# if !defined OPENSSL_NO_TRACE && !defined FIPS_MODULE
+
+#  define OSSL_TRACEV(category, args) \
+    OSSL_TRACE_BEGIN(category) \
+        BIO_printf args; \
+    OSSL_TRACE_END(category)
+
+# else
+
+#  define OSSL_TRACEV(category, args) ((void)0)
+
+# endif
+
+# define OSSL_TRACE(category, text) \
+    OSSL_TRACEV(category, (trc_out, "%s", text))
+
+# define OSSL_TRACE1(category, format, arg1) \
+    OSSL_TRACEV(category, (trc_out, format, arg1))
+# define OSSL_TRACE2(category, format, arg1, arg2) \
+    OSSL_TRACEV(category, (trc_out, format, arg1, arg2))
+# define OSSL_TRACE3(category, format, arg1, arg2, arg3) \
+    OSSL_TRACEV(category, (trc_out, format, arg1, arg2, arg3))
+# define OSSL_TRACE4(category, format, arg1, arg2, arg3, arg4) \
+    OSSL_TRACEV(category, (trc_out, format, arg1, arg2, arg3, arg4))
+# define OSSL_TRACE5(category, format, arg1, arg2, arg3, arg4, arg5) \
+    OSSL_TRACEV(category, (trc_out, format, arg1, arg2, arg3, arg4, arg5))
+# define OSSL_TRACE6(category, format, arg1, arg2, arg3, arg4, arg5, arg6) \
+    OSSL_TRACEV(category, (trc_out, format, arg1, arg2, arg3, arg4, arg5, arg6))
+# define OSSL_TRACE7(category, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7) \
+    OSSL_TRACEV(category, (trc_out, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7))
+# define OSSL_TRACE8(category, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) \
+    OSSL_TRACEV(category, (trc_out, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8))
+# define OSSL_TRACE9(category, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) \
+    OSSL_TRACEV(category, (trc_out, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9))
+
+#define OSSL_TRACE_STRING_MAX 80
+int OSSL_trace_string(BIO *out, int text, int full,
+                      const unsigned char *data, size_t size);
+#define OSSL_TRACE_STRING(category, text, full, data, len) \
+    OSSL_TRACE_BEGIN(category) { \
+        OSSL_trace_string(trc_out, text, full, data, len);  \
+    } OSSL_TRACE_END(category)
+
+# ifdef  __cplusplus
+}
+# endif
+
+#endif
diff --git a/src/include/openssl/ts.h b/src/include/openssl/ts.h
new file mode 100644
index 0000000..b09b646
--- /dev/null
+++ b/src/include/openssl/ts.h
@@ -0,0 +1,505 @@
+/*
+ * Copyright 2006-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_TS_H
+# define OPENSSL_TS_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_TS_H
+# endif
+
+# include <openssl/opensslconf.h>
+
+# ifndef OPENSSL_NO_TS
+# include <openssl/symhacks.h>
+# include <openssl/buffer.h>
+# include <openssl/evp.h>
+# include <openssl/bio.h>
+# include <openssl/asn1.h>
+# include <openssl/safestack.h>
+# include <openssl/rsa.h>
+# include <openssl/dsa.h>
+# include <openssl/dh.h>
+# include <openssl/tserr.h>
+# include <openssl/ess.h>
+# include <openssl/x509.h>
+# include <openssl/x509v3.h>
+# ifndef OPENSSL_NO_STDIO
+#  include <stdio.h>
+# endif
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+typedef struct TS_msg_imprint_st TS_MSG_IMPRINT;
+typedef struct TS_req_st TS_REQ;
+typedef struct TS_accuracy_st TS_ACCURACY;
+typedef struct TS_tst_info_st TS_TST_INFO;
+
+/* Possible values for status. */
+# define TS_STATUS_GRANTED                       0
+# define TS_STATUS_GRANTED_WITH_MODS             1
+# define TS_STATUS_REJECTION                     2
+# define TS_STATUS_WAITING                       3
+# define TS_STATUS_REVOCATION_WARNING            4
+# define TS_STATUS_REVOCATION_NOTIFICATION       5
+
+/* Possible values for failure_info. */
+# define TS_INFO_BAD_ALG                 0
+# define TS_INFO_BAD_REQUEST             2
+# define TS_INFO_BAD_DATA_FORMAT         5
+# define TS_INFO_TIME_NOT_AVAILABLE      14
+# define TS_INFO_UNACCEPTED_POLICY       15
+# define TS_INFO_UNACCEPTED_EXTENSION    16
+# define TS_INFO_ADD_INFO_NOT_AVAILABLE  17
+# define TS_INFO_SYSTEM_FAILURE          25
+
+
+typedef struct TS_status_info_st TS_STATUS_INFO;
+
+typedef struct TS_resp_st TS_RESP;
+
+DECLARE_ASN1_ALLOC_FUNCTIONS(TS_REQ)
+DECLARE_ASN1_ENCODE_FUNCTIONS_only(TS_REQ, TS_REQ)
+DECLARE_ASN1_DUP_FUNCTION(TS_REQ)
+
+#ifndef OPENSSL_NO_STDIO
+TS_REQ *d2i_TS_REQ_fp(FILE *fp, TS_REQ **a);
+int i2d_TS_REQ_fp(FILE *fp, const TS_REQ *a);
+#endif
+TS_REQ *d2i_TS_REQ_bio(BIO *fp, TS_REQ **a);
+int i2d_TS_REQ_bio(BIO *fp, const TS_REQ *a);
+
+DECLARE_ASN1_ALLOC_FUNCTIONS(TS_MSG_IMPRINT)
+DECLARE_ASN1_ENCODE_FUNCTIONS_only(TS_MSG_IMPRINT, TS_MSG_IMPRINT)
+DECLARE_ASN1_DUP_FUNCTION(TS_MSG_IMPRINT)
+
+#ifndef OPENSSL_NO_STDIO
+TS_MSG_IMPRINT *d2i_TS_MSG_IMPRINT_fp(FILE *fp, TS_MSG_IMPRINT **a);
+int i2d_TS_MSG_IMPRINT_fp(FILE *fp, const TS_MSG_IMPRINT *a);
+#endif
+TS_MSG_IMPRINT *d2i_TS_MSG_IMPRINT_bio(BIO *bio, TS_MSG_IMPRINT **a);
+int i2d_TS_MSG_IMPRINT_bio(BIO *bio, const TS_MSG_IMPRINT *a);
+
+DECLARE_ASN1_ALLOC_FUNCTIONS(TS_RESP)
+DECLARE_ASN1_ENCODE_FUNCTIONS_only(TS_RESP, TS_RESP)
+DECLARE_ASN1_DUP_FUNCTION(TS_RESP)
+
+#ifndef OPENSSL_NO_STDIO
+TS_RESP *d2i_TS_RESP_fp(FILE *fp, TS_RESP **a);
+int i2d_TS_RESP_fp(FILE *fp, const TS_RESP *a);
+#endif
+TS_RESP *d2i_TS_RESP_bio(BIO *bio, TS_RESP **a);
+int i2d_TS_RESP_bio(BIO *bio, const TS_RESP *a);
+
+DECLARE_ASN1_ALLOC_FUNCTIONS(TS_STATUS_INFO)
+DECLARE_ASN1_ENCODE_FUNCTIONS_only(TS_STATUS_INFO, TS_STATUS_INFO)
+DECLARE_ASN1_DUP_FUNCTION(TS_STATUS_INFO)
+
+DECLARE_ASN1_ALLOC_FUNCTIONS(TS_TST_INFO)
+DECLARE_ASN1_ENCODE_FUNCTIONS_only(TS_TST_INFO, TS_TST_INFO)
+DECLARE_ASN1_DUP_FUNCTION(TS_TST_INFO)
+TS_TST_INFO *PKCS7_to_TS_TST_INFO(PKCS7 *token);
+
+#ifndef OPENSSL_NO_STDIO
+TS_TST_INFO *d2i_TS_TST_INFO_fp(FILE *fp, TS_TST_INFO **a);
+int i2d_TS_TST_INFO_fp(FILE *fp, const TS_TST_INFO *a);
+#endif
+TS_TST_INFO *d2i_TS_TST_INFO_bio(BIO *bio, TS_TST_INFO **a);
+int i2d_TS_TST_INFO_bio(BIO *bio, const TS_TST_INFO *a);
+
+DECLARE_ASN1_ALLOC_FUNCTIONS(TS_ACCURACY)
+DECLARE_ASN1_ENCODE_FUNCTIONS_only(TS_ACCURACY, TS_ACCURACY)
+DECLARE_ASN1_DUP_FUNCTION(TS_ACCURACY)
+
+int TS_REQ_set_version(TS_REQ *a, long version);
+long TS_REQ_get_version(const TS_REQ *a);
+
+int TS_STATUS_INFO_set_status(TS_STATUS_INFO *a, int i);
+const ASN1_INTEGER *TS_STATUS_INFO_get0_status(const TS_STATUS_INFO *a);
+
+const STACK_OF(ASN1_UTF8STRING) *
+TS_STATUS_INFO_get0_text(const TS_STATUS_INFO *a);
+
+const ASN1_BIT_STRING *
+TS_STATUS_INFO_get0_failure_info(const TS_STATUS_INFO *a);
+
+int TS_REQ_set_msg_imprint(TS_REQ *a, TS_MSG_IMPRINT *msg_imprint);
+TS_MSG_IMPRINT *TS_REQ_get_msg_imprint(TS_REQ *a);
+
+int TS_MSG_IMPRINT_set_algo(TS_MSG_IMPRINT *a, X509_ALGOR *alg);
+X509_ALGOR *TS_MSG_IMPRINT_get_algo(TS_MSG_IMPRINT *a);
+
+int TS_MSG_IMPRINT_set_msg(TS_MSG_IMPRINT *a, unsigned char *d, int len);
+ASN1_OCTET_STRING *TS_MSG_IMPRINT_get_msg(TS_MSG_IMPRINT *a);
+
+int TS_REQ_set_policy_id(TS_REQ *a, const ASN1_OBJECT *policy);
+ASN1_OBJECT *TS_REQ_get_policy_id(TS_REQ *a);
+
+int TS_REQ_set_nonce(TS_REQ *a, const ASN1_INTEGER *nonce);
+const ASN1_INTEGER *TS_REQ_get_nonce(const TS_REQ *a);
+
+int TS_REQ_set_cert_req(TS_REQ *a, int cert_req);
+int TS_REQ_get_cert_req(const TS_REQ *a);
+
+STACK_OF(X509_EXTENSION) *TS_REQ_get_exts(TS_REQ *a);
+void TS_REQ_ext_free(TS_REQ *a);
+int TS_REQ_get_ext_count(TS_REQ *a);
+int TS_REQ_get_ext_by_NID(TS_REQ *a, int nid, int lastpos);
+int TS_REQ_get_ext_by_OBJ(TS_REQ *a, const ASN1_OBJECT *obj, int lastpos);
+int TS_REQ_get_ext_by_critical(TS_REQ *a, int crit, int lastpos);
+X509_EXTENSION *TS_REQ_get_ext(TS_REQ *a, int loc);
+X509_EXTENSION *TS_REQ_delete_ext(TS_REQ *a, int loc);
+int TS_REQ_add_ext(TS_REQ *a, X509_EXTENSION *ex, int loc);
+void *TS_REQ_get_ext_d2i(TS_REQ *a, int nid, int *crit, int *idx);
+
+/* Function declarations for TS_REQ defined in ts/ts_req_print.c */
+
+int TS_REQ_print_bio(BIO *bio, TS_REQ *a);
+
+/* Function declarations for TS_RESP defined in ts/ts_resp_utils.c */
+
+int TS_RESP_set_status_info(TS_RESP *a, TS_STATUS_INFO *info);
+TS_STATUS_INFO *TS_RESP_get_status_info(TS_RESP *a);
+
+/* Caller loses ownership of PKCS7 and TS_TST_INFO objects. */
+void TS_RESP_set_tst_info(TS_RESP *a, PKCS7 *p7, TS_TST_INFO *tst_info);
+PKCS7 *TS_RESP_get_token(TS_RESP *a);
+TS_TST_INFO *TS_RESP_get_tst_info(TS_RESP *a);
+
+int TS_TST_INFO_set_version(TS_TST_INFO *a, long version);
+long TS_TST_INFO_get_version(const TS_TST_INFO *a);
+
+int TS_TST_INFO_set_policy_id(TS_TST_INFO *a, ASN1_OBJECT *policy_id);
+ASN1_OBJECT *TS_TST_INFO_get_policy_id(TS_TST_INFO *a);
+
+int TS_TST_INFO_set_msg_imprint(TS_TST_INFO *a, TS_MSG_IMPRINT *msg_imprint);
+TS_MSG_IMPRINT *TS_TST_INFO_get_msg_imprint(TS_TST_INFO *a);
+
+int TS_TST_INFO_set_serial(TS_TST_INFO *a, const ASN1_INTEGER *serial);
+const ASN1_INTEGER *TS_TST_INFO_get_serial(const TS_TST_INFO *a);
+
+int TS_TST_INFO_set_time(TS_TST_INFO *a, const ASN1_GENERALIZEDTIME *gtime);
+const ASN1_GENERALIZEDTIME *TS_TST_INFO_get_time(const TS_TST_INFO *a);
+
+int TS_TST_INFO_set_accuracy(TS_TST_INFO *a, TS_ACCURACY *accuracy);
+TS_ACCURACY *TS_TST_INFO_get_accuracy(TS_TST_INFO *a);
+
+int TS_ACCURACY_set_seconds(TS_ACCURACY *a, const ASN1_INTEGER *seconds);
+const ASN1_INTEGER *TS_ACCURACY_get_seconds(const TS_ACCURACY *a);
+
+int TS_ACCURACY_set_millis(TS_ACCURACY *a, const ASN1_INTEGER *millis);
+const ASN1_INTEGER *TS_ACCURACY_get_millis(const TS_ACCURACY *a);
+
+int TS_ACCURACY_set_micros(TS_ACCURACY *a, const ASN1_INTEGER *micros);
+const ASN1_INTEGER *TS_ACCURACY_get_micros(const TS_ACCURACY *a);
+
+int TS_TST_INFO_set_ordering(TS_TST_INFO *a, int ordering);
+int TS_TST_INFO_get_ordering(const TS_TST_INFO *a);
+
+int TS_TST_INFO_set_nonce(TS_TST_INFO *a, const ASN1_INTEGER *nonce);
+const ASN1_INTEGER *TS_TST_INFO_get_nonce(const TS_TST_INFO *a);
+
+int TS_TST_INFO_set_tsa(TS_TST_INFO *a, GENERAL_NAME *tsa);
+GENERAL_NAME *TS_TST_INFO_get_tsa(TS_TST_INFO *a);
+
+STACK_OF(X509_EXTENSION) *TS_TST_INFO_get_exts(TS_TST_INFO *a);
+void TS_TST_INFO_ext_free(TS_TST_INFO *a);
+int TS_TST_INFO_get_ext_count(TS_TST_INFO *a);
+int TS_TST_INFO_get_ext_by_NID(TS_TST_INFO *a, int nid, int lastpos);
+int TS_TST_INFO_get_ext_by_OBJ(TS_TST_INFO *a, const ASN1_OBJECT *obj,
+                               int lastpos);
+int TS_TST_INFO_get_ext_by_critical(TS_TST_INFO *a, int crit, int lastpos);
+X509_EXTENSION *TS_TST_INFO_get_ext(TS_TST_INFO *a, int loc);
+X509_EXTENSION *TS_TST_INFO_delete_ext(TS_TST_INFO *a, int loc);
+int TS_TST_INFO_add_ext(TS_TST_INFO *a, X509_EXTENSION *ex, int loc);
+void *TS_TST_INFO_get_ext_d2i(TS_TST_INFO *a, int nid, int *crit, int *idx);
+
+/*
+ * Declarations related to response generation, defined in ts/ts_resp_sign.c.
+ */
+
+/* Optional flags for response generation. */
+
+/* Don't include the TSA name in response. */
+# define TS_TSA_NAME             0x01
+
+/* Set ordering to true in response. */
+# define TS_ORDERING             0x02
+
+/*
+ * Include the signer certificate and the other specified certificates in
+ * the ESS signing certificate attribute beside the PKCS7 signed data.
+ * Only the signer certificates is included by default.
+ */
+# define TS_ESS_CERT_ID_CHAIN    0x04
+
+/* Forward declaration. */
+struct TS_resp_ctx;
+
+/* This must return a unique number less than 160 bits long. */
+typedef ASN1_INTEGER *(*TS_serial_cb) (struct TS_resp_ctx *, void *);
+
+/*
+ * This must return the seconds and microseconds since Jan 1, 1970 in the sec
+ * and usec variables allocated by the caller. Return non-zero for success
+ * and zero for failure.
+ */
+typedef int (*TS_time_cb) (struct TS_resp_ctx *, void *, long *sec,
+                           long *usec);
+
+/*
+ * This must process the given extension. It can modify the TS_TST_INFO
+ * object of the context. Return values: !0 (processed), 0 (error, it must
+ * set the status info/failure info of the response).
+ */
+typedef int (*TS_extension_cb) (struct TS_resp_ctx *, X509_EXTENSION *,
+                                void *);
+
+typedef struct TS_resp_ctx TS_RESP_CTX;
+
+/* Creates a response context that can be used for generating responses. */
+TS_RESP_CTX *TS_RESP_CTX_new(void);
+TS_RESP_CTX *TS_RESP_CTX_new_ex(OSSL_LIB_CTX *libctx, const char *propq);
+void TS_RESP_CTX_free(TS_RESP_CTX *ctx);
+
+/* This parameter must be set. */
+int TS_RESP_CTX_set_signer_cert(TS_RESP_CTX *ctx, X509 *signer);
+
+/* This parameter must be set. */
+int TS_RESP_CTX_set_signer_key(TS_RESP_CTX *ctx, EVP_PKEY *key);
+
+int TS_RESP_CTX_set_signer_digest(TS_RESP_CTX *ctx,
+                                  const EVP_MD *signer_digest);
+int TS_RESP_CTX_set_ess_cert_id_digest(TS_RESP_CTX *ctx, const EVP_MD *md);
+
+/* This parameter must be set. */
+int TS_RESP_CTX_set_def_policy(TS_RESP_CTX *ctx, const ASN1_OBJECT *def_policy);
+
+/* No additional certs are included in the response by default. */
+int TS_RESP_CTX_set_certs(TS_RESP_CTX *ctx, STACK_OF(X509) *certs);
+
+/*
+ * Adds a new acceptable policy, only the default policy is accepted by
+ * default.
+ */
+int TS_RESP_CTX_add_policy(TS_RESP_CTX *ctx, const ASN1_OBJECT *policy);
+
+/*
+ * Adds a new acceptable message digest. Note that no message digests are
+ * accepted by default. The md argument is shared with the caller.
+ */
+int TS_RESP_CTX_add_md(TS_RESP_CTX *ctx, const EVP_MD *md);
+
+/* Accuracy is not included by default. */
+int TS_RESP_CTX_set_accuracy(TS_RESP_CTX *ctx,
+                             int secs, int millis, int micros);
+
+/*
+ * Clock precision digits, i.e. the number of decimal digits: '0' means sec,
+ * '3' msec, '6' usec, and so on. Default is 0.
+ */
+int TS_RESP_CTX_set_clock_precision_digits(TS_RESP_CTX *ctx,
+                                           unsigned clock_precision_digits);
+/* At most we accept usec precision. */
+# define TS_MAX_CLOCK_PRECISION_DIGITS   6
+
+/* Maximum status message length */
+# define TS_MAX_STATUS_LENGTH   (1024 * 1024)
+
+/* No flags are set by default. */
+void TS_RESP_CTX_add_flags(TS_RESP_CTX *ctx, int flags);
+
+/* Default callback always returns a constant. */
+void TS_RESP_CTX_set_serial_cb(TS_RESP_CTX *ctx, TS_serial_cb cb, void *data);
+
+/* Default callback uses the gettimeofday() and gmtime() system calls. */
+void TS_RESP_CTX_set_time_cb(TS_RESP_CTX *ctx, TS_time_cb cb, void *data);
+
+/*
+ * Default callback rejects all extensions. The extension callback is called
+ * when the TS_TST_INFO object is already set up and not signed yet.
+ */
+/* FIXME: extension handling is not tested yet. */
+void TS_RESP_CTX_set_extension_cb(TS_RESP_CTX *ctx,
+                                  TS_extension_cb cb, void *data);
+
+/* The following methods can be used in the callbacks. */
+int TS_RESP_CTX_set_status_info(TS_RESP_CTX *ctx,
+                                int status, const char *text);
+
+/* Sets the status info only if it is still TS_STATUS_GRANTED. */
+int TS_RESP_CTX_set_status_info_cond(TS_RESP_CTX *ctx,
+                                     int status, const char *text);
+
+int TS_RESP_CTX_add_failure_info(TS_RESP_CTX *ctx, int failure);
+
+/* The get methods below can be used in the extension callback. */
+TS_REQ *TS_RESP_CTX_get_request(TS_RESP_CTX *ctx);
+
+TS_TST_INFO *TS_RESP_CTX_get_tst_info(TS_RESP_CTX *ctx);
+
+/*
+ * Creates the signed TS_TST_INFO and puts it in TS_RESP.
+ * In case of errors it sets the status info properly.
+ * Returns NULL only in case of memory allocation/fatal error.
+ */
+TS_RESP *TS_RESP_create_response(TS_RESP_CTX *ctx, BIO *req_bio);
+
+/*
+ * Declarations related to response verification,
+ * they are defined in ts/ts_resp_verify.c.
+ */
+
+int TS_RESP_verify_signature(PKCS7 *token, STACK_OF(X509) *certs,
+                             X509_STORE *store, X509 **signer_out);
+
+/* Context structure for the generic verify method. */
+
+/* Verify the signer's certificate and the signature of the response. */
+# define TS_VFY_SIGNATURE        (1u << 0)
+/* Verify the version number of the response. */
+# define TS_VFY_VERSION          (1u << 1)
+/* Verify if the policy supplied by the user matches the policy of the TSA. */
+# define TS_VFY_POLICY           (1u << 2)
+/*
+ * Verify the message imprint provided by the user. This flag should not be
+ * specified with TS_VFY_DATA.
+ */
+# define TS_VFY_IMPRINT          (1u << 3)
+/*
+ * Verify the message imprint computed by the verify method from the user
+ * provided data and the MD algorithm of the response. This flag should not
+ * be specified with TS_VFY_IMPRINT.
+ */
+# define TS_VFY_DATA             (1u << 4)
+/* Verify the nonce value. */
+# define TS_VFY_NONCE            (1u << 5)
+/* Verify if the TSA name field matches the signer certificate. */
+# define TS_VFY_SIGNER           (1u << 6)
+/* Verify if the TSA name field equals to the user provided name. */
+# define TS_VFY_TSA_NAME         (1u << 7)
+
+/* You can use the following convenience constants. */
+# define TS_VFY_ALL_IMPRINT      (TS_VFY_SIGNATURE       \
+                                 | TS_VFY_VERSION       \
+                                 | TS_VFY_POLICY        \
+                                 | TS_VFY_IMPRINT       \
+                                 | TS_VFY_NONCE         \
+                                 | TS_VFY_SIGNER        \
+                                 | TS_VFY_TSA_NAME)
+# define TS_VFY_ALL_DATA         (TS_VFY_SIGNATURE       \
+                                 | TS_VFY_VERSION       \
+                                 | TS_VFY_POLICY        \
+                                 | TS_VFY_DATA          \
+                                 | TS_VFY_NONCE         \
+                                 | TS_VFY_SIGNER        \
+                                 | TS_VFY_TSA_NAME)
+
+typedef struct TS_verify_ctx TS_VERIFY_CTX;
+
+int TS_RESP_verify_response(TS_VERIFY_CTX *ctx, TS_RESP *response);
+int TS_RESP_verify_token(TS_VERIFY_CTX *ctx, PKCS7 *token);
+
+/*
+ * Declarations related to response verification context,
+ */
+TS_VERIFY_CTX *TS_VERIFY_CTX_new(void);
+void TS_VERIFY_CTX_init(TS_VERIFY_CTX *ctx);
+void TS_VERIFY_CTX_free(TS_VERIFY_CTX *ctx);
+void TS_VERIFY_CTX_cleanup(TS_VERIFY_CTX *ctx);
+int TS_VERIFY_CTX_set_flags(TS_VERIFY_CTX *ctx, int f);
+int TS_VERIFY_CTX_add_flags(TS_VERIFY_CTX *ctx, int f);
+BIO *TS_VERIFY_CTX_set_data(TS_VERIFY_CTX *ctx, BIO *b);
+unsigned char *TS_VERIFY_CTX_set_imprint(TS_VERIFY_CTX *ctx,
+                                         unsigned char *hexstr, long len);
+X509_STORE *TS_VERIFY_CTX_set_store(TS_VERIFY_CTX *ctx, X509_STORE *s);
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define TS_VERIFY_CTS_set_certs(ctx, cert) TS_VERIFY_CTX_set_certs(ctx,cert)
+# endif
+STACK_OF(X509) *TS_VERIFY_CTX_set_certs(TS_VERIFY_CTX *ctx, STACK_OF(X509) *certs);
+
+/*-
+ * If ctx is NULL, it allocates and returns a new object, otherwise
+ * it returns ctx. It initialises all the members as follows:
+ * flags = TS_VFY_ALL_IMPRINT & ~(TS_VFY_TSA_NAME | TS_VFY_SIGNATURE)
+ * certs = NULL
+ * store = NULL
+ * policy = policy from the request or NULL if absent (in this case
+ *      TS_VFY_POLICY is cleared from flags as well)
+ * md_alg = MD algorithm from request
+ * imprint, imprint_len = imprint from request
+ * data = NULL
+ * nonce, nonce_len = nonce from the request or NULL if absent (in this case
+ *      TS_VFY_NONCE is cleared from flags as well)
+ * tsa_name = NULL
+ * Important: after calling this method TS_VFY_SIGNATURE should be added!
+ */
+TS_VERIFY_CTX *TS_REQ_to_TS_VERIFY_CTX(TS_REQ *req, TS_VERIFY_CTX *ctx);
+
+/* Function declarations for TS_RESP defined in ts/ts_resp_print.c */
+
+int TS_RESP_print_bio(BIO *bio, TS_RESP *a);
+int TS_STATUS_INFO_print_bio(BIO *bio, TS_STATUS_INFO *a);
+int TS_TST_INFO_print_bio(BIO *bio, TS_TST_INFO *a);
+
+/* Common utility functions defined in ts/ts_lib.c */
+
+int TS_ASN1_INTEGER_print_bio(BIO *bio, const ASN1_INTEGER *num);
+int TS_OBJ_print_bio(BIO *bio, const ASN1_OBJECT *obj);
+int TS_ext_print_bio(BIO *bio, const STACK_OF(X509_EXTENSION) *extensions);
+int TS_X509_ALGOR_print_bio(BIO *bio, const X509_ALGOR *alg);
+int TS_MSG_IMPRINT_print_bio(BIO *bio, TS_MSG_IMPRINT *msg);
+
+/*
+ * Function declarations for handling configuration options, defined in
+ * ts/ts_conf.c
+ */
+
+X509 *TS_CONF_load_cert(const char *file);
+STACK_OF(X509) *TS_CONF_load_certs(const char *file);
+EVP_PKEY *TS_CONF_load_key(const char *file, const char *pass);
+const char *TS_CONF_get_tsa_section(CONF *conf, const char *section);
+int TS_CONF_set_serial(CONF *conf, const char *section, TS_serial_cb cb,
+                       TS_RESP_CTX *ctx);
+#ifndef OPENSSL_NO_ENGINE
+int TS_CONF_set_crypto_device(CONF *conf, const char *section,
+                              const char *device);
+int TS_CONF_set_default_engine(const char *name);
+#endif
+int TS_CONF_set_signer_cert(CONF *conf, const char *section,
+                            const char *cert, TS_RESP_CTX *ctx);
+int TS_CONF_set_certs(CONF *conf, const char *section, const char *certs,
+                      TS_RESP_CTX *ctx);
+int TS_CONF_set_signer_key(CONF *conf, const char *section,
+                           const char *key, const char *pass,
+                           TS_RESP_CTX *ctx);
+int TS_CONF_set_signer_digest(CONF *conf, const char *section,
+                               const char *md, TS_RESP_CTX *ctx);
+int TS_CONF_set_def_policy(CONF *conf, const char *section,
+                           const char *policy, TS_RESP_CTX *ctx);
+int TS_CONF_set_policies(CONF *conf, const char *section, TS_RESP_CTX *ctx);
+int TS_CONF_set_digests(CONF *conf, const char *section, TS_RESP_CTX *ctx);
+int TS_CONF_set_accuracy(CONF *conf, const char *section, TS_RESP_CTX *ctx);
+int TS_CONF_set_clock_precision_digits(const CONF *conf, const char *section,
+                                       TS_RESP_CTX *ctx);
+int TS_CONF_set_ordering(CONF *conf, const char *section, TS_RESP_CTX *ctx);
+int TS_CONF_set_tsa_name(CONF *conf, const char *section, TS_RESP_CTX *ctx);
+int TS_CONF_set_ess_cert_id_chain(CONF *conf, const char *section,
+                                  TS_RESP_CTX *ctx);
+int TS_CONF_set_ess_cert_id_digest(CONF *conf, const char *section,
+                                      TS_RESP_CTX *ctx);
+
+#  ifdef  __cplusplus
+}
+#  endif
+# endif
+#endif
diff --git a/src/include/openssl/tserr.h b/src/include/openssl/tserr.h
new file mode 100644
index 0000000..e1b943e
--- /dev/null
+++ b/src/include/openssl/tserr.h
@@ -0,0 +1,67 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_TSERR_H
+# define OPENSSL_TSERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+# ifndef OPENSSL_NO_TS
+
+
+/*
+ * TS reason codes.
+ */
+#  define TS_R_BAD_PKCS7_TYPE                              132
+#  define TS_R_BAD_TYPE                                    133
+#  define TS_R_CANNOT_LOAD_CERT                            137
+#  define TS_R_CANNOT_LOAD_KEY                             138
+#  define TS_R_CERTIFICATE_VERIFY_ERROR                    100
+#  define TS_R_COULD_NOT_SET_ENGINE                        127
+#  define TS_R_COULD_NOT_SET_TIME                          115
+#  define TS_R_DETACHED_CONTENT                            134
+#  define TS_R_ESS_ADD_SIGNING_CERT_ERROR                  116
+#  define TS_R_ESS_ADD_SIGNING_CERT_V2_ERROR               139
+#  define TS_R_ESS_SIGNING_CERTIFICATE_ERROR               101
+#  define TS_R_INVALID_NULL_POINTER                        102
+#  define TS_R_INVALID_SIGNER_CERTIFICATE_PURPOSE          117
+#  define TS_R_MESSAGE_IMPRINT_MISMATCH                    103
+#  define TS_R_NONCE_MISMATCH                              104
+#  define TS_R_NONCE_NOT_RETURNED                          105
+#  define TS_R_NO_CONTENT                                  106
+#  define TS_R_NO_TIME_STAMP_TOKEN                         107
+#  define TS_R_PKCS7_ADD_SIGNATURE_ERROR                   118
+#  define TS_R_PKCS7_ADD_SIGNED_ATTR_ERROR                 119
+#  define TS_R_PKCS7_TO_TS_TST_INFO_FAILED                 129
+#  define TS_R_POLICY_MISMATCH                             108
+#  define TS_R_PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE      120
+#  define TS_R_RESPONSE_SETUP_ERROR                        121
+#  define TS_R_SIGNATURE_FAILURE                           109
+#  define TS_R_THERE_MUST_BE_ONE_SIGNER                    110
+#  define TS_R_TIME_SYSCALL_ERROR                          122
+#  define TS_R_TOKEN_NOT_PRESENT                           130
+#  define TS_R_TOKEN_PRESENT                               131
+#  define TS_R_TSA_NAME_MISMATCH                           111
+#  define TS_R_TSA_UNTRUSTED                               112
+#  define TS_R_TST_INFO_SETUP_ERROR                        123
+#  define TS_R_TS_DATASIGN                                 124
+#  define TS_R_UNACCEPTABLE_POLICY                         125
+#  define TS_R_UNSUPPORTED_MD_ALGORITHM                    126
+#  define TS_R_UNSUPPORTED_VERSION                         113
+#  define TS_R_VAR_BAD_VALUE                               135
+#  define TS_R_VAR_LOOKUP_FAILURE                          136
+#  define TS_R_WRONG_CONTENT_TYPE                          114
+
+# endif
+#endif
diff --git a/src/include/openssl/txt_db.h b/src/include/openssl/txt_db.h
new file mode 100644
index 0000000..af169a3
--- /dev/null
+++ b/src/include/openssl/txt_db.h
@@ -0,0 +1,63 @@
+/*
+ * Copyright 1995-2017 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_TXT_DB_H
+# define OPENSSL_TXT_DB_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_TXT_DB_H
+# endif
+
+# include <openssl/opensslconf.h>
+# include <openssl/bio.h>
+# include <openssl/safestack.h>
+# include <openssl/lhash.h>
+
+# define DB_ERROR_OK                     0
+# define DB_ERROR_MALLOC                 1
+# define DB_ERROR_INDEX_CLASH            2
+# define DB_ERROR_INDEX_OUT_OF_RANGE     3
+# define DB_ERROR_NO_INDEX               4
+# define DB_ERROR_INSERT_INDEX_CLASH     5
+# define DB_ERROR_WRONG_NUM_FIELDS       6
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+typedef OPENSSL_STRING *OPENSSL_PSTRING;
+DEFINE_SPECIAL_STACK_OF(OPENSSL_PSTRING, OPENSSL_STRING)
+
+typedef struct txt_db_st {
+    int num_fields;
+    STACK_OF(OPENSSL_PSTRING) *data;
+    LHASH_OF(OPENSSL_STRING) **index;
+    int (**qual) (OPENSSL_STRING *);
+    long error;
+    long arg1;
+    long arg2;
+    OPENSSL_STRING *arg_row;
+} TXT_DB;
+
+TXT_DB *TXT_DB_read(BIO *in, int num);
+long TXT_DB_write(BIO *out, TXT_DB *db);
+int TXT_DB_create_index(TXT_DB *db, int field, int (*qual) (OPENSSL_STRING *),
+                        OPENSSL_LH_HASHFUNC hash, OPENSSL_LH_COMPFUNC cmp);
+void TXT_DB_free(TXT_DB *db);
+OPENSSL_STRING *TXT_DB_get_by_index(TXT_DB *db, int idx,
+                                    OPENSSL_STRING *value);
+int TXT_DB_insert(TXT_DB *db, OPENSSL_STRING *value);
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/include/openssl/types.h b/src/include/openssl/types.h
new file mode 100644
index 0000000..c280286
--- /dev/null
+++ b/src/include/openssl/types.h
@@ -0,0 +1,239 @@
+/*
+ * Copyright 2001-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+/*
+ * Unfortunate workaround to avoid symbol conflict with wincrypt.h
+ * See https://github.com/openssl/openssl/issues/9981
+ */
+#ifdef _WIN32
+# define WINCRYPT_USE_SYMBOL_PREFIX
+# undef X509_NAME
+# undef X509_EXTENSIONS
+# undef PKCS7_SIGNER_INFO
+# undef OCSP_REQUEST
+# undef OCSP_RESPONSE
+#endif
+
+#ifndef OPENSSL_TYPES_H
+# define OPENSSL_TYPES_H
+
+# include <limits.h>
+
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+# include <openssl/e_os2.h>
+# include <openssl/safestack.h>
+# include <openssl/macros.h>
+
+typedef struct ossl_provider_st OSSL_PROVIDER; /* Provider Object */
+
+# ifdef NO_ASN1_TYPEDEFS
+#  define ASN1_INTEGER            ASN1_STRING
+#  define ASN1_ENUMERATED         ASN1_STRING
+#  define ASN1_BIT_STRING         ASN1_STRING
+#  define ASN1_OCTET_STRING       ASN1_STRING
+#  define ASN1_PRINTABLESTRING    ASN1_STRING
+#  define ASN1_T61STRING          ASN1_STRING
+#  define ASN1_IA5STRING          ASN1_STRING
+#  define ASN1_UTCTIME            ASN1_STRING
+#  define ASN1_GENERALIZEDTIME    ASN1_STRING
+#  define ASN1_TIME               ASN1_STRING
+#  define ASN1_GENERALSTRING      ASN1_STRING
+#  define ASN1_UNIVERSALSTRING    ASN1_STRING
+#  define ASN1_BMPSTRING          ASN1_STRING
+#  define ASN1_VISIBLESTRING      ASN1_STRING
+#  define ASN1_UTF8STRING         ASN1_STRING
+#  define ASN1_BOOLEAN            int
+#  define ASN1_NULL               int
+# else
+typedef struct asn1_string_st ASN1_INTEGER;
+typedef struct asn1_string_st ASN1_ENUMERATED;
+typedef struct asn1_string_st ASN1_BIT_STRING;
+typedef struct asn1_string_st ASN1_OCTET_STRING;
+typedef struct asn1_string_st ASN1_PRINTABLESTRING;
+typedef struct asn1_string_st ASN1_T61STRING;
+typedef struct asn1_string_st ASN1_IA5STRING;
+typedef struct asn1_string_st ASN1_GENERALSTRING;
+typedef struct asn1_string_st ASN1_UNIVERSALSTRING;
+typedef struct asn1_string_st ASN1_BMPSTRING;
+typedef struct asn1_string_st ASN1_UTCTIME;
+typedef struct asn1_string_st ASN1_TIME;
+typedef struct asn1_string_st ASN1_GENERALIZEDTIME;
+typedef struct asn1_string_st ASN1_VISIBLESTRING;
+typedef struct asn1_string_st ASN1_UTF8STRING;
+typedef struct asn1_string_st ASN1_STRING;
+typedef int ASN1_BOOLEAN;
+typedef int ASN1_NULL;
+# endif
+
+typedef struct asn1_type_st ASN1_TYPE;
+typedef struct asn1_object_st ASN1_OBJECT;
+typedef struct asn1_string_table_st ASN1_STRING_TABLE;
+
+typedef struct ASN1_ITEM_st ASN1_ITEM;
+typedef struct asn1_pctx_st ASN1_PCTX;
+typedef struct asn1_sctx_st ASN1_SCTX;
+
+# ifdef BIGNUM
+#  undef BIGNUM
+# endif
+
+typedef struct bio_st BIO;
+typedef struct bignum_st BIGNUM;
+typedef struct bignum_ctx BN_CTX;
+typedef struct bn_blinding_st BN_BLINDING;
+typedef struct bn_mont_ctx_st BN_MONT_CTX;
+typedef struct bn_recp_ctx_st BN_RECP_CTX;
+typedef struct bn_gencb_st BN_GENCB;
+
+typedef struct buf_mem_st BUF_MEM;
+
+STACK_OF(BIGNUM);
+STACK_OF(BIGNUM_const);
+
+typedef struct err_state_st ERR_STATE;
+
+typedef struct evp_cipher_st EVP_CIPHER;
+typedef struct evp_cipher_ctx_st EVP_CIPHER_CTX;
+typedef struct evp_md_st EVP_MD;
+typedef struct evp_md_ctx_st EVP_MD_CTX;
+typedef struct evp_mac_st EVP_MAC;
+typedef struct evp_mac_ctx_st EVP_MAC_CTX;
+typedef struct evp_pkey_st EVP_PKEY;
+
+typedef struct evp_pkey_asn1_method_st EVP_PKEY_ASN1_METHOD;
+
+typedef struct evp_pkey_method_st EVP_PKEY_METHOD;
+typedef struct evp_pkey_ctx_st EVP_PKEY_CTX;
+
+typedef struct evp_keymgmt_st EVP_KEYMGMT;
+
+typedef struct evp_kdf_st EVP_KDF;
+typedef struct evp_kdf_ctx_st EVP_KDF_CTX;
+
+typedef struct evp_rand_st EVP_RAND;
+typedef struct evp_rand_ctx_st EVP_RAND_CTX;
+
+typedef struct evp_keyexch_st EVP_KEYEXCH;
+
+typedef struct evp_signature_st EVP_SIGNATURE;
+
+typedef struct evp_asym_cipher_st EVP_ASYM_CIPHER;
+
+typedef struct evp_kem_st EVP_KEM;
+
+typedef struct evp_Encode_Ctx_st EVP_ENCODE_CTX;
+
+typedef struct hmac_ctx_st HMAC_CTX;
+
+typedef struct dh_st DH;
+typedef struct dh_method DH_METHOD;
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+typedef struct dsa_st DSA;
+typedef struct dsa_method DSA_METHOD;
+# endif
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+typedef struct rsa_st RSA;
+typedef struct rsa_meth_st RSA_METHOD;
+# endif
+typedef struct rsa_pss_params_st RSA_PSS_PARAMS;
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+typedef struct ec_key_st EC_KEY;
+typedef struct ec_key_method_st EC_KEY_METHOD;
+# endif
+
+typedef struct rand_meth_st RAND_METHOD;
+typedef struct rand_drbg_st RAND_DRBG;
+
+typedef struct ssl_dane_st SSL_DANE;
+typedef struct x509_st X509;
+typedef struct X509_algor_st X509_ALGOR;
+typedef struct X509_crl_st X509_CRL;
+typedef struct x509_crl_method_st X509_CRL_METHOD;
+typedef struct x509_revoked_st X509_REVOKED;
+typedef struct X509_name_st X509_NAME;
+typedef struct X509_pubkey_st X509_PUBKEY;
+typedef struct x509_store_st X509_STORE;
+typedef struct x509_store_ctx_st X509_STORE_CTX;
+
+typedef struct x509_object_st X509_OBJECT;
+typedef struct x509_lookup_st X509_LOOKUP;
+typedef struct x509_lookup_method_st X509_LOOKUP_METHOD;
+typedef struct X509_VERIFY_PARAM_st X509_VERIFY_PARAM;
+
+typedef struct x509_sig_info_st X509_SIG_INFO;
+
+typedef struct pkcs8_priv_key_info_st PKCS8_PRIV_KEY_INFO;
+
+typedef struct v3_ext_ctx X509V3_CTX;
+typedef struct conf_st CONF;
+typedef struct ossl_init_settings_st OPENSSL_INIT_SETTINGS;
+
+typedef struct ui_st UI;
+typedef struct ui_method_st UI_METHOD;
+
+typedef struct engine_st ENGINE;
+typedef struct ssl_st SSL;
+typedef struct ssl_ctx_st SSL_CTX;
+
+typedef struct comp_ctx_st COMP_CTX;
+typedef struct comp_method_st COMP_METHOD;
+
+typedef struct X509_POLICY_NODE_st X509_POLICY_NODE;
+typedef struct X509_POLICY_LEVEL_st X509_POLICY_LEVEL;
+typedef struct X509_POLICY_TREE_st X509_POLICY_TREE;
+typedef struct X509_POLICY_CACHE_st X509_POLICY_CACHE;
+
+typedef struct AUTHORITY_KEYID_st AUTHORITY_KEYID;
+typedef struct DIST_POINT_st DIST_POINT;
+typedef struct ISSUING_DIST_POINT_st ISSUING_DIST_POINT;
+typedef struct NAME_CONSTRAINTS_st NAME_CONSTRAINTS;
+
+typedef struct crypto_ex_data_st CRYPTO_EX_DATA;
+
+typedef struct ossl_http_req_ctx_st OSSL_HTTP_REQ_CTX;
+typedef struct ocsp_response_st OCSP_RESPONSE;
+typedef struct ocsp_responder_id_st OCSP_RESPID;
+
+typedef struct sct_st SCT;
+typedef struct sct_ctx_st SCT_CTX;
+typedef struct ctlog_st CTLOG;
+typedef struct ctlog_store_st CTLOG_STORE;
+typedef struct ct_policy_eval_ctx_st CT_POLICY_EVAL_CTX;
+
+typedef struct ossl_store_info_st OSSL_STORE_INFO;
+typedef struct ossl_store_search_st OSSL_STORE_SEARCH;
+
+typedef struct ossl_lib_ctx_st OSSL_LIB_CTX;
+
+typedef struct ossl_dispatch_st OSSL_DISPATCH;
+typedef struct ossl_item_st OSSL_ITEM;
+typedef struct ossl_algorithm_st OSSL_ALGORITHM;
+typedef struct ossl_param_st OSSL_PARAM;
+typedef struct ossl_param_bld_st OSSL_PARAM_BLD;
+
+typedef int pem_password_cb (char *buf, int size, int rwflag, void *userdata);
+
+typedef struct ossl_encoder_st OSSL_ENCODER;
+typedef struct ossl_encoder_ctx_st OSSL_ENCODER_CTX;
+typedef struct ossl_decoder_st OSSL_DECODER;
+typedef struct ossl_decoder_ctx_st OSSL_DECODER_CTX;
+
+typedef struct ossl_self_test_st OSSL_SELF_TEST;
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif /* OPENSSL_TYPES_H */
diff --git a/src/include/openssl/ui.h b/src/include/openssl/ui.h
new file mode 100644
index 0000000..835b0eb
--- /dev/null
+++ b/src/include/openssl/ui.h
@@ -0,0 +1,407 @@
+/*
+ * WARNING: do not edit!
+ * Generated by makefile from include\openssl\ui.h.in
+ *
+ * Copyright 2001-2020 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+
+
+#ifndef OPENSSL_UI_H
+# define OPENSSL_UI_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_UI_H
+# endif
+
+# include <openssl/opensslconf.h>
+
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#  include <openssl/crypto.h>
+# endif
+# include <openssl/safestack.h>
+# include <openssl/pem.h>
+# include <openssl/types.h>
+# include <openssl/uierr.h>
+
+/* For compatibility reasons, the macro OPENSSL_NO_UI is currently retained */
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  ifdef OPENSSL_NO_UI_CONSOLE
+#   define OPENSSL_NO_UI
+#  endif
+# endif
+
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+/*
+ * All the following functions return -1 or NULL on error and in some cases
+ * (UI_process()) -2 if interrupted or in some other way cancelled. When
+ * everything is fine, they return 0, a positive value or a non-NULL pointer,
+ * all depending on their purpose.
+ */
+
+/* Creators and destructor.   */
+UI *UI_new(void);
+UI *UI_new_method(const UI_METHOD *method);
+void UI_free(UI *ui);
+
+/*-
+   The following functions are used to add strings to be printed and prompt
+   strings to prompt for data.  The names are UI_{add,dup}_<function>_string
+   and UI_{add,dup}_input_boolean.
+
+   UI_{add,dup}_<function>_string have the following meanings:
+        add     add a text or prompt string.  The pointers given to these
+                functions are used verbatim, no copying is done.
+        dup     make a copy of the text or prompt string, then add the copy
+                to the collection of strings in the user interface.
+        <function>
+                The function is a name for the functionality that the given
+                string shall be used for.  It can be one of:
+                        input   use the string as data prompt.
+                        verify  use the string as verification prompt.  This
+                                is used to verify a previous input.
+                        info    use the string for informational output.
+                        error   use the string for error output.
+   Honestly, there's currently no difference between info and error for the
+   moment.
+
+   UI_{add,dup}_input_boolean have the same semantics for "add" and "dup",
+   and are typically used when one wants to prompt for a yes/no response.
+
+   All of the functions in this group take a UI and a prompt string.
+   The string input and verify addition functions also take a flag argument,
+   a buffer for the result to end up with, a minimum input size and a maximum
+   input size (the result buffer MUST be large enough to be able to contain
+   the maximum number of characters).  Additionally, the verify addition
+   functions takes another buffer to compare the result against.
+   The boolean input functions take an action description string (which should
+   be safe to ignore if the expected user action is obvious, for example with
+   a dialog box with an OK button and a Cancel button), a string of acceptable
+   characters to mean OK and to mean Cancel.  The two last strings are checked
+   to make sure they don't have common characters.  Additionally, the same
+   flag argument as for the string input is taken, as well as a result buffer.
+   The result buffer is required to be at least one byte long.  Depending on
+   the answer, the first character from the OK or the Cancel character strings
+   will be stored in the first byte of the result buffer.  No NUL will be
+   added, so the result is *not* a string.
+
+   On success, the all return an index of the added information.  That index
+   is useful when retrieving results with UI_get0_result(). */
+int UI_add_input_string(UI *ui, const char *prompt, int flags,
+                        char *result_buf, int minsize, int maxsize);
+int UI_dup_input_string(UI *ui, const char *prompt, int flags,
+                        char *result_buf, int minsize, int maxsize);
+int UI_add_verify_string(UI *ui, const char *prompt, int flags,
+                         char *result_buf, int minsize, int maxsize,
+                         const char *test_buf);
+int UI_dup_verify_string(UI *ui, const char *prompt, int flags,
+                         char *result_buf, int minsize, int maxsize,
+                         const char *test_buf);
+int UI_add_input_boolean(UI *ui, const char *prompt, const char *action_desc,
+                         const char *ok_chars, const char *cancel_chars,
+                         int flags, char *result_buf);
+int UI_dup_input_boolean(UI *ui, const char *prompt, const char *action_desc,
+                         const char *ok_chars, const char *cancel_chars,
+                         int flags, char *result_buf);
+int UI_add_info_string(UI *ui, const char *text);
+int UI_dup_info_string(UI *ui, const char *text);
+int UI_add_error_string(UI *ui, const char *text);
+int UI_dup_error_string(UI *ui, const char *text);
+
+/* These are the possible flags.  They can be or'ed together. */
+/* Use to have echoing of input */
+# define UI_INPUT_FLAG_ECHO              0x01
+/*
+ * Use a default password.  Where that password is found is completely up to
+ * the application, it might for example be in the user data set with
+ * UI_add_user_data().  It is not recommended to have more than one input in
+ * each UI being marked with this flag, or the application might get
+ * confused.
+ */
+# define UI_INPUT_FLAG_DEFAULT_PWD       0x02
+
+/*-
+ * The user of these routines may want to define flags of their own.  The core
+ * UI won't look at those, but will pass them on to the method routines.  They
+ * must use higher bits so they don't get confused with the UI bits above.
+ * UI_INPUT_FLAG_USER_BASE tells which is the lowest bit to use.  A good
+ * example of use is this:
+ *
+ *    #define MY_UI_FLAG1       (0x01 << UI_INPUT_FLAG_USER_BASE)
+ *
+*/
+# define UI_INPUT_FLAG_USER_BASE 16
+
+/*-
+ * The following function helps construct a prompt.
+ * phrase_desc is a textual short description of the phrase to enter,
+ * for example "pass phrase", and
+ * object_name is the name of the object
+ * (which might be a card name or a file name) or NULL.
+ * The returned string shall always be allocated on the heap with
+ * OPENSSL_malloc(), and need to be free'd with OPENSSL_free().
+ *
+ * If the ui_method doesn't contain a pointer to a user-defined prompt
+ * constructor, a default string is built, looking like this:
+ *
+ *       "Enter {phrase_desc} for {object_name}:"
+ *
+ * So, if phrase_desc has the value "pass phrase" and object_name has
+ * the value "foo.key", the resulting string is:
+ *
+ *       "Enter pass phrase for foo.key:"
+*/
+char *UI_construct_prompt(UI *ui_method,
+                          const char *phrase_desc, const char *object_name);
+
+/*
+ * The following function is used to store a pointer to user-specific data.
+ * Any previous such pointer will be returned and replaced.
+ *
+ * For callback purposes, this function makes a lot more sense than using
+ * ex_data, since the latter requires that different parts of OpenSSL or
+ * applications share the same ex_data index.
+ *
+ * Note that the UI_OpenSSL() method completely ignores the user data. Other
+ * methods may not, however.
+ */
+void *UI_add_user_data(UI *ui, void *user_data);
+/*
+ * Alternatively, this function is used to duplicate the user data.
+ * This uses the duplicator method function.  The destroy function will
+ * be used to free the user data in this case.
+ */
+int UI_dup_user_data(UI *ui, void *user_data);
+/* We need a user data retrieving function as well.  */
+void *UI_get0_user_data(UI *ui);
+
+/* Return the result associated with a prompt given with the index i. */
+const char *UI_get0_result(UI *ui, int i);
+int UI_get_result_length(UI *ui, int i);
+
+/* When all strings have been added, process the whole thing. */
+int UI_process(UI *ui);
+
+/*
+ * Give a user interface parameterised control commands.  This can be used to
+ * send down an integer, a data pointer or a function pointer, as well as be
+ * used to get information from a UI.
+ */
+int UI_ctrl(UI *ui, int cmd, long i, void *p, void (*f) (void));
+
+/* The commands */
+/*
+ * Use UI_CONTROL_PRINT_ERRORS with the value 1 to have UI_process print the
+ * OpenSSL error stack before printing any info or added error messages and
+ * before any prompting.
+ */
+# define UI_CTRL_PRINT_ERRORS            1
+/*
+ * Check if a UI_process() is possible to do again with the same instance of
+ * a user interface.  This makes UI_ctrl() return 1 if it is redoable, and 0
+ * if not.
+ */
+# define UI_CTRL_IS_REDOABLE             2
+
+/* Some methods may use extra data */
+# define UI_set_app_data(s,arg)         UI_set_ex_data(s,0,arg)
+# define UI_get_app_data(s)             UI_get_ex_data(s,0)
+
+# define UI_get_ex_new_index(l, p, newf, dupf, freef) \
+    CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_UI, l, p, newf, dupf, freef)
+int UI_set_ex_data(UI *r, int idx, void *arg);
+void *UI_get_ex_data(const UI *r, int idx);
+
+/* Use specific methods instead of the built-in one */
+void UI_set_default_method(const UI_METHOD *meth);
+const UI_METHOD *UI_get_default_method(void);
+const UI_METHOD *UI_get_method(UI *ui);
+const UI_METHOD *UI_set_method(UI *ui, const UI_METHOD *meth);
+
+# ifndef OPENSSL_NO_UI_CONSOLE
+
+/* The method with all the built-in thingies */
+UI_METHOD *UI_OpenSSL(void);
+
+# endif
+
+/*
+ * NULL method.  Literally does nothing, but may serve as a placeholder
+ * to avoid internal default.
+ */
+const UI_METHOD *UI_null(void);
+
+/* ---------- For method writers ---------- */
+/*-
+   A method contains a number of functions that implement the low level
+   of the User Interface.  The functions are:
+
+        an opener       This function starts a session, maybe by opening
+                        a channel to a tty, or by opening a window.
+        a writer        This function is called to write a given string,
+                        maybe to the tty, maybe as a field label in a
+                        window.
+        a flusher       This function is called to flush everything that
+                        has been output so far.  It can be used to actually
+                        display a dialog box after it has been built.
+        a reader        This function is called to read a given prompt,
+                        maybe from the tty, maybe from a field in a
+                        window.  Note that it's called with all string
+                        structures, not only the prompt ones, so it must
+                        check such things itself.
+        a closer        This function closes the session, maybe by closing
+                        the channel to the tty, or closing the window.
+
+   All these functions are expected to return:
+
+        0       on error.
+        1       on success.
+        -1      on out-of-band events, for example if some prompting has
+                been canceled (by pressing Ctrl-C, for example).  This is
+                only checked when returned by the flusher or the reader.
+
+   The way this is used, the opener is first called, then the writer for all
+   strings, then the flusher, then the reader for all strings and finally the
+   closer.  Note that if you want to prompt from a terminal or other command
+   line interface, the best is to have the reader also write the prompts
+   instead of having the writer do it.  If you want to prompt from a dialog
+   box, the writer can be used to build up the contents of the box, and the
+   flusher to actually display the box and run the event loop until all data
+   has been given, after which the reader only grabs the given data and puts
+   them back into the UI strings.
+
+   All method functions take a UI as argument.  Additionally, the writer and
+   the reader take a UI_STRING.
+*/
+
+/*
+ * The UI_STRING type is the data structure that contains all the needed info
+ * about a string or a prompt, including test data for a verification prompt.
+ */
+typedef struct ui_string_st UI_STRING;
+
+SKM_DEFINE_STACK_OF_INTERNAL(UI_STRING, UI_STRING, UI_STRING)
+#define sk_UI_STRING_num(sk) OPENSSL_sk_num(ossl_check_const_UI_STRING_sk_type(sk))
+#define sk_UI_STRING_value(sk, idx) ((UI_STRING *)OPENSSL_sk_value(ossl_check_const_UI_STRING_sk_type(sk), (idx)))
+#define sk_UI_STRING_new(cmp) ((STACK_OF(UI_STRING) *)OPENSSL_sk_new(ossl_check_UI_STRING_compfunc_type(cmp)))
+#define sk_UI_STRING_new_null() ((STACK_OF(UI_STRING) *)OPENSSL_sk_new_null())
+#define sk_UI_STRING_new_reserve(cmp, n) ((STACK_OF(UI_STRING) *)OPENSSL_sk_new_reserve(ossl_check_UI_STRING_compfunc_type(cmp), (n)))
+#define sk_UI_STRING_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_UI_STRING_sk_type(sk), (n))
+#define sk_UI_STRING_free(sk) OPENSSL_sk_free(ossl_check_UI_STRING_sk_type(sk))
+#define sk_UI_STRING_zero(sk) OPENSSL_sk_zero(ossl_check_UI_STRING_sk_type(sk))
+#define sk_UI_STRING_delete(sk, i) ((UI_STRING *)OPENSSL_sk_delete(ossl_check_UI_STRING_sk_type(sk), (i)))
+#define sk_UI_STRING_delete_ptr(sk, ptr) ((UI_STRING *)OPENSSL_sk_delete_ptr(ossl_check_UI_STRING_sk_type(sk), ossl_check_UI_STRING_type(ptr)))
+#define sk_UI_STRING_push(sk, ptr) OPENSSL_sk_push(ossl_check_UI_STRING_sk_type(sk), ossl_check_UI_STRING_type(ptr))
+#define sk_UI_STRING_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_UI_STRING_sk_type(sk), ossl_check_UI_STRING_type(ptr))
+#define sk_UI_STRING_pop(sk) ((UI_STRING *)OPENSSL_sk_pop(ossl_check_UI_STRING_sk_type(sk)))
+#define sk_UI_STRING_shift(sk) ((UI_STRING *)OPENSSL_sk_shift(ossl_check_UI_STRING_sk_type(sk)))
+#define sk_UI_STRING_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_UI_STRING_sk_type(sk),ossl_check_UI_STRING_freefunc_type(freefunc))
+#define sk_UI_STRING_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_UI_STRING_sk_type(sk), ossl_check_UI_STRING_type(ptr), (idx))
+#define sk_UI_STRING_set(sk, idx, ptr) ((UI_STRING *)OPENSSL_sk_set(ossl_check_UI_STRING_sk_type(sk), (idx), ossl_check_UI_STRING_type(ptr)))
+#define sk_UI_STRING_find(sk, ptr) OPENSSL_sk_find(ossl_check_UI_STRING_sk_type(sk), ossl_check_UI_STRING_type(ptr))
+#define sk_UI_STRING_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_UI_STRING_sk_type(sk), ossl_check_UI_STRING_type(ptr))
+#define sk_UI_STRING_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_UI_STRING_sk_type(sk), ossl_check_UI_STRING_type(ptr), pnum)
+#define sk_UI_STRING_sort(sk) OPENSSL_sk_sort(ossl_check_UI_STRING_sk_type(sk))
+#define sk_UI_STRING_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_UI_STRING_sk_type(sk))
+#define sk_UI_STRING_dup(sk) ((STACK_OF(UI_STRING) *)OPENSSL_sk_dup(ossl_check_const_UI_STRING_sk_type(sk)))
+#define sk_UI_STRING_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(UI_STRING) *)OPENSSL_sk_deep_copy(ossl_check_const_UI_STRING_sk_type(sk), ossl_check_UI_STRING_copyfunc_type(copyfunc), ossl_check_UI_STRING_freefunc_type(freefunc)))
+#define sk_UI_STRING_set_cmp_func(sk, cmp) ((sk_UI_STRING_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_UI_STRING_sk_type(sk), ossl_check_UI_STRING_compfunc_type(cmp)))
+
+
+/*
+ * The different types of strings that are currently supported. This is only
+ * needed by method authors.
+ */
+enum UI_string_types {
+    UIT_NONE = 0,
+    UIT_PROMPT,                 /* Prompt for a string */
+    UIT_VERIFY,                 /* Prompt for a string and verify */
+    UIT_BOOLEAN,                /* Prompt for a yes/no response */
+    UIT_INFO,                   /* Send info to the user */
+    UIT_ERROR                   /* Send an error message to the user */
+};
+
+/* Create and manipulate methods */
+UI_METHOD *UI_create_method(const char *name);
+void UI_destroy_method(UI_METHOD *ui_method);
+int UI_method_set_opener(UI_METHOD *method, int (*opener) (UI *ui));
+int UI_method_set_writer(UI_METHOD *method,
+                         int (*writer) (UI *ui, UI_STRING *uis));
+int UI_method_set_flusher(UI_METHOD *method, int (*flusher) (UI *ui));
+int UI_method_set_reader(UI_METHOD *method,
+                         int (*reader) (UI *ui, UI_STRING *uis));
+int UI_method_set_closer(UI_METHOD *method, int (*closer) (UI *ui));
+int UI_method_set_data_duplicator(UI_METHOD *method,
+                                  void *(*duplicator) (UI *ui, void *ui_data),
+                                  void (*destructor)(UI *ui, void *ui_data));
+int UI_method_set_prompt_constructor(UI_METHOD *method,
+                                     char *(*prompt_constructor) (UI *ui,
+                                                                  const char
+                                                                  *phrase_desc,
+                                                                  const char
+                                                                  *object_name));
+int UI_method_set_ex_data(UI_METHOD *method, int idx, void *data);
+int (*UI_method_get_opener(const UI_METHOD *method)) (UI *);
+int (*UI_method_get_writer(const UI_METHOD *method)) (UI *, UI_STRING *);
+int (*UI_method_get_flusher(const UI_METHOD *method)) (UI *);
+int (*UI_method_get_reader(const UI_METHOD *method)) (UI *, UI_STRING *);
+int (*UI_method_get_closer(const UI_METHOD *method)) (UI *);
+char *(*UI_method_get_prompt_constructor(const UI_METHOD *method))
+    (UI *, const char *, const char *);
+void *(*UI_method_get_data_duplicator(const UI_METHOD *method)) (UI *, void *);
+void (*UI_method_get_data_destructor(const UI_METHOD *method)) (UI *, void *);
+const void *UI_method_get_ex_data(const UI_METHOD *method, int idx);
+
+/*
+ * The following functions are helpers for method writers to access relevant
+ * data from a UI_STRING.
+ */
+
+/* Return type of the UI_STRING */
+enum UI_string_types UI_get_string_type(UI_STRING *uis);
+/* Return input flags of the UI_STRING */
+int UI_get_input_flags(UI_STRING *uis);
+/* Return the actual string to output (the prompt, info or error) */
+const char *UI_get0_output_string(UI_STRING *uis);
+/*
+ * Return the optional action string to output (the boolean prompt
+ * instruction)
+ */
+const char *UI_get0_action_string(UI_STRING *uis);
+/* Return the result of a prompt */
+const char *UI_get0_result_string(UI_STRING *uis);
+int UI_get_result_string_length(UI_STRING *uis);
+/*
+ * Return the string to test the result against.  Only useful with verifies.
+ */
+const char *UI_get0_test_string(UI_STRING *uis);
+/* Return the required minimum size of the result */
+int UI_get_result_minsize(UI_STRING *uis);
+/* Return the required maximum size of the result */
+int UI_get_result_maxsize(UI_STRING *uis);
+/* Set the result of a UI_STRING. */
+int UI_set_result(UI *ui, UI_STRING *uis, const char *result);
+int UI_set_result_ex(UI *ui, UI_STRING *uis, const char *result, int len);
+
+/* A couple of popular utility functions */
+int UI_UTIL_read_pw_string(char *buf, int length, const char *prompt,
+                           int verify);
+int UI_UTIL_read_pw(char *buf, char *buff, int size, const char *prompt,
+                    int verify);
+UI_METHOD *UI_UTIL_wrap_read_pem_callback(pem_password_cb *cb, int rwflag);
+
+
+# ifdef  __cplusplus
+}
+# endif
+#endif
diff --git a/src/include/openssl/uierr.h b/src/include/openssl/uierr.h
new file mode 100644
index 0000000..473b04e
--- /dev/null
+++ b/src/include/openssl/uierr.h
@@ -0,0 +1,38 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_UIERR_H
+# define OPENSSL_UIERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+
+/*
+ * UI reason codes.
+ */
+# define UI_R_COMMON_OK_AND_CANCEL_CHARACTERS             104
+# define UI_R_INDEX_TOO_LARGE                             102
+# define UI_R_INDEX_TOO_SMALL                             103
+# define UI_R_NO_RESULT_BUFFER                            105
+# define UI_R_PROCESSING_ERROR                            107
+# define UI_R_RESULT_TOO_LARGE                            100
+# define UI_R_RESULT_TOO_SMALL                            101
+# define UI_R_SYSASSIGN_ERROR                             109
+# define UI_R_SYSDASSGN_ERROR                             110
+# define UI_R_SYSQIOW_ERROR                               111
+# define UI_R_UNKNOWN_CONTROL_COMMAND                     106
+# define UI_R_UNKNOWN_TTYGET_ERRNO_VALUE                  108
+# define UI_R_USER_DATA_DUPLICATION_UNSUPPORTED           112
+
+#endif
diff --git a/src/include/openssl/whrlpool.h b/src/include/openssl/whrlpool.h
new file mode 100644
index 0000000..05ba463
--- /dev/null
+++ b/src/include/openssl/whrlpool.h
@@ -0,0 +1,62 @@
+/*
+ * Copyright 2005-2020 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_WHRLPOOL_H
+# define OPENSSL_WHRLPOOL_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_WHRLPOOL_H
+# endif
+
+# include <openssl/opensslconf.h>
+
+# ifndef OPENSSL_NO_WHIRLPOOL
+#  include <openssl/e_os2.h>
+#  include <stddef.h>
+#  ifdef __cplusplus
+extern "C" {
+#  endif
+
+#  define WHIRLPOOL_DIGEST_LENGTH (512/8)
+
+#  if !defined(OPENSSL_NO_DEPRECATED_3_0)
+
+#   define WHIRLPOOL_BBLOCK        512
+#   define WHIRLPOOL_COUNTER       (256/8)
+
+typedef struct {
+    union {
+        unsigned char c[WHIRLPOOL_DIGEST_LENGTH];
+        /* double q is here to ensure 64-bit alignment */
+        double q[WHIRLPOOL_DIGEST_LENGTH / sizeof(double)];
+    } H;
+    unsigned char data[WHIRLPOOL_BBLOCK / 8];
+    unsigned int bitoff;
+    size_t bitlen[WHIRLPOOL_COUNTER / sizeof(size_t)];
+} WHIRLPOOL_CTX;
+#  endif
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int WHIRLPOOL_Init(WHIRLPOOL_CTX *c);
+OSSL_DEPRECATEDIN_3_0 int WHIRLPOOL_Update(WHIRLPOOL_CTX *c,
+                                           const void *inp, size_t bytes);
+OSSL_DEPRECATEDIN_3_0 void WHIRLPOOL_BitUpdate(WHIRLPOOL_CTX *c,
+                                               const void *inp, size_t bits);
+OSSL_DEPRECATEDIN_3_0 int WHIRLPOOL_Final(unsigned char *md, WHIRLPOOL_CTX *c);
+OSSL_DEPRECATEDIN_3_0 unsigned char *WHIRLPOOL(const void *inp, size_t bytes,
+                                               unsigned char *md);
+#  endif
+
+#  ifdef __cplusplus
+}
+#  endif
+# endif
+
+#endif
diff --git a/src/include/openssl/x509.h b/src/include/openssl/x509.h
new file mode 100644
index 0000000..d3a83fc
--- /dev/null
+++ b/src/include/openssl/x509.h
@@ -0,0 +1,1286 @@
+/*
+ * WARNING: do not edit!
+ * Generated by makefile from include\openssl\x509.h.in
+ *
+ * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+
+
+#ifndef OPENSSL_X509_H
+# define OPENSSL_X509_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_X509_H
+# endif
+
+# include <openssl/e_os2.h>
+# include <openssl/types.h>
+# include <openssl/symhacks.h>
+# include <openssl/buffer.h>
+# include <openssl/evp.h>
+# include <openssl/bio.h>
+# include <openssl/asn1.h>
+# include <openssl/safestack.h>
+# include <openssl/ec.h>
+
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#  include <openssl/rsa.h>
+#  include <openssl/dsa.h>
+#  include <openssl/dh.h>
+# endif
+
+# include <openssl/sha.h>
+# include <openssl/x509err.h>
+# ifndef OPENSSL_NO_STDIO
+#  include <stdio.h>
+# endif
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+/* Needed stacks for types defined in other headers */
+SKM_DEFINE_STACK_OF_INTERNAL(X509_NAME, X509_NAME, X509_NAME)
+#define sk_X509_NAME_num(sk) OPENSSL_sk_num(ossl_check_const_X509_NAME_sk_type(sk))
+#define sk_X509_NAME_value(sk, idx) ((X509_NAME *)OPENSSL_sk_value(ossl_check_const_X509_NAME_sk_type(sk), (idx)))
+#define sk_X509_NAME_new(cmp) ((STACK_OF(X509_NAME) *)OPENSSL_sk_new(ossl_check_X509_NAME_compfunc_type(cmp)))
+#define sk_X509_NAME_new_null() ((STACK_OF(X509_NAME) *)OPENSSL_sk_new_null())
+#define sk_X509_NAME_new_reserve(cmp, n) ((STACK_OF(X509_NAME) *)OPENSSL_sk_new_reserve(ossl_check_X509_NAME_compfunc_type(cmp), (n)))
+#define sk_X509_NAME_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_X509_NAME_sk_type(sk), (n))
+#define sk_X509_NAME_free(sk) OPENSSL_sk_free(ossl_check_X509_NAME_sk_type(sk))
+#define sk_X509_NAME_zero(sk) OPENSSL_sk_zero(ossl_check_X509_NAME_sk_type(sk))
+#define sk_X509_NAME_delete(sk, i) ((X509_NAME *)OPENSSL_sk_delete(ossl_check_X509_NAME_sk_type(sk), (i)))
+#define sk_X509_NAME_delete_ptr(sk, ptr) ((X509_NAME *)OPENSSL_sk_delete_ptr(ossl_check_X509_NAME_sk_type(sk), ossl_check_X509_NAME_type(ptr)))
+#define sk_X509_NAME_push(sk, ptr) OPENSSL_sk_push(ossl_check_X509_NAME_sk_type(sk), ossl_check_X509_NAME_type(ptr))
+#define sk_X509_NAME_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_X509_NAME_sk_type(sk), ossl_check_X509_NAME_type(ptr))
+#define sk_X509_NAME_pop(sk) ((X509_NAME *)OPENSSL_sk_pop(ossl_check_X509_NAME_sk_type(sk)))
+#define sk_X509_NAME_shift(sk) ((X509_NAME *)OPENSSL_sk_shift(ossl_check_X509_NAME_sk_type(sk)))
+#define sk_X509_NAME_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_NAME_sk_type(sk),ossl_check_X509_NAME_freefunc_type(freefunc))
+#define sk_X509_NAME_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_X509_NAME_sk_type(sk), ossl_check_X509_NAME_type(ptr), (idx))
+#define sk_X509_NAME_set(sk, idx, ptr) ((X509_NAME *)OPENSSL_sk_set(ossl_check_X509_NAME_sk_type(sk), (idx), ossl_check_X509_NAME_type(ptr)))
+#define sk_X509_NAME_find(sk, ptr) OPENSSL_sk_find(ossl_check_X509_NAME_sk_type(sk), ossl_check_X509_NAME_type(ptr))
+#define sk_X509_NAME_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_X509_NAME_sk_type(sk), ossl_check_X509_NAME_type(ptr))
+#define sk_X509_NAME_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_X509_NAME_sk_type(sk), ossl_check_X509_NAME_type(ptr), pnum)
+#define sk_X509_NAME_sort(sk) OPENSSL_sk_sort(ossl_check_X509_NAME_sk_type(sk))
+#define sk_X509_NAME_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_X509_NAME_sk_type(sk))
+#define sk_X509_NAME_dup(sk) ((STACK_OF(X509_NAME) *)OPENSSL_sk_dup(ossl_check_const_X509_NAME_sk_type(sk)))
+#define sk_X509_NAME_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_NAME) *)OPENSSL_sk_deep_copy(ossl_check_const_X509_NAME_sk_type(sk), ossl_check_X509_NAME_copyfunc_type(copyfunc), ossl_check_X509_NAME_freefunc_type(freefunc)))
+#define sk_X509_NAME_set_cmp_func(sk, cmp) ((sk_X509_NAME_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_X509_NAME_sk_type(sk), ossl_check_X509_NAME_compfunc_type(cmp)))
+SKM_DEFINE_STACK_OF_INTERNAL(X509, X509, X509)
+#define sk_X509_num(sk) OPENSSL_sk_num(ossl_check_const_X509_sk_type(sk))
+#define sk_X509_value(sk, idx) ((X509 *)OPENSSL_sk_value(ossl_check_const_X509_sk_type(sk), (idx)))
+#define sk_X509_new(cmp) ((STACK_OF(X509) *)OPENSSL_sk_new(ossl_check_X509_compfunc_type(cmp)))
+#define sk_X509_new_null() ((STACK_OF(X509) *)OPENSSL_sk_new_null())
+#define sk_X509_new_reserve(cmp, n) ((STACK_OF(X509) *)OPENSSL_sk_new_reserve(ossl_check_X509_compfunc_type(cmp), (n)))
+#define sk_X509_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_X509_sk_type(sk), (n))
+#define sk_X509_free(sk) OPENSSL_sk_free(ossl_check_X509_sk_type(sk))
+#define sk_X509_zero(sk) OPENSSL_sk_zero(ossl_check_X509_sk_type(sk))
+#define sk_X509_delete(sk, i) ((X509 *)OPENSSL_sk_delete(ossl_check_X509_sk_type(sk), (i)))
+#define sk_X509_delete_ptr(sk, ptr) ((X509 *)OPENSSL_sk_delete_ptr(ossl_check_X509_sk_type(sk), ossl_check_X509_type(ptr)))
+#define sk_X509_push(sk, ptr) OPENSSL_sk_push(ossl_check_X509_sk_type(sk), ossl_check_X509_type(ptr))
+#define sk_X509_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_X509_sk_type(sk), ossl_check_X509_type(ptr))
+#define sk_X509_pop(sk) ((X509 *)OPENSSL_sk_pop(ossl_check_X509_sk_type(sk)))
+#define sk_X509_shift(sk) ((X509 *)OPENSSL_sk_shift(ossl_check_X509_sk_type(sk)))
+#define sk_X509_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_sk_type(sk),ossl_check_X509_freefunc_type(freefunc))
+#define sk_X509_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_X509_sk_type(sk), ossl_check_X509_type(ptr), (idx))
+#define sk_X509_set(sk, idx, ptr) ((X509 *)OPENSSL_sk_set(ossl_check_X509_sk_type(sk), (idx), ossl_check_X509_type(ptr)))
+#define sk_X509_find(sk, ptr) OPENSSL_sk_find(ossl_check_X509_sk_type(sk), ossl_check_X509_type(ptr))
+#define sk_X509_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_X509_sk_type(sk), ossl_check_X509_type(ptr))
+#define sk_X509_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_X509_sk_type(sk), ossl_check_X509_type(ptr), pnum)
+#define sk_X509_sort(sk) OPENSSL_sk_sort(ossl_check_X509_sk_type(sk))
+#define sk_X509_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_X509_sk_type(sk))
+#define sk_X509_dup(sk) ((STACK_OF(X509) *)OPENSSL_sk_dup(ossl_check_const_X509_sk_type(sk)))
+#define sk_X509_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509) *)OPENSSL_sk_deep_copy(ossl_check_const_X509_sk_type(sk), ossl_check_X509_copyfunc_type(copyfunc), ossl_check_X509_freefunc_type(freefunc)))
+#define sk_X509_set_cmp_func(sk, cmp) ((sk_X509_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_X509_sk_type(sk), ossl_check_X509_compfunc_type(cmp)))
+SKM_DEFINE_STACK_OF_INTERNAL(X509_REVOKED, X509_REVOKED, X509_REVOKED)
+#define sk_X509_REVOKED_num(sk) OPENSSL_sk_num(ossl_check_const_X509_REVOKED_sk_type(sk))
+#define sk_X509_REVOKED_value(sk, idx) ((X509_REVOKED *)OPENSSL_sk_value(ossl_check_const_X509_REVOKED_sk_type(sk), (idx)))
+#define sk_X509_REVOKED_new(cmp) ((STACK_OF(X509_REVOKED) *)OPENSSL_sk_new(ossl_check_X509_REVOKED_compfunc_type(cmp)))
+#define sk_X509_REVOKED_new_null() ((STACK_OF(X509_REVOKED) *)OPENSSL_sk_new_null())
+#define sk_X509_REVOKED_new_reserve(cmp, n) ((STACK_OF(X509_REVOKED) *)OPENSSL_sk_new_reserve(ossl_check_X509_REVOKED_compfunc_type(cmp), (n)))
+#define sk_X509_REVOKED_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_X509_REVOKED_sk_type(sk), (n))
+#define sk_X509_REVOKED_free(sk) OPENSSL_sk_free(ossl_check_X509_REVOKED_sk_type(sk))
+#define sk_X509_REVOKED_zero(sk) OPENSSL_sk_zero(ossl_check_X509_REVOKED_sk_type(sk))
+#define sk_X509_REVOKED_delete(sk, i) ((X509_REVOKED *)OPENSSL_sk_delete(ossl_check_X509_REVOKED_sk_type(sk), (i)))
+#define sk_X509_REVOKED_delete_ptr(sk, ptr) ((X509_REVOKED *)OPENSSL_sk_delete_ptr(ossl_check_X509_REVOKED_sk_type(sk), ossl_check_X509_REVOKED_type(ptr)))
+#define sk_X509_REVOKED_push(sk, ptr) OPENSSL_sk_push(ossl_check_X509_REVOKED_sk_type(sk), ossl_check_X509_REVOKED_type(ptr))
+#define sk_X509_REVOKED_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_X509_REVOKED_sk_type(sk), ossl_check_X509_REVOKED_type(ptr))
+#define sk_X509_REVOKED_pop(sk) ((X509_REVOKED *)OPENSSL_sk_pop(ossl_check_X509_REVOKED_sk_type(sk)))
+#define sk_X509_REVOKED_shift(sk) ((X509_REVOKED *)OPENSSL_sk_shift(ossl_check_X509_REVOKED_sk_type(sk)))
+#define sk_X509_REVOKED_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_REVOKED_sk_type(sk),ossl_check_X509_REVOKED_freefunc_type(freefunc))
+#define sk_X509_REVOKED_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_X509_REVOKED_sk_type(sk), ossl_check_X509_REVOKED_type(ptr), (idx))
+#define sk_X509_REVOKED_set(sk, idx, ptr) ((X509_REVOKED *)OPENSSL_sk_set(ossl_check_X509_REVOKED_sk_type(sk), (idx), ossl_check_X509_REVOKED_type(ptr)))
+#define sk_X509_REVOKED_find(sk, ptr) OPENSSL_sk_find(ossl_check_X509_REVOKED_sk_type(sk), ossl_check_X509_REVOKED_type(ptr))
+#define sk_X509_REVOKED_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_X509_REVOKED_sk_type(sk), ossl_check_X509_REVOKED_type(ptr))
+#define sk_X509_REVOKED_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_X509_REVOKED_sk_type(sk), ossl_check_X509_REVOKED_type(ptr), pnum)
+#define sk_X509_REVOKED_sort(sk) OPENSSL_sk_sort(ossl_check_X509_REVOKED_sk_type(sk))
+#define sk_X509_REVOKED_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_X509_REVOKED_sk_type(sk))
+#define sk_X509_REVOKED_dup(sk) ((STACK_OF(X509_REVOKED) *)OPENSSL_sk_dup(ossl_check_const_X509_REVOKED_sk_type(sk)))
+#define sk_X509_REVOKED_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_REVOKED) *)OPENSSL_sk_deep_copy(ossl_check_const_X509_REVOKED_sk_type(sk), ossl_check_X509_REVOKED_copyfunc_type(copyfunc), ossl_check_X509_REVOKED_freefunc_type(freefunc)))
+#define sk_X509_REVOKED_set_cmp_func(sk, cmp) ((sk_X509_REVOKED_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_X509_REVOKED_sk_type(sk), ossl_check_X509_REVOKED_compfunc_type(cmp)))
+SKM_DEFINE_STACK_OF_INTERNAL(X509_CRL, X509_CRL, X509_CRL)
+#define sk_X509_CRL_num(sk) OPENSSL_sk_num(ossl_check_const_X509_CRL_sk_type(sk))
+#define sk_X509_CRL_value(sk, idx) ((X509_CRL *)OPENSSL_sk_value(ossl_check_const_X509_CRL_sk_type(sk), (idx)))
+#define sk_X509_CRL_new(cmp) ((STACK_OF(X509_CRL) *)OPENSSL_sk_new(ossl_check_X509_CRL_compfunc_type(cmp)))
+#define sk_X509_CRL_new_null() ((STACK_OF(X509_CRL) *)OPENSSL_sk_new_null())
+#define sk_X509_CRL_new_reserve(cmp, n) ((STACK_OF(X509_CRL) *)OPENSSL_sk_new_reserve(ossl_check_X509_CRL_compfunc_type(cmp), (n)))
+#define sk_X509_CRL_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_X509_CRL_sk_type(sk), (n))
+#define sk_X509_CRL_free(sk) OPENSSL_sk_free(ossl_check_X509_CRL_sk_type(sk))
+#define sk_X509_CRL_zero(sk) OPENSSL_sk_zero(ossl_check_X509_CRL_sk_type(sk))
+#define sk_X509_CRL_delete(sk, i) ((X509_CRL *)OPENSSL_sk_delete(ossl_check_X509_CRL_sk_type(sk), (i)))
+#define sk_X509_CRL_delete_ptr(sk, ptr) ((X509_CRL *)OPENSSL_sk_delete_ptr(ossl_check_X509_CRL_sk_type(sk), ossl_check_X509_CRL_type(ptr)))
+#define sk_X509_CRL_push(sk, ptr) OPENSSL_sk_push(ossl_check_X509_CRL_sk_type(sk), ossl_check_X509_CRL_type(ptr))
+#define sk_X509_CRL_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_X509_CRL_sk_type(sk), ossl_check_X509_CRL_type(ptr))
+#define sk_X509_CRL_pop(sk) ((X509_CRL *)OPENSSL_sk_pop(ossl_check_X509_CRL_sk_type(sk)))
+#define sk_X509_CRL_shift(sk) ((X509_CRL *)OPENSSL_sk_shift(ossl_check_X509_CRL_sk_type(sk)))
+#define sk_X509_CRL_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_CRL_sk_type(sk),ossl_check_X509_CRL_freefunc_type(freefunc))
+#define sk_X509_CRL_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_X509_CRL_sk_type(sk), ossl_check_X509_CRL_type(ptr), (idx))
+#define sk_X509_CRL_set(sk, idx, ptr) ((X509_CRL *)OPENSSL_sk_set(ossl_check_X509_CRL_sk_type(sk), (idx), ossl_check_X509_CRL_type(ptr)))
+#define sk_X509_CRL_find(sk, ptr) OPENSSL_sk_find(ossl_check_X509_CRL_sk_type(sk), ossl_check_X509_CRL_type(ptr))
+#define sk_X509_CRL_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_X509_CRL_sk_type(sk), ossl_check_X509_CRL_type(ptr))
+#define sk_X509_CRL_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_X509_CRL_sk_type(sk), ossl_check_X509_CRL_type(ptr), pnum)
+#define sk_X509_CRL_sort(sk) OPENSSL_sk_sort(ossl_check_X509_CRL_sk_type(sk))
+#define sk_X509_CRL_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_X509_CRL_sk_type(sk))
+#define sk_X509_CRL_dup(sk) ((STACK_OF(X509_CRL) *)OPENSSL_sk_dup(ossl_check_const_X509_CRL_sk_type(sk)))
+#define sk_X509_CRL_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_CRL) *)OPENSSL_sk_deep_copy(ossl_check_const_X509_CRL_sk_type(sk), ossl_check_X509_CRL_copyfunc_type(copyfunc), ossl_check_X509_CRL_freefunc_type(freefunc)))
+#define sk_X509_CRL_set_cmp_func(sk, cmp) ((sk_X509_CRL_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_X509_CRL_sk_type(sk), ossl_check_X509_CRL_compfunc_type(cmp)))
+
+
+/* Flags for X509_get_signature_info() */
+/* Signature info is valid */
+# define X509_SIG_INFO_VALID     0x1
+/* Signature is suitable for TLS use */
+# define X509_SIG_INFO_TLS       0x2
+
+# define X509_FILETYPE_PEM       1
+# define X509_FILETYPE_ASN1      2
+# define X509_FILETYPE_DEFAULT   3
+
+# define X509v3_KU_DIGITAL_SIGNATURE     0x0080
+# define X509v3_KU_NON_REPUDIATION       0x0040
+# define X509v3_KU_KEY_ENCIPHERMENT      0x0020
+# define X509v3_KU_DATA_ENCIPHERMENT     0x0010
+# define X509v3_KU_KEY_AGREEMENT         0x0008
+# define X509v3_KU_KEY_CERT_SIGN         0x0004
+# define X509v3_KU_CRL_SIGN              0x0002
+# define X509v3_KU_ENCIPHER_ONLY         0x0001
+# define X509v3_KU_DECIPHER_ONLY         0x8000
+# define X509v3_KU_UNDEF                 0xffff
+
+struct X509_algor_st {
+    ASN1_OBJECT *algorithm;
+    ASN1_TYPE *parameter;
+} /* X509_ALGOR */ ;
+
+typedef STACK_OF(X509_ALGOR) X509_ALGORS;
+
+typedef struct X509_val_st {
+    ASN1_TIME *notBefore;
+    ASN1_TIME *notAfter;
+} X509_VAL;
+
+typedef struct X509_sig_st X509_SIG;
+
+typedef struct X509_name_entry_st X509_NAME_ENTRY;
+
+SKM_DEFINE_STACK_OF_INTERNAL(X509_NAME_ENTRY, X509_NAME_ENTRY, X509_NAME_ENTRY)
+#define sk_X509_NAME_ENTRY_num(sk) OPENSSL_sk_num(ossl_check_const_X509_NAME_ENTRY_sk_type(sk))
+#define sk_X509_NAME_ENTRY_value(sk, idx) ((X509_NAME_ENTRY *)OPENSSL_sk_value(ossl_check_const_X509_NAME_ENTRY_sk_type(sk), (idx)))
+#define sk_X509_NAME_ENTRY_new(cmp) ((STACK_OF(X509_NAME_ENTRY) *)OPENSSL_sk_new(ossl_check_X509_NAME_ENTRY_compfunc_type(cmp)))
+#define sk_X509_NAME_ENTRY_new_null() ((STACK_OF(X509_NAME_ENTRY) *)OPENSSL_sk_new_null())
+#define sk_X509_NAME_ENTRY_new_reserve(cmp, n) ((STACK_OF(X509_NAME_ENTRY) *)OPENSSL_sk_new_reserve(ossl_check_X509_NAME_ENTRY_compfunc_type(cmp), (n)))
+#define sk_X509_NAME_ENTRY_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_X509_NAME_ENTRY_sk_type(sk), (n))
+#define sk_X509_NAME_ENTRY_free(sk) OPENSSL_sk_free(ossl_check_X509_NAME_ENTRY_sk_type(sk))
+#define sk_X509_NAME_ENTRY_zero(sk) OPENSSL_sk_zero(ossl_check_X509_NAME_ENTRY_sk_type(sk))
+#define sk_X509_NAME_ENTRY_delete(sk, i) ((X509_NAME_ENTRY *)OPENSSL_sk_delete(ossl_check_X509_NAME_ENTRY_sk_type(sk), (i)))
+#define sk_X509_NAME_ENTRY_delete_ptr(sk, ptr) ((X509_NAME_ENTRY *)OPENSSL_sk_delete_ptr(ossl_check_X509_NAME_ENTRY_sk_type(sk), ossl_check_X509_NAME_ENTRY_type(ptr)))
+#define sk_X509_NAME_ENTRY_push(sk, ptr) OPENSSL_sk_push(ossl_check_X509_NAME_ENTRY_sk_type(sk), ossl_check_X509_NAME_ENTRY_type(ptr))
+#define sk_X509_NAME_ENTRY_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_X509_NAME_ENTRY_sk_type(sk), ossl_check_X509_NAME_ENTRY_type(ptr))
+#define sk_X509_NAME_ENTRY_pop(sk) ((X509_NAME_ENTRY *)OPENSSL_sk_pop(ossl_check_X509_NAME_ENTRY_sk_type(sk)))
+#define sk_X509_NAME_ENTRY_shift(sk) ((X509_NAME_ENTRY *)OPENSSL_sk_shift(ossl_check_X509_NAME_ENTRY_sk_type(sk)))
+#define sk_X509_NAME_ENTRY_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_NAME_ENTRY_sk_type(sk),ossl_check_X509_NAME_ENTRY_freefunc_type(freefunc))
+#define sk_X509_NAME_ENTRY_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_X509_NAME_ENTRY_sk_type(sk), ossl_check_X509_NAME_ENTRY_type(ptr), (idx))
+#define sk_X509_NAME_ENTRY_set(sk, idx, ptr) ((X509_NAME_ENTRY *)OPENSSL_sk_set(ossl_check_X509_NAME_ENTRY_sk_type(sk), (idx), ossl_check_X509_NAME_ENTRY_type(ptr)))
+#define sk_X509_NAME_ENTRY_find(sk, ptr) OPENSSL_sk_find(ossl_check_X509_NAME_ENTRY_sk_type(sk), ossl_check_X509_NAME_ENTRY_type(ptr))
+#define sk_X509_NAME_ENTRY_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_X509_NAME_ENTRY_sk_type(sk), ossl_check_X509_NAME_ENTRY_type(ptr))
+#define sk_X509_NAME_ENTRY_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_X509_NAME_ENTRY_sk_type(sk), ossl_check_X509_NAME_ENTRY_type(ptr), pnum)
+#define sk_X509_NAME_ENTRY_sort(sk) OPENSSL_sk_sort(ossl_check_X509_NAME_ENTRY_sk_type(sk))
+#define sk_X509_NAME_ENTRY_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_X509_NAME_ENTRY_sk_type(sk))
+#define sk_X509_NAME_ENTRY_dup(sk) ((STACK_OF(X509_NAME_ENTRY) *)OPENSSL_sk_dup(ossl_check_const_X509_NAME_ENTRY_sk_type(sk)))
+#define sk_X509_NAME_ENTRY_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_NAME_ENTRY) *)OPENSSL_sk_deep_copy(ossl_check_const_X509_NAME_ENTRY_sk_type(sk), ossl_check_X509_NAME_ENTRY_copyfunc_type(copyfunc), ossl_check_X509_NAME_ENTRY_freefunc_type(freefunc)))
+#define sk_X509_NAME_ENTRY_set_cmp_func(sk, cmp) ((sk_X509_NAME_ENTRY_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_X509_NAME_ENTRY_sk_type(sk), ossl_check_X509_NAME_ENTRY_compfunc_type(cmp)))
+
+
+# define X509_EX_V_NETSCAPE_HACK         0x8000
+# define X509_EX_V_INIT                  0x0001
+typedef struct X509_extension_st X509_EXTENSION;
+SKM_DEFINE_STACK_OF_INTERNAL(X509_EXTENSION, X509_EXTENSION, X509_EXTENSION)
+#define sk_X509_EXTENSION_num(sk) OPENSSL_sk_num(ossl_check_const_X509_EXTENSION_sk_type(sk))
+#define sk_X509_EXTENSION_value(sk, idx) ((X509_EXTENSION *)OPENSSL_sk_value(ossl_check_const_X509_EXTENSION_sk_type(sk), (idx)))
+#define sk_X509_EXTENSION_new(cmp) ((STACK_OF(X509_EXTENSION) *)OPENSSL_sk_new(ossl_check_X509_EXTENSION_compfunc_type(cmp)))
+#define sk_X509_EXTENSION_new_null() ((STACK_OF(X509_EXTENSION) *)OPENSSL_sk_new_null())
+#define sk_X509_EXTENSION_new_reserve(cmp, n) ((STACK_OF(X509_EXTENSION) *)OPENSSL_sk_new_reserve(ossl_check_X509_EXTENSION_compfunc_type(cmp), (n)))
+#define sk_X509_EXTENSION_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_X509_EXTENSION_sk_type(sk), (n))
+#define sk_X509_EXTENSION_free(sk) OPENSSL_sk_free(ossl_check_X509_EXTENSION_sk_type(sk))
+#define sk_X509_EXTENSION_zero(sk) OPENSSL_sk_zero(ossl_check_X509_EXTENSION_sk_type(sk))
+#define sk_X509_EXTENSION_delete(sk, i) ((X509_EXTENSION *)OPENSSL_sk_delete(ossl_check_X509_EXTENSION_sk_type(sk), (i)))
+#define sk_X509_EXTENSION_delete_ptr(sk, ptr) ((X509_EXTENSION *)OPENSSL_sk_delete_ptr(ossl_check_X509_EXTENSION_sk_type(sk), ossl_check_X509_EXTENSION_type(ptr)))
+#define sk_X509_EXTENSION_push(sk, ptr) OPENSSL_sk_push(ossl_check_X509_EXTENSION_sk_type(sk), ossl_check_X509_EXTENSION_type(ptr))
+#define sk_X509_EXTENSION_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_X509_EXTENSION_sk_type(sk), ossl_check_X509_EXTENSION_type(ptr))
+#define sk_X509_EXTENSION_pop(sk) ((X509_EXTENSION *)OPENSSL_sk_pop(ossl_check_X509_EXTENSION_sk_type(sk)))
+#define sk_X509_EXTENSION_shift(sk) ((X509_EXTENSION *)OPENSSL_sk_shift(ossl_check_X509_EXTENSION_sk_type(sk)))
+#define sk_X509_EXTENSION_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_EXTENSION_sk_type(sk),ossl_check_X509_EXTENSION_freefunc_type(freefunc))
+#define sk_X509_EXTENSION_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_X509_EXTENSION_sk_type(sk), ossl_check_X509_EXTENSION_type(ptr), (idx))
+#define sk_X509_EXTENSION_set(sk, idx, ptr) ((X509_EXTENSION *)OPENSSL_sk_set(ossl_check_X509_EXTENSION_sk_type(sk), (idx), ossl_check_X509_EXTENSION_type(ptr)))
+#define sk_X509_EXTENSION_find(sk, ptr) OPENSSL_sk_find(ossl_check_X509_EXTENSION_sk_type(sk), ossl_check_X509_EXTENSION_type(ptr))
+#define sk_X509_EXTENSION_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_X509_EXTENSION_sk_type(sk), ossl_check_X509_EXTENSION_type(ptr))
+#define sk_X509_EXTENSION_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_X509_EXTENSION_sk_type(sk), ossl_check_X509_EXTENSION_type(ptr), pnum)
+#define sk_X509_EXTENSION_sort(sk) OPENSSL_sk_sort(ossl_check_X509_EXTENSION_sk_type(sk))
+#define sk_X509_EXTENSION_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_X509_EXTENSION_sk_type(sk))
+#define sk_X509_EXTENSION_dup(sk) ((STACK_OF(X509_EXTENSION) *)OPENSSL_sk_dup(ossl_check_const_X509_EXTENSION_sk_type(sk)))
+#define sk_X509_EXTENSION_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_EXTENSION) *)OPENSSL_sk_deep_copy(ossl_check_const_X509_EXTENSION_sk_type(sk), ossl_check_X509_EXTENSION_copyfunc_type(copyfunc), ossl_check_X509_EXTENSION_freefunc_type(freefunc)))
+#define sk_X509_EXTENSION_set_cmp_func(sk, cmp) ((sk_X509_EXTENSION_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_X509_EXTENSION_sk_type(sk), ossl_check_X509_EXTENSION_compfunc_type(cmp)))
+
+typedef STACK_OF(X509_EXTENSION) X509_EXTENSIONS;
+typedef struct x509_attributes_st X509_ATTRIBUTE;
+SKM_DEFINE_STACK_OF_INTERNAL(X509_ATTRIBUTE, X509_ATTRIBUTE, X509_ATTRIBUTE)
+#define sk_X509_ATTRIBUTE_num(sk) OPENSSL_sk_num(ossl_check_const_X509_ATTRIBUTE_sk_type(sk))
+#define sk_X509_ATTRIBUTE_value(sk, idx) ((X509_ATTRIBUTE *)OPENSSL_sk_value(ossl_check_const_X509_ATTRIBUTE_sk_type(sk), (idx)))
+#define sk_X509_ATTRIBUTE_new(cmp) ((STACK_OF(X509_ATTRIBUTE) *)OPENSSL_sk_new(ossl_check_X509_ATTRIBUTE_compfunc_type(cmp)))
+#define sk_X509_ATTRIBUTE_new_null() ((STACK_OF(X509_ATTRIBUTE) *)OPENSSL_sk_new_null())
+#define sk_X509_ATTRIBUTE_new_reserve(cmp, n) ((STACK_OF(X509_ATTRIBUTE) *)OPENSSL_sk_new_reserve(ossl_check_X509_ATTRIBUTE_compfunc_type(cmp), (n)))
+#define sk_X509_ATTRIBUTE_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_X509_ATTRIBUTE_sk_type(sk), (n))
+#define sk_X509_ATTRIBUTE_free(sk) OPENSSL_sk_free(ossl_check_X509_ATTRIBUTE_sk_type(sk))
+#define sk_X509_ATTRIBUTE_zero(sk) OPENSSL_sk_zero(ossl_check_X509_ATTRIBUTE_sk_type(sk))
+#define sk_X509_ATTRIBUTE_delete(sk, i) ((X509_ATTRIBUTE *)OPENSSL_sk_delete(ossl_check_X509_ATTRIBUTE_sk_type(sk), (i)))
+#define sk_X509_ATTRIBUTE_delete_ptr(sk, ptr) ((X509_ATTRIBUTE *)OPENSSL_sk_delete_ptr(ossl_check_X509_ATTRIBUTE_sk_type(sk), ossl_check_X509_ATTRIBUTE_type(ptr)))
+#define sk_X509_ATTRIBUTE_push(sk, ptr) OPENSSL_sk_push(ossl_check_X509_ATTRIBUTE_sk_type(sk), ossl_check_X509_ATTRIBUTE_type(ptr))
+#define sk_X509_ATTRIBUTE_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_X509_ATTRIBUTE_sk_type(sk), ossl_check_X509_ATTRIBUTE_type(ptr))
+#define sk_X509_ATTRIBUTE_pop(sk) ((X509_ATTRIBUTE *)OPENSSL_sk_pop(ossl_check_X509_ATTRIBUTE_sk_type(sk)))
+#define sk_X509_ATTRIBUTE_shift(sk) ((X509_ATTRIBUTE *)OPENSSL_sk_shift(ossl_check_X509_ATTRIBUTE_sk_type(sk)))
+#define sk_X509_ATTRIBUTE_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_ATTRIBUTE_sk_type(sk),ossl_check_X509_ATTRIBUTE_freefunc_type(freefunc))
+#define sk_X509_ATTRIBUTE_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_X509_ATTRIBUTE_sk_type(sk), ossl_check_X509_ATTRIBUTE_type(ptr), (idx))
+#define sk_X509_ATTRIBUTE_set(sk, idx, ptr) ((X509_ATTRIBUTE *)OPENSSL_sk_set(ossl_check_X509_ATTRIBUTE_sk_type(sk), (idx), ossl_check_X509_ATTRIBUTE_type(ptr)))
+#define sk_X509_ATTRIBUTE_find(sk, ptr) OPENSSL_sk_find(ossl_check_X509_ATTRIBUTE_sk_type(sk), ossl_check_X509_ATTRIBUTE_type(ptr))
+#define sk_X509_ATTRIBUTE_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_X509_ATTRIBUTE_sk_type(sk), ossl_check_X509_ATTRIBUTE_type(ptr))
+#define sk_X509_ATTRIBUTE_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_X509_ATTRIBUTE_sk_type(sk), ossl_check_X509_ATTRIBUTE_type(ptr), pnum)
+#define sk_X509_ATTRIBUTE_sort(sk) OPENSSL_sk_sort(ossl_check_X509_ATTRIBUTE_sk_type(sk))
+#define sk_X509_ATTRIBUTE_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_X509_ATTRIBUTE_sk_type(sk))
+#define sk_X509_ATTRIBUTE_dup(sk) ((STACK_OF(X509_ATTRIBUTE) *)OPENSSL_sk_dup(ossl_check_const_X509_ATTRIBUTE_sk_type(sk)))
+#define sk_X509_ATTRIBUTE_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_ATTRIBUTE) *)OPENSSL_sk_deep_copy(ossl_check_const_X509_ATTRIBUTE_sk_type(sk), ossl_check_X509_ATTRIBUTE_copyfunc_type(copyfunc), ossl_check_X509_ATTRIBUTE_freefunc_type(freefunc)))
+#define sk_X509_ATTRIBUTE_set_cmp_func(sk, cmp) ((sk_X509_ATTRIBUTE_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_X509_ATTRIBUTE_sk_type(sk), ossl_check_X509_ATTRIBUTE_compfunc_type(cmp)))
+
+typedef struct X509_req_info_st X509_REQ_INFO;
+typedef struct X509_req_st X509_REQ;
+typedef struct x509_cert_aux_st X509_CERT_AUX;
+typedef struct x509_cinf_st X509_CINF;
+
+/* Flags for X509_print_ex() */
+
+# define X509_FLAG_COMPAT                0
+# define X509_FLAG_NO_HEADER             1L
+# define X509_FLAG_NO_VERSION            (1L << 1)
+# define X509_FLAG_NO_SERIAL             (1L << 2)
+# define X509_FLAG_NO_SIGNAME            (1L << 3)
+# define X509_FLAG_NO_ISSUER             (1L << 4)
+# define X509_FLAG_NO_VALIDITY           (1L << 5)
+# define X509_FLAG_NO_SUBJECT            (1L << 6)
+# define X509_FLAG_NO_PUBKEY             (1L << 7)
+# define X509_FLAG_NO_EXTENSIONS         (1L << 8)
+# define X509_FLAG_NO_SIGDUMP            (1L << 9)
+# define X509_FLAG_NO_AUX                (1L << 10)
+# define X509_FLAG_NO_ATTRIBUTES         (1L << 11)
+# define X509_FLAG_NO_IDS                (1L << 12)
+# define X509_FLAG_EXTENSIONS_ONLY_KID   (1L << 13)
+
+/* Flags specific to X509_NAME_print_ex() */
+
+/* The field separator information */
+
+# define XN_FLAG_SEP_MASK        (0xf << 16)
+
+# define XN_FLAG_COMPAT          0/* Traditional; use old X509_NAME_print */
+# define XN_FLAG_SEP_COMMA_PLUS  (1 << 16)/* RFC2253 ,+ */
+# define XN_FLAG_SEP_CPLUS_SPC   (2 << 16)/* ,+ spaced: more readable */
+# define XN_FLAG_SEP_SPLUS_SPC   (3 << 16)/* ;+ spaced */
+# define XN_FLAG_SEP_MULTILINE   (4 << 16)/* One line per field */
+
+# define XN_FLAG_DN_REV          (1 << 20)/* Reverse DN order */
+
+/* How the field name is shown */
+
+# define XN_FLAG_FN_MASK         (0x3 << 21)
+
+# define XN_FLAG_FN_SN           0/* Object short name */
+# define XN_FLAG_FN_LN           (1 << 21)/* Object long name */
+# define XN_FLAG_FN_OID          (2 << 21)/* Always use OIDs */
+# define XN_FLAG_FN_NONE         (3 << 21)/* No field names */
+
+# define XN_FLAG_SPC_EQ          (1 << 23)/* Put spaces round '=' */
+
+/*
+ * This determines if we dump fields we don't recognise: RFC2253 requires
+ * this.
+ */
+
+# define XN_FLAG_DUMP_UNKNOWN_FIELDS (1 << 24)
+
+# define XN_FLAG_FN_ALIGN        (1 << 25)/* Align field names to 20
+                                           * characters */
+
+/* Complete set of RFC2253 flags */
+
+# define XN_FLAG_RFC2253 (ASN1_STRFLGS_RFC2253 | \
+                        XN_FLAG_SEP_COMMA_PLUS | \
+                        XN_FLAG_DN_REV | \
+                        XN_FLAG_FN_SN | \
+                        XN_FLAG_DUMP_UNKNOWN_FIELDS)
+
+/* readable oneline form */
+
+# define XN_FLAG_ONELINE (ASN1_STRFLGS_RFC2253 | \
+                        ASN1_STRFLGS_ESC_QUOTE | \
+                        XN_FLAG_SEP_CPLUS_SPC | \
+                        XN_FLAG_SPC_EQ | \
+                        XN_FLAG_FN_SN)
+
+/* readable multiline form */
+
+# define XN_FLAG_MULTILINE (ASN1_STRFLGS_ESC_CTRL | \
+                        ASN1_STRFLGS_ESC_MSB | \
+                        XN_FLAG_SEP_MULTILINE | \
+                        XN_FLAG_SPC_EQ | \
+                        XN_FLAG_FN_LN | \
+                        XN_FLAG_FN_ALIGN)
+
+typedef struct X509_crl_info_st X509_CRL_INFO;
+
+typedef struct private_key_st {
+    int version;
+    /* The PKCS#8 data types */
+    X509_ALGOR *enc_algor;
+    ASN1_OCTET_STRING *enc_pkey; /* encrypted pub key */
+    /* When decrypted, the following will not be NULL */
+    EVP_PKEY *dec_pkey;
+    /* used to encrypt and decrypt */
+    int key_length;
+    char *key_data;
+    int key_free;               /* true if we should auto free key_data */
+    /* expanded version of 'enc_algor' */
+    EVP_CIPHER_INFO cipher;
+} X509_PKEY;
+
+typedef struct X509_info_st {
+    X509 *x509;
+    X509_CRL *crl;
+    X509_PKEY *x_pkey;
+    EVP_CIPHER_INFO enc_cipher;
+    int enc_len;
+    char *enc_data;
+} X509_INFO;
+SKM_DEFINE_STACK_OF_INTERNAL(X509_INFO, X509_INFO, X509_INFO)
+#define sk_X509_INFO_num(sk) OPENSSL_sk_num(ossl_check_const_X509_INFO_sk_type(sk))
+#define sk_X509_INFO_value(sk, idx) ((X509_INFO *)OPENSSL_sk_value(ossl_check_const_X509_INFO_sk_type(sk), (idx)))
+#define sk_X509_INFO_new(cmp) ((STACK_OF(X509_INFO) *)OPENSSL_sk_new(ossl_check_X509_INFO_compfunc_type(cmp)))
+#define sk_X509_INFO_new_null() ((STACK_OF(X509_INFO) *)OPENSSL_sk_new_null())
+#define sk_X509_INFO_new_reserve(cmp, n) ((STACK_OF(X509_INFO) *)OPENSSL_sk_new_reserve(ossl_check_X509_INFO_compfunc_type(cmp), (n)))
+#define sk_X509_INFO_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_X509_INFO_sk_type(sk), (n))
+#define sk_X509_INFO_free(sk) OPENSSL_sk_free(ossl_check_X509_INFO_sk_type(sk))
+#define sk_X509_INFO_zero(sk) OPENSSL_sk_zero(ossl_check_X509_INFO_sk_type(sk))
+#define sk_X509_INFO_delete(sk, i) ((X509_INFO *)OPENSSL_sk_delete(ossl_check_X509_INFO_sk_type(sk), (i)))
+#define sk_X509_INFO_delete_ptr(sk, ptr) ((X509_INFO *)OPENSSL_sk_delete_ptr(ossl_check_X509_INFO_sk_type(sk), ossl_check_X509_INFO_type(ptr)))
+#define sk_X509_INFO_push(sk, ptr) OPENSSL_sk_push(ossl_check_X509_INFO_sk_type(sk), ossl_check_X509_INFO_type(ptr))
+#define sk_X509_INFO_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_X509_INFO_sk_type(sk), ossl_check_X509_INFO_type(ptr))
+#define sk_X509_INFO_pop(sk) ((X509_INFO *)OPENSSL_sk_pop(ossl_check_X509_INFO_sk_type(sk)))
+#define sk_X509_INFO_shift(sk) ((X509_INFO *)OPENSSL_sk_shift(ossl_check_X509_INFO_sk_type(sk)))
+#define sk_X509_INFO_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_INFO_sk_type(sk),ossl_check_X509_INFO_freefunc_type(freefunc))
+#define sk_X509_INFO_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_X509_INFO_sk_type(sk), ossl_check_X509_INFO_type(ptr), (idx))
+#define sk_X509_INFO_set(sk, idx, ptr) ((X509_INFO *)OPENSSL_sk_set(ossl_check_X509_INFO_sk_type(sk), (idx), ossl_check_X509_INFO_type(ptr)))
+#define sk_X509_INFO_find(sk, ptr) OPENSSL_sk_find(ossl_check_X509_INFO_sk_type(sk), ossl_check_X509_INFO_type(ptr))
+#define sk_X509_INFO_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_X509_INFO_sk_type(sk), ossl_check_X509_INFO_type(ptr))
+#define sk_X509_INFO_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_X509_INFO_sk_type(sk), ossl_check_X509_INFO_type(ptr), pnum)
+#define sk_X509_INFO_sort(sk) OPENSSL_sk_sort(ossl_check_X509_INFO_sk_type(sk))
+#define sk_X509_INFO_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_X509_INFO_sk_type(sk))
+#define sk_X509_INFO_dup(sk) ((STACK_OF(X509_INFO) *)OPENSSL_sk_dup(ossl_check_const_X509_INFO_sk_type(sk)))
+#define sk_X509_INFO_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_INFO) *)OPENSSL_sk_deep_copy(ossl_check_const_X509_INFO_sk_type(sk), ossl_check_X509_INFO_copyfunc_type(copyfunc), ossl_check_X509_INFO_freefunc_type(freefunc)))
+#define sk_X509_INFO_set_cmp_func(sk, cmp) ((sk_X509_INFO_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_X509_INFO_sk_type(sk), ossl_check_X509_INFO_compfunc_type(cmp)))
+
+
+/*
+ * The next 2 structures and their 8 routines are used to manipulate Netscape's
+ * spki structures - useful if you are writing a CA web page
+ */
+typedef struct Netscape_spkac_st {
+    X509_PUBKEY *pubkey;
+    ASN1_IA5STRING *challenge;  /* challenge sent in atlas >= PR2 */
+} NETSCAPE_SPKAC;
+
+typedef struct Netscape_spki_st {
+    NETSCAPE_SPKAC *spkac;      /* signed public key and challenge */
+    X509_ALGOR sig_algor;
+    ASN1_BIT_STRING *signature;
+} NETSCAPE_SPKI;
+
+/* Netscape certificate sequence structure */
+typedef struct Netscape_certificate_sequence {
+    ASN1_OBJECT *type;
+    STACK_OF(X509) *certs;
+} NETSCAPE_CERT_SEQUENCE;
+
+/*- Unused (and iv length is wrong)
+typedef struct CBCParameter_st
+        {
+        unsigned char iv[8];
+        } CBC_PARAM;
+*/
+
+/* Password based encryption structure */
+
+typedef struct PBEPARAM_st {
+    ASN1_OCTET_STRING *salt;
+    ASN1_INTEGER *iter;
+} PBEPARAM;
+
+/* Password based encryption V2 structures */
+
+typedef struct PBE2PARAM_st {
+    X509_ALGOR *keyfunc;
+    X509_ALGOR *encryption;
+} PBE2PARAM;
+
+typedef struct PBKDF2PARAM_st {
+/* Usually OCTET STRING but could be anything */
+    ASN1_TYPE *salt;
+    ASN1_INTEGER *iter;
+    ASN1_INTEGER *keylength;
+    X509_ALGOR *prf;
+} PBKDF2PARAM;
+
+#ifndef OPENSSL_NO_SCRYPT
+typedef struct SCRYPT_PARAMS_st {
+    ASN1_OCTET_STRING *salt;
+    ASN1_INTEGER *costParameter;
+    ASN1_INTEGER *blockSize;
+    ASN1_INTEGER *parallelizationParameter;
+    ASN1_INTEGER *keyLength;
+} SCRYPT_PARAMS;
+#endif
+
+#ifdef  __cplusplus
+}
+#endif
+
+# include <openssl/x509_vfy.h>
+# include <openssl/pkcs7.h>
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+# define X509_EXT_PACK_UNKNOWN   1
+# define X509_EXT_PACK_STRING    2
+
+# define         X509_extract_key(x)     X509_get_pubkey(x)/*****/
+# define         X509_REQ_extract_key(a) X509_REQ_get_pubkey(a)
+# define         X509_name_cmp(a,b)      X509_NAME_cmp((a),(b))
+
+void X509_CRL_set_default_method(const X509_CRL_METHOD *meth);
+X509_CRL_METHOD *X509_CRL_METHOD_new(int (*crl_init) (X509_CRL *crl),
+                                     int (*crl_free) (X509_CRL *crl),
+                                     int (*crl_lookup) (X509_CRL *crl,
+                                                        X509_REVOKED **ret,
+                                                        const
+                                                        ASN1_INTEGER *serial,
+                                                        const
+                                                        X509_NAME *issuer),
+                                     int (*crl_verify) (X509_CRL *crl,
+                                                        EVP_PKEY *pk));
+void X509_CRL_METHOD_free(X509_CRL_METHOD *m);
+
+void X509_CRL_set_meth_data(X509_CRL *crl, void *dat);
+void *X509_CRL_get_meth_data(X509_CRL *crl);
+
+const char *X509_verify_cert_error_string(long n);
+
+int X509_verify(X509 *a, EVP_PKEY *r);
+int X509_self_signed(X509 *cert, int verify_signature);
+
+int X509_REQ_verify_ex(X509_REQ *a, EVP_PKEY *r, OSSL_LIB_CTX *libctx,
+                       const char *propq);
+int X509_REQ_verify(X509_REQ *a, EVP_PKEY *r);
+int X509_CRL_verify(X509_CRL *a, EVP_PKEY *r);
+int NETSCAPE_SPKI_verify(NETSCAPE_SPKI *a, EVP_PKEY *r);
+
+NETSCAPE_SPKI *NETSCAPE_SPKI_b64_decode(const char *str, int len);
+char *NETSCAPE_SPKI_b64_encode(NETSCAPE_SPKI *x);
+EVP_PKEY *NETSCAPE_SPKI_get_pubkey(NETSCAPE_SPKI *x);
+int NETSCAPE_SPKI_set_pubkey(NETSCAPE_SPKI *x, EVP_PKEY *pkey);
+
+int NETSCAPE_SPKI_print(BIO *out, NETSCAPE_SPKI *spki);
+
+int X509_signature_dump(BIO *bp, const ASN1_STRING *sig, int indent);
+int X509_signature_print(BIO *bp, const X509_ALGOR *alg,
+                         const ASN1_STRING *sig);
+
+int X509_sign(X509 *x, EVP_PKEY *pkey, const EVP_MD *md);
+int X509_sign_ctx(X509 *x, EVP_MD_CTX *ctx);
+int X509_REQ_sign(X509_REQ *x, EVP_PKEY *pkey, const EVP_MD *md);
+int X509_REQ_sign_ctx(X509_REQ *x, EVP_MD_CTX *ctx);
+int X509_CRL_sign(X509_CRL *x, EVP_PKEY *pkey, const EVP_MD *md);
+int X509_CRL_sign_ctx(X509_CRL *x, EVP_MD_CTX *ctx);
+int NETSCAPE_SPKI_sign(NETSCAPE_SPKI *x, EVP_PKEY *pkey, const EVP_MD *md);
+
+int X509_pubkey_digest(const X509 *data, const EVP_MD *type,
+                       unsigned char *md, unsigned int *len);
+int X509_digest(const X509 *data, const EVP_MD *type,
+                unsigned char *md, unsigned int *len);
+ASN1_OCTET_STRING *X509_digest_sig(const X509 *cert,
+                                   EVP_MD **md_used, int *md_is_fallback);
+int X509_CRL_digest(const X509_CRL *data, const EVP_MD *type,
+                    unsigned char *md, unsigned int *len);
+int X509_REQ_digest(const X509_REQ *data, const EVP_MD *type,
+                    unsigned char *md, unsigned int *len);
+int X509_NAME_digest(const X509_NAME *data, const EVP_MD *type,
+                     unsigned char *md, unsigned int *len);
+
+X509 *X509_load_http(const char *url, BIO *bio, BIO *rbio, int timeout);
+X509_CRL *X509_CRL_load_http(const char *url, BIO *bio, BIO *rbio, int timeout);
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  include <openssl/http.h> /* OSSL_HTTP_REQ_CTX_nbio_d2i */
+#  define X509_http_nbio(rctx, pcert) \
+      OSSL_HTTP_REQ_CTX_nbio_d2i(rctx, pcert, ASN1_ITEM_rptr(X509))
+#  define X509_CRL_http_nbio(rctx, pcrl) \
+      OSSL_HTTP_REQ_CTX_nbio_d2i(rctx, pcrl, ASN1_ITEM_rptr(X509_CRL))
+# endif
+
+# ifndef OPENSSL_NO_STDIO
+X509 *d2i_X509_fp(FILE *fp, X509 **x509);
+int i2d_X509_fp(FILE *fp, const X509 *x509);
+X509_CRL *d2i_X509_CRL_fp(FILE *fp, X509_CRL **crl);
+int i2d_X509_CRL_fp(FILE *fp, const X509_CRL *crl);
+X509_REQ *d2i_X509_REQ_fp(FILE *fp, X509_REQ **req);
+int i2d_X509_REQ_fp(FILE *fp, const X509_REQ *req);
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 RSA *d2i_RSAPrivateKey_fp(FILE *fp, RSA **rsa);
+OSSL_DEPRECATEDIN_3_0 int i2d_RSAPrivateKey_fp(FILE *fp, const RSA *rsa);
+OSSL_DEPRECATEDIN_3_0 RSA *d2i_RSAPublicKey_fp(FILE *fp, RSA **rsa);
+OSSL_DEPRECATEDIN_3_0 int i2d_RSAPublicKey_fp(FILE *fp, const RSA *rsa);
+OSSL_DEPRECATEDIN_3_0 RSA *d2i_RSA_PUBKEY_fp(FILE *fp, RSA **rsa);
+OSSL_DEPRECATEDIN_3_0 int i2d_RSA_PUBKEY_fp(FILE *fp, const RSA *rsa);
+#  endif
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+#   ifndef OPENSSL_NO_DSA
+OSSL_DEPRECATEDIN_3_0 DSA *d2i_DSA_PUBKEY_fp(FILE *fp, DSA **dsa);
+OSSL_DEPRECATEDIN_3_0 int i2d_DSA_PUBKEY_fp(FILE *fp, const DSA *dsa);
+OSSL_DEPRECATEDIN_3_0 DSA *d2i_DSAPrivateKey_fp(FILE *fp, DSA **dsa);
+OSSL_DEPRECATEDIN_3_0 int i2d_DSAPrivateKey_fp(FILE *fp, const DSA *dsa);
+#   endif
+#  endif
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+#   ifndef OPENSSL_NO_EC
+OSSL_DEPRECATEDIN_3_0 EC_KEY *d2i_EC_PUBKEY_fp(FILE *fp, EC_KEY **eckey);
+OSSL_DEPRECATEDIN_3_0 int i2d_EC_PUBKEY_fp(FILE *fp, const EC_KEY *eckey);
+OSSL_DEPRECATEDIN_3_0 EC_KEY *d2i_ECPrivateKey_fp(FILE *fp, EC_KEY **eckey);
+OSSL_DEPRECATEDIN_3_0 int i2d_ECPrivateKey_fp(FILE *fp, const EC_KEY *eckey);
+#   endif /* OPENSSL_NO_EC */
+#  endif /* OPENSSL_NO_DEPRECATED_3_0 */
+X509_SIG *d2i_PKCS8_fp(FILE *fp, X509_SIG **p8);
+int i2d_PKCS8_fp(FILE *fp, const X509_SIG *p8);
+X509_PUBKEY *d2i_X509_PUBKEY_fp(FILE *fp, X509_PUBKEY **xpk);
+int i2d_X509_PUBKEY_fp(FILE *fp, const X509_PUBKEY *xpk);
+PKCS8_PRIV_KEY_INFO *d2i_PKCS8_PRIV_KEY_INFO_fp(FILE *fp,
+                                                PKCS8_PRIV_KEY_INFO **p8inf);
+int i2d_PKCS8_PRIV_KEY_INFO_fp(FILE *fp, const PKCS8_PRIV_KEY_INFO *p8inf);
+int i2d_PKCS8PrivateKeyInfo_fp(FILE *fp, const EVP_PKEY *key);
+int i2d_PrivateKey_fp(FILE *fp, const EVP_PKEY *pkey);
+EVP_PKEY *d2i_PrivateKey_ex_fp(FILE *fp, EVP_PKEY **a, OSSL_LIB_CTX *libctx,
+                               const char *propq);
+EVP_PKEY *d2i_PrivateKey_fp(FILE *fp, EVP_PKEY **a);
+int i2d_PUBKEY_fp(FILE *fp, const EVP_PKEY *pkey);
+EVP_PKEY *d2i_PUBKEY_ex_fp(FILE *fp, EVP_PKEY **a, OSSL_LIB_CTX *libctx,
+                           const char *propq);
+EVP_PKEY *d2i_PUBKEY_fp(FILE *fp, EVP_PKEY **a);
+# endif
+
+X509 *d2i_X509_bio(BIO *bp, X509 **x509);
+int i2d_X509_bio(BIO *bp, const X509 *x509);
+X509_CRL *d2i_X509_CRL_bio(BIO *bp, X509_CRL **crl);
+int i2d_X509_CRL_bio(BIO *bp, const X509_CRL *crl);
+X509_REQ *d2i_X509_REQ_bio(BIO *bp, X509_REQ **req);
+int i2d_X509_REQ_bio(BIO *bp, const X509_REQ *req);
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 RSA *d2i_RSAPrivateKey_bio(BIO *bp, RSA **rsa);
+OSSL_DEPRECATEDIN_3_0 int i2d_RSAPrivateKey_bio(BIO *bp, const RSA *rsa);
+OSSL_DEPRECATEDIN_3_0 RSA *d2i_RSAPublicKey_bio(BIO *bp, RSA **rsa);
+OSSL_DEPRECATEDIN_3_0 int i2d_RSAPublicKey_bio(BIO *bp, const RSA *rsa);
+OSSL_DEPRECATEDIN_3_0 RSA *d2i_RSA_PUBKEY_bio(BIO *bp, RSA **rsa);
+OSSL_DEPRECATEDIN_3_0 int i2d_RSA_PUBKEY_bio(BIO *bp, const RSA *rsa);
+#  endif
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+#   ifndef OPENSSL_NO_DSA
+OSSL_DEPRECATEDIN_3_0 DSA *d2i_DSA_PUBKEY_bio(BIO *bp, DSA **dsa);
+OSSL_DEPRECATEDIN_3_0 int i2d_DSA_PUBKEY_bio(BIO *bp, const DSA *dsa);
+OSSL_DEPRECATEDIN_3_0 DSA *d2i_DSAPrivateKey_bio(BIO *bp, DSA **dsa);
+OSSL_DEPRECATEDIN_3_0 int i2d_DSAPrivateKey_bio(BIO *bp, const DSA *dsa);
+#   endif
+#  endif
+
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+#   ifndef OPENSSL_NO_EC
+OSSL_DEPRECATEDIN_3_0 EC_KEY *d2i_EC_PUBKEY_bio(BIO *bp, EC_KEY **eckey);
+OSSL_DEPRECATEDIN_3_0 int i2d_EC_PUBKEY_bio(BIO *bp, const EC_KEY *eckey);
+OSSL_DEPRECATEDIN_3_0 EC_KEY *d2i_ECPrivateKey_bio(BIO *bp, EC_KEY **eckey);
+OSSL_DEPRECATEDIN_3_0 int i2d_ECPrivateKey_bio(BIO *bp, const EC_KEY *eckey);
+#   endif /* OPENSSL_NO_EC */
+#  endif /* OPENSSL_NO_DEPRECATED_3_0 */
+
+X509_SIG *d2i_PKCS8_bio(BIO *bp, X509_SIG **p8);
+int i2d_PKCS8_bio(BIO *bp, const X509_SIG *p8);
+X509_PUBKEY *d2i_X509_PUBKEY_bio(BIO *bp, X509_PUBKEY **xpk);
+int i2d_X509_PUBKEY_bio(BIO *bp, const X509_PUBKEY *xpk);
+PKCS8_PRIV_KEY_INFO *d2i_PKCS8_PRIV_KEY_INFO_bio(BIO *bp,
+                                                 PKCS8_PRIV_KEY_INFO **p8inf);
+int i2d_PKCS8_PRIV_KEY_INFO_bio(BIO *bp, const PKCS8_PRIV_KEY_INFO *p8inf);
+int i2d_PKCS8PrivateKeyInfo_bio(BIO *bp, const EVP_PKEY *key);
+int i2d_PrivateKey_bio(BIO *bp, const EVP_PKEY *pkey);
+EVP_PKEY *d2i_PrivateKey_ex_bio(BIO *bp, EVP_PKEY **a, OSSL_LIB_CTX *libctx,
+                                const char *propq);
+EVP_PKEY *d2i_PrivateKey_bio(BIO *bp, EVP_PKEY **a);
+int i2d_PUBKEY_bio(BIO *bp, const EVP_PKEY *pkey);
+EVP_PKEY *d2i_PUBKEY_ex_bio(BIO *bp, EVP_PKEY **a, OSSL_LIB_CTX *libctx,
+                            const char *propq);
+EVP_PKEY *d2i_PUBKEY_bio(BIO *bp, EVP_PKEY **a);
+
+DECLARE_ASN1_DUP_FUNCTION(X509)
+DECLARE_ASN1_DUP_FUNCTION(X509_ALGOR)
+DECLARE_ASN1_DUP_FUNCTION(X509_ATTRIBUTE)
+DECLARE_ASN1_DUP_FUNCTION(X509_CRL)
+DECLARE_ASN1_DUP_FUNCTION(X509_EXTENSION)
+DECLARE_ASN1_DUP_FUNCTION(X509_PUBKEY)
+DECLARE_ASN1_DUP_FUNCTION(X509_REQ)
+DECLARE_ASN1_DUP_FUNCTION(X509_REVOKED)
+int X509_ALGOR_set0(X509_ALGOR *alg, ASN1_OBJECT *aobj, int ptype,
+                    void *pval);
+void X509_ALGOR_get0(const ASN1_OBJECT **paobj, int *pptype,
+                     const void **ppval, const X509_ALGOR *algor);
+void X509_ALGOR_set_md(X509_ALGOR *alg, const EVP_MD *md);
+int X509_ALGOR_cmp(const X509_ALGOR *a, const X509_ALGOR *b);
+int X509_ALGOR_copy(X509_ALGOR *dest, const X509_ALGOR *src);
+
+DECLARE_ASN1_DUP_FUNCTION(X509_NAME)
+DECLARE_ASN1_DUP_FUNCTION(X509_NAME_ENTRY)
+
+int X509_cmp_time(const ASN1_TIME *s, time_t *t);
+int X509_cmp_current_time(const ASN1_TIME *s);
+int X509_cmp_timeframe(const X509_VERIFY_PARAM *vpm,
+                       const ASN1_TIME *start, const ASN1_TIME *end);
+ASN1_TIME *X509_time_adj(ASN1_TIME *s, long adj, time_t *t);
+ASN1_TIME *X509_time_adj_ex(ASN1_TIME *s,
+                            int offset_day, long offset_sec, time_t *t);
+ASN1_TIME *X509_gmtime_adj(ASN1_TIME *s, long adj);
+
+const char *X509_get_default_cert_area(void);
+const char *X509_get_default_cert_dir(void);
+const char *X509_get_default_cert_file(void);
+const char *X509_get_default_cert_dir_env(void);
+const char *X509_get_default_cert_file_env(void);
+const char *X509_get_default_private_dir(void);
+
+X509_REQ *X509_to_X509_REQ(X509 *x, EVP_PKEY *pkey, const EVP_MD *md);
+X509 *X509_REQ_to_X509(X509_REQ *r, int days, EVP_PKEY *pkey);
+
+DECLARE_ASN1_FUNCTIONS(X509_ALGOR)
+DECLARE_ASN1_ENCODE_FUNCTIONS(X509_ALGORS, X509_ALGORS, X509_ALGORS)
+DECLARE_ASN1_FUNCTIONS(X509_VAL)
+
+DECLARE_ASN1_FUNCTIONS(X509_PUBKEY)
+
+X509_PUBKEY *X509_PUBKEY_new_ex(OSSL_LIB_CTX *libctx, const char *propq);
+int X509_PUBKEY_set(X509_PUBKEY **x, EVP_PKEY *pkey);
+EVP_PKEY *X509_PUBKEY_get0(const X509_PUBKEY *key);
+EVP_PKEY *X509_PUBKEY_get(const X509_PUBKEY *key);
+int X509_get_pubkey_parameters(EVP_PKEY *pkey, STACK_OF(X509) *chain);
+long X509_get_pathlen(X509 *x);
+DECLARE_ASN1_ENCODE_FUNCTIONS_only(EVP_PKEY, PUBKEY)
+EVP_PKEY *d2i_PUBKEY_ex(EVP_PKEY **a, const unsigned char **pp, long length,
+                        OSSL_LIB_CTX *libctx, const char *propq);
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+DECLARE_ASN1_ENCODE_FUNCTIONS_only_attr(OSSL_DEPRECATEDIN_3_0,RSA, RSA_PUBKEY)
+# endif
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  ifndef OPENSSL_NO_DSA
+DECLARE_ASN1_ENCODE_FUNCTIONS_only_attr(OSSL_DEPRECATEDIN_3_0,DSA, DSA_PUBKEY)
+#  endif
+# endif
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  ifndef OPENSSL_NO_EC
+DECLARE_ASN1_ENCODE_FUNCTIONS_only_attr(OSSL_DEPRECATEDIN_3_0, EC_KEY, EC_PUBKEY)
+#  endif
+# endif
+
+DECLARE_ASN1_FUNCTIONS(X509_SIG)
+void X509_SIG_get0(const X509_SIG *sig, const X509_ALGOR **palg,
+                   const ASN1_OCTET_STRING **pdigest);
+void X509_SIG_getm(X509_SIG *sig, X509_ALGOR **palg,
+                   ASN1_OCTET_STRING **pdigest);
+
+DECLARE_ASN1_FUNCTIONS(X509_REQ_INFO)
+DECLARE_ASN1_FUNCTIONS(X509_REQ)
+X509_REQ *X509_REQ_new_ex(OSSL_LIB_CTX *libctx, const char *propq);
+
+DECLARE_ASN1_FUNCTIONS(X509_ATTRIBUTE)
+X509_ATTRIBUTE *X509_ATTRIBUTE_create(int nid, int atrtype, void *value);
+
+DECLARE_ASN1_FUNCTIONS(X509_EXTENSION)
+DECLARE_ASN1_ENCODE_FUNCTIONS(X509_EXTENSIONS, X509_EXTENSIONS, X509_EXTENSIONS)
+
+DECLARE_ASN1_FUNCTIONS(X509_NAME_ENTRY)
+
+DECLARE_ASN1_FUNCTIONS(X509_NAME)
+
+int X509_NAME_set(X509_NAME **xn, const X509_NAME *name);
+
+DECLARE_ASN1_FUNCTIONS(X509_CINF)
+DECLARE_ASN1_FUNCTIONS(X509)
+X509 *X509_new_ex(OSSL_LIB_CTX *libctx, const char *propq);
+DECLARE_ASN1_FUNCTIONS(X509_CERT_AUX)
+
+#define X509_get_ex_new_index(l, p, newf, dupf, freef) \
+    CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_X509, l, p, newf, dupf, freef)
+int X509_set_ex_data(X509 *r, int idx, void *arg);
+void *X509_get_ex_data(const X509 *r, int idx);
+DECLARE_ASN1_ENCODE_FUNCTIONS_only(X509,X509_AUX)
+
+int i2d_re_X509_tbs(X509 *x, unsigned char **pp);
+
+int X509_SIG_INFO_get(const X509_SIG_INFO *siginf, int *mdnid, int *pknid,
+                      int *secbits, uint32_t *flags);
+void X509_SIG_INFO_set(X509_SIG_INFO *siginf, int mdnid, int pknid,
+                       int secbits, uint32_t flags);
+
+int X509_get_signature_info(X509 *x, int *mdnid, int *pknid, int *secbits,
+                            uint32_t *flags);
+
+void X509_get0_signature(const ASN1_BIT_STRING **psig,
+                         const X509_ALGOR **palg, const X509 *x);
+int X509_get_signature_nid(const X509 *x);
+
+void X509_set0_distinguishing_id(X509 *x, ASN1_OCTET_STRING *d_id);
+ASN1_OCTET_STRING *X509_get0_distinguishing_id(X509 *x);
+void X509_REQ_set0_distinguishing_id(X509_REQ *x, ASN1_OCTET_STRING *d_id);
+ASN1_OCTET_STRING *X509_REQ_get0_distinguishing_id(X509_REQ *x);
+
+int X509_alias_set1(X509 *x, const unsigned char *name, int len);
+int X509_keyid_set1(X509 *x, const unsigned char *id, int len);
+unsigned char *X509_alias_get0(X509 *x, int *len);
+unsigned char *X509_keyid_get0(X509 *x, int *len);
+
+DECLARE_ASN1_FUNCTIONS(X509_REVOKED)
+DECLARE_ASN1_FUNCTIONS(X509_CRL_INFO)
+DECLARE_ASN1_FUNCTIONS(X509_CRL)
+X509_CRL *X509_CRL_new_ex(OSSL_LIB_CTX *libctx, const char *propq);
+
+int X509_CRL_add0_revoked(X509_CRL *crl, X509_REVOKED *rev);
+int X509_CRL_get0_by_serial(X509_CRL *crl,
+                            X509_REVOKED **ret, const ASN1_INTEGER *serial);
+int X509_CRL_get0_by_cert(X509_CRL *crl, X509_REVOKED **ret, X509 *x);
+
+X509_PKEY *X509_PKEY_new(void);
+void X509_PKEY_free(X509_PKEY *a);
+
+DECLARE_ASN1_FUNCTIONS(NETSCAPE_SPKI)
+DECLARE_ASN1_FUNCTIONS(NETSCAPE_SPKAC)
+DECLARE_ASN1_FUNCTIONS(NETSCAPE_CERT_SEQUENCE)
+
+X509_INFO *X509_INFO_new(void);
+void X509_INFO_free(X509_INFO *a);
+char *X509_NAME_oneline(const X509_NAME *a, char *buf, int size);
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+int ASN1_verify(i2d_of_void *i2d, X509_ALGOR *algor1,
+                ASN1_BIT_STRING *signature, char *data, EVP_PKEY *pkey);
+OSSL_DEPRECATEDIN_3_0
+int ASN1_digest(i2d_of_void *i2d, const EVP_MD *type, char *data,
+                unsigned char *md, unsigned int *len);
+OSSL_DEPRECATEDIN_3_0
+int ASN1_sign(i2d_of_void *i2d, X509_ALGOR *algor1, X509_ALGOR *algor2,
+              ASN1_BIT_STRING *signature, char *data, EVP_PKEY *pkey,
+              const EVP_MD *type);
+#endif
+int ASN1_item_digest(const ASN1_ITEM *it, const EVP_MD *type, void *data,
+                     unsigned char *md, unsigned int *len);
+int ASN1_item_verify(const ASN1_ITEM *it, const X509_ALGOR *alg,
+                     const ASN1_BIT_STRING *signature, const void *data,
+                     EVP_PKEY *pkey);
+int ASN1_item_verify_ctx(const ASN1_ITEM *it, const X509_ALGOR *alg,
+                         const ASN1_BIT_STRING *signature, const void *data,
+                         EVP_MD_CTX *ctx);
+int ASN1_item_sign(const ASN1_ITEM *it, X509_ALGOR *algor1, X509_ALGOR *algor2,
+                   ASN1_BIT_STRING *signature, const void *data,
+                   EVP_PKEY *pkey, const EVP_MD *md);
+int ASN1_item_sign_ctx(const ASN1_ITEM *it, X509_ALGOR *algor1,
+                       X509_ALGOR *algor2, ASN1_BIT_STRING *signature,
+                       const void *data, EVP_MD_CTX *ctx);
+
+#define X509_VERSION_1 0
+#define X509_VERSION_2 1
+#define X509_VERSION_3 2
+
+long X509_get_version(const X509 *x);
+int X509_set_version(X509 *x, long version);
+int X509_set_serialNumber(X509 *x, ASN1_INTEGER *serial);
+ASN1_INTEGER *X509_get_serialNumber(X509 *x);
+const ASN1_INTEGER *X509_get0_serialNumber(const X509 *x);
+int X509_set_issuer_name(X509 *x, const X509_NAME *name);
+X509_NAME *X509_get_issuer_name(const X509 *a);
+int X509_set_subject_name(X509 *x, const X509_NAME *name);
+X509_NAME *X509_get_subject_name(const X509 *a);
+const ASN1_TIME * X509_get0_notBefore(const X509 *x);
+ASN1_TIME *X509_getm_notBefore(const X509 *x);
+int X509_set1_notBefore(X509 *x, const ASN1_TIME *tm);
+const ASN1_TIME *X509_get0_notAfter(const X509 *x);
+ASN1_TIME *X509_getm_notAfter(const X509 *x);
+int X509_set1_notAfter(X509 *x, const ASN1_TIME *tm);
+int X509_set_pubkey(X509 *x, EVP_PKEY *pkey);
+int X509_up_ref(X509 *x);
+int X509_get_signature_type(const X509 *x);
+
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#  define X509_get_notBefore X509_getm_notBefore
+#  define X509_get_notAfter X509_getm_notAfter
+#  define X509_set_notBefore X509_set1_notBefore
+#  define X509_set_notAfter X509_set1_notAfter
+#endif
+
+
+/*
+ * This one is only used so that a binary form can output, as in
+ * i2d_X509_PUBKEY(X509_get_X509_PUBKEY(x), &buf)
+ */
+X509_PUBKEY *X509_get_X509_PUBKEY(const X509 *x);
+const STACK_OF(X509_EXTENSION) *X509_get0_extensions(const X509 *x);
+void X509_get0_uids(const X509 *x, const ASN1_BIT_STRING **piuid,
+                    const ASN1_BIT_STRING **psuid);
+const X509_ALGOR *X509_get0_tbs_sigalg(const X509 *x);
+
+EVP_PKEY *X509_get0_pubkey(const X509 *x);
+EVP_PKEY *X509_get_pubkey(X509 *x);
+ASN1_BIT_STRING *X509_get0_pubkey_bitstr(const X509 *x);
+
+#define X509_REQ_VERSION_1 0
+
+long X509_REQ_get_version(const X509_REQ *req);
+int X509_REQ_set_version(X509_REQ *x, long version);
+X509_NAME *X509_REQ_get_subject_name(const X509_REQ *req);
+int X509_REQ_set_subject_name(X509_REQ *req, const X509_NAME *name);
+void X509_REQ_get0_signature(const X509_REQ *req, const ASN1_BIT_STRING **psig,
+                             const X509_ALGOR **palg);
+void X509_REQ_set0_signature(X509_REQ *req, ASN1_BIT_STRING *psig);
+int X509_REQ_set1_signature_algo(X509_REQ *req, X509_ALGOR *palg);
+int X509_REQ_get_signature_nid(const X509_REQ *req);
+int i2d_re_X509_REQ_tbs(X509_REQ *req, unsigned char **pp);
+int X509_REQ_set_pubkey(X509_REQ *x, EVP_PKEY *pkey);
+EVP_PKEY *X509_REQ_get_pubkey(X509_REQ *req);
+EVP_PKEY *X509_REQ_get0_pubkey(const X509_REQ *req);
+X509_PUBKEY *X509_REQ_get_X509_PUBKEY(X509_REQ *req);
+int X509_REQ_extension_nid(int nid);
+int *X509_REQ_get_extension_nids(void);
+void X509_REQ_set_extension_nids(int *nids);
+STACK_OF(X509_EXTENSION) *X509_REQ_get_extensions(X509_REQ *req);
+int X509_REQ_add_extensions_nid(X509_REQ *req,
+                                const STACK_OF(X509_EXTENSION) *exts, int nid);
+int X509_REQ_add_extensions(X509_REQ *req, const STACK_OF(X509_EXTENSION) *ext);
+int X509_REQ_get_attr_count(const X509_REQ *req);
+int X509_REQ_get_attr_by_NID(const X509_REQ *req, int nid, int lastpos);
+int X509_REQ_get_attr_by_OBJ(const X509_REQ *req, const ASN1_OBJECT *obj,
+                             int lastpos);
+X509_ATTRIBUTE *X509_REQ_get_attr(const X509_REQ *req, int loc);
+X509_ATTRIBUTE *X509_REQ_delete_attr(X509_REQ *req, int loc);
+int X509_REQ_add1_attr(X509_REQ *req, X509_ATTRIBUTE *attr);
+int X509_REQ_add1_attr_by_OBJ(X509_REQ *req,
+                              const ASN1_OBJECT *obj, int type,
+                              const unsigned char *bytes, int len);
+int X509_REQ_add1_attr_by_NID(X509_REQ *req,
+                              int nid, int type,
+                              const unsigned char *bytes, int len);
+int X509_REQ_add1_attr_by_txt(X509_REQ *req,
+                              const char *attrname, int type,
+                              const unsigned char *bytes, int len);
+
+#define X509_CRL_VERSION_1 0
+#define X509_CRL_VERSION_2 1
+
+int X509_CRL_set_version(X509_CRL *x, long version);
+int X509_CRL_set_issuer_name(X509_CRL *x, const X509_NAME *name);
+int X509_CRL_set1_lastUpdate(X509_CRL *x, const ASN1_TIME *tm);
+int X509_CRL_set1_nextUpdate(X509_CRL *x, const ASN1_TIME *tm);
+int X509_CRL_sort(X509_CRL *crl);
+int X509_CRL_up_ref(X509_CRL *crl);
+
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#  define X509_CRL_set_lastUpdate X509_CRL_set1_lastUpdate
+#  define X509_CRL_set_nextUpdate X509_CRL_set1_nextUpdate
+#endif
+
+long X509_CRL_get_version(const X509_CRL *crl);
+const ASN1_TIME *X509_CRL_get0_lastUpdate(const X509_CRL *crl);
+const ASN1_TIME *X509_CRL_get0_nextUpdate(const X509_CRL *crl);
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+OSSL_DEPRECATEDIN_1_1_0 ASN1_TIME *X509_CRL_get_lastUpdate(X509_CRL *crl);
+OSSL_DEPRECATEDIN_1_1_0 ASN1_TIME *X509_CRL_get_nextUpdate(X509_CRL *crl);
+#endif
+X509_NAME *X509_CRL_get_issuer(const X509_CRL *crl);
+const STACK_OF(X509_EXTENSION) *X509_CRL_get0_extensions(const X509_CRL *crl);
+STACK_OF(X509_REVOKED) *X509_CRL_get_REVOKED(X509_CRL *crl);
+void X509_CRL_get0_signature(const X509_CRL *crl, const ASN1_BIT_STRING **psig,
+                             const X509_ALGOR **palg);
+int X509_CRL_get_signature_nid(const X509_CRL *crl);
+int i2d_re_X509_CRL_tbs(X509_CRL *req, unsigned char **pp);
+
+const ASN1_INTEGER *X509_REVOKED_get0_serialNumber(const X509_REVOKED *x);
+int X509_REVOKED_set_serialNumber(X509_REVOKED *x, ASN1_INTEGER *serial);
+const ASN1_TIME *X509_REVOKED_get0_revocationDate(const X509_REVOKED *x);
+int X509_REVOKED_set_revocationDate(X509_REVOKED *r, ASN1_TIME *tm);
+const STACK_OF(X509_EXTENSION) *
+X509_REVOKED_get0_extensions(const X509_REVOKED *r);
+
+X509_CRL *X509_CRL_diff(X509_CRL *base, X509_CRL *newer,
+                        EVP_PKEY *skey, const EVP_MD *md, unsigned int flags);
+
+int X509_REQ_check_private_key(const X509_REQ *req, EVP_PKEY *pkey);
+
+int X509_check_private_key(const X509 *cert, const EVP_PKEY *pkey);
+int X509_chain_check_suiteb(int *perror_depth,
+                            X509 *x, STACK_OF(X509) *chain,
+                            unsigned long flags);
+int X509_CRL_check_suiteb(X509_CRL *crl, EVP_PKEY *pk, unsigned long flags);
+void OSSL_STACK_OF_X509_free(STACK_OF(X509) *certs);
+STACK_OF(X509) *X509_chain_up_ref(STACK_OF(X509) *chain);
+
+int X509_issuer_and_serial_cmp(const X509 *a, const X509 *b);
+unsigned long X509_issuer_and_serial_hash(X509 *a);
+
+int X509_issuer_name_cmp(const X509 *a, const X509 *b);
+unsigned long X509_issuer_name_hash(X509 *a);
+
+int X509_subject_name_cmp(const X509 *a, const X509 *b);
+unsigned long X509_subject_name_hash(X509 *x);
+
+# ifndef OPENSSL_NO_MD5
+unsigned long X509_issuer_name_hash_old(X509 *a);
+unsigned long X509_subject_name_hash_old(X509 *x);
+# endif
+
+# define X509_ADD_FLAG_DEFAULT  0
+# define X509_ADD_FLAG_UP_REF   0x1
+# define X509_ADD_FLAG_PREPEND  0x2
+# define X509_ADD_FLAG_NO_DUP   0x4
+# define X509_ADD_FLAG_NO_SS    0x8
+int X509_add_cert(STACK_OF(X509) *sk, X509 *cert, int flags);
+int X509_add_certs(STACK_OF(X509) *sk, STACK_OF(X509) *certs, int flags);
+
+int X509_cmp(const X509 *a, const X509 *b);
+int X509_NAME_cmp(const X509_NAME *a, const X509_NAME *b);
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+# define X509_NAME_hash(x) X509_NAME_hash_ex(x, NULL, NULL, NULL)
+OSSL_DEPRECATEDIN_3_0 int X509_certificate_type(const X509 *x,
+                                                const EVP_PKEY *pubkey);
+#endif
+unsigned long X509_NAME_hash_ex(const X509_NAME *x, OSSL_LIB_CTX *libctx,
+                                const char *propq, int *ok);
+unsigned long X509_NAME_hash_old(const X509_NAME *x);
+
+int X509_CRL_cmp(const X509_CRL *a, const X509_CRL *b);
+int X509_CRL_match(const X509_CRL *a, const X509_CRL *b);
+int X509_aux_print(BIO *out, X509 *x, int indent);
+# ifndef OPENSSL_NO_STDIO
+int X509_print_ex_fp(FILE *bp, X509 *x, unsigned long nmflag,
+                     unsigned long cflag);
+int X509_print_fp(FILE *bp, X509 *x);
+int X509_CRL_print_fp(FILE *bp, X509_CRL *x);
+int X509_REQ_print_fp(FILE *bp, X509_REQ *req);
+int X509_NAME_print_ex_fp(FILE *fp, const X509_NAME *nm, int indent,
+                          unsigned long flags);
+# endif
+
+int X509_NAME_print(BIO *bp, const X509_NAME *name, int obase);
+int X509_NAME_print_ex(BIO *out, const X509_NAME *nm, int indent,
+                       unsigned long flags);
+int X509_print_ex(BIO *bp, X509 *x, unsigned long nmflag,
+                  unsigned long cflag);
+int X509_print(BIO *bp, X509 *x);
+int X509_ocspid_print(BIO *bp, X509 *x);
+int X509_CRL_print_ex(BIO *out, X509_CRL *x, unsigned long nmflag);
+int X509_CRL_print(BIO *bp, X509_CRL *x);
+int X509_REQ_print_ex(BIO *bp, X509_REQ *x, unsigned long nmflag,
+                      unsigned long cflag);
+int X509_REQ_print(BIO *bp, X509_REQ *req);
+
+int X509_NAME_entry_count(const X509_NAME *name);
+int X509_NAME_get_text_by_NID(const X509_NAME *name, int nid,
+                              char *buf, int len);
+int X509_NAME_get_text_by_OBJ(const X509_NAME *name, const ASN1_OBJECT *obj,
+                              char *buf, int len);
+
+/*
+ * NOTE: you should be passing -1, not 0 as lastpos. The functions that use
+ * lastpos, search after that position on.
+ */
+int X509_NAME_get_index_by_NID(const X509_NAME *name, int nid, int lastpos);
+int X509_NAME_get_index_by_OBJ(const X509_NAME *name, const ASN1_OBJECT *obj,
+                               int lastpos);
+X509_NAME_ENTRY *X509_NAME_get_entry(const X509_NAME *name, int loc);
+X509_NAME_ENTRY *X509_NAME_delete_entry(X509_NAME *name, int loc);
+int X509_NAME_add_entry(X509_NAME *name, const X509_NAME_ENTRY *ne,
+                        int loc, int set);
+int X509_NAME_add_entry_by_OBJ(X509_NAME *name, const ASN1_OBJECT *obj, int type,
+                               const unsigned char *bytes, int len, int loc,
+                               int set);
+int X509_NAME_add_entry_by_NID(X509_NAME *name, int nid, int type,
+                               const unsigned char *bytes, int len, int loc,
+                               int set);
+X509_NAME_ENTRY *X509_NAME_ENTRY_create_by_txt(X509_NAME_ENTRY **ne,
+                                               const char *field, int type,
+                                               const unsigned char *bytes,
+                                               int len);
+X509_NAME_ENTRY *X509_NAME_ENTRY_create_by_NID(X509_NAME_ENTRY **ne, int nid,
+                                               int type,
+                                               const unsigned char *bytes,
+                                               int len);
+int X509_NAME_add_entry_by_txt(X509_NAME *name, const char *field, int type,
+                               const unsigned char *bytes, int len, int loc,
+                               int set);
+X509_NAME_ENTRY *X509_NAME_ENTRY_create_by_OBJ(X509_NAME_ENTRY **ne,
+                                               const ASN1_OBJECT *obj, int type,
+                                               const unsigned char *bytes,
+                                               int len);
+int X509_NAME_ENTRY_set_object(X509_NAME_ENTRY *ne, const ASN1_OBJECT *obj);
+int X509_NAME_ENTRY_set_data(X509_NAME_ENTRY *ne, int type,
+                             const unsigned char *bytes, int len);
+ASN1_OBJECT *X509_NAME_ENTRY_get_object(const X509_NAME_ENTRY *ne);
+ASN1_STRING * X509_NAME_ENTRY_get_data(const X509_NAME_ENTRY *ne);
+int X509_NAME_ENTRY_set(const X509_NAME_ENTRY *ne);
+
+int X509_NAME_get0_der(const X509_NAME *nm, const unsigned char **pder,
+                       size_t *pderlen);
+
+int X509v3_get_ext_count(const STACK_OF(X509_EXTENSION) *x);
+int X509v3_get_ext_by_NID(const STACK_OF(X509_EXTENSION) *x,
+                          int nid, int lastpos);
+int X509v3_get_ext_by_OBJ(const STACK_OF(X509_EXTENSION) *x,
+                          const ASN1_OBJECT *obj, int lastpos);
+int X509v3_get_ext_by_critical(const STACK_OF(X509_EXTENSION) *x,
+                               int crit, int lastpos);
+X509_EXTENSION *X509v3_get_ext(const STACK_OF(X509_EXTENSION) *x, int loc);
+X509_EXTENSION *X509v3_delete_ext(STACK_OF(X509_EXTENSION) *x, int loc);
+STACK_OF(X509_EXTENSION) *X509v3_add_ext(STACK_OF(X509_EXTENSION) **x,
+                                         X509_EXTENSION *ex, int loc);
+
+int X509_get_ext_count(const X509 *x);
+int X509_get_ext_by_NID(const X509 *x, int nid, int lastpos);
+int X509_get_ext_by_OBJ(const X509 *x, const ASN1_OBJECT *obj, int lastpos);
+int X509_get_ext_by_critical(const X509 *x, int crit, int lastpos);
+X509_EXTENSION *X509_get_ext(const X509 *x, int loc);
+X509_EXTENSION *X509_delete_ext(X509 *x, int loc);
+int X509_add_ext(X509 *x, X509_EXTENSION *ex, int loc);
+void *X509_get_ext_d2i(const X509 *x, int nid, int *crit, int *idx);
+int X509_add1_ext_i2d(X509 *x, int nid, void *value, int crit,
+                      unsigned long flags);
+
+int X509_CRL_get_ext_count(const X509_CRL *x);
+int X509_CRL_get_ext_by_NID(const X509_CRL *x, int nid, int lastpos);
+int X509_CRL_get_ext_by_OBJ(const X509_CRL *x, const ASN1_OBJECT *obj,
+                            int lastpos);
+int X509_CRL_get_ext_by_critical(const X509_CRL *x, int crit, int lastpos);
+X509_EXTENSION *X509_CRL_get_ext(const X509_CRL *x, int loc);
+X509_EXTENSION *X509_CRL_delete_ext(X509_CRL *x, int loc);
+int X509_CRL_add_ext(X509_CRL *x, X509_EXTENSION *ex, int loc);
+void *X509_CRL_get_ext_d2i(const X509_CRL *x, int nid, int *crit, int *idx);
+int X509_CRL_add1_ext_i2d(X509_CRL *x, int nid, void *value, int crit,
+                          unsigned long flags);
+
+int X509_REVOKED_get_ext_count(const X509_REVOKED *x);
+int X509_REVOKED_get_ext_by_NID(const X509_REVOKED *x, int nid, int lastpos);
+int X509_REVOKED_get_ext_by_OBJ(const X509_REVOKED *x, const ASN1_OBJECT *obj,
+                                int lastpos);
+int X509_REVOKED_get_ext_by_critical(const X509_REVOKED *x, int crit,
+                                     int lastpos);
+X509_EXTENSION *X509_REVOKED_get_ext(const X509_REVOKED *x, int loc);
+X509_EXTENSION *X509_REVOKED_delete_ext(X509_REVOKED *x, int loc);
+int X509_REVOKED_add_ext(X509_REVOKED *x, X509_EXTENSION *ex, int loc);
+void *X509_REVOKED_get_ext_d2i(const X509_REVOKED *x, int nid, int *crit,
+                               int *idx);
+int X509_REVOKED_add1_ext_i2d(X509_REVOKED *x, int nid, void *value, int crit,
+                              unsigned long flags);
+
+X509_EXTENSION *X509_EXTENSION_create_by_NID(X509_EXTENSION **ex,
+                                             int nid, int crit,
+                                             ASN1_OCTET_STRING *data);
+X509_EXTENSION *X509_EXTENSION_create_by_OBJ(X509_EXTENSION **ex,
+                                             const ASN1_OBJECT *obj, int crit,
+                                             ASN1_OCTET_STRING *data);
+int X509_EXTENSION_set_object(X509_EXTENSION *ex, const ASN1_OBJECT *obj);
+int X509_EXTENSION_set_critical(X509_EXTENSION *ex, int crit);
+int X509_EXTENSION_set_data(X509_EXTENSION *ex, ASN1_OCTET_STRING *data);
+ASN1_OBJECT *X509_EXTENSION_get_object(X509_EXTENSION *ex);
+ASN1_OCTET_STRING *X509_EXTENSION_get_data(X509_EXTENSION *ne);
+int X509_EXTENSION_get_critical(const X509_EXTENSION *ex);
+
+int X509at_get_attr_count(const STACK_OF(X509_ATTRIBUTE) *x);
+int X509at_get_attr_by_NID(const STACK_OF(X509_ATTRIBUTE) *x, int nid,
+                           int lastpos);
+int X509at_get_attr_by_OBJ(const STACK_OF(X509_ATTRIBUTE) *sk,
+                           const ASN1_OBJECT *obj, int lastpos);
+X509_ATTRIBUTE *X509at_get_attr(const STACK_OF(X509_ATTRIBUTE) *x, int loc);
+X509_ATTRIBUTE *X509at_delete_attr(STACK_OF(X509_ATTRIBUTE) *x, int loc);
+STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr(STACK_OF(X509_ATTRIBUTE) **x,
+                                           X509_ATTRIBUTE *attr);
+STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_OBJ(STACK_OF(X509_ATTRIBUTE)
+                                                  **x, const ASN1_OBJECT *obj,
+                                                  int type,
+                                                  const unsigned char *bytes,
+                                                  int len);
+STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_NID(STACK_OF(X509_ATTRIBUTE)
+                                                  **x, int nid, int type,
+                                                  const unsigned char *bytes,
+                                                  int len);
+STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_txt(STACK_OF(X509_ATTRIBUTE)
+                                                  **x, const char *attrname,
+                                                  int type,
+                                                  const unsigned char *bytes,
+                                                  int len);
+void *X509at_get0_data_by_OBJ(const STACK_OF(X509_ATTRIBUTE) *x,
+                              const ASN1_OBJECT *obj, int lastpos, int type);
+X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_NID(X509_ATTRIBUTE **attr, int nid,
+                                             int atrtype, const void *data,
+                                             int len);
+X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_OBJ(X509_ATTRIBUTE **attr,
+                                             const ASN1_OBJECT *obj,
+                                             int atrtype, const void *data,
+                                             int len);
+X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_txt(X509_ATTRIBUTE **attr,
+                                             const char *atrname, int type,
+                                             const unsigned char *bytes,
+                                             int len);
+int X509_ATTRIBUTE_set1_object(X509_ATTRIBUTE *attr, const ASN1_OBJECT *obj);
+int X509_ATTRIBUTE_set1_data(X509_ATTRIBUTE *attr, int attrtype,
+                             const void *data, int len);
+void *X509_ATTRIBUTE_get0_data(X509_ATTRIBUTE *attr, int idx, int atrtype,
+                               void *data);
+int X509_ATTRIBUTE_count(const X509_ATTRIBUTE *attr);
+ASN1_OBJECT *X509_ATTRIBUTE_get0_object(X509_ATTRIBUTE *attr);
+ASN1_TYPE *X509_ATTRIBUTE_get0_type(X509_ATTRIBUTE *attr, int idx);
+
+int EVP_PKEY_get_attr_count(const EVP_PKEY *key);
+int EVP_PKEY_get_attr_by_NID(const EVP_PKEY *key, int nid, int lastpos);
+int EVP_PKEY_get_attr_by_OBJ(const EVP_PKEY *key, const ASN1_OBJECT *obj,
+                             int lastpos);
+X509_ATTRIBUTE *EVP_PKEY_get_attr(const EVP_PKEY *key, int loc);
+X509_ATTRIBUTE *EVP_PKEY_delete_attr(EVP_PKEY *key, int loc);
+int EVP_PKEY_add1_attr(EVP_PKEY *key, X509_ATTRIBUTE *attr);
+int EVP_PKEY_add1_attr_by_OBJ(EVP_PKEY *key,
+                              const ASN1_OBJECT *obj, int type,
+                              const unsigned char *bytes, int len);
+int EVP_PKEY_add1_attr_by_NID(EVP_PKEY *key,
+                              int nid, int type,
+                              const unsigned char *bytes, int len);
+int EVP_PKEY_add1_attr_by_txt(EVP_PKEY *key,
+                              const char *attrname, int type,
+                              const unsigned char *bytes, int len);
+
+/* lookup a cert from a X509 STACK */
+X509 *X509_find_by_issuer_and_serial(STACK_OF(X509) *sk, const X509_NAME *name,
+                                     const ASN1_INTEGER *serial);
+X509 *X509_find_by_subject(STACK_OF(X509) *sk, const X509_NAME *name);
+
+DECLARE_ASN1_FUNCTIONS(PBEPARAM)
+DECLARE_ASN1_FUNCTIONS(PBE2PARAM)
+DECLARE_ASN1_FUNCTIONS(PBKDF2PARAM)
+#ifndef OPENSSL_NO_SCRYPT
+DECLARE_ASN1_FUNCTIONS(SCRYPT_PARAMS)
+#endif
+
+int PKCS5_pbe_set0_algor(X509_ALGOR *algor, int alg, int iter,
+                         const unsigned char *salt, int saltlen);
+int PKCS5_pbe_set0_algor_ex(X509_ALGOR *algor, int alg, int iter,
+                            const unsigned char *salt, int saltlen,
+                            OSSL_LIB_CTX *libctx);
+
+X509_ALGOR *PKCS5_pbe_set(int alg, int iter,
+                          const unsigned char *salt, int saltlen);
+X509_ALGOR *PKCS5_pbe_set_ex(int alg, int iter,
+                             const unsigned char *salt, int saltlen,
+                             OSSL_LIB_CTX *libctx);
+
+X509_ALGOR *PKCS5_pbe2_set(const EVP_CIPHER *cipher, int iter,
+                           unsigned char *salt, int saltlen);
+X509_ALGOR *PKCS5_pbe2_set_iv(const EVP_CIPHER *cipher, int iter,
+                              unsigned char *salt, int saltlen,
+                              unsigned char *aiv, int prf_nid);
+X509_ALGOR *PKCS5_pbe2_set_iv_ex(const EVP_CIPHER *cipher, int iter,
+                                 unsigned char *salt, int saltlen,
+                                 unsigned char *aiv, int prf_nid,
+                                 OSSL_LIB_CTX *libctx);
+
+#ifndef OPENSSL_NO_SCRYPT
+X509_ALGOR *PKCS5_pbe2_set_scrypt(const EVP_CIPHER *cipher,
+                                  const unsigned char *salt, int saltlen,
+                                  unsigned char *aiv, uint64_t N, uint64_t r,
+                                  uint64_t p);
+#endif
+
+X509_ALGOR *PKCS5_pbkdf2_set(int iter, unsigned char *salt, int saltlen,
+                             int prf_nid, int keylen);
+X509_ALGOR *PKCS5_pbkdf2_set_ex(int iter, unsigned char *salt, int saltlen,
+                                int prf_nid, int keylen,
+                                OSSL_LIB_CTX *libctx);
+
+/* PKCS#8 utilities */
+
+DECLARE_ASN1_FUNCTIONS(PKCS8_PRIV_KEY_INFO)
+
+EVP_PKEY *EVP_PKCS82PKEY(const PKCS8_PRIV_KEY_INFO *p8);
+EVP_PKEY *EVP_PKCS82PKEY_ex(const PKCS8_PRIV_KEY_INFO *p8, OSSL_LIB_CTX *libctx,
+                            const char *propq);
+PKCS8_PRIV_KEY_INFO *EVP_PKEY2PKCS8(const EVP_PKEY *pkey);
+
+int PKCS8_pkey_set0(PKCS8_PRIV_KEY_INFO *priv, ASN1_OBJECT *aobj,
+                    int version, int ptype, void *pval,
+                    unsigned char *penc, int penclen);
+int PKCS8_pkey_get0(const ASN1_OBJECT **ppkalg,
+                    const unsigned char **pk, int *ppklen,
+                    const X509_ALGOR **pa, const PKCS8_PRIV_KEY_INFO *p8);
+
+const STACK_OF(X509_ATTRIBUTE) *
+PKCS8_pkey_get0_attrs(const PKCS8_PRIV_KEY_INFO *p8);
+int PKCS8_pkey_add1_attr(PKCS8_PRIV_KEY_INFO *p8, X509_ATTRIBUTE *attr);
+int PKCS8_pkey_add1_attr_by_NID(PKCS8_PRIV_KEY_INFO *p8, int nid, int type,
+                                const unsigned char *bytes, int len);
+int PKCS8_pkey_add1_attr_by_OBJ(PKCS8_PRIV_KEY_INFO *p8, const ASN1_OBJECT *obj,
+                                int type, const unsigned char *bytes, int len);
+
+
+void X509_PUBKEY_set0_public_key(X509_PUBKEY *pub,
+                                 unsigned char *penc, int penclen);
+int X509_PUBKEY_set0_param(X509_PUBKEY *pub, ASN1_OBJECT *aobj,
+                           int ptype, void *pval,
+                           unsigned char *penc, int penclen);
+int X509_PUBKEY_get0_param(ASN1_OBJECT **ppkalg,
+                           const unsigned char **pk, int *ppklen,
+                           X509_ALGOR **pa, const X509_PUBKEY *pub);
+int X509_PUBKEY_eq(const X509_PUBKEY *a, const X509_PUBKEY *b);
+
+# ifdef  __cplusplus
+}
+# endif
+#endif
diff --git a/src/include/openssl/x509_vfy.h b/src/include/openssl/x509_vfy.h
new file mode 100644
index 0000000..bff2928
--- /dev/null
+++ b/src/include/openssl/x509_vfy.h
@@ -0,0 +1,902 @@
+/*
+ * WARNING: do not edit!
+ * Generated by makefile from include\openssl\x509_vfy.h.in
+ *
+ * Copyright 1995-2024 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+
+
+#ifndef OPENSSL_X509_VFY_H
+# define OPENSSL_X509_VFY_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_X509_VFY_H
+# endif
+
+/*
+ * Protect against recursion, x509.h and x509_vfy.h each include the other.
+ */
+# ifndef OPENSSL_X509_H
+#  include <openssl/x509.h>
+# endif
+
+# include <openssl/opensslconf.h>
+# include <openssl/lhash.h>
+# include <openssl/bio.h>
+# include <openssl/crypto.h>
+# include <openssl/symhacks.h>
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+/*-
+SSL_CTX -> X509_STORE
+                -> X509_LOOKUP
+                        ->X509_LOOKUP_METHOD
+                -> X509_LOOKUP
+                        ->X509_LOOKUP_METHOD
+
+SSL     -> X509_STORE_CTX
+                ->X509_STORE
+
+The X509_STORE holds the tables etc for verification stuff.
+A X509_STORE_CTX is used while validating a single certificate.
+The X509_STORE has X509_LOOKUPs for looking up certs.
+The X509_STORE then calls a function to actually verify the
+certificate chain.
+*/
+
+typedef enum {
+    X509_LU_NONE = 0,
+    X509_LU_X509, X509_LU_CRL
+} X509_LOOKUP_TYPE;
+
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#define X509_LU_RETRY   -1
+#define X509_LU_FAIL    0
+#endif
+
+SKM_DEFINE_STACK_OF_INTERNAL(X509_LOOKUP, X509_LOOKUP, X509_LOOKUP)
+#define sk_X509_LOOKUP_num(sk) OPENSSL_sk_num(ossl_check_const_X509_LOOKUP_sk_type(sk))
+#define sk_X509_LOOKUP_value(sk, idx) ((X509_LOOKUP *)OPENSSL_sk_value(ossl_check_const_X509_LOOKUP_sk_type(sk), (idx)))
+#define sk_X509_LOOKUP_new(cmp) ((STACK_OF(X509_LOOKUP) *)OPENSSL_sk_new(ossl_check_X509_LOOKUP_compfunc_type(cmp)))
+#define sk_X509_LOOKUP_new_null() ((STACK_OF(X509_LOOKUP) *)OPENSSL_sk_new_null())
+#define sk_X509_LOOKUP_new_reserve(cmp, n) ((STACK_OF(X509_LOOKUP) *)OPENSSL_sk_new_reserve(ossl_check_X509_LOOKUP_compfunc_type(cmp), (n)))
+#define sk_X509_LOOKUP_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_X509_LOOKUP_sk_type(sk), (n))
+#define sk_X509_LOOKUP_free(sk) OPENSSL_sk_free(ossl_check_X509_LOOKUP_sk_type(sk))
+#define sk_X509_LOOKUP_zero(sk) OPENSSL_sk_zero(ossl_check_X509_LOOKUP_sk_type(sk))
+#define sk_X509_LOOKUP_delete(sk, i) ((X509_LOOKUP *)OPENSSL_sk_delete(ossl_check_X509_LOOKUP_sk_type(sk), (i)))
+#define sk_X509_LOOKUP_delete_ptr(sk, ptr) ((X509_LOOKUP *)OPENSSL_sk_delete_ptr(ossl_check_X509_LOOKUP_sk_type(sk), ossl_check_X509_LOOKUP_type(ptr)))
+#define sk_X509_LOOKUP_push(sk, ptr) OPENSSL_sk_push(ossl_check_X509_LOOKUP_sk_type(sk), ossl_check_X509_LOOKUP_type(ptr))
+#define sk_X509_LOOKUP_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_X509_LOOKUP_sk_type(sk), ossl_check_X509_LOOKUP_type(ptr))
+#define sk_X509_LOOKUP_pop(sk) ((X509_LOOKUP *)OPENSSL_sk_pop(ossl_check_X509_LOOKUP_sk_type(sk)))
+#define sk_X509_LOOKUP_shift(sk) ((X509_LOOKUP *)OPENSSL_sk_shift(ossl_check_X509_LOOKUP_sk_type(sk)))
+#define sk_X509_LOOKUP_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_LOOKUP_sk_type(sk),ossl_check_X509_LOOKUP_freefunc_type(freefunc))
+#define sk_X509_LOOKUP_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_X509_LOOKUP_sk_type(sk), ossl_check_X509_LOOKUP_type(ptr), (idx))
+#define sk_X509_LOOKUP_set(sk, idx, ptr) ((X509_LOOKUP *)OPENSSL_sk_set(ossl_check_X509_LOOKUP_sk_type(sk), (idx), ossl_check_X509_LOOKUP_type(ptr)))
+#define sk_X509_LOOKUP_find(sk, ptr) OPENSSL_sk_find(ossl_check_X509_LOOKUP_sk_type(sk), ossl_check_X509_LOOKUP_type(ptr))
+#define sk_X509_LOOKUP_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_X509_LOOKUP_sk_type(sk), ossl_check_X509_LOOKUP_type(ptr))
+#define sk_X509_LOOKUP_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_X509_LOOKUP_sk_type(sk), ossl_check_X509_LOOKUP_type(ptr), pnum)
+#define sk_X509_LOOKUP_sort(sk) OPENSSL_sk_sort(ossl_check_X509_LOOKUP_sk_type(sk))
+#define sk_X509_LOOKUP_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_X509_LOOKUP_sk_type(sk))
+#define sk_X509_LOOKUP_dup(sk) ((STACK_OF(X509_LOOKUP) *)OPENSSL_sk_dup(ossl_check_const_X509_LOOKUP_sk_type(sk)))
+#define sk_X509_LOOKUP_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_LOOKUP) *)OPENSSL_sk_deep_copy(ossl_check_const_X509_LOOKUP_sk_type(sk), ossl_check_X509_LOOKUP_copyfunc_type(copyfunc), ossl_check_X509_LOOKUP_freefunc_type(freefunc)))
+#define sk_X509_LOOKUP_set_cmp_func(sk, cmp) ((sk_X509_LOOKUP_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_X509_LOOKUP_sk_type(sk), ossl_check_X509_LOOKUP_compfunc_type(cmp)))
+SKM_DEFINE_STACK_OF_INTERNAL(X509_OBJECT, X509_OBJECT, X509_OBJECT)
+#define sk_X509_OBJECT_num(sk) OPENSSL_sk_num(ossl_check_const_X509_OBJECT_sk_type(sk))
+#define sk_X509_OBJECT_value(sk, idx) ((X509_OBJECT *)OPENSSL_sk_value(ossl_check_const_X509_OBJECT_sk_type(sk), (idx)))
+#define sk_X509_OBJECT_new(cmp) ((STACK_OF(X509_OBJECT) *)OPENSSL_sk_new(ossl_check_X509_OBJECT_compfunc_type(cmp)))
+#define sk_X509_OBJECT_new_null() ((STACK_OF(X509_OBJECT) *)OPENSSL_sk_new_null())
+#define sk_X509_OBJECT_new_reserve(cmp, n) ((STACK_OF(X509_OBJECT) *)OPENSSL_sk_new_reserve(ossl_check_X509_OBJECT_compfunc_type(cmp), (n)))
+#define sk_X509_OBJECT_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_X509_OBJECT_sk_type(sk), (n))
+#define sk_X509_OBJECT_free(sk) OPENSSL_sk_free(ossl_check_X509_OBJECT_sk_type(sk))
+#define sk_X509_OBJECT_zero(sk) OPENSSL_sk_zero(ossl_check_X509_OBJECT_sk_type(sk))
+#define sk_X509_OBJECT_delete(sk, i) ((X509_OBJECT *)OPENSSL_sk_delete(ossl_check_X509_OBJECT_sk_type(sk), (i)))
+#define sk_X509_OBJECT_delete_ptr(sk, ptr) ((X509_OBJECT *)OPENSSL_sk_delete_ptr(ossl_check_X509_OBJECT_sk_type(sk), ossl_check_X509_OBJECT_type(ptr)))
+#define sk_X509_OBJECT_push(sk, ptr) OPENSSL_sk_push(ossl_check_X509_OBJECT_sk_type(sk), ossl_check_X509_OBJECT_type(ptr))
+#define sk_X509_OBJECT_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_X509_OBJECT_sk_type(sk), ossl_check_X509_OBJECT_type(ptr))
+#define sk_X509_OBJECT_pop(sk) ((X509_OBJECT *)OPENSSL_sk_pop(ossl_check_X509_OBJECT_sk_type(sk)))
+#define sk_X509_OBJECT_shift(sk) ((X509_OBJECT *)OPENSSL_sk_shift(ossl_check_X509_OBJECT_sk_type(sk)))
+#define sk_X509_OBJECT_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_OBJECT_sk_type(sk),ossl_check_X509_OBJECT_freefunc_type(freefunc))
+#define sk_X509_OBJECT_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_X509_OBJECT_sk_type(sk), ossl_check_X509_OBJECT_type(ptr), (idx))
+#define sk_X509_OBJECT_set(sk, idx, ptr) ((X509_OBJECT *)OPENSSL_sk_set(ossl_check_X509_OBJECT_sk_type(sk), (idx), ossl_check_X509_OBJECT_type(ptr)))
+#define sk_X509_OBJECT_find(sk, ptr) OPENSSL_sk_find(ossl_check_X509_OBJECT_sk_type(sk), ossl_check_X509_OBJECT_type(ptr))
+#define sk_X509_OBJECT_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_X509_OBJECT_sk_type(sk), ossl_check_X509_OBJECT_type(ptr))
+#define sk_X509_OBJECT_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_X509_OBJECT_sk_type(sk), ossl_check_X509_OBJECT_type(ptr), pnum)
+#define sk_X509_OBJECT_sort(sk) OPENSSL_sk_sort(ossl_check_X509_OBJECT_sk_type(sk))
+#define sk_X509_OBJECT_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_X509_OBJECT_sk_type(sk))
+#define sk_X509_OBJECT_dup(sk) ((STACK_OF(X509_OBJECT) *)OPENSSL_sk_dup(ossl_check_const_X509_OBJECT_sk_type(sk)))
+#define sk_X509_OBJECT_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_OBJECT) *)OPENSSL_sk_deep_copy(ossl_check_const_X509_OBJECT_sk_type(sk), ossl_check_X509_OBJECT_copyfunc_type(copyfunc), ossl_check_X509_OBJECT_freefunc_type(freefunc)))
+#define sk_X509_OBJECT_set_cmp_func(sk, cmp) ((sk_X509_OBJECT_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_X509_OBJECT_sk_type(sk), ossl_check_X509_OBJECT_compfunc_type(cmp)))
+SKM_DEFINE_STACK_OF_INTERNAL(X509_VERIFY_PARAM, X509_VERIFY_PARAM, X509_VERIFY_PARAM)
+#define sk_X509_VERIFY_PARAM_num(sk) OPENSSL_sk_num(ossl_check_const_X509_VERIFY_PARAM_sk_type(sk))
+#define sk_X509_VERIFY_PARAM_value(sk, idx) ((X509_VERIFY_PARAM *)OPENSSL_sk_value(ossl_check_const_X509_VERIFY_PARAM_sk_type(sk), (idx)))
+#define sk_X509_VERIFY_PARAM_new(cmp) ((STACK_OF(X509_VERIFY_PARAM) *)OPENSSL_sk_new(ossl_check_X509_VERIFY_PARAM_compfunc_type(cmp)))
+#define sk_X509_VERIFY_PARAM_new_null() ((STACK_OF(X509_VERIFY_PARAM) *)OPENSSL_sk_new_null())
+#define sk_X509_VERIFY_PARAM_new_reserve(cmp, n) ((STACK_OF(X509_VERIFY_PARAM) *)OPENSSL_sk_new_reserve(ossl_check_X509_VERIFY_PARAM_compfunc_type(cmp), (n)))
+#define sk_X509_VERIFY_PARAM_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_X509_VERIFY_PARAM_sk_type(sk), (n))
+#define sk_X509_VERIFY_PARAM_free(sk) OPENSSL_sk_free(ossl_check_X509_VERIFY_PARAM_sk_type(sk))
+#define sk_X509_VERIFY_PARAM_zero(sk) OPENSSL_sk_zero(ossl_check_X509_VERIFY_PARAM_sk_type(sk))
+#define sk_X509_VERIFY_PARAM_delete(sk, i) ((X509_VERIFY_PARAM *)OPENSSL_sk_delete(ossl_check_X509_VERIFY_PARAM_sk_type(sk), (i)))
+#define sk_X509_VERIFY_PARAM_delete_ptr(sk, ptr) ((X509_VERIFY_PARAM *)OPENSSL_sk_delete_ptr(ossl_check_X509_VERIFY_PARAM_sk_type(sk), ossl_check_X509_VERIFY_PARAM_type(ptr)))
+#define sk_X509_VERIFY_PARAM_push(sk, ptr) OPENSSL_sk_push(ossl_check_X509_VERIFY_PARAM_sk_type(sk), ossl_check_X509_VERIFY_PARAM_type(ptr))
+#define sk_X509_VERIFY_PARAM_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_X509_VERIFY_PARAM_sk_type(sk), ossl_check_X509_VERIFY_PARAM_type(ptr))
+#define sk_X509_VERIFY_PARAM_pop(sk) ((X509_VERIFY_PARAM *)OPENSSL_sk_pop(ossl_check_X509_VERIFY_PARAM_sk_type(sk)))
+#define sk_X509_VERIFY_PARAM_shift(sk) ((X509_VERIFY_PARAM *)OPENSSL_sk_shift(ossl_check_X509_VERIFY_PARAM_sk_type(sk)))
+#define sk_X509_VERIFY_PARAM_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_VERIFY_PARAM_sk_type(sk),ossl_check_X509_VERIFY_PARAM_freefunc_type(freefunc))
+#define sk_X509_VERIFY_PARAM_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_X509_VERIFY_PARAM_sk_type(sk), ossl_check_X509_VERIFY_PARAM_type(ptr), (idx))
+#define sk_X509_VERIFY_PARAM_set(sk, idx, ptr) ((X509_VERIFY_PARAM *)OPENSSL_sk_set(ossl_check_X509_VERIFY_PARAM_sk_type(sk), (idx), ossl_check_X509_VERIFY_PARAM_type(ptr)))
+#define sk_X509_VERIFY_PARAM_find(sk, ptr) OPENSSL_sk_find(ossl_check_X509_VERIFY_PARAM_sk_type(sk), ossl_check_X509_VERIFY_PARAM_type(ptr))
+#define sk_X509_VERIFY_PARAM_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_X509_VERIFY_PARAM_sk_type(sk), ossl_check_X509_VERIFY_PARAM_type(ptr))
+#define sk_X509_VERIFY_PARAM_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_X509_VERIFY_PARAM_sk_type(sk), ossl_check_X509_VERIFY_PARAM_type(ptr), pnum)
+#define sk_X509_VERIFY_PARAM_sort(sk) OPENSSL_sk_sort(ossl_check_X509_VERIFY_PARAM_sk_type(sk))
+#define sk_X509_VERIFY_PARAM_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_X509_VERIFY_PARAM_sk_type(sk))
+#define sk_X509_VERIFY_PARAM_dup(sk) ((STACK_OF(X509_VERIFY_PARAM) *)OPENSSL_sk_dup(ossl_check_const_X509_VERIFY_PARAM_sk_type(sk)))
+#define sk_X509_VERIFY_PARAM_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_VERIFY_PARAM) *)OPENSSL_sk_deep_copy(ossl_check_const_X509_VERIFY_PARAM_sk_type(sk), ossl_check_X509_VERIFY_PARAM_copyfunc_type(copyfunc), ossl_check_X509_VERIFY_PARAM_freefunc_type(freefunc)))
+#define sk_X509_VERIFY_PARAM_set_cmp_func(sk, cmp) ((sk_X509_VERIFY_PARAM_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_X509_VERIFY_PARAM_sk_type(sk), ossl_check_X509_VERIFY_PARAM_compfunc_type(cmp)))
+
+
+/* This is used for a table of trust checking functions */
+typedef struct x509_trust_st {
+    int trust;
+    int flags;
+    int (*check_trust) (struct x509_trust_st *, X509 *, int);
+    char *name;
+    int arg1;
+    void *arg2;
+} X509_TRUST;
+SKM_DEFINE_STACK_OF_INTERNAL(X509_TRUST, X509_TRUST, X509_TRUST)
+#define sk_X509_TRUST_num(sk) OPENSSL_sk_num(ossl_check_const_X509_TRUST_sk_type(sk))
+#define sk_X509_TRUST_value(sk, idx) ((X509_TRUST *)OPENSSL_sk_value(ossl_check_const_X509_TRUST_sk_type(sk), (idx)))
+#define sk_X509_TRUST_new(cmp) ((STACK_OF(X509_TRUST) *)OPENSSL_sk_new(ossl_check_X509_TRUST_compfunc_type(cmp)))
+#define sk_X509_TRUST_new_null() ((STACK_OF(X509_TRUST) *)OPENSSL_sk_new_null())
+#define sk_X509_TRUST_new_reserve(cmp, n) ((STACK_OF(X509_TRUST) *)OPENSSL_sk_new_reserve(ossl_check_X509_TRUST_compfunc_type(cmp), (n)))
+#define sk_X509_TRUST_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_X509_TRUST_sk_type(sk), (n))
+#define sk_X509_TRUST_free(sk) OPENSSL_sk_free(ossl_check_X509_TRUST_sk_type(sk))
+#define sk_X509_TRUST_zero(sk) OPENSSL_sk_zero(ossl_check_X509_TRUST_sk_type(sk))
+#define sk_X509_TRUST_delete(sk, i) ((X509_TRUST *)OPENSSL_sk_delete(ossl_check_X509_TRUST_sk_type(sk), (i)))
+#define sk_X509_TRUST_delete_ptr(sk, ptr) ((X509_TRUST *)OPENSSL_sk_delete_ptr(ossl_check_X509_TRUST_sk_type(sk), ossl_check_X509_TRUST_type(ptr)))
+#define sk_X509_TRUST_push(sk, ptr) OPENSSL_sk_push(ossl_check_X509_TRUST_sk_type(sk), ossl_check_X509_TRUST_type(ptr))
+#define sk_X509_TRUST_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_X509_TRUST_sk_type(sk), ossl_check_X509_TRUST_type(ptr))
+#define sk_X509_TRUST_pop(sk) ((X509_TRUST *)OPENSSL_sk_pop(ossl_check_X509_TRUST_sk_type(sk)))
+#define sk_X509_TRUST_shift(sk) ((X509_TRUST *)OPENSSL_sk_shift(ossl_check_X509_TRUST_sk_type(sk)))
+#define sk_X509_TRUST_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_TRUST_sk_type(sk),ossl_check_X509_TRUST_freefunc_type(freefunc))
+#define sk_X509_TRUST_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_X509_TRUST_sk_type(sk), ossl_check_X509_TRUST_type(ptr), (idx))
+#define sk_X509_TRUST_set(sk, idx, ptr) ((X509_TRUST *)OPENSSL_sk_set(ossl_check_X509_TRUST_sk_type(sk), (idx), ossl_check_X509_TRUST_type(ptr)))
+#define sk_X509_TRUST_find(sk, ptr) OPENSSL_sk_find(ossl_check_X509_TRUST_sk_type(sk), ossl_check_X509_TRUST_type(ptr))
+#define sk_X509_TRUST_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_X509_TRUST_sk_type(sk), ossl_check_X509_TRUST_type(ptr))
+#define sk_X509_TRUST_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_X509_TRUST_sk_type(sk), ossl_check_X509_TRUST_type(ptr), pnum)
+#define sk_X509_TRUST_sort(sk) OPENSSL_sk_sort(ossl_check_X509_TRUST_sk_type(sk))
+#define sk_X509_TRUST_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_X509_TRUST_sk_type(sk))
+#define sk_X509_TRUST_dup(sk) ((STACK_OF(X509_TRUST) *)OPENSSL_sk_dup(ossl_check_const_X509_TRUST_sk_type(sk)))
+#define sk_X509_TRUST_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_TRUST) *)OPENSSL_sk_deep_copy(ossl_check_const_X509_TRUST_sk_type(sk), ossl_check_X509_TRUST_copyfunc_type(copyfunc), ossl_check_X509_TRUST_freefunc_type(freefunc)))
+#define sk_X509_TRUST_set_cmp_func(sk, cmp) ((sk_X509_TRUST_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_X509_TRUST_sk_type(sk), ossl_check_X509_TRUST_compfunc_type(cmp)))
+
+
+/* standard trust ids */
+# define X509_TRUST_DEFAULT      0 /* Only valid in purpose settings */
+# define X509_TRUST_COMPAT       1
+# define X509_TRUST_SSL_CLIENT   2
+# define X509_TRUST_SSL_SERVER   3
+# define X509_TRUST_EMAIL        4
+# define X509_TRUST_OBJECT_SIGN  5
+# define X509_TRUST_OCSP_SIGN    6
+# define X509_TRUST_OCSP_REQUEST 7
+# define X509_TRUST_TSA          8
+/* Keep these up to date! */
+# define X509_TRUST_MIN          1
+# define X509_TRUST_MAX          8
+
+/* trust_flags values */
+# define X509_TRUST_DYNAMIC      (1U << 0)
+# define X509_TRUST_DYNAMIC_NAME (1U << 1)
+/* No compat trust if self-signed, preempts "DO_SS" */
+# define X509_TRUST_NO_SS_COMPAT (1U << 2)
+/* Compat trust if no explicit accepted trust EKUs */
+# define X509_TRUST_DO_SS_COMPAT (1U << 3)
+/* Accept "anyEKU" as a wildcard rejection OID and as a wildcard trust OID */
+# define X509_TRUST_OK_ANY_EKU   (1U << 4)
+
+/* check_trust return codes */
+# define X509_TRUST_TRUSTED      1
+# define X509_TRUST_REJECTED     2
+# define X509_TRUST_UNTRUSTED    3
+
+int X509_TRUST_set(int *t, int trust);
+int X509_TRUST_get_count(void);
+X509_TRUST *X509_TRUST_get0(int idx);
+int X509_TRUST_get_by_id(int id);
+int X509_TRUST_add(int id, int flags, int (*ck) (X509_TRUST *, X509 *, int),
+                   const char *name, int arg1, void *arg2);
+void X509_TRUST_cleanup(void);
+int X509_TRUST_get_flags(const X509_TRUST *xp);
+char *X509_TRUST_get0_name(const X509_TRUST *xp);
+int X509_TRUST_get_trust(const X509_TRUST *xp);
+
+int X509_trusted(const X509 *x);
+int X509_add1_trust_object(X509 *x, const ASN1_OBJECT *obj);
+int X509_add1_reject_object(X509 *x, const ASN1_OBJECT *obj);
+void X509_trust_clear(X509 *x);
+void X509_reject_clear(X509 *x);
+STACK_OF(ASN1_OBJECT) *X509_get0_trust_objects(X509 *x);
+STACK_OF(ASN1_OBJECT) *X509_get0_reject_objects(X509 *x);
+
+int (*X509_TRUST_set_default(int (*trust) (int, X509 *, int))) (int, X509 *,
+                                                                int);
+int X509_check_trust(X509 *x, int id, int flags);
+
+int X509_verify_cert(X509_STORE_CTX *ctx);
+int X509_STORE_CTX_verify(X509_STORE_CTX *ctx);
+STACK_OF(X509) *X509_build_chain(X509 *target, STACK_OF(X509) *certs,
+                                 X509_STORE *store, int with_self_signed,
+                                 OSSL_LIB_CTX *libctx, const char *propq);
+
+int X509_STORE_set_depth(X509_STORE *store, int depth);
+
+typedef int (*X509_STORE_CTX_verify_cb)(int, X509_STORE_CTX *);
+int X509_STORE_CTX_print_verify_cb(int ok, X509_STORE_CTX *ctx);
+typedef int (*X509_STORE_CTX_verify_fn)(X509_STORE_CTX *);
+typedef int (*X509_STORE_CTX_get_issuer_fn)(X509 **issuer,
+                                            X509_STORE_CTX *ctx, X509 *x);
+typedef int (*X509_STORE_CTX_check_issued_fn)(X509_STORE_CTX *ctx,
+                                              X509 *x, X509 *issuer);
+typedef int (*X509_STORE_CTX_check_revocation_fn)(X509_STORE_CTX *ctx);
+typedef int (*X509_STORE_CTX_get_crl_fn)(X509_STORE_CTX *ctx,
+                                         X509_CRL **crl, X509 *x);
+typedef int (*X509_STORE_CTX_check_crl_fn)(X509_STORE_CTX *ctx, X509_CRL *crl);
+typedef int (*X509_STORE_CTX_cert_crl_fn)(X509_STORE_CTX *ctx,
+                                          X509_CRL *crl, X509 *x);
+typedef int (*X509_STORE_CTX_check_policy_fn)(X509_STORE_CTX *ctx);
+typedef STACK_OF(X509)
+    *(*X509_STORE_CTX_lookup_certs_fn)(X509_STORE_CTX *ctx,
+                                       const X509_NAME *nm);
+typedef STACK_OF(X509_CRL)
+    *(*X509_STORE_CTX_lookup_crls_fn)(const X509_STORE_CTX *ctx,
+                                      const X509_NAME *nm);
+typedef int (*X509_STORE_CTX_cleanup_fn)(X509_STORE_CTX *ctx);
+
+void X509_STORE_CTX_set_depth(X509_STORE_CTX *ctx, int depth);
+
+# define X509_STORE_CTX_set_app_data(ctx,data) \
+        X509_STORE_CTX_set_ex_data(ctx,0,data)
+# define X509_STORE_CTX_get_app_data(ctx) \
+        X509_STORE_CTX_get_ex_data(ctx,0)
+
+# define X509_L_FILE_LOAD        1
+# define X509_L_ADD_DIR          2
+# define X509_L_ADD_STORE        3
+# define X509_L_LOAD_STORE       4
+
+# define X509_LOOKUP_load_file(x,name,type) \
+                X509_LOOKUP_ctrl((x),X509_L_FILE_LOAD,(name),(long)(type),NULL)
+
+# define X509_LOOKUP_add_dir(x,name,type) \
+                X509_LOOKUP_ctrl((x),X509_L_ADD_DIR,(name),(long)(type),NULL)
+
+# define X509_LOOKUP_add_store(x,name) \
+                X509_LOOKUP_ctrl((x),X509_L_ADD_STORE,(name),0,NULL)
+
+# define X509_LOOKUP_load_store(x,name) \
+                X509_LOOKUP_ctrl((x),X509_L_LOAD_STORE,(name),0,NULL)
+
+# define X509_LOOKUP_load_file_ex(x, name, type, libctx, propq)       \
+X509_LOOKUP_ctrl_ex((x), X509_L_FILE_LOAD, (name), (long)(type), NULL,\
+                    (libctx), (propq))
+
+# define X509_LOOKUP_load_store_ex(x, name, libctx, propq)            \
+X509_LOOKUP_ctrl_ex((x), X509_L_LOAD_STORE, (name), 0, NULL,          \
+                    (libctx), (propq))
+
+# define X509_LOOKUP_add_store_ex(x, name, libctx, propq)             \
+X509_LOOKUP_ctrl_ex((x), X509_L_ADD_STORE, (name), 0, NULL,           \
+                    (libctx), (propq))
+
+# define X509_V_OK                                       0
+# define X509_V_ERR_UNSPECIFIED                          1
+# define X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT            2
+# define X509_V_ERR_UNABLE_TO_GET_CRL                    3
+# define X509_V_ERR_UNABLE_TO_DECRYPT_CERT_SIGNATURE     4
+# define X509_V_ERR_UNABLE_TO_DECRYPT_CRL_SIGNATURE      5
+# define X509_V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY   6
+# define X509_V_ERR_CERT_SIGNATURE_FAILURE               7
+# define X509_V_ERR_CRL_SIGNATURE_FAILURE                8
+# define X509_V_ERR_CERT_NOT_YET_VALID                   9
+# define X509_V_ERR_CERT_HAS_EXPIRED                     10
+# define X509_V_ERR_CRL_NOT_YET_VALID                    11
+# define X509_V_ERR_CRL_HAS_EXPIRED                      12
+# define X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD       13
+# define X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD        14
+# define X509_V_ERR_ERROR_IN_CRL_LAST_UPDATE_FIELD       15
+# define X509_V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD       16
+# define X509_V_ERR_OUT_OF_MEM                           17
+# define X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT          18
+# define X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN            19
+# define X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY    20
+# define X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE      21
+# define X509_V_ERR_CERT_CHAIN_TOO_LONG                  22
+# define X509_V_ERR_CERT_REVOKED                         23
+# define X509_V_ERR_NO_ISSUER_PUBLIC_KEY                 24
+# define X509_V_ERR_PATH_LENGTH_EXCEEDED                 25
+# define X509_V_ERR_INVALID_PURPOSE                      26
+# define X509_V_ERR_CERT_UNTRUSTED                       27
+# define X509_V_ERR_CERT_REJECTED                        28
+
+/* These are 'informational' when looking for issuer cert */
+# define X509_V_ERR_SUBJECT_ISSUER_MISMATCH              29
+# define X509_V_ERR_AKID_SKID_MISMATCH                   30
+# define X509_V_ERR_AKID_ISSUER_SERIAL_MISMATCH          31
+# define X509_V_ERR_KEYUSAGE_NO_CERTSIGN                 32
+# define X509_V_ERR_UNABLE_TO_GET_CRL_ISSUER             33
+# define X509_V_ERR_UNHANDLED_CRITICAL_EXTENSION         34
+# define X509_V_ERR_KEYUSAGE_NO_CRL_SIGN                 35
+# define X509_V_ERR_UNHANDLED_CRITICAL_CRL_EXTENSION     36
+# define X509_V_ERR_INVALID_NON_CA                       37
+# define X509_V_ERR_PROXY_PATH_LENGTH_EXCEEDED           38
+# define X509_V_ERR_KEYUSAGE_NO_DIGITAL_SIGNATURE        39
+# define X509_V_ERR_PROXY_CERTIFICATES_NOT_ALLOWED       40
+# define X509_V_ERR_INVALID_EXTENSION                    41
+# define X509_V_ERR_INVALID_POLICY_EXTENSION             42
+# define X509_V_ERR_NO_EXPLICIT_POLICY                   43
+# define X509_V_ERR_DIFFERENT_CRL_SCOPE                  44
+# define X509_V_ERR_UNSUPPORTED_EXTENSION_FEATURE        45
+# define X509_V_ERR_UNNESTED_RESOURCE                    46
+# define X509_V_ERR_PERMITTED_VIOLATION                  47
+# define X509_V_ERR_EXCLUDED_VIOLATION                   48
+# define X509_V_ERR_SUBTREE_MINMAX                       49
+/* The application is not happy */
+# define X509_V_ERR_APPLICATION_VERIFICATION             50
+# define X509_V_ERR_UNSUPPORTED_CONSTRAINT_TYPE          51
+# define X509_V_ERR_UNSUPPORTED_CONSTRAINT_SYNTAX        52
+# define X509_V_ERR_UNSUPPORTED_NAME_SYNTAX              53
+# define X509_V_ERR_CRL_PATH_VALIDATION_ERROR            54
+/* Another issuer check debug option */
+# define X509_V_ERR_PATH_LOOP                            55
+/* Suite B mode algorithm violation */
+# define X509_V_ERR_SUITE_B_INVALID_VERSION              56
+# define X509_V_ERR_SUITE_B_INVALID_ALGORITHM            57
+# define X509_V_ERR_SUITE_B_INVALID_CURVE                58
+# define X509_V_ERR_SUITE_B_INVALID_SIGNATURE_ALGORITHM  59
+# define X509_V_ERR_SUITE_B_LOS_NOT_ALLOWED              60
+# define X509_V_ERR_SUITE_B_CANNOT_SIGN_P_384_WITH_P_256 61
+/* Host, email and IP check errors */
+# define X509_V_ERR_HOSTNAME_MISMATCH                    62
+# define X509_V_ERR_EMAIL_MISMATCH                       63
+# define X509_V_ERR_IP_ADDRESS_MISMATCH                  64
+/* DANE TLSA errors */
+# define X509_V_ERR_DANE_NO_MATCH                        65
+/* security level errors */
+# define X509_V_ERR_EE_KEY_TOO_SMALL                     66
+# define X509_V_ERR_CA_KEY_TOO_SMALL                     67
+# define X509_V_ERR_CA_MD_TOO_WEAK                       68
+/* Caller error */
+# define X509_V_ERR_INVALID_CALL                         69
+/* Issuer lookup error */
+# define X509_V_ERR_STORE_LOOKUP                         70
+/* Certificate transparency */
+# define X509_V_ERR_NO_VALID_SCTS                        71
+
+# define X509_V_ERR_PROXY_SUBJECT_NAME_VIOLATION         72
+/* OCSP status errors */
+# define X509_V_ERR_OCSP_VERIFY_NEEDED                   73  /* Need OCSP verification */
+# define X509_V_ERR_OCSP_VERIFY_FAILED                   74  /* Couldn't verify cert through OCSP */
+# define X509_V_ERR_OCSP_CERT_UNKNOWN                    75  /* Certificate wasn't recognized by the OCSP responder */
+
+# define X509_V_ERR_UNSUPPORTED_SIGNATURE_ALGORITHM      76
+# define X509_V_ERR_SIGNATURE_ALGORITHM_MISMATCH         77
+
+/* Errors in case a check in X509_V_FLAG_X509_STRICT mode fails */
+# define X509_V_ERR_SIGNATURE_ALGORITHM_INCONSISTENCY    78
+# define X509_V_ERR_INVALID_CA                           79
+# define X509_V_ERR_PATHLEN_INVALID_FOR_NON_CA           80
+# define X509_V_ERR_PATHLEN_WITHOUT_KU_KEY_CERT_SIGN     81
+# define X509_V_ERR_KU_KEY_CERT_SIGN_INVALID_FOR_NON_CA  82
+# define X509_V_ERR_ISSUER_NAME_EMPTY                    83
+# define X509_V_ERR_SUBJECT_NAME_EMPTY                   84
+# define X509_V_ERR_MISSING_AUTHORITY_KEY_IDENTIFIER     85
+# define X509_V_ERR_MISSING_SUBJECT_KEY_IDENTIFIER       86
+# define X509_V_ERR_EMPTY_SUBJECT_ALT_NAME               87
+# define X509_V_ERR_EMPTY_SUBJECT_SAN_NOT_CRITICAL       88
+# define X509_V_ERR_CA_BCONS_NOT_CRITICAL                89
+# define X509_V_ERR_AUTHORITY_KEY_IDENTIFIER_CRITICAL    90
+# define X509_V_ERR_SUBJECT_KEY_IDENTIFIER_CRITICAL      91
+# define X509_V_ERR_CA_CERT_MISSING_KEY_USAGE            92
+# define X509_V_ERR_EXTENSIONS_REQUIRE_VERSION_3         93
+# define X509_V_ERR_EC_KEY_EXPLICIT_PARAMS               94
+# define X509_V_ERR_RPK_UNTRUSTED                        95
+
+/* Certificate verify flags */
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#  define X509_V_FLAG_CB_ISSUER_CHECK             0x0   /* Deprecated */
+# endif
+/* Use check time instead of current time */
+# define X509_V_FLAG_USE_CHECK_TIME              0x2
+/* Lookup CRLs */
+# define X509_V_FLAG_CRL_CHECK                   0x4
+/* Lookup CRLs for whole chain */
+# define X509_V_FLAG_CRL_CHECK_ALL               0x8
+/* Ignore unhandled critical extensions */
+# define X509_V_FLAG_IGNORE_CRITICAL             0x10
+/* Disable workarounds for broken certificates */
+# define X509_V_FLAG_X509_STRICT                 0x20
+/* Enable proxy certificate validation */
+# define X509_V_FLAG_ALLOW_PROXY_CERTS           0x40
+/* Enable policy checking */
+# define X509_V_FLAG_POLICY_CHECK                0x80
+/* Policy variable require-explicit-policy */
+# define X509_V_FLAG_EXPLICIT_POLICY             0x100
+/* Policy variable inhibit-any-policy */
+# define X509_V_FLAG_INHIBIT_ANY                 0x200
+/* Policy variable inhibit-policy-mapping */
+# define X509_V_FLAG_INHIBIT_MAP                 0x400
+/* Notify callback that policy is OK */
+# define X509_V_FLAG_NOTIFY_POLICY               0x800
+/* Extended CRL features such as indirect CRLs, alternate CRL signing keys */
+# define X509_V_FLAG_EXTENDED_CRL_SUPPORT        0x1000
+/* Delta CRL support */
+# define X509_V_FLAG_USE_DELTAS                  0x2000
+/* Check self-signed CA signature */
+# define X509_V_FLAG_CHECK_SS_SIGNATURE          0x4000
+/* Use trusted store first */
+# define X509_V_FLAG_TRUSTED_FIRST               0x8000
+/* Suite B 128 bit only mode: not normally used */
+# define X509_V_FLAG_SUITEB_128_LOS_ONLY         0x10000
+/* Suite B 192 bit only mode */
+# define X509_V_FLAG_SUITEB_192_LOS              0x20000
+/* Suite B 128 bit mode allowing 192 bit algorithms */
+# define X509_V_FLAG_SUITEB_128_LOS              0x30000
+/* Allow partial chains if at least one certificate is in trusted store */
+# define X509_V_FLAG_PARTIAL_CHAIN               0x80000
+/*
+ * If the initial chain is not trusted, do not attempt to build an alternative
+ * chain. Alternate chain checking was introduced in 1.1.0. Setting this flag
+ * will force the behaviour to match that of previous versions.
+ */
+# define X509_V_FLAG_NO_ALT_CHAINS               0x100000
+/* Do not check certificate/CRL validity against current time */
+# define X509_V_FLAG_NO_CHECK_TIME               0x200000
+
+# define X509_VP_FLAG_DEFAULT                    0x1
+# define X509_VP_FLAG_OVERWRITE                  0x2
+# define X509_VP_FLAG_RESET_FLAGS                0x4
+# define X509_VP_FLAG_LOCKED                     0x8
+# define X509_VP_FLAG_ONCE                       0x10
+
+/* Internal use: mask of policy related options */
+# define X509_V_FLAG_POLICY_MASK (X509_V_FLAG_POLICY_CHECK \
+                                | X509_V_FLAG_EXPLICIT_POLICY \
+                                | X509_V_FLAG_INHIBIT_ANY \
+                                | X509_V_FLAG_INHIBIT_MAP)
+
+int X509_OBJECT_idx_by_subject(STACK_OF(X509_OBJECT) *h, X509_LOOKUP_TYPE type,
+                               const X509_NAME *name);
+X509_OBJECT *X509_OBJECT_retrieve_by_subject(STACK_OF(X509_OBJECT) *h,
+                                             X509_LOOKUP_TYPE type,
+                                             const X509_NAME *name);
+X509_OBJECT *X509_OBJECT_retrieve_match(STACK_OF(X509_OBJECT) *h,
+                                        X509_OBJECT *x);
+int X509_OBJECT_up_ref_count(X509_OBJECT *a);
+X509_OBJECT *X509_OBJECT_new(void);
+void X509_OBJECT_free(X509_OBJECT *a);
+X509_LOOKUP_TYPE X509_OBJECT_get_type(const X509_OBJECT *a);
+X509 *X509_OBJECT_get0_X509(const X509_OBJECT *a);
+int X509_OBJECT_set1_X509(X509_OBJECT *a, X509 *obj);
+X509_CRL *X509_OBJECT_get0_X509_CRL(const X509_OBJECT *a);
+int X509_OBJECT_set1_X509_CRL(X509_OBJECT *a, X509_CRL *obj);
+X509_STORE *X509_STORE_new(void);
+void X509_STORE_free(X509_STORE *xs);
+int X509_STORE_lock(X509_STORE *xs);
+int X509_STORE_unlock(X509_STORE *xs);
+int X509_STORE_up_ref(X509_STORE *xs);
+STACK_OF(X509_OBJECT) *X509_STORE_get0_objects(const X509_STORE *xs);
+STACK_OF(X509_OBJECT) *X509_STORE_get1_objects(X509_STORE *xs);
+STACK_OF(X509) *X509_STORE_get1_all_certs(X509_STORE *xs);
+STACK_OF(X509) *X509_STORE_CTX_get1_certs(X509_STORE_CTX *xs,
+                                          const X509_NAME *nm);
+STACK_OF(X509_CRL) *X509_STORE_CTX_get1_crls(const X509_STORE_CTX *st,
+                                             const X509_NAME *nm);
+int X509_STORE_set_flags(X509_STORE *xs, unsigned long flags);
+int X509_STORE_set_purpose(X509_STORE *xs, int purpose);
+int X509_STORE_set_trust(X509_STORE *xs, int trust);
+int X509_STORE_set1_param(X509_STORE *xs, const X509_VERIFY_PARAM *pm);
+X509_VERIFY_PARAM *X509_STORE_get0_param(const X509_STORE *xs);
+
+void X509_STORE_set_verify(X509_STORE *xs, X509_STORE_CTX_verify_fn verify);
+#define X509_STORE_set_verify_func(ctx, func) \
+            X509_STORE_set_verify((ctx),(func))
+void X509_STORE_CTX_set_verify(X509_STORE_CTX *ctx,
+                               X509_STORE_CTX_verify_fn verify);
+X509_STORE_CTX_verify_fn X509_STORE_get_verify(const X509_STORE *xs);
+void X509_STORE_set_verify_cb(X509_STORE *xs,
+                              X509_STORE_CTX_verify_cb verify_cb);
+# define X509_STORE_set_verify_cb_func(ctx,func) \
+            X509_STORE_set_verify_cb((ctx),(func))
+X509_STORE_CTX_verify_cb X509_STORE_get_verify_cb(const X509_STORE *xs);
+void X509_STORE_set_get_issuer(X509_STORE *xs,
+                               X509_STORE_CTX_get_issuer_fn get_issuer);
+X509_STORE_CTX_get_issuer_fn X509_STORE_get_get_issuer(const X509_STORE *xs);
+void X509_STORE_set_check_issued(X509_STORE *xs,
+                                 X509_STORE_CTX_check_issued_fn check_issued);
+X509_STORE_CTX_check_issued_fn X509_STORE_get_check_issued(const X509_STORE *s);
+void X509_STORE_set_check_revocation(X509_STORE *xs,
+                                     X509_STORE_CTX_check_revocation_fn check_revocation);
+X509_STORE_CTX_check_revocation_fn
+    X509_STORE_get_check_revocation(const X509_STORE *xs);
+void X509_STORE_set_get_crl(X509_STORE *xs,
+                            X509_STORE_CTX_get_crl_fn get_crl);
+X509_STORE_CTX_get_crl_fn X509_STORE_get_get_crl(const X509_STORE *xs);
+void X509_STORE_set_check_crl(X509_STORE *xs,
+                              X509_STORE_CTX_check_crl_fn check_crl);
+X509_STORE_CTX_check_crl_fn X509_STORE_get_check_crl(const X509_STORE *xs);
+void X509_STORE_set_cert_crl(X509_STORE *xs,
+                             X509_STORE_CTX_cert_crl_fn cert_crl);
+X509_STORE_CTX_cert_crl_fn X509_STORE_get_cert_crl(const X509_STORE *xs);
+void X509_STORE_set_check_policy(X509_STORE *xs,
+                                 X509_STORE_CTX_check_policy_fn check_policy);
+X509_STORE_CTX_check_policy_fn X509_STORE_get_check_policy(const X509_STORE *s);
+void X509_STORE_set_lookup_certs(X509_STORE *xs,
+                                 X509_STORE_CTX_lookup_certs_fn lookup_certs);
+X509_STORE_CTX_lookup_certs_fn X509_STORE_get_lookup_certs(const X509_STORE *s);
+void X509_STORE_set_lookup_crls(X509_STORE *xs,
+                                X509_STORE_CTX_lookup_crls_fn lookup_crls);
+#define X509_STORE_set_lookup_crls_cb(ctx, func) \
+    X509_STORE_set_lookup_crls((ctx), (func))
+X509_STORE_CTX_lookup_crls_fn X509_STORE_get_lookup_crls(const X509_STORE *xs);
+void X509_STORE_set_cleanup(X509_STORE *xs,
+                            X509_STORE_CTX_cleanup_fn cleanup);
+X509_STORE_CTX_cleanup_fn X509_STORE_get_cleanup(const X509_STORE *xs);
+
+#define X509_STORE_get_ex_new_index(l, p, newf, dupf, freef) \
+    CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_X509_STORE, l, p, newf, dupf, freef)
+int X509_STORE_set_ex_data(X509_STORE *xs, int idx, void *data);
+void *X509_STORE_get_ex_data(const X509_STORE *xs, int idx);
+
+X509_STORE_CTX *X509_STORE_CTX_new_ex(OSSL_LIB_CTX *libctx, const char *propq);
+X509_STORE_CTX *X509_STORE_CTX_new(void);
+
+int X509_STORE_CTX_get1_issuer(X509 **issuer, X509_STORE_CTX *ctx, X509 *x);
+
+void X509_STORE_CTX_free(X509_STORE_CTX *ctx);
+int X509_STORE_CTX_init(X509_STORE_CTX *ctx, X509_STORE *trust_store,
+                        X509 *target, STACK_OF(X509) *untrusted);
+int X509_STORE_CTX_init_rpk(X509_STORE_CTX *ctx, X509_STORE *trust_store,
+                            EVP_PKEY* rpk);
+void X509_STORE_CTX_set0_trusted_stack(X509_STORE_CTX *ctx, STACK_OF(X509) *sk);
+void X509_STORE_CTX_cleanup(X509_STORE_CTX *ctx);
+
+X509_STORE *X509_STORE_CTX_get0_store(const X509_STORE_CTX *ctx);
+X509 *X509_STORE_CTX_get0_cert(const X509_STORE_CTX *ctx);
+EVP_PKEY *X509_STORE_CTX_get0_rpk(const X509_STORE_CTX *ctx);
+STACK_OF(X509)* X509_STORE_CTX_get0_untrusted(const X509_STORE_CTX *ctx);
+void X509_STORE_CTX_set0_untrusted(X509_STORE_CTX *ctx, STACK_OF(X509) *sk);
+void X509_STORE_CTX_set_verify_cb(X509_STORE_CTX *ctx,
+                                  X509_STORE_CTX_verify_cb verify);
+X509_STORE_CTX_verify_cb X509_STORE_CTX_get_verify_cb(const X509_STORE_CTX *ctx);
+X509_STORE_CTX_verify_fn X509_STORE_CTX_get_verify(const X509_STORE_CTX *ctx);
+X509_STORE_CTX_get_issuer_fn X509_STORE_CTX_get_get_issuer(const X509_STORE_CTX *ctx);
+X509_STORE_CTX_check_issued_fn X509_STORE_CTX_get_check_issued(const X509_STORE_CTX *ctx);
+X509_STORE_CTX_check_revocation_fn X509_STORE_CTX_get_check_revocation(const X509_STORE_CTX *ctx);
+void X509_STORE_CTX_set_get_crl(X509_STORE_CTX *ctx,
+                                X509_STORE_CTX_get_crl_fn get_crl);
+X509_STORE_CTX_get_crl_fn X509_STORE_CTX_get_get_crl(const X509_STORE_CTX *ctx);
+X509_STORE_CTX_check_crl_fn X509_STORE_CTX_get_check_crl(const X509_STORE_CTX *ctx);
+X509_STORE_CTX_cert_crl_fn X509_STORE_CTX_get_cert_crl(const X509_STORE_CTX *ctx);
+X509_STORE_CTX_check_policy_fn X509_STORE_CTX_get_check_policy(const X509_STORE_CTX *ctx);
+X509_STORE_CTX_lookup_certs_fn X509_STORE_CTX_get_lookup_certs(const X509_STORE_CTX *ctx);
+X509_STORE_CTX_lookup_crls_fn X509_STORE_CTX_get_lookup_crls(const X509_STORE_CTX *ctx);
+X509_STORE_CTX_cleanup_fn X509_STORE_CTX_get_cleanup(const X509_STORE_CTX *ctx);
+
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+# define X509_STORE_CTX_get_chain X509_STORE_CTX_get0_chain
+# define X509_STORE_CTX_set_chain X509_STORE_CTX_set0_untrusted
+# define X509_STORE_CTX_trusted_stack X509_STORE_CTX_set0_trusted_stack
+# define X509_STORE_get_by_subject X509_STORE_CTX_get_by_subject
+# define X509_STORE_get1_certs X509_STORE_CTX_get1_certs
+# define X509_STORE_get1_crls X509_STORE_CTX_get1_crls
+/* the following macro is misspelled; use X509_STORE_get1_certs instead */
+# define X509_STORE_get1_cert X509_STORE_CTX_get1_certs
+/* the following macro is misspelled; use X509_STORE_get1_crls instead */
+# define X509_STORE_get1_crl X509_STORE_CTX_get1_crls
+#endif
+
+X509_LOOKUP *X509_STORE_add_lookup(X509_STORE *xs, X509_LOOKUP_METHOD *m);
+X509_LOOKUP_METHOD *X509_LOOKUP_hash_dir(void);
+X509_LOOKUP_METHOD *X509_LOOKUP_file(void);
+X509_LOOKUP_METHOD *X509_LOOKUP_store(void);
+
+typedef int (*X509_LOOKUP_ctrl_fn)(X509_LOOKUP *ctx, int cmd, const char *argc,
+                                   long argl, char **ret);
+typedef int (*X509_LOOKUP_ctrl_ex_fn)(
+    X509_LOOKUP *ctx, int cmd, const char *argc, long argl, char **ret,
+    OSSL_LIB_CTX *libctx, const char *propq);
+
+typedef int (*X509_LOOKUP_get_by_subject_fn)(X509_LOOKUP *ctx,
+                                             X509_LOOKUP_TYPE type,
+                                             const X509_NAME *name,
+                                             X509_OBJECT *ret);
+typedef int (*X509_LOOKUP_get_by_subject_ex_fn)(X509_LOOKUP *ctx,
+                                                         X509_LOOKUP_TYPE type,
+                                                         const X509_NAME *name,
+                                                         X509_OBJECT *ret,
+                                                         OSSL_LIB_CTX *libctx,
+                                                         const char *propq);
+typedef int (*X509_LOOKUP_get_by_issuer_serial_fn)(X509_LOOKUP *ctx,
+                                                   X509_LOOKUP_TYPE type,
+                                                   const X509_NAME *name,
+                                                   const ASN1_INTEGER *serial,
+                                                   X509_OBJECT *ret);
+typedef int (*X509_LOOKUP_get_by_fingerprint_fn)(X509_LOOKUP *ctx,
+                                                 X509_LOOKUP_TYPE type,
+                                                 const unsigned char* bytes,
+                                                 int len,
+                                                 X509_OBJECT *ret);
+typedef int (*X509_LOOKUP_get_by_alias_fn)(X509_LOOKUP *ctx,
+                                           X509_LOOKUP_TYPE type,
+                                           const char *str,
+                                           int len,
+                                           X509_OBJECT *ret);
+
+X509_LOOKUP_METHOD *X509_LOOKUP_meth_new(const char *name);
+void X509_LOOKUP_meth_free(X509_LOOKUP_METHOD *method);
+
+int X509_LOOKUP_meth_set_new_item(X509_LOOKUP_METHOD *method,
+                                  int (*new_item) (X509_LOOKUP *ctx));
+int (*X509_LOOKUP_meth_get_new_item(const X509_LOOKUP_METHOD* method))
+    (X509_LOOKUP *ctx);
+
+int X509_LOOKUP_meth_set_free(X509_LOOKUP_METHOD *method,
+                              void (*free_fn) (X509_LOOKUP *ctx));
+void (*X509_LOOKUP_meth_get_free(const X509_LOOKUP_METHOD* method))
+    (X509_LOOKUP *ctx);
+
+int X509_LOOKUP_meth_set_init(X509_LOOKUP_METHOD *method,
+                              int (*init) (X509_LOOKUP *ctx));
+int (*X509_LOOKUP_meth_get_init(const X509_LOOKUP_METHOD* method))
+    (X509_LOOKUP *ctx);
+
+int X509_LOOKUP_meth_set_shutdown(X509_LOOKUP_METHOD *method,
+                                  int (*shutdown) (X509_LOOKUP *ctx));
+int (*X509_LOOKUP_meth_get_shutdown(const X509_LOOKUP_METHOD* method))
+    (X509_LOOKUP *ctx);
+
+int X509_LOOKUP_meth_set_ctrl(X509_LOOKUP_METHOD *method,
+                              X509_LOOKUP_ctrl_fn ctrl_fn);
+X509_LOOKUP_ctrl_fn X509_LOOKUP_meth_get_ctrl(const X509_LOOKUP_METHOD *method);
+
+int X509_LOOKUP_meth_set_get_by_subject(X509_LOOKUP_METHOD *method,
+                                        X509_LOOKUP_get_by_subject_fn fn);
+X509_LOOKUP_get_by_subject_fn X509_LOOKUP_meth_get_get_by_subject(
+    const X509_LOOKUP_METHOD *method);
+
+int X509_LOOKUP_meth_set_get_by_issuer_serial(X509_LOOKUP_METHOD *method,
+    X509_LOOKUP_get_by_issuer_serial_fn fn);
+X509_LOOKUP_get_by_issuer_serial_fn X509_LOOKUP_meth_get_get_by_issuer_serial(
+    const X509_LOOKUP_METHOD *method);
+
+int X509_LOOKUP_meth_set_get_by_fingerprint(X509_LOOKUP_METHOD *method,
+    X509_LOOKUP_get_by_fingerprint_fn fn);
+X509_LOOKUP_get_by_fingerprint_fn X509_LOOKUP_meth_get_get_by_fingerprint(
+    const X509_LOOKUP_METHOD *method);
+
+int X509_LOOKUP_meth_set_get_by_alias(X509_LOOKUP_METHOD *method,
+                                      X509_LOOKUP_get_by_alias_fn fn);
+X509_LOOKUP_get_by_alias_fn X509_LOOKUP_meth_get_get_by_alias(
+    const X509_LOOKUP_METHOD *method);
+
+
+int X509_STORE_add_cert(X509_STORE *xs, X509 *x);
+int X509_STORE_add_crl(X509_STORE *xs, X509_CRL *x);
+
+int X509_STORE_CTX_get_by_subject(const X509_STORE_CTX *vs,
+                                  X509_LOOKUP_TYPE type,
+                                  const X509_NAME *name, X509_OBJECT *ret);
+X509_OBJECT *X509_STORE_CTX_get_obj_by_subject(X509_STORE_CTX *vs,
+                                               X509_LOOKUP_TYPE type,
+                                               const X509_NAME *name);
+
+int X509_LOOKUP_ctrl(X509_LOOKUP *ctx, int cmd, const char *argc,
+                     long argl, char **ret);
+int X509_LOOKUP_ctrl_ex(X509_LOOKUP *ctx, int cmd, const char *argc, long argl,
+                        char **ret, OSSL_LIB_CTX *libctx, const char *propq);
+
+int X509_load_cert_file(X509_LOOKUP *ctx, const char *file, int type);
+int X509_load_cert_file_ex(X509_LOOKUP *ctx, const char *file, int type,
+                           OSSL_LIB_CTX *libctx, const char *propq);
+int X509_load_crl_file(X509_LOOKUP *ctx, const char *file, int type);
+int X509_load_cert_crl_file(X509_LOOKUP *ctx, const char *file, int type);
+int X509_load_cert_crl_file_ex(X509_LOOKUP *ctx, const char *file, int type,
+                               OSSL_LIB_CTX *libctx, const char *propq);
+
+X509_LOOKUP *X509_LOOKUP_new(X509_LOOKUP_METHOD *method);
+void X509_LOOKUP_free(X509_LOOKUP *ctx);
+int X509_LOOKUP_init(X509_LOOKUP *ctx);
+int X509_LOOKUP_by_subject(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type,
+                           const X509_NAME *name, X509_OBJECT *ret);
+int X509_LOOKUP_by_subject_ex(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type,
+                              const X509_NAME *name, X509_OBJECT *ret,
+                              OSSL_LIB_CTX *libctx, const char *propq);
+int X509_LOOKUP_by_issuer_serial(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type,
+                                 const X509_NAME *name,
+                                 const ASN1_INTEGER *serial,
+                                 X509_OBJECT *ret);
+int X509_LOOKUP_by_fingerprint(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type,
+                               const unsigned char *bytes, int len,
+                               X509_OBJECT *ret);
+int X509_LOOKUP_by_alias(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type,
+                         const char *str, int len, X509_OBJECT *ret);
+int X509_LOOKUP_set_method_data(X509_LOOKUP *ctx, void *data);
+void *X509_LOOKUP_get_method_data(const X509_LOOKUP *ctx);
+X509_STORE *X509_LOOKUP_get_store(const X509_LOOKUP *ctx);
+int X509_LOOKUP_shutdown(X509_LOOKUP *ctx);
+
+int X509_STORE_load_file(X509_STORE *xs, const char *file);
+int X509_STORE_load_path(X509_STORE *xs, const char *path);
+int X509_STORE_load_store(X509_STORE *xs, const char *store);
+int X509_STORE_load_locations(X509_STORE *s, const char *file, const char *dir);
+int X509_STORE_set_default_paths(X509_STORE *xs);
+
+int X509_STORE_load_file_ex(X509_STORE *xs, const char *file,
+                            OSSL_LIB_CTX *libctx, const char *propq);
+int X509_STORE_load_store_ex(X509_STORE *xs, const char *store,
+                             OSSL_LIB_CTX *libctx, const char *propq);
+int X509_STORE_load_locations_ex(X509_STORE *xs,
+                                 const char *file, const char *dir,
+                                 OSSL_LIB_CTX *libctx, const char *propq);
+int X509_STORE_set_default_paths_ex(X509_STORE *xs,
+                                    OSSL_LIB_CTX *libctx, const char *propq);
+
+#define X509_STORE_CTX_get_ex_new_index(l, p, newf, dupf, freef) \
+    CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_X509_STORE_CTX, l, p, newf, dupf, freef)
+int X509_STORE_CTX_set_ex_data(X509_STORE_CTX *ctx, int idx, void *data);
+void *X509_STORE_CTX_get_ex_data(const X509_STORE_CTX *ctx, int idx);
+int X509_STORE_CTX_get_error(const X509_STORE_CTX *ctx);
+void X509_STORE_CTX_set_error(X509_STORE_CTX *ctx, int s);
+int X509_STORE_CTX_get_error_depth(const X509_STORE_CTX *ctx);
+void X509_STORE_CTX_set_error_depth(X509_STORE_CTX *ctx, int depth);
+X509 *X509_STORE_CTX_get_current_cert(const X509_STORE_CTX *ctx);
+void X509_STORE_CTX_set_current_cert(X509_STORE_CTX *ctx, X509 *x);
+X509 *X509_STORE_CTX_get0_current_issuer(const X509_STORE_CTX *ctx);
+X509_CRL *X509_STORE_CTX_get0_current_crl(const X509_STORE_CTX *ctx);
+X509_STORE_CTX *X509_STORE_CTX_get0_parent_ctx(const X509_STORE_CTX *ctx);
+STACK_OF(X509) *X509_STORE_CTX_get0_chain(const X509_STORE_CTX *ctx);
+STACK_OF(X509) *X509_STORE_CTX_get1_chain(const X509_STORE_CTX *ctx);
+void X509_STORE_CTX_set_cert(X509_STORE_CTX *ctx, X509 *target);
+void X509_STORE_CTX_set0_rpk(X509_STORE_CTX *ctx, EVP_PKEY *target);
+void X509_STORE_CTX_set0_verified_chain(X509_STORE_CTX *c, STACK_OF(X509) *sk);
+void X509_STORE_CTX_set0_crls(X509_STORE_CTX *ctx, STACK_OF(X509_CRL) *sk);
+int X509_STORE_CTX_set_purpose(X509_STORE_CTX *ctx, int purpose);
+int X509_STORE_CTX_set_trust(X509_STORE_CTX *ctx, int trust);
+int X509_STORE_CTX_purpose_inherit(X509_STORE_CTX *ctx, int def_purpose,
+                                   int purpose, int trust);
+void X509_STORE_CTX_set_flags(X509_STORE_CTX *ctx, unsigned long flags);
+void X509_STORE_CTX_set_time(X509_STORE_CTX *ctx, unsigned long flags,
+                             time_t t);
+void X509_STORE_CTX_set_current_reasons(X509_STORE_CTX *ctx,
+                                        unsigned int current_reasons);
+
+X509_POLICY_TREE *X509_STORE_CTX_get0_policy_tree(const X509_STORE_CTX *ctx);
+int X509_STORE_CTX_get_explicit_policy(const X509_STORE_CTX *ctx);
+int X509_STORE_CTX_get_num_untrusted(const X509_STORE_CTX *ctx);
+
+X509_VERIFY_PARAM *X509_STORE_CTX_get0_param(const X509_STORE_CTX *ctx);
+void X509_STORE_CTX_set0_param(X509_STORE_CTX *ctx, X509_VERIFY_PARAM *param);
+int X509_STORE_CTX_set_default(X509_STORE_CTX *ctx, const char *name);
+
+/*
+ * Bridge opacity barrier between libcrypt and libssl, also needed to support
+ * offline testing in test/danetest.c
+ */
+void X509_STORE_CTX_set0_dane(X509_STORE_CTX *ctx, SSL_DANE *dane);
+#define DANE_FLAG_NO_DANE_EE_NAMECHECKS (1L << 0)
+
+/* X509_VERIFY_PARAM functions */
+
+X509_VERIFY_PARAM *X509_VERIFY_PARAM_new(void);
+void X509_VERIFY_PARAM_free(X509_VERIFY_PARAM *param);
+int X509_VERIFY_PARAM_inherit(X509_VERIFY_PARAM *to,
+                              const X509_VERIFY_PARAM *from);
+int X509_VERIFY_PARAM_set1(X509_VERIFY_PARAM *to,
+                           const X509_VERIFY_PARAM *from);
+int X509_VERIFY_PARAM_set1_name(X509_VERIFY_PARAM *param, const char *name);
+int X509_VERIFY_PARAM_set_flags(X509_VERIFY_PARAM *param,
+                                unsigned long flags);
+int X509_VERIFY_PARAM_clear_flags(X509_VERIFY_PARAM *param,
+                                  unsigned long flags);
+unsigned long X509_VERIFY_PARAM_get_flags(const X509_VERIFY_PARAM *param);
+int X509_VERIFY_PARAM_set_purpose(X509_VERIFY_PARAM *param, int purpose);
+int X509_VERIFY_PARAM_set_trust(X509_VERIFY_PARAM *param, int trust);
+void X509_VERIFY_PARAM_set_depth(X509_VERIFY_PARAM *param, int depth);
+void X509_VERIFY_PARAM_set_auth_level(X509_VERIFY_PARAM *param, int auth_level);
+time_t X509_VERIFY_PARAM_get_time(const X509_VERIFY_PARAM *param);
+void X509_VERIFY_PARAM_set_time(X509_VERIFY_PARAM *param, time_t t);
+int X509_VERIFY_PARAM_add0_policy(X509_VERIFY_PARAM *param,
+                                  ASN1_OBJECT *policy);
+int X509_VERIFY_PARAM_set1_policies(X509_VERIFY_PARAM *param,
+                                    STACK_OF(ASN1_OBJECT) *policies);
+
+int X509_VERIFY_PARAM_set_inh_flags(X509_VERIFY_PARAM *param,
+                                    uint32_t flags);
+uint32_t X509_VERIFY_PARAM_get_inh_flags(const X509_VERIFY_PARAM *param);
+
+char *X509_VERIFY_PARAM_get0_host(X509_VERIFY_PARAM *param, int idx);
+int X509_VERIFY_PARAM_set1_host(X509_VERIFY_PARAM *param,
+                                const char *name, size_t namelen);
+int X509_VERIFY_PARAM_add1_host(X509_VERIFY_PARAM *param,
+                                const char *name, size_t namelen);
+void X509_VERIFY_PARAM_set_hostflags(X509_VERIFY_PARAM *param,
+                                     unsigned int flags);
+unsigned int X509_VERIFY_PARAM_get_hostflags(const X509_VERIFY_PARAM *param);
+char *X509_VERIFY_PARAM_get0_peername(const X509_VERIFY_PARAM *param);
+void X509_VERIFY_PARAM_move_peername(X509_VERIFY_PARAM *, X509_VERIFY_PARAM *);
+char *X509_VERIFY_PARAM_get0_email(X509_VERIFY_PARAM *param);
+int X509_VERIFY_PARAM_set1_email(X509_VERIFY_PARAM *param,
+                                 const char *email, size_t emaillen);
+char *X509_VERIFY_PARAM_get1_ip_asc(X509_VERIFY_PARAM *param);
+int X509_VERIFY_PARAM_set1_ip(X509_VERIFY_PARAM *param,
+                              const unsigned char *ip, size_t iplen);
+int X509_VERIFY_PARAM_set1_ip_asc(X509_VERIFY_PARAM *param,
+                                  const char *ipasc);
+
+int X509_VERIFY_PARAM_get_depth(const X509_VERIFY_PARAM *param);
+int X509_VERIFY_PARAM_get_auth_level(const X509_VERIFY_PARAM *param);
+const char *X509_VERIFY_PARAM_get0_name(const X509_VERIFY_PARAM *param);
+
+int X509_VERIFY_PARAM_add0_table(X509_VERIFY_PARAM *param);
+int X509_VERIFY_PARAM_get_count(void);
+const X509_VERIFY_PARAM *X509_VERIFY_PARAM_get0(int id);
+const X509_VERIFY_PARAM *X509_VERIFY_PARAM_lookup(const char *name);
+void X509_VERIFY_PARAM_table_cleanup(void);
+
+/* Non positive return values are errors */
+#define X509_PCY_TREE_FAILURE  -2 /* Failure to satisfy explicit policy */
+#define X509_PCY_TREE_INVALID  -1 /* Inconsistent or invalid extensions */
+#define X509_PCY_TREE_INTERNAL  0 /* Internal error, most likely malloc */
+
+/*
+ * Positive return values form a bit mask, all but the first are internal to
+ * the library and don't appear in results from X509_policy_check().
+ */
+#define X509_PCY_TREE_VALID     1 /* The policy tree is valid */
+#define X509_PCY_TREE_EMPTY     2 /* The policy tree is empty */
+#define X509_PCY_TREE_EXPLICIT  4 /* Explicit policy required */
+
+int X509_policy_check(X509_POLICY_TREE **ptree, int *pexplicit_policy,
+                      STACK_OF(X509) *certs,
+                      STACK_OF(ASN1_OBJECT) *policy_oids, unsigned int flags);
+
+void X509_policy_tree_free(X509_POLICY_TREE *tree);
+
+int X509_policy_tree_level_count(const X509_POLICY_TREE *tree);
+X509_POLICY_LEVEL *X509_policy_tree_get0_level(const X509_POLICY_TREE *tree,
+                                               int i);
+
+STACK_OF(X509_POLICY_NODE)
+    *X509_policy_tree_get0_policies(const X509_POLICY_TREE *tree);
+
+STACK_OF(X509_POLICY_NODE)
+    *X509_policy_tree_get0_user_policies(const X509_POLICY_TREE *tree);
+
+int X509_policy_level_node_count(X509_POLICY_LEVEL *level);
+
+X509_POLICY_NODE *X509_policy_level_get0_node(const X509_POLICY_LEVEL *level,
+                                              int i);
+
+const ASN1_OBJECT *X509_policy_node_get0_policy(const X509_POLICY_NODE *node);
+
+STACK_OF(POLICYQUALINFO)
+    *X509_policy_node_get0_qualifiers(const X509_POLICY_NODE *node);
+const X509_POLICY_NODE
+    *X509_policy_node_get0_parent(const X509_POLICY_NODE *node);
+
+#ifdef  __cplusplus
+}
+#endif
+#endif
diff --git a/src/include/openssl/x509err.h b/src/include/openssl/x509err.h
new file mode 100644
index 0000000..71b557a
--- /dev/null
+++ b/src/include/openssl/x509err.h
@@ -0,0 +1,69 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_X509ERR_H
+# define OPENSSL_X509ERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+
+/*
+ * X509 reason codes.
+ */
+# define X509_R_AKID_MISMATCH                             110
+# define X509_R_BAD_SELECTOR                              133
+# define X509_R_BAD_X509_FILETYPE                         100
+# define X509_R_BASE64_DECODE_ERROR                       118
+# define X509_R_CANT_CHECK_DH_KEY                         114
+# define X509_R_CERTIFICATE_VERIFICATION_FAILED           139
+# define X509_R_CERT_ALREADY_IN_HASH_TABLE                101
+# define X509_R_CRL_ALREADY_DELTA                         127
+# define X509_R_CRL_VERIFY_FAILURE                        131
+# define X509_R_DUPLICATE_ATTRIBUTE                       140
+# define X509_R_ERROR_GETTING_MD_BY_NID                   141
+# define X509_R_ERROR_USING_SIGINF_SET                    142
+# define X509_R_IDP_MISMATCH                              128
+# define X509_R_INVALID_ATTRIBUTES                        138
+# define X509_R_INVALID_DIRECTORY                         113
+# define X509_R_INVALID_DISTPOINT                         143
+# define X509_R_INVALID_FIELD_NAME                        119
+# define X509_R_INVALID_TRUST                             123
+# define X509_R_ISSUER_MISMATCH                           129
+# define X509_R_KEY_TYPE_MISMATCH                         115
+# define X509_R_KEY_VALUES_MISMATCH                       116
+# define X509_R_LOADING_CERT_DIR                          103
+# define X509_R_LOADING_DEFAULTS                          104
+# define X509_R_METHOD_NOT_SUPPORTED                      124
+# define X509_R_NAME_TOO_LONG                             134
+# define X509_R_NEWER_CRL_NOT_NEWER                       132
+# define X509_R_NO_CERTIFICATE_FOUND                      135
+# define X509_R_NO_CERTIFICATE_OR_CRL_FOUND               136
+# define X509_R_NO_CERT_SET_FOR_US_TO_VERIFY              105
+# define X509_R_NO_CRL_FOUND                              137
+# define X509_R_NO_CRL_NUMBER                             130
+# define X509_R_PUBLIC_KEY_DECODE_ERROR                   125
+# define X509_R_PUBLIC_KEY_ENCODE_ERROR                   126
+# define X509_R_SHOULD_RETRY                              106
+# define X509_R_UNABLE_TO_FIND_PARAMETERS_IN_CHAIN        107
+# define X509_R_UNABLE_TO_GET_CERTS_PUBLIC_KEY            108
+# define X509_R_UNKNOWN_KEY_TYPE                          117
+# define X509_R_UNKNOWN_NID                               109
+# define X509_R_UNKNOWN_PURPOSE_ID                        121
+# define X509_R_UNKNOWN_SIGID_ALGS                        144
+# define X509_R_UNKNOWN_TRUST_ID                          120
+# define X509_R_UNSUPPORTED_ALGORITHM                     111
+# define X509_R_WRONG_LOOKUP_TYPE                         112
+# define X509_R_WRONG_TYPE                                122
+
+#endif
diff --git a/src/include/openssl/x509v3.h b/src/include/openssl/x509v3.h
new file mode 100644
index 0000000..f8a1c35
--- /dev/null
+++ b/src/include/openssl/x509v3.h
@@ -0,0 +1,1454 @@
+/*
+ * WARNING: do not edit!
+ * Generated by makefile from include\openssl\x509v3.h.in
+ *
+ * Copyright 1999-2023 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+
+
+#ifndef OPENSSL_X509V3_H
+# define OPENSSL_X509V3_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_X509V3_H
+# endif
+
+# include <openssl/bio.h>
+# include <openssl/x509.h>
+# include <openssl/conf.h>
+# include <openssl/x509v3err.h>
+# ifndef OPENSSL_NO_STDIO
+#  include <stdio.h>
+# endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward reference */
+struct v3_ext_method;
+struct v3_ext_ctx;
+
+/* Useful typedefs */
+
+typedef void *(*X509V3_EXT_NEW)(void);
+typedef void (*X509V3_EXT_FREE) (void *);
+typedef void *(*X509V3_EXT_D2I)(void *, const unsigned char **, long);
+typedef int (*X509V3_EXT_I2D) (const void *, unsigned char **);
+typedef STACK_OF(CONF_VALUE) *
+    (*X509V3_EXT_I2V) (const struct v3_ext_method *method, void *ext,
+                       STACK_OF(CONF_VALUE) *extlist);
+typedef void *(*X509V3_EXT_V2I)(const struct v3_ext_method *method,
+                                struct v3_ext_ctx *ctx,
+                                STACK_OF(CONF_VALUE) *values);
+typedef char *(*X509V3_EXT_I2S)(const struct v3_ext_method *method,
+                                void *ext);
+typedef void *(*X509V3_EXT_S2I)(const struct v3_ext_method *method,
+                                struct v3_ext_ctx *ctx, const char *str);
+typedef int (*X509V3_EXT_I2R) (const struct v3_ext_method *method, void *ext,
+                               BIO *out, int indent);
+typedef void *(*X509V3_EXT_R2I)(const struct v3_ext_method *method,
+                                struct v3_ext_ctx *ctx, const char *str);
+
+/* V3 extension structure */
+
+struct v3_ext_method {
+    int ext_nid;
+    int ext_flags;
+/* If this is set the following four fields are ignored */
+    ASN1_ITEM_EXP *it;
+/* Old style ASN1 calls */
+    X509V3_EXT_NEW ext_new;
+    X509V3_EXT_FREE ext_free;
+    X509V3_EXT_D2I d2i;
+    X509V3_EXT_I2D i2d;
+/* The following pair is used for string extensions */
+    X509V3_EXT_I2S i2s;
+    X509V3_EXT_S2I s2i;
+/* The following pair is used for multi-valued extensions */
+    X509V3_EXT_I2V i2v;
+    X509V3_EXT_V2I v2i;
+/* The following are used for raw extensions */
+    X509V3_EXT_I2R i2r;
+    X509V3_EXT_R2I r2i;
+    void *usr_data;             /* Any extension specific data */
+};
+
+typedef struct X509V3_CONF_METHOD_st {
+    char *(*get_string) (void *db, const char *section, const char *value);
+    STACK_OF(CONF_VALUE) *(*get_section) (void *db, const char *section);
+    void (*free_string) (void *db, char *string);
+    void (*free_section) (void *db, STACK_OF(CONF_VALUE) *section);
+} X509V3_CONF_METHOD;
+
+/* Context specific info for producing X509 v3 extensions*/
+struct v3_ext_ctx {
+# define X509V3_CTX_TEST 0x1
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define CTX_TEST X509V3_CTX_TEST
+# endif
+# define X509V3_CTX_REPLACE 0x2
+    int flags;
+    X509 *issuer_cert;
+    X509 *subject_cert;
+    X509_REQ *subject_req;
+    X509_CRL *crl;
+    X509V3_CONF_METHOD *db_meth;
+    void *db;
+    EVP_PKEY *issuer_pkey;
+/* Maybe more here */
+};
+
+typedef struct v3_ext_method X509V3_EXT_METHOD;
+
+SKM_DEFINE_STACK_OF_INTERNAL(X509V3_EXT_METHOD, X509V3_EXT_METHOD, X509V3_EXT_METHOD)
+#define sk_X509V3_EXT_METHOD_num(sk) OPENSSL_sk_num(ossl_check_const_X509V3_EXT_METHOD_sk_type(sk))
+#define sk_X509V3_EXT_METHOD_value(sk, idx) ((X509V3_EXT_METHOD *)OPENSSL_sk_value(ossl_check_const_X509V3_EXT_METHOD_sk_type(sk), (idx)))
+#define sk_X509V3_EXT_METHOD_new(cmp) ((STACK_OF(X509V3_EXT_METHOD) *)OPENSSL_sk_new(ossl_check_X509V3_EXT_METHOD_compfunc_type(cmp)))
+#define sk_X509V3_EXT_METHOD_new_null() ((STACK_OF(X509V3_EXT_METHOD) *)OPENSSL_sk_new_null())
+#define sk_X509V3_EXT_METHOD_new_reserve(cmp, n) ((STACK_OF(X509V3_EXT_METHOD) *)OPENSSL_sk_new_reserve(ossl_check_X509V3_EXT_METHOD_compfunc_type(cmp), (n)))
+#define sk_X509V3_EXT_METHOD_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_X509V3_EXT_METHOD_sk_type(sk), (n))
+#define sk_X509V3_EXT_METHOD_free(sk) OPENSSL_sk_free(ossl_check_X509V3_EXT_METHOD_sk_type(sk))
+#define sk_X509V3_EXT_METHOD_zero(sk) OPENSSL_sk_zero(ossl_check_X509V3_EXT_METHOD_sk_type(sk))
+#define sk_X509V3_EXT_METHOD_delete(sk, i) ((X509V3_EXT_METHOD *)OPENSSL_sk_delete(ossl_check_X509V3_EXT_METHOD_sk_type(sk), (i)))
+#define sk_X509V3_EXT_METHOD_delete_ptr(sk, ptr) ((X509V3_EXT_METHOD *)OPENSSL_sk_delete_ptr(ossl_check_X509V3_EXT_METHOD_sk_type(sk), ossl_check_X509V3_EXT_METHOD_type(ptr)))
+#define sk_X509V3_EXT_METHOD_push(sk, ptr) OPENSSL_sk_push(ossl_check_X509V3_EXT_METHOD_sk_type(sk), ossl_check_X509V3_EXT_METHOD_type(ptr))
+#define sk_X509V3_EXT_METHOD_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_X509V3_EXT_METHOD_sk_type(sk), ossl_check_X509V3_EXT_METHOD_type(ptr))
+#define sk_X509V3_EXT_METHOD_pop(sk) ((X509V3_EXT_METHOD *)OPENSSL_sk_pop(ossl_check_X509V3_EXT_METHOD_sk_type(sk)))
+#define sk_X509V3_EXT_METHOD_shift(sk) ((X509V3_EXT_METHOD *)OPENSSL_sk_shift(ossl_check_X509V3_EXT_METHOD_sk_type(sk)))
+#define sk_X509V3_EXT_METHOD_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509V3_EXT_METHOD_sk_type(sk),ossl_check_X509V3_EXT_METHOD_freefunc_type(freefunc))
+#define sk_X509V3_EXT_METHOD_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_X509V3_EXT_METHOD_sk_type(sk), ossl_check_X509V3_EXT_METHOD_type(ptr), (idx))
+#define sk_X509V3_EXT_METHOD_set(sk, idx, ptr) ((X509V3_EXT_METHOD *)OPENSSL_sk_set(ossl_check_X509V3_EXT_METHOD_sk_type(sk), (idx), ossl_check_X509V3_EXT_METHOD_type(ptr)))
+#define sk_X509V3_EXT_METHOD_find(sk, ptr) OPENSSL_sk_find(ossl_check_X509V3_EXT_METHOD_sk_type(sk), ossl_check_X509V3_EXT_METHOD_type(ptr))
+#define sk_X509V3_EXT_METHOD_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_X509V3_EXT_METHOD_sk_type(sk), ossl_check_X509V3_EXT_METHOD_type(ptr))
+#define sk_X509V3_EXT_METHOD_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_X509V3_EXT_METHOD_sk_type(sk), ossl_check_X509V3_EXT_METHOD_type(ptr), pnum)
+#define sk_X509V3_EXT_METHOD_sort(sk) OPENSSL_sk_sort(ossl_check_X509V3_EXT_METHOD_sk_type(sk))
+#define sk_X509V3_EXT_METHOD_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_X509V3_EXT_METHOD_sk_type(sk))
+#define sk_X509V3_EXT_METHOD_dup(sk) ((STACK_OF(X509V3_EXT_METHOD) *)OPENSSL_sk_dup(ossl_check_const_X509V3_EXT_METHOD_sk_type(sk)))
+#define sk_X509V3_EXT_METHOD_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509V3_EXT_METHOD) *)OPENSSL_sk_deep_copy(ossl_check_const_X509V3_EXT_METHOD_sk_type(sk), ossl_check_X509V3_EXT_METHOD_copyfunc_type(copyfunc), ossl_check_X509V3_EXT_METHOD_freefunc_type(freefunc)))
+#define sk_X509V3_EXT_METHOD_set_cmp_func(sk, cmp) ((sk_X509V3_EXT_METHOD_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_X509V3_EXT_METHOD_sk_type(sk), ossl_check_X509V3_EXT_METHOD_compfunc_type(cmp)))
+
+
+/* ext_flags values */
+# define X509V3_EXT_DYNAMIC      0x1
+# define X509V3_EXT_CTX_DEP      0x2
+# define X509V3_EXT_MULTILINE    0x4
+
+typedef BIT_STRING_BITNAME ENUMERATED_NAMES;
+
+typedef struct BASIC_CONSTRAINTS_st {
+    int ca;
+    ASN1_INTEGER *pathlen;
+} BASIC_CONSTRAINTS;
+
+typedef struct PKEY_USAGE_PERIOD_st {
+    ASN1_GENERALIZEDTIME *notBefore;
+    ASN1_GENERALIZEDTIME *notAfter;
+} PKEY_USAGE_PERIOD;
+
+typedef struct otherName_st {
+    ASN1_OBJECT *type_id;
+    ASN1_TYPE *value;
+} OTHERNAME;
+
+typedef struct EDIPartyName_st {
+    ASN1_STRING *nameAssigner;
+    ASN1_STRING *partyName;
+} EDIPARTYNAME;
+
+typedef struct GENERAL_NAME_st {
+# define GEN_OTHERNAME   0
+# define GEN_EMAIL       1
+# define GEN_DNS         2
+# define GEN_X400        3
+# define GEN_DIRNAME     4
+# define GEN_EDIPARTY    5
+# define GEN_URI         6
+# define GEN_IPADD       7
+# define GEN_RID         8
+    int type;
+    union {
+        char *ptr;
+        OTHERNAME *otherName;   /* otherName */
+        ASN1_IA5STRING *rfc822Name;
+        ASN1_IA5STRING *dNSName;
+        ASN1_STRING *x400Address;
+        X509_NAME *directoryName;
+        EDIPARTYNAME *ediPartyName;
+        ASN1_IA5STRING *uniformResourceIdentifier;
+        ASN1_OCTET_STRING *iPAddress;
+        ASN1_OBJECT *registeredID;
+        /* Old names */
+        ASN1_OCTET_STRING *ip;  /* iPAddress */
+        X509_NAME *dirn;        /* dirn */
+        ASN1_IA5STRING *ia5;    /* rfc822Name, dNSName,
+                                 * uniformResourceIdentifier */
+        ASN1_OBJECT *rid;       /* registeredID */
+        ASN1_TYPE *other;       /* x400Address */
+    } d;
+} GENERAL_NAME;
+
+typedef struct ACCESS_DESCRIPTION_st {
+    ASN1_OBJECT *method;
+    GENERAL_NAME *location;
+} ACCESS_DESCRIPTION;
+
+SKM_DEFINE_STACK_OF_INTERNAL(ACCESS_DESCRIPTION, ACCESS_DESCRIPTION, ACCESS_DESCRIPTION)
+#define sk_ACCESS_DESCRIPTION_num(sk) OPENSSL_sk_num(ossl_check_const_ACCESS_DESCRIPTION_sk_type(sk))
+#define sk_ACCESS_DESCRIPTION_value(sk, idx) ((ACCESS_DESCRIPTION *)OPENSSL_sk_value(ossl_check_const_ACCESS_DESCRIPTION_sk_type(sk), (idx)))
+#define sk_ACCESS_DESCRIPTION_new(cmp) ((STACK_OF(ACCESS_DESCRIPTION) *)OPENSSL_sk_new(ossl_check_ACCESS_DESCRIPTION_compfunc_type(cmp)))
+#define sk_ACCESS_DESCRIPTION_new_null() ((STACK_OF(ACCESS_DESCRIPTION) *)OPENSSL_sk_new_null())
+#define sk_ACCESS_DESCRIPTION_new_reserve(cmp, n) ((STACK_OF(ACCESS_DESCRIPTION) *)OPENSSL_sk_new_reserve(ossl_check_ACCESS_DESCRIPTION_compfunc_type(cmp), (n)))
+#define sk_ACCESS_DESCRIPTION_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_ACCESS_DESCRIPTION_sk_type(sk), (n))
+#define sk_ACCESS_DESCRIPTION_free(sk) OPENSSL_sk_free(ossl_check_ACCESS_DESCRIPTION_sk_type(sk))
+#define sk_ACCESS_DESCRIPTION_zero(sk) OPENSSL_sk_zero(ossl_check_ACCESS_DESCRIPTION_sk_type(sk))
+#define sk_ACCESS_DESCRIPTION_delete(sk, i) ((ACCESS_DESCRIPTION *)OPENSSL_sk_delete(ossl_check_ACCESS_DESCRIPTION_sk_type(sk), (i)))
+#define sk_ACCESS_DESCRIPTION_delete_ptr(sk, ptr) ((ACCESS_DESCRIPTION *)OPENSSL_sk_delete_ptr(ossl_check_ACCESS_DESCRIPTION_sk_type(sk), ossl_check_ACCESS_DESCRIPTION_type(ptr)))
+#define sk_ACCESS_DESCRIPTION_push(sk, ptr) OPENSSL_sk_push(ossl_check_ACCESS_DESCRIPTION_sk_type(sk), ossl_check_ACCESS_DESCRIPTION_type(ptr))
+#define sk_ACCESS_DESCRIPTION_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_ACCESS_DESCRIPTION_sk_type(sk), ossl_check_ACCESS_DESCRIPTION_type(ptr))
+#define sk_ACCESS_DESCRIPTION_pop(sk) ((ACCESS_DESCRIPTION *)OPENSSL_sk_pop(ossl_check_ACCESS_DESCRIPTION_sk_type(sk)))
+#define sk_ACCESS_DESCRIPTION_shift(sk) ((ACCESS_DESCRIPTION *)OPENSSL_sk_shift(ossl_check_ACCESS_DESCRIPTION_sk_type(sk)))
+#define sk_ACCESS_DESCRIPTION_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ACCESS_DESCRIPTION_sk_type(sk),ossl_check_ACCESS_DESCRIPTION_freefunc_type(freefunc))
+#define sk_ACCESS_DESCRIPTION_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_ACCESS_DESCRIPTION_sk_type(sk), ossl_check_ACCESS_DESCRIPTION_type(ptr), (idx))
+#define sk_ACCESS_DESCRIPTION_set(sk, idx, ptr) ((ACCESS_DESCRIPTION *)OPENSSL_sk_set(ossl_check_ACCESS_DESCRIPTION_sk_type(sk), (idx), ossl_check_ACCESS_DESCRIPTION_type(ptr)))
+#define sk_ACCESS_DESCRIPTION_find(sk, ptr) OPENSSL_sk_find(ossl_check_ACCESS_DESCRIPTION_sk_type(sk), ossl_check_ACCESS_DESCRIPTION_type(ptr))
+#define sk_ACCESS_DESCRIPTION_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_ACCESS_DESCRIPTION_sk_type(sk), ossl_check_ACCESS_DESCRIPTION_type(ptr))
+#define sk_ACCESS_DESCRIPTION_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_ACCESS_DESCRIPTION_sk_type(sk), ossl_check_ACCESS_DESCRIPTION_type(ptr), pnum)
+#define sk_ACCESS_DESCRIPTION_sort(sk) OPENSSL_sk_sort(ossl_check_ACCESS_DESCRIPTION_sk_type(sk))
+#define sk_ACCESS_DESCRIPTION_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_ACCESS_DESCRIPTION_sk_type(sk))
+#define sk_ACCESS_DESCRIPTION_dup(sk) ((STACK_OF(ACCESS_DESCRIPTION) *)OPENSSL_sk_dup(ossl_check_const_ACCESS_DESCRIPTION_sk_type(sk)))
+#define sk_ACCESS_DESCRIPTION_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ACCESS_DESCRIPTION) *)OPENSSL_sk_deep_copy(ossl_check_const_ACCESS_DESCRIPTION_sk_type(sk), ossl_check_ACCESS_DESCRIPTION_copyfunc_type(copyfunc), ossl_check_ACCESS_DESCRIPTION_freefunc_type(freefunc)))
+#define sk_ACCESS_DESCRIPTION_set_cmp_func(sk, cmp) ((sk_ACCESS_DESCRIPTION_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_ACCESS_DESCRIPTION_sk_type(sk), ossl_check_ACCESS_DESCRIPTION_compfunc_type(cmp)))
+SKM_DEFINE_STACK_OF_INTERNAL(GENERAL_NAME, GENERAL_NAME, GENERAL_NAME)
+#define sk_GENERAL_NAME_num(sk) OPENSSL_sk_num(ossl_check_const_GENERAL_NAME_sk_type(sk))
+#define sk_GENERAL_NAME_value(sk, idx) ((GENERAL_NAME *)OPENSSL_sk_value(ossl_check_const_GENERAL_NAME_sk_type(sk), (idx)))
+#define sk_GENERAL_NAME_new(cmp) ((STACK_OF(GENERAL_NAME) *)OPENSSL_sk_new(ossl_check_GENERAL_NAME_compfunc_type(cmp)))
+#define sk_GENERAL_NAME_new_null() ((STACK_OF(GENERAL_NAME) *)OPENSSL_sk_new_null())
+#define sk_GENERAL_NAME_new_reserve(cmp, n) ((STACK_OF(GENERAL_NAME) *)OPENSSL_sk_new_reserve(ossl_check_GENERAL_NAME_compfunc_type(cmp), (n)))
+#define sk_GENERAL_NAME_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_GENERAL_NAME_sk_type(sk), (n))
+#define sk_GENERAL_NAME_free(sk) OPENSSL_sk_free(ossl_check_GENERAL_NAME_sk_type(sk))
+#define sk_GENERAL_NAME_zero(sk) OPENSSL_sk_zero(ossl_check_GENERAL_NAME_sk_type(sk))
+#define sk_GENERAL_NAME_delete(sk, i) ((GENERAL_NAME *)OPENSSL_sk_delete(ossl_check_GENERAL_NAME_sk_type(sk), (i)))
+#define sk_GENERAL_NAME_delete_ptr(sk, ptr) ((GENERAL_NAME *)OPENSSL_sk_delete_ptr(ossl_check_GENERAL_NAME_sk_type(sk), ossl_check_GENERAL_NAME_type(ptr)))
+#define sk_GENERAL_NAME_push(sk, ptr) OPENSSL_sk_push(ossl_check_GENERAL_NAME_sk_type(sk), ossl_check_GENERAL_NAME_type(ptr))
+#define sk_GENERAL_NAME_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_GENERAL_NAME_sk_type(sk), ossl_check_GENERAL_NAME_type(ptr))
+#define sk_GENERAL_NAME_pop(sk) ((GENERAL_NAME *)OPENSSL_sk_pop(ossl_check_GENERAL_NAME_sk_type(sk)))
+#define sk_GENERAL_NAME_shift(sk) ((GENERAL_NAME *)OPENSSL_sk_shift(ossl_check_GENERAL_NAME_sk_type(sk)))
+#define sk_GENERAL_NAME_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_GENERAL_NAME_sk_type(sk),ossl_check_GENERAL_NAME_freefunc_type(freefunc))
+#define sk_GENERAL_NAME_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_GENERAL_NAME_sk_type(sk), ossl_check_GENERAL_NAME_type(ptr), (idx))
+#define sk_GENERAL_NAME_set(sk, idx, ptr) ((GENERAL_NAME *)OPENSSL_sk_set(ossl_check_GENERAL_NAME_sk_type(sk), (idx), ossl_check_GENERAL_NAME_type(ptr)))
+#define sk_GENERAL_NAME_find(sk, ptr) OPENSSL_sk_find(ossl_check_GENERAL_NAME_sk_type(sk), ossl_check_GENERAL_NAME_type(ptr))
+#define sk_GENERAL_NAME_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_GENERAL_NAME_sk_type(sk), ossl_check_GENERAL_NAME_type(ptr))
+#define sk_GENERAL_NAME_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_GENERAL_NAME_sk_type(sk), ossl_check_GENERAL_NAME_type(ptr), pnum)
+#define sk_GENERAL_NAME_sort(sk) OPENSSL_sk_sort(ossl_check_GENERAL_NAME_sk_type(sk))
+#define sk_GENERAL_NAME_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_GENERAL_NAME_sk_type(sk))
+#define sk_GENERAL_NAME_dup(sk) ((STACK_OF(GENERAL_NAME) *)OPENSSL_sk_dup(ossl_check_const_GENERAL_NAME_sk_type(sk)))
+#define sk_GENERAL_NAME_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(GENERAL_NAME) *)OPENSSL_sk_deep_copy(ossl_check_const_GENERAL_NAME_sk_type(sk), ossl_check_GENERAL_NAME_copyfunc_type(copyfunc), ossl_check_GENERAL_NAME_freefunc_type(freefunc)))
+#define sk_GENERAL_NAME_set_cmp_func(sk, cmp) ((sk_GENERAL_NAME_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_GENERAL_NAME_sk_type(sk), ossl_check_GENERAL_NAME_compfunc_type(cmp)))
+
+
+typedef STACK_OF(ACCESS_DESCRIPTION) AUTHORITY_INFO_ACCESS;
+typedef STACK_OF(ASN1_OBJECT) EXTENDED_KEY_USAGE;
+typedef STACK_OF(ASN1_INTEGER) TLS_FEATURE;
+typedef STACK_OF(GENERAL_NAME) GENERAL_NAMES;
+
+SKM_DEFINE_STACK_OF_INTERNAL(GENERAL_NAMES, GENERAL_NAMES, GENERAL_NAMES)
+#define sk_GENERAL_NAMES_num(sk) OPENSSL_sk_num(ossl_check_const_GENERAL_NAMES_sk_type(sk))
+#define sk_GENERAL_NAMES_value(sk, idx) ((GENERAL_NAMES *)OPENSSL_sk_value(ossl_check_const_GENERAL_NAMES_sk_type(sk), (idx)))
+#define sk_GENERAL_NAMES_new(cmp) ((STACK_OF(GENERAL_NAMES) *)OPENSSL_sk_new(ossl_check_GENERAL_NAMES_compfunc_type(cmp)))
+#define sk_GENERAL_NAMES_new_null() ((STACK_OF(GENERAL_NAMES) *)OPENSSL_sk_new_null())
+#define sk_GENERAL_NAMES_new_reserve(cmp, n) ((STACK_OF(GENERAL_NAMES) *)OPENSSL_sk_new_reserve(ossl_check_GENERAL_NAMES_compfunc_type(cmp), (n)))
+#define sk_GENERAL_NAMES_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_GENERAL_NAMES_sk_type(sk), (n))
+#define sk_GENERAL_NAMES_free(sk) OPENSSL_sk_free(ossl_check_GENERAL_NAMES_sk_type(sk))
+#define sk_GENERAL_NAMES_zero(sk) OPENSSL_sk_zero(ossl_check_GENERAL_NAMES_sk_type(sk))
+#define sk_GENERAL_NAMES_delete(sk, i) ((GENERAL_NAMES *)OPENSSL_sk_delete(ossl_check_GENERAL_NAMES_sk_type(sk), (i)))
+#define sk_GENERAL_NAMES_delete_ptr(sk, ptr) ((GENERAL_NAMES *)OPENSSL_sk_delete_ptr(ossl_check_GENERAL_NAMES_sk_type(sk), ossl_check_GENERAL_NAMES_type(ptr)))
+#define sk_GENERAL_NAMES_push(sk, ptr) OPENSSL_sk_push(ossl_check_GENERAL_NAMES_sk_type(sk), ossl_check_GENERAL_NAMES_type(ptr))
+#define sk_GENERAL_NAMES_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_GENERAL_NAMES_sk_type(sk), ossl_check_GENERAL_NAMES_type(ptr))
+#define sk_GENERAL_NAMES_pop(sk) ((GENERAL_NAMES *)OPENSSL_sk_pop(ossl_check_GENERAL_NAMES_sk_type(sk)))
+#define sk_GENERAL_NAMES_shift(sk) ((GENERAL_NAMES *)OPENSSL_sk_shift(ossl_check_GENERAL_NAMES_sk_type(sk)))
+#define sk_GENERAL_NAMES_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_GENERAL_NAMES_sk_type(sk),ossl_check_GENERAL_NAMES_freefunc_type(freefunc))
+#define sk_GENERAL_NAMES_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_GENERAL_NAMES_sk_type(sk), ossl_check_GENERAL_NAMES_type(ptr), (idx))
+#define sk_GENERAL_NAMES_set(sk, idx, ptr) ((GENERAL_NAMES *)OPENSSL_sk_set(ossl_check_GENERAL_NAMES_sk_type(sk), (idx), ossl_check_GENERAL_NAMES_type(ptr)))
+#define sk_GENERAL_NAMES_find(sk, ptr) OPENSSL_sk_find(ossl_check_GENERAL_NAMES_sk_type(sk), ossl_check_GENERAL_NAMES_type(ptr))
+#define sk_GENERAL_NAMES_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_GENERAL_NAMES_sk_type(sk), ossl_check_GENERAL_NAMES_type(ptr))
+#define sk_GENERAL_NAMES_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_GENERAL_NAMES_sk_type(sk), ossl_check_GENERAL_NAMES_type(ptr), pnum)
+#define sk_GENERAL_NAMES_sort(sk) OPENSSL_sk_sort(ossl_check_GENERAL_NAMES_sk_type(sk))
+#define sk_GENERAL_NAMES_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_GENERAL_NAMES_sk_type(sk))
+#define sk_GENERAL_NAMES_dup(sk) ((STACK_OF(GENERAL_NAMES) *)OPENSSL_sk_dup(ossl_check_const_GENERAL_NAMES_sk_type(sk)))
+#define sk_GENERAL_NAMES_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(GENERAL_NAMES) *)OPENSSL_sk_deep_copy(ossl_check_const_GENERAL_NAMES_sk_type(sk), ossl_check_GENERAL_NAMES_copyfunc_type(copyfunc), ossl_check_GENERAL_NAMES_freefunc_type(freefunc)))
+#define sk_GENERAL_NAMES_set_cmp_func(sk, cmp) ((sk_GENERAL_NAMES_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_GENERAL_NAMES_sk_type(sk), ossl_check_GENERAL_NAMES_compfunc_type(cmp)))
+
+
+typedef struct DIST_POINT_NAME_st {
+    int type;
+    union {
+        GENERAL_NAMES *fullname;
+        STACK_OF(X509_NAME_ENTRY) *relativename;
+    } name;
+/* If relativename then this contains the full distribution point name */
+    X509_NAME *dpname;
+} DIST_POINT_NAME;
+/* All existing reasons */
+# define CRLDP_ALL_REASONS       0x807f
+
+# define CRL_REASON_NONE                         -1
+# define CRL_REASON_UNSPECIFIED                  0
+# define CRL_REASON_KEY_COMPROMISE               1
+# define CRL_REASON_CA_COMPROMISE                2
+# define CRL_REASON_AFFILIATION_CHANGED          3
+# define CRL_REASON_SUPERSEDED                   4
+# define CRL_REASON_CESSATION_OF_OPERATION       5
+# define CRL_REASON_CERTIFICATE_HOLD             6
+# define CRL_REASON_REMOVE_FROM_CRL              8
+# define CRL_REASON_PRIVILEGE_WITHDRAWN          9
+# define CRL_REASON_AA_COMPROMISE                10
+
+struct DIST_POINT_st {
+    DIST_POINT_NAME *distpoint;
+    ASN1_BIT_STRING *reasons;
+    GENERAL_NAMES *CRLissuer;
+    int dp_reasons;
+};
+
+SKM_DEFINE_STACK_OF_INTERNAL(DIST_POINT, DIST_POINT, DIST_POINT)
+#define sk_DIST_POINT_num(sk) OPENSSL_sk_num(ossl_check_const_DIST_POINT_sk_type(sk))
+#define sk_DIST_POINT_value(sk, idx) ((DIST_POINT *)OPENSSL_sk_value(ossl_check_const_DIST_POINT_sk_type(sk), (idx)))
+#define sk_DIST_POINT_new(cmp) ((STACK_OF(DIST_POINT) *)OPENSSL_sk_new(ossl_check_DIST_POINT_compfunc_type(cmp)))
+#define sk_DIST_POINT_new_null() ((STACK_OF(DIST_POINT) *)OPENSSL_sk_new_null())
+#define sk_DIST_POINT_new_reserve(cmp, n) ((STACK_OF(DIST_POINT) *)OPENSSL_sk_new_reserve(ossl_check_DIST_POINT_compfunc_type(cmp), (n)))
+#define sk_DIST_POINT_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_DIST_POINT_sk_type(sk), (n))
+#define sk_DIST_POINT_free(sk) OPENSSL_sk_free(ossl_check_DIST_POINT_sk_type(sk))
+#define sk_DIST_POINT_zero(sk) OPENSSL_sk_zero(ossl_check_DIST_POINT_sk_type(sk))
+#define sk_DIST_POINT_delete(sk, i) ((DIST_POINT *)OPENSSL_sk_delete(ossl_check_DIST_POINT_sk_type(sk), (i)))
+#define sk_DIST_POINT_delete_ptr(sk, ptr) ((DIST_POINT *)OPENSSL_sk_delete_ptr(ossl_check_DIST_POINT_sk_type(sk), ossl_check_DIST_POINT_type(ptr)))
+#define sk_DIST_POINT_push(sk, ptr) OPENSSL_sk_push(ossl_check_DIST_POINT_sk_type(sk), ossl_check_DIST_POINT_type(ptr))
+#define sk_DIST_POINT_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_DIST_POINT_sk_type(sk), ossl_check_DIST_POINT_type(ptr))
+#define sk_DIST_POINT_pop(sk) ((DIST_POINT *)OPENSSL_sk_pop(ossl_check_DIST_POINT_sk_type(sk)))
+#define sk_DIST_POINT_shift(sk) ((DIST_POINT *)OPENSSL_sk_shift(ossl_check_DIST_POINT_sk_type(sk)))
+#define sk_DIST_POINT_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_DIST_POINT_sk_type(sk),ossl_check_DIST_POINT_freefunc_type(freefunc))
+#define sk_DIST_POINT_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_DIST_POINT_sk_type(sk), ossl_check_DIST_POINT_type(ptr), (idx))
+#define sk_DIST_POINT_set(sk, idx, ptr) ((DIST_POINT *)OPENSSL_sk_set(ossl_check_DIST_POINT_sk_type(sk), (idx), ossl_check_DIST_POINT_type(ptr)))
+#define sk_DIST_POINT_find(sk, ptr) OPENSSL_sk_find(ossl_check_DIST_POINT_sk_type(sk), ossl_check_DIST_POINT_type(ptr))
+#define sk_DIST_POINT_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_DIST_POINT_sk_type(sk), ossl_check_DIST_POINT_type(ptr))
+#define sk_DIST_POINT_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_DIST_POINT_sk_type(sk), ossl_check_DIST_POINT_type(ptr), pnum)
+#define sk_DIST_POINT_sort(sk) OPENSSL_sk_sort(ossl_check_DIST_POINT_sk_type(sk))
+#define sk_DIST_POINT_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_DIST_POINT_sk_type(sk))
+#define sk_DIST_POINT_dup(sk) ((STACK_OF(DIST_POINT) *)OPENSSL_sk_dup(ossl_check_const_DIST_POINT_sk_type(sk)))
+#define sk_DIST_POINT_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(DIST_POINT) *)OPENSSL_sk_deep_copy(ossl_check_const_DIST_POINT_sk_type(sk), ossl_check_DIST_POINT_copyfunc_type(copyfunc), ossl_check_DIST_POINT_freefunc_type(freefunc)))
+#define sk_DIST_POINT_set_cmp_func(sk, cmp) ((sk_DIST_POINT_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_DIST_POINT_sk_type(sk), ossl_check_DIST_POINT_compfunc_type(cmp)))
+
+
+typedef STACK_OF(DIST_POINT) CRL_DIST_POINTS;
+
+struct AUTHORITY_KEYID_st {
+    ASN1_OCTET_STRING *keyid;
+    GENERAL_NAMES *issuer;
+    ASN1_INTEGER *serial;
+};
+
+/* Strong extranet structures */
+
+typedef struct SXNET_ID_st {
+    ASN1_INTEGER *zone;
+    ASN1_OCTET_STRING *user;
+} SXNETID;
+
+SKM_DEFINE_STACK_OF_INTERNAL(SXNETID, SXNETID, SXNETID)
+#define sk_SXNETID_num(sk) OPENSSL_sk_num(ossl_check_const_SXNETID_sk_type(sk))
+#define sk_SXNETID_value(sk, idx) ((SXNETID *)OPENSSL_sk_value(ossl_check_const_SXNETID_sk_type(sk), (idx)))
+#define sk_SXNETID_new(cmp) ((STACK_OF(SXNETID) *)OPENSSL_sk_new(ossl_check_SXNETID_compfunc_type(cmp)))
+#define sk_SXNETID_new_null() ((STACK_OF(SXNETID) *)OPENSSL_sk_new_null())
+#define sk_SXNETID_new_reserve(cmp, n) ((STACK_OF(SXNETID) *)OPENSSL_sk_new_reserve(ossl_check_SXNETID_compfunc_type(cmp), (n)))
+#define sk_SXNETID_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_SXNETID_sk_type(sk), (n))
+#define sk_SXNETID_free(sk) OPENSSL_sk_free(ossl_check_SXNETID_sk_type(sk))
+#define sk_SXNETID_zero(sk) OPENSSL_sk_zero(ossl_check_SXNETID_sk_type(sk))
+#define sk_SXNETID_delete(sk, i) ((SXNETID *)OPENSSL_sk_delete(ossl_check_SXNETID_sk_type(sk), (i)))
+#define sk_SXNETID_delete_ptr(sk, ptr) ((SXNETID *)OPENSSL_sk_delete_ptr(ossl_check_SXNETID_sk_type(sk), ossl_check_SXNETID_type(ptr)))
+#define sk_SXNETID_push(sk, ptr) OPENSSL_sk_push(ossl_check_SXNETID_sk_type(sk), ossl_check_SXNETID_type(ptr))
+#define sk_SXNETID_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_SXNETID_sk_type(sk), ossl_check_SXNETID_type(ptr))
+#define sk_SXNETID_pop(sk) ((SXNETID *)OPENSSL_sk_pop(ossl_check_SXNETID_sk_type(sk)))
+#define sk_SXNETID_shift(sk) ((SXNETID *)OPENSSL_sk_shift(ossl_check_SXNETID_sk_type(sk)))
+#define sk_SXNETID_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_SXNETID_sk_type(sk),ossl_check_SXNETID_freefunc_type(freefunc))
+#define sk_SXNETID_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_SXNETID_sk_type(sk), ossl_check_SXNETID_type(ptr), (idx))
+#define sk_SXNETID_set(sk, idx, ptr) ((SXNETID *)OPENSSL_sk_set(ossl_check_SXNETID_sk_type(sk), (idx), ossl_check_SXNETID_type(ptr)))
+#define sk_SXNETID_find(sk, ptr) OPENSSL_sk_find(ossl_check_SXNETID_sk_type(sk), ossl_check_SXNETID_type(ptr))
+#define sk_SXNETID_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_SXNETID_sk_type(sk), ossl_check_SXNETID_type(ptr))
+#define sk_SXNETID_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_SXNETID_sk_type(sk), ossl_check_SXNETID_type(ptr), pnum)
+#define sk_SXNETID_sort(sk) OPENSSL_sk_sort(ossl_check_SXNETID_sk_type(sk))
+#define sk_SXNETID_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_SXNETID_sk_type(sk))
+#define sk_SXNETID_dup(sk) ((STACK_OF(SXNETID) *)OPENSSL_sk_dup(ossl_check_const_SXNETID_sk_type(sk)))
+#define sk_SXNETID_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(SXNETID) *)OPENSSL_sk_deep_copy(ossl_check_const_SXNETID_sk_type(sk), ossl_check_SXNETID_copyfunc_type(copyfunc), ossl_check_SXNETID_freefunc_type(freefunc)))
+#define sk_SXNETID_set_cmp_func(sk, cmp) ((sk_SXNETID_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_SXNETID_sk_type(sk), ossl_check_SXNETID_compfunc_type(cmp)))
+
+
+
+typedef struct SXNET_st {
+    ASN1_INTEGER *version;
+    STACK_OF(SXNETID) *ids;
+} SXNET;
+
+typedef struct ISSUER_SIGN_TOOL_st {
+    ASN1_UTF8STRING *signTool;
+    ASN1_UTF8STRING *cATool;
+    ASN1_UTF8STRING *signToolCert;
+    ASN1_UTF8STRING *cAToolCert;
+} ISSUER_SIGN_TOOL;
+
+typedef struct NOTICEREF_st {
+    ASN1_STRING *organization;
+    STACK_OF(ASN1_INTEGER) *noticenos;
+} NOTICEREF;
+
+typedef struct USERNOTICE_st {
+    NOTICEREF *noticeref;
+    ASN1_STRING *exptext;
+} USERNOTICE;
+
+typedef struct POLICYQUALINFO_st {
+    ASN1_OBJECT *pqualid;
+    union {
+        ASN1_IA5STRING *cpsuri;
+        USERNOTICE *usernotice;
+        ASN1_TYPE *other;
+    } d;
+} POLICYQUALINFO;
+
+SKM_DEFINE_STACK_OF_INTERNAL(POLICYQUALINFO, POLICYQUALINFO, POLICYQUALINFO)
+#define sk_POLICYQUALINFO_num(sk) OPENSSL_sk_num(ossl_check_const_POLICYQUALINFO_sk_type(sk))
+#define sk_POLICYQUALINFO_value(sk, idx) ((POLICYQUALINFO *)OPENSSL_sk_value(ossl_check_const_POLICYQUALINFO_sk_type(sk), (idx)))
+#define sk_POLICYQUALINFO_new(cmp) ((STACK_OF(POLICYQUALINFO) *)OPENSSL_sk_new(ossl_check_POLICYQUALINFO_compfunc_type(cmp)))
+#define sk_POLICYQUALINFO_new_null() ((STACK_OF(POLICYQUALINFO) *)OPENSSL_sk_new_null())
+#define sk_POLICYQUALINFO_new_reserve(cmp, n) ((STACK_OF(POLICYQUALINFO) *)OPENSSL_sk_new_reserve(ossl_check_POLICYQUALINFO_compfunc_type(cmp), (n)))
+#define sk_POLICYQUALINFO_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_POLICYQUALINFO_sk_type(sk), (n))
+#define sk_POLICYQUALINFO_free(sk) OPENSSL_sk_free(ossl_check_POLICYQUALINFO_sk_type(sk))
+#define sk_POLICYQUALINFO_zero(sk) OPENSSL_sk_zero(ossl_check_POLICYQUALINFO_sk_type(sk))
+#define sk_POLICYQUALINFO_delete(sk, i) ((POLICYQUALINFO *)OPENSSL_sk_delete(ossl_check_POLICYQUALINFO_sk_type(sk), (i)))
+#define sk_POLICYQUALINFO_delete_ptr(sk, ptr) ((POLICYQUALINFO *)OPENSSL_sk_delete_ptr(ossl_check_POLICYQUALINFO_sk_type(sk), ossl_check_POLICYQUALINFO_type(ptr)))
+#define sk_POLICYQUALINFO_push(sk, ptr) OPENSSL_sk_push(ossl_check_POLICYQUALINFO_sk_type(sk), ossl_check_POLICYQUALINFO_type(ptr))
+#define sk_POLICYQUALINFO_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_POLICYQUALINFO_sk_type(sk), ossl_check_POLICYQUALINFO_type(ptr))
+#define sk_POLICYQUALINFO_pop(sk) ((POLICYQUALINFO *)OPENSSL_sk_pop(ossl_check_POLICYQUALINFO_sk_type(sk)))
+#define sk_POLICYQUALINFO_shift(sk) ((POLICYQUALINFO *)OPENSSL_sk_shift(ossl_check_POLICYQUALINFO_sk_type(sk)))
+#define sk_POLICYQUALINFO_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_POLICYQUALINFO_sk_type(sk),ossl_check_POLICYQUALINFO_freefunc_type(freefunc))
+#define sk_POLICYQUALINFO_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_POLICYQUALINFO_sk_type(sk), ossl_check_POLICYQUALINFO_type(ptr), (idx))
+#define sk_POLICYQUALINFO_set(sk, idx, ptr) ((POLICYQUALINFO *)OPENSSL_sk_set(ossl_check_POLICYQUALINFO_sk_type(sk), (idx), ossl_check_POLICYQUALINFO_type(ptr)))
+#define sk_POLICYQUALINFO_find(sk, ptr) OPENSSL_sk_find(ossl_check_POLICYQUALINFO_sk_type(sk), ossl_check_POLICYQUALINFO_type(ptr))
+#define sk_POLICYQUALINFO_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_POLICYQUALINFO_sk_type(sk), ossl_check_POLICYQUALINFO_type(ptr))
+#define sk_POLICYQUALINFO_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_POLICYQUALINFO_sk_type(sk), ossl_check_POLICYQUALINFO_type(ptr), pnum)
+#define sk_POLICYQUALINFO_sort(sk) OPENSSL_sk_sort(ossl_check_POLICYQUALINFO_sk_type(sk))
+#define sk_POLICYQUALINFO_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_POLICYQUALINFO_sk_type(sk))
+#define sk_POLICYQUALINFO_dup(sk) ((STACK_OF(POLICYQUALINFO) *)OPENSSL_sk_dup(ossl_check_const_POLICYQUALINFO_sk_type(sk)))
+#define sk_POLICYQUALINFO_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(POLICYQUALINFO) *)OPENSSL_sk_deep_copy(ossl_check_const_POLICYQUALINFO_sk_type(sk), ossl_check_POLICYQUALINFO_copyfunc_type(copyfunc), ossl_check_POLICYQUALINFO_freefunc_type(freefunc)))
+#define sk_POLICYQUALINFO_set_cmp_func(sk, cmp) ((sk_POLICYQUALINFO_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_POLICYQUALINFO_sk_type(sk), ossl_check_POLICYQUALINFO_compfunc_type(cmp)))
+
+
+
+typedef struct POLICYINFO_st {
+    ASN1_OBJECT *policyid;
+    STACK_OF(POLICYQUALINFO) *qualifiers;
+} POLICYINFO;
+
+SKM_DEFINE_STACK_OF_INTERNAL(POLICYINFO, POLICYINFO, POLICYINFO)
+#define sk_POLICYINFO_num(sk) OPENSSL_sk_num(ossl_check_const_POLICYINFO_sk_type(sk))
+#define sk_POLICYINFO_value(sk, idx) ((POLICYINFO *)OPENSSL_sk_value(ossl_check_const_POLICYINFO_sk_type(sk), (idx)))
+#define sk_POLICYINFO_new(cmp) ((STACK_OF(POLICYINFO) *)OPENSSL_sk_new(ossl_check_POLICYINFO_compfunc_type(cmp)))
+#define sk_POLICYINFO_new_null() ((STACK_OF(POLICYINFO) *)OPENSSL_sk_new_null())
+#define sk_POLICYINFO_new_reserve(cmp, n) ((STACK_OF(POLICYINFO) *)OPENSSL_sk_new_reserve(ossl_check_POLICYINFO_compfunc_type(cmp), (n)))
+#define sk_POLICYINFO_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_POLICYINFO_sk_type(sk), (n))
+#define sk_POLICYINFO_free(sk) OPENSSL_sk_free(ossl_check_POLICYINFO_sk_type(sk))
+#define sk_POLICYINFO_zero(sk) OPENSSL_sk_zero(ossl_check_POLICYINFO_sk_type(sk))
+#define sk_POLICYINFO_delete(sk, i) ((POLICYINFO *)OPENSSL_sk_delete(ossl_check_POLICYINFO_sk_type(sk), (i)))
+#define sk_POLICYINFO_delete_ptr(sk, ptr) ((POLICYINFO *)OPENSSL_sk_delete_ptr(ossl_check_POLICYINFO_sk_type(sk), ossl_check_POLICYINFO_type(ptr)))
+#define sk_POLICYINFO_push(sk, ptr) OPENSSL_sk_push(ossl_check_POLICYINFO_sk_type(sk), ossl_check_POLICYINFO_type(ptr))
+#define sk_POLICYINFO_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_POLICYINFO_sk_type(sk), ossl_check_POLICYINFO_type(ptr))
+#define sk_POLICYINFO_pop(sk) ((POLICYINFO *)OPENSSL_sk_pop(ossl_check_POLICYINFO_sk_type(sk)))
+#define sk_POLICYINFO_shift(sk) ((POLICYINFO *)OPENSSL_sk_shift(ossl_check_POLICYINFO_sk_type(sk)))
+#define sk_POLICYINFO_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_POLICYINFO_sk_type(sk),ossl_check_POLICYINFO_freefunc_type(freefunc))
+#define sk_POLICYINFO_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_POLICYINFO_sk_type(sk), ossl_check_POLICYINFO_type(ptr), (idx))
+#define sk_POLICYINFO_set(sk, idx, ptr) ((POLICYINFO *)OPENSSL_sk_set(ossl_check_POLICYINFO_sk_type(sk), (idx), ossl_check_POLICYINFO_type(ptr)))
+#define sk_POLICYINFO_find(sk, ptr) OPENSSL_sk_find(ossl_check_POLICYINFO_sk_type(sk), ossl_check_POLICYINFO_type(ptr))
+#define sk_POLICYINFO_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_POLICYINFO_sk_type(sk), ossl_check_POLICYINFO_type(ptr))
+#define sk_POLICYINFO_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_POLICYINFO_sk_type(sk), ossl_check_POLICYINFO_type(ptr), pnum)
+#define sk_POLICYINFO_sort(sk) OPENSSL_sk_sort(ossl_check_POLICYINFO_sk_type(sk))
+#define sk_POLICYINFO_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_POLICYINFO_sk_type(sk))
+#define sk_POLICYINFO_dup(sk) ((STACK_OF(POLICYINFO) *)OPENSSL_sk_dup(ossl_check_const_POLICYINFO_sk_type(sk)))
+#define sk_POLICYINFO_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(POLICYINFO) *)OPENSSL_sk_deep_copy(ossl_check_const_POLICYINFO_sk_type(sk), ossl_check_POLICYINFO_copyfunc_type(copyfunc), ossl_check_POLICYINFO_freefunc_type(freefunc)))
+#define sk_POLICYINFO_set_cmp_func(sk, cmp) ((sk_POLICYINFO_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_POLICYINFO_sk_type(sk), ossl_check_POLICYINFO_compfunc_type(cmp)))
+
+
+typedef STACK_OF(POLICYINFO) CERTIFICATEPOLICIES;
+
+typedef struct POLICY_MAPPING_st {
+    ASN1_OBJECT *issuerDomainPolicy;
+    ASN1_OBJECT *subjectDomainPolicy;
+} POLICY_MAPPING;
+
+SKM_DEFINE_STACK_OF_INTERNAL(POLICY_MAPPING, POLICY_MAPPING, POLICY_MAPPING)
+#define sk_POLICY_MAPPING_num(sk) OPENSSL_sk_num(ossl_check_const_POLICY_MAPPING_sk_type(sk))
+#define sk_POLICY_MAPPING_value(sk, idx) ((POLICY_MAPPING *)OPENSSL_sk_value(ossl_check_const_POLICY_MAPPING_sk_type(sk), (idx)))
+#define sk_POLICY_MAPPING_new(cmp) ((STACK_OF(POLICY_MAPPING) *)OPENSSL_sk_new(ossl_check_POLICY_MAPPING_compfunc_type(cmp)))
+#define sk_POLICY_MAPPING_new_null() ((STACK_OF(POLICY_MAPPING) *)OPENSSL_sk_new_null())
+#define sk_POLICY_MAPPING_new_reserve(cmp, n) ((STACK_OF(POLICY_MAPPING) *)OPENSSL_sk_new_reserve(ossl_check_POLICY_MAPPING_compfunc_type(cmp), (n)))
+#define sk_POLICY_MAPPING_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_POLICY_MAPPING_sk_type(sk), (n))
+#define sk_POLICY_MAPPING_free(sk) OPENSSL_sk_free(ossl_check_POLICY_MAPPING_sk_type(sk))
+#define sk_POLICY_MAPPING_zero(sk) OPENSSL_sk_zero(ossl_check_POLICY_MAPPING_sk_type(sk))
+#define sk_POLICY_MAPPING_delete(sk, i) ((POLICY_MAPPING *)OPENSSL_sk_delete(ossl_check_POLICY_MAPPING_sk_type(sk), (i)))
+#define sk_POLICY_MAPPING_delete_ptr(sk, ptr) ((POLICY_MAPPING *)OPENSSL_sk_delete_ptr(ossl_check_POLICY_MAPPING_sk_type(sk), ossl_check_POLICY_MAPPING_type(ptr)))
+#define sk_POLICY_MAPPING_push(sk, ptr) OPENSSL_sk_push(ossl_check_POLICY_MAPPING_sk_type(sk), ossl_check_POLICY_MAPPING_type(ptr))
+#define sk_POLICY_MAPPING_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_POLICY_MAPPING_sk_type(sk), ossl_check_POLICY_MAPPING_type(ptr))
+#define sk_POLICY_MAPPING_pop(sk) ((POLICY_MAPPING *)OPENSSL_sk_pop(ossl_check_POLICY_MAPPING_sk_type(sk)))
+#define sk_POLICY_MAPPING_shift(sk) ((POLICY_MAPPING *)OPENSSL_sk_shift(ossl_check_POLICY_MAPPING_sk_type(sk)))
+#define sk_POLICY_MAPPING_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_POLICY_MAPPING_sk_type(sk),ossl_check_POLICY_MAPPING_freefunc_type(freefunc))
+#define sk_POLICY_MAPPING_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_POLICY_MAPPING_sk_type(sk), ossl_check_POLICY_MAPPING_type(ptr), (idx))
+#define sk_POLICY_MAPPING_set(sk, idx, ptr) ((POLICY_MAPPING *)OPENSSL_sk_set(ossl_check_POLICY_MAPPING_sk_type(sk), (idx), ossl_check_POLICY_MAPPING_type(ptr)))
+#define sk_POLICY_MAPPING_find(sk, ptr) OPENSSL_sk_find(ossl_check_POLICY_MAPPING_sk_type(sk), ossl_check_POLICY_MAPPING_type(ptr))
+#define sk_POLICY_MAPPING_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_POLICY_MAPPING_sk_type(sk), ossl_check_POLICY_MAPPING_type(ptr))
+#define sk_POLICY_MAPPING_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_POLICY_MAPPING_sk_type(sk), ossl_check_POLICY_MAPPING_type(ptr), pnum)
+#define sk_POLICY_MAPPING_sort(sk) OPENSSL_sk_sort(ossl_check_POLICY_MAPPING_sk_type(sk))
+#define sk_POLICY_MAPPING_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_POLICY_MAPPING_sk_type(sk))
+#define sk_POLICY_MAPPING_dup(sk) ((STACK_OF(POLICY_MAPPING) *)OPENSSL_sk_dup(ossl_check_const_POLICY_MAPPING_sk_type(sk)))
+#define sk_POLICY_MAPPING_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(POLICY_MAPPING) *)OPENSSL_sk_deep_copy(ossl_check_const_POLICY_MAPPING_sk_type(sk), ossl_check_POLICY_MAPPING_copyfunc_type(copyfunc), ossl_check_POLICY_MAPPING_freefunc_type(freefunc)))
+#define sk_POLICY_MAPPING_set_cmp_func(sk, cmp) ((sk_POLICY_MAPPING_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_POLICY_MAPPING_sk_type(sk), ossl_check_POLICY_MAPPING_compfunc_type(cmp)))
+
+
+typedef STACK_OF(POLICY_MAPPING) POLICY_MAPPINGS;
+
+typedef struct GENERAL_SUBTREE_st {
+    GENERAL_NAME *base;
+    ASN1_INTEGER *minimum;
+    ASN1_INTEGER *maximum;
+} GENERAL_SUBTREE;
+
+SKM_DEFINE_STACK_OF_INTERNAL(GENERAL_SUBTREE, GENERAL_SUBTREE, GENERAL_SUBTREE)
+#define sk_GENERAL_SUBTREE_num(sk) OPENSSL_sk_num(ossl_check_const_GENERAL_SUBTREE_sk_type(sk))
+#define sk_GENERAL_SUBTREE_value(sk, idx) ((GENERAL_SUBTREE *)OPENSSL_sk_value(ossl_check_const_GENERAL_SUBTREE_sk_type(sk), (idx)))
+#define sk_GENERAL_SUBTREE_new(cmp) ((STACK_OF(GENERAL_SUBTREE) *)OPENSSL_sk_new(ossl_check_GENERAL_SUBTREE_compfunc_type(cmp)))
+#define sk_GENERAL_SUBTREE_new_null() ((STACK_OF(GENERAL_SUBTREE) *)OPENSSL_sk_new_null())
+#define sk_GENERAL_SUBTREE_new_reserve(cmp, n) ((STACK_OF(GENERAL_SUBTREE) *)OPENSSL_sk_new_reserve(ossl_check_GENERAL_SUBTREE_compfunc_type(cmp), (n)))
+#define sk_GENERAL_SUBTREE_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_GENERAL_SUBTREE_sk_type(sk), (n))
+#define sk_GENERAL_SUBTREE_free(sk) OPENSSL_sk_free(ossl_check_GENERAL_SUBTREE_sk_type(sk))
+#define sk_GENERAL_SUBTREE_zero(sk) OPENSSL_sk_zero(ossl_check_GENERAL_SUBTREE_sk_type(sk))
+#define sk_GENERAL_SUBTREE_delete(sk, i) ((GENERAL_SUBTREE *)OPENSSL_sk_delete(ossl_check_GENERAL_SUBTREE_sk_type(sk), (i)))
+#define sk_GENERAL_SUBTREE_delete_ptr(sk, ptr) ((GENERAL_SUBTREE *)OPENSSL_sk_delete_ptr(ossl_check_GENERAL_SUBTREE_sk_type(sk), ossl_check_GENERAL_SUBTREE_type(ptr)))
+#define sk_GENERAL_SUBTREE_push(sk, ptr) OPENSSL_sk_push(ossl_check_GENERAL_SUBTREE_sk_type(sk), ossl_check_GENERAL_SUBTREE_type(ptr))
+#define sk_GENERAL_SUBTREE_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_GENERAL_SUBTREE_sk_type(sk), ossl_check_GENERAL_SUBTREE_type(ptr))
+#define sk_GENERAL_SUBTREE_pop(sk) ((GENERAL_SUBTREE *)OPENSSL_sk_pop(ossl_check_GENERAL_SUBTREE_sk_type(sk)))
+#define sk_GENERAL_SUBTREE_shift(sk) ((GENERAL_SUBTREE *)OPENSSL_sk_shift(ossl_check_GENERAL_SUBTREE_sk_type(sk)))
+#define sk_GENERAL_SUBTREE_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_GENERAL_SUBTREE_sk_type(sk),ossl_check_GENERAL_SUBTREE_freefunc_type(freefunc))
+#define sk_GENERAL_SUBTREE_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_GENERAL_SUBTREE_sk_type(sk), ossl_check_GENERAL_SUBTREE_type(ptr), (idx))
+#define sk_GENERAL_SUBTREE_set(sk, idx, ptr) ((GENERAL_SUBTREE *)OPENSSL_sk_set(ossl_check_GENERAL_SUBTREE_sk_type(sk), (idx), ossl_check_GENERAL_SUBTREE_type(ptr)))
+#define sk_GENERAL_SUBTREE_find(sk, ptr) OPENSSL_sk_find(ossl_check_GENERAL_SUBTREE_sk_type(sk), ossl_check_GENERAL_SUBTREE_type(ptr))
+#define sk_GENERAL_SUBTREE_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_GENERAL_SUBTREE_sk_type(sk), ossl_check_GENERAL_SUBTREE_type(ptr))
+#define sk_GENERAL_SUBTREE_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_GENERAL_SUBTREE_sk_type(sk), ossl_check_GENERAL_SUBTREE_type(ptr), pnum)
+#define sk_GENERAL_SUBTREE_sort(sk) OPENSSL_sk_sort(ossl_check_GENERAL_SUBTREE_sk_type(sk))
+#define sk_GENERAL_SUBTREE_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_GENERAL_SUBTREE_sk_type(sk))
+#define sk_GENERAL_SUBTREE_dup(sk) ((STACK_OF(GENERAL_SUBTREE) *)OPENSSL_sk_dup(ossl_check_const_GENERAL_SUBTREE_sk_type(sk)))
+#define sk_GENERAL_SUBTREE_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(GENERAL_SUBTREE) *)OPENSSL_sk_deep_copy(ossl_check_const_GENERAL_SUBTREE_sk_type(sk), ossl_check_GENERAL_SUBTREE_copyfunc_type(copyfunc), ossl_check_GENERAL_SUBTREE_freefunc_type(freefunc)))
+#define sk_GENERAL_SUBTREE_set_cmp_func(sk, cmp) ((sk_GENERAL_SUBTREE_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_GENERAL_SUBTREE_sk_type(sk), ossl_check_GENERAL_SUBTREE_compfunc_type(cmp)))
+
+
+struct NAME_CONSTRAINTS_st {
+    STACK_OF(GENERAL_SUBTREE) *permittedSubtrees;
+    STACK_OF(GENERAL_SUBTREE) *excludedSubtrees;
+};
+
+typedef struct POLICY_CONSTRAINTS_st {
+    ASN1_INTEGER *requireExplicitPolicy;
+    ASN1_INTEGER *inhibitPolicyMapping;
+} POLICY_CONSTRAINTS;
+
+/* Proxy certificate structures, see RFC 3820 */
+typedef struct PROXY_POLICY_st {
+    ASN1_OBJECT *policyLanguage;
+    ASN1_OCTET_STRING *policy;
+} PROXY_POLICY;
+
+typedef struct PROXY_CERT_INFO_EXTENSION_st {
+    ASN1_INTEGER *pcPathLengthConstraint;
+    PROXY_POLICY *proxyPolicy;
+} PROXY_CERT_INFO_EXTENSION;
+
+DECLARE_ASN1_FUNCTIONS(PROXY_POLICY)
+DECLARE_ASN1_FUNCTIONS(PROXY_CERT_INFO_EXTENSION)
+
+struct ISSUING_DIST_POINT_st {
+    DIST_POINT_NAME *distpoint;
+    int onlyuser;
+    int onlyCA;
+    ASN1_BIT_STRING *onlysomereasons;
+    int indirectCRL;
+    int onlyattr;
+};
+
+/* Values in idp_flags field */
+/* IDP present */
+# define IDP_PRESENT     0x1
+/* IDP values inconsistent */
+# define IDP_INVALID     0x2
+/* onlyuser true */
+# define IDP_ONLYUSER    0x4
+/* onlyCA true */
+# define IDP_ONLYCA      0x8
+/* onlyattr true */
+# define IDP_ONLYATTR    0x10
+/* indirectCRL true */
+# define IDP_INDIRECT    0x20
+/* onlysomereasons present */
+# define IDP_REASONS     0x40
+
+# define X509V3_conf_err(val) ERR_add_error_data(6, \
+                        "section:", (val)->section, \
+                        ",name:", (val)->name, ",value:", (val)->value)
+
+# define X509V3_set_ctx_test(ctx) \
+    X509V3_set_ctx(ctx, NULL, NULL, NULL, NULL, X509V3_CTX_TEST)
+# define X509V3_set_ctx_nodb(ctx) (ctx)->db = NULL;
+
+# define EXT_BITSTRING(nid, table) { nid, 0, ASN1_ITEM_ref(ASN1_BIT_STRING), \
+                        0,0,0,0, \
+                        0,0, \
+                        (X509V3_EXT_I2V)i2v_ASN1_BIT_STRING, \
+                        (X509V3_EXT_V2I)v2i_ASN1_BIT_STRING, \
+                        NULL, NULL, \
+                        table}
+
+# define EXT_IA5STRING(nid) { nid, 0, ASN1_ITEM_ref(ASN1_IA5STRING), \
+                        0,0,0,0, \
+                        (X509V3_EXT_I2S)i2s_ASN1_IA5STRING, \
+                        (X509V3_EXT_S2I)s2i_ASN1_IA5STRING, \
+                        0,0,0,0, \
+                        NULL}
+
+#define EXT_UTF8STRING(nid) { nid, 0, ASN1_ITEM_ref(ASN1_UTF8STRING), \
+                        0,0,0,0, \
+                        (X509V3_EXT_I2S)i2s_ASN1_UTF8STRING, \
+                        (X509V3_EXT_S2I)s2i_ASN1_UTF8STRING, \
+                        0,0,0,0, \
+                        NULL}
+
+# define EXT_END { -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
+
+/* X509_PURPOSE stuff */
+
+# define EXFLAG_BCONS            0x1
+# define EXFLAG_KUSAGE           0x2
+# define EXFLAG_XKUSAGE          0x4
+# define EXFLAG_NSCERT           0x8
+
+# define EXFLAG_CA               0x10
+# define EXFLAG_SI               0x20 /* self-issued, maybe not self-signed */
+# define EXFLAG_V1               0x40
+# define EXFLAG_INVALID          0x80
+/* EXFLAG_SET is set to indicate that some values have been precomputed */
+# define EXFLAG_SET              0x100
+# define EXFLAG_CRITICAL         0x200
+# define EXFLAG_PROXY            0x400
+
+# define EXFLAG_INVALID_POLICY   0x800
+# define EXFLAG_FRESHEST         0x1000
+# define EXFLAG_SS               0x2000 /* cert is apparently self-signed */
+
+# define EXFLAG_BCONS_CRITICAL   0x10000
+# define EXFLAG_AKID_CRITICAL    0x20000
+# define EXFLAG_SKID_CRITICAL    0x40000
+# define EXFLAG_SAN_CRITICAL     0x80000
+# define EXFLAG_NO_FINGERPRINT   0x100000
+
+# define KU_DIGITAL_SIGNATURE    0x0080
+# define KU_NON_REPUDIATION      0x0040
+# define KU_KEY_ENCIPHERMENT     0x0020
+# define KU_DATA_ENCIPHERMENT    0x0010
+# define KU_KEY_AGREEMENT        0x0008
+# define KU_KEY_CERT_SIGN        0x0004
+# define KU_CRL_SIGN             0x0002
+# define KU_ENCIPHER_ONLY        0x0001
+# define KU_DECIPHER_ONLY        0x8000
+
+# define NS_SSL_CLIENT           0x80
+# define NS_SSL_SERVER           0x40
+# define NS_SMIME                0x20
+# define NS_OBJSIGN              0x10
+# define NS_SSL_CA               0x04
+# define NS_SMIME_CA             0x02
+# define NS_OBJSIGN_CA           0x01
+# define NS_ANY_CA               (NS_SSL_CA|NS_SMIME_CA|NS_OBJSIGN_CA)
+
+# define XKU_SSL_SERVER          0x1
+# define XKU_SSL_CLIENT          0x2
+# define XKU_SMIME               0x4
+# define XKU_CODE_SIGN           0x8
+# define XKU_SGC                 0x10 /* Netscape or MS Server-Gated Crypto */
+# define XKU_OCSP_SIGN           0x20
+# define XKU_TIMESTAMP           0x40
+# define XKU_DVCS                0x80
+# define XKU_ANYEKU              0x100
+
+# define X509_PURPOSE_DYNAMIC    0x1
+# define X509_PURPOSE_DYNAMIC_NAME       0x2
+
+typedef struct x509_purpose_st {
+    int purpose;
+    int trust;                  /* Default trust ID */
+    int flags;
+    int (*check_purpose) (const struct x509_purpose_st *, const X509 *, int);
+    char *name;
+    char *sname;
+    void *usr_data;
+} X509_PURPOSE;
+
+SKM_DEFINE_STACK_OF_INTERNAL(X509_PURPOSE, X509_PURPOSE, X509_PURPOSE)
+#define sk_X509_PURPOSE_num(sk) OPENSSL_sk_num(ossl_check_const_X509_PURPOSE_sk_type(sk))
+#define sk_X509_PURPOSE_value(sk, idx) ((X509_PURPOSE *)OPENSSL_sk_value(ossl_check_const_X509_PURPOSE_sk_type(sk), (idx)))
+#define sk_X509_PURPOSE_new(cmp) ((STACK_OF(X509_PURPOSE) *)OPENSSL_sk_new(ossl_check_X509_PURPOSE_compfunc_type(cmp)))
+#define sk_X509_PURPOSE_new_null() ((STACK_OF(X509_PURPOSE) *)OPENSSL_sk_new_null())
+#define sk_X509_PURPOSE_new_reserve(cmp, n) ((STACK_OF(X509_PURPOSE) *)OPENSSL_sk_new_reserve(ossl_check_X509_PURPOSE_compfunc_type(cmp), (n)))
+#define sk_X509_PURPOSE_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_X509_PURPOSE_sk_type(sk), (n))
+#define sk_X509_PURPOSE_free(sk) OPENSSL_sk_free(ossl_check_X509_PURPOSE_sk_type(sk))
+#define sk_X509_PURPOSE_zero(sk) OPENSSL_sk_zero(ossl_check_X509_PURPOSE_sk_type(sk))
+#define sk_X509_PURPOSE_delete(sk, i) ((X509_PURPOSE *)OPENSSL_sk_delete(ossl_check_X509_PURPOSE_sk_type(sk), (i)))
+#define sk_X509_PURPOSE_delete_ptr(sk, ptr) ((X509_PURPOSE *)OPENSSL_sk_delete_ptr(ossl_check_X509_PURPOSE_sk_type(sk), ossl_check_X509_PURPOSE_type(ptr)))
+#define sk_X509_PURPOSE_push(sk, ptr) OPENSSL_sk_push(ossl_check_X509_PURPOSE_sk_type(sk), ossl_check_X509_PURPOSE_type(ptr))
+#define sk_X509_PURPOSE_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_X509_PURPOSE_sk_type(sk), ossl_check_X509_PURPOSE_type(ptr))
+#define sk_X509_PURPOSE_pop(sk) ((X509_PURPOSE *)OPENSSL_sk_pop(ossl_check_X509_PURPOSE_sk_type(sk)))
+#define sk_X509_PURPOSE_shift(sk) ((X509_PURPOSE *)OPENSSL_sk_shift(ossl_check_X509_PURPOSE_sk_type(sk)))
+#define sk_X509_PURPOSE_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_PURPOSE_sk_type(sk),ossl_check_X509_PURPOSE_freefunc_type(freefunc))
+#define sk_X509_PURPOSE_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_X509_PURPOSE_sk_type(sk), ossl_check_X509_PURPOSE_type(ptr), (idx))
+#define sk_X509_PURPOSE_set(sk, idx, ptr) ((X509_PURPOSE *)OPENSSL_sk_set(ossl_check_X509_PURPOSE_sk_type(sk), (idx), ossl_check_X509_PURPOSE_type(ptr)))
+#define sk_X509_PURPOSE_find(sk, ptr) OPENSSL_sk_find(ossl_check_X509_PURPOSE_sk_type(sk), ossl_check_X509_PURPOSE_type(ptr))
+#define sk_X509_PURPOSE_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_X509_PURPOSE_sk_type(sk), ossl_check_X509_PURPOSE_type(ptr))
+#define sk_X509_PURPOSE_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_X509_PURPOSE_sk_type(sk), ossl_check_X509_PURPOSE_type(ptr), pnum)
+#define sk_X509_PURPOSE_sort(sk) OPENSSL_sk_sort(ossl_check_X509_PURPOSE_sk_type(sk))
+#define sk_X509_PURPOSE_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_X509_PURPOSE_sk_type(sk))
+#define sk_X509_PURPOSE_dup(sk) ((STACK_OF(X509_PURPOSE) *)OPENSSL_sk_dup(ossl_check_const_X509_PURPOSE_sk_type(sk)))
+#define sk_X509_PURPOSE_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_PURPOSE) *)OPENSSL_sk_deep_copy(ossl_check_const_X509_PURPOSE_sk_type(sk), ossl_check_X509_PURPOSE_copyfunc_type(copyfunc), ossl_check_X509_PURPOSE_freefunc_type(freefunc)))
+#define sk_X509_PURPOSE_set_cmp_func(sk, cmp) ((sk_X509_PURPOSE_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_X509_PURPOSE_sk_type(sk), ossl_check_X509_PURPOSE_compfunc_type(cmp)))
+
+
+
+# define X509_PURPOSE_SSL_CLIENT         1
+# define X509_PURPOSE_SSL_SERVER         2
+# define X509_PURPOSE_NS_SSL_SERVER      3
+# define X509_PURPOSE_SMIME_SIGN         4
+# define X509_PURPOSE_SMIME_ENCRYPT      5
+# define X509_PURPOSE_CRL_SIGN           6
+# define X509_PURPOSE_ANY                7
+# define X509_PURPOSE_OCSP_HELPER        8
+# define X509_PURPOSE_TIMESTAMP_SIGN     9
+# define X509_PURPOSE_CODE_SIGN         10
+
+# define X509_PURPOSE_MIN                1
+# define X509_PURPOSE_MAX               10
+
+/* Flags for X509V3_EXT_print() */
+
+# define X509V3_EXT_UNKNOWN_MASK         (0xfL << 16)
+/* Return error for unknown extensions */
+# define X509V3_EXT_DEFAULT              0
+/* Print error for unknown extensions */
+# define X509V3_EXT_ERROR_UNKNOWN        (1L << 16)
+/* ASN1 parse unknown extensions */
+# define X509V3_EXT_PARSE_UNKNOWN        (2L << 16)
+/* BIO_dump unknown extensions */
+# define X509V3_EXT_DUMP_UNKNOWN         (3L << 16)
+
+/* Flags for X509V3_add1_i2d */
+
+# define X509V3_ADD_OP_MASK              0xfL
+# define X509V3_ADD_DEFAULT              0L
+# define X509V3_ADD_APPEND               1L
+# define X509V3_ADD_REPLACE              2L
+# define X509V3_ADD_REPLACE_EXISTING     3L
+# define X509V3_ADD_KEEP_EXISTING        4L
+# define X509V3_ADD_DELETE               5L
+# define X509V3_ADD_SILENT               0x10
+
+DECLARE_ASN1_FUNCTIONS(BASIC_CONSTRAINTS)
+
+DECLARE_ASN1_FUNCTIONS(SXNET)
+DECLARE_ASN1_FUNCTIONS(SXNETID)
+
+DECLARE_ASN1_FUNCTIONS(ISSUER_SIGN_TOOL)
+
+int SXNET_add_id_asc(SXNET **psx, const char *zone, const char *user, int userlen);
+int SXNET_add_id_ulong(SXNET **psx, unsigned long lzone, const char *user,
+                       int userlen);
+int SXNET_add_id_INTEGER(SXNET **psx, ASN1_INTEGER *izone, const char *user,
+                         int userlen);
+
+ASN1_OCTET_STRING *SXNET_get_id_asc(SXNET *sx, const char *zone);
+ASN1_OCTET_STRING *SXNET_get_id_ulong(SXNET *sx, unsigned long lzone);
+ASN1_OCTET_STRING *SXNET_get_id_INTEGER(SXNET *sx, ASN1_INTEGER *zone);
+
+DECLARE_ASN1_FUNCTIONS(AUTHORITY_KEYID)
+
+DECLARE_ASN1_FUNCTIONS(PKEY_USAGE_PERIOD)
+
+DECLARE_ASN1_FUNCTIONS(GENERAL_NAME)
+DECLARE_ASN1_DUP_FUNCTION(GENERAL_NAME)
+int GENERAL_NAME_cmp(GENERAL_NAME *a, GENERAL_NAME *b);
+
+ASN1_BIT_STRING *v2i_ASN1_BIT_STRING(X509V3_EXT_METHOD *method,
+                                     X509V3_CTX *ctx,
+                                     STACK_OF(CONF_VALUE) *nval);
+STACK_OF(CONF_VALUE) *i2v_ASN1_BIT_STRING(X509V3_EXT_METHOD *method,
+                                          ASN1_BIT_STRING *bits,
+                                          STACK_OF(CONF_VALUE) *extlist);
+char *i2s_ASN1_IA5STRING(X509V3_EXT_METHOD *method, ASN1_IA5STRING *ia5);
+ASN1_IA5STRING *s2i_ASN1_IA5STRING(X509V3_EXT_METHOD *method,
+                                   X509V3_CTX *ctx, const char *str);
+char *i2s_ASN1_UTF8STRING(X509V3_EXT_METHOD *method, ASN1_UTF8STRING *utf8);
+ASN1_UTF8STRING *s2i_ASN1_UTF8STRING(X509V3_EXT_METHOD *method,
+                                   X509V3_CTX *ctx, const char *str);
+
+STACK_OF(CONF_VALUE) *i2v_GENERAL_NAME(X509V3_EXT_METHOD *method,
+                                       GENERAL_NAME *gen,
+                                       STACK_OF(CONF_VALUE) *ret);
+int GENERAL_NAME_print(BIO *out, GENERAL_NAME *gen);
+
+DECLARE_ASN1_FUNCTIONS(GENERAL_NAMES)
+
+STACK_OF(CONF_VALUE) *i2v_GENERAL_NAMES(X509V3_EXT_METHOD *method,
+                                        GENERAL_NAMES *gen,
+                                        STACK_OF(CONF_VALUE) *extlist);
+GENERAL_NAMES *v2i_GENERAL_NAMES(const X509V3_EXT_METHOD *method,
+                                 X509V3_CTX *ctx, STACK_OF(CONF_VALUE) *nval);
+
+DECLARE_ASN1_FUNCTIONS(OTHERNAME)
+DECLARE_ASN1_FUNCTIONS(EDIPARTYNAME)
+int OTHERNAME_cmp(OTHERNAME *a, OTHERNAME *b);
+void GENERAL_NAME_set0_value(GENERAL_NAME *a, int type, void *value);
+void *GENERAL_NAME_get0_value(const GENERAL_NAME *a, int *ptype);
+int GENERAL_NAME_set0_othername(GENERAL_NAME *gen,
+                                ASN1_OBJECT *oid, ASN1_TYPE *value);
+int GENERAL_NAME_get0_otherName(const GENERAL_NAME *gen,
+                                ASN1_OBJECT **poid, ASN1_TYPE **pvalue);
+
+char *i2s_ASN1_OCTET_STRING(X509V3_EXT_METHOD *method,
+                            const ASN1_OCTET_STRING *ia5);
+ASN1_OCTET_STRING *s2i_ASN1_OCTET_STRING(X509V3_EXT_METHOD *method,
+                                         X509V3_CTX *ctx, const char *str);
+
+DECLARE_ASN1_FUNCTIONS(EXTENDED_KEY_USAGE)
+int i2a_ACCESS_DESCRIPTION(BIO *bp, const ACCESS_DESCRIPTION *a);
+
+DECLARE_ASN1_ALLOC_FUNCTIONS(TLS_FEATURE)
+
+DECLARE_ASN1_FUNCTIONS(CERTIFICATEPOLICIES)
+DECLARE_ASN1_FUNCTIONS(POLICYINFO)
+DECLARE_ASN1_FUNCTIONS(POLICYQUALINFO)
+DECLARE_ASN1_FUNCTIONS(USERNOTICE)
+DECLARE_ASN1_FUNCTIONS(NOTICEREF)
+
+DECLARE_ASN1_FUNCTIONS(CRL_DIST_POINTS)
+DECLARE_ASN1_FUNCTIONS(DIST_POINT)
+DECLARE_ASN1_FUNCTIONS(DIST_POINT_NAME)
+DECLARE_ASN1_FUNCTIONS(ISSUING_DIST_POINT)
+
+int DIST_POINT_set_dpname(DIST_POINT_NAME *dpn, const X509_NAME *iname);
+
+int NAME_CONSTRAINTS_check(X509 *x, NAME_CONSTRAINTS *nc);
+int NAME_CONSTRAINTS_check_CN(X509 *x, NAME_CONSTRAINTS *nc);
+
+DECLARE_ASN1_FUNCTIONS(ACCESS_DESCRIPTION)
+DECLARE_ASN1_FUNCTIONS(AUTHORITY_INFO_ACCESS)
+
+DECLARE_ASN1_ITEM(POLICY_MAPPING)
+DECLARE_ASN1_ALLOC_FUNCTIONS(POLICY_MAPPING)
+DECLARE_ASN1_ITEM(POLICY_MAPPINGS)
+
+DECLARE_ASN1_ITEM(GENERAL_SUBTREE)
+DECLARE_ASN1_ALLOC_FUNCTIONS(GENERAL_SUBTREE)
+
+DECLARE_ASN1_ITEM(NAME_CONSTRAINTS)
+DECLARE_ASN1_ALLOC_FUNCTIONS(NAME_CONSTRAINTS)
+
+DECLARE_ASN1_ALLOC_FUNCTIONS(POLICY_CONSTRAINTS)
+DECLARE_ASN1_ITEM(POLICY_CONSTRAINTS)
+
+GENERAL_NAME *a2i_GENERAL_NAME(GENERAL_NAME *out,
+                               const X509V3_EXT_METHOD *method,
+                               X509V3_CTX *ctx, int gen_type,
+                               const char *value, int is_nc);
+
+# ifdef OPENSSL_CONF_H
+GENERAL_NAME *v2i_GENERAL_NAME(const X509V3_EXT_METHOD *method,
+                               X509V3_CTX *ctx, CONF_VALUE *cnf);
+GENERAL_NAME *v2i_GENERAL_NAME_ex(GENERAL_NAME *out,
+                                  const X509V3_EXT_METHOD *method,
+                                  X509V3_CTX *ctx, CONF_VALUE *cnf,
+                                  int is_nc);
+
+void X509V3_conf_free(CONF_VALUE *val);
+
+X509_EXTENSION *X509V3_EXT_nconf_nid(CONF *conf, X509V3_CTX *ctx, int ext_nid,
+                                     const char *value);
+X509_EXTENSION *X509V3_EXT_nconf(CONF *conf, X509V3_CTX *ctx, const char *name,
+                                 const char *value);
+int X509V3_EXT_add_nconf_sk(CONF *conf, X509V3_CTX *ctx, const char *section,
+                            STACK_OF(X509_EXTENSION) **sk);
+int X509V3_EXT_add_nconf(CONF *conf, X509V3_CTX *ctx, const char *section,
+                         X509 *cert);
+int X509V3_EXT_REQ_add_nconf(CONF *conf, X509V3_CTX *ctx, const char *section,
+                             X509_REQ *req);
+int X509V3_EXT_CRL_add_nconf(CONF *conf, X509V3_CTX *ctx, const char *section,
+                             X509_CRL *crl);
+
+X509_EXTENSION *X509V3_EXT_conf_nid(LHASH_OF(CONF_VALUE) *conf,
+                                    X509V3_CTX *ctx, int ext_nid,
+                                    const char *value);
+X509_EXTENSION *X509V3_EXT_conf(LHASH_OF(CONF_VALUE) *conf, X509V3_CTX *ctx,
+                                const char *name, const char *value);
+int X509V3_EXT_add_conf(LHASH_OF(CONF_VALUE) *conf, X509V3_CTX *ctx,
+                        const char *section, X509 *cert);
+int X509V3_EXT_REQ_add_conf(LHASH_OF(CONF_VALUE) *conf, X509V3_CTX *ctx,
+                            const char *section, X509_REQ *req);
+int X509V3_EXT_CRL_add_conf(LHASH_OF(CONF_VALUE) *conf, X509V3_CTX *ctx,
+                            const char *section, X509_CRL *crl);
+
+int X509V3_add_value_bool_nf(const char *name, int asn1_bool,
+                             STACK_OF(CONF_VALUE) **extlist);
+int X509V3_get_value_bool(const CONF_VALUE *value, int *asn1_bool);
+int X509V3_get_value_int(const CONF_VALUE *value, ASN1_INTEGER **aint);
+void X509V3_set_nconf(X509V3_CTX *ctx, CONF *conf);
+void X509V3_set_conf_lhash(X509V3_CTX *ctx, LHASH_OF(CONF_VALUE) *lhash);
+# endif
+
+char *X509V3_get_string(X509V3_CTX *ctx, const char *name, const char *section);
+STACK_OF(CONF_VALUE) *X509V3_get_section(X509V3_CTX *ctx, const char *section);
+void X509V3_string_free(X509V3_CTX *ctx, char *str);
+void X509V3_section_free(X509V3_CTX *ctx, STACK_OF(CONF_VALUE) *section);
+void X509V3_set_ctx(X509V3_CTX *ctx, X509 *issuer, X509 *subject,
+                    X509_REQ *req, X509_CRL *crl, int flags);
+/* For API backward compatibility, this is separate from X509V3_set_ctx(): */
+int X509V3_set_issuer_pkey(X509V3_CTX *ctx, EVP_PKEY *pkey);
+
+int X509V3_add_value(const char *name, const char *value,
+                     STACK_OF(CONF_VALUE) **extlist);
+int X509V3_add_value_uchar(const char *name, const unsigned char *value,
+                           STACK_OF(CONF_VALUE) **extlist);
+int X509V3_add_value_bool(const char *name, int asn1_bool,
+                          STACK_OF(CONF_VALUE) **extlist);
+int X509V3_add_value_int(const char *name, const ASN1_INTEGER *aint,
+                         STACK_OF(CONF_VALUE) **extlist);
+char *i2s_ASN1_INTEGER(X509V3_EXT_METHOD *meth, const ASN1_INTEGER *aint);
+ASN1_INTEGER *s2i_ASN1_INTEGER(X509V3_EXT_METHOD *meth, const char *value);
+char *i2s_ASN1_ENUMERATED(X509V3_EXT_METHOD *meth, const ASN1_ENUMERATED *aint);
+char *i2s_ASN1_ENUMERATED_TABLE(X509V3_EXT_METHOD *meth,
+                                const ASN1_ENUMERATED *aint);
+int X509V3_EXT_add(X509V3_EXT_METHOD *ext);
+int X509V3_EXT_add_list(X509V3_EXT_METHOD *extlist);
+int X509V3_EXT_add_alias(int nid_to, int nid_from);
+void X509V3_EXT_cleanup(void);
+
+const X509V3_EXT_METHOD *X509V3_EXT_get(X509_EXTENSION *ext);
+const X509V3_EXT_METHOD *X509V3_EXT_get_nid(int nid);
+int X509V3_add_standard_extensions(void);
+STACK_OF(CONF_VALUE) *X509V3_parse_list(const char *line);
+void *X509V3_EXT_d2i(X509_EXTENSION *ext);
+void *X509V3_get_d2i(const STACK_OF(X509_EXTENSION) *x, int nid, int *crit,
+                     int *idx);
+
+X509_EXTENSION *X509V3_EXT_i2d(int ext_nid, int crit, void *ext_struc);
+int X509V3_add1_i2d(STACK_OF(X509_EXTENSION) **x, int nid, void *value,
+                    int crit, unsigned long flags);
+
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+/* The new declarations are in crypto.h, but the old ones were here. */
+# define hex_to_string OPENSSL_buf2hexstr
+# define string_to_hex OPENSSL_hexstr2buf
+#endif
+
+void X509V3_EXT_val_prn(BIO *out, STACK_OF(CONF_VALUE) *val, int indent,
+                        int ml);
+int X509V3_EXT_print(BIO *out, X509_EXTENSION *ext, unsigned long flag,
+                     int indent);
+#ifndef OPENSSL_NO_STDIO
+int X509V3_EXT_print_fp(FILE *out, X509_EXTENSION *ext, int flag, int indent);
+#endif
+int X509V3_extensions_print(BIO *out, const char *title,
+                            const STACK_OF(X509_EXTENSION) *exts,
+                            unsigned long flag, int indent);
+
+int X509_check_ca(X509 *x);
+int X509_check_purpose(X509 *x, int id, int ca);
+int X509_supported_extension(X509_EXTENSION *ex);
+int X509_PURPOSE_set(int *p, int purpose);
+int X509_check_issued(X509 *issuer, X509 *subject);
+int X509_check_akid(const X509 *issuer, const AUTHORITY_KEYID *akid);
+void X509_set_proxy_flag(X509 *x);
+void X509_set_proxy_pathlen(X509 *x, long l);
+long X509_get_proxy_pathlen(X509 *x);
+
+uint32_t X509_get_extension_flags(X509 *x);
+uint32_t X509_get_key_usage(X509 *x);
+uint32_t X509_get_extended_key_usage(X509 *x);
+const ASN1_OCTET_STRING *X509_get0_subject_key_id(X509 *x);
+const ASN1_OCTET_STRING *X509_get0_authority_key_id(X509 *x);
+const GENERAL_NAMES *X509_get0_authority_issuer(X509 *x);
+const ASN1_INTEGER *X509_get0_authority_serial(X509 *x);
+
+int X509_PURPOSE_get_count(void);
+X509_PURPOSE *X509_PURPOSE_get0(int idx);
+int X509_PURPOSE_get_by_sname(const char *sname);
+int X509_PURPOSE_get_by_id(int id);
+int X509_PURPOSE_add(int id, int trust, int flags,
+                     int (*ck) (const X509_PURPOSE *, const X509 *, int),
+                     const char *name, const char *sname, void *arg);
+char *X509_PURPOSE_get0_name(const X509_PURPOSE *xp);
+char *X509_PURPOSE_get0_sname(const X509_PURPOSE *xp);
+int X509_PURPOSE_get_trust(const X509_PURPOSE *xp);
+void X509_PURPOSE_cleanup(void);
+int X509_PURPOSE_get_id(const X509_PURPOSE *);
+
+STACK_OF(OPENSSL_STRING) *X509_get1_email(X509 *x);
+STACK_OF(OPENSSL_STRING) *X509_REQ_get1_email(X509_REQ *x);
+void X509_email_free(STACK_OF(OPENSSL_STRING) *sk);
+STACK_OF(OPENSSL_STRING) *X509_get1_ocsp(X509 *x);
+/* Flags for X509_check_* functions */
+
+/*
+ * Always check subject name for host match even if subject alt names present
+ */
+# define X509_CHECK_FLAG_ALWAYS_CHECK_SUBJECT    0x1
+/* Disable wildcard matching for dnsName fields and common name. */
+# define X509_CHECK_FLAG_NO_WILDCARDS    0x2
+/* Wildcards must not match a partial label. */
+# define X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS 0x4
+/* Allow (non-partial) wildcards to match multiple labels. */
+# define X509_CHECK_FLAG_MULTI_LABEL_WILDCARDS 0x8
+/* Constraint verifier subdomain patterns to match a single labels. */
+# define X509_CHECK_FLAG_SINGLE_LABEL_SUBDOMAINS 0x10
+/* Never check the subject CN */
+# define X509_CHECK_FLAG_NEVER_CHECK_SUBJECT    0x20
+/*
+ * Match reference identifiers starting with "." to any sub-domain.
+ * This is a non-public flag, turned on implicitly when the subject
+ * reference identity is a DNS name.
+ */
+# define _X509_CHECK_FLAG_DOT_SUBDOMAINS 0x8000
+
+int X509_check_host(X509 *x, const char *chk, size_t chklen,
+                    unsigned int flags, char **peername);
+int X509_check_email(X509 *x, const char *chk, size_t chklen,
+                     unsigned int flags);
+int X509_check_ip(X509 *x, const unsigned char *chk, size_t chklen,
+                  unsigned int flags);
+int X509_check_ip_asc(X509 *x, const char *ipasc, unsigned int flags);
+
+ASN1_OCTET_STRING *a2i_IPADDRESS(const char *ipasc);
+ASN1_OCTET_STRING *a2i_IPADDRESS_NC(const char *ipasc);
+int X509V3_NAME_from_section(X509_NAME *nm, STACK_OF(CONF_VALUE) *dn_sk,
+                             unsigned long chtype);
+
+void X509_POLICY_NODE_print(BIO *out, X509_POLICY_NODE *node, int indent);
+SKM_DEFINE_STACK_OF_INTERNAL(X509_POLICY_NODE, X509_POLICY_NODE, X509_POLICY_NODE)
+#define sk_X509_POLICY_NODE_num(sk) OPENSSL_sk_num(ossl_check_const_X509_POLICY_NODE_sk_type(sk))
+#define sk_X509_POLICY_NODE_value(sk, idx) ((X509_POLICY_NODE *)OPENSSL_sk_value(ossl_check_const_X509_POLICY_NODE_sk_type(sk), (idx)))
+#define sk_X509_POLICY_NODE_new(cmp) ((STACK_OF(X509_POLICY_NODE) *)OPENSSL_sk_new(ossl_check_X509_POLICY_NODE_compfunc_type(cmp)))
+#define sk_X509_POLICY_NODE_new_null() ((STACK_OF(X509_POLICY_NODE) *)OPENSSL_sk_new_null())
+#define sk_X509_POLICY_NODE_new_reserve(cmp, n) ((STACK_OF(X509_POLICY_NODE) *)OPENSSL_sk_new_reserve(ossl_check_X509_POLICY_NODE_compfunc_type(cmp), (n)))
+#define sk_X509_POLICY_NODE_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_X509_POLICY_NODE_sk_type(sk), (n))
+#define sk_X509_POLICY_NODE_free(sk) OPENSSL_sk_free(ossl_check_X509_POLICY_NODE_sk_type(sk))
+#define sk_X509_POLICY_NODE_zero(sk) OPENSSL_sk_zero(ossl_check_X509_POLICY_NODE_sk_type(sk))
+#define sk_X509_POLICY_NODE_delete(sk, i) ((X509_POLICY_NODE *)OPENSSL_sk_delete(ossl_check_X509_POLICY_NODE_sk_type(sk), (i)))
+#define sk_X509_POLICY_NODE_delete_ptr(sk, ptr) ((X509_POLICY_NODE *)OPENSSL_sk_delete_ptr(ossl_check_X509_POLICY_NODE_sk_type(sk), ossl_check_X509_POLICY_NODE_type(ptr)))
+#define sk_X509_POLICY_NODE_push(sk, ptr) OPENSSL_sk_push(ossl_check_X509_POLICY_NODE_sk_type(sk), ossl_check_X509_POLICY_NODE_type(ptr))
+#define sk_X509_POLICY_NODE_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_X509_POLICY_NODE_sk_type(sk), ossl_check_X509_POLICY_NODE_type(ptr))
+#define sk_X509_POLICY_NODE_pop(sk) ((X509_POLICY_NODE *)OPENSSL_sk_pop(ossl_check_X509_POLICY_NODE_sk_type(sk)))
+#define sk_X509_POLICY_NODE_shift(sk) ((X509_POLICY_NODE *)OPENSSL_sk_shift(ossl_check_X509_POLICY_NODE_sk_type(sk)))
+#define sk_X509_POLICY_NODE_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_POLICY_NODE_sk_type(sk),ossl_check_X509_POLICY_NODE_freefunc_type(freefunc))
+#define sk_X509_POLICY_NODE_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_X509_POLICY_NODE_sk_type(sk), ossl_check_X509_POLICY_NODE_type(ptr), (idx))
+#define sk_X509_POLICY_NODE_set(sk, idx, ptr) ((X509_POLICY_NODE *)OPENSSL_sk_set(ossl_check_X509_POLICY_NODE_sk_type(sk), (idx), ossl_check_X509_POLICY_NODE_type(ptr)))
+#define sk_X509_POLICY_NODE_find(sk, ptr) OPENSSL_sk_find(ossl_check_X509_POLICY_NODE_sk_type(sk), ossl_check_X509_POLICY_NODE_type(ptr))
+#define sk_X509_POLICY_NODE_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_X509_POLICY_NODE_sk_type(sk), ossl_check_X509_POLICY_NODE_type(ptr))
+#define sk_X509_POLICY_NODE_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_X509_POLICY_NODE_sk_type(sk), ossl_check_X509_POLICY_NODE_type(ptr), pnum)
+#define sk_X509_POLICY_NODE_sort(sk) OPENSSL_sk_sort(ossl_check_X509_POLICY_NODE_sk_type(sk))
+#define sk_X509_POLICY_NODE_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_X509_POLICY_NODE_sk_type(sk))
+#define sk_X509_POLICY_NODE_dup(sk) ((STACK_OF(X509_POLICY_NODE) *)OPENSSL_sk_dup(ossl_check_const_X509_POLICY_NODE_sk_type(sk)))
+#define sk_X509_POLICY_NODE_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_POLICY_NODE) *)OPENSSL_sk_deep_copy(ossl_check_const_X509_POLICY_NODE_sk_type(sk), ossl_check_X509_POLICY_NODE_copyfunc_type(copyfunc), ossl_check_X509_POLICY_NODE_freefunc_type(freefunc)))
+#define sk_X509_POLICY_NODE_set_cmp_func(sk, cmp) ((sk_X509_POLICY_NODE_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_X509_POLICY_NODE_sk_type(sk), ossl_check_X509_POLICY_NODE_compfunc_type(cmp)))
+
+
+
+#ifndef OPENSSL_NO_RFC3779
+typedef struct ASRange_st {
+    ASN1_INTEGER *min, *max;
+} ASRange;
+
+# define ASIdOrRange_id          0
+# define ASIdOrRange_range       1
+
+typedef struct ASIdOrRange_st {
+    int type;
+    union {
+        ASN1_INTEGER *id;
+        ASRange *range;
+    } u;
+} ASIdOrRange;
+
+SKM_DEFINE_STACK_OF_INTERNAL(ASIdOrRange, ASIdOrRange, ASIdOrRange)
+#define sk_ASIdOrRange_num(sk) OPENSSL_sk_num(ossl_check_const_ASIdOrRange_sk_type(sk))
+#define sk_ASIdOrRange_value(sk, idx) ((ASIdOrRange *)OPENSSL_sk_value(ossl_check_const_ASIdOrRange_sk_type(sk), (idx)))
+#define sk_ASIdOrRange_new(cmp) ((STACK_OF(ASIdOrRange) *)OPENSSL_sk_new(ossl_check_ASIdOrRange_compfunc_type(cmp)))
+#define sk_ASIdOrRange_new_null() ((STACK_OF(ASIdOrRange) *)OPENSSL_sk_new_null())
+#define sk_ASIdOrRange_new_reserve(cmp, n) ((STACK_OF(ASIdOrRange) *)OPENSSL_sk_new_reserve(ossl_check_ASIdOrRange_compfunc_type(cmp), (n)))
+#define sk_ASIdOrRange_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_ASIdOrRange_sk_type(sk), (n))
+#define sk_ASIdOrRange_free(sk) OPENSSL_sk_free(ossl_check_ASIdOrRange_sk_type(sk))
+#define sk_ASIdOrRange_zero(sk) OPENSSL_sk_zero(ossl_check_ASIdOrRange_sk_type(sk))
+#define sk_ASIdOrRange_delete(sk, i) ((ASIdOrRange *)OPENSSL_sk_delete(ossl_check_ASIdOrRange_sk_type(sk), (i)))
+#define sk_ASIdOrRange_delete_ptr(sk, ptr) ((ASIdOrRange *)OPENSSL_sk_delete_ptr(ossl_check_ASIdOrRange_sk_type(sk), ossl_check_ASIdOrRange_type(ptr)))
+#define sk_ASIdOrRange_push(sk, ptr) OPENSSL_sk_push(ossl_check_ASIdOrRange_sk_type(sk), ossl_check_ASIdOrRange_type(ptr))
+#define sk_ASIdOrRange_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_ASIdOrRange_sk_type(sk), ossl_check_ASIdOrRange_type(ptr))
+#define sk_ASIdOrRange_pop(sk) ((ASIdOrRange *)OPENSSL_sk_pop(ossl_check_ASIdOrRange_sk_type(sk)))
+#define sk_ASIdOrRange_shift(sk) ((ASIdOrRange *)OPENSSL_sk_shift(ossl_check_ASIdOrRange_sk_type(sk)))
+#define sk_ASIdOrRange_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ASIdOrRange_sk_type(sk),ossl_check_ASIdOrRange_freefunc_type(freefunc))
+#define sk_ASIdOrRange_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_ASIdOrRange_sk_type(sk), ossl_check_ASIdOrRange_type(ptr), (idx))
+#define sk_ASIdOrRange_set(sk, idx, ptr) ((ASIdOrRange *)OPENSSL_sk_set(ossl_check_ASIdOrRange_sk_type(sk), (idx), ossl_check_ASIdOrRange_type(ptr)))
+#define sk_ASIdOrRange_find(sk, ptr) OPENSSL_sk_find(ossl_check_ASIdOrRange_sk_type(sk), ossl_check_ASIdOrRange_type(ptr))
+#define sk_ASIdOrRange_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_ASIdOrRange_sk_type(sk), ossl_check_ASIdOrRange_type(ptr))
+#define sk_ASIdOrRange_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_ASIdOrRange_sk_type(sk), ossl_check_ASIdOrRange_type(ptr), pnum)
+#define sk_ASIdOrRange_sort(sk) OPENSSL_sk_sort(ossl_check_ASIdOrRange_sk_type(sk))
+#define sk_ASIdOrRange_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_ASIdOrRange_sk_type(sk))
+#define sk_ASIdOrRange_dup(sk) ((STACK_OF(ASIdOrRange) *)OPENSSL_sk_dup(ossl_check_const_ASIdOrRange_sk_type(sk)))
+#define sk_ASIdOrRange_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ASIdOrRange) *)OPENSSL_sk_deep_copy(ossl_check_const_ASIdOrRange_sk_type(sk), ossl_check_ASIdOrRange_copyfunc_type(copyfunc), ossl_check_ASIdOrRange_freefunc_type(freefunc)))
+#define sk_ASIdOrRange_set_cmp_func(sk, cmp) ((sk_ASIdOrRange_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_ASIdOrRange_sk_type(sk), ossl_check_ASIdOrRange_compfunc_type(cmp)))
+
+
+typedef STACK_OF(ASIdOrRange) ASIdOrRanges;
+
+# define ASIdentifierChoice_inherit              0
+# define ASIdentifierChoice_asIdsOrRanges        1
+
+typedef struct ASIdentifierChoice_st {
+    int type;
+    union {
+        ASN1_NULL *inherit;
+        ASIdOrRanges *asIdsOrRanges;
+    } u;
+} ASIdentifierChoice;
+
+typedef struct ASIdentifiers_st {
+    ASIdentifierChoice *asnum, *rdi;
+} ASIdentifiers;
+
+DECLARE_ASN1_FUNCTIONS(ASRange)
+DECLARE_ASN1_FUNCTIONS(ASIdOrRange)
+DECLARE_ASN1_FUNCTIONS(ASIdentifierChoice)
+DECLARE_ASN1_FUNCTIONS(ASIdentifiers)
+
+typedef struct IPAddressRange_st {
+    ASN1_BIT_STRING *min, *max;
+} IPAddressRange;
+
+# define IPAddressOrRange_addressPrefix  0
+# define IPAddressOrRange_addressRange   1
+
+typedef struct IPAddressOrRange_st {
+    int type;
+    union {
+        ASN1_BIT_STRING *addressPrefix;
+        IPAddressRange *addressRange;
+    } u;
+} IPAddressOrRange;
+
+SKM_DEFINE_STACK_OF_INTERNAL(IPAddressOrRange, IPAddressOrRange, IPAddressOrRange)
+#define sk_IPAddressOrRange_num(sk) OPENSSL_sk_num(ossl_check_const_IPAddressOrRange_sk_type(sk))
+#define sk_IPAddressOrRange_value(sk, idx) ((IPAddressOrRange *)OPENSSL_sk_value(ossl_check_const_IPAddressOrRange_sk_type(sk), (idx)))
+#define sk_IPAddressOrRange_new(cmp) ((STACK_OF(IPAddressOrRange) *)OPENSSL_sk_new(ossl_check_IPAddressOrRange_compfunc_type(cmp)))
+#define sk_IPAddressOrRange_new_null() ((STACK_OF(IPAddressOrRange) *)OPENSSL_sk_new_null())
+#define sk_IPAddressOrRange_new_reserve(cmp, n) ((STACK_OF(IPAddressOrRange) *)OPENSSL_sk_new_reserve(ossl_check_IPAddressOrRange_compfunc_type(cmp), (n)))
+#define sk_IPAddressOrRange_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_IPAddressOrRange_sk_type(sk), (n))
+#define sk_IPAddressOrRange_free(sk) OPENSSL_sk_free(ossl_check_IPAddressOrRange_sk_type(sk))
+#define sk_IPAddressOrRange_zero(sk) OPENSSL_sk_zero(ossl_check_IPAddressOrRange_sk_type(sk))
+#define sk_IPAddressOrRange_delete(sk, i) ((IPAddressOrRange *)OPENSSL_sk_delete(ossl_check_IPAddressOrRange_sk_type(sk), (i)))
+#define sk_IPAddressOrRange_delete_ptr(sk, ptr) ((IPAddressOrRange *)OPENSSL_sk_delete_ptr(ossl_check_IPAddressOrRange_sk_type(sk), ossl_check_IPAddressOrRange_type(ptr)))
+#define sk_IPAddressOrRange_push(sk, ptr) OPENSSL_sk_push(ossl_check_IPAddressOrRange_sk_type(sk), ossl_check_IPAddressOrRange_type(ptr))
+#define sk_IPAddressOrRange_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_IPAddressOrRange_sk_type(sk), ossl_check_IPAddressOrRange_type(ptr))
+#define sk_IPAddressOrRange_pop(sk) ((IPAddressOrRange *)OPENSSL_sk_pop(ossl_check_IPAddressOrRange_sk_type(sk)))
+#define sk_IPAddressOrRange_shift(sk) ((IPAddressOrRange *)OPENSSL_sk_shift(ossl_check_IPAddressOrRange_sk_type(sk)))
+#define sk_IPAddressOrRange_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_IPAddressOrRange_sk_type(sk),ossl_check_IPAddressOrRange_freefunc_type(freefunc))
+#define sk_IPAddressOrRange_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_IPAddressOrRange_sk_type(sk), ossl_check_IPAddressOrRange_type(ptr), (idx))
+#define sk_IPAddressOrRange_set(sk, idx, ptr) ((IPAddressOrRange *)OPENSSL_sk_set(ossl_check_IPAddressOrRange_sk_type(sk), (idx), ossl_check_IPAddressOrRange_type(ptr)))
+#define sk_IPAddressOrRange_find(sk, ptr) OPENSSL_sk_find(ossl_check_IPAddressOrRange_sk_type(sk), ossl_check_IPAddressOrRange_type(ptr))
+#define sk_IPAddressOrRange_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_IPAddressOrRange_sk_type(sk), ossl_check_IPAddressOrRange_type(ptr))
+#define sk_IPAddressOrRange_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_IPAddressOrRange_sk_type(sk), ossl_check_IPAddressOrRange_type(ptr), pnum)
+#define sk_IPAddressOrRange_sort(sk) OPENSSL_sk_sort(ossl_check_IPAddressOrRange_sk_type(sk))
+#define sk_IPAddressOrRange_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_IPAddressOrRange_sk_type(sk))
+#define sk_IPAddressOrRange_dup(sk) ((STACK_OF(IPAddressOrRange) *)OPENSSL_sk_dup(ossl_check_const_IPAddressOrRange_sk_type(sk)))
+#define sk_IPAddressOrRange_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(IPAddressOrRange) *)OPENSSL_sk_deep_copy(ossl_check_const_IPAddressOrRange_sk_type(sk), ossl_check_IPAddressOrRange_copyfunc_type(copyfunc), ossl_check_IPAddressOrRange_freefunc_type(freefunc)))
+#define sk_IPAddressOrRange_set_cmp_func(sk, cmp) ((sk_IPAddressOrRange_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_IPAddressOrRange_sk_type(sk), ossl_check_IPAddressOrRange_compfunc_type(cmp)))
+
+
+typedef STACK_OF(IPAddressOrRange) IPAddressOrRanges;
+
+# define IPAddressChoice_inherit                 0
+# define IPAddressChoice_addressesOrRanges       1
+
+typedef struct IPAddressChoice_st {
+    int type;
+    union {
+        ASN1_NULL *inherit;
+        IPAddressOrRanges *addressesOrRanges;
+    } u;
+} IPAddressChoice;
+
+typedef struct IPAddressFamily_st {
+    ASN1_OCTET_STRING *addressFamily;
+    IPAddressChoice *ipAddressChoice;
+} IPAddressFamily;
+
+SKM_DEFINE_STACK_OF_INTERNAL(IPAddressFamily, IPAddressFamily, IPAddressFamily)
+#define sk_IPAddressFamily_num(sk) OPENSSL_sk_num(ossl_check_const_IPAddressFamily_sk_type(sk))
+#define sk_IPAddressFamily_value(sk, idx) ((IPAddressFamily *)OPENSSL_sk_value(ossl_check_const_IPAddressFamily_sk_type(sk), (idx)))
+#define sk_IPAddressFamily_new(cmp) ((STACK_OF(IPAddressFamily) *)OPENSSL_sk_new(ossl_check_IPAddressFamily_compfunc_type(cmp)))
+#define sk_IPAddressFamily_new_null() ((STACK_OF(IPAddressFamily) *)OPENSSL_sk_new_null())
+#define sk_IPAddressFamily_new_reserve(cmp, n) ((STACK_OF(IPAddressFamily) *)OPENSSL_sk_new_reserve(ossl_check_IPAddressFamily_compfunc_type(cmp), (n)))
+#define sk_IPAddressFamily_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_IPAddressFamily_sk_type(sk), (n))
+#define sk_IPAddressFamily_free(sk) OPENSSL_sk_free(ossl_check_IPAddressFamily_sk_type(sk))
+#define sk_IPAddressFamily_zero(sk) OPENSSL_sk_zero(ossl_check_IPAddressFamily_sk_type(sk))
+#define sk_IPAddressFamily_delete(sk, i) ((IPAddressFamily *)OPENSSL_sk_delete(ossl_check_IPAddressFamily_sk_type(sk), (i)))
+#define sk_IPAddressFamily_delete_ptr(sk, ptr) ((IPAddressFamily *)OPENSSL_sk_delete_ptr(ossl_check_IPAddressFamily_sk_type(sk), ossl_check_IPAddressFamily_type(ptr)))
+#define sk_IPAddressFamily_push(sk, ptr) OPENSSL_sk_push(ossl_check_IPAddressFamily_sk_type(sk), ossl_check_IPAddressFamily_type(ptr))
+#define sk_IPAddressFamily_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_IPAddressFamily_sk_type(sk), ossl_check_IPAddressFamily_type(ptr))
+#define sk_IPAddressFamily_pop(sk) ((IPAddressFamily *)OPENSSL_sk_pop(ossl_check_IPAddressFamily_sk_type(sk)))
+#define sk_IPAddressFamily_shift(sk) ((IPAddressFamily *)OPENSSL_sk_shift(ossl_check_IPAddressFamily_sk_type(sk)))
+#define sk_IPAddressFamily_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_IPAddressFamily_sk_type(sk),ossl_check_IPAddressFamily_freefunc_type(freefunc))
+#define sk_IPAddressFamily_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_IPAddressFamily_sk_type(sk), ossl_check_IPAddressFamily_type(ptr), (idx))
+#define sk_IPAddressFamily_set(sk, idx, ptr) ((IPAddressFamily *)OPENSSL_sk_set(ossl_check_IPAddressFamily_sk_type(sk), (idx), ossl_check_IPAddressFamily_type(ptr)))
+#define sk_IPAddressFamily_find(sk, ptr) OPENSSL_sk_find(ossl_check_IPAddressFamily_sk_type(sk), ossl_check_IPAddressFamily_type(ptr))
+#define sk_IPAddressFamily_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_IPAddressFamily_sk_type(sk), ossl_check_IPAddressFamily_type(ptr))
+#define sk_IPAddressFamily_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_IPAddressFamily_sk_type(sk), ossl_check_IPAddressFamily_type(ptr), pnum)
+#define sk_IPAddressFamily_sort(sk) OPENSSL_sk_sort(ossl_check_IPAddressFamily_sk_type(sk))
+#define sk_IPAddressFamily_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_IPAddressFamily_sk_type(sk))
+#define sk_IPAddressFamily_dup(sk) ((STACK_OF(IPAddressFamily) *)OPENSSL_sk_dup(ossl_check_const_IPAddressFamily_sk_type(sk)))
+#define sk_IPAddressFamily_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(IPAddressFamily) *)OPENSSL_sk_deep_copy(ossl_check_const_IPAddressFamily_sk_type(sk), ossl_check_IPAddressFamily_copyfunc_type(copyfunc), ossl_check_IPAddressFamily_freefunc_type(freefunc)))
+#define sk_IPAddressFamily_set_cmp_func(sk, cmp) ((sk_IPAddressFamily_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_IPAddressFamily_sk_type(sk), ossl_check_IPAddressFamily_compfunc_type(cmp)))
+
+
+
+typedef STACK_OF(IPAddressFamily) IPAddrBlocks;
+
+DECLARE_ASN1_FUNCTIONS(IPAddressRange)
+DECLARE_ASN1_FUNCTIONS(IPAddressOrRange)
+DECLARE_ASN1_FUNCTIONS(IPAddressChoice)
+DECLARE_ASN1_FUNCTIONS(IPAddressFamily)
+
+/*
+ * API tag for elements of the ASIdentifer SEQUENCE.
+ */
+# define V3_ASID_ASNUM   0
+# define V3_ASID_RDI     1
+
+/*
+ * AFI values, assigned by IANA.  It'd be nice to make the AFI
+ * handling code totally generic, but there are too many little things
+ * that would need to be defined for other address families for it to
+ * be worth the trouble.
+ */
+# define IANA_AFI_IPV4   1
+# define IANA_AFI_IPV6   2
+
+/*
+ * Utilities to construct and extract values from RFC3779 extensions,
+ * since some of the encodings (particularly for IP address prefixes
+ * and ranges) are a bit tedious to work with directly.
+ */
+int X509v3_asid_add_inherit(ASIdentifiers *asid, int which);
+int X509v3_asid_add_id_or_range(ASIdentifiers *asid, int which,
+                                ASN1_INTEGER *min, ASN1_INTEGER *max);
+int X509v3_addr_add_inherit(IPAddrBlocks *addr,
+                            const unsigned afi, const unsigned *safi);
+int X509v3_addr_add_prefix(IPAddrBlocks *addr,
+                           const unsigned afi, const unsigned *safi,
+                           unsigned char *a, const int prefixlen);
+int X509v3_addr_add_range(IPAddrBlocks *addr,
+                          const unsigned afi, const unsigned *safi,
+                          unsigned char *min, unsigned char *max);
+unsigned X509v3_addr_get_afi(const IPAddressFamily *f);
+int X509v3_addr_get_range(IPAddressOrRange *aor, const unsigned afi,
+                          unsigned char *min, unsigned char *max,
+                          const int length);
+
+/*
+ * Canonical forms.
+ */
+int X509v3_asid_is_canonical(ASIdentifiers *asid);
+int X509v3_addr_is_canonical(IPAddrBlocks *addr);
+int X509v3_asid_canonize(ASIdentifiers *asid);
+int X509v3_addr_canonize(IPAddrBlocks *addr);
+
+/*
+ * Tests for inheritance and containment.
+ */
+int X509v3_asid_inherits(ASIdentifiers *asid);
+int X509v3_addr_inherits(IPAddrBlocks *addr);
+int X509v3_asid_subset(ASIdentifiers *a, ASIdentifiers *b);
+int X509v3_addr_subset(IPAddrBlocks *a, IPAddrBlocks *b);
+
+/*
+ * Check whether RFC 3779 extensions nest properly in chains.
+ */
+int X509v3_asid_validate_path(X509_STORE_CTX *);
+int X509v3_addr_validate_path(X509_STORE_CTX *);
+int X509v3_asid_validate_resource_set(STACK_OF(X509) *chain,
+                                      ASIdentifiers *ext,
+                                      int allow_inheritance);
+int X509v3_addr_validate_resource_set(STACK_OF(X509) *chain,
+                                      IPAddrBlocks *ext, int allow_inheritance);
+
+#endif                         /* OPENSSL_NO_RFC3779 */
+
+SKM_DEFINE_STACK_OF_INTERNAL(ASN1_STRING, ASN1_STRING, ASN1_STRING)
+#define sk_ASN1_STRING_num(sk) OPENSSL_sk_num(ossl_check_const_ASN1_STRING_sk_type(sk))
+#define sk_ASN1_STRING_value(sk, idx) ((ASN1_STRING *)OPENSSL_sk_value(ossl_check_const_ASN1_STRING_sk_type(sk), (idx)))
+#define sk_ASN1_STRING_new(cmp) ((STACK_OF(ASN1_STRING) *)OPENSSL_sk_new(ossl_check_ASN1_STRING_compfunc_type(cmp)))
+#define sk_ASN1_STRING_new_null() ((STACK_OF(ASN1_STRING) *)OPENSSL_sk_new_null())
+#define sk_ASN1_STRING_new_reserve(cmp, n) ((STACK_OF(ASN1_STRING) *)OPENSSL_sk_new_reserve(ossl_check_ASN1_STRING_compfunc_type(cmp), (n)))
+#define sk_ASN1_STRING_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_ASN1_STRING_sk_type(sk), (n))
+#define sk_ASN1_STRING_free(sk) OPENSSL_sk_free(ossl_check_ASN1_STRING_sk_type(sk))
+#define sk_ASN1_STRING_zero(sk) OPENSSL_sk_zero(ossl_check_ASN1_STRING_sk_type(sk))
+#define sk_ASN1_STRING_delete(sk, i) ((ASN1_STRING *)OPENSSL_sk_delete(ossl_check_ASN1_STRING_sk_type(sk), (i)))
+#define sk_ASN1_STRING_delete_ptr(sk, ptr) ((ASN1_STRING *)OPENSSL_sk_delete_ptr(ossl_check_ASN1_STRING_sk_type(sk), ossl_check_ASN1_STRING_type(ptr)))
+#define sk_ASN1_STRING_push(sk, ptr) OPENSSL_sk_push(ossl_check_ASN1_STRING_sk_type(sk), ossl_check_ASN1_STRING_type(ptr))
+#define sk_ASN1_STRING_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_ASN1_STRING_sk_type(sk), ossl_check_ASN1_STRING_type(ptr))
+#define sk_ASN1_STRING_pop(sk) ((ASN1_STRING *)OPENSSL_sk_pop(ossl_check_ASN1_STRING_sk_type(sk)))
+#define sk_ASN1_STRING_shift(sk) ((ASN1_STRING *)OPENSSL_sk_shift(ossl_check_ASN1_STRING_sk_type(sk)))
+#define sk_ASN1_STRING_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ASN1_STRING_sk_type(sk),ossl_check_ASN1_STRING_freefunc_type(freefunc))
+#define sk_ASN1_STRING_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_ASN1_STRING_sk_type(sk), ossl_check_ASN1_STRING_type(ptr), (idx))
+#define sk_ASN1_STRING_set(sk, idx, ptr) ((ASN1_STRING *)OPENSSL_sk_set(ossl_check_ASN1_STRING_sk_type(sk), (idx), ossl_check_ASN1_STRING_type(ptr)))
+#define sk_ASN1_STRING_find(sk, ptr) OPENSSL_sk_find(ossl_check_ASN1_STRING_sk_type(sk), ossl_check_ASN1_STRING_type(ptr))
+#define sk_ASN1_STRING_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_ASN1_STRING_sk_type(sk), ossl_check_ASN1_STRING_type(ptr))
+#define sk_ASN1_STRING_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_ASN1_STRING_sk_type(sk), ossl_check_ASN1_STRING_type(ptr), pnum)
+#define sk_ASN1_STRING_sort(sk) OPENSSL_sk_sort(ossl_check_ASN1_STRING_sk_type(sk))
+#define sk_ASN1_STRING_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_ASN1_STRING_sk_type(sk))
+#define sk_ASN1_STRING_dup(sk) ((STACK_OF(ASN1_STRING) *)OPENSSL_sk_dup(ossl_check_const_ASN1_STRING_sk_type(sk)))
+#define sk_ASN1_STRING_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ASN1_STRING) *)OPENSSL_sk_deep_copy(ossl_check_const_ASN1_STRING_sk_type(sk), ossl_check_ASN1_STRING_copyfunc_type(copyfunc), ossl_check_ASN1_STRING_freefunc_type(freefunc)))
+#define sk_ASN1_STRING_set_cmp_func(sk, cmp) ((sk_ASN1_STRING_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_ASN1_STRING_sk_type(sk), ossl_check_ASN1_STRING_compfunc_type(cmp)))
+
+
+/*
+ * Admission Syntax
+ */
+typedef struct NamingAuthority_st NAMING_AUTHORITY;
+typedef struct ProfessionInfo_st PROFESSION_INFO;
+typedef struct Admissions_st ADMISSIONS;
+typedef struct AdmissionSyntax_st ADMISSION_SYNTAX;
+DECLARE_ASN1_FUNCTIONS(NAMING_AUTHORITY)
+DECLARE_ASN1_FUNCTIONS(PROFESSION_INFO)
+DECLARE_ASN1_FUNCTIONS(ADMISSIONS)
+DECLARE_ASN1_FUNCTIONS(ADMISSION_SYNTAX)
+SKM_DEFINE_STACK_OF_INTERNAL(PROFESSION_INFO, PROFESSION_INFO, PROFESSION_INFO)
+#define sk_PROFESSION_INFO_num(sk) OPENSSL_sk_num(ossl_check_const_PROFESSION_INFO_sk_type(sk))
+#define sk_PROFESSION_INFO_value(sk, idx) ((PROFESSION_INFO *)OPENSSL_sk_value(ossl_check_const_PROFESSION_INFO_sk_type(sk), (idx)))
+#define sk_PROFESSION_INFO_new(cmp) ((STACK_OF(PROFESSION_INFO) *)OPENSSL_sk_new(ossl_check_PROFESSION_INFO_compfunc_type(cmp)))
+#define sk_PROFESSION_INFO_new_null() ((STACK_OF(PROFESSION_INFO) *)OPENSSL_sk_new_null())
+#define sk_PROFESSION_INFO_new_reserve(cmp, n) ((STACK_OF(PROFESSION_INFO) *)OPENSSL_sk_new_reserve(ossl_check_PROFESSION_INFO_compfunc_type(cmp), (n)))
+#define sk_PROFESSION_INFO_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_PROFESSION_INFO_sk_type(sk), (n))
+#define sk_PROFESSION_INFO_free(sk) OPENSSL_sk_free(ossl_check_PROFESSION_INFO_sk_type(sk))
+#define sk_PROFESSION_INFO_zero(sk) OPENSSL_sk_zero(ossl_check_PROFESSION_INFO_sk_type(sk))
+#define sk_PROFESSION_INFO_delete(sk, i) ((PROFESSION_INFO *)OPENSSL_sk_delete(ossl_check_PROFESSION_INFO_sk_type(sk), (i)))
+#define sk_PROFESSION_INFO_delete_ptr(sk, ptr) ((PROFESSION_INFO *)OPENSSL_sk_delete_ptr(ossl_check_PROFESSION_INFO_sk_type(sk), ossl_check_PROFESSION_INFO_type(ptr)))
+#define sk_PROFESSION_INFO_push(sk, ptr) OPENSSL_sk_push(ossl_check_PROFESSION_INFO_sk_type(sk), ossl_check_PROFESSION_INFO_type(ptr))
+#define sk_PROFESSION_INFO_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_PROFESSION_INFO_sk_type(sk), ossl_check_PROFESSION_INFO_type(ptr))
+#define sk_PROFESSION_INFO_pop(sk) ((PROFESSION_INFO *)OPENSSL_sk_pop(ossl_check_PROFESSION_INFO_sk_type(sk)))
+#define sk_PROFESSION_INFO_shift(sk) ((PROFESSION_INFO *)OPENSSL_sk_shift(ossl_check_PROFESSION_INFO_sk_type(sk)))
+#define sk_PROFESSION_INFO_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_PROFESSION_INFO_sk_type(sk),ossl_check_PROFESSION_INFO_freefunc_type(freefunc))
+#define sk_PROFESSION_INFO_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_PROFESSION_INFO_sk_type(sk), ossl_check_PROFESSION_INFO_type(ptr), (idx))
+#define sk_PROFESSION_INFO_set(sk, idx, ptr) ((PROFESSION_INFO *)OPENSSL_sk_set(ossl_check_PROFESSION_INFO_sk_type(sk), (idx), ossl_check_PROFESSION_INFO_type(ptr)))
+#define sk_PROFESSION_INFO_find(sk, ptr) OPENSSL_sk_find(ossl_check_PROFESSION_INFO_sk_type(sk), ossl_check_PROFESSION_INFO_type(ptr))
+#define sk_PROFESSION_INFO_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_PROFESSION_INFO_sk_type(sk), ossl_check_PROFESSION_INFO_type(ptr))
+#define sk_PROFESSION_INFO_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_PROFESSION_INFO_sk_type(sk), ossl_check_PROFESSION_INFO_type(ptr), pnum)
+#define sk_PROFESSION_INFO_sort(sk) OPENSSL_sk_sort(ossl_check_PROFESSION_INFO_sk_type(sk))
+#define sk_PROFESSION_INFO_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_PROFESSION_INFO_sk_type(sk))
+#define sk_PROFESSION_INFO_dup(sk) ((STACK_OF(PROFESSION_INFO) *)OPENSSL_sk_dup(ossl_check_const_PROFESSION_INFO_sk_type(sk)))
+#define sk_PROFESSION_INFO_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(PROFESSION_INFO) *)OPENSSL_sk_deep_copy(ossl_check_const_PROFESSION_INFO_sk_type(sk), ossl_check_PROFESSION_INFO_copyfunc_type(copyfunc), ossl_check_PROFESSION_INFO_freefunc_type(freefunc)))
+#define sk_PROFESSION_INFO_set_cmp_func(sk, cmp) ((sk_PROFESSION_INFO_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_PROFESSION_INFO_sk_type(sk), ossl_check_PROFESSION_INFO_compfunc_type(cmp)))
+SKM_DEFINE_STACK_OF_INTERNAL(ADMISSIONS, ADMISSIONS, ADMISSIONS)
+#define sk_ADMISSIONS_num(sk) OPENSSL_sk_num(ossl_check_const_ADMISSIONS_sk_type(sk))
+#define sk_ADMISSIONS_value(sk, idx) ((ADMISSIONS *)OPENSSL_sk_value(ossl_check_const_ADMISSIONS_sk_type(sk), (idx)))
+#define sk_ADMISSIONS_new(cmp) ((STACK_OF(ADMISSIONS) *)OPENSSL_sk_new(ossl_check_ADMISSIONS_compfunc_type(cmp)))
+#define sk_ADMISSIONS_new_null() ((STACK_OF(ADMISSIONS) *)OPENSSL_sk_new_null())
+#define sk_ADMISSIONS_new_reserve(cmp, n) ((STACK_OF(ADMISSIONS) *)OPENSSL_sk_new_reserve(ossl_check_ADMISSIONS_compfunc_type(cmp), (n)))
+#define sk_ADMISSIONS_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_ADMISSIONS_sk_type(sk), (n))
+#define sk_ADMISSIONS_free(sk) OPENSSL_sk_free(ossl_check_ADMISSIONS_sk_type(sk))
+#define sk_ADMISSIONS_zero(sk) OPENSSL_sk_zero(ossl_check_ADMISSIONS_sk_type(sk))
+#define sk_ADMISSIONS_delete(sk, i) ((ADMISSIONS *)OPENSSL_sk_delete(ossl_check_ADMISSIONS_sk_type(sk), (i)))
+#define sk_ADMISSIONS_delete_ptr(sk, ptr) ((ADMISSIONS *)OPENSSL_sk_delete_ptr(ossl_check_ADMISSIONS_sk_type(sk), ossl_check_ADMISSIONS_type(ptr)))
+#define sk_ADMISSIONS_push(sk, ptr) OPENSSL_sk_push(ossl_check_ADMISSIONS_sk_type(sk), ossl_check_ADMISSIONS_type(ptr))
+#define sk_ADMISSIONS_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_ADMISSIONS_sk_type(sk), ossl_check_ADMISSIONS_type(ptr))
+#define sk_ADMISSIONS_pop(sk) ((ADMISSIONS *)OPENSSL_sk_pop(ossl_check_ADMISSIONS_sk_type(sk)))
+#define sk_ADMISSIONS_shift(sk) ((ADMISSIONS *)OPENSSL_sk_shift(ossl_check_ADMISSIONS_sk_type(sk)))
+#define sk_ADMISSIONS_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ADMISSIONS_sk_type(sk),ossl_check_ADMISSIONS_freefunc_type(freefunc))
+#define sk_ADMISSIONS_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_ADMISSIONS_sk_type(sk), ossl_check_ADMISSIONS_type(ptr), (idx))
+#define sk_ADMISSIONS_set(sk, idx, ptr) ((ADMISSIONS *)OPENSSL_sk_set(ossl_check_ADMISSIONS_sk_type(sk), (idx), ossl_check_ADMISSIONS_type(ptr)))
+#define sk_ADMISSIONS_find(sk, ptr) OPENSSL_sk_find(ossl_check_ADMISSIONS_sk_type(sk), ossl_check_ADMISSIONS_type(ptr))
+#define sk_ADMISSIONS_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_ADMISSIONS_sk_type(sk), ossl_check_ADMISSIONS_type(ptr))
+#define sk_ADMISSIONS_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_ADMISSIONS_sk_type(sk), ossl_check_ADMISSIONS_type(ptr), pnum)
+#define sk_ADMISSIONS_sort(sk) OPENSSL_sk_sort(ossl_check_ADMISSIONS_sk_type(sk))
+#define sk_ADMISSIONS_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_ADMISSIONS_sk_type(sk))
+#define sk_ADMISSIONS_dup(sk) ((STACK_OF(ADMISSIONS) *)OPENSSL_sk_dup(ossl_check_const_ADMISSIONS_sk_type(sk)))
+#define sk_ADMISSIONS_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ADMISSIONS) *)OPENSSL_sk_deep_copy(ossl_check_const_ADMISSIONS_sk_type(sk), ossl_check_ADMISSIONS_copyfunc_type(copyfunc), ossl_check_ADMISSIONS_freefunc_type(freefunc)))
+#define sk_ADMISSIONS_set_cmp_func(sk, cmp) ((sk_ADMISSIONS_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_ADMISSIONS_sk_type(sk), ossl_check_ADMISSIONS_compfunc_type(cmp)))
+
+typedef STACK_OF(PROFESSION_INFO) PROFESSION_INFOS;
+
+const ASN1_OBJECT *NAMING_AUTHORITY_get0_authorityId(
+    const NAMING_AUTHORITY *n);
+const ASN1_IA5STRING *NAMING_AUTHORITY_get0_authorityURL(
+    const NAMING_AUTHORITY *n);
+const ASN1_STRING *NAMING_AUTHORITY_get0_authorityText(
+    const NAMING_AUTHORITY *n);
+void NAMING_AUTHORITY_set0_authorityId(NAMING_AUTHORITY *n,
+    ASN1_OBJECT* namingAuthorityId);
+void NAMING_AUTHORITY_set0_authorityURL(NAMING_AUTHORITY *n,
+    ASN1_IA5STRING* namingAuthorityUrl);
+void NAMING_AUTHORITY_set0_authorityText(NAMING_AUTHORITY *n,
+    ASN1_STRING* namingAuthorityText);
+
+const GENERAL_NAME *ADMISSION_SYNTAX_get0_admissionAuthority(
+    const ADMISSION_SYNTAX *as);
+void ADMISSION_SYNTAX_set0_admissionAuthority(
+    ADMISSION_SYNTAX *as, GENERAL_NAME *aa);
+const STACK_OF(ADMISSIONS) *ADMISSION_SYNTAX_get0_contentsOfAdmissions(
+    const ADMISSION_SYNTAX *as);
+void ADMISSION_SYNTAX_set0_contentsOfAdmissions(
+    ADMISSION_SYNTAX *as, STACK_OF(ADMISSIONS) *a);
+const GENERAL_NAME *ADMISSIONS_get0_admissionAuthority(const ADMISSIONS *a);
+void ADMISSIONS_set0_admissionAuthority(ADMISSIONS *a, GENERAL_NAME *aa);
+const NAMING_AUTHORITY *ADMISSIONS_get0_namingAuthority(const ADMISSIONS *a);
+void ADMISSIONS_set0_namingAuthority(ADMISSIONS *a, NAMING_AUTHORITY *na);
+const PROFESSION_INFOS *ADMISSIONS_get0_professionInfos(const ADMISSIONS *a);
+void ADMISSIONS_set0_professionInfos(ADMISSIONS *a, PROFESSION_INFOS *pi);
+const ASN1_OCTET_STRING *PROFESSION_INFO_get0_addProfessionInfo(
+    const PROFESSION_INFO *pi);
+void PROFESSION_INFO_set0_addProfessionInfo(
+    PROFESSION_INFO *pi, ASN1_OCTET_STRING *aos);
+const NAMING_AUTHORITY *PROFESSION_INFO_get0_namingAuthority(
+    const PROFESSION_INFO *pi);
+void PROFESSION_INFO_set0_namingAuthority(
+    PROFESSION_INFO *pi, NAMING_AUTHORITY *na);
+const STACK_OF(ASN1_STRING) *PROFESSION_INFO_get0_professionItems(
+    const PROFESSION_INFO *pi);
+void PROFESSION_INFO_set0_professionItems(
+    PROFESSION_INFO *pi, STACK_OF(ASN1_STRING) *as);
+const STACK_OF(ASN1_OBJECT) *PROFESSION_INFO_get0_professionOIDs(
+    const PROFESSION_INFO *pi);
+void PROFESSION_INFO_set0_professionOIDs(
+    PROFESSION_INFO *pi, STACK_OF(ASN1_OBJECT) *po);
+const ASN1_PRINTABLESTRING *PROFESSION_INFO_get0_registrationNumber(
+    const PROFESSION_INFO *pi);
+void PROFESSION_INFO_set0_registrationNumber(
+    PROFESSION_INFO *pi, ASN1_PRINTABLESTRING *rn);
+
+# ifdef  __cplusplus
+}
+# endif
+#endif
diff --git a/src/include/openssl/x509v3err.h b/src/include/openssl/x509v3err.h
new file mode 100644
index 0000000..deede27
--- /dev/null
+++ b/src/include/openssl/x509v3err.h
@@ -0,0 +1,96 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2022 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_X509V3ERR_H
+# define OPENSSL_X509V3ERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+
+/*
+ * X509V3 reason codes.
+ */
+# define X509V3_R_BAD_IP_ADDRESS                          118
+# define X509V3_R_BAD_OBJECT                              119
+# define X509V3_R_BAD_OPTION                              170
+# define X509V3_R_BAD_VALUE                               171
+# define X509V3_R_BN_DEC2BN_ERROR                         100
+# define X509V3_R_BN_TO_ASN1_INTEGER_ERROR                101
+# define X509V3_R_DIRNAME_ERROR                           149
+# define X509V3_R_DISTPOINT_ALREADY_SET                   160
+# define X509V3_R_DUPLICATE_ZONE_ID                       133
+# define X509V3_R_EMPTY_KEY_USAGE                         169
+# define X509V3_R_ERROR_CONVERTING_ZONE                   131
+# define X509V3_R_ERROR_CREATING_EXTENSION                144
+# define X509V3_R_ERROR_IN_EXTENSION                      128
+# define X509V3_R_EXPECTED_A_SECTION_NAME                 137
+# define X509V3_R_EXTENSION_EXISTS                        145
+# define X509V3_R_EXTENSION_NAME_ERROR                    115
+# define X509V3_R_EXTENSION_NOT_FOUND                     102
+# define X509V3_R_EXTENSION_SETTING_NOT_SUPPORTED         103
+# define X509V3_R_EXTENSION_VALUE_ERROR                   116
+# define X509V3_R_ILLEGAL_EMPTY_EXTENSION                 151
+# define X509V3_R_INCORRECT_POLICY_SYNTAX_TAG             152
+# define X509V3_R_INVALID_ASNUMBER                        162
+# define X509V3_R_INVALID_ASRANGE                         163
+# define X509V3_R_INVALID_BOOLEAN_STRING                  104
+# define X509V3_R_INVALID_CERTIFICATE                     158
+# define X509V3_R_INVALID_EMPTY_NAME                      108
+# define X509V3_R_INVALID_EXTENSION_STRING                105
+# define X509V3_R_INVALID_INHERITANCE                     165
+# define X509V3_R_INVALID_IPADDRESS                       166
+# define X509V3_R_INVALID_MULTIPLE_RDNS                   161
+# define X509V3_R_INVALID_NAME                            106
+# define X509V3_R_INVALID_NULL_ARGUMENT                   107
+# define X509V3_R_INVALID_NULL_VALUE                      109
+# define X509V3_R_INVALID_NUMBER                          140
+# define X509V3_R_INVALID_NUMBERS                         141
+# define X509V3_R_INVALID_OBJECT_IDENTIFIER               110
+# define X509V3_R_INVALID_OPTION                          138
+# define X509V3_R_INVALID_POLICY_IDENTIFIER               134
+# define X509V3_R_INVALID_PROXY_POLICY_SETTING            153
+# define X509V3_R_INVALID_PURPOSE                         146
+# define X509V3_R_INVALID_SAFI                            164
+# define X509V3_R_INVALID_SECTION                         135
+# define X509V3_R_INVALID_SYNTAX                          143
+# define X509V3_R_ISSUER_DECODE_ERROR                     126
+# define X509V3_R_MISSING_VALUE                           124
+# define X509V3_R_NEED_ORGANIZATION_AND_NUMBERS           142
+# define X509V3_R_NEGATIVE_PATHLEN                        168
+# define X509V3_R_NO_CONFIG_DATABASE                      136
+# define X509V3_R_NO_ISSUER_CERTIFICATE                   121
+# define X509V3_R_NO_ISSUER_DETAILS                       127
+# define X509V3_R_NO_POLICY_IDENTIFIER                    139
+# define X509V3_R_NO_PROXY_CERT_POLICY_LANGUAGE_DEFINED   154
+# define X509V3_R_NO_PUBLIC_KEY                           114
+# define X509V3_R_NO_SUBJECT_DETAILS                      125
+# define X509V3_R_OPERATION_NOT_DEFINED                   148
+# define X509V3_R_OTHERNAME_ERROR                         147
+# define X509V3_R_POLICY_LANGUAGE_ALREADY_DEFINED         155
+# define X509V3_R_POLICY_PATH_LENGTH                      156
+# define X509V3_R_POLICY_PATH_LENGTH_ALREADY_DEFINED      157
+# define X509V3_R_POLICY_WHEN_PROXY_LANGUAGE_REQUIRES_NO_POLICY 159
+# define X509V3_R_SECTION_NOT_FOUND                       150
+# define X509V3_R_UNABLE_TO_GET_ISSUER_DETAILS            122
+# define X509V3_R_UNABLE_TO_GET_ISSUER_KEYID              123
+# define X509V3_R_UNKNOWN_BIT_STRING_ARGUMENT             111
+# define X509V3_R_UNKNOWN_EXTENSION                       129
+# define X509V3_R_UNKNOWN_EXTENSION_NAME                  130
+# define X509V3_R_UNKNOWN_OPTION                          120
+# define X509V3_R_UNKNOWN_VALUE                           172
+# define X509V3_R_UNSUPPORTED_OPTION                      117
+# define X509V3_R_UNSUPPORTED_TYPE                        167
+# define X509V3_R_USER_TOO_LONG                           132
+
+#endif
diff --git a/src/include/pthread/CONTRIBUTORS b/src/include/pthread/CONTRIBUTORS
new file mode 100644
index 0000000..a254185
--- /dev/null
+++ b/src/include/pthread/CONTRIBUTORS
@@ -0,0 +1,139 @@
+Contributors (in approximate order of appearance)
+
+[See also the ChangeLog file where individuals are
+attributed in log entries. Likewise in the FAQ file.]
+
+Ben Elliston		bje at cygnus dot com
+					Initiated the project;
+					setup the project infrastructure (CVS, web page, etc.);
+					early prototype routines.
+Ross Johnson		Ross dot Johnson at  dot homemail dot com dot au
+					early prototype routines;
+					ongoing project coordination/maintenance;
+					implementation of spin locks and barriers;
+					various enhancements;
+					bug fixes;
+					documentation;
+					testsuite.
+Robert Colquhoun	rjc at trump dot net dot au
+					Early bug fixes.
+John E. Bossom		john dot bossom at gmail dot com
+					Contributed substantial original working implementation;
+					bug fixes;
+Anders Norlander	anorland at hem2 dot passagen dot se
+					Early enhancements and runtime checking for supported
+					Win32 routines.
+Tor Lillqvist		tml at iki dot fi
+					General enhancements;
+					early bug fixes to condition variables.
+Scott Lightner		scott at curriculum dot com
+					Bug fix.
+Kevin Ruland		Kevin dot Ruland at anheuser-busch dot com
+					Various bug fixes.
+Mike Russo		miker at eai dot com
+					Bug fix.
+Mark E. Armstrong	avail at pacbell dot net
+					Bug fixes.
+Lorin Hochstein 	lmh at xiphos dot ca
+					general bug fixes; bug fixes to condition variables.
+Peter Slacik		Peter dot Slacik at tatramed dot sk
+					Bug fixes.
+Mumit Khan		khan at xraylith dot wisc dot edu
+					Fixes to work with Mingw32.
+Milan Gardian		mg at tatramed dot sk
+					Bug fixes and reports/analyses of obscure problems.
+Aurelio Medina		aureliom at crt dot com
+					First implementation of read-write locks.
+Graham Dumpleton	Graham dot Dumpleton at ra dot pad dot otc dot telstra dot com dot au
+					Bug fix in condition variables.
+Tristan Savatier	tristan at mpegtv dot com
+					WinCE port.
+Erik Hensema		erik at hensema dot xs4all dot nl
+					Bug fixes.
+Rich Peters		rpeters at micro-magic dot com
+Todd Owen		towen at lucidcalm dot dropbear dot id dot au
+					Bug fixes to dll loading.
+Jason Nye		jnye at nbnet dot nb dot ca
+					Implementation of async cancellation.
+Fred Forester		fforest at eticomm dot net
+Kevin D. Clark		kclark at cabletron dot com
+David Baggett		dmb at itasoftware dot com
+					Bug fixes.
+Paul Redondo		paul at matchvision dot com
+Scott McCaskill 	scott at 3dfx dot com
+					Bug fixes.
+Jef Gearhart		jgearhart at tpssys dot com
+					Bug fix.
+Arthur Kantor		akantor at bexusa dot com
+					Mutex enhancements.
+Steven Reddie		smr at essemer dot com dot au
+					Bug fix.
+Alexander Terekhov	TEREKHOV at de dot ibm dot com
+					Re-implemented and improved read-write locks;
+					(with Louis Thomas) re-implemented and improved
+					condition variables;
+					enhancements to semaphores;
+					enhancements to mutexes;
+					new mutex implementation in 'futex' style;
+					suggested a robust implementation of pthread_once
+					using a named mutex;
+					system clock change handling re CV timeouts;
+					bug fixes.
+Thomas Pfaff		tpfaff at gmx dot net
+					Changes to make C version usable with C++ applications;
+					re-implemented mutex routines to avoid Win32 mutexes
+					and TryEnterCriticalSection;
+					procedure to fix Mingw32 thread-safety issues.
+Franco Bez			franco dot bez at gmx dot de
+					procedure to fix Mingw32 thread-safety issues.
+Louis Thomas		lthomas at arbitrade dot com
+					(with Alexander Terekhov) re-implemented and improved
+					condition variables.
+David Korn			dgk at research dot att dot com
+					Ported to UWIN.
+Phil Frisbie, Jr.	phil at hawksoft dot com
+					Bug fix.
+Ralf Brese			Ralf dot Brese at pdb4 dot siemens dot de
+					Bug fix.
+prionx at juno dot com 	prionx at juno dot com
+					Bug fixes.
+Max Woodbury		mtew at cds dot duke dot edu
+					POSIX versioning conditionals;
+					reduced namespace pollution;
+					idea to separate routines to reduce statically
+					linked image sizes.
+Rob Fanner			rfanner at stonethree dot com
+					Bug fix.
+Michael Johnson 	michaelj at maine dot rr dot com
+					Bug fix.
+Nicolas Barry		boozai at yahoo dot com
+					Bug fixes.
+Piet van Bruggen	pietvb at newbridges dot nl
+					Bug fix.
+Makoto Kato			raven at oldskool dot jp
+					AMD64 port.
+Panagiotis E. Hadjidoukas	peh at hpclab dot ceid dot upatras dot gr
+                                phadjido at cs dot uoi dot gr
+					Contributed the QueueUserAPCEx package which
+					makes preemptive async cancellation possible.
+Will Bryant			will dot bryant at ecosm dot com
+					Borland compiler patch and makefile.
+Anuj Goyal			anuj dot goyal at gmail dot com
+					Port to Digital Mars compiler.
+Gottlob Frege		gottlobfrege at  gmail dot com
+					re-implemented pthread_once (version 2)
+					(pthread_once cancellation added by rpj).
+Vladimir Kliatchko	vladimir at kliatchko dot com
+					reimplemented pthread_once with the same form
+					as described by A.Terekhov (later version 2);
+					implementation of MCS (Mellor-Crummey/Scott) locks.
+Ramiro Polla		ramiro.polla at gmail dot com
+					static library auto init/cleanup on application
+					start/exit via RT hooks (MSC and GCC compilers only).
+Daniel Richard G.	skunk at iSKUNK dot org
+					Patches and cleanups for x86 and x64, particularly
+					across a range of MS build environments.
+John Kamp			john dot kamp at globalgraphics dot com
+					Patches to fix various problems on x64; brutal testing
+					particularly using high memory run environments.
+
diff --git a/src/include/pthread/FAQ b/src/include/pthread/FAQ
new file mode 100644
index 0000000..d62686a
--- /dev/null
+++ b/src/include/pthread/FAQ
@@ -0,0 +1,468 @@
+		  =========================================
+		  PTHREADS-WIN32 Frequently Asked Questions
+		  =========================================
+
+INDEX
+-----
+
+Q 1	What is it?
+
+Q 2	Which of the several dll versions do I use?
+	or,
+	What are all these pthread*.dll and pthread*.lib files?
+
+Q 3	What is the library naming convention?
+
+Q 4	Cleanup code default style or: it used to work when I built
+	the library myself, but now it doesn't - why?
+
+Q 5	Why is the default library version now less exception-friendly?
+
+Q 6	Should I use Cygwin or Mingw32 as a development environment?
+
+Q 7	Now that pthreads-win32 builds under Mingw32, why do I get
+	memory access violations (segfaults)?
+
+Q 8	How do I use pthread.dll for Win32 (Visual C++ 5.0)
+
+Q 9	cancellation doesn't work for me, why?
+
+Q 10	How do I generate pthreadGCE.dll and libpthreadw32.a for use
+	with Mingw32?
+
+Q 11    Why isn't pthread_t defined as a scalar (e.g. pointer or int)
+        like it is for other POSIX threads implementations?
+
+=============================================================================
+
+Q 1	What is it?
+---
+
+Pthreads-win32 is an Open Source Software implementation of the
+Threads component of the POSIX 1003.1c 1995 Standard for Microsoft's
+Win32 environment. Some functions from POSIX 1003.1b are also
+supported including semaphores. Other related functions include
+the set of read-write lock functions. The library also supports
+some of the functionality of the Open Group's Single Unix
+specification, version 2, namely mutex types.
+
+See the file "ANNOUNCE" for more information including standards
+conformance details and list of supported routines.
+
+
+------------------------------------------------------------------------------
+
+Q 2	Which of the several dll versions do I use?
+---	or,
+	What are all these pthread*.dll and pthread*.lib files?
+
+Simply, you only use one of them, but you need to choose carefully.
+
+The most important choice you need to make is whether to use a
+version that uses exceptions internally, or not (there are versions
+of the library that use exceptions as part of the thread
+cancellation and cleanup implementation, and one that uses
+setjmp/longjmp instead).
+
+There is some contension amongst POSIX threads experts as
+to how POSIX threads cancellation and exit should work
+with languages that include exceptions and handlers, e.g.
+C++ and even C (Microsoft's Structured Exceptions).
+
+The issue is: should cancellation of a thread in, say,
+a C++ application cause object destructors and C++ exception
+handlers to be invoked as the stack unwinds during thread
+exit, or not?
+
+There seems to be more opinion in favour of using the
+standard C version of the library (no EH) with C++ applications
+since this appears to be the assumption commercial pthreads
+implementations make. Therefore, if you use an EH version
+of pthreads-win32 then you may be under the illusion that
+your application will be portable, when in fact it is likely to
+behave very differently linked with other pthreads libraries.
+
+Now you may be asking: why have you kept the EH versions of
+the library?
+
+There are a couple of reasons:
+- there is division amongst the experts and so the code may
+  be needed in the future. (Yes, it's in the repository and we
+  can get it out anytime in the future, but ...)
+- pthreads-win32 is one of the few implementations, and possibly
+  the only freely available one, that has EH versions. It may be
+  useful to people who want to play with or study application
+  behaviour under these conditions.
+
+
+------------------------------------------------------------------------------
+
+Q 3	What is the library naming convention?
+---
+
+Because the library is being built using various exception
+handling schemes and compilers - and because the library
+may not work reliably if these are mixed in an application,
+each different version of the library has it's own name.
+
+Note 1: the incompatibility is really between EH implementations
+of the different compilers. It should be possible to use the
+standard C version from either compiler with C++ applications
+built with a different compiler. If you use an EH version of
+the library, then you must use the same compiler for the
+application. This is another complication and dependency that
+can be avoided by using only the standard C library version.
+
+Note 2: if you use a standard C pthread*.dll with a C++
+application, then any functions that you define that are
+intended to be called via pthread_cleanup_push() must be
+__cdecl.
+
+Note 3: the intention is to also name either the VC or GC
+version (it should be arbitrary) as pthread.dll, including
+pthread.lib and libpthread.a as appropriate.
+
+In general:
+	pthread[VG]{SE,CE,C}.dll
+	pthread[VG]{SE,CE,C}.lib
+
+where:
+	[VG] indicates the compiler
+	V	- MS VC
+	G	- GNU C
+
+	{SE,CE,C} indicates the exception handling scheme
+	SE	- Structured EH
+	CE	- C++ EH
+	C	- no exceptions - uses setjmp/longjmp
+
+For example:
+	pthreadVSE.dll	(MSVC/SEH)
+	pthreadGCE.dll	(GNUC/C++ EH)
+	pthreadGC.dll	(GNUC/not dependent on exceptions)
+
+The GNU library archive file names have changed to:
+
+	libpthreadGCE.a
+	libpthreadGC.a
+
+
+------------------------------------------------------------------------------
+
+Q 4	Cleanup code default style or: it used to work when I built
+---	the library myself, but now it doesn't - why?
+
+Up to and including snapshot 2001-07-12, if not defined, the cleanup
+style was determined automatically from the compiler used, and one
+of the following was defined accordingly:
+
+	__PTW32_CLEANUP_SEH	MSVC only
+	__PTW32_CLEANUP_CXX	C++, including MSVC++, GNU G++
+	__PTW32_CLEANUP_C		C, including GNU GCC, not MSVC
+
+These defines determine the style of cleanup (see pthread.h) and,
+most importantly, the way that cancellation and thread exit (via
+pthread_exit) is performed (see the routine __ptw32_throw() in private.c).
+
+In short, the exceptions versions of the library throw an exception
+when a thread is canceled or exits (via pthread_exit()), which is
+caught by a handler in the thread startup routine, so that the
+the correct stack unwinding occurs regardless of where the thread
+is when it's canceled or exits via pthread_exit().
+
+After snapshot 2001-07-12, unless your build explicitly defines (e.g.
+via a compiler option) __PTW32_CLEANUP_SEH, __PTW32_CLEANUP_CXX, or __PTW32_CLEANUP_C, then
+the build now ALWAYS defaults to __PTW32_CLEANUP_C style cleanup. This style
+uses setjmp/longjmp in the cancellation and pthread_exit implementations,
+and therefore won't do stack unwinding even when linked to applications
+that have it (e.g. C++ apps). This is for consistency with most/all
+commercial Unix POSIX threads implementations.
+
+Although it was not clearly documented before, it is still necessary to
+build your application using the same __PTW32_CLEANUP_* define as was
+used for the version of the library that you link with, so that the
+correct parts of pthread.h are included. That is, the possible
+defines require the following library versions:
+
+	__PTW32_CLEANUP_SEH	pthreadVSE.dll
+	__PTW32_CLEANUP_CXX	pthreadVCE.dll or pthreadGCE.dll
+	__PTW32_CLEANUP_C		pthreadVC.dll or pthreadGC.dll
+
+THE POINT OF ALL THIS IS: if you have not been defining one of these
+explicitly, then the defaults have been set according to the compiler
+and language you are using, as described at the top of this
+section.
+
+THIS NOW CHANGES, as has been explained above. For example:
+
+If you were building your application with MSVC++ i.e. using C++
+exceptions (rather than SEH) and not explicitly defining one of
+__PTW32_CLEANUP_*, then __PTW32_CLEANUP_C++ was defined for you in pthread.h.
+You should have been linking with pthreadVCE.dll, which does
+stack unwinding.
+
+If you now build your application as you had before, pthread.h will now
+set __PTW32_CLEANUP_C as the default style, and you will need to link
+with pthreadVC.dll. Stack unwinding will now NOT occur when a
+thread is canceled, nor when the thread calls pthread_exit().
+
+Your application will now most likely behave differently to previous
+versions, and in non-obvious ways. Most likely is that local
+objects may not be destroyed or cleaned up after a thread
+is canceled.
+
+If you want the same behaviour as before, then you must now define
+__PTW32_CLEANUP_C++ explicitly using a compiler option and link with
+pthreadVCE.dll as you did before.
+
+
+------------------------------------------------------------------------------
+
+Q 5	Why is the default library version now less exception-friendly?
+---
+
+Because most commercial Unix POSIX threads implementations don't allow you to
+choose to have stack unwinding. (Compaq's TRU64 Unix is possibly an exception.)
+
+Therefore, providing it in pthread-win32 as a default could be dangerous
+and non-portable. We still provide the choice but you must now consciously
+make it.
+
+WHY NOT REMOVE THE EXCEPTIONS VERSIONS OF THE LIBRARY ALTOGETHER?
+There are a few reasons:
+- because there are well respected POSIX threads people who believe
+  that POSIX threads implementations should be exceptions-aware and
+  do the expected thing in that context. (There are equally respected
+  people who believe it should not be easily accessible, if it's there
+  at all.)
+- because pthreads-win32 is one of the few implementations that has
+  the choice, perhaps the only freely available one, and so offers
+  a laboratory to people who may want to explore the effects;
+- although the code will always be around somewhere for anyone who
+  wants it, once it's removed from the current version it will not be
+  nearly as visible to people who may have a use for it.
+
+
+------------------------------------------------------------------------------
+
+Q 6	Should I use Cygwin or Mingw32 as a development environment?
+---
+
+Important: see Q7 also.
+
+Use Mingw32 with the MSVCRT library to build applications that use
+the pthreads DLL.
+
+Cygwin's own internal support for POSIX threads is growing.
+Consult that project's documentation for more information.
+
+------------------------------------------------------------------------------
+
+Q 7	Now that pthreads-win32 builds under Mingw32, why do I get
+---	memory access violations (segfaults)?
+
+The latest Mingw32 package has thread-safe exception handling (see Q10).
+Also, see Q6 above.
+
+------------------------------------------------------------------------------
+
+Q 8	How do I use pthread.dll for Win32 (Visual C++ 5.0)
+---	
+
+>
+> I'm a "rookie" when it comes to your pthread implementation.	I'm currently
+> desperately trying to install the prebuilt .dll file into my MSVC compiler.
+> Could you please provide me with explicit instructions on how to do this (or
+> direct me to a resource(s) where I can acquire such information)?
+>
+> Thank you,
+>
+
+You should have a .dll, .lib, .def, and three .h files. It is recommended
+that you use pthreadVC.dll, rather than pthreadVCE.dll or pthreadVSE.dll
+(see Q2 above).
+
+The .dll can go in any directory listed in your PATH environment
+variable, so putting it into C:\WINDOWS should work.
+
+The .lib file can go in any directory listed in your LIB environment
+variable.
+
+The .h files can go in any directory listed in your INCLUDE
+environment variable.
+
+Or you might prefer to put the .lib and .h files into a new directory
+and add its path to LIB and INCLUDE. You can probably do this easiest
+by editing the file:-
+
+C:\Program Files\DevStudio\vc\bin\vcvars32.bat
+
+The .def file isn't used by anything in the pre-compiled version but 
+is included for information.
+
+Cheers.
+Ross
+
+------------------------------------------------------------------------------
+
+Q 9	cancellation doesn't work for me, why?
+---
+
+> I'm investigating a problem regarding thread cancellation. The thread I want
+> to cancel has PTHREAD_CANCEL_ASYNCHRONOUS, however, this piece of code
+> blocks on the join():
+>
+>		if ((retv = Pthread_cancel( recvThread )) == 0)
+>		{
+>			retv = Pthread_join( recvThread, 0 );
+>		}
+>
+> Pthread_* are just macro's; they call pthread_*.
+>
+> The thread recvThread seems to block on a select() call. It doesn't get
+> cancelled.
+>
+> Two questions:
+>
+> 1) is this normal behaviour?
+>
+> 2) if not, how does the cancel mechanism work? I'm not very familliar to
+> win32 programming, so I don't really understand how the *Event() family of
+> calls work.
+
+The answer to your first question is, normal POSIX behaviour would  
+be to asynchronously cancel the thread. However, even that doesn't
+guarantee cancellation as the standard only says it should be
+cancelled as soon as possible.
+
+Snapshot 99-11-02 or earlier only partially supports asynchronous cancellation.
+Snapshots since then simulate async cancellation by poking the address of
+a cancellation routine into the PC of the threads context. This requires
+the thread to be resumed in some way for the cancellation to actually
+proceed. This is not true async cancellation, but it is as close as we've
+been able to get to it.
+
+If the thread you're trying to cancel is blocked (for instance, it could be
+waiting for data from the network), it will only get cancelled when it unblocks
+(when the data arrives). For true pre-emptive cancellation in these cases,
+pthreads-win32 from snapshot 2004-05-16 can automatically recognise and use the
+QueueUserAPCEx package by Panagiotis E. Hadjidoukas. This package is available
+from the pthreads-win32 ftp site and is included in the pthreads-win32
+self-unpacking zip from 2004-05-16 onwards.
+
+Using deferred cancellation would normally be the way to go, however,
+even though the POSIX threads standard lists a number of C library
+functions that are defined as deferred cancellation points, there is
+no hookup between those which are provided by Windows and the
+pthreads-win32 library.
+
+Incidently, it's worth noting for code portability that the older POSIX
+threads standards cancellation point lists didn't include "select" because
+(as I read in Butenhof) it wasn't part of POSIX. However, it does appear in
+the SUSV3.
+
+Effectively, the only mandatory cancellation points that pthreads-win32
+recognises are those the library implements itself, ie.
+	
+	pthread_testcancel
+	pthread_cond_wait
+	pthread_cond_timedwait
+	pthread_join
+	sem_wait
+	sem_timedwait
+	pthread_delay_np
+
+The following routines from the non-mandatory list in SUSV3 are
+cancellation points in pthreads-win32:
+
+	pthread_rwlock_wrlock
+	pthread_rwlock_timedwrlock
+
+The following routines from the non-mandatory list in SUSV3 are not
+cancellation points in pthreads-win32:
+
+	pthread_rwlock_rdlock
+	pthread_rwlock_timedrdlock
+
+Pthreads-win32 also provides two functions that allow you to create
+cancellation points within your application, but only for cases where
+a thread is going to block on a Win32 handle. These are:
+
+	pthreadCancelableWait(HANDLE waitHandle) /* Infinite wait */
+ 
+	pthreadCancelableTimedWait(HANDLE waitHandle, DWORD timeout)
+
+------------------------------------------------------------------------------
+ 
+
+Q 10	How do I create thread-safe applications using
+----	pthreadGCE.dll, libpthreadw32.a and Mingw32?
+
+This should not be a problem with recent versions of MinGW32.
+
+For early versions, see Thomas Pfaff's email at:
+http://sources.redhat.com/ml/pthreads-win32/2002/msg00000.html
+------------------------------------------------------------------------------
+
+Q 11    Why isn't pthread_t defined as a scalar (e.g. pointer or int)
+        like it is for other POSIX threads implementations?
+----
+
+The change from scalar to vector was made in response to the numerous
+queries we received at that time either requesting assistance to debug
+applications or reporting problems with the library that turned out to be
+application bugs. Since the change we have only received requests that
+we change back to scalar in order to support applications that are not
+compliant with POSIX.
+
+Originally we defined pthread_t as a pointer (to the opaque pthread_t_
+struct) and later we changed it to a struct containing the original
+pointer plus a sequence counter. This is not only allowed under both
+the original POSIX Threads Standard and the current Single Unix
+Specification, it is expected if the implemented chooses and is why
+the standard requires pthread_t to be an opaque type.
+
+When pthread_t is a simple pointer some very difficult thread management
+problems arise because the process of freeing and later allocing
+thread structs means that new pthread_t handles can acquire the identity of
+previously detached threads. There are solutions to manage this risk but
+they can easily introduce their own bugs and require all developers to
+spend significant time solving a problem that is not "core" to their work
+and that others have already solved. The problem is rarely solved in
+a portable and POSIX compliant way. It can't be because pthread_t is opaque,
+i.e. a developer is not supposed to assume anything about pthread_t. Several
+pthreads implmentations do provide non-portable aids, such as API calls to
+return unique sequence numbers etc.
+
+The change to a struct was made, along with some changes to their internal
+managment, in order to guarantee (for practical applications) that the
+pthread_t handle will be unique over the life of the running process.
+
+Where application code attempts to compare one pthread_t against another
+directly, a compiler error will be emitted because structs can't be
+compared at that level. This should signal a potentially serious problem
+in the code design, which would go undetected if pthread_t was a scalar.
+
+The POSIX Threading API provides a function named pthread_equal() to
+compare pthread_t thread handles.
+
+Other pthreads implementations, such as Sun's, use an int as the handle
+but do guarantee uniqueness within the process scope. Win32 scalar typed
+thread handles also guarantee uniqueness in system scope. It wasn't clear
+how well the internal management of these handles would scale as the
+number of threads and the fragmentation of the sequence numbering
+increased for applications where thousands or millions of threads are
+created and detached over time. The current management of threads within
+pthreads-win32 using structs for pthread_t, and reusing without ever
+freeing them, reduces the management time overheads to a constant, which
+could be important given that pthreads-win32 threads are built on top of
+Win32 threads and will therefore include that management overhead on top
+of their own. The cost is that the memory resources used for thread
+handles will remain at the peak level until the process exits.
+
+While it may be inconvenient for developers to be forced away from making
+assumptions about the internals of pthread_t, the advantage for the
+future development of pthread-win32, as well as those applications that
+use it, is that the library is free to change pthread_t internals and
+management as better methods arise.
+
diff --git a/src/include/pthread/LICENSE b/src/include/pthread/LICENSE
new file mode 100644
index 0000000..7a4a3ea
--- /dev/null
+++ b/src/include/pthread/LICENSE
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
\ No newline at end of file
diff --git a/src/include/pthread/MAINTAINERS b/src/include/pthread/MAINTAINERS
new file mode 100644
index 0000000..4314b6a
--- /dev/null
+++ b/src/include/pthread/MAINTAINERS
@@ -0,0 +1,3 @@
+CVS Repository maintainers
+
+Ross Johnson		Firstname.Lastname at LoungeByTheLake dot net
diff --git a/src/include/pthread/NEWS b/src/include/pthread/NEWS
new file mode 100644
index 0000000..b6c57c8
--- /dev/null
+++ b/src/include/pthread/NEWS
@@ -0,0 +1,1588 @@
+RELEASE 3.0.0
+--------------
+(2018-08-08)
+
+General
+-------
+Note that this is a new major release. The major version increment
+introduces two ABI changes along with other naming changes that will
+require recompilation of linking applications and possibly some textual
+changes to compile-time macro references in configuration and source
+files, e.g. PTW32_* changes to __PTW32_*, ptw32_* to __ptw32_*, etc.
+
+License Change
+--------------
+With the agreement of all substantial relevant contributors Pthreads4w
+version 3, with the exception of four files, is being released under the
+terms of the Apache License v2.0. The APLv2 is compatible with the GPLv3
+and LGPLv3 licenses and therefore this code may continue to be legally
+included within GPLv3 and LGPLv3 projects.
+
+A substantial relevant contributor was defined as one who has contributed
+original code that implements a capability present in the releases going
+forward. This excludes several contributors who have contributed code
+that has been obsoleted, or have provided patches that fix bugs,
+reorganise code for aesthetic or practical purposes, or improve build
+processes. This distinction was necessary in order to move forward in the
+likelyhood that not all contributors would be contactable. All
+contributors are listed in the file CONTRIBUTORS.
+
+The four files that will remain LGPL but change to v3 are files used to
+configure the GNU environment builds:
+
+	aclocal.m4
+	configure.ac
+	GNUmakefile.in
+	tests/GNUmakefile.in
+
+Contributors who have either requested this change or agreed to it when
+consulted are:
+
+John Bossom
+Alexander Terekhov
+Vladimir Kliatchko
+Ross Johnson
+
+Pthreads4w version 2 releases will remain LGPL but version 2.11 and later
+will be released under v3 of that license so that any additions to
+pthreads4w version 3 code that is backported to v2 will not pollute that
+code.
+
+Backporting and Support of Legacy Windows Releases
+--------------------------------------------------
+Some changes from 2011-02-26 onward may not be compatible with pre
+Windows 2000 systems.
+
+New bug fixes in all releases since 2.8.0 have NOT been applied to the
+1.x.x series.
+
+Testing and verification
+------------------------
+The MSVC, MinGW and MinGW64 builds have been tested on SMP architecture
+(Intel x64 Hex Core) by completing the included test suite, as well as the
+stress and bench tests.
+
+Be sure to run your builds against the test suite. If you see failures
+then please consider how your toolchains might be contributing to the
+failure. See the README file for more detailed descriptions of the
+toolchains and test systems that we have used to get the tests to pass
+successfully.
+
+We recommend MinGW64 over MinGW for both 64 and 32 bit GNU CC builds
+only because the MinGW DWARF2 exception handling with C++ builds causes some
+problems with thread cancelation.
+
+MinGW64 also includes its own native pthreads implementation, which you may
+prefer to use. If you wish to build our library you will need to select the
+Win32 native threads option at install time. We recommend also selecting the
+SJLJ exception handling method for MinGW64-w32 builds. For MinGW64-w64 builds
+either the SJLJ or SEH exception handling method should work.
+
+New Features
+------------
+Other than the following, this release is feature-equivalent to v2.11.0.
+
+This release introduces a change to pthread_t and pthread_once_t that will
+affect applications that link with the library.
+
+pthread_t: remains a struct but extends the reuse counter from 32 bits to 64
+bits. On 64 bit machines the overall size of the object will not increase, we
+simply put 4 bytes of padding to good use reducing the risk that the counter
+could wrap around in very long-running applications from small to, effectively,
+zero. The 64 bit reuse counter extends risk-free run time from months
+(assuming an average thread lifetime of 1ms) to centuries (assuming an
+average thread lifetime of 1ns).
+
+pthread_once_t: removes two long-obsoleted elements and reduces it's size.
+
+
+RELEASE 2.11.0
+--------------
+(2018-08-08)
+
+General
+-------
+New bug fixes in all releases since 2.8.0 have NOT been applied to the
+1.x.x series.
+
+Some changes from 2011-02-26 onward may not be compatible with
+pre Windows 2000 systems.
+
+License Change to LGPL v3
+-------------------------
+Pthreads4w version 2.11 and all future 2.x versions will be released
+under the Lesser GNU Public License version 3 (LGPLv3).
+
+Planned Release Under the Apache License v2
+-------------------------------------------
+The next major version of this software (version 3) will be released
+under the Apache License version 2.0 (ALv2). Releasing 2.11 under LGPLv3
+will allow modifications to version 3 of this software to be backported
+to version 2 going forward. Further to this, any GPL projects currently
+using this library will be able to continue to use either version 2 or 3
+of this code in their projects.
+
+For more information please see:
+https://www.apache.org/licenses/GPL-compatibility.html
+
+In order to remain consistent with this change, from this point on
+modifications to this library will only be accepted against version 3
+of this software under the terms of the ALv2. They will then, where
+appropriate, be backported to version 2.
+
+We hope to release version 3 at the same time as we release version 2.11.
+
+Testing and verification
+------------------------
+This version has been tested on SMP architecture (Intel x64 Hex Core)
+by completing the included test suite, as well as the stress and bench
+tests.
+
+Be sure to run your builds against the test suite. If you see failures
+then please consider how your toolchains might be contributing to the
+failure. See the README file for more detailed descriptions of the
+toolchains and test systems that we have used to get the tests to pass
+successfully. We recommend MinGW64 over MinGW32 for both 64 and 32 bit
+GNU CC builds. MinGW64 also includes its own independent pthreads
+implementation, which you may prefer to use.
+
+New Features or Changes
+-----------------------
+For Microsoft toolchain builds:
+(1) Static linking requires both this library and any linking
+libraries or applications to be compiled with /MT consistently.
+
+(2) Static libraries have been renamed as libpthreadV*.lib
+to differentiate them from DLL import libs pthreadV*.lib.
+
+(3) If you are using mixed linkage, e.g. linking the static /MT version
+of the library to an application linked with /MD you may be able to use
+GetLastError() to interrogate the error code because the library sets
+both errno (via _set_errno()) and SetLastError().
+
+Bug Fixes
+---------
+Remove the attempt to set PTW32_USES_SEPARATE_CRT in the headers which
+can cause unexpected results. In certain situations a user may want to
+define it explicitly in their environment to invoke it's effects, either
+when buidling the library or an application or both. See README.NONPORTABLE.
+-- Ross Johnson
+
+The library should be more reliable under fully statically linked
+scenarios. Note: we have removed the PIMAGE_TLS_CALLBACK code and
+reverted to the earlier method that appears to be more reliable
+across all compiler editions.
+- Mark Pizzolato
+
+Various corrections to GNUmakefile. Although this file has been removed, 
+for completeness the changes have been recorded as commits to the
+repository.
+- Kyle Schwarz
+
+MinGW64-w64 defines pid_t as __int64. sched.h now reflects that.
+- Kyle Schwarz
+
+Several tests have been fixed that were seen to fail on machines under
+load. Other tests that used similar crude mechanisms to synchronise
+threads (these are unit tests) had the same improvements applied:
+semaphore5.c recognises that sem_destroy can legitimately return
+EBUSY; mutex6*.c, mutex7*.c and mutex8*.c all replaced a single
+Sleep() with a polling loop.
+- Ross Johnson
+
+
+RELEASE 2.10.0
+--------------
+(2016-09-18)
+
+General
+-------
+New bug fixes in all releases since 2.8.0 have NOT been applied to the
+1.x.x series.
+
+Some changes from 2011-02-26 onward may not be compatible with
+pre Windows 2000 systems.
+
+Testing and verification
+------------------------
+This version has been tested on SMP architecture (Intel x64 Hex Core)
+by completing the included test suite, as well as the stress and bench
+tests.
+
+Be sure to run your builds against the test suite. If you see failures
+then please consider how your toolchains might be contributing to the
+failure. See the README file for more detailed descriptions of the
+toolchains and test systems that we have used to get the tests to pass
+successfully. We recommend MinGW64 over MinGW32 for both 64 and 32 bit
+GNU CC builds. MinGW64 also includes its own independent pthreads
+implementation, which you may prefer to use.
+
+New Features
+------------
+New routines:
+pthread_timedjoin_np()
+pthread_tryjoin_np()
+ - added for compatibility with Linux.
+sched_getaffinity()
+sched_setaffinity()
+pthread_getaffinity_np()
+pthread_setaffinity_np()
+pthread_attr_getaffinity_np()
+pthread_attr_setaffinity_np()
+ - added for compatibility with Linux and other libgcc-based systems.
+   The macros to manipulate cpu_set_t objects (the cpu affinity mask
+   vector) are also defined: CPU_ZERO, CPU_CLR, CPU_SET, CPU_EQUAL,
+   CPU_AND, CPU_OR, CPU_XOR, CPU_COUNT, CPU_ISSET.
+pthread_getname_np()
+pthread_setname_np()
+pthread_attr_getname_np()
+pthread_attr_setname_np()
+ - added for compatibility with other POSIX implementations. Because
+   some implementations use different *_setname_np() prototypes
+   you can define one of the following macros when building the library:
+      __PTW32_COMPATIBILITY_BSD (compatibility with NetBSD, FreeBSD)
+      __PTW32_COMPATIBILITY_TRU64
+   If not defined then compatibility is with Linux and other equivalents.
+   We don't impose a strict limit on the length of the thread name for the
+   default compatibility case. Unlike Linux, no default thread name is set.
+   For MSVC builds, the thread name if set is made available for use by the
+   MSVS debugger, i.e. it should be displayed within the debugger to
+   identify the thread in place of/as well as a threadID.
+pthread_win32_getabstime_np()
+ - Return the current time plus an optional offset in a platform-aware way
+   that is compatible with POSIX timed calls (returns the struct timespec
+   address which is the first argument). Intended primarily to make it
+   easier to write tests but may be useful for applications generally. 
+GNU compiler environments (MinGW32 and MinGW64) now have the option of using
+autoconf to automatically configure the build.
+
+Builds:
+New makefile targets have been added and existing targets modified or
+removed. For example, targets to build and test all of the possible
+configurations of both dll and static libs.
+
+GNU compiler builds are now explicitly using ISO C and C++ 2011 standards
+compatibility. If your GNU compiler doesn't support this please consider
+updating. Auto configuration is now possible via 'configure' script. The
+script must be generated using autoconf - see the README file. Thanks to
+Keith Marshall from the MinGW project.
+
+Static linking:
+The autostatic functionality has been moved to dll.c, and extended so
+that builds using MSVC8 and later no longer require apps to call
+pthread_win32_thread_detach_np(). That is, all of the DllMain
+functionality is now automatic for static linking for these builds.
+
+Some nmake static linking targets have been disabled:
+Due to an issue with TLS behaviour, the V*-small-static* nmake targets
+in Makefile have been disabled. The issue is exposed by tests/semaphore3.c
+where the pthread_self() call inside the thread fails to return the
+correct POSIX thread handle but returns a new "implicit" POSIX thread
+handle instead. Implicit pthread handles have detached thread status, which
+causes the pthread_detach() call inside the thread to return EINVAL. The
+V*-static* targets appear to be not affected. The primary difference is
+that the latter are generated from a single compilation unit.
+
+Bug Fixes
+---------
+Small object file static linking now works (MinGW). The autostatic code
+is required but nothing explicitly referenced this code so was getting
+optimised out.
+- Daniel Richard G.
+
+sem_getvalue() could return the errno value instead of setting errno
+and returning -1.
+- Ross Johnson
+
+Errno values were being lost if the library is statically linked
+with the runtime library, meaning also that the application used a
+separate runtime instance. This is still the case except a build
+switch has been added that allows more robust error status to be
+incorporated, i.e. allow the return code to be retrieved via
+GetLastError().
+- Daniel Richard G.
+
+Identified the cause of significant failures around cancelation
+and pthread_exit() for the GCE (GNU C++) build configuration as
+coming from Mingw32. Not sure if this is general or just when
+building 32 bit libraries and apps that run on 64 bit systems.
+These failures do not arise with Mingw64 32 bit builds (GCC built
+with multilib enabled) running on 64 bit systems.
+- Daniel Richard G. and Ross Johnson
+
+pthread_key_delete() bug introduced in release 2.9.x caused this
+routine to fail in a way that the test suite was not detecting. A
+new test has been added to confirm that this routine behaves
+correctly, particularly when keys with destructors are deleted
+before threads exit.
+- Stephane Clairet
+
+pthread_win32_process_attach_np() fix potential failure/security around
+finding and loading of QUSEREX.DLL.
+- Jason Baker
+
+_POSIX_THREAD_ATTR_STACKADDR is now set equal to -1 in pthread.h. As a
+consequence pthread_attr_setstackaddr() now returns ENOSYS. Previously
+the value was stored and could be retrieved but was otherwise unused.
+pthread_attr_getstackaddr() returns ENOSYS correspondingly.
+- Ross Johnson
+
+Fixed a potential memory leak in pthread_mutex_init(). The leak would
+only occur if the mutex initialisation failed (extremely rare if ever).
+- Jaeeun Choi
+
+Fixed sub-millisecond timeouts, which caused the library to busy wait.
+- Mark Smith
+
+Fix a race condition and crash in MCS locks. The waiter queue management
+code in __ptw32_mcs_lock_acquire was racing with the queue management code
+in __ptw32_mcs_lock_release and causing a segmentation fault.
+- Anurag Sharma
+- Jonathan Brown (also reported this bug and provided a fix)
+
+RELEASE 2.9.1
+-------------
+(2012-05-27)
+
+General
+-------
+New bug fixes in this release since 2.8.0 have NOT been applied to the
+1.x.x series.
+
+This release replaces an extremely brief 2.9.0 release and adds
+some last minute non-code changes were made to embed better
+descriptive properties in the dlls to indicate target architecture
+and build environments.
+
+Some changes post 2011-02-26 in CVS may not be compatible with pre
+Windows 2000 systems.
+
+Use of other than the "C" version of the library is now discouraged.
+That is, the "C++" version fails some tests and does not provide any
+additional functionality.
+
+Testing and verification
+------------------------
+This version has been tested on SMP architecture (Intel x64 Hex Core)
+by completing the included test suite, stress and bench tests.
+
+New Features
+------------
+DLL properties now properly includes the target architecture, i.e.
+right-click on the file pthreadVC2.dll in explorer and choose the Detail
+tab will show the compiler and architecture in the description field, e.g.
+"MS C x64" or "MS C x86".
+- Ross Johnson
+
+(MSC and GNU builds) The statically linked library now automatically
+initialises and cleans up on program start/exit, i.e. statically linked
+applications need not call the routines pthread_win32_process_attach_np()
+and pthread_win32_process_detach_np() explicitly. The per-thread routine
+pthread_win32_thread_detach_np() is also called at program exit to cleanup
+POSIX resources acquired by the primary Windows native thread, if I (RJ)
+understand the process correctly. Other Windows native threads that call
+POSIX API routines may need to call the thread detach routine on thread
+exit if the application depends on reclaimed POSIX resources or running
+POSIX TSD (TLS) destructors.
+See README.NONPORTABLE for descriptions of these routines.
+- Ramiro Polla
+
+Robust mutexes are implemented within the PROCESS_PRIVATE scope. NOTE that
+pthread_mutex_* functions may return different error codes for robust
+mutexes than they otherwise do in normal usage, e.g.  pthread_mutex_unlock
+is required to check ownership for all mutex types when the mutex is
+robust, whereas this does not occur for the "normal" non-robust mutex type.
+- Ross Johnson
+
+pthread_getunique_np is implemented for source level compatibility
+with some other implementations. This routine returns a 64 bit
+sequence number that is uniquely associated with a thread. It can be
+used by applications to order or hash POSIX thread handles.
+- Ross Johnson
+
+Bug fixes
+---------
+Many more changes for 64 bit systems.
+- Kai Tietz
+
+Various modifications and fixes to build and test for WinCE.
+- Marcel Ruff, Sinan Kaya
+
+Fix pthread_cond_destroy() - should not be a cancellation point. Other
+minor build problems fixed.
+- Romano Paolo Tenca
+
+Remove potential deadlock condition from pthread_cond_destroy().
+- Eric Berge
+
+Various modifications to build and test for Win64.
+- Kip Streithorst
+
+Various fixes to the QueueUserAPCEx async cancellation helper DLL
+(this is a separate download) and pthreads code cleanups.
+- Sebastian Gottschalk
+
+Removed potential NULL pointer reference.
+- Robert Kindred
+
+Removed the requirement that applications restrict the number of threads
+calling pthread_barrier_wait to just the barrier count. Also reduced the
+contention between barrier_wait and barrier_destroy. This change will have
+slowed barriers down slightly but halves the number of semaphores consumed
+per barrier to one.
+- Ross Johnson
+
+Fixed a handle leak in sched_[gs]etscheduler.
+- Mark Pizzolato
+
+Removed all of the POSIX re-entrant function compatibility macros from pthread.h.
+Some were simply not semanticly correct.
+- Igor Lubashev
+
+Threads no longer attempt to pass uncaught exceptions out of thread scope (C++
+and SEH builds only). Uncaught exceptions now cause the thread to exit with
+the return code PTHREAD_CANCELED.
+- Ross Johnson
+
+Lots of casting fixes particularly for x64, Interlocked fixes and reworking
+for x64.
+- Daniel Richard G., John Kamp
+
+Other changes
+-------------
+Dependence on the winsock library is now discretionary via
+#define RETAIN_WSALASTERROR in config.h. It is undefined by default unless
+WINCE is defined (because RJ is unsure of the dependency there).
+- Ramiro Polla
+
+Several static POSIX mutexes used for internal management were replaced by
+MCS queue-based locks to reduce resource consumption, in particular use of Win32
+objects.
+- Ross Johnson
+
+For security, the QuserEx.dll if used must now be installed in the Windows System
+folder.
+- Ross Johnson
+
+New tests
+---------
+robust[1-5].c - Robust mutexes
+sequence1.c - per-thread unique sequence numbers
+
+Modified tests and benchtests
+-----------------------------
+All mutex*.c tests wherever appropriate have been modified to also test
+robust mutexes under the same conditions.
+Added robust mutex benchtests to benchtest*.c wherever appropriate.
+
+
+RELEASE 2.8.0
+-------------
+(2006-12-22)
+
+General
+-------
+New bug fixes in this release since 2.7.0 have not been applied to the
+version 1.x.x series. It is probably time to drop version 1.
+
+Testing and verification
+------------------------
+This release has not yet been tested on SMP architechtures. All tests pass
+on a uni-processor system.
+
+Bug fixes
+---------
+Sem_destroy could return EBUSY even though no threads were waiting on the 
+semaphore. Other races around invalidating semaphore structs (internally)
+have been removed as well.
+
+New tests
+---------
+semaphore5.c - tests the bug fix referred to above.
+
+
+RELEASE 2.7.0
+-------------
+(2005-06-04)
+
+General
+-------
+All new features in this release have been back-ported in release 1.11.0,
+including the incorporation of MCS locks in pthread_once, however, versions
+1 and 2 remain incompatible even though they are now identical in
+performance and functionality.
+
+Testing and verification
+------------------------
+This release has been tested (passed the test suite) on both uni-processor
+and multi-processor systems.
+- Tim Theisen
+
+Bug fixes
+---------
+Pthread_once has been re-implemented to remove priority boosting and other
+complexity to improve robustness. Races for Win32 handles that are not
+recycle-unique have been removed. The general form of pthread_once is now
+the same as that suggested earlier by Alexander Terekhov, but instead of the
+'named mutex', a queue-based lock has been implemented which has the required
+properties of dynamic self initialisation and destruction. This lock is also
+efficient. The ABI is unaffected in as much as the size of pthread_once_t has
+not changed and PTHREAD_ONCE_INIT has not changed, however, applications that
+peek inside pthread_once_t, which is supposed to be opaque, will break.
+- Vladimir Kliatchko
+
+New features
+------------
+* Support for Mingw cross development tools added to GNUmakefile.
+Mingw cross tools allow building the libraries on Linux.
+- Mikael Magnusson
+
+
+RELEASE 2.6.0
+-------------
+(2005-05-19)
+
+General
+-------
+All of the bug fixes and new features in this release have been
+back-ported in release 1.10.0.
+
+Testing and verification
+------------------------
+This release has been tested (passed the test suite) on both uni-processor
+and multi-processor systems. Thanks to Tim Theisen at TomoTherapy for
+exhaustively running the MP tests and for providing crutial observations
+and data when faults are detected.
+
+Bugs fixed
+----------
+
+* pthread_detach() now reclaims remaining thread resources if called after
+the target thread has terminated. Previously, this routine did nothing in
+this case.
+
+New tests
+---------
+
+* detach1.c - tests that pthread_detach properly invalidates the target
+thread, which indicates that the thread resources have been reclaimed.
+
+
+RELEASE 2.5.0
+-------------
+(2005-05-09)
+
+General
+-------
+
+The package now includes a reference documentation set consisting of
+HTML formatted Unix-style manual pages that have been edited for
+consistency with Pthreads-w32. The set can also be read online at:
+https://sourceforge.net/projects/pthreads4w/manual/index.html
+
+Thanks again to Tim Theisen for running the test suite pre-release
+on an MP system.
+
+All of the bug fixes and new features in this release have been
+back-ported in release 1.9.0.
+
+Bugs fixed
+----------
+
+* Thread Specific Data (TSD) key management has been ammended to
+eliminate a source of (what was effectively) resource leakage (a HANDLE
+plus memory for each key destruct routine/thread association). This was
+not a true leak because these resources were eventually reclaimed when
+pthread_key_delete was run AND each thread referencing the key had exited.
+The problem was that these two conditions are often not met until very
+late, and often not until the process is about to exit.
+
+The ammended implementation avoids the need for the problematic HANDLE
+and reclaims the memory as soon as either the key is deleted OR the
+thread exits, whichever is first.
+
+Thanks to Richard Hughes at Aculab for identifying and locating the leak.
+
+* TSD key destructors are now processed up to PTHREAD_DESTRUCTOR_ITERATIONS
+times instead of just once. PTHREAD_DESTRUCTOR_ITERATIONS has been
+defined in pthread.h for some time but not used.
+
+* Fix a semaphore accounting race between sem_post/sem_post_multiple
+and sem_wait cancellation. This is the same issue as with
+sem_timedwait that was fixed in the last release.
+
+* sem_init, sem_post, and sem_post_multiple now check that the
+semaphore count never exceeds _POSIX_SEM_VALUE_MAX.
+
+* Although sigwait() is nothing more than a no-op, it should at least
+be a cancellation point to be consistent with the standard.
+
+New tests
+---------
+
+* stress1.c - attempts to expose problems in condition variable
+and semaphore timed wait logic. This test was inspired by Stephan
+Mueller's sample test code used to identify the sem_timedwait bug
+from the last release. It's not a part of the regular test suite
+because it can take awhile to run. To run it:
+nmake clean VC-stress
+
+* tsd2.c - tests that key destructors are re-run if the tsd key value is
+not NULL after the destructor routine has run. Also tests that
+pthread_setspecific() and pthread_getspecific() are callable from
+destructors.
+
+
+RELEASE 2.4.0
+-------------
+(2005-04-26)
+
+General
+-------
+
+There is now no plan to release a version 3.0.0 to fix problems in
+pthread_once(). Other possible implementations of pthread_once
+will still be investigated for a possible future release in an attempt
+to reduce the current implementation's complexity.
+
+All of the bug fixes and new features in this release have been
+back-ported for release 1.8.0.
+
+Bugs fixed
+----------
+
+* Fixed pthread_once race (failures on an MP system). Thanks to
+Tim Theisen for running exhaustive pre-release testing on his MP system
+using a range of compilers:
+  VC++ 6
+  VC++ 7.1
+  Intel C++ version 8.0
+All tests passed.
+Some minor speed improvements were also done.
+
+* Fix integer overrun error in pthread_mutex_timedlock() - missed when
+sem_timedwait() was fixed in release 2.2.0. This routine no longer returns
+ENOTSUP when NEED_SEM is defined - it is supported (NEED_SEM is only
+required for WinCE versions prior to 3.0).
+
+* Fix timeout bug in sem_timedwait().
+- Thanks to Stephan Mueller for reporting, providing diagnostic output
+and test code.
+
+* Fix several problems in the NEED_SEM conditionally included code.
+NEED_SEM included code is provided for systems that don't implement W32
+semaphores, such as WinCE prior to version 3.0. An alternate implementation
+of POSIX semaphores is built using W32 events for these systems when
+NEED_SEM is defined. This code has been completely rewritten in this
+release to reuse most of the default POSIX semaphore code, and particularly,
+to implement all of the sem_* routines supported by Pthreads4w. Tim
+Theisen also run the test suite over the NEED_SEM code on his MP system. All
+tests passed.
+
+* The library now builds without errors for the Borland Builder 5.5 compiler.
+
+New features
+------------
+
+* pthread_mutex_timedlock() and all sem_* routines provided by
+Pthreads4w are now implemented for WinCE versions prior to 3.0. Those
+versions did not implement W32 semaphores. Define NEED_SEM in config.h when
+building the library for these systems.
+
+Known issues in this release
+----------------------------
+
+* pthread_once is too complicated - but it works as far as testing can
+determine..
+
+* The Borland version of the dll fails some of the tests with a memory read
+exception. The cause is not yet known but a compiler bug has not been ruled
+out.
+
+
+RELEASE 2.3.0
+-------------
+(2005-04-12)
+
+General
+-------
+
+Release 1.7.0 is a backport of features and bug fixes new in
+this release. See earlier notes under Release 2.0.0/General.
+
+Bugs fixed
+----------
+
+* Fixed pthread_once potential for post once_routine cancellation
+hanging due to starvation. See comments in pthread_once.c.
+Momentary priority boosting is used to ensure that, after a
+once_routine is cancelled, the thread that will run the
+once_routine is not starved by higher priority waiting threads at
+critical times. Priority boosting occurs only AFTER a once_routine 
+cancellation, and is applied only to that once_control. The
+once_routine is run at the thread's normal base priority.
+
+New tests
+---------
+
+* once4.c: Aggressively tests pthread_once() under realtime
+conditions using threads with varying priorities. Windows'
+random priority boosting does not occur for threads with realtime
+priority levels.
+
+
+RELEASE 2.2.0
+-------------
+(2005-04-04)
+
+General
+-------
+
+* Added makefile targets to build static link versions of the library.
+Both MinGW and MSVC. Please note that this does not imply any change
+to the LGPL licensing, which still imposes psecific conditions on
+distributing software that has been statically linked with this library.
+
+* There is a known bug in pthread_once(). Cancellation of the init_routine
+exposes a potential starvation (i.e. deadlock) problem if a waiting thread
+has a higher priority than the initting thread. This problem will be fixed
+in version 3.0.0 of the library.
+
+Bugs fixed
+----------
+
+* Fix integer overrun error in sem_timedwait().
+Kevin Lussier
+
+* Fix preprocessor directives for static linking.
+Dimitar Panayotov
+
+
+RELEASE 2.1.0
+-------------
+(2005-03-16)
+
+Bugs fixed
+----------
+
+* Reverse change to pthread_setcancelstate() in 2.0.0.
+
+
+RELEASE 2.0.0
+-------------
+(2005-03-16)
+
+General
+-------
+
+This release represents an ABI change and the DLL version naming has
+incremented from 1 to 2, e.g. pthreadVC2.dll.
+
+Version 1.4.0 back-ports the new functionality included in this
+release. Please distribute DLLs built from that version with updates
+to applications built on pthreads-win32 version 1.x.x.
+
+The package naming has changed, replacing the snapshot date with 
+the version number + descriptive information. E.g. this
+release is "pthreads-w32-2-0-0-release".
+
+Bugs fixed
+----------
+
+* pthread_setcancelstate() no longer checks for a pending
+async cancel event if the library is using alertable async
+cancel. See the README file (Prerequisites section) for info
+on adding alertable async cancellation.
+
+New features
+------------
+
+* pthread_once() now supports init_routine cancellability.
+
+New tests
+---------
+
+* Agressively test pthread_once() init_routine cancellability.
+
+
+SNAPSHOT 2005-03-08
+-------------------
+Version 1.3.0
+
+Bug reports (fixed)
+-------------------
+
+* Implicitly created threads leave Win32 handles behind after exiting.
+- Dmitrii Semii
+
+* pthread_once() starvation problem.
+- Gottlob Frege
+
+New tests
+---------
+
+* More intense testing of pthread_once().
+
+
+SNAPSHOT 2005-01-25
+-------------------
+Version 1.2.0
+
+Bug fixes
+---------
+
+* Attempted acquisition of a recursive mutex could cause waiting threads
+to not be woken when the mutex was released.
+- Ralf Kubis  <RKubis at mc.com>
+
+* Various package omissions have been fixed.
+
+
+SNAPSHOT 2005-01-03
+-------------------
+Version 1.1.0
+
+Bug fixes
+---------
+
+* Unlocking recursive or errorcheck mutexes would sometimes
+unexpectedly return an EPERM error (bug introduced in
+snapshot-2004-11-03).
+- Konstantin Voronkov  <beowinkle at yahoo.com>
+
+
+SNAPSHOT 2004-11-22
+-------------------
+Version 1.0.0
+
+This snapshot primarily fixes the condvar bug introduced in
+snapshot-2004-11-03. DLL versioning has also been included to allow
+applications to runtime check the Microsoft compatible DLL version
+information, and to extend the DLL naming system for ABI and major
+(non-backward compatible) API changes. See the README file for details.
+
+Bug fixes
+---------
+
+* Condition variables no longer deadlock (bug introduced in
+snapshot-2004-11-03).
+- Alexander Kotliarov and Nicolas at saintmac
+
+* DLL naming extended to avoid 'DLL hell' in the future, and to
+accommodate the ABI change introduced in snapshot-2004-11-03. Snapshot
+2004-11-03 will be removed from FTP sites.
+
+New features
+------------
+
+* A Microsoft-style version resource has been added to the DLL for
+applications that wish to check DLL compatibility at runtime.
+
+* Pthreads4w DLL naming has been extended to allow incompatible DLL
+versions to co-exist in the same filesystem. See the README file for details,
+but briefly: while the version information inside the DLL will change with
+each release from now on, the DLL version names will only change if the new
+DLL is not backward compatible with older applications.
+
+The versioning scheme has been borrowed from GNU Libtool, and the DLL
+naming scheme is from Cygwin. Provided the Libtool-style numbering rules are
+honoured, the Cygwin DLL naming scheme automatcally ensures that DLL name
+changes are minimal and that applications will not load an incompatible
+Pthreads4w DLL.
+
+Those who use the pre-built DLLs will find that the DLL/LIB names have a new
+suffix (1) in this snapshot. E.g. pthreadVC1.dll etc.
+
+* The POSIX thread ID reuse uniqueness feature introduced in the last snapshot
+has been kept as default, but the behaviour can now be controlled when the DLL
+is built to effectively switch it off. This makes the library much more
+sensitive to applications that assume that POSIX thread IDs are unique, i.e.
+are not strictly compliant with POSIX. See the  __PTW32_THREAD_ID_REUSE_INCREMENT
+macro comments in config.h for details.
+
+Other changes
+-------------
+Certain POSIX macros have changed.
+
+These changes are intended to conform to the Single Unix Specification version 3,
+which states that, if set to 0 (zero) or not defined, then applications may use
+sysconf() to determine their values at runtime. Pthreads4w does not
+implement sysconf().
+
+The following macros are no longer undefined, but defined and set to -1
+(not implemented):
+
+      _POSIX_THREAD_ATTR_STACKADDR
+      _POSIX_THREAD_PRIO_INHERIT
+      _POSIX_THREAD_PRIO_PROTECT
+      _POSIX_THREAD_PROCESS_SHARED
+
+The following macros are defined and set to 200112L (implemented):
+
+      _POSIX_THREADS
+      _POSIX_THREAD_SAFE_FUNCTIONS
+      _POSIX_THREAD_ATTR_STACKSIZE
+      _POSIX_THREAD_PRIORITY_SCHEDULING
+      _POSIX_SEMAPHORES
+      _POSIX_READER_WRITER_LOCKS
+      _POSIX_SPIN_LOCKS
+      _POSIX_BARRIERS
+
+The following macros are defined and set to appropriate values:
+
+      _POSIX_THREAD_THREADS_MAX
+      _POSIX_SEM_VALUE_MAX
+      _POSIX_SEM_NSEMS_MAX
+      PTHREAD_DESTRUCTOR_ITERATIONS
+      PTHREAD_KEYS_MAX
+      PTHREAD_STACK_MIN
+      PTHREAD_THREADS_MAX
+
+
+SNAPSHOT 2004-11-03
+-------------------
+
+DLLs produced from this snapshot cannot be used with older applications without
+recompiling the application, due to a change to pthread_t to provide unique POSIX
+thread IDs.
+
+Although this snapshot passes the extended test suite, many of the changes are
+fairly major, and some applications may show different behaviour than previously,
+so adopt with care. Hopefully, any changed behaviour will be due to the library
+being better at it's job, not worse.
+
+Bug fixes
+---------
+
+* pthread_create() no longer accepts NULL as the thread reference arg.
+A segfault (memory access fault) will result, and no thread will be
+created.
+
+* pthread_barrier_wait() no longer acts as a cancellation point.
+
+* Fix potential race condition in pthread_once()
+- Tristan Savatier  <tristan at mpegtv.com>
+
+* Changes to pthread_cond_destroy() exposed some coding weaknesses in several
+test suite mini-apps because pthread_cond_destroy() now returns EBUSY if the CV
+is still in use.
+
+New features
+------------
+
+* Added for compatibility:
+PTHREAD_RECURSIVE_MUTEX_INITIALIZER,
+PTHREAD_ERRORCHECK_MUTEX_INITIALIZER,
+PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP,
+PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP
+
+* Initial support for Digital Mars compiler
+- Anuj Goyal  <anuj.goyal at gmail.com>
+
+* Faster Mutexes. These have been been rewritten following a model provided by
+Alexander Terekhov that reduces kernel space checks, and eliminates some additional
+critical sections used to manage a race between timedlock expiration and unlock.
+Please be aware that the new mutexes do not enforce strict absolute FIFO scheduling
+of mutexes, however any out-of-order lock acquisition should be very rare.
+
+* Faster semaphores. Following a similar model to mutexes above, these have been
+rewritten to use preliminary users space checks.
+
+* sem_getvalue() now returns the number of waiters.
+
+* The POSIX thread ID now has much stronger uniqueness characteristics. The library
+garrantees not to reuse the same thread ID for at least 2^(wordsize) thread
+destruction/creation cycles.
+
+New tests
+---------
+
+* semaphore4.c: Tests cancellation of the new sem_wait().
+
+* semaphore4t.c: Likewise for sem_timedwait().
+
+* rwlock8.c: Tests and times the slow execution paths of r/w locks, and the CVs,
+mutexes, and semaphores that they're built on.
+
+
+SNAPSHOT 2004-05-16
+-------------------
+
+Attempt to add Watcom to the list of compilers that can build the library.
+This failed in the end due to it's non-thread-aware errno. The library
+builds but the test suite fails. See README.Watcom for more details.
+
+Bug fixes
+---------
+* Bug and memory leak in sem_init()
+- Alex Blanco  <Alex.Blanco at motorola.com>
+
+* __ptw32_getprocessors() now returns CPU count of 1 for WinCE.
+- James Ewing  <james.ewing at sveasoft.com>
+
+* pthread_cond_wait() could be canceled at a point where it should not
+be cancelable. Fixed.
+- Alexander Terekhov  <TEREKHOV at de.ibm.com>
+
+* sem_timedwait() had an incorrect timeout calculation.
+- Philippe Di Cristo  <philipped at voicebox.com>
+
+* Fix a memory leak left behind after threads are destroyed.
+- P. van Bruggen  <pietvb at newbridges.nl>
+
+New features
+------------
+* Ported to AMD64.
+- Makoto Kato  <raven at oldskool.jp>
+
+* True pre-emptive asynchronous cancellation of threads. This is optional
+and requires that Panagiotis E. Hadjidoukas's QueueUserAPCEx package be
+installed. This package is included in the pthreads-win32 self-unpacking
+Zip archive starting from this snapshot. See the README.txt file inside
+the package for installation details.
+
+Note: If you don't use async cancellation in your application, or don't need
+to cancel threads that are blocked on system resources such as network I/O,
+then the default non-preemptive async cancellation is probably good enough.
+However, pthreads-win32 auto-detects the availability of these components
+at run-time, so you don't need to rebuild the library from source if you
+change your mind later.
+
+All of the advice available in books and elsewhere on the undesirability
+of using async cancellation in any application still stands, but this
+feature is a welcome addition with respect to the library's conformance to
+the POSIX standard.
+
+SNAPSHOT 2003-09-18
+-------------------
+
+Cleanup of thread priority management. In particular, setting of thread
+priority now attempts to map invalid Win32 values within the range returned
+by sched_get_priority_min/max() to useful values. See README.NONPORTABLE
+under "Thread priority".
+
+Bug fixes
+---------
+* pthread_getschedparam() now returns the priority given by the most recent
+call to pthread_setschedparam() or established by pthread_create(), as
+required by the standard. Previously, pthread_getschedparam() incorrectly
+returned the running thread priority at the time of the call, which may have
+been adjusted or temporarily promoted/demoted.
+
+* sched_get_priority_min() and sched_get_priority_max() now return -1 on error
+and set errno. Previously, they incorrectly returned the error value directly.
+
+
+SNAPSHOT 2003-09-04
+-------------------
+
+Bug fixes
+---------
+* __ptw32_cancelableWait() now allows cancellation of waiting implicit POSIX
+threads.
+
+New test
+--------
+* cancel8.c tests cancellation of Win32 threads waiting at a POSIX cancellation
+point.
+
+
+SNAPSHOT 2003-09-03
+-------------------
+
+Bug fixes
+---------
+* pthread_self() would free the newly created implicit POSIX thread handle if
+DuplicateHandle failed instead of recycle it (very unlikely).
+
+* pthread_exit() was neither freeing nor recycling the POSIX thread struct
+for implicit POSIX threads.
+
+New feature - cancellation of/by Win32 (non-POSIX) threads
+---------------------------------------------------------
+Since John Bossom's original implementation, the library has allowed non-POSIX
+initialised threads (Win32 threads) to call Pthreads4w routines and
+therefore interact with POSIX threads. This is done by creating an on-the-fly
+POSIX thread ID for the Win32 thread that, once created, allows fully
+reciprical interaction. This did not extend to thread cancellation (async or
+deferred). Now it does.
+
+Any thread can be canceled by any other thread (Win32 or POSIX) if the former
+thread's POSIX pthread_t value is known. It's TSD destructors and POSIX
+cleanup handlers will be run before the thread exits with an exit code of
+PTHREAD_CANCELED (retrieved with GetExitCodeThread()).
+
+This allows a Win32 thread to, for example, call POSIX CV routines in the same way
+that POSIX threads would/should, with pthread_cond_wait() cancelability and
+cleanup handlers (pthread_cond_wait() is a POSIX cancellation point).
+
+By adding cancellation, Win32 threads should now be able to call all POSIX
+threads routines that make sense including semaphores, mutexes, condition
+variables, read/write locks, barriers, spinlocks, tsd, cleanup push/pop,
+cancellation, pthread_exit, scheduling, etc.
+
+Note that these on-the-fly 'implicit' POSIX thread IDs are initialised as detached
+(not joinable) with deferred cancellation type. The POSIX thread ID will be created
+automatically by any POSIX routines that need a POSIX handle (unless the routine
+needs a pthread_t as a parameter of course). A Win32 thread can discover it's own
+POSIX thread ID by calling pthread_self(), which will create the handle if
+necessary and return the pthread_t value.
+
+New tests
+---------
+Test the above new feature.
+
+
+SNAPSHOT 2003-08-19
+-------------------
+
+This snapshot fixes some accidental corruption to new test case sources.
+There are no changes to the library source code.
+
+
+SNAPSHOT 2003-08-15
+-------------------
+
+Bug fixes
+---------
+
+* pthread.dsp now uses correct compile flags (/MD).
+- Viv  <vcotirlea@hotmail.com>
+
+* pthread_win32_process_detach_np() fixed memory leak.
+- Steven Reddie  <Steven.Reddie@ca.com>
+
+* pthread_mutex_destroy() fixed incorrect return code.
+- Nicolas Barry  <boozai@yahoo.com>
+
+* pthread_spin_destroy() fixed memory leak.
+- Piet van Bruggen  <pietvb@newbridges.nl>
+
+* Various changes to tighten arg checking, and to work with later versions of
+MinGW32 and MsysDTK.
+
+* pthread_getschedparam() etc, fixed dangerous thread validity checking.
+- Nicolas Barry  <boozai@yahoo.com>
+
+* POSIX thread handles are now reused and their memory is not freed on thread exit.
+This allows for stronger thread validity checking.
+
+New standard routine
+--------------------
+
+* pthread_kill() added to provide thread validity checking to applications.
+It does not accept any non zero values for the signal arg.
+
+New test cases
+--------------
+
+* New test cases to confirm validity checking, pthread_kill(), and thread reuse.
+
+
+SNAPSHOT 2003-05-10
+-------------------
+
+Bug fixes
+---------
+
+* pthread_mutex_trylock() now returns correct error values.
+pthread_mutex_destroy() will no longer destroy a recursively locked mutex.
+pthread_mutex_lock() is no longer inadvertantly behaving as a cancellation point.
+- Thomas Pfaff  <tpfaff@gmx.net>
+
+* pthread_mutex_timedlock() no longer occasionally sets incorrect mutex
+ownership, causing deadlocks in some applications.
+- Robert Strycek <strycek@posam.sk> and Alexander Terekhov  <TEREKHOV@de.ibm.com>
+
+
+SNAPSHOT 2002-11-04
+-------------------
+
+Bug fixes
+---------
+
+* sem_getvalue() now returns the correct value under Win NT and WinCE.
+- Rob Fanner  <rfanner@stonethree.com>
+
+* sem_timedwait() now uses tighter checks for unreasonable
+abstime values - that would result in unexpected timeout values.
+
+* __ptw32_cond_wait_cleanup() no longer mysteriously consumes
+CV signals but may produce more spurious wakeups. It is believed
+that the sem_timedwait() call is consuming a CV signal that it
+shouldn't.
+- Alexander Terekhov  <TEREKHOV@de.ibm.com>
+
+* Fixed a memory leak in __ptw32_threadDestroy() for implicit threads.
+
+* Fixed potential for deadlock in pthread_cond_destroy().
+A deadlock could occur for statically declared CVs (PTHREAD_COND_INITIALIZER),
+when one thread is attempting to destroy the condition variable while another
+is attempting to dynamically initialize it.
+- Michael Johnson  <michaelj@maine.rr.com>
+
+
+SNAPSHOT 2002-03-02
+-------------------
+
+Cleanup code default style. (IMPORTANT)
+----------------------------------------------------------------------
+Previously, if not defined, the cleanup style was determined automatically
+from the compiler/language, and one of the following was defined accordingly:
+
+        __PTW32_CLEANUP_SEH   MSVC only
+        __PTW32_CLEANUP_CXX   C++, including MSVC++, GNU G++
+        __PTW32_CLEANUP_C             C, including GNU GCC, not MSVC
+
+These defines determine the style of cleanup (see pthread.h) and,
+most importantly, the way that cancellation and thread exit (via
+pthread_exit) is performed (see the routine __ptw32_throw() in private.c).
+
+In short, the exceptions versions of the library throw an exception
+when a thread is canceled or exits (via pthread_exit()), which is
+caught by a handler in the thread startup routine, so that the
+the correct stack unwinding occurs regardless of where the thread
+is when it's canceled or exits via pthread_exit().
+
+In this and future snapshots, unless the build explicitly defines (e.g.
+via a compiler option) __PTW32_CLEANUP_SEH, __PTW32_CLEANUP_CXX, or __PTW32_CLEANUP_C, then
+the build NOW always defaults to __PTW32_CLEANUP_C style cleanup. This style
+uses setjmp/longjmp in the cancellation and pthread_exit implementations,
+and therefore won't do stack unwinding even when linked to applications
+that have it (e.g. C++ apps). This is for consistency with most
+current commercial Unix POSIX threads implementations. Compaq's TRU64
+may be an exception (no pun intended) and possible future trend.
+
+Although it was not clearly documented before, it is still necessary to
+build your application using the same __PTW32_CLEANUP_* define as was
+used for the version of the library that you link with, so that the
+correct parts of pthread.h are included. That is, the possible
+defines require the following library versions:
+
+        __PTW32_CLEANUP_SEH   pthreadVSE.dll
+        __PTW32_CLEANUP_CXX   pthreadVCE.dll or pthreadGCE.dll
+        __PTW32_CLEANUP_C     pthreadVC.dll or pthreadGC.dll
+
+E.g. regardless of whether your app is C or C++, if you link with
+pthreadVC.lib or libpthreadGC.a, then you must define __PTW32_CLEANUP_C.
+
+
+THE POINT OF ALL THIS IS: if you have not been defining one of these
+explicitly, then the defaults as described at the top of this
+section were being used.
+
+THIS NOW CHANGES, as has been explained above, but to try to make this
+clearer here's an example:
+
+If you were building your application with MSVC++ i.e. using C++
+exceptions and not explicitly defining one of __PTW32_CLEANUP_*, then
+__PTW32_CLEANUP_C++ was automatically defined for you in pthread.h.
+You should have been linking with pthreadVCE.dll, which does
+stack unwinding.
+
+If you now build your application as you had before, pthread.h will now
+automatically set __PTW32_CLEANUP_C as the default style, and you will need to
+link with pthreadVC.dll. Stack unwinding will now NOT occur when a thread
+is canceled, or the thread calls pthread_exit().
+
+Your application will now most likely behave differently to previous
+versions, and in non-obvious ways. Most likely is that locally
+instantiated objects may not be destroyed or cleaned up after a thread
+is canceled.
+
+If you want the same behaviour as before, then you must now define
+__PTW32_CLEANUP_C++ explicitly using a compiler option and link with
+pthreadVCE.dll as you did before.
+
+
+WHY ARE WE MAKING THE DEFAULT STYLE LESS EXCEPTION-FRIENDLY?
+Because no commercial Unix POSIX threads implementation allows you to
+choose to have stack unwinding. Therefore, providing it in pthread-win32
+as a default is dangerous. We still provide the choice but unless
+you consciously choose to do otherwise, your pthreads applications will
+now run or crash in similar ways irrespective of the threads platform
+you use. Or at least this is the hope.
+
+
+WHY NOT REMOVE THE EXCEPTIONS VERSIONS OF THE LIBRARY ALTOGETHER?
+There are a few reasons:
+- because there are well respected POSIX threads people who believe
+  that POSIX threads implementations should be exceptions aware and
+  do the expected thing in that context. (There are equally respected
+  people who believe it should not be easily accessible, if it's there
+  at all, for unconditional conformity to other implementations.)
+- because Pthreads4w is one of the few implementations that has
+  the choice, perhaps the only freely available one, and so offers
+  a laboratory to people who may want to explore the effects;
+- although the code will always be around somewhere for anyone who
+  wants it, once it's removed from the current version it will not be
+  nearly as visible to people who may have a use for it.
+
+
+Source module splitting
+-----------------------
+In order to enable smaller image sizes to be generated
+for applications that link statically with the library,
+most routines have been separated out into individual
+source code files.
+
+This is being done in such a way as to be backward compatible.
+The old source files are reused to congregate the individual
+routine files into larger translation units (via a bunch of
+# includes) so that the compiler can still optimise wherever
+possible, e.g. through inlining, which can only be done
+within the same translation unit.
+
+It is also possible to build the entire library by compiling
+the single file named "pthread.c", which just #includes all
+the secondary congregation source files. The compiler
+may be able to use this to do more inlining of routines.
+
+Although the GNU compiler is able to produce libraries with
+the necessary separation (the -ffunction-segments switch),
+AFAIK, the MSVC and other compilers don't have this feature.
+
+Finally, since I use makefiles and command-line compilation,
+I don't know what havoc this reorganisation may wreak amongst
+IDE project file users. You should be able to continue
+using your existing project files without modification.
+
+
+New non-portable functions
+--------------------------
+pthread_num_processors_np():
+  Returns the number of processors in the system that are
+  available to the process, as determined from the processor
+  affinity mask.
+
+pthread_timechange_handler_np():
+  To improve tolerance against operator or time service initiated
+  system clock changes.
+
+  This routine can be called by an application when it
+  receives a WM_TIMECHANGE message from the system. At present
+  it broadcasts all condition variables so that waiting threads
+  can wake up and re-evaluate their conditions and restart
+  their timed waits if required.
+  - Suggested by Alexander Terekhov
+
+
+Platform dependence
+-------------------
+As Win95 doesn't provide one, the library now contains
+it's own InterlockedCompareExchange() routine, which is used
+whenever Windows doesn't provide it. InterlockedCompareExchange()
+is used to implement spinlocks and barriers, and also in mutexes.
+This routine relies on the CMPXCHG machine instruction which
+is not available on i386 CPUs. This library (from snapshot
+20010712 onwards) is therefore no longer supported on i386
+processor platforms.
+
+
+New standard routines
+---------------------
+For source code portability only - rwlocks cannot be process shared yet.
+
+        pthread_rwlockattr_init()
+        pthread_rwlockattr_destroy()
+        pthread_rwlockattr_setpshared()
+        pthread_rwlockattr_getpshared()
+
+As defined in the new POSIX standard, and the Single Unix Spec version 3:
+
+        sem_timedwait()
+        pthread_mutex_timedlock()    - Alexander Terekhov and Thomas Pfaff
+        pthread_rwlock_timedrdlock() - adapted from pthread_rwlock_rdlock()
+        pthread_rwlock_timedwrlock() - adapted from pthread_rwlock_wrlock()
+
+
+pthread.h no longer includes windows.h
+--------------------------------------
+[Not yet for G++]
+
+This was done to prevent conflicts.
+
+HANDLE, DWORD, and NULL are temporarily defined within pthread.h if
+they are not already.
+
+
+pthread.h, sched.h and semaphore.h now use dllexport/dllimport
+--------------------------------------------------------------
+Not only to avoid the need for the pthread.def file, but to
+improve performance. Apparently, declaring functions with dllimport
+generates a direct call to the function and avoids the overhead
+of a stub function call.
+
+Bug fixes
+---------
+* Fixed potential NULL pointer dereferences in pthread_mutexattr_init,
+pthread_mutexattr_getpshared, pthread_barrierattr_init,
+pthread_barrierattr_getpshared, and pthread_condattr_getpshared.
+- Scott McCaskill <scott@magruder.org>
+
+* Removed potential race condition in pthread_mutex_trylock and
+pthread_mutex_lock;
+- Alexander Terekhov <TEREKHOV@de.ibm.com>
+
+* The behaviour of pthread_mutex_trylock in relation to
+recursive mutexes was inconsistent with commercial implementations.
+Trylock would return EBUSY if the lock was owned already by the
+calling thread regardless of mutex type. Trylock now increments the
+recursion count and returns 0 for RECURSIVE mutexes, and will
+return EDEADLK rather than EBUSY for ERRORCHECK mutexes. This is
+consistent with Solaris.
+- Thomas Pfaff <tpfaff@gmx.net>
+
+* Found a fix for the library and workaround for applications for
+the known bug #2, i.e. where __PTW32_CLEANUP_CXX or __PTW32_CLEANUP_SEH is defined.
+See the "Known Bugs in this snapshot" section below.
+
+This could be made transparent to applications by replacing the macros that
+define the current C++ and SEH versions of pthread_cleanup_push/pop
+with the C version, but AFAIK cleanup handlers would not then run in the
+correct sequence with destructors and exception cleanup handlers when
+an exception occurs.
+
+* cancellation once started in a thread cannot now be inadvertantly
+double canceled. That is, once a thread begins it's cancellation run,
+cancellation is disabled and a subsequent cancel request will
+return an error (ESRCH).
+
+* errno: An incorrect compiler directive caused a local version
+of errno to be used instead of the Win32 errno. Both instances are
+thread-safe but applications checking errno after a Pthreads4w
+call would be wrong. Fixing this also fixed a bad compiler
+option in the testsuite (/MT should have been /MD) which is
+needed to link with the correct library MSVCRT.LIB.
+
+
+SNAPSHOT 2001-07-12
+-------------------
+
+To be added
+
+
+SNAPSHOT 2001-07-03
+-------------------
+
+To be added
+
+
+SNAPSHOT 2000-08-13
+-------------------
+
+New:
+-       Renamed DLL and LIB files:
+                pthreadVSE.dll  (MS VC++/Structured EH)
+                pthreadVSE.lib
+                pthreadVCE.dll  (MS VC++/C++ EH)
+                pthreadVCE.lib
+                pthreadGCE.dll  (GNU G++/C++ EH)
+                libpthreadw32.a
+
+        Both your application and the pthread dll should use the
+        same exception handling scheme.
+
+Bugs fixed:
+-       MSVC++ C++ exception handling.
+
+Some new tests have been added.
+
+
+SNAPSHOT 2000-08-10
+-------------------
+
+New:
+-       asynchronous cancellation on X86 (Jason Nye)
+-       Makefile compatible with MS nmake to replace
+        buildlib.bat
+-       GNUmakefile for Mingw32
+-       tests/Makefile for MS nmake replaces runall.bat
+-       tests/GNUmakefile for Mingw32
+
+Bugs fixed:
+-       kernel32 load/free problem
+-       attempt to hide internel exceptions from application
+        exception handlers (__try/__except and try/catch blocks)
+-       Win32 thread handle leakage bug
+        (David Baggett/Paul Redondo/Eyal Lebedinsky)
+
+Some new tests have been added.
+
+
+SNAPSHOT 1999-11-02
+-------------------
+
+Bugs fixed:
+-       ctime_r macro had an incorrect argument (Erik Hensema),
+-       threads were not being created 
+        PTHREAD_CANCEL_DEFERRED. This should have
+        had little effect as deferred is the only
+        supported type. (Ross Johnson).
+
+Some compatibility improvements added, eg.
+-       pthread_setcancelstate accepts NULL pointer
+        for the previous value argument. Ditto for
+        pthread_setcanceltype. This is compatible
+        with Solaris but should not affect
+        standard applications (Erik Hensema)
+
+Some new tests have been added.
+
+
+SNAPSHOT 1999-10-17
+-------------------
+
+Bug fix - cancellation of threads waiting on condition variables
+now works properly (Lorin Hochstein and Peter Slacik)
+
+
+SNAPSHOT 1999-08-12
+-------------------
+
+Fixed exception stack cleanup if calling pthread_exit()
+- (Lorin Hochstein and John Bossom).
+
+Fixed bugs in condition variables - (Peter Slacik):
+        - additional contention checks
+        - properly adjust number of waiting threads after timed
+          condvar timeout.
+
+
+SNAPSHOT 1999-05-30
+-------------------
+
+Some minor bugs have been fixed. See the ChangeLog file for details.
+
+Some more POSIX 1b functions are now included but ony return an
+error (ENOSYS) if called. They are:
+
+        sem_open
+        sem_close
+        sem_unlink
+        sem_getvalue
+
+
+SNAPSHOT 1999-04-07
+-------------------
+
+Some POSIX 1b functions which were internally supported are now
+available as exported functions:
+
+        sem_init
+        sem_destroy
+        sem_wait
+        sem_trywait
+        sem_post
+        sched_yield
+        sched_get_priority_min
+        sched_get_priority_max
+
+Some minor bugs have been fixed. See the ChangeLog file for details.
+
+
+SNAPSHOT 1999-03-16
+-------------------
+
+Initial release.
+
diff --git a/src/include/pthread/NOTICE b/src/include/pthread/NOTICE
new file mode 100644
index 0000000..d73542d
--- /dev/null
+++ b/src/include/pthread/NOTICE
@@ -0,0 +1,29 @@
+PThreads4W - POSIX threads for Windows
+Copyright 1998 John E. Bossom
+Copyright 1999-2018, Pthreads4w contributors
+
+This product includes software developed through the colaborative
+effort of several individuals, each of whom is listed in the file
+CONTRIBUTORS included with this software.
+
+The following files are not covered under the Copyrights
+listed above:
+
+    [1] tests/rwlock7.c
+    [1] tests/rwlock7_1.c
+    [1] tests/rwlock8.c
+    [1] tests/rwlock8_1.c
+    [2] tests/threestage.c
+
+[1] The file tests/rwlock7.c and those similarly named are derived from
+code written by Dave Butenhof for his book 'Programming With POSIX(R)
+Threads'. The original code was obtained by free download from his
+website http://home.earthlink.net/~anneart/family/Threads/source.html
+
+[2] The file tests/threestage.c is taken directly from examples in the
+book "Windows System Programming, Edition 4" by Johnson (John) Hart
+Session 6, Chapter 10. ThreeStage.c
+Several required additional header and source files from the
+book examples have been included inline to simplify compilation.
+The only modification to the code has been to provide default
+values when run without arguments.
diff --git a/src/include/pthread/PROGRESS b/src/include/pthread/PROGRESS
new file mode 100644
index 0000000..6a1b4e5
--- /dev/null
+++ b/src/include/pthread/PROGRESS
@@ -0,0 +1,4 @@
+Please see the ANNOUNCE file "Level of Standards Conformance"
+or the web page:
+
+https://sourceforge.net/projects/pthreads4w/conformance.html
diff --git a/src/include/pthread/README b/src/include/pthread/README
new file mode 100644
index 0000000..d7c8181
--- /dev/null
+++ b/src/include/pthread/README
@@ -0,0 +1,571 @@
+PTHREADS4W (a.k.a. PTHREADS-WIN32)
+==================================
+
+What is it?
+-----------
+
+Pthreads4w is an Open Source Software implementation of the Threads
+component of the POSIX 1003.1c 1995 Standard (or later) for Microsoft's
+Windows environment. Some functions from POSIX 1003.1b are also supported,
+including semaphores. Other related functions include the set of read-write
+lock functions. The library also supports some of the functionality of the
+Open Group's Single Unix specification, namely mutex types, plus some common
+and pthreads4w specific non-portable routines (see README.NONPORTABLE).
+
+See the file "ANNOUNCE" for more information including standards
+conformance details and the list of supported and unsupported
+routines.
+
+
+Prerequisites
+-------------
+MSVC or GNU C (MinGW or MinGW64 with AutoConf Tools)
+	To build from source.
+
+QueueUserAPCEx by Panagiotis E. Hadjidoukas
+	To support any thread cancellation in C++ library builds or
+	to support cancellation of blocked threads in any build.
+	This library is not required otherwise.
+
+	For true async cancellation of threads (including blocked threads).
+	This is a DLL and Windows driver that provides pre-emptive APC
+	by forcing threads into an alertable state when the APC is queued.
+	Both the DLL and driver are provided with the pthreads4w.exe
+	self-unpacking ZIP, and on the pthreads4w FTP site  (in source
+	and pre-built forms). Currently this is a separate LGPL package to
+	pthreads4w. See the README in the QueueUserAPCEx folder for
+	installation instructions.
+
+	pthreads4w will automatically detect if the QueueUserAPCEx DLL
+	QuserEx.DLL is available and whether the driver AlertDrv.sys is
+	loaded. If it is not available, pthreads4w will simulate async
+	cancellation, which means that it can async cancel only threads that
+	are runnable. The simulated async cancellation cannot cancel blocked
+	threads.
+
+    [FOR SECURITY] To be found Quserex.dll MUST be installed in the
+	Windows System Folder. This is not an unreasonable constraint given a
+	driver must also be installed and loaded at system startup.
+
+
+Library naming
+--------------
+
+Because the library is being built using various exception
+handling schemes and compilers - and because the library
+may not work reliably if these are mixed in an application,
+each different version of the library has it's own name.
+
+Please do not distribute your own modified versions of the library
+using names conforming to this description. You can use the
+makefile variable "EXTRAVERSION" to append your own suffix to the
+library names when building and testing your library.
+
+Note 1: the incompatibility is really between EH implementations
+of the different compilers. It should be possible to use the
+standard C version from either compiler with C++ applications
+built with a different compiler. If you use an EH version of
+the library, then you must use the same compiler for the
+application. This is another complication and dependency that
+can be avoided by using only the standard C library version.
+
+Note 2: if you use a standard C pthread*.dll with a C++
+application, then any functions that you define that are
+intended to be called via pthread_cleanup_push() must be
+__cdecl.
+
+Note 3: the intention was to also name either the VC or GC
+version (it should be arbitrary) as pthread.dll, including
+pthread.lib and libpthread.a as appropriate. This is no longer
+likely to happen.
+
+Note 4: the compatibility number (major version number) was
+added so that applications can differentiate between binary
+incompatible versions of the libs and dlls.
+
+In general the naming format used is:
+    pthread[VG]{SE,CE,C}[c][E].dll
+    pthread[VG]{SE,CE,C}[c][E].lib
+
+where:
+    [VG] indicates the compiler
+        V	- MS VC, or
+        G	- GNU C
+
+    {SE,CE,C} indicates the exception handling scheme
+        SE	- Structured EH, or
+        CE	- C++ EH, or
+        C	- no exceptions - uses setjmp/longjmp
+
+        c	- DLL major version number indicating ABI
+              compatibility with applications built against
+              a snapshot with the same major version number.
+              See 'Version numbering' below.
+        E	- EXTRAVERSION suffix.
+
+The name may also be suffixed by a 'd' to indicate a debugging version
+of the library. E.g. pthreadVC2d.lib. These will be created e.g. when
+the *-debug makefile targets are used.
+
+Examples:
+	pthreadVC2.dll	    (MSVC/not dependent on exceptions - not binary
+                         compatible with pthreadVC1.dll or pthreadVC.dll)
+    pthreadGC2-w32.dll  (As built, e.g., by "make GC ARCH=-m32 EXTRAVERSION=-w32")
+    pthreadVC2-w64.dll  (As built, e.g., by "nmake VC ARCH=-m64 EXTRAVERSION=-w64")
+
+For information on ARCH (MinGW GNUmakefile) or TARGET_CPU (MSVS Makefile)
+see the respective "Building with ..." sections below.
+
+The GNU library archive file names have correspondingly changed, e.g.:
+
+	libpthreadGCE2.a
+	libpthreadGC2.a
+	libpthreadGC2-w64.a
+
+
+Version numbering
+-----------------
+
+See pthread.h and the resource file 'version.rc'.
+
+Microsoft version numbers use 4 integers:
+
+	0.0.0.0
+
+Pthreads4w uses the first 3 following the standard major.minor.micro
+system. We had claimed to follow the Libtool convention but this has
+not been the case with recent releases. Binary compatibility and
+consequently library file naming has not changed over this time either
+so it should not cause any problems.
+
+NOTE: Changes to the platform ABI can cause the library ABI to change
+and the current version numbering system does not account for this.
+
+The fourth is commonly used for the build number, but will be reserved
+for future use.
+
+	major.minor.micro.0
+
+The numbers are changed as follows:
+
+1. If the general binary interface (ABI) has changed at all since the
+   last update in a way that requires recompilation and relinking of
+   applications, then increment Major, and set both minor and micro to 0.
+   (`M:m:u' becomes `M+1:0:0')
+2. If the general API has changed at all since the last update or
+   there have been semantic/behaviour changes (bug fixes etc) but does
+   not require recompilation of existing applications, then increment
+   minor and set micro to 0.
+   (`M:m:u' becomes `M:m+1:0')
+3. If there have been no interface or semantic changes since the last
+   public release but a new release is deemed necessary for some reason,
+   then increment micro.
+   (`M:m:u' becomes `M:m:u+1')
+
+
+DLL compatibility numbering is an attempt to ensure that applications
+always load a compatible pthreads4w DLL by using a DLL naming system
+that is consistent with the version numbering system. It also allows
+older and newer DLLs to coexist in the same filesystem so that older
+applications can continue to be used. For pre .NET Windows systems,
+this inevitably requires incompatible versions of the same DLLs to have
+different names.
+
+Pthreads4w has adopted the Cygwin convention of appending a single
+integer number to the DLL name. The number used is simply the library's
+major version number.
+
+Consequently, DLL name/s will only change when the DLL's
+backwards compatibility changes. Note that the addition of new
+'interfaces' will not of itself change the DLL's compatibility for older
+applications.
+
+
+Which of the several dll versions to use?
+-----------------------------------------
+or,
+---
+What are all these pthread*.dll and pthread*.lib files?
+-------------------------------------------------------
+
+Simple, use either pthreadGCc.* if you use GCC, or pthreadVCc.* if you
+use MSVC - where 'c' is the DLL versioning (compatibility) number.
+
+Otherwise, you need to choose carefully and know WHY.
+
+The most important choice you need to make is whether to use a
+version that uses exceptions internally, or not. There are versions
+of the library that use exceptions as part of the thread
+cancellation and exit implementation. The default version uses
+setjmp/longjmp.
+
+If you use either pthreadVCE[2] or pthreadGCE[2]:
+
+1. [See also the discussion in the FAQ file - Q2, Q4, and Q5]
+
+If your application contains catch(...) blocks in your POSIX
+threads then you will need to replace the "catch(...)" with the macro
+"__PtW32Catch", eg.
+
+	#ifdef __PtW32Catch
+		__PtW32Catch {
+			...
+		}
+	#else
+		catch(...) {
+			...
+		}
+	#endif
+
+Otherwise neither pthreads cancellation nor pthread_exit() will work
+reliably when using versions of the library that use C++ exceptions
+for cancellation and thread exit.
+
+NB: [lib]pthreadGCE[2] does not support asynchronous cancellation. Any
+attempt to cancel a thread set for asynchronous cancellation using
+this version of the library will cause the applicaton to terminate.
+We believe this is due to the "unmanaged" context switch that is
+disrupting the stack unwinding mechanism and which is used
+to cancel blocked threads. See pthread_cancel.c
+
+
+Other name changes
+------------------
+
+All snapshots prior to and including snapshot 2000-08-13
+used "_pthread_" as the prefix to library internal
+functions, and "_PTHREAD_" to many library internal
+macros. These have now been changed to "__ptw32_" and "__PTW32_"
+respectively so as to not conflict with the ANSI standard's
+reservation of identifiers beginning with "_" and "__" for
+use by compiler implementations only.
+
+If you have written any applications and you are linking
+statically with the pthreads4w library then you may have
+included a call to _pthread_processInitialize. You will
+now have to change that to __ptw32_processInitialize.
+
+
+Cleanup code default style
+--------------------------
+
+Previously, if not defined, the cleanup style was determined automatically
+from the compiler used, and one of the following was defined accordingly:
+
+	__PTW32_CLEANUP_SEH	MSVC only
+	__PTW32_CLEANUP_CXX	C++, including MSVC++, GNU G++
+	__PTW32_CLEANUP_C	C, including GNU GCC, not MSVC
+
+These defines determine the style of cleanup (see pthread.h) and,
+most importantly, the way that cancellation and thread exit (via
+pthread_exit) is performed (see the routine __ptw32_throw()).
+
+In short, the exceptions versions of the library throw an exception
+when a thread is canceled, or exits via pthread_exit(). This exception is
+caught by a handler in the thread startup routine, so that the
+the correct stack unwinding occurs regardless of where the thread
+is when it's canceled or exits via pthread_exit().
+
+In this snapshot, unless the build explicitly defines (e.g. via a
+compiler option) __PTW32_CLEANUP_SEH, __PTW32_CLEANUP_CXX, or __PTW32_CLEANUP_C, then
+the build NOW always defaults to __PTW32_CLEANUP_C style cleanup. This style
+uses setjmp/longjmp in the cancellation and pthread_exit implementations,
+and therefore won't do stack unwinding even when linked to applications
+that have it (e.g. C++ apps). This is for consistency with most/all
+commercial Unix POSIX threads implementations.
+
+Although it was not clearly documented before, it is still necessary to
+build your application using the same __PTW32_CLEANUP_* define as was
+used for the version of the library that you link with, so that the
+correct parts of pthread.h are included. That is, the possible
+defines require the following library versions:
+
+	__PTW32_CLEANUP_SEH	pthreadVSE.dll
+	__PTW32_CLEANUP_CXX	pthreadVCE.dll or pthreadGCE.dll
+	__PTW32_CLEANUP_C	pthreadVC.dll or pthreadGC.dll
+
+It is recommended that you let pthread.h use it's default __PTW32_CLEANUP_C
+for both library and application builds. That is, don't define any of
+the above, and then link with pthreadVC.lib (MSVC or MSVC++) and
+libpthreadGC.a (MinGW GCC or G++). The reason is explained below, but
+another reason is that the prebuilt pthreadVCE.dll is currently broken.
+Versions built with MSVC++ later than version 6 may not be broken, but I
+can't verify this yet.
+
+WHY ARE WE MAKING THE DEFAULT STYLE LESS EXCEPTION-FRIENDLY?
+Because no commercial Unix POSIX threads implementation allows you to
+choose to have stack unwinding. Therefore, providing it in pthread-win32
+as a default is dangerous. We still provide the choice but unless
+you consciously choose to do otherwise, your pthreads applications will
+now run or crash in similar ways irrespective of the pthreads platform
+you use. Or at least this is the hope.
+
+
+Development Build Toolchains and Configurations
+-----------------------------------------------
+
+As of Release 2.10 all build configurations pass the full test suite
+for the following toolchains and configurations:
+
+All DLL and static library build targets enabled in the makefiles:
+VC, VCE, VSE (DLL, inlined statics only)
+GC, GCE (DLL, inlined and small statics)
+
+MSVS:
+Intel Core i7 (6 Core HT)
+Windows 7 64 bit
+MSVS 2010 Express with SDK 7.1 (using the SDK command shell TARGET_CPU = x64 or x86)
+MSVS 2013 Express Cross Tools for x64 Command Prompt
+MSVS 2013 Express Native Tools for x32 Command Prompt
+
+GNU:
+Intel Core i7 (6 Core HT)
+Windows 7 64 bit
+MinGW64 multilib enabled (ARCH = -m64 or -m32)
+MinGW64 multilib disabled
+
+
+Building with MS Visual Studio (C, VC++ using C++ EH, or Structured EH)
+-----------------------------------------------------------------------
+
+NOTE: A VS project/solution/whatever file is included as a contributed
+work and is not used of maintained in development. All building and
+testing is done using makefiles. We use the native make system for each
+toolchain, which is 'nmake' in this case.
+
+From the source directory run nmake without any arguments to list
+help information. E.g.
+
+$ nmake
+
+As examples, as at Release 2.10 the pre-built DLLs and static libraries
+can be built using one of the following command-lines:
+
+[Note: "setenv" comes with the SDK which is not required to build the library.
+I use it to build and test both 64 and 32 bit versions of the library.
+"/2003" is used to override my build system which is Win7 (at the time of
+writing) for backwards compatibility.]
+
+$ setenv /x64 /2003 /Release
+$ nmake realclean VC
+$ nmake realclean VCE
+$ nmake realclean VSE
+$ nmake realclean VC-static
+$ nmake realclean VCE-static
+$ nmake realclean VSE-static
+$ setenv /x86 /2003 /Release
+$ nmake realclean VC
+$ nmake realclean VCE
+$ nmake realclean VSE
+$ nmake realclean VC-static
+$ nmake realclean VCE-static
+$ nmake realclean VSE-static
+
+If you want to differentiate or customise library naming you can use,
+e.g.:
+
+$ nmake realclean VC EXTRAVERSION="-w64"
+
+The string provided via the variable EXTRAVERSION is appended to the dll
+and .lib library names, e.g.:
+
+pthreadVC2-w64.dll
+pthreadVC2-w64.lib
+
+To build and test all DLLs and static lib compatibility versions
+(VC, VCE, VSE):
+
+$ setenv /x64 /2003 /release
+$ nmake all-tests
+
+You can run the testsuite by changing to the "tests" directory and
+running nmake. E.g.:
+
+$ cd tests
+$ nmake VC
+
+Note: the EXTRAVERSION="..." option is passed to the tests Makefile
+when you target "all-tests". If you build the library then change to the
+tests directory to run the tests you will need to repeat the option
+explicitly to the test "nmake" command-line.
+
+For failure analysis etc. individual tests can be built
+and run, e.g:
+
+$ cd tests
+$ nmake VC TESTS="foo bar"
+
+This builds and runs all prerequisite tests as well as the individual
+tests listed. Prerequisite tests are defined in tests\runorder.mk.
+
+To build and run only the tests listed use:
+
+$ cd tests
+$ nmake VC NO_DEPS=1 TESTS="foo bar"
+
+
+Building with MinGW
+-------------------
+
+NOTE: All building and testing is done using makefiles. We use the native
+make system for each toolchain, which is 'make' in this case.
+
+We have found that Mingw builds of the GCE library variants can fail when
+run on 64 bit systems, believed to be due to the DWARF2 exception handling
+being a 32 bit mechanism. The GC variants are fine. MinGW64 offers
+SJLJ or SEH exception handling so choose one of those.
+
+From the source directory:
+
+run 'autoheader' to rewrite the config.h file
+run 'autoconf' to rewrite the GNUmakefiles (library and tests)
+run './configure' to create config.h and GNUmakefile.
+run 'make' without arguments to list possible targets.
+
+E.g.
+
+$ autoheader
+$ autoconf
+$ ./configure
+$ make realclean all-tests
+
+With MinGW64 multilib installed the following variables can be defined
+either on the make command line or in the shell environment:
+
+ARCH
+ - possible values are "-m64" and "-m32". You will probably recognise
+   these as gcc flags however the GNUmakefile also converts these into
+   the appropriate windres options when building version.o.
+
+As examples, as at Release 2.10 the pre-built DLLs and static libraries
+are built from the following command-lines:
+
+$ nmake realclean GC ARCH=-m64
+$ nmake realclean GC ARCH=-m32
+$ nmake realclean GCE ARCH=-m64
+$ nmake realclean GCE ARCH=-m32
+$ nmake realclean GC-static ARCH=-m64
+$ nmake realclean GC-static ARCH=-m32
+$ nmake realclean GCE-static ARCH=-m64
+$ nmake realclean GCE-static ARCH=-m32
+
+If you want to differentiate between libraries by their names you can use,
+e.g.:
+
+$ make realclean GC ARCH="-m64" EXTRAVERSION="-w64"
+
+The string provided via the variable EXTRAVERSION is appended to the dll
+and .a library names, e.g.:
+
+pthreadGC2-w64.dll
+libpthreadGC2-w64.a
+
+To build and test all DLLs and static lib compatibility variants (GC, GCE):
+
+$ make all-tests
+or, with MinGW64 (multilib enabled):
+$ make all-tests ARCH=-m64
+$ make all-tests ARCH=-m32
+
+You can run the testsuite by changing to the "tests" directory and
+running make. E.g.:
+
+$ cd tests
+$ make GC
+
+Note that the ARCH="..." and/or EXTRAVERSION="..." options are passed to the
+tests GNUmakefile when you target "all-tests". If you change to the tests
+directory and run the tests you will need to repeat those options explicitly
+to the test "make" command-line.
+
+For failure analysis etc. individual tests can be built and run, e.g:
+
+$ cd tests
+$ make GC TESTS="foo bar"
+
+This builds and runs all prerequisite tests as well as the individual
+tests listed. Prerequisite tests are defined in tests\runorder.mk.
+
+To build and run only those tests listed use:
+
+$ cd tests
+$ make GC NO_DEPS=1 TESTS="foo bar"
+
+
+Building under Linux using the MinGW cross development tools
+------------------------------------------------------------
+
+You can build the library on Linux by using the MinGW cross development
+toolchain. See http://www.libsdl.org/extras/win32/cross/ for tools and
+info. The GNUmakefile contains some support for this, for example:
+
+make CROSS=i386-mingw32msvc- clean GC
+
+will build pthreadGCn.dll and libpthreadGCn.a (n=version#), provided your
+cross-tools/bin directory is in your PATH (or use the cross-make.sh script
+at the URL above).
+
+
+Building the library as a statically linkable library
+-----------------------------------------------------
+
+General:  __PTW32_STATIC_LIB must be defined for both the library build and the
+application build. The makefiles supplied and used by the following 'make'
+command lines will define this for you.
+
+MSVC (creates pthreadVCn.lib as a static link lib):
+
+nmake clean VC-static
+
+
+MinGW32 (creates libpthreadGCn.a as a static link lib):
+
+make clean GC-static
+
+Define  __PTW32_STATIC_LIB also when building your application.
+
+Building the library under Cygwin
+---------------------------------
+
+Cygwin implements it's own POSIX threads routines and these
+will be the ones to use if you develop using Cygwin.
+
+Building applications
+---------------------
+
+The files you will need for your application build are:
+
+The four header files:
+	_ptw32.h
+	pthread.h
+	semaphore.h
+	sched.h
+
+The DLL library files that you built:
+	pthread*.dll
+	plus the matching *.lib (MSVS) or *.a file (GNU)
+
+or, the static link library that you built:
+	pthread*.lib (MSVS) or libpthread*.a (GNU)
+
+Place them in the appropriate directories for your build, which may be the
+standard compiler locations or, locations specific to your project (you
+might have a separate third-party dependency tree for example).
+
+Acknowledgements
+----------------
+
+See the ANNOUNCE file for acknowledgements.
+See the 'CONTRIBUTORS' file for the list of contributors.
+
+As much as possible, the ChangeLog file attributes
+contributions and patches that have been incorporated
+in the library to the individuals responsible.
+
+Finally, thanks to all those who work on and contribute to the
+POSIX and Single Unix Specification standards. The maturity of an
+industry can be measured by it's open standards.
+
+----
+Ross Johnson
+<ross.johnson@loungebythelake.net>
diff --git a/src/include/pthread/TODO b/src/include/pthread/TODO
new file mode 100644
index 0000000..6fc172e
--- /dev/null
+++ b/src/include/pthread/TODO
@@ -0,0 +1,9 @@
+                   Things that aren't done yet
+                   ---------------------------
+
+1. Implement PTHREAD_PROCESS_SHARED for semaphores, mutexes,
+   condition variables, read/write locks, barriers.
+   
+   IMO, to do this in a source code compatible way requires implementation of
+   POSIX shared memory functions, etc.
+   
\ No newline at end of file
diff --git a/src/include/pthread/_ptw32.h b/src/include/pthread/_ptw32.h
new file mode 100644
index 0000000..75f0045
--- /dev/null
+++ b/src/include/pthread/_ptw32.h
@@ -0,0 +1,217 @@
+/*
+ * Module: _ptw32.h
+ *
+ * Purpose:
+ *      Pthreads4w internal macros, to be shared by other headers
+ *      comprising the pthreads4w package.
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ */
+
+#ifndef __PTW32_H
+#define __PTW32_H
+
+/* See the README file for an explanation of the pthreads-win32
+ * version numbering scheme and how the DLL is named etc.
+ *
+ * FIXME: consider moving this to <_ptw32.h>; maybe also add a
+ * leading underscore to the macro names.
+ */
+#define  __PTW32_VERSION_MAJOR 3
+#define  __PTW32_VERSION_MINOR 0
+#define  __PTW32_VERSION_MICRO 0
+#define  __PTW32_VERION_BUILD 0
+#define  __PTW32_VERSION 3,0,0,0
+#define  __PTW32_VERSION_STRING "3, 0, 0, 0\0"
+
+#if defined(__GNUC__)
+# pragma GCC system_header
+# if ! defined __declspec
+#  error "Please upgrade your GNU compiler to one that supports __declspec."
+# endif
+#endif
+
+#if defined (__cplusplus)
+# define __PTW32_BEGIN_C_DECLS  extern "C" {
+# define __PTW32_END_C_DECLS    }
+#else
+# define __PTW32_BEGIN_C_DECLS
+# define __PTW32_END_C_DECLS
+#endif
+
+#if defined __PTW32_STATIC_LIB
+# define __PTW32_DLLPORT
+
+#elif defined  __PTW32_BUILD
+# define  __PTW32_DLLPORT __declspec (dllexport)
+#else
+# define  __PTW32_DLLPORT /*__declspec (dllimport)*/
+#endif
+
+#ifndef  __PTW32_CDECL
+/* FIXME: another internal macro; should have two initial underscores;
+ * Nominally, we prefer to use __cdecl calling convention for all our
+ * functions, but we map it through this macro alias to facilitate the
+ * possible choice of alternatives; for example:
+ */
+
+#if defined _OPEN_WATCOM_SOURCE || __WATCOMC__
+  /* The Open Watcom C/C++ compiler uses a non-standard default calling
+   * convention, (similar to __fastcall), which passes function arguments
+   * in registers, unless the __cdecl convention is explicitly specified
+   * in exposed function prototypes.
+   *
+   * Our preference is to specify the __cdecl convention for all calls,
+   * even though this could slow Watcom code down slightly.  If you know
+   * that the Watcom compiler will be used to build both the DLL and your
+   * application, then you may #define _OPEN_WATCOM_SOURCE, so disabling
+   * the forced specification of __cdecl for all function declarations;
+   * remember that this must be defined consistently, for both the DLL
+   * build, and the application build.
+   */
+  #define  __PTW32_CDECL
+#else
+    #define  __PTW32_CDECL __cdecl
+#endif /* WATCOM */
+
+#endif
+
+/*
+ * This is more or less a duplicate of what is in the autoconf config.h,
+ * which is only used when building the pthreads4w libraries.
+ */
+
+#if !defined (__PTW32_CONFIG_H) && !defined(__PTW32_PSEUDO_CONFIG_H_SOURCED)
+#  define __PTW32_PSEUDO_CONFIG_H_SOURCED
+#  if defined(WINCE)
+#    undef  HAVE_CPU_AFFINITY
+#    define NEED_DUPLICATEHANDLE
+#    define NEED_CREATETHREAD
+#    define NEED_ERRNO
+#    define NEED_CALLOC
+#    define NEED_UNICODE_CONSTS
+#    define NEED_PROCESS_AFFINITY_MASK
+/* This may not be needed */
+#    define RETAIN_WSALASTERROR
+#  elif defined(_MSC_VER)
+#    if _MSC_VER >= 1900
+#      define HAVE_STRUCT_TIMESPEC
+#    elif _MSC_VER < 1300
+#      define  __PTW32_CONFIG_MSVC6
+#    elif _MSC_VER < 1400
+#      define  __PTW32_CONFIG_MSVC7
+#    endif
+#  elif defined(_UWIN)
+#    define HAVE_MODE_T
+#    define HAVE_STRUCT_TIMESPEC
+#    define HAVE_SIGNAL_H
+#  endif
+#endif
+
+/*
+ * If HAVE_ERRNO_H is defined then assume that autoconf has been used
+ * to overwrite config.h, otherwise the original config.h is in use
+ * at build-time or the above block of defines is in use otherwise
+ * and NEED_ERRNO is either defined or not defined.
+ */
+#if defined(HAVE_ERRNO_H) || !defined(NEED_ERRNO)
+#  include <errno.h>
+#else
+#  include "need_errno.h"
+#endif
+
+#if defined(__BORLANDC__)
+#  define int64_t LONGLONG
+#  define uint64_t ULONGLONG
+#elif !defined(__MINGW32__)
+     typedef long long int int64_t;
+     typedef unsigned long long int uint64_t;
+#  if defined (__PTW32_CONFIG_MSVC6)
+     typedef long intptr_t;
+#  endif
+#elif defined(HAVE_STDINT_H) && HAVE_STDINT_H == 1
+#  include <stdint.h>
+#endif
+
+/*
+ * In case ETIMEDOUT hasn't been defined above somehow.
+ */
+#if !defined(ETIMEDOUT)
+  /*
+   * note: ETIMEDOUT is no longer defined in winsock.h
+   * WSAETIMEDOUT is so use its value.
+   */
+#  include <winsock.h>
+#  if defined(WSAETIMEDOUT)
+#    define ETIMEDOUT WSAETIMEDOUT
+#  else
+#   define ETIMEDOUT 10060  /* This is the value of WSAETIMEDOUT in winsock.h. */
+#  endif
+#endif
+
+/*
+ * Several systems may not define some error numbers;
+ * defining those which are likely to be missing here will let
+ * us complete the library builds.
+ */
+#if !defined(ENOTSUP)
+#  define ENOTSUP 48   /* This is the value in Solaris. */
+#endif
+
+#if !defined(ENOSYS)
+#  define ENOSYS 140     /* Semi-arbitrary value */
+#endif
+
+#if !defined(EDEADLK)
+#  if defined(EDEADLOCK)
+#    define EDEADLK EDEADLOCK
+#  else
+#    define EDEADLK 36     /* This is the value in MSVC. */
+#  endif
+#endif
+
+/* POSIX 2008 - related to robust mutexes */
+#if  __PTW32_VERSION_MAJOR > 2
+#  if !defined(EOWNERDEAD)
+#    define EOWNERDEAD 1000
+#  endif
+#  if !defined(ENOTRECOVERABLE)
+#    define ENOTRECOVERABLE 1001
+#  endif
+#else
+#  if !defined(EOWNERDEAD)
+#    define EOWNERDEAD 42
+#  endif
+#  if !defined(ENOTRECOVERABLE)
+#    define ENOTRECOVERABLE 43
+#  endif
+#endif
+
+#endif  /* !__PTW32_H */
diff --git a/src/include/pthread/config.h b/src/include/pthread/config.h
new file mode 100644
index 0000000..6da5690
--- /dev/null
+++ b/src/include/pthread/config.h
@@ -0,0 +1,150 @@
+/* config.h  */
+
+#ifndef  __PTW32_CONFIG_H
+#define  __PTW32_CONFIG_H
+
+/*********************************************************************
+ * Defaults: see target specific redefinitions below.
+ *********************************************************************/
+
+/* We're building the pthreads-win32 library */
+#define  __PTW32_BUILD
+
+/* CPU affinity */
+#define HAVE_CPU_AFFINITY
+
+/* Do we know about the C type sigset_t? */
+#undef HAVE_SIGSET_T
+
+/* Define if you have the <signal.h> header file.  */
+#undef HAVE_SIGNAL_H
+
+/* Define if you have the Borland TASM32 or compatible assembler.  */
+#undef HAVE_TASM32
+
+/* Define if you don't have Win32 DuplicateHandle. (eg. WinCE) */
+#undef NEED_DUPLICATEHANDLE
+
+/* Define if you don't have Win32 _beginthreadex. (eg. WinCE) */
+#undef NEED_CREATETHREAD
+
+/* Define if you don't have Win32 errno. (eg. WinCE) */
+#undef NEED_ERRNO
+
+/* Define if you don't have Win32 calloc. (eg. WinCE)  */
+#undef NEED_CALLOC
+
+/* Define if you don't have Win32 semaphores. (eg. WinCE 2.1 or earlier)  */
+#undef NEED_SEM
+
+/* Define if you need to convert string parameters to unicode. (eg. WinCE)  */
+#undef NEED_UNICODE_CONSTS
+
+/* Define if your C (not C++) compiler supports "inline" functions. */
+#undef HAVE_C_INLINE
+
+/* Do we know about type mode_t? */
+#undef HAVE_MODE_T
+
+/*
+ * Define if GCC has atomic builtins, i.e. __sync_* intrinsics
+ * __sync_lock_* is implemented in mingw32 gcc 4.5.2 at least
+ * so this define does not turn those on or off. If you get an
+ * error from __sync_lock* then consider upgrading your gcc.
+ */
+#undef HAVE_GCC_ATOMIC_BUILTINS
+
+/* Define if you have the timespec struct */
+#undef HAVE_STRUCT_TIMESPEC
+
+/* Define if you don't have the GetProcessAffinityMask() */
+#undef NEED_PROCESS_AFFINITY_MASK
+
+/* Define if your version of Windows TLSGetValue() clears WSALastError
+ * and calling SetLastError() isn't enough restore it. You'll also need to
+ * link against wsock32.lib (or libwsock32.a for MinGW).
+ */
+#undef RETAIN_WSALASTERROR
+
+/*
+# ----------------------------------------------------------------------
+# The library can be built with some alternative behaviour to better
+# facilitate development of applications on Win32 that will be ported
+# to other POSIX systems.
+#
+# Nothing described here will make the library non-compliant and strictly
+# compliant applications will not be affected in any way, but
+# applications that make assumptions that POSIX does not guarantee are
+# not strictly compliant and may fail or misbehave with some settings.
+#
+#  __PTW32_THREAD_ID_REUSE_INCREMENT
+# Purpose:
+# POSIX says that applications should assume that thread IDs can be
+# recycled. However, Solaris (and some other systems) use a [very large]
+# sequence number as the thread ID, which provides virtual uniqueness.
+# This provides a very high but finite level of safety for applications
+# that are not meticulous in tracking thread lifecycles e.g. applications
+# that call functions which target detached threads without some form of
+# thread exit synchronisation.
+#
+# Usage:
+# Set to any value in the range: 0 <= value < 2^wordsize.
+# Set to 0 to emulate reusable thread ID behaviour like Linux or *BSD.
+# Set to 1 for unique thread IDs like Solaris (this is the default).
+# Set to some factor of 2^wordsize to emulate smaller word size types
+# (i.e. will wrap sooner). This might be useful to emulate some embedded
+# systems.
+#
+# define  __PTW32_THREAD_ID_REUSE_INCREMENT 0
+#
+# ----------------------------------------------------------------------
+ */
+#undef  __PTW32_THREAD_ID_REUSE_INCREMENT
+
+
+/*********************************************************************
+ * Target specific groups
+ *
+ * If you find that these are incorrect or incomplete please report it
+ * to the pthreads-win32 maintainer. Thanks.
+ *********************************************************************/
+#if defined(WINCE)
+#  undef  HAVE_CPU_AFFINITY
+#  define NEED_DUPLICATEHANDLE
+#  define NEED_CREATETHREAD
+#  define NEED_ERRNO
+#  define NEED_CALLOC
+#  define NEED_FTIME
+/* #  define NEED_SEM */
+#  define NEED_UNICODE_CONSTS
+#  define NEED_PROCESS_AFFINITY_MASK
+/* This may not be needed */
+#  define RETAIN_WSALASTERROR
+#endif
+
+#if defined(_UWIN)
+#  define HAVE_MODE_T
+#  define HAVE_STRUCT_TIMESPEC
+#  define HAVE_SIGNAL_H
+#endif
+
+#if defined(__GNUC__)
+#  define HAVE_C_INLINE
+#endif
+
+#if defined(__BORLANDC__)
+#endif
+
+#if defined(__WATCOMC__)
+#endif
+
+#if defined(__DMC__)
+#define HAVE_SIGNAL_H
+#define HAVE_C_INLINE
+#endif
+
+#if defined(_MSC_VER) && _MSC_VER >= 1900
+#define HAVE_STRUCT_TIMESPEC
+#endif
+
+#endif /*  __PTW32_CONFIG_H */
diff --git a/src/include/pthread/context.h b/src/include/pthread/context.h
new file mode 100644
index 0000000..33294c1
--- /dev/null
+++ b/src/include/pthread/context.h
@@ -0,0 +1,72 @@
+/*
+ * context.h
+ *
+ * Description:
+ * POSIX thread macros related to thread cancellation.
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef  __PTW32_CONTEXT_H
+#define  __PTW32_CONTEXT_H
+
+#undef  __PTW32_PROGCTR
+
+#if defined(_M_IX86) || (defined(_X86_) && !defined(__amd64__))
+#define  __PTW32_PROGCTR(Context)  ((Context).Eip)
+#endif
+
+#if defined (_M_IA64) || defined(_IA64)
+#define  __PTW32_PROGCTR(Context)  ((Context).StIIP)
+#endif
+
+#if defined(_MIPS_) || defined(MIPS)
+#define  __PTW32_PROGCTR(Context)  ((Context).Fir)
+#endif
+
+#if defined(_ALPHA_)
+#define  __PTW32_PROGCTR(Context)  ((Context).Fir)
+#endif
+
+#if defined(_PPC_)
+#define  __PTW32_PROGCTR(Context)  ((Context).Iar)
+#endif
+
+#if defined(_AMD64_) || defined(__amd64__)
+#define  __PTW32_PROGCTR(Context)  ((Context).Rip)
+#endif
+
+#if defined(_ARM_) || defined(ARM) || defined(_M_ARM) || defined(_M_ARM64)
+#define PTW32_PROGCTR(Context)  ((Context).Pc)
+#endif
+
+#if !defined (__PTW32_PROGCTR)
+#error Module contains CPU-specific code; modify and recompile.
+#endif
+
+#endif
diff --git a/src/include/pthread/implement.h b/src/include/pthread/implement.h
new file mode 100644
index 0000000..53f3c46
--- /dev/null
+++ b/src/include/pthread/implement.h
@@ -0,0 +1,980 @@
+/*
+ * implement.h
+ *
+ * Definitions that don't need to be public.
+ *
+ * Keeps all the internals out of pthread.h
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+
+#if !defined(_IMPLEMENT_H)
+#define _IMPLEMENT_H
+
+/*
+#if !defined (__PTW32_CONFIG_H)
+# error "config.h was not #included"
+#endif
+*/
+
+#include"config.h"
+
+#include"_ptw32.h"
+
+#if !defined(_WIN32_WINNT)
+# define _WIN32_WINNT 0x0400
+#endif
+
+#define WIN32_LEAN_AND_MEAN
+
+#include<windows.h>
+#include<sys/types.h>
+/*
+ * In case windows.h doesn't define it (e.g. WinCE perhaps)
+ */
+#if defined(WINCE)
+typedef VOID (APIENTRY *PAPCFUNC)(DWORD dwParam);
+#endif
+
+/*
+ * Designed to allow error values to be set and retrieved in builds where
+ * MSCRT libraries are statically linked to DLLs.
+ *
+ * This does not handle the case where a static pthreads4w lib is linked
+ * to a static linked app. Compiling and linking pthreads.c with app.c
+ * as one does work with the right macros defined. See tests/Makefile
+ * for clues or just "cd tests && nmake clean VC-static".
+ */
+#if ! defined(WINCE) && \
+    (( defined(__MINGW32__) && __MSVCRT_VERSION__ >= 0x0800 ) || \
+    ( defined(_MSC_VER) && _MSC_VER >= 1400 ))  /* MSVC8+ */
+#  if defined(__MINGW32__)
+__attribute__((unused))
+#  endif
+static int __ptw32_get_errno(void) { int err = 0; _get_errno(&err); return err; }
+#  define __PTW32_GET_ERRNO() __ptw32_get_errno()
+#  if defined(__MINGW32__)
+__attribute__((unused))
+#  endif
+static void __ptw32_set_errno(int err) { _set_errno(err); SetLastError(err); }
+#    define __PTW32_SET_ERRNO(err) __ptw32_set_errno(err)
+#else
+#  define __PTW32_GET_ERRNO() (errno)
+#  if defined(__MINGW32__)
+__attribute__((unused))
+#  endif
+static void __ptw32_set_errno(int err) { errno = err; SetLastError(err); }
+#    define __PTW32_SET_ERRNO(err) __ptw32_set_errno(err)
+#endif
+
+#if !defined(malloc)
+# include <malloc.h>
+#endif
+
+#if defined(__PTW32_CLEANUP_C)
+# include <setjmp.h>
+#endif
+
+#if !defined(INT_MAX)
+# include <limits.h>
+#endif
+
+/* use local include files during development */
+#include "semaphore.h"
+#include "sched.h"
+
+/* MSVC 7.1 doesn't like complex #if expressions */
+#define INLINE
+#if defined (__PTW32_BUILD_INLINED)
+#  if defined(HAVE_C_INLINE) || defined(__cplusplus)
+#    undef INLINE
+#    define INLINE inline
+#  endif
+#endif
+
+#if defined (__PTW32_CONFIG_MSVC6)
+# define  __PTW32_INTERLOCKED_VOLATILE
+#else
+# define  __PTW32_INTERLOCKED_VOLATILE volatile
+#endif
+
+#define  __PTW32_INTERLOCKED_LONG long
+#define  __PTW32_INTERLOCKED_PVOID PVOID
+#define  __PTW32_INTERLOCKED_LONGPTR  __PTW32_INTERLOCKED_VOLATILE long*
+#define  __PTW32_INTERLOCKED_PVOID_PTR  __PTW32_INTERLOCKED_VOLATILE PVOID*
+#if defined(_WIN64)
+#  define  __PTW32_INTERLOCKED_SIZE LONGLONG
+#  define  __PTW32_INTERLOCKED_SIZEPTR  __PTW32_INTERLOCKED_VOLATILE LONGLONG*
+#else
+#  define  __PTW32_INTERLOCKED_SIZE long
+#  define  __PTW32_INTERLOCKED_SIZEPTR  __PTW32_INTERLOCKED_VOLATILE long*
+#endif
+
+/*
+ * Don't allow the linker to optimize away dll.obj (dll.o) in static builds.
+ */
+#if defined (__PTW32_STATIC_LIB) && defined (__PTW32_BUILD) && !defined (__PTW32_TEST_SNEAK_PEEK)
+  void __ptw32_autostatic_anchor(void);
+# if defined(__GNUC__)
+    __attribute__((unused, used))
+# endif
+  static void (*local_autostatic_anchor)(void) = __ptw32_autostatic_anchor;
+#endif
+
+typedef enum
+{
+  /*
+   * This enumeration represents the state of the thread;
+   * The thread is still valid if the numeric value of the
+   * state is greater or equal "PThreadStateRunning".
+   */
+  PThreadStateInitial = 0,	/* Thread not running                   */
+  PThreadStateReuse,            /* In reuse pool.                       */
+  PThreadStateRunning,		/* Thread alive & kicking               */
+  PThreadStateSuspended,	/* Thread alive but suspended           */
+  PThreadStateCancelPending,	/* Thread alive but                     */
+                                /* has cancellation pending.            */
+  PThreadStateCanceling,	/* Thread alive but is                  */
+                                /* in the process of terminating        */
+                                /* due to a cancellation request        */
+  PThreadStateExiting,		/* Thread alive but exiting             */
+                                /* due to an exception                  */
+  PThreadStateLast              /* All handlers have been run and now   */
+                                /* final cleanup can be done.           */
+}
+PThreadState;
+
+typedef struct __ptw32_mcs_node_t_     __ptw32_mcs_local_node_t;
+typedef struct __ptw32_mcs_node_t_*    __ptw32_mcs_lock_t;
+typedef struct __ptw32_robust_node_t_  __ptw32_robust_node_t;
+typedef struct __ptw32_thread_t_       __ptw32_thread_t;
+
+struct __ptw32_thread_t_
+{
+  unsigned __int64 seqNumber;	/* Process-unique thread sequence number */
+  HANDLE threadH;		/* Win32 thread handle - POSIX thread is invalid if threadH == 0 */
+  pthread_t ptHandle;		/* This thread's permanent pthread_t handle */
+  __ptw32_thread_t * prevReuse;	/* Links threads on reuse stack */
+  volatile PThreadState state;
+  __ptw32_mcs_lock_t threadLock;	/* Used for serialised access to public thread state */
+  __ptw32_mcs_lock_t stateLock;	/* Used for async-cancel safety */
+  HANDLE cancelEvent;
+  void *exitStatus;
+  void *parms;
+  void *keys;
+  void *nextAssoc;
+#if defined(__PTW32_CLEANUP_C)
+  jmp_buf start_mark;		/* Jump buffer follows void* so should be aligned */
+#endif				/* __PTW32_CLEANUP_C */
+#if defined(HAVE_SIGSET_T)
+  sigset_t sigmask;
+#endif				/* HAVE_SIGSET_T */
+  __ptw32_mcs_lock_t
+              robustMxListLock; /* robustMxList lock */
+  __ptw32_robust_node_t*
+                  robustMxList; /* List of currenty held robust mutexes */
+  int ptErrno;
+  int detachState;
+  int sched_priority;		/* As set, not as currently is */
+  int cancelState;
+  int cancelType;
+  int implicit:1;
+  DWORD thread;			/* Windows thread ID */
+#if defined(HAVE_CPU_AFFINITY)
+  size_t cpuset;		/* Thread CPU affinity set */
+#endif
+  char * name;                  /* Thread name */
+#if defined(_UWIN)
+  DWORD dummy[5];
+#endif
+  size_t align;			/* Force alignment if this struct is packed */
+};
+
+
+/*
+ * Special value to mark attribute objects as valid.
+ */
+#define  __PTW32_ATTR_VALID ((unsigned long) 0xC4C0FFEE)
+
+struct pthread_attr_t_
+{
+  unsigned long valid;
+  void *stackaddr;
+  size_t stacksize;
+  int detachstate;
+  struct sched_param param;
+  int inheritsched;
+  int contentionscope;
+  size_t cpuset;
+  char * thrname;
+#if defined(HAVE_SIGSET_T)
+  sigset_t sigmask;
+#endif				/* HAVE_SIGSET_T */
+};
+
+
+/*
+ * ====================
+ * ====================
+ * Semaphores, Mutexes and Condition Variables
+ * ====================
+ * ====================
+ */
+
+struct sem_t_
+{
+  int value;
+  __ptw32_mcs_lock_t lock;
+  HANDLE sem;
+#if defined(NEED_SEM)
+  int leftToUnblock;
+#endif
+};
+
+#define  __PTW32_OBJECT_AUTO_INIT ((void *)(size_t) -1)
+#define  __PTW32_OBJECT_INVALID   NULL
+
+struct pthread_mutex_t_
+{
+  LONG lock_idx;		/* Provides exclusive access to mutex state
+				   via the Interlocked* mechanism.
+				    0: unlocked/free.
+				    1: locked - no other waiters.
+				   -1: locked - with possible other waiters.
+				*/
+  int recursive_count;		/* Number of unlocks a thread needs to perform
+				   before the lock is released (recursive
+				   mutexes only). */
+  int kind;			/* Mutex type. */
+  pthread_t ownerThread;
+  HANDLE event;			/* Mutex release notification to waiting
+				   threads. */
+  __ptw32_robust_node_t*
+                    robustNode; /* Extra state for robust mutexes  */
+};
+
+enum __ptw32_robust_state_t_
+{
+   __PTW32_ROBUST_CONSISTENT,
+   __PTW32_ROBUST_INCONSISTENT,
+   __PTW32_ROBUST_NOTRECOVERABLE
+};
+
+typedef enum __ptw32_robust_state_t_   __ptw32_robust_state_t;
+
+/*
+ * Node used to manage per-thread lists of currently-held robust mutexes.
+ */
+struct __ptw32_robust_node_t_
+{
+  pthread_mutex_t mx;
+  __ptw32_robust_state_t stateInconsistent;
+  __ptw32_robust_node_t* prev;
+  __ptw32_robust_node_t* next;
+};
+
+struct pthread_mutexattr_t_
+{
+  int pshared;
+  int kind;
+  int robustness;
+};
+
+/*
+ * Possible values, other than  __PTW32_OBJECT_INVALID,
+ * for the "interlock" element in a spinlock.
+ *
+ * In this implementation, when a spinlock is initialised,
+ * the number of cpus available to the process is checked.
+ * If there is only one cpu then "interlock" is set equal to
+ *  __PTW32_SPIN_USE_MUTEX and u.mutex is an initialised mutex.
+ * If the number of cpus is greater than 1 then "interlock"
+ * is set equal to  __PTW32_SPIN_UNLOCKED and the number is
+ * stored in u.cpus. This arrangement allows the spinlock
+ * routines to attempt an InterlockedCompareExchange on "interlock"
+ * immediately and, if that fails, to try the inferior mutex.
+ *
+ * "u.cpus" isn't used for anything yet, but could be used at
+ * some point to optimise spinlock behaviour.
+ */
+#define  __PTW32_SPIN_INVALID     (0)
+#define  __PTW32_SPIN_UNLOCKED    (1)
+#define  __PTW32_SPIN_LOCKED      (2)
+#define  __PTW32_SPIN_USE_MUTEX   (3)
+
+struct pthread_spinlock_t_
+{
+  long interlock;		/* Locking element for multi-cpus. */
+  union
+  {
+    int cpus;			/* No. of cpus if multi cpus, or   */
+    pthread_mutex_t mutex;	/* mutex if single cpu.            */
+  } u;
+};
+
+/*
+ * MCS lock queue node - see ptw32_MCS_lock.c
+ */
+struct __ptw32_mcs_node_t_
+{
+  struct __ptw32_mcs_node_t_ **lock;        /* ptr to tail of queue */
+  struct __ptw32_mcs_node_t_  *next;        /* ptr to successor in queue */
+  HANDLE                     readyFlag;   /* set after lock is released by
+                                             predecessor */
+  HANDLE                     nextFlag;    /* set after 'next' ptr is set by
+                                             successor */
+};
+
+
+struct pthread_barrier_t_
+{
+  unsigned int nCurrentBarrierHeight;
+  unsigned int nInitialBarrierHeight;
+  int pshared;
+  sem_t semBarrierBreeched;
+  __ptw32_mcs_lock_t lock;
+  __ptw32_mcs_local_node_t proxynode;
+};
+
+struct pthread_barrierattr_t_
+{
+  int pshared;
+};
+
+struct pthread_key_t_
+{
+  DWORD key;
+  void  (__PTW32_CDECL *destructor) (void *);
+  __ptw32_mcs_lock_t keyLock;
+  void *threads;
+};
+
+
+typedef struct ThreadParms ThreadParms;
+
+struct ThreadParms
+{
+  pthread_t tid;
+  void * (__PTW32_CDECL *start) (void *);
+  void *arg;
+};
+
+
+struct pthread_cond_t_
+{
+  long nWaitersBlocked;		/* Number of threads blocked            */
+  long nWaitersGone;		/* Number of threads timed out          */
+  long nWaitersToUnblock;	/* Number of threads to unblock         */
+  sem_t semBlockQueue;		/* Queue up threads waiting for the     */
+  /*   condition to become signalled      */
+  sem_t semBlockLock;		/* Semaphore that guards access to      */
+  /* | waiters blocked count/block queue  */
+  /* +-> Mandatory Sync.LEVEL-1           */
+  pthread_mutex_t mtxUnblockLock;	/* Mutex that guards access to          */
+  /* | waiters (to)unblock(ed) counts     */
+  /* +-> Optional* Sync.LEVEL-2           */
+  pthread_cond_t next;		/* Doubly linked list                   */
+  pthread_cond_t prev;
+};
+
+
+struct pthread_condattr_t_
+{
+  int pshared;
+};
+
+#define  __PTW32_RWLOCK_MAGIC 0xfacade2
+
+struct pthread_rwlock_t_
+{
+  pthread_mutex_t mtxExclusiveAccess;
+  pthread_mutex_t mtxSharedAccessCompleted;
+  pthread_cond_t cndSharedAccessCompleted;
+  int nSharedAccessCount;
+  int nExclusiveAccessCount;
+  int nCompletedSharedAccessCount;
+  int nMagic;
+};
+
+struct pthread_rwlockattr_t_
+{
+  int pshared;
+};
+
+typedef union
+{
+  char cpuset[CPU_SETSIZE/8];
+  size_t _cpuset;
+} _sched_cpu_set_vector_;
+
+typedef struct ThreadKeyAssoc ThreadKeyAssoc;
+
+struct ThreadKeyAssoc
+{
+  /*
+   * Purpose:
+   *      This structure creates an association between a thread and a key.
+   *      It is used to implement the implicit invocation of a user defined
+   *      destroy routine for thread specific data registered by a user upon
+   *      exiting a thread.
+   *
+   *      Graphically, the arrangement is as follows, where:
+   *
+   *         K - Key with destructor
+   *            (head of chain is key->threads)
+   *         T - Thread that has called pthread_setspecific(Kn)
+   *            (head of chain is thread->keys)
+   *         A - Association. Each association is a node at the
+   *             intersection of two doubly-linked lists.
+   *
+   *                 T1    T2    T3
+   *                 |     |     |
+   *                 |     |     |
+   *         K1 -----+-----A-----A----->
+   *                 |     |     |
+   *                 |     |     |
+   *         K2 -----A-----A-----+----->
+   *                 |     |     |
+   *                 |     |     |
+   *         K3 -----A-----+-----A----->
+   *                 |     |     |
+   *                 |     |     |
+   *                 V     V     V
+   *
+   *      Access to the association is guarded by two locks: the key's
+   *      general lock (guarding the row) and the thread's general
+   *      lock (guarding the column). This avoids the need for a
+   *      dedicated lock for each association, which not only consumes
+   *      more handles but requires that the lock resources persist
+   *      until both the key is deleted and the thread has called the
+   *      destructor. The two-lock arrangement allows those resources
+   *      to be freed as soon as either thread or key is concluded.
+   *
+   *      To avoid deadlock, whenever both locks are required both the
+   *      key and thread locks are acquired consistently in the order
+   *      "key lock then thread lock". An exception to this exists
+   *      when a thread calls the destructors, however, this is done
+   *      carefully (but inelegantly) to avoid deadlock.
+   *
+   *      An association is created when a thread first calls
+   *      pthread_setspecific() on a key that has a specified
+   *      destructor.
+   *
+   *      An association is destroyed either immediately after the
+   *      thread calls the key destructor function on thread exit, or
+   *      when the key is deleted.
+   *
+   * Attributes:
+   *      thread
+   *              reference to the thread that owns the
+   *              association. This is actually the pointer to the
+   *              thread struct itself. Since the association is
+   *              destroyed before the thread exits, this can never
+   *              point to a different logical thread to the one that
+   *              created the assoc, i.e. after thread struct reuse.
+   *
+   *      key
+   *              reference to the key that owns the association.
+   *
+   *      nextKey
+   *              The pthread_t->keys attribute is the head of a
+   *              chain of associations that runs through the nextKey
+   *              link. This chain provides the 1 to many relationship
+   *              between a pthread_t and all pthread_key_t on which
+   *              it called pthread_setspecific.
+   *
+   *      prevKey
+   *              Similarly.
+   *
+   *      nextThread
+   *              The pthread_key_t->threads attribute is the head of
+   *              a chain of associations that runs through the
+   *              nextThreads link. This chain provides the 1 to many
+   *              relationship between a pthread_key_t and all the
+   *              PThreads that have called pthread_setspecific for
+   *              this pthread_key_t.
+   *
+   *      prevThread
+   *              Similarly.
+   *
+   * Notes:
+   *      1)      As soon as either the key or the thread is no longer
+   *              referencing the association, it can be destroyed. The
+   *              association will be removed from both chains.
+   *
+   *      2)      Under WIN32, an association is only created by
+   *              pthread_setspecific if the user provided a
+   *              destroyRoutine when they created the key.
+   *
+   *
+   */
+  __ptw32_thread_t * thread;
+  pthread_key_t key;
+  ThreadKeyAssoc *nextKey;
+  ThreadKeyAssoc *nextThread;
+  ThreadKeyAssoc *prevKey;
+  ThreadKeyAssoc *prevThread;
+};
+
+
+#if defined(__PTW32_CLEANUP_SEH)
+/*
+ * --------------------------------------------------------------
+ * MAKE_SOFTWARE_EXCEPTION
+ *      This macro constructs a software exception code following
+ *      the same format as the standard Win32 error codes as defined
+ *      in WINERROR.H
+ *  Values are 32 bit values laid out as follows:
+ *
+ *   1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
+ *  +---+-+-+-----------------------+-------------------------------+
+ *  |Sev|C|R|     Facility          |               Code            |
+ *  +---+-+-+-----------------------+-------------------------------+
+ *
+ * Severity Values:
+ */
+#define SE_SUCCESS              0x00
+#define SE_INFORMATION          0x01
+#define SE_WARNING              0x02
+#define SE_ERROR                0x03
+
+#define MAKE_SOFTWARE_EXCEPTION( _severity, _facility, _exception ) \
+( (DWORD) ( ( (_severity) << 30 ) |     /* Severity code        */ \
+            ( 1 << 29 ) |               /* MS=0, User=1         */ \
+            ( 0 << 28 ) |               /* Reserved             */ \
+            ( (_facility) << 16 ) |     /* Facility Code        */ \
+            ( (_exception) <<  0 )      /* Exception Code       */ \
+            ) )
+
+/*
+ * We choose one specific Facility/Error code combination to
+ * identify our software exceptions vs. WIN32 exceptions.
+ * We store our actual component and error code within
+ * the optional information array.
+ */
+#define EXCEPTION_PTW32_SERVICES        \
+     MAKE_SOFTWARE_EXCEPTION( SE_ERROR, \
+                               __PTW32_SERVICES_FACILITY, \
+                               __PTW32_SERVICES_ERROR )
+
+#define  __PTW32_SERVICES_FACILITY         0xBAD
+#define  __PTW32_SERVICES_ERROR            0xDEED
+
+#endif /* __PTW32_CLEANUP_SEH */
+
+/*
+ * Services available through EXCEPTION_PTW32_SERVICES
+ * and also used [as parameters to __ptw32_throw()] as
+ * generic exception selectors.
+ */
+
+#define  __PTW32_EPS_EXIT                  (1)
+#define  __PTW32_EPS_CANCEL                (2)
+
+
+/* Useful macros */
+#define  __PTW32_MAX(a,b)  ((a)<(b)?(b):(a))
+#define  __PTW32_MIN(a,b)  ((a)>(b)?(b):(a))
+
+
+/* Declared in pthread_cancel.c */
+extern DWORD (*__ptw32_register_cancellation) (PAPCFUNC, HANDLE, DWORD);
+
+/* Thread Reuse stack bottom marker. Must not be NULL or any valid pointer to memory. */
+#define  __PTW32_THREAD_REUSE_EMPTY ((__ptw32_thread_t *)(size_t) 1)
+
+extern int __ptw32_processInitialized;
+extern __ptw32_thread_t * __ptw32_threadReuseTop;
+extern __ptw32_thread_t * __ptw32_threadReuseBottom;
+extern pthread_key_t __ptw32_selfThreadKey;
+extern pthread_key_t __ptw32_cleanupKey;
+extern pthread_cond_t __ptw32_cond_list_head;
+extern pthread_cond_t __ptw32_cond_list_tail;
+
+extern int __ptw32_mutex_default_kind;
+
+extern unsigned __int64 __ptw32_threadSeqNumber;
+
+extern int __ptw32_concurrency;
+
+extern int __ptw32_features;
+
+extern __ptw32_mcs_lock_t __ptw32_thread_reuse_lock;
+extern __ptw32_mcs_lock_t __ptw32_mutex_test_init_lock;
+extern __ptw32_mcs_lock_t __ptw32_cond_list_lock;
+extern __ptw32_mcs_lock_t __ptw32_cond_test_init_lock;
+extern __ptw32_mcs_lock_t __ptw32_rwlock_test_init_lock;
+extern __ptw32_mcs_lock_t __ptw32_spinlock_test_init_lock;
+
+#if defined(_UWIN)
+extern int pthread_count;
+#endif
+
+__PTW32_BEGIN_C_DECLS
+
+/*
+ * =====================
+ * =====================
+ * Forward Declarations
+ * =====================
+ * =====================
+ */
+
+  int __ptw32_is_attr (const pthread_attr_t * attr);
+
+  int __ptw32_cond_check_need_init (pthread_cond_t * cond);
+  int __ptw32_mutex_check_need_init (pthread_mutex_t * mutex);
+  int __ptw32_rwlock_check_need_init (pthread_rwlock_t * rwlock);
+  int __ptw32_spinlock_check_need_init (pthread_spinlock_t * lock);
+
+  int __ptw32_robust_mutex_inherit(pthread_mutex_t * mutex);
+  void __ptw32_robust_mutex_add(pthread_mutex_t* mutex, pthread_t self);
+  void __ptw32_robust_mutex_remove(pthread_mutex_t* mutex, __ptw32_thread_t* otp);
+
+  DWORD
+    __ptw32_Registercancellation (PAPCFUNC callback,
+			       HANDLE threadH, DWORD callback_arg);
+
+  int __ptw32_processInitialize (void);
+
+  void __ptw32_processTerminate (void);
+
+  void __ptw32_threadDestroy (pthread_t tid);
+
+  void __ptw32_pop_cleanup_all (int execute);
+
+  pthread_t __ptw32_new (void);
+
+  pthread_t __ptw32_threadReusePop (void);
+
+  void __ptw32_threadReusePush (pthread_t thread);
+
+  int __ptw32_getprocessors (int *count);
+
+  int __ptw32_setthreadpriority (pthread_t thread, int policy, int priority);
+
+  void __ptw32_rwlock_cancelwrwait (void *arg);
+
+#if ! defined (__MINGW32__) || (defined (__MSVCRT__) && ! defined (__DMC__))
+  unsigned __stdcall
+#else
+  void
+#endif
+    __ptw32_threadStart (void *vthreadParms);
+
+  void __ptw32_callUserDestroyRoutines (pthread_t thread);
+
+  int __ptw32_tkAssocCreate (__ptw32_thread_t * thread, pthread_key_t key);
+
+  void __ptw32_tkAssocDestroy (ThreadKeyAssoc * assoc);
+
+  int __ptw32_semwait (sem_t * sem);
+
+  DWORD __ptw32_relmillisecs (const struct timespec * abstime);
+
+  void __ptw32_mcs_lock_acquire (__ptw32_mcs_lock_t * lock, __ptw32_mcs_local_node_t * node);
+
+  int __ptw32_mcs_lock_try_acquire (__ptw32_mcs_lock_t * lock, __ptw32_mcs_local_node_t * node);
+
+  void __ptw32_mcs_lock_release (__ptw32_mcs_local_node_t * node);
+
+  void __ptw32_mcs_node_transfer (__ptw32_mcs_local_node_t * new_node, __ptw32_mcs_local_node_t * old_node);
+
+  void __ptw32_timespec_to_filetime (const struct timespec *ts, FILETIME * ft);
+
+  void __ptw32_filetime_to_timespec (const FILETIME * ft, struct timespec *ts);
+
+/* Declared in pthw32_calloc.c */
+#if defined(NEED_CALLOC)
+#define calloc(n, s) __ptw32_calloc(n, s)
+  void *__ptw32_calloc (size_t n, size_t s);
+#endif
+
+/* Declared in ptw32_throw.c */
+void __ptw32_throw (DWORD exception);
+
+__PTW32_END_C_DECLS
+
+#if defined(_UWIN_)
+#   if defined(_MT)
+
+__PTW32_BEGIN_C_DECLS
+
+  _CRTIMP unsigned long __cdecl _beginthread (void (__cdecl *) (void *),
+					      unsigned, void *);
+  _CRTIMP void __cdecl _endthread (void);
+  _CRTIMP unsigned long __cdecl _beginthreadex (void *, unsigned,
+						unsigned (__stdcall *) (void *),
+						void *, unsigned, unsigned *);
+  _CRTIMP void __cdecl _endthreadex (unsigned);
+
+__PTW32_END_C_DECLS
+
+#   endif
+#else
+#   if ! defined(WINCE)
+#     include <process.h>
+#   endif
+#endif
+
+
+/*
+ * Use intrinsic versions wherever possible. VC will do this
+ * automatically where possible and GCC define these if available:
+ * __GCC_HAVE_SYNC_COMPARE_AND_SWAP_1
+ * __GCC_HAVE_SYNC_COMPARE_AND_SWAP_2
+ * __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4
+ * __GCC_HAVE_SYNC_COMPARE_AND_SWAP_8
+ * __GCC_HAVE_SYNC_COMPARE_AND_SWAP_16
+ *
+ * The full set of Interlocked intrinsics in GCC are (check versions):
+ * type __sync_fetch_and_add (type *ptr, type value, ...)
+ * type __sync_fetch_and_sub (type *ptr, type value, ...)
+ * type __sync_fetch_and_or (type *ptr, type value, ...)
+ * type __sync_fetch_and_and (type *ptr, type value, ...)
+ * type __sync_fetch_and_xor (type *ptr, type value, ...)
+ * type __sync_fetch_and_nand (type *ptr, type value, ...)
+ * type __sync_add_and_fetch (type *ptr, type value, ...)
+ * type __sync_sub_and_fetch (type *ptr, type value, ...)
+ * type __sync_or_and_fetch (type *ptr, type value, ...)
+ * type __sync_and_and_fetch (type *ptr, type value, ...)
+ * type __sync_xor_and_fetch (type *ptr, type value, ...)
+ * type __sync_nand_and_fetch (type *ptr, type value, ...)
+ * bool __sync_bool_compare_and_swap (type *ptr, type oldval type newval, ...)
+ * type __sync_val_compare_and_swap (type *ptr, type oldval type newval, ...)
+ * __sync_synchronize (...) // Full memory barrier
+ * type __sync_lock_test_and_set (type *ptr, type value, ...) // Acquire barrier
+ * void __sync_lock_release (type *ptr, ...) // Release barrier
+ *
+ * These are all overloaded and take 1,2,4,8 byte scalar or pointer types.
+ *
+ * The above aren't available in Mingw32 as of gcc 4.5.2 so define our own.
+ */
+#if defined(__cplusplus)
+# define  __PTW32_TO_VLONG64PTR(ptr) reinterpret_cast<volatile LONG64 *>(ptr)
+#else
+# define  __PTW32_TO_VLONG64PTR(ptr) (ptr)
+#endif
+
+#if defined(__GNUC__)
+# if defined(_WIN64)
+# define  __PTW32_INTERLOCKED_COMPARE_EXCHANGE_64(location, value, comparand) \
+    ({                                                                     \
+      __typeof (value) _result;                                            \
+      __asm__ __volatile__                                                 \
+      (                                                                    \
+        "lock\n\t"                                                         \
+        "cmpxchgq      %2,(%1)"                                            \
+        :"=a" (_result)                                                    \
+        :"r"  (location), "r" (value), "a" (comparand)                     \
+        :"memory", "cc");                                                  \
+      _result;                                                             \
+    })
+# define  __PTW32_INTERLOCKED_EXCHANGE_64(location, value)                    \
+    ({                                                                     \
+      __typeof (value) _result;                                            \
+      __asm__ __volatile__                                                 \
+      (                                                                    \
+        "xchgq	 %0,(%1)"                                                  \
+        :"=r" (_result)                                                    \
+        :"r" (location), "0" (value)                                       \
+        :"memory", "cc");                                                  \
+      _result;                                                             \
+    })
+# define  __PTW32_INTERLOCKED_EXCHANGE_ADD_64(location, value)                \
+    ({                                                                     \
+      __typeof (value) _result;                                            \
+      __asm__ __volatile__                                                 \
+      (                                                                    \
+        "lock\n\t"                                                         \
+        "xaddq	 %0,(%1)"                                                  \
+        :"=r" (_result)                                                    \
+        :"r" (location), "0" (value)                                       \
+        :"memory", "cc");                                                  \
+      _result;                                                             \
+    })
+# define  __PTW32_INTERLOCKED_INCREMENT_64(location)                          \
+    ({                                                                     \
+       __PTW32_INTERLOCKED_LONG _temp = 1;                                    \
+      __asm__ __volatile__                                                 \
+      (                                                                    \
+        "lock\n\t"                                                         \
+        "xaddq	 %0,(%1)"                                                  \
+        :"+r" (_temp)                                                      \
+        :"r" (location)                                                    \
+        :"memory", "cc");                                                  \
+      ++_temp;                                                             \
+    })
+# define  __PTW32_INTERLOCKED_DECREMENT_64(location)                          \
+    ({                                                                     \
+       __PTW32_INTERLOCKED_LONG _temp = -1;                                   \
+      __asm__ __volatile__                                                 \
+      (                                                                    \
+        "lock\n\t"                                                         \
+        "xaddq	 %2,(%1)"                                                  \
+        :"+r" (_temp)                                                      \
+        :"r" (location)                                                    \
+        :"memory", "cc");                                                  \
+      --_temp;                                                             \
+    })
+#endif
+# define  __PTW32_INTERLOCKED_COMPARE_EXCHANGE_LONG(location, value, comparand) \
+    ({                                                                     \
+      __typeof (value) _result;                                            \
+      __asm__ __volatile__                                                 \
+      (                                                                    \
+        "lock\n\t"                                                         \
+        "cmpxchgl       %2,(%1)"                                           \
+        :"=a" (_result)                                                    \
+        :"r"  (location), "r" (value), "a" (comparand)                     \
+        :"memory", "cc");                                                  \
+      _result;                                                             \
+    })
+# define  __PTW32_INTERLOCKED_EXCHANGE_LONG(location, value)                  \
+    ({                                                                     \
+      __typeof (value) _result;                                            \
+      __asm__ __volatile__                                                 \
+      (                                                                    \
+        "xchgl	 %0,(%1)"                                                  \
+        :"=r" (_result)                                                    \
+        :"r" (location), "0" (value)                                       \
+        :"memory", "cc");                                                  \
+      _result;                                                             \
+    })
+# define  __PTW32_INTERLOCKED_EXCHANGE_ADD_LONG(location, value)              \
+    ({                                                                     \
+      __typeof (value) _result;                                            \
+      __asm__ __volatile__                                                 \
+      (                                                                    \
+        "lock\n\t"                                                         \
+        "xaddl	 %0,(%1)"                                                  \
+        :"=r" (_result)                                                    \
+        :"r" (location), "0" (value)                                       \
+        :"memory", "cc");                                                  \
+      _result;                                                             \
+    })
+# define  __PTW32_INTERLOCKED_INCREMENT_LONG(location)                        \
+    ({                                                                     \
+       __PTW32_INTERLOCKED_LONG _temp = 1;                                    \
+      __asm__ __volatile__                                                 \
+      (                                                                    \
+        "lock\n\t"                                                         \
+        "xaddl	 %0,(%1)"                                                  \
+        :"+r" (_temp)                                                      \
+        :"r" (location)                                                    \
+        :"memory", "cc");                                                  \
+      ++_temp;                                                             \
+    })
+# define  __PTW32_INTERLOCKED_DECREMENT_LONG(location)                        \
+    ({                                                                     \
+       __PTW32_INTERLOCKED_LONG _temp = -1;                                   \
+      __asm__ __volatile__                                                 \
+      (                                                                    \
+        "lock\n\t"                                                         \
+        "xaddl	 %0,(%1)"                                                  \
+        :"+r" (_temp)                                                      \
+        :"r" (location)                                                    \
+        :"memory", "cc");                                                  \
+      --_temp;                                                             \
+    })
+# define  __PTW32_INTERLOCKED_COMPARE_EXCHANGE_PTR(location, value, comparand) \
+     __PTW32_INTERLOCKED_COMPARE_EXCHANGE_SIZE ((__PTW32_INTERLOCKED_SIZEPTR)location, \
+                                             (__PTW32_INTERLOCKED_SIZE)value, \
+                                             (__PTW32_INTERLOCKED_SIZE)comparand)
+# define  __PTW32_INTERLOCKED_EXCHANGE_PTR(location, value) \
+     __PTW32_INTERLOCKED_EXCHANGE_SIZE ((__PTW32_INTERLOCKED_SIZEPTR)location, \
+                                     (__PTW32_INTERLOCKED_SIZE)value)
+#else
+# if defined(_WIN64)
+#   define  __PTW32_INTERLOCKED_COMPARE_EXCHANGE_64(p,v,c) InterlockedCompareExchange64 (__PTW32_TO_VLONG64PTR(p),(v),(c))
+#   define  __PTW32_INTERLOCKED_EXCHANGE_64(p,v) InterlockedExchange64 (__PTW32_TO_VLONG64PTR(p),(v))
+#   define  __PTW32_INTERLOCKED_EXCHANGE_ADD_64(p,v) InterlockedExchangeAdd64 (__PTW32_TO_VLONG64PTR(p),(v))
+#   define  __PTW32_INTERLOCKED_INCREMENT_64(p) InterlockedIncrement64 (__PTW32_TO_VLONG64PTR(p))
+#   define  __PTW32_INTERLOCKED_DECREMENT_64(p) InterlockedDecrement64 (__PTW32_TO_VLONG64PTR(p))
+# endif
+# if defined (__PTW32_CONFIG_MSVC6) && !defined(_WIN64)
+#  define  __PTW32_INTERLOCKED_COMPARE_EXCHANGE_LONG(location, value, comparand) \
+      ((LONG)InterlockedCompareExchange((PVOID *)(location), (PVOID)(value), (PVOID)(comparand)))
+# else
+#  define  __PTW32_INTERLOCKED_COMPARE_EXCHANGE_LONG InterlockedCompareExchange
+# endif
+# define  __PTW32_INTERLOCKED_EXCHANGE_LONG(p,v) InterlockedExchange((p),(v))
+# define  __PTW32_INTERLOCKED_EXCHANGE_ADD_LONG(p,v) InterlockedExchangeAdd((p),(v))
+# define  __PTW32_INTERLOCKED_INCREMENT_LONG(p) InterlockedIncrement((p))
+# define  __PTW32_INTERLOCKED_DECREMENT_LONG(p) InterlockedDecrement((p))
+# if defined (__PTW32_CONFIG_MSVC6) && !defined(_WIN64)
+#  define  __PTW32_INTERLOCKED_COMPARE_EXCHANGE_PTR InterlockedCompareExchange
+#  define  __PTW32_INTERLOCKED_EXCHANGE_PTR(location, value) \
+    ((PVOID)InterlockedExchange((LPLONG)(location), (LONG)(value)))
+# else
+#  define  __PTW32_INTERLOCKED_COMPARE_EXCHANGE_PTR(p,v,c) InterlockedCompareExchangePointer((p),(v),(c))
+#  define  __PTW32_INTERLOCKED_EXCHANGE_PTR(p,v) InterlockedExchangePointer((p),(v))
+# endif
+#endif
+#if defined(_WIN64)
+#   define  __PTW32_INTERLOCKED_COMPARE_EXCHANGE_SIZE(p,v,c)  __PTW32_INTERLOCKED_COMPARE_EXCHANGE_64 (__PTW32_TO_VLONG64PTR(p),(v),(c))
+#   define  __PTW32_INTERLOCKED_EXCHANGE_SIZE(p,v)  __PTW32_INTERLOCKED_EXCHANGE_64 (__PTW32_TO_VLONG64PTR(p),(v))
+#   define  __PTW32_INTERLOCKED_EXCHANGE_ADD_SIZE(p,v)  __PTW32_INTERLOCKED_EXCHANGE_ADD_64 (__PTW32_TO_VLONG64PTR(p),(v))
+#   define  __PTW32_INTERLOCKED_INCREMENT_SIZE(p)  __PTW32_INTERLOCKED_INCREMENT_64 (__PTW32_TO_VLONG64PTR(p))
+#   define  __PTW32_INTERLOCKED_DECREMENT_SIZE(p)  __PTW32_INTERLOCKED_DECREMENT_64 (__PTW32_TO_VLONG64PTR(p))
+#else
+#   define  __PTW32_INTERLOCKED_COMPARE_EXCHANGE_SIZE(p,v,c)  __PTW32_INTERLOCKED_COMPARE_EXCHANGE_LONG((p),(v),(c))
+#   define  __PTW32_INTERLOCKED_EXCHANGE_SIZE(p,v)  __PTW32_INTERLOCKED_EXCHANGE_LONG((p),(v))
+#   define  __PTW32_INTERLOCKED_EXCHANGE_ADD_SIZE(p,v)  __PTW32_INTERLOCKED_EXCHANGE_ADD_LONG((p),(v))
+#   define  __PTW32_INTERLOCKED_INCREMENT_SIZE(p)  __PTW32_INTERLOCKED_INCREMENT_LONG((p))
+#   define  __PTW32_INTERLOCKED_DECREMENT_SIZE(p)  __PTW32_INTERLOCKED_DECREMENT_LONG((p))
+#endif
+
+#if defined(NEED_CREATETHREAD)
+
+/*
+ * Macro uses args so we can cast start_proc to LPTHREAD_START_ROUTINE
+ * in order to avoid warnings because of return type
+ */
+
+#define _beginthreadex(security, \
+                       stack_size, \
+                       start_proc, \
+                       arg, \
+                       flags, \
+                       pid) \
+        CreateThread(security, \
+                     stack_size, \
+                     (LPTHREAD_START_ROUTINE) start_proc, \
+                     arg, \
+                     flags, \
+                     pid)
+
+#define _endthreadex ExitThread
+
+#endif				/* NEED_CREATETHREAD */
+
+
+#endif				/* _IMPLEMENT_H */
diff --git a/src/include/pthread/manual/ChangeLog b/src/include/pthread/manual/ChangeLog
new file mode 100644
index 0000000..bcf8930
--- /dev/null
+++ b/src/include/pthread/manual/ChangeLog
@@ -0,0 +1,104 @@
+2016-12-25  Ross Johnson  <ross at homemail dot com dot au>
+
+	* Change all references to "pthreads-w32" etc. to "PThreads4W"
+	* Change all references to the sourceware projects web page to the
+	SourceForge project web page.
+
+2015-02-03  Ross Johnson  <ross at homemail dot com dot au>
+
+	* *.html: Fix HEAD section inconsistencies and remove editor meta tags.
+	* pthread_equal.html (pthread_self): Fix HREF URL.
+	* pthread_exit.html (several): Likewise.
+	* pthread_setaffinity_np.html: New.
+
+2012-10-04  Ross Johnson  <ross at homemail dot com dot au>
+
+	* pthread_join.html (pthread_tryjoin_np): Added description.
+	* index.html (pthread_tryjoin_np): Added link.
+
+2012-09-20  Ross Johnson  <ross at homemail dot com dot au>
+
+	* cpu_set.html: New manual page.
+	* pthread_create.html: Updated.
+	* index.html: Updated.
+	* sched_setaffinity.html: Fixed corrupted formatting.
+	
+2012-08-19  Ross Johnson  <ross at homemail dot com dot au>
+
+	* pthread_join.html(pthread_timedjoin_np): Added.
+	* index.html(pthread_timedjoin_np): Added link.
+
+2011-03-26  Ross Johnson  <ross at homemail dot com dot au>
+
+	* pthread_nutex_init.html (robust mutexes): Added
+	descriptions for newly implemented interface.
+	* pthread_mutexattr_init.html (robust mutexes): Likewise.
+	* pthread_getsequence_np.html: New.
+	* index.html: Updated.
+
+2008-06-30  Ross Johnson  <ross at callisto.canberra.edu.au>
+
+	* pthread_setschedparam.html: Fix "see also" links.
+
+2005-05-06  Ross Johnson  <ross at callisto.canberra.edu.au>
+
+	* PortabilityIssues.html: Was nonPortableIssues.html.
+	* index.html: Updated; add table of contents at top.
+	* *.html: Add PThreads4W header info; add link back to the
+	index page 'index.html'.
+
+2005-05-06  Ross Johnson  <ross at callisto.canberra.edu.au>
+
+	* index.html: New.
+	* nonPortableIssues.html: New.
+	* pthread_attr_init.html: New.
+	* pthread_attr_setstackaddr.html: New.
+	* pthread_attr_setstacksize.html: New.
+	* pthread_barrierattr_init.html: New.
+	* pthread_barrierattr_setpshared.html: New.
+	* pthread_barrier_init.html: New.
+	* pthread_barrier_wait.html: New.
+	* pthreadCancelableWait.html: New.
+	* pthread_cancel.html: New.
+	* pthread_cleanup_push.html: New.
+	* pthread_condattr_init.html: New.
+	* pthread_condattr_setpshared.html: New.
+	* pthread_cond_init.html: New.
+	* pthread_create.html: New.
+	* pthread_delay_np.html: New.
+	* pthread_detach.html: New.
+	* pthread_equal.html: New.
+	* pthread_exit.html: New.
+	* pthread_getw32threadhandle_np.html: New.
+	* pthread_join.html: New.
+	* pthread_key_create.html: New.
+	* pthread_kill.html: New.
+	* pthread_mutexattr_init.html: New.
+	* pthread_mutexattr_setpshared.html: New.
+	* pthread_mutex_init.html: New.
+	* pthread_num_processors_np.html: New.
+	* pthread_once.html: New.
+	* pthread_rwlockattr_init.html: New.
+	* pthread_rwlockattr_setpshared.html: New.
+	* pthread_rwlock_init.html: New.
+	* pthread_rwlock_rdlock.html: New.
+	* pthread_rwlock_timedrdlock.html: New.
+	* pthread_rwlock_timedwrlock.html: New.
+	* pthread_rwlock_unlock.html: New.
+	* pthread_rwlock_wrlock.html: New.
+	* pthread_self.html: New.
+	* pthread_setcancelstate.html: New.
+	* pthread_setcanceltype.html: New.
+	* pthread_setconcurrency.html: New.
+	* pthread_setschedparam.html: New.
+	* pthread_spin_init.html: New.
+	* pthread_spin_lock.html: New.
+	* pthread_spin_unlock.html: New.
+	* pthread_timechange_handler_np.html: New.
+	* pthread_win32_attach_detach_np.html: New.
+	* pthread_win32_test_features_np.html: New.
+	* sched_get_priority_max.html: New.
+	* sched_getscheduler.html: New.
+	* sched_setscheduler.html: New.
+	* sched_yield.html: New.
+	* sem_init.html: New.
diff --git a/src/include/pthread/manual/PortabilityIssues.html b/src/include/pthread/manual/PortabilityIssues.html
new file mode 100644
index 0000000..0fce9e0
--- /dev/null
+++ b/src/include/pthread/manual/PortabilityIssues.html
@@ -0,0 +1,726 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=windows-1252">
+	<TITLE>PORTABILITY ISSUES manual page</TITLE>
+	<META NAME="GENERATOR" CONTENT="OpenOffice 4.1.1  (Win32)">
+	<META NAME="CREATED" CONTENT="0;0">
+	<META NAME="CHANGEDBY" CONTENT="Ross Johnson">
+	<META NAME="CHANGED" CONTENT="20160229;19514155">
+	<STYLE TYPE="text/css">
+	<!--
+		H4.cjk { font-family: "SimSun" }
+		H4.ctl { font-family: "Mangal" }
+		H2.cjk { font-family: "SimSun" }
+		H2.ctl { font-family: "Mangal" }
+	-->
+	</STYLE>
+</HEAD>
+<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
+<H4 CLASS="western">POSIX Threads for Windows &ndash; REFERENCE &ndash;
+<A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A></H4>
+<P><A HREF="index.html">Reference Index</A></P>
+<H4 CLASS="western"><A HREF="#toc">Table of Contents</A></H4>
+<H2 CLASS="western"><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P STYLE="font-weight: normal">Portability issues</P>
+<H2 CLASS="western"><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P><B>Thread priority</B></P>
+<H2 CLASS="western"><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<H3>Thread priority</H3>
+<P STYLE="margin-left: 2cm">POSIX defines a single contiguous range
+of numbers that determine a thread's priority. Win32 defines priority
+classes - and priority levels relative to these classes. Classes are
+simply priority base levels that the defined priority levels are
+relative to such that, changing a process's priority class will
+change the priority of all of it's threads, while the threads retain
+the same relativity to each other.</P>
+<P STYLE="margin-left: 2cm">A Win32 system defines a single
+contiguous monotonic range of values that define system priority
+levels, just like POSIX. However, Win32 restricts individual threads
+to a subset of this range on a per-process basis.</P>
+<P STYLE="margin-left: 2cm">The following table shows the base
+priority levels for combinations of priority class and priority value
+in Win32.</P>
+<DL>
+		<DD>
+		<TABLE WIDTH=742 BORDER=0 CELLPADDING=0 CELLSPACING=0 STYLE="page-break-inside: avoid">
+			<COL WIDTH=50>
+			<COL WIDTH=356>
+			<COL WIDTH=336>
+			<THEAD>
+				<TR VALIGN=TOP>
+					<TD WIDTH=50>
+						<P ALIGN=CENTER><BR>
+						</P>
+					</TD>
+					<TD WIDTH=356>
+						<P ALIGN=LEFT><B>Process Priority Class</B></P>
+					</TD>
+					<TD WIDTH=336>
+						<P ALIGN=LEFT><B>Thread Priority Level</B></P>
+					</TD>
+				</TR>
+			</THEAD>
+			<TBODY>
+				<TR>
+					<TD WIDTH=50 VALIGN=BOTTOM SDVAL="1" SDNUM="3081;">
+						<P ALIGN=CENTER>1</P>
+					</TD>
+					<TD WIDTH=356 VALIGN=TOP>
+						<P ALIGN=LEFT>IDLE_PRIORITY_CLASS</P>
+					</TD>
+					<TD WIDTH=336 VALIGN=TOP>
+						<P ALIGN=LEFT>THREAD_PRIORITY_IDLE</P>
+					</TD>
+				</TR>
+				<TR>
+					<TD WIDTH=50 VALIGN=BOTTOM SDVAL="1" SDNUM="3081;">
+						<P ALIGN=CENTER>1</P>
+					</TD>
+					<TD WIDTH=356 VALIGN=TOP>
+						<P ALIGN=LEFT>BELOW_NORMAL_PRIORITY_CLASS</P>
+					</TD>
+					<TD WIDTH=336 VALIGN=TOP>
+						<P ALIGN=LEFT>THREAD_PRIORITY_IDLE</P>
+					</TD>
+				</TR>
+				<TR>
+					<TD WIDTH=50 VALIGN=BOTTOM SDVAL="1" SDNUM="3081;">
+						<P ALIGN=CENTER>1</P>
+					</TD>
+					<TD WIDTH=356 VALIGN=TOP>
+						<P ALIGN=LEFT>NORMAL_PRIORITY_CLASS</P>
+					</TD>
+					<TD WIDTH=336 VALIGN=TOP>
+						<P ALIGN=LEFT>THREAD_PRIORITY_IDLE</P>
+					</TD>
+				</TR>
+				<TR>
+					<TD WIDTH=50 VALIGN=BOTTOM SDVAL="1" SDNUM="3081;">
+						<P ALIGN=CENTER>1</P>
+					</TD>
+					<TD WIDTH=356 VALIGN=TOP>
+						<P ALIGN=LEFT>ABOVE_NORMAL_PRIORITY_CLASS</P>
+					</TD>
+					<TD WIDTH=336 VALIGN=TOP>
+						<P ALIGN=LEFT>THREAD_PRIORITY_IDLE</P>
+					</TD>
+				</TR>
+				<TR>
+					<TD WIDTH=50 VALIGN=BOTTOM SDVAL="1" SDNUM="3081;">
+						<P ALIGN=CENTER>1</P>
+					</TD>
+					<TD WIDTH=356 VALIGN=TOP>
+						<P ALIGN=LEFT>HIGH_PRIORITY_CLASS</P>
+					</TD>
+					<TD WIDTH=336 VALIGN=TOP>
+						<P ALIGN=LEFT>THREAD_PRIORITY_IDLE</P>
+					</TD>
+				</TR>
+				<TR>
+					<TD WIDTH=50 VALIGN=BOTTOM SDVAL="2" SDNUM="3081;">
+						<P ALIGN=CENTER>2</P>
+					</TD>
+					<TD WIDTH=356 VALIGN=TOP>
+						<P ALIGN=LEFT>IDLE_PRIORITY_CLASS</P>
+					</TD>
+					<TD WIDTH=336 VALIGN=TOP>
+						<P ALIGN=LEFT>THREAD_PRIORITY_LOWEST</P>
+					</TD>
+				</TR>
+				<TR>
+					<TD WIDTH=50 VALIGN=BOTTOM SDVAL="3" SDNUM="3081;">
+						<P ALIGN=CENTER>3</P>
+					</TD>
+					<TD WIDTH=356 VALIGN=TOP>
+						<P ALIGN=LEFT>IDLE_PRIORITY_CLASS</P>
+					</TD>
+					<TD WIDTH=336 VALIGN=TOP>
+						<P ALIGN=LEFT>THREAD_PRIORITY_BELOW_NORMAL</P>
+					</TD>
+				</TR>
+				<TR>
+					<TD WIDTH=50 VALIGN=BOTTOM SDVAL="4" SDNUM="3081;">
+						<P ALIGN=CENTER>4</P>
+					</TD>
+					<TD WIDTH=356 VALIGN=TOP>
+						<P ALIGN=LEFT>IDLE_PRIORITY_CLASS</P>
+					</TD>
+					<TD WIDTH=336 VALIGN=TOP>
+						<P ALIGN=LEFT>THREAD_PRIORITY_NORMAL</P>
+					</TD>
+				</TR>
+				<TR>
+					<TD WIDTH=50 VALIGN=BOTTOM SDVAL="4" SDNUM="3081;">
+						<P ALIGN=CENTER>4</P>
+					</TD>
+					<TD WIDTH=356 VALIGN=TOP>
+						<P ALIGN=LEFT>BELOW_NORMAL_PRIORITY_CLASS</P>
+					</TD>
+					<TD WIDTH=336 VALIGN=TOP>
+						<P ALIGN=LEFT>THREAD_PRIORITY_LOWEST</P>
+					</TD>
+				</TR>
+				<TR>
+					<TD WIDTH=50 VALIGN=BOTTOM SDVAL="5" SDNUM="3081;">
+						<P ALIGN=CENTER>5</P>
+					</TD>
+					<TD WIDTH=356 VALIGN=TOP>
+						<P ALIGN=LEFT>IDLE_PRIORITY_CLASS</P>
+					</TD>
+					<TD WIDTH=336 VALIGN=TOP>
+						<P ALIGN=LEFT>THREAD_PRIORITY_ABOVE_NORMAL</P>
+					</TD>
+				</TR>
+				<TR>
+					<TD WIDTH=50 VALIGN=BOTTOM SDVAL="5" SDNUM="3081;">
+						<P ALIGN=CENTER>5</P>
+					</TD>
+					<TD WIDTH=356 VALIGN=TOP>
+						<P ALIGN=LEFT>BELOW_NORMAL_PRIORITY_CLASS</P>
+					</TD>
+					<TD WIDTH=336 VALIGN=TOP>
+						<P ALIGN=LEFT>THREAD_PRIORITY_BELOW_NORMAL</P>
+					</TD>
+				</TR>
+				<TR>
+					<TD WIDTH=50 VALIGN=BOTTOM SDVAL="5" SDNUM="3081;">
+						<P ALIGN=CENTER>5</P>
+					</TD>
+					<TD WIDTH=356 VALIGN=TOP>
+						<P ALIGN=LEFT>Background NORMAL_PRIORITY_CLASS</P>
+					</TD>
+					<TD WIDTH=336 VALIGN=TOP>
+						<P ALIGN=LEFT>THREAD_PRIORITY_LOWEST</P>
+					</TD>
+				</TR>
+				<TR>
+					<TD WIDTH=50 VALIGN=BOTTOM SDVAL="6" SDNUM="3081;">
+						<P ALIGN=CENTER>6</P>
+					</TD>
+					<TD WIDTH=356 VALIGN=TOP>
+						<P ALIGN=LEFT>IDLE_PRIORITY_CLASS</P>
+					</TD>
+					<TD WIDTH=336 VALIGN=TOP>
+						<P ALIGN=LEFT>THREAD_PRIORITY_HIGHEST</P>
+					</TD>
+				</TR>
+				<TR>
+					<TD WIDTH=50 VALIGN=BOTTOM SDVAL="6" SDNUM="3081;">
+						<P ALIGN=CENTER>6</P>
+					</TD>
+					<TD WIDTH=356 VALIGN=TOP>
+						<P ALIGN=LEFT>BELOW_NORMAL_PRIORITY_CLASS</P>
+					</TD>
+					<TD WIDTH=336 VALIGN=TOP>
+						<P ALIGN=LEFT>THREAD_PRIORITY_NORMAL</P>
+					</TD>
+				</TR>
+				<TR>
+					<TD WIDTH=50 VALIGN=BOTTOM SDVAL="6" SDNUM="3081;">
+						<P ALIGN=CENTER>6</P>
+					</TD>
+					<TD WIDTH=356 VALIGN=TOP>
+						<P ALIGN=LEFT>Background NORMAL_PRIORITY_CLASS</P>
+					</TD>
+					<TD WIDTH=336 VALIGN=TOP>
+						<P ALIGN=LEFT>THREAD_PRIORITY_BELOW_NORMAL</P>
+					</TD>
+				</TR>
+				<TR>
+					<TD WIDTH=50 VALIGN=BOTTOM SDVAL="7" SDNUM="3081;">
+						<P ALIGN=CENTER>7</P>
+					</TD>
+					<TD WIDTH=356 VALIGN=TOP>
+						<P ALIGN=LEFT>BELOW_NORMAL_PRIORITY_CLASS</P>
+					</TD>
+					<TD WIDTH=336 VALIGN=TOP>
+						<P ALIGN=LEFT>THREAD_PRIORITY_ABOVE_NORMAL</P>
+					</TD>
+				</TR>
+				<TR>
+					<TD WIDTH=50 VALIGN=BOTTOM SDVAL="7" SDNUM="3081;">
+						<P ALIGN=CENTER>7</P>
+					</TD>
+					<TD WIDTH=356 VALIGN=TOP>
+						<P ALIGN=LEFT>Background NORMAL_PRIORITY_CLASS</P>
+					</TD>
+					<TD WIDTH=336 VALIGN=TOP>
+						<P ALIGN=LEFT>THREAD_PRIORITY_NORMAL</P>
+					</TD>
+				</TR>
+				<TR>
+					<TD WIDTH=50 VALIGN=BOTTOM SDVAL="7" SDNUM="3081;">
+						<P ALIGN=CENTER>7</P>
+					</TD>
+					<TD WIDTH=356 VALIGN=TOP>
+						<P ALIGN=LEFT>Foreground NORMAL_PRIORITY_CLASS</P>
+					</TD>
+					<TD WIDTH=336 VALIGN=TOP>
+						<P ALIGN=LEFT>THREAD_PRIORITY_LOWEST</P>
+					</TD>
+				</TR>
+				<TR>
+					<TD WIDTH=50 VALIGN=BOTTOM SDVAL="8" SDNUM="3081;">
+						<P ALIGN=CENTER>8</P>
+					</TD>
+					<TD WIDTH=356 VALIGN=TOP>
+						<P ALIGN=LEFT>BELOW_NORMAL_PRIORITY_CLASS</P>
+					</TD>
+					<TD WIDTH=336 VALIGN=TOP>
+						<P ALIGN=LEFT>THREAD_PRIORITY_HIGHEST</P>
+					</TD>
+				</TR>
+				<TR>
+					<TD WIDTH=50 VALIGN=BOTTOM SDVAL="8" SDNUM="3081;">
+						<P ALIGN=CENTER>8</P>
+					</TD>
+					<TD WIDTH=356 VALIGN=TOP>
+						<P ALIGN=LEFT>NORMAL_PRIORITY_CLASS</P>
+					</TD>
+					<TD WIDTH=336 VALIGN=TOP>
+						<P ALIGN=LEFT>THREAD_PRIORITY_ABOVE_NORMAL</P>
+					</TD>
+				</TR>
+				<TR>
+					<TD WIDTH=50 VALIGN=BOTTOM SDVAL="8" SDNUM="3081;">
+						<P ALIGN=CENTER>8</P>
+					</TD>
+					<TD WIDTH=356 VALIGN=TOP>
+						<P ALIGN=LEFT>Foreground NORMAL_PRIORITY_CLASS</P>
+					</TD>
+					<TD WIDTH=336 VALIGN=TOP>
+						<P ALIGN=LEFT>THREAD_PRIORITY_BELOW_NORMAL</P>
+					</TD>
+				</TR>
+				<TR>
+					<TD WIDTH=50 VALIGN=BOTTOM SDVAL="8" SDNUM="3081;">
+						<P ALIGN=CENTER>8</P>
+					</TD>
+					<TD WIDTH=356 VALIGN=TOP>
+						<P ALIGN=LEFT>ABOVE_NORMAL_PRIORITY_CLASS</P>
+					</TD>
+					<TD WIDTH=336 VALIGN=TOP>
+						<P ALIGN=LEFT>THREAD_PRIORITY_LOWEST</P>
+					</TD>
+				</TR>
+				<TR>
+					<TD WIDTH=50 VALIGN=BOTTOM SDVAL="9" SDNUM="3081;">
+						<P ALIGN=CENTER>9</P>
+					</TD>
+					<TD WIDTH=356 VALIGN=TOP>
+						<P ALIGN=LEFT>NORMAL_PRIORITY_CLASS</P>
+					</TD>
+					<TD WIDTH=336 VALIGN=TOP>
+						<P ALIGN=LEFT>THREAD_PRIORITY_HIGHEST</P>
+					</TD>
+				</TR>
+				<TR>
+					<TD WIDTH=50 VALIGN=BOTTOM SDVAL="9" SDNUM="3081;">
+						<P ALIGN=CENTER>9</P>
+					</TD>
+					<TD WIDTH=356 VALIGN=TOP>
+						<P ALIGN=LEFT>Foreground NORMAL_PRIORITY_CLASS</P>
+					</TD>
+					<TD WIDTH=336 VALIGN=TOP>
+						<P ALIGN=LEFT>THREAD_PRIORITY_NORMAL</P>
+					</TD>
+				</TR>
+				<TR>
+					<TD WIDTH=50 VALIGN=BOTTOM SDVAL="9" SDNUM="3081;">
+						<P ALIGN=CENTER>9</P>
+					</TD>
+					<TD WIDTH=356 VALIGN=TOP>
+						<P ALIGN=LEFT>ABOVE_NORMAL_PRIORITY_CLASS</P>
+					</TD>
+					<TD WIDTH=336 VALIGN=TOP>
+						<P ALIGN=LEFT>THREAD_PRIORITY_BELOW_NORMAL</P>
+					</TD>
+				</TR>
+				<TR>
+					<TD WIDTH=50 VALIGN=BOTTOM SDVAL="10" SDNUM="3081;">
+						<P ALIGN=CENTER>10</P>
+					</TD>
+					<TD WIDTH=356 VALIGN=TOP>
+						<P ALIGN=LEFT>Foreground NORMAL_PRIORITY_CLASS</P>
+					</TD>
+					<TD WIDTH=336 VALIGN=TOP>
+						<P ALIGN=LEFT>THREAD_PRIORITY_ABOVE_NORMAL</P>
+					</TD>
+				</TR>
+				<TR>
+					<TD WIDTH=50 VALIGN=BOTTOM SDVAL="10" SDNUM="3081;">
+						<P ALIGN=CENTER>10</P>
+					</TD>
+					<TD WIDTH=356 VALIGN=TOP>
+						<P ALIGN=LEFT>ABOVE_NORMAL_PRIORITY_CLASS</P>
+					</TD>
+					<TD WIDTH=336 VALIGN=TOP>
+						<P ALIGN=LEFT>THREAD_PRIORITY_NORMAL</P>
+					</TD>
+				</TR>
+				<TR>
+					<TD WIDTH=50 VALIGN=BOTTOM SDVAL="11" SDNUM="3081;">
+						<P ALIGN=CENTER>11</P>
+					</TD>
+					<TD WIDTH=356 VALIGN=TOP>
+						<P ALIGN=LEFT>Foreground NORMAL_PRIORITY_CLASS</P>
+					</TD>
+					<TD WIDTH=336 VALIGN=TOP>
+						<P ALIGN=LEFT>THREAD_PRIORITY_HIGHEST</P>
+					</TD>
+				</TR>
+				<TR>
+					<TD WIDTH=50 VALIGN=BOTTOM SDVAL="11" SDNUM="3081;">
+						<P ALIGN=CENTER>11</P>
+					</TD>
+					<TD WIDTH=356 VALIGN=TOP>
+						<P ALIGN=LEFT>ABOVE_NORMAL_PRIORITY_CLASS</P>
+					</TD>
+					<TD WIDTH=336 VALIGN=TOP>
+						<P ALIGN=LEFT>THREAD_PRIORITY_ABOVE_NORMAL</P>
+					</TD>
+				</TR>
+				<TR>
+					<TD WIDTH=50 VALIGN=BOTTOM SDVAL="11" SDNUM="3081;">
+						<P ALIGN=CENTER>11</P>
+					</TD>
+					<TD WIDTH=356 VALIGN=TOP>
+						<P ALIGN=LEFT>HIGH_PRIORITY_CLASS</P>
+					</TD>
+					<TD WIDTH=336 VALIGN=TOP>
+						<P ALIGN=LEFT>THREAD_PRIORITY_LOWEST</P>
+					</TD>
+				</TR>
+				<TR>
+					<TD WIDTH=50 VALIGN=BOTTOM SDVAL="12" SDNUM="3081;">
+						<P ALIGN=CENTER>12</P>
+					</TD>
+					<TD WIDTH=356 VALIGN=TOP>
+						<P ALIGN=LEFT>ABOVE_NORMAL_PRIORITY_CLASS</P>
+					</TD>
+					<TD WIDTH=336 VALIGN=TOP>
+						<P ALIGN=LEFT>THREAD_PRIORITY_HIGHEST</P>
+					</TD>
+				</TR>
+				<TR>
+					<TD WIDTH=50 VALIGN=BOTTOM SDVAL="12" SDNUM="3081;">
+						<P ALIGN=CENTER>12</P>
+					</TD>
+					<TD WIDTH=356 VALIGN=TOP>
+						<P ALIGN=LEFT>HIGH_PRIORITY_CLASS</P>
+					</TD>
+					<TD WIDTH=336 VALIGN=TOP>
+						<P ALIGN=LEFT>THREAD_PRIORITY_BELOW_NORMAL</P>
+					</TD>
+				</TR>
+				<TR>
+					<TD WIDTH=50 VALIGN=BOTTOM SDVAL="13" SDNUM="3081;">
+						<P ALIGN=CENTER>13</P>
+					</TD>
+					<TD WIDTH=356 VALIGN=TOP>
+						<P ALIGN=LEFT>HIGH_PRIORITY_CLASS</P>
+					</TD>
+					<TD WIDTH=336 VALIGN=TOP>
+						<P ALIGN=LEFT>THREAD_PRIORITY_NORMAL</P>
+					</TD>
+				</TR>
+				<TR>
+					<TD WIDTH=50 VALIGN=BOTTOM SDVAL="14" SDNUM="3081;">
+						<P ALIGN=CENTER>14</P>
+					</TD>
+					<TD WIDTH=356 VALIGN=TOP>
+						<P ALIGN=LEFT>HIGH_PRIORITY_CLASS</P>
+					</TD>
+					<TD WIDTH=336 VALIGN=TOP>
+						<P ALIGN=LEFT>THREAD_PRIORITY_ABOVE_NORMAL</P>
+					</TD>
+				</TR>
+				<TR>
+					<TD WIDTH=50 VALIGN=BOTTOM SDVAL="15" SDNUM="3081;">
+						<P ALIGN=CENTER>15</P>
+					</TD>
+					<TD WIDTH=356 VALIGN=TOP>
+						<P ALIGN=LEFT>HIGH_PRIORITY_CLASS</P>
+					</TD>
+					<TD WIDTH=336 VALIGN=TOP>
+						<P ALIGN=LEFT>THREAD_PRIORITY_HIGHEST</P>
+					</TD>
+				</TR>
+				<TR>
+					<TD WIDTH=50 VALIGN=BOTTOM SDVAL="15" SDNUM="3081;">
+						<P ALIGN=CENTER>15</P>
+					</TD>
+					<TD WIDTH=356 VALIGN=TOP>
+						<P ALIGN=LEFT>HIGH_PRIORITY_CLASS</P>
+					</TD>
+					<TD WIDTH=336 VALIGN=TOP>
+						<P ALIGN=LEFT>THREAD_PRIORITY_TIME_CRITICAL</P>
+					</TD>
+				</TR>
+				<TR>
+					<TD WIDTH=50 VALIGN=BOTTOM SDVAL="15" SDNUM="3081;">
+						<P ALIGN=CENTER>15</P>
+					</TD>
+					<TD WIDTH=356 VALIGN=TOP>
+						<P ALIGN=LEFT>IDLE_PRIORITY_CLASS</P>
+					</TD>
+					<TD WIDTH=336 VALIGN=TOP>
+						<P ALIGN=LEFT>THREAD_PRIORITY_TIME_CRITICAL</P>
+					</TD>
+				</TR>
+				<TR>
+					<TD WIDTH=50 VALIGN=BOTTOM SDVAL="15" SDNUM="3081;">
+						<P ALIGN=CENTER>15</P>
+					</TD>
+					<TD WIDTH=356 VALIGN=TOP>
+						<P ALIGN=LEFT>BELOW_NORMAL_PRIORITY_CLASS</P>
+					</TD>
+					<TD WIDTH=336 VALIGN=TOP>
+						<P ALIGN=LEFT>THREAD_PRIORITY_TIME_CRITICAL</P>
+					</TD>
+				</TR>
+				<TR>
+					<TD WIDTH=50 VALIGN=BOTTOM SDVAL="15" SDNUM="3081;">
+						<P ALIGN=CENTER>15</P>
+					</TD>
+					<TD WIDTH=356 VALIGN=TOP>
+						<P ALIGN=LEFT>NORMAL_PRIORITY_CLASS</P>
+					</TD>
+					<TD WIDTH=336 VALIGN=TOP>
+						<P ALIGN=LEFT>THREAD_PRIORITY_TIME_CRITICAL</P>
+					</TD>
+				</TR>
+				<TR>
+					<TD WIDTH=50 VALIGN=BOTTOM SDVAL="15" SDNUM="3081;">
+						<P ALIGN=CENTER>15</P>
+					</TD>
+					<TD WIDTH=356 VALIGN=TOP>
+						<P ALIGN=LEFT>ABOVE_NORMAL_PRIORITY_CLASS</P>
+					</TD>
+					<TD WIDTH=336 VALIGN=TOP>
+						<P ALIGN=LEFT>THREAD_PRIORITY_TIME_CRITICAL</P>
+					</TD>
+				</TR>
+				<TR>
+					<TD WIDTH=50 VALIGN=BOTTOM SDVAL="16" SDNUM="3081;">
+						<P ALIGN=CENTER>16</P>
+					</TD>
+					<TD WIDTH=356 VALIGN=TOP>
+						<P ALIGN=LEFT>REALTIME_PRIORITY_CLASS</P>
+					</TD>
+					<TD WIDTH=336 VALIGN=TOP>
+						<P ALIGN=LEFT>THREAD_PRIORITY_IDLE</P>
+					</TD>
+				</TR>
+				<TR>
+					<TD WIDTH=50 VALIGN=BOTTOM SDVAL="17" SDNUM="3081;">
+						<P ALIGN=CENTER>17</P>
+					</TD>
+					<TD WIDTH=356 VALIGN=TOP>
+						<P ALIGN=LEFT>REALTIME_PRIORITY_CLASS</P>
+					</TD>
+					<TD WIDTH=336 VALIGN=BOTTOM SDVAL="-7" SDNUM="3081;">
+						<P ALIGN=LEFT>-7</P>
+					</TD>
+				</TR>
+				<TR>
+					<TD WIDTH=50 VALIGN=BOTTOM SDVAL="18" SDNUM="3081;">
+						<P ALIGN=CENTER>18</P>
+					</TD>
+					<TD WIDTH=356 VALIGN=TOP>
+						<P ALIGN=LEFT>REALTIME_PRIORITY_CLASS</P>
+					</TD>
+					<TD WIDTH=336 VALIGN=BOTTOM SDVAL="-6" SDNUM="3081;">
+						<P ALIGN=LEFT>-6</P>
+					</TD>
+				</TR>
+				<TR>
+					<TD WIDTH=50 VALIGN=BOTTOM SDVAL="19" SDNUM="3081;">
+						<P ALIGN=CENTER>19</P>
+					</TD>
+					<TD WIDTH=356 VALIGN=TOP>
+						<P ALIGN=LEFT>REALTIME_PRIORITY_CLASS</P>
+					</TD>
+					<TD WIDTH=336 VALIGN=BOTTOM SDVAL="-5" SDNUM="3081;">
+						<P ALIGN=LEFT>-5</P>
+					</TD>
+				</TR>
+				<TR>
+					<TD WIDTH=50 VALIGN=BOTTOM SDVAL="20" SDNUM="3081;">
+						<P ALIGN=CENTER>20</P>
+					</TD>
+					<TD WIDTH=356 VALIGN=TOP>
+						<P ALIGN=LEFT>REALTIME_PRIORITY_CLASS</P>
+					</TD>
+					<TD WIDTH=336 VALIGN=BOTTOM SDVAL="-4" SDNUM="3081;">
+						<P ALIGN=LEFT>-4</P>
+					</TD>
+				</TR>
+				<TR>
+					<TD WIDTH=50 VALIGN=BOTTOM SDVAL="21" SDNUM="3081;">
+						<P ALIGN=CENTER>21</P>
+					</TD>
+					<TD WIDTH=356 VALIGN=TOP>
+						<P ALIGN=LEFT>REALTIME_PRIORITY_CLASS</P>
+					</TD>
+					<TD WIDTH=336 VALIGN=BOTTOM SDVAL="-3" SDNUM="3081;">
+						<P ALIGN=LEFT>-3</P>
+					</TD>
+				</TR>
+				<TR>
+					<TD WIDTH=50 VALIGN=BOTTOM SDVAL="22" SDNUM="3081;">
+						<P ALIGN=CENTER>22</P>
+					</TD>
+					<TD WIDTH=356 VALIGN=TOP>
+						<P ALIGN=LEFT>REALTIME_PRIORITY_CLASS</P>
+					</TD>
+					<TD WIDTH=336 VALIGN=TOP>
+						<P ALIGN=LEFT>THREAD_PRIORITY_LOWEST</P>
+					</TD>
+				</TR>
+				<TR>
+					<TD WIDTH=50 VALIGN=BOTTOM SDVAL="23" SDNUM="3081;">
+						<P ALIGN=CENTER>23</P>
+					</TD>
+					<TD WIDTH=356 VALIGN=TOP>
+						<P ALIGN=LEFT>REALTIME_PRIORITY_CLASS</P>
+					</TD>
+					<TD WIDTH=336 VALIGN=TOP>
+						<P ALIGN=LEFT>THREAD_PRIORITY_BELOW_NORMAL</P>
+					</TD>
+				</TR>
+				<TR>
+					<TD WIDTH=50 VALIGN=BOTTOM SDVAL="24" SDNUM="3081;">
+						<P ALIGN=CENTER>24</P>
+					</TD>
+					<TD WIDTH=356 VALIGN=TOP>
+						<P ALIGN=LEFT>REALTIME_PRIORITY_CLASS</P>
+					</TD>
+					<TD WIDTH=336 VALIGN=TOP>
+						<P ALIGN=LEFT>THREAD_PRIORITY_NORMAL</P>
+					</TD>
+				</TR>
+				<TR>
+					<TD WIDTH=50 VALIGN=BOTTOM SDVAL="25" SDNUM="3081;">
+						<P ALIGN=CENTER>25</P>
+					</TD>
+					<TD WIDTH=356 VALIGN=TOP>
+						<P ALIGN=LEFT>REALTIME_PRIORITY_CLASS</P>
+					</TD>
+					<TD WIDTH=336 VALIGN=TOP>
+						<P ALIGN=LEFT>THREAD_PRIORITY_ABOVE_NORMAL</P>
+					</TD>
+				</TR>
+				<TR>
+					<TD WIDTH=50 VALIGN=BOTTOM SDVAL="26" SDNUM="3081;">
+						<P ALIGN=CENTER>26</P>
+					</TD>
+					<TD WIDTH=356 VALIGN=TOP>
+						<P ALIGN=LEFT>REALTIME_PRIORITY_CLASS</P>
+					</TD>
+					<TD WIDTH=336 VALIGN=TOP>
+						<P ALIGN=LEFT>THREAD_PRIORITY_HIGHEST</P>
+					</TD>
+				</TR>
+				<TR>
+					<TD WIDTH=50 VALIGN=BOTTOM SDVAL="27" SDNUM="3081;">
+						<P ALIGN=CENTER>27</P>
+					</TD>
+					<TD WIDTH=356 VALIGN=TOP>
+						<P ALIGN=LEFT>REALTIME_PRIORITY_CLASS</P>
+					</TD>
+					<TD WIDTH=336 VALIGN=BOTTOM SDVAL="3" SDNUM="3081;">
+						<P ALIGN=LEFT>3</P>
+					</TD>
+				</TR>
+				<TR>
+					<TD WIDTH=50 VALIGN=BOTTOM SDVAL="28" SDNUM="3081;">
+						<P ALIGN=CENTER>28</P>
+					</TD>
+					<TD WIDTH=356 VALIGN=TOP>
+						<P ALIGN=LEFT>REALTIME_PRIORITY_CLASS</P>
+					</TD>
+					<TD WIDTH=336 VALIGN=BOTTOM SDVAL="4" SDNUM="3081;">
+						<P ALIGN=LEFT>4</P>
+					</TD>
+				</TR>
+				<TR>
+					<TD WIDTH=50 VALIGN=BOTTOM SDVAL="29" SDNUM="3081;">
+						<P ALIGN=CENTER>29</P>
+					</TD>
+					<TD WIDTH=356 VALIGN=TOP>
+						<P ALIGN=LEFT>REALTIME_PRIORITY_CLASS</P>
+					</TD>
+					<TD WIDTH=336 VALIGN=BOTTOM SDVAL="5" SDNUM="3081;">
+						<P ALIGN=LEFT>5</P>
+					</TD>
+				</TR>
+				<TR>
+					<TD WIDTH=50 VALIGN=BOTTOM SDVAL="30" SDNUM="3081;">
+						<P ALIGN=CENTER>30</P>
+					</TD>
+					<TD WIDTH=356 VALIGN=TOP>
+						<P ALIGN=LEFT>REALTIME_PRIORITY_CLASS</P>
+					</TD>
+					<TD WIDTH=336 VALIGN=BOTTOM SDVAL="6" SDNUM="3081;">
+						<P ALIGN=LEFT>6</P>
+					</TD>
+				</TR>
+				<TR>
+					<TD WIDTH=50 VALIGN=BOTTOM SDVAL="31" SDNUM="3081;">
+						<P ALIGN=CENTER>31</P>
+					</TD>
+					<TD WIDTH=356 VALIGN=TOP>
+						<P ALIGN=LEFT>REALTIME_PRIORITY_CLASS</P>
+					</TD>
+					<TD WIDTH=336 VALIGN=TOP>
+						<P ALIGN=LEFT>THREAD_PRIORITY_TIME_CRITICAL</P>
+					</TD>
+				</TR>
+			</TBODY>
+		</TABLE>
+</DL>
+<P STYLE="margin-left: 2cm">Windows NT: Values -7, -6, -5, -4, -3, 3,
+4, 5, and 6 are not supported.</P>
+<P STYLE="margin-left: 2cm">As you can see, the real priority levels
+available to any individual Win32 thread are non-contiguous.</P>
+<P STYLE="margin-left: 2cm">An application using PThreads4W should
+not make assumptions about the numbers used to represent thread
+priority levels, except that they are monotonic between the values
+returned by sched_get_priority_min() and sched_get_priority_max().
+E.g. Windows 95, 98, NT, 2000, XP make available a non-contiguous
+range of numbers between -15 and 15, while at least one version of
+WinCE (3.0) defines the minimum priority (THREAD_PRIORITY_LOWEST) as
+5, and the maximum priority (THREAD_PRIORITY_HIGHEST) as 1.</P>
+<P STYLE="margin-left: 2cm">Internally, PThreads4W maps any
+priority levels between THREAD_PRIORITY_IDLE and
+THREAD_PRIORITY_LOWEST to THREAD_PRIORITY_LOWEST, or between
+THREAD_PRIORITY_TIME_CRITICAL and THREAD_PRIORITY_HIGHEST to
+THREAD_PRIORITY_HIGHEST. Currently, this also applies to
+REALTIME_PRIORITY_CLASS even if levels -7, -6, -5, -4, -3, 3, 4, 5,
+and 6 are supported.</P>
+<P STYLE="margin-left: 2cm">If it wishes, a Win32 application using
+PThreads4W can use the Win32 defined priority macros
+THREAD_PRIORITY_IDLE through THREAD_PRIORITY_TIME_CRITICAL.</P>
+<H2 CLASS="western"><A HREF="#toc3" NAME="sect3">Author</A></H2>
+<P>Ross Johnson for use with <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A>.</P>
+<H2 CLASS="western"><A HREF="#toc4" NAME="sect4">See also</A></H2>
+<P><BR><BR>
+</P>
+<HR>
+<P><A NAME="toc"></A><B>Table of Contents</B></P>
+<UL>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Author</A>
+		</P>
+	<LI><P><A HREF="#sect4" NAME="toc4">See also</A> 
+	</P>
+</UL>
+</BODY>
+</HTML>
\ No newline at end of file
diff --git a/src/include/pthread/manual/cpu_set.html b/src/include/pthread/manual/cpu_set.html
new file mode 100644
index 0000000..15d3660
--- /dev/null
+++ b/src/include/pthread/manual/cpu_set.html
@@ -0,0 +1,115 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<TITLE>CPU_SET(3) manual page</TITLE>
+	<STYLE TYPE="text/css">
+	<!--
+		H4.cjk { font-family: "SimSun" }
+		H4.ctl { font-family: "Mangal" }
+		H2.cjk { font-family: "SimSun" }
+		H2.ctl { font-family: "Mangal" }
+	-->
+	</STYLE>
+</HEAD>
+<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
+<H4 CLASS="western"><FONT FACE="Times New Roman, serif"><FONT SIZE=3><SPAN STYLE="font-style: normal">POSIX
+Threads for Windows &ndash; REFERENCE - <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A></SPAN></FONT></FONT></H4>
+<P><A HREF="index.html">Reference Index</A></P>
+<P><A HREF="#toc">Table of Contents</A></P>
+<H2 CLASS="western"><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P>Operations on CPU affinity sets:</P>
+<P>CPU_EQUAL		- test equality of two sets</P>
+<P>CPU_ZERO		- clear all CPUs from set</P>
+<P>CPU_SET		- set a specified CPU in a set</P>
+<P>CPU_CLR		- unset a specified CPU in a set</P>
+<P>CPU_ISSET		- test if a specified CPU in a set is set</P>
+<P>CPU_COUNT		- return the number of CPUs currently set</P>
+<P>CPU_AND		- obtain the intersection of two sets</P>
+<P>CPU_OR		- obtain the union of two sets</P>
+<P>CPU_XOR		- obtain the mutually excluded set</P>
+<H2 CLASS="western"><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P><B>#include &lt;sched.h&gt; </B>
+</P>
+<P><B>int CPU_EQUAL(cpu_set_t * </B><I><SPAN STYLE="font-weight: normal">set1</SPAN></I><B>,
+cpu_set_t * </B><I><SPAN STYLE="font-weight: normal">set2</SPAN></I><B>);</B></P>
+<P><B>void CPU_ZERO(cpu_set_t * </B><I><SPAN STYLE="font-weight: normal">set</SPAN></I><B>);</B></P>
+<P><B>void CPU_SET(int </B><I><SPAN STYLE="font-weight: normal">cpu</SPAN></I><B>,
+cpu_set_t * </B><I><SPAN STYLE="font-weight: normal">set</SPAN></I><B>);</B></P>
+<P><B>void CPU_CLR(int </B><I><SPAN STYLE="font-weight: normal">cpu</SPAN></I><B>,
+cpu_set_t * </B><I><SPAN STYLE="font-weight: normal">set</SPAN></I><B>);</B></P>
+<P><B>int CPU_ISSET(int </B><I><SPAN STYLE="font-weight: normal">cpu</SPAN></I><B>,
+cpu_set_t * </B><I><SPAN STYLE="font-weight: normal">set</SPAN></I><B>);</B></P>
+<P><B>int CPU_COUNT(cpu_set_t * </B><I><SPAN STYLE="font-weight: normal">set</SPAN></I><B>);</B></P>
+<P><B>void CPU_AND(cpu_set_t * </B><I><SPAN STYLE="font-weight: normal">destset</SPAN></I><B>,
+cpu_set_t * </B><I><SPAN STYLE="font-weight: normal">srcset1</SPAN></I><B>,
+cpu_set_t * </B><I><SPAN STYLE="font-weight: normal">srcset2</SPAN></I><B>);</B></P>
+<P><B>void CPU_OR(cpu_set_t * </B><I><SPAN STYLE="font-weight: normal">destset</SPAN></I><B>,
+cpu_set_t * </B><I><SPAN STYLE="font-weight: normal">srcset1</SPAN></I><B>,
+cpu_set_t * </B><I><SPAN STYLE="font-weight: normal">srcset2</SPAN></I><B>);</B></P>
+<P><B>void CPU_XOR(cpu_set_t * </B><I><SPAN STYLE="font-weight: normal">destset</SPAN></I><B>,
+cpu_set_t * </B><I><SPAN STYLE="font-weight: normal">srcset1</SPAN></I><B>,
+cpu_set_t * </B><I><SPAN STYLE="font-weight: normal">srcset2</SPAN></I><B>);</B></P>
+<H2 CLASS="western"><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P>The cpu_set_t data structure represents a set of CPUs. CPU sets
+are used by <A HREF="sched_setaffinity.html"><B>sched_setaffinity</B>()</A>
+and <A HREF="pthread_setaffinity_np.html"><B>pthread_setaffinity_np</B>()</A>,
+etc.</P>
+<P>The cpu_set_t data type is implemented as a bitset. However, the
+data structure is considered opaque: all manipulation of CPU sets
+should be done via the macros described in this page.</P>
+<P>The following macros are provided to operate on the CPU set set:</P>
+<P><B>CPU_ZERO</B>		Clears <I>set</I>, so that it contains no CPUs.</P>
+<P><B>CPU_SET</B>		Add CPU cpu to <I>set</I>.</P>
+<P><B>CPU_CLR</B>		Remove CPU cpu from <I>set</I>.</P>
+<P><B>CPU_ISSET</B>		Test to see if CPU cpu is a member of <I>set</I>.</P>
+<P><B>CPU_COUNT</B>	Return the number of CPUs in <I>set</I>.</P>
+<P>Where a <I>cpu</I> argument is specified, it should not produce
+side effects, since the above macros may evaluate the argument more
+than once.</P>
+<P>The first available CPU on the system corresponds to a cpu value
+of 0, the next CPU corresponds to a cpu value of 1, and so on.</P>
+<P>The following macros perform logical operations on CPU sets:</P>
+<P><B>CPU_AND</B>		Store the intersection of the sets <I>srcset1</I>
+and <I>srcset2</I> in <I>destset</I> (which may be one of the source
+sets).</P>
+<P><B>CPU_OR</B>		Store the union of the sets  <I>srcset1</I>  and 
+<I>srcset2</I>  in <I>destset</I> (which may be one of the source
+sets).</P>
+<P><B>CPU_XOR</B>		Store the XOR of the sets <I>srcset1</I> and
+<I>srcset2</I> in <I>destset</I> (which may be one of the source
+sets).   The  XOR means the set of CPUs that are in either srcset1 or
+srcset2, but not both.</P>
+<P><B>CPU_EQUAL</B>		Test whether two CPU set contain exactly the
+same CPUs.</P>
+<H2 CLASS="western"><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
+<P>These macros either return a value consistent with the operation
+or nothing.</P>
+<H2 CLASS="western"><A HREF="#toc4" NAME="sect4">Errors</A></H2>
+<P>These macros do not return an error status.</P>
+<H2 CLASS="western"><A HREF="#toc6" NAME="sect6">See Also</A></H2>
+<P><A HREF="sched_setaffinity.html"><B>sched_getaffinity(3)</B></A> ,
+<A HREF="sched_setaffinity.html"><B>sched_setaffinity(3)</B></A><SPAN STYLE="font-weight: normal">
+, </SPAN><A HREF="pthread_setaffinity_np.html"><B>pthread_setaffininty_np</B>(3)</A>
+, <A HREF="pthread_setaffinity_np.html"><B>pthread_getaffinity_np</B>(3)</A>
+.</P>
+<HR>
+<P><A NAME="toc"></A><B>Table of Contents</B></P>
+<UL>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
+	Value</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">See
+	Also</A></P>
+</UL>
+<H4 CLASS="western"><BR><BR>
+</H4>
+</BODY>
+</HTML>
\ No newline at end of file
diff --git a/src/include/pthread/manual/index.html b/src/include/pthread/manual/index.html
new file mode 100644
index 0000000..36828a5
--- /dev/null
+++ b/src/include/pthread/manual/index.html
@@ -0,0 +1,175 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=windows-1252">
+	<TITLE></TITLE>
+	<META NAME="GENERATOR" CONTENT="OpenOffice 4.1.1  (Win32)">
+	<META NAME="CREATED" CONTENT="20050504;17350500">
+	<META NAME="CHANGEDBY" CONTENT="Ross Johnson">
+	<META NAME="CHANGED" CONTENT="20160330;18090089">
+	<STYLE TYPE="text/css">
+	<!--
+		H3.cjk { font-family: "AR PL UMing CN" }
+		H3.ctl { font-family: "Lohit Devanagari" }
+		H4.cjk { font-family: "AR PL UMing CN" }
+		H4.ctl { font-family: "Lohit Devanagari" }
+		H2.cjk { font-family: "AR PL UMing CN" }
+		H2.ctl { font-family: "Lohit Devanagari" }
+	-->
+	</STYLE>
+</HEAD>
+<BODY LANG="en-GB" DIR="LTR">
+<H4 CLASS="western">POSIX Threads for Windows &ndash; REFERENCE -
+<A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A></H4>
+<H3 CLASS="western">Table of Contents</H3>
+<P><A HREF="#sect1" NAME="toc1">POSIX threads API
+reference</A><BR><A HREF="#sect2" NAME="toc2">Miscellaneous POSIX
+thread safe routines provided by PThreads4W</A><BR><A HREF="#sect3" NAME="toc3">Non-portable
+PThreads4W routines</A><BR><A HREF="#sect4" NAME="toc4">Other</A></P>
+<H2 CLASS="western"><A HREF="#toc1" NAME="sect1">POSIX threads API
+reference</A></H2>
+<P><A HREF="cpu_set.html"><B>cpu_set</B></A></P>
+<P><A HREF="pthread_attr_init.html"><B>pthread_attr_destroy</B></A></P>
+<P><A HREF="pthread_attr_init.html"><B>pthread_attr_getdetachstate</B></A></P>
+<P><A HREF="pthread_attr_init.html"><B>pthread_attr_getinheritsched</B></A></P>
+<P><A HREF="pthread_attr_init.html"><B>pthread_attr_getname_np</B></A></P>
+<P><A HREF="pthread_attr_init.html"><B>pthread_attr_getschedparam</B></A></P>
+<P><A HREF="pthread_attr_init.html"><B>pthread_attr_getschedpolicy</B></A></P>
+<P><A HREF="pthread_attr_init.html"><B>pthread_attr_getscope</B></A></P>
+<P><A HREF="pthread_attr_setstackaddr.html"><B>pthread_attr_getstackaddr</B></A></P>
+<P><A HREF="pthread_attr_setstacksize.html"><B>pthread_attr_getstacksize</B></A></P>
+<P><A HREF="pthread_attr_init.html"><B>pthread_attr_init</B></A></P>
+<P><A HREF="pthread_attr_init.html"><B>pthread_attr_getaffinity_np</B></A></P>
+<P><A HREF="pthread_attr_init.html"><B>pthread_attr_setdetachstate</B></A></P>
+<P><A HREF="pthread_attr_init.html"><B>pthread_attr_setinheritsched</B></A></P>
+<P><A HREF="pthread_attr_init.html"><B>pthread_attr_setname_np</B></A></P>
+<P><A HREF="pthread_attr_init.html"><B>pthread_attr_setschedparam</B></A></P>
+<P><A HREF="pthread_attr_init.html"><B>pthread_attr_setschedpolicy</B></A></P>
+<P><A HREF="pthread_attr_init.html"><B>pthread_attr_setscope</B></A></P>
+<P><A HREF="pthread_attr_setstackaddr.html"><B>pthread_attr_setstackaddr</B></A></P>
+<P><A HREF="pthread_attr_setstacksize.html"><B>pthread_attr_setstacksize</B></A></P>
+<P><A HREF="pthread_barrierattr_init.html"><B>pthread_barrierattr_destroy</B></A></P>
+<P><A HREF="pthread_barrierattr_setpshared.html"><B>pthread_barrierattr_getpshared</B></A></P>
+<P><A HREF="pthread_barrierattr_init.html"><B>pthread_barrierattr_init</B></A></P>
+<P><A HREF="pthread_barrierattr_setpshared.html"><B>pthread_barrierattr_setpshared</B></A></P>
+<P><A HREF="pthread_barrier_init.html"><B>pthread_barrier_destroy</B></A></P>
+<P><A HREF="pthread_barrier_init.html"><B>pthread_barrier_init</B></A></P>
+<P><A HREF="pthread_barrier_wait.html"><B>pthread_barrier_wait</B></A></P>
+<P><A HREF="pthread_cancel.html"><B>pthread_cancel</B></A></P>
+<P><A HREF="pthread_cleanup_push.html"><B>pthread_cleanup_pop</B></A></P>
+<P><A HREF="pthread_cleanup_push.html"><B>pthread_cleanup_push</B></A></P>
+<P><A HREF="pthread_condattr_init.html"><B>pthread_condattr_destroy</B></A></P>
+<P><A HREF="pthread_condattr_setpshared.html"><B>pthread_condattr_getpshared</B></A></P>
+<P><A HREF="pthread_condattr_init.html"><B>pthread_condattr_init</B></A></P>
+<P><A HREF="pthread_condattr_setpshared.html"><B>pthread_condattr_setpshared</B></A></P>
+<P><A HREF="pthread_cond_init.html"><B>pthread_cond_broadcast</B></A></P>
+<P><A HREF="pthread_cond_init.html"><B>pthread_cond_destroy</B></A></P>
+<P><A HREF="pthread_cond_init.html"><B>pthread_cond_init</B></A></P>
+<P><A HREF="pthread_cond_init.html"><B>pthread_cond_signal</B></A></P>
+<P><A HREF="pthread_cond_init.html"><B>pthread_cond_timedwait</B></A></P>
+<P><A HREF="pthread_cond_init.html"><B>pthread_cond_wait</B></A></P>
+<P><A HREF="pthread_create.html"><B>pthread_create</B></A></P>
+<P><A HREF="pthread_detach.html"><B>pthread_detach</B></A></P>
+<P><A HREF="pthread_equal.html"><B>pthread_equal</B></A></P>
+<P><A HREF="pthread_exit.html"><B>pthread_exit</B></A></P>
+<P><A HREF="pthread_setconcurrency.html"><B>pthread_getconcurrency</B></A></P>
+<P><A HREF="pthread_setname_np.html"><B>pthread_getname_np</B></A></P>
+<P><A HREF="pthread_setschedparam.html"><B>pthread_getschedparam</B></A></P>
+<P><A HREF="pthread_getunique_np.html"><B>pthread_getunique_np</B></A></P>
+<P><A HREF="pthread_key_create.html"><B>pthread_getspecific</B></A></P>
+<P><A HREF="pthread_join.html"><B>pthread_join</B></A></P>
+<P><A HREF="pthread_join.html"><B>pthread_timedjoin_np</B></A></P>
+<P><A HREF="pthread_join.html"><B>pthread_tryjoin_np</B></A></P>
+<P><A HREF="pthread_key_create.html"><B>pthread_key_create</B></A></P>
+<P><A HREF="pthread_key_create.html"><B>pthread_key_delete</B></A></P>
+<P><A HREF="pthread_kill.html"><B>pthread_kill</B></A></P>
+<P><A HREF="pthread_mutexattr_init.html"><B>pthread_mutexattr_destroy</B></A></P>
+<P><A HREF="pthread_mutexattr_init.html"><B>pthread_mutexattr_getkind_np</B></A></P>
+<P><A HREF="pthread_mutexattr_setpshared.html"><B>pthread_mutexattr_getpshared</B></A></P>
+<P><A HREF="pthread_mutexattr_init.html"><B>pthread_mutexattr_getrobust</B></A></P>
+<P><A HREF="pthread_mutexattr_init.html"><B>pthread_mutexattr_gettype</B></A></P>
+<P><A HREF="pthread_mutexattr_init.html"><B>pthread_mutexattr_init</B></A></P>
+<P><A HREF="pthread_mutexattr_init.html"><B>pthread_mutexattr_setkind_np</B></A></P>
+<P><A HREF="pthread_mutexattr_setpshared.html"><B>pthread_mutexattr_setpshared</B></A></P>
+<P><A HREF="pthread_mutexattr_init.html"><B>pthread_mutexattr_setrobust</B></A></P>
+<P><A HREF="pthread_mutexattr_init.html"><B>pthread_mutexattr_settype</B></A></P>
+<P><A HREF="pthread_mutex_init.html"><B>pthread_mutex_consistent</B></A></P>
+<P><A HREF="pthread_mutex_init.html"><B>pthread_mutex_destroy</B></A></P>
+<P><A HREF="pthread_mutex_init.html"><B>pthread_mutex_init</B></A></P>
+<P><A HREF="pthread_mutex_init.html"><B>pthread_mutex_lock</B></A></P>
+<P><A HREF="pthread_mutex_init.html"><B>pthread_mutex_timedlock</B></A></P>
+<P><A HREF="pthread_mutex_init.html"><B>pthread_mutex_trylock</B></A></P>
+<P><A HREF="pthread_mutex_init.html"><B>pthread_mutex_unlock</B></A></P>
+<P><A HREF="pthread_once.html"><B>pthread_once</B></A></P>
+<P><A HREF="pthread_rwlockattr_init.html"><B>pthread_rwlockattr_destroy</B></A></P>
+<P><A HREF="pthread_rwlockattr_setpshared.html"><B>pthread_rwlockattr_getpshared</B></A></P>
+<P><A HREF="pthread_rwlockattr_init.html"><B>pthread_rwlockattr_init</B></A></P>
+<P><A HREF="pthread_rwlockattr_setpshared.html"><B>pthread_rwlockattr_setpshared</B></A></P>
+<P><A HREF="pthread_rwlock_init.html"><B>pthread_rwlock_destroy</B></A></P>
+<P><A HREF="pthread_rwlock_init.html"><B>pthread_rwlock_init</B></A></P>
+<P><A HREF="pthread_rwlock_rdlock.html"><B>pthread_rwlock_rdlock</B></A></P>
+<P><A HREF="pthread_rwlock_timedrdlock.html"><B>pthread_rwlock_timedrdlock</B></A></P>
+<P><A HREF="pthread_rwlock_timedwrlock.html"><B>pthread_rwlock_timedwrlock</B></A></P>
+<P><A HREF="pthread_rwlock_rdlock.html"><B>pthread_rwlock_tryrdlock</B></A></P>
+<P><A HREF="pthread_rwlock_wrlock.html"><B>pthread_rwlock_trywrlock</B></A></P>
+<P><A HREF="pthread_rwlock_unlock.html"><B>pthread_rwlock_unlock</B></A></P>
+<P><A HREF="pthread_rwlock_wrlock.html"><B>pthread_rwlock_wrlock</B></A></P>
+<P><A HREF="pthread_self.html"><B>pthread_self</B></A></P>
+<P><A HREF="pthread_cancel.html"><B>pthread_setcancelstate</B></A></P>
+<P><A HREF="pthread_cancel.html"><B>pthread_setcanceltype</B></A></P>
+<P><A HREF="pthread_setconcurrency.html"><B>pthread_setconcurrency</B></A></P>
+<P><A HREF="pthread_setname_np.html"><B>pthread_setname_np</B></A></P>
+<P><A HREF="pthread_setschedparam.html"><B>pthread_setschedparam</B></A></P>
+<P><A HREF="pthread_key_create.html"><B>pthread_setspecific</B></A></P>
+<P><A HREF="pthread_kill.html"><B>pthread_sigmask</B></A></P>
+<P><A HREF="pthread_spin_init.html"><B>pthread_spin_destroy</B></A></P>
+<P><A HREF="pthread_spin_init.html"><B>pthread_spin_init</B></A></P>
+<P><A HREF="pthread_spin_lock.html"><B>pthread_spin_lock</B></A></P>
+<P><A HREF="pthread_spin_lock.html"><B>pthread_spin_trylock</B></A></P>
+<P><A HREF="pthread_spin_unlock.html"><B>pthread_spin_unlock</B></A></P>
+<P><A HREF="pthread_cancel.html"><B>pthread_testcancel</B></A></P>
+<P><A HREF="sched_get_priority_max.html"><B>sched_get_priority_max</B></A></P>
+<P><A HREF="sched_get_priority_max.html"><B>sched_get_priority_min</B></A></P>
+<P><A HREF="sched_setaffinity.html"><B>sched_getaffinity</B></A></P>
+<P><A HREF="sched_getscheduler.html"><B>sched_getscheduler</B></A></P>
+<P><A HREF="sched_setaffinity.html"><B>sched_setaffinity</B></A></P>
+<P><A HREF="sched_setscheduler.html"><B>sched_setscheduler</B></A></P>
+<P><A HREF="sched_yield.html"><B>sched_yield</B></A></P>
+<P><B>sem_close</B></P>
+<P><A HREF="sem_init.html"><B>sem_destroy</B></A></P>
+<P><A HREF="sem_init.html"><B>sem_getvalue</B></A></P>
+<P><A HREF="sem_init.html"><B>sem_init</B></A></P>
+<P><B>sem_open</B></P>
+<P><A HREF="sem_init.html"><B>sem_post</B></A></P>
+<P><A HREF="sem_init.html"><B>sem_post_multiple</B></A></P>
+<P><A HREF="sem_init.html"><B>sem_timedwait</B></A></P>
+<P><A HREF="sem_init.html"><B>sem_trywait</B></A></P>
+<P><B>sem_unlink</B></P>
+<P><A HREF="sem_init.html"><B>sem_wait</B></A></P>
+<P><A HREF="pthread_kill.html"><B>sigwait</B></A></P>
+<H2 CLASS="western"><A HREF="#toc3" NAME="sect3">Non-portable
+PThreads4W routines</A></H2>
+<P><A HREF="pthreadCancelableWait.html"><B>pthreadCancelableTimedWait</B></A></P>
+<P><A HREF="pthreadCancelableWait.html"><B>pthreadCancelableWait</B></A></P>
+<P><A HREF="pthread_attr_init.html"><B>pthread_attr_getaffinity_np</B></A></P>
+<P><A HREF="pthread_attr_init.html"><B>pthread_attr_setaffinity_np</B></A></P>
+<P><A HREF="pthread_setaffinity_np.html"><B>pthread_getaffinity_np</B></A></P>
+<P><A HREF="pthread_setaffinity_np.html"><B>pthread_setaffinity_np</B></A></P>
+<P><A HREF="pthread_delay_np.html"><B>pthread_delay_np</B></A></P>
+<P><A HREF="pthread_setname_np.html"><B>pthread_getname_np</B></A></P>
+<P><A HREF="pthread_getunique_np.html"><B>pthread_getunique_np</B></A></P>
+<P><A HREF="pthread_getw32threadhandle_np.html"><B>pthread_getw32threadhandle_np</B></A></P>
+<P><A HREF="pthread_num_processors_np.html"><B>pthread_num_processors_np</B></A></P>
+<P><A HREF="pthread_setname_np.html"><B>pthread_setname_np</B></A></P>
+<P><A HREF="pthread_timechange_handler_np.html"><B>pthread_timechange_handler_np</B></A></P>
+<P><A HREF="pthread_join.html"><B>pthread_timedjoin_np</B></A></P>
+<P><A HREF="pthread_win32_getabstime_np.html"><B>pthread_win32_getabstime_np</B></A></P>
+<P><A HREF="pthread_win32_attach_detach_np.html"><B>pthread_win32_process_attach_np</B></A></P>
+<P><A HREF="pthread_win32_attach_detach_np.html"><B>pthread_win32_process_detach_np</B></A></P>
+<P><A HREF="pthread_win32_test_features_np.html"><B>pthread_win32_test_features_np</B></A></P>
+<P><A HREF="pthread_win32_attach_detach_np.html"><B>pthread_win32_thread_attach_np</B></A></P>
+<P><A HREF="pthread_win32_attach_detach_np.html"><B>pthread_win32_thread_detach_np</B></A></P>
+<H2 CLASS="western"><A HREF="#toc4" NAME="sect4">Other</A></H2>
+<P><A HREF="PortabilityIssues.html"><B>Portability issues</B></A></P>
+</BODY>
+</HTML>
\ No newline at end of file
diff --git a/src/include/pthread/manual/pthreadCancelableWait.html b/src/include/pthread/manual/pthreadCancelableWait.html
new file mode 100644
index 0000000..bd3108b
--- /dev/null
+++ b/src/include/pthread/manual/pthreadCancelableWait.html
@@ -0,0 +1,93 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=windows-1252">
+	<TITLE>PTHREADCANCELLABLEWAIT(3) manual page</TITLE>
+	<META NAME="GENERATOR" CONTENT="OpenOffice 4.1.1  (Win32)">
+	<META NAME="CREATED" CONTENT="0;0">
+	<META NAME="CHANGEDBY" CONTENT="Ross Johnson">
+	<META NAME="CHANGED" CONTENT="20160229;19515927">
+	<STYLE TYPE="text/css">
+	<!--
+		H4.cjk { font-family: "SimSun" }
+		H4.ctl { font-family: "Mangal" }
+		H2.cjk { font-family: "SimSun" }
+		H2.ctl { font-family: "Mangal" }
+	-->
+	</STYLE>
+</HEAD>
+<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
+<H4 CLASS="western">POSIX Threads for Windows &ndash; REFERENCE &ndash;
+<A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A></H4>
+<P><A HREF="index.html">Reference Index</A></P>
+<P><A HREF="#toc">Table of Contents</A></P>
+<H2 CLASS="western"><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P STYLE="font-weight: normal">pthreadCancelableTimedWait,
+pthreadCancelableWait &ndash; provide cancellation hooks for user
+Win32 routines</P>
+<H2 CLASS="western"><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P><B>#include &lt;pthread.h&gt;</B> 
+</P>
+<P><B>int pthreadCancelableTimedWait (HANDLE </B><I>waitHandle</I><B>,
+DWORD </B><I>timeout</I><B>);</B></P>
+<P><B>int pthreadCancelableWait (HANDLE </B><I>waitHandle</I><B>);</B></P>
+<H2 CLASS="western"><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P>These two functions provide hooks into the <A HREF="pthread_cancel.html"><B>pthread_cancel</B></A>()
+mechanism that will allow you to wait on a Windows handle and make it
+a cancellation point. Both functions block until either the given
+Win32 <B>HANDLE</B> is signalled, or <A HREF="pthread_cancel.html"><B>pthread_cancel</B></A>()
+has been called. They are implemented using <B>WaitForMultipleObjects</B>
+on <I>waitHandle</I> and the manually reset Win32 event handle that
+is the target of <A HREF="pthread_cancel.html"><B>pthread_cancel</B></A>().
+These routines may be called from Win32 native threads but
+<A HREF="pthread_cancel.html"><B>pthread_cancel</B></A>() will
+require that thread's POSIX thread ID that the thread must retrieve
+using <A HREF="pthread_self.html"><B>pthread_self</B></A>().</P>
+<P><B>pthreadCancelableTimedWait</B> is the timed version that will
+return with the code <B>ETIMEDOUT</B> if the interval <I>timeout</I>
+milliseconds elapses before <I>waitHandle</I> is signalled.</P>
+<H2 CLASS="western"><A HREF="#toc3" NAME="sect3">Cancellation</A></H2>
+<P>These routines allow routines that block on Win32 HANDLEs to be
+cancellable via <A HREF="pthread_cancel.html"><B>pthread_cancel</B></A>().</P>
+<H2 CLASS="western"><A HREF="#toc4" NAME="sect4">Return Value</A></H2>
+<P><BR><BR>
+</P>
+<H2 CLASS="western"><A HREF="#toc5" NAME="sect5">Errors</A></H2>
+<P>The <B>pthreadCancelableTimedWait</B> function returns the
+following error code on error: 
+</P>
+<DL>
+		<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>ETIMEDOUT</B>
+				</DT>
+</DL>
+<P STYLE="margin-left: 2cm">
+The interval <I>timeout</I> milliseconds elapsed before <I>waitHandle</I>
+was signalled.</P>
+<H2 CLASS="western"><A HREF="#toc6" NAME="sect6">Author</A></H2>
+<P>Ross Johnson for use with <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A>.</P>
+<H2 CLASS="western"><A HREF="#toc7" NAME="sect7">See also</A></H2>
+<P><A HREF="pthread_cancel.html"><B>pthread_cancel()</B></A>,
+<A HREF="pthread_self.html"><B>pthread_self()</B></A></P>
+<HR>
+<P><A NAME="toc"></A><B>Table of Contents</B></P>
+<UL>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Cancellation</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Return
+	Value</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Errors</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Author</A>
+		</P>
+	<LI><P><A HREF="#sect7" NAME="toc7">See also</A> 
+	</P>
+</UL>
+</BODY>
+</HTML>
\ No newline at end of file
diff --git a/src/include/pthread/manual/pthread_attr_init.html b/src/include/pthread/manual/pthread_attr_init.html
new file mode 100644
index 0000000..79b2b0b
--- /dev/null
+++ b/src/include/pthread/manual/pthread_attr_init.html
@@ -0,0 +1,330 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=windows-1252">
+	<TITLE>PTHREAD_ATTR_INIT(3) manual page</TITLE>
+	<META NAME="GENERATOR" CONTENT="OpenOffice 4.1.1  (Win32)">
+	<META NAME="CREATED" CONTENT="0;0">
+	<META NAME="CHANGEDBY" CONTENT="Ross Johnson">
+	<META NAME="CHANGED" CONTENT="20160229;19521095">
+	<STYLE TYPE="text/css">
+	<!--
+		H3.cjk { font-family: "SimSun" }
+		H3.ctl { font-family: "Mangal" }
+		H4.cjk { font-family: "SimSun" }
+		H4.ctl { font-family: "Mangal" }
+		H2.cjk { font-family: "SimSun" }
+		H2.ctl { font-family: "Mangal" }
+	-->
+	</STYLE>
+</HEAD>
+<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
+<H4 CLASS="western">POSIX Threads for Windows &ndash; REFERENCE &ndash;
+<A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A></H4>
+<P><A HREF="index.html">Reference Index</A></P>
+<P><A HREF="#toc">Table of Contents</A></P>
+<H2 CLASS="western"><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P>pthread_attr_init, pthread_attr_destroy,
+pthread_attr_setaffinity_np, pthread_attr_setdetachstate,
+pthread_attr_getaffinity_np, pthread_attr_getdetachstate,
+pthread_attr_setschedparam, pthread_attr_getschedparam,
+pthread_attr_setschedpolicy, pthread_attr_getschedpolicy,
+pthread_attr_setinheritsched, pthread_attr_getinheritsched,
+pthread_attr_setscope, pthread_attr_getscope - thread creation
+attributes 
+</P>
+<H2 CLASS="western"><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P><B>#include &lt;pthread.h&gt;</B> 
+</P>
+<P><B>int pthread_attr_init(pthread_attr_t *</B><I>attr</I><B>);</B> 
+</P>
+<P><B>int pthread_attr_destroy(pthread_attr_t *</B><I>attr</I><B>);</B>
+</P>
+<P><B>int pthread_attr_setaffinity_np(pthread_attr_t *</B><I>attr</I><B>,
+size_t </B><SPAN STYLE="font-style: normal"><SPAN STYLE="font-weight: normal">cpusetsize,
+</SPAN></SPAN><SPAN STYLE="font-style: normal"><B>cpu_set_t </B></SPAN><SPAN STYLE="font-style: normal"><SPAN STYLE="font-weight: normal">*
+</SPAN></SPAN><I><SPAN STYLE="font-weight: normal">cpuset</SPAN></I><SPAN STYLE="font-style: normal"><SPAN STYLE="font-weight: normal">);</SPAN></SPAN>
+</P>
+<P><B>int pthread_attr_getaffinity_np(const pthread_attr_t *</B><I>attr</I><B>,
+size_t </B><SPAN STYLE="font-style: normal"><SPAN STYLE="font-weight: normal">cpusetsize,
+</SPAN></SPAN><SPAN STYLE="font-style: normal"><B>cpu_set_t </B></SPAN><SPAN STYLE="font-style: normal"><SPAN STYLE="font-weight: normal">*
+</SPAN></SPAN><I><SPAN STYLE="font-weight: normal">cpuset</SPAN></I><SPAN STYLE="font-style: normal"><SPAN STYLE="font-weight: normal">);</SPAN></SPAN>
+</P>
+<P><B>int pthread_attr_setdetachstate(pthread_attr_t *</B><I>attr</I><B>,
+int </B><I>detachstate</I><B>);</B> 
+</P>
+<P><B>int pthread_attr_getdetachstate(const pthread_attr_t *</B><I>attr</I><B>,
+int *</B><I>detachstate</I><B>);</B> 
+</P>
+<P><B>int pthread_attr_setname_np(const pthread_attr_t *</B><I>attr</I><B>,
+const char * </B><I><SPAN STYLE="font-weight: normal">name</SPAN></I><B>,</B>
+<B>void</B> <B>*</B> <I><SPAN STYLE="font-weight: normal">arg</SPAN></I><B>);</B></P>
+<P><B>int pthread_attr_getname_np(const pthread_attr_t *</B><I>attr</I><B>,
+char * </B><I><SPAN STYLE="font-weight: normal">name</SPAN></I><B>,</B>
+<I><B>int </B></I><I><SPAN STYLE="font-weight: normal">len</SPAN></I><B>);</B></P>
+<P><B>int pthread_attr_setschedpolicy(pthread_attr_t *</B><I>attr</I><B>,
+int </B><I>policy</I><B>);</B> 
+</P>
+<P><B>int pthread_attr_getschedpolicy(const pthread_attr_t *</B><I>attr</I><B>,
+int *</B><I>policy</I><B>);</B> 
+</P>
+<P><B>int pthread_attr_setschedparam(pthread_attr_t *</B><I>attr</I><B>,
+const struct sched_param *</B><I>param</I><B>);</B> 
+</P>
+<P><B>int pthread_attr_getschedparam(const pthread_attr_t *</B><I>attr</I><B>,
+struct sched_param *</B><I>param</I><B>);</B> 
+</P>
+<P><B>int pthread_attr_setinheritsched(pthread_attr_t *</B><I>attr</I><B>,
+int </B><I>inherit</I><B>);</B> 
+</P>
+<P><B>int pthread_attr_getinheritsched(const pthread_attr_t *</B><I>attr</I><B>,
+int *</B><I>inherit</I><B>);</B> 
+</P>
+<P><B>int pthread_attr_setscope(pthread_attr_t *</B><I>attr</I><B>,
+int </B><I>scope</I><B>);</B> 
+</P>
+<P><B>int pthread_attr_getscope(const pthread_attr_t *</B><I>attr</I><B>,
+int *</B><I>scope</I><B>);</B> 
+</P>
+<H2 CLASS="western"><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P>Setting attributes for threads is achieved by filling a thread
+attribute object <I>attr</I> of type <B>pthread_attr_t</B>, then
+passing it as second argument to <A HREF="pthread_create.html"><B>pthread_create</B>(3)</A>
+. Passing <B>NULL</B> is equivalent to passing a thread attribute
+object with all attributes set to their default values. 
+</P>
+<P><B>pthread_attr_init</B> initializes the thread attribute object
+<I>attr</I> and fills it with default values for the attributes. (The
+default values are listed below for each attribute.) 
+</P>
+<P>Each attribute <I>attrname</I> (see below for a list of all
+attributes) can be individually set using the function
+<B>pthread_attr_set</B><I>attrname</I> and retrieved using the
+function <B>pthread_attr_get</B><I>attrname.</I> 
+</P>
+<P><B>pthread_attr_destroy</B> destroys a thread attribute object,
+which must not then be reused until it is reinitialized. 
+</P>
+<P>Attribute objects are consulted only when creating a new thread.
+The same attribute object can be used for creating several threads.
+Modifying an attribute object after a call to <B>pthread_create</B>
+does not change the attributes of the thread previously created. 
+</P>
+<P>The following thread attributes are supported: 
+</P>
+<H3 CLASS="western"><A HREF="#toc201" NAME="sect201">affinity</A></H3>
+<P>Controls which CPUs the thread is eligible to run on. If not set
+then the thread will inherit the <I>cpuset</I> from it's parent
+[creator thread]. See also: <A HREF="pthread_setaffinity_np.html">pthread_setaffinity_np(3)</A>,
+<A HREF="pthread_getaffinity_np.html">pthread_getaffinity_np(3)</A>,
+<A HREF="sched_setaffinity.html">sched_setaffinity(3)</A>,
+<A HREF="sched_getaffinity.html">sched_getaffinity(3)</A>, <A HREF="cpu_set.html">cpu_set(3)</A></P>
+<H3 CLASS="western"><A HREF="#toc3" NAME="sect3">detachstate</A></H3>
+<P>Control whether the thread is created in the joinable state (value
+<B>PTHREAD_CREATE_JOINABLE</B>) or in the detached state (
+<B>PTHREAD_CREATE_DETACHED</B>). 
+</P>
+<P>Default value: <B>PTHREAD_CREATE_JOINABLE</B>. 
+</P>
+<P>In the joinable state, another thread can synchronize on the
+thread termination and recover its termination code using
+<A HREF="pthread_join.html"><B>pthread_join</B>(3)</A> . When a
+joinable thread terminates, some of the thread resources are kept
+allocated, and released only when another thread performs
+<A HREF="pthread_join.html"><B>pthread_join</B>(3)</A> on that
+thread. 
+</P>
+<P>In the detached state, the thread's resources are released
+immediately when it terminates. <A HREF="pthread_join.html"><B>pthread_join</B>(3)</A>
+cannot be used to synchronize on the thread termination. 
+</P>
+<P>A thread created in the joinable state can later be put in the
+detached thread using <A HREF="pthread_detach.html"><B>pthread_detach</B>(3)</A>
+. 
+</P>
+<H3 CLASS="western"><A HREF="#toc202" NAME="sect202">name</A></H3>
+<P>Give threads names to aid in tracing during debugging Threads do
+not have a default name. See also: <A HREF="pthread_setname_np.html">pthread_setname_np(3)</A>,
+<A HREF="pthread_setname_np.html">pthread_getname_np(3)</A>.</P>
+<H3 CLASS="western"><A HREF="#toc4" NAME="sect4">schedpolicy</A></H3>
+<P>Select the scheduling policy for the thread: one of <B>SCHED_OTHER</B>
+(regular, non-real-time scheduling), <B>SCHED_RR</B> (real-time,
+round-robin) or <B>SCHED_FIFO</B> (real-time, first-in first-out). 
+</P>
+<P><B>PThreads4W</B> only supports <B>SCHED_OTHER</B> - attempting
+to set one of the other policies will return an error ENOTSUP.</P>
+<P>Default value: <B>SCHED_OTHER</B>. 
+</P>
+<P><B>PThreads4W</B> only supports <B>SCHED_OTHER</B> - attempting
+to set one of the other policies will return an error ENOTSUP.</P>
+<P>The scheduling policy of a thread can be changed after creation
+with <A HREF="pthread_setschedparam.html"><B>pthread_setschedparam</B>(3)</A>
+. 
+</P>
+<H3 CLASS="western"><A HREF="#toc5" NAME="sect5">schedparam</A></H3>
+<P>Contain the scheduling parameters (essentially, the scheduling
+priority) for the thread.</P>
+<P><B>PThreads4W</B> supports the priority levels defined by the
+Windows system it is running on. Under Windows, thread priorities are
+relative to the process priority class, which must be set via the
+Windows W32 API.</P>
+<P>Default value: priority is 0 (Win32 level <B>THREAD_PRIORITY_NORMAL</B>).
+</P>
+<P>The scheduling priority of a thread can be changed after creation
+with <A HREF="pthread_setschedparam.html"><B>pthread_setschedparam</B>(3)</A>
+. 
+</P>
+<H3 CLASS="western"><A HREF="#toc6" NAME="sect6">inheritsched</A></H3>
+<P>Indicate whether the scheduling policy and scheduling parameters
+for the newly created thread are determined by the values of the
+<I>schedpolicy</I> and <I>schedparam</I> attributes (value
+<B>PTHREAD_EXPLICIT_SCHED</B>) or are inherited from the parent
+thread (value <B>PTHREAD_INHERIT_SCHED</B>). 
+</P>
+<P>Default value: <B>PTHREAD_EXPLICIT_SCHED</B>. 
+</P>
+<H3 CLASS="western"><A HREF="#toc7" NAME="sect7">scope</A></H3>
+<P>Define the scheduling contention scope for the created thread. The
+only value supported in the <B>PThreads4W</B> implementation is
+<B>PTHREAD_SCOPE_SYSTEM</B>, meaning that the threads contend for CPU
+time with all processes running on the machine. The other value
+specified by the standard, <B>PTHREAD_SCOPE_PROCESS</B>, means that
+scheduling contention occurs only between the threads of the running
+process.</P>
+<P><B>PThreads4W</B> only supports <B>PTHREAD_SCOPE_SYSTEM</B>.</P>
+<P>Default value: <B>PTHREAD_SCOPE_SYSTEM</B>. 
+</P>
+<H2 CLASS="western"><A HREF="#toc8" NAME="sect8">Return Value</A></H2>
+<P>All functions return 0 on success and a non-zero error code on
+error. On success, the <B>pthread_attr_get</B><I>attrname</I>
+functions also store the current value of the attribute <I>attrname</I>
+in the location pointed to by their second argument. 
+</P>
+<H2 CLASS="western"><A HREF="#toc9" NAME="sect9">Errors</A></H2>
+<P>The <B>pthread_attr_setaffinity</B> function returns the following
+error codes on error: 
+</P>
+<DL>
+		<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EINVAL</B></DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
+		one or both of the specified <I>attribute</I> or <I>cpuset</I>
+		argument is invalid.</DD>
+</DL>
+<P>
+The <B>pthread_attr_setdetachstate</B> function returns the following
+error codes on error: 
+</P>
+<DL>
+		<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EINVAL</B> 
+		</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
+		the specified <I>detachstate</I> is not one of
+		<B>PTHREAD_CREATE_JOINABLE</B> or <B>PTHREAD_CREATE_DETACHED</B>. 
+		</DD>
+</DL>
+<P>
+The <B>pthread_attr_setschedparam</B> function returns the following
+error codes on error: 
+</P>
+<DL>
+		<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EINVAL</B> 
+		</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
+		the priority specified in <I>param</I> is outside the range of
+		allowed priorities for the scheduling policy currently in <I>attr</I>
+		(1 to 99 for <B>SCHED_FIFO</B> and <B>SCHED_RR</B>; 0 for
+		<B>SCHED_OTHER</B>). 
+		</DD>
+</DL>
+<P>
+The <B>pthread_attr_setschedpolicy</B> function returns the following
+error codes on error: 
+</P>
+<DL>
+		<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EINVAL</B> 
+		</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
+		the specified <I>policy</I> is not one of <B>SCHED_OTHER</B>,
+		<B>SCHED_FIFO</B>, or <B>SCHED_RR</B>. 
+		</DD><DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
+		<B>ENOTSUP</B> 
+		</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
+		<I>policy</I> is not <B>SCHED_OTHER</B>, the only value supported
+		by <B>PThreads4W</B>.</DD>
+</DL>
+<P>
+The <B>pthread_attr_setinheritsched</B> function returns the
+following error codes on error: 
+</P>
+<DL>
+		<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EINVAL</B> 
+		</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
+		the specified <I>inherit</I> is not one of <B>PTHREAD_INHERIT_SCHED</B>
+		or <B>PTHREAD_EXPLICIT_SCHED</B>. 
+		</DD>
+</DL>
+<P>
+The <B>pthread_attr_setscope</B> function returns the following error
+codes on error: 
+</P>
+<DL>
+		<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EINVAL</B> 
+		</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
+		the specified <I>scope</I> is not one of <B>PTHREAD_SCOPE_SYSTEM</B>
+		or <B>PTHREAD_SCOPE_PROCESS</B>. 
+		</DD><DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
+		<B>ENOTSUP</B> 
+		</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
+		the specified <I>scope</I> is <B>PTHREAD_SCOPE_PROCESS</B> (not
+		supported by <B>PThreads4W</B>). 
+		</DD>
+</DL>
+<H2 CLASS="western">
+<A HREF="#toc10" NAME="sect10">Author</A></H2>
+<P>Xavier Leroy &lt;Xavier.Leroy@inria.fr&gt; 
+</P>
+<P>Modified by Ross Johnson for use with <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A>.</P>
+<H2 CLASS="western"><A HREF="#toc11" NAME="sect11">See Also</A></H2>
+<P><A HREF="pthread_create.html"><B>pthread_create</B>(3)</A> ,
+<A HREF="pthread_join.html"><B>pthread_join</B>(3)</A> ,
+<A HREF="pthread_detach.html"><B>pthread_detach</B>(3)</A> ,
+<A HREF="pthread_setname_np.html">pthread_setname_np(3)</A>,
+<A HREF="pthread_setname_np.html">pthread_getname_np(3)</A>,
+<A HREF="pthread_setschedparam.html"><B>pthread_setschedparam</B>(3)</A>
+, <A HREF="pthread_setaffinity_np.html">pthread_setaffinity_np(3)</A>
+, <A HREF="pthread_getaffinity_np.html">pthread_getaffinity_np(3)</A>
+, <A HREF="sched_setaffinity.html">sched_setaffinity(3)</A> ,
+<A HREF="sched_getaffinity.html">sched_getaffinity(3)</A> ,
+<A HREF="cpu_set.html">cpu_set(3)</A> . 
+</P>
+<HR>
+<P><A NAME="toc"></A><B>Table of Contents</B></P>
+<UL>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
+		</P>
+	<UL>
+		<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect201" NAME="toc201">affinity</A></P>
+		<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">detachstate</A>
+				</P>
+		<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect202" NAME="toc202">name</A></P>
+		<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">schedpolicy</A>
+				</P>
+		<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">schedparam</A>
+				</P>
+		<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">inheritsched</A>
+				</P>
+		<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">scope</A>
+				</P>
+	</UL>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect8" NAME="toc8">Return
+	Value</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect9" NAME="toc9">Errors</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect10" NAME="toc10">Author</A>
+		</P>
+	<LI><P><A HREF="#sect11" NAME="toc11">See Also</A> 
+	</P>
+</UL>
+</BODY>
+</HTML>
\ No newline at end of file
diff --git a/src/include/pthread/manual/pthread_attr_setstackaddr.html b/src/include/pthread/manual/pthread_attr_setstackaddr.html
new file mode 100644
index 0000000..44c9ea1
--- /dev/null
+++ b/src/include/pthread/manual/pthread_attr_setstackaddr.html
@@ -0,0 +1,164 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=windows-1252">
+	<TITLE>PTHREAD_ATTR_SETSTACKADDR(3) manual page</TITLE>
+	<META NAME="GENERATOR" CONTENT="OpenOffice 4.1.1  (Win32)">
+	<META NAME="CREATED" CONTENT="0;0">
+	<META NAME="CHANGEDBY" CONTENT="Ross Johnson">
+	<META NAME="CHANGED" CONTENT="20160229;19522374">
+	<STYLE TYPE="text/css">
+	<!--
+		H4.cjk { font-family: "SimSun" }
+		H4.ctl { font-family: "Mangal" }
+		H2.cjk { font-family: "SimSun" }
+		H2.ctl { font-family: "Mangal" }
+	-->
+	</STYLE>
+</HEAD>
+<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
+<H4 CLASS="western">POSIX Threads for Windows &ndash; REFERENCE &ndash;
+<A HREF="http://sourceforge.net/projects/pthreads4w/">PThreads4W</A></H4>
+<P><A HREF="index.html">Reference Index</A></P>
+<P><A HREF="#toc">Table of Contents</A></P>
+<H2 CLASS="western"><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P>pthread_attr_getstackaddr, pthread_attr_setstackaddr - get and set
+the stackaddr attribute 
+</P>
+<H2 CLASS="western"><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P><B>#include &lt;pthread.h&gt; </B>
+</P>
+<P><B>int pthread_attr_getstackaddr(const pthread_attr_t *restrict</B>
+<I>attr</I><B>, void **restrict</B> <I>stackaddr</I><B>); <BR>int
+pthread_attr_setstackaddr(pthread_attr_t *</B><I>attr</I><B>, void
+*</B><I>stackaddr</I><B>); </B>
+</P>
+<H2 CLASS="western"><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P>The <B>pthread_attr_getstackaddr</B> and <B>pthread_attr_setstackaddr</B>
+functions, respectively, shall get and set the thread creation
+<I>stackaddr</I> attribute in the <I>attr</I> object. 
+</P>
+<P>The <I>stackaddr</I> attribute specifies the location of storage
+to be used for the created thread&rsquo;s stack. The size of the
+storage shall be at least {PTHREAD_STACK_MIN}. 
+</P>
+<P><B>PThreads4W</B> defines <B>_POSIX_THREAD_ATTR_STACKADDR</B> in
+pthread.h as -1 to indicate that these routines are implemented but
+cannot used to set or get the stack address. These routines always
+return the error ENOSYS when called.</P>
+<H2 CLASS="western"><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
+<P>Upon successful completion, <B>pthread_attr_getstackaddr</B> and
+<B>pthread_attr_setstackaddr</B> shall return a value of 0;
+otherwise, an error number shall be returned to indicate the error. 
+</P>
+<P>The <B>pthread_attr_getstackaddr</B> function stores the <I>stackaddr</I>
+attribute value in <I>stackaddr</I> if successful. 
+</P>
+<H2 CLASS="western"><A HREF="#toc4" NAME="sect4">Errors</A></H2>
+<P>The <B>pthread_attr_setstackaddr</B> function always returns the
+following error code: 
+</P>
+<DL>
+		<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>ENOSYS</B></DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
+		The function is not supported. 
+		</DD>
+</DL>
+<P>
+The <B>pthread_attr_getstackaddr</B> function always returns the
+following error code: 
+</P>
+<DL>
+		<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>ENOSYS</B></DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
+		The function is not supported. 
+		</DD>
+</DL>
+<P>
+These functions shall not return an error code of [EINTR]. 
+</P>
+<P><I>The following sections are informative.</I> 
+</P>
+<H2 CLASS="western"><A HREF="#toc5" NAME="sect5">Examples</A></H2>
+<P>None. 
+</P>
+<H2 CLASS="western"><A HREF="#toc6" NAME="sect6">Application Usage</A></H2>
+<P>The specification of the <I>stackaddr</I> attribute presents
+several ambiguities that make portable use of these interfaces
+impossible. The description of the single address parameter as a
+&quot;stack&quot; does not specify a particular relationship between
+the address and the &quot;stack&quot; implied by that address. For
+example, the address may be taken as the low memory address of a
+buffer intended for use as a stack, or it may be taken as the address
+to be used as the initial stack pointer register value for the new
+thread. These two are not the same except for a machine on which the
+stack grows &quot;up&quot; from low memory to high, and on which a
+&quot;push&quot; operation first stores the value in memory and then
+increments the stack pointer register. Further, on a machine where
+the stack grows &quot;down&quot; from high memory to low,
+interpretation of the address as the &quot;low memory&quot; address
+requires a determination of the intended size of the stack.
+IEEE&nbsp;Std&nbsp;1003.1-2001 has introduced the new interfaces
+<A HREF="pthread_attr_setstack.html"><B>pthread_attr_setstack</B>(3)</A>
+and <A HREF="pthread_attr_getstack.html"><B>pthread_attr_getstack</B>(3)</A>
+to resolve these ambiguities. 
+</P>
+<H2 CLASS="western"><A HREF="#toc7" NAME="sect7">Rationale</A></H2>
+<P>None. 
+</P>
+<H2 CLASS="western"><A HREF="#toc8" NAME="sect8">Future Directions</A></H2>
+<P>None. 
+</P>
+<H2 CLASS="western"><A HREF="#toc9" NAME="sect9">See Also</A></H2>
+<P><A HREF="pthread_attr_init.html"><B>pthread_attr_destroy</B>(3)</A>
+, <A HREF="pthread_attr_init.html"><B>pthread_attr_getdetachstate</B>(3)</A>
+, <A HREF="pthread_attr_getstack.html"><B>pthread_attr_getstack</B>(3)</A>
+, <A HREF="pthread_attr_getstacksize.html"><B>pthread_attr_getstacksize</B>(3)</A>
+, <A HREF="pthread_attr_setstack.html"><B>pthread_attr_setstack</B>(3)</A>
+, <A HREF="pthread_create.html"><B>pthread_create</B>(3)</A> , the
+Base Definitions volume of IEEE&nbsp;Std&nbsp;1003.1-2001,
+<I>&lt;limits.h&gt;</I>, <I>&lt;pthread.h&gt;</I> 
+</P>
+<H2 CLASS="western"><A HREF="#toc10" NAME="sect10">Copyright</A></H2>
+<P>Portions of this text are reprinted and reproduced in electronic
+form from IEEE Std 1003.1, 2003 Edition, Standard for Information
+Technology -- Portable Operating System Interface (POSIX), The Open
+Group Base Specifications Issue 6, Copyright (C) 2001-2003 by the
+Institute of Electrical and Electronics Engineers, Inc and The Open
+Group. In the event of any discrepancy between this version and the
+original IEEE and The Open Group Standard, the original IEEE and The
+Open Group Standard is the referee document. The original Standard
+can be obtained online at <A HREF="http://www.opengroup.org/unix/online.html">http://www.opengroup.org/unix/online.html</A>
+. 
+</P>
+<P>Modified by Ross Johnson for use with <A HREF="http://sourceforge.net/projects/pthreads4w/">PThreads4W</A>.</P>
+<HR>
+<P><A NAME="toc"></A><B>Table of Contents</B></P>
+<UL>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
+	Value</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Examples</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Application
+	Usage</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">Rationale</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect8" NAME="toc8">Future
+	Directions</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect9" NAME="toc9">See
+	Also</A> 
+	</P>
+	<LI><P><A HREF="#sect10" NAME="toc10">Copyright</A> 
+	</P>
+</UL>
+</BODY>
+</HTML>
\ No newline at end of file
diff --git a/src/include/pthread/manual/pthread_attr_setstacksize.html b/src/include/pthread/manual/pthread_attr_setstacksize.html
new file mode 100644
index 0000000..ebce839
--- /dev/null
+++ b/src/include/pthread/manual/pthread_attr_setstacksize.html
@@ -0,0 +1,122 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
+	<TITLE>PTHREAD_ATTR_SETSTACKSIZE(3) manual page</TITLE>
+</HEAD>
+<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
+<H4>POSIX Threads for Windows – REFERENCE - <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A></H4>
+<P><A HREF="index.html">Reference Index</A></P>
+<P><A HREF="#toc">Table of Contents</A></P>
+<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P>pthread_attr_getstacksize, pthread_attr_setstacksize - get and set
+the stacksize attribute 
+</P>
+<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P><B>#include &lt;pthread.h&gt; </B>
+</P>
+<P><B>int pthread_attr_getstacksize(const pthread_attr_t *restrict</B>
+<I>attr</I><B>, size_t *restrict</B> <I>stacksize</I><B>); <BR>int
+pthread_attr_setstacksize(pthread_attr_t *</B><I>attr</I><B>, size_t</B>
+<I>stacksize</I><B>); </B>
+</P>
+<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P>The <B>pthread_attr_getstacksize</B> and <B>pthread_attr_setstacksize</B>
+functions, respectively, shall get and set the thread creation
+<I>stacksize</I> attribute in the <I>attr</I> object. 
+</P>
+<P>The <I>stacksize</I> attribute shall define the minimum stack size
+(in bytes) allocated for the created threads stack. 
+</P>
+<P><B>PThreads4W</B> defines <B>_POSIX_THREAD_ATTR_STACKSIZE</B> in
+pthread.h to indicate that these routines are implemented and may be
+used to set or get the stack size.</P>
+<P>Default value: 0 (in PThreads4W a value of 0 means the stack
+will grow as required)</P>
+<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
+<P>Upon successful completion, <B>pthread_attr_getstacksize</B> and
+<B>pthread_attr_setstacksize</B> shall return a value of 0;
+otherwise, an error number shall be returned to indicate the error. 
+</P>
+<P>The <B>pthread_attr_getstacksize</B> function stores the <I>stacksize</I>
+attribute value in <I>stacksize</I> if successful. 
+</P>
+<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
+<P>The <B>pthread_attr_setstacksize</B> function shall fail if: 
+</P>
+<DL>
+	<DT><B>EINVAL</B> 
+	</DT><DD STYLE="margin-bottom: 0.5cm">
+	The value of <I>stacksize</I> is less than {PTHREAD_STACK_MIN} or
+	exceeds a system-imposed limit. 
+	</DD></DL>
+<P>
+These functions shall not return an error code of [EINTR]. 
+</P>
+<P><I>The following sections are informative.</I> 
+</P>
+<H2><A HREF="#toc5" NAME="sect5">Examples</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc6" NAME="sect6">Application Usage</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc7" NAME="sect7">Rationale</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc8" NAME="sect8">Future Directions</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc9" NAME="sect9">See Also</A></H2>
+<P><A HREF="pthread_attr_init.html"><B>pthread_attr_destroy</B>(3)</A>
+<B>,</B> <A HREF="pthread_attr_setstackaddr.html"><B>pthread_attr_getstackaddr</B>(3)</A>
+<B>,</B> <A HREF="pthread_attr_init.html"><B>pthread_attr_getdetachstate</B>(3)</A>
+<B>,</B> <A HREF="pthread_create.html"><B>pthread_create</B>(3)</A> <B>,</B>
+the Base Definitions volume of IEEE&nbsp;Std&nbsp;1003.1-2001,
+<I>&lt;limits.h&gt;</I>, <I>&lt;pthread.h&gt;</I> 
+</P>
+<H2><A HREF="#toc10" NAME="sect10">Copyright</A></H2>
+<P>Portions of this text are reprinted and reproduced in electronic
+form from IEEE Std 1003.1, 2003 Edition, Standard for Information
+Technology -- Portable Operating System Interface (POSIX), The Open
+Group Base Specifications Issue 6, Copyright (C) 2001-2003 by the
+Institute of Electrical and Electronics Engineers, Inc and The Open
+Group. In the event of any discrepancy between this version and the
+original IEEE and The Open Group Standard, the original IEEE and The
+Open Group Standard is the referee document. The original Standard
+can be obtained online at <A HREF="http://www.opengroup.org/unix/online.html">http://www.opengroup.org/unix/online.html</A>
+. 
+</P>
+<P>Modified by Ross Johnson for use with <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A>.</P>
+<HR>
+<P><A NAME="toc"></A><B>Table of Contents</B></P>
+<UL>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
+	Value</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Examples</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Application
+	Usage</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">Rationale</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect8" NAME="toc8">Future
+	Directions</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect9" NAME="toc9">See
+	Also</A> 
+	</P>
+	<LI><P><A HREF="#sect10" NAME="toc10">Copyright</A> 
+	</P>
+</UL>
+</BODY>
+</HTML>
diff --git a/src/include/pthread/manual/pthread_barrier_init.html b/src/include/pthread/manual/pthread_barrier_init.html
new file mode 100644
index 0000000..82116a2
--- /dev/null
+++ b/src/include/pthread/manual/pthread_barrier_init.html
@@ -0,0 +1,191 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
+	<TITLE>PTHREAD_BARRIER_INIT(3) manual page</TITLE>
+</HEAD>
+<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
+<H4>POSIX Threads for Windows – REFERENCE - <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A></H4>
+<P><A HREF="index.html">Reference Index</A></P>
+<P><A HREF="#toc">Table of Contents</A></P>
+<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P>pthread_barrier_destroy, pthread_barrier_init - destroy and
+initialize a barrier object (<B>ADVANCED REALTIME THREADS</B>) 
+</P>
+<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P><B>#include &lt;pthread.h&gt; </B>
+</P>
+<P><B>int pthread_barrier_destroy(pthread_barrier_t *</B><I>barrier</I><B>);
+<BR>int pthread_barrier_init(pthread_barrier_t *restrict</B> <I>barrier</I><B>,
+const pthread_barrierattr_t *restrict</B> <I>attr</I><B>, unsigned</B>
+<I>count</I><B>); </B>
+</P>
+<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P>The <B>pthread_barrier_destroy</B> function shall destroy the
+barrier referenced by <I>barrier</I> and release any resources used
+by the barrier. The effect of subsequent use of the barrier is
+undefined until the barrier is reinitialized by another call to
+<B>pthread_barrier_init</B> . An implementation may use this function
+to set <I>barrier</I> to an invalid value. An error code is returned if <B>pthread_barrier_destroy</B> is called when any thread is
+blocked on the barrier, or if this function is called with an
+uninitialized barrier. 
+</P>
+<P>The <B>pthread_barrier_init</B> function shall allocate any
+resources required to use the barrier referenced by <I>barrier</I>
+and shall initialize the barrier with attributes referenced by <I>attr</I>.
+If <I>attr</I> is NULL, the default barrier attributes shall be used;
+the effect is the same as passing the address of a default barrier
+attributes object. The results are undefined if <B>pthread_barrier_init</B>
+is called when any thread is blocked on the barrier (that is, has not
+returned from the <A HREF="pthread_barrier_wait.html"><B>pthread_barrier_wait</B>(3)</A>
+call). The results are undefined if a barrier is used without first
+being initialized. The results are undefined if <B>pthread_barrier_init</B>
+is called specifying an already initialized barrier. 
+</P>
+<P>The <I>count</I> argument specifies the number of threads that
+must call <A HREF="pthread_barrier_wait.html"><B>pthread_barrier_wait</B>(3)</A>
+before any of them successfully return from the call. The value
+specified by <I>count</I> must be greater than zero. 
+</P>
+<P>If the <B>pthread_barrier_init</B> function fails, the barrier
+shall not be initialized and the contents of <I>barrier</I> are
+undefined. 
+</P>
+<P>Only the object referenced by <I>barrier</I> may be used for
+performing synchronization. The result of referring to copies of that
+object in calls to <B>pthread_barrier_destroy</B> <B>or</B>
+<A HREF="pthread_barrier_wait.html"><B>pthread_barrier_wait</B>(3)</A>
+is undefined.</P>
+<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
+<P>Upon successful completion, these functions shall return zero;
+otherwise, an error number shall be returned to indicate the error. 
+</P>
+<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
+<P>The <B>pthread_barrier_destroy</B> function may fail if: 
+</P>
+<DL>
+	<DT><B>EBUSY</B> 
+	</DT><DD>
+	The implementation has detected an attempt to destroy a barrier
+	while it is in use (for example, while being used in a
+	<A HREF="pthread_barrier_wait.html"><B>pthread_barrier_wait</B>(3)</A>
+	call) by another thread. 
+	</DD><DT>
+	<B>EINVAL</B> 
+	</DT><DD STYLE="margin-bottom: 0.5cm">
+	The value specified by <I>barrier</I> is invalid. 
+	</DD></DL>
+<P>
+The <B>pthread_barrier_init</B> function shall fail if: 
+</P>
+<DL>
+	<DT><B>EAGAIN</B> 
+	</DT><DD>
+	The system lacks the necessary resources to initialize another
+	barrier. 
+	</DD><DT>
+	<B>EINVAL</B> 
+	</DT><DD>
+	The value specified by <I>count</I> is equal to zero. 
+	</DD><DT>
+	<B>ENOMEM</B> 
+	</DT><DD STYLE="margin-bottom: 0.5cm">
+	Insufficient memory exists to initialize the barrier. 
+	</DD></DL>
+<P>
+The <B>pthread_barrier_init</B> function may fail if: 
+</P>
+<DL>
+	<DT><B>EBUSY</B> 
+	</DT><DD>
+	The implementation has detected an attempt to reinitialize a barrier
+	while it is in use (for example, while being used in a
+	<A HREF="pthread_barrier_wait.html"><B>pthread_barrier_wait</B>(3)</A>
+	call) by another thread. 
+	</DD><DT>
+	<B>EINVAL</B> 
+	</DT><DD STYLE="margin-bottom: 0.5cm">
+	The value specified by <I>attr</I> is invalid. 
+	</DD></DL>
+<P>
+These functions shall not return an error code of [EINTR]. 
+</P>
+<P><I>The following sections are informative.</I> 
+</P>
+<H2><A HREF="#toc5" NAME="sect5">Examples</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc6" NAME="sect6">Application Usage</A></H2>
+<P>The <B>pthread_barrier_destroy</B> and <B>pthread_barrier_init</B>
+functions are part of the Barriers option and need not be provided on
+all implementations. 
+</P>
+<P><B>PThreads4W</B> defines <B>_POSIX_BARRIERS</B> to indicate
+that these routines are implemented and may be used.</P>
+<H2><A HREF="#toc7" NAME="sect7">Rationale</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc8" NAME="sect8">Future Directions</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc11" NAME="sect11">Known Bugs</A></H2>
+<DL>
+	<DD STYLE="margin-left: 0cm; margin-bottom: 0.5cm">In
+	<B><SPAN LANG="en-GB"><SPAN LANG="en-GB">PThreads4W</SPAN></SPAN></B>,
+	the behaviour of threads which enter <A HREF="pthread_barrier_wait.html"><B>pthread_barrier_wait</B>(3)</A>
+	while the barrier is being destroyed is undefined. 
+	</DD></DL>
+<H2>
+<A HREF="#toc9" NAME="sect9">See Also</A></H2>
+<P><A HREF="pthread_barrier_wait.html"><B>pthread_barrier_wait</B>(3)</A>
+<B>,</B> the Base Definitions volume of IEEE&nbsp;Std&nbsp;1003.1-2001,
+<I>&lt;pthread.h&gt;</I> 
+</P>
+<H2><A HREF="#toc10" NAME="sect10">Copyright</A></H2>
+<P>Portions of this text are reprinted and reproduced in electronic
+form from IEEE Std 1003.1, 2003 Edition, Standard for Information
+Technology -- Portable Operating System Interface (POSIX), The Open
+Group Base Specifications Issue 6, Copyright (C) 2001-2003 by the
+Institute of Electrical and Electronics Engineers, Inc and The Open
+Group. In the event of any discrepancy between this version and the
+original IEEE and The Open Group Standard, the original IEEE and The
+Open Group Standard is the referee document. The original Standard
+can be obtained online at <A HREF="http://www.opengroup.org/unix/online.html">http://www.opengroup.org/unix/online.html</A>
+. 
+</P>
+<P>Modified by Ross Johnson for use with <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A>.</P>
+<HR>
+<P><A NAME="toc"></A><B>Table of Contents</B></P>
+<UL>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
+	Value</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Examples</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Application
+	Usage</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">Rationale</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect8" NAME="toc8">Future
+	Directions</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect11" NAME="toc11">Known
+	Bugs</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect9" NAME="toc9">See
+	Also</A> 
+	</P>
+	<LI><P><A HREF="#sect10" NAME="toc10">Copyright</A> 
+	</P>
+</UL>
+</BODY>
+</HTML>
\ No newline at end of file
diff --git a/src/include/pthread/manual/pthread_barrier_wait.html b/src/include/pthread/manual/pthread_barrier_wait.html
new file mode 100644
index 0000000..82c8243
--- /dev/null
+++ b/src/include/pthread/manual/pthread_barrier_wait.html
@@ -0,0 +1,155 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
+	<TITLE>PTHREAD_BARRIER_WAIT(3) manual page</TITLE>
+</HEAD>
+<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
+<H4>POSIX Threads for Windows – REFERENCE - <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A></H4>
+<P><A HREF="index.html">Reference Index</A></P>
+<P><A HREF="#toc">Table of Contents</A></P>
+<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P>pthread_barrier_wait - synchronize at a barrier (<B>ADVANCED
+REALTIME THREADS</B>) 
+</P>
+<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P><B>#include &lt;pthread.h&gt; </B>
+</P>
+<P><B>int pthread_barrier_wait(pthread_barrier_t *</B><I>barrier</I><B>);
+</B>
+</P>
+<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P>The <B>pthread_barrier_wait</B> function shall synchronize
+participating threads at the barrier referenced by <I>barrier</I>.
+The calling thread shall block until the required number of threads
+have called <B>pthread_barrier_wait</B> specifying the barrier. 
+</P>
+<P>When the required number of threads have called
+<B>pthread_barrier_wait</B> specifying the barrier, the constant
+<B>PTHREAD_BARRIER_SERIAL_THREAD</B> shall be returned to one
+unspecified thread and zero shall be returned to each of the
+remaining threads. At this point, the barrier shall be reset to the
+state it had as a result of the most recent <A HREF="pthread_barrier_init.html"><B>pthread_barrier_init</B>(3)</A>
+function that referenced it. 
+</P>
+<P>The constant <B>PTHREAD_BARRIER_SERIAL_THREAD</B> is defined in
+<I>&lt;pthread.h&gt;</I> and its value shall be distinct from any
+other value returned by <B>pthread_barrier_wait</B> . 
+</P>
+<P>The results are undefined if this function is called with an
+uninitialized barrier. 
+</P>
+<P>If a signal is delivered to a thread blocked on a barrier, upon
+return from the signal handler the thread shall resume waiting at the
+barrier if the barrier wait has not completed (that is, if the
+required number of threads have not arrived at the barrier during the
+execution of the signal handler); otherwise, the thread shall
+continue as normal from the completed barrier wait. Until the thread
+in the signal handler returns from it, it is unspecified whether
+other threads may proceed past the barrier once they have all reached
+it. 
+</P>
+<P>A thread that has blocked on a barrier shall not prevent any
+unblocked thread that is eligible to use the same processing
+resources from eventually making forward progress in its execution.
+Eligibility for processing resources shall be determined by the
+scheduling policy. 
+</P>
+<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
+<P>Upon successful completion, the <B>pthread_barrier_wait</B>
+function shall return <B>PTHREAD_BARRIER_SERIAL_THREAD</B> for a
+single (arbitrary) thread synchronized at the barrier and zero for
+each of the other threads. Otherwise, an error number shall be
+returned to indicate the error. 
+</P>
+<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
+<P>The <B>pthread_barrier_wait</B> function may fail if: 
+</P>
+<DL>
+	<DT><B>EINVAL</B> 
+	</DT><DD STYLE="margin-bottom: 0.5cm">
+	The value specified by <I>barrier</I> does not refer to an
+	initialized barrier object. 
+	</DD></DL>
+<P>
+This function shall not return an error code of [EINTR]. 
+</P>
+<P><I>The following sections are informative.</I> 
+</P>
+<H2><A HREF="#toc5" NAME="sect5">Examples</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc6" NAME="sect6">Application Usage</A></H2>
+<P>Applications using this function may be subject to priority
+inversion, as discussed in the Base Definitions volume of
+IEEE&nbsp;Std&nbsp;1003.1-2001, Section 3.285, Priority Inversion. 
+</P>
+<P>The <B>pthread_barrier_wait</B> function is part of the Barriers
+option and need not be provided on all implementations. 
+</P>
+<P><B>PThreads4W</B> defines <B>_POSIX_BARRIERS</B> to indicate
+that this routine is implemented and may be used.</P>
+<H2><A HREF="#toc7" NAME="sect7">Rationale</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc8" NAME="sect8">Future Directions</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc11" NAME="sect11">Known Bugs</A></H2>
+<DL>
+	None.</DL>
+<H2>
+<A HREF="#toc9" NAME="sect9">See Also</A></H2>
+<P><A HREF="pthread_barrier_init.html"><B>pthread_barrier_destroy</B>(3)</A>,
+<A HREF="pthread_barrier_init.html"><B>pthread_barrier_init(3)</B></A>,
+the Base Definitions volume of IEEE&nbsp;Std&nbsp;1003.1-2001,
+<I>&lt;pthread.h&gt;</I> 
+</P>
+<H2><A HREF="#toc10" NAME="sect10">Copyright</A></H2>
+<P>Portions of this text are reprinted and reproduced in electronic
+form from IEEE Std 1003.1, 2003 Edition, Standard for Information
+Technology -- Portable Operating System Interface (POSIX), The Open
+Group Base Specifications Issue 6, Copyright (C) 2001-2003 by the
+Institute of Electrical and Electronics Engineers, Inc and The Open
+Group. In the event of any discrepancy between this version and the
+original IEEE and The Open Group Standard, the original IEEE and The
+Open Group Standard is the referee document. The original Standard
+can be obtained online at <A HREF="http://www.opengroup.org/unix/online.html">http://www.opengroup.org/unix/online.html</A>
+. 
+</P>
+<P>Modified by Ross Johnson for use with <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A>.</P>
+<HR>
+<P><A NAME="toc"></A><B>Table of Contents</B></P>
+<UL>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
+	Value</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Examples</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Application
+	Usage</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">Rationale</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect8" NAME="toc8">Future
+	Directions</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect11" NAME="toc11">Known
+	Bugs</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect9" NAME="toc9">See
+	Also</A> 
+	</P>
+	<LI><P><A HREF="#sect10" NAME="toc10">Copyright</A> 
+	</P>
+</UL>
+</BODY>
+</HTML>
\ No newline at end of file
diff --git a/src/include/pthread/manual/pthread_barrierattr_init.html b/src/include/pthread/manual/pthread_barrierattr_init.html
new file mode 100644
index 0000000..b26c402
--- /dev/null
+++ b/src/include/pthread/manual/pthread_barrierattr_init.html
@@ -0,0 +1,137 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
+	<TITLE>PTHREAD_BARRIERATTR_INIT(3) manual page</TITLE>
+</HEAD>
+<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
+<H4>POSIX Threads for Windows – REFERENCE - <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A></H4>
+<P><A HREF="index.html">Reference Index</A></P>
+<P><A HREF="#toc">Table of Contents</A></P>
+<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P>pthread_barrierattr_destroy, pthread_barrierattr_init - destroy
+and initialize the barrier attributes object (<B>ADVANCED REALTIME
+THREADS</B>) 
+</P>
+<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P><B>#include &lt;pthread.h&gt; </B>
+</P>
+<P>i<B>nt pthread_barrierattr_destroy(pthread_barrierattr_t *</B><I>attr</I><B>);
+<BR>int pthread_barrierattr_init(pthread_barrierattr_t *</B><I>attr</I><B>);
+</B>
+</P>
+<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P>The <B>pthread_barrierattr_destroy</B> function shall destroy a
+barrier attributes object. A destroyed <I>attr</I> attributes object
+can be reinitialized using <B>pthread_barrierattr_init</B> ; the
+results of otherwise referencing the object after it has been
+destroyed are undefined. An implementation may cause
+<B>pthread_barrierattr_destroy</B> to set the object referenced by
+<I>attr</I> to an invalid value. 
+</P>
+<P>The <B>pthread_barrierattr_init</B> function shall initialize a
+barrier attributes object <I>attr</I> with the default value for all
+of the attributes defined by the implementation. 
+</P>
+<P>Results are undefined if <B>pthread_barrierattr_init</B> is called
+specifying an already initialized <I>attr</I> attributes object. 
+</P>
+<P>After a barrier attributes object has been used to initialize one
+or more barriers, any function affecting the attributes object
+(including destruction) shall not affect any previously initialized
+barrier. 
+</P>
+<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
+<P>If successful, the <B>pthread_barrierattr_destroy</B> and
+<B>pthread_barrierattr_init</B> functions shall return zero;
+otherwise, an error number shall be returned to indicate the error. 
+</P>
+<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
+<P>The <B>pthread_barrierattr_destroy</B> function may fail if: 
+</P>
+<DL>
+	<DT><B>EINVAL</B> 
+	</DT><DD STYLE="margin-bottom: 0.5cm">
+	The value specified by <I>attr</I> is invalid. 
+	</DD></DL>
+<P>
+The <B>pthread_barrierattr_init</B> function shall fail if: 
+</P>
+<DL>
+	<DT><B>ENOMEM</B> 
+	</DT><DD STYLE="margin-bottom: 0.5cm">
+	Insufficient memory exists to initialize the barrier attributes
+	object. 
+	</DD></DL>
+<P>
+These functions shall not return an error code of [EINTR]. 
+</P>
+<P><I>The following sections are informative.</I> 
+</P>
+<H2><A HREF="#toc5" NAME="sect5">Examples</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc6" NAME="sect6">Application Usage</A></H2>
+<P>The <B>pthread_barrierattr_destroy</B> and
+<B>pthread_barrierattr_init</B> functions are part of the Barriers
+option and need not be provided on all implementations. 
+</P>
+<P><B>PThreads4W</B> defines <B>_POSIX_BARRIERS</B> to indicate
+that these routines are implemented and may be used.</P>
+<H2><A HREF="#toc7" NAME="sect7">Rationale</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc8" NAME="sect8">Future Directions</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc9" NAME="sect9">See Also</A></H2>
+<P><A HREF="pthread_barrierattr_setpshared.html"><B>pthread_barrierattr_getpshared</B>(3)</A>
+<B>,</B> <A HREF="pthread_barrierattr_setpshared.html"><B>pthread_barrierattr_setpshared</B>(3)</A>
+, the Base Definitions volume of IEEE&nbsp;Std&nbsp;1003.1-2001,
+<I>&lt;pthread.h&gt;</I>. 
+</P>
+<H2><A HREF="#toc10" NAME="sect10">Copyright</A></H2>
+<P>Portions of this text are reprinted and reproduced in electronic
+form from IEEE Std 1003.1, 2003 Edition, Standard for Information
+Technology -- Portable Operating System Interface (POSIX), The Open
+Group Base Specifications Issue 6, Copyright (C) 2001-2003 by the
+Institute of Electrical and Electronics Engineers, Inc and The Open
+Group. In the event of any discrepancy between this version and the
+original IEEE and The Open Group Standard, the original IEEE and The
+Open Group Standard is the referee document. The original Standard
+can be obtained online at <A HREF="http://www.opengroup.org/unix/online.html">http://www.opengroup.org/unix/online.html</A>
+. 
+</P>
+<P>Modified by Ross Johnson for use with <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A>.</P>
+<HR>
+<P><A NAME="toc"></A><B>Table of Contents</B></P>
+<UL>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
+	Value</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Examples</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Application
+	Usage</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">Rationale</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect8" NAME="toc8">Future
+	Directions</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect9" NAME="toc9">See
+	Also</A> 
+	</P>
+	<LI><P><A HREF="#sect10" NAME="toc10">Copyright</A> 
+	</P>
+</UL>
+</BODY>
+</HTML>
diff --git a/src/include/pthread/manual/pthread_barrierattr_setpshared.html b/src/include/pthread/manual/pthread_barrierattr_setpshared.html
new file mode 100644
index 0000000..afeab8e
--- /dev/null
+++ b/src/include/pthread/manual/pthread_barrierattr_setpshared.html
@@ -0,0 +1,154 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
+	<TITLE>PTHREAD_BARRIERATTR_SETPSHARED(3) manual page</TITLE>
+</HEAD>
+<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
+<H4>POSIX Threads for Windows – REFERENCE - <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A></H4>
+<P><A HREF="index.html">Reference Index</A></P>
+<P><A HREF="#toc">Table of Contents</A></P>
+<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P>pthread_barrierattr_getpshared, pthread_barrierattr_setpshared -
+get and set the process-shared attribute of the barrier attributes
+object (<B>ADVANCED REALTIME THREADS</B>) 
+</P>
+<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P><B>#include &lt;pthread.h&gt; </B>
+</P>
+<P><B>int pthread_barrierattr_getpshared(const pthread_barrierattr_t
+* restrict</B> <I>attr</I><B>, int *restrict</B> <I>pshared</I><B>);
+<BR>int pthread_barrierattr_setpshared(pthread_barrierattr_t *</B><I>attr</I><B>,
+int</B> <I>pshared</I><B>); </B>
+</P>
+<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P>The <B>pthread_barrierattr_getpshared</B> function shall obtain
+the value of the <I>process-shared</I> attribute from the attributes
+object referenced by <I>attr</I>. The <B>pthread_barrierattr_setpshared</B>
+function shall set the <I>process-shared</I> attribute in an
+initialized attributes object referenced by <I>attr</I>. 
+</P>
+<P>The <I>process-shared</I> attribute is set to
+PTHREAD_PROCESS_SHARED to permit a barrier to be operated upon by any
+thread that has access to the memory where the barrier is allocated.
+If the <I>process-shared</I> attribute is PTHREAD_PROCESS_PRIVATE,
+the barrier shall only be operated upon by threads created within the
+same process as the thread that initialized the barrier; if threads
+of different processes attempt to operate on such a barrier, the
+behavior is undefined. The default value of the attribute shall be
+PTHREAD_PROCESS_PRIVATE. Both constants PTHREAD_PROCESS_SHARED and
+PTHREAD_PROCESS_PRIVATE are defined in <I>&lt;pthread.h&gt;</I>. 
+</P>
+<P><B>PThreads4W</B> defines _<B>POSIX_THREAD_PROCESS_SHARED</B> in
+pthread.h as -1 to indicate that these routines are implemented but
+that the process shared attribute is not supported.</P>
+<P>Additional attributes, their default values, and the names of the
+associated functions to get and set those attribute values are
+implementation-defined. 
+</P>
+<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
+<P>If successful, the <B>pthread_barrierattr_getpshared</B> function
+shall return zero and store the value of the <I>process-shared</I>
+attribute of <I>attr</I> into the object referenced by the <I>pshared</I>
+parameter. Otherwise, an error number shall be returned to indicate
+the error. 
+</P>
+<P>If successful, the <B>pthread_barrierattr_setpshared</B> function
+shall return zero; otherwise, an error number shall be returned to
+indicate the error. 
+</P>
+<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
+<P>These functions may fail if: 
+</P>
+<DL>
+	<DT><B>EINVAL</B> 
+	</DT><DD STYLE="margin-bottom: 0.5cm">
+	The value specified by <I>attr</I> is invalid. 
+	</DD><DT>
+	The <B>pthread_barrierattr_setpshared</B> function may fail if: 
+	</DT><DT>
+	<B>EINVAL</B> 
+	</DT><DD STYLE="margin-bottom: 0.5cm">
+	The new value specified for the <I>process-shared</I> attribute is
+	not one of the legal values <B>PTHREAD_PROCESS_SHARED</B> or
+	<B>PTHREAD_PROCESS_PRIVATE</B>. 
+	</DD><DT>
+	<B>ENOSYS</B> 
+	</DT><DD STYLE="margin-bottom: 0.5cm">
+	The value specified by <I>attr</I> was <B>PTHREAD_PROCESS_SHARED</B>
+	(PThreads4W).</DD></DL>
+<P>
+These functions shall not return an error code of [EINTR]. 
+</P>
+<P><I>The following sections are informative.</I> 
+</P>
+<H2><A HREF="#toc5" NAME="sect5">Examples</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc6" NAME="sect6">Application Usage</A></H2>
+<P>The <B>pthread_barrierattr_getpshared</B> and
+<B>pthread_barrierattr_setpshared</B> functions are part of the
+Barriers option and need not be provided on all implementations. 
+</P>
+<P><B>PThreads4W</B> defines <B>_POSIX_BARRIERS</B> and
+<B>_POSIX_THREAD_PROCESS_SHARED</B> in pthread.h as -1 to indicate
+that these routines are implemented and may be used, but do not
+support the process shared option.</P>
+<H2><A HREF="#toc7" NAME="sect7">Rationale</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc8" NAME="sect8">Future Directions</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc9" NAME="sect9">See Also</A></H2>
+<P><A HREF="pthread_barrier_init.html"><B>pthread_barrier_destroy</B>(3)</A>
+<B>,</B> <A HREF="pthread_barrierattr_init.html"><B>pthread_barrierattr_destroy</B>(3)</A>
+<B>,</B> <A HREF="pthread_barrierattr_init.html"><B>pthread_barrierattr_init</B>(3)</A>
+<B>,</B> the Base Definitions volume of IEEE&nbsp;Std&nbsp;1003.1-2001,
+<I>&lt;pthread.h&gt;</I> 
+</P>
+<H2><A HREF="#toc10" NAME="sect10">Copyright</A></H2>
+<P>Portions of this text are reprinted and reproduced in electronic
+form from IEEE Std 1003.1, 2003 Edition, Standard for Information
+Technology -- Portable Operating System Interface (POSIX), The Open
+Group Base Specifications Issue 6, Copyright (C) 2001-2003 by the
+Institute of Electrical and Electronics Engineers, Inc and The Open
+Group. In the event of any discrepancy between this version and the
+original IEEE and The Open Group Standard, the original IEEE and The
+Open Group Standard is the referee document. The original Standard
+can be obtained online at <A HREF="http://www.opengroup.org/unix/online.html">http://www.opengroup.org/unix/online.html</A>
+. 
+</P>
+<P>Modified by Ross Johnson for use with <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A>.</P>
+<HR>
+<P><A NAME="toc"></A><B>Table of Contents</B></P>
+<UL>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
+	Value</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Examples</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Application
+	Usage</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">Rationale</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect8" NAME="toc8">Future
+	Directions</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect9" NAME="toc9">See
+	Also</A> 
+	</P>
+	<LI><P><A HREF="#sect10" NAME="toc10">Copyright</A> 
+	</P>
+</UL>
+</BODY>
+</HTML>
diff --git a/src/include/pthread/manual/pthread_cancel.html b/src/include/pthread/manual/pthread_cancel.html
new file mode 100644
index 0000000..b6ce0a0
--- /dev/null
+++ b/src/include/pthread/manual/pthread_cancel.html
@@ -0,0 +1,197 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
+	<TITLE>PTHREAD_CANCEL(3) manual page</TITLE>
+</HEAD>
+<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
+<H4>POSIX Threads for Windows – REFERENCE - <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A></H4>
+<P><A HREF="index.html">Reference Index</A></P>
+<P><A HREF="#toc">Table of Contents</A></P>
+<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P>pthread_cancel, pthread_setcancelstate, pthread_setcanceltype,
+pthread_testcancel - thread cancellation 
+</P>
+<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P><B>#include &lt;pthread.h&gt;</B> 
+</P>
+<P><B>int pthread_cancel(pthread_t </B><I>thread</I><B>);</B> 
+</P>
+<P><B>int pthread_setcancelstate(int </B><I>state</I><B>, int
+*</B><I>oldstate</I><B>);</B> 
+</P>
+<P><B>int pthread_setcanceltype(int </B><I>type</I><B>, int
+*</B><I>oldtype</I><B>);</B> 
+</P>
+<P><B>void pthread_testcancel(void);</B> 
+</P>
+<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P>Cancellation is the mechanism by which a thread can terminate the
+execution of another thread. More precisely, a thread can send a
+cancellation request to another thread. Depending on its settings,
+the target thread can then either ignore the request, honor it
+immediately, or defer it until it reaches a cancellation point. 
+</P>
+<P>When a thread eventually honors a cancellation request, it
+performs as if <B>pthread_exit(PTHREAD_CANCELED)</B> has been called
+at that point: all cleanup handlers are executed in reverse order,
+destructor functions for thread-specific data are called, and finally
+the thread stops executing with the return value <B>PTHREAD_CANCELED</B>.
+See <A HREF="pthread_exit.html"><B>pthread_exit</B>(3)</A> for more
+information. 
+</P>
+<P><B>pthread_cancel</B> sends a cancellation request to the thread
+denoted by the <I>thread</I> argument. 
+</P>
+<P><B>pthread_setcancelstate</B> changes the cancellation state for
+the calling thread -- that is, whether cancellation requests are
+ignored or not. The <I>state</I> argument is the new cancellation
+state: either <B>PTHREAD_CANCEL_ENABLE</B> to enable cancellation, or
+<B>PTHREAD_CANCEL_DISABLE</B> to disable cancellation (cancellation
+requests are ignored). If <I>oldstate</I> is not <B>NULL</B>, the
+previous cancellation state is stored in the location pointed to by
+<I>oldstate</I>, and can thus be restored later by another call to
+<B>pthread_setcancelstate</B>. 
+</P>
+<P><B>pthread_setcanceltype</B> changes the type of responses to
+cancellation requests for the calling thread: asynchronous
+(immediate) or deferred. The <I>type</I> argument is the new
+cancellation type: either <B>PTHREAD_CANCEL_ASYNCHRONOUS</B> to
+cancel the calling thread as soon as the cancellation request is
+received, or <B>PTHREAD_CANCEL_DEFERRED</B> to keep the cancellation
+request pending until the next cancellation point. If <I>oldtype</I>
+is not <B>NULL</B>, the previous cancellation state is stored in the
+location pointed to by <I>oldtype</I>, and can thus be restored later
+by another call to <B>pthread_setcanceltype</B>. 
+</P>
+<P><B>PThreads4W</B> provides two levels of support for
+<B>PTHREAD_CANCEL_ASYNCHRONOUS</B>: full and partial. Full support
+requires an additional DLL and driver be installed on the Windows
+system (see the See Also section below) that allows blocked threads
+to be cancelled immediately. Partial support means that the target
+thread will not cancel until it resumes execution naturally. Partial
+support is provided if either the DLL or the driver are not
+automatically detected by the PThreads4W library at run-time.</P>
+<P>Threads are always created by <A HREF="pthread_create.html"><B>pthread_create</B>(3)</A>
+with cancellation enabled and deferred. That is, the initial
+cancellation state is <B>PTHREAD_CANCEL_ENABLE</B> and the initial
+type is <B>PTHREAD_CANCEL_DEFERRED</B>. 
+</P>
+<P>Cancellation points are those points in the program execution
+where a test for pending cancellation requests is performed and
+cancellation is executed if positive. The following POSIX threads
+functions are cancellation points: 
+</P>
+<P><A HREF="pthread_join.html"><B>pthread_join</B>(3)</A>
+<BR><A HREF="pthread_cond_init.html"><B>pthread_cond_wait</B>(3)</A>
+<BR><A HREF="pthread_cond_init.html"><B>pthread_cond_timedwait</B>(3)</A>
+<BR><A HREF=""><B>pthread_testcancel</B>(3)</A> <BR><A HREF="sem_init.html"><B>sem_wait</B>(3)</A>
+<BR><A HREF="sem_init.html"><B>sem_timedwait</B>(3)</A> <BR><A HREF="pthread_kill.html"><B>sigwait</B>(3)</A></P>
+<P><B>PThreads4W</B> provides two functions to enable additional
+cancellation points to be created in user functions that block on
+Win32 HANDLEs:</P>
+<P><A HREF="pthreadCancelableWait.html">pthreadCancelableWait()</A>
+<BR><A HREF="pthreadCancelableTimedWait.html">pthreadCancelableTimedWait()</A></P>
+<P>All other POSIX threads functions are guaranteed not to be
+cancellation points. That is, they never perform cancellation in
+deferred cancellation mode. 
+</P>
+<P><B>pthread_testcancel</B> does nothing except testing for pending
+cancellation and executing it. Its purpose is to introduce explicit
+checks for cancellation in long sequences of code that do not call
+cancellation point functions otherwise. 
+</P>
+<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
+<P><B>pthread_cancel</B>, <B>pthread_setcancelstate</B> and
+<B>pthread_setcanceltype</B> return 0 on success and a non-zero error
+code on error. 
+</P>
+<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
+<P><B>pthread_cancel</B> returns the following error code on error: 
+</P>
+<DL>
+		<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>ESRCH</B> 
+		</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
+		no thread could be found corresponding to that specified by the
+		<I>thread</I> ID. 
+		</DD>
+</DL>
+<P>
+<B>pthread_setcancelstate</B> returns the following error code on
+error: 
+</P>
+<DL>
+		<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EINVAL</B> 
+		</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
+		the <I>state</I> argument is not 
+		</DD>
+</DL>
+<BLOCKQUOTE>
+<B>PTHREAD_CANCEL_ENABLE</B> nor <B>PTHREAD_CANCEL_DISABLE</B> 
+</BLOCKQUOTE>
+<P><B>pthread_setcanceltype</B> returns the following error code on
+error: 
+</P>
+<DL>
+		<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EINVAL</B> 
+		</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
+		the <I>type</I> argument is not 
+		</DD>
+</DL>
+<BLOCKQUOTE>
+<B>PTHREAD_CANCEL_DEFERRED</B> nor <B>PTHREAD_CANCEL_ASYNCHRONOUS</B>
+</BLOCKQUOTE>
+<H2><A HREF="#toc5" NAME="sect5">Author</A></H2>
+<P>Xavier Leroy &lt;Xavier.Leroy@inria.fr&gt; 
+</P>
+<P>Modified by Ross Johnson for use with <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A>.</P>
+<H2><A HREF="#toc6" NAME="sect6">See Also</A></H2>
+<P><A HREF="pthread_exit.html"><B>pthread_exit</B>(3)</A> ,
+<A HREF="pthread_cleanup_push.html"><B>pthread_cleanup_push</B>(3)</A>
+, <A HREF="pthread_cleanup_pop.html"><B>pthread_cleanup_pop</B>(3)</A>
+, PThreads4W package README file 'Prerequisites' section. 
+</P>
+<H2><A HREF="#toc7" NAME="sect7">Bugs</A></H2>
+<P>POSIX specifies that a number of system calls (basically, all
+system calls that may block, such as <A HREF="read.html"><B>read</B>(2)</A>
+, <A HREF="write.html"><B>write</B>(2)</A> , <A HREF="wait.html"><B>wait</B>(2)</A>
+, etc.) and library functions that may call these system calls (e.g.
+<A HREF="fprintf.html"><B>fprintf</B>(3)</A> ) are cancellation
+points. <B>PThreads4W</B> is not integrated enough with the C
+library to implement this, and thus none of the C library functions
+is a cancellation point. 
+</P>
+<P>A workaround for these calls is to temporarily switch to
+asynchronous cancellation (assuming full asynchronous cancellation
+support is installed). So, checking for cancellation during a <B>read</B>
+system call, for instance, can be achieved as follows: 
+</P>
+<BLOCKQUOTE><BR><BR>
+</BLOCKQUOTE>
+<PRE STYLE="margin-left: 1cm; margin-right: 1cm">pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &amp;oldCancelType);
+read(fd, buffer, length);
+pthread_setcanceltype(oldCancelType, NULL);</PRE>
+<HR>
+<BLOCKQUOTE><A NAME="toc"></A><B>Table of Contents</B></BLOCKQUOTE>
+<UL>
+	<LI><BLOCKQUOTE STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
+		</BLOCKQUOTE>
+	<LI><BLOCKQUOTE STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</BLOCKQUOTE>
+	<LI><BLOCKQUOTE STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
+		</BLOCKQUOTE>
+	<LI><BLOCKQUOTE STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
+	Value</A> 
+	</BLOCKQUOTE>
+	<LI><BLOCKQUOTE STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
+		</BLOCKQUOTE>
+	<LI><BLOCKQUOTE STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Author</A>
+		</BLOCKQUOTE>
+	<LI><BLOCKQUOTE STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">See
+	Also</A> 
+	</BLOCKQUOTE>
+	<LI><BLOCKQUOTE><A HREF="#sect7" NAME="toc7">Bugs</A> 
+	</BLOCKQUOTE>
+</UL>
+</BODY>
+</HTML>
diff --git a/src/include/pthread/manual/pthread_cleanup_push.html b/src/include/pthread/manual/pthread_cleanup_push.html
new file mode 100644
index 0000000..2eda0a5
--- /dev/null
+++ b/src/include/pthread/manual/pthread_cleanup_push.html
@@ -0,0 +1,135 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
+	<TITLE>PTHREAD_CLEANUP_PUSH(3) manual page</TITLE>
+</HEAD>
+<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
+<H4>POSIX Threads for Windows – REFERENCE - <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A></H4>
+<P><A HREF="index.html">Reference Index</A></P>
+<P><A HREF="#toc">Table of Contents</A></P>
+<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P>pthread_cleanup_push, pthread_cleanup_pop - install and remove
+cleanup handlers 
+</P>
+<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P><B>#include &lt;pthread.h&gt;</B> 
+</P>
+<P><B>void pthread_cleanup_push(void (*</B><I>routine</I><B>) (void
+*), void *</B><I>arg</I><B>);</B> 
+</P>
+<P><B>void pthread_cleanup_pop(int </B><I>execute</I><B>);</B> 
+</P>
+<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P>Cleanup handlers are functions that get called when a thread
+terminates, either by calling <A HREF="pthread_exit.html"><B>pthread_exit</B>(3)</A>
+or because of cancellation. Cleanup handlers are installed and
+removed following a stack-like discipline. 
+</P>
+<P>The purpose of cleanup handlers is to free the resources that a
+thread may hold at the time it terminates. In particular, if a thread
+exits or is cancelled while it owns a locked mutex, the mutex will
+remain locked forever and prevent other threads from executing
+normally. The best way to avoid this is, just before locking the
+mutex, to install a cleanup handler whose effect is to unlock the
+mutex. Cleanup handlers can be used similarly to free blocks
+allocated with <A HREF="malloc.html"><B>malloc</B>(3)</A> or close
+file descriptors on thread termination. 
+</P>
+<P><B>pthread_cleanup_push</B> installs the <I>routine</I> function
+with argument <I>arg</I> as a cleanup handler. From this point on to
+the matching <B>pthread_cleanup_pop</B>, the function <I>routine</I>
+will be called with arguments <I>arg</I> when the thread terminates,
+either through <A HREF="pthread_exit.html"><B>pthread_exit</B>(3)</A>
+or by cancellation. If several cleanup handlers are active at that
+point, they are called in LIFO order: the most recently installed
+handler is called first. 
+</P>
+<P><B>pthread_cleanup_pop</B> removes the most recently installed
+cleanup handler. If the <I>execute</I> argument is not 0, it also
+executes the handler, by calling the <I>routine</I> function with
+arguments <I>arg</I>. If the <I>execute</I> argument is 0, the
+handler is only removed but not executed. 
+</P>
+<P>Matching pairs of <B>pthread_cleanup_push</B> and
+<B>pthread_cleanup_pop</B> must occur in the same function, at the
+same level of block nesting. Actually, <B>pthread_cleanup_push</B>
+and <B>pthread_cleanup_pop</B> are macros, and the expansion of
+<B>pthread_cleanup_push</B> introduces an open brace <B>{</B> with
+the matching closing brace <B>}</B> being introduced by the expansion
+of the matching <B>pthread_cleanup_pop</B>. 
+</P>
+<H2 STYLE="margin-top: 0cm"><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
+<BLOCKQUOTE STYLE="margin-left: 0cm; margin-right: 0cm">None. 
+</BLOCKQUOTE>
+<H2 STYLE="margin-top: 0cm"><A HREF="#toc4" NAME="sect4">Errors</A></H2>
+<BLOCKQUOTE STYLE="margin-left: 0cm; margin-right: 0cm">None. 
+</BLOCKQUOTE>
+<H2 STYLE="margin-top: 0cm"><A HREF="#toc5" NAME="sect5">Author</A></H2>
+<BLOCKQUOTE STYLE="margin-left: 0cm; margin-right: 0cm">Xavier Leroy
+&lt;Xavier.Leroy@inria.fr&gt; 
+</BLOCKQUOTE>
+<BLOCKQUOTE STYLE="margin-left: 0cm; margin-right: 0cm">Modified by
+Ross Johnson for use with PThreads4W.</BLOCKQUOTE>
+<H2 STYLE="margin-top: 0cm"><A HREF="#toc6" NAME="sect6">See Also</A></H2>
+<BLOCKQUOTE STYLE="margin-left: 0cm; margin-right: 0cm"><A HREF="pthread_exit.html"><B>pthread_exit</B>(3)</A>
+, <A HREF="pthread_cancel.html"><B>pthread_cancel</B>(3)</A> ,
+<A HREF="pthread_cancel.html"><B>pthread_setcanceltype</B>(3)</A> . 
+</BLOCKQUOTE>
+<H2 STYLE="margin-top: 0cm"><A HREF="#toc7" NAME="sect7">Example</A></H2>
+<BLOCKQUOTE STYLE="margin-left: 0cm; margin-right: 0cm">Here is how
+to lock a mutex <I>mut</I> in such a way that it will be unlocked if
+the thread is canceled while <I>mut</I> is locked: 
+</BLOCKQUOTE>
+<PRE>pthread_cleanup_push(pthread_mutex_unlock, (void *) &amp;mut);
+pthread_mutex_lock(&amp;mut);
+/* do some work */
+pthread_mutex_unlock(&amp;mut);
+pthread_cleanup_pop(0);</PRE><BLOCKQUOTE STYLE="margin-left: 0cm; margin-right: 0cm">
+Equivalently, the last two lines can be replaced by 
+</BLOCKQUOTE>
+<PRE STYLE="margin-bottom: 0.5cm">pthread_cleanup_pop(1);</PRE><BLOCKQUOTE STYLE="margin-left: 0cm; margin-right: 0cm">
+Notice that the code above is safe only in deferred cancellation mode
+(see <A HREF="pthread_cancel.html"><B>pthread_setcanceltype</B>(3)</A>
+). In asynchronous cancellation mode, a cancellation can occur
+between <B>pthread_cleanup_push</B> and <B>pthread_mutex_lock</B>, or
+between <B>pthread_mutex_unlock</B> and <B>pthread_cleanup_pop</B>,
+resulting in both cases in the thread trying to unlock a mutex not
+locked by the current thread. This is the main reason why
+asynchronous cancellation is difficult to use. 
+</BLOCKQUOTE>
+<BLOCKQUOTE STYLE="margin-left: 0cm; margin-right: 0cm">If the code
+above must also work in asynchronous cancellation mode, then it must
+switch to deferred mode for locking and unlocking the mutex: 
+</BLOCKQUOTE>
+<PRE>pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, &amp;oldtype);
+pthread_cleanup_push(pthread_mutex_unlock, (void *) &amp;mut);
+pthread_mutex_lock(&amp;mut);
+/* do some work */
+pthread_cleanup_pop(1);
+pthread_setcanceltype(oldtype, NULL);</PRE>
+<HR>
+<BLOCKQUOTE STYLE="margin-left: 0cm; margin-right: 0cm"><A NAME="toc"></A>
+<B>Table of Contents</B></BLOCKQUOTE>
+<UL>
+	<LI><BLOCKQUOTE STYLE="margin-right: 0cm; margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
+		</BLOCKQUOTE>
+	<LI><BLOCKQUOTE STYLE="margin-right: 0cm; margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</BLOCKQUOTE>
+	<LI><BLOCKQUOTE STYLE="margin-right: 0cm; margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
+		</BLOCKQUOTE>
+	<LI><BLOCKQUOTE STYLE="margin-right: 0cm; margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
+	Value</A> 
+	</BLOCKQUOTE>
+	<LI><BLOCKQUOTE STYLE="margin-right: 0cm; margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
+		</BLOCKQUOTE>
+	<LI><BLOCKQUOTE STYLE="margin-right: 0cm; margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Author</A>
+		</BLOCKQUOTE>
+	<LI><BLOCKQUOTE STYLE="margin-right: 0cm; margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">See
+	Also</A> 
+	</BLOCKQUOTE>
+	<LI><BLOCKQUOTE STYLE="margin-right: 0cm"><A HREF="#sect7" NAME="toc7">Example</A>
+		</BLOCKQUOTE>
+</UL>
+</BODY>
+</HTML>
diff --git a/src/include/pthread/manual/pthread_cond_init.html b/src/include/pthread/manual/pthread_cond_init.html
new file mode 100644
index 0000000..9c88684
--- /dev/null
+++ b/src/include/pthread/manual/pthread_cond_init.html
@@ -0,0 +1,300 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
+	<TITLE>PTHREAD_COND_INIT(3) manual page</TITLE>
+</HEAD>
+<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
+<H4>POSIX Threads for Windows – REFERENCE - <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A></H4>
+<P><A HREF="index.html">Reference Index</A></P>
+<P><A HREF="#toc">Table of Contents</A></P>
+<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P>pthread_cond_init, pthread_cond_destroy, pthread_cond_signal,
+pthread_cond_broadcast, pthread_cond_wait, pthread_cond_timedwait -
+operations on conditions 
+</P>
+<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P><B>#include &lt;pthread.h&gt;</B> 
+</P>
+<P><B>pthread_cond_t </B><I>cond</I> <B>= PTHREAD_COND_INITIALIZER;</B>
+</P>
+<P><B>int pthread_cond_init(pthread_cond_t *</B><I>cond</I><B>,
+pthread_condattr_t *</B><I>cond_attr</I><B>);</B> 
+</P>
+<P><B>int pthread_cond_signal(pthread_cond_t *</B><I>cond</I><B>);</B>
+</P>
+<P><B>int pthread_cond_broadcast(pthread_cond_t *</B><I>cond</I><B>);</B>
+</P>
+<P><B>int pthread_cond_wait(pthread_cond_t *</B><I>cond</I><B>,
+pthread_mutex_t *</B><I>mutex</I><B>);</B> 
+</P>
+<P><B>int pthread_cond_timedwait(pthread_cond_t *</B><I>cond</I><B>,
+pthread_mutex_t *</B><I>mutex</I><B>, const struct timespec
+*</B><I>abstime</I><B>);</B> 
+</P>
+<P><B>int pthread_cond_destroy(pthread_cond_t *</B><I>cond</I><B>);</B>
+</P>
+<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P>A condition (short for ‘‘condition variable’’) is a
+synchronization device that allows threads to suspend execution and
+relinquish the processors until some predicate on shared data is
+satisfied. The basic operations on conditions are: signal the
+condition (when the predicate becomes true), and wait for the
+condition, suspending the thread execution until another thread
+signals the condition. 
+</P>
+<P>A condition variable must always be associated with a mutex, to
+avoid the race condition where a thread prepares to wait on a
+condition variable and another thread signals the condition just
+before the first thread actually waits on it. 
+</P>
+<P><B>pthread_cond_init</B> initializes the condition variable <I>cond</I>,
+using the condition attributes specified in <I>cond_attr</I>, or
+default attributes if <I>cond_attr</I> is <B>NULL</B>. 
+</P>
+<P>Variables of type <B>pthread_cond_t</B> can also be initialized
+statically, using the constant <B>PTHREAD_COND_INITIALIZER</B>. In
+the <B>PThreads4W</B> implementation, an application should still
+call <B>pthread_cond_destroy</B> at some point to ensure that any
+resources consumed by the condition variable are released.</P>
+<P><B>pthread_cond_signal</B> restarts one of the threads that are
+waiting on the condition variable <I>cond</I>. If no threads are
+waiting on <I>cond</I>, nothing happens. If several threads are
+waiting on <I>cond</I>, exactly one is restarted, but it is not
+specified which. 
+</P>
+<P><B>pthread_cond_broadcast</B> restarts all the threads that are
+waiting on the condition variable <I>cond</I>. Nothing happens if no
+threads are waiting on <I>cond</I>. 
+</P>
+<P><B>pthread_cond_wait</B> atomically unlocks the <I>mutex</I> (as
+per <B>pthread_unlock_mutex</B>) and waits for the condition variable
+<I>cond</I> to be signalled. The thread execution is suspended and
+does not consume any CPU time until the condition variable is
+signalled. The <I>mutex</I> must be locked by the calling thread on
+entrance to <B>pthread_cond_wait</B>. Before returning to the calling
+thread, <B>pthread_cond_wait</B> re-acquires <I>mutex</I> (as per
+<B>pthread_lock_mutex</B>). 
+</P>
+<P>Unlocking the mutex and suspending on the condition variable is
+done atomically. Thus, if all threads always acquire the mutex before
+signalling the condition, this guarantees that the condition cannot
+be signalled (and thus ignored) between the time a thread locks the
+mutex and the time it waits on the condition variable. 
+</P>
+<P><B>pthread_cond_timedwait</B> atomically unlocks <I>mutex</I> and
+waits on <I>cond</I>, as <B>pthread_cond_wait</B> does, but it also
+bounds the duration of the wait. If <I>cond</I> has not been
+signalled within the amount of time specified by <I>abstime</I>, the
+mutex <I>mutex</I> is re-acquired and <B>pthread_cond_timedwait</B>
+returns the error <B>ETIMEDOUT</B>. The <I>abstime</I> parameter
+specifies an absolute time, with the same origin as <A HREF="time.html"><B>time</B>(2)</A>
+and <A HREF="gettimeofday.html"><B>gettimeofday</B>(2)</A>. 
+</P>
+<P><B>pthread_cond_destroy</B> destroys a condition variable, freeing
+the resources it might hold. No threads must be waiting on the
+condition variable on entrance to <B>pthread_cond_destroy</B>.</P>
+<H2><A HREF="#toc3" NAME="sect3">Cancellation</A></H2>
+<P><B>pthread_cond_wait</B> and <B>pthread_cond_timedwait</B> are
+cancellation points. If a thread is cancelled while suspended in one
+of these functions, the thread immediately resumes execution, then
+locks again the <I>mutex</I> argument to <B>pthread_cond_wait</B> and
+<B>pthread_cond_timedwait</B>, and finally executes the cancellation.
+Consequently, cleanup handlers are assured that <I>mutex</I> is
+locked when they are called. 
+</P>
+<H2><A HREF="#toc4" NAME="sect4">Async-signal Safety</A></H2>
+<P>The condition functions are not async-signal safe, and should not
+be called from a signal handler. In particular, calling
+<B>pthread_cond_signal</B> or <B>pthread_cond_broadcast</B> from a
+signal handler may deadlock the calling thread. 
+</P>
+<H2><A HREF="#toc5" NAME="sect5">Return Value</A></H2>
+<P>All condition variable functions return 0 on success and a
+non-zero error code on error. 
+</P>
+<H2><A HREF="#toc6" NAME="sect6">Errors</A></H2>
+<P><B>pthread_cond_init</B>, <B>pthread_cond_signal</B>,
+<B>pthread_cond_broadcast</B>, and <B>pthread_cond_wait</B> never
+return an error code. 
+</P>
+<P>The <B>pthread_cond_init</B> function returns the following error
+codes on error: 
+</P>
+<DL>
+		<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EINVAL</B> 
+		</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
+		The <I>cond</I> argument is invalid. 
+		</DD><DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
+		<B>ENOMEM</B> 
+		</DT>
+</DL>
+<BLOCKQUOTE STYLE="margin-left: 4cm">
+There was not enough memory to allocate the condition variable. 
+</BLOCKQUOTE>
+<P>The <B>pthread_cond_signal</B> function returns the following
+error codes on error: 
+</P>
+<DL>
+		<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EINVAL</B> 
+		</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
+		The <I>cond</I> argument is invalid. 
+		</DD>
+</DL>
+<P>
+The <B>pthread_cond_broadcast</B> function returns the following
+error codes on error: 
+</P>
+<DL>
+		<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EINVAL</B> 
+		</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
+		The <I>cond</I> argument is invalid. 
+		</DD>
+</DL>
+<P>
+The <B>pthread_cond_wait</B> function returns the following error
+codes on error: 
+</P>
+<DL>
+		<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EINVAL</B> 
+		</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
+		The <I>cond</I> argument is invalid. 
+		</DD><DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
+		<B>ENOMEM</B> 
+		</DT>
+</DL>
+<BLOCKQUOTE STYLE="margin-left: 4cm">
+There was not enough memory to allocate the statically initialised
+condition variable. Statically initialised condition variables are
+dynamically allocated by the first thread to wait on them.</BLOCKQUOTE>
+<P>The <B>pthread_cond_timedwait</B> function returns the following
+error codes on error: 
+</P>
+<DL>
+		<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EINVAL</B> 
+		</DT>
+</DL>
+<P STYLE="margin-left: 2cm">
+The <I>cond</I> argument is invalid. 
+</P>
+<DL>
+		<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>ETIMEDOUT</B>
+				</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
+		The condition variable was not signalled before the timeout
+		specified by <I>abstime</I> 
+		</DD><DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
+		<B>ENOMEM</B> 
+		</DT>
+</DL>
+<BLOCKQUOTE STYLE="margin-left: 4cm">
+There was not enough memory to allocate the statically initialised
+condition variable. Statically initialised condition variables are
+dynamically allocated by the first thread to wait on them. 
+</BLOCKQUOTE>
+<P>The <B>pthread_cond_destroy</B> function returns the following
+error code on error: 
+</P>
+<DL>
+		<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EINVAL</B> 
+		</DT>
+</DL>
+<P STYLE="margin-left: 2cm; margin-right: 1cm">
+The <I>cond</I> argument is invalid. 
+</P>
+<DL>
+		<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EBUSY</B> 
+		</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
+		Some threads are currently waiting on <I>cond</I>. 
+		</DD>
+</DL>
+<H2>
+<A HREF="#toc7" NAME="sect7">Author</A></H2>
+<P>Xavier Leroy &lt;Xavier.Leroy@inria.fr&gt; 
+</P>
+<P>Modified by Ross Johnson for use with <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A>.</P>
+<H2><A HREF="#toc8" NAME="sect8">See Also</A></H2>
+<P><A HREF="pthread_condattr_init.html"><B>pthread_condattr_init</B>(3)</A>
+, <A HREF="pthread_mutex_lock.html"><B>pthread_mutex_lock</B>(3)</A>
+, <A HREF="pthread_mutex_unlock.html"><B>pthread_mutex_unlock</B>(3)</A>
+, <A HREF="pthread_cancel.html"><B>pthread_cancel(3)</B></A>. 
+</P>
+<H2><A HREF="#toc9" NAME="sect9">Example</A></H2>
+<P>Consider two shared variables <I>x</I> and <I>y</I>, protected by
+the mutex <I>mut</I>, and a condition variable <I>cond</I> that is to
+be signaled whenever <I>x</I> becomes greater than <I>y</I>. 
+</P>
+<PRE STYLE="margin-left: 1cm; margin-right: 1cm">int x,y;
+pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
+pthread_cond_t cond = PTHREAD_COND_INITIALIZER;</PRE><BLOCKQUOTE>
+Waiting until <I>x</I> is greater than <I>y</I> is performed as
+follows: 
+</BLOCKQUOTE>
+<PRE STYLE="margin-left: 1.01cm">pthread_mutex_lock(&amp;mut);
+while (x &lt;= y) {
+        pthread_cond_wait(&amp;cond, &amp;mut);
+}
+/* operate on x and y */
+pthread_mutex_unlock(&amp;mut);</PRE><BLOCKQUOTE STYLE="margin-left: 3.01cm">
+Modifications on <I>x</I> and <I>y</I> that may cause <I>x</I> to
+become greater than <I>y</I> should signal the condition if needed: 
+</BLOCKQUOTE>
+<PRE STYLE="margin-left: 1.01cm">pthread_mutex_lock(&amp;mut);
+/* modify x and y */
+if (x &gt; y) pthread_cond_broadcast(&amp;cond);
+pthread_mutex_unlock(&amp;mut);</PRE><BLOCKQUOTE STYLE="margin-left: 3.01cm">
+If it can be proved that at most one waiting thread needs to be waken
+up (for instance, if there are only two threads communicating through
+<I>x</I> and <I>y</I>), <B>pthread_cond_signal</B> can be used as a
+slightly more efficient alternative to <B>pthread_cond_broadcast</B>.
+If in doubt, use <B>pthread_cond_broadcast</B>. 
+</BLOCKQUOTE>
+<BLOCKQUOTE STYLE="margin-left: 3.01cm">To wait for <I>x</I> to
+become greater than <I>y</I> with a timeout of 5 seconds, do: 
+</BLOCKQUOTE>
+<PRE STYLE="margin-left: 1.01cm">struct timeval now;
+struct timespec timeout;
+int retcode;
+pthread_mutex_lock(&amp;mut);
+gettimeofday(&amp;now);
+timeout.tv_sec = now.tv_sec + 5;
+timeout.tv_nsec = now.tv_usec * 1000;
+retcode = 0;
+while (x &lt;= y &amp;&amp; retcode != ETIMEDOUT) {
+        retcode = pthread_cond_timedwait(&amp;cond, &amp;mut, &amp;timeout);
+}
+if (retcode == ETIMEDOUT) {
+        /* timeout occurred */
+} else {
+        /* operate on x and y */
+}
+pthread_mutex_unlock(&amp;mut);</PRE>
+<HR>
+<BLOCKQUOTE STYLE="margin-left: 0cm; margin-right: 0cm"><A NAME="toc"></A>
+<B>Table of Contents</B></BLOCKQUOTE>
+<UL>
+	<LI><BLOCKQUOTE STYLE="margin-right: 0cm; margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
+		</BLOCKQUOTE>
+	<LI><BLOCKQUOTE STYLE="margin-right: 0cm; margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</BLOCKQUOTE>
+	<LI><BLOCKQUOTE STYLE="margin-right: 0cm; margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
+		</BLOCKQUOTE>
+	<LI><BLOCKQUOTE STYLE="margin-right: 0cm; margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Cancellation</A>
+		</BLOCKQUOTE>
+	<LI><BLOCKQUOTE STYLE="margin-right: 0cm; margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Async-signal
+	Safety</A> 
+	</BLOCKQUOTE>
+	<LI><BLOCKQUOTE STYLE="margin-right: 0cm; margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Return
+	Value</A> 
+	</BLOCKQUOTE>
+	<LI><BLOCKQUOTE STYLE="margin-right: 0cm; margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Errors</A>
+		</BLOCKQUOTE>
+	<LI><BLOCKQUOTE STYLE="margin-right: 0cm; margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">Author</A>
+		</BLOCKQUOTE>
+	<LI><BLOCKQUOTE STYLE="margin-right: 0cm; margin-bottom: 0cm"><A HREF="#sect8" NAME="toc8">See
+	Also</A> 
+	</BLOCKQUOTE>
+	<LI><BLOCKQUOTE STYLE="margin-right: 0cm"><A HREF="#sect9" NAME="toc9">Example</A>
+		</BLOCKQUOTE>
+</UL>
+</BODY>
+</HTML>
diff --git a/src/include/pthread/manual/pthread_condattr_init.html b/src/include/pthread/manual/pthread_condattr_init.html
new file mode 100644
index 0000000..3c6f7cf
--- /dev/null
+++ b/src/include/pthread/manual/pthread_condattr_init.html
@@ -0,0 +1,91 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
+	<TITLE>PTHREAD_CONDATTR_INIT(3) manual page</TITLE>
+</HEAD>
+<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
+<H4>POSIX Threads for Windows – REFERENCE - <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A></H4>
+<P><A HREF="index.html">Reference Index</A></P>
+<P><A HREF="#toc">Table of Contents</A></P>
+<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P>pthread_condattr_init, pthread_condattr_destroy - condition
+creation 
+</P>
+<P>attributes 
+</P>
+<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P><B>#include &lt;pthread.h&gt;</B> 
+</P>
+<P><B>int pthread_condattr_init(pthread_condattr_t *</B><I>attr</I><B>);</B>
+</P>
+<P><B>int pthread_condattr_destroy(pthread_condattr_t *</B><I>attr</I><B>);</B>
+</P>
+<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P>Condition attributes can be specified at condition creation time,
+by passing a condition attribute object as second argument to
+<A HREF="pthread_cond_init.html"><B>pthread_cond_init</B>(3)</A> .
+Passing <B>NULL</B> is equivalent to passing a condition attribute
+object with all attributes set to their default values. 
+</P>
+<P><B>pthread_condattr_init</B> initializes the condition attribute
+object <I>attr</I> and fills it with default values for the
+attributes. <B>pthread_condattr_destroy</B> destroys a condition
+attribute object, which must not be reused until it is reinitialized.</P>
+<P><B>PThreads4W</B> defines _<B>POSIX_THREAD_PROCESS_SHARED</B> in
+pthread.h as -1 to indicate that the attribute routines are
+implemented but that the process shared attribute is not supported.</P>
+<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
+<P>All condition variable functions return 0 on success and a
+non-zero error code on error.</P>
+<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
+<P>The <B>pthread_condattr_init</B> function returns the following
+error code on error: 
+</P>
+<DL>
+		<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>ENOMEM</B> 
+		</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
+		The was insufficient memory to create the attribute.<SPAN STYLE="font-weight: medium">
+		</SPAN>
+		</DD>
+</DL>
+<P>
+The <B>pthread_condattr_destroy</B> function returns the following
+error code on error: 
+</P>
+<DL>
+		<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EINVAL</B> 
+		</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
+		The <I>attr</I> argument is not valid.<SPAN STYLE="font-weight: medium">
+		</SPAN>
+		</DD>
+</DL>
+<H2>
+<A HREF="#toc5" NAME="sect5">Author</A></H2>
+<P>Xavier Leroy &lt;Xavier.Leroy@inria.fr&gt; 
+</P>
+<P>Modified by Ross Johnson for use with <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A>.</P>
+<H2><A HREF="#toc6" NAME="sect6">See Also</A></H2>
+<P><A HREF="pthread_cond_init.html"><B>pthread_cond_init</B>(3)</A> .
+</P>
+<HR>
+<P><A NAME="toc"></A><B>Table of Contents</B></P>
+<UL>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
+	Value</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Author</A>
+		</P>
+	<LI><P><A HREF="#sect6" NAME="toc6">See Also</A> 
+	</P>
+</UL>
+</BODY>
+</HTML>
diff --git a/src/include/pthread/manual/pthread_condattr_setpshared.html b/src/include/pthread/manual/pthread_condattr_setpshared.html
new file mode 100644
index 0000000..6f3b2f9
--- /dev/null
+++ b/src/include/pthread/manual/pthread_condattr_setpshared.html
@@ -0,0 +1,148 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
+	<TITLE>PTHREAD_CONDATTR_SETPSHARED(3) manual page</TITLE>
+</HEAD>
+<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
+<H4>POSIX Threads for Windows – REFERENCE - <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A></H4>
+<P><A HREF="index.html">Reference Index</A></P>
+<P><A HREF="#toc">Table of Contents</A></P>
+<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P>pthread_condattr_getpshared, pthread_condattr_setpshared - get and
+set the process-shared condition variable attributes 
+</P>
+<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P><B>#include &lt;pthread.h&gt; </B>
+</P>
+<P><B>int pthread_condattr_getpshared(const pthread_condattr_t
+*restrict</B> <I>attr</I><B>, int *restrict</B> <I>pshared</I><B>);
+<BR>int pthread_condattr_setpshared(pthread_condattr_t *</B><I>attr</I><B>,
+int</B> <I>pshared</I><B>); </B>
+</P>
+<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P>The <B>pthread_condattr_getpshared</B> function shall obtain the
+value of the <I>process-shared</I> attribute from the attributes
+object referenced by <I>attr</I>. The <B>pthread_condattr_setpshared</B>
+function shall set the <I>process-shared</I> attribute in an
+initialized attributes object referenced by <I>attr</I>. 
+</P>
+<P>The <I>process-shared</I> attribute is set to
+<B>PTHREAD_PROCESS_SHARED</B> to permit a condition variable to be
+operated upon by any thread that has access to the memory where the
+condition variable is allocated, even if the condition variable is
+allocated in memory that is shared by multiple processes. If the
+<I>process-shared</I> attribute is <B>PTHREAD_PROCESS_PRIVATE</B>,
+the condition variable shall only be operated upon by threads created
+within the same process as the thread that initialized the condition
+variable; if threads of differing processes attempt to operate on
+such a condition variable, the behavior is undefined. The default
+value of the attribute is <B>PTHREAD_PROCESS_PRIVATE</B>. 
+</P>
+<P><B>PThreads4W</B> defines _<B>POSIX_THREAD_PROCESS_SHARED</B> in
+pthread.h as -1 to indicate that these routines are implemented but
+that the process shared attribute is not supported.</P>
+<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
+<P>If successful, the <B>pthread_condattr_setpshared</B> function
+shall return zero; otherwise, an error number shall be returned to
+indicate the error. 
+</P>
+<P>If successful, the <B>pthread_condattr_getpshared</B> function
+shall return zero and store the value of the <I>process-shared</I>
+attribute of <I>attr</I> into the object referenced by the <I>pshared</I>
+parameter. Otherwise, an error number shall be returned to indicate
+the error. 
+</P>
+<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
+<P>The <B>pthread_condattr_getpshared</B> and
+<B>pthread_condattr_setpshared</B> functions may fail if: 
+</P>
+<DL>
+	<DT><B>EINVAL</B> 
+	</DT><DD STYLE="margin-bottom: 0.5cm">
+	The value specified by <I>attr</I> is invalid. 
+	</DD></DL>
+<P>
+The <B>pthread_condattr_setpshared</B> function may fail if: 
+</P>
+<DL>
+	<DT><B>EINVAL</B> 
+	</DT><DD STYLE="margin-bottom: 0.5cm">
+	The new value specified for the attribute is outside the range of
+	legal values for that attribute. 
+	</DD><DT>
+	<B>ENOSYS</B> 
+	</DT><DD STYLE="margin-bottom: 0.5cm">
+	The value specified by <I>attr</I> was <B>PTHREAD_PROCESS_SHARED</B>
+	(PThreads4W).</DD></DL>
+<P>
+These functions shall not return an error code of [EINTR]. 
+</P>
+<P><I>The following sections are informative.</I> 
+</P>
+<H2><A HREF="#toc5" NAME="sect5">Examples</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc6" NAME="sect6">Application Usage</A></H2>
+<P><B>PThreads4W</B> defines <B>_POSIX_THREAD_PROCESS_SHARED</B> in
+pthread.h as -1 to indicate that these routines are implemented and
+may be used, but do not support the process shared option.</P>
+<H2><A HREF="#toc7" NAME="sect7">Rationale</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc8" NAME="sect8">Future Directions</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc9" NAME="sect9">See Also</A></H2>
+<P><A HREF="pthread_create.html"><B>pthread_create</B>(3)</A> <B>,</B>
+<A HREF="pthread_cond_init.html"><B>pthread_cond_destroy</B>(3)</A> <B>,</B>
+<A HREF="pthread_condattr_init.html"><B>pthread_condattr_destroy</B>(3)</A>
+<B>,</B> <A HREF="pthread_mutex_init.html"><B>pthread_mutex_destroy</B>(3)</A>
+<B>,</B> the Base Definitions volume of IEEE&nbsp;Std&nbsp;1003.1-2001,
+<I>&lt;pthread.h&gt;</I> 
+</P>
+<H2><A HREF="#toc10" NAME="sect10">Copyright</A></H2>
+<P>Portions of this text are reprinted and reproduced in electronic
+form from IEEE Std 1003.1, 2003 Edition, Standard for Information
+Technology -- Portable Operating System Interface (POSIX), The Open
+Group Base Specifications Issue 6, Copyright (C) 2001-2003 by the
+Institute of Electrical and Electronics Engineers, Inc and The Open
+Group. In the event of any discrepancy between this version and the
+original IEEE and The Open Group Standard, the original IEEE and The
+Open Group Standard is the referee document. The original Standard
+can be obtained online at <A HREF="http://www.opengroup.org/unix/online.html">http://www.opengroup.org/unix/online.html</A>
+. 
+</P>
+<P>Modified by Ross Johnson for use with <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A>.</P>
+<HR>
+<P><A NAME="toc"></A><B>Table of Contents</B></P>
+<UL>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
+	Value</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Examples</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Application
+	Usage</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">Rationale</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect8" NAME="toc8">Future
+	Directions</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect9" NAME="toc9">See
+	Also</A> 
+	</P>
+	<LI><P><A HREF="#sect10" NAME="toc10">Copyright</A> 
+	</P>
+</UL>
+</BODY>
+</HTML>
diff --git a/src/include/pthread/manual/pthread_create.html b/src/include/pthread/manual/pthread_create.html
new file mode 100644
index 0000000..9d58eaf
--- /dev/null
+++ b/src/include/pthread/manual/pthread_create.html
@@ -0,0 +1,114 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=windows-1252">
+	<TITLE>PTHREAD_CREATE(3) manual page</TITLE>
+	<META NAME="GENERATOR" CONTENT="OpenOffice 4.1.1  (Win32)">
+	<META NAME="CREATED" CONTENT="0;0">
+	<META NAME="CHANGEDBY" CONTENT="Ross Johnson">
+	<META NAME="CHANGED" CONTENT="20160229;20085251">
+	<STYLE TYPE="text/css">
+	<!--
+		H4.cjk { font-family: "SimSun" }
+		H4.ctl { font-family: "Mangal" }
+		H2.cjk { font-family: "SimSun" }
+		H2.ctl { font-family: "Mangal" }
+	-->
+	</STYLE>
+</HEAD>
+<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
+<H4 CLASS="western">POSIX Threads for Windows &ndash; REFERENCE -
+<A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A></H4>
+<P><A HREF="index.html">Reference Index</A></P>
+<P><A HREF="#toc">Table of Contents</A></P>
+<H2 CLASS="western"><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P>pthread_create - create a new thread 
+</P>
+<H2 CLASS="western"><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P><B>#include &lt;pthread.h&gt;</B> 
+</P>
+<P><B>int pthread_create(pthread_t * </B><I>thread</I><B>,
+pthread_attr_t * </B><I>attr</I><B>, void * (*</B><I>start_routine</I><B>)(void
+*), void * </B><I>arg</I><B>);</B> 
+</P>
+<H2 CLASS="western"><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P><B>pthread_create</B> creates a new thread of control that
+executes concurrently with the calling thread. The new thread applies
+the function <I>start_routine</I> passing it <I>arg</I> as first
+argument. The new thread terminates either explicitly, by calling
+<A HREF="pthread_exit.html"><B>pthread_exit</B>(3)</A> , or
+implicitly, by returning from the <I>start_routine</I> function. The
+latter case is equivalent to calling <A HREF="pthread_exit.html"><B>pthread_exit</B>(3)</A>
+with the result returned by <I>start_routine</I> as exit code. 
+</P>
+<P>The initial signal state of the new thread is inherited from it's
+creating thread and there are no pending signals. <B>PThreads4W</B>
+does not yet implement signals.</P>
+<P>The initial CPU affinity of the new thread is inherited from it's
+creating thread. A threads CPU affinity can be obtained through
+<A HREF="pthread_setaffinity_np.html"><B>pthread_getaffinity_np(3)</B></A>
+and may be changed through <A HREF="pthread_setaffinity_np.html"><B>pthread_setaffinity_np(3)</B></A>.
+Unless changed, all threads inherit the CPU affinity of the parent
+process. See <A HREF="sched_setaffinity.html"><B>sched_getaffinity(3)</B></A>
+and <A HREF="sched_setaffinity.html"><B>sched_setaffinity(3)</B></A>.</P>
+<P>The <I>attr</I> argument specifies thread attributes to be applied
+to the new thread. See <A HREF="pthread_attr_init.html"><B>pthread_attr_init</B>(3)</A>
+for a complete list of thread attributes. The <I>attr</I> argument
+can also be <B>NULL</B>, in which case default attributes are used:
+the created thread is joinable (not detached) and has default (non
+real-time) scheduling policy. 
+</P>
+<H2 CLASS="western"><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
+<P>On success, the identifier of the newly created thread is stored
+in the location pointed by the <I>thread</I> argument, and a 0 is
+returned. On error, a non-zero error code is returned. 
+</P>
+<H2 CLASS="western"><A HREF="#toc4" NAME="sect4">Errors</A></H2>
+<DL>
+	<DL>
+		<DT STYLE="margin-left: 0.25cm"><B>EAGAIN</B></DT><DL>
+			<DL>
+				<DT STYLE="margin-left: -0.5cm; margin-bottom: 0.5cm">
+				Not enough system resources to create a process for the new
+				thread, or<BR>more than <B>PTHREAD_THREADS_MAX</B> threads are
+				already active. 
+				</DT></DL>
+		</DL>
+	</DL>
+</DL>
+<H2 CLASS="western">
+<A HREF="#toc5" NAME="sect5">Author</A></H2>
+<P>Xavier Leroy &lt;Xavier.Leroy@inria.fr&gt; 
+</P>
+<P>Modified by Ross Johnson for use with <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A>.</P>
+<H2 CLASS="western"><A HREF="#toc6" NAME="sect6">See Also</A></H2>
+<P><A HREF="pthread_exit.html"><B>pthread_exit</B>(3)</A> ,
+<A HREF="pthread_join.html"><B>pthread_join</B>(3)</A> ,
+<A HREF="pthread_detach.html"><B>pthread_detach</B>(3)</A> ,
+<A HREF="pthread_attr_init.html"><B>pthread_attr_init</B>(3)</A> ,
+<A HREF="pthread_setaffinity_np.html"><B>pthread_getaffinity_np(3)</B></A>
+, <A HREF="pthread_setaffinity_np.html"><B>pthread_setaffinity_np(3)</B></A>
+, <A HREF="sched_setaffinity.html"><B>sched_getaffinity(3)</B></A> ,
+<A HREF="sched_setaffinity.html"><B>sched_setaffinity(3)</B></A> . 
+</P>
+<HR>
+<P><A NAME="toc"></A><B>Table of Contents</B></P>
+<UL>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
+	Value</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Author</A>
+		</P>
+	<LI><P><A HREF="#sect6" NAME="toc6">See Also</A> 
+	</P>
+</UL>
+</BODY>
+</HTML>
\ No newline at end of file
diff --git a/src/include/pthread/manual/pthread_delay_np.html b/src/include/pthread/manual/pthread_delay_np.html
new file mode 100644
index 0000000..6570444
--- /dev/null
+++ b/src/include/pthread/manual/pthread_delay_np.html
@@ -0,0 +1,66 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
+	<TITLE>PTHREAD_DELAY_NP(3) manual page</TITLE>
+</HEAD>
+<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
+<H4>POSIX Threads for Windows – REFERENCE - <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A></H4>
+<P><A HREF="index.html">Reference Index</A></P>
+<P><A HREF="#toc">Table of Contents</A></P>
+<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P STYLE="font-weight: medium">pthread_delay_np – suspend the
+thread for a specified period</P>
+<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P><B>#include &lt;pthread.h&gt;</B> 
+</P>
+<P><B>int pthread_delay_np (const struct timespec *</B>interval<B>);</B></P>
+<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P><B>pthread_delay_np</B> causes a thread to delay execution for a
+specific period of time. This period ends at the current time plus
+the specified interval. The routine will not return before the end of
+the period is reached, but may return an arbitrary amount of time
+after the period has gone by. This can be due to system load, thread
+priorities, and system timer granularity.</P>
+<P>Specifying an interval of zero (0) seconds and zero (0)
+nanoseconds is allowed and can be used to force the thread to give up
+the processor or to deliver a pending cancellation request.</P>
+<H2><A HREF="#toc3" NAME="sect3">Cancellation</A></H2>
+<P><B>pthread_delay_np </B>is a cancellation point.</P>
+<H2><A HREF="#toc4" NAME="sect4">Return Value</A></H2>
+<P>If an error condition occurs, <B>pthread_delay_np</B> returns an
+integer value indicating the type of error.</P>
+<H2><A HREF="#toc5" NAME="sect5">Errors</A></H2>
+<P>The <B>pthread_delay_np</B> function returns the following error
+code on error: 
+</P>
+<DL>
+	<DL>
+		<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EINVAL</B> 
+		</DT></DL>
+</DL>
+<P STYLE="margin-left: 2cm">
+The value specified by interval is invalid.</P>
+<H2><A HREF="#toc6" NAME="sect6">Author</A></H2>
+<P>Ross Johnson for use with <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A>.</P>
+<HR>
+<P><A NAME="toc"></A><B>Table of Contents</B></P>
+<UL>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Cancellation</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Return
+	Value</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Errors</A>
+		</P>
+	<LI><P><A HREF="#sect6" NAME="toc6">Author</A> 
+	</P>
+</UL>
+</BODY>
+</HTML>
diff --git a/src/include/pthread/manual/pthread_detach.html b/src/include/pthread/manual/pthread_detach.html
new file mode 100644
index 0000000..779b032
--- /dev/null
+++ b/src/include/pthread/manual/pthread_detach.html
@@ -0,0 +1,84 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
+	<TITLE>PTHREAD_DETACH(3) manual page</TITLE>
+</HEAD>
+<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
+<H4>POSIX Threads for Windows – REFERENCE - <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A></H4>
+<P><A HREF="index.html">Reference Index</A></P>
+<P><A HREF="#toc">Table of Contents</A></P>
+<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P>pthread_detach - put a running thread in the detached state 
+</P>
+<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P><B>#include &lt;pthread.h&gt;</B> 
+</P>
+<P><B>int pthread_detach(pthread_t </B><I>th</I><B>);</B> 
+</P>
+<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P><B>pthread_detach</B> puts the thread <I>th</I> in the detached
+state. This guarantees that the resources consumed by <I>th</I> will
+be freed immediately when <I>th</I> terminates. However, this
+prevents other threads from synchronizing on the termination of <I>th</I>
+using <B>pthread_join</B>. If, when <B>pthread_detach</B> is called,
+<I>th</I> has already terminated, all of <I>th</I>'s remaining
+resources will be freed.</P>
+<P>A thread can be created initially in the detached state, using the
+<B>detachstate</B> attribute to <A HREF="pthread_create.html"><B>pthread_create</B>(3)</A>
+. In contrast, <B>pthread_detach</B> applies to threads created in
+the joinable state, and which need to be put in the detached state
+later. 
+</P>
+<P>After <B>pthread_detach</B> completes, subsequent attempts to
+perform <B>pthread_join</B> on <I>th</I> will fail. If another thread
+is already joining the thread <I>th</I> at the time <B>pthread_detach</B>
+is called, <I>th</I> will be detached and <B>pthread_join</B> will
+eventually return when <I>th</I> terminates but may not return with
+<I>th</I>'s correct return code. 
+</P>
+<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
+<P>On success, 0 is returned. On error, a non-zero error code is
+returned. 
+</P>
+<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
+<DL>
+	<DT><B>ESRCH</B> 
+	</DT><DD>
+	No thread could be found corresponding to that specified by <I>th</I>
+		</DD><DT>
+	<B>EINVAL</B> 
+	</DT><DD STYLE="margin-bottom: 0.5cm">
+	the thread <I>th</I> is already in the detached state 
+	</DD></DL>
+<H2>
+<A HREF="#toc5" NAME="sect5">Author</A></H2>
+<P>Xavier Leroy &lt;Xavier.Leroy@inria.fr&gt; 
+</P>
+<P>Modified by Ross Johnson for use with PThreads4W.</P>
+<H2><A HREF="#toc6" NAME="sect6">See Also</A></H2>
+<P><A HREF="pthread_create.html"><B>pthread_create</B>(3)</A> ,
+<A HREF="pthread_join.html"><B>pthread_join</B>(3)</A> ,
+<A HREF="pthread_attr_init.html"><B>pthread_attr_setdetachstate</B>(3)</A>
+</P>
+<HR>
+<P><A NAME="toc"></A><B>Table of Contents</B></P>
+<UL>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
+	Value</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Author</A>
+		</P>
+	<LI><P><A HREF="#sect6" NAME="toc6">See Also</A> 
+	</P>
+</UL>
+</BODY>
+</HTML>
\ No newline at end of file
diff --git a/src/include/pthread/manual/pthread_equal.html b/src/include/pthread/manual/pthread_equal.html
new file mode 100644
index 0000000..4503e66
--- /dev/null
+++ b/src/include/pthread/manual/pthread_equal.html
@@ -0,0 +1,63 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=windows-1252">
+	<TITLE>PTHREAD_EQUAL(3) manual page</TITLE>
+	<META NAME="GENERATOR" CONTENT="OpenOffice 4.1.1  (Win32)">
+	<META NAME="CREATED" CONTENT="0;0">
+	<META NAME="CHANGEDBY" CONTENT="Ross Johnson">
+	<META NAME="CHANGED" CONTENT="20160229;19421115">
+	<STYLE TYPE="text/css">
+	<!--
+		H2.cjk { font-family: "SimSun" }
+		H2.ctl { font-family: "Mangal" }
+	-->
+	</STYLE>
+</HEAD>
+<BODY LANG="en-AU" BGCOLOR="#ffffff" DIR="LTR">
+<P LANG="en-GB"><A HREF="#toc">Table of Contents</A></P>
+<H2 LANG="en-GB" CLASS="western"><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P LANG="en-GB">pthread_equal - compare two thread identifiers 
+</P>
+<H2 LANG="en-GB" CLASS="western"><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P LANG="en-GB"><B>#include &lt;pthread.h&gt;</B> 
+</P>
+<P LANG="en-GB"><B>int pthread_equal(pthread_t </B><I>thread1</I><B>,
+pthread_t </B><I>thread2</I><B>);</B> 
+</P>
+<H2 LANG="en-GB" CLASS="western"><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P LANG="en-GB"><B>pthread_equal</B> determines if two thread
+identifiers refer to the same thread. 
+</P>
+<H2 LANG="en-GB" CLASS="western"><A HREF="#toc3" NAME="sect3">Return
+Value</A></H2>
+<P LANG="en-GB">A non-zero value is returned if <I>thread1</I> and
+<I>thread2</I> refer to the same thread. Otherwise, 0 is returned. 
+</P>
+<H2 LANG="en-GB" CLASS="western"><A HREF="#toc4" NAME="sect4">Author</A></H2>
+<P LANG="en-GB">Xavier Leroy &lt;Xavier.Leroy@inria.fr&gt; 
+</P>
+<H2 LANG="en-GB" CLASS="western"><A HREF="#toc5" NAME="sect5">See
+Also</A></H2>
+<P LANG="en-GB"><A HREF="pthread_self.html"><B>pthread_self</B>(3)</A>
+. 
+</P>
+<HR>
+<P LANG="en-GB"><A NAME="toc"></A><B>Table of Contents</B></P>
+<UL>
+	<LI><P LANG="en-GB" STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
+		</P>
+	<LI><P LANG="en-GB" STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</P>
+	<LI><P LANG="en-GB" STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
+		</P>
+	<LI><P LANG="en-GB" STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
+	Value</A> 
+	</P>
+	<LI><P LANG="en-GB" STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Author</A>
+		</P>
+	<LI><P LANG="en-GB"><A HREF="#sect5" NAME="toc5">See Also</A> 
+	</P>
+</UL>
+</BODY>
+</HTML>
\ No newline at end of file
diff --git a/src/include/pthread/manual/pthread_exit.html b/src/include/pthread/manual/pthread_exit.html
new file mode 100644
index 0000000..715bf61
--- /dev/null
+++ b/src/include/pthread/manual/pthread_exit.html
@@ -0,0 +1,71 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=windows-1252">
+	<TITLE>PTHREAD_EXIT(3) manual page</TITLE>
+	<META NAME="GENERATOR" CONTENT="OpenOffice 4.1.1  (Win32)">
+	<META NAME="CREATED" CONTENT="0;0">
+	<META NAME="CHANGEDBY" CONTENT="Ross Johnson">
+	<META NAME="CHANGED" CONTENT="20160229;19455468">
+	<STYLE TYPE="text/css">
+	<!--
+		H2.cjk { font-family: "SimSun" }
+		H2.ctl { font-family: "Mangal" }
+	-->
+	</STYLE>
+</HEAD>
+<BODY LANG="en-AU" BGCOLOR="#ffffff" DIR="LTR">
+<P LANG="en-GB"><A HREF="#toc">Table of Contents</A></P>
+<H2 LANG="en-GB" CLASS="western"><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P LANG="en-GB">pthread_exit - terminate the calling thread 
+</P>
+<H2 LANG="en-GB" CLASS="western"><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P LANG="en-GB"><B>#include &lt;pthread.h&gt;</B> 
+</P>
+<P LANG="en-GB"><B>void pthread_exit(void *</B><I>retval</I><B>);</B>
+</P>
+<H2 LANG="en-GB" CLASS="western"><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P LANG="en-GB"><B>pthread_exit</B> terminates the execution of the
+calling thread. All cleanup handlers that have been set for the
+calling thread with <A HREF="pthread_cleanup_push.html"><B>pthread_cleanup_push</B>(3)</A>
+are executed in reverse order (the most recently pushed handler is
+executed first). Finalization functions for thread-specific data are
+then called for all keys that have non- <B>NULL</B> values associated
+with them in the calling thread (see <A HREF="pthread_key_create.html"><B>pthread_key_create</B>(3)</A>
+). Finally, execution of the calling thread is stopped. 
+</P>
+<P LANG="en-GB">The <I>retval</I> argument is the return value of the
+thread. It can be consulted from another thread using <A HREF="pthread_join.html"><B>pthread_join</B>(3)</A>
+. 
+</P>
+<H2 LANG="en-GB" CLASS="western"><A HREF="#toc3" NAME="sect3">Return
+Value</A></H2>
+<P LANG="en-GB">The <B>pthread_exit</B> function never returns. 
+</P>
+<H2 LANG="en-GB" CLASS="western"><A HREF="#toc4" NAME="sect4">Author</A></H2>
+<P LANG="en-GB">Xavier Leroy &lt;Xavier.Leroy@inria.fr&gt; 
+</P>
+<H2 LANG="en-GB" CLASS="western"><A HREF="#toc5" NAME="sect5">See
+Also</A></H2>
+<P LANG="en-GB"><A HREF="pthread_create.html"><B>pthread_create</B>(3)</A>
+, <A HREF="pthread_join.html"><B>pthread_join</B>(3)</A> . 
+</P>
+<HR>
+<P LANG="en-GB"><A NAME="toc"></A><B>Table of Contents</B></P>
+<UL>
+	<LI><P LANG="en-GB" STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
+		</P>
+	<LI><P LANG="en-GB" STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</P>
+	<LI><P LANG="en-GB" STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
+		</P>
+	<LI><P LANG="en-GB" STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
+	Value</A> 
+	</P>
+	<LI><P LANG="en-GB" STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Author</A>
+		</P>
+	<LI><P LANG="en-GB"><A HREF="#sect5" NAME="toc5">See Also</A> 
+	</P>
+</UL>
+</BODY>
+</HTML>
\ No newline at end of file
diff --git a/src/include/pthread/manual/pthread_getunique_np.html b/src/include/pthread/manual/pthread_getunique_np.html
new file mode 100644
index 0000000..191d43e
--- /dev/null
+++ b/src/include/pthread/manual/pthread_getunique_np.html
@@ -0,0 +1,69 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
+	<TITLE>PTHREAD_GETUNIQUE_NP(3) manual page</TITLE>
+	<STYLE TYPE="text/css">
+	<!--
+		H4.cjk { font-family: "AR PL UMing CN" }
+		H4.ctl { font-family: "Lohit Devanagari" }
+		H2.cjk { font-family: "AR PL UMing CN" }
+		H2.ctl { font-family: "Lohit Devanagari" }
+	-->
+	</STYLE>
+</HEAD>
+<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
+<H4 CLASS="western">POSIX Threads for Windows – REFERENCE -
+<A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A></H4>
+<P><A HREF="index.html">Reference Index</A></P>
+<P><A HREF="#toc">Table of Contents</A></P>
+<H2 CLASS="western"><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P STYLE="font-weight: normal">pthread_getunique_np – get the
+unique sequence number associated with a thread</P>
+<H2 CLASS="western"><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P><B>#include &lt;pthread.h&gt;</B> 
+</P>
+<P><B>unsigned long long pthread_getunique_np(pthread_t</B> <I>thread</I><B>);</B></P>
+<H2 CLASS="western"><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P>Returns the <B>unique </B><SPAN STYLE="font-weight: normal">64 bit
+sequence number</SPAN> assigned to <I>thread</I>.</P>
+<P>In <B>PThreads4W:</B></P>
+<UL>
+	<LI><P>the value returned is not reused after the thread terminates
+	so it is unique for the life of the process</P>
+	<LI><P>Windows native threads may obtain their own POSIX thread
+	sequence number by first retrieving their <B>pthread_t</B> handle
+	via <B>pthread_self</B> to use as the <I>thread</I> argument.</P>
+</UL>
+<P>This function was added for source code compatibility with some
+other POSIX threads implementations.</P>
+<H2 CLASS="western"><A HREF="#toc3" NAME="sect3">Cancellation</A></H2>
+<P>None.</P>
+<H2 CLASS="western"><A HREF="#toc4" NAME="sect4">Return Value</A></H2>
+<P><B>pthread_getunique_np</B> returns the unique sequence number for
+<I>thread</I>.</P>
+<H2 CLASS="western"><A HREF="#toc5" NAME="sect5">Errors</A></H2>
+<P>None.</P>
+<H2 CLASS="western"><A HREF="#toc6" NAME="sect6">Author</A></H2>
+<P>Ross Johnson for use with <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A>.</P>
+<HR>
+<P><A NAME="toc"></A><B>Table of Contents</B></P>
+<UL>
+	<LI><P STYLE="margin-bottom: 0in"><A HREF="#sect0" NAME="toc0">Name</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0in"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0in"><A HREF="#sect2" NAME="toc2">Description</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0in"><A HREF="#sect3" NAME="toc3">Cancellation</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0in"><A HREF="#sect4" NAME="toc4">Return
+	Value</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0in"><A HREF="#sect5" NAME="toc5">Errors</A>
+		</P>
+	<LI><P><A HREF="#sect6" NAME="toc6">Author</A> 
+	</P>
+</UL>
+</BODY>
+</HTML>
\ No newline at end of file
diff --git a/src/include/pthread/manual/pthread_getw32threadhandle_np.html b/src/include/pthread/manual/pthread_getw32threadhandle_np.html
new file mode 100644
index 0000000..d4899c3
--- /dev/null
+++ b/src/include/pthread/manual/pthread_getw32threadhandle_np.html
@@ -0,0 +1,52 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
+	<TITLE>PTHREAD_GETW32THREADHANDLE_NP(3) manual page</TITLE>
+</HEAD>
+<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
+<H4>POSIX Threads for Windows – REFERENCE - <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A></H4>
+<P><A HREF="index.html">Reference Index</A></P>
+<P><A HREF="#toc">Table of Contents</A></P>
+<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P STYLE="font-weight: medium">pthread_getw32threadhandle_np – get
+the Win32 thread handle associated with a thread</P>
+<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P><B>#include &lt;pthread.h&gt;</B> 
+</P>
+<P><B>HANDLE pthread_getw32threadhandle_np(pthread_t</B> <I>thread</I><B>);</B></P>
+<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P>Returns the Win32 native thread <B>HANDLE</B> that the POSIX
+thread <I>thread</I> is running as.</P>
+<P>Applications can use the Win32 handle to set Win32 specific
+attributes of the thread.</P>
+<H2><A HREF="#toc3" NAME="sect3">Cancellation</A></H2>
+<P>None.</P>
+<H2><A HREF="#toc4" NAME="sect4">Return Value</A></H2>
+<P><B>pthread_getw32threadhandle_np</B> returns the Win32 native
+thread <B>HANDLE</B> for the specified POSIX thread <I>thread</I>.</P>
+<H2><A HREF="#toc5" NAME="sect5">Errors</A></H2>
+<P>None.</P>
+<H2><A HREF="#toc6" NAME="sect6">Author</A></H2>
+<P>Ross Johnson for use with <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A>.</P>
+<HR>
+<P><A NAME="toc"></A><B>Table of Contents</B></P>
+<UL>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Cancellation</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Return
+	Value</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Errors</A>
+		</P>
+	<LI><P><A HREF="#sect6" NAME="toc6">Author</A> 
+	</P>
+</UL>
+</BODY>
+</HTML>
diff --git a/src/include/pthread/manual/pthread_join.html b/src/include/pthread/manual/pthread_join.html
new file mode 100644
index 0000000..f470cdd
--- /dev/null
+++ b/src/include/pthread/manual/pthread_join.html
@@ -0,0 +1,150 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=windows-1252">
+	<TITLE>PTHREAD_JOIN(3) manual page</TITLE>
+	<STYLE TYPE="text/css">
+	<!--
+		H4.cjk { font-family: "SimSun" }
+		H4.ctl { font-family: "Mangal" }
+		H2.cjk { font-family: "SimSun" }
+		H2.ctl { font-family: "Mangal" }
+	-->
+	</STYLE>
+</HEAD>
+<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
+<H4 CLASS="western">POSIX Threads for Windows &ndash; REFERENCE -
+<A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A></H4>
+<P><A HREF="index.html">Reference Index</A></P>
+<P><A HREF="#toc">Table of Contents</A></P>
+<H2 CLASS="western"><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P>pthread_join - wait for termination of another thread</P>
+<P>pthread_timedjoin_np - wait for termination of another thread with
+a timeout 
+</P>
+<P>pthread_tryjoin_np &ndash; join another thread without waiting</P>
+<H2 CLASS="western"><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P><B>#include &lt;pthread.h&gt;</B> 
+</P>
+<P><B>int pthread_join(pthread_t </B><I>th</I><B>, void
+**</B><I>thread_return</I><B>);</B> 
+</P>
+<P><B>int pthread_timedjoin_np(pthread_t </B><I>th</I><B>, void
+**</B><I>thread_return, </I><SPAN STYLE="font-style: normal"><B>const
+struct timespec *</B></SPAN><I>abstime</I><B>);</B> 
+</P>
+<P><B>int pthread_tryjoin_np(pthread_t </B><I>th</I><B>, void
+**</B><I>thread_return</I><B>);</B> 
+</P>
+<H2 CLASS="western"><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P><B>pthread_join</B> suspends the execution of the calling thread
+until the thread identified by <I>th</I> terminates, either by
+calling <A HREF="pthread_exit.html"><B>pthread_exit</B>(3)</A> or by
+being cancelled. 
+</P>
+<P>If <I>thread_return</I> is not <B>NULL</B>, the return value of <I>th</I>
+is stored in the location pointed to by <I>thread_return</I>. The
+return value of <I>th</I> is either the argument it gave to
+<A HREF="pthread_exit.html"><B>pthread_exit</B>(3)</A> , or
+<B>PTHREAD_CANCELED</B> if <I>th</I> was cancelled. 
+</P>
+<P>The joined thread <I><SPAN STYLE="font-weight: normal">th</SPAN></I>
+must be in the joinable state: it must not have been detached using
+<A HREF="pthread_detach.html"><B>pthread_detach</B>(3)</A> or the
+<B>PTHREAD_CREATE_DETACHED</B> attribute to <A HREF="pthread_create.html"><B>pthread_create</B>(3)</A>
+. 
+</P>
+<P>When a joinable thread terminates, its memory resources (thread
+descriptor and stack) are not deallocated until another thread
+performs <B>pthread_join</B> on it. Therefore, <B>pthread_join</B>
+must be called once for each joinable thread created to avoid memory
+leaks.</P>
+<P><B>pthread_timedjoin_np</B> is identical to pthread_join except
+that it will return the error ETIMEDOUT if the target thread <I>th</I>
+has not exited before <I>abstime</I> passes. If <I>abstime</I> is
+NULL the function will wait forever and it's behaviour will therefore
+be identical to pthread_join.</P>
+<P><B>pthread_tryjoin_np</B> is identical to pthread_join except that
+it will return immediately with the error EBUSY if the target thread
+<I>th</I> has not exited.</P>
+<P>At most one thread can wait for the termination of a given thread.
+Calling <B>pthread_join</B> on a thread <I>th</I> on which another
+thread is already waiting for termination returns an error. 
+</P>
+<H2 CLASS="western"><A HREF="#toc3" NAME="sect3">Cancellation</A></H2>
+<P><B>pthread_join, pthread_tryjoin_np</B> <SPAN STYLE="font-weight: normal">and
+</SPAN><B>pthread_timedjoin_np</B> are cancellation points. If a
+thread is cancelled while suspended in <SPAN STYLE="font-weight: normal">either
+function</SPAN>, the thread execution resumes immediately and the
+cancellation is executed without waiting for the <I>th</I> thread to
+terminate. If cancellation occurs during either function, the <I>th</I>
+thread remains not joined. 
+</P>
+<H2 CLASS="western"><A HREF="#toc4" NAME="sect4">Return Value</A></H2>
+<P>On success, the return value of <I>th</I> is stored in the
+location pointed to by <I>thread_return</I>, and 0 is returned. On
+error, a non-zero error code is returned. 
+</P>
+<H2 CLASS="western"><A HREF="#toc5" NAME="sect5">Errors</A></H2>
+<DL>
+	<DT><B>ESRCH</B> 
+	</DT><DD>
+	No thread could be found corresponding to that specified by <I>th</I>.
+		</DD><DT>
+	<B>EINVAL</B> 
+	</DT><DD>
+	The <I>th</I> thread has been detached. 
+	</DD><DT>
+	<B>EINVAL</B> 
+	</DT><DD>
+	Another thread is already waiting on termination of <I>th</I>. 
+	</DD><DT>
+	<B>ETIMEDOUT</B> 
+	</DT><DD>
+	<SPAN STYLE="font-style: normal"><SPAN STYLE="font-weight: normal">(pthread_timedjoin_np
+	only):</SPAN></SPAN> <I>abstime</I> <SPAN STYLE="font-style: normal">passed
+	before </SPAN><I>th</I> <SPAN STYLE="font-style: normal">could be
+	joined</SPAN>. 
+	</DD><DT>
+	<B>EDEADLK</B> 
+	</DT><DD STYLE="margin-bottom: 0.5cm">
+	The <I>th</I> argument refers to the calling thread. 
+	</DD></DL>
+<H2 CLASS="western">
+<A HREF="#toc6" NAME="sect6">Author</A></H2>
+<P>Xavier Leroy &lt;Xavier.Leroy@inria.fr&gt; 
+</P>
+<P>Modified by Ross Johnson for use with <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A>.
+</P>
+<H2 CLASS="western"><A HREF="#toc7" NAME="sect7">See Also</A></H2>
+<P><A HREF="pthread_exit.html"><B>pthread_exit</B>(3)</A> ,
+<A HREF="pthread_detach.html"><B>pthread_detach</B>(3)</A> ,
+<A HREF="pthread_create.html"><B>pthread_create</B>(3)</A> ,
+<A HREF="pthread_attr_setdetachstate.html"><B>pthread_attr_setdetachstate</B>(3)</A>
+, <A HREF="pthread_cleanup_push.html"><B>pthread_cleanup_push</B>(3)</A>
+, <A HREF="pthread_key_create.html"><B>pthread_key_create</B>(3)</A>
+. 
+</P>
+<HR>
+<P><A NAME="toc"></A><B>Table of Contents</B></P>
+<UL>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Cancellation</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Return
+	Value</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Errors</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Author</A>
+		</P>
+	<LI><P><A HREF="#sect7" NAME="toc7">See Also</A> 
+	</P>
+</UL>
+</BODY>
+</HTML>
\ No newline at end of file
diff --git a/src/include/pthread/manual/pthread_key_create.html b/src/include/pthread/manual/pthread_key_create.html
new file mode 100644
index 0000000..3f1d566
--- /dev/null
+++ b/src/include/pthread/manual/pthread_key_create.html
@@ -0,0 +1,206 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
+	<TITLE>PTHREAD_KEY_CREATE(3) manual page</TITLE>
+</HEAD>
+<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
+<H4>POSIX Threads for Windows – REFERENCE - <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A></H4>
+<P><A HREF="index.html">Reference Index</A></P>
+<P><A HREF="#toc">Table of Contents</A></P>
+<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P>pthread_key_create, pthread_key_delete, pthread_setspecific,
+pthread_getspecific - management of thread-specific data 
+</P>
+<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P><B>#include &lt;pthread.h&gt;</B> 
+</P>
+<P><B>int pthread_key_create(pthread_key_t *</B><I>key</I><B>, void
+(*</B><I>destr_function</I><B>) (void *));</B> 
+</P>
+<P><B>int pthread_key_delete(pthread_key_t </B><I>key</I><B>);</B> 
+</P>
+<P><B>int pthread_setspecific(pthread_key_t </B><I>key</I><B>, const
+void *</B><I>pointer</I><B>);</B> 
+</P>
+<P><B>void * pthread_getspecific(pthread_key_t </B><I>key</I><B>);</B>
+</P>
+<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P>Programs often need global or static variables that have different
+values in different threads. Since threads share one memory space,
+this cannot be achieved with regular variables. Thread-specific data
+is the POSIX threads answer to this need. 
+</P>
+<P>Each thread possesses a private memory block, the thread-specific
+data area, or TSD area for short. This area is indexed by TSD keys.
+The TSD area associates values of type <B>void *</B> to TSD keys. TSD
+keys are common to all threads, but the value associated with a given
+TSD key can be different in each thread. 
+</P>
+<P>For concreteness, the TSD areas can be viewed as arrays of <B>void
+*</B> pointers, TSD keys as integer indices into these arrays, and
+the value of a TSD key as the value of the corresponding array
+element in the calling thread. 
+</P>
+<P>When a thread is created, its TSD area initially associates <B>NULL</B>
+with all keys. 
+</P>
+<P><B>pthread_key_create</B> allocates a new TSD key. The key is
+stored in the location pointed to by <I>key</I>. There is a limit of
+<B>PTHREAD_KEYS_MAX</B> on the number of keys allocated at a given
+time. The value initially associated with the returned key is <B>NULL</B>
+in all currently executing threads. 
+</P>
+<P>The <I>destr_function</I> argument, if not <B>NULL</B>, specifies
+a destructor function associated with the key. When a thread
+terminates via <B>pthread_exit</B> or by cancellation, <I>destr_function</I>
+is called with arguments the value associated with the key in that
+thread. The <I>destr_function</I> is not called if that value is <B>NULL</B><SPAN STYLE="font-weight: medium">
+or the key has been deleted</SPAN>. The order in which destructor
+functions are called at thread termination time is unspecified. 
+</P>
+<P>Before the destructor function is called, the <B>NULL</B> value is
+associated with the key in the current thread. A destructor function
+might, however, re-associate non- <B>NULL</B> values to that key or
+some other key. To deal with this, if after all the destructors have
+been called for all non- <B>NULL</B> values, there are still some
+non- <B>NULL</B> values with associated destructors, then the process
+is repeated.</P>
+<P><B>pthread_key_delete</B> deallocates a TSD key. It does not check
+whether non- <B>NULL</B> values are associated with that key in the
+currently executing threads, nor call the destructor function
+associated with the key. 
+</P>
+<P><B>pthread_setspecific</B> changes the value associated with <I>key</I>
+in the calling thread, storing the given <I>pointer</I> instead. 
+</P>
+<P><B>pthread_getspecific</B> returns the value currently associated
+with <I>key</I> in the calling thread. 
+</P>
+<P>The routines <B>pthread_setspecific</B>, <B>pthread_getspecific</B>,
+and <B>pthread_key_delete</B> can be called from <I>destr_function</I>
+targeting any valid key including the key on which <I>destr_function</I>
+is currently operating. If <B>pthread_getspecific</B> is called on
+the key whose thread specific data is being destroyed, the value NULL
+is returned, unless <B>pthread_setspecific</B> was called previously
+on that key from within <I>destr_function</I> to set the value to
+non-NULL. For some implementations the effect of calling
+<B>pthread_setspecific</B> from within <I>destr_function</I> can be
+either memory leakage or infinite loops if <I>destr_function</I> has
+already been called at least <B>PTHREAD_DESTRUCTOR_ITERATIONS</B>
+times.</P>
+<P STYLE="font-weight: medium"><B>PThreads4W</B> stops running key
+<I>destr_function</I> routines after <B>PTHREAD_DESTRUCTOR_ITERATIONS</B>
+iterations, even if some non- <B>NULL</B> values with associated
+descriptors remain. If memory is allocated and associated with a key
+from within <I>destr_function</I>, that memory may not be reclaimed
+because that key's <I>destr_function</I>, may not run again.</P>
+<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
+<P><B>pthread_key_create</B>, <B>pthread_key_delete</B>, and
+<B>pthread_setspecific</B> return 0 on success and a non-zero error
+code on failure. If successful, <B>pthread_key_create</B> stores the
+newly allocated key in the location pointed to by its <I>key</I>
+argument. 
+</P>
+<P><B>pthread_getspecific</B> returns the value associated with <I>key</I>
+on success, and <B>NULL</B> on error. 
+</P>
+<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
+<P><B>pthread_key_create</B> returns the following error code on
+error: 
+</P>
+<DL>
+	<DL>
+		<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EAGAIN</B> 
+		</DT></DL>
+</DL>
+<BLOCKQUOTE STYLE="margin-left: 5cm">
+<B>PTHREAD_KEYS_MAX</B> keys are already allocated 
+</BLOCKQUOTE>
+<DL>
+	<DL>
+		<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>ENOMEM</B> 
+		</DT></DL>
+</DL>
+<BLOCKQUOTE STYLE="margin-left: 5cm">
+Insufficient memory to allocate the key. 
+</BLOCKQUOTE>
+<P><B>pthread_key_delete</B> and <B>pthread_setspecific</B> return
+the following error code on error: 
+</P>
+<DL>
+	<DL>
+		<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EINVAL</B> 
+		</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
+		<I>key</I> is not a valid, allocated TSD key 
+		</DD></DL>
+</DL>
+<P>
+<B>pthread_getspecific</B> returns <B>NULL</B> if <I>key</I> is not a
+valid, allocated TSD key. 
+</P>
+<H2><A HREF="#toc5" NAME="sect5">Author</A></H2>
+<P>Xavier Leroy &lt;Xavier.Leroy@inria.fr&gt; 
+</P>
+<P>Modified by Ross Johnson for use with <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A>.</P>
+<H2><A HREF="#toc6" NAME="sect6">See Also</A></H2>
+<P><A HREF="pthread_create.html">pthread_create(3)</A> ,
+<A HREF="pthread_exit.html">pthread_exit(3)</A> ,
+<A HREF="pthread_cancel.html">pthread_testcancel(3)</A> . 
+</P>
+<H2><A HREF="#toc7" NAME="sect7">Example</A></H2>
+<P>The following code fragment allocates a thread-specific array of
+100 characters, with automatic reclamation at thread exit: 
+</P>
+<BLOCKQUOTE><BR><BR>
+</BLOCKQUOTE>
+<PRE STYLE="margin-left: 1cm; margin-right: 1cm">/* Key for the thread-specific buffer */
+static pthread_key_t buffer_key;
+/* Once-only initialisation of the key */
+static pthread_once_t buffer_key_once = PTHREAD_ONCE_INIT;
+/* Allocate the thread-specific buffer */
+void buffer_alloc(void)
+{
+  pthread_once(&amp;buffer_key_once, buffer_key_alloc);
+  pthread_setspecific(buffer_key, malloc(100));
+}
+/* Return the thread-specific buffer */
+char * get_buffer(void)
+{
+  return (char *) pthread_getspecific(buffer_key);
+}
+/* Allocate the key */
+static void buffer_key_alloc()
+{
+  pthread_key_create(&amp;buffer_key, buffer_destroy);
+}
+/* Free the thread-specific buffer */
+static void buffer_destroy(void * buf)
+{
+  free(buf);
+}</PRE>
+<HR>
+<BLOCKQUOTE STYLE="margin-left: 0cm; margin-right: 0cm"><A NAME="toc"></A>
+<B>Table of Contents</B></BLOCKQUOTE>
+<UL>
+	<LI><BLOCKQUOTE STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
+		</BLOCKQUOTE>
+	<LI><BLOCKQUOTE STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</BLOCKQUOTE>
+	<LI><BLOCKQUOTE STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
+		</BLOCKQUOTE>
+	<LI><BLOCKQUOTE STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
+	Value</A> 
+	</BLOCKQUOTE>
+	<LI><BLOCKQUOTE STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
+		</BLOCKQUOTE>
+	<LI><BLOCKQUOTE STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Author</A>
+		</BLOCKQUOTE>
+	<LI><BLOCKQUOTE STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">See
+	Also</A> 
+	</BLOCKQUOTE>
+	<LI><BLOCKQUOTE><A HREF="#sect7" NAME="toc7">Example</A> 
+	</BLOCKQUOTE>
+</UL>
+</BODY>
+</HTML>
\ No newline at end of file
diff --git a/src/include/pthread/manual/pthread_kill.html b/src/include/pthread/manual/pthread_kill.html
new file mode 100644
index 0000000..005e937
--- /dev/null
+++ b/src/include/pthread/manual/pthread_kill.html
@@ -0,0 +1,147 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
+	<TITLE>PTHREAD_KILL(3) manual page</TITLE>
+</HEAD>
+<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
+<H4>POSIX Threads for Windows – REFERENCE - <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A></H4>
+<P><A HREF="index.html">Reference Index</A></P>
+<P><A HREF="#toc">Table of Contents</A></P>
+<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P>pthread_sigmask, pthread_kill, sigwait - handling of signals in
+threads 
+</P>
+<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P><B>#include &lt;pthread.h&gt;</B> <BR><B>#include &lt;signal.h&gt;</B>
+</P>
+<P><B>int pthread_sigmask(int </B><I>how</I><B>, const sigset_t
+*</B><I>newmask</I><B>, sigset_t *</B><I>oldmask</I><B>);</B> 
+</P>
+<P><B>int pthread_kill(pthread_t </B><I>thread</I><B>, int </B><I>signo</I><B>);</B>
+</P>
+<P><B>int sigwait(const sigset_t *</B>set, <B>int</B> *sig);</P>
+<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P><B>pthread_sigmask</B> changes the signal mask for the calling
+thread as described by the <I>how</I> and <I>newmask</I> arguments.
+If <I>oldmask</I> is not <B>NULL</B>, the previous signal mask is
+stored in the location pointed to by <I>oldmask</I>. <B>PThreads4W</B>
+implements this function but no other function uses the signal mask
+yet.</P>
+<P>The meaning of the <I>how</I> and <I>newmask</I> arguments is the
+same as for <B><SPAN STYLE="font-style: normal">sigprocmask</SPAN></B>(2).
+If <I>how</I> is <B>SIG_SETMASK</B>, the signal mask is set to
+<I>newmask</I>. If <I>how</I> is <B>SIG_BLOCK</B>, the signals
+specified to <I>newmask</I> are added to the current signal mask. If
+<I>how</I> is <B>SIG_UNBLOCK</B>, the signals specified to <I>newmask</I>
+are removed from the current signal mask. 
+</P>
+<P>Recall that signal masks are set on a per-thread basis, but signal
+actions and signal handlers, as set with <B>sigaction</B>(2), are
+shared between all threads. 
+</P>
+<P><B>pthread_kill</B> send signal number <I>signo</I> to the thread
+<I>thread</I>. <B>PThreads4W</B> only supports signal number 0,
+which does not send any signal but causes <B>pthread_kill</B> to
+return an error if <I>thread</I> is not valid.</P>
+<P><B>sigwait</B> suspends the calling thread until one of the
+signals in <I>set</I> is delivered to the calling thread. It then
+stores the number of the signal received in the location pointed to
+by <I>sig</I> and returns. The signals in <I>set</I> must be blocked
+and not ignored on entrance to <B>sigwait</B>. If the delivered
+signal has a signal handler function attached, that function is <I>not</I>
+called. <B>PThreads4W</B> implements this function as a
+cancellation point only - it does not wait for any signals and does
+not change the location pointed to by <I>sig</I>.</P>
+<H2><A HREF="#toc3" NAME="sect3">Cancellation</A></H2>
+<P><B>sigwait</B> is a cancellation point. 
+</P>
+<H2><A HREF="#toc4" NAME="sect4">Return Value</A></H2>
+<P>On success, 0 is returned. On failure, a non-zero error code is
+returned. 
+</P>
+<H2><A HREF="#toc5" NAME="sect5">Errors</A></H2>
+<P>The <B>pthread_sigmask</B> function returns the following error
+codes on error: 
+</P>
+<DL>
+	<DL>
+		<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EINVAL</B> 
+		</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
+		<I>how</I> is not one of <B>SIG_SETMASK</B>, <B>SIG_BLOCK</B>, or
+		<B>SIG_UNBLOCK</B> 
+		</DD></DL>
+</DL>
+<P>
+The <B>pthread_kill</B> function returns the following error codes on
+error: 
+</P>
+<DL>
+	<DL>
+		<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EINVAL</B> 
+		</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
+		<I>signo</I> is not a valid signal number or is unsupported.</DD><DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
+		<B>ESRCH</B> 
+		</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
+		the thread <I>thread</I> does not exist (e.g. it has already
+		terminated) 
+		</DD></DL>
+</DL>
+<P>
+The <B>sigwait</B> function never returns an error. 
+</P>
+<H2><A HREF="#toc6" NAME="sect6">Author</A></H2>
+<P>Xavier Leroy &lt;Xavier.Leroy@inria.fr&gt; 
+</P>
+<P>Modified by Ross Johnson for use with <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A>.</P>
+<H2><A HREF="#toc7" NAME="sect7">See Also</A></H2>
+<P> 
+</P>
+<H2><A HREF="#toc8" NAME="sect8">Notes</A></H2>
+<P>In any implementation, for <B>sigwait</B> to work reliably, the
+signals being waited for must be blocked in all threads, not only in
+the calling thread, since otherwise the POSIX semantics for signal
+delivery do not guarantee that it’s the thread doing the <B>sigwait</B>
+that will receive the signal. The best way to achieve this is to
+block those signals before any threads are created, and never unblock
+them in the program other than by calling <B>sigwait</B>. This works
+because all threads inherit their initial sigmask from their creating
+thread.</P>
+<H2><A HREF="#toc9" NAME="sect9">Bugs</A></H2>
+<P><B>PThreads4W</B> does not implement signals yet and so these
+routines have almost no use except to prevent the compiler or linker
+from complaining. <B>pthread_kill</B> is useful in determining if the
+thread is a valid thread, but since many threads implementations
+reuse thread IDs, the valid thread may no longer be the thread you
+think it is, and so this method of determining thread validity is not
+portable, and very risky. <B>PThreads4W</B> from version 1.0.0
+onwards implements pseudo-unique thread IDs, so applications that use
+this technique (but really shouldn't) have some protection.</P>
+<HR>
+<P><A NAME="toc"></A><B>Table of Contents</B></P>
+<UL>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Cancellation</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Return
+	Value</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Errors</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Author</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">See
+	Also</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect8" NAME="toc8">Notes</A>
+		</P>
+	<LI><P><A HREF="#sect9" NAME="toc9">Bugs</A> 
+	</P>
+</UL>
+</BODY>
+</HTML>
diff --git a/src/include/pthread/manual/pthread_mutex_init.html b/src/include/pthread/manual/pthread_mutex_init.html
new file mode 100644
index 0000000..8eae6cc
--- /dev/null
+++ b/src/include/pthread/manual/pthread_mutex_init.html
@@ -0,0 +1,348 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
+	<TITLE>PTHREAD_MUTEX_INIT(3) manual page</TITLE>
+	<STYLE TYPE="text/css">
+	<!--
+		H4.cjk { font-family: "AR PL UMing CN" }
+		H4.ctl { font-family: "Lohit Devanagari" }
+		H2.cjk { font-family: "AR PL UMing CN" }
+		H2.ctl { font-family: "Lohit Devanagari" }
+		PRE.cjk { font-family: "AR PL UMing CN", monospace }
+		PRE.ctl { font-family: "Lohit Devanagari", monospace }
+	-->
+	</STYLE>
+</HEAD>
+<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
+<H4 CLASS="western">POSIX Threads for Windows – REFERENCE -
+<A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A></H4>
+<P><A HREF="index.html">Reference Index</A></P>
+<P><A HREF="#toc">Table of Contents</A></P>
+<H2 CLASS="western"><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P>pthread_mutex_init, pthread_mutex_lock, pthread_mutex_trylock,
+pthread_mutex_timedlock, pthread_mutex_unlock,
+pthread_mutex_consistent, pthread_mutex_destroy - operations on
+mutexes 
+</P>
+<H2 CLASS="western"><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P><B>#include &lt;pthread.h&gt;</B> 
+</P>
+<P><B>#include &lt;time.h&gt;</B></P>
+<P><B>pthread_mutex_t </B><I>fastmutex</I> <B>=
+PTHREAD_MUTEX_INITIALIZER;</B> 
+</P>
+<P><B>pthread_mutex_t </B><I>recmutex</I> <B>=
+PTHREAD_RECURSIVE_MUTEX_INITIALIZER;</B> 
+</P>
+<P><B>pthread_mutex_t </B><I>errchkmutex</I> <B>=
+PTHREAD_ERRORCHECK_MUTEX_INITIALIZER;</B> 
+</P>
+<P><B>pthread_mutex_t </B><I>recmutex</I> <B>=
+PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;</B> 
+</P>
+<P><B>pthread_mutex_t </B><I>errchkmutex</I> <B>=
+PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP;</B> 
+</P>
+<P><B>int pthread_mutex_init(pthread_mutex_t *</B><I>mutex</I><B>,
+const pthread_mutexattr_t *</B><I>mutexattr</I><B>);</B> 
+</P>
+<P><B>int pthread_mutex_lock(pthread_mutex_t *</B><I>mutex</I><B>);</B>
+</P>
+<P><B>int pthread_mutex_trylock(pthread_mutex_t *</B><I>mutex</I><B>);</B>
+</P>
+<P><B>int pthread_mutex_timedlock(pthread_mutex_t *</B><I>mutex,
+</I><B>const struct timespec *</B><I>abs_timeout</I><B>);</B> 
+</P>
+<P><B>int pthread_mutex_unlock(pthread_mutex_t *</B><I>mutex</I><B>);</B>
+</P>
+<P><B>int pthread_mutex_consistent(pthread_mutex_t *</B><I>mutex</I><B>);</B>
+</P>
+<P><B>int pthread_mutex_destroy(pthread_mutex_t *</B><I>mutex</I><B>);</B>
+</P>
+<H2 CLASS="western"><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P>A mutex is a MUTual EXclusion device, and is useful for protecting
+shared data structures from concurrent modifications, and
+implementing critical sections and monitors. 
+</P>
+<P>A mutex has two possible states: unlocked (not owned by any
+thread), and locked (owned by one thread). A mutex can never be owned
+by two different threads simultaneously. A thread attempting to lock
+a mutex that is already locked by another thread is suspended until
+the owning thread unlocks the mutex first. 
+</P>
+<P><B>pthread_mutex_init</B> initializes the mutex object pointed to
+by <I>mutex</I> according to the mutex attributes specified in
+<I>mutexattr</I>. If <I>mutexattr</I> is <B>NULL</B>, default
+attributes are used instead. 
+</P>
+<P>The type of a mutex determines whether it can be locked again by a
+thread that already owns it. The default type is “normal�. See
+<A HREF="pthread_mutexattr_init.html"><B>pthread_mutexattr_init</B>(3)</A>
+for more information on mutex attributes. 
+</P>
+<P>Variables of type <B>pthread_mutex_t</B> can also be initialized
+statically, using the constants <B>PTHREAD_MUTEX_INITIALIZER</B> (for
+normal “fast� mutexes), <B>PTHREAD_RECURSIVE_MUTEX_INITIALIZER</B>
+(for recursive mutexes), and <B>PTHREAD_ERRORCHECK_MUTEX_INITIALIZER</B>
+(for error checking mutexes). <SPAN STYLE="font-weight: normal">In
+the </SPAN><B>PThreads4W</B> <SPAN STYLE="font-weight: normal">implementation,
+an application should still call </SPAN><B>pthread_mutex_destroy</B>
+<SPAN STYLE="font-weight: normal">at some point to ensure that any
+resources consumed by the mutex are released.</SPAN></P>
+<P><SPAN STYLE="font-weight: normal">Any mutex type can be
+initialized as a </SPAN><B>robust mutex</B><SPAN STYLE="font-weight: normal">.
+See </SPAN><A HREF="pthread_mutexattr_init.html"><B>pthread_mutexattr_init</B><SPAN STYLE="font-weight: normal">(3)</SPAN></A>
+<SPAN STYLE="font-weight: normal">for more information as well as the
+section </SPAN><I><U><SPAN STYLE="font-weight: normal">Robust Mutexes</SPAN></U></I>
+<SPAN STYLE="font-weight: normal">below.</SPAN></P>
+<P><B>pthread_mutex_lock</B> locks the given mutex. If the mutex is
+currently unlocked, it becomes locked and owned by the calling
+thread, and <B>pthread_mutex_lock</B> returns immediately. If the
+mutex is already locked by another thread, <B>pthread_mutex_lock</B>
+suspends the calling thread until the mutex is unlocked.</P>
+<P>If the mutex is already locked by the calling thread, the behavior
+of <B>pthread_mutex_lock</B> depends on the type of the mutex. If the
+mutex is of the “normal� type, the calling thread is suspended
+until the mutex is unlocked, thus effectively causing the calling
+thread to deadlock. If the mutex is of the ‘‘error checking’’
+type, <B>pthread_mutex_lock</B> returns immediately with the error
+code <B>EDEADLK</B>. If the mutex is of the ‘‘recursive’’
+type, <B>pthread_mutex_lock</B> succeeds and returns immediately,
+recording the number of times the calling thread has locked the
+mutex. An equal number of <B>pthread_mutex_unlock</B> operations must
+be performed before the mutex returns to the unlocked state. 
+</P>
+<P><B>pthread_mutex_trylock</B> behaves identically to
+<B>pthread_mutex_lock</B>, except that it does not block the calling
+thread if the mutex is already locked by another thread (or by the
+calling thread in the case of a “normal� or “<SPAN STYLE="font-style: normal">errorcheck</SPAN>�
+mutex). Instead, <B>pthread_mutex_trylock</B> returns immediately
+with the error code <B>EBUSY</B>. 
+</P>
+<P><B>pthread_mutex_timedlock</B> behaves identically to
+<B>pthread_mutex_lock</B>, except that if it cannot acquire the lock
+before the <I>abs_timeout</I> time, the call returns with the error
+code <B>ETIMEDOUT</B>. If the mutex can be locked immediately it is,
+and the <B>abs_timeout</B> parameter is ignored.</P>
+<P><B>pthread_mutex_consistent</B> may only be called for
+<B>PTHREAD_MUTEX_ROBUST</B> mutexes. It simply marks the mutex as
+consistent. See <I><U>Robust Mutexes</U></I> below.</P>
+<P><B>pthread_mutex_unlock</B> unlocks the given mutex. The mutex is
+assumed to be locked and owned by the calling thread on entrance to
+<B>pthread_mutex_unlock</B>. If the mutex is of the “normal�
+type, <B>pthread_mutex_unlock</B> always returns it to the unlocked
+state. If it is of the ‘‘recursive’’ type, it decrements the
+locking count of the mutex (number of <B>pthread_mutex_lock</B>
+operations performed on it by the calling thread), and only when this
+count reaches zero is the mutex actually unlocked. In <B>PThreads4W</B>,
+non-robust normal or default mutex types do not check the owner of
+the mutex. For all types of robust mutexes the owner is checked and
+an error code is returned if the calling thread does not own the
+mutex.</P>
+<P>On ‘‘error checking’’ mutexes, <B>pthread_mutex_unlock</B>
+actually checks at run-time that the mutex is locked on entrance, and
+that it was locked by the same thread that is now calling
+<B>pthread_mutex_unlock</B>. If these conditions are not met, an
+error code is returned and the mutex remains unchanged. ‘‘Normal’’
+[non-robust] mutexes perform no such checks, thus allowing a locked
+mutex to be unlocked by a thread other than its owner. This is
+non-portable behavior and is not meant to be used as a feature.</P>
+<P><B>pthread_mutex_destroy</B> destroys a mutex object, freeing the
+resources it might hold. The mutex must be unlocked on entrance.</P>
+<H2 CLASS="western"><A HREF="#toc10" NAME="sect10">Robust Mutexes</A></H2>
+<P>If the mutex is <B>PTHREAD_MUTEX_ROBUST</B> and the owning thread
+terminates without unlocking the mutex the implementation will wake
+one waiting thread, if any. The next thread to acquire the mutex will
+receive the error code <B>EOWNERDEAD</B><SPAN STYLE="font-weight: normal">,
+in which case that thread should if possible ensure that the state
+protected by the mutex is consistent and then call
+</SPAN><B>pthread_mutex_consistent</B> <SPAN STYLE="font-weight: normal">before
+unlocking. The mutex may then be used normally from then on.</SPAN></P>
+<P><SPAN STYLE="font-weight: normal">If the thread cannot recover the
+state then it must call </SPAN><B>pthread_mutex_unlock</B><SPAN STYLE="font-weight: normal">
+without calling </SPAN><B>pthread_mutex_consistent</B><SPAN STYLE="font-weight: normal">.
+This will mark the mutex as unusable and wake all currently waiting
+threads with the return code </SPAN><B>ENOTRECOVERABLE</B><SPAN STYLE="font-weight: normal">.
+The error indicates that the mutex is no longer usable and any
+threads that receive this error code from any lock operation have not
+acquired the mutex. The mutex can be made consistent by calling
+</SPAN><B>pthread_mutex_destroy</B> <SPAN STYLE="font-weight: normal">to
+uninitialize the mutex, and calling </SPAN><B>pthread_mutex_int</B>
+<SPAN STYLE="font-weight: normal">to reinitialize the mutex. However,
+the state that was protected by the mutex remains inconsistent and
+some form of application recovery is required.</SPAN></P>
+<P><SPAN STYLE="font-weight: normal">If a thread that receives the
+</SPAN><B>EOWNERDEAD</B> <SPAN STYLE="font-weight: normal">error code
+itself terminates without unlocking the mutex then this behaviour
+repeats for the next acquiring thread.</SPAN></P>
+<P><SPAN STYLE="font-weight: normal">Applications must ensure that
+they check the return values from all calls targeting robust mutexes.</SPAN></P>
+<P STYLE="font-weight: normal">Robust mutexes are slower because they
+require some additional overhead, however they are not very much
+slower than the non-robust recursive type.</P>
+<H2 CLASS="western"><A HREF="#toc3" NAME="sect3">Cancellation</A></H2>
+<P>None of the mutex functions is a cancellation point, not even
+<B>pthread_mutex_lock</B>, in spite of the fact that it can suspend a
+thread for arbitrary durations. This way, the status of mutexes at
+cancellation points is predictable, allowing cancellation handlers to
+unlock precisely those mutexes that need to be unlocked before the
+thread stops executing. Consequently, threads using deferred
+cancellation should never hold a mutex for extended periods of time. 
+</P>
+<H2 CLASS="western"><A HREF="#toc4" NAME="sect4">Async-signal Safety</A></H2>
+<P>The mutex functions are not async-signal safe. What this means is
+that they should not be called from a signal handler. In particular,
+calling <B>pthread_mutex_lock</B> or <B>pthread_mutex_unlock</B> from
+a signal handler may deadlock the calling thread. 
+</P>
+<H2 CLASS="western"><A HREF="#toc5" NAME="sect5">Return Value</A></H2>
+<P><B>pthread_mutex_init</B> always returns 0. The other mutex
+functions return 0 on success and a non-zero error code on error. 
+</P>
+<H2 CLASS="western"><A HREF="#toc6" NAME="sect6">Errors</A></H2>
+<P>The <B>pthread_mutex_lock</B> function returns the following error
+code on error: 
+</P>
+<DL>
+	<DL>
+		<DT STYLE="margin-right: 0.39in; margin-bottom: 0.2in"><B>EINVAL</B></DT><DD STYLE="margin-right: 0.39in; margin-bottom: 0.2in">
+		the mutex has not been properly initialized. 
+		</DD><DT STYLE="margin-right: 0.39in; margin-bottom: 0.2in">
+		<B>EDEADLK</B></DT><DD STYLE="margin-right: 0.39in; margin-bottom: 0.2in">
+		the mutex is already locked by the calling thread (‘‘error
+		checking’’ mutexes only). 
+		</DD><DT STYLE="margin-right: 0.39in; margin-bottom: 0.2in">
+		<B>EOWNERDEAD</B></DT><DD STYLE="margin-right: 0.39in; margin-bottom: 0.2in">
+		the robust mutex is now locked by the calling thread after the
+		previous owner terminated without unlocking it.</DD><DT STYLE="margin-right: 0.39in; margin-bottom: 0.2in">
+		<B>ENOTRECOVERABLE</B></DT><DD STYLE="margin-right: 0.39in; margin-bottom: 0.2in">
+		the robust mutex is not locked and is no longer usable after the
+		previous owner unlocked it without calling
+		pthread_mutex_consistent.</DD></DL>
+	<DD STYLE="margin-right: 0.39in; margin-bottom: 0.2in">
+	The <B>pthread_mutex_trylock</B> function returns the following
+	error codes on error: 
+	</DD><DL>
+		<DT STYLE="margin-right: 0.39in; margin-bottom: 0.2in">
+		<B>EBUSY</B> 
+		</DT><DD STYLE="margin-right: 0.39in; margin-bottom: 0.2in">
+		the mutex could not be acquired because it was currently locked. 
+		</DD><DT STYLE="margin-right: 0.39in; margin-bottom: 0.2in">
+		<B>EINVAL</B> 
+		</DT><DD STYLE="margin-right: 0.39in; margin-bottom: 0.2in">
+		the mutex has not been properly initialized. 
+		</DD><DT STYLE="margin-right: 0.39in; margin-bottom: 0.2in">
+		<B>EOWNERDEAD</B></DT><DD STYLE="margin-right: 0.39in; margin-bottom: 0.2in">
+		the robust mutex is now locked by the calling thread after the
+		previous owner terminated without unlocking it.</DD><DT STYLE="margin-right: 0.39in; margin-bottom: 0.2in">
+		<B>ENOTRECOVERABLE</B></DT><DD STYLE="margin-right: 0.39in; margin-bottom: 0.2in">
+		the robust mutex is not locked and is no longer usable after the
+		previous owner unlocked it without calling
+		pthread_mutex_consistent.</DD></DL>
+</DL>
+<P>
+The <B>pthread_mutex_timedlock</B> function returns the following
+error codes on error: 
+</P>
+<DL>
+	<DL>
+		<DT STYLE="margin-right: 0.39in; margin-bottom: 0.2in"><B>ETIMEDOUT</B>
+				</DT><DD STYLE="margin-right: 0.39in; margin-bottom: 0.2in">
+		the mutex could not be acquired before the <I>abs_timeout</I> time
+		arrived. 
+		</DD><DT STYLE="margin-right: 0.39in; margin-bottom: 0.2in">
+		<B>EINVAL</B> 
+		</DT><DD STYLE="margin-right: 0.39in; margin-bottom: 0.2in">
+		the mutex has not been properly initialized. 
+		</DD><DT STYLE="margin-right: 0.39in; margin-bottom: 0.2in">
+		<B>EOWNERDEAD</B></DT><DD STYLE="margin-right: 0.39in; margin-bottom: 0.2in">
+		the robust mutex is now locked by the calling thread after the
+		previous owner terminated without unlocking it.</DD><DT STYLE="margin-right: 0.39in; margin-bottom: 0.2in">
+		<B>ENOTRECOVERABLE</B></DT><DD STYLE="margin-right: 0.39in; margin-bottom: 0.2in">
+		the robust mutex is not locked and is no longer usable after the
+		previous owner unlocked it without calling
+		pthread_mutex_consistent.</DD></DL>
+</DL>
+<P>
+The <B>pthread_mutex_unlock</B> function returns the following error
+code on error: 
+</P>
+<DL>
+	<DL>
+		<DT STYLE="margin-right: 0.39in; margin-bottom: 0.2in"><B>EINVAL</B>
+				</DT><DD STYLE="margin-right: 0.39in; margin-bottom: 0.2in">
+		the mutex has not been properly initialized. 
+		</DD><DT STYLE="margin-right: 0.39in; margin-bottom: 0.2in">
+		<B>EPERM</B> 
+		</DT><DD STYLE="margin-right: 0.39in; margin-bottom: 0.2in">
+		the calling thread does not own the mutex (‘‘error checking’’
+		mutexes only). 
+		</DD></DL>
+</DL>
+<P>
+The <B>pthread_mutex_destroy</B> function returns the following error
+code on error: 
+</P>
+<DL>
+	<DL>
+		<DT STYLE="margin-right: 0.39in; margin-bottom: 0.2in"><B>EBUSY</B>
+				</DT><DD STYLE="margin-right: 0.39in; margin-bottom: 0.2in">
+		the mutex is currently locked. 
+		</DD></DL>
+</DL>
+<H2 CLASS="western">
+<A HREF="#toc7" NAME="sect7">Author</A></H2>
+<P>Xavier Leroy &lt;Xavier.Leroy@inria.fr&gt; 
+</P>
+<P>Modified by Ross Johnson for use with <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A>.</P>
+<H2 CLASS="western"><A HREF="#toc8" NAME="sect8">See Also</A></H2>
+<P><A HREF="pthread_mutexattr_init.html"><B>pthread_mutexattr_init</B>(3)</A>
+, <A HREF="pthread_mutexattr_init.html"><B>pthread_mutexattr_settype</B>(3)</A>
+, <A HREF="pthread_cancel.html"><B>pthread_cancel</B>(3)</A> . 
+</P>
+<H2 CLASS="western"><A HREF="#toc9" NAME="sect9">Example</A></H2>
+<P>A shared global variable <I>x</I> can be protected by a mutex as
+follows: 
+</P>
+<PRE CLASS="western" STYLE="margin-left: 0.39in; margin-right: 0.39in">int x;
+pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;</PRE><BLOCKQUOTE STYLE="margin-left: 0in; margin-right: 0in">
+All accesses and modifications to <I>x</I> should be bracketed by
+calls to <B>pthread_mutex_lock</B> and <B>pthread_mutex_unlock</B> as
+follows: 
+</BLOCKQUOTE>
+<PRE CLASS="western" STYLE="margin-left: 0.41in; margin-right: 0.79in">pthread_mutex_lock(&amp;mut);
+/* operate on x */
+pthread_mutex_unlock(&amp;mut);</PRE>
+<HR>
+<BLOCKQUOTE STYLE="margin-right: 2.75in"><A NAME="toc"></A><B>Table
+of Contents</B></BLOCKQUOTE>
+<UL>
+	<LI><BLOCKQUOTE STYLE="margin-right: 2.75in; margin-bottom: 0in"><A HREF="#sect0" NAME="toc0">Name</A>
+		</BLOCKQUOTE>
+	<LI><BLOCKQUOTE STYLE="margin-right: 2.75in; margin-bottom: 0in"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</BLOCKQUOTE>
+	<LI><BLOCKQUOTE STYLE="margin-right: 2.75in; margin-bottom: 0in"><A HREF="#sect2" NAME="toc2">Description</A>
+		</BLOCKQUOTE>
+	<LI><BLOCKQUOTE STYLE="margin-right: 2.75in; margin-bottom: 0in"><A HREF="#sect10" NAME="toc10">Robust
+	Mutexes</A></BLOCKQUOTE>
+	<LI><BLOCKQUOTE STYLE="margin-right: 2.75in; margin-bottom: 0in"><A HREF="#sect3" NAME="toc3">Cancellation</A>
+		</BLOCKQUOTE>
+	<LI><BLOCKQUOTE STYLE="margin-right: 2.75in; margin-bottom: 0in"><A HREF="#sect4" NAME="toc4">Async-signal
+	Safety</A> 
+	</BLOCKQUOTE>
+	<LI><BLOCKQUOTE STYLE="margin-right: 2.75in; margin-bottom: 0in"><A HREF="#sect5" NAME="toc5">Return
+	Value</A> 
+	</BLOCKQUOTE>
+	<LI><BLOCKQUOTE STYLE="margin-right: 2.75in; margin-bottom: 0in"><A HREF="#sect6" NAME="toc6">Errors</A>
+		</BLOCKQUOTE>
+	<LI><BLOCKQUOTE STYLE="margin-right: 2.75in; margin-bottom: 0in"><A HREF="#sect7" NAME="toc7">Author</A>
+		</BLOCKQUOTE>
+	<LI><BLOCKQUOTE STYLE="margin-right: 2.75in; margin-bottom: 0in"><A HREF="#sect8" NAME="toc8">See
+	Also</A> 
+	</BLOCKQUOTE>
+	<LI><BLOCKQUOTE STYLE="margin-right: 2.75in"><A HREF="#sect9" NAME="toc9">Example</A>
+		</BLOCKQUOTE>
+</UL>
+</BODY>
+</HTML>
\ No newline at end of file
diff --git a/src/include/pthread/manual/pthread_mutexattr_init.html b/src/include/pthread/manual/pthread_mutexattr_init.html
new file mode 100644
index 0000000..1b3f119
--- /dev/null
+++ b/src/include/pthread/manual/pthread_mutexattr_init.html
@@ -0,0 +1,201 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
+	<TITLE>PTHREAD_MUTEXATTR_INIT(3) manual page</TITLE>
+	<STYLE TYPE="text/css">
+	<!--
+		H4.cjk { font-family: "AR PL UMing CN" }
+		H4.ctl { font-family: "Lohit Devanagari" }
+		H2.cjk { font-family: "AR PL UMing CN" }
+		H2.ctl { font-family: "Lohit Devanagari" }
+	-->
+	</STYLE>
+</HEAD>
+<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
+<H4 CLASS="western">POSIX Threads for Windows – REFERENCE -
+<A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A></H4>
+<P><A HREF="index.html">Reference Index</A></P>
+<P><A HREF="#toc">Table of Contents</A></P>
+<H2 CLASS="western"><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P>pthread_mutexattr_init, pthread_mutexattr_destroy,
+pthread_mutexattr_settype, pthread_mutexattr_gettype - mutex creation
+attributes 
+</P>
+<H2 CLASS="western"><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P><B>#include &lt;pthread.h&gt;</B> 
+</P>
+<P><B>int pthread_mutexattr_init(pthread_mutexattr_t *</B><I>attr</I><B>);</B>
+</P>
+<P><B>int pthread_mutexattr_destroy(pthread_mutexattr_t *</B><I>attr</I><B>);</B>
+</P>
+<P><B>int pthread_mutexattr_settype(pthread_mutexattr_t *</B><I>attr</I><B>,
+int </B><I>type</I><B>);</B> 
+</P>
+<P><B>int pthread_mutexattr_gettype(const pthread_mutexattr_t *</B><I>attr</I><B>,
+int *</B><I>type</I><B>);</B> 
+</P>
+<P><B>int pthread_mutexattr_setkind_np(pthread_mutexattr_t *</B><I>attr</I><B>,
+int </B><I>type</I><B>);</B> 
+</P>
+<P><B>int pthread_mutexattr_getkind_np(const pthread_mutexattr_t
+*</B><I>attr</I><B>, int *</B><I>type</I><B>);</B> 
+</P>
+<P><B>int pthread_mutexattr_setrobust(pthread_mutexattr_t *</B><I>attr</I><B>,
+int</B><SPAN STYLE="font-weight: normal"> </SPAN><I><SPAN STYLE="font-weight: normal">robust</SPAN></I><B>);</B>
+</P>
+<P><B>int pthread_mutexattr_getrobust(pthread_mutexattr_t *</B><I>attr</I><B>,
+int</B><SPAN STYLE="font-weight: normal"> </SPAN><B>*</B><I><SPAN STYLE="font-weight: normal">robust</SPAN></I><B>);</B>
+</P>
+<H2 CLASS="western"><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P>Mutex attributes can be specified at mutex creation time, by
+passing a mutex attribute object as second argument to
+<A HREF="pthread_mutex_init.html"><B>pthread_mutex_init</B>(3)</A> .
+Passing <B>NULL</B> is equivalent to passing a mutex attribute object
+with all attributes set to their default values. 
+</P>
+<P><B>pthread_mutexattr_init</B> initializes the mutex attribute
+object <I>attr</I> and fills it with default values for the
+attributes. 
+</P>
+<P><B>pthread_mutexattr_destroy</B> destroys a mutex attribute
+object, which must not be reused until it is reinitialized.</P>
+<P><B>pthread_mutexattr_settype</B> sets the mutex type attribute in
+<I>attr</I> to the value specified by <I>type</I>. 
+</P>
+<P><B>pthread_mutexattr_gettype</B> retrieves the current value of
+the mutex kind attribute in <I>attr</I> and stores it in the location
+pointed to by <I>type</I>. 
+</P>
+<P><B>PThreads4W</B> also recognises the following equivalent
+functions that are used in Linux:</P>
+<P><B>pthread_mutexattr_setkind_np</B> is an alias for
+<B>pthread_mutexattr_settype</B>. 
+</P>
+<P STYLE="font-weight: normal"><B>pthread_mutexattr_getkind_np</B> is
+an alias for <B>pthread_mutexattr_gettype</B>. 
+</P>
+<P>The following mutex types are supported:</P>
+<P STYLE="margin-left: 0.79in"><B>PTHREAD_MUTEX_NORMAL</B> - for
+‘‘fast’’ mutexes.</P>
+<P STYLE="margin-left: 0.79in"><B>PTHREAD_MUTEX_RECURSIVE</B> - for
+‘‘recursive’’ mutexes.</P>
+<P STYLE="margin-left: 0.79in"><B>PTHREAD_MUTEX_ERRORCHECK</B> - for
+‘‘error checking’’ mutexes.</P>
+<P>The mutex type determines what happens if a thread attempts to
+lock a mutex it already owns with <A HREF="pthread_mutex_lock.html"><B>pthread_mutex_lock</B>(3)</A>
+. If the mutex is of the “normal� or “fast� type,
+<A HREF="pthread_mutex_lock.html"><B>pthread_mutex_lock</B>(3)</A>
+simply suspends the calling thread forever. If the mutex is of the
+‘‘error checking’’ type, <A HREF="pthread_mutex_lock.html"><B>pthread_mutex_lock</B>(3)</A>
+returns immediately with the error code <B>EDEADLK</B>. If the mutex
+is of the ‘‘recursive’’ type, the call to
+<A HREF="pthread_mutex_lock.html"><B>pthread_mutex_lock</B>(3)</A>
+returns immediately with a success return code. The number of times
+the thread owning the mutex has locked it is recorded in the mutex.
+The owning thread must call <A HREF="pthread_mutex_unlock.html"><B>pthread_mutex_unlock</B>(3)</A>
+the same number of times before the mutex returns to the unlocked
+state. 
+</P>
+<P>The default mutex type is <B>PTHREAD_MUTEX_NORMAL</B></P>
+<P><B>PThreads4W</B> also recognises the following equivalent types
+that are used by Linux:</P>
+<P STYLE="margin-left: 0.79in; font-weight: normal"><B>PTHREAD_MUTEX_FAST_NP</B>
+– equivalent to <B>PTHREAD_MUTEX_NORMAL</B></P>
+<P STYLE="margin-left: 0.79in"><B>PTHREAD_MUTEX_RECURSIVE_NP</B></P>
+<P STYLE="margin-left: 0.79in"><B>PTHREAD_MUTEX_ERRORCHECK_NP</B></P>
+<P><B>pthread_mutexattr_setrobust</B><SPAN STYLE="font-weight: normal">
+sets the robustness attribute to the value given by </SPAN><I><SPAN STYLE="font-weight: normal">robust</SPAN></I><SPAN STYLE="font-weight: normal">.</SPAN></P>
+<P><B>pthread_mutexattr_getrobust</B><SPAN STYLE="font-weight: normal">
+returns the current robustness value to the location given by
+*</SPAN><I><SPAN STYLE="font-weight: normal">robust</SPAN></I><SPAN STYLE="font-weight: normal">.</SPAN></P>
+<P><SPAN STYLE="font-weight: normal">The possible values for </SPAN><I><SPAN STYLE="font-weight: normal">robust</SPAN></I><SPAN STYLE="font-weight: normal">
+are:</SPAN></P>
+<P STYLE="margin-left: 0.79in"><B>PTHREAD_MUTEX_STALLED</B><SPAN STYLE="font-weight: normal">
+- when the owner of the mutex terminates without unlocking the mutex,
+all subsequent calls
 to pthread_mutex_*lock() are blocked from
+progress in an unspecified manner.</SPAN></P>
+<P STYLE="margin-left: 0.79in"><B>PTHREAD_MUTEX_ROBUST</B><SPAN STYLE="font-weight: normal">
+- when the owner of the mutex terminates without unlocking the mutex,
+the mutex is
 unlocked. The next owner of this mutex acquires the
+mutex with an error return of
EOWNERDEAD.</SPAN></P>
+<H2 CLASS="western"><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
+<P><SPAN STYLE="font-weight: normal">On success all functions return
+0, otherwise they return an error code as follows:</SPAN></P>
+<P><B>pthread_mutexattr_init</B></P>
+<P STYLE="margin-left: 0.79in"><B>ENOMEM</B><SPAN STYLE="font-weight: normal">
+- insufficient memory for </SPAN><I><SPAN STYLE="font-weight: normal">attr</SPAN></I><SPAN STYLE="font-weight: normal">.</SPAN></P>
+<P><B>pthread_mutexattr_destroy</B></P>
+<P STYLE="margin-left: 0.79in"><B>EINVAL</B><SPAN STYLE="font-weight: normal">
+- </SPAN><I><SPAN STYLE="font-weight: normal">attr</SPAN></I><SPAN STYLE="font-weight: normal">
+is invalid.</SPAN></P>
+<P><B>pthread_mutexattr_gettype</B></P>
+<P STYLE="margin-left: 0.79in"><B>EINVAL</B><SPAN STYLE="font-weight: normal">
+- </SPAN><I><SPAN STYLE="font-weight: normal">attr</SPAN></I><SPAN STYLE="font-weight: normal">
+is invalid.</SPAN></P>
+<P><B>pthread_mutexattr_settype</B></P>
+<DL>
+	<DL>
+		<DL>
+			<DT><B>EINVAL</B><SPAN STYLE="font-weight: normal"> - </SPAN><I><SPAN STYLE="font-weight: normal">attr</SPAN></I><SPAN STYLE="font-weight: normal">
+			is invalid or </SPAN><I><SPAN STYLE="font-weight: normal">type</SPAN></I><SPAN STYLE="font-weight: normal">
+			is none of:</SPAN></DT><DL>
+				<DL>
+					<DT>
+					<B>PTHREAD_MUTEX_NORMAL<BR>PTHREAD_MUTEX_FAST_NP<BR>PTHREAD_MUTEX_RECURSIVE<BR>PTHREAD_MUTEX_RECURSIVE_NP<BR>PTHREAD_MUTEX_ERRORCHECK<BR>PTHREAD_MUTEX_ERRORCHECK_NP</B></DT></DL>
+			</DL>
+		</DL>
+	</DL>
+	<DD STYLE="margin-left: 0in">
+	<BR>
+	</DD></DL>
+<P>
+<B>pthread_mutexattr_getrobust</B></P>
+<P STYLE="margin-left: 0.79in"><B>EINVAL</B><SPAN STYLE="font-weight: normal">
+– </SPAN><I><SPAN STYLE="font-weight: normal">attr</SPAN></I><SPAN STYLE="font-weight: normal">
+or </SPAN><I><SPAN STYLE="font-weight: normal">robust</SPAN></I><SPAN STYLE="font-weight: normal">
+is invalid.</SPAN></P>
+<P><B>pthread_mutexattr_setrobust</B></P>
+<P STYLE="margin-left: 0.79in"><B>EINVAL</B><SPAN STYLE="font-weight: normal">
+– </SPAN><I><SPAN STYLE="font-weight: normal">attr</SPAN></I><SPAN STYLE="font-weight: normal">
+or </SPAN><I><SPAN STYLE="font-weight: normal">robust</SPAN></I><SPAN STYLE="font-weight: normal">
+is invalid.</SPAN></P>
+<H2 CLASS="western"><A HREF="#toc5" NAME="sect5">Author</A></H2>
+<P>Xavier Leroy &lt;Xavier.Leroy@inria.fr&gt; 
+</P>
+<P>Modified by Ross Johnson for use with <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A>.</P>
+<H2 CLASS="western"><A HREF="#toc6" NAME="sect6">See Also</A></H2>
+<P><A HREF="pthread_mutex_init.html"><B>pthread_mutex_init</B>(3)</A>
+, <A HREF="pthread_mutex_lock.html"><B>pthread_mutex_lock</B>(3)</A>
+, <A HREF="pthread_mutex_unlock.html"><B>pthread_mutex_unlock</B>(3)</A>
+. 
+</P>
+<H2 CLASS="western"><A HREF="#toc7" NAME="sect7"><FONT COLOR="#000080"><U>Notes</U></FONT></A></H2>
+<P>For speed, <B>PThreads4W</B> never checks the thread ownership
+of non-robust mutexes of type <B>PTHREAD_MUTEX_NORMAL</B> (or
+<B>PTHREAD_MUTEX_FAST_NP</B>) when performing operations on the
+mutex. It is therefore possible for one thread to lock such a mutex
+and another to unlock it.</P>
+<P STYLE="font-weight: normal">When developing code, it is a common
+precaution to substitute the error checking type, then drop in the
+normal type for release if the extra performance is required.</P>
+<HR>
+<P><A NAME="toc"></A><B>Table of Contents</B></P>
+<UL>
+	<LI><P STYLE="margin-bottom: 0in"><A HREF="#sect0" NAME="toc0">Name</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0in"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0in"><A HREF="#sect2" NAME="toc2">Description</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0in"><A HREF="#sect3" NAME="toc3">Return
+	Value</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0in"><A HREF="#sect5" NAME="toc5">Author</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0in"><A HREF="#sect6" NAME="toc6">See
+	Also</A></P>
+	<LI><P><A HREF="#sect7" NAME="toc7">Notes</A></P>
+</UL>
+</BODY>
+</HTML>
\ No newline at end of file
diff --git a/src/include/pthread/manual/pthread_mutexattr_setpshared.html b/src/include/pthread/manual/pthread_mutexattr_setpshared.html
new file mode 100644
index 0000000..c3100b8
--- /dev/null
+++ b/src/include/pthread/manual/pthread_mutexattr_setpshared.html
@@ -0,0 +1,146 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
+	<TITLE>PTHREAD_MUTEXATTR_SETPSHARED(3) manual page</TITLE>
+</HEAD>
+<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
+<H4>POSIX Threads for Windows – REFERENCE - <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A></H4>
+<P><A HREF="index.html">Reference Index</A></P>
+<P><A HREF="#toc">Table of Contents</A></P>
+<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P>pthread_mutexattr_getpshared, pthread_mutexattr_setpshared - get
+and set the process-shared attribute 
+</P>
+<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P><B>#include &lt;pthread.h&gt; </B>
+</P>
+<P><B>int pthread_mutexattr_getpshared(const pthread_mutexattr_t *
+restrict</B> <I>attr</I><B>, int *restrict</B> <I>pshared</I><B>);
+<BR>int pthread_mutexattr_setpshared(pthread_mutexattr_t *</B><I>attr</I><B>,
+int</B> <I>pshared</I><B>); </B>
+</P>
+<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P>The <B>pthread_mutexattr_getpshared</B> function shall obtain the
+value of the <I>process-shared</I> attribute from the attributes
+object referenced by <I>attr</I>. The <B>pthread_mutexattr_setpshared</B>
+function shall set the <I>process-shared</I> attribute in an
+initialized attributes object referenced by <I>attr</I>. 
+</P>
+<P>The <I>process-shared</I> attribute is set to
+<B>PTHREAD_PROCESS_SHARED</B> to permit a mutex to be operated upon
+by any thread that has access to the memory where the mutex is
+allocated, even if the mutex is allocated in memory that is shared by
+multiple processes. If the <I>process-shared</I> attribute is
+<B>PTHREAD_PROCESS_PRIVATE</B>, the mutex shall only be operated upon
+by threads created within the same process as the thread that
+initialized the mutex; if threads of differing processes attempt to
+operate on such a mutex, the behavior is undefined. The default value
+of the attribute shall be <B>PTHREAD_PROCESS_PRIVATE</B>. 
+</P>
+<P><B>PThreads4W</B> defines <B>_POSIX_THREAD_PROCESS_SHARED</B> in
+pthread.h as -1 to indicate that these routines are implemented but
+the process shared option is not supported.</P>
+<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
+<P>Upon successful completion, <B>pthread_mutexattr_setpshared</B>
+shall return zero; otherwise, an error number shall be returned to
+indicate the error. 
+</P>
+<P>Upon successful completion, <B>pthread_mutexattr_getpshared</B>
+shall return zero and store the value of the <I>process-shared</I>
+attribute of <I>attr</I> into the object referenced by the <I>pshared</I>
+parameter. Otherwise, an error number shall be returned to indicate
+the error. 
+</P>
+<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
+<P>The <B>pthread_mutexattr_getpshared</B> and
+<B>pthread_mutexattr_setpshared</B> functions may fail if: 
+</P>
+<DL>
+	<DT><B>EINVAL</B> 
+	</DT><DD STYLE="margin-bottom: 0.5cm">
+	The value specified by <I>attr</I> is invalid. 
+	</DD></DL>
+<P>
+The <B>pthread_mutexattr_setpshared</B> function may fail if: 
+</P>
+<DL>
+	<DT><B>EINVAL</B> 
+	</DT><DD STYLE="margin-bottom: 0.5cm">
+	The new value specified for the attribute is outside the range of
+	legal values for that attribute. 
+	</DD><DT>
+	<B>ENOTSUP</B> 
+	</DT><DD STYLE="margin-bottom: 0.5cm">
+	The new value specified for the attribute is PTHREAD_PROCESS_SHARED.
+		</DD></DL>
+<P>
+These functions shall not return an error code of [EINTR]. 
+</P>
+<P><I>The following sections are informative.</I> 
+</P>
+<H2><A HREF="#toc5" NAME="sect5">Examples</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc6" NAME="sect6">Application Usage</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc7" NAME="sect7">Rationale</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc8" NAME="sect8">Future Directions</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc9" NAME="sect9">See Also</A></H2>
+<P><A HREF="pthread_cond_init.html"><B>pthread_cond_destroy</B>(3)</A>
+<B>,</B> <A HREF="pthread_create.html"><B>pthread_create</B>(3)</A> <B>,</B>
+<A HREF="pthread_mutex_init.html"><B>pthread_mutex_destroy</B>(3)</A>
+<B>,</B> <A HREF="pthread_mutexattr_init.html"><B>pthread_mutexattr_destroy</B>(3)</A>
+<B>,</B> the Base Definitions volume of IEEE&nbsp;Std&nbsp;1003.1-2001,
+<I>&lt;pthread.h&gt;</I> 
+</P>
+<H2><A HREF="#toc10" NAME="sect10">Copyright</A></H2>
+<P>Portions of this text are reprinted and reproduced in electronic
+form from IEEE Std 1003.1, 2003 Edition, Standard for Information
+Technology -- Portable Operating System Interface (POSIX), The Open
+Group Base Specifications Issue 6, Copyright (C) 2001-2003 by the
+Institute of Electrical and Electronics Engineers, Inc and The Open
+Group. In the event of any discrepancy between this version and the
+original IEEE and The Open Group Standard, the original IEEE and The
+Open Group Standard is the referee document. The original Standard
+can be obtained online at <A HREF="http://www.opengroup.org/unix/online.html">http://www.opengroup.org/unix/online.html</A>
+. 
+</P>
+<P>Modified by Ross Johnson for use with <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A>.</P>
+<HR>
+<P><A NAME="toc"></A><B>Table of Contents</B></P>
+<UL>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
+	Value</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Examples</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Application
+	Usage</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">Rationale</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect8" NAME="toc8">Future
+	Directions</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect9" NAME="toc9">See
+	Also</A> 
+	</P>
+	<LI><P><A HREF="#sect10" NAME="toc10">Copyright</A> 
+	</P>
+</UL>
+</BODY>
+</HTML>
diff --git a/src/include/pthread/manual/pthread_num_processors_np.html b/src/include/pthread/manual/pthread_num_processors_np.html
new file mode 100644
index 0000000..ab148c3
--- /dev/null
+++ b/src/include/pthread/manual/pthread_num_processors_np.html
@@ -0,0 +1,52 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
+	<TITLE>PTHREAD_NUM_PROCESSORS_NP(3) manual page</TITLE>
+</HEAD>
+<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
+<H4>POSIX Threads for Windows – REFERENCE - <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A></H4>
+<P><A HREF="index.html">Reference Index</A></P>
+<P><A HREF="#toc">Table of Contents</A></P>
+<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P STYLE="font-weight: medium">pthread_num_processors_np – get the
+number of processors (CPUs) in use by the process</P>
+<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P><B>#include &lt;pthread.h&gt;</B> 
+</P>
+<P><B>int pthread_num_processors_np(void);</B></P>
+<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P><B>pthread_num_processors_np </B>returns the number of processors
+in the system. This implementation actually returns the number of
+processors available to the process, which can be a lower number than
+the system's number, depending on the process's affinity mask.</P>
+<H2><A HREF="#toc3" NAME="sect3">Cancellation</A></H2>
+<P>None.</P>
+<H2><A HREF="#toc4" NAME="sect4"><FONT COLOR="#000080">Return Value</FONT></A></H2>
+<P><B>pthread_num_processors_np</B> returns the number of processors
+currently available to the process.</P>
+<H2><A HREF="#toc5" NAME="sect5">Errors</A></H2>
+<P>None.</P>
+<H2><A HREF="#toc6" NAME="sect6">Author</A></H2>
+<P>Ross Johnson for use with <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A>.</P>
+<HR>
+<P><A NAME="toc"></A><B>Table of Contents</B></P>
+<UL>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Cancellation</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Return
+	Value</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Errors</A>
+		</P>
+	<LI><P><A HREF="#sect6" NAME="toc6">Author</A> 
+	</P>
+</UL>
+</BODY>
+</HTML>
diff --git a/src/include/pthread/manual/pthread_once.html b/src/include/pthread/manual/pthread_once.html
new file mode 100644
index 0000000..69903fa
--- /dev/null
+++ b/src/include/pthread/manual/pthread_once.html
@@ -0,0 +1,78 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
+	<TITLE>PTHREAD_ONCE(3) manual page</TITLE>
+</HEAD>
+<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
+<H4>POSIX Threads for Windows – REFERENCE - <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A></H4>
+<P><A HREF="index.html">Reference Index</A></P>
+<P><A HREF="#toc">Table of Contents</A></P>
+<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P>pthread_once - once-only initialization 
+</P>
+<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P><B>#include &lt;pthread.h&gt;</B> 
+</P>
+<P><B>pthread_once_t </B><I>once_control</I> <B>= PTHREAD_ONCE_INIT;</B>
+</P>
+<P><B>int pthread_once(pthread_once_t *</B><I>once_control</I><B>,
+void (*</B><I>init_routine</I><B>) (void));</B> 
+</P>
+<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P>The purpose of <B>pthread_once</B> is to ensure that a piece of
+initialization code is executed at most once. The <I>once_control</I>
+argument points to a static or extern variable statically initialized
+to <B>PTHREAD_ONCE_INIT</B>. 
+</P>
+<P>The first time <B>pthread_once</B> is called with a given
+<I>once_control</I> argument, it calls <I>init_routine</I> with no
+argument and changes the value of the <I>once_control</I> variable to
+record that initialization has been performed. Subsequent calls to
+<B>pthread_once</B> with the same <B>once_control</B> argument do
+nothing. 
+</P>
+<H2><A HREF="#toc3" NAME="sect3">Cancellation</A></H2>
+<P>While <B>pthread_once</B> is not a cancellation point,
+<I>init_routine</I> can be. The effect on <I>once_control</I> of a
+cancellation inside the <I>init_routine</I> is to leave it as if
+<B>pthread_once</B> had not been called by the cancelled thread.</P>
+<H2><A HREF="#toc4" NAME="sect4">Return Value</A></H2>
+<P STYLE="text-decoration: none"><FONT COLOR="#000000"><B>pthread_once</B>
+returns 0 on success, or an error code on failure.</FONT></P>
+<H2><A HREF="#toc5" NAME="sect5">Errors</A></H2>
+<P>The <B>pthread_once</B> function returns the following error code
+on error: 
+</P>
+<DL>
+	<DL>
+		<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EINVAL</B> 
+		</DT></DL>
+</DL>
+<P STYLE="margin-left: 2cm">
+The once_control or init_routine parameter is NULL.</P>
+<H2><A HREF="#toc6" NAME="sect6">Author</A></H2>
+<P>Xavier Leroy &lt;Xavier.Leroy@inria.fr&gt; 
+</P>
+<P>Modified by Ross Johnson for use with <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A>.</P>
+<HR>
+<P><A NAME="toc"></A><B>Table of Contents</B></P>
+<UL>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Cancellation</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Return
+	Value</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Errors</A>
+		</P>
+	<LI><P><A HREF="#sect6" NAME="toc6">Author</A> 
+	</P>
+</UL>
+</BODY>
+</HTML>
\ No newline at end of file
diff --git a/src/include/pthread/manual/pthread_rwlock_init.html b/src/include/pthread/manual/pthread_rwlock_init.html
new file mode 100644
index 0000000..5ab9aa6
--- /dev/null
+++ b/src/include/pthread/manual/pthread_rwlock_init.html
@@ -0,0 +1,188 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
+	<TITLE>PTHREAD_RWLOCK_INIT(3) manual page</TITLE>
+</HEAD>
+<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
+<H4>POSIX Threads for Windows – REFERENCE - <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A></H4>
+<P><A HREF="index.html">Reference Index</A></P>
+<P><A HREF="#toc">Table of Contents</A></P>
+<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P>pthread_rwlock_destroy, pthread_rwlock_init - destroy and
+initialize a read-write lock object 
+</P>
+<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P><B>#include &lt;pthread.h&gt; </B>
+</P>
+<P><B>pthread_wrlock_t </B><I>rwlock</I> <B>=
+PTHREAD_RWLOCK_INITIALIZER;</B></P>
+<P><B>int pthread_rwlock_destroy(pthread_rwlock_t *</B><I>rwlock</I><B>);
+<BR>int pthread_rwlock_init(pthread_rwlock_t *restrict</B> <I>rwlock</I><B>,
+const pthread_rwlockattr_t *restrict</B> <I>attr</I><B>); </B>
+</P>
+<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P>The <B>pthread_rwlock_destroy</B> function shall destroy the
+read-write lock object referenced by <I>rwlock</I> and release any
+resources used by the lock. The effect of subsequent use of the lock
+is undefined until the lock is reinitialized by another call to
+<B>pthread_rwlock_init</B>. An implementation may cause
+<B>pthread_rwlock_destroy</B> to set the object referenced by <I>rwlock</I>
+to an invalid value. Results are undefined if <B>pthread_rwlock_destroy</B>
+is called when any thread holds <I>rwlock</I>. Attempting to destroy
+an uninitialized read-write lock results in undefined behavior. 
+</P>
+<P>The <B>pthread_rwlock_init</B> function shall allocate any
+resources required to use the read-write lock referenced by <I>rwlock</I>
+and initializes the lock to an unlocked state with attributes
+referenced by <I>attr</I>. If <I>attr</I> is NULL, the default
+read-write lock attributes shall be used; the effect is the same as
+passing the address of a default read-write lock attributes object.
+Once initialized, the lock can be used any number of times without
+being reinitialized. Results are undefined if <B>pthread_rwlock_init</B>
+is called specifying an already initialized read-write lock. Results
+are undefined if a read-write lock is used without first being
+initialized. 
+</P>
+<P>If the <B>pthread_rwlock_init</B> function fails, <I>rwlock</I>
+shall not be initialized and the contents of <I>rwlock</I> are
+undefined. 
+</P>
+<P><B>PThreads4W</B> supports statically initialized <I>rwlock</I>
+objects using <B>PTHREAD_RWLOCK_INITIALIZER</B>. <SPAN STYLE="font-weight: medium">
+An application should still call <B>pthread_rwlock_destroy</B> at
+some point to ensure that any resources consumed by the read/write
+lock are released.</SPAN></P>
+<P>Only the object referenced by <I>rwlock</I> may be used for
+performing synchronization. The result of referring to copies of that
+object in calls to <B>pthread_rwlock_destroy</B> ,
+<B>pthread_rwlock_rdlock</B> , <B>pthread_rwlock_timedrdlock</B> ,
+<B>pthread_rwlock_timedwrlock</B> , <B>pthread_rwlock_tryrdlock</B> ,
+<B>pthread_rwlock_trywrlock</B> , <B>pthread_rwlock_unlock</B> , or
+<B>pthread_rwlock_wrlock</B> is undefined. 
+</P>
+<P><B>PThreads4W</B> defines <B>_POSIX_READER_WRITER_LOCKS</B> in
+pthread.h as 200112L to indicate that the reader/writer routines are
+implemented and may be used.</P>
+<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
+<P>If successful, the <B>pthread_rwlock_destroy</B> and
+<B>pthread_rwlock_init</B> functions shall return zero; otherwise, an
+error number shall be returned to indicate the error. 
+</P>
+<P>The [EBUSY] and [EINVAL] error checks, if implemented, act as if
+they were performed immediately at the beginning of processing for
+the function and caused an error return prior to modifying the state
+of the read-write lock specified by <I>rwlock</I>. 
+</P>
+<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
+<P>The <B>pthread_rwlock_destroy</B> function may fail if: 
+</P>
+<DL>
+	<DT><B>EBUSY</B> 
+	</DT><DD>
+	The implementation has detected an attempt to destroy the object
+	referenced by <I>rwlock</I> while it is locked. 
+	</DD><DT>
+	<B>EINVAL</B> 
+	</DT><DD STYLE="margin-bottom: 0.5cm">
+	The value specified by <I>rwlock</I> is invalid. 
+	</DD></DL>
+<P>
+The <B>pthread_rwlock_init</B> function shall fail if: 
+</P>
+<DL>
+	<DT><B>EAGAIN</B> 
+	</DT><DD>
+	The system lacked the necessary resources (other than memory) to
+	initialize another read-write lock. 
+	</DD><DT>
+	<B>ENOMEM</B> 
+	</DT><DD>
+	Insufficient memory exists to initialize the read-write lock. 
+	</DD><DD STYLE="margin-left: 0cm; margin-bottom: 0.5cm">
+	<BR><BR>
+	</DD></DL>
+<P>
+The <B>pthread_rwlock_init</B> function may fail if: 
+</P>
+<DL>
+	<DT><B>EINVAL</B> 
+	</DT><DD STYLE="margin-bottom: 0.5cm">
+	The value specified by <I>attr</I> is invalid. 
+	</DD></DL>
+<P>
+These functions shall not return an error code of [EINTR]. 
+</P>
+<P><I>The following sections are informative.</I> 
+</P>
+<H2><A HREF="#toc5" NAME="sect5">Examples</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc6" NAME="sect6">Application Usage</A></H2>
+<P>Applications using these and related read-write lock functions may
+be subject to priority inversion, as discussed in the Base
+Definitions volume of IEEE&nbsp;Std&nbsp;1003.1-2001, Section 3.285,
+Priority Inversion. 
+</P>
+<H2><A HREF="#toc7" NAME="sect7">Rationale</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc8" NAME="sect8">Future Directions</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc9" NAME="sect9">See Also</A></H2>
+<P><A HREF="pthread_rwlock_rdlock.html"><B>pthread_rwlock_rdlock</B>(3)</A>
+<B>,</B> <A HREF="pthread_rwlock_timedrdlock.html"><B>pthread_rwlock_timedrdlock</B>(3)</A>
+<B>,</B> <A HREF="pthread_rwlock_timedwrlock.html"><B>pthread_rwlock_timedwrlock</B>(3)</A>
+<B>,</B> <A HREF="pthread_rwlock_rdlock.html"><B>pthread_rwlock_tryrdlock</B>(3)</A>
+<B>,</B> <A HREF="pthread_rwlock_wrlock.html"><B>pthread_rwlock_trywrlock</B>(3)</A>
+<B>,</B> <A HREF="pthread_rwlock_unlock.html"><B>pthread_rwlock_unlock</B>(3)</A>
+<B>,</B> <A HREF="pthread_rwlock_wrlock.html"><B>pthread_rwlock_wrlock</B>(3)</A>
+<B>,</B> the Base Definitions volume of IEEE&nbsp;Std&nbsp;1003.1-2001,
+<I>&lt;pthread.h&gt;</I> 
+</P>
+<H2><A HREF="#toc10" NAME="sect10">Copyright</A></H2>
+<P>Portions of this text are reprinted and reproduced in electronic
+form from IEEE Std 1003.1, 2003 Edition, Standard for Information
+Technology -- Portable Operating System Interface (POSIX), The Open
+Group Base Specifications Issue 6, Copyright (C) 2001-2003 by the
+Institute of Electrical and Electronics Engineers, Inc and The Open
+Group. In the event of any discrepancy between this version and the
+original IEEE and The Open Group Standard, the original IEEE and The
+Open Group Standard is the referee document. The original Standard
+can be obtained online at <A HREF="http://www.opengroup.org/unix/online.html">http://www.opengroup.org/unix/online.html</A>
+. 
+</P>
+<P>Modified by Ross Johnson for use with <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A>.</P>
+<HR>
+<P><A NAME="toc"></A><B>Table of Contents</B></P>
+<UL>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
+	Value</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Examples</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Application
+	Usage</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">Rationale</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect8" NAME="toc8">Future
+	Directions</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect9" NAME="toc9">See
+	Also</A> 
+	</P>
+	<LI><P><A HREF="#sect10" NAME="toc10">Copyright</A> 
+	</P>
+</UL>
+</BODY>
+</HTML>
diff --git a/src/include/pthread/manual/pthread_rwlock_rdlock.html b/src/include/pthread/manual/pthread_rwlock_rdlock.html
new file mode 100644
index 0000000..a9a13df
--- /dev/null
+++ b/src/include/pthread/manual/pthread_rwlock_rdlock.html
@@ -0,0 +1,163 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
+	<TITLE>PTHREAD_RWLOCK_RDLOCK(3) manual page</TITLE>
+</HEAD>
+<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
+<H4>POSIX Threads for Windows – REFERENCE - <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A></H4>
+<P><A HREF="index.html">Reference Index</A></P>
+<P><A HREF="#toc">Table of Contents</A></P>
+<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P>pthread_rwlock_rdlock, pthread_rwlock_tryrdlock - lock a
+read-write lock object for reading 
+</P>
+<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P><B>#include &lt;pthread.h&gt; </B>
+</P>
+<P><B>int pthread_rwlock_rdlock(pthread_rwlock_t <I>*</I></B><I>rwlock</I><B>);
+<BR></B>i<B>nt pthread_rwlock_tryrdlock(pthread_rwlock_t <I>*</I></B><I>rwlock</I><B>);
+</B>
+</P>
+<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P>The <B>pthread_rwlock_rdlock</B> function shall apply a read lock
+to the read-write lock referenced by <I>rwlock</I>. The calling
+thread acquires the read lock if a writer does not hold the lock and
+there are no writers blocked on the lock. 
+</P>
+<P><B>PThreads4W</B> does not prefer either writers or readers in
+acquiring the lock – all threads enter a single prioritised FIFO
+queue. While this may not be optimally efficient for some
+applications, it does ensure that one type does not starve the other.</P>
+<P>A thread may hold multiple concurrent read locks on <I>rwlock</I>
+(that is, successfully call the <B>pthread_rwlock_rdlock</B> function
+<I>n</I> times). If so, the application shall ensure that the thread
+performs matching unlocks (that is, it calls the
+<A HREF="pthread_rwlock_unlock.html"><B>pthread_rwlock_unlock</B>(3)</A>
+function <I>n</I> times). 
+</P>
+<P>The <B>pthread_rwlock_tryrdlock</B> function shall apply a read
+lock as in the <B>pthread_rwlock_rdlock</B> function, with the
+exception that the function shall fail if the equivalent
+<B>pthread_rwlock_rdlock</B> call would have blocked the calling
+thread. In no case shall the <B>pthread_rwlock_tryrdlock</B> function
+ever block; it always either acquires the lock or fails and returns
+immediately. 
+</P>
+<P>Results are undefined if any of these functions are called with an
+uninitialized read-write lock. 
+</P>
+<P><B>PThreads4W</B> does not detect deadlock if the thread already
+owns the lock for writing.</P>
+<P><B>PThreads4W</B> defines <B>_POSIX_READER_WRITER_LOCKS</B> in
+pthread.h as  200112L to indicate that the reader/writer routines are
+implemented and may be used.</P>
+<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
+<P>If successful, the <B>pthread_rwlock_rdlock</B> function shall
+return zero; otherwise, an error number shall be returned to indicate
+the error. 
+</P>
+<P>The <B>pthread_rwlock_tryrdlock</B> function shall return zero if
+the lock for reading on the read-write lock object referenced by
+<I>rwlock</I> is acquired. Otherwise, an error number shall be
+returned to indicate the error. 
+</P>
+<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
+<P>The <B>pthread_rwlock_tryrdlock</B> function shall fail if: 
+</P>
+<DL>
+	<DT><B>EBUSY</B> 
+	</DT><DD STYLE="margin-bottom: 0.5cm">
+	The read-write lock could not be acquired for reading because a
+	writer holds the lock or a writer with the appropriate priority was
+	blocked on it. 
+	</DD></DL>
+<P>
+The <B>pthread_rwlock_rdlock</B> and <B>pthread_rwlock_tryrdlock</B>
+functions may fail if: 
+</P>
+<DL>
+	<DT><B>EINVAL</B> 
+	</DT><DD>
+	The value specified by <I>rwlock</I> does not refer to an
+	initialized read-write lock object. 
+	</DD><DT>
+	<B>EAGAIN</B> 
+	</DT><DD STYLE="margin-bottom: 0.5cm">
+	The read lock could not be acquired because the maximum number of
+	read locks for <I>rwlock</I> has been exceeded. 
+	</DD></DL>
+<P>
+These functions shall not return an error code of [EINTR]. 
+</P>
+<P><I>The following sections are informative.</I> 
+</P>
+<H2><A HREF="#toc5" NAME="sect5">Examples</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc6" NAME="sect6">Application Usage</A></H2>
+<P>Applications using these functions may be subject to priority
+inversion, as discussed in the Base Definitions volume of
+IEEE&nbsp;Std&nbsp;1003.1-2001, Section 3.285, Priority Inversion. 
+</P>
+<H2><A HREF="#toc7" NAME="sect7">Rationale</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc8" NAME="sect8">Future Directions</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc9" NAME="sect9">See Also</A></H2>
+<P><A HREF="pthread_rwlock_init.html"><B>pthread_rwlock_destroy</B>(3)</A>
+<B>,</B> <A HREF="pthread_rwlock_timedrdlock.html"><B>pthread_rwlock_timedrdlock</B>(3)</A>
+<B>,</B> <A HREF="pthread_rwlock_timedwrlock.html"><B>pthread_rwlock_timedwrlock</B>(3)</A>
+<B>,</B> <A HREF="pthread_rwlock_wrlock.html"><B>pthread_rwlock_trywrlock</B>(3)</A>
+<B>,</B> <A HREF="pthread_rwlock_unlock.html"><B>pthread_rwlock_unlock</B>(3)</A>
+<B>,</B> <A HREF="pthread_rwlock_wrlock.html"><B>pthread_rwlock_wrlock</B>(3)</A>
+<B>,</B> the Base Definitions volume of IEEE&nbsp;Std&nbsp;1003.1-2001,
+<I>&lt;pthread.h&gt;</I> 
+</P>
+<H2><A HREF="#toc10" NAME="sect10">Copyright</A></H2>
+<P>Portions of this text are reprinted and reproduced in electronic
+form from IEEE Std 1003.1, 2003 Edition, Standard for Information
+Technology -- Portable Operating System Interface (POSIX), The Open
+Group Base Specifications Issue 6, Copyright (C) 2001-2003 by the
+Institute of Electrical and Electronics Engineers, Inc and The Open
+Group. In the event of any discrepancy between this version and the
+original IEEE and The Open Group Standard, the original IEEE and The
+Open Group Standard is the referee document. The original Standard
+can be obtained online at <A HREF="http://www.opengroup.org/unix/online.html">http://www.opengroup.org/unix/online.html</A>
+. 
+</P>
+<P>Modified by Ross Johnson for use with <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A>.</P>
+<HR>
+<P><A NAME="toc"></A><B>Table of Contents</B></P>
+<UL>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
+	Value</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Examples</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Application
+	Usage</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">Rationale</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect8" NAME="toc8">Future
+	Directions</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect9" NAME="toc9">See
+	Also</A> 
+	</P>
+	<LI><P><A HREF="#sect10" NAME="toc10">Copyright</A> 
+	</P>
+</UL>
+</BODY>
+</HTML>
diff --git a/src/include/pthread/manual/pthread_rwlock_timedrdlock.html b/src/include/pthread/manual/pthread_rwlock_timedrdlock.html
new file mode 100644
index 0000000..e135f8d
--- /dev/null
+++ b/src/include/pthread/manual/pthread_rwlock_timedrdlock.html
@@ -0,0 +1,151 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
+	<TITLE>PTHREAD_RWLOCK_TIMEDRDLOCK(3) manual page</TITLE>
+</HEAD>
+<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
+<H4>POSIX Threads for Windows – REFERENCE - <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A></H4>
+<P><A HREF="index.html">Reference Index</A></P>
+<P><A HREF="#toc">Table of Contents</A></P>
+<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P>pthread_rwlock_timedrdlock - lock a read-write lock for reading 
+</P>
+<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P><B>#include &lt;pthread.h&gt; <BR></B>#include &lt;time.h&gt; 
+</P>
+<P><B>int pthread_rwlock_timedrdlock(pthread_rwlock_t *restrict</B>
+<I>rwlock</I><B>, const struct timespec *restrict</B> <I>abs_timeout</I><B>);
+</B>
+</P>
+<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P>The <B>pthread_rwlock_timedrdlock</B> function shall apply a read
+lock to the read-write lock referenced by <I>rwlock</I> as in the
+<A HREF="pthread_rwlock_rdlock.html"><B>pthread_rwlock_rdlock</B>(3)</A>
+function. However, if the lock cannot be acquired without waiting for
+other threads to unlock the lock, this wait shall be terminated when
+the specified timeout expires. The timeout shall expire when the
+absolute time specified by <I>abs_timeout</I> passes, as measured by
+the clock on which timeouts are based (that is, when the value of
+that clock equals or exceeds <I>abs_timeout</I>), or if the absolute
+time specified by <I>abs_timeout</I> has already been passed at the
+time of the call. 
+</P>
+<P>The <B>timespec</B> data type is defined in the <I>&lt;time.h&gt;</I>
+header. Under no circumstances shall the function fail with a timeout
+if the lock can be acquired immediately. The validity of the
+<I>abs_timeout</I> parameter need not be checked if the lock can be
+immediately acquired. 
+</P>
+<P>The calling thread may deadlock if at the time the call is made it
+holds a write lock on <I>rwlock</I>. The results are undefined if
+this function is called with an uninitialized read-write lock. 
+</P>
+<P><B>PThreads4W</B> defines <B>_POSIX_READER_WRITER_LOCKS</B> in
+pthread.h as  200112L to indicate that the reader/writer routines are
+implemented and may be used.</P>
+<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
+<P>The <B>pthread_rwlock_timedrdlock</B> function shall return zero
+if the lock for reading on the read-write lock object referenced by
+<I>rwlock</I> is acquired. Otherwise, an error number shall be
+returned to indicate the error. 
+</P>
+<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
+<P>The <B>pthread_rwlock_timedrdlock</B> function shall fail if: 
+</P>
+<DL>
+	<DT><B>ETIMEDOUT</B> 
+	</DT><DD STYLE="margin-bottom: 0.5cm">
+	The lock could not be acquired before the specified timeout expired.
+		</DD></DL>
+<P>
+The <B>pthread_rwlock_timedrdlock</B> function may fail if: 
+</P>
+<DL>
+	<DT><B>EAGAIN</B> 
+	</DT><DD>
+	The read lock could not be acquired because the maximum number of
+	read locks for lock would be exceeded. 
+	</DD><DT>
+	<B>EINVAL</B> 
+	</DT><DD STYLE="margin-bottom: 0.5cm">
+	The value specified by <I>rwlock</I> does not refer to an
+	initialized read-write lock object, or the <I>abs_timeout</I>
+	nanosecond value is less than zero or greater than or equal to 1000
+	million. 
+	</DD></DL>
+<P>
+This function shall not return an error code of [EINTR]. 
+</P>
+<P><I>The following sections are informative.</I> 
+</P>
+<H2><A HREF="#toc5" NAME="sect5">Examples</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc6" NAME="sect6">Application Usage</A></H2>
+<P>Applications using this function may be subject to priority
+inversion, as discussed in the Base Definitions volume of
+IEEE&nbsp;Std&nbsp;1003.1-2001, Section 3.285, Priority Inversion. 
+</P>
+<H2><A HREF="#toc7" NAME="sect7">Rationale</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc8" NAME="sect8">Future Directions</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc9" NAME="sect9">See Also</A></H2>
+<P><A HREF="pthread_rwlock_init.html"><B>pthread_rwlock_destroy</B>(3)</A>
+<B>,</B> <A HREF="pthread_rwlock_rdlock.html"><B>pthread_rwlock_rdlock</B>(3)</A>
+<B>,</B> <A HREF="pthread_rwlock_timedwrlock.html"><B>pthread_rwlock_timedwrlock</B>(3)</A>
+<B>,</B> <A HREF="pthread_rwlock_rdlock.html"><B>pthread_rwlock_tryrdlock</B>(3)</A>
+<B>,</B> <A HREF="pthread_rwlock_wrlock.html"><B>pthread_rwlock_trywrlock</B>(3)</A>
+<B>,</B> <A HREF="pthread_rwlock_unlock.html"><B>pthread_rwlock_unlock</B>(3)</A>
+<B>,</B> <A HREF="pthread_rwlock_wrlock.html"><B>pthread_rwlock_wrlock</B>(3)</A>
+<B>,</B> the Base Definitions volume of IEEE&nbsp;Std&nbsp;1003.1-2001,
+<I>&lt;pthread.h&gt;</I>, <I>&lt;time.h&gt;</I> 
+</P>
+<H2><A HREF="#toc10" NAME="sect10">Copyright</A></H2>
+<P>Portions of this text are reprinted and reproduced in electronic
+form from IEEE Std 1003.1, 2003 Edition, Standard for Information
+Technology -- Portable Operating System Interface (POSIX), The Open
+Group Base Specifications Issue 6, Copyright (C) 2001-2003 by the
+Institute of Electrical and Electronics Engineers, Inc and The Open
+Group. In the event of any discrepancy between this version and the
+original IEEE and The Open Group Standard, the original IEEE and The
+Open Group Standard is the referee document. The original Standard
+can be obtained online at <A HREF="http://www.opengroup.org/unix/online.html">http://www.opengroup.org/unix/online.html</A>
+. 
+</P>
+<P>Modified by Ross Johnson for use with <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A>.</P>
+<HR>
+<P><A NAME="toc"></A><B>Table of Contents</B></P>
+<UL>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
+	Value</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Examples</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Application
+	Usage</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">Rationale</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect8" NAME="toc8">Future
+	Directions</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect9" NAME="toc9">See
+	Also</A> 
+	</P>
+	<LI><P><A HREF="#sect10" NAME="toc10">Copyright</A> 
+	</P>
+</UL>
+</BODY>
+</HTML>
diff --git a/src/include/pthread/manual/pthread_rwlock_timedwrlock.html b/src/include/pthread/manual/pthread_rwlock_timedwrlock.html
new file mode 100644
index 0000000..f2f853d
--- /dev/null
+++ b/src/include/pthread/manual/pthread_rwlock_timedwrlock.html
@@ -0,0 +1,145 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
+	<TITLE>PTHREAD_RWLOCK_TIMEDWRLOCK(3) manual page</TITLE>
+</HEAD>
+<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
+<H4>POSIX Threads for Windows – REFERENCE - <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A></H4>
+<P><A HREF="index.html">Reference Index</A></P>
+<P><A HREF="#toc">Table of Contents</A></P>
+<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P>pthread_rwlock_timedwrlock - lock a read-write lock for writing 
+</P>
+<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P><B>#include &lt;pthread.h&gt; <BR></B>#include &lt;time.h&gt; 
+</P>
+<P><B>int pthread_rwlock_timedwrlock(pthread_rwlock_t *restrict</B>
+<I>rwlock</I><B>, const struct timespec *restrict</B> <I>abs_timeout</I><B>);
+</B>
+</P>
+<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P>The <B>pthread_rwlock_timedwrlock</B> function shall apply a write
+lock to the read-write lock referenced by <I>rwlock</I> as in the
+<A HREF="pthread_rwlock_wrlock.html"><B>pthread_rwlock_wrlock</B>(3)</A>
+function. However, if the lock cannot be acquired without waiting for
+other threads to unlock the lock, this wait shall be terminated when
+the specified timeout expires. The timeout shall expire when the
+absolute time specified by <I>abs_timeout</I> passes, as measured by
+the clock on which timeouts are based (that is, when the value of
+that clock equals or exceeds <I>abs_timeout</I>), or if the absolute
+time specified by <I>abs_timeout</I> has already been passed at the
+time of the call. 
+</P>
+<P>The <B>timespec</B> data type is defined in the <I>&lt;time.h&gt;</I>
+header. Under no circumstances shall the function fail with a timeout
+if the lock can be acquired immediately. The validity of the
+<I>abs_timeout</I> parameter need not be checked if the lock can be
+immediately acquired. 
+</P>
+<P>The calling thread may deadlock if at the time the call is made it
+holds the read-write lock. The results are undefined if this function
+is called with an uninitialized read-write lock. 
+</P>
+<P><B>PThreads4W</B> defines <B>_POSIX_READER_WRITER_LOCKS</B> in
+pthread.h as  200112L to indicate that the reader/writer routines are
+implemented and may be used.</P>
+<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
+<P>The <B>pthread_rwlock_timedwrlock</B> function shall return zero
+if the lock for writing on the read-write lock object referenced by
+<I>rwlock</I> is acquired. Otherwise, an error number shall be
+returned to indicate the error. 
+</P>
+<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
+<P>The <B>pthread_rwlock_timedwrlock</B> function shall fail if: 
+</P>
+<DL>
+	<DT><B>ETIMEDOUT</B> 
+	</DT><DD STYLE="margin-bottom: 0.5cm">
+	The lock could not be acquired before the specified timeout expired.
+		</DD></DL>
+<P>
+The <B>pthread_rwlock_timedwrlock</B> function may fail if: 
+</P>
+<DL>
+	<DT><B>EINVAL</B> 
+	</DT><DD STYLE="margin-bottom: 0.5cm">
+	The value specified by rwlock does not refer to an initialized
+	read-write lock object, or the <I>abs_timeout</I> nanosecond value
+	is less than zero or greater than or equal to 1000 million. 
+	</DD></DL>
+<P>
+This function shall not return an error code of [EINTR]. 
+</P>
+<P><I>The following sections are informative.</I> 
+</P>
+<H2><A HREF="#toc5" NAME="sect5">Examples</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc6" NAME="sect6">Application Usage</A></H2>
+<P>Applications using this function may be subject to priority
+inversion, as discussed in the Base Definitions volume of
+IEEE&nbsp;Std&nbsp;1003.1-2001, Section 3.285, Priority Inversion. 
+</P>
+<H2><A HREF="#toc7" NAME="sect7">Rationale</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc8" NAME="sect8">Future Directions</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc9" NAME="sect9">See Also</A></H2>
+<P><A HREF="pthread_rwlock_init.html"><B>pthread_rwlock_destroy</B>(3)</A>
+<B>,</B> <A HREF="pthread_rwlock_rdlock.html"><B>pthread_rwlock_rdlock</B>(3)</A>
+<B>,</B> <A HREF="pthread_rwlock_timedrdlock.html"><B>pthread_rwlock_timedrdlock</B>(3)</A>
+<B>,</B> <A HREF="pthread_rwlock_rdlock.html"><B>pthread_rwlock_tryrdlock</B>(3)</A>
+<B>,</B> <A HREF="pthread_rwlock_wrlock.html"><B>pthread_rwlock_trywrlock</B>(3)</A>
+<B>,</B> <A HREF="pthread_rwlock_unlock.html"><B>pthread_rwlock_unlock</B>(3)</A>
+<B>,</B> <A HREF="pthread_rwlock_wrlock.html"><B>pthread_rwlock_wrlock</B>(3)</A>
+<B>,</B> the Base Definitions volume of IEEE&nbsp;Std&nbsp;1003.1-2001,
+<I>&lt;pthread.h&gt;</I>, <I>&lt;time.h&gt;</I> 
+</P>
+<H2><A HREF="#toc10" NAME="sect10">Copyright</A></H2>
+<P>Portions of this text are reprinted and reproduced in electronic
+form from IEEE Std 1003.1, 2003 Edition, Standard for Information
+Technology -- Portable Operating System Interface (POSIX), The Open
+Group Base Specifications Issue 6, Copyright (C) 2001-2003 by the
+Institute of Electrical and Electronics Engineers, Inc and The Open
+Group. In the event of any discrepancy between this version and the
+original IEEE and The Open Group Standard, the original IEEE and The
+Open Group Standard is the referee document. The original Standard
+can be obtained online at <A HREF="http://www.opengroup.org/unix/online.html">http://www.opengroup.org/unix/online.html</A>
+. 
+</P>
+<P>Modified by Ross Johnson for use with <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A>.</P>
+<HR>
+<P><A NAME="toc"></A><B>Table of Contents</B></P>
+<UL>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
+	Value</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Examples</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Application
+	Usage</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">Rationale</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect8" NAME="toc8">Future
+	Directions</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect9" NAME="toc9">See
+	Also</A> 
+	</P>
+	<LI><P><A HREF="#sect10" NAME="toc10">Copyright</A> 
+	</P>
+</UL>
+</BODY>
+</HTML>
diff --git a/src/include/pthread/manual/pthread_rwlock_unlock.html b/src/include/pthread/manual/pthread_rwlock_unlock.html
new file mode 100644
index 0000000..583faa0
--- /dev/null
+++ b/src/include/pthread/manual/pthread_rwlock_unlock.html
@@ -0,0 +1,136 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
+	<TITLE>PTHREAD_RWLOCK_UNLOCK(3) manual page</TITLE>
+</HEAD>
+<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
+<H4>POSIX Threads for Windows – REFERENCE - <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A></H4>
+<P><A HREF="index.html">Reference Index</A></P>
+<P><A HREF="#toc">Table of Contents</A></P>
+<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P>pthread_rwlock_unlock - unlock a read-write lock object 
+</P>
+<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P><B>#include &lt;pthread.h&gt; </B>
+</P>
+<P>in<B>t pthread_rwlock_unlock(pthread_rwlock_t <I>*</I></B><I>rwlock</I><B>);
+</B>
+</P>
+<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P>The <B>pthread_rwlock_unlock</B> function shall release a lock
+held on the read-write lock object referenced by <I>rwlock</I>.
+Results are undefined if the read-write lock <I>rwlock</I> is not
+held by the calling thread. 
+</P>
+<P>If this function is called to release a read lock from the
+read-write lock object and there are other read locks currently held
+on this read-write lock object, the read-write lock object remains in
+the read locked state. If this function releases the last read lock
+for this read-write lock object, the read-write lock object shall be
+put in the unlocked state with no owners. 
+</P>
+<P>If this function is called to release a write lock for this
+read-write lock object, the read-write lock object shall be put in
+the unlocked state. 
+</P>
+<P><B>PThreads4W</B> does not prefer either writers or readers in
+acquiring the lock – all threads enter a single prioritised FIFO
+queue. While this may not be optimally efficient for some
+applications, it does ensure that one type does not starve the other.</P>
+<P>Results are undefined if any of these functions are called with an
+uninitialized read-write lock. 
+</P>
+<P><B>PThreads4W</B> defines <B>_POSIX_READER_WRITER_LOCKS</B> in
+pthread.h as  200112L to indicate that the reader/writer routines are
+implemented and may be used.</P>
+<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
+<P>If successful, the <B>pthread_rwlock_unlock</B> function shall
+return zero; otherwise, an error number shall be returned to indicate
+the error. 
+</P>
+<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
+<P>The <B>pthread_rwlock_unlock</B> function may fail if: 
+</P>
+<DL>
+	<DT><B>EINVAL</B> 
+	</DT><DD>
+	The value specified by <I>rwlock</I> does not refer to an
+	initialized read-write lock object. 
+	</DD><DD STYLE="margin-left: 0cm; margin-bottom: 0.5cm">
+	<BR><BR>
+	</DD></DL>
+<P>
+The <B>pthread_rwlock_unlock</B> function shall not return an error
+code of [EINTR]. 
+</P>
+<P><I>The following sections are informative.</I> 
+</P>
+<H2><A HREF="#toc5" NAME="sect5">Examples</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc6" NAME="sect6">Application Usage</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc7" NAME="sect7">Rationale</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc8" NAME="sect8">Future Directions</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc9" NAME="sect9">See Also</A></H2>
+<P><A HREF="pthread_rwlock_init.html"><B>pthread_rwlock_destroy</B>(3)</A>
+<B>,</B> <A HREF="pthread_rwlock_rdlock.html"><B>pthread_rwlock_rdlock</B>(3)</A>
+<B>,</B> <A HREF="pthread_rwlock_timedrdlock.html"><B>pthread_rwlock_timedrdlock</B>(3)</A>
+<B>,</B> <A HREF="pthread_rwlock_timedwrlock.html"><B>pthread_rwlock_timedwrlock</B>(3)</A>
+<B>,</B> <A HREF="pthread_rwlock_rdlock.html"><B>pthread_rwlock_tryrdlock</B>(3)</A>
+<B>,</B> <A HREF="pthread_rwlock_wrlock.html"><B>pthread_rwlock_trywrlock</B>(3)</A>
+<B>,</B> <A HREF="pthread_rwlock_wrlock.html"><B>pthread_rwlock_wrlock</B>(3)</A>
+, the Base Definitions volume of IEEE&nbsp;Std&nbsp;1003.1-2001,
+<I>&lt;pthread.h&gt;</I> 
+</P>
+<H2><A HREF="#toc10" NAME="sect10">Copyright</A></H2>
+<P>Portions of this text are reprinted and reproduced in electronic
+form from IEEE Std 1003.1, 2003 Edition, Standard for Information
+Technology -- Portable Operating System Interface (POSIX), The Open
+Group Base Specifications Issue 6, Copyright (C) 2001-2003 by the
+Institute of Electrical and Electronics Engineers, Inc and The Open
+Group. In the event of any discrepancy between this version and the
+original IEEE and The Open Group Standard, the original IEEE and The
+Open Group Standard is the referee document. The original Standard
+can be obtained online at <A HREF="http://www.opengroup.org/unix/online.html">http://www.opengroup.org/unix/online.html</A>
+. 
+</P>
+<P>Modified by Ross Johnson for use with <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A>.</P>
+<HR>
+<P><A NAME="toc"></A><B>Table of Contents</B></P>
+<UL>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
+	Value</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Examples</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Application
+	Usage</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">Rationale</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect8" NAME="toc8">Future
+	Directions</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect9" NAME="toc9">See
+	Also</A> 
+	</P>
+	<LI><P><A HREF="#sect10" NAME="toc10">Copyright</A> 
+	</P>
+</UL>
+</BODY>
+</HTML>
diff --git a/src/include/pthread/manual/pthread_rwlock_wrlock.html b/src/include/pthread/manual/pthread_rwlock_wrlock.html
new file mode 100644
index 0000000..7e165b3
--- /dev/null
+++ b/src/include/pthread/manual/pthread_rwlock_wrlock.html
@@ -0,0 +1,148 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
+	<TITLE>PTHREAD_RWLOCK_WRLOCK(3) manual page</TITLE>
+</HEAD>
+<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
+<H4>POSIX Threads for Windows – REFERENCE - <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A></H4>
+<P><A HREF="index.html">Reference Index</A></P>
+<P><A HREF="#toc">Table of Contents</A></P>
+<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P>pthread_rwlock_trywrlock, pthread_rwlock_wrlock - lock a
+read-write lock object for writing 
+</P>
+<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P><B>#include &lt;pthread.h&gt; </B>
+</P>
+<P><B>int pthread_rwlock_trywrlock(pthread_rwlock_t <I>*</I></B><I>rwlock</I><B>);
+<BR>int pthread_rwlock_wrlock(pthread_rwlock_t <I>*</I></B><I>rwlock</I><B>);
+</B>
+</P>
+<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P>The <B>pthread_rwlock_trywrlock</B> function shall apply a write
+lock like the <B>pthread_rwlock_wrlock</B> function, with the
+exception that the function shall fail if any thread currently holds
+<I>rwlock</I> (for reading or writing). 
+</P>
+<P>The <B>pthread_rwlock_wrlock</B> function shall apply a write lock
+to the read-write lock referenced by <I>rwlock</I>. The calling
+thread acquires the write lock if no other thread (reader or writer)
+holds the read-write lock <I>rwlock</I>. Otherwise, the thread shall
+block until it can acquire the lock. The calling thread may deadlock
+if at the time the call is made it holds the read-write lock (whether
+a read or write lock). 
+</P>
+<P><B>PThreads4W</B> does not prefer either writers or readers in
+acquiring the lock – all threads enter a single prioritised FIFO
+queue. While this may not be optimally efficient for some
+applications, it does ensure that one type does not starve the other.</P>
+<P>Results are undefined if any of these functions are called with an
+uninitialized read-write lock. 
+</P>
+<P><B>PThreads4W</B> defines <B>_POSIX_READER_WRITER_LOCKS</B> in
+pthread.h as  200112L to indicate that the reader/writer routines are
+implemented and may be used.</P>
+<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
+<P>The <B>pthread_rwlock_trywrlock</B> function shall return zero if
+the lock for writing on the read-write lock object referenced by
+<I>rwlock</I> is acquired. Otherwise, an error number shall be
+returned to indicate the error. 
+</P>
+<P>If successful, the <B>pthread_rwlock_wrlock</B> function shall
+return zero; otherwise, an error number shall be returned to indicate
+the error. 
+</P>
+<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
+<P>The <B>pthread_rwlock_trywrlock</B> function shall fail if: 
+</P>
+<DL>
+	<DT><B>EBUSY</B> 
+	</DT><DD STYLE="margin-bottom: 0.5cm">
+	The read-write lock could not be acquired for writing because it was
+	already locked for reading or writing. 
+	</DD></DL>
+<P>
+The <B>pthread_rwlock_trywrlock</B> and <B>pthread_rwlock_wrlock</B>
+functions may fail if: 
+</P>
+<DL>
+	<DT><B>EINVAL</B> 
+	</DT><DD STYLE="margin-bottom: 0.5cm">
+	The value specified by <I>rwlock</I> does not refer to an
+	initialized read-write lock object. 
+	</DD></DL>
+<P>
+These functions shall not return an error code of [EINTR]. 
+</P>
+<P><I>The following sections are informative.</I> 
+</P>
+<H2><A HREF="#toc5" NAME="sect5">Examples</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc6" NAME="sect6">Application Usage</A></H2>
+<P>Applications using these functions may be subject to priority
+inversion, as discussed in the Base Definitions volume of
+IEEE&nbsp;Std&nbsp;1003.1-2001, Section 3.285, Priority Inversion. 
+</P>
+<H2><A HREF="#toc7" NAME="sect7">Rationale</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc8" NAME="sect8">Future Directions</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc9" NAME="sect9">See Also</A></H2>
+<P><A HREF="pthread_rwlock_init.html"><B>pthread_rwlock_destroy</B>(3)</A>
+<B>,</B> <A HREF="pthread_rwlock_rdlock.html"><B>pthread_rwlock_rdlock</B>(3)</A>
+<B>,</B> <A HREF="pthread_rwlock_timedrdlock.html"><B>pthread_rwlock_timedrdlock</B>(3)</A>
+<B>,</B> <A HREF="pthread_rwlock_timedwrlock.html"><B>pthread_rwlock_timedwrlock</B>(3)</A>
+<B>,</B> <A HREF="pthread_rwlock_rdlock.html"><B>pthread_rwlock_tryrdlock</B>(3)</A>
+<B>,</B> <A HREF="pthread_rwlock_unlock.html"><B>pthread_rwlock_unlock</B>(3)</A>
+<B>,</B> the Base Definitions volume of IEEE&nbsp;Std&nbsp;1003.1-2001,
+<I>&lt;pthread.h&gt;</I> 
+</P>
+<H2><A HREF="#toc10" NAME="sect10">Copyright</A></H2>
+<P>Portions of this text are reprinted and reproduced in electronic
+form from IEEE Std 1003.1, 2003 Edition, Standard for Information
+Technology -- Portable Operating System Interface (POSIX), The Open
+Group Base Specifications Issue 6, Copyright (C) 2001-2003 by the
+Institute of Electrical and Electronics Engineers, Inc and The Open
+Group. In the event of any discrepancy between this version and the
+original IEEE and The Open Group Standard, the original IEEE and The
+Open Group Standard is the referee document. The original Standard
+can be obtained online at <A HREF="http://www.opengroup.org/unix/online.html">http://www.opengroup.org/unix/online.html</A>
+. 
+</P>
+<P>Modified by Ross Johnson for use with <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A>.</P>
+<HR>
+<P><A NAME="toc"></A><B>Table of Contents</B></P>
+<UL>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
+	Value</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Examples</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Application
+	Usage</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">Rationale</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect8" NAME="toc8">Future
+	Directions</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect9" NAME="toc9">See
+	Also</A> 
+	</P>
+	<LI><P><A HREF="#sect10" NAME="toc10">Copyright</A> 
+	</P>
+</UL>
+</BODY>
+</HTML>
diff --git a/src/include/pthread/manual/pthread_rwlockattr_init.html b/src/include/pthread/manual/pthread_rwlockattr_init.html
new file mode 100644
index 0000000..c9d04ea
--- /dev/null
+++ b/src/include/pthread/manual/pthread_rwlockattr_init.html
@@ -0,0 +1,136 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
+	<TITLE>PTHREAD_RWLOCKATTR_INIT(3) manual page</TITLE>
+</HEAD>
+<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
+<H4>POSIX Threads for Windows – REFERENCE - <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A></H4>
+<P><A HREF="index.html">Reference Index</A></P>
+<P><A HREF="#toc">Table of Contents</A></P>
+<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P>pthread_rwlockattr_destroy, pthread_rwlockattr_init - destroy and
+initialize the read-write lock attributes object 
+</P>
+<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P><B>#include &lt;pthread.h&gt; </B>
+</P>
+<P><B>int pthread_rwlockattr_destroy(pthread_rwlockattr_t <I>*</I></B><I>attr</I><B>);
+<BR>int pthread_rwlockattr_init(pthread_rwlockattr_t <I>*</I></B><I>attr</I><B>);
+</B>
+</P>
+<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P>The <B>pthread_rwlockattr_destroy</B> function shall destroy a
+read-write lock attributes object. A destroyed <I>attr</I> attributes
+object can be reinitialized using <B>pthread_rwlockattr_init</B> ;
+the results of otherwise referencing the object after it has been
+destroyed are undefined. An implementation may cause
+<B>pthread_rwlockattr_destroy</B> to set the object referenced by
+<I>attr</I> to an invalid value. 
+</P>
+<P>The <B>pthread_rwlockattr_init</B> function shall initialize a
+read-write lock attributes object <I>attr</I> with the default value
+for all of the attributes defined by the implementation. 
+</P>
+<P>Results are undefined if <B>pthread_rwlockattr_init</B> is called
+specifying an already initialized <I>attr</I> attributes object. 
+</P>
+<P>After a read-write lock attributes object has been used to
+initialize one or more read-write locks, any function affecting the
+attributes object (including destruction) shall not affect any
+previously initialized read-write locks. 
+</P>
+<P><B>PThreads4W</B> defines <B>_POSIX_READER_WRITER_LOCKS</B> in
+pthread.h as 200112L to indicate that the reader/writer routines are
+implemented and may be used.</P>
+<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
+<P>If successful, the <B>pthread_rwlockattr_destroy</B> and
+<B>pthread_rwlockattr_init</B> functions shall return zero;
+otherwise, an error number shall be returned to indicate the error. 
+</P>
+<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
+<P>The <B>pthread_rwlockattr_destroy</B> function may fail if: 
+</P>
+<DL>
+	<DT><B>EINVAL</B> 
+	</DT><DD STYLE="margin-bottom: 0.5cm">
+	The value specified by <I>attr</I> is invalid. 
+	</DD></DL>
+<P>
+The <B>pthread_rwlockattr_init</B> function shall fail if: 
+</P>
+<DL>
+	<DT><B>ENOMEM</B> 
+	</DT><DD STYLE="margin-bottom: 0.5cm">
+	Insufficient memory exists to initialize the read-write lock
+	attributes object. 
+	</DD></DL>
+<P>
+These functions shall not return an error code of [EINTR]. 
+</P>
+<P><I>The following sections are informative.</I> 
+</P>
+<H2><A HREF="#toc5" NAME="sect5">Examples</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc6" NAME="sect6">Application Usage</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc7" NAME="sect7">Rationale</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc8" NAME="sect8">Future Directions</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc9" NAME="sect9">See Also</A></H2>
+<P><A HREF="pthread_rwlock_init.html"><B>pthread_rwlock_destroy</B>(3)</A>
+<B>,</B> <A HREF="pthread_rwlockattr_setpshared.html"><B>pthread_rwlockattr_getpshared</B>(3)</A>
+<B>,</B> <A HREF="pthread_rwlockattr_setpshared.html"><B>pthread_rwlockattr_setpshared</B>(3)</A>
+<B>,</B> the Base Definitions volume of IEEE&nbsp;Std&nbsp;1003.1-2001,
+<I>&lt;pthread.h&gt;</I> 
+</P>
+<H2><A HREF="#toc10" NAME="sect10">Copyright</A></H2>
+<P>Portions of this text are reprinted and reproduced in electronic
+form from IEEE Std 1003.1, 2003 Edition, Standard for Information
+Technology -- Portable Operating System Interface (POSIX), The Open
+Group Base Specifications Issue 6, Copyright (C) 2001-2003 by the
+Institute of Electrical and Electronics Engineers, Inc and The Open
+Group. In the event of any discrepancy between this version and the
+original IEEE and The Open Group Standard, the original IEEE and The
+Open Group Standard is the referee document. The original Standard
+can be obtained online at <A HREF="http://www.opengroup.org/unix/online.html">http://www.opengroup.org/unix/online.html</A>
+. 
+</P>
+<P>Modified by Ross Johnson for use with <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A>.</P>
+<HR>
+<P><A NAME="toc"></A><B>Table of Contents</B></P>
+<UL>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
+	Value</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Examples</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Application
+	Usage</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">Rationale</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect8" NAME="toc8">Future
+	Directions</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect9" NAME="toc9">See
+	Also</A> 
+	</P>
+	<LI><P><A HREF="#sect10" NAME="toc10">Copyright</A> 
+	</P>
+</UL>
+</BODY>
+</HTML>
diff --git a/src/include/pthread/manual/pthread_rwlockattr_setpshared.html b/src/include/pthread/manual/pthread_rwlockattr_setpshared.html
new file mode 100644
index 0000000..dfe033e
--- /dev/null
+++ b/src/include/pthread/manual/pthread_rwlockattr_setpshared.html
@@ -0,0 +1,155 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
+	<TITLE>PTHREAD_RWLOCKATTR_SETPSHARED(3) manual page</TITLE>
+</HEAD>
+<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
+<H4>POSIX Threads for Windows – REFERENCE - <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A></H4>
+<P><A HREF="index.html">Reference Index</A></P>
+<P><A HREF="#toc">Table of Contents</A></P>
+<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P>pthread_rwlockattr_getpshared, pthread_rwlockattr_setpshared - get
+and set the process-shared attribute of the read-write lock
+attributes object 
+</P>
+<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P><B>#include &lt;pthread.h&gt; </B>
+</P>
+<P><B>int pthread_rwlockattr_getpshared(const pthread_rwlockattr_t *
+restrict </B><I>attr</I><B>, int *restrict</B> <I>pshared</I><B>);
+<BR>int pthread_rwlockattr_setpshared(pthread_rwlockattr_t <I>*</I></B><I>attr</I><B>,
+int</B> <I>pshared</I><B>); </B>
+</P>
+<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P>The <B>pthread_rwlockattr_getpshared</B> function shall obtain the
+value of the <I>process-shared</I> attribute from the initialized
+attributes object referenced by <I>attr</I>. The
+<B>pthread_rwlockattr_setpshared</B> function shall set the
+<I>process-shared</I> attribute in an initialized attributes object
+referenced by <I>attr</I>. 
+</P>
+<P>The <I>process-shared</I> attribute shall be set to
+<B>PTHREAD_PROCESS_SHARED</B> to permit a read-write lock to be
+operated upon by any thread that has access to the memory where the
+read-write lock is allocated, even if the read-write lock is
+allocated in memory that is shared by multiple processes. If the
+<I>process-shared</I> attribute is <B>PTHREAD_PROCESS_PRIVATE</B>,
+the read-write lock shall only be operated upon by threads created
+within the same process as the thread that initialized the read-write
+lock; if threads of differing processes attempt to operate on such a
+read-write lock, the behavior is undefined. The default value of the
+<I>process-shared</I> attribute shall be <B>PTHREAD_PROCESS_PRIVATE</B>.
+</P>
+<P><B>PThreads4W</B> defines <B>_POSIX_THREAD_PROCESS_SHARED</B> in
+pthread.h as -1 to indicate that these routines are implemented but
+they do not support the process shared option.</P>
+<P>Additional attributes, their default values, and the names of the
+associated functions to get and set those attribute values are
+implementation-defined. 
+</P>
+<P><B>PThreads4W</B> defines <B>_POSIX_READER_WRITER_LOCKS</B> in
+pthread.h as  200112L to indicate that the reader/writer routines are
+implemented and may be used.</P>
+<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
+<P>Upon successful completion, the <B>pthread_rwlockattr_getpshared</B>
+function shall return zero and store the value of the <I>process-shared</I>
+attribute of <I>attr</I> into the object referenced by the <I>pshared</I>
+parameter. Otherwise, an error number shall be returned to indicate
+the error. 
+</P>
+<P>If successful, the <B>pthread_rwlockattr_setpshared</B> function
+shall return zero; otherwise, an error number shall be returned to
+indicate the error. 
+</P>
+<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
+<P>The <B>pthread_rwlockattr_getpshared</B> and
+<B>pthread_rwlockattr_setpshared</B> functions may fail if: 
+</P>
+<DL>
+	<DT><B>EINVAL</B> 
+	</DT><DD STYLE="margin-bottom: 0.5cm">
+	The value specified by <I>attr</I> is invalid. 
+	</DD></DL>
+<P>
+The <B>pthread_rwlockattr_setpshared</B> function may fail if: 
+</P>
+<DL>
+	<DT><B>EINVAL</B> 
+	</DT><DD STYLE="margin-bottom: 0.5cm">
+	The new value specified for the attribute is outside the range of
+	legal values for that attribute. 
+	</DD><DT>
+	<B>ENOTSUP</B> 
+	</DT><DD STYLE="margin-bottom: 0.5cm">
+	The new value specified for the attribute is <B>PTHREAD_PROCESS_SHARED</B>.
+		</DD></DL>
+<P>
+These functions shall not return an error code of [EINTR]. 
+</P>
+<P><I>The following sections are informative.</I> 
+</P>
+<H2><A HREF="#toc5" NAME="sect5">Examples</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc6" NAME="sect6">Application Usage</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc7" NAME="sect7">Rationale</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc8" NAME="sect8">Future Directions</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc9" NAME="sect9">See Also</A></H2>
+<P><A HREF="pthread_rwlock_init.html"><B>pthread_rwlock_destroy</B>(3)</A>
+<B>,</B> <A HREF="pthread_rwlockattr_init.html"><B>pthread_rwlockattr_destroy</B>(3)</A>
+<B>,</B> <A HREF="pthread_rwlockattr_init.html"><B>pthread_rwlockattr_init</B>(3)</A>
+<B>,</B> the Base Definitions volume of IEEE&nbsp;Std&nbsp;1003.1-2001,
+<I>&lt;pthread.h&gt;</I> 
+</P>
+<H2><A HREF="#toc10" NAME="sect10">Copyright</A></H2>
+<P>Portions of this text are reprinted and reproduced in electronic
+form from IEEE Std 1003.1, 2003 Edition, Standard for Information
+Technology -- Portable Operating System Interface (POSIX), The Open
+Group Base Specifications Issue 6, Copyright (C) 2001-2003 by the
+Institute of Electrical and Electronics Engineers, Inc and The Open
+Group. In the event of any discrepancy between this version and the
+original IEEE and The Open Group Standard, the original IEEE and The
+Open Group Standard is the referee document. The original Standard
+can be obtained online at <A HREF="http://www.opengroup.org/unix/online.html">http://www.opengroup.org/unix/online.html</A>
+. 
+</P>
+<P>Modified by Ross Johnson for use with <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A>.</P>
+<HR>
+<P><A NAME="toc"></A><B>Table of Contents</B></P>
+<UL>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
+	Value</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Examples</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Application
+	Usage</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">Rationale</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect8" NAME="toc8">Future
+	Directions</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect9" NAME="toc9">See
+	Also</A> 
+	</P>
+	<LI><P><A HREF="#sect10" NAME="toc10">Copyright</A> 
+	</P>
+</UL>
+</BODY>
+</HTML>
diff --git a/src/include/pthread/manual/pthread_self.html b/src/include/pthread/manual/pthread_self.html
new file mode 100644
index 0000000..f0080ea
--- /dev/null
+++ b/src/include/pthread/manual/pthread_self.html
@@ -0,0 +1,65 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
+	<TITLE>PTHREAD_SELF(3) manual page</TITLE>
+</HEAD>
+<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
+<H4>POSIX Threads for Windows – REFERENCE - <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A></H4>
+<P><A HREF="index.html">Reference Index</A></P>
+<P><A HREF="#toc">Table of Contents</A></P>
+<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P>pthread_self - return identifier of current thread 
+</P>
+<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P><B>#include &lt;pthread.h&gt;</B> 
+</P>
+<P><B>pthread_t pthread_self(void);</B> 
+</P>
+<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P><B>pthread_self</B> return the thread identifier for the calling
+thread. 
+</P>
+<P><B>PThreads4W</B> also provides support for <B>Win32</B> native
+threads to interact with POSIX threads through the pthreads API.
+Whereas all threads created via a call to pthread_create have a POSIX
+thread ID and thread state, the library ensures that any Win32 native
+threads that interact through the Pthreads API also generate a POSIX
+thread ID and thread state when and if necessary. This provides full
+<SPAN LANG="en-GB">reciprocity</SPAN> between Win32 and POSIX
+threads. Win32 native threads that generate a POSIX thread ID and
+state are treated by the library as having been created with the
+<B>PTHREAD_CREATE_DETACHED</B> attribute.</P>
+<P>Any Win32 native thread may call <B>pthread_self</B> directly to
+return it's POSIX thread identifier. The ID and state will be
+generated if it does not already exist. Win32 native threads do not
+need to call <B>pthread_self</B> before calling PThreads4W routines
+unless that routine requires a pthread_t parameter.</P>
+<H2><A HREF="#toc3" NAME="sect3">Author</A></H2>
+<P>Xavier Leroy &lt;Xavier.Leroy@inria.fr&gt; 
+</P>
+<P>Modified by Ross Johnson for use with <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A>.</P>
+<H2><A HREF="#toc4" NAME="sect4">See Also</A></H2>
+<P><A HREF="pthread_equal.html"><B>pthread_equal</B>(3)</A> ,
+<A HREF="pthread_join.html"><B>pthread_join</B>(3)</A> ,
+<A HREF="pthread_detach.html"><B>pthread_detach</B>(3)</A> ,
+<A HREF="pthread_setschedparam.html"><B>pthread_setschedparam</B>(3)</A>
+, <A HREF="pthread_setschedparam.html"><B>pthread_getschedparam</B>(3)</A>
+. 
+</P>
+<HR>
+<P><A NAME="toc"></A><B>Table of Contents</B></P>
+<UL>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Author</A>
+		</P>
+	<LI><P><A HREF="#sect4" NAME="toc4">See Also</A> 
+	</P>
+</UL>
+</BODY>
+</HTML>
diff --git a/src/include/pthread/manual/pthread_setaffinity_np.html b/src/include/pthread/manual/pthread_setaffinity_np.html
new file mode 100644
index 0000000..3983171
--- /dev/null
+++ b/src/include/pthread/manual/pthread_setaffinity_np.html
@@ -0,0 +1,134 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<TITLE>PTHREAD_SETAFFINITY_NP(3) manual page</TITLE>
+	<STYLE TYPE="text/css">
+	<!--
+		H4.cjk { font-family: "SimSun" }
+		H4.ctl { font-family: "Mangal" }
+		H2.cjk { font-family: "SimSun" }
+		H2.ctl { font-family: "Mangal" }
+	-->
+	</STYLE>
+</HEAD>
+<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
+<H4 CLASS="western"><FONT FACE="Times New Roman, serif"><FONT SIZE=3><SPAN STYLE="font-style: normal">POSIX
+Threads for Windows &ndash; REFERENCE - <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A></SPAN></FONT></FONT></H4>
+<P><A HREF="index.html">Reference Index</A></P>
+<P><A HREF="#toc">Table of Contents</A></P>
+<H2 CLASS="western"><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P>pthread_setaffinity_np - set thread CPU affinity</P>
+<P>pthread_getaffinity_np - get thread CPU affinity</P>
+<H2 CLASS="western"><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P><B>#include &lt;pthread.h&gt; </B>
+</P>
+<P><B>int pthread_setaffinity_np(pthread_t </B><I><SPAN STYLE="font-weight: normal">tid</SPAN></I><B>,
+int </B><I><SPAN STYLE="font-weight: normal">cpusetsize</SPAN></I><B>,
+const cpu_set_t *</B><I><SPAN STYLE="font-weight: normal">mask</SPAN></I><B>);</B></P>
+<P><B>int pthread_getaffinity_np(pthread_t </B><I><SPAN STYLE="font-weight: normal">tid</SPAN></I><B>,
+int </B><I><SPAN STYLE="font-weight: normal">cpusetsize</SPAN></I><B>,
+cpu_set_t *</B><I><SPAN STYLE="font-weight: normal">mask</SPAN></I><B>);</B></P>
+<H2 CLASS="western"><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P><B>pthread_setaffinity_np</B> sets the CPU affinity mask of the thread
+whose ID is <I>tid</I> to the value specified by mask. The argument <I>cpusetsize</I>
+is the length (in bytes) of the data pointed to by <I>mask</I>.
+Normally this argument would be specified as <I>sizeof(cpu_set_t)</I>.</P>
+<P>If the thread specified by <I>tid</I> is not currently running on
+one of the CPUs specified in <I>mask</I>, then that thread is
+migrated to one of the CPUs specified in <I>mask</I>.</P>
+<P>After a call to <B>pthread_setaffinity_np</B>, the set of CPUs on which
+the thread will actually run is the intersection of the set
+specified in the <I>mask</I> argument and the set of CPUs actually
+present on the system.</P>
+<P><B>pthread_getaffinity_np</B> writes the affinity mask of the thread
+whose ID is <I>tid</I> into the cpu_set_t structure pointed to by
+<I>mask</I>. The <I>cpusetsize</I> argument specifies the size (in
+bytes) of <I>mask</I>.
+<P><B>PThreads4W</B> currently ignores the <I>cpusetsize</I>
+parameter for either function because cpu_set_t is a direct typeset
+to the Windows affinity vector type DWORD_PTR.</P>
+<H2 CLASS="western"><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
+<P>On success, <B>pthread_setaffinity_np</B> and <B>pthread_getaffinity_np</B>
+return 0. On error, an error number is returned.</P>
+<H2 CLASS="western"><A HREF="#toc4" NAME="sect4">Errors</A></H2>
+<DL>
+	<DT><B>EFAULT</B></DT><DL>
+		<DL>
+			<DT STYLE="margin-left: 0.02cm">
+			A supplied memory address was invalid.</DT></DL>
+	</DL>
+	<DT>
+	<B>EINVAL</B></DT><DL>
+		<DL>
+			<DT STYLE="margin-left: 0.04cm">
+			The affinity bit mask mask contains no processors that are
+			currently physically on the system.</DT></DL>
+	</DL>
+	<DT>
+	<B>EAGAIN</B></DT><DL>
+		<DL>
+			<DT STYLE="margin-left: 0.02cm">
+			The function did not succeed in changing or obtaining the CPU
+			affinity for some undetermined reason. Try again.</DT></DL>
+	</DL>
+	<DT>
+	<B>EPERM</B></DT><DL>
+		<DL>
+			<DT STYLE="margin-left: 0.02cm">
+			The calling process does not have appropriate privileges.</DT></DL>
+	</DL>
+	<DT>
+	<B>ESRCH</B> 
+	</DT><DL>
+		<DL>
+			<DT STYLE="margin-left: 0.02cm">
+			The thread whose ID is tid could not be found.</DT></DL>
+	</DL>
+</DL>
+<H2 CLASS="western">
+<A HREF="#toc5" NAME="sect5">Application Usage</A></H2>
+<P>A thread's CPU affinity mask determines the set of CPUs on which
+it is eligible to run. On a multiprocessor system, setting the CPU
+affinity mask can be used to obtain performance benefits. For
+example, by dedicating one CPU to a particular thread (i.e., setting
+the affinity mask of that thread to specify a single CPU, and
+setting the affinity mask of all other threads to exclude that
+CPU), it is possible to ensure maximum execution speed for that
+thread. Restricting a thread to run on a single CPU also minimises the
+performance cost caused by the cache invalidation that occurs when a
+thread ceases to execute on one CPU and then recommences execution
+on a different CPU.</P>
+<P>A CPU affinity mask is represented by the cpu_set_t structure, a
+&quot;CPU set&quot;, pointed to by <I>mask</I>. A set of macros for
+manipulating CPU sets is described in <B>cpu_set</B>(3).</P>
+<H2 CLASS="western"><A HREF="#toc6" NAME="sect6">See Also</A></H2>
+<P><A HREF="cpu_set.html"><B>cpu_set</B>(3)</A>,
+<A HREF="sched_setaffinity.html"><B>sched_setaffininty</B>(3)</A>,
+<A HREF="sched_setaffinity.html"><B>sched_getaffinity</B>(3)</A></P>
+<H2 CLASS="western"><A HREF="#toc7" NAME="sect7">Copyright</A></H2>
+<P>Most of this is taken from the Linux manual page.</P>
+<P>Modified by Ross Johnson for use with <B>PThreads4W</B>.</P>
+<HR>
+<P><A NAME="toc"></A><B>Table of Contents</B></P>
+<UL>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
+	Value</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Application
+	Usage</A></P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">See
+	Also</A></P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">Copyright</A></P>
+</UL>
+<H4 CLASS="western"><BR><BR>
+</H4>
+</BODY>
+</HTML>
\ No newline at end of file
diff --git a/src/include/pthread/manual/pthread_setcancelstate.html b/src/include/pthread/manual/pthread_setcancelstate.html
new file mode 100644
index 0000000..231625c
--- /dev/null
+++ b/src/include/pthread/manual/pthread_setcancelstate.html
@@ -0,0 +1,202 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
+	<TITLE>PTHREAD_SETCANCELSTATE(3) manual page</TITLE>
+</HEAD>
+<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
+<H4>POSIX Threads for Windows – REFERENCE - <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A></H4>
+<P><A HREF="index.html">Reference Index</A></P>
+<P><A HREF="#toc">Table of Contents</A></P>
+<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P>pthread_cancel, pthread_setcancelstate, pthread_setcanceltype,
+pthread_testcancel - thread cancellation 
+</P>
+<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P><B>#include &lt;pthread.h&gt;</B> 
+</P>
+<P><B>int pthread_cancel(pthread_t </B><I>thread</I><B>);</B> 
+</P>
+<P><B>int pthread_setcancelstate(int </B><I>state</I><B>, int
+*</B><I>oldstate</I><B>);</B> 
+</P>
+<P><B>int pthread_setcanceltype(int </B><I>type</I><B>, int
+*</B><I>oldtype</I><B>);</B> 
+</P>
+<P><B>void pthread_testcancel(void);</B> 
+</P>
+<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P>Cancellation is the mechanism by which a thread can terminate the
+execution of another thread. More precisely, a thread can send a
+cancellation request to another thread. Depending on its settings,
+the target thread can then either ignore the request, honor it
+immediately, or defer it until it reaches a cancellation point. 
+</P>
+<P>When a thread eventually honors a cancellation request, it
+performs as if <B>pthread_exit(PTHREAD_CANCELED)</B> has been called
+at that point: all cleanup handlers are executed in reverse order,
+destructor functions for thread-specific data are called, and finally
+the thread stops executing with the return value <B>PTHREAD_CANCELED</B>.
+See <A HREF="pthread_exit.html"><B>pthread_exit</B>(3)</A> for more
+information. 
+</P>
+<P><B>pthread_cancel</B> sends a cancellation request to the thread
+denoted by the <I>thread</I> argument. 
+</P>
+<P><B>pthread_setcancelstate</B> changes the cancellation state for
+the calling thread -- that is, whether cancellation requests are
+ignored or not. The <I>state</I> argument is the new cancellation
+state: either <B>PTHREAD_CANCEL_ENABLE</B> to enable cancellation, or
+<B>PTHREAD_CANCEL_DISABLE</B> to disable cancellation (cancellation
+requests are ignored). If <I>oldstate</I> is not <B>NULL</B>, the
+previous cancellation state is stored in the location pointed to by
+<I>oldstate</I>, and can thus be restored later by another call to
+<B>pthread_setcancelstate</B>. 
+</P>
+<P><B>pthread_setcanceltype</B> changes the type of responses to
+cancellation requests for the calling thread: asynchronous
+(immediate) or deferred. The <I>type</I> argument is the new
+cancellation type: either <B>PTHREAD_CANCEL_ASYNCHRONOUS</B> to
+cancel the calling thread as soon as the cancellation request is
+received, or <B>PTHREAD_CANCEL_DEFERRED</B> to keep the cancellation
+request pending until the next cancellation point. If <I>oldtype</I>
+is not <B>NULL</B>, the previous cancellation state is stored in the
+location pointed to by <I>oldtype</I>, and can thus be restored later
+by another call to <B>pthread_setcanceltype</B>. 
+</P>
+<P><B>PThreads4W</B> provides two levels of support for
+<B>PTHREAD_CANCEL_ASYNCHRONOUS</B>: full and partial. Full support
+requires an additional DLL and driver be installed on the Windows
+system (see the See Also section below) that allows blocked threads
+to be cancelled immediately. Partial support means that the target
+thread will not cancel until it resumes execution naturally. Partial
+support is provided if either the DLL or the driver are not
+automatically detected by the PThreads4W library at run-time.</P>
+<P>Threads are always created by <A HREF="pthread_create.html"><B>pthread_create</B>(3)</A>
+with cancellation enabled and deferred. That is, the initial
+cancellation state is <B>PTHREAD_CANCEL_ENABLE</B> and the initial
+type is <B>PTHREAD_CANCEL_DEFERRED</B>. 
+</P>
+<P>Cancellation points are those points in the program execution
+where a test for pending cancellation requests is performed and
+cancellation is executed if positive. The following POSIX threads
+functions are cancellation points: 
+</P>
+<P><A HREF="pthread_join.html"><B>pthread_join</B>(3)</A>
+<BR><A HREF="pthread_cond_wait.html"><B>pthread_cond_wait</B>(3)</A>
+<BR><A HREF="pthread_cond_timedwait.html"><B>pthread_cond_timedwait</B>(3)</A>
+<BR><A HREF="pthread_testcancel.html"><B>pthread_testcancel</B>(3)</A>
+<BR><A HREF="sem_wait.html"><B>sem_wait</B>(3)</A> <BR><A HREF="sem_timedwait.html"><B>sem_timedwait</B>(3)</A>
+<BR><A HREF="sigwait.html"><B>sigwait</B>(3)</A> (not supported under
+<B>PThreads4W</B>)</P>
+<P><B>PThreads4W</B> provides two functions to enable additional
+cancellation points to be created in user functions that block on
+Win32 HANDLEs:</P>
+<P><A HREF="pthreadCancelableWait.html">pthreadCancelableWait()</A>
+<BR><A HREF="pthreadCancelableTimedWait.html">pthreadCancelableTimedWait()</A></P>
+<P>All other POSIX threads functions are guaranteed not to be
+cancellation points. That is, they never perform cancellation in
+deferred cancellation mode. 
+</P>
+<P><B>pthread_testcancel</B> does nothing except testing for pending
+cancellation and executing it. Its purpose is to introduce explicit
+checks for cancellation in long sequences of code that do not call
+cancellation point functions otherwise. 
+</P>
+<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
+<P><B>pthread_cancel</B>, <B>pthread_setcancelstate</B> and
+<B>pthread_setcanceltype</B> return 0 on success and a non-zero error
+code on error. 
+</P>
+<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
+<P><B>pthread_cancel</B> returns the following error code on error: 
+</P>
+<DL>
+	<DL>
+		<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>ESRCH</B> 
+		</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
+		no thread could be found corresponding to that specified by the
+		<I>thread</I> ID. 
+		</DD></DL>
+</DL>
+<P>
+<B>pthread_setcancelstate</B> returns the following error code on
+error: 
+</P>
+<DL>
+	<DL>
+		<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EINVAL</B> 
+		</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
+		the <I>state</I> argument is not 
+		</DD></DL>
+</DL>
+<BLOCKQUOTE>
+<B>PTHREAD_CANCEL_ENABLE</B> nor <B>PTHREAD_CANCEL_DISABLE</B> 
+</BLOCKQUOTE>
+<P><B>pthread_setcanceltype</B> returns the following error code on
+error: 
+</P>
+<DL>
+	<DL>
+		<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EINVAL</B> 
+		</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
+		the <I>type</I> argument is not 
+		</DD></DL>
+</DL>
+<BLOCKQUOTE>
+<B>PTHREAD_CANCEL_DEFERRED</B> nor <B>PTHREAD_CANCEL_ASYNCHRONOUS</B>
+</BLOCKQUOTE>
+<H2><A HREF="#toc5" NAME="sect5">Author</A></H2>
+<P>Xavier Leroy &lt;Xavier.Leroy@inria.fr&gt; 
+</P>
+<P>Modified by Ross Johnson for use with <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A>.</P>
+<H2><A HREF="#toc6" NAME="sect6">See Also</A></H2>
+<P><A HREF="pthread_exit.html"><B>pthread_exit</B>(3)</A> ,
+<A HREF="pthread_cleanup_push.html"><B>pthread_cleanup_push</B>(3)</A>
+, <A HREF="pthread_cleanup_pop.html"><B>pthread_cleanup_pop</B>(3)</A>
+, PThreads4W package README file 'Prerequisites' section. 
+</P>
+<H2><A HREF="#toc7" NAME="sect7">Bugs</A></H2>
+<P>POSIX specifies that a number of system calls (basically, all
+system calls that may block, such as <A HREF="read.html"><B>read</B>(2)</A>
+, <A HREF="write.html"><B>write</B>(2)</A> , <A HREF="wait.html"><B>wait</B>(2)</A>
+, etc.) and library functions that may call these system calls (e.g.
+<A HREF="fprintf.html"><B>fprintf</B>(3)</A> ) are cancellation
+points. <B>PThreads4W</B> is not integrated enough with the C
+library to implement this, and thus none of the C library functions
+is a cancellation point. 
+</P>
+<P>A workaround for these calls is to temporarily switch to
+asynchronous cancellation (assuming full asynchronous cancellation
+support is installed). So, checking for cancellation during a <B>read</B>
+system call, for instance, can be achieved as follows: 
+</P>
+<BLOCKQUOTE><BR><BR>
+</BLOCKQUOTE>
+<PRE STYLE="margin-left: 1cm; margin-right: 1cm">pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &amp;oldCancelType);
+read(fd, buffer, length);
+pthread_setcanceltype(oldCancelType, NULL);</PRE>
+<HR>
+<BLOCKQUOTE><A NAME="toc"></A><B>Table of Contents</B></BLOCKQUOTE>
+<UL>
+	<LI><BLOCKQUOTE STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
+		</BLOCKQUOTE>
+	<LI><BLOCKQUOTE STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</BLOCKQUOTE>
+	<LI><BLOCKQUOTE STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
+		</BLOCKQUOTE>
+	<LI><BLOCKQUOTE STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
+	Value</A> 
+	</BLOCKQUOTE>
+	<LI><BLOCKQUOTE STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
+		</BLOCKQUOTE>
+	<LI><BLOCKQUOTE STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Author</A>
+		</BLOCKQUOTE>
+	<LI><BLOCKQUOTE STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">See
+	Also</A> 
+	</BLOCKQUOTE>
+	<LI><BLOCKQUOTE><A HREF="#sect7" NAME="toc7">Bugs</A> 
+	</BLOCKQUOTE>
+</UL>
+</BODY>
+</HTML>
diff --git a/src/include/pthread/manual/pthread_setcanceltype.html b/src/include/pthread/manual/pthread_setcanceltype.html
new file mode 100644
index 0000000..231625c
--- /dev/null
+++ b/src/include/pthread/manual/pthread_setcanceltype.html
@@ -0,0 +1,202 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
+	<TITLE>PTHREAD_SETCANCELSTATE(3) manual page</TITLE>
+</HEAD>
+<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
+<H4>POSIX Threads for Windows – REFERENCE - <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A></H4>
+<P><A HREF="index.html">Reference Index</A></P>
+<P><A HREF="#toc">Table of Contents</A></P>
+<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P>pthread_cancel, pthread_setcancelstate, pthread_setcanceltype,
+pthread_testcancel - thread cancellation 
+</P>
+<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P><B>#include &lt;pthread.h&gt;</B> 
+</P>
+<P><B>int pthread_cancel(pthread_t </B><I>thread</I><B>);</B> 
+</P>
+<P><B>int pthread_setcancelstate(int </B><I>state</I><B>, int
+*</B><I>oldstate</I><B>);</B> 
+</P>
+<P><B>int pthread_setcanceltype(int </B><I>type</I><B>, int
+*</B><I>oldtype</I><B>);</B> 
+</P>
+<P><B>void pthread_testcancel(void);</B> 
+</P>
+<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P>Cancellation is the mechanism by which a thread can terminate the
+execution of another thread. More precisely, a thread can send a
+cancellation request to another thread. Depending on its settings,
+the target thread can then either ignore the request, honor it
+immediately, or defer it until it reaches a cancellation point. 
+</P>
+<P>When a thread eventually honors a cancellation request, it
+performs as if <B>pthread_exit(PTHREAD_CANCELED)</B> has been called
+at that point: all cleanup handlers are executed in reverse order,
+destructor functions for thread-specific data are called, and finally
+the thread stops executing with the return value <B>PTHREAD_CANCELED</B>.
+See <A HREF="pthread_exit.html"><B>pthread_exit</B>(3)</A> for more
+information. 
+</P>
+<P><B>pthread_cancel</B> sends a cancellation request to the thread
+denoted by the <I>thread</I> argument. 
+</P>
+<P><B>pthread_setcancelstate</B> changes the cancellation state for
+the calling thread -- that is, whether cancellation requests are
+ignored or not. The <I>state</I> argument is the new cancellation
+state: either <B>PTHREAD_CANCEL_ENABLE</B> to enable cancellation, or
+<B>PTHREAD_CANCEL_DISABLE</B> to disable cancellation (cancellation
+requests are ignored). If <I>oldstate</I> is not <B>NULL</B>, the
+previous cancellation state is stored in the location pointed to by
+<I>oldstate</I>, and can thus be restored later by another call to
+<B>pthread_setcancelstate</B>. 
+</P>
+<P><B>pthread_setcanceltype</B> changes the type of responses to
+cancellation requests for the calling thread: asynchronous
+(immediate) or deferred. The <I>type</I> argument is the new
+cancellation type: either <B>PTHREAD_CANCEL_ASYNCHRONOUS</B> to
+cancel the calling thread as soon as the cancellation request is
+received, or <B>PTHREAD_CANCEL_DEFERRED</B> to keep the cancellation
+request pending until the next cancellation point. If <I>oldtype</I>
+is not <B>NULL</B>, the previous cancellation state is stored in the
+location pointed to by <I>oldtype</I>, and can thus be restored later
+by another call to <B>pthread_setcanceltype</B>. 
+</P>
+<P><B>PThreads4W</B> provides two levels of support for
+<B>PTHREAD_CANCEL_ASYNCHRONOUS</B>: full and partial. Full support
+requires an additional DLL and driver be installed on the Windows
+system (see the See Also section below) that allows blocked threads
+to be cancelled immediately. Partial support means that the target
+thread will not cancel until it resumes execution naturally. Partial
+support is provided if either the DLL or the driver are not
+automatically detected by the PThreads4W library at run-time.</P>
+<P>Threads are always created by <A HREF="pthread_create.html"><B>pthread_create</B>(3)</A>
+with cancellation enabled and deferred. That is, the initial
+cancellation state is <B>PTHREAD_CANCEL_ENABLE</B> and the initial
+type is <B>PTHREAD_CANCEL_DEFERRED</B>. 
+</P>
+<P>Cancellation points are those points in the program execution
+where a test for pending cancellation requests is performed and
+cancellation is executed if positive. The following POSIX threads
+functions are cancellation points: 
+</P>
+<P><A HREF="pthread_join.html"><B>pthread_join</B>(3)</A>
+<BR><A HREF="pthread_cond_wait.html"><B>pthread_cond_wait</B>(3)</A>
+<BR><A HREF="pthread_cond_timedwait.html"><B>pthread_cond_timedwait</B>(3)</A>
+<BR><A HREF="pthread_testcancel.html"><B>pthread_testcancel</B>(3)</A>
+<BR><A HREF="sem_wait.html"><B>sem_wait</B>(3)</A> <BR><A HREF="sem_timedwait.html"><B>sem_timedwait</B>(3)</A>
+<BR><A HREF="sigwait.html"><B>sigwait</B>(3)</A> (not supported under
+<B>PThreads4W</B>)</P>
+<P><B>PThreads4W</B> provides two functions to enable additional
+cancellation points to be created in user functions that block on
+Win32 HANDLEs:</P>
+<P><A HREF="pthreadCancelableWait.html">pthreadCancelableWait()</A>
+<BR><A HREF="pthreadCancelableTimedWait.html">pthreadCancelableTimedWait()</A></P>
+<P>All other POSIX threads functions are guaranteed not to be
+cancellation points. That is, they never perform cancellation in
+deferred cancellation mode. 
+</P>
+<P><B>pthread_testcancel</B> does nothing except testing for pending
+cancellation and executing it. Its purpose is to introduce explicit
+checks for cancellation in long sequences of code that do not call
+cancellation point functions otherwise. 
+</P>
+<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
+<P><B>pthread_cancel</B>, <B>pthread_setcancelstate</B> and
+<B>pthread_setcanceltype</B> return 0 on success and a non-zero error
+code on error. 
+</P>
+<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
+<P><B>pthread_cancel</B> returns the following error code on error: 
+</P>
+<DL>
+	<DL>
+		<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>ESRCH</B> 
+		</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
+		no thread could be found corresponding to that specified by the
+		<I>thread</I> ID. 
+		</DD></DL>
+</DL>
+<P>
+<B>pthread_setcancelstate</B> returns the following error code on
+error: 
+</P>
+<DL>
+	<DL>
+		<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EINVAL</B> 
+		</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
+		the <I>state</I> argument is not 
+		</DD></DL>
+</DL>
+<BLOCKQUOTE>
+<B>PTHREAD_CANCEL_ENABLE</B> nor <B>PTHREAD_CANCEL_DISABLE</B> 
+</BLOCKQUOTE>
+<P><B>pthread_setcanceltype</B> returns the following error code on
+error: 
+</P>
+<DL>
+	<DL>
+		<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EINVAL</B> 
+		</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
+		the <I>type</I> argument is not 
+		</DD></DL>
+</DL>
+<BLOCKQUOTE>
+<B>PTHREAD_CANCEL_DEFERRED</B> nor <B>PTHREAD_CANCEL_ASYNCHRONOUS</B>
+</BLOCKQUOTE>
+<H2><A HREF="#toc5" NAME="sect5">Author</A></H2>
+<P>Xavier Leroy &lt;Xavier.Leroy@inria.fr&gt; 
+</P>
+<P>Modified by Ross Johnson for use with <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A>.</P>
+<H2><A HREF="#toc6" NAME="sect6">See Also</A></H2>
+<P><A HREF="pthread_exit.html"><B>pthread_exit</B>(3)</A> ,
+<A HREF="pthread_cleanup_push.html"><B>pthread_cleanup_push</B>(3)</A>
+, <A HREF="pthread_cleanup_pop.html"><B>pthread_cleanup_pop</B>(3)</A>
+, PThreads4W package README file 'Prerequisites' section. 
+</P>
+<H2><A HREF="#toc7" NAME="sect7">Bugs</A></H2>
+<P>POSIX specifies that a number of system calls (basically, all
+system calls that may block, such as <A HREF="read.html"><B>read</B>(2)</A>
+, <A HREF="write.html"><B>write</B>(2)</A> , <A HREF="wait.html"><B>wait</B>(2)</A>
+, etc.) and library functions that may call these system calls (e.g.
+<A HREF="fprintf.html"><B>fprintf</B>(3)</A> ) are cancellation
+points. <B>PThreads4W</B> is not integrated enough with the C
+library to implement this, and thus none of the C library functions
+is a cancellation point. 
+</P>
+<P>A workaround for these calls is to temporarily switch to
+asynchronous cancellation (assuming full asynchronous cancellation
+support is installed). So, checking for cancellation during a <B>read</B>
+system call, for instance, can be achieved as follows: 
+</P>
+<BLOCKQUOTE><BR><BR>
+</BLOCKQUOTE>
+<PRE STYLE="margin-left: 1cm; margin-right: 1cm">pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &amp;oldCancelType);
+read(fd, buffer, length);
+pthread_setcanceltype(oldCancelType, NULL);</PRE>
+<HR>
+<BLOCKQUOTE><A NAME="toc"></A><B>Table of Contents</B></BLOCKQUOTE>
+<UL>
+	<LI><BLOCKQUOTE STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
+		</BLOCKQUOTE>
+	<LI><BLOCKQUOTE STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</BLOCKQUOTE>
+	<LI><BLOCKQUOTE STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
+		</BLOCKQUOTE>
+	<LI><BLOCKQUOTE STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
+	Value</A> 
+	</BLOCKQUOTE>
+	<LI><BLOCKQUOTE STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
+		</BLOCKQUOTE>
+	<LI><BLOCKQUOTE STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Author</A>
+		</BLOCKQUOTE>
+	<LI><BLOCKQUOTE STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">See
+	Also</A> 
+	</BLOCKQUOTE>
+	<LI><BLOCKQUOTE><A HREF="#sect7" NAME="toc7">Bugs</A> 
+	</BLOCKQUOTE>
+</UL>
+</BODY>
+</HTML>
diff --git a/src/include/pthread/manual/pthread_setconcurrency.html b/src/include/pthread/manual/pthread_setconcurrency.html
new file mode 100644
index 0000000..cb18405
--- /dev/null
+++ b/src/include/pthread/manual/pthread_setconcurrency.html
@@ -0,0 +1,150 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
+	<TITLE>PTHREAD_SETCONCURRENCY(3) manual page</TITLE>
+</HEAD>
+<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
+<H4>POSIX Threads for Windows – REFERENCE - <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A></H4>
+<P><A HREF="index.html">Reference Index</A></P>
+<P><A HREF="#toc">Table of Contents</A></P>
+<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P>pthread_getconcurrency, pthread_setconcurrency - get and set the
+level of concurrency 
+</P>
+<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P><B>#include &lt;pthread.h&gt; </B>
+</P>
+<P><B>int pthread_getconcurrency(void);</B> <BR><B>int
+pthread_setconcurrency(int</B> <I>new_level</I><B>); </B>
+</P>
+<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P>Unbound threads in a process may or may not be required to be
+simultaneously active. By default, the threads implementation ensures
+that a sufficient number of threads are active so that the process
+can continue to make progress. While this conserves system resources,
+it may not produce the most effective level of concurrency. 
+</P>
+<P>The <B>pthread_setconcurrency</B> function allows an application
+to inform the threads implementation of its desired concurrency
+level, <I>new_level</I>. The actual level of concurrency provided by
+the implementation as a result of this function call is unspecified. 
+</P>
+<P>If <I>new_level</I> is zero, it causes the implementation to
+maintain the concurrency level at its discretion as if
+<B>pthread_setconcurrency</B> had never been called. 
+</P>
+<P>The <B>pthread_getconcurrency</B> function shall return the value
+set by a previous call to the <B>pthread_setconcurrency</B> function.
+If the <B>pthread_setconcurrency</B> function was not previously
+called, this function shall return zero to indicate that the
+implementation is maintaining the concurrency level. 
+</P>
+<P>A call to <B>pthread_setconcurrency</B> shall inform the
+implementation of its desired concurrency level. The implementation
+shall use this as a hint, not a requirement. 
+</P>
+<P>If an implementation does not support multiplexing of user threads
+on top of several kernel-scheduled entities, the
+<B>pthread_setconcurrency</B> and <B>pthread_getconcurrency</B>
+functions are provided for source code compatibility but they shall
+have no effect when called. To maintain the function semantics, the
+<I>new_level</I> parameter is saved when <B>pthread_setconcurrency</B>
+is called so that a subsequent call to <B>pthread_getconcurrency</B>
+shall return the same value. 
+</P>
+<P><B>PThreads4W</B> provides these routines for source code
+compatibility only, as described in the previous paragraph.</P>
+<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
+<P>If successful, the <B>pthread_setconcurrency</B> function shall
+return zero; otherwise, an error number shall be returned to indicate
+the error. 
+</P>
+<P>The <B>pthread_getconcurrency</B> function shall always return the
+concurrency level set by a previous call to <B>pthread_setconcurrency</B>
+. If the <B>pthread_setconcurrency</B> function has never been
+called, <B>pthread_getconcurrency</B> shall return zero. 
+</P>
+<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
+<P>The <B>pthread_setconcurrency</B> function shall fail if: 
+</P>
+<DL>
+	<DT><B>EINVAL</B> 
+	</DT><DD>
+	The value specified by <I>new_level</I> is negative. 
+	</DD><DT>
+	<B>EAGAIN</B> 
+	</DT><DD STYLE="margin-bottom: 0.5cm">
+	The value specific by <I>new_level</I> would cause a system resource
+	to be exceeded. 
+	</DD></DL>
+<P>
+These functions shall not return an error code of [EINTR]. 
+</P>
+<P><I>The following sections are informative.</I> 
+</P>
+<H2><A HREF="#toc5" NAME="sect5">Examples</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc6" NAME="sect6">Application Usage</A></H2>
+<P>Use of these functions changes the state of the underlying
+concurrency upon which the application depends. Library developers
+are advised to not use the <B>pthread_getconcurrency</B> and
+<B>pthread_setconcurrency</B> functions since their use may conflict
+with an applications use of these functions. 
+</P>
+<H2><A HREF="#toc7" NAME="sect7">Rationale</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc8" NAME="sect8">Future Directions</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc9" NAME="sect9">See Also</A></H2>
+<P>The Base Definitions volume of IEEE&nbsp;Std&nbsp;1003.1-2001,
+<I>&lt;pthread.h&gt;</I> 
+</P>
+<H2><A HREF="#toc10" NAME="sect10">Copyright</A></H2>
+<P>Portions of this text are reprinted and reproduced in electronic
+form from IEEE Std 1003.1, 2003 Edition, Standard for Information
+Technology -- Portable Operating System Interface (POSIX), The Open
+Group Base Specifications Issue 6, Copyright (C) 2001-2003 by the
+Institute of Electrical and Electronics Engineers, Inc and The Open
+Group. In the event of any discrepancy between this version and the
+original IEEE and The Open Group Standard, the original IEEE and The
+Open Group Standard is the referee document. The original Standard
+can be obtained online at <A HREF="http://www.opengroup.org/unix/online.html">http://www.opengroup.org/unix/online.html</A>
+. 
+</P>
+<P>Modified by Ross Johnson for use with <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A>.</P>
+<HR>
+<P><A NAME="toc"></A><B>Table of Contents</B></P>
+<UL>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
+	Value</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Examples</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Application
+	Usage</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">Rationale</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect8" NAME="toc8">Future
+	Directions</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect9" NAME="toc9">See
+	Also</A> 
+	</P>
+	<LI><P><A HREF="#sect10" NAME="toc10">Copyright</A> 
+	</P>
+</UL>
+</BODY>
+</HTML>
diff --git a/src/include/pthread/manual/pthread_setname_np.html b/src/include/pthread/manual/pthread_setname_np.html
new file mode 100644
index 0000000..5e4e8b1
--- /dev/null
+++ b/src/include/pthread/manual/pthread_setname_np.html
@@ -0,0 +1,228 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=windows-1252">
+	<TITLE>PTHREAD_SETNAME_NP(3) manual page</TITLE>
+	<STYLE TYPE="text/css">
+	<!--
+		P { margin-bottom: 0.21cm }
+		TD P { margin-bottom: 0.21cm }
+		PRE.western { font-family: "Times New Roman", serif }
+		PRE.cjk { font-family: "NSimSun", monospace }
+		H4 { margin-bottom: 0.21cm }
+		H4.western { font-family: "Arial", sans-serif; font-size: 11pt; font-style: italic }
+		H4.cjk { font-family: "Microsoft YaHei"; font-size: 11pt; font-style: italic }
+		H4.ctl { font-family: "Mangal"; font-size: 11pt; font-style: italic }
+		H2 { margin-bottom: 0.21cm }
+		H2.cjk { font-family: "SimSun" }
+		H2.ctl { font-family: "Mangal" }
+		P.list-indent { margin-left: 5cm; text-indent: -4.5cm }
+		A:link { so-language: zxx }
+	-->
+	</STYLE>
+</HEAD>
+<BODY LANG="en-AU" DIR="LTR">
+<H4 CLASS="western"><SPAN STYLE="font-variant: normal"><FONT FACE="Times New Roman, serif"><FONT SIZE=3><SPAN STYLE="font-style: normal">POSIX
+Threads for Windows &ndash; REFERENCE - <A HREF="http://sourceforge.net/projects/pthreads4w/">PThreads4W</A></SPAN></FONT></FONT></SPAN></H4>
+<P><A HREF="index.html">Reference Index</A></P>
+<P><A HREF="#toc" NAME="sect">Table of Contents</A></P>
+<H2 CLASS="western"><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P>pthread_getname_np, pthread_setname_np - get and set the thread
+name</P>
+<H2 CLASS="western"><A HREF="#toc1" NAME="sect1"><SPAN STYLE="text-decoration: none">Synopsis</SPAN></A></H2>
+<P><B>#include &lt;pthread.h&gt; </B>
+</P>
+<P><B>int pthread_getname_np(pthread_t </B><I><SPAN STYLE="font-weight: normal">thr</SPAN></I><B>,
+char * </B><I><SPAN STYLE="font-weight: normal">name</SPAN></I><B>,
+int </B><I><SPAN STYLE="font-weight: normal">len</SPAN></I><B>);</B></P>
+<P>#if defined (__PTW32_COMPATIBILITY_BSD) ||
+defined (__PTW32_COMPATIBILITY_TRU64)<BR><B>int
+pthread_setname_np(pthread_t </B><I><SPAN STYLE="font-weight: normal">thr</SPAN></I><B>,
+const char * </B><I><SPAN STYLE="font-weight: normal">name</SPAN></I><B>,
+void * </B><I><SPAN STYLE="font-weight: normal">arg</SPAN></I><B>);</B></P>
+<P>#else</P>
+<P><B>int pthread_setname_np(pthread_t </B><I><SPAN STYLE="font-weight: normal">thr</SPAN></I><B>,
+const char * </B><I><SPAN STYLE="font-weight: normal">name</SPAN></I><B>);</B></P>
+<P>#endif</P>
+<H2 CLASS="western"><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P><B>pthread_setname_np()</B> sets the descriptive name of the
+thread. It takes the following arguments.</P>
+<P>#if defined (__PTW32_COMPATIBILITY_BSD)</P>
+<TABLE WIDTH=100% CELLPADDING=4 CELLSPACING=0>
+	<COL WIDTH=30*>
+	<COL WIDTH=226*>
+	<TR VALIGN=TOP>
+		<TD WIDTH=12% STYLE="border: none; padding: 0cm">
+			<P><I>thr</I></P>
+		</TD>
+		<TD WIDTH=88% STYLE="border: none; padding: 0cm">
+			<P>The thread whose name will be set.</P>
+		</TD>
+	</TR>
+	<TR VALIGN=TOP>
+		<TD WIDTH=12% STYLE="border: none; padding: 0cm">
+			<P><I>name</I></P>
+		</TD>
+		<TD WIDTH=88% STYLE="border: none; padding: 0cm">
+			<P>The printf(3) format string to be used to construct the name of
+			the thread. The resulting name should be shorter than
+			<B>PTHREAD_MAX_NAMELEN_NP</B>.</P>
+		</TD>
+	</TR>
+	<TR VALIGN=TOP>
+		<TD WIDTH=12% STYLE="border: none; padding: 0cm">
+			<P><I>arg</I></P>
+		</TD>
+		<TD WIDTH=88% STYLE="border: none; padding: 0cm">
+			<P>The printf(3) argument used with name.</P>
+		</TD>
+	</TR>
+</TABLE>
+<P>#elif defined (__PTW32_COMPATIBILITY_TRU64)</P>
+<TABLE WIDTH=100% CELLPADDING=4 CELLSPACING=0>
+	<COL WIDTH=30*>
+	<COL WIDTH=226*>
+	<TR VALIGN=TOP>
+		<TD WIDTH=12% STYLE="border: none; padding: 0cm">
+			<P><I>thr</I></P>
+		</TD>
+		<TD WIDTH=88% STYLE="border: none; padding: 0cm">
+			<P>The thread whose name will be set.</P>
+		</TD>
+	</TR>
+	<TR VALIGN=TOP>
+		<TD WIDTH=12% STYLE="border: none; padding: 0cm">
+			<P><I>name</I></P>
+		</TD>
+		<TD WIDTH=88% STYLE="border: none; padding: 0cm">
+			<P>The name.</P>
+		</TD>
+	</TR>
+	<TR VALIGN=TOP>
+		<TD WIDTH=12% STYLE="border: none; padding: 0cm">
+			<P><I>arg</I></P>
+		</TD>
+		<TD WIDTH=88% STYLE="border: none; padding: 0cm">
+			<P>Reserved for future use.</P>
+		</TD>
+	</TR>
+</TABLE>
+<P>#else</P>
+<TABLE WIDTH=100% CELLPADDING=4 CELLSPACING=0>
+	<COL WIDTH=30*>
+	<COL WIDTH=226*>
+	<TR VALIGN=TOP>
+		<TD WIDTH=12% STYLE="border: none; padding: 0cm">
+			<P><I>thr</I></P>
+		</TD>
+		<TD WIDTH=88% STYLE="border: none; padding: 0cm">
+			<P>The thread whose name will be set.</P>
+		</TD>
+	</TR>
+	<TR VALIGN=TOP>
+		<TD WIDTH=12% STYLE="border: none; padding: 0cm">
+			<P><I>name</I></P>
+		</TD>
+		<TD WIDTH=88% STYLE="border: none; padding: 0cm">
+			<P>The name.</P>
+		</TD>
+	</TR>
+</TABLE>
+<P>#endif</P>
+<P>The string passed as the name argument is copied.</P>
+<P><BR><BR>
+</P>
+<P><B>pthread_getname_np()</B> gets the descriptive name of the
+thread. It takes the following arguments.</P>
+<TABLE WIDTH=100% CELLPADDING=4 CELLSPACING=0>
+	<COL WIDTH=30*>
+	<COL WIDTH=226*>
+	<TR VALIGN=TOP>
+		<TD WIDTH=12% STYLE="border: none; padding: 0cm">
+			<P><I>thr</I></P>
+		</TD>
+		<TD WIDTH=88% STYLE="border: none; padding: 0cm">
+			<P>The thread whose descriptive name will be obtained.</P>
+		</TD>
+	</TR>
+	<TR VALIGN=TOP>
+		<TD WIDTH=12% STYLE="border: none; padding: 0cm">
+			<P><I>name</I></P>
+		</TD>
+		<TD WIDTH=88% STYLE="border: none; padding: 0cm">
+			<P>The buffer to be filled with the descriptive name of the
+			thread.</P>
+		</TD>
+	</TR>
+	<TR VALIGN=TOP>
+		<TD WIDTH=12% STYLE="border: none; padding: 0cm">
+			<P><I>len</I></P>
+		</TD>
+		<TD WIDTH=88% STYLE="border: none; padding: 0cm">
+			<P>The size of the buffer name in bytes.</P>
+		</TD>
+	</TR>
+</TABLE>
+<P><BR><BR>
+</P>
+<P>For the MSVC built library the name is made available for use and
+display by the MSVS debugger.</P>
+<H2 CLASS="western"><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
+<P>These routines return 0 on success or an error code on failure.</P>
+<PRE CLASS="western" STYLE="margin-bottom: 0.5cm">        </PRE><H2 CLASS="western">
+<A HREF="#toc4" NAME="sect4">Errors</A></H2>
+<P>The pthread_setname_np function shall fail if: 
+</P>
+<DL>
+	<DT STYLE="margin-bottom: 0.5cm"><B>ESRCH</B> 
+	</DT></DL>
+<P CLASS="list-indent">
+The value specified by thr does not refer to a valid thread.</P>
+<DL>
+	<DT STYLE="margin-bottom: 0.5cm"><B>EINVAL</B></DT></DL>
+<P CLASS="list-indent">
+The expansion of name with arg has length greater or equal to
+<B>PTHREAD_MAX_NAMELEN_NP</B>.</P>
+<P><BR><BR>
+</P>
+<P><I>The following sections are informative. </I>
+</P>
+<H2 CLASS="western"><A HREF="#toc5" NAME="sect5">Examples</A></H2>
+<P>None. 
+</P>
+<H2 CLASS="western"><A HREF="#toc6" NAME="sect6">Application Usage</A></H2>
+<P>In addition to use within applications, when the library is built
+with MSVC, thread names set via pthread_setname_np will be available
+for display in the MSVS debugger.</P>
+<H2 CLASS="western"><A HREF="#toc7" NAME="sect7">Rationale</A></H2>
+<P>None. 
+</P>
+<H2 CLASS="western"><A HREF="#toc8" NAME="sect8">Future Directions</A></H2>
+<P>None. 
+</P>
+<H2 CLASS="western"><A HREF="#toc9" NAME="sect9">See Also</A></H2>
+<P>The Base Definitions volume of IEEE&nbsp;Std&nbsp;1003.1-2001,
+&lt;pthread.h&gt; 
+</P>
+<H2 CLASS="western"><A HREF="#sect" NAME="toc">Table of Contents</A></H2>
+<P><A HREF="#sect0" NAME="toc0">Name</A> 
+</P>
+<P><A HREF="#sect1" NAME="toc1">Synopsis</A> 
+</P>
+<P><A HREF="#sect2" NAME="toc2">Description</A> 
+</P>
+<P><A HREF="#sect3" NAME="toc3">Return Value</A> 
+</P>
+<P><A HREF="#sect4" NAME="toc4">Errors</A> 
+</P>
+<P><A HREF="#sect5" NAME="toc5">Examples</A> 
+</P>
+<P><A HREF="#sect6" NAME="toc6">Application Usage</A> 
+</P>
+<P><A HREF="#sect7" NAME="toc7">Rationale</A> 
+</P>
+<P><A HREF="#sect8" NAME="toc8">Future Directions</A> 
+</P>
+<P><A HREF="#sect9" NAME="toc9">See Also</A></P>
+</BODY>
+</HTML>
\ No newline at end of file
diff --git a/src/include/pthread/manual/pthread_setschedparam.html b/src/include/pthread/manual/pthread_setschedparam.html
new file mode 100644
index 0000000..6fe6d60
--- /dev/null
+++ b/src/include/pthread/manual/pthread_setschedparam.html
@@ -0,0 +1,108 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
+	<TITLE>PTHREAD_SETSCHEDPARAM(3) manual page</TITLE>
+</HEAD>
+<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
+<H4>POSIX Threads for Windows – REFERENCE - <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A></H4>
+<P><A HREF="index.html">Reference Index</A></P>
+<P><A HREF="#toc">Table of Contents</A></P>
+<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P>pthread_setschedparam, pthread_getschedparam - control thread
+scheduling 
+</P>
+<P>parameters 
+</P>
+<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P><B>#include &lt;pthread.h&gt;</B> 
+</P>
+<P><B>int pthread_setschedparam(pthread_t </B><I>target_thread</I><B>,
+int </B><I>policy</I><B>, const struct sched_param *</B><I>param</I><B>);</B>
+</P>
+<P><B>int pthread_getschedparam(pthread_t </B><I>target_thread</I><B>,
+int *</B><I>policy</I><B>, struct sched_param *</B><I>param</I><B>);</B>
+</P>
+<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P><B>pthread_setschedparam</B> sets the scheduling parameters for
+the thread <I>target_thread</I> as indicated by <I>policy</I> and
+<I>param</I>. <I>policy</I> can be either <B>SCHED_OTHER</B>
+(regular, non-real-time scheduling), <B>SCHED_RR</B> (real-time,
+round-robin) or <B>SCHED_FIFO</B> (real-time, first-in first-out).
+<I>param</I> specifies the scheduling priority for the two real-time
+policies.</P>
+<P><B>PThreads4W</B> only supports SCHED_OTHER and does not support
+the real-time scheduling policies <B>SCHED_RR</B> and <B>SCHED_FIFO.</B>
+</P>
+<P><B>pthread_getschedparam</B> retrieves the scheduling policy and
+scheduling parameters for the thread <I>target_thread</I> and stores
+them in the locations pointed to by <I>policy</I> and <I>param</I>,
+respectively. 
+</P>
+<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
+<P><B>pthread_setschedparam</B> and <B>pthread_getschedparam</B>
+return 0 on success and a non-zero error code on error. 
+</P>
+<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
+<P>On error, <B>pthread_setschedparam</B> returns the following error
+codes: 
+</P>
+<DL>
+	<DL>
+		<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>ENOTSUP</B> 
+		</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
+		<I>policy</I> is not <B>SCHED_OTHER.</B></DD><DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
+		<B>EINVAL</B> 
+		</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
+		One of the arguments is invalid, or the priority value specified by
+		<I>param</I> is not valid for the specified policy.</DD><DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
+		<B>ESRCH</B> 
+		</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
+		The <I>target_thread</I> is invalid or has already terminated 
+		</DD></DL>
+</DL>
+<P>
+On error, <B>pthread_getschedparam</B> returns the following error
+codes: 
+</P>
+<DL>
+	<DL>
+		<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>ESRCH</B> 
+		</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
+		the <I>target_thread</I> is invalid or has already terminated 
+		</DD></DL>
+</DL>
+<H2>
+<A HREF="#toc5" NAME="sect5">Author</A></H2>
+<P>Xavier Leroy &lt;Xavier.Leroy@inria.fr&gt; 
+</P>
+<P>Modified by Ross Johnson for use with <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A>.</P>
+<H2><A HREF="#toc6" NAME="sect6">See Also</A></H2>
+<P><A HREF="sched_setscheduler.html"><B>sched_setscheduler</B>(2)</A>
+, <A HREF="sched_getscheduler.html"><B>sched_getscheduler</B>(2)</A>
+, <A HREF="sched_getparam.html"><B>sched_getparam</B>(2)</A> ,
+<A HREF="pthread_attr_init.html"><B>pthread_attr_setschedpolicy</B>(3)</A>
+, <A HREF="pthread_attr_init.html"><B>pthread_attr_setschedparam</B>(3)</A>
+. 
+</P>
+<HR>
+<P><A NAME="toc"></A><B>Table of Contents</B></P>
+<UL>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
+	Value</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Author</A>
+		</P>
+	<LI><P><A HREF="#sect6" NAME="toc6">See Also</A> 
+	</P>
+</UL>
+</BODY>
+</HTML>
\ No newline at end of file
diff --git a/src/include/pthread/manual/pthread_spin_init.html b/src/include/pthread/manual/pthread_spin_init.html
new file mode 100644
index 0000000..2287ec1
--- /dev/null
+++ b/src/include/pthread/manual/pthread_spin_init.html
@@ -0,0 +1,171 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
+	<TITLE>PTHREAD_SPIN_INIT(3) manual page</TITLE>
+</HEAD>
+<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
+<H4>POSIX Threads for Windows – REFERENCE - <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A></H4>
+<P><A HREF="index.html">Reference Index</A></P>
+<P><A HREF="#toc">Table of Contents</A></P>
+<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P>pthread_spin_destroy, pthread_spin_init - destroy or initialize a
+spin lock object (<B>ADVANCED REALTIME THREADS</B>) 
+</P>
+<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P><B>#include &lt;pthread.h&gt; </B>
+</P>
+<P><B>pthread_spinlock_t</B> <I>lock</I> <B>=
+PTHREAD_SPINLOCK_INITIALIZER;</B></P>
+<P><B>int pthread_spin_destroy(pthread_spinlock_t *</B><I>lock</I><B>);
+<BR>int pthread_spin_init(pthread_spinlock_t *</B><I>lock</I><B>, int</B>
+<I>pshared</I><B>); </B>
+</P>
+<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P>The <B>pthread_spin_destroy</B> function shall destroy the spin
+lock referenced by <I>lock</I> and release any resources used by the
+lock. The effect of subsequent use of the lock is undefined until the
+lock is reinitialized by another call to <B>pthread_spin_init</B> .
+The results are undefined if <B>pthread_spin_destroy</B> is called
+when a thread holds the lock, or if this function is called with an
+uninitialized thread spin lock. 
+</P>
+<P>The <B>pthread_spin_init</B> function shall allocate any resources
+required to use the spin lock referenced by <I>lock</I> and
+initialize the lock to an unlocked state. 
+</P>
+<P><B>PThreads4W</B> supports single and multiple processor systems
+as well as process CPU affinity masking by checking the mask when the
+spin lock is initialized. If the process is using only a single
+processor at the time <B>pthread_spin_init</B> is called then the
+spin lock is initialized as a PTHREAD_MUTEX_NORMAL mutex object. A
+thread that calls <A HREF="pthread_spin_lock.html"><B>pthread_spin_lock(3)</B></A>
+will block rather than spin in this case. If the process CPU affinity
+mask is altered after the spin lock has been initialised, the spin
+lock is not modified, and may no longer be optimal for the number of
+CPUs available.</P>
+<P><B>PThreads4W</B> defines <B>_POSIX_THREAD_PROCESS_SHARED</B> in
+pthread.h as -1 to indicate that these routines do not support the
+<B>PTHREAD_PROCESS_SHARED</B> attribute. <B>pthread_spin_init</B>
+will return the error <B>ENOTSUP</B> if the value of <I>pshared</I>
+is not <B>PTHREAD_PROCESS_PRIVATE</B>.</P>
+<P>The results are undefined if <B>pthread_spin_init</B> is called
+specifying an already initialized spin lock. The results are
+undefined if a spin lock is used without first being initialized. 
+</P>
+<P>If the <B>pthread_spin_init</B> function fails, the lock is not
+initialized and the contents of <I>lock</I> are undefined. 
+</P>
+<P>Only the object referenced by <I>lock</I> may be used for
+performing synchronization. 
+</P>
+<P>The result of referring to copies of that object in calls to
+<B>pthread_spin_destroy</B> , <A HREF="pthread_spin_lock.html"><B>pthread_spin_lock</B>(3)</A>
+, <A HREF="pthread_spin_lock.html"><B>pthread_spin_trylock</B>(3)</A>,
+or <A HREF="pthread_spin_unlock.html"><B>pthread_spin_unlock</B>(3)</A>
+is undefined. 
+</P>
+<P><B>PThreads4W</B> supports statically initialized spin locks
+using <B>PTHREAD_SPINLOCK_INITIALIZER</B>. An application should
+still call <B>pthread_spin_destroy</B> at some point to ensure that
+any resources consumed by the spin lock are released.</P>
+<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
+<P>Upon successful completion, these functions shall return zero;
+otherwise, an error number shall be returned to indicate the error. 
+</P>
+<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
+<P>These functions may fail if: 
+</P>
+<DL>
+	<DT><B>EBUSY</B> 
+	</DT><DD>
+	The implementation has detected an attempt to initialize or destroy
+	a spin lock while it is in use (for example, while being used in a
+	<A HREF="pthread_spin_lock.html"><B>pthread_spin_lock</B>(3)</A>
+	call) by another thread. 
+	</DD><DT>
+	<B>EINVAL</B> 
+	</DT><DD STYLE="margin-bottom: 0.5cm">
+	The value specified by <I>lock</I> is invalid. 
+	</DD></DL>
+<P>
+The <B>pthread_spin_init</B> function shall fail if: 
+</P>
+<DL>
+	<DT><B>ENOTSUP</B> 
+	</DT><DD>
+	The value of <I>pshared</I> is not <B>PTHREAD_PROCESS_PRIVATE</B>.</DD><DT>
+	<B>ENOMEM</B> 
+	</DT><DD STYLE="margin-bottom: 0.5cm">
+	Insufficient memory exists to initialize the lock. 
+	</DD></DL>
+<P>
+These functions shall not return an error code of [EINTR]. 
+</P>
+<P><I>The following sections are informative.</I> 
+</P>
+<H2><A HREF="#toc5" NAME="sect5">Examples</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc6" NAME="sect6">Application Usage</A></H2>
+<P>The <B>pthread_spin_destroy</B> and <B>pthread_spin_init</B>
+functions are part of the Spin Locks option and need not be provided
+on all implementations. 
+</P>
+<H2><A HREF="#toc7" NAME="sect7">Rationale</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc8" NAME="sect8">Future Directions</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc9" NAME="sect9">See Also</A></H2>
+<P><A HREF="pthread_spin_lock.html"><B>pthread_spin_lock</B>(3)</A> <B>,</B>
+<A HREF="pthread_spin_unlock.html"><B>pthread_spin_unlock</B>(3)</A>
+<B>,</B> the Base Definitions volume of IEEE&nbsp;Std&nbsp;1003.1-2001,
+<I>&lt;pthread.h&gt;</I> 
+</P>
+<H2><A HREF="#toc10" NAME="sect10">Copyright</A></H2>
+<P>Portions of this text are reprinted and reproduced in electronic
+form from IEEE Std 1003.1, 2003 Edition, Standard for Information
+Technology -- Portable Operating System Interface (POSIX), The Open
+Group Base Specifications Issue 6, Copyright (C) 2001-2003 by the
+Institute of Electrical and Electronics Engineers, Inc and The Open
+Group. In the event of any discrepancy between this version and the
+original IEEE and The Open Group Standard, the original IEEE and The
+Open Group Standard is the referee document. The original Standard
+can be obtained online at <A HREF="http://www.opengroup.org/unix/online.html">http://www.opengroup.org/unix/online.html</A>
+. 
+</P>
+<P>Modified by Ross Johnson for use with <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A>.</P>
+<HR>
+<P><A NAME="toc"></A><B>Table of Contents</B></P>
+<UL>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
+	Value</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Examples</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Application
+	Usage</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">Rationale</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect8" NAME="toc8">Future
+	Directions</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect9" NAME="toc9">See
+	Also</A> 
+	</P>
+	<LI><P><A HREF="#sect10" NAME="toc10">Copyright</A> 
+	</P>
+</UL>
+</BODY>
+</HTML>
diff --git a/src/include/pthread/manual/pthread_spin_lock.html b/src/include/pthread/manual/pthread_spin_lock.html
new file mode 100644
index 0000000..e33b6bf
--- /dev/null
+++ b/src/include/pthread/manual/pthread_spin_lock.html
@@ -0,0 +1,136 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
+	<TITLE>PTHREAD_SPIN_LOCK(3) manual page</TITLE>
+</HEAD>
+<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
+<H4>POSIX Threads for Windows – REFERENCE - <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A></H4>
+<P><A HREF="index.html">Reference Index</A></P>
+<P><A HREF="#toc">Table of Contents</A></P>
+<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P>pthread_spin_lock, pthread_spin_trylock - lock a spin lock object
+(<B>ADVANCED REALTIME THREADS</B>) 
+</P>
+<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P><B>#include &lt;pthread.h&gt; </B>
+</P>
+<P><B>int pthread_spin_lock(pthread_spinlock_t *</B><I>lock</I><B>);
+<BR>int pthread_spin_trylock(pthread_spinlock_t *</B><I>lock</I><B>);
+</B>
+</P>
+<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P>The <B>pthread_spin_lock</B> function shall lock the spin lock
+referenced by <I>lock</I>. The calling thread shall acquire the lock
+if it is not held by another thread. Otherwise, the thread shall spin
+(that is, shall not return from the <B>pthread_spin_lock</B> call)
+until the lock becomes available. The results are undefined if the
+calling thread holds the lock at the time the call is made.</P>
+<P><B>PThreads4W</B> supports single and multiple processor systems
+as well as process CPU affinity masking by checking the mask when the
+spin lock is initialized. If the process is using only a single
+processor at the time <A HREF="pthread_spin_init.html"><B>pthread_spin_init</B>(3)</A>
+is called then the spin lock is initialized as a PTHREAD_MUTEX_NORMAL
+mutex object. A thread that calls <B>pthread_spin_lock</B> will block
+rather than spin in this case. If the process CPU affinity mask is
+altered after the spin lock has been initialised, the spin lock is
+not modified, and may no longer be optimal for the number of CPUs
+available.</P>
+<P>The <B>pthread_spin_trylock</B> function shall lock the spin lock
+referenced by <I>lock</I> if it is not held by any thread. Otherwise,
+the function shall fail. 
+</P>
+<P>The results are undefined if any of these functions is called with
+an uninitialized spin lock. 
+</P>
+<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
+<P>Upon successful completion, these functions shall return zero;
+otherwise, an error number shall be returned to indicate the error. 
+</P>
+<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
+<P>These functions may fail if: 
+</P>
+<DL>
+	<DT><B>EINVAL</B> 
+	</DT><DD STYLE="margin-bottom: 0.5cm">
+	The value specified by <I>lock</I> does not refer to an initialized
+	spin lock object. 
+	</DD></DL>
+<P>
+The <B>pthread_spin_trylock</B> function shall fail if: 
+</P>
+<DL>
+	<DT><B>EBUSY</B> 
+	</DT><DD STYLE="margin-bottom: 0.5cm">
+	A thread currently holds the lock. 
+	</DD></DL>
+<P>
+These functions shall not return an error code of [EINTR]. 
+</P>
+<P><I>The following sections are informative.</I> 
+</P>
+<H2><A HREF="#toc5" NAME="sect5">Examples</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc6" NAME="sect6">Application Usage</A></H2>
+<P>Applications using this function may be subject to priority
+inversion, as discussed in the Base Definitions volume of
+IEEE&nbsp;Std&nbsp;1003.1-2001, Section 3.285, Priority Inversion. 
+</P>
+<H2><A HREF="#toc7" NAME="sect7">Rationale</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc8" NAME="sect8">Future Directions</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc9" NAME="sect9">See Also</A></H2>
+<P><A HREF="pthread_spin_init.html"><B>pthread_spin_destroy</B>(3)</A>
+<B>,</B> <A HREF="pthread_spin_unlock.html"><B>pthread_spin_unlock</B>(3)</A>
+<B>,</B> the Base Definitions volume of IEEE&nbsp;Std&nbsp;1003.1-2001,
+<I>&lt;pthread.h&gt;</I> 
+</P>
+<H2><A HREF="#toc10" NAME="sect10">Copyright</A></H2>
+<P>Portions of this text are reprinted and reproduced in electronic
+form from IEEE Std 1003.1, 2003 Edition, Standard for Information
+Technology -- Portable Operating System Interface (POSIX), The Open
+Group Base Specifications Issue 6, Copyright (C) 2001-2003 by the
+Institute of Electrical and Electronics Engineers, Inc and The Open
+Group. In the event of any discrepancy between this version and the
+original IEEE and The Open Group Standard, the original IEEE and The
+Open Group Standard is the referee document. The original Standard
+can be obtained online at <A HREF="http://www.opengroup.org/unix/online.html">http://www.opengroup.org/unix/online.html</A>
+. 
+</P>
+<P>Modified by Ross Johnson for use with <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A>.</P>
+<HR>
+<P><A NAME="toc"></A><B>Table of Contents</B></P>
+<UL>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
+	Value</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Examples</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Application
+	Usage</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">Rationale</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect8" NAME="toc8">Future
+	Directions</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect9" NAME="toc9">See
+	Also</A> 
+	</P>
+	<LI><P><A HREF="#sect10" NAME="toc10">Copyright</A> 
+	</P>
+</UL>
+</BODY>
+</HTML>
diff --git a/src/include/pthread/manual/pthread_spin_unlock.html b/src/include/pthread/manual/pthread_spin_unlock.html
new file mode 100644
index 0000000..19d66bf
--- /dev/null
+++ b/src/include/pthread/manual/pthread_spin_unlock.html
@@ -0,0 +1,119 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
+	<TITLE>PTHREAD_SPIN_UNLOCK(3) manual page</TITLE>
+</HEAD>
+<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
+<H4>POSIX Threads for Windows – REFERENCE - <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A></H4>
+<P><A HREF="index.html">Reference Index</A></P>
+<P><A HREF="#toc">Table of Contents</A></P>
+<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P>pthread_spin_unlock - unlock a spin lock object (<B>ADVANCED
+REALTIME THREADS</B>) 
+</P>
+<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P><B>#include &lt;pthread.h&gt; </B>
+</P>
+<P><B>int pthread_spin_unlock(pthread_spinlock_t *</B><I>lock</I><B>);
+</B>
+</P>
+<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P>The <B>pthread_spin_unlock</B> function shall release the spin
+lock referenced by <I>lock</I> which was locked via the
+<A HREF="pthread_spin_lock.html"><B>pthread_spin_lock</B>(3)</A> or
+<A HREF="pthread_spin_lock.html"><B>pthread_spin_trylock</B>(3)</A>
+functions. If there are threads spinning on the lock when
+<B>pthread_spin_unlock</B> is called, the lock becomes available and
+an unspecified spinning thread shall acquire the lock. 
+</P>
+<P><B>PThreads4W</B> does not check ownership of the lock and it is
+therefore possible for a thread other than the locker to unlock the
+spin lock. This is not a feature that should be exploited.</P>
+<P>The results are undefined if this function is called with an
+uninitialized thread spin lock. 
+</P>
+<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
+<P>Upon successful completion, the <B>pthread_spin_unlock</B>
+function shall return zero; otherwise, an error number shall be
+returned to indicate the error. 
+</P>
+<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
+<P>The <B>pthread_spin_unlock</B> function may fail if: 
+</P>
+<DL>
+	<DT><B>EINVAL</B> 
+	</DT><DD>
+	An invalid argument was specified. 
+	</DD><DD STYLE="margin-left: -2cm">
+	<BR>
+	</DD></DL>
+<P>
+This function shall not return an error code of [EINTR]. 
+</P>
+<P><I>The following sections are informative.</I> 
+</P>
+<H2><A HREF="#toc5" NAME="sect5">Examples</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc6" NAME="sect6">Application Usage</A></H2>
+<P><B>PThreads4W</B> does not check ownership of the lock and it is
+therefore possible for a thread other than the locker to unlock the
+spin lock. This is not a feature that should be exploited.</P>
+<H2><A HREF="#toc7" NAME="sect7">Rationale</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc8" NAME="sect8">Future Directions</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc9" NAME="sect9">See Also</A></H2>
+<P><A HREF="pthread_spin_init.html"><B>pthread_spin_destroy</B>(3)</A>
+<B>,</B> <A HREF="pthread_spin_lock.html"><B>pthread_spin_lock</B>(3)</A>
+<B>,</B> the Base Definitions volume of IEEE&nbsp;Std&nbsp;1003.1-2001,
+<I>&lt;pthread.h&gt;</I> 
+</P>
+<H2><A HREF="#toc10" NAME="sect10">Copyright</A></H2>
+<P>Portions of this text are reprinted and reproduced in electronic
+form from IEEE Std 1003.1, 2003 Edition, Standard for Information
+Technology -- Portable Operating System Interface (POSIX), The Open
+Group Base Specifications Issue 6, Copyright (C) 2001-2003 by the
+Institute of Electrical and Electronics Engineers, Inc and The Open
+Group. In the event of any discrepancy between this version and the
+original IEEE and The Open Group Standard, the original IEEE and The
+Open Group Standard is the referee document. The original Standard
+can be obtained online at <A HREF="http://www.opengroup.org/unix/online.html">http://www.opengroup.org/unix/online.html</A>
+. 
+</P>
+<P>Modified by Ross Johnson for use with <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A>.</P>
+<HR>
+<P><A NAME="toc"></A><B>Table of Contents</B></P>
+<UL>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
+	Value</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Examples</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Application
+	Usage</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">Rationale</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect8" NAME="toc8">Future
+	Directions</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect9" NAME="toc9">See
+	Also</A> 
+	</P>
+	<LI><P><A HREF="#sect10" NAME="toc10">Copyright</A> 
+	</P>
+</UL>
+</BODY>
+</HTML>
diff --git a/src/include/pthread/manual/pthread_timechange_handler_np.html b/src/include/pthread/manual/pthread_timechange_handler_np.html
new file mode 100644
index 0000000..1509826
--- /dev/null
+++ b/src/include/pthread/manual/pthread_timechange_handler_np.html
@@ -0,0 +1,71 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
+	<TITLE>PTHREAD_TIMECHANGE_HANDLER_NP(3) manual page</TITLE>
+</HEAD>
+<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
+<H4>POSIX Threads for Windows – REFERENCE - <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A></H4>
+<P><A HREF="index.html">Reference Index</A></P>
+<P><A HREF="#toc">Table of Contents</A></P>
+<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P STYLE="font-weight: medium">pthread_timechange_handler_np –
+alert timed waiting condition variables to system time changes.</P>
+<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P><B>#include &lt;pthread.h&gt;</B> 
+</P>
+<P><B>void * pthread_timechange_handler_np(void * </B><I>dummy</I><B>);</B></P>
+<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P>To improve tolerance against operator or time service initiated
+system clock changes.</P>
+<P><B>pthread_timechange_handler_np </B>can be called by an
+application when it receives a WM_TIMECHANGE message from the system.
+At present it broadcasts all condition variables so that waiting
+threads can wake up and re-evaluate their conditions and restart
+their timed waits if required.</P>
+<P><B>pthread_timechange_handler_np </B>has the same return type and
+argument type as a thread routine so that it may be called directly
+through pthread_create(), i.e. as a separate thread. If run as a
+thread, the return code must be retrieved through <A HREF="pthread_join.html"><B>pthread_join</B>()</A>.</P>
+<P>Although the <I>dummy</I> parameter is required it is not used and
+any value including NULL can be given.</P>
+<H2><A HREF="#toc3" NAME="sect3">Cancellation</A></H2>
+<P>None.</P>
+<H2><A HREF="#toc4" NAME="sect4"><FONT COLOR="#000080">Return Value</FONT></A></H2>
+<P><B>pthread_timechange_handler_np</B> returns 0 on success, or an
+error code.</P>
+<H2><A HREF="#toc5" NAME="sect5">Errors</A></H2>
+<P>The <B>pthread_timechange_handler_np</B> function returns the
+following error code on error: 
+</P>
+<DL>
+	<DL>
+		<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EAGAIN</B> 
+		</DT></DL>
+</DL>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm">
+To indicate that not all condition variables were signalled for some
+reason.</P>
+<H2><A HREF="#toc6" NAME="sect6">Author</A></H2>
+<P>Ross Johnson for use with <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A>.</P>
+<HR>
+<P><A NAME="toc"></A><B>Table of Contents</B></P>
+<UL>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Cancellation</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Return
+	Value</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Errors</A>
+		</P>
+	<LI><P><A HREF="#sect6" NAME="toc6">Author</A> 
+	</P>
+</UL>
+</BODY>
+</HTML>
diff --git a/src/include/pthread/manual/pthread_win32_attach_detach_np.html b/src/include/pthread/manual/pthread_win32_attach_detach_np.html
new file mode 100644
index 0000000..b042968
--- /dev/null
+++ b/src/include/pthread/manual/pthread_win32_attach_detach_np.html
@@ -0,0 +1,69 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
+	<TITLE>PTHREAD_WIN32_ATTACH_DETACH_NP(3) manual page</TITLE>
+</HEAD>
+<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
+<H4>POSIX Threads for Windows – REFERENCE - <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A></H4>
+<P><A HREF="index.html">Reference Index</A></P>
+<P><A HREF="#toc">Table of Contents</A></P>
+<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P STYLE="font-weight: medium">pthread_win32_process_attach_np,
+pthread_win32_process_detach_np, pthread_win32_thread_attach_np,
+pthread_win32_thread_detach_np – exposed versions of the
+PThreads4W DLL dllMain() switch functionality for use when
+statically linking the library.</P>
+<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P><B>#include &lt;pthread.h&gt;</B> 
+</P>
+<P><B>BOOL pthread_win32_process_attach_np (void);</B></P>
+<P><B>BOOL pthread_win32_process_detach_np (void);</B></P>
+<P><B>BOOL pthread_win32_thread_attach_np (void);</B></P>
+<P><B>BOOL pthread_win32_thread_detach_np (void);</B></P>
+<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P>These functions contain the code normally run via <b>dllMain</b>
+when the library is used as a dll but which need to be called
+explicitly by an application when the library is statically linked. As of version 2.9.0,  the  static library built using either MSC or GCC includes RT hooks which will call the pthread_win32_process_*_np routines automatically on  start/exit of the application.</P>
+<P>You will need to call <B>pthread_win32_process_attach_np</B>
+before you can call any pthread routines when statically linking. You
+should call <B>pthread_win32_process_detach_np</B> before exiting
+your application to clean up.</P>
+<P><B>pthread_win32_thread_attach_np</B> is currently a no-op, but
+<B>pthread_win32_thread_detach_np</B> is needed to clean up the
+implicit  pthread handle that is allocated to a Win32 thread if it
+calls certain pthreads routines. Call this routine when the Win32
+thread exits.</P>
+<P>These functions invariably return TRUE except for
+<B>pthread_win32_process_attach_np</B> which will return FALSE if
+PThreads4W initialisation fails.</P>
+<H2><A HREF="#toc3" NAME="sect3">Cancellation</A></H2>
+<P>None.</P>
+<H2><A HREF="#toc4" NAME="sect4"><FONT COLOR="#000080">Return Value</FONT></A></H2>
+<P>These routines return TRUE (non-zero) on success, or FALSE (0) if
+they fail.</P>
+<H2><A HREF="#toc5" NAME="sect5">Errors</A></H2>
+<P>None.</P>
+<H2><A HREF="#toc6" NAME="sect6">Author</A></H2>
+<P>Ross Johnson for use with <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A>.</P>
+<HR>
+<P><A NAME="toc"></A><B>Table of Contents</B></P>
+<UL>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Cancellation</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Return
+	Value</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Errors</A>
+		</P>
+	<LI><P><A HREF="#sect6" NAME="toc6">Author</A> 
+	</P>
+</UL>
+</BODY>
+</HTML>
diff --git a/src/include/pthread/manual/pthread_win32_getabstime_np.html b/src/include/pthread/manual/pthread_win32_getabstime_np.html
new file mode 100644
index 0000000..7e4e060
--- /dev/null
+++ b/src/include/pthread/manual/pthread_win32_getabstime_np.html
@@ -0,0 +1,71 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=windows-1252">
+	<TITLE>PTHREAD_WIN32_ATTACH_DETACH_NP(3) manual page</TITLE>
+	<META NAME="GENERATOR" CONTENT="OpenOffice 4.1.1  (Win32)">
+	<META NAME="CREATED" CONTENT="0;0">
+	<META NAME="CHANGEDBY" CONTENT="Ross Johnson">
+	<META NAME="CHANGED" CONTENT="20160330;18071352">
+	<STYLE TYPE="text/css">
+	<!--
+		H4.cjk { font-family: "SimSun" }
+		H4.ctl { font-family: "Mangal" }
+		H2.cjk { font-family: "SimSun" }
+		H2.ctl { font-family: "Mangal" }
+	-->
+	</STYLE>
+</HEAD>
+<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
+<H4 CLASS="western">POSIX Threads for Windows &ndash; REFERENCE -
+<A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A></H4>
+<P><A HREF="index.html">Reference Index</A></P>
+<P><A HREF="#toc">Table of Contents</A></P>
+<H2 CLASS="western"><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P STYLE="font-weight: normal">pthread_win32_getabstime_np</P>
+<H2 CLASS="western"><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P><B>#include &lt;pthread.h&gt;</B> 
+</P>
+<P><B>struct timespec * pthread_win32_getabstime_np (struct timespec
+* abstime, struct timespec * reltime);</B></P>
+<H2 CLASS="western"><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P>Primarily to facilitate writing unit tests but exported for
+convenience. The <FONT COLOR="#000000"><I><U>struct</U></I></FONT><I>
+</I><FONT COLOR="#000000"><I><U>timespec</U></I></FONT> pointed to by
+the first parameter is modified to represent the current time plus an
+optional offset value <I>struct </I><FONT COLOR="#000000"><I><U>timespec</U></I></FONT>
+in a platform optimal way.</P>
+<P>Returns the first parameter so is compatible as the<I> </I><FONT COLOR="#000000"><I><U>struct</U></I></FONT><I>
+</I><FONT COLOR="#000000"><I><U>timespec</U></I></FONT><I> *</I>
+parameter in POSIX timed function calls.</P>
+<H2 CLASS="western"><A HREF="#toc3" NAME="sect3">Cancellation</A></H2>
+<P>None.</P>
+<H2 CLASS="western"><A HREF="#toc4" NAME="sect4"><FONT COLOR="#000080">Return
+Value</FONT></A></H2>
+<P>This routine returns the first parameter (non-zero) on success, or
+NULL (0) if it fails.</P>
+<H2 CLASS="western"><A HREF="#toc5" NAME="sect5">Errors</A></H2>
+<P>None.</P>
+<H2 CLASS="western"><A HREF="#toc6" NAME="sect6">Author</A></H2>
+<P>Ross Johnson for use with <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A>.</P>
+<HR>
+<P><A NAME="toc"></A><B>Table of Contents</B></P>
+<UL>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Cancellation</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Return
+	Value</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Errors</A>
+		</P>
+	<LI><P><A HREF="#sect6" NAME="toc6">Author</A> 
+	</P>
+</UL>
+</BODY>
+</HTML>
\ No newline at end of file
diff --git a/src/include/pthread/manual/pthread_win32_test_features_np.html b/src/include/pthread/manual/pthread_win32_test_features_np.html
new file mode 100644
index 0000000..927942c
--- /dev/null
+++ b/src/include/pthread/manual/pthread_win32_test_features_np.html
@@ -0,0 +1,63 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
+	<TITLE>PTHREAD_WIN32_TEST_FEATURES_NP(3) manual page</TITLE>
+</HEAD>
+<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
+<H4>POSIX Threads for Windows – REFERENCE - <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A></H4>
+<P><A HREF="index.html">Reference Index</A></P>
+<P><A HREF="#toc">Table of Contents</A></P>
+<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P STYLE="font-weight: medium">pthread_win32_test_features_np –
+find out what features were detected at process attach time.</P>
+<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P><B>#include &lt;pthread.h&gt;</B> 
+</P>
+<P><B>BOOL pthread_win32_test_features_np(int</B> <I>mask</I><B>);</B></P>
+<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P><B>pthread_win32_test_features_np</B> allows an application to
+check which run-time auto-detected features are available within the
+library.</P>
+<P>The possible features are:</P>
+<P><B>PTW32_SYSTEM_INTERLOCKED_COMPARE_EXCHANGE</B></P>
+<P STYLE="margin-left: 2cm">Return TRUE if the Win32 version of
+InterlockedCompareExchange() is being used. On IA32 systems the
+library can use optimised and inlinable assembler versions of
+InterlockedExchange() and InterlockedCompareExchange().</P>
+<P><B>PTW32_ALERTABLE_ASYNC_CANCEL</B></P>
+<P STYLE="margin-left: 2cm">Return TRUE if the QueueUserAPCEx package
+QUSEREX.DLL and the AlertDrv.sys driver was detected. This package
+provides alertable (pre-emptive) asynchronous threads cancellation.
+If this feature returns FALSE then the default async cancel scheme is
+in use, which cannot cancel blocked threads.</P>
+<H2><A HREF="#toc3" NAME="sect3">Cancellation</A></H2>
+<P>None.</P>
+<H2><A HREF="#toc4" NAME="sect4"><FONT COLOR="#000080">Return Value</FONT></A></H2>
+<P><B>pthread_win32_test_features_np</B> returns TRUE (non-zero) if
+the specified feature is present, and FALSE (0) otherwise.</P>
+<H2><A HREF="#toc5" NAME="sect5">Errors</A></H2>
+<P>None.</P>
+<H2><A HREF="#toc6" NAME="sect6">Author</A></H2>
+<P>Ross Johnson for use with <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A>.</P>
+<HR>
+<P><A NAME="toc"></A><B>Table of Contents</B></P>
+<UL>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Cancellation</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Return
+	Value</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Errors</A>
+		</P>
+	<LI><P><A HREF="#sect6" NAME="toc6">Author</A> 
+	</P>
+</UL>
+</BODY>
+</HTML>
\ No newline at end of file
diff --git a/src/include/pthread/manual/sched_get_priority_max.html b/src/include/pthread/manual/sched_get_priority_max.html
new file mode 100644
index 0000000..72311d9
--- /dev/null
+++ b/src/include/pthread/manual/sched_get_priority_max.html
@@ -0,0 +1,110 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
+	<TITLE>SCHED_GET_PRIORITY_MAX(3) manual page</TITLE>
+</HEAD>
+<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
+<H4>POSIX Threads for Windows – REFERENCE - <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A></H4>
+<P><A HREF="index.html">Reference Index</A></P>
+<P><A HREF="#toc">Table of Contents</A></P>
+<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P>sched_get_priority_max, sched_get_priority_min - get priority
+limits (<B>REALTIME</B>) 
+</P>
+<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P><B>#include &lt;sched.h&gt; </B>
+</P>
+<P><B>int sched_get_priority_max(int</B> <I>policy</I><B>); <BR>int
+sched_get_priority_min(int</B> <I>policy</I><B>); </B>
+</P>
+<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P>The <B>sched_get_priority_max</B> and <B>sched_get_priority_min</B>
+functions shall return the appropriate maximum or minimum,
+respectively, for the scheduling policy specified by <I>policy</I>. 
+</P>
+<P>The value of <I>policy</I> shall be one of the scheduling policy
+values defined in <I>&lt;sched.h&gt;</I>. 
+</P>
+<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
+<P>If successful, the <B>sched_get_priority_max</B> and
+<B>sched_get_priority_min</B> functions shall return the appropriate
+maximum or minimum values, respectively. If unsuccessful, they shall
+return a value of -1 and set <I>errno</I> to indicate the error. 
+</P>
+<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
+<P>The <B>sched_get_priority_max</B> and <B>sched_get_priority_min</B>
+functions shall fail if: 
+</P>
+<DL>
+	<DT><B>EINVAL</B> 
+	</DT><DD STYLE="margin-bottom: 0.5cm">
+	The value of the <I>policy</I> parameter does not represent a
+	defined scheduling policy. 
+	</DD></DL>
+<P>
+<I>The following sections are informative.</I> 
+</P>
+<H2><A HREF="#toc5" NAME="sect5">Examples</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc6" NAME="sect6">Application Usage</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc7" NAME="sect7">Rationale</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc8" NAME="sect8">Future Directions</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc9" NAME="sect9">See Also</A></H2>
+<P><A HREF="sched_getscheduler.html"><B>sched_getscheduler</B>(3)</A>
+<B>,</B> <A HREF="sched_setscheduler.html"><B>sched_setscheduler</B>(3)</A>
+<B>,</B> the Base Definitions volume of IEEE&nbsp;Std&nbsp;1003.1-2001,
+<I>&lt;sched.h&gt;</I> 
+</P>
+<H2><A HREF="#toc10" NAME="sect10">Copyright</A></H2>
+<P>Portions of this text are reprinted and reproduced in electronic
+form from IEEE Std 1003.1, 2003 Edition, Standard for Information
+Technology -- Portable Operating System Interface (POSIX), The Open
+Group Base Specifications Issue 6, Copyright (C) 2001-2003 by the
+Institute of Electrical and Electronics Engineers, Inc and The Open
+Group. In the event of any discrepancy between this version and the
+original IEEE and The Open Group Standard, the original IEEE and The
+Open Group Standard is the referee document. The original Standard
+can be obtained online at <A HREF="http://www.opengroup.org/unix/online.html">http://www.opengroup.org/unix/online.html</A>
+. 
+</P>
+<P>Modified by Ross Johnson for use with <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A>.</P>
+<HR>
+<P><A NAME="toc"></A><B>Table of Contents</B></P>
+<UL>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
+	Value</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Examples</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Application
+	Usage</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">Rationale</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect8" NAME="toc8">Future
+	Directions</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect9" NAME="toc9">See
+	Also</A> 
+	</P>
+	<LI><P><A HREF="#sect10" NAME="toc10">Copyright</A> 
+	</P>
+</UL>
+</BODY>
+</HTML>
\ No newline at end of file
diff --git a/src/include/pthread/manual/sched_getscheduler.html b/src/include/pthread/manual/sched_getscheduler.html
new file mode 100644
index 0000000..9acd5e7
--- /dev/null
+++ b/src/include/pthread/manual/sched_getscheduler.html
@@ -0,0 +1,122 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
+	<TITLE>SCHED_GETSCHEDULER(3) manual page</TITLE>
+</HEAD>
+<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
+<H4>POSIX Threads for Windows – REFERENCE - <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A></H4>
+<P><A HREF="index.html">Reference Index</A></P>
+<P><A HREF="#toc">Table of Contents</A></P>
+<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P>sched_getscheduler - get scheduling policy (<B>REALTIME</B>) 
+</P>
+<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P><B>#include &lt;sched.h&gt; </B>
+</P>
+<P><B>int sched_getscheduler(pid_t</B> <I>pid</I><B>); </B>
+</P>
+<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P>The <B>sched_getscheduler</B> function shall return the scheduling
+policy of the process specified by <I>pid</I>. If the value of <I>pid</I>
+is negative, the behavior of the <B>sched_getscheduler</B> function
+is unspecified. 
+</P>
+<P>The values that can be returned by <B>sched_getscheduler</B> are
+defined in the <I>&lt;sched.h&gt;</I> header. 
+</P>
+<P><B>PThreads4W</B> only supports the <B>SCHED_OTHER</B> policy,
+which is the only value that can be returned. However, checks on <I>pid</I>
+and permissions are performed first so that the other useful side
+effects of this routine are retained.</P>
+<P>If a process specified by <I>pid</I> exists, and if the calling
+process has permission, the scheduling policy shall be returned for
+the process whose process ID is equal to <I>pid</I>. 
+</P>
+<P>If <I>pid</I> is zero, the scheduling policy shall be returned for
+the calling process. 
+</P>
+<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
+<P>Upon successful completion, the <B>sched_getscheduler</B> function
+shall return the scheduling policy of the specified process. If
+unsuccessful, the function shall return -1 and set <I>errno</I> to
+indicate the error. 
+</P>
+<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
+<P>The <B>sched_getscheduler</B> function shall fail if: 
+</P>
+<DL>
+	<DT><B>EPERM</B> 
+	</DT><DD>
+	The requesting process does not have permission to determine the
+	scheduling policy of the specified process. 
+	</DD><DT>
+	<B>ESRCH</B> 
+	</DT><DD STYLE="margin-bottom: 0.5cm">
+	No process can be found corresponding to that specified by <I>pid</I>.
+		</DD></DL>
+<P>
+<I>The following sections are informative.</I> 
+</P>
+<H2><A HREF="#toc5" NAME="sect5">Examples</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc6" NAME="sect6">Application Usage</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc7" NAME="sect7">Rationale</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc8" NAME="sect8">Future Directions</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc9" NAME="sect9">See Also</A></H2>
+<P><A HREF="sched_setscheduler.html"><B>sched_setscheduler</B>(3)</A>
+, the Base Definitions volume of IEEE&nbsp;Std&nbsp;1003.1-2001,
+<I>&lt;sched.h&gt;</I> 
+</P>
+<H2><A HREF="#toc10" NAME="sect10">Copyright</A></H2>
+<P>Portions of this text are reprinted and reproduced in electronic
+form from IEEE Std 1003.1, 2003 Edition, Standard for Information
+Technology -- Portable Operating System Interface (POSIX), The Open
+Group Base Specifications Issue 6, Copyright (C) 2001-2003 by the
+Institute of Electrical and Electronics Engineers, Inc and The Open
+Group. In the event of any discrepancy between this version and the
+original IEEE and The Open Group Standard, the original IEEE and The
+Open Group Standard is the referee document. The original Standard
+can be obtained online at <A HREF="http://www.opengroup.org/unix/online.html">http://www.opengroup.org/unix/online.html</A>
+. 
+</P>
+<P>Modified by Ross Johnson for use with <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A>.</P>
+<HR>
+<P><A NAME="toc"></A><B>Table of Contents</B></P>
+<UL>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
+	Value</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Examples</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Application
+	Usage</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">Rationale</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect8" NAME="toc8">Future
+	Directions</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect9" NAME="toc9">See
+	Also</A> 
+	</P>
+	<LI><P><A HREF="#sect10" NAME="toc10">Copyright</A> 
+	</P>
+</UL>
+</BODY>
+</HTML>
diff --git a/src/include/pthread/manual/sched_setaffinity.html b/src/include/pthread/manual/sched_setaffinity.html
new file mode 100644
index 0000000..279e4b0
--- /dev/null
+++ b/src/include/pthread/manual/sched_setaffinity.html
@@ -0,0 +1,139 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<TITLE>SCHED_SETAFFINITY(3) manual page</TITLE>
+	<STYLE TYPE="text/css">
+	<!--
+		H4.cjk { font-family: "SimSun" }
+		H4.ctl { font-family: "Mangal" }
+		H2.cjk { font-family: "SimSun" }
+		H2.ctl { font-family: "Mangal" }
+	-->
+	</STYLE>
+</HEAD>
+<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
+<H4 CLASS="western"><FONT FACE="Times New Roman, serif"><FONT SIZE=3><SPAN STYLE="font-style: normal">POSIX
+Threads for Windows &ndash; REFERENCE - <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A></SPAN></FONT></FONT></H4>
+<P><A HREF="index.html">Reference Index</A></P>
+<P><A HREF="#toc">Table of Contents</A></P>
+<H2 CLASS="western"><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P>sched_setaffinity - set process CPU affinity</P>
+<P>sched_getaffinity - get process CPU affinity</P>
+<H2 CLASS="western"><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P><B>#include &lt;sched.h&gt; </B>
+</P>
+<P><B>int sched_setaffinity(pid_t </B><I><SPAN STYLE="font-weight: normal">pid</SPAN></I><B>,
+int </B><I><SPAN STYLE="font-weight: normal">cpusetsize</SPAN></I><B>,
+const cpu_set_t *</B><I><SPAN STYLE="font-weight: normal">mask</SPAN></I><B>);</B></P>
+<P><B>int sched_getaffinity(pid_t </B><I><SPAN STYLE="font-weight: normal">pid</SPAN></I><B>,
+int </B><I><SPAN STYLE="font-weight: normal">cpusetsize</SPAN></I><B>,
+cpu_set_t *</B><I><SPAN STYLE="font-weight: normal">mask</SPAN></I><B>);</B></P>
+<H2 CLASS="western"><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P><B>sched_setaffinity</B> sets the CPU affinity mask of the process
+whose ID is <I>pid</I> to the value specified by mask. If <I>pid</I>
+is zero, then the calling process is used. The argument <I>cpusetsize</I>
+is the length (in bytes) of the data pointed to by <I>mask</I>.
+Normally this argument would be specified as <I>sizeof(cpu_set_t)</I>.</P>
+<P>If the process specified by <I>pid</I> is not currently running on
+one of the CPUs specified in <I>mask</I>, then that process is
+migrated to one of the CPUs specified in <I>mask</I>.</P>
+<P>After a call to <B>sched_setaffinity</B>, the set of CPUs on which
+the process will actually run is the intersection of the set
+specified in the <I>mask</I> argument and the set of CPUs actually
+present on the system.</P>
+<P><B>sched_getaffinity</B> writes the affinity mask of the process
+whose ID is <I>pid</I> into the cpu_set_t structure pointed to by
+<I>mask</I>. The <I>cpusetsize</I> argument specifies the size (in
+bytes) of <I>mask</I>. If <I>pid</I> is zero, then the mask of the
+calling process is returned.</P>
+<P><B>PThreads4W</B> currently ignores the <I>cpusetsize</I>
+parameter for either function because cpu_set_t is a direct typeset
+to the Windows affinity vector type DWORD_PTR.</P>
+<P>Windows may require that the requesting process have permission to
+set its own CPU affinity or that of another process.</P>
+<H2 CLASS="western"><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
+<P>On success, <B>sched_setaffinity</B> and <B>sched_getaffinity</B>
+return 0. On error, -1 is returned, and <I>errno</I> is set
+appropriately.</P>
+<H2 CLASS="western"><A HREF="#toc4" NAME="sect4">Errors</A></H2>
+<DL>
+	<DT><B>EFAULT</B></DT><DL>
+		<DL>
+			<DT STYLE="margin-left: 0.02cm">
+			A supplied memory address was invalid.</DT></DL>
+	</DL>
+	<DT>
+	<B>EINVAL</B></DT><DL>
+		<DL>
+			<DT STYLE="margin-left: 0.04cm">
+			The affinity bit mask mask contains no processors that are
+			currently physically on the system.</DT></DL>
+	</DL>
+	<DT>
+	<B>EAGAIN</B></DT><DL>
+		<DL>
+			<DT STYLE="margin-left: 0.02cm">
+			The function did not succeed in changing or obtaining the CPU
+			affinity for some undetermined reason. Try again.</DT></DL>
+	</DL>
+	<DT>
+	<B>EPERM</B></DT><DL>
+		<DL>
+			<DT STYLE="margin-left: 0.02cm">
+			The calling process does not have appropriate privileges.</DT></DL>
+	</DL>
+	<DT>
+	<B>ESRCH</B> 
+	</DT><DL>
+		<DL>
+			<DT STYLE="margin-left: 0.02cm">
+			The process whose ID is pid could not be found.</DT></DL>
+	</DL>
+</DL>
+<H2 CLASS="western">
+<A HREF="#toc5" NAME="sect5">Application Usage</A></H2>
+<P>A process's CPU affinity mask determines the set of CPUs on which
+it is eligible to run. On a multiprocessor system, setting the CPU
+affinity mask can be used to obtain performance benefits. For
+example, by dedicating one CPU to a particular process (i.e., setting
+the affinity mask of that process to specify a single CPU, and
+setting the affinity mask of all other processes to exclude that
+CPU), it is possible to ensure maximum execution speed for that
+process. Restricting a process to run on a single CPU also avoids the
+performance cost caused by the cache invalidation that occurs when a
+process ceases to execute on one CPU and then recommences execution
+on a different CPU.</P>
+<P>A CPU affinity mask is represented by the cpu_set_t structure, a
+&quot;CPU set&quot;, pointed to by <I>mask</I>. A set of macros for
+manipulating CPU sets is described in <B>cpu_set</B>(3).</P>
+<H2 CLASS="western"><A HREF="#toc6" NAME="sect6">See Also</A></H2>
+<P><A HREF="cpu_set.html"><B>cpu_set</B>(3)</A>,
+<A HREF="pthread_setaffinity_np.html"><B>pthread_setaffininty_np</B>(3)</A>,
+<A HREF="pthread_setaffinity_np.html"><B>pthread_getaffinity_np</B>(3)</A></P>
+<H2 CLASS="western"><A HREF="#toc7" NAME="sect7">Copyright</A></H2>
+<P>Most of this is taken from the Linux manual page.</P>
+<P>Modified by Ross Johnson for use with <B>PThreads4W</B>.</P>
+<HR>
+<P><A NAME="toc"></A><B>Table of Contents</B></P>
+<UL>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
+	Value</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Application
+	Usage</A></P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">See
+	Also</A></P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">Copyright</A></P>
+</UL>
+<H4 CLASS="western"><BR><BR>
+</H4>
+</BODY>
+</HTML>
\ No newline at end of file
diff --git a/src/include/pthread/manual/sched_setscheduler.html b/src/include/pthread/manual/sched_setscheduler.html
new file mode 100644
index 0000000..988287f
--- /dev/null
+++ b/src/include/pthread/manual/sched_setscheduler.html
@@ -0,0 +1,176 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
+	<TITLE>SCHED_SETSCHEDULER(3) manual page</TITLE>
+</HEAD>
+<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
+<H4>POSIX Threads for Windows – REFERENCE - <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A></H4>
+<P><A HREF="index.html">Reference Index</A></P>
+<P><A HREF="#toc">Table of Contents</A></P>
+<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P>sched_setscheduler - set scheduling policy and parameters
+(<B>REALTIME</B>) 
+</P>
+<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P><B>#include &lt;sched.h&gt; </B>
+</P>
+<P><B>int sched_setscheduler(pid_t</B> <I>pid</I><B>, int</B> <I>policy</I><B>,
+const struct sched_param *</B><I>param</I><B>); </B>
+</P>
+<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P>The <B>sched_setscheduler</B> function shall set the scheduling
+policy and scheduling parameters of the process specified by <I>pid</I>
+to <I>policy</I> and the parameters specified in the <B>sched_param</B>
+structure pointed to by <I>param</I>, respectively. The value of the
+<I>sched_priority</I> member in the <B>sched_param</B> structure
+shall be any integer within the inclusive priority range for the
+scheduling policy specified by <I>policy</I>. If the value of <I>pid</I>
+is negative, the behavior of the <B>sched_setscheduler</B> function
+is unspecified. 
+</P>
+<P>The possible values for the <I>policy</I> parameter are defined in
+the <I>&lt;sched.h&gt;</I> header. 
+</P>
+<P><B>PThreads4W</B> only supports the <B>SCHED_OTHER</B> policy.
+Any other value for <I>policy</I> will return failure with errno set
+to <B>ENOSYS</B>. However, checks on <I>pid</I> and permissions are
+performed first so that the other useful side effects of this routine
+are retained.</P>
+<P>If a process specified by <I>pid</I> exists, and if the calling
+process has permission, the scheduling policy and scheduling
+parameters shall be set for the process whose process ID is equal to
+<I>pid</I>. 
+</P>
+<P>If <I>pid</I> is zero, the scheduling policy and scheduling
+parameters shall be set for the calling process. 
+</P>
+<P>Implementations may require that the requesting process have
+permission to set its own scheduling parameters or those of another
+process. Additionally, implementation-defined restrictions may apply
+as to the appropriate privileges required to set a process’ own
+scheduling policy, or another process’ scheduling policy, to a
+particular value. 
+</P>
+<P>The <B>sched_setscheduler</B> function shall be considered
+successful if it succeeds in setting the scheduling policy and
+scheduling parameters of the process specified by <I>pid</I> to the
+values specified by <I>policy</I> and the structure pointed to by
+<I>param</I>, respectively. 
+</P>
+<P>The effect of this function on individual threads is dependent on
+the scheduling contention scope of the threads: 
+</P>
+<DL>
+	<DT>* 
+	</DT><DD STYLE="margin-bottom: 0.5cm">
+	For threads with system scheduling contention scope, these functions
+	shall have no effect on their scheduling. 
+	</DD><DT>
+	* 
+	</DT><DD STYLE="margin-bottom: 0.5cm">
+	For threads with process scheduling contention scope, the threads’
+	scheduling policy and associated parameters shall not be affected.
+	However, the scheduling of these threads with respect to threads in
+	other processes may be dependent on the scheduling parameters of
+	their process, which are governed using these functions. 
+	</DD></DL>
+<P>
+This function is not atomic with respect to other threads in the
+process. Threads may continue to execute while this function call is
+in the process of changing the scheduling policy and associated
+scheduling parameters for the underlying kernel-scheduled entities
+used by the process contention scope threads. 
+</P>
+<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
+<P>Upon successful completion, the function shall return the former
+scheduling policy of the specified process. If the <B>sched_setscheduler</B>
+function fails to complete successfully, the policy and scheduling
+parameters shall remain unchanged, and the function shall return a
+value of -1 and set <I>errno</I> to indicate the error. 
+</P>
+<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
+<P>The <B>sched_setscheduler</B> function shall fail if: 
+</P>
+<DL>
+	<DT><B>EINVAL</B> 
+	</DT><DD>
+	The value of the <I>policy</I> parameter is invalid, or one or more
+	of the parameters contained in <I>param</I> is outside the valid
+	range for the specified scheduling policy. 
+	</DD><DT>
+	<B>EPERM</B> 
+	</DT><DD>
+	The requesting process does not have permission to set either or
+	both of the scheduling parameters or the scheduling policy of the
+	specified process. 
+	</DD><DT>
+	<B>ESRCH</B> 
+	</DT><DD STYLE="margin-bottom: 0.5cm">
+	No process can be found corresponding to that specified by <I>pid</I>.
+		</DD></DL>
+<P>
+<I>The following sections are informative.</I> 
+</P>
+<H2><A HREF="#toc5" NAME="sect5">Examples</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc6" NAME="sect6">Application Usage</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc7" NAME="sect7">Rationale</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc8" NAME="sect8">Future Directions</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc9" NAME="sect9">See Also</A></H2>
+<P><A HREF="sched_getscheduler.html"><B>sched_getscheduler</B>(3)</A>
+<B>,</B> the Base Definitions volume of IEEE&nbsp;Std&nbsp;1003.1-2001,
+<I>&lt;sched.h&gt;</I> 
+</P>
+<H2><A HREF="#toc10" NAME="sect10">Copyright</A></H2>
+<P>Portions of this text are reprinted and reproduced in electronic
+form from IEEE Std 1003.1, 2003 Edition, Standard for Information
+Technology -- Portable Operating System Interface (POSIX), The Open
+Group Base Specifications Issue 6, Copyright (C) 2001-2003 by the
+Institute of Electrical and Electronics Engineers, Inc and The Open
+Group. In the event of any discrepancy between this version and the
+original IEEE and The Open Group Standard, the original IEEE and The
+Open Group Standard is the referee document. The original Standard
+can be obtained online at <A HREF="http://www.opengroup.org/unix/online.html">http://www.opengroup.org/unix/online.html</A>
+. 
+</P>
+<P>Modified by Ross Johnson for use with <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A>.</P>
+<HR>
+<P><A NAME="toc"></A><B>Table of Contents</B></P>
+<UL>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
+	Value</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Examples</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Application
+	Usage</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">Rationale</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect8" NAME="toc8">Future
+	Directions</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect9" NAME="toc9">See
+	Also</A> 
+	</P>
+	<LI><P><A HREF="#sect10" NAME="toc10">Copyright</A> 
+	</P>
+</UL>
+</BODY>
+</HTML>
diff --git a/src/include/pthread/manual/sched_yield.html b/src/include/pthread/manual/sched_yield.html
new file mode 100644
index 0000000..1eed915
--- /dev/null
+++ b/src/include/pthread/manual/sched_yield.html
@@ -0,0 +1,93 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
+	<TITLE>SCHED_YIELD(3) manual page</TITLE>
+</HEAD>
+<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
+<H4>POSIX Threads for Windows – REFERENCE - <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A></H4>
+<P><A HREF="index.html">Reference Index</A></P>
+<P><A HREF="#toc">Table of Contents</A></P>
+<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P>sched_yield - yield the processor 
+</P>
+<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P><B>#include &lt;sched.h&gt; </B>
+</P>
+<P><B>int sched_yield(void);</B> 
+</P>
+<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P>The <B>sched_yield</B> function shall force the running thread to
+relinquish the processor until it again becomes the head of its
+thread list. It takes no arguments. 
+</P>
+<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
+<P>The <B>sched_yield</B> function shall return 0 if it completes
+successfully; otherwise, it shall return a value of -1 and set <I>errno</I>
+to indicate the error. 
+</P>
+<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
+<P>No errors are defined. 
+</P>
+<P><I>The following sections are informative.</I> 
+</P>
+<H2><A HREF="#toc5" NAME="sect5">Examples</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc6" NAME="sect6">Application Usage</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc7" NAME="sect7">Rationale</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc8" NAME="sect8">Future Directions</A></H2>
+<P>None. 
+</P>
+<H2><A HREF="#toc9" NAME="sect9">See Also</A></H2>
+<P>The Base Definitions volume of IEEE&nbsp;Std&nbsp;1003.1-2001,
+<I>&lt;sched.h&gt;</I> 
+</P>
+<H2><A HREF="#toc10" NAME="sect10">Copyright</A></H2>
+<P>Portions of this text are reprinted and reproduced in electronic
+form from IEEE Std 1003.1, 2003 Edition, Standard for Information
+Technology -- Portable Operating System Interface (POSIX), The Open
+Group Base Specifications Issue 6, Copyright (C) 2001-2003 by the
+Institute of Electrical and Electronics Engineers, Inc and The Open
+Group. In the event of any discrepancy between this version and the
+original IEEE and The Open Group Standard, the original IEEE and The
+Open Group Standard is the referee document. The original Standard
+can be obtained online at <A HREF="http://www.opengroup.org/unix/online.html">http://www.opengroup.org/unix/online.html</A>
+. 
+</P>
+<HR>
+<P><A NAME="toc"></A><B>Table of Contents</B></P>
+<UL>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
+	Value</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Examples</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Application
+	Usage</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">Rationale</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect8" NAME="toc8">Future
+	Directions</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect9" NAME="toc9">See
+	Also</A> 
+	</P>
+	<LI><P><A HREF="#sect10" NAME="toc10">Copyright</A> 
+	</P>
+</UL>
+</BODY>
+</HTML>
diff --git a/src/include/pthread/manual/sem_init.html b/src/include/pthread/manual/sem_init.html
new file mode 100644
index 0000000..a856b45
--- /dev/null
+++ b/src/include/pthread/manual/sem_init.html
@@ -0,0 +1,195 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
+	<TITLE>SEM_INIT(3) manual page</TITLE>
+</HEAD>
+<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
+<H4>POSIX Threads for Windows – REFERENCE - <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A></H4>
+<P><A HREF="index.html">Reference Index</A></P>
+<P><A HREF="#toc">Table of Contents</A></P>
+<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
+<P>sem_init, sem_wait, sem_trywait, sem_post, sem_getvalue,
+sem_destroy - operations on semaphores 
+</P>
+<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
+<P><B>#include &lt;semaphore.h&gt;</B> 
+</P>
+<P><B>int sem_init(sem_t *</B><I>sem</I><B>, int </B><I>pshared</I><B>,
+unsigned int </B><I>value</I><B>);</B> 
+</P>
+<P><B>int sem_wait(sem_t * </B><I>sem</I><B>);</B> 
+</P>
+<P><B>int sem_timedwait(sem_t * </B><I>sem</I>, <B>const struct
+timespec *</B><I>abstime</I><B>);</B> 
+</P>
+<P><B>int sem_trywait(sem_t * </B><I>sem</I><B>);</B> 
+</P>
+<P><B>int sem_post(sem_t * </B><I>sem</I><B>);</B> 
+</P>
+<P><B>int sem_post_multiple(sem_t * </B><I>sem, </I><B>int</B>
+<I>number</I><B>);</B> 
+</P>
+<P><B>int sem_getvalue(sem_t * </B><I>sem</I><B>, int * </B><I>sval</I><B>);</B>
+</P>
+<P><B>int sem_destroy(sem_t * </B><I>sem</I><B>);</B> 
+</P>
+<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
+<P>Semaphores are counters for resources shared between threads. The
+basic operations on semaphores are: increment the counter atomically,
+and wait until the counter is non-null and decrement it atomically. 
+</P>
+<P><B>sem_init</B> initializes the semaphore object pointed to by
+<I>sem</I>. The count associated with the semaphore is set initially
+to <I>value</I>. The <I>pshared</I> argument indicates whether the
+semaphore is local to the current process ( <I>pshared</I> is zero)
+or is to be shared between several processes ( <I>pshared</I> is not
+zero).</P>
+<P><B>PThreads4W</B> currently does not support process-shared
+semaphores, thus <B>sem_init</B> always returns with error <B>EPERM</B>
+if <I>pshared</I> is not zero. 
+</P>
+<P><B>sem_wait</B> atomically decrements <I>sem</I>'s count if it is
+greater than 0 and returns immediately or it suspends the calling
+thread until it can resume following a call to <B>sem_post</B> or
+<B>sem_post_multiple</B>.</P>
+<P><B>sem_timedwait</B> atomically decrements <I>sem</I>'s count if
+it is greater than 0 and returns immediately, or it suspends the
+calling thread. If <I>abstime</I> time arrives before the thread can
+resume following a call to <B>sem_post</B> or <B>sem_post_multiple</B>,
+then <B>sem_timedwait</B> returns with a return code of -1 after
+having set <B>errno</B> to <B>ETIMEDOUT</B>. If the call can return
+without suspending then <I>abstime</I> is not checked.</P>
+<P><B>sem_trywait</B> atomically decrements <I>sem</I>'s count if it
+is greater than 0 and returns immediately, or it returns immediately
+with a return code of -1 after having set <B>errno</B> to <B>EAGAIN</B>.
+<B>sem_trywait</B> never blocks.</P>
+<P><B>sem_post</B> either releases one thread if there are any
+waiting on <I>sem</I>, or it atomically increments <I>sem</I>'s
+count.</P>
+<P><B>sem_post_multiple</B> either releases multiple threads if there
+are any waiting on <I>sem</I> and/or it atomically increases <I>sem</I>'s
+count. If there are currently <I>n</I> waiters, where <I>n</I> the
+largest number less than or equal to <I>number</I>, then <I>n</I>
+waiters are released and <I>sem</I>'s count is incremented by <I>number</I>
+minus <I>n</I>.</P>
+<P><B>sem_getvalue</B> stores in the location pointed to by <I>sval</I>
+the current count of the semaphore <I>sem</I>. In the <B>PThreads4W</B>
+implementation: if the value returned in <I>sval</I> is greater than
+or equal to 0 it was the <I>sem</I>'s count at some point during the
+call to <B>sem_getvalue</B>. If the value returned in <I>sval</I> is
+less than 0 then it's absolute value represents the number of threads
+waiting on <I>sem</I> at some point during the call to <B>sem_getvalue.
+</B>POSIX does not require an implementation of <B>sem_getvalue</B>
+to return a value in <I>sval</I> that is less than 0, but if it does
+then it's absolute value must represent the number of waiters.</P>
+<P><B>sem_destroy</B> destroys a semaphore object, freeing the
+resources it might hold. No threads should be waiting on the
+semaphore at the time <B>sem_destroy</B> is called.</P>
+<H2><A HREF="#toc3" NAME="sect3">Cancellation</A></H2>
+<P><B>sem_wait</B> and <B>sem_timedwait</B> are cancellation points. 
+</P>
+<H2><A HREF="#toc4" NAME="sect4">Async-signal Safety</A></H2>
+<P>These routines are not async-cancel safe.</P>
+<H2><A HREF="#toc5" NAME="sect5">Return Value</A></H2>
+<P>All semaphore functions return 0 on success, or -1 on error in
+which case they write an error code in <B>errno</B>. 
+</P>
+<H2><A HREF="#toc6" NAME="sect6">Errors</A></H2>
+<P>The <B>sem_init</B> function sets <B>errno</B> to the following
+codes on error: 
+</P>
+<DL>
+	<DL>
+		<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EINVAL</B> 
+		</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
+		<I>value</I> exceeds the maximal counter value <B>SEM_VALUE_MAX</B>
+				</DD><DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
+		<B>ENOSYS</B> 
+		</DT></DL>
+</DL>
+<BLOCKQUOTE STYLE="margin-left: 3cm">
+<I>pshared</I> is not zero 
+</BLOCKQUOTE>
+<P>The <B>sem_timedwait</B> function sets <B>errno</B> to the
+following error code on error: 
+</P>
+<DL>
+	<DL>
+		<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>ETIMEDOUT</B>
+				</DT></DL>
+</DL>
+<BLOCKQUOTE STYLE="margin-left: 3cm">
+if <I>abstime</I> arrives before the waiting thread can resume
+following a call to <B>sem_post</B> or <B>sem_post_multiple</B>. 
+</BLOCKQUOTE>
+<P>The <B>sem_trywait</B> function sets <B>errno</B> to the following
+error code on error: 
+</P>
+<DL>
+	<DL>
+		<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EAGAIN</B> 
+		</DT></DL>
+</DL>
+<BLOCKQUOTE STYLE="margin-left: 3cm">
+if the semaphore count is currently 0 
+</BLOCKQUOTE>
+<P>The <B>sem_post</B> and <B>sem_post_multiple</B> functions set
+<B>errno</B> to the following error code on error: 
+</P>
+<DL>
+	<DL>
+		<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>ERANGE</B> 
+		</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
+		if after incrementing, the semaphore count would exceed
+		<B>SEM_VALUE_MAX</B> (the semaphore count is left unchanged in this
+		case) 
+		</DD></DL>
+</DL>
+<P>
+The <B>sem_destroy</B> function sets <B>errno</B> to the following
+error code on error: 
+</P>
+<DL>
+	<DL>
+		<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EBUSY</B> 
+		</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
+		if some threads are currently blocked waiting on the semaphore. 
+		</DD></DL>
+</DL>
+<H2>
+<A HREF="#toc7" NAME="sect7">Author</A></H2>
+<P>Xavier Leroy &lt;Xavier.Leroy@inria.fr&gt; 
+</P>
+<P>Modified by Ross Johnson for use with <A HREF="https://sourceforge.net/projects/pthreads4w/">Pthreads4W</A>.</P>
+<H2><A HREF="#toc8" NAME="sect8">See Also</A></H2>
+<P><A HREF="pthread_mutex_init.html"><B>pthread_mutex_init</B>(3)</A>
+, <A HREF="pthread_cond_init.html"><B>pthread_cond_init</B>(3)</A> ,
+<A HREF="pthread_cancel.html"><B>pthread_cancel</B>(3)</A> . 
+</P>
+<HR>
+<P><A NAME="toc"></A><B>Table of Contents</B></P>
+<UL>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Cancellation</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Async-signal
+	Safety</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Return
+	Value</A> 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Errors</A>
+		</P>
+	<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">Author</A>
+		</P>
+	<LI><P><A HREF="#sect8" NAME="toc8">See Also</A> 
+	</P>
+</UL>
+</BODY>
+</HTML>
\ No newline at end of file
diff --git a/src/include/pthread/need_errno.h b/src/include/pthread/need_errno.h
new file mode 100644
index 0000000..fc79f2e
--- /dev/null
+++ b/src/include/pthread/need_errno.h
@@ -0,0 +1,166 @@
+/***
+* errno.h - system wide error numbers (set by system calls)
+*
+*       Copyright (c) 1985-1997, Microsoft Corporation. All rights reserved.
+*
+* Purpose:
+*       This file defines the system-wide error numbers (set by
+*       system calls).  Conforms to the XENIX standard.  Extended
+*       for compatibility with Uniforum standard.
+*       [System V]
+*
+*       [Public]
+*
+****/
+
+#if     _MSC_VER > 1000
+#pragma once
+#endif
+
+#if !defined(_INC_ERRNO)
+#define _INC_ERRNO
+
+#if !defined(_WIN32)
+#error ERROR: Only Win32 targets supported!
+#endif
+
+//#include <winsock.h>
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+
+
+/* Define _CRTIMP */
+
+#ifndef _CRTIMP
+#if defined(_DLL)
+#define _CRTIMP __declspec(dllimport)
+#else   /* ndef _DLL */
+#define _CRTIMP
+#endif  /* _DLL */
+#endif  /* _CRTIMP */
+
+
+/* Define __cdecl for non-Microsoft compilers */
+
+#if ( !defined(_MSC_VER) && !defined(__cdecl) )
+#define __cdecl
+#endif
+
+/* Define _CRTAPI1 (for compatibility with the NT SDK) */
+
+#if !defined(_CRTAPI1)
+#if	_MSC_VER >= 800 && _M_IX86 >= 300
+#define _CRTAPI1 __cdecl
+#else
+#define _CRTAPI1
+#endif
+#endif
+
+#if defined(__PTW32_STATIC_LIB) && defined(_MSC_VER) && _MSC_VER >= 1400
+#  define __PTW32_STATIC_TLSLIB
+#endif
+
+#if defined (__PTW32_STATIC_LIB) || defined (__PTW32_STATIC_TLSLIB)
+#  define  __PTW32_DLLPORT
+#elif defined (__PTW32_BUILD)
+#    define  __PTW32_DLLPORT __declspec (dllexport)
+#  else
+#    define  __PTW32_DLLPORT __declspec (dllimport)
+#  endif
+
+/* declare reference to errno */
+
+#if (defined(_MT) || defined(_MD) || defined(_DLL)) && !defined(_MAC)
+__PTW32_DLLPORT int * __cdecl _errno(void);
+#define errno   (*_errno())
+#else   /* ndef _MT && ndef _MD && ndef _DLL */
+_CRTIMP extern int errno;
+#endif  /* _MT || _MD || _DLL */
+
+/* Error Codes */
+
+#define EPERM           1
+#define ENOENT          2
+#define ESRCH           3
+#define EINTR           4
+#define EIO             5
+#define ENXIO           6
+#define E2BIG           7
+#define ENOEXEC         8
+#define EBADF           9
+#define ECHILD          10
+#define EAGAIN          11
+#define ENOMEM          12
+#define EACCES          13
+#define EFAULT          14
+#define EBUSY           16
+#define EEXIST          17
+#define EXDEV           18
+#define ENODEV          19
+#define ENOTDIR         20
+#define EISDIR          21
+#define EINVAL          22
+#define ENFILE          23
+#define EMFILE          24
+#define ENOTTY          25
+#define EFBIG           27
+#define ENOSPC          28
+#define ESPIPE          29
+#define EROFS           30
+#define EMLINK          31
+#define EPIPE           32
+#define EDOM            33
+#define ERANGE          34
+#define EDEADLK         36
+
+/* defined differently in winsock.h on WinCE
+ * We don't use this value.
+ */
+//#if !defined(ENAMETOOLONG)
+//#define ENAMETOOLONG    38
+//#endif
+
+#define ENOLCK          39
+#define ENOSYS          40
+
+/* defined differently in winsock.h on WinCE
+ * We don't use this value.
+ */
+//#if !defined(ENOTEMPTY)
+//#define ENOTEMPTY       41
+//#endif
+
+#define EILSEQ          42
+
+/*
+ * POSIX 2008 - robust mutexes.
+ */
+#if  __PTW32_VERSION_MAJOR > 2
+#  if !defined(EOWNERDEAD)
+#    define EOWNERDEAD 1000
+#  endif
+#  if !defined(ENOTRECOVERABLE)
+#    define ENOTRECOVERABLE 1001
+#  endif
+#else
+#  if !defined(EOWNERDEAD)
+#    define EOWNERDEAD 42
+#  endif
+#  if !defined(ENOTRECOVERABLE)
+#    define ENOTRECOVERABLE 43
+#  endif
+#endif
+
+/*
+ * Support EDEADLOCK for compatibility with older MS-C versions.
+ */
+#define EDEADLOCK       EDEADLK
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif  /* _INC_ERRNO */
diff --git a/src/include/pthread/pthread.h b/src/include/pthread/pthread.h
new file mode 100644
index 0000000..03a6a14
--- /dev/null
+++ b/src/include/pthread/pthread.h
@@ -0,0 +1,1227 @@
+/* This is an implementation of the threads API of the Single Unix Specification.
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#if !defined( PTHREAD_H )
+#define PTHREAD_H
+
+/* There are three implementations of cancel cleanup.
+ * Note that pthread.h is included in both application
+ * compilation units and also internally for the library.
+ * The code here and within the library aims to work
+ * for all reasonable combinations of environments.
+ *
+ * The three implementations are:
+ *
+ *   WIN32 SEH
+ *   C
+ *   C++
+ *
+ * Please note that exiting a push/pop block via
+ * "return", "exit", "break", or "continue" will
+ * lead to different behaviour amongst applications
+ * depending upon whether the library was built
+ * using SEH, C++, or C. For example, a library built
+ * with SEH will call the cleanup routine, while both
+ * C++ and C built versions will not.
+ */
+
+/*
+ * Define defaults for cleanup code.
+ * Note: Unless the build explicitly defines one of the following, then
+ * we default to standard C style cleanup. This style uses setjmp/longjmp
+ * in the cancellation and thread exit implementations and therefore won't
+ * do stack unwinding if linked to applications that have it (e.g.
+ * C++ apps). This is currently consistent with most/all commercial Unix
+ * POSIX threads implementations.
+ */
+#if !defined( __PTW32_CLEANUP_SEH ) && !defined( __PTW32_CLEANUP_CXX ) && !defined( __PTW32_CLEANUP_C )
+# define __PTW32_CLEANUP_C
+#endif
+
+#if defined( __PTW32_CLEANUP_SEH ) && ( !defined( _MSC_VER ) && !defined (__PTW32_RC_MSC))
+#error ERROR [__FILE__, line __LINE__]: SEH is not supported for this compiler.
+#endif
+
+#include"_ptw32.h"
+
+/*
+ * Stop here if we are being included by the resource compiler.
+ */
+#if !defined(RC_INVOKED)
+
+#undef  __PTW32_LEVEL
+#undef  __PTW32_LEVEL_MAX
+#define __PTW32_LEVEL_MAX  3
+
+#if _POSIX_C_SOURCE >= 200112L			/* POSIX.1-2001 and later */
+# define __PTW32_LEVEL  __PTW32_LEVEL_MAX	/* include everything     */
+
+#elif defined INCLUDE_NP			/* earlier than POSIX.1-2001, but... */
+# define __PTW32_LEVEL  2			/* include non-portable extensions   */
+
+#elif _POSIX_C_SOURCE >= 199309L		/* POSIX.1-1993           */
+# define __PTW32_LEVEL  1 			/* include 1b, 1c, and 1d */
+
+#elif defined _POSIX_SOURCE			/* early POSIX     */
+# define __PTW32_LEVEL  0			/* minimal support */
+
+#else						/* unspecified support level */
+# define __PTW32_LEVEL  __PTW32_LEVEL_MAX	/* include everything anyway */
+#endif
+
+/*
+ * -------------------------------------------------------------
+ *
+ *
+ * Module: pthread.h
+ *
+ * Purpose:
+ *      Provides an implementation of PThreads based upon the
+ *      standard:
+ *
+ *              POSIX 1003.1-2001
+ *  and
+ *    The Single Unix Specification version 3
+ *
+ *    (these two are equivalent)
+ *
+ *      in order to enhance code portability between Windows,
+ *  various commercial Unix implementations, and Linux.
+ *
+ *      See the ANNOUNCE file for a full list of conforming
+ *      routines and defined constants, and a list of missing
+ *      routines and constants not defined in this implementation.
+ *
+ * Authors:
+ *      There have been many contributors to this library.
+ *      The initial implementation was contributed by
+ *      John Bossom, and several others have provided major
+ *      sections or revisions of parts of the implementation.
+ *      Often significant effort has been contributed to
+ *      find and fix important bugs and other problems to
+ *      improve the reliability of the library, which sometimes
+ *      is not reflected in the amount of code which changed as
+ *      result.
+ *      As much as possible, the contributors are acknowledged
+ *      in the ChangeLog file in the source code distribution
+ *      where their changes are noted in detail.
+ *
+ *      Contributors are listed in the CONTRIBUTORS file.
+ *
+ *      As usual, all bouquets go to the contributors, and all
+ *      brickbats go to the project maintainer.
+ *
+ * Maintainer:
+ *      The code base for this project is coordinated and
+ *      eventually pre-tested, packaged, and made available by
+ *
+ *              Ross Johnson <rpj@callisto.canberra.edu.au>
+ *
+ * QA Testers:
+ *      Ultimately, the library is tested in the real world by
+ *      a host of competent and demanding scientists and
+ *      engineers who report bugs and/or provide solutions
+ *      which are then fixed or incorporated into subsequent
+ *      versions of the library. Each time a bug is fixed, a
+ *      test case is written to prove the fix and ensure
+ *      that later changes to the code don't reintroduce the
+ *      same error. The number of test cases is slowly growing
+ *      and therefore so is the code reliability.
+ *
+ * Compliance:
+ *      See the file ANNOUNCE for the list of implemented
+ *      and not-implemented routines and defined options.
+ *      Of course, these are all defined is this file as well.
+ *
+ * Web site:
+ *      The source code and other information about this library
+ *      are available from
+ *
+ *              https://sourceforge.net/projects/pthreads4w/
+ *
+ * -------------------------------------------------------------
+ */
+enum
+{ /* Boolean values to make us independent of system includes. */
+   __PTW32_FALSE = 0,
+   __PTW32_TRUE = (!  __PTW32_FALSE)
+};
+
+#include <time.h>
+#include"sched.h"
+
+/*
+ * -------------------------------------------------------------
+ *
+ * POSIX 1003.1-2001 Options
+ * =========================
+ *
+ * Options are normally set in <unistd.h>, which is not provided
+ * with pthreads-win32.
+ *
+ * For conformance with the Single Unix Specification (version 3), all of the
+ * options below are defined, and have a value of either -1 (not supported)
+ * or yyyymm[dd]L (supported).
+ *
+ * These options can neither be left undefined nor have a value of 0, because
+ * either indicates that sysconf(), which is not implemented, may be used at
+ * runtime to check the status of the option.
+ *
+ * _POSIX_THREADS (== 20080912L)
+ *                      If == 20080912L, you can use threads
+ *
+ * _POSIX_THREAD_ATTR_STACKSIZE (== 200809L)
+ *                      If == 200809L, you can control the size of a thread's
+ *                      stack
+ *                              pthread_attr_getstacksize
+ *                              pthread_attr_setstacksize
+ *
+ * _POSIX_THREAD_ATTR_STACKADDR (== -1)
+ *                      If == 200809L, you can allocate and control a thread's
+ *                      stack. If not supported, the following functions
+ *                      will return ENOSYS, indicating they are not
+ *                      supported:
+ *                              pthread_attr_getstackaddr
+ *                              pthread_attr_setstackaddr
+ *
+ * _POSIX_THREAD_PRIORITY_SCHEDULING (== -1)
+ *                      If == 200112L, you can use realtime scheduling.
+ *                      This option indicates that the behaviour of some
+ *                      implemented functions conforms to the additional TPS
+ *                      requirements in the standard. E.g. rwlocks favour
+ *                      writers over readers when threads have equal priority.
+ *
+ * _POSIX_THREAD_PRIO_INHERIT (== -1)
+ *                      If == 200809L, you can create priority inheritance
+ *                      mutexes.
+ *                              pthread_mutexattr_getprotocol +
+ *                              pthread_mutexattr_setprotocol +
+ *
+ * _POSIX_THREAD_PRIO_PROTECT (== -1)
+ *                      If == 200809L, you can create priority ceiling mutexes
+ *                      Indicates the availability of:
+ *                              pthread_mutex_getprioceiling
+ *                              pthread_mutex_setprioceiling
+ *                              pthread_mutexattr_getprioceiling
+ *                              pthread_mutexattr_getprotocol     +
+ *                              pthread_mutexattr_setprioceiling
+ *                              pthread_mutexattr_setprotocol     +
+ *
+ * _POSIX_THREAD_PROCESS_SHARED (== -1)
+ *                      If set, you can create mutexes and condition
+ *                      variables that can be shared with another
+ *                      process.If set, indicates the availability
+ *                      of:
+ *                              pthread_mutexattr_getpshared
+ *                              pthread_mutexattr_setpshared
+ *                              pthread_condattr_getpshared
+ *                              pthread_condattr_setpshared
+ *
+ * _POSIX_THREAD_SAFE_FUNCTIONS (== 200809L)
+ *                      If == 200809L you can use the special *_r library
+ *                      functions that provide thread-safe behaviour
+ *
+ * _POSIX_READER_WRITER_LOCKS (== 200809L)
+ *                      If == 200809L, you can use read/write locks
+ *
+ * _POSIX_SPIN_LOCKS (== 200809L)
+ *                      If == 200809L, you can use spin locks
+ *
+ * _POSIX_BARRIERS (== 200809L)
+ *                      If == 200809L, you can use barriers
+ *
+ * _POSIX_ROBUST_MUTEXES (== 200809L)
+ *                      If == 200809L, you can use robust mutexes
+ *                      Officially this should also imply
+ *                      _POSIX_THREAD_PROCESS_SHARED != -1 however
+ *                      not here yet.
+ *
+ * -------------------------------------------------------------
+ */
+
+/*
+ * POSIX Options
+ */
+#undef  _POSIX_THREADS
+#define _POSIX_THREADS  200809L
+
+#undef  _POSIX_READER_WRITER_LOCKS
+#define _POSIX_READER_WRITER_LOCKS  200809L
+
+#undef  _POSIX_SPIN_LOCKS
+#define _POSIX_SPIN_LOCKS  200809L
+
+#undef  _POSIX_BARRIERS
+#define _POSIX_BARRIERS  200809L
+
+#undef  _POSIX_THREAD_SAFE_FUNCTIONS
+#define _POSIX_THREAD_SAFE_FUNCTIONS  200809L
+
+#undef  _POSIX_THREAD_ATTR_STACKSIZE
+#define _POSIX_THREAD_ATTR_STACKSIZE  200809L
+
+#undef  _POSIX_ROBUST_MUTEXES
+#define _POSIX_ROBUST_MUTEXES  200809L
+
+/*
+ * The following options are not supported
+ */
+#undef  _POSIX_THREAD_ATTR_STACKADDR
+#define _POSIX_THREAD_ATTR_STACKADDR  -1
+
+#undef  _POSIX_THREAD_PRIO_INHERIT
+#define _POSIX_THREAD_PRIO_INHERIT  -1
+
+#undef  _POSIX_THREAD_PRIO_PROTECT
+#define _POSIX_THREAD_PRIO_PROTECT  -1
+
+/* TPS is not fully supported.  */
+#undef  _POSIX_THREAD_PRIORITY_SCHEDULING
+#define _POSIX_THREAD_PRIORITY_SCHEDULING  -1
+
+#undef  _POSIX_THREAD_PROCESS_SHARED
+#define _POSIX_THREAD_PROCESS_SHARED  -1
+
+
+/*
+ * POSIX 1003.1-2001 Limits
+ * ===========================
+ *
+ * These limits are normally set in <limits.h>, which is not provided with
+ * pthreads-win32.
+ *
+ * PTHREAD_DESTRUCTOR_ITERATIONS
+ *                      Maximum number of attempts to destroy
+ *                      a thread's thread-specific data on
+ *                      termination (must be at least 4)
+ *
+ * PTHREAD_KEYS_MAX
+ *                      Maximum number of thread-specific data keys
+ *                      available per process (must be at least 128)
+ *
+ * PTHREAD_STACK_MIN
+ *                      Minimum supported stack size for a thread
+ *
+ * PTHREAD_THREADS_MAX
+ *                      Maximum number of threads supported per
+ *                      process (must be at least 64).
+ *
+ * SEM_NSEMS_MAX
+ *                      The maximum number of semaphores a process can have.
+ *                      (must be at least 256)
+ *
+ * SEM_VALUE_MAX
+ *                      The maximum value a semaphore can have.
+ *                      (must be at least 32767)
+ *
+ */
+#undef  _POSIX_THREAD_DESTRUCTOR_ITERATIONS
+#define _POSIX_THREAD_DESTRUCTOR_ITERATIONS     4
+
+#undef  PTHREAD_DESTRUCTOR_ITERATIONS
+#define PTHREAD_DESTRUCTOR_ITERATIONS           _POSIX_THREAD_DESTRUCTOR_ITERATIONS
+
+#undef  _POSIX_THREAD_KEYS_MAX
+#define _POSIX_THREAD_KEYS_MAX                  128
+
+#undef  PTHREAD_KEYS_MAX
+#define PTHREAD_KEYS_MAX                        _POSIX_THREAD_KEYS_MAX
+
+#undef  PTHREAD_STACK_MIN
+#define PTHREAD_STACK_MIN                       0
+
+#undef  _POSIX_THREAD_THREADS_MAX
+#define _POSIX_THREAD_THREADS_MAX               64
+
+/* Arbitrary value */
+#undef  PTHREAD_THREADS_MAX
+#define PTHREAD_THREADS_MAX                     2019
+
+#undef  _POSIX_SEM_NSEMS_MAX
+#define _POSIX_SEM_NSEMS_MAX                    256
+
+/* Arbitrary value */
+#undef  SEM_NSEMS_MAX
+#define SEM_NSEMS_MAX                           1024
+
+#undef  _POSIX_SEM_VALUE_MAX
+#define _POSIX_SEM_VALUE_MAX                    32767
+
+#undef  SEM_VALUE_MAX
+#define SEM_VALUE_MAX                           INT_MAX
+
+
+#if defined(_UWIN) && __PTW32_LEVEL >= __PTW32_LEVEL_MAX
+#   include     <sys/types.h>
+#else
+/* Generic handle type - intended to provide the lifetime-uniqueness that
+ * a simple pointer can't. It should scale for either
+ * 32 or 64 bit systems.
+ *
+ * The constraint with this approach is that applications must
+ * strictly comply with POSIX, e.g. not assume scalar type, only
+ * compare pthread_t using the API function pthread_equal(), etc.
+ *
+ * Non-conforming applications could use the element 'p' to compare,
+ * e.g. for sorting, but it will be up to the application to determine
+ * if handles are live or dead, or resurrected for an entirely
+ * new/different thread. I.e. the thread is valid iff
+ * x == p->ptHandle.x
+ */
+typedef struct
+{ void * p;                   /* Pointer to actual object */
+#if  __PTW32_VERSION_MAJOR > 2
+  size_t x;                   /* Extra information - reuse count etc */
+#else
+  unsigned int x;             /* Extra information - reuse count etc */
+#endif
+} __ptw32_handle_t;
+
+typedef __ptw32_handle_t pthread_t;
+typedef struct pthread_attr_t_ * pthread_attr_t;
+typedef struct pthread_once_t_ pthread_once_t;
+typedef struct pthread_key_t_ * pthread_key_t;
+typedef struct pthread_mutex_t_ * pthread_mutex_t;
+typedef struct pthread_mutexattr_t_ * pthread_mutexattr_t;
+typedef struct pthread_cond_t_ * pthread_cond_t;
+typedef struct pthread_condattr_t_ * pthread_condattr_t;
+#endif
+
+typedef struct pthread_rwlock_t_ * pthread_rwlock_t;
+typedef struct pthread_rwlockattr_t_ * pthread_rwlockattr_t;
+typedef struct pthread_spinlock_t_ * pthread_spinlock_t;
+typedef struct pthread_barrier_t_ * pthread_barrier_t;
+typedef struct pthread_barrierattr_t_ * pthread_barrierattr_t;
+
+/*
+ * ====================
+ * ====================
+ * POSIX Threads
+ * ====================
+ * ====================
+ */
+
+enum
+{ /* pthread_attr_{get,set}detachstate
+   */
+  PTHREAD_CREATE_JOINABLE       = 0,  /* Default */
+  PTHREAD_CREATE_DETACHED       = 1,
+  /*
+   * pthread_attr_{get,set}inheritsched
+   */
+  PTHREAD_INHERIT_SCHED         = 0,
+  PTHREAD_EXPLICIT_SCHED        = 1,  /* Default */
+  /*
+   * pthread_{get,set}scope
+   */
+  PTHREAD_SCOPE_PROCESS         = 0,
+  PTHREAD_SCOPE_SYSTEM          = 1,  /* Default */
+  /*
+   * pthread_setcancelstate paramters
+   */
+  PTHREAD_CANCEL_ENABLE         = 0,  /* Default */
+  PTHREAD_CANCEL_DISABLE        = 1,
+  /*
+   * pthread_setcanceltype parameters
+   */
+  PTHREAD_CANCEL_ASYNCHRONOUS   = 0,
+  PTHREAD_CANCEL_DEFERRED       = 1,  /* Default */
+  /*
+   * pthread_mutexattr_{get,set}pshared
+   * pthread_condattr_{get,set}pshared
+   */
+  PTHREAD_PROCESS_PRIVATE       = 0,
+  PTHREAD_PROCESS_SHARED        = 1,
+  /*
+   * pthread_mutexattr_{get,set}robust
+   */
+  PTHREAD_MUTEX_STALLED         = 0,  /* Default */
+  PTHREAD_MUTEX_ROBUST          = 1,
+  /*
+   * pthread_barrier_wait
+   */
+  PTHREAD_BARRIER_SERIAL_THREAD = -1
+};
+
+/*
+ * ====================
+ * ====================
+ * cancellation
+ * ====================
+ * ====================
+ */
+#define PTHREAD_CANCELED       ((void *)(size_t) -1)
+
+
+/*
+ * ====================
+ * ====================
+ * Once Key
+ * ====================
+ * ====================
+ */
+#if  __PTW32_VERSION_MAJOR > 2
+
+#define PTHREAD_ONCE_INIT       { 0,  __PTW32_FALSE }
+
+struct pthread_once_t_
+{
+  void *       lock;		/* MCS lock */
+  int          done;    	/* indicates if user function has been executed */
+};
+
+#else
+
+#define PTHREAD_ONCE_INIT       {  __PTW32_FALSE, 0, 0, 0 }
+
+struct pthread_once_t_
+{
+  int          done;       	/* indicates if user function has been executed */
+  void *       lock;		/* MCS lock */
+  int          reserved1;
+  int          reserved2;
+};
+
+#endif
+
+
+/*
+ * ====================
+ * ====================
+ * Object initialisers
+ * ====================
+ * ====================
+ */
+#define PTHREAD_MUTEX_INITIALIZER ((pthread_mutex_t)(size_t) -1)
+#define PTHREAD_RECURSIVE_MUTEX_INITIALIZER ((pthread_mutex_t)(size_t) -2)
+#define PTHREAD_ERRORCHECK_MUTEX_INITIALIZER ((pthread_mutex_t)(size_t) -3)
+
+/*
+ * Compatibility with LinuxThreads
+ */
+#define PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP PTHREAD_RECURSIVE_MUTEX_INITIALIZER
+#define PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP PTHREAD_ERRORCHECK_MUTEX_INITIALIZER
+
+#define PTHREAD_COND_INITIALIZER ((pthread_cond_t)(size_t) -1)
+
+#define PTHREAD_RWLOCK_INITIALIZER ((pthread_rwlock_t)(size_t) -1)
+
+#define PTHREAD_SPINLOCK_INITIALIZER ((pthread_spinlock_t)(size_t) -1)
+
+
+/*
+ * Mutex types.
+ */
+enum
+{
+  /* Compatibility with LinuxThreads */
+  PTHREAD_MUTEX_FAST_NP,
+  PTHREAD_MUTEX_RECURSIVE_NP,
+  PTHREAD_MUTEX_ERRORCHECK_NP,
+  PTHREAD_MUTEX_TIMED_NP = PTHREAD_MUTEX_FAST_NP,
+  PTHREAD_MUTEX_ADAPTIVE_NP = PTHREAD_MUTEX_FAST_NP,
+  /* For compatibility with POSIX */
+  PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_FAST_NP,
+  PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP,
+  PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP,
+  PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL
+};
+
+
+typedef struct __ptw32_cleanup_t __ptw32_cleanup_t;
+
+#if defined(_MSC_VER)
+/* Disable MSVC 'anachronism used' warning */
+#pragma warning( disable : 4229 )
+#endif
+
+typedef void (*  __PTW32_CDECL __ptw32_cleanup_callback_t)(void *);
+
+#if defined(_MSC_VER)
+#pragma warning( default : 4229 )
+#endif
+
+struct __ptw32_cleanup_t
+{
+  __ptw32_cleanup_callback_t routine;
+  void *arg;
+  struct __ptw32_cleanup_t *prev;
+};
+
+#if defined(__PTW32_CLEANUP_SEH)
+        /*
+         * WIN32 SEH version of cancel cleanup.
+         */
+
+#define pthread_cleanup_push( _rout, _arg ) \
+        { \
+            __ptw32_cleanup_t     _cleanup; \
+            \
+        _cleanup.routine        = (__ptw32_cleanup_callback_t)(_rout); \
+            _cleanup.arg        = (_arg); \
+            __try \
+              { \
+
+#define pthread_cleanup_pop( _execute ) \
+              } \
+            __finally \
+                { \
+                    if( _execute || AbnormalTermination()) \
+                      { \
+                          (*(_cleanup.routine))( _cleanup.arg ); \
+                      } \
+                } \
+        }
+
+#else /* __PTW32_CLEANUP_SEH */
+
+#if defined(__PTW32_CLEANUP_C)
+
+        /*
+         * C implementation of PThreads cancel cleanup
+         */
+
+#define pthread_cleanup_push( _rout, _arg ) \
+        { \
+            __ptw32_cleanup_t     _cleanup; \
+            \
+            __ptw32_push_cleanup( &_cleanup, (__ptw32_cleanup_callback_t) (_rout), (_arg) ); \
+
+#define pthread_cleanup_pop( _execute ) \
+            (void) __ptw32_pop_cleanup( _execute ); \
+        }
+
+#else /* __PTW32_CLEANUP_C */
+
+#if defined(__PTW32_CLEANUP_CXX)
+
+        /*
+         * C++ version of cancel cleanup.
+         * - John E. Bossom.
+         */
+
+        class PThreadCleanup {
+          /*
+           * PThreadCleanup
+           *
+           * Purpose
+           *      This class is a C++ helper class that is
+           *      used to implement pthread_cleanup_push/
+           *      pthread_cleanup_pop.
+           *      The destructor of this class automatically
+           *      pops the pushed cleanup routine regardless
+           *      of how the code exits the scope
+           *      (i.e. such as by an exception)
+           */
+      __ptw32_cleanup_callback_t cleanUpRout;
+          void    *       obj;
+          int             executeIt;
+
+        public:
+          PThreadCleanup() :
+            cleanUpRout( 0 ),
+            obj( 0 ),
+            executeIt( 0 )
+            /*
+             * No cleanup performed
+             */
+            {
+            }
+
+          PThreadCleanup(
+             __ptw32_cleanup_callback_t routine,
+                         void    *       arg ) :
+            cleanUpRout( routine ),
+            obj( arg ),
+            executeIt( 1 )
+            /*
+             * Registers a cleanup routine for 'arg'
+             */
+            {
+            }
+
+          ~PThreadCleanup()
+            {
+              if ( executeIt && ((void *) cleanUpRout != (void *) 0) )
+                {
+                  (void) (*cleanUpRout)( obj );
+                }
+            }
+
+          void execute( int exec )
+            {
+              executeIt = exec;
+            }
+        };
+
+        /*
+         * C++ implementation of PThreads cancel cleanup;
+         * This implementation takes advantage of a helper
+         * class who's destructor automatically calls the
+         * cleanup routine if we exit our scope weirdly
+         */
+#define pthread_cleanup_push( _rout, _arg ) \
+        { \
+            PThreadCleanup  cleanup((__ptw32_cleanup_callback_t)(_rout), \
+                                    (void *) (_arg) );
+
+#define pthread_cleanup_pop( _execute ) \
+            cleanup.execute( _execute ); \
+        }
+
+#else
+
+#error ERROR [__FILE__, line __LINE__]: Cleanup type undefined.
+
+#endif /* __PTW32_CLEANUP_CXX */
+
+#endif /* __PTW32_CLEANUP_C */
+
+#endif /* __PTW32_CLEANUP_SEH */
+
+
+/*
+ * ===============
+ * ===============
+ * Methods
+ * ===============
+ * ===============
+ */
+
+__PTW32_BEGIN_C_DECLS
+
+/*
+ * PThread Attribute Functions
+ */
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_attr_init (pthread_attr_t * attr);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_attr_destroy (pthread_attr_t * attr);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_attr_getaffinity_np (const pthread_attr_t * attr,
+                                         size_t cpusetsize,
+                                         cpu_set_t * cpuset);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_attr_getdetachstate (const pthread_attr_t * attr,
+                                         int *detachstate);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_attr_getstackaddr (const pthread_attr_t * attr,
+                                       void **stackaddr);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_attr_getstacksize (const pthread_attr_t * attr,
+                                       size_t * stacksize);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_attr_setaffinity_np (pthread_attr_t * attr,
+                                       size_t cpusetsize,
+                                       const cpu_set_t * cpuset);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_attr_setdetachstate (pthread_attr_t * attr,
+                                         int detachstate);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_attr_setstackaddr (pthread_attr_t * attr,
+                                       void *stackaddr);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_attr_setstacksize (pthread_attr_t * attr,
+                                       size_t stacksize);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_attr_getschedparam (const pthread_attr_t *attr,
+                                        struct sched_param *param);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_attr_setschedparam (pthread_attr_t *attr,
+                                        const struct sched_param *param);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_attr_setschedpolicy (pthread_attr_t *,
+                                         int);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_attr_getschedpolicy (const pthread_attr_t *,
+                                         int *);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_attr_setinheritsched(pthread_attr_t * attr,
+                                         int inheritsched);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_attr_getinheritsched(const pthread_attr_t * attr,
+                                         int * inheritsched);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_attr_setscope (pthread_attr_t *,
+                                   int);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_attr_getscope (const pthread_attr_t *,
+                                   int *);
+
+/*
+ * PThread Functions
+ */
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_create(pthread_t * tid, 
+                                                  const pthread_attr_t * attr, 
+                                                  void *(__PTW32_CDECL *start) (void *), 
+                                                  void *arg);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_detach (pthread_t tid);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_equal (pthread_t t1,
+                           pthread_t t2);
+
+__PTW32_DLLPORT void  __PTW32_CDECL pthread_exit (void *value_ptr);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_join (pthread_t thread,
+                          void **value_ptr);
+
+__PTW32_DLLPORT pthread_t  __PTW32_CDECL pthread_self (void);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_cancel (pthread_t thread);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_setcancelstate (int state,
+                                    int *oldstate);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_setcanceltype (int type,
+                                   int *oldtype);
+
+__PTW32_DLLPORT void  __PTW32_CDECL pthread_testcancel (void);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_once (pthread_once_t * once_control,
+                          void  (__PTW32_CDECL *init_routine) (void));
+
+#if __PTW32_LEVEL >= __PTW32_LEVEL_MAX
+__PTW32_DLLPORT __ptw32_cleanup_t *  __PTW32_CDECL __ptw32_pop_cleanup (int execute);
+
+__PTW32_DLLPORT void  __PTW32_CDECL __ptw32_push_cleanup (__ptw32_cleanup_t * cleanup,
+                                 __ptw32_cleanup_callback_t routine,
+                                 void *arg);
+#endif /* __PTW32_LEVEL >= __PTW32_LEVEL_MAX */
+
+/*
+ * Thread Specific Data Functions
+ */
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_key_create (pthread_key_t * key, void  (__PTW32_CDECL *destructor) (void *));
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_key_delete (pthread_key_t key);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_setspecific (pthread_key_t key,
+                                 const void *value);
+
+__PTW32_DLLPORT void *  __PTW32_CDECL pthread_getspecific (pthread_key_t key);
+
+
+/*
+ * Mutex Attribute Functions
+ */
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_mutexattr_init (pthread_mutexattr_t * attr);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_mutexattr_destroy (pthread_mutexattr_t * attr);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_mutexattr_getpshared (const pthread_mutexattr_t
+                                          * attr,
+                                          int *pshared);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_mutexattr_setpshared (pthread_mutexattr_t * attr,
+                                          int pshared);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_mutexattr_settype (pthread_mutexattr_t * attr, int kind);
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_mutexattr_gettype (const pthread_mutexattr_t * attr, int *kind);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_mutexattr_setrobust(
+                                           pthread_mutexattr_t *attr,
+                                           int robust);
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_mutexattr_getrobust(
+                                           const pthread_mutexattr_t * attr,
+                                           int * robust);
+
+/*
+ * Barrier Attribute Functions
+ */
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_barrierattr_init (pthread_barrierattr_t * attr);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_barrierattr_destroy (pthread_barrierattr_t * attr);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_barrierattr_getpshared (const pthread_barrierattr_t
+                                            * attr,
+                                            int *pshared);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_barrierattr_setpshared (pthread_barrierattr_t * attr,
+                                            int pshared);
+
+/*
+ * Mutex Functions
+ */
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_mutex_init (pthread_mutex_t * mutex,
+                                const pthread_mutexattr_t * attr);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_mutex_destroy (pthread_mutex_t * mutex);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_mutex_lock (pthread_mutex_t * mutex);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_mutex_timedlock(pthread_mutex_t * mutex,
+                                    const struct timespec *abstime);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_mutex_trylock (pthread_mutex_t * mutex);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_mutex_unlock (pthread_mutex_t * mutex);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_mutex_consistent (pthread_mutex_t * mutex);
+
+/*
+ * Spinlock Functions
+ */
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_spin_init (pthread_spinlock_t * lock, int pshared);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_spin_destroy (pthread_spinlock_t * lock);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_spin_lock (pthread_spinlock_t * lock);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_spin_trylock (pthread_spinlock_t * lock);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_spin_unlock (pthread_spinlock_t * lock);
+
+/*
+ * Barrier Functions
+ */
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_barrier_init (pthread_barrier_t * barrier,
+                                  const pthread_barrierattr_t * attr,
+                                  unsigned int count);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_barrier_destroy (pthread_barrier_t * barrier);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_barrier_wait (pthread_barrier_t * barrier);
+
+/*
+ * Condition Variable Attribute Functions
+ */
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_condattr_init (pthread_condattr_t * attr);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_condattr_destroy (pthread_condattr_t * attr);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_condattr_getpshared (const pthread_condattr_t * attr,
+                                         int *pshared);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_condattr_setpshared (pthread_condattr_t * attr,
+                                         int pshared);
+
+/*
+ * Condition Variable Functions
+ */
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_cond_init (pthread_cond_t * cond,
+                               const pthread_condattr_t * attr);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_cond_destroy (pthread_cond_t * cond);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_cond_wait (pthread_cond_t * cond,
+                               pthread_mutex_t * mutex);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_cond_timedwait (pthread_cond_t * cond,
+                                    pthread_mutex_t * mutex,
+                                    const struct timespec *abstime);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_cond_signal (pthread_cond_t * cond);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_cond_broadcast (pthread_cond_t * cond);
+
+/*
+ * Scheduling
+ */
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_setschedparam (pthread_t thread,
+                                   int policy,
+                                   const struct sched_param *param);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_getschedparam (pthread_t thread,
+                                   int *policy,
+                                   struct sched_param *param);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_setconcurrency (int);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_getconcurrency (void);
+
+/*
+ * Read-Write Lock Functions
+ */
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_rwlock_init(pthread_rwlock_t *lock,
+                                const pthread_rwlockattr_t *attr);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_rwlock_destroy(pthread_rwlock_t *lock);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_rwlock_tryrdlock(pthread_rwlock_t *);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_rwlock_trywrlock(pthread_rwlock_t *);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_rwlock_rdlock(pthread_rwlock_t *lock);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_rwlock_timedrdlock(pthread_rwlock_t *lock,
+                                       const struct timespec *abstime);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_rwlock_wrlock(pthread_rwlock_t *lock);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_rwlock_timedwrlock(pthread_rwlock_t *lock,
+                                       const struct timespec *abstime);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_rwlock_unlock(pthread_rwlock_t *lock);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_rwlockattr_init (pthread_rwlockattr_t * attr);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_rwlockattr_destroy (pthread_rwlockattr_t * attr);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_rwlockattr_getpshared (const pthread_rwlockattr_t * attr,
+                                           int *pshared);
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_rwlockattr_setpshared (pthread_rwlockattr_t * attr,
+                                           int pshared);
+
+#if __PTW32_LEVEL >= __PTW32_LEVEL_MAX - 1
+
+/*
+ * Signal Functions. Should be defined in <signal.h> but MSVC and MinGW32
+ * already have signal.h that don't define these.
+ */
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_kill(pthread_t thread, int sig);
+
+/*
+ * Non-portable functions
+ */
+
+/*
+ * Compatibility with Linux.
+ */
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_mutexattr_setkind_np(pthread_mutexattr_t * attr,
+                                         int kind);
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_mutexattr_getkind_np(pthread_mutexattr_t * attr,
+                                         int *kind);
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_timedjoin_np(pthread_t thread,
+                                         void **value_ptr,
+                                         const struct timespec *abstime);
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_tryjoin_np(pthread_t thread,
+                                         void **value_ptr);
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_setaffinity_np(pthread_t thread,
+										 size_t cpusetsize,
+										 const cpu_set_t *cpuset);
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_getaffinity_np(pthread_t thread,
+										 size_t cpusetsize,
+										 cpu_set_t *cpuset);
+
+/*
+ * Possibly supported by other POSIX threads implementations
+ */
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_delay_np (struct timespec * interval);
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_num_processors_np(void);
+__PTW32_DLLPORT unsigned __int64  __PTW32_CDECL pthread_getunique_np(pthread_t thread);
+
+/*
+ * Useful if an application wants to statically link
+ * the lib rather than load the DLL at run-time.
+ */
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_win32_process_attach_np(void);
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_win32_process_detach_np(void);
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_win32_thread_attach_np(void);
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_win32_thread_detach_np(void);
+
+/*
+ * Returns the first parameter "abstime" modified to represent the current system time.
+ * If "relative" is not NULL it represents an interval to add to "abstime".
+ */
+
+__PTW32_DLLPORT struct timespec *  __PTW32_CDECL pthread_win32_getabstime_np(
+						      struct timespec * abstime,
+						      const struct timespec * relative);
+
+/*
+ * Features that are auto-detected at load/run time.
+ */
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_win32_test_features_np(int);
+enum __ptw32_features
+{
+   __PTW32_SYSTEM_INTERLOCKED_COMPARE_EXCHANGE = 0x0001,	/* System provides it. */
+   __PTW32_ALERTABLE_ASYNC_CANCEL              = 0x0002	/* Can cancel blocked threads. */
+};
+
+/*
+ * Register a system time change with the library.
+ * Causes the library to perform various functions
+ * in response to the change. Should be called whenever
+ * the application's top level window receives a
+ * WM_TIMECHANGE message. It can be passed directly to
+ * pthread_create() as a new thread if desired.
+ */
+__PTW32_DLLPORT void *  __PTW32_CDECL pthread_timechange_handler_np(void *);
+
+#endif /* __PTW32_LEVEL >= __PTW32_LEVEL_MAX - 1 */
+
+#if __PTW32_LEVEL >= __PTW32_LEVEL_MAX
+
+/*
+ * Returns the Win32 HANDLE for the POSIX thread.
+ */
+__PTW32_DLLPORT void *  __PTW32_CDECL pthread_getw32threadhandle_np(pthread_t thread);
+/*
+ * Returns the win32 thread ID for POSIX thread.
+ */
+__PTW32_DLLPORT unsigned long  __PTW32_CDECL pthread_getw32threadid_np (pthread_t thread);
+
+/*
+ * Sets the POSIX thread name. If _MSC_VER is defined the name should be displayed by
+ * the MSVS debugger.
+ */
+#if defined (__PTW32_COMPATIBILITY_BSD) || defined (__PTW32_COMPATIBILITY_TRU64)
+#define PTHREAD_MAX_NAMELEN_NP 16
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_setname_np (pthread_t thr, const char * name, void * arg);
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_attr_setname_np (pthread_attr_t * attr, const char * name, void * arg);
+#else
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_setname_np (pthread_t thr, const char * name);
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_attr_setname_np (pthread_attr_t * attr, const char * name);
+#endif
+
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_getname_np (pthread_t thr, char * name, int len);
+__PTW32_DLLPORT int  __PTW32_CDECL pthread_attr_getname_np (pthread_attr_t * attr, char * name, int len);
+
+
+/*
+ * Protected Methods
+ *
+ * This function blocks until the given WIN32 handle
+ * is signalled or pthread_cancel had been called.
+ * This function allows the caller to hook into the
+ * PThreads cancel mechanism. It is implemented using
+ *
+ *              WaitForMultipleObjects
+ *
+ * on 'waitHandle' and a manually reset WIN32 Event
+ * used to implement pthread_cancel. The 'timeout'
+ * argument to TimedWait is simply passed to
+ * WaitForMultipleObjects.
+ */
+__PTW32_DLLPORT int  __PTW32_CDECL pthreadCancelableWait (void *waitHandle);
+__PTW32_DLLPORT int  __PTW32_CDECL pthreadCancelableTimedWait (void *waitHandle,
+                                        unsigned long timeout);
+
+#endif /* __PTW32_LEVEL >= __PTW32_LEVEL_MAX */
+
+/*
+ * Declare a thread-safe errno for Open Watcom
+ * (note: this has not been tested in a long time)
+ */
+#if defined(__WATCOMC__) && !defined(errno)
+#  if defined(_MT) || defined(_DLL)
+     __declspec(dllimport) extern int * __cdecl _errno(void);
+#    define errno (*_errno())
+#  endif
+#endif
+
+#if defined (__PTW32_USES_SEPARATE_CRT) && (defined(__PTW32_CLEANUP_CXX) || defined(__PTW32_CLEANUP_SEH))
+typedef void (*__ptw32_terminate_handler)();
+__PTW32_DLLPORT __ptw32_terminate_handler  __PTW32_CDECL pthread_win32_set_terminate_np(__ptw32_terminate_handler termFunction);
+#endif
+
+#if defined(__cplusplus)
+
+/*
+ * Internal exceptions
+ */
+class __ptw32_exception {};
+class __ptw32_exception_cancel : public __ptw32_exception {};
+class __ptw32_exception_exit   : public __ptw32_exception {};
+
+#endif
+
+#if __PTW32_LEVEL >= __PTW32_LEVEL_MAX
+
+/* FIXME: This is only required if the library was built using SEH */
+/*
+ * Get internal SEH tag
+ */
+__PTW32_DLLPORT unsigned long  __PTW32_CDECL __ptw32_get_exception_services_code(void);
+
+#endif /* __PTW32_LEVEL >= __PTW32_LEVEL_MAX */
+
+#if !defined (__PTW32_BUILD)
+
+#if defined(__PTW32_CLEANUP_SEH)
+
+/*
+ * Redefine the SEH __except keyword to ensure that applications
+ * propagate our internal exceptions up to the library's internal handlers.
+ */
+#define __except( E ) \
+        __except( ( GetExceptionCode() == __ptw32_get_exception_services_code() ) \
+                 ? EXCEPTION_CONTINUE_SEARCH : ( E ) )
+
+#endif /* __PTW32_CLEANUP_SEH */
+
+#if defined(__PTW32_CLEANUP_CXX)
+
+/*
+ * Redefine the C++ catch keyword to ensure that applications
+ * propagate our internal exceptions up to the library's internal handlers.
+ */
+#if defined(_MSC_VER)
+        /*
+         * WARNING: Replace any 'catch( ... )' with '__PtW32CatchAll'
+         * if you want Pthread-Win32 cancellation and pthread_exit to work.
+         */
+
+#if !defined(__PtW32NoCatchWarn)
+
+#pragma message("Specify \"/D__PtW32NoCatchWarn\" compiler flag to skip this message.")
+#pragma message("------------------------------------------------------------------")
+#pragma message("When compiling applications with MSVC++ and C++ exception handling:")
+#pragma message("  Replace any 'catch( ... )' in routines called from POSIX threads")
+#pragma message("  with '__PtW32CatchAll' or 'CATCHALL' if you want POSIX thread")
+#pragma message("  cancellation and pthread_exit to work. For example:")
+#pragma message("")
+#pragma message("    #if defined(__PtW32CatchAll)")
+#pragma message("      __PtW32CatchAll")
+#pragma message("    #else")
+#pragma message("      catch(...)")
+#pragma message("    #endif")
+#pragma message("        {")
+#pragma message("          /* Catchall block processing */")
+#pragma message("        }")
+#pragma message("------------------------------------------------------------------")
+
+#endif
+
+#define __PtW32CatchAll \
+        catch( __ptw32_exception & ) { throw; } \
+        catch( ... )
+
+#else /* _MSC_VER */
+
+#define catch( E ) \
+        catch( __ptw32_exception & ) { throw; } \
+        catch( E )
+
+#endif /* _MSC_VER */
+
+#endif /* __PTW32_CLEANUP_CXX */
+
+#endif /* !  __PTW32_BUILD */
+
+__PTW32_END_C_DECLS
+
+#undef __PTW32_LEVEL
+#undef __PTW32_LEVEL_MAX
+
+#endif /* ! RC_INVOKED */
+
+#endif /* PTHREAD_H */
diff --git a/src/include/pthread/sched.h b/src/include/pthread/sched.h
new file mode 100644
index 0000000..f2105fa
--- /dev/null
+++ b/src/include/pthread/sched.h
@@ -0,0 +1,235 @@
+/*
+ * Module: sched.h
+ *
+ * Purpose:
+ *      Provides an implementation of POSIX realtime extensions
+ *      as defined in
+ *
+ *              POSIX 1003.1b-1993      (POSIX.1b)
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#if !defined(_SCHED_H)
+#define _SCHED_H
+#define __SCHED_H_SOURCED__
+
+#include"_ptw32.h"
+
+/* We need a typedef for pid_t, (and POSIX requires <sched.h> to
+ * define it, as it is defined in <sys/types.h>, but it does NOT
+ * sanction exposure of everything from <sys/types.h>); there is
+ * no pid_t in Windows anyway, (except that MinGW does define it
+ * in their <sys/types.h>), so just provide a suitable typedef,
+ * but note that we must do so cautiously, to avoid a typedef
+ * conflict if MinGW's <sys/types.h> is also #included:
+ */
+#if ! defined __MINGW32__ || ! defined __have_typedef_pid_t
+
+# if defined __MINGW64__
+    typedef __int64 pid_t;
+# else
+    typedef int pid_t;
+#endif
+
+#if __GNUC__ < 4
+/* GCC v4.0 and later, (as used by MinGW), allows us to repeat a
+ * typedef, provided every duplicate is consistent; only set this
+ * multiple definition guard when we cannot be certain that it is
+ * permissable to repeat typedefs.
+ */
+#define __have_typedef_pid_t  1
+#endif
+#endif
+
+/* POSIX.1-1993 says that <sched.h> WILL expose all of <time.h>
+ */
+#undef __SCHED_H_SOURCED__
+#if _POSIX_C_SOURCE >= 200112L
+/* POSIX.1-2001 and later revises this to say only that it MAY do so;
+ * only struct timespec, and associated time_t are actually required,
+ * so prefer to be selective; (MinGW.org's <time.h> offers an option
+ * for selective #inclusion, when __SCHED_H_SOURCED__ is defined):
+ */
+#define __SCHED_H_SOURCED__
+#define __need_struct_timespec
+#define __need_time_t
+#endif
+#include <time.h>
+
+#if defined __MINGW64__ || _MSC_VER >= 1900
+/* These are known to define struct timespec, when <time.h> has been
+ * #included, but may not, (probably don't), follow the convention of
+ * defining __struct_timespec_defined, as adopted by MinGW.org; for
+ * these cases, we unconditionally assume that struct timespec has
+ * been defined, otherwise, if MinGW.org's criterion has not been
+ * satisfied...
+ */
+#elif ! defined __struct_timespec_defined
+#  ifndef _TIMESPEC_DEFINED
+#  define _TIMESPEC_DEFINED
+struct timespec
+{ /* ...we fall back on this explicit definition.
+   */
+  time_t	tv_sec;
+  int		tv_nsec;
+};
+#  endif
+#endif
+
+/*
+ * Microsoft VC++6.0 lacks these *_PTR types
+ */
+#if defined(_MSC_VER) && _MSC_VER < 1300 && !defined (__PTW32_HAVE_DWORD_PTR)
+typedef unsigned long ULONG_PTR;
+typedef ULONG_PTR DWORD_PTR;
+#endif
+
+/* Thread scheduling policies */
+
+enum
+{ SCHED_OTHER = 0,
+  SCHED_FIFO,
+  SCHED_RR,
+  SCHED_MIN   = SCHED_OTHER,
+  SCHED_MAX   = SCHED_RR
+};
+
+struct sched_param
+{ int  sched_priority;
+};
+
+/*
+ * CPU affinity
+ *
+ * cpu_set_t:
+ * Considered opaque but cannot be an opaque pointer due to the need for
+ * compatibility with GNU systems and sched_setaffinity() et.al., which
+ * include the cpusetsize parameter "normally set to sizeof(cpu_set_t)".
+ *
+ * FIXME: These are GNU, and NOT specified by POSIX; maybe consider
+ * occluding them within a _GNU_SOURCE (or similar) feature test.
+ */
+
+#define CPU_SETSIZE (sizeof(size_t)*8)
+
+#define CPU_COUNT(setptr) (_sched_affinitycpucount(setptr))
+
+#define CPU_ZERO(setptr) (_sched_affinitycpuzero(setptr))
+
+#define CPU_SET(cpu, setptr) (_sched_affinitycpuset((cpu),(setptr)))
+
+#define CPU_CLR(cpu, setptr) (_sched_affinitycpuclr((cpu),(setptr)))
+
+#define CPU_ISSET(cpu, setptr) (_sched_affinitycpuisset((cpu),(setptr)))
+
+#define CPU_AND(destsetptr, srcset1ptr, srcset2ptr) (_sched_affinitycpuand((destsetptr),(srcset1ptr),(srcset2ptr)))
+
+#define CPU_OR(destsetptr, srcset1ptr, srcset2ptr) (_sched_affinitycpuor((destsetptr),(srcset1ptr),(srcset2ptr)))
+
+#define CPU_XOR(destsetptr, srcset1ptr, srcset2ptr) \
+ (_sched_affinitycpuxor((destsetptr),(srcset1ptr),(srcset2ptr)))
+
+#define CPU_EQUAL(set1ptr, set2ptr) (_sched_affinitycpuequal((set1ptr),(set2ptr)))
+
+typedef union
+{ char     cpuset[CPU_SETSIZE/8];
+  size_t  _align;
+} cpu_set_t;
+
+__PTW32_BEGIN_C_DECLS
+
+__PTW32_DLLPORT int  __PTW32_CDECL sched_yield (void);
+
+__PTW32_DLLPORT int  __PTW32_CDECL sched_get_priority_min (int policy);
+
+__PTW32_DLLPORT int  __PTW32_CDECL sched_get_priority_max (int policy);
+
+/* FIXME: this declaration of sched_setscheduler() is NOT as prescribed
+ * by POSIX; it lacks const struct sched_param * as third argument.
+ */
+__PTW32_DLLPORT int  __PTW32_CDECL sched_setscheduler (pid_t pid, int policy);
+
+/* FIXME: In addition to the above five functions, POSIX also requires:
+ *
+ *   int sched_getparam (pid_t, struct sched_param *);
+ *   int sched_setparam (pid_t, const struct sched_param *);
+ *
+ * both of which are conspicuous by their absence here!
+ */
+
+/* Compatibility with Linux - not standard in POSIX
+ * FIXME: consider occluding within a _GNU_SOURCE (or similar) feature test.
+ */
+__PTW32_DLLPORT int  __PTW32_CDECL sched_setaffinity (pid_t pid, size_t cpusetsize, cpu_set_t *mask);
+
+__PTW32_DLLPORT int  __PTW32_CDECL sched_getaffinity (pid_t pid, size_t cpusetsize, cpu_set_t *mask);
+
+/*
+ * Support routines and macros for cpu_set_t
+ */
+__PTW32_DLLPORT int  __PTW32_CDECL _sched_affinitycpucount (const cpu_set_t *set);
+
+__PTW32_DLLPORT void  __PTW32_CDECL _sched_affinitycpuzero (cpu_set_t *pset);
+
+__PTW32_DLLPORT void  __PTW32_CDECL _sched_affinitycpuset (int cpu, cpu_set_t *pset);
+
+__PTW32_DLLPORT void  __PTW32_CDECL _sched_affinitycpuclr (int cpu, cpu_set_t *pset);
+
+__PTW32_DLLPORT int  __PTW32_CDECL _sched_affinitycpuisset (int cpu, const cpu_set_t *pset);
+
+__PTW32_DLLPORT void  __PTW32_CDECL _sched_affinitycpuand(cpu_set_t *pdestset, const cpu_set_t *psrcset1, const cpu_set_t *psrcset2);
+
+__PTW32_DLLPORT void  __PTW32_CDECL _sched_affinitycpuor(cpu_set_t *pdestset, const cpu_set_t *psrcset1, const cpu_set_t *psrcset2);
+
+__PTW32_DLLPORT void  __PTW32_CDECL _sched_affinitycpuxor(cpu_set_t *pdestset, const cpu_set_t *psrcset1, const cpu_set_t *psrcset2);
+
+__PTW32_DLLPORT int  __PTW32_CDECL _sched_affinitycpuequal (const cpu_set_t *pset1, const cpu_set_t *pset2);
+
+/* Note that this macro returns ENOTSUP rather than ENOSYS, as
+ * might be expected. However, returning ENOSYS should mean that
+ * sched_get_priority_{min,max} are not implemented as well as
+ * sched_rr_get_interval.  This is not the case, since we just
+ * don't support round-robin scheduling. Therefore I have chosen
+ * to return the same value as sched_setscheduler when SCHED_RR
+ * is passed to it.
+ *
+ * FIXME: POSIX requires this to be defined as a function; this
+ * macro implementation is permitted IN ADDITION to the function,
+ * but the macro alone is not POSIX compliant!  Worse still, it
+ * imposes a requirement on the caller, to ensure that both the
+ * declaration of errno, and the definition of ENOTSUP, are in
+ * scope at point of call, (which it may wish to do anyway, but
+ * POSIX imposes no such constraint)!
+ */
+#define sched_rr_get_interval(_pid, _interval) \
+  ( errno = ENOTSUP, (int) -1 )
+
+__PTW32_END_C_DECLS
+
+#undef __SCHED_H_SOURCED__
+#endif	/* !_SCHED_H */
diff --git a/src/include/pthread/semaphore.h b/src/include/pthread/semaphore.h
new file mode 100644
index 0000000..c6e9407
--- /dev/null
+++ b/src/include/pthread/semaphore.h
@@ -0,0 +1,169 @@
+/*
+ * Module: semaphore.h
+ *
+ * Purpose:
+ *	Semaphores aren't actually part of the PThreads standard.
+ *	They are defined by the POSIX Standard:
+ *
+ *		POSIX 1003.1b-1993	(POSIX.1b)
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads-win32 - POSIX Threads Library for Win32
+ *      Copyright(C) 1998 John E. Bossom
+ *      Copyright(C) 1999,2005 Pthreads-win32 contributors
+ * 
+ *      Contact Email: rpj@callisto.canberra.edu.au
+ * 
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *      http://sources.redhat.com/pthreads-win32/contributors.html
+ * 
+ *      This library is free software; you can redistribute it and/or
+ *      modify it under the terms of the GNU Lesser General Public
+ *      License as published by the Free Software Foundation; either
+ *      version 2 of the License, or (at your option) any later version.
+ * 
+ *      This library is distributed in the hope that it will be useful,
+ *      but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *      Lesser General Public License for more details.
+ * 
+ *      You should have received a copy of the GNU Lesser General Public
+ *      License along with this library in the file COPYING.LIB;
+ *      if not, write to the Free Software Foundation, Inc.,
+ *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+#if !defined( SEMAPHORE_H )
+#define SEMAPHORE_H
+
+#undef PTW32_SEMAPHORE_LEVEL
+
+#if defined(_POSIX_SOURCE)
+#define PTW32_SEMAPHORE_LEVEL 0
+/* Early POSIX */
+#endif
+
+#if defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 199309
+#undef PTW32_SEMAPHORE_LEVEL
+#define PTW32_SEMAPHORE_LEVEL 1
+/* Include 1b, 1c and 1d */
+#endif
+
+#if defined(INCLUDE_NP)
+#undef PTW32_SEMAPHORE_LEVEL
+#define PTW32_SEMAPHORE_LEVEL 2
+/* Include Non-Portable extensions */
+#endif
+
+#define PTW32_SEMAPHORE_LEVEL_MAX 3
+
+#if !defined(PTW32_SEMAPHORE_LEVEL)
+#define PTW32_SEMAPHORE_LEVEL PTW32_SEMAPHORE_LEVEL_MAX
+/* Include everything */
+#endif
+
+#if defined(__GNUC__) && ! defined (__declspec)
+# error Please upgrade your GNU compiler to one that supports __declspec.
+#endif
+
+/*
+ * When building the library, you should define PTW32_BUILD so that
+ * the variables/functions are exported correctly. When using the library,
+ * do NOT define PTW32_BUILD, and then the variables/functions will
+ * be imported correctly.
+ */
+#if !defined(PTW32_STATIC_LIB)
+#  if defined(PTW32_BUILD)
+#    define PTW32_DLLPORT __declspec (dllexport)
+#  else
+#    define PTW32_DLLPORT __declspec (dllimport)
+#  endif
+#else
+#  define PTW32_DLLPORT
+#endif
+
+/*
+ * This is a duplicate of what is in the autoconf config.h,
+ * which is only used when building the pthread-win32 libraries.
+ */
+
+#if !defined(PTW32_CONFIG_H)
+#  if defined(WINCE)
+#    define NEED_ERRNO
+#    define NEED_SEM
+#  endif
+#  if defined(__MINGW64__)
+#    define HAVE_STRUCT_TIMESPEC
+#    define HAVE_MODE_T
+#  elif defined(_UWIN) || defined(__MINGW32__)
+#    define HAVE_MODE_T
+#  endif
+#endif
+
+/*
+ *
+ */
+
+#if PTW32_SEMAPHORE_LEVEL >= PTW32_SEMAPHORE_LEVEL_MAX
+#if defined(NEED_ERRNO)
+#include "need_errno.h"
+#else
+#include <errno.h>
+#endif
+#endif /* PTW32_SEMAPHORE_LEVEL >= PTW32_SEMAPHORE_LEVEL_MAX */
+
+#define _POSIX_SEMAPHORES
+
+#if defined(__cplusplus)
+extern "C"
+{
+#endif				/* __cplusplus */
+
+#if !defined(HAVE_MODE_T)
+typedef unsigned int mode_t;
+#endif
+
+
+typedef struct sem_t_ * sem_t;
+
+PTW32_DLLPORT int __cdecl sem_init (sem_t * sem,
+			    int pshared,
+			    unsigned int value);
+
+PTW32_DLLPORT int __cdecl sem_destroy (sem_t * sem);
+
+PTW32_DLLPORT int __cdecl sem_trywait (sem_t * sem);
+
+PTW32_DLLPORT int __cdecl sem_wait (sem_t * sem);
+
+PTW32_DLLPORT int __cdecl sem_timedwait (sem_t * sem,
+				 const struct timespec * abstime);
+
+PTW32_DLLPORT int __cdecl sem_post (sem_t * sem);
+
+PTW32_DLLPORT int __cdecl sem_post_multiple (sem_t * sem,
+				     int count);
+
+PTW32_DLLPORT int __cdecl sem_open (const char * name,
+			    int oflag,
+			    mode_t mode,
+			    unsigned int value);
+
+PTW32_DLLPORT int __cdecl sem_close (sem_t * sem);
+
+PTW32_DLLPORT int __cdecl sem_unlink (const char * name);
+
+PTW32_DLLPORT int __cdecl sem_getvalue (sem_t * sem,
+				int * sval);
+
+#if defined(__cplusplus)
+}				/* End of extern "C" */
+#endif				/* __cplusplus */
+
+#undef PTW32_SEMAPHORE_LEVEL
+#undef PTW32_SEMAPHORE_LEVEL_MAX
+
+#endif				/* !SEMAPHORE_H */
diff --git a/src/include/pthread/tests/Bmakefile b/src/include/pthread/tests/Bmakefile
new file mode 100644
index 0000000..a386861
--- /dev/null
+++ b/src/include/pthread/tests/Bmakefile
@@ -0,0 +1,368 @@
+# Makefile for the pthreads test suite.
+# If all of the .pass files can be created, the test suite has passed.
+#
+# --------------------------------------------------------------------------
+#
+#      Pthreads-win32 - POSIX Threads Library for Win32
+#      Copyright(C) 1998 John E. Bossom
+#      Copyright(C) 1999,2012 Pthreads-win32 contributors
+# 
+#      Contact Email: rpj@callisto.canberra.edu.au
+# 
+#      The current list of contributors is contained
+#      in the file CONTRIBUTORS included with the source
+#      code distribution. The list can also be seen at the
+#      following World Wide Web location:
+#      https://sourceforge.net/projects/pthreads4w/contributors.html
+# 
+#      This library is free software; you can redistribute it and/or
+#      modify it under the terms of the GNU Lesser General Public
+#      License as published by the Free Software Foundation; either
+#      version 2 of the License, or (at your option) any later version.
+# 
+#      This library is distributed in the hope that it will be useful,
+#      but WITHOUT ANY WARRANTY; without even the implied warranty of
+#      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#      Lesser General Public License for more details.
+# 
+#      You should have received a copy of the GNU Lesser General Public
+#      License along with this library in the file COPYING.LIB;
+#      if not, write to the Free Software Foundation, Inc.,
+#      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+#
+
+PTW32_VER	= 3
+
+CP	= copy
+RM	= erase
+CAT	= type
+MKDIR	= mkdir
+TOUCH	= echo Passed >
+ECHO	= @echo
+
+# The next path is relative to $BUILD_DIR
+QAPC	= # ..\QueueUserAPCEx\User\quserex.dll
+
+CPHDR	= pthread.h semaphore.h sched.h
+
+OPTIM	= -O2
+
+XXLIBS	= cw32mti.lib ws2_32.lib
+
+# C++ Exceptions
+BCEFLAGS	= -P -D__PtW32NoCatchWarn -D__PTW32_CLEANUP_CXX
+BCELIB	= pthreadBCE$(PTW32_VER).lib
+BCEDLL	= pthreadBCE$(PTW32_VER).dll
+# C cleanup code
+BCFLAGS	= -D__PTW32_CLEANUP_C
+BCLIB	= pthreadBC$(PTW32_VER).lib
+BCDLL	= pthreadBC$(PTW32_VER).dll
+# C++ Exceptions in application - using VC version of pthreads dll
+BCXFLAGS	= -D__PTW32_CLEANUP_C
+
+# Defaults
+CPLIB	= $(BCLIB)
+CPDLL	= $(BCDLL)
+
+CFLAGS= -q $(OPTIM) -w -tWC -tWM -4 -w-aus -w-asc -w-par
+LFLAGS= 
+INCLUDES=-I.
+BUILD_DIR=..
+
+COPYFILES	= $(CPHDR) $(CPLIB) $(CPDLL) $(QAPC)
+
+EHFLAGS	=
+
+# If a test case returns a non-zero exit code to the shell, make will
+# stop.
+
+PASSES=   \
+	  errno1.pass  \
+	  self1.pass  mutex5.pass  \
+	  mutex1.pass  mutex1n.pass  mutex1e.pass  mutex1r.pass  \
+	  semaphore1.pass  semaphore2.pass  semaphore3.pass  \
+	  mutex2.pass  mutex3.pass  \
+	  mutex2r.pass  mutex2e.pass  mutex3r.pass  mutex3e.pass  \
+	  condvar1.pass  condvar1_1.pass  condvar1_2.pass  condvar2.pass  condvar2_1.pass  \
+	  exit1.pass  create1.pass  create2.pass  reuse1.pass  reuse2.pass  equal1.pass  \
+	  sequence1.pass  kill1.pass  valid1.pass  valid2.pass  \
+	  exit2.pass  exit3.pass  exit4.pass  exit5.pass  \
+	  join0.pass  join1.pass  detach1.pass  join2.pass join3.pass join4.pass  \
+	  mutex4.pass  mutex6.pass  mutex6n.pass  mutex6e.pass  mutex6r.pass  \
+	  mutex6s.pass  mutex6es.pass  mutex6rs.pass  \
+	  mutex7.pass  mutex7n.pass  mutex7e.pass  mutex7r.pass  \
+	  mutex8.pass  mutex8n.pass  mutex8e.pass  mutex8r.pass  \
+	  robust1.pass  robust2.pass  robust3.pass  robust4.pass  robust5.pass  \
+	  count1.pass  \
+	  once1.pass  once2.pass  once3.pass  once4.pass  \
+	  self2.pass  \
+	  cancel1.pass  cancel2.pass  \
+	  semaphore4.pass  semaphore4t.pass  semaphore5.pass  \
+	  barrier1.pass  barrier2.pass  barrier3.pass  barrier4.pass  barrier5.pass barrier6.pass \
+	  tsd1.pass  tsd2.pass  delay1.pass  delay2.pass  eyal1.pass  \
+	  condvar3.pass  condvar3_1.pass  condvar3_2.pass  condvar3_3.pass  \
+	  condvar4.pass  condvar5.pass  condvar6.pass  \
+	  condvar7.pass  condvar8.pass  condvar9.pass  \
+	  rwlock1.pass  rwlock2.pass  rwlock3.pass  rwlock4.pass  \
+	  rwlock5.pass  rwlock6.pass  rwlock7.pass  rwlock8.pass  \
+	  rwlock2_t.pass  rwlock3_t.pass  rwlock4_t.pass  rwlock5_t.pass  rwlock6_t.pass  rwlock6_t2.pass  \
+	  context1.pass  \
+	  cancel3.pass  cancel4.pass  cancel5.pass  cancel6a.pass  cancel6d.pass  \
+	  cancel7.pass  cancel8.pass  \
+	  cleanup0.pass  cleanup1.pass  cleanup2.pass  cleanup3.pass  \
+	  priority1.pass priority2.pass inherit1.pass  \
+	  spin1.pass  spin2.pass  spin3.pass  spin4.pass  \
+	  exception1.pass  exception2.pass  exception3_0.pass  exception3.pass  \
+	  cancel9.pass  \
+	  affinity1.pass  affinity2.pass  affinity3.pass  affinity4.pass  affinity5.pass  \
+	  stress1.pass
+
+BENCHRESULTS = \
+	  benchtest1.bench benchtest2.bench benchtest3.bench benchtest4.bench benchtest5.bench
+
+help:
+	@ $(ECHO) Run one of the following command lines:
+	@ $(ECHO) make clean BC    (to test using BC dll with VC (no EH) applications)
+	@ $(ECHO) make clean BCX   (to test using BC dll with VC++ (EH) applications)
+	@ $(ECHO) make clean BCE   (to test using the BCE dll with VC++ EH applications)
+	@ $(ECHO) make clean BC-bench    (to benchtest using BC dll with C bench app)
+	@ $(ECHO) make clean BCX-bench   (to benchtest using BC dll with C++ bench app)
+	@ $(ECHO) make clean BCE-bench   (to benchtest using BCE dll with C++ bench app)
+
+all:
+	@ make clean BC
+	@ make clean BCX
+	@ make clean BCE
+	@ make clean BC-bench
+
+# This allows an individual test application to be made using the default lib.
+# e.g. make clean test cancel3.exe
+test: $(CPLIB) $(CPDLL) $(CPHDR) $(QAPC)
+
+tests: $(CPLIB) $(CPDLL) $(CPHDR) $(QAPC) sizes.pass $(PASSES)
+	@ $(ECHO) ALL TESTS PASSED! Congratulations!
+
+benchtests: $(CPLIB) $(CPDLL) $(CPHDR) $(BENCHRESULTS)
+	@ $(ECHO) ALL BENCH TESTS DONE.
+
+sizes.pass: sizes.exe
+	@ $(ECHO) ... Running $(TEST) test: $*.exe
+	@ .\$*.exe > SIZES.$(TEST)
+	@ $(CAT) SIZES.$(TEST)
+	@ $(ECHO) ...... Passed
+	@ $(TOUCH) $*.pass
+
+BCE:
+	@ make -f Bmakefile TEST="$@" CPLIB="$(BCELIB)" CPDLL="$(BCEDLL)" EHFLAGS="$(BCEFLAGS)" tests
+
+BC:
+	@ make -f Bmakefile TEST="$@" CPLIB="$(BCLIB)" CPDLL="$(BCDLL)" EHFLAGS="$(BCFLAGS)" tests
+
+BCX:
+	@ make -f Bmakefile TEST="$@" CPLIB="$(BCLIB)" CPDLL="$(BCDLL)" EHFLAGS="$(BCXFLAGS)" tests
+
+BCE-bench:
+	@ make -f Bmakefile TEST="$@" CPLIB="$(BCELIB)" CPDLL="$(BCEDLL)" EHFLAGS="$(BCEFLAGS)" XXLIBS="benchlib.o" benchtests
+
+BC-bench:
+	@ make -f Bmakefile TEST="$@" CPLIB="$(BCLIB)" CPDLL="$(BCDLL)" EHFLAGS="$(BCFLAGS)" XXLIBS="benchlib.o" benchtests
+
+BCX-bench:
+	@ make -f Bmakefile TEST="$@" CPLIB="$(BCLIB)" CPDLL="$(BCDLL)" EHFLAGS="$(BCXFLAGS)" XXLIBS="benchlib.o" benchtests
+
+.exe.pass:
+	@ $(ECHO) ... Running $(TEST) test: $<
+	@ .\$<
+	@ $(ECHO) ...... Passed
+	@ $(TOUCH) $@
+
+.exe.bench:
+	@ $(ECHO) ... Running $(TEST) benchtest: $<
+	@ .\$<
+	@ $(ECHO) ...... Done
+	@ $(TOUCH) $@
+
+.c.exe:
+	@ $(ECHO) $(CC) $(EHFLAGS) $(CFLAGS) $(INCLUDES) $< -e$@ $(LFLAGS) $(CPLIB) $(XXLIBS)
+	@ $(CC) $(EHFLAGS) $(CFLAGS) $(INCLUDES) $< -e$@ $(LFLAGS) $(CPLIB) $(XXLIBS)
+
+.c.o:
+	@ $(ECHO) $(CC) $(EHFLAGS) -c $(CFLAGS) $(INCLUDES) $< -o$@
+	@ $(CC) $(EHFLAGS) $(CFLAGS) -c $(INCLUDES) $< -o$@
+
+
+.c.i:
+	@ $(CC) /P $(EHFLAGS) $(CFLAGS) $(INCLUDES) $<
+
+$(COPYFILES):
+	@ $(ECHO) Copying $(BUILD_DIR)\$@
+	@ $(CP) $(BUILD_DIR)\$@ .
+
+pthread.dll: $(CPDLL)
+	@ $(CP) $(CPDLL) pthread.dll
+	@ $(CP) $(CPLIB) pthread.lib
+
+clean:
+	- $(RM) *.dll
+	- $(RM) *.lib
+	- $(RM) pthread.h
+	- $(RM) semaphore.h
+	- $(RM) sched.h
+	- $(RM) *.e
+	- $(RM) *.i
+	- $(RM) *.obj
+	- $(RM) *.tds
+	- $(RM) *.pdb
+	- $(RM) *.o
+	- $(RM) *.asm
+	- $(RM) *.exe
+	- $(RM) *.manifest
+	- $(RM) *.pass
+	- $(RM) *.bench
+	- $(RM) *.log
+
+benchtest1.bench:
+benchtest2.bench:
+benchtest3.bench:
+benchtest4.bench:
+benchtest5.bench:
+
+affinity1.pass:
+affinity2.pass: affinity1.pass
+affinity3.pass: affinity2.pass
+affinity4.pass: affinity3.pass
+affinity5.pass: affinity4.pass
+barrier1.pass: semaphore4.pass
+barrier2.pass: barrier1.pass
+barrier3.pass: barrier2.pass
+barrier4.pass: barrier3.pass
+barrier5.pass: barrier4.pass
+barrier6.pass: barrier5.pass
+cancel1.pass: create1.pass
+cancel2.pass: cancel1.pass
+cancel3.pass: context1.pass
+cancel4.pass: cancel3.pass
+cancel5.pass: cancel3.pass
+cancel6a.pass: cancel3.pass
+cancel6d.pass: cancel3.pass
+cancel7.pass: kill1.pass
+cancel8.pass: cancel7.pass
+cancel9.pass: cancel8.pass
+cleanup0.pass: cancel5.pass
+cleanup1.pass: cleanup0.pass
+cleanup2.pass: cleanup1.pass
+cleanup3.pass: cleanup2.pass
+condvar1.pass:
+condvar1_1.pass: condvar1.pass
+condvar1_2.pass: join2.pass
+condvar2.pass: condvar1.pass
+condvar2_1.pass: condvar2.pass join2.pass
+condvar3.pass: create1.pass condvar2.pass
+condvar3_1.pass: condvar3.pass join2.pass
+condvar3_2.pass: condvar3_1.pass
+condvar3_3.pass: condvar3_2.pass
+condvar4.pass: create1.pass
+condvar5.pass: condvar4.pass
+condvar6.pass: condvar5.pass
+condvar7.pass: condvar6.pass cleanup1.pass
+condvar8.pass: condvar7.pass
+condvar9.pass: condvar8.pass
+context1.pass: cancel1.pass
+count1.pass: join1.pass
+create1.pass: mutex2.pass
+create2.pass: create1.pass
+delay1.pass:
+delay2.pass: delay1.pass
+detach1.pass: join0.pass
+equal1.pass: create1.pass
+errno1.pass: mutex3.pass
+exception1.pass: cancel4.pass
+exception2.pass: exception1.pass
+exception3_0.pass: exception2.pass
+exception3.pass: exception3_0.pass
+exit1.pass:
+exit2.pass: create1.pass
+exit3.pass: create1.pass
+exit4.pass:
+exit5.pass: kill1.pass
+eyal1.pass: tsd1.pass
+inherit1.pass: join1.pass priority1.pass
+join0.pass: create1.pass
+join1.pass: create1.pass
+join2.pass: create1.pass
+join3.pass: join2.pass
+join4.pass: join3.pass
+kill1.pass: 
+mutex1.pass: self1.pass
+mutex1n.pass: mutex1.pass
+mutex1e.pass: mutex1.pass
+mutex1r.pass: mutex1.pass
+mutex2.pass: mutex1.pass
+mutex2r.pass: mutex2.pass
+mutex2e.pass: mutex2.pass
+mutex3.pass: create1.pass
+mutex3r.pass: mutex3.pass
+mutex3e.pass: mutex3.pass
+mutex4.pass: mutex3.pass
+mutex5.pass:
+mutex6.pass: mutex4.pass
+mutex6n.pass: mutex4.pass
+mutex6e.pass: mutex4.pass
+mutex6r.pass: mutex4.pass
+mutex6s.pass: mutex6.pass
+mutex6rs.pass: mutex6r.pass
+mutex6es.pass: mutex6e.pass
+mutex7.pass: mutex6.pass
+mutex7n.pass: mutex6n.pass
+mutex7e.pass: mutex6e.pass
+mutex7r.pass: mutex6r.pass
+mutex8.pass: mutex7.pass
+mutex8n.pass: mutex7n.pass
+mutex8e.pass: mutex7e.pass
+mutex8r.pass: mutex7r.pass
+once1.pass: create1.pass
+once2.pass: once1.pass
+once3.pass: once2.pass
+once4.pass: once3.pass
+priority1.pass: join1.pass
+priority2.pass: priority1.pass barrier3.pass
+reuse1.pass: create2.pass
+reuse2.pass: reuse1.pass
+robust1.pass: mutex8r.pass
+robust2.pass: mutex8r.pass
+robust3.pass: robust2.pass
+robust4.pass: robust3.pass
+robust5.pass: robust4.pass
+rwlock1.pass: condvar6.pass
+rwlock2.pass: rwlock1.pass
+rwlock3.pass: rwlock2.pass join2.pass
+rwlock4.pass: rwlock3.pass
+rwlock5.pass: rwlock4.pass
+rwlock6.pass: rwlock5.pass
+rwlock7.pass: rwlock6.pass
+rwlock8.pass: rwlock7.pass
+rwlock2_t.pass: rwlock2.pass
+rwlock3_t.pass: rwlock2_t.pass
+rwlock4_t.pass: rwlock3_t.pass
+rwlock5_t.pass: rwlock4_t.pass
+rwlock6_t.pass: rwlock5_t.pass
+rwlock6_t2.pass: rwlock6_t.pass
+self1.pass:
+self2.pass: create1.pass
+semaphore1.pass:
+semaphore2.pass:
+semaphore3.pass: semaphore2.pass
+semaphore4.pass: semaphore3.pass cancel1.pass
+semaphore4t.pass: semaphore4.pass
+semaphore5.pass: semaphore4.pass
+sequence1.pass: reuse2.pass
+sizes.pass:
+spin1.pass:
+spin2.pass: spin1.pass
+spin3.pass: spin2.pass
+spin4.pass: spin3.pass
+stress1.pass:
+tsd1.pass: barrier5.pass join1.pass
+tsd2.pass: tsd1.pass
+valid1.pass: join1.pass
+valid2.pass: valid1.pass
diff --git a/src/include/pthread/tests/ChangeLog b/src/include/pthread/tests/ChangeLog
new file mode 100644
index 0000000..c6c69cf
--- /dev/null
+++ b/src/include/pthread/tests/ChangeLog
@@ -0,0 +1,1348 @@
+2018-08-07  Ross Johnson <ross dot johnson at homemail dot com dot au>
+
+	* GNUmakefile.in (DLL_VER): rename as PTW32_VER.
+	* Makefile (DLL_VER): Likewise.
+	* Bmakefile (DLL_VER): Likewise; does anyone use this anymore?
+	* Makefile: Variable renaming: e.g. VCLIB to VCIMP for DLL import
+	library pthreadVC2.lib and VCLIB now holds static library name
+	libpthreadVC2.lib, and similar for the other cleanup method versions.
+
+2018-07-22  Mark Pizzolato <markpizzolato dash pthreads dash win32 at subscriptions dot pizzolato dot net>
+
+	* Makefile: Change the various static test runs to actually
+	compile with /MT or /MTd, i.e. No mixed /MT and /MD. Static
+	builds no longer create a separate pthreads*.lib static library
+	because errno does not work across that linkage.
+	* sequence1.c: Use more reasonable number of threads to avoid
+	resource limits.
+
+2016-12-25  Ross Johnson <ross dot johnson at homemail dot com dot au>
+
+	* Change all license notices to the Apache License 2.0
+
+2016-12-21  Ross Johnson <ross dot johnson at homemail dot com dot au>
+
+	* mutex6.c: fix random failures by using a polling loop to replace
+	a single Sleep().
+	* mutex6n.c: Likewise.
+	* mutex6s.c: Likewise.
+	* mutex7.c: Likewise.
+	* mutex7n.c: Likewise.
+	* mutex8.c: Likewise
+	* mutex8n.c: Likewise.
+	* semaphore5.c: don't fail on expected sem_destroy EBUSY.
+
+2016-12-20  Ross Johnson <ross dot johnson at homemail dot com dot au>
+
+	* all (PTW32_*): rename to __PTW32_*.
+	(ptw32_*): rename to __ptw32_*.
+	(PtW32*): rename to __PtW32*.
+	* GNUmakefile: removed; must now configure from GNUmakefile.in.
+
+2016-12-18  Ross Johnson <ross dot johnson at homemail dot com dot au>
+
+	* test.c  (__PTW32_TEST_SNEAK_PEEK): #define this to prevent some
+	tests from failing (specifically "make GCX-small-static") with
+	undefined __ptw32_autostatic_anchor. Checked in ../implement.h.
+	* GNUMakfile.in: Rename testsuite log to test-specific name and
+	do not remove.
+	* GNUMakfile.in: Add realclean target
+
+2016-04-30  Ross Johnson <ross dot johnson at homemail dot com dot au>
+
+	* semaphore4t.c: No longer need to include ptw32_timespec.c and the
+	defines that tried to make it work (but failed). There is now an
+	exported routine that this test uses that can also be used by
+	applications. It's a general routine that keeps all the platform
+	conditional stuff inside the library.
+	* Makefile: Remove _ptw32.h copied from parent directory.
+
+2016-03-31  Ross Johnson <ross dot johnson at homemail dot com dot au>
+
+	* Makefile (_ptw32.h): Copy header to tests directory required to
+	build tests, and apps.
+
+2016-03-31  Ross Johnson <ross dot johnson at homemail dot com dot au>
+
+	* test.h: source errno.h
+
+2016-03-31  Keith Marshall <MinGW32 project>
+
+	* test.h: Patch for MinGW32 autoconf.
+	* GNUmakefile.in: New for autoconf.
+
+2016-03-28  Ross Johnson <ross dot johnson at homemail dot com dot au>
+
+	* condvar2.c: Use platform-aware pthread_win32_getabstime_np.
+	* condvar2_1.c: Likewise.
+	* condvar3.c: Likewise.
+	* condvar3_1.c: Likewise.
+	* condvar3_2.c: Likewise.
+	* condvar3_3.c: Likewise.
+	* condvar4.c: Likewise.
+	* condvar5.c: Likewise.
+	* condvar6.c: Likewise.
+	* condvar7.c: Likewise.
+	* condvar8.c: Likewise.
+	* condvar9.c: Likewise.
+	* join4.c: Likewise.
+	* mutex8.c: Likewise.
+	* mutex8e.c: Likewise.
+	* mutex8n.c: Likewise.
+	* mutex8r.c: Likewise.
+	* reinit1.c: Likewise.
+	* rwlock2_t.c: Likewise.
+	* rwlock3_t.c: Likewise.
+	* rwlock4_t.c: Likewise.
+	* rwlock5_t.c: Likewise.
+	* rwlock6_t.c: Likewise.
+	* rwlock6_t2.c: Likewise.
+	* semaphore4t.c: Likewise.
+	* stress1.c: Likewise.
+	* reinit1.c: Remove unused variable declarations.
+
+2015-11-01	Mark Smith <masmith at fb dot com>
+
+	* semaphore4t.c: Enhanced and additional testing of sub-millisecond
+	timeouts.
+
+2014-07-22  Scott Libert  <scott underscore libert at dell dot com>
+
+	* semaphore3.c: Wait for threads to complete before exiting main().
+	This test would sometimes fail because, behaviourally, it was not
+	standard-compliant.
+
+2013-12-10  Ross Johnson <ross dot johnson at homemail dot com dot au>
+
+	* cancel9.c (bytes, dwEvent): Removed to eliminate warning "set but
+	not used".
+
+2013-11-13  Ross Johnson <ross dot johnson at homemail dot com dot au>
+
+	* reinit1.c: New test - reinitialising the library.
+	* common.mk: Add new test.
+	* reorder.mk: Likewise.
+
+2013-07-23  Ross Johnson <ross dot johnson at homemail dot com dot au>
+
+	* affinity*.c: Skipped under WINCE.
+
+2013-07-02  Ross Johnson <ross dot johnson at homemail dot com dot au>
+
+	* threestage.c: New test/example code; not written specifically as
+	a test; independently written and essentially unmodified pthreads
+	example.
+
+2013-06-19  Ross Johnson <ross dot johnson at homemail dot com dot au>
+
+	* exit6.c: New test (added some time ago but not committed).
+	* name_np1.c: New test for pthread_[sg]etname_np().
+	* name_np2.c: New test for pthread_attr_[sg]etname_np().
+	* common.mk: Add new tests.
+	* reorder.mk: Likewise.
+
+2013-06-06  Ross Johnson <ross dot johnson at homemail dot com dot au>
+
+	* affinity6.c: New test for pthread_attr_[gs]etaffinity_np()
+	* common.mk: Add new tests.
+	* reorder.mk: Likewise.
+
+2012-10-24  Ross Johnson <ross dot johnson at homemail dot com dot au>
+
+	* tsd3.c: New regression test for Stephane Clairet bug fix/report;
+	this test confirms that keys are deleted correctly prior to threads
+	exiting.
+	* tsd2.c: Modified comments and indentation.
+	* tsd1.c: Likewise.
+	* common.mk (tsd3): New test added.
+	* reorder.mk (tsd3): Likewise.
+
+2012-10-16  Ross Johnson <ross dot johnson at homemail dot com dot au>
+
+	* GNUmakefile (EXTRAVERSION): Naming option for libraries to be
+	consistent with MSVS Makefile; no longer automatically based on
+	ARCH setting.
+
+2012-10-10  Ross Johnson <ross dot johnson at homemail dot com dot au>
+
+	* cancel1.c: Fix comment typo.
+	* Makefile: Adding functionality to support rapid turnaround of
+	individual or small sets of tests; removed loadfree test.
+	* GNUmakefile: Likewise.
+	* Bmakefile: Removed loadfree test.
+	* Wmakefile: Likewise.
+	* common.mk: New makefile include file; split out common macros.
+	* runorder.mk: New makefile include file; split out run order rules
+	to allow selective inclusion.
+	* loadfree.c: Removed from suite; not required; unnecessarily
+	complicates the makefiles.
+
+2012-10-04  Ross Johnson <ross dot johnson at homemail dot com dot au>
+
+	* join4.c: Modified for pthread_tryjoin_np tests.
+
+2012-09-29  Ross Johnson <ross dot johnson at homemail dot com dot au>
+
+	* Makefile: Align target names with build makefile target names
+	following changes there; remove the separate static tests list.
+	* GNUmakefile: Likewise; consolidate rules.
+
+2012-09-25  Ross Johnson <ross dot johnson at homemail dot com dot au>
+
+	* context1.c (anotherEnding): Should exit the thread, not return.
+
+2012-09-23  Ross Johnson <ross dot johnson at homemail dot com dot au>
+
+	* Makefile: Add secondary target names to existing test targets so
+	we can output how the library was built, e.g. "Running VC-inlined test".
+	This is useful when making "all-tests" from the library build Makefile.
+	* GNUmakefile: Similarly.
+
+2012-09-22  Ross Johnson <ross dot johnson at homemail dot com dot au>
+
+	* GNUmakefile: Do what Makefile does and print the make target
+	when running each test.
+
+2012-09-22  Daniel Richard. G <danielg at teragram dot com>
+
+	* Makefile: This reverts an earlier change of mine. In some
+	versions of nmake, $(MAKE) is a full path, which utterly futzes
+	up the "make help" output; regularized the test targets, so we
+	have e.g. VSE-static now; regularized the parentheticals;
+	removed a spurious use of $(DLL_VER); new test targets: VCX-debug
+	{VSE,VCX}-static{,-debug}; fixed the {VC,VCE}-static-debug targets.
+	* exception3.c: Narrowly exclude this test from the known-bad VS2005
+	configuration (By the way: I downloaded and tested with what is
+	presumably the most up-to-date MSVCR80.DLL. Same deal.); use
+	pthread_win32_set_terminate_np() when appropriate, and verify that
+	it has an effect different from calling set_terminate(); no need for
+	that assert(); it's overly pedantic.
+	* exception3_0.c: Same VS2005 exclusion.
+	* once3.c: Put in a note so that users know what to do if the test
+	hangs or exits abnormally (I figured this is better than narrowly
+	disabling pthread_cancel() on MSVC6, since cancellation does seem to
+	work correctly with /EHa, and we don't have any way of telling at
+	compile time whether /EHs or /EHa is in use).
+	* once4.c: Likewise.
+	* semaphore1.c: s/PTW32_BROKEN_ERRNO/PTW32_USES_SEPARATE_CRT/
+
+2012-09-22  Ross Johnson <ross dot johnson at homemail dot com dot au>
+
+	* pthread_win32_attach_detach_np.c (pthread_win32_detach_thread_np):
+	Check for NULL __ptw32_selfThreadKey before call to TlsSetKey(). Need
+	to find where this is being set to NULL before this point. Was
+	consistently failing tests/seamphore3.c in all GC static builds and
+	never seen in GC DLL builds. May also be responsible for
+	inconsistent VCE fails on that test, although the fail mode was
+	different - the latter hangs the test while the former segfaults.
+
+2012-09-22  Ross Johnson <ross dot johnson at homemail dot com dot au>
+
+	* GNUmakefile (GC-static-debug): New make target.
+
+2012-09-21  Ross Johnson <ross dot johnson at homemail dot com dot au>
+
+	* affinity1.c: New test for new process CPU affinity routines.
+	* affinity2.c: New test for new process CPU affinity routines.
+	* affinity3.c: New test for new process and thread CPU affinity routines.
+	* affinity4.c: New test for new process and thread CPU affinity routines.
+	* affinity5.c: New test for new process and thread CPU affinity routines.
+	* Makefile: Add new tests.
+	* GNUmakfile: Likewise.
+	* Bmakfile: Likewise.
+	* Wmakfile: Likewise.
+
+2012-09-09  Ross Johnson <ross dot johnson at homemail dot com dot au>
+
+	* exception3.c: Rewrite to fix strategy.
+	* exception3_0.c: New test.
+	* exception2.c: Reduce sleep time to speed up test.
+	* Makefile (exception3_0.*): Add new test.
+	* GNUmakefile (exception3_0.*): Add new test.
+	* Bmakefile (exception3_0.*): Add new test.
+	* Wmakefile (exception3_0.*): Add new test.
+
+2012-09-05  Daniel Richard. G <danielg at teragram dot com>
+
+	* exception2.c: Fix result codes to avoid false negative failures.
+	* cancel9.c: cosmetic change.
+	* GNUmakefile (clean): delete manifest files.
+	* Bmakefile: Likewise.
+	* Wmakefile: Likewise.
+	* Makefile: Likewise.
+
+2012-09-04  Ross Johnson <ross dot johnson at homemail dot com dot au>
+
+	* Makefile (VCEFLAGS): Changed from /EHsc to /EHs which was causing
+	tests/once3.c to hang, suspect exceptions not being thrown from
+	extern C routines.
+	* cancel2.c: Rewrite to use a barrier for thread control; remove
+	asyncronous cancel type which was a massive bug in the test strategy
+	and cusing SEGFAULTs (access violations).
+	* eyal1.c: Remove unused variable 'i' to clear compiler warning.
+	* context1.c: Remove call to pthread_exit() in alternate ending to
+	quell error in GCE tests see when running x86 build on x64.
+
+2012-09-03  Ross Johnson <ross dot johnson at homemail dot com dot au>
+
+	* Makefile (VCE-static): Add VC++ static build target
+	(VCE-static-debug): Likewise.
+
+2012-08-29  Daniel Richard. G <danielg at teragram dot com>
+
+	* mutex6.c: Removed pointless exit(0) and never-reached comment.
+	* mutex6r.c: Likewise.
+	* mutex6rs.c: Likewise.
+	* mutex6s.c: Likewise.
+	* mutex6e.c: Likewise.
+	* mutex6es.c: Likewise.
+	* mutex7.c: Likewise.
+	* mutex7e.c: Likewise.
+	* mutex7n.c: Likewise.
+	* mutex7r.c: Likewise.
+	* mutex6n.c: Likewise; ensure operator precedence.
+	* once2.c (sharedInt_t): replace static initialization of struct with memset.
+	* once3.c: Likewise.
+	* once4.c: Likewise.
+	* cleanup0.c: Likewise.
+	* cleanup1.c: Likewise.
+	* cleanup2.c: Likewise.
+	* cleanup3.c: Likewise.
+	* openmp1.c: Fix casts.
+	* exit1.c: Remove assert statement that is never reached and return 1.
+	* exception2.c: Prevent displaying modal error dialog.
+
+2012-08-19  Ross Johnson <ross dot johnson at homemail dot com dot au>
+
+	* join4.c: Test for new pthread_timedjoin_np routine
+	* Makefile (join4): Added.
+	* GNUmakefile (join4): Added.
+	* Bmakefile (join4): Added.
+	* Wmakefile (join4): Added.
+	* test.h (sys/timeb.h): Add #include.
+	* mutex8.c (sys/timeb.h): Remove #include.
+	* mutex8e.c (sys/timeb.h): Remove #include.
+	* mutex8n.c (sys/timeb.h): Remove #include.
+	* mutex8r.c (sys/timeb.h): Remove #include.
+	* benchtest1.c (sys/timeb.h): Remove #include.
+	* benchtest2.c (sys/timeb.h): Remove #include.
+	* benchtest3.c (sys/timeb.h): Remove #include.
+	* benchtest4.c (sys/timeb.h): Remove #include.
+	* benchtest5.c (sys/timeb.h): Remove #include.
+
+2012-08-11  Daniel Richard. G <danielg at teragram dot com>
+
+	* Makefile: Various improvements.
+	* GNUmakefile: Likewise.
+
+2011-07-20  Ross Johnson <ross dot johnson at homemail dot com dot au>
+
+	* cancel2.c (PTHREAD_CANCELED): Fix cast warning when compiling with g++.
+	* cleanup0.c (PTHREAD_CANCELED): Likewise.
+	* cleanup1.c (PTHREAD_CANCELED): Likewise.
+
+2012-07-19  Daniel Richard. G <danielg at teragram dot com>
+
+	* Makefile: Various fixes.
+	* GNUmakefile: Likewise.
+
+2011-07-03  Ross Johnson <ross dot johnson at homemail dot com dot au>
+
+	* create3.c: Removed; testing a condition that is not in the library's
+	scope and was more trouble than it was worth.
+	* cancel2.c: Ensure this test only runs for Structured or C++ EH.
+	* exit2.c: Shorten Sleep() time.
+	* exit3.c: Likewise.
+	* cancel1.c: Likewise.
+	* cancel3.c: Likewise.
+	* exception3.c: Likewise; make terminate routine consistent for all
+	build environments.
+
+2011-07-02  Ross Johnson <ross dot johnson at homemail dot com dot au>
+
+	* spin3.c: Unlock the unlocked spinlock now returns success.
+	* rwlock3.c: Join the thread to ensure it's completed.
+	* rwlock4.c: Likewise.
+	* rwlock5.c: Likewise.
+	* Makefile: Adjust prerequisites.
+	* GNUmakefile: Likewise.
+	* Bmakefile: Likewise.
+	* Wmakefile: Likewise.
+
+2011-07-02 Daniel Richard G. <skunk at iskunk dot org>
+
+	* *.[ch]: Cleanups around timeb struct, mainly centralising
+	macro definitions in test.h.
+	* Makefile: Fix annoying nmake warning.
+
+2011-06-30  Ross Johnson <ross.johnson at homemail.com.au>
+
+	* sequence1.c: Fix loop overrun.
+
+2011-05-11  Ross Johnson <ross.johnson at homemail.com.au>
+
+	* GNUmakefile (GCE-debug): New target; expects pthreadGCE2d.dll.
+	
+2011-05-05  Ross Johnson <ross.johnson at homemail.com.au>
+
+	* openmp1.c: Add missing test; used to comfirm that this
+	library works with libgomp; if this test produces a segfault
+	then try upgrading your version of libgomp/gcc; gcc version
+	4.5.2 passes this test.
+
+2011-03-26  Ross Johnson <ross.johnson at homemail.com.au>
+
+	* sequence1.c: New test for new pthread_getsequence_np().
+
+2011-03-24  Ross Johnson <ross.johnson at homemail.com.au>
+
+	* mutex*.c: Include tests for robust mutexes wherever
+	appropriate.
+	* benchtest*.c: Include comparisons for robust mutexes.
+	* robust1.c: New test for robust mutex handling.
+	* robust2.c: Likewise.
+	* robust3.c: Likewise.
+	* robust4.c: Likewise.
+	* robust5.c: Likewise.
+	* GNUmakefile: Include new tests.
+	* Makefile: Likewise.
+	* Bmakefile: Likewise (not tested).
+	* Wmakefile: Likewise (not tested).
+
+2011-03-06  Ross Johnson <ross.johnson at homemail.com.au>
+
+	* several (MINGW64): Cast and call fixups for 64 bit compatibility;
+	clean build via x86_64-w64-mingw32 cross toolchain on Linux
+	i686 targeting x86_64 win64.
+
+2011-03-04  Ross Johnson <Ross dot Johnson at homemail dot com dot au>
+
+	* condvar3_2.c: abstime.tv_sec operation warning fixed.
+	* several: Use correct casting on pthread_join result arg
+	and associated declaration and usage; assumed that 64 bit
+	gcc gave some warnings for it.
+
+2011-02-28  Ross Johnson <Ross dot Johnson at homemail dot com dot au>
+
+	* test.h: Define FTIME to be _ftime64_s or _ftime64 or _ftime
+	in that order of preference where supported.
+	* several: Replace calls to _ftime with the FTIME macro.
+
+2010-06-19  Ross Johnson <Ross dot Johnson at homemail dot com dot au>
+
+	* Makefile (STATICRESULTS): Add all tests into suite for static
+	library.
+	* GNUmakefile (STATICTESTS): Likewise, except for openmp1.c which
+	has a DLL dependency.
+
+2010-02-04  Ross Johnson <Ross dot Johnson at homemail dot com dot au>
+
+	* openmp1.c: New; for libgomp compatibility (OpenMP).
+	* barrier5.c: Rewrite after changes to barriers.
+	* barrier6.c: New.
+	* benchtest6.c: New; timing barriers.
+	* GNUMakefile: Update for new tests.
+	* Makefile: Ditto.
+	* BMakefile: Ditto.
+	* once3.c: Improve cancellation testing.
+	* stress1.c: Fix comment.
+
+2007-01-04  Ross Johnson <Ross dot Johnson at homemail dot com dot au>
+
+        * context1.c: Include context.h from library sources and remove
+        x86 dependence in main().
+
+2005-06-12  Ross Johnson  <rpj@callisto.canberra.edu.au>
+
+	* stress1.c (millisecondsFromNow): Remove limit 0 <= millisecs < 1000;
+	now works for -INT_MAX <= millisecs <= INT_MAX; not needed for
+	stress1.c but should be general anyway.
+
+2005-05-18  Ross Johnson  <rpj@callisto.canberra.edu.au>
+
+	* reuse2.c (main): Must use a read with memory barrier semantics
+	when polling 'done' to force the cache into coherence on MP systems.
+
+2005-05-15  Ross Johnson  <rpj@callisto.canberra.edu.au>
+
+	* detach1.c: New test.
+	* join1.c: Reduce sleep times.
+	* join0.c: Remove MSVCRT conditional compile - join should always
+	return the thread exit code.
+	* join1.c: Likewise.
+	* join2.c: Likewise.
+	* join3.c: Likewise.
+
+2005-04-18  Ross Johnson  <rpj@callisto.canberra.edu.au>
+
+	* condvar3.c: Remove locks from around signalling calls - should not
+	be required for normal operation and only serve to mask deficiencies;
+	ensure that CV destruction is not premature after removing guards.
+	* condvar3_1.c: Likewise.
+	* condvar3_2.c: Likewise.
+	* condvar3_3.c: Likewise.
+	* condvar4.c: Likewise.
+	* condvar5.c: Likewise.
+	* condvar6.c: Likewise.
+	* condvar7.c: Likewise.
+	* condvar8.c: Likewise.
+	* condvar9.c: Likewise.
+
+2005-04-11  Ross Johnson  <rpj@callisto.canberra.edu.au>
+
+        * once4.c: New test; tries to test priority adjustments
+        in pthread_once(); set priority class to realtime so that
+        any failures can be seen.
+
+2005-04-06  Ross Johnson  <rpj@callisto.canberra.edu.au>
+
+	* cleanup0.c: Fix unguarded global variable accesses.
+	* cleanup1.c: Likewise.
+	* cleanup2.c: Likewise.
+	* cleanup3.c: Likewise.
+	* once2.c: Likewise.
+	* once3.c: Likewise.
+
+2005-04-01  Ross Johnson  <rpj@callisto.canberra.edu.au>
+
+	* GNUmakefile: Add target to test linking static link library.
+	* Makefile: Likewise.
+	* self1.c: Run process attach/detach routines when static linked.
+
+2005-03-16  Ross Johnson  <rpj@callisto.canberra.edu.au>
+
+	* mutex5.c: Prevent optimiser from removing asserts.
+
+2005-03-12  Ross Johnson  <rpj@callisto.canberra.edu.au>
+
+	* once3.c: New test.
+
+2005-03-08  Ross Johnson  <rpj@callisto.canberra.edu.au>
+
+        * once2.c: New test.
+
+2004-11-19  Ross Johnson  <rpj@callisto.canberra.edu.au>
+
+	* Bmakefile: New makefile for Borland.
+	* Makefile (DLL_VER): Added.
+	* GNUmakefile (DLL_VER): Added.
+	* Wmakefile (DLL_VER): Added.
+
+2004-10-29  Ross Johnson  <rpj@callisto.canberra.edu.au>
+
+	* semaphore4.c: New test.
+	* semaphore4t.c: New test.
+	* Debug.dsp (et al): Created MSVC Workspace project to aid debugging.
+	* All: Many tests have been modified to work with the new pthread
+	ID type; some other corrections were made after some library
+	functions were semantically strengthened. For example,
+	pthread_cond_destroy() no longer destroys a busy CV, which
+	required minor redesigns of some tests, including some where
+	the mutex associated with the CV was not locked during
+	signaling and broadcasting.
+
+2004-10-23  Ross Johnson  <rpj@callisto.canberra.edu.au>
+
+	* condvar3.c: Fixed mutex operations that were incorrectly
+	placed in relation to their condition variable operations.
+	The error became evident after sem_destroy() was rewritten
+	and conditions for destroing the semaphore were tightened.
+	As a result, pthread_cond_destroy() was not able to
+	destroy the cv queueing sempahore.
+	* condvar3_1.c: Likewise.
+	* condvar3_2.c: Likewise.
+	* condvar4.c: Likewise.
+	* condvar5.c: Likewise.
+	* condvar6.c: Likewise.
+	* condvar7.c: Likewise.
+	* condvar8.c: Likewise.
+	* condvar9.c: Likewise.
+
+2004-10-19  Ross Johnson  <rpj@callisto.canberra.edu.au>
+
+	* semaphore3.c: New test.
+
+2004-10-14  Ross Johnson  <rpj@callisto.canberra.edu.au>
+
+	* rwlock7.c (main): Tidy up statistics reporting; randomise
+	update accesses.
+	* rwlock8.c: New test.
+
+2004-09-08  Alexandre Girao  <alexgirao@gmail.com>
+
+	* cancel7.c (main): Win98 wants a valid (non-NULL) location
+	for the last arg of _beginthreadex().
+	* cancel8.c (main): Likewise.
+	* exit4.c (main): Likewise.
+	* exit5.c (main): Likewise.
+
+2004-08-26  Ross Johnson  <rpj@callisto.canberra.edu.au>
+
+	* create3.c: New test.
+
+2004-06-21  Ross Johnson  <rpj@callisto.canberra.edu.au>
+
+	* mutex2r.c: New test.
+	* mutex2e.c: New test.
+	* mutex3r.c: New test.
+	* mutex3e.c: New test.
+	* mutex6s.c: New test.
+	* mutex6rs.c: New test.
+	* mutex6es.c: New test.
+
+2004-05-21  Ross Johnson  <rpj@callisto.canberra.edu.au>
+
+	* join3.c: New test.
+
+2004-05-16  Ross Johnson  <rpj@callisto.canberra.edu.au>
+
+	* condvar2.c (WIN32_WINNT): Define to avoid redefinition warning
+	from inclusion of implement.h.
+	* convar2_1.c: Likewise.
+	* condvar3_1.c: Likewise.
+	* condvar3_2.c: Likewise.
+	* context1.c: Likewise.
+	* sizes.c: Likewise.
+	* Makefile: Don't define _WIN32_WINNT on compiler command line.
+	* GNUmakefile: Likewise.
+	* priority1.c (main): Add column to output for actual win32
+	priority.
+
+2004-05-16  Ross Johnson  <rpj@callisto.canberra.edu.au>
+
+	* cancel9.c: New test.
+	* cancel3.c: Remove inappropriate conditional compilation;
+	GNU C version of test suite no longer quietly skips this test.
+	* cancel5.c: Likewise.
+	* GNUmakefile: Can now build individual test app using default
+	C version of library using 'make clean testname.c'.
+	* Makefile: Likewise for VC using 'nmake clean test testname.c'.
+
+2003-10-14  Ross Johnson  <rpj@callisto.canberra.edu.au>
+
+	* Wmakefile: New makefile for Watcom testing.
+
+2003-09-18  Ross Johnson  <rpj@callisto.canberra.edu.au>
+
+	* benchtest.h: Move old mutex code into benchlib.c.
+	* benchlib.c: New statically linked module to ensure that
+	bench apps don't inline the code and therefore have an unfair
+	advantage over the pthreads lib routines. Made little or no
+	difference.
+	* benchtest1.c: Minor change to avoid compiler warnings.
+	* benchtest5.c: Likewise.
+	* benchtest2.c: Fix misinformation in output report.
+	* README.BENCH: Add comments on results.
+
+2003-09-14  Ross Johnson  <rpj@callisto.canberra.edu.au>
+
+	* priority1.c: Reworked to comply with modified priority
+	management and provide additional output.
+	* priority2.c: Likewise.
+	* inherit1.c: Likewise.
+
+2003-09-03  Ross Johnson  <rpj@callisto.canberra.edu.au>
+
+	* exit4.c: New test.
+	* exit5.c: New test.
+	* cancel7.c: New test.
+	* cancel8.c: New test.
+
+2003-08-13  Ross Johnson  <rpj@ise.canberra.edu.au>
+
+	* reuse1.c: New test.
+	* reuse1.c: New test.
+	* valid1.c: New test.
+	* valid2.c: New test.
+	* kill1.c: New test.
+ 	* create2.c: Now included in test regime.
+
+2003-07-19  Ross Johnson  <rpj@ise.canberra.edu.au>
+
+	* eyal1.c (waste_time): Make threads do more work to ensure that
+	all threads get to do some work.
+	* semaphore1.c: Make it clear that certain errors are expected.
+	* exception2.c (non_MSVC code sections): Change to include
+	C++ standard include file, i.e. change <new.h> to <exception>.
+	* exception3.c (non_MSVC code sections): Likewise; qualify std::
+	namespace entities where necessary.
+	* GNUmakefile: modified to work in the MsysDTK (newer MinGW)
+	environment; define CC as gcc or g++ as appropriate because
+	using gcc -x c++ doesn't link with required c++ libs by default,
+	but g++ does.
+
+2002-12-11  Ross Johnson  <ross@special.ise.canberra.edu.au>
+
+	* mutex7e.c: Assert EBUSY return instead of EDEADLK.
+
+2002-06-03  Ross Johnson  <rpj@digit.ise.canberra.edu.au>
+
+	* semaphore2.c: New test.
+
+2002-03-02  Ross Johnson  <rpj@special.ise.canberra.edu.au>
+
+	* Makefile (CFLAGS): Changed /MT to /MD to link with
+	the correct library MSVCRT.LIB. Otherwise errno doesn't
+	work.
+
+2002-02-28  Ross Johnson  <rpj@special.ise.canberra.edu.au>
+
+	* exception3.c: Correct recent change.
+
+	* semaphore1.c: New test.
+
+	* Makefile: Add rule to generate pre-processor output.
+
+2002-02-28  Ross Johnson  <rpj@special.ise.canberra.edu.au>
+
+	* exception3.c (terminateFunction): For MSVC++, call
+	exit() rather than pthread_exit(). Add comments to explain
+	why.
+	   * Notes from the MSVC++ manual:
+	   *       1) A term_func() should call exit(), otherwise
+	   *          abort() will be called on return to the caller.
+	   *          abort() raises SIGABRT. The default signal handler
+	   *          for all signals terminates the calling program with
+	   *          exit code 3.
+	   *       2) A term_func() must not throw an exception. Therefore
+	   *          term_func() should not call pthread_exit() if an
+	   *          an exception-using version of pthreads-win32 library
+	   *          is being used (i.e. either pthreadVCE or pthreadVSE).
+
+
+2002-02-23  Ross Johnson  <rpj@special.ise.canberra.edu.au>
+
+	* rwlock2_t.c: New test.
+	* rwlock3_t.c: New test.
+	* rwlock4_t.c: New test.
+	* rwlock5_t.c: New test.
+	* rwlock6_t.c: New test.
+	* rwlock6_t2.c: New test.
+	* rwlock6.c (main): Swap thread and result variables
+	to correspond to actual thread functions.
+	* rwlock1.c: Change test description comment to correspond
+	to the actual test.
+
+	* condvar1_2.c: Loop over the test many times in the hope
+	of detecting any intermittent deadlocks. This is to
+	test a fixed problem in pthread_cond_destroy.c.
+
+	* spin4.c: Remove unused variable.
+
+2002-02-17  Ross Johnson  <rpj@special.ise.canberra.edu.au>
+
+	* condvar1_1.c: New test.
+	* condvar1_2.c: New test.
+
+2002-02-07  Ross Johnson  <rpj@special.ise.canberra.edu.au>
+
+	* delay1.c: New test.
+	* delay2.c: New test.
+	* exit4.c: New test.
+
+2002-02-02  Ross Johnson  <rpj@special.ise.canberra.edu.au>
+
+	* mutex8: New test.
+	* mutex8n: New test.
+	* mutex8e: New test.
+	* mutex8r: New test.
+	* cancel6a: New test.
+	* cancel6d: New test.
+	* cleanup0.c: Add pragmas for inline optimisation control.
+	* cleanup1.c: Add pragmas for inline optimisation control.
+	* cleanup2.c: Add pragmas for inline optimisation control.
+	* cleanup3.c: Add pragmas for inline optimisation control.
+	* condvar7.c: Add pragmas for inline optimisation control.
+	* condvar8.c: Add pragmas for inline optimisation control.
+	* condvar9.c: Add pragmas for inline optimisation control.
+
+2002-01-30  Ross Johnson  <rpj@special.ise.canberra.edu.au>
+
+	* cleanup1.c (): Must be declared __cdecl when compiled
+	as C++ AND testing the standard C library version.
+
+2002-01-16  Ross Johnson  <rpj@special.ise.canberra.edu.au>
+
+	* spin4.c (main): Fix renamed function call.
+
+2002-01-14  Ross Johnson  <rpj@special.ise.canberra.edu.au>
+
+	* exception3.c (main): Shorten wait time.
+
+2002-01-09  Ross Johnson  <rpj@special.ise.canberra.edu.au>
+
+	* mutex7.c: New test.
+	* mutex7n.c: New test.
+	* mutex7e.c: New test.
+	* mutex7r.c: New test.
+	* mutex6.c: Modified to avoid leaving the locked mutex
+	around on exit.
+
+2001-10-25  Ross Johnson  <rpj@setup1.ise.canberra.edu.au>
+
+	* condvar2.c: Remove reference to cv->nWaitersUnblocked.
+	* condvar2_1.c: Likewise; lower NUMTHREADS from 60 to 30.
+	* condvar3_1.c: Likewise.
+	* condvar3_2.c: Likewise.
+	* count1.c: lower NUMTHREADS from 60 to 30.
+	* inherit1.c: Determine valid priority values and then
+	assert values returned by POSIX routines are the same.
+	* priority1.c: Likewise.
+	* priority2.c: Likewise.
+	
+2001-07-12  Ross Johnson  <rpj@setup1.ise.canberra.edu.au>
+
+	* barrier5.c: Assert that precisely one thread receives
+	PTHREAD_BARRIER_SERIAL_THREAD at each barrier.
+
+2001-07-09  Ross Johnson  <rpj@setup1.ise.canberra.edu.au>
+
+	* barrier3.c: Fixed.
+	* barrier4.c: Fixed.
+	* barrier5.c: New; proves that all threads in the group
+	reaching the barrier wait and then resume together. Repeats the test
+	using groups of 1 to 16 threads. Each group of threads must negotiate
+	a large number of barriers (10000).
+	* spin4.c: Fixed.
+	* test.h (error_string): Modified the success (0) value.
+
+2001-07-07  Ross Johnson  <rpj@setup1.ise.canberra.edu.au>
+
+	* spin3.c: Changed test and fixed.
+	* spin4.c: Fixed.
+	* barrier3.c: Fixed.
+	* barrier4.c: Fixed.
+
+2001-07-05  Ross Johnson  <rpj@special.ise.canberra.edu.au>
+
+	* spin1.c: New; testing spinlocks.
+	* spin2.c: New; testing spinlocks.
+	* spin3.c: New; testing spinlocks.
+	* spin4.c: New; testing spinlocks.
+	* barrier1.c: New; testing barriers.
+	* barrier2.c: New; testing barriers.
+	* barrier3.c: New; testing barriers.
+	* barrier4.c: New; testing barriers.
+	* GNUmakefile: Add new tests.
+	* Makefile: Add new tests.
+
+2001-07-01  Ross Johnson  <rpj@special.ise.canberra.edu.au>
+
+	* benchtest3.c: New; timing mutexes.
+	* benchtest4.c: New; time mutexes.
+	* condvar3_1.c: Fixed bug - Alexander Terekhov
+	* condvar3_3.c: New test.
+
+2001-06-25  Ross Johnson  <rpj@special.ise.canberra.edu.au>
+
+	* priority1.c: New test.
+	* priority2.c: New test.
+	* inherit1.c: New test.
+	* benchtest1.c: New; timing mutexes.
+	* benchtest2.c: New; timing mutexes.
+	* mutex4.c: Modified to test all mutex types.
+
+2001-06-8  Ross Johnson  <rpj@special.ise.canberra.edu.au>
+
+	* mutex5.c: Insert inert change to quell compiler warnings.
+	* condvar3_2.c: Remove unused variable.
+	
+2001-06-3  Ross Johnson  <rpj@special.ise.canberra.edu.au>
+
+	* condvar2_1.c: New test.
+	* condvar3_1.c: New test.
+	* condvar3_2.c: New test.
+
+2001-05-30  Ross Johnson  <rpj@special.ise.canberra.edu.au>
+
+	* mutex1n.c: New test.
+	* mutex1e.c: New test.
+	* mutex1r.c: New test.
+	* mutex4.c: Now locks and unlocks a mutex.
+	* mutex5.c: New test.
+	* mutex6.c: New test.
+	* mutex6n.c: New test.
+	* mutex6e.c: New test.
+	* mutex6r.c: New test.
+	* Makefile: Added new tests; reorganised.
+	* GNUmakefile: Likewise.
+	* rwlock6.c: Fix to properly prove read-while-write locking
+	and single writer locking.
+
+2001-05-29  Ross Johnson  <rpj@special.ise.canberra.edu.au>
+
+	* Makefile: Reorganisation.
+	* GNUmakefile: Likewise.
+	- Thomas Pfaff <tpfaff@gmx.net>
+
+	* exception1.c: Add stdio.h include to define fprintf and stderr
+	in non-exception C version of main().
+	* exception2.c: Likewise.
+	* exception3.c: Likewise.
+
+	* Makefile (rwlock7): Add new test.
+	* GNUmakefile (rwlock7): Add new test.
+	* rwlock7.c: New test.
+	* rwlock6.c: Changed to test that writer has priority.
+
+	* eyal1.c (main): Unlock each mutex_start lock before destroying
+	it.
+
+2000-12-29  Ross Johnson  <rpj@special.ise.canberra.edu.au>
+
+	* GNUmakefile: Add mutex4 test; ensure libpthreadw32.a is
+	removed for "clean" target.
+	* Makefile: Add mutex4 test.
+
+	* exception3.c: Remove SEH code; automatically pass the test
+	under SEH (which is an N/A environment).
+
+	* mutex4.c: New test.
+
+	* eyal1.c (do_work_unit): Add a dummy "if" to force the
+	optimiser to retain code; reduce thread work loads.
+
+	* condvar8.c (main): Add an additional "assert" for debugging;
+	increase pthread_cond_signal timeout.
+
+2000-12-28  Ross Johnson  <rpj@special.ise.canberra.edu.au>
+
+	* eyal1.c: Increase thread work loads.
+	* exception2.c: New test.
+	* exception3.c: New test.
+	* Makefile: Add new tests exception2.c and exception3.c.
+	* GNUmakefile: Likewise.
+
+2000-12-11  Ross Johnson  <rpj@special.ise.canberra.edu.au>
+
+	* cleanup3.c: Remove unused variable.
+	* cleanup2.c: Likewise.
+	* exception1.c: Throw an exception rather than use
+	a deliberate zero divide so that catch(...) will
+	handle it under Mingw32. Mingw32 now builds the
+	library correctly to pass all tests - see Thomas
+	Pfaff's detailed instructions re needed changes
+	to Mingw32 in the Pthreads-Win32 FAQ.
+
+2000-09-08  Ross Johnson  <rpj@special.ise.canberra.edu.au>
+
+	* cancel5.c: New; tests calling pthread_cancel()
+	from the main thread without first creating a
+	POSIX thread struct for the non-POSIX main thread
+	- this forces pthread_cancel() to create one via
+	pthread_self().
+	* Makefile (cancel5): Add new test.
+	* GNUmakefile (cancel5): Likewise.
+
+2000-08-17  Ross Johnson  <rpj@special.ise.canberra.edu.au>
+
+	* create2.c: New; Test that pthread_t contains
+	the W32 HANDLE before it calls the thread routine
+	proper.
+
+2000-08-13  Ross Johnson  <rpj@special.ise.canberra.edu.au>
+
+	* condvar3.c: Minor change to eliminate compiler
+	warning.
+
+	* condvar4.c: ditto.
+
+	* condvar5.c: ditto.
+
+	* condvar6.c: ditto.
+
+	* condvar7.c: ditto.
+
+	* condvar8.c: ditto.
+
+	* condvar9.c: ditto.
+
+	* exit1.c: Function needed return statement.
+
+	* cleanup1.c: Remove unnecessary printf arg.
+
+	* cleanup2.c: Fix cast.
+
+	* rwlock6.c: Fix casts.
+
+	* exception1.c (__PtW32CatchAll): Had the wrong name;
+	fix casts.
+
+	* cancel3.c: Remove unused waitLock variable.
+
+	* GNUmakefile: Change library/dll naming; add new tests;
+	general minor changes.
+
+	* Makefile: Change library/dll naming; add targets for
+	testing each of the two VC++ EH scheme versions;
+	default target now issues help message; compile warnings
+	now interpreted as errors to stop the make; add new
+	tests; restructure to remove prerequisites needed
+	otherwise.
+
+	* README: Updated.
+
+
+2000-08-10  Ross Johnson  <rpj@special.ise.canberra.edu.au>
+
+	* eyal1.c (main): Change implicit cast to explicit
+	cast when passing "print_server" function pointer;
+	G++ no longer allows implicit func parameter casts.
+
+	* cleanup1.c: Remove unused "waitLock".
+	(main): Fix implicit parameter cast.
+
+	* cancel2.c (main): Fix implicit parameter cast.
+
+	* cancel4.c (main): Fix implicit parameter cast.
+
+	* cancel3.c (main): Fix implicit parameter cast.
+
+	* GNUmakefile: Renamed from Makefile; Add missing
+	cancel1 and cancel2 test targets.
+
+	* Makefile: Converted for use with MS nmake.
+
+2000-08-06  Ross Johnson  <rpj@special.ise.canberra.edu.au>
+
+	* ccl.bat: Add /nologo to remove extraneous output.
+
+	* exception1.c (exceptionedThread): Init 'dummy';
+	put expression into if condition to prevent optimising away;
+	remove unused variable.
+
+	* cancel4.c (mythread): Cast return value to avoid warnings.
+
+	* cancel2.c (mythread): Missing #endif.
+
+	* condvar9.c (mythread): Cast return value to avoid warnings.
+
+	* condvar8.c (mythread): Cast return value to avoid warnings.
+
+	* condvar7.c (mythread): Cast return value to avoid warnings.
+
+	* cleanup3.c (mythread): Cast return value to avoid warnings.
+
+	* cleanup2.c (mythread): Cast return value to avoid warnings.
+
+	* cleanup1.c (mythread): Cast return value to avoid warnings.
+
+	* condvar5.c (mythread): Cast return value to avoid warnings.
+
+	* condvar3.c (mythread): Cast return value to avoid warnings.
+
+	* condvar6.c (mythread): Cast return value to avoid warnings.
+
+	* condvar4.c (mythread): Cast return value to avoid warnings.
+
+2000-08-05  Ross Johnson  <rpj@special.ise.canberra.edu.au>
+
+	* cancel2.c: Use __PtW32CatchAll macro if defined.
+
+	* exception1.c: Use __PtW32CatchAll macro if defined.
+
+2000-08-02  Ross Johnson  <rpj@special.ise.canberra.edu.au>
+
+	* tsd1.c: Fix typecasts of &result [g++ is now very fussy].
+	
+	* test.h (assert): Return 0's explicitly to allay
+	g++ errors.
+	
+	* join2.c: Add explicit typecasts.
+	
+	* join1.c: Add explicit typecasts.
+	
+	* join0.c: Add explicit typecasts.
+	
+	* eyal1.c: Add explicit typecasts.
+	
+	* count1.c (main): Add type cast to remove g++ parse warning
+	[gcc-2.95.2 seems to have tightened up on this].
+
+	* Makefile (GLANG): Use c++ explicitly.
+	Remove MSVC sections (was commented out).
+	Add target to generate cpp output.
+
+2000-07-25  Ross Johnson  <rpj@special.ise.canberra.edu.au>
+
+	* runtest.bat: modified to work under W98.
+	
+	* runall.bat: Add new tests; modified to work under W98.
+	It was ok under NT.
+
+	* Makefile: Add new tests.
+
+	* exception1.c: New; Test passing exceptions back to the
+	application and retaining library internal exceptions.
+
+	* join0.c: New; Test a single join.
+
+2000-01-06  Ross Johnson  <rpj@special.ise.canberra.edu.au>
+
+	* cleanup1.c: New; Test cleanup handler executes (when thread is
+	canceled).
+
+	* cleanup2.c: New; Test cleanup handler executes (when thread is
+	not canceled).
+
+	* cleanup3.c: New; Test cleanup handler does not execute
+	(when thread is not canceled).
+
+2000-01-04  Ross Johnson  <rpj@special.ise.canberra.edu.au>
+
+	* cancel4.c: New; Test cancellation does not occur in deferred
+	cancellation threads with no cancellation points.
+
+	* cancel3.c: New; Test asynchronous cancellation.
+
+	* context1.c: New; Test context switching method for async
+	cancellation.
+
+1999-11-23  Ross Johnson  <rpj@special.ise.canberra.edu.au>
+
+	* test.h: Add header includes; include local header versions rather
+	than system versions; rearrange the assert macro defines.
+
+1999-11-07  Ross Johnson  <rpj@ixobrychus.canberra.edu.au>
+
+	* loadfree.c: New. Test loading and freeing the library (DLL).
+
+1999-10-30  Ross Johnson  <rpj@ixobrychus.canberra.edu.au>
+
+	* cancel1.c: New. Test pthread_setcancelstate and
+	pthread_setcanceltype functions.
+	* eyal1.c (waste_time): Change calculation to avoid FP exception
+	on Aplhas
+	- Rich Peters <rpeters@micro-magic.com>
+
+Oct 14 1999  Ross Johnson  <rpj@ixobrychus.canberra.edu.au>
+
+	* condvar7.c: New. Test broadcast after waiting thread is canceled.
+	* condvar8.c: New. Test multiple broadcasts.
+	* condvar9.c: New. Test multiple broadcasts with thread
+	cancellation.
+	
+Sep 16 1999  Ross Johnson  <rpj@ixobrychus.canberra.edu.au>
+
+	* rwlock6.c: New test.
+
+Sep 15 1999  Ross Johnson  <rpj@ixobrychus.canberra.edu.au>
+
+	* rwlock1.c: New test.
+	* rwlock2.c: New test.
+	* rwlock3.c: New test.
+	* rwlock4.c: New test.
+	* rwlock5.c: New test.
+
+Aug 22 1999  Ross Johnson  <rpj@ixobrychus.canberra.edu.au>
+
+	* runall.bat (join2): Add test.
+
+Aug 19 1999  Ross Johnson  <rpj@ixobrychus.canberra.edu.au>
+
+	* join2.c: New test.
+
+Wed Aug 12 1999  Ross Johnson  <rpj@ixobrychus.canberra.edu.au>
+
+	* Makefile (LIBS): Add -L.
+
+Mon May 31 10:25:01 1999  Ross Johnson  <rpj@ixobrychus.canberra.edu.au>
+
+	* Makefile (GLANG): Add GCC language option.
+
+Sat May 29 23:29:04 1999  Ross Johnson  <rpj@ixobrychus.canberra.edu.au>
+
+	* runall.bat (condvar5): Add new test.
+
+	* runall.bat (condvar6): Add new test.
+
+	* Makefile (condvar5) : Add new test.
+	
+	* Makefile (condvar6) : Add new test.
+	
+	* condvar5.c: New test for pthread_cond_broadcast().
+
+	* condvar6.c: New test for pthread_cond_broadcast().
+
+Sun Apr  4 12:04:28 1999  Ross Johnson  <rpj@ixobrychus.canberra.edu.au>
+
+	* tsd1.c (mythread): Change Sleep(0) to sched_yield().
+	(sched.h): Include.
+
+	* condvar3.c (mythread): Remove redundant Sleep().
+
+	* runtest.bat: Re-organised to make more informative.
+
+Fri Mar 19 1999  Ross Johnson  <rpj@ixobrychus.canberra.edu.au>
+
+	* *.bat: redirect unwanted output to nul:
+
+	* runall.bat: new.
+
+	* cancel1.c: new. Not part of suite yet.
+	
+Mon Mar 15 00:17:55 1999  Ross Johnson  <rpj@ixobrychus.canberra.edu.au>
+
+	* mutex1.c: only test mutex init and destroy; add assertions.
+
+	* count1.c: raise number of spawned threads to 60 (appears to
+	be the limit under Win98).
+
+Sun Mar 14 21:31:02 1999  Ross Johnson  <rpj@ixobrychus.canberra.edu.au>
+
+	* test.h (assert): add assertion trace option.
+	Use:
+	"#define ASSERT_TRACE 1" to turn it on,
+	"#define ASSERT_TRACE 0" to turn it off (default).
+
+	* condvar3.c (main): add more assertions.
+
+	* condvar4.c (main): add more assertions.
+
+	* condvar1.c (main): add more assertions.
+
+Fri Mar 12 08:34:15 1999  Ross Johnson  <rpj@ixobrychus.canberra.edu.au>
+
+	* condvar4.c (cvthing): switch the order of the INITIALIZERs.
+
+	* eyal1.c (main): Fix trylock loop; was not waiting for thread to lock
+	the "started" mutex.
+
+Wed Mar 10 10:41:52 1999  Ross Johnson  <rpj@ixobrychus.canberra.edu.au>
+
+	* tryentercs.c: Apply typo patch from bje.
+
+	* tryentercs2.c: Ditto.
+
+Sun Mar  7 10:41:52 1999  Ross Johnson  <rpj@ixobrychus.canberra.edu.au>
+
+	* Makefile (condvar3, condvar4): Add tests.
+
+	* condvar4.c (General): Reduce to simple test case; prerequisite
+	is condvar3.c; add description.
+
+	* condvar3.c (General): Reduce to simple test case; prerequisite
+	is condvar2.c; add description.
+
+	* condvar2.c (General): Reduce to simple test case; prerequisite
+	is condvar1.c; add description.
+
+	* condvar1.c (General): Reduce to simple test case; add
+	description.
+
+	* Template.c (Comments): Add generic test detail.
+
+1999-02-23  Ross Johnson  <rpj@ise.canberra.edu.au>
+
+        * Template.c: Revamp.
+
+        * condvar1.c: Add.
+
+        * condvar2.c: Add.
+
+        * Makefile: Add condvar1 condvar2 tests.
+
+        * exit1.c, exit2.c, exit3.c: Cosmetic changes.
+
+1999-02-23  Ross Johnson  <rpj@ise.canberra.edu.au>
+
+	* Makefile: Some refinement.
+
+	* *.c: More exhaustive checking through assertions; clean up;
+	add some more tests.
+
+	* Makefile: Now actually runs the tests.
+
+	* tests.h: Define our own assert macro. The Mingw32
+	version pops up a dialog but we want to run non-interactively.
+
+	* equal1.c: use assert a little more directly so that it
+	prints the actual call statement.
+
+	* exit1.c: Modify to return 0 on success, 1 on failure.
+
+1999-02-22  Ross Johnson  <rpj@ise.canberra.edu.au>
+
+	* self2.c: Bring up to date.
+
+	* self3.c: Ditto.
+
+1999-02-21  Ben Elliston  <bje@cygnus.com>
+
+	* README: Update.
+
+	* Makefile: New file. Run all tests automatically. Primitive tests
+	are run first; more complex tests are run last.
+
+	* count1.c: New test. Validate the thread count.
+
+	* exit2.c: Perform a simpler test.
+	
+	* exit3.c: New test. Replaces exit2.c, since exit2.c needs to
+	perform simpler checking first.
+
+	* create1.c: Update to use the new testsuite exiting convention.
+	
+	* equal1.c: Likewise.
+
+	* mutex1.c: Likewise.
+
+	* mutex2.c: Likewise.
+
+	* once1.c: Likewise.
+
+	* self2.c: Likewise.
+
+	* self3.c: Likewise.
+
+	* tsd1.c: Likewise.
+
+1999-02-20  Ross Johnson  <rpj@ise.canberra.edu.au>
+
+	* mutex2.c: Test static mutex initialisation.
+
+	* test.h: New. Declares a table mapping error numbers to
+	error names.
+
+1999-01-17  Ross Johnson  <rpj@ise.canberra.edu.au>
+
+	* runtest: New script to build and run a test in the tests directory.
+
+Wed Dec 30 11:22:44 1998  Ross Johnson  <rpj@ixobrychus.canberra.edu.au>
+
+	* tsd1.c: Re-written. See comments at start of file.
+	* Template.c: New. Contains skeleton code and comment template
+	intended to fully document the test.
+
+Fri Oct 16 17:59:49 1998  Ross Johnson  <rpj@swan.canberra.edu.au>
+
+	* tsd1.c (destroy_key): Add function. Change diagnostics.
+
+Thu Oct 15 17:42:37 1998  Ross Johnson  <rpj@swan.canberra.edu.au>
+
+	* tsd1.c (mythread): Fix some casts and add some message
+	output. Fix inverted conditional.
+
+Mon Oct 12 02:12:29 1998  Ross Johnson  <rpj@ixobrychus.canberra.edu.au>
+
+	* tsd1.c: New. Test TSD using 1 key and 2 threads.
+
+1998-09-13  Ben Elliston  <bje@cygnus.com>
+
+	* eyal1.c: New file; contributed by Eyal Lebedinsky
+	<eyal@eyal.emu.id.au>.
+
+1998-09-12  Ben Elliston  <bje@cygnus.com>
+
+	* exit2.c (func): Return a value.
+	(main): Call the right thread entry function.
+
+1998-07-22  Ben Elliston  <bje@cygnus.com>
+
+	* exit2.c (main): Fix size of pthread_t array.
+
+1998-07-10  Ben Elliston  <bje@cygnus.com>
+
+	* exit2.c: New file; test pthread_exit() harder.
+
+	* exit1.c: New file; test pthread_exit().
diff --git a/src/include/pthread/tests/Debug.dsp b/src/include/pthread/tests/Debug.dsp
new file mode 100644
index 0000000..191b978
--- /dev/null
+++ b/src/include/pthread/tests/Debug.dsp
@@ -0,0 +1,93 @@
+# Microsoft Developer Studio Project File - Name="Debug" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Console Application" 0x0103
+
+CFG=Debug - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "Debug.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "Debug.mak" CFG="Debug - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "Debug - Win32 Release" (based on "Win32 (x86) Console Application")
+!MESSAGE "Debug - Win32 Debug" (based on "Win32 (x86) Console Application")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "Debug - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD BASE RSC /l 0xc09 /d "NDEBUG"
+# ADD RSC /l 0xc09 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+
+!ELSEIF  "$(CFG)" == "Debug - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
+# ADD CPP /nologo /MDd /W3 /WX /Gm /ZI /Od /I ".." /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /D "CLEANUP_C" /FR /YX /FD /GZ /c
+# ADD BASE RSC /l 0xc09 /d "_DEBUG"
+# ADD RSC /l 0xc09 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib pthreadVC2d.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept /libpath:".."
+
+!ENDIF 
+
+# Begin Target
+
+# Name "Debug - Win32 Release"
+# Name "Debug - Win32 Debug"
+# Begin Source File
+
+SOURCE=.\Debug.txt
+# End Source File
+# Begin Source File
+
+SOURCE=.\semaphore1.c
+# End Source File
+# End Target
+# End Project
diff --git a/src/include/pthread/tests/Debug.dsw b/src/include/pthread/tests/Debug.dsw
new file mode 100644
index 0000000..5fd6af3
--- /dev/null
+++ b/src/include/pthread/tests/Debug.dsw
@@ -0,0 +1,29 @@
+Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+
+###############################################################################
+
+Project: "Debug"=.\Debug.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
+
diff --git a/src/include/pthread/tests/Debug.plg b/src/include/pthread/tests/Debug.plg
new file mode 100644
index 0000000..22ce672
--- /dev/null
+++ b/src/include/pthread/tests/Debug.plg
@@ -0,0 +1,32 @@
+<html>
+<body>
+<pre>
+<h1>Build Log</h1>
+<h3>
+--------------------Configuration: Debug - Win32 Debug--------------------
+</h3>
+<h3>Command Lines</h3>
+Creating temporary file "C:\DOCUME~1\ADMINI~1\LOCALS~1\Temp\RSP9.tmp" with contents
+[
+/nologo /MDd /W3 /WX /Gm /ZI /Od /I ".." /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /D "CLEANUP_C" /FR"Debug/" /Fp"Debug/Debug.pch" /YX /Fo"Debug/" /Fd"Debug/" /FD /GZ /c 
+"E:\PTHREADS\pthreads.2\tests\semaphore1.c"
+]
+Creating command line "cl.exe @C:\DOCUME~1\ADMINI~1\LOCALS~1\Temp\RSP9.tmp" 
+Creating temporary file "C:\DOCUME~1\ADMINI~1\LOCALS~1\Temp\RSPA.tmp" with contents
+[
+kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib pthreadVC2d.lib /nologo /subsystem:console /incremental:yes /pdb:"Debug/Debug.pdb" /debug /machine:I386 /out:"Debug/Debug.exe" /pdbtype:sept /libpath:".." 
+.\Debug\semaphore1.obj
+]
+Creating command line "link.exe @C:\DOCUME~1\ADMINI~1\LOCALS~1\Temp\RSPA.tmp"
+<h3>Output Window</h3>
+Compiling...
+semaphore1.c
+Linking...
+
+
+
+<h3>Results</h3>
+Debug.exe - 0 error(s), 0 warning(s)
+</pre>
+</body>
+</html>
diff --git a/src/include/pthread/tests/Debug.txt b/src/include/pthread/tests/Debug.txt
new file mode 100644
index 0000000..5323874
--- /dev/null
+++ b/src/include/pthread/tests/Debug.txt
@@ -0,0 +1,6 @@
+This project is used to debug individual test case programs.
+
+To build and debug a test case:
+- add the .c file to this project;
+- remove any .c files from other test cases from this project.
+- build and debug as usual.
\ No newline at end of file
diff --git a/src/include/pthread/tests/GNUmakefile.in b/src/include/pthread/tests/GNUmakefile.in
new file mode 100644
index 0000000..7a4623d
--- /dev/null
+++ b/src/include/pthread/tests/GNUmakefile.in
@@ -0,0 +1,270 @@
+# Makefile for the pthreads test suite.
+# If all of the .pass files can be created, the test suite has passed.
+#
+# --------------------------------------------------------------------------
+#
+#      Pthreads4w - POSIX Threads for Windows
+#      Copyright 1998 John E. Bossom
+#      Copyright 1999-2018, Pthreads4w contributors
+#
+#      Homepage: https://sourceforge.net/projects/pthreads4w/
+#
+#      The current list of contributors is contained
+#      in the file CONTRIBUTORS included with the source
+#      code distribution. The list can also be seen at the
+#      following World Wide Web location:
+#
+#      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+#
+#      This library is free software; you can redistribute it and/or
+#      modify it under the terms of the GNU Lesser General Public
+#      License as published by the Free Software Foundation; either
+#      version 3 of the License, or (at your option) any later version.
+# 
+#      This library is distributed in the hope that it will be useful,
+#      but WITHOUT ANY WARRANTY; without even the implied warranty of
+#      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#      Lesser General Public License for more details.
+# 
+#      You should have received a copy of the GNU Lesser General Public
+#      License along with this library in the file COPYING.LIB;
+#      if not, write to the Free Software Foundation, Inc.,
+#      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+#
+srcdir = @srcdir@
+top_srcdir = @top_srcdir@
+VPATH = @srcdir@
+
+LOGFILE = testsuite.log
+
+builddir = @builddir@
+top_builddir = @top_builddir@
+
+PTW32_VER	= 3$(EXTRAVERSION)
+
+CP		= cp -f
+MV		= mv -f
+RM		= rm -f
+CAT		= cat
+GREP	= grep
+WC		= wc
+TEE		= tee
+MKDIR		= mkdir
+ECHO		= echo
+TOUCH		= $(ECHO) Passed >
+TESTFILE	= test -f
+TESTDIR		= test -d
+AND		= &&
+
+# For cross compiling use e.g.
+# # make CROSS=i386-mingw32msvc- clean GC
+#CROSS   =
+
+# For cross testing use e.g.
+# # make RUN=wine CROSS=i386-mingw32msvc- clean GC
+RUN     =
+
+AR      = $(CROSS)@AR@
+DLLTOOL = $(CROSS)@DLLTOOL@
+CC      = $(CROSS)@CC@
+CXX     = $(CROSS)@CXX@
+RANLIB  = $(CROSS)@RANLIB@
+
+#
+# Mingw
+#
+XLIBS	=
+XXCFLAGS=
+XXLIBS	=
+OPT	= -O3
+DOPT	= -g -O0
+CFLAGS	= ${OPT} $(ARCH) -UNDEBUG -Wall -Wno-missing-braces $(XXCFLAGS)
+LFLAGS	= $(ARCH) $(XXLFLAGS)
+#
+# Uncomment this next to link the GCC/C++ runtime libraries statically
+# (Be sure to read about these options and their associated caveats
+# at http://gcc.gnu.org/onlinedocs/gcc/Link-Options.html)
+#
+# NOTE 1: Doing this appears to break GCE:pthread_cleanup_*(), which
+# relies on C++ class destructors being called when leaving scope.
+#
+# NOTE 2: If you do this DO NOT distribute your pthreads DLLs with
+# the official filenaming, i.e. pthreadVC2.dll, etc. Instead, change PTW32_VER
+# above to "2slgcc" for example, to build "pthreadGC2slgcc.dll", etc.
+#
+#LFLAGS	+= -static-libgcc -static-libstdc++
+
+BUILD_DIR	= ..
+INCLUDES	= -I ${top_srcdir}
+
+TEST	= GC
+
+# Default lib version
+GCX	= GC$(PTW32_VER)
+
+# Files we need to run the tests
+# - paths are relative to pthreads build dir.
+HDR	= pthread.h semaphore.h sched.h
+LIB	= libpthread$(GCX).a
+DLL	= pthread$(GCX).dll
+# The next path is relative to $BUILD_DIR
+QAPC	=  # ../QueueUserAPCEx/User/quserex.dll
+
+include ${srcdir}/common.mk
+
+.INTERMEDIATE: $(ALL_KNOWN_TESTS:%=%.exe) $(BENCHTESTS:%=%.exe)
+.SECONDARY: $(ALL_KNOWN_TESTS:%=%.exe) $(ALL_KNOWN_TESTS:%=%.pass) $(BENCHTESTS:%=%.exe) $(BENCHTESTS:%=%.bench)
+.PRECIOUS: $(ALL_KNOWN_TESTS:%=%.exe) $(ALL_KNOWN_TESTS:%=%.pass) $(BENCHTESTS:%=%.exe) $(BENCHTESTS:%=%.bench)
+
+ASM		= $(ALL_KNOWN_TESTS:%=%.s)
+TESTS		= $(ALL_KNOWN_TESTS)
+BENCHRESULTS	= $(BENCHTESTS:%=%.bench)
+
+#
+# To build and run "foo.exe" and "bar.exe" only use, e.g.:
+# make clean GC NO_DEPS=1 TESTS="foo bar"
+#
+# To build and run "foo.exe" and "bar.exe" and run all prerequisite tests
+# use, e.g.:
+# make clean GC TESTS="foo bar"
+#
+# Set TESTS to one or more tests.
+#
+ifndef NO_DEPS
+include ${srcdir}/runorder.mk
+endif
+
+help:
+	@ $(ECHO) "Run one of the following command lines:"
+	@ $(ECHO) "$(MAKE) clean GC                 (to test using GC dll with C (no EH) applications)"
+	@ $(ECHO) "$(MAKE) clean GCX                (to test using GC dll with C++ (EH) applications)"
+	@ $(ECHO) "$(MAKE) clean GCE                (to test using GCE dll with C++ (EH) applications)"
+	@ $(ECHO) "$(MAKE) clean GC-bench           (to benchtest using GNU C dll with C cleanup code)"
+	@ $(ECHO) "$(MAKE) clean GC-debug           (to test using GC dll with C (no EH) applications)"
+	@ $(ECHO) "$(MAKE) clean GC-static          (to test using GC static lib with C (no EH) applications)"
+	@ $(ECHO) "$(MAKE) clean GC-static-debug    (to test using GC static lib with C (no EH) applications)"
+	@ $(ECHO) "$(MAKE) clean GCE-static         (to test using GC static lib with C (no EH) applications)"
+	@ $(ECHO) "$(MAKE) clean GCE-static-debug   (to test using GC static lib with C (no EH) applications)"
+	@ $(ECHO) "$(MAKE) clean GCE-debug          (to test using GCE dll with C++ (EH) applications)"
+	@ $(ECHO) "$(MAKE) clean GCX-static         (to test using GC static lib with C++ applications)"
+	@ $(ECHO) "$(MAKE) clean GCX-static-debug   (to test using GC static lib with C++ applications)"
+	@ $(ECHO) "$(MAKE) clean GCX-debug          (to test using GCE dll with C++ (EH) applications)"
+	@ $(ECHO) "$(MAKE) clean GC TESTS="foo bar" (to build individual tests \"foo.c and bar.c\" with C and run using GC dll)"
+
+GC:
+	@ $(MAKE) --no-builtin-rules TEST=$@ GCX="GC$(PTW32_VER)" CC=$(CC) XXCFLAGS="-D__PTW32_CLEANUP_C" allpassed
+
+GC-asm:
+	@ $(MAKE) --no-builtin-rules TEST=$@ GCX="GC$(PTW32_VER)" CC=$(CC) XXCFLAGS="-D__PTW32_CLEANUP_C" all-asm
+
+GC-bench:
+	@ $(MAKE) --no-builtin-rules TEST=$@ GCX="GC$(PTW32_VER)" CC=$(CC) XXCFLAGS="-D__PTW32_CLEANUP_C" XXLIBS="benchlib.o" all-bench
+
+GC-bench-debug:
+	@ $(MAKE) --no-builtin-rules TEST=$@ GCX="GC$(PTW32_VER)d" CC=$(CC) XXCFLAGS="-D__PTW32_CLEANUP_C" XXLIBS="benchlib.o" OPT="${DOPT}" all-bench
+
+GC-debug:
+	@ $(MAKE) --no-builtin-rules TEST=$@ GCX="GC$(PTW32_VER)d" CC=$(CC) XXCFLAGS="-D__PTW32_CLEANUP_C" OPT="${DOPT}" allpassed
+
+GC-static GC-small-static:
+	@ $(MAKE) --no-builtin-rules TEST=$@ GCX="GC$(PTW32_VER)" CC=$(CC) XXCFLAGS="-D__PTW32_CLEANUP_C -D__PTW32_STATIC_LIB -Wl,-Bstatic" DLL="" allpassed
+
+GC-static-debug GC-small-static-debug:
+	@ $(MAKE) --no-builtin-rules TEST=$@ GCX="GC$(PTW32_VER)d" CC=$(CC) XXCFLAGS="-D__PTW32_CLEANUP_C -D__PTW32_STATIC_LIB -Wl,-Bstatic" OPT="$(DOPT)" DLL="" allpassed
+
+GCE:
+	@ $(MAKE) --no-builtin-rules TEST=$@ GCX="GCE$(PTW32_VER)" CC=$(CXX) XXCFLAGS="-mthreads -D__PTW32_CLEANUP_CXX" allpassed
+
+GCE-debug:
+	@ $(MAKE) --no-builtin-rules TEST=$@ GCX="GCE$(PTW32_VER)d" CC=$(CXX) XXCFLAGS="-D__PTW32_CLEANUP_CXX" OPT="${DOPT}" allpassed
+
+GCE-static GCE-small-static:
+	@ $(MAKE) --no-builtin-rules TEST=$@ GCX="GCE$(PTW32_VER)" CC=$(CXX) XXCFLAGS="-D__PTW32_CLEANUP_CXX -D__PTW32_STATIC_LIB -Wl,-Bstatic" DLL="" allpassed
+
+GCE-static-debug GCE-small-static-debug:
+	@ $(MAKE) --no-builtin-rules TEST=$@ GCX="GCE$(PTW32_VER)d" CC=$(CXX) XXCFLAGS="-D__PTW32_CLEANUP_CXX -D__PTW32_STATIC_LIB -Wl,-Bstatic" OPT="$(DOPT)" DLL="" allpassed
+
+GCX:
+	@ $(MAKE) --no-builtin-rules TEST=$@ GCX="GC$(PTW32_VER)" CC=$(CXX) XXCFLAGS="-mthreads -D__PTW32_CLEANUP_C" allpassed
+
+GCX-debug:
+	@ $(MAKE) --no-builtin-rules TEST=$@ GCX="GC$(PTW32_VER)d" CC=$(CXX) XXCFLAGS="-D__PTW32_CLEANUP_C" OPT="${DOPT}" allpassed
+
+GCX-static GCX-small-static:
+	@ $(MAKE) --no-builtin-rules TEST=$@ GCX="GC$(PTW32_VER)" CC=$(CXX) XXCFLAGS="-D__PTW32_CLEANUP_C -D__PTW32_STATIC_LIB -Wl,-Bstatic" DLL="" allpassed
+
+GCX-static-debug GCX-small-static-debug:
+	@ $(MAKE) --no-builtin-rules TEST=$@ GCX="GC$(PTW32_VER)d" CC=$(CXX) XXCFLAGS="-D__PTW32_CLEANUP_C -D__PTW32_STATIC_LIB -Wl,-Bstatic" OPT="$(DOPT)" DLL="" allpassed
+
+all-asm: $(ASM)
+	@ $(ECHO) "ALL TESTS COMPILED TO ASSEMBLER CODE"
+
+allpassed: $(HDR) $(LIB) $(DLL) $(QAPC) $(TESTS:%=%.pass)
+	@ $(ECHO) "ALL TESTS COMPLETED. Check the logfile: $(LOGFILE)"
+	@ $(ECHO) "FAILURES: $$( $(GREP) FAILED $(LOGFILE) | $(WC) -l ) "
+	@ - ! $(GREP) FAILED $(LOGFILE)
+	@ $(MV) $(LOGFILE) ../$(TEST)-$(LOGFILE)
+
+all-bench: $(HDR) $(LIB) $(DLL) $(QAPC) $(XXLIBS) $(BENCHRESULTS)
+	@ $(ECHO) "ALL BENCH TESTS COMPLETED. Check the logfile: $(LOGFILE)"
+	@ $(ECHO) "FAILURES: $$( $(GREP) FAILED $(LOGFILE) | $(WC) -l ) "
+	@ - ! $(GREP) FAILED $(LOGFILE)
+	@ $(MV) $(LOGFILE) ../$(TEST)-$(LOGFILE)
+
+cancel9.exe: XLIBS = -lws2_32
+
+%.pass: %.exe
+	@ $(ECHO) Running $(TEST) test \"$*\" | tee -a $(LOGFILE)
+	@ (PATH=${top_builddir}:$$PATH $(RUN) ./$* \
+	  && { $(ECHO) Passed; $(TOUCH) $@; } || { $(ECHO) FAILED: $* ; $(ECHO) ; } ) \
+	  2>&1 | tee -a $(LOGFILE)
+
+%.bench: %.exe
+	@ $(ECHO) Running $(TEST) test \"$*\" | tee -a $(LOGFILE)
+	@ (PATH=${top_builddir}:$$PATH $(RUN) ./$* \
+	  && { $(ECHO) Done; $(TOUCH) $@; } || { $(ECHO) FAILED ; $(ECHO) ; } ) \
+	  2>&1 | tee -a $(LOGFILE)
+
+%.exe: %.c
+	$(CC) $(CFLAGS) $(INCLUDES) $(LFLAGS) -o $@ $< -L.. -lpthread$(GCX) $(XLIBS) $(XXLIBS)
+
+%.pre: %.c $(HDR)
+	$(CC) -E $(CFLAGS) -o $@ $< $(INCLUDES)
+
+%.s: %.c $(HDR)
+	@ $(ECHO) Compiling $@
+	$(CC) -S $(CFLAGS) -o $@ $< $(INCLUDES)
+
+$(HDR) $(LIB) $(DLL) $(QAPC): $(LOGFILE)
+#	@ $(ECHO) Copying $(BUILD_DIR)/$@
+#	@ $(TESTFILE) $(BUILD_DIR)/$@ $(AND) $(CP) $(BUILD_DIR)/$@ .
+
+.PHONY: $(LOGFILE)
+$(LOGFILE):; > $@
+
+benchlib.o: benchlib.c
+	@ $(ECHO) Compiling $@
+	$(CC) -c $(CFLAGS) $< $(INCLUDES)
+
+clean:
+	- $(RM) *.dll
+	- $(RM) *.lib
+	- $(RM) _ptw32.h
+	- $(RM) pthread.h
+	- $(RM) semaphore.h
+	- $(RM) sched.h
+	- $(RM) *.a
+	- $(RM) *.e
+	- $(RM) *.i
+	- $(RM) *.o
+	- $(RM) *.s
+	- $(RM) *.so
+	- $(RM) *.obj
+	- $(RM) *.pdb
+	- $(RM) *.exe
+	- $(RM) *.manifest
+	- $(RM) *.pass
+	- $(RM) *.bench
+
+realclean: clean
+	- $(RM) *.log
diff --git a/src/include/pthread/tests/Makefile b/src/include/pthread/tests/Makefile
new file mode 100644
index 0000000..ebf457d
--- /dev/null
+++ b/src/include/pthread/tests/Makefile
@@ -0,0 +1,233 @@
+# Makefile for the pthreads test suite.
+# If all of the .pass files can be created, the test suite has passed.
+
+PTW32_VER	= 3$(EXTRAVERSION)
+
+CC = cl /errorReport:none /nologo
+
+CP	= copy
+RM	= erase
+RMDIR	= rmdir /s /q
+CAT	= type
+MKDIR	= mkdir
+ECHO	= echo
+TOUCH	= $(ECHO) touched >
+
+# The next path is relative to $BUILD_DIR
+QAPC	= # ..\QueueUserAPCEx\User\quserex.dll
+
+CPHDR	= _ptw32.h pthread.h semaphore.h sched.h
+
+OPTIM	= /O2 /Ob0
+
+XXLIBS	= ws2_32.lib
+
+# C++ Exceptions
+VCEFLAGS	= /EHs /TP /D__PtW32NoCatchWarn /D__PTW32_CLEANUP_CXX
+VCELIB	= libpthreadVCE$(PTW32_VER).lib
+VCEIMP	= pthreadVCE$(PTW32_VER).lib
+VCEDLL	= pthreadVCE$(PTW32_VER).dll
+VCELIBD	= libpthreadVCE$(PTW32_VER)d.lib
+VCEIMPD	= pthreadVCE$(PTW32_VER)d.lib
+VCEDLLD	= pthreadVCE$(PTW32_VER)d.dll
+# Structured Exceptions
+VSEFLAGS	= /D__PTW32_CLEANUP_SEH
+VSELIB	= libpthreadVSE$(PTW32_VER).lib
+VSEIMP	= pthreadVSE$(PTW32_VER).lib
+VSEDLL	= pthreadVSE$(PTW32_VER).dll
+VSELIBD	= libpthreadVSE$(PTW32_VER)d.lib
+VSEIMPD	= pthreadVSE$(PTW32_VER)d.lib
+VSEDLLD	= pthreadVSE$(PTW32_VER)d.dll
+# C cleanup code
+VCFLAGS	= /D__PTW32_CLEANUP_C
+VCLIB	= libpthreadVC$(PTW32_VER).lib
+VCIMP	= pthreadVC$(PTW32_VER).lib
+VCDLL	= pthreadVC$(PTW32_VER).dll
+VCLIBD	= libpthreadVC$(PTW32_VER)d.lib
+VCIMPD	= pthreadVC$(PTW32_VER)d.lib
+VCDLLD	= pthreadVC$(PTW32_VER)d.dll
+# C++ Exceptions in application - using VC version of pthreads dll
+VCXFLAGS	= /EHs /TP /D__PTW32_CLEANUP_C
+
+# Defaults
+CPLIB	= $(VCLIB)
+CPDLL	= $(VCDLL)
+
+CFLAGS				= $(OPTIM) /W3 /Z7
+CFLAGS_DEBUG		= $(OPTIM) /W3 /Z7
+LFLAGS				= /INCREMENTAL:NO
+INCLUDES			= -I.
+BUILD_DIR			= ..
+
+EHFLAGS		=
+EHFLAGS_DLL				= /MD
+EHFLAGS_DLL_DEBUG		= /MDd
+EHFLAGS_STATIC			= /MT
+EHFLAGS_STATIC_DEBUG	= /MTd
+
+# If a test case returns a non-zero exit code to the shell, make will
+# stop.
+
+include common.mk
+
+#
+# To build and run "foo.exe" and "bar.exe" only use, e.g.:
+# nmake clean VC NO_DEPS=1 TESTS="foo bar"
+#
+# To build and run "foo.exe" and "bar.exe" and run all prerequisite tests
+# use, e.g.:
+# nmake clean VC TESTS="foo bar"
+#
+# Set TESTS to one or more tests.
+#
+!IFNDEF NO_DEPS
+include runorder.mk
+!ENDIF
+
+help:
+	@ $(ECHO) Run one of the following command lines:
+	@ $(ECHO) nmake clean VC
+	@ $(ECHO) nmake clean VC-bench
+	@ $(ECHO) nmake clean VC-static
+	@ $(ECHO) nmake clean VC-static-bench
+	@ $(ECHO) nmake clean VC-debug
+	@ $(ECHO) nmake clean VC-static-debug
+	@ $(ECHO) nmake clean VC-small-static-debug
+	@ $(ECHO) nmake clean VCX
+	@ $(ECHO) nmake clean VCX-bench
+	@ $(ECHO) nmake clean VCX-static
+	@ $(ECHO) nmake clean VCX-static-bench
+	@ $(ECHO) nmake clean VCX-debug
+	@ $(ECHO) nmake clean VCX-static-debug
+	@ $(ECHO) nmake clean VCX-small-static-debug
+	@ $(ECHO) nmake clean VCE
+	@ $(ECHO) nmake clean VCE-bench
+	@ $(ECHO) nmake clean VCE-static
+	@ $(ECHO) nmake clean VCE-static-bench
+	@ $(ECHO) nmake clean VCE-debug
+	@ $(ECHO) nmake clean VCE-static-debug
+	@ $(ECHO) nmake clean VCE-small-static-debug
+	@ $(ECHO) nmake clean VSE
+	@ $(ECHO) nmake clean VSE-bench
+	@ $(ECHO) nmake clean VSE-static
+	@ $(ECHO) nmake clean VSE-static-bench
+	@ $(ECHO) nmake clean VSE-debug
+	@ $(ECHO) nmake clean VSE-static-debug
+	@ $(ECHO) nmake clean VSE-small-static-debug
+
+VC:
+	@ $(MAKE) /E /nologo TEST="$@" CPLIB="$(VCIMP)" CPDLL="$(VCDLL)" EHFLAGS="$(VCFLAGS) $(EHFLAGS_DLL)" allpassed
+
+VCE:
+	@ $(MAKE) /E /nologo TEST="$@" CPLIB="$(VCEIMP)" CPDLL="$(VCEDLL)" EHFLAGS="$(VCEFLAGS) $(EHFLAGS_DLL)" allpassed
+
+VSE:	
+	@ $(MAKE) /E /nologo TEST="$@" CPLIB="$(VSEIMP)" CPDLL="$(VSEDLL)" EHFLAGS="$(VSEFLAGS) $(EHFLAGS_DLL)" allpassed
+
+VCX:
+	@ $(MAKE) /E /nologo TEST="$@" CPLIB="$(VCIMP)" CPDLL="$(VCDLL)" EHFLAGS="$(VCXFLAGS) $(EHFLAGS_DLL)" allpassed
+
+VC-bench:
+	@ $(MAKE) /E /nologo TEST="$@" CPLIB="$(VCIMP)" CPDLL="$(VCDLL)" EHFLAGS="$(VCFLAGS) $(EHFLAGS_DLL)" $(BENCHTESTS)
+
+VCE-bench:
+	@ $(MAKE) /E /nologo TEST="$@" CPLIB="$(VCEIMP)" CPDLL="$(VCEDLL)" EHFLAGS="$(VCEFLAGS) $(EHFLAGS_DLL)" $(BENCHTESTS)
+
+VSE-bench:
+	@ $(MAKE) /E /nologo TEST="$@" CPLIB="$(VSEIMP)" CPDLL="$(VSEDLL)" EHFLAGS="$(VSEFLAGS) $(EHFLAGS_DLL)" $(BENCHTESTS)
+
+VCX-bench:
+	@ $(MAKE) /E /nologo TEST="$@" CPLIB="$(VCIMP)" CPDLL="$(VCDLL)" EHFLAGS="$(VCXFLAGS) $(EHFLAGS_DLL)" $(BENCHTESTS)
+
+VC-static VC-small-static:
+	@ $(MAKE) /E /nologo TEST="$@" CPLIB="$(VCLIB)" CPDLL="" EHFLAGS="$(VCFLAGS) $(EHFLAGS_STATIC)" allpassed
+
+VCE-static VCE-small-static:
+	@ $(MAKE) /E /nologo TEST="$@" CPLIB="$(VCELIB)" CPDLL="" EHFLAGS="$(VCEFLAGS) $(EHFLAGS_STATIC)" allpassed
+
+VSE-static VSE-small-static:
+	@ $(MAKE) /E /nologo TEST="$@" CPLIB="$(VSELIB)" CPDLL="" EHFLAGS="$(VSEFLAGS) $(EHFLAGS_STATIC)" allpassed
+
+VCX-static VCX-small-static:
+	@ $(MAKE) /E /nologo TEST="$@" CPLIB="$(VCLIBD)" CPDLL="" EHFLAGS="$(VCXFLAGS) $(EHFLAGS_STATIC)" allpassed
+
+VC-static-bench:
+	@ $(MAKE) /E /nologo TEST="$@" CPLIB="$(VCLIB)" CPDLL="" EHFLAGS="$(VCFLAGS) $(EHFLAGS_STATIC)" $(BENCHTESTS)
+
+VCE-static-bench:
+	@ $(MAKE) /E /nologo TEST="$@" CPLIB="$(VCELIB)" CPDLL="" EHFLAGS="$(VCEFLAGS) $(EHFLAGS_STATIC)" $(BENCHTESTS)
+
+VSE-static-bench:
+	@ $(MAKE) /E /nologo TEST="$@" CPLIB="$(VSELIB)" CPDLL="" EHFLAGS="$(VSEFLAGS) $(EHFLAGS_STATIC)" $(BENCHTESTS)
+
+VCX-static-bench:
+	@ $(MAKE) /E /nologo TEST="$@" CPLIB="$(VCLIBD)" CPDLL="" EHFLAGS="$(VCXFLAGS) $(EHFLAGS_STATIC)" $(BENCHTESTS)
+
+VC-debug:
+	@ $(MAKE) /E /nologo TEST="$@" CPLIB="$(VCIMPD)" CPDLL="$(VCDLLD)" EHFLAGS="$(VCFLAGS) $(EHFLAGS_DLL_DEBUG)" allpassed
+
+VC-static-debug VC-small-static-debug:
+	@ $(MAKE) /E /nologo TEST="$@" CPLIB="$(VCLIBD)" CPDLL="" EHFLAGS="$(VCFLAGS) $(EHFLAGS_STATIC_DEBUG)" allpassed
+
+VCE-debug:
+	@ $(MAKE) /E /nologo TEST="$@" CPLIB="$(VCEIMPD)" CPDLL="$(VCEDLLD)" EHFLAGS="$(VCEFLAGS) $(EHFLAGS_DLL_DEBUG)" allpassed
+
+VCE-static-debug VCE-small-static-debug:
+	@ $(MAKE) /E /nologo TEST="$@" CPLIB="$(VCELIBD)" CPDLL="" EHFLAGS="$(VCEFLAGS) $(EHFLAGS_STATIC_DEBUG)" allpassed
+
+VSE-debug:
+	@ $(MAKE) /E /nologo TEST="$@" CPLIB="$(VSEIMPD)" CPDLL="$(VSEDLLD)" EHFLAGS="$(VSEFLAGS) $(EHFLAGS_DLL_DEBUG)" allpassed
+
+VSE-static-debug VSE-small-static-debug:
+	@ $(MAKE) /E /nologo TEST="$@" CPLIB="$(VSELIBD)" CPDLL="" EHFLAGS="$(VSEFLAGS) $(EHFLAGS_STATIC_DEBUG)" allpassed
+
+VCX-debug:
+	@ $(MAKE) /E /nologo TEST="$@" CPLIB="$(VCIMPD)" CPDLL="$(VCDLLD)" EHFLAGS="$(VCXFLAGS) $(EHFLAGS_DLL_DEBUG)" allpassed
+
+VCX-static-debug VCX-small-static-debug:
+	@ $(MAKE) /E /nologo TEST="$@" CPLIB="$(VCLIBD)" CPDLL="" EHFLAGS="$(VCXFLAGS) $(EHFLAGS_STATIC_DEBUG)" allpassed
+
+clean:
+	if exist *.dll $(RM) *.dll
+	if exist *.lib $(RM) *.lib
+	if exist _ptw32.h $(RM) _ptw32.h
+	if exist pthread.h $(RM) pthread.h
+	if exist semaphore.h $(RM) semaphore.h
+	if exist sched.h $(RM) sched.h
+	if exist *.e $(RM) *.e
+	if exist *.i $(RM) *.i
+	if exist *.obj $(RM) *.obj
+	if exist *.pdb $(RM) *.pdb
+	if exist *.o $(RM) *.o
+	if exist *.asm $(RM) *.asm
+	if exist *.exe $(RM) *.exe
+	if exist *.manifest $(RM) *.manifest
+	if exist *.pass $(RM) *.pass
+	if exist *.bench $(RM) *.bench
+
+realclean: clean
+	if exist *.log $(RM) *.log
+
+.c.pass:
+	$(CC) $(CFLAGS) $(INCLUDES) $(EHFLAGS) $*.c /Fe$*.exe /link $(LFLAGS) $(CPLIB) $(XXLIBS)
+	@ $(ECHO) ... Running $(TEST) test: $*.exe
+	@ .\$*.exe
+	@ $(ECHO) ...... Passed
+	@ $(TOUCH) $*.pass
+
+$(ALL_KNOWN_TESTS): $(CPHDR) $(CPLIB) $(CPDLL) $(QAPC) $@.pass
+
+allpassed: $(TESTS)
+	@ $(ECHO) ALL TESTS PASSED! Congratulations!
+
+$(BENCHTESTS): $(CPHDR) $(CPLIB) $(CPDLL) $(QAPC)
+	$(CC) $(EHFLAGS) $(CFLAGS) $(INCLUDES) benchlib.c $*.c /Fe$*.exe /link $(LFLAGS) $(CPLIB) $(XXLIBS)
+	@ $(ECHO) ... Running $(TEST) benchmark: $*.exe
+	@ .\$*.exe
+	@ $(ECHO) ...... Done
+
+.c.i:
+	$(CC) /P $(EHFLAGS) $(CFLAGS) $(INCLUDES) $<
+
+$(CPHDR) $(CPLIB) $(CPDLL) $(QAPC):
+	@ if exist $(BUILD_DIR)\$@ $(ECHO) Copying $(BUILD_DIR)\$@ && $(CP) $(BUILD_DIR)\$@ .
diff --git a/src/include/pthread/tests/README b/src/include/pthread/tests/README
new file mode 100644
index 0000000..65d46cc
--- /dev/null
+++ b/src/include/pthread/tests/README
@@ -0,0 +1,47 @@
+Running test cases in this directory
+------------------------------------
+
+These make scripts expect to be able to copy the dll, library
+and header files from this directory's parent directory,
+which should be the pthreads-win32 source directory.
+
+MS VC nmake
+-------------
+
+Run the target corresponding to the DLL version being tested:
+ 
+nmake clean VC
+ 
+or:
+ 
+nmake clean VS
+
+
+GNU GCC make
+------------
+
+Run "make clean" and then "make". See the "Known bugs" section
+in ..\README.
+
+
+Writing Test Cases
+------------------
+
+Tests written in this test suite should behave in the following manner:
+
+	* If a test fails, leave main() with a result of 1.
+
+	* If a test succeeds, leave main() with a result of 0.
+
+	* No diagnostic output should appear when the test is succeeding
+	  unless it is particularly useful to visualise test behaviour.
+	  Diagnostic output should be emitted if something in the test
+	  fails, to help determine the cause of the test failure. Use assert()
+	  for all API calls if possible.
+
+Notes:
+------
+
+Many test cases use knowledge of implementation internals which are supposed
+to be opaque to portable applications. These should not be used as examples
+of methods that can be conformantly applied to application code.
diff --git a/src/include/pthread/tests/README.BENCHTESTS b/src/include/pthread/tests/README.BENCHTESTS
new file mode 100644
index 0000000..448570c
--- /dev/null
+++ b/src/include/pthread/tests/README.BENCHTESTS
@@ -0,0 +1,74 @@
+
+------------
+Benchmarking
+------------
+There is a set a benchmarking programs in the
+"tests" directory. These should be runnable using the
+following command-lines corresponding to each of the possible
+library builds:
+
+MSVC:
+nmake clean VC-bench
+nmake clean VCE-bench
+nmake clean VSE-bench
+
+Mingw32:
+make clean GC-bench
+make clean GCE-bench
+
+UWIN:
+The benchtests are run as part of the testsuite.
+
+
+Mutex benchtests
+----------------
+
+benchtest1 - Lock plus unlock on an unlocked mutex.
+benchtest2 - Lock plus unlock on a locked mutex.
+benchtest3 - Trylock on a locked mutex.
+benchtest4 - Trylock plus unlock on an unlocked mutex.
+
+
+Each test times up to three alternate synchronisation
+implementations as a reference, and then times each of
+the four mutex types provided by the library. Each is
+described below:
+
+Simple Critical Section
+- uses a simple Win32 critical section. There is no
+additional overhead for this case as there is in the
+remaining cases.
+
+POSIX mutex implemented using a Critical Section
+- The old implementation which uses runtime adaptation
+depending on the Windows variant being run on. When
+the pthreads DLL was run on WinNT or higher then
+POSIX mutexes would use Win32 Critical Sections.
+
+POSIX mutex implemented using a Win32 Mutex
+- The old implementation which uses runtime adaptation
+depending on the Windows variant being run on. When
+the pthreads DLL was run on Win9x then POSIX mutexes
+would use Win32 Mutexes (because TryEnterCriticalSection
+is not implemented on Win9x).
+
+PTHREAD_MUTEX_DEFAULT
+PTHREAD_MUTEX_NORMAL
+PTHREAD_MUTEX_ERRORCHECK
+PTHREAD_MUTEX_RECURSIVE
+- The current implementation supports these mutex types.
+The underlying basis of POSIX mutexes is now the same
+irrespective of the Windows variant, and should therefore
+have consistent performance.
+
+
+Semaphore benchtests
+--------------------
+
+benchtest5 - Timing for various uncontended cases.
+
+
+In all benchtests, the operation is repeated a large
+number of times and an average is calculated. Loop
+overhead is measured and subtracted from all test times.
+
diff --git a/src/include/pthread/tests/Wmakefile b/src/include/pthread/tests/Wmakefile
new file mode 100644
index 0000000..053880d
--- /dev/null
+++ b/src/include/pthread/tests/Wmakefile
@@ -0,0 +1,365 @@
+# Watcom makefile for the pthreads test suite.
+# If all of the .pass files can be created, the test suite has passed.
+#
+# --------------------------------------------------------------------------
+#
+#      Pthreads-win32 - POSIX Threads Library for Win32
+#      Copyright(C) 1998 John E. Bossom
+#      Copyright(C) 1999,2012 Pthreads-win32 contributors
+# 
+#      Contact Email: rpj@callisto.canberra.edu.au
+# 
+#      The current list of contributors is contained
+#      in the file CONTRIBUTORS included with the source
+#      code distribution. The list can also be seen at the
+#     following World Wide Web location:
+#      https://sourceforge.net/projects/pthreads4w/contributors.html
+# 
+#      This library is free software; you can redistribute it and/or
+#      modify it under the terms of the GNU Lesser General Public
+#      License as published by the Free Software Foundation; either
+#      version 2 of the License, or (at your option) any later version.
+# 
+#      This library is distributed in the hope that it will be useful,
+#      but WITHOUT ANY WARRANTY; without even the implied warranty of
+#      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#      Lesser General Public License for more details.
+# 
+#      You should have received a copy of the GNU Lesser General Public
+#      License along with this library in the file COPYING.LIB;
+#      if not, write to the Free Software Foundation, Inc.,
+#      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+#
+
+
+DLL_VER	= 2
+
+.EXTENSIONS:
+
+.EXTENSIONS: .pass .exe .obj .i .c
+
+CP	= copy
+RM	= erase
+CAT	= type
+MKDIR	= mkdir
+TOUCH	= echo Passed >
+ECHO	= @echo
+
+CPHDR	= pthread.h semaphore.h sched.h
+
+OPTIM	= -od
+
+XXLIBS	=
+
+# C++ Exceptions
+WCEFLAGS	= -xs -d__PtW32NoCatchWarn -d__PTW32_CLEANUP_CXX
+WCELIB	= pthreadWCE$(DLL_VER).lib
+WCEDLL	= pthreadWCE$(DLL_VER).dll
+# C cleanup code
+WCFLAGS	= -d__PTW32_CLEANUP_C
+WCLIB	= pthreadWC$(DLL_VER).lib
+WCDLL	= pthreadWC$(DLL_VER).dll
+# C++ Exceptions in application - using WC version of pthreads dll
+WCXFLAGS	= -xs -d__PTW32_CLEANUP_C
+
+CFLAGS= -w4 -e25 -d_REENTRANT -zq -bm $(OPTIM) -5r -bt=nt -mf -d2
+
+LFLAGS= 
+INCLUDES= -i=.
+BUILD_DIR=..
+
+# The next path is relative to $BUILD_DIR
+QAPC	= # ..\QueueUserAPCEx\User\quserex.dll
+
+COPYFILES	= $(CPHDR) $(CPLIB) $(CPDLL) $(QAPC)
+
+TEST		=
+EHFLAGS	=
+
+# If a test case returns a non-zero exit code to the shell, make will
+# stop.
+
+PASSES	= sizes.pass  &
+	  self1.pass  mutex5.pass  &
+	  mutex1.pass  mutex1n.pass  mutex1e.pass  mutex1r.pass &
+	  semaphore1.pass  semaphore2.pass semaphore3.pass &
+	  mutex2.pass  mutex3.pass  &
+	  mutex2r.pass  mutex2e.pass  mutex3r.pass  mutex3e.pass  &
+	  condvar1.pass  condvar1_1.pass  condvar1_2.pass  condvar2.pass  condvar2_1.pass  &
+	  exit1.pass  create1.pass  create2.pass  reuse1.pass  reuse2.pass  equal1.pass  &
+	  sequence1.pass  kill1.pass  valid1.pass  valid2.pass  &
+	  exit2.pass  exit3.pass  exit4  exit5  &
+	  join0.pass  join1.pass  detach1.pass  join2.pass join3.pass join4.pass  &
+	  mutex4.pass  mutex6.pass  mutex6n.pass  mutex6e.pass  mutex6r.pass  &
+	  mutex6s.pass  mutex6es.pass  mutex6rs.pass  &
+	  mutex7.pass  mutex7n.pass  mutex7e.pass  mutex7r.pass  &
+	  mutex8.pass  mutex8n.pass  mutex8e.pass  mutex8r.pass  &
+	  robust1.pass  robust2.pass  robust3.pass  robust4.pass  robust5.pass  &
+	  count1.pass  &
+	  once1.pass  once2.pass  once3.pass  once4.pass  tsd1.pass  &
+	  self2.pass  &
+	  cancel1.pass  cancel2.pass  &
+	  semaphore4.pass semaphore4t.pass semaphore5.pass &
+	  delay1.pass  delay2.pass  eyal1.pass  &
+	  condvar3.pass  condvar3_1.pass  condvar3_2.pass  condvar3_3.pass  &
+	  condvar4.pass  condvar5.pass  condvar6.pass  &
+	  condvar7.pass  condvar8.pass  condvar9.pass  &
+	  errno1.pass  &
+	  rwlock1.pass  rwlock2.pass  rwlock3.pass  rwlock4.pass  rwlock5.pass  &
+	  rwlock6.pass  rwlock7.pass  rwlock8.pass  &
+	  rwlock2_t.pass  rwlock3_t.pass  rwlock4_t.pass  rwlock5_t.pass  rwlock6_t.pass  rwlock6_t2.pass  &
+	  context1.pass  &
+	  cancel3.pass  cancel4.pass  cancel5.pass  cancel6a.pass  cancel6d.pass  &
+	  cancel7  cancel8  &
+	  cleanup0.pass  cleanup1.pass  cleanup2.pass  cleanup3.pass  &
+	  priority1.pass priority2.pass inherit1.pass  &
+	  spin1.pass  spin2.pass  spin3.pass  spin4.pass  &
+	  barrier1.pass  barrier2.pass  barrier3.pass  barrier4.pass  barrier5.pass  &
+	  exception1.pass  exception2.pass  exception3_0.pass  exception3.pass  &
+	  cancel9.pass  &
+	  affinity1.pass  affinity2.pass  affinity3.pass  affinity4.pass  affinity5.pass  &
+	  stress1.pass
+
+BENCHRESULTS = &
+	  benchtest1.bench benchtest2.bench benchtest3.bench benchtest4.bench benchtest5.bench
+
+help: .SYMBOLIC
+	@ $(ECHO) Run one of the following command lines:
+	@ $(ECHO) wmake /f Wmakefile clean WC    (to test using WC dll with wcc386 (no EH) applications)
+	@ $(ECHO) wmake /f Wmakefile clean WCX   (to test using WC dll with wpp386 (EH) applications)
+	@ $(ECHO) wmake /f Wmakefile clean WCE   (to test using the WCE dll with wpp386 EH applications)
+	@ $(ECHO) wmake /f Wmakefile clean WC-bench    (to benchtest using WC dll with C bench app)
+	@ $(ECHO) wmake /f Wmakefile clean WCX-bench   (to benchtest using WC dll with C++ bench app)
+	@ $(ECHO) wmake /f Wmakefile clean WCE-bench   (to benchtest using WCE dll with C++ bench app)
+
+all: .SYMBOLIC
+	@ wmake /f Wmakefile clean WC
+	@ wmake /f Wmakefile clean WCX
+	@ wmake /f Wmakefile clean WCE
+	@ wmake /f Wmakefile clean WSE
+	@ wmake /f Wmakefile clean WC-bench
+
+tests: $(CPLIB) $(CPDLL) $(CPHDR) $(PASSES) .SYMBOLIC
+	@ $(ECHO) ALL TESTS PASSED! Congratulations!
+
+benchtests: $(CPLIB) $(CPDLL) $(CPHDR) $(XXLIBS) $(BENCHRESULTS) .SYMBOLIC
+	@ $(ECHO) ALL BENCH TESTS DONE.
+
+$(BENCHRESULTS): ($[*).exe
+	@ $(ECHO) ... Running $(TEST) benchtest: ($[*).exe
+	@ .\($[*).exe
+	@ $(ECHO) ...... Done
+	@ $(TOUCH) ($[*).bench
+
+WCE: .SYMBOLIC
+	@ wmake /f Wmakefile CC=wpp386 TEST="$@" CPLIB="$(WCELIB)" CPDLL="$(WCEDLL)" EHFLAGS="$(WCEFLAGS)" tests
+
+WC: .SYMBOLIC
+	@ wmake /f Wmakefile CC=wcc386 TEST="$@" CPLIB="$(WCLIB)" CPDLL="$(WCDLL)" EHFLAGS="$(WCFLAGS)" tests
+
+WCX: .SYMBOLIC
+	@ wmake /f Wmakefile CC=wpp386 TEST="$@" CPLIB="$(WCLIB)" CPDLL="$(WCDLL)" EHFLAGS="$(WCXFLAGS)" tests
+
+WCE-bench: .SYMBOLIC
+	@ wmake /f Wmakefile CC=wpp386 TEST="$@" CPLIB="$(WCELIB)" CPDLL="$(WCEDLL)" EHFLAGS="$(WCEFLAGS)" XXLIBS="benchlib.o" benchtests
+
+WC-bench: .SYMBOLIC
+	@ wmake /f Wmakefile CC=wcc386 TEST="$@" CPLIB="$(WCLIB)" CPDLL="$(WCDLL)" EHFLAGS="$(WCFLAGS)" XXLIBS="benchlib.o" benchtests
+
+WCX-bench: .SYMBOLIC
+	@ wmake /f Wmakefile CC=wpp386 TEST="$@" CPLIB="$(WCLIB)" CPDLL="$(WCDLL)" EHFLAGS="$(WCXFLAGS)" XXLIBS="benchlib.o" benchtests
+
+sizes.pass: sizes.exe
+	@ $(ECHO) ... Running $(TEST) test: $^*
+	@ $[@ > SIZES.$(TEST)
+	@ $(CAT) SIZES.$(TEST)
+	@ $(ECHO) ...... Passed
+	@ $(TOUCH) $^@
+
+.exe.pass:
+	@ $(ECHO) ... Running $(TEST) test: $^*
+	@ $[@
+	@ $(ECHO) ...... Passed
+	@ $(TOUCH) $^@
+
+.obj.exe:
+	@ $(ECHO) wlink NAME $^@ FILE $[@ LIBRARY $(CPLIB) OPTION quiet
+	@ wlink NAME $^@ FILE $[@ LIBRARY $(CPLIB) OPTION quiet
+
+.c.obj:
+	@ $(ECHO) $(CC) $^* $(EHFLAGS) $(CFLAGS) $(INCLUDES)
+	@ $(CC) $^* $(EHFLAGS) $(CFLAGS) $(INCLUDES)
+
+.c.i:
+	@ $(CC) /P $(EHFLAGS) $(CFLAGS) $(INCLUDES) $<
+
+$(COPYFILES): .SYMBOLIC
+	@ $(ECHO) Copying $(BUILD_DIR)\$@
+	@ $(CP) $(BUILD_DIR)\$@ .
+
+pthread.dll:
+	@ $(CP) $(CPDLL) $*.dll
+	@ $(CP) $(CPLIB) $*.lib
+
+clean: .SYMBOLIC
+	@ if exist *.dll $(RM) *.dll
+	@ if exist *.lib $(RM) *.lib
+	@ if exist *.err $(RM) *.err
+	@ if exist pthread.h $(RM) pthread.h
+	@ if exist semaphore.h $(RM) semaphore.h
+	@ if exist sched.h $(RM) sched.h
+	@ if exist *.e $(RM) *.e
+	@ if exist *.i $(RM) *.i
+	@ if exist *.obj $(RM) *.obj
+	@ if exist *.pdb $(RM) *.pdb
+	@ if exist *.o $(RM) *.o
+	@ if exist *.asm $(RM) *.asm
+	@ if exist *.exe $(RM) *.exe
+	@ if exist *.manifest $(RM) *.manifest
+	@ if exist *.pass $(RM) *.pass
+	@ if exist *.bench $(RM) *.bench
+	@ if exist *.log $(RM) *.log
+	@ $(ECHO) Clean completed.
+
+benchtest1.bench:
+benchtest2.bench:
+benchtest3.bench:
+benchtest4.bench:
+benchtest5.bench:
+
+affinity1.pass:
+affinity2.pass: affinity1.pass
+affinity3.pass: affinity2.pass
+affinity4.pass: affinity3.pass
+affinity5.pass: affinity4.pass
+barrier1.pass: semaphore4.pass
+barrier2.pass: barrier1.pass
+barrier3.pass: barrier2.pass
+barrier4.pass: barrier3.pass
+barrier5.pass: barrier4.pass
+cancel1.pass: create1.pass
+cancel2.pass: cancel1.pass
+cancel3.pass: context1.pass
+cancel4.pass: cancel3.pass
+cancel5.pass: cancel3.pass
+cancel6a.pass: cancel3.pass
+cancel6d.pass: cancel3.pass
+cancel7.pass: kill1.pass
+cancel8.pass: cancel7.pass
+cleanup0.pass: cancel5.pass
+cleanup1.pass: cleanup0.pass
+cleanup2.pass: cleanup1.pass
+cleanup3.pass: cleanup2.pass
+condvar1.pass:
+condvar1_1.pass: condvar1.pass
+condvar1_2.pass: join2.pass
+condvar2.pass: condvar1.pass
+condvar2_1.pass: condvar2.pass join2.pass
+condvar3.pass: create1.pass condvar2.pass
+condvar3_1.pass: condvar3.pass join2.pass
+condvar3_2.pass: condvar3_1.pass
+condvar3_3.pass: condvar3_2.pass
+condvar4.pass: create1.pass
+condvar5.pass: condvar4.pass
+condvar6.pass: condvar5.pass
+condvar7.pass: condvar6.pass cleanup1.pass
+condvar8.pass: condvar7.pass
+condvar9.pass: condvar8.pass
+context1.pass: cancel1.pass
+count1.pass: join1.pass
+create1.pass: mutex2.pass
+create2.pass: create1.pass
+delay1.pass:
+delay2.pass: delay1.pass
+detach1.pass: join0.pass
+equal1.pass: create1.pass
+errno1.pass: mutex3.pass
+exception1.pass: cancel4.pass
+exception2.pass: exception1.pass
+exception3_0.pass: exception2.pass
+exception3.pass: exception3_0.pass
+exit1.pass:
+exit2.pass: create1.pass
+exit3.pass: create1.pass
+exit4.pass:
+exit5.pass: kill1.pass
+eyal1.pass: tsd1.pass
+inherit1.pass: join1.pass priority1.pass
+join0.pass: create1.pass
+join1.pass: create1.pass
+join2.pass: create1.pass
+join3.pass: join2.pass
+join4.pass: join3.pass
+kill1.pass: 
+mutex1.pass: self1.pass
+mutex1n.pass: mutex1.pass
+mutex1e.pass: mutex1.pass
+mutex1r.pass: mutex1.pass
+mutex2.pass: mutex1.pass
+mutex2r.pass: mutex2.pass
+mutex2e.pass: mutex2.pass
+mutex3.pass: create1.pass
+mutex3r.pass: mutex3.pass
+mutex3e.pass: mutex3.pass
+mutex4.pass: mutex3.pass
+mutex5.pass:
+mutex6.pass: mutex4.pass
+mutex6n.pass: mutex4.pass
+mutex6e.pass: mutex4.pass
+mutex6r.pass: mutex4.pass
+mutex6s.pass: mutex6.pass
+mutex6rs.pass: mutex6r.pass
+mutex6es.pass: mutex6e.pass
+mutex7.pass: mutex6.pass
+mutex7n.pass: mutex6n.pass
+mutex7e.pass: mutex6e.pass
+mutex7r.pass: mutex6r.pass
+mutex8.pass: mutex7.pass
+mutex8n.pass: mutex7n.pass
+mutex8e.pass: mutex7e.pass
+mutex8r.pass: mutex7r.pass
+once1.pass: create1.pass
+once2.pass: once1.pass
+once3.pass: once2.pass
+once4.pass: once3.pass
+priority1.pass: join1.pass
+priority2.pass: priority1.pass barrier3.pass
+reuse1.pass: create2.pass
+reuse2.pass: reuse1.pass
+robust1.pass: mutex8r.pass
+robust2.pass: mutex8r.pass
+robust3.pass: robust2.pass
+robust4.pass: robust3.pass
+robust5.pass: robust4.pass
+rwlock1.pass: condvar6.pass
+rwlock2.pass: rwlock1.pass
+rwlock3.pass: rwlock2.pass join2.pass
+rwlock4.pass: rwlock3.pass
+rwlock5.pass: rwlock4.pass
+rwlock6.pass: rwlock5.pass
+rwlock7.pass: rwlock6.pass
+rwlock2_t.pass: rwlock2.pass
+rwlock3_t.pass: rwlock2_t.pass
+rwlock4_t.pass: rwlock3_t.pass
+rwlock5_t.pass: rwlock4_t.pass
+rwlock6_t.pass: rwlock5_t.pass
+rwlock6_t2.pass: rwlock6_t.pass
+self1.pass:
+self2.pass: create1.pass
+semaphore1.pass:
+semaphore2.pass:
+semaphore3.pass: semaphore2.pass
+semaphore4.pass: semaphore3.pass cancel1.pass
+semaphore4t.pass: semaphore4.pass
+semaphore5.pass: semaphore4.pass
+sequence1.pass: reuse2.pass
+sizes.pass:
+spin1.pass:
+spin2.pass: spin1.pass
+spin3.pass: spin2.pass
+spin4.pass: spin3.pass
+stress1.pass:
+tsd1.pass: join1.pass
+valid1.pass: join1.pass
+valid2.pass: valid1.pass
+cancel9.pass: cancel8.pass
diff --git a/src/include/pthread/tests/affinity1.c b/src/include/pthread/tests/affinity1.c
new file mode 100644
index 0000000..4c4577e
--- /dev/null
+++ b/src/include/pthread/tests/affinity1.c
@@ -0,0 +1,123 @@
+/*
+ * affinity1.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Basic test of CPU_*() support routines.
+ *
+ */
+
+#if ! defined(WINCE)
+
+#include "test.h"
+
+int
+main()
+{
+  unsigned int cpu;
+  cpu_set_t newmask;
+  cpu_set_t src1mask;
+  cpu_set_t src2mask;
+  cpu_set_t src3mask;
+
+  CPU_ZERO(&newmask);
+  CPU_ZERO(&src1mask);
+  memset(&src2mask, 0, sizeof(cpu_set_t));
+  assert(memcmp(&src1mask, &src2mask, sizeof(cpu_set_t)) == 0);
+  assert(CPU_EQUAL(&src1mask, &src2mask));
+  assert(CPU_COUNT(&src1mask) == 0);
+
+  CPU_ZERO(&src1mask);
+  CPU_ZERO(&src2mask);
+  CPU_ZERO(&src3mask);
+
+  for (cpu = 0; cpu < sizeof(cpu_set_t)*8; cpu += 2)
+    {
+	  CPU_SET(cpu, &src1mask);					/* 0b01010101010101010101010101010101 */
+    }
+  for (cpu = 0; cpu < sizeof(cpu_set_t)*4; cpu++)
+    {
+	  CPU_SET(cpu, &src2mask);					/* 0b00000000000000001111111111111111 */
+    }
+  for (cpu = sizeof(cpu_set_t)*4; cpu < sizeof(cpu_set_t)*8; cpu += 2)
+  {
+	  CPU_SET(cpu, &src2mask);					/* 0b01010101010101011111111111111111 */
+  }
+  for (cpu = 0; cpu < sizeof(cpu_set_t)*8; cpu += 2)
+    {
+	  CPU_SET(cpu, &src3mask);					/* 0b01010101010101010101010101010101 */
+    }
+
+  assert(CPU_COUNT(&src1mask) == (sizeof(cpu_set_t)*4));
+  assert(CPU_COUNT(&src2mask) == ((sizeof(cpu_set_t)*4 + (sizeof(cpu_set_t)*2))));
+  assert(CPU_COUNT(&src3mask) == (sizeof(cpu_set_t)*4));
+  CPU_SET(0, &newmask);
+  CPU_SET(1, &newmask);
+  CPU_SET(3, &newmask);
+  assert(CPU_ISSET(1, &newmask));
+  CPU_CLR(1, &newmask);
+  assert(!CPU_ISSET(1, &newmask));
+  CPU_OR(&newmask, &src1mask, &src2mask);
+  assert(CPU_EQUAL(&newmask, &src2mask));
+  CPU_AND(&newmask, &src1mask, &src2mask);
+  assert(CPU_EQUAL(&newmask, &src1mask));
+  CPU_XOR(&newmask, &src1mask, &src3mask);
+  memset(&src2mask, 0, sizeof(cpu_set_t));
+  assert(memcmp(&newmask, &src2mask, sizeof(cpu_set_t)) == 0);
+
+  /*
+   * Need to confirm the bitwise logical right-shift in CpuCount().
+   * i.e. zeros inserted into MSB on shift because cpu_set_t is
+   * unsigned.
+   */
+  CPU_ZERO(&src1mask);
+  for (cpu = 1; cpu < sizeof(cpu_set_t)*8; cpu += 2)
+    {
+	  CPU_SET(cpu, &src1mask);					/* 0b10101010101010101010101010101010 */
+    }
+  assert(CPU_ISSET(sizeof(cpu_set_t)*8-1, &src1mask));
+  assert(CPU_COUNT(&src1mask) == (sizeof(cpu_set_t)*4));
+
+  return 0;
+}
+
+#else
+
+#include <stdio.h>
+
+int
+main()
+{
+  fprintf(stderr, "Test N/A for this target environment.\n");
+  return 0;
+}
+
+#endif
diff --git a/src/include/pthread/tests/affinity2.c b/src/include/pthread/tests/affinity2.c
new file mode 100644
index 0000000..73bfb4b
--- /dev/null
+++ b/src/include/pthread/tests/affinity2.c
@@ -0,0 +1,114 @@
+/*
+ * affinity2.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Have the process switch CPUs.
+ *
+ */
+
+#if ! defined(WINCE)
+
+#include "test.h"
+
+int
+main()
+{
+  unsigned int cpu;
+  int result;
+  cpu_set_t newmask;
+  cpu_set_t mask;
+  cpu_set_t switchmask;
+  cpu_set_t flipmask;
+
+  CPU_ZERO(&mask);
+  CPU_ZERO(&switchmask);
+  CPU_ZERO(&flipmask);
+
+  for (cpu = 0; cpu < sizeof(cpu_set_t)*8; cpu += 2)
+    {
+	  CPU_SET(cpu, &switchmask);				/* 0b01010101010101010101010101010101 */
+    }
+  for (cpu = 0; cpu < sizeof(cpu_set_t)*8; cpu++)
+    {
+	  CPU_SET(cpu, &flipmask);					/* 0b11111111111111111111111111111111 */
+    }
+
+  assert(sched_getaffinity(0, sizeof(cpu_set_t), &newmask) == 0);
+  assert(!CPU_EQUAL(&newmask, &mask));
+
+  result = sched_setaffinity(0, sizeof(cpu_set_t), &newmask);
+  if (result != 0)
+	{
+	  int err =
+#if defined (__PTW32_USES_SEPARATE_CRT)
+	  GetLastError();
+#else
+      errno;
+#endif
+
+	  assert(err != ESRCH);
+	  assert(err != EFAULT);
+	  assert(err != EPERM);
+	  assert(err != EINVAL);
+	  assert(err != EAGAIN);
+	  assert(err == ENOSYS);
+	  assert(CPU_COUNT(&mask) == 1);
+	}
+  else
+	{
+	  if (CPU_COUNT(&mask) > 1)
+		{
+		  CPU_AND(&newmask, &mask, &switchmask); /* Remove every other CPU */
+		  assert(sched_setaffinity(0, sizeof(cpu_set_t), &newmask) == 0);
+		  assert(sched_getaffinity(0, sizeof(cpu_set_t), &mask) == 0);
+		  CPU_XOR(&newmask, &mask, &flipmask);  /* Switch to all alternative CPUs */
+		  assert(sched_setaffinity(0, sizeof(cpu_set_t), &newmask) == 0);
+		  assert(sched_getaffinity(0, sizeof(cpu_set_t), &mask) == 0);
+		  assert(!CPU_EQUAL(&newmask, &mask));
+		}
+	}
+
+  return 0;
+}
+
+#else
+
+#include <stdio.h>
+
+int
+main()
+{
+  fprintf(stderr, "Test N/A for this target environment.\n");
+  return 0;
+}
+
+#endif
diff --git a/src/include/pthread/tests/affinity3.c b/src/include/pthread/tests/affinity3.c
new file mode 100644
index 0000000..be3d61c
--- /dev/null
+++ b/src/include/pthread/tests/affinity3.c
@@ -0,0 +1,117 @@
+/*
+ * affinity3.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Have the thread switch CPUs.
+ *
+ */
+
+#if ! defined(WINCE)
+
+#include "test.h"
+
+int
+main()
+{
+  int result;
+  unsigned int cpu;
+  cpu_set_t newmask;
+  cpu_set_t processCpus;
+  cpu_set_t mask;
+  cpu_set_t switchmask;
+  cpu_set_t flipmask;
+  pthread_t self = pthread_self();
+
+  CPU_ZERO(&mask);
+  CPU_ZERO(&switchmask);
+  CPU_ZERO(&flipmask);
+
+  if (pthread_getaffinity_np(self, sizeof(cpu_set_t), &processCpus) == ENOSYS)
+    {
+      printf("pthread_get/set_affinity_np API not supported for this platform: skipping test.");
+      return 0;
+    }
+  assert(pthread_getaffinity_np(self, sizeof(cpu_set_t), &processCpus) == 0);
+  printf("This thread has a starting affinity with %d CPUs\n", CPU_COUNT(&processCpus));
+  assert(!CPU_EQUAL(&mask, &processCpus));
+
+  for (cpu = 0; cpu < sizeof(cpu_set_t)*8; cpu += 2)
+    {
+	  CPU_SET(cpu, &switchmask);				/* 0b01010101010101010101010101010101 */
+    }
+  for (cpu = 0; cpu < sizeof(cpu_set_t)*8; cpu++)
+    {
+	  CPU_SET(cpu, &flipmask);					/* 0b11111111111111111111111111111111 */
+    }
+
+  result = pthread_setaffinity_np(self, sizeof(cpu_set_t), &processCpus);
+  if (result != 0)
+	{
+	  assert(result != ESRCH);
+	  assert(result != EFAULT);
+	  assert(result != EPERM);
+	  assert(result != EINVAL);
+	  assert(result != EAGAIN);
+	  assert(result == ENOSYS);
+	  assert(CPU_COUNT(&mask) == 1);
+	}
+  else
+	{
+	  if (CPU_COUNT(&mask) > 1)
+		{
+		  CPU_AND(&newmask, &processCpus, &switchmask); /* Remove every other CPU */
+		  assert(pthread_setaffinity_np(self, sizeof(cpu_set_t), &newmask) == 0);
+		  assert(pthread_getaffinity_np(self, sizeof(cpu_set_t), &mask) == 0);
+		  assert(CPU_EQUAL(&mask, &newmask));
+		  CPU_XOR(&newmask, &mask, &flipmask);  /* Switch to all alternative CPUs */
+		  assert(!CPU_EQUAL(&mask, &newmask));
+		  assert(pthread_setaffinity_np(self, sizeof(cpu_set_t), &newmask) == 0);
+		  assert(pthread_getaffinity_np(self, sizeof(cpu_set_t), &mask) == 0);
+		  assert(CPU_EQUAL(&mask, &newmask));
+		}
+	}
+
+  return 0;
+}
+
+#else
+
+#include <stdio.h>
+
+int
+main()
+{
+  fprintf(stderr, "Test N/A for this target environment.\n");
+  return 0;
+}
+
+#endif
diff --git a/src/include/pthread/tests/affinity4.c b/src/include/pthread/tests/affinity4.c
new file mode 100644
index 0000000..eabf92a
--- /dev/null
+++ b/src/include/pthread/tests/affinity4.c
@@ -0,0 +1,88 @@
+/*
+ * affinity4.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test thread CPU affinity setting.
+ *
+ */
+
+#if ! defined(WINCE)
+
+#include "test.h"
+
+int
+main()
+{
+  unsigned int cpu;
+  cpu_set_t threadCpus;
+  DWORD_PTR vThreadMask;
+  cpu_set_t keepCpus;
+  pthread_t self = pthread_self();
+
+  if (pthread_getaffinity_np(self, sizeof(cpu_set_t), &threadCpus) == ENOSYS)
+    {
+      printf("pthread_get/set_affinity_np API not supported for this platform: skipping test.");
+      return 0;
+    }
+
+  CPU_ZERO(&keepCpus);
+  for (cpu = 1; cpu < sizeof(cpu_set_t)*8; cpu += 2)
+    {
+	  CPU_SET(cpu, &keepCpus);					/* 0b10101010101010101010101010101010 */
+    }
+
+  assert(pthread_getaffinity_np(self, sizeof(cpu_set_t), &threadCpus) == 0);
+  if (CPU_COUNT(&threadCpus) > 1)
+    {
+	  CPU_AND(&threadCpus, &threadCpus, &keepCpus);
+	  vThreadMask = SetThreadAffinityMask(GetCurrentThread(), (*(PDWORD_PTR)&threadCpus) /* Violating Opacity */);
+	  assert(pthread_setaffinity_np(self, sizeof(cpu_set_t), &threadCpus) == 0);
+	  vThreadMask = SetThreadAffinityMask(GetCurrentThread(), vThreadMask);
+	  assert(vThreadMask != 0);
+	  assert(memcmp(&vThreadMask, &threadCpus, sizeof(DWORD_PTR)) == 0);
+    }
+
+  return 0;
+}
+
+#else
+
+#include <stdio.h>
+
+int
+main()
+{
+  fprintf(stderr, "Test N/A for this target environment.\n");
+  return 0;
+}
+
+#endif
diff --git a/src/include/pthread/tests/affinity5.c b/src/include/pthread/tests/affinity5.c
new file mode 100644
index 0000000..538ad9d
--- /dev/null
+++ b/src/include/pthread/tests/affinity5.c
@@ -0,0 +1,121 @@
+/*
+ * affinity5.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test thread CPU affinity inheritance.
+ *
+ */
+
+#if ! defined(WINCE)
+
+#include "test.h"
+
+typedef union
+{
+	/* Violates opacity */
+	cpu_set_t cpuset;
+	unsigned long int bits;  /* To stop GCC complaining about %lx args to printf */
+} cpuset_to_ulint;
+
+void *
+mythread(void * arg)
+{
+  HANDLE threadH = GetCurrentThread();
+  cpu_set_t *parentCpus = (cpu_set_t*) arg;
+  cpu_set_t threadCpus;
+  DWORD_PTR vThreadMask;
+  cpuset_to_ulint a, b;
+
+  assert(pthread_getaffinity_np(pthread_self(), sizeof(cpu_set_t), &threadCpus) == 0);
+  assert(CPU_EQUAL(parentCpus, &threadCpus));
+  vThreadMask = SetThreadAffinityMask(threadH, (*(PDWORD_PTR)&threadCpus) /* Violating Opacity */);
+  assert(vThreadMask != 0);
+  assert(memcmp(&vThreadMask, &threadCpus, sizeof(DWORD_PTR)) == 0);
+  a.cpuset = *parentCpus;
+  b.cpuset = threadCpus;
+  /* Violates opacity */
+  printf("CPU affinity: Parent/Thread = 0x%lx/0x%lx\n", a.bits, b.bits);
+
+  return (void*) 0;
+}
+
+int
+main()
+{
+  unsigned int cpu;
+  pthread_t tid;
+  cpu_set_t threadCpus;
+  DWORD_PTR vThreadMask;
+  cpu_set_t keepCpus;
+  pthread_t self = pthread_self();
+
+  if (pthread_getaffinity_np(self, sizeof(cpu_set_t), &threadCpus) == ENOSYS)
+    {
+      printf("pthread_get/set_affinity_np API not supported for this platform: skipping test.");
+      return 0;
+    }
+
+  CPU_ZERO(&keepCpus);
+  for (cpu = 1; cpu < sizeof(cpu_set_t)*8; cpu += 2)
+    {
+	  CPU_SET(cpu, &keepCpus);					/* 0b10101010101010101010101010101010 */
+    }
+
+  assert(pthread_getaffinity_np(self, sizeof(cpu_set_t), &threadCpus) == 0);
+  if (CPU_COUNT(&threadCpus) > 1)
+    {
+	  assert(pthread_create(&tid, NULL, mythread, (void*)&threadCpus) == 0);
+	  assert(pthread_join(tid, NULL) == 0);
+	  CPU_AND(&threadCpus, &threadCpus, &keepCpus);
+	  assert(pthread_setaffinity_np(self, sizeof(cpu_set_t), &threadCpus) == 0);
+	  vThreadMask = SetThreadAffinityMask(GetCurrentThread(), (*(PDWORD_PTR)&threadCpus) /* Violating Opacity */);
+	  assert(vThreadMask != 0);
+	  assert(memcmp(&vThreadMask, &threadCpus, sizeof(DWORD_PTR)) == 0);
+	  assert(pthread_create(&tid, NULL, mythread, (void*)&threadCpus) == 0);
+	  assert(pthread_join(tid, NULL) == 0);
+    }
+
+  return 0;
+}
+
+#else
+
+#include <stdio.h>
+
+int
+main()
+{
+  fprintf(stderr, "Test N/A for this target environment.\n");
+  return 0;
+}
+
+#endif
diff --git a/src/include/pthread/tests/affinity6.c b/src/include/pthread/tests/affinity6.c
new file mode 100644
index 0000000..4b9190c
--- /dev/null
+++ b/src/include/pthread/tests/affinity6.c
@@ -0,0 +1,116 @@
+/*
+ * affinity6.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test thread CPU affinity from thread attributes.
+ *
+ */
+
+#if ! defined(WINCE)
+
+#include "test.h"
+
+typedef union
+{
+        /* Violates opacity */
+        cpu_set_t cpuset;
+        unsigned long int bits;  /* To stop GCC complaining about %lx args to printf */
+} cpuset_to_ulint;
+
+void *
+mythread(void * arg)
+{
+  pthread_attr_t *attrPtr = (pthread_attr_t *) arg;
+  cpu_set_t threadCpus, attrCpus;
+
+  assert(pthread_getaffinity_np(pthread_self(), sizeof(cpu_set_t), &threadCpus) == 0);
+  assert(pthread_attr_getaffinity_np(attrPtr, sizeof(cpu_set_t), &attrCpus) == 0);
+  assert(CPU_EQUAL(&attrCpus, &threadCpus));
+
+  return (void*) 0;
+}
+
+int
+main()
+{
+  unsigned int cpu;
+  pthread_t tid;
+  pthread_attr_t attr1, attr2;
+  cpu_set_t threadCpus;
+  cpu_set_t keepCpus;
+  pthread_t self = pthread_self();
+
+  if (pthread_getaffinity_np(self, sizeof(cpu_set_t), &threadCpus) == ENOSYS)
+    {
+      printf("pthread_get/set_affinity_np API not supported for this platform: skipping test.");
+      return 0;
+    }
+
+  assert(pthread_attr_init(&attr1) == 0);
+  assert(pthread_attr_init(&attr2) == 0);
+
+  CPU_ZERO(&keepCpus);
+  for (cpu = 1; cpu < sizeof(cpu_set_t)*8; cpu += 2)
+    {
+          CPU_SET(cpu, &keepCpus);                                      /* 0b10101010101010101010101010101010 */
+    }
+
+  assert(pthread_getaffinity_np(self, sizeof(cpu_set_t), &threadCpus) == 0);
+
+  if (CPU_COUNT(&threadCpus) > 1)
+    {
+          assert(pthread_attr_setaffinity_np(&attr1, sizeof(cpu_set_t), &threadCpus) == 0);
+          CPU_AND(&threadCpus, &threadCpus, &keepCpus);
+          assert(pthread_attr_setaffinity_np(&attr2, sizeof(cpu_set_t), &threadCpus) == 0);
+
+          assert(pthread_create(&tid, &attr1, mythread, (void *) &attr1) == 0);
+          assert(pthread_join(tid, NULL) == 0);
+          assert(pthread_create(&tid, &attr2, mythread, (void *) &attr2) == 0);
+          assert(pthread_join(tid, NULL) == 0);
+    }
+  assert(pthread_attr_destroy(&attr1) == 0);
+  assert(pthread_attr_destroy(&attr2) == 0);
+  return 0;
+}
+
+#else
+
+#include <stdio.h>
+
+int
+main()
+{
+  fprintf(stderr, "Test N/A for this target environment.\n");
+  return 0;
+}
+
+#endif
diff --git a/src/include/pthread/tests/barrier1.c b/src/include/pthread/tests/barrier1.c
new file mode 100644
index 0000000..677be2b
--- /dev/null
+++ b/src/include/pthread/tests/barrier1.c
@@ -0,0 +1,56 @@
+/* 
+ * barrier1.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Create a barrier object and then destroy it.
+ *
+ */
+
+#include "test.h"
+
+pthread_barrier_t barrier = NULL;
+
+int
+main()
+{
+  assert(barrier == NULL);
+
+  assert(pthread_barrier_init(&barrier, NULL, 1) == 0);
+
+  assert(barrier != NULL);
+
+  assert(pthread_barrier_destroy(&barrier) == 0);
+
+  assert(barrier == NULL);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/barrier2.c b/src/include/pthread/tests/barrier2.c
new file mode 100644
index 0000000..6d40c05
--- /dev/null
+++ b/src/include/pthread/tests/barrier2.c
@@ -0,0 +1,53 @@
+/* 
+ * barrier2.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Declare a single barrier object, wait on it, 
+ * and then destroy it.
+ *
+ */
+
+#include "test.h"
+ 
+pthread_barrier_t barrier = NULL;
+
+int
+main()
+{
+  assert(pthread_barrier_init(&barrier, NULL, 1) == 0);
+
+  assert(pthread_barrier_wait(&barrier) == PTHREAD_BARRIER_SERIAL_THREAD);
+
+  assert(pthread_barrier_destroy(&barrier) == 0);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/barrier3.c b/src/include/pthread/tests/barrier3.c
new file mode 100644
index 0000000..1775c79
--- /dev/null
+++ b/src/include/pthread/tests/barrier3.c
@@ -0,0 +1,69 @@
+/*
+ * barrier3.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Declare a single barrier object with barrier attribute, wait on it, 
+ * and then destroy it.
+ *
+ */
+
+#include "test.h"
+ 
+pthread_barrier_t barrier = NULL;
+static void* result = (void*)1;
+
+void * func(void * arg)
+{
+  return (void *) (size_t)pthread_barrier_wait(&barrier);
+}
+ 
+int
+main()
+{
+  pthread_t t;
+  pthread_barrierattr_t ba;
+
+  assert(pthread_barrierattr_init(&ba) == 0);
+  assert(pthread_barrierattr_setpshared(&ba, PTHREAD_PROCESS_PRIVATE) == 0);
+  assert(pthread_barrier_init(&barrier, &ba, 1) == 0);
+
+  assert(pthread_create(&t, NULL, func, NULL) == 0);
+
+  assert(pthread_join(t, &result) == 0);
+
+  assert((int)(size_t)result == PTHREAD_BARRIER_SERIAL_THREAD);
+
+  assert(pthread_barrier_destroy(&barrier) == 0);
+  assert(pthread_barrierattr_destroy(&ba) == 0);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/barrier4.c b/src/include/pthread/tests/barrier4.c
new file mode 100644
index 0000000..04756c1
--- /dev/null
+++ b/src/include/pthread/tests/barrier4.c
@@ -0,0 +1,108 @@
+/*
+ * barrier4.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Declare a single barrier object, multiple wait on it, 
+ * and then destroy it.
+ *
+ */
+
+#include "test.h"
+
+enum {
+  NUMTHREADS = 16
+};
+ 
+pthread_barrier_t barrier = NULL;
+pthread_mutex_t mx = PTHREAD_MUTEX_INITIALIZER;
+static int serialThreadCount = 0;
+static int otherThreadCount = 0;
+
+void *
+func(void * arg)
+{
+  int result = pthread_barrier_wait(&barrier);
+
+  assert(pthread_mutex_lock(&mx) == 0);
+
+  if (result == PTHREAD_BARRIER_SERIAL_THREAD)
+    {
+      serialThreadCount++;
+    }
+  else if (0 == result)
+    {
+      otherThreadCount++;
+    }
+  else
+    {
+      printf("Barrier wait failed: error = %s\n", error_string[result]);
+      fflush(stdout);
+      return NULL;
+    }
+  assert(pthread_mutex_unlock(&mx) == 0);
+
+  return NULL;
+}
+
+int
+main()
+{
+  int i, j;
+  pthread_t t[NUMTHREADS + 1];
+
+  for (j = 1; j <= NUMTHREADS; j++)
+    {
+      printf("Barrier height = %d\n", j);
+
+      serialThreadCount = 0;
+
+      assert(pthread_barrier_init(&barrier, NULL, j) == 0);
+
+      for (i = 1; i <= j; i++)
+        {
+          assert(pthread_create(&t[i], NULL, func, NULL) == 0);
+        }
+
+      for (i = 1; i <= j; i++)
+        {
+          assert(pthread_join(t[i], NULL) == 0);
+        }
+
+      assert(serialThreadCount == 1);
+
+      assert(pthread_barrier_destroy(&barrier) == 0);
+    }
+
+  assert(pthread_mutex_destroy(&mx) == 0);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/barrier5.c b/src/include/pthread/tests/barrier5.c
new file mode 100644
index 0000000..ed41cd8
--- /dev/null
+++ b/src/include/pthread/tests/barrier5.c
@@ -0,0 +1,116 @@
+/*
+ * barrier5.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Set up a series of barriers at different heights and test various numbers
+ * of threads accessing, especially cases where there are more threads than the
+ * barrier height (count), i.e. test contention when the barrier is released.
+ */
+
+#include "test.h"
+
+enum {
+  NUMTHREADS = 15,
+  HEIGHT = 10,
+  BARRIERMULTIPLE = 1000
+};
+ 
+pthread_barrier_t barrier = NULL;
+pthread_mutex_t mx = PTHREAD_MUTEX_INITIALIZER;
+LONG totalThreadCrossings;
+
+void *
+func(void * crossings)
+{
+  int result;
+  int serialThreads = 0;
+
+  while ((LONG)(size_t)crossings >= (LONG)InterlockedIncrement((LPLONG)&totalThreadCrossings))
+    {
+      result = pthread_barrier_wait(&barrier);
+
+      if (result == PTHREAD_BARRIER_SERIAL_THREAD)
+        {
+          serialThreads++;
+        }
+      else if (result != 0)
+        {
+          printf("Barrier failed: result = %s\n", error_string[result]);
+          fflush(stdout);
+          return NULL;
+        }
+    }
+
+  return (void*)(size_t)serialThreads;
+}
+
+int
+main()
+{
+  int i, j;
+  void* result;
+  int serialThreadsTotal;
+  LONG Crossings;
+  pthread_t t[NUMTHREADS + 1];
+
+  for (j = 1; j <= NUMTHREADS; j++)
+    {
+      int height = j<HEIGHT?j:HEIGHT;
+
+      totalThreadCrossings = 0;
+      Crossings = height * BARRIERMULTIPLE;
+
+      printf("Threads=%d, Barrier height=%d\n", j, height);
+
+      assert(pthread_barrier_init(&barrier, NULL, height) == 0);
+
+      for (i = 1; i <= j; i++)
+        {
+          assert(pthread_create(&t[i], NULL, func, (void *)(size_t)Crossings) == 0);
+        }
+
+      serialThreadsTotal = 0;
+      for (i = 1; i <= j; i++)
+        {
+          assert(pthread_join(t[i], &result) == 0);
+          serialThreadsTotal += (int)(size_t)result;
+        }
+
+      assert(serialThreadsTotal == BARRIERMULTIPLE);
+
+      assert(pthread_barrier_destroy(&barrier) == 0);
+    }
+
+  assert(pthread_mutex_destroy(&mx) == 0);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/barrier6.c b/src/include/pthread/tests/barrier6.c
new file mode 100644
index 0000000..d7a700e
--- /dev/null
+++ b/src/include/pthread/tests/barrier6.c
@@ -0,0 +1,115 @@
+/*
+ * barrier6.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Destroy the barrier after initial count threads are released then let
+ * additional threads attempt to wait on it.
+ *
+ */
+
+#include "test.h"
+
+enum {
+  NUMTHREADS = 31
+};
+ 
+pthread_barrier_t barrier = NULL;
+pthread_mutex_t mx = PTHREAD_MUTEX_INITIALIZER;
+static int serialThreadCount = 0;
+static int otherThreadCount = 0;
+
+void *
+func(void * arg)
+{
+  int result = pthread_barrier_wait(&barrier);
+
+  assert(pthread_mutex_lock(&mx) == 0);
+
+  if (result == PTHREAD_BARRIER_SERIAL_THREAD)
+    {
+      serialThreadCount++;
+    }
+  else if (0 == result)
+    {
+      otherThreadCount++;
+    }
+  assert(pthread_mutex_unlock(&mx) == 0);
+
+  return NULL;
+}
+
+int
+main()
+{
+  int i, j, k;
+  pthread_t t[NUMTHREADS + 1];
+
+  for (j = 1; j <= NUMTHREADS; j++)
+    {
+      int howHigh = j/2 + 1;
+
+      printf("Barrier height = %d, Total threads %d\n", howHigh, j);
+
+      serialThreadCount = 0;
+      otherThreadCount = 0;
+
+      assert(pthread_barrier_init(&barrier, NULL, howHigh) == 0);
+
+      for (i = 1; i <= j; i++)
+        {
+          assert(pthread_create(&t[i], NULL, func, NULL) == 0);
+
+          if (i == howHigh)
+            {
+              for (k = 1; k <= howHigh; k++)
+                {
+                  assert(pthread_join(t[k], NULL) == 0);
+                }
+              assert(pthread_barrier_destroy(&barrier) == 0);
+            }
+        }
+
+      for (i = howHigh+1; i <= j; i++)
+        {
+          assert(pthread_join(t[i], NULL) == 0);
+        }
+
+      assert(serialThreadCount == 1);
+      assert(otherThreadCount == (howHigh - 1));
+
+      assert(pthread_barrier_destroy(&barrier) == EINVAL);
+    }
+
+  assert(pthread_mutex_destroy(&mx) == 0);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/benchlib.c b/src/include/pthread/tests/benchlib.c
new file mode 100644
index 0000000..055ea04
--- /dev/null
+++ b/src/include/pthread/tests/benchlib.c
@@ -0,0 +1,361 @@
+/*
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include "../config.h"
+
+#include "pthread.h"
+#include "sched.h"
+#include "semaphore.h"
+#include <windows.h>
+#include <stdio.h>
+
+#ifdef __GNUC__
+#include <stdlib.h>
+#endif
+
+#include "benchtest.h"
+
+int old_mutex_use = OLD_WIN32CS;
+
+BOOL (WINAPI *__ptw32_try_enter_critical_section)(LPCRITICAL_SECTION) = NULL;
+HINSTANCE __ptw32_h_kernel32;
+
+void
+dummy_call(int * a)
+{
+}
+
+void
+interlocked_inc_with_conditionals(int * a)
+{
+  if (a != NULL)
+    if (InterlockedIncrement((long *) a) == -1)
+      {
+        *a = 0;
+      }
+}
+
+void
+interlocked_dec_with_conditionals(int * a)
+{
+  if (a != NULL)
+    if (InterlockedDecrement((long *) a) == -1)
+      {
+        *a = 0;
+      }
+}
+
+int
+old_mutex_init(old_mutex_t *mutex, const old_mutexattr_t *attr)
+{
+  int result = 0;
+  old_mutex_t mx;
+
+  if (mutex == NULL)
+    {
+      return EINVAL;
+    }
+
+  mx = (old_mutex_t) calloc(1, sizeof(*mx));
+
+  if (mx == NULL)
+    {
+      result = ENOMEM;
+      goto FAIL0;
+    }
+
+  mx->mutex = 0;
+
+  if (attr != NULL
+      && *attr != NULL
+      && (*attr)->pshared == PTHREAD_PROCESS_SHARED
+      )
+    {
+      result = ENOSYS;
+    }
+  else
+    {
+        CRITICAL_SECTION cs;
+
+        /*
+         * Load KERNEL32 and try to get address of TryEnterCriticalSection
+         */
+        __ptw32_h_kernel32 = LoadLibrary(TEXT("KERNEL32.DLL"));
+        __ptw32_try_enter_critical_section = (BOOL (WINAPI *)(LPCRITICAL_SECTION))
+
+#if defined(NEED_UNICODE_CONSTS)
+        GetProcAddress(__ptw32_h_kernel32,
+                       (const TCHAR *)TEXT("TryEnterCriticalSection"));
+#else
+        GetProcAddress(__ptw32_h_kernel32,
+                       (LPCSTR) "TryEnterCriticalSection");
+#endif
+
+        if (__ptw32_try_enter_critical_section != NULL)
+          {
+            InitializeCriticalSection(&cs);
+            if ((*__ptw32_try_enter_critical_section)(&cs))
+              {
+                LeaveCriticalSection(&cs);
+              }
+            else
+              {
+                /*
+                 * Not really supported (Win98?).
+                 */
+                __ptw32_try_enter_critical_section = NULL;
+              }
+            DeleteCriticalSection(&cs);
+          }
+
+        if (__ptw32_try_enter_critical_section == NULL)
+          {
+            (void) FreeLibrary(__ptw32_h_kernel32);
+            __ptw32_h_kernel32 = 0;
+          }
+
+      if (old_mutex_use == OLD_WIN32CS)
+	{
+	  InitializeCriticalSection(&mx->cs);
+	}
+      else if (old_mutex_use == OLD_WIN32MUTEX)
+      {
+	  mx->mutex = CreateMutex (NULL,
+				   FALSE,
+				   NULL);
+
+	  if (mx->mutex == 0)
+	    {
+	      result = EAGAIN;
+	    }
+	}
+      else
+	{
+        result = EINVAL;
+      }
+    }
+
+  if (result != 0 && mx != NULL)
+    {
+      free(mx);
+      mx = NULL;
+    }
+
+FAIL0:
+  *mutex = mx;
+
+  return(result);
+}
+
+
+int
+old_mutex_lock(old_mutex_t *mutex)
+{
+  int result = 0;
+  old_mutex_t mx;
+
+  if (mutex == NULL || *mutex == NULL)
+    {
+      return EINVAL;
+    }
+
+  if (*mutex == (old_mutex_t)  __PTW32_OBJECT_AUTO_INIT)
+    {
+      /*
+       * Don't use initialisers when benchtesting.
+       */
+      result = EINVAL;
+    }
+
+  mx = *mutex;
+
+  if (result == 0)
+    {
+      if (mx->mutex == 0)
+	{
+	  EnterCriticalSection(&mx->cs);
+	}
+      else
+	{
+	  result = (WaitForSingleObject(mx->mutex, INFINITE) 
+		    == WAIT_OBJECT_0)
+	    ? 0
+	    : EINVAL;
+	}
+    }
+
+  return(result);
+}
+
+int
+old_mutex_unlock(old_mutex_t *mutex)
+{
+  int result = 0;
+  old_mutex_t mx;
+
+  if (mutex == NULL || *mutex == NULL)
+    {
+      return EINVAL;
+    }
+
+  mx = *mutex;
+
+  if (mx != (old_mutex_t)  __PTW32_OBJECT_AUTO_INIT)
+    {
+      if (mx->mutex == 0)
+	{
+	  LeaveCriticalSection(&mx->cs);
+	}
+      else
+	{
+	  result = (ReleaseMutex (mx->mutex) ? 0 : EINVAL);
+	}
+    }
+  else
+    {
+      result = EINVAL;
+    }
+
+  return(result);
+}
+
+
+int
+old_mutex_trylock(old_mutex_t *mutex)
+{
+  int result = 0;
+  old_mutex_t mx;
+
+  if (mutex == NULL || *mutex == NULL)
+    {
+      return EINVAL;
+    }
+
+  if (*mutex == (old_mutex_t)  __PTW32_OBJECT_AUTO_INIT)
+    {
+      /*
+       * Don't use initialisers when benchtesting.
+       */
+      result = EINVAL;
+    }
+
+  mx = *mutex;
+
+  if (result == 0)
+    {
+      if (mx->mutex == 0)
+	{
+	  if (__ptw32_try_enter_critical_section == NULL)
+          {
+            result = 0;
+          }
+        else if ((*__ptw32_try_enter_critical_section)(&mx->cs) != TRUE)
+	    {
+	      result = EBUSY;
+	    }
+	}
+      else
+	{
+	  DWORD status;
+
+	  status = WaitForSingleObject (mx->mutex, 0);
+
+	  if (status != WAIT_OBJECT_0)
+	    {
+	      result = ((status == WAIT_TIMEOUT)
+			? EBUSY
+			: EINVAL);
+	    }
+	}
+    }
+
+  return(result);
+}
+
+
+int
+old_mutex_destroy(old_mutex_t *mutex)
+{
+  int result = 0;
+  old_mutex_t mx;
+
+  if (mutex == NULL
+      || *mutex == NULL)
+    {
+      return EINVAL;
+    }
+
+  if (*mutex != (old_mutex_t)  __PTW32_OBJECT_AUTO_INIT)
+    {
+      mx = *mutex;
+
+      if ((result = old_mutex_trylock(&mx)) == 0)
+        {
+          *mutex = NULL;
+
+          (void) old_mutex_unlock(&mx);
+
+          if (mx->mutex == 0)
+            {
+              DeleteCriticalSection(&mx->cs);
+            }
+          else
+            {
+              result = (CloseHandle (mx->mutex) ? 0 : EINVAL);
+            }
+
+          if (result == 0)
+            {
+              mx->mutex = 0;
+              free(mx);
+            }
+          else
+            {
+              *mutex = mx;
+            }
+        }
+    }
+  else
+    {
+      result = EINVAL;
+    }
+
+  if (__ptw32_try_enter_critical_section != NULL)
+    {
+      (void) FreeLibrary(__ptw32_h_kernel32);
+      __ptw32_h_kernel32 = 0;
+    }
+
+  return(result);
+}
+
+/****************************************************************************************/
diff --git a/src/include/pthread/tests/benchtest.h b/src/include/pthread/tests/benchtest.h
new file mode 100644
index 0000000..6a22b4b
--- /dev/null
+++ b/src/include/pthread/tests/benchtest.h
@@ -0,0 +1,68 @@
+/*
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include "../config.h"
+
+enum {
+  OLD_WIN32CS,
+  OLD_WIN32MUTEX
+};
+
+extern int old_mutex_use;
+
+struct old_mutex_t_ {
+  HANDLE mutex;
+  CRITICAL_SECTION cs;
+};
+
+typedef struct old_mutex_t_ * old_mutex_t;
+
+struct old_mutexattr_t_ {
+  int pshared;
+};
+
+typedef struct old_mutexattr_t_ * old_mutexattr_t;
+
+extern BOOL (WINAPI *__ptw32_try_enter_critical_section)(LPCRITICAL_SECTION);
+extern HINSTANCE __ptw32_h_kernel32;
+
+#define  __PTW32_OBJECT_AUTO_INIT ((void *) -1)
+
+void dummy_call(int * a);
+void interlocked_inc_with_conditionals(int *a);
+void interlocked_dec_with_conditionals(int *a);
+int old_mutex_init(old_mutex_t *mutex, const old_mutexattr_t *attr);
+int old_mutex_lock(old_mutex_t *mutex);
+int old_mutex_unlock(old_mutex_t *mutex);
+int old_mutex_trylock(old_mutex_t *mutex);
+int old_mutex_destroy(old_mutex_t *mutex);
+/****************************************************************************************/
diff --git a/src/include/pthread/tests/benchtest1.c b/src/include/pthread/tests/benchtest1.c
new file mode 100644
index 0000000..23e8d72
--- /dev/null
+++ b/src/include/pthread/tests/benchtest1.c
@@ -0,0 +1,263 @@
+/*
+ * benchtest1.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Measure time taken to complete an elementary operation.
+ *
+ * - Mutex
+ *   Single thread iteration over lock/unlock for each mutex type.
+ */
+
+#include "test.h"
+
+#ifdef __GNUC__
+#include <stdlib.h>
+#endif
+
+#include "benchtest.h"
+
+#define  __PTW32_MUTEX_TYPES
+#define ITERATIONS      10000000L
+
+pthread_mutex_t mx;
+pthread_mutexattr_t ma;
+__PTW32_STRUCT_TIMEB currSysTimeStart;
+__PTW32_STRUCT_TIMEB currSysTimeStop;
+long durationMilliSecs;
+long overHeadMilliSecs = 0;
+int two = 2;
+int one = 1;
+int zero = 0;
+int iter;
+
+#define GetDurationMilliSecs(_TStart, _TStop) ((long)((_TStop.time*1000+_TStop.millitm) \
+                                               - (_TStart.time*1000+_TStart.millitm)))
+
+/*
+ * Dummy use of j, otherwise the loop may be removed by the optimiser
+ * when doing the overhead timing with an empty loop.
+ */
+#define TESTSTART \
+  { int i, j = 0, k = 0;  __PTW32_FTIME(&currSysTimeStart); for (i = 0; i < ITERATIONS; i++) { j++;
+
+#define TESTSTOP \
+  };  __PTW32_FTIME(&currSysTimeStop); if (j + k == i) j++; }
+
+
+void
+runTest (char * testNameString, int mType)
+{
+#ifdef  __PTW32_MUTEX_TYPES
+  assert(pthread_mutexattr_settype(&ma, mType) == 0);
+#endif
+  assert(pthread_mutex_init(&mx, &ma) == 0);
+
+  TESTSTART
+  assert((pthread_mutex_lock(&mx),1) == one);
+  assert((pthread_mutex_unlock(&mx),2) == two);
+  TESTSTOP
+
+  assert(pthread_mutex_destroy(&mx) == 0);
+
+  durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - overHeadMilliSecs;
+
+  printf( "%-45s %15ld %15.3f\n",
+	    testNameString,
+          durationMilliSecs,
+          (float) durationMilliSecs * 1E3 / ITERATIONS);
+}
+
+
+int
+main (int argc, char *argv[])
+{
+  int i = 0;
+  CRITICAL_SECTION cs;
+  old_mutex_t ox;
+  pthread_mutexattr_init(&ma);
+
+  printf( "=============================================================================\n");
+  printf( "\nLock plus unlock on an unlocked mutex.\n%ld iterations\n\n",
+          ITERATIONS);
+  printf( "%-45s %15s %15s\n",
+	    "Test",
+	    "Total(msec)",
+	    "average(usec)");
+  printf( "-----------------------------------------------------------------------------\n");
+
+  /*
+   * Time the loop overhead so we can subtract it from the actual test times.
+   */
+  TESTSTART
+  assert(1 == one);
+  assert(2 == two);
+  TESTSTOP
+
+  durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - overHeadMilliSecs;
+  overHeadMilliSecs = durationMilliSecs;
+
+
+  TESTSTART
+  assert((dummy_call(&i), 1) == one);
+  assert((dummy_call(&i), 2) == two);
+  TESTSTOP
+
+  durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - overHeadMilliSecs;
+
+  printf( "%-45s %15ld %15.3f\n",
+	    "Dummy call x 2",
+          durationMilliSecs,
+          (float) (durationMilliSecs * 1E3 / ITERATIONS));
+
+
+  TESTSTART
+  assert((interlocked_inc_with_conditionals(&i), 1) == one);
+  assert((interlocked_dec_with_conditionals(&i), 2) == two);
+  TESTSTOP
+
+  durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - overHeadMilliSecs;
+
+  printf( "%-45s %15ld %15.3f\n",
+	    "Dummy call -> Interlocked with cond x 2",
+          durationMilliSecs,
+          (float) durationMilliSecs * 1E3 / ITERATIONS);
+
+
+  TESTSTART
+  assert((InterlockedIncrement((LPLONG)&i), 1) == (LONG)one);
+  assert((InterlockedDecrement((LPLONG)&i), 2) == (LONG)two);
+  TESTSTOP
+
+  durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - overHeadMilliSecs;
+
+  printf( "%-45s %15ld %15.3f\n",
+	    "InterlockedOp x 2",
+          durationMilliSecs,
+          (float) durationMilliSecs * 1E3 / ITERATIONS);
+
+
+  InitializeCriticalSection(&cs);
+
+  TESTSTART
+  assert((EnterCriticalSection(&cs), 1) == one);
+  assert((LeaveCriticalSection(&cs), 2) == two);
+  TESTSTOP
+
+  DeleteCriticalSection(&cs);
+
+  durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - overHeadMilliSecs;
+
+  printf( "%-45s %15ld %15.3f\n",
+	    "Simple Critical Section",
+          durationMilliSecs,
+          (float) durationMilliSecs * 1E3 / ITERATIONS);
+
+
+  old_mutex_use = OLD_WIN32CS;
+  assert(old_mutex_init(&ox, NULL) == 0);
+
+  TESTSTART
+  assert(old_mutex_lock(&ox) == zero);
+  assert(old_mutex_unlock(&ox) == zero);
+  TESTSTOP
+
+  assert(old_mutex_destroy(&ox) == 0);
+
+  durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - overHeadMilliSecs;
+
+  printf( "%-45s %15ld %15.3f\n",
+	    "Old PT Mutex using a Critical Section (WNT)",
+          durationMilliSecs,
+          (float) durationMilliSecs * 1E3 / ITERATIONS);
+
+
+  old_mutex_use = OLD_WIN32MUTEX;
+  assert(old_mutex_init(&ox, NULL) == 0);
+
+  TESTSTART
+  assert(old_mutex_lock(&ox) == zero);
+  assert(old_mutex_unlock(&ox) == zero);
+  TESTSTOP
+
+  assert(old_mutex_destroy(&ox) == 0);
+
+  durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - overHeadMilliSecs;
+
+  printf( "%-45s %15ld %15.3f\n",
+	    "Old PT Mutex using a Win32 Mutex (W9x)",
+          durationMilliSecs,
+          (float) durationMilliSecs * 1E3 / ITERATIONS);
+
+  printf( ".............................................................................\n");
+
+  /*
+   * Now we can start the actual tests
+   */
+#ifdef  __PTW32_MUTEX_TYPES
+  runTest("PTHREAD_MUTEX_DEFAULT", PTHREAD_MUTEX_DEFAULT);
+
+  runTest("PTHREAD_MUTEX_NORMAL", PTHREAD_MUTEX_NORMAL);
+
+  runTest("PTHREAD_MUTEX_ERRORCHECK", PTHREAD_MUTEX_ERRORCHECK);
+
+  runTest("PTHREAD_MUTEX_RECURSIVE", PTHREAD_MUTEX_RECURSIVE);
+#else
+  runTest("Non-blocking lock", 0);
+#endif
+
+  printf( ".............................................................................\n");
+
+  pthread_mutexattr_setrobust(&ma, PTHREAD_MUTEX_ROBUST);
+
+#ifdef  __PTW32_MUTEX_TYPES
+  runTest("PTHREAD_MUTEX_DEFAULT (Robust)", PTHREAD_MUTEX_DEFAULT);
+
+  runTest("PTHREAD_MUTEX_NORMAL (Robust)", PTHREAD_MUTEX_NORMAL);
+
+  runTest("PTHREAD_MUTEX_ERRORCHECK (Robust)", PTHREAD_MUTEX_ERRORCHECK);
+
+  runTest("PTHREAD_MUTEX_RECURSIVE (Robust)", PTHREAD_MUTEX_RECURSIVE);
+#else
+  runTest("Non-blocking lock", 0);
+#endif
+
+  printf( "=============================================================================\n");
+
+  /*
+   * End of tests.
+   */
+
+  pthread_mutexattr_destroy(&ma);
+
+  one = i; /* Dummy assignment to avoid 'variable unused' warning */
+  return 0;
+}
diff --git a/src/include/pthread/tests/benchtest2.c b/src/include/pthread/tests/benchtest2.c
new file mode 100644
index 0000000..e28c10e
--- /dev/null
+++ b/src/include/pthread/tests/benchtest2.c
@@ -0,0 +1,324 @@
+/*
+ * benchtest1.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Measure time taken to complete an elementary operation.
+ *
+ * - Mutex
+ *   Two threads iterate over lock/unlock for each mutex type.
+ *   The two threads are forced into lock-step using two mutexes,
+ *   forcing the threads to block on each lock operation. The
+ *   time measured is therefore the worst case senario.
+ */
+
+#include "test.h"
+
+#ifdef __GNUC__
+#include <stdlib.h>
+#endif
+
+#include "benchtest.h"
+
+#define  __PTW32_MUTEX_TYPES
+#define ITERATIONS      100000L
+
+pthread_mutex_t gate1, gate2;
+old_mutex_t ox1, ox2;
+CRITICAL_SECTION cs1, cs2;
+pthread_mutexattr_t ma;
+long durationMilliSecs;
+long overHeadMilliSecs = 0;
+__PTW32_STRUCT_TIMEB currSysTimeStart;
+__PTW32_STRUCT_TIMEB currSysTimeStop;
+pthread_t worker;
+int running = 0;
+
+#define GetDurationMilliSecs(_TStart, _TStop) ((long)((_TStop.time*1000+_TStop.millitm) \
+                                               - (_TStart.time*1000+_TStart.millitm)))
+
+/*
+ * Dummy use of j, otherwise the loop may be removed by the optimiser
+ * when doing the overhead timing with an empty loop.
+ */
+#define TESTSTART \
+  { int i, j = 0, k = 0;  __PTW32_FTIME(&currSysTimeStart); for (i = 0; i < ITERATIONS; i++) { j++;
+
+#define TESTSTOP \
+  };  __PTW32_FTIME(&currSysTimeStop); if (j + k == i) j++; }
+
+
+void *
+overheadThread(void * arg)
+{
+  do
+    {
+      sched_yield();
+    }
+  while (running);
+
+  return NULL;
+}
+
+
+void *
+oldThread(void * arg)
+{
+  do
+    {
+      (void) old_mutex_lock(&ox1);
+      (void) old_mutex_lock(&ox2);
+      (void) old_mutex_unlock(&ox1);
+      sched_yield();
+      (void) old_mutex_unlock(&ox2);
+    }
+  while (running);
+
+  return NULL;
+}
+
+void *
+workerThread(void * arg)
+{
+  do
+    {
+      (void) pthread_mutex_lock(&gate1);
+      (void) pthread_mutex_lock(&gate2);
+      (void) pthread_mutex_unlock(&gate1);
+      sched_yield();
+      (void) pthread_mutex_unlock(&gate2);
+    }
+  while (running);
+
+  return NULL;
+}
+
+void *
+CSThread(void * arg)
+{
+  do
+    {
+      EnterCriticalSection(&cs1);
+      EnterCriticalSection(&cs2);
+      LeaveCriticalSection(&cs1);
+      sched_yield();
+      LeaveCriticalSection(&cs2);
+    }
+  while (running);
+
+  return NULL;
+}
+
+void
+runTest (char * testNameString, int mType)
+{
+#ifdef  __PTW32_MUTEX_TYPES
+  assert(pthread_mutexattr_settype(&ma, mType) == 0);
+#endif
+  assert(pthread_mutex_init(&gate1, &ma) == 0);
+  assert(pthread_mutex_init(&gate2, &ma) == 0);
+  assert(pthread_mutex_lock(&gate1) == 0);
+  assert(pthread_mutex_lock(&gate2) == 0);
+  running = 1;
+  assert(pthread_create(&worker, NULL, workerThread, NULL) == 0);
+  TESTSTART
+  (void) pthread_mutex_unlock(&gate1);
+  sched_yield();
+  (void) pthread_mutex_unlock(&gate2);
+  (void) pthread_mutex_lock(&gate1);
+  (void) pthread_mutex_lock(&gate2);
+  TESTSTOP
+  running = 0;
+  assert(pthread_mutex_unlock(&gate2) == 0);
+  assert(pthread_mutex_unlock(&gate1) == 0);
+  assert(pthread_join(worker, NULL) == 0);
+  assert(pthread_mutex_destroy(&gate2) == 0);
+  assert(pthread_mutex_destroy(&gate1) == 0);
+  durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - overHeadMilliSecs;
+  printf( "%-45s %15ld %15.3f\n",
+	    testNameString,
+          durationMilliSecs,
+          (float) durationMilliSecs * 1E3 / ITERATIONS / 4   /* Four locks/unlocks per iteration */);
+}
+
+
+int
+main (int argc, char *argv[])
+{
+  assert(pthread_mutexattr_init(&ma) == 0);
+
+  printf( "=============================================================================\n");
+  printf( "\nLock plus unlock on a locked mutex.\n");
+  printf("%ld iterations, four locks/unlocks per iteration.\n\n", ITERATIONS);
+
+  printf( "%-45s %15s %15s\n",
+	    "Test",
+	    "Total(msec)",
+	    "average(usec)");
+  printf( "-----------------------------------------------------------------------------\n");
+
+  /*
+   * Time the loop overhead so we can subtract it from the actual test times.
+   */
+
+  running = 1;
+  assert(pthread_create(&worker, NULL, overheadThread, NULL) == 0);
+  TESTSTART
+  sched_yield();
+  sched_yield();
+  TESTSTOP
+  running = 0;
+  assert(pthread_join(worker, NULL) == 0);
+  durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - overHeadMilliSecs;
+  overHeadMilliSecs = durationMilliSecs;
+
+
+  InitializeCriticalSection(&cs1);
+  InitializeCriticalSection(&cs2);
+  EnterCriticalSection(&cs1);
+  EnterCriticalSection(&cs2);
+  running = 1;
+  assert(pthread_create(&worker, NULL, CSThread, NULL) == 0);
+  TESTSTART
+  LeaveCriticalSection(&cs1);
+  sched_yield();
+  LeaveCriticalSection(&cs2);
+  EnterCriticalSection(&cs1);
+  EnterCriticalSection(&cs2);
+  TESTSTOP
+  running = 0;
+  LeaveCriticalSection(&cs2);
+  LeaveCriticalSection(&cs1);
+  assert(pthread_join(worker, NULL) == 0);
+  DeleteCriticalSection(&cs2);
+  DeleteCriticalSection(&cs1);
+  durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - overHeadMilliSecs;
+  printf( "%-45s %15ld %15.3f\n",
+	    "Simple Critical Section",
+          durationMilliSecs,
+          (float) durationMilliSecs * 1E3 / ITERATIONS / 4 );
+
+
+  old_mutex_use = OLD_WIN32CS;
+  assert(old_mutex_init(&ox1, NULL) == 0);
+  assert(old_mutex_init(&ox2, NULL) == 0);
+  assert(old_mutex_lock(&ox1) == 0);
+  assert(old_mutex_lock(&ox2) == 0);
+  running = 1;
+  assert(pthread_create(&worker, NULL, oldThread, NULL) == 0);
+  TESTSTART
+  (void) old_mutex_unlock(&ox1);
+  sched_yield();
+  (void) old_mutex_unlock(&ox2);
+  (void) old_mutex_lock(&ox1);
+  (void) old_mutex_lock(&ox2);
+  TESTSTOP
+  running = 0;
+  assert(old_mutex_unlock(&ox1) == 0);
+  assert(old_mutex_unlock(&ox2) == 0);
+  assert(pthread_join(worker, NULL) == 0);
+  assert(old_mutex_destroy(&ox2) == 0);
+  assert(old_mutex_destroy(&ox1) == 0);
+  durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - overHeadMilliSecs;
+  printf( "%-45s %15ld %15.3f\n",
+	    "Old PT Mutex using a Critical Section (WNT)",
+          durationMilliSecs,
+          (float) durationMilliSecs * 1E3 / ITERATIONS / 4);
+
+
+  old_mutex_use = OLD_WIN32MUTEX;
+  assert(old_mutex_init(&ox1, NULL) == 0);
+  assert(old_mutex_init(&ox2, NULL) == 0);
+  assert(old_mutex_lock(&ox1) == 0);
+  assert(old_mutex_lock(&ox2) == 0);
+  running = 1;
+  assert(pthread_create(&worker, NULL, oldThread, NULL) == 0);
+  TESTSTART
+  (void) old_mutex_unlock(&ox1);
+  sched_yield();
+  (void) old_mutex_unlock(&ox2);
+  (void) old_mutex_lock(&ox1);
+  (void) old_mutex_lock(&ox2);
+  TESTSTOP
+  running = 0;
+  assert(old_mutex_unlock(&ox1) == 0);
+  assert(old_mutex_unlock(&ox2) == 0);
+  assert(pthread_join(worker, NULL) == 0);
+  assert(old_mutex_destroy(&ox2) == 0);
+  assert(old_mutex_destroy(&ox1) == 0);
+  durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - overHeadMilliSecs;
+  printf( "%-45s %15ld %15.3f\n",
+	    "Old PT Mutex using a Win32 Mutex (W9x)",
+          durationMilliSecs,
+          (float) durationMilliSecs * 1E3 / ITERATIONS / 4);
+
+  printf( ".............................................................................\n");
+
+  /*
+   * Now we can start the actual tests
+   */
+#ifdef  __PTW32_MUTEX_TYPES
+  runTest("PTHREAD_MUTEX_DEFAULT", PTHREAD_MUTEX_DEFAULT);
+
+  runTest("PTHREAD_MUTEX_NORMAL", PTHREAD_MUTEX_NORMAL);
+
+  runTest("PTHREAD_MUTEX_ERRORCHECK", PTHREAD_MUTEX_ERRORCHECK);
+
+  runTest("PTHREAD_MUTEX_RECURSIVE", PTHREAD_MUTEX_RECURSIVE);
+#else
+  runTest("Non-blocking lock", 0);
+#endif
+
+  printf( ".............................................................................\n");
+
+  pthread_mutexattr_setrobust(&ma, PTHREAD_MUTEX_ROBUST);
+
+#ifdef  __PTW32_MUTEX_TYPES
+  runTest("PTHREAD_MUTEX_DEFAULT (Robust)", PTHREAD_MUTEX_DEFAULT);
+
+  runTest("PTHREAD_MUTEX_NORMAL (Robust)", PTHREAD_MUTEX_NORMAL);
+
+  runTest("PTHREAD_MUTEX_ERRORCHECK (Robust)", PTHREAD_MUTEX_ERRORCHECK);
+
+  runTest("PTHREAD_MUTEX_RECURSIVE (Robust)", PTHREAD_MUTEX_RECURSIVE);
+#else
+  runTest("Non-blocking lock", 0);
+#endif
+
+  printf( "=============================================================================\n");
+  /*
+   * End of tests.
+   */
+
+  pthread_mutexattr_destroy(&ma);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/benchtest3.c b/src/include/pthread/tests/benchtest3.c
new file mode 100644
index 0000000..1bc5a04
--- /dev/null
+++ b/src/include/pthread/tests/benchtest3.c
@@ -0,0 +1,214 @@
+/*
+ * benchtest3.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Measure time taken to complete an elementary operation.
+ *
+ * - Mutex
+ *   Single thread iteration over a trylock on a locked mutex for each mutex type.
+ */
+
+#include "test.h"
+
+#ifdef __GNUC__
+#include <stdlib.h>
+#endif
+
+#include "benchtest.h"
+
+#define  __PTW32_MUTEX_TYPES
+#define ITERATIONS      10000000L
+
+pthread_mutex_t mx;
+old_mutex_t ox;
+pthread_mutexattr_t ma;
+__PTW32_STRUCT_TIMEB currSysTimeStart;
+__PTW32_STRUCT_TIMEB currSysTimeStop;
+long durationMilliSecs;
+long overHeadMilliSecs = 0;
+
+#define GetDurationMilliSecs(_TStart, _TStop) ((long)((_TStop.time*1000+_TStop.millitm) \
+                                               - (_TStart.time*1000+_TStart.millitm)))
+
+/*
+ * Dummy use of j, otherwise the loop may be removed by the optimiser
+ * when doing the overhead timing with an empty loop.
+ */
+#define TESTSTART \
+  { int i, j = 0, k = 0;  __PTW32_FTIME(&currSysTimeStart); for (i = 0; i < ITERATIONS; i++) { j++;
+
+#define TESTSTOP \
+  };  __PTW32_FTIME(&currSysTimeStop); if (j + k == i) j++; }
+
+
+void *
+trylockThread (void * arg)
+{
+  TESTSTART
+  (void) pthread_mutex_trylock(&mx);
+  TESTSTOP
+
+  return NULL;
+}
+
+
+void *
+oldTrylockThread (void * arg)
+{
+  TESTSTART
+  (void) old_mutex_trylock(&ox);
+  TESTSTOP
+
+  return NULL;
+}
+
+
+void
+runTest (char * testNameString, int mType)
+{
+  pthread_t t;
+
+#ifdef  __PTW32_MUTEX_TYPES
+  (void) pthread_mutexattr_settype(&ma, mType);
+#endif
+  assert(pthread_mutex_init(&mx, &ma) == 0);
+  assert(pthread_mutex_lock(&mx) == 0);
+  assert(pthread_create(&t, NULL, trylockThread, 0) == 0);
+  assert(pthread_join(t, NULL) == 0);
+  assert(pthread_mutex_unlock(&mx) == 0);
+  assert(pthread_mutex_destroy(&mx) == 0);
+
+  durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - overHeadMilliSecs;
+
+  printf( "%-45s %15ld %15.3f\n",
+	    testNameString,
+          durationMilliSecs,
+          (float) durationMilliSecs * 1E3 / ITERATIONS);
+}
+
+
+int
+main (int argc, char *argv[])
+{
+  pthread_t t;
+
+  assert(pthread_mutexattr_init(&ma) == 0);
+
+  printf( "=============================================================================\n");
+  printf( "\nTrylock on a locked mutex.\n");
+  printf( "%ld iterations.\n\n", ITERATIONS);
+  printf( "%-45s %15s %15s\n",
+	    "Test",
+	    "Total(msec)",
+	    "average(usec)");
+  printf( "-----------------------------------------------------------------------------\n");
+
+  /*
+   * Time the loop overhead so we can subtract it from the actual test times.
+   */
+
+  TESTSTART
+  TESTSTOP
+
+  durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - overHeadMilliSecs;
+  overHeadMilliSecs = durationMilliSecs;
+
+
+  old_mutex_use = OLD_WIN32CS;
+  assert(old_mutex_init(&ox, NULL) == 0);
+  assert(old_mutex_lock(&ox) == 0);
+  assert(pthread_create(&t, NULL, oldTrylockThread, 0) == 0);
+  assert(pthread_join(t, NULL) == 0);
+  assert(old_mutex_unlock(&ox) == 0);
+  assert(old_mutex_destroy(&ox) == 0);
+  durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - overHeadMilliSecs;
+  printf( "%-45s %15ld %15.3f\n",
+	    "Old PT Mutex using a Critical Section (WNT)",
+          durationMilliSecs,
+          (float) durationMilliSecs * 1E3 / ITERATIONS);
+
+  old_mutex_use = OLD_WIN32MUTEX;
+  assert(old_mutex_init(&ox, NULL) == 0);
+  assert(old_mutex_lock(&ox) == 0);
+  assert(pthread_create(&t, NULL, oldTrylockThread, 0) == 0);
+  assert(pthread_join(t, NULL) == 0);
+  assert(old_mutex_unlock(&ox) == 0);
+  assert(old_mutex_destroy(&ox) == 0);
+  durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - overHeadMilliSecs;
+  printf( "%-45s %15ld %15.3f\n",
+	    "Old PT Mutex using a Win32 Mutex (W9x)",
+          durationMilliSecs,
+          (float) durationMilliSecs * 1E3 / ITERATIONS);
+
+  printf( ".............................................................................\n");
+
+  /*
+   * Now we can start the actual tests
+   */
+#ifdef  __PTW32_MUTEX_TYPES
+  runTest("PTHREAD_MUTEX_DEFAULT", PTHREAD_MUTEX_DEFAULT);
+
+  runTest("PTHREAD_MUTEX_NORMAL", PTHREAD_MUTEX_NORMAL);
+
+  runTest("PTHREAD_MUTEX_ERRORCHECK", PTHREAD_MUTEX_ERRORCHECK);
+
+  runTest("PTHREAD_MUTEX_RECURSIVE", PTHREAD_MUTEX_RECURSIVE);
+#else
+  runTest("Non-blocking lock", 0);
+#endif
+
+  printf( ".............................................................................\n");
+
+  pthread_mutexattr_setrobust(&ma, PTHREAD_MUTEX_ROBUST);
+
+#ifdef  __PTW32_MUTEX_TYPES
+  runTest("PTHREAD_MUTEX_DEFAULT (Robust)", PTHREAD_MUTEX_DEFAULT);
+
+  runTest("PTHREAD_MUTEX_NORMAL (Robust)", PTHREAD_MUTEX_NORMAL);
+
+  runTest("PTHREAD_MUTEX_ERRORCHECK (Robust)", PTHREAD_MUTEX_ERRORCHECK);
+
+  runTest("PTHREAD_MUTEX_RECURSIVE (Robust)", PTHREAD_MUTEX_RECURSIVE);
+#else
+  runTest("Non-blocking lock", 0);
+#endif
+
+  printf( "=============================================================================\n");
+
+  /*
+   * End of tests.
+   */
+
+  pthread_mutexattr_destroy(&ma);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/benchtest4.c b/src/include/pthread/tests/benchtest4.c
new file mode 100644
index 0000000..51cd256
--- /dev/null
+++ b/src/include/pthread/tests/benchtest4.c
@@ -0,0 +1,195 @@
+/*
+ * benchtest4.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Measure time taken to complete an elementary operation.
+ *
+ * - Mutex
+ *   Single thread iteration over trylock/unlock for each mutex type.
+ */
+
+#include "test.h"
+
+#ifdef __GNUC__
+#include <stdlib.h>
+#endif
+
+#include "benchtest.h"
+
+#define  __PTW32_MUTEX_TYPES
+#define ITERATIONS      10000000L
+
+pthread_mutex_t mx;
+old_mutex_t ox;
+pthread_mutexattr_t ma;
+__PTW32_STRUCT_TIMEB currSysTimeStart;
+__PTW32_STRUCT_TIMEB currSysTimeStop;
+long durationMilliSecs;
+long overHeadMilliSecs = 0;
+
+#define GetDurationMilliSecs(_TStart, _TStop) ((long)((_TStop.time*1000+_TStop.millitm) \
+                                               - (_TStart.time*1000+_TStart.millitm)))
+
+/*
+ * Dummy use of j, otherwise the loop may be removed by the optimiser
+ * when doing the overhead timing with an empty loop.
+ */
+#define TESTSTART \
+  { int i, j = 0, k = 0;  __PTW32_FTIME(&currSysTimeStart); for (i = 0; i < ITERATIONS; i++) { j++;
+
+#define TESTSTOP \
+  };  __PTW32_FTIME(&currSysTimeStop); if (j + k == i) j++; }
+
+
+void
+oldRunTest (char * testNameString, int mType)
+{
+}
+
+
+void
+runTest (char * testNameString, int mType)
+{
+#ifdef  __PTW32_MUTEX_TYPES
+  pthread_mutexattr_settype(&ma, mType);
+#endif
+  pthread_mutex_init(&mx, &ma);
+
+  TESTSTART
+  (void) pthread_mutex_trylock(&mx);
+  (void) pthread_mutex_unlock(&mx);
+  TESTSTOP
+
+  pthread_mutex_destroy(&mx);
+
+  durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - overHeadMilliSecs;
+
+  printf( "%-45s %15ld %15.3f\n",
+	    testNameString,
+          durationMilliSecs,
+          (float) durationMilliSecs * 1E3 / ITERATIONS);
+}
+
+
+int
+main (int argc, char *argv[])
+{
+  pthread_mutexattr_init(&ma);
+
+  printf( "=============================================================================\n");
+  printf( "Trylock plus unlock on an unlocked mutex.\n");
+  printf( "%ld iterations.\n\n", ITERATIONS);
+  printf( "%-45s %15s %15s\n",
+	    "Test",
+	    "Total(msec)",
+	    "average(usec)");
+  printf( "-----------------------------------------------------------------------------\n");
+
+  /*
+   * Time the loop overhead so we can subtract it from the actual test times.
+   */
+
+  TESTSTART
+  TESTSTOP
+
+  durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - overHeadMilliSecs;
+  overHeadMilliSecs = durationMilliSecs;
+
+  old_mutex_use = OLD_WIN32CS;
+  assert(old_mutex_init(&ox, NULL) == 0);
+  TESTSTART
+  (void) old_mutex_trylock(&ox);
+  (void) old_mutex_unlock(&ox);
+  TESTSTOP
+  assert(old_mutex_destroy(&ox) == 0);
+  durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - overHeadMilliSecs;
+  printf( "%-45s %15ld %15.3f\n",
+	    "Old PT Mutex using a Critical Section (WNT)",
+          durationMilliSecs,
+          (float) durationMilliSecs * 1E3 / ITERATIONS);
+
+  old_mutex_use = OLD_WIN32MUTEX;
+  assert(old_mutex_init(&ox, NULL) == 0);
+  TESTSTART
+  (void) old_mutex_trylock(&ox);
+  (void) old_mutex_unlock(&ox);
+  TESTSTOP
+  assert(old_mutex_destroy(&ox) == 0);
+  durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - overHeadMilliSecs;
+  printf( "%-45s %15ld %15.3f\n",
+	    "Old PT Mutex using a Win32 Mutex (W9x)",
+          durationMilliSecs,
+          (float) durationMilliSecs * 1E3 / ITERATIONS);
+
+  printf( ".............................................................................\n");
+
+  /*
+   * Now we can start the actual tests
+   */
+#ifdef  __PTW32_MUTEX_TYPES
+  runTest("PTHREAD_MUTEX_DEFAULT", PTHREAD_MUTEX_DEFAULT);
+
+  runTest("PTHREAD_MUTEX_NORMAL", PTHREAD_MUTEX_NORMAL);
+
+  runTest("PTHREAD_MUTEX_ERRORCHECK", PTHREAD_MUTEX_ERRORCHECK);
+
+  runTest("PTHREAD_MUTEX_RECURSIVE", PTHREAD_MUTEX_RECURSIVE);
+#else
+  runTest("Non-blocking lock", 0);
+#endif
+
+  printf( ".............................................................................\n");
+
+  pthread_mutexattr_setrobust(&ma, PTHREAD_MUTEX_ROBUST);
+
+#ifdef  __PTW32_MUTEX_TYPES
+  runTest("PTHREAD_MUTEX_DEFAULT (Robust)", PTHREAD_MUTEX_DEFAULT);
+
+  runTest("PTHREAD_MUTEX_NORMAL (Robust)", PTHREAD_MUTEX_NORMAL);
+
+  runTest("PTHREAD_MUTEX_ERRORCHECK (Robust)", PTHREAD_MUTEX_ERRORCHECK);
+
+  runTest("PTHREAD_MUTEX_RECURSIVE (Robust)", PTHREAD_MUTEX_RECURSIVE);
+#else
+  runTest("Non-blocking lock", 0);
+#endif
+
+  printf( "=============================================================================\n");
+
+  /*
+   * End of tests.
+   */
+
+  pthread_mutexattr_destroy(&ma);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/benchtest5.c b/src/include/pthread/tests/benchtest5.c
new file mode 100644
index 0000000..d4fd515
--- /dev/null
+++ b/src/include/pthread/tests/benchtest5.c
@@ -0,0 +1,156 @@
+/*
+ * benchtest5.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Measure time taken to complete an elementary operation.
+ *
+ * - Semaphore
+ *   Single thread iteration over post/wait for a semaphore.
+ */
+
+#include "test.h"
+
+#ifdef __GNUC__
+#include <stdlib.h>
+#endif
+
+#include "benchtest.h"
+
+#define ITERATIONS      1000000L
+
+sem_t sema;
+HANDLE w32sema;
+
+__PTW32_STRUCT_TIMEB currSysTimeStart;
+__PTW32_STRUCT_TIMEB currSysTimeStop;
+long durationMilliSecs;
+long overHeadMilliSecs = 0;
+int one = 1;
+int zero = 0;
+
+#define GetDurationMilliSecs(_TStart, _TStop) ((long)((_TStop.time*1000+_TStop.millitm) \
+                                               - (_TStart.time*1000+_TStart.millitm)))
+
+/*
+ * Dummy use of j, otherwise the loop may be removed by the optimiser
+ * when doing the overhead timing with an empty loop.
+ */
+#define TESTSTART \
+  { int i, j = 0, k = 0;  __PTW32_FTIME(&currSysTimeStart); for (i = 0; i < ITERATIONS; i++) { j++;
+
+#define TESTSTOP \
+  };  __PTW32_FTIME(&currSysTimeStop); if (j + k == i) j++; }
+
+
+void
+reportTest (char * testNameString)
+{
+  durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - overHeadMilliSecs;
+
+  printf( "%-45s %15ld %15.3f\n",
+	    testNameString,
+          durationMilliSecs,
+          (float) durationMilliSecs * 1E3 / ITERATIONS);
+}
+
+
+int
+main (int argc, char *argv[])
+{
+  printf( "=============================================================================\n");
+  printf( "\nOperations on a semaphore.\n%ld iterations\n\n",
+          ITERATIONS);
+  printf( "%-45s %15s %15s\n",
+	    "Test",
+	    "Total(msec)",
+	    "average(usec)");
+  printf( "-----------------------------------------------------------------------------\n");
+
+  /*
+   * Time the loop overhead so we can subtract it from the actual test times.
+   */
+
+  TESTSTART
+  assert(1 == one);
+  TESTSTOP
+
+  durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - overHeadMilliSecs;
+  overHeadMilliSecs = durationMilliSecs;
+
+
+  /*
+   * Now we can start the actual tests
+   */
+  assert((w32sema = CreateSemaphore(NULL, (long) 0, (long) ITERATIONS, NULL)) != 0);
+  TESTSTART
+  assert((ReleaseSemaphore(w32sema, 1, NULL),1) == one);
+  TESTSTOP
+  assert(CloseHandle(w32sema) != 0);
+
+  reportTest("W32 Post with no waiters");
+
+
+  assert((w32sema = CreateSemaphore(NULL, (long) ITERATIONS, (long) ITERATIONS, NULL)) != 0);
+  TESTSTART
+  assert((WaitForSingleObject(w32sema, INFINITE),1) == one);
+  TESTSTOP
+  assert(CloseHandle(w32sema) != 0);
+
+  reportTest("W32 Wait without blocking");
+
+
+  assert(sem_init(&sema, 0, 0) == 0);
+  TESTSTART
+  assert((sem_post(&sema),1) == one);
+  TESTSTOP
+  assert(sem_destroy(&sema) == 0);
+
+  reportTest("POSIX Post with no waiters");
+
+
+  assert(sem_init(&sema, 0, ITERATIONS) == 0);
+  TESTSTART
+  assert((sem_wait(&sema),1) == one);
+  TESTSTOP
+  assert(sem_destroy(&sema) == 0);
+
+  reportTest("POSIX Wait without blocking");
+
+
+  printf( "=============================================================================\n");
+
+  /*
+   * End of tests.
+   */
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/cancel1.c b/src/include/pthread/tests/cancel1.c
new file mode 100644
index 0000000..b672230
--- /dev/null
+++ b/src/include/pthread/tests/cancel1.c
@@ -0,0 +1,177 @@
+/*
+ * File: cancel1.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis: Test setting cancel state and cancel type.
+ * -
+ *
+ * Test Method (Validation or Falsification):
+ * -
+ *
+ * Requirements Tested:
+ * - pthread_setcancelstate function
+ * - pthread_setcanceltype function
+ *
+ * Features Tested:
+ * -
+ *
+ * Cases Tested:
+ * -
+ *
+ * Description:
+ * -
+ *
+ * Environment:
+ * -
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * - pthread_create, pthread_self work.
+ *
+ * Pass Criteria:
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - Process returns non-zero exit status.
+ */
+
+#include "test.h"
+
+/*
+ * Create NUMTHREADS threads in addition to the Main thread.
+ */
+enum {
+  NUMTHREADS = 2
+};
+
+typedef struct bag_t_ bag_t;
+struct bag_t_ {
+  int threadnum;
+  int started;
+  /* Add more per-thread state variables here */
+};
+
+static bag_t threadbag[NUMTHREADS + 1];
+
+void *
+mythread(void * arg)
+{
+  bag_t * bag = (bag_t *) arg;
+
+  assert(bag == &threadbag[bag->threadnum]);
+  assert(bag->started == 0);
+  bag->started = 1;
+
+  /* ... */
+  {
+    int oldstate;
+    int oldtype;
+
+    assert(pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &oldstate) == 0);
+    assert(oldstate == PTHREAD_CANCEL_ENABLE); /* Check default */
+    assert(pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL) == 0);
+    assert(pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL) == 0);
+    assert(pthread_setcancelstate(oldstate, &oldstate) == 0);
+    assert(oldstate == PTHREAD_CANCEL_DISABLE); /* Check setting */
+
+    assert(pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &oldtype) == 0);
+    assert(oldtype == PTHREAD_CANCEL_DEFERRED); /* Check default */
+    assert(pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, NULL) == 0);
+    assert(pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL) == 0);
+    assert(pthread_setcanceltype(oldtype, &oldtype) == 0);
+    assert(oldtype == PTHREAD_CANCEL_ASYNCHRONOUS); /* Check setting */
+  }
+
+  return 0;
+}
+
+int
+main()
+{
+  int failed = 0;
+  int i;
+  pthread_t t[NUMTHREADS + 1];
+
+  assert((t[0] = pthread_self()).p != NULL);
+
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      threadbag[i].started = 0;
+      threadbag[i].threadnum = i;
+      assert(pthread_create(&t[i], NULL, mythread, (void *) &threadbag[i]) == 0);
+    }
+
+  /*
+   * Code to control or manipulate child threads should probably go here.
+   */
+
+  /*
+   * Give threads time to run.
+   */
+  Sleep(NUMTHREADS * 100);
+
+  /*
+   * Standard check that all threads started.
+   */
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      failed = !threadbag[i].started;
+
+      if (failed)
+	{
+	  fprintf(stderr, "Thread %d: started %d\n", i, threadbag[i].started);
+	}
+    }
+
+  assert(!failed);
+
+  /*
+   * Check any results here. Set "failed" and only print output on failure.
+   */
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      /* ... */
+    }
+
+  assert(!failed);
+
+  /*
+   * Success.
+   */
+  return 0;
+}
diff --git a/src/include/pthread/tests/cancel2.c b/src/include/pthread/tests/cancel2.c
new file mode 100644
index 0000000..a67fbd2
--- /dev/null
+++ b/src/include/pthread/tests/cancel2.c
@@ -0,0 +1,236 @@
+/*
+ * File: cancel2.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis: Test SEH or C++ cancel exception handling within
+ * application exception blocks.
+ *
+ * Test Method (Validation or Falsification):
+ * - 
+ *
+ * Requirements Tested:
+ * -
+ *
+ * Features Tested:
+ * - 
+ *
+ * Cases Tested:
+ * - 
+ *
+ * Description:
+ * - 
+ *
+ * Environment:
+ * - 
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * - have working pthread_create, pthread_self, pthread_mutex_lock/unlock
+ *   pthread_testcancel, pthread_cancel, pthread_join
+ *
+ * Pass Criteria:
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - Process returns non-zero exit status.
+ */
+
+/*
+ * Don't know how to identify if we are using SEH so it's only C++ for now
+ */
+#if defined(__cplusplus)
+
+#include "test.h"
+
+/*
+ * Create NUMTHREADS threads in addition to the Main thread.
+ */
+enum {
+  NUMTHREADS = 4
+};
+
+typedef struct bag_t_ bag_t;
+struct bag_t_ {
+  int threadnum;
+  int started;
+  /* Add more per-thread state variables here */
+};
+
+static bag_t threadbag[NUMTHREADS + 1];
+
+static pthread_barrier_t go = NULL;
+
+void *
+mythread(void * arg)
+{
+  int result = 0;
+  bag_t * bag = (bag_t *) arg;
+
+  assert(bag == &threadbag[bag->threadnum]);
+  assert(bag->started == 0);
+  bag->started = 1;
+
+  /* Set to known state and type */
+
+  assert(pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL) == 0);
+  assert(pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, NULL) == 0);
+  result = 1;
+
+#if !defined(__cplusplus)
+  __try
+#else
+  try
+#endif
+    {
+      /* Wait for go from main */
+      pthread_barrier_wait(&go);
+      pthread_barrier_wait(&go);
+
+      pthread_testcancel();
+    }
+#if !defined(__cplusplus)
+  __except(EXCEPTION_EXECUTE_HANDLER)
+#else
+#if defined(__PtW32CatchAll)
+  __PtW32CatchAll
+#else
+  catch(...)
+#endif
+#endif
+    {
+      /*
+       * Should not get into here.
+       */
+      result += 100;
+    }
+
+  /* 
+   * Should not get to here either.
+   */
+  result += 1000;
+
+  return (void *)(size_t)result;
+}
+
+int
+main()
+{
+  int failed = 0;
+  int i;
+  pthread_t t[NUMTHREADS + 1];
+
+  assert((t[0] = pthread_self()).p != NULL);
+  assert(pthread_barrier_init(&go, NULL, NUMTHREADS + 1) == 0);
+
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      threadbag[i].started = 0;
+      threadbag[i].threadnum = i;
+      assert(pthread_create(&t[i], NULL, mythread, (void *) &threadbag[i]) == 0);
+    }
+
+  /*
+   * Code to control or manipulate child threads should probably go here.
+   */
+
+  pthread_barrier_wait(&go);
+
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      assert(pthread_cancel(t[i]) == 0);
+    }
+
+  pthread_barrier_wait(&go);
+
+  /*
+   * Standard check that all threads started.
+   */
+  for (i = 1; i <= NUMTHREADS; i++)
+    { 
+      if (!threadbag[i].started)
+	{
+	  failed |= !threadbag[i].started;
+	  fprintf(stderr, "Thread %d: started %d\n", i, threadbag[i].started);
+	}
+    }
+
+  assert(!failed);
+
+  /*
+   * Check any results here. Set "failed" and only print output on failure.
+   */
+  failed = 0;
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      int fail = 0;
+      void* result = (void*)0;
+
+      assert(pthread_join(t[i], &result) == 0);
+      fail = (result != PTHREAD_CANCELED);
+      if (fail)
+	{
+	  fprintf(stderr, "Thread %d: started %d: location %d\n",
+		  i,
+		  threadbag[i].started,
+		  (int)(size_t)result);
+	}
+      failed |= fail;
+    }
+
+  assert(!failed);
+  assert(pthread_barrier_destroy(&go) == 0);
+
+  /*
+   * Success.
+   */
+  return 0;
+}
+
+#else /* defined(__cplusplus) */
+
+#include <stdio.h>
+
+int
+main()
+{
+  fprintf(stderr, "Test N/A for this compiler environment.\n");
+  return 0;
+}
+
+#endif /* defined(__cplusplus) */
+
diff --git a/src/include/pthread/tests/cancel3.c b/src/include/pthread/tests/cancel3.c
new file mode 100644
index 0000000..88e203d
--- /dev/null
+++ b/src/include/pthread/tests/cancel3.c
@@ -0,0 +1,202 @@
+/*
+ * File: cancel3.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis: Test asynchronous cancellation (alertable or non-alertable).
+ *
+ * Test Method (Validation or Falsification):
+ * - 
+ *
+ * Requirements Tested:
+ * - Async cancel if thread is not blocked (i.e. voluntarily resumes if blocked).
+ *
+ * Features Tested:
+ * - 
+ *
+ * Cases Tested:
+ * - 
+ *
+ * Description:
+ * - 
+ *
+ * Environment:
+ * - 
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * - have working pthread_create, pthread_self, pthread_mutex_lock/unlock
+ *   pthread_testcancel, pthread_cancel, pthread_join.
+ * - quserex.dll and alertdrv.sys are not available.
+ *
+ * Pass Criteria:
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - Process returns non-zero exit status.
+ */
+
+#include "test.h"
+
+/*
+ * Create NUMTHREADS threads in addition to the Main thread.
+ */
+enum
+{
+  NUMTHREADS = 4
+};
+
+typedef struct bag_t_ bag_t;
+struct bag_t_
+{
+  int threadnum;
+  int started;
+  /* Add more per-thread state variables here */
+  int count;
+};
+
+static bag_t threadbag[NUMTHREADS + 1];
+
+void *
+mythread (void *arg)
+{
+  void* result = (void*)((int)(size_t)PTHREAD_CANCELED + 1);
+  bag_t *bag = (bag_t *) arg;
+
+  assert (bag == &threadbag[bag->threadnum]);
+  assert (bag->started == 0);
+  bag->started = 1;
+
+  /* Set to known state and type */
+
+  assert (pthread_setcancelstate (PTHREAD_CANCEL_ENABLE, NULL) == 0);
+
+  assert (pthread_setcanceltype (PTHREAD_CANCEL_ASYNCHRONOUS, NULL) == 0);
+
+  /*
+   * We wait up to 10 seconds, waking every 0.1 seconds,
+   * for a cancellation to be applied to us.
+   */
+  for (bag->count = 0; bag->count < 100; bag->count++)
+    Sleep (100);
+
+  return result;
+}
+
+int
+main ()
+{
+  int failed = 0;
+  int i;
+  pthread_t t[NUMTHREADS + 1];
+
+  DWORD dwMode = SetErrorMode(SEM_NOGPFAULTERRORBOX);
+  SetErrorMode(dwMode | SEM_NOGPFAULTERRORBOX);
+
+  assert ((t[0] = pthread_self ()).p != NULL);
+
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      threadbag[i].started = 0;
+      threadbag[i].threadnum = i;
+      assert (pthread_create (&t[i], NULL, mythread, (void *) &threadbag[i])
+	      == 0);
+    }
+
+  /*
+   * Code to control or manipulate child threads should probably go here.
+   */
+  Sleep (NUMTHREADS * 100);
+
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      assert (pthread_cancel (t[i]) == 0);
+    }
+
+  /*
+   * Give threads time to complete.
+   */
+  Sleep (NUMTHREADS * 100);
+
+  /*
+   * Standard check that all threads started.
+   */
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      if (!threadbag[i].started)
+	{
+	  failed |= !threadbag[i].started;
+	  fprintf (stderr, "Thread %d: started %d\n", i,
+		   threadbag[i].started);
+	}
+    }
+
+  assert (!failed);
+
+  /*
+   * Check any results here. Set "failed" and only print output on failure.
+   */
+  failed = 0;
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      int fail = 0;
+      void* result = (void*)0;
+
+      /*
+       * The thread does not contain any cancellation points, so
+       * a return value of PTHREAD_CANCELED confirms that async
+       * cancellation succeeded.
+       */
+      assert (pthread_join (t[i], &result) == 0);
+
+      fail = (result != PTHREAD_CANCELED);
+
+      if (fail)
+	{
+	  fprintf (stderr, "Thread %d: started %d: count %d\n",
+		   i, threadbag[i].started, threadbag[i].count);
+	}
+      failed = (failed || fail);
+    }
+
+  assert (!failed);
+
+  /*
+   * Success.
+   */
+  return 0;
+}
diff --git a/src/include/pthread/tests/cancel4.c b/src/include/pthread/tests/cancel4.c
new file mode 100644
index 0000000..7f31d6b
--- /dev/null
+++ b/src/include/pthread/tests/cancel4.c
@@ -0,0 +1,201 @@
+/*
+ * File: cancel4.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis: Test cancellation does not occur in deferred
+ *                cancellation threads with no cancellation points.
+ *
+ * Test Method (Validation or Falsification):
+ * - 
+ *
+ * Requirements Tested:
+ * -
+ *
+ * Features Tested:
+ * - 
+ *
+ * Cases Tested:
+ * - 
+ *
+ * Description:
+ * - 
+ *
+ * Environment:
+ * - 
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * - pthread_create
+ *   pthread_self
+ *   pthread_cancel
+ *   pthread_join
+ *   pthread_setcancelstate
+ *   pthread_setcanceltype
+ *
+ * Pass Criteria:
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - Process returns non-zero exit status.
+ */
+
+#include "test.h"
+
+/*
+ * Create NUMTHREADS threads in addition to the Main thread.
+ */
+enum {
+  NUMTHREADS = 4
+};
+
+typedef struct bag_t_ bag_t;
+struct bag_t_ {
+  int threadnum;
+  int started;
+  /* Add more per-thread state variables here */
+  int count;
+};
+
+static bag_t threadbag[NUMTHREADS + 1];
+
+void *
+mythread(void * arg)
+{
+  void* result = (void*)((int)(size_t)PTHREAD_CANCELED + 1);
+  bag_t * bag = (bag_t *) arg;
+
+  assert(bag == &threadbag[bag->threadnum]);
+  assert(bag->started == 0);
+  bag->started = 1;
+
+  /* Set to known state and type */
+
+  assert(pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL) == 0);
+
+  assert(pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, NULL) == 0);
+
+  /*
+   * We wait up to 2 seconds, waking every 0.1 seconds,
+   * for a cancellation to be applied to us.
+   */
+  for (bag->count = 0; bag->count < 20; bag->count++)
+    Sleep(100);
+
+  return result;
+}
+
+int
+main()
+{
+  int failed = 0;
+  int i;
+  pthread_t t[NUMTHREADS + 1];
+
+  assert((t[0] = pthread_self()).p != NULL);
+
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      threadbag[i].started = 0;
+      threadbag[i].threadnum = i;
+      assert(pthread_create(&t[i], NULL, mythread, (void *) &threadbag[i]) == 0);
+    }
+
+  /*
+   * Code to control or manipulate child threads should probably go here.
+   */
+  Sleep(500);
+
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      assert(pthread_cancel(t[i]) == 0);
+    }
+
+  /*
+   * Give threads time to run.
+   */
+  Sleep(NUMTHREADS * 100);
+
+  /*
+   * Standard check that all threads started.
+   */
+  for (i = 1; i <= NUMTHREADS; i++)
+    { 
+      if (!threadbag[i].started)
+	{
+	  failed |= !threadbag[i].started;
+	  fprintf(stderr, "Thread %d: started %d\n", i, threadbag[i].started);
+	}
+    }
+
+  assert(!failed);
+
+  /*
+   * Check any results here. Set "failed" and only print output on failure.
+   */
+  failed = 0;
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      int fail = 0;
+      void* result = (void*)0;
+
+      /*
+       * The thread does not contain any cancellation points, so
+       * a return value of PTHREAD_CANCELED indicates that async
+       * cancellation occurred.
+       */
+      assert(pthread_join(t[i], &result) == 0);
+
+      fail = (result == PTHREAD_CANCELED);
+
+      if (fail)
+	{
+	  fprintf(stderr, "Thread %d: started %d: count %d\n",
+		  i,
+		  threadbag[i].started,
+		  threadbag[i].count);
+	}
+      failed = (failed || fail);
+    }
+
+  assert(!failed);
+
+  /*
+   * Success.
+   */
+  return 0;
+}
diff --git a/src/include/pthread/tests/cancel5.c b/src/include/pthread/tests/cancel5.c
new file mode 100644
index 0000000..9bc770b
--- /dev/null
+++ b/src/include/pthread/tests/cancel5.c
@@ -0,0 +1,200 @@
+/*
+ * File: cancel5.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis: Test calling pthread_cancel from the main thread
+ *                without calling pthread_self() in main.
+ *
+ * Test Method (Validation or Falsification):
+ * - 
+ *
+ * Requirements Tested:
+ * -
+ *
+ * Features Tested:
+ * - 
+ *
+ * Cases Tested:
+ * - 
+ *
+ * Description:
+ * - 
+ *
+ * Environment:
+ * - 
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * - have working pthread_create, pthread_self, pthread_mutex_lock/unlock
+ *   pthread_testcancel, pthread_cancel, pthread_join
+ *
+ * Pass Criteria:
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - Process returns non-zero exit status.
+ */
+
+#include "test.h"
+
+/*
+ * Create NUMTHREADS threads in addition to the Main thread.
+ */
+enum
+{
+  NUMTHREADS = 4
+};
+
+typedef struct bag_t_ bag_t;
+struct bag_t_
+{
+  int threadnum;
+  int started;
+  /* Add more per-thread state variables here */
+  int count;
+};
+
+static bag_t threadbag[NUMTHREADS + 1];
+
+void *
+mythread (void *arg)
+{
+  void* result = (void*)((int)(size_t)PTHREAD_CANCELED + 1);
+  bag_t *bag = (bag_t *) arg;
+
+  assert (bag == &threadbag[bag->threadnum]);
+  assert (bag->started == 0);
+  bag->started = 1;
+
+  /* Set to known state and type */
+
+  assert (pthread_setcancelstate (PTHREAD_CANCEL_ENABLE, NULL) == 0);
+
+  assert (pthread_setcanceltype (PTHREAD_CANCEL_ASYNCHRONOUS, NULL) == 0);
+
+  /*
+   * We wait up to 10 seconds, waking every 0.1 seconds,
+   * for a cancellation to be applied to us.
+   */
+  for (bag->count = 0; bag->count < 100; bag->count++)
+    Sleep (100);
+
+  return result;
+}
+
+int
+main ()
+{
+  int failed = 0;
+  int i;
+  pthread_t t[NUMTHREADS + 1];
+
+  DWORD dwMode = SetErrorMode(SEM_NOGPFAULTERRORBOX);
+  SetErrorMode(dwMode | SEM_NOGPFAULTERRORBOX);
+
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      threadbag[i].started = 0;
+      threadbag[i].threadnum = i;
+      assert (pthread_create (&t[i], NULL, mythread, (void *) &threadbag[i])
+	      == 0);
+    }
+
+  /*
+   * Code to control or manipulate child threads should probably go here.
+   */
+  Sleep (500);
+
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      assert (pthread_cancel (t[i]) == 0);
+    }
+
+  /*
+   * Give threads time to run.
+   */
+  Sleep (NUMTHREADS * 100);
+
+  /*
+   * Standard check that all threads started.
+   */
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      if (!threadbag[i].started)
+	{
+	  failed |= !threadbag[i].started;
+	  fprintf (stderr, "Thread %d: started %d\n", i,
+		   threadbag[i].started);
+	}
+    }
+
+  assert (!failed);
+
+  /*
+   * Check any results here. Set "failed" and only print output on failure.
+   */
+  failed = 0;
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      int fail = 0;
+      void* result = (void*)((int)(size_t)PTHREAD_CANCELED + 1);
+
+      /*
+       * The thread does not contain any cancellation points, so
+       * a return value of PTHREAD_CANCELED confirms that async
+       * cancellation succeeded.
+       */
+      assert (pthread_join (t[i], &result) == 0);
+
+      fail = (result != PTHREAD_CANCELED);
+
+      if (fail)
+	{
+	  fprintf (stderr, "Thread %d: started %d: count %d\n",
+		   i, threadbag[i].started, threadbag[i].count);
+	}
+      failed = (failed || fail);
+    }
+
+  assert (!failed);
+
+  /*
+   * Success.
+   */
+  return 0;
+}
diff --git a/src/include/pthread/tests/cancel6a.c b/src/include/pthread/tests/cancel6a.c
new file mode 100644
index 0000000..7646458
--- /dev/null
+++ b/src/include/pthread/tests/cancel6a.c
@@ -0,0 +1,199 @@
+/*
+ * File: cancel6a.c
+ *
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis: Test double cancellation - asynchronous.
+ * Second attempt should fail (ESRCH).
+ *
+ * Test Method (Validation or Falsification):
+ * -
+ *
+ * Requirements Tested:
+ * -
+ *
+ * Features Tested:
+ * - 
+ *
+ * Cases Tested:
+ * - 
+ *
+ * Description:
+ * - 
+ *
+ * Environment:
+ * - 
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * - have working pthread_create, pthread_self, pthread_mutex_lock/unlock
+ *   pthread_testcancel, pthread_cancel, pthread_join
+ *
+ * Pass Criteria:
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - Process returns non-zero exit status.
+ */
+
+#include "test.h"
+
+/*
+ * Create NUMTHREADS threads in addition to the Main thread.
+ */
+enum {
+  NUMTHREADS = 4
+};
+
+typedef struct bag_t_ bag_t;
+struct bag_t_ {
+  int threadnum;
+  int started;
+  /* Add more per-thread state variables here */
+  int count;
+};
+
+static bag_t threadbag[NUMTHREADS + 1];
+
+void *
+mythread(void * arg)
+{
+  void* result = (void*)((int)(size_t)PTHREAD_CANCELED + 1);
+  bag_t * bag = (bag_t *) arg;
+
+  assert(bag == &threadbag[bag->threadnum]);
+  assert(bag->started == 0);
+  bag->started = 1;
+
+  /* Set to known state and type */
+
+  assert(pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL) == 0);
+
+  assert(pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL) == 0);
+
+  /*
+   * We wait up to 10 seconds, waking every 0.1 seconds,
+   * for a cancellation to be applied to us.
+   */
+  for (bag->count = 0; bag->count < 100; bag->count++)
+    Sleep(100);
+
+  return result;
+}
+
+int
+main()
+{
+  int failed = 0;
+  int i;
+  pthread_t t[NUMTHREADS + 1];
+
+  DWORD dwMode = SetErrorMode(SEM_NOGPFAULTERRORBOX);
+  SetErrorMode(dwMode | SEM_NOGPFAULTERRORBOX);
+
+  assert((t[0] = pthread_self()).p != NULL);
+
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      threadbag[i].started = 0;
+      threadbag[i].threadnum = i;
+      assert(pthread_create(&t[i], NULL, mythread, (void *) &threadbag[i]) == 0);
+    }
+
+  /*
+   * Code to control or manipulate child threads should probably go here.
+   */
+  Sleep(500);
+
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      assert(pthread_cancel(t[i]) == 0);
+      assert(pthread_cancel(t[i]) == ESRCH);
+    }
+
+  /*
+   * Give threads time to run.
+   */
+  Sleep(NUMTHREADS * 100);
+
+  /*
+   * Standard check that all threads started.
+   */
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      if (!threadbag[i].started)
+	{
+	  failed |= !threadbag[i].started;
+	  fprintf(stderr, "Thread %d: started %d\n", i, threadbag[i].started);
+	}
+    }
+
+  assert(!failed);
+
+  /*
+   * Check any results here. Set "failed" and only print output on failure.
+   */
+  failed = 0;
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      int fail = 0;
+      void* result = (void*)0;
+
+      /*
+       * The thread does not contain any cancellation points, so
+       * a return value of PTHREAD_CANCELED confirms that async
+       * cancellation succeeded.
+       */
+      assert(pthread_join(t[i], &result) == 0);
+
+      fail = (result != PTHREAD_CANCELED);
+
+      if (fail)
+	{
+	  fprintf(stderr, "Thread %d: started %d: count %d\n",
+		  i,
+		  threadbag[i].started,
+		  threadbag[i].count);
+	}
+      failed = (failed || fail);
+    }
+
+  assert(!failed);
+
+  /*
+   * Success.
+   */
+  return 0;
+}
diff --git a/src/include/pthread/tests/cancel6d.c b/src/include/pthread/tests/cancel6d.c
new file mode 100644
index 0000000..2ead7dc
--- /dev/null
+++ b/src/include/pthread/tests/cancel6d.c
@@ -0,0 +1,198 @@
+/*
+ * File: cancel6d.c
+ *
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis: Test double cancellation - deferred.
+ * Second attempt should succeed (unless the canceled thread has started
+ * cancellation already - not tested here).
+ *
+ * Test Method (Validation or Falsification):
+ * -
+ *
+ * Requirements Tested:
+ * -
+ *
+ * Features Tested:
+ * - 
+ *
+ * Cases Tested:
+ * - 
+ *
+ * Description:
+ * - 
+ *
+ * Environment:
+ * - 
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * - have working pthread_create, pthread_self, pthread_mutex_lock/unlock
+ *   pthread_testcancel, pthread_cancel, pthread_join
+ *
+ * Pass Criteria:
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - Process returns non-zero exit status.
+ */
+
+#include "test.h"
+
+/*
+ * Create NUMTHREADS threads in addition to the Main thread.
+ */
+enum {
+  NUMTHREADS = 4
+};
+
+typedef struct bag_t_ bag_t;
+struct bag_t_ {
+  int threadnum;
+  int started;
+  /* Add more per-thread state variables here */
+  int count;
+};
+
+static bag_t threadbag[NUMTHREADS + 1];
+
+void *
+mythread(void * arg)
+{
+  void* result = (void*)((int)(size_t)PTHREAD_CANCELED + 1);
+  bag_t * bag = (bag_t *) arg;
+
+  assert(bag == &threadbag[bag->threadnum]);
+  assert(bag->started == 0);
+  bag->started = 1;
+
+  /* Set to known state and type */
+
+  assert(pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL) == 0);
+
+  assert(pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, NULL) == 0);
+
+  /*
+   * We wait up to 10 seconds, waking every 0.1 seconds,
+   * for a cancellation to be applied to us.
+   */
+  for (bag->count = 0; bag->count < 100; bag->count++)
+    {
+      Sleep(100);
+      pthread_testcancel();
+    }
+
+  return result;
+}
+
+int
+main()
+{
+  int failed = 0;
+  int i;
+  pthread_t t[NUMTHREADS + 1];
+
+  assert((t[0] = pthread_self()).p != NULL);
+
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      threadbag[i].started = 0;
+      threadbag[i].threadnum = i;
+      assert(pthread_create(&t[i], NULL, mythread, (void *)(size_t) &threadbag[i]) == 0);
+    }
+
+  /*
+   * Code to control or manipulate child threads should probably go here.
+   */
+  Sleep(500);
+
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      assert(pthread_cancel(t[i]) == 0);
+      if (pthread_cancel(t[i]) != 0)
+        {
+          printf("Second cancellation failed but this is expected sometimes.\n");
+        }
+    }
+
+  /*
+   * Give threads time to run.
+   */
+  Sleep(NUMTHREADS * 100);
+
+  /*
+   * Standard check that all threads started.
+   */
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      if (!threadbag[i].started)
+	{
+	  failed |= !threadbag[i].started;
+	  fprintf(stderr, "Thread %d: started %d\n", i, threadbag[i].started);
+	}
+    }
+
+  assert(!failed);
+
+  /*
+   * Check any results here. Set "failed" and only print output on failure.
+   */
+  failed = 0;
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      int fail = 0;
+      void* result = (void*)0;
+
+      assert(pthread_join(t[i], &result) == 0);
+
+      fail = (result != PTHREAD_CANCELED);
+
+      if (fail)
+	{
+	  fprintf(stderr, "Thread %d: started %d: count %d\n",
+		  i,
+		  threadbag[i].started,
+		  threadbag[i].count);
+	}
+      failed = (failed || fail);
+    }
+
+  assert(!failed);
+
+  /*
+   * Success.
+   */
+  return 0;
+}
diff --git a/src/include/pthread/tests/cancel7.c b/src/include/pthread/tests/cancel7.c
new file mode 100644
index 0000000..cd3a577
--- /dev/null
+++ b/src/include/pthread/tests/cancel7.c
@@ -0,0 +1,216 @@
+/*
+ * File: cancel7.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis: Test canceling a Win32 thread having created an
+ * implicit POSIX handle for it.
+ *
+ * Test Method (Validation or Falsification):
+ * - Validate return value and that POSIX handle is created and destroyed.
+ *
+ * Requirements Tested:
+ * -
+ *
+ * Features Tested:
+ * - 
+ *
+ * Cases Tested:
+ * - 
+ *
+ * Description:
+ * - 
+ *
+ * Environment:
+ * - 
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * - have working pthread_create, pthread_self, pthread_mutex_lock/unlock
+ *   pthread_testcancel, pthread_cancel
+ *
+ * Pass Criteria:
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - Process returns non-zero exit status.
+ */
+
+#include "test.h"
+#ifndef _UWIN
+#include <process.h>
+#endif
+
+/*
+ * Create NUMTHREADS threads in addition to the Main thread.
+ */
+enum {
+  NUMTHREADS = 4
+};
+
+typedef struct bag_t_ bag_t;
+struct bag_t_ {
+  int threadnum;
+  int started;
+  /* Add more per-thread state variables here */
+  int count;
+  pthread_t self;
+};
+
+static bag_t threadbag[NUMTHREADS + 1];
+
+#if ! defined (__MINGW32__) || defined (__MSVCRT__)
+unsigned __stdcall
+#else
+void
+#endif
+Win32thread(void * arg)
+{
+  int i;
+  bag_t * bag = (bag_t *) arg;
+
+  assert(bag == &threadbag[bag->threadnum]);
+  assert(bag->started == 0);
+  bag->started = 1;
+
+  assert((bag->self = pthread_self()).p != NULL);
+  assert(pthread_kill(bag->self, 0) == 0);
+
+  for (i = 0; i < 100; i++)
+    {
+      Sleep(100);
+      pthread_testcancel();
+    }
+
+#if ! defined (__MINGW32__) || defined (__MSVCRT__)
+  return 0;
+#endif
+}
+
+int
+main()
+{
+  int failed = 0;
+  int i;
+  HANDLE h[NUMTHREADS + 1];
+  unsigned thrAddr; /* Dummy variable to pass a valid location to _beginthreadex (Win98). */
+
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      threadbag[i].started = 0;
+      threadbag[i].threadnum = i;
+#if ! defined (__MINGW32__) || defined (__MSVCRT__)
+      h[i] = (HANDLE) _beginthreadex(NULL, 0, Win32thread, (void *) &threadbag[i], 0, &thrAddr);
+#else
+      h[i] = (HANDLE) _beginthread(Win32thread, 0, (void *) &threadbag[i]);
+#endif
+    }
+
+  /*
+   * Code to control or manipulate child threads should probably go here.
+   */
+  Sleep(500);
+
+  /*
+   * Cancel all threads.
+   */
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      assert(pthread_kill(threadbag[i].self, 0) == 0);
+      assert(pthread_cancel(threadbag[i].self) == 0);
+    }
+
+  /*
+   * Give threads time to run.
+   */
+  Sleep(NUMTHREADS * 100);
+
+  /*
+   * Standard check that all threads started.
+   */
+  for (i = 1; i <= NUMTHREADS; i++)
+    { 
+      if (!threadbag[i].started)
+	{
+	  failed |= !threadbag[i].started;
+	  fprintf(stderr, "Thread %d: started %d\n", i, threadbag[i].started);
+	}
+    }
+
+  assert(!failed);
+
+  /*
+   * Check any results here. Set "failed" and only print output on failure.
+   */
+  failed = 0;
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      int fail = 0;
+      int result = 0;
+
+#if ! defined (__MINGW32__) || defined (__MSVCRT__)
+      assert(GetExitCodeThread(h[i], (LPDWORD) &result) == TRUE);
+#else
+      /*
+       * Can't get a result code.
+       */
+      result = (int)(size_t)PTHREAD_CANCELED;
+#endif
+
+      assert(threadbag[i].self.p != NULL);
+      assert(pthread_kill(threadbag[i].self, 0) == ESRCH);
+
+      fail = (result != (int)(size_t)PTHREAD_CANCELED);
+
+      if (fail)
+	{
+	  fprintf(stderr, "Thread %d: started %d: count %d\n",
+		  i,
+		  threadbag[i].started,
+		  threadbag[i].count);
+	}
+      failed = (failed || fail);
+    }
+
+  assert(!failed);
+
+  /*
+   * Success.
+   */
+  return 0;
+}
+
diff --git a/src/include/pthread/tests/cancel8.c b/src/include/pthread/tests/cancel8.c
new file mode 100644
index 0000000..f2c20a2
--- /dev/null
+++ b/src/include/pthread/tests/cancel8.c
@@ -0,0 +1,217 @@
+/*
+ * File: cancel8.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis: Test cancelling a blocked Win32 thread having created an
+ * implicit POSIX handle for it.
+ *
+ * Test Method (Validation or Falsification):
+ * - Validate return value and that POSIX handle is created and destroyed.
+ *
+ * Requirements Tested:
+ * -
+ *
+ * Features Tested:
+ * - 
+ *
+ * Cases Tested:
+ * - 
+ *
+ * Description:
+ * - 
+ *
+ * Environment:
+ * - 
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * - have working pthread_create, pthread_self, pthread_mutex_lock/unlock
+ *   pthread_testcancel, pthread_cancel
+ *
+ * Pass Criteria:
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - Process returns non-zero exit status.
+ */
+
+#include "test.h"
+#ifndef _UWIN
+#include <process.h>
+#endif
+
+/*
+ * Create NUMTHREADS threads in addition to the Main thread.
+ */
+enum {
+  NUMTHREADS = 4
+};
+
+typedef struct bag_t_ bag_t;
+struct bag_t_ {
+  int threadnum;
+  int started;
+  /* Add more per-thread state variables here */
+  int count;
+  pthread_t self;
+};
+
+static bag_t threadbag[NUMTHREADS + 1];
+
+pthread_cond_t CV = PTHREAD_COND_INITIALIZER;
+pthread_mutex_t CVLock = PTHREAD_MUTEX_INITIALIZER;
+
+#if ! defined (__MINGW32__) || defined (__MSVCRT__)
+unsigned __stdcall
+#else
+void
+#endif
+Win32thread(void * arg)
+{
+  bag_t * bag = (bag_t *) arg;
+
+  assert(bag == &threadbag[bag->threadnum]);
+  assert(bag->started == 0);
+  bag->started = 1;
+
+  assert((bag->self = pthread_self()).p != NULL);
+  assert(pthread_kill(bag->self, 0) == 0);
+
+  assert(pthread_mutex_lock(&CVLock) == 0);
+  pthread_cleanup_push(pthread_mutex_unlock, &CVLock);
+  pthread_cond_wait(&CV, &CVLock);
+  pthread_cleanup_pop(1);
+
+#if ! defined (__MINGW32__) || defined (__MSVCRT__)
+  return 0;
+#endif
+}
+
+int
+main()
+{
+  int failed = 0;
+  int i;
+  HANDLE h[NUMTHREADS + 1];
+  unsigned thrAddr; /* Dummy variable to pass a valid location to _beginthreadex (Win98). */
+
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      threadbag[i].started = 0;
+      threadbag[i].threadnum = i;
+#if ! defined (__MINGW32__) || defined (__MSVCRT__)
+      h[i] = (HANDLE) _beginthreadex(NULL, 0, Win32thread, (void *) &threadbag[i], 0, &thrAddr);
+#else
+      h[i] = (HANDLE) _beginthread(Win32thread, 0, (void *) &threadbag[i]);
+#endif
+    }
+
+  /*
+   * Code to control or manipulate child threads should probably go here.
+   */
+  Sleep(500);
+
+  /*
+   * Cancel all threads.
+   */
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      assert(pthread_kill(threadbag[i].self, 0) == 0);
+      assert(pthread_cancel(threadbag[i].self) == 0);
+    }
+
+  /*
+   * Give threads time to run.
+   */
+  Sleep(NUMTHREADS * 100);
+
+  /*
+   * Standard check that all threads started.
+   */
+  for (i = 1; i <= NUMTHREADS; i++)
+    { 
+      if (!threadbag[i].started)
+	{
+	  failed |= !threadbag[i].started;
+	  fprintf(stderr, "Thread %d: started %d\n", i, threadbag[i].started);
+	}
+    }
+
+  assert(!failed);
+
+  /*
+   * Check any results here. Set "failed" and only print output on failure.
+   */
+  failed = 0;
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      int fail = 0;
+      int result = 0;
+
+#if ! defined (__MINGW32__) || defined (__MSVCRT__)
+      assert(GetExitCodeThread(h[i], (LPDWORD) &result) == TRUE);
+#else
+      /*
+       * Can't get a result code.
+       */
+      result = (int)(size_t)PTHREAD_CANCELED;
+#endif
+
+      assert(threadbag[i].self.p != NULL);
+      assert(pthread_kill(threadbag[i].self, 0) == ESRCH);
+
+      fail = (result != (int)(size_t)PTHREAD_CANCELED);
+
+      if (fail)
+	{
+	  fprintf(stderr, "Thread %d: started %d: count %d\n",
+		  i,
+		  threadbag[i].started,
+		  threadbag[i].count);
+	}
+      failed = (failed || fail);
+    }
+
+  assert(!failed);
+
+  /*
+   * Success.
+   */
+  return 0;
+}
+
diff --git a/src/include/pthread/tests/cancel9.c b/src/include/pthread/tests/cancel9.c
new file mode 100644
index 0000000..52468ac
--- /dev/null
+++ b/src/include/pthread/tests/cancel9.c
@@ -0,0 +1,198 @@
+/*
+ * File: cancel9.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis: Test true asynchronous cancellation with Alert driver.
+ *
+ * Test Method (Validation or Falsification):
+ * -
+ *
+ * Requirements Tested:
+ * - Cancel threads, including those blocked on system recources
+ *   such as network I/O.
+ *
+ * Features Tested:
+ * -
+ *
+ * Cases Tested:
+ * -
+ *
+ * Description:
+ * -
+ *
+ * Environment:
+ * -
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * - have working pthread_create, pthread_self, pthread_mutex_lock/unlock
+ *   pthread_testcancel, pthread_cancel, pthread_join
+ *
+ * Pass Criteria:
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - Process returns non-zero exit status.
+ */
+
+#include "test.h"
+#include <windows.h>
+
+
+void *
+test_udp (void *arg)
+{
+  struct sockaddr_in serverAddress;
+  struct sockaddr_in clientAddress;
+  SOCKET UDPSocket;
+  int addr_len;
+  int nbyte;
+  char buffer[4096];
+  WORD wsaVersion = MAKEWORD (2, 2);
+  WSADATA wsaData;
+
+  pthread_setcancelstate (PTHREAD_CANCEL_ENABLE, NULL);
+  pthread_setcanceltype (PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
+
+  if (WSAStartup (wsaVersion, &wsaData) != 0)
+    {
+      return NULL;
+    }
+
+  UDPSocket = socket (AF_INET, SOCK_DGRAM, 0);
+  if ((int)UDPSocket == -1)
+    {
+      printf ("Server: socket ERROR \n");
+      exit (-1);
+    }
+
+  serverAddress.sin_family = AF_INET;
+  serverAddress.sin_addr.s_addr = INADDR_ANY;
+  serverAddress.sin_port = htons (9003);
+
+  if (bind
+      (UDPSocket, (struct sockaddr *) &serverAddress,
+       sizeof (struct sockaddr_in)))
+    {
+      printf ("Server: ERROR can't bind UDPSocket");
+      exit (-1);
+    }
+
+  addr_len = sizeof (struct sockaddr);
+
+  nbyte = 512;
+
+  (void) recvfrom (UDPSocket, (char *) buffer, nbyte, 0,
+	           (struct sockaddr *) &clientAddress, &addr_len);
+
+  closesocket (UDPSocket);
+  WSACleanup ();
+
+  return NULL;
+}
+
+
+void *
+test_sleep (void *arg)
+{
+  pthread_setcancelstate (PTHREAD_CANCEL_ENABLE, NULL);
+  pthread_setcanceltype (PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
+
+  Sleep (1000);
+  return NULL;
+
+}
+
+void *
+test_wait (void *arg)
+{
+  HANDLE hEvent;
+
+  pthread_setcancelstate (PTHREAD_CANCEL_ENABLE, NULL);
+  pthread_setcanceltype (PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
+
+  hEvent = CreateEvent (NULL, FALSE, FALSE, NULL);
+
+  (void) WaitForSingleObject (hEvent, 1000);	/* WAIT_IO_COMPLETION */
+
+  return NULL;
+}
+
+
+int
+main ()
+{
+  pthread_t t;
+  void *result;
+
+  if (pthread_win32_test_features_np  (__PTW32_ALERTABLE_ASYNC_CANCEL))
+    {
+      printf ("Cancel sleeping thread.\n");
+      assert (pthread_create (&t, NULL, test_sleep, NULL) == 0);
+      /* Sleep for a while; then cancel */
+      Sleep (100);
+      assert (pthread_cancel (t) == 0);
+      assert (pthread_join (t, &result) == 0);
+      assert (result == PTHREAD_CANCELED && "test_sleep");
+
+      printf ("Cancel waiting thread.\n");
+      assert (pthread_create (&t, NULL, test_wait, NULL) == 0);
+      /* Sleep for a while; then cancel. */
+      Sleep (100);
+      assert (pthread_cancel (t) == 0);
+      assert (pthread_join (t, &result) == 0);
+      assert (result == PTHREAD_CANCELED && "test_wait");
+
+      printf ("Cancel blocked thread (blocked on network I/O).\n");
+      assert (pthread_create (&t, NULL, test_udp, NULL) == 0);
+      /* Sleep for a while; then cancel. */
+      Sleep (100);
+      assert (pthread_cancel (t) == 0);
+      assert (pthread_join (t, &result) == 0);
+      assert (result == PTHREAD_CANCELED && "test_udp");
+    }
+  else
+    {
+      printf ("Alertable async cancel not available.\n");
+    }
+
+  /*
+   * Success.
+   */
+  return 0;
+}
diff --git a/src/include/pthread/tests/cleanup0.c b/src/include/pthread/tests/cleanup0.c
new file mode 100644
index 0000000..742eaa7
--- /dev/null
+++ b/src/include/pthread/tests/cleanup0.c
@@ -0,0 +1,229 @@
+/*
+ * File: cleanup1.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis: Test cleanup handler executes (when thread is not canceled).
+ *
+ * Test Method (Validation or Falsification):
+ * - 
+ *
+ * Requirements Tested:
+ * -
+ *
+ * Features Tested:
+ * - 
+ *
+ * Cases Tested:
+ * - 
+ *
+ * Description:
+ * - 
+ *
+ * Environment:
+ * - 
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * - have working pthread_create, pthread_self, pthread_mutex_lock/unlock
+ *   pthread_testcancel, pthread_cancel, pthread_join
+ *
+ * Pass Criteria:
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - Process returns non-zero exit status.
+ */
+
+#if defined(_MSC_VER) || defined(__cplusplus)
+
+#include "test.h"
+
+/*
+ * Create NUMTHREADS threads in addition to the Main thread.
+ */
+enum {
+  NUMTHREADS = 10
+};
+
+typedef struct bag_t_ bag_t;
+struct bag_t_ {
+  int threadnum;
+  int started;
+  /* Add more per-thread state variables here */
+  int count;
+};
+
+static bag_t threadbag[NUMTHREADS + 1];
+
+typedef struct {
+  int i;
+  CRITICAL_SECTION cs;
+} sharedInt_t;
+
+static sharedInt_t pop_count;
+
+static void
+increment_pop_count(void * arg)
+{
+  sharedInt_t * sI = (sharedInt_t *) arg;
+
+  EnterCriticalSection(&sI->cs);
+  sI->i++;
+  LeaveCriticalSection(&sI->cs);
+}
+
+void *
+mythread(void * arg)
+{
+  int result = 0;
+  bag_t * bag = (bag_t *) arg;
+
+  assert(bag == &threadbag[bag->threadnum]);
+  assert(bag->started == 0);
+  bag->started = 1;
+
+  /* Set to known state and type */
+
+  assert(pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL) == 0);
+
+  assert(pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL) == 0);
+
+#ifdef _MSC_VER
+#pragma inline_depth(0)
+#endif
+  pthread_cleanup_push(increment_pop_count, (void *) &pop_count);
+
+  Sleep(100);
+
+  pthread_cleanup_pop(1);
+#ifdef _MSC_VER
+#pragma inline_depth()
+#endif
+
+  return (void *) (size_t)result;
+}
+
+int
+main()
+{
+  int failed = 0;
+  int i;
+  pthread_t t[NUMTHREADS + 1];
+
+  memset(&pop_count, 0, sizeof(sharedInt_t));
+
+  InitializeCriticalSection(&pop_count.cs);
+
+  assert((t[0] = pthread_self()).p != NULL);
+
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      threadbag[i].started = 0;
+      threadbag[i].threadnum = i;
+      assert(pthread_create(&t[i], NULL, mythread, (void *) &threadbag[i]) == 0);
+    }
+
+  /*
+   * Code to control or manipulate child threads should probably go here.
+   */
+  Sleep(500);
+
+  /*
+   * Give threads time to run.
+   */
+  Sleep(NUMTHREADS * 100);
+
+  /*
+   * Standard check that all threads started.
+   */
+  for (i = 1; i <= NUMTHREADS; i++)
+    { 
+      if (!threadbag[i].started)
+	{
+	  failed |= !threadbag[i].started;
+	  fprintf(stderr, "Thread %d: started %d\n", i, threadbag[i].started);
+	}
+    }
+
+  assert(!failed);
+
+  /*
+   * Check any results here. Set "failed" and only print output on failure.
+   */
+  failed = 0;
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      int fail = 0;
+      void* result = (void*)0;
+
+      assert(pthread_join(t[i], &result) == 0);
+
+      fail = (result == PTHREAD_CANCELED);
+
+      if (fail)
+	{
+	  fprintf(stderr, "Thread %d: started %d: result %d\n",
+		  i,
+		  threadbag[i].started,
+		(int)(size_t)result);
+	  fflush(stderr);
+	}
+      failed = (failed || fail);
+    }
+
+  assert(!failed);
+
+  assert(pop_count.i == NUMTHREADS);
+
+  DeleteCriticalSection(&pop_count.cs);
+
+  /*
+   * Success.
+   */
+  return 0;
+}
+
+#else /* defined(_MSC_VER) || defined(__cplusplus) */
+
+int
+main()
+{
+  return 0;
+}
+
+#endif /* defined(_MSC_VER) || defined(__cplusplus) */
diff --git a/src/include/pthread/tests/cleanup1.c b/src/include/pthread/tests/cleanup1.c
new file mode 100644
index 0000000..85d0e0d
--- /dev/null
+++ b/src/include/pthread/tests/cleanup1.c
@@ -0,0 +1,245 @@
+/*
+ * File: cleanup1.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis: Test cleanup handler executes (when thread is canceled).
+ *
+ * Test Method (Validation or Falsification):
+ * -
+ *
+ * Requirements Tested:
+ * -
+ *
+ * Features Tested:
+ * -
+ *
+ * Cases Tested:
+ * -
+ *
+ * Description:
+ * -
+ *
+ * Environment:
+ * -
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * - have working pthread_create, pthread_self, pthread_mutex_lock/unlock
+ *   pthread_testcancel, pthread_cancel, pthread_join
+ *
+ * Pass Criteria:
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - Process returns non-zero exit status.
+ */
+
+#if defined(_MSC_VER) || defined(__cplusplus)
+
+#include "test.h"
+
+/*
+ * Create NUMTHREADS threads in addition to the Main thread.
+ */
+enum {
+  NUMTHREADS = 10
+};
+
+typedef struct bag_t_ bag_t;
+struct bag_t_ {
+  int threadnum;
+  int started;
+  /* Add more per-thread state variables here */
+  int count;
+};
+
+static bag_t threadbag[NUMTHREADS + 1];
+
+typedef struct {
+  int i;
+  CRITICAL_SECTION cs;
+} sharedInt_t;
+
+static sharedInt_t pop_count;
+
+static void
+#ifdef __PTW32_CLEANUP_C
+__cdecl
+#endif
+increment_pop_count(void * arg)
+{
+  sharedInt_t * sI = (sharedInt_t *) arg;
+
+  EnterCriticalSection(&sI->cs);
+  sI->i++;
+  LeaveCriticalSection(&sI->cs);
+}
+
+void *
+mythread(void * arg)
+{
+  int result = 0;
+  bag_t * bag = (bag_t *) arg;
+
+  assert(bag == &threadbag[bag->threadnum]);
+  assert(bag->started == 0);
+  bag->started = 1;
+
+  /* Set to known state and type */
+
+  assert(pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL) == 0);
+
+  assert(pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL) == 0);
+
+#ifdef _MSC_VER
+#pragma inline_depth(0)
+#endif
+  pthread_cleanup_push(increment_pop_count, (void *) &pop_count);
+  /*
+   * We don't have true async cancellation - it relies on the thread
+   * at least re-entering the run state at some point.
+   * We wait up to 10 seconds, waking every 0.1 seconds,
+   * for a cancellation to be applied to us.
+   */
+  for (bag->count = 0; bag->count < 100; bag->count++)
+    Sleep(100);
+
+  pthread_cleanup_pop(0);
+#ifdef _MSC_VER
+#pragma inline_depth()
+#endif
+
+  return (void *) (size_t)result;
+}
+
+int
+main()
+{
+  int failed = 0;
+  int i;
+  pthread_t t[NUMTHREADS + 1];
+
+  DWORD dwMode = SetErrorMode(SEM_NOGPFAULTERRORBOX);
+  SetErrorMode(dwMode | SEM_NOGPFAULTERRORBOX);
+
+  memset(&pop_count, 0, sizeof(sharedInt_t));
+
+  InitializeCriticalSection(&pop_count.cs);
+
+  assert((t[0] = pthread_self()).p != NULL);
+
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      threadbag[i].started = 0;
+      threadbag[i].threadnum = i;
+      assert(pthread_create(&t[i], NULL, mythread, (void *) &threadbag[i]) == 0);
+    }
+
+  /*
+   * Code to control or manipulate child threads should probably go here.
+   */
+  Sleep(500);
+
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      assert(pthread_cancel(t[i]) == 0);
+    }
+
+  /*
+   * Give threads time to run.
+   */
+  Sleep(NUMTHREADS * 100);
+
+  /*
+   * Standard check that all threads started.
+   */
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      if (!threadbag[i].started)
+	    {
+    	  failed |= !threadbag[i].started;
+    	  fprintf(stderr, "Thread %d: started %d\n", i, threadbag[i].started);
+	    }
+    }
+
+  assert(!failed);
+
+  /*
+   * Check any results here. Set "failed" and only print output on failure.
+   */
+  failed = 0;
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      int fail = 0;
+      void* result = (void*)0;
+
+      assert(pthread_join(t[i], &result) == 0);
+
+      fail = (result != PTHREAD_CANCELED);
+
+      if (fail)
+	{
+	  fprintf(stderr, "Thread %d: started %d: result %d\n",
+		  i,
+		  threadbag[i].started,
+		  (int)(size_t)result);
+	}
+      failed = (failed || fail);
+    }
+
+  assert(!failed);
+
+  assert(pop_count.i == NUMTHREADS);
+
+  DeleteCriticalSection(&pop_count.cs);
+
+  /*
+   * Success.
+   */
+  return 0;
+}
+
+#else /* defined(_MSC_VER) || defined(__cplusplus) */
+
+int
+main()
+{
+  return 0;
+}
+
+#endif /* defined(_MSC_VER) || defined(__cplusplus) */
diff --git a/src/include/pthread/tests/cleanup2.c b/src/include/pthread/tests/cleanup2.c
new file mode 100644
index 0000000..95e893d
--- /dev/null
+++ b/src/include/pthread/tests/cleanup2.c
@@ -0,0 +1,217 @@
+/*
+ * File: cleanup2.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis: Test cleanup handler executes (when thread is not canceled).
+ *
+ * Test Method (Validation or Falsification):
+ * - 
+ *
+ * Requirements Tested:
+ * -
+ *
+ * Features Tested:
+ * - 
+ *
+ * Cases Tested:
+ * - 
+ *
+ * Description:
+ * - 
+ *
+ * Environment:
+ * - 
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * - have working pthread_create, pthread_self, pthread_mutex_lock/unlock
+ *   pthread_testcancel, pthread_cancel, pthread_join
+ *
+ * Pass Criteria:
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - Process returns non-zero exit status.
+ */
+
+#if defined(_MSC_VER) || defined(__cplusplus)
+
+#include "test.h"
+
+/*
+ * Create NUMTHREADS threads in addition to the Main thread.
+ */
+enum {
+  NUMTHREADS = 10
+};
+
+typedef struct bag_t_ bag_t;
+struct bag_t_ {
+  int threadnum;
+  int started;
+  /* Add more per-thread state variables here */
+  int count;
+};
+
+static bag_t threadbag[NUMTHREADS + 1];
+
+typedef struct {
+  int i;
+  CRITICAL_SECTION cs;
+} sharedInt_t;
+
+static sharedInt_t pop_count;
+
+static void
+increment_pop_count(void * arg)
+{
+  sharedInt_t * sI = (sharedInt_t *) arg;
+
+  EnterCriticalSection(&sI->cs);
+  sI->i++;
+  LeaveCriticalSection(&sI->cs);
+}
+
+void *
+mythread(void * arg)
+{
+  int result = 0;
+  bag_t * bag = (bag_t *) arg;
+
+  assert(bag == &threadbag[bag->threadnum]);
+  assert(bag->started == 0);
+  bag->started = 1;
+
+#ifdef _MSC_VER
+#pragma inline_depth(0)
+#endif
+  pthread_cleanup_push(increment_pop_count, (void *) &pop_count);
+
+  sched_yield();
+
+  pthread_cleanup_pop(1);
+#ifdef _MSC_VER
+#pragma inline_depth()
+#endif
+
+  return (void *) (size_t)result;
+}
+
+int
+main()
+{
+  int failed = 0;
+  int i;
+  pthread_t t[NUMTHREADS + 1];
+
+  memset(&pop_count, 0, sizeof(sharedInt_t));
+
+  InitializeCriticalSection(&pop_count.cs);
+
+  assert((t[0] = pthread_self()).p != NULL);
+
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      threadbag[i].started = 0;
+      threadbag[i].threadnum = i;
+      assert(pthread_create(&t[i], NULL, mythread, (void *) &threadbag[i]) == 0);
+    }
+
+  /*
+   * Code to control or manipulate child threads should probably go here.
+   */
+  Sleep(1000);
+
+  /*
+   * Standard check that all threads started.
+   */
+  for (i = 1; i <= NUMTHREADS; i++)
+    { 
+      if (!threadbag[i].started)
+	{
+	  failed |= !threadbag[i].started;
+	  fprintf(stderr, "Thread %d: started %d\n", i, threadbag[i].started);
+	}
+    }
+
+  assert(!failed);
+
+  /*
+   * Check any results here. Set "failed" and only print output on failure.
+   */
+  failed = 0;
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      int fail = 0;
+      void* result = (void*)0;
+
+      assert(pthread_join(t[i], &result) == 0);
+
+      fail = ((int)(size_t)result != 0);
+
+      if (fail)
+	{
+	  fprintf(stderr, "Thread %d: started %d: result: %d\n",
+		  i,
+		  threadbag[i].started,
+		  (int)(size_t)result);
+	}
+      failed = (failed || fail);
+    }
+
+  assert(!failed);
+
+  assert(pop_count.i == NUMTHREADS);
+
+  DeleteCriticalSection(&pop_count.cs);
+
+  /*
+   * Success.
+   */
+  return 0;
+}
+
+#else /* defined(_MSC_VER) || defined(__cplusplus) */
+
+int
+main()
+{
+  return 0;
+}
+
+#endif /* defined(_MSC_VER) || defined(__cplusplus) */
diff --git a/src/include/pthread/tests/cleanup3.c b/src/include/pthread/tests/cleanup3.c
new file mode 100644
index 0000000..9f4f771
--- /dev/null
+++ b/src/include/pthread/tests/cleanup3.c
@@ -0,0 +1,222 @@
+/*
+ * File: cleanup3.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis: Test cleanup handler does not execute (when thread is
+ * not canceled).
+ *
+ * Test Method (Validation or Falsification):
+ * - 
+ *
+ * Requirements Tested:
+ * -
+ *
+ * Features Tested:
+ * - 
+ *
+ * Cases Tested:
+ * - 
+ *
+ * Description:
+ * - 
+ *
+ * Environment:
+ * - 
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * - have working pthread_create, pthread_self, pthread_mutex_lock/unlock
+ *   pthread_testcancel, pthread_cancel, pthread_join
+ *
+ * Pass Criteria:
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - Process returns non-zero exit status.
+ */
+
+#if defined(_MSC_VER) || defined(__cplusplus)
+
+#include "test.h"
+
+/*
+ * Create NUMTHREADS threads in addition to the Main thread.
+ */
+enum {
+  NUMTHREADS = 10
+};
+
+typedef struct bag_t_ bag_t;
+struct bag_t_ {
+  int threadnum;
+  int started;
+  /* Add more per-thread state variables here */
+  int count;
+};
+
+static bag_t threadbag[NUMTHREADS + 1];
+
+typedef struct {
+  int i;
+  CRITICAL_SECTION cs;
+} sharedInt_t;
+
+static sharedInt_t pop_count;
+
+static void
+increment_pop_count(void * arg)
+{
+  sharedInt_t * sI = (sharedInt_t *) arg;
+
+  EnterCriticalSection(&sI->cs);
+  sI->i++;
+  LeaveCriticalSection(&sI->cs);
+}
+
+void *
+mythread(void * arg)
+{
+  int result = 0;
+  bag_t * bag = (bag_t *) arg;
+
+  assert(bag == &threadbag[bag->threadnum]);
+  assert(bag->started == 0);
+  bag->started = 1;
+
+#ifdef _MSC_VER
+#pragma inline_depth(0)
+#endif
+  pthread_cleanup_push(increment_pop_count, (void *) &pop_count);
+
+  sched_yield();
+
+  EnterCriticalSection(&pop_count.cs);
+  pop_count.i--;
+  LeaveCriticalSection(&pop_count.cs);
+
+  pthread_cleanup_pop(0);
+#ifdef _MSC_VER
+#pragma inline_depth()
+#endif
+
+  return (void *) (size_t)result;
+}
+
+int
+main()
+{
+  int failed = 0;
+  int i;
+  pthread_t t[NUMTHREADS + 1];
+
+  memset(&pop_count, 0, sizeof(sharedInt_t));
+
+  InitializeCriticalSection(&pop_count.cs);
+
+  assert((t[0] = pthread_self()).p != NULL);
+
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      threadbag[i].started = 0;
+      threadbag[i].threadnum = i;
+      assert(pthread_create(&t[i], NULL, mythread, (void *) &threadbag[i]) == 0);
+    }
+
+  /*
+   * Code to control or manipulate child threads should probably go here.
+   */
+  Sleep(1000);
+
+  /*
+   * Standard check that all threads started.
+   */
+  for (i = 1; i <= NUMTHREADS; i++)
+    { 
+      if (!threadbag[i].started)
+	{
+	  failed |= !threadbag[i].started;
+	  fprintf(stderr, "Thread %d: started %d\n", i, threadbag[i].started);
+	}
+    }
+
+  assert(!failed);
+
+  /*
+   * Check any results here. Set "failed" and only print output on failure.
+   */
+  failed = 0;
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      int fail = 0;
+      void* result = (void*)0;
+
+      assert(pthread_join(t[i], &result) == 0);
+
+      fail = ((int)(size_t)result != 0);
+
+      if (fail)
+	{
+	  fprintf(stderr, "Thread %d: started %d: result: %d\n",
+		  i,
+		  threadbag[i].started,
+		  (int)(size_t)result);
+	}
+      failed = (failed || fail);
+    }
+
+  assert(!failed);
+
+  assert(pop_count.i == -(NUMTHREADS));
+
+  DeleteCriticalSection(&pop_count.cs);
+
+  /*
+   * Success.
+   */
+  return 0;
+}
+
+#else /* defined(_MSC_VER) || defined(__cplusplus) */
+
+int
+main()
+{
+  return 0;
+}
+
+#endif /* defined(_MSC_VER) || defined(__cplusplus) */
diff --git a/src/include/pthread/tests/common.mk b/src/include/pthread/tests/common.mk
new file mode 100644
index 0000000..af4ed0c
--- /dev/null
+++ b/src/include/pthread/tests/common.mk
@@ -0,0 +1,119 @@
+#
+# Common elements to all makefiles
+#
+
+ALL_KNOWN_TESTS = \
+	affinity1 affinity2 affinity3 affinity4 affinity5 affinity6 \
+	barrier1 barrier2 barrier3 barrier4 barrier5 barrier6 \
+	cancel1 cancel2 cancel3 cancel4 cancel5 cancel6a cancel6d \
+	cancel7 cancel8 cancel9 \
+	cleanup0 cleanup1 cleanup2 cleanup3 \
+	condvar1 condvar1_1 condvar1_2 condvar2 condvar2_1 \
+	condvar3 condvar3_1 condvar3_2 condvar3_3 \
+	condvar4 condvar5 condvar6 \
+	condvar7 condvar8 condvar9 \
+	timeouts \
+	count1 \
+	context1 \
+	create1 create2 create3 \
+	delay1 delay2 \
+	detach1 \
+	equal1 \
+	errno1 \
+	exception1 exception2 exception3_0 exception3 \
+	exit1 exit2 exit3 exit4 exit5 exit6 \
+	eyal1 \
+	join0 join1 join2 join3 join4 \
+	kill1 \
+	mutex1 mutex1n mutex1e mutex1r \
+	mutex2 mutex2r mutex2e mutex3 mutex3r mutex3e \
+	mutex4 mutex5 mutex6 mutex6n mutex6e mutex6r \
+	mutex6s mutex6es mutex6rs \
+	mutex7 mutex7n mutex7e mutex7r \
+	mutex8 mutex8n mutex8e mutex8r \
+	name_np1 name_np2 \
+	once1 once2 once3 once4 \
+	priority1 priority2 inherit1 \
+	reinit1 \
+	reuse1 reuse2 \
+	robust1 robust2 robust3 robust4 robust5 \
+	rwlock1 rwlock2 rwlock3 rwlock4 \
+	rwlock2_t rwlock3_t rwlock4_t rwlock5_t rwlock6_t rwlock6_t2 \
+	rwlock5 rwlock6 rwlock7 rwlock7_1 rwlock8 rwlock8_1 \
+	self1 self2 \
+	semaphore1 semaphore2 semaphore3 \
+	semaphore4 semaphore4t semaphore5 \
+	sequence1 \
+	sizes \
+	spin1 spin2 spin3 spin4 \
+	stress1 threestage \
+	tsd1 tsd2 tsd3 \
+	valid1 valid2
+
+TESTS = $(ALL_KNOWN_TESTS)
+
+BENCHTESTS = \
+	benchtest1 benchtest2 benchtest3 benchtest4 benchtest5
+
+# Output useful info if no target given. I.e. the first target that "make" sees is used in this case.
+default_target: help
+#
+# Common elements to all makefiles
+#
+
+ALL_KNOWN_TESTS = \
+	affinity1 affinity2 affinity3 affinity4 affinity5 affinity6 \
+	barrier1 barrier2 barrier3 barrier4 barrier5 barrier6 \
+	cancel1 cancel2 cancel3 cancel4 cancel5 cancel6a cancel6d \
+	cancel7 cancel8 cancel9 \
+	cleanup0 cleanup1 cleanup2 cleanup3 \
+	condvar1 condvar1_1 condvar1_2 condvar2 condvar2_1 \
+	condvar3 condvar3_1 condvar3_2 condvar3_3 \
+	condvar4 condvar5 condvar6 \
+	condvar7 condvar8 condvar9 \
+	timeouts \
+	count1 \
+	context1 \
+	create1 create2 create3 \
+	delay1 delay2 \
+	detach1 \
+	equal1 \
+	errno1 errno0 \
+	exception1 exception2 exception3_0 exception3 \
+	exit1 exit2 exit3 exit4 exit5 exit6 \
+	eyal1 \
+	join0 join1 join2 join3 join4 \
+	kill1 \
+	mutex1 mutex1n mutex1e mutex1r \
+	mutex2 mutex2r mutex2e mutex3 mutex3r mutex3e \
+	mutex4 mutex5 mutex6 mutex6n mutex6e mutex6r \
+	mutex6s mutex6es mutex6rs \
+	mutex7 mutex7n mutex7e mutex7r \
+	mutex8 mutex8n mutex8e mutex8r \
+	name_np1 name_np2 \
+	once1 once2 once3 once4 \
+	priority1 priority2 inherit1 \
+	reinit1 \
+	reuse1 reuse2 \
+	robust1 robust2 robust3 robust4 robust5 \
+	rwlock1 rwlock2 rwlock3 rwlock4 \
+	rwlock2_t rwlock3_t rwlock4_t rwlock5_t rwlock6_t rwlock6_t2 \
+	rwlock5 rwlock6 rwlock7 rwlock8 \
+	self1 self2 \
+	semaphore1 semaphore2 semaphore3 \
+	semaphore4 semaphore4t semaphore5 \
+	sequence1 \
+	sizes \
+	spin1 spin2 spin3 spin4 \
+	stress1 threestage \
+	tsd1 tsd2 tsd3 \
+	valid1 valid2
+
+TESTS = $(ALL_KNOWN_TESTS)
+
+BENCHTESTS = \
+	benchtest1 benchtest2 benchtest3 benchtest4 benchtest5
+
+# Output useful info if no target given. I.e. the first target that "make" sees is used in this case.
+default_target: help
+	
\ No newline at end of file
diff --git a/src/include/pthread/tests/condvar1.c b/src/include/pthread/tests/condvar1.c
new file mode 100644
index 0000000..12e1502
--- /dev/null
+++ b/src/include/pthread/tests/condvar1.c
@@ -0,0 +1,95 @@
+/*
+ * File: condvar1.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis:
+ * - Test initialisation and destruction of a CV.
+ *
+ * Test Method (Validation or Falsification):
+ * - Validation
+ *
+ * Requirements Tested:
+ * - 
+ *
+ * Features Tested:
+ * - 
+ *
+ * Cases Tested:
+ * - 
+ *
+ * Description:
+ * - Creates and then imediately destroys a CV. Does not
+ *   test the CV.
+ *
+ * Environment:
+ * - 
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * - 
+ *
+ * Pass Criteria:
+ * - pthread_cond_init returns 0, and
+ * - pthread_cond_destroy returns 0.
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - pthread_cond_init returns non-zero, or
+ * - pthread_cond_destroy returns non-zero.
+ * - Process returns non-zero exit status.
+ */
+
+#include "test.h"
+
+static pthread_cond_t cv = NULL;
+
+int
+main()
+{
+  assert(cv == NULL);
+
+  assert(pthread_cond_init(&cv, NULL) == 0);
+
+  assert(cv != NULL);
+
+  assert(pthread_cond_destroy(&cv) == 0);
+
+  assert(cv == NULL);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/condvar1_1.c b/src/include/pthread/tests/condvar1_1.c
new file mode 100644
index 0000000..3eb61ed
--- /dev/null
+++ b/src/include/pthread/tests/condvar1_1.c
@@ -0,0 +1,113 @@
+/*
+ * File: condvar1_1.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis:
+ * - Test CV linked list management.
+ *
+ * Test Method (Validation or Falsification):
+ * - Validation:
+ *   Initiate and destroy several CVs in random order.
+ *
+ * Requirements Tested:
+ * - 
+ *
+ * Features Tested:
+ * - 
+ *
+ * Cases Tested:
+ * - 
+ *
+ * Description:
+ * - Creates and then imediately destroys a CV. Does not
+ *   test the CV.
+ *
+ * Environment:
+ * - 
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * -
+ *
+ * Pass Criteria:
+ * - All initialised CVs destroyed without segfault.
+ * - Successfully broadcasts all remaining CVs after
+ *   each CV is removed.
+ *
+ * Fail Criteria:
+ */
+
+#include <stdlib.h>
+#include "test.h"
+
+enum {
+  NUM_CV = 100
+};
+
+static pthread_cond_t cv[NUM_CV];
+
+int
+main()
+{
+  int i, j;
+
+  for (i = 0; i < NUM_CV; i++)
+    {
+      /* Traverse the list before every init of a CV. */
+      assert(pthread_timechange_handler_np(NULL) == (void *) 0);
+      assert(pthread_cond_init(&cv[i], NULL) == 0);
+    }
+
+  j = NUM_CV;
+  (void) srand((unsigned)time(NULL));
+
+  do
+    {
+      i = (NUM_CV - 1) * rand() / RAND_MAX;
+      if (cv[i] != NULL)
+        {
+          j--;
+          assert(pthread_cond_destroy(&cv[i]) == 0);
+          /* Traverse the list every time we remove a CV. */
+          assert(pthread_timechange_handler_np(NULL) == (void *) 0);
+        }
+    }
+  while (j > 0);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/condvar1_2.c b/src/include/pthread/tests/condvar1_2.c
new file mode 100644
index 0000000..adb5b08
--- /dev/null
+++ b/src/include/pthread/tests/condvar1_2.c
@@ -0,0 +1,122 @@
+/*
+ * File: condvar1_2.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis:
+ * - Test CV linked list management and serialisation.
+ *
+ * Test Method (Validation or Falsification):
+ * - Validation:
+ *   Initiate and destroy several CVs in random order.
+ *   Asynchronously traverse the CV list and broadcast.
+ *
+ * Requirements Tested:
+ * - 
+ *
+ * Features Tested:
+ * - 
+ *
+ * Cases Tested:
+ * - 
+ *
+ * Description:
+ * - Creates and then imediately destroys a CV. Does not
+ *   test the CV.
+ *
+ * Environment:
+ * - 
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * -
+ *
+ * Pass Criteria:
+ * - All initialised CVs destroyed without segfault.
+ * - Successfully broadcasts all remaining CVs after
+ *   each CV is removed.
+ *
+ * Fail Criteria:
+ */
+
+#include <stdlib.h>
+#include "test.h"
+
+enum {
+  NUM_CV = 5,
+  NUM_LOOPS = 5
+};
+
+static pthread_cond_t cv[NUM_CV];
+
+int
+main()
+{
+  int i, j, k;
+  void* result = (void*)-1;
+  pthread_t t;
+
+  for (k = 0; k < NUM_LOOPS; k++)
+    {
+      for (i = 0; i < NUM_CV; i++)
+        {
+          assert(pthread_cond_init(&cv[i], NULL) == 0);
+        }
+
+      j = NUM_CV;
+      (void) srand((unsigned)time(NULL));
+
+      /* Traverse the list asynchronously. */
+      assert(pthread_create(&t, NULL, pthread_timechange_handler_np, NULL) == 0);
+
+      do
+        {
+          i = (NUM_CV - 1) * rand() / RAND_MAX;
+          if (cv[i] != NULL)
+            {
+              j--;
+              assert(pthread_cond_destroy(&cv[i]) == 0);
+            }
+        }
+      while (j > 0);
+
+      assert(pthread_join(t, &result) == 0);
+      assert ((int)(size_t)result == 0);
+    }
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/condvar2.c b/src/include/pthread/tests/condvar2.c
new file mode 100644
index 0000000..453573a
--- /dev/null
+++ b/src/include/pthread/tests/condvar2.c
@@ -0,0 +1,117 @@
+/*
+ * File: condvar2.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis:
+ * - Test timed wait on a CV.
+ *
+ * Test Method (Validation or Falsification):
+ * - Validation
+ *
+ * Requirements Tested:
+ * - 
+ *
+ * Features Tested:
+ * - 
+ *
+ * Cases Tested:
+ * - 
+ *
+ * Description:
+ * - Because the CV is never signaled, we expect the wait to time out.
+ *
+ * Environment:
+ * -
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * - 
+ *
+ * Pass Criteria:
+ * - pthread_cond_timedwait returns ETIMEDOUT.
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - pthread_cond_timedwait does not return ETIMEDOUT.
+ * - Process returns non-zero exit status.
+ */
+
+#define _WIN32_WINNT 0x400
+
+#include "test.h"
+#include <sys/timeb.h>
+
+pthread_cond_t cv;
+pthread_mutex_t mutex;
+
+/* Cheating here - sneaking a peek at library internals */
+#include "../config.h"
+#include "../implement.h"
+
+int
+main()
+{
+  struct timespec abstime = { 0, 0 }, reltime = { 1, 0 };
+
+  assert(pthread_cond_init(&cv, NULL) == 0);
+
+  assert(pthread_mutex_init(&mutex, NULL) == 0);
+
+  assert(pthread_mutex_lock(&mutex) == 0);
+
+  (void) pthread_win32_getabstime_np(&abstime, &reltime);
+
+  assert(pthread_cond_timedwait(&cv, &mutex, &abstime) == ETIMEDOUT);
+  
+  assert(pthread_mutex_unlock(&mutex) == 0);
+
+  {
+  int result = pthread_cond_destroy(&cv);
+  if (result != 0)
+    {
+      fprintf(stderr, "Result = %s\n", error_string[result]);
+      fprintf(stderr, "\tWaitersBlocked = %ld\n", cv->nWaitersBlocked);
+      fprintf(stderr, "\tWaitersGone = %ld\n", cv->nWaitersGone);
+      fprintf(stderr, "\tWaitersToUnblock = %ld\n", cv->nWaitersToUnblock);
+      fflush(stderr);
+    }
+  assert(result == 0);
+  }
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/condvar2_1.c b/src/include/pthread/tests/condvar2_1.c
new file mode 100644
index 0000000..75e6a12
--- /dev/null
+++ b/src/include/pthread/tests/condvar2_1.c
@@ -0,0 +1,145 @@
+/*
+ * File: condvar2_1.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis:
+ * - Test timeout of multiple waits on a CV with no signal/broadcast.
+ *
+ * Test Method (Validation or Falsification):
+ * - Validation
+ *
+ * Requirements Tested:
+ * - 
+ *
+ * Features Tested:
+ * - 
+ *
+ * Cases Tested:
+ * - 
+ *
+ * Description:
+ * - Because the CV is never signaled, we expect the waits to time out.
+ *
+ * Environment:
+ * -
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * - 
+ *
+ * Pass Criteria:
+ * - pthread_cond_timedwait returns ETIMEDOUT.
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - pthread_cond_timedwait does not return ETIMEDOUT.
+ * - Process returns non-zero exit status.
+ */
+
+#define _WIN32_WINNT 0x400
+
+#include "test.h"
+#include <sys/timeb.h>
+
+static pthread_cond_t cv;
+static pthread_mutex_t mutex;
+static struct timespec abstime = { 0, 0 }, reltime = { 5, 0 };
+
+enum {
+  NUMTHREADS = 30
+};
+
+void *
+mythread(void * arg)
+{
+  assert(pthread_mutex_lock(&mutex) == 0);
+
+  assert(pthread_cond_timedwait(&cv, &mutex, &abstime) == ETIMEDOUT);
+
+  assert(pthread_mutex_unlock(&mutex) == 0);
+
+  return arg;
+}
+
+/* Cheating here - sneaking a peek at library internals */
+#include "../config.h"
+#include "../implement.h"
+
+int
+main()
+{
+  int i;
+  pthread_t t[NUMTHREADS + 1];
+  void* result = (void*)0;
+
+  assert(pthread_cond_init(&cv, NULL) == 0);
+
+  assert(pthread_mutex_init(&mutex, NULL) == 0);
+
+  pthread_win32_getabstime_np(&abstime, &reltime);
+
+  assert(pthread_mutex_lock(&mutex) == 0);
+
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      assert(pthread_create(&t[i], NULL, mythread, (void *)(size_t)i) == 0);
+    }
+
+  assert(pthread_mutex_unlock(&mutex) == 0);
+
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      assert(pthread_join(t[i], &result) == 0);
+	assert((int)(size_t)result == i);
+    }
+
+  {
+  int result = pthread_cond_destroy(&cv);
+  if (result != 0)
+    {
+      fprintf(stderr, "Result = %s\n", error_string[result]);
+	fprintf(stderr, "\tWaitersBlocked = %ld\n", cv->nWaitersBlocked);
+	fprintf(stderr, "\tWaitersGone = %ld\n", cv->nWaitersGone);
+	fprintf(stderr, "\tWaitersToUnblock = %ld\n", cv->nWaitersToUnblock);
+	fflush(stderr);
+    }
+  assert(result == 0);
+  }
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/condvar3.c b/src/include/pthread/tests/condvar3.c
new file mode 100644
index 0000000..bd097e2
--- /dev/null
+++ b/src/include/pthread/tests/condvar3.c
@@ -0,0 +1,138 @@
+/*
+ * File: condvar3.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis:
+ * - Test basic function of a CV
+ *
+ * Test Method (Validation or Falsification):
+ * - Validation
+ *
+ * Requirements Tested:
+ * - 
+ *
+ * Features Tested:
+ * - 
+ *
+ * Cases Tested:
+ * - 
+ *
+ * Description:
+ * - The primary thread takes the lock before creating any threads.
+ *   The secondary thread blocks on the lock allowing the primary
+ *   thread to enter the cv wait state which releases the lock.
+ *   The secondary thread then takes the lock and signals the waiting
+ *   primary thread.
+ *
+ * Environment:
+ * - 
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * - 
+ *
+ * Pass Criteria:
+ * - pthread_cond_timedwait returns 0.
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - pthread_cond_timedwait returns ETIMEDOUT.
+ * - Process returns non-zero exit status.
+ */
+
+#include "test.h"
+#include <sys/timeb.h>
+
+static pthread_cond_t cv;
+static pthread_mutex_t mutex;
+static int shared = 0;
+
+enum {
+  NUMTHREADS = 2         /* Including the primary thread. */
+};
+
+void *
+mythread(void * arg)
+{
+  int result = 0;
+
+  assert(pthread_mutex_lock(&mutex) == 0);
+  shared++;
+  assert(pthread_mutex_unlock(&mutex) == 0);
+
+  if ((result = pthread_cond_signal(&cv)) != 0)
+    {
+      printf("Error = %s\n", error_string[result]);
+    }
+  assert(result == 0);
+
+
+  return (void *) 0;
+}
+
+int
+main()
+{
+  pthread_t t[NUMTHREADS];
+  struct timespec abstime, reltime = { 5, 0 };
+
+  assert((t[0] = pthread_self()).p != NULL);
+
+  assert(pthread_cond_init(&cv, NULL) == 0);
+
+  assert(pthread_mutex_init(&mutex, NULL) == 0);
+
+  assert(pthread_mutex_lock(&mutex) == 0);
+
+  assert(pthread_create(&t[1], NULL, mythread, (void *) 1) == 0);
+
+  (void) pthread_win32_getabstime_np(&abstime, &reltime);
+
+  while (! (shared > 0))
+    assert(pthread_cond_timedwait(&cv, &mutex, &abstime) == 0);
+
+  assert(shared > 0);
+
+  assert(pthread_mutex_unlock(&mutex) == 0);
+
+  assert(pthread_join(t[1], NULL) == 0);
+
+  assert(pthread_cond_destroy(&cv) == 0);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/condvar3_1.c b/src/include/pthread/tests/condvar3_1.c
new file mode 100644
index 0000000..2e5e81e
--- /dev/null
+++ b/src/include/pthread/tests/condvar3_1.c
@@ -0,0 +1,193 @@
+/*
+ * File: condvar3_1.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis:
+ * - Test timeout of multiple waits on a CV with some signaled.
+ *
+ * Test Method (Validation or Falsification):
+ * - Validation
+ *
+ * Requirements Tested:
+ * - 
+ *
+ * Features Tested:
+ * - 
+ *
+ * Cases Tested:
+ * - 
+ *
+ * Description:
+ * - Because some CVs are never signaled, we expect their waits to time out.
+ *   Some are signaled, the rest time out. Pthread_cond_destroy() will fail
+ *   unless all are accounted for, either signaled or timedout.
+ *
+ * Environment:
+ * -
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * - 
+ *
+ * Pass Criteria:
+ * - pthread_cond_timedwait returns ETIMEDOUT.
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - pthread_cond_timedwait does not return ETIMEDOUT.
+ * - Process returns non-zero exit status.
+ */
+
+#define _WIN32_WINNT 0x400
+
+#include "test.h"
+#include <sys/timeb.h>
+
+static pthread_cond_t cv;
+static pthread_cond_t cv1;
+static pthread_mutex_t mutex;
+static pthread_mutex_t mutex1;
+static struct timespec abstime = { 0, 0 }, reltime = { 5, 0 };
+static int timedout = 0;
+static int signaled = 0;
+static int awoken = 0;
+static int waiting = 0;
+
+enum {
+  NUMTHREADS = 30
+};
+
+void *
+mythread(void * arg)
+{
+  int result;
+
+  assert(pthread_mutex_lock(&mutex1) == 0);
+  ++waiting;
+  assert(pthread_mutex_unlock(&mutex1) == 0);
+  assert(pthread_cond_signal(&cv1) == 0);
+
+  assert(pthread_mutex_lock(&mutex) == 0);
+  result = pthread_cond_timedwait(&cv, &mutex, &abstime);
+  if (result == ETIMEDOUT)
+    {
+      timedout++;
+    }
+  else
+    {
+      awoken++;
+    }
+  assert(pthread_mutex_unlock(&mutex) == 0);
+
+  return arg;
+}
+
+/* Cheating here - sneaking a peek at library internals */
+#include "../config.h"
+#include "../implement.h"
+
+int
+main()
+{
+  int i;
+  pthread_t t[NUMTHREADS + 1];
+  void* result = (void*)0;
+
+  assert(pthread_cond_init(&cv, NULL) == 0);
+  assert(pthread_cond_init(&cv1, NULL) == 0);
+
+  assert(pthread_mutex_init(&mutex, NULL) == 0);
+  assert(pthread_mutex_init(&mutex1, NULL) == 0);
+
+  (void) pthread_win32_getabstime_np(&abstime, &reltime);
+
+  assert(pthread_mutex_lock(&mutex1) == 0);
+
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      assert(pthread_create(&t[i], NULL, mythread, (void *)(size_t)i) == 0);
+    }
+
+  do {
+    assert(pthread_cond_wait(&cv1,&mutex1) == 0);
+  } while ( NUMTHREADS > waiting );
+
+  assert(pthread_mutex_unlock(&mutex1) == 0);
+
+  for (i = NUMTHREADS/3; i <= 2*NUMTHREADS/3; i++)
+    {
+//      assert(pthread_mutex_lock(&mutex) == 0);
+      assert(pthread_cond_signal(&cv) == 0);
+//      assert(pthread_mutex_unlock(&mutex) == 0);
+
+      signaled++;
+    }
+
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      assert(pthread_join(t[i], &result) == 0);
+        assert((int)(size_t)result == i);
+    }
+
+      fprintf(stderr, "awk = %d\n", awoken);
+      fprintf(stderr, "sig = %d\n", signaled);
+      fprintf(stderr, "tot = %d\n", timedout);
+
+  assert(signaled == awoken);
+  assert(timedout == NUMTHREADS - signaled);
+
+  assert(pthread_cond_destroy(&cv1) == 0);
+
+  {
+  int result = pthread_cond_destroy(&cv);
+  if (result != 0)
+    {
+      fprintf(stderr, "Result = %s\n", error_string[result]);
+        fprintf(stderr, "\tWaitersBlocked = %ld\n", cv->nWaitersBlocked);
+        fprintf(stderr, "\tWaitersGone = %ld\n", cv->nWaitersGone);
+        fprintf(stderr, "\tWaitersToUnblock = %ld\n", cv->nWaitersToUnblock);
+        fflush(stderr);
+    }
+  assert(result == 0);
+  }
+
+  assert(pthread_mutex_destroy(&mutex1) == 0);
+  assert(pthread_mutex_destroy(&mutex) == 0);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/condvar3_2.c b/src/include/pthread/tests/condvar3_2.c
new file mode 100644
index 0000000..43a01f1
--- /dev/null
+++ b/src/include/pthread/tests/condvar3_2.c
@@ -0,0 +1,188 @@
+/*
+ * File: condvar3_2.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis:
+ * - Test timeout of multiple waits on a CV with remainder broadcast awoken.
+ *
+ * Test Method (Validation or Falsification):
+ * - Validation
+ *
+ * Requirements Tested:
+ * - 
+ *
+ * Features Tested:
+ * - 
+ *
+ * Cases Tested:
+ * - 
+ *
+ * Description:
+ * - Because some CVs are never signaled, we expect their waits to time out.
+ *   Some time out, the rest are broadcast signaled. Pthread_cond_destroy() will fail
+ *   unless all are accounted for, either signaled or timedout.
+ *
+ * Environment:
+ * -
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * - 
+ *
+ * Pass Criteria:
+ * - pthread_cond_timedwait returns ETIMEDOUT.
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - pthread_cond_timedwait does not return ETIMEDOUT.
+ * - Process returns non-zero exit status.
+ */
+
+#define _WIN32_WINNT 0x400
+
+#include "test.h"
+#include <sys/timeb.h>
+
+static pthread_cond_t cv;
+static pthread_mutex_t mutex;
+static struct timespec abstime, abstime2;
+static struct timespec reltime = { 5, 0 };
+static int timedout = 0;
+static int awoken = 0;
+
+enum {
+  NUMTHREADS = 30
+};
+
+void *
+mythread(void * arg)
+{
+  int result;
+
+  assert(pthread_mutex_lock(&mutex) == 0);
+
+  abstime2.tv_sec = abstime.tv_sec;
+
+  if ((int) (size_t)arg % 3 == 0)
+    {
+      abstime2.tv_sec += 2;
+    }
+
+  result = pthread_cond_timedwait(&cv, &mutex, &abstime2);
+  assert(pthread_mutex_unlock(&mutex) == 0);
+  if (result == ETIMEDOUT)
+    {
+      InterlockedIncrement((LPLONG)&timedout);
+    }
+  else
+    {
+      InterlockedIncrement((LPLONG)&awoken);
+    }
+
+  return arg;
+}
+
+/* Cheating here - sneaking a peek at library internals */
+#include "../config.h"
+#include "../implement.h"
+
+int
+main()
+{
+  int i;
+  pthread_t t[NUMTHREADS + 1];
+  void* result = (void*)0;
+
+  assert(pthread_cond_init(&cv, NULL) == 0);
+
+  assert(pthread_mutex_init(&mutex, NULL) == 0);
+
+  (void) pthread_win32_getabstime_np(&abstime, &reltime);
+  abstime2.tv_sec = abstime.tv_sec;
+  abstime2.tv_nsec = abstime.tv_nsec;
+
+  assert(pthread_mutex_lock(&mutex) == 0);
+
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      assert(pthread_create(&t[i], NULL, mythread, (void *)(size_t)i) == 0);
+    }
+
+  assert(pthread_mutex_unlock(&mutex) == 0);
+
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      assert(pthread_join(t[i], &result) == 0);
+	assert((int)(size_t)result == i);
+      /*
+       * Approximately 2/3rds of the threads are expected to time out.
+       * Signal the remainder after some threads have woken up and exited
+       * and while some are still waking up after timeout.
+       * Also tests that redundant broadcasts don't return errors.
+       */
+
+//      assert(pthread_mutex_lock(&mutex) == 0);
+
+      if (InterlockedExchangeAdd((LPLONG)&awoken, 0L) > NUMTHREADS/3)
+        {
+          assert(pthread_cond_broadcast(&cv) == 0);
+        }
+
+//      assert(pthread_mutex_unlock(&mutex) == 0);
+
+    }
+
+  assert(awoken == NUMTHREADS - timedout);
+
+  {
+  int result = pthread_cond_destroy(&cv);
+  if (result != 0)
+    {
+      fprintf(stderr, "Result = %s\n", error_string[result]);
+	fprintf(stderr, "\tWaitersBlocked = %ld\n", cv->nWaitersBlocked);
+	fprintf(stderr, "\tWaitersGone = %ld\n", cv->nWaitersGone);
+	fprintf(stderr, "\tWaitersToUnblock = %ld\n", cv->nWaitersToUnblock);
+	fflush(stderr);
+    }
+  assert(result == 0);
+  }
+
+  assert(pthread_mutex_destroy(&mutex) == 0);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/condvar3_3.c b/src/include/pthread/tests/condvar3_3.c
new file mode 100644
index 0000000..51222dd
--- /dev/null
+++ b/src/include/pthread/tests/condvar3_3.c
@@ -0,0 +1,118 @@
+/*
+ * File: condvar3_3.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis:
+ * - Test timeouts and lost signals on a CV.
+ *
+ * Test Method (Validation or Falsification):
+ * - Validation
+ *
+ * Requirements Tested:
+ * - 
+ *
+ * Features Tested:
+ * - 
+ *
+ * Cases Tested:
+ * - 
+ *
+ * Description:
+ * -
+ *
+ * Environment:
+ * -
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * - 
+ *
+ * Pass Criteria:
+ * - pthread_cond_timedwait returns ETIMEDOUT.
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - pthread_cond_timedwait does not return ETIMEDOUT.
+ * - Process returns non-zero exit status.
+ */
+
+/* Timur Aydin (taydin@snet.net) */
+
+#include "test.h"
+
+#include <sys/timeb.h>
+
+pthread_cond_t cnd;
+pthread_mutex_t mtx;
+
+static const long NANOSEC_PER_SEC = 1000000000L;
+
+int main()
+{
+   int rc;
+   struct timespec abstime, reltime = { 0, NANOSEC_PER_SEC/2 };
+
+   assert(pthread_cond_init(&cnd, 0) == 0);
+   assert(pthread_mutex_init(&mtx, 0) == 0);
+
+   (void) pthread_win32_getabstime_np(&abstime, &reltime);
+
+   /* Here pthread_cond_timedwait should time out after one second. */
+
+   assert(pthread_mutex_lock(&mtx) == 0);
+
+   assert((rc = pthread_cond_timedwait(&cnd, &mtx, &abstime)) == ETIMEDOUT);
+
+   assert(pthread_mutex_unlock(&mtx) == 0);
+
+   /* Here, the condition variable is signalled, but there are no
+      threads waiting on it. The signal should be lost and
+      the next pthread_cond_timedwait should time out too. */
+
+   assert((rc = pthread_cond_signal(&cnd)) == 0);
+
+   assert(pthread_mutex_lock(&mtx) == 0);
+
+   (void) pthread_win32_getabstime_np(&abstime, &reltime);
+
+   assert((rc = pthread_cond_timedwait(&cnd, &mtx, &abstime)) == ETIMEDOUT);
+
+   assert(pthread_mutex_unlock(&mtx) == 0);
+
+   return 0;
+}
diff --git a/src/include/pthread/tests/condvar4.c b/src/include/pthread/tests/condvar4.c
new file mode 100644
index 0000000..bf6516f
--- /dev/null
+++ b/src/include/pthread/tests/condvar4.c
@@ -0,0 +1,154 @@
+/*
+ * File: condvar4.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis:
+ * - Test PTHREAD_COND_INITIALIZER.
+ *
+ * Test Method (Validation or Falsification):
+ * - Validation
+ *
+ * Requirements Tested:
+ * - 
+ *
+ * Features Tested:
+ * - 
+ *
+ * Cases Tested:
+ * - 
+ *
+ * Description:
+ * - Test basic CV function but starting with a static initialised
+ *   CV.
+ *
+ * Environment:
+ * - 
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * - 
+ *
+ * Pass Criteria:
+ * - pthread_cond_timedwait returns 0.
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - pthread_cond_timedwait returns ETIMEDOUT.
+ * - Process returns non-zero exit status.
+ */
+
+#include "test.h"
+#include <sys/timeb.h>
+
+typedef struct cvthing_t_ cvthing_t;
+
+struct cvthing_t_ {
+  pthread_cond_t notbusy;
+  pthread_mutex_t lock;
+  int shared;
+};
+
+static cvthing_t cvthing = {
+  PTHREAD_COND_INITIALIZER,
+  PTHREAD_MUTEX_INITIALIZER,
+  0
+};
+
+enum {
+  NUMTHREADS = 2
+};
+
+void *
+mythread(void * arg)
+{
+  assert(pthread_mutex_lock(&cvthing.lock) == 0);
+  cvthing.shared++;
+  assert(pthread_mutex_unlock(&cvthing.lock) == 0);
+
+  assert(pthread_cond_signal(&cvthing.notbusy) == 0);
+
+  return (void *) 0;
+}
+
+int
+main()
+{
+  pthread_t t[NUMTHREADS];
+  struct timespec abstime, reltime = { 5, 0 };
+
+  cvthing.shared = 0;
+
+  assert((t[0] = pthread_self()).p != NULL);
+
+  assert(cvthing.notbusy == PTHREAD_COND_INITIALIZER);
+
+  assert(cvthing.lock == PTHREAD_MUTEX_INITIALIZER);
+
+  assert(pthread_mutex_lock(&cvthing.lock) == 0);
+
+  assert(cvthing.lock != PTHREAD_MUTEX_INITIALIZER);
+
+  (void) pthread_win32_getabstime_np(&abstime, &reltime);
+
+  assert(pthread_cond_timedwait(&cvthing.notbusy, &cvthing.lock, &abstime) == ETIMEDOUT);
+  
+  assert(cvthing.notbusy != PTHREAD_COND_INITIALIZER);
+
+  assert(pthread_create(&t[1], NULL, mythread, (void *) 1) == 0);
+
+  (void) pthread_win32_getabstime_np(&abstime, &reltime);
+
+  while (! (cvthing.shared > 0))
+    assert(pthread_cond_timedwait(&cvthing.notbusy, &cvthing.lock, &abstime) == 0);
+
+  assert(cvthing.shared > 0);
+
+  assert(pthread_mutex_unlock(&cvthing.lock) == 0);
+
+  assert(pthread_join(t[1], NULL) == 0);
+
+  assert(pthread_mutex_destroy(&cvthing.lock) == 0);
+
+  assert(cvthing.lock == NULL);
+
+  assert(pthread_cond_destroy(&cvthing.notbusy) == 0);
+
+  assert(cvthing.notbusy == NULL);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/condvar5.c b/src/include/pthread/tests/condvar5.c
new file mode 100644
index 0000000..551ffa2
--- /dev/null
+++ b/src/include/pthread/tests/condvar5.c
@@ -0,0 +1,153 @@
+/*
+ * File: condvar5.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis:
+ * - Test pthread_cond_broadcast.
+ *
+ * Test Method (Validation or Falsification):
+ * - Validation
+ *
+ * Requirements Tested:
+ * - 
+ *
+ * Features Tested:
+ * - 
+ *
+ * Cases Tested:
+ * - 
+ *
+ * Description:
+ * - Test broadcast with one waiting CV.
+ *
+ * Environment:
+ * - 
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * - 
+ *
+ * Pass Criteria:
+ * - pthread_cond_timedwait returns 0.
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - pthread_cond_timedwait returns ETIMEDOUT.
+ * - Process returns non-zero exit status.
+ */
+
+#include "test.h"
+#include <sys/timeb.h>
+
+typedef struct cvthing_t_ cvthing_t;
+
+struct cvthing_t_ {
+  pthread_cond_t notbusy;
+  pthread_mutex_t lock;
+  int shared;
+};
+
+static cvthing_t cvthing = {
+  PTHREAD_COND_INITIALIZER,
+  PTHREAD_MUTEX_INITIALIZER,
+  0
+};
+
+enum {
+  NUMTHREADS = 2
+};
+
+void *
+mythread(void * arg)
+{
+  assert(pthread_mutex_lock(&cvthing.lock) == 0);
+  cvthing.shared++;
+  assert(pthread_mutex_unlock(&cvthing.lock) == 0);
+
+  assert(pthread_cond_broadcast(&cvthing.notbusy) == 0);
+
+  return (void *) 0;
+}
+
+int
+main()
+{
+  pthread_t t[NUMTHREADS];
+  struct timespec abstime, reltime = { 5, 0 };
+
+  cvthing.shared = 0;
+
+  assert((t[0] = pthread_self()).p != NULL);
+
+  assert(cvthing.notbusy == PTHREAD_COND_INITIALIZER);
+
+  assert(cvthing.lock == PTHREAD_MUTEX_INITIALIZER);
+
+  assert(pthread_mutex_lock(&cvthing.lock) == 0);
+
+  assert(cvthing.lock != PTHREAD_MUTEX_INITIALIZER);
+
+  (void) pthread_win32_getabstime_np(&abstime, &reltime);
+
+  assert(pthread_cond_timedwait(&cvthing.notbusy, &cvthing.lock, &abstime) == ETIMEDOUT);
+  
+  assert(cvthing.notbusy != PTHREAD_COND_INITIALIZER);
+
+  assert(pthread_create(&t[1], NULL, mythread, (void *) 1) == 0);
+
+  (void) pthread_win32_getabstime_np(&abstime, &reltime);
+
+  while (! (cvthing.shared > 0))
+    assert(pthread_cond_timedwait(&cvthing.notbusy, &cvthing.lock, &abstime) == 0);
+
+  assert(cvthing.shared > 0);
+
+  assert(pthread_mutex_unlock(&cvthing.lock) == 0);
+
+  assert(pthread_join(t[1], NULL) == 0);
+
+  assert(pthread_mutex_destroy(&cvthing.lock) == 0);
+
+  assert(cvthing.lock == NULL);
+
+  assert(pthread_cond_destroy(&cvthing.notbusy) == 0);
+
+  assert(cvthing.notbusy == NULL);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/condvar6.c b/src/include/pthread/tests/condvar6.c
new file mode 100644
index 0000000..dc49548
--- /dev/null
+++ b/src/include/pthread/tests/condvar6.c
@@ -0,0 +1,232 @@
+/*
+ * File: condvar6.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis:
+ * - Test pthread_cond_broadcast.
+ *
+ * Test Method (Validation or Falsification):
+ * - Validation
+ *
+ * Requirements Tested:
+ * - 
+ *
+ * Features Tested:
+ * - 
+ *
+ * Cases Tested:
+ * - 
+ *
+ * Description:
+ * - Test broadcast with NUMTHREADS (=5) waiting CVs.
+ *
+ * Environment:
+ * - 
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * - 
+ *
+ * Pass Criteria:
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - Process returns non-zero exit status.
+ */
+
+#include "test.h"
+#include <sys/timeb.h>
+
+/*
+ * Create NUMTHREADS threads in addition to the Main thread.
+ */
+enum {
+  NUMTHREADS = 5
+};
+
+typedef struct bag_t_ bag_t;
+struct bag_t_ {
+  int threadnum;
+  int started;
+  /* Add more per-thread state variables here */
+};
+
+static bag_t threadbag[NUMTHREADS + 1];
+
+typedef struct cvthing_t_ cvthing_t;
+
+struct cvthing_t_ {
+  pthread_cond_t notbusy;
+  pthread_mutex_t lock;
+  int shared;
+};
+
+static cvthing_t cvthing = {
+  PTHREAD_COND_INITIALIZER,
+  PTHREAD_MUTEX_INITIALIZER,
+  0
+};
+
+static pthread_mutex_t start_flag = PTHREAD_MUTEX_INITIALIZER;
+
+static struct timespec abstime, reltime = { 5, 0 };
+
+static int awoken;
+
+void *
+mythread(void * arg)
+{
+  bag_t * bag = (bag_t *) arg;
+
+  assert(bag == &threadbag[bag->threadnum]);
+  assert(bag->started == 0);
+  bag->started = 1;
+
+  /* Wait for the start gun */
+  assert(pthread_mutex_lock(&start_flag) == 0);
+  assert(pthread_mutex_unlock(&start_flag) == 0);
+
+  assert(pthread_mutex_lock(&cvthing.lock) == 0);
+
+  while (! (cvthing.shared > 0))
+    assert(pthread_cond_timedwait(&cvthing.notbusy, &cvthing.lock, &abstime) == 0);
+
+  assert(cvthing.shared > 0);
+
+  awoken++;
+
+  assert(pthread_mutex_unlock(&cvthing.lock) == 0);
+
+  return (void *) 0;
+}
+
+int
+main()
+{
+  int failed = 0;
+  int i;
+  pthread_t t[NUMTHREADS + 1];
+
+  cvthing.shared = 0;
+
+  assert((t[0] = pthread_self()).p != NULL);
+
+  assert(cvthing.notbusy == PTHREAD_COND_INITIALIZER);
+
+  assert(cvthing.lock == PTHREAD_MUTEX_INITIALIZER);
+
+  assert(pthread_mutex_lock(&start_flag) == 0);
+
+  (void) pthread_win32_getabstime_np(&abstime, &reltime);
+
+  assert((t[0] = pthread_self()).p != NULL);
+
+  awoken = 0;
+
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      threadbag[i].started = 0;
+      threadbag[i].threadnum = i;
+      assert(pthread_create(&t[i], NULL, mythread, (void *) &threadbag[i]) == 0);
+    }
+
+  /*
+   * Code to control or manipulate child threads should probably go here.
+   */
+
+  assert(pthread_mutex_unlock(&start_flag) == 0);
+
+  /*
+   * Give threads time to start.
+   */
+  Sleep(1000);
+
+  assert(pthread_mutex_lock(&cvthing.lock) == 0);
+  cvthing.shared++;
+  assert(pthread_mutex_unlock(&cvthing.lock) == 0);
+
+  assert(pthread_cond_broadcast(&cvthing.notbusy) == 0);
+
+  /*
+   * Give threads time to complete.
+   */
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      assert(pthread_join(t[i], NULL) == 0);
+    }
+
+  /* 
+   * Cleanup the CV.
+   */
+  
+  assert(pthread_mutex_destroy(&cvthing.lock) == 0);
+
+  assert(cvthing.lock == NULL);
+
+  assert(pthread_cond_destroy(&cvthing.notbusy) == 0);
+
+  assert(cvthing.notbusy == NULL);
+
+  /*
+   * Standard check that all threads started.
+   */
+  for (i = 1; i <= NUMTHREADS; i++)
+    { 
+      failed = !threadbag[i].started;
+
+      if (failed)
+	{
+	  fprintf(stderr, "Thread %d: started %d\n", i, threadbag[i].started);
+	}
+    }
+
+  assert(!failed);
+
+  /*
+   * Check any results here.
+   */
+
+  assert(awoken == NUMTHREADS);
+
+  /*
+   * Success.
+   */
+  return 0;
+}
+
+
diff --git a/src/include/pthread/tests/condvar7.c b/src/include/pthread/tests/condvar7.c
new file mode 100644
index 0000000..00eca82
--- /dev/null
+++ b/src/include/pthread/tests/condvar7.c
@@ -0,0 +1,247 @@
+/*
+ * File: condvar7.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis:
+ * - Test pthread_cond_broadcast with thread cancellation.
+ *
+ * Test Method (Validation or Falsification):
+ * - Validation
+ *
+ * Requirements Tested:
+ * - 
+ *
+ * Features Tested:
+ * - 
+ *
+ * Cases Tested:
+ * - 
+ *
+ * Description:
+ * - Test broadcast with NUMTHREADS (=5) waiting CVs, one is canceled while waiting.
+ *
+ * Environment:
+ * - 
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * - 
+ *
+ * Pass Criteria:
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - Process returns non-zero exit status.
+ */
+
+#include "test.h"
+#include <sys/timeb.h>
+
+/*
+ * Create NUMTHREADS threads in addition to the Main thread.
+ */
+enum {
+  NUMTHREADS = 5
+};
+
+typedef struct bag_t_ bag_t;
+struct bag_t_ {
+  int threadnum;
+  int started;
+  /* Add more per-thread state variables here */
+};
+
+static bag_t threadbag[NUMTHREADS + 1];
+
+typedef struct cvthing_t_ cvthing_t;
+
+struct cvthing_t_ {
+  pthread_cond_t notbusy;
+  pthread_mutex_t lock;
+  int shared;
+};
+
+static cvthing_t cvthing = {
+  PTHREAD_COND_INITIALIZER,
+  PTHREAD_MUTEX_INITIALIZER,
+  0
+};
+
+static pthread_mutex_t start_flag = PTHREAD_MUTEX_INITIALIZER;
+
+static struct timespec abstime, reltime = { 10, 0 };
+
+static int awoken;
+
+void *
+mythread(void * arg)
+{
+  bag_t * bag = (bag_t *) arg;
+
+  assert(bag == &threadbag[bag->threadnum]);
+  assert(bag->started == 0);
+  bag->started = 1;
+
+  /* Wait for the start gun */
+  assert(pthread_mutex_lock(&start_flag) == 0);
+  assert(pthread_mutex_unlock(&start_flag) == 0);
+
+  assert(pthread_mutex_lock(&cvthing.lock) == 0);
+
+#ifdef _MSC_VER
+#pragma inline_depth(0)
+#endif
+  pthread_cleanup_push(pthread_mutex_unlock, (void *) &cvthing.lock);
+
+  while (! (cvthing.shared > 0))
+    assert(pthread_cond_timedwait(&cvthing.notbusy, &cvthing.lock, &abstime) == 0);
+
+  pthread_cleanup_pop(0);
+#ifdef _MSC_VER
+#pragma inline_depth()
+#endif
+
+  assert(cvthing.shared > 0);
+
+  awoken++;
+
+  assert(pthread_mutex_unlock(&cvthing.lock) == 0);
+
+  return (void *) 0;
+}
+
+int
+main()
+{
+  int failed = 0;
+  int i;
+  pthread_t t[NUMTHREADS + 1];
+
+  cvthing.shared = 0;
+
+  assert((t[0] = pthread_self()).p != NULL);
+
+  assert(cvthing.notbusy == PTHREAD_COND_INITIALIZER);
+
+  assert(cvthing.lock == PTHREAD_MUTEX_INITIALIZER);
+
+  assert(pthread_mutex_lock(&start_flag) == 0);
+
+  (void) pthread_win32_getabstime_np(&abstime, &reltime);
+
+  assert((t[0] = pthread_self()).p != NULL);
+
+  awoken = 0;
+
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      threadbag[i].started = 0;
+      threadbag[i].threadnum = i;
+      assert(pthread_create(&t[i], NULL, mythread, (void *) &threadbag[i]) == 0);
+    }
+
+  /*
+   * Code to control or manipulate child threads should probably go here.
+   */
+
+  assert(pthread_mutex_unlock(&start_flag) == 0);
+
+  /*
+   * Give threads time to start.
+   */
+  Sleep(1000);
+
+  /*
+   * Cancel one of the threads.
+   */
+  assert(pthread_cancel(t[1]) == 0);
+  assert(pthread_join(t[1], NULL) == 0);
+
+  assert(pthread_mutex_lock(&cvthing.lock) == 0);
+  cvthing.shared++;
+  assert(pthread_mutex_unlock(&cvthing.lock) == 0);
+
+  /*
+   * Signal all remaining waiting threads.
+   */
+  assert(pthread_cond_broadcast(&cvthing.notbusy) == 0);
+
+  /*
+   * Wait for all threads to complete.
+   */
+  for (i = 2; i <= NUMTHREADS; i++)
+    assert(pthread_join(t[i], NULL) == 0);
+
+  /* 
+   * Cleanup the CV.
+   */
+  
+  assert(pthread_mutex_destroy(&cvthing.lock) == 0);
+
+  assert(cvthing.lock == NULL);
+
+  assert(pthread_cond_destroy(&cvthing.notbusy) == 0);
+
+  assert(cvthing.notbusy == NULL);
+
+  /*
+   * Standard check that all threads started.
+   */
+  for (i = 1; i <= NUMTHREADS; i++)
+    { 
+      failed = !threadbag[i].started;
+
+      if (failed)
+	{
+	  fprintf(stderr, "Thread %d: started %d\n", i, threadbag[i].started);
+	}
+    }
+
+  assert(!failed);
+
+  /*
+   * Check any results here.
+   */
+
+  assert(awoken == (NUMTHREADS - 1));
+
+  /*
+   * Success.
+   */
+  return 0;
+}
diff --git a/src/include/pthread/tests/condvar8.c b/src/include/pthread/tests/condvar8.c
new file mode 100644
index 0000000..22f23a1
--- /dev/null
+++ b/src/include/pthread/tests/condvar8.c
@@ -0,0 +1,248 @@
+/*
+ * File: condvar8.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis:
+ * - Test multiple pthread_cond_broadcasts.
+ *
+ * Test Method (Validation or Falsification):
+ * - Validation
+ *
+ * Requirements Tested:
+ * - 
+ *
+ * Features Tested:
+ * - 
+ *
+ * Cases Tested:
+ * - 
+ *
+ * Description:
+ * - Make NUMTHREADS threads wait on CV, broadcast signal them, and then repeat.
+ *
+ * Environment:
+ * - 
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * - 
+ *
+ * Pass Criteria:
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - Process returns non-zero exit status.
+ */
+
+#include "test.h"
+#include <sys/timeb.h>
+
+/*
+ * Create NUMTHREADS threads in addition to the Main thread.
+ */
+enum {
+  NUMTHREADS = 5
+};
+
+typedef struct bag_t_ bag_t;
+struct bag_t_ {
+  int threadnum;
+  int started;
+  /* Add more per-thread state variables here */
+};
+
+static bag_t threadbag[NUMTHREADS + 1];
+
+typedef struct cvthing_t_ cvthing_t;
+
+struct cvthing_t_ {
+  pthread_cond_t notbusy;
+  pthread_mutex_t lock;
+  int shared;
+};
+
+static cvthing_t cvthing = {
+  PTHREAD_COND_INITIALIZER,
+  PTHREAD_MUTEX_INITIALIZER,
+  0
+};
+
+static pthread_mutex_t start_flag = PTHREAD_MUTEX_INITIALIZER;
+
+static struct timespec abstime, reltime = { 10, 0 };
+
+static int awoken;
+
+static void *
+mythread(void * arg)
+{
+  bag_t * bag = (bag_t *) arg;
+
+  assert(bag == &threadbag[bag->threadnum]);
+  assert(bag->started == 0);
+  bag->started = 1;
+
+  /* Wait for the start gun */
+  assert(pthread_mutex_lock(&start_flag) == 0);
+  assert(pthread_mutex_unlock(&start_flag) == 0);
+
+  assert(pthread_mutex_lock(&cvthing.lock) == 0);
+
+#ifdef _MSC_VER
+#pragma inline_depth(0)
+#endif
+  pthread_cleanup_push(pthread_mutex_unlock, (void *) &cvthing.lock);
+
+  while (! (cvthing.shared > 0))
+    assert(pthread_cond_timedwait(&cvthing.notbusy, &cvthing.lock, &abstime) == 0);
+
+  pthread_cleanup_pop(0);
+#ifdef _MSC_VER
+#pragma inline_depth()
+#endif
+
+  assert(cvthing.shared > 0);
+
+  awoken++;
+
+  assert(pthread_mutex_unlock(&cvthing.lock) == 0);
+
+  return (void *) 0;
+}
+
+int
+main()
+{
+  int failed = 0;
+  int i;
+  int first, last;
+  pthread_t t[NUMTHREADS + 1];
+
+  assert((t[0] = pthread_self()).p != NULL);
+
+  assert(cvthing.notbusy == PTHREAD_COND_INITIALIZER);
+
+  assert(cvthing.lock == PTHREAD_MUTEX_INITIALIZER);
+
+  (void) pthread_win32_getabstime_np(&abstime, &reltime);
+
+  assert((t[0] = pthread_self()).p != NULL);
+
+  awoken = 0;
+
+  for (first = 1, last = NUMTHREADS / 2;
+       first < NUMTHREADS;
+       first = last + 1, last = NUMTHREADS)
+    {
+      assert(pthread_mutex_lock(&start_flag) == 0);
+
+      for (i = first; i <= last; i++)
+	{
+	  threadbag[i].started = 0;
+	  threadbag[i].threadnum = i;
+	  assert(pthread_create(&t[i], NULL, mythread, (void *) &threadbag[i]) == 0);
+	}
+
+      /*
+       * Code to control or manipulate child threads should probably go here.
+       */
+      cvthing.shared = 0;
+
+      assert(pthread_mutex_unlock(&start_flag) == 0);
+
+      /*
+       * Give threads time to start.
+       */
+      Sleep(100);
+
+      assert(pthread_mutex_lock(&cvthing.lock) == 0);
+      cvthing.shared++;
+      assert(pthread_mutex_unlock(&cvthing.lock) == 0);
+
+      assert(pthread_cond_broadcast(&cvthing.notbusy) == 0);
+
+      /*
+       * Give threads time to complete.
+       */
+      for (i = first; i <= last; i++)
+	{
+	  assert(pthread_join(t[i], NULL) == 0);
+	}
+
+      assert(awoken == (i - 1));
+    }
+
+
+  /*
+   * Standard check that all threads started.
+   */
+  for (i = 1; i <= NUMTHREADS; i++)
+    { 
+      failed = !threadbag[i].started;
+
+      if (failed)
+	{
+	  fprintf(stderr, "Thread %d: started %d\n", i, threadbag[i].started);
+	}
+    }
+
+  /* 
+   * Cleanup the CV.
+   */
+  
+  assert(pthread_mutex_destroy(&cvthing.lock) == 0);
+
+  assert(cvthing.lock == NULL);
+
+  assert(pthread_cond_destroy(&cvthing.notbusy) == 0);
+
+  assert(cvthing.notbusy == NULL);
+
+  assert(!failed);
+
+  /*
+   * Check any results here.
+   */
+
+  assert(awoken == NUMTHREADS);
+
+  /*
+   * Success.
+   */
+  return 0;
+}
diff --git a/src/include/pthread/tests/condvar9.c b/src/include/pthread/tests/condvar9.c
new file mode 100644
index 0000000..233f16f
--- /dev/null
+++ b/src/include/pthread/tests/condvar9.c
@@ -0,0 +1,257 @@
+/*
+ * File: condvar9.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis:
+ * - Test multiple pthread_cond_broadcasts with thread cancellation.
+ *
+ * Test Method (Validation or Falsification):
+ * - Validation
+ *
+ * Requirements Tested:
+ * - 
+ *
+ * Features Tested:
+ * - 
+ *
+ * Cases Tested:
+ * - 
+ *
+ * Description:
+ * - Make NUMTHREADS threads wait on CV, cancel one, broadcast signal them,
+ *   and then repeat.
+ *
+ * Environment:
+ * - 
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * - 
+ *
+ * Pass Criteria:
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - Process returns non-zero exit status.
+ */
+
+#include "test.h"
+#include <sys/timeb.h>
+
+/*
+ * Create NUMTHREADS threads in addition to the Main thread.
+ */
+enum {
+  NUMTHREADS = 9
+};
+
+typedef struct bag_t_ bag_t;
+struct bag_t_ {
+  int threadnum;
+  int started;
+  int finished;
+  /* Add more per-thread state variables here */
+};
+
+static bag_t threadbag[NUMTHREADS + 1];
+
+typedef struct cvthing_t_ cvthing_t;
+
+struct cvthing_t_ {
+  pthread_cond_t notbusy;
+  pthread_mutex_t lock;
+  int shared;
+};
+
+static cvthing_t cvthing = {
+  PTHREAD_COND_INITIALIZER,
+  PTHREAD_MUTEX_INITIALIZER,
+  0
+};
+
+static pthread_mutex_t start_flag = PTHREAD_MUTEX_INITIALIZER;
+
+static struct timespec abstime, reltime = { 5, 0 };
+
+static int awoken;
+
+static void *
+mythread(void * arg)
+{
+  bag_t * bag = (bag_t *) arg;
+
+  assert(bag == &threadbag[bag->threadnum]);
+  assert(bag->started == 0);
+  bag->started = 1;
+
+  /* Wait for the start gun */
+  assert(pthread_mutex_lock(&start_flag) == 0);
+  assert(pthread_mutex_unlock(&start_flag) == 0);
+
+  assert(pthread_mutex_lock(&cvthing.lock) == 0);
+
+  /*
+   * pthread_cond_timedwait is a cancellation point and we're
+   * going to cancel some threads deliberately.
+   */
+#ifdef _MSC_VER
+#pragma inline_depth(0)
+#endif
+  pthread_cleanup_push(pthread_mutex_unlock, (void *) &cvthing.lock);
+
+  while (! (cvthing.shared > 0))
+    assert(pthread_cond_timedwait(&cvthing.notbusy, &cvthing.lock, &abstime) == 0);
+
+  pthread_cleanup_pop(0);
+#ifdef _MSC_VER
+#pragma inline_depth()
+#endif
+
+  assert(cvthing.shared > 0);
+
+  awoken++;
+  bag->finished = 1;
+
+  assert(pthread_mutex_unlock(&cvthing.lock) == 0);
+
+  return (void *) 0;
+}
+
+int
+main()
+{
+  int failed = 0;
+  int i;
+  int first, last;
+  int canceledThreads = 0;
+  pthread_t t[NUMTHREADS + 1];
+
+  assert((t[0] = pthread_self()).p != NULL);
+
+  assert(cvthing.notbusy == PTHREAD_COND_INITIALIZER);
+
+  assert(cvthing.lock == PTHREAD_MUTEX_INITIALIZER);
+
+  (void) pthread_win32_getabstime_np(&abstime, &reltime);
+
+  assert((t[0] = pthread_self()).p != NULL);
+
+  awoken = 0;
+
+  for (first = 1, last = NUMTHREADS / 2;
+       first < NUMTHREADS;
+       first = last + 1, last = NUMTHREADS)
+    {
+      int ct;
+
+      assert(pthread_mutex_lock(&start_flag) == 0);
+
+      for (i = first; i <= last; i++)
+	{
+	  threadbag[i].started = threadbag[i].finished = 0;
+	  threadbag[i].threadnum = i;
+	  assert(pthread_create(&t[i], NULL, mythread, (void *) &threadbag[i]) == 0);
+	}
+
+      /*
+       * Code to control or manipulate child threads should probably go here.
+       */
+      cvthing.shared = 0;
+
+      assert(pthread_mutex_unlock(&start_flag) == 0);
+
+      /*
+       * Give threads time to start.
+       */
+      Sleep(1000);
+
+      ct = (first + last) / 2;
+      assert(pthread_cancel(t[ct]) == 0);
+      canceledThreads++;
+      assert(pthread_join(t[ct], NULL) == 0);
+
+      assert(pthread_mutex_lock(&cvthing.lock) == 0);
+      cvthing.shared++;
+      assert(pthread_mutex_unlock(&cvthing.lock) == 0);
+
+      assert(pthread_cond_broadcast(&cvthing.notbusy) == 0);
+
+      /*
+       * Standard check that all threads started - and wait for them to finish.
+       */
+      for (i = first; i <= last; i++)
+	{ 
+	  failed = !threadbag[i].started;
+
+          if (failed)
+	    {
+	      fprintf(stderr, "Thread %d: started %d\n", i, threadbag[i].started);
+	    }
+	  else
+	    {
+	      assert(pthread_join(t[i], NULL) == 0 || threadbag[i].finished == 0);
+//	      fprintf(stderr, "Thread %d: finished %d\n", i, threadbag[i].finished);
+	    }
+	}
+    }
+
+  /* 
+   * Cleanup the CV.
+   */
+
+  assert(pthread_mutex_destroy(&cvthing.lock) == 0);
+
+  assert(cvthing.lock == NULL);
+
+  assert_e(pthread_cond_destroy(&cvthing.notbusy), ==, 0);
+
+  assert(cvthing.notbusy == NULL);
+
+  assert(!failed);
+
+  /*
+   * Check any results here.
+   */
+
+  assert(awoken == NUMTHREADS - canceledThreads);
+
+  /*
+   * Success.
+   */
+  return 0;
+}
diff --git a/src/include/pthread/tests/context1.c b/src/include/pthread/tests/context1.c
new file mode 100644
index 0000000..ee5d33d
--- /dev/null
+++ b/src/include/pthread/tests/context1.c
@@ -0,0 +1,144 @@
+/*
+ * File: context1.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis: Test context switching method.
+ *
+ * Test Method (Validation or Falsification):
+ * - 
+ *
+ * Requirements Tested:
+ * -
+ *
+ * Features Tested:
+ * - 
+ *
+ * Cases Tested:
+ * - 
+ *
+ * Description:
+ * - 
+ *
+ * Environment:
+ * - 
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * - pthread_create
+ *   pthread_exit
+ *
+ * Pass Criteria:
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - Process returns non-zero exit status.
+ */
+
+#define _WIN32_WINNT 0x400
+
+#include "test.h"
+/* Cheating here - sneaking a peek at library internals */
+#include "../config.h"
+#include "../implement.h"
+#include "../context.h"
+
+static int washere = 0;
+
+static void * func(void * arg)
+{
+  washere = 1;
+
+  Sleep(1000);
+
+  return 0;
+}
+
+static void
+anotherEnding ()
+{
+  /*
+   * Switched context
+   */
+  washere++;
+  pthread_exit(0);
+}
+
+int
+main()
+{
+  pthread_t t;
+  HANDLE hThread;
+
+  DWORD dwMode = SetErrorMode(SEM_NOGPFAULTERRORBOX);
+  SetErrorMode(dwMode | SEM_NOGPFAULTERRORBOX);
+
+  assert(pthread_create(&t, NULL, func, NULL) == 0);
+
+  hThread = ((__ptw32_thread_t *)t.p)->threadH;
+
+  Sleep(500);
+
+  SuspendThread(hThread);
+
+  if (WaitForSingleObject(hThread, 0) == WAIT_TIMEOUT) 
+    {
+      /*
+       * Ok, thread did not exit before we got to it.
+       */
+      CONTEXT context;
+
+      context.ContextFlags = CONTEXT_CONTROL;
+
+      GetThreadContext(hThread, &context);
+       __PTW32_PROGCTR (context) = (DWORD_PTR) anotherEnding;
+      SetThreadContext(hThread, &context);
+      ResumeThread(hThread);
+    }
+  else
+    {
+      printf("Exited early\n");
+      fflush(stdout);
+    }
+
+  Sleep(1000);
+
+  assert(washere == 2);
+
+  return 0;
+}
+
diff --git a/src/include/pthread/tests/context2.c b/src/include/pthread/tests/context2.c
new file mode 100644
index 0000000..4a4d983
--- /dev/null
+++ b/src/include/pthread/tests/context2.c
@@ -0,0 +1,157 @@
+/*
+ * File: context2.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis: Test context switching method.
+ *
+ * Test Method (Validation or Falsification):
+ * -
+ *
+ * Requirements Tested:
+ * -
+ *
+ * Features Tested:
+ * -
+ *
+ * Cases Tested:
+ * -
+ *
+ * Description:
+ * -
+ *
+ * Environment:
+ * -
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * - pthread_create
+ *   pthread_exit
+ *
+ * Pass Criteria:
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - Process returns non-zero exit status.
+ */
+
+#define _WIN32_WINNT 0x400
+
+#include "test.h"
+/* Cheating here - sneaking a peek at library internals */
+#include "../config.h"
+#include "../implement.h"
+#include "../context.h"
+
+static int washere = 0;
+static volatile size_t tree_counter = 0;
+
+#ifdef _MSC_VER
+# pragma inline_depth(0)
+# pragma optimize("g", off)
+#endif
+
+static size_t tree(size_t depth)
+{
+  if (! depth--)
+    return tree_counter++;
+
+  return tree(depth) + tree(depth);
+}
+
+static void * func(void * arg)
+{
+  washere = 1;
+
+  return (void *) tree(64);
+}
+
+static void
+anotherEnding ()
+{
+  /*
+   * Switched context
+   */
+  washere++;
+  pthread_exit(0);
+}
+
+#ifdef _MSC_VER
+# pragma inline_depth()
+# pragma optimize("", on)
+#endif
+
+int
+main()
+{
+  pthread_t t;
+  HANDLE hThread;
+
+  assert(pthread_create(&t, NULL, func, NULL) == 0);
+
+  hThread = ((__ptw32_thread_t *)t.p)->threadH;
+
+  Sleep(500);
+
+  SuspendThread(hThread);
+
+  if (WaitForSingleObject(hThread, 0) == WAIT_TIMEOUT)
+    {
+      /*
+       * Ok, thread did not exit before we got to it.
+       */
+      CONTEXT context;
+
+      context.ContextFlags = CONTEXT_CONTROL;
+
+      GetThreadContext(hThread, &context);
+       __PTW32_PROGCTR (context) = (DWORD_PTR) anotherEnding;
+      SetThreadContext(hThread, &context);
+      ResumeThread(hThread);
+    }
+  else
+    {
+      printf("Exited early\n");
+      fflush(stdout);
+    }
+
+  Sleep(1000);
+
+  assert(washere == 2);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/count1.c b/src/include/pthread/tests/count1.c
new file mode 100644
index 0000000..e8e4ed3
--- /dev/null
+++ b/src/include/pthread/tests/count1.c
@@ -0,0 +1,88 @@
+/*
+ * count1.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Description:
+ * Test some basic assertions about the number of threads at runtime.
+ */
+
+#include "test.h"
+
+#define NUMTHREADS (30)
+
+static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
+static pthread_t threads[NUMTHREADS];
+static unsigned numThreads = 0;
+
+void *
+myfunc(void *arg)
+{
+  pthread_mutex_lock(&lock);
+  numThreads++;
+  pthread_mutex_unlock(&lock);
+
+  Sleep(1000);
+  return 0;
+}
+int
+main()
+{
+  int i;
+  int maxThreads = sizeof(threads) / sizeof(pthread_t);
+
+  /*
+   * Spawn NUMTHREADS threads. Each thread should increment the
+   * numThreads variable, sleep for one second.
+   */
+  for (i = 0; i < maxThreads; i++)
+    {
+      assert(pthread_create(&threads[i], NULL, myfunc, 0) == 0);
+    }
+  
+  /*
+   * Wait for all the threads to exit.
+   */
+  for (i = 0; i < maxThreads; i++)
+    {
+      assert(pthread_join(threads[i], NULL) == 0);
+    }
+
+  /* 
+   * Check the number of threads created.
+   */
+  assert((int) numThreads == maxThreads);
+  
+  /*
+   * Success.
+   */
+  return 0;
+}
diff --git a/src/include/pthread/tests/create1.c b/src/include/pthread/tests/create1.c
new file mode 100644
index 0000000..3ae0d7f
--- /dev/null
+++ b/src/include/pthread/tests/create1.c
@@ -0,0 +1,64 @@
+/*
+ * create1.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Description:
+ * Create a thread and check that it ran.
+ *
+ * Depends on API functions: None.
+ */
+
+#include "test.h"
+
+static int washere = 0;
+
+void * func(void * arg)
+{
+  washere = 1;
+  return 0; 
+}
+ 
+int
+main()
+{
+  pthread_t t;
+
+  assert(pthread_create(&t, NULL, func, NULL) == 0);
+
+  /* A dirty hack, but we cannot rely on pthread_join in this
+     primitive test. */
+  Sleep(2000);
+
+  assert(washere == 1);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/create2.c b/src/include/pthread/tests/create2.c
new file mode 100644
index 0000000..1c2bb8d
--- /dev/null
+++ b/src/include/pthread/tests/create2.c
@@ -0,0 +1,107 @@
+/*
+ * File: create2.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis:
+ * - Test that threads have a Win32 handle when started.
+ *
+ * Test Method (Validation or Falsification):
+ * - Statistical, not absolute (depends on sample size).
+ *
+ * Requirements Tested:
+ * -
+ *
+ * Features Tested:
+ * -
+ *
+ * Cases Tested:
+ * -
+ *
+ * Description:
+ * -
+ *
+ * Environment:
+ * -
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * -
+ *
+ * Pass Criteria:
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - Process returns non-zero exit status.
+ */
+
+#include "test.h"
+
+enum {
+  NUMTHREADS = 10000
+};
+
+static int washere = 0;
+
+void * func(void * arg)
+{
+  washere = 1;
+  return (void *) 0; 
+}
+ 
+int
+main()
+{
+  pthread_t t;
+  pthread_attr_t attr;
+  void * result = NULL;
+  int i;
+
+  pthread_attr_init(&attr);
+  pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
+
+  for (i = 0; i < NUMTHREADS; i++)
+    {
+      washere = 0;
+      assert(pthread_create(&t, &attr, func, NULL) == 0);
+      assert(pthread_join(t, &result) == 0);
+      assert((int)(size_t)result == 0);
+      assert(washere == 1);
+    }
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/create3.c b/src/include/pthread/tests/create3.c
new file mode 100644
index 0000000..3422bc2
--- /dev/null
+++ b/src/include/pthread/tests/create3.c
@@ -0,0 +1,107 @@
+/*
+ * File: create3.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis:
+ * - Test passing arg to thread function.
+ *
+ * Test Method (Validation or Falsification):
+ * - Statistical, not absolute (depends on sample size).
+ *
+ * Requirements Tested:
+ * -
+ *
+ * Features Tested:
+ * -
+ *
+ * Cases Tested:
+ * -
+ *
+ * Description:
+ * -
+ *
+ * Environment:
+ * -
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * -
+ *
+ * Pass Criteria:
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - Process returns non-zero exit status.
+ */
+
+#include "test.h"
+
+enum {
+  NUMTHREADS = 10000
+};
+
+static int washere = 0;
+
+void * func(void * arg)
+{
+  washere = (int)(size_t)arg;
+  return (void *) 0; 
+}
+ 
+int
+main()
+{
+  pthread_t t;
+  pthread_attr_t attr;
+  void * result = NULL;
+  int i;
+
+  pthread_attr_init(&attr);
+  pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
+
+  for (i = 0; i < NUMTHREADS; i++)
+    {
+      washere = 0;
+      assert(pthread_create(&t, &attr, func, (void *)(size_t)1) == 0);
+      assert(pthread_join(t, &result) == 0);
+      assert((int)(size_t)result == 0);
+      assert(washere == 1);
+    }
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/delay1.c b/src/include/pthread/tests/delay1.c
new file mode 100644
index 0000000..a607fe6
--- /dev/null
+++ b/src/include/pthread/tests/delay1.c
@@ -0,0 +1,49 @@
+/*
+ * delay1.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Depends on API functions:
+ *    pthread_delay_np
+ */
+
+#include "test.h"
+
+int
+main(int argc, char * argv[])
+{
+  struct timespec interval = {1L, 500000000L};
+
+  assert(pthread_delay_np(&interval) == 0);
+
+  return 0;
+}
+
diff --git a/src/include/pthread/tests/delay2.c b/src/include/pthread/tests/delay2.c
new file mode 100644
index 0000000..7dc68ce
--- /dev/null
+++ b/src/include/pthread/tests/delay2.c
@@ -0,0 +1,80 @@
+/*
+ * delay1.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Depends on API functions:
+ *    pthread_delay_np
+ */
+
+#include "test.h"
+
+pthread_mutex_t mx = PTHREAD_MUTEX_INITIALIZER;
+
+void *
+func(void * arg)
+{
+  struct timespec interval = {5, 500000000L};
+
+  assert(pthread_mutex_lock(&mx) == 0);
+
+#ifdef _MSC_VER
+#pragma inline_depth(0)
+#endif
+  pthread_cleanup_push(pthread_mutex_unlock, &mx);
+  assert(pthread_delay_np(&interval) == 0);
+  pthread_cleanup_pop(1);
+#ifdef _MSC_VER
+#pragma inline_depth()
+#endif
+
+  return (void *)(size_t)1;
+}
+
+int
+main(int argc, char * argv[])
+{
+  pthread_t t;
+  void* result = (void*)0;
+
+  assert(pthread_mutex_lock(&mx) == 0);
+
+  assert(pthread_create(&t, NULL, func, NULL) == 0);
+  assert(pthread_cancel(t) == 0);
+
+  assert(pthread_mutex_unlock(&mx) == 0);
+
+  assert(pthread_join(t, &result) == 0);
+  assert(result == (void*)PTHREAD_CANCELED);
+
+  return 0;
+}
+
diff --git a/src/include/pthread/tests/detach1.c b/src/include/pthread/tests/detach1.c
new file mode 100644
index 0000000..d9ebe52
--- /dev/null
+++ b/src/include/pthread/tests/detach1.c
@@ -0,0 +1,91 @@
+/*
+ * Test for pthread_detach().
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Depends on API functions: pthread_create(), pthread_detach(), pthread_exit().
+ */
+
+#include "test.h"
+
+
+enum {
+  NUMTHREADS = 100
+};
+
+void *
+func(void * arg)
+{
+    int i = (int)(size_t)arg;
+
+    Sleep(i * 10);
+
+    pthread_exit(arg);
+
+    /* Never reached. */
+    exit(1);
+}
+
+int
+main(int argc, char * argv[])
+{
+	pthread_t id[NUMTHREADS];
+	int i;
+
+	/* Create a few threads and then exit. */
+	for (i = 0; i < NUMTHREADS; i++)
+	  {
+	    assert(pthread_create(&id[i], NULL, func, (void *)(size_t)i) == 0);
+	  }
+
+	/* Some threads will finish before they are detached, some after. */
+	Sleep(NUMTHREADS/2 * 10 + 50);
+
+	for (i = 0; i < NUMTHREADS; i++)
+	  {
+	    assert(pthread_detach(id[i]) == 0);
+	  }
+
+	Sleep(NUMTHREADS * 10 + 100);
+
+	/*
+	 * Check that all threads are now invalid.
+	 * This relies on unique thread IDs - e.g. works with
+	 * pthreads-w32 or Solaris, but may not work for Linux, BSD etc.
+	 */
+	for (i = 0; i < NUMTHREADS; i++)
+	  {
+	    assert(pthread_kill(id[i], 0) == ESRCH);
+	  }
+
+	/* Success. */
+	return 0;
+}
diff --git a/src/include/pthread/tests/equal1.c b/src/include/pthread/tests/equal1.c
new file mode 100644
index 0000000..1b1e6dd
--- /dev/null
+++ b/src/include/pthread/tests/equal1.c
@@ -0,0 +1,64 @@
+/*
+ * Test for pthread_equal.
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Depends on functions: pthread_create().
+ */
+
+#include "test.h"
+
+void * func(void * arg)
+{
+  Sleep(2000);
+  return 0;
+}
+
+int 
+main()
+{
+  pthread_t t1, t2;
+
+  assert(pthread_create(&t1, NULL, func, (void *) 1) == 0);
+
+  assert(pthread_create(&t2, NULL, func, (void *) 2) == 0);
+
+  assert(pthread_equal(t1, t2) == 0);
+
+  assert(pthread_equal(t1,t1) != 0);
+
+  /* This is a hack. We don't want to rely on pthread_join
+     yet if we can help it. */
+   Sleep(4000);
+
+  /* Success. */
+  return 0;
+}
diff --git a/src/include/pthread/tests/errno0.c b/src/include/pthread/tests/errno0.c
new file mode 100644
index 0000000..83790e2
--- /dev/null
+++ b/src/include/pthread/tests/errno0.c
@@ -0,0 +1,99 @@
+/*
+ * File: errno0.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads Library for Win32
+ *      Copyright(C) 1998 John E. Bossom
+ *      Copyright(C) 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * This file is part of Pthreads4w.
+ *
+ *    Pthreads4w is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    Pthreads4w is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with Pthreads4w.  If not, see <http://www.gnu.org/licenses/>. *
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis: Test transmissibility of errno between library and exe
+ * - 
+ *
+ * Test Method (Validation or Falsification):
+ * - Validation
+ *
+ * Requirements Tested:
+ * - 
+ *
+ * Features Tested:
+ * - 
+ *
+ * Cases Tested:
+ * - 
+ *
+ * Description:
+ * - 
+ *
+ * Environment:
+ * - 
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * - 
+ *
+ * Pass Criteria:
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - Process returns non-zero exit status.
+ */
+
+#include "test.h"
+
+int
+main()
+{
+  int err = 0;
+  errno = 0;
+
+  assert(errno == 0);
+  assert(0 != sem_destroy(NULL));
+
+  err =
+#if defined(PTW32_USES_SEPARATE_CRT)
+      GetLastError();
+#else
+      errno;
+#endif
+
+  assert(err != 0);
+  assert(err == EINVAL);
+
+  /*
+   * Success.
+   */
+  return 0;
+}
diff --git a/src/include/pthread/tests/errno1.c b/src/include/pthread/tests/errno1.c
new file mode 100644
index 0000000..29fabf2
--- /dev/null
+++ b/src/include/pthread/tests/errno1.c
@@ -0,0 +1,175 @@
+/*
+ * File: errno1.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis: Test thread-safety of errno
+ * - 
+ *
+ * Test Method (Validation or Falsification):
+ * - Validation
+ *
+ * Requirements Tested:
+ * - 
+ *
+ * Features Tested:
+ * - 
+ *
+ * Cases Tested:
+ * - 
+ *
+ * Description:
+ * - 
+ *
+ * Environment:
+ * - 
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * - 
+ *
+ * Pass Criteria:
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - Process returns non-zero exit status.
+ */
+
+#include "test.h"
+
+/*
+ * Create NUMTHREADS threads in addition to the Main thread.
+ */
+enum {
+  NUMTHREADS = 3
+};
+
+typedef struct bag_t_ bag_t;
+struct bag_t_ {
+  int threadnum;
+  int started;
+  /* Add more per-thread state variables here */
+};
+
+static bag_t threadbag[NUMTHREADS + 1];
+
+pthread_mutex_t stop_here = PTHREAD_MUTEX_INITIALIZER;
+
+void *
+mythread(void * arg)
+{
+  bag_t * bag = (bag_t *) arg;
+
+  assert(bag == &threadbag[bag->threadnum]);
+  assert(bag->started == 0);
+  bag->started = 1;
+
+  errno = bag->threadnum;
+
+  Sleep(1000);
+
+  pthread_mutex_lock(&stop_here);
+
+  assert(errno == bag->threadnum);
+
+  pthread_mutex_unlock(&stop_here);
+
+  Sleep(1000);
+
+  return 0;
+}
+
+int
+main()
+{
+  int failed = 0;
+  int i;
+  pthread_t t[NUMTHREADS + 1];
+
+  pthread_mutex_lock(&stop_here);
+  errno = 0;
+
+  assert((t[0] = pthread_self()).p != NULL);
+
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      threadbag[i].started = 0;
+      threadbag[i].threadnum = i;
+      assert(pthread_create(&t[i], NULL, mythread, (void *) &threadbag[i]) == 0);
+    }
+
+  /*
+   * Code to control or manipulate child threads should probably go here.
+   */
+  Sleep(2000);
+  pthread_mutex_unlock(&stop_here);
+
+  /*
+   * Give threads time to run.
+   */
+  Sleep(NUMTHREADS * 1000);
+
+  /*
+   * Standard check that all threads started.
+   */
+  for (i = 1; i <= NUMTHREADS; i++)
+    { 
+      failed = !threadbag[i].started;
+
+      if (failed)
+	{
+	  fprintf(stderr, "Thread %d: started %d\n", i, threadbag[i].started);
+	}
+    }
+
+  assert(!failed);
+
+  /*
+   * Check any results here. Set "failed" and only print ouput on failure.
+   */
+  for (i = 1; i <= NUMTHREADS; i++)
+    { 
+      /* ... */
+    }
+
+  assert(!failed);
+
+  /*
+   * Success.
+   */
+  return 0;
+}
diff --git a/src/include/pthread/tests/exception1.c b/src/include/pthread/tests/exception1.c
new file mode 100644
index 0000000..7ee37bd
--- /dev/null
+++ b/src/include/pthread/tests/exception1.c
@@ -0,0 +1,264 @@
+/*
+ * File: exception1.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis: Test passing of exceptions back to the application.
+ *
+ * Test Method (Validation or Falsification):
+ * -
+ *
+ * Requirements Tested:
+ * -
+ *
+ * Features Tested:
+ * -
+ *
+ * Cases Tested:
+ * -
+ *
+ * Description:
+ * -
+ *
+ * Environment:
+ * -
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * - have working pthread_create, pthread_self, pthread_mutex_lock/unlock
+ *   pthread_testcancel, pthread_cancel, pthread_join
+ *
+ * Pass Criteria:
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - Process returns non-zero exit status.
+ */
+
+#if defined(_MSC_VER) || defined(__cplusplus)
+
+#include "test.h"
+
+/*
+ * Create NUMTHREADS threads in addition to the Main thread.
+ */
+enum {
+  NUMTHREADS = 4
+};
+
+void *
+exceptionedThread(void * arg)
+{
+  int dummy = 0;
+  void* result = (void*)((int)(size_t)PTHREAD_CANCELED + 1);
+  /* Set to async cancelable */
+
+  assert(pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL) == 0);
+
+  assert(pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL) == 0);
+
+  Sleep(100);
+
+#if defined(_MSC_VER) && !defined(__cplusplus)
+  __try
+  {
+    int zero = (int) (size_t)arg; /* Passed in from arg to avoid compiler error */
+    int one = 1;
+    /*
+     * The deliberate exception condition (zero divide) is
+     * in an "if" to avoid being optimised out.
+     */
+    if (dummy == one/zero)
+      Sleep(0);
+  }
+  __except (EXCEPTION_EXECUTE_HANDLER)
+  {
+    /* Should get into here. */
+    result = (void*)((int)(size_t)PTHREAD_CANCELED + 2);
+  }
+#elif defined(__cplusplus)
+  try
+  {
+    /*
+     * I had a zero divide exception here but it
+     * wasn't being caught by the catch(...)
+     * below under Mingw32. That could be a problem.
+     */
+    throw dummy;
+  }
+#if defined(__PtW32CatchAll)
+  __PtW32CatchAll
+#else
+  catch (...)
+#endif
+  {
+    /* Should get into here. */
+    result = (void*)((int)(size_t)PTHREAD_CANCELED + 2);
+  }
+#endif
+
+  return (void *) (size_t)result;
+}
+
+void *
+canceledThread(void * arg)
+{
+  void* result = (void*)((int)(size_t)PTHREAD_CANCELED + 1);
+  int count;
+
+  /* Set to async cancelable */
+
+  assert(pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL) == 0);
+
+  assert(pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL) == 0);
+
+#if defined(_MSC_VER) && !defined(__cplusplus)
+  __try
+  {
+    /*
+     * We wait up to 10 seconds, waking every 0.1 seconds,
+     * for a cancellation to be applied to us.
+     */
+    for (count = 0; count < 100; count++)
+      Sleep(100);
+  }
+  __except (EXCEPTION_EXECUTE_HANDLER)
+  {
+    /* Should NOT get into here. */
+    result = (void*)((int)(size_t)PTHREAD_CANCELED + 2);
+  }
+#elif defined(__cplusplus)
+  try
+  {
+    /*
+     * We wait up to 10 seconds, waking every 0.1 seconds,
+     * for a cancellation to be applied to us.
+     */
+    for (count = 0; count < 100; count++)
+      Sleep(100);
+  }
+#if defined(__PtW32CatchAll)
+  __PtW32CatchAll
+#else
+  catch (...)
+#endif
+  {
+    /* Should NOT get into here. */
+    result = (void*)((int)(size_t)PTHREAD_CANCELED + 2);
+  }
+#endif
+
+  return (void *) (size_t)result;
+}
+
+int
+main()
+{
+  int failed = 0;
+  int i;
+  pthread_t mt;
+  pthread_t et[NUMTHREADS];
+  pthread_t ct[NUMTHREADS];
+
+  DWORD dwMode = SetErrorMode(SEM_NOGPFAULTERRORBOX);
+  SetErrorMode(dwMode | SEM_NOGPFAULTERRORBOX);
+
+  assert((mt = pthread_self()).p != NULL);
+
+  for (i = 0; i < NUMTHREADS; i++)
+    {
+      assert(pthread_create(&et[i], NULL, exceptionedThread, (void *) 0) == 0);
+      assert(pthread_create(&ct[i], NULL, canceledThread, NULL) == 0);
+    }
+
+  /*
+   * Code to control or manipulate child threads should probably go here.
+   */
+  Sleep(100);
+
+  for (i = 0; i < NUMTHREADS; i++)
+    {
+      assert(pthread_cancel(ct[i]) == 0);
+    }
+
+  /*
+   * Give threads time to run.
+   */
+  Sleep(NUMTHREADS * 100);
+
+  /*
+   * Check any results here. Set "failed" and only print output on failure.
+   */
+  failed = 0;
+  for (i = 0; i < NUMTHREADS; i++)
+    {
+      int fail = 0;
+      void* result = (void*)0;
+
+	/* Canceled thread */
+      assert(pthread_join(ct[i], &result) == 0);
+      assert(!(fail = (result != PTHREAD_CANCELED)));
+
+      failed = (failed || fail);
+
+      /* Exceptioned thread */
+      assert(pthread_join(et[i], &result) == 0);
+      assert(!(fail = (result != (void*)((int)(size_t)PTHREAD_CANCELED + 2))));
+
+      failed = (failed || fail);
+    }
+
+  assert(!failed);
+
+  /*
+   * Success.
+   */
+  return 0;
+}
+
+#else /* defined(_MSC_VER) || defined(__cplusplus) */
+
+#include <stdio.h>
+
+int
+main()
+{
+  fprintf(stderr, "Test N/A for this compiler environment.\n");
+  return 0;
+}
+
+#endif /* defined(_MSC_VER) || defined(__cplusplus) */
diff --git a/src/include/pthread/tests/exception2.c b/src/include/pthread/tests/exception2.c
new file mode 100644
index 0000000..ce61b05
--- /dev/null
+++ b/src/include/pthread/tests/exception2.c
@@ -0,0 +1,170 @@
+/*
+ * File: exception2.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis: Test passing of exceptions out of thread scope.
+ *
+ * Test Method (Validation or Falsification):
+ * - 
+ *
+ * Requirements Tested:
+ * -
+ *
+ * Features Tested:
+ * - 
+ *
+ * Cases Tested:
+ * - 
+ *
+ * Description:
+ * - 
+ *
+ * Environment:
+ * - 
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * - have working pthread_create, pthread_self, pthread_mutex_lock/unlock
+ *   pthread_testcancel, pthread_cancel
+ *
+ * Pass Criteria:
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - Process returns non-zero exit status.
+ */
+
+
+#if defined(_MSC_VER) || defined(__cplusplus)
+
+#if defined(_MSC_VER) && defined(__cplusplus)
+#include <eh.h>
+#elif defined(__cplusplus)
+#include <exception>
+#endif
+
+#ifdef __GNUC__
+#include <stdlib.h>
+#endif
+
+#include "test.h"
+
+/*
+ * Create NUMTHREADS threads in addition to the Main thread.
+ */
+enum {
+  NUMTHREADS = 1
+};
+
+
+void *
+exceptionedThread(void * arg)
+{
+  int dummy = 0x1;
+
+#if defined(_MSC_VER) && !defined(__cplusplus)
+
+  RaiseException(dummy, 0, 0, NULL);
+
+#elif defined(__cplusplus)
+
+  throw dummy;
+
+#endif
+
+  return (void *) 100;
+}
+
+int
+main(int argc, char* argv[])
+{
+  int i;
+  pthread_t mt;
+  pthread_t et[NUMTHREADS];
+
+  DWORD dwMode = SetErrorMode(SEM_NOGPFAULTERRORBOX);
+  SetErrorMode(dwMode | SEM_NOGPFAULTERRORBOX);
+
+  if (argc <= 1)
+    {
+      int result;
+
+      printf("You should see an \"abnormal termination\" message\n");
+      fflush(stdout);
+
+      result = system("exception2.exe die");
+
+      printf("\"exception2.exe die\" returned status %d\n", result);
+
+      /*
+       * result should be 0, 1 or 3 depending on build settings
+       */
+      exit((result == 0 || result == 1 || result == 3) ? 0 : 1);
+    }
+
+#if defined(NO_ERROR_DIALOGS)
+  SetErrorMode(SEM_NOGPFAULTERRORBOX);
+#endif
+
+  assert((mt = pthread_self()).p != NULL);
+
+  for (i = 0; i < NUMTHREADS; i++)
+    {
+      assert(pthread_create(&et[i], NULL, exceptionedThread, NULL) == 0);
+    }
+
+  Sleep(100);
+
+  /*
+   * Success.
+   */
+  return 0;
+}
+
+#else /* defined(_MSC_VER) || defined(__cplusplus) */
+
+#include <stdio.h>
+
+int
+main()
+{
+  fprintf(stderr, "Test N/A for this compiler environment.\n");
+  return 0;
+}
+
+#endif /* defined(_MSC_VER) || defined(__cplusplus) */
diff --git a/src/include/pthread/tests/exception3.c b/src/include/pthread/tests/exception3.c
new file mode 100644
index 0000000..f7ae311
--- /dev/null
+++ b/src/include/pthread/tests/exception3.c
@@ -0,0 +1,209 @@
+/*
+ * File: exception3.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis: Test running of user supplied terminate() function.
+ *
+ * Test Method (Validation or Falsification):
+ * - 
+ *
+ * Requirements Tested:
+ * -
+ *
+ * Features Tested:
+ * - 
+ *
+ * Cases Tested:
+ * - 
+ *
+ * Description:
+ * - 
+ *
+ * Environment:
+ * - 
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * - have working pthread_create, pthread_self, pthread_mutex_lock/unlock
+ *   pthread_testcancel, pthread_cancel
+ *
+ * Pass Criteria:
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - Process returns non-zero exit status.
+ */
+
+#include "test.h"
+
+/*
+ * Note: Due to a buggy C++ runtime in Visual Studio 2005, when we are
+ * built with /MD and an unhandled exception occurs, the runtime does not
+ * properly call the terminate handler specified by set_terminate().
+ */
+#if defined(__cplusplus) \
+	&& !(defined(_MSC_VER) && _MSC_VER == 1400 && defined(_DLL) && !defined(_DEBUG))
+
+#if defined(_MSC_VER)
+# include <eh.h>
+#else
+# if defined(__GNUC__) && __GNUC__ < 3
+#   include <new.h>
+# else
+#   include <new>
+    using std::set_terminate;
+# endif
+#endif
+
+/*
+ * Create NUMTHREADS threads in addition to the Main thread.
+ */
+enum {
+  NUMTHREADS = 10
+};
+
+int caught = 0;
+pthread_mutex_t caughtLock;
+
+void
+terminateFunction ()
+{
+  assert(pthread_mutex_lock(&caughtLock) == 0);
+  caught++;
+#if 0
+  {
+     FILE * fp = fopen("pthread.log", "a");
+     fprintf(fp, "Caught = %d\n", caught);
+     fclose(fp);
+  }
+#endif
+  assert_e(pthread_mutex_unlock(&caughtLock), ==, 0);
+
+  /*
+   * Notes from the MSVC++ manual:
+   *       1) A term_func() should call exit(), otherwise
+   *          abort() will be called on return to the caller.
+   *          abort() raises SIGABRT. The default signal handler
+   *          for all signals terminates the calling program with
+   *          exit code 3.
+   *       2) A term_func() must not throw an exception. Dev: Therefore
+   *          term_func() should not call pthread_exit() if an
+   *          exception-using version of pthreads-win32 library
+   *          is being used (i.e. either pthreadVCE or pthreadVSE).
+   */
+  /*
+   * Allow time for all threads to reach here before exit, otherwise
+   * threads will be terminated while holding the lock and cause
+   * the next unlock to return EPERM (we're using ERRORCHECK mutexes).
+   * Perhaps this would be a good test for robust mutexes.
+   */
+  Sleep(20);
+
+  exit(0);
+}
+
+void
+wrongTerminateFunction ()
+{
+  fputs("This is not the termination routine that should have been called!\n", stderr);
+  exit(1);
+}
+
+void *
+exceptionedThread(void * arg)
+{
+  int dummy = 0x1;
+
+#if defined (__PTW32_USES_SEPARATE_CRT) && (defined(__PTW32_CLEANUP_CXX) || defined(__PTW32_CLEANUP_SEH))
+  printf("PTW32_USES_SEPARATE_CRT is defined\n");
+  pthread_win32_set_terminate_np(&terminateFunction);
+  set_terminate(&wrongTerminateFunction);
+#else
+  set_terminate(&terminateFunction);
+#endif
+
+  throw dummy;
+
+  return (void *) 0;
+}
+
+int
+main()
+{
+  int i;
+  pthread_t mt;
+  pthread_t et[NUMTHREADS];
+  pthread_mutexattr_t ma;
+
+  DWORD dwMode = SetErrorMode(SEM_NOGPFAULTERRORBOX);
+  SetErrorMode(dwMode | SEM_NOGPFAULTERRORBOX);
+
+  assert((mt = pthread_self()).p != NULL);
+
+  printf("See the notes inside of exception3.c re term_funcs.\n");
+
+  assert(pthread_mutexattr_init(&ma) == 0);
+  assert(pthread_mutexattr_settype(&ma, PTHREAD_MUTEX_ERRORCHECK) == 0);
+  assert(pthread_mutex_init(&caughtLock, &ma) == 0);
+  assert(pthread_mutexattr_destroy(&ma) == 0);
+
+  for (i = 0; i < NUMTHREADS; i++)
+    {
+      assert(pthread_create(&et[i], NULL, exceptionedThread, NULL) == 0);
+    }
+
+  while (true);
+
+  /*
+   * Should never be reached.
+   */
+  return 1;
+}
+
+#else /* defined(__cplusplus) */
+
+#include <stdio.h>
+
+int
+main()
+{
+  fprintf(stderr, "Test N/A for this compiler environment.\n");
+  return 0;
+}
+
+#endif /* defined(__cplusplus) */
diff --git a/src/include/pthread/tests/exception3_0.c b/src/include/pthread/tests/exception3_0.c
new file mode 100644
index 0000000..b331de7
--- /dev/null
+++ b/src/include/pthread/tests/exception3_0.c
@@ -0,0 +1,187 @@
+/*
+ * File: exception3.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis: Test running of user supplied terminate() function.
+ *
+ * Test Method (Validation or Falsification):
+ * -
+ *
+ * Requirements Tested:
+ * -
+ *
+ * Features Tested:
+ * -
+ *
+ * Cases Tested:
+ * -
+ *
+ * Description:
+ * -
+ *
+ * Environment:
+ * -
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * - have working pthread_create, pthread_self, pthread_mutex_lock/unlock
+ *   pthread_testcancel, pthread_cancel
+ *
+ * Pass Criteria:
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - Process returns non-zero exit status.
+ */
+
+#include "test.h"
+
+/*
+ * Note: Due to a buggy C++ runtime in Visual Studio 2005, when we are
+ * built with /MD and an unhandled exception occurs, the runtime does not
+ * properly call the terminate handler specified by set_terminate().
+ */
+#if defined(__cplusplus) \
+	&& !(defined(_MSC_VER) && _MSC_VER == 1400 && defined(_DLL) && !defined(_DEBUG))
+
+#if defined(_MSC_VER)
+# include <eh.h>
+#else
+# if defined(__GNUC__) && __GNUC__ < 3
+#   include <new.h>
+# else
+#   include <new>
+    using std::set_terminate;
+# endif
+#endif
+
+/*
+ * Create NUMTHREADS threads in addition to the Main thread.
+ */
+enum {
+  NUMTHREADS = 10
+};
+
+int caught = 0;
+CRITICAL_SECTION caughtLock;
+
+void
+terminateFunction ()
+{
+  EnterCriticalSection(&caughtLock);
+  caught++;
+#if 0
+  {
+     FILE * fp = fopen("pthread.log", "a");
+     fprintf(fp, "Caught = %d\n", caught);
+     fclose(fp);
+  }
+#endif
+  LeaveCriticalSection(&caughtLock);
+
+  /*
+   * Notes from the MSVC++ manual:
+   *       1) A term_func() should call exit(), otherwise
+   *          abort() will be called on return to the caller.
+   *          abort() raises SIGABRT. The default signal handler
+   *          for all signals terminates the calling program with
+   *          exit code 3.
+   *       2) A term_func() must not throw an exception. Dev: Therefore
+   *          term_func() should not call pthread_exit() if an
+   *          exception-using version of pthreads-win32 library
+   *          is being used (i.e. either pthreadVCE or pthreadVSE).
+   */
+  exit(0);
+}
+
+void *
+exceptionedThread(void * arg)
+{
+  int dummy = 0x1;
+
+  set_terminate(&terminateFunction);
+  assert(set_terminate(&terminateFunction) == &terminateFunction);
+
+  throw dummy;
+
+  return (void *) 2;
+}
+
+int
+main()
+{
+  int i;
+  DWORD et[NUMTHREADS];
+
+  DWORD dwMode = SetErrorMode(SEM_NOGPFAULTERRORBOX);
+  SetErrorMode(dwMode | SEM_NOGPFAULTERRORBOX);
+
+  InitializeCriticalSection(&caughtLock);
+
+  for (i = 0; i < NUMTHREADS; i++)
+    {
+      CreateThread(NULL, //Choose default security
+        0, //Default stack size
+        (LPTHREAD_START_ROUTINE)&exceptionedThread, //Routine to execute
+        NULL, //Thread parameter
+        0, //Immediately run the thread
+        &et[i] //Thread Id
+        );
+    }
+
+  Sleep(NUMTHREADS * 10);
+
+  DeleteCriticalSection(&caughtLock);
+  /*
+   * Fail. Should never be reached.
+   */
+  return 1;
+}
+
+#else /* defined(__cplusplus) */
+
+#include <stdio.h>
+
+int
+main()
+{
+  fprintf(stderr, "Test N/A for this compiler environment.\n");
+  return 0;
+}
+
+#endif /* defined(__cplusplus) */
diff --git a/src/include/pthread/tests/exit1.c b/src/include/pthread/tests/exit1.c
new file mode 100644
index 0000000..73d917c
--- /dev/null
+++ b/src/include/pthread/tests/exit1.c
@@ -0,0 +1,47 @@
+/*
+ * Test for pthread_exit().
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Depends on API functions: None.
+ */
+
+#include "test.h"
+
+int
+main(int argc, char * argv[])
+{
+	/* A simple test first. */
+	pthread_exit((void *) 0);
+
+	/* Not reached */
+	return 1;
+}
diff --git a/src/include/pthread/tests/exit2.c b/src/include/pthread/tests/exit2.c
new file mode 100644
index 0000000..af25ec0
--- /dev/null
+++ b/src/include/pthread/tests/exit2.c
@@ -0,0 +1,67 @@
+/*
+ * Test for pthread_exit().
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Depends on API functions:
+ *	pthread_create()
+ *	pthread_exit()
+ */
+
+#include "test.h"
+
+void *
+func(void * arg)
+{
+  int failed = (int) arg;
+
+  pthread_exit(arg);
+
+  /* Never reached. */
+  /*
+   * Trick gcc compiler into not issuing a warning here
+   */
+  assert(failed - (int)arg);
+
+  return NULL;
+}
+
+int
+main(int argc, char * argv[])
+{
+  pthread_t t;
+
+  assert(pthread_create(&t, NULL, func, (void *) NULL) == 0);
+
+  Sleep(100);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/exit3.c b/src/include/pthread/tests/exit3.c
new file mode 100644
index 0000000..a4cb122
--- /dev/null
+++ b/src/include/pthread/tests/exit3.c
@@ -0,0 +1,71 @@
+/*
+ * Test for pthread_exit().
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Depends on API functions: pthread_create().
+ */
+
+#include "test.h"
+
+void *
+func(void * arg)
+{
+	int failed = (int) arg;
+
+	pthread_exit(arg);
+
+	/* Never reached. */
+        /*
+         * assert(0) in a way to prevent warning or optimising away.
+         */
+	assert(failed - (int) arg);
+
+	return NULL;
+}
+
+int
+main(int argc, char * argv[])
+{
+	pthread_t id[4];
+	int i;
+
+	/* Create a few threads and then exit. */
+	for (i = 0; i < 4; i++)
+	  {
+	    assert(pthread_create(&id[i], NULL, func, (void *)(size_t)i) == 0);
+	  }
+
+	Sleep(400);
+
+	/* Success. */
+	return 0;
+}
diff --git a/src/include/pthread/tests/exit4.c b/src/include/pthread/tests/exit4.c
new file mode 100644
index 0000000..746bfc8
--- /dev/null
+++ b/src/include/pthread/tests/exit4.c
@@ -0,0 +1,197 @@
+/*
+ * File: exit4.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis: Test calling pthread_exit from a Win32 thread
+ *                without having created an implicit POSIX handle for it.
+ *
+ * Test Method (Validation or Falsification):
+ * - 
+ *
+ * Requirements Tested:
+ * -
+ *
+ * Features Tested:
+ * - 
+ *
+ * Cases Tested:
+ * - 
+ *
+ * Description:
+ * - 
+ *
+ * Environment:
+ * - 
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * - have working pthread_create, pthread_self, pthread_mutex_lock/unlock
+ *   pthread_testcancel, pthread_cancel
+ *
+ * Pass Criteria:
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - Process returns non-zero exit status.
+ */
+
+#include "test.h"
+#ifndef _UWIN
+#include <process.h>
+#endif
+
+/*
+ * Create NUMTHREADS threads in addition to the Main thread.
+ */
+enum {
+  NUMTHREADS = 4
+};
+
+typedef struct bag_t_ bag_t;
+struct bag_t_ {
+  int threadnum;
+  int started;
+  /* Add more per-thread state variables here */
+  int count;
+};
+
+static bag_t threadbag[NUMTHREADS + 1];
+
+#if ! defined (__MINGW32__) || defined (__MSVCRT__)
+unsigned __stdcall
+#else
+void
+#endif
+Win32thread(void * arg)
+{
+  int result = 1;
+  bag_t * bag = (bag_t *) arg;
+
+  assert(bag == &threadbag[bag->threadnum]);
+  assert(bag->started == 0);
+  bag->started = 1;
+
+  /*
+   * Doesn't return and doesn't create an implicit POSIX handle.
+   */
+  pthread_exit((void *)(size_t)result);
+
+  return 0;
+}
+
+int
+main()
+{
+  int failed = 0;
+  int i;
+  HANDLE h[NUMTHREADS + 1];
+  unsigned thrAddr; /* Dummy variable to pass a valid location to _beginthreadex (Win98). */
+
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      threadbag[i].started = 0;
+      threadbag[i].threadnum = i;
+#if ! defined (__MINGW32__) || defined (__MSVCRT__)
+      h[i] = (HANDLE) _beginthreadex(NULL, 0, Win32thread, (void *) &threadbag[i], 0, &thrAddr);
+#else
+      h[i] = (HANDLE) _beginthread(Win32thread, 0, (void *) &threadbag[i]);
+#endif
+    }
+
+  /*
+   * Code to control or manipulate child threads should probably go here.
+   */
+  Sleep(500);
+
+  /*
+   * Give threads time to run.
+   */
+  Sleep(NUMTHREADS * 100);
+
+  /*
+   * Standard check that all threads started.
+   */
+  for (i = 1; i <= NUMTHREADS; i++)
+    { 
+      if (!threadbag[i].started)
+	{
+	  failed |= !threadbag[i].started;
+	  fprintf(stderr, "Thread %d: started %d\n", i, threadbag[i].started);
+	}
+    }
+
+  assert(!failed);
+
+  /*
+   * Check any results here. Set "failed" and only print output on failure.
+   */
+  failed = 0;
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      int fail = 0;
+      int result = 0;
+
+#if ! defined (__MINGW32__) || defined (__MSVCRT__)
+      assert(GetExitCodeThread(h[i], (LPDWORD) &result) == TRUE);
+#else
+      /*
+       * Can't get a result code.
+       */
+      result = 1;
+#endif
+
+      fail = (result != 1);
+
+      if (fail)
+	{
+	  fprintf(stderr, "Thread %d: started %d: count %d\n",
+		  i,
+		  threadbag[i].started,
+		  threadbag[i].count);
+	}
+      failed = (failed || fail);
+    }
+
+  assert(!failed);
+
+  /*
+   * Success.
+   */
+  return 0;
+}
+
diff --git a/src/include/pthread/tests/exit5.c b/src/include/pthread/tests/exit5.c
new file mode 100644
index 0000000..c33e8a9
--- /dev/null
+++ b/src/include/pthread/tests/exit5.c
@@ -0,0 +1,204 @@
+/*
+ * File: exit5.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis: Test calling pthread_exit from a Win32 thread
+ *                having created an implicit POSIX handle for it.
+ *
+ * Test Method (Validation or Falsification):
+ * - Validate return value and that POSIX handle is created and destroyed.
+ *
+ * Requirements Tested:
+ * -
+ *
+ * Features Tested:
+ * -
+ *
+ * Cases Tested:
+ * -
+ *
+ * Description:
+ * -
+ *
+ * Environment:
+ * -
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * - have working pthread_create, pthread_self, pthread_mutex_lock/unlock
+ *   pthread_testcancel, pthread_cancel
+ *
+ * Pass Criteria:
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - Process returns non-zero exit status.
+ */
+
+#include "test.h"
+#ifndef _UWIN
+#include <process.h>
+#endif
+
+/*
+ * Create NUMTHREADS threads in addition to the Main thread.
+ */
+enum {
+  NUMTHREADS = 4
+};
+
+typedef struct bag_t_ bag_t;
+struct bag_t_ {
+  int threadnum;
+  int started;
+  /* Add more per-thread state variables here */
+  int count;
+  pthread_t self;
+};
+
+static bag_t threadbag[NUMTHREADS + 1];
+
+#if ! defined (__MINGW32__) || defined (__MSVCRT__)
+unsigned __stdcall
+#else
+void
+#endif
+Win32thread(void * arg)
+{
+  int result = 1;
+  bag_t * bag = (bag_t *) arg;
+
+  assert(bag == &threadbag[bag->threadnum]);
+  assert(bag->started == 0);
+  bag->started = 1;
+
+  assert((bag->self = pthread_self()).p != NULL);
+  assert(pthread_kill(bag->self, 0) == 0);
+
+  /*
+   * Doesn't return.
+   */
+  pthread_exit((void *)(size_t)result);
+
+  return 0;
+}
+
+int
+main()
+{
+  int failed = 0;
+  int i;
+  HANDLE h[NUMTHREADS + 1];
+  unsigned thrAddr; /* Dummy variable to pass a valid location to _beginthreadex (Win98). */
+
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      threadbag[i].started = 0;
+      threadbag[i].threadnum = i;
+#if ! defined (__MINGW32__) || defined (__MSVCRT__)
+      h[i] = (HANDLE) _beginthreadex(NULL, 0, Win32thread, (void *) &threadbag[i], 0, &thrAddr);
+#else
+      h[i] = (HANDLE) _beginthread(Win32thread, 0, (void *) &threadbag[i]);
+#endif
+    }
+
+  /*
+   * Code to control or manipulate child threads should probably go here.
+   */
+  Sleep(500);
+
+  /*
+   * Give threads time to run.
+   */
+  Sleep(NUMTHREADS * 100);
+
+  /*
+   * Standard check that all threads started.
+   */
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      if (!threadbag[i].started)
+	{
+	  failed |= !threadbag[i].started;
+	  fprintf(stderr, "Thread %d: started %d\n", i, threadbag[i].started);
+	}
+    }
+
+  assert(!failed);
+
+  /*
+   * Check any results here. Set "failed" and only print output on failure.
+   */
+  failed = 0;
+  for (i = 1; i <= NUMTHREADS; i++)
+    {
+      int fail = 0;
+      int result = 0;
+
+#if ! defined (__MINGW32__) || defined (__MSVCRT__)
+      assert(GetExitCodeThread(h[i], (LPDWORD) &result) == TRUE);
+#else
+      /*
+       * Can't get a result code.
+       */
+      result = 1;
+#endif
+
+      assert(threadbag[i].self.p != NULL);
+      assert(pthread_kill(threadbag[i].self, 0) == ESRCH);
+
+      fail = (result != 1);
+
+      if (fail)
+	{
+	  fprintf(stderr, "Thread %d: started %d: count %d\n",
+		  i,
+		  threadbag[i].started,
+		  threadbag[i].count);
+	}
+      failed = (failed || fail);
+    }
+
+  assert(!failed);
+
+  /*
+   * Success.
+   */
+  return 0;
+}
+
diff --git a/src/include/pthread/tests/exit6.c b/src/include/pthread/tests/exit6.c
new file mode 100644
index 0000000..8a38463
--- /dev/null
+++ b/src/include/pthread/tests/exit6.c
@@ -0,0 +1,57 @@
+/*
+ * exit6.c
+ *
+ *  Created on: 14/05/2013
+ *      Author: ross
+ */
+
+#include "test.h"
+#ifndef _UWIN
+#include <process.h>
+#endif
+
+#include <pthread.h>
+//#include <stdlib.h>
+
+static pthread_key_t key;
+static int where;
+
+static unsigned __stdcall
+start_routine(void * arg)
+{
+  int *val = (int *) malloc(4);
+
+  where = 2;
+  //printf("start_routine: native thread\n");
+
+  *val = 48;
+  pthread_setspecific(key, val);
+  return 0;
+}
+
+static void
+key_dtor(void *arg)
+{
+  //printf("key_dtor: %d\n", *(int*)arg);
+  if (where == 2)
+    printf("Library has thread exit POSIX cleanup for native threads.\n");
+  else
+    printf("Library has process exit POSIX cleanup for native threads.\n");
+  free(arg);
+}
+
+int main(int argc, char **argv)
+{
+  HANDLE hthread;
+
+  where = 1;
+  pthread_key_create(&key, key_dtor);
+  hthread = (HANDLE)_beginthreadex(NULL, 0, start_routine, NULL, 0, NULL);
+  WaitForSingleObject(hthread, INFINITE);
+  CloseHandle(hthread);
+  where = 3;
+  pthread_key_delete(key);
+
+  //printf("main: exiting\n");
+  return 0;
+}
diff --git a/src/include/pthread/tests/eyal1.c b/src/include/pthread/tests/eyal1.c
new file mode 100644
index 0000000..e66fc57
--- /dev/null
+++ b/src/include/pthread/tests/eyal1.c
@@ -0,0 +1,362 @@
+/* Simple POSIX threads program.
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Author: Eyal Lebedinsky eyal@eyal.emu.id.au
+ * Written: Sep 1998.
+ * Version Date: 12 Sep 1998
+ *
+ * Do we need to lock stdout or is it thread safe?
+ *
+ * Used:
+ *	pthread_t
+ *	pthread_attr_t
+ *	pthread_create()
+ *	pthread_join()
+ *	pthread_mutex_t
+ *	PTHREAD_MUTEX_INITIALIZER
+ *	pthread_mutex_init() [not used now]
+ *	pthread_mutex_destroy()
+ *	pthread_mutex_lock()
+ *	pthread_mutex_trylock()
+ *	pthread_mutex_unlock()
+ *
+ * What this program does is establish a work queue (implemented using
+ * four mutexes for each thread). It then schedules work (by storing
+ * a number in 'todo') and releases the threads. When the work is done
+ * the threads will block. The program then repeats the same thing once
+ * more (just to test the logic) and when the work is done it destroyes
+ * the threads.
+ *
+ * The 'work' we do is simply burning CPU cycles in a loop.
+ * The 'todo' work queue is trivial - each threads pops one element
+ * off it by incrementing it, the poped number is the 'work' to do.
+ * When 'todo' reaches the limit (nwork) the queue is considered
+ * empty.
+ *
+ * The number displayed at the end is the amount of work each thread
+ * did, so we can see if the load was properly distributed.
+ *
+ * The program was written to test a threading setup (not seen here)
+ * rather than to demonstrate correct usage of the pthread facilities.
+ *
+ * Note how each thread is given access to a thread control structure
+ * (TC) which is used for communicating to/from the main program (e.g.
+ * the threads knows its 'id' and also filles in the 'work' done).
+*/
+
+#include "test.h"
+
+#include <stdlib.h>
+#include <math.h>
+
+struct thread_control {
+  int		id;
+  pthread_t	thread;		/* thread id */
+  pthread_mutex_t	mutex_start;
+  pthread_mutex_t	mutex_started;
+  pthread_mutex_t	mutex_end;
+  pthread_mutex_t	mutex_ended;
+  long		work;		/* work done */
+  int		stat;		/* pthread_init status */
+};
+
+typedef struct thread_control	TC;
+
+static TC		*tcs = NULL;
+static int		nthreads = 10;
+static int		nwork = 100;
+static int		quiet = 0;
+
+static int		todo = -1;
+
+static pthread_mutex_t	mutex_todo = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t	mutex_stdout = PTHREAD_MUTEX_INITIALIZER;
+
+
+static void
+die (int ret)
+{
+  if (NULL != tcs)
+    {
+      free (tcs);
+      tcs = NULL;
+    }
+
+  if (ret)
+    exit (ret);
+}
+
+
+static double
+waste_time (int n)
+{
+  int		i;
+  double	f, g, h, s;
+
+  s = 0.0;
+
+  /*
+   * Useless work.
+   */
+  for (i = n*100; i > 0; --i)
+    {
+      f = rand ();
+      g = rand ();
+      h = rand ();
+      s += 2.0 * f * g / (h != 0.0 ? (h * h) : 1.0);
+    }
+  return s;
+}
+
+static int
+do_work_unit (int who, int n)
+{
+  static int	nchars = 0;
+  double	f = 0.0;
+
+  if (!quiet) {
+    /*
+     * get lock on stdout
+     */
+    assert(pthread_mutex_lock (&mutex_stdout) == 0);
+
+    /*
+     * do our job
+     */
+    (void) printf ("%c", "0123456789abcdefghijklmnopqrstuvwxyz"[who]);
+
+    if (!(++nchars % 50))
+      printf ("\n");
+
+    fflush (stdout);
+
+    /*
+     * release lock on stdout
+     */
+    assert(pthread_mutex_unlock (&mutex_stdout) == 0);
+  }
+
+  n = rand () % 10000;	/* ignore incoming 'n' */
+  f = waste_time (n);
+
+  /* This prevents the statement above from being optimised out */
+  if (f > 0.0)
+    return(n);
+
+  return (n);
+}
+
+static int
+print_server (void *ptr)
+{
+  int		mywork;
+  int		n;
+  TC		*tc = (TC *)ptr;
+
+  assert(pthread_mutex_lock (&tc->mutex_started) == 0);
+
+  for (;;)
+    {
+      assert(pthread_mutex_lock (&tc->mutex_start) == 0);
+      assert(pthread_mutex_unlock (&tc->mutex_start) == 0);
+      assert(pthread_mutex_lock (&tc->mutex_ended) == 0);
+      assert(pthread_mutex_unlock (&tc->mutex_started) == 0);
+
+      for (;;)
+	{
+
+	  /*
+	   * get lock on todo list
+	   */
+	  assert(pthread_mutex_lock (&mutex_todo) == 0);
+
+	  mywork = todo;
+	  if (todo >= 0)
+	    {
+	      ++todo;
+	      if (todo >= nwork)
+		todo = -1;
+	    }
+	  assert(pthread_mutex_unlock (&mutex_todo) == 0);
+
+	  if (mywork < 0)
+	    break;
+
+	  assert((n = do_work_unit (tc->id, mywork)) >= 0);
+	  tc->work += n;
+	}
+
+      assert(pthread_mutex_lock (&tc->mutex_end) == 0);
+      assert(pthread_mutex_unlock (&tc->mutex_end) == 0);
+      assert(pthread_mutex_lock (&tc->mutex_started) == 0);
+      assert(pthread_mutex_unlock (&tc->mutex_ended) == 0);
+
+      if (-2 == mywork)
+	break;
+    }
+
+  assert(pthread_mutex_unlock (&tc->mutex_started) == 0);
+
+  return (0);
+}
+
+static void
+dosync (void)
+{
+  int		i;
+
+  for (i = 0; i < nthreads; ++i)
+    {
+      assert(pthread_mutex_lock (&tcs[i].mutex_end) == 0);
+      assert(pthread_mutex_unlock (&tcs[i].mutex_start) == 0);
+      assert(pthread_mutex_lock (&tcs[i].mutex_started) == 0);
+      assert(pthread_mutex_unlock (&tcs[i].mutex_started) == 0);
+    }
+
+  /*
+   * Now threads do their work
+   */
+  for (i = 0; i < nthreads; ++i)
+    {
+      assert(pthread_mutex_lock (&tcs[i].mutex_start) == 0);
+      assert(pthread_mutex_unlock (&tcs[i].mutex_end) == 0);
+      assert(pthread_mutex_lock (&tcs[i].mutex_ended) == 0);
+      assert(pthread_mutex_unlock (&tcs[i].mutex_ended) == 0);
+    }
+}
+
+static void
+dowork (void)
+{
+  todo = 0;
+  dosync();
+
+  todo = 0;
+  dosync();
+}
+
+int
+main (int argc, char *argv[])
+{
+  int		i;
+
+  assert(NULL != (tcs = (TC *) calloc (nthreads, sizeof (*tcs))));
+
+  /* 
+   * Launch threads
+   */
+  for (i = 0; i < nthreads; ++i)
+    {
+      tcs[i].id = i;
+
+      assert(pthread_mutex_init (&tcs[i].mutex_start, NULL) == 0);
+      assert(pthread_mutex_init (&tcs[i].mutex_started, NULL) == 0);
+      assert(pthread_mutex_init (&tcs[i].mutex_end, NULL) == 0);
+      assert(pthread_mutex_init (&tcs[i].mutex_ended, NULL) == 0);
+
+      tcs[i].work = 0;  
+
+      assert(pthread_mutex_lock (&tcs[i].mutex_start) == 0);
+      assert((tcs[i].stat = 
+	      pthread_create (&tcs[i].thread,
+			      NULL,
+                  (void *(*)(void *))print_server,
+                (void *) &tcs[i])
+	      ) == 0);
+
+      /* 
+       * Wait for thread initialisation
+       */
+      {
+	int trylock = 0;
+
+	while (trylock == 0)
+	  {
+	    trylock = pthread_mutex_trylock(&tcs[i].mutex_started);
+	    assert(trylock == 0 || trylock == EBUSY);
+
+	    if (trylock == 0)
+	      {
+		assert(pthread_mutex_unlock (&tcs[i].mutex_started) == 0);
+	      }
+	  }
+      }
+    }
+
+  dowork ();
+
+  /*
+   * Terminate threads
+   */
+  todo = -2;	/* please terminate */
+  dosync();
+
+  for (i = 0; i < nthreads; ++i)
+    {
+      if (0 == tcs[i].stat)
+	assert(pthread_join (tcs[i].thread, NULL) == 0);
+    }
+
+  /* 
+   * destroy locks
+   */
+  assert(pthread_mutex_destroy (&mutex_stdout) == 0);
+  assert(pthread_mutex_destroy (&mutex_todo) == 0);
+
+  /*
+   * Cleanup
+   */
+  printf ("\n");
+
+  /*
+   * Show results
+   */
+  for (i = 0; i < nthreads; ++i)
+    {
+      printf ("%2d ", i);
+      if (0 == tcs[i].stat)
+	printf ("%10ld\n", tcs[i].work);
+      else
+	printf ("failed %d\n", tcs[i].stat);
+
+      assert(pthread_mutex_unlock(&tcs[i].mutex_start) == 0);
+
+      assert(pthread_mutex_destroy (&tcs[i].mutex_start) == 0);
+      assert(pthread_mutex_destroy (&tcs[i].mutex_started) == 0);
+      assert(pthread_mutex_destroy (&tcs[i].mutex_end) == 0);
+      assert(pthread_mutex_destroy (&tcs[i].mutex_ended) == 0);
+    }
+
+  die (0);
+
+  return (0);
+}
diff --git a/src/include/pthread/tests/inherit1.c b/src/include/pthread/tests/inherit1.c
new file mode 100644
index 0000000..8fc0776
--- /dev/null
+++ b/src/include/pthread/tests/inherit1.c
@@ -0,0 +1,175 @@
+/*
+ * File: inherit1.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis:
+ * - Test thread priority inheritance.
+ *
+ * Test Method (Validation or Falsification):
+ * - 
+ *
+ * Requirements Tested:
+ * -
+ *
+ * Features Tested:
+ * -
+ *
+ * Cases Tested:
+ * -
+ *
+ * Description:
+ * -
+ *
+ * Environment:
+ * -
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * -
+ *
+ * Pass Criteria:
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - Process returns non-zero exit status.
+ */
+
+#include "test.h"
+
+enum {
+  PTW32TEST_THREAD_INIT_PRIO = 0,
+  PTW32TEST_MAXPRIORITIES = 512
+};
+
+int minPrio;
+int maxPrio;
+int validPriorities[PTW32TEST_MAXPRIORITIES];
+
+
+void * func(void * arg)
+{
+  int policy;
+  struct sched_param param;
+
+  assert(pthread_getschedparam(pthread_self(), &policy, &param) == 0);
+  return (void *) (size_t)param.sched_priority;
+}
+
+
+void *
+getValidPriorities(void * arg)
+{
+  int prioSet;
+  pthread_t thread = pthread_self();
+  HANDLE threadH = pthread_getw32threadhandle_np(thread);
+  struct sched_param param;
+
+  for (prioSet = minPrio;
+       prioSet <= maxPrio;
+       prioSet++)
+    {
+        /*
+       * If prioSet is invalid then the threads priority is unchanged
+       * from the previous value. Make the previous value a known
+       * one so that we can check later.
+       */
+        param.sched_priority = prioSet;
+        assert(pthread_setschedparam(thread, SCHED_OTHER, &param) == 0);
+        validPriorities[prioSet+(PTW32TEST_MAXPRIORITIES/2)] = GetThreadPriority(threadH);
+    }
+
+  return (void *) 0;
+}
+
+
+int
+main()
+{
+  pthread_t t;
+  pthread_t mainThread = pthread_self();
+  pthread_attr_t attr;
+  void * result = NULL;
+  struct sched_param param;
+  struct sched_param mainParam;
+  int prio;
+  int policy;
+  int inheritsched = -1;
+  pthread_t threadID = pthread_self();
+  HANDLE threadH = pthread_getw32threadhandle_np(threadID);
+
+  assert((maxPrio = sched_get_priority_max(SCHED_OTHER)) != -1);
+  assert((minPrio = sched_get_priority_min(SCHED_OTHER)) != -1);
+
+  assert(pthread_create(&t, NULL, getValidPriorities, NULL) == 0);
+  assert(pthread_join(t, &result) == 0);
+
+  assert(pthread_attr_init(&attr) == 0);
+  assert(pthread_attr_setinheritsched(&attr, PTHREAD_INHERIT_SCHED) == 0);
+  assert(pthread_attr_getinheritsched(&attr, &inheritsched) == 0);
+  assert(inheritsched == PTHREAD_INHERIT_SCHED);
+
+  for (prio = minPrio; prio <= maxPrio; prio++)
+    {
+      mainParam.sched_priority = prio;
+
+      /* Set the thread's priority to a known initial value. */
+      SetThreadPriority(threadH, PTW32TEST_THREAD_INIT_PRIO);
+
+      /* Change the main thread priority */
+      assert(pthread_setschedparam(mainThread, SCHED_OTHER, &mainParam) == 0);
+      assert(pthread_getschedparam(mainThread, &policy, &mainParam) == 0);
+      assert(policy == SCHED_OTHER);
+      /* Priority returned below should be the level set by pthread_setschedparam(). */
+      assert(mainParam.sched_priority == prio);
+      assert(GetThreadPriority(threadH) ==
+               validPriorities[prio+(PTW32TEST_MAXPRIORITIES/2)]);
+
+      for (param.sched_priority = prio;
+           param.sched_priority <= maxPrio;
+           param.sched_priority++)
+        {
+          /* The new thread create should ignore this new priority */
+          assert(pthread_attr_setschedparam(&attr, &param) == 0);
+          assert(pthread_create(&t, &attr, func, NULL) == 0);
+          pthread_join(t, &result);
+          assert((int)(size_t) result == mainParam.sched_priority);
+        }
+    }
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/join0.c b/src/include/pthread/tests/join0.c
new file mode 100644
index 0000000..d7ec9d8
--- /dev/null
+++ b/src/include/pthread/tests/join0.c
@@ -0,0 +1,65 @@
+/*
+ * Test for pthread_join().
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Depends on API functions: pthread_create(), pthread_exit().
+ */
+
+#include "test.h"
+
+void *
+func(void * arg)
+{
+  Sleep(2000);
+
+  pthread_exit(arg);
+
+  /* Never reached. */
+  exit(1);
+}
+
+int
+main(int argc, char * argv[])
+{
+  pthread_t id;
+  void* result = (void*)0;
+
+  /* Create a single thread and wait for it to exit. */
+  assert(pthread_create(&id, NULL, func, (void *) 123) == 0);
+
+  assert(pthread_join(id, &result) == 0);
+
+  assert((int)(size_t)result == 123);
+
+  /* Success. */
+  return 0;
+}
diff --git a/src/include/pthread/tests/join1.c b/src/include/pthread/tests/join1.c
new file mode 100644
index 0000000..a797417
--- /dev/null
+++ b/src/include/pthread/tests/join1.c
@@ -0,0 +1,76 @@
+/*
+ * Test for pthread_join().
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Depends on API functions: pthread_create(), pthread_join(), pthread_exit().
+ */
+
+#include "test.h"
+
+void *
+func(void * arg)
+{
+    int i = (int)(size_t)arg;
+
+    Sleep(i * 100);
+
+    pthread_exit(arg);
+
+    /* Never reached. */
+    exit(1);
+}
+
+int
+main(int argc, char * argv[])
+{
+	pthread_t id[4];
+	int i;
+	void* result = (void*)-1;
+
+	/* Create a few threads and then exit. */
+	for (i = 0; i < 4; i++)
+	  {
+	    assert(pthread_create(&id[i], NULL, func, (void *)(size_t)i) == 0);
+	  }
+
+	/* Some threads will finish before they are joined, some after. */
+	Sleep(2 * 100 + 50);
+
+	for (i = 0; i < 4; i++)
+	  {
+	    assert(pthread_join(id[i], &result) == 0);
+	    assert((int)(size_t)result == i);
+	  }
+
+	/* Success. */
+	return 0;
+}
diff --git a/src/include/pthread/tests/join2.c b/src/include/pthread/tests/join2.c
new file mode 100644
index 0000000..fe0b8ea
--- /dev/null
+++ b/src/include/pthread/tests/join2.c
@@ -0,0 +1,67 @@
+/*
+ * Test for pthread_join() returning return value from threads.
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Depends on API functions: pthread_create().
+ */
+
+#include "test.h"
+
+void *
+func(void * arg)
+{
+	Sleep(1000);
+	return arg;
+}
+
+int
+main(int argc, char * argv[])
+{
+	pthread_t id[4];
+	int i;
+	void* result = (void*)-1;
+
+	/* Create a few threads and then exit. */
+	for (i = 0; i < 4; i++)
+	  {
+	    assert(pthread_create(&id[i], NULL, func, (void *)(size_t)i) == 0);
+	  }
+
+	for (i = 0; i < 4; i++)
+	  {
+	    assert(pthread_join(id[i], &result) == 0);
+	    assert((int)(size_t)result == i);
+	  }
+
+	/* Success. */
+	return 0;
+}
diff --git a/src/include/pthread/tests/join3.c b/src/include/pthread/tests/join3.c
new file mode 100644
index 0000000..80dac31
--- /dev/null
+++ b/src/include/pthread/tests/join3.c
@@ -0,0 +1,73 @@
+/*
+ * Test for pthread_join() returning return value from threads.
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Depends on API functions: pthread_create().
+ */
+
+#include "test.h"
+
+void *
+func(void * arg)
+{
+	sched_yield();
+	return arg;
+}
+
+int
+main(int argc, char * argv[])
+{
+	pthread_t id[4];
+	int i;
+	void* result = (void*)-1;
+
+	/* Create a few threads and then exit. */
+	for (i = 0; i < 4; i++)
+	  {
+	    assert(pthread_create(&id[i], NULL, func, (void *)(size_t)i) == 0);
+	  }
+
+	/*
+	 * Let threads exit before we join them.
+	 * We should still retrieve the exit code for the threads.
+	 */
+	Sleep(1000);
+
+	for (i = 0; i < 4; i++)
+	  {
+	    assert(pthread_join(id[i], &result) == 0);
+	    assert((int)(size_t)result == i);
+	  }
+
+	/* Success. */
+	return 0;
+}
diff --git a/src/include/pthread/tests/join4.c b/src/include/pthread/tests/join4.c
new file mode 100644
index 0000000..62ed56e
--- /dev/null
+++ b/src/include/pthread/tests/join4.c
@@ -0,0 +1,78 @@
+/*
+ * Test for pthread_timedjoin_np() timing out.
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Depends on API functions: pthread_create().
+ */
+
+#include "test.h"
+
+void *
+func(void * arg)
+{
+        Sleep(1200);
+        return arg;
+}
+
+int
+main(int argc, char * argv[])
+{
+        pthread_t id;
+        struct timespec abstime, reltime = { 1, 0 };
+        void* result = (void*)-1;
+
+        assert(pthread_create(&id, NULL, func, (void *)(size_t)999) == 0);
+
+        /*
+         * Let thread start before we attempt to join it.
+         */
+        Sleep(100);
+
+        (void) pthread_win32_getabstime_np(&abstime, &reltime);
+
+        /* Test for pthread_timedjoin_np timeout */
+        assert(pthread_timedjoin_np(id, &result, &abstime) == ETIMEDOUT);
+        assert((int)(size_t)result == -1);
+
+        /* Test for pthread_tryjoin_np behaviour before thread has exited */
+        assert(pthread_tryjoin_np(id, &result) == EBUSY);
+        assert((int)(size_t)result == -1);
+
+        Sleep(500);
+
+        /* Test for pthread_tryjoin_np behaviour after thread has exited */
+        assert(pthread_tryjoin_np(id, &result) == 0);
+        assert((int)(size_t)result == 999);
+
+        /* Success. */
+        return 0;
+}
diff --git a/src/include/pthread/tests/kill1.c b/src/include/pthread/tests/kill1.c
new file mode 100644
index 0000000..2cb3266
--- /dev/null
+++ b/src/include/pthread/tests/kill1.c
@@ -0,0 +1,81 @@
+/*
+ * File: kill1.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis:
+ * - pthread_kill() does not support non zero signals..
+ *
+ * Test Method (Validation or Falsification):
+ * -
+ *
+ * Requirements Tested:
+ * -
+ *
+ * Features Tested:
+ * -
+ *
+ * Cases Tested:
+ * -
+ *
+ * Description:
+ * -
+ *
+ * Environment:
+ * -
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * -
+ *
+ * Pass Criteria:
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - Process returns non-zero exit status.
+ */
+
+#include "test.h"
+
+
+int
+main()
+{
+  assert(pthread_kill(pthread_self(), 1) == EINVAL);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/mutex1.c b/src/include/pthread/tests/mutex1.c
new file mode 100644
index 0000000..4b28d6d
--- /dev/null
+++ b/src/include/pthread/tests/mutex1.c
@@ -0,0 +1,66 @@
+/* 
+ * mutex1.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Create a simple mutex object, lock it, and then unlock it again.
+ * This is the simplest test of the pthread mutex family that we can do.
+ *
+ * Depends on API functions:
+ * 	pthread_mutex_init()
+ *	pthread_mutex_lock()
+ *	pthread_mutex_unlock()
+ *	pthread_mutex_destroy()
+ */
+
+#include "test.h"
+
+pthread_mutex_t mutex = NULL;
+
+int
+main()
+{
+  assert(mutex == NULL);
+
+  assert(pthread_mutex_init(&mutex, NULL) == 0);
+
+  assert(mutex != NULL);
+
+  assert(pthread_mutex_lock(&mutex) == 0);
+
+  assert(pthread_mutex_unlock(&mutex) == 0);
+
+  assert(pthread_mutex_destroy(&mutex) == 0);
+
+  assert(mutex == NULL);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/mutex1e.c b/src/include/pthread/tests/mutex1e.c
new file mode 100644
index 0000000..4e7c30f
--- /dev/null
+++ b/src/include/pthread/tests/mutex1e.c
@@ -0,0 +1,76 @@
+/* 
+ * mutex1e.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * As for mutex1.c but with type set to PTHREAD_MUTEX_ERRORCHECK.
+ *
+ * Create a simple mutex object, lock it, unlock it, then destroy it.
+ * This is the simplest test of the pthread mutex family that we can do.
+ *
+ * Depends on API functions:
+ *	pthread_mutexattr_settype()
+ * 	pthread_mutex_init()
+ *	pthread_mutex_destroy()
+ */
+
+#include "test.h"
+
+pthread_mutex_t mutex = NULL;
+pthread_mutexattr_t mxAttr;
+
+int
+main()
+{
+  assert(pthread_mutexattr_init(&mxAttr) == 0);
+
+  BEGIN_MUTEX_STALLED_ROBUST(mxAttr)
+
+  assert(pthread_mutexattr_settype(&mxAttr, PTHREAD_MUTEX_ERRORCHECK) == 0);
+
+  assert(mutex == NULL);
+
+  assert(pthread_mutex_init(&mutex, &mxAttr) == 0);
+
+  assert(mutex != NULL);
+
+  assert(pthread_mutex_lock(&mutex) == 0);
+
+  assert(pthread_mutex_unlock(&mutex) == 0);
+
+  assert(pthread_mutex_destroy(&mutex) == 0);
+
+  assert(mutex == NULL);
+
+  END_MUTEX_STALLED_ROBUST(mxAttr)
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/mutex1n.c b/src/include/pthread/tests/mutex1n.c
new file mode 100644
index 0000000..03caf1e
--- /dev/null
+++ b/src/include/pthread/tests/mutex1n.c
@@ -0,0 +1,76 @@
+/* 
+ * mutex1n.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * As for mutex1.c but with type set to PTHREAD_MUTEX_NORMAL.
+ *
+ * Create a simple mutex object, lock it, unlock it, then destroy it.
+ * This is the simplest test of the pthread mutex family that we can do.
+ *
+ * Depends on API functions:
+ *	pthread_mutexattr_settype()
+ * 	pthread_mutex_init()
+ *	pthread_mutex_destroy()
+ */
+
+#include "test.h"
+
+pthread_mutex_t mutex = NULL;
+pthread_mutexattr_t mxAttr;
+
+int
+main()
+{
+  assert(pthread_mutexattr_init(&mxAttr) == 0);
+
+  BEGIN_MUTEX_STALLED_ROBUST(mxAttr)
+
+  assert(pthread_mutexattr_settype(&mxAttr, PTHREAD_MUTEX_NORMAL) == 0);
+
+  assert(mutex == NULL);
+
+  assert(pthread_mutex_init(&mutex, &mxAttr) == 0);
+
+  assert(mutex != NULL);
+
+  assert(pthread_mutex_lock(&mutex) == 0);
+
+  assert(pthread_mutex_unlock(&mutex) == 0);
+
+  assert(pthread_mutex_destroy(&mutex) == 0);
+
+  assert(mutex == NULL);
+
+  END_MUTEX_STALLED_ROBUST(mxAttr)
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/mutex1r.c b/src/include/pthread/tests/mutex1r.c
new file mode 100644
index 0000000..2241608
--- /dev/null
+++ b/src/include/pthread/tests/mutex1r.c
@@ -0,0 +1,76 @@
+/* 
+ * mutex1r.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * As for mutex1.c but with type set to PTHREAD_MUTEX_RECURSIVE.
+ *
+ * Create a simple mutex object, lock it, unlock it, then destroy it.
+ * This is the simplest test of the pthread mutex family that we can do.
+ *
+ * Depends on API functions:
+ *	pthread_mutexattr_settype()
+ * 	pthread_mutex_init()
+ *	pthread_mutex_destroy()
+ */
+
+#include "test.h"
+
+pthread_mutex_t mutex = NULL;
+pthread_mutexattr_t mxAttr;
+
+int
+main()
+{
+  assert(pthread_mutexattr_init(&mxAttr) == 0);
+
+  BEGIN_MUTEX_STALLED_ROBUST(mxAttr)
+
+  assert(pthread_mutexattr_settype(&mxAttr, PTHREAD_MUTEX_RECURSIVE) == 0);
+
+  assert(mutex == NULL);
+
+  assert(pthread_mutex_init(&mutex, &mxAttr) == 0);
+
+  assert(mutex != NULL);
+
+  assert(pthread_mutex_lock(&mutex) == 0);
+
+  assert(pthread_mutex_unlock(&mutex) == 0);
+
+  assert(pthread_mutex_destroy(&mutex) == 0);
+
+  assert(mutex == NULL);
+
+  END_MUTEX_STALLED_ROBUST(mxAttr)
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/mutex2.c b/src/include/pthread/tests/mutex2.c
new file mode 100644
index 0000000..4a33243
--- /dev/null
+++ b/src/include/pthread/tests/mutex2.c
@@ -0,0 +1,64 @@
+/* 
+ * mutex2.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Declare a static mutex object, lock it, 
+ * and then unlock it again.
+ *
+ * Depends on API functions: 
+ *	pthread_mutex_lock()
+ *	pthread_mutex_unlock()
+ */
+
+#include "test.h"
+ 
+pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
+
+int
+main()
+{
+  assert(mutex == PTHREAD_MUTEX_INITIALIZER);
+
+  assert(pthread_mutex_lock(&mutex) == 0);
+
+  assert(mutex != PTHREAD_MUTEX_INITIALIZER);
+
+  assert(mutex != NULL);
+
+  assert(pthread_mutex_unlock(&mutex) == 0);
+
+  assert(pthread_mutex_destroy(&mutex) == 0);
+
+  assert(mutex == NULL);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/mutex2e.c b/src/include/pthread/tests/mutex2e.c
new file mode 100644
index 0000000..8748f49
--- /dev/null
+++ b/src/include/pthread/tests/mutex2e.c
@@ -0,0 +1,64 @@
+/* 
+ * mutex2e.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Declare a static mutex object, lock it, 
+ * and then unlock it again.
+ *
+ * Depends on API functions: 
+ *	pthread_mutex_lock()
+ *	pthread_mutex_unlock()
+ */
+
+#include "test.h"
+ 
+pthread_mutex_t mutex = PTHREAD_ERRORCHECK_MUTEX_INITIALIZER;
+
+int
+main()
+{
+  assert(mutex == PTHREAD_ERRORCHECK_MUTEX_INITIALIZER);
+
+  assert(pthread_mutex_lock(&mutex) == 0);
+
+  assert(mutex != PTHREAD_ERRORCHECK_MUTEX_INITIALIZER);
+
+  assert(mutex != NULL);
+
+  assert(pthread_mutex_unlock(&mutex) == 0);
+
+  assert(pthread_mutex_destroy(&mutex) == 0);
+
+  assert(mutex == NULL);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/mutex2r.c b/src/include/pthread/tests/mutex2r.c
new file mode 100644
index 0000000..6363045
--- /dev/null
+++ b/src/include/pthread/tests/mutex2r.c
@@ -0,0 +1,64 @@
+/* 
+ * mutex2r.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Declare a static mutex object, lock it, 
+ * and then unlock it again.
+ *
+ * Depends on API functions: 
+ *	pthread_mutex_lock()
+ *	pthread_mutex_unlock()
+ */
+
+#include "test.h"
+ 
+pthread_mutex_t mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER;
+
+int
+main()
+{
+  assert(mutex == PTHREAD_RECURSIVE_MUTEX_INITIALIZER);
+
+  assert(pthread_mutex_lock(&mutex) == 0);
+
+  assert(mutex != PTHREAD_RECURSIVE_MUTEX_INITIALIZER);
+
+  assert(mutex != NULL);
+
+  assert(pthread_mutex_unlock(&mutex) == 0);
+
+  assert(pthread_mutex_destroy(&mutex) == 0);
+
+  assert(mutex == NULL);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/mutex3.c b/src/include/pthread/tests/mutex3.c
new file mode 100644
index 0000000..40ee266
--- /dev/null
+++ b/src/include/pthread/tests/mutex3.c
@@ -0,0 +1,73 @@
+/* 
+ * mutex3.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Declare a static mutex object, lock it, trylock it, 
+ * and then unlock it again.
+ *
+ * Depends on API functions: 
+ *	pthread_mutex_lock()
+ *	pthread_mutex_trylock()
+ *	pthread_mutex_unlock()
+ */
+
+#include "test.h"
+ 
+pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
+
+static int washere = 0;
+
+void * func(void * arg)
+{
+  assert(pthread_mutex_trylock(&mutex1) == EBUSY);
+
+  washere = 1;
+
+  return 0; 
+}
+ 
+int
+main()
+{
+  pthread_t t;
+
+  assert(pthread_mutex_lock(&mutex1) == 0);
+
+  assert(pthread_create(&t, NULL, func, NULL) == 0);
+  assert(pthread_join(t, NULL) == 0);
+
+  assert(pthread_mutex_unlock(&mutex1) == 0);
+
+  assert(washere == 1);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/mutex3e.c b/src/include/pthread/tests/mutex3e.c
new file mode 100644
index 0000000..27e9ab7
--- /dev/null
+++ b/src/include/pthread/tests/mutex3e.c
@@ -0,0 +1,73 @@
+/* 
+ * mutex3e.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Declare a static mutex object, lock it, trylock it, 
+ * and then unlock it again.
+ *
+ * Depends on API functions: 
+ *	pthread_mutex_lock()
+ *	pthread_mutex_trylock()
+ *	pthread_mutex_unlock()
+ */
+
+#include "test.h"
+ 
+pthread_mutex_t mutex1 = PTHREAD_ERRORCHECK_MUTEX_INITIALIZER;
+
+static int washere = 0;
+
+void * func(void * arg)
+{
+  assert(pthread_mutex_trylock(&mutex1) == EBUSY);
+
+  washere = 1;
+
+  return 0; 
+}
+ 
+int
+main()
+{
+  pthread_t t;
+
+  assert(pthread_mutex_lock(&mutex1) == 0);
+
+  assert(pthread_create(&t, NULL, func, NULL) == 0);
+  assert(pthread_join(t, NULL) == 0);
+
+  assert(pthread_mutex_unlock(&mutex1) == 0);
+
+  assert(washere == 1);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/mutex3r.c b/src/include/pthread/tests/mutex3r.c
new file mode 100644
index 0000000..c2946f2
--- /dev/null
+++ b/src/include/pthread/tests/mutex3r.c
@@ -0,0 +1,73 @@
+/* 
+ * mutex3r.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Declare a static mutex object, lock it, trylock it, 
+ * and then unlock it again.
+ *
+ * Depends on API functions: 
+ *	pthread_mutex_lock()
+ *	pthread_mutex_trylock()
+ *	pthread_mutex_unlock()
+ */
+
+#include "test.h"
+ 
+pthread_mutex_t mutex1 = PTHREAD_RECURSIVE_MUTEX_INITIALIZER;
+
+static int washere = 0;
+
+void * func(void * arg)
+{
+  assert(pthread_mutex_trylock(&mutex1) == EBUSY);
+
+  washere = 1;
+
+  return 0; 
+}
+ 
+int
+main()
+{
+  pthread_t t;
+
+  assert(pthread_mutex_lock(&mutex1) == 0);
+
+  assert(pthread_create(&t, NULL, func, NULL) == 0);
+  assert(pthread_join(t, NULL) == 0);
+
+  assert(pthread_mutex_unlock(&mutex1) == 0);
+
+  assert(washere == 1);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/mutex4.c b/src/include/pthread/tests/mutex4.c
new file mode 100644
index 0000000..b09969e
--- /dev/null
+++ b/src/include/pthread/tests/mutex4.c
@@ -0,0 +1,107 @@
+/* 
+ * mutex4.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Thread A locks mutex - thread B tries to unlock.
+ *
+ * Depends on API functions: 
+ *	pthread_mutex_lock()
+ *	pthread_mutex_trylock()
+ *	pthread_mutex_unlock()
+ */
+
+#include "test.h"
+
+static int wasHere = 0;
+
+static pthread_mutex_t mutex1;
+ 
+void * unlocker(void * arg)
+{
+  int expectedResult = (int)(size_t)arg;
+
+  wasHere++;
+  assert(pthread_mutex_unlock(&mutex1) == expectedResult);
+  wasHere++;
+  return NULL;
+}
+ 
+int
+main()
+{
+  pthread_t t;
+  pthread_mutexattr_t ma;
+
+  assert(pthread_mutexattr_init(&ma) == 0);
+
+  BEGIN_MUTEX_STALLED_ROBUST(ma)
+
+  wasHere = 0;
+  assert(pthread_mutexattr_settype(&ma, PTHREAD_MUTEX_DEFAULT) == 0);
+  assert(pthread_mutex_init(&mutex1, &ma) == 0);
+  assert(pthread_mutex_lock(&mutex1) == 0);
+  assert(pthread_create(&t, NULL, unlocker, (void *)(size_t)(IS_ROBUST?EPERM:0)) == 0);
+  assert(pthread_join(t, NULL) == 0);
+  assert(pthread_mutex_unlock(&mutex1) == 0);
+  assert(wasHere == 2);
+
+  wasHere = 0;
+  assert(pthread_mutexattr_settype(&ma, PTHREAD_MUTEX_NORMAL) == 0);
+  assert(pthread_mutex_init(&mutex1, &ma) == 0);
+  assert(pthread_mutex_lock(&mutex1) == 0);
+  assert(pthread_create(&t, NULL, unlocker, (void *)(size_t)(IS_ROBUST?EPERM:0)) == 0);
+  assert(pthread_join(t, NULL) == 0);
+  assert(pthread_mutex_unlock(&mutex1) == 0);
+  assert(wasHere == 2);
+
+  wasHere = 0;
+  assert(pthread_mutexattr_settype(&ma, PTHREAD_MUTEX_ERRORCHECK) == 0);
+  assert(pthread_mutex_init(&mutex1, &ma) == 0);
+  assert(pthread_mutex_lock(&mutex1) == 0);
+  assert(pthread_create(&t, NULL, unlocker, (void *)(size_t) EPERM) == 0);
+  assert(pthread_join(t, NULL) == 0);
+  assert(pthread_mutex_unlock(&mutex1) == 0);
+  assert(wasHere == 2);
+
+  wasHere = 0;
+  assert(pthread_mutexattr_settype(&ma, PTHREAD_MUTEX_RECURSIVE) == 0);
+  assert(pthread_mutex_init(&mutex1, &ma) == 0);
+  assert(pthread_mutex_lock(&mutex1) == 0);
+  assert(pthread_create(&t, NULL, unlocker, (void *)(size_t) EPERM) == 0);
+  assert(pthread_join(t, NULL) == 0);
+  assert(pthread_mutex_unlock(&mutex1) == 0);
+  assert(wasHere == 2);
+
+  END_MUTEX_STALLED_ROBUST(ma)
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/mutex5.c b/src/include/pthread/tests/mutex5.c
new file mode 100644
index 0000000..636adbf
--- /dev/null
+++ b/src/include/pthread/tests/mutex5.c
@@ -0,0 +1,65 @@
+/* 
+ * mutex5.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Confirm the equality/inequality of the various mutex types,
+ * and the default not-set value.
+ */
+
+#include "test.h"
+
+static pthread_mutexattr_t mxAttr;
+
+/* Prevent optimiser from removing dead or obvious asserts. */
+int _optimiseFoil;
+#define FOIL(x) (_optimiseFoil = x)
+
+int
+main()
+{
+  int mxType = -1;
+
+  assert(FOIL(PTHREAD_MUTEX_DEFAULT) == PTHREAD_MUTEX_NORMAL);
+  assert(FOIL(PTHREAD_MUTEX_DEFAULT) != PTHREAD_MUTEX_ERRORCHECK);
+  assert(FOIL(PTHREAD_MUTEX_DEFAULT) != PTHREAD_MUTEX_RECURSIVE);
+  assert(FOIL(PTHREAD_MUTEX_RECURSIVE) != PTHREAD_MUTEX_ERRORCHECK);
+
+  assert(FOIL(PTHREAD_MUTEX_NORMAL) == PTHREAD_MUTEX_FAST_NP);
+  assert(FOIL(PTHREAD_MUTEX_RECURSIVE) == PTHREAD_MUTEX_RECURSIVE_NP);
+  assert(FOIL(PTHREAD_MUTEX_ERRORCHECK) == PTHREAD_MUTEX_ERRORCHECK_NP);
+
+  assert(pthread_mutexattr_init(&mxAttr) == 0);
+  assert(pthread_mutexattr_gettype(&mxAttr, &mxType) == 0);
+  assert(mxType == PTHREAD_MUTEX_NORMAL);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/mutex6.c b/src/include/pthread/tests/mutex6.c
new file mode 100644
index 0000000..b42ed7d
--- /dev/null
+++ b/src/include/pthread/tests/mutex6.c
@@ -0,0 +1,94 @@
+/* 
+ * mutex6.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test the default (type not set) mutex type.
+ * Should be the same as PTHREAD_MUTEX_NORMAL.
+ * Thread locks mutex twice (recursive lock).
+ * Locking thread should deadlock on second attempt.
+ *
+ * Depends on API functions: 
+ *	pthread_mutex_lock()
+ *	pthread_mutex_trylock()
+ *	pthread_mutex_unlock()
+ */
+
+#include "test.h"
+
+static int lockCount = 0;
+
+static pthread_mutex_t mutex;
+
+void * locker(void * arg)
+{
+  assert(pthread_mutex_lock(&mutex) == 0);
+  lockCount++;
+
+  /* Should wait here (deadlocked) */
+  assert(pthread_mutex_lock(&mutex) == 0);
+  lockCount++;
+  assert(pthread_mutex_unlock(&mutex) == 0);
+
+  return 0;
+}
+ 
+int
+main()
+{
+  pthread_t t;
+
+  assert(pthread_mutex_init(&mutex, NULL) == 0);
+
+  assert(pthread_create(&t, NULL, locker, NULL) == 0);
+
+  while (lockCount < 1)
+    {
+      Sleep(1);
+    }
+
+  assert(lockCount == 1);
+
+  /*
+   * Should succeed even though we don't own the lock
+   * because FAST mutexes don't check ownership.
+   */
+  assert(pthread_mutex_unlock(&mutex) == 0);
+
+  while (lockCount < 2)
+    {
+      Sleep(1);
+    }
+
+  assert(lockCount == 2);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/mutex6e.c b/src/include/pthread/tests/mutex6e.c
new file mode 100644
index 0000000..7c2f5a7
--- /dev/null
+++ b/src/include/pthread/tests/mutex6e.c
@@ -0,0 +1,104 @@
+/* 
+ * mutex6e.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Tests PTHREAD_MUTEX_ERRORCHECK mutex type.
+ * Thread locks mutex twice (recursive lock).
+ * This should fail with an EDEADLK error.
+ * The second unlock attempt should fail with an EPERM error.
+ *
+ * Depends on API functions: 
+ *      pthread_create()
+ *      pthread_join()
+ *      pthread_mutexattr_init()
+ *      pthread_mutexattr_destroy()
+ *      pthread_mutexattr_settype()
+ *      pthread_mutexattr_gettype()
+ *      pthread_mutex_init()
+ *      pthread_mutex_destroy()
+ *	pthread_mutex_lock()
+ *	pthread_mutex_unlock()
+ */
+
+#include "test.h"
+
+static int lockCount;
+
+static pthread_mutex_t mutex;
+static pthread_mutexattr_t mxAttr;
+
+void * locker(void * arg)
+{
+  assert(pthread_mutex_lock(&mutex) == 0);
+  lockCount++;
+  assert(pthread_mutex_lock(&mutex) == EDEADLK);
+  lockCount++;
+  assert(pthread_mutex_unlock(&mutex) == 0);
+  assert(pthread_mutex_unlock(&mutex) == EPERM);
+
+  return (void *) 555;
+}
+ 
+int
+main()
+{
+  pthread_t t;
+  void* result = (void*)0;
+  int mxType = -1;
+
+  assert(pthread_mutexattr_init(&mxAttr) == 0);
+
+  BEGIN_MUTEX_STALLED_ROBUST(mxAttr)
+
+  lockCount = 0;
+  assert(pthread_mutexattr_settype(&mxAttr, PTHREAD_MUTEX_ERRORCHECK) == 0);
+  assert(pthread_mutexattr_gettype(&mxAttr, &mxType) == 0);
+  assert(mxType == PTHREAD_MUTEX_ERRORCHECK);
+
+  assert(pthread_mutex_init(&mutex, &mxAttr) == 0);
+
+  assert(pthread_create(&t, NULL, locker, NULL) == 0);
+
+  assert(pthread_join(t, &result) == 0);
+  assert((int)(size_t)result == 555);
+
+  assert(lockCount == 2);
+
+  assert(pthread_mutex_destroy(&mutex) == 0);
+
+  END_MUTEX_STALLED_ROBUST(mxAttr)
+
+  assert(pthread_mutexattr_destroy(&mxAttr) == 0);
+
+  return 0;
+}
+
diff --git a/src/include/pthread/tests/mutex6es.c b/src/include/pthread/tests/mutex6es.c
new file mode 100644
index 0000000..e405938
--- /dev/null
+++ b/src/include/pthread/tests/mutex6es.c
@@ -0,0 +1,89 @@
+/* 
+ * mutex6es.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Tests PTHREAD_MUTEX_ERRORCHECK static mutex type.
+ * Thread locks mutex twice (recursive lock).
+ * This should fail with an EDEADLK error.
+ * The second unlock attempt should fail with an EPERM error.
+ *
+ * Depends on API functions: 
+ *      pthread_create()
+ *      pthread_join()
+ *      pthread_mutexattr_init()
+ *      pthread_mutexattr_destroy()
+ *      pthread_mutexattr_settype()
+ *      pthread_mutexattr_gettype()
+ *      pthread_mutex_init()
+ *      pthread_mutex_destroy()
+ *	pthread_mutex_lock()
+ *	pthread_mutex_unlock()
+ */
+
+#include "test.h"
+
+static int lockCount = 0;
+
+static pthread_mutex_t mutex = PTHREAD_ERRORCHECK_MUTEX_INITIALIZER;
+
+void * locker(void * arg)
+{
+  assert(pthread_mutex_lock(&mutex) == 0);
+  lockCount++;
+  assert(pthread_mutex_lock(&mutex) == EDEADLK);
+  lockCount++;
+  assert(pthread_mutex_unlock(&mutex) == 0);
+  assert(pthread_mutex_unlock(&mutex) == EPERM);
+
+  return (void *) 555;
+}
+ 
+int
+main()
+{
+  pthread_t t;
+  void* result = (void*)0;
+
+  assert(mutex == PTHREAD_ERRORCHECK_MUTEX_INITIALIZER);
+
+  assert(pthread_create(&t, NULL, locker, NULL) == 0);
+
+  assert(pthread_join(t, &result) == 0);
+  assert((int)(size_t)result == 555);
+
+  assert(lockCount == 2);
+
+  assert(pthread_mutex_destroy(&mutex) == 0);
+
+  return 0;
+}
+
diff --git a/src/include/pthread/tests/mutex6n.c b/src/include/pthread/tests/mutex6n.c
new file mode 100644
index 0000000..6d59989
--- /dev/null
+++ b/src/include/pthread/tests/mutex6n.c
@@ -0,0 +1,108 @@
+/* 
+ * mutex6n.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Tests PTHREAD_MUTEX_NORMAL mutex type.
+ * Thread locks mutex twice (recursive lock).
+ * The thread should deadlock.
+ *
+ * Depends on API functions: 
+ *      pthread_create()
+ *      pthread_mutexattr_init()
+ *      pthread_mutexattr_settype()
+ *      pthread_mutexattr_gettype()
+ *      pthread_mutex_init()
+ *	pthread_mutex_lock()
+ *	pthread_mutex_unlock()
+ */
+
+#include "test.h"
+
+static int lockCount;
+
+static pthread_mutex_t mutex;
+static pthread_mutexattr_t mxAttr;
+
+void * locker(void * arg)
+{
+  assert(pthread_mutex_lock(&mutex) == 0);
+  lockCount++;
+
+  /* Should wait here (deadlocked) */
+  assert(pthread_mutex_lock(&mutex) == 0);
+
+  lockCount++;
+  assert(pthread_mutex_unlock(&mutex) == 0);
+
+  return (void *) 555;
+}
+ 
+int
+main()
+{
+  pthread_t t;
+  int mxType = -1;
+
+  assert(pthread_mutexattr_init(&mxAttr) == 0);
+
+  BEGIN_MUTEX_STALLED_ROBUST(mxAttr)
+
+  lockCount = 0;
+  assert(pthread_mutexattr_settype(&mxAttr, PTHREAD_MUTEX_NORMAL) == 0);
+  assert(pthread_mutexattr_gettype(&mxAttr, &mxType) == 0);
+  assert(mxType == PTHREAD_MUTEX_NORMAL);
+
+  assert(pthread_mutex_init(&mutex, &mxAttr) == 0);
+
+  assert(pthread_create(&t, NULL, locker, NULL) == 0);
+
+  while (lockCount < 1)
+    {
+      Sleep(1);
+    }
+
+  assert(lockCount == 1);
+
+  assert(pthread_mutex_unlock(&mutex) == (IS_ROBUST?EPERM:0));
+
+  while (lockCount < (IS_ROBUST?1:2))
+    {
+      Sleep(1);
+    }
+
+  assert(lockCount == (IS_ROBUST?1:2));
+
+  END_MUTEX_STALLED_ROBUST(mxAttr)
+
+  return 0;
+}
+
diff --git a/src/include/pthread/tests/mutex6r.c b/src/include/pthread/tests/mutex6r.c
new file mode 100644
index 0000000..65827ff
--- /dev/null
+++ b/src/include/pthread/tests/mutex6r.c
@@ -0,0 +1,102 @@
+/* 
+ * mutex6r.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Tests PTHREAD_MUTEX_RECURSIVE mutex type.
+ * Thread locks mutex twice (recursive lock).
+ * Both locks and unlocks should succeed.
+ *
+ * Depends on API functions: 
+ *      pthread_create()
+ *      pthread_join()
+ *      pthread_mutexattr_init()
+ *      pthread_mutexattr_destroy()
+ *      pthread_mutexattr_settype()
+ *      pthread_mutexattr_gettype()
+ *      pthread_mutex_init()
+ *      pthread_mutex_destroy()
+ *	pthread_mutex_lock()
+ *	pthread_mutex_unlock()
+ */
+
+#include "test.h"
+
+static int lockCount;
+
+static pthread_mutex_t mutex;
+static pthread_mutexattr_t mxAttr;
+
+void * locker(void * arg)
+{
+  assert(pthread_mutex_lock(&mutex) == 0);
+  lockCount++;
+  assert(pthread_mutex_lock(&mutex) == 0);
+  lockCount++;
+  assert(pthread_mutex_unlock(&mutex) == 0);
+  assert(pthread_mutex_unlock(&mutex) == 0);
+
+  return (void *) 555;
+}
+ 
+int
+main()
+{
+  pthread_t t;
+  void* result = (void*)0;
+  int mxType = -1;
+
+  assert(pthread_mutexattr_init(&mxAttr) == 0);
+
+  BEGIN_MUTEX_STALLED_ROBUST(mxAttr)
+
+  lockCount = 0;
+  assert(pthread_mutexattr_settype(&mxAttr, PTHREAD_MUTEX_RECURSIVE) == 0);
+  assert(pthread_mutexattr_gettype(&mxAttr, &mxType) == 0);
+  assert(mxType == PTHREAD_MUTEX_RECURSIVE);
+
+  assert(pthread_mutex_init(&mutex, &mxAttr) == 0);
+
+  assert(pthread_create(&t, NULL, locker, NULL) == 0);
+
+  assert(pthread_join(t, &result) == 0);
+  assert((int)(size_t)result == 555);
+
+  assert(lockCount == 2);
+
+  assert(pthread_mutex_destroy(&mutex) == 0);
+
+  END_MUTEX_STALLED_ROBUST(mxAttr)
+
+  assert(pthread_mutexattr_destroy(&mxAttr) == 0);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/mutex6rs.c b/src/include/pthread/tests/mutex6rs.c
new file mode 100644
index 0000000..c38b009
--- /dev/null
+++ b/src/include/pthread/tests/mutex6rs.c
@@ -0,0 +1,87 @@
+/* 
+ * mutex6rs.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Tests PTHREAD_MUTEX_RECURSIVE static mutex type.
+ * Thread locks mutex twice (recursive lock).
+ * Both locks and unlocks should succeed.
+ *
+ * Depends on API functions: 
+ *      pthread_create()
+ *      pthread_join()
+ *      pthread_mutexattr_init()
+ *      pthread_mutexattr_destroy()
+ *      pthread_mutexattr_settype()
+ *      pthread_mutexattr_gettype()
+ *      pthread_mutex_init()
+ *      pthread_mutex_destroy()
+ *	pthread_mutex_lock()
+ *	pthread_mutex_unlock()
+ */
+
+#include "test.h"
+
+static int lockCount = 0;
+
+static pthread_mutex_t mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER;
+
+void * locker(void * arg)
+{
+  assert(pthread_mutex_lock(&mutex) == 0);
+  lockCount++;
+  assert(pthread_mutex_lock(&mutex) == 0);
+  lockCount++;
+  assert(pthread_mutex_unlock(&mutex) == 0);
+  assert(pthread_mutex_unlock(&mutex) == 0);
+
+  return (void *) 555;
+}
+ 
+int
+main()
+{
+  pthread_t t;
+  void* result = (void*)0;
+
+  assert(mutex == PTHREAD_RECURSIVE_MUTEX_INITIALIZER);
+
+  assert(pthread_create(&t, NULL, locker, NULL) == 0);
+
+  assert(pthread_join(t, &result) == 0);
+  assert((int)(size_t)result == 555);
+
+  assert(lockCount == 2);
+
+  assert(pthread_mutex_destroy(&mutex) == 0);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/mutex6s.c b/src/include/pthread/tests/mutex6s.c
new file mode 100644
index 0000000..44638f2
--- /dev/null
+++ b/src/include/pthread/tests/mutex6s.c
@@ -0,0 +1,94 @@
+/* 
+ * mutex6s.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test the default (type not set) static mutex type.
+ * Should be the same as PTHREAD_MUTEX_NORMAL.
+ * Thread locks mutex twice (recursive lock).
+ * Locking thread should deadlock on second attempt.
+ *
+ * Depends on API functions: 
+ *	pthread_mutex_lock()
+ *	pthread_mutex_trylock()
+ *	pthread_mutex_unlock()
+ */
+
+#include "test.h"
+
+static int lockCount = 0;
+
+static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
+
+void * locker(void * arg)
+{
+  assert(pthread_mutex_lock(&mutex) == 0);
+  lockCount++;
+
+  /* Should wait here (deadlocked) */
+  assert(pthread_mutex_lock(&mutex) == 0);
+  lockCount++;
+  assert(pthread_mutex_unlock(&mutex) == 0);
+
+  return 0;
+}
+ 
+int
+main()
+{
+  pthread_t t;
+
+  assert(mutex == PTHREAD_MUTEX_INITIALIZER);
+
+  assert(pthread_create(&t, NULL, locker, NULL) == 0);
+
+  while (lockCount < 1)
+    {
+      Sleep(1);
+    }
+
+  assert(lockCount == 1);
+
+  /*
+   * Should succeed even though we don't own the lock
+   * because FAST mutexes don't check ownership.
+   */
+  assert(pthread_mutex_unlock(&mutex) == 0);
+
+  while (lockCount < 2)
+    {
+      Sleep(1);
+    }
+
+  assert(lockCount == 2);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/mutex7.c b/src/include/pthread/tests/mutex7.c
new file mode 100644
index 0000000..2385e01
--- /dev/null
+++ b/src/include/pthread/tests/mutex7.c
@@ -0,0 +1,80 @@
+/* 
+ * mutex7.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test the default (type not set) mutex type.
+ * Should be the same as PTHREAD_MUTEX_NORMAL.
+ * Thread locks then trylocks mutex (attempted recursive lock).
+ * The thread should lock first time and EBUSY second time.
+ *
+ * Depends on API functions: 
+ *	pthread_mutex_lock()
+ *	pthread_mutex_trylock()
+ *	pthread_mutex_unlock()
+ */
+
+#include "test.h"
+
+static int lockCount = 0;
+
+static pthread_mutex_t mutex;
+
+void * locker(void * arg)
+{
+  assert(pthread_mutex_lock(&mutex) == 0);
+  lockCount++;
+  assert(pthread_mutex_trylock(&mutex) == EBUSY);
+  lockCount++;
+  assert(pthread_mutex_unlock(&mutex) == 0);
+  assert(pthread_mutex_unlock(&mutex) == 0);
+
+  return 0;
+}
+ 
+int
+main()
+{
+  pthread_t t;
+
+  assert(pthread_mutex_init(&mutex, NULL) == 0);
+
+  assert(pthread_create(&t, NULL, locker, NULL) == 0);
+
+  while (lockCount < 2)
+    {
+      Sleep(1);
+    }
+
+  assert(lockCount == 2);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/mutex7e.c b/src/include/pthread/tests/mutex7e.c
new file mode 100644
index 0000000..ea6279c
--- /dev/null
+++ b/src/include/pthread/tests/mutex7e.c
@@ -0,0 +1,103 @@
+/* 
+ * mutex7e.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Tests PTHREAD_MUTEX_ERRORCHECK mutex type.
+ * Thread locks and then trylocks mutex (attempted recursive lock).
+ * Trylock should fail with an EBUSY error.
+ * The second unlock attempt should fail with an EPERM error.
+ *
+ * Depends on API functions: 
+ *      pthread_create()
+ *      pthread_join()
+ *      pthread_mutexattr_init()
+ *      pthread_mutexattr_destroy()
+ *      pthread_mutexattr_settype()
+ *      pthread_mutexattr_gettype()
+ *      pthread_mutex_init()
+ *      pthread_mutex_destroy()
+ *	pthread_mutex_lock()
+ *	pthread_mutex_unlock()
+ */
+
+#include "test.h"
+
+static int lockCount;
+
+static pthread_mutex_t mutex;
+static pthread_mutexattr_t mxAttr;
+
+void * locker(void * arg)
+{
+  assert(pthread_mutex_lock(&mutex) == 0);
+  lockCount++;
+  assert(pthread_mutex_trylock(&mutex) == EBUSY);
+  lockCount++;
+  assert(pthread_mutex_unlock(&mutex) == 0);
+
+  return (void *) 555;
+}
+ 
+int
+main()
+{
+  pthread_t t;
+  void* result = (void*)0;
+  int mxType = -1;
+
+  assert(pthread_mutexattr_init(&mxAttr) == 0);
+
+  BEGIN_MUTEX_STALLED_ROBUST(mxAttr)
+
+  lockCount = 0;
+  assert(pthread_mutexattr_settype(&mxAttr, PTHREAD_MUTEX_ERRORCHECK) == 0);
+  assert(pthread_mutexattr_gettype(&mxAttr, &mxType) == 0);
+  assert(mxType == PTHREAD_MUTEX_ERRORCHECK);
+
+  assert(pthread_mutex_init(&mutex, &mxAttr) == 0);
+
+  assert(pthread_create(&t, NULL, locker, NULL) == 0);
+
+  assert(pthread_join(t, &result) == 0);
+  assert((int)(size_t)result == 555);
+
+  assert(lockCount == 2);
+
+  assert(pthread_mutex_destroy(&mutex) == 0);
+
+  END_MUTEX_STALLED_ROBUST(mxAttr)
+
+  assert(pthread_mutexattr_destroy(&mxAttr) == 0);
+
+  return 0;
+}
+
diff --git a/src/include/pthread/tests/mutex7n.c b/src/include/pthread/tests/mutex7n.c
new file mode 100644
index 0000000..d8f339f
--- /dev/null
+++ b/src/include/pthread/tests/mutex7n.c
@@ -0,0 +1,98 @@
+/* 
+ * mutex7n.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Tests PTHREAD_MUTEX_NORMAL mutex type.
+ * Thread locks then trylocks mutex (attempted recursive lock).
+ * The thread should lock first time and EBUSY second time.
+ *
+ * Depends on API functions: 
+ *      pthread_create()
+ *      pthread_mutexattr_init()
+ *      pthread_mutexattr_settype()
+ *      pthread_mutexattr_gettype()
+ *      pthread_mutex_init()
+ *	pthread_mutex_lock()
+ *	pthread_mutex_unlock()
+ */
+
+#include "test.h"
+
+static int lockCount;
+
+static pthread_mutex_t mutex;
+static pthread_mutexattr_t mxAttr;
+
+void * locker(void * arg)
+{
+  assert(pthread_mutex_lock(&mutex) == 0);
+  lockCount++;
+  assert(pthread_mutex_trylock(&mutex) == EBUSY);
+  lockCount++;
+  assert(pthread_mutex_unlock(&mutex) == 0);
+
+  return (void *) 555;
+}
+ 
+int
+main()
+{
+  pthread_t t;
+  int mxType = -1;
+
+  assert(pthread_mutexattr_init(&mxAttr) == 0);
+
+  BEGIN_MUTEX_STALLED_ROBUST(mxAttr)
+
+  lockCount = 0;
+  assert(pthread_mutexattr_settype(&mxAttr, PTHREAD_MUTEX_NORMAL) == 0);
+  assert(pthread_mutexattr_gettype(&mxAttr, &mxType) == 0);
+  assert(mxType == PTHREAD_MUTEX_NORMAL);
+
+  assert(pthread_mutex_init(&mutex, &mxAttr) == 0);
+
+  assert(pthread_create(&t, NULL, locker, NULL) == 0);
+
+  while (lockCount < 2)
+    {
+      Sleep(1);
+    }
+
+  assert(lockCount == 2);
+
+  END_MUTEX_STALLED_ROBUST(mxAttr)
+
+  assert(pthread_mutexattr_destroy(&mxAttr) == 0);
+
+  return 0;
+}
+
diff --git a/src/include/pthread/tests/mutex7r.c b/src/include/pthread/tests/mutex7r.c
new file mode 100644
index 0000000..3f667ad
--- /dev/null
+++ b/src/include/pthread/tests/mutex7r.c
@@ -0,0 +1,102 @@
+/* 
+ * mutex7r.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Tests PTHREAD_MUTEX_RECURSIVE mutex type.
+ * Thread locks mutex then trylocks mutex (recursive lock twice).
+ * Both locks and unlocks should succeed.
+ *
+ * Depends on API functions: 
+ *      pthread_create()
+ *      pthread_join()
+ *      pthread_mutexattr_init()
+ *      pthread_mutexattr_destroy()
+ *      pthread_mutexattr_settype()
+ *      pthread_mutexattr_gettype()
+ *      pthread_mutex_init()
+ *      pthread_mutex_destroy()
+ *	pthread_mutex_lock()
+ *	pthread_mutex_unlock()
+ */
+
+#include "test.h"
+
+static int lockCount;
+
+static pthread_mutex_t mutex;
+static pthread_mutexattr_t mxAttr;
+
+void * locker(void * arg)
+{
+  assert(pthread_mutex_lock(&mutex) == 0);
+  lockCount++;
+  assert(pthread_mutex_trylock(&mutex) == 0);
+  lockCount++;
+  assert(pthread_mutex_unlock(&mutex) == 0);
+  assert(pthread_mutex_unlock(&mutex) == 0);
+
+  return (void *) 555;
+}
+ 
+int
+main()
+{
+  pthread_t t;
+  void* result = (void*)0;
+  int mxType = -1;
+
+  assert(pthread_mutexattr_init(&mxAttr) == 0);
+
+  BEGIN_MUTEX_STALLED_ROBUST(mxAttr)
+
+  lockCount = 0;
+  assert(pthread_mutexattr_settype(&mxAttr, PTHREAD_MUTEX_RECURSIVE) == 0);
+  assert(pthread_mutexattr_gettype(&mxAttr, &mxType) == 0);
+  assert(mxType == PTHREAD_MUTEX_RECURSIVE);
+
+  assert(pthread_mutex_init(&mutex, &mxAttr) == 0);
+
+  assert(pthread_create(&t, NULL, locker, NULL) == 0);
+
+  assert(pthread_join(t, &result) == 0);
+  assert((int)(size_t)result == 555);
+
+  assert(lockCount == 2);
+
+  assert(pthread_mutex_destroy(&mutex) == 0);
+
+  END_MUTEX_STALLED_ROBUST(mxAttr)
+
+  assert(pthread_mutexattr_destroy(&mxAttr) == 0);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/mutex8.c b/src/include/pthread/tests/mutex8.c
new file mode 100644
index 0000000..055196e
--- /dev/null
+++ b/src/include/pthread/tests/mutex8.c
@@ -0,0 +1,82 @@
+/* 
+ * mutex8.c
+ *
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test the default (type not set) mutex type exercising timedlock.
+ * Thread locks mutex, another thread timedlocks the mutex.
+ * Timed thread should timeout.
+ *
+ * Depends on API functions:
+ *	pthread_mutex_lock()
+ *	pthread_mutex_timedlock()
+ *	pthread_mutex_unlock()
+ */
+
+#include "test.h"
+
+static int lockCount = 0;
+
+static pthread_mutex_t mutex;
+
+void * locker(void * arg)
+{
+  struct timespec abstime, reltime = { 1, 0 };
+
+  (void) pthread_win32_getabstime_np(&abstime, &reltime);
+
+  assert(pthread_mutex_timedlock(&mutex, &abstime) == ETIMEDOUT);
+
+  lockCount++;
+
+  return 0;
+}
+
+int
+main()
+{
+  pthread_t t;
+
+  assert(pthread_mutex_init(&mutex, NULL) == 0);
+
+  assert(pthread_mutex_lock(&mutex) == 0);
+
+  assert(pthread_create(&t, NULL, locker, NULL) == 0);
+
+  while (lockCount < 1)
+    {
+      Sleep(1);
+    }
+
+  assert(lockCount == 1);
+
+  assert(pthread_mutex_unlock(&mutex) == 0);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/mutex8e.c b/src/include/pthread/tests/mutex8e.c
new file mode 100644
index 0000000..8f59d5a
--- /dev/null
+++ b/src/include/pthread/tests/mutex8e.c
@@ -0,0 +1,100 @@
+/* 
+ * mutex8e.c
+ *
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Tests PTHREAD_MUTEX_ERRORCHECK mutex type exercising timedlock.
+ * Thread locks mutex, another thread timedlocks the mutex.
+ * Timed thread should timeout.
+ *
+ * Depends on API functions:
+ *	pthread_create()
+ *	pthread_mutexattr_init()
+ *	pthread_mutexattr_destroy()
+ *	pthread_mutexattr_settype()
+ *	pthread_mutexattr_gettype()
+ *	pthread_mutex_init()
+ *	pthread_mutex_destroy()
+ *	pthread_mutex_lock()
+ *	pthread_mutex_timedlock()
+ *	pthread_mutex_unlock()
+ */
+
+#include "test.h"
+
+static int lockCount;
+
+static pthread_mutex_t mutex;
+static pthread_mutexattr_t mxAttr;
+
+void * locker(void * arg)
+{
+  struct timespec abstime, reltime = { 1, 0 };
+
+  (void) pthread_win32_getabstime_np(&abstime, &reltime);
+
+  assert(pthread_mutex_timedlock(&mutex, &abstime) == ETIMEDOUT);
+
+  lockCount++;
+
+  return 0;
+}
+
+int
+main()
+{
+  pthread_t t;
+  int mxType = -1;
+
+  assert(pthread_mutexattr_init(&mxAttr) == 0);
+
+  BEGIN_MUTEX_STALLED_ROBUST(mxAttr)
+
+  lockCount = 0;
+  assert(pthread_mutexattr_settype(&mxAttr, PTHREAD_MUTEX_ERRORCHECK) == 0);
+  assert(pthread_mutexattr_gettype(&mxAttr, &mxType) == 0);
+  assert(mxType == PTHREAD_MUTEX_ERRORCHECK);
+
+  assert(pthread_mutex_init(&mutex, &mxAttr) == 0);
+
+  assert(pthread_mutex_lock(&mutex) == 0);
+
+  assert(pthread_create(&t, NULL, locker, NULL) == 0);
+
+  Sleep(2000);
+
+  assert(lockCount == 1);
+
+  assert(pthread_mutex_unlock(&mutex) == 0);
+
+  END_MUTEX_STALLED_ROBUST(mxAttr)
+
+  return 0;
+}
+
diff --git a/src/include/pthread/tests/mutex8n.c b/src/include/pthread/tests/mutex8n.c
new file mode 100644
index 0000000..96ea2e9
--- /dev/null
+++ b/src/include/pthread/tests/mutex8n.c
@@ -0,0 +1,103 @@
+/*
+ * mutex8n.c
+ *
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Tests PTHREAD_MUTEX_NORMAL mutex type exercising timedlock.
+ * Thread locks mutex, another thread timedlocks the mutex.
+ * Timed thread should timeout.
+ *
+ * Depends on API functions:
+ *	pthread_create()
+ *	pthread_mutexattr_init()
+ *	pthread_mutexattr_destroy()
+ *	pthread_mutexattr_settype()
+ *	pthread_mutexattr_gettype()
+ *	pthread_mutex_init()
+ *	pthread_mutex_destroy()
+ *	pthread_mutex_lock()
+ *	pthread_mutex_timedlock()
+ *	pthread_mutex_unlock()
+ */
+
+#include "test.h"
+
+static int lockCount;
+
+static pthread_mutex_t mutex;
+static pthread_mutexattr_t mxAttr;
+
+void * locker(void * arg)
+{
+  struct timespec abstime, reltime = { 1, 0 };
+
+  (void) pthread_win32_getabstime_np(&abstime, &reltime);
+
+  assert(pthread_mutex_timedlock(&mutex, &abstime) == ETIMEDOUT);
+
+  lockCount++;
+
+  return 0;
+}
+
+int
+main()
+{
+  pthread_t t;
+  int mxType = -1;
+
+  assert(pthread_mutexattr_init(&mxAttr) == 0);
+
+  BEGIN_MUTEX_STALLED_ROBUST(mxAttr)
+
+  lockCount = 0;
+  assert(pthread_mutexattr_settype(&mxAttr, PTHREAD_MUTEX_NORMAL) == 0);
+  assert(pthread_mutexattr_gettype(&mxAttr, &mxType) == 0);
+  assert(mxType == PTHREAD_MUTEX_NORMAL);
+
+  assert(pthread_mutex_init(&mutex, &mxAttr) == 0);
+
+  assert(pthread_mutex_lock(&mutex) == 0);
+
+  assert(pthread_create(&t, NULL, locker, NULL) == 0);
+
+  while (lockCount < 1)
+    {
+      Sleep(1);
+    }
+
+  assert(lockCount == 1);
+
+  assert(pthread_mutex_unlock(&mutex) == 0);
+
+  END_MUTEX_STALLED_ROBUST(mxAttr)
+
+  return 0;
+}
+
diff --git a/src/include/pthread/tests/mutex8r.c b/src/include/pthread/tests/mutex8r.c
new file mode 100644
index 0000000..e811cd8
--- /dev/null
+++ b/src/include/pthread/tests/mutex8r.c
@@ -0,0 +1,100 @@
+/* 
+ * mutex8r.c
+ *
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Tests PTHREAD_MUTEX_RECURSIVE mutex type exercising timedlock.
+ * Thread locks mutex, another thread timedlocks the mutex.
+ * Timed thread should timeout.
+ *
+ * Depends on API functions:
+ *	pthread_create()
+ *	pthread_mutexattr_init()
+ *	pthread_mutexattr_destroy()
+ *	pthread_mutexattr_settype()
+ *	pthread_mutexattr_gettype()
+ *	pthread_mutex_init()
+ *	pthread_mutex_destroy()
+ *	pthread_mutex_lock()
+ *	pthread_mutex_timedlock()
+ *	pthread_mutex_unlock()
+ */
+
+#include "test.h"
+
+static int lockCount;
+
+static pthread_mutex_t mutex;
+static pthread_mutexattr_t mxAttr;
+
+void * locker(void * arg)
+{
+  struct timespec abstime, reltime = { 1, 0 };
+
+  (void) pthread_win32_getabstime_np(&abstime, &reltime);
+
+  assert(pthread_mutex_timedlock(&mutex, &abstime) == ETIMEDOUT);
+
+  lockCount++;
+
+  return 0;
+}
+
+int
+main()
+{
+  pthread_t t;
+  int mxType = -1;
+
+  assert(pthread_mutexattr_init(&mxAttr) == 0);
+
+  BEGIN_MUTEX_STALLED_ROBUST(mxAttr)
+
+  lockCount = 0;
+  assert(pthread_mutexattr_settype(&mxAttr, PTHREAD_MUTEX_RECURSIVE) == 0);
+  assert(pthread_mutexattr_gettype(&mxAttr, &mxType) == 0);
+  assert(mxType == PTHREAD_MUTEX_RECURSIVE);
+
+  assert(pthread_mutex_init(&mutex, &mxAttr) == 0);
+
+  assert(pthread_mutex_lock(&mutex) == 0);
+
+  assert(pthread_create(&t, NULL, locker, NULL) == 0);
+
+  Sleep(2000);
+
+  assert(lockCount == 1);
+
+  assert(pthread_mutex_unlock(&mutex) == 0);
+
+  END_MUTEX_STALLED_ROBUST(mxAttr)
+
+  return 0;
+}
+
diff --git a/src/include/pthread/tests/name_np1.c b/src/include/pthread/tests/name_np1.c
new file mode 100644
index 0000000..61bbdef
--- /dev/null
+++ b/src/include/pthread/tests/name_np1.c
@@ -0,0 +1,102 @@
+/*
+ * name_np1.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Description:
+ * Create a thread and give it a name.
+ *
+ * The MSVC version should display the thread name in the MSVS debugger.
+ * Confirmed for MSVS10 Express:
+ *
+ *      VCExpress name_np1.exe /debugexe
+ *
+ * did indeed display the thread name in the trace output.
+ *
+ * Depends on API functions:
+ *      pthread_create
+ *      pthread_join
+ *      pthread_self
+ *      pthread_getname_np
+ *      pthread_setname_np
+ *      pthread_barrier_init
+ *      pthread_barrier_wait
+ */
+
+#include "test.h"
+
+static int washere = 0;
+static pthread_barrier_t sync;
+#if defined (__PTW32_COMPATIBILITY_BSD)
+static int seqno = 0;
+#endif
+
+void * func(void * arg)
+{
+  char buf[32];
+  pthread_t self = pthread_self();
+
+  washere = 1;
+  pthread_barrier_wait(&sync);
+  assert(pthread_getname_np(self, buf, 32) == 0);
+  printf("Thread name: %s\n", buf);
+  pthread_barrier_wait(&sync);
+
+  return 0;
+}
+
+int
+main()
+{
+  pthread_t t;
+
+  assert(pthread_barrier_init(&sync, NULL, 2) == 0);
+
+  assert(pthread_create(&t, NULL, func, NULL) == 0);
+#if defined (__PTW32_COMPATIBILITY_BSD)
+  seqno++;
+  assert(pthread_setname_np(t, "MyThread%d", (void *)&seqno) == 0);
+#elif defined (__PTW32_COMPATIBILITY_TRU64)
+  assert(pthread_setname_np(t, "MyThread1", NULL) == 0);
+#else
+  assert(pthread_setname_np(t, "MyThread1") == 0);
+#endif
+  pthread_barrier_wait(&sync);
+  pthread_barrier_wait(&sync);
+
+  assert(pthread_join(t, NULL) == 0);
+
+  assert(pthread_barrier_destroy(&sync) == 0);
+
+  assert(washere == 1);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/name_np2.c b/src/include/pthread/tests/name_np2.c
new file mode 100644
index 0000000..4c098ec
--- /dev/null
+++ b/src/include/pthread/tests/name_np2.c
@@ -0,0 +1,107 @@
+/*
+ * name_np2.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Description:
+ * Create a thread and give it a name.
+ *
+ * The MSVC version should display the thread name in the MSVS debugger.
+ * Confirmed for MSVS10 Express:
+ *
+ *      VCExpress name_np1.exe /debugexe
+ *
+ * did indeed display the thread name in the trace output.
+ *
+ * Depends on API functions:
+ *      pthread_create
+ *      pthread_join
+ *      pthread_self
+ *      pthread_attr_init
+ *      pthread_getname_np
+ *      pthread_attr_setname_np
+ *      pthread_barrier_init
+ *      pthread_barrier_wait
+ */
+
+#include "test.h"
+
+static int washere = 0;
+static pthread_attr_t attr;
+static pthread_barrier_t sync;
+#if defined (__PTW32_COMPATIBILITY_BSD)
+static int seqno = 0;
+#endif
+
+void * func(void * arg)
+{
+  char buf[32];
+  pthread_t self = pthread_self();
+
+  washere = 1;
+  pthread_barrier_wait(&sync);
+  assert(pthread_getname_np(self, buf, 32) == 0);
+  printf("Thread name: %s\n", buf);
+  pthread_barrier_wait(&sync);
+
+  return 0;
+}
+
+int
+main()
+{
+  pthread_t t;
+
+  assert(pthread_attr_init(&attr) == 0);
+#if defined (__PTW32_COMPATIBILITY_BSD)
+  seqno++;
+  assert(pthread_attr_setname_np(&attr, "MyThread%d", (void *)&seqno) == 0);
+#elif defined (__PTW32_COMPATIBILITY_TRU64)
+  assert(pthread_attr_setname_np(&attr, "MyThread1", NULL) == 0);
+#else
+  assert(pthread_attr_setname_np(&attr, "MyThread1") == 0);
+#endif
+
+  assert(pthread_barrier_init(&sync, NULL, 2) == 0);
+
+  assert(pthread_create(&t, &attr, func, NULL) == 0);
+  pthread_barrier_wait(&sync);
+  pthread_barrier_wait(&sync);
+
+  assert(pthread_join(t, NULL) == 0);
+
+  assert(pthread_barrier_destroy(&sync) == 0);
+  assert(pthread_attr_destroy(&attr) == 0);
+
+  assert(washere == 1);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/once1.c b/src/include/pthread/tests/once1.c
new file mode 100644
index 0000000..8a9ab55
--- /dev/null
+++ b/src/include/pthread/tests/once1.c
@@ -0,0 +1,75 @@
+/*
+ * once1.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Create a static pthread_once and test that it calls myfunc once.
+ *
+ * Depends on API functions:
+ *	pthread_once()
+ *	pthread_create()
+ */
+
+#include "test.h"
+
+pthread_once_t once = PTHREAD_ONCE_INIT;
+
+static int washere = 0;
+
+void
+myfunc(void)
+{
+  washere++;
+}
+
+void *
+mythread(void * arg)
+{
+   assert(pthread_once(&once, myfunc) == 0);
+
+   return 0;
+}
+
+int
+main()
+{
+  pthread_t t1, t2;
+  
+  assert(pthread_create(&t1, NULL, mythread, NULL) == 0);
+
+  assert(pthread_create(&t2, NULL, mythread, NULL) == 0);
+
+  Sleep(2000);
+
+  assert(washere == 1);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/once2.c b/src/include/pthread/tests/once2.c
new file mode 100644
index 0000000..f8243af
--- /dev/null
+++ b/src/include/pthread/tests/once2.c
@@ -0,0 +1,114 @@
+/*
+ * once2.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Create several static pthread_once objects and channel several threads
+ * through each.
+ *
+ * Depends on API functions:
+ *	pthread_once()
+ *	pthread_create()
+ */
+
+#include "test.h"
+
+#define NUM_THREADS 100 /* Targeting each once control */
+#define NUM_ONCE    10
+
+pthread_once_t o = PTHREAD_ONCE_INIT;
+pthread_once_t once[NUM_ONCE];
+
+typedef struct {
+  int i;
+  CRITICAL_SECTION cs;
+} sharedInt_t;
+
+static sharedInt_t numOnce;
+static sharedInt_t numThreads;
+
+void
+myfunc(void)
+{
+  EnterCriticalSection(&numOnce.cs);
+  numOnce.i++;
+  LeaveCriticalSection(&numOnce.cs);
+  /* Simulate slow once routine so that following threads pile up behind it */
+  Sleep(100);
+}
+
+void *
+mythread(void * arg)
+{
+   assert(pthread_once(&once[(int)(size_t)arg], myfunc) == 0);
+   EnterCriticalSection(&numThreads.cs);
+   numThreads.i++;   
+   LeaveCriticalSection(&numThreads.cs);
+   return (void*)(size_t)0;
+}
+
+int
+main()
+{
+  pthread_t t[NUM_THREADS][NUM_ONCE];
+  int i, j;
+  
+  memset(&numOnce, 0, sizeof(sharedInt_t));
+  memset(&numThreads, 0, sizeof(sharedInt_t));
+
+  InitializeCriticalSection(&numThreads.cs);
+  InitializeCriticalSection(&numOnce.cs);
+
+  for (j = 0; j < NUM_ONCE; j++)
+    {
+      once[j] = o;
+
+      for (i = 0; i < NUM_THREADS; i++)
+        {
+	  /* GCC build: create was failing with EAGAIN after 790 threads */
+          while (0 != pthread_create(&t[i][j], NULL, mythread, (void *)(size_t)j))
+	    sched_yield();
+        }
+    }
+
+  for (j = 0; j < NUM_ONCE; j++)
+    for (i = 0; i < NUM_THREADS; i++)
+      if (pthread_join(t[i][j], NULL) != 0)
+        printf("Join failed for [thread,once] = [%d,%d]\n", i, j);
+
+  assert(numOnce.i == NUM_ONCE);
+  assert(numThreads.i == NUM_THREADS * NUM_ONCE);
+
+  DeleteCriticalSection(&numOnce.cs);
+  DeleteCriticalSection(&numThreads.cs);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/once3.c b/src/include/pthread/tests/once3.c
new file mode 100644
index 0000000..54073ec
--- /dev/null
+++ b/src/include/pthread/tests/once3.c
@@ -0,0 +1,147 @@
+/*
+ * once3.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Create several pthread_once objects and channel several threads
+ * through each. Make the init_routine cancelable and cancel them with
+ * waiters waiting.
+ *
+ * Depends on API functions:
+ *	pthread_once()
+ *	pthread_create()
+ *      pthread_testcancel()
+ *      pthread_cancel()
+ *      pthread_once()
+ */
+
+/* #define ASSERT_TRACE */
+
+#include "test.h"
+
+#define NUM_THREADS 100 /* Targeting each once control */
+#define NUM_ONCE    10
+
+static pthread_once_t o = PTHREAD_ONCE_INIT;
+static pthread_once_t once[NUM_ONCE];
+
+typedef struct {
+  int i;
+  CRITICAL_SECTION cs;
+} sharedInt_t;
+
+static sharedInt_t numOnce;
+static sharedInt_t numThreads;
+
+void
+myfunc(void)
+{
+  EnterCriticalSection(&numOnce.cs);
+  numOnce.i++;
+  assert(numOnce.i > 0);
+  LeaveCriticalSection(&numOnce.cs);
+  /* Simulate slow once routine so that following threads pile up behind it */
+  Sleep(10);
+  /* Test for cancellation late so we're sure to have waiters. */
+  pthread_testcancel();
+}
+
+void *
+mythread(void * arg)
+{
+  /*
+   * Cancel every thread. These threads are deferred cancelable only, so
+   * this thread will see it only when it performs the once routine (my_func).
+   * The result will be that every thread eventually cancels only when it
+   * becomes the new 'once' thread.
+   */
+  assert(pthread_cancel(pthread_self()) == 0);
+  /*
+   * Now we block on the 'once' control.
+   */
+  assert(pthread_once(&once[(int)(size_t)arg], myfunc) == 0);
+  /*
+   * We should never get to here.
+   */
+  EnterCriticalSection(&numThreads.cs);
+  numThreads.i++;
+  LeaveCriticalSection(&numThreads.cs);
+  return (void*)(size_t)0;
+}
+
+int
+main()
+{
+  pthread_t t[NUM_THREADS][NUM_ONCE];
+  int i, j;
+
+#if defined (__PTW32_CONFIG_MSVC6) && defined(__PTW32_CLEANUP_CXX)
+  puts("If this test fails or hangs, rebuild the library with /EHa instead of /EHs.");
+  puts("(This is a known issue with Microsoft VC++6.0.)");
+  fflush(stdout);
+#endif
+  
+  memset(&numOnce, 0, sizeof(sharedInt_t));
+  memset(&numThreads, 0, sizeof(sharedInt_t));
+
+  InitializeCriticalSection(&numThreads.cs);
+  InitializeCriticalSection(&numOnce.cs);
+
+  for (j = 0; j < NUM_ONCE; j++)
+    {
+      once[j] = o;
+
+      for (i = 0; i < NUM_THREADS; i++)
+        {
+          /* GCC build: create was failing with EAGAIN after 790 threads */
+          while (0 != pthread_create(&t[i][j], NULL, mythread, (void *)(size_t)j))
+            sched_yield();
+        }
+    }
+
+  for (j = 0; j < NUM_ONCE; j++)
+    for (i = 0; i < NUM_THREADS; i++)
+      if (pthread_join(t[i][j], NULL) != 0)
+        printf("Join failed for [thread,once] = [%d,%d]\n", i, j);
+
+  /*
+   * All threads will cancel, none will return normally from
+   * pthread_once and so numThreads should never be incremented. However,
+   * numOnce should be incremented by every thread (NUM_THREADS*NUM_ONCE).
+   */
+  assert(numOnce.i == NUM_ONCE * NUM_THREADS);
+  assert(numThreads.i == 0);
+
+  DeleteCriticalSection(&numOnce.cs);
+  DeleteCriticalSection(&numThreads.cs);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/once4.c b/src/include/pthread/tests/once4.c
new file mode 100644
index 0000000..af8d22c
--- /dev/null
+++ b/src/include/pthread/tests/once4.c
@@ -0,0 +1,200 @@
+/*
+ * once4.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Create several pthread_once objects and channel several threads
+ * through each. Make the init_routine cancelable and cancel them
+ * waiters waiting. Vary the priorities.
+ *
+ * Depends on API functions:
+ *	pthread_once()
+ *	pthread_create()
+ *      pthread_testcancel()
+ *      pthread_cancel()
+ *      pthread_once()
+ */
+
+#include "test.h"
+
+#define NUM_THREADS 100 /* Targeting each once control */
+#define NUM_ONCE    10
+
+pthread_once_t o = PTHREAD_ONCE_INIT;
+pthread_once_t once[NUM_ONCE];
+
+typedef struct {
+  int i;
+  CRITICAL_SECTION cs;
+} sharedInt_t;
+
+static sharedInt_t numOnce;
+static sharedInt_t numThreads;
+
+typedef struct {
+  int threadnum;
+  int oncenum;
+  int myPrio;
+  HANDLE w32Thread;
+} bag_t;
+
+static bag_t threadbag[NUM_THREADS][NUM_ONCE];
+
+CRITICAL_SECTION print_lock;
+
+void
+mycleanupfunc(void * arg)
+{
+  bag_t * bag = (bag_t *) arg;
+  EnterCriticalSection(&print_lock);
+  /*      once thrd  prio error */
+  printf("%4d %4d %4d %4d\n",
+	 bag->oncenum,
+	 bag->threadnum,
+	 bag->myPrio,
+	 bag->myPrio - GetThreadPriority(bag->w32Thread));
+  LeaveCriticalSection(&print_lock);
+}
+
+void
+myinitfunc(void)
+{
+  EnterCriticalSection(&numOnce.cs);
+  numOnce.i++;
+  LeaveCriticalSection(&numOnce.cs);
+  /* Simulate slow once routine so that following threads pile up behind it */
+  Sleep(10);
+  /* test for cancellation late so we're sure to have waiters. */
+  pthread_testcancel();
+}
+
+void *
+mythread(void * arg)
+{
+  bag_t * bag = (bag_t *) arg;
+  struct sched_param param;
+
+  /*
+   * Cancel every thread. These threads are deferred cancelable only, so
+   * only the thread performing the init_routine will see it (there are
+   * no other cancellation points here). The result will be that every thread
+   * eventually cancels only when it becomes the new initter.
+   */
+  pthread_t self = pthread_self();
+  bag->w32Thread = pthread_getw32threadhandle_np(self);
+  /*
+   * Set priority between -2 and 2 inclusive.
+   */
+  bag->myPrio = (bag->threadnum % 5) - 2;
+  param.sched_priority = bag->myPrio;
+  pthread_setschedparam(self, SCHED_OTHER, &param);
+
+  /* Trigger a cancellation at the next cancellation point in this thread */
+  pthread_cancel(self);
+#if 0
+  pthread_cleanup_push(mycleanupfunc, arg);
+  assert(pthread_once(&once[bag->oncenum], myinitfunc) == 0);
+  pthread_cleanup_pop(1);
+#else
+  assert(pthread_once(&once[bag->oncenum], myinitfunc) == 0);
+#endif
+  EnterCriticalSection(&numThreads.cs);
+  numThreads.i++;
+  LeaveCriticalSection(&numThreads.cs);
+  return 0;
+}
+
+int
+main()
+{
+  pthread_t t[NUM_THREADS][NUM_ONCE];
+  int i, j;
+
+#if defined (__PTW32_CONFIG_MSVC6) && defined(__PTW32_CLEANUP_CXX)
+  puts("If this test fails or hangs, rebuild the library with /EHa instead of /EHs.");
+  puts("(This is a known issue with Microsoft VC++6.0.)");
+  fflush(stdout);
+#endif
+
+  memset(&numOnce, 0, sizeof(sharedInt_t));
+  memset(&numThreads, 0, sizeof(sharedInt_t));
+
+  InitializeCriticalSection(&print_lock);
+  InitializeCriticalSection(&numThreads.cs);
+  InitializeCriticalSection(&numOnce.cs);
+
+#if 0
+  /*       once thrd  prio change */
+  printf("once thrd  prio  error\n");
+#endif
+
+  /*
+   * Set the priority class to realtime - otherwise normal
+   * Windows random priority boosting will obscure any problems.
+   */
+  SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS);
+  /* Set main thread to lower prio than threads */
+  SetThreadPriority(GetCurrentThread(), -2);
+
+  for (j = 0; j < NUM_ONCE; j++)
+    {
+      once[j] = o;
+
+      for (i = 0; i < NUM_THREADS; i++)
+        {
+	  bag_t * bag = &threadbag[i][j];
+	  bag->threadnum = i;
+	  bag->oncenum = j;
+          /* GCC build: create was failing with EAGAIN after 790 threads */
+          while (0 != pthread_create(&t[i][j], NULL, mythread, (void *)bag))
+            sched_yield();
+        }
+    }
+
+  for (j = 0; j < NUM_ONCE; j++)
+    for (i = 0; i < NUM_THREADS; i++)
+      if (pthread_join(t[i][j], NULL) != 0)
+        printf("Join failed for [thread,once] = [%d,%d]\n", i, j);
+
+  /*
+   * All threads will cancel, none will return normally from
+   * pthread_once and so numThreads should never be incremented. However,
+   * numOnce should be incremented by every thread (NUM_THREADS*NUM_ONCE).
+   */
+  assert(numOnce.i == NUM_ONCE * NUM_THREADS);
+  assert(numThreads.i == 0);
+
+  DeleteCriticalSection(&numOnce.cs);
+  DeleteCriticalSection(&numThreads.cs);
+  DeleteCriticalSection(&print_lock);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/openmp1.c b/src/include/pthread/tests/openmp1.c
new file mode 100644
index 0000000..b5791e2
--- /dev/null
+++ b/src/include/pthread/tests/openmp1.c
@@ -0,0 +1,140 @@
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _OPENMP
+#  include <omp.h>
+#endif
+#include <pthread.h>
+
+enum {
+  Size = 10000
+};
+
+const int  ShouldSum = (Size-1)*Size/2;
+
+short Verbose = 1;
+
+short ThreadOK[3] = {0,0,0}; // Main, Thread1, Thread2
+
+// Thread
+void *_thread(void* Id) {
+  int i;
+  int x[Size];
+
+#ifdef _OPENMP
+#  pragma omp parallel for
+#endif
+  for ( i = 0; i < Size; i++ ) {
+#ifdef _OPENMP
+    if (Verbose && i%1000==0) {
+      int tid = omp_get_thread_num();
+#  pragma omp critical
+      printf("thread %d : tid %d handles %d\n",(int)(size_t)Id,tid,i);
+    }
+#endif
+
+    x[i] = i;
+  }
+
+  int Sum=0;
+  for ( i = 0; i < Size; i++ ) {
+    Sum += x[i];
+  }
+  if (Verbose) {
+#ifdef _OPENMP
+#  pragma omp critical
+#endif
+    printf("Id %d : %s : %d(should be %d)\n",(int)(size_t)Id, __FUNCTION__, Sum,ShouldSum);
+  }
+  if (Sum == ShouldSum) ThreadOK[(int)(size_t)Id] = 1;
+  return NULL;
+}
+
+// MainThread
+void MainThread() {
+  int i;
+
+#ifdef _OPENMP
+#  pragma omp parallel for
+#endif
+  for ( i = 0; i < 4; i++ ) {
+#ifdef _OPENMP
+      int tid = omp_get_thread_num();
+#  pragma omp critical
+      printf("Main : tid %d\n",tid);
+      _thread((void *)(size_t)tid);
+#endif
+  }
+  return;
+}
+
+// Comment in/out for checking the effect of multiple threads.
+#define SPAWN_THREADS
+
+// main
+int main(int argc, char *argv[]) {
+
+  if (argc>1) Verbose = 1;
+
+#ifdef _OPENMP
+  omp_set_nested(-1);
+  printf("%s%s%s\n", "Nested parallel blocks are ", omp_get_nested()?" ":"NOT ", "supported.");
+#endif
+
+  MainThread();
+
+#ifdef SPAWN_THREADS
+  {
+    pthread_t a_thr;
+    pthread_t b_thr;
+    int status;
+
+    printf("%s:%d - %s - a_thr:%p - b_thr:%p\n",
+           __FILE__,__LINE__,__FUNCTION__,a_thr.p,b_thr.p);
+
+    status = pthread_create(&a_thr, NULL, _thread, (void*) 1 );
+    if ( status != 0 ) {
+      printf("Failed to create thread 1\n");
+      return (-1);
+    }
+
+    status = pthread_create(&b_thr, NULL, _thread, (void*) 2 );
+    if ( status != 0 ) {
+      printf("Failed to create thread 2\n");
+      return (-1);
+    }
+
+    status = pthread_join(a_thr, NULL);
+    if ( status != 0 ) {
+      printf("Failed to join thread 1\n");
+      return (-1);
+    }
+    printf("Joined thread1\n");
+
+    status = pthread_join(b_thr, NULL);
+    if ( status != 0 ) {
+      printf("Failed to join thread 2\n");
+      return (-1);
+    }
+    printf("Joined thread2\n");
+  }
+#endif // SPAWN_THREADS
+
+  short OK = 0;
+  // Check that we have OpenMP before declaring things OK formally.
+#ifdef _OPENMP
+    OK = 1;
+    {
+      short i;
+      for (i=0;i<3;i++) OK &= ThreadOK[i];
+    }
+    if (OK) printf("OMP : All looks good\n");
+    else printf("OMP : Error\n");
+#else
+    printf("OpenMP seems not enabled ...\n");
+#endif
+
+  return OK?0:1;
+}
+
+//g++ -fopenmp omp_test.c -o omp_test -lpthread
+
diff --git a/src/include/pthread/tests/priority1.c b/src/include/pthread/tests/priority1.c
new file mode 100644
index 0000000..7f29a46
--- /dev/null
+++ b/src/include/pthread/tests/priority1.c
@@ -0,0 +1,170 @@
+/*
+ * File: priority1.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis:
+ * - Test thread priority explicit setting using thread attribute.
+ *
+ * Test Method (Validation or Falsification):
+ * - 
+ *
+ * Requirements Tested:
+ * -
+ *
+ * Features Tested:
+ * -
+ *
+ * Cases Tested:
+ * -
+ *
+ * Description:
+ * -
+ *
+ * Environment:
+ * -
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * -
+ *
+ * Pass Criteria:
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - Process returns non-zero exit status.
+ */
+
+#include "test.h"
+
+enum {
+  PTW32TEST_THREAD_INIT_PRIO = 0,
+  PTW32TEST_MAXPRIORITIES = 512
+};
+
+int minPrio;
+int maxPrio;
+int validPriorities[PTW32TEST_MAXPRIORITIES];
+
+void *
+func(void * arg)
+{
+  int policy;
+  struct sched_param param;
+  pthread_t threadID = pthread_self();
+
+  assert(pthread_getschedparam(threadID, &policy, &param) == 0);
+  assert(policy == SCHED_OTHER);
+  return (void *) (size_t)(param.sched_priority);
+}
+
+void *
+getValidPriorities(void * arg)
+{
+  int prioSet;
+  pthread_t threadID = pthread_self();
+  HANDLE threadH = pthread_getw32threadhandle_np(threadID);
+
+  printf("Using GetThreadPriority\n");
+  printf("%10s %10s\n", "Set value", "Get value");
+
+  for (prioSet = minPrio;
+       prioSet <= maxPrio;
+       prioSet++)
+    {
+	/*
+       * If prioSet is invalid then the threads priority is unchanged
+       * from the previous value. Make the previous value a known
+       * one so that we can check later.
+       */
+        if (prioSet < 0)
+	  SetThreadPriority(threadH, THREAD_PRIORITY_LOWEST);
+        else
+	  SetThreadPriority(threadH, THREAD_PRIORITY_HIGHEST);
+	SetThreadPriority(threadH, prioSet);
+	validPriorities[prioSet+(PTW32TEST_MAXPRIORITIES/2)] = GetThreadPriority(threadH);
+	printf("%10d %10d\n", prioSet, validPriorities[prioSet+(PTW32TEST_MAXPRIORITIES/2)]);
+    }
+
+  return (void *) 0;
+}
+
+
+int
+main()
+{
+  pthread_t t;
+  pthread_attr_t attr;
+  void * result = NULL;
+  struct sched_param param;
+
+  assert((maxPrio = sched_get_priority_max(SCHED_OTHER)) != -1);
+  assert((minPrio = sched_get_priority_min(SCHED_OTHER)) != -1);
+
+  assert(pthread_create(&t, NULL, getValidPriorities, NULL) == 0);
+  assert(pthread_join(t, &result) == 0);
+
+  assert(pthread_attr_init(&attr) == 0);
+  assert(pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED) == 0);
+
+  /* Set the thread's priority to a known initial value. */
+  SetThreadPriority(pthread_getw32threadhandle_np(pthread_self()),
+                    PTW32TEST_THREAD_INIT_PRIO);
+
+  printf("Using pthread_getschedparam\n");
+  printf("%10s %10s %10s\n", "Set value", "Get value", "Win priority");
+
+  for (param.sched_priority = minPrio;
+       param.sched_priority <= maxPrio;
+       param.sched_priority++)
+    {
+      int prio;
+
+      assert(pthread_attr_setschedparam(&attr, &param) == 0);
+      assert(pthread_create(&t, &attr, func, (void *) &attr) == 0);
+
+      assert((prio = GetThreadPriority(pthread_getw32threadhandle_np(t)))
+             == validPriorities[param.sched_priority+(PTW32TEST_MAXPRIORITIES/2)]);
+
+      assert(pthread_join(t, &result) == 0);
+
+      assert(param.sched_priority == (int)(size_t) result);
+      printf("%10d %10d %10d\n", param.sched_priority, (int)(size_t) result, prio);
+    }
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/priority2.c b/src/include/pthread/tests/priority2.c
new file mode 100644
index 0000000..0396314
--- /dev/null
+++ b/src/include/pthread/tests/priority2.c
@@ -0,0 +1,167 @@
+/*
+ * File: priority2.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis:
+ * - Test thread priority setting after creation.
+ *
+ * Test Method (Validation or Falsification):
+ * - 
+ *
+ * Requirements Tested:
+ * -
+ *
+ * Features Tested:
+ * -
+ *
+ * Cases Tested:
+ * -
+ *
+ * Description:
+ * -
+ *
+ * Environment:
+ * -
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * -
+ *
+ * Pass Criteria:
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - Process returns non-zero exit status.
+ */
+
+#include "test.h"
+
+enum {
+  PTW32TEST_THREAD_INIT_PRIO = 0,
+  PTW32TEST_MAXPRIORITIES = 512
+};
+
+int minPrio;
+int maxPrio;
+int validPriorities[PTW32TEST_MAXPRIORITIES];
+pthread_barrier_t startBarrier, endBarrier;
+
+void * func(void * arg)
+{
+  int policy;
+  int result;
+  struct sched_param param;
+
+  result = pthread_barrier_wait(&startBarrier);
+  assert(result == 0 || result == PTHREAD_BARRIER_SERIAL_THREAD);
+  assert(pthread_getschedparam(pthread_self(), &policy, &param) == 0);
+  assert(policy == SCHED_OTHER);
+  result = pthread_barrier_wait(&endBarrier);
+  assert(result == 0 || result == PTHREAD_BARRIER_SERIAL_THREAD);
+  return (void *) (size_t)param.sched_priority;
+}
+
+
+void *
+getValidPriorities(void * arg)
+{
+  int prioSet;
+  pthread_t thread = pthread_self();
+  HANDLE threadH = pthread_getw32threadhandle_np(thread);
+  struct sched_param param;
+
+  for (prioSet = minPrio;
+       prioSet <= maxPrio;
+       prioSet++)
+    {
+	/*
+       * If prioSet is invalid then the threads priority is unchanged
+       * from the previous value. Make the previous value a known
+       * one so that we can check later.
+       */
+        param.sched_priority = prioSet;
+	assert(pthread_setschedparam(thread, SCHED_OTHER, &param) == 0);
+	validPriorities[prioSet+(PTW32TEST_MAXPRIORITIES/2)] = GetThreadPriority(threadH);
+    }
+
+  return (void *) 0;
+}
+
+
+int
+main()
+{
+  pthread_t t;
+  void * result = NULL;
+  int result2;
+  struct sched_param param;
+
+  assert((maxPrio = sched_get_priority_max(SCHED_OTHER)) != -1);
+  assert((minPrio = sched_get_priority_min(SCHED_OTHER)) != -1);
+
+  assert(pthread_create(&t, NULL, getValidPriorities, NULL) == 0);
+  assert(pthread_join(t, &result) == 0);
+
+  assert(pthread_barrier_init(&startBarrier, NULL, 2) == 0);
+  assert(pthread_barrier_init(&endBarrier, NULL, 2) == 0);
+
+  /* Set the thread's priority to a known initial value.
+   * If the new priority is invalid then the threads priority
+   * is unchanged from the previous value.
+   */
+  SetThreadPriority(pthread_getw32threadhandle_np(pthread_self()),
+                    PTW32TEST_THREAD_INIT_PRIO);
+
+  for (param.sched_priority = minPrio;
+       param.sched_priority <= maxPrio;
+       param.sched_priority++)
+    {
+      assert(pthread_create(&t, NULL, func, NULL) == 0);
+      assert(pthread_setschedparam(t, SCHED_OTHER, &param) == 0);
+      result2 = pthread_barrier_wait(&startBarrier);
+      assert(result2 == 0 || result2 == PTHREAD_BARRIER_SERIAL_THREAD);
+      result2 = pthread_barrier_wait(&endBarrier);
+      assert(result2 == 0 || result2 == PTHREAD_BARRIER_SERIAL_THREAD);
+      assert(GetThreadPriority(pthread_getw32threadhandle_np(t)) ==
+	  validPriorities[param.sched_priority+(PTW32TEST_MAXPRIORITIES/2)]);
+      pthread_join(t, &result);
+      assert(param.sched_priority == (int)(size_t)result);
+    }
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/reinit1.c b/src/include/pthread/tests/reinit1.c
new file mode 100644
index 0000000..81fc4ff
--- /dev/null
+++ b/src/include/pthread/tests/reinit1.c
@@ -0,0 +1,154 @@
+/*
+ * reinit1.c
+ *
+ * Same test as rwlock7.c but loop two or more times reinitialising the library
+ * each time, to test reinitialisation. We use a rwlock test because rw locks
+ * use CVs, mutexes and semaphores internally.
+ *
+ * rwlock7.c description:
+ * Hammer on a bunch of rwlocks to test robustness and fairness.
+ * Printed stats should be roughly even for each thread.
+ */
+
+#include "test.h"
+#include <sys/timeb.h>
+
+#ifdef __GNUC__
+#include <stdlib.h>
+#endif
+
+#define THREADS         5
+#define DATASIZE        7
+#define ITERATIONS      1000000
+#define LOOPS           3
+
+/*
+ * Keep statistics for each thread.
+ */
+typedef struct thread_tag {
+  int         thread_num;
+  pthread_t   thread_id;
+  int         updates;
+  int         reads;
+  int         changed;
+  int         seed;
+} thread_t;
+
+/*
+ * Read-write lock and shared data
+ */
+typedef struct data_tag {
+  pthread_rwlock_t    lock;
+  int                 data;
+  int                 updates;
+} data_t;
+
+static thread_t threads[THREADS];
+static data_t data[DATASIZE];
+
+/*
+ * Thread start routine that uses read-write locks
+ */
+void *thread_routine (void *arg)
+{
+  thread_t *self = (thread_t*)arg;
+  int iteration;
+  int element = 0;
+  int seed = self->seed;
+  int interval = 1 + rand_r (&seed) % 71;
+
+  self->changed = 0;
+
+  assert(pthread_getunique_np(self->thread_id) == (unsigned __int64)(self->thread_num + 2));
+
+  for (iteration = 0; iteration < ITERATIONS; iteration++)
+    {
+      /*
+       * Each "self->interval" iterations, perform an
+       * update operation (write lock instead of read
+       * lock).
+       */
+      if ((iteration % interval) == 0)
+        {
+          assert(pthread_rwlock_wrlock (&data[element].lock) == 0);
+          data[element].data = self->thread_num;
+          data[element].updates++;
+          self->updates++;
+	  interval = 1 + rand_r (&seed) % 71;
+          assert(pthread_rwlock_unlock (&data[element].lock) == 0);
+        } else {
+          /*
+           * Look at the current data element to see whether
+           * the current thread last updated it. Count the
+           * times, to report later.
+           */
+          assert(pthread_rwlock_rdlock (&data[element].lock) == 0);
+
+          self->reads++;
+
+          if (data[element].data != self->thread_num)
+            {
+              self->changed++;
+	      interval = 1 + self->changed % 71;
+            }
+
+          assert(pthread_rwlock_unlock (&data[element].lock) == 0);
+        }
+
+      element = (element + 1) % DATASIZE;
+
+    }
+
+  return NULL;
+}
+
+int
+main (int argc, char *argv[])
+{
+  int count;
+  int data_count;
+  int reinit_count;
+  int seed = 1;
+
+  for (reinit_count = 0; reinit_count < LOOPS; reinit_count++)
+    {
+      /*
+       * Initialize the shared data.
+       */
+      for (data_count = 0; data_count < DATASIZE; data_count++)
+        {
+          data[data_count].data = 0;
+          data[data_count].updates = 0;
+
+          assert(pthread_rwlock_init (&data[data_count].lock, NULL) == 0);
+        }
+
+      /*
+       * Create THREADS threads to access shared data.
+       */
+      for (count = 0; count < THREADS; count++)
+        {
+          threads[count].thread_num = count;
+          threads[count].updates = 0;
+          threads[count].reads = 0;
+          threads[count].seed = 1 + rand_r (&seed) % 71;
+
+          assert(pthread_create (&threads[count].thread_id,
+                                 NULL, thread_routine, (void*)(size_t)&threads[count]) == 0);
+        }
+
+      /*
+       * Wait for all threads to complete, and collect
+       * statistics.
+       */
+      for (count = 0; count < THREADS; count++)
+        {
+          assert(pthread_join (threads[count].thread_id, NULL) == 0);
+        }
+
+      pthread_win32_process_detach_np();
+      pthread_win32_process_attach_np();
+    }
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/reuse1.c b/src/include/pthread/tests/reuse1.c
new file mode 100644
index 0000000..ac6158d
--- /dev/null
+++ b/src/include/pthread/tests/reuse1.c
@@ -0,0 +1,122 @@
+/*
+ * File: reuse1.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis:
+ * - Confirm that thread reuse works for joined threads.
+ *
+ * Test Method (Validation or Falsification):
+ * -
+ *
+ * Requirements Tested:
+ * -
+ *
+ * Features Tested:
+ * -
+ *
+ * Cases Tested:
+ * -
+ *
+ * Description:
+ * -
+ *
+ * Environment:
+ * -
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * -
+ *
+ * Pass Criteria:
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - Process returns non-zero exit status.
+ */
+
+#include "test.h"
+
+enum {
+	NUMTHREADS = 100
+};
+
+static int washere = 0;
+
+void * func(void * arg)
+{
+  washere = 1;
+  return arg; 
+}
+ 
+int
+main()
+{
+  pthread_t t,
+            last_t;
+  pthread_attr_t attr;
+  void * result = NULL;
+  int i;
+
+  assert(pthread_attr_init(&attr) == 0);;
+  assert(pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE) == 0);
+
+  washere = 0;
+  assert(pthread_create(&t, &attr, func, NULL) == 0);
+  assert(pthread_join(t, &result) == 0);;
+  assert((int)(size_t)result == 0);
+  assert(washere == 1);
+  last_t = t;
+
+  for (i = 1; i < NUMTHREADS; i++)
+    {
+      washere = 0;
+      assert(pthread_create(&t, &attr, func, (void *)(size_t)i) == 0);
+      pthread_join(t, &result);
+      assert((int)(size_t) result == i);
+      assert(washere == 1);
+      /* thread IDs should be unique */
+      assert(!pthread_equal(t, last_t));
+      /* thread struct pointers should be the same */
+      assert(t.p == last_t.p);
+      /* thread handle reuse counter should be different by one */
+      assert(t.x == last_t.x+1);
+      last_t = t;
+    }
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/reuse2.c b/src/include/pthread/tests/reuse2.c
new file mode 100644
index 0000000..33a8fcb
--- /dev/null
+++ b/src/include/pthread/tests/reuse2.c
@@ -0,0 +1,166 @@
+/*
+ * File: reuse2.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis:
+ * - Test that thread reuse works for detached threads.
+ * - Analyse thread struct reuse.
+ *
+ * Test Method (Validation or Falsification):
+ * -
+ *
+ * Requirements Tested:
+ * -
+ *
+ * Features Tested:
+ * -
+ *
+ * Cases Tested:
+ * -
+ *
+ * Description:
+ * -
+ *
+ * Environment:
+ * - This test is implementation specific
+ * because it uses knowledge of internals that should be
+ * opaque to an application.
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * -
+ *
+ * Pass Criteria:
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - Process returns non-zero exit status.
+ */
+
+#include "test.h"
+
+/*
+ */
+
+enum {
+	NUMTHREADS = 10000
+};
+
+
+static long done = 0;
+
+void * func(void * arg)
+{
+  sched_yield();
+
+  InterlockedIncrement(&done);
+
+  return (void *) 0; 
+}
+ 
+int
+main()
+{
+  pthread_t t[NUMTHREADS];
+  pthread_attr_t attr;
+  int i;
+  unsigned int notUnique = 0,
+	       totalHandles = 0,
+	       reuseMax = 0,
+	       reuseMin = NUMTHREADS;
+
+  assert(pthread_attr_init(&attr) == 0);
+  assert(pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED) == 0);
+
+  for (i = 0; i < NUMTHREADS; i++)
+    {
+      while(pthread_create(&t[i], &attr, func, NULL) != 0)
+        Sleep(1);
+    }
+
+  while (NUMTHREADS > InterlockedExchangeAdd((LPLONG)&done, 0L))
+    Sleep(100);
+
+  Sleep(100);
+
+  /*
+   * Analyse reuse by computing min and max number of times pthread_create()
+   * returned the same pthread_t value.
+   */
+  for (i = 0; i < NUMTHREADS; i++)
+    {
+      if (t[i].p != NULL)
+        {
+          unsigned int j, thisMax;
+
+          thisMax = t[i].x;
+
+          for (j = i+1; j < NUMTHREADS; j++)
+            if (t[i].p == t[j].p)
+              {
+		if (t[i].x == t[j].x)
+		  notUnique++;
+                if (thisMax < t[j].x)
+                  thisMax = t[j].x;
+                t[j].p = NULL;
+              }
+
+          if (reuseMin > thisMax)
+            reuseMin = thisMax;
+
+          if (reuseMax < thisMax)
+            reuseMax = thisMax;
+        }
+    }
+
+  for (i = 0; i < NUMTHREADS; i++)
+    if (t[i].p != NULL)
+      totalHandles++;
+
+  /*
+   * pthread_t reuse counts start at 0, so we need to add 1
+   * to the max and min values derived above.
+   */
+  printf("For %d total threads:\n", NUMTHREADS);
+  printf("Non-unique IDs = %d\n", notUnique);
+  printf("Reuse maximum  = %d\n", reuseMax + 1);
+  printf("Reuse minimum  = %d\n", reuseMin + 1);
+  printf("Total handles  = %d\n", totalHandles);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/robust1.c b/src/include/pthread/tests/robust1.c
new file mode 100644
index 0000000..db597c8
--- /dev/null
+++ b/src/include/pthread/tests/robust1.c
@@ -0,0 +1,139 @@
+/* 
+ * robust1.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * For all robust mutex types.
+ * Thread A locks mutex
+ * Thread A terminates with no threads waiting on robust mutex
+ * Thread B acquires (inherits) mutex and unlocks
+ * Main attempts to lock mutex with unrecovered state.
+ *
+ * Depends on API functions: 
+ *      pthread_create()
+ *      pthread_join()
+ *	pthread_mutex_init()
+ *	pthread_mutex_lock()
+ *	pthread_mutex_unlock()
+ *	pthread_mutex_destroy()
+ *	pthread_mutexattr_init()
+ *	pthread_mutexattr_setrobust()
+ *	pthread_mutexattr_settype()
+ *	pthread_mutexattr_destroy()
+ */
+
+#include "test.h"
+
+static int lockCount;
+
+static pthread_mutex_t mutex;
+
+void * owner(void * arg)
+{
+  assert(pthread_mutex_lock(&mutex) == 0);
+  lockCount++;
+
+  return 0;
+}
+ 
+void * inheritor(void * arg)
+{
+  assert(pthread_mutex_lock(&mutex) == EOWNERDEAD);
+  lockCount++;
+  assert(pthread_mutex_unlock(&mutex) == 0);
+
+  return 0;
+}
+ 
+int
+main()
+{
+  pthread_t to, ti;
+  pthread_mutexattr_t ma;
+
+  assert(pthread_mutexattr_init(&ma) == 0);
+  assert(pthread_mutexattr_setrobust(&ma, PTHREAD_MUTEX_ROBUST) == 0);
+
+  /* Default (NORMAL) type */ 
+  lockCount = 0;
+  assert(pthread_mutex_init(&mutex, &ma) == 0);
+  assert(pthread_create(&to, NULL, owner, NULL) == 0);
+  assert(pthread_join(to, NULL) == 0);
+  assert(pthread_create(&ti, NULL, inheritor, NULL) == 0);
+  assert(pthread_join(ti, NULL) == 0);
+  assert(lockCount == 2);
+  assert(pthread_mutex_lock(&mutex) == ENOTRECOVERABLE);
+  assert(pthread_mutex_unlock(&mutex) == EPERM);
+  assert(pthread_mutex_destroy(&mutex) == 0);
+
+  /* NORMAL type */ 
+  lockCount = 0;
+  assert(pthread_mutexattr_settype(&ma, PTHREAD_MUTEX_NORMAL) == 0);
+  assert(pthread_mutex_init(&mutex, &ma) == 0);
+  assert(pthread_create(&to, NULL, owner, NULL) == 0);
+  assert(pthread_join(to, NULL) == 0);
+  assert(pthread_create(&ti, NULL, inheritor, NULL) == 0);
+  assert(pthread_join(ti, NULL) == 0);
+  assert(lockCount == 2);
+  assert(pthread_mutex_lock(&mutex) == ENOTRECOVERABLE);
+  assert(pthread_mutex_unlock(&mutex) == EPERM);
+  assert(pthread_mutex_destroy(&mutex) == 0);
+
+  /* ERRORCHECK type */ 
+  lockCount = 0;
+  assert(pthread_mutexattr_settype(&ma, PTHREAD_MUTEX_ERRORCHECK) == 0);
+  assert(pthread_mutex_init(&mutex, &ma) == 0);
+  assert(pthread_create(&to, NULL, owner, NULL) == 0);
+  assert(pthread_join(to, NULL) == 0);
+  assert(pthread_create(&ti, NULL, inheritor, NULL) == 0);
+  assert(pthread_join(ti, NULL) == 0);
+  assert(lockCount == 2);
+  assert(pthread_mutex_lock(&mutex) == ENOTRECOVERABLE);
+  assert(pthread_mutex_unlock(&mutex) == EPERM);
+  assert(pthread_mutex_destroy(&mutex) == 0);
+
+  /* RECURSIVE type */ 
+  lockCount = 0;
+  assert(pthread_mutexattr_settype(&ma, PTHREAD_MUTEX_RECURSIVE) == 0);
+  assert(pthread_mutex_init(&mutex, &ma) == 0);
+  assert(pthread_create(&to, NULL, owner, NULL) == 0);
+  assert(pthread_join(to, NULL) == 0);
+  assert(pthread_create(&ti, NULL, inheritor, NULL) == 0);
+  assert(pthread_join(ti, NULL) == 0);
+  assert(lockCount == 2);
+  assert(pthread_mutex_lock(&mutex) == ENOTRECOVERABLE);
+  assert(pthread_mutex_unlock(&mutex) == EPERM);
+  assert(pthread_mutex_destroy(&mutex) == 0);
+
+  assert(pthread_mutexattr_destroy(&ma) == 0);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/robust2.c b/src/include/pthread/tests/robust2.c
new file mode 100644
index 0000000..afdd9b9
--- /dev/null
+++ b/src/include/pthread/tests/robust2.c
@@ -0,0 +1,141 @@
+/* 
+ * robust2.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * For all robust mutex types.
+ * Thread A locks mutex
+ * Thread B blocks on mutex
+ * Thread A terminates with threads waiting on robust mutex
+ * Thread B awakes and inherits mutex and unlocks
+ * Main attempts to lock mutex with unrecovered state.
+ *
+ * Depends on API functions: 
+ *      pthread_create()
+ *      pthread_join()
+ *	pthread_mutex_init()
+ *	pthread_mutex_lock()
+ *	pthread_mutex_unlock()
+ *	pthread_mutex_destroy()
+ *	pthread_mutexattr_init()
+ *	pthread_mutexattr_setrobust()
+ *	pthread_mutexattr_settype()
+ *	pthread_mutexattr_destroy()
+ */
+
+#include "test.h"
+
+static int lockCount;
+
+static pthread_mutex_t mutex;
+
+void * owner(void * arg)
+{
+  assert(pthread_mutex_lock(&mutex) == 0);
+  lockCount++;
+  Sleep(200);
+
+  return 0;
+}
+ 
+void * inheritor(void * arg)
+{
+  assert(pthread_mutex_lock(&mutex) == EOWNERDEAD);
+  lockCount++;
+  assert(pthread_mutex_unlock(&mutex) == 0);
+
+  return 0;
+}
+ 
+int
+main()
+{
+  pthread_t to, ti;
+  pthread_mutexattr_t ma;
+
+  assert(pthread_mutexattr_init(&ma) == 0);
+  assert(pthread_mutexattr_setrobust(&ma, PTHREAD_MUTEX_ROBUST) == 0);
+
+  /* Default (NORMAL) type */ 
+  lockCount = 0;
+  assert(pthread_mutex_init(&mutex, &ma) == 0);
+  assert(pthread_create(&to, NULL, owner, NULL) == 0);
+  Sleep(100);
+  assert(pthread_create(&ti, NULL, inheritor, NULL) == 0);
+  assert(pthread_join(to, NULL) == 0);
+  assert(pthread_join(ti, NULL) == 0);
+  assert(lockCount == 2);
+  assert(pthread_mutex_lock(&mutex) == ENOTRECOVERABLE);
+  assert(pthread_mutex_destroy(&mutex) == 0);
+
+  /* NORMAL type */ 
+  lockCount = 0;
+  assert(pthread_mutexattr_settype(&ma, PTHREAD_MUTEX_NORMAL) == 0);
+  assert(pthread_mutex_init(&mutex, &ma) == 0);
+  assert(pthread_create(&to, NULL, owner, NULL) == 0);
+  Sleep(100);
+  assert(pthread_create(&ti, NULL, inheritor, NULL) == 0);
+  assert(pthread_join(to, NULL) == 0);
+  assert(pthread_join(ti, NULL) == 0);
+  assert(lockCount == 2);
+  assert(pthread_mutex_lock(&mutex) == ENOTRECOVERABLE);
+  assert(pthread_mutex_destroy(&mutex) == 0);
+
+  /* ERRORCHECK type */ 
+  lockCount = 0;
+  assert(pthread_mutexattr_settype(&ma, PTHREAD_MUTEX_ERRORCHECK) == 0);
+  assert(pthread_mutex_init(&mutex, &ma) == 0);
+  assert(pthread_create(&to, NULL, owner, NULL) == 0);
+  Sleep(100);
+  assert(pthread_create(&ti, NULL, inheritor, NULL) == 0);
+  assert(pthread_join(to, NULL) == 0);
+  assert(pthread_join(ti, NULL) == 0);
+  assert(lockCount == 2);
+  assert(pthread_mutex_lock(&mutex) == ENOTRECOVERABLE);
+  assert(pthread_mutex_destroy(&mutex) == 0);
+
+  /* RECURSIVE type */ 
+  lockCount = 0;
+  assert(pthread_mutexattr_settype(&ma, PTHREAD_MUTEX_RECURSIVE) == 0);
+  assert(pthread_mutex_init(&mutex, &ma) == 0);
+  assert(pthread_create(&to, NULL, owner, NULL) == 0);
+  Sleep(100);
+  assert(pthread_create(&ti, NULL, inheritor, NULL) == 0);
+  assert(pthread_join(to, NULL) == 0);
+  assert(pthread_join(ti, NULL) == 0);
+  assert(lockCount == 2);
+  assert(pthread_mutex_lock(&mutex) == ENOTRECOVERABLE);
+  assert(pthread_mutex_destroy(&mutex) == 0);
+
+  assert(pthread_mutexattr_destroy(&ma) == 0);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/robust3.c b/src/include/pthread/tests/robust3.c
new file mode 100644
index 0000000..ee96eef
--- /dev/null
+++ b/src/include/pthread/tests/robust3.c
@@ -0,0 +1,147 @@
+/* 
+ * robust3.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * For all robust mutex types.
+ * Thread A locks mutex
+ * Thread B blocks on mutex
+ * Thread A terminates with threads waiting on robust mutex
+ * Thread B awakes and inherits mutex, sets consistent and unlocks
+ * Main acquires mutex with recovered state.
+ *
+ * Depends on API functions: 
+ *      pthread_create()
+ *      pthread_join()
+ *	pthread_mutex_init()
+ *	pthread_mutex_lock()
+ *	pthread_mutex_unlock()
+ *	pthread_mutex_consistent()
+ *	pthread_mutex_destroy()
+ *	pthread_mutexattr_init()
+ *	pthread_mutexattr_setrobust()
+ *	pthread_mutexattr_settype()
+ *	pthread_mutexattr_destroy()
+ */
+
+#include "test.h"
+
+static int lockCount;
+
+static pthread_mutex_t mutex;
+
+void * owner(void * arg)
+{
+  assert(pthread_mutex_lock(&mutex) == 0);
+  lockCount++;
+  Sleep(200);
+
+  return 0;
+}
+ 
+void * inheritor(void * arg)
+{
+  assert(pthread_mutex_lock(&mutex) == EOWNERDEAD);
+  lockCount++;
+  assert(pthread_mutex_consistent(&mutex) == 0);
+  assert(pthread_mutex_unlock(&mutex) == 0);
+
+  return 0;
+}
+ 
+int
+main()
+{
+  pthread_t to, ti;
+  pthread_mutexattr_t ma;
+
+  assert(pthread_mutexattr_init(&ma) == 0);
+  assert(pthread_mutexattr_setrobust(&ma, PTHREAD_MUTEX_ROBUST) == 0);
+
+  /* Default (NORMAL) type */ 
+  lockCount = 0;
+  assert(pthread_mutex_init(&mutex, &ma) == 0);
+  assert(pthread_create(&to, NULL, owner, NULL) == 0);
+  Sleep(100);
+  assert(pthread_create(&ti, NULL, inheritor, NULL) == 0);
+  assert(pthread_join(to, NULL) == 0);
+  assert(pthread_join(ti, NULL) == 0);
+  assert(lockCount == 2);
+  assert(pthread_mutex_lock(&mutex) == 0);
+  assert(pthread_mutex_unlock(&mutex) == 0);
+  assert(pthread_mutex_destroy(&mutex) == 0);
+
+  /* NORMAL type */ 
+  lockCount = 0;
+  assert(pthread_mutexattr_settype(&ma, PTHREAD_MUTEX_NORMAL) == 0);
+  assert(pthread_mutex_init(&mutex, &ma) == 0);
+  assert(pthread_create(&to, NULL, owner, NULL) == 0);
+  Sleep(100);
+  assert(pthread_create(&ti, NULL, inheritor, NULL) == 0);
+  assert(pthread_join(to, NULL) == 0);
+  assert(pthread_join(ti, NULL) == 0);
+  assert(lockCount == 2);
+  assert(pthread_mutex_lock(&mutex) == 0);
+  assert(pthread_mutex_unlock(&mutex) == 0);
+  assert(pthread_mutex_destroy(&mutex) == 0);
+
+  /* ERRORCHECK type */ 
+  lockCount = 0;
+  assert(pthread_mutexattr_settype(&ma, PTHREAD_MUTEX_ERRORCHECK) == 0);
+  assert(pthread_mutex_init(&mutex, &ma) == 0);
+  assert(pthread_create(&to, NULL, owner, NULL) == 0);
+  Sleep(100);
+  assert(pthread_create(&ti, NULL, inheritor, NULL) == 0);
+  assert(pthread_join(to, NULL) == 0);
+  assert(pthread_join(ti, NULL) == 0);
+  assert(lockCount == 2);
+  assert(pthread_mutex_lock(&mutex) == 0);
+  assert(pthread_mutex_unlock(&mutex) == 0);
+  assert(pthread_mutex_destroy(&mutex) == 0);
+
+  /* RECURSIVE type */ 
+  lockCount = 0;
+  assert(pthread_mutexattr_settype(&ma, PTHREAD_MUTEX_RECURSIVE) == 0);
+  assert(pthread_mutex_init(&mutex, &ma) == 0);
+  assert(pthread_create(&to, NULL, owner, NULL) == 0);
+  Sleep(100);
+  assert(pthread_create(&ti, NULL, inheritor, NULL) == 0);
+  assert(pthread_join(to, NULL) == 0);
+  assert(pthread_join(ti, NULL) == 0);
+  assert(lockCount == 2);
+  assert(pthread_mutex_lock(&mutex) == 0);
+  assert(pthread_mutex_unlock(&mutex) == 0);
+  assert(pthread_mutex_destroy(&mutex) == 0);
+
+  assert(pthread_mutexattr_destroy(&ma) == 0);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/robust4.c b/src/include/pthread/tests/robust4.c
new file mode 100644
index 0000000..9e38b01
--- /dev/null
+++ b/src/include/pthread/tests/robust4.c
@@ -0,0 +1,197 @@
+/* 
+ * robust4.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Thread A locks multiple robust mutexes
+ * Thread B blocks on same mutexes in different orderings
+ * Thread A terminates with thread waiting on mutexes
+ * Thread B awakes and inherits each mutex in turn, sets consistent and unlocks
+ * Main acquires mutexes with recovered state.
+ *
+ * Depends on API functions: 
+ *      pthread_create()
+ *      pthread_join()
+ *	pthread_mutex_init()
+ *	pthread_mutex_lock()
+ *	pthread_mutex_unlock()
+ *	pthread_mutex_destroy()
+ *	pthread_mutexattr_init()
+ *	pthread_mutexattr_setrobust()
+ *	pthread_mutexattr_settype()
+ *	pthread_mutexattr_destroy()
+ */
+
+#include "test.h"
+
+static int lockCount;
+
+static pthread_mutex_t mutex[3];
+
+void * owner(void * arg)
+{
+  assert(pthread_mutex_lock(&mutex[0]) == 0);
+  lockCount++;
+  assert(pthread_mutex_lock(&mutex[1]) == 0);
+  lockCount++;
+  assert(pthread_mutex_lock(&mutex[2]) == 0);
+  lockCount++;
+  Sleep(200);
+
+  return 0;
+}
+ 
+void * inheritor(void * arg)
+{
+  int* o = (int*)arg;
+
+  assert(pthread_mutex_lock(&mutex[o[0]]) == EOWNERDEAD);
+  lockCount++;
+  assert(pthread_mutex_lock(&mutex[o[1]]) == EOWNERDEAD);
+  lockCount++;
+  assert(pthread_mutex_lock(&mutex[o[2]]) == EOWNERDEAD);
+  lockCount++;
+  assert(pthread_mutex_consistent(&mutex[o[2]]) == 0);
+  assert(pthread_mutex_consistent(&mutex[o[1]]) == 0);
+  assert(pthread_mutex_consistent(&mutex[o[0]]) == 0);
+  assert(pthread_mutex_unlock(&mutex[o[2]]) == 0);
+  assert(pthread_mutex_unlock(&mutex[o[1]]) == 0);
+  assert(pthread_mutex_unlock(&mutex[o[0]]) == 0);
+
+  return 0;
+}
+ 
+int
+main()
+{
+  pthread_t to, ti;
+  pthread_mutexattr_t ma;
+  int order[3];
+
+  assert(pthread_mutexattr_init(&ma) == 0);
+  assert(pthread_mutexattr_setrobust(&ma, PTHREAD_MUTEX_ROBUST) == 0);
+
+  order[0]=0;
+  order[1]=1;
+  order[2]=2;
+  lockCount = 0;
+  assert(pthread_mutex_init(&mutex[0], &ma) == 0);
+  assert(pthread_mutex_init(&mutex[1], &ma) == 0);
+  assert(pthread_mutex_init(&mutex[2], &ma) == 0);
+  assert(pthread_create(&to, NULL, owner, NULL) == 0);
+  Sleep(100);
+  assert(pthread_create(&ti, NULL, inheritor, (void *)order) == 0);
+  assert(pthread_join(to, NULL) == 0);
+  assert(pthread_join(ti, NULL) == 0);
+  assert(lockCount == 6);
+  assert(pthread_mutex_lock(&mutex[0]) == 0);
+  assert(pthread_mutex_unlock(&mutex[0]) == 0);
+  assert(pthread_mutex_destroy(&mutex[0]) == 0);
+  assert(pthread_mutex_lock(&mutex[1]) == 0);
+  assert(pthread_mutex_unlock(&mutex[1]) == 0);
+  assert(pthread_mutex_destroy(&mutex[1]) == 0);
+  assert(pthread_mutex_lock(&mutex[2]) == 0);
+  assert(pthread_mutex_unlock(&mutex[2]) == 0);
+  assert(pthread_mutex_destroy(&mutex[2]) == 0);
+
+  order[0]=1;
+  order[1]=0;
+  order[2]=2;
+  lockCount = 0;
+  assert(pthread_mutex_init(&mutex[0], &ma) == 0);
+  assert(pthread_mutex_init(&mutex[1], &ma) == 0);
+  assert(pthread_mutex_init(&mutex[2], &ma) == 0);
+  assert(pthread_create(&to, NULL, owner, NULL) == 0);
+  Sleep(100);
+  assert(pthread_create(&ti, NULL, inheritor, (void *)order) == 0);
+  assert(pthread_join(to, NULL) == 0);
+  assert(pthread_join(ti, NULL) == 0);
+  assert(lockCount == 6);
+  assert(pthread_mutex_lock(&mutex[0]) == 0);
+  assert(pthread_mutex_unlock(&mutex[0]) == 0);
+  assert(pthread_mutex_destroy(&mutex[0]) == 0);
+  assert(pthread_mutex_lock(&mutex[1]) == 0);
+  assert(pthread_mutex_unlock(&mutex[1]) == 0);
+  assert(pthread_mutex_destroy(&mutex[1]) == 0);
+  assert(pthread_mutex_lock(&mutex[2]) == 0);
+  assert(pthread_mutex_unlock(&mutex[2]) == 0);
+  assert(pthread_mutex_destroy(&mutex[2]) == 0);
+
+  order[0]=0;
+  order[1]=2;
+  order[2]=1;
+  lockCount = 0;
+  assert(pthread_mutex_init(&mutex[0], &ma) == 0);
+  assert(pthread_mutex_init(&mutex[1], &ma) == 0);
+  assert(pthread_mutex_init(&mutex[2], &ma) == 0);
+  assert(pthread_create(&to, NULL, owner, NULL) == 0);
+  Sleep(100);
+  assert(pthread_create(&ti, NULL, inheritor, (void *)order) == 0);
+  assert(pthread_join(to, NULL) == 0);
+  assert(pthread_join(ti, NULL) == 0);
+  assert(lockCount == 6);
+  assert(pthread_mutex_lock(&mutex[0]) == 0);
+  assert(pthread_mutex_unlock(&mutex[0]) == 0);
+  assert(pthread_mutex_destroy(&mutex[0]) == 0);
+  assert(pthread_mutex_lock(&mutex[1]) == 0);
+  assert(pthread_mutex_unlock(&mutex[1]) == 0);
+  assert(pthread_mutex_destroy(&mutex[1]) == 0);
+  assert(pthread_mutex_lock(&mutex[2]) == 0);
+  assert(pthread_mutex_unlock(&mutex[2]) == 0);
+  assert(pthread_mutex_destroy(&mutex[2]) == 0);
+
+  order[0]=2;
+  order[1]=1;
+  order[2]=0;
+  lockCount = 0;
+  assert(pthread_mutex_init(&mutex[0], &ma) == 0);
+  assert(pthread_mutex_init(&mutex[1], &ma) == 0);
+  assert(pthread_mutex_init(&mutex[2], &ma) == 0);
+  assert(pthread_create(&to, NULL, owner, NULL) == 0);
+  Sleep(100);
+  assert(pthread_create(&ti, NULL, inheritor, (void *)order) == 0);
+  assert(pthread_join(to, NULL) == 0);
+  assert(pthread_join(ti, NULL) == 0);
+  assert(lockCount == 6);
+  assert(pthread_mutex_lock(&mutex[0]) == 0);
+  assert(pthread_mutex_unlock(&mutex[0]) == 0);
+  assert(pthread_mutex_destroy(&mutex[0]) == 0);
+  assert(pthread_mutex_lock(&mutex[1]) == 0);
+  assert(pthread_mutex_unlock(&mutex[1]) == 0);
+  assert(pthread_mutex_destroy(&mutex[1]) == 0);
+  assert(pthread_mutex_lock(&mutex[2]) == 0);
+  assert(pthread_mutex_unlock(&mutex[2]) == 0);
+  assert(pthread_mutex_destroy(&mutex[2]) == 0);
+
+  assert(pthread_mutexattr_destroy(&ma) == 0);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/robust5.c b/src/include/pthread/tests/robust5.c
new file mode 100644
index 0000000..b12b343
--- /dev/null
+++ b/src/include/pthread/tests/robust5.c
@@ -0,0 +1,118 @@
+/* 
+ * robust5.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Thread A locks multiple robust mutexes
+ * Thread B blocks on same mutexes
+ * Thread A terminates with thread waiting on mutexes
+ * Thread B awakes and inherits each mutex in turn
+ * Thread B terminates leaving orphaned mutexes
+ * Main inherits mutexes, sets consistent and unlocks.
+ *
+ * Depends on API functions: 
+ *      pthread_create()
+ *      pthread_join()
+ *	pthread_mutex_init()
+ *	pthread_mutex_lock()
+ *	pthread_mutex_unlock()
+ *	pthread_mutex_destroy()
+ *	pthread_mutexattr_init()
+ *	pthread_mutexattr_setrobust()
+ *	pthread_mutexattr_settype()
+ *	pthread_mutexattr_destroy()
+ */
+
+#include "test.h"
+
+static int lockCount;
+
+static pthread_mutex_t mutex[3];
+
+void * owner(void * arg)
+{
+  assert(pthread_mutex_lock(&mutex[0]) == 0);
+  lockCount++;
+  assert(pthread_mutex_lock(&mutex[1]) == 0);
+  lockCount++;
+  assert(pthread_mutex_lock(&mutex[2]) == 0);
+  lockCount++;
+
+  return 0;
+}
+ 
+void * inheritor(void * arg)
+{
+  assert(pthread_mutex_lock(&mutex[0]) == EOWNERDEAD);
+  lockCount++;
+  assert(pthread_mutex_lock(&mutex[1]) == EOWNERDEAD);
+  lockCount++;
+  assert(pthread_mutex_lock(&mutex[2]) == EOWNERDEAD);
+  lockCount++;
+
+  return 0;
+}
+ 
+int
+main()
+{
+  pthread_t to, ti;
+  pthread_mutexattr_t ma;
+
+  assert(pthread_mutexattr_init(&ma) == 0);
+  assert(pthread_mutexattr_setrobust(&ma, PTHREAD_MUTEX_ROBUST) == 0);
+
+  lockCount = 0;
+  assert(pthread_mutex_init(&mutex[0], &ma) == 0);
+  assert(pthread_mutex_init(&mutex[1], &ma) == 0);
+  assert(pthread_mutex_init(&mutex[2], &ma) == 0);
+  assert(pthread_create(&to, NULL, owner, NULL) == 0);
+  assert(pthread_join(to, NULL) == 0);
+  assert(pthread_create(&ti, NULL, inheritor, NULL) == 0);
+  assert(pthread_join(ti, NULL) == 0);
+  assert(lockCount == 6);
+  assert(pthread_mutex_lock(&mutex[0]) == EOWNERDEAD);
+  assert(pthread_mutex_consistent(&mutex[0]) == 0);
+  assert(pthread_mutex_unlock(&mutex[0]) == 0);
+  assert(pthread_mutex_destroy(&mutex[0]) == 0);
+  assert(pthread_mutex_lock(&mutex[1]) == EOWNERDEAD);
+  assert(pthread_mutex_consistent(&mutex[1]) == 0);
+  assert(pthread_mutex_unlock(&mutex[1]) == 0);
+  assert(pthread_mutex_destroy(&mutex[1]) == 0);
+  assert(pthread_mutex_lock(&mutex[2]) == EOWNERDEAD);
+  assert(pthread_mutex_consistent(&mutex[2]) == 0);
+  assert(pthread_mutex_unlock(&mutex[2]) == 0);
+  assert(pthread_mutex_destroy(&mutex[2]) == 0);
+
+  assert(pthread_mutexattr_destroy(&ma) == 0);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/runorder.mk b/src/include/pthread/tests/runorder.mk
new file mode 100644
index 0000000..2af2c68
--- /dev/null
+++ b/src/include/pthread/tests/runorder.mk
@@ -0,0 +1,158 @@
+#
+# Common rules that define the run order of tests
+#
+benchtest1.bench:
+benchtest2.bench:
+benchtest3.bench:
+benchtest4.bench:
+benchtest5.bench:
+
+affinity1.pass: errno0.pass
+affinity2.pass: affinity1.pass
+affinity3.pass: affinity2.pass self1.pass create3.pass
+affinity4.pass: affinity3.pass
+affinity5.pass: affinity4.pass
+affinity6.pass: affinity5.pass
+barrier1.pass: semaphore4.pass
+barrier2.pass: barrier1.pass semaphore4.pass
+barrier3.pass: barrier2.pass semaphore4.pass self1.pass create3.pass join4.pass
+barrier4.pass: barrier3.pass semaphore4.pass self1.pass create3.pass join4.pass mutex8.pass
+barrier5.pass: barrier4.pass semaphore4.pass self1.pass create3.pass join4.pass mutex8.pass
+barrier6.pass: barrier5.pass semaphore4.pass self1.pass create3.pass join4.pass mutex8.pass
+cancel1.pass: self1.pass create3.pass
+cancel2.pass: self1.pass create3.pass join4.pass barrier6.pass
+cancel3.pass: self1.pass create3.pass join4.pass context1.pass
+cancel4.pass: cancel3.pass self1.pass create3.pass join4.pass
+cancel5.pass: cancel3.pass self1.pass create3.pass join4.pass
+cancel6a.pass: cancel3.pass self1.pass create3.pass join4.pass
+cancel6d.pass: cancel3.pass self1.pass create3.pass join4.pass
+cancel7.pass: self1.pass create3.pass join4.pass kill1.pass
+cancel8.pass: cancel7.pass self1.pass mutex8.pass kill1.pass
+cancel9.pass: cancel8.pass self1.pass create3.pass join4.pass mutex8.pass kill1.pass
+cleanup0.pass: self1.pass create3.pass join4.pass mutex8.pass cancel5.pass
+cleanup1.pass: cleanup0.pass
+cleanup2.pass: cleanup1.pass
+cleanup3.pass: cleanup2.pass
+condvar1.pass: self1.pass create3.pass semaphore1.pass mutex8.pass
+condvar1_1.pass: condvar1.pass
+condvar1_2.pass: join2.pass
+condvar2.pass: condvar1.pass
+condvar2_1.pass: condvar2.pass join2.pass
+condvar3.pass: create1.pass condvar2.pass
+condvar3_1.pass: condvar3.pass join2.pass
+condvar3_2.pass: condvar3_1.pass
+condvar3_3.pass: condvar3_2.pass
+condvar4.pass: create1.pass
+condvar5.pass: condvar4.pass
+condvar6.pass: condvar5.pass
+condvar7.pass: condvar6.pass cleanup1.pass
+condvar8.pass: condvar7.pass
+condvar9.pass: condvar8.pass
+context1.pass: cancel1.pass
+count1.pass: join1.pass
+create1.pass: mutex2.pass
+create2.pass: create1.pass
+create3.pass: create2.pass
+delay1.pass: self1.pass create3.pass
+delay2.pass: delay1.pass
+detach1.pass: join0.pass
+equal1.pass: self1.pass create1.pass
+errno0.pass: sizes.pass
+errno1.pass: mutex3.pass
+exception1.pass: cancel4.pass
+exception2.pass: exception1.pass
+exception3_0.pass: exception2.pass
+exception3.pass: exception3_0.pass
+exit1.pass: self1.pass create3.pass
+exit2.pass: create1.pass
+exit3.pass: create1.pass
+exit4.pass: self1.pass create3.pass 
+exit5.pass: exit4.pass kill1.pass
+exit6.pass: exit5.pass
+eyal1.pass: self1.pass create3.pass mutex8.pass tsd1.pass
+inherit1.pass: join1.pass priority1.pass
+join0.pass: create1.pass
+join1.pass: create1.pass
+join2.pass: create1.pass
+join3.pass: join2.pass
+join4.pass: join3.pass
+kill1.pass: self1.pass
+mutex1.pass: mutex5.pass
+mutex1n.pass: mutex1.pass
+mutex1e.pass: mutex1.pass
+mutex1r.pass: mutex1.pass
+mutex2.pass: mutex1.pass
+mutex2r.pass: mutex2.pass
+mutex2e.pass: mutex2.pass
+mutex3.pass: create1.pass
+mutex3r.pass: mutex3.pass
+mutex3e.pass: mutex3.pass
+mutex4.pass: mutex3.pass
+mutex5.pass: sizes.pass
+mutex6.pass: mutex4.pass
+mutex6n.pass: mutex4.pass
+mutex6e.pass: mutex4.pass
+mutex6r.pass: mutex4.pass
+mutex6s.pass: mutex6.pass
+mutex6rs.pass: mutex6r.pass
+mutex6es.pass: mutex6e.pass
+mutex7.pass: mutex6.pass
+mutex7n.pass: mutex6n.pass
+mutex7e.pass: mutex6e.pass
+mutex7r.pass: mutex6r.pass
+mutex8.pass: mutex7.pass
+mutex8n.pass: mutex7n.pass
+mutex8e.pass: mutex7e.pass
+mutex8r.pass: mutex7r.pass
+name_np1.pass: join4.pass barrier6.pass
+name_np2.pass: name_np1.pass
+once1.pass: create1.pass
+once2.pass: once1.pass
+once3.pass: once2.pass
+once4.pass: once3.pass
+priority1.pass: join1.pass
+priority2.pass: priority1.pass barrier3.pass
+reinit1.pass: rwlock7.pass
+reuse1.pass: create3.pass
+reuse2.pass: reuse1.pass
+robust1.pass: mutex8r.pass
+robust2.pass: mutex8r.pass
+robust3.pass: robust2.pass
+robust4.pass: robust3.pass
+robust5.pass: robust4.pass
+rwlock1.pass: condvar6.pass
+rwlock2.pass: rwlock1.pass
+rwlock3.pass: rwlock2.pass join2.pass
+rwlock4.pass: rwlock3.pass
+rwlock5.pass: rwlock4.pass
+rwlock6.pass: rwlock5.pass
+rwlock7.pass: rwlock6.pass
+rwlock8.pass: rwlock7.pass
+rwlock2_t.pass: rwlock2.pass
+rwlock3_t.pass: rwlock2_t.pass
+rwlock4_t.pass: rwlock3_t.pass
+rwlock5_t.pass: rwlock4_t.pass
+rwlock6_t.pass: rwlock5_t.pass
+rwlock6_t2.pass: rwlock6_t.pass
+self1.pass: sizes.pass
+self2.pass: self1.pass equal1.pass create1.pass
+semaphore1.pass: sizes.pass
+semaphore2.pass: semaphore1.pass
+semaphore3.pass: semaphore2.pass
+semaphore4.pass: semaphore3.pass cancel1.pass
+semaphore4t.pass: semaphore4.pass
+semaphore5.pass: semaphore4.pass
+sequence1.pass: reuse2.pass
+sizes.pass: 
+spin1.pass: self1.pass create3.pass mutex8.pass
+spin2.pass: spin1.pass
+spin3.pass: spin2.pass
+spin4.pass: spin3.pass
+stress1.pass: create3.pass mutex8.pass barrier6.pass
+threestage.pass: stress1.pass
+timeouts.pass: condvar9.pass
+tsd1.pass: barrier5.pass join1.pass
+tsd2.pass: tsd1.pass
+tsd3.pass: tsd2.pass
+valid1.pass: join1.pass
+valid2.pass: valid1.pass
diff --git a/src/include/pthread/tests/rwlock1.c b/src/include/pthread/tests/rwlock1.c
new file mode 100644
index 0000000..1ce05b9
--- /dev/null
+++ b/src/include/pthread/tests/rwlock1.c
@@ -0,0 +1,59 @@
+/* 
+ * rwlock1.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Create a simple rwlock object and then destroy it.
+ *
+ * Depends on API functions:
+ * 	pthread_rwlock_init()
+ *	pthread_rwlock_destroy()
+ */
+
+#include "test.h"
+
+pthread_rwlock_t rwlock = NULL;
+
+int
+main()
+{
+  assert(rwlock == NULL);
+
+  assert(pthread_rwlock_init(&rwlock, NULL) == 0);
+
+  assert(rwlock != NULL);
+
+  assert(pthread_rwlock_destroy(&rwlock) == 0);
+
+  assert(rwlock == NULL);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/rwlock2.c b/src/include/pthread/tests/rwlock2.c
new file mode 100644
index 0000000..4b2251b
--- /dev/null
+++ b/src/include/pthread/tests/rwlock2.c
@@ -0,0 +1,64 @@
+/* 
+ * rwlock2.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Declare a static rwlock object, lock it, 
+ * and then unlock it again.
+ *
+ * Depends on API functions: 
+ *	pthread_rwlock_rdlock()
+ *	pthread_rwlock_unlock()
+ */
+
+#include "test.h"
+ 
+pthread_rwlock_t rwlock = PTHREAD_RWLOCK_INITIALIZER;
+
+int
+main()
+{
+  assert(rwlock == PTHREAD_RWLOCK_INITIALIZER);
+
+  assert(pthread_rwlock_rdlock(&rwlock) == 0);
+
+  assert(rwlock != PTHREAD_RWLOCK_INITIALIZER);
+
+  assert(rwlock != NULL);
+
+  assert(pthread_rwlock_unlock(&rwlock) == 0);
+
+  assert(pthread_rwlock_destroy(&rwlock) == 0);
+
+  assert(rwlock == NULL);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/rwlock2_t.c b/src/include/pthread/tests/rwlock2_t.c
new file mode 100644
index 0000000..e879793
--- /dev/null
+++ b/src/include/pthread/tests/rwlock2_t.c
@@ -0,0 +1,69 @@
+/* 
+ * rwlock2_t.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Declare a static rwlock object, timed-lock it, 
+ * and then unlock it again.
+ *
+ * Depends on API functions:
+ *	pthread_rwlock_timedrdlock()
+ *	pthread_rwlock_unlock()
+ */
+
+#include "test.h"
+#include <sys/timeb.h>
+
+pthread_rwlock_t rwlock = PTHREAD_RWLOCK_INITIALIZER;
+
+int
+main()
+{
+  struct timespec abstime, reltime = { 1, 0 };
+
+  (void) pthread_win32_getabstime_np(&abstime, &reltime);
+
+  assert(rwlock == PTHREAD_RWLOCK_INITIALIZER);
+
+  assert(pthread_rwlock_timedrdlock(&rwlock, &abstime) == 0);
+
+  assert(rwlock != PTHREAD_RWLOCK_INITIALIZER);
+
+  assert(rwlock != NULL);
+
+  assert(pthread_rwlock_unlock(&rwlock) == 0);
+
+  assert(pthread_rwlock_destroy(&rwlock) == 0);
+
+  assert(rwlock == NULL);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/rwlock3.c b/src/include/pthread/tests/rwlock3.c
new file mode 100644
index 0000000..dd46ea4
--- /dev/null
+++ b/src/include/pthread/tests/rwlock3.c
@@ -0,0 +1,76 @@
+/* 
+ * rwlock3.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Declare a static rwlock object, wrlock it, trywrlock it, 
+ * and then unlock it again.
+ *
+ * Depends on API functions: 
+ *	pthread_create()
+ *	pthread_join()
+ *	pthread_rwlock_wrlock()
+ *	pthread_rwlock_trywrlock()
+ *	pthread_rwlock_unlock()
+ */
+
+#include "test.h"
+ 
+pthread_rwlock_t rwlock1 = PTHREAD_RWLOCK_INITIALIZER;
+
+static int washere = 0;
+
+void * func(void * arg)
+{
+  assert(pthread_rwlock_trywrlock(&rwlock1) == EBUSY);
+
+  washere = 1;
+
+  return 0; 
+}
+ 
+int
+main()
+{
+  pthread_t t;
+
+  assert(pthread_rwlock_wrlock(&rwlock1) == 0);
+
+  assert(pthread_create(&t, NULL, func, NULL) == 0);
+
+  assert(pthread_join(t, NULL) == 0);
+
+  assert(pthread_rwlock_unlock(&rwlock1) == 0);
+
+  assert(washere == 1);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/rwlock3_t.c b/src/include/pthread/tests/rwlock3_t.c
new file mode 100644
index 0000000..318e515
--- /dev/null
+++ b/src/include/pthread/tests/rwlock3_t.c
@@ -0,0 +1,78 @@
+/* 
+ * rwlock3_t.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Declare a static rwlock object, timed-wrlock it, trywrlock it, 
+ * and then unlock it again.
+ *
+ * Depends on API functions: 
+ *	pthread_rwlock_timedwrlock()
+ *	pthread_rwlock_trywrlock()
+ *	pthread_rwlock_unlock()
+ */
+
+#include "test.h"
+#include <sys/timeb.h>
+
+pthread_rwlock_t rwlock1 = PTHREAD_RWLOCK_INITIALIZER;
+
+static int washere = 0;
+
+void * func(void * arg)
+{
+  assert(pthread_rwlock_trywrlock(&rwlock1) == EBUSY);
+
+  washere = 1;
+
+  return 0; 
+}
+ 
+int
+main()
+{
+  pthread_t t;
+  struct timespec abstime, reltime = { 1, 0 };
+
+  (void) pthread_win32_getabstime_np(&abstime, &reltime);
+
+  assert(pthread_rwlock_timedwrlock(&rwlock1, &abstime) == 0);
+
+  assert(pthread_create(&t, NULL, func, NULL) == 0);
+
+  Sleep(2000);
+
+  assert(pthread_rwlock_unlock(&rwlock1) == 0);
+
+  assert(washere == 1);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/rwlock4.c b/src/include/pthread/tests/rwlock4.c
new file mode 100644
index 0000000..3b71b17
--- /dev/null
+++ b/src/include/pthread/tests/rwlock4.c
@@ -0,0 +1,76 @@
+/* 
+ * rwlock4.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Declare a static rwlock object, rdlock it, trywrlock it, 
+ * and then unlock it again.
+ *
+ * Depends on API functions: 
+ * 	pthread_create()
+ * 	pthread_join()
+ *	pthread_rwlock_rdlock()
+ *	pthread_rwlock_trywrlock()
+ *	pthread_rwlock_unlock()
+ */
+
+#include "test.h"
+ 
+pthread_rwlock_t rwlock1 = PTHREAD_RWLOCK_INITIALIZER;
+
+static int washere = 0;
+
+void * func(void * arg)
+{
+  assert(pthread_rwlock_trywrlock(&rwlock1) == EBUSY);
+
+  washere = 1;
+
+  return 0; 
+}
+ 
+int
+main()
+{
+  pthread_t t;
+
+  assert(pthread_rwlock_rdlock(&rwlock1) == 0);
+
+  assert(pthread_create(&t, NULL, func, NULL) == 0);
+
+  assert(pthread_join(t, NULL) == 0);
+
+  assert(pthread_rwlock_unlock(&rwlock1) == 0);
+
+  assert(washere == 1);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/rwlock4_t.c b/src/include/pthread/tests/rwlock4_t.c
new file mode 100644
index 0000000..5dd206d
--- /dev/null
+++ b/src/include/pthread/tests/rwlock4_t.c
@@ -0,0 +1,77 @@
+/* 
+ * rwlock4_t.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Declare a static rwlock object, timed-rdlock it, trywrlock it, 
+ * and then unlock it again.
+ *
+ * Depends on API functions: 
+ *	pthread_rwlock_timedrdlock()
+ *	pthread_rwlock_trywrlock()
+ *	pthread_rwlock_unlock()
+ */
+
+#include "test.h"
+#include <sys/timeb.h>
+
+pthread_rwlock_t rwlock1 = PTHREAD_RWLOCK_INITIALIZER;
+
+static int washere = 0;
+
+void * func(void * arg)
+{
+  assert(pthread_rwlock_trywrlock(&rwlock1) == EBUSY);
+
+  washere = 1;
+
+  return 0; 
+}
+ 
+int
+main()
+{
+  pthread_t t;
+  struct timespec abstime = { 0, 0 };
+  struct timespec reltime = { 1, 0 };
+
+  assert(pthread_rwlock_timedrdlock(&rwlock1, pthread_win32_getabstime_np(&abstime, &reltime)) == 0);
+
+  assert(pthread_create(&t, NULL, func, NULL) == 0);
+
+  Sleep(2000);
+
+  assert(pthread_rwlock_unlock(&rwlock1) == 0);
+
+  assert(washere == 1);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/rwlock5.c b/src/include/pthread/tests/rwlock5.c
new file mode 100644
index 0000000..988e690
--- /dev/null
+++ b/src/include/pthread/tests/rwlock5.c
@@ -0,0 +1,78 @@
+/* 
+ * rwlock5.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Declare a static rwlock object, rdlock it, tryrdlock it, 
+ * and then unlock it again.
+ *
+ * Depends on API functions: 
+ *      pthread_create()
+ *      pthread_join()
+ *	pthread_rwlock_rdlock()
+ *	pthread_rwlock_tryrdlock()
+ *	pthread_rwlock_unlock()
+ */
+
+#include "test.h"
+ 
+pthread_rwlock_t rwlock1 = PTHREAD_RWLOCK_INITIALIZER;
+
+static int washere = 0;
+
+void * func(void * arg)
+{
+  assert(pthread_rwlock_tryrdlock(&rwlock1) == 0);
+
+  assert(pthread_rwlock_unlock(&rwlock1) == 0);
+
+  washere = 1;
+
+  return 0; 
+}
+ 
+int
+main()
+{
+  pthread_t t;
+
+  assert(pthread_rwlock_rdlock(&rwlock1) == 0);
+
+  assert(pthread_create(&t, NULL, func, NULL) == 0);
+
+  assert(pthread_join(t, NULL) == 0);
+
+  assert(pthread_rwlock_unlock(&rwlock1) == 0);
+
+  assert(washere == 1);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/rwlock5_t.c b/src/include/pthread/tests/rwlock5_t.c
new file mode 100644
index 0000000..8cf55c4
--- /dev/null
+++ b/src/include/pthread/tests/rwlock5_t.c
@@ -0,0 +1,80 @@
+/* 
+ * rwlock5_t.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Declare a static rwlock object, timed-rdlock it, tryrdlock it, 
+ * and then unlock it again.
+ *
+ * Depends on API functions: 
+ *	pthread_rwlock_timedrdlock()
+ *	pthread_rwlock_tryrdlock()
+ *	pthread_rwlock_unlock()
+ */
+
+#include "test.h"
+#include <sys/timeb.h>
+
+pthread_rwlock_t rwlock1 = PTHREAD_RWLOCK_INITIALIZER;
+
+static int washere = 0;
+
+void * func(void * arg)
+{
+  assert(pthread_rwlock_tryrdlock(&rwlock1) == 0);
+
+  assert(pthread_rwlock_unlock(&rwlock1) == 0);
+
+  washere = 1;
+
+  return 0; 
+}
+ 
+int
+main()
+{
+  pthread_t t;
+  struct timespec abstime, reltime = { 1, 0 };
+
+  (void) pthread_win32_getabstime_np(&abstime, &reltime);
+
+  assert(pthread_rwlock_timedrdlock(&rwlock1, &abstime) == 0);
+
+  assert(pthread_create(&t, NULL, func, NULL) == 0);
+
+  Sleep(2000);
+
+  assert(pthread_rwlock_unlock(&rwlock1) == 0);
+
+  assert(washere == 1);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/rwlock6.c b/src/include/pthread/tests/rwlock6.c
new file mode 100644
index 0000000..50b96ec
--- /dev/null
+++ b/src/include/pthread/tests/rwlock6.c
@@ -0,0 +1,99 @@
+/*
+ * rwlock6.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Check writer and reader locking
+ *
+ * Depends on API functions:
+ *      pthread_rwlock_rdlock()
+ *      pthread_rwlock_wrlock()
+ *      pthread_rwlock_unlock()
+ */
+
+#include "test.h"
+
+static pthread_rwlock_t rwlock1 = PTHREAD_RWLOCK_INITIALIZER;
+
+static int bankAccount = 0;
+
+void * wrfunc(void * arg)
+{
+  int ba;
+
+  assert(pthread_rwlock_wrlock(&rwlock1) == 0);
+  Sleep(200);
+  bankAccount += 10;
+  ba = bankAccount;
+  assert(pthread_rwlock_unlock(&rwlock1) == 0);
+
+  return ((void *)(size_t)ba);
+}
+
+void * rdfunc(void * arg)
+{
+  int ba;
+
+  assert(pthread_rwlock_rdlock(&rwlock1) == 0);
+  ba = bankAccount;
+  assert(pthread_rwlock_unlock(&rwlock1) == 0);
+
+  return ((void *)(size_t)ba);
+}
+
+int
+main()
+{
+  pthread_t wrt1;
+  pthread_t wrt2;
+  pthread_t rdt;
+  void* wr1Result = (void*)0;
+  void* wr2Result = (void*)0;
+  void* rdResult = (void*)0;
+
+  bankAccount = 0;
+
+  assert(pthread_create(&wrt1, NULL, wrfunc, NULL) == 0);
+  Sleep(50);
+  assert(pthread_create(&rdt, NULL, rdfunc, NULL) == 0);
+  Sleep(50);
+  assert(pthread_create(&wrt2, NULL, wrfunc, NULL) == 0);
+
+  assert(pthread_join(wrt1, &wr1Result) == 0);
+  assert(pthread_join(rdt, &rdResult) == 0);
+  assert(pthread_join(wrt2, &wr2Result) == 0);
+
+  assert((int)(size_t)wr1Result == 10);
+  assert((int)(size_t)rdResult == 10);
+  assert((int)(size_t)wr2Result == 20);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/rwlock6_t.c b/src/include/pthread/tests/rwlock6_t.c
new file mode 100644
index 0000000..a590922
--- /dev/null
+++ b/src/include/pthread/tests/rwlock6_t.c
@@ -0,0 +1,116 @@
+/*
+ * rwlock6_t.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Check writer and reader locking with reader timeouts
+ *
+ * Depends on API functions: 
+ *      pthread_rwlock_timedrdlock()
+ *      pthread_rwlock_wrlock()
+ *      pthread_rwlock_unlock()
+ */
+
+#include "test.h"
+#include <sys/timeb.h>
+
+static pthread_rwlock_t rwlock1 = PTHREAD_RWLOCK_INITIALIZER;
+
+static int bankAccount = 0;
+
+void * wrfunc(void * arg)
+{
+  assert(pthread_rwlock_wrlock(&rwlock1) == 0);
+  Sleep(2000);
+  bankAccount += 10;
+  assert(pthread_rwlock_unlock(&rwlock1) == 0);
+
+  return ((void *)(size_t)bankAccount);
+}
+
+void * rdfunc(void * arg)
+{
+  int ba = -1;
+  struct timespec abstime;
+
+  (void) pthread_win32_getabstime_np(&abstime, NULL);
+
+  if ((int) (size_t)arg == 1)
+    {
+      abstime.tv_sec += 1;
+      assert(pthread_rwlock_timedrdlock(&rwlock1, &abstime) == ETIMEDOUT);
+      ba = 0;
+    }
+  else if ((int) (size_t)arg == 2)
+    {
+      abstime.tv_sec += 3;
+      assert(pthread_rwlock_timedrdlock(&rwlock1, &abstime) == 0);
+      ba = bankAccount;
+      assert(pthread_rwlock_unlock(&rwlock1) == 0);
+    }
+
+  return ((void *)(size_t)ba);
+}
+
+int
+main()
+{
+  pthread_t wrt1;
+  pthread_t wrt2;
+  pthread_t rdt1;
+  pthread_t rdt2;
+  void* wr1Result = (void*)0;
+  void* wr2Result = (void*)0;
+  void* rd1Result = (void*)0;
+  void* rd2Result = (void*)0;
+
+  bankAccount = 0;
+
+  assert(pthread_create(&wrt1, NULL, wrfunc, NULL) == 0);
+  Sleep(500);
+  assert(pthread_create(&rdt1, NULL, rdfunc, (void *)(size_t)1) == 0);
+  Sleep(500);
+  assert(pthread_create(&wrt2, NULL, wrfunc, NULL) == 0);
+  Sleep(500);
+  assert(pthread_create(&rdt2, NULL, rdfunc, (void *)(size_t)2) == 0);
+
+  assert(pthread_join(wrt1, &wr1Result) == 0);
+  assert(pthread_join(rdt1, &rd1Result) == 0);
+  assert(pthread_join(wrt2, &wr2Result) == 0);
+  assert(pthread_join(rdt2, &rd2Result) == 0);
+
+  assert((int)(size_t)wr1Result == 10);
+  assert((int)(size_t)rd1Result == 0);
+  assert((int)(size_t)wr2Result == 20);
+  assert((int)(size_t)rd2Result == 20);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/rwlock6_t2.c b/src/include/pthread/tests/rwlock6_t2.c
new file mode 100644
index 0000000..71e957f
--- /dev/null
+++ b/src/include/pthread/tests/rwlock6_t2.c
@@ -0,0 +1,110 @@
+/*
+ * rwlock6_t2.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Check writer and reader timeouts.
+ *
+ * Depends on API functions: 
+ *      pthread_rwlock_timedrdlock()
+ *      pthread_rwlock_timedwrlock()
+ *      pthread_rwlock_unlock()
+ */
+
+#include "test.h"
+#include <sys/timeb.h>
+
+static pthread_rwlock_t rwlock1 = PTHREAD_RWLOCK_INITIALIZER;
+
+static int bankAccount = 0;
+struct timespec abstime, reltime = { 1, 0 };
+
+void * wrfunc(void * arg)
+{
+  int result;
+
+  result = pthread_rwlock_timedwrlock(&rwlock1, &abstime);
+  if ((int) (size_t)arg == 1)
+    {
+      assert(result == 0);
+      Sleep(2000);
+      bankAccount += 10;
+      assert(pthread_rwlock_unlock(&rwlock1) == 0);
+      return ((void *)(size_t)bankAccount);
+    }
+  else if ((int) (size_t)arg == 2)
+    {
+      assert(result == ETIMEDOUT);
+      return ((void *) 100);
+    }
+
+  return ((void *)(size_t)-1);
+}
+
+void * rdfunc(void * arg)
+{
+  int ba = 0;
+
+  assert(pthread_rwlock_timedrdlock(&rwlock1, &abstime) == ETIMEDOUT);
+
+  return ((void *)(size_t)ba);
+}
+
+int
+main()
+{
+  pthread_t wrt1;
+  pthread_t wrt2;
+  pthread_t rdt;
+  void* wr1Result = (void*)0;
+  void* wr2Result = (void*)0;
+  void* rdResult = (void*)0;
+
+  (void) pthread_win32_getabstime_np(&abstime, &reltime);
+
+  bankAccount = 0;
+
+  assert(pthread_create(&wrt1, NULL, wrfunc, (void *)(size_t)1) == 0);
+  Sleep(100);
+  assert(pthread_create(&rdt, NULL, rdfunc, NULL) == 0);
+  Sleep(100);
+  assert(pthread_create(&wrt2, NULL, wrfunc, (void *)(size_t)2) == 0);
+
+  assert(pthread_join(wrt1, &wr1Result) == 0);
+  assert(pthread_join(rdt, &rdResult) == 0);
+  assert(pthread_join(wrt2, &wr2Result) == 0);
+
+  assert((int)(size_t)wr1Result == 10);
+  assert((int)(size_t)rdResult == 0);
+  assert((int)(size_t)wr2Result == 100);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/rwlock7.c b/src/include/pthread/tests/rwlock7.c
new file mode 100644
index 0000000..9d58f6e
--- /dev/null
+++ b/src/include/pthread/tests/rwlock7.c
@@ -0,0 +1,199 @@
+/*
+ * rwlock7.c
+ *
+ * Hammer on a bunch of rwlocks to test robustness and fairness.
+ * Printed stats should be roughly even for each thread.
+ */
+
+#include "test.h"
+#include <sys/timeb.h>
+
+#ifdef __GNUC__
+#include <stdlib.h>
+#endif
+
+#define THREADS         5
+#define DATASIZE        7
+#define ITERATIONS      1000000
+
+/*
+ * Keep statistics for each thread.
+ */
+typedef struct thread_tag {
+  int         thread_num;
+  pthread_t   thread_id;
+  int         updates;
+  int         reads;
+  int         changed;
+  int         seed;
+} thread_t;
+
+/*
+ * Read-write lock and shared data
+ */
+typedef struct data_tag {
+  pthread_rwlock_t    lock;
+  int                 data;
+  int                 updates;
+} data_t;
+
+static thread_t threads[THREADS];
+static data_t data[DATASIZE];
+
+/*
+ * Thread start routine that uses read-write locks
+ */
+void *thread_routine (void *arg)
+{
+  thread_t *self = (thread_t*)arg;
+  int iteration;
+  int element = 0;
+  int seed = self->seed;
+  int interval = 1 + rand_r (&seed) % 71;
+
+  self->changed = 0;
+
+  for (iteration = 0; iteration < ITERATIONS; iteration++)
+    {
+      if (iteration % (ITERATIONS / 10) == 0)
+        {
+          putchar('.');
+          fflush(stdout);
+        }
+      /*
+       * Each "self->interval" iterations, perform an
+       * update operation (write lock instead of read
+       * lock).
+       */
+      if ((iteration % interval) == 0)
+        {
+          assert(pthread_rwlock_wrlock (&data[element].lock) == 0);
+          data[element].data = self->thread_num;
+          data[element].updates++;
+          self->updates++;
+	  interval = 1 + rand_r (&seed) % 71;
+          assert(pthread_rwlock_unlock (&data[element].lock) == 0);
+        } else {
+          /*
+           * Look at the current data element to see whether
+           * the current thread last updated it. Count the
+           * times, to report later.
+           */
+          assert(pthread_rwlock_rdlock (&data[element].lock) == 0);
+
+          self->reads++;
+
+          if (data[element].data != self->thread_num)
+            {
+              self->changed++;
+	      interval = 1 + self->changed % 71;
+            }
+
+          assert(pthread_rwlock_unlock (&data[element].lock) == 0);
+        }
+
+      element = (element + 1) % DATASIZE;
+
+    }
+
+  return NULL;
+}
+
+int
+main (int argc, char *argv[])
+{
+  int count;
+  int data_count;
+  int thread_updates = 0;
+  int data_updates = 0;
+  int seed = 1;
+
+   __PTW32_STRUCT_TIMEB currSysTime1;
+   __PTW32_STRUCT_TIMEB currSysTime2;
+
+  /*
+   * Initialize the shared data.
+   */
+  for (data_count = 0; data_count < DATASIZE; data_count++)
+    {
+      data[data_count].data = 0;
+      data[data_count].updates = 0;
+
+      assert(pthread_rwlock_init (&data[data_count].lock, NULL) == 0);
+    }
+
+   __PTW32_FTIME(&currSysTime1);
+
+  /*
+   * Create THREADS threads to access shared data.
+   */
+  for (count = 0; count < THREADS; count++)
+    {
+      threads[count].thread_num = count;
+      threads[count].updates = 0;
+      threads[count].reads = 0;
+      threads[count].seed = 1 + rand_r (&seed) % 71;
+
+      assert(pthread_create (&threads[count].thread_id,
+                             NULL, thread_routine, (void*)(size_t)&threads[count]) == 0);
+    }
+
+  /*
+   * Wait for all threads to complete, and collect
+   * statistics.
+   */
+  for (count = 0; count < THREADS; count++)
+    {
+      assert(pthread_join (threads[count].thread_id, NULL) == 0);
+    }
+
+  putchar('\n');
+  fflush(stdout);
+
+  for (count = 0; count < THREADS; count++)
+    {
+      if (threads[count].changed > 0)
+        {
+          printf ("Thread %d found changed elements %d times\n",
+                  count, threads[count].changed);
+        }
+    }
+
+  putchar('\n');
+  fflush(stdout);
+
+  for (count = 0; count < THREADS; count++)
+    {
+      thread_updates += threads[count].updates;
+      printf ("%02d: seed %d, updates %d, reads %d\n",
+              count, threads[count].seed,
+              threads[count].updates, threads[count].reads);
+    }
+
+  putchar('\n');
+  fflush(stdout);
+
+  /*
+   * Collect statistics for the data.
+   */
+  for (data_count = 0; data_count < DATASIZE; data_count++)
+    {
+      data_updates += data[data_count].updates;
+      printf ("data %02d: value %d, %d updates\n",
+              data_count, data[data_count].data, data[data_count].updates);
+      assert(pthread_rwlock_destroy (&data[data_count].lock) == 0);
+    }
+
+  printf ("%d thread updates, %d data updates\n",
+          thread_updates, data_updates);
+
+   __PTW32_FTIME(&currSysTime2);
+
+  printf( "\nstart: %ld/%d, stop: %ld/%d, duration:%ld\n",
+          (long)currSysTime1.time,currSysTime1.millitm,
+          (long)currSysTime2.time,currSysTime2.millitm,
+          ((long)((currSysTime2.time*1000+currSysTime2.millitm) -
+          (currSysTime1.time*1000+currSysTime1.millitm))));
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/rwlock7_1.c b/src/include/pthread/tests/rwlock7_1.c
new file mode 100644
index 0000000..4e2ea49
--- /dev/null
+++ b/src/include/pthread/tests/rwlock7_1.c
@@ -0,0 +1,222 @@
+/*
+ * rwlock7_1.c
+ *
+ * Hammer on a bunch of rwlocks to test robustness and fairness.
+ * Printed stats should be roughly even for each thread.
+ *
+ * Use CPU affinity to compare against non-affinity rwlock7.c
+ */
+
+#include "test.h"
+#include <sys/timeb.h>
+
+#ifdef __GNUC__
+#include <stdlib.h>
+#endif
+
+#define THREADS         5
+#define DATASIZE        7
+#define ITERATIONS      1000000
+
+/*
+ * Keep statistics for each thread.
+ */
+typedef struct thread_tag {
+  int         thread_num;
+  pthread_t   thread_id;
+  cpu_set_t   threadCpus;
+  int         updates;
+  int         reads;
+  int         changed;
+  int         seed;
+} thread_t;
+
+/*
+ * Read-write lock and shared data
+ */
+typedef struct data_tag {
+  pthread_rwlock_t    lock;
+  int                 data;
+  int                 updates;
+} data_t;
+
+static thread_t threads[THREADS];
+static data_t data[DATASIZE];
+static cpu_set_t processCpus;
+static int cpu_count;
+
+/*
+ * Thread start routine that uses read-write locks
+ */
+void *thread_routine (void *arg)
+{
+  thread_t *self = (thread_t*)arg;
+  int iteration;
+  int element = 0;
+  int seed = self->seed;
+  int interval = 1 + rand_r (&seed) % 71;
+
+  /*
+   * Set each thread to a fixed (different if possible) cpu.
+   */
+  CPU_ZERO(&self->threadCpus);
+  CPU_SET(self->thread_num%cpu_count, &self->threadCpus);
+  assert(pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &self->threadCpus) == 0);
+
+  self->changed = 0;
+
+  for (iteration = 0; iteration < ITERATIONS; iteration++)
+    {
+      if (iteration % (ITERATIONS / 10) == 0)
+        {
+          putchar('.');
+          fflush(stdout);
+        }
+      /*
+       * Each "self->interval" iterations, perform an
+       * update operation (write lock instead of read
+       * lock).
+       */
+      if ((iteration % interval) == 0)
+        {
+          assert(pthread_rwlock_wrlock (&data[element].lock) == 0);
+          data[element].data = self->thread_num;
+          data[element].updates++;
+          self->updates++;
+	  interval = 1 + rand_r (&seed) % 71;
+          assert(pthread_rwlock_unlock (&data[element].lock) == 0);
+        } else {
+          /*
+           * Look at the current data element to see whether
+           * the current thread last updated it. Count the
+           * times, to report later.
+           */
+          assert(pthread_rwlock_rdlock (&data[element].lock) == 0);
+
+          self->reads++;
+
+          if (data[element].data != self->thread_num)
+            {
+              self->changed++;
+	      interval = 1 + self->changed % 71;
+            }
+
+          assert(pthread_rwlock_unlock (&data[element].lock) == 0);
+        }
+
+      element = (element + 1) % DATASIZE;
+
+    }
+
+  return NULL;
+}
+
+int
+main (int argc, char *argv[])
+{
+  int count;
+  int data_count;
+  int thread_updates = 0;
+  int data_updates = 0;
+  int seed = 1;
+  pthread_t self = pthread_self();
+  __PTW32_STRUCT_TIMEB currSysTime1;
+  __PTW32_STRUCT_TIMEB currSysTime2;
+
+  if (pthread_getaffinity_np(self, sizeof(cpu_set_t), &processCpus) == ENOSYS)
+    {
+      printf("pthread_get/set_affinity_np API not supported for this platform: skipping test.");
+      return 0;
+    }
+
+  assert(pthread_getaffinity_np(self, sizeof(cpu_set_t), &processCpus) == 0);
+  assert((cpu_count = CPU_COUNT(&processCpus)) > 0);
+  printf("CPUs: %d\n", cpu_count);
+
+  /*
+   * Initialize the shared data.
+   */
+  for (data_count = 0; data_count < DATASIZE; data_count++)
+    {
+      data[data_count].data = 0;
+      data[data_count].updates = 0;
+
+      assert(pthread_rwlock_init (&data[data_count].lock, NULL) == 0);
+    }
+
+   __PTW32_FTIME(&currSysTime1);
+
+  /*
+   * Create THREADS threads to access shared data.
+   */
+  for (count = 0; count < THREADS; count++)
+    {
+      threads[count].thread_num = count;
+      threads[count].updates = 0;
+      threads[count].reads = 0;
+      threads[count].seed = 1 + rand_r (&seed) % 71;
+
+      assert(pthread_create (&threads[count].thread_id,
+                             NULL, thread_routine, (void*)(size_t)&threads[count]) == 0);
+    }
+
+  /*
+   * Wait for all threads to complete, and collect
+   * statistics.
+   */
+  for (count = 0; count < THREADS; count++)
+    {
+      assert(pthread_join (threads[count].thread_id, NULL) == 0);
+    }
+
+  putchar('\n');
+  fflush(stdout);
+
+  for (count = 0; count < THREADS; count++)
+    {
+      if (threads[count].changed > 0)
+        {
+          printf ("Thread %d found changed elements %d times\n",
+                  count, threads[count].changed);
+        }
+    }
+
+  putchar('\n');
+  fflush(stdout);
+
+  for (count = 0; count < THREADS; count++)
+    {
+      thread_updates += threads[count].updates;
+      printf ("%02d: seed %d, updates %d, reads %d, cpu %d\n",
+              count, threads[count].seed,
+              threads[count].updates, threads[count].reads,
+	      threads[count].thread_num%cpu_count);
+    }
+
+  putchar('\n');
+  fflush(stdout);
+
+  /*
+   * Collect statistics for the data.
+   */
+  for (data_count = 0; data_count < DATASIZE; data_count++)
+    {
+      data_updates += data[data_count].updates;
+      printf ("data %02d: value %d, %d updates\n",
+              data_count, data[data_count].data, data[data_count].updates);
+      assert(pthread_rwlock_destroy (&data[data_count].lock) == 0);
+    }
+
+  printf ("%d thread updates, %d data updates\n",
+          thread_updates, data_updates);
+
+   __PTW32_FTIME(&currSysTime2);
+
+  printf( "\nstart: %ld/%d, stop: %ld/%d, duration:%ld\n",
+          (long)currSysTime1.time,currSysTime1.millitm,
+          (long)currSysTime2.time,currSysTime2.millitm,
+          ((long)((currSysTime2.time*1000+currSysTime2.millitm) -
+          (currSysTime1.time*1000+currSysTime1.millitm))));
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/rwlock8.c b/src/include/pthread/tests/rwlock8.c
new file mode 100644
index 0000000..301e1ec
--- /dev/null
+++ b/src/include/pthread/tests/rwlock8.c
@@ -0,0 +1,205 @@
+/*
+ * rwlock8.c
+ *
+ * Hammer on a bunch of rwlocks to test robustness and fairness.
+ * Printed stats should be roughly even for each thread.
+ *
+ * Yield during each access to exercise lock contention code paths
+ * more than rwlock7.c does (particularly on uni-processor systems).
+ */
+
+#include "test.h"
+#include <sys/timeb.h>
+
+#ifdef __GNUC__
+#include <stdlib.h>
+#endif
+
+#define THREADS         5
+#define DATASIZE        7
+#define ITERATIONS      100000
+
+/*
+ * Keep statistics for each thread.
+ */
+typedef struct thread_tag {
+  int         thread_num;
+  pthread_t   thread_id;
+  int         updates;
+  int         reads;
+  int         changed;
+  int         seed;
+} thread_t;
+
+/*
+ * Read-write lock and shared data
+ */
+typedef struct data_tag {
+  pthread_rwlock_t    lock;
+  int                 data;
+  int                 updates;
+} data_t;
+
+static thread_t threads[THREADS];
+static data_t data[DATASIZE];
+
+/*
+ * Thread start routine that uses read-write locks
+ */
+void *thread_routine (void *arg)
+{
+  thread_t *self = (thread_t*)arg;
+  int iteration;
+  int element = 0;
+  int seed = self->seed;
+  int interval = 1 + rand_r (&seed) % 71;
+
+  self->changed = 0;
+
+  for (iteration = 0; iteration < ITERATIONS; iteration++)
+    {
+      if (iteration % (ITERATIONS / 10) == 0)
+        {
+          putchar('.');
+          fflush(stdout);
+        }
+      /*
+       * Each "self->interval" iterations, perform an
+       * update operation (write lock instead of read
+       * lock).
+       */
+      if ((iteration % interval) == 0)
+        {
+          assert(pthread_rwlock_wrlock (&data[element].lock) == 0);
+          data[element].data = self->thread_num;
+          data[element].updates++;
+          self->updates++;
+	  interval = 1 + rand_r (&seed) % 71;
+	  sched_yield();
+          assert(pthread_rwlock_unlock (&data[element].lock) == 0);
+        } else {
+          /*
+           * Look at the current data element to see whether
+           * the current thread last updated it. Count the
+           * times, to report later.
+           */
+          assert(pthread_rwlock_rdlock (&data[element].lock) == 0);
+
+          self->reads++;
+
+          if (data[element].data != self->thread_num)
+            {
+              self->changed++;
+	      interval = 1 + self->changed % 71;
+            }
+
+	  sched_yield();
+
+          assert(pthread_rwlock_unlock (&data[element].lock) == 0);
+        }
+
+      element = (element + 1) % DATASIZE;
+
+    }
+
+  return NULL;
+}
+
+int
+main (int argc, char *argv[])
+{
+  int count;
+  int data_count;
+  int thread_updates = 0;
+  int data_updates = 0;
+  int seed = 1;
+
+   __PTW32_STRUCT_TIMEB currSysTime1;
+   __PTW32_STRUCT_TIMEB currSysTime2;
+
+  /*
+   * Initialize the shared data.
+   */
+  for (data_count = 0; data_count < DATASIZE; data_count++)
+    {
+      data[data_count].data = 0;
+      data[data_count].updates = 0;
+
+      assert(pthread_rwlock_init (&data[data_count].lock, NULL) == 0);
+    }
+
+   __PTW32_FTIME(&currSysTime1);
+
+  /*
+   * Create THREADS threads to access shared data.
+   */
+  for (count = 0; count < THREADS; count++)
+    {
+      threads[count].thread_num = count;
+      threads[count].updates = 0;
+      threads[count].reads = 0;
+      threads[count].seed = 1 + rand_r (&seed) % 71;
+
+      assert(pthread_create (&threads[count].thread_id,
+                             NULL, thread_routine, (void*)(size_t)&threads[count]) == 0);
+    }
+
+  /*
+   * Wait for all threads to complete, and collect
+   * statistics.
+   */
+  for (count = 0; count < THREADS; count++)
+    {
+      assert(pthread_join (threads[count].thread_id, NULL) == 0);
+    }
+
+  putchar('\n');
+  fflush(stdout);
+
+  for (count = 0; count < THREADS; count++)
+    {
+      if (threads[count].changed > 0)
+        {
+          printf ("Thread %d found changed elements %d times\n",
+                  count, threads[count].changed);
+        }
+    }
+
+  putchar('\n');
+  fflush(stdout);
+
+  for (count = 0; count < THREADS; count++)
+    {
+      thread_updates += threads[count].updates;
+      printf ("%02d: seed %d, updates %d, reads %d\n",
+              count, threads[count].seed,
+              threads[count].updates, threads[count].reads);
+    }
+
+  putchar('\n');
+  fflush(stdout);
+
+  /*
+   * Collect statistics for the data.
+   */
+  for (data_count = 0; data_count < DATASIZE; data_count++)
+    {
+      data_updates += data[data_count].updates;
+      printf ("data %02d: value %d, %d updates\n",
+              data_count, data[data_count].data, data[data_count].updates);
+      assert(pthread_rwlock_destroy (&data[data_count].lock) == 0);
+    }
+
+  printf ("%d thread updates, %d data updates\n",
+          thread_updates, data_updates);
+
+   __PTW32_FTIME(&currSysTime2);
+
+  printf( "\nstart: %ld/%d, stop: %ld/%d, duration:%ld\n",
+          (long)currSysTime1.time,currSysTime1.millitm,
+          (long)currSysTime2.time,currSysTime2.millitm,
+          ((long)((currSysTime2.time*1000+currSysTime2.millitm) -
+          (currSysTime1.time*1000+currSysTime1.millitm))));
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/rwlock8_1.c b/src/include/pthread/tests/rwlock8_1.c
new file mode 100644
index 0000000..a85f37f
--- /dev/null
+++ b/src/include/pthread/tests/rwlock8_1.c
@@ -0,0 +1,228 @@
+/*
+ * rwlock8.c
+ *
+ * Hammer on a bunch of rwlocks to test robustness and fairness.
+ * Printed stats should be roughly even for each thread.
+ *
+ * Yield during each access to exercise lock contention code paths
+ * more than rwlock7.c does (particularly on uni-processor systems).
+ *
+ * Use CPU affinity to compare against non-affinity rwlock8.c
+ */
+
+#include "test.h"
+#include <sys/timeb.h>
+
+#ifdef __GNUC__
+#include <stdlib.h>
+#endif
+
+#define THREADS         5
+#define DATASIZE        7
+#define ITERATIONS      100000
+
+/*
+ * Keep statistics for each thread.
+ */
+typedef struct thread_tag {
+  int         thread_num;
+  pthread_t   thread_id;
+  cpu_set_t   threadCpus;
+  int         updates;
+  int         reads;
+  int         changed;
+  int         seed;
+} thread_t;
+
+/*
+ * Read-write lock and shared data
+ */
+typedef struct data_tag {
+  pthread_rwlock_t    lock;
+  int                 data;
+  int                 updates;
+} data_t;
+
+static thread_t threads[THREADS];
+static data_t data[DATASIZE];
+static cpu_set_t processCpus;
+static int cpu_count;
+
+/*
+ * Thread start routine that uses read-write locks
+ */
+void *thread_routine (void *arg)
+{
+  thread_t *self = (thread_t*)arg;
+  int iteration;
+  int element = 0;
+  int seed = self->seed;
+  int interval = 1 + rand_r (&seed) % 71;
+
+  /*
+   * Set each thread to a fixed (different if possible) cpu.
+   */
+  CPU_ZERO(&self->threadCpus);
+  CPU_SET(self->thread_num%cpu_count, &self->threadCpus);
+  assert(pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &self->threadCpus) == 0);
+
+  self->changed = 0;
+
+  for (iteration = 0; iteration < ITERATIONS; iteration++)
+    {
+      if (iteration % (ITERATIONS / 10) == 0)
+        {
+          putchar('.');
+          fflush(stdout);
+        }
+      /*
+       * Each "self->interval" iterations, perform an
+       * update operation (write lock instead of read
+       * lock).
+       */
+      if ((iteration % interval) == 0)
+        {
+          assert(pthread_rwlock_wrlock (&data[element].lock) == 0);
+          data[element].data = self->thread_num;
+          data[element].updates++;
+          self->updates++;
+	  interval = 1 + rand_r (&seed) % 71;
+	  sched_yield();
+          assert(pthread_rwlock_unlock (&data[element].lock) == 0);
+        } else {
+          /*
+           * Look at the current data element to see whether
+           * the current thread last updated it. Count the
+           * times, to report later.
+           */
+          assert(pthread_rwlock_rdlock (&data[element].lock) == 0);
+
+          self->reads++;
+
+          if (data[element].data != self->thread_num)
+            {
+              self->changed++;
+	      interval = 1 + self->changed % 71;
+            }
+
+	  sched_yield();
+
+          assert(pthread_rwlock_unlock (&data[element].lock) == 0);
+        }
+
+      element = (element + 1) % DATASIZE;
+
+    }
+
+  return NULL;
+}
+
+int
+main (int argc, char *argv[])
+{
+  int count;
+  int data_count;
+  int thread_updates = 0;
+  int data_updates = 0;
+  int seed = 1;
+  pthread_t self = pthread_self();
+  __PTW32_STRUCT_TIMEB currSysTime1;
+  __PTW32_STRUCT_TIMEB currSysTime2;
+
+  if (pthread_getaffinity_np(self, sizeof(cpu_set_t), &processCpus) == ENOSYS)
+    {
+      printf("pthread_get/set_affinity_np API not supported for this platform: skipping test.");
+      return 0;
+    }
+
+  assert(pthread_getaffinity_np(self, sizeof(cpu_set_t), &processCpus) == 0);
+  assert((cpu_count = CPU_COUNT(&processCpus)) > 0);
+  printf("CPUs: %d\n", cpu_count);
+
+  /*
+   * Initialize the shared data.
+   */
+  for (data_count = 0; data_count < DATASIZE; data_count++)
+    {
+      data[data_count].data = 0;
+      data[data_count].updates = 0;
+
+      assert(pthread_rwlock_init (&data[data_count].lock, NULL) == 0);
+    }
+
+   __PTW32_FTIME(&currSysTime1);
+
+  /*
+   * Create THREADS threads to access shared data.
+   */
+  for (count = 0; count < THREADS; count++)
+    {
+      threads[count].thread_num = count;
+      threads[count].updates = 0;
+      threads[count].reads = 0;
+      threads[count].seed = 1 + rand_r (&seed) % 71;
+
+      assert(pthread_create (&threads[count].thread_id,
+                             NULL, thread_routine, (void*)(size_t)&threads[count]) == 0);
+    }
+
+  /*
+   * Wait for all threads to complete, and collect
+   * statistics.
+   */
+  for (count = 0; count < THREADS; count++)
+    {
+      assert(pthread_join (threads[count].thread_id, NULL) == 0);
+    }
+
+  putchar('\n');
+  fflush(stdout);
+
+  for (count = 0; count < THREADS; count++)
+    {
+      if (threads[count].changed > 0)
+        {
+          printf ("Thread %d found changed elements %d times\n",
+                  count, threads[count].changed);
+        }
+    }
+
+  putchar('\n');
+  fflush(stdout);
+
+  for (count = 0; count < THREADS; count++)
+    {
+      thread_updates += threads[count].updates;
+      printf ("%02d: seed %d, updates %d, reads %d, cpu %d\n",
+              count, threads[count].seed,
+              threads[count].updates, threads[count].reads,
+	      threads[count].thread_num%cpu_count);
+    }
+
+  putchar('\n');
+  fflush(stdout);
+
+  /*
+   * Collect statistics for the data.
+   */
+  for (data_count = 0; data_count < DATASIZE; data_count++)
+    {
+      data_updates += data[data_count].updates;
+      printf ("data %02d: value %d, %d updates\n",
+              data_count, data[data_count].data, data[data_count].updates);
+      assert(pthread_rwlock_destroy (&data[data_count].lock) == 0);
+    }
+
+  printf ("%d thread updates, %d data updates\n",
+          thread_updates, data_updates);
+
+   __PTW32_FTIME(&currSysTime2);
+
+  printf( "\nstart: %ld/%d, stop: %ld/%d, duration:%ld\n",
+          (long)currSysTime1.time,currSysTime1.millitm,
+          (long)currSysTime2.time,currSysTime2.millitm,
+          ((long)((currSysTime2.time*1000+currSysTime2.millitm) -
+          (currSysTime1.time*1000+currSysTime1.millitm))));
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/self1.c b/src/include/pthread/tests/self1.c
new file mode 100644
index 0000000..ef3a777
--- /dev/null
+++ b/src/include/pthread/tests/self1.c
@@ -0,0 +1,67 @@
+/*
+ * self1.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test for pthread_self().
+ *
+ * Depends on API functions:
+ *	pthread_self()
+ *
+ * Implicitly depends on:
+ *	pthread_getspecific()
+ *	pthread_setspecific()
+ */
+
+#include "test.h"
+
+int
+main(int argc, char * argv[])
+{
+	/*
+	 * This should always succeed unless the system has no
+	 * resources (memory) left.
+	 */
+	pthread_t self;
+
+#if defined (__PTW32_STATIC_LIB) && !(defined(_MSC_VER) || defined(__MINGW32__))
+	pthread_win32_process_attach_np();
+#endif
+
+	self = pthread_self();
+
+	assert(self.p != NULL);
+
+#if defined (__PTW32_STATIC_LIB) && !(defined(_MSC_VER) || defined(__MINGW32__))
+	pthread_win32_process_detach_np();
+#endif
+	return 0;
+}
diff --git a/src/include/pthread/tests/self2.c b/src/include/pthread/tests/self2.c
new file mode 100644
index 0000000..ee067ba
--- /dev/null
+++ b/src/include/pthread/tests/self2.c
@@ -0,0 +1,71 @@
+/*
+ * self2.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test for pthread_self().
+ *
+ * Depends on API functions:
+ *	pthread_create()
+ *	pthread_self()
+ *
+ * Implicitly depends on:
+ *	pthread_getspecific()
+ *	pthread_setspecific()
+ */
+
+#include "test.h"
+#include <string.h>
+
+static pthread_t me;
+
+void *
+entry(void * arg)
+{
+  me = pthread_self();
+
+  return arg;
+}
+
+int
+main()
+{
+  pthread_t t;
+
+  assert(pthread_create(&t, NULL, entry, NULL) == 0);
+
+  Sleep(100);
+
+  assert(pthread_equal(t, me) != 0);
+
+  /* Success. */
+  return 0;
+}
diff --git a/src/include/pthread/tests/semaphore1.c b/src/include/pthread/tests/semaphore1.c
new file mode 100644
index 0000000..ca5051b
--- /dev/null
+++ b/src/include/pthread/tests/semaphore1.c
@@ -0,0 +1,158 @@
+/*
+ * File: semaphore1.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis: Verify trywait() returns -1 and sets EAGAIN.
+ * - 
+ *
+ * Test Method (Validation or Falsification):
+ * - Validation
+ *
+ * Requirements Tested:
+ * - 
+ *
+ * Features Tested:
+ * - 
+ *
+ * Cases Tested:
+ * - 
+ *
+ * Description:
+ * - 
+ *
+ * Environment:
+ * - 
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * - 
+ *
+ * Pass Criteria:
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - Process returns non-zero exit status.
+ */
+
+#include "test.h"
+
+void *
+thr(void * arg)
+{
+  sem_t s;
+  int result;
+
+  assert(sem_init(&s, PTHREAD_PROCESS_PRIVATE, 0) == 0);
+
+  assert((result = sem_trywait(&s)) == -1);
+
+  if ( result == -1 )
+  {
+	  int err =
+#if defined (__PTW32_USES_SEPARATE_CRT)
+	  GetLastError();
+#else
+      errno;
+#endif
+    if (err != EAGAIN)
+    {
+      printf("thread: sem_trywait 1: expecting error %s: got %s\n",
+	     error_string[EAGAIN], error_string[err]); fflush(stdout);
+    }
+    assert(err == EAGAIN);
+  }
+  else
+  {
+    printf("thread: ok 1\n");
+  }
+
+  assert((result = sem_post(&s)) == 0);
+
+  assert((result = sem_trywait(&s)) == 0);
+
+  assert(sem_post(&s) == 0);
+
+  return NULL;
+}
+
+
+int
+main()
+{
+  pthread_t t;
+  sem_t s;
+  void* result1 = (void*)-1;
+  int result2;
+
+  assert(pthread_create(&t, NULL, thr, NULL) == 0);
+  assert(pthread_join(t, &result1) == 0);
+  assert((int)(size_t)result1 == 0);
+
+  assert(sem_init(&s, PTHREAD_PROCESS_PRIVATE, 0) == 0);
+
+  assert((result2 = sem_trywait(&s)) == -1);
+
+  if (result2 == -1)
+  {
+    int err =
+#if defined (__PTW32_USES_SEPARATE_CRT)
+      GetLastError();
+#else
+      errno;
+#endif
+    if (err != EAGAIN)
+    {
+      printf("main: sem_trywait 1: expecting error %s: got %s\n",
+	     error_string[EAGAIN], error_string[err]); fflush(stdout);
+    }
+    assert(err == EAGAIN);
+  }
+  else
+  {
+    printf("main: ok 1\n");
+  }
+
+  assert((result2 = sem_post(&s)) == 0);
+
+  assert((result2 = sem_trywait(&s)) == 0);
+
+  assert(sem_post(&s) == 0);
+
+  return 0;
+}
+
diff --git a/src/include/pthread/tests/semaphore2.c b/src/include/pthread/tests/semaphore2.c
new file mode 100644
index 0000000..2ad3207
--- /dev/null
+++ b/src/include/pthread/tests/semaphore2.c
@@ -0,0 +1,106 @@
+/*
+ * File: semaphore2.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis: Verify sem_getvalue returns the correct value.
+ * - 
+ *
+ * Test Method (Validation or Falsification):
+ * - Validation
+ *
+ * Requirements Tested:
+ * - 
+ *
+ * Features Tested:
+ * - 
+ *
+ * Cases Tested:
+ * -
+ *
+ * Description:
+ * -
+ *
+ * Environment:
+ * -
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * -
+ *
+ * Pass Criteria:
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - Process returns non-zero exit status.
+ */
+
+#include "test.h"
+
+#define MAX_COUNT 100
+
+int
+main()
+{
+  sem_t s;
+	int value = 0;
+	int i;
+
+  assert(sem_init(&s, PTHREAD_PROCESS_PRIVATE, MAX_COUNT) == 0);
+	assert(sem_getvalue(&s, &value) == 0);
+	assert(value == MAX_COUNT);
+//	  printf("Value = %ld\n", value);
+
+	for (i = MAX_COUNT - 1; i >= 0; i--)
+		{
+			assert(sem_wait(&s) == 0);
+			assert(sem_getvalue(&s, &value) == 0);
+//			  printf("Value = %ld\n", value);
+			assert(value == i);
+		}
+
+	for (i = 1; i <= MAX_COUNT; i++)
+		{
+			assert(sem_post(&s) == 0);
+			assert(sem_getvalue(&s, &value) == 0);
+//			  printf("Value = %ld\n", value);
+			assert(value == i);
+		}
+
+  return 0;
+}
+
diff --git a/src/include/pthread/tests/semaphore3.c b/src/include/pthread/tests/semaphore3.c
new file mode 100644
index 0000000..881131f
--- /dev/null
+++ b/src/include/pthread/tests/semaphore3.c
@@ -0,0 +1,123 @@
+/*
+ * File: semaphore3.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis: Verify sem_getvalue returns the correct number of waiters.
+ * -
+ *
+ * Test Method (Validation or Falsification):
+ * - Validation
+ *
+ * Requirements Tested:
+ * -
+ *
+ * Features Tested:
+ * -
+ *
+ * Cases Tested:
+ * -
+ *
+ * Description:
+ * -
+ *
+ * Environment:
+ * -
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * -
+ *
+ * Pass Criteria:
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - Process returns non-zero exit status.
+ */
+
+#include "test.h"
+
+#define MAX_COUNT 100
+
+sem_t s;
+
+void *
+thr (void * arg)
+{
+  assert(sem_wait(&s) == 0);
+  return NULL;
+}
+
+int
+main()
+{
+  int value = 0;
+  int i;
+  pthread_t t[MAX_COUNT+1];
+
+  assert(sem_init(&s, PTHREAD_PROCESS_PRIVATE, 0) == 0);
+  assert(sem_getvalue(&s, &value) == 0);
+  //printf("Value = %d\n", value);	fflush(stdout);
+  assert(value == 0);
+
+  for (i = 1; i <= MAX_COUNT; i++)
+    {
+      assert(pthread_create(&t[i], NULL, thr, NULL) == 0);
+      do
+        {
+          sched_yield();
+          assert(sem_getvalue(&s, &value) == 0);
+        }
+      while (-value != i);
+      //printf("1:Value = %d\n", value); fflush(stdout);
+      assert(-value == i);
+    }
+
+  for (i = MAX_COUNT - 1; i >= 0; i--)
+    {
+      assert(sem_post(&s) == 0);
+      assert(sem_getvalue(&s, &value) == 0);
+      //printf("2:Value = %d\n", value);	fflush(stdout);
+      assert(-value == i);
+    }
+
+  for (i = MAX_COUNT; i > 0; i--)
+    {
+      pthread_join(t[i], NULL);
+    }
+  return 0;
+}
diff --git a/src/include/pthread/tests/semaphore4.c b/src/include/pthread/tests/semaphore4.c
new file mode 100644
index 0000000..06bd1d4
--- /dev/null
+++ b/src/include/pthread/tests/semaphore4.c
@@ -0,0 +1,130 @@
+/*
+ * File: semaphore4.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis: Verify sem_getvalue returns the correct number of waiters
+ * after threads are cancelled.
+ * - 
+ *
+ * Test Method (Validation or Falsification):
+ * - Validation
+ *
+ * Requirements Tested:
+ * - 
+ *
+ * Features Tested:
+ * - 
+ *
+ * Cases Tested:
+ * -
+ *
+ * Description:
+ * -
+ *
+ * Environment:
+ * -
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * -
+ *
+ * Pass Criteria:
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - Process returns non-zero exit status.
+ */
+
+#include "test.h"
+
+#define MAX_COUNT 100
+
+sem_t s;
+
+void *
+thr (void * arg)
+{
+  assert(sem_wait(&s) == 0);
+  return NULL;
+}
+
+int
+main()
+{
+	int value = 0;
+	int i;
+	pthread_t t[MAX_COUNT+1];
+
+	assert(sem_init(&s, PTHREAD_PROCESS_PRIVATE, 0) == 0);
+	assert(sem_getvalue(&s, &value) == 0);
+	assert(value == 0);
+
+	for (i = 1; i <= MAX_COUNT; i++)
+		{
+			assert(pthread_create(&t[i], NULL, thr, NULL) == 0);
+			do {
+			  sched_yield();
+			  assert(sem_getvalue(&s, &value) == 0);
+			} while (value != -i);
+			assert(-value == i);
+		}
+
+	assert(sem_getvalue(&s, &value) == 0);
+	assert(-value == MAX_COUNT);
+	assert(pthread_cancel(t[50]) == 0);
+	  {
+	    void* result;
+	    assert(pthread_join(t[50], &result) == 0);
+	  }
+	assert(sem_getvalue(&s, &value) == 0);
+	assert(-value == (MAX_COUNT - 1));
+
+	for (i = MAX_COUNT - 2; i >= 0; i--)
+		{
+			assert(sem_post(&s) == 0);
+			assert(sem_getvalue(&s, &value) == 0);
+			assert(-value == i);
+		}
+
+	for (i = 1; i <= MAX_COUNT; i++)
+	  if (i != 50)
+	    assert(pthread_join(t[i], NULL) == 0);
+
+  return 0;
+}
+
diff --git a/src/include/pthread/tests/semaphore4t.c b/src/include/pthread/tests/semaphore4t.c
new file mode 100644
index 0000000..9ab75a8
--- /dev/null
+++ b/src/include/pthread/tests/semaphore4t.c
@@ -0,0 +1,192 @@
+/*
+ * File: semaphore4t.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis: Verify sem_getvalue returns the correct number of waiters
+ * after threads are cancelled.
+ * -
+ *
+ * Test Method (Validation or Falsification):
+ * - Validation
+ *
+ * Requirements Tested:
+ * - sem_timedwait cancellation.
+ *
+ * Features Tested:
+ * -
+ *
+ * Cases Tested:
+ * -
+ *
+ * Description:
+ * -
+ *
+ * Environment:
+ * -
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * -
+ *
+ * Pass Criteria:
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - Process returns non-zero exit status.
+ */
+
+#include "test.h"
+
+#define MAX_COUNT 100
+
+const long NANOSEC_PER_SEC = 1000000000L;
+
+sem_t s;
+
+void *
+thr (void * arg)
+{
+  assert(sem_timedwait(&s, NULL) == 0);
+  return NULL;
+}
+
+int
+timeoutwithnanos(sem_t sem, int nanoseconds)
+{
+  struct timespec ts, rel;
+  FILETIME ft_before, ft_after;
+  int rc;
+
+  rel.tv_sec = 0;
+  rel.tv_nsec = nanoseconds;
+
+  GetSystemTimeAsFileTime(&ft_before);
+  rc = sem_timedwait(&sem, pthread_win32_getabstime_np(&ts, &rel));
+
+  /* This should have timed out */
+  assert(rc != 0);
+  assert(errno == ETIMEDOUT);
+  GetSystemTimeAsFileTime(&ft_after);
+  // We specified a non-zero wait. Time must advance.
+  if (ft_before.dwLowDateTime == ft_after.dwLowDateTime && ft_before.dwHighDateTime == ft_after.dwHighDateTime)
+    {
+      printf("nanoseconds: %d, rc: %d, errno: %d. before filetime: %d, %d; after filetime: %d, %d\n",
+          nanoseconds, rc, errno,
+          (int)ft_before.dwLowDateTime, (int)ft_before.dwHighDateTime,
+          (int)ft_after.dwLowDateTime, (int)ft_after.dwHighDateTime);
+      printf("time must advance during sem_timedwait.");
+      return 1;
+    }
+  return 0;
+}
+
+int
+testtimeout()
+{
+  int rc = 0;
+  sem_t s2;
+  int value = 0;
+  assert(sem_init(&s2, PTHREAD_PROCESS_PRIVATE, 0) == 0);
+  assert(sem_getvalue(&s2, &value) == 0);
+  assert(value == 0);
+
+  rc += timeoutwithnanos(s2, 1000);        // 1 microsecond
+  rc += timeoutwithnanos(s2, 10 * 1000);   // 10 microseconds
+  rc += timeoutwithnanos(s2, 100 * 1000);  // 100 microseconds
+  rc += timeoutwithnanos(s2, 1000 * 1000); // 1 millisecond
+
+  return rc;
+}
+
+int
+testmainstuff()
+{
+  int value = 0;
+  int i;
+  pthread_t t[MAX_COUNT+1];
+
+  assert(sem_init(&s, PTHREAD_PROCESS_PRIVATE, 0) == 0);
+  assert(sem_getvalue(&s, &value) == 0);
+  assert(value == 0);
+
+  for (i = 1; i <= MAX_COUNT; i++)
+    {
+      assert(pthread_create(&t[i], NULL, thr, NULL) == 0);
+      do {
+          sched_yield();
+          assert(sem_getvalue(&s, &value) == 0);
+      } while (value != -i);
+      assert(-value == i);
+    }
+
+  assert(sem_getvalue(&s, &value) == 0);
+  assert(-value == MAX_COUNT);
+  assert(pthread_cancel(t[50]) == 0);
+  assert(pthread_join(t[50], NULL) == 0);
+  assert(sem_getvalue(&s, &value) == 0);
+  assert(-value == MAX_COUNT - 1);
+
+  for (i = MAX_COUNT - 2; i >= 0; i--)
+    {
+      assert(sem_post(&s) == 0);
+      assert(sem_getvalue(&s, &value) == 0);
+      assert(-value == i);
+    }
+
+  for (i = 1; i <= MAX_COUNT; i++)
+    {
+      if (i != 50)
+        {
+          assert(pthread_join(t[i], NULL) == 0);
+        }
+    }
+
+  return 0;
+}
+
+int
+main()
+{
+  int rc = 0;
+
+  rc += testmainstuff();
+  rc += testtimeout();
+
+  return rc;
+}
+
diff --git a/src/include/pthread/tests/semaphore5.c b/src/include/pthread/tests/semaphore5.c
new file mode 100644
index 0000000..15ee340
--- /dev/null
+++ b/src/include/pthread/tests/semaphore5.c
@@ -0,0 +1,105 @@
+/*
+ * File: semaphore5.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis: Verify sem_destroy EBUSY race avoidance
+ * - 
+ *
+ * Test Method (Validation or Falsification):
+ * - Validation
+ *
+ * Requirements Tested:
+ * - 
+ *
+ * Features Tested:
+ * - 
+ *
+ * Cases Tested:
+ * - 
+ *
+ * Description:
+ * - 
+ *
+ * Environment:
+ * - 
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * - 
+ *
+ * Pass Criteria:
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - Process returns non-zero exit status.
+ */
+
+// #define ASSERT_TRACE
+
+#include "test.h"
+
+void *
+thr(void * arg)
+{
+  assert(sem_post((sem_t *)arg) == 0);
+
+  return 0;
+}
+
+
+int
+main()
+{
+  pthread_t t;
+  sem_t s;
+
+  assert(sem_init(&s, PTHREAD_PROCESS_PRIVATE, 0) == 0);
+  assert(pthread_create(&t, NULL, thr, (void *)&s) == 0);
+
+  assert(sem_wait(&s) == 0);
+  /*
+   * Normally we would retry this next, but we're only
+   * interested in unexpected results in this test.
+   */
+  assert(sem_destroy(&s) == 0 || errno == EBUSY);
+
+  assert(pthread_join(t, NULL) == 0);
+
+  return 0;
+}
+
diff --git a/src/include/pthread/tests/sequence1.c b/src/include/pthread/tests/sequence1.c
new file mode 100644
index 0000000..48e1006
--- /dev/null
+++ b/src/include/pthread/tests/sequence1.c
@@ -0,0 +1,139 @@
+/*
+ * File: sequence1.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis:
+ * - that unique thread sequence numbers are generated.
+ *
+ * Test Method (Validation or Falsification):
+ * -
+ *
+ * Requirements Tested:
+ * -
+ *
+ * Features Tested:
+ * -
+ *
+ * Cases Tested:
+ * -
+ *
+ * Description:
+ * -
+ *
+ * Environment:
+ * - This test is implementation specific
+ * because it uses knowledge of internals that should be
+ * opaque to an application.
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - analysis output on success.
+ *
+ * Assumptions:
+ * -
+ *
+ * Pass Criteria:
+ * - unique sequence numbers are generated for every new thread.
+ *
+ * Fail Criteria:
+ * - 
+ */
+
+#include "test.h"
+
+/*
+ */
+
+enum {
+	NUMTHREADS = PTHREAD_THREADS_MAX
+};
+
+
+static long done = 0;
+/*
+ * seqmap should have 1 in every element except [0]
+ * Thread sequence numbers start at 1 and we will also
+ * include this main thread so we need NUMTHREADS+2
+ * elements. 
+ */
+static UINT64 seqmap[NUMTHREADS+2];
+
+void * func(void * arg)
+{
+  sched_yield();
+  seqmap[(int)pthread_getunique_np(pthread_self())] = 1;
+  InterlockedIncrement(&done);
+
+  return (void *) 0; 
+}
+ 
+int
+main()
+{
+  pthread_t t[NUMTHREADS];
+  pthread_attr_t attr;
+  int i;
+
+  assert(pthread_attr_init(&attr) == 0);
+  assert(pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED) == 0);
+
+  for (i = 0; i < NUMTHREADS+2; i++)
+    {
+      seqmap[i] = 0;
+    }
+
+  for (i = 0; i < NUMTHREADS; i++)
+    {
+      if (NUMTHREADS/2 == i)
+        {
+          /* Include this main thread, which will be an implicit pthread_t */
+          seqmap[(int)pthread_getunique_np(pthread_self())] = 1;
+        }
+      assert(pthread_create(&t[i], &attr, func, NULL) == 0);
+    }
+
+  while (NUMTHREADS > InterlockedExchangeAdd((LPLONG)&done, 0L))
+    Sleep(100);
+
+  Sleep(100);
+
+  assert(seqmap[0] == 0);
+  for (i = 1; i < NUMTHREADS+2; i++)
+    {
+      assert(seqmap[i] == 1);
+    }
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/sizes.c b/src/include/pthread/tests/sizes.c
new file mode 100644
index 0000000..31a146d
--- /dev/null
+++ b/src/include/pthread/tests/sizes.c
@@ -0,0 +1,34 @@
+#define _WIN32_WINNT 0x400
+
+#include "test.h"
+/* Cheating here - sneaking a peek at library internals */
+#include "../config.h"
+#include "../implement.h"
+
+int
+main()
+{
+  printf("Sizes of pthreads-win32 structs\n");
+  printf("-------------------------------\n");
+  printf("%30s %4d\n", "pthread_t", (int)sizeof(pthread_t));
+  printf("%30s %4d\n", "__ptw32_thread_t", (int)sizeof(__ptw32_thread_t));
+  printf("%30s %4d\n", "pthread_attr_t_", (int)sizeof(struct pthread_attr_t_));
+  printf("%30s %4d\n", "sem_t_", (int)sizeof(struct sem_t_));
+  printf("%30s %4d\n", "pthread_mutex_t_", (int)sizeof(struct pthread_mutex_t_));
+  printf("%30s %4d\n", "pthread_mutexattr_t_", (int)sizeof(struct pthread_mutexattr_t_));
+  printf("%30s %4d\n", "pthread_spinlock_t_", (int)sizeof(struct pthread_spinlock_t_));
+  printf("%30s %4d\n", "pthread_barrier_t_", (int)sizeof(struct pthread_barrier_t_));
+  printf("%30s %4d\n", "pthread_barrierattr_t_", (int)sizeof(struct pthread_barrierattr_t_));
+  printf("%30s %4d\n", "pthread_key_t_", (int)sizeof(struct pthread_key_t_));
+  printf("%30s %4d\n", "pthread_cond_t_", (int)sizeof(struct pthread_cond_t_));
+  printf("%30s %4d\n", "pthread_condattr_t_", (int)sizeof(struct pthread_condattr_t_));
+  printf("%30s %4d\n", "pthread_rwlock_t_", (int)sizeof(struct pthread_rwlock_t_));
+  printf("%30s %4d\n", "pthread_rwlockattr_t_", (int)sizeof(struct pthread_rwlockattr_t_));
+  printf("%30s %4d\n", "pthread_once_t_", (int)sizeof(struct pthread_once_t_));
+  printf("%30s %4d\n", "__ptw32_cleanup_t", (int)sizeof(struct __ptw32_cleanup_t));
+  printf("%30s %4d\n", "__ptw32_mcs_node_t_", (int)sizeof(struct __ptw32_mcs_node_t_));
+  printf("%30s %4d\n", "sched_param", (int)sizeof(struct sched_param));
+  printf("-------------------------------\n");
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/spin1.c b/src/include/pthread/tests/spin1.c
new file mode 100644
index 0000000..8aa4820
--- /dev/null
+++ b/src/include/pthread/tests/spin1.c
@@ -0,0 +1,57 @@
+/* 
+ * spin1.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Create a simple spinlock object, lock it, and then unlock it again.
+ * This is the simplest test of the pthread mutex family that we can do.
+ *
+ */
+
+#include "test.h"
+
+pthread_spinlock_t lock;
+
+int
+main()
+{
+  assert(pthread_spin_init(&lock, PTHREAD_PROCESS_PRIVATE) == 0);
+
+  assert(pthread_spin_lock(&lock) == 0);
+
+  assert(pthread_spin_unlock(&lock) == 0);
+
+  assert(pthread_spin_destroy(&lock) == 0);
+
+  assert(pthread_spin_lock(&lock) == EINVAL);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/spin2.c b/src/include/pthread/tests/spin2.c
new file mode 100644
index 0000000..50e1775
--- /dev/null
+++ b/src/include/pthread/tests/spin2.c
@@ -0,0 +1,73 @@
+/* 
+ * spin2.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Declare a spinlock object, lock it, trylock it, 
+ * and then unlock it again.
+ *
+ */
+
+#include "test.h"
+ 
+pthread_spinlock_t lock = NULL;
+
+static int washere = 0;
+
+void * func(void * arg)
+{
+  assert(pthread_spin_trylock(&lock) == EBUSY);
+
+  washere = 1;
+
+  return 0; 
+}
+ 
+int
+main()
+{
+  pthread_t t;
+
+  assert(pthread_spin_init(&lock, PTHREAD_PROCESS_PRIVATE) == 0);
+
+  assert(pthread_spin_lock(&lock) == 0);
+
+  assert(pthread_create(&t, NULL, func, NULL) == 0);
+  assert(pthread_join(t, NULL) == 0);
+
+  assert(pthread_spin_unlock(&lock) == 0);
+
+  assert(pthread_spin_destroy(&lock) == 0);
+
+  assert(washere == 1);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/spin3.c b/src/include/pthread/tests/spin3.c
new file mode 100644
index 0000000..a666226
--- /dev/null
+++ b/src/include/pthread/tests/spin3.c
@@ -0,0 +1,74 @@
+/* 
+ * spin3.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Thread A locks spin - thread B tries to unlock.
+ * This should succeed, but it's undefined behaviour.
+ *
+ */
+
+#include "test.h"
+
+static int wasHere = 0;
+
+static pthread_spinlock_t spin;
+ 
+void * unlocker(void * arg)
+{
+  int expectedResult = (int)(size_t)arg;
+
+  wasHere++;
+  assert(pthread_spin_unlock(&spin) == expectedResult);
+  wasHere++;
+  return NULL;
+}
+ 
+int
+main()
+{
+  pthread_t t;
+
+  wasHere = 0;
+  assert(pthread_spin_init(&spin, PTHREAD_PROCESS_PRIVATE) == 0);
+  assert(pthread_spin_lock(&spin) == 0);
+  assert(pthread_create(&t, NULL, unlocker, (void*)0) == 0);
+  assert(pthread_join(t, NULL) == 0);
+  /*
+   * Our spinlocks don't record the owner thread so any thread can unlock the spinlock,
+   * but nor is it an error for any thread to unlock a spinlock that is not locked.
+   */
+  assert(pthread_spin_unlock(&spin) == 0);
+  assert(pthread_spin_destroy(&spin) == 0);
+  assert(wasHere == 2);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/spin4.c b/src/include/pthread/tests/spin4.c
new file mode 100644
index 0000000..0aea33f
--- /dev/null
+++ b/src/include/pthread/tests/spin4.c
@@ -0,0 +1,101 @@
+/* 
+ * spin4.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Declare a static spinlock object, lock it, spin on it, 
+ * and then unlock it again.
+ */
+
+#include "test.h"
+#include <sys/timeb.h>
+ 
+pthread_spinlock_t lock = PTHREAD_SPINLOCK_INITIALIZER;
+__PTW32_STRUCT_TIMEB currSysTimeStart;
+__PTW32_STRUCT_TIMEB currSysTimeStop;
+
+#define GetDurationMilliSecs(_TStart, _TStop) ((_TStop.time*1000+_TStop.millitm) \
+					       - (_TStart.time*1000+_TStart.millitm))
+
+static int washere = 0;
+
+void * func(void * arg)
+{
+   __PTW32_FTIME(&currSysTimeStart);
+  washere = 1;
+  assert(pthread_spin_lock(&lock) == 0);
+  assert(pthread_spin_unlock(&lock) == 0);
+   __PTW32_FTIME(&currSysTimeStop);
+
+  return (void *)(size_t)GetDurationMilliSecs(currSysTimeStart, currSysTimeStop);
+}
+ 
+int
+main()
+{
+  void* result = (void*)0;
+  pthread_t t;
+  int CPUs;
+   __PTW32_STRUCT_TIMEB sysTime;
+
+  if ((CPUs = pthread_num_processors_np()) == 1)
+    {
+      printf("Test not run - it requires multiple CPUs.\n");
+	exit(0);
+    }
+
+  assert(pthread_spin_lock(&lock) == 0);
+
+  assert(pthread_create(&t, NULL, func, NULL) == 0);
+
+  while (washere == 0)
+    {
+      sched_yield();
+    }
+
+  do
+    {
+      sched_yield();
+       __PTW32_FTIME(&sysTime);
+    }
+  while (GetDurationMilliSecs(currSysTimeStart, sysTime) <= 1000);
+
+  assert(pthread_spin_unlock(&lock) == 0);
+
+  assert(pthread_join(t, &result) == 0);
+  assert((int)(size_t)result > 1000);
+
+  assert(pthread_spin_destroy(&lock) == 0);
+
+  assert(washere == 1);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/stress1.c b/src/include/pthread/tests/stress1.c
new file mode 100644
index 0000000..d632107
--- /dev/null
+++ b/src/include/pthread/tests/stress1.c
@@ -0,0 +1,246 @@
+/*
+ * stress1.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis:
+ * - Stress test condition variables, mutexes, semaphores.
+ *
+ * Test Method (Validation or Falsification):
+ * - Validation
+ *
+ * Requirements Tested:
+ * - Correct accounting of semaphore and condition variable waiters.
+ *
+ * Features Tested:
+ * - 
+ *
+ * Cases Tested:
+ * - 
+ *
+ * Description:
+ * Attempting to expose race conditions in cond vars, semaphores etc.
+ * - Master attempts to signal slave close to when timeout is due.
+ * - Master and slave do battle continuously until main tells them to stop.
+ * - Afterwards, the CV must be successfully destroyed (will return an
+ * error if there are waiters (including any internal semaphore waiters,
+ * which, if there are, cannot be real waiters).
+ *
+ * Environment:
+ * - 
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * - 
+ *
+ * Pass Criteria:
+ * - CV is successfully destroyed.
+ *
+ * Fail Criteria:
+ * - CV destroy fails.
+ */
+
+#include "test.h"
+#include <string.h>
+#include <sys/timeb.h>
+
+
+const unsigned int ITERATIONS = 1000;
+
+static pthread_t master, slave;
+typedef struct {
+  int value;
+  pthread_cond_t cv;
+  pthread_mutex_t mx;
+} mysig_t;
+
+static int allExit;
+static mysig_t control = {0, PTHREAD_COND_INITIALIZER, PTHREAD_MUTEX_INITIALIZER};
+static pthread_barrier_t startBarrier, readyBarrier, holdBarrier;
+static int timeoutCount = 0;
+static int signalsTakenCount = 0;
+static int signalsSent = 0;
+static int bias = 0;
+static int timeout = 10; // Must be > 0
+static const long NANOSEC_PER_MILLISEC = 1000000;
+
+enum {
+  CTL_STOP     = -1
+};
+
+void *
+masterThread (void * arg)
+{
+  int dither = (int)(size_t)arg;
+
+  timeout = (int)(size_t)arg;
+
+  pthread_barrier_wait(&startBarrier);
+
+  do
+    {
+      int sleepTime;
+
+      assert(pthread_mutex_lock(&control.mx) == 0);
+      control.value = timeout;
+      assert(pthread_mutex_unlock(&control.mx) == 0);
+
+      /*
+       * We are attempting to send the signal close to when the slave
+       * is due to timeout. We feel around by adding some [non-random] dither.
+       *
+       * dither is in the range 2*timeout peak-to-peak
+       * sleep time is the average of timeout plus dither.
+       * e.g.
+       * if timeout = 10 then dither = 20 and
+       * sleep millisecs is: 5 <= ms <= 15
+       *
+       * The bias value attempts to apply some negative feedback to keep
+       * the ratio of timeouts to signals taken close to 1:1.
+       * bias changes more slowly than dither so as to average more.
+       *
+       * Finally, if abs(bias) exceeds timeout then timeout is incremented.
+       */
+      if (signalsSent % timeout == 0)
+	{
+          if (timeoutCount > signalsTakenCount)
+	    {
+	      bias++;
+	    }
+          else if (timeoutCount < signalsTakenCount)
+	    {
+	      bias--;
+	    }
+	  if (bias < -timeout || bias > timeout)
+	    {
+	      timeout++;
+	    }
+	}
+      dither = (dither + 1 ) % (timeout * 2);
+      sleepTime = (timeout - bias + dither) / 2;
+      Sleep(sleepTime);
+      assert(pthread_cond_signal(&control.cv) == 0);
+      signalsSent++;
+
+      pthread_barrier_wait(&holdBarrier);
+      pthread_barrier_wait(&readyBarrier);
+    }
+  while (!allExit);
+
+  return NULL;
+}
+
+void *
+slaveThread (void * arg)
+{
+  struct timespec abstime, reltime;
+
+  pthread_barrier_wait(&startBarrier);
+
+  do
+    {
+      assert(pthread_mutex_lock(&control.mx) == 0);
+
+      reltime.tv_sec = (control.value / 1000);
+      reltime.tv_nsec = (control.value % 1000) * NANOSEC_PER_MILLISEC;
+
+      if (pthread_cond_timedwait(&control.cv,
+				 &control.mx,
+				 pthread_win32_getabstime_np(&abstime, &reltime)) == ETIMEDOUT)
+	{
+	  timeoutCount++;
+	}
+      else
+	{
+	  signalsTakenCount++;
+	}
+      assert(pthread_mutex_unlock(&control.mx) == 0);
+
+      pthread_barrier_wait(&holdBarrier);
+      pthread_barrier_wait(&readyBarrier);
+    }
+  while (!allExit);
+
+  return NULL;
+}
+
+int
+main ()
+{
+  unsigned int i;
+
+  assert(pthread_barrier_init(&startBarrier, NULL, 3) == 0);
+  assert(pthread_barrier_init(&readyBarrier, NULL, 3) == 0);
+  assert(pthread_barrier_init(&holdBarrier, NULL, 3) == 0);
+
+  assert(pthread_create(&master, NULL, masterThread, (void *)(size_t)timeout) == 0);
+  assert(pthread_create(&slave, NULL, slaveThread, NULL) == 0);
+
+  allExit = FALSE;
+
+  pthread_barrier_wait(&startBarrier);
+
+  for (i = 1; !allExit; i++)
+    {
+      pthread_barrier_wait(&holdBarrier);
+      if (i >= ITERATIONS)
+	{
+	  allExit = TRUE;
+	}
+      pthread_barrier_wait(&readyBarrier);
+    }
+
+  assert(pthread_join(slave, NULL) == 0);
+  assert(pthread_join(master, NULL) == 0);
+
+  printf("Signals sent = %d\nWait timeouts = %d\nSignals taken = %d\nBias = %d\nTimeout = %d\n",
+	 signalsSent,
+	 timeoutCount,
+	 signalsTakenCount,
+	 (int) bias,
+	 timeout);
+
+  /* Cleanup */
+  assert(pthread_barrier_destroy(&holdBarrier) == 0);
+  assert(pthread_barrier_destroy(&readyBarrier) == 0);
+  assert(pthread_barrier_destroy(&startBarrier) == 0);
+  assert(pthread_cond_destroy(&control.cv) == 0);
+  assert(pthread_mutex_destroy(&control.mx) == 0);
+
+  /* Success. */
+  return 0;
+}
diff --git a/src/include/pthread/tests/test.h b/src/include/pthread/tests/test.h
new file mode 100644
index 0000000..db72214
--- /dev/null
+++ b/src/include/pthread/tests/test.h
@@ -0,0 +1,201 @@
+/*
+ * test.h
+ *
+ * Useful definitions and declarations for tests.
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#ifndef _PTHREAD_TEST_H_
+#define _PTHREAD_TEST_H_
+
+/*
+ * Some tests sneak a peek at ../implement.h
+ * This is used inside ../implement.h to control
+ * what these test apps see and don't see.
+ */
+#define  __PTW32_TEST_SNEAK_PEEK
+
+#include "pthread.h"
+#include "sched.h"
+#include "semaphore.h"
+
+#include <windows.h>
+#include <stdio.h>
+#include <sys/timeb.h>
+/*
+ * FIXME: May not be available on all platforms.
+ */
+#include <errno.h>
+
+#define  __PTW32_THREAD_NULL_ID {NULL,0}
+
+/*
+ * Some non-thread POSIX API substitutes
+ */
+#if !defined(__MINGW64_VERSION_MAJOR)
+#  define rand_r( _seed ) \
+        ( _seed == _seed? rand() : rand() )
+#endif
+
+#if defined(__MINGW32__)
+# include <stdint.h>
+#elif defined(__BORLANDC__)
+# define int64_t ULONGLONG
+#else
+# define int64_t _int64
+#endif
+
+#if defined(_MSC_VER) && _MSC_VER >= 1400
+#  define  __PTW32_FTIME(x) _ftime64_s(x)
+#  define  __PTW32_STRUCT_TIMEB struct __timeb64
+#elif ( defined(_MSC_VER) && _MSC_VER >= 1300 ) || \
+      ( defined(__MINGW32__) && __MSVCRT_VERSION__ >= 0x0601 )
+#  define  __PTW32_FTIME(x) _ftime64(x)
+#  define  __PTW32_STRUCT_TIMEB struct __timeb64
+#else
+#  define  __PTW32_FTIME(x) _ftime(x)
+#  define  __PTW32_STRUCT_TIMEB struct _timeb
+#endif
+
+
+const char * error_string[] = {
+  "ZERO_or_EOK",
+  "EPERM",
+  "ENOFILE_or_ENOENT",
+  "ESRCH",
+  "EINTR",
+  "EIO",
+  "ENXIO",
+  "E2BIG",
+  "ENOEXEC",
+  "EBADF",
+  "ECHILD",
+  "EAGAIN",
+  "ENOMEM",
+  "EACCES",
+  "EFAULT",
+  "UNKNOWN_15",
+  "EBUSY",
+  "EEXIST",
+  "EXDEV",
+  "ENODEV",
+  "ENOTDIR",
+  "EISDIR",
+  "EINVAL",
+  "ENFILE",
+  "EMFILE",
+  "ENOTTY",
+  "UNKNOWN_26",
+  "EFBIG",
+  "ENOSPC",
+  "ESPIPE",
+  "EROFS",
+  "EMLINK",
+  "EPIPE",
+  "EDOM",
+  "ERANGE",
+  "UNKNOWN_35",
+  "EDEADLOCK_or_EDEADLK",
+  "UNKNOWN_37",
+  "ENAMETOOLONG",
+  "ENOLCK",
+  "ENOSYS",
+  "ENOTEMPTY",
+#if  __PTW32_VERSION_MAJOR > 2
+  "EILSEQ",
+#else
+  "EILSEQ_or_EOWNERDEAD",
+  "ENOTRECOVERABLE"
+#endif
+};
+
+/*
+ * The Mingw32 assert macro calls the CRTDLL _assert function
+ * which pops up a dialog. We want to run in batch mode so
+ * we define our own assert macro.
+ */
+#ifdef assert
+# undef assert
+#endif
+
+#ifndef ASSERT_TRACE
+# define ASSERT_TRACE 0
+#else
+# undef ASSERT_TRACE
+# define ASSERT_TRACE 1
+#endif
+
+# define assert(e) \
+   ((e) ? ((ASSERT_TRACE) ? fprintf(stderr, \
+                                    "Assertion succeeded: (%s), file %s, line %d\n", \
+			            #e, __FILE__, (int) __LINE__), \
+	                            fflush(stderr) : \
+                             0) : \
+          (fprintf(stderr, "Assertion failed: (%s), file %s, line %d\n", \
+                   #e, __FILE__, (int) __LINE__), exit(1), 0))
+
+int assertE;
+# define assert_e(e, o, r) \
+   (((assertE = e) o (r)) ? ((ASSERT_TRACE) ? fprintf(stderr, \
+                                    "Assertion succeeded: (%s), file %s, line %d\n", \
+			            #e, __FILE__, (int) __LINE__), \
+	                            fflush(stderr) : \
+                             0) : \
+       (assertE <= (int) (sizeof(error_string)/sizeof(error_string[0]))) ? \
+	   (fprintf(stderr, "Assertion failed: (%s %s %s), file %s, line %d, error %s\n", \
+			    #e,#o,#r, __FILE__, (int) __LINE__, error_string[assertE]), exit(1), 0) :\
+		   (fprintf(stderr, \
+			    "Assertion failed: (%s %s %s), file %s, line %d, error %d\n", \
+		            #e,#o,#r, __FILE__, (int) __LINE__, assertE), exit(1), 0))
+
+#endif
+
+# define BEGIN_MUTEX_STALLED_ROBUST(mxAttr) \
+  for(;;) \
+    { \
+      static int _i=0; \
+      static int _robust; \
+      pthread_mutexattr_getrobust(&(mxAttr), &_robust);
+
+# define END_MUTEX_STALLED_ROBUST(mxAttr) \
+      printf("Pass %s\n", _robust==PTHREAD_MUTEX_ROBUST?"Robust":"Non-robust"); \
+      if (++_i > 1) \
+        break; \
+      else \
+        { \
+          pthread_mutexattr_t *pma, *pmaEnd; \
+          for(pma = &(mxAttr), pmaEnd = pma + sizeof(mxAttr)/sizeof(pthread_mutexattr_t); \
+              pma < pmaEnd; \
+              pthread_mutexattr_setrobust(pma++, PTHREAD_MUTEX_ROBUST)); \
+        } \
+    }
+
+# define IS_ROBUST (_robust==PTHREAD_MUTEX_ROBUST)
diff --git a/src/include/pthread/tests/threestage.c b/src/include/pthread/tests/threestage.c
new file mode 100644
index 0000000..cd607f0
--- /dev/null
+++ b/src/include/pthread/tests/threestage.c
@@ -0,0 +1,583 @@
+/*
+ This source code is taken directly from examples in the book
+ Windows System Programming, Edition 4 by Johnson (John) Hart
+
+ Session 6, Chapter 10. ThreeStage.c
+
+ Several required additional header and source files from the
+ book examples have been included inline to simplify building.
+ The only modification to the code has been to provide default
+ values when run without arguments.
+
+ Three-stage Producer Consumer system
+ Other files required in this project, either directly or
+ in the form of libraries (DLLs are preferable)
+              QueueObj.c (inlined here)
+              Messages.c (inlined here)
+
+ Usage: ThreeStage npc goal [display]
+ start up "npc" paired producer  and consumer threads.
+          Display messages if "display" is non-zero
+ Each producer must produce a total of
+ "goal" messages, where each message is tagged
+ with the consumer that should receive it
+ Messages are sent to a "transmitter thread" which performs
+ additional processing before sending message groups to the
+ "receiver thread." Finally, the receiver thread sends
+ the messages to the consumer threads.
+
+ Transmitter: Receive messages one at a time from producers,
+ create a transmission message of up to "TBLOCK_SIZE" messages
+ to be sent to the Receiver. (this could be a network xfer
+ Receiver: Take message blocks sent by the Transmitter
+ and send the individual messages to the designated consumer
+ */
+
+/* Suppress warning re use of ctime() */
+#define _CRT_SECURE_NO_WARNINGS 1
+
+#include "test.h"
+#define sleep(i) Sleep(i*1000)
+#ifndef max
+#define max(a,b) ((a) > (b) ? (a) : (b))
+#endif
+
+#define DATA_SIZE 256
+typedef struct msg_block_tag { /* Message block */
+  pthread_mutex_t mguard; /* Mutex for  the message block */
+  pthread_cond_t  mconsumed; /* Event: Message consumed;          */
+  /* Produce a new one or stop    */
+  pthread_cond_t  mready; /* Event: Message ready         */
+  /*
+   * Note: the mutex and events are not used by some programs, such
+   * as Program 10-3, 4, 5 (the multi-stage pipeline) as the messages
+   * are part of a protected queue
+   */
+  volatile unsigned int source; /* Creating producer identity     */
+  volatile unsigned int destination;/* Identity of receiving thread*/
+
+  volatile unsigned int f_consumed;
+  volatile unsigned int f_ready;
+  volatile unsigned int f_stop;
+  /* Consumed & ready state flags, stop flag      */
+  volatile unsigned int sequence; /* Message block sequence number        */
+  time_t timestamp;
+  unsigned int checksum; /* Message contents checksum             */
+  unsigned int data[DATA_SIZE]; /* Message Contents               */
+} msg_block_t;
+
+void message_fill (msg_block_t *, unsigned int, unsigned int, unsigned int);
+void message_display (msg_block_t *);
+
+#define CV_TIMEOUT 5  /* tunable parameter for the CV model */
+
+
+/*
+ Definitions of a synchronized, general bounded queue structure.
+ Queues are implemented as arrays with indices to youngest
+ and oldest messages, with wrap around.
+ Each queue also contains a guard mutex and
+ "not empty" and "not full" condition variables.
+ Finally, there is a pointer to an array of messages of
+ arbitrary type
+ */
+
+typedef struct queue_tag {      /* General purpose queue        */
+  pthread_mutex_t q_guard;/* Guard the message block      */
+  pthread_cond_t  q_ne;   /* Event: Queue is not empty            */
+  pthread_cond_t  q_nf;   /* Event: Queue is not full                     */
+  /* These two events are manual-reset for the broadcast model
+   * and auto-reset for the signal model */
+  volatile unsigned int q_size;   /* Queue max size size          */
+  volatile unsigned int q_first;  /* Index of oldest message      */
+  volatile unsigned int q_last;   /* Index of youngest msg        */
+  volatile unsigned int q_destroyed;/* Q receiver has terminated  */
+  void *  msg_array;      /* array of q_size messages     */
+} queue_t;
+
+/* Queue management functions */
+unsigned int q_initialize (queue_t *, unsigned int, unsigned int);
+unsigned int q_destroy (queue_t *);
+unsigned int q_destroyed (queue_t *);
+unsigned int q_empty (queue_t *);
+unsigned int q_full (queue_t *);
+unsigned int q_get (queue_t *, void *, unsigned int, unsigned int);
+unsigned int q_put (queue_t *, void *, unsigned int, unsigned int);
+unsigned int q_remove (queue_t *, void *, unsigned int);
+unsigned int q_insert (queue_t *, void *, unsigned int);
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <time.h>
+
+#define DELAY_COUNT 1000
+#define MAX_THREADS 1024
+
+/* Queue lengths and blocking factors. These numbers are arbitrary and  */
+/* can be adjusted for performance tuning. The current values are       */
+/* not well balanced.                                                   */
+
+#define TBLOCK_SIZE 5   /* Transmitter combines this many messages at at time */
+#define Q_TIMEOUT 2000 /* Transmiter and receiver timeout (ms) waiting for messages */
+//#define Q_TIMEOUT INFINITE
+#define MAX_RETRY 5  /* Number of q_get retries before quitting */
+#define P2T_QLEN 10     /* Producer to Transmitter queue length */
+#define T2R_QLEN 4      /* Transmitter to Receiver queue length */
+#define R2C_QLEN 4      /* Receiver to Consumer queue length - there is one
+ * such queue for each consumer */
+
+void * producer (void *);
+void * consumer (void *);
+void * transmitter (void *);
+void * receiver (void *);
+
+
+typedef struct _THARG {
+  volatile unsigned int thread_number;
+  volatile unsigned int work_goal;    /* used by producers */
+  volatile unsigned int work_done;    /* Used by producers and consumers */
+} THARG;
+
+
+/* Grouped messages sent by the transmitter to receiver         */
+typedef struct T2R_MSG_TYPEag {
+  volatile unsigned int num_msgs; /* Number of messages contained */
+  msg_block_t messages [TBLOCK_SIZE];
+} T2R_MSG_TYPE;
+
+queue_t p2tq, t2rq, *r2cq_array;
+
+/* ShutDown, AllProduced are global flags to shut down the system & transmitter */
+static volatile unsigned int ShutDown = 0;
+static volatile unsigned int AllProduced = 0;
+static unsigned int DisplayMessages = 0;
+
+int main (int argc, char * argv[])
+{
+  unsigned int tstatus = 0, nthread, ithread, goal, thid;
+  pthread_t *producer_th, *consumer_th, transmitter_th, receiver_th;
+  THARG *producer_arg, *consumer_arg;
+
+  if (argc < 3) {
+      nthread = 32;
+      goal = 1000;
+  } else {
+      nthread = atoi(argv[1]);
+      goal = atoi(argv[2]);
+      if (argc >= 4)
+        DisplayMessages = atoi(argv[3]);
+  }
+
+  srand ((int)time(NULL));        /* Seed the RN generator */
+
+  if (nthread > MAX_THREADS) {
+      printf ("Maximum number of producers or consumers is %d.\n", MAX_THREADS);
+      return 2;
+  }
+  producer_th = (pthread_t *) malloc (nthread * sizeof(pthread_t));
+  producer_arg = (THARG *) calloc (nthread, sizeof (THARG));
+  consumer_th = (pthread_t *) malloc (nthread * sizeof(pthread_t));
+  consumer_arg = (THARG *) calloc (nthread, sizeof (THARG));
+
+  if (producer_th == NULL || producer_arg == NULL
+      || consumer_th == NULL || consumer_arg == NULL)
+    perror ("Cannot allocate working memory for threads.");
+
+  q_initialize (&p2tq, sizeof(msg_block_t), P2T_QLEN);
+  q_initialize (&t2rq, sizeof(T2R_MSG_TYPE), T2R_QLEN);
+  /* Allocate and initialize Receiver to Consumer queue for each consumer */
+  r2cq_array = (queue_t *) calloc (nthread, sizeof(queue_t));
+  if (r2cq_array == NULL) perror ("Cannot allocate memory for r2c queues");
+
+  for (ithread = 0; ithread < nthread; ithread++) {
+      /* Initialize r2c queue for this consumer thread */
+      q_initialize (&r2cq_array[ithread], sizeof(msg_block_t), R2C_QLEN);
+      /* Fill in the thread arg */
+      consumer_arg[ithread].thread_number = ithread;
+      consumer_arg[ithread].work_goal = goal;
+      consumer_arg[ithread].work_done = 0;
+
+      tstatus = pthread_create (&consumer_th[ithread], NULL,
+          consumer, (void *)&consumer_arg[ithread]);
+      if (tstatus != 0)
+        perror ("Cannot create consumer thread");
+
+      producer_arg[ithread].thread_number = ithread;
+      producer_arg[ithread].work_goal = goal;
+      producer_arg[ithread].work_done = 0;
+      tstatus = pthread_create (&producer_th[ithread], NULL,
+          producer, (void *)&producer_arg[ithread]);
+      if (tstatus != 0)
+        perror ("Cannot create producer thread");
+  }
+
+  tstatus = pthread_create (&transmitter_th, NULL, transmitter, &thid);
+  if (tstatus != 0)
+    perror ("Cannot create tranmitter thread");
+  tstatus = pthread_create (&receiver_th, NULL, receiver, &thid);
+  if (tstatus != 0)
+    perror ("Cannot create receiver thread");
+
+
+  printf ("BOSS: All threads are running\n");
+  /* Wait for the producers to complete */
+  /* The implementation allows too many threads for WaitForMultipleObjects */
+  /* although you could call WFMO in a loop */
+  for (ithread = 0; ithread < nthread; ithread++) {
+      tstatus = pthread_join (producer_th[ithread], NULL);
+      if (tstatus != 0)
+        perror ("Cannot wait for producer thread");
+      printf ("BOSS: Producer %d produced %d work units\n",
+          ithread, producer_arg[ithread].work_done);
+  }
+  /* Producers have completed their work. */
+  printf ("BOSS: All producers have completed their work.\n");
+  AllProduced = 1;
+
+  /* Wait for the consumers to complete */
+  for (ithread = 0; ithread < nthread; ithread++) {
+      tstatus = pthread_join (consumer_th[ithread], NULL);
+      if (tstatus != 0)
+        perror ("Cannot wait for consumer thread");
+      printf ("BOSS: consumer %d consumed %d work units\n",
+          ithread, consumer_arg[ithread].work_done);
+  }
+  printf ("BOSS: All consumers have completed their work.\n");
+
+  ShutDown = 1; /* Set a shutdown flag - All messages have been consumed */
+
+  /* Wait for the transmitter and receiver */
+
+  tstatus = pthread_join (transmitter_th, NULL);
+  if (tstatus != 0)
+    perror ("Failed waiting for transmitter");
+  tstatus = pthread_join (receiver_th, NULL);
+  if (tstatus != 0)
+    perror ("Failed waiting for receiver");
+
+  q_destroy (&p2tq);
+  q_destroy (&t2rq);
+  for (ithread = 0; ithread < nthread; ithread++)
+    q_destroy (&r2cq_array[ithread]);
+  free (r2cq_array);
+  free (producer_th);
+  free (consumer_th);
+  free (producer_arg);
+  free(consumer_arg);
+  printf ("System has finished. Shutting down\n");
+  return 0;
+}
+
+void * producer (void * arg)
+{
+  THARG * parg;
+  unsigned int ithread, tstatus = 0;
+  msg_block_t msg;
+
+  parg = (THARG *)arg;
+  ithread = parg->thread_number;
+
+  while (parg->work_done < parg->work_goal && !ShutDown) {
+      /* Periodically produce work units until the goal is satisfied */
+      /* messages receive a source and destination address which are */
+      /* the same in this case but could, in general, be different. */
+      sleep (rand()/100000000);
+      message_fill (&msg, ithread, ithread, parg->work_done);
+
+      /* put the message in the queue - Use an infinite timeout to assure
+       * that the message is inserted, even if consumers are delayed */
+      tstatus = q_put (&p2tq, &msg, sizeof(msg), INFINITE);
+      if (0 == tstatus) {
+          parg->work_done++;
+      }
+  }
+
+  return 0;
+}
+
+void * consumer (void * arg)
+{
+  THARG * carg;
+  unsigned int tstatus = 0, ithread, Retries = 0;
+  msg_block_t msg;
+  queue_t *pr2cq;
+
+  carg = (THARG *) arg;
+  ithread = carg->thread_number;
+
+  carg = (THARG *)arg;
+  pr2cq = &r2cq_array[ithread];
+
+  while (carg->work_done < carg->work_goal && Retries < MAX_RETRY && !ShutDown) {
+      /* Receive and display/process messages */
+      /* Try to receive the requested number of messages,
+       * but allow for early system shutdown */
+
+      tstatus = q_get (pr2cq, &msg, sizeof(msg), Q_TIMEOUT);
+      if (0 == tstatus) {
+          if (DisplayMessages > 0) message_display (&msg);
+          carg->work_done++;
+          Retries = 0;
+      } else {
+          Retries++;
+      }
+  }
+
+  return NULL;
+}
+
+void * transmitter (void * arg)
+{
+
+  /* Obtain multiple producer messages, combining into a single   */
+  /* compound message for the receiver */
+
+  unsigned int tstatus = 0, im, Retries = 0;
+  T2R_MSG_TYPE t2r_msg = {0};
+  msg_block_t p2t_msg;
+
+  while (!ShutDown && !AllProduced) {
+      t2r_msg.num_msgs = 0;
+      /* pack the messages for transmission to the receiver */
+      im = 0;
+      while (im < TBLOCK_SIZE && !ShutDown && Retries < MAX_RETRY && !AllProduced) {
+          tstatus = q_get (&p2tq, &p2t_msg, sizeof(p2t_msg), Q_TIMEOUT);
+          if (0 == tstatus) {
+              memcpy (&t2r_msg.messages[im], &p2t_msg, sizeof(p2t_msg));
+              t2r_msg.num_msgs++;
+              im++;
+              Retries = 0;
+          } else { /* Timed out.  */
+              Retries++;
+          }
+      }
+      tstatus = q_put (&t2rq, &t2r_msg, sizeof(t2r_msg), INFINITE);
+      if (tstatus != 0) return NULL;
+  }
+  return NULL;
+}
+
+
+void * receiver (void * arg)
+{
+  /* Obtain compound messages from the transmitter and unblock them       */
+  /* and transmit to the designated consumer.                             */
+
+  unsigned int tstatus = 0, im, ic, Retries = 0;
+  T2R_MSG_TYPE t2r_msg;
+  msg_block_t r2c_msg;
+
+  while (!ShutDown && Retries < MAX_RETRY) {
+      tstatus = q_get (&t2rq, &t2r_msg, sizeof(t2r_msg), Q_TIMEOUT);
+      if (tstatus != 0) { /* Timeout - Have the producers shut down? */
+          Retries++;
+          continue;
+      }
+      Retries = 0;
+      /* Distribute the packaged messages to the proper consumer */
+      im = 0;
+      while (im < t2r_msg.num_msgs) {
+          memcpy (&r2c_msg, &t2r_msg.messages[im], sizeof(r2c_msg));
+          ic = r2c_msg.destination; /* Destination consumer */
+          tstatus = q_put (&r2cq_array[ic], &r2c_msg, sizeof(r2c_msg), INFINITE);
+          if (0 == tstatus) im++;
+      }
+  }
+  return NULL;
+}
+
+#if (!defined INFINITE)
+#define INFINITE 0xFFFFFFFF
+#endif
+
+/*
+ Finite bounded queue management functions
+ q_get, q_put timeouts (max_wait) are in ms - convert to sec, rounding up
+ */
+unsigned int q_get (queue_t *q, void * msg, unsigned int msize, unsigned int MaxWait)
+{
+  int tstatus = 0, got_msg = 0, time_inc = (MaxWait + 999) /1000;
+  struct timespec timeout;
+  timeout.tv_nsec = 0;
+
+  if (q_destroyed(q)) return 1;
+  pthread_mutex_lock (&q->q_guard);
+  while (q_empty (q) && 0 == tstatus) {
+      if (MaxWait != INFINITE) {
+          timeout.tv_sec = time(NULL) + time_inc;
+          tstatus = pthread_cond_timedwait (&q->q_ne, &q->q_guard, &timeout);
+      } else {
+          tstatus = pthread_cond_wait (&q->q_ne, &q->q_guard);
+      }
+  }
+  /* remove the message, if any, from the queue */
+  if (0 == tstatus && !q_empty (q)) {
+      q_remove (q, msg, msize);
+      got_msg = 1;
+      /* Signal that the queue is not full as we've removed a message */
+      pthread_cond_broadcast (&q->q_nf);
+  }
+  pthread_mutex_unlock (&q->q_guard);
+  return (0 == tstatus && got_msg == 1 ? 0 : max(1, tstatus));   /* 0 indicates success */
+}
+
+unsigned int q_put (queue_t *q, void * msg, unsigned int msize, unsigned int MaxWait)
+{
+  int tstatus = 0, put_msg = 0, time_inc = (MaxWait + 999) /1000;
+  struct timespec timeout;
+  timeout.tv_nsec = 0;
+
+  if (q_destroyed(q)) return 1;
+  pthread_mutex_lock (&q->q_guard);
+  while (q_full (q) && 0 == tstatus) {
+      if (MaxWait != INFINITE) {
+          timeout.tv_sec = time(NULL) + time_inc;
+          tstatus = pthread_cond_timedwait (&q->q_nf, &q->q_guard, &timeout);
+      } else {
+          tstatus = pthread_cond_wait (&q->q_nf, &q->q_guard);
+      }
+  }
+  /* Insert the message into the queue if there's room */
+  if (0 == tstatus && !q_full (q)) {
+      q_insert (q, msg, msize);
+      put_msg = 1;
+      /* Signal that the queue is not empty as we've inserted a message */
+      pthread_cond_broadcast (&q->q_ne);
+  }
+  pthread_mutex_unlock (&q->q_guard);
+  return (0 == tstatus && put_msg == 1 ? 0 : max(1, tstatus));   /* 0 indictates success */
+}
+
+unsigned int q_initialize (queue_t *q, unsigned int msize, unsigned int nmsgs)
+{
+  /* Initialize queue, including its mutex and events */
+  /* Allocate storage for all messages. */
+
+  q->q_first = q->q_last = 0;
+  q->q_size = nmsgs;
+  q->q_destroyed = 0;
+
+  pthread_mutex_init (&q->q_guard, NULL);
+  pthread_cond_init (&q->q_ne, NULL);
+  pthread_cond_init (&q->q_nf, NULL);
+
+  if ((q->msg_array = calloc (nmsgs, msize)) == NULL) return 1;
+  return 0; /* No error */
+}
+
+unsigned int q_destroy (queue_t *q)
+{
+  if (q_destroyed(q)) return 1;
+  /* Free all the resources created by q_initialize */
+  pthread_mutex_lock (&q->q_guard);
+  q->q_destroyed = 1;
+  free (q->msg_array);
+  pthread_cond_destroy (&q->q_ne);
+  pthread_cond_destroy (&q->q_nf);
+  pthread_mutex_unlock (&q->q_guard);
+  pthread_mutex_destroy (&q->q_guard);
+
+  return 0;
+}
+
+unsigned int q_destroyed (queue_t *q)
+{
+  return (q->q_destroyed);
+}
+
+unsigned int q_empty (queue_t *q)
+{
+  return (q->q_first == q->q_last);
+}
+
+unsigned int q_full (queue_t *q)
+{
+  return ((q->q_first - q->q_last) == 1 ||
+      (q->q_last == q->q_size-1 && q->q_first == 0));
+}
+
+
+unsigned int q_remove (queue_t *q, void * msg, unsigned int msize)
+{
+  char *pm;
+
+  pm = (char *)q->msg_array;
+  /* Remove oldest ("first") message */
+  memcpy (msg, pm + (q->q_first * msize), msize);
+  // Invalidate the message
+  q->q_first = ((q->q_first + 1) % q->q_size);
+  return 0; /* no error */
+}
+
+unsigned int q_insert (queue_t *q, void * msg, unsigned int msize)
+{
+  char *pm;
+
+  pm = (char *)q->msg_array;
+  /* Add a new youngest ("last") message */
+  if (q_full(q)) return 1; /* Error - Q is full */
+  memcpy (pm + (q->q_last * msize), msg, msize);
+  q->q_last = ((q->q_last + 1) % q->q_size);
+
+  return 0;
+}
+
+unsigned int compute_checksum (void * msg, unsigned int length)
+{
+  /* Computer an xor checksum on the entire message of "length"
+   * integers */
+  unsigned int i, cs = 0, *pint;
+
+  pint = (unsigned int *) msg;
+  for (i = 0; i < length; i++) {
+      cs = (cs ^ *pint);
+      pint++;
+  }
+  return cs;
+}
+
+void  message_fill (msg_block_t *mblock, unsigned int src, unsigned int dest, unsigned int seqno)
+{
+  /* Fill the message buffer, and include checksum and timestamp  */
+  /* This function is called from the producer thread while it    */
+  /* owns the message block mutex                                 */
+
+  unsigned int i;
+
+  mblock->checksum = 0;
+  for (i = 0; i < DATA_SIZE; i++) {
+      mblock->data[i] = rand();
+  }
+  mblock->source = src;
+  mblock->destination = dest;
+  mblock->sequence = seqno;
+  mblock->timestamp = time(NULL);
+  mblock->checksum = compute_checksum (mblock, sizeof(msg_block_t)/sizeof(unsigned int));
+  /*      printf ("Generated message: %d %d %d %d %x %x\n",
+                src, dest, seqno, mblock->timestamp,
+                mblock->data[0], mblock->data[DATA_SIZE-1]);  */
+  return;
+}
+
+void  message_display (msg_block_t *mblock)
+{
+  /* Display message buffer and timestamp, validate checksum      */
+  /* This function is called from the consumer thread while it    */
+  /* owns the message block mutex                                 */
+  unsigned int tcheck = 0;
+
+  tcheck = compute_checksum (mblock, sizeof(msg_block_t)/sizeof(unsigned int));
+  printf ("\nMessage number %d generated at: %s",
+      mblock->sequence, ctime (&(mblock->timestamp)));
+  printf ("Source and destination: %d %d\n",
+      mblock->source, mblock->destination);
+  printf ("First and last entries: %x %x\n",
+      mblock->data[0], mblock->data[DATA_SIZE-1]);
+  if (tcheck == 0 /*mblock->checksum was 0 when CS first computed */)
+    printf ("GOOD ->Checksum was validated.\n");
+  else
+    printf ("BAD  ->Checksum failed. message was corrupted\n");
+
+  return;
+
+}
diff --git a/src/include/pthread/tests/timeouts.c b/src/include/pthread/tests/timeouts.c
new file mode 100644
index 0000000..99d8a0c
--- /dev/null
+++ b/src/include/pthread/tests/timeouts.c
@@ -0,0 +1,251 @@
+/*
+ * File: timeouts.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis:
+ * - confirm accuracy of abstime calculations and timeouts
+ *
+ * Test Method (Validation or Falsification):
+ * - time actual CV wait timeout using a sequence of increasing sub 1 second timeouts.
+ *
+ * Requirements Tested:
+ * -
+ *
+ * Features Tested:
+ * -
+ *
+ * Cases Tested:
+ * -
+ *
+ * Description:
+ * -
+ *
+ * Environment:
+ * -
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - Printed measured elapsed time should closely match specified timeout.
+ * - Return code should always be ETIMEDOUT (usually 138 but possibly 10060)
+ *
+ * Assumptions:
+ * -
+ *
+ * Pass Criteria:
+ * - Relies on observation.
+ *
+ * Fail Criteria:
+ * -
+ */
+
+#include "test.h"
+
+/*
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <sys/timeb.h>
+#include <windows.h>
+
+#include "pthread.h"
+
+#define DEFAULT_MINTIME_INIT    999999999
+#define CYG_ONEBILLION          1000000000LL
+#define CYG_ONEMILLION          1000000LL
+#define CYG_ONEKAPPA            1000LL
+
+#if defined(_MSC_VER) && (_MSC_VER > 1200)
+typedef long long cyg_tim_t; //msvc > 6.0
+#else
+typedef int64_t cyg_tim_t; //msvc 6.0
+#endif
+
+LARGE_INTEGER frequency;
+LARGE_INTEGER global_start;
+
+cyg_tim_t CYG_DIFFT(cyg_tim_t t1, cyg_tim_t t2)
+{
+  return (cyg_tim_t)((t2 - t1) * CYG_ONEBILLION / frequency.QuadPart); //nsec
+}
+
+void CYG_InitTimers()
+{
+  QueryPerformanceFrequency(&frequency);
+  global_start.QuadPart = 0;
+}
+
+void CYG_MARK1(cyg_tim_t *T)
+{
+  LARGE_INTEGER curTime;
+  QueryPerformanceCounter (&curTime);
+  *T = (curTime.QuadPart);// + global_start.QuadPart);
+}
+
+///////////////////GetTimestampTS/////////////////
+
+#if 1
+
+int GetTimestampTS(struct timespec *tv)
+{
+  struct _timeb timebuffer;
+
+#if !(_MSC_VER <= 1200)
+  _ftime64_s( &timebuffer ); //msvc > 6.0
+#else
+  _ftime( &timebuffer ); //msvc = 6.0
+#endif
+
+  tv->tv_sec = timebuffer.time;
+  tv->tv_nsec = 1000000L * timebuffer.millitm;
+  return 0;
+}
+
+#else
+
+int GetTimestampTS(struct timespec *tv)
+{
+  static LONGLONG     epoch = 0;
+  SYSTEMTIME          local;
+  FILETIME            abs;
+  LONGLONG            now;
+
+  if(!epoch) {
+      memset(&local,0,sizeof(SYSTEMTIME));
+      local.wYear = 1970;
+      local.wMonth = 1;
+      local.wDay = 1;
+      local.wHour = 0;
+      local.wMinute = 0;
+      local.wSecond = 0;
+      SystemTimeToFileTime(&local, &abs);
+      epoch = *(LONGLONG *)&abs;
+  }
+  GetSystemTime(&local);
+  SystemTimeToFileTime(&local, &abs);
+  now = *(LONGLONG *)&abs;
+  now = now - epoch;
+  tv->tv_sec = (long)(now / 10000000);
+  tv->tv_nsec = (long)((now * 100) % 1000000000);
+
+  return 0;
+}
+
+#endif
+
+///////////////////GetTimestampTS/////////////////
+
+
+#define MSEC_F 1000000L
+#define USEC_F 1000L
+#define NSEC_F 1L
+
+pthread_mutexattr_t mattr_;
+pthread_mutex_t mutex_;
+pthread_condattr_t cattr_;
+pthread_cond_t cv_;
+
+int Init(void)
+{
+  assert(0 == pthread_mutexattr_init(&mattr_));
+  assert(0 == pthread_mutex_init(&mutex_, &mattr_));
+  assert(0 == pthread_condattr_init(&cattr_));
+  assert(0 == pthread_cond_init(&cv_, &cattr_));
+  return 0;
+}
+
+int Destroy(void)
+{
+  assert(0 == pthread_cond_destroy(&cv_));
+  assert(0 == pthread_mutex_destroy(&mutex_));
+  assert(0 == pthread_mutexattr_destroy(&mattr_));
+  assert(0 == pthread_condattr_destroy(&cattr_));
+  return 0;
+}
+
+int Wait(time_t sec, long nsec)
+{
+  struct timespec abstime;
+  long sc;
+  int result = 0;
+  GetTimestampTS(&abstime);
+  abstime.tv_sec  += sec;
+  abstime.tv_nsec += nsec;
+  if((sc = (abstime.tv_nsec / 1000000000L))){
+      abstime.tv_sec += sc;
+      abstime.tv_nsec %= 1000000000L;
+  }
+  assert(0 == pthread_mutex_lock(&mutex_));
+  /*
+   * We don't need to check the CV.
+   */
+  result = pthread_cond_timedwait(&cv_, &mutex_, &abstime);
+  assert(result != 0);
+  assert(errno == ETIMEDOUT);
+  pthread_mutex_unlock(&mutex_);
+  return result;
+}
+
+char tbuf[128];
+void printtim(cyg_tim_t rt, cyg_tim_t dt, int wres)
+{
+  printf("wait result [%d]: timeout(ms) [expected/actual]: %ld/%ld\n", wres, (long)(rt/CYG_ONEMILLION), (long)(dt/CYG_ONEMILLION));
+}
+
+
+int main(int argc, char* argv[])
+{
+  int i = 0;
+  int wres = 0;
+  cyg_tim_t t1, t2, dt, rt;
+
+  CYG_InitTimers();
+
+  Init();
+
+  while(i++ < 10){
+      rt = 90*i*MSEC_F;
+      CYG_MARK1(&t1);
+      wres = Wait(0, (long)(size_t)rt);
+      CYG_MARK1(&t2);
+      dt = CYG_DIFFT(t1, t2);
+      printtim(rt, dt, wres);
+  }
+
+  Destroy();
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/tryentercs.c b/src/include/pthread/tests/tryentercs.c
new file mode 100644
index 0000000..51154e6
--- /dev/null
+++ b/src/include/pthread/tests/tryentercs.c
@@ -0,0 +1,101 @@
+/*
+ * tryentercs.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * See if we have the TryEnterCriticalSection function.
+ * Does not use any part of pthreads.
+ */
+
+#include <windows.h>
+#include <process.h>
+#include <stdio.h>
+
+/*
+ * Function pointer to TryEnterCriticalSection if it exists
+ * - otherwise NULL
+ */
+BOOL (WINAPI *_try_enter_critical_section)(LPCRITICAL_SECTION) =
+NULL;
+
+/*
+ * Handle to kernel32.dll
+ */
+static HINSTANCE _h_kernel32;
+
+
+int
+main()
+{
+  CRITICAL_SECTION cs;
+
+  SetLastError(0);
+
+  printf("Last Error [main enter] %ld\n", (long) GetLastError());
+
+  /*
+   * Load KERNEL32 and try to get address of TryEnterCriticalSection
+   */
+  _h_kernel32 = LoadLibrary(TEXT("KERNEL32.DLL"));
+  _try_enter_critical_section =
+        (BOOL (PT_STDCALL *)(LPCRITICAL_SECTION))
+        GetProcAddress(_h_kernel32,
+                         (LPCSTR) "TryEnterCriticalSection");
+
+  if (_try_enter_critical_section != NULL)
+    {
+      InitializeCriticalSection(&cs);
+
+      SetLastError(0);
+
+      if ((*_try_enter_critical_section)(&cs) != 0)
+        {
+          LeaveCriticalSection(&cs);
+        }
+	else
+	  {
+	    printf("Last Error [try enter] %ld\n", (long) GetLastError());
+
+	    _try_enter_critical_section = NULL;
+	  }
+      DeleteCriticalSection(&cs);
+    }
+
+  (void) FreeLibrary(_h_kernel32);
+
+  printf("This system %s TryEnterCriticalSection.\n",
+         (_try_enter_critical_section == NULL) ? "DOES NOT SUPPORT" : "SUPPORTS");
+  printf("POSIX Mutexes will be based on Win32 %s.\n",
+         (_try_enter_critical_section == NULL) ? "Mutexes" : "Critical Sections");
+
+  return(0);
+}
+
diff --git a/src/include/pthread/tests/tryentercs2.c b/src/include/pthread/tests/tryentercs2.c
new file mode 100644
index 0000000..a747b0f
--- /dev/null
+++ b/src/include/pthread/tests/tryentercs2.c
@@ -0,0 +1,90 @@
+/*
+ * tryentercs.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * See if we have the TryEnterCriticalSection function.
+ * Does not use any part of pthreads.
+ */
+
+#include <windows.h>
+#include <process.h>
+#include <stdio.h>
+
+/*
+ * Function pointer to TryEnterCriticalSection if it exists
+ * - otherwise NULL
+ */
+BOOL (WINAPI *_try_enter_critical_section)(LPCRITICAL_SECTION) = NULL;
+
+/*
+ * Handle to kernel32.dll
+ */
+static HINSTANCE _h_kernel32;
+
+
+int
+main()
+{
+  LPCRITICAL_SECTION lpcs = NULL;
+
+  SetLastError(0);
+
+  printf("Last Error [main enter] %ld\n", (long) GetLastError());
+
+  /*
+   * Load KERNEL32 and try to get address of TryEnterCriticalSection
+   */
+  _h_kernel32 = LoadLibrary(TEXT("KERNEL32.DLL"));
+  _try_enter_critical_section =
+        (BOOL (PT_STDCALL *)(LPCRITICAL_SECTION))
+        GetProcAddress(_h_kernel32,
+                         (LPCSTR) "TryEnterCriticalSection");
+
+  if (_try_enter_critical_section != NULL)
+    {
+      SetLastError(0);
+
+      (*_try_enter_critical_section)(lpcs);
+
+      printf("Last Error [try enter] %ld\n", (long) GetLastError());
+    }
+
+  (void) FreeLibrary(_h_kernel32);
+
+  printf("This system %s TryEnterCriticalSection.\n",
+         (_try_enter_critical_section == NULL) ? "DOES NOT SUPPORT" : "SUPPORTS");
+  printf("POSIX Mutexes will be based on Win32 %s.\n",
+         (_try_enter_critical_section == NULL) ? "Mutexes" : "Critical Sections");
+
+  return(0);
+}
+
diff --git a/src/include/pthread/tests/tsd1.c b/src/include/pthread/tests/tsd1.c
new file mode 100644
index 0000000..ecae5a5
--- /dev/null
+++ b/src/include/pthread/tests/tsd1.c
@@ -0,0 +1,204 @@
+/*
+ * tsd1.c
+ *
+ * Test Thread Specific Data (TSD) key creation and destruction.
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Description:
+ * -
+ *
+ * Test Method (validation or falsification):
+ * - validation
+ *
+ * Requirements Tested:
+ * - keys are created for each existing thread including the main thread
+ * - keys are created for newly created threads
+ * - keys are thread specific
+ * - destroy routine is called on each thread exit including the main thread
+ *
+ * Features Tested:
+ * -
+ *
+ * Cases Tested:
+ * -
+ *
+ * Environment:
+ * -
+ *
+ * Input:
+ * - none
+ *
+ * Output:
+ * - text to stdout
+ *
+ * Assumptions:
+ * - already validated:     pthread_create()
+ *                          pthread_once()
+ * - main thread also has a POSIX thread identity
+ *
+ * Pass Criteria:
+ *
+ * Fail Criteria:
+ */
+
+#include <sched.h>
+#include "test.h"
+
+enum {
+  NUM_THREADS = 100
+};
+
+static pthread_key_t key = NULL;
+static int accesscount[NUM_THREADS];
+static int thread_set[NUM_THREADS];
+static int thread_destroyed[NUM_THREADS];
+static pthread_barrier_t startBarrier;
+
+static void
+destroy_key(void * arg)
+{
+  int * j = (int *) arg;
+
+  (*j)++;
+
+  assert(*j == 2);
+
+  thread_destroyed[j - accesscount] = 1;
+}
+
+static void
+setkey(void * arg)
+{
+  int * j = (int *) arg;
+
+  thread_set[j - accesscount] = 1;
+
+  assert(*j == 0);
+
+  assert(pthread_getspecific(key) == NULL);
+
+  assert(pthread_setspecific(key, arg) == 0);
+  assert(pthread_setspecific(key, arg) == 0);
+  assert(pthread_setspecific(key, arg) == 0);
+
+  assert(pthread_getspecific(key) == arg);
+
+  (*j)++;
+
+  assert(*j == 1);
+}
+
+static void *
+mythread(void * arg)
+{
+  (void) pthread_barrier_wait(&startBarrier);
+
+  setkey(arg);
+
+  return 0;
+
+  /* Exiting the thread will call the key destructor. */
+}
+
+int
+main()
+{
+  int i;
+  int fail = 0;
+  pthread_t thread[NUM_THREADS];
+
+  assert(pthread_barrier_init(&startBarrier, NULL, NUM_THREADS/2) == 0);
+
+  for (i = 1; i < NUM_THREADS/2; i++)
+    {
+      accesscount[i] = thread_set[i] = thread_destroyed[i] = 0;
+      assert(pthread_create(&thread[i], NULL, mythread, (void *)&accesscount[i]) == 0);
+    }
+
+  /*
+   * Here we test that existing threads will get a key created
+   * for them.
+   */
+  assert(pthread_key_create(&key, destroy_key) == 0);
+
+  (void) pthread_barrier_wait(&startBarrier);
+
+  /*
+   * Test main thread key.
+   */
+  accesscount[0] = 0;
+  setkey((void *) &accesscount[0]);
+
+  /*
+   * Here we test that new threads will get a key created
+   * for them.
+   */
+  for (i = NUM_THREADS/2; i < NUM_THREADS; i++)
+    {
+      accesscount[i] = thread_set[i] = thread_destroyed[i] = 0;
+      assert(pthread_create(&thread[i], NULL, mythread, (void *)&accesscount[i]) == 0);
+    }
+
+  /*
+   * Wait for all threads to complete.
+   */
+  for (i = 1; i < NUM_THREADS; i++)
+    {
+	assert(pthread_join(thread[i], NULL) == 0);
+    }
+
+  assert(pthread_key_delete(key) == 0);
+
+  assert(pthread_barrier_destroy(&startBarrier) == 0);
+
+  for (i = 1; i < NUM_THREADS; i++)
+    {
+      /*
+       * The counter is incremented once when the key is set to
+       * a value, and again when the key is destroyed. If the key
+       * doesn't get set for some reason then it will still be
+       * NULL and the destroy function will not be called, and
+       * hence accesscount will not equal 2.
+       */
+      if (accesscount[i] != 2)
+        {
+          fail++;
+          fprintf(stderr, "Thread %d key, set = %d, destroyed = %d\n",
+              i, thread_set[i], thread_destroyed[i]);
+        }
+    }
+
+  fflush(stderr);
+
+  return (fail);
+}
diff --git a/src/include/pthread/tests/tsd2.c b/src/include/pthread/tests/tsd2.c
new file mode 100644
index 0000000..38c8db6
--- /dev/null
+++ b/src/include/pthread/tests/tsd2.c
@@ -0,0 +1,214 @@
+/*
+ * tsd2.c
+ *
+ * Test Thread Specific Data (TSD) key creation and destruction.
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Description:
+ * -
+ *
+ * Test Method (validation or falsification):
+ * - validation
+ *
+ * Requirements Tested:
+ * - keys are created for each existing thread including the main thread
+ * - keys are created for newly created threads
+ * - keys are thread specific
+ * - destroy routine is called on each thread exit including the main thread
+ *
+ * Features Tested:
+ * -
+ *
+ * Cases Tested:
+ * -
+ *
+ * Environment:
+ * -
+ *
+ * Input:
+ * - none
+ *
+ * Output:
+ * - text to stdout
+ *
+ * Assumptions:
+ * - already validated:     pthread_create()
+ *                          pthread_once()
+ * - main thread also has a POSIX thread identity
+ *
+ * Pass Criteria:
+ *
+ * Fail Criteria:
+ */
+
+#include <sched.h>
+#include "test.h"
+
+enum {
+  NUM_THREADS = 100
+};
+
+static pthread_key_t key = NULL;
+static int accesscount[NUM_THREADS];
+static int thread_set[NUM_THREADS];
+static int thread_destroyed[NUM_THREADS];
+static pthread_barrier_t startBarrier;
+
+static void
+destroy_key(void * arg)
+{
+  int * j = (int *) arg;
+
+  (*j)++;
+
+  /*
+   * Set TSD key from the destructor to test destructor iteration.
+   * The key value will have been set to NULL by the library before
+   * calling the destructor (with the value that the key had). We
+   * reset the key value here which should cause the destructor to be
+   * called a second time.
+   */
+  if (*j == 2)
+    assert(pthread_setspecific(key, arg) == 0);
+  else
+    assert(*j == 3);
+
+  thread_destroyed[j - accesscount] = 1;
+}
+
+static void
+setkey(void * arg)
+{
+  int * j = (int *) arg;
+
+  thread_set[j - accesscount] = 1;
+
+  assert(*j == 0);
+
+  assert(pthread_getspecific(key) == NULL);
+
+  assert(pthread_setspecific(key, arg) == 0);
+  assert(pthread_setspecific(key, arg) == 0);
+  assert(pthread_setspecific(key, arg) == 0);
+
+  assert(pthread_getspecific(key) == arg);
+
+  (*j)++;
+
+  assert(*j == 1);
+}
+
+static void *
+mythread(void * arg)
+{
+  (void) pthread_barrier_wait(&startBarrier);
+
+  setkey(arg);
+
+  return 0;
+
+  /* Exiting the thread will call the key destructor. */
+}
+
+int
+main()
+{
+  int i;
+  int fail = 0;
+  pthread_t thread[NUM_THREADS];
+
+  assert(pthread_barrier_init(&startBarrier, NULL, NUM_THREADS/2) == 0);
+
+  for (i = 1; i < NUM_THREADS/2; i++)
+    {
+      accesscount[i] = thread_set[i] = thread_destroyed[i] = 0;
+      assert(pthread_create(&thread[i], NULL, mythread, (void *)&accesscount[i]) == 0);
+    }
+
+  /*
+   * Here we test that existing threads will get a key created
+   * for them.
+   */
+  assert(pthread_key_create(&key, destroy_key) == 0);
+
+  (void) pthread_barrier_wait(&startBarrier);
+
+  /*
+   * Test main thread key.
+   */
+  accesscount[0] = 0;
+  setkey((void *) &accesscount[0]);
+
+  /*
+   * Here we test that new threads will get a key created
+   * for them.
+   */
+  for (i = NUM_THREADS/2; i < NUM_THREADS; i++)
+    {
+      accesscount[i] = thread_set[i] = thread_destroyed[i] = 0;
+      assert(pthread_create(&thread[i], NULL, mythread, (void *)&accesscount[i]) == 0);
+    }
+
+  /*
+   * Wait for all threads to complete.
+   */
+  for (i = 1; i < NUM_THREADS; i++)
+    {
+	assert(pthread_join(thread[i], NULL) == 0);
+    }
+
+  assert(pthread_key_delete(key) == 0);
+
+  assert(pthread_barrier_destroy(&startBarrier) == 0);
+
+  for (i = 1; i < NUM_THREADS; i++)
+    {
+      /*
+       * The counter is incremented once when the key is set to
+       * a value, and again when the key is destroyed. If the key
+       * doesn't get set for some reason then it will still be
+       * NULL and the destroy function will not be called, and
+       * hence accesscount will not equal 2.
+       */
+      if (accesscount[i] != 3)
+        {
+          fail++;
+          fprintf(stderr, "Thread %d key, set = %d, destroyed = %d\n",
+              i, thread_set[i], thread_destroyed[i]);
+        }
+    }
+
+  fflush(stderr);
+
+  return (fail);
+}
diff --git a/src/include/pthread/tests/tsd3.c b/src/include/pthread/tests/tsd3.c
new file mode 100644
index 0000000..63ecf55
--- /dev/null
+++ b/src/include/pthread/tests/tsd3.c
@@ -0,0 +1,209 @@
+/*
+ * tsd3.c
+ *
+ * Test Thread Specific Data (TSD) key creation and destruction.
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Description:
+ * -
+ *
+ * Test Method (validation or falsification):
+ * - validation
+ *
+ * Requirements Tested:
+ * - keys are created for each existing thread including the main thread
+ * - keys are created for newly created threads
+ * - keys are thread specific
+ * - key is deleted before threads exit
+ * - key destructor function is not called
+ *
+ * Features Tested:
+ * -
+ *
+ * Cases Tested:
+ * -
+ *
+ * Environment:
+ * -
+ *
+ * Input:
+ * - none
+ *
+ * Output:
+ * - text to stdout
+ *
+ * Assumptions:
+ * - already validated:     pthread_create()
+ *                          pthread_once()
+ * - main thread also has a POSIX thread identity
+ *
+ * Pass Criteria:
+ *
+ * Fail Criteria:
+ */
+
+#include <sched.h>
+#include "test.h"
+
+enum {
+  NUM_THREADS = 100
+};
+
+static pthread_key_t key = NULL;
+static int accesscount[NUM_THREADS];
+static int thread_set[NUM_THREADS];
+static int thread_destroyed[NUM_THREADS];
+static pthread_barrier_t startBarrier;
+static pthread_barrier_t progressSyncBarrier;
+
+static void
+destroy_key(void * arg)
+{
+  /*
+   * The destructor function should not be called if the key
+   * is deleted before the thread exits.
+   */
+  fprintf(stderr, "The key destructor was called but should not have been.\n");
+  exit (1);
+}
+
+static void
+setkey(void * arg)
+{
+  int * j = (int *) arg;
+
+  thread_set[j - accesscount] = 1;
+
+  assert(*j == 0);
+
+  assert(pthread_getspecific(key) == NULL);
+
+  assert(pthread_setspecific(key, arg) == 0);
+  assert(pthread_setspecific(key, arg) == 0);
+  assert(pthread_setspecific(key, arg) == 0);
+
+  assert(pthread_getspecific(key) == arg);
+
+  (*j)++;
+
+  assert(*j == 1);
+}
+
+static void *
+mythread(void * arg)
+{
+  (void) pthread_barrier_wait(&startBarrier);
+
+  setkey(arg);
+  (void) pthread_barrier_wait(&progressSyncBarrier);
+  (void) pthread_barrier_wait(&progressSyncBarrier);
+
+  return 0;
+}
+
+int
+main()
+{
+  int i;
+  int fail = 0;
+  pthread_t thread[NUM_THREADS];
+
+  assert(pthread_barrier_init(&startBarrier, NULL, NUM_THREADS/2) == 0);
+  assert(pthread_barrier_init(&progressSyncBarrier, NULL, NUM_THREADS) == 0);
+
+  for (i = 1; i < NUM_THREADS/2; i++)
+    {
+      accesscount[i] = thread_set[i] = thread_destroyed[i] = 0;
+      assert(pthread_create(&thread[i], NULL, mythread, (void *)&accesscount[i]) == 0);
+    }
+
+  /*
+   * Here we test that existing threads will get a key created
+   * for them.
+   */
+  assert(pthread_key_create(&key, destroy_key) == 0);
+
+  (void) pthread_barrier_wait(&startBarrier);
+
+  /*
+   * Test main thread key.
+   */
+  accesscount[0] = 0;
+  setkey((void *) &accesscount[0]);
+
+  /*
+   * Here we test that new threads will get a key created
+   * for them.
+   */
+  for (i = NUM_THREADS/2; i < NUM_THREADS; i++)
+    {
+      accesscount[i] = thread_set[i] = thread_destroyed[i] = 0;
+      assert(pthread_create(&thread[i], NULL, mythread, (void *)&accesscount[i]) == 0);
+    }
+
+  (void) pthread_barrier_wait(&progressSyncBarrier);
+  /*
+   * Deleting the key should not call the key destructor.
+   */
+  assert(pthread_key_delete(key) == 0);
+  (void) pthread_barrier_wait(&progressSyncBarrier);
+
+  /*
+   * Wait for all threads to complete.
+   */
+  for (i = 1; i < NUM_THREADS; i++)
+    {
+	assert(pthread_join(thread[i], NULL) == 0);
+    }
+
+  assert(pthread_barrier_destroy(&startBarrier) == 0);
+  assert(pthread_barrier_destroy(&progressSyncBarrier) == 0);
+
+  for (i = 1; i < NUM_THREADS; i++)
+    {
+      /*
+       * The counter is incremented once when the key is set to
+       * a value.
+       */
+      if (accesscount[i] != 1)
+        {
+          fail++;
+          fprintf(stderr, "Thread %d key, set = %d, destroyed = %d\n",
+              i, thread_set[i], thread_destroyed[i]);
+        }
+    }
+
+  fflush(stderr);
+
+  return (fail);
+}
diff --git a/src/include/pthread/tests/valid1.c b/src/include/pthread/tests/valid1.c
new file mode 100644
index 0000000..7bf8f65
--- /dev/null
+++ b/src/include/pthread/tests/valid1.c
@@ -0,0 +1,101 @@
+/*
+ * File: valid1.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis:
+ * - Test that thread validation works.
+ *
+ * Test Method (Validation or Falsification):
+ * -
+ *
+ * Requirements Tested:
+ * -
+ *
+ * Features Tested:
+ * -
+ *
+ * Cases Tested:
+ * -
+ *
+ * Description:
+ * -
+ *
+ * Environment:
+ * -
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * -
+ *
+ * Pass Criteria:
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - Process returns non-zero exit status.
+ */
+
+#include "test.h"
+
+enum {
+	NUMTHREADS = 1
+};
+
+static int washere = 0;
+
+void * func(void * arg)
+{
+  washere = 1;
+  return (void *) 0; 
+}
+ 
+int
+main()
+{
+  pthread_t t;
+  void * result = NULL;
+
+  washere = 0;
+  assert(pthread_create(&t, NULL, func, NULL) == 0);
+  assert(pthread_join(t, &result) == 0);
+  assert((int)(size_t)result == 0);
+  assert(washere == 1);
+  sched_yield();
+  assert(pthread_kill(t, 0) == ESRCH);
+
+  return 0;
+}
diff --git a/src/include/pthread/tests/valid2.c b/src/include/pthread/tests/valid2.c
new file mode 100644
index 0000000..c389c0d
--- /dev/null
+++ b/src/include/pthread/tests/valid2.c
@@ -0,0 +1,82 @@
+/*
+ * File: valid2.c
+ *
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads4w - POSIX Threads for Windows
+ *      Copyright 1998 John E. Bossom
+ *      Copyright 1999-2018, Pthreads4w contributors
+ *
+ *      Homepage: https://sourceforge.net/projects/pthreads4w/
+ *
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *
+ *      https://sourceforge.net/p/pthreads4w/wiki/Contributors/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Test Synopsis:
+ * - Confirm that thread validation fails for garbage thread ID.
+ *
+ * Test Method (Validation or Falsification):
+ * -
+ *
+ * Requirements Tested:
+ * -
+ *
+ * Features Tested:
+ * -
+ *
+ * Cases Tested:
+ * -
+ *
+ * Description:
+ * -
+ *
+ * Environment:
+ * -
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * -
+ *
+ * Pass Criteria:
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - Process returns non-zero exit status.
+ */
+
+#include "test.h"
+ 
+int
+main()
+{
+  pthread_t NullThread =  __PTW32_THREAD_NULL_ID;
+
+  assert(pthread_kill(NullThread, 0) == ESRCH);
+
+  return 0;
+}
diff --git a/src/lpc_launcher/LauncherView/ErrorCodes.h b/src/lpc_launcher/LauncherView/ErrorCodes.h
new file mode 100644
index 0000000..d56fe2d
--- /dev/null
+++ b/src/lpc_launcher/LauncherView/ErrorCodes.h
@@ -0,0 +1,21 @@
+#ifndef _LAUNCHERVIEW_ERRORCODES_H_
+#define _LAUNCHERVIEW_ERRORCODES_H_
+
+
+typedef struct 
+{
+	int ERROR_SUCCESS = 0;
+	int ERROR_SERVICE_ALREADY_RUNNING = 1056;
+	int ERROR_PRODUCT_UNINSTALLED = 1614;
+	int ERROR_NOT_SUPPORTED = 50;
+	int ERROR_UNKNOWN = 65535;
+	
+} Lview_ErrorCodes;
+
+
+
+
+
+
+
+#endif /* _LAUNCHERVIEW_ERRORCODES_H_ */
diff --git a/src/lpc_launcher/LauncherView/JsInterop/LauncherObject.h b/src/lpc_launcher/LauncherView/JsInterop/LauncherObject.h
new file mode 100644
index 0000000..5620468
--- /dev/null
+++ b/src/lpc_launcher/LauncherView/JsInterop/LauncherObject.h
@@ -0,0 +1,130 @@
+#ifndef _JSINTEROP_LAUNCHEROBJECT_H_
+#define _JSINTEROP_LAUNCHEROBJECT_H_
+
+
+char Name = "_launcher_object_";
+
+// private static readonly Regex Whitespaces = new Regex("\\s+", RegexOptions.Compiled);
+
+bool _isLoggedIn;
+
+//MainWindow _mainWindow;
+
+// Rectangle _mainWindowDragger;
+
+// ChromiumWebBrowser _wb;
+
+// IBrowser _b;
+
+ int HeartBeatTick = 3000;
+
+typedef struct 
+{
+    double Width;
+    double Height;
+} WindowSize;
+
+
+typedef struct 
+{
+    char* InstallPath;
+    int IsInstallDirExist;
+    int IsSameNamedFileWithInstallDirExist;
+} InstallInfo;
+
+void InstallInfo_Init() {}
+
+
+
+
+int LauncherObject() {}
+
+int resize() {}
+
+int ResizeDragger() {}
+
+void ResizeOriginSizePosition() {}
+
+int ResizeAndMove() {}
+
+int GetSize() {}
+
+int Minimize() {}
+
+int Close() {}
+
+int Show() {}
+
+int Hide() {}
+
+int Reload() {}
+
+int ClearCookie() {}
+
+int OpenDefaultBrowser() {}
+
+int Is64BitLauncher() {}
+
+int Is64BitOS() {}
+
+int GetLauncherVersion() {}
+
+int GetInstallInfo() {}
+
+int JSIOP_Alert() {}
+
+int OnLogin() {}
+
+void SaveEmail() {}
+
+char GetLoginInfo() {}
+
+int ExecuteGame() {return 0;}
+
+char GetSessionValidatorUrl() {}
+
+char GetPatchSourceUrl() {}
+
+void Logout() {}
+
+void RestartLoginFlow() {}
+
+void SetExitEventOnGameClient() {}
+
+void SetExitEventOnGameStarter() {}
+
+int SaveUserLocalConfig() {}
+
+int SaveUserLocalConfig() {}
+
+int SetSavedId() {}
+
+void HeartBeat() {}
+
+char GetSavedId() {}
+
+char GetLang() {}
+
+void SetLang() {}
+
+void ClearCache() {}
+
+void PopFocus() {}
+
+int PrepareInstall() {}
+
+char GetMachineUid() {}
+
+bool IsClientValidationDisabled() {}
+
+bool IsClientInstallPathOverridden() {}
+
+bool IsRunning() {}
+
+
+
+
+
+
+
+#endif /* _JSINTEROP_LAUNCHEROBJECT_H_ */
diff --git a/src/lpc_launcher/LauncherView/LifeSpanHandler.h b/src/lpc_launcher/LauncherView/LifeSpanHandler.h
new file mode 100644
index 0000000..e6e0ac5
--- /dev/null
+++ b/src/lpc_launcher/LauncherView/LifeSpanHandler.h
@@ -0,0 +1,37 @@
+#ifndef _LAUNCHERVIEW_LIFESPANHANDLER_H_
+#define _LAUNCHERVIEW_LIFESPANHANDLER_H_
+
+
+MainWindow _mainWindow;
+Rectangle _mainWindowDragger;
+
+int LifeSpanHandler(){}
+
+bool DoClose() {}
+
+void OnAfterCreated() {}
+
+void OnBeforeClose() {}
+
+bool OnBeforePopup() {}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#endif /* _LAUNCHERVIEW_LIFESPANHANDLER_H_ */
diff --git a/src/lpc_launcher/LauncherView/MainWindow.h b/src/lpc_launcher/LauncherView/MainWindow.h
new file mode 100644
index 0000000..b3658e4
--- /dev/null
+++ b/src/lpc_launcher/LauncherView/MainWindow.h
@@ -0,0 +1,109 @@
+#ifndef _LAUNCHERVIEW_MAINWINDOW_H_
+#define _LAUNCHERVIEW_MAINWINDOW_H_
+
+
+
+bool IsTitleFixed;
+
+// NotifyIcon NotifyIcon;
+
+// HashSet<IBrowser> PopupBrowsers;
+
+bool IsTerminating;
+
+int LoginWindowWidth = 400;
+int LoginWindowHeight = 630;
+int MainWindowWidth = 1280;
+int MainWindowHeight = 760;
+
+// string mStartAddress = string.Empty;
+
+// Dictionary<ContextMenuItems, Action> mCommandDictionary = new Dictionary<ContextMenuItems, Action>();
+
+// List<KeyValuePair<ContextMenuItems, string>> mContextMenuStringMatchList = new List<KeyValuePair<ContextMenuItems, string>>();
+
+
+enum WindowsMessage
+{
+	WM_CLOSE = 16,
+	WM_QUIT = 18
+}
+
+enum MainWindowPage
+{
+	Login,
+	Launcher
+}
+
+
+void OnMainBrowserMouseDown() {}
+
+void OnMainBrowserTitleChanged() {}
+
+void OnMainBrowserLoadingStateChanged() {}
+
+void OnMainBrowserLoadError() {}
+
+void OnMainBrowserDragEnter() {}
+
+void OnMainWindowDraggerMouseMove() {}
+
+
+int MainWindow() {}
+
+MainWindowPage GetCurrentPage() {}
+
+void ResizeToOrigin() {}
+
+void Resize() {}
+
+void PositionToCenter() {}
+
+void ResizeOriginSizePosition() {}
+
+void OnClosing() {}
+
+void OnDisplaySettingChanging() {}
+
+void OnDisplaySettingChanged() {}
+
+void TerminateApp() {}
+
+UserLocalConfig LoadUserLocalConfig() {}
+
+char GetLang() {}
+
+void ShowCloseModal() {}
+
+void NotifyIconMouseClick() {}
+
+void PrepareNotifyIcon() {}
+
+void OnNotifyIconContextMenu() {}
+
+void InitializeCommandTable() {}
+
+void ExecuteCommand() {}
+
+void OnLogin() {}
+
+void OnLogout() {}
+
+void OnRestartLoginFlow() {}
+
+void OnCloseCommand() {}
+
+void GetMenu() {}
+
+void CollapseToTrayIcon() {}
+
+
+
+
+
+
+
+
+
+#endif /* _LAUNCHERVIEW_MAINWINDOW_H_ */
+
diff --git a/src/lpc_launcher/LauncherView/TrayRefresher.h b/src/lpc_launcher/LauncherView/TrayRefresher.h
new file mode 100644
index 0000000..ed74198
--- /dev/null
+++ b/src/lpc_launcher/LauncherView/TrayRefresher.h
@@ -0,0 +1,118 @@
+#ifndef _LAUNCHERVIEW_TRAYREFRESHER_H_
+#define _LAUNCHERVIEW_TRAYREFRESHER_H_
+
+
+#include <windows.h>
+
+/*  
+
+HWND tray = FindWindow("Shell_TrayWnd", NULL);
+HWND notify = FindWindowEx(tray, NULL, "TrayNotifyWnd", NULL);
+HWND sysPager = FindWindowEx(notify, NULL, "SysPager", NULL);
+HWND toolbar = FindWindowEx(sysPager, NULL, "ToolbarWindow32", "Notification Area");
+
+if (!toolbar)
+    toolbar = FindWindowEx(sysPager, NULL, "ToolbarWindow32", "User Promoted Notification Area");
+
+RECT rect;
+GetClientRect(toolbar, &rect);
+
+for (int x = 0; x < rect.right; x += 5)
+{
+    for (int y = 0; y < rect.bottom; y += 5)
+    {
+        SendMessage(toolbar, WM_MOUSEMOVE, 0, MAKELPARAM(x, y));
+    }
+}
+
+*/
+
+void RefreshTrayArea(HWND hWnd)
+{
+    RECT rect;
+    int x, y;
+
+    if (!GetClientRect(hWnd, &rect))
+    {
+        return;
+    }
+
+    for(x = 0; x < rect.right; x += 5)
+    {
+        for (y = 0; y < rect.bottom; y += 5)
+        {
+            SendMessage(hWnd, WM_MOUSEMOVE, 0, (y << 16) | (x & 0xFFFF));
+        }
+    }
+}
+
+void RefreshTrayIcons()
+{
+    HWND hShellTrayWnd;
+    HWND hTrayNotifyWnd;
+    HWND hSysPager;
+    HWND hToolbar;
+
+    hShellTrayWnd = FindWindowA("Shell_TrayWnd", NULL);
+    if (!hShellTrayWnd) return;
+
+    hTrayNotifyWnd = FindWindowExA(hShellTrayWnd, NULL, "TrayNotifyWnd", NULL);
+    if (!hTrayNotifyWnd) return;
+
+    hSysPager = FindWindowExA(hTrayNotifyWnd, NULL, "SysPager", NULL);
+    if (!hSysPager) return;
+
+    hToolbar = FindWindowExA(hSysPager, NULL, "ToolbarWindow32", "Notification Area");
+
+    if(!hToolbar)
+    {
+        // Tenta área promovida no Windows 7+ (compatível com XP também)
+        hToolbar = FindWindowExA(hSysPager, NULL, "ToolbarWindow32", "User Promoted Notification Area");
+
+        // Overflow window (às vezes usado em sistemas mais recentes)
+        if(!hToolbar)
+        {
+            HWND hNotifyOverflow = FindWindowA("NotifyIconOverflowWindow", NULL);
+            if(hNotifyOverflow)
+            {
+                hToolbar = FindWindowExA(hNotifyOverflow, NULL, "ToolbarWindow32", NULL);
+            }
+        }
+    }
+
+    if (hToolbar)
+    {
+        RefreshTrayArea(hToolbar);
+    }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#endif /* _LAUNCHERVIEW_TRAYREFRESHER_H_ */
diff --git a/src/lpc_launcher/LauncherView/UserLocalConfig.h b/src/lpc_launcher/LauncherView/UserLocalConfig.h
new file mode 100644
index 0000000..1663825
--- /dev/null
+++ b/src/lpc_launcher/LauncherView/UserLocalConfig.h
@@ -0,0 +1,83 @@
+#ifndef _USERLOCALCONFIG_H_
+#define _USERLOCALCONFIG_H_
+
+/*
+typedef struct 
+{
+    char email[128];
+    char defaultLanguage[16];
+} UserLocalConfig;
+
+
+void set_email(UserLocalConfig* cfg, const char* email) 
+{
+    strcpy(cfg->email, email);
+}
+
+const char* get_email(UserLocalConfig* cfg) 
+{
+    return cfg->email;
+}*/
+
+
+#define MAX_EMAIL_LENGTH 128
+#define MAX_LANG_LENGTH 16
+
+typedef struct 
+{
+    char email[MAX_EMAIL_LENGTH];
+    char defaultLanguage[MAX_LANG_LENGTH];
+} UserLocalConfig;
+
+/*
+// Inicializa a estrutura com strings vazias
+void initUserLocalConfig(UserLocalConfig* cfg);
+
+// Setters
+void setEmail(UserLocalConfig* cfg, const char* email);
+void setDefaultLanguage(UserLocalConfig* cfg, const char* lang);
+
+// Getters
+const char* getEmail(const UserLocalConfig* cfg);
+const char* getDefaultLanguage(const UserLocalConfig* cfg);
+*/
+
+void initUserLocalConfig(UserLocalConfig* cfg) 
+{
+    cfg->email[0] = '\0';
+    cfg->defaultLanguage[0] = '\0';
+}
+
+void setEmail(UserLocalConfig* cfg, const char* email) 
+{
+    strncpy(cfg->email, email, MAX_EMAIL_LENGTH - 1);
+    cfg->email[MAX_EMAIL_LENGTH - 1] = '\0';
+}
+
+void setDefaultLanguage(UserLocalConfig* cfg, const char* lang) 
+{
+    strncpy(cfg->defaultLanguage, lang, MAX_LANG_LENGTH - 1);
+    cfg->defaultLanguage[MAX_LANG_LENGTH - 1] = '\0';
+}
+
+const char* getEmail(const UserLocalConfig* cfg) 
+{
+    return cfg->email;
+}
+
+const char* getDefaultLanguage(const UserLocalConfig* cfg) 
+{
+    return cfg->defaultLanguage;
+}
+
+
+
+
+
+
+
+
+
+
+
+#endif /* _USERLOCALCONFIG_H_ */
diff --git a/src/lpc_launcher/cef_manager/cef_custom.h b/src/lpc_launcher/cef_manager/cef_custom.h
new file mode 100644
index 0000000..9244475
--- /dev/null
+++ b/src/lpc_launcher/cef_manager/cef_custom.h
@@ -0,0 +1,67 @@
+#ifndef __CEF_CUSTOM_H__
+#define __CEF_CUSTOM_H__
+
+
+// Inicializa o CEF com settings básicos
+void init_cef(HINSTANCE hInstance)
+{
+	cef_main_args_t main_args = {0};
+	cef_settings_t settings = {0};
+
+    // CefMainArgs
+  
+    main_args.instance = hInstance;
+
+    // Settings
+    
+    settings.size = sizeof(settings);
+    settings.no_sandbox = 1;
+    settings.multi_threaded_message_loop = 1; // usa o loop do Windows
+    settings.single_process = 1;              // necessário para XP
+
+    // Inicializa o CEF
+    cef_initialize(&main_args, &settings, NULL, NULL);
+}
+
+// Prototypes
+void CEF_CALLBACK on_after_created(struct _cef_life_span_handler_t* self, struct _cef_browser_t* browser);
+
+// Struct de handler
+typedef struct 
+{
+    cef_life_span_handler_t handler;
+} MyLifeSpanHandler;
+
+MyLifeSpanHandler g_lifeSpanHandler;
+
+void CEF_CALLBACK on_after_created(struct _cef_life_span_handler_t* self, struct _cef_browser_t* browser)
+{
+    printf("[CEF] Browser created!\n");
+}
+
+// Define a vtable da interface
+void setup_lifespan_handler()
+{
+    g_lifeSpanHandler.handler.base.size = sizeof(cef_life_span_handler_t);
+    g_lifeSpanHandler.handler.on_after_created = on_after_created;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#endif /* __CEF_CUSTOM_H__ */
diff --git a/src/lpc_launcher/display_manager/display_manager.h b/src/lpc_launcher/display_manager/display_manager.h
new file mode 100644
index 0000000..f2f4423
--- /dev/null
+++ b/src/lpc_launcher/display_manager/display_manager.h
@@ -0,0 +1,65 @@
+/* display_manager.h : window manipulator system.
+2023 - 2024 Sild Team
+2025 - OG:BattleGrounds 
+*/
+
+/*
+NOTE !
+
+    This scheme was designed for desktops or window management systems, 
+    perhaps it will be implemented in the future for mobile with changes to the function names.
+    
+    some functions may work differently or have an undesired result on different systems
+*/
+
+#ifndef _DISPLAY_MANAGER_H_
+#define _DISPLAY_MANAGER_H_
+
+/* oh my head ! this comment is for me , im so confuse sorry
+    windows [HWND] = Linux [Window]
+    windows [HINSTANCE] +- Linux [Display]
+ */
+
+#ifndef MAX_WINDOWS
+    #define MAX_WINDOWS 14 /* Based on old systems resource limits , 
+    if you want more windows just #undef this header and increase the limit*/
+#endif 
+
+
+typedef struct 
+{
+    void *platformHandle;     /* Platform-specific handle, HWND for Win32, Window for X11, etc. */
+    void *platformConnection; /* Platform-specific Instance Server, HINSTANCE for Win32, Display for X11, etc */
+    int  width;
+    int  height;
+    int  windowPosX;
+    int  windowPosY;
+    int  windowActiveStatus; 
+} LE_Display;
+
+
+
+/* Display Functions */
+LE_Display* engineCreateDisplay(const char *title, int width, int height);
+
+void engineDeleteDisplay(LE_Display *display);
+
+void getWindowActiveStatus(LE_Display *display);
+
+int engineSetLoop(LE_Display *display, int *loopVar, void(*renderFunction)());
+
+void setWindowSize(LE_Display *display, int width, int height);
+
+void getWindowSize(LE_Display *display, int *width, int *height);
+
+void engineSetWindowTitle(LE_Display *display, const char* format, ...);
+
+void engineSetWindowIcon(LE_Display *display, const char* iconPath);
+
+void windowBorderless(LE_Display *display, int mode, ...);
+
+
+
+
+#endif /*_WINDOW_MANAGER_H_
+*/
diff --git a/src/lpc_launcher/display_manager/display_manager_linux.c b/src/lpc_launcher/display_manager/display_manager_linux.c
new file mode 100644
index 0000000..81c1cd6
--- /dev/null
+++ b/src/lpc_launcher/display_manager/display_manager_linux.c
@@ -0,0 +1,352 @@
+/* display_manager.c : for linux 
+2023-2024 SILD Team
+*/
+
+#include<X11/Xlib.h>
+#include<X11/Xutil.h>
+#include<stdlib.h>
+#include<stdio.h>
+#include<stdarg.h>
+
+#include"display_manager.h"
+
+LE_Window* windows[MAX_WINDOWS];
+LE_Window *currentWindow = NULL;
+int windowCount = 0;
+
+
+LE_Window* engineCreateDisplay(const char *title, int width, int height)
+{
+    LE_Window *window = (LE_Window*)malloc(sizeof(LE_Window));
+
+    Display             *display;
+    Window               root;
+    XSetWindowAttributes attributes;
+    int                  screen;
+    XColor               color;
+    Colormap             colormap;
+    int                  screenWidth,
+                         screenHeight;
+
+
+    if(!window) 
+    {
+        fprintf(stderr, "Erro: não foi possível alocar memória para a estrutura da janela.\n");
+        return NULL;
+    }
+
+    if (windowCount >= MAX_WINDOWS) 
+    {
+        printf(" \n ~~[ ALERT! ]: Maximum number of windows reached! Window Limit =  %d \n", windowCount);
+        return NULL;
+    }
+
+    window->width = width;
+    window->height = height;
+
+    /* Open the connection to the X server */
+    display = XOpenDisplay(NULL);
+    if (display == NULL) 
+    {
+        printf("\n ~~[ERROR!]: Cannot connect to X server\n\n");
+        free(window);
+        return NULL;
+    }
+
+    screen = DefaultScreen(display);
+    root = RootWindow(display, screen);
+
+    colormap = DefaultColormap(display, screen);
+
+    /* Sets the background color */
+    if (!XParseColor(display, colormap, "#000700", &color)) 
+    {
+        fprintf(stderr, "Erro ao analisar a cor.\n");
+        XCloseDisplay(display);
+        free(window);
+        return NULL;
+    }
+
+    if (!XAllocColor(display, colormap, &color)) 
+    {
+        fprintf(stderr, "Erro ao alocar a cor.\n");
+        XCloseDisplay(display);
+        free(window);
+        return NULL;
+    }
+
+
+    /* Window Settings */
+    attributes.background_pixel = color.pixel;
+    attributes.border_pixel = WhitePixel(display, screen);
+    attributes.override_redirect = False;  /* Allows the window manager to control */
+    attributes.event_mask = ExposureMask | KeyPressMask;
+
+    /* Adjusting the window position (centering on the screen) */
+    screenWidth = DisplayWidth(display, screen);
+    screenHeight = DisplayHeight(display, screen);
+    window->windowPosX = (screenWidth - width) / 2;
+    window->windowPosY = (screenHeight - height) / 2;
+
+    /* Create Window */
+    window->platformHandle = (void *)XCreateWindow(display,
+                                                   root,
+                                                   window->windowPosX,
+                                                   window->windowPosY,
+                                                   width,
+                                                   height,
+                                                   0,
+                                                   CopyFromParent,
+                                                   InputOutput,
+                                                   CopyFromParent,
+                                                   CWBackPixel | CWBorderPixel | CWEventMask,
+                                                   &attributes);
+
+    if (!window->platformHandle) 
+    {
+        fprintf(stderr, "Erro: não foi possível criar a janela X.\n");
+        XCloseDisplay(display);
+        free(window);
+        return NULL;
+    }
+
+    /* Sets the window title */
+    XStoreName(display, (Window)window->platformHandle, title);
+    XMapWindow(display, (Window)window->platformHandle);
+    XFlush(display);
+
+    /* Saves the Display within the structure, in case you need it in the future */
+    window->platformConnection = (void *)display;
+
+    windows[windowCount++] = window;
+    currentWindow = window;
+    return window;
+}
+
+void engineDeleteDisplay(LE_Window *window) /* FIXME - Dont Work , destroy first window Only !*/ 
+{                                             /* i hate this ! AAAA**/
+    Display *display;
+
+    display = (Display *)window->platformConnection;
+
+    if(window) 
+    {
+        if(window->platformHandle) 
+        {
+            XDestroyWindow(display, (Window)window->platformHandle);
+        }
+        free(window);
+    }
+    else 
+    {
+        fprintf(stderr, "Warning: Attempted to delete a null window.\n");
+    }
+}
+
+void getWindowActiveStatus(LE_Window *window) 
+{
+    Display *display;
+    Window focusedWindow;
+    int revert;
+
+    /* Open a connection to the X server */
+    display = XOpenDisplay(NULL);
+    if (display == NULL) 
+    {
+        /* Failed to open connection to server X */
+        window->windowActiveStatus = 0;
+        return;
+    }
+
+    /* Gets the currently focused window */
+    XGetInputFocus(display, &focusedWindow, &revert);
+
+    /* Checks if the current window has focus */
+    window->windowActiveStatus = (focusedWindow == (Window)window->platformHandle) ? 1 : 0;
+
+    /* Closes the connection to the X server */
+    XCloseDisplay(display);
+}
+
+int engineSetLoop(LE_Window *window, int loopVar, void (*renderFunction)())
+{
+    Display *display;
+    XEvent   event;
+
+    display = (Display *)window->platformConnection;
+
+
+    if(renderFunction == NULL) 
+    {
+        printf("\n ~~[ERROR!]: [engineSetLoop()] Parameter 3 is NULL!\n");
+        return -1;
+    }
+
+    while(loopVar)
+    {
+        while(XPending(display) > 0) 
+        {
+            XNextEvent(display, &event);
+
+        }
+        renderFunction();
+    }
+    XDestroyWindow(display, (Window)window->platformHandle);
+    XCloseDisplay(display);
+return 0;
+}
+
+void setWindowSize(LE_Window *window, int width, int height) 
+{
+    Display *display;
+    Screen *screen;
+    int screenWidth, screenHeight;
+
+    /* Open a connection to the X server */
+    display = XOpenDisplay(NULL);
+    if(display == NULL) 
+    {
+        /* Failed to open connection to server X */
+        return;
+    }
+
+    /* Gets the default screen and its dimensions */
+    screen = DefaultScreenOfDisplay(display);
+    screenWidth = screen->width;
+    screenHeight = screen->height;
+
+    /* Updates the width and height values in the window structure */
+    window->width = width;
+    window->height = height;
+
+    /* Centers the window on the screen */
+    window->windowPosX = (screenWidth - window->width) / 2;
+    window->windowPosY = (screenHeight - window->height) / 2;
+
+    if(window && window->platformHandle) 
+    {
+        /* Move and resize the window */
+        XMoveResizeWindow(display, (Window)window->platformHandle, 
+                          window->windowPosX, window->windowPosY, 
+                          width, height);
+    }
+
+    /* Updates the display */
+    XFlush(display);
+
+    /* Closes the connection to the X server */
+    XCloseDisplay(display);
+}
+
+void getWindowSize(LE_Window *window, int *width, int *height) 
+{
+    Display *display;
+    Window win;
+    XWindowAttributes attributes;
+
+    /* Gets the display and window from the LE_Window structure */
+    display = (Display *)window->platformConnection;
+    win = (Window)window->platformHandle;
+
+    /* Gets the window attributes */
+    if (XGetWindowAttributes(display, win, &attributes)) 
+    {
+        *width = attributes.width;
+        *height = attributes.height;
+    } 
+    else 
+    {
+        printf("Erro: não foi possível obter os atributos da janela.\n");
+        *width = 0;
+        *height = 0;
+    }
+}
+
+void engineSetWindowTitle(LE_Window *window, const char *format, ...) 
+{
+    Display *display;  /* Gets the Display from the rendering context */
+    Window win = (Window)window->platformHandle; /* Gets the window from the handle */
+
+    display = (Display *)window->platformConnection;
+
+    char title[256]; /* window title buffer */
+    va_list args;
+
+    /* Initialize the argument list */
+    va_start(args, format); 
+    
+    /* Format the title */
+    vsnprintf(title, sizeof(title), format, args);
+
+    /* Finalizes the argument list */
+    va_end(args);
+
+    /* Sets the window title */
+    XStoreName(display, win, title);
+
+    /* Requests the X server to update the screen */
+    XFlush(display);
+}
+
+void engineSetWindowIcon(LE_Window *window, const char* iconPath)
+{
+    /* ??? x11 doesn't have a default icon system other than xpm so I'll leave it empty for now */
+}
+
+
+void windowBorderless(LE_Window *window, int mode, ...) /* FIXME */
+{
+    Display                 *display;
+    Window                  win = (Window)window->platformHandle;
+    XSetWindowAttributes    attributes;
+    XWindowChanges          changes;
+    int                     screen = DefaultScreen(display);
+    va_list                 args;
+    int                     windowWidth = window->width;
+    int                     windowHeight = window->height;
+
+    display = (Display *)window->platformConnection;
+
+    va_start(args, mode);
+
+    if (mode == 2) 
+    { /* Fullscreen */
+        /* Gets the dimensions of the screen */
+        Window root = RootWindow(display, screen);
+        XWindowAttributes root_attrs;
+        XGetWindowAttributes(display, root, &root_attrs);
+
+        windowWidth = root_attrs.width;
+        windowHeight = root_attrs.height;
+
+        /* Sets the window to full screen mode */
+        attributes.override_redirect = True;
+        XChangeWindowAttributes(display, win, CWOverrideRedirect, &attributes);
+    } 
+    else if (mode == 1) 
+    { /* Borderless with specified size */
+        windowWidth = va_arg(args, int);
+        windowHeight = va_arg(args, int);
+        /* Remove borders and decorations */
+        attributes.border_pixel = BlackPixel(display, screen);
+        XChangeWindowAttributes(display, win, CWBorderPixel, &attributes);
+        XSetWindowBorderWidth(display, win, 0);
+    } 
+    else if (mode == 0) 
+    { /* Normal window with borders */
+        /* Set border attributes if needed */
+        attributes.border_pixel = WhitePixel(display, screen);
+        XChangeWindowAttributes(display, win, CWBorderPixel, &attributes);
+        XSetWindowBorderWidth(display, win, 1);
+    }
+
+    /* Updates window position and size */
+    XMoveResizeWindow(display, win, 0, 0, windowWidth, windowHeight);
+
+    /* Map the window to make sure it is visible */
+    XMapWindow(display, win);
+    XFlush(display);
+
+    va_end(args);
+}
+
diff --git a/src/lpc_launcher/display_manager/display_manager_nt.c b/src/lpc_launcher/display_manager/display_manager_nt.c
new file mode 100644
index 0000000..ccef515
--- /dev/null
+++ b/src/lpc_launcher/display_manager/display_manager_nt.c
@@ -0,0 +1,456 @@
+
+
+
+#define _WIN32_WINNT 0x0501 // Windows XP or superior
+#include<windows.h>
+
+#include<uxtheme.h> // DArk Themes
+
+#include<stdio.h>
+#include<stdarg.h>  /* for va_list and associated values and functions */
+
+#include"display_manager.h"
+
+
+LE_Display* windows[MAX_WINDOWS];
+LE_Display *currentWindow = NULL;
+int windowCount = 0;
+int windowClassIndex = 1;
+
+int windowMovable = 1;
+
+HWND editBox;
+
+
+LRESULT CALLBACK
+    WINAPI WindowProc(HWND hWnd, 
+                      UINT uMsg, 
+                      WPARAM wParam, 
+                      LPARAM lParam)
+{   
+    int i;
+    
+    for(i = 0; i < windowCount; i++) 
+    {
+        if(windows[i]->platformHandle == hWnd) 
+        {
+            switch(uMsg) 
+            {   
+                case WM_CTLCOLORSTATIC:
+                case WM_CTLCOLOREDIT: 
+                    {
+                    }
+                break;
+                case WM_COMMAND:
+                    
+                    return 0;
+                
+                case WM_INPUT:
+                {
+                }
+                break;
+                case WM_MOUSEMOVE: 
+                {
+                }
+                break;
+                case WM_PAINT:
+                {
+
+                }
+                break;
+                case WM_SETTEXT:
+                {
+                    return DefWindowProc(hWnd, uMsg, wParam, lParam);
+                }
+                break;
+                case WM_SIZE:
+                    if(wParam != SIZE_MINIMIZED)
+                    {
+
+                    }
+                break;
+                case WM_SYSCOMMAND:
+                    switch(wParam) 
+                    {
+                        case SC_MINIMIZE:
+                            // Manipular minimização
+                        break;
+                        case SC_MAXIMIZE:
+                            // Manipular maximização
+                        break;
+                        case SC_CLOSE:
+                            // Manipular fechamento
+                        break;
+                    }
+                    return DefWindowProc(hWnd, uMsg, wParam, lParam);
+                break;
+                case WM_CLOSE:
+                    /* Find the window and remove it from the list */
+                    
+                    {
+                        PostQuitMessage(0);
+                    }
+
+                    //engineDeleteDisplay(windows[i]);
+                    
+                    /* Note: engineDeleteDisplay will handle removing the window from the list */
+                    /* and setting currentWindow to NULL if needed. */
+                    
+                    /* After destruction, break here to avoid further processing */
+                    return 0;
+                break;
+                case WM_DESTROY:
+                    PostQuitMessage(0);
+                    return 0;
+                break;
+                default:
+                    if(windowMovable)
+                    {
+                        return DefWindowProc(hWnd, uMsg, wParam, lParam);
+                    }
+                    else
+                    {
+                        break;
+                    }
+            }
+            //return 0;
+            return DefWindowProc(hWnd, uMsg, wParam, lParam);  /* Passes the message to the default handler */
+        }
+    }
+    return DefWindowProc(hWnd, uMsg, wParam, lParam);   /* Default message for unhandled cases */
+}
+
+
+LE_Display* engineCreateDisplay(const char *title, int width, int height)
+{
+    LE_Display *window = (LE_Display*)malloc(sizeof(LE_Display));
+
+    int screenWidth;
+    int screenHeight;
+
+    char className[256];
+
+    WNDCLASSEX wc = {0};
+    RECT wr = {0};
+
+    snprintf(className, sizeof(className), "LEFA_NT_%d", windowClassIndex++);
+    
+    if(windowCount >= MAX_WINDOWS) 
+    {
+        printf(" \n ~~[ ALERT! ]: Maximum number of windows reached! Window Limit =  %d \n", windowCount);
+        return NULL;
+    }
+
+    if(!window)
+    {
+        printf("\n ~~[ErRoR]: Window Struct Not Defined Or have Problem ! \n");
+        return NULL;
+    }
+
+    window->width = width;
+    window->height = height;
+
+    window->platformConnection = (void *)GetModuleHandle(NULL);
+    
+    ZeroMemory(&wc, sizeof(WNDCLASSEX));
+    wc.cbSize = sizeof(WNDCLASSEX);
+    wc.style  = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
+    wc.cbClsExtra = 0;
+    wc.cbWndExtra = 0;
+    wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
+    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
+    wc.lpszMenuName  = NULL;
+    wc.hbrBackground = CreateSolidBrush(RGB(0, 7, 0));
+    wc.lpfnWndProc   = WindowProc;
+    wc.lpszClassName = className;
+    wc.hIconSm = LoadIcon(NULL, IDI_WINLOGO);
+    wc.hInstance     = (HINSTANCE)window->platformConnection;
+
+    if(!RegisterClassEx(&wc))
+    {
+        printf(" \n ~~[ERROR!]: function [RegisterClassEX()] in function [engineCreateDisplay] \n");
+        free(window);
+        return NULL;
+    }
+
+    ZeroMemory(&wr, sizeof(RECT));
+    wr.left = 0;
+    wr.top  = 0;
+    wr.right  = window->width;
+    wr.bottom = window->height;
+    AdjustWindowRect(&wr, WS_OVERLAPPEDWINDOW, FALSE);
+
+
+    /* Get screen dimensions */
+    screenWidth  = GetSystemMetrics(SM_CXSCREEN);
+    screenHeight = GetSystemMetrics(SM_CYSCREEN);
+     /* Calculate window coordinates to center it on the screen */
+    window->windowPosX = (screenWidth  - window->width)  / 2;
+    window->windowPosY = (screenHeight - window->height) / 2;
+
+    window->platformHandle = CreateWindowEx(0,
+                                            className,
+                                            title,
+                                            WS_OVERLAPPEDWINDOW | WS_VISIBLE | WS_SYSMENU,
+                                            window->windowPosX,
+                                            window->windowPosY,
+                                            width,
+                                            height,
+                                            NULL,
+                                            NULL,
+                                            (HINSTANCE)window->platformConnection,
+                                            NULL
+    );
+
+    if(!window->platformHandle) 
+    {
+        printf(" \n ~~[ERROR!]: function [CreateWindowEx()] \n");
+        free(window);
+        return NULL;
+    }
+
+    ShowWindow((HWND)window->platformHandle, SW_SHOW);
+    //ShowWindow((HWND)window->platformHandle, SW_SHOWNORMAL);
+    UpdateWindow((HWND)window->platformHandle); /* need this for title top bar */
+    windows[windowCount++] = window;
+    currentWindow = window;
+    return window;
+}
+
+void engineDeleteDisplay(LE_Display *display) 
+{
+    int i, j = 0; 
+    if(display) 
+    {
+        // Remove the window from the list
+        for (i = 0; i < windowCount; i++) 
+        {
+            if (windows[i] == display) 
+            {
+                // Remove the window from the array
+                for (j = i; j < windowCount - 1; j++) 
+                {
+                    windows[j] = windows[j + 1];
+                }
+                windowCount--;
+                break;
+            }
+        }
+
+        // Verifique se a janela a ser destruída é a janela atual
+        if (currentWindow == display) 
+        {
+            currentWindow = NULL; // Desvincule a janela atual
+        }
+
+        // Destroi a janela
+        if(display->platformHandle) 
+        {
+            DestroyWindow((HWND)display->platformHandle);
+        }
+        if(windowCount == 0)
+        {
+            ExitProcess(0); // Encerra o processo e fecha o terminal
+        }
+
+        // Libera a memória da estrutura da janela
+        free(display);
+    }
+}
+
+void getWindowActiveStatus(LE_Display *display) 
+{
+    /* check if the window is active */
+    display->windowActiveStatus = (GetForegroundWindow() == display->platformHandle);
+}
+
+int engineSetLoop(LE_Display *display, int *loopVar, void (*renderFunction)())
+{
+
+    /* Start Loop */
+    MSG msg;
+    
+
+    if(renderFunction == NULL) 
+    {
+        printf("\n ~~[ERROR!]: [engineSetLoop()] Parameter 3 is NULL!\n");
+        return -1;
+    }
+
+
+    for(;;)
+    {
+        /* check if the window is active */
+        //display->windowActiveStatus = (GetForegroundWindow() == display->platformHandle);
+
+        /*if (isWindowActive)
+        {
+            //int nahx, nahy;
+            //mouseInput(hwnd, TRUE, &nahx, &nahy);
+        }*/
+
+        if(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
+        {
+            if(msg.message == WM_QUIT)
+            {
+                *loopVar = 0;
+            }
+            else 
+            {
+                TranslateMessage(&msg);
+                DispatchMessage(&msg);
+            }
+        }
+        else
+        {
+            renderFunction();
+        }
+        
+        if(*loopVar == 0)
+        {
+            break;
+        }
+    }
+    
+
+    DestroyWindow(display->platformHandle);
+    return 0;
+}
+
+void setWindowSize(LE_Display *display, int width, int height) 
+{
+    RECT desktop;
+    const HWND hDesktop = GetDesktopWindow();
+
+
+    // Atualiza os valores de largura e altura na estrutura da janela
+    display->width = width;
+    display->height = height;
+
+    GetWindowRect(hDesktop, &desktop);
+
+    display->windowPosX = (desktop.right  - display->width)  / 2;
+    display->windowPosY = (desktop.bottom - display->height) / 2;
+
+    if(display) 
+    {
+        SetWindowPos(display->platformHandle, 
+                     HWND_TOP, 
+                     display->windowPosX, 
+                     display->windowPosY, 
+                     width, 
+                     height, 
+                     SWP_NOZORDER);
+    }
+}
+
+
+void getWindowSize(LE_Display *display, int *width, int *height) 
+{
+    RECT clientRect;
+    GetClientRect(display->platformHandle, &clientRect);
+    *width  = clientRect.right  - clientRect.left;
+    *height = clientRect.bottom - clientRect.top;
+}
+
+void engineSetWindowTitle(LE_Display *display, const char *format, ...) 
+{
+    char title[256];
+    va_list args;
+
+    /* Initialize the argument list */
+    va_start(args, format);
+
+    /* Format the string */
+    vsnprintf(title, sizeof(title), format, args);
+
+    /* Clean up the argument list */
+    va_end(args);
+
+    /* Set the window title */
+    SetWindowText((HWND)display->platformHandle, title);
+}
+
+void engineSetWindowIcon(LE_Display *display, const char* iconPath)
+{
+    /* Set the window icon */
+    HICON hIcon = (HICON)LoadImage((HINSTANCE)display->platformConnection,
+                                   iconPath,
+                                   IMAGE_ICON,
+                                   32,
+                                   32,
+                                   LR_LOADFROMFILE);
+    if(hIcon) 
+    {
+        SendMessage(display->platformHandle, WM_SETICON, ICON_BIG, (LPARAM)hIcon);
+    } 
+    else 
+    {
+        printf("Failed to load icon from path: %s\n", iconPath);
+    }
+}
+
+
+
+void windowBorderless(LE_Display *display, int mode, ...)
+{
+    int windowWidth = 0;
+    int windowHeight = 0;
+
+    DWORD style = GetWindowLongPtr(display->platformHandle, GWL_STYLE);
+
+    /* Initialize variable argument list */ 
+    va_list args;
+    va_start(args, mode);
+
+
+    /* If the mode requires additional width and height */ 
+    if(mode == 2) /* Let's assume 2 means full screen */
+    {
+        windowWidth = GetSystemMetrics(SM_CXSCREEN);
+        windowHeight = GetSystemMetrics(SM_CYSCREEN);
+    }
+    else
+    {
+        /* Receives the width and height if provided */
+        if(mode == 1) /* Let's assume 1 means border mode without specifying size */
+        {
+            windowWidth = va_arg(args, int);
+            windowHeight = va_arg(args, int);
+        }
+    }
+
+    if(mode == 0) 
+    {
+        /* Bordered mode */
+        style |= (WS_CAPTION | WS_THICKFRAME);  /* Restores edges */
+        SetWindowLongPtr(display->platformHandle, GWL_STYLE, style);
+    }
+    else if(mode == 1)
+    {
+        /* Borderless mode with specified width and height */
+        style &= ~(WS_CAPTION | WS_THICKFRAME); /* Remove borders */
+        SetWindowLongPtr(display->platformHandle, GWL_STYLE, style);
+    }
+    else if(mode == 2)
+    {
+        /* Full screen mode */
+        style &= ~(WS_CAPTION | WS_THICKFRAME); /* Remove borders */
+        SetWindowLongPtr(display->platformHandle, GWL_STYLE, style);
+        windowWidth = GetSystemMetrics(SM_CXSCREEN);
+        windowHeight = GetSystemMetrics(SM_CYSCREEN);
+    }
+
+    /* Updates window position and size */
+    SetWindowPos(display->platformHandle, 
+                 HWND_TOP, 
+                 0, 
+                 0, 
+                 windowWidth, 
+                 windowHeight, 
+                 SWP_SHOWWINDOW | SWP_FRAMECHANGED);
+
+    /* Clears the list of variable arguments */
+    va_end(args);
+}
+
diff --git a/src/lpc_launcher/main.c b/src/lpc_launcher/main.c
new file mode 100644
index 0000000..eb8006b
--- /dev/null
+++ b/src/lpc_launcher/main.c
@@ -0,0 +1,207 @@
+/* main.c
+
+    copy this crap, it's open source
+        2025 - OG:Battlegrounds 
+
+*/
+
+/*
+    This is the main executable, 
+        the objective of this project is to recreate/decompile the original pubg lite launcher, 
+        with the aim of being lighter/more portable/and more compatible, 
+        without the need for the .net crap, 
+        this code is being developed to work with Windows XP Service pack 3 and higher , Linux and Macos.
+
+
+    the project is using CEF 2623 b1401 for windows systems, and CEF 2704 b1415 for linux and macos.
+
+    This program is focused on opening on your potato, so do not use 3D web elements like css3d, webgl etc,
+            because this program may be focused on working with coding in software mode, not on gpus
+
+    why do you want it to work on windows xp?
+        for experiments, and also good portability
+
+
+    
+    Note! The original launcher uses CEF 3578 b1870 so some features may not be available.
+    
+    cef libraries should be c only, 
+        do not include c++ wrappers, they require boring libraries and use __stdcall differently than __cdecl
+
+        you can code this program with c++, but do not include the cef c++ libraries.
+
+    the code for this program must be written with C 89 or C++ 98, 
+            for compatibility with other compilers, and for readability.
+
+        avoid specific compiler calls.
+
+        avoid compiler specific syntax
+
+    the code will use doxygen, so document the implemented code well
+
+
+
+    compatible compilers are Open Watcom 1.9, Visual Studio 2019/2022, clang for macos
+
+    I won't have access to the mac, so I'll leave that in someone else's hands.
+
+
+
+    maybe some original launcher implementations don't work on linux and macos, 
+                    like hiding the launcher window and leaving an icon in the tray
+
+
+    use or create abstractions so that the code is the same on multiple platforms
+
+    The CEF localization files for macOS are messier and uglier, 
+        if you want to use Xcode or Cocoa it will look like this, 
+            if not we will use the manual loading method.
+
+
+    Now an IMPORTANT note, 
+        I put libcef 2623 as libcef_ in the include directory, 
+            and I put libcef 2704 in its place, 
+            in case the program presents any problem, 
+            or some inclusion code for Windows gives problems, 
+            just use a macro and include libcef_ in place of libcef : this feat was done by phikill
+
+
+*/
+
+#include<windows.h>
+#include<libcef/capi/cef_app_capi.h>
+#include<libcef/capi/cef_client_capi.h>
+#include<libcef/capi/cef_browser_capi.h>
+#include<libcef/capi/cef_life_span_handler_capi.h>
+
+#include"display_manager/display_manager.h"
+
+//#include"cef_manager/cef_custom.h"
+
+#include<stdio.h>
+
+int programLoop = 1; // This is the main loop of the program, if you reset it the program will close
+
+LE_Display *progDisplay; // defined structure of the window handler component
+
+int cefInitialized = 0;
+
+// Struct de handler
+typedef struct 
+{
+    cef_life_span_handler_t handler;
+} MyLifeSpanHandler;
+
+typedef struct 
+{
+    cef_client_t client;
+} MyClient;
+
+MyClient g_client;
+MyLifeSpanHandler g_lifeSpanHandler;
+
+// Inicializa o CEF com settings básicos
+void init_cef(HINSTANCE hInstance)
+{
+	cef_main_args_t main_args = {0};
+	cef_settings_t settings = {0};
+
+    // CefMainArgs
+  
+    main_args.instance = hInstance;
+
+    // Settings
+    
+    settings.size = sizeof(settings);
+    settings.no_sandbox = 1;
+    settings.multi_threaded_message_loop = 1; // uses the Windows loop
+    settings.single_process = 1;              // required for XP
+
+    // Inicializa o CEF
+    cef_initialize(&main_args, &settings, NULL, NULL);
+}
+
+
+
+void CEF_CALLBACK on_after_created(struct _cef_life_span_handler_t* self, struct _cef_browser_t* browser)
+{
+    printf("[CEF] Browser created!\n");
+}
+
+// Define a vtable da interface
+void setup_lifespan_handler()
+{
+    g_lifeSpanHandler.handler.base.size = sizeof(cef_life_span_handler_t);
+    g_lifeSpanHandler.handler.on_after_created = on_after_created;
+}
+
+cef_life_span_handler_t* CEF_CALLBACK get_life_span_handler(struct _cef_client_t* self)
+{
+    return (cef_life_span_handler_t*)&g_lifeSpanHandler;
+}
+
+void setup_client()
+{
+    g_client.client.base.size = sizeof(cef_client_t);
+    g_client.client.get_life_span_handler = get_life_span_handler;
+}
+
+void create_browser()
+{
+    //CefWindowHandle hwnd = (HWND)progDisplay->platformHandle;
+    cef_window_handle_t hwnd = (cef_window_handle_t)progDisplay->platformHandle;
+
+    cef_window_info_t window_info = {0};
+    cef_browser_settings_t browser_settings = {0};
+    cef_string_utf16_t url = {0};
+
+
+    window_info.parent_window = hwnd;
+    window_info.style = WS_CHILD | WS_VISIBLE;
+    window_info.x = 0;
+    window_info.y = 0;
+    window_info.width = progDisplay->width;
+    window_info.height = progDisplay->height;
+
+    browser_settings.size = sizeof(cef_browser_settings_t);
+
+    cef_string_utf8_to_utf16("http://127.0.0.1/oidc/interaction/login", strlen("http://127.0.0.1/oidc/interaction/login"), &url);
+
+    cef_browser_host_create_browser(&window_info,
+                                    (cef_client_t*)&g_client,
+                                    &url,
+                                    &browser_settings,
+                                    NULL);
+}
+
+
+void progLoop()
+{
+
+	if(!cefInitialized)
+    {
+        setup_lifespan_handler();
+        setup_client();
+        create_browser();
+        cefInitialized = 1;
+    }
+
+
+}
+
+int main()
+{
+
+
+	progDisplay = engineCreateDisplay("MainWindow", 417, 670);
+
+	init_cef(progDisplay->platformConnection);
+
+
+
+	engineSetLoop(progDisplay, &programLoop, progLoop);
+
+	cef_shutdown();
+
+	return 0;
+}
diff --git a/src/lpc_launcher/resource/app.ico b/src/lpc_launcher/resource/app.ico
new file mode 100644
index 0000000..e2800ca
Binary files /dev/null and b/src/lpc_launcher/resource/app.ico differ
diff --git a/src/lpc_launcher/resource/app_small.ico b/src/lpc_launcher/resource/app_small.ico
new file mode 100644
index 0000000..2d4c046
Binary files /dev/null and b/src/lpc_launcher/resource/app_small.ico differ
diff --git a/src/lpc_launcher/resource/pres.rc b/src/lpc_launcher/resource/pres.rc
new file mode 100644
index 0000000..5447844
--- /dev/null
+++ b/src/lpc_launcher/resource/pres.rc
@@ -0,0 +1,34 @@
+#include<WINDOWS.H>
+
+BASE_ICON ICON "src/lpc_launcher/resource/app.ico"
+BASE_ICON_SMALL ICON "src/lpc_launcher/resource/app_small.ico"
+
+VS_VERSION_INFO VERSIONINFO
+FILEVERSION 0, 0, 0, 1
+PRODUCTVERSION 0, 0, 0, 2
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "040904E4"
+        BEGIN 
+            VALUE "Comments", "\0"
+            VALUE "CompanyName", "OG:BG\0"
+            VALUE "FileDescription", "PUBG Launcher\0"
+            VALUE "FileVersion", "0.0.0.1\0"
+            VALUE "InternalName", "lpc_launcher.exe\0"
+            VALUE "LegalCopyright", "\xA9 2025 - OG:Battlegrounds \0"
+            VALUE "LegalTrademarks", "\0"
+            VALUE "OriginalFilename", "lpc_launcher.exe\0"
+            VALUE "ProductName", "PUBG Launcher\0"
+            VALUE "ProductVersion", "Dev Version 0.0.0.02\0"
+        END
+    END
+
+    BLOCK "VarFileInfo"
+    BEGIN
+            //VALUE "Translation", 0x409, 1252    // Language English (EUA)
+            //VALUE "Translation", 0x416, 1252    // Idioma português (Brasil)
+            VALUE "Translation", 0x000, 0x04B0      // Local Computer Lang
+    END
+END
+